lcd.c 22 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
/*
 * Common LCD routines for supported CPUs
 *
 * (C) Copyright 2001-2002
 * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

/************************************************************************/
/* ** HEADER FILES							*/
/************************************************************************/

/* #define DEBUG */

#include <config.h>
#include <common.h>
#include <command.h>
#include <stdarg.h>
#include <linux/types.h>
37
#include <stdio_dev.h>
38
39
40
41
#if defined(CONFIG_POST)
#include <post.h>
#endif
#include <lcd.h>
wdenk's avatar
wdenk committed
42
#include <watchdog.h>
43

44
45
46
#if defined(CONFIG_CPU_PXA25X) || defined(CONFIG_CPU_PXA27X) || \
	defined(CONFIG_CPU_MONAHANS)
#define CONFIG_CPU_PXA
47
48
49
50
51
52
53
#include <asm/byteorder.h>
#endif

#if defined(CONFIG_MPC823)
#include <lcdvideo.h>
#endif

Stelian Pop's avatar
Stelian Pop committed
54
55
56
57
#if defined(CONFIG_ATMEL_LCD)
#include <atmel_lcdc.h>
#endif

58
59
60
61
/************************************************************************/
/* ** FONT DATA								*/
/************************************************************************/
#include <video_font.h>		/* Get font data, width and height	*/
62
#include <video_font_data.h>
63

wdenk's avatar
wdenk committed
64
65
66
67
68
/************************************************************************/
/* ** LOGO DATA								*/
/************************************************************************/
#ifdef CONFIG_LCD_LOGO
# include <bmp_logo.h>		/* Get logo data, width and height	*/
69
# include <bmp_logo_data.h>
Alessandro Rubini's avatar
Alessandro Rubini committed
70
# if (CONSOLE_COLOR_WHITE >= BMP_LOGO_OFFSET) && (LCD_BPP != LCD_COLOR16)
wdenk's avatar
wdenk committed
71
72
73
#  error Default Color Map overlaps with Logo Color Map
# endif
#endif
74

75
76
77
78
#ifndef CONFIG_LCD_ALIGNMENT
#define CONFIG_LCD_ALIGNMENT PAGE_SIZE
#endif

79
80
DECLARE_GLOBAL_DATA_PTR;

81
82
ulong lcd_setmem (ulong addr);

83
84
85
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);
86

87
static int lcd_init(void *lcdbase);
88
89
90

static void *lcd_logo (void);

91
92
93
static int lcd_getbgcolor(void);
static void lcd_setfgcolor(int color);
static void lcd_setbgcolor(int color);
94
95
96
97

char lcd_is_enabled = 0;

#ifdef	NOT_USED_SO_FAR
98
static void lcd_getcolreg(ushort regno,
99
				ushort *red, ushort *green, ushort *blue);
100
static int lcd_getfgcolor(void);
101
102
103
104
105
106
#endif	/* NOT_USED_SO_FAR */

/************************************************************************/

/*----------------------------------------------------------------------*/

107
static void console_scrollup(void)
108
109
{
	/* Copy up rows ignoring the first one */
110
	memcpy(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, CONSOLE_SCROLL_SIZE);
111
112

	/* Clear the last one */
113
	memset(CONSOLE_ROW_LAST, COLOR_MASK(lcd_color_bg), CONSOLE_ROW_SIZE);
114
115
116
117
}

/*----------------------------------------------------------------------*/

118
static inline void console_back(void)
119
120
121
122
123
124
125
126
{
	if (--console_col < 0) {
		console_col = CONSOLE_COLS-1 ;
		if (--console_row < 0) {
			console_row = 0;
		}
	}

127
128
	lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
		console_row * VIDEO_FONT_HEIGHT, ' ');
129
130
131
132
}

/*----------------------------------------------------------------------*/

133
static inline void console_newline(void)
134
135
136
137
138
139
140
{
	++console_row;
	console_col = 0;

	/* Check if we need to scroll the terminal */
	if (console_row >= CONSOLE_ROWS) {
		/* Scroll everything up */
141
		console_scrollup();
142
143
144
145
146
147
		--console_row;
	}
}

/*----------------------------------------------------------------------*/

148
void lcd_putc(const char c)
149
150
151
{
	if (!lcd_is_enabled) {
		serial_putc(c);
152

153
154
155
156
		return;
	}

	switch (c) {
157
158
	case '\r':
		console_col = 0;
159

160
161
162
		return;
	case '\n':
		console_newline();
163

164
		return;
165
	case '\t':	/* Tab (8 chars alignment) */
166
167
		console_col +=  8;
		console_col &= ~7;
168

169
170
		if (console_col >= CONSOLE_COLS)
			console_newline();
171

172
173
174
		return;
	case '\b':
		console_back();
175

176
177
178
179
180
181
		return;
	default:
		lcd_putc_xy(console_col * VIDEO_FONT_WIDTH,
			console_row * VIDEO_FONT_HEIGHT, c);
		if (++console_col >= CONSOLE_COLS)
			console_newline();
182
183
184
185
186
	}
}

/*----------------------------------------------------------------------*/

187
void lcd_puts(const char *s)
188
189
{
	if (!lcd_is_enabled) {
190
191
		serial_puts(s);

192
193
194
195
		return;
	}

	while (*s) {
196
		lcd_putc(*s++);
197
198
199
	}
}

200
201
202
203
204
205
206
207
208
209
210
211
212
213
/*----------------------------------------------------------------------*/

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);
}

214
215
216
217
/************************************************************************/
/* ** Low-Level Graphics Routines					*/
/************************************************************************/

218
static void lcd_drawchars(ushort x, ushort y, uchar *str, int count)
219
220
{
	uchar *dest;
Marek Vasut's avatar
Marek Vasut committed
221
222
	ushort row;

223
224
225
226
#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
	y += BMP_LOGO_HEIGHT;
#endif

Marek Vasut's avatar
Marek Vasut committed
227
228
229
#if LCD_BPP == LCD_MONOCHROME
	ushort off  = x * (1 << LCD_BPP) % 8;
#endif
230
231
232

	dest = (uchar *)(lcd_base + y * lcd_line_length + x * (1 << LCD_BPP) / 8);

233
	for (row = 0; row < VIDEO_FONT_HEIGHT; ++row, dest += lcd_line_length) {
234
235
		uchar *s = str;
		int i;
Alessandro Rubini's avatar
Alessandro Rubini committed
236
237
238
239
240
#if LCD_BPP == LCD_COLOR16
		ushort *d = (ushort *)dest;
#else
		uchar *d = dest;
#endif
241
242
243
244
245

#if LCD_BPP == LCD_MONOCHROME
		uchar rest = *d & -(1 << (8-off));
		uchar sym;
#endif
246
		for (i = 0; i < count; ++i) {
247
248
249
250
251
252
253
			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) |
254
				(COLOR_MASK(lcd_color_bg) & ~bits);
255
256
257
258

			*d++ = rest | (sym >> off);
			rest = sym << (8-off);
#elif LCD_BPP == LCD_COLOR8
259
			for (c = 0; c < 8; ++c) {
260
261
262
263
264
				*d++ = (bits & 0x80) ?
						lcd_color_fg : lcd_color_bg;
				bits <<= 1;
			}
#elif LCD_BPP == LCD_COLOR16
265
			for (c = 0; c < 8; ++c) {
266
267
268
269
270
271
272
273
274
275
276
277
278
279
				*d++ = (bits & 0x80) ?
						lcd_color_fg : lcd_color_bg;
				bits <<= 1;
			}
#endif
		}
#if LCD_BPP == LCD_MONOCHROME
		*d  = rest | (*d & ((1 << (8-off)) - 1));
#endif
	}
}

/*----------------------------------------------------------------------*/

280
static inline void lcd_puts_xy(ushort x, ushort y, uchar *s)
281
{
282
	lcd_drawchars(x, y, s, strlen((char *)s));
283
284
285
286
}

/*----------------------------------------------------------------------*/

287
static inline void lcd_putc_xy(ushort x, ushort y, uchar c)
288
{
289
	lcd_drawchars(x, y, &c, 1);
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
}

/************************************************************************/
/**  Small utility to check that you got the colours right		*/
/************************************************************************/
#ifdef LCD_TEST_PATTERN

#define	N_BLK_VERT	2
#define	N_BLK_HOR	3

static int test_colors[N_BLK_HOR*N_BLK_VERT] = {
	CONSOLE_COLOR_RED,	CONSOLE_COLOR_GREEN,	CONSOLE_COLOR_YELLOW,
	CONSOLE_COLOR_BLUE,	CONSOLE_COLOR_MAGENTA,	CONSOLE_COLOR_CYAN,
};

305
static void test_pattern(void)
306
307
308
309
310
311
312
313
{
	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;

314
	printf("[LCD] Test Pattern: %d x %d [%d x %d]\n",
315
316
317
		h_max, v_max, h_step, v_step);

	/* WARNING: Code silently assumes 8bit/pixel */
318
	for (v = 0; v < v_max; ++v) {
319
		uchar iy = v / v_step;
320
		for (h = 0; h < h_max; ++h) {
321
322
323
324
325
326
327
328
329
330
331
332
			uchar ix = N_BLK_HOR * iy + (h/h_step);
			*pix++ = test_colors[ix];
		}
	}
}
#endif /* LCD_TEST_PATTERN */


/************************************************************************/
/* ** GENERIC Initialization Routines					*/
/************************************************************************/

333
334
335
336
337
338
int lcd_get_size(int *line_length)
{
	*line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
	return *line_length * panel_info.vl_row;
}

339
340
int drv_lcd_init (void)
{
341
	struct stdio_dev lcddev;
342
343
344
345
	int rc;

	lcd_base = (void *)(gd->fb_base);

346
	lcd_get_size(&lcd_line_length);
347

348
	lcd_init(lcd_base);		/* LCD initialization */
349
350

	/* Device initialization */
351
	memset(&lcddev, 0, sizeof(lcddev));
352

353
	strcpy(lcddev.name, "lcd");
354
355
356
357
358
	lcddev.ext   = 0;			/* No extensions */
	lcddev.flags = DEV_FLAGS_OUTPUT;	/* Output only */
	lcddev.putc  = lcd_putc;		/* 'putc' function */
	lcddev.puts  = lcd_puts;		/* 'puts' function */

359
	rc = stdio_register (&lcddev);
360
361
362
363
364

	return (rc == 0) ? 1 : rc;
}

/*----------------------------------------------------------------------*/
365
366
367
368
369
370
371
372
static
int do_lcd_clear(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
	lcd_clear();
	return 0;
}

void lcd_clear(void)
373
374
375
376
377
378
379
{
#if LCD_BPP == LCD_MONOCHROME
	/* Setting the palette */
	lcd_initcolregs();

#elif LCD_BPP == LCD_COLOR8
	/* Setting the palette */
380
381
382
383
384
385
386
387
388
	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);
389
390
#endif

391
#ifndef CONFIG_SYS_WHITE_ON_BLACK
392
393
	lcd_setfgcolor(CONSOLE_COLOR_BLACK);
	lcd_setbgcolor(CONSOLE_COLOR_WHITE);
394
#else
395
396
	lcd_setfgcolor(CONSOLE_COLOR_WHITE);
	lcd_setbgcolor(CONSOLE_COLOR_BLACK);
397
#endif	/* CONFIG_SYS_WHITE_ON_BLACK */
398
399
400
401
402

#ifdef	LCD_TEST_PATTERN
	test_pattern();
#else
	/* set framebuffer to background color */
403
	memset((char *)lcd_base,
404
405
406
407
		COLOR_MASK(lcd_getbgcolor()),
		lcd_line_length*panel_info.vl_row);
#endif
	/* Paint the logo and retrieve LCD base address */
408
	debug("[LCD] Drawing the logo...\n");
409
410
411
412
413
414
415
	lcd_console_address = lcd_logo ();

	console_col = 0;
	console_row = 0;
}

U_BOOT_CMD(
416
	cls,	1,	1,	do_lcd_clear,
Peter Tyser's avatar
Peter Tyser committed
417
	"clear screen",
Wolfgang Denk's avatar
Wolfgang Denk committed
418
	""
419
420
421
422
);

/*----------------------------------------------------------------------*/

423
static int lcd_init(void *lcdbase)
424
425
{
	/* Initialize the lcd controller */
426
	debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
427

428
	lcd_ctrl_init(lcdbase);
429
	lcd_is_enabled = 1;
430
	lcd_clear();
431
432
433
434
	lcd_enable ();

	/* Initialize the console */
	console_col = 0;
wdenk's avatar
wdenk committed
435
#ifdef CONFIG_LCD_INFO_BELOW_LOGO
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
	console_row = 7 + BMP_LOGO_HEIGHT / VIDEO_FONT_HEIGHT;
#else
	console_row = 1;	/* leave 1 blank line below logo */
#endif

	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.
 */
455
ulong lcd_setmem(ulong addr)
456
457
{
	ulong size;
458
	int line_length;
459

460
461
	debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
		panel_info.vl_row, NBITS(panel_info.vl_bpix));
462

463
	size = lcd_get_size(&line_length);
464

465
466
467
	/* 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);
468
469
470
471

	/* Allocate pages for the frame buffer. */
	addr -= size;

472
	debug("Reserving %ldk for LCD Framebuffer at: %08lx\n", size>>10, addr);
473

474
	return addr;
475
476
477
478
}

/*----------------------------------------------------------------------*/

479
static void lcd_setfgcolor(int color)
480
{
Stelian Pop's avatar
Stelian Pop committed
481
	lcd_color_fg = color;
482
483
484
485
}

/*----------------------------------------------------------------------*/

486
static void lcd_setbgcolor(int color)
487
{
Stelian Pop's avatar
Stelian Pop committed
488
	lcd_color_bg = color;
489
490
491
492
493
}

/*----------------------------------------------------------------------*/

#ifdef	NOT_USED_SO_FAR
494
static int lcd_getfgcolor(void)
495
496
497
498
499
500
501
{
	return lcd_color_fg;
}
#endif	/* NOT_USED_SO_FAR */

/*----------------------------------------------------------------------*/

502
static int lcd_getbgcolor(void)
503
504
505
506
507
508
509
510
511
{
	return lcd_color_bg;
}

/*----------------------------------------------------------------------*/

/************************************************************************/
/* ** Chipset depending Bitmap / Logo stuff...                          */
/************************************************************************/
512
513
514
515
516
517
518
519
520
521
522
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));
523
524
#elif !defined(CONFIG_ATMEL_HLCD) && !defined(CONFIG_EXYNOS_FB)
	return panel_info.cmap;
525
#else
526
527
528
529
530
#if defined(CONFIG_LCD_LOGO)
	return bmp_logo_palette;
#else
	return NULL;
#endif
531
532
533
#endif
}

534
#ifdef CONFIG_LCD_LOGO
535
void bitmap_plot(int x, int y)
536
{
Stelian Pop's avatar
Stelian Pop committed
537
#ifdef CONFIG_ATMEL_LCD
538
	uint *cmap = (uint *)bmp_logo_palette;
Stelian Pop's avatar
Stelian Pop committed
539
#else
540
	ushort *cmap = (ushort *)bmp_logo_palette;
Stelian Pop's avatar
Stelian Pop committed
541
#endif
542
543
544
545
	ushort i, j;
	uchar *bmap;
	uchar *fb;
	ushort *fb16;
546
547
548
#if defined(CONFIG_MPC823)
	immap_t *immr = (immap_t *) CONFIG_SYS_IMMR;
	cpm8xx_t *cp = &(immr->im_cpm);
549
550
#endif

551
	debug("Logo: width %d  height %d  colors %d  cmap %d\n",
552
		BMP_LOGO_WIDTH, BMP_LOGO_HEIGHT, BMP_LOGO_COLORS,
553
		ARRAY_SIZE(bmp_logo_palette));
554
555

	bmap = &bmp_logo_bitmap[0];
Wolfgang Denk's avatar
Wolfgang Denk committed
556
	fb   = (uchar *)(lcd_base + y * lcd_line_length + x);
557
558

	if (NBITS(panel_info.vl_bpix) < 12) {
559
560
561
562
563
564
		/* 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)
565
		cmap = (ushort *) &(cp->lcd_cmap[BMP_LOGO_OFFSET * sizeof(ushort)]);
Stelian Pop's avatar
Stelian Pop committed
566
#elif defined(CONFIG_ATMEL_LCD)
567
		cmap = (uint *)configuration_get_cmap();
Alessandro Rubini's avatar
Alessandro Rubini committed
568
#else
569
		cmap = configuration_get_cmap();
570
571
572
573
574
#endif

		WATCHDOG_RESET();

		/* Set color map */
575
		for (i = 0; i < ARRAY_SIZE(bmp_logo_palette); ++i) {
576
			ushort colreg = bmp_logo_palette[i];
Stelian Pop's avatar
Stelian Pop committed
577
578
579
580
#ifdef CONFIG_ATMEL_LCD
			uint lut_entry;
#ifdef CONFIG_ATMEL_LCD_BGR555
			lut_entry = ((colreg & 0x000F) << 11) |
581
582
					((colreg & 0x00F0) <<  2) |
					((colreg & 0x0F00) >>  7);
Stelian Pop's avatar
Stelian Pop committed
583
584
#else /* CONFIG_ATMEL_LCD_RGB565 */
			lut_entry = ((colreg & 0x000F) << 1) |
585
586
					((colreg & 0x00F0) << 3) |
					((colreg & 0x0F00) << 4);
Stelian Pop's avatar
Stelian Pop committed
587
588
589
590
#endif
			*(cmap + BMP_LOGO_OFFSET) = lut_entry;
			cmap++;
#else /* !CONFIG_ATMEL_LCD */
591
#ifdef  CONFIG_SYS_INVERT_COLORS
592
593
594
595
			*cmap++ = 0xffff - colreg;
#else
			*cmap++ = colreg;
#endif
Stelian Pop's avatar
Stelian Pop committed
596
#endif /* CONFIG_ATMEL_LCD */
597
598
599
600
		}

		WATCHDOG_RESET();

601
602
		for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
			memcpy(fb, bmap, BMP_LOGO_WIDTH);
603
604
605
606
607
			bmap += BMP_LOGO_WIDTH;
			fb   += panel_info.vl_col;
		}
	}
	else { /* true color mode */
Alessandro Rubini's avatar
Alessandro Rubini committed
608
		u16 col16;
609
		fb16 = (ushort *)(lcd_base + y * lcd_line_length + x);
610
611
		for (i = 0; i < BMP_LOGO_HEIGHT; ++i) {
			for (j = 0; j < BMP_LOGO_WIDTH; j++) {
Alessandro Rubini's avatar
Alessandro Rubini committed
612
613
614
615
616
				col16 = bmp_logo_palette[(bmap[j]-16)];
				fb16[j] =
					((col16 & 0x000F) << 1) |
					((col16 & 0x00F0) << 3) |
					((col16 & 0x0F00) << 4);
617
618
619
620
621
622
623
624
				}
			bmap += BMP_LOGO_WIDTH;
			fb16 += panel_info.vl_col;
		}
	}

	WATCHDOG_RESET();
}
625
626
#else
static inline void bitmap_plot(int x, int y) {}
627
628
629
#endif /* CONFIG_LCD_LOGO */

/*----------------------------------------------------------------------*/
630
#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
631
632
633
634
/*
 * Display the BMP file located at address bmp_image.
 * Only uncompressed.
 */
635
636
637

#ifdef CONFIG_SPLASH_SCREEN_ALIGN
#define BMP_ALIGN_CENTER	0x7FFF
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653

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);
}
654
655
#endif

656
#if defined(CONFIG_MPC823) || defined(CONFIG_MCC200)
657
#define FB_PUT_BYTE(fb, from) *(fb)++ = (255 - *(from)++)
658
659
#else
#define FB_PUT_BYTE(fb, from) *(fb)++ = *(from)++
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
#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 */

679
680
int lcd_display_bitmap(ulong bmp_image, int x, int y)
{
681
682
683
684
#if !defined(CONFIG_MCC200)
	ushort *cmap = NULL;
#endif
	ushort *cmap_base = NULL;
685
686
687
688
689
	ushort i, j;
	uchar *fb;
	bmp_image_t *bmp=(bmp_image_t *)bmp_image;
	uchar *bmap;
	ushort padded_line;
690
	unsigned long width, height, byte_width;
691
	unsigned long pwidth = panel_info.vl_col;
692
	unsigned colors, bpix, bmp_bpix;
693

694
	if (!bmp || !((bmp->header.signature[0] == 'B') &&
695
696
697
		(bmp->header.signature[1] == 'M'))) {
		printf("Error: no valid bmp image at %lx\n", bmp_image);

698
		return 1;
699
	}
700

701
702
	width = le32_to_cpu(bmp->header.width);
	height = le32_to_cpu(bmp->header.height);
703
704
	bmp_bpix = le16_to_cpu(bmp->header.bit_count);
	colors = 1 << bmp_bpix;
705
706
707

	bpix = NBITS(panel_info.vl_bpix);

708
	if ((bpix != 1) && (bpix != 8) && (bpix != 16) && (bpix != 32)) {
709
710
		printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
			bpix, bmp_bpix);
711

712
713
714
		return 1;
	}

715
	/* We support displaying 8bpp BMPs on 16bpp LCDs */
716
	if (bpix != bmp_bpix && (bmp_bpix != 8 || bpix != 16 || bpix != 32)) {
717
718
719
		printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
			bpix,
			le16_to_cpu(bmp->header.bit_count));
720

721
722
723
		return 1;
	}

724
	debug("Display-bmp: %d x %d  with %d colors\n",
725
726
		(int)width, (int)height, (int)colors);

727
728
#if !defined(CONFIG_MCC200)
	/* MCC200 LCD doesn't need CMAP, supports 1bpp b&w only */
729
	if (bmp_bpix == 8) {
730
		cmap = configuration_get_cmap();
731
732
		cmap_base = cmap;

733
		/* Set color map */
734
		for (i = 0; i < colors; ++i) {
735
			bmp_color_table_entry_t cte = bmp->color_table[i];
736
#if !defined(CONFIG_ATMEL_LCD)
737
738
			ushort colreg =
				( ((cte.red)   << 8) & 0xf800) |
739
740
				( ((cte.green) << 3) & 0x07e0) |
				( ((cte.blue)  >> 3) & 0x001f) ;
741
#ifdef CONFIG_SYS_INVERT_COLORS
wdenk's avatar
wdenk committed
742
			*cmap = 0xffff - colreg;
743
#else
wdenk's avatar
wdenk committed
744
745
			*cmap = colreg;
#endif
746
#if defined(CONFIG_MPC823)
wdenk's avatar
wdenk committed
747
			cmap--;
748
749
#else
			cmap++;
750
751
752
#endif
#else /* CONFIG_ATMEL_LCD */
			lcd_setcolreg(i, cte.red, cte.green, cte.blue);
753
754
755
#endif
		}
	}
756
#endif
757

758
759
760
761
762
763
	/*
	 *  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.
Wolfgang Denk's avatar
Wolfgang Denk committed
764
765
	 *  Probably, PXA250 and MPC823 process 1bpp BMP images in
	 * their own ways, so make the converting to be MCC200
766
767
768
	 * specific.
	 */
#if defined(CONFIG_MCC200)
769
	if (bpix == 1) {
770
771
772
773
774
775
		width = ((width + 7) & ~7) >> 3;
		x     = ((x + 7) & ~7) >> 3;
		pwidth= ((pwidth + 7) & ~7) >> 3;
	}
#endif

776
	padded_line = (width&0x3) ? ((width&~0x3)+4) : (width);
777
778

#ifdef CONFIG_SPLASH_SCREEN_ALIGN
779
780
	splash_align_axis(&x, pwidth, width);
	splash_align_axis(&y, panel_info.vl_row, height);
781
782
#endif /* CONFIG_SPLASH_SCREEN_ALIGN */

783
	if ((x + width) > pwidth)
784
		width = pwidth - x;
785
	if ((y + height) > panel_info.vl_row)
786
787
		height = panel_info.vl_row - y;

788
	bmap = (uchar *)bmp + le32_to_cpu(bmp->header.data_offset);
789
	fb   = (uchar *) (lcd_base +
790
		(y + height - 1) * lcd_line_length + x * bpix / 8);
Mark Jackson's avatar
Mark Jackson committed
791

792
	switch (bmp_bpix) {
Mark Jackson's avatar
Mark Jackson committed
793
794
	case 1: /* pass through */
	case 8:
795
796
797
798
799
		if (bpix != 16)
			byte_width = width;
		else
			byte_width = width * 2;

Mark Jackson's avatar
Mark Jackson committed
800
801
		for (i = 0; i < height; ++i) {
			WATCHDOG_RESET();
802
803
			for (j = 0; j < width; j++) {
				if (bpix != 16) {
804
					FB_PUT_BYTE(fb, bmap);
805
806
807
808
809
				} else {
					*(uint16_t *)fb = cmap_base[*(bmap++)];
					fb += sizeof(uint16_t) / sizeof(*fb);
				}
			}
Mark Jackson's avatar
Mark Jackson committed
810
			bmap += (width - padded_line);
811
			fb   -= (byte_width + lcd_line_length);
Mark Jackson's avatar
Mark Jackson committed
812
813
814
815
816
817
818
		}
		break;

#if defined(CONFIG_BMP_16BPP)
	case 16:
		for (i = 0; i < height; ++i) {
			WATCHDOG_RESET();
819
820
821
			for (j = 0; j < width; j++)
				fb_put_word(&fb, &bmap);

Mark Jackson's avatar
Mark Jackson committed
822
823
824
825
826
827
			bmap += (padded_line - width) * 2;
			fb   -= (width * 2 + lcd_line_length);
		}
		break;
#endif /* CONFIG_BMP_16BPP */

828
829
830
831
832
833
834
835
836
837
838
839
840
#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++);
			}
			fb  -= (lcd_line_length + width * (bpix / 8));
		}
		break;
#endif /* CONFIG_BMP_32BPP */
Mark Jackson's avatar
Mark Jackson committed
841
842
843
	default:
		break;
	};
844

845
	return 0;
846
}
847
#endif
848

849
static void *lcd_logo(void)
850
851
852
853
854
855
856
{
#ifdef CONFIG_SPLASH_SCREEN
	char *s;
	ulong addr;
	static int do_splash = 1;

	if (do_splash && (s = getenv("splashimage")) != NULL) {
857
		int x = 0, y = 0;
858
859
		do_splash = 0;

860
861
		addr = simple_strtoul (s, NULL, 16);
#ifdef CONFIG_SPLASH_SCREEN_ALIGN
862
863
		s = getenv("splashpos");
		if (s != NULL) {
864
865
866
			if (s[0] == 'm')
				x = BMP_ALIGN_CENTER;
			else
867
				x = simple_strtol(s, NULL, 0);
868

869
870
			s = strchr(s + 1, ',');
			if (s != NULL) {
871
872
873
874
875
876
877
878
				if (s[1] == 'm')
					y = BMP_ALIGN_CENTER;
				else
					y = simple_strtol (s + 1, NULL, 0);
			}
		}
#endif /* CONFIG_SPLASH_SCREEN_ALIGN */

879
		if (bmp_display(addr, x, y) == 0)
880
			return (void *)lcd_base;
881
882
883
	}
#endif /* CONFIG_SPLASH_SCREEN */

884
	bitmap_plot(0, 0);
885

886
887
888
889
890
#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 */
Stelian Pop's avatar
Stelian Pop committed
891

wdenk's avatar
wdenk committed
892
#if defined(CONFIG_LCD_LOGO) && !defined(CONFIG_LCD_INFO_BELOW_LOGO)
893
	return (void *)((ulong)lcd_base + BMP_LOGO_HEIGHT * lcd_line_length);
894
#else
895
	return (void *)lcd_base;
wdenk's avatar
wdenk committed
896
#endif /* CONFIG_LCD_LOGO && !CONFIG_LCD_INFO_BELOW_LOGO */
897
898
899
900
}

/************************************************************************/
/************************************************************************/