Implement native VGA Support.

This code brings a rather complete set of VGA IO routines for whoever wants it.
These consist of the by now familiar read/write/mask sets. Due to the crazy
nature of VGA, an ancient standard with bits all over the place, it makes no
sense to define individual registers. You need a vga register spec at hand if
you want to do anything anyway. These IO routines are always exposed.

It also provides code to natively set up a 640x400 VGA textmode with an 8x16
font. The native VGA mode code is behind the OPTION_VGA option, as the font
really adds to the size of the compiled/compressed rom. The font is the one
also present in the linux kernel, but this file is unlicensed. Another copy of
this is also present in coreboot in the deprecated console/btext code.

The vga console code has been cleaned up, but it still has some TODO's left
open, but that's for when i finally have found the remaining issue with the
epia-m. Right now, it is important to get parts of my work out already and to
make the remainder managable again.

Signed-off-by: Luc Verhaegen <libv@skynet.be>
Acked-by: Peter Stuge <peter@stuge.se>

git-svn-id: svn://svn.coreboot.org/coreboot/trunk@4321 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1
This commit is contained in:
Luc Verhaegen
2009-05-29 03:04:16 +00:00
parent 195f5cd666
commit 5c5beb765d
12 changed files with 5406 additions and 292 deletions

View File

@@ -1,5 +1,4 @@
uses CONFIG_IDE
uses CONFIG_CONSOLE_VGA
uses CONFIG_UDELAY_IO
object mc146818rtc.o
@@ -15,4 +14,6 @@ if CONFIG_IDE
dir ide
end
dir vga
object keyboard.o

9
src/pc80/vga/Config.lb Normal file
View File

@@ -0,0 +1,9 @@
uses CONFIG_VGA
# always build this.
object vga_io.o
# this adds a vga modeset including a huge font.
if CONFIG_VGA
object vga.o
end

328
src/pc80/vga/vga.c Normal file
View File

@@ -0,0 +1,328 @@
/*
* Copyright (C) 2007-2009 Luc Verhaegen <libv@skynet.be>
*
* 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., 51
* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <pc80/vga.h>
#include <pc80/vga_io.h>
#include <string.h>
/*
* pci io enable should've happened before
*/
void
vga_io_init(void)
{
vga_enable_mask(0x01, 0x01);
/* cr io is at 0x3D4/0x3D5 */
vga_misc_mask(0x01, 0x01);
/* clear cr0-7 protection */
vga_cr_mask(0x11, 0x00, 0x80);
}
/*
*
*/
static void
vga_fb_init(void)
{
vga_sr_write(0x02, 0x03);
vga_sr_write(0x03, 0x00);
vga_sr_write(0x04, 0x02); /* access all 256kB */
vga_gr_write(0x00, 0x00);
vga_gr_write(0x01, 0x00);
vga_gr_write(0x02, 0x00);
vga_gr_write(0x03, 0x00);
vga_gr_write(0x04, 0x00);
vga_gr_write(0x05, 0x10);
vga_gr_write(0x06, 0x0E); /* map at 0xB8000 */
vga_gr_write(0x07, 0x00);
vga_gr_write(0x08, 0xFF);
/* o/e enable: ram enable */
vga_misc_mask(0x22, 0x22);
}
/*
*
*/
static void
vga_fb_clear(void)
{
memset((void *)VGA_FB, 0x00, 0x8000);
}
#include "vga_palette.c"
/*
*
*/
static void
vga_palette_init(void)
{
unsigned int i;
/* set up attribute registers */
for (i = 0; i < 0x10; i++)
vga_ar_write(i, i);
vga_ar_write(0x10, 0x0c);
vga_ar_write(0x11, 0x00);
vga_ar_write(0x12, 0x0F);
vga_ar_write(0x13, 0x08);
vga_ar_write(0x14, 0x00);
vga_palette_disable();
/* load actual palette */
vga_dac_mask_write(0xFF);
for (i = 0; i < 0x100; i++) {
vga_dac_write_address(i);
vga_dac_data_write(default_vga_palette[i].red);
vga_dac_data_write(default_vga_palette[i].green);
vga_dac_data_write(default_vga_palette[i].blue);
}
}
/*
*
*/
static void
vga_mode_set(int hdisplay, int hblankstart, int hsyncstart, int hsyncend,
int hblankend, int htotal, int vdisplay, int vblankstart,
int vsyncstart, int vsyncend, int vblankend, int vtotal,
int stride)
{
/* htotal: 2080 */
htotal /= 8;
htotal -= 5;
vga_cr_write(0x00, htotal);
/* hdisplay: 2048 */
hdisplay /= 8;
hdisplay -= 1;
vga_cr_write(0x01, hdisplay);
/* hblankstart: 2048 */
hblankstart /= 8;
hblankstart -= 1;
vga_cr_write(0x02, hblankstart);
/* hblankend: hblankstart + 512 */
hblankend /= 8;
hblankend -= 1;
vga_cr_mask(0x03, hblankend, 0x1F);
vga_cr_mask(0x05, hblankend << 2, 0x80);
/* hsyncstart: 255 * 8: 2040 */
vga_cr_write(0x04, hsyncstart / 8);
/* hsyncend: hsyncstart + 255 */
vga_cr_mask(0x05, hsyncend / 8, 0x1F);
/* vtotal: 1025 */
vtotal -= 2;
vga_cr_write(0x06, vtotal);
vga_cr_mask(0x07, vtotal >> 8, 0x01);
vga_cr_mask(0x07, vtotal >> 4, 0x20);
/* vdisplay: 1024 */
vdisplay -= 1;
vga_cr_write(0x12, vdisplay);
vga_cr_mask(0x07, vdisplay >> 7, 0x02);
vga_cr_mask(0x07, vdisplay >> 3, 0x40);
/* vblankstart: 1024 */
vblankstart -= 1;
vga_cr_write(0x15, vblankstart);
vga_cr_mask(0x07, vblankstart >> 5, 0x08);
vga_cr_mask(0x09, vblankstart >> 4, 0x20);
/* vblankend: vblankstart + 256 */
vblankend -= 1;
vga_cr_write(0x16, vblankend);
/* vsyncstart: 1023 */
vga_cr_write(0x10, vsyncstart);
vga_cr_mask(0x07, vsyncstart >> 6, 0x04);
vga_cr_mask(0x07, vsyncstart >> 2, 0x80);
/* vsyncend: vsyncstart + 16 */
vga_cr_mask(0x11, vsyncend, 0x0F);
/* stride */
vga_cr_write(0x13, stride / 8);
/* line compare */
vga_cr_write(0x18, 0xFF);
vga_cr_mask(0x07, 0x10, 0x10);
vga_cr_mask(0x09, 0x40, 0x40);
vga_misc_mask(0x44, 0xCC); /* set up clock: 27mhz and h/vsync */
vga_cr_mask(0x09, 0x00, 0x80); /* disable doublescan */
}
#include "vga_font_8x16.c"
static void
vga_font_8x16_load(void)
{
unsigned char *p;
int i, j;
unsigned char sr2, sr4, gr5, gr6;
#define height 16
#define count 256
sr2 = vga_sr_read(0x02);
sr4 = vga_sr_read(0x04);
gr5 = vga_gr_read(0x05);
gr6 = vga_gr_read(0x06);
/* disable odd/even */
vga_sr_mask(0x04, 0x04, 0x04);
vga_gr_mask(0x05, 0x00, 0x10);
vga_gr_mask(0x06, 0x00, 0x02);
/* plane 2 */
vga_sr_write(0x02, 0x04);
p = (unsigned char *) VGA_FB;
for (i = 0; i < count; i++) {
for (j = 0; j < 32; j++) {
if (j < height)
*p = vga_font_8x16[i][j];
else
*p = 0x00;
p++;
}
}
vga_gr_write(0x06, gr6);
vga_gr_write(0x05, gr5);
vga_sr_write(0x04, sr4);
vga_sr_write(0x02, sr2);
/* set up font size */
vga_cr_mask(0x09, 16 - 1, 0x1F);
}
/*
*
*/
void
vga_cursor_enable(int enable)
{
if (enable)
vga_cr_mask(0x0A, 0x00, 0x20);
else
vga_cr_mask(0x0A, 0x20, 0x20);
}
/*
*
*/
void
vga_cursor_reset(void)
{
vga_cr_write(0x0A, 0x2E);
vga_cr_write(0x0B, 0x0E);
vga_cr_write(0x0E, 0x00);
vga_cr_write(0x0F, 0x00);
}
/*
*
*/
void
vga_cursor_set(unsigned int line, unsigned int character)
{
unsigned int offset = (80 * line + character) & 0xFFFF;
vga_cr_write(0x0A, 0x0E);
vga_cr_write(0x0B, 0x0E);
vga_cr_write(0x0E, offset >> 8);
vga_cr_write(0x0F, offset & 0xFF);
}
/*
*
*/
void
vga_frame_set(unsigned int line, unsigned int character)
{
unsigned int offset = (80 * line + character) & 0xFFFF;
vga_cr_write(0x0C, offset >> 8);
vga_cr_write(0x0D, offset & 0xFF);
}
/*
* simply fills a line with the given string.
*/
void
vga_line_write(unsigned int line, const char *string)
{
unsigned short *p = (unsigned short *) VGA_FB + (80 * line);
int i, len = strlen(string);
for (i = 0; i < 80; i++) {
if (i < len)
p[i] = 0x0F00 | string[i];
else
p[i] = 0x0F00;
}
}
/*
* set up everything to get a basic 80x25 textmode.
*/
void
vga_textmode_init(void)
{
vga_sr_write(0x00, 0x01); /* clear reset */
vga_sr_write(0x01, 0x00);
/* set up cr */
vga_cr_mask(0x03, 0x80, 0xE0);
vga_cr_mask(0x05, 0x00, 0x60);
vga_cr_write(0x08, 0x00);
vga_cr_write(0x14, 0x00); /* */
vga_cr_write(0x17, 0x23);
vga_palette_init();
vga_mode_set(640, 648, 680, 776, 792, 800,
400, 407, 412, 414, 442, 449, 320);
vga_cursor_reset();
vga_frame_set(0, 0);
vga_fb_init();
vga_fb_clear();
vga_font_8x16_load();
vga_sr_mask(0x00, 0x02, 0x02); /* take us out of reset */
vga_cr_mask(0x17, 0x80, 0x80); /* sync! */
}

4362
src/pc80/vga/vga_font_8x16.c Normal file

File diff suppressed because it is too large Load Diff

275
src/pc80/vga/vga_io.c Normal file
View File

@@ -0,0 +1,275 @@
/*
* Copyright (C) 2007-2009 Luc Verhaegen <libv@skynet.be>
*
* 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., 51
* Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
/*
* All IO necessary to poke VGA registers.
*/
#include <pc80/vga_io.h>
#include <arch/io.h>
#define VGA_CR_INDEX 0x3D4
#define VGA_CR_VALUE 0x3D5
#define VGA_SR_INDEX 0x3C4
#define VGA_SR_VALUE 0x3C5
#define VGA_GR_INDEX 0x3CE
#define VGA_GR_VALUE 0x3CF
#define VGA_AR_INDEX 0x3C0
#define VGA_AR_VALUE_READ 0x3C1
#define VGA_AR_VALUE_WRITE VGA_AR_INDEX
#define VGA_MISC_WRITE 0x3C2
#define VGA_MISC_READ 0x3CC
#define VGA_ENABLE 0x3C3
#define VGA_STAT1 0x3DA
#define VGA_DAC_MASK 0x3C6
#define VGA_DAC_READ_ADDRESS 0x3C7
#define VGA_DAC_WRITE_ADDRESS 0x3C8
#define VGA_DAC_DATA 0x3C9
/*
* VGA enable. Poke this to have the PCI IO enabled device accept VGA IO.
*/
unsigned char
vga_enable_read(void)
{
return inb(VGA_ENABLE);
}
void
vga_enable_write(unsigned char value)
{
outb(value, VGA_ENABLE);
}
void
vga_enable_mask(unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_enable_read();
tmp &= ~mask;
tmp |= (value & mask);
vga_enable_write(tmp);
}
/*
* Miscellaneous register.
*/
unsigned char
vga_misc_read(void)
{
return inb(VGA_MISC_READ);
}
void
vga_misc_write(unsigned char value)
{
outb(value, VGA_MISC_WRITE);
}
void
vga_misc_mask(unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_misc_read();
tmp &= ~mask;
tmp |= (value & mask);
vga_misc_write(tmp);
}
/*
* Sequencer registers.
*/
unsigned char
vga_sr_read(unsigned char index)
{
outb(index, VGA_SR_INDEX);
return (inb(VGA_SR_VALUE));
}
void
vga_sr_write(unsigned char index, unsigned char value)
{
outb(index, VGA_SR_INDEX);
outb(value, VGA_SR_VALUE);
}
void
vga_sr_mask(unsigned char index, unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_sr_read(index);
tmp &= ~mask;
tmp |= (value & mask);
vga_sr_write(index, tmp);
}
/*
* CRTC registers.
*/
unsigned char
vga_cr_read(unsigned char index)
{
outb(index, VGA_CR_INDEX);
return (inb(VGA_CR_VALUE));
}
void
vga_cr_write(unsigned char index, unsigned char value)
{
outb(index, VGA_CR_INDEX);
outb(value, VGA_CR_VALUE);
}
void
vga_cr_mask(unsigned char index, unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_cr_read(index);
tmp &= ~mask;
tmp |= (value & mask);
vga_cr_write(index, tmp);
}
/*
* Attribute registers.
*/
unsigned char
vga_ar_read(unsigned char index)
{
unsigned char ret;
(void) inb(VGA_STAT1);
outb(index, VGA_AR_INDEX);
ret = inb(VGA_AR_VALUE_READ);
(void) inb(VGA_STAT1);
return ret;
}
void
vga_ar_write(unsigned char index, unsigned char value)
{
(void) inb(VGA_STAT1);
outb(index, VGA_AR_INDEX);
outb(value, VGA_AR_VALUE_WRITE);
(void) inb(VGA_STAT1);
}
void
vga_ar_mask(unsigned char index, unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_ar_read(index);
tmp &= ~mask;
tmp |= (value & mask);
vga_ar_write(index, tmp);
}
/*
* Graphics registers.
*/
unsigned char
vga_gr_read(unsigned char index)
{
outb(index, VGA_GR_INDEX);
return (inb(VGA_GR_VALUE));
}
void
vga_gr_write(unsigned char index, unsigned char value)
{
outb(index, VGA_GR_INDEX);
outb(value, VGA_GR_VALUE);
}
void
vga_gr_mask(unsigned char index, unsigned char value, unsigned char mask)
{
unsigned char tmp;
tmp = vga_gr_read(index);
tmp &= ~mask;
tmp |= (value & mask);
vga_gr_write(index, tmp);
}
/*
* DAC functions.
*/
void
vga_palette_enable(void)
{
(void) inb(VGA_STAT1);
outb(0x00, VGA_AR_INDEX);
(void) inb(VGA_STAT1);
}
void
vga_palette_disable(void)
{
(void) inb(VGA_STAT1);
outb(0x20, VGA_AR_INDEX);
(void) inb(VGA_STAT1);
}
unsigned char
vga_dac_mask_read(void)
{
return inb(VGA_DAC_MASK);
}
void
vga_dac_mask_write(unsigned char mask)
{
outb(mask, VGA_DAC_MASK);
}
void
vga_dac_read_address(unsigned char address)
{
outb(address, VGA_DAC_READ_ADDRESS);
}
void
vga_dac_write_address(unsigned char address)
{
outb(address, VGA_DAC_WRITE_ADDRESS);
}
unsigned char
vga_dac_data_read(void)
{
return inb(VGA_DAC_DATA);
}
void
vga_dac_data_write(unsigned char data)
{
outb(data, VGA_DAC_DATA);
}

261
src/pc80/vga/vga_palette.c Normal file
View File

@@ -0,0 +1,261 @@
/*
* Basic palette.
*/
struct palette {
unsigned char red;
unsigned char green;
unsigned char blue;
};
static const struct palette
default_vga_palette[0x100] = {
{ 0x00, 0x00, 0x00},
{ 0x00, 0x00, 0x2A},
{ 0x00, 0x2A, 0x00},
{ 0x00, 0x2A, 0x2A},
{ 0x2A, 0x00, 0x00},
{ 0x2A, 0x00, 0x2A},
{ 0x2A, 0x15, 0x00},
{ 0x2A, 0x2A, 0x2A},
{ 0x15, 0x15, 0x15},
{ 0x15, 0x15, 0x3F},
{ 0x15, 0x3F, 0x15},
{ 0x15, 0x3F, 0x3F},
{ 0x3F, 0x15, 0x15},
{ 0x3F, 0x15, 0x3F},
{ 0x3F, 0x3F, 0x15},
{ 0x3F, 0x3F, 0x3F},
{ 0x00, 0x00, 0x00},
{ 0x05, 0x05, 0x05},
{ 0x08, 0x08, 0x08},
{ 0x0B, 0x0B, 0x0B},
{ 0x0E, 0x0E, 0x0E},
{ 0x11, 0x11, 0x11},
{ 0x16, 0x16, 0x16},
{ 0x18, 0x18, 0x18},
{ 0x1C, 0x1C, 0x1C},
{ 0x20, 0x20, 0x20},
{ 0x24, 0x24, 0x24},
{ 0x28, 0x28, 0x28},
{ 0x2D, 0x2D, 0x2D},
{ 0x32, 0x32, 0x32},
{ 0x38, 0x38, 0x38},
{ 0x3F, 0x3F, 0x3F},
{ 0x00, 0x00, 0x3F},
{ 0x20, 0x00, 0x3F},
{ 0x1F, 0x00, 0x3F},
{ 0x2F, 0x00, 0x3F},
{ 0x3F, 0x00, 0x3F},
{ 0x3F, 0x00, 0x2F},
{ 0x3F, 0x00, 0x1F},
{ 0x3F, 0x00, 0x20},
{ 0x3F, 0x00, 0x00},
{ 0x3F, 0x20, 0x00},
{ 0x3F, 0x1F, 0x00},
{ 0x3F, 0x2F, 0x00},
{ 0x3F, 0x3F, 0x00},
{ 0x2F, 0x3F, 0x00},
{ 0x1F, 0x3F, 0x00},
{ 0x20, 0x3F, 0x00},
{ 0x00, 0x3F, 0x00},
{ 0x00, 0x3F, 0x20},
{ 0x00, 0x3F, 0x1F},
{ 0x00, 0x3F, 0x2F},
{ 0x00, 0x3F, 0x3F},
{ 0x00, 0x2F, 0x3F},
{ 0x00, 0x1F, 0x3F},
{ 0x00, 0x20, 0x3F},
{ 0x1F, 0x1F, 0x3F},
{ 0x27, 0x1F, 0x3F},
{ 0x2F, 0x1F, 0x3F},
{ 0x37, 0x1F, 0x3F},
{ 0x3F, 0x1F, 0x3F},
{ 0x3F, 0x1F, 0x37},
{ 0x3F, 0x1F, 0x2F},
{ 0x3F, 0x1F, 0x27},
{ 0x3F, 0x1F, 0x1F},
{ 0x3F, 0x27, 0x1F},
{ 0x3F, 0x2F, 0x1F},
{ 0x3F, 0x37, 0x1F},
{ 0x3F, 0x3F, 0x1F},
{ 0x37, 0x3F, 0x1F},
{ 0x2F, 0x3F, 0x1F},
{ 0x27, 0x3F, 0x1F},
{ 0x1F, 0x3F, 0x1F},
{ 0x1F, 0x3F, 0x27},
{ 0x1F, 0x3F, 0x2F},
{ 0x1F, 0x3F, 0x37},
{ 0x1F, 0x3F, 0x3F},
{ 0x1F, 0x37, 0x3F},
{ 0x1F, 0x2F, 0x3F},
{ 0x1F, 0x27, 0x3F},
{ 0x2D, 0x2D, 0x3F},
{ 0x31, 0x2D, 0x3F},
{ 0x36, 0x2D, 0x3F},
{ 0x3A, 0x2D, 0x3F},
{ 0x3F, 0x2D, 0x3F},
{ 0x3F, 0x2D, 0x3A},
{ 0x3F, 0x2D, 0x36},
{ 0x3F, 0x2D, 0x31},
{ 0x3F, 0x2D, 0x2D},
{ 0x3F, 0x31, 0x2D},
{ 0x3F, 0x36, 0x2D},
{ 0x3F, 0x3A, 0x2D},
{ 0x3F, 0x3F, 0x2D},
{ 0x3A, 0x3F, 0x2D},
{ 0x36, 0x3F, 0x2D},
{ 0x31, 0x3F, 0x2D},
{ 0x2D, 0x3F, 0x2D},
{ 0x2D, 0x3F, 0x31},
{ 0x2D, 0x3F, 0x36},
{ 0x2D, 0x3F, 0x3A},
{ 0x2D, 0x3F, 0x3F},
{ 0x2D, 0x3A, 0x3F},
{ 0x2D, 0x36, 0x3F},
{ 0x2D, 0x31, 0x3F},
{ 0x00, 0x00, 0x1C},
{ 0x07, 0x00, 0x1C},
{ 0x0E, 0x00, 0x1C},
{ 0x15, 0x00, 0x1C},
{ 0x1C, 0x00, 0x1C},
{ 0x1C, 0x00, 0x15},
{ 0x1C, 0x00, 0x0E},
{ 0x1C, 0x00, 0x07},
{ 0x1C, 0x00, 0x00},
{ 0x1C, 0x07, 0x00},
{ 0x1C, 0x0E, 0x00},
{ 0x1C, 0x15, 0x00},
{ 0x1C, 0x1C, 0x00},
{ 0x15, 0x1C, 0x00},
{ 0x0E, 0x1C, 0x00},
{ 0x07, 0x1C, 0x00},
{ 0x00, 0x1C, 0x00},
{ 0x00, 0x1C, 0x07},
{ 0x00, 0x1C, 0x0E},
{ 0x00, 0x1C, 0x15},
{ 0x00, 0x1C, 0x1C},
{ 0x00, 0x15, 0x1C},
{ 0x00, 0x0E, 0x1C},
{ 0x00, 0x07, 0x1C},
{ 0x0E, 0x0E, 0x1C},
{ 0x11, 0x0E, 0x1C},
{ 0x15, 0x0E, 0x1C},
{ 0x18, 0x0E, 0x1C},
{ 0x1C, 0x0E, 0x1C},
{ 0x1C, 0x0E, 0x18},
{ 0x1C, 0x0E, 0x15},
{ 0x1C, 0x0E, 0x11},
{ 0x1C, 0x0E, 0x0E},
{ 0x1C, 0x11, 0x0E},
{ 0x1C, 0x15, 0x0E},
{ 0x1C, 0x18, 0x0E},
{ 0x1C, 0x1C, 0x0E},
{ 0x18, 0x1C, 0x0E},
{ 0x15, 0x1C, 0x0E},
{ 0x11, 0x1C, 0x0E},
{ 0x0E, 0x1C, 0x0E},
{ 0x0E, 0x1C, 0x11},
{ 0x0E, 0x1C, 0x15},
{ 0x0E, 0x1C, 0x18},
{ 0x0E, 0x1C, 0x1C},
{ 0x0E, 0x18, 0x1C},
{ 0x0E, 0x15, 0x1C},
{ 0x0E, 0x11, 0x1C},
{ 0x16, 0x16, 0x1C},
{ 0x16, 0x16, 0x1C},
{ 0x18, 0x16, 0x1C},
{ 0x1A, 0x16, 0x1C},
{ 0x1C, 0x16, 0x1C},
{ 0x1C, 0x16, 0x1A},
{ 0x1C, 0x16, 0x18},
{ 0x1C, 0x16, 0x16},
{ 0x1C, 0x16, 0x16},
{ 0x1C, 0x16, 0x16},
{ 0x1C, 0x18, 0x16},
{ 0x1C, 0x1A, 0x16},
{ 0x1C, 0x1C, 0x16},
{ 0x1A, 0x1C, 0x16},
{ 0x18, 0x1C, 0x16},
{ 0x16, 0x1C, 0x16},
{ 0x16, 0x1C, 0x16},
{ 0x16, 0x1C, 0x16},
{ 0x16, 0x1C, 0x18},
{ 0x16, 0x1C, 0x1A},
{ 0x16, 0x1C, 0x1C},
{ 0x16, 0x1A, 0x1C},
{ 0x16, 0x18, 0x1C},
{ 0x16, 0x16, 0x1C},
{ 0x00, 0x00, 0x20},
{ 0x04, 0x00, 0x20},
{ 0x08, 0x00, 0x20},
{ 0x0C, 0x00, 0x20},
{ 0x20, 0x00, 0x20},
{ 0x20, 0x00, 0x0C},
{ 0x20, 0x00, 0x08},
{ 0x20, 0x00, 0x04},
{ 0x20, 0x00, 0x00},
{ 0x20, 0x04, 0x00},
{ 0x20, 0x08, 0x00},
{ 0x20, 0x0C, 0x00},
{ 0x20, 0x20, 0x00},
{ 0x0C, 0x20, 0x00},
{ 0x08, 0x20, 0x00},
{ 0x04, 0x20, 0x00},
{ 0x00, 0x20, 0x00},
{ 0x00, 0x20, 0x04},
{ 0x00, 0x20, 0x08},
{ 0x00, 0x20, 0x0C},
{ 0x00, 0x20, 0x20},
{ 0x00, 0x0C, 0x20},
{ 0x00, 0x08, 0x20},
{ 0x00, 0x04, 0x20},
{ 0x08, 0x08, 0x20},
{ 0x0A, 0x08, 0x20},
{ 0x0C, 0x08, 0x20},
{ 0x0E, 0x08, 0x20},
{ 0x20, 0x08, 0x20},
{ 0x20, 0x08, 0x0E},
{ 0x20, 0x08, 0x0C},
{ 0x20, 0x08, 0x0A},
{ 0x20, 0x08, 0x08},
{ 0x20, 0x0A, 0x08},
{ 0x20, 0x0C, 0x08},
{ 0x20, 0x0E, 0x08},
{ 0x20, 0x20, 0x08},
{ 0x0E, 0x20, 0x08},
{ 0x0C, 0x20, 0x08},
{ 0x0A, 0x20, 0x08},
{ 0x08, 0x20, 0x08},
{ 0x08, 0x20, 0x0A},
{ 0x08, 0x20, 0x0C},
{ 0x08, 0x20, 0x0E},
{ 0x08, 0x20, 0x20},
{ 0x08, 0x0E, 0x20},
{ 0x08, 0x0C, 0x20},
{ 0x08, 0x0A, 0x20},
{ 0x0B, 0x0B, 0x20},
{ 0x0C, 0x0B, 0x20},
{ 0x0D, 0x0B, 0x20},
{ 0x0F, 0x0B, 0x20},
{ 0x20, 0x0B, 0x20},
{ 0x20, 0x0B, 0x0F},
{ 0x20, 0x0B, 0x0D},
{ 0x20, 0x0B, 0x0C},
{ 0x20, 0x0B, 0x0B},
{ 0x20, 0x0C, 0x0B},
{ 0x20, 0x0D, 0x0B},
{ 0x20, 0x0F, 0x0B},
{ 0x20, 0x20, 0x0B},
{ 0x0F, 0x20, 0x0B},
{ 0x0D, 0x20, 0x0B},
{ 0x0C, 0x20, 0x0B},
{ 0x0B, 0x20, 0x0B},
{ 0x0B, 0x20, 0x0C},
{ 0x0B, 0x20, 0x0D},
{ 0x0B, 0x20, 0x0F},
{ 0x0B, 0x20, 0x20},
{ 0x0B, 0x0F, 0x20},
{ 0x0B, 0x0D, 0x20},
{ 0x0B, 0x0C, 0x20},
/* Pad with NULL */
};