From: robertkaiser Date: Fri, 27 Sep 2002 16:26:00 +0000 (+0000) Subject: add framebuffer/IrDA Keyboard support for Shannon (Tuxscreen) X-Git-Url: https://www.infradead.org/git/?a=commitdiff_plain;h=0f74acc73e146aec4c0187f57cfd4c27df89c5cf;p=users%2Frw%2Farmboot.git add framebuffer/IrDA Keyboard support for Shannon (Tuxscreen) --- diff --git a/CHANGELOG b/CHANGELOG index cc26079..e344b24 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -2,6 +2,10 @@ Recent Modifications ====================================================================== +* Patch by Robert Kaiser : + + - add framebuffer/IrDA Keyboard support for Shannon (Tuxscreen) + * Patch by Robert Kaiser : - flush caches before executing code that may have been downloaded diff --git a/Makefile b/Makefile index 7dd833f..0ab1d4c 100644 --- 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 56105d3..72ffa5d 100644 --- 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 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" + ./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 index 0000000..f06eae2 --- /dev/null +++ b/board/shannon/irkbd.c @@ -0,0 +1,94 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 index 0000000..0bf4c7b --- /dev/null +++ b/board/shannon/kbd_map.c @@ -0,0 +1,415 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 -'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 */ +const static char _F12[] = {'\033','[','2','4','~','\000', 0x08 }; /* F12: */ +const static char _F13[] = {'\033','[','2','5','~','\000','\012'}; /* F13: */ + +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: */ +#define F12 SKEY(_F12_Index) /* F12: */ +#define F13 SKEY(_F13_Index) /* F13: */ + +#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 index 0000000..cf4adc5 --- /dev/null +++ b/board/shannon/video.c @@ -0,0 +1,126 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 + +/* +************************************************************ +** 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 030588b..d1d502f 100644 --- 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 9ef8c8f..f725b86 100644 --- 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 bd96f56..542e295 100644 --- 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 d9717f6..043a0ff 100644 --- a/common/console.c +++ b/common/console.c @@ -24,11 +24,32 @@ #include #include #include +#include + +#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 4fada9f..d3b585b 100644 --- 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 index 0000000..15a20f6 --- /dev/null +++ b/drivers/ansi_console.c @@ -0,0 +1,815 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 index 0000000..8614cd7 --- /dev/null +++ b/drivers/cfb_console.c @@ -0,0 +1,894 @@ +/* + * (C) Copyright 2002 ELTEC Elektronik AG + * Frank Gottschling + * + * 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 + +#ifdef CONFIG_CFB_CONSOLE + +/*****************************************************************************/ +/* Console device defines with SMI graphic */ +/* Any other graphic must change this section */ +/*****************************************************************************/ + +#ifdef CONFIG_VIDEO_SMI_LYNXEM +#include + +#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 + +#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 + +#define VIDEO_KBD_INIT_FCT i8042_kbd_init() +#define VIDEO_TSTC_FCT i8042_tstc +#define VIDEO_GETC_FCT i8042_getc +#endif + + +/*****************************************************************************/ +/* Console device */ +/*****************************************************************************/ + +#include +#include +#include +#include +#ifdef CFG_CMD_DATE +#include + +#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 +#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 index 0000000..b35ca1b --- /dev/null +++ b/drivers/cursor.h @@ -0,0 +1,43 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 index 0000000..9f9f06e --- /dev/null +++ b/drivers/font.h @@ -0,0 +1,35 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 index 0000000..b03edf4 --- /dev/null +++ b/drivers/font8x14.c @@ -0,0 +1,1491 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 index 0000000..f1c7018 --- /dev/null +++ b/drivers/framebuffer.c @@ -0,0 +1,953 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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< 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<> 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 index 0000000..c7623e5 --- /dev/null +++ b/drivers/keyboard.c @@ -0,0 +1,456 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 +#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 09b31e3..8cef359 100644 --- 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 41a4c57..06d4873 100644 --- 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 index 0000000..de2053e --- /dev/null +++ b/include/keyboard.h @@ -0,0 +1,188 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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 + +/* +** 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 +** -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 & mkbrkmask == makecode -> key has been pressed +** if & 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 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 index 0000000..e9ef5b3 --- /dev/null +++ b/include/shannon_video.h @@ -0,0 +1,71 @@ +/* + * (C) Copyright 2002 + * Sysgo Real-Time Solutions, GmbH + * Robert Kaiser + * + * 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<