add framebuffer/IrDA Keyboard support for Shannon (Tuxscreen)

diff --git a/CHANGELOG b/CHANGELOG
index cc2607935f2de4510cda4a46e564d79ef00ae47c..e344b240c55ec764d9c3185c41ff31166f02da97 100644 (file)
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -2,6 +2,10 @@
 Recent Modifications
 ======================================================================
 
+* Patch by Robert Kaiser <rob@sysgo.de>:
+
+  - add framebuffer/IrDA Keyboard support for Shannon (Tuxscreen)
+
 * Patch by Robert Kaiser <rob@sysgo.de>:
 
   - flush caches before executing code that may have been downloaded

diff --git a/Makefile b/Makefile
index 7dd833f37abeaa4c72ce285e3043241b8e1814be..0ab1d4cfee366c751c0a858dc268deabaf601862 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -80,6 +80,9 @@ OBJS +=       drivers/libdrivers.a
 # by the other libraries
 OBJS +=        common/libcommon.a
 
+# include board library unce again (circular references)
+OBJS +=        board/$(BOARDDIR)/lib$(BOARD).a
+
 #########################################################################
 
 all:           armboot.srec armboot.hex armboot.bin

diff --git a/board/shannon/Makefile b/board/shannon/Makefile
index 56105d36a9aa46a7d3285e6fac3bf36c158920e5..72ffa5d129311ad33913039aa42d599e4e3c866c 100644 (file)
--- a/board/shannon/Makefile
+++ b/board/shannon/Makefile
@@ -25,7 +25,7 @@ include $(TOPDIR)/config.mk
 
 LIB    = lib$(BOARD).a
 
-OBJS   := shannon.o flash.o env.o
+OBJS   := shannon.o flash.o env.o video.o irkbd.o kbd_map.o
 SOBJS  := memsetup.o
 
 $(LIB):        $(OBJS) $(SOBJS)

diff --git a/board/shannon/README.Install b/board/shannon/README.Install
new file mode 100644 (file)
index 0000000..18a594d
--- /dev/null
+++ b/board/shannon/README.Install
@@ -0,0 +1,121 @@
+#
+# (C) Copyright 2002
+# SYSGO Real-Time Solutions GmbH
+#
+# http://www.sysgo.de
+# http://www.elinos.com
+#
+# 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
+
+
+Installing ARMboot on the Shannon (aka Tuxscreen)
+=================================================
+
+1. Building ARMboot
+-------------------
+
+Please refer to the  top level README file for instructions on how to build
+ARMboot for any of the supported boards. For the Shannon board, there are
+some additional options that are discussed here:
+
+1.1. Frame buffer support
+
+ARMboot can now use the Shannon's LCD screen for console messages. There
+are two different drivers that can be used:
+
+ansi_console: This is a generic ANSI terminal emulation. It understands the
+usual escape codes and is quite versatile in that it can be used with different
+fonts (though the distribution contains only one).
+
+cfb_console:  A simple teletype-style terminal. It does not interpret escape
+codes, but it has a fancy Linux penguin logo option.
+
+Which one you choose depends on your taste ;-). By default, ansi_console
+is configured. To change to cfb_console, undefine CONFIG_ANSI_CONSOLE 
+in the shannon config file (include/configs/config_shannon.h) and define
+CONFIG_CFB_CONSOLE, then recompile.
+
+If you do not want framebuffer support, undefine both CONFIG_ANSI_CONSOLE
+and CONFIG_CFB_CONSOLE.
+
+
+1.2. IrDA keyboard support
+
+ARMboot can now use the Shannon's IrDA keyboard for console input.
+This is enabled by options CONFIG_KEYBOARD and CONFIG_KEYBOARD_IRDA
+in the shannon config file. The keyboard driver has the theoretical
+possiblity to switch between different keyboard mappings by setting
+the environment variable "keymap" to, e.g. "us", "de", "fr", etc.
+however, since -to my knowledge- there exist only "us"-Type keyboards
+for the Shannon, the keyboard map table (board/shannon/kbd_map.c)
+contains only a single mapping.
+
+If you do not want IrDA keyboard support, undefine both CONFIG_KEYBOARD
+and CONFIG_KEYBOARD_IRDA.
+
+2. Installing ARMboot on the Shannon
+------------------------------------
+
+ARMboot expects to be loaded by the Inferno bootloader. To make this
+happen, you must put the ARMboot binary in the board's flash and you
+must convert into a format suitable for Inferno. Specifically, the image
+must be preceeded by an Inferno-specific header and the whole image
+(header + ARMboot) must be compressed with gzip. The Inferno header
+is distributed with ARMboot under board/shannon/inferno.header.
+Thus, to obtain an inferno-bootable ARMboot image, run a command like
+this:
+
+    cat board/shannon/inferno.header armboot.bin|gzip> armboot.i
+
+To install Armboot in flash, you need the Inferno tools that you can
+download from:
+
+- Unpack the Inferno tools into a directory (e.g. /home/inferno).
+- Copy the armboot.i file into that directory
+- Make sure you have read/write access to your system's first serial port.
+- Connect the Shannon board's serial port to your host's serial port
+  with a so-called "nullmodem cable".
+- enter the commands:
+
+   export EMU="-r<Directory where you put Inferno>"
+   ./Linux/386/bin/emu
+
+The Inferno shell starts up and you should see it's prompt (";").
+Enter:
+
+       bind -a '#t' /dev
+       rdp -s38400 -r
+
+Now reset your Shannon, when the splash screen comes up, enter ESC and
+then CTRL+A. This should put the board into remote debug mode and the
+Inferno shell should indicate that it has a connection.
+
+By entering "c F!kern2 D!backup" you can save the contents of flash
+partition "kern2" (this is the one we are going to overwrite) into
+a file named "backup". Then, by entering "c S:armboot.i F!kern2" you
+install ARMboot in that partition. This takes a while (you can watch
+the download progress on the Shannon's screen). When done, disconnect
+the power supply from your Shannon (there seems to be no other way out
+of remote debug mode).
+
+Now, when you turn your Shannon back on, hit ESC when the spash screen
+comes up. Then enter CTRL+P. This will bring you into the Inferno monitor.
+From there, enter "B F!kern2" to invoke ARMboot.
+
+

diff --git a/board/shannon/irkbd.c b/board/shannon/irkbd.c
new file mode 100644 (file)
index 0000000..f06eae2
--- /dev/null
+++ b/board/shannon/irkbd.c
@@ -0,0 +1,94 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+#include "config.h"
+
+#ifdef CONFIG_KEYBOARD
+
+
+/*
+** Keyboard low-level driver for Shannon (AKA Tuxscreen)
+** infrared keyboard port
+*/
+
+#include "SA-1100.h"
+
+/*
+ * Initialise the infrared port
+ *
+ */
+void irkbd_init(void)
+{
+       /*
+        * Enable NRZ modulation, and ensure that the port is disabled.
+        */
+       Ser2UTCR3 = 0;
+       Ser2HSCR0 &= ~HSCR0_HSSP;
+
+       /* clear status register to prevent unwanted interrupts */
+       Ser2UTSR0 &= UTSR0_RID | UTSR0_RBB | UTSR0_REB;
+
+       /* 8O1 */
+       Ser2UTCR0 = UTCR0_8BitData | UTCR0_PE | UTCR0_OddPar | UTCR0_1StpBit;
+
+       /* 1266 baud */
+       Ser2UTCR1 = 0;
+       Ser2UTCR2 = 0xb5;
+
+       Ser2UTCR4 = UTCR4_NRZ;
+       Ser2HSCR2 = HSCR2_RcDataH | HSCR2_TrDataH;
+
+       /* enable receiver, disable receive fifo interrupt */
+       Ser2UTCR3 = UTCR3_RXE;
+
+       /* clear status register to prevent unwanted interrupts */
+       Ser2UTSR0 &= UTSR0_RID | UTSR0_RBB | UTSR0_REB;
+}
+
+/*
+ * See if there is a character available from the keyboard
+ *
+ */
+int irkbd_tstc(void)
+{
+       return(Ser2UTSR1 & UTSR1_RNE);
+}
+
+/*
+ * Read a single byte from the infrared keyboard. Returns 1 on success, 0
+ * otherwise. When the function is successful, the character read is
+ * written into its argument c.
+ */
+int irkbd_getc(void)
+{
+       int status;
+       while(!((status = Ser2UTSR1)) & UTSR1_RNE)
+       {
+               if(status & (UTSR1_FRE | UTSR1_ROR | UTSR1_PRE))
+                       return(-1);
+       }
+       return(Ser2UTDR & 0xff);
+}
+
+#endif /* CONFIG_KEYBOARD */

diff --git a/board/shannon/kbd_map.c b/board/shannon/kbd_map.c
new file mode 100644 (file)
index 0000000..0bf4c7b
--- /dev/null
+++ b/board/shannon/kbd_map.c
@@ -0,0 +1,415 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+#include "config.h"
+
+
+#ifdef CONFIG_KEYBOARD
+
+
+#include "keyboard.h"
+
+/*
+** Keyboard map for Shannon (aka Tuxscreen) infrared keyboard
+*/
+
+/*
+** Status translation table
+**
+** Used to combine the status of the left & right shift, control
+** and alt keys (6 keys) into a 3 bit value determining the logical
+** status of shift, control and alt:
+*/
+static const unsigned char T_STATETRANS[] =
+{              /*  SAC  rs ls ra la rc lc */
+       0,      /* %000   -  -  -  -  -  - */
+       1,      /* %001   -  -  -  -  -  + */
+       1,      /* %001   -  -  -  -  +  - */
+       1,      /* %001   -  -  -  -  +  + */
+       2,      /* %010   -  -  -  +  -  - */
+       3,      /* %011   -  -  -  +  -  + */
+       3,      /* %011   -  -  -  +  +  - */
+       3,      /* %011   -  -  -  +  +  + */
+       2,      /* %010   -  -  +  -  -  - */
+       3,      /* %011   -  -  +  -  -  + */
+       3,      /* %011   -  -  +  -  +  - */
+       3,      /* %011   -  -  +  -  +  + */
+       2,      /* %010   -  -  +  +  -  - */
+       3,      /* %011   -  -  +  +  -  + */
+       3,      /* %011   -  -  +  +  +  - */
+       3,      /* %011   -  -  +  +  +  + */
+       4,      /* %100   -  +  -  -  -  - */
+       5,      /* %101   -  +  -  -  -  + */
+       5,      /* %101   -  +  -  -  +  - */
+       5,      /* %101   -  +  -  -  +  + */
+       6,      /* %110   -  +  -  +  -  - */
+       7,      /* %111   -  +  -  +  -  + */
+       7,      /* %111   -  +  -  +  +  - */
+       7,      /* %111   -  +  -  +  +  + */
+       6,      /* %110   -  +  +  -  -  - */
+       7,      /* %111   -  +  +  -  -  + */
+       7,      /* %111   -  +  +  -  +  - */
+       7,      /* %111   -  +  +  -  +  + */
+       6,      /* %110   -  +  +  +  -  - */
+       7,      /* %111   -  +  +  +  -  + */
+       7,      /* %111   -  +  +  +  +  - */
+       7,      /* %111   -  +  +  +  +  + */
+       4,      /* %100   +  -  -  -  -  - */
+       5,      /* %101   +  -  -  -  -  + */
+       5,      /* %101   +  -  -  -  +  - */
+       5,      /* %101   +  -  -  -  +  + */
+       6,      /* %110   +  -  -  +  -  - */
+       7,      /* %111   +  -  -  +  -  + */
+       7,      /* %111   +  -  -  +  +  - */
+       7,      /* %111   +  -  -  +  +  + */
+       6,      /* %110   +  -  +  -  -  - */
+       7,      /* %111   +  -  +  -  -  + */
+       7,      /* %111   +  -  +  -  +  - */
+       7,      /* %111   +  -  +  -  +  + */
+       6,      /* %110   +  -  +  +  -  - */
+       7,      /* %111   +  -  +  +  -  + */
+       7,      /* %111   +  -  +  +  +  - */
+       7,      /* %111   +  -  +  +  +  + */
+       4,      /* %100   +  +  -  -  -  - */
+       5,      /* %101   +  +  -  -  -  + */
+       5,      /* %101   +  +  -  -  +  - */
+       5,      /* %101   +  +  -  -  +  + */
+       6,      /* %110   +  +  -  +  -  - */
+       7,      /* %111   +  +  -  +  -  + */
+       7,      /* %111   +  +  -  +  +  - */
+       7,      /* %111   +  +  -  +  +  + */
+       6,      /* %110   +  +  +  -  -  - */
+       7,      /* %111   +  +  +  -  -  + */
+       7,      /* %111   +  +  +  -  +  - */
+       7,      /* %111   +  +  +  -  +  + */
+       6,      /* %110   +  +  +  +  -  - */
+       7,      /* %111   +  +  +  +  -  + */
+       7,      /* %111   +  +  +  +  +  - */
+       7       /* %111   +  +  +  +  +  + */
+};
+
+/*
+** Compose Table:
+**
+** This allows to enter characters from the international character set.
+**
+** for instance: entering <Compose-key>-'a'-'"' will issue 'ä'.
+**
+** The following table contains one entry for each possible compose
+** character with the two characters it is composed from:
+*/
+const static struct compose_char T_COMPOSE[] =
+{
+   {{'!','!'}, 0xa1},
+   {{'c','/'}, 0xa2},
+   {{'C','/'}, 0xa2},
+   {{'l','-'}, 0xa3},
+   {{'L','-'}, 0xa3},
+   {{'y','='}, 0xa5},
+   {{'Y','='}, 0xa5},
+   {{'s','o'}, 0xa7},
+   {{'S','o'}, 0xa7},
+   {{'s','O'}, 0xa7},
+   {{'S','O'}, 0xa7},
+   {{'x','o'}, 0xa8},
+   {{'X','o'}, 0xa8},
+   {{'x','O'}, 0xa8},
+   {{'X','O'}, 0xa8},
+   {{'c','o'}, 0xa9},
+   {{'C','o'}, 0xa9},
+   {{'c','O'}, 0xa9},
+   {{'C','O'}, 0xa9},
+   {{'a','_'}, 0xaa},
+   {{'A','_'}, 0xaa},
+   {{'<','<'}, 0xab},
+   {{'0','^'}, 0xb0},
+   {{'+','-'}, 0xb1},
+   {{'^','2'}, 0xb2},
+   {{'^','3'}, 0xb3},
+   {{'/','u'}, 0xb5},
+   {{'p','!'}, 0xb6},
+   {{'P','!'}, 0xb6},
+   {{'^','.'}, 0xb7},
+   {{'^','1'}, 0xb9},
+   {{'o','_'}, 0xba},
+   {{'O','_'}, 0xba},
+   {{'>','>'}, 0xbb},
+   {{'1','4'}, 0xbc},
+   {{'1','2'}, 0xbd},
+   {{'?','?'}, 0xbf},
+   {{'A','`'}, 0xc0},
+   {{'A','\''}, 0xc1},
+   {{'A','^'}, 0xc2},
+   {{'A','~'}, 0xc3},
+   {{'A','"'}, 0xc4},
+   {{'A','*'}, 0xc5},
+   {{'A','E'}, 0xc6},
+   {{'a','E'}, 0xc6},
+   {{'C',','}, 0xc7},
+   {{'E','`'}, 0xc8},
+   {{'E','\''}, 0xc9},
+   {{'E','"'}, 0xcb},
+   {{'I','`'}, 0xcc},
+   {{'I','\''}, 0xcd},
+   {{'I','^'}, 0xce},
+   {{'I','"'}, 0xcf},
+   {{'N','~'}, 0xd1},
+   {{'O','`'}, 0xd2},
+   {{'O','\''}, 0xd3},
+   {{'O','^'}, 0xd4},
+   {{'O','~'}, 0xd5},
+   {{'O','"'}, 0xd6},
+   {{'O','E'}, 0xd7},
+   {{'o','E'}, 0xf7},
+   {{'O','/'}, 0xd8},
+   {{'U','`'}, 0xd9},
+   {{'U','\''}, 0xda},
+   {{'U','^'}, 0xdb},
+   {{'U','"'}, 0xdc},
+   {{'Y','"'}, 0xdd},
+   {{'s','s'}, 0xdf},
+   {{'S','s'}, 0xdf},
+   {{'s','S'}, 0xdf},
+   {{'S','S'}, 0xdf},
+   {{'a','`'}, 0xe0},
+   {{'a','\''}, 0xe1},
+   {{'a','^'}, 0xe2},
+   {{'a','~'}, 0xe3},
+   {{'a','"'}, 0xe4},
+   {{'a','*'}, 0xe5},
+   {{'a','e'}, 0xe6},
+   {{'A','e'}, 0xe6},
+   {{'c',','}, 0xe7},
+   {{'e','`'}, 0xe8},
+   {{'e','\''}, 0xe9},
+   {{'e','"'}, 0xeb},
+   {{'i','`'}, 0xec},
+   {{'i','\''}, 0xed},
+   {{'i','^'}, 0xee},
+   {{'i','"'}, 0xef},
+   {{'n','~'}, 0xf1},
+   {{'o','`'}, 0xf2},
+   {{'o','\''}, 0xf3},
+   {{'o','^'}, 0xf4},
+   {{'o','~'}, 0xf5},
+   {{'o','"'}, 0xf6},
+   {{'o','e'}, 0xf7},
+   {{'O','e'}, 0xf7},
+   {{'o','/'}, 0xf8},
+   {{'u','`'}, 0xf9},
+   {{'u','\''}, 0xfa},
+   {{'u','^'}, 0xfb},
+   {{'u','"'}, 0xfc},
+   {{'y','"'}, 0xfd},
+   {{'+','+'}, '#'},
+   {{'a','a'}, '@'},
+   {{'a','A'}, '@'},
+   {{'A','a'}, '@'},
+   {{'A','A'}, '@'},
+   {{'(','('}, '['},
+   {{'/','/'}, 0x5c},
+   {{')',')'}, ']'},
+   {{'-','('}, '{'},
+   {{'/','^'}, '|'},
+   {{')','-'}, '}'},
+   {{'^',' '}, '^'},
+   {{'^','^'}, '^'},
+   {{'\'',' '}, '\''},
+   {{'\'','\''}, '\''},
+   {{'`',' '}, '`'},
+   {{'`','`'}, '`'},
+   {{0,0}, 0},  /* Endmarker!!! */
+};
+
+/*
+** String definitions for sequence keys:
+**
+** NOTE: if the byte after the null-terminator is non-zero, it
+**       is the alternate code issued by that key when the
+**       keyboard is in numlock state.
+**
+**
+** The strings defined here are appropriate for a DEC vt-220-type
+** keyboard. Alternate numlock codes are assigned where useful.
+*/
+const static char _CUP[] = {'\033','[','A','\000','\000'};/* Cursor up, down, left, right */
+const static char _CDW[] = {'\033','[','B','\000','\000'};
+const static char _CRT[] = {'\033','[','C','\000','\000'};
+const static char _CLF[] = {'\033','[','D','\000','\000'};
+
+const static char _F1[] = {'\033','[','2','~','\000','\000'}; /* F1: Insert Here */
+const static char _F2[] = {'\033','[','3','~','\000','\000'}; /* F2: Remove */
+const static char _F3[] = {'\033','[','4','~','\000','\000'}; /* F3: Select */
+const static char _F4[] = {'\033','[','5','~','\000','\000'}; /* F4: Prev. Screen */
+const static char _F5[] = {'\033','[','6','~','\000','\000'}; /* F5: Next Screen */
+const static char _F6[] = {'\033','[','1','7','~','\000','\000'}; /* F6 */
+const static char _F7[] = {'\033','[','1','8','~','\000','\000'}; /* F7 */
+const static char _F8[] = {'\033','[','1','9','~','\000','\000'}; /* F8 */
+const static char _F9[] = {'\033','[','2','0','~','\000','\000'}; /* F9 */
+const static char _F10[] = {'\033','[','2','1','~','\000','\000'}; /* F10 */
+const static char _F11[] = {'\033','[','2','3','~','\000','\033'}; /* F11 <ESC> */
+const static char _F12[] = {'\033','[','2','4','~','\000', 0x08 }; /* F12: <BS> */
+const static char _F13[] = {'\033','[','2','5','~','\000','\012'}; /* F13: <LF> */
+
+const unsigned char * const T_SEQSTRING[] =
+{
+       _CUP,   _CDW,   _CRT,   _CLF,   _F1,    _F2,    _F3,    _F4,
+       _F5,    _F6,    _F7,    _F8,    _F9,    _F10,   _F11,   _F12,   _F13
+};
+
+#define _CUP_Index     0
+#define _CDW_Index     1
+#define _CRT_Index     2
+#define _CLF_Index     3
+#define _F1_Index      4
+#define _F2_Index      5
+#define _F3_Index      6
+#define _F4_Index      7
+#define _F5_Index      8
+#define _F6_Index      9
+#define _F7_Index     10
+#define _F8_Index     11
+#define _F9_Index     12
+#define _F10_Index    13
+#define _F11_Index    14
+#define _F12_Index    15
+#define _F13_Index    16
+
+#define CUP SKEY(_CUP_Index)    /* Cursor up, down, left, right  */
+#define CDW SKEY(_CDW_Index)
+#define CRT SKEY(_CRT_Index)
+#define CLF SKEY(_CLF_Index)
+#define F01 SKEY(_F1_Index)     /* F1: Insert Here */
+#define F02 SKEY(_F2_Index)     /* F2: Remove */
+#define F03 SKEY(_F3_Index)     /* F2: Select */
+#define F04 SKEY(_F4_Index)     /* F3: Prev. Screen */
+#define F05 SKEY(_F5_Index)     /* F4: Next Screen */
+#define F06 SKEY(_F6_Index)     /* F6 */
+#define F07 SKEY(_F7_Index)     /* F7 */
+#define F08 SKEY(_F8_Index)     /* F8 */
+#define F09 SKEY(_F9_Index)     /* F9 */
+#define F10 SKEY(_F10_Index)    /* F10 */
+#define F11 SKEY(_F11_Index)    /* F11: <ESC> */
+#define F12 SKEY(_F12_Index)    /* F12: <BS> */
+#define F13 SKEY(_F13_Index)    /* F13: <LF> */
+
+#define NUL    0x00
+#define SDW    0x00
+#define SUP    0x00
+#define PSC    0x00
+#define CSR    0x00
+#define HOM    0x00
+#define PGU    0x00
+#define PGD    0x00
+#define END    0x00
+#define SDW    0x00
+
+/* Some links, to get same addresses for different lables */
+#define T_S_C T___C
+#define T__AC T___C
+#define T_SAC T___C
+#define T_SA_ T___C
+#define T__A_ T___C
+
+
+const static unsigned short T____[] =
+{
+/*
+** Conversion table for no control, shift, alt or prefix
+**
+**     0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
+*/
+       NUL,NUL,NUL,NUL,SDW,NUL,NUL,NUL,NUL,CPL,'x',F05,F01,'2','s','w',
+       NUL,F03,'c',F04,F02,'3','d','e',LAL,TAB,'z',ESC,LCT,'1','a','q',
+       'b','t','v','g','5','4','f','r',RAL,SUP,NUL,CMP,NUL,PSC,NUL,NML,
+       NUL,LSH,RSH,NUL,NUL,NUL,NUL,NUL,SPC,BSP,ENT,F06,F09,F10,'\\',NUL,
+       NUL,NUL,NUL,NUL,NUL,NUL,NUL,NUL,CLF,NUL,CSR,CUP,HOM,NUL,PGU,NUL,
+       CDW,NUL,F13,NUL,RCT,F11,PGD,NUL,CRT,NUL,NUL,END,'`',F12,NUL,NUL,
+       NUL,F07,'.',NUL,F08,'9','l','o','/','[',NUL,'\'','-','0',';','p',
+       NUL,']',',',NUL,'=','8','k','i','n','y','m','h','6','7','j','u'
+};
+
+const static unsigned short T_S__[] =
+{
+/*
+** Conversion table for shift
+**  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
+**
+*/
+       NUL,NUL,NUL,NUL,SDW,NUL,NUL,NUL,NUL,CPL,'X',F05,F01,'@','S','W',
+       NUL,F03,'C',F04,F02,'#','D','E',LAL,TAB,'Z',ESC,LCT,'!','A','Q',
+       'B','T','V','G','%','$','F','R',RAL,SUP,NUL,CMP,NUL,PSC,NUL,NML,
+       NUL,LSH,RSH,NUL,NUL,NUL,NUL,NUL,SPC,BSP,ENT,F06,F09,F10,'|',NUL,
+       NUL,NUL,NUL,NUL,NUL,NUL,NUL,NUL,CLF,NUL,CSR,CUP,HOM,NUL,PGU,NUL,
+       CDW,NUL,F13,NUL,RCT,F11,PGD,NUL,CRT,NUL,NUL,END,'~',F12,NUL,NUL,
+       NUL,F07,'>',NUL,F08,'(','L','O','?','{',NUL,'\"','_',')',':','P',
+       NUL,'}','<',NUL,'+','*','K','I','N','Y','M','H','^','&','J','U'
+};
+
+const static unsigned short T___C[] = /* T__S_C[] = T___AC[] = T__SAC[], */
+{                  /* T__A_[] = T__SA_[] linked by #defines above        */
+/*
+** Conversion table for control, control-shift, control-alt
+** control-shift-alt, alt and shift-alt
+**
+**  0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f
+*/
+       NUL,NUL,NUL,NUL,SDW,NUL,NUL,NUL,NUL,CPL,0x18,F05,F01,0x00,0x13,0x17,
+       NUL,F03,0x03,F04,F02,'3',0x04,0x05,LAL,TAB,0x1a,ESC,LCT,'1',0x01,0x11,
+       0x02,0x14,0x16,0x07,'5','4',0x06,0x12,RAL,SUP,NUL,CMP,NUL,PSC,NUL,NML,
+       NUL,LSH,RSH,NUL,NUL,NUL,NUL,NUL,SPC,BSP,ENT,F06,F09,F10,0x1c,NUL,
+       NUL,NUL,NUL,NUL,NUL,NUL,NUL,NUL,CLF,NUL,CSR,CUP,HOM,NUL,PGU,NUL,
+       CDW,NUL,F13,NUL,RCT,F11,PGD,NUL,CRT,NUL,NUL,END,0x1e,F12,NUL,NUL,
+       NUL,F07,',',NUL,F08,'9',0x0c,0x0f,'/',0x1b,NUL,'\'',0x1f,'0',';',0x10,
+       NUL,0x1d,'.',NUL,'=','8',0x0b,0x09,0x0e,0x19,0x0d,0x08,'6','7',0x0a,0x15
+};
+
+const struct keyboardmap kbd_header =
+{
+       128,                                    /* convtabsize */
+       0x94,                                   /* makecode    */
+       0xd4,                                   /* breakcode   */
+       0xffffffff,                             /* mkbrkmask   */
+       &T_STATETRANS[0],               /* statustable */
+       {                                               /* convtables  */
+                               /* Shift, Alt, Control  */
+               T____,  /*   -     -     -      */
+               T___C,  /*   -     -     +      */
+               T__A_,  /*   -     +     -      */
+               T__AC,  /*   -     +     +      */
+               T_S__,  /*   +     -     -      */
+               T_S_C,  /*   +     -     +      */
+               T_SA_,  /*   +     +     -      */
+               T_SAC,  /*   +     +     +      */
+       },
+       &T_SEQSTRING[0],                /* seqstring    */
+    &T_COMPOSE[0]                      /* composetable */
+};
+
+const struct maptable kbd_mapping_table[] =
+{
+       { "us", &kbd_header },  /* shannon only has a single mapping (us) */
+       { 0, 0 }                                /* end marker !! */
+};
+
+#endif /* CONFIG_KEYBOARD */

diff --git a/board/shannon/video.c b/board/shannon/video.c
new file mode 100644 (file)
index 0000000..cf4adc5
--- /dev/null
+++ b/board/shannon/video.c
@@ -0,0 +1,126 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+/*
+** Shannon specific support routines for framebuffer driver
+*/
+
+#include "config.h"
+#include <shannon_video.h>
+
+/*
+************************************************************
+** Access the color lookup table
+************************************************************
+*/
+
+#if defined (CONFIG_CFB_CONSOLE) || defined(CONFIG_FRAMEBUFFER_CLUT)
+void video_set_lut(
+       unsigned int index,     /* color number */
+       unsigned char r,        /* red */
+       unsigned char g,        /* green */
+       unsigned char b)        /* blue */
+{
+       video_lut_entry *entry;
+
+       /*
+       ** color values are passed as 8-bit values, scale them
+       ** down to 4-bit
+       */
+       r >>= 4;
+       g >>= 4;
+       b >>= 4;
+
+       r &= COL_MASK;
+       g &= COL_MASK;
+       b &= COL_MASK;
+
+       /* set the entry, leave for MS bits intact */
+       entry = (video_lut_entry*)LCD_LUT_ADDR + index;
+       *entry = (*entry & ~RGB_MASK) | (r << R_SHIFT) | (g << G_SHIFT) | (b << B_SHIFT);
+}
+#endif
+
+
+/*
+************************************************************
+** Initialize video hardware
+************************************************************
+*/
+
+/*
+** Actually, we don't initialize hardware here -- We rely on
+** the Inferno firmware having done this already. All we do
+** here is to set the color lookup table such that we get
+** sane colors for black and white, and we clear the screen.
+*/
+
+#ifdef CONFIG_CFB_CONSOLE
+
+/*
+** This is the init function required for the cfb_console driver
+*/
+void *video_hw_init(void)
+{
+       int   cnt;
+       unsigned long *p = (unsigned long*)LCD_VIDEO_ADDR;
+
+       /* set lookup table for black and white */
+       video_set_lut(0, 0, 0, 0);
+       video_set_lut(1, 0xff, 0xff, 0xff);
+
+       /* clear the framebuffer memory */
+       for(cnt = 0; cnt < LCD_VIDEO_SIZE; cnt++)
+               *p++ = 0;
+
+       return (void*)LCD_VIDEO_ADDR;
+}
+#endif /* CONFIG_CFB_CONSOLE */
+
+
+#ifdef CONFIG_FRAMEBUFFER
+
+/*
+** This is the init function required for the framebuffer driver
+*/
+void *video_framebuffer_init(
+       unsigned int *ax,
+       unsigned int *ay,
+       unsigned int *pitch,
+       unsigned int *fcol,
+       unsigned int *bcol)
+{
+       /*
+       ** just deliver the required infomation to the caller
+       */
+       *ax    = LCD_VIDEO_COLS;
+       *ay    = LCD_VIDEO_ROWS;
+
+       *pitch = LCD_VIDEO_COLS;/* address offset between vertically adjacent pixels */
+       *fcol  = 0x00;                  /* these colors are also used by the Inferno firmware */
+       *bcol  = 0xc9;
+       return (void*)LCD_VIDEO_ADDR;
+}
+#endif /* CONFIG_FRAMEBUFFER */
+

diff --git a/common/board.c b/common/board.c
index 030588b7cf261a074476bf93b3ea1b0e3aa55e61..d1d502f17565e690b4f492a2cf8a3993eddbcf07 100644 (file)
--- a/common/board.c
+++ b/common/board.c
@@ -99,6 +99,18 @@ void start_armboot(void)
     /* serial communications setup */
     serial_init(&bd);
 
+#ifdef CONFIG_ANSI_CONSOLE
+       ansi_console_init();
+#endif
+
+#ifdef CONFIG_CFB_CONSOLE
+       video_init();
+#endif
+
+#ifdef CONFIG_KEYBOARD
+       kbd_init(&bd);
+#endif
+
     display_banner(&bd);
 
     /* set up execptions */

diff --git a/common/cmd_boot.c b/common/cmd_boot.c
index 9ef8c8fe51303811953cdb9d0d2a7e32c35609bf..f725b8629d6ba522256dd7189f12df96ab2a7451 100644 (file)
--- a/common/cmd_boot.c
+++ b/common/cmd_boot.c
@@ -215,11 +215,15 @@ load_serial (ulong offset)
        ulong   start_addr = ~0;
        ulong   end_addr   =  0;
        int     line_count =  0;
+       int spin_cnt = 0;
+       const char *spin = "|/-\\";
 
        while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
                type = srec_decode (record, &binlen, &addr, binbuf);
 
                if (type < 0) {
+                       if(spin_cnt)
+                               putc('\b');
                        return (~0);            /* Invalid S-Record             */
                }
 
@@ -257,6 +261,8 @@ load_serial (ulong offset)
                case SREC_END3:
                case SREC_END4:
                    udelay (10000);
+                       if(spin_cnt)
+                               putc('\b');
                    printf ("\n"
                            "## First Load Addr = 0x%08lx\n"
                            "## Last  Load Addr = 0x%08lx\n"
@@ -271,12 +277,24 @@ load_serial (ulong offset)
                default:
                    break;
                }
-               if (!do_echo) { /* print a '.' every 100 lines */
-                       if ((++line_count % 100) == 0)
-                               putc ('.');
+               if (!do_echo) {
+                   /*
+                    * print a spinning dash every 100 lines
+                    *
+                    * Note: do not print anything here that might cause a
+                    *       linefeed, or configurations with a frame buffer
+                    *       console might miss bytes while scrolling.
+                    */
+                   if ((++line_count % 100) == 0) {
+                               if(spin_cnt)
+                                       putc('\b');
+                               putc(spin[spin_cnt++ & 3]);
+                   }
                }
        }
 
+       if(spin_cnt)
+               putc('\b');
        return (~0);                    /* Download aborted             */
 }
 

diff --git a/common/cmd_nvedit.c b/common/cmd_nvedit.c
index bd96f56fc89128df56f3f03f4162e266e6f9b21c..542e29522dd496c31f1602a0451f0329c67f1eed 100644 (file)
--- a/common/cmd_nvedit.c
+++ b/common/cmd_nvedit.c
@@ -409,6 +409,13 @@ int _do_setenv (bd_t *bd, int flag, int argc, char *argv[])
     }
 #endif /* CFG_CMD_NET */
 
+#ifdef CONFIG_KEYBOARD
+    if (strcmp(argv[1],"keymap") == 0) {
+       kbd_mapping (argv[2]);
+       return 0;
+    }
+#endif /* CONFIG_KEYBOARD */
+
     return 0;
 }
 

diff --git a/common/console.c b/common/console.c
index d9717f621e7c8ce04626a0e98d00029ccc7bb0e3..043a0ff4cb4fd7073dca8c24d6d323ca54924df3 100644 (file)
--- a/common/console.c
+++ b/common/console.c
@@ -24,11 +24,32 @@
 #include <armboot.h>
 #include <stdarg.h>
 #include <malloc.h>
+#include <config.h>
+
+#if defined(CONFIG_ANSI_CONSOLE)
+#      define CONSOLE_PUTC     ansi_console_putc
+#elif defined (CONFIG_CFB_CONSOLE)
+#      define CONSOLE_PUTC     video_putc
+#else
+#      define CONSOLE_PUTC     serial_putc
+#endif
+
+#ifdef CONFIG_KEYBOARD
+extern int     kbd_tstc(void);
+extern int     kbd_getc(void);
+#      define CONSOLE_GETC     kbd_getc
+#      define CONSOLE_TSTC     kbd_tstc
+#else
+#      define CONSOLE_GETC     serial_getc
+#      define CONSOLE_TSTC     serial_tstc
+#endif
+
+
 
 void serial_puts (const char *s)
 {
        while (*s) {
-               serial_putc (*s++);
+               CONSOLE_PUTC (*s++);
        }
 }
 
@@ -52,19 +73,19 @@ void serial_printf(const char *fmt, ...)
 int    getc(void)
 {
     /* Send directly to the handler */
-    return serial_getc();
+       return CONSOLE_GETC();
 }
 
 int    tstc(void)
 {
     /* Send directly to the handler */
-    return serial_tstc();
+       return CONSOLE_TSTC();
 }
 
 void   putc(const char c)
 {
        /* Send directly to the handler */
-       serial_putc(c);
+       CONSOLE_PUTC (c);
 }
 
 void   puts(const char *s)

diff --git a/drivers/Makefile b/drivers/Makefile
index 4fada9fd4312e2e318a305b39bc6b5e4ac5f47e5..d3b585b30b1294e9a7af51426ff88ca5c327e0eb 100644 (file)
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -26,7 +26,8 @@ include $(TOPDIR)/config.mk
 
 LIB    = libdrivers.a
 
-OBJS   = cs8900.o smc91111.o 3c589.o
+OBJS   = cs8900.o smc91111.o 3c589.o ansi_console.o framebuffer.o \
+                       font8x14.o keyboard.o cfb_console.o
 
 all:   .depend $(START) $(LIB)
 

diff --git a/drivers/ansi_console.c b/drivers/ansi_console.c
new file mode 100644 (file)
index 0000000..15a20f6
--- /dev/null
+++ b/drivers/ansi_console.c
@@ -0,0 +1,815 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+#include "config.h"
+
+#ifdef CONFIG_ANSI_CONSOLE
+
+/*
+************************************************************
+**
+**  Simple ansi terminal interpreter
+**
+************************************************************
+*/
+
+/*
+** This code covers the state machine part of a simple ansi
+** terminal emulation. It uses a bunch of device dependent
+** functions to do the actual output to screen.
+*/
+
+#include "cursor.h"
+
+/*
+** allocation limits                                                         
+*/
+/* max. number of numeric arguments in sequence; NPARAMS(+1) is ...  */
+#define NPARAMS 2      /* ... the size of param[] */
+
+/*
+** structure storing parameters from ansi-sequence
+*/
+struct param_def
+{
+       int  parablock[NPARAMS + 1];    /* buffer for numeric arguments   */
+       int  prmidx;                                    /* index of current argument      */
+       char last_char;                                 /* character terminating sequence */
+};
+
+/*
+** some enumerated types
+*/
+enum argstate
+{
+       NO_ARG,
+       IN_ARG
+};
+
+enum linestate
+{
+       LS_INLINE,
+       LS_EOL
+};
+
+enum awstate
+{
+       AW_OFF,
+       AW_ON
+};
+
+
+/*
+************************************************************
+** External screen driver functions:
+************************************************************
+*/
+
+
+extern void screen_init(
+       unsigned int *fcol,
+       unsigned int *bcol,
+       unsigned int *NoOfLins,
+       unsigned int *NoOfClms);
+
+extern void screen_curset(struct curdef *curs);
+extern void screen_curclr(struct curdef *curs);
+extern void screen_cpylns(int from, int to, int count);
+extern void screen_erase(
+       int froml,
+       int fromc,
+       int nl,
+       int nc,
+       unsigned int bgcol);
+extern void screen_bell(void);
+extern void screen_chrlow(unsigned char c, struct curdef *curs);
+
+/*
+** stateblock
+*/
+struct state
+{
+       unsigned int nlines, nclms;     /* number of lines and columns     */
+       struct selector  *current;      /* the actual machine state        */
+       enum argstate    subcsi;        /* csi-arg input has begun         */
+       enum awstate autowrap;
+       struct param_def param;         /* parameter (arguments) structure */
+       struct curdef    cursor;        /* cursor defintion record         */
+       enum linestate eol;
+};
+
+/*
+** machine state selector
+*/
+struct selector
+{
+       unsigned char from, to;
+       void (*funct) (struct state *, unsigned char);
+};
+
+/*
+************************************************************
+** static storage requirements
+************************************************************
+*/
+static struct state ansi_stateblock;
+#define GetStateBlockAddr()    (&ansi_stateblock)
+
+/*
+************************************************************
+** Local functions, to be used by the state machine
+************************************************************
+*/
+
+static void x_setup(struct state *, unsigned int, unsigned int);
+static void x_exe(struct state *, unsigned char);
+static void x_null(struct state *, unsigned char);
+static void x_stnrm(struct state *, unsigned char);
+static void x_stcsi(struct state *, unsigned char);
+static void x_stesc(struct state *, unsigned char);
+static void x_stprv(struct state *, unsigned char);
+static void x_stbad(struct state *, unsigned char);
+static void x_argnxt(struct state *, unsigned char);
+static void x_argdig(struct state *, unsigned char);
+static void x_indfwd(struct state *, unsigned char);
+static void x_newlin(struct state *, unsigned char);
+static void x_bs(struct state *, unsigned char);
+static void x_bell(struct state *, unsigned char);
+static void x_tab(struct state *, unsigned char);
+static void x_lf(struct state *, unsigned char);
+static void x_cr(struct state *, unsigned char);
+static void x_curup(struct state *, unsigned char);
+static void x_curdwn(struct state *, unsigned char);
+static void x_curfwd(struct state *, unsigned char);
+static void x_curbak(struct state *, unsigned char);
+static void x_curpos(struct state *, unsigned char);
+static void x_eradis(struct state *, unsigned char);
+static void x_eralin(struct state *, unsigned char);
+static void x_rendit(struct state *, unsigned char);
+static void x_chargl(struct state *, unsigned char);
+static void x_prvon(struct state *, unsigned char);
+static void x_prvoff(struct state *, unsigned char);
+
+
+/*
+************************************************************
+** State tables
+************************************************************
+*/
+
+/*
+** Control code functions
+*/
+static const struct selector st_control[] = {
+       {' ', '~', x_exe},                      /* normal processing                  */
+       {'\x07', '\x07', x_bell},       /* BELL                               */
+       {'\x08', '\x08', x_bs},         /* BS: non-destructive backspace      */
+       {'\x09', '\x09', x_tab},        /* TAB: go to next tabulator position */
+       {'\x0a', '\x0a', x_lf},         /* LF: newline                        */
+       {'\x0d', '\x0d', x_cr},         /* CR: first column                   */
+       {'\x1b', '\x1b', x_stesc},      /* ESC: enter ESC-sequence            */
+       {'\x9b', '\x9b', x_stcsi},      /* CSI: enter CSI-sequence            */
+       {'\x00', '\xff', x_null}        /* ignore others by default           */
+};
+
+/*
+** ESC functions
+*/
+static const struct selector st_esc[] = {
+       {'[', '[', x_stcsi},            /* enter CSI-Sequence                 */
+       {'\x00', '\xff', x_stnrm}       /* default: abort sequence            */
+};
+
+/*
+** CSI functions
+*/
+static const struct selector st_csi[] = {
+       {'A', 'A', x_curup},            /* cursor up                          */
+       {'B', 'B', x_curdwn},           /* cursor down                        */
+       {'C', 'C', x_curfwd},           /* cursor forward                     */
+       {'D', 'D', x_curbak},           /* cursor backward                    */
+       {'H', 'H', x_curpos},           /* cursor position addressing         */
+       {'J', 'J', x_eradis},           /* erase in display                   */
+       {'K', 'K', x_eralin},           /* erase in line                      */
+       {'m', 'm', x_rendit},           /* set character rendition            */
+       {'?', '?', x_stprv},            /* start private sequence             */
+       {';', ';', x_argnxt},           /* next csi argument                  */
+       {'0', '9', x_argdig},           /* next digit of csi argument         */
+       {'\x00', '\xff', x_stbad}       /* default: abort with next alpha     */
+};
+
+/*
+** Private functions
+*/
+static const struct selector st_prv[] = {
+       {'h', 'h', x_prvon},            /* turn on private attribute          */
+       {'l', 'l', x_prvoff},           /* turn off private attribute         */
+       {'0', '9', x_argdig},           /* next digit of argument parameter   */
+       {';', ';', x_argnxt},           /* next prv argument                  */
+       {'\x00', '\xff', x_stbad}       /* default: abort with next alpha     */
+};
+
+/*
+** Error status: ignore all until 0x20..0x7e received
+*/
+static const struct selector st_bad[] = {
+       {' ', '~', x_stnrm},            /* abort sequence with next alpha     */
+       {'\x00', '\xff', x_null}        /* ignore others                      */
+};
+
+/*
+** Normal (not-in-sequence) functions
+*/
+static const struct selector st_nrm[] = {
+       {' ', '~', x_chargl},           /* printing normal codes              */
+       {'\x00', '\xff', x_null}        /* ignore others                      */
+};
+
+/*
+** Supported CSI arguments
+*/
+#define P_CURVIS       25
+#define P_AUTOWRAP     7
+
+/*
+************************************************************
+**  Some commonly used macros
+**
+**  The local stateblock pointer (pSB) must be be set up
+**  before using any of these.
+************************************************************
+*/
+
+#define NoOfLins (pSB->nlines)
+#define NoOfClms (pSB->nclms)
+
+#define ScrollTop 1
+#define ScrollBtm NoOfLins
+
+
+#define CURDLTD() (pSB->cursor.vis = CS_OFF)
+
+#define CURPOS(y,x) (pSB->cursor.lin = (y), pSB->cursor.clm = (x))
+
+#define CLRCUR() \
+{\
+  if (pSB->cursor.vis == CS_ON  &&  pSB->cursor.abl == CS_ON)\
+  {\
+    screen_curclr (&pSB->cursor);\
+    CURDLTD ();\
+  }\
+}
+
+#define SETCUR() \
+{\
+  if (pSB->cursor.vis == CS_OFF  &&  pSB->cursor.abl == CS_ON)\
+  {\
+    screen_curset (&pSB->cursor);\
+    pSB->cursor.vis = CS_ON;\
+  }\
+}
+
+#define DEFAULT(x,y) \
+{\
+  if((pSB->param.prmidx < (x)) || (pSB->param.parablock[(x)] == 0))\
+    pSB->param.parablock[(x)] = (y);\
+}
+
+#define ENDSEQ() (pSB->current = (struct selector *) st_nrm)
+
+#define CLREOL() (pSB->eol = LS_INLINE)
+#define SETEOL() (pSB->eol = LS_EOL)
+
+/*
+************************************************************
+**  Main interpreter entrypoints:
+************************************************************
+*/
+
+/*
+************************************************************
+**  ansi_console_init(): hardware initialization
+************************************************************
+*/
+
+void ansi_console_init(void)
+{
+       struct state *pSB = GetStateBlockAddr();
+       unsigned int fcol, bcol;
+
+       screen_init(&fcol, &bcol, &NoOfLins, &NoOfClms);
+       x_setup(pSB, fcol, bcol);
+}
+
+/*
+************************************************************
+** ansi_console_putc(): output character on screen
+************************************************************
+*/
+void ansi_console_putc(const char c)
+{
+       /*
+       ** search character in table and call function from table
+       */
+       struct state *pSB = GetStateBlockAddr();
+       struct selector *table = (struct selector *)st_control;
+
+       while((unsigned char)c < table->from || (unsigned char)c > table->to)
+               table++;
+
+       (*table->funct)(pSB, (unsigned char)c);
+       
+       if (c == '\n')
+               ansi_console_putc('\r');
+       SETCUR();
+}
+
+/*
+************************************************************
+** Local functions
+************************************************************
+*/
+
+#define I_CURABL    CS_ON
+#define I_CURVIS    CS_OFF
+#define I_AWSTAT    AW_ON
+#define I_EOLSTAT   LS_INLINE
+#define I_REVERSE   0
+
+/*
+**  x_setup(): initialize static parameters
+*/
+static void x_setup(
+       struct state *pSB,
+       unsigned int fcol,
+       unsigned int bcol)
+{
+
+       pSB->current = (struct selector *)st_nrm;
+
+       pSB->subcsi = NO_ARG;
+
+       pSB->cursor.FGndCol = fcol;
+       pSB->cursor.BGndCol = bcol;
+
+       pSB->cursor.abl     = I_CURABL;
+       pSB->cursor.vis     = I_CURVIS;
+       pSB->cursor.reverse = I_REVERSE;
+
+       CURPOS(0, 0);
+
+       pSB->autowrap = I_AWSTAT;
+       pSB->eol = I_EOLSTAT;
+}
+
+/*
+** x_exe(): state processor
+*/
+static void x_exe(struct state *pSB, unsigned char c)
+{
+       struct selector *table = pSB->current;
+
+       while(c < table->from || c > table->to)
+               table++;
+
+       (*table->funct)(pSB, c);
+}
+
+
+/*
+************************************************************
+**  state switching routines
+************************************************************
+*/
+
+/*
+** x_null(): ignore this char - state unchanged
+*/
+static void x_null(struct state *pSB, unsigned char c)
+{
+       /* no-op */
+}
+
+/*
+** x_stnrm(): abort current sequence - enter normal state
+*/
+static void x_stnrm(struct state *pSB, unsigned char c)
+{
+       ENDSEQ();
+}
+
+/*
+** x_stcsi(): enter CSI-sequence
+*/
+static void x_stcsi(struct state *pSB, unsigned char c)
+{
+       pSB->current = (struct selector *)st_csi;
+       pSB->param.parablock[pSB->param.prmidx = 0] = 0;        /* reset argument input */
+       pSB->subcsi = NO_ARG;                                                           /* mark 'no argument up to now' */
+}
+
+/*
+** x_stesc(): enter escape-sequence
+*/
+static void x_stesc(struct state *pSB, unsigned char c)
+{
+       pSB->current = (struct selector *)st_esc;
+}
+
+/*
+** x_stprv(): enter private sequence (CSI - ?)
+*/
+static void x_stprv(struct state *pSB, unsigned char c)
+{
+       if(pSB->subcsi == NO_ARG)
+       {
+               pSB->current = (struct selector *)st_prv;
+               pSB->param.parablock[pSB->param.prmidx = 0] = 0;
+       }
+       else
+               ENDSEQ();
+}
+
+/*
+** x_stbad(): enter error-in-sequence state
+*/
+static void x_stbad(struct state *pSB, unsigned char c)
+{
+       pSB->current = (struct selector *)st_bad;
+}
+
+/*
+************************************************************
+**  Argument input routines
+************************************************************
+*/
+
+/*
+** x_argnxt(): next argument
+*/
+static void x_argnxt(struct state *pSB, unsigned char c)
+{
+       pSB->subcsi = IN_ARG;
+       if(pSB->param.prmidx < NPARAMS)
+               pSB->param.parablock[++pSB->param.prmidx] = 0;
+}
+
+/*
+** x_argdig(): next digit
+*/
+static void x_argdig(struct state *pSB, unsigned char d)
+{
+       int *p = pSB->param.parablock + pSB->param.prmidx;
+
+       pSB->subcsi = IN_ARG;
+       *p = *p * 10 + (d & '\x0f');
+}
+
+/*
+** x_indfwd(): forward index, scroll at scroll.bot
+*/
+static void x_indfwd(struct state *pSB, unsigned char c)
+{
+       if(pSB->cursor.lin == (ScrollBtm - 1))
+       {
+               CLRCUR();                               /* avoid copying the cursor */
+               screen_cpylns((ScrollTop - 1) + 1,      /* from line */
+                                ScrollTop - 1, /* to line */
+                                ScrollBtm - ScrollTop);        /* size in lines */
+
+               screen_erase(ScrollBtm - 1, 0,  /* from line / column */
+                               1, NoOfClms,    /* size lines * columns */
+                               pSB->cursor.BGndCol);   /* erase color */
+       }
+       else if(pSB->cursor.lin < NoOfLins)
+       {
+               CLRCUR();
+               ++pSB->cursor.lin;
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_newlin(): nel: newline
+*/
+static void x_newlin(struct state *pSB, unsigned char c)
+{
+       x_cr(pSB, 0);
+       x_indfwd(pSB, 0);
+       if((c & 0x60) != 0)                     /* do no endsequence in case of C1 */
+               ENDSEQ();
+}
+
+/*
+************************************************************
+**  c0 control code execution: cr, lf, bs, tab etc.
+************************************************************
+*/
+
+/*
+** x_bell(): activate beeper
+*/
+static void x_bell(struct state *pSB, unsigned char c)
+{
+       screen_bell();
+}
+
+/*
+** x_bs(): backspace, non-destructive, non-wrap
+*/
+static void x_bs(struct state *pSB, unsigned char c)
+{
+       if((pSB->cursor.clm > 0))
+       {
+               CLRCUR();
+               --pSB->cursor.clm;
+       }
+       CLREOL();
+}
+
+/*
+** x_tab(): handle TAB character
+*/
+static void x_tab(struct state *pSB, unsigned char c)
+{
+}
+
+/*
+** x_lf(): linefeed, scroll at scroll.bot
+*/
+static void x_lf(struct state *pSB, unsigned char c)
+{
+       x_indfwd(pSB, 0);
+}
+
+/*
+** x_cr(): carriage return
+*/
+static void x_cr(struct state *pSB, unsigned char c)
+{
+       if(pSB->cursor.clm != 0)
+       {
+               CLRCUR();
+               pSB->cursor.clm = 0;
+       }
+
+       CLREOL();
+}
+
+/*
+************************************************************
+**  csi-execution routines
+************************************************************
+*/
+
+/*
+** x_curup(): cursor n lines up, no wrap, no scroll, stops at scroll.top
+*/
+static void x_curup(struct state *pSB, unsigned char c)
+{
+       unsigned long maxup = pSB->cursor.lin;
+
+       if(maxup)
+       {
+               CLRCUR();
+               DEFAULT(0, 1);
+               if(pSB->param.parablock[0] >= maxup)
+                       pSB->cursor.lin -= maxup;
+               else
+                       pSB->cursor.lin -= pSB->param.parablock[0];
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_curdwn(): cursor n lines down, no wrap, no scroll, stops at scroll.bot
+*/
+static void x_curdwn(struct state *pSB, unsigned char c)
+{
+       unsigned long maxdwn;
+
+       if(pSB->cursor.lin <= (ScrollBtm - 1))
+               maxdwn = ScrollBtm - pSB->cursor.lin - 1;
+       else
+               maxdwn = NoOfLins - pSB->cursor.lin - 1;
+
+       if(maxdwn)
+       {
+               DEFAULT(0, 1);
+               CLRCUR();
+
+               if(pSB->param.parablock[0] >= maxdwn)
+                       pSB->cursor.lin += maxdwn;
+               else
+                       pSB->cursor.lin += pSB->param.parablock[0];
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_curfwd(): cursor n columns forward, no wrap, no scroll
+*/
+static void x_curfwd(struct state *pSB, unsigned char c)
+{
+       if(pSB->cursor.clm < (NoOfClms - 1))
+       {
+               DEFAULT(0, 1);
+               CLRCUR();
+               if((pSB->cursor.clm += pSB->param.parablock[0]) > (NoOfClms - 1))
+                       pSB->cursor.clm = NoOfClms - 1;
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_curbak(): cursor n columns backward, no wrap, no scroll
+*/
+
+static void x_curbak(struct state *pSB, unsigned char c)
+{
+       if(pSB->cursor.clm > 0)
+       {
+               DEFAULT(0, 1);
+               CLRCUR();
+               if(pSB->cursor.clm < pSB->param.parablock[0])
+                       pSB->cursor.clm = 0;
+               else
+                       pSB->cursor.clm -= pSB->param.parablock[0];
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_curpos(): cursor position addressing, regular ceiling
+*/
+static void x_curpos(struct state *pSB, unsigned char c)
+{
+       int top, bot;
+
+       DEFAULT(0, 1);
+       --pSB->param.parablock[0];
+       DEFAULT(1, 1);
+       --pSB->param.parablock[1];
+
+       top = 0;
+       bot = NoOfLins;
+
+       pSB->param.parablock[0] += top;
+
+       if(pSB->param.parablock[0] > bot)
+               pSB->param.parablock[0] = bot - 1;
+       if(pSB->param.parablock[1] > NoOfClms)
+               pSB->param.parablock[1] = NoOfClms - 1;
+       if(pSB->param.parablock[0] != pSB->cursor.lin ||
+          pSB->param.parablock[1] != pSB->cursor.clm)
+       {
+               CLRCUR();
+               CURPOS(pSB->param.parablock[0], pSB->param.parablock[1]);
+       }
+
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_eradis(): erase in display
+*/
+static void x_eradis(struct state *pSB, unsigned char c)
+{
+       screen_erase(pSB->cursor.lin, pSB->cursor.clm,
+                       1, (NoOfClms - 1) - pSB->cursor.clm + 1, pSB->cursor.BGndCol);
+       if(pSB->cursor.lin < (NoOfLins - 1))
+               screen_erase(pSB->cursor.lin + 1, 0,
+                               NoOfLins - 1 - pSB->cursor.lin,
+                               NoOfClms, pSB->cursor.BGndCol);
+
+       CURDLTD();
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_eralin(): erase in line
+*/
+static void x_eralin(struct state *pSB, unsigned char c)
+{
+       screen_erase(pSB->cursor.lin, pSB->cursor.clm,
+                       1, (NoOfClms - 1) - pSB->cursor.clm + 1, pSB->cursor.BGndCol);
+
+       CURDLTD();
+       ENDSEQ();
+       CLREOL();
+}
+
+/*
+** x_rendit(): set character rendition
+*/
+static void x_rendit(struct state *pSB, unsigned char c)
+{
+       int i, *p;
+
+       for(i = 0, p = pSB->param.parablock; i <= pSB->param.prmidx; ++i, ++p)
+               if(*p >= 1 && *p <= 19)
+                       pSB->cursor.reverse = 1;
+               else
+                       pSB->cursor.reverse = 0;
+
+       ENDSEQ();
+}
+
+/*
+** x_chargl(): character, gl set
+*/
+static void x_chargl(struct state *pSB, unsigned char c)
+{
+       /* AUTOWRAP start */
+       if(pSB->eol == LS_EOL)
+       {
+               x_newlin(pSB, 0);
+               CLREOL();
+       }
+
+       /* AUTOWRAP end */
+       screen_chrlow(c, &pSB->cursor);
+       CURDLTD();
+
+       if(pSB->cursor.clm < (NoOfClms - 1))
+               ++pSB->cursor.clm;
+
+       /* AUTOWRAP start */
+       else if(pSB->autowrap == AW_ON)
+               SETEOL();
+
+       /* AUTOWRAP start */
+}
+
+/*
+** x_prvon(): set private features
+*/
+static void x_prvon(struct state *pSB, unsigned char c)
+{
+       switch (pSB->param.parablock[0])
+       {
+               case P_CURVIS:
+                       pSB->cursor.abl = CS_ON;
+                       break;
+
+               case P_AUTOWRAP:
+                       pSB->autowrap = AW_ON;
+                       break;
+       }
+       ENDSEQ();
+}
+
+/*
+** x_prvoff(): reset private features
+*/
+static void x_prvoff(struct state *pSB, unsigned char c)
+{
+       switch (pSB->param.parablock[0])
+       {
+               case P_CURVIS:
+                       CLRCUR();
+                       pSB->cursor.abl = CS_OFF;
+                       break;
+
+               case P_AUTOWRAP:
+                       CLREOL();
+                       pSB->autowrap = AW_OFF;
+                       break;
+       }
+
+       ENDSEQ();
+}
+
+#endif /* CONFIG_ANSI_CONSOLE */

diff --git a/drivers/cfb_console.c b/drivers/cfb_console.c
new file mode 100644 (file)
index 0000000..8614cd7
--- /dev/null
+++ b/drivers/cfb_console.c
@@ -0,0 +1,894 @@
+/*
+ * (C) Copyright 2002 ELTEC Elektronik AG
+ * Frank Gottschling <fgottschling@eltec.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
+ */
+
+/*
+ * cfb_console.c
+ *
+ * Color Framebuffer Console driver for 8/15/16/24/32 bits per pixel.
+ *
+ * At the moment only the 8x16 font is tested and the font fore- and
+ * background color is limited to black/white/gray colors. The Linux
+ * logo can be placed in the upper left corner and additional board
+ * information strings (that normaly goes to serial port) can be drawed.
+ *
+ * The console driver can use the standard PC keyboard interface (i8042)
+ * for character input. Character output goes to a memory mapped video
+ * framebuffer with little or big-endian organisation.
+ * With environment setting 'console=serial' the console i/o can be
+ * forced to serial port.
+
+ The driver uses graphic specific defines/parameters/functions:
+
+ (for SMI LynxE graphic chip)
+
+ CONFIG_VIDEO_SMI_LYNXEM - use graphic driver for SMI 710,712,810
+ VIDEO_FB_LITTLE_ENDIAN  - framebuffer organisation default: big endian
+ VIDEO_HW_RECTFILL       - graphic driver supports hardware rectangle fill
+ VIDEO_HW_BITBLT         - graphic driver supports hardware bit blt
+
+ Console Parameters are set by graphic drivers global struct:
+
+ VIDEO_VISIBLE_COLS          - x resolution
+ VIDEO_VISIBLE_ROWS          - y resolution
+ VIDEO_PIXEL_SIZE            - storage size in byte per pixel
+ VIDEO_DATA_FORMAT           - graphical data format GDF
+ VIDEO_FB_ADRS               - start of video memory
+
+ CONFIG_I8042_KBD            - AT Keyboard driver for i8042
+ VIDEO_KBD_INIT_FCT          - init function for keyboard
+ VIDEO_TSTC_FCT              - keyboard_tstc function
+ VIDEO_GETC_FCT              - keyboard_getc function
+
+ CONFIG_CONSOLE_CURSOR_BLINK - on/off drawing cursor is done with delay
+                               loop in VIDEO_TSTC_FCT (i8042)
+ CFG_CONSOLE_BLINK_COUNT     - value for delay loop - blink rate
+ CONFIG_CONSOLE_TIME         - display time/date in upper right corner,
+                               needs CFG_CMD_DATE and CONFIG_CONSOLE_CURSOR_BLINK
+ CONFIG_VIDEO_LOGO           - display Linux Logo in upper left corner
+ CONFIG_CONSOLE_EXTRA_INFO   - display additional board information strings
+                               that normaly goes to serial port. This define
+                               requires a board specific function:
+                               video_drawstring (VIDEO_INFO_X,
+                                                 VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT,
+                                                 info);
+                               that fills a info buffer at i=row.
+                               s.a: board/eltec/bab7xx.
+*/
+
+#include <config.h>
+
+#ifdef CONFIG_CFB_CONSOLE
+
+/*****************************************************************************/
+/* Console device defines with SMI graphic                                   */
+/* Any other graphic must change this section                                */
+/*****************************************************************************/
+
+#ifdef  CONFIG_VIDEO_SMI_LYNXEM
+#include <smiLynxEM.h>
+
+#define VIDEO_FB_LITTLE_ENDIAN
+#define VIDEO_HW_RECTFILL
+#define VIDEO_HW_BITBLT
+
+#define VIDEO_VISIBLE_COLS      (smi.winSizeX)
+#define VIDEO_VISIBLE_ROWS      (smi.winSizeY)
+#define VIDEO_PIXEL_SIZE        (smi.gdfBytesPP)
+#define VIDEO_DATA_FORMAT       (smi.gdfIndex)
+#define VIDEO_FB_ADRS           (smi.frameAdrs)
+#endif
+
+/*****************************************************************************/
+/* Console device defines for Shannon (SA-1100) board                        */
+/*****************************************************************************/
+
+#ifdef  CONFIG_VIDEO_SHANNON
+#include <shannon_video.h>
+
+#define VIDEO_VISIBLE_COLS      LCD_VIDEO_COLS
+#define VIDEO_VISIBLE_ROWS      LCD_VIDEO_ROWS
+#define VIDEO_PIXEL_SIZE        (LCD_VIDEO_BPP/8)
+#define VIDEO_DATA_FORMAT       LCD_VIDEO_FORMAT
+#define VIDEO_FB_ADRS           LCD_VIDEO_ADDR
+#endif
+
+/*****************************************************************************/
+/* Console device defines with i8042 keyboard controller                     */
+/* Any other keyboard controller must change this section                    */
+/*****************************************************************************/
+
+#ifdef  CONFIG_I8042_KBD
+#include <i8042.h>
+
+#define VIDEO_KBD_INIT_FCT      i8042_kbd_init()
+#define VIDEO_TSTC_FCT          i8042_tstc
+#define VIDEO_GETC_FCT          i8042_getc
+#endif
+
+
+/*****************************************************************************/
+/* Console device                                                            */
+/*****************************************************************************/
+
+#include <version.h>
+#include <armboot.h>
+#include <types.h>
+#include <video_font.h>
+#ifdef CFG_CMD_DATE
+#include <rtc.h>
+
+#endif
+
+#ifndef cpu_to_be32
+#ifdef __BIG_ENDIAN
+#define cpu_to_be32(x) (x)
+#else
+#define cpu_to_be32(x)   ((((x) & 0x000000ff) << 24) | (((x) & 0x0000ff00) << 8)|\
+                          (((x) & 0x00ff0000) >>  8) | (((x) & 0xff000000) >> 24) )
+#endif
+#endif
+
+#define CONSOLE_BG_COL            0x00
+#define CONSOLE_FG_COL            0xa0
+
+/*
+ * Graphic Data Format (GDF) bits for VIDEO_DATA_FORMAT
+ */
+#define GDF__8BIT_INDEX         0
+#define GDF_15BIT_555RGB        1
+#define GDF_16BIT_565RGB        2
+#define GDF_32BIT_X888RGB       3
+#define GDF_24BIT_888RGB        4
+#define GDF__8BIT_332RGB        5
+
+#ifdef  CONFIG_CONSOLE_CURSOR
+void    console_cursor (int state);
+static int cursor_state = 0; /* cursor state (on or off) */
+#define CURSOR_OFF console_cursor(0);
+#ifdef CONFIG_I8042_KBD
+/* Cursor drawing done in drivers/i8042.c */
+#define CURSOR_ON
+#define CURSOR_CLR
+#else
+#define CURSOR_ON  console_cursor(1);
+#define CURSOR_CLR     (cursor_state = 0);
+#endif
+#else
+#define CURSOR_ON
+#define CURSOR_OFF
+#define CURSOR_CLR
+#ifdef  CONFIG_CONSOLE_TIME
+#error  CONFIG_CONSOLE_CURSOR must be defined for CONFIG_CONSOLE_TIME
+#endif
+#endif
+
+#ifdef  CONFIG_VIDEO_LOGO
+#define LINUX_LOGO_WIDTH        80
+#define LINUX_LOGO_HEIGHT       80
+#define LINUX_LOGO_COLORS       214
+#define LINUX_LOGO_LUT_OFFSET   0x20
+#define __initdata
+#include <linux_logo.h>
+#define VIDEO_LOGO_WIDTH        LINUX_LOGO_WIDTH
+#define VIDEO_LOGO_HEIGHT       LINUX_LOGO_HEIGHT
+
+#define VIDEO_INFO_X            (VIDEO_LOGO_WIDTH)
+#define VIDEO_INFO_Y            (VIDEO_FONT_HEIGHT/2)
+#else
+#define VIDEO_LOGO_WIDTH        0
+#define VIDEO_LOGO_HEIGHT       0
+#endif
+
+#define VIDEO_COLS              VIDEO_VISIBLE_COLS
+#define VIDEO_ROWS              VIDEO_VISIBLE_ROWS
+#define VIDEO_SIZE              (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)
+#define VIDEO_PIX_BLOCKS        (VIDEO_SIZE >> 2)
+#define VIDEO_LINE_LEN          (VIDEO_COLS*VIDEO_PIXEL_SIZE)
+#define VIDEO_BURST_LEN         (VIDEO_COLS/8)
+
+#ifdef  CONFIG_VIDEO_LOGO
+#define CONSOLE_ROWS            ((VIDEO_ROWS - VIDEO_LOGO_HEIGHT) / VIDEO_FONT_HEIGHT)
+#else
+#define CONSOLE_ROWS            (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
+#endif
+
+#define CONSOLE_COLS            (VIDEO_COLS / VIDEO_FONT_WIDTH)
+#define CONSOLE_ROW_SIZE        (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
+#define CONSOLE_ROW_FIRST       (video_console_address)
+#define CONSOLE_ROW_SECOND      (video_console_address + CONSOLE_ROW_SIZE)
+#define CONSOLE_ROW_LAST        (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
+#define CONSOLE_SIZE            (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
+#define CONSOLE_SCROLL_SIZE     (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
+
+/* Macros */
+
+#ifdef  VIDEO_FB_LITTLE_ENDIAN
+#define swap16(x)        ((((x) & 0x00ff) << 8) | ( (x) >> 8))
+#define swap32(x)        ((((x) & 0x000000ff) << 24) | (((x) & 0x0000ff00) << 8)|\
+                          (((x) & 0x00ff0000) >>  8) | (((x) & 0xff000000) >> 24) )
+#define shortswap32(x)   ((((x) & 0x000000ff) <<  8) | (((x) & 0x0000ff00) >> 8)|\
+                          (((x) & 0x00ff0000) <<  8) | (((x) & 0xff000000) >> 8) )
+#else
+#define swap16(x)        (x)
+#define swap32(x)        (x)
+#define shortswap32(x)   (x)
+#endif
+
+#if defined(DEBUG) || defined(DEBUG_CFB_CONSOLE)
+#define PRINTD(x)         printf(x)
+#else
+#define PRINTD(x)
+#endif
+
+/* Imports */
+
+extern void *video_hw_init (void);    /* return the graphic device struct or NULL */
+
+extern void video_hw_bitblt (
+    unsigned int bpp,       /* bytes per pixel */
+    unsigned int src_x,     /* source pos x */
+    unsigned int src_y,     /* source pos y */
+    unsigned int dst_x,     /* dest pos x */
+    unsigned int dst_y,     /* dest pos y */
+    unsigned int dim_x,     /* frame width */
+    unsigned int dim_y      /* frame height */
+    );
+
+extern void video_hw_rectfill (
+    unsigned int bpp,       /* bytes per pixel */
+    unsigned int dst_x,     /* dest pos x */
+    unsigned int dst_y,     /* dest pos y */
+    unsigned int dim_x,     /* frame width */
+    unsigned int dim_y,     /* frame height */
+    unsigned int color      /* fill color */
+    );
+
+extern void video_set_lut (
+    unsigned int index,     /* color number */
+    unsigned char r,        /* red */
+    unsigned char g,        /* green */
+    unsigned char b         /* blue */
+    );
+
+extern void video_get_info_str (    /* setup a board string: type, speed, etc. */
+    int line_number,        /* location to place info string beside logo */
+    char *info              /* buffer for info string */
+    );
+
+
+/* Locals */
+static void *video_fb_address;          /* frame buffer address */
+static void *video_console_address;     /* console buffer start address */
+
+static int console_col = 0; /* cursor col */
+static int console_row = 0; /* cursor row */
+
+static u32 eorx, fgx, bgx;  /* color pats */
+
+static const int video_font_draw_table8[] = {
+#ifdef __BIG_ENDIAN
+            0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
+            0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
+            0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
+            0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff };
+#else
+            0x00000000, 0xff000000, 0x00ff0000, 0xffff0000,
+            0x0000ff00, 0xff00ff00, 0x00ffff00, 0xffffff00,
+            0x000000ff, 0xff0000ff, 0x00ff00ff, 0xffff00ff,
+            0x0000ffff, 0xff00ffff, 0x00ffffff, 0xffffffff };
+#endif
+
+
+static const int video_font_draw_table15[] = {
+#ifdef __BIG_ENDIAN
+            0x00000000, 0x00007fff, 0x7fff0000, 0x7fff7fff };
+#else
+            0x00000000, 0xff7f0000, 0x0000ff7f, 0xff7fff7f };
+#endif
+
+
+static const int video_font_draw_table16[] = {
+#ifdef __BIG_ENDIAN
+            0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
+#else
+            0x00000000, 0xffff0000, 0x0000ffff, 0xffffffff };
+#endif
+
+
+static const int video_font_draw_table24[16][3] = {
+#ifdef __BIG_ENDIAN
+            { 0x00000000, 0x00000000, 0x00000000 },
+            { 0x00000000, 0x00000000, 0x00ffffff },
+            { 0x00000000, 0x0000ffff, 0xff000000 },
+            { 0x00000000, 0x0000ffff, 0xffffffff },
+            { 0x000000ff, 0xffff0000, 0x00000000 },
+            { 0x000000ff, 0xffff0000, 0x00ffffff },
+            { 0x000000ff, 0xffffffff, 0xff000000 },
+            { 0x000000ff, 0xffffffff, 0xffffffff },
+            { 0xffffff00, 0x00000000, 0x00000000 },
+            { 0xffffff00, 0x00000000, 0x00ffffff },
+            { 0xffffff00, 0x0000ffff, 0xff000000 },
+            { 0xffffff00, 0x0000ffff, 0xffffffff },
+            { 0xffffffff, 0xffff0000, 0x00000000 },
+            { 0xffffffff, 0xffff0000, 0x00ffffff },
+            { 0xffffffff, 0xffffffff, 0xff000000 },
+            { 0xffffffff, 0xffffffff, 0xffffffff } };
+#else
+            { 0x00000000, 0x00000000, 0x00000000 },
+            { 0x00000000, 0x00000000, 0xffffff00 },
+            { 0x00000000, 0xffff0000, 0x000000ff },
+            { 0x00000000, 0xffff0000, 0xffffffff },
+            { 0xff000000, 0x0000ffff, 0x00000000 },
+            { 0xff000000, 0x0000ffff, 0xffffff00 },
+            { 0xff000000, 0xffffffff, 0x000000ff },
+            { 0xff000000, 0xffffffff, 0xffffffff },
+            { 0x00ffffff, 0x00000000, 0x00000000 },
+            { 0x00ffffff, 0x00000000, 0xffffff00 },
+            { 0x00ffffff, 0xffff0000, 0x000000ff },
+            { 0x00ffffff, 0xffff0000, 0xffffffff },
+            { 0xffffffff, 0x0000ffff, 0x00000000 },
+            { 0xffffffff, 0x0000ffff, 0xffffff00 },
+            { 0xffffffff, 0xffffffff, 0x000000ff },
+            { 0xffffffff, 0xffffffff, 0xffffffff } };
+#endif
+
+
+static const int video_font_draw_table32[16][4] = {
+#ifdef __BIG_ENDIAN
+            { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
+            { 0x00000000, 0x00000000, 0x00000000, 0x00ffffff },
+            { 0x00000000, 0x00000000, 0x00ffffff, 0x00000000 },
+            { 0x00000000, 0x00000000, 0x00ffffff, 0x00ffffff },
+            { 0x00000000, 0x00ffffff, 0x00000000, 0x00000000 },
+            { 0x00000000, 0x00ffffff, 0x00000000, 0x00ffffff },
+            { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00000000 },
+            { 0x00000000, 0x00ffffff, 0x00ffffff, 0x00ffffff },
+            { 0x00ffffff, 0x00000000, 0x00000000, 0x00000000 },
+            { 0x00ffffff, 0x00000000, 0x00000000, 0x00ffffff },
+            { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00000000 },
+            { 0x00ffffff, 0x00000000, 0x00ffffff, 0x00ffffff },
+            { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00000000 },
+            { 0x00ffffff, 0x00ffffff, 0x00000000, 0x00ffffff },
+            { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00000000 },
+            { 0x00ffffff, 0x00ffffff, 0x00ffffff, 0x00ffffff } };
+#else
+            { 0x00000000, 0x00000000, 0x00000000, 0x00000000 },
+            { 0x00000000, 0x00000000, 0x00000000, 0xffffff00 },
+            { 0x00000000, 0x00000000, 0xffffff00, 0x00000000 },
+            { 0x00000000, 0x00000000, 0xffffff00, 0xffffff00 },
+            { 0x00000000, 0xffffff00, 0x00000000, 0x00000000 },
+            { 0x00000000, 0xffffff00, 0x00000000, 0xffffff00 },
+            { 0x00000000, 0xffffff00, 0xffffff00, 0x00000000 },
+            { 0x00000000, 0xffffff00, 0xffffff00, 0xffffff00 },
+            { 0xffffff00, 0x00000000, 0x00000000, 0x00000000 },
+            { 0xffffff00, 0x00000000, 0x00000000, 0xffffff00 },
+            { 0xffffff00, 0x00000000, 0xffffff00, 0x00000000 },
+            { 0xffffff00, 0x00000000, 0xffffff00, 0xffffff00 },
+            { 0xffffff00, 0xffffff00, 0x00000000, 0x00000000 },
+            { 0xffffff00, 0xffffff00, 0x00000000, 0xffffff00 },
+            { 0xffffff00, 0xffffff00, 0xffffff00, 0x00000000 },
+            { 0xffffff00, 0xffffff00, 0xffffff00, 0xffffff00 } };
+#endif
+
+/******************************************************************************/
+
+
+static void video_drawchars (int xx, int yy, unsigned char *s, int count)
+{
+    u8  *cdat, *dest, *dest0;
+    int rows, offset, c;
+
+    offset = yy * VIDEO_LINE_LEN + xx * VIDEO_PIXEL_SIZE;
+    dest0 = video_fb_address + offset;
+
+    switch (VIDEO_DATA_FORMAT)
+    {
+    case GDF__8BIT_INDEX:
+    case GDF__8BIT_332RGB:
+        while (count--)
+        {
+        c = *s ;
+        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
+        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN)
+        {
+            u8 bits = *cdat++;
+            ((u32 *)dest)[0] = (video_font_draw_table8[bits >> 4] & eorx) ^ bgx;
+            ((u32 *)dest)[1] = (video_font_draw_table8[bits & 15] & eorx) ^ bgx;
+        }
+        dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
+        s++;
+        }
+        break;
+
+    case GDF_15BIT_555RGB:
+        while (count--)
+        {
+        c = *s ;
+        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
+        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN)
+        {
+            u8 bits = *cdat++;
+            ((u32 *)dest)[0] = shortswap32((video_font_draw_table15[bits >> 6] & eorx) ^ bgx);
+            ((u32 *)dest)[1] = shortswap32((video_font_draw_table15[bits >> 4 & 3] & eorx) ^ bgx);
+            ((u32 *)dest)[2] = shortswap32((video_font_draw_table15[bits >> 2 & 3] & eorx) ^ bgx);
+            ((u32 *)dest)[3] = shortswap32((video_font_draw_table15[bits & 3] & eorx) ^ bgx);
+            }
+            dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
+            s++ ;
+        }
+        break;
+
+    case GDF_16BIT_565RGB:
+        while (count--)
+        {
+        c = *s ;
+        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
+        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN)
+        {
+            u8 bits = *cdat++;
+            ((u32 *)dest)[0] = shortswap32((video_font_draw_table16[bits >> 6] & eorx) ^ bgx);
+            ((u32 *)dest)[1] = shortswap32((video_font_draw_table16[bits >> 4 & 3] & eorx) ^ bgx);
+            ((u32 *)dest)[2] = shortswap32((video_font_draw_table16[bits >> 2 & 3] & eorx) ^ bgx);
+            ((u32 *)dest)[3] = shortswap32((video_font_draw_table16[bits & 3] & eorx) ^ bgx);
+        }
+        dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
+        s++ ;
+        }
+        break;
+
+    case GDF_32BIT_X888RGB:
+        while (count--)
+        {
+        c = *s ;
+        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
+        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN)
+        {
+            u8 bits = *cdat++;
+            ((u32 *)dest)[0] = swap32((video_font_draw_table32[bits >> 4][0] & eorx) ^ bgx);
+            ((u32 *)dest)[1] = swap32((video_font_draw_table32[bits >> 4][1] & eorx) ^ bgx);
+            ((u32 *)dest)[2] = swap32((video_font_draw_table32[bits >> 4][2] & eorx) ^ bgx);
+            ((u32 *)dest)[3] = swap32((video_font_draw_table32[bits >> 4][3] & eorx) ^ bgx);
+            ((u32 *)dest)[4] = swap32((video_font_draw_table32[bits & 15][0] & eorx) ^ bgx);
+            ((u32 *)dest)[5] = swap32((video_font_draw_table32[bits & 15][1] & eorx) ^ bgx);
+            ((u32 *)dest)[6] = swap32((video_font_draw_table32[bits & 15][2] & eorx) ^ bgx);
+            ((u32 *)dest)[7] = swap32((video_font_draw_table32[bits & 15][3] & eorx) ^ bgx);
+        }
+        dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
+        s++ ;
+        }
+        break;
+
+    case GDF_24BIT_888RGB:
+        while (count--)
+        {
+        c = *s ;
+        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
+        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--; dest += VIDEO_LINE_LEN)
+        {
+            u8 bits = *cdat++;
+            ((u32 *)dest)[0] = (video_font_draw_table24[bits >> 4][0] & eorx) ^ bgx;
+            ((u32 *)dest)[1] = (video_font_draw_table24[bits >> 4][1] & eorx) ^ bgx;
+            ((u32 *)dest)[2] = (video_font_draw_table24[bits >> 4][2] & eorx) ^ bgx;
+            ((u32 *)dest)[3] = (video_font_draw_table24[bits & 15][0] & eorx) ^ bgx;
+            ((u32 *)dest)[4] = (video_font_draw_table24[bits & 15][1] & eorx) ^ bgx;
+            ((u32 *)dest)[5] = (video_font_draw_table24[bits & 15][2] & eorx) ^ bgx;
+        }
+        dest0 += VIDEO_FONT_WIDTH * VIDEO_PIXEL_SIZE;
+        s++ ;
+        }
+        break;
+    }
+}
+
+/*****************************************************************************/
+
+static inline void video_drawstring(int xx, int yy, unsigned char *s)
+{
+    video_drawchars (xx, yy, s, strlen(s));
+}
+
+/*****************************************************************************/
+
+static void video_putchar(int xx, int yy, unsigned char c)
+{
+#ifdef CONFIG_VIDEO_LOGO
+    video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, &c, 1);
+#else
+    video_drawchars (xx, yy, &c, 1);
+#endif
+}
+
+/*****************************************************************************/
+
+#ifdef  CONFIG_CONSOLE_CURSOR
+void console_cursor (int state)
+{
+#ifdef CONFIG_CONSOLE_TIME
+    struct rtc_time tm;
+    char info[16];
+
+    /* time update only if cursor is on (faster scroll) */
+    if (state)
+    {
+    rtc_get (&tm);
+
+    sprintf(info, " %02d:%02d:%02d ", tm.tm_hour, tm.tm_min, tm.tm_sec);
+    video_drawstring(VIDEO_VISIBLE_COLS-10*VIDEO_FONT_WIDTH,
+             VIDEO_INFO_Y, info);
+
+    sprintf(info, "%02d.%02d.%04d", tm.tm_mday, tm.tm_mon, tm.tm_year);
+    video_drawstring(VIDEO_VISIBLE_COLS-10*VIDEO_FONT_WIDTH,
+             VIDEO_INFO_Y+1*VIDEO_FONT_HEIGHT, info);
+    }
+#endif
+
+    if (state && (cursor_state != state))
+    {
+        /* swap drawing colors */
+        eorx = fgx;
+        fgx  = bgx;
+        bgx  = eorx;
+        eorx = fgx ^ bgx;
+        /* draw cursor */
+        video_putchar (console_col * VIDEO_FONT_WIDTH,
+                       console_row * VIDEO_FONT_HEIGHT, ' ');
+        /* restore drawing colors */
+        eorx = fgx;
+        fgx  = bgx;
+        bgx  = eorx;
+        eorx = fgx ^ bgx;
+    }
+
+    if (!state && (cursor_state != state))
+    {
+        /* clear cursor */
+        video_putchar (console_col * VIDEO_FONT_WIDTH,
+                       console_row * VIDEO_FONT_HEIGHT, ' ');
+    }
+
+    cursor_state = state;
+}
+#endif
+
+/*****************************************************************************/
+
+#ifndef VIDEO_HW_RECTFILL
+static void memsetl (int *p, int c, int v)
+{
+    while (c--)
+        *(p++) = v;
+}
+#endif
+
+/*****************************************************************************/
+
+#ifndef VIDEO_HW_BITBLT
+static void memcpyl (int *d, int *s, int c)
+{
+    while (c--)
+        *(d++) = *(s++);
+}
+#endif
+
+/*****************************************************************************/
+
+static void console_scrollup (void)
+{
+    /* copy up rows ignoring the first one */
+
+#ifdef VIDEO_HW_BITBLT
+    video_hw_bitblt (
+    VIDEO_PIXEL_SIZE,     /* bytes per pixel */
+    0,                    /* source pos x */
+    VIDEO_LOGO_HEIGHT + VIDEO_FONT_HEIGHT, /* source pos y */
+    0,                    /* dest pos x */
+    VIDEO_LOGO_HEIGHT,    /* dest pos y */
+    VIDEO_VISIBLE_COLS,   /* frame width */
+    VIDEO_VISIBLE_ROWS - VIDEO_LOGO_HEIGHT - VIDEO_FONT_HEIGHT /* frame height */
+    );
+#else
+    memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, CONSOLE_SCROLL_SIZE >> 2);
+#endif
+
+    /* clear the last one */
+#ifdef VIDEO_HW_RECTFILL
+    video_hw_rectfill (
+    VIDEO_PIXEL_SIZE,     /* bytes per pixel */
+    0,                    /* dest pos x */
+    VIDEO_VISIBLE_ROWS - VIDEO_FONT_HEIGHT,  /* dest pos y */
+    VIDEO_VISIBLE_COLS,   /* frame width */
+    VIDEO_FONT_HEIGHT,    /* frame height */
+    CONSOLE_BG_COL          /* fill color */
+    );
+#else
+    memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, CONSOLE_BG_COL);
+#endif
+}
+
+/*****************************************************************************/
+
+static inline void console_back (void)
+{
+    CURSOR_OFF
+    console_col--;
+
+    if (console_col < 0)
+    {
+        console_col = CONSOLE_COLS - 1;
+        console_row--;
+        if (console_row < 0)
+        console_row = 0;
+    }
+    video_putchar (console_col * VIDEO_FONT_WIDTH,
+                   console_row * VIDEO_FONT_HEIGHT, ' ');
+}
+
+/*****************************************************************************/
+
+static void console_newline (void)
+{
+    CURSOR_OFF
+    console_row++;
+    console_col = 0;
+
+    /* Check if we need to scroll the terminal */
+    if (console_row >= CONSOLE_ROWS)
+    {
+    /* Scroll everything up */
+    console_scrollup ();
+
+    /* Decrement row number */
+    console_row--;
+    }
+}
+
+/*****************************************************************************/
+
+void video_putc (const char c)
+{
+    switch (c)
+    {
+    case 13: /* ignore */
+        break;
+
+    case '\n': /* next line */
+        console_newline();
+               CURSOR_ON
+        break;
+
+    case 9:    /* tab 8 */
+        CURSOR_OFF
+        console_col |=  0x0008;
+        console_col &= ~0x0007;
+
+        if (console_col >= CONSOLE_COLS)
+            console_newline();
+               CURSOR_ON
+        break;
+
+    case 8:    /* backspace */
+        console_back();
+               CURSOR_ON
+        break;
+
+    default: /* draw the char */
+        CURSOR_CLR
+        video_putchar (console_col * VIDEO_FONT_WIDTH,
+                       console_row * VIDEO_FONT_HEIGHT, c);
+        console_col++ ;
+
+        /* check for newline */
+        if (console_col >= CONSOLE_COLS)
+            console_newline();
+               CURSOR_ON
+               break;
+    }
+}
+
+
+
+/*****************************************************************************/
+
+void video_puts (const char *s)
+{
+    int count = strlen(s);
+
+    while(count--)
+        video_putc(*s++);
+}
+
+/*****************************************************************************/
+
+#ifdef CONFIG_VIDEO_LOGO
+void logo_plot (void *screen, int width, int x, int y)
+{
+    int skip = (width - LINUX_LOGO_WIDTH) * VIDEO_PIXEL_SIZE,
+        xcount, i,
+        ycount = LINUX_LOGO_HEIGHT;
+    unsigned char
+        *source = linux_logo,
+        *dest   = (unsigned char *) screen + ((y * width * VIDEO_PIXEL_SIZE) + x),
+        r, g, b;
+
+    if (VIDEO_DATA_FORMAT == GDF__8BIT_INDEX)
+    {
+        for (i = 0; i < LINUX_LOGO_COLORS; i++)
+        {
+            r = (unsigned char)linux_logo_red  [i];
+            g = (unsigned char)linux_logo_green[i];
+            b = (unsigned char)linux_logo_blue [i];
+            video_set_lut (LINUX_LOGO_LUT_OFFSET + i, r, g, b);
+        }
+    }
+
+    while (ycount--)
+    {
+    xcount = LINUX_LOGO_WIDTH;
+    while (xcount--)
+    {
+        r = (unsigned char)linux_logo_red  [*source - LINUX_LOGO_LUT_OFFSET];
+        g = (unsigned char)linux_logo_green[*source - LINUX_LOGO_LUT_OFFSET];
+        b = (unsigned char)linux_logo_blue [*source - LINUX_LOGO_LUT_OFFSET];
+
+        switch (VIDEO_DATA_FORMAT)
+        {
+        case GDF__8BIT_INDEX:
+            *dest = *source;
+            break;
+        case GDF__8BIT_332RGB:
+            *dest = ((r>>5)<<5) | ((g>>5)<<2) | (b>>6);
+            break;
+        case GDF_15BIT_555RGB:
+            *(unsigned short *)dest =
+            swap16((unsigned short)(((r>>3)<<10) | ((g>>3)<<5) | (b>>3)));
+            break;
+        case GDF_16BIT_565RGB:
+            *(unsigned short *)dest =
+            swap16((unsigned short)(((r>>3)<<11) | ((g>>2)<<5) | (b>>3)));
+            break;
+        case GDF_32BIT_X888RGB:
+            *(unsigned long  *)dest =
+            swap32((unsigned long)((r<<16) | (g<<8) | b));
+            break;
+        case GDF_24BIT_888RGB:
+#ifdef VIDEO_FB_LITTLE_ENDIAN
+            dest[0] = b;
+            dest[1] = g;
+            dest[2] = r;
+#else
+            dest[0] = r;
+            dest[1] = g;
+            dest[2] = b;
+#endif
+            break;
+        }
+        source++;
+        dest += VIDEO_PIXEL_SIZE;
+    }
+    dest += skip;
+    }
+}
+
+
+/*****************************************************************************/
+
+static void *video_logo (void)
+{
+    char info[128];
+
+    logo_plot (video_fb_address, VIDEO_COLS, 0, 0);
+
+    sprintf(info, " %s (%s - %s)", ARMBOOT_VERSION, __DATE__, __TIME__);
+    video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, info);
+
+#ifdef CONFIG_CONSOLE_EXTRA_INFO
+    {
+    int i, n = ((VIDEO_LOGO_HEIGHT-VIDEO_FONT_HEIGHT)/VIDEO_FONT_HEIGHT);
+
+    for (i = 1; i < n; i++)
+    {
+        video_get_info_str (i, info);
+        if (*info)
+        video_drawstring (VIDEO_INFO_X,
+                          VIDEO_INFO_Y + i*VIDEO_FONT_HEIGHT, info);
+    }
+    }
+#endif
+
+    return (video_fb_address + VIDEO_LOGO_HEIGHT * VIDEO_LINE_LEN);
+}
+#endif
+
+
+/*****************************************************************************/
+
+int video_init(void)
+{
+    unsigned char color8;
+
+    if (video_hw_init() == NULL)
+        return -1;
+
+    video_fb_address = (void*)VIDEO_FB_ADRS;
+
+    /* Init drawing pats */
+    switch (VIDEO_DATA_FORMAT)
+    {
+    case GDF__8BIT_INDEX:
+        video_set_lut (0x01, CONSOLE_FG_COL, CONSOLE_FG_COL, CONSOLE_FG_COL);
+        video_set_lut (0x00, CONSOLE_BG_COL, CONSOLE_BG_COL, CONSOLE_BG_COL);
+        fgx = 0x01010101;
+        bgx = 0x00000000;
+        break;
+    case GDF__8BIT_332RGB:
+        color8 = ((CONSOLE_FG_COL & 0xe0) | ((CONSOLE_FG_COL>>3) & 0x1c) | CONSOLE_FG_COL>>6);
+        fgx = (color8<<24) | (color8<<16) | (color8<<8) | color8;
+        color8 = ((CONSOLE_BG_COL & 0xe0) | ((CONSOLE_BG_COL>>3) & 0x1c) | CONSOLE_BG_COL>>6);
+        bgx = (color8<<24) | (color8<<16) | (color8<<8) | color8;
+        break;
+    case GDF_15BIT_555RGB:
+        fgx = (((CONSOLE_FG_COL>>3)<<26) | ((CONSOLE_FG_COL>>3)<<21) | ((CONSOLE_FG_COL>>3)<<16) |
+           ((CONSOLE_FG_COL>>3)<<10) | ((CONSOLE_FG_COL>>3)<<5)  |  (CONSOLE_FG_COL>>3));
+        bgx = (((CONSOLE_BG_COL>>3)<<26) | ((CONSOLE_BG_COL>>3)<<21) | ((CONSOLE_BG_COL>>3)<<16) |
+           ((CONSOLE_BG_COL>>3)<<10) | ((CONSOLE_BG_COL>>3)<<5)  |  (CONSOLE_BG_COL>>3));
+        break;
+    case GDF_16BIT_565RGB:
+        fgx = (((CONSOLE_FG_COL>>3)<<27) | ((CONSOLE_FG_COL>>2)<<21) | ((CONSOLE_FG_COL>>3)<<16) |
+           ((CONSOLE_FG_COL>>3)<<11) | ((CONSOLE_FG_COL>>2)<<5)  |  (CONSOLE_FG_COL>>3));
+        bgx = (((CONSOLE_BG_COL>>3)<<27) | ((CONSOLE_BG_COL>>2)<<21) | ((CONSOLE_BG_COL>>3)<<16) |
+           ((CONSOLE_BG_COL>>3)<<11) | ((CONSOLE_BG_COL>>2)<<5)  |  (CONSOLE_BG_COL>>3));
+        break;
+    case GDF_32BIT_X888RGB:
+        fgx = (CONSOLE_FG_COL<<16) | (CONSOLE_FG_COL<<8) | CONSOLE_FG_COL;
+        bgx = (CONSOLE_BG_COL<<16) | (CONSOLE_BG_COL<<8) | CONSOLE_BG_COL;
+        break;
+    case GDF_24BIT_888RGB:
+        fgx = (CONSOLE_FG_COL<<24) | (CONSOLE_FG_COL<<16) | (CONSOLE_FG_COL<<8) | CONSOLE_FG_COL;
+        bgx = (CONSOLE_BG_COL<<24) | (CONSOLE_BG_COL<<16) | (CONSOLE_BG_COL<<8) | CONSOLE_BG_COL;
+        break;
+    }
+
+       /* adapt fgx/bgx to host endianess */
+       fgx = cpu_to_be32(fgx);
+       bgx = cpu_to_be32(bgx);
+
+    eorx = fgx ^ bgx;
+
+#ifdef CONFIG_VIDEO_LOGO
+    /* Plot the logo and get start point of console */
+    PRINTD("Video: Drawing the logo ...\n");
+    video_console_address = video_logo();
+#else
+    video_console_address = video_fb_address;
+#endif
+
+    /* Initialize the console */
+    console_col  = 0;
+    console_row  = 0;
+
+    return 0 ;
+}
+
+
+
+#endif /* CONFIG_CFB_CONSOLE */

diff --git a/drivers/cursor.h b/drivers/cursor.h
new file mode 100644 (file)
index 0000000..b35ca1b
--- /dev/null
+++ b/drivers/cursor.h
@@ -0,0 +1,43 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+enum curstate
+{
+       CS_OFF,
+       CS_ON
+};
+
+
+/*
+** cursor control block
+*/
+struct curdef
+{
+       unsigned int  lin, clm; /* cursor position                */
+       enum curstate abl;              /* currently available ?          */
+       enum curstate vis;              /* currently visible ?            */
+       unsigned int  reverse;  /* character rendition attributes */
+       unsigned int  FGndCol, BGndCol;
+};
+

diff --git a/drivers/font.h b/drivers/font.h
new file mode 100644 (file)
index 0000000..9f9f06e
--- /dev/null
+++ b/drivers/font.h
@@ -0,0 +1,35 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+
+struct FontHead
+{
+       unsigned int fontlength;
+       unsigned int firstcode;
+       unsigned int ptnsize;
+       unsigned int rowsize;
+       unsigned int width;
+       unsigned int height;
+};
+

diff --git a/drivers/font8x14.c b/drivers/font8x14.c
new file mode 100644 (file)
index 0000000..b03edf4
--- /dev/null
+++ b/drivers/font8x14.c
@@ -0,0 +1,1491 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+
+/*
+ * Font "fnt8x14q.c"
+ */
+
+#include "config.h"
+
+#ifdef CONFIG_FRAMEBUFFER
+
+#include "font.h"
+
+const struct FontHead font_header =
+{
+       0x60,   /* fontlength*/
+       0x20,   /* firstcode */
+       28,             /* ptnsize   */
+       2,              /* rowsize   */
+       8,              /* width     */
+       14              /* height    */
+};
+
+
+const unsigned char font_pattern[] =
+{
+       /* CHR 0x20: ' ' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x21: '!' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x22: '"' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x23: '#' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x24: '$' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x3c, 0x00,     /* --****---------- */
+       0x50, 0x00,     /* -*-*------------ */
+       0x38, 0x00,     /* --***----------- */
+       0x14, 0x00,     /* ---*-*---------- */
+       0x78, 0x00,     /* -****----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x25: '%' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x22, 0x00,     /* --*---*--------- */
+       0x52, 0x00,     /* -*-*--*--------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x24, 0x00,     /* --*--*---------- */
+       0x2a, 0x00,     /* --*-*-*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x26: '&' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x30, 0x00,     /* --**------------ */
+       0x48, 0x00,     /* -*--*----------- */
+       0x48, 0x00,     /* -*--*----------- */
+       0x30, 0x00,     /* --**------------ */
+       0x4a, 0x00,     /* -*--*-*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x27: ''' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x38, 0x00,     /* --***----------- */
+       0x30, 0x00,     /* --**------------ */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x28: '(' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x29: ')' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2a: '*' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2b: '+' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x7c, 0x00,     /* -*****---------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2c: ',' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x38, 0x00,     /* --***----------- */
+       0x30, 0x00,     /* --**------------ */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2d: '-' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2e: '.' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x38, 0x00,     /* --***----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x2f: '/' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x80, 0x00,     /* *--------------- */
+       0x80, 0x00,     /* *--------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x30: '0' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x31: '1' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x30, 0x00,     /* --**------------ */
+       0x50, 0x00,     /* -*-*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x7c, 0x00,     /* -*****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x32: '2' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x20, 0x00,     /* --*------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x33: '3' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x1c, 0x00,     /* ---***---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x34: '4' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x0c, 0x00,     /* ----**---------- */
+       0x14, 0x00,     /* ---*-*---------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x35: '5' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x36: '6' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x1c, 0x00,     /* ---***---------- */
+       0x20, 0x00,     /* --*------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x37: '7' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x38: '8' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x39: '9' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x38, 0x00,     /* --***----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3a: ':' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x38, 0x00,     /* --***----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x38, 0x00,     /* --***----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3b: ';' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x38, 0x00,     /* --***----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x38, 0x00,     /* --***----------- */
+       0x30, 0x00,     /* --**------------ */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3c: '<' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3d: '=' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3e: '>' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x3f: '?' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x40: '@' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x4e, 0x00,     /* -*--***--------- */
+       0x52, 0x00,     /* -*-*--*--------- */
+       0x56, 0x00,     /* -*-*-**--------- */
+       0x4a, 0x00,     /* -*--*-*--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x41: 'A' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x42: 'B' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0xfc, 0x00,     /* ******---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0xfc, 0x00,     /* ******---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x43: 'C' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x44: 'D' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0xfc, 0x00,     /* ******---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0xfc, 0x00,     /* ******---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x45: 'E' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x78, 0x00,     /* -****----------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x46: 'F' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x78, 0x00,     /* -****----------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x47: 'G' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x4e, 0x00,     /* -*--***--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x48: 'H' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x49: 'I' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x7c, 0x00,     /* -*****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4a: 'J' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x1e, 0x00,     /* ---****--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x38, 0x00,     /* --***----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4b: 'K' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x48, 0x00,     /* -*--*----------- */
+       0x50, 0x00,     /* -*-*------------ */
+       0x60, 0x00,     /* -**------------- */
+       0x50, 0x00,     /* -*-*------------ */
+       0x48, 0x00,     /* -*--*----------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4c: 'L' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4d: 'M' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0xc6, 0x00,     /* **---**--------- */
+       0xaa, 0x00,     /* *-*-*-*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4e: 'N' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x52, 0x00,     /* -*-*--*--------- */
+       0x4a, 0x00,     /* -*--*-*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x4f: 'O' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x50: 'P' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x51: 'Q' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x52, 0x00,     /* -*-*--*--------- */
+       0x4a, 0x00,     /* -*--*-*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x52: 'R' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x50, 0x00,     /* -*-*------------ */
+       0x48, 0x00,     /* -*--*----------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x53: 'S' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x54: 'T' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0xfe, 0x00,     /* *******--------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x55: 'U' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x56: 'V' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x57: 'W' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0xaa, 0x00,     /* *-*-*-*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x58: 'X' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x28, 0x00,     /* --*-*----------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x59: 'Y' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5a: 'Z' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5b: '[' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5c: '\' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x80, 0x00,     /* *--------------- */
+       0x80, 0x00,     /* *--------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5d: ']' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x78, 0x00,     /* -****----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x78, 0x00,     /* -****----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5e: '^' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x28, 0x00,     /* --*-*----------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x5f: '_' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0xff, 0x00,     /* ********-------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x60: '`' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x38, 0x00,     /* --***----------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x61: 'a' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x3e, 0x00,     /* --*****--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x62: 'b' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x63: 'c' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x64: 'd' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x65: 'e' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x66: 'f' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x1c, 0x00,     /* ---***---------- */
+       0x22, 0x00,     /* --*---*--------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x67: 'g' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x38, 0x00,     /* --***----------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x68: 'h' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x69: 'i' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x30, 0x00,     /* --**------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x7c, 0x00,     /* -*****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6a: 'j' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x0c, 0x00,     /* ----**---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x38, 0x00,     /* --***----------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6b: 'k' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x48, 0x00,     /* -*--*----------- */
+       0x70, 0x00,     /* -***------------ */
+       0x48, 0x00,     /* -*--*----------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6c: 'l' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x30, 0x00,     /* --**------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x7c, 0x00,     /* -*****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6d: 'm' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0xec, 0x00,     /* ***-**---------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6e: 'n' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x6f: 'o' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x70: 'p' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x62, 0x00,     /* -**---*--------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x40, 0x00,     /* -*-------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x71: 'q' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x72: 'r' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x5c, 0x00,     /* -*-***---------- */
+       0x22, 0x00,     /* --*---*--------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x73: 's' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x30, 0x00,     /* --**------------ */
+       0x0c, 0x00,     /* ----**---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x74: 't' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x7c, 0x00,     /* -*****---------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x20, 0x00,     /* --*------------- */
+       0x22, 0x00,     /* --*---*--------- */
+       0x1c, 0x00,     /* ---***---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x75: 'u' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x76: 'v' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x28, 0x00,     /* --*-*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x77: 'w' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x82, 0x00,     /* *-----*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0x92, 0x00,     /* *--*--*--------- */
+       0xaa, 0x00,     /* *-*-*-*--------- */
+       0x44, 0x00,     /* -*---*---------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x78: 'x' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x18, 0x00,     /* ---**----------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x79: 'y' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x46, 0x00,     /* -*---**--------- */
+       0x3a, 0x00,     /* --***-*--------- */
+       0x02, 0x00,     /* ------*--------- */
+       0x42, 0x00,     /* -*----*--------- */
+       0x3c, 0x00,     /* --****---------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7a: 'z' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x04, 0x00,     /* -----*---------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x20, 0x00,     /* --*------------- */
+       0x7e, 0x00,     /* -******--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7b: '{' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x0e, 0x00,     /* ----***--------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x30, 0x00,     /* --**------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x0e, 0x00,     /* ----***--------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7c: '|' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x10, 0x00,     /* ---*------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7d: '}' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x70, 0x00,     /* -***------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x0c, 0x00,     /* ----**---------- */
+       0x10, 0x00,     /* ---*------------ */
+       0x08, 0x00,     /* ----*----------- */
+       0x08, 0x00,     /* ----*----------- */
+       0x70, 0x00,     /* -***------------ */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7e: '~' */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x24, 0x00,     /* --*--*---------- */
+       0x54, 0x00,     /* -*-*-*---------- */
+       0x48, 0x00,     /* -*--*----------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       /* CHR 0x7f:        */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+       0x00, 0x00,     /* ---------------- */
+};
+
+#endif /* CONFIG_FRAMEBUFFER */

diff --git a/drivers/framebuffer.c b/drivers/framebuffer.c
new file mode 100644 (file)
index 0000000..f1c7018
--- /dev/null
+++ b/drivers/framebuffer.c
@@ -0,0 +1,953 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+#include "config.h"
+
+#ifdef CONFIG_FRAMEBUFFER
+
+
+/*
+************************************************************
+** 
+** Bitmap screen driver
+** 
+************************************************************
+*/
+
+/*
+** The routines in this module provide an interface for the ansi
+** terminal emulator (ansi_console.c) to access a raster graphics
+** screen (aka framebuffer).
+*/
+
+#include "font.h"
+#include "cursor.h"
+
+/*
+************************************************************
+** Imports
+************************************************************
+*/
+
+extern void video_set_lut(
+    unsigned int index,     /* color number */
+    unsigned char r,        /* red */
+    unsigned char g,        /* green */
+    unsigned char b);       /* blue */
+
+extern void *video_framebuffer_init(
+       unsigned int *ax,               /* number of columns */
+       unsigned int *ay,               /* number of columns */
+       unsigned int *pitch,    /* vertical address offset */
+       unsigned int *fcol,             /* foreground color */
+       unsigned int *bcol);    /* background color */
+
+/*
+************************************************************
+** Some macros
+************************************************************
+*/
+
+/*
+** This defines the pixel size used by the frame buffer.
+** BPP_SHIFT = log2(BitsPerPixel), i.e. for eight bits
+** per pixel, this is 3.
+**
+** Note:
+** This code *should* work for BPP_SHIFT= 0, 1, 2, 3 and 4,
+** but as of today, only BPP_SHIFT = 3 has been tested!
+*/
+
+#if (CONFIG_FRAMEBUFFER_BPP == 16)
+#      define BPP_SHIFT        4
+#elif (CONFIG_FRAMEBUFFER_BPP == 8)
+#      define BPP_SHIFT        3
+#elif (CONFIG_FRAMEBUFFER_BPP == 4)
+#      define BPP_SHIFT        2
+#elif (CONFIG_FRAMEBUFFER_BPP == 2)
+#      define BPP_SHIFT        1
+#elif (CONFIG_FRAMEBUFFER_BPP == 1)
+#      define BPP_SHIFT        0
+#else
+#error "unsupported CONFIG_FRAMEBUFFER_BPP"
+#endif
+
+
+#define ABS(x) ((x) < 0 ? -(x) : (x))
+
+/*
+** All framebuffer accesses done by this code are 32-bit wide
+*/
+#define BITS_PER_PIXEL (1 << BPP_SHIFT)
+#define PIXEL_PER_LONG (32 >> BPP_SHIFT)
+
+#define UNIT_SHIFT             5
+#define BITS_PER_UNIT  (1 << UNIT_SHIFT)
+#define PIXEL_PER_UNIT (BITS_PER_UNIT / BITS_PER_PIXEL)
+#define ALIGN_MASK             (BITS_PER_UNIT - 1)
+#define UNITS_PER_LINE (PITCH / PIXEL_PER_UNIT)
+#define PTNSHIFT               (1 << (UNIT_SHIFT-BPP_SHIFT))
+#define PTNMASK                        ((1 << PTNSHIFT) - 1)
+
+/*
+** Macros for adapting this code to different endianesses:
+**
+** Note:
+** This code *should* work for little endian as well as
+** big endian configurations, however as of today, only
+** little endian has been tested!
+*/
+#ifdef __BIG_ENDIAN
+
+/* big endian case */
+#define hosttofb(x)            (x)
+#define fbtohost(x)            (x)
+#define fb_shr(x, s)   ((x) >> (s))
+#define fb_shl(x, s)   ((x) << (s))
+
+#else
+
+/* little endian case */
+#define SWAP32(x)      ((((x) >> 24) & 0x000000ff)| \
+                                       (((x) >>  8) & 0x0000ff00) | \
+                                       (((x) <<  8) & 0x00ff0000) | \
+                                       (((x) << 24) & 0xff000000) )
+
+#define hosttofb(x)            SWAP32(x)
+#define fbtohost(x)            SWAP32(x)
+#define fb_shr(x, s)   ((x) << (s))
+#define fb_shl(x, s)   ((x) >> (s))
+
+#endif
+
+
+
+/*
+************************************************************
+** Static storage requirements
+************************************************************
+*/
+struct ScreenDev
+{
+       unsigned int                    PlnSizX, PlnSizY;       /* screen size (in pixels) */
+       const struct FontHead   *pFontHead;                     /* font description parameters  */
+       const unsigned char             *pFont;                         /* Pointer to 1.st char pattern */
+       volatile unsigned long  *DispStartAddr;         /* display start address */
+       unsigned int                    Pitch;                          /* vertical address offset */
+       /*
+       ** conversion tables
+       ** Note: for BPP_SHIFT = 1, CharConv will be *very* big (256KB)
+       */       
+       unsigned long                   maskleft[BITS_PER_UNIT+1];
+       unsigned long                   maskright[BITS_PER_UNIT+1];
+#if (BPP_SHIFT > 0)
+       unsigned long                   CharConv[1 << PTNSHIFT];
+#endif
+};
+
+static struct ScreenDev this_dev;
+#define GetScreenDev() (&this_dev)
+
+/*
+** shortcuts to access static variables:
+*/
+#define FNTHEAD                (pSB->pFontHead)
+#define PITCH          (pSB->Pitch)
+#define MASKLEFT       (pSB->maskleft)
+#define MASKRIGHT      (pSB->maskright)
+#define CHARCONV       (pSB->CharConv)
+#define ADRS(y_start, x_aligned)\
+       ((volatile unsigned long *) ((pSB->DispStartAddr) + \
+               ((y_start) * units_per_line + (x_aligned))))
+
+/*
+** Imports from font module:
+*/
+extern const struct FontHead   font_header;
+extern const unsigned char             font_pattern[];
+
+#define GetFntHeadAddr()       (&font_header)
+#define GetFntPtnAddr()                (font_pattern)
+
+/*
+************************************************************
+**
+** Raster graphics (framebuffer) manipulation routines
+**
+************************************************************
+*/
+
+/*
+************************************************************
+** Local helper routine: the "color repeater"
+************************************************************
+*/
+static __inline__ unsigned long repcol(int color)
+{
+       unsigned long d = color;
+       int ColoredPixel,BitsPerPixel, ppl;
+
+       ppl = PIXEL_PER_LONG;
+
+       BitsPerPixel = BITS_PER_PIXEL;
+       ColoredPixel = ((1<<BitsPerPixel)-1) & d;
+
+       while (--ppl > 0) {
+               d <<= BitsPerPixel;
+               d |= ColoredPixel ;
+       }
+       return(d);
+}
+
+
+/*
+************************************************************
+** Initialize the device
+************************************************************
+*/
+static void raster_init(
+       struct ScreenDev *pSB,
+       unsigned int *fcol,
+       unsigned int *bcol)
+{
+       unsigned int i, j, ones;
+
+       /*
+       ** Initialize hardware, set video parameters
+       */
+       pSB->DispStartAddr = (volatile unsigned long*)
+               video_framebuffer_init(&pSB->PlnSizX, &pSB->PlnSizY,
+                                      &pSB->Pitch, fcol, bcol);
+       /*
+       ** set color palette entries for black and white
+       */
+#ifdef CONFIG_FRAMEBUFFER_CLUT
+       video_set_lut(*bcol, 0, 0, 0);
+       video_set_lut(*fcol, -1, -1, -1);
+#endif
+
+       /*
+       ** Initialize conversion arrays in static storage
+       */
+       for(i = 0; i < BITS_PER_UNIT+1; i++)
+       {
+               pSB->maskleft[i]  = hosttofb(0xffffffff << (BITS_PER_UNIT - i));
+               pSB->maskright[i] = hosttofb(0xffffffff >> (BITS_PER_UNIT - i));
+       }
+       ones = (1 << BITS_PER_PIXEL) - 1;
+       for (i = 0; i < (1 << PTNSHIFT); i++)
+       {
+               CHARCONV[i] = 0x00000000;
+               for(j = 0; j < PTNSHIFT; j++)
+               {
+                       if (i & (1<<j))
+                               CHARCONV[i] |= hosttofb(ones << (j * BITS_PER_PIXEL));
+               }
+       }
+}
+
+
+/*
+************************************************************
+** Clear window
+************************************************************
+*/
+static void raster_clear(
+       struct ScreenDev *pSB,
+       int    color,
+       int    xs,
+       int    ys,
+       int    ax,
+       int    ay)
+{
+       unsigned long col = repcol(color);
+       unsigned long lftmsk, rgtmsk;
+       long tmp;               /* general purpose register */
+       int xs_aligned;
+       int nr_of_longs;
+       volatile unsigned long *source_ptr, *sp;
+       int xs_bits, ax_bits;   /* pixel coordinates in bits */
+       int units_per_line = UNITS_PER_LINE;
+
+       /* Lefthand Edge of Cursor */
+       xs_bits = xs << BPP_SHIFT;
+       xs_aligned = xs_bits >> UNIT_SHIFT;     /* LONG offset from FRMBUF's left */
+       lftmsk = ~MASKLEFT[xs_bits & ALIGN_MASK];       /* mask for lefthand tail */
+
+
+       /* Righthand Edge of Cursor */
+       ax_bits = ax << BPP_SHIFT;
+       tmp = xs_bits + ax_bits - 1;    /* bit offset from FRMBUF's left margin  */
+       rgtmsk = MASKLEFT[(tmp & ALIGN_MASK) + 1];      /* mask for righthand tail   */
+
+       /* Horizontal Sizing */
+       nr_of_longs = ((tmp >> UNIT_SHIFT) - xs_aligned) - 1;   /* LONGS between tails */
+
+       source_ptr = ADRS(ys, xs_aligned);
+
+       while (--ay >= 0)
+       {
+               sp = source_ptr;
+
+               source_ptr += units_per_line;
+
+               if (nr_of_longs < 0)
+                       *sp = (*sp & (~lftmsk | ~rgtmsk)) | (col & lftmsk & rgtmsk);
+               else
+               {
+                       *sp++ = (*sp & ~lftmsk) | (col & lftmsk);
+
+                       tmp = nr_of_longs;
+                       while (--tmp >= 0)
+                               *sp++ = col;
+
+                       *sp = (*sp & ~rgtmsk) | (col & rgtmsk);
+               }
+       }
+}
+
+/*
+************************************************************
+** Screen copy routine
+************************************************************
+*/
+
+/*
+**  some macros to copy a normal line
+*/
+
+#define CPY_LEFT(sp, dp, maskl)\
+{\
+       *dp++ = (*sp++ & ~(maskl)) | (*dp & (maskl));\
+}
+
+#define CPY_RIGHT(sp, dp, maskr)\
+{\
+       *dp = (*sp & (maskr)) | (*dp & (~(maskr)));\
+}
+
+/*
+**  macro to copy a line if copy region is within one longword
+*/
+
+#define CPY_SPECIAL(sp, dp, mask, notmask)\
+{\
+       *dp = (*sp & (mask)) | (*dp & (notmask));\
+}
+
+
+static void raster_vcopy(
+       struct ScreenDev *pSB,
+       long x_src,
+       long y_src,
+       long ax,
+       long ay,
+       long y_dst)
+{
+       volatile unsigned long *sp, *dp;
+       long counter2;
+       long units_per_line = UNITS_PER_LINE;
+       long counter1;
+       long right_margin;
+       unsigned long maskr, maskl;
+       char *source_ptr, *dest_ptr;
+       long abs_ay = ABS(ay);
+       long modl, modr;
+       long x_aligned;
+       long xs_bits, ax_bits;
+
+    /* special mask: combination of left and right margin mask */
+       xs_bits = x_src << BPP_SHIFT;
+       ax_bits = ax << BPP_SHIFT;
+       x_aligned = xs_bits >> UNIT_SHIFT;
+
+       right_margin = (xs_bits + ax_bits) / BITS_PER_UNIT - 1;
+       modl = xs_bits & ALIGN_MASK;
+       modr = (xs_bits + ax_bits) & ALIGN_MASK;
+
+       /* calculate source and destination address */
+       sp = ADRS (y_src, x_aligned);
+       dp = ADRS (y_dst, x_aligned);
+
+       if (ay < 0)
+               units_per_line = -units_per_line;
+
+       /*
+       ** speed optimization: declaring source_ptr and dest_ptr
+       ** as char pointers will allow us pre-multipy units_per_line
+       ** by four (sizeof(unsigned long)) OUTSIDE of all loops
+       */
+       source_ptr = (char*)sp;
+       dest_ptr   = (char*)dp;
+       units_per_line <<= 2;
+
+       /* copy region within the same longword */
+       if (xs_bits + BITS_PER_UNIT > xs_bits + ax_bits)
+       {       /* combine left and right margin mask */
+               maskl = MASKRIGHT[modl] & MASKLEFT[modr];
+               maskr = ~maskl;
+               for (counter1 = 0; counter1 <= abs_ay; ++counter1)
+               {
+                       sp = (unsigned long*)source_ptr;
+                       dp = (unsigned long*)dest_ptr;
+                       source_ptr += units_per_line;
+                       dest_ptr   += units_per_line;
+                       CPY_SPECIAL (sp, dp, maskl, maskr);
+               }
+       }
+       else    /* copy region in different longwords */
+       {
+               maskl = MASKLEFT[modl];
+               maskr = MASKLEFT[modr];
+               if(maskr || maskl)
+               {
+                       for (counter1 = 0; counter1 <= abs_ay; ++counter1)
+                       {
+                               sp = (unsigned long*)source_ptr;
+                               dp = (unsigned long*)dest_ptr;
+                               source_ptr += units_per_line;
+                               dest_ptr   += units_per_line;
+                               CPY_LEFT   (sp, dp, maskl);     /* copy left margin of region */
+                               if((counter2 = right_margin)) do
+                                       *dp++ = *sp++;
+                               while(--counter2);
+                               CPY_RIGHT  (sp, dp, maskr);     /* copy right margin of region */
+                       }
+               }
+               else
+               {       /*
+                       ** maskr = maskl = 0: this special case is well worth
+                       ** to be considered seperately as it seems to be the most
+                       ** common case when scrolling:
+                       */
+                       ++right_margin;
+                       if(((counter1 = (abs_ay + 1)) > 0) && 
+                          ((counter2 = right_margin) > 0)) do
+                       {
+                               sp = (unsigned long*)source_ptr;
+                               dp = (unsigned long*)dest_ptr;
+                               source_ptr += units_per_line;
+                               dest_ptr   += units_per_line;
+                               do
+                                       *dp++ = *sp++;
+                               while(--counter2);
+                               counter2 = right_margin;
+                       }
+                       while(--counter1);
+               }
+       }
+}
+
+/*
+************************************************************
+** Draw filled rectangle routine
+************************************************************
+*/
+
+static void raster_frct(
+       struct ScreenDev *pSB,
+       int color,
+       int xs,
+       int ys,
+       int ax,
+       int ay)
+{
+       unsigned long col = repcol(color);
+       unsigned long lftmsk, rgtmsk;
+       long tmp;
+       int xs_aligned;
+       int nr_of_longs;
+       volatile unsigned long *source_ptr, *sp;
+       int xs_bits, ax_bits;
+       int units_per_line = UNITS_PER_LINE;
+
+       /* Lefthand Edge of Cursor */
+       xs_bits = xs << BPP_SHIFT;
+       xs_aligned = xs_bits >> UNIT_SHIFT;    /* LONG offset from FRMBUF's left margin */
+       lftmsk = ~MASKLEFT[xs_bits & ALIGN_MASK]; /* mask for lefthand tail */
+
+       ax_bits = ax << BPP_SHIFT;
+
+       /* Righthand Edge of Cursor */
+       tmp = xs_bits + ax_bits - 1;    /* bit offset from FRMBUF's left margin */
+       rgtmsk = MASKLEFT[(tmp & ALIGN_MASK) + 1];      /* mask for righthand tail */
+
+       nr_of_longs = ((tmp >> UNIT_SHIFT) - xs_aligned) - 1; /* LONGS between tails */
+
+       source_ptr = ADRS (ys, xs_aligned);
+
+       while(--ay >= 0)
+       {
+               sp = source_ptr;
+
+               source_ptr += units_per_line;
+
+               if(nr_of_longs < 0)
+                       *sp ^= col & lftmsk & rgtmsk;
+               else
+               {
+                       *sp++ ^= col & lftmsk;
+
+                       tmp = nr_of_longs;
+                       while( --tmp >= 0)
+                               *sp++ ^= col;
+                       *sp ^= col & rgtmsk;
+               }
+       }
+}
+
+/*
+************************************************************
+** Character printer routine
+************************************************************
+*/
+
+#define CHAR_2LONGS(fp, work_reg)\
+{\
+       work_reg |= fb_shr(char_reg, shift);\
+       *fp++ = work_reg;\
+       work_reg = *fp & rgtmsk;\
+       work_reg |= fb_shl(char_reg, (BITS_PER_UNIT - shift)) & (~rgtmsk);\
+       *fp = work_reg;\
+}
+
+#define CHAR_1LONG(fp, work_reg)\
+{\
+       work_reg |= fb_shr(char_reg, shift) & (~rgtmsk);\
+       *fp = work_reg;\
+}
+
+#define NEXT_ROW()\
+{\
+       char_row_ptr += rowsize;\
+       ax_bits = ax << BPP_SHIFT;\
+}
+
+#define SETUP()\
+{\
+       crp = (unsigned char *)char_row_ptr;\
+       fp = frame_ptr;\
+       frame_ptr += units_per_line;\
+       work_reg = *fp & lftmsk;\
+       ptnshift = 8;\
+}
+
+#if (BPP_SHIFT == 0)
+#define GET_CHAR_REG(index)\
+{\
+       char_reg  = fbtohost(*((unsigned long*)crp)++);\
+}
+#endif
+
+#if (BPP_SHIFT == 1)
+#define GET_CHAR_REG(index)\
+{\
+       char_reg = CHARCONV[*((unsigned short*)crp)++];\
+       char_reg = (fcol & char_reg) | (bcol & (char_reg ^ MASKLEFT[index]));\
+}
+#endif
+
+#if (BPP_SHIFT == 2)
+#define GET_CHAR_REG(index)\
+{\
+       char_reg = CHARCONV[*crp++];\
+       char_reg = (fcol & char_reg) | (bcol & (char_reg ^ MASKLEFT[index]));\
+}
+#endif
+
+#if (BPP_SHIFT == 3)
+#define GET_CHAR_REG(index)\
+{\
+       if((ptnshift -= PTNSHIFT) == 0) {\
+               char_reg = CHARCONV[*crp & PTNMASK];\
+               crp++;\
+               ptnshift = 8;\
+       }\
+       else\
+       {\
+               char_reg = CHARCONV[(*crp >> ptnshift) & PTNMASK];\
+       }\
+       char_reg = (fcol & char_reg) | (bcol & (char_reg ^ MASKLEFT[index]));\
+}
+#endif
+
+#if (BPP_SHIFT == 4)
+#define GET_CHAR_REG(index)\
+{\
+       if((ptnshift -= PTNSHIFT) == 0) {\
+               char_reg = CHARCONV[*crp & PTNMASK];\
+               crp++;\
+               ptnshift = 8;\
+       }\
+       else\
+       {\
+               char_reg = CHARCONV[(*crp >> ptnshift) & PTNMASK];\
+       }\
+       char_reg = (fcol & char_reg) | (bcol & (char_reg ^ MASKLEFT[index]));\
+}
+#endif
+
+static void raster_print(
+       struct ScreenDev *pSB,
+       const unsigned char *char_ptr,
+       unsigned long rowsize,                          /* width of one pattern line */
+       long xs,
+       long ys,
+       long ax,
+       long ay,
+       int fgcolor,
+       int bgcolor)
+{
+       unsigned long fcol = repcol(fgcolor);
+       unsigned long bcol = repcol(bgcolor);
+       unsigned long work_reg, char_reg;
+       volatile unsigned long *fp;
+       unsigned char *crp;
+       const unsigned char *char_row_ptr;
+       unsigned long ax_bits;
+       int shift;
+       unsigned long lftmsk, rgtmsk, ptnshift;
+       long tmp;
+       volatile unsigned long *frame_ptr;
+       int xs_aligned;
+       unsigned long xs_bits;
+       int units_per_line = UNITS_PER_LINE;
+
+       /* Lefthand Edge of cursor */
+       xs_bits = xs << BPP_SHIFT;
+       xs_aligned = xs_bits >> UNIT_SHIFT;     /* long offset from frmbuf's left margin */
+       lftmsk = MASKLEFT[xs_bits & ALIGN_MASK];        /* mask for lefthand tail */
+
+       char_row_ptr = char_ptr;
+       ax_bits = ax << BPP_SHIFT;
+
+       /* Righthand Edge of Cursor */
+       tmp = xs_bits + ax_bits - 1;    /* bit offset from frmbuf's left margin */
+       rgtmsk = ~MASKLEFT[(tmp & ALIGN_MASK) + 1];     /* mask for righthand tail */
+
+       frame_ptr = ADRS(ys, xs_aligned);
+
+       shift = (xs_bits & ALIGN_MASK);
+
+       if((xs_bits & ALIGN_MASK) == 0)
+       {       /* n * long (aligned) + rest within 1 long (aligned) */
+               while(--ay >= 0)
+               {
+                       SETUP();
+
+                       while(ax_bits > BITS_PER_UNIT)
+                       {
+                               GET_CHAR_REG(BITS_PER_UNIT);
+                               ax_bits -= BITS_PER_UNIT;
+                               *fp++ = char_reg;
+                       }
+
+                       work_reg = *fp & rgtmsk;
+                       GET_CHAR_REG(ax_bits);
+                       CHAR_1LONG(fp, work_reg);
+
+                       NEXT_ROW();
+               }
+       }
+       else
+       {
+               if(ax_bits <= BITS_PER_UNIT)
+               {
+                       if((xs_bits / BITS_PER_UNIT) ==
+                          ((xs_bits + ax_bits - 1) / BITS_PER_UNIT))
+                       {                                       /* only rest within 1 long (unaligned) */
+                               while(--ay >= 0)
+                               {
+                                       SETUP();
+
+                                       work_reg |= *fp & rgtmsk;
+                                       GET_CHAR_REG(ax_bits);
+                                       CHAR_1LONG(fp, work_reg);
+
+                                       NEXT_ROW();
+                               }
+                       }
+                       else
+                       {       /* only rest over 2 longs (unaligned) */
+                               while(--ay >= 0)
+                               {       /* loop over rows */
+                                       SETUP();
+
+                                       GET_CHAR_REG(ax_bits);
+                                       CHAR_2LONGS(fp, work_reg);
+                                       NEXT_ROW();
+                               }
+                       }
+               }
+               else
+               {
+                       if((xs_bits / BITS_PER_UNIT) ==
+                          ((xs_bits + ((ax_bits - 1) & ALIGN_MASK)) / BITS_PER_UNIT))
+                       {       /* n * long (unaligned) + rest within 1 long (unaligned) */
+                               while(--ay >= 0)
+                               {
+                                       SETUP();
+
+                                       while(ax_bits > BITS_PER_UNIT)  /* loop within one row */
+                                       {
+                                               GET_CHAR_REG(BITS_PER_UNIT);
+                                               ax_bits -= BITS_PER_UNIT;
+                                               work_reg |= fb_shr(char_reg, shift);
+                                               *fp++ = work_reg;
+                                               work_reg = fb_shl(char_reg, (BITS_PER_UNIT - shift));
+                                       }
+
+                                       GET_CHAR_REG(ax_bits);
+                                       work_reg |= *fp & rgtmsk;
+                                       CHAR_1LONG(fp, work_reg);
+                                       NEXT_ROW();
+                               }
+                       }
+                       else
+                       {       /* n * long (unaligned) + rest over 2 longs (unaligned ) */
+                               while(--ay >= 0)
+                               {
+                                       SETUP();
+
+                                       while(ax_bits > BITS_PER_UNIT)  /* loop within one row */
+                                       {
+                                               GET_CHAR_REG(BITS_PER_UNIT);
+
+                                               ax_bits -= BITS_PER_UNIT;
+                                               work_reg |= fb_shr(char_reg, shift);
+                                               *fp++ = work_reg;
+                                               work_reg = fb_shl(char_reg, (BITS_PER_UNIT - shift));
+                                       }
+
+                                       GET_CHAR_REG(ax_bits);
+                                       CHAR_2LONGS(fp, work_reg);
+                                       NEXT_ROW();
+                               }
+                       }
+               }
+       }
+}
+
+/*
+************************************************************
+**
+** Entry points
+**
+************************************************************
+*/
+
+/*
+************************************************************
+** initialize hardware, handle font
+************************************************************
+*/
+void screen_init(
+       unsigned int *fcol, 
+       unsigned int *bcol, 
+       unsigned int *nlines,
+       unsigned int *nclms)
+{
+       struct ScreenDev *pSB = GetScreenDev();
+
+       pSB->pFontHead = GetFntHeadAddr();
+       pSB->pFont     = GetFntPtnAddr();
+
+       /* initialize raster graphics hardware */
+       raster_init(pSB, fcol, bcol);
+
+       /* clear screen */
+       raster_clear(pSB, *bcol, 0, 0, pSB->PlnSizX, pSB->PlnSizY);
+
+       /*
+       ** Calculate size (in characters) of the terminal window based on
+       ** the size of the font and the graphical resolution
+       */
+       *nclms  = pSB->PlnSizX / FNTHEAD->width;
+       *nlines = pSB->PlnSizY / FNTHEAD->height;
+}
+
+
+/*
+************************************************************
+**  screen_curset(): set block or dash cursor
+************************************************************
+*/
+void screen_curset(struct curdef *cursor)
+{
+       struct ScreenDev *pSB = GetScreenDev();
+       int curcol = cursor->FGndCol ^ cursor->BGndCol;
+       int x_start, y_start, delta_x, delta_y;
+
+       x_start = cursor->clm * FNTHEAD->width;
+       y_start = cursor->lin * FNTHEAD->height;
+       delta_x = FNTHEAD->width;
+       delta_y = FNTHEAD->height;
+       raster_frct(pSB, curcol, x_start, y_start, delta_x, delta_y);
+}
+
+
+/*
+************************************************************
+** screen_curclr(): clear cursor
+************************************************************
+*/
+void screen_curclr(struct curdef *cursor)
+{
+       screen_curset(cursor);
+}
+
+/*
+************************************************************
+**  screen_cpylns(): copy a number of lines from source to destination
+************************************************************
+*/
+void screen_cpylns(
+       int from_lin,                   /* first line to be copied */
+       int to_lin,                             /* first line of destination area */
+       int nr_of_lins)                 /* number of lines to be copied */
+{
+       struct ScreenDev *pSB = GetScreenDev();
+       int from, to;
+       int dy, dy1;
+
+       if(nr_of_lins)                          /* if more than zero lines */
+       {
+               if(nr_of_lins < 0)              /* standardize to positive nr_of_lines */
+               {
+                       nr_of_lins = -nr_of_lins;
+                       from_lin -= nr_of_lins + 1;     /* goto other edge! */
+                       to_lin -= nr_of_lins + 1;
+               }
+
+               /*
+               ** transform line numbers to raster coordinates
+               ** size of area in units of raster lines
+               */
+               dy = nr_of_lins * FNTHEAD->height;
+               from = from_lin * FNTHEAD->height;
+               to =   to_lin   * FNTHEAD->height;
+               dy1 = dy - 1;                   /* delta y */
+
+               /* if TO is within [FROM,FROM+DY] then change the direction */
+               if(((from - to) ^ (from + dy - to)) < 0)
+               {
+                       to = to + dy1;
+                       from = from + dy1;
+                       dy1 = -dy;
+               }
+               /* call hardware copy function */
+               raster_vcopy(pSB, 0, from, pSB->PlnSizX, dy1, to);
+       }
+}
+
+
+/*
+************************************************************
+** screen_erase(): clear a number of lines and columns
+************************************************************
+*/
+void screen_erase(
+       int from_lin,                   /* first line to be erased */
+       int from_clm,                   /* first col to be erased */
+       int nr_of_lins,                 /* number of lines to be erased */
+       int nr_of_clms,                 /* number of columns to be erased */
+       unsigned int BGndCol)
+{
+       struct ScreenDev *pSB = GetScreenDev();
+       int line, column;
+       int delta_line, delta_column;
+
+       if(nr_of_clms && nr_of_lins)    /* if more than 0 columns and lines */
+       {
+               /* standardize to positive nr_of_lines and nr_of_columns */
+               if(nr_of_clms < 0)
+               {
+                       nr_of_clms = -nr_of_clms;
+                       from_clm -= nr_of_clms + 1;     /* goto other edge! */
+               }
+
+               if(nr_of_lins < 0)
+               {
+                       nr_of_lins = -nr_of_lins;
+                       from_lin -= nr_of_lins + 1;     /* goto other edge! */
+               }
+
+               /* transform line and column number to raster coordinates */
+               line = from_lin * FNTHEAD->height;
+               column = from_clm * FNTHEAD->width;
+
+               delta_line = nr_of_lins * FNTHEAD->height;
+               delta_column = nr_of_clms * FNTHEAD->width;
+
+               raster_clear(pSB, BGndCol, column, line, delta_column, delta_line);
+       }
+}
+
+
+/*
+************************************************************
+** screen_chrlow(): print one character from the first characterset
+**
+** Note: blink attribute not supported
+************************************************************
+*/
+void screen_chrlow(
+       unsigned char charcode,
+       struct curdef *cursor)
+{
+       struct ScreenDev *pSB = GetScreenDev();
+       const unsigned char *ptnpointer;        /* ptr to actual character's pattern */
+       unsigned int BGndCol, FGndCol, TempCol; /* to exchange colors */
+       int curxpos, curypos;
+
+       if((charcode -= FNTHEAD->firstcode) >= FNTHEAD->fontlength)
+               charcode = FNTHEAD->fontlength - 1;
+       ptnpointer = (pSB->pFont + charcode * FNTHEAD->ptnsize);
+
+       FGndCol = cursor->FGndCol;
+       BGndCol = cursor->BGndCol;
+
+       if(cursor->reverse)
+       {
+               TempCol = BGndCol;
+               BGndCol = FGndCol;
+               FGndCol = TempCol;
+       }
+
+       curxpos = cursor->clm * FNTHEAD->width;
+       curypos = cursor->lin * FNTHEAD->height;
+
+       raster_print(pSB, ptnpointer, FNTHEAD->rowsize, curxpos, curypos,
+                       FNTHEAD->width, FNTHEAD->height, FGndCol, BGndCol);
+}
+
+/*
+************************************************************
+** screen_bell(): ring the terminal bell
+************************************************************
+*/
+void screen_bell(void)
+{      /* currently not supported -- some day we might add  visible bell here */
+}
+
+#endif /* CONFIG_FRAMEBUFFER */

diff --git a/drivers/keyboard.c b/drivers/keyboard.c
new file mode 100644 (file)
index 0000000..c7623e5
--- /dev/null
+++ b/drivers/keyboard.c
@@ -0,0 +1,456 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+#include "config.h"
+
+
+#ifdef CONFIG_KEYBOARD
+
+#include <armboot.h>
+#include "keyboard.h"
+
+/*
+** Keyboard encoder for simple (make/break) keyboard
+*/
+
+/*
+************************************************************
+** Configuration section
+************************************************************
+*/
+
+/*
+** define the lowlevel driver (the one that delivers the
+** scancodes):
+*/
+#ifdef CONFIG_KEYBOARD_IRDA
+
+/* use IrDA keyboard driver */
+extern void irkbd_init(void);
+extern void irkbd_setleds(int);
+extern int  irkbd_tstc(void);
+extern int  irkbd_getc(void);
+
+#define KEYBOARD_DEV_INIT              irkbd_init
+#define KEYBOARD_DEV_TSTC              irkbd_tstc
+#define KEYBOARD_DEV_GETC              irkbd_getc
+#define KEYBOARD_DEV_SETLEDS   0
+#endif
+
+/*
+** The table of supported keyboard mappings:
+*/
+extern const struct maptable kbd_mapping_table[];
+
+
+/*
+************************************************************
+** static storage requirements
+************************************************************
+*/
+struct state
+{
+       unsigned int                            status;
+       unsigned int                            released;
+       unsigned int                            composereceived;
+       unsigned int                            lookahead;
+       unsigned int                            lookaheadvalid;
+       int                                                     (*kbd_tstc)(void);
+       int                                                     (*kbd_getc)(void);
+       void                                            (*set_leds)(int);
+       const unsigned char                     *sequenceptr;
+       const struct keyboardmap        *kbd_header;
+       unsigned char                           composebuffer[2];
+};
+
+#define Status                 (pSB->status)
+#define        SequencePtr             (pSB->sequenceptr)
+#define ComposeReceived        (pSB->composereceived)
+#define Kbd_getc               (pSB->kbd_getc)
+#define Kbd_tstc               (pSB->kbd_tstc)
+#define Set_leds               (pSB->set_leds)
+#define CC                             (pSB->composebuffer)
+#define Released               (pSB->released)
+#define LookAheadValid (pSB->lookaheadvalid)
+#define LookAhead              (pSB->lookahead)
+#define KbMapping              (pSB->kbd_header)
+
+static struct state kbdencode_stateblock;
+#define GetStateBlockAddr()    (&kbdencode_stateblock)
+
+
+#define StatusTable            (pKB->statustable)
+#define ConvTabSize            (pKB->convtabsize)
+#define ConvTables             (pKB->convtables)
+#define SeqString              (pKB->seqstring)
+#define ComposeTable   (pKB->composetable)
+#define MakeCode               (pKB->makecode)
+#define BreakCode              (pKB->breakcode)
+#define MkBrkMask              (pKB->mkbrkmask)
+
+/*
+** mask for all modifier keys which are non-toggle keys, i.e.
+** keys which are active only as long as they are held down:
+*/
+#define S_NOTOGGLE     (S_LCTRL|S_RCTRL|S_LALT|S_RALT|S_LSHIFT|S_RSHIFT)
+#define S_MODIFIER     (S_LCTRL|S_RCTRL|S_LALT|S_RALT|S_LSHIFT|S_RSHIFT) 
+
+/*
+**************************************************************
+** Look up a compose character from compose table
+**************************************************************
+*/
+static int composechar(struct state  *pSB, const struct keyboardmap *pKB, unsigned char *c)
+{
+       unsigned char       *cp = c;
+       const struct compose_char *ct;
+
+       ct = ComposeTable;
+       while(ct->subst)
+       {
+               if(ct->c[0] == *cp)
+                       if(ct->c[1] == *(cp + 1))
+                               break;
+               ++ct;
+       }
+       if(ct->subst)
+               return(ct->subst);
+
+       ct = ComposeTable;
+       cp++;
+
+       while(ct->subst)
+       {
+               if(ct->c[0] == *cp)
+                       if(ct->c[1] == *(cp - 1))
+                               break;
+               ++ct;
+       }
+       return(ct->subst);
+}
+
+
+/*
+**************************************************************
+* scancode to ASCII encoding state machine
+**************************************************************
+*/
+static int encode(
+       struct state  *pSB,
+       const struct keyboardmap *pKB,
+       unsigned int  c,                /* the scancode */
+       int           released, /* wether the key was pressed or released */
+       const unsigned char **sequence)
+{
+       unsigned short  Code;
+       const unsigned char     *Seq, *sq;
+       int                             TableIndex;
+
+       /*
+       ** compose table index from control, shift, alt and prefix states:
+       **
+       ** The state of the six modifier keys (6 bits) is translated via
+       ** the status translation table to obtain the actual logical status
+       ** of SHIFT, CONTROL and ALT (3 bits).
+       */
+       TableIndex = *(StatusTable + (Status & (S_MODIFIER)));
+
+       TableIndex &= (NUM_CONVTABLES-1);       /* just a safety measure */
+       if(c >= ConvTabSize)
+               c = 0;
+
+       Code = *(ConvTables[TableIndex] + c);  /* get code from table */
+       if(Code & 0x8000)
+               Code &= 0xff;
+
+       if(Code & MODIFIER_KEY)  /* was it shift, alt, ctrl, numlock or capslock ? */
+       {
+               if(Code & S_NOTOGGLE) /* was it shift, alt or ctrl */
+               {
+                       Code &= S_NOTOGGLE;
+                       if(released)                       /* if the key has been released,   */
+                       {                         /* reset the appropiate status bit */
+                               Status &= ~Code;
+                               return(-1);
+                       }
+                       else
+                       {   /* if the key has been pressed, set the status bit */
+                               Status |= Code;
+                               return(-1);
+                       }
+               }
+               else   /* compose key, numlock or capslock: */
+               {
+                       Code &= (S_COMPOSE | S_NUMLOCK | S_CAPSLOCK);
+                       if(released)
+                       {  /* key released: ignore it */
+                               return(-1);
+                       }
+                       else
+                       {   /* if key has been newly pressed,
+                                  toggle the appropriate status bit */
+                               Status ^= Code;
+                               if(Code & S_COMPOSE)     /* was it the compose key ?    */
+                                       ComposeReceived = 0; /* init compose sequence if so */
+                               else if(Set_leds)
+                               { /* update keyboard status indicators if numlock or capslock */
+                                       Set_leds(((!!(Status & S_NUMLOCK)) << 2)|
+                                                ((!!(Status & S_CAPSLOCK)) << 1));
+                               }
+                               return(-1);
+                       }
+               }
+       }
+       else  /* non-special key pressed or released: */
+       {
+               if(released)  /* key has been released: */
+               {   /* return 'no character' */
+                       return(-1);
+               }
+               else    /* key is pressed: */
+               {
+                       if(Code & AUTOCOMPOSE_KEY)    /* autocompose key ? */
+                       {       /*
+                               ** If a key's conversion table value has 
+                               ** the AUTOCOMPOSE_KEY bit set, the value
+                               ** is treated as an offset to a string
+                               ** which determines a sequence to be generated
+                               ** by that key:
+                               */
+                               if(!(Status & S_COMPOSE)) /* not yet in compose sequence ? */
+                               {
+                                       Status |= S_COMPOSE;  /* init compose sequence if so */
+                                       ComposeReceived = 0;
+                               }
+                               Code &= ~AUTOCOMPOSE_KEY; /* strip compose bit off key code */
+                       }
+                       if(Code & SEQUENCE_KEY)
+                       { /* if sequence key: */
+                               Code &= ~SEQUENCE_KEY;
+                               Seq = SeqString[Code];  /* get pointer to sequence */
+
+                               if(Status & S_NUMLOCK)
+                               {                       /* if numlock is active:        */
+                                       sq = Seq;           /* see if there is an alternate */
+                                       while(*sq++)        /* character at the end of the  */
+                                               ;               /* sequence. If so, return this */
+                                       if((Code = *sq))    /* character, otherwise return  */
+                                               return(Code);   /* the sequence                 */
+                                       else
+                                       {
+                                               *sequence = Seq;
+                                               return(-1);
+                                       }
+                               }
+                               else
+                               {  /* no numlock: flag sequence and return it: */
+                                       *sequence = Seq;
+                                       return(-1);
+                               }
+                       }
+                       else
+                       {   /* normal key */
+                               if(Status & S_COMPOSE) /* are we in a compose sequence ? */
+                               {
+                                       CC[ComposeReceived++] = Code; /* store the character */
+                                       if(ComposeReceived == 2)      /* do we have both ?   */
+                                       {
+                                               Status &= ~S_COMPOSE;     /* clear compose status */
+                                               Code = composechar(pSB, pKB, CC);  /* return composed character */
+                                       }
+                                       else /* only first component: wait for next one */
+                                               return(-1);
+                               }
+                               else if(Status & S_CAPSLOCK)
+                               {       /* convert to upper case if capslock active */
+                                       if(Code >= 'a' && Code <= 'z')
+                                               Code -= 'a' - 'A';
+                               }
+                               return(Code);
+                       }
+               }
+       }
+}
+
+
+/*
+**************************************************************
+** get next byte from the keyboard
+**************************************************************
+*/
+
+static int nextchar(struct state  *pSB)
+{
+       const struct keyboardmap *pKB = KbMapping;
+       int c = -1;
+
+       if(!SequencePtr)        /* no sequence of characters being output ? */
+       {
+               /*
+               ** read from keyboard port and pass the keycode
+               ** through the encoder
+               */
+nextk: if(!Kbd_tstc())                 /* any  key available ?   */
+                       return(-1);
+               else if((c = Kbd_getc()) < 0)
+                       return(c);                      /* error reading keyboard */
+               else if((c & MkBrkMask) == MakeCode)
+               {
+                       Released = 0;           /* key pressed: continue  */
+                       if(MkBrkMask == 0xffffffff)
+                               goto nextk;             /* consume make code */
+                       else
+                               c &= ~MkBrkMask;        /* strip make bit(s) from keycode */
+               }
+               else if((c & MkBrkMask) == BreakCode)
+               {
+                       Released = 1;           /* key released: continue */
+                       if(MkBrkMask == 0xffffffff)
+                               goto nextk;             /* consume break code */
+                       else
+                               c &= ~MkBrkMask;        /* strip break bit(s) from keycode */
+               }
+               else if((c = encode(pSB, pKB, c, Released, &SequencePtr)) >= 0)
+                       return(c);                      /* normal character: return it */
+       }
+       if(SequencePtr) /* a sequence of characters being output ? */
+       {
+               c = *SequencePtr++;     /* get next key of sequence     */
+               if(!*SequencePtr)       /* end of sequence ?            */
+                       SequencePtr = (unsigned char*)0;  /* terminate it */
+       }
+       return(c);
+}
+
+/*
+**************************************************************
+** See if a byte is available from the keyboard
+**************************************************************
+*/
+
+int kbd_tstc(void)
+{
+       struct state  *pSB = GetStateBlockAddr();
+    int c;
+
+       if(LookAheadValid)      /* do we have a byte in the lookahead buffer ? */
+       {       /* if cfb_console is in use, draw cursor while waiting for input */
+               return(1);
+       }
+       else if((c = nextchar(pSB)) >= 0)       /* get a byte from the keyboard */
+    {
+               LookAhead = c;
+               LookAheadValid = 1;
+               return(1);
+       }
+       else
+       {
+               return(0);
+       }
+}
+
+/*
+**************************************************************
+** Read a byte from the keyboard.
+**************************************************************
+*/
+
+int kbd_getc(void)
+{
+       struct state  *pSB = GetStateBlockAddr();
+       int c;
+
+       if(LookAheadValid)      /* do we have a byte in the lookahead buffer ? */
+       {
+               LookAheadValid = 0;
+               return(LookAhead);
+       }
+       else
+       {       /* wait until there is something available from the keyboard */
+               while((c = nextchar(pSB)) < 0)
+                       ;
+       }
+       return(c);
+}
+
+/*
+**************************************************************
+** Select keyboard mapping
+**************************************************************
+*/
+
+void kbd_mapping(const char *name)
+{
+       int i;
+       struct state  *pSB = GetStateBlockAddr();
+
+       /* scan mapping table for a matching name */
+       for(i = 0; kbd_mapping_table[i].name; i++)
+       {
+               if(!strcmp(name, kbd_mapping_table[i].name))
+               {       /* match found: select this mapping */
+                       KbMapping = kbd_mapping_table[i].map;
+                       return;
+               }
+       }
+       /* no match: use default mapping */
+       KbMapping = kbd_mapping_table[0].map;
+       return;
+}
+
+/*
+**************************************************************
+** Initialize keyboard encoder
+**************************************************************
+*/
+
+void kbd_init(bd_t *bd)
+{
+       char *mapping_name;
+       void (*Kbd_init)(void);
+       struct state  *pSB = GetStateBlockAddr();
+
+       /* Initialize status variables */
+       Status          = 0;
+       ComposeReceived = 0;
+       SequencePtr     = (unsigned char *)0;
+       Released                = 0;
+       LookAheadValid  = 0;
+       LookAhead               = 0;
+
+       /* get keyboard mapping table, use "us" by default */
+       if(!(mapping_name = getenv(bd, "keymap")))
+               mapping_name = "us";
+       kbd_mapping(mapping_name);
+
+       /* get hardware access functions */
+       Kbd_init        = KEYBOARD_DEV_INIT;
+       Kbd_getc                = KEYBOARD_DEV_GETC;
+       Kbd_tstc                = KEYBOARD_DEV_TSTC;
+       Set_leds                = KEYBOARD_DEV_SETLEDS;
+
+       /* initialize hardware */
+       Kbd_init();
+}
+
+#endif /* CONFIG_KEYBD */

diff --git a/include/armboot.h b/include/armboot.h
index 09b31e31f18de4f486fd84948c310a71e886f1d9..8cef359c3f5f3ced9853a08ce92fcfb55beb6e00 100644 (file)
--- a/include/armboot.h
+++ b/include/armboot.h
@@ -231,6 +231,27 @@ void       fputc(int file, const char c);
 int    ftstc(int file);
 int    fgetc(int file);
 
+#ifdef CONFIG_ANSI_CONSOLE
+/* drivers/ansi_console.c */
+void    ansi_console_init(void);
+void    ansi_console_putc(const char c);
+#endif
+
+#ifdef CONFIG_CFB_CONSOLE
+/* drivers/cfb_console.c */
+int     video_init(void);
+void    video_putc(const char c);
+#endif
+
+#ifdef CONFIG_KEYBOARD
+/* drivers/keyboard.c */
+void    kbd_init(bd_t *bd);
+int     kbd_getc(void);
+int     kbd_tstc(void);
+void    kbd_mapping(const char *name);
+#endif
+
+
 /* Byte swapping stuff */
 #define SWAP16(x)      ((((x) & 0xff) << 8) | ((x) >> 8))
 #define SWAP32(x)       ( \

diff --git a/include/configs/config_shannon.h b/include/configs/config_shannon.h
index 41a4c5778cc2ba5e396b3afa5d112274bff94725..06d4873f6a4d15c61f2d16f06379c9c90d2509ed 100644 (file)
--- a/include/configs/config_shannon.h
+++ b/include/configs/config_shannon.h
@@ -63,6 +63,35 @@
  */
 #define CONFIG_SERIAL3          1      /* we use SERIAL 3  */
 
+/*
+ * LCD screen
+ *
+ * There are two possible drivers for the shannon's LCD screen,
+ * select one of these:
+ */
+#define CONFIG_ANSI_CONSOLE     /* ansi terminal emulation */
+#undef  CONFIG_CFB_CONSOLE      /* framebuffer console with std input */
+
+#ifdef CONFIG_ANSI_CONSOLE
+/* this set of defines will enable the generic frame buffer driver */
+#define CONFIG_FRAMEBUFFER                     /* use framebuffer */
+#define CONFIG_FRAMEBUFFER_BPP 8       /* 8 bits per pixel */
+#define CONFIG_FRAMEBUFFER_CLUT                /* h/w has color lookup table */
+#endif
+
+#ifdef CONFIG_CFB_CONSOLE
+#define CONFIG_CONSOLE_CURSOR   /* display cursor */
+#define CONFIG_VIDEO_LOGO       /* display linux logo */
+#define CONFIG_VIDEO_SHANNON   /* enable Shannon video driver */
+#endif
+
+/*
+ * Keyboard device
+ */
+#define CONFIG_KEYBOARD                        /* enable generic keyboard driver */
+#define CONFIG_KEYBOARD_IRDA   /* use IrDA keyboard */
+
+
 /* allow to overwrite serial and ethaddr */
 #define CONFIG_ENV_OVERWRITE
 

diff --git a/include/keyboard.h b/include/keyboard.h
new file mode 100644 (file)
index 0000000..de2053e
--- /dev/null
+++ b/include/keyboard.h
@@ -0,0 +1,188 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+#ifndef _KEYBOARD_H_
+#define _KEYBOARD_H_ 1
+
+#include <armboot.h>
+
+/*
+** A sequence key is identified by it's bit #14 being set,
+** a modifier key is identified by it's bit #13 being set.
+** an autocompose key is identified by it's bit #12 being set.
+*/
+#define SEQUENCE_KEY 0x4000
+#define SKEY(x) (SEQUENCE_KEY|(x))
+
+#define MODIFIER_KEY   0x2000
+#define MKEY(x) (MODIFIER_KEY|(x))
+
+#define AUTOCOMPOSE_KEY 0x1000
+#define AKEY(x) (AUTOCOMPOSE_KEY|(x))
+
+/*
+** Status bits for modifier keys:
+**
+** The driver must keep track of each modifier key individually.
+** The status of the right and left ALT, CONTROL and SHIFT key pairs
+** (6 keys->64 possibilities) is translated via a status
+** translation table in the keyboard map to determine the
+** actual logical SHIFT, ALT and CONTROL state.
+** This means, that -for example- it is possible to give the
+** right ALT key the function of CTRL-ALT, e.g. for a german
+** DIN keyboard.
+*/
+
+#define S_LCTRL                0x001
+#define S_RCTRL                0x002
+
+#define S_LALT         0x004
+#define S_RALT         0x008
+
+#define S_LSHIFT       0x010
+#define S_RSHIFT       0x020
+
+#define S_NUMLOCK      0x080
+#define S_CAPSLOCK     0x100
+#define S_COMPOSE      0x200
+
+#define L_NONE         0x00
+#define L_CTRL      0x01
+#define L_ALT       0x02
+#define L_SHIFT     0x04
+
+/*
+** Number of logical modifier states:
+*/
+#define NUM_CONVTABLES ((L_CTRL|L_ALT|L_SHIFT) + 1)
+
+/*
+** Some ASCII codes
+*/
+#define ESC    0x1b
+#define SPC    ' '
+#define BSP    0x08
+#define DEL    0x7f
+#define TAB    0x09
+#define ENT    0x0d
+
+/*
+** If one of the following symbols appears in a conversion
+** table, the corresponding key becomes a modifier key.
+** These special function keys do not issue any codes
+** when being pressed, but are used to switch between key
+** assignments (i.e. different conversion tables). The
+** numlock and capslock functions are toggles, i.e. their
+** function is activated by pressing the corresponding key
+** once and is deactivated by pressing it once more.
+** The compose key switches the keyboard into compose mode
+** which will cause the next two keys to be combined via the
+** compose table. Compose mode is always reset after two keys
+** have been pressed.
+** All the other functions are active only while the corresponding
+** key is being held down.
+*/
+
+#define LCT MKEY(S_LCTRL)   /* left control key */
+#define RCT MKEY(S_RCTRL)   /* right   "     " */
+#define LAL MKEY(S_LALT)    /* left alt key */
+#define RAL MKEY(S_RALT)    /* right "   " */
+#define LSH MKEY(S_LSHIFT)  /* left shift key */
+#define RSH MKEY(S_RSHIFT)  /* right  "    " */
+#define NML MKEY(S_NUMLOCK) /* numlock key */
+#define CPL MKEY(S_CAPSLOCK)/* capslock key */
+#define CMP MKEY(S_COMPOSE) /* compose key */
+
+
+
+/*
+** Compose characters allow to enter some international
+** characters by "composing" two keys. To enter a composed
+** character, the user must enter the "compose key" followed
+** by the two characters to be composed. E.g. by entering
+** <Compose-Key>-A-", you get the german umlaut Ä.
+**
+** structure of one entry in the compose key table:
+*/
+struct compose_char
+{
+       unsigned char c[2];  /* characters to be composed  */
+       unsigned char subst; /* resulting compose key code */
+};
+
+/*
+** structure to describe a keyboard mapping
+**
+** Some keyboards issue two bytes for each keypress/keyrelease
+** event, where the first byte indicates wether the key has
+** been pressed/released and the second byte indicates the
+** individual key. In these cases, the driver must "consume"
+** the first byte (i.e. the make/break code), while passing the
+** the key code down to the encoder state machine.
+**
+** Some keyboards issue a single byte per keypress/keyrelease
+** event, where -typically- the high bit indicates wether the
+** key has been pressed/released and the lower bits indicate
+** the individual key. In these cases, the driver must strip
+** off the make/break bit(s) and pass the remaining key code
+** down to the encoder state machine.
+**
+** It is possible to control this behavior by specifying
+** three values in the keyboard map:
+**
+** if <byte> & mkbrkmask == makecode -> key has been pressed
+** if <byte> & mkbrkmask == breakcode -> key has been released
+** if mkbrkmask == 0xffffffff -> consume make/break code
+*/
+struct keyboardmap
+{
+       unsigned int                            convtabsize;    /* # of entries in each table */
+       unsigned int                            makecode;               /* make code */
+       unsigned int                            breakcode;              /* break code */
+       unsigned int                            mkbrkmask;              /* make/break code mask */
+       const unsigned char                     *statustable;   /* state translation table */
+       const unsigned short            *convtables[NUM_CONVTABLES];
+       const unsigned char                     * const * seqstring;
+       const struct compose_char       *composetable;
+};
+
+/*
+** entry in list of keyboard mappings
+*/
+struct maptable
+{
+       const char *name;
+       const struct keyboardmap *map;
+};
+
+
+/*
+** Function prototytes:
+*/
+extern void kbd_init(bd_t *bd);
+extern int  kbd_tstc(void);
+extern int  kbd_getc(void);
+extern void kbd_mapping(const char *name);
+
+#endif /* _KEYBOARD_H_ */

diff --git a/include/linux_logo.h b/include/linux_logo.h
new file mode 100644 (file)
index 0000000..1f10b54
--- /dev/null
+++ b/include/linux_logo.h
@@ -0,0 +1,1445 @@
+/* $Id: linux_logo.h,v 1.1 2002/09/27 16:26:05 robertkaiser Exp $
+ * include/linux/linux_logo.h: This is a linux logo
+ *                             to be displayed on boot.
+ *
+ * Copyright (C) 1996 Larry Ewing (lewing@isc.tamu.edu)
+ * Copyright (C) 1996,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ *
+ * You can put anything here, but:
+ * LINUX_LOGO_COLORS has to be less than 224
+ * image size has to be 80x80
+ * values have to start from 0x20
+ * (i.e. RGB(linux_logo_red[0],
+ *           linux_logo_green[0],
+ *           linux_logo_blue[0]) is color 0x20)
+ * BW image has to be 80x80 as well, with MS bit
+ * on the left
+ * Serial_console ascii image can be any size,
+ * but should contain %s to display the version
+ */
+
+#if LINUX_LOGO_COLORS == 214
+
+unsigned char linux_logo_red[] __initdata = {
+  0x02, 0x9E, 0xE9, 0xC4, 0x50, 0xC9, 0xC4, 0xE9,
+  0x65, 0xE3, 0xC2, 0x25, 0xA4, 0xEC, 0x90, 0xA6,
+  0xC4, 0x6A, 0xD1, 0xF3, 0x12, 0xED, 0xA0, 0xC2,
+  0xB8, 0xD5, 0xDB, 0xD2, 0x3E, 0x16, 0xEB, 0x54,
+  0xA9, 0xCD, 0xF5, 0x0A, 0xBA, 0xB3, 0xDC, 0x74,
+  0xCE, 0xF6, 0xD3, 0xC5, 0xEA, 0xB8, 0xED, 0x5E,
+  0xE5, 0x26, 0xF4, 0xA9, 0x82, 0x94, 0xE6, 0x38,
+  0xF2, 0x0F, 0x7F, 0x49, 0xE5, 0xF4, 0xD3, 0xC3,
+  0xC2, 0x1E, 0xD5, 0xC6, 0xA4, 0xFA, 0x0A, 0xBA,
+  0xD4, 0xEB, 0xEA, 0xEC, 0xA8, 0xBC, 0xB4, 0xDC,
+  0x84, 0xE4, 0xCE, 0xEC, 0x92, 0xCD, 0xDC, 0x8B,
+  0xCC, 0x1E, 0xF6, 0xB2, 0x60, 0x2A, 0x96, 0x52,
+  0x0F, 0xBD, 0xFA, 0xCC, 0xB8, 0x7A, 0x4C, 0xD2,
+  0x06, 0xEF, 0x44, 0x64, 0xF4, 0xBA, 0xCE, 0xE6,
+  0x8A, 0x6F, 0x3C, 0x70, 0x7C, 0x9C, 0xBA, 0xDF,
+  0x2C, 0x4D, 0x3B, 0xCA, 0xDE, 0xCE, 0xEE, 0x46,
+  0x6A, 0xAC, 0x96, 0xE5, 0x96, 0x7A, 0xBA, 0xB6,
+  0xE2, 0x7E, 0xAA, 0xC5, 0x96, 0x9E, 0xC2, 0xAA,
+  0xDA, 0x35, 0xB6, 0x82, 0x88, 0xBE, 0xC2, 0x9E,
+  0xB4, 0xD5, 0xDA, 0x9C, 0xA0, 0xD0, 0xA8, 0xC7,
+  0x72, 0xF2, 0xDB, 0x76, 0xDC, 0xBE, 0xAA, 0xF4,
+  0x87, 0x2F, 0x53, 0x8E, 0x36, 0xCE, 0xE6, 0xCA,
+  0xCB, 0xE4, 0xD6, 0xAA, 0x42, 0x5D, 0xB4, 0x59,
+  0x1C, 0xC8, 0x96, 0x6C, 0xDA, 0xCE, 0xE6, 0xCB,
+  0x96, 0x16, 0xFA, 0xBE, 0xAE, 0xFE, 0x6E, 0xD6,
+  0xCE, 0xB6, 0xE5, 0xED, 0xDB, 0xDC, 0xF4, 0x72,
+  0x1F, 0xAE, 0xE6, 0xC2, 0xCA, 0xC4
+};
+
+unsigned char linux_logo_green[] __initdata = {
+  0x02, 0x88, 0xC4, 0x85, 0x44, 0xA2, 0xA8, 0xE5,
+  0x65, 0xA6, 0xC2, 0x24, 0xA4, 0xB4, 0x62, 0x86,
+  0x94, 0x44, 0xD2, 0xB6, 0x12, 0xD4, 0x73, 0x96,
+  0x92, 0x95, 0xB2, 0xC2, 0x36, 0x0E, 0xBC, 0x54,
+  0x75, 0xA5, 0xF5, 0x0A, 0xB2, 0x83, 0xC2, 0x74,
+  0x9B, 0xBD, 0xA2, 0xCA, 0xDA, 0x8C, 0xCB, 0x42,
+  0xAC, 0x12, 0xDA, 0x7B, 0x54, 0x94, 0xD2, 0x24,
+  0xBE, 0x06, 0x65, 0x33, 0xBB, 0xBC, 0xAB, 0x8C,
+  0x92, 0x1E, 0x9B, 0xB6, 0x6E, 0xFB, 0x04, 0xA2,
+  0xC8, 0xBD, 0xAD, 0xEC, 0x92, 0xBC, 0x7B, 0x9D,
+  0x84, 0xC4, 0xC4, 0xB4, 0x6C, 0x93, 0xA3, 0x5E,
+  0x8D, 0x13, 0xD6, 0x82, 0x4C, 0x2A, 0x7A, 0x5A,
+  0x0D, 0x82, 0xBB, 0xCC, 0x8B, 0x6A, 0x3C, 0xBE,
+  0x06, 0xC4, 0x44, 0x45, 0xDB, 0x96, 0xB6, 0xDE,
+  0x8A, 0x4D, 0x3C, 0x5A, 0x7C, 0x9C, 0xAA, 0xCB,
+  0x1C, 0x4D, 0x2E, 0xB2, 0xBE, 0xAA, 0xDE, 0x3E,
+  0x6A, 0xAC, 0x82, 0xE5, 0x72, 0x62, 0x92, 0x9E,
+  0xCA, 0x4A, 0x8E, 0xBE, 0x86, 0x6B, 0xAA, 0x9A,
+  0xBE, 0x34, 0xAB, 0x76, 0x6E, 0x9A, 0x9E, 0x62,
+  0x76, 0xCE, 0xD3, 0x92, 0x7C, 0xB8, 0x7E, 0xC6,
+  0x5E, 0xE2, 0xC3, 0x54, 0xAA, 0x9E, 0x8A, 0xCA,
+  0x63, 0x2D, 0x3B, 0x8E, 0x1A, 0x9E, 0xC2, 0xA6,
+  0xCB, 0xDC, 0xD6, 0x8E, 0x26, 0x5C, 0xB4, 0x45,
+  0x1C, 0xB8, 0x6E, 0x4C, 0xBC, 0xAE, 0xD6, 0x92,
+  0x63, 0x16, 0xF6, 0x8C, 0x7A, 0xFE, 0x6E, 0xBA,
+  0xC6, 0x86, 0xAA, 0xAE, 0xDB, 0xA4, 0xD4, 0x56,
+  0x0E, 0x6E, 0xB6, 0xB2, 0xBE, 0xBE
+};
+
+unsigned char linux_logo_blue[] __initdata = {
+  0x04, 0x28, 0x10, 0x0B, 0x14, 0x14, 0x74, 0xC7,
+  0x64, 0x0E, 0xC3, 0x24, 0xA4, 0x0C, 0x10, 0x20,
+  0x0D, 0x04, 0xD1, 0x0D, 0x13, 0x22, 0x0A, 0x40,
+  0x14, 0x0C, 0x11, 0x94, 0x0C, 0x08, 0x0B, 0x56,
+  0x09, 0x47, 0xF4, 0x0B, 0x9C, 0x07, 0x54, 0x74,
+  0x0F, 0x0C, 0x0F, 0xC7, 0x6C, 0x14, 0x14, 0x11,
+  0x0B, 0x04, 0x12, 0x0C, 0x05, 0x94, 0x94, 0x0A,
+  0x34, 0x09, 0x14, 0x08, 0x2F, 0x15, 0x19, 0x11,
+  0x28, 0x0C, 0x0B, 0x94, 0x08, 0xFA, 0x08, 0x7C,
+  0xBC, 0x15, 0x0A, 0xEC, 0x64, 0xBB, 0x0A, 0x0C,
+  0x84, 0x2C, 0xA0, 0x15, 0x10, 0x0D, 0x0B, 0x0E,
+  0x0A, 0x07, 0x10, 0x3C, 0x24, 0x2C, 0x28, 0x5C,
+  0x0A, 0x0D, 0x0A, 0xC1, 0x22, 0x4C, 0x10, 0x94,
+  0x04, 0x0F, 0x45, 0x08, 0x31, 0x54, 0x3C, 0xBC,
+  0x8C, 0x09, 0x3C, 0x18, 0x7C, 0x9C, 0x7C, 0x91,
+  0x0C, 0x4D, 0x17, 0x74, 0x0C, 0x48, 0x9C, 0x3C,
+  0x6A, 0xAC, 0x5C, 0xE3, 0x29, 0x3C, 0x2C, 0x7C,
+  0x6C, 0x04, 0x14, 0xA9, 0x74, 0x07, 0x2C, 0x74,
+  0x4C, 0x34, 0x97, 0x5C, 0x38, 0x0C, 0x5C, 0x04,
+  0x0C, 0xBA, 0xBC, 0x78, 0x18, 0x88, 0x24, 0xC2,
+  0x3C, 0xB4, 0x87, 0x0C, 0x14, 0x4C, 0x3C, 0x10,
+  0x17, 0x2C, 0x0A, 0x8C, 0x04, 0x1C, 0x44, 0x2C,
+  0xCD, 0xD8, 0xD4, 0x34, 0x0C, 0x5B, 0xB4, 0x1E,
+  0x1D, 0xAC, 0x24, 0x18, 0x20, 0x5C, 0xB4, 0x1C,
+  0x09, 0x14, 0xFC, 0x0C, 0x10, 0xFC, 0x6C, 0x7C,
+  0xB4, 0x1C, 0x15, 0x17, 0xDB, 0x18, 0x21, 0x24,
+  0x04, 0x04, 0x44, 0x8C, 0x8C, 0xB7
+};
+
+unsigned char linux_logo[] __initdata = {
+  0xBF, 0x95, 0x90, 0xCB, 0x95, 0xA1, 0x2C, 0x2C,
+  0x95, 0x55, 0xCB, 0x90, 0xCB, 0x95, 0x2C, 0x95,
+  0xCB, 0x47, 0x94, 0x95, 0xA1, 0xD6, 0xD6, 0x2C,
+  0x90, 0x47, 0x70, 0x2C, 0x6D, 0x2A, 0x6D, 0xD6,
+  0xA1, 0x2C, 0x55, 0x95, 0x2C, 0x2C, 0x55, 0x55,
+  0x95, 0xA1, 0xA1, 0xA1, 0x6D, 0xBF, 0x2A, 0x2A,
+  0xBF, 0x83, 0xBF, 0x95, 0x90, 0xCB, 0x95, 0xA1,
+  0x2C, 0x2C, 0x95, 0x55, 0xCB, 0x90, 0xCB, 0x95,
+  0x2C, 0x95, 0xCB, 0x47, 0x94, 0x95, 0xA1, 0xD6,
+  0xD6, 0x2C, 0x90, 0x47, 0x70, 0x2C, 0x6D, 0x2A,
+  0x95, 0x47, 0x47, 0x90, 0x2C, 0x2C, 0x2C, 0x95,
+  0x55, 0x55, 0xCB, 0x90, 0xCB, 0x55, 0x55, 0xCB,
+  0x47, 0xE6, 0x70, 0x95, 0xD6, 0xD6, 0xA1, 0x2C,
+  0x55, 0x55, 0x95, 0xD6, 0x6D, 0xD6, 0xA1, 0x2C,
+  0x2C, 0x95, 0x55, 0x95, 0x95, 0x95, 0x2C, 0x2C,
+  0xA1, 0xA1, 0x2C, 0x2C, 0xA1, 0xD6, 0xD6, 0xD6,
+  0xD6, 0xD6, 0x95, 0x47, 0x47, 0x90, 0x2C, 0x2C,
+  0x2C, 0x95, 0x55, 0x55, 0xCB, 0x90, 0xCB, 0x55,
+  0x55, 0xCB, 0x47, 0xE6, 0x70, 0x95, 0xD6, 0xD6,
+  0xA1, 0x2C, 0x55, 0x55, 0x95, 0xD6, 0x6D, 0xD6,
+  0x90, 0x47, 0x47, 0x70, 0x2C, 0xA1, 0x2C, 0x95,
+  0x55, 0x55, 0x90, 0xCB, 0x55, 0x55, 0x55, 0x70,
+  0x94, 0x70, 0x95, 0xA1, 0xD6, 0xD6, 0xA1, 0x2C,
+  0x95, 0x95, 0x2C, 0xA1, 0xD6, 0xA1, 0x2C, 0x2C,
+  0x95, 0x55, 0xCB, 0x95, 0xD6, 0xA1, 0x2C, 0x95,
+  0xA1, 0xD6, 0xD6, 0xA1, 0xA1, 0xD6, 0xA1, 0xA1,
+  0xA1, 0x2C, 0x90, 0x47, 0x47, 0x70, 0x2C, 0xA1,
+  0x2C, 0x95, 0x55, 0x55, 0x90, 0xCB, 0x55, 0x55,
+  0x55, 0x70, 0x94, 0x70, 0x95, 0xA1, 0xD6, 0xD6,
+  0xA1, 0x2C, 0x95, 0x95, 0x2C, 0xD6, 0xD6, 0xA1,
+  0x94, 0xA0, 0x47, 0x55, 0x2C, 0xD6, 0xA1, 0x95,
+  0x55, 0x55, 0xCB, 0xCB, 0x55, 0x55, 0xCB, 0xCB,
+  0x55, 0x95, 0x2C, 0xA1, 0xD6, 0xD6, 0xA1, 0x2C,
+  0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x95,
+  0x55, 0x55, 0x2C, 0x3F, 0x80, 0x20, 0x88, 0x88,
+  0x88, 0x20, 0x88, 0xB1, 0x2C, 0xA1, 0x2C, 0x2C,
+  0x95, 0xCB, 0x94, 0xA0, 0x47, 0x55, 0x2C, 0xD6,
+  0xA1, 0x95, 0x55, 0x55, 0xCB, 0xCB, 0x55, 0x55,
+  0xCB, 0xCB, 0x55, 0x95, 0x2C, 0xA1, 0xD6, 0xD6,
+  0xA1, 0x2C, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x94, 0x94, 0x70, 0x2C, 0xA1, 0xD6, 0xA1, 0x2C,
+  0x55, 0x55, 0xCB, 0x55, 0x55, 0x55, 0x55, 0x55,
+  0x95, 0x2C, 0xD6, 0xD6, 0xD6, 0xA1, 0x2C, 0x95,
+  0x55, 0x55, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x2C, 0x94, 0x80, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x88, 0x92, 0xA1, 0x95,
+  0x55, 0x90, 0x94, 0x94, 0x70, 0x2C, 0xA1, 0xD6,
+  0xA1, 0x2C, 0x55, 0x55, 0xCB, 0x55, 0x55, 0x55,
+  0x55, 0x55, 0x95, 0x2C, 0xD6, 0xD6, 0xD6, 0xA1,
+  0x2C, 0x95, 0x55, 0x55, 0x55, 0x95, 0x95, 0x95,
+  0x70, 0x70, 0x55, 0x2C, 0xD6, 0xD6, 0xA1, 0x95,
+  0x55, 0x90, 0xCB, 0xCB, 0x55, 0x55, 0x2C, 0x2C,
+  0xA1, 0xD6, 0xA1, 0xA1, 0x2C, 0x2C, 0x95, 0x55,
+  0x55, 0x55, 0x95, 0x95, 0x2C, 0x95, 0x95, 0xD6,
+  0xB1, 0x88, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x80, 0x34, 0x88, 0x43, 0x47,
+  0x95, 0xCB, 0x70, 0x70, 0x55, 0x2C, 0xD6, 0xD6,
+  0xA1, 0x95, 0x55, 0x90, 0xCB, 0xCB, 0x55, 0x55,
+  0x2C, 0x2C, 0xA1, 0xD6, 0xA1, 0xA1, 0xA1, 0x2C,
+  0x55, 0x55, 0x55, 0x55, 0x2C, 0x95, 0x2C, 0x2C,
+  0x55, 0x55, 0x95, 0x2C, 0xA1, 0xA1, 0x2C, 0x55,
+  0x90, 0x70, 0x90, 0x55, 0x95, 0x95, 0xA1, 0xA1,
+  0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x95, 0x95, 0x95,
+  0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0xD5,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x88, 0x7D, 0x3F, 0xB1, 0x80, 0x20,
+  0x99, 0x2C, 0x55, 0x55, 0x95, 0x2C, 0xA1, 0xA1,
+  0x2C, 0x55, 0x90, 0x70, 0x90, 0x55, 0x95, 0x95,
+  0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x2C, 0x2C,
+  0x95, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x95, 0x90, 0x55, 0x2C, 0xA1, 0xA1, 0x95, 0xCB,
+  0x70, 0x94, 0x90, 0x55, 0x95, 0xA1, 0xA1, 0xA1,
+  0x2C, 0x2C, 0x2C, 0x2C, 0x95, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0xA1, 0x88,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0xB1, 0x47, 0xD5, 0x7D, 0x43,
+  0x20, 0x70, 0x95, 0x90, 0x55, 0x2C, 0xA1, 0xA1,
+  0x95, 0xCB, 0x70, 0x94, 0x90, 0x55, 0x95, 0xA1,
+  0xA1, 0xA1, 0x2C, 0x95, 0x2C, 0x2C, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x2C, 0x95, 0x95, 0x95, 0x95,
+  0x95, 0x90, 0x55, 0x2C, 0xD6, 0xD6, 0x2C, 0x90,
+  0x94, 0x70, 0x55, 0x95, 0x2C, 0xD6, 0xD6, 0xA1,
+  0x95, 0x95, 0x95, 0x2C, 0x2C, 0x95, 0x55, 0x55,
+  0xCB, 0xCB, 0xCB, 0x55, 0xCB, 0x55, 0x47, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x88, 0xB1, 0x3F, 0x92, 0x2B, 0x80,
+  0x20, 0x80, 0xD6, 0x70, 0x55, 0x2C, 0xD6, 0xD6,
+  0x2C, 0x90, 0x94, 0x70, 0x55, 0x95, 0x2C, 0xD6,
+  0xD6, 0xA1, 0x2C, 0x95, 0x95, 0x2C, 0x2C, 0x95,
+  0x95, 0x55, 0x90, 0xCB, 0xCB, 0xCB, 0xCB, 0x55,
+  0xD6, 0x55, 0x95, 0xA1, 0xD6, 0xA1, 0x55, 0x70,
+  0x94, 0x55, 0x95, 0xA1, 0xA1, 0xA1, 0xA1, 0x95,
+  0x55, 0x55, 0x55, 0x95, 0x55, 0x55, 0xCB, 0x90,
+  0x70, 0x90, 0xCB, 0x55, 0x55, 0xA1, 0xD8, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x88, 0xD8, 0xE1, 0x88, 0x20, 0x20,
+  0x88, 0x88, 0xE6, 0x55, 0x2C, 0xA1, 0xD6, 0xA1,
+  0x55, 0x70, 0x94, 0x55, 0x95, 0xA1, 0xA1, 0xA1,
+  0xA1, 0x95, 0x55, 0x55, 0x95, 0x95, 0x55, 0x55,
+  0x90, 0x90, 0x90, 0x90, 0xCB, 0x55, 0x55, 0x55,
+  0xD6, 0x2C, 0xA1, 0xD6, 0xD6, 0xA1, 0xCB, 0x70,
+  0x70, 0x95, 0x2C, 0xA1, 0xA1, 0x2C, 0x2C, 0x55,
+  0xCB, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+  0x55, 0x95, 0x2C, 0x95, 0x2C, 0xD6, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x80, 0xD6, 0xA1, 0xD6, 0xD6, 0xA1,
+  0xCB, 0x70, 0x70, 0x95, 0x2C, 0xA1, 0xA1, 0x2C,
+  0x2C, 0x55, 0xCB, 0xCB, 0x55, 0x55, 0x55, 0x55,
+  0x55, 0x55, 0x55, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0xD6, 0xA1, 0xA1, 0xA1, 0xA1, 0x55, 0x70, 0x94,
+  0xCB, 0x95, 0xA1, 0xA1, 0x2C, 0x95, 0xCB, 0x55,
+  0x90, 0xCB, 0x55, 0x55, 0x55, 0x55, 0x95, 0xA1,
+  0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0x95, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x88, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x88, 0x95, 0xA1, 0xA1, 0xA1, 0x55,
+  0x70, 0x94, 0xCB, 0x95, 0xA1, 0xA1, 0x2C, 0x95,
+  0xCB, 0xCB, 0x90, 0xCB, 0x55, 0x55, 0x55, 0x55,
+  0x95, 0x2C, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1,
+  0x2C, 0x2C, 0x2C, 0x95, 0x95, 0xCB, 0x70, 0x70,
+  0x95, 0x2C, 0x2C, 0x95, 0xCB, 0x70, 0x90, 0xCB,
+  0xCB, 0x55, 0x55, 0xCB, 0x55, 0x55, 0x2C, 0xD6,
+  0xD6, 0xD6, 0xD6, 0xA1, 0x2C, 0x70, 0x20, 0x20,
+  0x88, 0x43, 0xD8, 0x43, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x88, 0x88, 0x43, 0x2B, 0xD8, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x3F, 0x2C, 0x95, 0x95, 0xCB,
+  0x70, 0x70, 0x95, 0x2C, 0x2C, 0x95, 0xCB, 0x90,
+  0x90, 0xCB, 0x55, 0xCB, 0x55, 0xCB, 0x55, 0x95,
+  0x2C, 0xD6, 0xD6, 0xD6, 0xD6, 0xA1, 0x2C, 0x2C,
+  0xA1, 0x95, 0x95, 0x55, 0xCB, 0x70, 0x90, 0x55,
+  0x2C, 0x2C, 0x2C, 0x55, 0x70, 0x70, 0x55, 0x95,
+  0x95, 0xCB, 0x90, 0x90, 0x90, 0x95, 0x2C, 0xA1,
+  0xD6, 0xD6, 0x2C, 0x2C, 0x95, 0x70, 0x20, 0x20,
+  0x80, 0x2B, 0x34, 0x2B, 0x88, 0x20, 0x20, 0x20,
+  0x88, 0xB1, 0x28, 0x28, 0x2B, 0x7D, 0x80, 0x20,
+  0x20, 0x20, 0x20, 0x92, 0x95, 0x55, 0xCB, 0x70,
+  0x90, 0x55, 0x2C, 0x2C, 0x2C, 0x55, 0x70, 0x70,
+  0x55, 0x95, 0x55, 0x55, 0x90, 0x90, 0x90, 0x55,
+  0x2C, 0xA1, 0xD6, 0xA1, 0x2C, 0x2C, 0x95, 0x95,
+  0xA1, 0x95, 0x55, 0xCB, 0x90, 0x70, 0xCB, 0x95,
+  0xA1, 0x95, 0x95, 0xCB, 0x90, 0xCB, 0x95, 0x2C,
+  0x95, 0x70, 0x70, 0x90, 0x55, 0x2C, 0xA1, 0xA1,
+  0x2C, 0x2C, 0x55, 0xCB, 0x55, 0x90, 0x20, 0x34,
+  0x90, 0x6D, 0x70, 0xD8, 0x43, 0x20, 0x20, 0x88,
+  0x3F, 0x55, 0xA1, 0x2A, 0xD6, 0x7D, 0x43, 0x20,
+  0x20, 0x20, 0x88, 0x7D, 0x55, 0xCB, 0x90, 0x70,
+  0xCB, 0x95, 0xA1, 0x95, 0x95, 0xCB, 0x70, 0xCB,
+  0x95, 0xA1, 0x95, 0x70, 0x70, 0xCB, 0x55, 0x2C,
+  0xA1, 0xA1, 0xA1, 0x95, 0x55, 0x55, 0x55, 0x95,
+  0x2C, 0x55, 0x90, 0x70, 0x94, 0x90, 0x95, 0x2C,
+  0x2C, 0x95, 0xCB, 0x90, 0x55, 0x95, 0xA1, 0xA1,
+  0x95, 0x90, 0x90, 0x95, 0xA1, 0xD6, 0xD6, 0x6D,
+  0xA1, 0x95, 0x55, 0xCB, 0x55, 0xCB, 0x20, 0x99,
+  0xBF, 0xA3, 0xA3, 0x90, 0x20, 0x20, 0x20, 0x92,
+  0x83, 0x6B, 0x6B, 0x6B, 0xA3, 0x70, 0x88, 0x20,
+  0x20, 0x20, 0x20, 0x2B, 0x90, 0x70, 0x94, 0x90,
+  0x95, 0x2C, 0x2C, 0x95, 0xCB, 0x90, 0x55, 0x95,
+  0xA1, 0x2C, 0x55, 0x90, 0x90, 0x95, 0xA1, 0xD6,
+  0xD6, 0x6D, 0xA1, 0x95, 0x55, 0xCB, 0x55, 0x55,
+  0x2C, 0x55, 0x70, 0x70, 0x94, 0x90, 0x95, 0x2C,
+  0x2C, 0x55, 0xCB, 0xCB, 0x95, 0x2C, 0x2C, 0x2C,
+  0x55, 0x55, 0x95, 0xA1, 0x6D, 0xBF, 0x6D, 0xD6,
+  0x95, 0x55, 0x90, 0xCB, 0x55, 0x95, 0x88, 0x95,
+  0x2C, 0x3F, 0x6D, 0x6B, 0x34, 0x20, 0x20, 0x47,
+  0x65, 0xD6, 0xE1, 0x3F, 0x2A, 0x6B, 0x2B, 0x20,
+  0x20, 0x20, 0x20, 0x43, 0x70, 0x70, 0x94, 0x90,
+  0x95, 0x2C, 0x2C, 0x55, 0x55, 0x55, 0x95, 0x2C,
+  0xA1, 0x2C, 0x55, 0xCB, 0x95, 0xA1, 0x6D, 0xBF,
+  0x6D, 0xD6, 0x2C, 0x55, 0x90, 0xCB, 0x95, 0x95,
+  0x95, 0x55, 0x70, 0x94, 0x70, 0x55, 0x2C, 0xA1,
+  0x2C, 0x55, 0xCB, 0x55, 0x2C, 0x95, 0x2C, 0x95,
+  0x95, 0x95, 0xA1, 0x6D, 0xBF, 0x2A, 0xD6, 0x95,
+  0x70, 0x94, 0x94, 0x70, 0x55, 0x55, 0x20, 0xBF,
+  0xC9, 0xB1, 0x99, 0x42, 0xB1, 0x61, 0x7D, 0x94,
+  0x65, 0xB1, 0x88, 0x99, 0xD5, 0xE5, 0x7F, 0x20,
+  0x20, 0x20, 0x20, 0x43, 0x70, 0x94, 0x70, 0x55,
+  0x2C, 0xA1, 0x2C, 0x55, 0x90, 0x55, 0x2C, 0x95,
+  0x2C, 0x95, 0x95, 0x2C, 0xA1, 0x6D, 0xBF, 0xBF,
+  0xD6, 0x55, 0x70, 0x94, 0x94, 0x70, 0xCB, 0x55,
+  0x55, 0xCB, 0x70, 0x94, 0x70, 0x95, 0xA1, 0xA1,
+  0x95, 0x55, 0x55, 0x95, 0x2C, 0x95, 0x95, 0x95,
+  0x95, 0xA1, 0x6D, 0x2A, 0x2A, 0xD6, 0x55, 0x94,
+  0xE6, 0xE6, 0x47, 0x70, 0x55, 0x95, 0x20, 0x2A,
+  0xD8, 0x43, 0xC9, 0x83, 0x98, 0x79, 0x34, 0x9F,
+  0x6B, 0x43, 0x20, 0x88, 0x2B, 0x65, 0xA0, 0x20,
+  0x20, 0x20, 0x20, 0xE1, 0x70, 0x94, 0x70, 0x95,
+  0xA1, 0xA1, 0x95, 0x55, 0x55, 0x95, 0x2C, 0x95,
+  0x95, 0x95, 0x95, 0xA1, 0x6D, 0xBF, 0x2A, 0xD6,
+  0x55, 0x94, 0xE6, 0xE6, 0x47, 0x70, 0x55, 0x55,
+  0x94, 0x70, 0x94, 0x47, 0x70, 0x95, 0x2C, 0x2C,
+  0x95, 0xCB, 0x95, 0x2C, 0x2C, 0xA1, 0x2C, 0x2C,
+  0xA1, 0xD6, 0x6D, 0x6D, 0xA1, 0xCB, 0x47, 0x28,
+  0xE6, 0x47, 0x70, 0x55, 0x95, 0xA1, 0x20, 0x2C,
+  0x7F, 0x88, 0xF0, 0xC6, 0x25, 0x5E, 0xCF, 0x2F,
+  0xE7, 0x9A, 0x20, 0x88, 0x99, 0x65, 0x3F, 0x20,
+  0x20, 0x20, 0x20, 0x34, 0x94, 0x47, 0x70, 0x95,
+  0xA1, 0x2C, 0x55, 0xCB, 0x95, 0x2C, 0x2C, 0xA1,
+  0x2C, 0x2C, 0xA1, 0xD6, 0x6D, 0x6D, 0xA1, 0xCB,
+  0x94, 0x28, 0xA0, 0x47, 0x70, 0x55, 0x95, 0x95,
+  0x47, 0x70, 0x90, 0x94, 0x70, 0x95, 0xA1, 0x2C,
+  0x55, 0x55, 0x2C, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C,
+  0xA1, 0x6D, 0x2A, 0xD6, 0x55, 0x47, 0x28, 0x28,
+  0x47, 0x70, 0x55, 0x95, 0x2C, 0xA1, 0x20, 0x28,
+  0xEC, 0x86, 0xBE, 0x48, 0x3E, 0x3E, 0x3A, 0x25,
+  0x4E, 0xAE, 0x93, 0xD7, 0xEC, 0xD1, 0x34, 0x20,
+  0x20, 0x20, 0x20, 0x43, 0x55, 0x94, 0x70, 0x95,
+  0xA1, 0xA1, 0x55, 0xCB, 0x2C, 0xA1, 0xA1, 0xA1,
+  0xA1, 0x2C, 0xA1, 0x6D, 0x6D, 0xD6, 0x55, 0x47,
+  0x28, 0x28, 0x47, 0x70, 0x55, 0x95, 0x2C, 0x2C,
+  0x95, 0x95, 0x55, 0x90, 0xCB, 0x2C, 0xA1, 0xA1,
+  0x55, 0x55, 0x2C, 0xD6, 0xD6, 0xA1, 0xA1, 0x2C,
+  0xD6, 0x6D, 0x6D, 0xA1, 0x70, 0x28, 0xD5, 0xE6,
+  0x70, 0x55, 0x95, 0x2C, 0xA1, 0xD6, 0x20, 0xE1,
+  0x26, 0x84, 0x76, 0x73, 0x9C, 0x22, 0x4E, 0x35,
+  0x8C, 0x7A, 0x4E, 0xDC, 0x8E, 0x7E, 0x3D, 0x88,
+  0x20, 0x20, 0x20, 0x88, 0x2C, 0x90, 0x90, 0x95,
+  0xA1, 0x2C, 0x55, 0x55, 0x2C, 0xD6, 0xD6, 0xD6,
+  0x2C, 0x2C, 0xD6, 0x2A, 0x6D, 0x2C, 0x70, 0x28,
+  0xD5, 0xE6, 0x70, 0x55, 0x95, 0xA1, 0x2C, 0xA1,
+  0xBF, 0xA1, 0x95, 0xCB, 0xCB, 0x2C, 0xA1, 0xA1,
+  0x95, 0x95, 0xA1, 0xD6, 0xD6, 0xA1, 0x2C, 0x95,
+  0xD6, 0x6D, 0xD6, 0x95, 0x94, 0x28, 0xE6, 0x70,
+  0x55, 0x95, 0xA1, 0xA1, 0xA1, 0xD6, 0x20, 0x57,
+  0xE4, 0xDF, 0x50, 0x3E, 0x22, 0x4E, 0x35, 0x8C,
+  0x8C, 0x52, 0x52, 0x7A, 0x4E, 0x58, 0xD7, 0x20,
+  0x20, 0x20, 0x20, 0x88, 0x2C, 0xCB, 0x55, 0x2C,
+  0xA1, 0xA1, 0x95, 0x95, 0xA1, 0xD6, 0xD6, 0xA1,
+  0x2C, 0x95, 0xA1, 0x6D, 0x6D, 0x95, 0x47, 0xA0,
+  0xE6, 0x70, 0x55, 0x95, 0x2C, 0xA1, 0xA1, 0xA1,
+  0xD2, 0x95, 0x55, 0x90, 0x55, 0x2C, 0xD6, 0xA1,
+  0x95, 0x95, 0xA1, 0xD6, 0xD6, 0x2C, 0x95, 0x2C,
+  0xA1, 0x6D, 0xA1, 0x55, 0x94, 0x47, 0x94, 0xCB,
+  0x55, 0x95, 0x2C, 0xA1, 0xD6, 0xD6, 0x59, 0xC8,
+  0xE3, 0x76, 0x2D, 0x3E, 0x22, 0x4E, 0x8C, 0x35,
+  0x52, 0x52, 0xEE, 0x3A, 0x4D, 0xED, 0x24, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x28, 0xCB, 0x55, 0x2C,
+  0xD6, 0xA1, 0x95, 0x95, 0xA1, 0xD6, 0xA1, 0x2C,
+  0x95, 0x2C, 0xD6, 0x6D, 0xA1, 0x55, 0x94, 0xE6,
+  0x70, 0xCB, 0x55, 0x95, 0xA1, 0xD6, 0xD6, 0xA1,
+  0xD0, 0x94, 0x94, 0x90, 0x55, 0x2C, 0xA1, 0xA1,
+  0x55, 0x95, 0xA1, 0xA1, 0xA1, 0x2C, 0x95, 0x2C,
+  0xA1, 0xD6, 0x2C, 0x70, 0x94, 0x94, 0x94, 0x94,
+  0x70, 0x55, 0xA1, 0xD6, 0xA1, 0xD6, 0x88, 0x77,
+  0x38, 0xC4, 0x3E, 0x69, 0x4E, 0x35, 0x8C, 0xEE,
+  0x35, 0x89, 0x30, 0x30, 0x4A, 0x48, 0x3C, 0x20,
+  0x20, 0x88, 0x20, 0x20, 0xD8, 0x2C, 0x55, 0x2C,
+  0xD6, 0xA1, 0x95, 0x95, 0x2C, 0xD6, 0xA1, 0x2C,
+  0x95, 0x2C, 0xA1, 0xD6, 0x2C, 0x90, 0x94, 0x47,
+  0x94, 0x94, 0x70, 0x55, 0x2C, 0xD6, 0xA1, 0x95,
+  0x95, 0x28, 0x47, 0x90, 0x95, 0x2C, 0xA1, 0x2C,
+  0x95, 0x55, 0x95, 0xA1, 0xD6, 0xA1, 0x2C, 0x2C,
+  0xA1, 0xA1, 0x55, 0x70, 0x94, 0x47, 0x94, 0x94,
+  0x70, 0x2C, 0xD6, 0xD6, 0x2C, 0xA1, 0x43, 0x98,
+  0x54, 0x48, 0x3E, 0x22, 0x35, 0xEE, 0xEE, 0x9C,
+  0x4D, 0x45, 0x75, 0x4A, 0xDF, 0x7B, 0x3D, 0x20,
+  0xD8, 0x28, 0x2B, 0x88, 0x20, 0x95, 0x95, 0x2C,
+  0xA1, 0x2C, 0x55, 0x55, 0x2C, 0xA1, 0xD6, 0xA1,
+  0x2C, 0x95, 0xA1, 0x2C, 0x55, 0x70, 0x94, 0x94,
+  0x94, 0x94, 0x70, 0x95, 0xD6, 0xD6, 0x2C, 0x95,
+  0x70, 0x28, 0x47, 0x55, 0x95, 0x2C, 0x2C, 0x2C,
+  0x95, 0x95, 0x95, 0xA1, 0xA1, 0xA1, 0x95, 0x55,
+  0x95, 0x95, 0x55, 0x70, 0x70, 0x70, 0x94, 0x70,
+  0x55, 0xD6, 0x6D, 0xD6, 0x95, 0x2C, 0x20, 0x43,
+  0xBB, 0xC8, 0x36, 0x30, 0x30, 0x38, 0x45, 0x6E,
+  0xE3, 0x75, 0x78, 0x37, 0xBD, 0xD9, 0x3F, 0x20,
+  0x88, 0xD5, 0x70, 0xB1, 0x88, 0xA0, 0x95, 0x2C,
+  0x2C, 0xA1, 0x95, 0x55, 0x95, 0xA1, 0xA1, 0xA1,
+  0x2C, 0x55, 0x95, 0x2C, 0x55, 0x70, 0x70, 0x70,
+  0x94, 0x70, 0x55, 0xD6, 0x6D, 0x6D, 0x95, 0x55,
+  0x94, 0x47, 0x70, 0x95, 0x2C, 0x2C, 0x2C, 0xA1,
+  0x2C, 0x95, 0x2C, 0xA1, 0xD6, 0xA1, 0x2C, 0x55,
+  0x55, 0x95, 0x95, 0x55, 0x55, 0x55, 0x55, 0x95,
+  0xA1, 0x6D, 0x4B, 0xD6, 0x55, 0xD6, 0x20, 0xD8,
+  0xD6, 0x67, 0xDA, 0x4D, 0xED, 0x62, 0x78, 0x78,
+  0x23, 0x84, 0x67, 0xF5, 0x4B, 0xBF, 0x90, 0x88,
+  0x88, 0x2B, 0x47, 0x99, 0x20, 0x43, 0xD6, 0x2C,
+  0x2C, 0xA1, 0x2C, 0x95, 0x2C, 0xA1, 0xD6, 0xA1,
+  0x95, 0x95, 0x55, 0x95, 0x55, 0x55, 0x55, 0x55,
+  0x55, 0x95, 0xD6, 0x6D, 0xBF, 0xD6, 0x55, 0xCB,
+  0x55, 0x55, 0x55, 0x2C, 0x2C, 0x2C, 0x2C, 0xA1,
+  0x2C, 0x2C, 0x2C, 0xA1, 0xA1, 0x2C, 0x2C, 0x95,
+  0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0xA1,
+  0x6D, 0x2A, 0x2A, 0xA1, 0x55, 0x55, 0x20, 0xD8,
+  0x6D, 0xAB, 0x96, 0x7E, 0x64, 0x53, 0x36, 0x36,
+  0xC6, 0x63, 0x6D, 0xD0, 0x6B, 0xE5, 0xA3, 0x7D,
+  0x20, 0x88, 0x80, 0x88, 0x20, 0x20, 0xC9, 0xA1,
+  0x2C, 0xA1, 0xA1, 0x2C, 0x2C, 0xA1, 0xA1, 0xA1,
+  0x95, 0x95, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x2C, 0xA1, 0x6D, 0xBF, 0x6D, 0xA1, 0x55, 0x55,
+  0x95, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0xA1,
+  0xA1, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x95,
+  0x55, 0x55, 0x2C, 0x2C, 0xA1, 0xA1, 0xD6, 0xD6,
+  0x6D, 0x6D, 0xA1, 0x55, 0x2C, 0xD8, 0x20, 0xB1,
+  0xA3, 0x4B, 0x6D, 0xD9, 0xA7, 0x6C, 0xAF, 0xB2,
+  0x6D, 0x2A, 0x83, 0x42, 0xE5, 0xE5, 0x65, 0x2C,
+  0x20, 0x20, 0x88, 0x20, 0x20, 0x20, 0x88, 0x95,
+  0x2C, 0xA1, 0x2C, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x2C, 0x95, 0x55, 0x55, 0x2C, 0x2C, 0xA1, 0xA1,
+  0xD6, 0xD6, 0x6D, 0x6D, 0xA1, 0x55, 0xCB, 0x55,
+  0x95, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x95, 0x2C,
+  0x2C, 0x95, 0x95, 0x95, 0x95, 0x95, 0x2C, 0x95,
+  0x55, 0x95, 0x2C, 0x2C, 0xA1, 0xA1, 0xD6, 0xA1,
+  0xA1, 0x2C, 0x55, 0x55, 0x28, 0x88, 0x43, 0x2A,
+  0xE5, 0xA3, 0x6D, 0x6D, 0x6D, 0x6D, 0x6D, 0x6D,
+  0xBF, 0xA3, 0x42, 0xE5, 0xE5, 0xE5, 0xE5, 0x65,
+  0xB1, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0xD8,
+  0xD6, 0x2C, 0x2C, 0x95, 0x95, 0x95, 0x95, 0x2C,
+  0x95, 0x95, 0x55, 0x95, 0x2C, 0x2C, 0xA1, 0xA1,
+  0xA1, 0xA1, 0xA1, 0x2C, 0x95, 0x90, 0x90, 0x55,
+  0x90, 0xCB, 0x55, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x2C, 0x2C, 0x95, 0x55, 0x95, 0x95, 0x95, 0x55,
+  0x55, 0xCB, 0x55, 0x2C, 0x95, 0x95, 0x95, 0x95,
+  0x55, 0x90, 0x90, 0x90, 0xE1, 0x43, 0x28, 0xE5,
+  0xE5, 0x65, 0xD0, 0x6D, 0x6D, 0x6D, 0x2A, 0xD2,
+  0x42, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xD6, 0x20, 0x20, 0x20, 0x20, 0x20, 0x88, 0x88,
+  0xD5, 0x2C, 0x2C, 0x2C, 0x95, 0x55, 0x95, 0x95,
+  0x95, 0x55, 0x55, 0xCB, 0x55, 0x95, 0x2C, 0x95,
+  0x95, 0x95, 0x55, 0x90, 0x70, 0x70, 0x70, 0x90,
+  0x70, 0x70, 0xCB, 0x55, 0x55, 0x95, 0x95, 0x95,
+  0x2C, 0x95, 0x95, 0x55, 0x55, 0x55, 0x55, 0xCB,
+  0x70, 0x70, 0x70, 0xCB, 0x90, 0x90, 0x70, 0x94,
+  0x94, 0x94, 0x2C, 0x80, 0x20, 0xE1, 0xA3, 0xE5,
+  0xE5, 0xE5, 0x42, 0xEC, 0xD0, 0x83, 0xA3, 0x65,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0x65, 0x7D, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x88, 0x2C, 0x95, 0x95, 0x95, 0x55, 0x55, 0x55,
+  0x55, 0xCB, 0x70, 0x70, 0x90, 0x90, 0x90, 0x90,
+  0x70, 0x94, 0x94, 0x94, 0x70, 0x70, 0x70, 0x70,
+  0x70, 0x55, 0x55, 0x55, 0x95, 0x95, 0x95, 0x95,
+  0x2C, 0x2C, 0x95, 0x55, 0x55, 0x55, 0x55, 0x55,
+  0x90, 0x70, 0x90, 0x55, 0x55, 0xCB, 0x70, 0x94,
+  0x94, 0x95, 0xD8, 0x20, 0x88, 0x70, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0x65, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0x47, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0xE1, 0x6D, 0x2C, 0x95, 0x55, 0x55, 0x55,
+  0x55, 0x55, 0x90, 0x70, 0x70, 0x55, 0x55, 0xCB,
+  0x70, 0x94, 0x94, 0x94, 0x70, 0x90, 0x70, 0x94,
+  0x55, 0x2C, 0x2C, 0x2C, 0x95, 0x2C, 0x95, 0x95,
+  0x2C, 0x2C, 0x2C, 0x55, 0x55, 0x55, 0x55, 0x55,
+  0xCB, 0xCB, 0x95, 0x2C, 0x2C, 0x95, 0x55, 0x90,
+  0x55, 0x99, 0x20, 0x20, 0xE1, 0xA3, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xD6, 0x88, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x2B, 0x6D, 0x95, 0x95, 0x55, 0x55,
+  0x55, 0x55, 0xCB, 0x55, 0x95, 0x2C, 0x2C, 0x95,
+  0x55, 0x90, 0xCB, 0xCB, 0xCB, 0xCB, 0x90, 0x70,
+  0x2C, 0xD6, 0xD6, 0x2C, 0x2C, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x2C, 0x95, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x2C, 0xA1, 0x2C, 0x95, 0x55, 0x95,
+  0xE6, 0x88, 0x20, 0x20, 0x3F, 0xA3, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0x42, 0xA3, 0x88, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x88, 0x2B, 0xD6, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x2C, 0xA1, 0x2C, 0x95,
+  0x55, 0x55, 0x95, 0x95, 0x95, 0x55, 0x55, 0x55,
+  0xA1, 0xD6, 0xD6, 0xA1, 0x2C, 0x2C, 0x95, 0x2C,
+  0x2C, 0x2C, 0x95, 0x2C, 0x95, 0x95, 0x55, 0x95,
+  0x95, 0x2C, 0x2C, 0x2C, 0x95, 0xCB, 0xCB, 0x94,
+  0x20, 0x20, 0x20, 0x20, 0xE6, 0x83, 0x65, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x42, 0x6B, 0x6B, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x42, 0x6B, 0x6B, 0xA3, 0xD2,
+  0xD2, 0x6B, 0xC9, 0x20, 0x20, 0x88, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x88, 0x8A, 0xA1, 0x95, 0x95,
+  0x95, 0x55, 0x95, 0x2C, 0xA1, 0x2C, 0x95, 0xCB,
+  0xCB, 0x55, 0x95, 0x95, 0x95, 0x55, 0x55, 0x95,
+  0x6D, 0x6D, 0x6D, 0xD6, 0xA1, 0x2C, 0x2C, 0x95,
+  0x2C, 0x95, 0x2C, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x55, 0x70, 0x70, 0x2C, 0x80,
+  0x88, 0x20, 0x20, 0x80, 0x94, 0xD6, 0x32, 0x6B,
+  0xE5, 0xE5, 0xE5, 0x42, 0x6B, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xA3, 0xD2, 0xD0, 0xBF, 0x2A,
+  0x2A, 0xD0, 0x6D, 0x34, 0x20, 0xE1, 0x88, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x88, 0xA1, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x55, 0x70, 0x70,
+  0x70, 0x90, 0xCB, 0xCB, 0xCB, 0x95, 0x95, 0x2C,
+  0xD0, 0x6D, 0xD6, 0xD6, 0xA1, 0xA1, 0xA1, 0x2C,
+  0x2C, 0x2C, 0x2C, 0x95, 0x55, 0x55, 0x55, 0x95,
+  0x95, 0x2C, 0x95, 0x55, 0xCB, 0xCB, 0x95, 0x88,
+  0x20, 0x20, 0x88, 0xD8, 0x2C, 0xD1, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x65, 0x65, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x42, 0x6B, 0xEC,
+  0xBF, 0x2A, 0xEC, 0x95, 0x20, 0x34, 0x2B, 0xE1,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x99, 0x95, 0x55,
+  0x55, 0x55, 0x95, 0x95, 0x95, 0x55, 0xCB, 0xCB,
+  0x55, 0x55, 0xCB, 0xCB, 0xCB, 0x55, 0x95, 0x95,
+  0x32, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x2C,
+  0xA1, 0x95, 0x95, 0x95, 0x55, 0xCB, 0xCB, 0x55,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x55, 0x99, 0x20,
+  0xE1, 0xE1, 0x43, 0x47, 0x6B, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0x42, 0xEC, 0xBF, 0xA3, 0x8A, 0x20, 0x88, 0xD8,
+  0x2B, 0x20, 0x20, 0x20, 0x88, 0x88, 0x2C, 0xCB,
+  0xCB, 0x95, 0x95, 0x2C, 0x95, 0x95, 0x55, 0x95,
+  0x55, 0x55, 0x55, 0x55, 0x55, 0x95, 0x55, 0x95,
+  0x6D, 0x55, 0x55, 0x55, 0x95, 0x95, 0x2C, 0x95,
+  0x2C, 0x95, 0x95, 0x55, 0x55, 0x55, 0x55, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0xA1, 0x34, 0x20,
+  0xC9, 0x20, 0xE1, 0xA3, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xA3, 0x83, 0x6D, 0x20, 0x88, 0x88,
+  0x2B, 0x34, 0x20, 0x20, 0x20, 0x88, 0xD5, 0x55,
+  0x55, 0x55, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x55, 0x55, 0x95, 0x95,
+  0x2C, 0x55, 0xCB, 0x55, 0xCB, 0x55, 0x55, 0x95,
+  0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x2C, 0x95, 0x95, 0x55, 0x95, 0x2C, 0x20, 0xD8,
+  0xE1, 0x20, 0x70, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x65, 0xA3, 0x92, 0x43, 0x7D,
+  0xD8, 0xC9, 0x88, 0x20, 0x20, 0x20, 0x43, 0xD6,
+  0x2C, 0x2C, 0x95, 0x95, 0x95, 0x55, 0x95, 0x2C,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x2C, 0x95, 0x2C,
+  0xA1, 0x55, 0x55, 0x55, 0x55, 0x95, 0x95, 0x55,
+  0x55, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0xA1, 0x2C,
+  0xA1, 0x2C, 0x2C, 0x95, 0x2C, 0x99, 0x88, 0xB1,
+  0x20, 0xD8, 0x42, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xCB, 0x34, 0x8A,
+  0xC9, 0x34, 0x2B, 0x20, 0x20, 0x20, 0x20, 0x90,
+  0xA1, 0xA1, 0xA1, 0x2C, 0x2C, 0x95, 0x95, 0x2C,
+  0x2C, 0x95, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0xD6, 0x2C, 0x55, 0x55, 0x95, 0x2C, 0x2C, 0x2C,
+  0x55, 0xCB, 0x55, 0x2C, 0x2C, 0xA1, 0x2C, 0xA1,
+  0xA1, 0xA1, 0x2C, 0x2C, 0x6D, 0x43, 0xD8, 0x80,
+  0x88, 0xCB, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x32, 0x80, 0xE1,
+  0x80, 0x20, 0xB1, 0x20, 0x20, 0x20, 0x20, 0xC9,
+  0xD6, 0xA1, 0xA1, 0xA1, 0x2C, 0xA1, 0x2C, 0x2C,
+  0x2C, 0x55, 0x55, 0x55, 0x95, 0x95, 0x95, 0x55,
+  0xD6, 0x95, 0x95, 0x95, 0x2C, 0xA1, 0x2C, 0x2C,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x2C, 0x95, 0x2C,
+  0x2C, 0x2C, 0x2C, 0x95, 0xCB, 0x20, 0xC9, 0x20,
+  0xE1, 0xA3, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x42, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xD8, 0x20,
+  0x20, 0x20, 0x2B, 0x43, 0x20, 0x20, 0x20, 0x88,
+  0xD6, 0x2C, 0x2C, 0x2C, 0x95, 0x95, 0x95, 0x55,
+  0x95, 0x55, 0x55, 0xCB, 0x55, 0xCB, 0xCB, 0x55,
+  0x2C, 0x55, 0x55, 0x95, 0x2C, 0x2C, 0xA1, 0x95,
+  0x55, 0x95, 0x55, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x55, 0xCB, 0x70, 0xCB, 0xC9, 0x80, 0x2B, 0x20,
+  0xA0, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x42, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x92, 0x20,
+  0x20, 0x20, 0xE1, 0xD8, 0x20, 0x20, 0x20, 0x20,
+  0x95, 0x95, 0x55, 0xCB, 0x90, 0x90, 0x70, 0x90,
+  0x90, 0x90, 0xCB, 0xCB, 0xCB, 0xCB, 0x55, 0x95,
+  0x95, 0x55, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x95, 0x95, 0x55, 0x55, 0x55, 0x95, 0x95, 0x55,
+  0x90, 0x47, 0xA0, 0x55, 0x20, 0x2B, 0x43, 0x88,
+  0x6D, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x28, 0x20,
+  0x20, 0x20, 0xE1, 0xE1, 0x20, 0x20, 0x20, 0x20,
+  0x28, 0x55, 0x90, 0x47, 0xA0, 0x47, 0x94, 0x70,
+  0x55, 0x95, 0x95, 0x55, 0xCB, 0x55, 0x55, 0x2C,
+  0x2C, 0x2C, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x95, 0x2C, 0x95, 0x95, 0x95, 0x95, 0x95, 0x55,
+  0x94, 0xE6, 0x70, 0x2B, 0x88, 0x2B, 0x88, 0xE1,
+  0x65, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x47, 0x20,
+  0x20, 0x20, 0xE1, 0x34, 0x20, 0x20, 0x20, 0x20,
+  0xB1, 0x95, 0x94, 0xE6, 0xA0, 0x47, 0x70, 0x55,
+  0x2C, 0xA1, 0x2C, 0x55, 0x90, 0xCB, 0x2C, 0xD6,
+  0x6D, 0xA1, 0x2C, 0x95, 0x95, 0xA1, 0x2C, 0xA1,
+  0x2C, 0x2C, 0x95, 0x95, 0x95, 0x95, 0x95, 0x55,
+  0x70, 0xE6, 0x70, 0x20, 0x20, 0x7D, 0x20, 0x8A,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0xA3, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x94, 0x20,
+  0x20, 0x20, 0xD8, 0x88, 0x20, 0x20, 0x20, 0x20,
+  0xD8, 0x2C, 0x94, 0x47, 0x47, 0x90, 0x95, 0x95,
+  0xA1, 0x6D, 0xA1, 0x90, 0x94, 0x55, 0x2C, 0xD6,
+  0xD0, 0xA1, 0x95, 0x95, 0x2C, 0x2C, 0xA1, 0x2C,
+  0x95, 0x95, 0x55, 0x55, 0x55, 0x95, 0x2C, 0x2C,
+  0xCB, 0x95, 0xD8, 0x20, 0x20, 0xB1, 0x88, 0x28,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE2, 0xA3, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xCB, 0x20,
+  0x20, 0x20, 0x2B, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x88, 0xD6, 0x55, 0x47, 0x94, 0x55, 0x2C, 0xA1,
+  0xA1, 0xD6, 0x95, 0x94, 0x94, 0x55, 0xD6, 0x6D,
+  0xBF, 0x95, 0x90, 0xCB, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x55, 0x95, 0xCB, 0x90, 0x90, 0x95, 0x2C, 0x95,
+  0x90, 0x70, 0x20, 0x20, 0x34, 0x8A, 0x20, 0x94,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xCB, 0x20,
+  0x20, 0x88, 0x2B, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x88, 0xD6, 0xCB, 0x47, 0x94, 0x55, 0xA1, 0xD6,
+  0xD6, 0x2C, 0xCB, 0x47, 0x70, 0xA1, 0x6D, 0x2A,
+  0x95, 0x47, 0x47, 0x70, 0x95, 0xA1, 0x2C, 0x95,
+  0x55, 0x55, 0x90, 0x90, 0x55, 0x55, 0x55, 0x90,
+  0x47, 0xD5, 0x20, 0x20, 0x80, 0xD5, 0x43, 0xCB,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x42, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xCB, 0x20,
+  0x20, 0x80, 0x34, 0x20, 0x20, 0x20, 0x88, 0x20,
+  0x20, 0x2C, 0x47, 0xE6, 0x70, 0x2C, 0xD6, 0xD6,
+  0xA1, 0x2C, 0x55, 0xCB, 0x95, 0xA1, 0x6D, 0xD6,
+  0x90, 0x47, 0x47, 0x90, 0x2C, 0xA1, 0x2C, 0x95,
+  0x55, 0x55, 0x90, 0x90, 0x55, 0x55, 0x55, 0x70,
+  0x94, 0x8A, 0x20, 0x88, 0x88, 0xE1, 0xD8, 0x95,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE2, 0x42, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x47, 0x20,
+  0x43, 0x7D, 0x43, 0x80, 0x88, 0x20, 0x20, 0x20,
+  0x88, 0xCB, 0x94, 0x70, 0x55, 0xA1, 0xD6, 0xD6,
+  0xA1, 0x2C, 0x2C, 0x95, 0xA1, 0xA1, 0xD6, 0xA1,
+  0x94, 0xE6, 0x47, 0x55, 0x2C, 0xD6, 0xA1, 0x95,
+  0x55, 0x55, 0xCB, 0xCB, 0x55, 0x55, 0xCB, 0xCB,
+  0x55, 0xA0, 0x43, 0x86, 0x86, 0x43, 0xD8, 0xCB,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x3F, 0x80,
+  0xD8, 0x80, 0x88, 0x34, 0xD8, 0x2B, 0xD8, 0x20,
+  0x99, 0x90, 0x55, 0x95, 0x2C, 0xA1, 0xD6, 0xD6,
+  0xA1, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x94, 0x94, 0x70, 0x2C, 0xA1, 0xD6, 0xA1, 0x2C,
+  0x55, 0x55, 0xCB, 0x55, 0x55, 0x55, 0x55, 0x55,
+  0x95, 0x44, 0xBC, 0x3E, 0x5D, 0xD3, 0x79, 0x92,
+  0xA3, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0x42, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x65, 0x9A, 0x34,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x43, 0x99, 0xE1,
+  0x70, 0x55, 0x95, 0xA1, 0xD6, 0xD6, 0xD6, 0xA1,
+  0x2C, 0x95, 0x55, 0x55, 0x95, 0x95, 0x95, 0x95,
+  0x70, 0x70, 0x55, 0x2C, 0xD6, 0xD6, 0xA1, 0x95,
+  0x55, 0x90, 0xCB, 0xCB, 0x55, 0x55, 0x2C, 0x2C,
+  0x32, 0x9D, 0xEB, 0x5D, 0x69, 0x49, 0x84, 0xF0,
+  0xB1, 0xEC, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x42, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xC1, 0x4E, 0x21, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x34, 0xC9, 0xD8,
+  0xBB, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x2C,
+  0x95, 0x55, 0x55, 0x55, 0x95, 0x95, 0x2C, 0x2C,
+  0x55, 0xCB, 0x95, 0x2C, 0xA1, 0xA1, 0x2C, 0x55,
+  0x90, 0x70, 0x90, 0x55, 0x95, 0x95, 0x6D, 0xD0,
+  0xC2, 0x48, 0x6A, 0x49, 0x69, 0x82, 0x5D, 0x2F,
+  0x59, 0x7D, 0xBF, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xEA, 0xC7, 0x7E, 0x66,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x34, 0x43, 0x5A,
+  0x46, 0x27, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x95,
+  0x95, 0x55, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x95, 0x90, 0x55, 0x2C, 0xA1, 0xA1, 0x95, 0x55,
+  0x94, 0x94, 0x2C, 0x2A, 0x72, 0x3B, 0x56, 0xDD,
+  0xDF, 0x29, 0x5D, 0x49, 0x89, 0x5D, 0x3E, 0x69,
+  0x93, 0x66, 0x34, 0xA1, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x65, 0x42, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xEA, 0x3E, 0x5A, 0x66,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x5B, 0x73,
+  0x89, 0x4C, 0xBF, 0x2C, 0x95, 0x2C, 0x2C, 0x95,
+  0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
+  0x2C, 0x70, 0x55, 0x2C, 0xD6, 0xD6, 0x2C, 0xCB,
+  0x70, 0x55, 0xE7, 0x60, 0x4A, 0x48, 0xCD, 0x4A,
+  0x29, 0x73, 0x5D, 0x82, 0x49, 0x49, 0x49, 0x49,
+  0x3A, 0x57, 0x88, 0x88, 0x70, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0x42, 0x73, 0x50, 0xBE, 0x79,
+  0x20, 0x20, 0x20, 0x20, 0x66, 0xCC, 0x37, 0x9C,
+  0x3E, 0xCE, 0xBF, 0x95, 0x95, 0x95, 0x2C, 0x95,
+  0x95, 0x55, 0xCB, 0xCB, 0xCB, 0xCB, 0xCB, 0x55,
+  0xA1, 0x55, 0x95, 0xA1, 0xD6, 0xA1, 0x55, 0x94,
+  0x94, 0xE8, 0x60, 0xC4, 0x3E, 0x2D, 0x2D, 0x2D,
+  0x33, 0x5D, 0x82, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x89, 0xAA, 0x59, 0x20, 0x20, 0x28, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xEC, 0x4A, 0x2D, 0x50, 0x78, 0x2E,
+  0x57, 0x51, 0xF0, 0x57, 0x31, 0x4D, 0x50, 0x2D,
+  0x5D, 0xF2, 0xA1, 0x2C, 0x95, 0x95, 0x55, 0x55,
+  0x90, 0x90, 0x70, 0x90, 0xCB, 0x55, 0x55, 0x55,
+  0x6D, 0x2C, 0xA1, 0xD6, 0xD6, 0xA1, 0x55, 0x94,
+  0x70, 0xB9, 0x75, 0x50, 0x3E, 0x49, 0x49, 0x49,
+  0x5D, 0x82, 0x49, 0x49, 0x82, 0x49, 0x49, 0x49,
+  0x89, 0x69, 0x4F, 0x20, 0x20, 0x20, 0x8A, 0x42,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0x83, 0x4A, 0x3A, 0x50, 0x62, 0x23,
+  0x81, 0xB8, 0xB8, 0xE9, 0x5F, 0x29, 0x33, 0x5D,
+  0x5D, 0x73, 0xE8, 0xCB, 0x55, 0x55, 0x55, 0x55,
+  0x55, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0xD6, 0xA1, 0xA1, 0xA1, 0xA1, 0x55, 0x70, 0x70,
+  0xCB, 0x68, 0x75, 0x50, 0x82, 0x49, 0x49, 0x49,
+  0x5D, 0x49, 0x49, 0x5D, 0x49, 0x49, 0x5D, 0x82,
+  0x69, 0x5D, 0x25, 0xF0, 0x20, 0x20, 0x20, 0xE1,
+  0x2A, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0x4B, 0xF4, 0xDF, 0x50, 0x73, 0x76, 0x48,
+  0x75, 0xDF, 0x75, 0x62, 0xC4, 0x33, 0x82, 0x49,
+  0x5D, 0x5D, 0xA8, 0xF5, 0x55, 0x55, 0x55, 0x55,
+  0x2C, 0x2C, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1, 0xA1,
+  0x2C, 0x2C, 0x2C, 0x95, 0x95, 0xCB, 0x70, 0x70,
+  0x95, 0x83, 0x5F, 0xEA, 0x2D, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x5D, 0x49, 0x22, 0x5A, 0x79, 0x20, 0x20, 0x20,
+  0x80, 0xD2, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0x65, 0xD0, 0x63, 0x5F, 0x29, 0x2D, 0x2D, 0xEA,
+  0x29, 0x29, 0x76, 0x50, 0x2D, 0x82, 0x49, 0x49,
+  0x3E, 0x49, 0x5C, 0xB0, 0xBA, 0x95, 0x55, 0x55,
+  0x2C, 0xA1, 0xD6, 0xD6, 0xD6, 0xA1, 0x2C, 0x2C,
+  0xA1, 0x95, 0x95, 0x55, 0xCB, 0x70, 0x70, 0x55,
+  0x2C, 0x83, 0x60, 0x76, 0x5D, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x5D, 0x89, 0xDC, 0x8B, 0x20, 0x20, 0x20,
+  0x20, 0x95, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE2, 0x32, 0x85, 0xE3, 0x29, 0x2D, 0x33, 0x2D,
+  0x2D, 0x2D, 0x6A, 0x2D, 0x33, 0x5D, 0x49, 0x82,
+  0x49, 0x49, 0x82, 0x73, 0x5C, 0x9E, 0x2C, 0x55,
+  0x2C, 0xA1, 0xD6, 0xA1, 0x2C, 0x2C, 0x95, 0x95,
+  0x2C, 0x95, 0x55, 0xCB, 0x90, 0x90, 0xCB, 0x95,
+  0x2C, 0x6D, 0x41, 0x6F, 0x3E, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x82, 0x3E, 0x4E, 0x38, 0xCA, 0x20, 0x20,
+  0x20, 0x55, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0x65,
+  0x42, 0xA0, 0xD4, 0xE3, 0x29, 0x2D, 0x82, 0x5D,
+  0x5D, 0x82, 0x82, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x3E, 0x49, 0x49, 0x49, 0x5C, 0x56, 0xD6,
+  0xA1, 0xA1, 0xA1, 0x95, 0x55, 0x55, 0x55, 0x95,
+  0xA1, 0x55, 0x90, 0x70, 0x94, 0x70, 0x95, 0x2C,
+  0x2C, 0xD6, 0xDD, 0x6F, 0x33, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x5D, 0x5D, 0x82, 0x69, 0x22, 0x62, 0x80, 0x34,
+  0x94, 0x6B, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0x65, 0xE5, 0x65, 0x6B,
+  0xD5, 0x88, 0x5B, 0xE3, 0x29, 0x5D, 0x5D, 0x5D,
+  0x5D, 0x5D, 0x5D, 0x5D, 0x49, 0x49, 0x49, 0x82,
+  0x49, 0x49, 0x89, 0x49, 0x82, 0x49, 0x71, 0xBA,
+  0x6D, 0x6D, 0xA1, 0x95, 0x55, 0xCB, 0x55, 0x55,
+  0x2C, 0x55, 0x70, 0x70, 0x70, 0x90, 0x95, 0xA1,
+  0x2C, 0xA1, 0x41, 0x76, 0x5D, 0x5D, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x5D, 0x82, 0x5D, 0x89, 0x5E, 0x96, 0x65,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0xE5, 0xE5, 0xE5, 0xE5, 0x65, 0x65, 0xEC, 0xB1,
+  0x20, 0x20, 0xCA, 0x23, 0x29, 0x33, 0x49, 0x5D,
+  0x49, 0x82, 0x49, 0x49, 0x49, 0x49, 0x49, 0x82,
+  0x49, 0x82, 0x5D, 0x5D, 0x5D, 0x2D, 0x5C, 0x8F,
+  0x6D, 0xD6, 0x2C, 0x55, 0x90, 0xCB, 0x95, 0x95,
+  0x95, 0x55, 0x70, 0x94, 0x70, 0x55, 0x2C, 0xA1,
+  0x95, 0xE8, 0x5F, 0x76, 0x33, 0x5D, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x3E, 0x9C, 0x2F, 0x68,
+  0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5, 0xE5,
+  0x65, 0xE5, 0x65, 0xE5, 0x6B, 0x90, 0x80, 0x20,
+  0x20, 0x20, 0x4F, 0x81, 0x50, 0x3E, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x69, 0x69, 0x49, 0x5D, 0x2D, 0xC4, 0x46, 0xA3,
+  0xD6, 0x55, 0x70, 0x94, 0x94, 0x70, 0xCB, 0x55,
+  0x55, 0xCB, 0x70, 0x47, 0x70, 0x95, 0xA1, 0xA1,
+  0x95, 0xBD, 0x75, 0x2D, 0x33, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x5D, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x5D, 0x2D, 0xB5, 0xDB,
+  0xD6, 0x65, 0xE5, 0x65, 0xE5, 0xE5, 0x65, 0xE5,
+  0x65, 0x65, 0x6B, 0x95, 0x2B, 0x88, 0x20, 0x20,
+  0x20, 0x20, 0x8B, 0x81, 0x29, 0x33, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x3E, 0x3E, 0x5E, 0x41, 0x97, 0x27, 0xD6,
+  0x55, 0x94, 0xE6, 0xE6, 0x47, 0x70, 0x55, 0x55,
+  0x94, 0x70, 0x94, 0x94, 0x70, 0x55, 0xA1, 0x2C,
+  0x6D, 0xC5, 0x39, 0x6A, 0x5D, 0x5D, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x3E, 0xEA, 0x30, 0x77,
+  0xE1, 0xC9, 0x94, 0x2C, 0xD6, 0xD6, 0xA1, 0x55,
+  0x47, 0x9F, 0x43, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x80, 0x91, 0x81, 0x6A, 0x2D, 0x49, 0x49,
+  0x49, 0x5D, 0x5D, 0x49, 0x49, 0x5D, 0x5D, 0x82,
+  0xEB, 0x4A, 0x41, 0xC2, 0x8F, 0xF5, 0xA1, 0x55,
+  0x94, 0x28, 0xA0, 0x47, 0x70, 0x55, 0x95, 0x95,
+  0x47, 0x70, 0x70, 0x94, 0x90, 0x95, 0xA1, 0x2C,
+  0xE8, 0xA6, 0x39, 0x76, 0x50, 0x50, 0x2D, 0x2D,
+  0x3E, 0x3E, 0x5D, 0x3E, 0x5D, 0x5D, 0x49, 0x82,
+  0x49, 0x49, 0x49, 0x82, 0x82, 0x50, 0x75, 0xE0,
+  0x57, 0x20, 0x88, 0x88, 0x20, 0x20, 0x88, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x79, 0x91, 0x81, 0x76, 0x33, 0x49, 0x49,
+  0x5D, 0x82, 0x49, 0x49, 0x3E, 0x6A, 0xEA, 0x29,
+  0xDF, 0x97, 0xBF, 0x6D, 0x6D, 0xD6, 0x55, 0x47,
+  0x28, 0x28, 0x47, 0x70, 0x55, 0x95, 0x2C, 0x2C,
+  0x95, 0x95, 0x55, 0x90, 0x90, 0x95, 0xA1, 0xA1,
+  0xD6, 0x26, 0x45, 0x81, 0x5F, 0x30, 0x48, 0x6F,
+  0x6F, 0x29, 0x29, 0x6A, 0x2D, 0x2D, 0x5D, 0x49,
+  0x49, 0x49, 0x49, 0x49, 0x2D, 0x76, 0x6E, 0x77,
+  0x5B, 0x66, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x79, 0xA9, 0xB8, 0x39, 0x50, 0x5D, 0x5D,
+  0x5D, 0x5D, 0x3E, 0x2D, 0x29, 0x76, 0xCD, 0x37,
+  0xB9, 0xA1, 0xA1, 0x6D, 0x6D, 0x2C, 0x94, 0x28,
+  0xD5, 0xE6, 0x70, 0x55, 0x95, 0xA1, 0x2C, 0xA1,
+  0xBF, 0xA1, 0x95, 0xCB, 0x55, 0x95, 0xA1, 0x2C,
+  0x95, 0x83, 0xDE, 0x87, 0xB6, 0xBE, 0x40, 0x6E,
+  0x81, 0x81, 0x78, 0x78, 0x39, 0x6F, 0xEA, 0x2D,
+  0x2D, 0x33, 0x33, 0x33, 0x76, 0x30, 0x64, 0x54,
+  0x5B, 0x66, 0x20, 0x20, 0x66, 0x20, 0x88, 0x20,
+  0x20, 0x20, 0x88, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x88, 0x34, 0x8B, 0xF1, 0x23, 0x6F, 0x50, 0x2D,
+  0x2D, 0x6A, 0x29, 0x6F, 0x78, 0x84, 0x9B, 0xD2,
+  0x2C, 0x2C, 0xD6, 0x6D, 0x6D, 0x2C, 0x47, 0xA0,
+  0xE6, 0x70, 0x55, 0x95, 0x2C, 0xA1, 0xA1, 0xA1,
+  0xD2, 0x95, 0x55, 0xCB, 0x55, 0x2C, 0xD6, 0xA1,
+  0x95, 0x95, 0xA1, 0xD6, 0x6D, 0x6D, 0xBA, 0xF3,
+  0x8D, 0x36, 0x74, 0x36, 0xF1, 0xB8, 0x23, 0x78,
+  0x62, 0x4A, 0x29, 0x62, 0x23, 0xF1, 0x54, 0x31,
+  0x57, 0x2B, 0x90, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0x2C, 0x2C, 0xCB,
+  0xE6, 0x7D, 0xCA, 0xB7, 0xB8, 0x75, 0x6F, 0x6F,
+  0x76, 0x6F, 0x78, 0x81, 0x53, 0xBD, 0x6D, 0x2C,
+  0x95, 0x95, 0xA1, 0x6D, 0xA1, 0x55, 0x94, 0xE6,
+  0x70, 0xCB, 0x55, 0x95, 0xA1, 0xD6, 0xD6, 0xA1,
+  0xD0, 0x94, 0x94, 0x90, 0x95, 0x2C, 0xD6, 0xA1,
+  0x95, 0x55, 0x2C, 0xA1, 0xD6, 0xA1, 0x95, 0x2C,
+  0xD6, 0x68, 0xAB, 0x6C, 0xA4, 0x77, 0x77, 0xAD,
+  0x40, 0x53, 0x6E, 0x40, 0xB7, 0x54, 0x31, 0xD7,
+  0xAC, 0xD6, 0x55, 0x55, 0x95, 0x95, 0x95, 0x55,
+  0x95, 0x2C, 0x2C, 0xA1, 0x95, 0x95, 0x2C, 0xA1,
+  0x6D, 0xD2, 0x7C, 0x54, 0xAD, 0x40, 0x6E, 0x81,
+  0x81, 0x6E, 0x36, 0xDA, 0xE8, 0xD6, 0xD6, 0x2C,
+  0x2C, 0x2C, 0xA1, 0xD6, 0x95, 0x90, 0x94, 0x47,
+  0x94, 0x94, 0x70, 0x55, 0x2C, 0xD6, 0xA1, 0x95,
+  0x95, 0x28, 0x47, 0x90, 0x95, 0x2C, 0xA1, 0x2C,
+  0x55, 0x95, 0x2C, 0xA1, 0xA1, 0x2C, 0x2C, 0x2C,
+  0x2C, 0xA1, 0x55, 0x70, 0x95, 0x2C, 0xB2, 0xB4,
+  0xC3, 0xC3, 0x54, 0x54, 0xA9, 0x31, 0xCA, 0x2A,
+  0x95, 0x90, 0x55, 0x95, 0x2C, 0xA1, 0x2C, 0x95,
+  0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0xD6,
+  0x6D, 0x2A, 0xB2, 0x4F, 0x31, 0x2E, 0xE0, 0xAD,
+  0xB7, 0xC8, 0xB4, 0xF5, 0x2C, 0xA1, 0xA1, 0xA1,
+  0x95, 0x2C, 0xA1, 0x2C, 0x95, 0x70, 0x94, 0x94,
+  0x94, 0x94, 0x70, 0x95, 0xD6, 0xD6, 0x2C, 0x95,
+  0x94, 0x28, 0x47, 0xCB, 0x95, 0x2C, 0xA1, 0xA1,
+  0x95, 0x55, 0x2C, 0xA1, 0xD6, 0xA1, 0x95, 0x95,
+  0x95, 0x2C, 0x55, 0x70, 0x70, 0x70, 0x94, 0x2C,
+  0x63, 0xBB, 0xA5, 0xD7, 0xCA, 0xB3, 0x6D, 0x2C,
+  0x55, 0x55, 0x95, 0x2C, 0x2C, 0x2C, 0x95, 0x95,
+  0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0x2C, 0xA1,
+  0xD6, 0x2C, 0x70, 0x95, 0xAC, 0xC0, 0xDB, 0xEF,
+  0xEF, 0xA2, 0xE8, 0x95, 0x95, 0xA1, 0xD6, 0xA1,
+  0x95, 0x55, 0x2C, 0x95, 0x55, 0x70, 0x70, 0x70,
+  0x94, 0x70, 0x55, 0xD6, 0x6D, 0x6D, 0x95, 0x55,
+  0x70, 0x47, 0x70, 0x95, 0x2C, 0x2C, 0x2C, 0xA1,
+  0x2C, 0x95, 0x2C, 0xA1, 0xD6, 0xA1, 0x95, 0x55,
+  0x55, 0x95, 0x55, 0x55, 0x55, 0x55, 0x55, 0x95,
+  0xA1, 0xF5, 0xBF, 0xBF, 0xA1, 0x95, 0x95, 0x95,
+  0x95, 0x55, 0x2C, 0x2C, 0x95, 0x55, 0x55, 0x95,
+  0x95, 0x95, 0xA1, 0xA1, 0xA1, 0xA1, 0x2C, 0xA1,
+  0x2C, 0x55, 0x70, 0x94, 0x90, 0x2C, 0x6D, 0x6D,
+  0x6D, 0xA1, 0x2C, 0x95, 0x2C, 0xA1, 0xD6, 0xA1,
+  0x2C, 0x55, 0x55, 0x95, 0x55, 0x55, 0x55, 0x55,
+  0x55, 0x95, 0xD6, 0x6D, 0xBF, 0xD6, 0x55, 0xCB,
+  0x55, 0x55, 0x55, 0x2C, 0x2C, 0x2C, 0x2C, 0xA1,
+  0xA1, 0x95, 0x2C, 0xA1, 0xA1, 0xA1, 0x2C, 0x95,
+  0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C, 0xA1,
+  0x6D, 0xBF, 0x6D, 0x2C, 0x55, 0x55, 0x95, 0x95,
+  0xCB, 0xCB, 0x55, 0x55, 0xCB, 0x55, 0x55, 0x95,
+  0x95, 0x2C, 0x2C, 0xA1, 0xA1, 0xA1, 0x2C, 0x2C,
+  0xA1, 0x95, 0xCB, 0xCB, 0x95, 0x95, 0x2C, 0x2C,
+  0x2C, 0xA1, 0x2C, 0x2C, 0x2C, 0xA1, 0xA1, 0x2C,
+  0x2C, 0x95, 0x55, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x2C, 0xA1, 0x6D, 0xBF, 0x6D, 0xA1, 0x55, 0x55,
+  0x95, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x2C,
+  0x2C, 0x95, 0x95, 0x95, 0x2C, 0x2C, 0x2C, 0x95,
+  0x55, 0x95, 0x2C, 0x2C, 0xA1, 0xA1, 0xD6, 0xD6,
+  0x6D, 0x6D, 0xA1, 0x95, 0xCB, 0x55, 0x95, 0x55,
+  0x90, 0x70, 0xCB, 0xCB, 0x90, 0xCB, 0x95, 0x95,
+  0x2C, 0x2C, 0xA1, 0xD6, 0xA1, 0xA1, 0xA1, 0xA1,
+  0xA1, 0xA1, 0x2C, 0x95, 0x95, 0x2C, 0x2C, 0x2C,
+  0x2C, 0xA1, 0x2C, 0x95, 0x95, 0x95, 0x2C, 0x2C,
+  0x2C, 0x95, 0x55, 0x55, 0x2C, 0x2C, 0xA1, 0xA1,
+  0xD6, 0xD6, 0x6D, 0x6D, 0xA1, 0x55, 0xCB, 0x55
+};
+
+#endif
+
+#ifdef INCLUDE_LINUX_LOGOBW
+
+unsigned char linux_logo_bw[] __initdata = {
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x80, 0x00, 0x3F,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1F,
+  0xFE, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFE, 0x3F, 0xFF, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFE, 0x7F, 0xFF, 0xC7, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xC3,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF,
+  0xFB, 0xE3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFD, 0xFF, 0xFF, 0xE1, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xF9, 0xFF, 0xFF, 0xF1, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0xFF, 0xFF, 0xF1,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0xFF,
+  0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xF9, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xF9, 0xCF, 0xC3, 0xF8, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0x87, 0x81, 0xF9,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0xA7,
+  0x99, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xF9, 0xF3, 0xBC, 0xF9, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xF9, 0xE3, 0xBC, 0xF9, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0xB0, 0x3C, 0xF9,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0xB0,
+  0x19, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xF9, 0xC0, 0x03, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xF9, 0x80, 0x01, 0xF8, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0x80, 0x01, 0xF8,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF9, 0x80,
+  0x01, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xF9, 0xC0, 0x21, 0xD8, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xF9, 0xB1, 0x80, 0xEC, 0xC0, 0x1F,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xF1, 0x90, 0x00, 0xE4,
+  0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xF1, 0x8C,
+  0xC0, 0x7C, 0x04, 0x81, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xE3, 0x80, 0x00, 0x7C, 0x40, 0x11, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xE3, 0x80, 0x00, 0x7F, 0xD2, 0x29,
+  0xFF, 0xFF, 0xFF, 0xFF, 0x87, 0x00, 0x00, 0x3F,
+  0x80, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0x0E, 0x00,
+  0x00, 0x3F, 0x80, 0x19, 0xFF, 0xFF, 0xFF, 0xFF,
+  0x1E, 0x00, 0x00, 0x1F, 0x80, 0x19, 0xFF, 0xFF,
+  0xFF, 0xFE, 0x1C, 0x00, 0x00, 0x1E, 0x80, 0x19,
+  0xFF, 0xFF, 0xFF, 0xFE, 0x3C, 0x00, 0x00, 0x1E,
+  0x80, 0x11, 0xFF, 0xFF, 0xFF, 0xFC, 0x7C, 0x00,
+  0x00, 0x0F, 0x80, 0x11, 0xFF, 0xFF, 0xFF, 0xFC,
+  0xF8, 0x00, 0x00, 0x0E, 0x80, 0x11, 0xFF, 0xFF,
+  0xFF, 0xFC, 0xF8, 0x00, 0x00, 0x06, 0x00, 0x11,
+  0xFF, 0xFF, 0xFF, 0xF8, 0xF8, 0x00, 0x00, 0x06,
+  0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xF9, 0xF0, 0x00,
+  0x00, 0x02, 0x00, 0x09, 0xFF, 0xFF, 0xFF, 0xF1,
+  0xF0, 0x00, 0x00, 0x02, 0x80, 0x10, 0xFF, 0xFF,
+  0xFF, 0xF1, 0xE0, 0x00, 0x00, 0x00, 0x97, 0x10,
+  0xFF, 0xFF, 0xFF, 0xE3, 0xE0, 0x00, 0x00, 0x00,
+  0xDF, 0xF0, 0xFF, 0xFF, 0xFF, 0xE3, 0xC0, 0x00,
+  0x00, 0x00, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0xC7,
+  0xC0, 0x00, 0x00, 0x01, 0xFF, 0xF8, 0xFF, 0xFF,
+  0xFF, 0xC7, 0x80, 0x00, 0x00, 0x01, 0xFF, 0xF8,
+  0xFF, 0xFF, 0xFF, 0x8F, 0x80, 0x00, 0x00, 0x01,
+  0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0x8F, 0x80, 0x00,
+  0x00, 0x01, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF, 0x9F,
+  0x80, 0x00, 0x00, 0x01, 0xFF, 0xF8, 0xFF, 0xFF,
+  0xFF, 0x9F, 0x80, 0x00, 0x00, 0x01, 0x80, 0x18,
+  0xFF, 0xFF, 0xFF, 0x9E, 0x80, 0x00, 0x00, 0x03,
+  0xA8, 0x11, 0xFF, 0xFF, 0xFF, 0x9F, 0x80, 0x00,
+  0x00, 0x02, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0x99,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0x09, 0xFF, 0xFF,
+  0xFF, 0x00, 0x80, 0x00, 0x00, 0x01, 0xC0, 0x01,
+  0xFF, 0xFF, 0xFE, 0x20, 0x60, 0x00, 0x00, 0x00,
+  0xFF, 0xC3, 0xFF, 0xFF, 0xF8, 0x00, 0x30, 0x00,
+  0x00, 0x00, 0xFF, 0x0F, 0xFF, 0xFF, 0xC0, 0x40,
+  0x38, 0x00, 0x00, 0x00, 0xFE, 0x47, 0xFF, 0xFF,
+  0x81, 0x00, 0x1C, 0x00, 0x00, 0x00, 0xFC, 0x23,
+  0xFF, 0xFF, 0x90, 0x00, 0x1E, 0x00, 0x00, 0x00,
+  0x78, 0x11, 0xFF, 0xFF, 0x80, 0x00, 0x0F, 0x80,
+  0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0x80, 0x00,
+  0x07, 0xC0, 0x00, 0x00, 0x00, 0x08, 0xFF, 0xFF,
+  0xC0, 0x00, 0x07, 0xC0, 0x00, 0x00, 0x00, 0x04,
+  0x7F, 0xFF, 0x80, 0x00, 0x03, 0xC0, 0x00, 0x10,
+  0x00, 0x00, 0x1F, 0xFF, 0x80, 0x00, 0x01, 0x80,
+  0x00, 0x30, 0x00, 0x00, 0x0F, 0xFF, 0x80, 0x00,
+  0x00, 0x00, 0x00, 0x70, 0x00, 0x01, 0x4F, 0xFF,
+  0x80, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00,
+  0x0F, 0xFF, 0xC0, 0x00, 0x00, 0x80, 0x03, 0xF0,
+  0x00, 0x00, 0x8F, 0xFF, 0x80, 0x00, 0x00, 0x40,
+  0x0F, 0xF0, 0x00, 0x04, 0x1F, 0xFF, 0x80, 0x00,
+  0x00, 0x7F, 0xFF, 0xF0, 0x00, 0x10, 0x1F, 0xFF,
+  0xC0, 0x00, 0x00, 0x7F, 0xFF, 0xF0, 0x00, 0x40,
+  0xFF, 0xFF, 0x98, 0x00, 0x00, 0xFF, 0xFF, 0xF0,
+  0x00, 0x83, 0xFF, 0xFF, 0x81, 0xE0, 0x01, 0xFF,
+  0xFF, 0xF8, 0x02, 0x07, 0xFF, 0xFF, 0x80, 0x3F,
+  0x07, 0xE0, 0x00, 0x1C, 0x0C, 0x1F, 0xFF, 0xFF,
+  0xF8, 0x03, 0xFF, 0x80, 0x00, 0x1F, 0x78, 0x1F,
+  0xFF, 0xFF, 0xFF, 0x80, 0x7F, 0x00, 0x07, 0x0F,
+  0xF0, 0x7F, 0xFF, 0xFF, 0xFF, 0xFE, 0x0C, 0x07,
+  0xFF, 0x83, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0x00, 0x1F, 0xFF, 0xC0, 0x03, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x07, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+  0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+};
+
+#endif
+
+#ifdef INCLUDE_LINUX_LOGO16
+
+unsigned char linux_logo16_red[] __initdata = {
+    0x00, 0x90, 0xb0, 0x9c, 0xf7, 0x35, 0x83, 0xa5,
+    0x65, 0x8f, 0x98, 0xc9, 0xdb, 0xe1, 0xe7, 0xf8
+};
+
+unsigned char linux_logo16_green[] __initdata = {
+    0x00, 0x90, 0xb0, 0x9c, 0xf7, 0x2e, 0x83, 0xa5,
+    0x65, 0x6e, 0x98, 0x89, 0xbf, 0xac, 0xda, 0xf8
+};
+
+unsigned char linux_logo16_blue[] __initdata = {
+    0x00, 0x90, 0xaf, 0x9c, 0xf7, 0x2b, 0x82, 0xa5,
+    0x65, 0x41, 0x97, 0x1e, 0x60, 0x29, 0xa5, 0xf8
+};
+
+unsigned char linux_logo16[] __initdata = {
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa1, 0x11, 0x11,
+    0x61, 0x16, 0x66, 0x66, 0x11, 0x11, 0x11, 0x11,
+    0x11, 0x11, 0x1a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0xa8, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x87, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x77, 0x73, 0x33, 0x33, 0x3a, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xa3, 0x33, 0x33, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x77, 0x77, 0x77, 0x77,
+    0x77, 0x27, 0x77, 0x77, 0x77, 0x33, 0x3a, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xa3, 0x33, 0x33, 0x30, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x55, 0x50, 0x08, 0x33, 0x77, 0x77,
+    0x77, 0x72, 0x72, 0x27, 0x77, 0x77, 0x33, 0x33,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xa3, 0x33, 0x33, 0x77, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x58, 0x85, 0x00, 0x11, 0x11, 0xaa,
+    0xa3, 0x37, 0x77, 0x72, 0x22, 0x22, 0x77, 0x73,
+    0x33, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa3,
+    0x33, 0x37, 0x77, 0x33, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x56, 0x85, 0x00, 0x06, 0x66, 0x11,
+    0x11, 0x1a, 0xa3, 0x37, 0x77, 0x72, 0x22, 0x77,
+    0x73, 0x33, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x33,
+    0x33, 0x33, 0x33, 0x30, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x55, 0x00, 0x00, 0x06, 0x66, 0x66,
+    0x66, 0x66, 0x11, 0x1a, 0xa3, 0x77, 0x72, 0x22,
+    0x77, 0x73, 0x3a, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0x33,
+    0x33, 0x33, 0x33, 0xa0, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11,
+    0x66, 0x66, 0x66, 0x66, 0x11, 0xa3, 0x77, 0x22,
+    0x22, 0x77, 0x33, 0x33, 0xaa, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0x33, 0x33,
+    0x33, 0x3a, 0xa1, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0x33,
+    0xaa, 0x11, 0x16, 0x66, 0x66, 0x61, 0x1a, 0x37,
+    0x22, 0x22, 0x77, 0x33, 0x3a, 0xaa, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xa3, 0x33, 0x33, 0x33,
+    0x3a, 0xa1, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x02, 0x22,
+    0x22, 0x77, 0x3a, 0x11, 0x66, 0x66, 0x66, 0x1a,
+    0x37, 0x22, 0x22, 0x77, 0x33, 0x3a, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0x33, 0x33, 0x3a,
+    0xa1, 0x11, 0x11, 0x10, 0x00, 0x00, 0x50, 0x00,
+    0x00, 0x05, 0x80, 0x50, 0x00, 0x00, 0x07, 0x72,
+    0x22, 0x22, 0x22, 0x73, 0xa1, 0x66, 0x66, 0x61,
+    0x1a, 0x77, 0x22, 0x27, 0x73, 0x33, 0xaa, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0x33, 0x3a, 0xaa,
+    0x11, 0x11, 0x1a, 0xa0, 0x08, 0x71, 0x05, 0x00,
+    0x00, 0x12, 0x22, 0x50, 0x00, 0x00, 0x07, 0x77,
+    0x77, 0x72, 0x22, 0x22, 0x27, 0x31, 0x16, 0x66,
+    0x61, 0x13, 0x77, 0x22, 0x77, 0x33, 0x3a, 0xaa,
+    0xaa, 0xaa, 0xaa, 0xa3, 0x33, 0x33, 0xaa, 0xa1,
+    0x11, 0x1a, 0x33, 0x70, 0x07, 0x2e, 0x70, 0x00,
+    0x01, 0x44, 0x42, 0x60, 0x00, 0x00, 0x02, 0x22,
+    0x22, 0x22, 0x22, 0x22, 0x22, 0x27, 0x31, 0x66,
+    0x66, 0x61, 0xa3, 0x72, 0x22, 0x77, 0x33, 0xaa,
+    0xaa, 0xaa, 0xa3, 0x33, 0x33, 0xaa, 0xaa, 0x11,
+    0x1a, 0x33, 0x77, 0x30, 0x04, 0x82, 0x40, 0x00,
+    0x54, 0x48, 0x54, 0x40, 0x00, 0x00, 0x01, 0xaa,
+    0x32, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x31,
+    0x66, 0x66, 0x11, 0x37, 0x22, 0x27, 0x73, 0x3a,
+    0xaa, 0xaa, 0xa3, 0x33, 0x3a, 0xaa, 0xaa, 0xaa,
+    0xa3, 0x77, 0xaa, 0x10, 0x50, 0x08, 0x46, 0x05,
+    0x54, 0x80, 0x50, 0x42, 0x00, 0x00, 0x08, 0x66,
+    0x66, 0x1a, 0x32, 0x22, 0x22, 0x22, 0x22, 0x27,
+    0x31, 0x66, 0x66, 0x13, 0x72, 0x22, 0x77, 0x33,
+    0xaa, 0xaa, 0xaa, 0x33, 0xaa, 0xa1, 0xaa, 0xa3,
+    0x37, 0xa1, 0x1a, 0x30, 0x50, 0x06, 0x26, 0x00,
+    0x54, 0x00, 0x00, 0x44, 0x00, 0x00, 0x08, 0xe2,
+    0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0x22, 0x22,
+    0x27, 0xa6, 0x66, 0x61, 0xa7, 0x72, 0x27, 0x73,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x33,
+    0x31, 0x11, 0x37, 0x70, 0x02, 0x00, 0xab, 0xbb,
+    0xb6, 0x00, 0x00, 0xf4, 0x00, 0x00, 0xee, 0xee,
+    0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0x22,
+    0x22, 0x23, 0x16, 0x66, 0x1a, 0x37, 0x22, 0x77,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa3, 0x3a,
+    0x11, 0xa7, 0x33, 0x10, 0x04, 0x09, 0xbd, 0xdd,
+    0xbd, 0xd0, 0x04, 0x45, 0x00, 0x0e, 0xee, 0xee,
+    0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0x22,
+    0x22, 0x22, 0x71, 0x66, 0x66, 0x13, 0x72, 0x27,
+    0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x33, 0x11,
+    0xa3, 0x73, 0xa1, 0x60, 0x08, 0xbd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdb, 0x90, 0x00, 0x02, 0xec, 0xee,
+    0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xce, 0x22,
+    0x22, 0x22, 0x27, 0xa6, 0x66, 0x61, 0x37, 0x27,
+    0x1a, 0xaa, 0xaa, 0xaa, 0xaa, 0xa3, 0xa1, 0x1a,
+    0x33, 0xa1, 0x16, 0x60, 0x0b, 0xbd, 0xdd, 0xdd,
+    0xcd, 0xdd, 0xdd, 0xd9, 0x00, 0x00, 0xec, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0xa2,
+    0x22, 0x22, 0x22, 0x7a, 0x66, 0x66, 0x13, 0x77,
+    0x1a, 0xaa, 0xaa, 0xaa, 0xaa, 0x3a, 0x11, 0x33,
+    0xaa, 0x11, 0x66, 0x60, 0x9b, 0xdd, 0xdd, 0xdd,
+    0xcd, 0xdd, 0xdb, 0xb9, 0x00, 0x00, 0xec, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xee, 0x61,
+    0x72, 0x22, 0x22, 0x22, 0xa1, 0x66, 0x61, 0x37,
+    0x1a, 0xaa, 0xaa, 0xaa, 0xa3, 0xa1, 0x13, 0x3a,
+    0x11, 0x11, 0x11, 0x10, 0x5b, 0xdd, 0xdd, 0xdc,
+    0xdd, 0xdd, 0xbd, 0xd9, 0x00, 0x00, 0xec, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xee, 0x86,
+    0x17, 0x22, 0x22, 0x22, 0x23, 0x16, 0x66, 0xaa,
+    0xaa, 0xa3, 0x3a, 0xaa, 0xaa, 0x1a, 0x3a, 0xa1,
+    0x11, 0x11, 0x1a, 0x70, 0x05, 0xbd, 0xdd, 0xdd,
+    0xdb, 0x5b, 0xdd, 0xb0, 0x00, 0x60, 0x2e, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xe6, 0x88,
+    0x66, 0x32, 0x22, 0x22, 0x22, 0x36, 0x66, 0x11,
+    0x33, 0x33, 0x3a, 0xaa, 0x11, 0xaa, 0xaa, 0xa1,
+    0x11, 0x1a, 0x3a, 0x60, 0x02, 0x99, 0xbb, 0xb9,
+    0x9b, 0xbb, 0xbc, 0x22, 0x00, 0x86, 0x5e, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xe1, 0x68,
+    0x86, 0x63, 0x22, 0x22, 0x22, 0x2a, 0x66, 0x66,
+    0x33, 0x33, 0xaa, 0xaa, 0x1a, 0xaa, 0xaa, 0x11,
+    0x1a, 0xa7, 0x68, 0x80, 0x02, 0x2b, 0xbd, 0xbb,
+    0xbb, 0xb9, 0x22, 0x22, 0x00, 0x06, 0x6e, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc7, 0xa6,
+    0x88, 0x86, 0x32, 0x22, 0x22, 0x27, 0xa6, 0x66,
+    0x33, 0x3a, 0xaa, 0xa1, 0xaa, 0xaa, 0xa1, 0x11,
+    0xa3, 0xa6, 0x88, 0x80, 0x02, 0x22, 0x9b, 0xbb,
+    0xbb, 0x22, 0x24, 0xf4, 0x60, 0x00, 0x0c, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xc2, 0x21,
+    0x68, 0x88, 0x63, 0x22, 0x22, 0x22, 0x71, 0x66,
+    0x33, 0x3a, 0x11, 0x11, 0xaa, 0xaa, 0x11, 0xaa,
+    0x71, 0x88, 0x88, 0x00, 0x02, 0xe2, 0x26, 0x99,
+    0x22, 0x22, 0x4f, 0xf4, 0x40, 0x00, 0x0c, 0xcc,
+    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x22, 0x22,
+    0x16, 0x88, 0x86, 0xa2, 0x22, 0x22, 0x27, 0x11,
+    0x33, 0xa1, 0x11, 0x11, 0xaa, 0x31, 0x1a, 0xa3,
+    0x68, 0x88, 0x81, 0x00, 0x54, 0x42, 0x22, 0x22,
+    0x22, 0x44, 0xff, 0xff, 0x48, 0x00, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x22, 0x22,
+    0x21, 0x88, 0x88, 0x6a, 0x22, 0x22, 0x22, 0x31,
+    0x3a, 0xa1, 0x11, 0x1a, 0xa3, 0x11, 0x33, 0x36,
+    0x88, 0x86, 0x30, 0x00, 0x4f, 0x44, 0x22, 0x22,
+    0x24, 0xff, 0xff, 0xff, 0x44, 0x00, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x95, 0x22, 0x72,
+    0x22, 0x18, 0x88, 0x86, 0x32, 0x22, 0x22, 0x27,
+    0xaa, 0x11, 0x11, 0x1a, 0x31, 0x13, 0x33, 0x68,
+    0x88, 0x6a, 0x00, 0x02, 0x4f, 0x4f, 0x42, 0x24,
+    0x4f, 0xff, 0xff, 0xff, 0xf4, 0x50, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x22, 0x73,
+    0x72, 0x26, 0x88, 0x88, 0x63, 0x22, 0x22, 0x22,
+    0x11, 0x11, 0x11, 0xa3, 0xa1, 0x73, 0xa6, 0x88,
+    0x81, 0xa5, 0x00, 0x04, 0x4f, 0x4f, 0x44, 0x4f,
+    0xff, 0xff, 0xff, 0xff, 0xf4, 0x40, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x12, 0x27,
+    0xaa, 0x22, 0x68, 0x55, 0x86, 0x72, 0x22, 0x22,
+    0x11, 0x11, 0x1a, 0x33, 0x13, 0x3a, 0x18, 0x88,
+    0x1a, 0x10, 0x00, 0x44, 0x4f, 0x4f, 0xff, 0x4f,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x61, 0x22,
+    0x3a, 0xa2, 0x26, 0x85, 0x58, 0x67, 0x22, 0x22,
+    0x61, 0x61, 0x1a, 0x7a, 0x37, 0x31, 0x88, 0x81,
+    0x11, 0x00, 0x05, 0xe4, 0x44, 0xff, 0xff, 0xff,
+    0x4f, 0xf4, 0x44, 0xff, 0xff, 0xf5, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x88, 0x12,
+    0x2a, 0xaa, 0x72, 0x68, 0x55, 0x81, 0x22, 0x22,
+    0x66, 0x61, 0xa3, 0x33, 0x73, 0x16, 0x88, 0x11,
+    0x10, 0x00, 0x08, 0x74, 0x44, 0x4f, 0x44, 0x44,
+    0xf4, 0xf4, 0x44, 0x44, 0xe2, 0x44, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x88, 0x81,
+    0x22, 0xaa, 0xa7, 0x26, 0x85, 0x88, 0x12, 0x22,
+    0x66, 0x61, 0x37, 0xa7, 0x3a, 0x66, 0x66, 0x11,
+    0x80, 0x00, 0x0a, 0x72, 0x44, 0x4f, 0x44, 0x4f,
+    0xff, 0x44, 0x44, 0x22, 0x22, 0x24, 0x00, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0x85, 0x88,
+    0x12, 0x2a, 0xaa, 0x22, 0x68, 0x58, 0x63, 0x22,
+    0x66, 0x1a, 0x73, 0x77, 0x31, 0x66, 0x61, 0x11,
+    0x00, 0x00, 0x07, 0x44, 0xff, 0x4f, 0xf4, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0x42, 0x22, 0x40, 0x9b,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xb9, 0x85, 0x55,
+    0x81, 0x27, 0xaa, 0xa2, 0x78, 0x88, 0x86, 0x72,
+    0x66, 0x13, 0x77, 0x73, 0x11, 0x66, 0x61, 0x76,
+    0x00, 0x50, 0x84, 0xf4, 0xff, 0x4f, 0xf4, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x42, 0x40, 0x9b,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xb9, 0x68, 0x55,
+    0x58, 0x12, 0x3a, 0xaa, 0x23, 0x88, 0x88, 0xa7,
+    0x66, 0xa7, 0x77, 0x7a, 0x16, 0x66, 0x1a, 0x15,
+    0x05, 0x00, 0x4f, 0xf4, 0xff, 0x4f, 0xf4, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x44, 0x24, 0x9b,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xb9, 0x26, 0x55,
+    0x55, 0x81, 0x23, 0xaa, 0x32, 0x18, 0x88, 0x6a,
+    0x61, 0x37, 0x77, 0x31, 0x66, 0x66, 0x17, 0x60,
+    0x05, 0x08, 0x4f, 0xf4, 0xff, 0x4f, 0xf4, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x4e, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x99, 0xa2, 0x65,
+    0x55, 0x58, 0xa2, 0x7a, 0xa2, 0x26, 0x88, 0x61,
+    0x61, 0x32, 0x27, 0xa1, 0x66, 0x61, 0x31, 0x60,
+    0x00, 0x04, 0x4f, 0xf4, 0xff, 0x44, 0x44, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x44, 0xf4, 0x99,
+    0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0x9b, 0xaa, 0x26,
+    0x55, 0x55, 0x87, 0x27, 0x33, 0x27, 0x68, 0x61,
+    0x1a, 0x72, 0x27, 0xa6, 0x66, 0x6a, 0x71, 0x00,
+    0x80, 0x84, 0xff, 0xf4, 0xff, 0x44, 0x44, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x44, 0xf4, 0x99,
+    0x9b, 0x9b, 0x99, 0xb9, 0xb9, 0x99, 0xaa, 0xa2,
+    0x85, 0x55, 0x56, 0x22, 0x27, 0x22, 0x36, 0x66,
+    0x13, 0x22, 0x23, 0x16, 0x86, 0x63, 0x73, 0x00,
+    0x00, 0x44, 0xf4, 0xf4, 0xff, 0x44, 0x44, 0xff,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x4f, 0x99,
+    0x9b, 0x99, 0x99, 0x99, 0xb9, 0x99, 0xaa, 0xaa,
+    0x28, 0x55, 0x58, 0x12, 0x22, 0x22, 0x21, 0x11,
+    0xa3, 0x27, 0x7a, 0x66, 0x86, 0x17, 0x75, 0x05,
+    0x05, 0xff, 0xf4, 0xf4, 0xff, 0x44, 0x44, 0xff,
+    0xff, 0x4f, 0x44, 0x4f, 0x4f, 0x44, 0x4f, 0x99,
+    0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x3a, 0xaa,
+    0xa2, 0x85, 0x58, 0x67, 0x72, 0x22, 0x27, 0xa1,
+    0x37, 0x27, 0x7a, 0x68, 0x86, 0xa2, 0x70, 0x00,
+    0x02, 0xff, 0xf4, 0xf4, 0xff, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0xf4, 0xf4, 0xf4, 0x99,
+    0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x23, 0xaa,
+    0xa7, 0x78, 0x88, 0x81, 0x77, 0x22, 0x27, 0x3a,
+    0x72, 0x73, 0x71, 0x68, 0x66, 0x32, 0x50, 0x00,
+    0x04, 0x4f, 0xf4, 0xf4, 0xff, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0xf4, 0xf4, 0x44, 0x95,
+    0x99, 0x99, 0x99, 0x99, 0x99, 0x55, 0x12, 0x3a,
+    0xaa, 0x21, 0x88, 0x81, 0x77, 0x27, 0x73, 0x73,
+    0x72, 0x33, 0x36, 0x86, 0x61, 0x72, 0x00, 0x00,
+    0x04, 0x44, 0xf4, 0xf4, 0xf4, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x44, 0x55,
+    0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x8a, 0x27,
+    0xaa, 0x77, 0x68, 0x61, 0x23, 0x71, 0x11, 0x3a,
+    0x27, 0xa3, 0x36, 0x86, 0x61, 0x20, 0x00, 0x00,
+    0x04, 0xf4, 0xf4, 0xf4, 0xf4, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x41, 0x59,
+    0x99, 0x99, 0x99, 0x99, 0x99, 0x95, 0x58, 0x77,
+    0x27, 0x32, 0x36, 0x63, 0x23, 0x71, 0x66, 0x11,
+    0x27, 0x13, 0xa6, 0x86, 0x6a, 0x20, 0x00, 0x50,
+    0x04, 0x4f, 0x4f, 0x4f, 0x4f, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x41, 0x99,
+    0x9b, 0xbb, 0xbb, 0xbb, 0xb9, 0x99, 0x68, 0x13,
+    0x32, 0x22, 0x73, 0xa7, 0x2a, 0x31, 0x88, 0x66,
+    0x7a, 0x13, 0x18, 0x66, 0x63, 0x20, 0x00, 0x06,
+    0x0f, 0x4f, 0x4f, 0x4f, 0x4f, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0x4f, 0x4f, 0x49, 0x95,
+    0xa9, 0xa9, 0x99, 0x97, 0x92, 0x99, 0x65, 0x6a,
+    0x17, 0x22, 0x23, 0x72, 0x27, 0xaa, 0x88, 0x88,
+    0xa1, 0x17, 0x68, 0x66, 0x67, 0x70, 0x00, 0x05,
+    0x0f, 0x4f, 0x4f, 0x4f, 0x4f, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0xf4, 0xf4, 0x49, 0x9c,
+    0x2e, 0xee, 0xee, 0xee, 0xee, 0xa9, 0x65, 0x8a,
+    0x1a, 0xaa, 0x37, 0x72, 0x27, 0x37, 0x88, 0x88,
+    0x11, 0x17, 0x68, 0x66, 0x67, 0x10, 0x9d, 0xd0,
+    0x84, 0x44, 0xff, 0x4f, 0x4f, 0x44, 0xf4, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0xf4, 0xf4, 0x4f, 0x69,
+    0xcc, 0xee, 0xee, 0xee, 0xec, 0x99, 0x88, 0x63,
+    0x61, 0x68, 0x61, 0x72, 0x22, 0x7a, 0x68, 0x88,
+    0x11, 0x17, 0x88, 0x66, 0x12, 0x1b, 0xdd, 0xdd,
+    0x02, 0x44, 0x4f, 0x4f, 0x4f, 0x44, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xff, 0xff, 0x4f, 0x4c, 0xc5,
+    0x0c, 0xc1, 0x11, 0x1c, 0xc0, 0x26, 0x66, 0x17,
+    0x66, 0x88, 0x88, 0x12, 0x22, 0x23, 0xa8, 0x88,
+    0x11, 0x13, 0x88, 0x66, 0x17, 0xbb, 0xdd, 0xdd,
+    0xd0, 0x8f, 0xff, 0xf4, 0xf4, 0x44, 0xf4, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0x4f, 0x44, 0xdd, 0xdd,
+    0x00, 0x00, 0x00, 0x05, 0x9d, 0x21, 0x66, 0x27,
+    0xa6, 0x65, 0x58, 0x67, 0x22, 0x27, 0x28, 0x88,
+    0x11, 0xaa, 0x86, 0x68, 0x1a, 0xbb, 0xdd, 0xdd,
+    0xdb, 0x05, 0xf4, 0xf4, 0xf4, 0xf4, 0x44, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0xf4, 0xf4, 0xdd, 0xdb,
+    0x00, 0x00, 0x00, 0x00, 0xdd, 0xda, 0x66, 0x22,
+    0x71, 0x15, 0x55, 0x81, 0x22, 0x22, 0x76, 0x88,
+    0x11, 0x31, 0x88, 0x88, 0xab, 0xbd, 0xdd, 0xdd,
+    0xdd, 0x00, 0x04, 0x44, 0xff, 0xff, 0x4f, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0xf4, 0x44, 0xdd, 0xdb,
+    0x00, 0x00, 0x00, 0x0b, 0xdd, 0xda, 0x11, 0x22,
+    0x23, 0x68, 0x55, 0x86, 0x22, 0x22, 0x7a, 0x88,
+    0x1a, 0x71, 0x88, 0x89, 0xbb, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xd0, 0x00, 0x4f, 0x44, 0xff, 0x4f, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0xff, 0xe2, 0xdd, 0xdb,
+    0x90, 0x00, 0x05, 0xbd, 0xdd, 0xb8, 0x63, 0x22,
+    0x27, 0xa6, 0x55, 0x88, 0x77, 0x22, 0x22, 0x88,
+    0x1a, 0x28, 0xbd, 0xdb, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdb, 0x00, 0x07, 0x44, 0x4f, 0x4f, 0x4f,
+    0xff, 0x4f, 0x44, 0x4f, 0x4f, 0x22, 0xdd, 0xdb,
+    0xbb, 0x9b, 0xbb, 0xbd, 0xdd, 0xd5, 0x86, 0x22,
+    0x22, 0x77, 0x85, 0x88, 0x17, 0x22, 0x22, 0x88,
+    0xaa, 0x2b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0x00, 0x00, 0x54, 0x4f, 0x4f, 0x4f,
+    0xff, 0x4f, 0x44, 0xf4, 0x44, 0x22, 0xbd, 0xdd,
+    0xbb, 0xbb, 0xbb, 0xdd, 0xdd, 0xdd, 0x88, 0x72,
+    0x27, 0x22, 0x88, 0x88, 0x67, 0x72, 0x22, 0x18,
+    0x33, 0x2d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xd0, 0x00, 0x05, 0x4f, 0x4f, 0x4f,
+    0xff, 0x4f, 0x44, 0x44, 0x4f, 0x22, 0xbd, 0xdd,
+    0xdb, 0xbb, 0xdd, 0xdd, 0xdd, 0xdd, 0x88, 0x17,
+    0x27, 0x72, 0x68, 0x88, 0x87, 0x32, 0x22, 0x36,
+    0x37, 0x2d, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xd5, 0x00, 0x00, 0x4f, 0x4f, 0x4f,
+    0xff, 0xf4, 0xf4, 0xf4, 0xf4, 0x22, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd8, 0x67,
+    0x72, 0x77, 0x38, 0x88, 0x83, 0x37, 0x22, 0x26,
+    0x72, 0x2b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0x00, 0x00, 0x4f, 0x4f, 0x4f,
+    0xff, 0xf4, 0xf4, 0xf4, 0x44, 0x25, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd3,
+    0x32, 0x73, 0x76, 0x88, 0x81, 0x33, 0x22, 0x2a,
+    0x22, 0x2b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xb0, 0x54, 0x4f, 0x4f, 0x4f,
+    0xff, 0xf4, 0xf4, 0xff, 0x44, 0x00, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xa7, 0x73, 0x26, 0x88, 0x86, 0x7a, 0x72, 0x27,
+    0x22, 0x2b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdb, 0x44, 0xff, 0x4f, 0x4f,
+    0xff, 0xf4, 0xf4, 0x44, 0x40, 0x05, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0x13, 0x23, 0x21, 0x68, 0x86, 0x17, 0x72, 0x22,
+    0x22, 0x2b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdb, 0x44, 0x4f, 0x4f, 0x4f,
+    0xff, 0xff, 0x44, 0x42, 0x00, 0x05, 0xbd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0x87, 0x27, 0x27, 0x16, 0x66, 0x67, 0x22, 0x22,
+    0x72, 0x7b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0x94, 0x44, 0x44, 0x44,
+    0x44, 0x44, 0x44, 0x00, 0x00, 0x05, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xb8,
+    0x86, 0x22, 0x22, 0x7a, 0x68, 0x81, 0x22, 0x22,
+    0x37, 0x7b, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdb, 0xb5, 0x44, 0x44, 0x44,
+    0x44, 0x47, 0x00, 0x00, 0x00, 0x05, 0xbd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xd8, 0x68,
+    0x58, 0x72, 0x22, 0x27, 0x18, 0x86, 0x72, 0x22,
+    0x1a, 0xbb, 0xbd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdb, 0xb5, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xb9, 0x18, 0x85,
+    0x58, 0x12, 0x22, 0x36, 0x18, 0x88, 0x32, 0x22,
+    0x61, 0x3b, 0xbb, 0xbb, 0xbd, 0xdd, 0xdd, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdb, 0xb9, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0xbb, 0xdd,
+    0xdd, 0xdd, 0xdd, 0xdd, 0xb9, 0x7a, 0x68, 0x85,
+    0x88, 0x62, 0x27, 0x16, 0x18, 0x88, 0x12, 0x27,
+    0x86, 0x18, 0x9b, 0xbb, 0xbb, 0xbb, 0xbb, 0xbd,
+    0xdd, 0xdd, 0xdd, 0xbb, 0xb5, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xbb, 0xbd,
+    0xdd, 0xdd, 0xdb, 0xbb, 0x87, 0x31, 0x68, 0x65,
+    0x88, 0x82, 0x23, 0x16, 0x18, 0x88, 0x12, 0x23,
+    0x88, 0x67, 0x27, 0xa8, 0x9b, 0xbb, 0xbb, 0xbb,
+    0xbd, 0xdd, 0xbb, 0xbb, 0x95, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x9b, 0xbb,
+    0xbb, 0xbb, 0xbb, 0x96, 0x87, 0x16, 0x68, 0x18,
+    0x88, 0x62, 0x31, 0x66, 0x18, 0x88, 0x62, 0x73,
+    0x88, 0x63, 0x27, 0x33, 0x65, 0x55, 0x99, 0x9b,
+    0xbb, 0xbb, 0xbb, 0x99, 0x55, 0x0a, 0xa1, 0x86,
+    0x81, 0x68, 0x88, 0x55, 0x58, 0x85, 0x9b, 0xbb,
+    0xbb, 0xbb, 0x95, 0x88, 0x83, 0x66, 0x66, 0x18,
+    0x66, 0x82, 0xa1, 0x66, 0x18, 0x88, 0x62, 0x33,
+    0x88, 0x81, 0x27, 0x7a, 0x18, 0x58, 0x86, 0x85,
+    0x99, 0x99, 0x99, 0x95, 0x53, 0x2a, 0xaa, 0x88,
+    0x67, 0x31, 0x68, 0x55, 0x58, 0x85, 0x59, 0xbb,
+    0xbb, 0xb9, 0x58, 0x68, 0x83, 0x66, 0x61, 0x16,
+    0x66, 0x62, 0x16, 0x66, 0x68, 0x88, 0x62, 0xaa,
+    0x88, 0x86, 0x27, 0x77, 0x78, 0x55, 0x88, 0x22,
+    0x25, 0x55, 0x95, 0x55, 0x6a, 0xa2, 0x2a, 0x88,
+    0x62, 0x27, 0x37, 0x38, 0x88, 0x87, 0x55, 0x59,
+    0x95, 0x58, 0x16, 0x88, 0x8a, 0x66, 0x63, 0x68,
+    0x86, 0x67, 0x66, 0x66, 0x68, 0x88, 0x12, 0x11,
+    0x88, 0x88, 0x72, 0x77, 0x78, 0x85, 0x58, 0x17,
+    0x23, 0x32, 0x55, 0x55, 0x81, 0x13, 0x73, 0x66,
+    0x62, 0x7a, 0xaa, 0x38, 0x88, 0x58, 0x27, 0x55,
+    0x58, 0x32, 0x38, 0x88, 0x81, 0x66, 0xa2, 0x88,
+    0x86, 0x61, 0x66, 0x61, 0x66, 0x68, 0x13, 0x11,
+    0x88, 0x88, 0x12, 0x22, 0x71, 0x85, 0x58, 0x62,
+    0x23, 0xa2, 0x68, 0x88, 0x81, 0x66, 0x88, 0x88,
+    0x63, 0x2a, 0xaa, 0x28, 0x88, 0x55, 0x86, 0x61,
+    0x66, 0x66, 0x68, 0x88, 0x66, 0x66, 0x77, 0x88,
+    0x68, 0x16, 0x66, 0x62, 0x66, 0x68, 0xa1, 0x61,
+    0x88, 0x88, 0x62, 0x22, 0x22, 0x85, 0x55, 0x83,
+    0x72, 0x37, 0xa8, 0x88, 0x61, 0x66, 0x85, 0x55,
+    0x86, 0x23, 0xaa, 0x71, 0x88, 0x85, 0x88, 0x66,
+    0x88, 0x86, 0x88, 0x88, 0x16, 0x61, 0x21, 0x88,
+    0x66, 0xa6, 0x86, 0x17, 0x66, 0x66, 0x31, 0x61,
+    0x88, 0x88, 0x87, 0x72, 0x22, 0x68, 0x55, 0x86,
+    0x77, 0x77, 0x36, 0x88, 0x13, 0x68, 0x85, 0x55,
+    0x58, 0x12, 0x73, 0x72, 0x76, 0x88, 0x88, 0x68,
+    0x88, 0x88, 0x88, 0x66, 0x36, 0x63, 0x26, 0x86,
+    0x86, 0x36, 0x86, 0x11, 0x66, 0x66, 0x76, 0x61,
+    0x88, 0x88, 0x81, 0x22, 0x22, 0x38, 0x85, 0x58,
+    0x37, 0x22, 0x21, 0x68, 0xa2, 0x31, 0x68, 0x55,
+    0x55, 0x81, 0x22, 0x22, 0xa8, 0x88, 0x88, 0x68,
+    0x86, 0x88, 0x68, 0x81, 0x36, 0x17, 0x21, 0x68,
+    0x86, 0x16, 0x66, 0x26, 0x66, 0x61, 0x36, 0x66,
+    0x68, 0x88, 0x86, 0x27, 0x22, 0x28, 0x88, 0x88,
+    0x17, 0x72, 0x2a, 0x66, 0xa2, 0x22, 0x36, 0x55,
+    0x55, 0x58, 0x37, 0x3a, 0x16, 0x66, 0x66, 0x66,
+    0x66, 0x18, 0x88, 0x67, 0x16, 0x12, 0x71, 0x68,
+    0x81, 0x68, 0x61, 0x76, 0x66, 0x6a, 0x16, 0x66,
+    0x88, 0x88, 0x86, 0x77, 0x22, 0x26, 0x88, 0x88,
+    0x13, 0x37, 0x71, 0x66, 0xa2, 0x33, 0x2a, 0x85,
+    0x55, 0x55, 0x17, 0x73, 0x16, 0x66, 0x66, 0x68,
+    0x63, 0x88, 0x88, 0xa2, 0x66, 0xa2, 0xa6, 0x88,
+    0x61, 0x68, 0x6a, 0x76, 0x66, 0x6a, 0x66, 0x6a
+};
+
+#endif

diff --git a/include/shannon_video.h b/include/shannon_video.h
new file mode 100644 (file)
index 0000000..e9ef5b3
--- /dev/null
+++ b/include/shannon_video.h
@@ -0,0 +1,71 @@
+/*
+ * (C) Copyright 2002
+ * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
+ * Robert Kaiser <rkaiser@sysgo.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
+ */
+
+/*
+** Definitions for the Shannon video interface:
+*/
+
+/*
+** This driver does not initialize the screen interface, but rather relies
+** on the Inferno firmware having done this in a known fashion:
+**
+** - Resolution: 640x480 pixels
+** - Eight bits per pixel
+** - Color palette memory at 0xd83a4d00
+** - Frame buffer memory at 0xd83a4d00+0x200
+**
+*/
+#define LCD_LUT_ADDR            (0xd83a4d00)        /* address of color map */
+#define LCD_VIDEO_ADDR          (LCD_LUT_ADDR+512)  /* address of frame buffer */
+#define LCD_VIDEO_SIZE          ((640*480) / 4)
+#define LCD_VIDEO_COLS          640                 /* # of colomns (pixels) */
+#define LCD_VIDEO_ROWS          480                 /* # of lines (pixels) */
+#define LCD_VIDEO_BPP                  8                                       /* # of bits per pixel */
+#define LCD_VIDEO_FORMAT               0                                       /* see cfb_console.c GDF__8BIT_INDEX */
+
+/*
+** Entries in the color lookup table are 16-bits wide, where
+** four bits are used for each color component:
+**
+** 15  12    8    4    0
+** +----+----+----+----+
+** |xxxx| r  | g  | b  |
+** +----+----+----+----+
+**
+*/
+
+typedef unsigned short video_lut_entry;
+
+#define COL_MASK       0xf     /* four bits per color */
+#define R_SHIFT                8
+#define G_SHIFT                4
+#define B_SHIFT                0
+
+#define R_MASK (COL_MASK<<R_SHIFT)
+#define G_MASK (COL_MASK<<G_SHIFT)
+#define B_MASK (COL_MASK<<B_SHIFT)
+
+#define RGB_MASK       (R_MASK|G_MASK|B_MASK)
+
+