xref: /openbmc/u-boot/drivers/video/cfb_console.c (revision 1155d555)
1  /*
2   * (C) Copyright 2002 ELTEC Elektronik AG
3   * Frank Gottschling <fgottschling@eltec.de>
4   *
5   * See file CREDITS for list of people who contributed to this
6   * project.
7   *
8   * This program is free software; you can redistribute it and/or
9   * modify it under the terms of the GNU General Public License as
10   * published by the Free Software Foundation; either version 2 of
11   * the License, or (at your option) any later version.
12   *
13   * This program is distributed in the hope that it will be useful,
14   * but WITHOUT ANY WARRANTY; without even the implied warranty of
15   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
16   * GNU General Public License for more details.
17   *
18   * You should have received a copy of the GNU General Public License
19   * along with this program; if not, write to the Free Software
20   * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21   * MA 02111-1307 USA
22   */
23  
24  /*
25   * cfb_console.c
26   *
27   * Color Framebuffer Console driver for 8/15/16/24/32 bits per pixel.
28   *
29   * At the moment only the 8x16 font is tested and the font fore- and
30   * background color is limited to black/white/gray colors. The Linux
31   * logo can be placed in the upper left corner and additional board
32   * information strings (that normally goes to serial port) can be drawn.
33   *
34   * The console driver can use the standard PC keyboard interface (i8042)
35   * for character input. Character output goes to a memory mapped video
36   * framebuffer with little or big-endian organisation.
37   * With environment setting 'console=serial' the console i/o can be
38   * forced to serial port.
39   *
40   * The driver uses graphic specific defines/parameters/functions:
41   *
42   * (for SMI LynxE graphic chip)
43   *
44   * CONFIG_VIDEO_SMI_LYNXEM    - use graphic driver for SMI 710,712,810
45   * VIDEO_FB_LITTLE_ENDIAN     - framebuffer organisation default: big endian
46   * VIDEO_HW_RECTFILL	      - graphic driver supports hardware rectangle fill
47   * VIDEO_HW_BITBLT	      - graphic driver supports hardware bit blt
48   *
49   * Console Parameters are set by graphic drivers global struct:
50   *
51   * VIDEO_VISIBLE_COLS	      - x resolution
52   * VIDEO_VISIBLE_ROWS	      - y resolution
53   * VIDEO_PIXEL_SIZE	      - storage size in byte per pixel
54   * VIDEO_DATA_FORMAT	      - graphical data format GDF
55   * VIDEO_FB_ADRS	      - start of video memory
56   *
57   * CONFIG_I8042_KBD	      - AT Keyboard driver for i8042
58   * VIDEO_KBD_INIT_FCT	      - init function for keyboard
59   * VIDEO_TSTC_FCT	      - keyboard_tstc function
60   * VIDEO_GETC_FCT	      - keyboard_getc function
61   *
62   * CONFIG_CONSOLE_CURSOR      - on/off drawing cursor is done with
63   *				delay loop in VIDEO_TSTC_FCT (i8042)
64   *
65   * CONFIG_SYS_CONSOLE_BLINK_COUNT - value for delay loop - blink rate
66   * CONFIG_CONSOLE_TIME	      - display time/date in upper right
67   *				corner, needs CONFIG_CMD_DATE and
68   *				CONFIG_CONSOLE_CURSOR
69   * CONFIG_VIDEO_LOGO	      - display Linux Logo in upper left corner.
70   *				Use CONFIG_SPLASH_SCREEN_ALIGN with
71   *				environment variable "splashpos" to place
72   *				the logo on other position. In this case
73   *				no CONSOLE_EXTRA_INFO is possible.
74   * CONFIG_VIDEO_BMP_LOGO      - use bmp_logo instead of linux_logo
75   * CONFIG_CONSOLE_EXTRA_INFO  - display additional board information
76   *				strings that normaly goes to serial
77   *				port.  This define requires a board
78   *				specific function:
79   *				video_drawstring (VIDEO_INFO_X,
80   *					VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT,
81   *					info);
82   *				that fills a info buffer at i=row.
83   *				s.a: board/eltec/bab7xx.
84   * CONFIG_VGA_AS_SINGLE_DEVICE - If set the framebuffer device will be
85   *				initialized as an output only device.
86   *				The Keyboard driver will not be
87   *				set-up.  This may be used, if you have
88   *				no or more than one Keyboard devices
89   *				(USB Keyboard, AT Keyboard).
90   *
91   * CONFIG_VIDEO_SW_CURSOR:    - Draws a cursor after the last
92   *				character. No blinking is provided.
93   *				Uses the macros CURSOR_SET and
94   *				CURSOR_OFF.
95   *
96   * CONFIG_VIDEO_HW_CURSOR:    - Uses the hardware cursor capability
97   *				of the graphic chip. Uses the macro
98   *				CURSOR_SET. ATTENTION: If booting an
99   *				OS, the display driver must disable
100   *				the hardware register of the graphic
101   *				chip. Otherwise a blinking field is
102   *				displayed.
103   */
104  
105  #include <common.h>
106  #include <version.h>
107  #include <malloc.h>
108  #include <linux/compiler.h>
109  
110  /*
111   * Console device defines with SMI graphic
112   * Any other graphic must change this section
113   */
114  
115  #ifdef	CONFIG_VIDEO_SMI_LYNXEM
116  
117  #define VIDEO_FB_LITTLE_ENDIAN
118  #define VIDEO_HW_RECTFILL
119  #define VIDEO_HW_BITBLT
120  #endif
121  
122  /*
123   * Defines for the CT69000 driver
124   */
125  #ifdef	CONFIG_VIDEO_CT69000
126  
127  #define VIDEO_FB_LITTLE_ENDIAN
128  #define VIDEO_HW_RECTFILL
129  #define VIDEO_HW_BITBLT
130  #endif
131  
132  /*
133   * Defines for the SED13806 driver
134   */
135  #ifdef CONFIG_VIDEO_SED13806
136  
137  #ifndef CONFIG_TOTAL5200
138  #define VIDEO_FB_LITTLE_ENDIAN
139  #endif
140  #define VIDEO_HW_RECTFILL
141  #define VIDEO_HW_BITBLT
142  #endif
143  
144  /*
145   * Defines for the SED13806 driver
146   */
147  #ifdef CONFIG_VIDEO_SM501
148  
149  #ifdef CONFIG_HH405
150  #define VIDEO_FB_LITTLE_ENDIAN
151  #endif
152  #endif
153  
154  /*
155   * Defines for the MB862xx driver
156   */
157  #ifdef CONFIG_VIDEO_MB862xx
158  
159  #ifdef CONFIG_VIDEO_CORALP
160  #define VIDEO_FB_LITTLE_ENDIAN
161  #endif
162  #ifdef CONFIG_VIDEO_MB862xx_ACCEL
163  #define VIDEO_HW_RECTFILL
164  #define VIDEO_HW_BITBLT
165  #endif
166  #endif
167  
168  /*
169   * Defines for the i.MX31 driver (mx3fb.c)
170   */
171  #if defined(CONFIG_VIDEO_MX3) || defined(CONFIG_VIDEO_IPUV3)
172  #define VIDEO_FB_16BPP_WORD_SWAP
173  #endif
174  
175  /*
176   * Include video_fb.h after definitions of VIDEO_HW_RECTFILL etc.
177   */
178  #include <video_fb.h>
179  
180  /*
181   * some Macros
182   */
183  #define VIDEO_VISIBLE_COLS	(pGD->winSizeX)
184  #define VIDEO_VISIBLE_ROWS	(pGD->winSizeY)
185  #define VIDEO_PIXEL_SIZE	(pGD->gdfBytesPP)
186  #define VIDEO_DATA_FORMAT	(pGD->gdfIndex)
187  #define VIDEO_FB_ADRS		(pGD->frameAdrs)
188  
189  /*
190   * Console device defines with i8042 keyboard controller
191   * Any other keyboard controller must change this section
192   */
193  
194  #ifdef	CONFIG_I8042_KBD
195  #include <i8042.h>
196  
197  #define VIDEO_KBD_INIT_FCT	i8042_kbd_init()
198  #define VIDEO_TSTC_FCT		i8042_tstc
199  #define VIDEO_GETC_FCT		i8042_getc
200  #endif
201  
202  /*
203   * Console device
204   */
205  
206  #include <version.h>
207  #include <linux/types.h>
208  #include <stdio_dev.h>
209  #include <video_font.h>
210  #include <video_font_data.h>
211  
212  #if defined(CONFIG_CMD_DATE)
213  #include <rtc.h>
214  #endif
215  
216  #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
217  #include <watchdog.h>
218  #include <bmp_layout.h>
219  
220  #ifdef CONFIG_SPLASH_SCREEN_ALIGN
221  #define BMP_ALIGN_CENTER	0x7FFF
222  #endif
223  
224  #endif
225  
226  /*
227   * Cursor definition:
228   * CONFIG_CONSOLE_CURSOR:  Uses a timer function (see drivers/input/i8042.c)
229   *			   to let the cursor blink. Uses the macros
230   *			   CURSOR_OFF and CURSOR_ON.
231   * CONFIG_VIDEO_SW_CURSOR: Draws a cursor after the last character. No
232   *			   blinking is provided. Uses the macros CURSOR_SET
233   *			   and CURSOR_OFF.
234   * CONFIG_VIDEO_HW_CURSOR: Uses the hardware cursor capability of the
235   *			   graphic chip. Uses the macro CURSOR_SET.
236   *			   ATTENTION: If booting an OS, the display driver
237   *			   must disable the hardware register of the graphic
238   *			   chip. Otherwise a blinking field is displayed
239   */
240  #if !defined(CONFIG_CONSOLE_CURSOR) && \
241      !defined(CONFIG_VIDEO_SW_CURSOR) && \
242      !defined(CONFIG_VIDEO_HW_CURSOR)
243  /* no Cursor defined */
244  #define CURSOR_ON
245  #define CURSOR_OFF
246  #define CURSOR_SET
247  #endif
248  
249  #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
250  #if defined(CURSOR_ON) || \
251  	(defined(CONFIG_CONSOLE_CURSOR) && defined(CONFIG_VIDEO_SW_CURSOR))
252  #error	only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
253  	or CONFIG_VIDEO_HW_CURSOR can be defined
254  #endif
255  void console_cursor(int state);
256  
257  #define CURSOR_ON  console_cursor(1)
258  #define CURSOR_OFF console_cursor(0)
259  #define CURSOR_SET video_set_cursor()
260  #endif /* CONFIG_CONSOLE_CURSOR || CONFIG_VIDEO_SW_CURSOR */
261  
262  #ifdef	CONFIG_CONSOLE_CURSOR
263  #ifndef	CONFIG_CONSOLE_TIME
264  #error	CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
265  #endif
266  #ifndef CONFIG_I8042_KBD
267  #warning Cursor drawing on/off needs timer function s.a. drivers/input/i8042.c
268  #endif
269  #endif /* CONFIG_CONSOLE_CURSOR */
270  
271  
272  #ifdef CONFIG_VIDEO_HW_CURSOR
273  #ifdef	CURSOR_ON
274  #error	only one of CONFIG_CONSOLE_CURSOR, CONFIG_VIDEO_SW_CURSOR, \
275  	or CONFIG_VIDEO_HW_CURSOR can be defined
276  #endif
277  #define CURSOR_ON
278  #define CURSOR_OFF
279  #define CURSOR_SET video_set_hw_cursor(console_col * VIDEO_FONT_WIDTH, \
280  		  (console_row * VIDEO_FONT_HEIGHT) + video_logo_height)
281  #endif /* CONFIG_VIDEO_HW_CURSOR */
282  
283  #ifdef	CONFIG_VIDEO_LOGO
284  #ifdef	CONFIG_VIDEO_BMP_LOGO
285  #include <bmp_logo.h>
286  #include <bmp_logo_data.h>
287  #define VIDEO_LOGO_WIDTH	BMP_LOGO_WIDTH
288  #define VIDEO_LOGO_HEIGHT	BMP_LOGO_HEIGHT
289  #define VIDEO_LOGO_LUT_OFFSET	BMP_LOGO_OFFSET
290  #define VIDEO_LOGO_COLORS	BMP_LOGO_COLORS
291  
292  #else  /* CONFIG_VIDEO_BMP_LOGO */
293  #define LINUX_LOGO_WIDTH	80
294  #define LINUX_LOGO_HEIGHT	80
295  #define LINUX_LOGO_COLORS	214
296  #define LINUX_LOGO_LUT_OFFSET	0x20
297  #define __initdata
298  #include <linux_logo.h>
299  #define VIDEO_LOGO_WIDTH	LINUX_LOGO_WIDTH
300  #define VIDEO_LOGO_HEIGHT	LINUX_LOGO_HEIGHT
301  #define VIDEO_LOGO_LUT_OFFSET	LINUX_LOGO_LUT_OFFSET
302  #define VIDEO_LOGO_COLORS	LINUX_LOGO_COLORS
303  #endif /* CONFIG_VIDEO_BMP_LOGO */
304  #define VIDEO_INFO_X		(VIDEO_LOGO_WIDTH)
305  #define VIDEO_INFO_Y		(VIDEO_FONT_HEIGHT/2)
306  #else  /* CONFIG_VIDEO_LOGO */
307  #define VIDEO_LOGO_WIDTH	0
308  #define VIDEO_LOGO_HEIGHT	0
309  #endif /* CONFIG_VIDEO_LOGO */
310  
311  #define VIDEO_COLS		VIDEO_VISIBLE_COLS
312  #define VIDEO_ROWS		VIDEO_VISIBLE_ROWS
313  #define VIDEO_SIZE		(VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
314  #define VIDEO_PIX_BLOCKS	(VIDEO_SIZE >> 2)
315  #define VIDEO_LINE_LEN		(VIDEO_COLS*VIDEO_PIXEL_SIZE)
316  #define VIDEO_BURST_LEN		(VIDEO_COLS/8)
317  
318  #ifdef	CONFIG_VIDEO_LOGO
319  #define CONSOLE_ROWS		((VIDEO_ROWS - video_logo_height) / VIDEO_FONT_HEIGHT)
320  #else
321  #define CONSOLE_ROWS		(VIDEO_ROWS / VIDEO_FONT_HEIGHT)
322  #endif
323  
324  #define CONSOLE_COLS		(VIDEO_COLS / VIDEO_FONT_WIDTH)
325  #define CONSOLE_ROW_SIZE	(VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
326  #define CONSOLE_ROW_FIRST	(video_console_address)
327  #define CONSOLE_ROW_SECOND	(video_console_address + CONSOLE_ROW_SIZE)
328  #define CONSOLE_ROW_LAST	(video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
329  #define CONSOLE_SIZE		(CONSOLE_ROW_SIZE * CONSOLE_ROWS)
330  #define CONSOLE_SCROLL_SIZE	(CONSOLE_SIZE - CONSOLE_ROW_SIZE)
331  
332  /* Macros */
333  #ifdef	VIDEO_FB_LITTLE_ENDIAN
334  #define SWAP16(x)		((((x) & 0x00ff) << 8) | \
335  				  ((x) >> 8) \
336  				)
337  #define SWAP32(x)		((((x) & 0x000000ff) << 24) | \
338  				 (((x) & 0x0000ff00) <<  8) | \
339  				 (((x) & 0x00ff0000) >>  8) | \
340  				 (((x) & 0xff000000) >> 24)   \
341  				)
342  #define SHORTSWAP32(x)		((((x) & 0x000000ff) <<  8) | \
343  				 (((x) & 0x0000ff00) >>  8) | \
344  				 (((x) & 0x00ff0000) <<  8) | \
345  				 (((x) & 0xff000000) >>  8)   \
346  				)
347  #else
348  #define SWAP16(x)		(x)
349  #define SWAP32(x)		(x)
350  #if defined(VIDEO_FB_16BPP_WORD_SWAP)
351  #define SHORTSWAP32(x)		(((x) >> 16) | ((x) << 16))
352  #else
353  #define SHORTSWAP32(x)		(x)
354  #endif
355  #endif
356  
357  #ifdef CONFIG_CONSOLE_EXTRA_INFO
358  /*
359   * setup a board string: type, speed, etc.
360   *
361   * line_number:	location to place info string beside logo
362   * info:	buffer for info string
363   */
364  extern void video_get_info_str(int line_number,	char *info);
365  #endif
366  
367  DECLARE_GLOBAL_DATA_PTR;
368  
369  /* Locals */
370  static GraphicDevice *pGD;	/* Pointer to Graphic array */
371  
372  static void *video_fb_address;	/* frame buffer address */
373  static void *video_console_address;	/* console buffer start address */
374  
375  static int video_logo_height = VIDEO_LOGO_HEIGHT;
376  
377  static int __maybe_unused cursor_state;
378  static int __maybe_unused old_col;
379  static int __maybe_unused old_row;
380  
381  static int console_col;		/* cursor col */
382  static int console_row;		/* cursor row */
383  
384  static u32 eorx, fgx, bgx;	/* color pats */
385  
386  static int cfb_do_flush_cache;
387  
388  #ifdef CONFIG_CFB_CONSOLE_ANSI
389  static char ansi_buf[10];
390  static int ansi_buf_size;
391  static int ansi_colors_need_revert;
392  static int ansi_cursor_hidden;
393  #endif
394  
395  static const int video_font_draw_table8[] = {
396  	0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
397  	0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
398  	0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
399  	0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff
400  };
401  
402  static const int video_font_draw_table15[] = {
403  	0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff
404  };
405  
406  static const int video_font_draw_table16[] = {
407  	0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff
408  };
409  
410  static const int video_font_draw_table24[16][3] = {
411  	{0x00000000, 0x00000000, 0x00000000},
412  	{0x00000000, 0x00000000, 0x00ffffff},
413  	{0x00000000, 0x0000ffff, 0xff000000},
414  	{0x00000000, 0x0000ffff, 0xffffffff},
415  	{0x000000ff, 0xffff0000, 0x00000000},
416  	{0x000000ff, 0xffff0000, 0x00ffffff},
417  	{0x000000ff, 0xffffffff, 0xff000000},
418  	{0x000000ff, 0xffffffff, 0xffffffff},
419  	{0xffffff00, 0x00000000, 0x00000000},
420  	{0xffffff00, 0x00000000, 0x00ffffff},
421  	{0xffffff00, 0x0000ffff, 0xff000000},
422  	{0xffffff00, 0x0000ffff, 0xffffffff},
423  	{0xffffffff, 0xffff0000, 0x00000000},
424  	{0xffffffff, 0xffff0000, 0x00ffffff},
425  	{0xffffffff, 0xffffffff, 0xff000000},
426  	{0xffffffff, 0xffffffff, 0xffffffff}
427  };
428  
429  static const int video_font_draw_table32[16][4] = {
430  	{0x00000000, 0x00000000, 0x00000000, 0x00000000},
431  	{0x00000000, 0x00000000, 0x00000000, 0x00ffffff},
432  	{0x00000000, 0x00000000, 0x00ffffff, 0x00000000},
433  	{0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff},
434  	{0x00000000, 0x00ffffff, 0x00000000, 0x00000000},
435  	{0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff},
436  	{0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000},
437  	{0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff},
438  	{0x00ffffff, 0x00000000, 0x00000000, 0x00000000},
439  	{0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff},
440  	{0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000},
441  	{0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff},
442  	{0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000},
443  	{0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff},
444  	{0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000},
445  	{0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff}
446  };
447  
448  static void video_drawchars(int xx, int yy, unsigned char *s, int count)
449  {
450  	u8 *cdat, *dest, *dest0;
451  	int rows, offset, c;
452  
453  	offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
454  	dest0 = video_fb_address + offset;
455  
456  	switch (VIDEO_DATA_FORMAT) {
457  	case GDF__8BIT_INDEX:
458  	case GDF__8BIT_332RGB:
459  		while (count--) {
460  			c = *s;
461  			cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
462  			for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
463  			     rows--; dest += VIDEO_LINE_LEN) {
464  				u8 bits = *cdat++;
465  
466  				((u32 *) dest)[0] =
467  					(video_font_draw_table8[bits >> 4] &
468  					 eorx) ^ bgx;
469  				((u32 *) dest)[1] =
470  					(video_font_draw_table8[bits & 15] &
471  					 eorx) ^ bgx;
472  			}
473  			dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
474  			s++;
475  		}
476  		break;
477  
478  	case GDF_15BIT_555RGB:
479  		while (count--) {
480  			c = *s;
481  			cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
482  			for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
483  			     rows--; dest += VIDEO_LINE_LEN) {
484  				u8 bits = *cdat++;
485  
486  				((u32 *) dest)[0] =
487  					SHORTSWAP32((video_font_draw_table15
488  						     [bits >> 6] & eorx) ^
489  						    bgx);
490  				((u32 *) dest)[1] =
491  					SHORTSWAP32((video_font_draw_table15
492  						     [bits >> 4 & 3] & eorx) ^
493  						    bgx);
494  				((u32 *) dest)[2] =
495  					SHORTSWAP32((video_font_draw_table15
496  						     [bits >> 2 & 3] & eorx) ^
497  						    bgx);
498  				((u32 *) dest)[3] =
499  					SHORTSWAP32((video_font_draw_table15
500  						     [bits & 3] & eorx) ^
501  						    bgx);
502  			}
503  			dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
504  			s++;
505  		}
506  		break;
507  
508  	case GDF_16BIT_565RGB:
509  		while (count--) {
510  			c = *s;
511  			cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
512  			for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
513  			     rows--; dest += VIDEO_LINE_LEN) {
514  				u8 bits = *cdat++;
515  
516  				((u32 *) dest)[0] =
517  					SHORTSWAP32((video_font_draw_table16
518  						     [bits >> 6] & eorx) ^
519  						    bgx);
520  				((u32 *) dest)[1] =
521  					SHORTSWAP32((video_font_draw_table16
522  						     [bits >> 4 & 3] & eorx) ^
523  						    bgx);
524  				((u32 *) dest)[2] =
525  					SHORTSWAP32((video_font_draw_table16
526  						     [bits >> 2 & 3] & eorx) ^
527  						    bgx);
528  				((u32 *) dest)[3] =
529  					SHORTSWAP32((video_font_draw_table16
530  						     [bits & 3] & eorx) ^
531  						    bgx);
532  			}
533  			dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
534  			s++;
535  		}
536  		break;
537  
538  	case GDF_32BIT_X888RGB:
539  		while (count--) {
540  			c = *s;
541  			cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
542  			for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
543  			     rows--; dest += VIDEO_LINE_LEN) {
544  				u8 bits = *cdat++;
545  
546  				((u32 *) dest)[0] =
547  					SWAP32((video_font_draw_table32
548  						[bits >> 4][0] & eorx) ^ bgx);
549  				((u32 *) dest)[1] =
550  					SWAP32((video_font_draw_table32
551  						[bits >> 4][1] & eorx) ^ bgx);
552  				((u32 *) dest)[2] =
553  					SWAP32((video_font_draw_table32
554  						[bits >> 4][2] & eorx) ^ bgx);
555  				((u32 *) dest)[3] =
556  					SWAP32((video_font_draw_table32
557  						[bits >> 4][3] & eorx) ^ bgx);
558  				((u32 *) dest)[4] =
559  					SWAP32((video_font_draw_table32
560  						[bits & 15][0] & eorx) ^ bgx);
561  				((u32 *) dest)[5] =
562  					SWAP32((video_font_draw_table32
563  						[bits & 15][1] & eorx) ^ bgx);
564  				((u32 *) dest)[6] =
565  					SWAP32((video_font_draw_table32
566  						[bits & 15][2] & eorx) ^ bgx);
567  				((u32 *) dest)[7] =
568  					SWAP32((video_font_draw_table32
569  						[bits & 15][3] & eorx) ^ bgx);
570  			}
571  			if (cfb_do_flush_cache)
572  				flush_cache((ulong)dest0, 32);
573  			dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
574  			s++;
575  		}
576  		break;
577  
578  	case GDF_24BIT_888RGB:
579  		while (count--) {
580  			c = *s;
581  			cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
582  			for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
583  			     rows--; dest += VIDEO_LINE_LEN) {
584  				u8 bits = *cdat++;
585  
586  				((u32 *) dest)[0] =
587  					(video_font_draw_table24[bits >> 4][0]
588  					 & eorx) ^ bgx;
589  				((u32 *) dest)[1] =
590  					(video_font_draw_table24[bits >> 4][1]
591  					 & eorx) ^ bgx;
592  				((u32 *) dest)[2] =
593  					(video_font_draw_table24[bits >> 4][2]
594  					 & eorx) ^ bgx;
595  				((u32 *) dest)[3] =
596  					(video_font_draw_table24[bits & 15][0]
597  					 & eorx) ^ bgx;
598  				((u32 *) dest)[4] =
599  					(video_font_draw_table24[bits & 15][1]
600  					 & eorx) ^ bgx;
601  				((u32 *) dest)[5] =
602  					(video_font_draw_table24[bits & 15][2]
603  					 & eorx) ^ bgx;
604  			}
605  			dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
606  			s++;
607  		}
608  		break;
609  	}
610  }
611  
612  static inline void video_drawstring(int xx, int yy, unsigned char *s)
613  {
614  	video_drawchars(xx, yy, s, strlen((char *) s));
615  }
616  
617  static void video_putchar(int xx, int yy, unsigned char c)
618  {
619  	video_drawchars(xx, yy + video_logo_height, &c, 1);
620  }
621  
622  #if defined(CONFIG_CONSOLE_CURSOR) || defined(CONFIG_VIDEO_SW_CURSOR)
623  static void video_set_cursor(void)
624  {
625  	if (cursor_state)
626  		console_cursor(0);
627  	console_cursor(1);
628  }
629  
630  static void video_invertchar(int xx, int yy)
631  {
632  	int firstx = xx * VIDEO_PIXEL_SIZE;
633  	int lastx = (xx + VIDEO_FONT_WIDTH) * VIDEO_PIXEL_SIZE;
634  	int firsty = yy * VIDEO_LINE_LEN;
635  	int lasty = (yy + VIDEO_FONT_HEIGHT) * VIDEO_LINE_LEN;
636  	int x, y;
637  	for (y = firsty; y < lasty; y += VIDEO_LINE_LEN) {
638  		for (x = firstx; x < lastx; x++) {
639  			u8 *dest = (u8 *)(video_fb_address) + x + y;
640  			*dest = ~*dest;
641  			if (cfb_do_flush_cache)
642  				flush_cache((ulong)dest, 4);
643  		}
644  	}
645  }
646  
647  void console_cursor(int state)
648  {
649  #ifdef CONFIG_CONSOLE_TIME
650  	struct rtc_time tm;
651  	char info[16];
652  
653  	/* time update only if cursor is on (faster scroll) */
654  	if (state) {
655  		rtc_get(&tm);
656  
657  		sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min,
658  			tm.tm_sec);
659  		video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
660  				 VIDEO_INFO_Y, (uchar *) info);
661  
662  		sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon,
663  			tm.tm_year);
664  		video_drawstring(VIDEO_VISIBLE_COLS - 10 * VIDEO_FONT_WIDTH,
665  				 VIDEO_INFO_Y + 1 * VIDEO_FONT_HEIGHT,
666  				 (uchar *) info);
667  	}
668  #endif
669  
670  	if (cursor_state != state) {
671  		if (cursor_state) {
672  			/* turn off the cursor */
673  			video_invertchar(old_col * VIDEO_FONT_WIDTH,
674  					 old_row * VIDEO_FONT_HEIGHT +
675  					 video_logo_height);
676  		} else {
677  			/* turn off the cursor and record where it is */
678  			video_invertchar(console_col * VIDEO_FONT_WIDTH,
679  					 console_row * VIDEO_FONT_HEIGHT +
680  					 video_logo_height);
681  			old_col = console_col;
682  			old_row = console_row;
683  		}
684  		cursor_state = state;
685  	}
686  }
687  #endif
688  
689  #ifndef VIDEO_HW_RECTFILL
690  static void memsetl(int *p, int c, int v)
691  {
692  	while (c--)
693  		*(p++) = v;
694  }
695  #endif
696  
697  #ifndef VIDEO_HW_BITBLT
698  static void memcpyl(int *d, int *s, int c)
699  {
700  	while (c--)
701  		*(d++) = *(s++);
702  }
703  #endif
704  
705  static void console_clear_line(int line, int begin, int end)
706  {
707  #ifdef VIDEO_HW_RECTFILL
708  	video_hw_rectfill(VIDEO_PIXEL_SIZE,		/* bytes per pixel */
709  			  VIDEO_FONT_WIDTH * begin,	/* dest pos x */
710  			  video_logo_height +
711  			  VIDEO_FONT_HEIGHT * line,	/* dest pos y */
712  			  VIDEO_FONT_WIDTH * (end - begin + 1), /* fr. width */
713  			  VIDEO_FONT_HEIGHT,		/* frame height */
714  			  bgx				/* fill color */
715  		);
716  #else
717  	if (begin == 0 && (end + 1) == CONSOLE_COLS) {
718  		memsetl(CONSOLE_ROW_FIRST +
719  			CONSOLE_ROW_SIZE * line,	/* offset of row */
720  			CONSOLE_ROW_SIZE >> 2,		/* length of row */
721  			bgx				/* fill color */
722  		);
723  	} else {
724  		void *offset;
725  		int i, size;
726  
727  		offset = CONSOLE_ROW_FIRST +
728  			 CONSOLE_ROW_SIZE * line +	/* offset of row */
729  			 VIDEO_FONT_WIDTH *
730  			 VIDEO_PIXEL_SIZE * begin;	/* offset of col */
731  		size = VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE * (end - begin + 1);
732  		size >>= 2; /* length to end for memsetl() */
733  		/* fill at col offset of i'th line using bgx as fill color */
734  		for (i = 0; i < VIDEO_FONT_HEIGHT; i++)
735  			memsetl(offset + i * VIDEO_LINE_LEN, size, bgx);
736  	}
737  #endif
738  	if (cfb_do_flush_cache)
739  		flush_cache((ulong)CONSOLE_ROW_FIRST, CONSOLE_SIZE);
740  }
741  
742  static void console_scrollup(void)
743  {
744  	/* copy up rows ignoring the first one */
745  
746  #ifdef VIDEO_HW_BITBLT
747  	video_hw_bitblt(VIDEO_PIXEL_SIZE,	/* bytes per pixel */
748  			0,			/* source pos x */
749  			video_logo_height +
750  				VIDEO_FONT_HEIGHT, /* source pos y */
751  			0,			/* dest pos x */
752  			video_logo_height,	/* dest pos y */
753  			VIDEO_VISIBLE_COLS,	/* frame width */
754  			VIDEO_VISIBLE_ROWS
755  			- video_logo_height
756  			- VIDEO_FONT_HEIGHT	/* frame height */
757  		);
758  #else
759  	memcpyl(CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND,
760  		CONSOLE_SCROLL_SIZE >> 2);
761  #endif
762  	/* clear the last one */
763  	console_clear_line(CONSOLE_ROWS - 1, 0, CONSOLE_COLS - 1);
764  }
765  
766  static void console_back(void)
767  {
768  	console_col--;
769  
770  	if (console_col < 0) {
771  		console_col = CONSOLE_COLS - 1;
772  		console_row--;
773  		if (console_row < 0)
774  			console_row = 0;
775  	}
776  }
777  
778  #ifdef CONFIG_CFB_CONSOLE_ANSI
779  
780  static void console_clear(void)
781  {
782  #ifdef VIDEO_HW_RECTFILL
783  	video_hw_rectfill(VIDEO_PIXEL_SIZE,	/* bytes per pixel */
784  			  0,			/* dest pos x */
785  			  video_logo_height,	/* dest pos y */
786  			  VIDEO_VISIBLE_COLS,	/* frame width */
787  			  VIDEO_VISIBLE_ROWS,	/* frame height */
788  			  bgx			/* fill color */
789  	);
790  #else
791  	memsetl(CONSOLE_ROW_FIRST, CONSOLE_SIZE, bgx);
792  #endif
793  }
794  
795  static void console_cursor_fix(void)
796  {
797  	if (console_row < 0)
798  		console_row = 0;
799  	if (console_row >= CONSOLE_ROWS)
800  		console_row = CONSOLE_ROWS - 1;
801  	if (console_col < 0)
802  		console_col = 0;
803  	if (console_col >= CONSOLE_COLS)
804  		console_col = CONSOLE_COLS - 1;
805  }
806  
807  static void console_cursor_up(int n)
808  {
809  	console_row -= n;
810  	console_cursor_fix();
811  }
812  
813  static void console_cursor_down(int n)
814  {
815  	console_row += n;
816  	console_cursor_fix();
817  }
818  
819  static void console_cursor_left(int n)
820  {
821  	console_col -= n;
822  	console_cursor_fix();
823  }
824  
825  static void console_cursor_right(int n)
826  {
827  	console_col += n;
828  	console_cursor_fix();
829  }
830  
831  static void console_cursor_set_position(int row, int col)
832  {
833  	if (console_row != -1)
834  		console_row = row;
835  	if (console_col != -1)
836  		console_col = col;
837  	console_cursor_fix();
838  }
839  
840  static void console_previousline(int n)
841  {
842  	/* FIXME: also scroll terminal ? */
843  	console_row -= n;
844  	console_cursor_fix();
845  }
846  
847  static void console_swap_colors(void)
848  {
849  	eorx = fgx;
850  	fgx = bgx;
851  	bgx = eorx;
852  	eorx = fgx ^ bgx;
853  }
854  
855  static inline int console_cursor_is_visible(void)
856  {
857  	return !ansi_cursor_hidden;
858  }
859  #else
860  static inline int console_cursor_is_visible(void)
861  {
862  	return 1;
863  }
864  #endif
865  
866  static void console_newline(int n)
867  {
868  	console_row += n;
869  	console_col = 0;
870  
871  	/* Check if we need to scroll the terminal */
872  	if (console_row >= CONSOLE_ROWS) {
873  		/* Scroll everything up */
874  		console_scrollup();
875  
876  		/* Decrement row number */
877  		console_row = CONSOLE_ROWS - 1;
878  	}
879  }
880  
881  static void console_cr(void)
882  {
883  	console_col = 0;
884  }
885  
886  static void parse_putc(const char c)
887  {
888  	static int nl = 1;
889  
890  	if (console_cursor_is_visible())
891  		CURSOR_OFF;
892  
893  	switch (c) {
894  	case 13:		/* back to first column */
895  		console_cr();
896  		break;
897  
898  	case '\n':		/* next line */
899  		if (console_col || (!console_col && nl))
900  			console_newline(1);
901  		nl = 1;
902  		break;
903  
904  	case 9:		/* tab 8 */
905  		console_col |= 0x0008;
906  		console_col &= ~0x0007;
907  
908  		if (console_col >= CONSOLE_COLS)
909  			console_newline(1);
910  		break;
911  
912  	case 8:		/* backspace */
913  		console_back();
914  		break;
915  
916  	case 7:		/* bell */
917  		break;	/* ignored */
918  
919  	default:		/* draw the char */
920  		video_putchar(console_col * VIDEO_FONT_WIDTH,
921  			      console_row * VIDEO_FONT_HEIGHT, c);
922  		console_col++;
923  
924  		/* check for newline */
925  		if (console_col >= CONSOLE_COLS) {
926  			console_newline(1);
927  			nl = 0;
928  		}
929  	}
930  
931  	if (console_cursor_is_visible())
932  		CURSOR_SET;
933  }
934  
935  void video_putc(const char c)
936  {
937  #ifdef CONFIG_CFB_CONSOLE_ANSI
938  	int i;
939  
940  	if (c == 27) {
941  		for (i = 0; i < ansi_buf_size; ++i)
942  			parse_putc(ansi_buf[i]);
943  		ansi_buf[0] = 27;
944  		ansi_buf_size = 1;
945  		return;
946  	}
947  
948  	if (ansi_buf_size > 0) {
949  		/*
950  		 * 0 - ESC
951  		 * 1 - [
952  		 * 2 - num1
953  		 * 3 - ..
954  		 * 4 - ;
955  		 * 5 - num2
956  		 * 6 - ..
957  		 * - cchar
958  		 */
959  		int next = 0;
960  
961  		int flush = 0;
962  		int fail = 0;
963  
964  		int num1 = 0;
965  		int num2 = 0;
966  		int cchar = 0;
967  
968  		ansi_buf[ansi_buf_size++] = c;
969  
970  		if (ansi_buf_size >= sizeof(ansi_buf))
971  			fail = 1;
972  
973  		for (i = 0; i < ansi_buf_size; ++i) {
974  			if (fail)
975  				break;
976  
977  			switch (next) {
978  			case 0:
979  				if (ansi_buf[i] == 27)
980  					next = 1;
981  				else
982  					fail = 1;
983  				break;
984  
985  			case 1:
986  				if (ansi_buf[i] == '[')
987  					next = 2;
988  				else
989  					fail = 1;
990  				break;
991  
992  			case 2:
993  				if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') {
994  					num1 = ansi_buf[i]-'0';
995  					next = 3;
996  				} else if (ansi_buf[i] != '?') {
997  					--i;
998  					num1 = 1;
999  					next = 4;
1000  				}
1001  				break;
1002  
1003  			case 3:
1004  				if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') {
1005  					num1 *= 10;
1006  					num1 += ansi_buf[i]-'0';
1007  				} else {
1008  					--i;
1009  					next = 4;
1010  				}
1011  				break;
1012  
1013  			case 4:
1014  				if (ansi_buf[i] != ';') {
1015  					--i;
1016  					next = 7;
1017  				} else
1018  					next = 5;
1019  				break;
1020  
1021  			case 5:
1022  				if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') {
1023  					num2 = ansi_buf[i]-'0';
1024  					next = 6;
1025  				} else
1026  					fail = 1;
1027  				break;
1028  
1029  			case 6:
1030  				if (ansi_buf[i] >= '0' && ansi_buf[i] <= '9') {
1031  					num2 *= 10;
1032  					num2 += ansi_buf[i]-'0';
1033  				} else {
1034  					--i;
1035  					next = 7;
1036  				}
1037  				break;
1038  
1039  			case 7:
1040  				if ((ansi_buf[i] >= 'A' && ansi_buf[i] <= 'H')
1041  					|| ansi_buf[i] == 'J'
1042  					|| ansi_buf[i] == 'K'
1043  					|| ansi_buf[i] == 'h'
1044  					|| ansi_buf[i] == 'l'
1045  					|| ansi_buf[i] == 'm') {
1046  					cchar = ansi_buf[i];
1047  					flush = 1;
1048  				} else
1049  					fail = 1;
1050  				break;
1051  			}
1052  		}
1053  
1054  		if (fail) {
1055  			for (i = 0; i < ansi_buf_size; ++i)
1056  				parse_putc(ansi_buf[i]);
1057  			ansi_buf_size = 0;
1058  			return;
1059  		}
1060  
1061  		if (flush) {
1062  			if (!ansi_cursor_hidden)
1063  				CURSOR_OFF;
1064  			ansi_buf_size = 0;
1065  			switch (cchar) {
1066  			case 'A':
1067  				/* move cursor num1 rows up */
1068  				console_cursor_up(num1);
1069  				break;
1070  			case 'B':
1071  				/* move cursor num1 rows down */
1072  				console_cursor_down(num1);
1073  				break;
1074  			case 'C':
1075  				/* move cursor num1 columns forward */
1076  				console_cursor_right(num1);
1077  				break;
1078  			case 'D':
1079  				/* move cursor num1 columns back */
1080  				console_cursor_left(num1);
1081  				break;
1082  			case 'E':
1083  				/* move cursor num1 rows up at begin of row */
1084  				console_previousline(num1);
1085  				break;
1086  			case 'F':
1087  				/* move cursor num1 rows down at begin of row */
1088  				console_newline(num1);
1089  				break;
1090  			case 'G':
1091  				/* move cursor to column num1 */
1092  				console_cursor_set_position(-1, num1-1);
1093  				break;
1094  			case 'H':
1095  				/* move cursor to row num1, column num2 */
1096  				console_cursor_set_position(num1-1, num2-1);
1097  				break;
1098  			case 'J':
1099  				/* clear console and move cursor to 0, 0 */
1100  				console_clear();
1101  				console_cursor_set_position(0, 0);
1102  				break;
1103  			case 'K':
1104  				/* clear line */
1105  				if (num1 == 0)
1106  					console_clear_line(console_row,
1107  							console_col,
1108  							CONSOLE_COLS-1);
1109  				else if (num1 == 1)
1110  					console_clear_line(console_row,
1111  							0, console_col);
1112  				else
1113  					console_clear_line(console_row,
1114  							0, CONSOLE_COLS-1);
1115  				break;
1116  			case 'h':
1117  				ansi_cursor_hidden = 0;
1118  				break;
1119  			case 'l':
1120  				ansi_cursor_hidden = 1;
1121  				break;
1122  			case 'm':
1123  				if (num1 == 0) { /* reset swapped colors */
1124  					if (ansi_colors_need_revert) {
1125  						console_swap_colors();
1126  						ansi_colors_need_revert = 0;
1127  					}
1128  				} else if (num1 == 7) { /* once swap colors */
1129  					if (!ansi_colors_need_revert) {
1130  						console_swap_colors();
1131  						ansi_colors_need_revert = 1;
1132  					}
1133  				}
1134  				break;
1135  			}
1136  			if (!ansi_cursor_hidden)
1137  				CURSOR_SET;
1138  		}
1139  	} else {
1140  		parse_putc(c);
1141  	}
1142  #else
1143  	parse_putc(c);
1144  #endif
1145  }
1146  
1147  void video_puts(const char *s)
1148  {
1149  	int count = strlen(s);
1150  
1151  	while (count--)
1152  		video_putc(*s++);
1153  }
1154  
1155  /*
1156   * Do not enforce drivers (or board code) to provide empty
1157   * video_set_lut() if they do not support 8 bpp format.
1158   * Implement weak default function instead.
1159   */
1160  void __video_set_lut(unsigned int index, unsigned char r,
1161  		     unsigned char g, unsigned char b)
1162  {
1163  }
1164  
1165  void video_set_lut(unsigned int, unsigned char, unsigned char, unsigned char)
1166  	__attribute__ ((weak, alias("__video_set_lut")));
1167  
1168  #if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
1169  
1170  #define FILL_8BIT_332RGB(r,g,b)	{			\
1171  	*fb = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6);	\
1172  	fb ++;						\
1173  }
1174  
1175  #define FILL_15BIT_555RGB(r,g,b) {			\
1176  	*(unsigned short *)fb =				\
1177  		SWAP16((unsigned short)(((r>>3)<<10) |	\
1178  					((g>>3)<<5)  |	\
1179  					 (b>>3)));	\
1180  	fb += 2;					\
1181  }
1182  
1183  #define FILL_16BIT_565RGB(r,g,b) {			\
1184  	*(unsigned short *)fb =				\
1185  		SWAP16((unsigned short)((((r)>>3)<<11)| \
1186  					(((g)>>2)<<5) | \
1187  					 ((b)>>3)));	\
1188  	fb += 2;					\
1189  }
1190  
1191  #define FILL_32BIT_X888RGB(r,g,b) {			\
1192  	*(unsigned long *)fb =				\
1193  		SWAP32((unsigned long)(((r<<16) |	\
1194  					(g<<8)  |	\
1195  					 b)));		\
1196  	fb += 4;					\
1197  }
1198  
1199  #ifdef VIDEO_FB_LITTLE_ENDIAN
1200  #define FILL_24BIT_888RGB(r,g,b) {			\
1201  	fb[0] = b;					\
1202  	fb[1] = g;					\
1203  	fb[2] = r;					\
1204  	fb += 3;					\
1205  }
1206  #else
1207  #define FILL_24BIT_888RGB(r,g,b) {			\
1208  	fb[0] = r;					\
1209  	fb[1] = g;					\
1210  	fb[2] = b;					\
1211  	fb += 3;					\
1212  }
1213  #endif
1214  
1215  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1216  static inline void fill_555rgb_pswap(uchar *fb, int x, u8 r, u8 g, u8 b)
1217  {
1218  	ushort *dst = (ushort *) fb;
1219  	ushort color = (ushort) (((r >> 3) << 10) |
1220  				 ((g >> 3) <<  5) |
1221  				  (b >> 3));
1222  	if (x & 1)
1223  		*(--dst) = color;
1224  	else
1225  		*(++dst) = color;
1226  }
1227  #endif
1228  
1229  /*
1230   * RLE8 bitmap support
1231   */
1232  
1233  #ifdef CONFIG_VIDEO_BMP_RLE8
1234  /* Pre-calculated color table entry */
1235  struct palette {
1236  	union {
1237  		unsigned short w;	/* word */
1238  		unsigned int dw;	/* double word */
1239  	} ce;				/* color entry */
1240  };
1241  
1242  /*
1243   * Helper to draw encoded/unencoded run.
1244   */
1245  static void draw_bitmap(uchar **fb, uchar *bm, struct palette *p,
1246  			int cnt, int enc)
1247  {
1248  	ulong addr = (ulong) *fb;
1249  	int *off;
1250  	int enc_off = 1;
1251  	int i;
1252  
1253  	/*
1254  	 * Setup offset of the color index in the bitmap.
1255  	 * Color index of encoded run is at offset 1.
1256  	 */
1257  	off = enc ? &enc_off : &i;
1258  
1259  	switch (VIDEO_DATA_FORMAT) {
1260  	case GDF__8BIT_INDEX:
1261  		for (i = 0; i < cnt; i++)
1262  			*(unsigned char *) addr++ = bm[*off];
1263  		break;
1264  	case GDF_15BIT_555RGB:
1265  	case GDF_16BIT_565RGB:
1266  		/* differences handled while pre-calculating palette */
1267  		for (i = 0; i < cnt; i++) {
1268  			*(unsigned short *) addr = p[bm[*off]].ce.w;
1269  			addr += 2;
1270  		}
1271  		break;
1272  	case GDF_32BIT_X888RGB:
1273  		for (i = 0; i < cnt; i++) {
1274  			*(unsigned long *) addr = p[bm[*off]].ce.dw;
1275  			addr += 4;
1276  		}
1277  		break;
1278  	}
1279  	*fb = (uchar *) addr;	/* return modified address */
1280  }
1281  
1282  static int display_rle8_bitmap(bmp_image_t *img, int xoff, int yoff,
1283  			       int width, int height)
1284  {
1285  	unsigned char *bm;
1286  	unsigned char *fbp;
1287  	unsigned int cnt, runlen;
1288  	int decode = 1;
1289  	int x, y, bpp, i, ncolors;
1290  	struct palette p[256];
1291  	bmp_color_table_entry_t cte;
1292  	int green_shift, red_off;
1293  	int limit = VIDEO_COLS * VIDEO_ROWS;
1294  	int pixels = 0;
1295  
1296  	x = 0;
1297  	y = __le32_to_cpu(img->header.height) - 1;
1298  	ncolors = __le32_to_cpu(img->header.colors_used);
1299  	bpp = VIDEO_PIXEL_SIZE;
1300  	fbp = (unsigned char *) ((unsigned int) video_fb_address +
1301  				 (((y + yoff) * VIDEO_COLS) + xoff) * bpp);
1302  
1303  	bm = (uchar *) img + __le32_to_cpu(img->header.data_offset);
1304  
1305  	/* pre-calculate and setup palette */
1306  	switch (VIDEO_DATA_FORMAT) {
1307  	case GDF__8BIT_INDEX:
1308  		for (i = 0; i < ncolors; i++) {
1309  			cte = img->color_table[i];
1310  			video_set_lut(i, cte.red, cte.green, cte.blue);
1311  		}
1312  		break;
1313  	case GDF_15BIT_555RGB:
1314  	case GDF_16BIT_565RGB:
1315  		if (VIDEO_DATA_FORMAT == GDF_15BIT_555RGB) {
1316  			green_shift = 3;
1317  			red_off = 10;
1318  		} else {
1319  			green_shift = 2;
1320  			red_off = 11;
1321  		}
1322  		for (i = 0; i < ncolors; i++) {
1323  			cte = img->color_table[i];
1324  			p[i].ce.w = SWAP16((unsigned short)
1325  					   (((cte.red >> 3) << red_off) |
1326  					    ((cte.green >> green_shift) << 5) |
1327  					    cte.blue >> 3));
1328  		}
1329  		break;
1330  	case GDF_32BIT_X888RGB:
1331  		for (i = 0; i < ncolors; i++) {
1332  			cte = img->color_table[i];
1333  			p[i].ce.dw = SWAP32((cte.red << 16) |
1334  					    (cte.green << 8) |
1335  					     cte.blue);
1336  		}
1337  		break;
1338  	default:
1339  		printf("RLE Bitmap unsupported in video mode 0x%x\n",
1340  		       VIDEO_DATA_FORMAT);
1341  		return -1;
1342  	}
1343  
1344  	while (decode) {
1345  		switch (bm[0]) {
1346  		case 0:
1347  			switch (bm[1]) {
1348  			case 0:
1349  				/* scan line end marker */
1350  				bm += 2;
1351  				x = 0;
1352  				y--;
1353  				fbp = (unsigned char *)
1354  					((unsigned int) video_fb_address +
1355  					 (((y + yoff) * VIDEO_COLS) +
1356  					  xoff) * bpp);
1357  				continue;
1358  			case 1:
1359  				/* end of bitmap data marker */
1360  				decode = 0;
1361  				break;
1362  			case 2:
1363  				/* run offset marker */
1364  				x += bm[2];
1365  				y -= bm[3];
1366  				fbp = (unsigned char *)
1367  					((unsigned int) video_fb_address +
1368  					 (((y + yoff) * VIDEO_COLS) +
1369  					  x + xoff) * bpp);
1370  				bm += 4;
1371  				break;
1372  			default:
1373  				/* unencoded run */
1374  				cnt = bm[1];
1375  				runlen = cnt;
1376  				pixels += cnt;
1377  				if (pixels > limit)
1378  					goto error;
1379  
1380  				bm += 2;
1381  				if (y < height) {
1382  					if (x >= width) {
1383  						x += runlen;
1384  						goto next_run;
1385  					}
1386  					if (x + runlen > width)
1387  						cnt = width - x;
1388  					draw_bitmap(&fbp, bm, p, cnt, 0);
1389  					x += runlen;
1390  				}
1391  next_run:
1392  				bm += runlen;
1393  				if (runlen & 1)
1394  					bm++;	/* 0 padding if length is odd */
1395  			}
1396  			break;
1397  		default:
1398  			/* encoded run */
1399  			cnt = bm[0];
1400  			runlen = cnt;
1401  			pixels += cnt;
1402  			if (pixels > limit)
1403  				goto error;
1404  
1405  			if (y < height) {     /* only draw into visible area */
1406  				if (x >= width) {
1407  					x += runlen;
1408  					bm += 2;
1409  					continue;
1410  				}
1411  				if (x + runlen > width)
1412  					cnt = width - x;
1413  				draw_bitmap(&fbp, bm, p, cnt, 1);
1414  				x += runlen;
1415  			}
1416  			bm += 2;
1417  			break;
1418  		}
1419  	}
1420  	return 0;
1421  error:
1422  	printf("Error: Too much encoded pixel data, validate your bitmap\n");
1423  	return -1;
1424  }
1425  #endif
1426  
1427  /*
1428   * Display the BMP file located at address bmp_image.
1429   */
1430  int video_display_bitmap(ulong bmp_image, int x, int y)
1431  {
1432  	ushort xcount, ycount;
1433  	uchar *fb;
1434  	bmp_image_t *bmp = (bmp_image_t *) bmp_image;
1435  	uchar *bmap;
1436  	ushort padded_line;
1437  	unsigned long width, height, bpp;
1438  	unsigned colors;
1439  	unsigned long compression;
1440  	bmp_color_table_entry_t cte;
1441  
1442  #ifdef CONFIG_VIDEO_BMP_GZIP
1443  	unsigned char *dst = NULL;
1444  	ulong len;
1445  #endif
1446  
1447  	WATCHDOG_RESET();
1448  
1449  	if (!((bmp->header.signature[0] == 'B') &&
1450  	      (bmp->header.signature[1] == 'M'))) {
1451  
1452  #ifdef CONFIG_VIDEO_BMP_GZIP
1453  		/*
1454  		 * Could be a gzipped bmp image, try to decrompress...
1455  		 */
1456  		len = CONFIG_SYS_VIDEO_LOGO_MAX_SIZE;
1457  		dst = malloc(CONFIG_SYS_VIDEO_LOGO_MAX_SIZE);
1458  		if (dst == NULL) {
1459  			printf("Error: malloc in gunzip failed!\n");
1460  			return 1;
1461  		}
1462  		if (gunzip(dst, CONFIG_SYS_VIDEO_LOGO_MAX_SIZE,
1463  			   (uchar *) bmp_image,
1464  			   &len) != 0) {
1465  			printf("Error: no valid bmp or bmp.gz image at %lx\n",
1466  			       bmp_image);
1467  			free(dst);
1468  			return 1;
1469  		}
1470  		if (len == CONFIG_SYS_VIDEO_LOGO_MAX_SIZE) {
1471  			printf("Image could be truncated "
1472  				"(increase CONFIG_SYS_VIDEO_LOGO_MAX_SIZE)!\n");
1473  		}
1474  
1475  		/*
1476  		 * Set addr to decompressed image
1477  		 */
1478  		bmp = (bmp_image_t *) dst;
1479  
1480  		if (!((bmp->header.signature[0] == 'B') &&
1481  		      (bmp->header.signature[1] == 'M'))) {
1482  			printf("Error: no valid bmp.gz image at %lx\n",
1483  			       bmp_image);
1484  			free(dst);
1485  			return 1;
1486  		}
1487  #else
1488  		printf("Error: no valid bmp image at %lx\n", bmp_image);
1489  		return 1;
1490  #endif /* CONFIG_VIDEO_BMP_GZIP */
1491  	}
1492  
1493  	width = le32_to_cpu(bmp->header.width);
1494  	height = le32_to_cpu(bmp->header.height);
1495  	bpp = le16_to_cpu(bmp->header.bit_count);
1496  	colors = le32_to_cpu(bmp->header.colors_used);
1497  	compression = le32_to_cpu(bmp->header.compression);
1498  
1499  	debug("Display-bmp: %ld x %ld  with %d colors\n",
1500  	      width, height, colors);
1501  
1502  	if (compression != BMP_BI_RGB
1503  #ifdef CONFIG_VIDEO_BMP_RLE8
1504  	    && compression != BMP_BI_RLE8
1505  #endif
1506  		) {
1507  		printf("Error: compression type %ld not supported\n",
1508  		       compression);
1509  #ifdef CONFIG_VIDEO_BMP_GZIP
1510  		if (dst)
1511  			free(dst);
1512  #endif
1513  		return 1;
1514  	}
1515  
1516  	padded_line = (((width * bpp + 7) / 8) + 3) & ~0x3;
1517  
1518  #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1519  	if (x == BMP_ALIGN_CENTER)
1520  		x = max(0, (VIDEO_VISIBLE_COLS - width) / 2);
1521  	else if (x < 0)
1522  		x = max(0, VIDEO_VISIBLE_COLS - width + x + 1);
1523  
1524  	if (y == BMP_ALIGN_CENTER)
1525  		y = max(0, (VIDEO_VISIBLE_ROWS - height) / 2);
1526  	else if (y < 0)
1527  		y = max(0, VIDEO_VISIBLE_ROWS - height + y + 1);
1528  #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1529  
1530  	/*
1531  	 * Just ignore elements which are completely beyond screen
1532  	 * dimensions.
1533  	 */
1534  	if ((x >= VIDEO_VISIBLE_COLS) || (y >= VIDEO_VISIBLE_ROWS))
1535  		return 0;
1536  
1537  	if ((x + width) > VIDEO_VISIBLE_COLS)
1538  		width = VIDEO_VISIBLE_COLS - x;
1539  	if ((y + height) > VIDEO_VISIBLE_ROWS)
1540  		height = VIDEO_VISIBLE_ROWS - y;
1541  
1542  	bmap = (uchar *) bmp + le32_to_cpu(bmp->header.data_offset);
1543  	fb = (uchar *) (video_fb_address +
1544  			((y + height - 1) * VIDEO_COLS * VIDEO_PIXEL_SIZE) +
1545  			x * VIDEO_PIXEL_SIZE);
1546  
1547  #ifdef CONFIG_VIDEO_BMP_RLE8
1548  	if (compression == BMP_BI_RLE8) {
1549  		return display_rle8_bitmap(bmp, x, y, width, height);
1550  	}
1551  #endif
1552  
1553  	/* We handle only 4, 8, or 24 bpp bitmaps */
1554  	switch (le16_to_cpu(bmp->header.bit_count)) {
1555  	case 4:
1556  		padded_line -= width / 2;
1557  		ycount = height;
1558  
1559  		switch (VIDEO_DATA_FORMAT) {
1560  		case GDF_32BIT_X888RGB:
1561  			while (ycount--) {
1562  				WATCHDOG_RESET();
1563  				/*
1564  				 * Don't assume that 'width' is an
1565  				 * even number
1566  				 */
1567  				for (xcount = 0; xcount < width; xcount++) {
1568  					uchar idx;
1569  
1570  					if (xcount & 1) {
1571  						idx = *bmap & 0xF;
1572  						bmap++;
1573  					} else
1574  						idx = *bmap >> 4;
1575  					cte = bmp->color_table[idx];
1576  					FILL_32BIT_X888RGB(cte.red, cte.green,
1577  							   cte.blue);
1578  				}
1579  				bmap += padded_line;
1580  				fb -= (VIDEO_VISIBLE_COLS + width) *
1581  					VIDEO_PIXEL_SIZE;
1582  			}
1583  			break;
1584  		default:
1585  			puts("4bpp bitmap unsupported with current "
1586  			     "video mode\n");
1587  			break;
1588  		}
1589  		break;
1590  
1591  	case 8:
1592  		padded_line -= width;
1593  		if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1594  			/* Copy colormap */
1595  			for (xcount = 0; xcount < colors; ++xcount) {
1596  				cte = bmp->color_table[xcount];
1597  				video_set_lut(xcount, cte.red, cte.green,
1598  					      cte.blue);
1599  			}
1600  		}
1601  		ycount = height;
1602  		switch (VIDEO_DATA_FORMAT) {
1603  		case GDF__8BIT_INDEX:
1604  			while (ycount--) {
1605  				WATCHDOG_RESET();
1606  				xcount = width;
1607  				while (xcount--) {
1608  					*fb++ = *bmap++;
1609  				}
1610  				bmap += padded_line;
1611  				fb -= (VIDEO_VISIBLE_COLS + width) *
1612  							VIDEO_PIXEL_SIZE;
1613  			}
1614  			break;
1615  		case GDF__8BIT_332RGB:
1616  			while (ycount--) {
1617  				WATCHDOG_RESET();
1618  				xcount = width;
1619  				while (xcount--) {
1620  					cte = bmp->color_table[*bmap++];
1621  					FILL_8BIT_332RGB(cte.red, cte.green,
1622  							 cte.blue);
1623  				}
1624  				bmap += padded_line;
1625  				fb -= (VIDEO_VISIBLE_COLS + width) *
1626  							VIDEO_PIXEL_SIZE;
1627  			}
1628  			break;
1629  		case GDF_15BIT_555RGB:
1630  			while (ycount--) {
1631  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1632  				int xpos = x;
1633  #endif
1634  				WATCHDOG_RESET();
1635  				xcount = width;
1636  				while (xcount--) {
1637  					cte = bmp->color_table[*bmap++];
1638  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1639  					fill_555rgb_pswap(fb, xpos++, cte.red,
1640  							  cte.green,
1641  							  cte.blue);
1642  					fb += 2;
1643  #else
1644  					FILL_15BIT_555RGB(cte.red, cte.green,
1645  							  cte.blue);
1646  #endif
1647  				}
1648  				bmap += padded_line;
1649  				fb -= (VIDEO_VISIBLE_COLS + width) *
1650  							VIDEO_PIXEL_SIZE;
1651  			}
1652  			break;
1653  		case GDF_16BIT_565RGB:
1654  			while (ycount--) {
1655  				WATCHDOG_RESET();
1656  				xcount = width;
1657  				while (xcount--) {
1658  					cte = bmp->color_table[*bmap++];
1659  					FILL_16BIT_565RGB(cte.red, cte.green,
1660  							  cte.blue);
1661  				}
1662  				bmap += padded_line;
1663  				fb -= (VIDEO_VISIBLE_COLS + width) *
1664  							VIDEO_PIXEL_SIZE;
1665  			}
1666  			break;
1667  		case GDF_32BIT_X888RGB:
1668  			while (ycount--) {
1669  				WATCHDOG_RESET();
1670  				xcount = width;
1671  				while (xcount--) {
1672  					cte = bmp->color_table[*bmap++];
1673  					FILL_32BIT_X888RGB(cte.red, cte.green,
1674  							   cte.blue);
1675  				}
1676  				bmap += padded_line;
1677  				fb -= (VIDEO_VISIBLE_COLS + width) *
1678  							VIDEO_PIXEL_SIZE;
1679  			}
1680  			break;
1681  		case GDF_24BIT_888RGB:
1682  			while (ycount--) {
1683  				WATCHDOG_RESET();
1684  				xcount = width;
1685  				while (xcount--) {
1686  					cte = bmp->color_table[*bmap++];
1687  					FILL_24BIT_888RGB(cte.red, cte.green,
1688  							  cte.blue);
1689  				}
1690  				bmap += padded_line;
1691  				fb -= (VIDEO_VISIBLE_COLS + width) *
1692  							VIDEO_PIXEL_SIZE;
1693  			}
1694  			break;
1695  		}
1696  		break;
1697  	case 24:
1698  		padded_line -= 3 * width;
1699  		ycount = height;
1700  		switch (VIDEO_DATA_FORMAT) {
1701  		case GDF__8BIT_332RGB:
1702  			while (ycount--) {
1703  				WATCHDOG_RESET();
1704  				xcount = width;
1705  				while (xcount--) {
1706  					FILL_8BIT_332RGB(bmap[2], bmap[1],
1707  							 bmap[0]);
1708  					bmap += 3;
1709  				}
1710  				bmap += padded_line;
1711  				fb -= (VIDEO_VISIBLE_COLS + width) *
1712  							VIDEO_PIXEL_SIZE;
1713  			}
1714  			break;
1715  		case GDF_15BIT_555RGB:
1716  			while (ycount--) {
1717  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1718  				int xpos = x;
1719  #endif
1720  				WATCHDOG_RESET();
1721  				xcount = width;
1722  				while (xcount--) {
1723  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1724  					fill_555rgb_pswap(fb, xpos++, bmap[2],
1725  							  bmap[1], bmap[0]);
1726  					fb += 2;
1727  #else
1728  					FILL_15BIT_555RGB(bmap[2], bmap[1],
1729  							  bmap[0]);
1730  #endif
1731  					bmap += 3;
1732  				}
1733  				bmap += padded_line;
1734  				fb -= (VIDEO_VISIBLE_COLS + width) *
1735  							VIDEO_PIXEL_SIZE;
1736  			}
1737  			break;
1738  		case GDF_16BIT_565RGB:
1739  			while (ycount--) {
1740  				WATCHDOG_RESET();
1741  				xcount = width;
1742  				while (xcount--) {
1743  					FILL_16BIT_565RGB(bmap[2], bmap[1],
1744  							  bmap[0]);
1745  					bmap += 3;
1746  				}
1747  				bmap += padded_line;
1748  				fb -= (VIDEO_VISIBLE_COLS + width) *
1749  							VIDEO_PIXEL_SIZE;
1750  			}
1751  			break;
1752  		case GDF_32BIT_X888RGB:
1753  			while (ycount--) {
1754  				WATCHDOG_RESET();
1755  				xcount = width;
1756  				while (xcount--) {
1757  					FILL_32BIT_X888RGB(bmap[2], bmap[1],
1758  							   bmap[0]);
1759  					bmap += 3;
1760  				}
1761  				bmap += padded_line;
1762  				fb -= (VIDEO_VISIBLE_COLS + width) *
1763  							VIDEO_PIXEL_SIZE;
1764  			}
1765  			break;
1766  		case GDF_24BIT_888RGB:
1767  			while (ycount--) {
1768  				WATCHDOG_RESET();
1769  				xcount = width;
1770  				while (xcount--) {
1771  					FILL_24BIT_888RGB(bmap[2], bmap[1],
1772  							  bmap[0]);
1773  					bmap += 3;
1774  				}
1775  				bmap += padded_line;
1776  				fb -= (VIDEO_VISIBLE_COLS + width) *
1777  							VIDEO_PIXEL_SIZE;
1778  			}
1779  			break;
1780  		default:
1781  			printf("Error: 24 bits/pixel bitmap incompatible "
1782  				"with current video mode\n");
1783  			break;
1784  		}
1785  		break;
1786  	default:
1787  		printf("Error: %d bit/pixel bitmaps not supported by U-Boot\n",
1788  			le16_to_cpu(bmp->header.bit_count));
1789  		break;
1790  	}
1791  
1792  #ifdef CONFIG_VIDEO_BMP_GZIP
1793  	if (dst) {
1794  		free(dst);
1795  	}
1796  #endif
1797  
1798  	return (0);
1799  }
1800  #endif
1801  
1802  
1803  #ifdef CONFIG_VIDEO_LOGO
1804  static int video_logo_xpos;
1805  static int video_logo_ypos;
1806  
1807  static void plot_logo_or_black(void *screen, int width, int x, int y,	\
1808  			int black);
1809  
1810  static void logo_plot(void *screen, int width, int x, int y)
1811  {
1812  	plot_logo_or_black(screen, width, x, y, 0);
1813  }
1814  
1815  static void logo_black(void)
1816  {
1817  	plot_logo_or_black(video_fb_address, \
1818  			VIDEO_COLS, \
1819  			video_logo_xpos, \
1820  			video_logo_ypos, \
1821  			1);
1822  }
1823  
1824  static int do_clrlogo(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1825  {
1826  	if (argc != 1)
1827  		return cmd_usage(cmdtp);
1828  
1829  	logo_black();
1830  	return 0;
1831  }
1832  
1833  U_BOOT_CMD(
1834  	   clrlogo, 1, 0, do_clrlogo,
1835  	   "fill the boot logo area with black",
1836  	   " "
1837  	   );
1838  
1839  static void plot_logo_or_black(void *screen, int width, int x, int y, int black)
1840  {
1841  
1842  	int xcount, i;
1843  	int skip = (width - VIDEO_LOGO_WIDTH) * VIDEO_PIXEL_SIZE;
1844  	int ycount = video_logo_height;
1845  	unsigned char r, g, b, *logo_red, *logo_blue, *logo_green;
1846  	unsigned char *source;
1847  	unsigned char *dest;
1848  
1849  #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1850  	if (x == BMP_ALIGN_CENTER)
1851  		x = max(0, (VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH) / 2);
1852  	else if (x < 0)
1853  		x = max(0, VIDEO_VISIBLE_COLS - VIDEO_LOGO_WIDTH + x + 1);
1854  
1855  	if (y == BMP_ALIGN_CENTER)
1856  		y = max(0, (VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT) / 2);
1857  	else if (y < 0)
1858  		y = max(0, VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT + y + 1);
1859  #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1860  
1861  	dest = (unsigned char *)screen + (y * width  + x) * VIDEO_PIXEL_SIZE;
1862  
1863  #ifdef CONFIG_VIDEO_BMP_LOGO
1864  	source = bmp_logo_bitmap;
1865  
1866  	/* Allocate temporary space for computing colormap */
1867  	logo_red = malloc(BMP_LOGO_COLORS);
1868  	logo_green = malloc(BMP_LOGO_COLORS);
1869  	logo_blue = malloc(BMP_LOGO_COLORS);
1870  	/* Compute color map */
1871  	for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1872  		logo_red[i] = (bmp_logo_palette[i] & 0x0f00) >> 4;
1873  		logo_green[i] = (bmp_logo_palette[i] & 0x00f0);
1874  		logo_blue[i] = (bmp_logo_palette[i] & 0x000f) << 4;
1875  	}
1876  #else
1877  	source = linux_logo;
1878  	logo_red = linux_logo_red;
1879  	logo_green = linux_logo_green;
1880  	logo_blue = linux_logo_blue;
1881  #endif
1882  
1883  	if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX) {
1884  		for (i = 0; i < VIDEO_LOGO_COLORS; i++) {
1885  			video_set_lut(i + VIDEO_LOGO_LUT_OFFSET,
1886  				      logo_red[i], logo_green[i],
1887  				      logo_blue[i]);
1888  		}
1889  	}
1890  
1891  	while (ycount--) {
1892  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1893  		int xpos = x;
1894  #endif
1895  		xcount = VIDEO_LOGO_WIDTH;
1896  		while (xcount--) {
1897  			if (black) {
1898  				r = 0x00;
1899  				g = 0x00;
1900  				b = 0x00;
1901  			} else {
1902  				r = logo_red[*source - VIDEO_LOGO_LUT_OFFSET];
1903  				g = logo_green[*source - VIDEO_LOGO_LUT_OFFSET];
1904  				b = logo_blue[*source - VIDEO_LOGO_LUT_OFFSET];
1905  			}
1906  
1907  			switch (VIDEO_DATA_FORMAT) {
1908  			case GDF__8BIT_INDEX:
1909  				*dest = *source;
1910  				break;
1911  			case GDF__8BIT_332RGB:
1912  				*dest = ((r >> 5) << 5) |
1913  					((g >> 5) << 2) |
1914  					 (b >> 6);
1915  				break;
1916  			case GDF_15BIT_555RGB:
1917  #if defined(VIDEO_FB_16BPP_PIXEL_SWAP)
1918  				fill_555rgb_pswap(dest, xpos++, r, g, b);
1919  #else
1920  				*(unsigned short *) dest =
1921  					SWAP16((unsigned short) (
1922  							((r >> 3) << 10) |
1923  							((g >> 3) <<  5) |
1924  							 (b >> 3)));
1925  #endif
1926  				break;
1927  			case GDF_16BIT_565RGB:
1928  				*(unsigned short *) dest =
1929  					SWAP16((unsigned short) (
1930  							((r >> 3) << 11) |
1931  							((g >> 2) <<  5) |
1932  							 (b >> 3)));
1933  				break;
1934  			case GDF_32BIT_X888RGB:
1935  				*(unsigned long *) dest =
1936  					SWAP32((unsigned long) (
1937  							(r << 16) |
1938  							(g <<  8) |
1939  							 b));
1940  				break;
1941  			case GDF_24BIT_888RGB:
1942  #ifdef VIDEO_FB_LITTLE_ENDIAN
1943  				dest[0] = b;
1944  				dest[1] = g;
1945  				dest[2] = r;
1946  #else
1947  				dest[0] = r;
1948  				dest[1] = g;
1949  				dest[2] = b;
1950  #endif
1951  				break;
1952  			}
1953  			source++;
1954  			dest += VIDEO_PIXEL_SIZE;
1955  		}
1956  		dest += skip;
1957  	}
1958  #ifdef CONFIG_VIDEO_BMP_LOGO
1959  	free(logo_red);
1960  	free(logo_green);
1961  	free(logo_blue);
1962  #endif
1963  }
1964  
1965  static void *video_logo(void)
1966  {
1967  	char info[128];
1968  	int space, len;
1969  	__maybe_unused int y_off = 0;
1970  	__maybe_unused ulong addr;
1971  	__maybe_unused char *s;
1972  
1973  #ifdef CONFIG_SPLASH_SCREEN_ALIGN
1974  	s = getenv("splashpos");
1975  	if (s != NULL) {
1976  		if (s[0] == 'm')
1977  			video_logo_xpos = BMP_ALIGN_CENTER;
1978  		else
1979  			video_logo_xpos = simple_strtol(s, NULL, 0);
1980  
1981  		s = strchr(s + 1, ',');
1982  		if (s != NULL) {
1983  			if (s[1] == 'm')
1984  				video_logo_ypos = BMP_ALIGN_CENTER;
1985  			else
1986  				video_logo_ypos = simple_strtol(s + 1, NULL, 0);
1987  		}
1988  	}
1989  #endif /* CONFIG_SPLASH_SCREEN_ALIGN */
1990  
1991  #ifdef CONFIG_SPLASH_SCREEN
1992  	s = getenv("splashimage");
1993  	if (s != NULL) {
1994  
1995  		addr = simple_strtoul(s, NULL, 16);
1996  
1997  
1998  		if (video_display_bitmap(addr,
1999  					video_logo_xpos,
2000  					video_logo_ypos) == 0) {
2001  			video_logo_height = 0;
2002  			return ((void *) (video_fb_address));
2003  		}
2004  	}
2005  #endif /* CONFIG_SPLASH_SCREEN */
2006  
2007  	logo_plot(video_fb_address, VIDEO_COLS,
2008  		  video_logo_xpos, video_logo_ypos);
2009  
2010  #ifdef CONFIG_SPLASH_SCREEN_ALIGN
2011  	/*
2012  	 * when using splashpos for video_logo, skip any info
2013  	 * output on video console if the logo is not at 0,0
2014  	 */
2015  	if (video_logo_xpos || video_logo_ypos) {
2016  		/*
2017  		 * video_logo_height is used in text and cursor offset
2018  		 * calculations. Since the console is below the logo,
2019  		 * we need to adjust the logo height
2020  		 */
2021  		if (video_logo_ypos == BMP_ALIGN_CENTER)
2022  			video_logo_height += max(0, (VIDEO_VISIBLE_ROWS - \
2023  						     VIDEO_LOGO_HEIGHT) / 2);
2024  		else if (video_logo_ypos > 0)
2025  			video_logo_height += video_logo_ypos;
2026  
2027  		return video_fb_address + video_logo_height * VIDEO_LINE_LEN;
2028  	}
2029  #endif
2030  
2031  	sprintf(info, " %s", version_string);
2032  
2033  	space = (VIDEO_LINE_LEN / 2 - VIDEO_INFO_X) / VIDEO_FONT_WIDTH;
2034  	len = strlen(info);
2035  
2036  	if (len > space) {
2037  		video_drawchars(VIDEO_INFO_X, VIDEO_INFO_Y,
2038  				(uchar *) info, space);
2039  		video_drawchars(VIDEO_INFO_X + VIDEO_FONT_WIDTH,
2040  				VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
2041  				(uchar *) info + space, len - space);
2042  		y_off = 1;
2043  	} else
2044  		video_drawstring(VIDEO_INFO_X, VIDEO_INFO_Y, (uchar *) info);
2045  
2046  #ifdef CONFIG_CONSOLE_EXTRA_INFO
2047  	{
2048  		int i, n =
2049  			((video_logo_height -
2050  			  VIDEO_FONT_HEIGHT) / VIDEO_FONT_HEIGHT);
2051  
2052  		for (i = 1; i < n; i++) {
2053  			video_get_info_str(i, info);
2054  			if (!*info)
2055  				continue;
2056  
2057  			len = strlen(info);
2058  			if (len > space) {
2059  				video_drawchars(VIDEO_INFO_X,
2060  						VIDEO_INFO_Y +
2061  						(i + y_off) *
2062  							VIDEO_FONT_HEIGHT,
2063  						(uchar *) info, space);
2064  				y_off++;
2065  				video_drawchars(VIDEO_INFO_X +
2066  						VIDEO_FONT_WIDTH,
2067  						VIDEO_INFO_Y +
2068  							(i + y_off) *
2069  							VIDEO_FONT_HEIGHT,
2070  						(uchar *) info + space,
2071  						len - space);
2072  			} else {
2073  				video_drawstring(VIDEO_INFO_X,
2074  						 VIDEO_INFO_Y +
2075  						 (i + y_off) *
2076  							VIDEO_FONT_HEIGHT,
2077  						 (uchar *) info);
2078  			}
2079  		}
2080  	}
2081  #endif
2082  
2083  	return (video_fb_address + video_logo_height * VIDEO_LINE_LEN);
2084  }
2085  #endif
2086  
2087  static int cfb_fb_is_in_dram(void)
2088  {
2089  	bd_t *bd = gd->bd;
2090  #if defined(CONFIG_ARM) || defined(CONFIG_AVR32) || defined(COFNIG_NDS32) || \
2091  defined(CONFIG_SANDBOX) || defined(CONFIG_X86)
2092  	ulong start, end;
2093  	int i;
2094  
2095  	for (i = 0; i < CONFIG_NR_DRAM_BANKS; ++i) {
2096  		start = bd->bi_dram[i].start;
2097  		end = bd->bi_dram[i].start + bd->bi_dram[i].size - 1;
2098  		if ((ulong)video_fb_address >= start &&
2099  		    (ulong)video_fb_address < end)
2100  			return 1;
2101  	}
2102  #else
2103  	if ((ulong)video_fb_address >= bd->bi_memstart &&
2104  	    (ulong)video_fb_address < bd->bi_memstart + bd->bi_memsize)
2105  		return 1;
2106  #endif
2107  	return 0;
2108  }
2109  
2110  static int video_init(void)
2111  {
2112  	unsigned char color8;
2113  
2114  	pGD = video_hw_init();
2115  	if (pGD == NULL)
2116  		return -1;
2117  
2118  	video_fb_address = (void *) VIDEO_FB_ADRS;
2119  #ifdef CONFIG_VIDEO_HW_CURSOR
2120  	video_init_hw_cursor(VIDEO_FONT_WIDTH, VIDEO_FONT_HEIGHT);
2121  #endif
2122  
2123  	cfb_do_flush_cache = cfb_fb_is_in_dram() && dcache_status();
2124  
2125  	/* Init drawing pats */
2126  	switch (VIDEO_DATA_FORMAT) {
2127  	case GDF__8BIT_INDEX:
2128  		video_set_lut(0x01, CONSOLE_FG_COL, CONSOLE_FG_COL,
2129  			      CONSOLE_FG_COL);
2130  		video_set_lut(0x00, CONSOLE_BG_COL, CONSOLE_BG_COL,
2131  			      CONSOLE_BG_COL);
2132  		fgx = 0x01010101;
2133  		bgx = 0x00000000;
2134  		break;
2135  	case GDF__8BIT_332RGB:
2136  		color8 = ((CONSOLE_FG_COL & 0xe0) |
2137  			  ((CONSOLE_FG_COL >> 3) & 0x1c) |
2138  			  CONSOLE_FG_COL >> 6);
2139  		fgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
2140  			color8;
2141  		color8 = ((CONSOLE_BG_COL & 0xe0) |
2142  			  ((CONSOLE_BG_COL >> 3) & 0x1c) |
2143  			  CONSOLE_BG_COL >> 6);
2144  		bgx = (color8 << 24) | (color8 << 16) | (color8 << 8) |
2145  			color8;
2146  		break;
2147  	case GDF_15BIT_555RGB:
2148  		fgx = (((CONSOLE_FG_COL >> 3) << 26) |
2149  		       ((CONSOLE_FG_COL >> 3) << 21) |
2150  		       ((CONSOLE_FG_COL >> 3) << 16) |
2151  		       ((CONSOLE_FG_COL >> 3) << 10) |
2152  		       ((CONSOLE_FG_COL >> 3) <<  5) |
2153  			(CONSOLE_FG_COL >> 3));
2154  		bgx = (((CONSOLE_BG_COL >> 3) << 26) |
2155  		       ((CONSOLE_BG_COL >> 3) << 21) |
2156  		       ((CONSOLE_BG_COL >> 3) << 16) |
2157  		       ((CONSOLE_BG_COL >> 3) << 10) |
2158  		       ((CONSOLE_BG_COL >> 3) <<  5) |
2159  			(CONSOLE_BG_COL >> 3));
2160  		break;
2161  	case GDF_16BIT_565RGB:
2162  		fgx = (((CONSOLE_FG_COL >> 3) << 27) |
2163  		       ((CONSOLE_FG_COL >> 2) << 21) |
2164  		       ((CONSOLE_FG_COL >> 3) << 16) |
2165  		       ((CONSOLE_FG_COL >> 3) << 11) |
2166  		       ((CONSOLE_FG_COL >> 2) <<  5) |
2167  			(CONSOLE_FG_COL >> 3));
2168  		bgx = (((CONSOLE_BG_COL >> 3) << 27) |
2169  		       ((CONSOLE_BG_COL >> 2) << 21) |
2170  		       ((CONSOLE_BG_COL >> 3) << 16) |
2171  		       ((CONSOLE_BG_COL >> 3) << 11) |
2172  		       ((CONSOLE_BG_COL >> 2) <<  5) |
2173  			(CONSOLE_BG_COL >> 3));
2174  		break;
2175  	case GDF_32BIT_X888RGB:
2176  		fgx =	(CONSOLE_FG_COL << 16) |
2177  			(CONSOLE_FG_COL <<  8) |
2178  			 CONSOLE_FG_COL;
2179  		bgx =	(CONSOLE_BG_COL << 16) |
2180  			(CONSOLE_BG_COL <<  8) |
2181  			 CONSOLE_BG_COL;
2182  		break;
2183  	case GDF_24BIT_888RGB:
2184  		fgx =	(CONSOLE_FG_COL << 24) |
2185  			(CONSOLE_FG_COL << 16) |
2186  			(CONSOLE_FG_COL <<  8) |
2187  			 CONSOLE_FG_COL;
2188  		bgx =	(CONSOLE_BG_COL << 24) |
2189  			(CONSOLE_BG_COL << 16) |
2190  			(CONSOLE_BG_COL <<  8) |
2191  			 CONSOLE_BG_COL;
2192  		break;
2193  	}
2194  	eorx = fgx ^ bgx;
2195  
2196  #ifdef CONFIG_VIDEO_LOGO
2197  	/* Plot the logo and get start point of console */
2198  	debug("Video: Drawing the logo ...\n");
2199  	video_console_address = video_logo();
2200  #else
2201  	video_console_address = video_fb_address;
2202  #endif
2203  
2204  	/* Initialize the console */
2205  	console_col = 0;
2206  	console_row = 0;
2207  
2208  	return 0;
2209  }
2210  
2211  /*
2212   * Implement a weak default function for boards that optionally
2213   * need to skip the video initialization.
2214   */
2215  int __board_video_skip(void)
2216  {
2217  	/* As default, don't skip test */
2218  	return 0;
2219  }
2220  
2221  int board_video_skip(void)
2222  	__attribute__ ((weak, alias("__board_video_skip")));
2223  
2224  int drv_video_init(void)
2225  {
2226  	int skip_dev_init;
2227  	struct stdio_dev console_dev;
2228  
2229  	/* Check if video initialization should be skipped */
2230  	if (board_video_skip())
2231  		return 0;
2232  
2233  	/* Init video chip - returns with framebuffer cleared */
2234  	skip_dev_init = (video_init() == -1);
2235  
2236  #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
2237  	debug("KBD: Keyboard init ...\n");
2238  	skip_dev_init |= (VIDEO_KBD_INIT_FCT == -1);
2239  #endif
2240  
2241  	if (skip_dev_init)
2242  		return 0;
2243  
2244  	/* Init vga device */
2245  	memset(&console_dev, 0, sizeof(console_dev));
2246  	strcpy(console_dev.name, "vga");
2247  	console_dev.ext = DEV_EXT_VIDEO;	/* Video extensions */
2248  	console_dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_SYSTEM;
2249  	console_dev.putc = video_putc;	/* 'putc' function */
2250  	console_dev.puts = video_puts;	/* 'puts' function */
2251  	console_dev.tstc = NULL;	/* 'tstc' function */
2252  	console_dev.getc = NULL;	/* 'getc' function */
2253  
2254  #if !defined(CONFIG_VGA_AS_SINGLE_DEVICE)
2255  	/* Also init console device */
2256  	console_dev.flags |= DEV_FLAGS_INPUT;
2257  	console_dev.tstc = VIDEO_TSTC_FCT;	/* 'tstc' function */
2258  	console_dev.getc = VIDEO_GETC_FCT;	/* 'getc' function */
2259  #endif /* CONFIG_VGA_AS_SINGLE_DEVICE */
2260  
2261  	if (stdio_register(&console_dev) != 0)
2262  		return 0;
2263  
2264  	/* Return success */
2265  	return 1;
2266  }
2267  
2268  void video_position_cursor(unsigned col, unsigned row)
2269  {
2270  	console_col = min(col, CONSOLE_COLS - 1);
2271  	console_row = min(row, CONSOLE_ROWS - 1);
2272  }
2273  
2274  int video_get_pixel_width(void)
2275  {
2276  	return VIDEO_VISIBLE_COLS;
2277  }
2278  
2279  int video_get_pixel_height(void)
2280  {
2281  	return VIDEO_VISIBLE_ROWS;
2282  }
2283  
2284  int video_get_screen_rows(void)
2285  {
2286  	return CONSOLE_ROWS;
2287  }
2288  
2289  int video_get_screen_columns(void)
2290  {
2291  	return CONSOLE_COLS;
2292  }
2293  
2294  void video_clear(void)
2295  {
2296  	if (!video_fb_address)
2297  		return;
2298  #ifdef VIDEO_HW_RECTFILL
2299  	video_hw_rectfill(VIDEO_PIXEL_SIZE,	/* bytes per pixel */
2300  			  0,			/* dest pos x */
2301  			  0,			/* dest pos y */
2302  			  VIDEO_VISIBLE_COLS,	/* frame width */
2303  			  VIDEO_VISIBLE_ROWS,	/* frame height */
2304  			  bgx			/* fill color */
2305  	);
2306  #else
2307  	memsetl(video_fb_address,
2308  		(VIDEO_VISIBLE_ROWS * VIDEO_LINE_LEN) / sizeof(int), bgx);
2309  #endif
2310  }
2311