lcd.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781
  1. /*
  2. * Common LCD routines
  3. *
  4. * (C) Copyright 2001-2002
  5. * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
  6. *
  7. * SPDX-License-Identifier: GPL-2.0+
  8. */
  9. /* #define DEBUG */
  10. #include <config.h>
  11. #include <common.h>
  12. #include <command.h>
  13. #include <env_callback.h>
  14. #include <linux/types.h>
  15. #include <stdio_dev.h>
  16. #include <lcd.h>
  17. #include <mapmem.h>
  18. #include <watchdog.h>
  19. #include <asm/unaligned.h>
  20. #include <splash.h>
  21. #include <asm/io.h>
  22. #include <asm/unaligned.h>
  23. #include <video_font.h>
  24. #ifdef CONFIG_LCD_LOGO
  25. #include <bmp_logo.h>
  26. #include <bmp_logo_data.h>
  27. #if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16)
  28. #error Default Color Map overlaps with Logo Color Map
  29. #endif
  30. #endif
  31. #ifndef CONFIG_LCD_ALIGNMENT
  32. #define CONFIG_LCD_ALIGNMENT PAGE_SIZE
  33. #endif
  34. #if (LCD_BPP != LCD_COLOR8) && (LCD_BPP != LCD_COLOR16) && \
  35. (LCD_BPP != LCD_COLOR32)
  36. #error Unsupported LCD BPP.
  37. #endif
  38. DECLARE_GLOBAL_DATA_PTR;
  39. static int lcd_init(void *lcdbase);
  40. static void lcd_logo(void);
  41. static void lcd_setfgcolor(int color);
  42. static void lcd_setbgcolor(int color);
  43. static int lcd_color_fg;
  44. static int lcd_color_bg;
  45. int lcd_line_length;
  46. char lcd_is_enabled = 0;
  47. static void *lcd_base; /* Start of framebuffer memory */
  48. static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
  49. /* Flush LCD activity to the caches */
  50. void lcd_sync(void)
  51. {
  52. /*
  53. * flush_dcache_range() is declared in common.h but it seems that some
  54. * architectures do not actually implement it. Is there a way to find
  55. * out whether it exists? For now, ARM is safe.
  56. */
  57. #if defined(CONFIG_ARM) && !defined(CONFIG_SYS_DCACHE_OFF)
  58. int line_length;
  59. if (lcd_flush_dcache)
  60. flush_dcache_range((ulong)lcd_base,
  61. (ulong)(lcd_base + lcd_get_size(&line_length)));
  62. #endif
  63. }
  64. void lcd_set_flush_dcache(int flush)
  65. {
  66. lcd_flush_dcache = (flush != 0);
  67. }
  68. static void lcd_stub_putc(struct stdio_dev *dev, const char c)
  69. {
  70. lcd_putc(c);
  71. }
  72. static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
  73. {
  74. lcd_puts(s);
  75. }
  76. /* Small utility to check that you got the colours right */
  77. #ifdef LCD_TEST_PATTERN
  78. #if LCD_BPP == LCD_COLOR8
  79. #define N_BLK_VERT 2
  80. #define N_BLK_HOR 3
  81. static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
  82. CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW,
  83. CONSOLE_COLOR_BLUE, CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN,
  84. }; /*LCD_BPP == LCD_COLOR8 */
  85. #elif LCD_BPP == LCD_COLOR16
  86. #define N_BLK_VERT 2
  87. #define N_BLK_HOR 4
  88. static int test_colors[N_BLK_HOR * N_BLK_VERT] = {
  89. CONSOLE_COLOR_RED, CONSOLE_COLOR_GREEN, CONSOLE_COLOR_YELLOW, CONSOLE_COLOR_BLUE,
  90. CONSOLE_COLOR_MAGENTA, CONSOLE_COLOR_CYAN, CONSOLE_COLOR_GREY, CONSOLE_COLOR_WHITE,
  91. };
  92. #endif /*LCD_BPP == LCD_COLOR16 */
  93. static void test_pattern(void)
  94. {
  95. ushort v_max = panel_info.vl_row;
  96. ushort h_max = panel_info.vl_col;
  97. ushort v_step = (v_max + N_BLK_VERT - 1) / N_BLK_VERT;
  98. ushort h_step = (h_max + N_BLK_HOR - 1) / N_BLK_HOR;
  99. ushort v, h;
  100. #if LCD_BPP == LCD_COLOR8
  101. uchar *pix = (uchar *)lcd_base;
  102. #elif LCD_BPP == LCD_COLOR16
  103. ushort *pix = (ushort *)lcd_base;
  104. #endif
  105. printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
  106. h_max, v_max, h_step, v_step);
  107. for (v = 0; v < v_max; ++v) {
  108. uchar iy = v / v_step;
  109. for (h = 0; h < h_max; ++h) {
  110. uchar ix = N_BLK_HOR * iy + h / h_step;
  111. *pix++ = test_colors[ix];
  112. }
  113. }
  114. }
  115. #endif /* LCD_TEST_PATTERN */
  116. /*
  117. * With most lcd drivers the line length is set up
  118. * by calculating it from panel_info parameters. Some
  119. * drivers need to calculate the line length differently,
  120. * so make the function weak to allow overriding it.
  121. */
  122. __weak int lcd_get_size(int *line_length)
  123. {
  124. *line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
  125. return *line_length * panel_info.vl_row;
  126. }
  127. int drv_lcd_init(void)
  128. {
  129. struct stdio_dev lcddev;
  130. int rc;
  131. lcd_base = map_sysmem(gd->fb_base, 0);
  132. lcd_init(lcd_base);
  133. /* Device initialization */
  134. memset(&lcddev, 0, sizeof(lcddev));
  135. strcpy(lcddev.name, "lcd");
  136. lcddev.ext = 0; /* No extensions */
  137. lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
  138. lcddev.putc = lcd_stub_putc; /* 'putc' function */
  139. lcddev.puts = lcd_stub_puts; /* 'puts' function */
  140. rc = stdio_register(&lcddev);
  141. return (rc == 0) ? 1 : rc;
  142. }
  143. void lcd_clear(void)
  144. {
  145. int bg_color;
  146. char *s;
  147. ulong addr;
  148. static int do_splash = 1;
  149. #if LCD_BPP == LCD_COLOR8
  150. /* Setting the palette */
  151. lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
  152. lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
  153. lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
  154. lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
  155. lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
  156. lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
  157. lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
  158. lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
  159. lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
  160. #endif
  161. #ifndef CONFIG_SYS_WHITE_ON_BLACK
  162. lcd_setfgcolor(CONSOLE_COLOR_BLACK);
  163. lcd_setbgcolor(CONSOLE_COLOR_WHITE);
  164. bg_color = CONSOLE_COLOR_WHITE;
  165. #else
  166. lcd_setfgcolor(CONSOLE_COLOR_WHITE);
  167. lcd_setbgcolor(CONSOLE_COLOR_BLACK);
  168. bg_color = CONSOLE_COLOR_BLACK;
  169. #endif /* CONFIG_SYS_WHITE_ON_BLACK */
  170. #ifdef LCD_TEST_PATTERN
  171. test_pattern();
  172. #else
  173. /* set framebuffer to background color */
  174. #if (LCD_BPP != LCD_COLOR32)
  175. memset((char *)lcd_base, bg_color, lcd_line_length * panel_info.vl_row);
  176. #else
  177. u32 *ppix = lcd_base;
  178. u32 i;
  179. for (i = 0;
  180. i < (lcd_line_length * panel_info.vl_row)/NBYTES(panel_info.vl_bpix);
  181. i++) {
  182. *ppix++ = bg_color;
  183. }
  184. #endif
  185. #endif
  186. /* setup text-console */
  187. debug("[LCD] setting up console...\n");
  188. lcd_init_console(lcd_base,
  189. panel_info.vl_col,
  190. panel_info.vl_row,
  191. panel_info.vl_rot);
  192. /* Paint the logo and retrieve LCD base address */
  193. debug("[LCD] Drawing the logo...\n");
  194. if (do_splash) {
  195. s = getenv("splashimage");
  196. if (s) {
  197. do_splash = 0;
  198. addr = simple_strtoul(s, NULL, 16);
  199. if (lcd_splash(addr) == 0) {
  200. lcd_sync();
  201. return;
  202. }
  203. }
  204. }
  205. lcd_logo();
  206. #if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
  207. addr = (ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length;
  208. lcd_init_console((void *)addr, panel_info.vl_col,
  209. panel_info.vl_row, panel_info.vl_rot);
  210. #endif
  211. lcd_sync();
  212. }
  213. static int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc,
  214. char *const argv[])
  215. {
  216. lcd_clear();
  217. return 0;
  218. }
  219. U_BOOT_CMD(cls, 1, 1, do_lcd_clear, "clear screen", "");
  220. static int lcd_init(void *lcdbase)
  221. {
  222. debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
  223. lcd_ctrl_init(lcdbase);
  224. /*
  225. * lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi) ignores
  226. * the 'lcdbase' argument and uses custom lcd base address
  227. * by setting up gd->fb_base. Check for this condition and fixup
  228. * 'lcd_base' address.
  229. */
  230. if (map_to_sysmem(lcdbase) != gd->fb_base)
  231. lcd_base = map_sysmem(gd->fb_base, 0);
  232. debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
  233. lcd_get_size(&lcd_line_length);
  234. lcd_is_enabled = 1;
  235. lcd_clear();
  236. lcd_enable();
  237. /* Initialize the console */
  238. lcd_set_col(0);
  239. #ifdef CONFIG_LCD_INFO_BELOW_LOGO
  240. lcd_set_row(7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT);
  241. #else
  242. lcd_set_row(1); /* leave 1 blank line below logo */
  243. #endif
  244. return 0;
  245. }
  246. /*
  247. * This is called early in the system initialization to grab memory
  248. * for the LCD controller.
  249. * Returns new address for monitor, after reserving LCD buffer memory
  250. *
  251. * Note that this is running from ROM, so no write access to global data.
  252. */
  253. ulong lcd_setmem(ulong addr)
  254. {
  255. ulong size;
  256. int line_length;
  257. debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
  258. panel_info.vl_row, NBITS(panel_info.vl_bpix));
  259. size = lcd_get_size(&line_length);
  260. /* Round up to nearest full page, or MMU section if defined */
  261. size = ALIGN(size, CONFIG_LCD_ALIGNMENT);
  262. addr = ALIGN(addr - CONFIG_LCD_ALIGNMENT + 1, CONFIG_LCD_ALIGNMENT);
  263. /* Allocate pages for the frame buffer. */
  264. addr -= size;
  265. debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
  266. size >> 10, addr);
  267. return addr;
  268. }
  269. static void lcd_setfgcolor(int color)
  270. {
  271. lcd_color_fg = color;
  272. }
  273. int lcd_getfgcolor(void)
  274. {
  275. return lcd_color_fg;
  276. }
  277. static void lcd_setbgcolor(int color)
  278. {
  279. lcd_color_bg = color;
  280. }
  281. int lcd_getbgcolor(void)
  282. {
  283. return lcd_color_bg;
  284. }
  285. #ifdef CONFIG_LCD_LOGO
  286. __weak void lcd_logo_set_cmap(void)
  287. {
  288. int i;
  289. ushort *cmap = configuration_get_cmap();
  290. for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i)
  291. *cmap++ = bmp_logo_palette[i];
  292. }
  293. void lcd_logo_plot(int x, int y)
  294. {
  295. ushort i, j;
  296. uchar *bmap = &bmp_logo_bitmap[0];
  297. unsigned bpix = NBITS(panel_info.vl_bpix);
  298. uchar *fb = (uchar *)(lcd_base + y * lcd_line_length + x * bpix / 8);
  299. ushort *fb16;
  300. debug("Logo: width %d height %d colors %d\n",
  301. BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS);
  302. if (bpix < 12) {
  303. WATCHDOG_RESET();
  304. lcd_logo_set_cmap();
  305. WATCHDOG_RESET();
  306. for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
  307. memcpy(fb, bmap, BMP_LOGO_WIDTH);
  308. bmap += BMP_LOGO_WIDTH;
  309. fb += panel_info.vl_col;
  310. }
  311. }
  312. else { /* true color mode */
  313. u16 col16;
  314. fb16 = (ushort *)fb;
  315. for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
  316. for (j = 0; j < BMP_LOGO_WIDTH; j++) {
  317. col16 = bmp_logo_palette[(bmap[j]-16)];
  318. fb16[j] =
  319. ((col16 & 0x000F) << 1) |
  320. ((col16 & 0x00F0) << 3) |
  321. ((col16 & 0x0F00) << 4);
  322. }
  323. bmap += BMP_LOGO_WIDTH;
  324. fb16 += panel_info.vl_col;
  325. }
  326. }
  327. WATCHDOG_RESET();
  328. lcd_sync();
  329. }
  330. #else
  331. static inline void lcd_logo_plot(int x, int y) {}
  332. #endif /* CONFIG_LCD_LOGO */
  333. #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
  334. #ifdef CONFIG_SPLASH_SCREEN_ALIGN
  335. #define BMP_ALIGN_CENTER 0x7FFF
  336. static void splash_align_axis(int *axis, unsigned long panel_size,
  337. unsigned long picture_size)
  338. {
  339. unsigned long panel_picture_delta = panel_size - picture_size;
  340. unsigned long axis_alignment;
  341. if (*axis == BMP_ALIGN_CENTER)
  342. axis_alignment = panel_picture_delta / 2;
  343. else if (*axis < 0)
  344. axis_alignment = panel_picture_delta + *axis + 1;
  345. else
  346. return;
  347. *axis = max(0, (int)axis_alignment);
  348. }
  349. #endif
  350. #ifdef CONFIG_LCD_BMP_RLE8
  351. #define BMP_RLE8_ESCAPE 0
  352. #define BMP_RLE8_EOL 0
  353. #define BMP_RLE8_EOBMP 1
  354. #define BMP_RLE8_DELTA 2
  355. static void draw_unencoded_bitmap(ushort **fbp, uchar *bmap, ushort *cmap,
  356. int cnt)
  357. {
  358. while (cnt > 0) {
  359. *(*fbp)++ = cmap[*bmap++];
  360. cnt--;
  361. }
  362. }
  363. static void draw_encoded_bitmap(ushort **fbp, ushort c, int cnt)
  364. {
  365. ushort *fb = *fbp;
  366. int cnt_8copy = cnt >> 3;
  367. cnt -= cnt_8copy << 3;
  368. while (cnt_8copy > 0) {
  369. *fb++ = c;
  370. *fb++ = c;
  371. *fb++ = c;
  372. *fb++ = c;
  373. *fb++ = c;
  374. *fb++ = c;
  375. *fb++ = c;
  376. *fb++ = c;
  377. cnt_8copy--;
  378. }
  379. while (cnt > 0) {
  380. *fb++ = c;
  381. cnt--;
  382. }
  383. *fbp = fb;
  384. }
  385. /*
  386. * Do not call this function directly, must be called from lcd_display_bitmap.
  387. */
  388. static void lcd_display_rle8_bitmap(struct bmp_image *bmp, ushort *cmap,
  389. uchar *fb, int x_off, int y_off)
  390. {
  391. uchar *bmap;
  392. ulong width, height;
  393. ulong cnt, runlen;
  394. int x, y;
  395. int decode = 1;
  396. width = get_unaligned_le32(&bmp->header.width);
  397. height = get_unaligned_le32(&bmp->header.height);
  398. bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
  399. x = 0;
  400. y = height - 1;
  401. while (decode) {
  402. if (bmap[0] == BMP_RLE8_ESCAPE) {
  403. switch (bmap[1]) {
  404. case BMP_RLE8_EOL:
  405. /* end of line */
  406. bmap += 2;
  407. x = 0;
  408. y--;
  409. /* 16bpix, 2-byte per pixel, width should *2 */
  410. fb -= (width * 2 + lcd_line_length);
  411. break;
  412. case BMP_RLE8_EOBMP:
  413. /* end of bitmap */
  414. decode = 0;
  415. break;
  416. case BMP_RLE8_DELTA:
  417. /* delta run */
  418. x += bmap[2];
  419. y -= bmap[3];
  420. /* 16bpix, 2-byte per pixel, x should *2 */
  421. fb = (uchar *) (lcd_base + (y + y_off - 1)
  422. * lcd_line_length + (x + x_off) * 2);
  423. bmap += 4;
  424. break;
  425. default:
  426. /* unencoded run */
  427. runlen = bmap[1];
  428. bmap += 2;
  429. if (y < height) {
  430. if (x < width) {
  431. if (x + runlen > width)
  432. cnt = width - x;
  433. else
  434. cnt = runlen;
  435. draw_unencoded_bitmap(
  436. (ushort **)&fb,
  437. bmap, cmap, cnt);
  438. }
  439. x += runlen;
  440. }
  441. bmap += runlen;
  442. if (runlen & 1)
  443. bmap++;
  444. }
  445. } else {
  446. /* encoded run */
  447. if (y < height) {
  448. runlen = bmap[0];
  449. if (x < width) {
  450. /* aggregate the same code */
  451. while (bmap[0] == 0xff &&
  452. bmap[2] != BMP_RLE8_ESCAPE &&
  453. bmap[1] == bmap[3]) {
  454. runlen += bmap[2];
  455. bmap += 2;
  456. }
  457. if (x + runlen > width)
  458. cnt = width - x;
  459. else
  460. cnt = runlen;
  461. draw_encoded_bitmap((ushort **)&fb,
  462. cmap[bmap[1]], cnt);
  463. }
  464. x += runlen;
  465. }
  466. bmap += 2;
  467. }
  468. }
  469. }
  470. #endif
  471. __weak void fb_put_byte(uchar **fb, uchar **from)
  472. {
  473. *(*fb)++ = *(*from)++;
  474. }
  475. #if defined(CONFIG_BMP_16BPP)
  476. __weak void fb_put_word(uchar **fb, uchar **from)
  477. {
  478. *(*fb)++ = *(*from)++;
  479. *(*fb)++ = *(*from)++;
  480. }
  481. #endif /* CONFIG_BMP_16BPP */
  482. __weak void lcd_set_cmap(struct bmp_image *bmp, unsigned colors)
  483. {
  484. int i;
  485. struct bmp_color_table_entry cte;
  486. ushort *cmap = configuration_get_cmap();
  487. for (i = 0; i < colors; ++i) {
  488. cte = bmp->color_table[i];
  489. *cmap = (((cte.red) << 8) & 0xf800) |
  490. (((cte.green) << 3) & 0x07e0) |
  491. (((cte.blue) >> 3) & 0x001f);
  492. cmap++;
  493. }
  494. }
  495. int lcd_display_bitmap(ulong bmp_image, int x, int y)
  496. {
  497. ushort *cmap_base = NULL;
  498. ushort i, j;
  499. uchar *fb;
  500. struct bmp_image *bmp = (struct bmp_image *)map_sysmem(bmp_image, 0);
  501. uchar *bmap;
  502. ushort padded_width;
  503. unsigned long width, height, byte_width;
  504. unsigned long pwidth = panel_info.vl_col;
  505. unsigned colors, bpix, bmp_bpix;
  506. int hdr_size;
  507. struct bmp_color_table_entry *palette = bmp->color_table;
  508. if (!bmp || !(bmp->header.signature[0] == 'B' &&
  509. bmp->header.signature[1] == 'M')) {
  510. printf("Error: no valid bmp image at %lx\n", bmp_image);
  511. return 1;
  512. }
  513. width = get_unaligned_le32(&bmp->header.width);
  514. height = get_unaligned_le32(&bmp->header.height);
  515. bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
  516. hdr_size = get_unaligned_le16(&bmp->header.size);
  517. debug("hdr_size=%d, bmp_bpix=%d\n", hdr_size, bmp_bpix);
  518. colors = 1 << bmp_bpix;
  519. bpix = NBITS(panel_info.vl_bpix);
  520. if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
  521. printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
  522. bpix, bmp_bpix);
  523. return 1;
  524. }
  525. /*
  526. * We support displaying 8bpp BMPs on 16bpp LCDs
  527. * and displaying 24bpp BMPs on 32bpp LCDs
  528. * */
  529. if (bpix != bmp_bpix &&
  530. !(bmp_bpix == 8 && bpix == 16) &&
  531. !(bmp_bpix == 24 && bpix == 32)) {
  532. printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
  533. bpix, get_unaligned_le16(&bmp->header.bit_count));
  534. return 1;
  535. }
  536. debug("Display-bmp: %d x %d with %d colors, display %d\n",
  537. (int)width, (int)height, (int)colors, 1 << bpix);
  538. if (bmp_bpix == 8)
  539. lcd_set_cmap(bmp, colors);
  540. padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
  541. #ifdef CONFIG_SPLASH_SCREEN_ALIGN
  542. splash_align_axis(&x, pwidth, width);
  543. splash_align_axis(&y, panel_info.vl_row, height);
  544. #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
  545. if ((x + width) > pwidth)
  546. width = pwidth - x;
  547. if ((y + height) > panel_info.vl_row)
  548. height = panel_info.vl_row - y;
  549. bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
  550. fb = (uchar *)(lcd_base +
  551. (y + height - 1) * lcd_line_length + x * bpix / 8);
  552. switch (bmp_bpix) {
  553. case 1:
  554. case 8: {
  555. cmap_base = configuration_get_cmap();
  556. #ifdef CONFIG_LCD_BMP_RLE8
  557. u32 compression = get_unaligned_le32(&bmp->header.compression);
  558. debug("compressed %d %d\n", compression, BMP_BI_RLE8);
  559. if (compression == BMP_BI_RLE8) {
  560. if (bpix != 16) {
  561. /* TODO implement render code for bpix != 16 */
  562. printf("Error: only support 16 bpix");
  563. return 1;
  564. }
  565. lcd_display_rle8_bitmap(bmp, cmap_base, fb, x, y);
  566. break;
  567. }
  568. #endif
  569. if (bpix != 16)
  570. byte_width = width;
  571. else
  572. byte_width = width * 2;
  573. for (i = 0; i < height; ++i) {
  574. WATCHDOG_RESET();
  575. for (j = 0; j < width; j++) {
  576. if (bpix != 16) {
  577. fb_put_byte(&fb, &bmap);
  578. } else {
  579. struct bmp_color_table_entry *entry;
  580. uint val;
  581. if (cmap_base) {
  582. val = cmap_base[*bmap];
  583. } else {
  584. entry = &palette[*bmap];
  585. val = entry->blue >> 3 |
  586. entry->green >> 2 << 5 |
  587. entry->red >> 3 << 11;
  588. }
  589. *(uint16_t *)fb = val;
  590. bmap++;
  591. fb += sizeof(uint16_t) / sizeof(*fb);
  592. }
  593. }
  594. bmap += (padded_width - width);
  595. fb -= byte_width + lcd_line_length;
  596. }
  597. break;
  598. }
  599. #if defined(CONFIG_BMP_16BPP)
  600. case 16:
  601. for (i = 0; i < height; ++i) {
  602. WATCHDOG_RESET();
  603. for (j = 0; j < width; j++)
  604. fb_put_word(&fb, &bmap);
  605. bmap += (padded_width - width) * 2;
  606. fb -= width * 2 + lcd_line_length;
  607. }
  608. break;
  609. #endif /* CONFIG_BMP_16BPP */
  610. #if defined(CONFIG_BMP_24BPP)
  611. case 24:
  612. for (i = 0; i < height; ++i) {
  613. for (j = 0; j < width; j++) {
  614. *(fb++) = *(bmap++);
  615. *(fb++) = *(bmap++);
  616. *(fb++) = *(bmap++);
  617. *(fb++) = 0;
  618. }
  619. fb -= lcd_line_length + width * (bpix / 8);
  620. }
  621. break;
  622. #endif /* CONFIG_BMP_24BPP */
  623. #if defined(CONFIG_BMP_32BPP)
  624. case 32:
  625. for (i = 0; i < height; ++i) {
  626. for (j = 0; j < width; j++) {
  627. *(fb++) = *(bmap++);
  628. *(fb++) = *(bmap++);
  629. *(fb++) = *(bmap++);
  630. *(fb++) = *(bmap++);
  631. }
  632. fb -= lcd_line_length + width * (bpix / 8);
  633. }
  634. break;
  635. #endif /* CONFIG_BMP_32BPP */
  636. default:
  637. break;
  638. };
  639. lcd_sync();
  640. return 0;
  641. }
  642. #endif
  643. static void lcd_logo(void)
  644. {
  645. lcd_logo_plot(0, 0);
  646. #ifdef CONFIG_LCD_INFO
  647. lcd_set_col(LCD_INFO_X / VIDEO_FONT_WIDTH);
  648. lcd_set_row(LCD_INFO_Y / VIDEO_FONT_HEIGHT);
  649. lcd_show_board_info();
  650. #endif /* CONFIG_LCD_INFO */
  651. }
  652. #ifdef CONFIG_SPLASHIMAGE_GUARD
  653. static int on_splashimage(const char *name, const char *value, enum env_op op,
  654. int flags)
  655. {
  656. ulong addr;
  657. int aligned;
  658. if (op == env_op_delete)
  659. return 0;
  660. addr = simple_strtoul(value, NULL, 16);
  661. /* See README.displaying-bmps */
  662. aligned = (addr % 4 == 2);
  663. if (!aligned) {
  664. printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
  665. return -1;
  666. }
  667. return 0;
  668. }
  669. U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
  670. #endif
  671. int lcd_get_pixel_width(void)
  672. {
  673. return panel_info.vl_col;
  674. }
  675. int lcd_get_pixel_height(void)
  676. {
  677. return panel_info.vl_row;
  678. }