From: Vincent Hanquez Date: Wed, 20 May 2009 19:46:54 +0000 (+0100) Subject: push 3.4 in master X-Git-Url: http://xenbits.xensource.com/gitweb?a=commitdiff_plain;h=9b364a75e2c266bf198abef302be33ded19ff56c;p=xenclient%2Fxen-pq.git push 3.4 in master --- diff --git a/master/acpi-slic b/master/acpi-slic new file mode 100644 index 0000000..bcada23 --- /dev/null +++ b/master/acpi-slic @@ -0,0 +1,244 @@ +diff -Nur a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c +--- a/tools/firmware/hvmloader/acpi/build.c 2009-04-01 16:02:46.000000000 -0400 ++++ b/tools/firmware/hvmloader/acpi/build.c 2009-04-01 15:57:01.000000000 -0400 +@@ -59,7 +59,16 @@ + return 1; + } + +-static int construct_madt(struct acpi_20_madt *madt) ++static void pt_update_acpi_tables(struct acpi_header *header, struct hvm_acinfo_table *va_ac) ++{ ++ memcpy(header->oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ memcpy(header->oem_table_id, va_ac->oem_table_id, HVM_ACINFO_OEM_TABLE_ID_SIZE); ++ header->oem_revision = va_ac->oem_revision; ++ header->creator_id = ASCII32(va_ac->creator_id[0],va_ac->creator_id[1],va_ac->creator_id[2],va_ac->creator_id[3]); ++ header->creator_revision = va_ac->creator_revision; ++} ++ ++static int construct_madt(struct acpi_20_madt *madt, struct hvm_acinfo_table *va_ac) + { + struct acpi_20_madt_intsrcovr *intsrcovr; + struct acpi_20_madt_ioapic *io_apic; +@@ -69,7 +78,14 @@ + memset(madt, 0, sizeof(*madt)); + madt->header.signature = ACPI_2_0_MADT_SIGNATURE; + madt->header.revision = ACPI_2_0_MADT_REVISION; +- fixed_strcpy(madt->header.oem_id, ACPI_OEM_ID); ++ if (va_ac == NULL) ++ { ++ fixed_strcpy(madt->header.oem_id, ACPI_OEM_ID); ++ } ++ else ++ { ++ memcpy(madt->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ } + fixed_strcpy(madt->header.oem_table_id, ACPI_OEM_TABLE_ID); + madt->header.oem_revision = ACPI_OEM_REVISION; + madt->header.creator_id = ACPI_CREATOR_ID; +@@ -136,14 +152,21 @@ + return align16(offset); + } + +-static int construct_hpet(struct acpi_20_hpet *hpet) ++static int construct_hpet(struct acpi_20_hpet *hpet, struct hvm_acinfo_table *va_ac) + { + int offset; + + memset(hpet, 0, sizeof(*hpet)); + hpet->header.signature = ACPI_2_0_HPET_SIGNATURE; + hpet->header.revision = ACPI_2_0_HPET_REVISION; +- fixed_strcpy(hpet->header.oem_id, ACPI_OEM_ID); ++ if (va_ac == NULL) ++ { ++ fixed_strcpy(hpet->header.oem_id, ACPI_OEM_ID); ++ } ++ else ++ { ++ memcpy(hpet->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ } + fixed_strcpy(hpet->header.oem_table_id, ACPI_OEM_TABLE_ID); + hpet->header.oem_revision = ACPI_OEM_REVISION; + hpet->header.creator_id = ACPI_CREATOR_ID; +@@ -158,7 +181,7 @@ + return offset; + } + +-static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs) ++static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs, struct hvm_acinfo_table *va_ac) + { + int offset = 0, nr_tables = 0; + struct acpi_20_madt *madt; +@@ -172,7 +195,7 @@ + if ( (hvm_info->nr_vcpus > 1) || hvm_info->apic_mode ) + { + madt = (struct acpi_20_madt *)&buf[offset]; +- offset += construct_madt(madt); ++ offset += construct_madt(madt, va_ac); + table_ptrs[nr_tables++] = (unsigned long)madt; + } + +@@ -180,7 +203,7 @@ + if ( hpet_exists(ACPI_HPET_ADDRESS) ) + { + hpet = (struct acpi_20_hpet *)&buf[offset]; +- offset += construct_hpet(hpet); ++ offset += construct_hpet(hpet, va_ac); + table_ptrs[nr_tables++] = (unsigned long)hpet; + } + +@@ -191,6 +214,14 @@ + offset += align16(sizeof(AmlCode_PM)); + } + ++ /* SLIC */ ++ if (va_ac != NULL) ++ { ++ table_ptrs[nr_tables++] = (unsigned long)&buf[offset]; ++ memcpy(&buf[offset], (uint8_t*)va_ac + sizeof(struct hvm_acinfo_table), va_ac->slic_length); ++ offset += align16(va_ac->slic_length); ++ } ++ + /* TPM TCPA and SSDT. */ + tis_hdr = (uint16_t *)0xFED40F00; + if ( (tis_hdr[0] == tis_signature[0]) && +@@ -209,7 +240,14 @@ + tcpa->header.signature = ACPI_2_0_TCPA_SIGNATURE; + tcpa->header.length = sizeof(*tcpa); + tcpa->header.revision = ACPI_2_0_TCPA_REVISION; +- fixed_strcpy(tcpa->header.oem_id, ACPI_OEM_ID); ++ if (va_ac == NULL) ++ { ++ fixed_strcpy(tcpa->header.oem_id, ACPI_OEM_ID); ++ } ++ else ++ { ++ memcpy(tcpa->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ } + fixed_strcpy(tcpa->header.oem_table_id, ACPI_OEM_TABLE_ID); + tcpa->header.oem_revision = ACPI_OEM_REVISION; + tcpa->header.creator_id = ACPI_CREATOR_ID; +@@ -240,6 +278,21 @@ + unsigned char *dsdt; + unsigned long secondary_tables[16]; + int offset = 0, i; ++ struct hvm_acinfo_table *va_ac; ++ ++ /* ++ * First get the ACPI info structure that may be passed to the HVM loader. This will be used ++ * to pass through platform ACPI information if present. ++ */ ++ va_ac = get_hvm_acinfo_table(); ++ if (va_ac != NULL) ++ { ++ pt_update_acpi_tables(&Rsdt.header, va_ac); ++ pt_update_acpi_tables(&Xsdt.header, va_ac); ++ /* just the OEM ID for the RSDP and FADT */ ++ memcpy(Rsdp.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ memcpy(Fadt.header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); ++ } + + /* + * Fill in high-memory data structures, starting at @buf. +@@ -283,7 +336,7 @@ + offsetof(struct acpi_header, checksum), + sizeof(struct acpi_20_fadt)); + +- offset += construct_secondary_tables(&buf[offset], secondary_tables); ++ offset += construct_secondary_tables(&buf[offset], secondary_tables, va_ac); + + xsdt = (struct acpi_20_xsdt *)&buf[offset]; + memcpy(xsdt, &Xsdt, sizeof(struct acpi_header)); +diff -Nur a/tools/firmware/hvmloader/util.c b/tools/firmware/hvmloader/util.c +--- a/tools/firmware/hvmloader/util.c 2009-04-01 16:02:51.000000000 -0400 ++++ b/tools/firmware/hvmloader/util.c 2009-04-01 15:47:57.000000000 -0400 +@@ -680,6 +680,32 @@ + return table; + } + ++struct hvm_acinfo_table *get_hvm_acinfo_table(void) ++{ ++ static struct hvm_acinfo_table *table = NULL; ++ static int validated = 0; ++ struct hvm_acinfo_table *t; ++ ++ if ( validated ) ++ return table; ++ ++ t = (struct hvm_acinfo_table *)HVM_ACINFO_PADDR; ++ ++ if ( t->slic_length == 0 ) { ++ printf("HVM ACPI info table missing SLIC table?\n"); ++ validated = 1; ++ return table; ++ } ++ ++ if ( validate_hvm_info_table((uint8_t*)t, t->slic_length + sizeof(struct hvm_acinfo_table), t->signature, "AC INFO", 7) ) ++ table = t; ++ else ++ printf("Bad or missing HVM SMBIOS info table\n"); ++ validated = 1; ++ ++ return table; ++} ++ + struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type) + { + struct hvm_smtable_header *header = +diff -Nur a/tools/firmware/hvmloader/util.h b/tools/firmware/hvmloader/util.h +--- a/tools/firmware/hvmloader/util.h 2009-04-01 16:02:51.000000000 -0400 ++++ b/tools/firmware/hvmloader/util.h 2009-04-01 15:48:13.000000000 -0400 +@@ -113,6 +113,7 @@ + + /* HVM-build SMBIOS/ACPI info extensions */ + struct hvm_sminfo_table *get_hvm_sminfo_table(void); ++struct hvm_acinfo_table *get_hvm_acinfo_table(void); + struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type); + + /* String and memory functions */ +diff -Nur a/tools/libxc/xc_dom_x86.c b/tools/libxc/xc_dom_x86.c +--- a/tools/libxc/xc_dom_x86.c 2009-04-01 14:06:29.000000000 -0400 ++++ b/tools/libxc/xc_dom_x86.c 2009-04-01 16:00:48.000000000 -0400 +@@ -17,7 +17,6 @@ + #include + #include + #include +-#include + #include + + #include "xg_private.h" +diff -Nur a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h +--- a/xen/include/public/hvm/hvm_info_table.h 2009-04-01 16:02:51.000000000 -0400 ++++ b/xen/include/public/hvm/hvm_info_table.h 2009-04-01 15:41:59.000000000 -0400 +@@ -32,8 +32,12 @@ + #define HVM_SMINFO_OFFSET 0x0 + #define HVM_SMINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_SMINFO_OFFSET) + #define HVM_SMINFO_MAX 0x800 ++#define HVM_ACINFO_OFFSET 0xC00 ++#define HVM_ACINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_ACINFO_OFFSET) ++#define HVM_ACINFO_MAX 0x400 + + #define HVM_SMINFO_EXTENSIONS 1 ++#define HVM_ACINFO_EXTENSIONS 1 + + struct hvm_info_table { + char signature[8]; /* "HVM INFO" */ +@@ -83,4 +87,19 @@ + uint32_t sm_length; /* beginning after this stucture, includes fixed table, string list, and terminator */ + }; + ++#define HVM_ACINFO_OEM_ID_SIZE 6 ++#define HVM_ACINFO_OEM_TABLE_ID_SIZE 8 ++#define HVM_ACINFO_CREATOR_ID_SIZE 4 ++ ++struct hvm_acinfo_table { ++ char signature[7]; /* "AC INFO" */ ++ uint8_t checksum; ++ uint32_t slic_length; /* length of SLIC following this structure */ ++ char oem_id[HVM_ACINFO_OEM_ID_SIZE]; ++ char oem_table_id[HVM_ACINFO_OEM_TABLE_ID_SIZE]; ++ uint32_t oem_revision; ++ char creator_id[HVM_ACINFO_CREATOR_ID_SIZE]; ++ uint32_t creator_revision; ++}; ++ + #endif /* __XEN_PUBLIC_HVM_HVM_INFO_TABLE_H__ */ diff --git a/master/fix_compilation b/master/fix_compilation new file mode 100644 index 0000000..a634631 --- /dev/null +++ b/master/fix_compilation @@ -0,0 +1,82 @@ +diff --git a/tools/Makefile b/tools/Makefile +index 00e3981..ea26bd9 100644 +--- a/tools/Makefile ++++ b/tools/Makefile +@@ -2,16 +2,16 @@ XEN_ROOT = ../ + include $(XEN_ROOT)/tools/Rules.mk + + SUBDIRS-y := +-SUBDIRS-y += check ++SUBDIRS-n += check + SUBDIRS-y += include + SUBDIRS-y += libxc + SUBDIRS-y += flask + SUBDIRS-y += xenstore +-SUBDIRS-y += misc +-SUBDIRS-y += examples ++SUBDIRS-n += misc ++SUBDIRS-n += examples + SUBDIRS-y += hotplug + SUBDIRS-y += xentrace +-SUBDIRS-$(CONFIG_XCUTILS) += xcutils ++SUBDIRS-n += xcutils + SUBDIRS-$(CONFIG_X86) += firmware + SUBDIRS-$(ACM_SECURITY) += security + SUBDIRS-y += console +@@ -23,15 +23,15 @@ SUBDIRS-$(CONFIG_Linux) += libaio + SUBDIRS-$(CONFIG_Linux) += blktap + SUBDIRS-y += libfsimage + SUBDIRS-$(LIBXENAPI_BINDINGS) += libxen +-SUBDIRS-$(CONFIG_Linux) += fs-back ++SUBDIRS-n += fs-back + SUBDIRS-$(CONFIG_IOEMU) += ioemu-dir + SUBDIRS-y += xenpmd + + # These don't cross-compile +-ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) +-SUBDIRS-$(PYTHON_TOOLS) += python +-SUBDIRS-$(PYTHON_TOOLS) += pygrub +-endif ++#ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) ++#SUBDIRS-$(PYTHON_TOOLS) += python ++#SUBDIRS-$(PYTHON_TOOLS) += pygrub ++#endif + + # For the sake of linking, set the sys-root + ifneq ($(CROSS_COMPILE),) +@@ -54,7 +54,7 @@ install: subdirs-install + clean distclean: subdirs-clean + + ifneq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) +-IOEMU_CONFIGURE_CROSS ?= --cpu=$(XEN_TARGET_ARCH) \ ++IOEMU_CONFIGURE_CROSS ?= --cpu=$(XEN_TARGET_ARCH:x86_32=i386) \ + --cross-prefix=$(CROSS_COMPILE) \ + --interp-prefix=$(CROSS_SYS_ROOT) + endif +@@ -69,26 +69,6 @@ subdir-clean-ioemu: + $(MAKE) -C ioemu distclean + + ioemu-dir-find: +- set -ex; \ +- if test -d $(CONFIG_QEMU); then \ +- rm -f ioemu-dir; \ +- ln -sf $(CONFIG_QEMU) ioemu-dir; \ +- else \ +- if [ ! -d ioemu-remote ]; then \ +- rm -rf ioemu-remote ioemu-remote.tmp; \ +- mkdir ioemu-remote.tmp; rmdir ioemu-remote.tmp; \ +- $(GIT) clone $(CONFIG_QEMU) ioemu-remote.tmp; \ +- if [ "$(QEMU_TAG)" ]; then \ +- cd ioemu-remote.tmp; \ +- $(GIT) branch -D dummy >/dev/null 2>&1 ||:; \ +- $(GIT) checkout -b dummy $(QEMU_TAG); \ +- cd ..; \ +- fi; \ +- mv ioemu-remote.tmp ioemu-remote; \ +- fi; \ +- rm -f ioemu-dir; \ +- ln -sf ioemu-remote ioemu-dir; \ +- fi + set -e; \ + $(absolutify_xen_root); \ + cd ioemu-dir; \ diff --git a/master/init-vgabios-and-set-size b/master/init-vgabios-and-set-size new file mode 100644 index 0000000..bde9d6d --- /dev/null +++ b/master/init-vgabios-and-set-size @@ -0,0 +1,91 @@ +diff --git a/tools/firmware/hvmloader/hvmloader.c b/tools/firmware/hvmloader/hvmloader.c +index 39aa949..12ac806 100644 +--- a/tools/firmware/hvmloader/hvmloader.c ++++ b/tools/firmware/hvmloader/hvmloader.c +@@ -672,6 +672,7 @@ int main(void) + break; + default: + printf("No emulated VGA adaptor ...\n"); ++ vgabios_sz = round_option_rom((*(uint8_t *)(VGABIOS_PHYSICAL_ADDRESS+2)) * 512); + break; + } + +diff --git a/tools/libxc/xc_hvm_build.c b/tools/libxc/xc_hvm_build.c +index 0ba8c44..787f4ec 100644 +--- a/tools/libxc/xc_hvm_build.c ++++ b/tools/libxc/xc_hvm_build.c +@@ -66,14 +66,35 @@ static void build_hvm_info(void *hvm_info_page, uint64_t mem_size) + hvm_info->checksum = -sum; + } + ++static int init_vgabios(int xc_handle, uint32_t dom, unsigned char *buffer, uint32_t bios_size) ++{ ++ char *va_bios = NULL; ++ uint32_t va_size = 0; ++ ++ va_size = bios_size + bios_size % XC_PAGE_SIZE; ++ va_bios = xc_map_foreign_range(xc_handle, dom, va_size, ++ PROT_READ | PROT_WRITE, 0xC0); ++ if ( !va_bios ) ++ { ++ IPRINTF("Unable to map vga bios!\n"); ++ return -1; ++ } ++ ++ if ( buffer != NULL ) ++ memcpy(va_bios, buffer, bios_size); ++ else ++ memset(va_bios, 0, bios_size); ++ ++ munmap(va_bios, va_size); ++ return 0; ++} ++ + static int setup_vga_pt(int xc_handle, + uint32_t dom) + { + int rc = 0; + unsigned char *bios = NULL; + int bios_size = 0; +- char *va_bios = NULL; +- uint32_t va_size = 0; + char *c = NULL; + char checksum = 0; + +@@ -87,16 +108,9 @@ static int setup_vga_pt(int xc_handle, + bios_size = 0; + #endif /* __linux__ */ + +- va_size = bios_size + bios_size % XC_PAGE_SIZE; + if (bios_size == 0) + { +- rc = -1; +- goto error; +- } +- va_bios = xc_map_foreign_range(xc_handle, dom, va_size, +- PROT_READ | PROT_WRITE, 0xC0); +- if (!va_bios) +- { ++ IPRINTF("vga bios size is 0!\n"); + rc = -1; + goto error; + } +@@ -107,8 +121,7 @@ static int setup_vga_pt(int xc_handle, + if (checksum) + bios[bios_size - 1] -= checksum; + +- memcpy(va_bios, bios, bios_size); +- munmap(va_bios, va_size); ++ init_vgabios(xc_handle, dom, bios, bios_size); + error: + free(bios); + return rc; +@@ -416,6 +429,8 @@ int xc_hvm_build(int xc_handle, + sts = xc_hvm_build_internal(xc_handle, domid, memsize, memsize, image, image_size); + if ( vga_pt_enabled ) + sts |= setup_vga_pt(xc_handle, domid); ++ else ++ sts |= init_vgabios(xc_handle, domid, NULL, 0x800); + + free(image); + diff --git a/master/mfn-validity-check-before-shadow-remove b/master/mfn-validity-check-before-shadow-remove new file mode 100644 index 0000000..cb75b6e --- /dev/null +++ b/master/mfn-validity-check-before-shadow-remove @@ -0,0 +1,18 @@ +diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c +index ca4cb13..71bfe27 100644 +--- a/xen/arch/x86/mm/shadow/common.c ++++ b/xen/arch/x86/mm/shadow/common.c +@@ -2730,6 +2730,13 @@ void sh_remove_shadows(struct vcpu *v, mfn_t gmfn, int fast, int all) + + ASSERT(!(all && fast)); + ++ if ( unlikely(!mfn_valid(gmfn)) ) ++ { ++ /* Get out now if we're trying to remove shadows of a MMIO ++ * direct page. */ ++ return; ++ } ++ + /* Although this is an externally visible function, we do not know + * whether the shadow lock will be held when it is called (since it + * can be called via put_page_type when we clear a shadow l1e). diff --git a/master/module-reloc b/master/module-reloc new file mode 100644 index 0000000..3363aaa --- /dev/null +++ b/master/module-reloc @@ -0,0 +1,52 @@ +diff --git a/xen/arch/x86/setup.c b/xen/arch/x86/setup.c +index 8cf4190..6960ebb 100644 +--- a/xen/arch/x86/setup.c ++++ b/xen/arch/x86/setup.c +@@ -419,7 +419,7 @@ void __init __start_xen(unsigned long mbi_p) + multiboot_info_t *mbi = __va(mbi_p); + module_t *mod = (module_t *)__va(mbi->mods_addr); + unsigned long nr_pages, modules_length, modules_headroom; +- int i, e820_warn = 0, bytes = 0; ++ int i, j, e820_warn = 0, bytes = 0; + struct ns16550_defaults ns16550 = { + .data_bits = 8, + .parity = 'n', +@@ -616,7 +616,9 @@ void __init __start_xen(unsigned long mbi_p) + * we can relocate the dom0 kernel and other multiboot modules. Also, on + * x86/64, we relocate Xen to higher memory. + */ +- modules_length = mod[mbi->mods_count-1].mod_end - mod[0].mod_start; ++ modules_length = 0; ++ for ( i = 0; i < mbi->mods_count; i++ ) ++ modules_length += mod[i].mod_end - mod[i].mod_start; + + /* ensure mod[0] is mapped before parsing */ + bootstrap_map(mod[0].mod_start, mod[0].mod_end); +@@ -737,8 +739,15 @@ void __init __start_xen(unsigned long mbi_p) + initial_images_start = e; + e -= modules_headroom; + initial_images_base = e; +- move_memory(initial_images_start, +- mod[0].mod_start, mod[mbi->mods_count-1].mod_end); ++ e += modules_length + modules_headroom; ++ for ( j = mbi->mods_count-1; j >= 0; j-- ) ++ { ++ e -= mod[j].mod_end - mod[j].mod_start; ++ move_memory(e, mod[j].mod_start, mod[j].mod_end); ++ mod[j].mod_end += e - mod[j].mod_start; ++ mod[j].mod_start = e; ++ } ++ + } + + if ( !kexec_crash_area.start && (s < e) && +@@ -1032,8 +1041,7 @@ void __init __start_xen(unsigned long mbi_p) + + if ( (initrdidx > 0) && (initrdidx < mbi->mods_count) ) + { +- _initrd_start = initial_images_start + +- (mod[initrdidx].mod_start - mod[0].mod_start); ++ _initrd_start = mod[initrdidx].mod_start; + _initrd_len = mod[initrdidx].mod_end - mod[initrdidx].mod_start; + } + diff --git a/master/mtrr-changes b/master/mtrr-changes new file mode 100644 index 0000000..9e936e8 --- /dev/null +++ b/master/mtrr-changes @@ -0,0 +1,15 @@ +diff --git a/tools/firmware/hvmloader/cacheattr.c b/tools/firmware/hvmloader/cacheattr.c +index ae23b3e..9ae7ce8 100644 +--- a/tools/firmware/hvmloader/cacheattr.c ++++ b/tools/firmware/hvmloader/cacheattr.c +@@ -72,9 +72,7 @@ void cacheattr_init(void) + content = 0x0606060606060606ull; + wrmsr(MSR_MTRRfix64K_00000, content); + wrmsr(MSR_MTRRfix16K_80000, content); +- /* 0xa0000-0xbffff: Write Combining (WC) */ +- if ( mtrr_cap & (1u << 10) ) /* WC supported? */ +- content = 0x0101010101010101ull; ++ content = 0x0000000000000000ull; + wrmsr(MSR_MTRRfix16K_A0000, content); + /* 0xc0000-0xfffff: Write Back (WB) */ + content = 0x0606060606060606ull; diff --git a/master/oem-features b/master/oem-features new file mode 100644 index 0000000..1c54752 --- /dev/null +++ b/master/oem-features @@ -0,0 +1,2670 @@ +diff -Nur a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c +--- a/tools/firmware/hvmloader/acpi/build.c 2009-04-01 16:31:10.000000000 -0400 ++++ b/tools/firmware/hvmloader/acpi/build.c 2009-04-01 17:04:59.000000000 -0400 +@@ -19,8 +19,12 @@ + #include "acpi2_0.h" + #include "ssdt_tpm.h" + #include "ssdt_pm.h" ++#include "ssdt_hp_6930p_elitebook.h" ++#include "ssdt_dell_latitude_eseries.h" ++#include "ssdt_lenovo_t_and_x_series.h" + #include "../config.h" + #include "../util.h" ++#include "../smbios_types.h" + + #define align16(sz) (((sz) + 15) & ~15) + #define fixed_strcpy(d, s) strncpy((d), (s), sizeof(d)) +@@ -33,6 +37,16 @@ + extern unsigned char AmlCode[]; + extern int DsdtLen; + ++#define OEM_NAME_DELL "Dell" ++#define OEM_NAME_HP "Hewlett-Packard" ++#define OEM_NAME_LENOVO "LENOVO" ++ ++#define OEM_MODEL_DELL_LATITUDE_1 "Latitude E4200" ++#define OEM_MODEL_DELL_LATITUDE_2 "Latitude E6500" ++#define OEM_MODEL_HP_EliteBook "HP EliteBook 6930p" ++#define OEM_MODEL_LENOVO_T400 "6475BY3" ++#define OEM_MODEL_LENOVO_X200 "74542NU" ++ + static void set_checksum( + void *table, uint32_t checksum_offset, uint32_t length) + { +@@ -59,6 +73,12 @@ + return 1; + } + ++static uint8_t oem_value_add_exists(void) ++{ ++ outb(0x96, 100); ++ return (inb(0x96) == 100); ++} ++ + static void pt_update_acpi_tables(struct acpi_header *header, struct hvm_acinfo_table *va_ac) + { + memcpy(header->oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); +@@ -68,6 +88,59 @@ + header->creator_revision = va_ac->creator_revision; + } + ++static int construct_oem_ssdt(uint8_t *buf) ++{ ++ struct smbios_type_1 *type1_info; ++ char *manufacturer, *model; ++ struct hvm_sminfo_table *pa_sm; ++ struct hvm_smtable_header *header; ++ ++ pa_sm = get_hvm_sminfo_table(); ++ if ( pa_sm == NULL ) ++ return 0; ++ ++ header = (struct hvm_smtable_header *)get_sminfo_by_type(pa_sm, 1); ++ if ( header == NULL ) ++ return 0; ++ if ( header->sm_length < sizeof(struct smbios_type_1) ) ++ return 0; ++ ++ type1_info = (struct smbios_type_1 *)((char *)header + sizeof(struct hvm_smtable_header)); ++ manufacturer = (char *)type1_info + type1_info->header.length; ++ model = manufacturer + strlen(manufacturer) + 1; ++ ++ if ( strncmp(manufacturer, OEM_NAME_DELL, strlen(OEM_NAME_DELL)) == 0 ) ++ { ++ if ( (strncmp(model, OEM_MODEL_DELL_LATITUDE_1, strlen(OEM_MODEL_DELL_LATITUDE_1)) != 0) && ++ (strncmp(model, OEM_MODEL_DELL_LATITUDE_2, strlen(OEM_MODEL_DELL_LATITUDE_2)) != 0) ) ++ return 0; ++ ++ memcpy(buf, AmlCode_DELL_LATITUDE_ESERIES, sizeof(AmlCode_DELL_LATITUDE_ESERIES)); ++ return align16(sizeof(AmlCode_DELL_LATITUDE_ESERIES)); ++ } ++ ++ if ( strncmp(manufacturer, OEM_NAME_HP, strlen(OEM_NAME_HP)) == 0 ) ++ { ++ if ( strncmp(model, OEM_MODEL_HP_EliteBook, strlen(OEM_MODEL_HP_EliteBook)) != 0 ) ++ return 0; ++ ++ memcpy(buf, AmlCode_HP_6930P_ELITEBOOK, sizeof(AmlCode_HP_6930P_ELITEBOOK)); ++ return align16(sizeof(AmlCode_HP_6930P_ELITEBOOK)); ++ } ++ ++ if ( strncmp(manufacturer, OEM_NAME_LENOVO, strlen(OEM_NAME_LENOVO)) == 0 ) ++ { ++ if ( (strncmp(model, OEM_MODEL_LENOVO_T400, strlen(OEM_MODEL_LENOVO_T400)) != 0) && ++ (strncmp(model, OEM_MODEL_LENOVO_X200, strlen(OEM_MODEL_LENOVO_X200)) != 0) ) ++ return 0; ++ ++ memcpy(buf, AmlCode_LENOVO_T_AND_X_SERIES, sizeof(AmlCode_LENOVO_T_AND_X_SERIES)); ++ return align16(sizeof(AmlCode_LENOVO_T_AND_X_SERIES)); ++ } ++ ++ return 0; ++} ++ + static int construct_madt(struct acpi_20_madt *madt, struct hvm_acinfo_table *va_ac) + { + struct acpi_20_madt_intsrcovr *intsrcovr; +@@ -183,12 +256,13 @@ + + static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs, struct hvm_acinfo_table *va_ac) + { +- int offset = 0, nr_tables = 0; ++ int offset = 0, nr_tables = 0, oem_ssdt_offset = 0; + struct acpi_20_madt *madt; + struct acpi_20_hpet *hpet; + struct acpi_20_tcpa *tcpa; + static const uint16_t tis_signature[] = {0x0001, 0x0001, 0x0001}; + uint16_t *tis_hdr; ++ uint8_t *oem_ssdt; + void *lasa; + + /* MADT. */ +@@ -222,6 +296,17 @@ + offset += align16(va_ac->slic_length); + } + ++ if ( oem_value_add_exists() ) ++ { ++ oem_ssdt = &buf[offset]; ++ oem_ssdt_offset = construct_oem_ssdt(oem_ssdt); ++ if ( oem_ssdt_offset != 0 ) ++ { ++ offset += oem_ssdt_offset; ++ table_ptrs[nr_tables++] = (unsigned long)oem_ssdt; ++ } ++ } ++ + /* TPM TCPA and SSDT. */ + tis_hdr = (uint16_t *)0xFED40F00; + if ( (tis_hdr[0] == tis_signature[0]) && +diff -Nur a/tools/firmware/hvmloader/acpi/Makefile b/tools/firmware/hvmloader/acpi/Makefile +--- a/tools/firmware/hvmloader/acpi/Makefile 2009-04-01 16:30:52.000000000 -0400 ++++ b/tools/firmware/hvmloader/acpi/Makefile 2009-04-01 16:36:38.000000000 -0400 +@@ -19,7 +19,7 @@ + include $(XEN_ROOT)/tools/firmware/Rules.mk + + C_SRC = build.c dsdt.c static_tables.c +-H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_tpm.h ++H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_hp_6930p_elitebook.h ssdt_dell_latitude_eseries.h ssdt_lenovo_t_and_x_series.h ssdt_tpm.h + OBJS = $(patsubst %.c,%.o,$(C_SRC)) + + build.o: $(H_SRC) build.c +@@ -39,6 +39,27 @@ + mv $*.hex $@ + rm -f *.aml + ++ssdt_hp_6930p_elitebook.h: ssdt_hp_6930p_elitebook.asl ++ $(MAKE) iasl ++ iasl -tc $< ++ sed -i'' -re 's/AmlCode/AmlCode_HP_6930P_ELITEBOOK/g' $*.hex ++ mv $*.hex $@ ++ rm -f *.aml ++ ++ssdt_dell_latitude_eseries.h: ssdt_dell_latitude_eseries.asl ++ $(MAKE) iasl ++ iasl -tc $< ++ sed -i'' -re 's/AmlCode/AmlCode_DELL_LATITUDE_ESERIES/g' $*.hex ++ mv $*.hex $@ ++ rm -f *.aml ++ ++ssdt_lenovo_t_and_x_series.h: ssdt_lenovo_t_and_x_series.asl ++ $(MAKE) iasl ++ iasl -tc $< ++ sed -i'' -re 's/AmlCode/AmlCode_LENOVO_T_AND_X_SERIES/g' $*.hex ++ mv $*.hex $@ ++ rm -f *.aml ++ + ssdt_tpm.h: ssdt_tpm.asl + $(MAKE) iasl + iasl -tc $< +diff +--- /dev/null ++++ b/tools/firmware/hvmloader/acpi/ssdt_dell_latitude_eseries.asl 2009-04-01 16:35:13.000000000 -0400 +@@ -0,0 +1,516 @@ ++/* ++ * ssdt_dell_latitude_eseries.asl ++ * ++ * Copyright (c) 2009 Kamala Narasimhan ++ * Copyright (c) 2009 Citrix Systems, Inc. ++ * ++ * 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 ++ */ ++ ++/* SSDT for exposing Dell latitude eseries specific value add functionalities like ++ * hotkeys, special buttons. ++ */ ++ ++/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through ++ * WMI psuedo device objects. For our guests to benefit from such value add, we ++ * expose a psuedo device object in our vACPI layer also. This psuedo object is ++ * similar to the underlying base firmware object in the sense we expose the ++ * same _WDG method which describes the WMI methods, data objects and events ++ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically ++ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get ++ * known entry points and calls those entry points for further information exchange. ++ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ */ ++ ++/* COMMUNICATION DETAILS - ++ * Command port - 0x96 ++ * Writes to this port describe what type of information is about ++ * to be exchanged. E.g., guid, input argument transfer etc. ++ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. ++ * Communicates data to and from the backend. E.g. Input buffer values ++ * get written to this port and output buffer values are read from this ++ * port. ++ */ ++ ++DefinitionBlock ("SSDT_DELL_LATITUDE_ESERIES.aml", "SSDT", 2, "Xen", "HVM", 0) ++{ ++ Scope (\_SB) ++ { ++ ++ OperationRegion (LAT1, SystemIO, 0x96, 0x01) ++ Field (LAT1, ByteAcc, NoLock, Preserve) ++ { ++ P96, 8 ++ } ++ ++ OperationRegion (LAT2, SystemIO, 0x98, 0x01) ++ Field (LAT2, ByteAcc, NoLock, Preserve) ++ { ++ P98, 8 ++ } ++ ++ OperationRegion (LAT3, SystemIO, 0x9A, 0x04) ++ Field (LAT3, DWordAcc, NoLock, Preserve) ++ { ++ P9A, 32 ++ } ++ ++ Device (AMW0) ++ { ++ /* Exposing a pseudo device with HID PNP0C14 will ++ * result in Windows guest loading their WMI wrapper ++ * driver - wmiacpi.sys ++ */ ++ Name (_HID, EisaId ("PNP0C14")) ++ Name (_UID, 0x00) ++ ++ /* Following list of data blocks exposed by _WDG is same as the ++ * one provided by the underlying firmware. Refer to - ++ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ * for further information about _WDG and what it exposes. ++ */ ++ Name (_WDG, Buffer (0x78) ++ { ++ /* Data Block 1 */ ++ /* GUID */ ++ 0xBC, 0xDC, 0x9D, 0x8D, 0x97, 0xA9, 0xDA, 0x11, ++ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, ++ 0x41, 0x41, /* Object ID - WQAA */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 2 */ ++ /* GUID */ ++ 0xCE, 0x93, 0x05, 0xA8, 0x97, 0xA9, 0xDA, 0x11, ++ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, ++ 0x42, 0x41, /*Object ID - WMBA */ ++ 0x01, /* Instance count */ ++ 0x02, /* Flag - Method */ ++ ++ /* Data Block 3 */ ++ /* GUID */ ++ 0x94, 0x59, 0xBB, 0x9D, 0x97, 0xA9, 0xDA, 0x11, ++ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, ++ 0xD0, 0x00, /* Event notification ID */ ++ 0x01, /* Instance count */ ++ 0x08, /* Flag - Event */ ++ ++ /* Data Block 4 */ ++ /* GUID */ ++ 0xE0, 0x6C, 0x77, 0xA3, 0x88, 0x1E, 0xDB, 0x11, ++ 0xA9, 0x8B, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66, ++ 0x42, 0x43, /* Object ID - WQBC */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 5 */ ++ /* GUID */ ++ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, ++ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, ++ 0x4D, 0x4F, /* Object ID - WQMO */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Method */ ++ ++ /* Data Block 6 */ ++ /* GUID */ ++ 0x28, 0x07, 0xBD, 0x77, 0x34, 0x2E, 0x8C, 0x47, ++ 0xB6, 0x25, 0x67, 0xF0, 0x2A, 0x7E, 0x48, 0x97, ++ 0x42, 0x44, /* Object ID - WMBD */ ++ 0x01, /* Instance count */ ++ 0x02, /* Flag - Method */ ++ ++ }) ++ ++ /* Initialize cmd port and communicate invocation type ++ * i.e., method execution or query or set object ++ */ ++ Method (INIT, 1, Serialized) ++ { ++ Store (100, P96) ++ Store (Arg0, P98) ++ } ++ ++ /* Pass the guid pertaining to the operation */ ++ Method (GUID, 1, Serialized) ++ { ++ Store (101, P96) ++ Store (0x0, Local0) ++ Store (Arg0, Local1) ++ ++ While ( LLess(Local0,16) ) ++ { ++ Add(Local1, Local0, Local2) ++ Store (DerefOf(Index (_WDG, Local2)), P98 ) ++ Increment( Local0 ) ++ } ++ } ++ ++ /* Pass instance # for the associated object pertaining ++ * to the invocation. ++ */ ++ Method (INST, 1, Serialized) ++ { ++ Store(102, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass method id relevant to the method about to be ++ * executed. ++ */ ++ Method (MTID, 1, Serialized) ++ { ++ Store(103, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass input buffer pertaining to the current operation */ ++ Method (IBUF, 1, Serialized) ++ { ++ Store (105, P96) ++ Store (SizeOf(Arg0), Local0) ++ Store (Local0, P9A) ++ ToBuffer (Arg0, Local1) ++ Store (0, Local2) ++ Store (104, P96) ++ While ( LLess(Local2,Local0) ) ++ { ++ Store (DerefOf(Index (Local1, Local2)), P98) ++ Increment (Local2) ++ } ++ } ++ ++ /* Now that the input arguments are passed, execute the command */ ++ Method (EXEC, 0, Serialized) ++ { ++ Store (106, P96) ++ } ++ ++ /* Get the output buffer pertaining to the just executed command */ ++ Method (OBUF, 0, Serialized) ++ { ++ Store (108, P96) ++ Store (P9A, Local0) ++ Store (Buffer(Local0) {}, Local2) ++ Store (0, Local1) ++ Store (107, P96) ++ While ( LLess(Local1, Local0) ) ++ { ++ Store (P98, Index(Local2, Local1)) ++ Increment (Local1) ++ } ++ Return (Local2) ++ } ++ ++ /* Get event data */ ++ Method (_WED, 1, Serialized) ++ { ++ INIT (4) ++ Store (109, P96) ++ Store (Arg0, P98) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Following are well know entry points as supplied by ++ * _WDG. ++ * @TODO: Though current testing suggest that defining ++ * a method for seralized execution is enough to prevent ++ * synchronization issues, consider using explicit mutexes ++ * for further protection. ++ */ ++ Method (WQAA, 1, Serialized) ++ { ++ INIT (2) ++ GUID (0) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMBA, 3, Serialized) ++ { ++ INIT (1) ++ GUID (20) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBC, 1, Serialized) ++ { ++ INIT (2) ++ GUID (60) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Like all other well know entry points, we could delegate ++ * the below to the base firmware also. But, why ask for a ++ * static list (that too this big) and go through layer after ++ * layer to get it? Also, port i/o is not a good idea for this ++ * much data transfer. Luckily, this is the only place that appear ++ * to transfer so much data. ++ */ ++ Name (WQMO, Buffer (0x06CD) ++ { ++ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, ++ /* 0008 */ 0xBD, 0x06, 0x00, 0x00, 0x66, 0x23, 0x00, 0x00, ++ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, ++ /* 0018 */ 0x98, 0x40, 0x91, 0x00, 0x01, 0x06, 0x18, 0x42, ++ /* 0020 */ 0x10, 0x11, 0x10, 0x22, 0x21, 0x30, 0x34, 0x32, ++ /* 0028 */ 0x0B, 0x03, 0x63, 0x04, 0x8A, 0x0B, 0x21, 0x07, ++ /* 0030 */ 0x10, 0x12, 0x07, 0x85, 0x12, 0x02, 0xA1, 0xFE, ++ /* 0038 */ 0x04, 0xF2, 0x2B, 0x00, 0xA1, 0x43, 0x01, 0x32, ++ /* 0040 */ 0x05, 0x18, 0x14, 0xE0, 0x14, 0x41, 0x04, 0xBD, ++ /* 0048 */ 0x0A, 0xB0, 0x29, 0xC0, 0xA4, 0x00, 0x8B, 0x02, ++ /* 0050 */ 0xB4, 0x0B, 0xB0, 0x2C, 0x40, 0xB7, 0x00, 0xE9, ++ /* 0058 */ 0xB0, 0x44, 0x24, 0x38, 0x4A, 0x0C, 0x38, 0x4A, ++ /* 0060 */ 0x27, 0xB6, 0x70, 0xC3, 0x06, 0x2F, 0x14, 0x45, ++ /* 0068 */ 0x33, 0x88, 0x92, 0xA0, 0x72, 0x01, 0xBE, 0x11, ++ /* 0070 */ 0x04, 0x5E, 0xAE, 0x00, 0xC9, 0x13, 0x90, 0x66, ++ /* 0078 */ 0x01, 0x86, 0x05, 0x58, 0x17, 0x20, 0x7B, 0x08, ++ /* 0080 */ 0x54, 0xEA, 0x10, 0x50, 0x72, 0x86, 0x80, 0x1A, ++ /* 0088 */ 0x40, 0xAB, 0x13, 0x10, 0x7E, 0xA5, 0x53, 0x42, ++ /* 0090 */ 0x12, 0x84, 0x33, 0x56, 0xF1, 0xF8, 0x9A, 0x45, ++ /* 0098 */ 0xD3, 0x73, 0x92, 0x73, 0x0C, 0x39, 0x1E, 0x17, ++ /* 00A0 */ 0x7A, 0x10, 0x3C, 0x90, 0x02, 0x10, 0x16, 0x1E, ++ /* 00A8 */ 0x42, 0x11, 0x60, 0x50, 0x12, 0xC6, 0x42, 0x5D, ++ /* 00B0 */ 0x8C, 0x1A, 0x35, 0x52, 0x36, 0x20, 0x43, 0x94, ++ /* 00B8 */ 0x36, 0x6A, 0xF4, 0x80, 0xCE, 0xEF, 0x48, 0xCE, ++ /* 00C0 */ 0xEE, 0xE8, 0x8E, 0x24, 0x81, 0x51, 0x8F, 0xE9, ++ /* 00C8 */ 0x18, 0x0B, 0x9B, 0x91, 0x50, 0x63, 0x34, 0x07, ++ /* 00D0 */ 0x45, 0xA0, 0x71, 0x83, 0xB6, 0x44, 0x58, 0x8D, ++ /* 00D8 */ 0x2B, 0xF6, 0x99, 0x59, 0xF8, 0xB0, 0x84, 0x71, ++ /* 00E0 */ 0x04, 0x07, 0x96, 0xA0, 0x51, 0x34, 0xCD, 0xF1, ++ /* 00E8 */ 0x6C, 0x43, 0x24, 0x38, 0x88, 0xD0, 0x18, 0x19, ++ /* 00F0 */ 0x10, 0xF2, 0x3C, 0x6C, 0x81, 0x1E, 0x79, 0x02, ++ /* 00F8 */ 0xBB, 0x47, 0x94, 0x42, 0x04, 0xCD, 0xF7, 0x44, ++ /* 0100 */ 0x6A, 0x14, 0xA0, 0x0D, 0x43, 0xB6, 0xCE, 0x06, ++ /* 0108 */ 0x1A, 0x6A, 0xAC, 0xC6, 0x50, 0x04, 0x11, 0x21, ++ /* 0110 */ 0x68, 0x14, 0x83, 0x45, 0x08, 0x15, 0xE2, 0xFF, ++ /* 0118 */ 0x1F, 0x25, 0xEA, 0x29, 0x05, 0x89, 0x5A, 0x19, ++ /* 0120 */ 0x88, 0xD0, 0x82, 0x19, 0x81, 0xD9, 0x1F, 0x04, ++ /* 0128 */ 0x89, 0x71, 0x66, 0xD0, 0x61, 0xC1, 0x32, 0x40, ++ /* 0130 */ 0x64, 0x44, 0xD0, 0x68, 0xD8, 0x59, 0xC0, 0xC3, ++ /* 0138 */ 0xF1, 0x4C, 0x9A, 0x9F, 0x98, 0x06, 0x67, 0x82, ++ /* 0140 */ 0xB1, 0x21, 0xA4, 0x01, 0x42, 0xA2, 0x0E, 0x0E, ++ /* 0148 */ 0x94, 0xC0, 0x52, 0x06, 0x4E, 0x6C, 0x8F, 0x4B, ++ /* 0150 */ 0xE3, 0x3B, 0xE3, 0xA8, 0x21, 0x4E, 0xFD, 0xCC, ++ /* 0158 */ 0xFC, 0x8F, 0xF0, 0x16, 0x7C, 0x04, 0xE0, 0x63, ++ /* 0160 */ 0xF0, 0x60, 0x0F, 0x21, 0xE0, 0x11, 0xB2, 0x33, ++ /* 0168 */ 0x80, 0x01, 0xF1, 0xDE, 0x27, 0x4D, 0xE6, 0xE2, ++ /* 0170 */ 0xB3, 0x00, 0x8C, 0xE1, 0xC3, 0x35, 0x3E, 0x0A, ++ /* 0178 */ 0x8D, 0x87, 0x9D, 0x0F, 0xD8, 0xB8, 0x38, 0xBC, ++ /* 0180 */ 0x0F, 0x05, 0x27, 0x5C, 0x2C, 0x88, 0x02, 0x40, ++ /* 0188 */ 0x48, 0xD6, 0xF9, 0x00, 0x3D, 0xEB, 0x63, 0x0B, ++ /* 0190 */ 0xF8, 0x30, 0xD0, 0xEC, 0x1D, 0x82, 0x10, 0xBC, ++ /* 0198 */ 0x08, 0xF8, 0xE8, 0xE0, 0xE3, 0x86, 0xC7, 0xFD, ++ /* 01A0 */ 0xBC, 0x01, 0x86, 0xC3, 0x81, 0x87, 0xE3, 0xD3, ++ /* 01A8 */ 0x06, 0x70, 0x19, 0x01, 0x97, 0xF6, 0xA4, 0x30, ++ /* 01B0 */ 0x81, 0x24, 0x3F, 0x01, 0x24, 0x06, 0x06, 0x75, ++ /* 01B8 */ 0x20, 0xF0, 0xC1, 0x02, 0xAE, 0x24, 0x38, 0xD4, ++ /* 01C0 */ 0xF0, 0x3C, 0xB1, 0x07, 0x84, 0xFF, 0xFF, 0x51, ++ /* 01C8 */ 0x9E, 0xC8, 0x8B, 0x81, 0xA7, 0xFF, 0x18, 0x00, ++ /* 01D0 */ 0xE3, 0x80, 0xE0, 0x69, 0x9D, 0x94, 0x6F, 0x1E, ++ /* 01D8 */ 0x0F, 0x12, 0x1E, 0x54, 0x98, 0x04, 0x3E, 0x25, ++ /* 01E0 */ 0x30, 0x34, 0x7E, 0xDC, 0x00, 0xEB, 0xA8, 0xF1, ++ /* 01E8 */ 0x07, 0x04, 0x78, 0x27, 0x89, 0xF3, 0xEB, 0x73, ++ /* 01F0 */ 0x00, 0x3A, 0x34, 0x9C, 0x22, 0x03, 0x79, 0x0D, ++ /* 01F8 */ 0x38, 0xE9, 0x53, 0xF2, 0xF8, 0x12, 0xF8, 0xCC, ++ /* 0200 */ 0x01, 0xFB, 0x6E, 0x70, 0x18, 0x07, 0x13, 0x22, ++ /* 0208 */ 0xC2, 0x7B, 0xC0, 0x53, 0x87, 0xEF, 0x1A, 0x8F, ++ /* 0210 */ 0x02, 0x81, 0x22, 0xF4, 0x76, 0xE6, 0xA0, 0xA7, ++ /* 0218 */ 0x10, 0xA3, 0x44, 0x3B, 0xAB, 0x30, 0x0F, 0x1C, ++ /* 0220 */ 0x51, 0x7C, 0xE4, 0x30, 0xC2, 0xBB, 0x87, 0xEF, ++ /* 0228 */ 0x04, 0x0F, 0x20, 0xAD, 0x4D, 0x4E, 0xB8, 0x81, ++ /* 0230 */ 0x9E, 0x39, 0x58, 0xB4, 0x33, 0x8B, 0x2C, 0x80, ++ /* 0238 */ 0x28, 0xD2, 0x68, 0x50, 0x67, 0x04, 0x9F, 0x06, ++ /* 0240 */ 0x3C, 0xAD, 0xA7, 0x18, 0x1F, 0x25, 0x0C, 0x72, ++ /* 0248 */ 0x86, 0x07, 0xF6, 0x9C, 0xF0, 0x18, 0xE0, 0x01, ++ /* 0250 */ 0xB3, 0xFB, 0x81, 0x8F, 0x13, 0x3E, 0x17, 0xE0, ++ /* 0258 */ 0x5D, 0x03, 0x6A, 0x86, 0x3E, 0x6C, 0xC0, 0x39, ++ /* 0260 */ 0x74, 0xE0, 0x4F, 0x13, 0xF8, 0x83, 0x05, 0x7E, ++ /* 0268 */ 0x3C, 0xBE, 0xE6, 0xB0, 0x09, 0x27, 0xB0, 0xFC, ++ /* 0270 */ 0x41, 0xA0, 0x46, 0x66, 0x68, 0xCF, 0xF2, 0xB4, ++ /* 0278 */ 0x5E, 0x03, 0x7C, 0xDA, 0x31, 0x81, 0xCF, 0x1B, ++ /* 0280 */ 0xFE, 0xFF, 0xFF, 0x73, 0x3C, 0x1E, 0xF0, 0x2B, ++ /* 0288 */ 0x3E, 0x5D, 0x90, 0xBB, 0x82, 0xE7, 0xEB, 0xB3, ++ /* 0290 */ 0x0B, 0xB3, 0x31, 0x1E, 0xD4, 0x28, 0x7C, 0xC0, ++ /* 0298 */ 0xC1, 0x9D, 0x5D, 0x7C, 0x04, 0xF0, 0xD9, 0x05, ++ /* 02A0 */ 0x78, 0x4E, 0xE2, 0x59, 0x02, 0xBC, 0x87, 0x00, ++ /* 02A8 */ 0x9F, 0x48, 0xE2, 0x3D, 0x6C, 0xC1, 0x18, 0x31, ++ /* 02B0 */ 0x1E, 0xF2, 0x8C, 0xAB, 0x1E, 0x86, 0x2E, 0x02, ++ /* 02B8 */ 0x56, 0x77, 0x5F, 0x41, 0x1D, 0xBD, 0xC0, 0x04, ++ /* 02C0 */ 0xF5, 0x9A, 0x81, 0x3B, 0xBD, 0x00, 0x9F, 0x53, ++ /* 02C8 */ 0x16, 0xBC, 0xFF, 0xFF, 0x29, 0x0B, 0xB8, 0x5F, ++ /* 02D0 */ 0x15, 0xF8, 0x11, 0x05, 0x0C, 0x90, 0x9D, 0x9D, ++ /* 02D8 */ 0x4E, 0x84, 0xF0, 0x5E, 0xF2, 0x1C, 0xE2, 0xDB, ++ /* 02E0 */ 0x95, 0x0F, 0x26, 0x41, 0x9E, 0x03, 0x22, 0x3C, ++ /* 02E8 */ 0x65, 0xF1, 0xFB, 0x40, 0x94, 0x98, 0x07, 0x14, ++ /* 02F0 */ 0x29, 0x8A, 0x11, 0x83, 0x3C, 0x61, 0xF9, 0x7A, ++ /* 02F8 */ 0x12, 0xC3, 0xD0, 0xC1, 0xC2, 0x85, 0x8F, 0xF0, ++ /* 0300 */ 0x94, 0x05, 0x58, 0xBC, 0x64, 0x61, 0x4E, 0x59, ++ /* 0308 */ 0x30, 0xDF, 0x06, 0x3E, 0x65, 0x81, 0xE3, 0xFF, ++ /* 0310 */ 0x7F, 0xCA, 0x02, 0xD7, 0xB8, 0x9F, 0xB2, 0x80, ++ /* 0318 */ 0x99, 0xF4, 0xA7, 0x80, 0x4F, 0x35, 0x7E, 0x02, ++ /* 0320 */ 0x28, 0xFA, 0xC1, 0x82, 0xC2, 0xF8, 0x94, 0x05, ++ /* 0328 */ 0xB8, 0x92, 0x77, 0x40, 0x00, 0xCD, 0xD9, 0xC9, ++ /* 0330 */ 0xB7, 0x05, 0x83, 0x1D, 0xB3, 0x2F, 0x19, 0x3E, ++ /* 0338 */ 0x25, 0x82, 0xE1, 0x90, 0xE1, 0x3B, 0xD5, 0xA1, ++ /* 0340 */ 0x3C, 0x72, 0x3C, 0x05, 0xF8, 0x88, 0x05, 0xF6, ++ /* 0348 */ 0x38, 0xC7, 0x00, 0x1D, 0x57, 0x7C, 0xC4, 0xF2, ++ /* 0350 */ 0xFF, 0xFF, 0x88, 0x05, 0x70, 0xE3, 0x00, 0x82, ++ /* 0358 */ 0x3F, 0x75, 0xC0, 0xBA, 0x07, 0x84, 0xF5, 0xA1, ++ /* 0360 */ 0x03, 0x78, 0xC8, 0x7E, 0x08, 0xE8, 0x0C, 0x63, ++ /* 0368 */ 0xC9, 0x20, 0xB2, 0x71, 0xAE, 0xA1, 0x63, 0xB4, ++ /* 0370 */ 0xF8, 0x85, 0xEA, 0xA6, 0x10, 0xFB, 0x60, 0xB8, ++ /* 0378 */ 0x6C, 0x20, 0x81, 0x7A, 0xB8, 0x16, 0x4C, 0x21, ++ /* 0380 */ 0x51, 0x34, 0x1A, 0x8D, 0x81, 0x09, 0x8C, 0xE0, ++ /* 0388 */ 0x0C, 0x62, 0x40, 0x67, 0x84, 0xD0, 0xA1, 0x0C, ++ /* 0390 */ 0xA7, 0xE2, 0x3C, 0x84, 0xFA, 0xFF, 0x13, 0x0C, ++ /* 0398 */ 0x75, 0x63, 0xA2, 0xB3, 0xF3, 0xFC, 0xF9, 0x6D, ++ /* 03A0 */ 0xC4, 0x27, 0x02, 0x03, 0xFB, 0x0A, 0xF1, 0x96, ++ /* 03A8 */ 0x01, 0x96, 0x61, 0x79, 0x71, 0x4F, 0x00, 0xC7, ++ /* 03B0 */ 0x78, 0x92, 0x09, 0xAA, 0x39, 0xD6, 0xA0, 0xE6, ++ /* 03B8 */ 0xE0, 0xAB, 0xC0, 0x1B, 0x99, 0x09, 0x7C, 0x05, ++ /* 03C0 */ 0x03, 0xDB, 0x69, 0x06, 0xA3, 0xEF, 0x4E, 0x00, ++ /* 03C8 */ 0x0A, 0x20, 0x1F, 0x05, 0x7C, 0x5F, 0x7E, 0x1B, ++ /* 03D0 */ 0x60, 0xB3, 0x78, 0x65, 0x36, 0x9A, 0xCF, 0x9F, ++ /* 03D8 */ 0x88, 0xA1, 0xA3, 0xC4, 0x0C, 0x9D, 0x82, 0x78, ++ /* 03E0 */ 0xE8, 0x0E, 0x3A, 0x74, 0xF4, 0x71, 0xC0, 0x27, ++ /* 03E8 */ 0x2B, 0x5C, 0xB0, 0xC3, 0x17, 0xB4, 0xC9, 0x1D, ++ /* 03F0 */ 0xED, 0x89, 0x79, 0x16, 0x9E, 0x27, 0x6E, 0xEE, ++ /* 03F8 */ 0x60, 0x3A, 0x22, 0xC1, 0x18, 0x3C, 0x66, 0xF2, ++ /* 0400 */ 0x60, 0x16, 0x38, 0x79, 0x50, 0xFC, 0xFF, 0x27, ++ /* 0408 */ 0x0F, 0x13, 0x1E, 0x13, 0xF6, 0x70, 0x48, 0x0F, ++ /* 0410 */ 0x1D, 0x1E, 0x19, 0x1F, 0xA7, 0x4F, 0x3F, 0x0C, ++ /* 0418 */ 0xFB, 0x74, 0xCE, 0xA5, 0xE8, 0x19, 0xE9, 0x8E, ++ /* 0420 */ 0xF1, 0xCC, 0x85, 0x81, 0xF5, 0xC8, 0x39, 0xAC, ++ /* 0428 */ 0xD1, 0xC2, 0x1E, 0xF0, 0x73, 0x88, 0xEF, 0x30, ++ /* 0430 */ 0x3E, 0xF0, 0x30, 0x58, 0x9F, 0x5E, 0xC0, 0x71, ++ /* 0438 */ 0xFC, 0x82, 0x7F, 0x1A, 0x00, 0xCF, 0x01, 0xC4, ++ /* 0440 */ 0x63, 0x78, 0x01, 0xE1, 0x04, 0x73, 0x9D, 0xA6, ++ /* 0448 */ 0x50, 0xF1, 0x4F, 0x53, 0x80, 0xF6, 0xFF, 0xFF, ++ /* 0450 */ 0x69, 0x0A, 0xE6, 0x61, 0xD0, 0x67, 0x08, 0x4F, ++ /* 0458 */ 0x25, 0xC8, 0xEB, 0xD3, 0xAB, 0xA0, 0x31, 0x9E, ++ /* 0460 */ 0x1B, 0x1E, 0xA8, 0x8E, 0x27, 0x4A, 0x88, 0x50, ++ /* 0468 */ 0x91, 0xCE, 0xE0, 0x55, 0x8A, 0x1F, 0xA4, 0xA2, ++ /* 0470 */ 0x04, 0x09, 0xF5, 0x1A, 0xF0, 0x34, 0xE8, 0x2B, ++ /* 0478 */ 0x44, 0x94, 0xA8, 0x21, 0x23, 0xBE, 0x58, 0xF9, ++ /* 0480 */ 0x34, 0xC5, 0x22, 0x9D, 0xA6, 0x00, 0x9A, 0x9C, ++ /* 0488 */ 0x18, 0xF0, 0xA7, 0x29, 0x58, 0xB7, 0x04, 0xCF, ++ /* 0490 */ 0xEE, 0x11, 0x83, 0x9F, 0xA7, 0xC0, 0xFD, 0xFF, ++ /* 0498 */ 0x3F, 0x4F, 0xE1, 0xF2, 0x9C, 0xA7, 0x68, 0x96, ++ /* 04A0 */ 0xF3, 0x14, 0xEA, 0x7C, 0xE1, 0x24, 0x4B, 0x15, ++ /* 04A8 */ 0xFE, 0x23, 0x85, 0x11, 0x8E, 0x87, 0x13, 0x58, ++ /* 04B0 */ 0xFF, 0x89, 0x0A, 0xA5, 0x9C, 0x42, 0xCA, 0xCE, ++ /* 04B8 */ 0x41, 0x28, 0x2D, 0xE7, 0x20, 0x0A, 0xE2, 0x73, ++ /* 04C0 */ 0x10, 0x9C, 0x13, 0x15, 0x36, 0xD9, 0x89, 0x0A, ++ /* 04C8 */ 0xFA, 0x15, 0x07, 0x77, 0x41, 0x86, 0x3D, 0x2F, ++ /* 04D0 */ 0xB6, 0xBE, 0x77, 0x2A, 0xC0, 0x92, 0xBC, 0xC9, ++ /* 04D8 */ 0xA3, 0x04, 0x4D, 0x9E, 0x82, 0x78, 0xF2, 0xBE, ++ /* 04E0 */ 0x0D, 0xF9, 0x4E, 0x05, 0x37, 0xDC, 0x9D, 0x0A, ++ /* 04E8 */ 0x14, 0xC3, 0x07, 0xC3, 0xFF, 0x7F, 0xF8, 0xB0, ++ /* 04F0 */ 0x6F, 0x55, 0x80, 0x9B, 0xE0, 0xB7, 0x2A, 0x40, ++ /* 04F8 */ 0xCF, 0x00, 0x9F, 0x07, 0xC0, 0x72, 0x0D, 0xE1, ++ /* 0500 */ 0xD7, 0x2A, 0xDF, 0x08, 0x30, 0x07, 0x82, 0x67, ++ /* 0508 */ 0x1E, 0x63, 0x62, 0x2E, 0x33, 0x7A, 0x2B, 0xF8, ++ /* 0510 */ 0x0A, 0xE5, 0x25, 0x4A, 0x1E, 0x0C, 0xEA, 0x6E, ++ /* 0518 */ 0x05, 0xF6, 0xFF, 0xFF, 0xDD, 0x0A, 0xD8, 0x5E, ++ /* 0520 */ 0xB4, 0xC1, 0x73, 0x57, 0x78, 0x14, 0xF2, 0xA1, ++ /* 0528 */ 0xC0, 0x37, 0x2B, 0xF8, 0xC3, 0x38, 0x82, 0xC3, ++ /* 0530 */ 0x8F, 0xF0, 0xDC, 0x6B, 0x84, 0xE7, 0x2A, 0x5F, ++ /* 0538 */ 0x7B, 0xC1, 0x1D, 0xFB, 0x39, 0xA2, 0x43, 0x80, ++ /* 0540 */ 0x6F, 0x56, 0x80, 0xE9, 0xFF, 0xFF, 0xCD, 0x0A, ++ /* 0548 */ 0xAC, 0x6F, 0x10, 0x9F, 0x6B, 0xE0, 0x06, 0x3E, ++ /* 0550 */ 0x97, 0xD0, 0xEB, 0x3F, 0xF0, 0xBC, 0x30, 0x82, ++ /* 0558 */ 0xE7, 0x18, 0xE1, 0xDB, 0x28, 0xEE, 0x84, 0x03, ++ /* 0560 */ 0x36, 0xA3, 0x27, 0x1C, 0x04, 0x38, 0xFE, 0x66, ++ /* 0568 */ 0x06, 0x6B, 0x0C, 0x7D, 0xA2, 0xE8, 0x8C, 0x81, ++ /* 0570 */ 0xBB, 0x9A, 0x01, 0x8F, 0x1B, 0x91, 0x87, 0xC0, ++ /* 0578 */ 0x4F, 0x13, 0x1E, 0x02, 0x1F, 0x40, 0xAB, 0xD3, ++ /* 0580 */ 0x23, 0x67, 0x9F, 0x53, 0xC2, 0x1D, 0x07, 0xF8, ++ /* 0588 */ 0x94, 0x70, 0x03, 0xE0, 0xFF, 0x7F, 0x82, 0x01, ++ /* 0590 */ 0x6E, 0x9C, 0xA8, 0xE8, 0x37, 0x4E, 0x80, 0x10, ++ /* 0598 */ 0x20, 0x11, 0x5E, 0x35, 0x7D, 0x88, 0x79, 0xD0, ++ /* 05A0 */ 0xF4, 0x60, 0xDE, 0x62, 0x8C, 0xF3, 0xD6, 0xF0, ++ /* 05A8 */ 0xB2, 0xE9, 0x83, 0x8C, 0xF1, 0xC2, 0x44, 0x39, ++ /* 05B0 */ 0x86, 0x43, 0x8A, 0x19, 0xC5, 0x88, 0x41, 0x42, ++ /* 05B8 */ 0xBC, 0x71, 0x1A, 0xC3, 0xA8, 0xC1, 0xC2, 0x45, ++ /* 05C0 */ 0x8F, 0xF0, 0x20, 0xC3, 0xE2, 0xDC, 0x38, 0x01, ++ /* 05C8 */ 0x21, 0xFF, 0xFF, 0x83, 0x0C, 0x60, 0xE5, 0x68, ++ /* 05D0 */ 0xE6, 0x83, 0x08, 0xFC, 0xE3, 0xC3, 0x9B, 0x42, ++ /* 05D8 */ 0xF0, 0xA7, 0x10, 0x60, 0x22, 0xFE, 0xBE, 0x49, ++ /* 05E0 */ 0x85, 0xDF, 0x37, 0x51, 0x63, 0xB4, 0xF8, 0x85, ++ /* 05E8 */ 0xEA, 0xFA, 0xEC, 0xB9, 0x78, 0xDA, 0x96, 0x7D, ++ /* 05F0 */ 0xDB, 0x44, 0x09, 0xA6, 0x90, 0xA8, 0x13, 0x22, ++ /* 05F8 */ 0x4A, 0xC6, 0x09, 0x91, 0x82, 0x18, 0xD0, 0x19, ++ /* 0600 */ 0x6F, 0x9B, 0x90, 0x43, 0xDD, 0x36, 0xA1, 0xDF, ++ /* 0608 */ 0x1E, 0x9E, 0xE1, 0xC1, 0x79, 0xD6, 0x04, 0xDB, ++ /* 0610 */ 0xFF, 0xFF, 0xAC, 0x09, 0x4C, 0xA5, 0x0D, 0x1D, ++ /* 0618 */ 0x25, 0x66, 0xE8, 0x14, 0xC4, 0xF7, 0x56, 0x38, ++ /* 0620 */ 0x87, 0x28, 0x7C, 0xB0, 0xB3, 0x26, 0x28, 0x4E, ++ /* 0628 */ 0x4C, 0xE0, 0x99, 0x3B, 0xF6, 0xA4, 0x09, 0xD8, ++ /* 0630 */ 0x89, 0x7C, 0xD2, 0x04, 0x82, 0xFF, 0xFF, 0xE3, ++ /* 0638 */ 0x18, 0xD8, 0x8F, 0x54, 0xB8, 0xD3, 0x00, 0xDC, ++ /* 0640 */ 0x03, 0x88, 0xC7, 0x70, 0x9C, 0xEF, 0x4F, 0x06, ++ /* 0648 */ 0x79, 0x1E, 0xF1, 0x81, 0xC0, 0x47, 0x19, 0xA6, ++ /* 0650 */ 0xD0, 0xA6, 0x4F, 0x8D, 0x46, 0xAD, 0x1A, 0x94, ++ /* 0658 */ 0xA9, 0x51, 0xA6, 0x41, 0xAD, 0x3E, 0x95, 0x1A, ++ /* 0660 */ 0x33, 0x76, 0xC0, 0xB0, 0x88, 0xB5, 0x6A, 0xB0, ++ /* 0668 */ 0x0E, 0xB5, 0x5E, 0x81, 0x58, 0xD2, 0x13, 0x43, ++ /* 0670 */ 0x20, 0x16, 0xE5, 0x01, 0x84, 0xC5, 0x35, 0x01, ++ /* 0678 */ 0xC2, 0x84, 0xAF, 0x4A, 0x20, 0x8E, 0x0D, 0x42, ++ /* 0680 */ 0xC5, 0xEA, 0x80, 0x68, 0x64, 0x88, 0x06, 0x11, ++ /* 0688 */ 0x90, 0x43, 0xF8, 0x00, 0x62, 0x91, 0x40, 0x04, ++ /* 0690 */ 0xE4, 0xC8, 0x4A, 0x40, 0x98, 0x60, 0x27, 0x20, ++ /* 0698 */ 0x2C, 0xF3, 0xAB, 0x4A, 0x80, 0x16, 0x60, 0x05, ++ /* 06A0 */ 0x88, 0xE9, 0xD1, 0x02, 0xC4, 0xD4, 0x81, 0x08, ++ /* 06A8 */ 0xC8, 0x29, 0xCC, 0x80, 0x30, 0x0D, 0xAB, 0x12, ++ /* 06B0 */ 0x88, 0xF3, 0x83, 0xD0, 0xD4, 0x76, 0x40, 0x98, ++ /* 06B8 */ 0x66, 0x3D, 0x20, 0x2C, 0xA9, 0x1F, 0x70, 0x16, ++ /* 06C0 */ 0x1B, 0x44, 0x40, 0x56, 0x60, 0x08, 0x88, 0xE9, ++ /* 06C8 */ 0x01, 0x11, 0x90, 0xFF, 0xFF ++ }) ++ ++ Method (WMBD, 3, Serialized) ++ { ++ INIT (1) ++ GUID (100) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ } ++ } ++ ++ /* Wire GPE events to notify OEM ++ * added value events. ++ */ ++ Scope (\_GPE) ++ { ++ Method (_L18, 0, Serialized) ++ { ++ Notify (\_SB.AMW0, 0xD0) ++ } ++ } ++} ++ +diff +--- /dev/null ++++ b/tools/firmware/hvmloader/acpi/ssdt_hp_6930p_elitebook.asl 2009-04-01 16:35:21.000000000 -0400 +@@ -0,0 +1,1309 @@ ++/* ++ * ssdt_hp_6930p_elitebook.asl ++ * ++ * Copyright (c) 2009 Kamala Narasimhan ++ * Copyright (c) 2009 Citrix Systems, Inc. ++ * ++ * 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 ++ */ ++ ++/* SSDT for exposing HP 6930p elitebook specific value add functionalities like ++ * hotkeys, special buttons (e.g., wireless button, presentation button etc.). ++ */ ++ ++/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through ++ * WMI psuedo device objects. For our guests to benefit from such value add, we ++ * expose a psuedo device object in our vACPI layer also. This psuedo object is ++ * similar to the underlying base firmware object in the sense we expose the ++ * same _WDG method which describes the WMI methods, data objects and events ++ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically ++ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get ++ * known entry points and calls those entry points for further information exchange. ++ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ */ ++ ++/* COMMUNICATION DETAILS - ++ * Command port - 0x96 ++ * Writes to this port describe what type of information is about ++ * to be exchanged. E.g., guid, input argument transfer etc. ++ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. ++ * Communicates data to and from the backend. E.g. Input buffer values ++ * get written to this port and output buffer values are read from this ++ * port. ++ */ ++ ++DefinitionBlock ("SSDT_HP_6930P_ELITEBOOK.aml", "SSDT", 2, "Xen", "HVM", 0) ++{ ++ Scope (\_SB) ++ { ++ ++ OperationRegion (HP1, SystemIO, 0x96, 0x01) ++ Field (HP1, ByteAcc, NoLock, Preserve) ++ { ++ P96, 8 ++ } ++ ++ OperationRegion (HP2, SystemIO, 0x98, 0x01) ++ Field (HP2, ByteAcc, NoLock, Preserve) ++ { ++ P98, 8 ++ } ++ ++ OperationRegion (HP3, SystemIO, 0x9A, 0x04) ++ Field (HP3, DWordAcc, NoLock, Preserve) ++ { ++ P9A, 32 ++ } ++ ++ Device (WMID) ++ { ++ /* Exposing a pseudo device with HID PNP0C14 will ++ * result in Windows guest loading their WMI wrapper ++ * driver - wmiacpi.sys ++ */ ++ Name (_HID, EisaId ("PNP0C14")) ++ Name (_UID, 0x00) ++ ++ /* Following list of data blocks exposed by _WDG is same as the ++ * one provided by the underlying firmware. Refer to - ++ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ * for further information about _WDG and what it exposes. ++ */ ++ Name (_WDG, Buffer (0xF0) ++ { ++ /* Data Block 1 */ ++ /* GUID */ ++ 0x34, 0xF0, 0xB7, 0x5F, 0x63, 0x2C, 0xE9, 0x45, ++ 0xBE, 0x91, 0x3D, 0x44, 0xE2, 0xC7, 0x07, 0xE4, ++ 0x41, 0x41, /* Object ID - WMAA */ ++ 0x01, /* Instance count */ ++ 0x02, /* Flag - Method */ ++ ++ /* Data Block 2 */ ++ /* GUID */ ++ 0x79, 0x42, 0xF2, 0x95, 0x7B, 0x4D, 0x34, 0x43, ++ 0x93, 0x87, 0xAC, 0xCD, 0xC6, 0x7E, 0xF6, 0x1C, ++ 0x80, 0x00, /* Event notification ID */ ++ 0x01, /* Instance count */ ++ 0x08, /* Flag - Event */ ++ ++ /* Data Block 3 */ ++ /* GUID */ ++ 0x18, 0x43, 0x81, 0x2B, 0xE8, 0x4B, 0x07, 0x47, ++ 0x9D, 0x84, 0xA1, 0x90, 0xA8, 0x59, 0xB5, 0xD0, ++ 0xA0, 0x00, /* Event notification ID */ ++ 0x01, /* Instance count */ ++ 0x08, /* Flag - Event */ ++ ++ /* Data Block 4 */ ++ /* GUID */ ++ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, ++ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, ++ 0x41, 0x42, /* Object ID - WQAB */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 5 */ ++ /* GUID */ ++ 0xEB, 0x91, 0x4C, 0x1F, 0x5C, 0xDC, 0x0B, 0x46, ++ 0x95, 0x1D, 0xC7, 0xCB, 0x9B, 0x4B, 0x8D, 0x5E, ++ 0x42, 0x41, /* Object ID - WMBA */ ++ 0x01, /* Instance count */ ++ 0x02, /* Flag - Method */ ++ ++ /* Data Block 6 */ ++ /* GUID */ ++ 0x49, 0x4B, 0x11, 0x2D, 0xFB, 0x2D, 0x30, 0x41, ++ 0xB8, 0xFE, 0x4A, 0x3C, 0x09, 0xE7, 0x51, 0x33, ++ 0x42, 0x43, /* Object ID - WQBC */ ++ 0x74, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 7 */ ++ /* GUID */ ++ 0xE3, 0x08, 0x8D, 0x98, 0xF4, 0x68, 0x35, 0x4C, ++ 0xAF, 0x3E, 0x6A, 0x1B, 0x81, 0x06, 0xF8, 0x3C, ++ 0x42, 0x44, /* Object ID - WQBD */ ++ 0x19, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 8 */ ++ /* GUID */ ++ 0x46, 0x97, 0xEA, 0x14, 0x1F, 0xCE, 0x98, 0x40, ++ 0xA0, 0xE0, 0x70, 0x45, 0xCB, 0x4D, 0xA7, 0x45, ++ 0x42, 0x45, /* Object ID - WQBE */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 9 */ ++ /* GUID */ ++ 0x28, 0x20, 0x2F, 0x32, 0x84, 0x0F, 0x01, 0x49, ++ 0x98, 0x8E, 0x01, 0x51, 0x76, 0x04, 0x9E, 0x2D, ++ 0x42, 0x46, /* Object ID - WQBF */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag Data */ ++ ++ /* Data Block 10 */ ++ /* GUID */ ++ 0x3D, 0xDE, 0x32, 0x82, 0x3D, 0x66, 0x27, 0x43, ++ 0xA8, 0xF4, 0xE2, 0x93, 0xAD, 0xB9, 0xBF, 0x05, ++ 0x42, 0x47, /* Object ID - WQBG */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 11 */ ++ /* GUID */ ++ 0x36, 0x64, 0x1F, 0x8F, 0x42, 0x9F, 0xC8, 0x42, ++ 0xBA, 0xDC, 0x0E, 0x94, 0x24, 0xF2, 0x0C, 0x9A, ++ 0x42, 0x48, /* Object ID - WQBH */ ++ 0x00, /* Instance count */ ++ 0x00, /* Flag - Data */ ++ ++ /* Data Block 12 */ ++ /* GUID */ ++ 0x35, 0x64, 0x1F, 0x8F, 0x42, 0x9F, 0xC8, 0x42, ++ 0xBA, 0xDC, 0x0E, 0x94, 0x24, 0xF2, 0x0C, 0x9A, ++ 0x42, 0x49, /* Object ID - WQBI */ ++ 0x00, /* Instance count */ ++ 0x00 /* Flag - Data */ ++ }) ++ ++ /* Initialize cmd port and communicate invocation type ++ * i.e., method execution or query or set object ++ */ ++ Method (INIT, 1, Serialized) ++ { ++ Store (100, P96) ++ Store (Arg0, P98) ++ } ++ ++ /* Pass the guid pertaining to the operation */ ++ Method (GUID, 1, Serialized) ++ { ++ Store (101, P96) ++ Store (0x0, Local0) ++ Store (Arg0, Local1) ++ ++ While ( LLess(Local0,16) ) ++ { ++ Add(Local1, Local0, Local2) ++ Store (DerefOf(Index (_WDG, Local2)), P98 ) ++ Increment( Local0 ) ++ } ++ } ++ ++ /* Pass instance # for the associated object pertaining ++ * to the invocation. ++ */ ++ Method (INST, 1, Serialized) ++ { ++ Store(102, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass method id relevant to the method about to be ++ * executed. ++ */ ++ Method (MTID, 1, Serialized) ++ { ++ Store(103, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass input buffer pertaining to the current operation */ ++ Method (IBUF, 1, Serialized) ++ { ++ Store (105, P96) ++ Store (SizeOf(Arg0), Local0) ++ Store (Local0, P9A) ++ ToBuffer (Arg0, Local1) ++ Store (0, Local2) ++ Store (104, P96) ++ While ( LLess(Local2,Local0) ) ++ { ++ Store (DerefOf(Index (Local1, Local2)), P98) ++ Increment (Local2) ++ } ++ } ++ ++ /* Now that the input arguments are passed, execute the command */ ++ Method (EXEC, 0, Serialized) ++ { ++ Store (106, P96) ++ } ++ ++ /* Get the output buffer pertaining to the just executed command */ ++ Method (OBUF, 0, Serialized) ++ { ++ Store (108, P96) ++ Store (P9A, Local0) ++ Store (Buffer(Local0) {}, Local2) ++ Store (0, Local1) ++ Store (107, P96) ++ While ( LLess(Local1, Local0) ) ++ { ++ Store (P98, Index(Local2, Local1)) ++ Increment (Local1) ++ } ++ Return (Local2) ++ } ++ ++ /* Get event data */ ++ Method (_WED, 1, Serialized) ++ { ++ INIT (4) ++ Store (109, P96) ++ Store (Arg0, P98) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Following are well know entry points as supplied by ++ * _WDG. ++ * @TODO: Though current testing suggest that defining ++ * a method for seralized execution is enough to prevent ++ * synchronization issues, consider using explicit mutexes ++ * for further protection. ++ */ ++ Method (WMAA, 3, Serialized) ++ { ++ INIT (1) ++ GUID (0) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMBA, 3, Serialized) ++ { ++ INIT (1) ++ GUID (80) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Like all other well know entry points, we could delegate ++ * the below to the base firmware also. But, why ask for a ++ * static list (that too this big) and go through layer after ++ * layer to get it? Also, port i/o is not a good idea for this ++ * much data transfer. Luckily, this is the only place that appear ++ * to transfer so much data. ++ */ ++ Name (WQAB, Buffer (0x1C53) ++ { ++ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, ++ /* 0008 */ 0x43, 0x1C, 0x00, 0x00, 0xEA, 0xB4, 0x00, 0x00, ++ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, ++ /* 0018 */ 0x98, 0x2D, 0x96, 0x00, 0x01, 0x06, 0x18, 0x42, ++ /* 0020 */ 0x10, 0x47, 0x10, 0x92, 0x46, 0x62, 0x02, 0x89, ++ /* 0028 */ 0x80, 0x90, 0x18, 0x18, 0x14, 0x81, 0x85, 0x00, ++ /* 0030 */ 0x49, 0x02, 0x88, 0xC4, 0x41, 0xE1, 0x20, 0xD4, ++ /* 0038 */ 0x9F, 0x40, 0x7E, 0x05, 0x20, 0x74, 0x28, 0x40, ++ /* 0040 */ 0xA6, 0x00, 0x83, 0x02, 0x9C, 0x22, 0x88, 0xA0, ++ /* 0048 */ 0x57, 0x01, 0x36, 0x05, 0x98, 0x14, 0x60, 0x51, ++ /* 0050 */ 0x80, 0x76, 0x01, 0x96, 0x05, 0xE8, 0x16, 0x20, ++ /* 0058 */ 0x1D, 0x96, 0x88, 0x04, 0x47, 0x89, 0x01, 0x47, ++ /* 0060 */ 0xE9, 0xC4, 0x16, 0x6E, 0xD8, 0xE0, 0x85, 0xA2, ++ /* 0068 */ 0x68, 0x06, 0x51, 0x12, 0x94, 0x8B, 0x20, 0x5D, ++ /* 0070 */ 0x10, 0x52, 0x2E, 0xC0, 0x37, 0x82, 0x06, 0x10, ++ /* 0078 */ 0xA5, 0x77, 0x01, 0xB6, 0x05, 0x98, 0x86, 0x27, ++ /* 0080 */ 0xD2, 0x20, 0xE4, 0x60, 0x08, 0x54, 0xCE, 0x80, ++ /* 0088 */ 0x20, 0x69, 0x44, 0x21, 0x1E, 0xA7, 0x44, 0x08, ++ /* 0090 */ 0x0A, 0x84, 0x90, 0xD4, 0xF1, 0xA0, 0xA0, 0x71, ++ /* 0098 */ 0x88, 0xAD, 0xCE, 0x46, 0x93, 0xA9, 0x74, 0x7E, ++ /* 00A0 */ 0x48, 0x82, 0x70, 0xC6, 0x2A, 0x7E, 0x3A, 0x9A, ++ /* 00A8 */ 0xD0, 0xD9, 0x9C, 0x60, 0xE7, 0x18, 0x72, 0x3C, ++ /* 00B0 */ 0x48, 0xF4, 0x20, 0xB8, 0x00, 0x0F, 0x1C, 0x2C, ++ /* 00B8 */ 0x34, 0x84, 0x22, 0x6B, 0x80, 0xC1, 0x8C, 0xDD, ++ /* 00C0 */ 0x63, 0xB1, 0x0B, 0x4E, 0x0A, 0xEC, 0x61, 0xB3, ++ /* 00C8 */ 0x01, 0x19, 0xA2, 0x24, 0x38, 0xD4, 0x11, 0xC0, ++ /* 00D0 */ 0x12, 0x05, 0x98, 0x1F, 0x87, 0x0C, 0x0F, 0x95, ++ /* 00D8 */ 0x8C, 0x25, 0x24, 0x1B, 0xAB, 0x87, 0xC2, 0xA5, ++ /* 00E0 */ 0x40, 0x68, 0x6C, 0x27, 0xED, 0x19, 0x45, 0x2C, ++ /* 00E8 */ 0x79, 0x4A, 0x82, 0x49, 0xE0, 0x51, 0x44, 0x36, ++ /* 00F0 */ 0x1A, 0x27, 0x28, 0x1B, 0x1A, 0x25, 0x03, 0x42, ++ /* 00F8 */ 0x9E, 0x05, 0x58, 0x07, 0x26, 0x04, 0x76, 0x2F, ++ /* 0100 */ 0xC0, 0x9A, 0x00, 0x73, 0xB3, 0x90, 0xB1, 0xB9, ++ /* 0108 */ 0xE8, 0xFF, 0x0F, 0x71, 0xB0, 0x31, 0xDA, 0x9A, ++ /* 0110 */ 0xAE, 0x90, 0xC2, 0xC4, 0x88, 0x12, 0x2C, 0x5E, ++ /* 0118 */ 0xC5, 0xC3, 0x10, 0xCA, 0x93, 0x42, 0xA8, 0x48, ++ /* 0120 */ 0x95, 0xA1, 0x68, 0xB4, 0x51, 0x2A, 0x14, 0xE0, ++ /* 0128 */ 0x4C, 0x80, 0x30, 0x5C, 0x1D, 0x03, 0x82, 0x46, ++ /* 0130 */ 0x88, 0x15, 0x29, 0x56, 0xFB, 0x83, 0x20, 0xF1, ++ /* 0138 */ 0x2D, 0x40, 0x54, 0x01, 0xA2, 0x48, 0xA3, 0x41, ++ /* 0140 */ 0x9D, 0x03, 0x3C, 0x5C, 0x0F, 0xF5, 0xF0, 0x3D, ++ /* 0148 */ 0xF6, 0x93, 0x0C, 0x72, 0x90, 0x67, 0xF1, 0xA8, ++ /* 0150 */ 0x70, 0x9C, 0x06, 0x49, 0xE0, 0x0B, 0x80, 0x4F, ++ /* 0158 */ 0x08, 0x1E, 0x38, 0xDE, 0x35, 0xA0, 0x66, 0x7C, ++ /* 0160 */ 0xBC, 0x4C, 0x10, 0x1C, 0x6A, 0x88, 0x1E, 0x68, ++ /* 0168 */ 0xB8, 0x13, 0x38, 0x44, 0x06, 0xE8, 0x49, 0x3D, ++ /* 0170 */ 0x52, 0x60, 0x07, 0x77, 0x32, 0xEF, 0x01, 0xAF, ++ /* 0178 */ 0x0A, 0xCD, 0x5E, 0x12, 0x08, 0xC1, 0xF1, 0xF8, ++ /* 0180 */ 0x7E, 0xC0, 0x26, 0x9C, 0xC0, 0xF2, 0x07, 0x81, ++ /* 0188 */ 0x1A, 0x99, 0xA1, 0x3D, 0xCA, 0xD3, 0x8A, 0x19, ++ /* 0190 */ 0xF2, 0x31, 0xC1, 0x04, 0x16, 0x0B, 0x21, 0x05, ++ /* 0198 */ 0x10, 0x1A, 0x0F, 0xF8, 0x6F, 0x00, 0x8F, 0x17, ++ /* 01A0 */ 0xBE, 0x12, 0xC4, 0xF6, 0x80, 0x12, 0x0C, 0x0B, ++ /* 01A8 */ 0x21, 0x23, 0xAB, 0xF0, 0x78, 0xE8, 0x28, 0x7C, ++ /* 01B0 */ 0x95, 0x38, 0x9C, 0xD3, 0x8A, 0x67, 0x82, 0xE1, ++ /* 01B8 */ 0x20, 0xF4, 0x05, 0x90, 0x00, 0x51, 0xE7, 0x0C, ++ /* 01C0 */ 0xD4, 0x61, 0xC1, 0xE7, 0x04, 0x76, 0x33, 0x38, ++ /* 01C8 */ 0x83, 0x47, 0x00, 0x8F, 0xE4, 0x84, 0xFC, 0x2B, ++ /* 01D0 */ 0xF1, 0xC0, 0xE0, 0x03, 0xE2, 0xEF, 0x1F, 0xA7, ++ /* 01D8 */ 0xEC, 0x11, 0x9C, 0xA9, 0x01, 0x7D, 0x1C, 0xF0, ++ /* 01E0 */ 0xFF, 0x7F, 0x28, 0x7C, 0x88, 0x1E, 0xDF, 0x29, ++ /* 01E8 */ 0x1F, 0xAF, 0x4F, 0x17, 0x96, 0x35, 0x4E, 0xE8, ++ /* 01F0 */ 0x77, 0x08, 0x9F, 0x38, 0x7C, 0x64, 0x71, 0x44, ++ /* 01F8 */ 0x08, 0x39, 0x39, 0x05, 0xA0, 0x81, 0x4F, 0xF7, ++ /* 0200 */ 0xEC, 0x22, 0x9C, 0xAE, 0x27, 0xE5, 0x40, 0xC3, ++ /* 0208 */ 0xA0, 0xE3, 0x04, 0xC7, 0x79, 0x00, 0x1C, 0xE3, ++ /* 0210 */ 0x84, 0x7F, 0x2E, 0x80, 0x3F, 0x40, 0x7E, 0xCA, ++ /* 0218 */ 0x78, 0xC5, 0x48, 0xE0, 0x98, 0x23, 0x44, 0x9F, ++ /* 0220 */ 0x6B, 0x3C, 0x42, 0x2C, 0xFC, 0x53, 0x45, 0xE1, ++ /* 0228 */ 0x03, 0x21, 0x63, 0x04, 0x17, 0xA0, 0xC7, 0x08, ++ /* 0230 */ 0x7C, 0x03, 0x8E, 0x11, 0x7D, 0x94, 0xE0, 0xEA, ++ /* 0238 */ 0x0F, 0x1A, 0x74, 0x80, 0xB8, 0xFF, 0xFF, 0x00, ++ /* 0240 */ 0xE1, 0x83, 0x7A, 0x80, 0xC0, 0x37, 0xFA, 0xD1, ++ /* 0248 */ 0x03, 0x3D, 0x2E, 0x8B, 0x3E, 0x0F, 0xC8, 0xF8, ++ /* 0250 */ 0x89, 0x46, 0xF3, 0xE2, 0xA7, 0x03, 0x7E, 0xF8, ++ /* 0258 */ 0x00, 0x0F, 0xA8, 0x87, 0x84, 0x03, 0xC5, 0x4C, ++ /* 0260 */ 0x9B, 0x83, 0x3E, 0xBB, 0x1C, 0x3A, 0x76, 0xB8, ++ /* 0268 */ 0xE0, 0x3F, 0x81, 0x80, 0x4B, 0xDE, 0x21, 0x0C, ++ /* 0270 */ 0x14, 0x23, 0xC6, 0x9F, 0x83, 0x7C, 0x0A, 0x03, ++ /* 0278 */ 0xFF, 0xFF, 0xFF, 0x14, 0x06, 0xFE, 0xE1, 0xF0, ++ /* 0280 */ 0x20, 0x4F, 0x07, 0x9F, 0xB6, 0xA8, 0x74, 0x18, ++ /* 0288 */ 0xD4, 0x81, 0x0B, 0xB0, 0x32, 0x89, 0x08, 0xCF, ++ /* 0290 */ 0x12, 0xB5, 0x41, 0xE8, 0xD4, 0xF0, 0x36, 0xF1, ++ /* 0298 */ 0xB6, 0xE5, 0x5B, 0x40, 0x9C, 0xD3, 0xEC, 0xED, ++ /* 02A0 */ 0xC0, 0x45, 0x30, 0x22, 0xD4, 0x0C, 0x45, 0x4E, ++ /* 02A8 */ 0x5A, 0x11, 0x63, 0x44, 0x79, 0xDC, 0x32, 0xCA, ++ /* 02B0 */ 0xDB, 0xD6, 0x0B, 0x40, 0xBC, 0x13, 0x7B, 0xDE, ++ /* 02B8 */ 0x32, 0x46, 0xF0, 0xC8, 0x0F, 0x5C, 0x2C, 0xC6, ++ /* 02C0 */ 0xEA, 0xF5, 0x5F, 0xF3, 0x81, 0x0B, 0x70, 0xF6, ++ /* 02C8 */ 0xFF, 0x3F, 0x70, 0x01, 0x1C, 0x0A, 0x7A, 0x18, ++ /* 02D0 */ 0x42, 0x0F, 0xC3, 0x53, 0x39, 0x97, 0x87, 0xC8, ++ /* 02D8 */ 0x53, 0x89, 0x18, 0x35, 0x4C, 0xD4, 0x67, 0x28, ++ /* 02E0 */ 0xDF, 0x2D, 0x7C, 0x20, 0x02, 0xDF, 0x99, 0x0B, ++ /* 02E8 */ 0xF8, 0xFD, 0xFF, 0x0F, 0x44, 0x70, 0x8E, 0x29, ++ /* 02F0 */ 0xB8, 0x33, 0x0D, 0x78, 0x7C, 0xCE, 0x40, 0x20, ++ /* 02F8 */ 0xA7, 0xE2, 0x43, 0x0D, 0x60, 0x41, 0xF4, 0x13, ++ /* 0300 */ 0xC2, 0x27, 0x1A, 0x2A, 0x13, 0x06, 0x75, 0xA8, ++ /* 0308 */ 0x01, 0xAC, 0x5C, 0x61, 0x9E, 0x46, 0xCF, 0xF9, ++ /* 0310 */ 0x59, 0xC6, 0xA7, 0x1A, 0x1F, 0x4A, 0x8D, 0x63, ++ /* 0318 */ 0x88, 0x97, 0x99, 0x87, 0x1A, 0x1F, 0x0B, 0x5E, ++ /* 0320 */ 0x49, 0x7D, 0xA8, 0x31, 0x54, 0x9C, 0x87, 0x1A, ++ /* 0328 */ 0x0F, 0x37, 0x50, 0xD4, 0x37, 0x9B, 0x67, 0x1B, ++ /* 0330 */ 0xA3, 0xC7, 0xF7, 0x0D, 0xD5, 0x10, 0x0F, 0x35, ++ /* 0338 */ 0x4C, 0xF2, 0x4A, 0x35, 0x16, 0x1F, 0x6A, 0xC0, ++ /* 0340 */ 0xF1, 0xFF, 0x3F, 0xD4, 0x00, 0xFC, 0xFF, 0xFF, ++ /* 0348 */ 0x1F, 0x6A, 0x00, 0x47, 0x47, 0x03, 0x38, 0x47, ++ /* 0350 */ 0x46, 0xDC, 0xD1, 0x00, 0x5C, 0x87, 0x52, 0xE0, ++ /* 0358 */ 0x70, 0x34, 0x00, 0x1E, 0x47, 0x21, 0x30, 0x5F, ++ /* 0360 */ 0x68, 0x7C, 0x14, 0x02, 0x16, 0xFF, 0xFF, 0xA3, ++ /* 0368 */ 0x10, 0xF8, 0x65, 0x9F, 0x83, 0x50, 0x42, 0x8F, ++ /* 0370 */ 0x42, 0x80, 0xA0, 0xDB, 0xCF, 0x53, 0xC4, 0xB3, ++ /* 0378 */ 0x8F, 0x2F, 0x3F, 0x0F, 0x04, 0x11, 0x5E, 0xF3, ++ /* 0380 */ 0x7D, 0x0A, 0xF2, 0x21, 0xDF, 0x47, 0x21, 0x06, ++ /* 0388 */ 0x63, 0x28, 0x5F, 0x83, 0x7C, 0x14, 0x62, 0x50, ++ /* 0390 */ 0xAF, 0x41, 0xBE, 0xEF, 0x1B, 0xE4, 0xF1, 0x22, ++ /* 0398 */ 0x48, 0xEC, 0x67, 0x02, 0x1F, 0x85, 0x98, 0xE8, ++ /* 03A0 */ 0xA3, 0x10, 0xA0, 0xF0, 0xFF, 0x7F, 0x14, 0x02, ++ /* 03A8 */ 0xF8, 0xFF, 0xFF, 0x3F, 0x0A, 0x01, 0xCE, 0x02, ++ /* 03B0 */ 0x1C, 0x0D, 0x40, 0x37, 0xAD, 0x47, 0x21, 0xF0, ++ /* 03B8 */ 0xDE, 0x59, 0x4E, 0xFB, 0x04, 0x7C, 0x16, 0x02, ++ /* 03C0 */ 0xCC, 0xFE, 0xFF, 0xCF, 0x42, 0xC0, 0xEC, 0x28, ++ /* 03C8 */ 0x74, 0x14, 0x67, 0xF9, 0x2A, 0xF4, 0x04, 0xF0, ++ /* 03D0 */ 0x02, 0x10, 0x23, 0xCC, 0x3B, 0xD0, 0x4B, 0x26, ++ /* 03D8 */ 0xBB, 0x8B, 0x1B, 0xE7, 0xC9, 0xE5, 0x2C, 0x9E, ++ /* 03E0 */ 0xC4, 0x7D, 0x09, 0xF2, 0x81, 0xE2, 0x59, 0xC8, ++ /* 03E8 */ 0x50, 0xA7, 0x1B, 0xF4, 0x8D, 0xDC, 0x03, 0x8B, ++ /* 03F0 */ 0x19, 0x3F, 0xC4, 0xF3, 0x90, 0x21, 0x9E, 0x85, ++ /* 03F8 */ 0x00, 0x76, 0xFD, 0xFF, 0xCF, 0x42, 0x00, 0xFF, ++ /* 0400 */ 0xFF, 0xFF, 0x47, 0x03, 0xF8, 0x2F, 0x00, 0x9F, ++ /* 0408 */ 0x85, 0x80, 0xE7, 0x09, 0xE0, 0x41, 0xDB, 0x67, ++ /* 0410 */ 0x21, 0x80, 0x33, 0x87, 0xCB, 0xF3, 0x7F, 0x05, ++ /* 0418 */ 0x3A, 0x96, 0xF7, 0x08, 0xCF, 0xFA, 0x24, 0x5F, ++ /* 0420 */ 0x2F, 0x3D, 0xD3, 0x87, 0x82, 0x67, 0x21, 0x86, ++ /* 0428 */ 0x75, 0x18, 0x3E, 0x0B, 0x31, 0x88, 0x17, 0x4D, ++ /* 0430 */ 0x43, 0xBC, 0x70, 0xFA, 0x30, 0xE0, 0xFF, 0x3F, ++ /* 0438 */ 0x5E, 0xE0, 0x57, 0x4E, 0x03, 0x05, 0x09, 0xF4, ++ /* 0440 */ 0x2C, 0x04, 0x30, 0xFE, 0xFF, 0x7F, 0x16, 0x02, ++ /* 0448 */ 0xC8, 0xB8, 0x46, 0x9D, 0x85, 0x80, 0xE5, 0x6D, ++ /* 0450 */ 0xE5, 0x19, 0xDB, 0xA7, 0x95, 0x04, 0xFF, 0xFF, ++ /* 0458 */ 0x67, 0x21, 0xC0, 0x41, 0x2E, 0x23, 0x07, 0x21, ++ /* 0460 */ 0x4C, 0xC4, 0x87, 0x83, 0x8F, 0x99, 0x80, 0x9E, ++ /* 0468 */ 0x29, 0xBE, 0xB8, 0x1B, 0xE3, 0x09, 0xE0, 0x45, ++ /* 0470 */ 0xE2, 0x31, 0x93, 0x1D, 0x35, 0x0D, 0xF3, 0x2C, ++ /* 0478 */ 0x64, 0xBC, 0xB3, 0x78, 0x0D, 0x78, 0x82, 0xF7, ++ /* 0480 */ 0xE4, 0x9F, 0x85, 0x18, 0xD8, 0x61, 0x05, 0x7B, ++ /* 0488 */ 0x14, 0x32, 0xA8, 0xC1, 0x63, 0x87, 0x08, 0x13, ++ /* 0490 */ 0xE8, 0x59, 0x88, 0xC5, 0x7D, 0xAE, 0xE8, 0x3C, ++ /* 0498 */ 0xE1, 0xB3, 0x10, 0xF0, 0xFE, 0xFF, 0x9F, 0x25, ++ /* 04A0 */ 0xE0, 0x5E, 0x0D, 0x9E, 0x85, 0x00, 0x13, 0x87, ++ /* 04A8 */ 0x0D, 0x9F, 0x35, 0xC0, 0x33, 0x7C, 0x8F, 0xEA, ++ /* 04B0 */ 0x1C, 0x1E, 0x8F, 0x81, 0x7F, 0x56, 0x1D, 0xE7, ++ /* 04B8 */ 0x04, 0x96, 0x7B, 0xD1, 0xB2, 0x71, 0xA0, 0xA1, ++ /* 04C0 */ 0x23, 0xB2, 0x3A, 0x20, 0x8D, 0x0D, 0x73, 0x29, ++ /* 04C8 */ 0x89, 0x7C, 0x72, 0x6C, 0xD4, 0x56, 0x04, 0xA7, ++ /* 04D0 */ 0x33, 0x93, 0x4F, 0x00, 0xD6, 0x42, 0x21, 0x05, ++ /* 04D8 */ 0x34, 0x1A, 0x8B, 0xE1, 0x9D, 0xF9, 0xE8, 0x44, ++ /* 04E0 */ 0x41, 0x0C, 0xE8, 0xE3, 0x90, 0x6D, 0x1C, 0x0A, ++ /* 04E8 */ 0x50, 0x7B, 0xD1, 0x14, 0xC8, 0x39, 0x07, 0xA3, ++ /* 04F0 */ 0x7F, 0x76, 0x74, 0x36, 0xBE, 0x13, 0x70, 0x0D, ++ /* 04F8 */ 0x10, 0x3A, 0x25, 0x18, 0xDA, 0x6A, 0x04, 0xFC, ++ /* 0500 */ 0xFF, 0x67, 0x89, 0x01, 0x33, 0xFE, 0x53, 0x8C, ++ /* 0508 */ 0x09, 0x7C, 0x8E, 0xC1, 0x1F, 0x0C, 0xF0, 0x03, ++ /* 0510 */ 0x7F, 0x31, 0xA8, 0xFA, 0x5E, 0xA0, 0xFB, 0x82, ++ /* 0518 */ 0xD5, 0xDD, 0x64, 0x20, 0xCC, 0xC8, 0x04, 0xF5, ++ /* 0520 */ 0x9D, 0x0E, 0x40, 0x01, 0xE4, 0x0B, 0x81, 0xCF, ++ /* 0528 */ 0x51, 0x0F, 0x05, 0x6C, 0x22, 0x21, 0xC2, 0x44, ++ /* 0530 */ 0x33, 0x3A, 0x62, 0xC2, 0xA8, 0xE8, 0x13, 0xA6, ++ /* 0538 */ 0x20, 0x9E, 0xB0, 0x63, 0x4D, 0x18, 0x3D, 0x13, ++ /* 0540 */ 0x5F, 0x74, 0xD8, 0x88, 0x31, 0x21, 0xAE, 0x1E, ++ /* 0548 */ 0xD0, 0x26, 0x18, 0xD4, 0x97, 0x22, 0x58, 0x43, ++ /* 0550 */ 0xE6, 0x63, 0xF1, 0x05, 0x02, 0x37, 0x65, 0x30, ++ /* 0558 */ 0xCE, 0x89, 0x5D, 0x13, 0x7C, 0xD9, 0xC1, 0xCD, ++ /* 0560 */ 0x19, 0x8C, 0xF0, 0x98, 0xBB, 0x18, 0xBF, 0x3A, ++ /* 0568 */ 0x79, 0x74, 0xFC, 0xA0, 0xE0, 0x1B, 0x0E, 0xC3, ++ /* 0570 */ 0x7E, 0x32, 0xF3, 0x8C, 0xDE, 0xCB, 0x7C, 0x8D, ++ /* 0578 */ 0xC3, 0xC0, 0x7A, 0xBC, 0x1C, 0xD6, 0x68, 0x61, ++ /* 0580 */ 0x0F, 0xED, 0x3D, 0xC4, 0xFF, 0xFF, 0x43, 0x8C, ++ /* 0588 */ 0xCF, 0x13, 0xC6, 0x08, 0xEB, 0xDB, 0x0B, 0x38, ++ /* 0590 */ 0xEE, 0x59, 0xF0, 0xEF, 0x1A, 0xE0, 0xB9, 0x84, ++ /* 0598 */ 0xF8, 0xAE, 0x01, 0x30, 0xF0, 0xFF, 0x7F, 0xD7, ++ /* 05A0 */ 0x00, 0x4E, 0xD7, 0x04, 0xDF, 0x35, 0x80, 0xF7, ++ /* 05A8 */ 0xD0, 0x7D, 0xD7, 0x00, 0xAE, 0xD9, 0xEF, 0x1A, ++ /* 05B0 */ 0xA8, 0x63, 0x80, 0x15, 0xDE, 0x35, 0xA0, 0x5D, ++ /* 05B8 */ 0xD9, 0xDE, 0xD7, 0x9E, 0xB0, 0xAC, 0xE9, 0xB2, ++ /* 05C0 */ 0x81, 0x52, 0x73, 0xD9, 0x00, 0x14, 0xFC, 0xFF, ++ /* 05C8 */ 0x2F, 0x1B, 0x80, 0x01, 0x29, 0x13, 0x46, 0x85, ++ /* 05D0 */ 0x9F, 0x30, 0x05, 0xF1, 0x84, 0x1D, 0xEC, 0xB2, ++ /* 05D8 */ 0x01, 0x8A, 0x18, 0x97, 0x0D, 0xD0, 0x8F, 0xED, ++ /* 05E0 */ 0x65, 0x03, 0x18, 0xDC, 0x13, 0xF8, 0x6D, 0x03, ++ /* 05E8 */ 0x78, 0x43, 0xFA, 0xB6, 0x01, 0xD6, 0xFF, 0xFF, ++ /* 05F0 */ 0x6D, 0x03, 0xAC, 0xF9, 0x6F, 0x1B, 0x28, 0x0E, ++ /* 05F8 */ 0xAB, 0xBC, 0x6D, 0x40, 0x3C, 0xC9, 0x33, 0x02, ++ /* 0600 */ 0xAB, 0xBA, 0x6E, 0xA0, 0xF4, 0x5C, 0x37, 0x00, ++ /* 0608 */ 0x12, 0x88, 0x99, 0x30, 0x2A, 0xFE, 0x84, 0x29, ++ /* 0610 */ 0x88, 0x27, 0xEC, 0x68, 0xD7, 0x0D, 0x50, 0x04, ++ /* 0618 */ 0xB9, 0x6E, 0x80, 0x7E, 0x5E, 0x09, 0xFE, 0xFF, ++ /* 0620 */ 0xAF, 0x1B, 0xC0, 0xE0, 0xA2, 0x80, 0xB9, 0x6F, ++ /* 0628 */ 0x00, 0x6F, 0x58, 0x7E, 0xDF, 0x00, 0x7C, 0xDC, ++ /* 0630 */ 0xC4, 0x31, 0xF7, 0x0D, 0xC0, 0xCC, 0xFF, 0xFF, ++ /* 0638 */ 0xBE, 0x01, 0xB0, 0xE7, 0xA2, 0x80, 0xBB, 0x6F, ++ /* 0640 */ 0x00, 0xEF, 0x8B, 0xB4, 0xEF, 0x1B, 0x60, 0xFE, ++ /* 0648 */ 0xFF, 0xDF, 0x37, 0xC0, 0x28, 0x6D, 0xFD, 0x1E, ++ /* 0650 */ 0x1C, 0x3D, 0x21, 0x78, 0x7C, 0xB8, 0xFB, 0xA5, ++ /* 0658 */ 0xC7, 0xE7, 0xBB, 0x39, 0x38, 0x06, 0x79, 0x8C, ++ /* 0660 */ 0x87, 0x76, 0xC0, 0xAF, 0xEF, 0x9E, 0x98, 0xEF, ++ /* 0668 */ 0xE6, 0xC0, 0xFF, 0x4C, 0x70, 0x3C, 0x18, 0x68, ++ /* 0670 */ 0x1C, 0x62, 0xAB, 0x97, 0x06, 0x72, 0x34, 0x38, ++ /* 0678 */ 0x3F, 0xDC, 0x19, 0x81, 0x61, 0x15, 0x7F, 0xF2, ++ /* 0680 */ 0x47, 0x38, 0xC7, 0xD0, 0xD9, 0xE1, 0x20, 0xB1, ++ /* 0688 */ 0x83, 0xE0, 0xC1, 0x56, 0x6D, 0x02, 0x85, 0x86, ++ /* 0690 */ 0x50, 0x14, 0x18, 0x14, 0x8B, 0x0F, 0x18, 0xF8, ++ /* 0698 */ 0x61, 0xB3, 0xB3, 0x00, 0x93, 0x04, 0x87, 0x3A, ++ /* 06A0 */ 0x02, 0xF8, 0x3E, 0xD1, 0xFC, 0x38, 0x74, 0x37, ++ /* 06A8 */ 0x38, 0x54, 0x8F, 0xE5, 0xA1, 0x80, 0x9E, 0x01, ++ /* 06B0 */ 0x71, 0xC7, 0x0C, 0x32, 0x69, 0xCF, 0x28, 0xE2, ++ /* 06B8 */ 0x53, 0xC2, 0x29, 0x85, 0x49, 0xE0, 0xF3, 0x03, ++ /* 06C0 */ 0x43, 0xE3, 0x04, 0xAF, 0x0D, 0xA1, 0xF9, 0xFF, ++ /* 06C8 */ 0xFF, 0xA4, 0xC0, 0x3C, 0xDF, 0x31, 0x04, 0x6C, ++ /* 06D0 */ 0x02, 0xBB, 0xBF, 0x64, 0xC8, 0xDA, 0xC0, 0x75, ++ /* 06D8 */ 0x4B, 0x32, 0x44, 0x6F, 0x38, 0xB2, 0x85, 0xA2, ++ /* 06E0 */ 0xE9, 0x44, 0x79, 0xDF, 0x88, 0x62, 0x67, 0x08, ++ /* 06E8 */ 0xC2, 0x88, 0x12, 0x2C, 0xC8, 0xA3, 0x42, 0xAC, ++ /* 06F0 */ 0x28, 0x2F, 0x05, 0x46, 0x88, 0x18, 0xE2, 0x95, ++ /* 06F8 */ 0x23, 0xD0, 0x09, 0x87, 0x0F, 0xF2, 0xD8, 0x14, ++ /* 0700 */ 0xA7, 0xFD, 0x41, 0x90, 0x58, 0x4F, 0x02, 0x8D, ++ /* 0708 */ 0xC5, 0x91, 0x46, 0x83, 0x3A, 0x07, 0x78, 0xB8, ++ /* 0710 */ 0x3E, 0xC4, 0x78, 0xF8, 0x0F, 0x21, 0x06, 0x39, ++ /* 0718 */ 0xC8, 0x73, 0x7B, 0x54, 0x38, 0x4E, 0x5F, 0x25, ++ /* 0720 */ 0x4C, 0xF0, 0x02, 0xE0, 0x83, 0x0A, 0x1C, 0xD7, ++ /* 0728 */ 0x80, 0x9A, 0xF1, 0x33, 0x06, 0x58, 0x8E, 0xE3, ++ /* 0730 */ 0x3E, 0xA9, 0xC0, 0x1D, 0x8F, 0xEF, 0x07, 0x6C, ++ /* 0738 */ 0xC2, 0x09, 0x2C, 0x7F, 0x10, 0xA8, 0xE3, 0x0C, ++ /* 0740 */ 0x9F, 0xE7, 0x0B, 0x8B, 0x21, 0x1F, 0x13, 0x4C, ++ /* 0748 */ 0x60, 0xB1, 0x27, 0x1B, 0x3A, 0x1E, 0xF0, 0xDF, ++ /* 0750 */ 0x63, 0x1E, 0x2F, 0x7C, 0x32, 0xF1, 0x7C, 0x4D, ++ /* 0758 */ 0x30, 0x22, 0x84, 0x9C, 0x8C, 0x07, 0x7D, 0x87, ++ /* 0760 */ 0xC0, 0x5C, 0x6F, 0xD8, 0xB9, 0x85, 0x8B, 0x3A, ++ /* 0768 */ 0x68, 0xA0, 0x4E, 0x0B, 0x3E, 0x28, 0xB0, 0x9B, ++ /* 0770 */ 0x11, 0xE6, 0xB8, 0xCE, 0xCF, 0x2A, 0x60, 0xF8, ++ /* 0778 */ 0xFF, 0x9F, 0x55, 0x60, 0x8F, 0x10, 0xFE, 0xED, ++ /* 0780 */ 0xC1, 0xF3, 0xF2, 0x95, 0xE1, 0xD5, 0x21, 0x81, ++ /* 0788 */ 0x43, 0x8E, 0x10, 0x3D, 0x2E, 0x8F, 0x10, 0x73, ++ /* 0790 */ 0x3E, 0xC2, 0x0C, 0x11, 0x5C, 0x67, 0x01, 0x70, ++ /* 0798 */ 0x0C, 0x11, 0xF8, 0x1C, 0x70, 0xC0, 0x71, 0x69, ++ /* 07A0 */ 0xE2, 0x03, 0xF5, 0x01, 0x07, 0x70, 0x70, 0x4D, ++ /* 07A8 */ 0xC3, 0x1D, 0x70, 0xC0, 0x71, 0x16, 0x60, 0xFF, ++ /* 07B0 */ 0xFF, 0xC3, 0x0D, 0x2C, 0x49, 0x26, 0x0E, 0x23, ++ /* 07B8 */ 0x18, 0x11, 0x30, 0x28, 0x02, 0x02, 0xA4, 0xB3, ++ /* 07C0 */ 0x80, 0x0F, 0x29, 0x00, 0x1F, 0xAE, 0x0C, 0x0F, ++ /* 07C8 */ 0x29, 0xD8, 0x93, 0x86, 0x07, 0x8E, 0x1B, 0x85, ++ /* 07D0 */ 0x07, 0x8D, 0x0B, 0x30, 0x68, 0x7A, 0xE2, 0x80, ++ /* 07D8 */ 0x7F, 0x4C, 0xF0, 0x19, 0x05, 0x1C, 0xE3, 0x06, ++ /* 07E0 */ 0xDF, 0x2A, 0x0C, 0xFC, 0xFF, 0x3F, 0x30, 0xCC, ++ /* 07E8 */ 0xE1, 0xC2, 0x63, 0x39, 0x8A, 0xA0, 0x07, 0x1E, ++ /* 07F0 */ 0xD4, 0xF7, 0x8C, 0x33, 0xF7, 0x24, 0x8F, 0xD1, ++ /* 07F8 */ 0x51, 0x0F, 0x27, 0xF4, 0xE4, 0x85, 0x3B, 0x57, ++ /* 0800 */ 0xF9, 0x0A, 0x71, 0x14, 0x18, 0xB8, 0x77, 0x29, ++ /* 0808 */ 0x8F, 0xCF, 0x17, 0x2B, 0xC3, 0x63, 0x46, 0xFB, ++ /* 0810 */ 0x1E, 0x72, 0xD6, 0x11, 0x02, 0xE2, 0x2F, 0x75, ++ /* 0818 */ 0x6C, 0xC0, 0x60, 0x39, 0x18, 0x00, 0x87, 0x01, ++ /* 0820 */ 0xE3, 0x13, 0x0D, 0x58, 0x67, 0x1B, 0x3C, 0xF4, ++ /* 0828 */ 0x69, 0x31, 0xC4, 0xE3, 0x0B, 0xFB, 0x56, 0x61, ++ /* 0830 */ 0x82, 0xEA, 0x41, 0x75, 0x12, 0xF4, 0xD0, 0xC0, ++ /* 0838 */ 0x01, 0xE8, 0xA1, 0xC1, 0x3F, 0xB9, 0x90, 0xFB, ++ /* 0840 */ 0x2B, 0x1D, 0x82, 0xB5, 0xE2, 0x69, 0xDE, 0x47, ++ /* 0848 */ 0x1E, 0xF3, 0xDC, 0xA2, 0xBC, 0x0D, 0x3C, 0x07, ++ /* 0850 */ 0xF0, 0xD3, 0x82, 0x87, 0xE3, 0x63, 0x81, 0xC7, ++ /* 0858 */ 0xE9, 0x4B, 0x58, 0x82, 0xF7, 0x1A, 0x9F, 0x6C, ++ /* 0860 */ 0x1E, 0x5C, 0x58, 0xB2, 0x21, 0xA0, 0x06, 0xEB, ++ /* 0868 */ 0x21, 0x60, 0xA6, 0x9A, 0xC0, 0x49, 0x46, 0x80, ++ /* 0870 */ 0xCA, 0x00, 0xA1, 0x1B, 0xCB, 0xE9, 0x3E, 0x8B, ++ /* 0878 */ 0x84, 0x38, 0xCD, 0x47, 0x99, 0xC7, 0x02, 0x8F, ++ /* 0880 */ 0xF5, 0xC1, 0xC0, 0xFF, 0x7F, 0xCD, 0x23, 0xD4, ++ /* 0888 */ 0x7D, 0xCD, 0x33, 0x7B, 0x3A, 0xC0, 0xAC, 0x22, ++ /* 0890 */ 0xDC, 0x7B, 0xCE, 0x1B, 0x86, 0xD1, 0x9E, 0x2D, ++ /* 0898 */ 0x7C, 0xCD, 0x78, 0xD6, 0x34, 0x42, 0x38, 0x76, ++ /* 08A0 */ 0x83, 0xF3, 0x48, 0x8C, 0xF0, 0x82, 0xC0, 0x4E, ++ /* 08A8 */ 0x0C, 0x0F, 0x30, 0xC6, 0x39, 0x79, 0xC3, 0xFA, ++ /* 08B0 */ 0xC2, 0xCB, 0x40, 0x83, 0x19, 0xDB, 0x97, 0x01, ++ /* 08B8 */ 0x36, 0x2A, 0xDF, 0x88, 0xC0, 0x97, 0xFC, 0x62, ++ /* 08C0 */ 0x00, 0x65, 0x16, 0xBE, 0x9E, 0xF8, 0xA0, 0xC4, ++ /* 08C8 */ 0x2E, 0x06, 0x2C, 0xE5, 0xC5, 0x00, 0x54, 0x37, ++ /* 08D0 */ 0x0C, 0x5F, 0x0C, 0xE0, 0x5F, 0x89, 0x5E, 0x0C, ++ /* 08D8 */ 0xC0, 0x70, 0x71, 0xF2, 0x3D, 0xC0, 0x1E, 0xEE, ++ /* 08E0 */ 0xA3, 0x74, 0x9C, 0xBE, 0xFD, 0xBD, 0x19, 0xF8, ++ /* 08E8 */ 0x6C, 0xC0, 0x60, 0x3C, 0xC3, 0x30, 0xC6, 0x08, ++ /* 08F0 */ 0xE3, 0x51, 0x86, 0x31, 0xC1, 0xDC, 0xB7, 0x03, ++ /* 08F8 */ 0xE8, 0x39, 0x87, 0x81, 0x4A, 0x78, 0x3B, 0x80, ++ /* 0900 */ 0x72, 0x0E, 0xE8, 0xF2, 0x68, 0x42, 0x4F, 0x01, ++ /* 0908 */ 0x4F, 0x07, 0x3E, 0x29, 0x1A, 0xA2, 0xAF, 0xB1, ++ /* 0910 */ 0x0A, 0x26, 0x50, 0xC4, 0x07, 0x0D, 0x3E, 0xB5, ++ /* 0918 */ 0x28, 0x3E, 0x15, 0x78, 0x2D, 0xCF, 0x4E, 0xE1, ++ /* 0920 */ 0xE2, 0x9C, 0x89, 0xA7, 0x6A, 0x38, 0x03, 0xBD, ++ /* 0928 */ 0xE6, 0x86, 0x63, 0xFF, 0x7F, 0x38, 0xFC, 0xA9, ++ /* 0930 */ 0xE0, 0x35, 0x80, 0x1D, 0x24, 0x3D, 0x2D, 0x23, ++ /* 0938 */ 0xC2, 0x38, 0xA4, 0x3C, 0x32, 0xF8, 0xB6, 0x18, ++ /* 0940 */ 0xC7, 0x90, 0x0F, 0x91, 0xBE, 0x13, 0x18, 0xF2, ++ /* 0948 */ 0x21, 0xEF, 0x79, 0xC7, 0xC0, 0xAF, 0x08, 0x71, ++ /* 0950 */ 0x9E, 0xB2, 0x7C, 0x67, 0xF0, 0x65, 0x01, 0x7C, ++ /* 0958 */ 0x91, 0x2E, 0x0B, 0x68, 0x68, 0x9F, 0x64, 0x7C, ++ /* 0960 */ 0x41, 0x30, 0xEC, 0x89, 0xB3, 0x00, 0x77, 0x05, ++ /* 0968 */ 0x50, 0x81, 0xFA, 0xAE, 0x00, 0xFF, 0x42, 0xF0, ++ /* 0970 */ 0xAE, 0x00, 0x86, 0x79, 0xF9, 0x56, 0xC0, 0x35, ++ /* 0978 */ 0x1D, 0x4A, 0xD0, 0x67, 0x12, 0x5F, 0x17, 0x70, ++ /* 0980 */ 0x53, 0x64, 0xA9, 0x8E, 0x0A, 0xD0, 0x53, 0x4C, ++ /* 0988 */ 0x02, 0x75, 0x47, 0xF7, 0x51, 0x01, 0xC6, 0x4D, ++ /* 0990 */ 0xD9, 0x07, 0x54, 0x76, 0x5A, 0x60, 0x67, 0x21, ++ /* 0998 */ 0x76, 0x1D, 0xC1, 0x5D, 0x49, 0x18, 0xCA, 0xB3, ++ /* 09A0 */ 0x81, 0x2F, 0x59, 0xFC, 0x70, 0x00, 0x03, 0xDC, ++ /* 09A8 */ 0xB3, 0x38, 0xC4, 0x08, 0xB1, 0xD9, 0x81, 0xEB, ++ /* 09B0 */ 0x75, 0xD2, 0x70, 0x2F, 0x44, 0xEC, 0xFF, 0x7F, ++ /* 09B8 */ 0x32, 0x00, 0xE3, 0x51, 0x1B, 0x1C, 0x27, 0x9D, ++ /* 09C0 */ 0xF0, 0x91, 0x9E, 0x59, 0xF8, 0x49, 0x19, 0x30, ++ /* 09C8 */ 0x71, 0xF2, 0x03, 0xE3, 0xC9, 0x1A, 0xC6, 0x00, ++ /* 09D0 */ 0xB8, 0xBC, 0x57, 0x95, 0x81, 0xFC, 0x43, 0x90, ++ /* 09D8 */ 0x20, 0x18, 0xD4, 0x29, 0x19, 0x38, 0x1C, 0xC5, ++ /* 09E0 */ 0x70, 0xA7, 0x64, 0x78, 0x50, 0xF8, 0xC3, 0x00, ++ /* 09E8 */ 0xE6, 0x46, 0xE8, 0x7B, 0x82, 0xA1, 0xDE, 0x93, ++ /* 09F0 */ 0x0E, 0xE3, 0x91, 0xD0, 0x04, 0x3E, 0x2D, 0xC3, ++ /* 09F8 */ 0xFA, 0xFF, 0x9F, 0x96, 0xF9, 0x39, 0x21, 0xFE, ++ /* 0A00 */ 0x53, 0xCE, 0xFB, 0xC5, 0x83, 0xB2, 0x31, 0xA2, ++ /* 0A08 */ 0xBC, 0x2A, 0xFB, 0x9C, 0x69, 0x14, 0x76, 0x4B, ++ /* 0A10 */ 0x7E, 0x73, 0x78, 0x55, 0xF6, 0x69, 0xF9, 0xDC, ++ /* 0A18 */ 0x22, 0xBD, 0x2F, 0x7B, 0xE4, 0x31, 0xE3, 0xC4, ++ /* 0A20 */ 0x0A, 0x12, 0xE8, 0x7D, 0x23, 0x4A, 0xD8, 0x18, ++ /* 0A28 */ 0xE1, 0x02, 0x3D, 0x2D, 0xB3, 0x63, 0xBB, 0x87, ++ /* 0A30 */ 0xEC, 0xB3, 0x02, 0xEE, 0xEC, 0x00, 0x77, 0x7A, ++ /* 0A38 */ 0xFC, 0xF4, 0x00, 0x38, 0x01, 0x7A, 0x7A, 0x00, ++ /* 0A40 */ 0xDB, 0x79, 0x03, 0xEE, 0x81, 0x00, 0x71, 0xFC, ++ /* 0A48 */ 0x47, 0x05, 0xBF, 0xB2, 0x50, 0x38, 0x7E, 0x6C, ++ /* 0A50 */ 0xE7, 0xC7, 0x12, 0xDC, 0xE1, 0xC0, 0x47, 0x06, ++ /* 0A58 */ 0x1F, 0x20, 0x71, 0x43, 0xF1, 0xA1, 0x02, 0x79, ++ /* 0A60 */ 0x16, 0x00, 0xC5, 0xE8, 0xD9, 0x08, 0xD8, 0x0D, ++ /* 0A68 */ 0xE6, 0xA5, 0x25, 0xCA, 0xFF, 0xFF, 0xBD, 0x81, ++ /* 0A70 */ 0x9D, 0x52, 0x70, 0x07, 0x01, 0xF0, 0x1D, 0x03, ++ /* 0A78 */ 0xC0, 0x3B, 0x18, 0x2E, 0x6B, 0xCC, 0x28, 0x21, ++ /* 0A80 */ 0x30, 0x1A, 0x33, 0xEE, 0x10, 0xC2, 0x4F, 0x04, ++ /* 0A88 */ 0xB8, 0x31, 0x7B, 0xDC, 0x1E, 0x33, 0xEE, 0x38, ++ /* 0A90 */ 0xCB, 0x47, 0xF5, 0x94, 0x11, 0xCA, 0x07, 0x0E, ++ /* 0A98 */ 0x76, 0xCE, 0x78, 0x23, 0xE0, 0x43, 0x07, 0x1E, ++ /* 0AA0 */ 0x07, 0x18, 0xDC, 0x91, 0x02, 0x8C, 0x97, 0x03, ++ /* 0AA8 */ 0x36, 0x76, 0x70, 0x07, 0x21, 0xA7, 0x40, 0x96, ++ /* 0AB0 */ 0x0E, 0xA3, 0xB1, 0xE3, 0x64, 0x03, 0xE9, 0x18, ++ /* 0AB8 */ 0xE3, 0x43, 0xAE, 0xC7, 0x8E, 0x1B, 0xAC, 0xC7, ++ /* 0AC0 */ 0x8E, 0x3B, 0xBE, 0x60, 0xFF, 0xFF, 0xC7, 0x17, ++ /* 0AC8 */ 0x30, 0x8C, 0x81, 0x8B, 0x1F, 0x06, 0xFA, 0xE6, ++ /* 0AD0 */ 0xE7, 0xD1, 0x19, 0xDC, 0xC3, 0xF6, 0x09, 0x26, ++ /* 0AD8 */ 0xC6, 0x1B, 0x4C, 0x88, 0x47, 0x96, 0x97, 0x96, ++ /* 0AE0 */ 0x08, 0x0F, 0x2D, 0xBE, 0xB9, 0xBC, 0xB4, 0xF8, ++ /* 0AE8 */ 0x16, 0x63, 0x94, 0x10, 0x11, 0x0E, 0x26, 0xCE, ++ /* 0AF0 */ 0x13, 0x8C, 0x11, 0x0E, 0x3C, 0x8A, 0x21, 0x22, ++ /* 0AF8 */ 0x9C, 0x40, 0x88, 0x93, 0x3E, 0xD9, 0x20, 0xE1, ++ /* 0B00 */ 0x63, 0x84, 0x8D, 0x16, 0xE5, 0x09, 0x86, 0x8D, ++ /* 0B08 */ 0x85, 0x9F, 0x57, 0x3C, 0x78, 0x7E, 0x5A, 0xF3, ++ /* 0B10 */ 0x5D, 0xD0, 0x93, 0x39, 0xC7, 0x87, 0x2C, 0x4F, ++ /* 0B18 */ 0xED, 0x71, 0xD2, 0x87, 0x59, 0xDC, 0xA0, 0x1E, ++ /* 0B20 */ 0x1C, 0xD9, 0x5D, 0xC7, 0xC7, 0x6B, 0xEC, 0x29, ++ /* 0B28 */ 0xC8, 0x43, 0xE0, 0x27, 0x02, 0x5F, 0x10, 0x3D, ++ /* 0B30 */ 0x59, 0xDF, 0xF5, 0xD8, 0xBD, 0xCC, 0x18, 0xD5, ++ /* 0B38 */ 0x4F, 0x01, 0x75, 0x4C, 0x39, 0x83, 0x57, 0x08, ++ /* 0B40 */ 0x76, 0xCF, 0xF3, 0x21, 0xDB, 0x77, 0x49, 0x36, ++ /* 0B48 */ 0x0A, 0xDC, 0x21, 0xC1, 0x67, 0x24, 0x7E, 0xAA, ++ /* 0B50 */ 0xF0, 0x30, 0x3C, 0x0A, 0x18, 0x33, 0x78, 0x47, ++ /* 0B58 */ 0x38, 0xB4, 0x10, 0x07, 0xFC, 0xBE, 0xCB, 0x86, ++ /* 0B60 */ 0x1A, 0xE3, 0xF4, 0x7C, 0xFE, 0x60, 0x83, 0x80, ++ /* 0B68 */ 0x0F, 0x75, 0xA8, 0x1E, 0xE6, 0x51, 0xBD, 0x14, ++ /* 0B70 */ 0x32, 0x9C, 0xB3, 0x83, 0x3B, 0x08, 0xEC, 0xF1, ++ /* 0B78 */ 0xC3, 0x83, 0xE0, 0x37, 0x4B, 0x3E, 0x08, 0x76, ++ /* 0B80 */ 0xBE, 0x79, 0x83, 0x33, 0xC8, 0xFF, 0xFF, 0x18, ++ /* 0B88 */ 0x60, 0x9F, 0xA9, 0x7C, 0x34, 0x41, 0x1C, 0x01, ++ /* 0B90 */ 0xD1, 0xE7, 0x0F, 0x8F, 0xE1, 0x4D, 0x8E, 0x0F, ++ /* 0B98 */ 0x07, 0x7B, 0xF4, 0xC0, 0x9D, 0x44, 0xE0, 0x1E, ++ /* 0BA0 */ 0xBB, 0x0E, 0xDA, 0xD7, 0x38, 0x5F, 0xB4, 0x60, ++ /* 0BA8 */ 0xDC, 0xF7, 0x9E, 0x45, 0xC0, 0x8F, 0xF1, 0xD8, ++ /* 0BB0 */ 0x02, 0x8E, 0x43, 0x09, 0xB8, 0x83, 0x1D, 0xD7, ++ /* 0BB8 */ 0x38, 0x84, 0xA2, 0xC0, 0xE8, 0x50, 0x82, 0x8B, ++ /* 0BC0 */ 0x01, 0x24, 0x18, 0xC7, 0x38, 0xA3, 0xA1, 0x2F, ++ /* 0BC8 */ 0x91, 0x3E, 0xA4, 0xC1, 0x19, 0x34, 0xEC, 0x79, ++ /* 0BD0 */ 0x3E, 0xA1, 0x70, 0x7B, 0x02, 0x14, 0x9D, 0x50, ++ /* 0BD8 */ 0x40, 0x86, 0xFB, 0x0C, 0x82, 0x3D, 0x21, 0xF0, ++ /* 0BE0 */ 0x33, 0x08, 0xFB, 0xFF, 0x1F, 0x1C, 0x3D, 0xEE, ++ /* 0BE8 */ 0xF7, 0x46, 0x9F, 0x1A, 0xD9, 0xDC, 0x1F, 0x02, ++ /* 0BF0 */ 0x4E, 0xE0, 0xDC, 0xD9, 0xA9, 0x19, 0x77, 0x66, ++ /* 0BF8 */ 0xC0, 0x9E, 0x3F, 0x3C, 0x04, 0x7E, 0x2E, 0xF0, ++ /* 0C00 */ 0xF0, 0x3D, 0x04, 0xFC, 0xE0, 0x1F, 0x98, 0x0D, ++ /* 0C08 */ 0x0E, 0xC6, 0x53, 0x84, 0xAF, 0x1D, 0x1C, 0x9C, ++ /* 0C10 */ 0x9F, 0x06, 0x0C, 0xCE, 0x5F, 0xA1, 0x3E, 0xCF, ++ /* 0C18 */ 0x33, 0x70, 0xEC, 0xA9, 0xD7, 0xF7, 0x0E, 0xCF, ++ /* 0C20 */ 0xD7, 0x87, 0x0A, 0xFC, 0x4D, 0xCF, 0x87, 0x0A, ++ /* 0C28 */ 0x70, 0x1C, 0x1E, 0xF8, 0x61, 0x85, 0x0D, 0xE1, ++ /* 0C30 */ 0x51, 0x00, 0x7F, 0x6A, 0xF1, 0xF1, 0x2F, 0xCE, ++ /* 0C38 */ 0x53, 0x04, 0xBB, 0x8D, 0x60, 0x0F, 0x17, 0x80, ++ /* 0C40 */ 0xA3, 0x68, 0x67, 0x31, 0x54, 0x98, 0xB3, 0x18, ++ /* 0C48 */ 0xF9, 0xFF, 0x9F, 0xA3, 0x50, 0x67, 0x31, 0x7A, ++ /* 0C50 */ 0xB8, 0x00, 0x5C, 0x08, 0x3E, 0x1E, 0x80, 0xE6, ++ /* 0C58 */ 0x20, 0xF0, 0xB8, 0xE0, 0x0B, 0xC1, 0x91, 0x1C, ++ /* 0C60 */ 0xC8, 0xD3, 0x01, 0xE0, 0x53, 0x1E, 0x09, 0x3D, ++ /* 0C68 */ 0x1F, 0x59, 0x10, 0x0C, 0xEA, 0x7C, 0xE0, 0x13, ++ /* 0C70 */ 0x8A, 0x8F, 0x1D, 0xFC, 0x6C, 0xE0, 0x1B, 0xB9, ++ /* 0C78 */ 0x87, 0xCA, 0x4F, 0xCD, 0x3E, 0x69, 0xF3, 0xE0, ++ /* 0C80 */ 0x3F, 0x69, 0xD9, 0x80, 0x51, 0xA0, 0x61, 0xA0, ++ /* 0C88 */ 0x46, 0xE4, 0x23, 0xD2, 0xFF, 0xFF, 0xB9, 0x0D, ++ /* 0C90 */ 0x1B, 0x60, 0x68, 0xF4, 0x1C, 0x0E, 0xE3, 0x80, ++ /* 0C98 */ 0xEB, 0x73, 0x38, 0x76, 0x40, 0x3E, 0x87, 0xC3, ++ /* 0CA0 */ 0x3F, 0x47, 0xC3, 0x1F, 0x1B, 0x3B, 0xDD, 0xF3, ++ /* 0CA8 */ 0x81, 0xC1, 0xBA, 0x7E, 0x63, 0x06, 0x06, 0xB6, ++ /* 0CB0 */ 0x6F, 0x91, 0x07, 0x06, 0x1C, 0x51, 0xCF, 0xC6, ++ /* 0CB8 */ 0x57, 0x08, 0x0F, 0x0C, 0x6C, 0x80, 0x1E, 0x18, ++ /* 0CC0 */ 0xF0, 0x89, 0x05, 0x21, 0x27, 0x03, 0x43, 0x9D, ++ /* 0CC8 */ 0x32, 0x8C, 0x1C, 0xF3, 0x89, 0xC3, 0xC3, 0xF0, ++ /* 0CD0 */ 0xA1, 0x22, 0xEA, 0x33, 0xC0, 0x23, 0x1E, 0x1B, ++ /* 0CD8 */ 0x1B, 0xFB, 0xFF, 0x8F, 0x0D, 0x2C, 0xC7, 0x16, ++ /* 0CE0 */ 0x8F, 0x0D, 0xFC, 0x47, 0x78, 0xFC, 0xD8, 0xE0, ++ /* 0CE8 */ 0x8C, 0xE5, 0xD1, 0xC4, 0x97, 0x99, 0x23, 0x3B, ++ /* 0CF0 */ 0x8D, 0x33, 0x7B, 0x0D, 0xF1, 0xD1, 0xEE, 0xF1, ++ /* 0CF8 */ 0xDB, 0x63, 0x03, 0x97, 0x85, 0xB1, 0x01, 0xA5, ++ /* 0D00 */ 0x90, 0x63, 0x43, 0x1F, 0x52, 0x7C, 0x0A, 0xB0, ++ /* 0D08 */ 0x71, 0x54, 0x32, 0x0F, 0x1F, 0xAF, 0x7C, 0x62, ++ /* 0D10 */ 0x38, 0xBA, 0x20, 0x6F, 0xE8, 0xBE, 0x5C, 0xF8, ++ /* 0D18 */ 0x48, 0x63, 0x30, 0x5F, 0x5A, 0x7C, 0x06, 0xE5, ++ /* 0D20 */ 0x43, 0x04, 0x97, 0x86, 0x21, 0x02, 0xA5, 0x50, ++ /* 0D28 */ 0x43, 0x44, 0x8F, 0xE7, 0xFF, 0xFF, 0x08, 0xE6, ++ /* 0D30 */ 0x21, 0xB2, 0xA1, 0x81, 0xF7, 0x1B, 0xA3, 0xA1, ++ /* 0D38 */ 0x01, 0xA1, 0x70, 0x43, 0x43, 0x1F, 0xD6, 0x7C, ++ /* 0D40 */ 0x08, 0x60, 0x10, 0xBE, 0x0D, 0xB0, 0xAB, 0x80, ++ /* 0D48 */ 0xAF, 0x42, 0x1E, 0xE0, 0x93, 0x28, 0x1B, 0x1E, ++ /* 0D50 */ 0xF8, 0x06, 0xE5, 0xE1, 0x01, 0x9F, 0xF0, 0xC0, ++ /* 0D58 */ 0x5E, 0x85, 0x87, 0x47, 0xCF, 0x4A, 0x1E, 0x1E, ++ /* 0D60 */ 0x3C, 0x90, 0xC7, 0x08, 0x76, 0x0E, 0xF1, 0xE0, ++ /* 0D68 */ 0xC0, 0x61, 0x62, 0x70, 0xA0, 0x38, 0xFA, 0xE3, ++ /* 0D70 */ 0x86, 0xC0, 0x2E, 0xB3, 0x9E, 0x38, 0xBF, 0xB2, ++ /* 0D78 */ 0x78, 0x50, 0xF8, 0xFF, 0xFF, 0x11, 0x00, 0xD6, ++ /* 0D80 */ 0x71, 0x06, 0x7C, 0xC1, 0x0E, 0x07, 0xE8, 0x63, ++ /* 0D88 */ 0x22, 0x1B, 0xC3, 0x43, 0xC4, 0x83, 0xAB, 0x07, ++ /* 0D90 */ 0xE2, 0x6B, 0xC7, 0x6B, 0x31, 0xEE, 0x68, 0x00, ++ /* 0D98 */ 0x2E, 0x15, 0x47, 0x03, 0xA0, 0x74, 0xB0, 0x05, ++ /* 0DA0 */ 0xC7, 0x3D, 0xCD, 0x47, 0x3B, 0xCC, 0x1C, 0x3D, ++ /* 0DA8 */ 0x80, 0xE7, 0x37, 0x8F, 0x96, 0x9F, 0xDF, 0x00, ++ /* 0DB0 */ 0x47, 0x41, 0x0F, 0xB6, 0x74, 0xE0, 0x8E, 0x06, ++ /* 0DB8 */ 0x83, 0x3A, 0xBF, 0x61, 0xFE, 0xFF, 0xE7, 0x37, ++ /* 0DC0 */ 0x30, 0x44, 0x00, 0xD7, 0x99, 0xC6, 0xE7, 0x17, ++ /* 0DC8 */ 0x38, 0x43, 0x3D, 0x68, 0x5F, 0x13, 0x3C, 0x6B, ++ /* 0DD0 */ 0xDF, 0xB8, 0xD8, 0x39, 0x01, 0x5C, 0x03, 0xF2, ++ /* 0DD8 */ 0x49, 0x07, 0x38, 0x02, 0x9F, 0xC4, 0x03, 0xFE, ++ /* 0DE0 */ 0xA1, 0x81, 0x79, 0x58, 0x1E, 0x1A, 0xF0, 0x39, ++ /* 0DE8 */ 0x1A, 0xE0, 0x4E, 0x14, 0xE0, 0xB9, 0x8D, 0xE0, ++ /* 0DF0 */ 0x0E, 0x14, 0xC0, 0xE2, 0xFF, 0x7F, 0xA0, 0x00, ++ /* 0DF8 */ 0x56, 0x47, 0x7C, 0x8F, 0x8B, 0x43, 0xE3, 0x10, ++ /* 0E00 */ 0x1F, 0xD2, 0xCE, 0xD9, 0xE7, 0xAF, 0x33, 0xC5, ++ /* 0E08 */ 0x9D, 0x45, 0xC0, 0x70, 0xA2, 0x47, 0xBC, 0xD3, ++ /* 0E10 */ 0x0C, 0xE4, 0x07, 0x86, 0x84, 0xC0, 0xA0, 0x4E, ++ /* 0E18 */ 0x40, 0x1E, 0x8A, 0x0F, 0x06, 0x1C, 0xD8, 0x47, ++ /* 0E20 */ 0x04, 0x76, 0x2E, 0x60, 0x07, 0x28, 0xC3, 0xF1, ++ /* 0E28 */ 0xB3, 0x80, 0x4F, 0x09, 0x0F, 0x35, 0xC7, 0xF1, ++ /* 0E30 */ 0xB8, 0xE9, 0xBB, 0x99, 0x21, 0xD9, 0xD5, 0xE0, ++ /* 0E38 */ 0xF9, 0x07, 0x7B, 0xDA, 0x85, 0x73, 0xC4, 0x05, ++ /* 0E40 */ 0x17, 0x81, 0xCF, 0x3A, 0x1E, 0x05, 0x3F, 0x3D, ++ /* 0E48 */ 0x78, 0x8E, 0x6F, 0x0C, 0x3E, 0x3D, 0x30, 0xF7, ++ /* 0E50 */ 0x02, 0xCC, 0x1D, 0xBA, 0x85, 0x70, 0x4C, 0xAF, ++ /* 0E58 */ 0x0F, 0x31, 0x8E, 0xFA, 0xB1, 0xA1, 0x2D, 0x01, ++ /* 0E60 */ 0xDA, 0x50, 0x74, 0x07, 0x78, 0x19, 0x88, 0x12, ++ /* 0E68 */ 0xE2, 0x08, 0x22, 0xB5, 0x86, 0xA2, 0x99, 0x47, ++ /* 0E70 */ 0x8A, 0x12, 0x30, 0x9E, 0x61, 0x1A, 0x9B, 0x8C, ++ /* 0E78 */ 0x20, 0x63, 0x84, 0x8E, 0x13, 0x2C, 0x4A, 0xB4, ++ /* 0E80 */ 0x57, 0x80, 0xF6, 0x47, 0xCB, 0x56, 0xAC, 0xB1, ++ /* 0E88 */ 0x38, 0xD2, 0xC9, 0x12, 0x3D, 0x6C, 0x1F, 0xB3, ++ /* 0E90 */ 0xF1, 0xA7, 0x55, 0xCC, 0xFF, 0x9F, 0xE0, 0x55, ++ /* 0E98 */ 0xC5, 0x07, 0x05, 0x1F, 0x00, 0xF0, 0x2E, 0x01, ++ /* 0EA0 */ 0x75, 0x75, 0xF4, 0xB8, 0x7D, 0xDE, 0x00, 0xFF, ++ /* 0EA8 */ 0xF5, 0x02, 0x4B, 0x50, 0xFE, 0x20, 0x50, 0x23, ++ /* 0EB0 */ 0x33, 0xB4, 0xC7, 0xF9, 0x36, 0x63, 0xC8, 0x27, ++ /* 0EB8 */ 0x27, 0x13, 0x58, 0xEC, 0x09, 0x15, 0x68, 0x0C, ++ /* 0EC0 */ 0xFE, 0x69, 0xC3, 0xD7, 0x76, 0xCF, 0xD7, 0xE7, ++ /* 0EC8 */ 0x38, 0x80, 0x0F, 0xFF, 0xFF, 0x73, 0x1C, 0x60, ++ /* 0ED0 */ 0x68, 0x38, 0xB8, 0xA3, 0x0F, 0xDC, 0x2B, 0x09, ++ /* 0ED8 */ 0x3F, 0xFC, 0x00, 0xCE, 0x80, 0x1E, 0x7E, 0xC0, ++ /* 0EE0 */ 0x3E, 0x54, 0xDC, 0x10, 0x78, 0x84, 0x15, 0xD1, ++ /* 0EE8 */ 0xC3, 0x80, 0x45, 0xC3, 0xA0, 0xCE, 0x6B, 0xD8, ++ /* 0EF0 */ 0xFF, 0xFF, 0x79, 0x0D, 0xB6, 0x38, 0x70, 0x1D, ++ /* 0EF8 */ 0x54, 0x7D, 0x36, 0x86, 0x33, 0xA8, 0xD3, 0xEE, ++ /* 0F00 */ 0xFD, 0xAE, 0x40, 0x2E, 0x22, 0x1E, 0xF4, 0xF9, ++ /* 0F08 */ 0x3C, 0x3B, 0xB0, 0x03, 0x1B, 0xF0, 0x1F, 0x1B, ++ /* 0F10 */ 0x9C, 0x1B, 0xC0, 0x53, 0x74, 0x84, 0x63, 0x03, ++ /* 0F18 */ 0xFB, 0x89, 0x0D, 0x38, 0x9D, 0xED, 0xE0, 0x5C, ++ /* 0F20 */ 0xA1, 0xD8, 0x6D, 0x1F, 0x37, 0x34, 0xB0, 0xD9, ++ /* 0F28 */ 0x18, 0x1A, 0xC8, 0xFE, 0xFF, 0x87, 0x4F, 0xE0, ++ /* 0F30 */ 0x75, 0xE8, 0xE2, 0x97, 0x8A, 0xE7, 0x2F, 0x7E, ++ /* 0F38 */ 0xB8, 0x03, 0x9C, 0x4B, 0x3B, 0xD9, 0xA1, 0xC4, ++ /* 0F40 */ 0x1C, 0xEE, 0x00, 0x29, 0xFF, 0xFF, 0xC3, 0x1D, ++ /* 0F48 */ 0xB8, 0xEE, 0x72, 0xEF, 0x0C, 0x2F, 0x0D, 0x9E, ++ /* 0F50 */ 0xD3, 0xBB, 0x9D, 0x31, 0x5E, 0xEA, 0x8C, 0x10, ++ /* 0F58 */ 0x85, 0xDD, 0x06, 0xA2, 0xD9, 0xDB, 0xE1, 0x8E, ++ /* 0F60 */ 0x9C, 0xF0, 0x38, 0x66, 0xA4, 0x27, 0xBD, 0x60, ++ /* 0F68 */ 0x91, 0x22, 0x1E, 0x4E, 0x94, 0x10, 0xC1, 0x5E, ++ /* 0F70 */ 0x27, 0x9E, 0xF2, 0x1E, 0xEE, 0x98, 0x90, 0xC3, ++ /* 0F78 */ 0x1D, 0xD0, 0x71, 0x7D, 0xB8, 0x03, 0x2A, 0x27, ++ /* 0F80 */ 0x2A, 0xFC, 0xE1, 0x0E, 0x30, 0xFB, 0xFF, 0x3F, ++ /* 0F88 */ 0xDC, 0x01, 0x8C, 0x3A, 0xA3, 0xE1, 0x0E, 0x77, ++ /* 0F90 */ 0x60, 0x3B, 0xFD, 0x00, 0xE7, 0xFF, 0xFF, 0xE9, ++ /* 0F98 */ 0x07, 0x78, 0x8F, 0x15, 0xC6, 0x18, 0x78, 0xB4, ++ /* 0FA0 */ 0x25, 0x51, 0x20, 0x87, 0x81, 0x41, 0x11, 0x38, ++ /* 0FA8 */ 0xC8, 0xA1, 0x8E, 0x06, 0x3B, 0xBD, 0x40, 0x99, ++ /* 0FB0 */ 0xCB, 0x81, 0x9E, 0xC2, 0x33, 0x82, 0x0F, 0x60, ++ /* 0FB8 */ 0x60, 0x3F, 0xD5, 0x01, 0x87, 0x53, 0x03, 0x3E, ++ /* 0FC0 */ 0xD0, 0x09, 0x05, 0x3D, 0x0A, 0x9F, 0x4D, 0xC0, ++ /* 0FC8 */ 0x7B, 0xA4, 0x03, 0x36, 0xFF, 0xFF, 0xB3, 0x09, ++ /* 0FD0 */ 0x7B, 0x35, 0xFA, 0x6C, 0x82, 0x63, 0x31, 0xEA, ++ /* 0FD8 */ 0x1B, 0xC4, 0x21, 0xBE, 0x74, 0xF8, 0xDC, 0xF8, ++ /* 0FE0 */ 0x4E, 0xE3, 0x4B, 0x00, 0xE6, 0xFA, 0x61, 0x82, ++ /* 0FE8 */ 0x31, 0x21, 0xF4, 0xC9, 0xF2, 0xA9, 0x0E, 0x38, ++ /* 0FF0 */ 0x1D, 0x4E, 0xE0, 0x8D, 0x1E, 0x77, 0x5A, 0xF0, ++ /* 0FF8 */ 0x70, 0x38, 0xB8, 0x67, 0xF3, 0x2C, 0xF1, 0x44, ++ /* 1000 */ 0xE4, 0x71, 0xF8, 0x74, 0x02, 0xBC, 0x0E, 0x18, ++ /* 1008 */ 0x98, 0x19, 0x84, 0x7F, 0x08, 0x61, 0xA7, 0x4F, ++ /* 1010 */ 0x1F, 0x99, 0x3C, 0xF7, 0x77, 0x23, 0x9F, 0x4E, ++ /* 1018 */ 0x00, 0x5F, 0xFF, 0xFF, 0xA3, 0x1E, 0xB0, 0x90, ++ /* 1020 */ 0xA8, 0xE1, 0x9C, 0x87, 0x11, 0x05, 0x83, 0x3A, ++ /* 1028 */ 0xEA, 0x01, 0xD6, 0x2E, 0x7A, 0x36, 0x86, 0xA0, ++ /* 1030 */ 0x8B, 0xC0, 0x19, 0x84, 0x78, 0xBC, 0x7B, 0xC5, ++ /* 1038 */ 0x8B, 0xE4, 0x3B, 0x40, 0x9C, 0x47, 0x3D, 0x83, ++ /* 1040 */ 0xBD, 0x7D, 0x3C, 0x48, 0x44, 0x89, 0xF3, 0xA8, ++ /* 1048 */ 0xE7, 0xD1, 0x87, 0xF2, 0xE4, 0x43, 0x9D, 0x7E, ++ /* 1050 */ 0xAC, 0xB0, 0x81, 0x9E, 0xF8, 0x5E, 0xF4, 0x42, ++ /* 1058 */ 0x1A, 0xE1, 0x51, 0x8F, 0x09, 0x7A, 0x79, 0xE8, ++ /* 1060 */ 0x70, 0xE5, 0xA3, 0x1E, 0x60, 0xE5, 0xFF, 0x7F, ++ /* 1068 */ 0xD4, 0x03, 0xF8, 0xFF, 0xFF, 0x3F, 0xEA, 0x81, ++ /* 1070 */ 0xF9, 0xF4, 0x04, 0xF8, 0x3F, 0xD6, 0xE0, 0x8E, ++ /* 1078 */ 0x8A, 0x60, 0x3B, 0x3F, 0x01, 0x2E, 0xFE, 0xFF, ++ /* 1080 */ 0xE7, 0x27, 0x30, 0x0D, 0xDD, 0xE7, 0x27, 0x30, ++ /* 1088 */ 0x8F, 0x16, 0xE6, 0x01, 0x01, 0x71, 0x56, 0x44, ++ /* 1090 */ 0x85, 0x7F, 0xC8, 0x18, 0x0E, 0x15, 0x1C, 0x48, ++ /* 1098 */ 0xBF, 0x28, 0x1F, 0x01, 0x81, 0xCB, 0x51, 0x11, ++ /* 10A0 */ 0x38, 0x9C, 0x59, 0xF0, 0x42, 0x4E, 0x1D, 0xE8, ++ /* 10A8 */ 0xF1, 0x18, 0xF4, 0x95, 0xC3, 0x57, 0x02, 0x7E, ++ /* 10B0 */ 0xE4, 0x60, 0xA1, 0x8F, 0x1C, 0xA0, 0x3A, 0x2C, ++ /* 10B8 */ 0x82, 0xEF, 0xC8, 0x01, 0x8E, 0xEB, 0x55, 0x60, ++ /* 10C0 */ 0xFE, 0xFF, 0x07, 0x66, 0xB7, 0x83, 0xD7, 0x4F, ++ /* 10C8 */ 0x4F, 0xE2, 0x31, 0xEA, 0x38, 0x43, 0x14, 0x8E, ++ /* 10D0 */ 0x49, 0x0E, 0x06, 0x91, 0xDE, 0xC1, 0xD8, 0x00, ++ /* 10D8 */ 0x5F, 0x5E, 0x7C, 0xA8, 0xF2, 0x31, 0x10, 0x18, ++ /* 10E0 */ 0x42, 0x9C, 0x0D, 0x3F, 0x5D, 0x18, 0xF3, 0x74, ++ /* 10E8 */ 0xF8, 0x31, 0x10, 0xB0, 0x2E, 0xF5, 0x0C, 0x88, ++ /* 10F0 */ 0x12, 0x77, 0x0C, 0x04, 0x52, 0xFF, 0xFF, 0x63, ++ /* 10F8 */ 0x20, 0x70, 0xBD, 0x04, 0x7A, 0xCC, 0x67, 0xFC, ++ /* 1100 */ 0xE6, 0xF7, 0xE4, 0x17, 0xA5, 0xB6, 0xEB, 0x9F, ++ /* 1108 */ 0xEE, 0x06, 0xC6, 0x7A, 0x08, 0x78, 0x02, 0xF4, ++ /* 1110 */ 0xFD, 0xCF, 0xC7, 0x8A, 0x28, 0x01, 0xA3, 0xC4, ++ /* 1118 */ 0x7A, 0x11, 0x34, 0x66, 0x8C, 0x60, 0xEF, 0x80, ++ /* 1120 */ 0x31, 0x1F, 0x09, 0x3D, 0xC2, 0x68, 0xC1, 0x0D, ++ /* 1128 */ 0xF4, 0x18, 0xC8, 0x84, 0x1D, 0x03, 0x01, 0x12, ++ /* 1130 */ 0xFD, 0xFF, 0x8F, 0x81, 0x00, 0x23, 0x4F, 0x50, ++ /* 1138 */ 0xC0, 0xF6, 0xFF, 0x7F, 0x82, 0x02, 0x0C, 0x1D, ++ /* 1140 */ 0x05, 0xC1, 0x7C, 0x86, 0x02, 0xAC, 0x1D, 0x05, ++ /* 1148 */ 0xC1, 0x3E, 0x5A, 0x98, 0xA3, 0xE0, 0x82, 0x5E, ++ /* 1150 */ 0x1E, 0x06, 0xA2, 0x12, 0x24, 0xFC, 0xFF, 0x8F, ++ /* 1158 */ 0x82, 0xD8, 0xF8, 0x6B, 0x13, 0x8C, 0x43, 0x9D, ++ /* 1160 */ 0x5E, 0xD0, 0x07, 0x05, 0x0F, 0xFB, 0xA9, 0xC0, ++ /* 1168 */ 0x93, 0x38, 0x55, 0x5F, 0x0B, 0x8E, 0xE2, 0x09, ++ /* 1170 */ 0xC0, 0x87, 0x41, 0xE0, 0x3F, 0x34, 0x58, 0x93, ++ /* 1178 */ 0x28, 0x7E, 0x68, 0xA0, 0x3E, 0x7B, 0x80, 0x6F, ++ /* 1180 */ 0x68, 0xE0, 0x88, 0x7A, 0xC6, 0x41, 0x9F, 0x88, ++ /* 1188 */ 0x7C, 0x36, 0x88, 0xF9, 0xE6, 0x11, 0xE1, 0xC9, ++ /* 1190 */ 0xC3, 0xD7, 0x07, 0x76, 0xF2, 0xF4, 0xA9, 0x29, ++ /* 1198 */ 0x50, 0x94, 0xF7, 0x0D, 0x1E, 0xE7, 0x94, 0x03, ++ /* 11A0 */ 0xAA, 0xC3, 0x2F, 0x38, 0x0E, 0xBC, 0x30, 0xFE, ++ /* 11A8 */ 0xFF, 0x07, 0x5E, 0x76, 0x9C, 0xF2, 0xB1, 0x04, ++ /* 11B0 */ 0x7C, 0x67, 0x52, 0x38, 0x37, 0x17, 0xDF, 0xF1, ++ /* 11B8 */ 0xD8, 0x69, 0x00, 0x6C, 0x3A, 0x4E, 0x03, 0x40, ++ /* 11C0 */ 0xE9, 0x58, 0xC5, 0xCF, 0x93, 0x60, 0x82, 0x39, ++ /* 11C8 */ 0x98, 0xF7, 0x6B, 0x7B, 0x3F, 0xDE, 0xD0, 0xD3, ++ /* 11D0 */ 0x24, 0xE0, 0xF8, 0xFF, 0x7F, 0x9A, 0x84, 0x21, ++ /* 11D8 */ 0xE2, 0x28, 0x89, 0x8A, 0xFD, 0x90, 0xF2, 0x69, ++ /* 11E0 */ 0x12, 0x90, 0x77, 0x67, 0x30, 0xC2, 0xF9, 0x87, ++ /* 11E8 */ 0x78, 0x80, 0x08, 0xF1, 0x20, 0x69, 0x90, 0x38, ++ /* 11F0 */ 0x41, 0x5E, 0x06, 0x9E, 0x26, 0x7D, 0x99, 0x8C, ++ /* 11F8 */ 0xF3, 0x40, 0x19, 0xE5, 0x75, 0xD2, 0x08, 0x47, ++ /* 1200 */ 0x1F, 0xCF, 0x40, 0x2F, 0x92, 0x21, 0x5E, 0x25, ++ /* 1208 */ 0x1F, 0x2C, 0xDF, 0x27, 0x8D, 0x16, 0x2B, 0xF8, ++ /* 1210 */ 0x31, 0x3E, 0x4D, 0xB2, 0xC8, 0x2B, 0xD6, 0x69, ++ /* 1218 */ 0x12, 0xB0, 0xF9, 0xFF, 0x3F, 0x4D, 0x02, 0xFC, ++ /* 1220 */ 0xFF, 0xFF, 0x9F, 0x1D, 0xD8, 0xC1, 0x0A, 0x38, ++ /* 1228 */ 0x1E, 0xC3, 0xC0, 0x71, 0xB0, 0x02, 0x2E, 0xE7, ++ /* 1230 */ 0x79, 0xF0, 0x1C, 0x1F, 0x61, 0x1C, 0x99, 0x00, ++ /* 1238 */ 0xD7, 0xFF, 0xFF, 0xB1, 0xC2, 0x18, 0x03, 0x4F, ++ /* 1240 */ 0xF6, 0x34, 0xA0, 0xC7, 0x01, 0x8B, 0x3A, 0x30, ++ /* 1248 */ 0x09, 0x86, 0xB3, 0xF8, 0xB0, 0xE0, 0x23, 0x02, ++ /* 1250 */ 0x3F, 0x2C, 0x78, 0x04, 0x15, 0x8F, 0x93, 0x1E, ++ /* 1258 */ 0x8B, 0x7C, 0x98, 0x64, 0x87, 0x04, 0x1F, 0x42, ++ /* 1260 */ 0x3C, 0x48, 0x9F, 0x50, 0xC1, 0x73, 0xB0, 0x82, ++ /* 1268 */ 0x77, 0x5D, 0x82, 0x73, 0x2A, 0x00, 0xDC, 0x68, ++ /* 1270 */ 0x57, 0x71, 0xBA, 0x60, 0x01, 0x0E, 0x60, 0xB2, ++ /* 1278 */ 0x71, 0x0C, 0xA1, 0x1C, 0x8E, 0xF9, 0xF6, 0xD0, ++ /* 1280 */ 0x34, 0xD9, 0x91, 0x0C, 0x66, 0x2C, 0x48, 0x9D, ++ /* 1288 */ 0x04, 0x3C, 0x00, 0x07, 0x82, 0x91, 0x76, 0x12, ++ /* 1290 */ 0x8D, 0xC6, 0x70, 0x56, 0x0B, 0x23, 0x38, 0x83, ++ /* 1298 */ 0xF8, 0x38, 0xE2, 0x5C, 0x47, 0x2A, 0xF4, 0x6E, ++ /* 12A0 */ 0x74, 0x9C, 0x42, 0x05, 0xB9, 0x97, 0xD0, 0x79, ++ /* 12A8 */ 0xFB, 0x6E, 0xC0, 0xDF, 0x69, 0x1E, 0x8B, 0x81, ++ /* 12B0 */ 0x7D, 0x43, 0xF0, 0xFF, 0xFF, 0x76, 0x02, 0x7F, ++ /* 12B8 */ 0x2E, 0x56, 0x03, 0x8A, 0x1A, 0x80, 0xD1, 0x30, ++ /* 12C0 */ 0xA7, 0x80, 0xA7, 0x12, 0x70, 0x05, 0x9B, 0x1B, ++ /* 12C8 */ 0xFA, 0xC2, 0x62, 0xAD, 0x53, 0xD1, 0xF1, 0xE9, ++ /* 12D0 */ 0x7D, 0xE0, 0xE0, 0x80, 0xC7, 0xEC, 0x3D, 0x38, ++ /* 12D8 */ 0x58, 0x68, 0x1E, 0x1C, 0xD8, 0xB2, 0x0D, 0x0E, ++ /* 12E0 */ 0xAD, 0xE4, 0x2E, 0x42, 0x0E, 0x1F, 0xF8, 0xD9, ++ /* 12E8 */ 0x01, 0x07, 0x40, 0xCF, 0x0E, 0x16, 0x92, 0x67, ++ /* 12F0 */ 0x07, 0x36, 0x7D, 0x67, 0x11, 0x50, 0x00, 0xF9, ++ /* 12F8 */ 0xDE, 0xE1, 0x73, 0xCB, 0xFF, 0xFF, 0xD9, 0x83, ++ /* 1300 */ 0x8D, 0xE1, 0xD1, 0xC5, 0x68, 0x46, 0xE7, 0x9A, ++ /* 1308 */ 0x6E, 0x13, 0x28, 0x15, 0xB7, 0x09, 0x0A, 0xE2, ++ /* 1310 */ 0x1B, 0x80, 0x13, 0xD2, 0xE8, 0x9E, 0x86, 0x9B, ++ /* 1318 */ 0x89, 0xF1, 0x1F, 0x31, 0x7C, 0x44, 0x38, 0xA4, ++ /* 1320 */ 0xB3, 0x35, 0xC1, 0x3C, 0x90, 0x7A, 0x3F, 0xFA, ++ /* 1328 */ 0xB2, 0x87, 0x9F, 0x7D, 0xC8, 0x07, 0x17, 0x4F, ++ /* 1330 */ 0xC3, 0xD7, 0x1B, 0x72, 0xEF, 0xA0, 0xD3, 0xF6, ++ /* 1338 */ 0x99, 0x01, 0x73, 0x42, 0xF6, 0x75, 0x2A, 0x81, ++ /* 1340 */ 0x65, 0x5D, 0x25, 0xA8, 0x87, 0x0B, 0x08, 0xBD, ++ /* 1348 */ 0xD0, 0xF8, 0x5E, 0x98, 0xE0, 0xE1, 0xCC, 0xB7, ++ /* 1350 */ 0xB3, 0xF7, 0x12, 0x76, 0x38, 0x4C, 0xF0, 0x6E, ++ /* 1358 */ 0x98, 0x60, 0xDE, 0x41, 0xA0, 0x46, 0xE5, 0x41, ++ /* 1360 */ 0x60, 0x2E, 0xFF, 0x2C, 0xDF, 0x18, 0x50, 0xC9, ++ /* 1368 */ 0x2E, 0x5A, 0xF4, 0x0C, 0xF3, 0x0E, 0xE3, 0x4B, ++ /* 1370 */ 0x82, 0xAF, 0x1F, 0x3E, 0xB7, 0x78, 0x01, 0xAF, ++ /* 1378 */ 0x5B, 0x30, 0x08, 0x9E, 0x81, 0x5E, 0x5D, 0x7C, ++ /* 1380 */ 0xCB, 0x37, 0xF0, 0xAB, 0xC0, 0x1B, 0x4D, 0x88, ++ /* 1388 */ 0x60, 0x86, 0x3D, 0xFC, 0xB7, 0x7D, 0xA3, 0xFA, ++ /* 1390 */ 0xA6, 0x63, 0xAC, 0xD7, 0x11, 0x8F, 0x94, 0x1F, ++ /* 1398 */ 0x5B, 0x0E, 0x28, 0xD2, 0x5B, 0x9F, 0x27, 0xE0, ++ /* 13A0 */ 0xB3, 0x8C, 0x8F, 0x83, 0x27, 0xE5, 0x7B, 0xA5, ++ /* 13A8 */ 0xD1, 0x5F, 0x21, 0x7C, 0xF8, 0x31, 0xB2, 0xCF, ++ /* 13B0 */ 0x39, 0xEC, 0x60, 0xC8, 0x06, 0xC5, 0x11, 0x1F, ++ /* 13B8 */ 0x18, 0x5E, 0x6A, 0x3C, 0x15, 0x76, 0xEE, 0x82, ++ /* 13C0 */ 0x71, 0x70, 0x60, 0xC7, 0x22, 0xCC, 0x51, 0x0F, ++ /* 13C8 */ 0x5C, 0x27, 0x1B, 0x03, 0xB3, 0xFF, 0xFF, 0xC9, ++ /* 13D0 */ 0x01, 0x9C, 0xF0, 0x98, 0x13, 0xB3, 0xCF, 0x1B, ++ /* 13D8 */ 0xBE, 0x19, 0x78, 0x5C, 0xFC, 0xC8, 0xE1, 0xE3, ++ /* 13E0 */ 0x1D, 0xC3, 0x3E, 0x4D, 0x1F, 0x8D, 0x5E, 0xDE, ++ /* 13E8 */ 0x7C, 0x7A, 0xC1, 0xC0, 0xFA, 0xD2, 0xC0, 0x61, ++ /* 13F0 */ 0x8D, 0x16, 0xF6, 0x31, 0xE0, 0xCC, 0x7D, 0x21, ++ /* 13F8 */ 0xC2, 0x9D, 0x3A, 0xC1, 0x02, 0x88, 0xBF, 0x95, ++ /* 1400 */ 0x3C, 0x72, 0x78, 0x02, 0x06, 0x64, 0xB9, 0xD7, ++ /* 1408 */ 0xA5, 0x03, 0x11, 0x3F, 0xE5, 0x59, 0xDD, 0x81, ++ /* 1410 */ 0x08, 0x81, 0xF1, 0x38, 0xFA, 0xF8, 0xE1, 0xD9, ++ /* 1418 */ 0xF8, 0x28, 0xE0, 0x63, 0x94, 0x67, 0x7E, 0x46, ++ /* 1420 */ 0x91, 0x5E, 0x19, 0xAC, 0xE5, 0x44, 0x84, 0x52, ++ /* 1428 */ 0x01, 0xA3, 0xC0, 0x34, 0xBA, 0x73, 0xF0, 0x88, ++ /* 1430 */ 0x30, 0x82, 0x33, 0x88, 0x47, 0xEB, 0x9B, 0x0B, ++ /* 1438 */ 0x30, 0x3D, 0x13, 0x01, 0x97, 0xEB, 0xA5, 0x71, ++ /* 1440 */ 0xFD, 0xFF, 0xBF, 0x2C, 0x62, 0xA7, 0x6D, 0xDC, ++ /* 1448 */ 0x57, 0x54, 0x9F, 0x8E, 0x3D, 0xF1, 0xD3, 0x86, ++ /* 1450 */ 0x71, 0x32, 0x02, 0x7C, 0xDC, 0x75, 0x00, 0xFE, ++ /* 1458 */ 0xFC, 0xFF, 0xEF, 0x3A, 0x00, 0xB7, 0xEE, 0x0F, ++ /* 1460 */ 0xBE, 0xEB, 0x00, 0xD7, 0x48, 0xAB, 0xA2, 0x22, ++ /* 1468 */ 0x7E, 0x0B, 0x0A, 0x01, 0x83, 0x1A, 0x9D, 0xAF, ++ /* 1470 */ 0x15, 0xF8, 0x63, 0x09, 0x23, 0xF8, 0xFF, 0x07, ++ /* 1478 */ 0xF7, 0x79, 0xC5, 0x70, 0x7C, 0xE0, 0x1E, 0xDF, ++ /* 1480 */ 0xEB, 0xCA, 0x69, 0x3D, 0x1B, 0xF8, 0xC6, 0x62, ++ /* 1488 */ 0x48, 0x76, 0x41, 0xC5, 0xDD, 0x2F, 0x7C, 0xA3, ++ /* 1490 */ 0xF6, 0x54, 0x5F, 0x14, 0xDE, 0x13, 0x7C, 0x47, ++ /* 1498 */ 0x60, 0x50, 0x30, 0xEE, 0xA8, 0x98, 0x03, 0x2A, ++ /* 14A0 */ 0x1C, 0x82, 0x33, 0x3E, 0x0A, 0xCC, 0x20, 0x7D, ++ /* 14A8 */ 0x48, 0x79, 0x3D, 0xF0, 0x60, 0x99, 0xFB, 0xE3, ++ /* 14B0 */ 0x86, 0x2E, 0x11, 0x0F, 0x1B, 0x4F, 0x06, 0xCD, ++ /* 14B8 */ 0xA1, 0xE8, 0x4C, 0x70, 0x0A, 0x6D, 0x0D, 0x4B, ++ /* 14C0 */ 0x38, 0xEF, 0x1B, 0x21, 0xA2, 0x04, 0x7B, 0xE1, ++ /* 14C8 */ 0x78, 0x63, 0x78, 0x9A, 0x8D, 0x12, 0x2F, 0x52, ++ /* 14D0 */ 0xC0, 0x68, 0x51, 0x82, 0xF5, 0x06, 0x21, 0xD0, ++ /* 14D8 */ 0x48, 0x21, 0x02, 0x86, 0x28, 0x0E, 0x4B, 0x70, ++ /* 14E0 */ 0xD1, 0xDB, 0xBF, 0xC6, 0xB3, 0x37, 0x81, 0x8E, ++ /* 14E8 */ 0x32, 0x8E, 0x74, 0xDC, 0x41, 0x0F, 0xDB, 0x37, ++ /* 14F0 */ 0x56, 0x7E, 0xBE, 0xF7, 0xB8, 0x7C, 0x01, 0xC5, ++ /* 14F8 */ 0x10, 0xBC, 0x66, 0xF8, 0x0B, 0xE0, 0x03, 0x00, ++ /* 1500 */ 0xDE, 0x35, 0xA0, 0x66, 0xFE, 0x78, 0x00, 0x96, ++ /* 1508 */ 0xEB, 0x35, 0xF8, 0xE4, 0x0F, 0x02, 0x75, 0x99, ++ /* 1510 */ 0xE1, 0x67, 0x0F, 0xDF, 0x5C, 0x7D, 0x0F, 0x38, ++ /* 1518 */ 0x2C, 0x76, 0xEB, 0xE6, 0xE3, 0x01, 0xFF, 0xFF, ++ /* 1520 */ 0x7F, 0xE8, 0x2F, 0xBD, 0x3E, 0x54, 0x78, 0xBE, ++ /* 1528 */ 0xBE, 0xFA, 0xFA, 0xF6, 0x0D, 0xDE, 0xCB, 0x31, ++ /* 1530 */ 0x60, 0x4F, 0xF0, 0x0D, 0x1C, 0xE4, 0xE3, 0x05, ++ /* 1538 */ 0xC3, 0x38, 0xB8, 0x72, 0x12, 0x7A, 0x2C, 0xB0, ++ /* 1540 */ 0x56, 0x18, 0xD4, 0x2D, 0x1C, 0x5C, 0x9A, 0xC0, ++ /* 1548 */ 0x75, 0x55, 0xF6, 0xA1, 0xC6, 0x87, 0x60, 0xFC, ++ /* 1550 */ 0xF9, 0x02, 0x17, 0x60, 0xC8, 0xF4, 0x54, 0x06, ++ /* 1558 */ 0xE3, 0x9A, 0xE2, 0x53, 0x19, 0xFB, 0xFF, 0x9F, ++ /* 1560 */ 0xCA, 0x7C, 0x77, 0xF0, 0x80, 0x7C, 0xC4, 0x00, ++ /* 1568 */ 0x3E, 0xAB, 0xF0, 0xC0, 0x70, 0xA7, 0x05, 0xDF, ++ /* 1570 */ 0x94, 0x0C, 0x7A, 0x8E, 0x41, 0x7D, 0xE4, 0x39, ++ /* 1578 */ 0x79, 0xDF, 0x13, 0x1E, 0x27, 0x1C, 0xF5, 0x1C, ++ /* 1580 */ 0x44, 0xC7, 0x06, 0x8E, 0xE3, 0x06, 0x38, 0x0E, ++ /* 1588 */ 0x37, 0xB8, 0x73, 0x1E, 0x1B, 0x17, 0x06, 0xEE, ++ /* 1590 */ 0xB9, 0xC0, 0xC3, 0xF0, 0x4D, 0xC7, 0x23, 0xC2, ++ /* 1598 */ 0x8C, 0xFF, 0x51, 0xCF, 0x08, 0x01, 0xF1, 0x17, ++ /* 15A0 */ 0x23, 0x36, 0x60, 0x30, 0xDE, 0xDA, 0x7C, 0x7D, ++ /* 15A8 */ 0xC3, 0x0D, 0xD8, 0x57, 0x07, 0x5F, 0x30, 0x7C, ++ /* 15B0 */ 0x02, 0x33, 0xFA, 0x0B, 0xCC, 0x93, 0x98, 0x8F, ++ /* 15B8 */ 0x0D, 0xE4, 0x02, 0x47, 0x07, 0x0C, 0x0E, 0x40, ++ /* 15C0 */ 0x0F, 0x18, 0xFE, 0xE1, 0xE2, 0x5D, 0x0E, 0x0C, ++ /* 15C8 */ 0x57, 0x41, 0xFF, 0xFF, 0x8F, 0x0B, 0x3E, 0xF6, ++ /* 15D0 */ 0x58, 0xD1, 0x5D, 0x0E, 0x7D, 0x93, 0x33, 0x4C, ++ /* 15D8 */ 0x1C, 0x43, 0xBC, 0x81, 0xB1, 0xBB, 0x04, 0x39, ++ /* 15E0 */ 0xCC, 0x41, 0xBD, 0x4B, 0x78, 0x0E, 0xFC, 0x6C, ++ /* 15E8 */ 0xE1, 0x13, 0x9C, 0x6F, 0x3E, 0x21, 0x4E, 0xF5, ++ /* 15F0 */ 0xD1, 0xEA, 0x3D, 0xC0, 0x47, 0x8F, 0xF7, 0x2E, ++ /* 15F8 */ 0x9F, 0x9D, 0xD8, 0x45, 0xC0, 0x47, 0x2E, 0xE3, ++ /* 1600 */ 0x78, 0x9A, 0xBE, 0x02, 0x7A, 0xC8, 0x06, 0x7B, ++ /* 1608 */ 0xD5, 0xF0, 0x09, 0xCC, 0x47, 0x37, 0xDC, 0x31, ++ /* 1610 */ 0xCA, 0x33, 0xF1, 0xF4, 0x7D, 0x07, 0x61, 0x47, ++ /* 1618 */ 0x92, 0xA3, 0x0E, 0x75, 0x4D, 0x8F, 0x28, 0x27, ++ /* 1620 */ 0x74, 0x20, 0xBE, 0xB5, 0x81, 0x33, 0xDA, 0xFD, ++ /* 1628 */ 0x03, 0xBD, 0x4D, 0x8F, 0x0C, 0x73, 0x34, 0x80, ++ /* 1630 */ 0x75, 0x09, 0x01, 0xD7, 0x1D, 0xC3, 0x97, 0x10, ++ /* 1638 */ 0xE0, 0x13, 0xF4, 0x12, 0x81, 0xBE, 0x66, 0x78, ++ /* 1640 */ 0x74, 0x8F, 0x00, 0x98, 0x2B, 0x06, 0x3B, 0x16, ++ /* 1648 */ 0xF8, 0xB0, 0xE1, 0x6B, 0x00, 0xBB, 0x17, 0x38, ++ /* 1650 */ 0xCC, 0x3D, 0x02, 0xE2, 0xFF, 0x7F, 0x78, 0x30, ++ /* 1658 */ 0x40, 0x3D, 0x3C, 0xF8, 0x6A, 0xEF, 0x11, 0xA0, ++ /* 1660 */ 0x38, 0x59, 0xFA, 0xD0, 0xE0, 0x81, 0x5A, 0xD5, ++ /* 1668 */ 0x19, 0x13, 0xCA, 0x11, 0x93, 0x43, 0x45, 0x63, ++ /* 1670 */ 0xB7, 0x02, 0x76, 0xBB, 0xF4, 0x4D, 0x02, 0x6E, ++ /* 1678 */ 0x9E, 0x59, 0xA0, 0x92, 0xDC, 0x24, 0xA0, 0xC3, ++ /* 1680 */ 0x74, 0x79, 0x99, 0xA1, 0xF3, 0x3F, 0x70, 0xDF, ++ /* 1688 */ 0xEA, 0x3C, 0x42, 0x1F, 0x22, 0x18, 0xCA, 0x7B, ++ /* 1690 */ 0x9E, 0x4F, 0x61, 0xFC, 0x0C, 0xE1, 0x03, 0x26, ++ /* 1698 */ 0x3B, 0x53, 0xF0, 0xB3, 0x26, 0xEE, 0x0E, 0x60, ++ /* 16A0 */ 0x94, 0x37, 0x4F, 0x4F, 0x80, 0x9D, 0x3F, 0x8D, ++ /* 16A8 */ 0xFC, 0x6E, 0xF0, 0x2E, 0xE0, 0xE9, 0xFB, 0x5E, ++ /* 16B0 */ 0xC4, 0x4F, 0x14, 0xE0, 0x0B, 0x76, 0xA7, 0x83, ++ /* 16B8 */ 0x02, 0x7D, 0x42, 0x1E, 0x91, 0x51, 0x7D, 0x44, ++ /* 16C0 */ 0xE0, 0x97, 0x24, 0x30, 0x1E, 0x49, 0x7C, 0xA0, ++ /* 16C8 */ 0x00, 0xC3, 0xFF, 0xFF, 0x40, 0x01, 0xBA, 0x7B, ++ /* 16D0 */ 0x01, 0xEA, 0xF4, 0xC1, 0x0F, 0xCF, 0xBE, 0xA0, ++ /* 16D8 */ 0x1A, 0xF3, 0xDD, 0xEA, 0x11, 0xCE, 0x93, 0xC3, ++ /* 16E0 */ 0x5C, 0x0E, 0x58, 0x9C, 0x6B, 0x12, 0xA8, 0x8E, ++ /* 16E8 */ 0xBB, 0x7C, 0x74, 0x70, 0xAF, 0xAD, 0xF8, 0xC1, ++ /* 16F0 */ 0xBD, 0xB3, 0xBC, 0xF3, 0x19, 0xCA, 0x83, 0x04, ++ /* 16F8 */ 0xDF, 0xB5, 0x15, 0x1C, 0x57, 0x35, 0x18, 0xC7, ++ /* 1700 */ 0x16, 0x7E, 0xC9, 0x03, 0xEC, 0x0C, 0x8B, 0x0B, ++ /* 1708 */ 0xFE, 0x7B, 0x18, 0x88, 0x4A, 0x84, 0x41, 0x11, ++ /* 1710 */ 0x58, 0x9E, 0x81, 0xFF, 0xFF, 0xB9, 0x80, 0xC1, ++ /* 1718 */ 0x1F, 0x32, 0x18, 0x6F, 0x0A, 0x7C, 0xD2, 0xD8, ++ /* 1720 */ 0x51, 0x03, 0x76, 0x86, 0x8A, 0xBB, 0x29, 0x82, ++ /* 1728 */ 0x75, 0xAA, 0x98, 0x21, 0xF0, 0x60, 0x0F, 0x00, ++ /* 1730 */ 0x9F, 0xAF, 0x7C, 0x06, 0x50, 0x14, 0x18, 0xD4, ++ /* 1738 */ 0xA1, 0x1D, 0xCE, 0x6D, 0x18, 0x70, 0x30, 0x62, ++ /* 1740 */ 0xDC, 0xC1, 0xE0, 0xFF, 0xFF, 0x52, 0x08, 0x73, ++ /* 1748 */ 0xCA, 0xEF, 0x28, 0xB1, 0x9F, 0xCB, 0xD9, 0x74, ++ /* 1750 */ 0x71, 0x57, 0x73, 0x9F, 0x4E, 0xD8, 0x05, 0x19, ++ /* 1758 */ 0xC6, 0x59, 0xE0, 0x11, 0xE0, 0xD5, 0x9C, 0x5F, ++ /* 1760 */ 0x90, 0x5F, 0x88, 0x5F, 0x08, 0xDE, 0x90, 0x7D, ++ /* 1768 */ 0x53, 0x7A, 0x36, 0x78, 0xD9, 0x89, 0xF1, 0x6E, ++ /* 1770 */ 0xEC, 0x53, 0xB2, 0xCF, 0x3B, 0x2F, 0xC8, 0xC6, ++ /* 1778 */ 0x38, 0x9A, 0x88, 0x51, 0xCE, 0xED, 0x61, 0xE0, ++ /* 1780 */ 0x35, 0xD9, 0x28, 0xEF, 0x27, 0x2F, 0x04, 0x11, ++ /* 1788 */ 0xA3, 0x19, 0x22, 0x68, 0x8C, 0x40, 0xEF, 0xCB, ++ /* 1790 */ 0xC6, 0x7B, 0x41, 0x66, 0x02, 0xDF, 0x0A, 0x3A, ++ /* 1798 */ 0xB8, 0xF8, 0x82, 0x0C, 0xF0, 0xE3, 0x64, 0x04, ++ /* 17A0 */ 0xB6, 0xFF, 0xFF, 0xC9, 0x08, 0x30, 0x74, 0xE2, ++ /* 17A8 */ 0xC0, 0x5D, 0xAA, 0xC1, 0x77, 0xB2, 0x01, 0x9C, ++ /* 17B0 */ 0x0D, 0xDD, 0x27, 0x1B, 0x70, 0x8F, 0x16, 0xDE, ++ /* 17B8 */ 0xD1, 0x04, 0x71, 0xB2, 0xA1, 0x40, 0x0E, 0xEE, ++ /* 17C0 */ 0xE0, 0xFF, 0x7F, 0x68, 0xC2, 0x86, 0x3E, 0x89, ++ /* 17C8 */ 0xD0, 0xA3, 0x93, 0x8F, 0x92, 0xB8, 0x33, 0x83, ++ /* 17D0 */ 0x27, 0xF2, 0xCE, 0xE2, 0x51, 0xBC, 0x0C, 0xFA, ++ /* 17D8 */ 0x5E, 0x70, 0x22, 0xAF, 0x0F, 0x96, 0x73, 0x8C, ++ /* 17E0 */ 0x04, 0xD5, 0x48, 0x7C, 0x7C, 0x80, 0x7F, 0x7D, ++ /* 17E8 */ 0xF1, 0x31, 0x12, 0x3E, 0x9F, 0x7F, 0x58, 0x1E, ++ /* 17F0 */ 0x8C, 0x21, 0x7D, 0x8A, 0xE4, 0x20, 0xCF, 0x2E, ++ /* 17F8 */ 0x8F, 0x21, 0xFC, 0x02, 0x09, 0xF7, 0x34, 0x73, ++ /* 1800 */ 0x00, 0x18, 0x59, 0x97, 0x47, 0xF4, 0xD9, 0x91, ++ /* 1808 */ 0x63, 0xC4, 0xF5, 0x45, 0xD1, 0x57, 0x60, 0x1F, ++ /* 1810 */ 0x04, 0xCE, 0xE7, 0x39, 0x11, 0xAC, 0xA3, 0xE6, ++ /* 1818 */ 0x47, 0x1B, 0x3E, 0x7E, 0x0E, 0xFE, 0x56, 0xF0, ++ /* 1820 */ 0x40, 0xE9, 0x63, 0x51, 0x88, 0x47, 0x24, 0x7E, ++ /* 1828 */ 0x4E, 0x04, 0x97, 0x89, 0x73, 0x22, 0x90, 0x18, ++ /* 1830 */ 0x9C, 0xFF, 0xFF, 0x87, 0x5E, 0xEC, 0x69, 0x01, ++ /* 1838 */ 0x37, 0x10, 0x9F, 0x29, 0xB1, 0x53, 0x3E, 0x11, ++ /* 1840 */ 0x76, 0x2E, 0xC1, 0x8C, 0x0E, 0x5C, 0x97, 0x7B, ++ /* 1848 */ 0x8F, 0x0E, 0xFC, 0x27, 0x01, 0x3C, 0xD6, 0xE3, ++ /* 1850 */ 0x1D, 0xF8, 0x4E, 0xEA, 0xBE, 0x9B, 0xF8, 0x22, ++ /* 1858 */ 0xE3, 0x43, 0xD1, 0xF3, 0x1D, 0xE0, 0x3F, 0x9C, ++ /* 1860 */ 0x84, 0xFF, 0xFF, 0xE1, 0x0E, 0x13, 0xE7, 0x7C, ++ /* 1868 */ 0x07, 0x50, 0xE3, 0x6C, 0xFD, 0x7C, 0x07, 0x76, ++ /* 1870 */ 0x91, 0xE7, 0x3B, 0x40, 0xCC, 0xFF, 0xFF, 0x7C, ++ /* 1878 */ 0x07, 0xB0, 0xEB, 0x8C, 0x86, 0x3B, 0xDF, 0x81, ++ /* 1880 */ 0xED, 0x68, 0x03, 0x3C, 0xFF, 0xFF, 0x47, 0x1B, ++ /* 1888 */ 0x60, 0x34, 0x8D, 0x47, 0x1B, 0x70, 0x0F, 0x17, ++ /* 1890 */ 0xF6, 0x30, 0xB8, 0x42, 0x9B, 0x3E, 0x35, 0x1A, ++ /* 1898 */ 0xB5, 0x6A, 0x50, 0xA6, 0x46, 0x99, 0x06, 0xB5, ++ /* 18A0 */ 0xFA, 0x54, 0x6A, 0xCC, 0x98, 0x84, 0xD3, 0x8D, ++ /* 18A8 */ 0x02, 0x3E, 0x2A, 0x34, 0x36, 0xCB, 0xA3, 0x10, ++ /* 18B0 */ 0x88, 0xC5, 0xBC, 0x1A, 0x04, 0xE2, 0xB0, 0x20, ++ /* 18B8 */ 0x34, 0xD2, 0x2B, 0x47, 0x20, 0x96, 0xFC, 0xEC, ++ /* 18C0 */ 0x17, 0x88, 0xE5, 0xBE, 0x19, 0x04, 0xE2, 0x80, ++ /* 18C8 */ 0x6F, 0x30, 0x81, 0x93, 0x87, 0x95, 0xC0, 0xC9, ++ /* 18D0 */ 0xBB, 0x41, 0x20, 0x8E, 0x0C, 0x42, 0x85, 0xEA, ++ /* 18D8 */ 0x00, 0x61, 0x31, 0x41, 0x68, 0x28, 0x1F, 0x20, ++ /* 18E0 */ 0x4C, 0xFA, 0x23, 0x41, 0x80, 0xC4, 0x08, 0x08, ++ /* 18E8 */ 0x0B, 0xF7, 0xFE, 0x12, 0x88, 0xA5, 0xBD, 0x27, ++ /* 18F0 */ 0x04, 0x62, 0x21, 0x56, 0x40, 0x58, 0x5C, 0x10, ++ /* 18F8 */ 0x1A, 0x4E, 0x0B, 0x08, 0x93, 0x64, 0x06, 0x84, ++ /* 1900 */ 0x05, 0x02, 0xA1, 0xF2, 0xD5, 0x80, 0x30, 0x91, ++ /* 1908 */ 0x6E, 0x00, 0xE9, 0xEA, 0x05, 0xE2, 0x20, 0x7A, ++ /* 1910 */ 0x40, 0x98, 0x0C, 0x3F, 0x20, 0x2C, 0x34, 0x08, ++ /* 1918 */ 0x8D, 0xF6, 0xC0, 0x10, 0x20, 0x31, 0x04, 0xC2, ++ /* 1920 */ 0xE2, 0x3B, 0x02, 0x61, 0xE2, 0x5F, 0x45, 0x02, ++ /* 1928 */ 0x71, 0x7E, 0x4B, 0x10, 0x37, 0xA5, 0x21, 0xD6, ++ /* 1930 */ 0x04, 0xC4, 0x34, 0x78, 0x02, 0x62, 0x8A, 0x40, ++ /* 1938 */ 0x04, 0xE4, 0xD8, 0x4F, 0x0F, 0x01, 0x59, 0x83, ++ /* 1940 */ 0x29, 0x20, 0xFF, 0xFF, 0x09, 0x46, 0x07, 0x11, ++ /* 1948 */ 0x90, 0x85, 0xA8, 0x02, 0x62, 0x79, 0x5D, 0x01, ++ /* 1950 */ 0xB1, 0xF0, 0x20, 0x02, 0x72, 0xE6, 0x97, 0x9F, ++ /* 1958 */ 0x80, 0xAC, 0xE0, 0xA5, 0xF3, 0x10, 0xC0, 0xDE, ++ /* 1960 */ 0x10, 0x81, 0x48, 0x72, 0x10, 0x01, 0x39, 0xB0, ++ /* 1968 */ 0x2F, 0x20, 0x16, 0x1F, 0x44, 0x40, 0xCE, 0xFA, ++ /* 1970 */ 0x28, 0x14, 0x90, 0x83, 0x83, 0x68, 0x10, 0xE4, ++ /* 1978 */ 0x6B, 0x26, 0x20, 0xA7, 0x07, 0x11, 0x10, 0xF9, ++ /* 1980 */ 0x04, 0x05, 0x21, 0x6A, 0xBD, 0x81, 0x30, 0x3D, ++ /* 1988 */ 0x8F, 0x42, 0x0D, 0x85, 0x80, 0x50, 0xE5, 0xEA, ++ /* 1990 */ 0xCE, 0x31, 0x2C, 0x07, 0x08, 0xCD, 0x05, 0x22, ++ /* 1998 */ 0x30, 0xAB, 0x70, 0x07, 0xC4, 0x54, 0x81, 0x08, ++ /* 19A0 */ 0xC8, 0x09, 0x80, 0x68, 0x2A, 0x10, 0x9A, 0x12, ++ /* 19A8 */ 0x8C, 0xEA, 0x92, 0x07, 0xC4, 0x12, 0x80, 0xD0, ++ /* 19B0 */ 0x54, 0x20, 0x34, 0x25, 0x88, 0x00, 0xAD, 0xCA, ++ /* 19B8 */ 0x1E, 0x10, 0x53, 0x0A, 0x42, 0x95, 0x83, 0xD0, ++ /* 19C0 */ 0x74, 0x20, 0x54, 0xB6, 0xBE, 0xC3, 0x02, 0x05, ++ /* 19C8 */ 0x11, 0x90, 0xA3, 0x83, 0x50, 0xE1, 0xFE, 0x40, ++ /* 19D0 */ 0x98, 0xDE, 0x97, 0x86, 0x00, 0x9D, 0x0E, 0x44, ++ /* 19D8 */ 0x40, 0x4E, 0x0C, 0x42, 0x15, 0x7C, 0x32, 0x82, ++ /* 19E0 */ 0x10, 0xB1, 0x20, 0x54, 0xC1, 0x27, 0x23, 0x28, ++ /* 19E8 */ 0xD1, 0xF2, 0xB2, 0x13, 0x90, 0xF5, 0x81, 0x50, ++ /* 19F0 */ 0xBD, 0x20, 0x02, 0x73, 0x36, 0x20, 0x9A, 0x17, ++ /* 19F8 */ 0x84, 0xE6, 0x07, 0xA3, 0x5A, 0x8D, 0x02, 0x31, ++ /* 1A00 */ 0xFD, 0x20, 0x34, 0x0F, 0x88, 0xC0, 0xAC, 0xE0, ++ /* 1A08 */ 0xF9, 0x71, 0xC0, 0x0C, 0x84, 0xAA, 0x04, 0x11, ++ /* 1A10 */ 0x98, 0x73, 0x01, 0xD1, 0xAC, 0x20, 0x34, 0x3B, ++ /* 1A18 */ 0x18, 0xD5, 0xFE, 0x0F, 0xD1, 0x00, 0x08, 0x08, ++ /* 1A20 */ 0xCD, 0x07, 0xA2, 0xC3, 0x00, 0x79, 0x96, 0x09, ++ /* 1A28 */ 0xC8, 0x1A, 0x41, 0xC8, 0xFF, 0x9F, 0xA0, 0x66, ++ /* 1A30 */ 0x10, 0x1D, 0x0F, 0x08, 0x10, 0xCD, 0x0F, 0x42, ++ /* 1A38 */ 0xF5, 0xFC, 0x4D, 0x82, 0x91, 0x0C, 0x20, 0x02, ++ /* 1A40 */ 0xB2, 0x96, 0x27, 0x68, 0x20, 0xA2, 0x1F, 0x44, ++ /* 1A48 */ 0x40, 0xCE, 0x04, 0x42, 0x33, 0x82, 0x51, 0xB5, ++ /* 1A50 */ 0x6F, 0x1D, 0x1D, 0x07, 0x08, 0x08, 0x4D, 0x04, ++ /* 1A58 */ 0xA2, 0xE1, 0x91, 0x77, 0xCF, 0xE1, 0x31, 0x10, ++ /* 1A60 */ 0xAA, 0x12, 0x44, 0x60, 0xD6, 0xF8, 0x74, 0x11, ++ /* 1A68 */ 0x88, 0x13, 0x82, 0x50, 0xF5, 0x76, 0x0F, 0x0C, ++ /* 1A70 */ 0x54, 0xEF, 0x20, 0xA8, 0xE0, 0x41, 0x50, 0x10, ++ /* 1A78 */ 0x9A, 0x08, 0x44, 0x87, 0x0C, 0xF2, 0x3E, 0x13, ++ /* 1A80 */ 0x90, 0x75, 0x81, 0x50, 0x9D, 0x20, 0x1A, 0x32, ++ /* 1A88 */ 0x01, 0xA2, 0x59, 0x41, 0x68, 0x76, 0x30, 0x9A, ++ /* 1A90 */ 0xFD, 0x9B, 0xA4, 0x61, 0x90, 0xEF, 0x95, 0x0E, ++ /* 1A98 */ 0x0C, 0xE4, 0x11, 0x17, 0x84, 0x28, 0xFA, 0x18, ++ /* 1AA0 */ 0x09, 0xC4, 0xB9, 0xDF, 0x40, 0x1A, 0x28, 0x79, ++ /* 1AA8 */ 0xCC, 0x04, 0x21, 0xDA, 0x40, 0x04, 0xE6, 0x1C, ++ /* 1AB0 */ 0x40, 0x34, 0x1B, 0x08, 0xCD, 0x0A, 0x46, 0xB3, ++ /* 1AB8 */ 0xAA, 0x3E, 0x62, 0xD0, 0x9F, 0xCD, 0xA1, 0xB1, ++ /* 1AC0 */ 0xE7, 0x95, 0x40, 0xAC, 0xE4, 0x65, 0xF3, 0x68, ++ /* 1AC8 */ 0xC1, 0x7E, 0xB6, 0x02, 0x21, 0xC6, 0x81, 0xE9, ++ /* 1AD0 */ 0xF7, 0x46, 0xC7, 0x00, 0x02, 0x42, 0xF5, 0xFC, ++ /* 1AD8 */ 0xAE, 0x74, 0x04, 0x20, 0x20, 0x3A, 0x02, 0x10, ++ /* 1AE0 */ 0x10, 0x9A, 0x11, 0x84, 0x66, 0x07, 0xA1, 0xBA, ++ /* 1AE8 */ 0xDE, 0x6B, 0x02, 0xB5, 0x36, 0xEF, 0x20, 0x2C, ++ /* 1AF0 */ 0x19, 0x08, 0x55, 0x2D, 0x1E, 0x84, 0x29, 0x7E, ++ /* 1AF8 */ 0xB0, 0x69, 0x98, 0x44, 0xFD, 0x21, 0x80, 0x3E, ++ /* 1B00 */ 0xCF, 0x04, 0x6E, 0xDD, 0x20, 0x34, 0x07, 0x88, ++ /* 1B08 */ 0x06, 0x4A, 0x80, 0xA8, 0x96, 0x2F, 0x9D, 0x06, ++ /* 1B10 */ 0x4A, 0x40, 0x04, 0xE6, 0x4C, 0x40, 0xE4, 0xFF, ++ /* 1B18 */ 0x4F, 0x30, 0x27, 0x08, 0x55, 0xA1, 0x7F, 0x18, ++ /* 1B20 */ 0x14, 0x44, 0x40, 0x4E, 0x01, 0x42, 0x53, 0x81, ++ /* 1B28 */ 0xD1, 0x54, 0x05, 0x40, 0x98, 0xA6, 0x04, 0x03, ++ /* 1B30 */ 0xA6, 0x20, 0x34, 0x6B, 0x03, 0x40, 0x1A, 0xE1, ++ /* 1B38 */ 0xF8, 0x43, 0x3B, 0x80, 0xB3, 0xF8, 0x20, 0x54, ++ /* 1B40 */ 0x52, 0x88, 0x03, 0x0B, 0xD3, 0x07, 0x22, 0x40, ++ /* 1B48 */ 0x47, 0x01, 0x11, 0x98, 0x63, 0x81, 0xD0, 0xA8, ++ /* 1B50 */ 0x80, 0x34, 0x37, 0x20, 0x55, 0x59, 0x02, 0x8C, ++ /* 1B58 */ 0x29, 0x06, 0xA1, 0x29, 0x40, 0x04, 0xE8, 0x48, ++ /* 1B60 */ 0x20, 0x02, 0xB4, 0xE0, 0x14, 0x60, 0x4C, 0x3E, ++ /* 1B68 */ 0x08, 0x8D, 0x09, 0x42, 0x53, 0xB5, 0x00, 0x65, ++ /* 1B70 */ 0x19, 0x41, 0x34, 0x68, 0x12, 0xE3, 0xA0, 0x42, ++ /* 1B78 */ 0x41, 0x68, 0x1E, 0x10, 0x9A, 0x0F, 0x84, 0x0A, ++ /* 1B80 */ 0xAF, 0x01, 0xC2, 0x42, 0x80, 0xD0, 0x60, 0x20, ++ /* 1B88 */ 0x1A, 0x80, 0x53, 0x82, 0x68, 0x00, 0x16, 0x97, ++ /* 1B90 */ 0x03, 0x8C, 0x09, 0x05, 0xA1, 0xE2, 0x41, 0x04, ++ /* 1B98 */ 0xE8, 0x24, 0x20, 0x02, 0xB4, 0xCE, 0x1E, 0x60, ++ /* 1BA0 */ 0x4C, 0x35, 0x08, 0x4D, 0x07, 0x42, 0xC3, 0x04, ++ /* 1BA8 */ 0x01, 0x65, 0xD1, 0x40, 0x74, 0x68, 0x22, 0x45, ++ /* 1BB0 */ 0xC0, 0x98, 0x60, 0x10, 0x1A, 0x03, 0x84, 0xC6, ++ /* 1BB8 */ 0x02, 0xA1, 0x92, 0x9B, 0x1C, 0x81, 0x28, 0x08, ++ /* 1BC0 */ 0x8D, 0x5C, 0x05, 0x8C, 0xC9, 0xC8, 0x02, 0xC2, ++ /* 1BC8 */ 0x64, 0x81, 0xE8, 0xB0, 0x44, 0x80, 0x68, 0x38, ++ /* 1BD0 */ 0x10, 0x1A, 0x16, 0x90, 0x77, 0x01, 0xA4, 0x20, ++ /* 1BD8 */ 0x02, 0x24, 0x20, 0x34, 0x2C, 0x08, 0x55, 0x15, ++ /* 1BE0 */ 0xE6, 0xC0, 0x43, 0x41, 0x74, 0x88, 0x20, 0x65, ++ /* 1BE8 */ 0x8E, 0x34, 0x14, 0x84, 0xFC, 0xFF, 0x8F, 0x14, ++ /* 1BF0 */ 0x02, 0xD1, 0xD1, 0x81, 0x00, 0x51, 0x2D, 0x69, ++ /* 1BF8 */ 0x8E, 0x0E, 0x14, 0x84, 0x06, 0x01, 0xA1, 0x3A, ++ /* 1C00 */ 0xDB, 0x1C, 0x6F, 0x28, 0x88, 0x8E, 0x37, 0x04, ++ /* 1C08 */ 0x84, 0xE6, 0x07, 0xA3, 0xAA, 0x9F, 0x84, 0x02, ++ /* 1C10 */ 0x72, 0x12, 0x10, 0x9A, 0x13, 0x44, 0x87, 0x07, ++ /* 1C18 */ 0x52, 0x08, 0x84, 0x25, 0x02, 0xA1, 0xCA, 0x13, ++ /* 1C20 */ 0x1D, 0x0C, 0xE8, 0x9B, 0x53, 0x87, 0x0B, 0x02, ++ /* 1C28 */ 0x42, 0x73, 0x80, 0xD0, 0xA4, 0x20, 0x54, 0x55, ++ /* 1C30 */ 0x25, 0x50, 0x96, 0x04, 0x44, 0x07, 0x01, 0x02, ++ /* 1C38 */ 0x42, 0xD3, 0x82, 0x51, 0x8D, 0x99, 0x06, 0x40, ++ /* 1C40 */ 0x41, 0x68, 0x0E, 0x10, 0x81, 0x39, 0x71, 0x29, ++ /* 1C48 */ 0x10, 0xA6, 0x37, 0xD5, 0xA1, 0x89, 0xB6, 0x02, ++ /* 1C50 */ 0x61, 0xFF, 0x7F ++ }) ++ ++ /* Rename the below method to WQAB if we choose not to ++ * go with the above buffer. ++ */ ++ Method (XQAB, 1, Serialized) ++ { ++ INIT (2) ++ GUID (60) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBC, 1, Serialized) ++ { ++ INIT (2) ++ GUID (100) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBD, 1, Serialized) ++ { ++ INIT (2) ++ GUID (120) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBE, 1, Serialized) ++ { ++ INIT (2) ++ GUID (140) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBF, 1, Serialized) ++ { ++ INIT (2) ++ GUID (160) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBG, 1, Serialized) ++ { ++ INIT (2) ++ GUID (180) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBH, 1, Serialized) ++ { ++ INIT (2) ++ GUID (200) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBI, 1, Serialized) ++ { ++ INIT (2) ++ GUID (220) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ } ++ } ++ ++ /* Wire GPE events to notify OEM ++ * special buttons press like wireless or ++ * presentation button. ++ */ ++ Scope (\_GPE) ++ { ++ Method (_L18, 0, Serialized) ++ { ++ Notify (\_SB.WMID, 0x80) ++ } ++ } ++} ++ +diff +--- /dev/null ++++ b/tools/firmware/hvmloader/acpi/ssdt_lenovo_t_and_x_series.asl 2009-04-01 16:35:28.000000000 -0400 +@@ -0,0 +1,616 @@ ++/* ++ * ssdt_lenovo_t_and_x_series.asl ++ * ++ * Copyright (c) 2009 Kamala Narasimhan ++ * Copyright (c) 2009 Citrix Systems, Inc. ++ * ++ * 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 ++ */ ++ ++/* SSDT for exposing Lenovo T and X series specific value add functionalities like ++ * hotkeys, special buttons. ++ */ ++ ++/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through ++ * WMI psuedo device objects. For our guests to benefit from such value add, we ++ * expose a psuedo device object in our vACPI layer also. This psuedo object is ++ * similar to the underlying base firmware object in the sense we expose the ++ * same _WDG method which describes the WMI methods, data objects and events ++ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically ++ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get ++ * known entry points and calls those entry points for further information exchange. ++ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ */ ++ ++/* COMMUNICATION DETAILS - ++ * Command port - 0x96 ++ * Writes to this port describe what type of information is about ++ * to be exchanged. E.g., guid, input argument transfer etc. ++ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. ++ * Communicates data to and from the backend. E.g. Input buffer values ++ * get written to this port and output buffer values are read from this ++ * port. ++ */ ++ ++DefinitionBlock ("SSDT_LENOVO_T_AND_X_SERIES.aml", "SSDT", 2, "Xen", "HVM", 0) ++{ ++ Scope (\_SB) ++ { ++ ++ OperationRegion (LEN1, SystemIO, 0x96, 0x01) ++ Field (LEN1, ByteAcc, NoLock, Preserve) ++ { ++ P96, 8 ++ } ++ ++ OperationRegion (LEN2, SystemIO, 0x98, 0x01) ++ Field (LEN2, ByteAcc, NoLock, Preserve) ++ { ++ P98, 8 ++ } ++ ++ OperationRegion (LEN3, SystemIO, 0x9A, 0x04) ++ Field (LEN3, DWordAcc, NoLock, Preserve) ++ { ++ P9A, 32 ++ } ++ ++ Device (WMI1) ++ { ++ /* Exposing a pseudo device with HID PNP0C14 will ++ * result in Windows guest loading their WMI wrapper ++ * driver - wmiacpi.sys ++ */ ++ Name (_HID, EisaId ("PNP0C14")) ++ Name (_UID, 0x01) ++ ++ /* Following list of data blocks exposed by _WDG is same as the ++ * one provided by the underlying firmware. Refer to - ++ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx ++ * for further information about _WDG and what it exposes. ++ */ ++ Name (_WDG, Buffer (0xA0) ++ { ++ /* Data Block 1 */ ++ /* GUID */ ++ 0x0E, 0x23, 0xF5, 0x51, 0x77, 0x96, 0xCD, 0x46, ++ 0xA1, 0xCF, 0xC0, 0xB2, 0x3E, 0xE3, 0x4D, 0xB7, ++ 0x41, 0x30, /* Object ID - WQA0 */ ++ 0x5A, /* Instance count */ ++ 0x05, /* Flag - String block & Expensive */ ++ ++ /* Data Block 2 */ ++ /* GUID */ ++ 0x64, 0x9A, 0x47, 0x98, 0xF5, 0x33, 0x33, 0x4E, ++ 0xA7, 0x07, 0x8E, 0x25, 0x1E, 0xBB, 0xC3, 0xA1, ++ 0x41, 0x31, /*Object ID - WMA1 */ ++ 0x01, /* Instance count */ ++ 0x06, /* Flag - Method & string block */ ++ ++ /* Data Block 3 */ ++ /* GUID */ ++ 0xEF, 0x54, 0x4B, 0x6A, 0xED, 0xA5, 0x33, 0x4D, ++ 0x94, 0x55, 0xB0, 0xD9, 0xB4, 0x8D, 0xF4, 0xB3, ++ 0x41, 0x32, /* Object ID - WMA2 */ ++ 0x01, /* Instance count */ ++ 0x06, /* Flag - Method & string block */ ++ ++ /* Data Block 4 */ ++ /* GUID */ ++ 0xB6, 0xEB, 0xF1, 0x74, 0x7A, 0x92, 0x7D, 0x4C, ++ 0x95, 0xDF, 0x69, 0x8E, 0x21, 0xE8, 0x0E, 0xB5, ++ 0x41, 0x33, /* Object ID - WMA3 */ ++ 0x01, /* Instance count */ ++ 0x06, /* Flag - Method & string block */ ++ ++ /* Data Block 5 */ ++ /* GUID */ ++ 0xFF, 0x04, 0xEF, 0x7E, 0x28, 0x43, 0x7C, 0x44, ++ 0xB5, 0xBB, 0xD4, 0x49, 0x92, 0x5D, 0x53, 0x8D, ++ 0x41, 0x34, /* Object ID - WMA4 */ ++ 0x01, /* Instance count */ ++ 0x06, /* Flag - Method & string block*/ ++ ++ /* Data Block 6 */ ++ /* GUID */ ++ 0x9E, 0x15, 0xDB, 0x8A, 0x32, 0x1E, 0x5C, 0x45, ++ 0xBC, 0x93, 0x30, 0x8A, 0x7E, 0xD9, 0x82, 0x46, ++ 0x41, 0x35, /* Object ID - WQA5 */ ++ 0x01, /* Instance count */ ++ 0x01, /* Flag - Expensive */ ++ ++ /* Data Block 7 */ ++ /* GUID */ ++ 0xFD, 0xD9, 0x51, 0x26, 0x1C, 0x91, 0x69, 0x4B, ++ 0xB9, 0x4E, 0xD0, 0xDE, 0xD5, 0x96, 0x3B, 0xD7, ++ 0x41, 0x36, /* Object ID - WMA6 */ ++ 0x01, /* Instance count */ ++ 0x06, /* Flag - Method & string block */ ++ ++ /* Data Block 6 */ ++ /* GUID */ ++ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, ++ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, ++ 0x42, 0x41, /* Object ID - WQBA */ ++ 0x01, /* Instance count */ ++ 0x00, /* Flag - Expensive */ ++ ++ }) ++ ++ /* Initialize cmd port and communicate invocation type ++ * i.e., method execution or query or set object ++ */ ++ Method (INIT, 1, Serialized) ++ { ++ Store (100, P96) ++ Store (Arg0, P98) ++ } ++ ++ /* Pass the guid pertaining to the operation */ ++ Method (GUID, 1, Serialized) ++ { ++ Store (101, P96) ++ Store (0x0, Local0) ++ Store (Arg0, Local1) ++ ++ While ( LLess(Local0,16) ) ++ { ++ Add(Local1, Local0, Local2) ++ Store (DerefOf(Index (_WDG, Local2)), P98 ) ++ Increment( Local0 ) ++ } ++ } ++ ++ /* Pass instance # for the associated object pertaining ++ * to the invocation. ++ */ ++ Method (INST, 1, Serialized) ++ { ++ Store(102, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass method id relevant to the method about to be ++ * executed. ++ */ ++ Method (MTID, 1, Serialized) ++ { ++ Store(103, P96) ++ Store(Arg0, P9A) ++ } ++ ++ /* Pass input buffer pertaining to the current operation */ ++ Method (IBUF, 1, Serialized) ++ { ++ Store (105, P96) ++ Store (SizeOf(Arg0), Local0) ++ Store (Local0, P9A) ++ ToBuffer (Arg0, Local1) ++ Store (0, Local2) ++ Store (104, P96) ++ While ( LLess(Local2,Local0) ) ++ { ++ Store (DerefOf(Index (Local1, Local2)), P98) ++ Increment (Local2) ++ } ++ } ++ ++ /* Now that the input arguments are passed, execute the command */ ++ Method (EXEC, 0, Serialized) ++ { ++ Store (106, P96) ++ } ++ ++ /* Get the output buffer pertaining to the just executed command */ ++ Method (OBUF, 0, Serialized) ++ { ++ Store (108, P96) ++ Store (P9A, Local0) ++ Store (Buffer(Local0) {}, Local2) ++ Store (0, Local1) ++ Store (107, P96) ++ While ( LLess(Local1, Local0) ) ++ { ++ Store (P98, Index(Local2, Local1)) ++ Increment (Local1) ++ } ++ Return (Local2) ++ } ++ ++ /* Get event data */ ++ Method (_WED, 1, Serialized) ++ { ++ INIT (4) ++ Store (109, P96) ++ Store (Arg0, P98) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Following are well know entry points as supplied by ++ * _WDG. ++ * @TODO: Though current testing suggest that defining ++ * a method for seralized execution is enough to prevent ++ * synchronization issues, consider using explicit mutexes ++ * for further protection. ++ */ ++ Method (WQA0, 1, Serialized) ++ { ++ INIT (2) ++ GUID (0) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMA1, 3, Serialized) ++ { ++ INIT (1) ++ GUID (20) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMA2, 3, Serialized) ++ { ++ INIT (1) ++ GUID (40) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMA3, 3, Serialized) ++ { ++ INIT (1) ++ GUID (60) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMA4, 3, Serialized) ++ { ++ INIT (1) ++ GUID (80) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQA5, 1, Serialized) ++ { ++ INIT (2) ++ GUID (100) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WMA6, 3, Serialized) ++ { ++ INIT (1) ++ GUID (120) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Method (WQBC, 1, Serialized) ++ { ++ INIT (2) ++ GUID (60) ++ INST (Arg0) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ /* Like all other well know entry points, we could delegate ++ * the below to the base firmware also. But, why ask for a ++ * static list (that too this big) and go through layer after ++ * layer to get it? Also, port i/o is not a good idea for this ++ * much data transfer. Luckily, this is the only place that appear ++ * to transfer so much data. ++ */ ++ ++ Method (WMBD, 3, Serialized) ++ { ++ INIT (1) ++ GUID (100) ++ INST (Arg0) ++ MTID (Arg1) ++ IBUF (Arg2) ++ EXEC () ++ Return (OBUF()) ++ } ++ ++ Name (WQBA, Buffer (0x07C1) ++ { ++ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, ++ /* 0008 */ 0xB1, 0x07, 0x00, 0x00, 0x5A, 0x30, 0x00, 0x00, ++ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, ++ /* 0018 */ 0x98, 0x51, 0x97, 0x00, 0x01, 0x06, 0x18, 0x42, ++ /* 0020 */ 0x10, 0x11, 0x10, 0x0A, 0x0D, 0x21, 0x02, 0x0B, ++ /* 0028 */ 0x83, 0x50, 0x4C, 0x18, 0x14, 0xA0, 0x45, 0x41, ++ /* 0030 */ 0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, ++ /* 0038 */ 0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, ++ /* 0040 */ 0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, ++ /* 0048 */ 0x31, 0x0E, 0x88, 0x14, 0x40, 0x48, 0xE6, 0x28, ++ /* 0050 */ 0x28, 0x81, 0x85, 0xC0, 0x11, 0x82, 0x7E, 0x05, ++ /* 0058 */ 0x20, 0x74, 0x88, 0x26, 0x83, 0x02, 0x9C, 0x22, ++ /* 0060 */ 0x08, 0xD2, 0x96, 0x05, 0xE8, 0x16, 0xE0, 0x5B, ++ /* 0068 */ 0x80, 0x76, 0x08, 0xA1, 0x55, 0x28, 0xC0, 0xA4, ++ /* 0070 */ 0x00, 0x9F, 0x60, 0xB2, 0x28, 0x40, 0x36, 0x98, ++ /* 0078 */ 0x6C, 0xC3, 0x91, 0x61, 0x30, 0x91, 0x63, 0x40, ++ /* 0080 */ 0x89, 0x19, 0x03, 0x4A, 0xE7, 0x14, 0x64, 0x13, ++ /* 0088 */ 0x58, 0xD0, 0x85, 0xA2, 0x68, 0x1A, 0x51, 0x12, ++ /* 0090 */ 0x1C, 0xD4, 0x31, 0x44, 0x08, 0x5E, 0xAE, 0x00, ++ /* 0098 */ 0xC9, 0x13, 0x90, 0xE6, 0x79, 0xC9, 0xFA, 0x20, ++ /* 00A0 */ 0x34, 0x04, 0x36, 0x02, 0x1E, 0x45, 0x02, 0x08, ++ /* 00A8 */ 0x8B, 0xB1, 0x4C, 0x89, 0x87, 0x41, 0x79, 0x00, ++ /* 00B0 */ 0x91, 0x9C, 0xA1, 0xA2, 0x80, 0xED, 0x75, 0x22, ++ /* 00B8 */ 0x1A, 0xD6, 0x71, 0x32, 0x49, 0x70, 0xA8, 0x51, ++ /* 00C0 */ 0x5A, 0xA2, 0x00, 0xF3, 0x23, 0xD3, 0x44, 0x8E, ++ /* 00C8 */ 0xAD, 0xE9, 0x11, 0x0B, 0x92, 0x49, 0x1B, 0x0A, ++ /* 00D0 */ 0x6A, 0xE8, 0x9E, 0xD6, 0x49, 0x79, 0xA2, 0x11, ++ /* 00D8 */ 0x0F, 0xCA, 0x30, 0x09, 0x3C, 0x0A, 0x86, 0xC6, ++ /* 00E0 */ 0x09, 0xCA, 0x82, 0x90, 0x83, 0x81, 0xA2, 0x00, ++ /* 00E8 */ 0x4F, 0xC2, 0x73, 0x2C, 0x5E, 0x80, 0xF0, 0x19, ++ /* 00F0 */ 0x93, 0xA3, 0x40, 0x8C, 0x04, 0x3E, 0x12, 0x78, ++ /* 00F8 */ 0x34, 0xC7, 0x8C, 0x05, 0x0A, 0x17, 0xF0, 0x7C, ++ /* 0100 */ 0x8E, 0x21, 0x72, 0xDC, 0x43, 0x8D, 0x71, 0x14, ++ /* 0108 */ 0x91, 0x13, 0xBC, 0x03, 0x44, 0x31, 0x5A, 0x41, ++ /* 0110 */ 0xF3, 0x16, 0x62, 0xB0, 0x68, 0x06, 0xEB, 0x19, ++ /* 0118 */ 0x9C, 0x0C, 0x3A, 0xC1, 0xFF, 0xFF, 0x08, 0xB8, ++ /* 0120 */ 0x0C, 0x08, 0x79, 0x14, 0x60, 0x75, 0x50, 0x9A, ++ /* 0128 */ 0x86, 0x09, 0xBA, 0x17, 0x60, 0x4D, 0x80, 0x31, ++ /* 0130 */ 0x01, 0x1A, 0x31, 0xA4, 0x4C, 0x80, 0xB3, 0xFB, ++ /* 0138 */ 0x82, 0x66, 0xD4, 0x96, 0x00, 0x73, 0x02, 0xB4, ++ /* 0140 */ 0x09, 0xF0, 0x86, 0x20, 0x94, 0xF3, 0x8C, 0x72, ++ /* 0148 */ 0x2C, 0xA7, 0x18, 0xE5, 0x61, 0x20, 0xE6, 0xCB, ++ /* 0150 */ 0x40, 0xD0, 0x28, 0x31, 0x62, 0x9E, 0x4B, 0x5C, ++ /* 0158 */ 0xC3, 0x46, 0x88, 0x11, 0xF2, 0x14, 0x02, 0xC5, ++ /* 0160 */ 0x6D, 0x7F, 0x10, 0x64, 0xD0, 0xB8, 0xD1, 0xFB, ++ /* 0168 */ 0xB4, 0x70, 0x56, 0x27, 0x70, 0xF4, 0x4F, 0x0A, ++ /* 0170 */ 0x26, 0xF0, 0x94, 0x0F, 0xEC, 0xD9, 0xE0, 0x04, ++ /* 0178 */ 0x8E, 0x35, 0x6A, 0x8C, 0x53, 0x49, 0xE0, 0xD8, ++ /* 0180 */ 0x0F, 0x08, 0x69, 0x00, 0x51, 0x24, 0x78, 0xD4, ++ /* 0188 */ 0x69, 0xC1, 0xE7, 0x02, 0x0F, 0xED, 0xA0, 0x3D, ++ /* 0190 */ 0xC7, 0x13, 0x08, 0x72, 0x08, 0x47, 0xF0, 0xC4, ++ /* 0198 */ 0xF0, 0x40, 0xE0, 0x31, 0xB0, 0x9B, 0x82, 0x8F, ++ /* 01A0 */ 0x00, 0x3E, 0x21, 0xE0, 0x5D, 0x03, 0xEA, 0x6A, ++ /* 01A8 */ 0xF0, 0x60, 0xC0, 0x06, 0x1D, 0x0E, 0x33, 0x5E, ++ /* 01B0 */ 0x0F, 0x3F, 0xDC, 0x09, 0x9C, 0xE4, 0x03, 0x06, ++ /* 01B8 */ 0x3F, 0x6C, 0x78, 0x70, 0xB8, 0x79, 0x9E, 0xCC, ++ /* 01C0 */ 0x91, 0x95, 0x2A, 0xC0, 0xEC, 0xE1, 0x40, 0x07, ++ /* 01C8 */ 0x09, 0x9F, 0x36, 0xD8, 0x19, 0x00, 0x23, 0x7F, ++ /* 01D0 */ 0x10, 0xA8, 0x91, 0x19, 0xDA, 0xE3, 0x7E, 0xE9, ++ /* 01D8 */ 0x30, 0xE4, 0x73, 0xC2, 0x61, 0x31, 0xB1, 0xA7, ++ /* 01E0 */ 0x0E, 0x3A, 0x1E, 0xF0, 0x5F, 0x46, 0x9E, 0x33, ++ /* 01E8 */ 0x3C, 0x7D, 0xCF, 0xD7, 0x04, 0xC3, 0x0E, 0x1C, ++ /* 01F0 */ 0x3D, 0x10, 0x43, 0x3F, 0x6C, 0x1C, 0xC6, 0x69, ++ /* 01F8 */ 0xF8, 0xFE, 0xE1, 0xF3, 0x02, 0x8C, 0x53, 0x80, ++ /* 0200 */ 0x47, 0xEE, 0xFF, 0xFF, 0x21, 0xC5, 0xA7, 0x09, ++ /* 0208 */ 0x7E, 0xB4, 0xF0, 0x69, 0x82, 0x5D, 0x0F, 0x4E, ++ /* 0210 */ 0xE3, 0x39, 0xC0, 0xC3, 0x39, 0x2B, 0x1F, 0x26, ++ /* 0218 */ 0xC0, 0x76, 0x3F, 0x61, 0x23, 0x7A, 0xB7, 0xF0, ++ /* 0220 */ 0x68, 0xB0, 0xA7, 0x00, 0xF0, 0x9D, 0x5F, 0xC0, ++ /* 0228 */ 0x79, 0xD7, 0x60, 0x83, 0x85, 0x71, 0x7E, 0x01, ++ /* 0230 */ 0x1E, 0x27, 0x04, 0x0F, 0x81, 0x1F, 0x24, 0x3C, ++ /* 0238 */ 0x04, 0x3E, 0x80, 0xE7, 0x8F, 0x33, 0xB4, 0xD2, ++ /* 0240 */ 0x79, 0x21, 0x07, 0x06, 0xEF, 0x9C, 0x03, 0x63, ++ /* 0248 */ 0x14, 0x3C, 0xCF, 0x63, 0xC3, 0x04, 0x0A, 0xF2, ++ /* 0250 */ 0x1A, 0x50, 0xA8, 0x67, 0x01, 0x85, 0xF1, 0xA9, ++ /* 0258 */ 0x06, 0x78, 0xFD, 0xFF, 0x4F, 0x35, 0xC0, 0xE5, ++ /* 0260 */ 0x70, 0x80, 0x3B, 0x39, 0xC0, 0xBD, 0x17, 0xB0, ++ /* 0268 */ 0x8B, 0xC3, 0x73, 0x0D, 0x5C, 0xD1, 0xE7, 0x1A, ++ /* 0270 */ 0xA8, 0xF7, 0x96, 0xE2, 0xC6, 0xA8, 0x6B, 0x4C, ++ /* 0278 */ 0x90, 0x47, 0x81, 0x47, 0x9A, 0x28, 0xCF, 0x33, ++ /* 0280 */ 0xEF, 0x32, 0x11, 0x9E, 0x6D, 0x7C, 0xAD, 0xF1, ++ /* 0288 */ 0x14, 0xE2, 0xF8, 0x5A, 0x63, 0xC4, 0x97, 0x89, ++ /* 0290 */ 0x77, 0x1B, 0xE3, 0x1E, 0xDC, 0x63, 0xCD, 0x43, ++ /* 0298 */ 0x8E, 0x41, 0x8E, 0x26, 0xC2, 0x8B, 0x41, 0xC0, ++ /* 02A0 */ 0xC7, 0x1B, 0x1F, 0x6B, 0xC0, 0x2B, 0xE6, 0x85, ++ /* 02A8 */ 0x22, 0x0B, 0xC7, 0x1A, 0x40, 0xE3, 0xFF, 0xFF, ++ /* 02B0 */ 0x58, 0x03, 0xDC, 0xB0, 0x1E, 0x50, 0xC0, 0x77, ++ /* 02B8 */ 0x64, 0x60, 0x37, 0x14, 0x78, 0x27, 0x14, 0xC0, ++ /* 02C0 */ 0x4F, 0xE2, 0x17, 0x80, 0x8E, 0x1C, 0x4E, 0x0B, ++ /* 02C8 */ 0x22, 0x1B, 0x6F, 0x00, 0x9F, 0x02, 0xA8, 0x1A, ++ /* 02D0 */ 0x20, 0x4D, 0x13, 0x36, 0xC1, 0xF4, 0xE4, 0x82, ++ /* 02D8 */ 0xF7, 0x91, 0xC0, 0xB9, 0x49, 0x94, 0x7C, 0x58, ++ /* 02E0 */ 0x14, 0xCE, 0x59, 0x0F, 0x22, 0x14, 0xC4, 0x80, ++ /* 02E8 */ 0x0E, 0x72, 0x9C, 0x40, 0x9F, 0x51, 0x7C, 0x10, ++ /* 02F0 */ 0x39, 0xD1, 0x27, 0x42, 0x0F, 0xCA, 0xC3, 0x78, ++ /* 02F8 */ 0x47, 0x61, 0x27, 0x10, 0x1F, 0x26, 0x3C, 0x76, ++ /* 0300 */ 0x1F, 0x13, 0xF8, 0x3F, 0xC6, 0xB3, 0x31, 0xBA, ++ /* 0308 */ 0xD5, 0x60, 0xE8, 0xFF, 0x7F, 0x4E, 0xE1, 0x60, ++ /* 0310 */ 0x3E, 0x88, 0x70, 0x82, 0x8F, 0x46, 0xDD, 0x24, ++ /* 0318 */ 0x40, 0xA5, 0xEF, 0xA8, 0x00, 0x0A, 0x20, 0xDF, ++ /* 0320 */ 0x0B, 0x7C, 0x0E, 0x78, 0x36, 0x60, 0x63, 0x78, ++ /* 0328 */ 0x14, 0x30, 0x9A, 0xD1, 0x79, 0xF8, 0xC9, 0xA2, ++ /* 0330 */ 0xE2, 0x4E, 0x96, 0x82, 0x78, 0xB2, 0x8E, 0x32, ++ /* 0338 */ 0x59, 0xF4, 0x4C, 0x7C, 0xAF, 0xF0, 0x8C, 0xDE, ++ /* 0340 */ 0xB4, 0x3C, 0x47, 0x4F, 0xD8, 0xF7, 0x10, 0x58, ++ /* 0348 */ 0x87, 0x81, 0x90, 0x0F, 0x06, 0x9E, 0x86, 0xE1, ++ /* 0350 */ 0x3C, 0x59, 0x0E, 0xE7, 0xC9, 0xF2, 0xB1, 0xF8, ++ /* 0358 */ 0x1A, 0x02, 0x3E, 0x81, 0xB3, 0x05, 0x39, 0x3C, ++ /* 0360 */ 0x26, 0xD6, 0xA8, 0xE8, 0x55, 0xC8, 0xC3, 0xE3, ++ /* 0368 */ 0x97, 0x03, 0xCF, 0xE7, 0x19, 0xE1, 0x28, 0x9F, ++ /* 0370 */ 0x24, 0x70, 0x18, 0xCF, 0x24, 0x1E, 0xA2, 0x6F, ++ /* 0378 */ 0x45, 0xB0, 0x26, 0x72, 0xD2, 0xBE, 0x2D, 0x9C, ++ /* 0380 */ 0x6C, 0xD0, 0xD7, 0x33, 0xCC, 0xAD, 0x08, 0xF6, ++ /* 0388 */ 0xFF, 0xFF, 0x56, 0x04, 0xE7, 0x82, 0x06, 0x33, ++ /* 0390 */ 0xD3, 0xBD, 0x0A, 0x15, 0xEB, 0x5E, 0x05, 0x88, ++ /* 0398 */ 0x1D, 0xD6, 0x6B, 0x8F, 0x0F, 0x56, 0x70, 0xEF, ++ /* 03A0 */ 0x55, 0x70, 0x2F, 0x55, 0xCF, 0x0A, 0xC7, 0x18, ++ /* 03A8 */ 0xFE, 0x61, 0x2A, 0xC6, 0x29, 0xBD, 0x76, 0x1A, ++ /* 03B0 */ 0x28, 0x4C, 0x94, 0x78, 0xEF, 0x55, 0x1E, 0xE3, ++ /* 03B8 */ 0x7B, 0x15, 0xBB, 0x42, 0x85, 0x89, 0xF5, 0x72, ++ /* 03C0 */ 0x65, 0xD4, 0xD7, 0x89, 0x70, 0x81, 0x82, 0x44, ++ /* 03C8 */ 0x7A, 0xB5, 0x8A, 0x12, 0x39, 0xBE, 0x21, 0xDF, ++ /* 03D0 */ 0xAB, 0xC0, 0x2B, 0xE7, 0x5E, 0x05, 0xB2, 0xFF, ++ /* 03D8 */ 0xFF, 0xBD, 0x0A, 0x30, 0x8F, 0xF6, 0x5E, 0x05, ++ /* 03E0 */ 0xC6, 0x6B, 0x03, 0xBB, 0x21, 0xC1, 0x02, 0x7A, ++ /* 03E8 */ 0xB1, 0x02, 0x0C, 0x65, 0xBE, 0x58, 0xD1, 0xBC, ++ /* 03F0 */ 0x17, 0x2B, 0xC4, 0xFF, 0xFF, 0x5C, 0xC2, 0xF4, ++ /* 03F8 */ 0x5C, 0xAC, 0xC8, 0x3C, 0xE1, 0xDF, 0xAC, 0x00, ++ /* 0400 */ 0x4E, 0xFF, 0xFF, 0x6F, 0x56, 0x80, 0xB1, 0x7B, ++ /* 0408 */ 0x11, 0xE6, 0x68, 0x05, 0x2F, 0xE5, 0xCD, 0x8A, ++ /* 0410 */ 0xC6, 0x59, 0x86, 0x02, 0x2E, 0x88, 0xC2, 0xF8, ++ /* 0418 */ 0x66, 0x05, 0x38, 0xBA, 0xAE, 0xE0, 0x86, 0x0C, ++ /* 0420 */ 0x17, 0x2C, 0x4A, 0x30, 0x1F, 0x42, 0x3C, 0x9D, ++ /* 0428 */ 0x23, 0x7E, 0x48, 0x78, 0x09, 0x78, 0xCC, 0xF1, ++ /* 0430 */ 0x80, 0x1F, 0x08, 0x7C, 0xB9, 0x02, 0xD3, 0xFF, ++ /* 0438 */ 0x9F, 0xC0, 0x27, 0xDF, 0xB3, 0x7C, 0x9B, 0x7A, ++ /* 0440 */ 0xEF, 0xE5, 0x07, 0xAC, 0xF7, 0x2A, 0x1F, 0x7E, ++ /* 0448 */ 0x63, 0xBD, 0x33, 0xBC, 0x5C, 0x79, 0x24, 0x51, ++ /* 0450 */ 0x4E, 0x22, 0x94, 0xEF, 0x56, 0xEF, 0x55, 0x46, ++ /* 0458 */ 0x89, 0xF8, 0x42, 0xEC, 0x53, 0xB0, 0xA1, 0x8D, ++ /* 0460 */ 0xF2, 0x54, 0x11, 0xDD, 0x78, 0x2F, 0x57, 0xE0, ++ /* 0468 */ 0x95, 0x74, 0xB9, 0x02, 0x68, 0x32, 0xFC, 0x97, ++ /* 0470 */ 0x2B, 0xF0, 0xDD, 0x1C, 0xB0, 0xD7, 0x24, 0x38, ++ /* 0478 */ 0xFF, 0xFF, 0x6B, 0x12, 0xBF, 0x5E, 0x01, 0x7E, ++ /* 0480 */ 0xB2, 0x5F, 0xAF, 0x68, 0xEE, 0xEB, 0x15, 0x4A, ++ /* 0488 */ 0x14, 0x84, 0x14, 0x01, 0x69, 0xA6, 0xE0, 0xB9, ++ /* 0490 */ 0x5F, 0x01, 0x9C, 0xF8, 0xFF, 0xDF, 0xAF, 0x00, ++ /* 0498 */ 0xCB, 0xE1, 0xEE, 0x57, 0x40, 0xEF, 0x76, 0x04, ++ /* 04A0 */ 0x5E, 0x94, 0xB7, 0x23, 0xEC, 0x15, 0x0B, 0x9F, ++ /* 04A8 */ 0xF1, 0x8A, 0x45, 0xC3, 0xAC, 0x44, 0xF1, 0xD6, ++ /* 04B0 */ 0x44, 0x61, 0x7C, 0xC5, 0x02, 0x26, 0xFF, 0xFF, ++ /* 04B8 */ 0x2B, 0x16, 0x30, 0x3B, 0x88, 0xE2, 0x46, 0x0D, ++ /* 04C0 */ 0xF7, 0xE2, 0xE4, 0x5B, 0x8F, 0xE7, 0x1B, 0xD1, ++ /* 04C8 */ 0x77, 0x18, 0xCC, 0x09, 0x0B, 0xC6, 0x0D, 0x0B, ++ /* 04D0 */ 0xFE, 0x90, 0x1E, 0x86, 0x7D, 0x92, 0x78, 0xC7, ++ /* 04D8 */ 0xF2, 0xD1, 0xCA, 0x20, 0x6F, 0xC0, 0x4F, 0x56, ++ /* 04E0 */ 0x0F, 0x56, 0x51, 0x8C, 0x10, 0xF0, 0x78, 0xDE, ++ /* 04E8 */ 0x85, 0x7D, 0xB4, 0x7A, 0xD3, 0x32, 0x4A, 0xEC, ++ /* 04F0 */ 0x58, 0xBE, 0x50, 0x3D, 0x6B, 0xF9, 0x9A, 0x65, ++ /* 04F8 */ 0x88, 0xB8, 0x0F, 0xC4, 0xBE, 0x61, 0x01, 0xB6, ++ /* 0500 */ 0xFF, 0xFF, 0x37, 0x2C, 0xC0, 0xD1, 0xC5, 0x81, ++ /* 0508 */ 0x1F, 0x1C, 0xB0, 0x37, 0x2C, 0xC0, 0xE7, 0x4C, ++ /* 0510 */ 0xC1, 0x73, 0xC3, 0x02, 0x36, 0xFF, 0xFF, 0x1B, ++ /* 0518 */ 0x16, 0xC0, 0xFF, 0xFF, 0xFF, 0x0D, 0x0B, 0x38, ++ /* 0520 */ 0xDC, 0xAE, 0xB0, 0xB7, 0x2C, 0xEC, 0xED, 0x85, ++ /* 0528 */ 0xAC, 0x82, 0x86, 0x5A, 0x89, 0x82, 0x7F, 0xAF, ++ /* 0530 */ 0x0C, 0x43, 0x6F, 0x58, 0x80, 0xA3, 0x71, 0x7B, ++ /* 0538 */ 0xD4, 0xE0, 0x38, 0x1B, 0x3C, 0x49, 0x60, 0xCE, ++ /* 0540 */ 0xD5, 0xB8, 0xD9, 0x1C, 0x5C, 0xE0, 0x08, 0xBD, ++ /* 0548 */ 0x83, 0x6A, 0xEE, 0xEC, 0x92, 0x02, 0xE3, 0x96, ++ /* 0550 */ 0x05, 0xF7, 0x52, 0xF5, 0xD0, 0x10, 0xE5, 0x20, ++ /* 0558 */ 0x5E, 0x85, 0x1F, 0xAC, 0x1E, 0xA5, 0x8E, 0xEC, ++ /* 0560 */ 0xF1, 0xEA, 0x69, 0xD8, 0xC7, 0x2C, 0xDF, 0xB2, ++ /* 0568 */ 0x0C, 0x15, 0xE1, 0x2D, 0x8B, 0x9D, 0x21, 0xE2, ++ /* 0570 */ 0xC5, 0x8A, 0x12, 0xE2, 0xBD, 0x22, 0xB4, 0xEF, ++ /* 0578 */ 0x5C, 0x06, 0x7F, 0x34, 0x36, 0x6A, 0xD0, 0x97, ++ /* 0580 */ 0xE3, 0xB7, 0x2C, 0x78, 0xFF, 0xFF, 0x5B, 0x16, ++ /* 0588 */ 0x7C, 0x91, 0x7F, 0x15, 0x9D, 0x08, 0x7C, 0xCB, ++ /* 0590 */ 0x02, 0xF8, 0x11, 0x0C, 0x42, 0x4E, 0x06, 0x8E, ++ /* 0598 */ 0x3E, 0x2F, 0xE0, 0x07, 0xF0, 0x30, 0xE2, 0x21, ++ /* 05A0 */ 0xB1, 0x00, 0x03, 0xA7, 0xF7, 0x25, 0x9F, 0x29, ++ /* 05A8 */ 0xF8, 0x01, 0xC3, 0x67, 0x0A, 0x76, 0x3D, 0x88, ++ /* 05B0 */ 0xFE, 0x18, 0xE0, 0x73, 0x09, 0x66, 0x70, 0xE0, ++ /* 05B8 */ 0xBF, 0x56, 0x1C, 0xBA, 0x47, 0xF1, 0xFA, 0x60, ++ /* 05C0 */ 0x02, 0x0F, 0x8E, 0xFF, 0xFF, 0x07, 0x07, 0xF7, ++ /* 05C8 */ 0xCE, 0x70, 0x44, 0xBE, 0xC3, 0x78, 0x70, 0x60, ++ /* 05D0 */ 0x3B, 0x08, 0x00, 0x87, 0xC1, 0xE1, 0x43, 0x0D, ++ /* 05D8 */ 0x0E, 0x3D, 0x1E, 0x03, 0x87, 0xF4, 0x79, 0x8C, ++ /* 05E0 */ 0x5D, 0x18, 0x1E, 0x72, 0x3C, 0x34, 0xB0, 0x01, ++ /* 05E8 */ 0x7A, 0x68, 0xC0, 0x72, 0x12, 0x4F, 0x21, 0x87, ++ /* 05F0 */ 0x06, 0x66, 0x09, 0x43, 0x03, 0x4A, 0xF1, 0x86, ++ /* 05F8 */ 0x46, 0xFF, 0xFF, 0x43, 0xE3, 0x43, 0xF2, 0x61, ++ /* 0600 */ 0x21, 0xE6, 0x53, 0x4E, 0x84, 0xF7, 0x05, 0x9F, ++ /* 0608 */ 0xA0, 0x18, 0xFA, 0x6B, 0x8A, 0x6F, 0x17, 0xBE, ++ /* 0610 */ 0x09, 0xE2, 0xC6, 0x07, 0xAE, 0x4B, 0xA7, 0xC7, ++ /* 0618 */ 0x07, 0x7C, 0x8E, 0x5C, 0x1E, 0x1F, 0xEE, 0xE8, ++ /* 0620 */ 0xE4, 0xF1, 0xC1, 0x70, 0x79, 0x95, 0x21, 0x47, ++ /* 0628 */ 0x13, 0x1F, 0xAD, 0xD8, 0xF0, 0xC0, 0x76, 0xD3, ++ /* 0630 */ 0xF3, 0xF0, 0x80, 0xCF, 0x75, 0x13, 0x8C, 0x57, ++ /* 0638 */ 0x48, 0x7E, 0x2D, 0x81, 0x71, 0x82, 0xC2, 0x5F, ++ /* 0640 */ 0x37, 0xC1, 0xFB, 0xFF, 0xBF, 0x6E, 0x02, 0xCF, ++ /* 0648 */ 0x51, 0x70, 0xAD, 0x97, 0x6C, 0x1A, 0xE4, 0x95, ++ /* 0650 */ 0xA3, 0x58, 0x2F, 0x02, 0x0A, 0xE3, 0x33, 0x1B, ++ /* 0658 */ 0xE0, 0x68, 0xAC, 0xCF, 0x6C, 0x60, 0xB9, 0x17, ++ /* 0660 */ 0xB0, 0x1B, 0x1B, 0xDC, 0xD3, 0x1A, 0xEC, 0xBB, ++ /* 0668 */ 0xC3, 0xC3, 0xD9, 0x63, 0xDA, 0xA3, 0xDA, 0x03, ++ /* 0670 */ 0x9A, 0x8F, 0xD8, 0x31, 0xDE, 0xD2, 0x82, 0xC4, ++ /* 0678 */ 0x89, 0xF0, 0x3A, 0xF0, 0xB4, 0xE6, 0x4B, 0x46, ++ /* 0680 */ 0xBC, 0x40, 0x4F, 0x6B, 0xC6, 0x88, 0xF3, 0xD2, ++ /* 0688 */ 0x66, 0xC4, 0x57, 0x8A, 0x10, 0x0F, 0x6B, 0x3E, ++ /* 0690 */ 0xB9, 0x19, 0xEF, 0x61, 0x22, 0x5C, 0x98, 0x17, ++ /* 0698 */ 0xB6, 0xA7, 0x35, 0x70, 0xFC, 0xFF, 0x4F, 0x6B, ++ /* 06A0 */ 0x70, 0xE4, 0x5C, 0xB1, 0x01, 0x9A, 0x5C, 0xF4, ++ /* 06A8 */ 0x71, 0x87, 0x14, 0xB0, 0x5C, 0x1B, 0xD8, 0x2D, ++ /* 06B0 */ 0x05, 0xDE, 0x05, 0x1B, 0x38, 0xFF, 0xFF, 0x8F, ++ /* 06B8 */ 0x28, 0xE0, 0xCB, 0x72, 0xC1, 0xA6, 0x39, 0x2E, ++ /* 06C0 */ 0xD8, 0x28, 0x0E, 0xAB, 0x01, 0xD2, 0x3C, 0xE1, ++ /* 06C8 */ 0x5F, 0xAF, 0xC1, 0x3F, 0x09, 0x5F, 0xAF, 0x01, ++ /* 06D0 */ 0xDB, 0xB7, 0x58, 0xDC, 0xF5, 0x1A, 0x58, 0xFD, ++ /* 06D8 */ 0xFF, 0xAF, 0xD7, 0xC0, 0x52, 0xF0, 0x48, 0xE9, ++ /* 06E0 */ 0x9D, 0x1A, 0x5C, 0x37, 0x6D, 0x3C, 0xE8, 0x9B, ++ /* 06E8 */ 0x36, 0x4C, 0x85, 0x36, 0x7D, 0x6A, 0x34, 0x6A, ++ /* 06F0 */ 0xD5, 0xA0, 0x4C, 0x8D, 0x32, 0x0D, 0x6A, 0xF5, ++ /* 06F8 */ 0xA9, 0xD4, 0x98, 0xB1, 0xA1, 0x5A, 0xDA, 0x5D, ++ /* 0700 */ 0x82, 0x8A, 0x59, 0x8C, 0x46, 0xE3, 0x28, 0x20, ++ /* 0708 */ 0x54, 0xF6, 0x1F, 0x50, 0x20, 0x0E, 0xF9, 0xD1, ++ /* 0710 */ 0x11, 0xA0, 0x83, 0x7D, 0xA7, 0x74, 0x0B, 0x27, ++ /* 0718 */ 0x6B, 0x13, 0x88, 0xE3, 0x9B, 0x80, 0x68, 0x04, ++ /* 0720 */ 0x44, 0x5A, 0x54, 0x00, 0xB1, 0xDC, 0x20, 0x02, ++ /* 0728 */ 0xB2, 0x8A, 0x35, 0x09, 0xC8, 0x9A, 0xBF, 0x2F, ++ /* 0730 */ 0x02, 0xB7, 0x4E, 0x1D, 0x40, 0x2C, 0x25, 0x08, ++ /* 0738 */ 0x4D, 0xB4, 0x70, 0x81, 0x3A, 0x1E, 0x88, 0x06, ++ /* 0740 */ 0x43, 0x68, 0x04, 0xE4, 0x60, 0x14, 0x02, 0xB2, ++ /* 0748 */ 0x8C, 0xCF, 0x9D, 0xC0, 0x2D, 0xC0, 0x0A, 0x10, ++ /* 0750 */ 0x93, 0x0F, 0x42, 0x05, 0x7B, 0x01, 0x65, 0xEA, ++ /* 0758 */ 0x41, 0x04, 0x64, 0xA5, 0x6B, 0x15, 0x90, 0x75, ++ /* 0760 */ 0x83, 0x08, 0xC8, 0x59, 0xCD, 0x80, 0xB3, 0x8C, ++ /* 0768 */ 0x6E, 0x80, 0x98, 0xC2, 0x87, 0x82, 0x40, 0xAC, ++ /* 0770 */ 0x49, 0x0F, 0x28, 0x13, 0x08, 0xA2, 0x0B, 0x07, ++ /* 0778 */ 0xF1, 0x03, 0xC4, 0xA4, 0x81, 0x08, 0xC8, 0x71, ++ /* 0780 */ 0x7E, 0x25, 0x02, 0x77, 0x1C, 0x45, 0x80, 0xD4, ++ /* 0788 */ 0xD1, 0x70, 0x29, 0x08, 0x15, 0xFF, 0x09, 0x13, ++ /* 0790 */ 0xC8, 0xFF, 0xFF, 0xFD, 0x44, 0x96, 0xC0, 0x28, ++ /* 0798 */ 0x08, 0x8D, 0xA0, 0x09, 0x84, 0xC9, 0xF3, 0x04, ++ /* 07A0 */ 0xC2, 0x42, 0xFD, 0xFD, 0x34, 0x04, 0x07, 0x51, ++ /* 07A8 */ 0x35, 0x44, 0xEA, 0x0A, 0x84, 0x05, 0x7E, 0x18, ++ /* 07B0 */ 0x68, 0x30, 0x4E, 0x0F, 0x22, 0x20, 0x27, 0x7D, ++ /* 07B8 */ 0x52, 0x05, 0x22, 0xB9, 0x41, 0x04, 0xE4, 0xFF, ++ /* 07C0 */ 0x3F ++ }) ++ } ++ } ++ ++ /* Wire GPE events to notify OEM ++ * added value events. ++ */ ++ Scope (\_GPE) ++ { ++ Method (_L18, 0, Serialized) ++ { ++ Notify (\_SB.WMI1, 0xD0) ++ } ++ } ++} ++ +diff -Nur a/tools/xenpmd/acpi-events.c b/tools/xenpmd/acpi-events.c +--- a/tools/xenpmd/acpi-events.c 2009-04-01 16:30:52.000000000 -0400 ++++ b/tools/xenpmd/acpi-events.c 2009-04-01 16:51:29.000000000 -0400 +@@ -41,6 +41,7 @@ + #define XS_LID_EVENT_PATH "/pm/events/lidstatechanged" + #define XS_PBTN_EVENT_PATH "/pm/events/powerbuttonpressed" + #define XS_SBTN_EVENT_PATH "/pm/events/sleepbuttonpressed" ++#define XS_OEM_EVENT_PATH "/oem/event" + + static int socket_fd; + static pthread_t acpi_thread; +@@ -97,6 +98,11 @@ + xs_write(xs, XBT_NULL, XS_SBTN_EVENT_PATH, "1", 1); + } + ++void handle_oem_event(void) ++{ ++ xs_write(xs, XBT_NULL, XS_OEM_EVENT_PATH, "1", 1); ++} ++ + void process_acpi_message(char *acpi_buffer) + { + if ( strstr(acpi_buffer, "ac_adapter") ) +@@ -119,7 +125,14 @@ + } + + if ( strstr(acpi_buffer, "SBTN") ) ++ { + handle_sbtn_pressed_event(); ++ return; ++ } ++ ++ if ( (strstr(acpi_buffer, "WMID")) || ++ (strstr(acpi_buffer, "AMW0")) ) ++ handle_oem_event(); + } + + static void *acpi_events_thread(void *arg) diff --git a/master/power-management-enhancement b/master/power-management-enhancement new file mode 100644 index 0000000..b9bdb77 --- /dev/null +++ b/master/power-management-enhancement @@ -0,0 +1,1066 @@ +diff --git a/tools/firmware/hvmloader/acpi/Makefile b/tools/firmware/hvmloader/acpi/Makefile +index c282d01..f9f6bc3 100644 +--- a/tools/firmware/hvmloader/acpi/Makefile ++++ b/tools/firmware/hvmloader/acpi/Makefile +@@ -19,17 +19,30 @@ XEN_ROOT = ../../../.. + include $(XEN_ROOT)/tools/firmware/Rules.mk + + C_SRC = build.c dsdt.c static_tables.c +-H_SRC = $(wildcard *.h) ++H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_tpm.h + OBJS = $(patsubst %.c,%.o,$(C_SRC)) + ++build.o: $(H_SRC) build.c ++ ++IASL_VER = acpica-unix-20080729 ++IASL_URL = http://acpica.org/download/$(IASL_VER).tar.gz ++ + CFLAGS += -I. -I.. $(CFLAGS_include) + + vpath iasl $(PATH) + all: acpi.a + +-ssdt_pm.h ssdt_tpm.h: %.h: %.asl ++ssdt_pm.h: ssdt_pm.asl ++ $(MAKE) iasl ++ iasl -tc $< ++ sed -i'' -re 's/AmlCode/AmlCode_PM/g' $*.hex ++ mv $*.hex $@ ++ rm -f *.aml ++ ++ssdt_tpm.h: ssdt_tpm.asl + $(MAKE) iasl + iasl -tc $< ++ sed -i'' -re 's/AmlCode/AmlCode_TPM/g' $*.hex + mv $*.hex $@ + rm -f *.aml + +diff --git a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c +index 82510fc..97dcdb5 100644 +--- a/tools/firmware/hvmloader/acpi/build.c ++++ b/tools/firmware/hvmloader/acpi/build.c +@@ -50,7 +50,13 @@ static void set_checksum( + + static uint8_t battery_port_exists(void) + { +- return (inb(0x88) == 0x1F); ++ uint8_t val; ++ ++ val = inb(0x88); ++ if ( (val == 0xff) || (val == 0x0) ) ++ return 0; ++ ++ return 1; + } + + static int construct_madt(struct acpi_20_madt *madt) +diff --git a/tools/firmware/hvmloader/acpi/ssdt_pm.asl b/tools/firmware/hvmloader/acpi/ssdt_pm.asl +index afb78b6..8f2d7a7 100644 +--- a/tools/firmware/hvmloader/acpi/ssdt_pm.asl ++++ b/tools/firmware/hvmloader/acpi/ssdt_pm.asl +@@ -95,6 +95,13 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + P88, 8 + } + ++ /* OperationRegion for Power Button */ ++ OperationRegion (PBOP, SystemIO, 0x200, 0x01) ++ Field (PBOP, ByteAcc, NoLock, WriteAsZeros) ++ { ++ SLP, 1, ++ WAK, 1 ++ } + + Mutex (SYNC, 0x01) + Name (BUF0, Buffer (0x0100) {}) +@@ -291,8 +298,99 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + Release (SYNC) + } + +- /* Future patches will extend AC object to better account for +- * AC to DC transition and more. */ ++ Method (E0, 0, NotSerialized) ++ { ++ If (\_SB.SLP) ++ { ++ Store (One, \_SB.SLP) ++ Notify (\_SB.SLPB, 0x80) ++ } ++ ++ if (\_SB.WAK) ++ { ++ Store (One, \_SB.WAK) ++ Notify (\_SB.SLPB, 0x2) ++ } ++ } ++ ++ Method (E1, 0, NotSerialized) ++ { ++ If (\_SB.SLP) ++ { ++ Store (One, \_SB.SLP) ++ Notify (\_SB.PBTN, 0x80) ++ } ++ ++ if (\_SB.WAK) ++ { ++ Store (One, \_SB.WAK) ++ Notify (\_SB.PBTN, 0x2) ++ } ++ } ++ ++ Method (E1C, 0, NotSerialized) ++ { ++ Notify (\_SB.AC, 0x80) ++ } ++ ++ Method (E17, 0, NotSerialized) ++ { ++ Notify (\_SB.LID, 0x80) ++ } ++ ++ Device (LID) ++ { ++ Name (_HID, EisaId ("PNP0C0D")) ++ Method (_LID, 0, NotSerialized) ++ { ++ Store (\_SB.P88, Local0) ++ If (And (Local0, 0x4)) ++ { ++ Return (0x1) ++ } ++ ++ Return (0x0) ++ } ++ ++ Name (_PRW, Package (0x02) ++ { ++ 0x17, ++ 0x03 ++ }) ++ ++ Method (_PSW, 1, NotSerialized) ++ { ++ Store (\_SB.P88, Local0) ++ If (And (Local0, 0x4)) ++ { ++ Return (0x1) ++ } ++ Return (0x0) ++ } ++ } ++ ++ Device (PBTN) ++ { ++ Name (_HID, EisaId ("PNP0C0C")) ++ ++ Name (_PRW, Package (0x02) ++ { ++ 0x01, ++ 0x04 ++ }) ++ } ++ ++ Device (SLPB) ++ { ++ Name (_HID, EisaId ("PNP0C0E")) ++ ++ Name (_PRW, Package (0x02) ++ { ++ 0x01, ++ 0x04 ++ }) ++ } ++ + Device (AC) + { + Name (_HID, "ACPI0003") +@@ -304,6 +402,12 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + }) + Method (_PSR, 0, NotSerialized) + { ++ Store (\_SB.P88, Local0) ++ If (And (Local0, 0x1)) ++ { ++ Return (0x1) ++ } ++ + Return (0x0) + } + +@@ -348,11 +452,16 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + \_SB + }) + +- /* Always returns 0x1f indicating battery present. */ ++ /* Returning 0x1F indicates battery present */ + Method (_STA, 0, NotSerialized) + { + Store (\_SB.P88, Local0) +- Return ( Local0 ) ++ If (And (Local0, 0x2)) ++ { ++ Return (0x1F) ++ } ++ ++ Return (0x0F) + } + + /* Battery generic info: design capacity, voltage, model # etc. */ +@@ -367,7 +476,7 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + /* Battery status including battery charging/discharging rate. */ + Method (_BST, 0, NotSerialized) + { +- Store (1, \_SB.DBG1) ++ /* Store (1, \_SB.DBG1) */ + ACQR () + INIT (0x02) + INIT (0x01) +@@ -378,7 +487,7 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + Store (HLP7 (), Index (BST0, 0x02)) + Store (HLP7 (), Index (BST0, 0x03)) + REL () +- Store (2, \_SB.DBG1) ++ /* Store (2, \_SB.DBG1) */ + Return (BST0) + } + } +@@ -419,5 +528,31 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) + } + } + } ++ ++ /* Wire GPE events to notify power state ++ * changes like ac power to battery use etc. ++ */ ++ Scope (\_GPE) ++ { ++ Method (_L00, 0, NotSerialized) ++ { ++ \_SB.E0() ++ } ++ ++ Method (_L01, 0, NotSerialized) ++ { ++ \_SB.E1() ++ } ++ ++ Method (_L1C, 0, NotSerialized) ++ { ++ \_SB.E1C() ++ } ++ ++ Method (_L17, 0, NotSerialized) ++ { ++ \_SB.E17() ++ } ++ } + } + +diff --git a/tools/firmware/hvmloader/acpi/ssdt_pm.h b/tools/firmware/hvmloader/acpi/ssdt_pm.h +index 020af0b..f277767 100644 +--- a/tools/firmware/hvmloader/acpi/ssdt_pm.h ++++ b/tools/firmware/hvmloader/acpi/ssdt_pm.h +@@ -1,22 +1,22 @@ + /* + * + * Intel ACPI Component Architecture +- * ASL Optimizing Compiler version 20061109 [May 18 2007] +- * Copyright (C) 2000 - 2006 Intel Corporation ++ * ASL Optimizing Compiler version 20080729 [Nov 24 2008] ++ * Copyright (C) 2000 - 2008 Intel Corporation + * Supports ACPI Specification Revision 3.0a + * +- * Compilation of "ssdt_pm.asl" - Sun Oct 12 23:57:51 2008 ++ * Compilation of "ssdt_pm.asl" - Thu May 14 12:24:23 2009 + * + * C source code output + * + */ + unsigned char AmlCode_PM[] = + { +- 0x53,0x53,0x44,0x54,0xD6,0x05,0x00,0x00, /* 00000000 "SSDT...." */ +- 0x02,0xD9,0x58,0x65,0x6E,0x00,0x00,0x00, /* 00000008 "..Xen..." */ ++ 0x53,0x53,0x44,0x54,0xA4,0x07,0x00,0x00, /* 00000000 "SSDT...." */ ++ 0x02,0x15,0x58,0x65,0x6E,0x00,0x00,0x00, /* 00000008 "..Xen..." */ + 0x48,0x56,0x4D,0x00,0x00,0x00,0x00,0x00, /* 00000010 "HVM....." */ + 0x00,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */ +- 0x09,0x11,0x06,0x20,0x10,0x41,0x5B,0x5C, /* 00000020 "... .A[\" */ ++ 0x29,0x07,0x08,0x20,0x10,0x43,0x73,0x5C, /* 00000020 ").. .Cs\" */ + 0x5F,0x53,0x42,0x5F,0x5B,0x80,0x44,0x42, /* 00000028 "_SB_[.DB" */ + 0x47,0x41,0x01,0x0B,0x40,0xB0,0x01,0x5B, /* 00000030 "GA..@..[" */ + 0x81,0x0B,0x44,0x42,0x47,0x41,0x01,0x44, /* 00000038 "..DBGA.D" */ +@@ -39,164 +39,222 @@ unsigned char AmlCode_PM[] = + 0x5B,0x80,0x50,0x52,0x54,0x33,0x01,0x0A, /* 000000C0 "[.PRT3.." */ + 0x88,0x01,0x5B,0x81,0x0B,0x50,0x52,0x54, /* 000000C8 "..[..PRT" */ + 0x33,0x01,0x50,0x38,0x38,0x5F,0x08,0x5B, /* 000000D0 "3.P88_.[" */ +- 0x01,0x53,0x59,0x4E,0x43,0x01,0x08,0x42, /* 000000D8 ".SYNC..B" */ +- 0x55,0x46,0x30,0x11,0x04,0x0B,0x00,0x01, /* 000000E0 "UF0....." */ +- 0x08,0x42,0x55,0x46,0x31,0x11,0x03,0x0A, /* 000000E8 ".BUF1..." */ +- 0x08,0x8B,0x42,0x55,0x46,0x31,0x00,0x42, /* 000000F0 "..BUF1.B" */ +- 0x55,0x46,0x41,0x8B,0x42,0x55,0x46,0x31, /* 000000F8 "UFA.BUF1" */ +- 0x0A,0x04,0x42,0x55,0x46,0x42,0x14,0x14, /* 00000100 "..BUFB.." */ +- 0x41,0x43,0x51,0x52,0x00,0x5B,0x23,0x53, /* 00000108 "ACQR.[#S" */ +- 0x59,0x4E,0x43,0xFF,0xFF,0x70,0x00,0x42, /* 00000110 "YNC..p.B" */ +- 0x55,0x46,0x41,0x14,0x31,0x49,0x4E,0x49, /* 00000118 "UFA.1INI" */ +- 0x54,0x01,0x70,0x42,0x55,0x46,0x41,0x60, /* 00000120 "T.pBUFA`" */ +- 0x75,0x60,0xA0,0x22,0x92,0x94,0x60,0x87, /* 00000128 "u`."..`." */ +- 0x42,0x55,0x46,0x30,0x8C,0x42,0x55,0x46, /* 00000130 "BUF0.BUF" */ +- 0x30,0x42,0x55,0x46,0x41,0x54,0x4D,0x50, /* 00000138 "0BUFATMP" */ +- 0x31,0x70,0x68,0x54,0x4D,0x50,0x31,0x70, /* 00000140 "1phTMP1p" */ +- 0x60,0x42,0x55,0x46,0x41,0x14,0x48,0x07, /* 00000148 "`BUFA.H." */ +- 0x57,0x50,0x52,0x54,0x02,0x70,0x69,0x5C, /* 00000150 "WPRT.pi\" */ +- 0x2E,0x5F,0x53,0x42,0x5F,0x50,0x38,0x36, /* 00000158 "._SB_P86" */ +- 0x5F,0x70,0x68,0x5C,0x2E,0x5F,0x53,0x42, /* 00000160 "_ph\._SB" */ +- 0x5F,0x50,0x42,0x32,0x5F,0x70,0x68,0x5C, /* 00000168 "_PB2_ph\" */ +- 0x2E,0x5F,0x53,0x42,0x5F,0x44,0x42,0x47, /* 00000170 "._SB_DBG" */ +- 0x32,0x70,0x69,0x5C,0x2E,0x5F,0x53,0x42, /* 00000178 "2pi\._SB" */ +- 0x5F,0x44,0x42,0x47,0x34,0x70,0x5C,0x2E, /* 00000180 "_DBG4p\." */ +- 0x5F,0x53,0x42,0x5F,0x50,0x42,0x32,0x5F, /* 00000188 "_SB_PB2_" */ +- 0x60,0xA2,0x11,0x92,0x93,0x60,0x00,0x70, /* 00000190 "`....`.p" */ +- 0x5C,0x2E,0x5F,0x53,0x42,0x5F,0x50,0x42, /* 00000198 "\._SB_PB" */ +- 0x32,0x5F,0x60,0x70,0x5C,0x2E,0x5F,0x53, /* 000001A0 "2_`p\._S" */ +- 0x42,0x5F,0x50,0x38,0x36,0x5F,0x61,0x70, /* 000001A8 "B_P86_ap" */ +- 0x61,0x5C,0x2E,0x5F,0x53,0x42,0x5F,0x44, /* 000001B0 "a\._SB_D" */ +- 0x42,0x47,0x33,0xA4,0x5C,0x2E,0x5F,0x53, /* 000001B8 "BG3.\._S" */ +- 0x42,0x5F,0x50,0x38,0x36,0x5F,0x14,0x1D, /* 000001C0 "B_P86_.." */ +- 0x48,0x4C,0x50,0x31,0x02,0xA0,0x16,0x95, /* 000001C8 "HLP1...." */ +- 0x69,0x87,0x68,0x8C,0x68,0x69,0x54,0x4D, /* 000001D0 "i.h.hiTM" */ +- 0x50,0x31,0x57,0x50,0x52,0x54,0x0A,0x7C, /* 000001D8 "P1WPRT.|" */ +- 0x54,0x4D,0x50,0x31,0x14,0x23,0x48,0x4C, /* 000001E0 "TMP1.#HL" */ +- 0x50,0x32,0x00,0x57,0x50,0x52,0x54,0x0A, /* 000001E8 "P2.WPRT." */ +- 0x7B,0x00,0x70,0x00,0x60,0xA2,0x12,0x95, /* 000001F0 "{.p.`..." */ +- 0x60,0x42,0x55,0x46,0x41,0x48,0x4C,0x50, /* 000001F8 "`BUFAHLP" */ +- 0x31,0x42,0x55,0x46,0x30,0x60,0x75,0x60, /* 00000200 "1BUF0`u`" */ +- 0x14,0x1F,0x48,0x4C,0x50,0x33,0x02,0xA0, /* 00000208 "..HLP3.." */ +- 0x18,0x95,0x69,0x87,0x68,0x8C,0x68,0x69, /* 00000210 "..i.h.hi" */ +- 0x54,0x4D,0x50,0x31,0x70,0x57,0x50,0x52, /* 00000218 "TMP1pWPR" */ +- 0x54,0x0A,0x7D,0x00,0x54,0x4D,0x50,0x31, /* 00000220 "T.}.TMP1" */ +- 0x14,0x23,0x48,0x4C,0x50,0x34,0x00,0x70, /* 00000228 ".#HLP4.p" */ +- 0x00,0x60,0xA2,0x19,0x95,0x60,0x42,0x55, /* 00000230 ".`...`BU" */ +- 0x46,0x42,0x72,0x42,0x55,0x46,0x41,0x60, /* 00000238 "FBrBUFA`" */ +- 0x61,0x48,0x4C,0x50,0x33,0x42,0x55,0x46, /* 00000240 "aHLP3BUF" */ +- 0x30,0x61,0x75,0x60,0x14,0x42,0x04,0x48, /* 00000248 "0au`.B.H" */ +- 0x4C,0x50,0x35,0x00,0x48,0x4C,0x50,0x32, /* 00000250 "LP5.HLP2" */ +- 0x70,0x57,0x50,0x52,0x54,0x0A,0x79,0x00, /* 00000258 "pWPRT.y." */ +- 0x42,0x55,0x46,0x42,0x72,0x42,0x55,0x46, /* 00000260 "BUFBrBUF" */ +- 0x41,0x42,0x55,0x46,0x42,0x60,0xA0,0x1C, /* 00000268 "ABUFB`.." */ +- 0x95,0x87,0x42,0x55,0x46,0x30,0x60,0x70, /* 00000270 "..BUF0`p" */ +- 0x87,0x42,0x55,0x46,0x30,0x60,0x74,0x60, /* 00000278 ".BUF0`t`" */ +- 0x42,0x55,0x46,0x41,0x60,0x70,0x60,0x42, /* 00000280 "BUFA`p`B" */ +- 0x55,0x46,0x42,0x48,0x4C,0x50,0x34,0x14, /* 00000288 "UFBHLP4." */ +- 0x32,0x48,0x4C,0x50,0x36,0x00,0x70,0x42, /* 00000290 "2HLP6.pB" */ +- 0x55,0x46,0x41,0x60,0x75,0x60,0xA0,0x21, /* 00000298 "UFA`u`.!" */ +- 0x92,0x94,0x60,0x87,0x42,0x55,0x46,0x30, /* 000002A0 "..`.BUF0" */ +- 0x8C,0x42,0x55,0x46,0x30,0x42,0x55,0x46, /* 000002A8 ".BUF0BUF" */ +- 0x41,0x54,0x4D,0x50,0x31,0x70,0x60,0x42, /* 000002B0 "ATMP1p`B" */ +- 0x55,0x46,0x41,0xA4,0x54,0x4D,0x50,0x31, /* 000002B8 "UFA.TMP1" */ +- 0xA4,0x00,0x14,0x35,0x48,0x4C,0x50,0x37, /* 000002C0 "...5HLP7" */ +- 0x00,0x70,0x42,0x55,0x46,0x41,0x60,0x72, /* 000002C8 ".pBUFA`r" */ +- 0x60,0x0A,0x04,0x60,0xA0,0x21,0x92,0x94, /* 000002D0 "`..`.!.." */ +- 0x60,0x87,0x42,0x55,0x46,0x30,0x8A,0x42, /* 000002D8 "`.BUF0.B" */ +- 0x55,0x46,0x30,0x42,0x55,0x46,0x41,0x53, /* 000002E0 "UF0BUFAS" */ +- 0x58,0x32,0x32,0x70,0x60,0x42,0x55,0x46, /* 000002E8 "X22p`BUF" */ +- 0x41,0xA4,0x53,0x58,0x32,0x32,0xA4,0x00, /* 000002F0 "A.SX22.." */ +- 0x14,0x1C,0x48,0x4C,0x50,0x38,0x02,0xA0, /* 000002F8 "..HLP8.." */ +- 0x15,0x95,0x69,0x87,0x68,0x8C,0x68,0x69, /* 00000300 "..i.h.hi" */ +- 0x54,0x4D,0x50,0x31,0x70,0x48,0x4C,0x50, /* 00000308 "TMP1pHLP" */ +- 0x36,0x54,0x4D,0x50,0x31,0x14,0x16,0x48, /* 00000310 "6TMP1..H" */ +- 0x4C,0x50,0x39,0x02,0x70,0x00,0x60,0xA2, /* 00000318 "LP9.p.`." */ +- 0x0C,0x95,0x60,0x69,0x48,0x4C,0x50,0x38, /* 00000320 "..`iHLP8" */ +- 0x68,0x60,0x75,0x60,0x14,0x22,0x48,0x4C, /* 00000328 "h`u`."HL" */ +- 0x50,0x41,0x00,0x70,0x48,0x4C,0x50,0x36, /* 00000330 "PA.pHLP6" */ +- 0x60,0x08,0x54,0x4D,0x50,0x5F,0x11,0x02, /* 00000338 "`.TMP_.." */ +- 0x60,0x48,0x4C,0x50,0x39,0x54,0x4D,0x50, /* 00000340 "`HLP9TMP" */ +- 0x5F,0x60,0xA4,0x54,0x4D,0x50,0x5F,0x14, /* 00000348 "_`.TMP_." */ +- 0x0C,0x52,0x45,0x4C,0x5F,0x00,0x5B,0x27, /* 00000350 ".REL_.['" */ +- 0x53,0x59,0x4E,0x43,0x5B,0x82,0x3C,0x41, /* 00000358 "SYNC[. ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define AC_ADAPTER_STATE_FILE_PATH "/proc/acpi/ac_adapter/AC/state" ++#define LID_STATE_FILE_PATH "/proc/acpi/button/lid/LID/state" ++#define ACPID_SOCKET_PATH "/var/run/acpid.socket" ++ ++#define XS_AC_ADAPTER_STATE_PATH "/pm/ac_adapter" ++#define XS_LID_STATE_PATH "/pm/lid_state" ++ ++#define XS_AC_ADAPTER_EVENT_PATH "/pm/events/acadapterstatechanged" ++#define XS_LID_EVENT_PATH "/pm/events/lidstatechanged" ++#define XS_PBTN_EVENT_PATH "/pm/events/powerbuttonpressed" ++#define XS_SBTN_EVENT_PATH "/pm/events/sleepbuttonpressed" ++ ++static int socket_fd; ++static pthread_t acpi_thread; ++extern struct xs_handle *xs; ++ ++void write_state_info_in_xenstore(char *file_path, char *xenstore_path, ++ char *search_str, char *default_value, char *alternate_value) ++{ ++ FILE *file; ++ char file_data[1024]; ++ ++ xs_write(xs, XBT_NULL, xenstore_path, default_value, strlen(default_value)); ++ file = fopen(file_path, "r"); ++ if ( file == NULL ) ++ return; ++ ++ memset(file_data, 0, 1024); ++ fgets(file_data, 1024, file); ++ if ( strstr(file_data, search_str) ) ++ xs_write(xs, XBT_NULL, xenstore_path, alternate_value, ++ strlen(alternate_value)); ++ fclose(file); ++} ++ ++void initialize_system_state_info(void) ++{ ++ write_state_info_in_xenstore(AC_ADAPTER_STATE_FILE_PATH, ++ XS_AC_ADAPTER_STATE_PATH, "off-line", "1", "0"); ++ write_state_info_in_xenstore(LID_STATE_FILE_PATH, XS_LID_STATE_PATH, ++ "closed", "1", "0"); ++} ++ ++void handle_ac_adapter_state_change(void) ++{ ++ write_state_info_in_xenstore(AC_ADAPTER_STATE_FILE_PATH, ++ XS_AC_ADAPTER_STATE_PATH, "off-line", "1", "0"); ++ xs_write(xs, XBT_NULL, XS_AC_ADAPTER_EVENT_PATH, "1", 1); ++} ++ ++void handle_lid_state_change(void) ++{ ++ write_state_info_in_xenstore(LID_STATE_FILE_PATH, XS_LID_STATE_PATH, ++ "closed", "1", "0"); ++ xs_write(xs, XBT_NULL, XS_LID_EVENT_PATH, "1", 1); ++} ++ ++void handle_pbtn_pressed_event(void) ++{ ++ xs_write(xs, XBT_NULL, XS_PBTN_EVENT_PATH, "1", 1); ++} ++ ++void handle_sbtn_pressed_event(void) ++{ ++ xs_write(xs, XBT_NULL, XS_SBTN_EVENT_PATH, "1", 1); ++} ++ ++void process_acpi_message(char *acpi_buffer) ++{ ++ if ( strstr(acpi_buffer, "ac_adapter") ) ++ { ++ handle_ac_adapter_state_change(); ++ return; ++ } ++ ++ if ( strstr(acpi_buffer, "LID") ) ++ { ++ handle_lid_state_change(); ++ return; ++ } ++ ++ if ( (strstr(acpi_buffer, "PBTN")) || ++ (strstr(acpi_buffer, "PWRF")) ) ++ { ++ handle_pbtn_pressed_event(); ++ return; ++ } ++ ++ if ( strstr(acpi_buffer, "SBTN") ) ++ handle_sbtn_pressed_event(); ++} ++ ++static void *acpi_events_thread(void *arg) ++{ ++ int ret; ++ struct sockaddr_un addr; ++ char acpi_buffer[1024]; ++ ++ socket_fd = socket(PF_UNIX, SOCK_STREAM, 0); ++ if ( socket_fd == -1) ++ return (void *)socket_fd; ++ ++ addr.sun_family = AF_UNIX; ++ strncpy(addr.sun_path, ACPID_SOCKET_PATH, strlen(ACPID_SOCKET_PATH)); ++ addr.sun_path[strlen(ACPID_SOCKET_PATH)] = '\0'; ++ ret = connect(socket_fd, (struct sockaddr *)&addr, sizeof(addr)); ++ if ( ret == -1 ) ++ return (void *)ret; ++ ++ while( 1 ) ++ { ++ memset(acpi_buffer, 0, sizeof(acpi_buffer)); ++ ret = recv(socket_fd, acpi_buffer, sizeof(acpi_buffer), 0); ++ if ( ret == 0 ) ++ continue; ++ ++ process_acpi_message(acpi_buffer); ++ } ++ ++ return (void *)1; ++} ++ ++void monitor_acpi_events(void) ++{ ++ pthread_create(&acpi_thread, NULL, &acpi_events_thread, NULL); ++} ++ ++void acpi_events_cleanup(void) ++{ ++ if ( socket_fd != -1 ) ++ close(socket_fd); ++ ++ pthread_cancel(acpi_thread); ++} ++ +diff --git a/tools/xenpmd/xenpmd.c b/tools/xenpmd/xenpmd.c +index 28de744..9bc0cc1 100644 +--- a/tools/xenpmd/xenpmd.c ++++ b/tools/xenpmd/xenpmd.c +@@ -40,10 +40,11 @@ + #include + #include + #include ++#include + #include + + /* #define RUN_STANDALONE */ +-#define RUN_IN_SIMULATE_MODE ++/* #define RUN_IN_SIMULATE_MODE */ + + enum BATTERY_INFO_TYPE { + BIF, +@@ -84,7 +85,12 @@ struct battery_status { + unsigned long present_voltage; + }; + +-static struct xs_handle *xs; ++struct xs_handle *xs; ++static pthread_t worker_thread; ++ ++extern void initialize_system_state_info(void); ++extern void monitor_acpi_events(void); ++extern void acpi_events_cleanup(void); + + #ifdef RUN_IN_SIMULATE_MODE + #define BATTERY_DIR_PATH "/tmp/battery" +@@ -218,11 +224,19 @@ void set_attribute_battery_status(char *attrib_name, + { + if ( strstr(attrib_name, "charging state") ) + { +- /* Check this, below is half baked */ +- if ( strstr(attrib_value, "charged") ) +- status->state = 0; +- else +- status->state = 1; ++ if ( strstr(attrib_value, "charging/discharging") ) ++ status->state |= 0x3; ++ else if ( strstr(attrib_value, "discharging") ) ++ status->state |= 0x1; ++ else if ( strstr(attrib_value, "charging") ) ++ status->state |= 0x2; ++ return; ++ } ++ ++ if ( strstr(attrib_name, "capacity state") ) ++ { ++ if ( strstr(attrib_value, "ok") ) ++ status->state |= 4; + return; + } + +@@ -292,11 +306,12 @@ int get_next_battery_info_or_status(DIR *battery_dir, + void *info_or_status) + { + FILE *file; +- char line_info[256]; ++ char line_info[1024]; + + if ( !info_or_status ) + return 0; + ++ memset(line_info, 0, sizeof (line_info)); + if (type == BIF) + memset(info_or_status, 0, sizeof(struct battery_info)); + else +@@ -306,8 +321,11 @@ int get_next_battery_info_or_status(DIR *battery_dir, + if ( !file ) + return 0; + +- while ( fgets(line_info, sizeof(line_info), file) != NULL ) ++ while ( fgets(line_info, sizeof (line_info), file) != NULL ) ++ { + parse_battery_info_or_status(line_info, type, info_or_status); ++ memset(line_info, 0, sizeof (line_info)); ++ } + + fclose(file); + return 1; +@@ -317,14 +335,14 @@ int get_next_battery_info_or_status(DIR *battery_dir, + void print_battery_info(struct battery_info *info) + { + printf("present: %d\n", info->present); +- printf("design capacity: %d\n", info->design_capacity); +- printf("last full capacity: %d\n", info->last_full_capacity); ++ printf("design capacity: %d\n", (int) info->design_capacity); ++ printf("last full capacity: %d\n", (int) info->last_full_capacity); + printf("battery technology: %d\n", info->battery_technology); +- printf("design voltage: %d\n", info->design_voltage); +- printf("design capacity warning:%d\n", info->design_capacity_warning); +- printf("design capacity low: %d\n", info->design_capacity_low); +- printf("capacity granularity 1: %d\n", info->capacity_granularity_1); +- printf("capacity granularity 2: %d\n", info->capacity_granularity_2); ++ printf("design voltage: %d\n", (int) info->design_voltage); ++ printf("design capacity warning:%d\n", (int) info->design_capacity_warning); ++ printf("design capacity low: %d\n", (int) info->design_capacity_low); ++ printf("capacity granularity 1: %d\n", (int) info->capacity_granularity_1); ++ printf("capacity granularity 2: %d\n", (int) info->capacity_granularity_2); + printf("model number: %s\n", info->model_number); + printf("serial number: %s\n", info->serial_number); + printf("battery type: %s\n", info->battery_type); +@@ -406,10 +424,11 @@ int write_one_time_battery_info(void) + void print_battery_status(struct battery_status *status) + { + printf("present: %d\n", status->present); +- printf("Battery state %d\n", status->state); +- printf("Battery present rate %d\n", status->present_rate); +- printf("Battery remining capacity %d\n", status->remaining_capacity); +- printf("Battery present voltage %d\n", status->present_voltage); ++ printf("Battery state %d\n", (int) status->state); ++ printf("Battery present rate %d\n", (int) status->present_rate); ++ printf("Battery remining capacity %d\n", ++ (int) status->remaining_capacity); ++ printf("Battery present voltage %d\n", (int) status->present_voltage); + } + #endif /*RUN_STANDALONE*/ + +@@ -469,6 +488,7 @@ int wait_for_and_update_battery_status_request(void) + return ret; + } + ++#ifndef RUN_STANDALONE + /* Borrowed daemonize from xenstored - Initially written by Stevens. */ + static void daemonize(void) + { +@@ -493,24 +513,57 @@ static void daemonize(void) + + umask(0); + } ++#endif + +-int main(int argc, char *argv[]) ++/* ++ * IMPORTANT: From the child process, we create a new thread ++ * to monitor acpid events. However, due to a bug in uClibc, ++ * the child process main thread does not get time slice ++ * after spawning a new thread. To work around this, we create ++ * a worker thread and then create an acpid monitor thread from ++ * this worker thread. This way both the worker thread and acpid ++ * thread will get time slices. This workaround will be removed ++ * once uClibc bug is fixed. ++ */ ++static void *worker_thread_routine(void *arg) + { + #ifndef RUN_STANDALONE + daemonize(); + #endif + xs = (struct xs_handle *)xs_daemon_open(); +- if ( xs == NULL ) +- return -1; +- +- if ( write_one_time_battery_info() == 0 ) ++ if ( xs == NULL ) ++ return NULL; ++ if ( xs == NULL ) ++ return NULL; ++ ++ if ( write_one_time_battery_info() == 0 ) ++ initialize_system_state_info(); ++ monitor_acpi_events(); ++ if ( write_one_time_battery_info() == 0 ) + { + xs_daemon_close(xs); +- return -1; ++ return NULL; + } + + wait_for_and_update_battery_status_request(); ++ acpi_events_cleanup(); + xs_daemon_close(xs); +- return 0; ++ return NULL; + } + ++ ++int main(int argc, char *argv[]) ++{ ++#ifndef RUN_STANDALONE ++ daemonize(); ++#endif ++ ++ /* Refer to worker_thread_routine for why we create additional thread */ ++ pthread_create(&worker_thread, NULL, &worker_thread_routine, NULL); ++ ++ /* below won't get a time slice because of uClibc bug. */ ++ while ( 1 ) ++ sleep(60); ++ ++ return 0; ++} diff --git a/master/pt-load-vga-bios b/master/pt-load-vga-bios new file mode 100644 index 0000000..e16f263 --- /dev/null +++ b/master/pt-load-vga-bios @@ -0,0 +1,199 @@ +diff --git a/tools/libxc/xc_hvm_build.c b/tools/libxc/xc_hvm_build.c +index e20f5ac..0ba8c44 100644 +--- a/tools/libxc/xc_hvm_build.c ++++ b/tools/libxc/xc_hvm_build.c +@@ -66,6 +66,54 @@ static void build_hvm_info(void *hvm_info_page, uint64_t mem_size) + hvm_info->checksum = -sum; + } + ++static int setup_vga_pt(int xc_handle, ++ uint32_t dom) ++{ ++ int rc = 0; ++ unsigned char *bios = NULL; ++ int bios_size = 0; ++ char *va_bios = NULL; ++ uint32_t va_size = 0; ++ char *c = NULL; ++ char checksum = 0; ++ ++ /* Allocated 64K for the vga bios */ ++ if (!(bios = malloc(64 * 1024))) ++ return -1; ++ ++#ifdef __linux__ ++ bios_size = xc_get_vgabios(bios, 64 * 1024); ++#else ++ bios_size = 0; ++#endif /* __linux__ */ ++ ++ va_size = bios_size + bios_size % XC_PAGE_SIZE; ++ if (bios_size == 0) ++ { ++ rc = -1; ++ goto error; ++ } ++ va_bios = xc_map_foreign_range(xc_handle, dom, va_size, ++ PROT_READ | PROT_WRITE, 0xC0); ++ if (!va_bios) ++ { ++ rc = -1; ++ goto error; ++ } ++ ++ /* Adjust the bios checksum */ ++ for ( c = (char*)bios; c < ((char*)bios + bios_size); c++ ) ++ checksum += *c; ++ if (checksum) ++ bios[bios_size - 1] -= checksum; ++ ++ memcpy(va_bios, bios, bios_size); ++ munmap(va_bios, va_size); ++error: ++ free(bios); ++ return rc; ++} ++ + static int loadelfimage( + struct elf_binary *elf, int xch, uint32_t dom, unsigned long *parray) + { +@@ -354,7 +402,8 @@ static inline int is_loadable_phdr(Elf32_Phdr *phdr) + int xc_hvm_build(int xc_handle, + uint32_t domid, + int memsize, +- const char *image_name) ++ const char *image_name, ++ int vga_pt_enabled) + { + char *image; + int sts; +@@ -365,6 +414,8 @@ int xc_hvm_build(int xc_handle, + return -1; + + sts = xc_hvm_build_internal(xc_handle, domid, memsize, memsize, image, image_size); ++ if ( vga_pt_enabled ) ++ sts |= setup_vga_pt(xc_handle, domid); + + free(image); + +diff --git a/tools/libxc/xc_linux.c b/tools/libxc/xc_linux.c +index 2480b3c..6068960 100644 +--- a/tools/libxc/xc_linux.c ++++ b/tools/libxc/xc_linux.c +@@ -562,6 +562,57 @@ int xc_gnttab_set_max_grants(int xcg_handle, + return 0; + } + ++int xc_get_vgabios(unsigned char *buf, ++ int len) ++{ ++ int mem; ++ uint32_t start, size = 0; ++ uint16_t magic = 0; ++ ++ start = 0xC0000; ++ if (len < size) ++ return 0; ++ if ((mem = open("/dev/mem", O_RDONLY)) < 0) ++ return 0; ++ ++ /* ++ ** Check if it a real bios extension. ++ ** The magic number is 0xAA55. ++ */ ++ if (start != lseek(mem, start, SEEK_SET)) ++ goto out; ++ if (read(mem, &magic, 2) != 2) ++ goto out; ++ if (magic != 0xAA55) ++ goto out; ++ ++ /* Find the size of the rom extension */ ++ if (start != lseek(mem, start, SEEK_SET)) ++ goto out; ++ if (lseek(mem, 2, SEEK_CUR) != (start + 2)) ++ goto out; ++ if (read(mem, &size, 1) != 1) ++ goto out; ++ /* This size is in 512K */ ++ size *= 512; ++ ++ /* ++ ** Set the file to the begining of the rombios, ++ ** to start the copy. ++ */ ++ if (start != lseek(mem, start, SEEK_SET)) ++ { ++ size = 0; ++ goto out; ++ } ++ if (size != read(mem, buf, size)) ++ size = 0; ++ ++out: ++ close(mem); ++ return size; ++} ++ + /* + * Local variables: + * mode: C +diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h +index 9ce2286..dfd6fa4 100644 +--- a/tools/libxc/xenctrl.h ++++ b/tools/libxc/xenctrl.h +@@ -145,6 +145,10 @@ int xc_waitdomain( + int *status, + int options); + ++int xc_get_vgabios( ++ unsigned char *bios, ++ int len); ++ + #endif /* __linux__ */ + + /* +diff --git a/tools/libxc/xenguest.h b/tools/libxc/xenguest.h +index d64fc45..e58302b 100644 +--- a/tools/libxc/xenguest.h ++++ b/tools/libxc/xenguest.h +@@ -125,10 +125,12 @@ int xc_linux_build_mem(int xc_handle, + unsigned int console_evtchn, + unsigned long *console_mfn); + ++#define USE_VGA_PASSTHROUGH_IN_HVM_BUILD + int xc_hvm_build(int xc_handle, + uint32_t domid, + int memsize, +- const char *image_name); ++ const char *image_name, ++ int vga_pt_enabled); + + int xc_hvm_build_target_mem(int xc_handle, + uint32_t domid, +diff --git a/tools/libxc/xg_private.c b/tools/libxc/xg_private.c +index 4dc3a5c..2a3706e 100644 +--- a/tools/libxc/xg_private.c ++++ b/tools/libxc/xg_private.c +@@ -177,7 +177,8 @@ __attribute__((weak)) + int xc_hvm_build(int xc_handle, + uint32_t domid, + int memsize, +- const char *image_name) ++ const char *image_name, ++ int vga_pt_enabled) + { + errno = ENOSYS; + return -1; +diff --git a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h +index eb965dc..774a7d5 100644 +--- a/xen/include/public/hvm/hvm_info_table.h ++++ b/xen/include/public/hvm/hvm_info_table.h +@@ -36,6 +36,7 @@ + #define HVM_ACINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_ACINFO_OFFSET) + #define HVM_ACINFO_MAX 0x400 + ++#define XEN_BRANCH_3_4 + #define HVM_SMINFO_EXTENSIONS 1 + #define HVM_ACINFO_EXTENSIONS 1 + diff --git a/master/remove-fixed-host-bridge-check b/master/remove-fixed-host-bridge-check new file mode 100644 index 0000000..329696b --- /dev/null +++ b/master/remove-fixed-host-bridge-check @@ -0,0 +1,13 @@ +diff --git a/tools/firmware/rombios/rombios.c b/tools/firmware/rombios/rombios.c +index 0aea421..1e5420c 100644 +--- a/tools/firmware/rombios/rombios.c ++++ b/tools/firmware/rombios/rombios.c +@@ -220,7 +220,7 @@ + // define this if you want to make PCIBIOS working on a specific bridge only + // undef enables PCIBIOS when at least one PCI device is found + // i440FX is emulated by Bochs and QEMU +-#define PCI_FIXED_HOST_BRIDGE 0x12378086 ;; i440FX PCI bridge ++//#define PCI_FIXED_HOST_BRIDGE 0x12378086 ;; i440FX PCI bridge + + // #20 is dec 20 + // #$20 is hex 20 = 32 diff --git a/master/series b/master/series new file mode 100644 index 0000000..b6d30f7 --- /dev/null +++ b/master/series @@ -0,0 +1,12 @@ +fix_compilation +power-management-enhancement +smbios +acpi-slic +oem-features +thermal-management +pt-load-vga-bios +init-vgabios-and-set-size +#module-reloc +mfn-validity-check-before-shadow-remove +remove-fixed-host-bridge-check +mtrr-changes diff --git a/master/smbios b/master/smbios new file mode 100644 index 0000000..972f8f6 --- /dev/null +++ b/master/smbios @@ -0,0 +1,786 @@ +diff +--- /dev/null ++++ b/oem/dell-960-optiplex-smbios.patch 2009-04-01 14:15:16.000000000 -0400 +@@ -0,0 +1,49 @@ ++diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h ++--- a/tools/firmware/hvmloader/markers.h 2008-11-25 12:47:54.000000000 -0500 +++++ b/tools/firmware/hvmloader/markers.h 2008-11-25 12:53:27.000000000 -0500 ++@@ -17,22 +17,22 @@ ++ struct bios_vendor_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; +++} bios_vendor = {BIOS_VENDOR_MARKER, "Dell Inc."}; ++ ++ struct bios_version_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_version = {BIOS_VERSION_MARKER, ""}; +++} bios_version = {BIOS_VERSION_MARKER, "X20"}; ++ ++ struct sys_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; +++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Dell Inc."}; ++ ++ struct sys_product_name_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; +++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "OptiPlex 960"}; ++ ++ struct sys_product_version_struct { ++ char marker[65]; ++@@ -57,15 +57,15 @@ ++ struct sys_enclosure_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; +++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Dell Inc."}; ++ ++ struct sys_enclosure_serial_struct { ++ char marker[65]; ++ char value[65]; ++ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; ++ ++-const char *oem_strings_array[1] = { ++- NULL +++const char *oem_strings_array[2] = { +++ "www.dell.com", NULL ++ }; ++ ++ #endif /* __HVMLOADER_MARKERS_H__ */ +diff +--- /dev/null ++++ b/oem/dell-e6500-latitude-smbios.patch 2009-04-01 14:15:16.000000000 -0400 +@@ -0,0 +1,49 @@ ++diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h ++--- a/tools/firmware/hvmloader/markers.h 2008-12-15 14:44:08.000000000 -0500 +++++ b/tools/firmware/hvmloader/markers.h 2008-12-15 14:56:51.000000000 -0500 ++@@ -17,22 +17,22 @@ ++ struct bios_vendor_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; +++} bios_vendor = {BIOS_VENDOR_MARKER, "Dell Inc."}; ++ ++ struct bios_version_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_version = {BIOS_VERSION_MARKER, ""}; +++} bios_version = {BIOS_VERSION_MARKER, "A09"}; ++ ++ struct sys_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; +++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Dell Inc."}; ++ ++ struct sys_product_name_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; +++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "Latitude E6500"}; ++ ++ struct sys_product_version_struct { ++ char marker[65]; ++@@ -57,15 +57,15 @@ ++ struct sys_enclosure_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; +++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Dell Inc."}; ++ ++ struct sys_enclosure_serial_struct { ++ char marker[65]; ++ char value[65]; ++ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; ++ ++-const char *oem_strings_array[1] = { ++- NULL +++const char *oem_strings_array[4] = { +++ "Dell System", "5[0031]", "13[PP04X]", NULL ++ }; ++ ++ #endif /* __HVMLOADER_MARKERS_H__ */ +diff +--- /dev/null ++++ b/oem/hp-6930p-elitebook-smbios.patch 2009-04-01 14:15:16.000000000 -0400 +@@ -0,0 +1,67 @@ ++diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h ++--- a/tools/firmware/hvmloader/markers.h 2008-11-25 12:47:54.000000000 -0500 +++++ b/tools/firmware/hvmloader/markers.h 2008-11-25 12:46:41.000000000 -0500 ++@@ -17,27 +17,27 @@ ++ struct bios_vendor_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; +++} bios_vendor = {BIOS_VENDOR_MARKER, "Hewlett-Packard"}; ++ ++ struct bios_version_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_version = {BIOS_VERSION_MARKER, ""}; +++} bios_version = {BIOS_VERSION_MARKER, "68PCU Ver. F.0B"}; ++ ++ struct sys_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; +++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Hewlett-Packard"}; ++ ++ struct sys_product_name_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; +++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HP EliteBook 6930p"}; ++ ++ struct sys_product_version_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; +++} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, "F.0B"}; ++ ++ struct sys_product_serial_struct { ++ char marker[65]; ++@@ -47,25 +47,25 @@ ++ struct sys_product_sku_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, ""}; +++} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, "GB996EA#ABU"}; ++ ++ struct sys_product_family_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; +++} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, "103C_5336AN"}; ++ ++ struct sys_enclosure_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; +++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Hewlett-Packard"}; ++ ++ struct sys_enclosure_serial_struct { ++ char marker[65]; ++ char value[65]; ++ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; ++ ++-const char *oem_strings_array[1] = { ++- NULL +++const char *oem_strings_array[4] = { +++ "ABS 70/71 79 7A 7B 7C", "CSM v01.24", "www.hp.com", NULL ++ }; ++ ++ #endif /* __HVMLOADER_MARKERS_H__ */ +diff +--- /dev/null ++++ b/oem/lenovo-x200-thinkpad-smbios.patch 2009-04-01 14:15:16.000000000 -0400 +@@ -0,0 +1,61 @@ ++diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h ++--- a/tools/firmware/hvmloader/markers.h 2008-12-15 14:44:08.000000000 -0500 +++++ b/tools/firmware/hvmloader/markers.h 2008-12-16 10:09:53.000000000 -0500 ++@@ -17,27 +17,27 @@ ++ struct bios_vendor_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; +++} bios_vendor = {BIOS_VENDOR_MARKER, "LENOVO"}; ++ ++ struct bios_version_struct { ++ char marker[65]; ++ char value[65]; ++-} bios_version = {BIOS_VERSION_MARKER, ""}; +++} bios_version = {BIOS_VERSION_MARKER, "6DET33WW (1.10 )"}; ++ ++ struct sys_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; +++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "LENOVO"}; ++ ++ struct sys_product_name_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; +++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "74542NU"}; ++ ++ struct sys_product_version_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; +++} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, "ThinkPad X200"}; ++ ++ struct sys_product_serial_struct { ++ char marker[65]; ++@@ -52,20 +52,20 @@ ++ struct sys_product_family_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; +++} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, "ThinkPad X200"}; ++ ++ struct sys_enclosure_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; +++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "LENOVO"}; ++ ++ struct sys_enclosure_serial_struct { ++ char marker[65]; ++ char value[65]; ++ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; ++ ++-const char *oem_strings_array[1] = { ++- NULL +++const char *oem_strings_array[2] = { +++ "IBM ThinkPad Embedded Controller -[7XHT21WW-1.03 ]-", NULL ++ }; ++ ++ #endif /* __HVMLOADER_MARKERS_H__ */ +diff +--- /dev/null ++++ b/tools/firmware/hvmloader/markers.h 2009-04-01 14:15:17.000000000 -0400 +@@ -0,0 +1,71 @@ ++#ifndef __HVMLOADER_MARKERS_H__ ++#define __HVMLOADER_MARKERS_H__ ++ ++#define BIOS_VENDOR_MARKER "##############################################BIOS_VENDOR_MARKER" ++#define BIOS_VERSION_MARKER "#############################################BIOS_VERSION_MARKER" ++ ++#define SYS_MANUFACTURER_MARKER "#########################################SYS_MANUFACTURER_MARKER" ++#define SYS_PRODUCT_NAME_MARKER "#########################################SYS_PRODUCT_NAME_MARKER" ++#define SYS_PRODUCT_VERSION_MARKER "######################################SYS_PRODUCT_VERSION_MARKER" ++#define SYS_PRODUCT_SERIAL_MARKER "#######################################SYS_PRODUCT_SERIAL_MARKER" ++#define SYS_PRODUCT_SKU_MARKER "##########################################SYS_PRODUCT_SKU_MARKER" ++#define SYS_PRODUCT_FAMILY_MARKER "#######################################SYS_PRODUCT_FAMILY_MARKER" ++ ++#define SYS_ENCLOSURE_MANUFACTURER_MARKER "###############################SYS_ENCLOSURE_MANUFACTURER_MARKER" ++#define SYS_ENCLOSURE_SERIAL_MARKER "#####################################SYS_ENCLOSURE_SERIAL_MARKER" ++ ++struct bios_vendor_struct { ++ char marker[65]; ++ char value[65]; ++} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; ++ ++struct bios_version_struct { ++ char marker[65]; ++ char value[65]; ++} bios_version = {BIOS_VERSION_MARKER, ""}; ++ ++struct sys_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; ++ ++struct sys_product_name_struct { ++ char marker[65]; ++ char value[65]; ++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; ++ ++struct sys_product_version_struct { ++ char marker[65]; ++ char value[65]; ++} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; ++ ++struct sys_product_serial_struct { ++ char marker[65]; ++ char value[65]; ++} sys_product_serial = {SYS_PRODUCT_SERIAL_MARKER, ""}; ++ ++struct sys_product_sku_struct { ++ char marker[65]; ++ char value[65]; ++} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, ""}; ++ ++struct sys_product_family_struct { ++ char marker[65]; ++ char value[65]; ++} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; ++ ++struct sys_enclosure_manufacturer_struct { ++ char marker[65]; ++ char value[65]; ++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; ++ ++struct sys_enclosure_serial_struct { ++ char marker[65]; ++ char value[65]; ++} sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; ++ ++const char *oem_strings_array[1] = { ++ NULL ++}; ++ ++#endif /* __HVMLOADER_MARKERS_H__ */ +diff -Nur a/tools/firmware/hvmloader/smbios.c b/tools/firmware/hvmloader/smbios.c +--- a/tools/firmware/hvmloader/smbios.c 2009-04-01 14:06:28.000000000 -0400 ++++ b/tools/firmware/hvmloader/smbios.c 2009-04-01 15:34:18.000000000 -0400 +@@ -27,6 +27,7 @@ + #include "util.h" + #include "hypercall.h" + #include "e820.h" ++#include "markers.h" + + static int + write_smbios_tables(void *start, +@@ -54,6 +55,8 @@ + smbios_type_4_init(void *start, unsigned int cpu_number, + char *cpu_manufacturer); + static void * ++smbios_type_11_init(void *start); ++static void * + smbios_type_16_init(void *start, uint32_t memory_size_mb, int nr_mem_devs); + static void * + smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance); +@@ -112,6 +115,7 @@ + do_struct(smbios_type_3_init(p)); + for ( cpu_num = 1; cpu_num <= vcpus; cpu_num++ ) + do_struct(smbios_type_4_init(p, cpu_num, cpu_manufacturer)); ++ do_struct(smbios_type_11_init(p)); + + /* Each 'memory device' covers up to 16GB of address space. */ + nr_mem_devs = (memsize + 0x3fff) >> 14; +@@ -127,6 +131,8 @@ + } + + do_struct(smbios_type_32_init(p)); ++ /* NOTE: future enhancement - vendor specific structures (range 128 - 256) would be ++ processed and added here */ + do_struct(smbios_type_127_init(p)); + + #undef do_struct +@@ -280,9 +286,33 @@ + smbios_type_0_init(void *start, const char *xen_version, + uint32_t xen_major_version, uint32_t xen_minor_version) + { +- struct smbios_type_0 *p = (struct smbios_type_0 *)start; + static const char *smbios_release_date = __SMBIOS_DATE__; ++ struct smbios_type_0 *p = (struct smbios_type_0 *)start; ++ struct hvm_sminfo_table *pa_sm; ++ struct hvm_smtable_header *header; ++ ++ /* if passed a struct, use it */ ++ pa_sm = get_hvm_sminfo_table(); ++ while (pa_sm != NULL) { ++ header = get_sminfo_by_type(pa_sm, 0); ++ if (header == NULL) ++ break; ++ if (header->sm_length < sizeof(struct smbios_type_0)) ++ break; ++ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); ++ ++ /* fix up some bits */ ++ p->header.handle = 0; ++ p->starting_address_segment = 0xe800; ++ p->rom_size = 0; ++ p->characteristics[0] = 0x80; /* PCI is supported */ ++ p->characteristics[2] = 0x08; /* EDD is supported */ ++ p->characteristics_extension_bytes[1] = 0x04; /* Enable Targeted Content Distribution. */ + ++ return (start + header->sm_length); ++ } ++ ++ /* fall back to building our own */ + memset(p, 0, sizeof(*p)); + + p->header.type = 0; +@@ -295,6 +325,7 @@ + p->release_date_str = 3; + p->rom_size = 0; + ++ memset(p->characteristics, 0, 8); + /* BIOS Characteristics. */ + p->characteristics[0] = 0x80; /* PCI is supported */ + p->characteristics[2] = 0x08; /* EDD is supported */ +@@ -308,10 +339,16 @@ + p->embedded_controller_minor = 0xff; + + start += sizeof(struct smbios_type_0); +- strcpy((char *)start, "Xen"); +- start += strlen("Xen") + 1; +- strcpy((char *)start, xen_version); +- start += strlen(xen_version) + 1; ++ strcpy((char *)start, bios_vendor.value); ++ start += strlen(bios_vendor.value) + 1; ++ ++ if ( strlen(bios_version.value) == 0 ) { ++ strncpy(bios_version.value, xen_version, sizeof(bios_version.value)); ++ } ++ ++ strcpy((char *)start, bios_version.value); ++ start += strlen(bios_version.value) + 1; ++ + strcpy((char *)start, smbios_release_date); + start += strlen(smbios_release_date) + 1; + +@@ -326,7 +363,27 @@ + { + char uuid_str[37]; + struct smbios_type_1 *p = (struct smbios_type_1 *)start; ++ int next = 5; ++ struct hvm_sminfo_table *pa_sm; ++ struct hvm_smtable_header *header; ++ ++ /* if passed a struct, use it */ ++ pa_sm = get_hvm_sminfo_table(); ++ while (pa_sm != NULL) { ++ header = get_sminfo_by_type(pa_sm, 1); ++ if (header == NULL) ++ break; ++ if (header->sm_length < sizeof(struct smbios_type_1)) ++ break; ++ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); ++ ++ /* fix up some bits */ ++ p->header.handle = 0x100; ++ ++ return (start + header->sm_length); ++ } + ++ /* fall back to building our own */ + memset(p, 0, sizeof(*p)); + + p->header.type = 1; +@@ -341,20 +398,46 @@ + memcpy(p->uuid, uuid, 16); + + p->wake_up_type = 0x06; /* power switch */ +- p->sku_str = 0; +- p->family_str = 0; + + start += sizeof(struct smbios_type_1); ++ ++ strcpy((char *)start, sys_manufacturer.value); ++ start += strlen(sys_manufacturer.value) + 1; ++ strcpy((char *)start, sys_product_name.value); ++ start += strlen(sys_product_name.value) + 1; ++ ++ if ( strlen(sys_product_version.value) == 0 ) { ++ strncpy(sys_product_version.value, xen_version, sizeof(sys_product_version.value)); ++ } ++ ++ strcpy((char *)start, sys_product_version.value); ++ start += strlen(sys_product_version.value) + 1; ++ ++ if ( strlen(sys_product_serial.value) == 0 ) { ++ uuid_to_string(uuid_str, uuid); ++ strncpy(sys_product_serial.value, uuid_str, sizeof(sys_product_serial.value)); ++ } + +- strcpy((char *)start, "Xen"); +- start += strlen("Xen") + 1; +- strcpy((char *)start, "HVM domU"); +- start += strlen("HVM domU") + 1; +- strcpy((char *)start, xen_version); +- start += strlen(xen_version) + 1; +- uuid_to_string(uuid_str, uuid); +- strcpy((char *)start, uuid_str); +- start += strlen(uuid_str) + 1; ++ strcpy((char *)start, sys_product_serial.value); ++ start += strlen(sys_product_serial.value) + 1; ++ ++ /* no internal defaults for these if the value is not set */ ++ if ( strlen(sys_product_sku.value) != 0 ) { ++ strcpy((char *)start, sys_product_sku.value); ++ start += strlen(sys_product_sku.value) + 1; ++ p->sku_str = next++; ++ } ++ else ++ p->sku_str = 0; ++ ++ if ( strlen(sys_product_family.value) != 0 ) { ++ strcpy((char *)start, sys_product_family.value); ++ start += strlen(sys_product_family.value) + 1; ++ p->family_str = next++; ++ } ++ else ++ p->family_str = 0; ++ + *((uint8_t *)start) = 0; + + return start+1; +@@ -365,7 +448,26 @@ + smbios_type_3_init(void *start) + { + struct smbios_type_3 *p = (struct smbios_type_3 *)start; +- ++ struct hvm_sminfo_table *pa_sm; ++ struct hvm_smtable_header *header; ++ ++ /* if passed a struct, use it */ ++ pa_sm = get_hvm_sminfo_table(); ++ while (pa_sm != NULL) { ++ header = get_sminfo_by_type(pa_sm, 3); ++ if (header == NULL) ++ break; ++ if (header->sm_length < sizeof(struct smbios_type_3)) ++ break; ++ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); ++ ++ /* fix up some bits */ ++ p->header.handle = 0x300; ++ ++ return (start + header->sm_length); ++ } ++ ++ /* fall back to building our own */ + memset(p, 0, sizeof(*p)); + + p->header.type = 3; +@@ -384,8 +486,18 @@ + + start += sizeof(struct smbios_type_3); + +- strcpy((char *)start, "Xen"); +- start += strlen("Xen") + 1; ++ strcpy((char *)start, sys_enclosure_manufacturer.value); ++ start += strlen(sys_enclosure_manufacturer.value) + 1; ++ ++ /* no internal defaults for this if the value is not set */ ++ if ( strlen(sys_enclosure_serial.value) != 0 ) { ++ strcpy((char *)start, sys_enclosure_serial.value); ++ start += strlen(sys_enclosure_serial.value) + 1; ++ p->serial_number_str = 2; ++ } ++ else ++ p->serial_number_str = 0; ++ + *((uint8_t *)start) = 0; + return start+1; + } +@@ -440,6 +552,52 @@ + return start+1; + } + ++/* Type 11 -- OEM Strings */ ++static void * ++smbios_type_11_init(void *start) ++{ ++ struct smbios_type_11 *p = (struct smbios_type_11 *)start; ++ int i = 0; ++ struct hvm_sminfo_table *pa_sm; ++ struct hvm_smtable_header *header; ++ ++ /* if passed a struct, use it */ ++ pa_sm = get_hvm_sminfo_table(); ++ while (pa_sm != NULL) { ++ header = get_sminfo_by_type(pa_sm, 11); ++ if (header == NULL) ++ break; ++ if (header->sm_length < sizeof(struct smbios_type_11)) ++ break; ++ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); ++ ++ /* fix up some bits */ ++ p->header.handle = 0xB00; ++ ++ return (start + header->sm_length); ++ } ++ ++ /* fall back to building our own */ ++ ++ if ( oem_strings_array[0] == NULL ) ++ return start; /* no OEM strings to add */ ++ ++ p->header.type = 11; ++ p->header.length = sizeof(struct smbios_type_11); ++ p->header.handle = 0xB00; ++ start += sizeof(struct smbios_type_11); ++ ++ while ( oem_strings_array[i] != NULL ) { ++ strcpy((char *)start, oem_strings_array[i]); ++ start += strlen(oem_strings_array[i]) + 1; ++ i++; ++ } ++ p->count = i; ++ *((uint8_t *)start) = 0; ++ ++ return start+1; ++} ++ + /* Type 16 -- Physical Memory Array */ + static void * + smbios_type_16_init(void *start, uint32_t memsize, int nr_mem_devs) +diff -Nur a/tools/firmware/hvmloader/smbios_types.h b/tools/firmware/hvmloader/smbios_types.h +--- a/tools/firmware/hvmloader/smbios_types.h 2009-04-01 14:06:28.000000000 -0400 ++++ b/tools/firmware/hvmloader/smbios_types.h 2009-04-01 15:28:52.000000000 -0400 +@@ -115,6 +115,12 @@ + uint8_t upgrade; + } __attribute__ ((packed)); + ++/* SMBIOS type 11 - OEM Strings */ ++struct smbios_type_11 { ++ struct smbios_structure_header header; ++ uint8_t count; ++} __attribute__ ((packed)); ++ + /* SMBIOS type 16 - Physical Memory Array + * Associated with one type 17 (Memory Device). + */ +diff -Nur a/tools/firmware/hvmloader/util.c b/tools/firmware/hvmloader/util.c +--- a/tools/firmware/hvmloader/util.c 2009-04-01 14:06:28.000000000 -0400 ++++ b/tools/firmware/hvmloader/util.c 2009-04-01 14:50:01.000000000 -0400 +@@ -542,32 +542,32 @@ + asm volatile ( "ud2" ); + } + +-static void validate_hvm_info(struct hvm_info_table *t) ++static int validate_hvm_info_table(uint8_t *table, uint32_t table_length, const char *table_sig, const char *sig, uint32_t sig_length) + { +- uint8_t *ptr = (uint8_t *)t; + uint8_t sum = 0; + int i; + +- if ( strncmp(t->signature, "HVM INFO", 8) ) +- { +- printf("Bad hvm info signature\n"); +- BUG(); ++ if (table_length == 0) { ++ printf("Empty HVM info table: %.*s\n", sig_length, sig); + } + +- if ( t->length < sizeof(struct hvm_info_table) ) ++ /* NOTE removed BUG() checking during xc merge because not all xc tables ++ are present - do a BUG() in get_hvm_info_table() only */ ++ ++ /* strncmp(t->signature, signature, sig_length) */ ++ for ( i = 0; i < sig_length; i++ ) + { +- printf("Bad hvm info length\n"); +- BUG(); ++ if ( table_sig[i] != sig[i] ) ++ { ++ printf("Bad HVM info signature for: %.*s\n", sig_length, sig); ++ return 0; ++ } + } + +- for ( i = 0; i < t->length; i++ ) +- sum += ptr[i]; ++ for ( i = 0; i < table_length; i++ ) ++ sum += table[i]; + +- if ( sum != 0 ) +- { +- printf("Bad hvm info checksum\n"); +- BUG(); +- } ++ return (sum == 0); + } + + struct hvm_info_table *get_hvm_info_table(void) +@@ -580,7 +580,11 @@ + + t = (struct hvm_info_table *)HVM_INFO_PADDR; + +- validate_hvm_info(t); ++ if ( !validate_hvm_info_table((uint8_t*)t, t->length, t->signature, "HVM INFO", 8) ) ++ { ++ printf("Bad HVM info table\n"); ++ BUG(); ++ } + + table = t; + +@@ -650,6 +654,52 @@ + return ((hpet_id >> 16) == 0x8086); + } + ++struct hvm_sminfo_table *get_hvm_sminfo_table(void) ++{ ++ static struct hvm_sminfo_table *table = NULL; ++ static int validated = 0; ++ struct hvm_sminfo_table *t; ++ ++ if ( validated ) ++ return table; ++ ++ t = (struct hvm_sminfo_table *)HVM_SMINFO_PADDR; ++ ++ if ( (t->total_length == 0) && (t->sm_count == 0) ) { ++ printf("Empty HVM SMBIOS info table\n"); ++ validated = 1; ++ return table; ++ } ++ ++ if ( validate_hvm_info_table((uint8_t*)t, t->total_length + sizeof(struct hvm_sminfo_table), t->signature, "SM INFO", 7) ) ++ table = t; ++ else ++ printf("Bad or missing HVM SMBIOS info table\n"); ++ validated = 1; ++ ++ return table; ++} ++ ++struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type) ++{ ++ struct hvm_smtable_header *header = ++ (struct hvm_smtable_header*)((uint8_t*)pa_sm + sizeof(struct hvm_sminfo_table)); ++ uint32_t count; ++ uint8_t *ptr; ++ ++ for (count = 0; count < pa_sm->sm_count; count++) { ++ if (header->sm_length == 0) { ++ printf("Invalid SMINFO tables passed to HVM loader."); ++ return NULL; ++ } ++ ptr = ((uint8_t*)header + sizeof(struct hvm_smtable_header)); ++ if (ptr[0] == type) ++ return header; ++ header = (struct hvm_smtable_header*)(ptr + header->sm_length); ++ } ++ return NULL; ++} ++ + /* + * Local variables: + * mode: C +diff -Nur a/tools/firmware/hvmloader/util.h b/tools/firmware/hvmloader/util.h +--- a/tools/firmware/hvmloader/util.h 2009-04-01 14:06:28.000000000 -0400 ++++ b/tools/firmware/hvmloader/util.h 2009-04-01 14:50:19.000000000 -0400 +@@ -111,6 +111,10 @@ + struct hvm_info_table *get_hvm_info_table(void); + #define hvm_info (get_hvm_info_table()) + ++/* HVM-build SMBIOS/ACPI info extensions */ ++struct hvm_sminfo_table *get_hvm_sminfo_table(void); ++struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type); ++ + /* String and memory functions */ + int strcmp(const char *cs, const char *ct); + int strncmp(const char *s1, const char *s2, uint32_t n); +diff -Nur a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h +--- a/xen/include/public/hvm/hvm_info_table.h 2009-04-01 14:06:32.000000000 -0400 ++++ b/xen/include/public/hvm/hvm_info_table.h 2009-04-01 14:24:54.000000000 -0400 +@@ -28,6 +28,12 @@ + #define HVM_INFO_PFN 0x09F + #define HVM_INFO_OFFSET 0x800 + #define HVM_INFO_PADDR ((HVM_INFO_PFN << 12) + HVM_INFO_OFFSET) ++#define HVM_INFO_MAX 0x400 ++#define HVM_SMINFO_OFFSET 0x0 ++#define HVM_SMINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_SMINFO_OFFSET) ++#define HVM_SMINFO_MAX 0x800 ++ ++#define HVM_SMINFO_EXTENSIONS 1 + + struct hvm_info_table { + char signature[8]; /* "HVM INFO" */ +@@ -66,4 +72,15 @@ + uint32_t high_mem_pgend; + }; + ++struct hvm_sminfo_table { ++ char signature[7]; /* "SM INFO" */ ++ uint8_t checksum; ++ uint32_t total_length; /* beginning after this stucture */ ++ uint32_t sm_count; ++}; ++ ++struct hvm_smtable_header { ++ uint32_t sm_length; /* beginning after this stucture, includes fixed table, string list, and terminator */ ++}; ++ + #endif /* __XEN_PUBLIC_HVM_HVM_INFO_TABLE_H__ */ diff --git a/master/status b/master/status new file mode 100644 index 0000000..e69de29 diff --git a/master/thermal-management b/master/thermal-management new file mode 100644 index 0000000..519e235 --- /dev/null +++ b/master/thermal-management @@ -0,0 +1,296 @@ +diff -Nur a/tools/firmware/hvmloader/acpi/ssdt_pm.asl b/tools/firmware/hvmloader/acpi/ssdt_pm.asl +--- a/tools/firmware/hvmloader/acpi/ssdt_pm.asl 2009-04-01 17:16:42.000000000 -0400 ++++ b/tools/firmware/hvmloader/acpi/ssdt_pm.asl 2009-04-01 17:18:03.000000000 -0400 +@@ -95,6 +95,14 @@ + P88, 8 + } + ++ /*OperationRegion for thermal zone */ ++ OperationRegion (PRT4, SystemIO, 0x90, 0x04) ++ Field (PRT4, WordAcc, NoLock, Preserve) ++ { ++ P90, 16, ++ P92, 16 ++ } ++ + /* OperationRegion for Power Button */ + OperationRegion (PBOP, SystemIO, 0x200, 0x01) + Field (PBOP, ByteAcc, NoLock, WriteAsZeros) +@@ -529,6 +537,24 @@ + } + } + ++ Scope (\_TZ) ++ { ++ ThermalZone (THM) ++ { ++ Method (_CRT, 0, NotSerialized) ++ { ++ Store(\_SB.P92, Local0) ++ Return (Local0) ++ } ++ ++ Method (_TMP, 0, NotSerialized) ++ { ++ Store(\_SB.P90, Local0) ++ Return (Local0) ++ } ++ } ++ } ++ + /* Wire GPE events to notify power state + * changes like ac power to battery use etc. + */ +diff -Nur a/tools/xenpmd/xenpmd.c b/tools/xenpmd/xenpmd.c +--- a/tools/xenpmd/xenpmd.c 2009-04-01 17:16:42.000000000 -0400 ++++ b/tools/xenpmd/xenpmd.c 2009-04-01 17:22:49.000000000 -0400 +@@ -93,13 +93,17 @@ + extern void acpi_events_cleanup(void); + + #ifdef RUN_IN_SIMULATE_MODE +- #define BATTERY_DIR_PATH "/tmp/battery" +- #define BATTERY_INFO_FILE_PATH "/tmp/battery/%s/info" +- #define BATTERY_STATE_FILE_PATH "/tmp/battery/%s/state" ++ #define BATTERY_DIR_PATH "/tmp/battery" ++ #define BATTERY_INFO_FILE_PATH "/tmp/battery/%s/info" ++ #define BATTERY_STATE_FILE_PATH "/tmp/battery/%s/state" ++ #define THERMAL_TRIP_POINTS_FILE "/tmp/thermal_zone/%s/trip_points" ++ #define THERMAL_TEMPERATURE_FILE "/tmp/thermal_zone/%s/temperature" + #else +- #define BATTERY_DIR_PATH "/proc/acpi/battery" +- #define BATTERY_INFO_FILE_PATH "/proc/acpi/battery/%s/info" +- #define BATTERY_STATE_FILE_PATH "/proc/acpi/battery/%s/state" ++ #define BATTERY_DIR_PATH "/proc/acpi/battery" ++ #define BATTERY_INFO_FILE_PATH "/proc/acpi/battery/%s/info" ++ #define BATTERY_STATE_FILE_PATH "/proc/acpi/battery/%s/state" ++ #define THERMAL_TRIP_POINTS_FILE "/proc/acpi/thermal_zone/%s/trip_points" ++ #define THERMAL_TEMPERATURE_FILE "/proc/acpi/thermal_zone/%s/temperature" + #endif + + FILE *get_next_battery_file(DIR *battery_dir, +@@ -448,44 +452,188 @@ + xs_write(xs, XBT_NULL, "/pm/bst", val, 35); + } + +-int wait_for_and_update_battery_status_request(void) ++void update_battery_status(void) + { + DIR *dir; +- int ret = 0; +- unsigned int count; + struct battery_status status; + +- while ( true ) +- { +- /* KN:@TODO - It is rather inefficient to not cache the file handle. +- * Switch to caching file handle. +- */ +- dir = opendir(BATTERY_DIR_PATH); +- if ( !dir ) +- return 0; ++ /* KN:@TODO - It is rather inefficient to not cache the file handle. ++ * Switch to caching file handle. ++ */ ++ dir = opendir(BATTERY_DIR_PATH); ++ if ( !dir ) ++ return; + +- while ( get_next_battery_info_or_status(dir, BST, (void *)&status) ) +- { ++ while ( get_next_battery_info_or_status(dir, BST, (void *)&status) ) ++ { + #ifdef RUN_STANDALONE +- print_battery_status(&status); ++ print_battery_status(&status); + #endif +- if ( status.present == YES ) +- { +- write_battery_status_to_xenstore(&status); +- ret = 1; +- /* rethink this; though I have never seen, there might be +- * systems out there with more than one battery device +- * present +- */ +- break; +- } ++ if ( status.present == YES ) ++ { ++ write_battery_status_to_xenstore(&status); ++ /* rethink this; though I have never seen, there might be ++ * systems out there with more than one battery device ++ * present ++ */ ++ break; + } +- closedir(dir); +- xs_watch(xs, "/pm/events", "refreshbatterystatus"); +- xs_read_watch(xs, &count); + } + +- return ret; ++ closedir(dir); ++ return; ++} ++ ++int open_thermal_files(char *subdir, FILE **trip_points_file, FILE **temp_file) ++{ ++ char trip_points_file_name[64]; ++ char temperature_file_name[64]; ++ ++ snprintf(trip_points_file_name, 64, THERMAL_TRIP_POINTS_FILE, subdir); ++ snprintf(temperature_file_name, 64, THERMAL_TEMPERATURE_FILE, subdir); ++ ++ *trip_points_file = fopen(trip_points_file_name, "r"); ++ *temp_file = fopen(temperature_file_name, "r"); ++ ++ if ( *trip_points_file == NULL || *temp_file == NULL ) ++ { ++ if ( *trip_points_file ) ++ { ++ fclose(*trip_points_file); ++ *trip_points_file = NULL; ++ } ++ ++ if ( *temp_file ) ++ { ++ fclose(*temp_file); ++ *temp_file = NULL; ++ } ++ return 0; ++ } ++ ++ return 1; ++} ++ ++/* Note: Below is the simplest approach based on studying the ++ * different thermal zones exposed by the OEMs at this point. ++ * In specific Dell E6*00, Lenovo T400, HP 6930p was taken into ++ * consideration before arriving at which thermal zone to expose ++ * to the guest. But, if we choose to expand our thermal zone ++ * implementation to be closer to the underlying firmware, we ++ * should revisit the below. ++ */ ++void get_thermal_files(FILE **trip_points_file, FILE **temp_file) ++{ ++ if ( open_thermal_files("/THM", trip_points_file, temp_file) ) ++ return; ++ ++ if ( open_thermal_files("/CPUZ", trip_points_file, temp_file) ) ++ return; ++ ++ if ( open_thermal_files("/THM1", trip_points_file, temp_file) ) ++ return; ++ ++ open_thermal_files("/THM0", trip_points_file, temp_file); ++} ++ ++/* @TODO: KN: There is similar code in one other place. ++ * consolidate it to one place. ++ */ ++int get_attribute_value(char *line_info, char *attribute_name) ++{ ++ char attrib_name[64]; ++ char attrib_value[64]; ++ char *delimiter; ++ unsigned long length; ++ ++ length = strlen(line_info); ++ delimiter = (char *) strchr( line_info, ':'); ++ if ( (!delimiter) || (delimiter == line_info) || ++ (delimiter == line_info + length) ) ++ return 0; ++ ++ strncpy(attrib_name, line_info, delimiter-line_info); ++ if ( !strstr(attrib_name, attribute_name) ) ++ return 0; ++ ++ while ( *(delimiter+1) == ' ' ) ++ { ++ delimiter++; ++ if ( delimiter+1 == line_info + length) ++ return 0; ++ } ++ ++ strncpy(attrib_value, delimiter+1, ++ (unsigned long)line_info + length -(unsigned long)delimiter); ++ return strtoull(attrib_value, NULL, 10); ++} ++ ++int get_thermalzone_value(FILE *file, char *attribute_name) ++{ ++ char line_info[256]; ++ int attribute_value; ++ ++ memset(line_info, 0, 256); ++ while ( fgets(line_info, 1024, file) != NULL ) ++ { ++ attribute_value = get_attribute_value(line_info, attribute_name); ++ if ( attribute_value > 0 ) ++ return attribute_value; ++ memset(line_info, 0, 256); ++ } ++ ++ return 0; ++} ++ ++void update_thermal_info(void) ++{ ++ char buffer[32]; ++ int current_temp, critical_trip_point; ++ FILE *trip_points_file = NULL, *temp_file = NULL; ++ ++ get_thermal_files(&trip_points_file, &temp_file); ++ if ( trip_points_file == NULL || temp_file == NULL ) ++ return; ++ ++ current_temp = get_thermalzone_value(temp_file, "temperature"); ++ critical_trip_point = get_thermalzone_value(trip_points_file, "critical"); ++ ++ fclose(trip_points_file); ++ fclose(temp_file); ++ ++ if ( current_temp <= 0 || critical_trip_point <= 0 ) ++ return; ++ ++ snprintf(buffer, 32, "%d", current_temp); ++ xs_write(xs, XBT_NULL, "/pm/current_temperature", buffer, strlen(buffer)); ++ ++ snprintf(buffer, 32, "%d", critical_trip_point); ++ xs_write(xs, XBT_NULL, "/pm/critical_temperature", buffer, strlen(buffer)); ++} ++ ++void wait_for_and_update_power_mgmt_info(void) ++{ ++ char **buffer; ++ unsigned int count; ++ ++ update_battery_status(); ++ update_thermal_info(); ++ ++ xs_watch(xs, "/pm/events", "refreshbatterystatus"); ++ xs_watch(xs, "/pm/events", "refreshthermalinfo"); ++ ++ while ( true ) ++ { ++ buffer = xs_read_watch(xs, &count); ++ if ( buffer == NULL ) ++ continue; ++ if (!strcmp(buffer[XS_WATCH_TOKEN], "refreshbatterystatus")) { ++ update_battery_status(); ++ } else if (!strcmp(buffer[XS_WATCH_TOKEN], "refreshthermalinfo")) { ++ update_thermal_info(); ++ } ++ free(buffer); ++ } + } + + #ifndef RUN_STANDALONE +@@ -539,7 +687,7 @@ + return 0; + } + +- wait_for_and_update_battery_status_request(); ++ wait_for_and_update_power_mgmt_info(); + acpi_events_cleanup(); + xs_daemon_close(xs); + return 0; diff --git a/xen-3.4/acpi-slic b/xen-3.4/acpi-slic deleted file mode 100644 index bcada23..0000000 --- a/xen-3.4/acpi-slic +++ /dev/null @@ -1,244 +0,0 @@ -diff -Nur a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c ---- a/tools/firmware/hvmloader/acpi/build.c 2009-04-01 16:02:46.000000000 -0400 -+++ b/tools/firmware/hvmloader/acpi/build.c 2009-04-01 15:57:01.000000000 -0400 -@@ -59,7 +59,16 @@ - return 1; - } - --static int construct_madt(struct acpi_20_madt *madt) -+static void pt_update_acpi_tables(struct acpi_header *header, struct hvm_acinfo_table *va_ac) -+{ -+ memcpy(header->oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ memcpy(header->oem_table_id, va_ac->oem_table_id, HVM_ACINFO_OEM_TABLE_ID_SIZE); -+ header->oem_revision = va_ac->oem_revision; -+ header->creator_id = ASCII32(va_ac->creator_id[0],va_ac->creator_id[1],va_ac->creator_id[2],va_ac->creator_id[3]); -+ header->creator_revision = va_ac->creator_revision; -+} -+ -+static int construct_madt(struct acpi_20_madt *madt, struct hvm_acinfo_table *va_ac) - { - struct acpi_20_madt_intsrcovr *intsrcovr; - struct acpi_20_madt_ioapic *io_apic; -@@ -69,7 +78,14 @@ - memset(madt, 0, sizeof(*madt)); - madt->header.signature = ACPI_2_0_MADT_SIGNATURE; - madt->header.revision = ACPI_2_0_MADT_REVISION; -- fixed_strcpy(madt->header.oem_id, ACPI_OEM_ID); -+ if (va_ac == NULL) -+ { -+ fixed_strcpy(madt->header.oem_id, ACPI_OEM_ID); -+ } -+ else -+ { -+ memcpy(madt->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ } - fixed_strcpy(madt->header.oem_table_id, ACPI_OEM_TABLE_ID); - madt->header.oem_revision = ACPI_OEM_REVISION; - madt->header.creator_id = ACPI_CREATOR_ID; -@@ -136,14 +152,21 @@ - return align16(offset); - } - --static int construct_hpet(struct acpi_20_hpet *hpet) -+static int construct_hpet(struct acpi_20_hpet *hpet, struct hvm_acinfo_table *va_ac) - { - int offset; - - memset(hpet, 0, sizeof(*hpet)); - hpet->header.signature = ACPI_2_0_HPET_SIGNATURE; - hpet->header.revision = ACPI_2_0_HPET_REVISION; -- fixed_strcpy(hpet->header.oem_id, ACPI_OEM_ID); -+ if (va_ac == NULL) -+ { -+ fixed_strcpy(hpet->header.oem_id, ACPI_OEM_ID); -+ } -+ else -+ { -+ memcpy(hpet->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ } - fixed_strcpy(hpet->header.oem_table_id, ACPI_OEM_TABLE_ID); - hpet->header.oem_revision = ACPI_OEM_REVISION; - hpet->header.creator_id = ACPI_CREATOR_ID; -@@ -158,7 +181,7 @@ - return offset; - } - --static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs) -+static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs, struct hvm_acinfo_table *va_ac) - { - int offset = 0, nr_tables = 0; - struct acpi_20_madt *madt; -@@ -172,7 +195,7 @@ - if ( (hvm_info->nr_vcpus > 1) || hvm_info->apic_mode ) - { - madt = (struct acpi_20_madt *)&buf[offset]; -- offset += construct_madt(madt); -+ offset += construct_madt(madt, va_ac); - table_ptrs[nr_tables++] = (unsigned long)madt; - } - -@@ -180,7 +203,7 @@ - if ( hpet_exists(ACPI_HPET_ADDRESS) ) - { - hpet = (struct acpi_20_hpet *)&buf[offset]; -- offset += construct_hpet(hpet); -+ offset += construct_hpet(hpet, va_ac); - table_ptrs[nr_tables++] = (unsigned long)hpet; - } - -@@ -191,6 +214,14 @@ - offset += align16(sizeof(AmlCode_PM)); - } - -+ /* SLIC */ -+ if (va_ac != NULL) -+ { -+ table_ptrs[nr_tables++] = (unsigned long)&buf[offset]; -+ memcpy(&buf[offset], (uint8_t*)va_ac + sizeof(struct hvm_acinfo_table), va_ac->slic_length); -+ offset += align16(va_ac->slic_length); -+ } -+ - /* TPM TCPA and SSDT. */ - tis_hdr = (uint16_t *)0xFED40F00; - if ( (tis_hdr[0] == tis_signature[0]) && -@@ -209,7 +240,14 @@ - tcpa->header.signature = ACPI_2_0_TCPA_SIGNATURE; - tcpa->header.length = sizeof(*tcpa); - tcpa->header.revision = ACPI_2_0_TCPA_REVISION; -- fixed_strcpy(tcpa->header.oem_id, ACPI_OEM_ID); -+ if (va_ac == NULL) -+ { -+ fixed_strcpy(tcpa->header.oem_id, ACPI_OEM_ID); -+ } -+ else -+ { -+ memcpy(tcpa->header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ } - fixed_strcpy(tcpa->header.oem_table_id, ACPI_OEM_TABLE_ID); - tcpa->header.oem_revision = ACPI_OEM_REVISION; - tcpa->header.creator_id = ACPI_CREATOR_ID; -@@ -240,6 +278,21 @@ - unsigned char *dsdt; - unsigned long secondary_tables[16]; - int offset = 0, i; -+ struct hvm_acinfo_table *va_ac; -+ -+ /* -+ * First get the ACPI info structure that may be passed to the HVM loader. This will be used -+ * to pass through platform ACPI information if present. -+ */ -+ va_ac = get_hvm_acinfo_table(); -+ if (va_ac != NULL) -+ { -+ pt_update_acpi_tables(&Rsdt.header, va_ac); -+ pt_update_acpi_tables(&Xsdt.header, va_ac); -+ /* just the OEM ID for the RSDP and FADT */ -+ memcpy(Rsdp.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ memcpy(Fadt.header.oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -+ } - - /* - * Fill in high-memory data structures, starting at @buf. -@@ -283,7 +336,7 @@ - offsetof(struct acpi_header, checksum), - sizeof(struct acpi_20_fadt)); - -- offset += construct_secondary_tables(&buf[offset], secondary_tables); -+ offset += construct_secondary_tables(&buf[offset], secondary_tables, va_ac); - - xsdt = (struct acpi_20_xsdt *)&buf[offset]; - memcpy(xsdt, &Xsdt, sizeof(struct acpi_header)); -diff -Nur a/tools/firmware/hvmloader/util.c b/tools/firmware/hvmloader/util.c ---- a/tools/firmware/hvmloader/util.c 2009-04-01 16:02:51.000000000 -0400 -+++ b/tools/firmware/hvmloader/util.c 2009-04-01 15:47:57.000000000 -0400 -@@ -680,6 +680,32 @@ - return table; - } - -+struct hvm_acinfo_table *get_hvm_acinfo_table(void) -+{ -+ static struct hvm_acinfo_table *table = NULL; -+ static int validated = 0; -+ struct hvm_acinfo_table *t; -+ -+ if ( validated ) -+ return table; -+ -+ t = (struct hvm_acinfo_table *)HVM_ACINFO_PADDR; -+ -+ if ( t->slic_length == 0 ) { -+ printf("HVM ACPI info table missing SLIC table?\n"); -+ validated = 1; -+ return table; -+ } -+ -+ if ( validate_hvm_info_table((uint8_t*)t, t->slic_length + sizeof(struct hvm_acinfo_table), t->signature, "AC INFO", 7) ) -+ table = t; -+ else -+ printf("Bad or missing HVM SMBIOS info table\n"); -+ validated = 1; -+ -+ return table; -+} -+ - struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type) - { - struct hvm_smtable_header *header = -diff -Nur a/tools/firmware/hvmloader/util.h b/tools/firmware/hvmloader/util.h ---- a/tools/firmware/hvmloader/util.h 2009-04-01 16:02:51.000000000 -0400 -+++ b/tools/firmware/hvmloader/util.h 2009-04-01 15:48:13.000000000 -0400 -@@ -113,6 +113,7 @@ - - /* HVM-build SMBIOS/ACPI info extensions */ - struct hvm_sminfo_table *get_hvm_sminfo_table(void); -+struct hvm_acinfo_table *get_hvm_acinfo_table(void); - struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type); - - /* String and memory functions */ -diff -Nur a/tools/libxc/xc_dom_x86.c b/tools/libxc/xc_dom_x86.c ---- a/tools/libxc/xc_dom_x86.c 2009-04-01 14:06:29.000000000 -0400 -+++ b/tools/libxc/xc_dom_x86.c 2009-04-01 16:00:48.000000000 -0400 -@@ -17,7 +17,6 @@ - #include - #include - #include --#include - #include - - #include "xg_private.h" -diff -Nur a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h ---- a/xen/include/public/hvm/hvm_info_table.h 2009-04-01 16:02:51.000000000 -0400 -+++ b/xen/include/public/hvm/hvm_info_table.h 2009-04-01 15:41:59.000000000 -0400 -@@ -32,8 +32,12 @@ - #define HVM_SMINFO_OFFSET 0x0 - #define HVM_SMINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_SMINFO_OFFSET) - #define HVM_SMINFO_MAX 0x800 -+#define HVM_ACINFO_OFFSET 0xC00 -+#define HVM_ACINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_ACINFO_OFFSET) -+#define HVM_ACINFO_MAX 0x400 - - #define HVM_SMINFO_EXTENSIONS 1 -+#define HVM_ACINFO_EXTENSIONS 1 - - struct hvm_info_table { - char signature[8]; /* "HVM INFO" */ -@@ -83,4 +87,19 @@ - uint32_t sm_length; /* beginning after this stucture, includes fixed table, string list, and terminator */ - }; - -+#define HVM_ACINFO_OEM_ID_SIZE 6 -+#define HVM_ACINFO_OEM_TABLE_ID_SIZE 8 -+#define HVM_ACINFO_CREATOR_ID_SIZE 4 -+ -+struct hvm_acinfo_table { -+ char signature[7]; /* "AC INFO" */ -+ uint8_t checksum; -+ uint32_t slic_length; /* length of SLIC following this structure */ -+ char oem_id[HVM_ACINFO_OEM_ID_SIZE]; -+ char oem_table_id[HVM_ACINFO_OEM_TABLE_ID_SIZE]; -+ uint32_t oem_revision; -+ char creator_id[HVM_ACINFO_CREATOR_ID_SIZE]; -+ uint32_t creator_revision; -+}; -+ - #endif /* __XEN_PUBLIC_HVM_HVM_INFO_TABLE_H__ */ diff --git a/xen-3.4/fix_compilation b/xen-3.4/fix_compilation deleted file mode 100644 index a634631..0000000 --- a/xen-3.4/fix_compilation +++ /dev/null @@ -1,82 +0,0 @@ -diff --git a/tools/Makefile b/tools/Makefile -index 00e3981..ea26bd9 100644 ---- a/tools/Makefile -+++ b/tools/Makefile -@@ -2,16 +2,16 @@ XEN_ROOT = ../ - include $(XEN_ROOT)/tools/Rules.mk - - SUBDIRS-y := --SUBDIRS-y += check -+SUBDIRS-n += check - SUBDIRS-y += include - SUBDIRS-y += libxc - SUBDIRS-y += flask - SUBDIRS-y += xenstore --SUBDIRS-y += misc --SUBDIRS-y += examples -+SUBDIRS-n += misc -+SUBDIRS-n += examples - SUBDIRS-y += hotplug - SUBDIRS-y += xentrace --SUBDIRS-$(CONFIG_XCUTILS) += xcutils -+SUBDIRS-n += xcutils - SUBDIRS-$(CONFIG_X86) += firmware - SUBDIRS-$(ACM_SECURITY) += security - SUBDIRS-y += console -@@ -23,15 +23,15 @@ SUBDIRS-$(CONFIG_Linux) += libaio - SUBDIRS-$(CONFIG_Linux) += blktap - SUBDIRS-y += libfsimage - SUBDIRS-$(LIBXENAPI_BINDINGS) += libxen --SUBDIRS-$(CONFIG_Linux) += fs-back -+SUBDIRS-n += fs-back - SUBDIRS-$(CONFIG_IOEMU) += ioemu-dir - SUBDIRS-y += xenpmd - - # These don't cross-compile --ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) --SUBDIRS-$(PYTHON_TOOLS) += python --SUBDIRS-$(PYTHON_TOOLS) += pygrub --endif -+#ifeq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) -+#SUBDIRS-$(PYTHON_TOOLS) += python -+#SUBDIRS-$(PYTHON_TOOLS) += pygrub -+#endif - - # For the sake of linking, set the sys-root - ifneq ($(CROSS_COMPILE),) -@@ -54,7 +54,7 @@ install: subdirs-install - clean distclean: subdirs-clean - - ifneq ($(XEN_COMPILE_ARCH),$(XEN_TARGET_ARCH)) --IOEMU_CONFIGURE_CROSS ?= --cpu=$(XEN_TARGET_ARCH) \ -+IOEMU_CONFIGURE_CROSS ?= --cpu=$(XEN_TARGET_ARCH:x86_32=i386) \ - --cross-prefix=$(CROSS_COMPILE) \ - --interp-prefix=$(CROSS_SYS_ROOT) - endif -@@ -69,26 +69,6 @@ subdir-clean-ioemu: - $(MAKE) -C ioemu distclean - - ioemu-dir-find: -- set -ex; \ -- if test -d $(CONFIG_QEMU); then \ -- rm -f ioemu-dir; \ -- ln -sf $(CONFIG_QEMU) ioemu-dir; \ -- else \ -- if [ ! -d ioemu-remote ]; then \ -- rm -rf ioemu-remote ioemu-remote.tmp; \ -- mkdir ioemu-remote.tmp; rmdir ioemu-remote.tmp; \ -- $(GIT) clone $(CONFIG_QEMU) ioemu-remote.tmp; \ -- if [ "$(QEMU_TAG)" ]; then \ -- cd ioemu-remote.tmp; \ -- $(GIT) branch -D dummy >/dev/null 2>&1 ||:; \ -- $(GIT) checkout -b dummy $(QEMU_TAG); \ -- cd ..; \ -- fi; \ -- mv ioemu-remote.tmp ioemu-remote; \ -- fi; \ -- rm -f ioemu-dir; \ -- ln -sf ioemu-remote ioemu-dir; \ -- fi - set -e; \ - $(absolutify_xen_root); \ - cd ioemu-dir; \ diff --git a/xen-3.4/init-vgabios-and-set-size b/xen-3.4/init-vgabios-and-set-size deleted file mode 100644 index bde9d6d..0000000 --- a/xen-3.4/init-vgabios-and-set-size +++ /dev/null @@ -1,91 +0,0 @@ -diff --git a/tools/firmware/hvmloader/hvmloader.c b/tools/firmware/hvmloader/hvmloader.c -index 39aa949..12ac806 100644 ---- a/tools/firmware/hvmloader/hvmloader.c -+++ b/tools/firmware/hvmloader/hvmloader.c -@@ -672,6 +672,7 @@ int main(void) - break; - default: - printf("No emulated VGA adaptor ...\n"); -+ vgabios_sz = round_option_rom((*(uint8_t *)(VGABIOS_PHYSICAL_ADDRESS+2)) * 512); - break; - } - -diff --git a/tools/libxc/xc_hvm_build.c b/tools/libxc/xc_hvm_build.c -index 0ba8c44..787f4ec 100644 ---- a/tools/libxc/xc_hvm_build.c -+++ b/tools/libxc/xc_hvm_build.c -@@ -66,14 +66,35 @@ static void build_hvm_info(void *hvm_info_page, uint64_t mem_size) - hvm_info->checksum = -sum; - } - -+static int init_vgabios(int xc_handle, uint32_t dom, unsigned char *buffer, uint32_t bios_size) -+{ -+ char *va_bios = NULL; -+ uint32_t va_size = 0; -+ -+ va_size = bios_size + bios_size % XC_PAGE_SIZE; -+ va_bios = xc_map_foreign_range(xc_handle, dom, va_size, -+ PROT_READ | PROT_WRITE, 0xC0); -+ if ( !va_bios ) -+ { -+ IPRINTF("Unable to map vga bios!\n"); -+ return -1; -+ } -+ -+ if ( buffer != NULL ) -+ memcpy(va_bios, buffer, bios_size); -+ else -+ memset(va_bios, 0, bios_size); -+ -+ munmap(va_bios, va_size); -+ return 0; -+} -+ - static int setup_vga_pt(int xc_handle, - uint32_t dom) - { - int rc = 0; - unsigned char *bios = NULL; - int bios_size = 0; -- char *va_bios = NULL; -- uint32_t va_size = 0; - char *c = NULL; - char checksum = 0; - -@@ -87,16 +108,9 @@ static int setup_vga_pt(int xc_handle, - bios_size = 0; - #endif /* __linux__ */ - -- va_size = bios_size + bios_size % XC_PAGE_SIZE; - if (bios_size == 0) - { -- rc = -1; -- goto error; -- } -- va_bios = xc_map_foreign_range(xc_handle, dom, va_size, -- PROT_READ | PROT_WRITE, 0xC0); -- if (!va_bios) -- { -+ IPRINTF("vga bios size is 0!\n"); - rc = -1; - goto error; - } -@@ -107,8 +121,7 @@ static int setup_vga_pt(int xc_handle, - if (checksum) - bios[bios_size - 1] -= checksum; - -- memcpy(va_bios, bios, bios_size); -- munmap(va_bios, va_size); -+ init_vgabios(xc_handle, dom, bios, bios_size); - error: - free(bios); - return rc; -@@ -416,6 +429,8 @@ int xc_hvm_build(int xc_handle, - sts = xc_hvm_build_internal(xc_handle, domid, memsize, memsize, image, image_size); - if ( vga_pt_enabled ) - sts |= setup_vga_pt(xc_handle, domid); -+ else -+ sts |= init_vgabios(xc_handle, domid, NULL, 0x800); - - free(image); - diff --git a/xen-3.4/mfn-validity-check-before-shadow-remove b/xen-3.4/mfn-validity-check-before-shadow-remove deleted file mode 100644 index cb75b6e..0000000 --- a/xen-3.4/mfn-validity-check-before-shadow-remove +++ /dev/null @@ -1,18 +0,0 @@ -diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c -index ca4cb13..71bfe27 100644 ---- a/xen/arch/x86/mm/shadow/common.c -+++ b/xen/arch/x86/mm/shadow/common.c -@@ -2730,6 +2730,13 @@ void sh_remove_shadows(struct vcpu *v, mfn_t gmfn, int fast, int all) - - ASSERT(!(all && fast)); - -+ if ( unlikely(!mfn_valid(gmfn)) ) -+ { -+ /* Get out now if we're trying to remove shadows of a MMIO -+ * direct page. */ -+ return; -+ } -+ - /* Although this is an externally visible function, we do not know - * whether the shadow lock will be held when it is called (since it - * can be called via put_page_type when we clear a shadow l1e). diff --git a/xen-3.4/module-reloc b/xen-3.4/module-reloc deleted file mode 100644 index 3363aaa..0000000 --- a/xen-3.4/module-reloc +++ /dev/null @@ -1,52 +0,0 @@ -diff --git a/xen/arch/x86/setup.c b/xen/arch/x86/setup.c -index 8cf4190..6960ebb 100644 ---- a/xen/arch/x86/setup.c -+++ b/xen/arch/x86/setup.c -@@ -419,7 +419,7 @@ void __init __start_xen(unsigned long mbi_p) - multiboot_info_t *mbi = __va(mbi_p); - module_t *mod = (module_t *)__va(mbi->mods_addr); - unsigned long nr_pages, modules_length, modules_headroom; -- int i, e820_warn = 0, bytes = 0; -+ int i, j, e820_warn = 0, bytes = 0; - struct ns16550_defaults ns16550 = { - .data_bits = 8, - .parity = 'n', -@@ -616,7 +616,9 @@ void __init __start_xen(unsigned long mbi_p) - * we can relocate the dom0 kernel and other multiboot modules. Also, on - * x86/64, we relocate Xen to higher memory. - */ -- modules_length = mod[mbi->mods_count-1].mod_end - mod[0].mod_start; -+ modules_length = 0; -+ for ( i = 0; i < mbi->mods_count; i++ ) -+ modules_length += mod[i].mod_end - mod[i].mod_start; - - /* ensure mod[0] is mapped before parsing */ - bootstrap_map(mod[0].mod_start, mod[0].mod_end); -@@ -737,8 +739,15 @@ void __init __start_xen(unsigned long mbi_p) - initial_images_start = e; - e -= modules_headroom; - initial_images_base = e; -- move_memory(initial_images_start, -- mod[0].mod_start, mod[mbi->mods_count-1].mod_end); -+ e += modules_length + modules_headroom; -+ for ( j = mbi->mods_count-1; j >= 0; j-- ) -+ { -+ e -= mod[j].mod_end - mod[j].mod_start; -+ move_memory(e, mod[j].mod_start, mod[j].mod_end); -+ mod[j].mod_end += e - mod[j].mod_start; -+ mod[j].mod_start = e; -+ } -+ - } - - if ( !kexec_crash_area.start && (s < e) && -@@ -1032,8 +1041,7 @@ void __init __start_xen(unsigned long mbi_p) - - if ( (initrdidx > 0) && (initrdidx < mbi->mods_count) ) - { -- _initrd_start = initial_images_start + -- (mod[initrdidx].mod_start - mod[0].mod_start); -+ _initrd_start = mod[initrdidx].mod_start; - _initrd_len = mod[initrdidx].mod_end - mod[initrdidx].mod_start; - } - diff --git a/xen-3.4/mtrr-changes b/xen-3.4/mtrr-changes deleted file mode 100644 index 9e936e8..0000000 --- a/xen-3.4/mtrr-changes +++ /dev/null @@ -1,15 +0,0 @@ -diff --git a/tools/firmware/hvmloader/cacheattr.c b/tools/firmware/hvmloader/cacheattr.c -index ae23b3e..9ae7ce8 100644 ---- a/tools/firmware/hvmloader/cacheattr.c -+++ b/tools/firmware/hvmloader/cacheattr.c -@@ -72,9 +72,7 @@ void cacheattr_init(void) - content = 0x0606060606060606ull; - wrmsr(MSR_MTRRfix64K_00000, content); - wrmsr(MSR_MTRRfix16K_80000, content); -- /* 0xa0000-0xbffff: Write Combining (WC) */ -- if ( mtrr_cap & (1u << 10) ) /* WC supported? */ -- content = 0x0101010101010101ull; -+ content = 0x0000000000000000ull; - wrmsr(MSR_MTRRfix16K_A0000, content); - /* 0xc0000-0xfffff: Write Back (WB) */ - content = 0x0606060606060606ull; diff --git a/xen-3.4/oem-features b/xen-3.4/oem-features deleted file mode 100644 index 1c54752..0000000 --- a/xen-3.4/oem-features +++ /dev/null @@ -1,2670 +0,0 @@ -diff -Nur a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c ---- a/tools/firmware/hvmloader/acpi/build.c 2009-04-01 16:31:10.000000000 -0400 -+++ b/tools/firmware/hvmloader/acpi/build.c 2009-04-01 17:04:59.000000000 -0400 -@@ -19,8 +19,12 @@ - #include "acpi2_0.h" - #include "ssdt_tpm.h" - #include "ssdt_pm.h" -+#include "ssdt_hp_6930p_elitebook.h" -+#include "ssdt_dell_latitude_eseries.h" -+#include "ssdt_lenovo_t_and_x_series.h" - #include "../config.h" - #include "../util.h" -+#include "../smbios_types.h" - - #define align16(sz) (((sz) + 15) & ~15) - #define fixed_strcpy(d, s) strncpy((d), (s), sizeof(d)) -@@ -33,6 +37,16 @@ - extern unsigned char AmlCode[]; - extern int DsdtLen; - -+#define OEM_NAME_DELL "Dell" -+#define OEM_NAME_HP "Hewlett-Packard" -+#define OEM_NAME_LENOVO "LENOVO" -+ -+#define OEM_MODEL_DELL_LATITUDE_1 "Latitude E4200" -+#define OEM_MODEL_DELL_LATITUDE_2 "Latitude E6500" -+#define OEM_MODEL_HP_EliteBook "HP EliteBook 6930p" -+#define OEM_MODEL_LENOVO_T400 "6475BY3" -+#define OEM_MODEL_LENOVO_X200 "74542NU" -+ - static void set_checksum( - void *table, uint32_t checksum_offset, uint32_t length) - { -@@ -59,6 +73,12 @@ - return 1; - } - -+static uint8_t oem_value_add_exists(void) -+{ -+ outb(0x96, 100); -+ return (inb(0x96) == 100); -+} -+ - static void pt_update_acpi_tables(struct acpi_header *header, struct hvm_acinfo_table *va_ac) - { - memcpy(header->oem_id, va_ac->oem_id, HVM_ACINFO_OEM_ID_SIZE); -@@ -68,6 +88,59 @@ - header->creator_revision = va_ac->creator_revision; - } - -+static int construct_oem_ssdt(uint8_t *buf) -+{ -+ struct smbios_type_1 *type1_info; -+ char *manufacturer, *model; -+ struct hvm_sminfo_table *pa_sm; -+ struct hvm_smtable_header *header; -+ -+ pa_sm = get_hvm_sminfo_table(); -+ if ( pa_sm == NULL ) -+ return 0; -+ -+ header = (struct hvm_smtable_header *)get_sminfo_by_type(pa_sm, 1); -+ if ( header == NULL ) -+ return 0; -+ if ( header->sm_length < sizeof(struct smbios_type_1) ) -+ return 0; -+ -+ type1_info = (struct smbios_type_1 *)((char *)header + sizeof(struct hvm_smtable_header)); -+ manufacturer = (char *)type1_info + type1_info->header.length; -+ model = manufacturer + strlen(manufacturer) + 1; -+ -+ if ( strncmp(manufacturer, OEM_NAME_DELL, strlen(OEM_NAME_DELL)) == 0 ) -+ { -+ if ( (strncmp(model, OEM_MODEL_DELL_LATITUDE_1, strlen(OEM_MODEL_DELL_LATITUDE_1)) != 0) && -+ (strncmp(model, OEM_MODEL_DELL_LATITUDE_2, strlen(OEM_MODEL_DELL_LATITUDE_2)) != 0) ) -+ return 0; -+ -+ memcpy(buf, AmlCode_DELL_LATITUDE_ESERIES, sizeof(AmlCode_DELL_LATITUDE_ESERIES)); -+ return align16(sizeof(AmlCode_DELL_LATITUDE_ESERIES)); -+ } -+ -+ if ( strncmp(manufacturer, OEM_NAME_HP, strlen(OEM_NAME_HP)) == 0 ) -+ { -+ if ( strncmp(model, OEM_MODEL_HP_EliteBook, strlen(OEM_MODEL_HP_EliteBook)) != 0 ) -+ return 0; -+ -+ memcpy(buf, AmlCode_HP_6930P_ELITEBOOK, sizeof(AmlCode_HP_6930P_ELITEBOOK)); -+ return align16(sizeof(AmlCode_HP_6930P_ELITEBOOK)); -+ } -+ -+ if ( strncmp(manufacturer, OEM_NAME_LENOVO, strlen(OEM_NAME_LENOVO)) == 0 ) -+ { -+ if ( (strncmp(model, OEM_MODEL_LENOVO_T400, strlen(OEM_MODEL_LENOVO_T400)) != 0) && -+ (strncmp(model, OEM_MODEL_LENOVO_X200, strlen(OEM_MODEL_LENOVO_X200)) != 0) ) -+ return 0; -+ -+ memcpy(buf, AmlCode_LENOVO_T_AND_X_SERIES, sizeof(AmlCode_LENOVO_T_AND_X_SERIES)); -+ return align16(sizeof(AmlCode_LENOVO_T_AND_X_SERIES)); -+ } -+ -+ return 0; -+} -+ - static int construct_madt(struct acpi_20_madt *madt, struct hvm_acinfo_table *va_ac) - { - struct acpi_20_madt_intsrcovr *intsrcovr; -@@ -183,12 +256,13 @@ - - static int construct_secondary_tables(uint8_t *buf, unsigned long *table_ptrs, struct hvm_acinfo_table *va_ac) - { -- int offset = 0, nr_tables = 0; -+ int offset = 0, nr_tables = 0, oem_ssdt_offset = 0; - struct acpi_20_madt *madt; - struct acpi_20_hpet *hpet; - struct acpi_20_tcpa *tcpa; - static const uint16_t tis_signature[] = {0x0001, 0x0001, 0x0001}; - uint16_t *tis_hdr; -+ uint8_t *oem_ssdt; - void *lasa; - - /* MADT. */ -@@ -222,6 +296,17 @@ - offset += align16(va_ac->slic_length); - } - -+ if ( oem_value_add_exists() ) -+ { -+ oem_ssdt = &buf[offset]; -+ oem_ssdt_offset = construct_oem_ssdt(oem_ssdt); -+ if ( oem_ssdt_offset != 0 ) -+ { -+ offset += oem_ssdt_offset; -+ table_ptrs[nr_tables++] = (unsigned long)oem_ssdt; -+ } -+ } -+ - /* TPM TCPA and SSDT. */ - tis_hdr = (uint16_t *)0xFED40F00; - if ( (tis_hdr[0] == tis_signature[0]) && -diff -Nur a/tools/firmware/hvmloader/acpi/Makefile b/tools/firmware/hvmloader/acpi/Makefile ---- a/tools/firmware/hvmloader/acpi/Makefile 2009-04-01 16:30:52.000000000 -0400 -+++ b/tools/firmware/hvmloader/acpi/Makefile 2009-04-01 16:36:38.000000000 -0400 -@@ -19,7 +19,7 @@ - include $(XEN_ROOT)/tools/firmware/Rules.mk - - C_SRC = build.c dsdt.c static_tables.c --H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_tpm.h -+H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_hp_6930p_elitebook.h ssdt_dell_latitude_eseries.h ssdt_lenovo_t_and_x_series.h ssdt_tpm.h - OBJS = $(patsubst %.c,%.o,$(C_SRC)) - - build.o: $(H_SRC) build.c -@@ -39,6 +39,27 @@ - mv $*.hex $@ - rm -f *.aml - -+ssdt_hp_6930p_elitebook.h: ssdt_hp_6930p_elitebook.asl -+ $(MAKE) iasl -+ iasl -tc $< -+ sed -i'' -re 's/AmlCode/AmlCode_HP_6930P_ELITEBOOK/g' $*.hex -+ mv $*.hex $@ -+ rm -f *.aml -+ -+ssdt_dell_latitude_eseries.h: ssdt_dell_latitude_eseries.asl -+ $(MAKE) iasl -+ iasl -tc $< -+ sed -i'' -re 's/AmlCode/AmlCode_DELL_LATITUDE_ESERIES/g' $*.hex -+ mv $*.hex $@ -+ rm -f *.aml -+ -+ssdt_lenovo_t_and_x_series.h: ssdt_lenovo_t_and_x_series.asl -+ $(MAKE) iasl -+ iasl -tc $< -+ sed -i'' -re 's/AmlCode/AmlCode_LENOVO_T_AND_X_SERIES/g' $*.hex -+ mv $*.hex $@ -+ rm -f *.aml -+ - ssdt_tpm.h: ssdt_tpm.asl - $(MAKE) iasl - iasl -tc $< -diff ---- /dev/null -+++ b/tools/firmware/hvmloader/acpi/ssdt_dell_latitude_eseries.asl 2009-04-01 16:35:13.000000000 -0400 -@@ -0,0 +1,516 @@ -+/* -+ * ssdt_dell_latitude_eseries.asl -+ * -+ * Copyright (c) 2009 Kamala Narasimhan -+ * Copyright (c) 2009 Citrix Systems, Inc. -+ * -+ * 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 -+ */ -+ -+/* SSDT for exposing Dell latitude eseries specific value add functionalities like -+ * hotkeys, special buttons. -+ */ -+ -+/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through -+ * WMI psuedo device objects. For our guests to benefit from such value add, we -+ * expose a psuedo device object in our vACPI layer also. This psuedo object is -+ * similar to the underlying base firmware object in the sense we expose the -+ * same _WDG method which describes the WMI methods, data objects and events -+ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically -+ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get -+ * known entry points and calls those entry points for further information exchange. -+ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ */ -+ -+/* COMMUNICATION DETAILS - -+ * Command port - 0x96 -+ * Writes to this port describe what type of information is about -+ * to be exchanged. E.g., guid, input argument transfer etc. -+ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. -+ * Communicates data to and from the backend. E.g. Input buffer values -+ * get written to this port and output buffer values are read from this -+ * port. -+ */ -+ -+DefinitionBlock ("SSDT_DELL_LATITUDE_ESERIES.aml", "SSDT", 2, "Xen", "HVM", 0) -+{ -+ Scope (\_SB) -+ { -+ -+ OperationRegion (LAT1, SystemIO, 0x96, 0x01) -+ Field (LAT1, ByteAcc, NoLock, Preserve) -+ { -+ P96, 8 -+ } -+ -+ OperationRegion (LAT2, SystemIO, 0x98, 0x01) -+ Field (LAT2, ByteAcc, NoLock, Preserve) -+ { -+ P98, 8 -+ } -+ -+ OperationRegion (LAT3, SystemIO, 0x9A, 0x04) -+ Field (LAT3, DWordAcc, NoLock, Preserve) -+ { -+ P9A, 32 -+ } -+ -+ Device (AMW0) -+ { -+ /* Exposing a pseudo device with HID PNP0C14 will -+ * result in Windows guest loading their WMI wrapper -+ * driver - wmiacpi.sys -+ */ -+ Name (_HID, EisaId ("PNP0C14")) -+ Name (_UID, 0x00) -+ -+ /* Following list of data blocks exposed by _WDG is same as the -+ * one provided by the underlying firmware. Refer to - -+ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ * for further information about _WDG and what it exposes. -+ */ -+ Name (_WDG, Buffer (0x78) -+ { -+ /* Data Block 1 */ -+ /* GUID */ -+ 0xBC, 0xDC, 0x9D, 0x8D, 0x97, 0xA9, 0xDA, 0x11, -+ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, -+ 0x41, 0x41, /* Object ID - WQAA */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 2 */ -+ /* GUID */ -+ 0xCE, 0x93, 0x05, 0xA8, 0x97, 0xA9, 0xDA, 0x11, -+ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, -+ 0x42, 0x41, /*Object ID - WMBA */ -+ 0x01, /* Instance count */ -+ 0x02, /* Flag - Method */ -+ -+ /* Data Block 3 */ -+ /* GUID */ -+ 0x94, 0x59, 0xBB, 0x9D, 0x97, 0xA9, 0xDA, 0x11, -+ 0xB0, 0x12, 0xB6, 0x22, 0xA1, 0xEF, 0x54, 0x92, -+ 0xD0, 0x00, /* Event notification ID */ -+ 0x01, /* Instance count */ -+ 0x08, /* Flag - Event */ -+ -+ /* Data Block 4 */ -+ /* GUID */ -+ 0xE0, 0x6C, 0x77, 0xA3, 0x88, 0x1E, 0xDB, 0x11, -+ 0xA9, 0x8B, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66, -+ 0x42, 0x43, /* Object ID - WQBC */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 5 */ -+ /* GUID */ -+ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, -+ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, -+ 0x4D, 0x4F, /* Object ID - WQMO */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Method */ -+ -+ /* Data Block 6 */ -+ /* GUID */ -+ 0x28, 0x07, 0xBD, 0x77, 0x34, 0x2E, 0x8C, 0x47, -+ 0xB6, 0x25, 0x67, 0xF0, 0x2A, 0x7E, 0x48, 0x97, -+ 0x42, 0x44, /* Object ID - WMBD */ -+ 0x01, /* Instance count */ -+ 0x02, /* Flag - Method */ -+ -+ }) -+ -+ /* Initialize cmd port and communicate invocation type -+ * i.e., method execution or query or set object -+ */ -+ Method (INIT, 1, Serialized) -+ { -+ Store (100, P96) -+ Store (Arg0, P98) -+ } -+ -+ /* Pass the guid pertaining to the operation */ -+ Method (GUID, 1, Serialized) -+ { -+ Store (101, P96) -+ Store (0x0, Local0) -+ Store (Arg0, Local1) -+ -+ While ( LLess(Local0,16) ) -+ { -+ Add(Local1, Local0, Local2) -+ Store (DerefOf(Index (_WDG, Local2)), P98 ) -+ Increment( Local0 ) -+ } -+ } -+ -+ /* Pass instance # for the associated object pertaining -+ * to the invocation. -+ */ -+ Method (INST, 1, Serialized) -+ { -+ Store(102, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass method id relevant to the method about to be -+ * executed. -+ */ -+ Method (MTID, 1, Serialized) -+ { -+ Store(103, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass input buffer pertaining to the current operation */ -+ Method (IBUF, 1, Serialized) -+ { -+ Store (105, P96) -+ Store (SizeOf(Arg0), Local0) -+ Store (Local0, P9A) -+ ToBuffer (Arg0, Local1) -+ Store (0, Local2) -+ Store (104, P96) -+ While ( LLess(Local2,Local0) ) -+ { -+ Store (DerefOf(Index (Local1, Local2)), P98) -+ Increment (Local2) -+ } -+ } -+ -+ /* Now that the input arguments are passed, execute the command */ -+ Method (EXEC, 0, Serialized) -+ { -+ Store (106, P96) -+ } -+ -+ /* Get the output buffer pertaining to the just executed command */ -+ Method (OBUF, 0, Serialized) -+ { -+ Store (108, P96) -+ Store (P9A, Local0) -+ Store (Buffer(Local0) {}, Local2) -+ Store (0, Local1) -+ Store (107, P96) -+ While ( LLess(Local1, Local0) ) -+ { -+ Store (P98, Index(Local2, Local1)) -+ Increment (Local1) -+ } -+ Return (Local2) -+ } -+ -+ /* Get event data */ -+ Method (_WED, 1, Serialized) -+ { -+ INIT (4) -+ Store (109, P96) -+ Store (Arg0, P98) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Following are well know entry points as supplied by -+ * _WDG. -+ * @TODO: Though current testing suggest that defining -+ * a method for seralized execution is enough to prevent -+ * synchronization issues, consider using explicit mutexes -+ * for further protection. -+ */ -+ Method (WQAA, 1, Serialized) -+ { -+ INIT (2) -+ GUID (0) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMBA, 3, Serialized) -+ { -+ INIT (1) -+ GUID (20) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBC, 1, Serialized) -+ { -+ INIT (2) -+ GUID (60) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Like all other well know entry points, we could delegate -+ * the below to the base firmware also. But, why ask for a -+ * static list (that too this big) and go through layer after -+ * layer to get it? Also, port i/o is not a good idea for this -+ * much data transfer. Luckily, this is the only place that appear -+ * to transfer so much data. -+ */ -+ Name (WQMO, Buffer (0x06CD) -+ { -+ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, -+ /* 0008 */ 0xBD, 0x06, 0x00, 0x00, 0x66, 0x23, 0x00, 0x00, -+ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, -+ /* 0018 */ 0x98, 0x40, 0x91, 0x00, 0x01, 0x06, 0x18, 0x42, -+ /* 0020 */ 0x10, 0x11, 0x10, 0x22, 0x21, 0x30, 0x34, 0x32, -+ /* 0028 */ 0x0B, 0x03, 0x63, 0x04, 0x8A, 0x0B, 0x21, 0x07, -+ /* 0030 */ 0x10, 0x12, 0x07, 0x85, 0x12, 0x02, 0xA1, 0xFE, -+ /* 0038 */ 0x04, 0xF2, 0x2B, 0x00, 0xA1, 0x43, 0x01, 0x32, -+ /* 0040 */ 0x05, 0x18, 0x14, 0xE0, 0x14, 0x41, 0x04, 0xBD, -+ /* 0048 */ 0x0A, 0xB0, 0x29, 0xC0, 0xA4, 0x00, 0x8B, 0x02, -+ /* 0050 */ 0xB4, 0x0B, 0xB0, 0x2C, 0x40, 0xB7, 0x00, 0xE9, -+ /* 0058 */ 0xB0, 0x44, 0x24, 0x38, 0x4A, 0x0C, 0x38, 0x4A, -+ /* 0060 */ 0x27, 0xB6, 0x70, 0xC3, 0x06, 0x2F, 0x14, 0x45, -+ /* 0068 */ 0x33, 0x88, 0x92, 0xA0, 0x72, 0x01, 0xBE, 0x11, -+ /* 0070 */ 0x04, 0x5E, 0xAE, 0x00, 0xC9, 0x13, 0x90, 0x66, -+ /* 0078 */ 0x01, 0x86, 0x05, 0x58, 0x17, 0x20, 0x7B, 0x08, -+ /* 0080 */ 0x54, 0xEA, 0x10, 0x50, 0x72, 0x86, 0x80, 0x1A, -+ /* 0088 */ 0x40, 0xAB, 0x13, 0x10, 0x7E, 0xA5, 0x53, 0x42, -+ /* 0090 */ 0x12, 0x84, 0x33, 0x56, 0xF1, 0xF8, 0x9A, 0x45, -+ /* 0098 */ 0xD3, 0x73, 0x92, 0x73, 0x0C, 0x39, 0x1E, 0x17, -+ /* 00A0 */ 0x7A, 0x10, 0x3C, 0x90, 0x02, 0x10, 0x16, 0x1E, -+ /* 00A8 */ 0x42, 0x11, 0x60, 0x50, 0x12, 0xC6, 0x42, 0x5D, -+ /* 00B0 */ 0x8C, 0x1A, 0x35, 0x52, 0x36, 0x20, 0x43, 0x94, -+ /* 00B8 */ 0x36, 0x6A, 0xF4, 0x80, 0xCE, 0xEF, 0x48, 0xCE, -+ /* 00C0 */ 0xEE, 0xE8, 0x8E, 0x24, 0x81, 0x51, 0x8F, 0xE9, -+ /* 00C8 */ 0x18, 0x0B, 0x9B, 0x91, 0x50, 0x63, 0x34, 0x07, -+ /* 00D0 */ 0x45, 0xA0, 0x71, 0x83, 0xB6, 0x44, 0x58, 0x8D, -+ /* 00D8 */ 0x2B, 0xF6, 0x99, 0x59, 0xF8, 0xB0, 0x84, 0x71, -+ /* 00E0 */ 0x04, 0x07, 0x96, 0xA0, 0x51, 0x34, 0xCD, 0xF1, -+ /* 00E8 */ 0x6C, 0x43, 0x24, 0x38, 0x88, 0xD0, 0x18, 0x19, -+ /* 00F0 */ 0x10, 0xF2, 0x3C, 0x6C, 0x81, 0x1E, 0x79, 0x02, -+ /* 00F8 */ 0xBB, 0x47, 0x94, 0x42, 0x04, 0xCD, 0xF7, 0x44, -+ /* 0100 */ 0x6A, 0x14, 0xA0, 0x0D, 0x43, 0xB6, 0xCE, 0x06, -+ /* 0108 */ 0x1A, 0x6A, 0xAC, 0xC6, 0x50, 0x04, 0x11, 0x21, -+ /* 0110 */ 0x68, 0x14, 0x83, 0x45, 0x08, 0x15, 0xE2, 0xFF, -+ /* 0118 */ 0x1F, 0x25, 0xEA, 0x29, 0x05, 0x89, 0x5A, 0x19, -+ /* 0120 */ 0x88, 0xD0, 0x82, 0x19, 0x81, 0xD9, 0x1F, 0x04, -+ /* 0128 */ 0x89, 0x71, 0x66, 0xD0, 0x61, 0xC1, 0x32, 0x40, -+ /* 0130 */ 0x64, 0x44, 0xD0, 0x68, 0xD8, 0x59, 0xC0, 0xC3, -+ /* 0138 */ 0xF1, 0x4C, 0x9A, 0x9F, 0x98, 0x06, 0x67, 0x82, -+ /* 0140 */ 0xB1, 0x21, 0xA4, 0x01, 0x42, 0xA2, 0x0E, 0x0E, -+ /* 0148 */ 0x94, 0xC0, 0x52, 0x06, 0x4E, 0x6C, 0x8F, 0x4B, -+ /* 0150 */ 0xE3, 0x3B, 0xE3, 0xA8, 0x21, 0x4E, 0xFD, 0xCC, -+ /* 0158 */ 0xFC, 0x8F, 0xF0, 0x16, 0x7C, 0x04, 0xE0, 0x63, -+ /* 0160 */ 0xF0, 0x60, 0x0F, 0x21, 0xE0, 0x11, 0xB2, 0x33, -+ /* 0168 */ 0x80, 0x01, 0xF1, 0xDE, 0x27, 0x4D, 0xE6, 0xE2, -+ /* 0170 */ 0xB3, 0x00, 0x8C, 0xE1, 0xC3, 0x35, 0x3E, 0x0A, -+ /* 0178 */ 0x8D, 0x87, 0x9D, 0x0F, 0xD8, 0xB8, 0x38, 0xBC, -+ /* 0180 */ 0x0F, 0x05, 0x27, 0x5C, 0x2C, 0x88, 0x02, 0x40, -+ /* 0188 */ 0x48, 0xD6, 0xF9, 0x00, 0x3D, 0xEB, 0x63, 0x0B, -+ /* 0190 */ 0xF8, 0x30, 0xD0, 0xEC, 0x1D, 0x82, 0x10, 0xBC, -+ /* 0198 */ 0x08, 0xF8, 0xE8, 0xE0, 0xE3, 0x86, 0xC7, 0xFD, -+ /* 01A0 */ 0xBC, 0x01, 0x86, 0xC3, 0x81, 0x87, 0xE3, 0xD3, -+ /* 01A8 */ 0x06, 0x70, 0x19, 0x01, 0x97, 0xF6, 0xA4, 0x30, -+ /* 01B0 */ 0x81, 0x24, 0x3F, 0x01, 0x24, 0x06, 0x06, 0x75, -+ /* 01B8 */ 0x20, 0xF0, 0xC1, 0x02, 0xAE, 0x24, 0x38, 0xD4, -+ /* 01C0 */ 0xF0, 0x3C, 0xB1, 0x07, 0x84, 0xFF, 0xFF, 0x51, -+ /* 01C8 */ 0x9E, 0xC8, 0x8B, 0x81, 0xA7, 0xFF, 0x18, 0x00, -+ /* 01D0 */ 0xE3, 0x80, 0xE0, 0x69, 0x9D, 0x94, 0x6F, 0x1E, -+ /* 01D8 */ 0x0F, 0x12, 0x1E, 0x54, 0x98, 0x04, 0x3E, 0x25, -+ /* 01E0 */ 0x30, 0x34, 0x7E, 0xDC, 0x00, 0xEB, 0xA8, 0xF1, -+ /* 01E8 */ 0x07, 0x04, 0x78, 0x27, 0x89, 0xF3, 0xEB, 0x73, -+ /* 01F0 */ 0x00, 0x3A, 0x34, 0x9C, 0x22, 0x03, 0x79, 0x0D, -+ /* 01F8 */ 0x38, 0xE9, 0x53, 0xF2, 0xF8, 0x12, 0xF8, 0xCC, -+ /* 0200 */ 0x01, 0xFB, 0x6E, 0x70, 0x18, 0x07, 0x13, 0x22, -+ /* 0208 */ 0xC2, 0x7B, 0xC0, 0x53, 0x87, 0xEF, 0x1A, 0x8F, -+ /* 0210 */ 0x02, 0x81, 0x22, 0xF4, 0x76, 0xE6, 0xA0, 0xA7, -+ /* 0218 */ 0x10, 0xA3, 0x44, 0x3B, 0xAB, 0x30, 0x0F, 0x1C, -+ /* 0220 */ 0x51, 0x7C, 0xE4, 0x30, 0xC2, 0xBB, 0x87, 0xEF, -+ /* 0228 */ 0x04, 0x0F, 0x20, 0xAD, 0x4D, 0x4E, 0xB8, 0x81, -+ /* 0230 */ 0x9E, 0x39, 0x58, 0xB4, 0x33, 0x8B, 0x2C, 0x80, -+ /* 0238 */ 0x28, 0xD2, 0x68, 0x50, 0x67, 0x04, 0x9F, 0x06, -+ /* 0240 */ 0x3C, 0xAD, 0xA7, 0x18, 0x1F, 0x25, 0x0C, 0x72, -+ /* 0248 */ 0x86, 0x07, 0xF6, 0x9C, 0xF0, 0x18, 0xE0, 0x01, -+ /* 0250 */ 0xB3, 0xFB, 0x81, 0x8F, 0x13, 0x3E, 0x17, 0xE0, -+ /* 0258 */ 0x5D, 0x03, 0x6A, 0x86, 0x3E, 0x6C, 0xC0, 0x39, -+ /* 0260 */ 0x74, 0xE0, 0x4F, 0x13, 0xF8, 0x83, 0x05, 0x7E, -+ /* 0268 */ 0x3C, 0xBE, 0xE6, 0xB0, 0x09, 0x27, 0xB0, 0xFC, -+ /* 0270 */ 0x41, 0xA0, 0x46, 0x66, 0x68, 0xCF, 0xF2, 0xB4, -+ /* 0278 */ 0x5E, 0x03, 0x7C, 0xDA, 0x31, 0x81, 0xCF, 0x1B, -+ /* 0280 */ 0xFE, 0xFF, 0xFF, 0x73, 0x3C, 0x1E, 0xF0, 0x2B, -+ /* 0288 */ 0x3E, 0x5D, 0x90, 0xBB, 0x82, 0xE7, 0xEB, 0xB3, -+ /* 0290 */ 0x0B, 0xB3, 0x31, 0x1E, 0xD4, 0x28, 0x7C, 0xC0, -+ /* 0298 */ 0xC1, 0x9D, 0x5D, 0x7C, 0x04, 0xF0, 0xD9, 0x05, -+ /* 02A0 */ 0x78, 0x4E, 0xE2, 0x59, 0x02, 0xBC, 0x87, 0x00, -+ /* 02A8 */ 0x9F, 0x48, 0xE2, 0x3D, 0x6C, 0xC1, 0x18, 0x31, -+ /* 02B0 */ 0x1E, 0xF2, 0x8C, 0xAB, 0x1E, 0x86, 0x2E, 0x02, -+ /* 02B8 */ 0x56, 0x77, 0x5F, 0x41, 0x1D, 0xBD, 0xC0, 0x04, -+ /* 02C0 */ 0xF5, 0x9A, 0x81, 0x3B, 0xBD, 0x00, 0x9F, 0x53, -+ /* 02C8 */ 0x16, 0xBC, 0xFF, 0xFF, 0x29, 0x0B, 0xB8, 0x5F, -+ /* 02D0 */ 0x15, 0xF8, 0x11, 0x05, 0x0C, 0x90, 0x9D, 0x9D, -+ /* 02D8 */ 0x4E, 0x84, 0xF0, 0x5E, 0xF2, 0x1C, 0xE2, 0xDB, -+ /* 02E0 */ 0x95, 0x0F, 0x26, 0x41, 0x9E, 0x03, 0x22, 0x3C, -+ /* 02E8 */ 0x65, 0xF1, 0xFB, 0x40, 0x94, 0x98, 0x07, 0x14, -+ /* 02F0 */ 0x29, 0x8A, 0x11, 0x83, 0x3C, 0x61, 0xF9, 0x7A, -+ /* 02F8 */ 0x12, 0xC3, 0xD0, 0xC1, 0xC2, 0x85, 0x8F, 0xF0, -+ /* 0300 */ 0x94, 0x05, 0x58, 0xBC, 0x64, 0x61, 0x4E, 0x59, -+ /* 0308 */ 0x30, 0xDF, 0x06, 0x3E, 0x65, 0x81, 0xE3, 0xFF, -+ /* 0310 */ 0x7F, 0xCA, 0x02, 0xD7, 0xB8, 0x9F, 0xB2, 0x80, -+ /* 0318 */ 0x99, 0xF4, 0xA7, 0x80, 0x4F, 0x35, 0x7E, 0x02, -+ /* 0320 */ 0x28, 0xFA, 0xC1, 0x82, 0xC2, 0xF8, 0x94, 0x05, -+ /* 0328 */ 0xB8, 0x92, 0x77, 0x40, 0x00, 0xCD, 0xD9, 0xC9, -+ /* 0330 */ 0xB7, 0x05, 0x83, 0x1D, 0xB3, 0x2F, 0x19, 0x3E, -+ /* 0338 */ 0x25, 0x82, 0xE1, 0x90, 0xE1, 0x3B, 0xD5, 0xA1, -+ /* 0340 */ 0x3C, 0x72, 0x3C, 0x05, 0xF8, 0x88, 0x05, 0xF6, -+ /* 0348 */ 0x38, 0xC7, 0x00, 0x1D, 0x57, 0x7C, 0xC4, 0xF2, -+ /* 0350 */ 0xFF, 0xFF, 0x88, 0x05, 0x70, 0xE3, 0x00, 0x82, -+ /* 0358 */ 0x3F, 0x75, 0xC0, 0xBA, 0x07, 0x84, 0xF5, 0xA1, -+ /* 0360 */ 0x03, 0x78, 0xC8, 0x7E, 0x08, 0xE8, 0x0C, 0x63, -+ /* 0368 */ 0xC9, 0x20, 0xB2, 0x71, 0xAE, 0xA1, 0x63, 0xB4, -+ /* 0370 */ 0xF8, 0x85, 0xEA, 0xA6, 0x10, 0xFB, 0x60, 0xB8, -+ /* 0378 */ 0x6C, 0x20, 0x81, 0x7A, 0xB8, 0x16, 0x4C, 0x21, -+ /* 0380 */ 0x51, 0x34, 0x1A, 0x8D, 0x81, 0x09, 0x8C, 0xE0, -+ /* 0388 */ 0x0C, 0x62, 0x40, 0x67, 0x84, 0xD0, 0xA1, 0x0C, -+ /* 0390 */ 0xA7, 0xE2, 0x3C, 0x84, 0xFA, 0xFF, 0x13, 0x0C, -+ /* 0398 */ 0x75, 0x63, 0xA2, 0xB3, 0xF3, 0xFC, 0xF9, 0x6D, -+ /* 03A0 */ 0xC4, 0x27, 0x02, 0x03, 0xFB, 0x0A, 0xF1, 0x96, -+ /* 03A8 */ 0x01, 0x96, 0x61, 0x79, 0x71, 0x4F, 0x00, 0xC7, -+ /* 03B0 */ 0x78, 0x92, 0x09, 0xAA, 0x39, 0xD6, 0xA0, 0xE6, -+ /* 03B8 */ 0xE0, 0xAB, 0xC0, 0x1B, 0x99, 0x09, 0x7C, 0x05, -+ /* 03C0 */ 0x03, 0xDB, 0x69, 0x06, 0xA3, 0xEF, 0x4E, 0x00, -+ /* 03C8 */ 0x0A, 0x20, 0x1F, 0x05, 0x7C, 0x5F, 0x7E, 0x1B, -+ /* 03D0 */ 0x60, 0xB3, 0x78, 0x65, 0x36, 0x9A, 0xCF, 0x9F, -+ /* 03D8 */ 0x88, 0xA1, 0xA3, 0xC4, 0x0C, 0x9D, 0x82, 0x78, -+ /* 03E0 */ 0xE8, 0x0E, 0x3A, 0x74, 0xF4, 0x71, 0xC0, 0x27, -+ /* 03E8 */ 0x2B, 0x5C, 0xB0, 0xC3, 0x17, 0xB4, 0xC9, 0x1D, -+ /* 03F0 */ 0xED, 0x89, 0x79, 0x16, 0x9E, 0x27, 0x6E, 0xEE, -+ /* 03F8 */ 0x60, 0x3A, 0x22, 0xC1, 0x18, 0x3C, 0x66, 0xF2, -+ /* 0400 */ 0x60, 0x16, 0x38, 0x79, 0x50, 0xFC, 0xFF, 0x27, -+ /* 0408 */ 0x0F, 0x13, 0x1E, 0x13, 0xF6, 0x70, 0x48, 0x0F, -+ /* 0410 */ 0x1D, 0x1E, 0x19, 0x1F, 0xA7, 0x4F, 0x3F, 0x0C, -+ /* 0418 */ 0xFB, 0x74, 0xCE, 0xA5, 0xE8, 0x19, 0xE9, 0x8E, -+ /* 0420 */ 0xF1, 0xCC, 0x85, 0x81, 0xF5, 0xC8, 0x39, 0xAC, -+ /* 0428 */ 0xD1, 0xC2, 0x1E, 0xF0, 0x73, 0x88, 0xEF, 0x30, -+ /* 0430 */ 0x3E, 0xF0, 0x30, 0x58, 0x9F, 0x5E, 0xC0, 0x71, -+ /* 0438 */ 0xFC, 0x82, 0x7F, 0x1A, 0x00, 0xCF, 0x01, 0xC4, -+ /* 0440 */ 0x63, 0x78, 0x01, 0xE1, 0x04, 0x73, 0x9D, 0xA6, -+ /* 0448 */ 0x50, 0xF1, 0x4F, 0x53, 0x80, 0xF6, 0xFF, 0xFF, -+ /* 0450 */ 0x69, 0x0A, 0xE6, 0x61, 0xD0, 0x67, 0x08, 0x4F, -+ /* 0458 */ 0x25, 0xC8, 0xEB, 0xD3, 0xAB, 0xA0, 0x31, 0x9E, -+ /* 0460 */ 0x1B, 0x1E, 0xA8, 0x8E, 0x27, 0x4A, 0x88, 0x50, -+ /* 0468 */ 0x91, 0xCE, 0xE0, 0x55, 0x8A, 0x1F, 0xA4, 0xA2, -+ /* 0470 */ 0x04, 0x09, 0xF5, 0x1A, 0xF0, 0x34, 0xE8, 0x2B, -+ /* 0478 */ 0x44, 0x94, 0xA8, 0x21, 0x23, 0xBE, 0x58, 0xF9, -+ /* 0480 */ 0x34, 0xC5, 0x22, 0x9D, 0xA6, 0x00, 0x9A, 0x9C, -+ /* 0488 */ 0x18, 0xF0, 0xA7, 0x29, 0x58, 0xB7, 0x04, 0xCF, -+ /* 0490 */ 0xEE, 0x11, 0x83, 0x9F, 0xA7, 0xC0, 0xFD, 0xFF, -+ /* 0498 */ 0x3F, 0x4F, 0xE1, 0xF2, 0x9C, 0xA7, 0x68, 0x96, -+ /* 04A0 */ 0xF3, 0x14, 0xEA, 0x7C, 0xE1, 0x24, 0x4B, 0x15, -+ /* 04A8 */ 0xFE, 0x23, 0x85, 0x11, 0x8E, 0x87, 0x13, 0x58, -+ /* 04B0 */ 0xFF, 0x89, 0x0A, 0xA5, 0x9C, 0x42, 0xCA, 0xCE, -+ /* 04B8 */ 0x41, 0x28, 0x2D, 0xE7, 0x20, 0x0A, 0xE2, 0x73, -+ /* 04C0 */ 0x10, 0x9C, 0x13, 0x15, 0x36, 0xD9, 0x89, 0x0A, -+ /* 04C8 */ 0xFA, 0x15, 0x07, 0x77, 0x41, 0x86, 0x3D, 0x2F, -+ /* 04D0 */ 0xB6, 0xBE, 0x77, 0x2A, 0xC0, 0x92, 0xBC, 0xC9, -+ /* 04D8 */ 0xA3, 0x04, 0x4D, 0x9E, 0x82, 0x78, 0xF2, 0xBE, -+ /* 04E0 */ 0x0D, 0xF9, 0x4E, 0x05, 0x37, 0xDC, 0x9D, 0x0A, -+ /* 04E8 */ 0x14, 0xC3, 0x07, 0xC3, 0xFF, 0x7F, 0xF8, 0xB0, -+ /* 04F0 */ 0x6F, 0x55, 0x80, 0x9B, 0xE0, 0xB7, 0x2A, 0x40, -+ /* 04F8 */ 0xCF, 0x00, 0x9F, 0x07, 0xC0, 0x72, 0x0D, 0xE1, -+ /* 0500 */ 0xD7, 0x2A, 0xDF, 0x08, 0x30, 0x07, 0x82, 0x67, -+ /* 0508 */ 0x1E, 0x63, 0x62, 0x2E, 0x33, 0x7A, 0x2B, 0xF8, -+ /* 0510 */ 0x0A, 0xE5, 0x25, 0x4A, 0x1E, 0x0C, 0xEA, 0x6E, -+ /* 0518 */ 0x05, 0xF6, 0xFF, 0xFF, 0xDD, 0x0A, 0xD8, 0x5E, -+ /* 0520 */ 0xB4, 0xC1, 0x73, 0x57, 0x78, 0x14, 0xF2, 0xA1, -+ /* 0528 */ 0xC0, 0x37, 0x2B, 0xF8, 0xC3, 0x38, 0x82, 0xC3, -+ /* 0530 */ 0x8F, 0xF0, 0xDC, 0x6B, 0x84, 0xE7, 0x2A, 0x5F, -+ /* 0538 */ 0x7B, 0xC1, 0x1D, 0xFB, 0x39, 0xA2, 0x43, 0x80, -+ /* 0540 */ 0x6F, 0x56, 0x80, 0xE9, 0xFF, 0xFF, 0xCD, 0x0A, -+ /* 0548 */ 0xAC, 0x6F, 0x10, 0x9F, 0x6B, 0xE0, 0x06, 0x3E, -+ /* 0550 */ 0x97, 0xD0, 0xEB, 0x3F, 0xF0, 0xBC, 0x30, 0x82, -+ /* 0558 */ 0xE7, 0x18, 0xE1, 0xDB, 0x28, 0xEE, 0x84, 0x03, -+ /* 0560 */ 0x36, 0xA3, 0x27, 0x1C, 0x04, 0x38, 0xFE, 0x66, -+ /* 0568 */ 0x06, 0x6B, 0x0C, 0x7D, 0xA2, 0xE8, 0x8C, 0x81, -+ /* 0570 */ 0xBB, 0x9A, 0x01, 0x8F, 0x1B, 0x91, 0x87, 0xC0, -+ /* 0578 */ 0x4F, 0x13, 0x1E, 0x02, 0x1F, 0x40, 0xAB, 0xD3, -+ /* 0580 */ 0x23, 0x67, 0x9F, 0x53, 0xC2, 0x1D, 0x07, 0xF8, -+ /* 0588 */ 0x94, 0x70, 0x03, 0xE0, 0xFF, 0x7F, 0x82, 0x01, -+ /* 0590 */ 0x6E, 0x9C, 0xA8, 0xE8, 0x37, 0x4E, 0x80, 0x10, -+ /* 0598 */ 0x20, 0x11, 0x5E, 0x35, 0x7D, 0x88, 0x79, 0xD0, -+ /* 05A0 */ 0xF4, 0x60, 0xDE, 0x62, 0x8C, 0xF3, 0xD6, 0xF0, -+ /* 05A8 */ 0xB2, 0xE9, 0x83, 0x8C, 0xF1, 0xC2, 0x44, 0x39, -+ /* 05B0 */ 0x86, 0x43, 0x8A, 0x19, 0xC5, 0x88, 0x41, 0x42, -+ /* 05B8 */ 0xBC, 0x71, 0x1A, 0xC3, 0xA8, 0xC1, 0xC2, 0x45, -+ /* 05C0 */ 0x8F, 0xF0, 0x20, 0xC3, 0xE2, 0xDC, 0x38, 0x01, -+ /* 05C8 */ 0x21, 0xFF, 0xFF, 0x83, 0x0C, 0x60, 0xE5, 0x68, -+ /* 05D0 */ 0xE6, 0x83, 0x08, 0xFC, 0xE3, 0xC3, 0x9B, 0x42, -+ /* 05D8 */ 0xF0, 0xA7, 0x10, 0x60, 0x22, 0xFE, 0xBE, 0x49, -+ /* 05E0 */ 0x85, 0xDF, 0x37, 0x51, 0x63, 0xB4, 0xF8, 0x85, -+ /* 05E8 */ 0xEA, 0xFA, 0xEC, 0xB9, 0x78, 0xDA, 0x96, 0x7D, -+ /* 05F0 */ 0xDB, 0x44, 0x09, 0xA6, 0x90, 0xA8, 0x13, 0x22, -+ /* 05F8 */ 0x4A, 0xC6, 0x09, 0x91, 0x82, 0x18, 0xD0, 0x19, -+ /* 0600 */ 0x6F, 0x9B, 0x90, 0x43, 0xDD, 0x36, 0xA1, 0xDF, -+ /* 0608 */ 0x1E, 0x9E, 0xE1, 0xC1, 0x79, 0xD6, 0x04, 0xDB, -+ /* 0610 */ 0xFF, 0xFF, 0xAC, 0x09, 0x4C, 0xA5, 0x0D, 0x1D, -+ /* 0618 */ 0x25, 0x66, 0xE8, 0x14, 0xC4, 0xF7, 0x56, 0x38, -+ /* 0620 */ 0x87, 0x28, 0x7C, 0xB0, 0xB3, 0x26, 0x28, 0x4E, -+ /* 0628 */ 0x4C, 0xE0, 0x99, 0x3B, 0xF6, 0xA4, 0x09, 0xD8, -+ /* 0630 */ 0x89, 0x7C, 0xD2, 0x04, 0x82, 0xFF, 0xFF, 0xE3, -+ /* 0638 */ 0x18, 0xD8, 0x8F, 0x54, 0xB8, 0xD3, 0x00, 0xDC, -+ /* 0640 */ 0x03, 0x88, 0xC7, 0x70, 0x9C, 0xEF, 0x4F, 0x06, -+ /* 0648 */ 0x79, 0x1E, 0xF1, 0x81, 0xC0, 0x47, 0x19, 0xA6, -+ /* 0650 */ 0xD0, 0xA6, 0x4F, 0x8D, 0x46, 0xAD, 0x1A, 0x94, -+ /* 0658 */ 0xA9, 0x51, 0xA6, 0x41, 0xAD, 0x3E, 0x95, 0x1A, -+ /* 0660 */ 0x33, 0x76, 0xC0, 0xB0, 0x88, 0xB5, 0x6A, 0xB0, -+ /* 0668 */ 0x0E, 0xB5, 0x5E, 0x81, 0x58, 0xD2, 0x13, 0x43, -+ /* 0670 */ 0x20, 0x16, 0xE5, 0x01, 0x84, 0xC5, 0x35, 0x01, -+ /* 0678 */ 0xC2, 0x84, 0xAF, 0x4A, 0x20, 0x8E, 0x0D, 0x42, -+ /* 0680 */ 0xC5, 0xEA, 0x80, 0x68, 0x64, 0x88, 0x06, 0x11, -+ /* 0688 */ 0x90, 0x43, 0xF8, 0x00, 0x62, 0x91, 0x40, 0x04, -+ /* 0690 */ 0xE4, 0xC8, 0x4A, 0x40, 0x98, 0x60, 0x27, 0x20, -+ /* 0698 */ 0x2C, 0xF3, 0xAB, 0x4A, 0x80, 0x16, 0x60, 0x05, -+ /* 06A0 */ 0x88, 0xE9, 0xD1, 0x02, 0xC4, 0xD4, 0x81, 0x08, -+ /* 06A8 */ 0xC8, 0x29, 0xCC, 0x80, 0x30, 0x0D, 0xAB, 0x12, -+ /* 06B0 */ 0x88, 0xF3, 0x83, 0xD0, 0xD4, 0x76, 0x40, 0x98, -+ /* 06B8 */ 0x66, 0x3D, 0x20, 0x2C, 0xA9, 0x1F, 0x70, 0x16, -+ /* 06C0 */ 0x1B, 0x44, 0x40, 0x56, 0x60, 0x08, 0x88, 0xE9, -+ /* 06C8 */ 0x01, 0x11, 0x90, 0xFF, 0xFF -+ }) -+ -+ Method (WMBD, 3, Serialized) -+ { -+ INIT (1) -+ GUID (100) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ } -+ } -+ -+ /* Wire GPE events to notify OEM -+ * added value events. -+ */ -+ Scope (\_GPE) -+ { -+ Method (_L18, 0, Serialized) -+ { -+ Notify (\_SB.AMW0, 0xD0) -+ } -+ } -+} -+ -diff ---- /dev/null -+++ b/tools/firmware/hvmloader/acpi/ssdt_hp_6930p_elitebook.asl 2009-04-01 16:35:21.000000000 -0400 -@@ -0,0 +1,1309 @@ -+/* -+ * ssdt_hp_6930p_elitebook.asl -+ * -+ * Copyright (c) 2009 Kamala Narasimhan -+ * Copyright (c) 2009 Citrix Systems, Inc. -+ * -+ * 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 -+ */ -+ -+/* SSDT for exposing HP 6930p elitebook specific value add functionalities like -+ * hotkeys, special buttons (e.g., wireless button, presentation button etc.). -+ */ -+ -+/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through -+ * WMI psuedo device objects. For our guests to benefit from such value add, we -+ * expose a psuedo device object in our vACPI layer also. This psuedo object is -+ * similar to the underlying base firmware object in the sense we expose the -+ * same _WDG method which describes the WMI methods, data objects and events -+ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically -+ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get -+ * known entry points and calls those entry points for further information exchange. -+ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ */ -+ -+/* COMMUNICATION DETAILS - -+ * Command port - 0x96 -+ * Writes to this port describe what type of information is about -+ * to be exchanged. E.g., guid, input argument transfer etc. -+ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. -+ * Communicates data to and from the backend. E.g. Input buffer values -+ * get written to this port and output buffer values are read from this -+ * port. -+ */ -+ -+DefinitionBlock ("SSDT_HP_6930P_ELITEBOOK.aml", "SSDT", 2, "Xen", "HVM", 0) -+{ -+ Scope (\_SB) -+ { -+ -+ OperationRegion (HP1, SystemIO, 0x96, 0x01) -+ Field (HP1, ByteAcc, NoLock, Preserve) -+ { -+ P96, 8 -+ } -+ -+ OperationRegion (HP2, SystemIO, 0x98, 0x01) -+ Field (HP2, ByteAcc, NoLock, Preserve) -+ { -+ P98, 8 -+ } -+ -+ OperationRegion (HP3, SystemIO, 0x9A, 0x04) -+ Field (HP3, DWordAcc, NoLock, Preserve) -+ { -+ P9A, 32 -+ } -+ -+ Device (WMID) -+ { -+ /* Exposing a pseudo device with HID PNP0C14 will -+ * result in Windows guest loading their WMI wrapper -+ * driver - wmiacpi.sys -+ */ -+ Name (_HID, EisaId ("PNP0C14")) -+ Name (_UID, 0x00) -+ -+ /* Following list of data blocks exposed by _WDG is same as the -+ * one provided by the underlying firmware. Refer to - -+ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ * for further information about _WDG and what it exposes. -+ */ -+ Name (_WDG, Buffer (0xF0) -+ { -+ /* Data Block 1 */ -+ /* GUID */ -+ 0x34, 0xF0, 0xB7, 0x5F, 0x63, 0x2C, 0xE9, 0x45, -+ 0xBE, 0x91, 0x3D, 0x44, 0xE2, 0xC7, 0x07, 0xE4, -+ 0x41, 0x41, /* Object ID - WMAA */ -+ 0x01, /* Instance count */ -+ 0x02, /* Flag - Method */ -+ -+ /* Data Block 2 */ -+ /* GUID */ -+ 0x79, 0x42, 0xF2, 0x95, 0x7B, 0x4D, 0x34, 0x43, -+ 0x93, 0x87, 0xAC, 0xCD, 0xC6, 0x7E, 0xF6, 0x1C, -+ 0x80, 0x00, /* Event notification ID */ -+ 0x01, /* Instance count */ -+ 0x08, /* Flag - Event */ -+ -+ /* Data Block 3 */ -+ /* GUID */ -+ 0x18, 0x43, 0x81, 0x2B, 0xE8, 0x4B, 0x07, 0x47, -+ 0x9D, 0x84, 0xA1, 0x90, 0xA8, 0x59, 0xB5, 0xD0, -+ 0xA0, 0x00, /* Event notification ID */ -+ 0x01, /* Instance count */ -+ 0x08, /* Flag - Event */ -+ -+ /* Data Block 4 */ -+ /* GUID */ -+ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, -+ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, -+ 0x41, 0x42, /* Object ID - WQAB */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 5 */ -+ /* GUID */ -+ 0xEB, 0x91, 0x4C, 0x1F, 0x5C, 0xDC, 0x0B, 0x46, -+ 0x95, 0x1D, 0xC7, 0xCB, 0x9B, 0x4B, 0x8D, 0x5E, -+ 0x42, 0x41, /* Object ID - WMBA */ -+ 0x01, /* Instance count */ -+ 0x02, /* Flag - Method */ -+ -+ /* Data Block 6 */ -+ /* GUID */ -+ 0x49, 0x4B, 0x11, 0x2D, 0xFB, 0x2D, 0x30, 0x41, -+ 0xB8, 0xFE, 0x4A, 0x3C, 0x09, 0xE7, 0x51, 0x33, -+ 0x42, 0x43, /* Object ID - WQBC */ -+ 0x74, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 7 */ -+ /* GUID */ -+ 0xE3, 0x08, 0x8D, 0x98, 0xF4, 0x68, 0x35, 0x4C, -+ 0xAF, 0x3E, 0x6A, 0x1B, 0x81, 0x06, 0xF8, 0x3C, -+ 0x42, 0x44, /* Object ID - WQBD */ -+ 0x19, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 8 */ -+ /* GUID */ -+ 0x46, 0x97, 0xEA, 0x14, 0x1F, 0xCE, 0x98, 0x40, -+ 0xA0, 0xE0, 0x70, 0x45, 0xCB, 0x4D, 0xA7, 0x45, -+ 0x42, 0x45, /* Object ID - WQBE */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 9 */ -+ /* GUID */ -+ 0x28, 0x20, 0x2F, 0x32, 0x84, 0x0F, 0x01, 0x49, -+ 0x98, 0x8E, 0x01, 0x51, 0x76, 0x04, 0x9E, 0x2D, -+ 0x42, 0x46, /* Object ID - WQBF */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag Data */ -+ -+ /* Data Block 10 */ -+ /* GUID */ -+ 0x3D, 0xDE, 0x32, 0x82, 0x3D, 0x66, 0x27, 0x43, -+ 0xA8, 0xF4, 0xE2, 0x93, 0xAD, 0xB9, 0xBF, 0x05, -+ 0x42, 0x47, /* Object ID - WQBG */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 11 */ -+ /* GUID */ -+ 0x36, 0x64, 0x1F, 0x8F, 0x42, 0x9F, 0xC8, 0x42, -+ 0xBA, 0xDC, 0x0E, 0x94, 0x24, 0xF2, 0x0C, 0x9A, -+ 0x42, 0x48, /* Object ID - WQBH */ -+ 0x00, /* Instance count */ -+ 0x00, /* Flag - Data */ -+ -+ /* Data Block 12 */ -+ /* GUID */ -+ 0x35, 0x64, 0x1F, 0x8F, 0x42, 0x9F, 0xC8, 0x42, -+ 0xBA, 0xDC, 0x0E, 0x94, 0x24, 0xF2, 0x0C, 0x9A, -+ 0x42, 0x49, /* Object ID - WQBI */ -+ 0x00, /* Instance count */ -+ 0x00 /* Flag - Data */ -+ }) -+ -+ /* Initialize cmd port and communicate invocation type -+ * i.e., method execution or query or set object -+ */ -+ Method (INIT, 1, Serialized) -+ { -+ Store (100, P96) -+ Store (Arg0, P98) -+ } -+ -+ /* Pass the guid pertaining to the operation */ -+ Method (GUID, 1, Serialized) -+ { -+ Store (101, P96) -+ Store (0x0, Local0) -+ Store (Arg0, Local1) -+ -+ While ( LLess(Local0,16) ) -+ { -+ Add(Local1, Local0, Local2) -+ Store (DerefOf(Index (_WDG, Local2)), P98 ) -+ Increment( Local0 ) -+ } -+ } -+ -+ /* Pass instance # for the associated object pertaining -+ * to the invocation. -+ */ -+ Method (INST, 1, Serialized) -+ { -+ Store(102, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass method id relevant to the method about to be -+ * executed. -+ */ -+ Method (MTID, 1, Serialized) -+ { -+ Store(103, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass input buffer pertaining to the current operation */ -+ Method (IBUF, 1, Serialized) -+ { -+ Store (105, P96) -+ Store (SizeOf(Arg0), Local0) -+ Store (Local0, P9A) -+ ToBuffer (Arg0, Local1) -+ Store (0, Local2) -+ Store (104, P96) -+ While ( LLess(Local2,Local0) ) -+ { -+ Store (DerefOf(Index (Local1, Local2)), P98) -+ Increment (Local2) -+ } -+ } -+ -+ /* Now that the input arguments are passed, execute the command */ -+ Method (EXEC, 0, Serialized) -+ { -+ Store (106, P96) -+ } -+ -+ /* Get the output buffer pertaining to the just executed command */ -+ Method (OBUF, 0, Serialized) -+ { -+ Store (108, P96) -+ Store (P9A, Local0) -+ Store (Buffer(Local0) {}, Local2) -+ Store (0, Local1) -+ Store (107, P96) -+ While ( LLess(Local1, Local0) ) -+ { -+ Store (P98, Index(Local2, Local1)) -+ Increment (Local1) -+ } -+ Return (Local2) -+ } -+ -+ /* Get event data */ -+ Method (_WED, 1, Serialized) -+ { -+ INIT (4) -+ Store (109, P96) -+ Store (Arg0, P98) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Following are well know entry points as supplied by -+ * _WDG. -+ * @TODO: Though current testing suggest that defining -+ * a method for seralized execution is enough to prevent -+ * synchronization issues, consider using explicit mutexes -+ * for further protection. -+ */ -+ Method (WMAA, 3, Serialized) -+ { -+ INIT (1) -+ GUID (0) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMBA, 3, Serialized) -+ { -+ INIT (1) -+ GUID (80) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Like all other well know entry points, we could delegate -+ * the below to the base firmware also. But, why ask for a -+ * static list (that too this big) and go through layer after -+ * layer to get it? Also, port i/o is not a good idea for this -+ * much data transfer. Luckily, this is the only place that appear -+ * to transfer so much data. -+ */ -+ Name (WQAB, Buffer (0x1C53) -+ { -+ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, -+ /* 0008 */ 0x43, 0x1C, 0x00, 0x00, 0xEA, 0xB4, 0x00, 0x00, -+ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, -+ /* 0018 */ 0x98, 0x2D, 0x96, 0x00, 0x01, 0x06, 0x18, 0x42, -+ /* 0020 */ 0x10, 0x47, 0x10, 0x92, 0x46, 0x62, 0x02, 0x89, -+ /* 0028 */ 0x80, 0x90, 0x18, 0x18, 0x14, 0x81, 0x85, 0x00, -+ /* 0030 */ 0x49, 0x02, 0x88, 0xC4, 0x41, 0xE1, 0x20, 0xD4, -+ /* 0038 */ 0x9F, 0x40, 0x7E, 0x05, 0x20, 0x74, 0x28, 0x40, -+ /* 0040 */ 0xA6, 0x00, 0x83, 0x02, 0x9C, 0x22, 0x88, 0xA0, -+ /* 0048 */ 0x57, 0x01, 0x36, 0x05, 0x98, 0x14, 0x60, 0x51, -+ /* 0050 */ 0x80, 0x76, 0x01, 0x96, 0x05, 0xE8, 0x16, 0x20, -+ /* 0058 */ 0x1D, 0x96, 0x88, 0x04, 0x47, 0x89, 0x01, 0x47, -+ /* 0060 */ 0xE9, 0xC4, 0x16, 0x6E, 0xD8, 0xE0, 0x85, 0xA2, -+ /* 0068 */ 0x68, 0x06, 0x51, 0x12, 0x94, 0x8B, 0x20, 0x5D, -+ /* 0070 */ 0x10, 0x52, 0x2E, 0xC0, 0x37, 0x82, 0x06, 0x10, -+ /* 0078 */ 0xA5, 0x77, 0x01, 0xB6, 0x05, 0x98, 0x86, 0x27, -+ /* 0080 */ 0xD2, 0x20, 0xE4, 0x60, 0x08, 0x54, 0xCE, 0x80, -+ /* 0088 */ 0x20, 0x69, 0x44, 0x21, 0x1E, 0xA7, 0x44, 0x08, -+ /* 0090 */ 0x0A, 0x84, 0x90, 0xD4, 0xF1, 0xA0, 0xA0, 0x71, -+ /* 0098 */ 0x88, 0xAD, 0xCE, 0x46, 0x93, 0xA9, 0x74, 0x7E, -+ /* 00A0 */ 0x48, 0x82, 0x70, 0xC6, 0x2A, 0x7E, 0x3A, 0x9A, -+ /* 00A8 */ 0xD0, 0xD9, 0x9C, 0x60, 0xE7, 0x18, 0x72, 0x3C, -+ /* 00B0 */ 0x48, 0xF4, 0x20, 0xB8, 0x00, 0x0F, 0x1C, 0x2C, -+ /* 00B8 */ 0x34, 0x84, 0x22, 0x6B, 0x80, 0xC1, 0x8C, 0xDD, -+ /* 00C0 */ 0x63, 0xB1, 0x0B, 0x4E, 0x0A, 0xEC, 0x61, 0xB3, -+ /* 00C8 */ 0x01, 0x19, 0xA2, 0x24, 0x38, 0xD4, 0x11, 0xC0, -+ /* 00D0 */ 0x12, 0x05, 0x98, 0x1F, 0x87, 0x0C, 0x0F, 0x95, -+ /* 00D8 */ 0x8C, 0x25, 0x24, 0x1B, 0xAB, 0x87, 0xC2, 0xA5, -+ /* 00E0 */ 0x40, 0x68, 0x6C, 0x27, 0xED, 0x19, 0x45, 0x2C, -+ /* 00E8 */ 0x79, 0x4A, 0x82, 0x49, 0xE0, 0x51, 0x44, 0x36, -+ /* 00F0 */ 0x1A, 0x27, 0x28, 0x1B, 0x1A, 0x25, 0x03, 0x42, -+ /* 00F8 */ 0x9E, 0x05, 0x58, 0x07, 0x26, 0x04, 0x76, 0x2F, -+ /* 0100 */ 0xC0, 0x9A, 0x00, 0x73, 0xB3, 0x90, 0xB1, 0xB9, -+ /* 0108 */ 0xE8, 0xFF, 0x0F, 0x71, 0xB0, 0x31, 0xDA, 0x9A, -+ /* 0110 */ 0xAE, 0x90, 0xC2, 0xC4, 0x88, 0x12, 0x2C, 0x5E, -+ /* 0118 */ 0xC5, 0xC3, 0x10, 0xCA, 0x93, 0x42, 0xA8, 0x48, -+ /* 0120 */ 0x95, 0xA1, 0x68, 0xB4, 0x51, 0x2A, 0x14, 0xE0, -+ /* 0128 */ 0x4C, 0x80, 0x30, 0x5C, 0x1D, 0x03, 0x82, 0x46, -+ /* 0130 */ 0x88, 0x15, 0x29, 0x56, 0xFB, 0x83, 0x20, 0xF1, -+ /* 0138 */ 0x2D, 0x40, 0x54, 0x01, 0xA2, 0x48, 0xA3, 0x41, -+ /* 0140 */ 0x9D, 0x03, 0x3C, 0x5C, 0x0F, 0xF5, 0xF0, 0x3D, -+ /* 0148 */ 0xF6, 0x93, 0x0C, 0x72, 0x90, 0x67, 0xF1, 0xA8, -+ /* 0150 */ 0x70, 0x9C, 0x06, 0x49, 0xE0, 0x0B, 0x80, 0x4F, -+ /* 0158 */ 0x08, 0x1E, 0x38, 0xDE, 0x35, 0xA0, 0x66, 0x7C, -+ /* 0160 */ 0xBC, 0x4C, 0x10, 0x1C, 0x6A, 0x88, 0x1E, 0x68, -+ /* 0168 */ 0xB8, 0x13, 0x38, 0x44, 0x06, 0xE8, 0x49, 0x3D, -+ /* 0170 */ 0x52, 0x60, 0x07, 0x77, 0x32, 0xEF, 0x01, 0xAF, -+ /* 0178 */ 0x0A, 0xCD, 0x5E, 0x12, 0x08, 0xC1, 0xF1, 0xF8, -+ /* 0180 */ 0x7E, 0xC0, 0x26, 0x9C, 0xC0, 0xF2, 0x07, 0x81, -+ /* 0188 */ 0x1A, 0x99, 0xA1, 0x3D, 0xCA, 0xD3, 0x8A, 0x19, -+ /* 0190 */ 0xF2, 0x31, 0xC1, 0x04, 0x16, 0x0B, 0x21, 0x05, -+ /* 0198 */ 0x10, 0x1A, 0x0F, 0xF8, 0x6F, 0x00, 0x8F, 0x17, -+ /* 01A0 */ 0xBE, 0x12, 0xC4, 0xF6, 0x80, 0x12, 0x0C, 0x0B, -+ /* 01A8 */ 0x21, 0x23, 0xAB, 0xF0, 0x78, 0xE8, 0x28, 0x7C, -+ /* 01B0 */ 0x95, 0x38, 0x9C, 0xD3, 0x8A, 0x67, 0x82, 0xE1, -+ /* 01B8 */ 0x20, 0xF4, 0x05, 0x90, 0x00, 0x51, 0xE7, 0x0C, -+ /* 01C0 */ 0xD4, 0x61, 0xC1, 0xE7, 0x04, 0x76, 0x33, 0x38, -+ /* 01C8 */ 0x83, 0x47, 0x00, 0x8F, 0xE4, 0x84, 0xFC, 0x2B, -+ /* 01D0 */ 0xF1, 0xC0, 0xE0, 0x03, 0xE2, 0xEF, 0x1F, 0xA7, -+ /* 01D8 */ 0xEC, 0x11, 0x9C, 0xA9, 0x01, 0x7D, 0x1C, 0xF0, -+ /* 01E0 */ 0xFF, 0x7F, 0x28, 0x7C, 0x88, 0x1E, 0xDF, 0x29, -+ /* 01E8 */ 0x1F, 0xAF, 0x4F, 0x17, 0x96, 0x35, 0x4E, 0xE8, -+ /* 01F0 */ 0x77, 0x08, 0x9F, 0x38, 0x7C, 0x64, 0x71, 0x44, -+ /* 01F8 */ 0x08, 0x39, 0x39, 0x05, 0xA0, 0x81, 0x4F, 0xF7, -+ /* 0200 */ 0xEC, 0x22, 0x9C, 0xAE, 0x27, 0xE5, 0x40, 0xC3, -+ /* 0208 */ 0xA0, 0xE3, 0x04, 0xC7, 0x79, 0x00, 0x1C, 0xE3, -+ /* 0210 */ 0x84, 0x7F, 0x2E, 0x80, 0x3F, 0x40, 0x7E, 0xCA, -+ /* 0218 */ 0x78, 0xC5, 0x48, 0xE0, 0x98, 0x23, 0x44, 0x9F, -+ /* 0220 */ 0x6B, 0x3C, 0x42, 0x2C, 0xFC, 0x53, 0x45, 0xE1, -+ /* 0228 */ 0x03, 0x21, 0x63, 0x04, 0x17, 0xA0, 0xC7, 0x08, -+ /* 0230 */ 0x7C, 0x03, 0x8E, 0x11, 0x7D, 0x94, 0xE0, 0xEA, -+ /* 0238 */ 0x0F, 0x1A, 0x74, 0x80, 0xB8, 0xFF, 0xFF, 0x00, -+ /* 0240 */ 0xE1, 0x83, 0x7A, 0x80, 0xC0, 0x37, 0xFA, 0xD1, -+ /* 0248 */ 0x03, 0x3D, 0x2E, 0x8B, 0x3E, 0x0F, 0xC8, 0xF8, -+ /* 0250 */ 0x89, 0x46, 0xF3, 0xE2, 0xA7, 0x03, 0x7E, 0xF8, -+ /* 0258 */ 0x00, 0x0F, 0xA8, 0x87, 0x84, 0x03, 0xC5, 0x4C, -+ /* 0260 */ 0x9B, 0x83, 0x3E, 0xBB, 0x1C, 0x3A, 0x76, 0xB8, -+ /* 0268 */ 0xE0, 0x3F, 0x81, 0x80, 0x4B, 0xDE, 0x21, 0x0C, -+ /* 0270 */ 0x14, 0x23, 0xC6, 0x9F, 0x83, 0x7C, 0x0A, 0x03, -+ /* 0278 */ 0xFF, 0xFF, 0xFF, 0x14, 0x06, 0xFE, 0xE1, 0xF0, -+ /* 0280 */ 0x20, 0x4F, 0x07, 0x9F, 0xB6, 0xA8, 0x74, 0x18, -+ /* 0288 */ 0xD4, 0x81, 0x0B, 0xB0, 0x32, 0x89, 0x08, 0xCF, -+ /* 0290 */ 0x12, 0xB5, 0x41, 0xE8, 0xD4, 0xF0, 0x36, 0xF1, -+ /* 0298 */ 0xB6, 0xE5, 0x5B, 0x40, 0x9C, 0xD3, 0xEC, 0xED, -+ /* 02A0 */ 0xC0, 0x45, 0x30, 0x22, 0xD4, 0x0C, 0x45, 0x4E, -+ /* 02A8 */ 0x5A, 0x11, 0x63, 0x44, 0x79, 0xDC, 0x32, 0xCA, -+ /* 02B0 */ 0xDB, 0xD6, 0x0B, 0x40, 0xBC, 0x13, 0x7B, 0xDE, -+ /* 02B8 */ 0x32, 0x46, 0xF0, 0xC8, 0x0F, 0x5C, 0x2C, 0xC6, -+ /* 02C0 */ 0xEA, 0xF5, 0x5F, 0xF3, 0x81, 0x0B, 0x70, 0xF6, -+ /* 02C8 */ 0xFF, 0x3F, 0x70, 0x01, 0x1C, 0x0A, 0x7A, 0x18, -+ /* 02D0 */ 0x42, 0x0F, 0xC3, 0x53, 0x39, 0x97, 0x87, 0xC8, -+ /* 02D8 */ 0x53, 0x89, 0x18, 0x35, 0x4C, 0xD4, 0x67, 0x28, -+ /* 02E0 */ 0xDF, 0x2D, 0x7C, 0x20, 0x02, 0xDF, 0x99, 0x0B, -+ /* 02E8 */ 0xF8, 0xFD, 0xFF, 0x0F, 0x44, 0x70, 0x8E, 0x29, -+ /* 02F0 */ 0xB8, 0x33, 0x0D, 0x78, 0x7C, 0xCE, 0x40, 0x20, -+ /* 02F8 */ 0xA7, 0xE2, 0x43, 0x0D, 0x60, 0x41, 0xF4, 0x13, -+ /* 0300 */ 0xC2, 0x27, 0x1A, 0x2A, 0x13, 0x06, 0x75, 0xA8, -+ /* 0308 */ 0x01, 0xAC, 0x5C, 0x61, 0x9E, 0x46, 0xCF, 0xF9, -+ /* 0310 */ 0x59, 0xC6, 0xA7, 0x1A, 0x1F, 0x4A, 0x8D, 0x63, -+ /* 0318 */ 0x88, 0x97, 0x99, 0x87, 0x1A, 0x1F, 0x0B, 0x5E, -+ /* 0320 */ 0x49, 0x7D, 0xA8, 0x31, 0x54, 0x9C, 0x87, 0x1A, -+ /* 0328 */ 0x0F, 0x37, 0x50, 0xD4, 0x37, 0x9B, 0x67, 0x1B, -+ /* 0330 */ 0xA3, 0xC7, 0xF7, 0x0D, 0xD5, 0x10, 0x0F, 0x35, -+ /* 0338 */ 0x4C, 0xF2, 0x4A, 0x35, 0x16, 0x1F, 0x6A, 0xC0, -+ /* 0340 */ 0xF1, 0xFF, 0x3F, 0xD4, 0x00, 0xFC, 0xFF, 0xFF, -+ /* 0348 */ 0x1F, 0x6A, 0x00, 0x47, 0x47, 0x03, 0x38, 0x47, -+ /* 0350 */ 0x46, 0xDC, 0xD1, 0x00, 0x5C, 0x87, 0x52, 0xE0, -+ /* 0358 */ 0x70, 0x34, 0x00, 0x1E, 0x47, 0x21, 0x30, 0x5F, -+ /* 0360 */ 0x68, 0x7C, 0x14, 0x02, 0x16, 0xFF, 0xFF, 0xA3, -+ /* 0368 */ 0x10, 0xF8, 0x65, 0x9F, 0x83, 0x50, 0x42, 0x8F, -+ /* 0370 */ 0x42, 0x80, 0xA0, 0xDB, 0xCF, 0x53, 0xC4, 0xB3, -+ /* 0378 */ 0x8F, 0x2F, 0x3F, 0x0F, 0x04, 0x11, 0x5E, 0xF3, -+ /* 0380 */ 0x7D, 0x0A, 0xF2, 0x21, 0xDF, 0x47, 0x21, 0x06, -+ /* 0388 */ 0x63, 0x28, 0x5F, 0x83, 0x7C, 0x14, 0x62, 0x50, -+ /* 0390 */ 0xAF, 0x41, 0xBE, 0xEF, 0x1B, 0xE4, 0xF1, 0x22, -+ /* 0398 */ 0x48, 0xEC, 0x67, 0x02, 0x1F, 0x85, 0x98, 0xE8, -+ /* 03A0 */ 0xA3, 0x10, 0xA0, 0xF0, 0xFF, 0x7F, 0x14, 0x02, -+ /* 03A8 */ 0xF8, 0xFF, 0xFF, 0x3F, 0x0A, 0x01, 0xCE, 0x02, -+ /* 03B0 */ 0x1C, 0x0D, 0x40, 0x37, 0xAD, 0x47, 0x21, 0xF0, -+ /* 03B8 */ 0xDE, 0x59, 0x4E, 0xFB, 0x04, 0x7C, 0x16, 0x02, -+ /* 03C0 */ 0xCC, 0xFE, 0xFF, 0xCF, 0x42, 0xC0, 0xEC, 0x28, -+ /* 03C8 */ 0x74, 0x14, 0x67, 0xF9, 0x2A, 0xF4, 0x04, 0xF0, -+ /* 03D0 */ 0x02, 0x10, 0x23, 0xCC, 0x3B, 0xD0, 0x4B, 0x26, -+ /* 03D8 */ 0xBB, 0x8B, 0x1B, 0xE7, 0xC9, 0xE5, 0x2C, 0x9E, -+ /* 03E0 */ 0xC4, 0x7D, 0x09, 0xF2, 0x81, 0xE2, 0x59, 0xC8, -+ /* 03E8 */ 0x50, 0xA7, 0x1B, 0xF4, 0x8D, 0xDC, 0x03, 0x8B, -+ /* 03F0 */ 0x19, 0x3F, 0xC4, 0xF3, 0x90, 0x21, 0x9E, 0x85, -+ /* 03F8 */ 0x00, 0x76, 0xFD, 0xFF, 0xCF, 0x42, 0x00, 0xFF, -+ /* 0400 */ 0xFF, 0xFF, 0x47, 0x03, 0xF8, 0x2F, 0x00, 0x9F, -+ /* 0408 */ 0x85, 0x80, 0xE7, 0x09, 0xE0, 0x41, 0xDB, 0x67, -+ /* 0410 */ 0x21, 0x80, 0x33, 0x87, 0xCB, 0xF3, 0x7F, 0x05, -+ /* 0418 */ 0x3A, 0x96, 0xF7, 0x08, 0xCF, 0xFA, 0x24, 0x5F, -+ /* 0420 */ 0x2F, 0x3D, 0xD3, 0x87, 0x82, 0x67, 0x21, 0x86, -+ /* 0428 */ 0x75, 0x18, 0x3E, 0x0B, 0x31, 0x88, 0x17, 0x4D, -+ /* 0430 */ 0x43, 0xBC, 0x70, 0xFA, 0x30, 0xE0, 0xFF, 0x3F, -+ /* 0438 */ 0x5E, 0xE0, 0x57, 0x4E, 0x03, 0x05, 0x09, 0xF4, -+ /* 0440 */ 0x2C, 0x04, 0x30, 0xFE, 0xFF, 0x7F, 0x16, 0x02, -+ /* 0448 */ 0xC8, 0xB8, 0x46, 0x9D, 0x85, 0x80, 0xE5, 0x6D, -+ /* 0450 */ 0xE5, 0x19, 0xDB, 0xA7, 0x95, 0x04, 0xFF, 0xFF, -+ /* 0458 */ 0x67, 0x21, 0xC0, 0x41, 0x2E, 0x23, 0x07, 0x21, -+ /* 0460 */ 0x4C, 0xC4, 0x87, 0x83, 0x8F, 0x99, 0x80, 0x9E, -+ /* 0468 */ 0x29, 0xBE, 0xB8, 0x1B, 0xE3, 0x09, 0xE0, 0x45, -+ /* 0470 */ 0xE2, 0x31, 0x93, 0x1D, 0x35, 0x0D, 0xF3, 0x2C, -+ /* 0478 */ 0x64, 0xBC, 0xB3, 0x78, 0x0D, 0x78, 0x82, 0xF7, -+ /* 0480 */ 0xE4, 0x9F, 0x85, 0x18, 0xD8, 0x61, 0x05, 0x7B, -+ /* 0488 */ 0x14, 0x32, 0xA8, 0xC1, 0x63, 0x87, 0x08, 0x13, -+ /* 0490 */ 0xE8, 0x59, 0x88, 0xC5, 0x7D, 0xAE, 0xE8, 0x3C, -+ /* 0498 */ 0xE1, 0xB3, 0x10, 0xF0, 0xFE, 0xFF, 0x9F, 0x25, -+ /* 04A0 */ 0xE0, 0x5E, 0x0D, 0x9E, 0x85, 0x00, 0x13, 0x87, -+ /* 04A8 */ 0x0D, 0x9F, 0x35, 0xC0, 0x33, 0x7C, 0x8F, 0xEA, -+ /* 04B0 */ 0x1C, 0x1E, 0x8F, 0x81, 0x7F, 0x56, 0x1D, 0xE7, -+ /* 04B8 */ 0x04, 0x96, 0x7B, 0xD1, 0xB2, 0x71, 0xA0, 0xA1, -+ /* 04C0 */ 0x23, 0xB2, 0x3A, 0x20, 0x8D, 0x0D, 0x73, 0x29, -+ /* 04C8 */ 0x89, 0x7C, 0x72, 0x6C, 0xD4, 0x56, 0x04, 0xA7, -+ /* 04D0 */ 0x33, 0x93, 0x4F, 0x00, 0xD6, 0x42, 0x21, 0x05, -+ /* 04D8 */ 0x34, 0x1A, 0x8B, 0xE1, 0x9D, 0xF9, 0xE8, 0x44, -+ /* 04E0 */ 0x41, 0x0C, 0xE8, 0xE3, 0x90, 0x6D, 0x1C, 0x0A, -+ /* 04E8 */ 0x50, 0x7B, 0xD1, 0x14, 0xC8, 0x39, 0x07, 0xA3, -+ /* 04F0 */ 0x7F, 0x76, 0x74, 0x36, 0xBE, 0x13, 0x70, 0x0D, -+ /* 04F8 */ 0x10, 0x3A, 0x25, 0x18, 0xDA, 0x6A, 0x04, 0xFC, -+ /* 0500 */ 0xFF, 0x67, 0x89, 0x01, 0x33, 0xFE, 0x53, 0x8C, -+ /* 0508 */ 0x09, 0x7C, 0x8E, 0xC1, 0x1F, 0x0C, 0xF0, 0x03, -+ /* 0510 */ 0x7F, 0x31, 0xA8, 0xFA, 0x5E, 0xA0, 0xFB, 0x82, -+ /* 0518 */ 0xD5, 0xDD, 0x64, 0x20, 0xCC, 0xC8, 0x04, 0xF5, -+ /* 0520 */ 0x9D, 0x0E, 0x40, 0x01, 0xE4, 0x0B, 0x81, 0xCF, -+ /* 0528 */ 0x51, 0x0F, 0x05, 0x6C, 0x22, 0x21, 0xC2, 0x44, -+ /* 0530 */ 0x33, 0x3A, 0x62, 0xC2, 0xA8, 0xE8, 0x13, 0xA6, -+ /* 0538 */ 0x20, 0x9E, 0xB0, 0x63, 0x4D, 0x18, 0x3D, 0x13, -+ /* 0540 */ 0x5F, 0x74, 0xD8, 0x88, 0x31, 0x21, 0xAE, 0x1E, -+ /* 0548 */ 0xD0, 0x26, 0x18, 0xD4, 0x97, 0x22, 0x58, 0x43, -+ /* 0550 */ 0xE6, 0x63, 0xF1, 0x05, 0x02, 0x37, 0x65, 0x30, -+ /* 0558 */ 0xCE, 0x89, 0x5D, 0x13, 0x7C, 0xD9, 0xC1, 0xCD, -+ /* 0560 */ 0x19, 0x8C, 0xF0, 0x98, 0xBB, 0x18, 0xBF, 0x3A, -+ /* 0568 */ 0x79, 0x74, 0xFC, 0xA0, 0xE0, 0x1B, 0x0E, 0xC3, -+ /* 0570 */ 0x7E, 0x32, 0xF3, 0x8C, 0xDE, 0xCB, 0x7C, 0x8D, -+ /* 0578 */ 0xC3, 0xC0, 0x7A, 0xBC, 0x1C, 0xD6, 0x68, 0x61, -+ /* 0580 */ 0x0F, 0xED, 0x3D, 0xC4, 0xFF, 0xFF, 0x43, 0x8C, -+ /* 0588 */ 0xCF, 0x13, 0xC6, 0x08, 0xEB, 0xDB, 0x0B, 0x38, -+ /* 0590 */ 0xEE, 0x59, 0xF0, 0xEF, 0x1A, 0xE0, 0xB9, 0x84, -+ /* 0598 */ 0xF8, 0xAE, 0x01, 0x30, 0xF0, 0xFF, 0x7F, 0xD7, -+ /* 05A0 */ 0x00, 0x4E, 0xD7, 0x04, 0xDF, 0x35, 0x80, 0xF7, -+ /* 05A8 */ 0xD0, 0x7D, 0xD7, 0x00, 0xAE, 0xD9, 0xEF, 0x1A, -+ /* 05B0 */ 0xA8, 0x63, 0x80, 0x15, 0xDE, 0x35, 0xA0, 0x5D, -+ /* 05B8 */ 0xD9, 0xDE, 0xD7, 0x9E, 0xB0, 0xAC, 0xE9, 0xB2, -+ /* 05C0 */ 0x81, 0x52, 0x73, 0xD9, 0x00, 0x14, 0xFC, 0xFF, -+ /* 05C8 */ 0x2F, 0x1B, 0x80, 0x01, 0x29, 0x13, 0x46, 0x85, -+ /* 05D0 */ 0x9F, 0x30, 0x05, 0xF1, 0x84, 0x1D, 0xEC, 0xB2, -+ /* 05D8 */ 0x01, 0x8A, 0x18, 0x97, 0x0D, 0xD0, 0x8F, 0xED, -+ /* 05E0 */ 0x65, 0x03, 0x18, 0xDC, 0x13, 0xF8, 0x6D, 0x03, -+ /* 05E8 */ 0x78, 0x43, 0xFA, 0xB6, 0x01, 0xD6, 0xFF, 0xFF, -+ /* 05F0 */ 0x6D, 0x03, 0xAC, 0xF9, 0x6F, 0x1B, 0x28, 0x0E, -+ /* 05F8 */ 0xAB, 0xBC, 0x6D, 0x40, 0x3C, 0xC9, 0x33, 0x02, -+ /* 0600 */ 0xAB, 0xBA, 0x6E, 0xA0, 0xF4, 0x5C, 0x37, 0x00, -+ /* 0608 */ 0x12, 0x88, 0x99, 0x30, 0x2A, 0xFE, 0x84, 0x29, -+ /* 0610 */ 0x88, 0x27, 0xEC, 0x68, 0xD7, 0x0D, 0x50, 0x04, -+ /* 0618 */ 0xB9, 0x6E, 0x80, 0x7E, 0x5E, 0x09, 0xFE, 0xFF, -+ /* 0620 */ 0xAF, 0x1B, 0xC0, 0xE0, 0xA2, 0x80, 0xB9, 0x6F, -+ /* 0628 */ 0x00, 0x6F, 0x58, 0x7E, 0xDF, 0x00, 0x7C, 0xDC, -+ /* 0630 */ 0xC4, 0x31, 0xF7, 0x0D, 0xC0, 0xCC, 0xFF, 0xFF, -+ /* 0638 */ 0xBE, 0x01, 0xB0, 0xE7, 0xA2, 0x80, 0xBB, 0x6F, -+ /* 0640 */ 0x00, 0xEF, 0x8B, 0xB4, 0xEF, 0x1B, 0x60, 0xFE, -+ /* 0648 */ 0xFF, 0xDF, 0x37, 0xC0, 0x28, 0x6D, 0xFD, 0x1E, -+ /* 0650 */ 0x1C, 0x3D, 0x21, 0x78, 0x7C, 0xB8, 0xFB, 0xA5, -+ /* 0658 */ 0xC7, 0xE7, 0xBB, 0x39, 0x38, 0x06, 0x79, 0x8C, -+ /* 0660 */ 0x87, 0x76, 0xC0, 0xAF, 0xEF, 0x9E, 0x98, 0xEF, -+ /* 0668 */ 0xE6, 0xC0, 0xFF, 0x4C, 0x70, 0x3C, 0x18, 0x68, -+ /* 0670 */ 0x1C, 0x62, 0xAB, 0x97, 0x06, 0x72, 0x34, 0x38, -+ /* 0678 */ 0x3F, 0xDC, 0x19, 0x81, 0x61, 0x15, 0x7F, 0xF2, -+ /* 0680 */ 0x47, 0x38, 0xC7, 0xD0, 0xD9, 0xE1, 0x20, 0xB1, -+ /* 0688 */ 0x83, 0xE0, 0xC1, 0x56, 0x6D, 0x02, 0x85, 0x86, -+ /* 0690 */ 0x50, 0x14, 0x18, 0x14, 0x8B, 0x0F, 0x18, 0xF8, -+ /* 0698 */ 0x61, 0xB3, 0xB3, 0x00, 0x93, 0x04, 0x87, 0x3A, -+ /* 06A0 */ 0x02, 0xF8, 0x3E, 0xD1, 0xFC, 0x38, 0x74, 0x37, -+ /* 06A8 */ 0x38, 0x54, 0x8F, 0xE5, 0xA1, 0x80, 0x9E, 0x01, -+ /* 06B0 */ 0x71, 0xC7, 0x0C, 0x32, 0x69, 0xCF, 0x28, 0xE2, -+ /* 06B8 */ 0x53, 0xC2, 0x29, 0x85, 0x49, 0xE0, 0xF3, 0x03, -+ /* 06C0 */ 0x43, 0xE3, 0x04, 0xAF, 0x0D, 0xA1, 0xF9, 0xFF, -+ /* 06C8 */ 0xFF, 0xA4, 0xC0, 0x3C, 0xDF, 0x31, 0x04, 0x6C, -+ /* 06D0 */ 0x02, 0xBB, 0xBF, 0x64, 0xC8, 0xDA, 0xC0, 0x75, -+ /* 06D8 */ 0x4B, 0x32, 0x44, 0x6F, 0x38, 0xB2, 0x85, 0xA2, -+ /* 06E0 */ 0xE9, 0x44, 0x79, 0xDF, 0x88, 0x62, 0x67, 0x08, -+ /* 06E8 */ 0xC2, 0x88, 0x12, 0x2C, 0xC8, 0xA3, 0x42, 0xAC, -+ /* 06F0 */ 0x28, 0x2F, 0x05, 0x46, 0x88, 0x18, 0xE2, 0x95, -+ /* 06F8 */ 0x23, 0xD0, 0x09, 0x87, 0x0F, 0xF2, 0xD8, 0x14, -+ /* 0700 */ 0xA7, 0xFD, 0x41, 0x90, 0x58, 0x4F, 0x02, 0x8D, -+ /* 0708 */ 0xC5, 0x91, 0x46, 0x83, 0x3A, 0x07, 0x78, 0xB8, -+ /* 0710 */ 0x3E, 0xC4, 0x78, 0xF8, 0x0F, 0x21, 0x06, 0x39, -+ /* 0718 */ 0xC8, 0x73, 0x7B, 0x54, 0x38, 0x4E, 0x5F, 0x25, -+ /* 0720 */ 0x4C, 0xF0, 0x02, 0xE0, 0x83, 0x0A, 0x1C, 0xD7, -+ /* 0728 */ 0x80, 0x9A, 0xF1, 0x33, 0x06, 0x58, 0x8E, 0xE3, -+ /* 0730 */ 0x3E, 0xA9, 0xC0, 0x1D, 0x8F, 0xEF, 0x07, 0x6C, -+ /* 0738 */ 0xC2, 0x09, 0x2C, 0x7F, 0x10, 0xA8, 0xE3, 0x0C, -+ /* 0740 */ 0x9F, 0xE7, 0x0B, 0x8B, 0x21, 0x1F, 0x13, 0x4C, -+ /* 0748 */ 0x60, 0xB1, 0x27, 0x1B, 0x3A, 0x1E, 0xF0, 0xDF, -+ /* 0750 */ 0x63, 0x1E, 0x2F, 0x7C, 0x32, 0xF1, 0x7C, 0x4D, -+ /* 0758 */ 0x30, 0x22, 0x84, 0x9C, 0x8C, 0x07, 0x7D, 0x87, -+ /* 0760 */ 0xC0, 0x5C, 0x6F, 0xD8, 0xB9, 0x85, 0x8B, 0x3A, -+ /* 0768 */ 0x68, 0xA0, 0x4E, 0x0B, 0x3E, 0x28, 0xB0, 0x9B, -+ /* 0770 */ 0x11, 0xE6, 0xB8, 0xCE, 0xCF, 0x2A, 0x60, 0xF8, -+ /* 0778 */ 0xFF, 0x9F, 0x55, 0x60, 0x8F, 0x10, 0xFE, 0xED, -+ /* 0780 */ 0xC1, 0xF3, 0xF2, 0x95, 0xE1, 0xD5, 0x21, 0x81, -+ /* 0788 */ 0x43, 0x8E, 0x10, 0x3D, 0x2E, 0x8F, 0x10, 0x73, -+ /* 0790 */ 0x3E, 0xC2, 0x0C, 0x11, 0x5C, 0x67, 0x01, 0x70, -+ /* 0798 */ 0x0C, 0x11, 0xF8, 0x1C, 0x70, 0xC0, 0x71, 0x69, -+ /* 07A0 */ 0xE2, 0x03, 0xF5, 0x01, 0x07, 0x70, 0x70, 0x4D, -+ /* 07A8 */ 0xC3, 0x1D, 0x70, 0xC0, 0x71, 0x16, 0x60, 0xFF, -+ /* 07B0 */ 0xFF, 0xC3, 0x0D, 0x2C, 0x49, 0x26, 0x0E, 0x23, -+ /* 07B8 */ 0x18, 0x11, 0x30, 0x28, 0x02, 0x02, 0xA4, 0xB3, -+ /* 07C0 */ 0x80, 0x0F, 0x29, 0x00, 0x1F, 0xAE, 0x0C, 0x0F, -+ /* 07C8 */ 0x29, 0xD8, 0x93, 0x86, 0x07, 0x8E, 0x1B, 0x85, -+ /* 07D0 */ 0x07, 0x8D, 0x0B, 0x30, 0x68, 0x7A, 0xE2, 0x80, -+ /* 07D8 */ 0x7F, 0x4C, 0xF0, 0x19, 0x05, 0x1C, 0xE3, 0x06, -+ /* 07E0 */ 0xDF, 0x2A, 0x0C, 0xFC, 0xFF, 0x3F, 0x30, 0xCC, -+ /* 07E8 */ 0xE1, 0xC2, 0x63, 0x39, 0x8A, 0xA0, 0x07, 0x1E, -+ /* 07F0 */ 0xD4, 0xF7, 0x8C, 0x33, 0xF7, 0x24, 0x8F, 0xD1, -+ /* 07F8 */ 0x51, 0x0F, 0x27, 0xF4, 0xE4, 0x85, 0x3B, 0x57, -+ /* 0800 */ 0xF9, 0x0A, 0x71, 0x14, 0x18, 0xB8, 0x77, 0x29, -+ /* 0808 */ 0x8F, 0xCF, 0x17, 0x2B, 0xC3, 0x63, 0x46, 0xFB, -+ /* 0810 */ 0x1E, 0x72, 0xD6, 0x11, 0x02, 0xE2, 0x2F, 0x75, -+ /* 0818 */ 0x6C, 0xC0, 0x60, 0x39, 0x18, 0x00, 0x87, 0x01, -+ /* 0820 */ 0xE3, 0x13, 0x0D, 0x58, 0x67, 0x1B, 0x3C, 0xF4, -+ /* 0828 */ 0x69, 0x31, 0xC4, 0xE3, 0x0B, 0xFB, 0x56, 0x61, -+ /* 0830 */ 0x82, 0xEA, 0x41, 0x75, 0x12, 0xF4, 0xD0, 0xC0, -+ /* 0838 */ 0x01, 0xE8, 0xA1, 0xC1, 0x3F, 0xB9, 0x90, 0xFB, -+ /* 0840 */ 0x2B, 0x1D, 0x82, 0xB5, 0xE2, 0x69, 0xDE, 0x47, -+ /* 0848 */ 0x1E, 0xF3, 0xDC, 0xA2, 0xBC, 0x0D, 0x3C, 0x07, -+ /* 0850 */ 0xF0, 0xD3, 0x82, 0x87, 0xE3, 0x63, 0x81, 0xC7, -+ /* 0858 */ 0xE9, 0x4B, 0x58, 0x82, 0xF7, 0x1A, 0x9F, 0x6C, -+ /* 0860 */ 0x1E, 0x5C, 0x58, 0xB2, 0x21, 0xA0, 0x06, 0xEB, -+ /* 0868 */ 0x21, 0x60, 0xA6, 0x9A, 0xC0, 0x49, 0x46, 0x80, -+ /* 0870 */ 0xCA, 0x00, 0xA1, 0x1B, 0xCB, 0xE9, 0x3E, 0x8B, -+ /* 0878 */ 0x84, 0x38, 0xCD, 0x47, 0x99, 0xC7, 0x02, 0x8F, -+ /* 0880 */ 0xF5, 0xC1, 0xC0, 0xFF, 0x7F, 0xCD, 0x23, 0xD4, -+ /* 0888 */ 0x7D, 0xCD, 0x33, 0x7B, 0x3A, 0xC0, 0xAC, 0x22, -+ /* 0890 */ 0xDC, 0x7B, 0xCE, 0x1B, 0x86, 0xD1, 0x9E, 0x2D, -+ /* 0898 */ 0x7C, 0xCD, 0x78, 0xD6, 0x34, 0x42, 0x38, 0x76, -+ /* 08A0 */ 0x83, 0xF3, 0x48, 0x8C, 0xF0, 0x82, 0xC0, 0x4E, -+ /* 08A8 */ 0x0C, 0x0F, 0x30, 0xC6, 0x39, 0x79, 0xC3, 0xFA, -+ /* 08B0 */ 0xC2, 0xCB, 0x40, 0x83, 0x19, 0xDB, 0x97, 0x01, -+ /* 08B8 */ 0x36, 0x2A, 0xDF, 0x88, 0xC0, 0x97, 0xFC, 0x62, -+ /* 08C0 */ 0x00, 0x65, 0x16, 0xBE, 0x9E, 0xF8, 0xA0, 0xC4, -+ /* 08C8 */ 0x2E, 0x06, 0x2C, 0xE5, 0xC5, 0x00, 0x54, 0x37, -+ /* 08D0 */ 0x0C, 0x5F, 0x0C, 0xE0, 0x5F, 0x89, 0x5E, 0x0C, -+ /* 08D8 */ 0xC0, 0x70, 0x71, 0xF2, 0x3D, 0xC0, 0x1E, 0xEE, -+ /* 08E0 */ 0xA3, 0x74, 0x9C, 0xBE, 0xFD, 0xBD, 0x19, 0xF8, -+ /* 08E8 */ 0x6C, 0xC0, 0x60, 0x3C, 0xC3, 0x30, 0xC6, 0x08, -+ /* 08F0 */ 0xE3, 0x51, 0x86, 0x31, 0xC1, 0xDC, 0xB7, 0x03, -+ /* 08F8 */ 0xE8, 0x39, 0x87, 0x81, 0x4A, 0x78, 0x3B, 0x80, -+ /* 0900 */ 0x72, 0x0E, 0xE8, 0xF2, 0x68, 0x42, 0x4F, 0x01, -+ /* 0908 */ 0x4F, 0x07, 0x3E, 0x29, 0x1A, 0xA2, 0xAF, 0xB1, -+ /* 0910 */ 0x0A, 0x26, 0x50, 0xC4, 0x07, 0x0D, 0x3E, 0xB5, -+ /* 0918 */ 0x28, 0x3E, 0x15, 0x78, 0x2D, 0xCF, 0x4E, 0xE1, -+ /* 0920 */ 0xE2, 0x9C, 0x89, 0xA7, 0x6A, 0x38, 0x03, 0xBD, -+ /* 0928 */ 0xE6, 0x86, 0x63, 0xFF, 0x7F, 0x38, 0xFC, 0xA9, -+ /* 0930 */ 0xE0, 0x35, 0x80, 0x1D, 0x24, 0x3D, 0x2D, 0x23, -+ /* 0938 */ 0xC2, 0x38, 0xA4, 0x3C, 0x32, 0xF8, 0xB6, 0x18, -+ /* 0940 */ 0xC7, 0x90, 0x0F, 0x91, 0xBE, 0x13, 0x18, 0xF2, -+ /* 0948 */ 0x21, 0xEF, 0x79, 0xC7, 0xC0, 0xAF, 0x08, 0x71, -+ /* 0950 */ 0x9E, 0xB2, 0x7C, 0x67, 0xF0, 0x65, 0x01, 0x7C, -+ /* 0958 */ 0x91, 0x2E, 0x0B, 0x68, 0x68, 0x9F, 0x64, 0x7C, -+ /* 0960 */ 0x41, 0x30, 0xEC, 0x89, 0xB3, 0x00, 0x77, 0x05, -+ /* 0968 */ 0x50, 0x81, 0xFA, 0xAE, 0x00, 0xFF, 0x42, 0xF0, -+ /* 0970 */ 0xAE, 0x00, 0x86, 0x79, 0xF9, 0x56, 0xC0, 0x35, -+ /* 0978 */ 0x1D, 0x4A, 0xD0, 0x67, 0x12, 0x5F, 0x17, 0x70, -+ /* 0980 */ 0x53, 0x64, 0xA9, 0x8E, 0x0A, 0xD0, 0x53, 0x4C, -+ /* 0988 */ 0x02, 0x75, 0x47, 0xF7, 0x51, 0x01, 0xC6, 0x4D, -+ /* 0990 */ 0xD9, 0x07, 0x54, 0x76, 0x5A, 0x60, 0x67, 0x21, -+ /* 0998 */ 0x76, 0x1D, 0xC1, 0x5D, 0x49, 0x18, 0xCA, 0xB3, -+ /* 09A0 */ 0x81, 0x2F, 0x59, 0xFC, 0x70, 0x00, 0x03, 0xDC, -+ /* 09A8 */ 0xB3, 0x38, 0xC4, 0x08, 0xB1, 0xD9, 0x81, 0xEB, -+ /* 09B0 */ 0x75, 0xD2, 0x70, 0x2F, 0x44, 0xEC, 0xFF, 0x7F, -+ /* 09B8 */ 0x32, 0x00, 0xE3, 0x51, 0x1B, 0x1C, 0x27, 0x9D, -+ /* 09C0 */ 0xF0, 0x91, 0x9E, 0x59, 0xF8, 0x49, 0x19, 0x30, -+ /* 09C8 */ 0x71, 0xF2, 0x03, 0xE3, 0xC9, 0x1A, 0xC6, 0x00, -+ /* 09D0 */ 0xB8, 0xBC, 0x57, 0x95, 0x81, 0xFC, 0x43, 0x90, -+ /* 09D8 */ 0x20, 0x18, 0xD4, 0x29, 0x19, 0x38, 0x1C, 0xC5, -+ /* 09E0 */ 0x70, 0xA7, 0x64, 0x78, 0x50, 0xF8, 0xC3, 0x00, -+ /* 09E8 */ 0xE6, 0x46, 0xE8, 0x7B, 0x82, 0xA1, 0xDE, 0x93, -+ /* 09F0 */ 0x0E, 0xE3, 0x91, 0xD0, 0x04, 0x3E, 0x2D, 0xC3, -+ /* 09F8 */ 0xFA, 0xFF, 0x9F, 0x96, 0xF9, 0x39, 0x21, 0xFE, -+ /* 0A00 */ 0x53, 0xCE, 0xFB, 0xC5, 0x83, 0xB2, 0x31, 0xA2, -+ /* 0A08 */ 0xBC, 0x2A, 0xFB, 0x9C, 0x69, 0x14, 0x76, 0x4B, -+ /* 0A10 */ 0x7E, 0x73, 0x78, 0x55, 0xF6, 0x69, 0xF9, 0xDC, -+ /* 0A18 */ 0x22, 0xBD, 0x2F, 0x7B, 0xE4, 0x31, 0xE3, 0xC4, -+ /* 0A20 */ 0x0A, 0x12, 0xE8, 0x7D, 0x23, 0x4A, 0xD8, 0x18, -+ /* 0A28 */ 0xE1, 0x02, 0x3D, 0x2D, 0xB3, 0x63, 0xBB, 0x87, -+ /* 0A30 */ 0xEC, 0xB3, 0x02, 0xEE, 0xEC, 0x00, 0x77, 0x7A, -+ /* 0A38 */ 0xFC, 0xF4, 0x00, 0x38, 0x01, 0x7A, 0x7A, 0x00, -+ /* 0A40 */ 0xDB, 0x79, 0x03, 0xEE, 0x81, 0x00, 0x71, 0xFC, -+ /* 0A48 */ 0x47, 0x05, 0xBF, 0xB2, 0x50, 0x38, 0x7E, 0x6C, -+ /* 0A50 */ 0xE7, 0xC7, 0x12, 0xDC, 0xE1, 0xC0, 0x47, 0x06, -+ /* 0A58 */ 0x1F, 0x20, 0x71, 0x43, 0xF1, 0xA1, 0x02, 0x79, -+ /* 0A60 */ 0x16, 0x00, 0xC5, 0xE8, 0xD9, 0x08, 0xD8, 0x0D, -+ /* 0A68 */ 0xE6, 0xA5, 0x25, 0xCA, 0xFF, 0xFF, 0xBD, 0x81, -+ /* 0A70 */ 0x9D, 0x52, 0x70, 0x07, 0x01, 0xF0, 0x1D, 0x03, -+ /* 0A78 */ 0xC0, 0x3B, 0x18, 0x2E, 0x6B, 0xCC, 0x28, 0x21, -+ /* 0A80 */ 0x30, 0x1A, 0x33, 0xEE, 0x10, 0xC2, 0x4F, 0x04, -+ /* 0A88 */ 0xB8, 0x31, 0x7B, 0xDC, 0x1E, 0x33, 0xEE, 0x38, -+ /* 0A90 */ 0xCB, 0x47, 0xF5, 0x94, 0x11, 0xCA, 0x07, 0x0E, -+ /* 0A98 */ 0x76, 0xCE, 0x78, 0x23, 0xE0, 0x43, 0x07, 0x1E, -+ /* 0AA0 */ 0x07, 0x18, 0xDC, 0x91, 0x02, 0x8C, 0x97, 0x03, -+ /* 0AA8 */ 0x36, 0x76, 0x70, 0x07, 0x21, 0xA7, 0x40, 0x96, -+ /* 0AB0 */ 0x0E, 0xA3, 0xB1, 0xE3, 0x64, 0x03, 0xE9, 0x18, -+ /* 0AB8 */ 0xE3, 0x43, 0xAE, 0xC7, 0x8E, 0x1B, 0xAC, 0xC7, -+ /* 0AC0 */ 0x8E, 0x3B, 0xBE, 0x60, 0xFF, 0xFF, 0xC7, 0x17, -+ /* 0AC8 */ 0x30, 0x8C, 0x81, 0x8B, 0x1F, 0x06, 0xFA, 0xE6, -+ /* 0AD0 */ 0xE7, 0xD1, 0x19, 0xDC, 0xC3, 0xF6, 0x09, 0x26, -+ /* 0AD8 */ 0xC6, 0x1B, 0x4C, 0x88, 0x47, 0x96, 0x97, 0x96, -+ /* 0AE0 */ 0x08, 0x0F, 0x2D, 0xBE, 0xB9, 0xBC, 0xB4, 0xF8, -+ /* 0AE8 */ 0x16, 0x63, 0x94, 0x10, 0x11, 0x0E, 0x26, 0xCE, -+ /* 0AF0 */ 0x13, 0x8C, 0x11, 0x0E, 0x3C, 0x8A, 0x21, 0x22, -+ /* 0AF8 */ 0x9C, 0x40, 0x88, 0x93, 0x3E, 0xD9, 0x20, 0xE1, -+ /* 0B00 */ 0x63, 0x84, 0x8D, 0x16, 0xE5, 0x09, 0x86, 0x8D, -+ /* 0B08 */ 0x85, 0x9F, 0x57, 0x3C, 0x78, 0x7E, 0x5A, 0xF3, -+ /* 0B10 */ 0x5D, 0xD0, 0x93, 0x39, 0xC7, 0x87, 0x2C, 0x4F, -+ /* 0B18 */ 0xED, 0x71, 0xD2, 0x87, 0x59, 0xDC, 0xA0, 0x1E, -+ /* 0B20 */ 0x1C, 0xD9, 0x5D, 0xC7, 0xC7, 0x6B, 0xEC, 0x29, -+ /* 0B28 */ 0xC8, 0x43, 0xE0, 0x27, 0x02, 0x5F, 0x10, 0x3D, -+ /* 0B30 */ 0x59, 0xDF, 0xF5, 0xD8, 0xBD, 0xCC, 0x18, 0xD5, -+ /* 0B38 */ 0x4F, 0x01, 0x75, 0x4C, 0x39, 0x83, 0x57, 0x08, -+ /* 0B40 */ 0x76, 0xCF, 0xF3, 0x21, 0xDB, 0x77, 0x49, 0x36, -+ /* 0B48 */ 0x0A, 0xDC, 0x21, 0xC1, 0x67, 0x24, 0x7E, 0xAA, -+ /* 0B50 */ 0xF0, 0x30, 0x3C, 0x0A, 0x18, 0x33, 0x78, 0x47, -+ /* 0B58 */ 0x38, 0xB4, 0x10, 0x07, 0xFC, 0xBE, 0xCB, 0x86, -+ /* 0B60 */ 0x1A, 0xE3, 0xF4, 0x7C, 0xFE, 0x60, 0x83, 0x80, -+ /* 0B68 */ 0x0F, 0x75, 0xA8, 0x1E, 0xE6, 0x51, 0xBD, 0x14, -+ /* 0B70 */ 0x32, 0x9C, 0xB3, 0x83, 0x3B, 0x08, 0xEC, 0xF1, -+ /* 0B78 */ 0xC3, 0x83, 0xE0, 0x37, 0x4B, 0x3E, 0x08, 0x76, -+ /* 0B80 */ 0xBE, 0x79, 0x83, 0x33, 0xC8, 0xFF, 0xFF, 0x18, -+ /* 0B88 */ 0x60, 0x9F, 0xA9, 0x7C, 0x34, 0x41, 0x1C, 0x01, -+ /* 0B90 */ 0xD1, 0xE7, 0x0F, 0x8F, 0xE1, 0x4D, 0x8E, 0x0F, -+ /* 0B98 */ 0x07, 0x7B, 0xF4, 0xC0, 0x9D, 0x44, 0xE0, 0x1E, -+ /* 0BA0 */ 0xBB, 0x0E, 0xDA, 0xD7, 0x38, 0x5F, 0xB4, 0x60, -+ /* 0BA8 */ 0xDC, 0xF7, 0x9E, 0x45, 0xC0, 0x8F, 0xF1, 0xD8, -+ /* 0BB0 */ 0x02, 0x8E, 0x43, 0x09, 0xB8, 0x83, 0x1D, 0xD7, -+ /* 0BB8 */ 0x38, 0x84, 0xA2, 0xC0, 0xE8, 0x50, 0x82, 0x8B, -+ /* 0BC0 */ 0x01, 0x24, 0x18, 0xC7, 0x38, 0xA3, 0xA1, 0x2F, -+ /* 0BC8 */ 0x91, 0x3E, 0xA4, 0xC1, 0x19, 0x34, 0xEC, 0x79, -+ /* 0BD0 */ 0x3E, 0xA1, 0x70, 0x7B, 0x02, 0x14, 0x9D, 0x50, -+ /* 0BD8 */ 0x40, 0x86, 0xFB, 0x0C, 0x82, 0x3D, 0x21, 0xF0, -+ /* 0BE0 */ 0x33, 0x08, 0xFB, 0xFF, 0x1F, 0x1C, 0x3D, 0xEE, -+ /* 0BE8 */ 0xF7, 0x46, 0x9F, 0x1A, 0xD9, 0xDC, 0x1F, 0x02, -+ /* 0BF0 */ 0x4E, 0xE0, 0xDC, 0xD9, 0xA9, 0x19, 0x77, 0x66, -+ /* 0BF8 */ 0xC0, 0x9E, 0x3F, 0x3C, 0x04, 0x7E, 0x2E, 0xF0, -+ /* 0C00 */ 0xF0, 0x3D, 0x04, 0xFC, 0xE0, 0x1F, 0x98, 0x0D, -+ /* 0C08 */ 0x0E, 0xC6, 0x53, 0x84, 0xAF, 0x1D, 0x1C, 0x9C, -+ /* 0C10 */ 0x9F, 0x06, 0x0C, 0xCE, 0x5F, 0xA1, 0x3E, 0xCF, -+ /* 0C18 */ 0x33, 0x70, 0xEC, 0xA9, 0xD7, 0xF7, 0x0E, 0xCF, -+ /* 0C20 */ 0xD7, 0x87, 0x0A, 0xFC, 0x4D, 0xCF, 0x87, 0x0A, -+ /* 0C28 */ 0x70, 0x1C, 0x1E, 0xF8, 0x61, 0x85, 0x0D, 0xE1, -+ /* 0C30 */ 0x51, 0x00, 0x7F, 0x6A, 0xF1, 0xF1, 0x2F, 0xCE, -+ /* 0C38 */ 0x53, 0x04, 0xBB, 0x8D, 0x60, 0x0F, 0x17, 0x80, -+ /* 0C40 */ 0xA3, 0x68, 0x67, 0x31, 0x54, 0x98, 0xB3, 0x18, -+ /* 0C48 */ 0xF9, 0xFF, 0x9F, 0xA3, 0x50, 0x67, 0x31, 0x7A, -+ /* 0C50 */ 0xB8, 0x00, 0x5C, 0x08, 0x3E, 0x1E, 0x80, 0xE6, -+ /* 0C58 */ 0x20, 0xF0, 0xB8, 0xE0, 0x0B, 0xC1, 0x91, 0x1C, -+ /* 0C60 */ 0xC8, 0xD3, 0x01, 0xE0, 0x53, 0x1E, 0x09, 0x3D, -+ /* 0C68 */ 0x1F, 0x59, 0x10, 0x0C, 0xEA, 0x7C, 0xE0, 0x13, -+ /* 0C70 */ 0x8A, 0x8F, 0x1D, 0xFC, 0x6C, 0xE0, 0x1B, 0xB9, -+ /* 0C78 */ 0x87, 0xCA, 0x4F, 0xCD, 0x3E, 0x69, 0xF3, 0xE0, -+ /* 0C80 */ 0x3F, 0x69, 0xD9, 0x80, 0x51, 0xA0, 0x61, 0xA0, -+ /* 0C88 */ 0x46, 0xE4, 0x23, 0xD2, 0xFF, 0xFF, 0xB9, 0x0D, -+ /* 0C90 */ 0x1B, 0x60, 0x68, 0xF4, 0x1C, 0x0E, 0xE3, 0x80, -+ /* 0C98 */ 0xEB, 0x73, 0x38, 0x76, 0x40, 0x3E, 0x87, 0xC3, -+ /* 0CA0 */ 0x3F, 0x47, 0xC3, 0x1F, 0x1B, 0x3B, 0xDD, 0xF3, -+ /* 0CA8 */ 0x81, 0xC1, 0xBA, 0x7E, 0x63, 0x06, 0x06, 0xB6, -+ /* 0CB0 */ 0x6F, 0x91, 0x07, 0x06, 0x1C, 0x51, 0xCF, 0xC6, -+ /* 0CB8 */ 0x57, 0x08, 0x0F, 0x0C, 0x6C, 0x80, 0x1E, 0x18, -+ /* 0CC0 */ 0xF0, 0x89, 0x05, 0x21, 0x27, 0x03, 0x43, 0x9D, -+ /* 0CC8 */ 0x32, 0x8C, 0x1C, 0xF3, 0x89, 0xC3, 0xC3, 0xF0, -+ /* 0CD0 */ 0xA1, 0x22, 0xEA, 0x33, 0xC0, 0x23, 0x1E, 0x1B, -+ /* 0CD8 */ 0x1B, 0xFB, 0xFF, 0x8F, 0x0D, 0x2C, 0xC7, 0x16, -+ /* 0CE0 */ 0x8F, 0x0D, 0xFC, 0x47, 0x78, 0xFC, 0xD8, 0xE0, -+ /* 0CE8 */ 0x8C, 0xE5, 0xD1, 0xC4, 0x97, 0x99, 0x23, 0x3B, -+ /* 0CF0 */ 0x8D, 0x33, 0x7B, 0x0D, 0xF1, 0xD1, 0xEE, 0xF1, -+ /* 0CF8 */ 0xDB, 0x63, 0x03, 0x97, 0x85, 0xB1, 0x01, 0xA5, -+ /* 0D00 */ 0x90, 0x63, 0x43, 0x1F, 0x52, 0x7C, 0x0A, 0xB0, -+ /* 0D08 */ 0x71, 0x54, 0x32, 0x0F, 0x1F, 0xAF, 0x7C, 0x62, -+ /* 0D10 */ 0x38, 0xBA, 0x20, 0x6F, 0xE8, 0xBE, 0x5C, 0xF8, -+ /* 0D18 */ 0x48, 0x63, 0x30, 0x5F, 0x5A, 0x7C, 0x06, 0xE5, -+ /* 0D20 */ 0x43, 0x04, 0x97, 0x86, 0x21, 0x02, 0xA5, 0x50, -+ /* 0D28 */ 0x43, 0x44, 0x8F, 0xE7, 0xFF, 0xFF, 0x08, 0xE6, -+ /* 0D30 */ 0x21, 0xB2, 0xA1, 0x81, 0xF7, 0x1B, 0xA3, 0xA1, -+ /* 0D38 */ 0x01, 0xA1, 0x70, 0x43, 0x43, 0x1F, 0xD6, 0x7C, -+ /* 0D40 */ 0x08, 0x60, 0x10, 0xBE, 0x0D, 0xB0, 0xAB, 0x80, -+ /* 0D48 */ 0xAF, 0x42, 0x1E, 0xE0, 0x93, 0x28, 0x1B, 0x1E, -+ /* 0D50 */ 0xF8, 0x06, 0xE5, 0xE1, 0x01, 0x9F, 0xF0, 0xC0, -+ /* 0D58 */ 0x5E, 0x85, 0x87, 0x47, 0xCF, 0x4A, 0x1E, 0x1E, -+ /* 0D60 */ 0x3C, 0x90, 0xC7, 0x08, 0x76, 0x0E, 0xF1, 0xE0, -+ /* 0D68 */ 0xC0, 0x61, 0x62, 0x70, 0xA0, 0x38, 0xFA, 0xE3, -+ /* 0D70 */ 0x86, 0xC0, 0x2E, 0xB3, 0x9E, 0x38, 0xBF, 0xB2, -+ /* 0D78 */ 0x78, 0x50, 0xF8, 0xFF, 0xFF, 0x11, 0x00, 0xD6, -+ /* 0D80 */ 0x71, 0x06, 0x7C, 0xC1, 0x0E, 0x07, 0xE8, 0x63, -+ /* 0D88 */ 0x22, 0x1B, 0xC3, 0x43, 0xC4, 0x83, 0xAB, 0x07, -+ /* 0D90 */ 0xE2, 0x6B, 0xC7, 0x6B, 0x31, 0xEE, 0x68, 0x00, -+ /* 0D98 */ 0x2E, 0x15, 0x47, 0x03, 0xA0, 0x74, 0xB0, 0x05, -+ /* 0DA0 */ 0xC7, 0x3D, 0xCD, 0x47, 0x3B, 0xCC, 0x1C, 0x3D, -+ /* 0DA8 */ 0x80, 0xE7, 0x37, 0x8F, 0x96, 0x9F, 0xDF, 0x00, -+ /* 0DB0 */ 0x47, 0x41, 0x0F, 0xB6, 0x74, 0xE0, 0x8E, 0x06, -+ /* 0DB8 */ 0x83, 0x3A, 0xBF, 0x61, 0xFE, 0xFF, 0xE7, 0x37, -+ /* 0DC0 */ 0x30, 0x44, 0x00, 0xD7, 0x99, 0xC6, 0xE7, 0x17, -+ /* 0DC8 */ 0x38, 0x43, 0x3D, 0x68, 0x5F, 0x13, 0x3C, 0x6B, -+ /* 0DD0 */ 0xDF, 0xB8, 0xD8, 0x39, 0x01, 0x5C, 0x03, 0xF2, -+ /* 0DD8 */ 0x49, 0x07, 0x38, 0x02, 0x9F, 0xC4, 0x03, 0xFE, -+ /* 0DE0 */ 0xA1, 0x81, 0x79, 0x58, 0x1E, 0x1A, 0xF0, 0x39, -+ /* 0DE8 */ 0x1A, 0xE0, 0x4E, 0x14, 0xE0, 0xB9, 0x8D, 0xE0, -+ /* 0DF0 */ 0x0E, 0x14, 0xC0, 0xE2, 0xFF, 0x7F, 0xA0, 0x00, -+ /* 0DF8 */ 0x56, 0x47, 0x7C, 0x8F, 0x8B, 0x43, 0xE3, 0x10, -+ /* 0E00 */ 0x1F, 0xD2, 0xCE, 0xD9, 0xE7, 0xAF, 0x33, 0xC5, -+ /* 0E08 */ 0x9D, 0x45, 0xC0, 0x70, 0xA2, 0x47, 0xBC, 0xD3, -+ /* 0E10 */ 0x0C, 0xE4, 0x07, 0x86, 0x84, 0xC0, 0xA0, 0x4E, -+ /* 0E18 */ 0x40, 0x1E, 0x8A, 0x0F, 0x06, 0x1C, 0xD8, 0x47, -+ /* 0E20 */ 0x04, 0x76, 0x2E, 0x60, 0x07, 0x28, 0xC3, 0xF1, -+ /* 0E28 */ 0xB3, 0x80, 0x4F, 0x09, 0x0F, 0x35, 0xC7, 0xF1, -+ /* 0E30 */ 0xB8, 0xE9, 0xBB, 0x99, 0x21, 0xD9, 0xD5, 0xE0, -+ /* 0E38 */ 0xF9, 0x07, 0x7B, 0xDA, 0x85, 0x73, 0xC4, 0x05, -+ /* 0E40 */ 0x17, 0x81, 0xCF, 0x3A, 0x1E, 0x05, 0x3F, 0x3D, -+ /* 0E48 */ 0x78, 0x8E, 0x6F, 0x0C, 0x3E, 0x3D, 0x30, 0xF7, -+ /* 0E50 */ 0x02, 0xCC, 0x1D, 0xBA, 0x85, 0x70, 0x4C, 0xAF, -+ /* 0E58 */ 0x0F, 0x31, 0x8E, 0xFA, 0xB1, 0xA1, 0x2D, 0x01, -+ /* 0E60 */ 0xDA, 0x50, 0x74, 0x07, 0x78, 0x19, 0x88, 0x12, -+ /* 0E68 */ 0xE2, 0x08, 0x22, 0xB5, 0x86, 0xA2, 0x99, 0x47, -+ /* 0E70 */ 0x8A, 0x12, 0x30, 0x9E, 0x61, 0x1A, 0x9B, 0x8C, -+ /* 0E78 */ 0x20, 0x63, 0x84, 0x8E, 0x13, 0x2C, 0x4A, 0xB4, -+ /* 0E80 */ 0x57, 0x80, 0xF6, 0x47, 0xCB, 0x56, 0xAC, 0xB1, -+ /* 0E88 */ 0x38, 0xD2, 0xC9, 0x12, 0x3D, 0x6C, 0x1F, 0xB3, -+ /* 0E90 */ 0xF1, 0xA7, 0x55, 0xCC, 0xFF, 0x9F, 0xE0, 0x55, -+ /* 0E98 */ 0xC5, 0x07, 0x05, 0x1F, 0x00, 0xF0, 0x2E, 0x01, -+ /* 0EA0 */ 0x75, 0x75, 0xF4, 0xB8, 0x7D, 0xDE, 0x00, 0xFF, -+ /* 0EA8 */ 0xF5, 0x02, 0x4B, 0x50, 0xFE, 0x20, 0x50, 0x23, -+ /* 0EB0 */ 0x33, 0xB4, 0xC7, 0xF9, 0x36, 0x63, 0xC8, 0x27, -+ /* 0EB8 */ 0x27, 0x13, 0x58, 0xEC, 0x09, 0x15, 0x68, 0x0C, -+ /* 0EC0 */ 0xFE, 0x69, 0xC3, 0xD7, 0x76, 0xCF, 0xD7, 0xE7, -+ /* 0EC8 */ 0x38, 0x80, 0x0F, 0xFF, 0xFF, 0x73, 0x1C, 0x60, -+ /* 0ED0 */ 0x68, 0x38, 0xB8, 0xA3, 0x0F, 0xDC, 0x2B, 0x09, -+ /* 0ED8 */ 0x3F, 0xFC, 0x00, 0xCE, 0x80, 0x1E, 0x7E, 0xC0, -+ /* 0EE0 */ 0x3E, 0x54, 0xDC, 0x10, 0x78, 0x84, 0x15, 0xD1, -+ /* 0EE8 */ 0xC3, 0x80, 0x45, 0xC3, 0xA0, 0xCE, 0x6B, 0xD8, -+ /* 0EF0 */ 0xFF, 0xFF, 0x79, 0x0D, 0xB6, 0x38, 0x70, 0x1D, -+ /* 0EF8 */ 0x54, 0x7D, 0x36, 0x86, 0x33, 0xA8, 0xD3, 0xEE, -+ /* 0F00 */ 0xFD, 0xAE, 0x40, 0x2E, 0x22, 0x1E, 0xF4, 0xF9, -+ /* 0F08 */ 0x3C, 0x3B, 0xB0, 0x03, 0x1B, 0xF0, 0x1F, 0x1B, -+ /* 0F10 */ 0x9C, 0x1B, 0xC0, 0x53, 0x74, 0x84, 0x63, 0x03, -+ /* 0F18 */ 0xFB, 0x89, 0x0D, 0x38, 0x9D, 0xED, 0xE0, 0x5C, -+ /* 0F20 */ 0xA1, 0xD8, 0x6D, 0x1F, 0x37, 0x34, 0xB0, 0xD9, -+ /* 0F28 */ 0x18, 0x1A, 0xC8, 0xFE, 0xFF, 0x87, 0x4F, 0xE0, -+ /* 0F30 */ 0x75, 0xE8, 0xE2, 0x97, 0x8A, 0xE7, 0x2F, 0x7E, -+ /* 0F38 */ 0xB8, 0x03, 0x9C, 0x4B, 0x3B, 0xD9, 0xA1, 0xC4, -+ /* 0F40 */ 0x1C, 0xEE, 0x00, 0x29, 0xFF, 0xFF, 0xC3, 0x1D, -+ /* 0F48 */ 0xB8, 0xEE, 0x72, 0xEF, 0x0C, 0x2F, 0x0D, 0x9E, -+ /* 0F50 */ 0xD3, 0xBB, 0x9D, 0x31, 0x5E, 0xEA, 0x8C, 0x10, -+ /* 0F58 */ 0x85, 0xDD, 0x06, 0xA2, 0xD9, 0xDB, 0xE1, 0x8E, -+ /* 0F60 */ 0x9C, 0xF0, 0x38, 0x66, 0xA4, 0x27, 0xBD, 0x60, -+ /* 0F68 */ 0x91, 0x22, 0x1E, 0x4E, 0x94, 0x10, 0xC1, 0x5E, -+ /* 0F70 */ 0x27, 0x9E, 0xF2, 0x1E, 0xEE, 0x98, 0x90, 0xC3, -+ /* 0F78 */ 0x1D, 0xD0, 0x71, 0x7D, 0xB8, 0x03, 0x2A, 0x27, -+ /* 0F80 */ 0x2A, 0xFC, 0xE1, 0x0E, 0x30, 0xFB, 0xFF, 0x3F, -+ /* 0F88 */ 0xDC, 0x01, 0x8C, 0x3A, 0xA3, 0xE1, 0x0E, 0x77, -+ /* 0F90 */ 0x60, 0x3B, 0xFD, 0x00, 0xE7, 0xFF, 0xFF, 0xE9, -+ /* 0F98 */ 0x07, 0x78, 0x8F, 0x15, 0xC6, 0x18, 0x78, 0xB4, -+ /* 0FA0 */ 0x25, 0x51, 0x20, 0x87, 0x81, 0x41, 0x11, 0x38, -+ /* 0FA8 */ 0xC8, 0xA1, 0x8E, 0x06, 0x3B, 0xBD, 0x40, 0x99, -+ /* 0FB0 */ 0xCB, 0x81, 0x9E, 0xC2, 0x33, 0x82, 0x0F, 0x60, -+ /* 0FB8 */ 0x60, 0x3F, 0xD5, 0x01, 0x87, 0x53, 0x03, 0x3E, -+ /* 0FC0 */ 0xD0, 0x09, 0x05, 0x3D, 0x0A, 0x9F, 0x4D, 0xC0, -+ /* 0FC8 */ 0x7B, 0xA4, 0x03, 0x36, 0xFF, 0xFF, 0xB3, 0x09, -+ /* 0FD0 */ 0x7B, 0x35, 0xFA, 0x6C, 0x82, 0x63, 0x31, 0xEA, -+ /* 0FD8 */ 0x1B, 0xC4, 0x21, 0xBE, 0x74, 0xF8, 0xDC, 0xF8, -+ /* 0FE0 */ 0x4E, 0xE3, 0x4B, 0x00, 0xE6, 0xFA, 0x61, 0x82, -+ /* 0FE8 */ 0x31, 0x21, 0xF4, 0xC9, 0xF2, 0xA9, 0x0E, 0x38, -+ /* 0FF0 */ 0x1D, 0x4E, 0xE0, 0x8D, 0x1E, 0x77, 0x5A, 0xF0, -+ /* 0FF8 */ 0x70, 0x38, 0xB8, 0x67, 0xF3, 0x2C, 0xF1, 0x44, -+ /* 1000 */ 0xE4, 0x71, 0xF8, 0x74, 0x02, 0xBC, 0x0E, 0x18, -+ /* 1008 */ 0x98, 0x19, 0x84, 0x7F, 0x08, 0x61, 0xA7, 0x4F, -+ /* 1010 */ 0x1F, 0x99, 0x3C, 0xF7, 0x77, 0x23, 0x9F, 0x4E, -+ /* 1018 */ 0x00, 0x5F, 0xFF, 0xFF, 0xA3, 0x1E, 0xB0, 0x90, -+ /* 1020 */ 0xA8, 0xE1, 0x9C, 0x87, 0x11, 0x05, 0x83, 0x3A, -+ /* 1028 */ 0xEA, 0x01, 0xD6, 0x2E, 0x7A, 0x36, 0x86, 0xA0, -+ /* 1030 */ 0x8B, 0xC0, 0x19, 0x84, 0x78, 0xBC, 0x7B, 0xC5, -+ /* 1038 */ 0x8B, 0xE4, 0x3B, 0x40, 0x9C, 0x47, 0x3D, 0x83, -+ /* 1040 */ 0xBD, 0x7D, 0x3C, 0x48, 0x44, 0x89, 0xF3, 0xA8, -+ /* 1048 */ 0xE7, 0xD1, 0x87, 0xF2, 0xE4, 0x43, 0x9D, 0x7E, -+ /* 1050 */ 0xAC, 0xB0, 0x81, 0x9E, 0xF8, 0x5E, 0xF4, 0x42, -+ /* 1058 */ 0x1A, 0xE1, 0x51, 0x8F, 0x09, 0x7A, 0x79, 0xE8, -+ /* 1060 */ 0x70, 0xE5, 0xA3, 0x1E, 0x60, 0xE5, 0xFF, 0x7F, -+ /* 1068 */ 0xD4, 0x03, 0xF8, 0xFF, 0xFF, 0x3F, 0xEA, 0x81, -+ /* 1070 */ 0xF9, 0xF4, 0x04, 0xF8, 0x3F, 0xD6, 0xE0, 0x8E, -+ /* 1078 */ 0x8A, 0x60, 0x3B, 0x3F, 0x01, 0x2E, 0xFE, 0xFF, -+ /* 1080 */ 0xE7, 0x27, 0x30, 0x0D, 0xDD, 0xE7, 0x27, 0x30, -+ /* 1088 */ 0x8F, 0x16, 0xE6, 0x01, 0x01, 0x71, 0x56, 0x44, -+ /* 1090 */ 0x85, 0x7F, 0xC8, 0x18, 0x0E, 0x15, 0x1C, 0x48, -+ /* 1098 */ 0xBF, 0x28, 0x1F, 0x01, 0x81, 0xCB, 0x51, 0x11, -+ /* 10A0 */ 0x38, 0x9C, 0x59, 0xF0, 0x42, 0x4E, 0x1D, 0xE8, -+ /* 10A8 */ 0xF1, 0x18, 0xF4, 0x95, 0xC3, 0x57, 0x02, 0x7E, -+ /* 10B0 */ 0xE4, 0x60, 0xA1, 0x8F, 0x1C, 0xA0, 0x3A, 0x2C, -+ /* 10B8 */ 0x82, 0xEF, 0xC8, 0x01, 0x8E, 0xEB, 0x55, 0x60, -+ /* 10C0 */ 0xFE, 0xFF, 0x07, 0x66, 0xB7, 0x83, 0xD7, 0x4F, -+ /* 10C8 */ 0x4F, 0xE2, 0x31, 0xEA, 0x38, 0x43, 0x14, 0x8E, -+ /* 10D0 */ 0x49, 0x0E, 0x06, 0x91, 0xDE, 0xC1, 0xD8, 0x00, -+ /* 10D8 */ 0x5F, 0x5E, 0x7C, 0xA8, 0xF2, 0x31, 0x10, 0x18, -+ /* 10E0 */ 0x42, 0x9C, 0x0D, 0x3F, 0x5D, 0x18, 0xF3, 0x74, -+ /* 10E8 */ 0xF8, 0x31, 0x10, 0xB0, 0x2E, 0xF5, 0x0C, 0x88, -+ /* 10F0 */ 0x12, 0x77, 0x0C, 0x04, 0x52, 0xFF, 0xFF, 0x63, -+ /* 10F8 */ 0x20, 0x70, 0xBD, 0x04, 0x7A, 0xCC, 0x67, 0xFC, -+ /* 1100 */ 0xE6, 0xF7, 0xE4, 0x17, 0xA5, 0xB6, 0xEB, 0x9F, -+ /* 1108 */ 0xEE, 0x06, 0xC6, 0x7A, 0x08, 0x78, 0x02, 0xF4, -+ /* 1110 */ 0xFD, 0xCF, 0xC7, 0x8A, 0x28, 0x01, 0xA3, 0xC4, -+ /* 1118 */ 0x7A, 0x11, 0x34, 0x66, 0x8C, 0x60, 0xEF, 0x80, -+ /* 1120 */ 0x31, 0x1F, 0x09, 0x3D, 0xC2, 0x68, 0xC1, 0x0D, -+ /* 1128 */ 0xF4, 0x18, 0xC8, 0x84, 0x1D, 0x03, 0x01, 0x12, -+ /* 1130 */ 0xFD, 0xFF, 0x8F, 0x81, 0x00, 0x23, 0x4F, 0x50, -+ /* 1138 */ 0xC0, 0xF6, 0xFF, 0x7F, 0x82, 0x02, 0x0C, 0x1D, -+ /* 1140 */ 0x05, 0xC1, 0x7C, 0x86, 0x02, 0xAC, 0x1D, 0x05, -+ /* 1148 */ 0xC1, 0x3E, 0x5A, 0x98, 0xA3, 0xE0, 0x82, 0x5E, -+ /* 1150 */ 0x1E, 0x06, 0xA2, 0x12, 0x24, 0xFC, 0xFF, 0x8F, -+ /* 1158 */ 0x82, 0xD8, 0xF8, 0x6B, 0x13, 0x8C, 0x43, 0x9D, -+ /* 1160 */ 0x5E, 0xD0, 0x07, 0x05, 0x0F, 0xFB, 0xA9, 0xC0, -+ /* 1168 */ 0x93, 0x38, 0x55, 0x5F, 0x0B, 0x8E, 0xE2, 0x09, -+ /* 1170 */ 0xC0, 0x87, 0x41, 0xE0, 0x3F, 0x34, 0x58, 0x93, -+ /* 1178 */ 0x28, 0x7E, 0x68, 0xA0, 0x3E, 0x7B, 0x80, 0x6F, -+ /* 1180 */ 0x68, 0xE0, 0x88, 0x7A, 0xC6, 0x41, 0x9F, 0x88, -+ /* 1188 */ 0x7C, 0x36, 0x88, 0xF9, 0xE6, 0x11, 0xE1, 0xC9, -+ /* 1190 */ 0xC3, 0xD7, 0x07, 0x76, 0xF2, 0xF4, 0xA9, 0x29, -+ /* 1198 */ 0x50, 0x94, 0xF7, 0x0D, 0x1E, 0xE7, 0x94, 0x03, -+ /* 11A0 */ 0xAA, 0xC3, 0x2F, 0x38, 0x0E, 0xBC, 0x30, 0xFE, -+ /* 11A8 */ 0xFF, 0x07, 0x5E, 0x76, 0x9C, 0xF2, 0xB1, 0x04, -+ /* 11B0 */ 0x7C, 0x67, 0x52, 0x38, 0x37, 0x17, 0xDF, 0xF1, -+ /* 11B8 */ 0xD8, 0x69, 0x00, 0x6C, 0x3A, 0x4E, 0x03, 0x40, -+ /* 11C0 */ 0xE9, 0x58, 0xC5, 0xCF, 0x93, 0x60, 0x82, 0x39, -+ /* 11C8 */ 0x98, 0xF7, 0x6B, 0x7B, 0x3F, 0xDE, 0xD0, 0xD3, -+ /* 11D0 */ 0x24, 0xE0, 0xF8, 0xFF, 0x7F, 0x9A, 0x84, 0x21, -+ /* 11D8 */ 0xE2, 0x28, 0x89, 0x8A, 0xFD, 0x90, 0xF2, 0x69, -+ /* 11E0 */ 0x12, 0x90, 0x77, 0x67, 0x30, 0xC2, 0xF9, 0x87, -+ /* 11E8 */ 0x78, 0x80, 0x08, 0xF1, 0x20, 0x69, 0x90, 0x38, -+ /* 11F0 */ 0x41, 0x5E, 0x06, 0x9E, 0x26, 0x7D, 0x99, 0x8C, -+ /* 11F8 */ 0xF3, 0x40, 0x19, 0xE5, 0x75, 0xD2, 0x08, 0x47, -+ /* 1200 */ 0x1F, 0xCF, 0x40, 0x2F, 0x92, 0x21, 0x5E, 0x25, -+ /* 1208 */ 0x1F, 0x2C, 0xDF, 0x27, 0x8D, 0x16, 0x2B, 0xF8, -+ /* 1210 */ 0x31, 0x3E, 0x4D, 0xB2, 0xC8, 0x2B, 0xD6, 0x69, -+ /* 1218 */ 0x12, 0xB0, 0xF9, 0xFF, 0x3F, 0x4D, 0x02, 0xFC, -+ /* 1220 */ 0xFF, 0xFF, 0x9F, 0x1D, 0xD8, 0xC1, 0x0A, 0x38, -+ /* 1228 */ 0x1E, 0xC3, 0xC0, 0x71, 0xB0, 0x02, 0x2E, 0xE7, -+ /* 1230 */ 0x79, 0xF0, 0x1C, 0x1F, 0x61, 0x1C, 0x99, 0x00, -+ /* 1238 */ 0xD7, 0xFF, 0xFF, 0xB1, 0xC2, 0x18, 0x03, 0x4F, -+ /* 1240 */ 0xF6, 0x34, 0xA0, 0xC7, 0x01, 0x8B, 0x3A, 0x30, -+ /* 1248 */ 0x09, 0x86, 0xB3, 0xF8, 0xB0, 0xE0, 0x23, 0x02, -+ /* 1250 */ 0x3F, 0x2C, 0x78, 0x04, 0x15, 0x8F, 0x93, 0x1E, -+ /* 1258 */ 0x8B, 0x7C, 0x98, 0x64, 0x87, 0x04, 0x1F, 0x42, -+ /* 1260 */ 0x3C, 0x48, 0x9F, 0x50, 0xC1, 0x73, 0xB0, 0x82, -+ /* 1268 */ 0x77, 0x5D, 0x82, 0x73, 0x2A, 0x00, 0xDC, 0x68, -+ /* 1270 */ 0x57, 0x71, 0xBA, 0x60, 0x01, 0x0E, 0x60, 0xB2, -+ /* 1278 */ 0x71, 0x0C, 0xA1, 0x1C, 0x8E, 0xF9, 0xF6, 0xD0, -+ /* 1280 */ 0x34, 0xD9, 0x91, 0x0C, 0x66, 0x2C, 0x48, 0x9D, -+ /* 1288 */ 0x04, 0x3C, 0x00, 0x07, 0x82, 0x91, 0x76, 0x12, -+ /* 1290 */ 0x8D, 0xC6, 0x70, 0x56, 0x0B, 0x23, 0x38, 0x83, -+ /* 1298 */ 0xF8, 0x38, 0xE2, 0x5C, 0x47, 0x2A, 0xF4, 0x6E, -+ /* 12A0 */ 0x74, 0x9C, 0x42, 0x05, 0xB9, 0x97, 0xD0, 0x79, -+ /* 12A8 */ 0xFB, 0x6E, 0xC0, 0xDF, 0x69, 0x1E, 0x8B, 0x81, -+ /* 12B0 */ 0x7D, 0x43, 0xF0, 0xFF, 0xFF, 0x76, 0x02, 0x7F, -+ /* 12B8 */ 0x2E, 0x56, 0x03, 0x8A, 0x1A, 0x80, 0xD1, 0x30, -+ /* 12C0 */ 0xA7, 0x80, 0xA7, 0x12, 0x70, 0x05, 0x9B, 0x1B, -+ /* 12C8 */ 0xFA, 0xC2, 0x62, 0xAD, 0x53, 0xD1, 0xF1, 0xE9, -+ /* 12D0 */ 0x7D, 0xE0, 0xE0, 0x80, 0xC7, 0xEC, 0x3D, 0x38, -+ /* 12D8 */ 0x58, 0x68, 0x1E, 0x1C, 0xD8, 0xB2, 0x0D, 0x0E, -+ /* 12E0 */ 0xAD, 0xE4, 0x2E, 0x42, 0x0E, 0x1F, 0xF8, 0xD9, -+ /* 12E8 */ 0x01, 0x07, 0x40, 0xCF, 0x0E, 0x16, 0x92, 0x67, -+ /* 12F0 */ 0x07, 0x36, 0x7D, 0x67, 0x11, 0x50, 0x00, 0xF9, -+ /* 12F8 */ 0xDE, 0xE1, 0x73, 0xCB, 0xFF, 0xFF, 0xD9, 0x83, -+ /* 1300 */ 0x8D, 0xE1, 0xD1, 0xC5, 0x68, 0x46, 0xE7, 0x9A, -+ /* 1308 */ 0x6E, 0x13, 0x28, 0x15, 0xB7, 0x09, 0x0A, 0xE2, -+ /* 1310 */ 0x1B, 0x80, 0x13, 0xD2, 0xE8, 0x9E, 0x86, 0x9B, -+ /* 1318 */ 0x89, 0xF1, 0x1F, 0x31, 0x7C, 0x44, 0x38, 0xA4, -+ /* 1320 */ 0xB3, 0x35, 0xC1, 0x3C, 0x90, 0x7A, 0x3F, 0xFA, -+ /* 1328 */ 0xB2, 0x87, 0x9F, 0x7D, 0xC8, 0x07, 0x17, 0x4F, -+ /* 1330 */ 0xC3, 0xD7, 0x1B, 0x72, 0xEF, 0xA0, 0xD3, 0xF6, -+ /* 1338 */ 0x99, 0x01, 0x73, 0x42, 0xF6, 0x75, 0x2A, 0x81, -+ /* 1340 */ 0x65, 0x5D, 0x25, 0xA8, 0x87, 0x0B, 0x08, 0xBD, -+ /* 1348 */ 0xD0, 0xF8, 0x5E, 0x98, 0xE0, 0xE1, 0xCC, 0xB7, -+ /* 1350 */ 0xB3, 0xF7, 0x12, 0x76, 0x38, 0x4C, 0xF0, 0x6E, -+ /* 1358 */ 0x98, 0x60, 0xDE, 0x41, 0xA0, 0x46, 0xE5, 0x41, -+ /* 1360 */ 0x60, 0x2E, 0xFF, 0x2C, 0xDF, 0x18, 0x50, 0xC9, -+ /* 1368 */ 0x2E, 0x5A, 0xF4, 0x0C, 0xF3, 0x0E, 0xE3, 0x4B, -+ /* 1370 */ 0x82, 0xAF, 0x1F, 0x3E, 0xB7, 0x78, 0x01, 0xAF, -+ /* 1378 */ 0x5B, 0x30, 0x08, 0x9E, 0x81, 0x5E, 0x5D, 0x7C, -+ /* 1380 */ 0xCB, 0x37, 0xF0, 0xAB, 0xC0, 0x1B, 0x4D, 0x88, -+ /* 1388 */ 0x60, 0x86, 0x3D, 0xFC, 0xB7, 0x7D, 0xA3, 0xFA, -+ /* 1390 */ 0xA6, 0x63, 0xAC, 0xD7, 0x11, 0x8F, 0x94, 0x1F, -+ /* 1398 */ 0x5B, 0x0E, 0x28, 0xD2, 0x5B, 0x9F, 0x27, 0xE0, -+ /* 13A0 */ 0xB3, 0x8C, 0x8F, 0x83, 0x27, 0xE5, 0x7B, 0xA5, -+ /* 13A8 */ 0xD1, 0x5F, 0x21, 0x7C, 0xF8, 0x31, 0xB2, 0xCF, -+ /* 13B0 */ 0x39, 0xEC, 0x60, 0xC8, 0x06, 0xC5, 0x11, 0x1F, -+ /* 13B8 */ 0x18, 0x5E, 0x6A, 0x3C, 0x15, 0x76, 0xEE, 0x82, -+ /* 13C0 */ 0x71, 0x70, 0x60, 0xC7, 0x22, 0xCC, 0x51, 0x0F, -+ /* 13C8 */ 0x5C, 0x27, 0x1B, 0x03, 0xB3, 0xFF, 0xFF, 0xC9, -+ /* 13D0 */ 0x01, 0x9C, 0xF0, 0x98, 0x13, 0xB3, 0xCF, 0x1B, -+ /* 13D8 */ 0xBE, 0x19, 0x78, 0x5C, 0xFC, 0xC8, 0xE1, 0xE3, -+ /* 13E0 */ 0x1D, 0xC3, 0x3E, 0x4D, 0x1F, 0x8D, 0x5E, 0xDE, -+ /* 13E8 */ 0x7C, 0x7A, 0xC1, 0xC0, 0xFA, 0xD2, 0xC0, 0x61, -+ /* 13F0 */ 0x8D, 0x16, 0xF6, 0x31, 0xE0, 0xCC, 0x7D, 0x21, -+ /* 13F8 */ 0xC2, 0x9D, 0x3A, 0xC1, 0x02, 0x88, 0xBF, 0x95, -+ /* 1400 */ 0x3C, 0x72, 0x78, 0x02, 0x06, 0x64, 0xB9, 0xD7, -+ /* 1408 */ 0xA5, 0x03, 0x11, 0x3F, 0xE5, 0x59, 0xDD, 0x81, -+ /* 1410 */ 0x08, 0x81, 0xF1, 0x38, 0xFA, 0xF8, 0xE1, 0xD9, -+ /* 1418 */ 0xF8, 0x28, 0xE0, 0x63, 0x94, 0x67, 0x7E, 0x46, -+ /* 1420 */ 0x91, 0x5E, 0x19, 0xAC, 0xE5, 0x44, 0x84, 0x52, -+ /* 1428 */ 0x01, 0xA3, 0xC0, 0x34, 0xBA, 0x73, 0xF0, 0x88, -+ /* 1430 */ 0x30, 0x82, 0x33, 0x88, 0x47, 0xEB, 0x9B, 0x0B, -+ /* 1438 */ 0x30, 0x3D, 0x13, 0x01, 0x97, 0xEB, 0xA5, 0x71, -+ /* 1440 */ 0xFD, 0xFF, 0xBF, 0x2C, 0x62, 0xA7, 0x6D, 0xDC, -+ /* 1448 */ 0x57, 0x54, 0x9F, 0x8E, 0x3D, 0xF1, 0xD3, 0x86, -+ /* 1450 */ 0x71, 0x32, 0x02, 0x7C, 0xDC, 0x75, 0x00, 0xFE, -+ /* 1458 */ 0xFC, 0xFF, 0xEF, 0x3A, 0x00, 0xB7, 0xEE, 0x0F, -+ /* 1460 */ 0xBE, 0xEB, 0x00, 0xD7, 0x48, 0xAB, 0xA2, 0x22, -+ /* 1468 */ 0x7E, 0x0B, 0x0A, 0x01, 0x83, 0x1A, 0x9D, 0xAF, -+ /* 1470 */ 0x15, 0xF8, 0x63, 0x09, 0x23, 0xF8, 0xFF, 0x07, -+ /* 1478 */ 0xF7, 0x79, 0xC5, 0x70, 0x7C, 0xE0, 0x1E, 0xDF, -+ /* 1480 */ 0xEB, 0xCA, 0x69, 0x3D, 0x1B, 0xF8, 0xC6, 0x62, -+ /* 1488 */ 0x48, 0x76, 0x41, 0xC5, 0xDD, 0x2F, 0x7C, 0xA3, -+ /* 1490 */ 0xF6, 0x54, 0x5F, 0x14, 0xDE, 0x13, 0x7C, 0x47, -+ /* 1498 */ 0x60, 0x50, 0x30, 0xEE, 0xA8, 0x98, 0x03, 0x2A, -+ /* 14A0 */ 0x1C, 0x82, 0x33, 0x3E, 0x0A, 0xCC, 0x20, 0x7D, -+ /* 14A8 */ 0x48, 0x79, 0x3D, 0xF0, 0x60, 0x99, 0xFB, 0xE3, -+ /* 14B0 */ 0x86, 0x2E, 0x11, 0x0F, 0x1B, 0x4F, 0x06, 0xCD, -+ /* 14B8 */ 0xA1, 0xE8, 0x4C, 0x70, 0x0A, 0x6D, 0x0D, 0x4B, -+ /* 14C0 */ 0x38, 0xEF, 0x1B, 0x21, 0xA2, 0x04, 0x7B, 0xE1, -+ /* 14C8 */ 0x78, 0x63, 0x78, 0x9A, 0x8D, 0x12, 0x2F, 0x52, -+ /* 14D0 */ 0xC0, 0x68, 0x51, 0x82, 0xF5, 0x06, 0x21, 0xD0, -+ /* 14D8 */ 0x48, 0x21, 0x02, 0x86, 0x28, 0x0E, 0x4B, 0x70, -+ /* 14E0 */ 0xD1, 0xDB, 0xBF, 0xC6, 0xB3, 0x37, 0x81, 0x8E, -+ /* 14E8 */ 0x32, 0x8E, 0x74, 0xDC, 0x41, 0x0F, 0xDB, 0x37, -+ /* 14F0 */ 0x56, 0x7E, 0xBE, 0xF7, 0xB8, 0x7C, 0x01, 0xC5, -+ /* 14F8 */ 0x10, 0xBC, 0x66, 0xF8, 0x0B, 0xE0, 0x03, 0x00, -+ /* 1500 */ 0xDE, 0x35, 0xA0, 0x66, 0xFE, 0x78, 0x00, 0x96, -+ /* 1508 */ 0xEB, 0x35, 0xF8, 0xE4, 0x0F, 0x02, 0x75, 0x99, -+ /* 1510 */ 0xE1, 0x67, 0x0F, 0xDF, 0x5C, 0x7D, 0x0F, 0x38, -+ /* 1518 */ 0x2C, 0x76, 0xEB, 0xE6, 0xE3, 0x01, 0xFF, 0xFF, -+ /* 1520 */ 0x7F, 0xE8, 0x2F, 0xBD, 0x3E, 0x54, 0x78, 0xBE, -+ /* 1528 */ 0xBE, 0xFA, 0xFA, 0xF6, 0x0D, 0xDE, 0xCB, 0x31, -+ /* 1530 */ 0x60, 0x4F, 0xF0, 0x0D, 0x1C, 0xE4, 0xE3, 0x05, -+ /* 1538 */ 0xC3, 0x38, 0xB8, 0x72, 0x12, 0x7A, 0x2C, 0xB0, -+ /* 1540 */ 0x56, 0x18, 0xD4, 0x2D, 0x1C, 0x5C, 0x9A, 0xC0, -+ /* 1548 */ 0x75, 0x55, 0xF6, 0xA1, 0xC6, 0x87, 0x60, 0xFC, -+ /* 1550 */ 0xF9, 0x02, 0x17, 0x60, 0xC8, 0xF4, 0x54, 0x06, -+ /* 1558 */ 0xE3, 0x9A, 0xE2, 0x53, 0x19, 0xFB, 0xFF, 0x9F, -+ /* 1560 */ 0xCA, 0x7C, 0x77, 0xF0, 0x80, 0x7C, 0xC4, 0x00, -+ /* 1568 */ 0x3E, 0xAB, 0xF0, 0xC0, 0x70, 0xA7, 0x05, 0xDF, -+ /* 1570 */ 0x94, 0x0C, 0x7A, 0x8E, 0x41, 0x7D, 0xE4, 0x39, -+ /* 1578 */ 0x79, 0xDF, 0x13, 0x1E, 0x27, 0x1C, 0xF5, 0x1C, -+ /* 1580 */ 0x44, 0xC7, 0x06, 0x8E, 0xE3, 0x06, 0x38, 0x0E, -+ /* 1588 */ 0x37, 0xB8, 0x73, 0x1E, 0x1B, 0x17, 0x06, 0xEE, -+ /* 1590 */ 0xB9, 0xC0, 0xC3, 0xF0, 0x4D, 0xC7, 0x23, 0xC2, -+ /* 1598 */ 0x8C, 0xFF, 0x51, 0xCF, 0x08, 0x01, 0xF1, 0x17, -+ /* 15A0 */ 0x23, 0x36, 0x60, 0x30, 0xDE, 0xDA, 0x7C, 0x7D, -+ /* 15A8 */ 0xC3, 0x0D, 0xD8, 0x57, 0x07, 0x5F, 0x30, 0x7C, -+ /* 15B0 */ 0x02, 0x33, 0xFA, 0x0B, 0xCC, 0x93, 0x98, 0x8F, -+ /* 15B8 */ 0x0D, 0xE4, 0x02, 0x47, 0x07, 0x0C, 0x0E, 0x40, -+ /* 15C0 */ 0x0F, 0x18, 0xFE, 0xE1, 0xE2, 0x5D, 0x0E, 0x0C, -+ /* 15C8 */ 0x57, 0x41, 0xFF, 0xFF, 0x8F, 0x0B, 0x3E, 0xF6, -+ /* 15D0 */ 0x58, 0xD1, 0x5D, 0x0E, 0x7D, 0x93, 0x33, 0x4C, -+ /* 15D8 */ 0x1C, 0x43, 0xBC, 0x81, 0xB1, 0xBB, 0x04, 0x39, -+ /* 15E0 */ 0xCC, 0x41, 0xBD, 0x4B, 0x78, 0x0E, 0xFC, 0x6C, -+ /* 15E8 */ 0xE1, 0x13, 0x9C, 0x6F, 0x3E, 0x21, 0x4E, 0xF5, -+ /* 15F0 */ 0xD1, 0xEA, 0x3D, 0xC0, 0x47, 0x8F, 0xF7, 0x2E, -+ /* 15F8 */ 0x9F, 0x9D, 0xD8, 0x45, 0xC0, 0x47, 0x2E, 0xE3, -+ /* 1600 */ 0x78, 0x9A, 0xBE, 0x02, 0x7A, 0xC8, 0x06, 0x7B, -+ /* 1608 */ 0xD5, 0xF0, 0x09, 0xCC, 0x47, 0x37, 0xDC, 0x31, -+ /* 1610 */ 0xCA, 0x33, 0xF1, 0xF4, 0x7D, 0x07, 0x61, 0x47, -+ /* 1618 */ 0x92, 0xA3, 0x0E, 0x75, 0x4D, 0x8F, 0x28, 0x27, -+ /* 1620 */ 0x74, 0x20, 0xBE, 0xB5, 0x81, 0x33, 0xDA, 0xFD, -+ /* 1628 */ 0x03, 0xBD, 0x4D, 0x8F, 0x0C, 0x73, 0x34, 0x80, -+ /* 1630 */ 0x75, 0x09, 0x01, 0xD7, 0x1D, 0xC3, 0x97, 0x10, -+ /* 1638 */ 0xE0, 0x13, 0xF4, 0x12, 0x81, 0xBE, 0x66, 0x78, -+ /* 1640 */ 0x74, 0x8F, 0x00, 0x98, 0x2B, 0x06, 0x3B, 0x16, -+ /* 1648 */ 0xF8, 0xB0, 0xE1, 0x6B, 0x00, 0xBB, 0x17, 0x38, -+ /* 1650 */ 0xCC, 0x3D, 0x02, 0xE2, 0xFF, 0x7F, 0x78, 0x30, -+ /* 1658 */ 0x40, 0x3D, 0x3C, 0xF8, 0x6A, 0xEF, 0x11, 0xA0, -+ /* 1660 */ 0x38, 0x59, 0xFA, 0xD0, 0xE0, 0x81, 0x5A, 0xD5, -+ /* 1668 */ 0x19, 0x13, 0xCA, 0x11, 0x93, 0x43, 0x45, 0x63, -+ /* 1670 */ 0xB7, 0x02, 0x76, 0xBB, 0xF4, 0x4D, 0x02, 0x6E, -+ /* 1678 */ 0x9E, 0x59, 0xA0, 0x92, 0xDC, 0x24, 0xA0, 0xC3, -+ /* 1680 */ 0x74, 0x79, 0x99, 0xA1, 0xF3, 0x3F, 0x70, 0xDF, -+ /* 1688 */ 0xEA, 0x3C, 0x42, 0x1F, 0x22, 0x18, 0xCA, 0x7B, -+ /* 1690 */ 0x9E, 0x4F, 0x61, 0xFC, 0x0C, 0xE1, 0x03, 0x26, -+ /* 1698 */ 0x3B, 0x53, 0xF0, 0xB3, 0x26, 0xEE, 0x0E, 0x60, -+ /* 16A0 */ 0x94, 0x37, 0x4F, 0x4F, 0x80, 0x9D, 0x3F, 0x8D, -+ /* 16A8 */ 0xFC, 0x6E, 0xF0, 0x2E, 0xE0, 0xE9, 0xFB, 0x5E, -+ /* 16B0 */ 0xC4, 0x4F, 0x14, 0xE0, 0x0B, 0x76, 0xA7, 0x83, -+ /* 16B8 */ 0x02, 0x7D, 0x42, 0x1E, 0x91, 0x51, 0x7D, 0x44, -+ /* 16C0 */ 0xE0, 0x97, 0x24, 0x30, 0x1E, 0x49, 0x7C, 0xA0, -+ /* 16C8 */ 0x00, 0xC3, 0xFF, 0xFF, 0x40, 0x01, 0xBA, 0x7B, -+ /* 16D0 */ 0x01, 0xEA, 0xF4, 0xC1, 0x0F, 0xCF, 0xBE, 0xA0, -+ /* 16D8 */ 0x1A, 0xF3, 0xDD, 0xEA, 0x11, 0xCE, 0x93, 0xC3, -+ /* 16E0 */ 0x5C, 0x0E, 0x58, 0x9C, 0x6B, 0x12, 0xA8, 0x8E, -+ /* 16E8 */ 0xBB, 0x7C, 0x74, 0x70, 0xAF, 0xAD, 0xF8, 0xC1, -+ /* 16F0 */ 0xBD, 0xB3, 0xBC, 0xF3, 0x19, 0xCA, 0x83, 0x04, -+ /* 16F8 */ 0xDF, 0xB5, 0x15, 0x1C, 0x57, 0x35, 0x18, 0xC7, -+ /* 1700 */ 0x16, 0x7E, 0xC9, 0x03, 0xEC, 0x0C, 0x8B, 0x0B, -+ /* 1708 */ 0xFE, 0x7B, 0x18, 0x88, 0x4A, 0x84, 0x41, 0x11, -+ /* 1710 */ 0x58, 0x9E, 0x81, 0xFF, 0xFF, 0xB9, 0x80, 0xC1, -+ /* 1718 */ 0x1F, 0x32, 0x18, 0x6F, 0x0A, 0x7C, 0xD2, 0xD8, -+ /* 1720 */ 0x51, 0x03, 0x76, 0x86, 0x8A, 0xBB, 0x29, 0x82, -+ /* 1728 */ 0x75, 0xAA, 0x98, 0x21, 0xF0, 0x60, 0x0F, 0x00, -+ /* 1730 */ 0x9F, 0xAF, 0x7C, 0x06, 0x50, 0x14, 0x18, 0xD4, -+ /* 1738 */ 0xA1, 0x1D, 0xCE, 0x6D, 0x18, 0x70, 0x30, 0x62, -+ /* 1740 */ 0xDC, 0xC1, 0xE0, 0xFF, 0xFF, 0x52, 0x08, 0x73, -+ /* 1748 */ 0xCA, 0xEF, 0x28, 0xB1, 0x9F, 0xCB, 0xD9, 0x74, -+ /* 1750 */ 0x71, 0x57, 0x73, 0x9F, 0x4E, 0xD8, 0x05, 0x19, -+ /* 1758 */ 0xC6, 0x59, 0xE0, 0x11, 0xE0, 0xD5, 0x9C, 0x5F, -+ /* 1760 */ 0x90, 0x5F, 0x88, 0x5F, 0x08, 0xDE, 0x90, 0x7D, -+ /* 1768 */ 0x53, 0x7A, 0x36, 0x78, 0xD9, 0x89, 0xF1, 0x6E, -+ /* 1770 */ 0xEC, 0x53, 0xB2, 0xCF, 0x3B, 0x2F, 0xC8, 0xC6, -+ /* 1778 */ 0x38, 0x9A, 0x88, 0x51, 0xCE, 0xED, 0x61, 0xE0, -+ /* 1780 */ 0x35, 0xD9, 0x28, 0xEF, 0x27, 0x2F, 0x04, 0x11, -+ /* 1788 */ 0xA3, 0x19, 0x22, 0x68, 0x8C, 0x40, 0xEF, 0xCB, -+ /* 1790 */ 0xC6, 0x7B, 0x41, 0x66, 0x02, 0xDF, 0x0A, 0x3A, -+ /* 1798 */ 0xB8, 0xF8, 0x82, 0x0C, 0xF0, 0xE3, 0x64, 0x04, -+ /* 17A0 */ 0xB6, 0xFF, 0xFF, 0xC9, 0x08, 0x30, 0x74, 0xE2, -+ /* 17A8 */ 0xC0, 0x5D, 0xAA, 0xC1, 0x77, 0xB2, 0x01, 0x9C, -+ /* 17B0 */ 0x0D, 0xDD, 0x27, 0x1B, 0x70, 0x8F, 0x16, 0xDE, -+ /* 17B8 */ 0xD1, 0x04, 0x71, 0xB2, 0xA1, 0x40, 0x0E, 0xEE, -+ /* 17C0 */ 0xE0, 0xFF, 0x7F, 0x68, 0xC2, 0x86, 0x3E, 0x89, -+ /* 17C8 */ 0xD0, 0xA3, 0x93, 0x8F, 0x92, 0xB8, 0x33, 0x83, -+ /* 17D0 */ 0x27, 0xF2, 0xCE, 0xE2, 0x51, 0xBC, 0x0C, 0xFA, -+ /* 17D8 */ 0x5E, 0x70, 0x22, 0xAF, 0x0F, 0x96, 0x73, 0x8C, -+ /* 17E0 */ 0x04, 0xD5, 0x48, 0x7C, 0x7C, 0x80, 0x7F, 0x7D, -+ /* 17E8 */ 0xF1, 0x31, 0x12, 0x3E, 0x9F, 0x7F, 0x58, 0x1E, -+ /* 17F0 */ 0x8C, 0x21, 0x7D, 0x8A, 0xE4, 0x20, 0xCF, 0x2E, -+ /* 17F8 */ 0x8F, 0x21, 0xFC, 0x02, 0x09, 0xF7, 0x34, 0x73, -+ /* 1800 */ 0x00, 0x18, 0x59, 0x97, 0x47, 0xF4, 0xD9, 0x91, -+ /* 1808 */ 0x63, 0xC4, 0xF5, 0x45, 0xD1, 0x57, 0x60, 0x1F, -+ /* 1810 */ 0x04, 0xCE, 0xE7, 0x39, 0x11, 0xAC, 0xA3, 0xE6, -+ /* 1818 */ 0x47, 0x1B, 0x3E, 0x7E, 0x0E, 0xFE, 0x56, 0xF0, -+ /* 1820 */ 0x40, 0xE9, 0x63, 0x51, 0x88, 0x47, 0x24, 0x7E, -+ /* 1828 */ 0x4E, 0x04, 0x97, 0x89, 0x73, 0x22, 0x90, 0x18, -+ /* 1830 */ 0x9C, 0xFF, 0xFF, 0x87, 0x5E, 0xEC, 0x69, 0x01, -+ /* 1838 */ 0x37, 0x10, 0x9F, 0x29, 0xB1, 0x53, 0x3E, 0x11, -+ /* 1840 */ 0x76, 0x2E, 0xC1, 0x8C, 0x0E, 0x5C, 0x97, 0x7B, -+ /* 1848 */ 0x8F, 0x0E, 0xFC, 0x27, 0x01, 0x3C, 0xD6, 0xE3, -+ /* 1850 */ 0x1D, 0xF8, 0x4E, 0xEA, 0xBE, 0x9B, 0xF8, 0x22, -+ /* 1858 */ 0xE3, 0x43, 0xD1, 0xF3, 0x1D, 0xE0, 0x3F, 0x9C, -+ /* 1860 */ 0x84, 0xFF, 0xFF, 0xE1, 0x0E, 0x13, 0xE7, 0x7C, -+ /* 1868 */ 0x07, 0x50, 0xE3, 0x6C, 0xFD, 0x7C, 0x07, 0x76, -+ /* 1870 */ 0x91, 0xE7, 0x3B, 0x40, 0xCC, 0xFF, 0xFF, 0x7C, -+ /* 1878 */ 0x07, 0xB0, 0xEB, 0x8C, 0x86, 0x3B, 0xDF, 0x81, -+ /* 1880 */ 0xED, 0x68, 0x03, 0x3C, 0xFF, 0xFF, 0x47, 0x1B, -+ /* 1888 */ 0x60, 0x34, 0x8D, 0x47, 0x1B, 0x70, 0x0F, 0x17, -+ /* 1890 */ 0xF6, 0x30, 0xB8, 0x42, 0x9B, 0x3E, 0x35, 0x1A, -+ /* 1898 */ 0xB5, 0x6A, 0x50, 0xA6, 0x46, 0x99, 0x06, 0xB5, -+ /* 18A0 */ 0xFA, 0x54, 0x6A, 0xCC, 0x98, 0x84, 0xD3, 0x8D, -+ /* 18A8 */ 0x02, 0x3E, 0x2A, 0x34, 0x36, 0xCB, 0xA3, 0x10, -+ /* 18B0 */ 0x88, 0xC5, 0xBC, 0x1A, 0x04, 0xE2, 0xB0, 0x20, -+ /* 18B8 */ 0x34, 0xD2, 0x2B, 0x47, 0x20, 0x96, 0xFC, 0xEC, -+ /* 18C0 */ 0x17, 0x88, 0xE5, 0xBE, 0x19, 0x04, 0xE2, 0x80, -+ /* 18C8 */ 0x6F, 0x30, 0x81, 0x93, 0x87, 0x95, 0xC0, 0xC9, -+ /* 18D0 */ 0xBB, 0x41, 0x20, 0x8E, 0x0C, 0x42, 0x85, 0xEA, -+ /* 18D8 */ 0x00, 0x61, 0x31, 0x41, 0x68, 0x28, 0x1F, 0x20, -+ /* 18E0 */ 0x4C, 0xFA, 0x23, 0x41, 0x80, 0xC4, 0x08, 0x08, -+ /* 18E8 */ 0x0B, 0xF7, 0xFE, 0x12, 0x88, 0xA5, 0xBD, 0x27, -+ /* 18F0 */ 0x04, 0x62, 0x21, 0x56, 0x40, 0x58, 0x5C, 0x10, -+ /* 18F8 */ 0x1A, 0x4E, 0x0B, 0x08, 0x93, 0x64, 0x06, 0x84, -+ /* 1900 */ 0x05, 0x02, 0xA1, 0xF2, 0xD5, 0x80, 0x30, 0x91, -+ /* 1908 */ 0x6E, 0x00, 0xE9, 0xEA, 0x05, 0xE2, 0x20, 0x7A, -+ /* 1910 */ 0x40, 0x98, 0x0C, 0x3F, 0x20, 0x2C, 0x34, 0x08, -+ /* 1918 */ 0x8D, 0xF6, 0xC0, 0x10, 0x20, 0x31, 0x04, 0xC2, -+ /* 1920 */ 0xE2, 0x3B, 0x02, 0x61, 0xE2, 0x5F, 0x45, 0x02, -+ /* 1928 */ 0x71, 0x7E, 0x4B, 0x10, 0x37, 0xA5, 0x21, 0xD6, -+ /* 1930 */ 0x04, 0xC4, 0x34, 0x78, 0x02, 0x62, 0x8A, 0x40, -+ /* 1938 */ 0x04, 0xE4, 0xD8, 0x4F, 0x0F, 0x01, 0x59, 0x83, -+ /* 1940 */ 0x29, 0x20, 0xFF, 0xFF, 0x09, 0x46, 0x07, 0x11, -+ /* 1948 */ 0x90, 0x85, 0xA8, 0x02, 0x62, 0x79, 0x5D, 0x01, -+ /* 1950 */ 0xB1, 0xF0, 0x20, 0x02, 0x72, 0xE6, 0x97, 0x9F, -+ /* 1958 */ 0x80, 0xAC, 0xE0, 0xA5, 0xF3, 0x10, 0xC0, 0xDE, -+ /* 1960 */ 0x10, 0x81, 0x48, 0x72, 0x10, 0x01, 0x39, 0xB0, -+ /* 1968 */ 0x2F, 0x20, 0x16, 0x1F, 0x44, 0x40, 0xCE, 0xFA, -+ /* 1970 */ 0x28, 0x14, 0x90, 0x83, 0x83, 0x68, 0x10, 0xE4, -+ /* 1978 */ 0x6B, 0x26, 0x20, 0xA7, 0x07, 0x11, 0x10, 0xF9, -+ /* 1980 */ 0x04, 0x05, 0x21, 0x6A, 0xBD, 0x81, 0x30, 0x3D, -+ /* 1988 */ 0x8F, 0x42, 0x0D, 0x85, 0x80, 0x50, 0xE5, 0xEA, -+ /* 1990 */ 0xCE, 0x31, 0x2C, 0x07, 0x08, 0xCD, 0x05, 0x22, -+ /* 1998 */ 0x30, 0xAB, 0x70, 0x07, 0xC4, 0x54, 0x81, 0x08, -+ /* 19A0 */ 0xC8, 0x09, 0x80, 0x68, 0x2A, 0x10, 0x9A, 0x12, -+ /* 19A8 */ 0x8C, 0xEA, 0x92, 0x07, 0xC4, 0x12, 0x80, 0xD0, -+ /* 19B0 */ 0x54, 0x20, 0x34, 0x25, 0x88, 0x00, 0xAD, 0xCA, -+ /* 19B8 */ 0x1E, 0x10, 0x53, 0x0A, 0x42, 0x95, 0x83, 0xD0, -+ /* 19C0 */ 0x74, 0x20, 0x54, 0xB6, 0xBE, 0xC3, 0x02, 0x05, -+ /* 19C8 */ 0x11, 0x90, 0xA3, 0x83, 0x50, 0xE1, 0xFE, 0x40, -+ /* 19D0 */ 0x98, 0xDE, 0x97, 0x86, 0x00, 0x9D, 0x0E, 0x44, -+ /* 19D8 */ 0x40, 0x4E, 0x0C, 0x42, 0x15, 0x7C, 0x32, 0x82, -+ /* 19E0 */ 0x10, 0xB1, 0x20, 0x54, 0xC1, 0x27, 0x23, 0x28, -+ /* 19E8 */ 0xD1, 0xF2, 0xB2, 0x13, 0x90, 0xF5, 0x81, 0x50, -+ /* 19F0 */ 0xBD, 0x20, 0x02, 0x73, 0x36, 0x20, 0x9A, 0x17, -+ /* 19F8 */ 0x84, 0xE6, 0x07, 0xA3, 0x5A, 0x8D, 0x02, 0x31, -+ /* 1A00 */ 0xFD, 0x20, 0x34, 0x0F, 0x88, 0xC0, 0xAC, 0xE0, -+ /* 1A08 */ 0xF9, 0x71, 0xC0, 0x0C, 0x84, 0xAA, 0x04, 0x11, -+ /* 1A10 */ 0x98, 0x73, 0x01, 0xD1, 0xAC, 0x20, 0x34, 0x3B, -+ /* 1A18 */ 0x18, 0xD5, 0xFE, 0x0F, 0xD1, 0x00, 0x08, 0x08, -+ /* 1A20 */ 0xCD, 0x07, 0xA2, 0xC3, 0x00, 0x79, 0x96, 0x09, -+ /* 1A28 */ 0xC8, 0x1A, 0x41, 0xC8, 0xFF, 0x9F, 0xA0, 0x66, -+ /* 1A30 */ 0x10, 0x1D, 0x0F, 0x08, 0x10, 0xCD, 0x0F, 0x42, -+ /* 1A38 */ 0xF5, 0xFC, 0x4D, 0x82, 0x91, 0x0C, 0x20, 0x02, -+ /* 1A40 */ 0xB2, 0x96, 0x27, 0x68, 0x20, 0xA2, 0x1F, 0x44, -+ /* 1A48 */ 0x40, 0xCE, 0x04, 0x42, 0x33, 0x82, 0x51, 0xB5, -+ /* 1A50 */ 0x6F, 0x1D, 0x1D, 0x07, 0x08, 0x08, 0x4D, 0x04, -+ /* 1A58 */ 0xA2, 0xE1, 0x91, 0x77, 0xCF, 0xE1, 0x31, 0x10, -+ /* 1A60 */ 0xAA, 0x12, 0x44, 0x60, 0xD6, 0xF8, 0x74, 0x11, -+ /* 1A68 */ 0x88, 0x13, 0x82, 0x50, 0xF5, 0x76, 0x0F, 0x0C, -+ /* 1A70 */ 0x54, 0xEF, 0x20, 0xA8, 0xE0, 0x41, 0x50, 0x10, -+ /* 1A78 */ 0x9A, 0x08, 0x44, 0x87, 0x0C, 0xF2, 0x3E, 0x13, -+ /* 1A80 */ 0x90, 0x75, 0x81, 0x50, 0x9D, 0x20, 0x1A, 0x32, -+ /* 1A88 */ 0x01, 0xA2, 0x59, 0x41, 0x68, 0x76, 0x30, 0x9A, -+ /* 1A90 */ 0xFD, 0x9B, 0xA4, 0x61, 0x90, 0xEF, 0x95, 0x0E, -+ /* 1A98 */ 0x0C, 0xE4, 0x11, 0x17, 0x84, 0x28, 0xFA, 0x18, -+ /* 1AA0 */ 0x09, 0xC4, 0xB9, 0xDF, 0x40, 0x1A, 0x28, 0x79, -+ /* 1AA8 */ 0xCC, 0x04, 0x21, 0xDA, 0x40, 0x04, 0xE6, 0x1C, -+ /* 1AB0 */ 0x40, 0x34, 0x1B, 0x08, 0xCD, 0x0A, 0x46, 0xB3, -+ /* 1AB8 */ 0xAA, 0x3E, 0x62, 0xD0, 0x9F, 0xCD, 0xA1, 0xB1, -+ /* 1AC0 */ 0xE7, 0x95, 0x40, 0xAC, 0xE4, 0x65, 0xF3, 0x68, -+ /* 1AC8 */ 0xC1, 0x7E, 0xB6, 0x02, 0x21, 0xC6, 0x81, 0xE9, -+ /* 1AD0 */ 0xF7, 0x46, 0xC7, 0x00, 0x02, 0x42, 0xF5, 0xFC, -+ /* 1AD8 */ 0xAE, 0x74, 0x04, 0x20, 0x20, 0x3A, 0x02, 0x10, -+ /* 1AE0 */ 0x10, 0x9A, 0x11, 0x84, 0x66, 0x07, 0xA1, 0xBA, -+ /* 1AE8 */ 0xDE, 0x6B, 0x02, 0xB5, 0x36, 0xEF, 0x20, 0x2C, -+ /* 1AF0 */ 0x19, 0x08, 0x55, 0x2D, 0x1E, 0x84, 0x29, 0x7E, -+ /* 1AF8 */ 0xB0, 0x69, 0x98, 0x44, 0xFD, 0x21, 0x80, 0x3E, -+ /* 1B00 */ 0xCF, 0x04, 0x6E, 0xDD, 0x20, 0x34, 0x07, 0x88, -+ /* 1B08 */ 0x06, 0x4A, 0x80, 0xA8, 0x96, 0x2F, 0x9D, 0x06, -+ /* 1B10 */ 0x4A, 0x40, 0x04, 0xE6, 0x4C, 0x40, 0xE4, 0xFF, -+ /* 1B18 */ 0x4F, 0x30, 0x27, 0x08, 0x55, 0xA1, 0x7F, 0x18, -+ /* 1B20 */ 0x14, 0x44, 0x40, 0x4E, 0x01, 0x42, 0x53, 0x81, -+ /* 1B28 */ 0xD1, 0x54, 0x05, 0x40, 0x98, 0xA6, 0x04, 0x03, -+ /* 1B30 */ 0xA6, 0x20, 0x34, 0x6B, 0x03, 0x40, 0x1A, 0xE1, -+ /* 1B38 */ 0xF8, 0x43, 0x3B, 0x80, 0xB3, 0xF8, 0x20, 0x54, -+ /* 1B40 */ 0x52, 0x88, 0x03, 0x0B, 0xD3, 0x07, 0x22, 0x40, -+ /* 1B48 */ 0x47, 0x01, 0x11, 0x98, 0x63, 0x81, 0xD0, 0xA8, -+ /* 1B50 */ 0x80, 0x34, 0x37, 0x20, 0x55, 0x59, 0x02, 0x8C, -+ /* 1B58 */ 0x29, 0x06, 0xA1, 0x29, 0x40, 0x04, 0xE8, 0x48, -+ /* 1B60 */ 0x20, 0x02, 0xB4, 0xE0, 0x14, 0x60, 0x4C, 0x3E, -+ /* 1B68 */ 0x08, 0x8D, 0x09, 0x42, 0x53, 0xB5, 0x00, 0x65, -+ /* 1B70 */ 0x19, 0x41, 0x34, 0x68, 0x12, 0xE3, 0xA0, 0x42, -+ /* 1B78 */ 0x41, 0x68, 0x1E, 0x10, 0x9A, 0x0F, 0x84, 0x0A, -+ /* 1B80 */ 0xAF, 0x01, 0xC2, 0x42, 0x80, 0xD0, 0x60, 0x20, -+ /* 1B88 */ 0x1A, 0x80, 0x53, 0x82, 0x68, 0x00, 0x16, 0x97, -+ /* 1B90 */ 0x03, 0x8C, 0x09, 0x05, 0xA1, 0xE2, 0x41, 0x04, -+ /* 1B98 */ 0xE8, 0x24, 0x20, 0x02, 0xB4, 0xCE, 0x1E, 0x60, -+ /* 1BA0 */ 0x4C, 0x35, 0x08, 0x4D, 0x07, 0x42, 0xC3, 0x04, -+ /* 1BA8 */ 0x01, 0x65, 0xD1, 0x40, 0x74, 0x68, 0x22, 0x45, -+ /* 1BB0 */ 0xC0, 0x98, 0x60, 0x10, 0x1A, 0x03, 0x84, 0xC6, -+ /* 1BB8 */ 0x02, 0xA1, 0x92, 0x9B, 0x1C, 0x81, 0x28, 0x08, -+ /* 1BC0 */ 0x8D, 0x5C, 0x05, 0x8C, 0xC9, 0xC8, 0x02, 0xC2, -+ /* 1BC8 */ 0x64, 0x81, 0xE8, 0xB0, 0x44, 0x80, 0x68, 0x38, -+ /* 1BD0 */ 0x10, 0x1A, 0x16, 0x90, 0x77, 0x01, 0xA4, 0x20, -+ /* 1BD8 */ 0x02, 0x24, 0x20, 0x34, 0x2C, 0x08, 0x55, 0x15, -+ /* 1BE0 */ 0xE6, 0xC0, 0x43, 0x41, 0x74, 0x88, 0x20, 0x65, -+ /* 1BE8 */ 0x8E, 0x34, 0x14, 0x84, 0xFC, 0xFF, 0x8F, 0x14, -+ /* 1BF0 */ 0x02, 0xD1, 0xD1, 0x81, 0x00, 0x51, 0x2D, 0x69, -+ /* 1BF8 */ 0x8E, 0x0E, 0x14, 0x84, 0x06, 0x01, 0xA1, 0x3A, -+ /* 1C00 */ 0xDB, 0x1C, 0x6F, 0x28, 0x88, 0x8E, 0x37, 0x04, -+ /* 1C08 */ 0x84, 0xE6, 0x07, 0xA3, 0xAA, 0x9F, 0x84, 0x02, -+ /* 1C10 */ 0x72, 0x12, 0x10, 0x9A, 0x13, 0x44, 0x87, 0x07, -+ /* 1C18 */ 0x52, 0x08, 0x84, 0x25, 0x02, 0xA1, 0xCA, 0x13, -+ /* 1C20 */ 0x1D, 0x0C, 0xE8, 0x9B, 0x53, 0x87, 0x0B, 0x02, -+ /* 1C28 */ 0x42, 0x73, 0x80, 0xD0, 0xA4, 0x20, 0x54, 0x55, -+ /* 1C30 */ 0x25, 0x50, 0x96, 0x04, 0x44, 0x07, 0x01, 0x02, -+ /* 1C38 */ 0x42, 0xD3, 0x82, 0x51, 0x8D, 0x99, 0x06, 0x40, -+ /* 1C40 */ 0x41, 0x68, 0x0E, 0x10, 0x81, 0x39, 0x71, 0x29, -+ /* 1C48 */ 0x10, 0xA6, 0x37, 0xD5, 0xA1, 0x89, 0xB6, 0x02, -+ /* 1C50 */ 0x61, 0xFF, 0x7F -+ }) -+ -+ /* Rename the below method to WQAB if we choose not to -+ * go with the above buffer. -+ */ -+ Method (XQAB, 1, Serialized) -+ { -+ INIT (2) -+ GUID (60) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBC, 1, Serialized) -+ { -+ INIT (2) -+ GUID (100) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBD, 1, Serialized) -+ { -+ INIT (2) -+ GUID (120) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBE, 1, Serialized) -+ { -+ INIT (2) -+ GUID (140) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBF, 1, Serialized) -+ { -+ INIT (2) -+ GUID (160) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBG, 1, Serialized) -+ { -+ INIT (2) -+ GUID (180) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBH, 1, Serialized) -+ { -+ INIT (2) -+ GUID (200) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBI, 1, Serialized) -+ { -+ INIT (2) -+ GUID (220) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ } -+ } -+ -+ /* Wire GPE events to notify OEM -+ * special buttons press like wireless or -+ * presentation button. -+ */ -+ Scope (\_GPE) -+ { -+ Method (_L18, 0, Serialized) -+ { -+ Notify (\_SB.WMID, 0x80) -+ } -+ } -+} -+ -diff ---- /dev/null -+++ b/tools/firmware/hvmloader/acpi/ssdt_lenovo_t_and_x_series.asl 2009-04-01 16:35:28.000000000 -0400 -@@ -0,0 +1,616 @@ -+/* -+ * ssdt_lenovo_t_and_x_series.asl -+ * -+ * Copyright (c) 2009 Kamala Narasimhan -+ * Copyright (c) 2009 Citrix Systems, Inc. -+ * -+ * 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 -+ */ -+ -+/* SSDT for exposing Lenovo T and X series specific value add functionalities like -+ * hotkeys, special buttons. -+ */ -+ -+/* IMPLEMENTATION DETAILS: OEM value add features are generally exposed through -+ * WMI psuedo device objects. For our guests to benefit from such value add, we -+ * expose a psuedo device object in our vACPI layer also. This psuedo object is -+ * similar to the underlying base firmware object in the sense we expose the -+ * same _WDG method which describes the WMI methods, data objects and events -+ * provided by the WMI psuedo object. Guest wmi wrapper driver which automatically -+ * gets loaded upon identifying this WMI pseudo device object, calls _WDG to get -+ * known entry points and calls those entry points for further information exchange. -+ * Reference - http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ */ -+ -+/* COMMUNICATION DETAILS - -+ * Command port - 0x96 -+ * Writes to this port describe what type of information is about -+ * to be exchanged. E.g., guid, input argument transfer etc. -+ * Data Port - 0x98 and 0x9A for byte and dword data transfer respectively. -+ * Communicates data to and from the backend. E.g. Input buffer values -+ * get written to this port and output buffer values are read from this -+ * port. -+ */ -+ -+DefinitionBlock ("SSDT_LENOVO_T_AND_X_SERIES.aml", "SSDT", 2, "Xen", "HVM", 0) -+{ -+ Scope (\_SB) -+ { -+ -+ OperationRegion (LEN1, SystemIO, 0x96, 0x01) -+ Field (LEN1, ByteAcc, NoLock, Preserve) -+ { -+ P96, 8 -+ } -+ -+ OperationRegion (LEN2, SystemIO, 0x98, 0x01) -+ Field (LEN2, ByteAcc, NoLock, Preserve) -+ { -+ P98, 8 -+ } -+ -+ OperationRegion (LEN3, SystemIO, 0x9A, 0x04) -+ Field (LEN3, DWordAcc, NoLock, Preserve) -+ { -+ P9A, 32 -+ } -+ -+ Device (WMI1) -+ { -+ /* Exposing a pseudo device with HID PNP0C14 will -+ * result in Windows guest loading their WMI wrapper -+ * driver - wmiacpi.sys -+ */ -+ Name (_HID, EisaId ("PNP0C14")) -+ Name (_UID, 0x01) -+ -+ /* Following list of data blocks exposed by _WDG is same as the -+ * one provided by the underlying firmware. Refer to - -+ * http://www.microsoft.com/whdc/system/pnppwr/wmi/wmi-acpi.mspx -+ * for further information about _WDG and what it exposes. -+ */ -+ Name (_WDG, Buffer (0xA0) -+ { -+ /* Data Block 1 */ -+ /* GUID */ -+ 0x0E, 0x23, 0xF5, 0x51, 0x77, 0x96, 0xCD, 0x46, -+ 0xA1, 0xCF, 0xC0, 0xB2, 0x3E, 0xE3, 0x4D, 0xB7, -+ 0x41, 0x30, /* Object ID - WQA0 */ -+ 0x5A, /* Instance count */ -+ 0x05, /* Flag - String block & Expensive */ -+ -+ /* Data Block 2 */ -+ /* GUID */ -+ 0x64, 0x9A, 0x47, 0x98, 0xF5, 0x33, 0x33, 0x4E, -+ 0xA7, 0x07, 0x8E, 0x25, 0x1E, 0xBB, 0xC3, 0xA1, -+ 0x41, 0x31, /*Object ID - WMA1 */ -+ 0x01, /* Instance count */ -+ 0x06, /* Flag - Method & string block */ -+ -+ /* Data Block 3 */ -+ /* GUID */ -+ 0xEF, 0x54, 0x4B, 0x6A, 0xED, 0xA5, 0x33, 0x4D, -+ 0x94, 0x55, 0xB0, 0xD9, 0xB4, 0x8D, 0xF4, 0xB3, -+ 0x41, 0x32, /* Object ID - WMA2 */ -+ 0x01, /* Instance count */ -+ 0x06, /* Flag - Method & string block */ -+ -+ /* Data Block 4 */ -+ /* GUID */ -+ 0xB6, 0xEB, 0xF1, 0x74, 0x7A, 0x92, 0x7D, 0x4C, -+ 0x95, 0xDF, 0x69, 0x8E, 0x21, 0xE8, 0x0E, 0xB5, -+ 0x41, 0x33, /* Object ID - WMA3 */ -+ 0x01, /* Instance count */ -+ 0x06, /* Flag - Method & string block */ -+ -+ /* Data Block 5 */ -+ /* GUID */ -+ 0xFF, 0x04, 0xEF, 0x7E, 0x28, 0x43, 0x7C, 0x44, -+ 0xB5, 0xBB, 0xD4, 0x49, 0x92, 0x5D, 0x53, 0x8D, -+ 0x41, 0x34, /* Object ID - WMA4 */ -+ 0x01, /* Instance count */ -+ 0x06, /* Flag - Method & string block*/ -+ -+ /* Data Block 6 */ -+ /* GUID */ -+ 0x9E, 0x15, 0xDB, 0x8A, 0x32, 0x1E, 0x5C, 0x45, -+ 0xBC, 0x93, 0x30, 0x8A, 0x7E, 0xD9, 0x82, 0x46, -+ 0x41, 0x35, /* Object ID - WQA5 */ -+ 0x01, /* Instance count */ -+ 0x01, /* Flag - Expensive */ -+ -+ /* Data Block 7 */ -+ /* GUID */ -+ 0xFD, 0xD9, 0x51, 0x26, 0x1C, 0x91, 0x69, 0x4B, -+ 0xB9, 0x4E, 0xD0, 0xDE, 0xD5, 0x96, 0x3B, 0xD7, -+ 0x41, 0x36, /* Object ID - WMA6 */ -+ 0x01, /* Instance count */ -+ 0x06, /* Flag - Method & string block */ -+ -+ /* Data Block 6 */ -+ /* GUID */ -+ 0x21, 0x12, 0x90, 0x05, 0x66, 0xD5, 0xD1, 0x11, -+ 0xB2, 0xF0, 0x00, 0xA0, 0xC9, 0x06, 0x29, 0x10, -+ 0x42, 0x41, /* Object ID - WQBA */ -+ 0x01, /* Instance count */ -+ 0x00, /* Flag - Expensive */ -+ -+ }) -+ -+ /* Initialize cmd port and communicate invocation type -+ * i.e., method execution or query or set object -+ */ -+ Method (INIT, 1, Serialized) -+ { -+ Store (100, P96) -+ Store (Arg0, P98) -+ } -+ -+ /* Pass the guid pertaining to the operation */ -+ Method (GUID, 1, Serialized) -+ { -+ Store (101, P96) -+ Store (0x0, Local0) -+ Store (Arg0, Local1) -+ -+ While ( LLess(Local0,16) ) -+ { -+ Add(Local1, Local0, Local2) -+ Store (DerefOf(Index (_WDG, Local2)), P98 ) -+ Increment( Local0 ) -+ } -+ } -+ -+ /* Pass instance # for the associated object pertaining -+ * to the invocation. -+ */ -+ Method (INST, 1, Serialized) -+ { -+ Store(102, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass method id relevant to the method about to be -+ * executed. -+ */ -+ Method (MTID, 1, Serialized) -+ { -+ Store(103, P96) -+ Store(Arg0, P9A) -+ } -+ -+ /* Pass input buffer pertaining to the current operation */ -+ Method (IBUF, 1, Serialized) -+ { -+ Store (105, P96) -+ Store (SizeOf(Arg0), Local0) -+ Store (Local0, P9A) -+ ToBuffer (Arg0, Local1) -+ Store (0, Local2) -+ Store (104, P96) -+ While ( LLess(Local2,Local0) ) -+ { -+ Store (DerefOf(Index (Local1, Local2)), P98) -+ Increment (Local2) -+ } -+ } -+ -+ /* Now that the input arguments are passed, execute the command */ -+ Method (EXEC, 0, Serialized) -+ { -+ Store (106, P96) -+ } -+ -+ /* Get the output buffer pertaining to the just executed command */ -+ Method (OBUF, 0, Serialized) -+ { -+ Store (108, P96) -+ Store (P9A, Local0) -+ Store (Buffer(Local0) {}, Local2) -+ Store (0, Local1) -+ Store (107, P96) -+ While ( LLess(Local1, Local0) ) -+ { -+ Store (P98, Index(Local2, Local1)) -+ Increment (Local1) -+ } -+ Return (Local2) -+ } -+ -+ /* Get event data */ -+ Method (_WED, 1, Serialized) -+ { -+ INIT (4) -+ Store (109, P96) -+ Store (Arg0, P98) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Following are well know entry points as supplied by -+ * _WDG. -+ * @TODO: Though current testing suggest that defining -+ * a method for seralized execution is enough to prevent -+ * synchronization issues, consider using explicit mutexes -+ * for further protection. -+ */ -+ Method (WQA0, 1, Serialized) -+ { -+ INIT (2) -+ GUID (0) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMA1, 3, Serialized) -+ { -+ INIT (1) -+ GUID (20) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMA2, 3, Serialized) -+ { -+ INIT (1) -+ GUID (40) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMA3, 3, Serialized) -+ { -+ INIT (1) -+ GUID (60) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMA4, 3, Serialized) -+ { -+ INIT (1) -+ GUID (80) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQA5, 1, Serialized) -+ { -+ INIT (2) -+ GUID (100) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WMA6, 3, Serialized) -+ { -+ INIT (1) -+ GUID (120) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Method (WQBC, 1, Serialized) -+ { -+ INIT (2) -+ GUID (60) -+ INST (Arg0) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ /* Like all other well know entry points, we could delegate -+ * the below to the base firmware also. But, why ask for a -+ * static list (that too this big) and go through layer after -+ * layer to get it? Also, port i/o is not a good idea for this -+ * much data transfer. Luckily, this is the only place that appear -+ * to transfer so much data. -+ */ -+ -+ Method (WMBD, 3, Serialized) -+ { -+ INIT (1) -+ GUID (100) -+ INST (Arg0) -+ MTID (Arg1) -+ IBUF (Arg2) -+ EXEC () -+ Return (OBUF()) -+ } -+ -+ Name (WQBA, Buffer (0x07C1) -+ { -+ /* 0000 */ 0x46, 0x4F, 0x4D, 0x42, 0x01, 0x00, 0x00, 0x00, -+ /* 0008 */ 0xB1, 0x07, 0x00, 0x00, 0x5A, 0x30, 0x00, 0x00, -+ /* 0010 */ 0x44, 0x53, 0x00, 0x01, 0x1A, 0x7D, 0xDA, 0x54, -+ /* 0018 */ 0x98, 0x51, 0x97, 0x00, 0x01, 0x06, 0x18, 0x42, -+ /* 0020 */ 0x10, 0x11, 0x10, 0x0A, 0x0D, 0x21, 0x02, 0x0B, -+ /* 0028 */ 0x83, 0x50, 0x4C, 0x18, 0x14, 0xA0, 0x45, 0x41, -+ /* 0030 */ 0xC8, 0x05, 0x14, 0x95, 0x02, 0x21, 0xC3, 0x02, -+ /* 0038 */ 0x14, 0x0B, 0x70, 0x2E, 0x40, 0xBA, 0x00, 0xE5, -+ /* 0040 */ 0x28, 0x72, 0x0C, 0x22, 0x02, 0xF7, 0xEF, 0x0F, -+ /* 0048 */ 0x31, 0x0E, 0x88, 0x14, 0x40, 0x48, 0xE6, 0x28, -+ /* 0050 */ 0x28, 0x81, 0x85, 0xC0, 0x11, 0x82, 0x7E, 0x05, -+ /* 0058 */ 0x20, 0x74, 0x88, 0x26, 0x83, 0x02, 0x9C, 0x22, -+ /* 0060 */ 0x08, 0xD2, 0x96, 0x05, 0xE8, 0x16, 0xE0, 0x5B, -+ /* 0068 */ 0x80, 0x76, 0x08, 0xA1, 0x55, 0x28, 0xC0, 0xA4, -+ /* 0070 */ 0x00, 0x9F, 0x60, 0xB2, 0x28, 0x40, 0x36, 0x98, -+ /* 0078 */ 0x6C, 0xC3, 0x91, 0x61, 0x30, 0x91, 0x63, 0x40, -+ /* 0080 */ 0x89, 0x19, 0x03, 0x4A, 0xE7, 0x14, 0x64, 0x13, -+ /* 0088 */ 0x58, 0xD0, 0x85, 0xA2, 0x68, 0x1A, 0x51, 0x12, -+ /* 0090 */ 0x1C, 0xD4, 0x31, 0x44, 0x08, 0x5E, 0xAE, 0x00, -+ /* 0098 */ 0xC9, 0x13, 0x90, 0xE6, 0x79, 0xC9, 0xFA, 0x20, -+ /* 00A0 */ 0x34, 0x04, 0x36, 0x02, 0x1E, 0x45, 0x02, 0x08, -+ /* 00A8 */ 0x8B, 0xB1, 0x4C, 0x89, 0x87, 0x41, 0x79, 0x00, -+ /* 00B0 */ 0x91, 0x9C, 0xA1, 0xA2, 0x80, 0xED, 0x75, 0x22, -+ /* 00B8 */ 0x1A, 0xD6, 0x71, 0x32, 0x49, 0x70, 0xA8, 0x51, -+ /* 00C0 */ 0x5A, 0xA2, 0x00, 0xF3, 0x23, 0xD3, 0x44, 0x8E, -+ /* 00C8 */ 0xAD, 0xE9, 0x11, 0x0B, 0x92, 0x49, 0x1B, 0x0A, -+ /* 00D0 */ 0x6A, 0xE8, 0x9E, 0xD6, 0x49, 0x79, 0xA2, 0x11, -+ /* 00D8 */ 0x0F, 0xCA, 0x30, 0x09, 0x3C, 0x0A, 0x86, 0xC6, -+ /* 00E0 */ 0x09, 0xCA, 0x82, 0x90, 0x83, 0x81, 0xA2, 0x00, -+ /* 00E8 */ 0x4F, 0xC2, 0x73, 0x2C, 0x5E, 0x80, 0xF0, 0x19, -+ /* 00F0 */ 0x93, 0xA3, 0x40, 0x8C, 0x04, 0x3E, 0x12, 0x78, -+ /* 00F8 */ 0x34, 0xC7, 0x8C, 0x05, 0x0A, 0x17, 0xF0, 0x7C, -+ /* 0100 */ 0x8E, 0x21, 0x72, 0xDC, 0x43, 0x8D, 0x71, 0x14, -+ /* 0108 */ 0x91, 0x13, 0xBC, 0x03, 0x44, 0x31, 0x5A, 0x41, -+ /* 0110 */ 0xF3, 0x16, 0x62, 0xB0, 0x68, 0x06, 0xEB, 0x19, -+ /* 0118 */ 0x9C, 0x0C, 0x3A, 0xC1, 0xFF, 0xFF, 0x08, 0xB8, -+ /* 0120 */ 0x0C, 0x08, 0x79, 0x14, 0x60, 0x75, 0x50, 0x9A, -+ /* 0128 */ 0x86, 0x09, 0xBA, 0x17, 0x60, 0x4D, 0x80, 0x31, -+ /* 0130 */ 0x01, 0x1A, 0x31, 0xA4, 0x4C, 0x80, 0xB3, 0xFB, -+ /* 0138 */ 0x82, 0x66, 0xD4, 0x96, 0x00, 0x73, 0x02, 0xB4, -+ /* 0140 */ 0x09, 0xF0, 0x86, 0x20, 0x94, 0xF3, 0x8C, 0x72, -+ /* 0148 */ 0x2C, 0xA7, 0x18, 0xE5, 0x61, 0x20, 0xE6, 0xCB, -+ /* 0150 */ 0x40, 0xD0, 0x28, 0x31, 0x62, 0x9E, 0x4B, 0x5C, -+ /* 0158 */ 0xC3, 0x46, 0x88, 0x11, 0xF2, 0x14, 0x02, 0xC5, -+ /* 0160 */ 0x6D, 0x7F, 0x10, 0x64, 0xD0, 0xB8, 0xD1, 0xFB, -+ /* 0168 */ 0xB4, 0x70, 0x56, 0x27, 0x70, 0xF4, 0x4F, 0x0A, -+ /* 0170 */ 0x26, 0xF0, 0x94, 0x0F, 0xEC, 0xD9, 0xE0, 0x04, -+ /* 0178 */ 0x8E, 0x35, 0x6A, 0x8C, 0x53, 0x49, 0xE0, 0xD8, -+ /* 0180 */ 0x0F, 0x08, 0x69, 0x00, 0x51, 0x24, 0x78, 0xD4, -+ /* 0188 */ 0x69, 0xC1, 0xE7, 0x02, 0x0F, 0xED, 0xA0, 0x3D, -+ /* 0190 */ 0xC7, 0x13, 0x08, 0x72, 0x08, 0x47, 0xF0, 0xC4, -+ /* 0198 */ 0xF0, 0x40, 0xE0, 0x31, 0xB0, 0x9B, 0x82, 0x8F, -+ /* 01A0 */ 0x00, 0x3E, 0x21, 0xE0, 0x5D, 0x03, 0xEA, 0x6A, -+ /* 01A8 */ 0xF0, 0x60, 0xC0, 0x06, 0x1D, 0x0E, 0x33, 0x5E, -+ /* 01B0 */ 0x0F, 0x3F, 0xDC, 0x09, 0x9C, 0xE4, 0x03, 0x06, -+ /* 01B8 */ 0x3F, 0x6C, 0x78, 0x70, 0xB8, 0x79, 0x9E, 0xCC, -+ /* 01C0 */ 0x91, 0x95, 0x2A, 0xC0, 0xEC, 0xE1, 0x40, 0x07, -+ /* 01C8 */ 0x09, 0x9F, 0x36, 0xD8, 0x19, 0x00, 0x23, 0x7F, -+ /* 01D0 */ 0x10, 0xA8, 0x91, 0x19, 0xDA, 0xE3, 0x7E, 0xE9, -+ /* 01D8 */ 0x30, 0xE4, 0x73, 0xC2, 0x61, 0x31, 0xB1, 0xA7, -+ /* 01E0 */ 0x0E, 0x3A, 0x1E, 0xF0, 0x5F, 0x46, 0x9E, 0x33, -+ /* 01E8 */ 0x3C, 0x7D, 0xCF, 0xD7, 0x04, 0xC3, 0x0E, 0x1C, -+ /* 01F0 */ 0x3D, 0x10, 0x43, 0x3F, 0x6C, 0x1C, 0xC6, 0x69, -+ /* 01F8 */ 0xF8, 0xFE, 0xE1, 0xF3, 0x02, 0x8C, 0x53, 0x80, -+ /* 0200 */ 0x47, 0xEE, 0xFF, 0xFF, 0x21, 0xC5, 0xA7, 0x09, -+ /* 0208 */ 0x7E, 0xB4, 0xF0, 0x69, 0x82, 0x5D, 0x0F, 0x4E, -+ /* 0210 */ 0xE3, 0x39, 0xC0, 0xC3, 0x39, 0x2B, 0x1F, 0x26, -+ /* 0218 */ 0xC0, 0x76, 0x3F, 0x61, 0x23, 0x7A, 0xB7, 0xF0, -+ /* 0220 */ 0x68, 0xB0, 0xA7, 0x00, 0xF0, 0x9D, 0x5F, 0xC0, -+ /* 0228 */ 0x79, 0xD7, 0x60, 0x83, 0x85, 0x71, 0x7E, 0x01, -+ /* 0230 */ 0x1E, 0x27, 0x04, 0x0F, 0x81, 0x1F, 0x24, 0x3C, -+ /* 0238 */ 0x04, 0x3E, 0x80, 0xE7, 0x8F, 0x33, 0xB4, 0xD2, -+ /* 0240 */ 0x79, 0x21, 0x07, 0x06, 0xEF, 0x9C, 0x03, 0x63, -+ /* 0248 */ 0x14, 0x3C, 0xCF, 0x63, 0xC3, 0x04, 0x0A, 0xF2, -+ /* 0250 */ 0x1A, 0x50, 0xA8, 0x67, 0x01, 0x85, 0xF1, 0xA9, -+ /* 0258 */ 0x06, 0x78, 0xFD, 0xFF, 0x4F, 0x35, 0xC0, 0xE5, -+ /* 0260 */ 0x70, 0x80, 0x3B, 0x39, 0xC0, 0xBD, 0x17, 0xB0, -+ /* 0268 */ 0x8B, 0xC3, 0x73, 0x0D, 0x5C, 0xD1, 0xE7, 0x1A, -+ /* 0270 */ 0xA8, 0xF7, 0x96, 0xE2, 0xC6, 0xA8, 0x6B, 0x4C, -+ /* 0278 */ 0x90, 0x47, 0x81, 0x47, 0x9A, 0x28, 0xCF, 0x33, -+ /* 0280 */ 0xEF, 0x32, 0x11, 0x9E, 0x6D, 0x7C, 0xAD, 0xF1, -+ /* 0288 */ 0x14, 0xE2, 0xF8, 0x5A, 0x63, 0xC4, 0x97, 0x89, -+ /* 0290 */ 0x77, 0x1B, 0xE3, 0x1E, 0xDC, 0x63, 0xCD, 0x43, -+ /* 0298 */ 0x8E, 0x41, 0x8E, 0x26, 0xC2, 0x8B, 0x41, 0xC0, -+ /* 02A0 */ 0xC7, 0x1B, 0x1F, 0x6B, 0xC0, 0x2B, 0xE6, 0x85, -+ /* 02A8 */ 0x22, 0x0B, 0xC7, 0x1A, 0x40, 0xE3, 0xFF, 0xFF, -+ /* 02B0 */ 0x58, 0x03, 0xDC, 0xB0, 0x1E, 0x50, 0xC0, 0x77, -+ /* 02B8 */ 0x64, 0x60, 0x37, 0x14, 0x78, 0x27, 0x14, 0xC0, -+ /* 02C0 */ 0x4F, 0xE2, 0x17, 0x80, 0x8E, 0x1C, 0x4E, 0x0B, -+ /* 02C8 */ 0x22, 0x1B, 0x6F, 0x00, 0x9F, 0x02, 0xA8, 0x1A, -+ /* 02D0 */ 0x20, 0x4D, 0x13, 0x36, 0xC1, 0xF4, 0xE4, 0x82, -+ /* 02D8 */ 0xF7, 0x91, 0xC0, 0xB9, 0x49, 0x94, 0x7C, 0x58, -+ /* 02E0 */ 0x14, 0xCE, 0x59, 0x0F, 0x22, 0x14, 0xC4, 0x80, -+ /* 02E8 */ 0x0E, 0x72, 0x9C, 0x40, 0x9F, 0x51, 0x7C, 0x10, -+ /* 02F0 */ 0x39, 0xD1, 0x27, 0x42, 0x0F, 0xCA, 0xC3, 0x78, -+ /* 02F8 */ 0x47, 0x61, 0x27, 0x10, 0x1F, 0x26, 0x3C, 0x76, -+ /* 0300 */ 0x1F, 0x13, 0xF8, 0x3F, 0xC6, 0xB3, 0x31, 0xBA, -+ /* 0308 */ 0xD5, 0x60, 0xE8, 0xFF, 0x7F, 0x4E, 0xE1, 0x60, -+ /* 0310 */ 0x3E, 0x88, 0x70, 0x82, 0x8F, 0x46, 0xDD, 0x24, -+ /* 0318 */ 0x40, 0xA5, 0xEF, 0xA8, 0x00, 0x0A, 0x20, 0xDF, -+ /* 0320 */ 0x0B, 0x7C, 0x0E, 0x78, 0x36, 0x60, 0x63, 0x78, -+ /* 0328 */ 0x14, 0x30, 0x9A, 0xD1, 0x79, 0xF8, 0xC9, 0xA2, -+ /* 0330 */ 0xE2, 0x4E, 0x96, 0x82, 0x78, 0xB2, 0x8E, 0x32, -+ /* 0338 */ 0x59, 0xF4, 0x4C, 0x7C, 0xAF, 0xF0, 0x8C, 0xDE, -+ /* 0340 */ 0xB4, 0x3C, 0x47, 0x4F, 0xD8, 0xF7, 0x10, 0x58, -+ /* 0348 */ 0x87, 0x81, 0x90, 0x0F, 0x06, 0x9E, 0x86, 0xE1, -+ /* 0350 */ 0x3C, 0x59, 0x0E, 0xE7, 0xC9, 0xF2, 0xB1, 0xF8, -+ /* 0358 */ 0x1A, 0x02, 0x3E, 0x81, 0xB3, 0x05, 0x39, 0x3C, -+ /* 0360 */ 0x26, 0xD6, 0xA8, 0xE8, 0x55, 0xC8, 0xC3, 0xE3, -+ /* 0368 */ 0x97, 0x03, 0xCF, 0xE7, 0x19, 0xE1, 0x28, 0x9F, -+ /* 0370 */ 0x24, 0x70, 0x18, 0xCF, 0x24, 0x1E, 0xA2, 0x6F, -+ /* 0378 */ 0x45, 0xB0, 0x26, 0x72, 0xD2, 0xBE, 0x2D, 0x9C, -+ /* 0380 */ 0x6C, 0xD0, 0xD7, 0x33, 0xCC, 0xAD, 0x08, 0xF6, -+ /* 0388 */ 0xFF, 0xFF, 0x56, 0x04, 0xE7, 0x82, 0x06, 0x33, -+ /* 0390 */ 0xD3, 0xBD, 0x0A, 0x15, 0xEB, 0x5E, 0x05, 0x88, -+ /* 0398 */ 0x1D, 0xD6, 0x6B, 0x8F, 0x0F, 0x56, 0x70, 0xEF, -+ /* 03A0 */ 0x55, 0x70, 0x2F, 0x55, 0xCF, 0x0A, 0xC7, 0x18, -+ /* 03A8 */ 0xFE, 0x61, 0x2A, 0xC6, 0x29, 0xBD, 0x76, 0x1A, -+ /* 03B0 */ 0x28, 0x4C, 0x94, 0x78, 0xEF, 0x55, 0x1E, 0xE3, -+ /* 03B8 */ 0x7B, 0x15, 0xBB, 0x42, 0x85, 0x89, 0xF5, 0x72, -+ /* 03C0 */ 0x65, 0xD4, 0xD7, 0x89, 0x70, 0x81, 0x82, 0x44, -+ /* 03C8 */ 0x7A, 0xB5, 0x8A, 0x12, 0x39, 0xBE, 0x21, 0xDF, -+ /* 03D0 */ 0xAB, 0xC0, 0x2B, 0xE7, 0x5E, 0x05, 0xB2, 0xFF, -+ /* 03D8 */ 0xFF, 0xBD, 0x0A, 0x30, 0x8F, 0xF6, 0x5E, 0x05, -+ /* 03E0 */ 0xC6, 0x6B, 0x03, 0xBB, 0x21, 0xC1, 0x02, 0x7A, -+ /* 03E8 */ 0xB1, 0x02, 0x0C, 0x65, 0xBE, 0x58, 0xD1, 0xBC, -+ /* 03F0 */ 0x17, 0x2B, 0xC4, 0xFF, 0xFF, 0x5C, 0xC2, 0xF4, -+ /* 03F8 */ 0x5C, 0xAC, 0xC8, 0x3C, 0xE1, 0xDF, 0xAC, 0x00, -+ /* 0400 */ 0x4E, 0xFF, 0xFF, 0x6F, 0x56, 0x80, 0xB1, 0x7B, -+ /* 0408 */ 0x11, 0xE6, 0x68, 0x05, 0x2F, 0xE5, 0xCD, 0x8A, -+ /* 0410 */ 0xC6, 0x59, 0x86, 0x02, 0x2E, 0x88, 0xC2, 0xF8, -+ /* 0418 */ 0x66, 0x05, 0x38, 0xBA, 0xAE, 0xE0, 0x86, 0x0C, -+ /* 0420 */ 0x17, 0x2C, 0x4A, 0x30, 0x1F, 0x42, 0x3C, 0x9D, -+ /* 0428 */ 0x23, 0x7E, 0x48, 0x78, 0x09, 0x78, 0xCC, 0xF1, -+ /* 0430 */ 0x80, 0x1F, 0x08, 0x7C, 0xB9, 0x02, 0xD3, 0xFF, -+ /* 0438 */ 0x9F, 0xC0, 0x27, 0xDF, 0xB3, 0x7C, 0x9B, 0x7A, -+ /* 0440 */ 0xEF, 0xE5, 0x07, 0xAC, 0xF7, 0x2A, 0x1F, 0x7E, -+ /* 0448 */ 0x63, 0xBD, 0x33, 0xBC, 0x5C, 0x79, 0x24, 0x51, -+ /* 0450 */ 0x4E, 0x22, 0x94, 0xEF, 0x56, 0xEF, 0x55, 0x46, -+ /* 0458 */ 0x89, 0xF8, 0x42, 0xEC, 0x53, 0xB0, 0xA1, 0x8D, -+ /* 0460 */ 0xF2, 0x54, 0x11, 0xDD, 0x78, 0x2F, 0x57, 0xE0, -+ /* 0468 */ 0x95, 0x74, 0xB9, 0x02, 0x68, 0x32, 0xFC, 0x97, -+ /* 0470 */ 0x2B, 0xF0, 0xDD, 0x1C, 0xB0, 0xD7, 0x24, 0x38, -+ /* 0478 */ 0xFF, 0xFF, 0x6B, 0x12, 0xBF, 0x5E, 0x01, 0x7E, -+ /* 0480 */ 0xB2, 0x5F, 0xAF, 0x68, 0xEE, 0xEB, 0x15, 0x4A, -+ /* 0488 */ 0x14, 0x84, 0x14, 0x01, 0x69, 0xA6, 0xE0, 0xB9, -+ /* 0490 */ 0x5F, 0x01, 0x9C, 0xF8, 0xFF, 0xDF, 0xAF, 0x00, -+ /* 0498 */ 0xCB, 0xE1, 0xEE, 0x57, 0x40, 0xEF, 0x76, 0x04, -+ /* 04A0 */ 0x5E, 0x94, 0xB7, 0x23, 0xEC, 0x15, 0x0B, 0x9F, -+ /* 04A8 */ 0xF1, 0x8A, 0x45, 0xC3, 0xAC, 0x44, 0xF1, 0xD6, -+ /* 04B0 */ 0x44, 0x61, 0x7C, 0xC5, 0x02, 0x26, 0xFF, 0xFF, -+ /* 04B8 */ 0x2B, 0x16, 0x30, 0x3B, 0x88, 0xE2, 0x46, 0x0D, -+ /* 04C0 */ 0xF7, 0xE2, 0xE4, 0x5B, 0x8F, 0xE7, 0x1B, 0xD1, -+ /* 04C8 */ 0x77, 0x18, 0xCC, 0x09, 0x0B, 0xC6, 0x0D, 0x0B, -+ /* 04D0 */ 0xFE, 0x90, 0x1E, 0x86, 0x7D, 0x92, 0x78, 0xC7, -+ /* 04D8 */ 0xF2, 0xD1, 0xCA, 0x20, 0x6F, 0xC0, 0x4F, 0x56, -+ /* 04E0 */ 0x0F, 0x56, 0x51, 0x8C, 0x10, 0xF0, 0x78, 0xDE, -+ /* 04E8 */ 0x85, 0x7D, 0xB4, 0x7A, 0xD3, 0x32, 0x4A, 0xEC, -+ /* 04F0 */ 0x58, 0xBE, 0x50, 0x3D, 0x6B, 0xF9, 0x9A, 0x65, -+ /* 04F8 */ 0x88, 0xB8, 0x0F, 0xC4, 0xBE, 0x61, 0x01, 0xB6, -+ /* 0500 */ 0xFF, 0xFF, 0x37, 0x2C, 0xC0, 0xD1, 0xC5, 0x81, -+ /* 0508 */ 0x1F, 0x1C, 0xB0, 0x37, 0x2C, 0xC0, 0xE7, 0x4C, -+ /* 0510 */ 0xC1, 0x73, 0xC3, 0x02, 0x36, 0xFF, 0xFF, 0x1B, -+ /* 0518 */ 0x16, 0xC0, 0xFF, 0xFF, 0xFF, 0x0D, 0x0B, 0x38, -+ /* 0520 */ 0xDC, 0xAE, 0xB0, 0xB7, 0x2C, 0xEC, 0xED, 0x85, -+ /* 0528 */ 0xAC, 0x82, 0x86, 0x5A, 0x89, 0x82, 0x7F, 0xAF, -+ /* 0530 */ 0x0C, 0x43, 0x6F, 0x58, 0x80, 0xA3, 0x71, 0x7B, -+ /* 0538 */ 0xD4, 0xE0, 0x38, 0x1B, 0x3C, 0x49, 0x60, 0xCE, -+ /* 0540 */ 0xD5, 0xB8, 0xD9, 0x1C, 0x5C, 0xE0, 0x08, 0xBD, -+ /* 0548 */ 0x83, 0x6A, 0xEE, 0xEC, 0x92, 0x02, 0xE3, 0x96, -+ /* 0550 */ 0x05, 0xF7, 0x52, 0xF5, 0xD0, 0x10, 0xE5, 0x20, -+ /* 0558 */ 0x5E, 0x85, 0x1F, 0xAC, 0x1E, 0xA5, 0x8E, 0xEC, -+ /* 0560 */ 0xF1, 0xEA, 0x69, 0xD8, 0xC7, 0x2C, 0xDF, 0xB2, -+ /* 0568 */ 0x0C, 0x15, 0xE1, 0x2D, 0x8B, 0x9D, 0x21, 0xE2, -+ /* 0570 */ 0xC5, 0x8A, 0x12, 0xE2, 0xBD, 0x22, 0xB4, 0xEF, -+ /* 0578 */ 0x5C, 0x06, 0x7F, 0x34, 0x36, 0x6A, 0xD0, 0x97, -+ /* 0580 */ 0xE3, 0xB7, 0x2C, 0x78, 0xFF, 0xFF, 0x5B, 0x16, -+ /* 0588 */ 0x7C, 0x91, 0x7F, 0x15, 0x9D, 0x08, 0x7C, 0xCB, -+ /* 0590 */ 0x02, 0xF8, 0x11, 0x0C, 0x42, 0x4E, 0x06, 0x8E, -+ /* 0598 */ 0x3E, 0x2F, 0xE0, 0x07, 0xF0, 0x30, 0xE2, 0x21, -+ /* 05A0 */ 0xB1, 0x00, 0x03, 0xA7, 0xF7, 0x25, 0x9F, 0x29, -+ /* 05A8 */ 0xF8, 0x01, 0xC3, 0x67, 0x0A, 0x76, 0x3D, 0x88, -+ /* 05B0 */ 0xFE, 0x18, 0xE0, 0x73, 0x09, 0x66, 0x70, 0xE0, -+ /* 05B8 */ 0xBF, 0x56, 0x1C, 0xBA, 0x47, 0xF1, 0xFA, 0x60, -+ /* 05C0 */ 0x02, 0x0F, 0x8E, 0xFF, 0xFF, 0x07, 0x07, 0xF7, -+ /* 05C8 */ 0xCE, 0x70, 0x44, 0xBE, 0xC3, 0x78, 0x70, 0x60, -+ /* 05D0 */ 0x3B, 0x08, 0x00, 0x87, 0xC1, 0xE1, 0x43, 0x0D, -+ /* 05D8 */ 0x0E, 0x3D, 0x1E, 0x03, 0x87, 0xF4, 0x79, 0x8C, -+ /* 05E0 */ 0x5D, 0x18, 0x1E, 0x72, 0x3C, 0x34, 0xB0, 0x01, -+ /* 05E8 */ 0x7A, 0x68, 0xC0, 0x72, 0x12, 0x4F, 0x21, 0x87, -+ /* 05F0 */ 0x06, 0x66, 0x09, 0x43, 0x03, 0x4A, 0xF1, 0x86, -+ /* 05F8 */ 0x46, 0xFF, 0xFF, 0x43, 0xE3, 0x43, 0xF2, 0x61, -+ /* 0600 */ 0x21, 0xE6, 0x53, 0x4E, 0x84, 0xF7, 0x05, 0x9F, -+ /* 0608 */ 0xA0, 0x18, 0xFA, 0x6B, 0x8A, 0x6F, 0x17, 0xBE, -+ /* 0610 */ 0x09, 0xE2, 0xC6, 0x07, 0xAE, 0x4B, 0xA7, 0xC7, -+ /* 0618 */ 0x07, 0x7C, 0x8E, 0x5C, 0x1E, 0x1F, 0xEE, 0xE8, -+ /* 0620 */ 0xE4, 0xF1, 0xC1, 0x70, 0x79, 0x95, 0x21, 0x47, -+ /* 0628 */ 0x13, 0x1F, 0xAD, 0xD8, 0xF0, 0xC0, 0x76, 0xD3, -+ /* 0630 */ 0xF3, 0xF0, 0x80, 0xCF, 0x75, 0x13, 0x8C, 0x57, -+ /* 0638 */ 0x48, 0x7E, 0x2D, 0x81, 0x71, 0x82, 0xC2, 0x5F, -+ /* 0640 */ 0x37, 0xC1, 0xFB, 0xFF, 0xBF, 0x6E, 0x02, 0xCF, -+ /* 0648 */ 0x51, 0x70, 0xAD, 0x97, 0x6C, 0x1A, 0xE4, 0x95, -+ /* 0650 */ 0xA3, 0x58, 0x2F, 0x02, 0x0A, 0xE3, 0x33, 0x1B, -+ /* 0658 */ 0xE0, 0x68, 0xAC, 0xCF, 0x6C, 0x60, 0xB9, 0x17, -+ /* 0660 */ 0xB0, 0x1B, 0x1B, 0xDC, 0xD3, 0x1A, 0xEC, 0xBB, -+ /* 0668 */ 0xC3, 0xC3, 0xD9, 0x63, 0xDA, 0xA3, 0xDA, 0x03, -+ /* 0670 */ 0x9A, 0x8F, 0xD8, 0x31, 0xDE, 0xD2, 0x82, 0xC4, -+ /* 0678 */ 0x89, 0xF0, 0x3A, 0xF0, 0xB4, 0xE6, 0x4B, 0x46, -+ /* 0680 */ 0xBC, 0x40, 0x4F, 0x6B, 0xC6, 0x88, 0xF3, 0xD2, -+ /* 0688 */ 0x66, 0xC4, 0x57, 0x8A, 0x10, 0x0F, 0x6B, 0x3E, -+ /* 0690 */ 0xB9, 0x19, 0xEF, 0x61, 0x22, 0x5C, 0x98, 0x17, -+ /* 0698 */ 0xB6, 0xA7, 0x35, 0x70, 0xFC, 0xFF, 0x4F, 0x6B, -+ /* 06A0 */ 0x70, 0xE4, 0x5C, 0xB1, 0x01, 0x9A, 0x5C, 0xF4, -+ /* 06A8 */ 0x71, 0x87, 0x14, 0xB0, 0x5C, 0x1B, 0xD8, 0x2D, -+ /* 06B0 */ 0x05, 0xDE, 0x05, 0x1B, 0x38, 0xFF, 0xFF, 0x8F, -+ /* 06B8 */ 0x28, 0xE0, 0xCB, 0x72, 0xC1, 0xA6, 0x39, 0x2E, -+ /* 06C0 */ 0xD8, 0x28, 0x0E, 0xAB, 0x01, 0xD2, 0x3C, 0xE1, -+ /* 06C8 */ 0x5F, 0xAF, 0xC1, 0x3F, 0x09, 0x5F, 0xAF, 0x01, -+ /* 06D0 */ 0xDB, 0xB7, 0x58, 0xDC, 0xF5, 0x1A, 0x58, 0xFD, -+ /* 06D8 */ 0xFF, 0xAF, 0xD7, 0xC0, 0x52, 0xF0, 0x48, 0xE9, -+ /* 06E0 */ 0x9D, 0x1A, 0x5C, 0x37, 0x6D, 0x3C, 0xE8, 0x9B, -+ /* 06E8 */ 0x36, 0x4C, 0x85, 0x36, 0x7D, 0x6A, 0x34, 0x6A, -+ /* 06F0 */ 0xD5, 0xA0, 0x4C, 0x8D, 0x32, 0x0D, 0x6A, 0xF5, -+ /* 06F8 */ 0xA9, 0xD4, 0x98, 0xB1, 0xA1, 0x5A, 0xDA, 0x5D, -+ /* 0700 */ 0x82, 0x8A, 0x59, 0x8C, 0x46, 0xE3, 0x28, 0x20, -+ /* 0708 */ 0x54, 0xF6, 0x1F, 0x50, 0x20, 0x0E, 0xF9, 0xD1, -+ /* 0710 */ 0x11, 0xA0, 0x83, 0x7D, 0xA7, 0x74, 0x0B, 0x27, -+ /* 0718 */ 0x6B, 0x13, 0x88, 0xE3, 0x9B, 0x80, 0x68, 0x04, -+ /* 0720 */ 0x44, 0x5A, 0x54, 0x00, 0xB1, 0xDC, 0x20, 0x02, -+ /* 0728 */ 0xB2, 0x8A, 0x35, 0x09, 0xC8, 0x9A, 0xBF, 0x2F, -+ /* 0730 */ 0x02, 0xB7, 0x4E, 0x1D, 0x40, 0x2C, 0x25, 0x08, -+ /* 0738 */ 0x4D, 0xB4, 0x70, 0x81, 0x3A, 0x1E, 0x88, 0x06, -+ /* 0740 */ 0x43, 0x68, 0x04, 0xE4, 0x60, 0x14, 0x02, 0xB2, -+ /* 0748 */ 0x8C, 0xCF, 0x9D, 0xC0, 0x2D, 0xC0, 0x0A, 0x10, -+ /* 0750 */ 0x93, 0x0F, 0x42, 0x05, 0x7B, 0x01, 0x65, 0xEA, -+ /* 0758 */ 0x41, 0x04, 0x64, 0xA5, 0x6B, 0x15, 0x90, 0x75, -+ /* 0760 */ 0x83, 0x08, 0xC8, 0x59, 0xCD, 0x80, 0xB3, 0x8C, -+ /* 0768 */ 0x6E, 0x80, 0x98, 0xC2, 0x87, 0x82, 0x40, 0xAC, -+ /* 0770 */ 0x49, 0x0F, 0x28, 0x13, 0x08, 0xA2, 0x0B, 0x07, -+ /* 0778 */ 0xF1, 0x03, 0xC4, 0xA4, 0x81, 0x08, 0xC8, 0x71, -+ /* 0780 */ 0x7E, 0x25, 0x02, 0x77, 0x1C, 0x45, 0x80, 0xD4, -+ /* 0788 */ 0xD1, 0x70, 0x29, 0x08, 0x15, 0xFF, 0x09, 0x13, -+ /* 0790 */ 0xC8, 0xFF, 0xFF, 0xFD, 0x44, 0x96, 0xC0, 0x28, -+ /* 0798 */ 0x08, 0x8D, 0xA0, 0x09, 0x84, 0xC9, 0xF3, 0x04, -+ /* 07A0 */ 0xC2, 0x42, 0xFD, 0xFD, 0x34, 0x04, 0x07, 0x51, -+ /* 07A8 */ 0x35, 0x44, 0xEA, 0x0A, 0x84, 0x05, 0x7E, 0x18, -+ /* 07B0 */ 0x68, 0x30, 0x4E, 0x0F, 0x22, 0x20, 0x27, 0x7D, -+ /* 07B8 */ 0x52, 0x05, 0x22, 0xB9, 0x41, 0x04, 0xE4, 0xFF, -+ /* 07C0 */ 0x3F -+ }) -+ } -+ } -+ -+ /* Wire GPE events to notify OEM -+ * added value events. -+ */ -+ Scope (\_GPE) -+ { -+ Method (_L18, 0, Serialized) -+ { -+ Notify (\_SB.WMI1, 0xD0) -+ } -+ } -+} -+ -diff -Nur a/tools/xenpmd/acpi-events.c b/tools/xenpmd/acpi-events.c ---- a/tools/xenpmd/acpi-events.c 2009-04-01 16:30:52.000000000 -0400 -+++ b/tools/xenpmd/acpi-events.c 2009-04-01 16:51:29.000000000 -0400 -@@ -41,6 +41,7 @@ - #define XS_LID_EVENT_PATH "/pm/events/lidstatechanged" - #define XS_PBTN_EVENT_PATH "/pm/events/powerbuttonpressed" - #define XS_SBTN_EVENT_PATH "/pm/events/sleepbuttonpressed" -+#define XS_OEM_EVENT_PATH "/oem/event" - - static int socket_fd; - static pthread_t acpi_thread; -@@ -97,6 +98,11 @@ - xs_write(xs, XBT_NULL, XS_SBTN_EVENT_PATH, "1", 1); - } - -+void handle_oem_event(void) -+{ -+ xs_write(xs, XBT_NULL, XS_OEM_EVENT_PATH, "1", 1); -+} -+ - void process_acpi_message(char *acpi_buffer) - { - if ( strstr(acpi_buffer, "ac_adapter") ) -@@ -119,7 +125,14 @@ - } - - if ( strstr(acpi_buffer, "SBTN") ) -+ { - handle_sbtn_pressed_event(); -+ return; -+ } -+ -+ if ( (strstr(acpi_buffer, "WMID")) || -+ (strstr(acpi_buffer, "AMW0")) ) -+ handle_oem_event(); - } - - static void *acpi_events_thread(void *arg) diff --git a/xen-3.4/power-management-enhancement b/xen-3.4/power-management-enhancement deleted file mode 100644 index b9bdb77..0000000 --- a/xen-3.4/power-management-enhancement +++ /dev/null @@ -1,1066 +0,0 @@ -diff --git a/tools/firmware/hvmloader/acpi/Makefile b/tools/firmware/hvmloader/acpi/Makefile -index c282d01..f9f6bc3 100644 ---- a/tools/firmware/hvmloader/acpi/Makefile -+++ b/tools/firmware/hvmloader/acpi/Makefile -@@ -19,17 +19,30 @@ XEN_ROOT = ../../../.. - include $(XEN_ROOT)/tools/firmware/Rules.mk - - C_SRC = build.c dsdt.c static_tables.c --H_SRC = $(wildcard *.h) -+H_SRC = $(wildcard *.h) ssdt_pm.h ssdt_tpm.h - OBJS = $(patsubst %.c,%.o,$(C_SRC)) - -+build.o: $(H_SRC) build.c -+ -+IASL_VER = acpica-unix-20080729 -+IASL_URL = http://acpica.org/download/$(IASL_VER).tar.gz -+ - CFLAGS += -I. -I.. $(CFLAGS_include) - - vpath iasl $(PATH) - all: acpi.a - --ssdt_pm.h ssdt_tpm.h: %.h: %.asl -+ssdt_pm.h: ssdt_pm.asl -+ $(MAKE) iasl -+ iasl -tc $< -+ sed -i'' -re 's/AmlCode/AmlCode_PM/g' $*.hex -+ mv $*.hex $@ -+ rm -f *.aml -+ -+ssdt_tpm.h: ssdt_tpm.asl - $(MAKE) iasl - iasl -tc $< -+ sed -i'' -re 's/AmlCode/AmlCode_TPM/g' $*.hex - mv $*.hex $@ - rm -f *.aml - -diff --git a/tools/firmware/hvmloader/acpi/build.c b/tools/firmware/hvmloader/acpi/build.c -index 82510fc..97dcdb5 100644 ---- a/tools/firmware/hvmloader/acpi/build.c -+++ b/tools/firmware/hvmloader/acpi/build.c -@@ -50,7 +50,13 @@ static void set_checksum( - - static uint8_t battery_port_exists(void) - { -- return (inb(0x88) == 0x1F); -+ uint8_t val; -+ -+ val = inb(0x88); -+ if ( (val == 0xff) || (val == 0x0) ) -+ return 0; -+ -+ return 1; - } - - static int construct_madt(struct acpi_20_madt *madt) -diff --git a/tools/firmware/hvmloader/acpi/ssdt_pm.asl b/tools/firmware/hvmloader/acpi/ssdt_pm.asl -index afb78b6..8f2d7a7 100644 ---- a/tools/firmware/hvmloader/acpi/ssdt_pm.asl -+++ b/tools/firmware/hvmloader/acpi/ssdt_pm.asl -@@ -95,6 +95,13 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - P88, 8 - } - -+ /* OperationRegion for Power Button */ -+ OperationRegion (PBOP, SystemIO, 0x200, 0x01) -+ Field (PBOP, ByteAcc, NoLock, WriteAsZeros) -+ { -+ SLP, 1, -+ WAK, 1 -+ } - - Mutex (SYNC, 0x01) - Name (BUF0, Buffer (0x0100) {}) -@@ -291,8 +298,99 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - Release (SYNC) - } - -- /* Future patches will extend AC object to better account for -- * AC to DC transition and more. */ -+ Method (E0, 0, NotSerialized) -+ { -+ If (\_SB.SLP) -+ { -+ Store (One, \_SB.SLP) -+ Notify (\_SB.SLPB, 0x80) -+ } -+ -+ if (\_SB.WAK) -+ { -+ Store (One, \_SB.WAK) -+ Notify (\_SB.SLPB, 0x2) -+ } -+ } -+ -+ Method (E1, 0, NotSerialized) -+ { -+ If (\_SB.SLP) -+ { -+ Store (One, \_SB.SLP) -+ Notify (\_SB.PBTN, 0x80) -+ } -+ -+ if (\_SB.WAK) -+ { -+ Store (One, \_SB.WAK) -+ Notify (\_SB.PBTN, 0x2) -+ } -+ } -+ -+ Method (E1C, 0, NotSerialized) -+ { -+ Notify (\_SB.AC, 0x80) -+ } -+ -+ Method (E17, 0, NotSerialized) -+ { -+ Notify (\_SB.LID, 0x80) -+ } -+ -+ Device (LID) -+ { -+ Name (_HID, EisaId ("PNP0C0D")) -+ Method (_LID, 0, NotSerialized) -+ { -+ Store (\_SB.P88, Local0) -+ If (And (Local0, 0x4)) -+ { -+ Return (0x1) -+ } -+ -+ Return (0x0) -+ } -+ -+ Name (_PRW, Package (0x02) -+ { -+ 0x17, -+ 0x03 -+ }) -+ -+ Method (_PSW, 1, NotSerialized) -+ { -+ Store (\_SB.P88, Local0) -+ If (And (Local0, 0x4)) -+ { -+ Return (0x1) -+ } -+ Return (0x0) -+ } -+ } -+ -+ Device (PBTN) -+ { -+ Name (_HID, EisaId ("PNP0C0C")) -+ -+ Name (_PRW, Package (0x02) -+ { -+ 0x01, -+ 0x04 -+ }) -+ } -+ -+ Device (SLPB) -+ { -+ Name (_HID, EisaId ("PNP0C0E")) -+ -+ Name (_PRW, Package (0x02) -+ { -+ 0x01, -+ 0x04 -+ }) -+ } -+ - Device (AC) - { - Name (_HID, "ACPI0003") -@@ -304,6 +402,12 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - }) - Method (_PSR, 0, NotSerialized) - { -+ Store (\_SB.P88, Local0) -+ If (And (Local0, 0x1)) -+ { -+ Return (0x1) -+ } -+ - Return (0x0) - } - -@@ -348,11 +452,16 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - \_SB - }) - -- /* Always returns 0x1f indicating battery present. */ -+ /* Returning 0x1F indicates battery present */ - Method (_STA, 0, NotSerialized) - { - Store (\_SB.P88, Local0) -- Return ( Local0 ) -+ If (And (Local0, 0x2)) -+ { -+ Return (0x1F) -+ } -+ -+ Return (0x0F) - } - - /* Battery generic info: design capacity, voltage, model # etc. */ -@@ -367,7 +476,7 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - /* Battery status including battery charging/discharging rate. */ - Method (_BST, 0, NotSerialized) - { -- Store (1, \_SB.DBG1) -+ /* Store (1, \_SB.DBG1) */ - ACQR () - INIT (0x02) - INIT (0x01) -@@ -378,7 +487,7 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - Store (HLP7 (), Index (BST0, 0x02)) - Store (HLP7 (), Index (BST0, 0x03)) - REL () -- Store (2, \_SB.DBG1) -+ /* Store (2, \_SB.DBG1) */ - Return (BST0) - } - } -@@ -419,5 +528,31 @@ DefinitionBlock ("SSDT_PM.aml", "SSDT", 2, "Xen", "HVM", 0) - } - } - } -+ -+ /* Wire GPE events to notify power state -+ * changes like ac power to battery use etc. -+ */ -+ Scope (\_GPE) -+ { -+ Method (_L00, 0, NotSerialized) -+ { -+ \_SB.E0() -+ } -+ -+ Method (_L01, 0, NotSerialized) -+ { -+ \_SB.E1() -+ } -+ -+ Method (_L1C, 0, NotSerialized) -+ { -+ \_SB.E1C() -+ } -+ -+ Method (_L17, 0, NotSerialized) -+ { -+ \_SB.E17() -+ } -+ } - } - -diff --git a/tools/firmware/hvmloader/acpi/ssdt_pm.h b/tools/firmware/hvmloader/acpi/ssdt_pm.h -index 020af0b..f277767 100644 ---- a/tools/firmware/hvmloader/acpi/ssdt_pm.h -+++ b/tools/firmware/hvmloader/acpi/ssdt_pm.h -@@ -1,22 +1,22 @@ - /* - * - * Intel ACPI Component Architecture -- * ASL Optimizing Compiler version 20061109 [May 18 2007] -- * Copyright (C) 2000 - 2006 Intel Corporation -+ * ASL Optimizing Compiler version 20080729 [Nov 24 2008] -+ * Copyright (C) 2000 - 2008 Intel Corporation - * Supports ACPI Specification Revision 3.0a - * -- * Compilation of "ssdt_pm.asl" - Sun Oct 12 23:57:51 2008 -+ * Compilation of "ssdt_pm.asl" - Thu May 14 12:24:23 2009 - * - * C source code output - * - */ - unsigned char AmlCode_PM[] = - { -- 0x53,0x53,0x44,0x54,0xD6,0x05,0x00,0x00, /* 00000000 "SSDT...." */ -- 0x02,0xD9,0x58,0x65,0x6E,0x00,0x00,0x00, /* 00000008 "..Xen..." */ -+ 0x53,0x53,0x44,0x54,0xA4,0x07,0x00,0x00, /* 00000000 "SSDT...." */ -+ 0x02,0x15,0x58,0x65,0x6E,0x00,0x00,0x00, /* 00000008 "..Xen..." */ - 0x48,0x56,0x4D,0x00,0x00,0x00,0x00,0x00, /* 00000010 "HVM....." */ - 0x00,0x00,0x00,0x00,0x49,0x4E,0x54,0x4C, /* 00000018 "....INTL" */ -- 0x09,0x11,0x06,0x20,0x10,0x41,0x5B,0x5C, /* 00000020 "... .A[\" */ -+ 0x29,0x07,0x08,0x20,0x10,0x43,0x73,0x5C, /* 00000020 ").. .Cs\" */ - 0x5F,0x53,0x42,0x5F,0x5B,0x80,0x44,0x42, /* 00000028 "_SB_[.DB" */ - 0x47,0x41,0x01,0x0B,0x40,0xB0,0x01,0x5B, /* 00000030 "GA..@..[" */ - 0x81,0x0B,0x44,0x42,0x47,0x41,0x01,0x44, /* 00000038 "..DBGA.D" */ -@@ -39,164 +39,222 @@ unsigned char AmlCode_PM[] = - 0x5B,0x80,0x50,0x52,0x54,0x33,0x01,0x0A, /* 000000C0 "[.PRT3.." */ - 0x88,0x01,0x5B,0x81,0x0B,0x50,0x52,0x54, /* 000000C8 "..[..PRT" */ - 0x33,0x01,0x50,0x38,0x38,0x5F,0x08,0x5B, /* 000000D0 "3.P88_.[" */ -- 0x01,0x53,0x59,0x4E,0x43,0x01,0x08,0x42, /* 000000D8 ".SYNC..B" */ -- 0x55,0x46,0x30,0x11,0x04,0x0B,0x00,0x01, /* 000000E0 "UF0....." */ -- 0x08,0x42,0x55,0x46,0x31,0x11,0x03,0x0A, /* 000000E8 ".BUF1..." */ -- 0x08,0x8B,0x42,0x55,0x46,0x31,0x00,0x42, /* 000000F0 "..BUF1.B" */ -- 0x55,0x46,0x41,0x8B,0x42,0x55,0x46,0x31, /* 000000F8 "UFA.BUF1" */ -- 0x0A,0x04,0x42,0x55,0x46,0x42,0x14,0x14, /* 00000100 "..BUFB.." */ -- 0x41,0x43,0x51,0x52,0x00,0x5B,0x23,0x53, /* 00000108 "ACQR.[#S" */ -- 0x59,0x4E,0x43,0xFF,0xFF,0x70,0x00,0x42, /* 00000110 "YNC..p.B" */ -- 0x55,0x46,0x41,0x14,0x31,0x49,0x4E,0x49, /* 00000118 "UFA.1INI" */ -- 0x54,0x01,0x70,0x42,0x55,0x46,0x41,0x60, /* 00000120 "T.pBUFA`" */ -- 0x75,0x60,0xA0,0x22,0x92,0x94,0x60,0x87, /* 00000128 "u`."..`." */ -- 0x42,0x55,0x46,0x30,0x8C,0x42,0x55,0x46, /* 00000130 "BUF0.BUF" */ -- 0x30,0x42,0x55,0x46,0x41,0x54,0x4D,0x50, /* 00000138 "0BUFATMP" */ -- 0x31,0x70,0x68,0x54,0x4D,0x50,0x31,0x70, /* 00000140 "1phTMP1p" */ -- 0x60,0x42,0x55,0x46,0x41,0x14,0x48,0x07, /* 00000148 "`BUFA.H." */ -- 0x57,0x50,0x52,0x54,0x02,0x70,0x69,0x5C, /* 00000150 "WPRT.pi\" */ -- 0x2E,0x5F,0x53,0x42,0x5F,0x50,0x38,0x36, /* 00000158 "._SB_P86" */ -- 0x5F,0x70,0x68,0x5C,0x2E,0x5F,0x53,0x42, /* 00000160 "_ph\._SB" */ -- 0x5F,0x50,0x42,0x32,0x5F,0x70,0x68,0x5C, /* 00000168 "_PB2_ph\" */ -- 0x2E,0x5F,0x53,0x42,0x5F,0x44,0x42,0x47, /* 00000170 "._SB_DBG" */ -- 0x32,0x70,0x69,0x5C,0x2E,0x5F,0x53,0x42, /* 00000178 "2pi\._SB" */ -- 0x5F,0x44,0x42,0x47,0x34,0x70,0x5C,0x2E, /* 00000180 "_DBG4p\." */ -- 0x5F,0x53,0x42,0x5F,0x50,0x42,0x32,0x5F, /* 00000188 "_SB_PB2_" */ -- 0x60,0xA2,0x11,0x92,0x93,0x60,0x00,0x70, /* 00000190 "`....`.p" */ -- 0x5C,0x2E,0x5F,0x53,0x42,0x5F,0x50,0x42, /* 00000198 "\._SB_PB" */ -- 0x32,0x5F,0x60,0x70,0x5C,0x2E,0x5F,0x53, /* 000001A0 "2_`p\._S" */ -- 0x42,0x5F,0x50,0x38,0x36,0x5F,0x61,0x70, /* 000001A8 "B_P86_ap" */ -- 0x61,0x5C,0x2E,0x5F,0x53,0x42,0x5F,0x44, /* 000001B0 "a\._SB_D" */ -- 0x42,0x47,0x33,0xA4,0x5C,0x2E,0x5F,0x53, /* 000001B8 "BG3.\._S" */ -- 0x42,0x5F,0x50,0x38,0x36,0x5F,0x14,0x1D, /* 000001C0 "B_P86_.." */ -- 0x48,0x4C,0x50,0x31,0x02,0xA0,0x16,0x95, /* 000001C8 "HLP1...." */ -- 0x69,0x87,0x68,0x8C,0x68,0x69,0x54,0x4D, /* 000001D0 "i.h.hiTM" */ -- 0x50,0x31,0x57,0x50,0x52,0x54,0x0A,0x7C, /* 000001D8 "P1WPRT.|" */ -- 0x54,0x4D,0x50,0x31,0x14,0x23,0x48,0x4C, /* 000001E0 "TMP1.#HL" */ -- 0x50,0x32,0x00,0x57,0x50,0x52,0x54,0x0A, /* 000001E8 "P2.WPRT." */ -- 0x7B,0x00,0x70,0x00,0x60,0xA2,0x12,0x95, /* 000001F0 "{.p.`..." */ -- 0x60,0x42,0x55,0x46,0x41,0x48,0x4C,0x50, /* 000001F8 "`BUFAHLP" */ -- 0x31,0x42,0x55,0x46,0x30,0x60,0x75,0x60, /* 00000200 "1BUF0`u`" */ -- 0x14,0x1F,0x48,0x4C,0x50,0x33,0x02,0xA0, /* 00000208 "..HLP3.." */ -- 0x18,0x95,0x69,0x87,0x68,0x8C,0x68,0x69, /* 00000210 "..i.h.hi" */ -- 0x54,0x4D,0x50,0x31,0x70,0x57,0x50,0x52, /* 00000218 "TMP1pWPR" */ -- 0x54,0x0A,0x7D,0x00,0x54,0x4D,0x50,0x31, /* 00000220 "T.}.TMP1" */ -- 0x14,0x23,0x48,0x4C,0x50,0x34,0x00,0x70, /* 00000228 ".#HLP4.p" */ -- 0x00,0x60,0xA2,0x19,0x95,0x60,0x42,0x55, /* 00000230 ".`...`BU" */ -- 0x46,0x42,0x72,0x42,0x55,0x46,0x41,0x60, /* 00000238 "FBrBUFA`" */ -- 0x61,0x48,0x4C,0x50,0x33,0x42,0x55,0x46, /* 00000240 "aHLP3BUF" */ -- 0x30,0x61,0x75,0x60,0x14,0x42,0x04,0x48, /* 00000248 "0au`.B.H" */ -- 0x4C,0x50,0x35,0x00,0x48,0x4C,0x50,0x32, /* 00000250 "LP5.HLP2" */ -- 0x70,0x57,0x50,0x52,0x54,0x0A,0x79,0x00, /* 00000258 "pWPRT.y." */ -- 0x42,0x55,0x46,0x42,0x72,0x42,0x55,0x46, /* 00000260 "BUFBrBUF" */ -- 0x41,0x42,0x55,0x46,0x42,0x60,0xA0,0x1C, /* 00000268 "ABUFB`.." */ -- 0x95,0x87,0x42,0x55,0x46,0x30,0x60,0x70, /* 00000270 "..BUF0`p" */ -- 0x87,0x42,0x55,0x46,0x30,0x60,0x74,0x60, /* 00000278 ".BUF0`t`" */ -- 0x42,0x55,0x46,0x41,0x60,0x70,0x60,0x42, /* 00000280 "BUFA`p`B" */ -- 0x55,0x46,0x42,0x48,0x4C,0x50,0x34,0x14, /* 00000288 "UFBHLP4." */ -- 0x32,0x48,0x4C,0x50,0x36,0x00,0x70,0x42, /* 00000290 "2HLP6.pB" */ -- 0x55,0x46,0x41,0x60,0x75,0x60,0xA0,0x21, /* 00000298 "UFA`u`.!" */ -- 0x92,0x94,0x60,0x87,0x42,0x55,0x46,0x30, /* 000002A0 "..`.BUF0" */ -- 0x8C,0x42,0x55,0x46,0x30,0x42,0x55,0x46, /* 000002A8 ".BUF0BUF" */ -- 0x41,0x54,0x4D,0x50,0x31,0x70,0x60,0x42, /* 000002B0 "ATMP1p`B" */ -- 0x55,0x46,0x41,0xA4,0x54,0x4D,0x50,0x31, /* 000002B8 "UFA.TMP1" */ -- 0xA4,0x00,0x14,0x35,0x48,0x4C,0x50,0x37, /* 000002C0 "...5HLP7" */ -- 0x00,0x70,0x42,0x55,0x46,0x41,0x60,0x72, /* 000002C8 ".pBUFA`r" */ -- 0x60,0x0A,0x04,0x60,0xA0,0x21,0x92,0x94, /* 000002D0 "`..`.!.." */ -- 0x60,0x87,0x42,0x55,0x46,0x30,0x8A,0x42, /* 000002D8 "`.BUF0.B" */ -- 0x55,0x46,0x30,0x42,0x55,0x46,0x41,0x53, /* 000002E0 "UF0BUFAS" */ -- 0x58,0x32,0x32,0x70,0x60,0x42,0x55,0x46, /* 000002E8 "X22p`BUF" */ -- 0x41,0xA4,0x53,0x58,0x32,0x32,0xA4,0x00, /* 000002F0 "A.SX22.." */ -- 0x14,0x1C,0x48,0x4C,0x50,0x38,0x02,0xA0, /* 000002F8 "..HLP8.." */ -- 0x15,0x95,0x69,0x87,0x68,0x8C,0x68,0x69, /* 00000300 "..i.h.hi" */ -- 0x54,0x4D,0x50,0x31,0x70,0x48,0x4C,0x50, /* 00000308 "TMP1pHLP" */ -- 0x36,0x54,0x4D,0x50,0x31,0x14,0x16,0x48, /* 00000310 "6TMP1..H" */ -- 0x4C,0x50,0x39,0x02,0x70,0x00,0x60,0xA2, /* 00000318 "LP9.p.`." */ -- 0x0C,0x95,0x60,0x69,0x48,0x4C,0x50,0x38, /* 00000320 "..`iHLP8" */ -- 0x68,0x60,0x75,0x60,0x14,0x22,0x48,0x4C, /* 00000328 "h`u`."HL" */ -- 0x50,0x41,0x00,0x70,0x48,0x4C,0x50,0x36, /* 00000330 "PA.pHLP6" */ -- 0x60,0x08,0x54,0x4D,0x50,0x5F,0x11,0x02, /* 00000338 "`.TMP_.." */ -- 0x60,0x48,0x4C,0x50,0x39,0x54,0x4D,0x50, /* 00000340 "`HLP9TMP" */ -- 0x5F,0x60,0xA4,0x54,0x4D,0x50,0x5F,0x14, /* 00000348 "_`.TMP_." */ -- 0x0C,0x52,0x45,0x4C,0x5F,0x00,0x5B,0x27, /* 00000350 ".REL_.['" */ -- 0x53,0x59,0x4E,0x43,0x5B,0x82,0x3C,0x41, /* 00000358 "SYNC[. -+#include -+#include -+#include -+#include -+#include -+#include -+ -+#define AC_ADAPTER_STATE_FILE_PATH "/proc/acpi/ac_adapter/AC/state" -+#define LID_STATE_FILE_PATH "/proc/acpi/button/lid/LID/state" -+#define ACPID_SOCKET_PATH "/var/run/acpid.socket" -+ -+#define XS_AC_ADAPTER_STATE_PATH "/pm/ac_adapter" -+#define XS_LID_STATE_PATH "/pm/lid_state" -+ -+#define XS_AC_ADAPTER_EVENT_PATH "/pm/events/acadapterstatechanged" -+#define XS_LID_EVENT_PATH "/pm/events/lidstatechanged" -+#define XS_PBTN_EVENT_PATH "/pm/events/powerbuttonpressed" -+#define XS_SBTN_EVENT_PATH "/pm/events/sleepbuttonpressed" -+ -+static int socket_fd; -+static pthread_t acpi_thread; -+extern struct xs_handle *xs; -+ -+void write_state_info_in_xenstore(char *file_path, char *xenstore_path, -+ char *search_str, char *default_value, char *alternate_value) -+{ -+ FILE *file; -+ char file_data[1024]; -+ -+ xs_write(xs, XBT_NULL, xenstore_path, default_value, strlen(default_value)); -+ file = fopen(file_path, "r"); -+ if ( file == NULL ) -+ return; -+ -+ memset(file_data, 0, 1024); -+ fgets(file_data, 1024, file); -+ if ( strstr(file_data, search_str) ) -+ xs_write(xs, XBT_NULL, xenstore_path, alternate_value, -+ strlen(alternate_value)); -+ fclose(file); -+} -+ -+void initialize_system_state_info(void) -+{ -+ write_state_info_in_xenstore(AC_ADAPTER_STATE_FILE_PATH, -+ XS_AC_ADAPTER_STATE_PATH, "off-line", "1", "0"); -+ write_state_info_in_xenstore(LID_STATE_FILE_PATH, XS_LID_STATE_PATH, -+ "closed", "1", "0"); -+} -+ -+void handle_ac_adapter_state_change(void) -+{ -+ write_state_info_in_xenstore(AC_ADAPTER_STATE_FILE_PATH, -+ XS_AC_ADAPTER_STATE_PATH, "off-line", "1", "0"); -+ xs_write(xs, XBT_NULL, XS_AC_ADAPTER_EVENT_PATH, "1", 1); -+} -+ -+void handle_lid_state_change(void) -+{ -+ write_state_info_in_xenstore(LID_STATE_FILE_PATH, XS_LID_STATE_PATH, -+ "closed", "1", "0"); -+ xs_write(xs, XBT_NULL, XS_LID_EVENT_PATH, "1", 1); -+} -+ -+void handle_pbtn_pressed_event(void) -+{ -+ xs_write(xs, XBT_NULL, XS_PBTN_EVENT_PATH, "1", 1); -+} -+ -+void handle_sbtn_pressed_event(void) -+{ -+ xs_write(xs, XBT_NULL, XS_SBTN_EVENT_PATH, "1", 1); -+} -+ -+void process_acpi_message(char *acpi_buffer) -+{ -+ if ( strstr(acpi_buffer, "ac_adapter") ) -+ { -+ handle_ac_adapter_state_change(); -+ return; -+ } -+ -+ if ( strstr(acpi_buffer, "LID") ) -+ { -+ handle_lid_state_change(); -+ return; -+ } -+ -+ if ( (strstr(acpi_buffer, "PBTN")) || -+ (strstr(acpi_buffer, "PWRF")) ) -+ { -+ handle_pbtn_pressed_event(); -+ return; -+ } -+ -+ if ( strstr(acpi_buffer, "SBTN") ) -+ handle_sbtn_pressed_event(); -+} -+ -+static void *acpi_events_thread(void *arg) -+{ -+ int ret; -+ struct sockaddr_un addr; -+ char acpi_buffer[1024]; -+ -+ socket_fd = socket(PF_UNIX, SOCK_STREAM, 0); -+ if ( socket_fd == -1) -+ return (void *)socket_fd; -+ -+ addr.sun_family = AF_UNIX; -+ strncpy(addr.sun_path, ACPID_SOCKET_PATH, strlen(ACPID_SOCKET_PATH)); -+ addr.sun_path[strlen(ACPID_SOCKET_PATH)] = '\0'; -+ ret = connect(socket_fd, (struct sockaddr *)&addr, sizeof(addr)); -+ if ( ret == -1 ) -+ return (void *)ret; -+ -+ while( 1 ) -+ { -+ memset(acpi_buffer, 0, sizeof(acpi_buffer)); -+ ret = recv(socket_fd, acpi_buffer, sizeof(acpi_buffer), 0); -+ if ( ret == 0 ) -+ continue; -+ -+ process_acpi_message(acpi_buffer); -+ } -+ -+ return (void *)1; -+} -+ -+void monitor_acpi_events(void) -+{ -+ pthread_create(&acpi_thread, NULL, &acpi_events_thread, NULL); -+} -+ -+void acpi_events_cleanup(void) -+{ -+ if ( socket_fd != -1 ) -+ close(socket_fd); -+ -+ pthread_cancel(acpi_thread); -+} -+ -diff --git a/tools/xenpmd/xenpmd.c b/tools/xenpmd/xenpmd.c -index 28de744..9bc0cc1 100644 ---- a/tools/xenpmd/xenpmd.c -+++ b/tools/xenpmd/xenpmd.c -@@ -40,10 +40,11 @@ - #include - #include - #include -+#include - #include - - /* #define RUN_STANDALONE */ --#define RUN_IN_SIMULATE_MODE -+/* #define RUN_IN_SIMULATE_MODE */ - - enum BATTERY_INFO_TYPE { - BIF, -@@ -84,7 +85,12 @@ struct battery_status { - unsigned long present_voltage; - }; - --static struct xs_handle *xs; -+struct xs_handle *xs; -+static pthread_t worker_thread; -+ -+extern void initialize_system_state_info(void); -+extern void monitor_acpi_events(void); -+extern void acpi_events_cleanup(void); - - #ifdef RUN_IN_SIMULATE_MODE - #define BATTERY_DIR_PATH "/tmp/battery" -@@ -218,11 +224,19 @@ void set_attribute_battery_status(char *attrib_name, - { - if ( strstr(attrib_name, "charging state") ) - { -- /* Check this, below is half baked */ -- if ( strstr(attrib_value, "charged") ) -- status->state = 0; -- else -- status->state = 1; -+ if ( strstr(attrib_value, "charging/discharging") ) -+ status->state |= 0x3; -+ else if ( strstr(attrib_value, "discharging") ) -+ status->state |= 0x1; -+ else if ( strstr(attrib_value, "charging") ) -+ status->state |= 0x2; -+ return; -+ } -+ -+ if ( strstr(attrib_name, "capacity state") ) -+ { -+ if ( strstr(attrib_value, "ok") ) -+ status->state |= 4; - return; - } - -@@ -292,11 +306,12 @@ int get_next_battery_info_or_status(DIR *battery_dir, - void *info_or_status) - { - FILE *file; -- char line_info[256]; -+ char line_info[1024]; - - if ( !info_or_status ) - return 0; - -+ memset(line_info, 0, sizeof (line_info)); - if (type == BIF) - memset(info_or_status, 0, sizeof(struct battery_info)); - else -@@ -306,8 +321,11 @@ int get_next_battery_info_or_status(DIR *battery_dir, - if ( !file ) - return 0; - -- while ( fgets(line_info, sizeof(line_info), file) != NULL ) -+ while ( fgets(line_info, sizeof (line_info), file) != NULL ) -+ { - parse_battery_info_or_status(line_info, type, info_or_status); -+ memset(line_info, 0, sizeof (line_info)); -+ } - - fclose(file); - return 1; -@@ -317,14 +335,14 @@ int get_next_battery_info_or_status(DIR *battery_dir, - void print_battery_info(struct battery_info *info) - { - printf("present: %d\n", info->present); -- printf("design capacity: %d\n", info->design_capacity); -- printf("last full capacity: %d\n", info->last_full_capacity); -+ printf("design capacity: %d\n", (int) info->design_capacity); -+ printf("last full capacity: %d\n", (int) info->last_full_capacity); - printf("battery technology: %d\n", info->battery_technology); -- printf("design voltage: %d\n", info->design_voltage); -- printf("design capacity warning:%d\n", info->design_capacity_warning); -- printf("design capacity low: %d\n", info->design_capacity_low); -- printf("capacity granularity 1: %d\n", info->capacity_granularity_1); -- printf("capacity granularity 2: %d\n", info->capacity_granularity_2); -+ printf("design voltage: %d\n", (int) info->design_voltage); -+ printf("design capacity warning:%d\n", (int) info->design_capacity_warning); -+ printf("design capacity low: %d\n", (int) info->design_capacity_low); -+ printf("capacity granularity 1: %d\n", (int) info->capacity_granularity_1); -+ printf("capacity granularity 2: %d\n", (int) info->capacity_granularity_2); - printf("model number: %s\n", info->model_number); - printf("serial number: %s\n", info->serial_number); - printf("battery type: %s\n", info->battery_type); -@@ -406,10 +424,11 @@ int write_one_time_battery_info(void) - void print_battery_status(struct battery_status *status) - { - printf("present: %d\n", status->present); -- printf("Battery state %d\n", status->state); -- printf("Battery present rate %d\n", status->present_rate); -- printf("Battery remining capacity %d\n", status->remaining_capacity); -- printf("Battery present voltage %d\n", status->present_voltage); -+ printf("Battery state %d\n", (int) status->state); -+ printf("Battery present rate %d\n", (int) status->present_rate); -+ printf("Battery remining capacity %d\n", -+ (int) status->remaining_capacity); -+ printf("Battery present voltage %d\n", (int) status->present_voltage); - } - #endif /*RUN_STANDALONE*/ - -@@ -469,6 +488,7 @@ int wait_for_and_update_battery_status_request(void) - return ret; - } - -+#ifndef RUN_STANDALONE - /* Borrowed daemonize from xenstored - Initially written by Stevens. */ - static void daemonize(void) - { -@@ -493,24 +513,57 @@ static void daemonize(void) - - umask(0); - } -+#endif - --int main(int argc, char *argv[]) -+/* -+ * IMPORTANT: From the child process, we create a new thread -+ * to monitor acpid events. However, due to a bug in uClibc, -+ * the child process main thread does not get time slice -+ * after spawning a new thread. To work around this, we create -+ * a worker thread and then create an acpid monitor thread from -+ * this worker thread. This way both the worker thread and acpid -+ * thread will get time slices. This workaround will be removed -+ * once uClibc bug is fixed. -+ */ -+static void *worker_thread_routine(void *arg) - { - #ifndef RUN_STANDALONE - daemonize(); - #endif - xs = (struct xs_handle *)xs_daemon_open(); -- if ( xs == NULL ) -- return -1; -- -- if ( write_one_time_battery_info() == 0 ) -+ if ( xs == NULL ) -+ return NULL; -+ if ( xs == NULL ) -+ return NULL; -+ -+ if ( write_one_time_battery_info() == 0 ) -+ initialize_system_state_info(); -+ monitor_acpi_events(); -+ if ( write_one_time_battery_info() == 0 ) - { - xs_daemon_close(xs); -- return -1; -+ return NULL; - } - - wait_for_and_update_battery_status_request(); -+ acpi_events_cleanup(); - xs_daemon_close(xs); -- return 0; -+ return NULL; - } - -+ -+int main(int argc, char *argv[]) -+{ -+#ifndef RUN_STANDALONE -+ daemonize(); -+#endif -+ -+ /* Refer to worker_thread_routine for why we create additional thread */ -+ pthread_create(&worker_thread, NULL, &worker_thread_routine, NULL); -+ -+ /* below won't get a time slice because of uClibc bug. */ -+ while ( 1 ) -+ sleep(60); -+ -+ return 0; -+} diff --git a/xen-3.4/pt-load-vga-bios b/xen-3.4/pt-load-vga-bios deleted file mode 100644 index e16f263..0000000 --- a/xen-3.4/pt-load-vga-bios +++ /dev/null @@ -1,199 +0,0 @@ -diff --git a/tools/libxc/xc_hvm_build.c b/tools/libxc/xc_hvm_build.c -index e20f5ac..0ba8c44 100644 ---- a/tools/libxc/xc_hvm_build.c -+++ b/tools/libxc/xc_hvm_build.c -@@ -66,6 +66,54 @@ static void build_hvm_info(void *hvm_info_page, uint64_t mem_size) - hvm_info->checksum = -sum; - } - -+static int setup_vga_pt(int xc_handle, -+ uint32_t dom) -+{ -+ int rc = 0; -+ unsigned char *bios = NULL; -+ int bios_size = 0; -+ char *va_bios = NULL; -+ uint32_t va_size = 0; -+ char *c = NULL; -+ char checksum = 0; -+ -+ /* Allocated 64K for the vga bios */ -+ if (!(bios = malloc(64 * 1024))) -+ return -1; -+ -+#ifdef __linux__ -+ bios_size = xc_get_vgabios(bios, 64 * 1024); -+#else -+ bios_size = 0; -+#endif /* __linux__ */ -+ -+ va_size = bios_size + bios_size % XC_PAGE_SIZE; -+ if (bios_size == 0) -+ { -+ rc = -1; -+ goto error; -+ } -+ va_bios = xc_map_foreign_range(xc_handle, dom, va_size, -+ PROT_READ | PROT_WRITE, 0xC0); -+ if (!va_bios) -+ { -+ rc = -1; -+ goto error; -+ } -+ -+ /* Adjust the bios checksum */ -+ for ( c = (char*)bios; c < ((char*)bios + bios_size); c++ ) -+ checksum += *c; -+ if (checksum) -+ bios[bios_size - 1] -= checksum; -+ -+ memcpy(va_bios, bios, bios_size); -+ munmap(va_bios, va_size); -+error: -+ free(bios); -+ return rc; -+} -+ - static int loadelfimage( - struct elf_binary *elf, int xch, uint32_t dom, unsigned long *parray) - { -@@ -354,7 +402,8 @@ static inline int is_loadable_phdr(Elf32_Phdr *phdr) - int xc_hvm_build(int xc_handle, - uint32_t domid, - int memsize, -- const char *image_name) -+ const char *image_name, -+ int vga_pt_enabled) - { - char *image; - int sts; -@@ -365,6 +414,8 @@ int xc_hvm_build(int xc_handle, - return -1; - - sts = xc_hvm_build_internal(xc_handle, domid, memsize, memsize, image, image_size); -+ if ( vga_pt_enabled ) -+ sts |= setup_vga_pt(xc_handle, domid); - - free(image); - -diff --git a/tools/libxc/xc_linux.c b/tools/libxc/xc_linux.c -index 2480b3c..6068960 100644 ---- a/tools/libxc/xc_linux.c -+++ b/tools/libxc/xc_linux.c -@@ -562,6 +562,57 @@ int xc_gnttab_set_max_grants(int xcg_handle, - return 0; - } - -+int xc_get_vgabios(unsigned char *buf, -+ int len) -+{ -+ int mem; -+ uint32_t start, size = 0; -+ uint16_t magic = 0; -+ -+ start = 0xC0000; -+ if (len < size) -+ return 0; -+ if ((mem = open("/dev/mem", O_RDONLY)) < 0) -+ return 0; -+ -+ /* -+ ** Check if it a real bios extension. -+ ** The magic number is 0xAA55. -+ */ -+ if (start != lseek(mem, start, SEEK_SET)) -+ goto out; -+ if (read(mem, &magic, 2) != 2) -+ goto out; -+ if (magic != 0xAA55) -+ goto out; -+ -+ /* Find the size of the rom extension */ -+ if (start != lseek(mem, start, SEEK_SET)) -+ goto out; -+ if (lseek(mem, 2, SEEK_CUR) != (start + 2)) -+ goto out; -+ if (read(mem, &size, 1) != 1) -+ goto out; -+ /* This size is in 512K */ -+ size *= 512; -+ -+ /* -+ ** Set the file to the begining of the rombios, -+ ** to start the copy. -+ */ -+ if (start != lseek(mem, start, SEEK_SET)) -+ { -+ size = 0; -+ goto out; -+ } -+ if (size != read(mem, buf, size)) -+ size = 0; -+ -+out: -+ close(mem); -+ return size; -+} -+ - /* - * Local variables: - * mode: C -diff --git a/tools/libxc/xenctrl.h b/tools/libxc/xenctrl.h -index 9ce2286..dfd6fa4 100644 ---- a/tools/libxc/xenctrl.h -+++ b/tools/libxc/xenctrl.h -@@ -145,6 +145,10 @@ int xc_waitdomain( - int *status, - int options); - -+int xc_get_vgabios( -+ unsigned char *bios, -+ int len); -+ - #endif /* __linux__ */ - - /* -diff --git a/tools/libxc/xenguest.h b/tools/libxc/xenguest.h -index d64fc45..e58302b 100644 ---- a/tools/libxc/xenguest.h -+++ b/tools/libxc/xenguest.h -@@ -125,10 +125,12 @@ int xc_linux_build_mem(int xc_handle, - unsigned int console_evtchn, - unsigned long *console_mfn); - -+#define USE_VGA_PASSTHROUGH_IN_HVM_BUILD - int xc_hvm_build(int xc_handle, - uint32_t domid, - int memsize, -- const char *image_name); -+ const char *image_name, -+ int vga_pt_enabled); - - int xc_hvm_build_target_mem(int xc_handle, - uint32_t domid, -diff --git a/tools/libxc/xg_private.c b/tools/libxc/xg_private.c -index 4dc3a5c..2a3706e 100644 ---- a/tools/libxc/xg_private.c -+++ b/tools/libxc/xg_private.c -@@ -177,7 +177,8 @@ __attribute__((weak)) - int xc_hvm_build(int xc_handle, - uint32_t domid, - int memsize, -- const char *image_name) -+ const char *image_name, -+ int vga_pt_enabled) - { - errno = ENOSYS; - return -1; -diff --git a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h -index eb965dc..774a7d5 100644 ---- a/xen/include/public/hvm/hvm_info_table.h -+++ b/xen/include/public/hvm/hvm_info_table.h -@@ -36,6 +36,7 @@ - #define HVM_ACINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_ACINFO_OFFSET) - #define HVM_ACINFO_MAX 0x400 - -+#define XEN_BRANCH_3_4 - #define HVM_SMINFO_EXTENSIONS 1 - #define HVM_ACINFO_EXTENSIONS 1 - diff --git a/xen-3.4/remove-fixed-host-bridge-check b/xen-3.4/remove-fixed-host-bridge-check deleted file mode 100644 index 329696b..0000000 --- a/xen-3.4/remove-fixed-host-bridge-check +++ /dev/null @@ -1,13 +0,0 @@ -diff --git a/tools/firmware/rombios/rombios.c b/tools/firmware/rombios/rombios.c -index 0aea421..1e5420c 100644 ---- a/tools/firmware/rombios/rombios.c -+++ b/tools/firmware/rombios/rombios.c -@@ -220,7 +220,7 @@ - // define this if you want to make PCIBIOS working on a specific bridge only - // undef enables PCIBIOS when at least one PCI device is found - // i440FX is emulated by Bochs and QEMU --#define PCI_FIXED_HOST_BRIDGE 0x12378086 ;; i440FX PCI bridge -+//#define PCI_FIXED_HOST_BRIDGE 0x12378086 ;; i440FX PCI bridge - - // #20 is dec 20 - // #$20 is hex 20 = 32 diff --git a/xen-3.4/series b/xen-3.4/series deleted file mode 100644 index b6d30f7..0000000 --- a/xen-3.4/series +++ /dev/null @@ -1,12 +0,0 @@ -fix_compilation -power-management-enhancement -smbios -acpi-slic -oem-features -thermal-management -pt-load-vga-bios -init-vgabios-and-set-size -#module-reloc -mfn-validity-check-before-shadow-remove -remove-fixed-host-bridge-check -mtrr-changes diff --git a/xen-3.4/smbios b/xen-3.4/smbios deleted file mode 100644 index 972f8f6..0000000 --- a/xen-3.4/smbios +++ /dev/null @@ -1,786 +0,0 @@ -diff ---- /dev/null -+++ b/oem/dell-960-optiplex-smbios.patch 2009-04-01 14:15:16.000000000 -0400 -@@ -0,0 +1,49 @@ -+diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h -+--- a/tools/firmware/hvmloader/markers.h 2008-11-25 12:47:54.000000000 -0500 -++++ b/tools/firmware/hvmloader/markers.h 2008-11-25 12:53:27.000000000 -0500 -+@@ -17,22 +17,22 @@ -+ struct bios_vendor_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; -++} bios_vendor = {BIOS_VENDOR_MARKER, "Dell Inc."}; -+ -+ struct bios_version_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_version = {BIOS_VERSION_MARKER, ""}; -++} bios_version = {BIOS_VERSION_MARKER, "X20"}; -+ -+ struct sys_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; -++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Dell Inc."}; -+ -+ struct sys_product_name_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; -++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "OptiPlex 960"}; -+ -+ struct sys_product_version_struct { -+ char marker[65]; -+@@ -57,15 +57,15 @@ -+ struct sys_enclosure_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; -++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Dell Inc."}; -+ -+ struct sys_enclosure_serial_struct { -+ char marker[65]; -+ char value[65]; -+ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; -+ -+-const char *oem_strings_array[1] = { -+- NULL -++const char *oem_strings_array[2] = { -++ "www.dell.com", NULL -+ }; -+ -+ #endif /* __HVMLOADER_MARKERS_H__ */ -diff ---- /dev/null -+++ b/oem/dell-e6500-latitude-smbios.patch 2009-04-01 14:15:16.000000000 -0400 -@@ -0,0 +1,49 @@ -+diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h -+--- a/tools/firmware/hvmloader/markers.h 2008-12-15 14:44:08.000000000 -0500 -++++ b/tools/firmware/hvmloader/markers.h 2008-12-15 14:56:51.000000000 -0500 -+@@ -17,22 +17,22 @@ -+ struct bios_vendor_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; -++} bios_vendor = {BIOS_VENDOR_MARKER, "Dell Inc."}; -+ -+ struct bios_version_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_version = {BIOS_VERSION_MARKER, ""}; -++} bios_version = {BIOS_VERSION_MARKER, "A09"}; -+ -+ struct sys_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; -++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Dell Inc."}; -+ -+ struct sys_product_name_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; -++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "Latitude E6500"}; -+ -+ struct sys_product_version_struct { -+ char marker[65]; -+@@ -57,15 +57,15 @@ -+ struct sys_enclosure_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; -++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Dell Inc."}; -+ -+ struct sys_enclosure_serial_struct { -+ char marker[65]; -+ char value[65]; -+ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; -+ -+-const char *oem_strings_array[1] = { -+- NULL -++const char *oem_strings_array[4] = { -++ "Dell System", "5[0031]", "13[PP04X]", NULL -+ }; -+ -+ #endif /* __HVMLOADER_MARKERS_H__ */ -diff ---- /dev/null -+++ b/oem/hp-6930p-elitebook-smbios.patch 2009-04-01 14:15:16.000000000 -0400 -@@ -0,0 +1,67 @@ -+diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h -+--- a/tools/firmware/hvmloader/markers.h 2008-11-25 12:47:54.000000000 -0500 -++++ b/tools/firmware/hvmloader/markers.h 2008-11-25 12:46:41.000000000 -0500 -+@@ -17,27 +17,27 @@ -+ struct bios_vendor_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; -++} bios_vendor = {BIOS_VENDOR_MARKER, "Hewlett-Packard"}; -+ -+ struct bios_version_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_version = {BIOS_VERSION_MARKER, ""}; -++} bios_version = {BIOS_VERSION_MARKER, "68PCU Ver. F.0B"}; -+ -+ struct sys_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; -++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Hewlett-Packard"}; -+ -+ struct sys_product_name_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; -++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HP EliteBook 6930p"}; -+ -+ struct sys_product_version_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; -++} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, "F.0B"}; -+ -+ struct sys_product_serial_struct { -+ char marker[65]; -+@@ -47,25 +47,25 @@ -+ struct sys_product_sku_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, ""}; -++} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, "GB996EA#ABU"}; -+ -+ struct sys_product_family_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; -++} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, "103C_5336AN"}; -+ -+ struct sys_enclosure_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; -++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Hewlett-Packard"}; -+ -+ struct sys_enclosure_serial_struct { -+ char marker[65]; -+ char value[65]; -+ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; -+ -+-const char *oem_strings_array[1] = { -+- NULL -++const char *oem_strings_array[4] = { -++ "ABS 70/71 79 7A 7B 7C", "CSM v01.24", "www.hp.com", NULL -+ }; -+ -+ #endif /* __HVMLOADER_MARKERS_H__ */ -diff ---- /dev/null -+++ b/oem/lenovo-x200-thinkpad-smbios.patch 2009-04-01 14:15:16.000000000 -0400 -@@ -0,0 +1,61 @@ -+diff -Nur a/tools/firmware/hvmloader/markers.h b/tools/firmware/hvmloader/markers.h -+--- a/tools/firmware/hvmloader/markers.h 2008-12-15 14:44:08.000000000 -0500 -++++ b/tools/firmware/hvmloader/markers.h 2008-12-16 10:09:53.000000000 -0500 -+@@ -17,27 +17,27 @@ -+ struct bios_vendor_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; -++} bios_vendor = {BIOS_VENDOR_MARKER, "LENOVO"}; -+ -+ struct bios_version_struct { -+ char marker[65]; -+ char value[65]; -+-} bios_version = {BIOS_VERSION_MARKER, ""}; -++} bios_version = {BIOS_VERSION_MARKER, "6DET33WW (1.10 )"}; -+ -+ struct sys_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; -++} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "LENOVO"}; -+ -+ struct sys_product_name_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; -++} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "74542NU"}; -+ -+ struct sys_product_version_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; -++} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, "ThinkPad X200"}; -+ -+ struct sys_product_serial_struct { -+ char marker[65]; -+@@ -52,20 +52,20 @@ -+ struct sys_product_family_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; -++} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, "ThinkPad X200"}; -+ -+ struct sys_enclosure_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+-} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; -++} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "LENOVO"}; -+ -+ struct sys_enclosure_serial_struct { -+ char marker[65]; -+ char value[65]; -+ } sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; -+ -+-const char *oem_strings_array[1] = { -+- NULL -++const char *oem_strings_array[2] = { -++ "IBM ThinkPad Embedded Controller -[7XHT21WW-1.03 ]-", NULL -+ }; -+ -+ #endif /* __HVMLOADER_MARKERS_H__ */ -diff ---- /dev/null -+++ b/tools/firmware/hvmloader/markers.h 2009-04-01 14:15:17.000000000 -0400 -@@ -0,0 +1,71 @@ -+#ifndef __HVMLOADER_MARKERS_H__ -+#define __HVMLOADER_MARKERS_H__ -+ -+#define BIOS_VENDOR_MARKER "##############################################BIOS_VENDOR_MARKER" -+#define BIOS_VERSION_MARKER "#############################################BIOS_VERSION_MARKER" -+ -+#define SYS_MANUFACTURER_MARKER "#########################################SYS_MANUFACTURER_MARKER" -+#define SYS_PRODUCT_NAME_MARKER "#########################################SYS_PRODUCT_NAME_MARKER" -+#define SYS_PRODUCT_VERSION_MARKER "######################################SYS_PRODUCT_VERSION_MARKER" -+#define SYS_PRODUCT_SERIAL_MARKER "#######################################SYS_PRODUCT_SERIAL_MARKER" -+#define SYS_PRODUCT_SKU_MARKER "##########################################SYS_PRODUCT_SKU_MARKER" -+#define SYS_PRODUCT_FAMILY_MARKER "#######################################SYS_PRODUCT_FAMILY_MARKER" -+ -+#define SYS_ENCLOSURE_MANUFACTURER_MARKER "###############################SYS_ENCLOSURE_MANUFACTURER_MARKER" -+#define SYS_ENCLOSURE_SERIAL_MARKER "#####################################SYS_ENCLOSURE_SERIAL_MARKER" -+ -+struct bios_vendor_struct { -+ char marker[65]; -+ char value[65]; -+} bios_vendor = {BIOS_VENDOR_MARKER, "Xen"}; -+ -+struct bios_version_struct { -+ char marker[65]; -+ char value[65]; -+} bios_version = {BIOS_VERSION_MARKER, ""}; -+ -+struct sys_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+} sys_manufacturer = {SYS_MANUFACTURER_MARKER, "Xen"}; -+ -+struct sys_product_name_struct { -+ char marker[65]; -+ char value[65]; -+} sys_product_name = {SYS_PRODUCT_NAME_MARKER, "HVM domU"}; -+ -+struct sys_product_version_struct { -+ char marker[65]; -+ char value[65]; -+} sys_product_version = {SYS_PRODUCT_VERSION_MARKER, ""}; -+ -+struct sys_product_serial_struct { -+ char marker[65]; -+ char value[65]; -+} sys_product_serial = {SYS_PRODUCT_SERIAL_MARKER, ""}; -+ -+struct sys_product_sku_struct { -+ char marker[65]; -+ char value[65]; -+} sys_product_sku = {SYS_PRODUCT_SKU_MARKER, ""}; -+ -+struct sys_product_family_struct { -+ char marker[65]; -+ char value[65]; -+} sys_product_family = {SYS_PRODUCT_FAMILY_MARKER, ""}; -+ -+struct sys_enclosure_manufacturer_struct { -+ char marker[65]; -+ char value[65]; -+} sys_enclosure_manufacturer = {SYS_ENCLOSURE_MANUFACTURER_MARKER, "Xen"}; -+ -+struct sys_enclosure_serial_struct { -+ char marker[65]; -+ char value[65]; -+} sys_enclosure_serial = {SYS_ENCLOSURE_SERIAL_MARKER, ""}; -+ -+const char *oem_strings_array[1] = { -+ NULL -+}; -+ -+#endif /* __HVMLOADER_MARKERS_H__ */ -diff -Nur a/tools/firmware/hvmloader/smbios.c b/tools/firmware/hvmloader/smbios.c ---- a/tools/firmware/hvmloader/smbios.c 2009-04-01 14:06:28.000000000 -0400 -+++ b/tools/firmware/hvmloader/smbios.c 2009-04-01 15:34:18.000000000 -0400 -@@ -27,6 +27,7 @@ - #include "util.h" - #include "hypercall.h" - #include "e820.h" -+#include "markers.h" - - static int - write_smbios_tables(void *start, -@@ -54,6 +55,8 @@ - smbios_type_4_init(void *start, unsigned int cpu_number, - char *cpu_manufacturer); - static void * -+smbios_type_11_init(void *start); -+static void * - smbios_type_16_init(void *start, uint32_t memory_size_mb, int nr_mem_devs); - static void * - smbios_type_17_init(void *start, uint32_t memory_size_mb, int instance); -@@ -112,6 +115,7 @@ - do_struct(smbios_type_3_init(p)); - for ( cpu_num = 1; cpu_num <= vcpus; cpu_num++ ) - do_struct(smbios_type_4_init(p, cpu_num, cpu_manufacturer)); -+ do_struct(smbios_type_11_init(p)); - - /* Each 'memory device' covers up to 16GB of address space. */ - nr_mem_devs = (memsize + 0x3fff) >> 14; -@@ -127,6 +131,8 @@ - } - - do_struct(smbios_type_32_init(p)); -+ /* NOTE: future enhancement - vendor specific structures (range 128 - 256) would be -+ processed and added here */ - do_struct(smbios_type_127_init(p)); - - #undef do_struct -@@ -280,9 +286,33 @@ - smbios_type_0_init(void *start, const char *xen_version, - uint32_t xen_major_version, uint32_t xen_minor_version) - { -- struct smbios_type_0 *p = (struct smbios_type_0 *)start; - static const char *smbios_release_date = __SMBIOS_DATE__; -+ struct smbios_type_0 *p = (struct smbios_type_0 *)start; -+ struct hvm_sminfo_table *pa_sm; -+ struct hvm_smtable_header *header; -+ -+ /* if passed a struct, use it */ -+ pa_sm = get_hvm_sminfo_table(); -+ while (pa_sm != NULL) { -+ header = get_sminfo_by_type(pa_sm, 0); -+ if (header == NULL) -+ break; -+ if (header->sm_length < sizeof(struct smbios_type_0)) -+ break; -+ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); -+ -+ /* fix up some bits */ -+ p->header.handle = 0; -+ p->starting_address_segment = 0xe800; -+ p->rom_size = 0; -+ p->characteristics[0] = 0x80; /* PCI is supported */ -+ p->characteristics[2] = 0x08; /* EDD is supported */ -+ p->characteristics_extension_bytes[1] = 0x04; /* Enable Targeted Content Distribution. */ - -+ return (start + header->sm_length); -+ } -+ -+ /* fall back to building our own */ - memset(p, 0, sizeof(*p)); - - p->header.type = 0; -@@ -295,6 +325,7 @@ - p->release_date_str = 3; - p->rom_size = 0; - -+ memset(p->characteristics, 0, 8); - /* BIOS Characteristics. */ - p->characteristics[0] = 0x80; /* PCI is supported */ - p->characteristics[2] = 0x08; /* EDD is supported */ -@@ -308,10 +339,16 @@ - p->embedded_controller_minor = 0xff; - - start += sizeof(struct smbios_type_0); -- strcpy((char *)start, "Xen"); -- start += strlen("Xen") + 1; -- strcpy((char *)start, xen_version); -- start += strlen(xen_version) + 1; -+ strcpy((char *)start, bios_vendor.value); -+ start += strlen(bios_vendor.value) + 1; -+ -+ if ( strlen(bios_version.value) == 0 ) { -+ strncpy(bios_version.value, xen_version, sizeof(bios_version.value)); -+ } -+ -+ strcpy((char *)start, bios_version.value); -+ start += strlen(bios_version.value) + 1; -+ - strcpy((char *)start, smbios_release_date); - start += strlen(smbios_release_date) + 1; - -@@ -326,7 +363,27 @@ - { - char uuid_str[37]; - struct smbios_type_1 *p = (struct smbios_type_1 *)start; -+ int next = 5; -+ struct hvm_sminfo_table *pa_sm; -+ struct hvm_smtable_header *header; -+ -+ /* if passed a struct, use it */ -+ pa_sm = get_hvm_sminfo_table(); -+ while (pa_sm != NULL) { -+ header = get_sminfo_by_type(pa_sm, 1); -+ if (header == NULL) -+ break; -+ if (header->sm_length < sizeof(struct smbios_type_1)) -+ break; -+ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); -+ -+ /* fix up some bits */ -+ p->header.handle = 0x100; -+ -+ return (start + header->sm_length); -+ } - -+ /* fall back to building our own */ - memset(p, 0, sizeof(*p)); - - p->header.type = 1; -@@ -341,20 +398,46 @@ - memcpy(p->uuid, uuid, 16); - - p->wake_up_type = 0x06; /* power switch */ -- p->sku_str = 0; -- p->family_str = 0; - - start += sizeof(struct smbios_type_1); -+ -+ strcpy((char *)start, sys_manufacturer.value); -+ start += strlen(sys_manufacturer.value) + 1; -+ strcpy((char *)start, sys_product_name.value); -+ start += strlen(sys_product_name.value) + 1; -+ -+ if ( strlen(sys_product_version.value) == 0 ) { -+ strncpy(sys_product_version.value, xen_version, sizeof(sys_product_version.value)); -+ } -+ -+ strcpy((char *)start, sys_product_version.value); -+ start += strlen(sys_product_version.value) + 1; -+ -+ if ( strlen(sys_product_serial.value) == 0 ) { -+ uuid_to_string(uuid_str, uuid); -+ strncpy(sys_product_serial.value, uuid_str, sizeof(sys_product_serial.value)); -+ } - -- strcpy((char *)start, "Xen"); -- start += strlen("Xen") + 1; -- strcpy((char *)start, "HVM domU"); -- start += strlen("HVM domU") + 1; -- strcpy((char *)start, xen_version); -- start += strlen(xen_version) + 1; -- uuid_to_string(uuid_str, uuid); -- strcpy((char *)start, uuid_str); -- start += strlen(uuid_str) + 1; -+ strcpy((char *)start, sys_product_serial.value); -+ start += strlen(sys_product_serial.value) + 1; -+ -+ /* no internal defaults for these if the value is not set */ -+ if ( strlen(sys_product_sku.value) != 0 ) { -+ strcpy((char *)start, sys_product_sku.value); -+ start += strlen(sys_product_sku.value) + 1; -+ p->sku_str = next++; -+ } -+ else -+ p->sku_str = 0; -+ -+ if ( strlen(sys_product_family.value) != 0 ) { -+ strcpy((char *)start, sys_product_family.value); -+ start += strlen(sys_product_family.value) + 1; -+ p->family_str = next++; -+ } -+ else -+ p->family_str = 0; -+ - *((uint8_t *)start) = 0; - - return start+1; -@@ -365,7 +448,26 @@ - smbios_type_3_init(void *start) - { - struct smbios_type_3 *p = (struct smbios_type_3 *)start; -- -+ struct hvm_sminfo_table *pa_sm; -+ struct hvm_smtable_header *header; -+ -+ /* if passed a struct, use it */ -+ pa_sm = get_hvm_sminfo_table(); -+ while (pa_sm != NULL) { -+ header = get_sminfo_by_type(pa_sm, 3); -+ if (header == NULL) -+ break; -+ if (header->sm_length < sizeof(struct smbios_type_3)) -+ break; -+ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); -+ -+ /* fix up some bits */ -+ p->header.handle = 0x300; -+ -+ return (start + header->sm_length); -+ } -+ -+ /* fall back to building our own */ - memset(p, 0, sizeof(*p)); - - p->header.type = 3; -@@ -384,8 +486,18 @@ - - start += sizeof(struct smbios_type_3); - -- strcpy((char *)start, "Xen"); -- start += strlen("Xen") + 1; -+ strcpy((char *)start, sys_enclosure_manufacturer.value); -+ start += strlen(sys_enclosure_manufacturer.value) + 1; -+ -+ /* no internal defaults for this if the value is not set */ -+ if ( strlen(sys_enclosure_serial.value) != 0 ) { -+ strcpy((char *)start, sys_enclosure_serial.value); -+ start += strlen(sys_enclosure_serial.value) + 1; -+ p->serial_number_str = 2; -+ } -+ else -+ p->serial_number_str = 0; -+ - *((uint8_t *)start) = 0; - return start+1; - } -@@ -440,6 +552,52 @@ - return start+1; - } - -+/* Type 11 -- OEM Strings */ -+static void * -+smbios_type_11_init(void *start) -+{ -+ struct smbios_type_11 *p = (struct smbios_type_11 *)start; -+ int i = 0; -+ struct hvm_sminfo_table *pa_sm; -+ struct hvm_smtable_header *header; -+ -+ /* if passed a struct, use it */ -+ pa_sm = get_hvm_sminfo_table(); -+ while (pa_sm != NULL) { -+ header = get_sminfo_by_type(pa_sm, 11); -+ if (header == NULL) -+ break; -+ if (header->sm_length < sizeof(struct smbios_type_11)) -+ break; -+ memcpy(start, ((uint8_t*)header + sizeof(struct hvm_smtable_header)), header->sm_length); -+ -+ /* fix up some bits */ -+ p->header.handle = 0xB00; -+ -+ return (start + header->sm_length); -+ } -+ -+ /* fall back to building our own */ -+ -+ if ( oem_strings_array[0] == NULL ) -+ return start; /* no OEM strings to add */ -+ -+ p->header.type = 11; -+ p->header.length = sizeof(struct smbios_type_11); -+ p->header.handle = 0xB00; -+ start += sizeof(struct smbios_type_11); -+ -+ while ( oem_strings_array[i] != NULL ) { -+ strcpy((char *)start, oem_strings_array[i]); -+ start += strlen(oem_strings_array[i]) + 1; -+ i++; -+ } -+ p->count = i; -+ *((uint8_t *)start) = 0; -+ -+ return start+1; -+} -+ - /* Type 16 -- Physical Memory Array */ - static void * - smbios_type_16_init(void *start, uint32_t memsize, int nr_mem_devs) -diff -Nur a/tools/firmware/hvmloader/smbios_types.h b/tools/firmware/hvmloader/smbios_types.h ---- a/tools/firmware/hvmloader/smbios_types.h 2009-04-01 14:06:28.000000000 -0400 -+++ b/tools/firmware/hvmloader/smbios_types.h 2009-04-01 15:28:52.000000000 -0400 -@@ -115,6 +115,12 @@ - uint8_t upgrade; - } __attribute__ ((packed)); - -+/* SMBIOS type 11 - OEM Strings */ -+struct smbios_type_11 { -+ struct smbios_structure_header header; -+ uint8_t count; -+} __attribute__ ((packed)); -+ - /* SMBIOS type 16 - Physical Memory Array - * Associated with one type 17 (Memory Device). - */ -diff -Nur a/tools/firmware/hvmloader/util.c b/tools/firmware/hvmloader/util.c ---- a/tools/firmware/hvmloader/util.c 2009-04-01 14:06:28.000000000 -0400 -+++ b/tools/firmware/hvmloader/util.c 2009-04-01 14:50:01.000000000 -0400 -@@ -542,32 +542,32 @@ - asm volatile ( "ud2" ); - } - --static void validate_hvm_info(struct hvm_info_table *t) -+static int validate_hvm_info_table(uint8_t *table, uint32_t table_length, const char *table_sig, const char *sig, uint32_t sig_length) - { -- uint8_t *ptr = (uint8_t *)t; - uint8_t sum = 0; - int i; - -- if ( strncmp(t->signature, "HVM INFO", 8) ) -- { -- printf("Bad hvm info signature\n"); -- BUG(); -+ if (table_length == 0) { -+ printf("Empty HVM info table: %.*s\n", sig_length, sig); - } - -- if ( t->length < sizeof(struct hvm_info_table) ) -+ /* NOTE removed BUG() checking during xc merge because not all xc tables -+ are present - do a BUG() in get_hvm_info_table() only */ -+ -+ /* strncmp(t->signature, signature, sig_length) */ -+ for ( i = 0; i < sig_length; i++ ) - { -- printf("Bad hvm info length\n"); -- BUG(); -+ if ( table_sig[i] != sig[i] ) -+ { -+ printf("Bad HVM info signature for: %.*s\n", sig_length, sig); -+ return 0; -+ } - } - -- for ( i = 0; i < t->length; i++ ) -- sum += ptr[i]; -+ for ( i = 0; i < table_length; i++ ) -+ sum += table[i]; - -- if ( sum != 0 ) -- { -- printf("Bad hvm info checksum\n"); -- BUG(); -- } -+ return (sum == 0); - } - - struct hvm_info_table *get_hvm_info_table(void) -@@ -580,7 +580,11 @@ - - t = (struct hvm_info_table *)HVM_INFO_PADDR; - -- validate_hvm_info(t); -+ if ( !validate_hvm_info_table((uint8_t*)t, t->length, t->signature, "HVM INFO", 8) ) -+ { -+ printf("Bad HVM info table\n"); -+ BUG(); -+ } - - table = t; - -@@ -650,6 +654,52 @@ - return ((hpet_id >> 16) == 0x8086); - } - -+struct hvm_sminfo_table *get_hvm_sminfo_table(void) -+{ -+ static struct hvm_sminfo_table *table = NULL; -+ static int validated = 0; -+ struct hvm_sminfo_table *t; -+ -+ if ( validated ) -+ return table; -+ -+ t = (struct hvm_sminfo_table *)HVM_SMINFO_PADDR; -+ -+ if ( (t->total_length == 0) && (t->sm_count == 0) ) { -+ printf("Empty HVM SMBIOS info table\n"); -+ validated = 1; -+ return table; -+ } -+ -+ if ( validate_hvm_info_table((uint8_t*)t, t->total_length + sizeof(struct hvm_sminfo_table), t->signature, "SM INFO", 7) ) -+ table = t; -+ else -+ printf("Bad or missing HVM SMBIOS info table\n"); -+ validated = 1; -+ -+ return table; -+} -+ -+struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type) -+{ -+ struct hvm_smtable_header *header = -+ (struct hvm_smtable_header*)((uint8_t*)pa_sm + sizeof(struct hvm_sminfo_table)); -+ uint32_t count; -+ uint8_t *ptr; -+ -+ for (count = 0; count < pa_sm->sm_count; count++) { -+ if (header->sm_length == 0) { -+ printf("Invalid SMINFO tables passed to HVM loader."); -+ return NULL; -+ } -+ ptr = ((uint8_t*)header + sizeof(struct hvm_smtable_header)); -+ if (ptr[0] == type) -+ return header; -+ header = (struct hvm_smtable_header*)(ptr + header->sm_length); -+ } -+ return NULL; -+} -+ - /* - * Local variables: - * mode: C -diff -Nur a/tools/firmware/hvmloader/util.h b/tools/firmware/hvmloader/util.h ---- a/tools/firmware/hvmloader/util.h 2009-04-01 14:06:28.000000000 -0400 -+++ b/tools/firmware/hvmloader/util.h 2009-04-01 14:50:19.000000000 -0400 -@@ -111,6 +111,10 @@ - struct hvm_info_table *get_hvm_info_table(void); - #define hvm_info (get_hvm_info_table()) - -+/* HVM-build SMBIOS/ACPI info extensions */ -+struct hvm_sminfo_table *get_hvm_sminfo_table(void); -+struct hvm_smtable_header * get_sminfo_by_type(struct hvm_sminfo_table *pa_sm, uint8_t type); -+ - /* String and memory functions */ - int strcmp(const char *cs, const char *ct); - int strncmp(const char *s1, const char *s2, uint32_t n); -diff -Nur a/xen/include/public/hvm/hvm_info_table.h b/xen/include/public/hvm/hvm_info_table.h ---- a/xen/include/public/hvm/hvm_info_table.h 2009-04-01 14:06:32.000000000 -0400 -+++ b/xen/include/public/hvm/hvm_info_table.h 2009-04-01 14:24:54.000000000 -0400 -@@ -28,6 +28,12 @@ - #define HVM_INFO_PFN 0x09F - #define HVM_INFO_OFFSET 0x800 - #define HVM_INFO_PADDR ((HVM_INFO_PFN << 12) + HVM_INFO_OFFSET) -+#define HVM_INFO_MAX 0x400 -+#define HVM_SMINFO_OFFSET 0x0 -+#define HVM_SMINFO_PADDR ((HVM_INFO_PFN << 12) + HVM_SMINFO_OFFSET) -+#define HVM_SMINFO_MAX 0x800 -+ -+#define HVM_SMINFO_EXTENSIONS 1 - - struct hvm_info_table { - char signature[8]; /* "HVM INFO" */ -@@ -66,4 +72,15 @@ - uint32_t high_mem_pgend; - }; - -+struct hvm_sminfo_table { -+ char signature[7]; /* "SM INFO" */ -+ uint8_t checksum; -+ uint32_t total_length; /* beginning after this stucture */ -+ uint32_t sm_count; -+}; -+ -+struct hvm_smtable_header { -+ uint32_t sm_length; /* beginning after this stucture, includes fixed table, string list, and terminator */ -+}; -+ - #endif /* __XEN_PUBLIC_HVM_HVM_INFO_TABLE_H__ */ diff --git a/xen-3.4/status b/xen-3.4/status deleted file mode 100644 index e69de29..0000000 diff --git a/xen-3.4/thermal-management b/xen-3.4/thermal-management deleted file mode 100644 index 519e235..0000000 --- a/xen-3.4/thermal-management +++ /dev/null @@ -1,296 +0,0 @@ -diff -Nur a/tools/firmware/hvmloader/acpi/ssdt_pm.asl b/tools/firmware/hvmloader/acpi/ssdt_pm.asl ---- a/tools/firmware/hvmloader/acpi/ssdt_pm.asl 2009-04-01 17:16:42.000000000 -0400 -+++ b/tools/firmware/hvmloader/acpi/ssdt_pm.asl 2009-04-01 17:18:03.000000000 -0400 -@@ -95,6 +95,14 @@ - P88, 8 - } - -+ /*OperationRegion for thermal zone */ -+ OperationRegion (PRT4, SystemIO, 0x90, 0x04) -+ Field (PRT4, WordAcc, NoLock, Preserve) -+ { -+ P90, 16, -+ P92, 16 -+ } -+ - /* OperationRegion for Power Button */ - OperationRegion (PBOP, SystemIO, 0x200, 0x01) - Field (PBOP, ByteAcc, NoLock, WriteAsZeros) -@@ -529,6 +537,24 @@ - } - } - -+ Scope (\_TZ) -+ { -+ ThermalZone (THM) -+ { -+ Method (_CRT, 0, NotSerialized) -+ { -+ Store(\_SB.P92, Local0) -+ Return (Local0) -+ } -+ -+ Method (_TMP, 0, NotSerialized) -+ { -+ Store(\_SB.P90, Local0) -+ Return (Local0) -+ } -+ } -+ } -+ - /* Wire GPE events to notify power state - * changes like ac power to battery use etc. - */ -diff -Nur a/tools/xenpmd/xenpmd.c b/tools/xenpmd/xenpmd.c ---- a/tools/xenpmd/xenpmd.c 2009-04-01 17:16:42.000000000 -0400 -+++ b/tools/xenpmd/xenpmd.c 2009-04-01 17:22:49.000000000 -0400 -@@ -93,13 +93,17 @@ - extern void acpi_events_cleanup(void); - - #ifdef RUN_IN_SIMULATE_MODE -- #define BATTERY_DIR_PATH "/tmp/battery" -- #define BATTERY_INFO_FILE_PATH "/tmp/battery/%s/info" -- #define BATTERY_STATE_FILE_PATH "/tmp/battery/%s/state" -+ #define BATTERY_DIR_PATH "/tmp/battery" -+ #define BATTERY_INFO_FILE_PATH "/tmp/battery/%s/info" -+ #define BATTERY_STATE_FILE_PATH "/tmp/battery/%s/state" -+ #define THERMAL_TRIP_POINTS_FILE "/tmp/thermal_zone/%s/trip_points" -+ #define THERMAL_TEMPERATURE_FILE "/tmp/thermal_zone/%s/temperature" - #else -- #define BATTERY_DIR_PATH "/proc/acpi/battery" -- #define BATTERY_INFO_FILE_PATH "/proc/acpi/battery/%s/info" -- #define BATTERY_STATE_FILE_PATH "/proc/acpi/battery/%s/state" -+ #define BATTERY_DIR_PATH "/proc/acpi/battery" -+ #define BATTERY_INFO_FILE_PATH "/proc/acpi/battery/%s/info" -+ #define BATTERY_STATE_FILE_PATH "/proc/acpi/battery/%s/state" -+ #define THERMAL_TRIP_POINTS_FILE "/proc/acpi/thermal_zone/%s/trip_points" -+ #define THERMAL_TEMPERATURE_FILE "/proc/acpi/thermal_zone/%s/temperature" - #endif - - FILE *get_next_battery_file(DIR *battery_dir, -@@ -448,44 +452,188 @@ - xs_write(xs, XBT_NULL, "/pm/bst", val, 35); - } - --int wait_for_and_update_battery_status_request(void) -+void update_battery_status(void) - { - DIR *dir; -- int ret = 0; -- unsigned int count; - struct battery_status status; - -- while ( true ) -- { -- /* KN:@TODO - It is rather inefficient to not cache the file handle. -- * Switch to caching file handle. -- */ -- dir = opendir(BATTERY_DIR_PATH); -- if ( !dir ) -- return 0; -+ /* KN:@TODO - It is rather inefficient to not cache the file handle. -+ * Switch to caching file handle. -+ */ -+ dir = opendir(BATTERY_DIR_PATH); -+ if ( !dir ) -+ return; - -- while ( get_next_battery_info_or_status(dir, BST, (void *)&status) ) -- { -+ while ( get_next_battery_info_or_status(dir, BST, (void *)&status) ) -+ { - #ifdef RUN_STANDALONE -- print_battery_status(&status); -+ print_battery_status(&status); - #endif -- if ( status.present == YES ) -- { -- write_battery_status_to_xenstore(&status); -- ret = 1; -- /* rethink this; though I have never seen, there might be -- * systems out there with more than one battery device -- * present -- */ -- break; -- } -+ if ( status.present == YES ) -+ { -+ write_battery_status_to_xenstore(&status); -+ /* rethink this; though I have never seen, there might be -+ * systems out there with more than one battery device -+ * present -+ */ -+ break; - } -- closedir(dir); -- xs_watch(xs, "/pm/events", "refreshbatterystatus"); -- xs_read_watch(xs, &count); - } - -- return ret; -+ closedir(dir); -+ return; -+} -+ -+int open_thermal_files(char *subdir, FILE **trip_points_file, FILE **temp_file) -+{ -+ char trip_points_file_name[64]; -+ char temperature_file_name[64]; -+ -+ snprintf(trip_points_file_name, 64, THERMAL_TRIP_POINTS_FILE, subdir); -+ snprintf(temperature_file_name, 64, THERMAL_TEMPERATURE_FILE, subdir); -+ -+ *trip_points_file = fopen(trip_points_file_name, "r"); -+ *temp_file = fopen(temperature_file_name, "r"); -+ -+ if ( *trip_points_file == NULL || *temp_file == NULL ) -+ { -+ if ( *trip_points_file ) -+ { -+ fclose(*trip_points_file); -+ *trip_points_file = NULL; -+ } -+ -+ if ( *temp_file ) -+ { -+ fclose(*temp_file); -+ *temp_file = NULL; -+ } -+ return 0; -+ } -+ -+ return 1; -+} -+ -+/* Note: Below is the simplest approach based on studying the -+ * different thermal zones exposed by the OEMs at this point. -+ * In specific Dell E6*00, Lenovo T400, HP 6930p was taken into -+ * consideration before arriving at which thermal zone to expose -+ * to the guest. But, if we choose to expand our thermal zone -+ * implementation to be closer to the underlying firmware, we -+ * should revisit the below. -+ */ -+void get_thermal_files(FILE **trip_points_file, FILE **temp_file) -+{ -+ if ( open_thermal_files("/THM", trip_points_file, temp_file) ) -+ return; -+ -+ if ( open_thermal_files("/CPUZ", trip_points_file, temp_file) ) -+ return; -+ -+ if ( open_thermal_files("/THM1", trip_points_file, temp_file) ) -+ return; -+ -+ open_thermal_files("/THM0", trip_points_file, temp_file); -+} -+ -+/* @TODO: KN: There is similar code in one other place. -+ * consolidate it to one place. -+ */ -+int get_attribute_value(char *line_info, char *attribute_name) -+{ -+ char attrib_name[64]; -+ char attrib_value[64]; -+ char *delimiter; -+ unsigned long length; -+ -+ length = strlen(line_info); -+ delimiter = (char *) strchr( line_info, ':'); -+ if ( (!delimiter) || (delimiter == line_info) || -+ (delimiter == line_info + length) ) -+ return 0; -+ -+ strncpy(attrib_name, line_info, delimiter-line_info); -+ if ( !strstr(attrib_name, attribute_name) ) -+ return 0; -+ -+ while ( *(delimiter+1) == ' ' ) -+ { -+ delimiter++; -+ if ( delimiter+1 == line_info + length) -+ return 0; -+ } -+ -+ strncpy(attrib_value, delimiter+1, -+ (unsigned long)line_info + length -(unsigned long)delimiter); -+ return strtoull(attrib_value, NULL, 10); -+} -+ -+int get_thermalzone_value(FILE *file, char *attribute_name) -+{ -+ char line_info[256]; -+ int attribute_value; -+ -+ memset(line_info, 0, 256); -+ while ( fgets(line_info, 1024, file) != NULL ) -+ { -+ attribute_value = get_attribute_value(line_info, attribute_name); -+ if ( attribute_value > 0 ) -+ return attribute_value; -+ memset(line_info, 0, 256); -+ } -+ -+ return 0; -+} -+ -+void update_thermal_info(void) -+{ -+ char buffer[32]; -+ int current_temp, critical_trip_point; -+ FILE *trip_points_file = NULL, *temp_file = NULL; -+ -+ get_thermal_files(&trip_points_file, &temp_file); -+ if ( trip_points_file == NULL || temp_file == NULL ) -+ return; -+ -+ current_temp = get_thermalzone_value(temp_file, "temperature"); -+ critical_trip_point = get_thermalzone_value(trip_points_file, "critical"); -+ -+ fclose(trip_points_file); -+ fclose(temp_file); -+ -+ if ( current_temp <= 0 || critical_trip_point <= 0 ) -+ return; -+ -+ snprintf(buffer, 32, "%d", current_temp); -+ xs_write(xs, XBT_NULL, "/pm/current_temperature", buffer, strlen(buffer)); -+ -+ snprintf(buffer, 32, "%d", critical_trip_point); -+ xs_write(xs, XBT_NULL, "/pm/critical_temperature", buffer, strlen(buffer)); -+} -+ -+void wait_for_and_update_power_mgmt_info(void) -+{ -+ char **buffer; -+ unsigned int count; -+ -+ update_battery_status(); -+ update_thermal_info(); -+ -+ xs_watch(xs, "/pm/events", "refreshbatterystatus"); -+ xs_watch(xs, "/pm/events", "refreshthermalinfo"); -+ -+ while ( true ) -+ { -+ buffer = xs_read_watch(xs, &count); -+ if ( buffer == NULL ) -+ continue; -+ if (!strcmp(buffer[XS_WATCH_TOKEN], "refreshbatterystatus")) { -+ update_battery_status(); -+ } else if (!strcmp(buffer[XS_WATCH_TOKEN], "refreshthermalinfo")) { -+ update_thermal_info(); -+ } -+ free(buffer); -+ } - } - - #ifndef RUN_STANDALONE -@@ -539,7 +687,7 @@ - return 0; - } - -- wait_for_and_update_battery_status_request(); -+ wait_for_and_update_power_mgmt_info(); - acpi_events_cleanup(); - xs_daemon_close(xs); - return 0;