leandrof/u-boot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge git://git.denx.de/u-boot-x86

Browse Source 
Conflicts:
	arch/x86/cpu/Makefile

Signed-off-by: Tom Rini <trini@ti.com>
This commit is contained in:
Tom Rini 2014-11-24 12:00:00 -05:00
commit 746667f1e5
86 changed files with 8300 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
Makefile
View File

@ -746,6 +746,9 @@ ALL-$(CONFIG_SPL) += $(CONFIG_SPL_TARGET:"%"=%)
endif
ALL-$(CONFIG_REMAKE_ELF) += u-boot.elf
# We can't do this yet due to the need for binary blobs
# ALL-$(CONFIG_X86_RESET_VECTOR) += u-boot.rom
# enable combined SPL/u-boot/dtb rules for tegra
ifneq ($(CONFIG_TEGRA),)
ifeq ($(CONFIG_SPL),y)
@ -814,7 +817,8 @@ OBJCOPYFLAGS_u-boot.srec := -O srec
u-boot.hex u-boot.srec: u-boot FORCE
$(call if_changed,objcopy)
OBJCOPYFLAGS_u-boot.bin := -O binary
OBJCOPYFLAGS_u-boot.bin := -O binary \
$(if $(CONFIG_X86_RESET_VECTOR),-R .start16 -R .resetvec)
binary_size_check: u-boot.bin FORCE
@file_size=$(shell wc -c u-boot.bin | awk '{print $$1}') ; \
@ -953,6 +957,36 @@ u-boot-nand.gph: u-boot.bin FORCE
$(call if_changed,mkimage)
@dd if=/dev/zero bs=8 count=1 2>/dev/null >> $@
# x86 uses a large ROM. We fill it with 0xff, put the 16-bit stuff (including
# reset vector) at the top, Intel ME descriptor at the bottom, and U-Boot in
# the middle.
ifneq ($(CONFIG_X86_RESET_VECTOR),)
rom: u-boot.rom FORCE
u-boot.rom: u-boot-x86-16bit.bin u-boot-dtb.bin \
$(srctree)/board/$(BOARDDIR)/mrc.bin
$(objtree)/tools/ifdtool -c -r $(CONFIG_ROM_SIZE) u-boot.tmp
if [ -n "$(CONFIG_HAVE_INTEL_ME)" ]; then \
$(objtree)/tools/ifdtool -D \
$(srctree)/board/$(BOARDDIR)/descriptor.bin u-boot.tmp; \
$(objtree)/tools/ifdtool \
-i ME:$(srctree)/board/$(BOARDDIR)/me.bin u-boot.tmp; \
fi
$(objtree)/tools/ifdtool -w \
$(CONFIG_SYS_TEXT_BASE):$(objtree)/u-boot-dtb.bin u-boot.tmp
$(objtree)/tools/ifdtool -w \
$(CONFIG_X86_MRC_START):$(srctree)/board/$(BOARDDIR)/mrc.bin \
u-boot.tmp
$(objtree)/tools/ifdtool -w \
$(CONFIG_SYS_X86_START16):$(objtree)/u-boot-x86-16bit.bin \
u-boot.tmp
mv u-boot.tmp $@
OBJCOPYFLAGS_u-boot-x86-16bit.bin := -O binary -j .start16 -j .resetvec
u-boot-x86-16bit.bin: u-boot FORCE
$(call if_changed,objcopy)
endif
ifneq ($(CONFIG_SUNXI),)
OBJCOPYFLAGS_u-boot-sunxi-with-spl.bin = -I binary -O binary \
--pad-to=$(CONFIG_SPL_PAD_TO) --gap-fill=0xff

74
arch/x86/Kconfig
View File

@ -12,9 +12,81 @@ choice
config TARGET_COREBOOT
bool "Support coreboot"
help
This target is used for running U-Boot on top of Coreboot. In
this case Coreboot does the early inititalisation, and U-Boot
takes over once the RAM, video and CPU are fully running.
U-Boot is loaded as a fallback payload from Coreboot, in
Coreboot terminology. This method was used for the Chromebook
Pixel when launched.
config TARGET_CHROMEBOOK_LINK
bool "Support Chromebook link"
help
This is the Chromebook Pixel released in 2013. It uses an Intel
i5 Ivybridge which is a die-shrink of Sandybridge, with 4GB of
SDRAM. It has a Panther Point platform controller hub, PCIe
WiFi and Bluetooth. It also includes a 720p webcam, USB SD
reader, microphone and speakers, display port and 32GB SATA
solid state drive. There is a Chrome OS EC connected on LPC,
and it provides a 2560x1700 high resolution touch-enabled LCD
display.
endchoice
source "board/chromebook-x86/coreboot/Kconfig"
config RAMBASE
hex
default 0x100000
config RAMTOP
hex
default 0x200000
config XIP_ROM_SIZE
hex
default 0x10000
config CPU_ADDR_BITS
int
default 36
config HPET_ADDRESS
hex
default 0xfed00000 if !HPET_ADDRESS_OVERRIDE
config SMM_TSEG
bool
default n
config SMM_TSEG_SIZE
hex
config ROM_SIZE
hex
default 0x800000
config HAVE_INTEL_ME
bool "Platform requires Intel Management Engine"
help
Newer higher-end devices have an Intel Management Engine (ME)
which is a very large binary blob (typically 1.5MB) which is
required for the platform to work. This enforces a particular
SPI flash format. You will need to supply the me.bin file in
your board directory.
config X86_RAMTEST
bool "Perform a simple RAM test after SDRAM initialisation"
help
If there is something wrong with SDRAM then the platform will
often crash within U-Boot or the kernel. This option enables a
very simple RAM test that quickly checks whether the SDRAM seems
to work correctly. It is not exhaustive but can save time by
detecting obvious failures.
source "arch/x86/cpu/ivybridge/Kconfig"
source "board/coreboot/coreboot/Kconfig"
source "board/google/chromebook_link/Kconfig"
endmenu

1
arch/x86/config.mk
View File

@ -15,7 +15,6 @@ PF_CPPFLAGS_X86 := $(call cc-option, -fno-toplevel-reorder, \
$(call cc-option, -mpreferred-stack-boundary=2)
PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_X86)
PLATFORM_CPPFLAGS += -fno-dwarf2-cfi-asm
PLATFORM_CPPFLAGS += -DREALMODE_BASE=0x7c0
PLATFORM_CPPFLAGS += -march=i386 -m32
# Support generic board on x86

1
arch/x86/cpu/Makefile
View File

@ -13,3 +13,4 @@ obj-$(CONFIG_X86_RESET_VECTOR) += resetvec.o start16.o
obj-y += interrupts.o cpu.o call64.o
obj-$(CONFIG_SYS_COREBOOT) += coreboot/
obj-$(CONFIG_PCI) += pci.o

42
arch/x86/cpu/coreboot/coreboot.c
View File

@ -13,25 +13,25 @@
#include <ns16550.h>
#include <asm/msr.h>
#include <asm/cache.h>
#include <asm/cpu.h>
#include <asm/io.h>
#include <asm/arch-coreboot/tables.h>
#include <asm/arch-coreboot/sysinfo.h>
#include <asm/arch/tables.h>
#include <asm/arch/sysinfo.h>
#include <asm/arch/timestamp.h>
DECLARE_GLOBAL_DATA_PTR;
/*
* Miscellaneous platform dependent initializations
*/
int cpu_init_f(void)
int arch_cpu_init(void)
{
int ret = get_coreboot_info(&lib_sysinfo);
if (ret != 0)
if (ret != 0) {
printf("Failed to parse coreboot tables.\n");
return ret;
}
timestamp_init();
return ret;
return x86_cpu_init_f();
}
int board_early_init_f(void)
@ -50,27 +50,9 @@ int board_early_init_r(void)
return 0;
}
void show_boot_progress(int val)
int print_cpuinfo(void)
{
#if MIN_PORT80_KCLOCKS_DELAY
/*
* Scale the time counter reading to avoid using 64 bit arithmetics.
* Can't use get_timer() here becuase it could be not yet
* initialized or even implemented.
*/
if (!gd->arch.tsc_prev) {
gd->arch.tsc_base_kclocks = rdtsc() / 1000;
gd->arch.tsc_prev = 0;
} else {
uint32_t now;
do {
now = rdtsc() / 1000 - gd->arch.tsc_base_kclocks;
} while (now < (gd->arch.tsc_prev + MIN_PORT80_KCLOCKS_DELAY));
gd->arch.tsc_prev = now;
}
#endif
outb(val, 0x80);
return default_print_cpuinfo();
}
int last_stage_init(void)
@ -98,7 +80,7 @@ int board_eth_init(bd_t *bis)
#define MTRRphysBase_MSR(reg) (0x200 + 2 * (reg))
#define MTRRphysMask_MSR(reg) (0x200 + 2 * (reg) + 1)
int board_final_cleanup(void)
void board_final_cleanup(void)
{
/* Un-cache the ROM so the kernel has one
* more MTRR available.
@ -120,8 +102,6 @@ int board_final_cleanup(void)
/* Issue SMI to Coreboot to lock down ME and registers */
printf("Finalizing Coreboot\n");
outb(0xcb, 0xb2);
return 0;
}
void panic_puts(const char *str)

2
arch/x86/cpu/coreboot/ipchecksum.c
View File

@ -30,7 +30,7 @@
*/
#include <compiler.h>
#include <asm/arch-coreboot/ipchecksum.h>
#include <asm/arch/ipchecksum.h>
unsigned short ipchksum(const void *vptr, unsigned long nbytes)
{

22
arch/x86/cpu/coreboot/pci.c
View File

@ -13,8 +13,6 @@
#include <pci.h>
#include <asm/pci.h>
static struct pci_controller coreboot_hose;
static void config_pci_bridge(struct pci_controller *hose, pci_dev_t dev,
struct pci_config_table *table)
{
@ -31,19 +29,13 @@ static struct pci_config_table pci_coreboot_config_table[] = {
{}
};
void pci_init_board(void)
void board_pci_setup_hose(struct pci_controller *hose)
{
coreboot_hose.config_table = pci_coreboot_config_table;
coreboot_hose.first_busno = 0;
coreboot_hose.last_busno = 0;
hose->config_table = pci_coreboot_config_table;
hose->first_busno = 0;
hose->last_busno = 0;
pci_set_region(coreboot_hose.regions + 0, 0x0, 0x0, 0xffffffff,
PCI_REGION_MEM);
coreboot_hose.region_count = 1;
pci_setup_type1(&coreboot_hose);
pci_register_hose(&coreboot_hose);
pci_hose_scan(&coreboot_hose);
pci_set_region(hose->regions + 0, 0x0, 0x0, 0xffffffff,
PCI_REGION_MEM);
hose->region_count = 1;
}

15
arch/x86/cpu/coreboot/sdram.c
View File

@ -11,8 +11,10 @@
#include <asm/e820.h>
#include <asm/u-boot-x86.h>
#include <asm/global_data.h>
#include <asm/init_helpers.h>
#include <asm/processor.h>
#include <asm/sections.h>
#include <asm/zimage.h>
#include <asm/arch/sysinfo.h>
#include <asm/arch/tables.h>
@ -79,7 +81,7 @@ ulong board_get_usable_ram_top(ulong total_size)
return (ulong)dest_addr;
}
int dram_init_f(void)
int dram_init(void)
{
int i;
phys_size_t ram_size = 0;
@ -94,10 +96,11 @@ int dram_init_f(void)
gd->ram_size = ram_size;
if (ram_size == 0)
return -1;
return 0;
return calculate_relocation_address();
}
int dram_init_banksize(void)
void dram_init_banksize(void)
{
int i, j;
@ -114,10 +117,4 @@ int dram_init_banksize(void)
}
}
}
return 0;
}
int dram_init(void)
{
return dram_init_banksize();
}

6
arch/x86/cpu/coreboot/tables.c
View File

@ -8,9 +8,9 @@
*/
#include <common.h>
#include <asm/arch-coreboot/ipchecksum.h>
#include <asm/arch-coreboot/sysinfo.h>
#include <asm/arch-coreboot/tables.h>
#include <asm/arch/ipchecksum.h>
#include <asm/arch/sysinfo.h>
#include <asm/arch/tables.h>
/*
* This needs to be in the .data section so that it's copied over during

303
arch/x86/cpu/cpu.c
View File

@ -13,6 +13,9 @@
* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
* Alex Zuepke <azu@sysgo.de>
*
* Part of this file is adapted from coreboot
* src/arch/x86/lib/cpu.c
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -22,11 +25,14 @@
#include <malloc.h>
#include <asm/control_regs.h>
#include <asm/cpu.h>
#include <asm/post.h>
#include <asm/processor.h>
#include <asm/processor-flags.h>
#include <asm/interrupt.h>
#include <linux/compiler.h>
DECLARE_GLOBAL_DATA_PTR;
/*
* Constructor for a conventional segment GDT (or LDT) entry
* This is a macro so it can be used in initialisers
@ -43,6 +49,52 @@ struct gdt_ptr {
u32 ptr;
} __packed;
struct cpu_device_id {
unsigned vendor;
unsigned device;
};
struct cpuinfo_x86 {
uint8_t x86; /* CPU family */
uint8_t x86_vendor; /* CPU vendor */
uint8_t x86_model;
uint8_t x86_mask;
};
/*
* List of cpu vendor strings along with their normalized
* id values.
*/
static struct {
int vendor;
const char *name;
} x86_vendors[] = {
{ X86_VENDOR_INTEL, "GenuineIntel", },
{ X86_VENDOR_CYRIX, "CyrixInstead", },
{ X86_VENDOR_AMD, "AuthenticAMD", },
{ X86_VENDOR_UMC, "UMC UMC UMC ", },
{ X86_VENDOR_NEXGEN, "NexGenDriven", },
{ X86_VENDOR_CENTAUR, "CentaurHauls", },
{ X86_VENDOR_RISE, "RiseRiseRise", },
{ X86_VENDOR_TRANSMETA, "GenuineTMx86", },
{ X86_VENDOR_TRANSMETA, "TransmetaCPU", },
{ X86_VENDOR_NSC, "Geode by NSC", },
{ X86_VENDOR_SIS, "SiS SiS SiS ", },
};
static const char *const x86_vendor_name[] = {
[X86_VENDOR_INTEL] = "Intel",
[X86_VENDOR_CYRIX] = "Cyrix",
[X86_VENDOR_AMD] = "AMD",
[X86_VENDOR_UMC] = "UMC",
[X86_VENDOR_NEXGEN] = "NexGen",
[X86_VENDOR_CENTAUR] = "Centaur",
[X86_VENDOR_RISE] = "Rise",
[X86_VENDOR_TRANSMETA] = "Transmeta",
[X86_VENDOR_NSC] = "NSC",
[X86_VENDOR_SIS] = "SiS",
};
static void load_ds(u32 segment)
{
asm volatile("movl %0, %%ds" : : "r" (segment * X86_GDT_ENTRY_SIZE));
@ -115,6 +167,129 @@ int __weak x86_cleanup_before_linux(void)
return 0;
}
/*
* Cyrix CPUs without cpuid or with cpuid not yet enabled can be detected
* by the fact that they preserve the flags across the division of 5/2.
* PII and PPro exhibit this behavior too, but they have cpuid available.
*/
/*
* Perform the Cyrix 5/2 test. A Cyrix won't change
* the flags, while other 486 chips will.
*/
static inline int test_cyrix_52div(void)
{
unsigned int test;
__asm__ __volatile__(
"sahf\n\t" /* clear flags (%eax = 0x0005) */
"div %b2\n\t" /* divide 5 by 2 */
"lahf" /* store flags into %ah */
: "=a" (test)
: "0" (5), "q" (2)
: "cc");
/* AH is 0x02 on Cyrix after the divide.. */
return (unsigned char) (test >> 8) == 0x02;
}
/*
* Detect a NexGen CPU running without BIOS hypercode new enough
* to have CPUID. (Thanks to Herbert Oppmann)
*/
static int deep_magic_nexgen_probe(void)
{
int ret;
__asm__ __volatile__ (
" movw $0x5555, %%ax\n"
" xorw %%dx,%%dx\n"
" movw $2, %%cx\n"
" divw %%cx\n"
" movl $0, %%eax\n"
" jnz 1f\n"
" movl $1, %%eax\n"
"1:\n"
: "=a" (ret) : : "cx", "dx");
return ret;
}
static bool has_cpuid(void)
{
return flag_is_changeable_p(X86_EFLAGS_ID);
}
static int build_vendor_name(char *vendor_name)
{
struct cpuid_result result;
result = cpuid(0x00000000);
unsigned int *name_as_ints = (unsigned int *)vendor_name;
name_as_ints[0] = result.ebx;
name_as_ints[1] = result.edx;
name_as_ints[2] = result.ecx;
return result.eax;
}
static void identify_cpu(struct cpu_device_id *cpu)
{
char vendor_name[16];
int i;
vendor_name[0] = '\0'; /* Unset */
cpu->device = 0; /* fix gcc 4.4.4 warning */
/* Find the id and vendor_name */
if (!has_cpuid()) {
/* Its a 486 if we can modify the AC flag */
if (flag_is_changeable_p(X86_EFLAGS_AC))
cpu->device = 0x00000400; /* 486 */
else
cpu->device = 0x00000300; /* 386 */
if ((cpu->device == 0x00000400) && test_cyrix_52div()) {
memcpy(vendor_name, "CyrixInstead", 13);
/* If we ever care we can enable cpuid here */
}
/* Detect NexGen with old hypercode */
else if (deep_magic_nexgen_probe())
memcpy(vendor_name, "NexGenDriven", 13);
}
if (has_cpuid()) {
int cpuid_level;
cpuid_level = build_vendor_name(vendor_name);
vendor_name[12] = '\0';
/* Intel-defined flags: level 0x00000001 */
if (cpuid_level >= 0x00000001) {
cpu->device = cpuid_eax(0x00000001);
} else {
/* Have CPUID level 0 only unheard of */
cpu->device = 0x00000400;
}
}
cpu->vendor = X86_VENDOR_UNKNOWN;
for (i = 0; i < ARRAY_SIZE(x86_vendors); i++) {
if (memcmp(vendor_name, x86_vendors[i].name, 12) == 0) {
cpu->vendor = x86_vendors[i].vendor;
break;
}
}
}
static inline void get_fms(struct cpuinfo_x86 *c, uint32_t tfms)
{
c->x86 = (tfms >> 8) & 0xf;
c->x86_model = (tfms >> 4) & 0xf;
c->x86_mask = tfms & 0xf;
if (c->x86 == 0xf)
c->x86 += (tfms >> 20) & 0xff;
if (c->x86 >= 0x6)
c->x86_model += ((tfms >> 16) & 0xF) << 4;
}
int x86_cpu_init_f(void)
{
const u32 em_rst = ~X86_CR0_EM;
@ -128,9 +303,22 @@ int x86_cpu_init_f(void)
"movl %%eax, %%cr0\n" \
: : "i" (em_rst), "i" (mp_ne_set) : "eax");
/* identify CPU via cpuid and store the decoded info into gd->arch */
if (has_cpuid()) {
struct cpu_device_id cpu;
struct cpuinfo_x86 c;
identify_cpu(&cpu);
get_fms(&c, cpu.device);
gd->arch.x86 = c.x86;
gd->arch.x86_vendor = cpu.vendor;
gd->arch.x86_model = c.x86_model;
gd->arch.x86_mask = c.x86_mask;
gd->arch.x86_device = cpu.device;
}
return 0;
}
int cpu_init_f(void) __attribute__((weak, alias("x86_cpu_init_f")));
int x86_cpu_init_r(void)
{
@ -198,14 +386,13 @@ asm(".globl generate_gpf\n"
"generate_gpf:\n"
"ljmp $0x70, $0x47114711\n");
void __reset_cpu(ulong addr)
__weak void reset_cpu(ulong addr)
{
printf("Resetting using x86 Triple Fault\n");
set_vector(13, generate_gpf); /* general protection fault handler */
set_vector(8, generate_gpf); /* double fault handler */
generate_gpf(); /* start the show */
}
void reset_cpu(ulong addr) __attribute__((weak, alias("__reset_cpu")));
int dcache_status(void)
{
@ -279,55 +466,14 @@ void cpu_disable_paging_pae(void)
: "eax");
}
static bool has_cpuid(void)
{
unsigned long flag;
asm volatile("pushf\n" \
"pop %%eax\n"
"mov %%eax, %%ecx\n" /* ecx = flags */
"xor %1, %%eax\n"
"push %%eax\n"
"popf\n" /* flags ^= $2 */
"pushf\n"
"pop %%eax\n" /* eax = flags */
"push %%ecx\n"
"popf\n" /* flags = ecx */
"xor %%ecx, %%eax\n"
"mov %%eax, %0"
: "=r" (flag)
: "i" (1 << 21)
: "eax", "ecx", "memory");
return flag != 0;
}
static bool can_detect_long_mode(void)
{
unsigned long flag;
asm volatile("mov $0x80000000, %%eax\n"
"cpuid\n"
"mov %%eax, %0"
: "=r" (flag)
:
: "eax", "ebx", "ecx", "edx", "memory");
return flag > 0x80000000UL;
return cpuid_eax(0x80000000) > 0x80000000UL;
}
static bool has_long_mode(void)
{
unsigned long flag;
asm volatile("mov $0x80000001, %%eax\n"
"cpuid\n"
"mov %%edx, %0"
: "=r" (flag)
:
: "eax", "ebx", "ecx", "edx", "memory");
return flag & (1 << 29) ? true : false;
return cpuid_edx(0x80000001) & (1 << 29) ? true : false;
}
int cpu_has_64bit(void)
@ -336,9 +482,47 @@ int cpu_has_64bit(void)
has_long_mode();
}
int print_cpuinfo(void)
const char *cpu_vendor_name(int vendor)
{
printf("CPU: %s\n", cpu_has_64bit() ? "x86_64" : "x86");
const char *name;
name = "<invalid cpu vendor>";
if ((vendor < (ARRAY_SIZE(x86_vendor_name))) &&
(x86_vendor_name[vendor] != 0))
name = x86_vendor_name[vendor];
return name;
}
char *cpu_get_name(char *name)
{
unsigned int *name_as_ints = (unsigned int *)name;
struct cpuid_result regs;
char *ptr;
int i;
/* This bit adds up to 48 bytes */
for (i = 0; i < 3; i++) {
regs = cpuid(0x80000002 + i);
name_as_ints[i * 4 + 0] = regs.eax;
name_as_ints[i * 4 + 1] = regs.ebx;
name_as_ints[i * 4 + 2] = regs.ecx;
name_as_ints[i * 4 + 3] = regs.edx;
}
name[CPU_MAX_NAME_LEN - 1] = '\0';
/* Skip leading spaces. */
ptr = name;
while (*ptr == ' ')
ptr++;
return ptr;
}
int default_print_cpuinfo(void)
{
printf("CPU: %s, vendor %s, device %xh\n",
cpu_has_64bit() ? "x86_64" : "x86",
cpu_vendor_name(gd->arch.x86_vendor), gd->arch.x86_device);
return 0;
}
@ -384,3 +568,26 @@ int cpu_jump_to_64bit(ulong setup_base, ulong target)
return -EFAULT;
}
void show_boot_progress(int val)
{
#if MIN_PORT80_KCLOCKS_DELAY
/*
* Scale the time counter reading to avoid using 64 bit arithmetics.
* Can't use get_timer() here becuase it could be not yet
* initialized or even implemented.
*/
if (!gd->arch.tsc_prev) {
gd->arch.tsc_base_kclocks = rdtsc() / 1000;
gd->arch.tsc_prev = 0;
} else {
uint32_t now;
do {
now = rdtsc() / 1000 - gd->arch.tsc_base_kclocks;
} while (now < (gd->arch.tsc_prev + MIN_PORT80_KCLOCKS_DELAY));
gd->arch.tsc_prev = now;
}
#endif
outb(val, POST_PORT);
}

2
arch/x86/cpu/interrupts.c
View File

@ -31,7 +31,7 @@ DECLARE_GLOBAL_DATA_PTR;
"pushl $"#x"\n" \
"jmp irq_common_entry\n"
void dump_regs(struct irq_regs *regs)
static void dump_regs(struct irq_regs *regs)
{
unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
unsigned long d0, d1, d2, d3, d6, d7;

172
arch/x86/cpu/ivybridge/Kconfig Normal file
View File

@ -0,0 +1,172 @@
#
# From Coreboot src/northbridge/intel/sandybridge/Kconfig
#
# Copyright (C) 2010 Google Inc.
#
# SPDX-License-Identifier: GPL-2.0
config NORTHBRIDGE_INTEL_SANDYBRIDGE
bool
select CACHE_MRC_BIN
select CPU_INTEL_MODEL_206AX
config NORTHBRIDGE_INTEL_IVYBRIDGE
bool
select CACHE_MRC_BIN
select CPU_INTEL_MODEL_306AX
if NORTHBRIDGE_INTEL_SANDYBRIDGE
config VGA_BIOS_ID
string
default "8086,0106"
config CACHE_MRC_SIZE_KB
int
default 256
config MRC_CACHE_BASE
hex
default 0xff800000
config MRC_CACHE_LOCATION
hex
depends on !CHROMEOS
default 0x1ec000
config MRC_CACHE_SIZE
hex
depends on !CHROMEOS
default 0x10000
config DCACHE_RAM_BASE
hex
default 0xff7f0000
config DCACHE_RAM_SIZE
hex
default 0x10000
endif
if NORTHBRIDGE_INTEL_IVYBRIDGE
config VGA_BIOS_ID
string
default "8086,0166"
config EXTERNAL_MRC_BLOB
bool
default n
config CACHE_MRC_SIZE_KB
int
default 512
config MRC_CACHE_BASE
hex
default 0xff800000
config MRC_CACHE_LOCATION
hex
depends on !CHROMEOS
default 0x370000
config MRC_CACHE_SIZE
hex
depends on !CHROMEOS
default 0x10000
config DCACHE_RAM_BASE
hex
default 0xff7e0000
config DCACHE_RAM_SIZE
hex
default 0x20000
endif
if NORTHBRIDGE_INTEL_SANDYBRIDGE || NORTHBRIDGE_INTEL_IVYBRIDGE
config HAVE_MRC
bool "Add a System Agent binary"
help
Select this option to add a System Agent binary to
the resulting U-Boot image. MRC stands for Memory Reference Code.
It is a binary blob which U-Boot uses to set up SDRAM.
Note: Without this binary U-Boot will not be able to set up its
SDRAM so will not boot.
config DCACHE_RAM_MRC_VAR_SIZE
hex
default 0x4000
help
This is the amount of CAR (Cache as RAM) reserved for use by the
memory reference code. This should be set to 16KB (0x4000 hex)
so that MRC has enough space to run.
config MRC_FILE
string "Intel System Agent path and filename"
depends on HAVE_MRC
default "systemagent-ivybridge.bin" if NORTHBRIDGE_INTEL_IVYBRIDGE
default "systemagent-sandybridge.bin" if NORTHBRIDGE_INTEL_SANDYBRIDGE
help
The path and filename of the file to use as System Agent
binary.
config CPU_SPECIFIC_OPTIONS
def_bool y
select SMM_TSEG
select ARCH_BOOTBLOCK_X86_32
select ARCH_ROMSTAGE_X86_32
select ARCH_RAMSTAGE_X86_32
select SMP
select SSE2
select UDELAY_LAPIC
select CPU_MICROCODE_IN_CBFS
select TSC_SYNC_MFENCE
select HAVE_INTEL_ME
select X86_RAMTEST
config SMM_TSEG_SIZE
hex
default 0x800000
config ENABLE_VMX
bool "Enable VMX for virtualization"
default n
help
Virtual Machine Extensions are provided in many x86 CPUs. These
provide various facilities for allowing a host OS to provide an
environment where potentially several guest OSes have only
limited access to the underlying hardware. This is achieved
without resorting to software trapping and/or instruction set
emulation (which would be very slow).
Intel's implementation of this is called VT-x. This option enables
VT-x this so that the OS that is booted by U-Boot can make use of
these facilities. If this option is not enabled, then the host OS
will be unable to support virtualisation, or it will run very
slowly.
endif
config CPU_INTEL_SOCKET_RPGA989
bool
if CPU_INTEL_SOCKET_RPGA989
config SOCKET_SPECIFIC_OPTIONS # dummy
def_bool y
select MMX
select SSE
select CACHE_AS_RAM
config CACHE_MRC_BIN
bool
default n
endif

16
arch/x86/cpu/ivybridge/Makefile Normal file
View File

@ -0,0 +1,16 @@
#
# Copyright (c) 2014 Google, Inc
#
# SPDX-License-Identifier: GPL-2.0+
#
obj-y += car.o
obj-y += cpu.o
obj-y += early_init.o
obj-y += early_me.o
obj-y += lpc.o
obj-y += me_status.o
obj-y += microcode_intel.o
obj-y += pci.o
obj-y += report_platform.o
obj-y += sdram.o

178
arch/x86/cpu/ivybridge/car.S Normal file
View File

@ -0,0 +1,178 @@
/*
* Copyright (c) 2014 Google, Inc
*
* From Coreboot file cpu/intel/model_206ax/cache_as_ram.inc
*
* Copyright (C) 2000,2007 Ronald G. Minnich <rminnich@gmail.com>
* Copyright (C) 2005 Tyan (written by Yinghai Lu for Tyan)
* Copyright (C) 2007-2008 coresystems GmbH
* Copyright (C) 2012 Kyösti Mälkki <kyosti.malkki@gmail.com>
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <asm/mtrr.h>
#include <asm/post.h>
#include <asm/processor-flags.h>
#define MTRR_PHYS_BASE_MSR(reg) (0x200 + 2 * (reg))
#define MTRR_PHYS_MASK_MSR(reg) (0x200 + 2 * (reg) + 1)
#define CACHE_AS_RAM_SIZE CONFIG_DCACHE_RAM_SIZE
#define CACHE_AS_RAM_BASE CONFIG_DCACHE_RAM_BASE
/* Cache 4GB - MRC_SIZE_KB for MRC */
#define CACHE_MRC_BYTES ((CONFIG_CACHE_MRC_SIZE_KB << 10) - 1)
#define CACHE_MRC_BASE (0xFFFFFFFF - CACHE_MRC_BYTES)
#define CACHE_MRC_MASK (~CACHE_MRC_BYTES)
#define CPU_PHYSMASK_HI (1 << (CONFIG_CPU_ADDR_BITS - 32) - 1)
#define NOEVICTMOD_MSR 0x2e0
/*
* Note: ebp must not be touched in this code as it holds the BIST
* value (built-in self test). We preserve this value until it can
* be written to global_data when CAR is ready for use.
*/
.globl car_init
car_init:
post_code(POST_CAR_START)
/* Send INIT IPI to all excluding ourself */
movl $0x000C4500, %eax
movl $0xFEE00300, %esi
movl %eax, (%esi)
post_code(POST_CAR_SIPI)
/* Zero out all fixed range and variable range MTRRs */
movl $mtrr_table, %esi
movl $((mtrr_table_end - mtrr_table) / 2), %edi
xorl %eax, %eax
xorl %edx, %edx
clear_mtrrs:
movw (%esi), %bx
movzx %bx, %ecx
wrmsr
add $2, %esi
dec %edi
jnz clear_mtrrs
post_code(POST_CAR_MTRR)
/* Configure the default memory type to uncacheable */
movl $MTRRdefType_MSR, %ecx
rdmsr
andl $(~0x00000cff), %eax
wrmsr
post_code(POST_CAR_UNCACHEABLE)
/* Set Cache-as-RAM base address */
movl $(MTRR_PHYS_BASE_MSR(0)), %ecx
movl $(CACHE_AS_RAM_BASE | MTRR_TYPE_WRBACK), %eax
xorl %edx, %edx
wrmsr
post_code(POST_CAR_BASE_ADDRESS)
/* Set Cache-as-RAM mask */
movl $(MTRR_PHYS_MASK_MSR(0)), %ecx
movl $(~(CACHE_AS_RAM_SIZE - 1) | MTRRphysMaskValid), %eax
movl $CPU_PHYSMASK_HI, %edx
wrmsr
post_code(POST_CAR_MASK)
/* Enable MTRR */
movl $MTRRdefType_MSR, %ecx
rdmsr
orl $MTRRdefTypeEn, %eax
wrmsr
/* Enable cache (CR0.CD = 0, CR0.NW = 0) */
movl %cr0, %eax
andl $(~(X86_CR0_CD | X86_CR0_NW)), %eax
invd
movl %eax, %cr0
/* enable the 'no eviction' mode */
movl $NOEVICTMOD_MSR, %ecx
rdmsr
orl $1, %eax
andl $~2, %eax
wrmsr
/* Clear the cache memory region. This will also fill up the cache */
movl $CACHE_AS_RAM_BASE, %esi
movl %esi, %edi
movl $(CACHE_AS_RAM_SIZE / 4), %ecx
xorl %eax, %eax
rep stosl
/* enable the 'no eviction run' state */
movl $NOEVICTMOD_MSR, %ecx
rdmsr
orl $3, %eax
wrmsr
post_code(POST_CAR_FILL)
/* Enable Cache-as-RAM mode by disabling cache */
movl %cr0, %eax
orl $X86_CR0_CD, %eax
movl %eax, %cr0
/* Enable cache for our code in Flash because we do XIP here */
movl $MTRR_PHYS_BASE_MSR(1), %ecx
xorl %edx, %edx
movl $car_init_ret, %eax
andl $(~(CONFIG_XIP_ROM_SIZE - 1)), %eax
orl $MTRR_TYPE_WRPROT, %eax
wrmsr
movl $MTRR_PHYS_MASK_MSR(1), %ecx
movl $CPU_PHYSMASK_HI, %edx
movl $(~(CONFIG_XIP_ROM_SIZE - 1) | MTRRphysMaskValid), %eax
wrmsr
post_code(POST_CAR_ROM_CACHE)
#ifdef CONFIG_CACHE_MRC_BIN
/* Enable caching for ram init code to run faster */
movl $MTRR_PHYS_BASE_MSR(2), %ecx
movl $(CACHE_MRC_BASE | MTRR_TYPE_WRPROT), %eax
xorl %edx, %edx
wrmsr
movl $MTRR_PHYS_MASK_MSR(2), %ecx
movl $(CACHE_MRC_MASK | MTRRphysMaskValid), %eax
movl $CPU_PHYSMASK_HI, %edx
wrmsr
#endif
post_code(POST_CAR_MRC_CACHE)
/* Enable cache */
movl %cr0, %eax
andl $(~(X86_CR0_CD | X86_CR0_NW)), %eax
movl %eax, %cr0
post_code(POST_CAR_CPU_CACHE)
/* All CPUs need to be in Wait for SIPI state */
wait_for_sipi:
movl (%esi), %eax
bt $12, %eax
jc wait_for_sipi
/* return */
jmp car_init_ret
mtrr_table:
/* Fixed MTRRs */
.word 0x250, 0x258, 0x259
.word 0x268, 0x269, 0x26A
.word 0x26B, 0x26C, 0x26D
.word 0x26E, 0x26F
/* Variable MTRRs */
.word 0x200, 0x201, 0x202, 0x203
.word 0x204, 0x205, 0x206, 0x207
.word 0x208, 0x209, 0x20A, 0x20B
.word 0x20C, 0x20D, 0x20E, 0x20F
.word 0x210, 0x211, 0x212, 0x213
mtrr_table_end:

357
arch/x86/cpu/ivybridge/cpu.c Normal file
View File

@ -0,0 +1,357 @@
/*
* Copyright (c) 2014 Google, Inc
* (C) Copyright 2008
* Graeme Russ, graeme.russ@gmail.com.
*
* Some portions from coreboot src/mainboard/google/link/romstage.c
* and src/cpu/intel/model_206ax/bootblock.c
* Copyright (C) 2007-2010 coresystems GmbH
* Copyright (C) 2011 Google Inc.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <errno.h>
#include <fdtdec.h>
#include <asm/cpu.h>
#include <asm/io.h>
#include <asm/lapic.h>
#include <asm/msr.h>
#include <asm/mtrr.h>
#include <asm/pci.h>
#include <asm/post.h>
#include <asm/processor.h>
#include <asm/arch/model_206ax.h>
#include <asm/arch/microcode.h>
#include <asm/arch/pch.h>
#include <asm/arch/sandybridge.h>
DECLARE_GLOBAL_DATA_PTR;
static void enable_port80_on_lpc(struct pci_controller *hose, pci_dev_t dev)
{
/* Enable port 80 POST on LPC */
pci_hose_write_config_dword(hose, dev, PCH_RCBA_BASE, DEFAULT_RCBA | 1);
clrbits_le32(RCB_REG(GCS), 4);
}
/*
* Enable Prefetching and Caching.
*/
static void enable_spi_prefetch(struct pci_controller *hose, pci_dev_t dev)
{
u8 reg8;
pci_hose_read_config_byte(hose, dev, 0xdc, &reg8);
reg8 &= ~(3 << 2);
reg8 |= (2 << 2); /* Prefetching and Caching Enabled */
pci_hose_write_config_byte(hose, dev, 0xdc, reg8);
}
static void set_var_mtrr(
unsigned reg, unsigned base, unsigned size, unsigned type)
{
/* Bit Bit 32-35 of MTRRphysMask should be set to 1 */
/* FIXME: It only support 4G less range */
wrmsr(MTRRphysBase_MSR(reg), base | type, 0);
wrmsr(MTRRphysMask_MSR(reg), ~(size - 1) | MTRRphysMaskValid,
(1 << (CONFIG_CPU_ADDR_BITS - 32)) - 1);
}
static void enable_rom_caching(void)
{
disable_caches();
set_var_mtrr(1, 0xffc00000, 4 << 20, MTRR_TYPE_WRPROT);
enable_caches();
/* Enable Variable MTRRs */
wrmsr(MTRRdefType_MSR, 0x800, 0);
}
static int set_flex_ratio_to_tdp_nominal(void)
{
msr_t flex_ratio, msr;
u8 nominal_ratio;
/* Minimum CPU revision for configurable TDP support */
if (cpuid_eax(1) < IVB_CONFIG_TDP_MIN_CPUID)
return -EINVAL;
/* Check for Flex Ratio support */
flex_ratio = msr_read(MSR_FLEX_RATIO);
if (!(flex_ratio.lo & FLEX_RATIO_EN))
return -EINVAL;
/* Check for >0 configurable TDPs */
msr = msr_read(MSR_PLATFORM_INFO);
if (((msr.hi >> 1) & 3) == 0)
return -EINVAL;
/* Use nominal TDP ratio for flex ratio */
msr = msr_read(MSR_CONFIG_TDP_NOMINAL);
nominal_ratio = msr.lo & 0xff;
/* See if flex ratio is already set to nominal TDP ratio */
if (((flex_ratio.lo >> 8) & 0xff) == nominal_ratio)
return 0;
/* Set flex ratio to nominal TDP ratio */
flex_ratio.lo &= ~0xff00;
flex_ratio.lo |= nominal_ratio << 8;
flex_ratio.lo |= FLEX_RATIO_LOCK;
msr_write(MSR_FLEX_RATIO, flex_ratio);
/* Set flex ratio in soft reset data register bits 11:6 */
clrsetbits_le32(RCB_REG(SOFT_RESET_DATA), 0x3f << 6,
(nominal_ratio & 0x3f) << 6);
/* Set soft reset control to use register value */
setbits_le32(RCB_REG(SOFT_RESET_CTRL), 1);
/* Issue warm reset, will be "CPU only" due to soft reset data */
outb(0x0, PORT_RESET);
outb(0x6, PORT_RESET);
cpu_hlt();
/* Not reached */
return -EINVAL;
}
static void set_spi_speed(void)
{
u32 fdod;
/* Observe SPI Descriptor Component Section 0 */
writel(0x1000, RCB_REG(SPI_DESC_COMP0));
/* Extract the1 Write/Erase SPI Frequency from descriptor */
fdod = readl(RCB_REG(SPI_FREQ_WR_ERA));
fdod >>= 24;
fdod &= 7;
/* Set Software Sequence frequency to match */
clrsetbits_8(RCB_REG(SPI_FREQ_SWSEQ), 7, fdod);
}
int arch_cpu_init(void)
{
const void *blob = gd->fdt_blob;
struct pci_controller *hose;
int node;
int ret;
post_code(POST_CPU_INIT);
timer_set_base(rdtsc());
ret = x86_cpu_init_f();
if (ret)
return ret;
ret = pci_early_init_hose(&hose);
if (ret)
return ret;
node = fdtdec_next_compatible(blob, 0, COMPAT_INTEL_LPC);
if (node < 0)
return -ENOENT;
ret = lpc_early_init(gd->fdt_blob, node, PCH_LPC_DEV);
if (ret)
return ret;
enable_spi_prefetch(hose, PCH_LPC_DEV);
/* This is already done in start.S, but let's do it in C */
enable_port80_on_lpc(hose, PCH_LPC_DEV);
/* already done in car.S */
if (false)
enable_rom_caching();
set_spi_speed();
/*
* We should do as little as possible before the serial console is
* up. Perhaps this should move to later. Our next lot of init
* happens in print_cpuinfo() when we have a console
*/
ret = set_flex_ratio_to_tdp_nominal();
if (ret)
return ret;
return 0;
}
static int enable_smbus(void)
{
pci_dev_t dev;
uint16_t value;
/* Set the SMBus device statically. */
dev = PCI_BDF(0x0, 0x1f, 0x3);
/* Check to make sure we've got the right device. */
value = pci_read_config16(dev, 0x0);
if (value != 0x8086) {
printf("SMBus controller not found\n");
return -ENOSYS;
}
/* Set SMBus I/O base. */
pci_write_config32(dev, SMB_BASE,
SMBUS_IO_BASE | PCI_BASE_ADDRESS_SPACE_IO);
/* Set SMBus enable. */
pci_write_config8(dev, HOSTC, HST_EN);
/* Set SMBus I/O space enable. */
pci_write_config16(dev, PCI_COMMAND, PCI_COMMAND_IO);
/* Disable interrupt generation. */
outb(0, SMBUS_IO_BASE + SMBHSTCTL);
/* Clear any lingering errors, so transactions can run. */
outb(inb(SMBUS_IO_BASE + SMBHSTSTAT), SMBUS_IO_BASE + SMBHSTSTAT);
debug("SMBus controller enabled\n");
return 0;
}
#define PCH_EHCI0_TEMP_BAR0 0xe8000000
#define PCH_EHCI1_TEMP_BAR0 0xe8000400
#define PCH_XHCI_TEMP_BAR0 0xe8001000
/*
* Setup USB controller MMIO BAR to prevent the reference code from
* resetting the controller.
*
* The BAR will be re-assigned during device enumeration so these are only
* temporary.
*
* This is used to speed up the resume path.
*/
static void enable_usb_bar(void)
{
pci_dev_t usb0 = PCH_EHCI1_DEV;
pci_dev_t usb1 = PCH_EHCI2_DEV;
pci_dev_t usb3 = PCH_XHCI_DEV;
u32 cmd;
/* USB Controller 1 */
pci_write_config32(usb0, PCI_BASE_ADDRESS_0,
PCH_EHCI0_TEMP_BAR0);
cmd = pci_read_config32(usb0, PCI_COMMAND);
cmd |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
pci_write_config32(usb0, PCI_COMMAND, cmd);
/* USB Controller 1 */
pci_write_config32(usb1, PCI_BASE_ADDRESS_0,
PCH_EHCI1_TEMP_BAR0);
cmd = pci_read_config32(usb1, PCI_COMMAND);
cmd |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
pci_write_config32(usb1, PCI_COMMAND, cmd);
/* USB3 Controller */
pci_write_config32(usb3, PCI_BASE_ADDRESS_0,
PCH_XHCI_TEMP_BAR0);
cmd = pci_read_config32(usb3, PCI_COMMAND);
cmd |= PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
pci_write_config32(usb3, PCI_COMMAND, cmd);
}
static int report_bist_failure(void)
{
if (gd->arch.bist != 0) {
printf("BIST failed: %08x\n", gd->arch.bist);
return -EFAULT;
}
return 0;
}
int print_cpuinfo(void)
{
enum pei_boot_mode_t boot_mode = PEI_BOOT_NONE;
char processor_name[CPU_MAX_NAME_LEN];
const char *name;
uint32_t pm1_cnt;
uint16_t pm1_sts;
int ret;
/* Halt if there was a built in self test failure */
ret = report_bist_failure();
if (ret)
return ret;
enable_lapic();
ret = microcode_update_intel();
if (ret && ret != -ENOENT && ret != -EEXIST)
return ret;
/* Enable upper 128bytes of CMOS */
writel(1 << 2, RCB_REG(RC));
/* TODO: cmos_post_init() */
if (readl(MCHBAR_REG(SSKPD)) == 0xCAFE) {
debug("soft reset detected\n");
boot_mode = PEI_BOOT_SOFT_RESET;
/* System is not happy after keyboard reset... */
debug("Issuing CF9 warm reset\n");
outb(0x6, 0xcf9);
cpu_hlt();
}
/* Early chipset init required before RAM init can work */
sandybridge_early_init(SANDYBRIDGE_MOBILE);
/* Check PM1_STS[15] to see if we are waking from Sx */
pm1_sts = inw(DEFAULT_PMBASE + PM1_STS);
/* Read PM1_CNT[12:10] to determine which Sx state */
pm1_cnt = inl(DEFAULT_PMBASE + PM1_CNT);
if ((pm1_sts & WAK_STS) && ((pm1_cnt >> 10) & 7) == 5) {
#if CONFIG_HAVE_ACPI_RESUME
debug("Resume from S3 detected.\n");
boot_mode = PEI_BOOT_RESUME;
/* Clear SLP_TYPE. This will break stage2 but
* we care for that when we get there.
*/
outl(pm1_cnt & ~(7 << 10), DEFAULT_PMBASE + PM1_CNT);
#else
debug("Resume from S3 detected, but disabled.\n");
#endif
} else {
/*
* TODO: An indication of life might be possible here (e.g.
* keyboard light)
*/
}
post_code(POST_EARLY_INIT);
/* Enable SPD ROMs and DDR-III DRAM */
ret = enable_smbus();
if (ret)
return ret;
/* Prepare USB controller early in S3 resume */
if (boot_mode == PEI_BOOT_RESUME)
enable_usb_bar();
gd->arch.pei_boot_mode = boot_mode;
/* TODO: Move this to the board or driver */
pci_write_config32(PCH_LPC_DEV, GPIO_BASE, DEFAULT_GPIOBASE | 1);
pci_write_config32(PCH_LPC_DEV, GPIO_CNTL, 0x10);
/* Print processor name */
name = cpu_get_name(processor_name);
printf("CPU: %s\n", name);
post_code(POST_CPU_INFO);
return 0;
}

145
arch/x86/cpu/ivybridge/early_init.c Normal file
View File

@ -0,0 +1,145 @@
/*
* From Coreboot
*
* Copyright (C) 2007-2010 coresystems GmbH
* Copyright (C) 2011 Google Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <asm/io.h>
#include <asm/pci.h>
#include <asm/arch/pch.h>
#include <asm/arch/sandybridge.h>
static void sandybridge_setup_bars(pci_dev_t pch_dev, pci_dev_t lpc_dev)
{
/* Setting up Southbridge. In the northbridge code. */
debug("Setting up static southbridge registers\n");
pci_write_config32(lpc_dev, PCH_RCBA_BASE, DEFAULT_RCBA | 1);
pci_write_config32(lpc_dev, PMBASE, DEFAULT_PMBASE | 1);
pci_write_config8(lpc_dev, ACPI_CNTL, 0x80); /* Enable ACPI BAR */
debug("Disabling watchdog reboot\n");
setbits_le32(RCB_REG(GCS), 1 >> 5); /* No reset */
outw(1 << 11, DEFAULT_PMBASE | 0x60 | 0x08); /* halt timer */
/* Set up all hardcoded northbridge BARs */
debug("Setting up static registers\n");
pci_write_config32(pch_dev, EPBAR, DEFAULT_EPBAR | 1);
pci_write_config32(pch_dev, EPBAR + 4, (0LL + DEFAULT_EPBAR) >> 32);
pci_write_config32(pch_dev, MCHBAR, DEFAULT_MCHBAR | 1);
pci_write_config32(pch_dev, MCHBAR + 4, (0LL + DEFAULT_MCHBAR) >> 32);
/* 64MB - busses 0-63 */
pci_write_config32(pch_dev, PCIEXBAR, DEFAULT_PCIEXBAR | 5);
pci_write_config32(pch_dev, PCIEXBAR + 4,
(0LL + DEFAULT_PCIEXBAR) >> 32);
pci_write_config32(pch_dev, DMIBAR, DEFAULT_DMIBAR | 1);
pci_write_config32(pch_dev, DMIBAR + 4, (0LL + DEFAULT_DMIBAR) >> 32);
/* Set C0000-FFFFF to access RAM on both reads and writes */
pci_write_config8(pch_dev, PAM0, 0x30);
pci_write_config8(pch_dev, PAM1, 0x33);
pci_write_config8(pch_dev, PAM2, 0x33);
pci_write_config8(pch_dev, PAM3, 0x33);
pci_write_config8(pch_dev, PAM4, 0x33);
pci_write_config8(pch_dev, PAM5, 0x33);
pci_write_config8(pch_dev, PAM6, 0x33);
}
static void sandybridge_setup_graphics(pci_dev_t pch_dev, pci_dev_t video_dev)
{
u32 reg32;
u16 reg16;
u8 reg8;
reg16 = pci_read_config16(video_dev, PCI_DEVICE_ID);
switch (reg16) {
case 0x0102: /* GT1 Desktop */
case 0x0106: /* GT1 Mobile */
case 0x010a: /* GT1 Server */
case 0x0112: /* GT2 Desktop */
case 0x0116: /* GT2 Mobile */
case 0x0122: /* GT2 Desktop >=1.3GHz */
case 0x0126: /* GT2 Mobile >=1.3GHz */
case 0x0156: /* IvyBridge */
case 0x0166: /* IvyBridge */
break;
default:
debug("Graphics not supported by this CPU/chipset\n");
return;
}
debug("Initialising Graphics\n");
/* Setup IGD memory by setting GGC[7:3] = 1 for 32MB */
reg16 = pci_read_config16(pch_dev, GGC);
reg16 &= ~0x00f8;
reg16 |= 1 << 3;
/* Program GTT memory by setting GGC[9:8] = 2MB */
reg16 &= ~0x0300;
reg16 |= 2 << 8;
/* Enable VGA decode */
reg16 &= ~0x0002;
pci_write_config16(pch_dev, GGC, reg16);
/* Enable 256MB aperture */
reg8 = pci_read_config8(video_dev, MSAC);
reg8 &= ~0x06;
reg8 |= 0x02;
pci_write_config8(video_dev, MSAC, reg8);
/* Erratum workarounds */
reg32 = readl(MCHBAR_REG(0x5f00));
reg32 |= (1 << 9) | (1 << 10);
writel(reg32, MCHBAR_REG(0x5f00));
/* Enable SA Clock Gating */
reg32 = readl(MCHBAR_REG(0x5f00));
writel(reg32 | 1, MCHBAR_REG(0x5f00));
/* GPU RC6 workaround for sighting 366252 */
reg32 = readl(MCHBAR_REG(0x5d14));
reg32 |= (1 << 31);
writel(reg32, MCHBAR_REG(0x5d14));
/* VLW */
reg32 = readl(MCHBAR_REG(0x6120));
reg32 &= ~(1 << 0);
writel(reg32, MCHBAR_REG(0x6120));
reg32 = readl(MCHBAR_REG(0x5418));
reg32 |= (1 << 4) | (1 << 5);
writel(reg32, MCHBAR_REG(0x5418));
}
void sandybridge_early_init(int chipset_type)
{
pci_dev_t pch_dev = PCH_DEV;
pci_dev_t video_dev = PCH_VIDEO_DEV;
pci_dev_t lpc_dev = PCH_LPC_DEV;
u32 capid0_a;
u8 reg8;
/* Device ID Override Enable should be done very early */
capid0_a = pci_read_config32(pch_dev, 0xe4);
if (capid0_a & (1 << 10)) {
reg8 = pci_read_config8(pch_dev, 0xf3);
reg8 &= ~7; /* Clear 2:0 */
if (chipset_type == SANDYBRIDGE_MOBILE)
reg8 |= 1; /* Set bit 0 */
pci_write_config8(pch_dev, 0xf3, reg8);
}
/* Setup all BARs required for early PCIe and raminit */
sandybridge_setup_bars(pch_dev, lpc_dev);
/* Device Enable */
pci_write_config32(pch_dev, DEVEN, DEVEN_HOST | DEVEN_IGD);
sandybridge_setup_graphics(pch_dev, video_dev);
}

191
arch/x86/cpu/ivybridge/early_me.c Normal file
View File

@ -0,0 +1,191 @@
/*
* From Coreboot src/southbridge/intel/bd82x6x/early_me.c
*
* Copyright (C) 2011 The Chromium OS Authors. All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <errno.h>
#include <asm/pci.h>
#include <asm/processor.h>
#include <asm/arch/me.h>
#include <asm/arch/pch.h>
#include <asm/io.h>
static const char *const me_ack_values[] = {
[ME_HFS_ACK_NO_DID] = "No DID Ack received",
[ME_HFS_ACK_RESET] = "Non-power cycle reset",
[ME_HFS_ACK_PWR_CYCLE] = "Power cycle reset",
[ME_HFS_ACK_S3] = "Go to S3",
[ME_HFS_ACK_S4] = "Go to S4",
[ME_HFS_ACK_S5] = "Go to S5",
[ME_HFS_ACK_GBL_RESET] = "Global Reset",
[ME_HFS_ACK_CONTINUE] = "Continue to boot"
};
static inline void pci_read_dword_ptr(void *ptr, int offset)
{
u32 dword;
dword = pci_read_config32(PCH_ME_DEV, offset);
memcpy(ptr, &dword, sizeof(dword));
}
static inline void pci_write_dword_ptr(void *ptr, int offset)
{
u32 dword = 0;
memcpy(&dword, ptr, sizeof(dword));
pci_write_config32(PCH_ME_DEV, offset, dword);
}
void intel_early_me_status(void)
{
struct me_hfs hfs;
struct me_gmes gmes;
pci_read_dword_ptr(&hfs, PCI_ME_HFS);
pci_read_dword_ptr(&gmes, PCI_ME_GMES);
intel_me_status(&hfs, &gmes);
}
int intel_early_me_init(void)
{
int count;
struct me_uma uma;
struct me_hfs hfs;
debug("Intel ME early init\n");
/* Wait for ME UMA SIZE VALID bit to be set */
for (count = ME_RETRY; count > 0; --count) {
pci_read_dword_ptr(&uma, PCI_ME_UMA);
if (uma.valid)
break;
udelay(ME_DELAY);
}
if (!count) {
printf("ERROR: ME is not ready!\n");
return -EBUSY;
}
/* Check for valid firmware */
pci_read_dword_ptr(&hfs, PCI_ME_HFS);
if (hfs.fpt_bad) {
printf("WARNING: ME has bad firmware\n");
return -EBADF;
}
debug("Intel ME firmware is ready\n");
return 0;
}
int intel_early_me_uma_size(void)
{
struct me_uma uma;
pci_read_dword_ptr(&uma, PCI_ME_UMA);
if (uma.valid) {
debug("ME: Requested %uMB UMA\n", uma.size);
return uma.size;
}
debug("ME: Invalid UMA size\n");
return -EINVAL;
}
static inline void set_global_reset(int enable)
{
u32 etr3;
etr3 = pci_read_config32(PCH_LPC_DEV, ETR3);
/* Clear CF9 Without Resume Well Reset Enable */
etr3 &= ~ETR3_CWORWRE;
/* CF9GR indicates a Global Reset */
if (enable)
etr3 |= ETR3_CF9GR;
else
etr3 &= ~ETR3_CF9GR;
pci_write_config32(PCH_LPC_DEV, ETR3, etr3);
}
int intel_early_me_init_done(u8 status)
{
u8 reset;
int count;
u32 mebase_l, mebase_h;
struct me_hfs hfs;
struct me_did did = {
.init_done = ME_INIT_DONE,
.status = status
};
/* MEBASE from MESEG_BASE[35:20] */
mebase_l = pci_read_config32(PCH_DEV, PCI_CPU_MEBASE_L);
mebase_h = pci_read_config32(PCH_DEV, PCI_CPU_MEBASE_H);
mebase_h &= 0xf;
did.uma_base = (mebase_l >> 20) | (mebase_h << 12);
/* Send message to ME */
debug("ME: Sending Init Done with status: %d, UMA base: 0x%04x\n",
status, did.uma_base);
pci_write_dword_ptr(&did, PCI_ME_H_GS);
/* Must wait for ME acknowledgement */
for (count = ME_RETRY; count > 0; --count) {
pci_read_dword_ptr(&hfs, PCI_ME_HFS);
if (hfs.bios_msg_ack)
break;
udelay(ME_DELAY);
}
if (!count) {
printf("ERROR: ME failed to respond\n");
return -1;
}
/* Return the requested BIOS action */
debug("ME: Requested BIOS Action: %s\n", me_ack_values[hfs.ack_data]);
/* Check status after acknowledgement */
intel_early_me_status();
reset = 0;
switch (hfs.ack_data) {
case ME_HFS_ACK_CONTINUE:
/* Continue to boot */
return 0;
case ME_HFS_ACK_RESET:
/* Non-power cycle reset */
set_global_reset(0);
reset = 0x06;
break;
case ME_HFS_ACK_PWR_CYCLE:
/* Power cycle reset */
set_global_reset(0);
reset = 0x0e;
break;
case ME_HFS_ACK_GBL_RESET:
/* Global reset */
set_global_reset(1);
reset = 0x0e;
break;
case ME_HFS_ACK_S3:
case ME_HFS_ACK_S4:
case ME_HFS_ACK_S5:
break;
}
/* Perform the requested reset */
if (reset) {
outb(reset, 0xcf9);
cpu_hlt();
}
return -1;
}

48
arch/x86/cpu/ivybridge/lpc.c Normal file
View File

@ -0,0 +1,48 @@
/*
* From coreboot southbridge/intel/bd82x6x/lpc.c
*
* Copyright (C) 2008-2009 coresystems GmbH
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <errno.h>
#include <fdtdec.h>
#include <pci.h>
#include <asm/pci.h>
#include <asm/arch/pch.h>
int lpc_early_init(const void *blob, int node, pci_dev_t dev)
{
struct reg_info {
u32 base;
u32 size;
} values[4], *ptr;
int count;
int i;
count = fdtdec_get_int_array_count(blob, node, "gen-dec",
(u32 *)values, sizeof(values) / sizeof(u32));
if (count < 0)
return -EINVAL;
/* Set COM1/COM2 decode range */
pci_write_config16(dev, LPC_IO_DEC, 0x0010);
/* Enable PS/2 Keyboard/Mouse, EC areas and COM1 */
pci_write_config16(dev, LPC_EN, KBC_LPC_EN | MC_LPC_EN |
GAMEL_LPC_EN | COMA_LPC_EN);
/* Write all registers but use 0 if we run out of data */
count = count * sizeof(u32) / sizeof(values[0]);
for (i = 0, ptr = values; i < ARRAY_SIZE(values); i++, ptr++) {
u32 reg = 0;
if (i < count)
reg = ptr->base | PCI_COMMAND_IO | (ptr->size << 16);
pci_write_config32(dev, LPC_GENX_DEC(i), reg);
}
return 0;
}

195
arch/x86/cpu/ivybridge/me_status.c Normal file
View File

@ -0,0 +1,195 @@
/*
* From Coreboot src/southbridge/intel/bd82x6x/me_status.c
*
* Copyright (C) 2011 The Chromium OS Authors. All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <asm/arch/me.h>
/* HFS1[3:0] Current Working State Values */
static const char *const me_cws_values[] = {
[ME_HFS_CWS_RESET] = "Reset",
[ME_HFS_CWS_INIT] = "Initializing",
[ME_HFS_CWS_REC] = "Recovery",
[ME_HFS_CWS_NORMAL] = "Normal",
[ME_HFS_CWS_WAIT] = "Platform Disable Wait",
[ME_HFS_CWS_TRANS] = "OP State Transition",
[ME_HFS_CWS_INVALID] = "Invalid CPU Plugged In"
};
/* HFS1[8:6] Current Operation State Values */
static const char *const me_opstate_values[] = {
[ME_HFS_STATE_PREBOOT] = "Preboot",
[ME_HFS_STATE_M0_UMA] = "M0 with UMA",
[ME_HFS_STATE_M3] = "M3 without UMA",
[ME_HFS_STATE_M0] = "M0 without UMA",
[ME_HFS_STATE_BRINGUP] = "Bring up",
[ME_HFS_STATE_ERROR] = "M0 without UMA but with error"
};
/* HFS[19:16] Current Operation Mode Values */
static const char *const me_opmode_values[] = {
[ME_HFS_MODE_NORMAL] = "Normal",
[ME_HFS_MODE_DEBUG] = "Debug",
[ME_HFS_MODE_DIS] = "Soft Temporary Disable",
[ME_HFS_MODE_OVER_JMPR] = "Security Override via Jumper",
[ME_HFS_MODE_OVER_MEI] = "Security Override via MEI Message"
};
/* HFS[15:12] Error Code Values */
static const char *const me_error_values[] = {
[ME_HFS_ERROR_NONE] = "No Error",
[ME_HFS_ERROR_UNCAT] = "Uncategorized Failure",
[ME_HFS_ERROR_IMAGE] = "Image Failure",
[ME_HFS_ERROR_DEBUG] = "Debug Failure"
};
/* GMES[31:28] ME Progress Code */
static const char *const me_progress_values[] = {
[ME_GMES_PHASE_ROM] = "ROM Phase",
[ME_GMES_PHASE_BUP] = "BUP Phase",
[ME_GMES_PHASE_UKERNEL] = "uKernel Phase",
[ME_GMES_PHASE_POLICY] = "Policy Module",
[ME_GMES_PHASE_MODULE] = "Module Loading",
[ME_GMES_PHASE_UNKNOWN] = "Unknown",
[ME_GMES_PHASE_HOST] = "Host Communication"
};
/* GMES[27:24] Power Management Event */
static const char *const me_pmevent_values[] = {
[0x00] = "Clean Moff->Mx wake",
[0x01] = "Moff->Mx wake after an error",
[0x02] = "Clean global reset",
[0x03] = "Global reset after an error",
[0x04] = "Clean Intel ME reset",
[0x05] = "Intel ME reset due to exception",
[0x06] = "Pseudo-global reset",
[0x07] = "S0/M0->Sx/M3",
[0x08] = "Sx/M3->S0/M0",
[0x09] = "Non-power cycle reset",
[0x0a] = "Power cycle reset through M3",
[0x0b] = "Power cycle reset through Moff",
[0x0c] = "Sx/Mx->Sx/Moff"
};
/* Progress Code 0 states */
static const char *const me_progress_rom_values[] = {
[0x00] = "BEGIN",
[0x06] = "DISABLE"
};
/* Progress Code 1 states */
static const char *const me_progress_bup_values[] = {
[0x00] = "Initialization starts",
[0x01] = "Disable the host wake event",
[0x04] = "Flow determination start process",
[0x08] = "Error reading/matching the VSCC table in the descriptor",
[0x0a] = "Check to see if straps say ME DISABLED",
[0x0b] = "Timeout waiting for PWROK",
[0x0d] = "Possibly handle BUP manufacturing override strap",
[0x11] = "Bringup in M3",
[0x12] = "Bringup in M0",
[0x13] = "Flow detection error",
[0x15] = "M3 clock switching error",
[0x18] = "M3 kernel load",
[0x1c] = "T34 missing - cannot program ICC",
[0x1f] = "Waiting for DID BIOS message",
[0x20] = "Waiting for DID BIOS message failure",
[0x21] = "DID reported an error",
[0x22] = "Enabling UMA",
[0x23] = "Enabling UMA error",
[0x24] = "Sending DID Ack to BIOS",
[0x25] = "Sending DID Ack to BIOS error",
[0x26] = "Switching clocks in M0",
[0x27] = "Switching clocks in M0 error",
[0x28] = "ME in temp disable",
[0x32] = "M0 kernel load",
};
/* Progress Code 3 states */
static const char *const me_progress_policy_values[] = {
[0x00] = "Entery into Policy Module",
[0x03] = "Received S3 entry",
[0x04] = "Received S4 entry",
[0x05] = "Received S5 entry",
[0x06] = "Received UPD entry",
[0x07] = "Received PCR entry",
[0x08] = "Received NPCR entry",
[0x09] = "Received host wake",
[0x0a] = "Received AC<>DC switch",
[0x0b] = "Received DRAM Init Done",
[0x0c] = "VSCC Data not found for flash device",
[0x0d] = "VSCC Table is not valid",
[0x0e] = "Flash Partition Boundary is outside address space",
[0x0f] = "ME cannot access the chipset descriptor region",
[0x10] = "Required VSCC values for flash parts do not match",
};
void intel_me_status(struct me_hfs *hfs, struct me_gmes *gmes)
{
/* Check Current States */
debug("ME: FW Partition Table : %s\n",
hfs->fpt_bad ? "BAD" : "OK");
debug("ME: Bringup Loader Failure : %s\n",
hfs->ft_bup_ld_flr ? "YES" : "NO");
debug("ME: Firmware Init Complete : %s\n",
hfs->fw_init_complete ? "YES" : "NO");
debug("ME: Manufacturing Mode : %s\n",
hfs->mfg_mode ? "YES" : "NO");
debug("ME: Boot Options Present : %s\n",
hfs->boot_options_present ? "YES" : "NO");
debug("ME: Update In Progress : %s\n",
hfs->update_in_progress ? "YES" : "NO");
debug("ME: Current Working State : %s\n",
me_cws_values[hfs->working_state]);
debug("ME: Current Operation State : %s\n",
me_opstate_values[hfs->operation_state]);
debug("ME: Current Operation Mode : %s\n",
me_opmode_values[hfs->operation_mode]);
debug("ME: Error Code : %s\n",
me_error_values[hfs->error_code]);
debug("ME: Progress Phase : %s\n",
me_progress_values[gmes->progress_code]);
debug("ME: Power Management Event : %s\n",
me_pmevent_values[gmes->current_pmevent]);
debug("ME: Progress Phase State : ");
switch (gmes->progress_code) {
case ME_GMES_PHASE_ROM: /* ROM Phase */
debug("%s", me_progress_rom_values[gmes->current_state]);
break;
case ME_GMES_PHASE_BUP: /* Bringup Phase */
if (gmes->current_state < ARRAY_SIZE(me_progress_bup_values) &&
me_progress_bup_values[gmes->current_state])
debug("%s",
me_progress_bup_values[gmes->current_state]);
else
debug("0x%02x", gmes->current_state);
break;
case ME_GMES_PHASE_POLICY: /* Policy Module Phase */
if (gmes->current_state <
ARRAY_SIZE(me_progress_policy_values) &&
me_progress_policy_values[gmes->current_state])
debug("%s",
me_progress_policy_values[gmes->current_state]);
else
debug("0x%02x", gmes->current_state);
break;
case ME_GMES_PHASE_HOST: /* Host Communication Phase */
if (!gmes->current_state)
debug("Host communication established");
else
debug("0x%02x", gmes->current_state);
break;
default:
debug("Unknown 0x%02x", gmes->current_state);
}
debug("\n");
}

151
arch/x86/cpu/ivybridge/microcode_intel.c Normal file
View File

@ -0,0 +1,151 @@
/*
* Copyright (c) 2014 Google, Inc
* Copyright (C) 2000 Ronald G. Minnich
*
* Microcode update for Intel PIII and later CPUs
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <errno.h>
#include <fdtdec.h>
#include <libfdt.h>
#include <asm/cpu.h>
#include <asm/msr.h>
#include <asm/processor.h>
/**
* struct microcode_update - standard microcode header from Intel
*
* We read this information out of the device tree and use it to determine
* whether the update is applicable or not. We also use the same structure
* to read information from the CPU.
*/
struct microcode_update {
uint header_version;
uint update_revision;
uint date_code;
uint processor_signature;
uint checksum;
uint loader_revision;
uint processor_flags;
const void *data;
int size;
};
static int microcode_decode_node(const void *blob, int node,
struct microcode_update *update)
{
update->data = fdt_getprop(blob, node, "data", &update->size);
if (!update->data)
return -EINVAL;
update->header_version = fdtdec_get_int(blob, node,
"intel,header-version", 0);
update->update_revision = fdtdec_get_int(blob, node,
"intel,update-revision", 0);
update->date_code = fdtdec_get_int(blob, node,
"intel,date-code", 0);
update->processor_signature = fdtdec_get_int(blob, node,
"intel.processor-signature", 0);
update->checksum = fdtdec_get_int(blob, node, "intel,checksum", 0);
update->loader_revision = fdtdec_get_int(blob, node,
"loader-revision", 0);
update->processor_flags = fdtdec_get_int(blob, node,
"processor-flags", 0);
return 0;
}
static uint32_t microcode_read_rev(void)
{
/*
* Some Intel CPUs can be very finicky about the CPUID sequence used.
* So this is implemented in assembly so that it works reliably.
*/
uint32_t low, high;
asm volatile (
"xorl %%eax, %%eax\n"
"xorl %%edx, %%edx\n"
"movl $0x8b, %%ecx\n"
"wrmsr\n"
"movl $0x01, %%eax\n"
"cpuid\n"
"movl $0x8b, %%ecx\n"
"rdmsr\n"
: /* outputs */
"=a" (low), "=d" (high)
: /* inputs */
: /* clobbers */
"ebx", "ecx"
);
return high;
}
static void microcode_read_cpu(struct microcode_update *cpu)
{
/* CPUID sets MSR 0x8B iff a microcode update has been loaded. */
unsigned int x86_model, x86_family;
struct cpuid_result result;
uint32_t low, high;
wrmsr(0x8b, 0, 0);
result = cpuid(1);
rdmsr(0x8b, low, cpu->update_revision);
x86_model = (result.eax >> 4) & 0x0f;
x86_family = (result.eax >> 8) & 0x0f;
cpu->processor_signature = result.eax;
cpu->processor_flags = 0;
if ((x86_model >= 5) || (x86_family > 6)) {
rdmsr(0x17, low, high);
cpu->processor_flags = 1 << ((high >> 18) & 7);
}
debug("microcode: sig=%#x pf=%#x revision=%#x\n",
cpu->processor_signature, cpu->processor_flags,
cpu->update_revision);
}
/* Get a microcode update from the device tree and apply it */
int microcode_update_intel(void)
{
struct microcode_update cpu, update;
const void *blob = gd->fdt_blob;
int count;
int node;
int ret;
microcode_read_cpu(&cpu);
node = 0;
count = 0;
do {
node = fdtdec_next_compatible(blob, node,
COMPAT_INTEL_MICROCODE);
if (node < 0) {
debug("%s: Found %d updates\n", __func__, count);
return count ? 0 : -ENOENT;
}
ret = microcode_decode_node(blob, node, &update);
if (ret) {
debug("%s: Unable to decode update: %d\n", __func__,
ret);
return ret;
}
if (update.processor_signature == cpu.processor_signature &&
(update.processor_flags & cpu.processor_flags)) {
debug("%s: Update already exists\n", __func__);
return -EEXIST;
}
wrmsr(0x79, (ulong)update.data, 0);
debug("microcode: updated to revision 0x%x date=%04x-%02x-%02x\n",
microcode_read_rev(), update.date_code & 0xffff,
(update.date_code >> 24) & 0xff,
(update.date_code >> 16) & 0xff);
count++;
} while (1);
}

60
arch/x86/cpu/ivybridge/pci.c Normal file
View File

@ -0,0 +1,60 @@
/*
* Copyright (c) 2011 The Chromium OS Authors.
* (C) Copyright 2008,2009
* Graeme Russ, <graeme.russ@gmail.com>
*
* (C) Copyright 2002
* Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <pci.h>
#include <asm/pci.h>
static void config_pci_bridge(struct pci_controller *hose, pci_dev_t dev,
struct pci_config_table *table)
{
u8 secondary;
hose->read_byte(hose, dev, PCI_SECONDARY_BUS, &secondary);
if (secondary != 0)
pci_hose_scan_bus(hose, secondary);
}
static struct pci_config_table pci_ivybridge_config_table[] = {
/* vendor, device, class, bus, dev, func */
{ PCI_ANY_ID, PCI_ANY_ID, PCI_CLASS_BRIDGE_PCI,
PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, &config_pci_bridge },
{}
};
void board_pci_setup_hose(struct pci_controller *hose)
{
hose->config_table = pci_ivybridge_config_table;
hose->first_busno = 0;
hose->last_busno = 0;
/* PCI memory space */
pci_set_region(hose->regions + 0,
CONFIG_PCI_MEM_BUS,
CONFIG_PCI_MEM_PHYS,
CONFIG_PCI_MEM_SIZE,
PCI_REGION_MEM);
/* PCI IO space */
pci_set_region(hose->regions + 1,
CONFIG_PCI_IO_BUS,
CONFIG_PCI_IO_PHYS,
CONFIG_PCI_IO_SIZE,
PCI_REGION_IO);
pci_set_region(hose->regions + 2,
CONFIG_PCI_PREF_BUS,
CONFIG_PCI_PREF_PHYS,
CONFIG_PCI_PREF_SIZE,
PCI_REGION_PREFETCH);
hose->region_count = 3;
}

89
arch/x86/cpu/ivybridge/report_platform.c Normal file
View File

@ -0,0 +1,89 @@
/*
* From Coreboot src/northbridge/intel/sandybridge/report_platform.c
*
* Copyright (C) 2012 Google Inc.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <asm/cpu.h>
#include <asm/pci.h>
#include <asm/arch/pch.h>
static void report_cpu_info(void)
{
char cpu_string[CPU_MAX_NAME_LEN], *cpu_name;
const char *mode[] = {"NOT ", ""};
struct cpuid_result cpuidr;
int vt, txt, aes;
u32 index;
index = 0x80000000;
cpuidr = cpuid(index);
if (cpuidr.eax < 0x80000004) {
strcpy(cpu_string, "Platform info not available");
cpu_name = cpu_string;
} else {
cpu_name = cpu_get_name(cpu_string);
}
cpuidr = cpuid(1);
debug("CPU id(%x): %s\n", cpuidr.eax, cpu_name);
aes = (cpuidr.ecx & (1 << 25)) ? 1 : 0;
txt = (cpuidr.ecx & (1 << 6)) ? 1 : 0;
vt = (cpuidr.ecx & (1 << 5)) ? 1 : 0;
debug("AES %ssupported, TXT %ssupported, VT %ssupported\n",
mode[aes], mode[txt], mode[vt]);
}
/* The PCI id name match comes from Intel document 472178 */
static struct {
u16 dev_id;
const char *dev_name;
} pch_table[] = {
{0x1E41, "Desktop Sample"},
{0x1E42, "Mobile Sample"},
{0x1E43, "SFF Sample"},
{0x1E44, "Z77"},
{0x1E45, "H71"},
{0x1E46, "Z75"},
{0x1E47, "Q77"},
{0x1E48, "Q75"},
{0x1E49, "B75"},
{0x1E4A, "H77"},
{0x1E53, "C216"},
{0x1E55, "QM77"},
{0x1E56, "QS77"},
{0x1E58, "UM77"},
{0x1E57, "HM77"},
{0x1E59, "HM76"},
{0x1E5D, "HM75"},
{0x1E5E, "HM70"},
{0x1E5F, "NM70"},
};
static void report_pch_info(void)
{
const char *pch_type = "Unknown";
int i;
u16 dev_id;
uint8_t rev_id;
dev_id = pci_read_config16(PCH_LPC_DEV, 2);
for (i = 0; i < ARRAY_SIZE(pch_table); i++) {
if (pch_table[i].dev_id == dev_id) {
pch_type = pch_table[i].dev_name;
break;
}
}
rev_id = pci_read_config8(PCH_LPC_DEV, 8);
debug("PCH type: %s, device id: %x, rev id %x\n", pch_type, dev_id,
rev_id);
}
void report_platform_info(void)
{
report_cpu_info();
report_pch_info();
}

571
arch/x86/cpu/ivybridge/sdram.c Normal file
View File

@ -0,0 +1,571 @@
/*
* Copyright (c) 2011 The Chromium OS Authors.
* (C) Copyright 2010,2011
* Graeme Russ, <graeme.russ@gmail.com>
*
* Portions from Coreboot mainboard/google/link/romstage.c
* Copyright (C) 2007-2010 coresystems GmbH
* Copyright (C) 2011 Google Inc.
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <errno.h>
#include <fdtdec.h>
#include <malloc.h>
#include <asm/processor.h>
#include <asm/gpio.h>
#include <asm/global_data.h>
#include <asm/pci.h>
#include <asm/arch/me.h>
#include <asm/arch/pei_data.h>
#include <asm/arch/pch.h>
#include <asm/post.h>
#include <asm/arch/sandybridge.h>
DECLARE_GLOBAL_DATA_PTR;
/*
* This function looks for the highest region of memory lower than 4GB which
* has enough space for U-Boot where U-Boot is aligned on a page boundary.
* It overrides the default implementation found elsewhere which simply
* picks the end of ram, wherever that may be. The location of the stack,
* the relocation address, and how far U-Boot is moved by relocation are
* set in the global data structure.
*/
ulong board_get_usable_ram_top(ulong total_size)
{
struct memory_info *info = &gd->arch.meminfo;
uintptr_t dest_addr = 0;
struct memory_area *largest = NULL;
int i;
/* Find largest area of memory below 4GB */
for (i = 0; i < info->num_areas; i++) {
struct memory_area *area = &info->area[i];
if (area->start >= 1ULL << 32)
continue;
if (!largest || area->size > largest->size)
largest = area;
}
/* If no suitable area was found, return an error. */
assert(largest);
if (!largest || largest->size < (2 << 20))
panic("No available memory found for relocation");
dest_addr = largest->start + largest->size;
return (ulong)dest_addr;
}
void dram_init_banksize(void)
{
struct memory_info *info = &gd->arch.meminfo;
int num_banks;
int i;
for (i = 0, num_banks = 0; i < info->num_areas; i++) {
struct memory_area *area = &info->area[i];
if (area->start >= 1ULL << 32)
continue;
gd->bd->bi_dram[num_banks].start = area->start;
gd->bd->bi_dram[num_banks].size = area->size;
num_banks++;
}
}
static const char *const ecc_decoder[] = {
"inactive",
"active on IO",
"disabled on IO",
"active"
};
/*
* Dump in the log memory controller configuration as read from the memory
* controller registers.
*/
static void report_memory_config(void)
{
u32 addr_decoder_common, addr_decode_ch[2];
int i;
addr_decoder_common = readl(MCHBAR_REG(0x5000));
addr_decode_ch[0] = readl(MCHBAR_REG(0x5004));
addr_decode_ch[1] = readl(MCHBAR_REG(0x5008));
debug("memcfg DDR3 clock %d MHz\n",
(readl(MCHBAR_REG(0x5e04)) * 13333 * 2 + 50) / 100);
debug("memcfg channel assignment: A: %d, B % d, C % d\n",
addr_decoder_common & 3,
(addr_decoder_common >> 2) & 3,
(addr_decoder_common >> 4) & 3);
for (i = 0; i < ARRAY_SIZE(addr_decode_ch); i++) {
u32 ch_conf = addr_decode_ch[i];
debug("memcfg channel[%d] config (%8.8x):\n", i, ch_conf);
debug(" ECC %s\n", ecc_decoder[(ch_conf >> 24) & 3]);
debug(" enhanced interleave mode %s\n",
((ch_conf >> 22) & 1) ? "on" : "off");
debug(" rank interleave %s\n",
((ch_conf >> 21) & 1) ? "on" : "off");
debug(" DIMMA %d MB width x%d %s rank%s\n",
((ch_conf >> 0) & 0xff) * 256,
((ch_conf >> 19) & 1) ? 16 : 8,
((ch_conf >> 17) & 1) ? "dual" : "single",
((ch_conf >> 16) & 1) ? "" : ", selected");
debug(" DIMMB %d MB width x%d %s rank%s\n",
((ch_conf >> 8) & 0xff) * 256,
((ch_conf >> 20) & 1) ? 16 : 8,
((ch_conf >> 18) & 1) ? "dual" : "single",
((ch_conf >> 16) & 1) ? ", selected" : "");
}
}
static void post_system_agent_init(struct pei_data *pei_data)
{
/* If PCIe init is skipped, set the PEG clock gating */
if (!pei_data->pcie_init)
setbits_le32(MCHBAR_REG(0x7010), 1);
}
static asmlinkage void console_tx_byte(unsigned char byte)
{
#ifdef DEBUG
putc(byte);
#endif
}
/**
* Find the PEI executable in the ROM and execute it.
*
* @param pei_data: configuration data for UEFI PEI reference code
*/
int sdram_initialise(struct pei_data *pei_data)
{
unsigned version;
const char *data;
uint16_t done;
int ret;
report_platform_info();
/* Wait for ME to be ready */
ret = intel_early_me_init();
if (ret)
return ret;
ret = intel_early_me_uma_size();
if (ret < 0)
return ret;
debug("Starting UEFI PEI System Agent\n");
/* If MRC data is not found we cannot continue S3 resume. */
if (pei_data->boot_mode == PEI_BOOT_RESUME && !pei_data->mrc_input) {
debug("Giving up in sdram_initialize: No MRC data\n");
outb(0x6, PORT_RESET);
cpu_hlt();
}
/* Pass console handler in pei_data */
pei_data->tx_byte = console_tx_byte;
debug("PEI data at %p, size %x:\n", pei_data, sizeof(*pei_data));
data = (char *)CONFIG_X86_MRC_START;
if (data) {
int rv;
int (*func)(struct pei_data *);
debug("Calling MRC at %p\n", data);
post_code(POST_PRE_MRC);
func = (int (*)(struct pei_data *))data;
rv = func(pei_data);
post_code(POST_MRC);
if (rv) {
switch (rv) {
case -1:
printf("PEI version mismatch.\n");
break;
case -2:
printf("Invalid memory frequency.\n");
break;
default:
printf("MRC returned %x.\n", rv);
}
printf("Nonzero MRC return value.\n");
return -EFAULT;
}
} else {
printf("UEFI PEI System Agent not found.\n");
return -ENOSYS;
}
#if CONFIG_USBDEBUG
/* mrc.bin reconfigures USB, so reinit it to have debug */
early_usbdebug_init();
#endif
version = readl(MCHBAR_REG(0x5034));
debug("System Agent Version %d.%d.%d Build %d\n",
version >> 24 , (version >> 16) & 0xff,
(version >> 8) & 0xff, version & 0xff);
/*
* Send ME init done for SandyBridge here. This is done inside the
* SystemAgent binary on IvyBridge
*/
done = pci_read_config32(PCH_DEV, PCI_DEVICE_ID);
done &= BASE_REV_MASK;
if (BASE_REV_SNB == done)
intel_early_me_init_done(ME_INIT_STATUS_SUCCESS);
else
intel_early_me_status();
post_system_agent_init(pei_data);
report_memory_config();
return 0;
}
static int copy_spd(struct pei_data *peid)
{
const int gpio_vector[] = {41, 42, 43, 10, -1};
int spd_index;
const void *blob = gd->fdt_blob;
int node, spd_node;
int ret, i;
for (i = 0; ; i++) {
if (gpio_vector[i] == -1)
break;
ret = gpio_requestf(gpio_vector[i], "spd_id%d", i);
if (ret) {
debug("%s: Could not request gpio %d\n", __func__,
gpio_vector[i]);
return ret;
}
}
spd_index = gpio_get_values_as_int(gpio_vector);
debug("spd index %d\n", spd_index);
node = fdtdec_next_compatible(blob, 0, COMPAT_MEMORY_SPD);
if (node < 0) {
printf("SPD data not found.\n");
return -ENOENT;
}
for (spd_node = fdt_first_subnode(blob, node);
spd_node > 0;
spd_node = fdt_next_subnode(blob, spd_node)) {
const char *data;
int len;
if (fdtdec_get_int(blob, spd_node, "reg", -1) != spd_index)
continue;
data = fdt_getprop(blob, spd_node, "data", &len);
if (len < sizeof(peid->spd_data[0])) {
printf("Missing SPD data\n");
return -EINVAL;
}
debug("Using SDRAM SPD data for '%s'\n",
fdt_get_name(blob, spd_node, NULL));
memcpy(peid->spd_data[0], data, sizeof(peid->spd_data[0]));
break;
}
if (spd_node < 0) {
printf("No SPD data found for index %d\n", spd_index);
return -ENOENT;
}
return 0;
}
/**
* add_memory_area() - Add a new usable memory area to our list
*
* Note: @start and @end must not span the first 4GB boundary
*
* @info: Place to store memory info
* @start: Start of this memory area
* @end: End of this memory area + 1
*/
static int add_memory_area(struct memory_info *info,
uint64_t start, uint64_t end)
{
struct memory_area *ptr;
if (info->num_areas == CONFIG_NR_DRAM_BANKS)
return -ENOSPC;
ptr = &info->area[info->num_areas];
ptr->start = start;
ptr->size = end - start;
info->total_memory += ptr->size;
if (ptr->start < (1ULL << 32))
info->total_32bit_memory += ptr->size;
debug("%d: memory %llx size %llx, total now %llx / %llx\n",
info->num_areas, ptr->start, ptr->size,
info->total_32bit_memory, info->total_memory);
info->num_areas++;
return 0;
}
/**
* sdram_find() - Find available memory
*
* This is a bit complicated since on x86 there are system memory holes all
* over the place. We create a list of available memory blocks
*/
static int sdram_find(pci_dev_t dev)
{
struct memory_info *info = &gd->arch.meminfo;
uint32_t tseg_base, uma_size, tolud;
uint64_t tom, me_base, touud;
uint64_t uma_memory_base = 0;
uint64_t uma_memory_size;
unsigned long long tomk;
uint16_t ggc;
/* Total Memory 2GB example:
*
* 00000000 0000MB-1992MB 1992MB RAM (writeback)
* 7c800000 1992MB-2000MB 8MB TSEG (SMRR)
* 7d000000 2000MB-2002MB 2MB GFX GTT (uncached)
* 7d200000 2002MB-2034MB 32MB GFX UMA (uncached)
* 7f200000 2034MB TOLUD
* 7f800000 2040MB MEBASE
* 7f800000 2040MB-2048MB 8MB ME UMA (uncached)
* 80000000 2048MB TOM
* 100000000 4096MB-4102MB 6MB RAM (writeback)
*
* Total Memory 4GB example:
*
* 00000000 0000MB-2768MB 2768MB RAM (writeback)
* ad000000 2768MB-2776MB 8MB TSEG (SMRR)
* ad800000 2776MB-2778MB 2MB GFX GTT (uncached)
* ada00000 2778MB-2810MB 32MB GFX UMA (uncached)
* afa00000 2810MB TOLUD
* ff800000 4088MB MEBASE
* ff800000 4088MB-4096MB 8MB ME UMA (uncached)
* 100000000 4096MB TOM
* 100000000 4096MB-5374MB 1278MB RAM (writeback)
* 14fe00000 5368MB TOUUD
*/
/* Top of Upper Usable DRAM, including remap */
touud = pci_read_config32(dev, TOUUD+4);
touud <<= 32;
touud |= pci_read_config32(dev, TOUUD);
/* Top of Lower Usable DRAM */
tolud = pci_read_config32(dev, TOLUD);
/* Top of Memory - does not account for any UMA */
tom = pci_read_config32(dev, 0xa4);
tom <<= 32;
tom |= pci_read_config32(dev, 0xa0);
debug("TOUUD %llx TOLUD %08x TOM %llx\n", touud, tolud, tom);
/* ME UMA needs excluding if total memory <4GB */
me_base = pci_read_config32(dev, 0x74);
me_base <<= 32;
me_base |= pci_read_config32(dev, 0x70);
debug("MEBASE %llx\n", me_base);
/* TODO: Get rid of all this shifting by 10 bits */
tomk = tolud >> 10;
if (me_base == tolud) {
/* ME is from MEBASE-TOM */
uma_size = (tom - me_base) >> 10;
/* Increment TOLUD to account for ME as RAM */
tolud += uma_size << 10;
/* UMA starts at old TOLUD */
uma_memory_base = tomk * 1024ULL;
uma_memory_size = uma_size * 1024ULL;
debug("ME UMA base %llx size %uM\n", me_base, uma_size >> 10);
}
/* Graphics memory comes next */
ggc = pci_read_config16(dev, GGC);
if (!(ggc & 2)) {
debug("IGD decoded, subtracting ");
/* Graphics memory */
uma_size = ((ggc >> 3) & 0x1f) * 32 * 1024ULL;
debug("%uM UMA", uma_size >> 10);
tomk -= uma_size;
uma_memory_base = tomk * 1024ULL;
uma_memory_size += uma_size * 1024ULL;
/* GTT Graphics Stolen Memory Size (GGMS) */
uma_size = ((ggc >> 8) & 0x3) * 1024ULL;
tomk -= uma_size;
uma_memory_base = tomk * 1024ULL;
uma_memory_size += uma_size * 1024ULL;
debug(" and %uM GTT\n", uma_size >> 10);
}
/* Calculate TSEG size from its base which must be below GTT */
tseg_base = pci_read_config32(dev, 0xb8);
uma_size = (uma_memory_base - tseg_base) >> 10;
tomk -= uma_size;
uma_memory_base = tomk * 1024ULL;
uma_memory_size += uma_size * 1024ULL;
debug("TSEG base 0x%08x size %uM\n", tseg_base, uma_size >> 10);
debug("Available memory below 4GB: %lluM\n", tomk >> 10);
/* Report the memory regions */
add_memory_area(info, 1 << 20, 2 << 28);
add_memory_area(info, (2 << 28) + (2 << 20), 4 << 28);
add_memory_area(info, (4 << 28) + (2 << 20), tseg_base);
add_memory_area(info, 1ULL << 32, touud);
/*
* If >= 4GB installed then memory from TOLUD to 4GB
* is remapped above TOM, TOUUD will account for both
*/
if (touud > (1ULL << 32ULL)) {
debug("Available memory above 4GB: %lluM\n",
(touud >> 20) - 4096);
}
return 0;
}
static void rcba_config(void)
{
/*
* GFX INTA -> PIRQA (MSI)
* D28IP_P3IP WLAN INTA -> PIRQB
* D29IP_E1P EHCI1 INTA -> PIRQD
* D26IP_E2P EHCI2 INTA -> PIRQF
* D31IP_SIP SATA INTA -> PIRQF (MSI)
* D31IP_SMIP SMBUS INTB -> PIRQH
* D31IP_TTIP THRT INTC -> PIRQA
* D27IP_ZIP HDA INTA -> PIRQA (MSI)
*
* TRACKPAD -> PIRQE (Edge Triggered)
* TOUCHSCREEN -> PIRQG (Edge Triggered)
*/
/* Device interrupt pin register (board specific) */
writel((INTC << D31IP_TTIP) | (NOINT << D31IP_SIP2) |
(INTB << D31IP_SMIP) | (INTA << D31IP_SIP), RCB_REG(D31IP));
writel(NOINT << D30IP_PIP, RCB_REG(D30IP));
writel(INTA << D29IP_E1P, RCB_REG(D29IP));
writel(INTA << D28IP_P3IP, RCB_REG(D28IP));
writel(INTA << D27IP_ZIP, RCB_REG(D27IP));
writel(INTA << D26IP_E2P, RCB_REG(D26IP));
writel(NOINT << D25IP_LIP, RCB_REG(D25IP));
writel(NOINT << D22IP_MEI1IP, RCB_REG(D22IP));
/* Device interrupt route registers */
writel(DIR_ROUTE(PIRQB, PIRQH, PIRQA, PIRQC), RCB_REG(D31IR));
writel(DIR_ROUTE(PIRQD, PIRQE, PIRQF, PIRQG), RCB_REG(D29IR));
writel(DIR_ROUTE(PIRQB, PIRQC, PIRQD, PIRQE), RCB_REG(D28IR));
writel(DIR_ROUTE(PIRQA, PIRQH, PIRQA, PIRQB), RCB_REG(D27IR));
writel(DIR_ROUTE(PIRQF, PIRQE, PIRQG, PIRQH), RCB_REG(D26IR));
writel(DIR_ROUTE(PIRQA, PIRQB, PIRQC, PIRQD), RCB_REG(D25IR));
writel(DIR_ROUTE(PIRQA, PIRQB, PIRQC, PIRQD), RCB_REG(D22IR));
/* Enable IOAPIC (generic) */
writew(0x0100, RCB_REG(OIC));
/* PCH BWG says to read back the IOAPIC enable register */
(void)readw(RCB_REG(OIC));
/* Disable unused devices (board specific) */
setbits_le32(RCB_REG(FD), PCH_DISABLE_ALWAYS);
}
int dram_init(void)
{
struct pei_data pei_data __aligned(8) = {
.pei_version = PEI_VERSION,
.mchbar = DEFAULT_MCHBAR,
.dmibar = DEFAULT_DMIBAR,
.epbar = DEFAULT_EPBAR,
.pciexbar = CONFIG_MMCONF_BASE_ADDRESS,
.smbusbar = SMBUS_IO_BASE,
.wdbbar = 0x4000000,
.wdbsize = 0x1000,
.hpet_address = CONFIG_HPET_ADDRESS,
.rcba = DEFAULT_RCBABASE,
.pmbase = DEFAULT_PMBASE,
.gpiobase = DEFAULT_GPIOBASE,
.thermalbase = 0xfed08000,
.system_type = 0, /* 0 Mobile, 1 Desktop/Server */
.tseg_size = CONFIG_SMM_TSEG_SIZE,
.ts_addresses = { 0x00, 0x00, 0x00, 0x00 },
.ec_present = 1,
.ddr3lv_support = 1,
/*
* 0 = leave channel enabled
* 1 = disable dimm 0 on channel
* 2 = disable dimm 1 on channel
* 3 = disable dimm 0+1 on channel
*/
.dimm_channel0_disabled = 2,
.dimm_channel1_disabled = 2,
.max_ddr3_freq = 1600,
.usb_port_config = {
/*
* Empty and onboard Ports 0-7, set to un-used pin
* OC3
*/
{ 0, 3, 0x0000 }, /* P0= Empty */
{ 1, 0, 0x0040 }, /* P1= Left USB 1 (OC0) */
{ 1, 1, 0x0040 }, /* P2= Left USB 2 (OC1) */
{ 1, 3, 0x0040 }, /* P3= SDCARD (no OC) */
{ 0, 3, 0x0000 }, /* P4= Empty */
{ 1, 3, 0x0040 }, /* P5= WWAN (no OC) */
{ 0, 3, 0x0000 }, /* P6= Empty */
{ 0, 3, 0x0000 }, /* P7= Empty */
/*
* Empty and onboard Ports 8-13, set to un-used pin
* OC4
*/
{ 1, 4, 0x0040 }, /* P8= Camera (no OC) */
{ 1, 4, 0x0040 }, /* P9= Bluetooth (no OC) */
{ 0, 4, 0x0000 }, /* P10= Empty */
{ 0, 4, 0x0000 }, /* P11= Empty */
{ 0, 4, 0x0000 }, /* P12= Empty */
{ 0, 4, 0x0000 }, /* P13= Empty */
},
};
pci_dev_t dev = PCI_BDF(0, 0, 0);
int ret;
debug("Boot mode %d\n", gd->arch.pei_boot_mode);
debug("mcr_input %p\n", pei_data.mrc_input);
pei_data.boot_mode = gd->arch.pei_boot_mode;
ret = copy_spd(&pei_data);
if (!ret)
ret = sdram_initialise(&pei_data);
if (ret)
return ret;
rcba_config();
quick_ram_check();
writew(0xCAFE, MCHBAR_REG(SSKPD));
post_code(POST_DRAM);
ret = sdram_find(dev);
if (ret)
return ret;
gd->ram_size = gd->arch.meminfo.total_32bit_memory;
return 0;
}

98
arch/x86/cpu/pci.c Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright (c) 2011 The Chromium OS Authors.
* (C) Copyright 2008,2009
* Graeme Russ, <graeme.russ@gmail.com>
*
* (C) Copyright 2002
* Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <errno.h>
#include <malloc.h>
#include <pci.h>
#include <asm/pci.h>
static struct pci_controller x86_hose;
int pci_early_init_hose(struct pci_controller **hosep)
{
struct pci_controller *hose;
hose = calloc(1, sizeof(struct pci_controller));
if (!hose)
return -ENOMEM;
board_pci_setup_hose(hose);
pci_setup_type1(hose);
gd->arch.hose = hose;
*hosep = hose;
return 0;
}
void pci_init_board(void)
{
struct pci_controller *hose = &x86_hose;
/* Stop using the early hose */
gd->arch.hose = NULL;
board_pci_setup_hose(hose);
pci_setup_type1(hose);
pci_register_hose(hose);
hose->last_busno = pci_hose_scan(hose);
}
static struct pci_controller *get_hose(void)
{
if (gd->arch.hose)
return gd->arch.hose;
return pci_bus_to_hose(0);
}
unsigned int pci_read_config8(pci_dev_t dev, unsigned where)
{
uint8_t value;
pci_hose_read_config_byte(get_hose(), dev, where, &value);
return value;
}
unsigned int pci_read_config16(pci_dev_t dev, unsigned where)
{
uint16_t value;
pci_hose_read_config_word(get_hose(), dev, where, &value);
return value;
}
unsigned int pci_read_config32(pci_dev_t dev, unsigned where)
{
uint32_t value;
pci_hose_read_config_dword(get_hose(), dev, where, &value);
return value;
}
void pci_write_config8(pci_dev_t dev, unsigned where, unsigned value)
{
pci_hose_write_config_byte(get_hose(), dev, where, value);
}
void pci_write_config16(pci_dev_t dev, unsigned where, unsigned value)
{
pci_hose_write_config_word(get_hose(), dev, where, value);
}
void pci_write_config32(pci_dev_t dev, unsigned where, unsigned value)
{
pci_hose_write_config_dword(get_hose(), dev, where, value);
}

40
arch/x86/cpu/start.S
View File

@ -13,6 +13,7 @@
#include <config.h>
#include <version.h>
#include <asm/global_data.h>
#include <asm/post.h>
#include <asm/processor.h>
#include <asm/processor-flags.h>
#include <generated/generic-asm-offsets.h>
@ -49,6 +50,8 @@ _start:
*/
movw $GD_FLG_COLD_BOOT, %bx
1:
/* Save BIST */
movl %eax, %ebp
/* Load the segement registes to match the gdt loaded in start16.S */
movl $(X86_GDT_ENTRY_32BIT_DS * X86_GDT_ENTRY_SIZE), %eax
@ -65,6 +68,7 @@ _start:
jmp early_board_init
.globl early_board_init_ret
early_board_init_ret:
post_code(POST_START)
/* Initialise Cache-As-RAM */
jmp car_init
@ -74,16 +78,29 @@ car_init_ret:
* We now have CONFIG_SYS_CAR_SIZE bytes of Cache-As-RAM (or SRAM,
* or fully initialised SDRAM - we really don't care which)
* starting at CONFIG_SYS_CAR_ADDR to be used as a temporary stack
* and early malloc area. The MRC requires some space at the top.
*
* Stack grows down from top of CAR. We have:
*
* top-> CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE
* MRC area
* global_data
* x86 global descriptor table
* early malloc area
* stack
* bottom-> CONFIG_SYS_CAR_ADDR
*/
/* Stack grows down from top of CAR */
movl $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE), %esp
movl $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %esp
#ifdef CONFIG_DCACHE_RAM_MRC_VAR_SIZE
subl $CONFIG_DCACHE_RAM_MRC_VAR_SIZE, %esp
#endif
/* Reserve space on stack for global data */
subl $GENERATED_GBL_DATA_SIZE, %esp
/* Align global data to 16-byte boundary */
andl $0xfffffff0, %esp
post_code(POST_START_STACK)
/* Zero the global data since it won't happen later */
xorl %eax, %eax
@ -91,31 +108,36 @@ car_init_ret:
movl %esp, %edi
rep stosb
/* Setup first parameter to setup_gdt */
/* Setup first parameter to setup_gdt, pointer to global_data */
movl %esp, %eax
/* Reserve space for global descriptor table */
subl $X86_GDT_SIZE, %esp
/* Align temporary global descriptor table to 16-byte boundary */
andl $0xfffffff0, %esp
movl %esp, %ecx
#if defined(CONFIG_SYS_MALLOC_F_LEN)
subl $CONFIG_SYS_MALLOC_F_LEN, %esp
movl %eax, %edx
addl $GD_MALLOC_BASE, %edx
movl %esp, (%edx)
#endif
/* Align temporary global descriptor table to 16-byte boundary */
andl $0xfffffff0, %esp
/* Store BIST */
movl %eax, %edx
addl $GD_BIST, %edx
movl %ebp, (%edx)
/* Set second parameter to setup_gdt */
movl %esp, %edx
movl %ecx, %edx
/* Setup global descriptor table so gd->xyz works */
call setup_gdt
/* Set parameter to board_init_f() to boot flags */
post_code(POST_START_DONE)
xorl %eax, %eax
movw %bx, %ax
/* Enter, U-boot! */
call board_init_f

18
arch/x86/cpu/start16.S
View File

@ -21,18 +21,16 @@
.code16
.globl start16
start16:
/* Save BIST */
movl %eax, %ecx
/* Set the Cold Boot / Hard Reset flag */
movl $GD_FLG_COLD_BOOT, %ebx
/*
* First we let the BSP do some early initialization
* this code have to map the flash to its final position
*/
jmp board_init16
.globl board_init16_ret
board_init16_ret:
xorl %eax, %eax
movl %eax, %cr3 /* Invalidate TLB */
/* Turn of cache (this might require a 486-class CPU) */
/* Turn off cache (this might require a 486-class CPU) */
movl %cr0, %eax
orl $(X86_CR0_NW | X86_CR0_CD), %eax
movl %eax, %cr0
@ -50,9 +48,11 @@ o32 cs lgdt gdt_ptr
/* Flush the prefetch queue */
jmp ff
ff:
/* Finally jump to the 32bit initialization code */
/* Finally restore BIST and jump to the 32bit initialization code */
movw $code32start, %ax
movw %ax, %bp
movl %ecx, %eax
o32 cs ljmp *(%bp)
/* 48-bit far pointer */

1
arch/x86/dts/Makefile
View File

@ -1,4 +1,5 @@
dtb-y += link.dtb \
chromebook_link.dtb \
alex.dtb
targets += $(dtb-y)

1
arch/x86/dts/chromebook_link.dts Symbolic link
View File

@ -0,0 +1 @@
link.dts

125
arch/x86/dts/link.dts
View File

@ -14,18 +14,21 @@
gpioa {
compatible = "intel,ich6-gpio";
u-boot,dm-pre-reloc;
reg = <0 0x10>;
bank-name = "A";
};
gpiob {
compatible = "intel,ich6-gpio";
u-boot,dm-pre-reloc;
reg = <0x30 0x10>;
bank-name = "B";
};
gpioc {
compatible = "intel,ich6-gpio";
u-boot,dm-pre-reloc;
reg = <0x40 0x10>;
bank-name = "C";
};
@ -38,6 +41,117 @@
chosen { };
memory { device_type = "memory"; reg = <0 0>; };
spd {
compatible = "memory-spd";
#address-cells = <1>;
#size-cells = <0>;
elpida_4Gb_1600_x16 {
reg = <0>;
data = [92 10 0b 03 04 19 02 02
03 52 01 08 0a 00 fe 00
69 78 69 3c 69 11 18 81
20 08 3c 3c 01 40 83 81
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 0f 11 42 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 02 fe 00
11 52 00 00 00 07 7f 37
45 42 4a 32 30 55 47 36
45 42 55 30 2d 47 4e 2d
46 20 30 20 02 fe 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00];
};
samsung_4Gb_1600_1.35v_x16 {
reg = <1>;
data = [92 11 0b 03 04 19 02 02
03 11 01 08 0a 00 fe 00
69 78 69 3c 69 11 18 81
f0 0a 3c 3c 01 40 83 01
00 80 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 0f 11 02 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 80 ce 01
00 00 00 00 00 00 6a 04
4d 34 37 31 42 35 36 37
34 42 48 30 2d 59 4b 30
20 20 00 00 80 ce 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00];
};
micron_4Gb_1600_1.35v_x16 {
reg = <2>;
data = [92 11 0b 03 04 19 02 02
03 11 01 08 0a 00 fe 00
69 78 69 3c 69 11 18 81
20 08 3c 3c 01 40 83 05
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 0f 01 02 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 80 2c 00
00 00 00 00 00 00 ad 75
34 4b 54 46 32 35 36 36
34 48 5a 2d 31 47 36 45
31 20 45 31 80 2c 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff
ff ff ff ff ff ff ff ff];
};
};
spi {
#address-cells = <1>;
#size-cells = <0>;
@ -53,6 +167,7 @@
compatible = "intel,lpc";
#address-cells = <1>;
#size-cells = <1>;
gen-dec = <0x800 0xfc 0x900 0xfc>;
cros-ec@200 {
compatible = "google,cros-ec";
reg = <0x204 1 0x200 1 0x880 0x80>;
@ -66,4 +181,14 @@
};
};
};
microcode {
update@0 {
#include "m12206a7_00000028.dtsi"
};
update@1 {
#include "m12306a9_00000017.dtsi"
};
};
};

622
arch/x86/dts/m12206a7_00000028.dtsi Normal file
View File

@ -0,0 +1,622 @@
/*
* Copyright (c) <1995-2013>, Intel Corporation.
* All rights reserved.
*
* Redistribution. Redistribution and use in binary form, without modification, are
* permitted provided that the following conditions are met:
* .Redistributions must reproduce the above copyright notice and the following
* disclaimer in the documentation and/or other materials provided with the
* distribution.
* Neither the name of Intel Corporation nor the names of its suppliers may be used
* to endorse or promote products derived from this software without specific prior
* written permission.
* .No reverse engineering, decompilation, or disassembly of this software is
* permitted.
* ."Binary form" includes any format commonly used for electronic conveyance
* which is a reversible, bit-exact translation of binary representation to ASCII or
* ISO text, for example, "uuencode."
*
* DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
* HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*---
* This is a device tree fragment. Use #include to add these properties to a
* node.
*/
compatible = "intel,microcode";
intel,header-version = <1>;
intel,update-revision = <0x28>;
intel,date-code = <0x04242012>;
intel,processor-signature = <0x000206a7>;
intel,checksum = <0xf3e9935d>;
intel,loader-revision = <1>;
intel,processor-flags = <0x12>;
/* The 48-byte public header is omitted. */
data = <
0x00000000 0x000000a1 0x00020001 0x00000028
0x00000000 0x00000000 0x20120423 0x000008f1
0x00000001 0x000206a7 0x00000000 0x00000000
0x00000000 0x00000000 0x00000000 0x00000000
0x00000000 0x000008f1 0x00000000 0x00000000
0x00000000 0x00000000 0x00000000 0x00000000
0x52b813ac 0xdb8994c7 0x70e9f6bb 0x9d6db2ff
0xf4d70f5d 0x5b1eccf6 0xac59106f 0x0ae2e2c1
0x1a7bbeb1 0x355a1d62 0x2e7eb594 0x09f8dea9
0x432a49e4 0xbf520253 0xdafa4010 0x893a858a
0x766e0efb 0xd91e196d 0x838bd2ef 0xe5146494
0xd515f413 0x29704828 0xe85598b6 0xdcbe6c51
0x88eabbfa 0xa1e8909f 0xd8931721 0x35386554
0x089a78a7 0xd9914775 0xd4644748 0x1556a4dc
0xf44448f6 0xd054d7db 0xf30f2b7d 0x5ae223d0
0xcbbb48b0 0x5c8b0383 0x177de157 0x9c1e5f73
0x2ec28289 0xd72a7b6c 0x823b6eb2 0x35e02171
0xba8deae4 0x06f4d468 0x13dbafaa 0x72b419f1
0x033385b5 0x05806920 0x4c6034cf 0x9bd117dc
0x976e2d04 0x250330f0 0x7250b5e1 0x184980c2
0x12a9d7d6 0x1bc808f9 0xae79994f 0xc6f87901
0xc0e3132f 0x671491c5 0x236cad39 0x37889d9c
0x67f7c3f3 0x964a6be5 0xbcced7da 0x57eeaa6e
0x7bca1522 0x654fee4c 0x2a1ca5d9 0xa1803cf3
0x00000011 0x8c316d2c 0x17603b7e 0x32e42981
0xc26c1400 0xf0fbccb6 0xeab6b43a 0x11d456a5
0x5b912d46 0x15195fe0 0x542f6db3 0x0b7f212e
0x47718dd9 0x7c41b108 0x06c21111 0x4445d5ea
0xb4fb8128 0xe07404a6 0x8d503da4 0x78fc7e44
0xb9919656 0x9968c797 0x87f26ab0 0x23bb1af7
0x1ec5d761 0x26f30d2c 0x7cdb747c 0xe4d42033
0x8a5d4801 0x768aff57 0xbcfd5d11 0x7c853c2d
0x231e6207 0x8b1988a6 0xd68fdb75 0x58dcb417
0x44422ef9 0x2a186ebb 0x7d27e85f 0x36ac31f7
0x1e487e77 0x2b0b8c37 0xd8ba682f 0x2cba791b
0xe6d3dece 0x1b2c2a99 0x4e5decab 0xfbd313a3
0xdbc78294 0x5a80cce7 0x2d8e0f0b 0xcf564f71
0x073d1f37 0x25162870 0x96cdb85b 0x9c553048
0x24eba740 0xfc0f352e 0x0c83be68 0x89b5076c
0xc39c4355 0x6a4cf25c 0x2bbd2682 0xc524fdb9
0x7ea19bae 0x191ad6f1 0xd3fbf3bf 0x21bf77fa
0x8f77fec4 0x0f90f635 0xe55e165c 0x868d58c0
0x966bc0ad 0x6c276364 0x9d8f7eff 0x4b7925d4
0x8b2f9326 0x4ab7b47e 0x33a9087c 0xf31ab949
0x69831dfb 0x4711a215 0x8128c1fa 0x8481c213
0x7401b01b 0xfdcfdc50 0xd6b55266 0xae9b23ac
0xfa2ad275 0xa225bb45 0x4dd720c4 0x760a20e6
0x5f1223c9 0x2f334372 0x6e1dcdab 0xe8ee8638
0x1c19ba8a 0xef9341c4 0x360aaa9d 0x90452ea9
0x65852446 0xe9398fa3 0xbba6a631 0x1a3e90b9
0xe2a73a56 0x6e8c0747 0x35c7c53d 0xcc1ac842
0x183356af 0xb6e98608 0x987b43c2 0xa8a3cfd2
0xc2c5fce0 0xcc3af64a 0xd6d3a291 0xe59ad1f5
0x124ca513 0x9522b50a 0x25150477 0xa2eb5797
0x7fc63626 0x648c48e3 0x9f5797ff 0x2307b84d
0x980625a4 0xabc05983 0x24980807 0x773c4f99
0x3407b872 0x07c3657a 0xa2cd9e48 0x49c1e6a8
0xa881b84c 0xf804d72c 0xb5319d2a 0x3e39780f
0x97518822 0x0acd54c2 0x0721a9ff 0x10e1d2fd
0xa7b6db77 0x845b1a56 0xef00160e 0x6b41bfd5
0xc994df0d 0xcf44a5ca 0x794b36a4 0xf9fdb127
0x922a1366 0x822aa8a9 0x4b137bd5 0x5722a49f
0x8933719a 0x17edc1a9 0x079d9538 0x21fae7d5
0xe534fd73 0x9d3038d5 0x48c3a056 0x5b22d58a
0x6f142866 0xf1d767cd 0xb51ad5a6 0x34a0ef85
0x0111703e 0xca4b3a30 0xa0f3c34d 0x9d48775a
0x3f2059f9 0xf2fe2c36 0x588861a9 0xed5bd9fe
0x8231f7cb 0x8c115969 0x3f82ba00 0x21b3730c
0xba757997 0x3ec0bb2c 0x16f11def 0x5d4356c6
0xdc2e0bc2 0x58c1eb6e 0x313ede0c 0xb68fcc52
0x84d3e1b5 0xcc6d9201 0x95046196 0x276b527b
0x80a4a729 0xe782916d 0x5cf09e0b 0x98aaf9fa
0x1de6dd43 0xab4f1962 0x49ece734 0x81455488
0xc2597b61 0x5b22af85 0x646f7b94 0x09213a1f
0x08edf7e4 0x963d343c 0x059ba888 0xb4e804ed
0xe7cc826c 0xf87bafc7 0xeecaec10 0x8e60919c
0xbf14c996 0xd3dcaee3 0xb8fa0b7e 0x81563c6e
0x7f59a258 0x2f344446 0x374d8aa6 0x9b6de5c9
0xbf992857 0xbc5b94fc 0x28adb080 0x17e41044
0xb87b469e 0xda504d12 0xf21bef8b 0xce75c1e3
0xdbd92c83 0x58bba0af 0x77b42977 0x506cfd75
0x1139e875 0x6ce5fe43 0xc6a5d7b3 0x87f9e628
0x7b5c500b 0x130066b3 0x789b611f 0xec8c1ba9
0xb7e6872d 0xaf828cd6 0xc28d3316 0x2a91f6d0
0xc725f063 0x065ac531 0x4f9ef4b8 0x2b9d927e
0xaf54f3f9 0x7c924f72 0xda1d77ad 0xff00db67
0xaf4f03c0 0xb4f4ee64 0x169e64e5 0x04653ac0
0xed51cb70 0xfeaff0e5 0x51dbf346 0x072a2407
0x23fb74f4 0x9a906eef 0x5d6fc3f0 0xbc3c374c
0x1cf9f063 0x919015d9 0x5b3e9d07 0xd6209d8b
0xa3710b3d 0x90ad23b8 0x420ceedc 0x58e8371f
0x5d419d1f 0xb8acd13f 0x7d100d6d 0x210c10d1
0xcd0a697e 0x5023db4b 0x33e6d8e7 0x44bbe6b4
0x827e859f 0x6ca4cc81 0x661bb2c3 0x71209ee8
0xb8c3ffaf 0xd1075f51 0xba1eae10 0x728b0a6a
0xe4af7a2f 0xca9bcf2e 0xb249a631 0xdce6be47
0x5c910321 0x425c3c27 0x33083e43 0xdea067ae
0xea594a23 0x41b75c2c 0x3a401a95 0xd33cd88a
0xc295cad0 0x67f48045 0x1dc9ad4c 0x4bc48864
0x53991b6e 0x7aadde5f 0x2b0bf775 0x06ba5380
0x9eb874be 0x2c4b967a 0x1bcc342f 0xe875001b
0x15b5642d 0x5be99c9d 0xcb210ace 0x1b4924ad
0x3793ed81 0x8b983114 0x3ec33981 0x75ec71e7
0x8b5b7df3 0x834756f4 0x100fad01 0x70037fdf
0x0cef9a36 0x3d9e3a2d 0x38b48efd 0xfc4034b6
0xa32e29dd 0x388944bc 0xc1c15614 0x3877e9c7
0xa5e733fa 0xa621bd53 0x4b651df6 0xce082970
0x85f30d6f 0x729a5c87 0x31dd7ba9 0xdb495828
0x7b12c698 0x953495c9 0x6b5f99e7 0x2cc42fa8
0x697ac512 0x1be679de 0xc116d305 0x94a36606
0x9e5e141e 0x874affed 0x58d40b0b 0x5e3cf5e5
0x5d05e9a9 0x06840efc 0xd2f98b21 0xa1e83ab2
0x4f726202 0xa6394535 0x62a02403 0x9f2167ec
0x4f9fc77b 0x98073be4 0x2bc781fa 0xfc8e4c89
0xc7179b97 0x692cf793 0x708ff7bb 0x12ecba93
0xacd06e21 0x202bef76 0x03852241 0xe84e02a1
0xf1f9ac8d 0xcee61aef 0x61a4f235 0xd22991eb
0x67a81345 0x375a15c6 0xe8fae8a3 0xb4ff2b37
0x339ee4ea 0x14ffadc3 0xf49340dd 0xf285e568
0x00fc6970 0x369c52d1 0x4f55368f 0x3f4d75f1
0x6a73b603 0x963c1f59 0x171e2bdc 0x72bac76b
0x9e2e5c32 0x307f7c3f 0xd3b48637 0x3a917acf
0xea52a65f 0xecd209fb 0xf0ad84bf 0xd4bdea70
0xa2647b38 0xce040b49 0xc6d5f13d 0x5d942c52
0xf8edc042 0x798fdefd 0x4b074246 0x1cb1873a
0x6793c186 0x23b9c774 0x77bb0202 0xc519b3aa
0xa30c09a2 0xe1f6669a 0xb7eddb8d 0x7aaa91d6
0x076a3789 0x0ac47791 0x1e503404 0x44fe8c54
0xf3cbbf49 0xd3234eef 0x0d898b3f 0xe854984b
0xe3986de9 0x923a5c76 0x2ee9abca 0x1a9fedbe
0xdf76dcd1 0xea07936b 0xcdaaf247 0xe62d98fa
0xa99c7f7b 0x34fc84d4 0x03a35111 0xad5675c8
0xcc64075b 0x408203f9 0x846e1f08 0xe934019e
0x423d1223 0x2f04f9e3 0xee1dbf40 0x65edc60f
0x097aa22f 0x7058a2b7 0x41c8a0a5 0xa68aa391
0x0f345c40 0x667517e6 0x860838ba 0x6dae933b
0x764d5919 0x6673fa0f 0xf0a5e97d 0x4262ebbe
0x64b413f2 0xd2c4145a 0x0b2c11f3 0xfdfe9f93
0x96c77107 0x1399fdda 0xf599f215 0xb504da5d
0xf8a95268 0x9ed1ef87 0x9ae33cfb 0x3b21f1ef
0xc6d447c2 0xe0694d4e 0x967febab 0xc13f631d
0x8393bfba 0x37438788 0x1724194d 0x8e77a045
0x20e2483c 0xb961c2fc 0x485cf593 0xb3462621
0xcb2959b8 0x10307e19 0xf71fbbfd 0xdda641e1
0x0daf5f66 0x56d85178 0x145f6749 0xebc46ed1
0x5593c249 0x94561f51 0x534cc654 0xca7c8814
0xb59a578c 0x40b2b614 0xeaf3437a 0x198d5b4e
0xf245fa53 0xfb75e0b0 0xa363c46d 0xc43b5468
0xdf036413 0xc59f5a36 0xd8ff4381 0xa3af3e36
0x7af63462 0x414526d7 0x7bdc41c5 0xa416f1e7
0x6987d9ad 0x472c5499 0x4f10ee37 0x47bb7ff7
0xc7f2e621 0x820008f7 0x33a475db 0x91ff5d72
0x0517401c 0x73d067c8 0xe417b69d 0xb86d9903
0x1ac9a032 0x74bbf582 0x8b65596e 0x883be34c
0x95dcc26f 0xe232c646 0xfae9c19f 0x35cb5273
0x6a94d095 0xfff6ca91 0xb9c40eb5 0xd351dcac
0xc90d464f 0x9b609642 0x15663b56 0x15f7f88d
0x22499f60 0x417fd6c5 0x2dc36fe2 0x712bf66a
0x22f1fba8 0x531b8092 0x40d269b6 0x1d227898
0xeb6ff35b 0x2490ac31 0xc958ed65 0x3ce6ffb7
0x9338a806 0x3beadfe2 0x1c361ac9 0x53d0e3b0
0x91d46102 0x4d57045f 0xb5c8afb3 0xfd2c9e7d
0x3d578410 0x2adb9406 0x10df7459 0x90abccfb
0xe3f217ed 0xef5f4e09 0x74925ce4 0x169b5879
0xfeff4ad5 0xb300dd1d 0xc96022ba 0x72da501b
0x1e694296 0x9efa33cb 0x0dc3ee6c 0x0ac4e7ea
0x73041130 0xf0e6a295 0xc46bdb6a 0x6a927044
0xd217ceca 0x0b744007 0xd5a2bafb 0x4220cd92
0x70d3352a 0x5ee4f661 0xfa07e5c0 0x155542d9
0x4a39fba0 0xcec0552d 0x30c1d8ef 0xbef9d21e
0x183879aa 0x5b3f30a8 0x54a06db4 0xef876e4e
0x5e823680 0x53e2a353 0xc9aa4112 0x13a56ee5
0x848859fd 0x0ba2b801 0xec15260f 0x7bb22672
0x1a097332 0xb141339f 0x752a67d9 0xdae373f3
0x3c8cfd49 0x2dfaf2a9 0x95820c6c 0x956b39a2
0x1ca0d24e 0x1312b978 0x7280e1bd 0xa7a7c2ff
0x0b48e987 0xb6083e55 0x4b4b82f4 0x9c6104ad
0xcb93beca 0xe1c34035 0x34de740d 0xbb151baa
0x71f5942f 0x1eaac228 0x0c68331b 0x3d2a1dd0
0xe7a3d41a 0x7253acae 0xfd4de230 0x79988d80
0x4468f19b 0xac4440fd 0x6e8a6ef3 0x5736adf8
0xded67716 0x1f1d5a4b 0x96c5f451 0x85bae181
0x1293ab28 0xc2ba53c2 0x729ff4cf 0x60218df8
0xc2870138 0x6127d844 0x89604e9e 0xd2b9ad4e
0x4f6ded9f 0xdd263849 0x1633bd92 0x64b03a24
0x96dabd4d 0x6e85d235 0x1ab69ad0 0x9aa80454
0x6b9041e0 0x106c7e9a 0x8f54812f 0xa274efe4
0xe45d6695 0xf3aa7bd3 0x6a5a2a63 0xe36f3525
0x6238fa4b 0x7d6cb06f 0x16d3b4a2 0xf3b04822
0x638f1a60 0x0e1875fa 0x1c0292b9 0x6b519ea4
0x9faba37b 0x209341ec 0x83c9061f 0x3387dfe8
0xc7f12ceb 0x2bef45d7 0x8f8acb47 0x35d9741b
0x7009f514 0xfd003802 0x6f9489c5 0xe2ea2504
0x910e996a 0xcc81d016 0x3280730d 0xdedfef59
0x5a7357cc 0x8fe8dd39 0x15543fe5 0x976c4207
0xe41cf62b 0x0ba6b4b5 0x5c3b7ced 0xa6c5b72b
0x72ad3b4d 0xff143181 0x2b78a157 0x7fe231a5
0x6ff0538a 0xe58ed1ac 0x81a311a5 0xefaa54b8
0xf04a797e 0xce6e69c7 0xdc810726 0x7bab7be3
0xdd5923e8 0x5a2413ed 0x31cef794 0x73dfd806
0x1b9223c1 0x0c370882 0x04fa3b68 0x87c50bc1
0x1d78c90f 0xf4e2cee6 0xebea941b 0x73e5838f
0xca8d39a6 0xe004296b 0x28cf8a0e 0x7c73e7ef
0x26a296c2 0x789d4c72 0xd1490265 0xd9a9e843
0xf03504c3 0xfae6dffb 0x7a48f00d 0x51e369c8
0xcb3eeee6 0x0625e936 0xe93d0d7d 0xfb15ba6b
0xec5c76da 0x8fdf44f1 0xa036653a 0x5730c4a3
0xe5bfe6dd 0x0b8c091f 0x3b51558c 0x403748f4
0xf4007f86 0x952b5db6 0x5524d8ba 0x8046409a
0xe3fc61a9 0x66f4ea56 0x5645150b 0xdb2bec15
0x50672218 0x7f40e87d 0x2b8359f8 0x438787dc
0x7f221597 0xf8b1590c 0x4f468251 0xff586d05
0xb9195380 0x0ee09e0b 0x2fa7dbd9 0xd197b327
0xa0dbad58 0xb485681f 0x5ef0937c 0x1e07ebb6
0xcb49fe3f 0xc2427cd9 0x6c2c5298 0x4a2e171a
0xa7f333a8 0xb3609ad6 0x94e374d6 0x0e1eb64d
0x22c3367d 0xcdf89975 0x647aceef 0x16727c9c
0xf476ae53 0x35a1212e 0x0db768b8 0xfff8b53d
0xbd4fe45e 0xab28a5a3 0x59cec0af 0x28bcd1ef
0x6f43ad69 0x2658a059 0x27aee0ec 0x4e8bbd15
0xa9fdcf04 0xc9aa329f 0x687f010f 0x5c968a07
0xb894e607 0x0e1cba22 0x2f00f203 0xe8e133ac
0x494a4746 0xe8bdff9a 0xf69791a2 0x64179ce2
0xbfd10dc6 0xc026f6d8 0x4871923a 0x8946b277
0x609f49a4 0x6466df1b 0xd8c3c131 0x46ef0291
0x0fdce8b6 0x2b9aedb7 0x225c4520 0x72b332cf
0x4e220d47 0xf2f69c36 0x2c23fad9 0x57a2a918
0xe017409c 0x490819af 0xf2121afd 0x951ff7ff
0x40363fcf 0x5078b94e 0x9e4be775 0xee97ef16
0xdb3a2390 0x17d42af9 0x96f56a51 0x1b4c2934
0xc866315c 0x2b746f99 0x9a3b73f6 0xa1e081fc
0xa9d07ebd 0xa6359fae 0xdf50d099 0x55304e01
0xfe5aaa81 0x1e74267d 0x38b1d2d7 0x8633e9af
0x99b013df 0x3aa05831 0x86279736 0xd2b464e0
0xdf036a9f 0xe8162915 0x876c0d4f 0x4beb7d0e
0xfec9b170 0x46bc9df4 0x46cb88fa 0x0cb5904d
0x2e2961cf 0x7ea5dc1a 0x60670df2 0xf935ca32
0x67e6777b 0x8bacc97a 0x5cd07248 0x32e483e6
0xfdf09b0d 0xca57150b 0x3f432d09 0xdea2d7db
0x9f6a2954 0x6f07dff3 0x4133f394 0x60272f97
0x1b98c9ec 0x2ab648d9 0xb5df14a8 0x0d2c38f2
0x5dfde2c4 0x7cb43ca3 0x8d0c6c01 0xe80ea41e
0x5f58b71e 0x4ca9fef2 0xabd201a4 0x50905c08
0xca8ba387 0x5592922b 0xfa4e05f5 0xceb64b14
0x0845c5bd 0x518d369b 0x727e570c 0x1daaab31
0x801e8b9c 0xec6568f3 0xd4c3760f 0x40a78d22
0x38af58b5 0xc406a76e 0x8c3a7779 0x18272c42
0x45cf7b70 0xa6f3c0f3 0x88021e41 0xda662504
0xe97aa709 0xe93bafe0 0x8862ed5f 0x35bc8268
0xf5a41551 0x3dd3bb21 0x1af0cf11 0x08fe1ad7
0x53ecae41 0x01a4a8ae 0xfed636b7 0xf09323e6
0x73b9b253 0x7ebd7ce2 0x7074b4de 0x21c719b2
0x50982743 0xd23cfd27 0x136a1f4a 0x23260f6e
0xfad89dcd 0x57586681 0xadc4fba5 0xad0f71b8
0x91a3f188 0x20d62385 0xfecda9cb 0x33d67776
0x2abb0e6c 0x0ad16087 0x486332da 0x2928d342
0xf6d1b174 0x5e133a4e 0x72fc0ad4 0x940578b8
0x320a42b1 0x9cbda7d4 0xf2a36135 0x00ab8de3
0x5bad9000 0x5778e633 0x3952763d 0xe0e58583
0xdfb0bf19 0xb11914b6 0xa67da7a1 0x8d9a9f81
0x638cbcf7 0x83bf931d 0x8703b0dd 0xcab30fa4
0xd6db2ee6 0x5cc2e5ac 0x717e636b 0xfdcbc760
0x563b3b25 0x0e4df458 0x9efb8fa7 0x95aaa7a1
0xf05b6680 0x5e237e59 0xc884018a 0x177b5a30
0x3ea2c9bc 0xd0325ee6 0xb1dae51b 0x812ee29d
0x6d58db21 0xb787fa68 0xfd092294 0x09683dd3
0xfe0d6405 0xfdd99aad 0x78744a59 0x936738e6
0x6ad6cba7 0x370f7f8f 0xd208c214 0x12239384
0xbe71f0e7 0xfc0ef264 0xc04e4a49 0x354f9cf3
0xf5d7572c 0x07839ad0 0x834a003d 0x23ba26e2
0xf4049ecf 0x5ff402b2 0xff9d6769 0x074ebe6d
0xdc829da1 0xc3d7697d 0x973efe4f 0xfc2a9165
0x126dc518 0x0b824ca4 0xc438fb70 0xb7b0ee00
0xbe56afd9 0xa3d8defd 0x971455ae 0xc11ffde7
0x346e619a 0xb41111a9 0x6004b62e 0x896c668d
0x738e458c 0x351f9fdd 0xe771b2ba 0xad6d7464
0x719b57c2 0x6f6a4611 0x8a676f2d 0xb8db1c43
0x3f102641 0x51bffdbc 0xb7862565 0x5d8dd231
0x7a79bd39 0xfa472894 0x0fd1d2ff 0x64cf589a
0x38234d7a 0x5c9acefd 0x8eb0b9f8 0x761e1c95
0xf2fe78fa 0xe06220d7 0xaf82a919 0xf4e196e1
0xa17c8935 0x06d08d16 0x6bad807b 0xf410805d
0x4ff2bce6 0x3297c81f 0x06e35353 0xbe1f5e1c
0x65d1cb92 0x0dc69b2f 0xac55d597 0x636ff24c
0xe2e4f2ba 0x63d64922 0x4b2e9f71 0xad2279ec
0x5f0b5c0e 0xac688638 0x35613358 0xf5531360
0x54a304e8 0x27ebfe65 0x977b5a3c 0x3dc5e10c
0x73b32ee9 0x3a2c9454 0x30a149c6 0x31e5b55c
0x2c10854f 0x745cd38a 0x2853a27b 0x6629e355
0x0bb67e39 0x5469184d 0x694a9bb6 0x0a0ca25f
0xa878c5de 0xee15fd46 0x23d92ff8 0x02328404
0x1c9402b5 0xa46b6ce0 0xefc3e947 0x0e9312ad
0x5830ae9e 0xe30e32f2 0x9db8ee81 0xe8aeebbc
0x30675c83 0x447278c2 0xab2bad3b 0x08ba3d0c
0x1124e681 0x3691242d 0x903c8d2b 0x3281c312
0x22af690f 0xd69a150c 0x57622c5b 0x29313c73
0x6ab2d7c6 0x39b06dad 0x6e1f9f81 0x03324986
0x53a49093 0x7654eba3 0x2527245a 0x9af596fb
0x818ffb3a 0xa3817173 0x6a2c4b80 0xfcc42ad5
0xfb1bbb69 0x3a3720a2 0x90a89bcf 0xed80308d
0x7753cb1c 0x1c2654a5 0xb01ee4af 0x81091e85
0x9067b3f1 0x2e2b9b5e 0x9fb0c7d1 0x78fd9f69
0x5771c46d 0xacdf498d 0xfd8b8e77 0x4c15fa61
0x607120ce 0x18a298d8 0x73716420 0x65e5e06a
0x18c53e04 0x35b84427 0xcd82b522 0x9a7d26bb
0xd56b4b74 0x49b47fe8 0x63178dc6 0x0bac0f46
0xc8b0755a 0x9bbaaf1f 0x18131d2b 0xcc019330
0x0ceb89bb 0x8808c2d6 0xfb5bd86c 0x6c945b71
0xdc911924 0x4ebb8d35 0x44e46d08 0xabfee615
0xf456931f 0x7a244955 0x0bffce7d 0x5533ca5f
0xb1b2c636 0x4f29075e 0x64012561 0x7aa5e7c7
0x9c8a0666 0x9698782d 0x3481ad8f 0x21a55b19
0x735aa45d 0x4245b9c4 0x0d4c3fdc 0xd1b10966
0x7035fcde 0xc2257947 0x4a37271a 0x9da464a9
0x228adbf8 0xbf309e03 0x096f560a 0xa2b8ca78
0x427702cd 0x35a99cf5 0x99811758 0x6953db58
0xec07533e 0xe95838b9 0x61c71654 0xc9cce595
0x275af106 0xc8697af3 0xb3f27e58 0x411d8d30
0xd0d90ecd 0x1503b9dc 0x76bf070e 0x49f89ef0
0x7333b083 0x53f9c44b 0x8330c3a2 0x6a1119c3
0xca555f2b 0x3d51fc6f 0xac7b3320 0xf8e42cdf
0x053753fe 0xc122336f 0x94d289c6 0x088b5a64
0xc3aac7f0 0x96a76344 0x2ff05828 0x9b4f2af3
0x46de6a46 0x4ed29d98 0xe2ab7634 0x27481ddc
0x300ca71f 0xce7ac539 0x88240e09 0xb1a14e78
0x2addd4c5 0xb3a7f320 0xe91f549b 0x6881c45b
0x0e381c47 0x1018feb4 0x64679650 0xe62281cc
0x670ee6d4 0x0d226160 0x947b7f08 0xbc595a74
0x2380c0b3 0xc0235785 0x63b41221 0x80b9cc31
0x3231b4ae 0x33ed5718 0xf2c5c90f 0xdd3b03ea
0x67dfca08 0x453e9d29 0xa2bdecbf 0x5e9a3181
0xad17aea2 0xff0a8f13 0xdf946849 0xcfbbecb7
0xb0a602d7 0xb1a820c6 0xfe7abbc8 0x7f70790d
0xeb5f8863 0x266d3cc1 0xbd552a44 0xe19b1b3d
0x856aefbd 0x51c11f1e 0xde661b7f 0x61c075d2
0xd0f6a834 0xff1d0d37 0x6793d1c2 0x70c133a5
0x20c4d2cf 0x8c80d4d3 0x61ebe382 0x788b74df
0x11c56903 0x535889ba 0x0a9c7380 0xf9de2837
0x09437fe7 0x1627c6b2 0xb943bdb8 0x69bc29b2
0xee9795a4 0x83c992e0 0x95437918 0x8ce166a2
0x56b56b66 0xb0680941 0x623d38a9 0x2add07ad
0xe583ba09 0x96f6532a 0x3eff4696 0x2a8a6b0b
0x905b913b 0xafc01673 0xe871e006 0x2c2339ad
0x248438e5 0x96d83e53 0xb3a75d6b 0x2258cf63
0x69ff39bf 0x95727173 0xc3ac09d5 0xea8d2c06
0x0e7c0a4b 0x144fcade 0x28a9a5a3 0x97c11ae8
0x89865e3d 0x1640cd32 0xe3e551f8 0x1f7ba770
0x6d23fb31 0x11eceae3 0xc8ccb8ee 0x46dd0bb0
0xd01a46ff 0x0504adf5 0xec6e170e 0x2e3d7ac5
0x70f893ac 0xaf9963db 0x061e283c 0xf0ad248f
0x2fe97e19 0x881fd340 0xc686c9d5 0x88ea8ba5
0x92f05cd7 0xd6716148 0x6fc47fc3 0x2c51d9b9
0xd50a7faf 0x4eccacd1 0x7c92f802 0xa63ffc83
0x7cb0ab1d 0x4492e81b 0x7d906554 0x43306ba1
0x73a5d57a 0xe57a05d6 0x6850b964 0xefed595c
0x7754978f 0x629e8236 0x62ec4dde 0x247439ee
0x8b9982fa 0x4eece5c2 0x48599175 0x0fdc752c
0xecd87b12 0x94936c75 0x17a45ea1 0x80a899ac
0x22a39ee7 0x745730b6 0x03ea4daf 0x4a7570d7
0x307621fa 0x7322e0a7 0x3a8e0316 0x454e46f7
0x08773750 0x156dcaad 0x5562bc06 0xa23a1ee3
0x20435211 0x1d679ea0 0xb220e205 0x682cc1a6
0xd64a71c7 0x3ca7f8e3 0x2e92f253 0xa7cfdd0b
0xd62b4053 0xf5c5f641 0xbf72dde1 0xdcb716c1
0xe2f7b05d 0xa03145ea 0xc09828d2 0x7dae7916
0x6fb97c79 0xb3a85204 0x998a9c7b 0x5f42ba8c
0xd9c628b3 0x6b17bacb 0xa889b716 0x450ff97d
0xe9166f3c 0x2d20777b 0x82a003ae 0x2c7ae0aa
0x6011a9fe 0xfeed34be 0x1328f67e 0xf61003a3
0xfaecdf20 0xee18c81e 0x731a0302 0x11a39e60
0x355d78dc 0x99088f2c 0xcf253759 0x97347603
0x736f71f1 0x37e4b395 0x9cc74540 0xf7e39994
0xf01c5f64 0xbec519f1 0xa79c1067 0x76000d5e
0x1ac85b6e 0x51e5b7a3 0x62a97ddf 0x6f20096a
0x2af51e77 0xea5554f6 0xb4e581da 0xc1ac4ba8
0xc8f22bf7 0x9e254d3b 0xd7dd62f6 0x6461ae3e
0x423e1f10 0xf143e7b9 0x18c73b04 0xa43de614
0x2da8d02f 0x9befa706 0xc01dcd49 0xa278f1e0
0xd85f3177 0x6b6679fd 0x1ccef04e 0x53af9252
0x34d751db 0xc8d32c86 0x3d725097 0xa64ed581
0xd090c42f 0x9e92bf3f 0x6f82b089 0xd42728eb
0x3dd651e0 0x1985bc52 0x4b0f4159 0x0f99bd7f
0xe2597023 0xca0cae4c 0xce48a894 0x7249dd88
0x8e146632 0xb4be1d6c 0x790ae7e5 0x6747b657
0x52143947 0xa2e42ed3 0xea359617 0x6ca01a11
0x35c5e2dc 0xc97b78fc 0x5db6db2a 0x80fe3414
0x27da19d4 0xd7431d04 0xa91e9110 0x7d8ecb23
0x2508700a 0xc8c71ed9 0xd28835af 0x018c2887
0x3d0a6fab 0x3e8523d6 0xd0688dee 0xe5c3865c
0x838d72e4 0x6bb73a1d 0x497a59ca 0xf77c56de
0x38ecb72e 0xa55e3565 0x04b12c92 0x1aec9997
0x037c340a 0xef0d04c3 0x78f74bd6 0xdec9b9e8
0xd95b61ea 0x5528e8f5 0x4ecd325c 0x88ffdc0b
0xb337ac61 0x899d90e7 0xb5eeb978 0x8295d9ae
0x1ed8978b 0xa8849eda 0x8633b4a3 0xb8c858b5
0xbe3c4375 0x28b9e84e 0xb2a26def 0x22f8f66b
0x3a4aed99 0x0c4914ea 0xad103249 0xba5a5eff
0x8a052461 0x26938899 0x915c6ed7 0xe6268ad9
0x246e8c74 0x75f3c196 0xc3e725d6 0x92e02549
0x1f78a5cb 0xeada57e5 0x40f14906 0x0215e49c
0x57c06bae 0xc1896b87 0x0cd40a63 0x60741d80
0x11a69899 0x80fed942 0x0497e115 0x56697b55
0xba89c3d4 0x27d6b7c5 0xddff87b0 0xd3b1ff2f
0x3160e528 0x9cca1286 0x13b4fdf1 0x38cdd907
0xb50c4597 0x4c151714 0x1cab86c7 0x23126a3e
0xe26e9749 0x289a0d0e 0xc4004640 0x9d33928d
0x33b691a2 0x15ed6e6b 0x6e773980 0xadd59678
0x188ba49f 0x08da4c6d 0x6d150d0b 0x0c6c7b98
0xc8e1df7e 0xb8b1e692 0x5e89fd35 0xcb253d24
0xfc6ee27c 0x8013de3d 0x1d38012b 0xe50a8f7b
0x7d410ff1 0xceee4e9f 0x0e8094b6 0xaa1a5f57
0xb395a551 0xbd62b2ae 0x5d7b34c8 0xbd2d6195
0x33af4109 0x0769ff18 0x9c6cc123 0x78ee6eb6
0x412644e7 0x70e0c6f4 0xf45d8fc6 0x0435f5af
0xd43622b7 0x27409d5b 0x6dd04e8f 0x9f02ecf5
0xca415f7d 0xc9f439c2 0x7198e539 0x20476b75
0x3cdd8dd8 0xce17fbb0 0xa5bc115e 0xb0ee52c1
0x0b074cfa 0xd26d4f99 0x3b43320b 0x230b680b
0x9908f2d2 0xcbcb1952 0xf45a2f53 0x7b4564c6
0xcf2fd983 0x414fe4b2 0x55ea7f11 0x63e8117d
0xe8954052 0x7c2ea344 0x97a02aaf 0x6ca874c3
0x1ae5b4ee 0x41754eae 0x6954abe0 0x115ddcda
0x9a27968b 0x32a53e65 0xffe47b2f 0x4fe7e5a7
0x6016dedc 0xb3c0893e 0x9626776d 0x5ec773f9
0x1104e01c 0x1473cfb3 0x43b2cedf 0x8ca9d119
0x7f1bc844 0xd8bb7387 0xba90d2ef 0x2bb0dcf4
0x2340f124 0xa5bd514c 0x50afab05 0x718f5ad5
0x7c03fad9 0x71d00d2d 0x1c31fdc2 0x4a938809
0x40945ded 0x437f2a0d 0x83c10d64 0xd224c6ab
0x0cd44481 0xb0040966 0x27fd6e7f 0x6ff45d4c
0xab057ad1 0x8fa4e5d4 0xac50270c 0x6e4926ca
0xc5721498 0x2529b458 0x40ee2ad5 0xde5e21f2
0xea8964ca 0x56766e60 0xdc3b8702 0xa93528d4
0x28d7713d 0x42edf022 0x59774dd8 0x200ff942
0xe7a4d769 0xd8c4ef5e 0xe177f715 0xe9d53cd6
0xc11270bb 0xb25977e5 0xb80867b4 0xfb48468b
0xdbf166a8 0x49700d85 0x0f85f98a 0xa7ca7a75
0x109817ce 0xca243f19 0x8bed7688 0x9a1c8231
0x94f0ce97 0xc36309ca 0x90ecac24 0x67e7e0de
0x86b18d62 0x18c7b7a5 0x622f5d3a 0x47e1e067
0xdc96b94d 0xe4a03beb 0x59d17692 0x040abc0d
0x44a5ae50 0x3d3dab7d 0xc18dfd30 0x2802b9d9
0x6818379f 0x56db41d7 0x97cbf039 0xe41d6a32
0x64b5fb01 0x6506e0b4 0xd60a3234 0xdf3573d2
0xac148579 0xe7f46ac0 0x05e1c763 0x904a5aa9
0xc7ca1ee0 0xe0c3b047 0x5e36e1bc 0x447a9141
0xe24654df 0x9853a49b 0x6a29cedb 0x022f00dc
0x6df2a7a7 0x3636da02 0x72bb9c81 0x4f0e0918
0xd649f4a5 0xbb0c81f9 0xc0ba93fd 0xc1b390f1
0xda84e720 0x1aea0064 0xf3ee67e1 0xb874ef4a
0x82467ce6 0x59abf506 0xafbf145a 0x9a4cf8a1
0x17247c89 0xd8669398 0x1796eaf7 0xbc2d24a9
0xcb486570 0x17a9db23 0x3e6504f0 0x08684517
0x2723ab28 0x7081b814 0x8a265a04 0x697e6d8b
0x69b146dc 0x6434c182 0x27ec8101 0x864405c5
0xfff86c9e 0x3052d8a6 0x23d283db 0x492970e8
0xbc6c64c3 0x46d8f98b 0xe16e7ff3 0x731e4f82
0xbd26b1af 0x6b30e6c1 0xff192fce 0x097e0bba
0x49df63a5 0x2fdc3f01 0x50aae053 0x60177b8f
0x1949eb85 0xa46084ce 0x9658f694 0xcb951fbc
0xc53806d9 0x63a17d30 0x3b3f86c2 0x8a37aa6c
0xedf8fe5c 0x87aee1d3 0x8c680126 0xfd8b27a6
0x231fa106 0x69358c25 0x4502c348 0xc107861c
0x46280e70 0xcf6067ac 0xf6a04ff3 0x3e488677
0x6f3fb4c1 0xeec1f758 0x560e1c48 0xb604c06b
0x69e34b1e 0x8ef41dec 0x854cea22 0x726581d7
0x55ea91f3 0x38ae4053 0x5ff7389d 0x6952cbf6
0x09aa0fc1 0xcccb1d50 0x5c1a633a 0xde1eba46
0x797212d8 0xa943fb3d 0x6063a1a8 0xbe68ef36
0x6ba0d5ba 0x0dbe2061 0x47711712 0x62679807
0x6f34009e 0xe6fe8f18 0x66a6a64b 0x3f80f472
0xe953d5e0 0xbcd8196a 0x086faad0 0x49da7f16
0x7f2199a5 0x55af4af2 0x085b4d38 0x22e634bd
0x6cff0416 0x343466f4 0xd121a7a6 0x6caa3942
0xe4f365a2 0xd832eb0c 0x616728e5 0xcca4c71a
0x4010cdc2 0xd0f1d1cb 0x5e695f89 0x27719206
0x0ec92854 0x76144a1b 0x49808021 0x12457a1b
0xdde7aa5c 0x8f1a077f 0x110a4a5a 0xb3a5ad31
0xaacebf8f 0x66ff7f33 0xa2340971 0xfb4c7e82
0x8dd536d7 0xafd2021a 0x72aa9c6e 0x22df6952
0x83c4b4fb 0xba515555 0x93eee8f0 0x22d0ed5a
0xbec05586 0x83828f28 0xe0d7f930 0xac0f0199
0xef6d76f9 0xf56ebdf8 0xf67323c9 0x8b805745
0xce5902c0 0xfa2ce3da 0x10f836dd 0xe1ac6d97
0xa0e415ea 0xbb7c32ad 0xc421f3b0 0x8166e898
0x74e7a73c 0xf454b82a 0x631369b1 0xe30ed23f
0xdaa1c75b 0xe7c9c6a7 0x5f33c375 0x99c05187
0xf2d6e6ae 0xcd2045b8 0x92ff3009 0x15082015
0xd1a1580e 0xdce25f9b 0x21984a75 0xa9be5388
0x099a5372 0x3ab9bcfa 0xdb9069aa 0x49a99be6
0x42a9ee0b 0xfe32d832 0x24e11ad3 0xd16f596b
0xb95982cc 0x754ab1c8 0x42ffa128 0x539e823d
0x28e0f976 0x262ddfc0 0x2a16e7ad 0x49b5acd9
0x931f3def 0xdc419b84 0x8412cc3c 0x81056cd9
0x91933e1f 0x57710b15 0xa55d2696 0x87d88724
0xd4fedfdc 0xcc3825c6 0x397f382f 0x80f9b6ba
0xcdd6d59f 0x24b984d8 0x8f1c5bcf 0x25bcef1d
0x00dc603a 0x76fd94c2 0xa267a7dc 0xa6e90a6a
0x5c5916d6 0x065a52cf 0xa28d3263 0x9b17b72d
0xb8436b48 0x1b1c2391 0x1fda3395 0xa6cecbcb
0xbc4ec502 0x1766b590 0x5945fbd6 0x6a124405
0xf92d06f2 0xe24694b7 0xf6befd08 0x8266cf5c
0x03ed670a 0x5f98be62 0xf27b7e2e 0x598cf22c
0x2e855591 0x879815fb 0x153799c6 0x3820faf6
0x3d3a2cc6 0xdbb6dece 0x1a3c46b2 0x5031bdda
0x47894c03 0xe43661fe 0x7a6ee548 0xa5ca9779
0x6aa9e105 0xbc8505a3 0xa03b860a 0x448faeb9
0x367de4a9 0xc9779c7d 0x6535ad8c 0x4b7fcacc
0xb2db5c10 0x0ab41ec6 0xe528ab90 0x5e6f03da
0x98bc76d3 0xf38df42e 0xea59b039 0x1c2eaa28
0xca30dac5 0xdb0eb8c6 0x60063860 0x18823f8d
0x164e2f28 0x7cbbe080 0x70a12315 0xb08f44d9
0x5fbb9453 0x4bc62738 0x9fa15ffc 0xe4033ca1
0xc9dfbc13 0x58245d7d 0x588113aa 0x8f5a6ac8
0x92588a60 0x26330c74 0xb2aaf0e3 0x24ada1ea
0xa9e973ae 0x624b73e7 0x4ef961db 0x95ede155
0xf2bb86ff 0x96bc79d9 0x95cd646b 0x1c3af453
0xf60fa711 0x10905115 0x0e24b740 0x169bb227
0x34cee6f0 0x990980db 0x18d8ace5 0xd4c87504
0x29515d32 0x2e5d9c04 0x87dffa60 0x12e815d1
0x021db8e9 0x2c5a42fd 0x6e3a1a13 0x88889ab5
0x3bc915a6 0x608919c5 0xd310a970 0xea8f3218
0x949f55bc 0x9ed7aadd 0x6d990157 0x181f1c2f
0xa940df64 0xf3be8c39 0x7ca2e699 0x7b4f07f9
0x89e83fee 0xe66b9493 0x54fc3d17 0xa63d2d46
0xd5e835d5 0x910e0144 0xecf67025 0x1fa6a93a
0xe692dbca 0x466af681 0xc2bc808c 0xbb4ebd60
0x74d5c729 0xa283ad25 0x1e66fa23 0x6d372988
0x753c9fcb 0x1742efdb 0x5b68cf15 0x372a0e33
0xaa3a7ebd 0xa0e944d5 0x95d5cbb4 0x4fb6020b
0xced927b0 0xb2afea78 0xd0646b72 0x1622fad4
0x4672c6b6 0x736ae4f8 0x8d46a4db 0x0e6a432e
0xe0a30a98 0x4c2bcf4f 0xd87acedd 0x19682d7a
0xf97c025c 0x55d8feb3 0xbcd4d2ff 0x236c6f9f
0x8ba0246d 0x42812f73 0x327636f5 0xc92cd30a
0x08a69d9d 0xc735a946 0x82eca01f 0xda0753a0
0x7077b1d1 0x17b05834 0xfa24bc02 0xf49f4473
0x8f9ac6b4 0xa880c630 0xf7457b4d 0xd5f829e4
0x25c49a99 0x1176a997 0xbb2d2009 0x61d35764
0xa322c752 0x6ef3ae02 0x5faae6f8 0x9a52acf1
0x19176f43 0x43843b07 0x14efc471 0xee474403
0x319c4857 0xa19adcf0 0xc0a466e1 0x02db14ad
0xb7f211f3 0x72aa6ca6 0x0eb9bffe 0x48a6d284
0x9a93a2ee 0xac09fc5f 0x92a62c4f 0xd34f0271
0xffb348c7 0xf229b6e2 0xc68ec1ca 0x19577dbc
0x069a10bf 0xf64ac347 0xf7c3c848 0x81975294
0x6376e550 0x93b53440 0x8bb17daa 0xc4c64c07
0xcaeff293 0xd51497b0 0x33da3565 0xa73d5def
0x4bf4dcde 0xfb470fcd 0xca7db864 0x7ef17022
0x47567363 0xd8fb8d74 0xa68c3c72 0x8202e4f3
0x75bf1798 0x16a70fd2 0xcc3b697f 0xab9a1075
0x13f56ef3 0x269d0302 0xcb655a43 0xc9a4de88
0xfb8363de 0xff40f36d 0xd2555489 0x647a7995
0xfd8eda6e 0xa3958c9a 0x20e029b4 0xbed3e225
0xa7df5f17 0x63bc3c1a 0x337ecc9d 0x6c329508
0x786aa47e 0x1db5b093 0xc0acd73b 0xf9587237
0x243e5d40 0xd3623c3a 0x338c4740 0xb672140e
0x43640a9b 0xb7ef3f6a 0x44151074 0x749bcc46
0xfa1f103b 0x0fefb19e 0x58855538 0x138ad276
0x2641fd80 0x297d99d0 0xfaa63ba2 0x00b6f11a
0x3793fb6b 0x124763a1 0x8b9419ac 0x56abf9eb
0xdbf83419 0x43570571 0x37299cd8 0x8b201e62
0xa4058fa5 0xb320e91b 0xbe7d40b7 0x4eca3b2d
0x8519c155 0xf4b17021 0x9e4c572a 0xdc1f9e16
0x39a589a3 0xa6cfc7a8 0x5b986910 0x64e150e7
0x60b6f2c1 0x02bacd3f 0x2f3b5a5c 0xc6f453a8
0x15a87a7e 0x76104a14 0xafa2ef63 0x2cd48dbe
0x3c7abddc 0xd786ea5a 0x4f65867a 0x355cda38
0x2ae03d9e 0x4f11f6be 0xfc0a0034 0xde4ea602
0x21ff83ea 0x0f12d913 0xedf4da28 0xc96d8fd1
0xd7e82c3c 0xfec63bdc 0x37a456d7 0x3007e18c
0x091a47b6 0x82f1c641 0x82219cce 0x3e7e6993
0x7b3a2115 0x0b8e1a02 0x40f88213 0xfa2f9c21
>;

750
arch/x86/dts/m12306a9_00000017.dtsi Normal file
View File

@ -0,0 +1,750 @@
/*
* Copyright (c) <1995-2013>, Intel Corporation.
* All rights reserved.
*
* Redistribution. Redistribution and use in binary form, without modification, are
* permitted provided that the following conditions are met:
* .Redistributions must reproduce the above copyright notice and the following
* disclaimer in the documentation and/or other materials provided with the
* distribution.
* Neither the name of Intel Corporation nor the names of its suppliers may be used
* to endorse or promote products derived from this software without specific prior
* written permission.
* .No reverse engineering, decompilation, or disassembly of this software is
* permitted.
* ."Binary form" includes any format commonly used for electronic conveyance
* which is a reversible, bit-exact translation of binary representation to ASCII or
* ISO text, for example, "uuencode."
*
* DISCLAIMER. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
* HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*---
* This is a device tree fragment. Use #include to add these properties to a
* node.
*/
compatible = "intel,microcode";
intel,header-version = <1>;
intel,update-revision = <0x17>;
intel,date-code = <0x01092013>;
intel,processor-signature = <0x000306a9>;
intel,checksum = <0x3546450b>;
intel,loader-revision = <1>;
intel,processor-flags = <0x12>;
/* The 48-byte public header is omitted. */
data = <
0x00000000 0x000000a1 0x00020001 0x00000017
0x00000000 0x00000000 0x20130107 0x00000a61
0x00000001 0x000306a9 0x00000000 0x00000000
0x00000000 0x00000000 0x00000000 0x00000000
0x00000000 0x00000000 0x00000000 0x00000000
0x00000000 0x00000000 0x00000000 0x00000000
0x86c5b0d4 0xf6978804 0x7f4f5870 0x6319dc3c
0xbb3b7d61 0x33cf9075 0xe8424658 0xf611a357
0x5a3401db 0x42caecce 0xb4d8e75e 0xe6dbaf24
0x7861b35f 0x6bd717bc 0x23b9b731 0x82ec1ac8
0x20337b64 0x5396dbf1 0x59973bff 0x724bc7e9
0x5237193b 0x0b8647c1 0x6a0d0e16 0xbf9ddb5b
0xace2cc1c 0xad707638 0x056f102f 0xa37e60f8
0x76255642 0xfb86e030 0xb8069a40 0x367795f1
0x653fb05e 0xab7f14ad 0xb6e8a8e1 0xd2598d20
0x2eba3f68 0x78b372f1 0xba8d13f8 0x1f1de861
0x97f951d5 0x8097c728 0x27dbf904 0xb97906a8
0xffe7a4ac 0x4b947668 0xc1dbd726 0x2adcf777
0x63b1bcf0 0x818e2a1b 0x49aa907b 0x2faf5e8d
0xae842352 0x82707fae 0x0aa12b41 0xa0bae11c
0xb4298c47 0xd2b4099c 0x4ff625f2 0xcd2630d4
0x79850981 0x05dbf57d 0xb05b81a5 0x56e73ec7
0x95cb3897 0xe262bda5 0xb2c6e288 0xcb7f8e77
0x72b8bdd3 0x3f400494 0x63ade65b 0xbc4adc71
0x00000011 0x06c0f8ff 0x0eb63d77 0xc54cdabf
0x76bc8860 0xdd142643 0xe7bfc220 0x17aa0a91
0x4fd676ba 0x4b6b1a15 0x2a1a1c16 0x4fed6de0
0x8c3d6bcf 0xbb319bf6 0xa82532f1 0x7c8ce014
0xb830a38b 0xec25bc6b 0x61c8a8a9 0x49a21dba
0xfcf8bad0 0x7372f29c 0x1f7fbcdd 0xc2ff42f4
0x780878f0 0xc967068e 0xe19cc3c9 0x155e6646
0x75235c43 0x9aaf3741 0x9dfd116d 0x0f031b6a
0x4963e039 0x6918daa8 0x7f0ca4ab 0xd77dad79
0x2f8847e8 0xf79c82a4 0x6a6aaad4 0x24f07dbc
0x895d3f6a 0xc96b2eb0 0xff50228f 0x573d364a
0x5fca9d56 0x3c11c35b 0x3e90fb12 0xc4604067
0x5c980234 0x7c42e0c7 0x60cca3de 0x637a4644
0xedc43956 0xb0efb4e1 0xe94716fa 0xa6478f51
0x33965654 0xdf6b40a3 0x48ac1b18 0xd6723c94
0xf040d6d1 0xaf850470 0xe2bcde48 0xb90a4998
0x8f620105 0x3d592878 0x2f697bad 0x9f7721d9
0xec34444a 0xb0594770 0xd7180f9f 0xa510a168
0x460563b0 0x5d4f34f4 0x21dfc16b 0x051de344
0xa57bc344 0xff2c7863 0xf0bc063d 0xf5a89004
0x79a81dab 0x9e8cb974 0x2309b0a4 0xa47a46de
0xcf9c0c44 0xf761c817 0x67ab642c 0x0db4422f
0xca3616fc 0x79e66c8a 0xd56a3332 0x5e0f338b
0x5814cb3a 0xed1b9a4d 0x47d59f72 0x25b03786
0x3edd1d42 0x8cd947cd 0x706e6ebd 0x82c2bada
0x1bf6a96b 0x77dd859a 0xda35335f 0x22fab458
0xd0661fd8 0x02bb4a42 0xe2a2bcdb 0x0616580e
0xd35be23f 0xc206d16c 0x401218be 0x51107c3d
0xba84b8be 0xace4d8f2 0x505b9b28 0xc517034b
0xac5ba582 0x7419fe54 0x43493cb1 0x2fe0a66e
0x206039b5 0x07569011 0x230ce53d 0x168d427f
0xbfe0bd10 0x82bf11be 0x5b55475b 0x5490a0e9
0x1c3c1e3c 0xacad77de 0x1666512f 0xfc3250d8
0x930a6312 0xdd85c066 0x1b95c18f 0xc8bbd3b0
0x1bb2a34e 0x642c7653 0x0f536213 0x1f7ab4eb
0xaa5ef677 0xe6ac9581 0xd7a2fe73 0xd417dc79
0x455a6877 0xae825a40 0xe0c98bec 0xac39ba49
0x299d9bd9 0x957d0bb0 0x1645111b 0xe9da4beb
0x1b005ce7 0xddb742ce 0x6c5f3ffc 0x24f74d2c
0xf4ace044 0xb21bc7ba 0x338002dc 0x240effa1
0xd208ae00 0xfe8c2b5c 0x9a457293 0xd9365ac4
0x98f24244 0xf6d1aaea 0x7b874350 0x1ba4086b
0x1d3bf168 0x2bb6f4fa 0xb27f8477 0x8da836f6
0xa8762693 0xc377fa64 0x74cfd979 0x90435c25
0x29d80e17 0xc3503c9c 0xaacd2178 0x232c748d
0x6fecd3ba 0x00fb4aa0 0xbac3ee19 0x6e5c63e3
0x17823c14 0x0e9d33bc 0x0fa9de06 0x998b14b2
0xfdd8c80d 0x01b0591b 0xf70bc4ce 0xb278c496
0xa7e30708 0x69cf8420 0x14f8b744 0x8bb8a0ff
0x168f6db0 0x95da6db2 0xf96d121d 0x67fd06f7
0xcd81d278 0x8693d095 0x15e1a24c 0xe5f554f2
0x499874e8 0x30fc0785 0x0f4fa1b9 0x65c93dad
0xd939bf24 0xdad29721 0xf253b752 0xf6ff59da
0xc5dfaffc 0xf0071f34 0xdb0db8b0 0x24475e2d
0x2a4d5b8a 0xf7624bea 0x3fdcbc90 0xb5a66e35
0xd0f08636 0x24643caa 0xc5d08e83 0xb134c55c
0x8e3653c7 0x34496b0c 0x6b2aeebc 0x2fbab601
0x105613a2 0x7babd55d 0xa01af846 0x248be690
0xed27917c 0x26ee6e13 0xa1dac5fe 0x852ed91a
0xfc83fcca 0xdf479c33 0xfd6efe96 0xdc62521b
0xa37d2a8c 0x1d2bad9e 0x4287614f 0xc4f7b62c
0x2aab0562 0xec6d4226 0x52853fb4 0x264e3507
0x1c3af366 0x33269776 0x81b8529d 0x115530dc
0xe035f98f 0x433d1b6c 0x1ea6daea 0xecfd2ad2
0xa57a0c22 0x1dbe3e12 0x6fafe41b 0x8e579e35
0x6c493fbb 0x034dd4f9 0xd17cd6f2 0x05c5cfa8
0xd9bffa39 0x0fc16e9c 0x831b88c8 0x7e7dce3e
0x3320bc7f 0xd5abafaa 0x217ab526 0xade2597d
0xf01b00f2 0xc9e34b72 0x00a4cb0b 0xdc198512
0xdc7cc8a1 0x89db07b5 0x6c2153ea 0xb8bdb8aa
0xdf8a1ae8 0xa517f6b1 0xd32569d9 0x37e79008
0x3c7527c3 0x7d5b2d3b 0xb31cb907 0x35db7f6c
0x0ab0cd65 0x75feaded 0x7c8260a9 0x5bc04f56
0x2fac9f60 0xd7b3a2c0 0x2b393634 0xc2df7f43
0x1ff2fa9f 0xc81af169 0x188b1f4e 0x08bf6f86
0x5ab2f188 0x0a71eb64 0x03b57501 0xa684fc23
0xa729ffef 0xe3b4a709 0xf9eb97d2 0x01506c95
0x0d9285f5 0x8e1ee93c 0x7d15a0d8 0xd9390673
0xf116ebd8 0x7e68798b 0x3dc8412e 0x5a9a04b4
0xe3805f51 0x00493bb1 0x4ec65ca2 0x2aedd69a
0x7f2a5b18 0x9994ac32 0x476f3703 0x7d3da882
0x5635f55f 0x7a0887e0 0x0af46feb 0xfc2f3591
0x02e29400 0x70fd3234 0xc549379e 0xaf34fa5a
0x5bf7c649 0xeb183cff 0xa236d508 0x4525ab64
0xc4301026 0xf281df99 0x0b298e46 0x9b7c1a99
0xc4b24e77 0xea536992 0x5a39e37c 0x570fb6df
0xae5d5c49 0x01142cc2 0xda05d3f1 0x337bf65c
0x3c986598 0xbecefd30 0xb5e34c2a 0xe7c3847f
0x18cb24b4 0x71278c26 0x4b8d6caa 0xaf7c300e
0xfb6ce9b8 0x94c4b785 0x67275f17 0x59498cf5
0xca8eeec6 0x3374e7a6 0x649affac 0x9049ba78
0xff9d3908 0xaceec446 0x225ece3a 0xac1d4fec
0xdc050fed 0x04e3ed8a 0xb303d8e9 0xe9d26aff
0x0a98691d 0xf243492d 0xe3b42f00 0x6c21a97b
0xa385ae98 0x14ba3f4d 0xc0215cc1 0xe1ba6c0d
0x412bbbe4 0x39f95d1c 0x593bd878 0x45d3066a
0x9fcee8a1 0x3f29b2fa 0xc9ae58ee 0xed6def92
0x6c8f2182 0xdba64e20 0x276c2c21 0x81ea9dfe
0x20ae00b2 0x8c2d2724 0x66c09f5c 0x24908e2e
0xfecf8194 0x6be61e94 0xcdf5d7db 0x98b829a3
0x4241ab07 0x1207ef2f 0x96e7b073 0x766293ea
0x58eb0882 0xf12a6426 0x741b074b 0xbd4302cb
0x909b6c4f 0x1c4949cc 0xd4d6a3e9 0x442b74b3
0xbc8cb3f9 0x0efad89a 0xa2ceff3d 0xecdf86bb
0x46a4a72e 0xe9d8abe4 0x94c91479 0xe99a80b9
0x1072b708 0xb8318ad3 0x0685426f 0x3e89a0d8
0x0b7c438e 0xb4b577d0 0x046599e2 0xd0ef85f2
0x3566d2d2 0x43ade22b 0x8753a78a 0x8f6d8e02
0xbdf33e56 0x8b2b6696 0x22a5e911 0xd0e0f4eb
0x42729c29 0x425921fb 0x82f7634e 0x2c145fd5
0xff59deeb 0x018a5372 0x33c4e11a 0xc001c097
0xf250cfcf 0x2f682912 0x21f40dc0 0x883196aa
0xcd5c58d0 0x7c329754 0x481c450e 0x9411c6c0
0x69a9df82 0xacb01a1a 0xc0b569a7 0x0b7fd1a9
0x4c339ad3 0xb0d9e211 0x07098664 0x14a5cff9
0x53beae37 0x4e173257 0x4e1d2e6c 0xce981dd1
0x45d6204f 0x3c193268 0x4f51ac3c 0x5ecffa12
0x48068ee9 0xde12270f 0x0a0aa980 0xd6fe8ca2
0x97d51da8 0xccf2db36 0xb3ad0598 0xbc56eb56
0x0adf5e5e 0x9e320aa1 0x8ebb75ef 0x3973a323
0x7e3d87e0 0x2c0d1858 0x83b7fa0c 0x36effdb5
0xcd9eba1a 0xab5b5790 0xa48fbf00 0x536e2ae9
0x2f2a3f61 0x05706a73 0xd2dfed08 0x7e4626b1
0x172c6ced 0xbf2e44ba 0x15aefc2e 0x9cf56c37
0x663c6695 0x04cece5f 0x4ce00027 0x465b1cd4
0x333dc2c7 0xce41f1f1 0x6dd8503b 0x52b79af7
0x564c81de 0x0e5e2daf 0x869753f5 0x16667889
0xe1acaf08 0x38ffbb0b 0x83400589 0x5144052f
0xa3819950 0xd21501c5 0x1bdadeda 0x0a874e2b
0x05480284 0xe8f76f11 0x582cad8a 0x0553f942
0xb6451cb9 0x76bdc86f 0x96ffe0c7 0xc630eba2
0xa82ec683 0x5902ef45 0xc362248c 0x18c412a9
0x1d09c103 0x2355ed98 0x5ec5c718 0x5037e359
0x1508f804 0x09cfea9d 0xa16cbdfa 0x5f962b17
0x85a35a27 0xa048dd30 0x6fe7ba90 0x0dc20150
0xcb56daa0 0x4188fb20 0xb4182598 0xa1bc5dd7
0x8c11e0bf 0x2104df35 0x025e74b8 0x79d177df
0xad74bb77 0x4b2419aa 0xe374add2 0x411593d5
0x796778da 0x9e43a420 0x4a2e0860 0xefb48578
0x47cafbdb 0xea15924d 0x70ac1467 0xf52fd888
0xd2df4bd6 0xc1fc63bb 0x119ab88e 0x0e147ead
0xa85bd8b5 0xc2e61ddb 0xd566417d 0x6bb9f9ec
0x69bbcf1e 0x24d46989 0x3caf067f 0x58151211
0xc2a6b6e5 0xb233416f 0x3da28155 0xf9cd9385
0x7a530045 0x1eab05ce 0xb86ed141 0xa8f13a5b
0xf9819f81 0x66d5d5c5 0x148c1a02 0x496d3c56
0x370dcd45 0x5f13f0b6 0xdd4eaeed 0x8dbad50d
0x0747ce54 0x69d2adcc 0xfb69c18f 0xd44ea186
0x74ab7537 0x0c642449 0x88b096cf 0x3a8ad683
0x408cd7aa 0x6daa6708 0xb267b312 0xa4225c7a
0x7a56dce7 0x6a8d497d 0x8837bcbb 0x6125397c
0xeb51d233 0x362bdde9 0x689657f7 0x32d09e1f
0x753a3d39 0xf77db5b2 0x8057908a 0xef12815d
0x594fffe6 0xcf3402c5 0x1a0d4923 0xca547b2f
0xaf9d604d 0x5d2e30f3 0xffe18005 0xe29bb0d9
0x36fc10f9 0x3720aac6 0x37bc1ad3 0x47d000ae
0xa4b0da0a 0xa178228b 0xdd9374e6 0xa1f3df5f
0x9ae2e451 0x21c4aceb 0x8f9fb226 0x5190b712
0x70253633 0x9c9cb5f1 0xc9178689 0x551c1a2d
0x6db67cc0 0xcf1b1ade 0x48449272 0xd18634f1
0x9d9c3de7 0x19025530 0x121d78d4 0xae4a39e1
0x62850819 0xf3d4af6a 0xe5ad5b80 0xfa053c7d
0x7ed68b9a 0xdbde2894 0x4b5c04de 0x65178203
0x9181cdd8 0xb17e27b9 0x0e29b338 0x50156ab4
0xf7726438 0x178108d6 0x1d8dc6b7 0xc3e7512f
0x0eb8339c 0xe2684a6f 0x7668ed31 0xd0ed6eda
0x4342a534 0x03840286 0xad1e6969 0xa9a6c98d
0x1bf77774 0xd32fc9d8 0x405620d2 0x8ab19efc
0xce4d7506 0x6f4eaae4 0x3e830dbd 0x76818782
0xfde4ee8d 0x1953cd0f 0xd47be276 0xf2480bc0
0xd1010013 0x2dd56a58 0x083084f4 0xc91b0ad6
0xc2524e12 0xa60710f2 0x3d955047 0xce380846
0x0f6dec2b 0x604d1492 0x5ca43ee1 0x6b51a626
0x350d5483 0x8d99ae30 0xcba06491 0xcc0185eb
0x7b64caa6 0x2f1754db 0xca0691f1 0x6219efb6
0x43291db0 0x259d3f12 0xeaf6ef9f 0x5f0e065b
0xad576541 0x8615a414 0x81124bdf 0x62b855a9
0xabdc529f 0x01bfdf75 0x10e4c656 0xf8e86f78
0x1fbe10d1 0xa6873c2c 0xdf83dcd8 0x20d35872
0xf46f2861 0x22f3d642 0xfdcda29a 0x16adbdb4
0x01e5844c 0x011e5454 0xf5432b04 0xd5f6a80d
0xb081fab6 0x64fc2fbd 0x4ca76e0f 0x3a8d8b29
0x3f03ec12 0x58e2bf6c 0x24f2b8b1 0x108e414f
0xe76a02ab 0xcb525af9 0x623ba7a3 0x31412c27
0x69c2f5db 0xd5546d8b 0x8200d2c9 0xf1e34a71
0x393e24dd 0x2b867933 0x0596e778 0xc5112b49
0xf433cdea 0xbc505e7b 0xf64bb064 0x1e892633
0xbf17307b 0x9118de2c 0x6b1d61a8 0x1945519c
0x32638ca4 0x5e436733 0x3dc20ff6 0x9babf127
0x485c1555 0x0d0c4e2d 0xc4d5d718 0x8cfffc16
0xf64050db 0xaa4ef416 0x8d398a00 0xe4a16eca
0x5d9d9314 0xefa2bf1c 0x05917dd4 0xca5f1660
0x59642534 0x02639b9f 0x12b895df 0xb2deaf0e
0x20d8f0b9 0x04d8342c 0xa1ba5f57 0xa26cdb06
0xca732ca8 0xdce0c561 0xf5e4b205 0xc05f5cfb
0xba4a41a6 0xaf219d7b 0xce08df01 0xa02bbdb9
0xc1adbc20 0xcb9ae4fd 0xd828cfb5 0x690b17db
0xd29ae8bc 0x8fc71289 0xd6fc9cf6 0x61c7a6fc
0x8e8012d5 0xd3320498 0x36e80084 0x0036d3ab
0x53141aae 0x987d0cba 0x57581df5 0xace4704c
0x3ce49642 0x991556c1 0x6cb0b984 0xac15e528
0xe7d208ca 0x2486d1c5 0x93b6623e 0x340b7622
0xe7e1cf7b 0x3cdeed88 0xa23c849a 0xcc6e8b3b
0x292add5a 0x17763ee1 0x9f87203e 0x72cf4551
0x2053e66f 0x06c3a411 0xb61c2e0c 0xa4a7f3ae
0x0ff87dbb 0x03999ed8 0x48aacedc 0x2e126ef3
0x799441bb 0xaee15b4d 0xea08bf54 0x47248787
0xb60afc11 0x8c3d6a20 0x7c04f801 0xb902760e
0x319040eb 0x370bbd5d 0x9a1dd5e6 0x63f7da1d
0xb3784eac 0x3b304dea 0x987ada9f 0x2b6b1cda
0xf9241003 0x0d3d16f2 0x1185dcbf 0x519b7a5f
0xeb612361 0x28b57da5 0xdeb8419a 0x0ba13122
0x062e28fa 0x5ffb9b36 0xb1258247 0x8337401f
0xed1f6423 0x730cafe6 0xf728c690 0xe40557eb
0xc4951a15 0x04a988a9 0xbf5fe18c 0x2766e40a
0xe4d74d13 0x8638d052 0x8eefeaf2 0x9ad07978
0x32042a87 0x4385f38d 0xc9b48f02 0x02ab0ae7
0x9eaeb632 0xf386c14d 0x8b1c2ab2 0xad432a24
0xfc5bd462 0x2d7ac5fe 0x45dff5c6 0xa235e1a6
0x825b770c 0x5568471b 0xa7ac3a3a 0xfcc6e40c
0x0c1be59c 0x77685a3c 0x5b1bafbd 0x40b8a139
0x3dd1bf01 0xb6651001 0xf2915a6a 0x16fe1cf2
0xe78467d1 0x4bec9fb1 0x88615320 0xa3920831
0xed4afac7 0x206cffba 0x96c42567 0xcc2b5215
0x7ca0193f 0x0e1a60e5 0xf3892c10 0x2ceee7b2
0x110d3311 0x9a322e7e 0x3cb7e5fc 0x3fb971c1
0x59971332 0x08386001 0xe4a2444d 0x17d9c47f
0x9f53c4a5 0xdb54e5c2 0xfaac9f08 0x975c07c6
0x8a6e6bcd 0x4392053a 0x6473bef8 0x4b3b91a3
0xfb7e8ebc 0x46c6ffed 0x04939839 0x71b93766
0x47e4f74a 0x786545c8 0x77f55b59 0xdf8e992d
0x60a0d2a5 0x6cc8a5cb 0x113ee95c 0xa378558d
0x5d3b8bd9 0x3c95b2a8 0x6efa3682 0x9535dd34
0x3e29974d 0xa477d069 0x2dbf58d2 0x165edae3
0xea25d53d 0x44e3ef71 0xba6341cf 0xc61b964c
0x4612838b 0x62151b9e 0xc1de2511 0xa364130c
0xa9710643 0x1a436c70 0x97030b09 0x5cef28e0
0xd5197e49 0x02b9ffa8 0x1b52dc7b 0x04f9428b
0x01ebed2a 0x1eaecbee 0xc53c4d54 0x3e34c125
0x05b4f37a 0x6e3d042b 0xf1c1f40d 0x39cfe9e1
0xd2938e89 0xa14b9846 0xb1333676 0x31068254
0x4b627e4b 0xb5185882 0x101b52bc 0x73e05abf
0x68a4e24c 0x67e301f4 0x6bf8b538 0xc502e1e1
0xc3889b5b 0xdfbc6d96 0x4239d0e1 0xbf3667ab
0xb0c4cb00 0x3efdcffd 0x7cd9661d 0x4f5eca03
0x0ef218dd 0x464f0826 0x048fc539 0x6a1c63fe
0x76cc341a 0x1ae2945c 0x7a339006 0x858fdc20
0x2a4a7270 0xd4cbe12c 0x7b27e5d8 0x998cf520
0x4795ccf7 0x52e15388 0x86aa7b96 0xff1845fa
0xd49d1061 0x035b6a80 0x1df18220 0x28fc4fd1
0xa8e8f333 0x3a9240a6 0x41a4caca 0xee736b6f
0xdfa7ce4b 0xd4bf5c0c 0x4e62f6d3 0xe98ae9b4
0x7f544550 0x2b0706df 0x8fb2e752 0x546af9d1
0x8517758f 0x53f522fc 0x03bd1819 0x6fd264e2
0x16839ef8 0x44a1200d 0xcd5a586b 0x1ead251c
0xf58dd3be 0x80217ce7 0x0367ff42 0x2d8f2ce8
0xe8a0a689 0xba33e366 0x5dc7980d 0x005c0eaf
0xc0c44118 0x5553076a 0xdaf39389 0x703e09eb
0xc54c8112 0x4a26135c 0x36a46f2b 0xdc93ee12
0x7060db72 0x7778befc 0xe028fc55 0x52e86278
0xd0b00188 0x6ed5565a 0xb5e2785c 0x3608bffa
0x55c3f5a3 0xe1e41afa 0x08a227fe 0x94c793ce
0x650934f7 0xddc36524 0x6dac40de 0x9eec3ceb
0x8fe3d1cc 0x3cebab86 0x61e4d63a 0x5382ea11
0xa90c9495 0x0277ccb3 0x412cecc1 0x5853c945
0x97df9a48 0x364d9b10 0x7e8c9bf1 0x6b4974ef
0xd3dbaeeb 0x6626dd26 0x2b746d2c 0xfb762155
0xf942f687 0x1317d1b5 0x0c989def 0x5f4c0ed6
0x31aebbd3 0x51cd8d5b 0x3d729511 0xc07c8f23
0xa7f3e6f7 0x7683dba9 0x5f051d5c 0x750437f5
0x1b9ffe98 0xa4de609b 0x4c498e9a 0x18dfc535
0x376c6c34 0x19a57039 0xa70e93eb 0x7e966bc7
0xb6e9d77a 0x3ab98e5f 0x1607125e 0xe8845aa3
0xa20a2d80 0xb17ac63b 0xa07a9790 0x71e5a14f
0xb6b5fc78 0x4c610f86 0xb57b21b6 0x1bcfb3ac
0xbf812998 0xd429986b 0x02b837e9 0x0823aca8
0xd8a85194 0x708bad39 0xff94ef19 0xc3599461
0xaee622f6 0xa8b5a808 0xf801b298 0x0aeb35b7
0x4db4bf27 0xfa31c205 0xa047dc66 0x7e0ae406
0x2ceea6cb 0xef0ef96f 0x4cc4fdba 0x6161256f
0x94505fd1 0xbced5596 0xbf9e36a5 0x271e68bd
0x7a3308b6 0xef1af50d 0xb55ede06 0x6783e602
0x1152acf0 0xdc644ccd 0x1b692da3 0x59f6886b
0xd7236158 0xe39d75a6 0xe7026697 0x25496283
0xb6b0a61c 0x09d0931c 0xe8d459a1 0x1a124097
0x88e50621 0xf2ed18ff 0x37681783 0x4afa1ffc
0x8a96ec4a 0x4474a860 0x274591b1 0x59df3968
0x34f56fb9 0xce821f96 0x7ec825b2 0x6ed4a9bf
0x687253cf 0xa511c1d3 0xaf2bd6f0 0xd1ce1a5c
0x241dd505 0x39037238 0x0c761934 0x53181db5
0x11ad47ec 0x915a527b 0x748bc970 0xeb8f2669
0xb8bfd5af 0xd8d19145 0x0361ff58 0x6dc6e2f2
0x1fd06556 0x120db4c5 0xbd704c8b 0x70a1a57c
0x27543851 0x095403a6 0x28171887 0x640e7c92
0xb48fd7d1 0x62ad2774 0x224767cd 0x347b8843
0x821ca7f3 0xf94749c6 0x2bc7f40f 0x700cc1d8
0x50d50832 0xc2f9465c 0xa6e1cbaa 0xe0f5e934
0x7f33617f 0x8876cb07 0x408c24fe 0xc0cfcdf7
0x39152b72 0xa0ba80ab 0x301a73eb 0x6e704f6c
0x3b73c24b 0xd433f861 0x43192007 0xa56d2ca4
0x2d28bd5d 0x14f4c9cd 0xb7fe189c 0x031e1818
0xf8f4133e 0xdc8e7727 0x4f8f5a06 0xe7b114cd
0x5cb9ff12 0xdb4c5a53 0xed956df5 0xf3634f5f
0x6cce1cc2 0x5393f9ac 0x1184c2f7 0x0b6fd240
0x64771374 0xaafed1a1 0xbdc55bcf 0x976414ef
0x6a333e56 0x0c5cefb2 0xff2574e0 0x11b059ef
0xff8b7f2a 0x9651e97b 0x594fe89b 0x7be60f6a
0x7b7695ac 0x612036f7 0x5be0d4fa 0x25855737
0x12e32ee2 0x8e86130f 0x46d75d41 0x3769d438
0xd14752d4 0x1612ad6d 0x8f86f2a0 0x63e01251
0x9a44ac4a 0x49fdb148 0xe1757062 0x42798804
0xf21f46c1 0xed0a3794 0x5528add4 0xeddc0c90
0x7f188ce8 0x59568b7a 0x8e25d50f 0x9277c492
0x955c6e6a 0x79f94a59 0x3a65fb08 0xceb23267
0x7d8dce01 0xd15c492d 0xa35f005c 0x0e7cba9a
0x950485d9 0x2d92e448 0x4aced016 0x0d10136d
0x3d2ec365 0xd982e881 0xe81940d2 0xb1a84849
0xdb30d967 0x9f51d3d4 0x4fbe18a9 0xef21cd28
0x5d3cba6c 0xaa89b02b 0xbe1e9526 0xa20a918e
0x0c26bd72 0x8372eff8 0xcf7ab414 0x1d3ab83f
0xfd2c8f79 0x4929f77e 0x2416e8df 0x65dcaaca
0x58fbf7b3 0x1c4a3089 0x9bfb6e26 0xc7338ac9
0x88e5ad26 0xc62bb3d4 0xad6d36f5 0x6445167d
0xe9de8daf 0xc391c6bc 0xa78b4558 0x0216bcdd
0xbd4365b9 0xb0a874b2 0xe95e9453 0x77296b9a
0x49803c1e 0xc01fd0ed 0x165a9d5d 0xf7da6442
0x4c00818d 0xaad5bfca 0xdb252937 0x0e4e0f74
0x0c2738e8 0xd075b8ba 0xe3b2df11 0x8aee60a4
0x36052cd8 0xb4aa190b 0x413e7155 0x3e7e646d
0x807e6eea 0x97993e6f 0xa5129ff5 0x98e01bca
0xa8bd70c9 0x8800721e 0xb3407ffa 0x266b2f99
0xd9da73ee 0xa06f634a 0xcaae53b1 0xd98e53c6
0x49368291 0xc89485fe 0x938a8a29 0xb57f77cc
0x58c867de 0xcdac8a84 0xf4d57b6f 0xc6daf080
0xe3d9c67f 0x0264b194 0xc3b2ca50 0x6d214667
0x88503872 0x549ed8cf 0xe827689f 0xcbe94e2e
0x4a02516d 0x24ddcfa1 0x3cbc736e 0x34c88707
0x9f4c9376 0x4ced4d41 0xfdbabfb5 0xafd291d9
0x2fa602a3 0x53e19d9c 0x44422427 0xf85e2c53
0x40e91ef7 0x02646045 0x3d1fa703 0x1613b99f
0xa108de10 0xf9cb3d04 0x7b9f9523 0x007d74b1
0x961771dc 0x2e49fe1b 0x5fefe27d 0x54737b43
0xa11d7c40 0x7f0cc2d9 0x67c6533e 0xd1ab10fa
0xb1950645 0x536087d2 0xd6937b40 0xc35960c1
0x2df0c356 0xecb5ab53 0x61e08998 0x1671bdd0
0xd72935b5 0xdf1a9d7c 0x70b1aa4e 0xa9272818
0x1f7b8d55 0xc7292a0f 0xda7af847 0x190076ad
0x58370ba6 0x3020fb4e 0xff8a4b30 0x13818958
0x6ba1ca38 0x6a90d39b 0x5e180929 0x206e8a22
0x0568f241 0x5f83ad21 0xef05e5c6 0x21d0521c
0xe7886eff 0x68eebbce 0x550c1659 0xa0843444
0x19468c2b 0x539cb9b8 0xa4b18b62 0xdab0680e
0x1b254dbc 0x47068aaf 0xa8193743 0x44b60b88
0x90c07337 0x2e55666a 0x632f4b23 0x68af10db
0x8e29f54b 0x5f436bcd 0x8bf81d55 0xb640ccc5
0x2e4ab6a9 0x198697a5 0x8a1c8481 0x572fb679
0x7597c416 0x608fd45e 0x57c8c7f4 0xe151d349
0xed9e17bb 0xa66f2816 0x8175fe68 0xd57d91ad
0x79df0711 0x7a349868 0x13403cd4 0x7d974c60
0x8860ce70 0x2e6d62ea 0x8916e2f2 0x0e336838
0xf54d382d 0xc4e172c8 0x94bfcfbf 0x5fa53172
0x2933cecd 0x4d5b8439 0x0ca0e6e4 0x8ef87b00
0x2fdd121c 0x24beae76 0xa85b47f4 0x4e38af2e
0x12b8734a 0xf698abf4 0xde2c2d93 0xeb100795
0x8ab19df8 0x93a6f4d1 0x43c4b2cb 0xbaff7c4a
0xf52b1471 0x72804f4f 0x0c0ca257 0x1dc24c77
0xbad7203b 0x3a998fa0 0x9cb20388 0x7ef1fb3b
0xbae66020 0x9a22144f 0x39ac47db 0x3f145996
0x05a32b6c 0xd201a2ec 0xd868727f 0x08b2df4f
0x4583bbfa 0x9a422baa 0xa6a2e8f5 0x236310ec
0x5aafc3cf 0x344156a6 0x6f964ceb 0xed0495ae
0xb5638c98 0x2c8e84ba 0x63d8c7a5 0xec956b66
0x69c54f32 0x767874ec 0xe8fb6ce1 0x68b1c780
0xe4b861e4 0x2787cc38 0x4b2202e7 0x23b476be
0xecdf296f 0x094aa000 0xe95ef073 0x4182ebb5
0x30daa31a 0xef68cb68 0x2fbcf6bc 0x21c52620
0x19abf83e 0x4de7528c 0x05fe4c05 0x32c2a1e9
0x8c23abdb 0xabba9a90 0xa6a215c1 0x891f915c
0x667cd65a 0xaa5a9b2c 0x689fd1e9 0x42b52c95
0xd9872e76 0x05dd5278 0xc19798f7 0x8d031d86
0x25690670 0x165f4b19 0x76b51d6f 0x61cd8232
0x7b530271 0xa8e9326c 0xd952e94d 0x56a7021b
0x128be860 0x4da40144 0xeb4ac3d5 0x82b7ff5a
0xea2abda7 0x690a9ebc 0x33562378 0x6bc91b2f
0x46134185 0x8fb77fb2 0x029518a2 0xe1fa1f4c
0xf78783b9 0x5d8ebe63 0x103e8050 0x924085bf
0x80593f2e 0x5be4bcb6 0xcb935edd 0x882d0a5f
0x7deb8205 0xcdc0fe2e 0x9c333db4 0x1d0c888d
0xf8dc3575 0x2f901125 0x6bf48cdb 0x98ab6fb4
0x491d7df2 0xa064922e 0xbbb86c70 0x88aad77d
0xfcff0669 0xb0c47c1c 0x0fcc6fe1 0x50df8a83
0x014460e4 0xb014e6ab 0xbeff4bc5 0x8d939fae
0xd750ae17 0x42dd29c9 0xdb1cbf70 0x82265be9
0xd11afd6a 0x21834e1c 0xd11e3c3a 0xbe568139
0x6cf92d50 0x9304ebf1 0xf177046b 0xa5b127a5
0xfb57e4a7 0xf94291df 0x0f089d58 0x07395b5f
0xde4ba5b9 0xf7371fc5 0xae44f190 0xd529271d
0xbcaea246 0xfa777c0b 0xad3bab9f 0x0d6251ec
0x6f4fa894 0xc39273e2 0x7710fcc3 0x81f08a5d
0x395b54ee 0x87295638 0x57398bb0 0xfd46c7c9
0x3f1dafc6 0x548479b7 0x37c42fba 0xa2130147
0x99dc0bb0 0x3596c5cf 0xbcca6bec 0x418735ed
0xfcd4273d 0xee141135 0x8457cf47 0x95fe7220
0x041aaf8a 0x6e947153 0xc963afa7 0x09390a74
0xc40dffd3 0x4208039c 0x319b1f84 0x42b6b3b7
0xade789da 0x83338c91 0xf2d74712 0xe80011dd
0xdd61645e 0x286fc63a 0x26e2fb23 0xfef2b4ea
0x3290efb8 0x595a0c17 0x6cd9bea9 0x7be1338e
0xe0ff2c09 0x1b93aea5 0xbbd97e91 0x5e1ae1e7
0x7c6c078b 0x0b9b3a03 0x43d38011 0x824cd94b
0x9725170d 0x87ce6f33 0x60525d85 0xc0a5e853
0x242e613b 0xebf72857 0xcb500fc6 0x0de5c3f0
0x382b625d 0x08840e50 0xcef30663 0x1bc848b6
0xefa78141 0x81b860d6 0x4eb125fe 0x7e125296
0x276a5558 0x45caa775 0x7c6ec23c 0x5dcddd08
0xc41aa32d 0x6a2851b1 0xb69ae1c1 0x8f603c43
0x763497f2 0x73344cbd 0xcffd175c 0xfccf5a91
0xb2318bf7 0x66ac628f 0xa98fa975 0xb68e5426
0x27555715 0x5157a93f 0x666fd404 0xb37fcc40
0x563b0512 0xb70f8446 0xe10d257f 0x73793ef2
0x31a84915 0xe0de9489 0x08dfa368 0x9169d4fd
0xc14f5c9a 0x92e6db4f 0xa30b6cec 0xca04670e
0x8a664367 0xe8984e70 0x1c96a39c 0x655f9abd
0x6999a190 0x76267621 0x0f49f963 0x8ddad3a1
0x51fdab6a 0xaf0d6863 0x23b71bdb 0x32818c8a
0x6398044d 0x26c60bec 0xb0b631fa 0x938f69c7
0x52f11913 0x1e6fbe7a 0x92dcd409 0x419bfeae
0xb147bb96 0xbac5bf9d 0x08de155a 0xde8ca968
0x20aef902 0x62df25a8 0x64a4042f 0xef19da4e
0xc75fd112 0xc9863e47 0xaccfdbcb 0xd29b6090
0x6dc67b4a 0xa84b3cd6 0x45a0e708 0xd28673bd
0x00bebebe 0xd5e518d7 0xc63d647c 0xa28f5f6d
0x3372edc8 0xa1c44ed1 0x88e61d44 0x5e095835
0x2d8713ce 0x6791a885 0xae89c04a 0xf1dc5105
0x6423f3b7 0xf4e2f384 0x2d2761a7 0x38ea905d
0xa263d776 0xd1936fa6 0x2fc54081 0x429a25c2
0x13f6c5df 0xffffa6c1 0xfaf82002 0xe4bbb103
0x2fc0c622 0x669ee281 0xec785fda 0x91156b25
0xa9f4444e 0x354fdfc2 0x7c5f5069 0x72ae591b
0x73bfd64e 0x6b96d744 0xf261daaa 0x2de15dae
0xedaba9c2 0xf287b3fd 0x8b2097b6 0x589934c0
0x7edc2a73 0x469b16eb 0x247b9a22 0x8b7e6c7b
0x3e71ffe2 0x5275f242 0x032a211f 0x977bff60
0x4306ad03 0x6a212383 0xceb36448 0xa2a79209
0xe3842f42 0xcee0cbe7 0x37cdb626 0x29a0a515
0x2857ead6 0x981d5d9b 0xf0ff9b06 0x95de8cad
0x4dcb565b 0x065d585d 0xe7eb754b 0x278fa774
0xe4d8fb7a 0xe152f018 0xfb7bb25e 0x50323b64
0xba618e43 0xf8cb1c61 0x1b6dce25 0xb4fc7867
0x2a7fb213 0xea9e646e 0x3f9b735b 0x5640315d
0x0793ba5b 0x71ff31fb 0x4b41f1d6 0xb1538146
0x336f4272 0xf176d509 0xb7fc03c5 0xd6a1c927
0x56a68c10 0x8b4740cd 0x14c54f8a 0xf07ad8a9
0xa8403db8 0x37c23f2b 0xdca69aba 0x4b39ef9d
0x2af13bdb 0x6baace1f 0x8c7ca0d2 0xba86bd02
0x2a74681c 0x5542ae58 0xc36709e2 0x82b34568
0x26ea06be 0xd4bf458c 0xde209de7 0xa311b4e5
0xdc00e139 0x7d305958 0xc5d76ed7 0x0943a285
0x48ce4e29 0xe371bd9a 0xfe6a6501 0x4167d215
0x402e47ba 0x588458be 0xbf4bcf37 0xf7fa27a8
0xb725f91a 0xc17f5c07 0xce771dbe 0x66f9d592
0xe8521ed4 0x42f75171 0x343b3e74 0x2d5448b5
0x2d1fca8c 0xd7a32431 0xc29a88d2 0xffb07fd7
0xcca0333f 0x43204f2f 0x866c1867 0xcb215814
0xfcb67d4f 0x423680be 0xdf22f6d6 0x03373eda
0x3bd202e3 0xd8972fe3 0xb7733d70 0x7a472c76
0x6cc8a627 0x3b27e643 0xa3475f3f 0x87ffb286
0xf823d69f 0x6d57c38e 0xa0fd464e 0x53e2e341
0xaaab23ef 0x439429ef 0x55ba2a2b 0x4da5ea4c
0xc1fe05fc 0x874b7a34 0x9a875956 0x713ccc90
0x49afcff2 0x5905dc0b 0x1f5dddb7 0x8ef5c1d9
0xf60eca50 0x25172569 0x3525639a 0x25804bbe
0x5729cd49 0x17f84e66 0xc540d86d 0x51524bc9
0x9a6e9901 0xf5bcc70e 0xf7a73ffd 0x54509c8f
0xec58b8a4 0x9993703b 0x6ef45fc4 0x5ce3a507
0x1d73c611 0x8780e8ff 0xc7d2e02b 0x0bc825f2
0x02f75fca 0xe80c0758 0x24646fe9 0xd378ff5a
0x592c5619 0x6c80372e 0x1f7351d1 0x4db5182d
0x3985fdfb 0x16ca9158 0x58ee1ae4 0xaf2b9fa0
0xe97f60ce 0xbb911e68 0x01748fa0 0xaef578d3
0xc3736418 0x8ab0deb5 0x0de16af1 0xb8369f7b
0x68e43c12 0x914ca0f6 0xe950ef28 0x834eff90
0x51adb952 0xc42ee4ce 0xf70ab4a5 0xbf9fc916
0xed9444b1 0x845a6a1e 0xf92e7b64 0xb9ca8a1b
0xa9cdfcd0 0xb5956bc8 0xb8520e59 0xdde7aa57
0xb41d390f 0x364aef3c 0xf39d4482 0x8b4e651e
0x0b82f5fb 0x7960e81c 0x12ed7b84 0xe9f123ca
0x88a64db2 0xa0c714cb 0x57b01471 0x80ff31a6
0x7571d8cd 0x857035d9 0x0508587c 0x594a4a42
0x011503e5 0x27c75e55 0x03264f62 0x9316ed1d
0x36e5cd1e 0xfa9b23b4 0x5bc8c606 0x0902bd38
0xd6745c69 0x6fa73118 0xa50f7b94 0xc529e962
0x28738486 0x7b85a599 0x2c495a35 0x85f2cbef
0xa09dfe51 0x1c763ab2 0x4effdb5c 0x506586f0
0xec182a58 0x45293146 0xaf8d78b8 0xa89bd228
0xec24826a 0x752cc421 0xbf36aa46 0x6760e225
0xe15d0987 0x6fa9bdf3 0x6837c755 0x9426d654
0x14b48f5b 0x5d70567d 0x63a14f92 0x809d5361
0x3b6e2729 0x84ce5415 0x7eaca6e0 0x9b467302
0x8f39d484 0x8e78398c 0x33108b33 0xdc07005c
0xbdc2500f 0x35f1f452 0x9d254e3d 0xfa61eb21
0x2ab6c7aa 0x83561fdc 0x8735d598 0x416e8591
0xfe10e93a 0x18da409d 0xab6d0bfd 0x675baaf1
0x287fdd24 0x6b50b63c 0x8c08abca 0x871a59c9
0x41bb2ae4 0xfba9abdf 0xb46491c7 0x4e433d5a
0x01e4fbda 0x0bc40399 0x3bdb61c2 0x3cf051ba
0x910daa46 0x8d4065d6 0x270667eb 0xf6d42459
0x01993a1b 0x00a95dda 0x6ed5a693 0xed4fbf7b
0x24dbb70f 0x67fd62ee 0xcef5f0a4 0x9e65b798
0x9a9913fd 0x3d0e7190 0x4265b4e4 0x80bfc46f
0x6b354d2c 0x2b90a987 0xc989cb75 0x773e6b64
0x55325e9f 0x18816a56 0x07413406 0x5177ae31
0x24a19ef7 0xdac405a4 0xdca2d3b4 0xab7c7b70
0x42b5de0e 0xfcf918a5 0xa54d934b 0xcaa9eab6
0x50e63e2a 0x4b168926 0xb2442913 0x594c0f94
0xf387f31f 0x4d716749 0xc8433297 0x34c1a5de
0xe929008e 0x5644251b 0x736476d0 0x0d00aee7
0xf20b2f64 0x5e158173 0x9af3e568 0x5f19fa7e
0xb23b2861 0x8659ee6e 0x94058a64 0x66ec4fb1
0x37cd6a4a 0xbd2944fe 0x0ea44ec6 0xe7d64c24
0x75a170e3 0xb4a9479c 0x2215716a 0x64a8a574
0x257e86ab 0x86bae993 0x3030352b 0x15cb88bc
0x576363a0 0x61138c36 0x7cc4fe7f 0x648977a8
0x0ef71fec 0x1c60df47 0xc75f70ea 0x88509798
0x172b407a 0xf888e400 0xef33cd15 0x5976757d
0xf8cfef13 0xbf024380 0xbb9c1b02 0xe4c38ec9
0xf30fce01 0x8efa5213 0xf4b48aad 0xc94c3a37
0xeb1bcece 0x09a18b56 0x4e83c0d3 0x6fcf9f77
0xf52f4d76 0xf3368a12 0x33b2797f 0x627b6e41
0xefd05154 0xa83ae2a0 0xea211129 0xd25723d5
0x7bbb0e3b 0x7131f088 0x5dd5193f 0xef5aa905
0x39f77be7 0xa21b48c1 0x1ded01c1 0x5cf98c5f
0x6e23d207 0xd7e7dadf 0x5932ed1a 0x2a729061
0x29a89f4a 0xac0e8447 0x01ff4205 0x8b1456c6
0x3fba0156 0x658c03f7 0x5c69f968 0xf6570582
0x21bb0145 0x8683bf5b 0xa4b6eba5 0x4ccfe5cb
0xd202898c 0xbd2411cc 0xc2fc702a 0x5c39b695
0x87584ccf 0xeae3c735 0xc472b6f9 0x4249f637
0x3fa89c0e 0xce5a8bd7 0xbb28138b 0xc080ecb1
0x9cbf1916 0xd70424e9 0x75cc4ed1 0xa575f3e9
0x1c571f68 0xe2906205 0xc26520cf 0xf9c1fc8e
0x61c982de 0x1af6cfcc 0xaf397c9a 0x46830771
0x623d98bb 0xda7b52fa 0x5a3c57d3 0xfa35d2f0
0x4783df19 0x6ad07325 0x487406f4 0x3fae5152
0x189137cb 0xd98a644e 0x17ffe880 0xeb6aa9f7
0x67184e3e 0xe475734b 0x0f1113c2 0x39a4df47
0xbf8f6ec9 0xe13a4d8b 0x63ec02f5 0xdfe7d75d
0x1379034c 0x5db7314a 0xa9d9ad3e 0xfaaed8f2
0xf0fb6074 0x12f27b84 0xc97a92bb 0xae5e3bb7
0x5f7fc2bf 0x00cbc1f7 0x9360a4d9 0x3632ba04
0xad044c83 0xeda13ec1 0x34a214c0 0xcf9c972a
0x96352243 0xf1a35357 0x2d77bc30 0x8485bbad
0x67fbaa99 0x8035b1a5 0x8ca763c0 0x109d7887
0xa1c35cd8 0xdc79e308 0x4495404d 0x64419226
0xacdcea08 0x9545c0ef 0x5493e09e 0x7fe16336
0x41381aa2 0x5c344f46 0xb40cab9f 0xc43951c4
0xd86e52a5 0xb141d934 0xd78efcff 0xf37ec320
0xc184a45b 0xf4a57954 0xc8aed0bd 0xe602c15a
0x71a6b48b 0xce837428 0x02733706 0xc4a4a044
0xa75efb97 0xcb63d62e 0xd0580b5a 0xce499087
0xc12bf4ca 0x9c995345 0x1d8adfbc 0xe62fd60e
0xccbf5412 0x6161f8d0 0x64268e34 0x565d066b
0x1896b63f 0x838f8f2a 0x1e314a00 0xac470276
0x1879cfdf 0x4702d7f9 0x83b4d777 0x81fcb068
0x1b6da94d 0xd075ed01 0x3c7734e8 0x56389a0b
0x0743b9cd 0xb6b0bf0d 0x63107ab9 0x193172bc
0xc7b84c8e 0x982ce2aa 0xb8e387a6 0xc264a4b0
0x2ac6c802 0xb89ea335 0x052332a4 0x49932ecc
0xb940f808 0xa7a09330 0x19f3f49d 0x7aef6b5a
0x201d8ed0 0xf29aac4b 0x8ae2ac0f 0x998c1ca7
0x665c3927 0xab4ef641 0xf136710d 0x9644ee9b
0x34efae96 0x4c596035 0x8cfe8b3b 0x5d9f742e
0xab2c63ca 0x017d864d 0xd0604d6e 0xab24eee0
0x75916a9a 0xad0d1167 0xbeb47775 0x6ac822d1
0x776907aa 0x9e9377f2 0x438c5d81 0xd70e9964
0x1c09c914 0xab90e5cf 0x31cee523 0x26ba6ea7
0xef00781d 0x622b886d 0x36a54031 0x88b1221c
0x666333f5 0x60e1c93e 0x5e4d0e0a 0x3ee6ff69
0xceb4c76b 0xa5deb4f8 0x0668ced8 0x30225378
0x6697cf37 0xc5d9661d 0x089eab85 0x7684a876
0x018a81af 0x221a7fb2 0x31d80de0 0x9f18ae90
0xa29c9af0 0xc3e2b00f 0xda0edbab 0x7ee9cd2a
0x3ab0f88e 0x02c58228 0x606fa7aa 0x7776cb0a
0x4e8ad99c 0x3b527469 0x58123d62 0x4ce428d2
0xee91a210 0x466ba2cc 0x043c57b9 0xaf7bdd43
0x98e76fee 0x8f3eac1b 0x00dffd6c 0x6fcb1c6a
0x5cb90573 0x485d4505 0x0df5418a 0x26eafe35
0x0faddf3e 0x4e972930 0xe113c823 0xe45944d1
0xa646077f 0xc1708ae5 0x6ba07c20 0xc7e4e234
0xc6754ed5 0xbd6e85aa 0x8cc1756e 0x02afda29
0x72809597 0x75b6f5a1 0x61141874 0x1774047f
0x7a10afed 0xfac2c4ad 0x42cf5c99 0x24f0350e
0x042f2864 0xfab55b67 0xc8ead5bc 0x914e9512
0x77c8ef6b 0x8369aeb1 0x71bc947f 0x0c6b49d8
0x8ddd0513 0x028ad10d 0x99a1b28f 0xe6cfbdc8
0x7978b4a6 0x3ebbade8 0x9985f5cf 0x431f42f1
0x004372b2 0x18b67f68 0x20111c21 0xbb6f77ff
0x1783b030 0xa045d7d1 0x0e9c7e09 0x3ccbd95f
0x0b84a2ed 0xf0ee3325 0x63f2e126 0x5ec4c67b
0x2ca782cc 0xcaf20d04 0x8b59d515 0x3212aa33
0x335ca0c3 0x6f9e0cdd 0x4d4bf189 0x44d2fa0c
0x5abe9396 0x492794ee 0x10dcfcb1 0x9acda9bd
0xe8aa2803 0x3f1b9605 0x3e2ecb5a 0x971bfa8a
0xcbf141d2 0x0afafe10 0x2fc906a6 0xefad20c0
0x9e922581 0xe69142cc 0xc9c0ba82 0xc069e640
0xb99c08b6 0x4b62ca1f 0xf3c5767a 0x6ab088c7
0x8f0f0c0b 0x6726f64a 0x9711a3cd 0x46462571
0x3a58350e 0xa2561911 0xe24dfdfe 0x97443fdc
0xf80540be 0x069978bf 0xb38a359b 0x8e574f62
0x69aea75c 0xdc753fcb 0x2a74002c 0xced027b4
0xda993254 0x03409b83 0xf827331d 0x75fb3271
0x01ad839d 0x68520842 0xca65c45c 0x1a3db5a0
0x91d37dd3 0x6168c0fb 0x935f5a08 0x002007c3
0x42eb4760 0xdab3a804 0x72a6297e 0x905c32d9
0x81abcfa9 0x1b21d04a 0x5a1289ae 0x424e7183
0xc207906c 0x31fe9134 0x5eb2e5af 0xc9253fc7
0xc32be24f 0xe5474cbd 0xeff6e1b0 0x710e5e69
0xe6c4c538 0x96b5f1de 0x2abc9c35 0xddbd1a92
0x8aca40d7 0xe359c238 0x954718f4 0x18b157e5
0xeeed790e 0x6948a963 0x24e70bfb 0x4d681547
0xf68369a7 0x5b54409a 0x1f0b787a 0xc2610047
0x0f8bd269 0xd7c8c154 0x9dee62d9 0xd4738ed8
0x1a66c6b1 0x5bad5a5b 0xb110311a 0xfaec6802
0x6b750f2d 0xcbf8d0e0 0x11edaf4b 0xf64a07bb
0x422e7c15 0xb1732663 0x1ff404f0 0x2d5052b0
0x6e45356c 0x7e2201e8 0x7c5ebcd1 0x1cb4425a
0xb1539a64 0xa2e4459f 0xcf1ade8a 0xfc476473
0xf4147deb 0x2afbdd77 0xff01fabc 0x6597408a
0x0951220b 0x6750f3ec 0x0a242763 0xf3d71c05
0x84cb1c26 0xdb7a81bd 0x7aea1a5d 0x7e719a48
0xc5c12fe1 0x0ce2e988 0x29ecc6f0 0x5ede901a
0xda8399b1 0x31c05d6b 0xe1956aff 0x59ed7c3d
0x60832637 0x9bcb7cac 0x63c530d1 0x14c677de
0x9225ed18 0x065327c9 0xd1ff6a0e 0x5516517e
0x53c6f5c2 0xed5983cf 0xaa1d18b9 0xbe300d7f
0xadc525a7 0x07ea81b6 0xfc517a09 0x4ead3f86
0x45435f41 0x2efa58df 0x02348ebc 0x30ed6783
0x190b4fb9 0x85c55d6e 0xc9ed8896 0x416ee113
0x9b3536d9 0x30577cc0 0xbc4b88c8 0xcda59612
0xdfe2bd89 0xd60cde71 0x98843881 0xcc1f32f2
0x18b3f643 0x671a14ca 0xd6482a47 0xac6a7d38
0x1897da16 0x91b6fcb3 0xf199bb35 0xd38c00ba
0xa8c946b6 0x52a1ad37 0xd38ed2d4 0xa1d6f81d
0x5af6865b 0xebdb858f 0xb844b110 0x53201ea2
0x08870945 0x10c869de 0x19849613 0xdb35d3ed
0xd68ebd6e 0x1056fd48 0xf1a0e305 0xe3982ebd
0x6f7cc391 0x5956374a 0xf414a5a2 0x325119ab
0x99ee1f96 0x6f044bd9 0x8374805b 0xb55c366c
0xa2c77051 0x68f199e5 0xd36a9714 0x878f847b
0xec0394ae 0x86d0584b 0xf4df66b9 0x451cd039
0xf4de06ae 0x35dd0554 0x818a342f 0xeefdbfc9
0x5b4e9edd 0x22d9313a 0x3b710d60 0x6deaeb4c
0xa9e26512 0x98d31867 0x3c2c2d61 0x7eb5ce41
0x40890db6 0x7a3aa660 0x3ef4f306 0x7322881f
0x49dac4d5 0x96efe685 0x27bb7f49 0xbb955283
0x79c5f2b7 0xff599c28 0x28ee7f5e 0x9f324b73
0x45edb7cf 0x39a8b79c 0xd0919c6e 0xe149b29d
0x62f5f82e 0xebcfa23e 0xd4d68937 0x54270090
0x958af0d4 0xa1e4e799 0xaf68ac19 0x82a84f4e
0x50f67b84 0xd5e59629 0xf5fdf24c 0xab1d63c5
0x30835807 0x431fce5f 0xe5f96f4d 0x3f6b4802
0x14010be8 0xdca45ae5 0xc82709af 0xff76ce2c
0x8b222c22 0x73a2d948 0xa8d59cea 0x8c31849e
0x469c2e5f 0x3777ee84 0x5fdfa5da 0x02ef9bb2
0x792d3194 0xbed63f21 0x0b6dc5f1 0xc9d7fe08
0x6df7883d 0x366566cf 0xef772769 0x37826465
0x1cdc3086 0xa69ff7b6 0x235012ea 0x292f7e75
0x30bdd0fd 0xffdc9df1 0x95c6d570 0xec206204
0xc6cd42cb 0xc0d6dfd9 0xb7a16b71 0x17fa527e
0x295f2c79 0x990f9820 0x8b8f447d 0x193f9ad1
0xebddb2af 0x5dd532eb 0xf1bbd8e8 0x3444a3f4
0x18ccce93 0x05edeb4f 0xc4a6b935 0xba37aab0
0x96076ba4 0x250dc2f7 0xc4093548 0x030e777d
0x7ea40933 0x8da7b1dd 0x59c0b79f 0x807d437c
0xf5233ddf 0x54c1983f 0xfc18771b 0xe74b85f0
0xdbd725b5 0x70cdd153 0x4ffe300c 0xfda4bdae
0xf4ac75d2 0x91c4e15a 0x34d92b97 0x16356a79
>;

5
arch/x86/include/asm/arch-coreboot/gpio.h
View File

@ -7,9 +7,4 @@
#ifndef _X86_ARCH_GPIO_H_
#define _X86_ARCH_GPIO_H_
struct ich6_bank_platdata {
uint32_t base_addr;
const char *bank_name;
};
#endif /* _X86_ARCH_GPIO_H_ */

10
arch/x86/include/asm/arch-ivybridge/gpio.h Normal file
View File

@ -0,0 +1,10 @@
/*
* Copyright (c) 2014, Google Inc.
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _X86_ARCH_GPIO_H_
#define _X86_ARCH_GPIO_H_
#endif /* _X86_ARCH_GPIO_H_ */

356
arch/x86/include/asm/arch-ivybridge/me.h Normal file
View File

@ -0,0 +1,356 @@
/*
* From Coreboot src/southbridge/intel/bd82x6x/me.h
*
* Copyright (C) 2011 The Chromium OS Authors. All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ASM_INTEL_ME_H
#define _ASM_INTEL_ME_H
#include <linux/compiler.h>
#include <linux/types.h>
#define ME_RETRY 100000 /* 1 second */
#define ME_DELAY 10 /* 10 us */
/*
* Management Engine PCI registers
*/
#define PCI_CPU_MEBASE_L 0x70 /* Set by MRC */
#define PCI_CPU_MEBASE_H 0x74 /* Set by MRC */
#define PCI_ME_HFS 0x40
#define ME_HFS_CWS_RESET 0
#define ME_HFS_CWS_INIT 1
#define ME_HFS_CWS_REC 2
#define ME_HFS_CWS_NORMAL 5
#define ME_HFS_CWS_WAIT 6
#define ME_HFS_CWS_TRANS 7
#define ME_HFS_CWS_INVALID 8
#define ME_HFS_STATE_PREBOOT 0
#define ME_HFS_STATE_M0_UMA 1
#define ME_HFS_STATE_M3 4
#define ME_HFS_STATE_M0 5
#define ME_HFS_STATE_BRINGUP 6
#define ME_HFS_STATE_ERROR 7
#define ME_HFS_ERROR_NONE 0
#define ME_HFS_ERROR_UNCAT 1
#define ME_HFS_ERROR_IMAGE 3
#define ME_HFS_ERROR_DEBUG 4
#define ME_HFS_MODE_NORMAL 0
#define ME_HFS_MODE_DEBUG 2
#define ME_HFS_MODE_DIS 3
#define ME_HFS_MODE_OVER_JMPR 4
#define ME_HFS_MODE_OVER_MEI 5
#define ME_HFS_BIOS_DRAM_ACK 1
#define ME_HFS_ACK_NO_DID 0
#define ME_HFS_ACK_RESET 1
#define ME_HFS_ACK_PWR_CYCLE 2
#define ME_HFS_ACK_S3 3
#define ME_HFS_ACK_S4 4
#define ME_HFS_ACK_S5 5
#define ME_HFS_ACK_GBL_RESET 6
#define ME_HFS_ACK_CONTINUE 7
struct me_hfs {
u32 working_state:4;
u32 mfg_mode:1;
u32 fpt_bad:1;
u32 operation_state:3;
u32 fw_init_complete:1;
u32 ft_bup_ld_flr:1;
u32 update_in_progress:1;
u32 error_code:4;
u32 operation_mode:4;
u32 reserved:4;
u32 boot_options_present:1;
u32 ack_data:3;
u32 bios_msg_ack:4;
} __packed;
#define PCI_ME_UMA 0x44
struct me_uma {
u32 size:6;
u32 reserved_1:10;
u32 valid:1;
u32 reserved_0:14;
u32 set_to_one:1;
} __packed;
#define PCI_ME_H_GS 0x4c
#define ME_INIT_DONE 1
#define ME_INIT_STATUS_SUCCESS 0
#define ME_INIT_STATUS_NOMEM 1
#define ME_INIT_STATUS_ERROR 2
struct me_did {
u32 uma_base:16;
u32 reserved:8;
u32 status:4;
u32 init_done:4;
} __packed;
#define PCI_ME_GMES 0x48
#define ME_GMES_PHASE_ROM 0
#define ME_GMES_PHASE_BUP 1
#define ME_GMES_PHASE_UKERNEL 2
#define ME_GMES_PHASE_POLICY 3
#define ME_GMES_PHASE_MODULE 4
#define ME_GMES_PHASE_UNKNOWN 5
#define ME_GMES_PHASE_HOST 6
struct me_gmes {
u32 bist_in_prog:1;
u32 icc_prog_sts:2;
u32 invoke_mebx:1;
u32 cpu_replaced_sts:1;
u32 mbp_rdy:1;
u32 mfs_failure:1;
u32 warm_rst_req_for_df:1;
u32 cpu_replaced_valid:1;
u32 reserved_1:2;
u32 fw_upd_ipu:1;
u32 reserved_2:4;
u32 current_state:8;
u32 current_pmevent:4;
u32 progress_code:4;
} __packed;
#define PCI_ME_HERES 0xbc
#define PCI_ME_EXT_SHA1 0x00
#define PCI_ME_EXT_SHA256 0x02
#define PCI_ME_HER(x) (0xc0+(4*(x)))
struct me_heres {
u32 extend_reg_algorithm:4;
u32 reserved:26;
u32 extend_feature_present:1;
u32 extend_reg_valid:1;
} __packed;
/*
* Management Engine MEI registers
*/
#define MEI_H_CB_WW 0x00
#define MEI_H_CSR 0x04
#define MEI_ME_CB_RW 0x08
#define MEI_ME_CSR_HA 0x0c
struct mei_csr {
u32 interrupt_enable:1;
u32 interrupt_status:1;
u32 interrupt_generate:1;
u32 ready:1;
u32 reset:1;
u32 reserved:3;
u32 buffer_read_ptr:8;
u32 buffer_write_ptr:8;
u32 buffer_depth:8;
} __packed;
#define MEI_ADDRESS_CORE 0x01
#define MEI_ADDRESS_AMT 0x02
#define MEI_ADDRESS_RESERVED 0x03
#define MEI_ADDRESS_WDT 0x04
#define MEI_ADDRESS_MKHI 0x07
#define MEI_ADDRESS_ICC 0x08
#define MEI_ADDRESS_THERMAL 0x09
#define MEI_HOST_ADDRESS 0
struct mei_header {
u32 client_address:8;
u32 host_address:8;
u32 length:9;
u32 reserved:6;
u32 is_complete:1;
} __packed;
#define MKHI_GROUP_ID_CBM 0x00
#define MKHI_GROUP_ID_FWCAPS 0x03
#define MKHI_GROUP_ID_MDES 0x08
#define MKHI_GROUP_ID_GEN 0xff
#define MKHI_GLOBAL_RESET 0x0b
#define MKHI_FWCAPS_GET_RULE 0x02
#define MKHI_MDES_ENABLE 0x09
#define MKHI_GET_FW_VERSION 0x02
#define MKHI_END_OF_POST 0x0c
#define MKHI_FEATURE_OVERRIDE 0x14
struct mkhi_header {
u32 group_id:8;
u32 command:7;
u32 is_response:1;
u32 reserved:8;
u32 result:8;
} __packed;
struct me_fw_version {
u16 code_minor;
u16 code_major;
u16 code_build_number;
u16 code_hot_fix;
u16 recovery_minor;
u16 recovery_major;
u16 recovery_build_number;
u16 recovery_hot_fix;
} __packed;
#define HECI_EOP_STATUS_SUCCESS 0x0
#define HECI_EOP_PERFORM_GLOBAL_RESET 0x1
#define CBM_RR_GLOBAL_RESET 0x01
#define GLOBAL_RESET_BIOS_MRC 0x01
#define GLOBAL_RESET_BIOS_POST 0x02
#define GLOBAL_RESET_MEBX 0x03
struct me_global_reset {
u8 request_origin;
u8 reset_type;
} __packed;
enum me_bios_path {
ME_NORMAL_BIOS_PATH,
ME_S3WAKE_BIOS_PATH,
ME_ERROR_BIOS_PATH,
ME_RECOVERY_BIOS_PATH,
ME_DISABLE_BIOS_PATH,
ME_FIRMWARE_UPDATE_BIOS_PATH,
};
struct __packed mbp_fw_version_name {
u32 major_version:16;
u32 minor_version:16;
u32 hotfix_version:16;
u32 build_version:16;
};
struct __packed mbp_icc_profile {
u8 num_icc_profiles;
u8 icc_profile_soft_strap;
u8 icc_profile_index;
u8 reserved;
u32 register_lock_mask[3];
};
struct __packed mefwcaps_sku {
u32 full_net:1;
u32 std_net:1;
u32 manageability:1;
u32 small_business:1;
u32 l3manageability:1;
u32 intel_at:1;
u32 intel_cls:1;
u32 reserved:3;
u32 intel_mpc:1;
u32 icc_over_clocking:1;
u32 pavp:1;
u32 reserved_1:4;
u32 ipv6:1;
u32 kvm:1;
u32 och:1;
u32 vlan:1;
u32 tls:1;
u32 reserved_4:1;
u32 wlan:1;
u32 reserved_5:8;
};
struct __packed tdt_state_flag {
u16 lock_state:1;
u16 authenticate_module:1;
u16 s3authentication:1;
u16 flash_wear_out:1;
u16 flash_variable_security:1;
u16 wwan3gpresent:1;
u16 wwan3goob:1;
u16 reserved:9;
};
struct __packed tdt_state_info {
u8 state;
u8 last_theft_trigger;
struct tdt_state_flag flags;
};
struct __packed platform_type_rule_data {
u32 platform_target_usage_type:4;
u32 platform_target_market_type:2;
u32 super_sku:1;
u32 reserved:1;
u32 intel_me_fw_image_type:4;
u32 platform_brand:4;
u32 reserved_1:16;
};
struct __packed mbp_fw_caps {
struct mefwcaps_sku fw_capabilities;
u8 available;
};
struct __packed mbp_rom_bist_data {
u16 device_id;
u16 fuse_test_flags;
u32 umchid[4];
};
struct __packed mbp_platform_key {
u32 key[8];
};
struct __packed mbp_plat_type {
struct platform_type_rule_data rule_data;
u8 available;
};
struct __packed me_bios_payload {
struct mbp_fw_version_name fw_version_name;
struct mbp_fw_caps fw_caps_sku;
struct mbp_rom_bist_data rom_bist_data;
struct mbp_platform_key platform_key;
struct mbp_plat_type fw_plat_type;
struct mbp_icc_profile icc_profile;
struct tdt_state_info at_state;
u32 mfsintegrity;
};
struct __packed mbp_header {
u32 mbp_size:8;
u32 num_entries:8;
u32 rsvd:16;
};
struct __packed mbp_item_header {
u32 app_id:8;
u32 item_id:8;
u32 length:8;
u32 rsvd:8;
};
struct __packed me_fwcaps {
u32 id;
u8 length;
struct mefwcaps_sku caps_sku;
u8 reserved[3];
};
/* Defined in me_status.c for both romstage and ramstage */
void intel_me_status(struct me_hfs *hfs, struct me_gmes *gmes);
void intel_early_me_status(void);
int intel_early_me_init(void);
int intel_early_me_uma_size(void);
int intel_early_me_init_done(u8 status);
#endif

20
arch/x86/include/asm/arch-ivybridge/microcode.h Normal file
View File

@ -0,0 +1,20 @@
/*
* Copyright (c) 2015 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef __ASM_ARCH_MICROCODE_H
#define __ASM_ARCH_MICROCODE_H
/**
* microcode_update_intel() - Apply microcode updates
*
* Applies any microcode updates in the device tree.
*
* @return 0 if OK, -EEXIST if the updates were already applied, -ENOENT if
* not updates were found, -EINVAL if an update was invalid
*/
int microcode_update_intel(void);
#endif

82
arch/x86/include/asm/arch-ivybridge/model_206ax.h Normal file
View File

@ -0,0 +1,82 @@
/*
* From Coreboot file of the same name
*
* Copyright (C) 2011 The ChromiumOS Authors.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ASM_ARCH_MODEL_206AX_H
#define _ASM_ARCH_MODEL_206AX_H
/* SandyBridge/IvyBridge bus clock is fixed at 100MHz */
#define SANDYBRIDGE_BCLK 100
#define CPUID_VMX (1 << 5)
#define CPUID_SMX (1 << 6)
#define MSR_FEATURE_CONFIG 0x13c
#define MSR_FLEX_RATIO 0x194
#define FLEX_RATIO_LOCK (1 << 20)
#define FLEX_RATIO_EN (1 << 16)
#define IA32_PLATFORM_DCA_CAP 0x1f8
#define IA32_MISC_ENABLE 0x1a0
#define MSR_TEMPERATURE_TARGET 0x1a2
#define IA32_PERF_CTL 0x199
#define IA32_THERM_INTERRUPT 0x19b
#define IA32_ENERGY_PERFORMANCE_BIAS 0x1b0
#define ENERGY_POLICY_PERFORMANCE 0
#define ENERGY_POLICY_NORMAL 6
#define ENERGY_POLICY_POWERSAVE 15
#define IA32_PACKAGE_THERM_INTERRUPT 0x1b2
#define MSR_LT_LOCK_MEMORY 0x2e7
#define IA32_MC0_STATUS 0x401
#define MSR_PIC_MSG_CONTROL 0x2e
#define PLATFORM_INFO_SET_TDP (1 << 29)
#define MSR_MISC_PWR_MGMT 0x1aa
#define MISC_PWR_MGMT_EIST_HW_DIS (1 << 0)
#define MSR_TURBO_RATIO_LIMIT 0x1ad
#define MSR_POWER_CTL 0x1fc
#define MSR_PKGC3_IRTL 0x60a
#define MSR_PKGC6_IRTL 0x60b
#define MSR_PKGC7_IRTL 0x60c
#define IRTL_VALID (1 << 15)
#define IRTL_1_NS (0 << 10)
#define IRTL_32_NS (1 << 10)
#define IRTL_1024_NS (2 << 10)
#define IRTL_32768_NS (3 << 10)
#define IRTL_1048576_NS (4 << 10)
#define IRTL_33554432_NS (5 << 10)
#define IRTL_RESPONSE_MASK (0x3ff)
/* long duration in low dword, short duration in high dword */
#define PKG_POWER_LIMIT_MASK 0x7fff
#define PKG_POWER_LIMIT_EN (1 << 15)
#define PKG_POWER_LIMIT_CLAMP (1 << 16)
#define PKG_POWER_LIMIT_TIME_SHIFT 17
#define PKG_POWER_LIMIT_TIME_MASK 0x7f
#define MSR_PP0_CURRENT_CONFIG 0x601
#define PP0_CURRENT_LIMIT (112 << 3) /* 112 A */
#define MSR_PP1_CURRENT_CONFIG 0x602
#define PP1_CURRENT_LIMIT_SNB (35 << 3) /* 35 A */
#define PP1_CURRENT_LIMIT_IVB (50 << 3) /* 50 A */
#define MSR_PKG_POWER_SKU_UNIT 0x606
#define MSR_PKG_POWER_SKU 0x614
#define IVB_CONFIG_TDP_MIN_CPUID 0x306a2
#define MSR_CONFIG_TDP_NOMINAL 0x648
#define MSR_CONFIG_TDP_LEVEL1 0x649
#define MSR_CONFIG_TDP_LEVEL2 0x64a
#define MSR_CONFIG_TDP_CONTROL 0x64b
#define MSR_TURBO_ACTIVATION_RATIO 0x64c
/* P-state configuration */
#define PSS_MAX_ENTRIES 8
#define PSS_RATIO_STEP 2
#define PSS_LATENCY_TRANSITION 10
#define PSS_LATENCY_BUSMASTER 10
#endif

356
arch/x86/include/asm/arch-ivybridge/pch.h Normal file
View File

@ -0,0 +1,356 @@
/*
* Copyright (c) 2014 Google, Inc
*
* From Coreboot src/southbridge/intel/bd82x6x/pch.h
*
* Copyright (C) 2008-2009 coresystems GmbH
* Copyright (C) 2012 The Chromium OS Authors. All rights reserved.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ASM_ARCH_PCH_H
#define _ASM_ARCH_PCH_H
#include <pci.h>
#define DEFAULT_GPIOBASE 0x0480
#define DEFAULT_PMBASE 0x0500
#define SMBUS_IO_BASE 0x0400
#define PCH_EHCI1_DEV PCI_BDF(0, 0x1d, 0)
#define PCH_EHCI2_DEV PCI_BDF(0, 0x1a, 0)
#define PCH_XHCI_DEV PCI_BDF(0, 0x14, 0)
#define PCH_ME_DEV PCI_BDF(0, 0x16, 0)
#define PCH_PCIE_DEV_SLOT 28
#define PCH_DEV PCI_BDF(0, 0, 0)
#define PCH_VIDEO_DEV PCI_BDF(0, 2, 0)
/* PCI Configuration Space (D31:F0): LPC */
#define PCH_LPC_DEV PCI_BDF(0, 0x1f, 0)
#define GEN_PMCON_1 0xa0
#define GEN_PMCON_2 0xa2
#define GEN_PMCON_3 0xa4
#define ETR3 0xac
#define ETR3_CWORWRE (1 << 18)
#define ETR3_CF9GR (1 << 20)
#define PMBASE 0x40
#define ACPI_CNTL 0x44
#define BIOS_CNTL 0xDC
#define GPIO_BASE 0x48 /* LPC GPIO Base Address Register */
#define GPIO_CNTL 0x4C /* LPC GPIO Control Register */
#define GPIO_ROUT 0xb8
#define LPC_IO_DEC 0x80 /* IO Decode Ranges Register */
#define LPC_EN 0x82 /* LPC IF Enables Register */
#define CNF2_LPC_EN (1 << 13) /* 0x4e/0x4f */
#define CNF1_LPC_EN (1 << 12) /* 0x2e/0x2f */
#define MC_LPC_EN (1 << 11) /* 0x62/0x66 */
#define KBC_LPC_EN (1 << 10) /* 0x60/0x64 */
#define GAMEH_LPC_EN (1 << 9) /* 0x208/0x20f */
#define GAMEL_LPC_EN (1 << 8) /* 0x200/0x207 */
#define FDD_LPC_EN (1 << 3) /* LPC_IO_DEC[12] */
#define LPT_LPC_EN (1 << 2) /* LPC_IO_DEC[9:8] */
#define COMB_LPC_EN (1 << 1) /* LPC_IO_DEC[6:4] */
#define COMA_LPC_EN (1 << 0) /* LPC_IO_DEC[3:2] */
#define LPC_GEN1_DEC 0x84 /* LPC IF Generic Decode Range 1 */
#define LPC_GEN2_DEC 0x88 /* LPC IF Generic Decode Range 2 */
#define LPC_GEN3_DEC 0x8c /* LPC IF Generic Decode Range 3 */
#define LPC_GEN4_DEC 0x90 /* LPC IF Generic Decode Range 4 */
#define LPC_GENX_DEC(x) (0x84 + 4 * (x))
/* PCI Configuration Space (D31:F3): SMBus */
#define PCH_SMBUS_DEV PCI_BDF(0, 0x1f, 3)
#define SMB_BASE 0x20
#define HOSTC 0x40
#define SMB_RCV_SLVA 0x09
/* HOSTC bits */
#define I2C_EN (1 << 2)
#define SMB_SMI_EN (1 << 1)
#define HST_EN (1 << 0)
/* SMBus I/O bits. */
#define SMBHSTSTAT 0x0
#define SMBHSTCTL 0x2
#define SMBHSTCMD 0x3
#define SMBXMITADD 0x4
#define SMBHSTDAT0 0x5
#define SMBHSTDAT1 0x6
#define SMBBLKDAT 0x7
#define SMBTRNSADD 0x9
#define SMBSLVDATA 0xa
#define SMLINK_PIN_CTL 0xe
#define SMBUS_PIN_CTL 0xf
#define SMBUS_TIMEOUT (10 * 1000 * 100)
/* Root Complex Register Block */
#define DEFAULT_RCBA 0xfed1c000
#define RCB_REG(reg) (DEFAULT_RCBA + (reg))
#define PCH_RCBA_BASE 0xf0
#define VCH 0x0000 /* 32bit */
#define VCAP1 0x0004 /* 32bit */
#define VCAP2 0x0008 /* 32bit */
#define PVC 0x000c /* 16bit */
#define PVS 0x000e /* 16bit */
#define V0CAP 0x0010 /* 32bit */
#define V0CTL 0x0014 /* 32bit */
#define V0STS 0x001a /* 16bit */
#define V1CAP 0x001c /* 32bit */
#define V1CTL 0x0020 /* 32bit */
#define V1STS 0x0026 /* 16bit */
#define RCTCL 0x0100 /* 32bit */
#define ESD 0x0104 /* 32bit */
#define ULD 0x0110 /* 32bit */
#define ULBA 0x0118 /* 64bit */
#define RP1D 0x0120 /* 32bit */
#define RP1BA 0x0128 /* 64bit */
#define RP2D 0x0130 /* 32bit */
#define RP2BA 0x0138 /* 64bit */
#define RP3D 0x0140 /* 32bit */
#define RP3BA 0x0148 /* 64bit */
#define RP4D 0x0150 /* 32bit */
#define RP4BA 0x0158 /* 64bit */
#define HDD 0x0160 /* 32bit */
#define HDBA 0x0168 /* 64bit */
#define RP5D 0x0170 /* 32bit */
#define RP5BA 0x0178 /* 64bit */
#define RP6D 0x0180 /* 32bit */
#define RP6BA 0x0188 /* 64bit */
#define RPC 0x0400 /* 32bit */
#define RPFN 0x0404 /* 32bit */
#define TRSR 0x1e00 /* 8bit */
#define TRCR 0x1e10 /* 64bit */
#define TWDR 0x1e18 /* 64bit */
#define IOTR0 0x1e80 /* 64bit */
#define IOTR1 0x1e88 /* 64bit */
#define IOTR2 0x1e90 /* 64bit */
#define IOTR3 0x1e98 /* 64bit */
#define TCTL 0x3000 /* 8bit */
#define NOINT 0
#define INTA 1
#define INTB 2
#define INTC 3
#define INTD 4
#define DIR_IDR 12 /* Interrupt D Pin Offset */
#define DIR_ICR 8 /* Interrupt C Pin Offset */
#define DIR_IBR 4 /* Interrupt B Pin Offset */
#define DIR_IAR 0 /* Interrupt A Pin Offset */
#define PIRQA 0
#define PIRQB 1
#define PIRQC 2
#define PIRQD 3
#define PIRQE 4
#define PIRQF 5
#define PIRQG 6
#define PIRQH 7
/* IO Buffer Programming */
#define IOBPIRI 0x2330
#define IOBPD 0x2334
#define IOBPS 0x2338
#define IOBPS_RW_BX ((1 << 9)|(1 << 10))
#define IOBPS_WRITE_AX ((1 << 9)|(1 << 10))
#define IOBPS_READ_AX ((1 << 8)|(1 << 9)|(1 << 10))
#define D31IP 0x3100 /* 32bit */
#define D31IP_TTIP 24 /* Thermal Throttle Pin */
#define D31IP_SIP2 20 /* SATA Pin 2 */
#define D31IP_SMIP 12 /* SMBUS Pin */
#define D31IP_SIP 8 /* SATA Pin */
#define D30IP 0x3104 /* 32bit */
#define D30IP_PIP 0 /* PCI Bridge Pin */
#define D29IP 0x3108 /* 32bit */
#define D29IP_E1P 0 /* EHCI #1 Pin */
#define D28IP 0x310c /* 32bit */
#define D28IP_P8IP 28 /* PCI Express Port 8 */
#define D28IP_P7IP 24 /* PCI Express Port 7 */
#define D28IP_P6IP 20 /* PCI Express Port 6 */
#define D28IP_P5IP 16 /* PCI Express Port 5 */
#define D28IP_P4IP 12 /* PCI Express Port 4 */
#define D28IP_P3IP 8 /* PCI Express Port 3 */
#define D28IP_P2IP 4 /* PCI Express Port 2 */
#define D28IP_P1IP 0 /* PCI Express Port 1 */
#define D27IP 0x3110 /* 32bit */
#define D27IP_ZIP 0 /* HD Audio Pin */
#define D26IP 0x3114 /* 32bit */
#define D26IP_E2P 0 /* EHCI #2 Pin */
#define D25IP 0x3118 /* 32bit */
#define D25IP_LIP 0 /* GbE LAN Pin */
#define D22IP 0x3124 /* 32bit */
#define D22IP_KTIP 12 /* KT Pin */
#define D22IP_IDERIP 8 /* IDE-R Pin */
#define D22IP_MEI2IP 4 /* MEI #2 Pin */
#define D22IP_MEI1IP 0 /* MEI #1 Pin */
#define D20IP 0x3128 /* 32bit */
#define D20IP_XHCIIP 0
#define D31IR 0x3140 /* 16bit */
#define D30IR 0x3142 /* 16bit */
#define D29IR 0x3144 /* 16bit */
#define D28IR 0x3146 /* 16bit */
#define D27IR 0x3148 /* 16bit */
#define D26IR 0x314c /* 16bit */
#define D25IR 0x3150 /* 16bit */
#define D22IR 0x315c /* 16bit */
#define D20IR 0x3160 /* 16bit */
#define OIC 0x31fe /* 16bit */
#define SPI_FREQ_SWSEQ 0x3893
#define SPI_DESC_COMP0 0x38b0
#define SPI_FREQ_WR_ERA 0x38b4
#define SOFT_RESET_CTRL 0x38f4
#define SOFT_RESET_DATA 0x38f8
#define DIR_ROUTE(a, b, c, d) \
(((d) << DIR_IDR) | ((c) << DIR_ICR) | \
((b) << DIR_IBR) | ((a) << DIR_IAR))
#define RC 0x3400 /* 32bit */
#define HPTC 0x3404 /* 32bit */
#define GCS 0x3410 /* 32bit */
#define BUC 0x3414 /* 32bit */
#define PCH_DISABLE_GBE (1 << 5)
#define FD 0x3418 /* 32bit */
#define DISPBDF 0x3424 /* 16bit */
#define FD2 0x3428 /* 32bit */
#define CG 0x341c /* 32bit */
/* Function Disable 1 RCBA 0x3418 */
#define PCH_DISABLE_ALWAYS ((1 << 0)|(1 << 26))
#define PCH_DISABLE_P2P (1 << 1)
#define PCH_DISABLE_SATA1 (1 << 2)
#define PCH_DISABLE_SMBUS (1 << 3)
#define PCH_DISABLE_HD_AUDIO (1 << 4)
#define PCH_DISABLE_EHCI2 (1 << 13)
#define PCH_DISABLE_LPC (1 << 14)
#define PCH_DISABLE_EHCI1 (1 << 15)
#define PCH_DISABLE_PCIE(x) (1 << (16 + x))
#define PCH_DISABLE_THERMAL (1 << 24)
#define PCH_DISABLE_SATA2 (1 << 25)
#define PCH_DISABLE_XHCI (1 << 27)
/* Function Disable 2 RCBA 0x3428 */
#define PCH_DISABLE_KT (1 << 4)
#define PCH_DISABLE_IDER (1 << 3)
#define PCH_DISABLE_MEI2 (1 << 2)
#define PCH_DISABLE_MEI1 (1 << 1)
#define PCH_ENABLE_DBDF (1 << 0)
/* ICH7 GPIOBASE */
#define GPIO_USE_SEL 0x00
#define GP_IO_SEL 0x04
#define GP_LVL 0x0c
#define GPO_BLINK 0x18
#define GPI_INV 0x2c
#define GPIO_USE_SEL2 0x30
#define GP_IO_SEL2 0x34
#define GP_LVL2 0x38
#define GPIO_USE_SEL3 0x40
#define GP_IO_SEL3 0x44
#define GP_LVL3 0x48
#define GP_RST_SEL1 0x60
#define GP_RST_SEL2 0x64
#define GP_RST_SEL3 0x68
/* ICH7 PMBASE */
#define PM1_STS 0x00
#define WAK_STS (1 << 15)
#define PCIEXPWAK_STS (1 << 14)
#define PRBTNOR_STS (1 << 11)
#define RTC_STS (1 << 10)
#define PWRBTN_STS (1 << 8)
#define GBL_STS (1 << 5)
#define BM_STS (1 << 4)
#define TMROF_STS (1 << 0)
#define PM1_EN 0x02
#define PCIEXPWAK_DIS (1 << 14)
#define RTC_EN (1 << 10)
#define PWRBTN_EN (1 << 8)
#define GBL_EN (1 << 5)
#define TMROF_EN (1 << 0)
#define PM1_CNT 0x04
#define SLP_EN (1 << 13)
#define SLP_TYP (7 << 10)
#define SLP_TYP_S0 0
#define SLP_TYP_S1 1
#define SLP_TYP_S3 5
#define SLP_TYP_S4 6
#define SLP_TYP_S5 7
#define GBL_RLS (1 << 2)
#define BM_RLD (1 << 1)
#define SCI_EN (1 << 0)
#define PM1_TMR 0x08
#define PROC_CNT 0x10
#define LV2 0x14
#define LV3 0x15
#define LV4 0x16
#define PM2_CNT 0x50 /* mobile only */
#define GPE0_STS 0x20
#define PME_B0_STS (1 << 13)
#define PME_STS (1 << 11)
#define BATLOW_STS (1 << 10)
#define PCI_EXP_STS (1 << 9)
#define RI_STS (1 << 8)
#define SMB_WAK_STS (1 << 7)
#define TCOSCI_STS (1 << 6)
#define SWGPE_STS (1 << 2)
#define HOT_PLUG_STS (1 << 1)
#define GPE0_EN 0x28
#define PME_B0_EN (1 << 13)
#define PME_EN (1 << 11)
#define TCOSCI_EN (1 << 6)
#define SMI_EN 0x30
#define INTEL_USB2_EN (1 << 18) /* Intel-Specific USB2 SMI logic */
#define LEGACY_USB2_EN (1 << 17) /* Legacy USB2 SMI logic */
#define PERIODIC_EN (1 << 14) /* SMI on PERIODIC_STS in SMI_STS */
#define TCO_EN (1 << 13) /* Enable TCO Logic (BIOSWE et al) */
#define MCSMI_EN (1 << 11) /* Trap microcontroller range access */
#define BIOS_RLS (1 << 7) /* asserts SCI on bit set */
#define SWSMI_TMR_EN (1 << 6) /* start software smi timer on bit set */
#define APMC_EN (1 << 5) /* Writes to APM_CNT cause SMI# */
#define SLP_SMI_EN (1 << 4) /* Write SLP_EN in PM1_CNT asserts SMI# */
#define LEGACY_USB_EN (1 << 3) /* Legacy USB circuit SMI logic */
#define BIOS_EN (1 << 2) /* Assert SMI# on setting GBL_RLS bit */
#define EOS (1 << 1) /* End of SMI (deassert SMI#) */
#define GBL_SMI_EN (1 << 0) /* SMI# generation at all? */
#define SMI_STS 0x34
#define ALT_GP_SMI_EN 0x38
#define ALT_GP_SMI_STS 0x3a
#define GPE_CNTL 0x42
#define DEVACT_STS 0x44
#define SS_CNT 0x50
#define C3_RES 0x54
#define TCO1_STS 0x64
#define DMISCI_STS (1 << 9)
#define TCO2_STS 0x66
/**
* lpc_early_init() - set up LPC serial ports and other early things
*
* @blob: Device tree blob
* @node: Offset of LPC node
* @dev: PCH PCI device containing the LPC
* @return 0 if OK, -ve on error
*/
int lpc_early_init(const void *blob, int node, pci_dev_t dev);
#endif

121
arch/x86/include/asm/arch-ivybridge/pei_data.h Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright (c) 2011, Google Inc.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef ASM_ARCH_PEI_DATA_H
#define ASM_ARCH_PEI_DATA_H
struct pch_usb3_controller_settings {
/* 0: Disable, 1: Enable, 2: Auto, 3: Smart Auto */
uint16_t mode;
/* 4 bit mask, 1: switchable, 0: not switchable */
uint16_t hs_port_switch_mask;
/* 0: No xHCI preOS driver, 1: xHCI preOS driver */
uint16_t preboot_support;
/* 0: Disable, 1: Enable */
uint16_t xhci_streams;
};
typedef asmlinkage void (*tx_byte_func)(unsigned char byte);
#define PEI_VERSION 6
struct __packed pei_data {
uint32_t pei_version;
uint32_t mchbar;
uint32_t dmibar;
uint32_t epbar;
uint32_t pciexbar;
uint16_t smbusbar;
uint32_t wdbbar;
uint32_t wdbsize;
uint32_t hpet_address;
uint32_t rcba;
uint32_t pmbase;
uint32_t gpiobase;
uint32_t thermalbase;
uint32_t system_type; /* 0 Mobile, 1 Desktop/Server */
uint32_t tseg_size;
uint8_t spd_addresses[4];
uint8_t ts_addresses[4];
int boot_mode;
int ec_present;
int gbe_enable;
/*
* 0 = leave channel enabled
* 1 = disable dimm 0 on channel
* 2 = disable dimm 1 on channel
* 3 = disable dimm 0+1 on channel
*/
int dimm_channel0_disabled;
int dimm_channel1_disabled;
/* Seed values saved in CMOS */
uint32_t scrambler_seed;
uint32_t scrambler_seed_s3;
/* Data read from flash and passed into MRC */
unsigned char *mrc_input;
unsigned int mrc_input_len;
/* Data from MRC that should be saved to flash */
unsigned char *mrc_output;
unsigned int mrc_output_len;
/*
* Max frequency DDR3 could be ran at. Could be one of four values:
* 800, 1067, 1333, 1600
*/
uint32_t max_ddr3_freq;
/*
* USB Port Configuration:
* [0] = enable
* [1] = overcurrent pin
* [2] = length
*
* Ports 0-7 can be mapped to OC0-OC3
* Ports 8-13 can be mapped to OC4-OC7
*
* Port Length
* MOBILE:
* < 0x050 = Setting 1 (back panel, 1-5in, lowest tx amplitude)
* < 0x140 = Setting 2 (back panel, 5-14in, highest tx amplitude)
* DESKTOP:
* < 0x080 = Setting 1 (front/back panel, <8in, lowest tx amplitude)
* < 0x130 = Setting 2 (back panel, 8-13in, higher tx amplitude)
* < 0x150 = Setting 3 (back panel, 13-15in, higest tx amplitude)
*/
uint16_t usb_port_config[16][3];
/* See the usb3 struct above for details */
struct pch_usb3_controller_settings usb3;
/*
* SPD data array for onboard RAM. Specify address 0xf0,
* 0xf1, 0xf2, 0xf3 to index one of the 4 slots in
* spd_address for a given "DIMM".
*/
uint8_t spd_data[4][256];
tx_byte_func tx_byte;
int ddr3lv_support;
/*
* pcie_init needs to be set to 1 to have the system agent initialise
* PCIe. Note: This should only be required if your system has Gen3
* devices and it will increase your boot time by at least 100ms.
*/
int pcie_init;
/*
* N mode functionality. Leave this setting at 0.
* 0 Auto
* 1 1N
* 2 2N
*/
int nmode;
/*
* DDR refresh rate config. JEDEC Standard No.21-C Annex K allows
* for DIMM SPD data to specify whether double-rate is required for
* extended operating temperature range.
* 0 Enable double rate based upon temperature thresholds
* 1 Normal rate
* 2 Always enable double rate
*/
int ddr_refresh_rate_config;
};
#endif

109
arch/x86/include/asm/arch-ivybridge/sandybridge.h Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright (c) 2014 Google, Inc
*
* From Coreboot file of the same name
*
* Copyright (C) 2007-2008 coresystems GmbH
* Copyright (C) 2011 Google Inc.
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ACH_ASM_SANDYBRIDGE_H
#define _ACH_ASM_SANDYBRIDGE_H
/* Chipset types */
#define SANDYBRIDGE_MOBILE 0
#define SANDYBRIDGE_DESKTOP 1
#define SANDYBRIDGE_SERVER 2
/* Device ID for SandyBridge and IvyBridge */
#define BASE_REV_SNB 0x00
#define BASE_REV_IVB 0x50
#define BASE_REV_MASK 0x50
/* SandyBridge CPU stepping */
#define SNB_STEP_D0 (BASE_REV_SNB + 5) /* Also J0 */
#define SNB_STEP_D1 (BASE_REV_SNB + 6)
#define SNB_STEP_D2 (BASE_REV_SNB + 7) /* Also J1/Q0 */
/* IvyBridge CPU stepping */
#define IVB_STEP_A0 (BASE_REV_IVB + 0)
#define IVB_STEP_B0 (BASE_REV_IVB + 2)
#define IVB_STEP_C0 (BASE_REV_IVB + 4)
#define IVB_STEP_K0 (BASE_REV_IVB + 5)
#define IVB_STEP_D0 (BASE_REV_IVB + 6)
/* Intel Enhanced Debug region must be 4MB */
#define IED_SIZE 0x400000
/* Northbridge BARs */
#define DEFAULT_MCHBAR 0xfed10000 /* 16 KB */
#define DEFAULT_DMIBAR 0xfed18000 /* 4 KB */
#define DEFAULT_EPBAR 0xfed19000 /* 4 KB */
#define DEFAULT_RCBABASE 0xfed1c000
/* 4 KB per PCIe device */
#define DEFAULT_PCIEXBAR CONFIG_MMCONF_BASE_ADDRESS
/* Device 0:0.0 PCI configuration space (Host Bridge) */
#define EPBAR 0x40
#define MCHBAR 0x48
#define PCIEXBAR 0x60
#define DMIBAR 0x68
#define X60BAR 0x60
#define GGC 0x50 /* GMCH Graphics Control */
#define DEVEN 0x54 /* Device Enable */
#define DEVEN_PEG60 (1 << 13)
#define DEVEN_IGD (1 << 4)
#define DEVEN_PEG10 (1 << 3)
#define DEVEN_PEG11 (1 << 2)
#define DEVEN_PEG12 (1 << 1)
#define DEVEN_HOST (1 << 0)
#define PAM0 0x80
#define PAM1 0x81
#define PAM2 0x82
#define PAM3 0x83
#define PAM4 0x84
#define PAM5 0x85
#define PAM6 0x86
#define LAC 0x87 /* Legacy Access Control */
#define SMRAM 0x88 /* System Management RAM Control */
#define D_OPEN (1 << 6)
#define D_CLS (1 << 5)
#define D_LCK (1 << 4)
#define G_SMRAME (1 << 3)
#define C_BASE_SEG ((0 << 2) | (1 << 1) | (0 << 0))
#define TOM 0xa0
#define TOUUD 0xa8 /* Top of Upper Usable DRAM */
#define TSEG 0xb8 /* TSEG base */
#define TOLUD 0xbc /* Top of Low Used Memory */
#define SKPAD 0xdc /* Scratchpad Data */
/* Device 0:1.0 PCI configuration space (PCI Express) */
#define BCTRL1 0x3e /* 16bit */
/* Device 0:2.0 PCI configuration space (Graphics Device) */
#define MSAC 0x62 /* Multi Size Aperture Control */
#define SWSCI 0xe8 /* SWSCI enable */
#define ASLS 0xfc /* OpRegion Base */
/*
* MCHBAR
*/
#define MCHBAR_REG(reg) (DEFAULT_RCBA + (reg))
#define SSKPD 0x5d14 /* 16bit (scratchpad) */
#define BIOS_RESET_CPL 0x5da8 /* 8bit */
void report_platform_info(void);
void sandybridge_early_init(int chipset_type);
#endif

1
arch/x86/include/asm/config.h
View File

@ -10,5 +10,6 @@
#define CONFIG_SYS_GENERIC_BOARD
#define CONFIG_LMB
#define CONFIG_SYS_BOOT_RAMDISK_HIGH
#define asmlinkage __attribute__((regparm(0)))
#endif

173
arch/x86/include/asm/cpu.h
View File

@ -1,16 +1,160 @@
/*
* Copyright (c) 2014 The Chromium OS Authors.
*
* Part of this file is adapted from coreboot
* src/arch/x86/include/arch/cpu.h and
* src/arch/x86/lib/cpu.c
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef __X86_CPU_H
#define __X86_CPU_H
#ifndef _ASM_CPU_H
#define _ASM_CPU_H
/**
enum {
X86_VENDOR_INVALID = 0,
X86_VENDOR_INTEL,
X86_VENDOR_CYRIX,
X86_VENDOR_AMD,
X86_VENDOR_UMC,
X86_VENDOR_NEXGEN,
X86_VENDOR_CENTAUR,
X86_VENDOR_RISE,
X86_VENDOR_TRANSMETA,
X86_VENDOR_NSC,
X86_VENDOR_SIS,
X86_VENDOR_ANY = 0xfe,
X86_VENDOR_UNKNOWN = 0xff
};
struct cpuid_result {
uint32_t eax;
uint32_t ebx;
uint32_t ecx;
uint32_t edx;
};
/*
* Generic CPUID function
*/
static inline struct cpuid_result cpuid(int op)
{
struct cpuid_result result;
asm volatile(
"mov %%ebx, %%edi;"
"cpuid;"
"mov %%ebx, %%esi;"
"mov %%edi, %%ebx;"
: "=a" (result.eax),
"=S" (result.ebx),
"=c" (result.ecx),
"=d" (result.edx)
: "0" (op)
: "edi");
return result;
}
/*
* Generic Extended CPUID function
*/
static inline struct cpuid_result cpuid_ext(int op, unsigned ecx)
{
struct cpuid_result result;
asm volatile(
"mov %%ebx, %%edi;"
"cpuid;"
"mov %%ebx, %%esi;"
"mov %%edi, %%ebx;"
: "=a" (result.eax),
"=S" (result.ebx),
"=c" (result.ecx),
"=d" (result.edx)
: "0" (op), "2" (ecx)
: "edi");
return result;
}
/*
* CPUID functions returning a single datum
*/
static inline unsigned int cpuid_eax(unsigned int op)
{
unsigned int eax;
__asm__("mov %%ebx, %%edi;"
"cpuid;"
"mov %%edi, %%ebx;"
: "=a" (eax)
: "0" (op)
: "ecx", "edx", "edi");
return eax;
}
static inline unsigned int cpuid_ebx(unsigned int op)
{
unsigned int eax, ebx;
__asm__("mov %%ebx, %%edi;"
"cpuid;"
"mov %%ebx, %%esi;"
"mov %%edi, %%ebx;"
: "=a" (eax), "=S" (ebx)
: "0" (op)
: "ecx", "edx", "edi");
return ebx;
}
static inline unsigned int cpuid_ecx(unsigned int op)
{
unsigned int eax, ecx;
__asm__("mov %%ebx, %%edi;"
"cpuid;"
"mov %%edi, %%ebx;"
: "=a" (eax), "=c" (ecx)
: "0" (op)
: "edx", "edi");
return ecx;
}
static inline unsigned int cpuid_edx(unsigned int op)
{
unsigned int eax, edx;
__asm__("mov %%ebx, %%edi;"
"cpuid;"
"mov %%edi, %%ebx;"
: "=a" (eax), "=d" (edx)
: "0" (op)
: "ecx", "edi");
return edx;
}
/* Standard macro to see if a specific flag is changeable */
static inline int flag_is_changeable_p(uint32_t flag)
{
uint32_t f1, f2;
asm(
"pushfl\n\t"
"pushfl\n\t"
"popl %0\n\t"
"movl %0,%1\n\t"
"xorl %2,%0\n\t"
"pushl %0\n\t"
"popfl\n\t"
"pushfl\n\t"
"popl %0\n\t"
"popfl\n\t"
: "=&r" (f1), "=&r" (f2)
: "ir" (flag));
return ((f1^f2) & flag) != 0;
}
/**
* cpu_enable_paging_pae() - Enable PAE-paging
*
* @pdpt: Value to set in cr3 (PDPT or PML4T)
* @cr3: Value to set in cr3 (PDPT or PML4T)
*/
void cpu_enable_paging_pae(ulong cr3);
@ -26,6 +170,27 @@ void cpu_disable_paging_pae(void);
*/
int cpu_has_64bit(void);
/**
* cpu_vendor_name() - Get CPU vendor name
*
* @vendor: CPU vendor enumeration number
*
* @return: Address to hold the CPU vendor name string
*/
const char *cpu_vendor_name(int vendor);
#define CPU_MAX_NAME_LEN 49
/**
* cpu_get_name() - Get the name of the current cpu
*
* @name: Place to put name, which must be CPU_MAX_NAME_LEN bytes including
* @return pointer to name, which will likely be a few bytes after the start
* of @name
* \0 terminator
*/
char *cpu_get_name(char *name);
/**
* cpu_call64() - Jump to a 64-bit Linux kernel (internal function)
*

30
arch/x86/include/asm/global_data.h
View File

@ -10,13 +10,43 @@
#ifndef __ASSEMBLY__
enum pei_boot_mode_t {
PEI_BOOT_NONE = 0,
PEI_BOOT_SOFT_RESET,
PEI_BOOT_RESUME,
};
struct memory_area {
uint64_t start;
uint64_t size;
};
struct memory_info {
int num_areas;
uint64_t total_memory;
uint64_t total_32bit_memory;
struct memory_area area[CONFIG_NR_DRAM_BANKS];
};
/* Architecture-specific global data */
struct arch_global_data {
struct global_data *gd_addr; /* Location of Global Data */
uint8_t x86; /* CPU family */
uint8_t x86_vendor; /* CPU vendor */
uint8_t x86_model;
uint8_t x86_mask;
uint32_t x86_device;
uint64_t tsc_base; /* Initial value returned by rdtsc() */
uint32_t tsc_base_kclocks; /* Initial tsc as a kclocks value */
uint32_t tsc_prev; /* For show_boot_progress() */
uint32_t tsc_mhz; /* TSC frequency in MHz */
void *new_fdt; /* Relocated FDT */
uint32_t bist; /* Built-in self test value */
struct pci_controller *hose; /* PCI hose for early use */
enum pei_boot_mode_t pei_boot_mode;
const struct pch_gpio_map *gpio_map; /* board GPIO map */
struct memory_info meminfo; /* Memory information */
};
#endif

142
arch/x86/include/asm/gpio.h
View File

@ -1,12 +1,152 @@
/*
* Copyright (c) 2012, Google Inc. All rights reserved.
* SPDX-License-Identifier: GPL-2.0+
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _X86_GPIO_H_
#define _X86_GPIO_H_
#include <linux/compiler.h>
#include <asm/arch/gpio.h>
#include <asm-generic/gpio.h>
struct ich6_bank_platdata {
uint32_t base_addr;
const char *bank_name;
};
#define GPIO_MODE_NATIVE 0
#define GPIO_MODE_GPIO 1
#define GPIO_MODE_NONE 1
#define GPIO_DIR_OUTPUT 0
#define GPIO_DIR_INPUT 1
#define GPIO_NO_INVERT 0
#define GPIO_INVERT 1
#define GPIO_LEVEL_LOW 0
#define GPIO_LEVEL_HIGH 1
#define GPIO_NO_BLINK 0
#define GPIO_BLINK 1
#define GPIO_RESET_PWROK 0
#define GPIO_RESET_RSMRST 1
struct pch_gpio_set1 {
u32 gpio0:1;
u32 gpio1:1;
u32 gpio2:1;
u32 gpio3:1;
u32 gpio4:1;
u32 gpio5:1;
u32 gpio6:1;
u32 gpio7:1;
u32 gpio8:1;
u32 gpio9:1;
u32 gpio10:1;
u32 gpio11:1;
u32 gpio12:1;
u32 gpio13:1;
u32 gpio14:1;
u32 gpio15:1;
u32 gpio16:1;
u32 gpio17:1;
u32 gpio18:1;
u32 gpio19:1;
u32 gpio20:1;
u32 gpio21:1;
u32 gpio22:1;
u32 gpio23:1;
u32 gpio24:1;
u32 gpio25:1;
u32 gpio26:1;
u32 gpio27:1;
u32 gpio28:1;
u32 gpio29:1;
u32 gpio30:1;
u32 gpio31:1;
} __packed;
struct pch_gpio_set2 {
u32 gpio32:1;
u32 gpio33:1;
u32 gpio34:1;
u32 gpio35:1;
u32 gpio36:1;
u32 gpio37:1;
u32 gpio38:1;
u32 gpio39:1;
u32 gpio40:1;
u32 gpio41:1;
u32 gpio42:1;
u32 gpio43:1;
u32 gpio44:1;
u32 gpio45:1;
u32 gpio46:1;
u32 gpio47:1;
u32 gpio48:1;
u32 gpio49:1;
u32 gpio50:1;
u32 gpio51:1;
u32 gpio52:1;
u32 gpio53:1;
u32 gpio54:1;
u32 gpio55:1;
u32 gpio56:1;
u32 gpio57:1;
u32 gpio58:1;
u32 gpio59:1;
u32 gpio60:1;
u32 gpio61:1;
u32 gpio62:1;
u32 gpio63:1;
} __packed;
struct pch_gpio_set3 {
u32 gpio64:1;
u32 gpio65:1;
u32 gpio66:1;
u32 gpio67:1;
u32 gpio68:1;
u32 gpio69:1;
u32 gpio70:1;
u32 gpio71:1;
u32 gpio72:1;
u32 gpio73:1;
u32 gpio74:1;
u32 gpio75:1;
} __packed;
/*
* This hilariously complex structure came from Coreboot. The
* setup_pch_gpios() function uses it. It could be move to device tree, or
* adjust to use masks instead of bitfields.
*/
struct pch_gpio_map {
struct {
const struct pch_gpio_set1 *mode;
const struct pch_gpio_set1 *direction;
const struct pch_gpio_set1 *level;
const struct pch_gpio_set1 *reset;
const struct pch_gpio_set1 *invert;
const struct pch_gpio_set1 *blink;
} set1;
struct {
const struct pch_gpio_set2 *mode;
const struct pch_gpio_set2 *direction;
const struct pch_gpio_set2 *level;
const struct pch_gpio_set2 *reset;
} set2;
struct {
const struct pch_gpio_set3 *mode;
const struct pch_gpio_set3 *direction;
const struct pch_gpio_set3 *level;
const struct pch_gpio_set3 *reset;
} set3;
};
void ich_gpio_set_gpio_map(const struct pch_gpio_map *map);
#endif /* _X86_GPIO_H_ */

3
arch/x86/include/asm/i8254.h
View File

@ -36,4 +36,7 @@
#define PIT_CMD_MODE4 0x08 /* Select mode 4 */
#define PIT_CMD_MODE5 0x0A /* Select mode 5 */
/* The clock frequency of the i8253/i8254 PIT */
#define PIT_TICK_RATE 1193182ul
#endif

2
arch/x86/include/asm/init_helpers.h
View File

@ -13,7 +13,5 @@ int calculate_relocation_address(void);
int init_cache_f_r(void);
int init_bd_struct_r(void);
int init_func_spi(void);
int find_fdt(void);
int prepare_fdt(void);
#endif /* !_INIT_HELPERS_H_ */

49
arch/x86/include/asm/io.h
View File

@ -69,6 +69,55 @@
#define memcpy_fromio(a,b,c) memcpy((a),(b),(c))
#define memcpy_toio(a,b,c) memcpy((a),(b),(c))
#define write_arch(type, endian, a, v) __raw_write##type(cpu_to_##endian(v), a)
#define read_arch(type, endian, a) endian##_to_cpu(__raw_read##type(a))
#define write_le64(a, v) write_arch(q, le64, a, v)
#define write_le32(a, v) write_arch(l, le32, a, v)
#define write_le16(a, v) write_arch(w, le16, a, v)
#define read_le64(a) read_arch(q, le64, a)
#define read_le32(a) read_arch(l, le32, a)
#define read_le16(a) read_arch(w, le16, a)
#define write_be32(a, v) write_arch(l, be32, a, v)
#define write_be16(a, v) write_arch(w, be16, a, v)
#define read_be32(a) read_arch(l, be32, a)
#define read_be16(a) read_arch(w, be16, a)
#define write_8(a, v) __raw_writeb(v, a)
#define read_8(a) __raw_readb(a)
#define clrbits(type, addr, clear) \
write_##type((addr), read_##type(addr) & ~(clear))
#define setbits(type, addr, set) \
write_##type((addr), read_##type(addr) | (set))
#define clrsetbits(type, addr, clear, set) \
write_##type((addr), (read_##type(addr) & ~(clear)) | (set))
#define clrbits_be32(addr, clear) clrbits(be32, addr, clear)
#define setbits_be32(addr, set) setbits(be32, addr, set)
#define clrsetbits_be32(addr, clear, set) clrsetbits(be32, addr, clear, set)
#define clrbits_le32(addr, clear) clrbits(le32, addr, clear)
#define setbits_le32(addr, set) setbits(le32, addr, set)
#define clrsetbits_le32(addr, clear, set) clrsetbits(le32, addr, clear, set)
#define clrbits_be16(addr, clear) clrbits(be16, addr, clear)
#define setbits_be16(addr, set) setbits(be16, addr, set)
#define clrsetbits_be16(addr, clear, set) clrsetbits(be16, addr, clear, set)
#define clrbits_le16(addr, clear) clrbits(le16, addr, clear)
#define setbits_le16(addr, set) setbits(le16, addr, set)
#define clrsetbits_le16(addr, clear, set) clrsetbits(le16, addr, clear, set)
#define clrbits_8(addr, clear) clrbits(8, addr, clear)
#define setbits_8(addr, set) setbits(8, addr, set)
#define clrsetbits_8(addr, clear, set) clrsetbits(8, addr, clear, set)
/*
* ISA space is 'always mapped' on a typical x86 system, no need to
* explicitly ioremap() it. The fact that the ISA IO space is mapped

59
arch/x86/include/asm/lapic.h Normal file
View File

@ -0,0 +1,59 @@
/*
* From Coreboot file of same name
*
* Copyright (C) 2014 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ARCH_ASM_LAPIC_H
#define _ARCH_ASM_LAPIC_H
#include <asm/io.h>
#include <asm/lapic_def.h>
#include <asm/msr.h>
#include <asm/processor.h>
static inline __attribute__((always_inline))
unsigned long lapic_read(unsigned long reg)
{
return readl(LAPIC_DEFAULT_BASE + reg);
}
static inline __attribute__((always_inline))
void lapic_write(unsigned long reg, unsigned long val)
{
writel(val, LAPIC_DEFAULT_BASE + reg);
}
static inline __attribute__((always_inline)) void lapic_wait_icr_idle(void)
{
do { } while (lapic_read(LAPIC_ICR) & LAPIC_ICR_BUSY);
}
static inline void enable_lapic(void)
{
msr_t msr;
msr = msr_read(LAPIC_BASE_MSR);
msr.hi &= 0xffffff00;
msr.lo &= 0x000007ff;
msr.lo |= LAPIC_DEFAULT_BASE | (1 << 11);
msr_write(LAPIC_BASE_MSR, msr);
}
static inline void disable_lapic(void)
{
msr_t msr;
msr = msr_read(LAPIC_BASE_MSR);
msr.lo &= ~(1 << 11);
msr_write(LAPIC_BASE_MSR, msr);
}
static inline __attribute__((always_inline)) unsigned long lapicid(void)
{
return lapic_read(LAPIC_ID) >> 24;
}
#endif

101
arch/x86/include/asm/lapic_def.h Normal file
View File

@ -0,0 +1,101 @@
/*
* Taken from the Coreboot file of the same name
*
* (C) Copyright 2014 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0
*/
#ifndef _ASM_LAPIC_DEF_H
#define _ASM_LAPIC_DEF_H
#define LAPIC_BASE_MSR 0x1B
#define LAPIC_BASE_MSR_BOOTSTRAP_PROCESSOR (1 << 8)
#define LAPIC_BASE_MSR_ENABLE (1 << 11)
#define LAPIC_BASE_MSR_ADDR_MASK 0xFFFFF000
#define LOCAL_APIC_ADDR 0xfee00000
#define LAPIC_DEFAULT_BASE LOCAL_APIC_ADDR
#define LAPIC_ID 0x020
#define LAPIC_LVR 0x030
#define LAPIC_TASKPRI 0x80
#define LAPIC_TPRI_MASK 0xFF
#define LAPIC_ARBID 0x090
#define LAPIC_RRR 0x0C0
#define LAPIC_SVR 0x0f0
#define LAPIC_SPIV 0x0f0
#define LAPIC_SPIV_ENABLE 0x100
#define LAPIC_ESR 0x280
#define LAPIC_ESR_SEND_CS 0x00001
#define LAPIC_ESR_RECV_CS 0x00002
#define LAPIC_ESR_SEND_ACC 0x00004
#define LAPIC_ESR_RECV_ACC 0x00008
#define LAPIC_ESR_SENDILL 0x00020
#define LAPIC_ESR_RECVILL 0x00040
#define LAPIC_ESR_ILLREGA 0x00080
#define LAPIC_ICR 0x300
#define LAPIC_DEST_SELF 0x40000
#define LAPIC_DEST_ALLINC 0x80000
#define LAPIC_DEST_ALLBUT 0xC0000
#define LAPIC_ICR_RR_MASK 0x30000
#define LAPIC_ICR_RR_INVALID 0x00000
#define LAPIC_ICR_RR_INPROG 0x10000
#define LAPIC_ICR_RR_VALID 0x20000
#define LAPIC_INT_LEVELTRIG 0x08000
#define LAPIC_INT_ASSERT 0x04000
#define LAPIC_ICR_BUSY 0x01000
#define LAPIC_DEST_LOGICAL 0x00800
#define LAPIC_DM_FIXED 0x00000
#define LAPIC_DM_LOWEST 0x00100
#define LAPIC_DM_SMI 0x00200
#define LAPIC_DM_REMRD 0x00300
#define LAPIC_DM_NMI 0x00400
#define LAPIC_DM_INIT 0x00500
#define LAPIC_DM_STARTUP 0x00600
#define LAPIC_DM_EXTINT 0x00700
#define LAPIC_VECTOR_MASK 0x000FF
#define LAPIC_ICR2 0x310
#define GET_LAPIC_DEST_FIELD(x) (((x) >> 24) & 0xFF)
#define SET_LAPIC_DEST_FIELD(x) ((x) << 24)
#define LAPIC_LVTT 0x320
#define LAPIC_LVTPC 0x340
#define LAPIC_LVT0 0x350
#define LAPIC_LVT_TIMER_BASE_MASK (0x3 << 18)
#define GET_LAPIC_TIMER_BASE(x) (((x) >> 18) & 0x3)
#define SET_LAPIC_TIMER_BASE(x) (((x) << 18))
#define LAPIC_TIMER_BASE_CLKIN 0x0
#define LAPIC_TIMER_BASE_TMBASE 0x1
#define LAPIC_TIMER_BASE_DIV 0x2
#define LAPIC_LVT_TIMER_PERIODIC (1 << 17)
#define LAPIC_LVT_MASKED (1 << 16)
#define LAPIC_LVT_LEVEL_TRIGGER (1 << 15)
#define LAPIC_LVT_REMOTE_IRR (1 << 14)
#define LAPIC_INPUT_POLARITY (1 << 13)
#define LAPIC_SEND_PENDING (1 << 12)
#define LAPIC_LVT_RESERVED_1 (1 << 11)
#define LAPIC_DELIVERY_MODE_MASK (7 << 8)
#define LAPIC_DELIVERY_MODE_FIXED (0 << 8)
#define LAPIC_DELIVERY_MODE_NMI (4 << 8)
#define LAPIC_DELIVERY_MODE_EXTINT (7 << 8)
#define GET_LAPIC_DELIVERY_MODE(x) (((x) >> 8) & 0x7)
#define SET_LAPIC_DELIVERY_MODE(x, y) (((x) & ~0x700)|((y) << 8))
#define LAPIC_MODE_FIXED 0x0
#define LAPIC_MODE_NMI 0x4
#define LAPIC_MODE_EXINT 0x7
#define LAPIC_LVT1 0x360
#define LAPIC_LVTERR 0x370
#define LAPIC_TMICT 0x380
#define LAPIC_TMCCT 0x390
#define LAPIC_TDCR 0x3E0
#define LAPIC_TDR_DIV_TMBASE (1 << 2)
#define LAPIC_TDR_DIV_1 0xB
#define LAPIC_TDR_DIV_2 0x0
#define LAPIC_TDR_DIV_4 0x1
#define LAPIC_TDR_DIV_8 0x2
#define LAPIC_TDR_DIV_16 0x3
#define LAPIC_TDR_DIV_32 0x8
#define LAPIC_TDR_DIV_64 0x9
#define LAPIC_TDR_DIV_128 0xA
#endif

19
arch/x86/include/asm/msr.h
View File

@ -175,6 +175,25 @@ static inline int wrmsr_safe_regs(u32 regs[8])
return native_wrmsr_safe_regs(regs);
}
typedef struct msr_t {
uint32_t lo;
uint32_t hi;
} msr_t;
static inline struct msr_t msr_read(unsigned msr_num)
{
struct msr_t msr;
rdmsr(msr_num, msr.lo, msr.hi);
return msr;
}
static inline void msr_write(unsigned msr_num, msr_t msr)
{
wrmsr(msr_num, msr.lo, msr.hi);
}
#define rdtscl(low) \
((low) = (u32)__native_read_tsc())

121
arch/x86/include/asm/mtrr.h Normal file
View File

@ -0,0 +1,121 @@
/*
* Copyright (c) 2014 Google, Inc
*
* From Coreboot file of the same name
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _ASM_MTRR_H
#define _ASM_MTRR_H
/* These are the region types */
#define MTRR_TYPE_UNCACHEABLE 0
#define MTRR_TYPE_WRCOMB 1
/*#define MTRR_TYPE_ 2*/
/*#define MTRR_TYPE_ 3*/
#define MTRR_TYPE_WRTHROUGH 4
#define MTRR_TYPE_WRPROT 5
#define MTRR_TYPE_WRBACK 6
#define MTRR_NUM_TYPES 7
#define MTRRcap_MSR 0x0fe
#define MTRRdefType_MSR 0x2ff
#define MTRRdefTypeEn (1 << 11)
#define MTRRdefTypeFixEn (1 << 10)
#define SMRRphysBase_MSR 0x1f2
#define SMRRphysMask_MSR 0x1f3
#define MTRRphysBase_MSR(reg) (0x200 + 2 * (reg))
#define MTRRphysMask_MSR(reg) (0x200 + 2 * (reg) + 1)
#define MTRRphysMaskValid (1 << 11)
#define NUM_FIXED_RANGES 88
#define RANGES_PER_FIXED_MTRR 8
#define MTRRfix64K_00000_MSR 0x250
#define MTRRfix16K_80000_MSR 0x258
#define MTRRfix16K_A0000_MSR 0x259
#define MTRRfix4K_C0000_MSR 0x268
#define MTRRfix4K_C8000_MSR 0x269
#define MTRRfix4K_D0000_MSR 0x26a
#define MTRRfix4K_D8000_MSR 0x26b
#define MTRRfix4K_E0000_MSR 0x26c
#define MTRRfix4K_E8000_MSR 0x26d
#define MTRRfix4K_F0000_MSR 0x26e
#define MTRRfix4K_F8000_MSR 0x26f
#if !defined(__ASSEMBLER__)
/*
* The MTRR code has some side effects that the callers should be aware for.
* 1. The call sequence matters. x86_setup_mtrrs() calls
* x86_setup_fixed_mtrrs_no_enable() then enable_fixed_mtrrs() (equivalent
* of x86_setup_fixed_mtrrs()) then x86_setup_var_mtrrs(). If the callers
* want to call the components of x86_setup_mtrrs() because of other
* rquirements the ordering should still preserved.
* 2. enable_fixed_mtrr() will enable both variable and fixed MTRRs because
* of the nature of the global MTRR enable flag. Therefore, all direct
* or indirect callers of enable_fixed_mtrr() should ensure that the
* variable MTRR MSRs do not contain bad ranges.
* 3. If CONFIG_CACHE_ROM is selected an MTRR is allocated for enabling
* the caching of the ROM. However, it is set to uncacheable (UC). It
* is the responsiblity of the caller to enable it by calling
* x86_mtrr_enable_rom_caching().
*/
void x86_setup_mtrrs(void);
/*
* x86_setup_var_mtrrs() parameters:
* address_bits - number of physical address bits supported by cpu
* above4gb - 2 means dynamically detect number of variable MTRRs available.
* non-zero means handle memory ranges above 4GiB.
* 0 means ignore memory ranges above 4GiB
*/
void x86_setup_var_mtrrs(unsigned int address_bits, unsigned int above4gb);
void enable_fixed_mtrr(void);
void x86_setup_fixed_mtrrs(void);
/* Set up fixed MTRRs but do not enable them. */
void x86_setup_fixed_mtrrs_no_enable(void);
int x86_mtrr_check(void);
/* ROM caching can be used after variable MTRRs are set up. Beware that
* enabling CONFIG_CACHE_ROM will eat through quite a few MTRRs based on
* one's IO hole size and WRCOMB resources. Be sure to check the console
* log when enabling CONFIG_CACHE_ROM or adding WRCOMB resources. Beware that
* on CPUs with core-scoped MTRR registers such as hyperthreaded CPUs the
* rom caching will be disabled if all threads run the MTRR code. Therefore,
* one needs to call x86_mtrr_enable_rom_caching() after all threads of the
* same core have run the MTRR code. */
#if CONFIG_CACHE_ROM
void x86_mtrr_enable_rom_caching(void);
void x86_mtrr_disable_rom_caching(void);
/* Return the variable range MTRR index of the ROM cache. */
long x86_mtrr_rom_cache_var_index(void);
#else
static inline void x86_mtrr_enable_rom_caching(void) {}
static inline void x86_mtrr_disable_rom_caching(void) {}
static inline long x86_mtrr_rom_cache_var_index(void) { return -1; }
#endif /* CONFIG_CACHE_ROM */
#endif
#if !defined(CONFIG_RAMTOP)
# error "CONFIG_RAMTOP not defined"
#endif
#if ((CONFIG_XIP_ROM_SIZE & (CONFIG_XIP_ROM_SIZE - 1)) != 0)
# error "CONFIG_XIP_ROM_SIZE is not a power of 2"
#endif
#if ((CONFIG_CACHE_ROM_SIZE & (CONFIG_CACHE_ROM_SIZE - 1)) != 0)
# error "CONFIG_CACHE_ROM_SIZE is not a power of 2"
#endif
#define CACHE_ROM_BASE (((1 << 20) - (CONFIG_CACHE_ROM_SIZE >> 12)) << 12)
#if (CONFIG_RAMTOP & (CONFIG_RAMTOP - 1)) != 0
# error "CONFIG_RAMTOP must be a power of 2"
#endif
#endif

33
arch/x86/include/asm/pci.h
View File

@ -12,5 +12,38 @@
#define DEFINE_PCI_DEVICE_TABLE(_table) \
const struct pci_device_id _table[]
struct pci_controller;
void pci_setup_type1(struct pci_controller *hose);
/**
* board_pci_setup_hose() - Set up the PCI hose
*
* This is called by the common x86 PCI code to set up the PCI controller
* hose. It may be called when no memory/BSS is available so should just
* store things in 'hose' and not in BSS variables.
*/
void board_pci_setup_hose(struct pci_controller *hose);
/**
* pci_early_init_hose() - Set up PCI host before relocation
*
* This allocates memory for, sets up and returns the PCI hose. It can be
* called before relocation. The hose will be stored in gd->arch.hose for
* later use, but will become invalid one DRAM is available.
*/
int pci_early_init_hose(struct pci_controller **hosep);
/*
* Simple PCI access routines - these work from either the early PCI hose
* or the 'real' one, created after U-Boot has memory available
*/
unsigned int pci_read_config8(pci_dev_t dev, unsigned where);
unsigned int pci_read_config16(pci_dev_t dev, unsigned where);
unsigned int pci_read_config32(pci_dev_t dev, unsigned where);
void pci_write_config8(pci_dev_t dev, unsigned where, unsigned value);
void pci_write_config16(pci_dev_t dev, unsigned where, unsigned value);
void pci_write_config32(pci_dev_t dev, unsigned where, unsigned value);
#endif

50
arch/x86/include/asm/post.h Normal file
View File

@ -0,0 +1,50 @@
/*
* Copyright (c) 2014 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
#ifndef _post_h
#define _post_h
/* port to use for post codes */
#define POST_PORT 0x80
/* post codes which represent various stages of init */
#define POST_START 0x1e
#define POST_CAR_START 0x1f
#define POST_CAR_SIPI 0x20
#define POST_CAR_MTRR 0x21
#define POST_CAR_UNCACHEABLE 0x22
#define POST_CAR_BASE_ADDRESS 0x23
#define POST_CAR_MASK 0x24
#define POST_CAR_FILL 0x25
#define POST_CAR_ROM_CACHE 0x26
#define POST_CAR_MRC_CACHE 0x27
#define POST_CAR_CPU_CACHE 0x28
#define POST_START_STACK 0x29
#define POST_START_DONE 0x2a
#define POST_CPU_INIT 0x2b
#define POST_EARLY_INIT 0x2c
#define POST_CPU_INFO 0x2d
#define POST_PRE_MRC 0x2e
#define POST_MRC 0x2f
#define POST_DRAM 0x2f
#define POST_RAM_FAILURE 0xea
/* Output a post code using al - value must be 0 to 0xff */
#ifdef __ASSEMBLY__
#define post_code(value) \
movb $value, %al; \
outb %al, $POST_PORT
#else
#include <asm/io.h>
static inline void post_code(int code)
{
outb(code, POST_PORT);
}
#endif
#endif

21
arch/x86/include/asm/processor.h
View File

@ -30,4 +30,25 @@ enum {
#define X86_GDT_SIZE (X86_GDT_NUM_ENTRIES * X86_GDT_ENTRY_SIZE)
#ifndef __ASSEMBLY__
#define PORT_RESET 0xcf9
static inline __attribute__((always_inline)) void cpu_hlt(void)
{
asm("hlt");
}
static inline ulong cpu_get_sp(void)
{
ulong result;
asm volatile(
"mov %%esp, %%eax"
: "=a" (result));
return result;
}
#endif /* __ASSEMBLY__ */
#endif

17
arch/x86/include/asm/u-boot-x86.h
View File

@ -9,6 +9,7 @@
#define _U_BOOT_I386_H_ 1
/* cpu/.../cpu.c */
int arch_cpu_init(void);
int x86_cpu_init_r(void);
int cpu_init_r(void);
int x86_cpu_init_f(void);
@ -27,8 +28,8 @@ unsigned long get_tbclk_mhz(void);
void timer_set_base(uint64_t base);
int pcat_timer_init(void);
/* Architecture specific - can be in arch/x86/cpu/, arch/x86/lib/, or $(BOARD)/ */
int dram_init_f(void);
/* Architecture specific DRAM init */
int dram_init(void);
/* cpu/.../interrupts.c */
int cpu_init_interrupts(void);
@ -36,6 +37,16 @@ int cpu_init_interrupts(void);
/* board/.../... */
int dram_init(void);
int cleanup_before_linux(void);
int x86_cleanup_before_linux(void);
void x86_enable_caches(void);
void x86_disable_caches(void);
int x86_init_cache(void);
void reset_cpu(ulong addr);
ulong board_get_usable_ram_top(ulong total_size);
void dram_init_banksize(void);
int default_print_cpuinfo(void);
void setup_pcat_compatibility(void);
void isa_unmap_rom(u32 addr);
@ -59,4 +70,6 @@ static inline __attribute__((no_instrument_function)) uint64_t rdtsc(void)
void timer_set_tsc_base(uint64_t new_base);
uint64_t timer_get_tsc(void);
void quick_ram_check(void);
#endif /* _U_BOOT_I386_H_ */

1
arch/x86/lib/Makefile
View File

@ -15,6 +15,7 @@ obj-$(CONFIG_SYS_PCAT_TIMER) += pcat_timer.o
obj-$(CONFIG_PCI) += pci_type1.o
obj-y += relocate.o
obj-y += physmem.o
obj-$(CONFIG_X86_RAMTEST) += ramtest.o
obj-y += string.o
obj-$(CONFIG_SYS_X86_TSC_TIMER) += tsc_timer.o
obj-$(CONFIG_VIDEO_VGA) += video.o

27
arch/x86/lib/init_helpers.c
View File

@ -87,30 +87,3 @@ int init_func_spi(void)
puts("ready\n");
return 0;
}
int find_fdt(void)
{
#ifdef CONFIG_OF_EMBED
/* Get a pointer to the FDT */
gd->fdt_blob = __dtb_dt_begin;
#elif defined CONFIG_OF_SEPARATE
/* FDT is at end of image */
gd->fdt_blob = (ulong *)&_end;
#endif
/* Allow the early environment to override the fdt address */
gd->fdt_blob = (void *)getenv_ulong("fdtcontroladdr", 16,
(uintptr_t)gd->fdt_blob);
return 0;
}
int prepare_fdt(void)
{
/* For now, put this check after the console is ready */
if (fdtdec_prepare_fdt()) {
panic("** CONFIG_OF_CONTROL defined but no FDT - please see "
"doc/README.fdt-control");
}
return 0;
}

79
arch/x86/lib/ramtest.c Normal file
View File

@ -0,0 +1,79 @@
/*
* Copyright (c) 2014 Google, Inc
*
* From Coreboot src/lib/ramtest.c
*
* SPDX-License-Identifier: GPL-2.0
*/
#include <common.h>
#include <asm/io.h>
#include <asm/post.h>
static void write_phys(unsigned long addr, u32 value)
{
#if CONFIG_SSE2
asm volatile(
"movnti %1, (%0)"
: /* outputs */
: "r" (addr), "r" (value) /* inputs */
: /* clobbers */
);
#else
writel(value, addr);
#endif
}
static u32 read_phys(unsigned long addr)
{
return readl(addr);
}
static void phys_memory_barrier(void)
{
#if CONFIG_SSE2
/* Needed for movnti */
asm volatile(
"sfence"
:
:
: "memory"
);
#else
asm volatile(""
:
:
: "memory");
#endif
}
void quick_ram_check(void)
{
int fail = 0;
u32 backup;
backup = read_phys(CONFIG_RAMBASE);
write_phys(CONFIG_RAMBASE, 0x55555555);
phys_memory_barrier();
if (read_phys(CONFIG_RAMBASE) != 0x55555555)
fail = 1;
write_phys(CONFIG_RAMBASE, 0xaaaaaaaa);
phys_memory_barrier();
if (read_phys(CONFIG_RAMBASE) != 0xaaaaaaaa)
fail = 1;
write_phys(CONFIG_RAMBASE, 0x00000000);
phys_memory_barrier();
if (read_phys(CONFIG_RAMBASE) != 0x00000000)
fail = 1;
write_phys(CONFIG_RAMBASE, 0xffffffff);
phys_memory_barrier();
if (read_phys(CONFIG_RAMBASE) != 0xffffffff)
fail = 1;
write_phys(CONFIG_RAMBASE, backup);
if (fail) {
post_code(POST_RAM_FAILURE);
panic("RAM INIT FAILURE!\n");
}
phys_memory_barrier();
}

285
arch/x86/lib/tsc_timer.c
View File

@ -1,6 +1,9 @@
/*
* Copyright (c) 2012 The Chromium OS Authors.
*
* TSC calibration codes are adapted from Linux kernel
* arch/x86/kernel/tsc_msr.c and arch/x86/kernel/tsc.c
*
* SPDX-License-Identifier: GPL-2.0+
*/
@ -12,8 +15,269 @@
#include <asm/msr.h>
#include <asm/u-boot-x86.h>
/* CPU reference clock frequency: in KHz */
#define FREQ_83 83200
#define FREQ_100 99840
#define FREQ_133 133200
#define FREQ_166 166400
#define MAX_NUM_FREQS 8
DECLARE_GLOBAL_DATA_PTR;
/*
* According to Intel 64 and IA-32 System Programming Guide,
* if MSR_PERF_STAT[31] is set, the maximum resolved bus ratio can be
* read in MSR_PLATFORM_ID[12:8], otherwise in MSR_PERF_STAT[44:40].
* Unfortunately some Intel Atom SoCs aren't quite compliant to this,
* so we need manually differentiate SoC families. This is what the
* field msr_plat does.
*/
struct freq_desc {
u8 x86_family; /* CPU family */
u8 x86_model; /* model */
/* 2: use 100MHz, 1: use MSR_PLATFORM_INFO, 0: MSR_IA32_PERF_STATUS */
u8 msr_plat;
u32 freqs[MAX_NUM_FREQS];
};
static struct freq_desc freq_desc_tables[] = {
/* PNW */
{ 6, 0x27, 0, { 0, 0, 0, 0, 0, FREQ_100, 0, FREQ_83 } },
/* CLV+ */
{ 6, 0x35, 0, { 0, FREQ_133, 0, 0, 0, FREQ_100, 0, FREQ_83 } },
/* TNG */
{ 6, 0x4a, 1, { 0, FREQ_100, FREQ_133, 0, 0, 0, 0, 0 } },
/* VLV2 */
{ 6, 0x37, 1, { FREQ_83, FREQ_100, FREQ_133, FREQ_166, 0, 0, 0, 0 } },
/* Ivybridge */
{ 6, 0x3a, 2, { 0, 0, 0, 0, 0, 0, 0, 0 } },
/* ANN */
{ 6, 0x5a, 1, { FREQ_83, FREQ_100, FREQ_133, FREQ_100, 0, 0, 0, 0 } },
};
static int match_cpu(u8 family, u8 model)
{
int i;
for (i = 0; i < ARRAY_SIZE(freq_desc_tables); i++) {
if ((family == freq_desc_tables[i].x86_family) &&
(model == freq_desc_tables[i].x86_model))
return i;
}
return -1;
}
/* Map CPU reference clock freq ID(0-7) to CPU reference clock freq(KHz) */
#define id_to_freq(cpu_index, freq_id) \
(freq_desc_tables[cpu_index].freqs[freq_id])
/*
* Do MSR calibration only for known/supported CPUs.
*
* Returns the calibration value or 0 if MSR calibration failed.
*/
static unsigned long try_msr_calibrate_tsc(void)
{
u32 lo, hi, ratio, freq_id, freq;
unsigned long res;
int cpu_index;
cpu_index = match_cpu(gd->arch.x86, gd->arch.x86_model);
if (cpu_index < 0)
return 0;
if (freq_desc_tables[cpu_index].msr_plat) {
rdmsr(MSR_PLATFORM_INFO, lo, hi);
ratio = (lo >> 8) & 0x1f;
} else {
rdmsr(MSR_IA32_PERF_STATUS, lo, hi);
ratio = (hi >> 8) & 0x1f;
}
debug("Maximum core-clock to bus-clock ratio: 0x%x\n", ratio);
if (!ratio)
goto fail;
if (freq_desc_tables[cpu_index].msr_plat == 2) {
/* TODO: Figure out how best to deal with this */
freq = FREQ_100;
debug("Using frequency: %u KHz\n", freq);
} else {
/* Get FSB FREQ ID */
rdmsr(MSR_FSB_FREQ, lo, hi);
freq_id = lo & 0x7;
freq = id_to_freq(cpu_index, freq_id);
debug("Resolved frequency ID: %u, frequency: %u KHz\n",
freq_id, freq);
}
if (!freq)
goto fail;
/* TSC frequency = maximum resolved freq * maximum resolved bus ratio */
res = freq * ratio / 1000;
debug("TSC runs at %lu MHz\n", res);
return res;
fail:
debug("Fast TSC calibration using MSR failed\n");
return 0;
}
/*
* This reads the current MSB of the PIT counter, and
* checks if we are running on sufficiently fast and
* non-virtualized hardware.
*
* Our expectations are:
*
* - the PIT is running at roughly 1.19MHz
*
* - each IO is going to take about 1us on real hardware,
* but we allow it to be much faster (by a factor of 10) or
* _slightly_ slower (ie we allow up to a 2us read+counter
* update - anything else implies a unacceptably slow CPU
* or PIT for the fast calibration to work.
*
* - with 256 PIT ticks to read the value, we have 214us to
* see the same MSB (and overhead like doing a single TSC
* read per MSB value etc).
*
* - We're doing 2 reads per loop (LSB, MSB), and we expect
* them each to take about a microsecond on real hardware.
* So we expect a count value of around 100. But we'll be
* generous, and accept anything over 50.
*
* - if the PIT is stuck, and we see *many* more reads, we
* return early (and the next caller of pit_expect_msb()
* then consider it a failure when they don't see the
* next expected value).
*
* These expectations mean that we know that we have seen the
* transition from one expected value to another with a fairly
* high accuracy, and we didn't miss any events. We can thus
* use the TSC value at the transitions to calculate a pretty
* good value for the TSC frequencty.
*/
static inline int pit_verify_msb(unsigned char val)
{
/* Ignore LSB */
inb(0x42);
return inb(0x42) == val;
}
static inline int pit_expect_msb(unsigned char val, u64 *tscp,
unsigned long *deltap)
{
int count;
u64 tsc = 0, prev_tsc = 0;
for (count = 0; count < 50000; count++) {
if (!pit_verify_msb(val))
break;
prev_tsc = tsc;
tsc = rdtsc();
}
*deltap = rdtsc() - prev_tsc;
*tscp = tsc;
/*
* We require _some_ success, but the quality control
* will be based on the error terms on the TSC values.
*/
return count > 5;
}
/*
* How many MSB values do we want to see? We aim for
* a maximum error rate of 500ppm (in practice the
* real error is much smaller), but refuse to spend
* more than 50ms on it.
*/
#define MAX_QUICK_PIT_MS 50
#define MAX_QUICK_PIT_ITERATIONS (MAX_QUICK_PIT_MS * PIT_TICK_RATE / 1000 / 256)
static unsigned long quick_pit_calibrate(void)
{
int i;
u64 tsc, delta;
unsigned long d1, d2;
/* Set the Gate high, disable speaker */
outb((inb(0x61) & ~0x02) | 0x01, 0x61);
/*
* Counter 2, mode 0 (one-shot), binary count
*
* NOTE! Mode 2 decrements by two (and then the
* output is flipped each time, giving the same
* final output frequency as a decrement-by-one),
* so mode 0 is much better when looking at the
* individual counts.
*/
outb(0xb0, 0x43);
/* Start at 0xffff */
outb(0xff, 0x42);
outb(0xff, 0x42);
/*
* The PIT starts counting at the next edge, so we
* need to delay for a microsecond. The easiest way
* to do that is to just read back the 16-bit counter
* once from the PIT.
*/
pit_verify_msb(0);
if (pit_expect_msb(0xff, &tsc, &d1)) {
for (i = 1; i <= MAX_QUICK_PIT_ITERATIONS; i++) {
if (!pit_expect_msb(0xff-i, &delta, &d2))
break;
/*
* Iterate until the error is less than 500 ppm
*/
delta -= tsc;
if (d1+d2 >= delta >> 11)
continue;
/*
* Check the PIT one more time to verify that
* all TSC reads were stable wrt the PIT.
*
* This also guarantees serialization of the
* last cycle read ('d2') in pit_expect_msb.
*/
if (!pit_verify_msb(0xfe - i))
break;
goto success;
}
}
debug("Fast TSC calibration failed\n");
return 0;
success:
/*
* Ok, if we get here, then we've seen the
* MSB of the PIT decrement 'i' times, and the
* error has shrunk to less than 500 ppm.
*
* As a result, we can depend on there not being
* any odd delays anywhere, and the TSC reads are
* reliable (within the error).
*
* kHz = ticks / time-in-seconds / 1000;
* kHz = (t2 - t1) / (I * 256 / PIT_TICK_RATE) / 1000
* kHz = ((t2 - t1) * PIT_TICK_RATE) / (I * 256 * 1000)
*/
delta *= PIT_TICK_RATE;
delta /= (i*256*1000);
debug("Fast TSC calibration using PIT\n");
return delta / 1000;
}
void timer_set_base(u64 base)
{
gd->arch.tsc_base = base;
@ -34,17 +298,24 @@ u64 __attribute__((no_instrument_function)) get_ticks(void)
return now_tick - gd->arch.tsc_base;
}
#define PLATFORM_INFO_MSR 0xce
/* Get the speed of the TSC timer in MHz */
unsigned __attribute__((no_instrument_function)) long get_tbclk_mhz(void)
{
u32 ratio;
u64 platform_info = native_read_msr(PLATFORM_INFO_MSR);
unsigned long fast_calibrate;
/* 100MHz times Max Non Turbo ratio */
ratio = (platform_info >> 8) & 0xff;
return 100 * ratio;
if (gd->arch.tsc_mhz)
return gd->arch.tsc_mhz;
fast_calibrate = try_msr_calibrate_tsc();
if (!fast_calibrate) {
fast_calibrate = quick_pit_calibrate();
if (!fast_calibrate)
panic("TSC frequency is ZERO");
}
gd->arch.tsc_mhz = fast_calibrate;
return fast_calibrate;
}
unsigned long get_tbclk(void)

2
board/chromebook-x86/coreboot/Kconfig → board/coreboot/coreboot/Kconfig
View File

@ -4,7 +4,7 @@ config SYS_BOARD
default "coreboot"
config SYS_VENDOR
default "chromebook-x86"
default "coreboot"
config SYS_SOC
default "coreboot"

2
board/chromebook-x86/coreboot/MAINTAINERS → board/coreboot/coreboot/MAINTAINERS
View File

@ -1,6 +1,6 @@
COREBOOT BOARD
M: Simon Glass <sjg@chromium.org>
S: Maintained
F: board/chromebook-x86/coreboot/
F: board/coreboot/coreboot/
F: include/configs/coreboot.h
F: configs/coreboot-x86_defconfig

0
board/chromebook-x86/coreboot/Makefile → board/coreboot/coreboot/Makefile
View File

0
board/chromebook-x86/coreboot/coreboot.c → board/coreboot/coreboot/coreboot.c
View File

0
board/chromebook-x86/coreboot/coreboot_start.S → board/coreboot/coreboot/coreboot_start.S
View File

31
board/google/chromebook_link/Kconfig Normal file
View File

@ -0,0 +1,31 @@
if TARGET_CHROMEBOOK_LINK
config SYS_BOARD
default "chromebook_link"
config SYS_VENDOR
default "google"
config SYS_SOC
default "ivybridge"
config SYS_CONFIG_NAME
default "chromebook_link"
config BOARD_SPECIFIC_OPTIONS # dummy
def_bool y
select CPU_INTEL_SOCKET_RPGA989
select NORTHBRIDGE_INTEL_IVYBRIDGE
select SOUTHBRIDGE_INTEL_C216
select HAVE_ACPI_RESUME
select MARK_GRAPHICS_MEM_WRCOMB
config MMCONF_BASE_ADDRESS
hex
default 0xf0000000
config EARLY_POST_CROS_EC
bool "Enable early post to Chrome OS EC"
default y
endif

6
board/google/chromebook_link/MAINTAINERS Normal file
View File

@ -0,0 +1,6 @@
CHROMEBOOK LINK BOARD
M: Simon Glass <sjg@chromium.org>
S: Maintained
F: board/google/chromebook_link/
F: include/configs/chromebook_link.h
F: configs/chromebook_link_defconfig

15
board/google/chromebook_link/Makefile Normal file
View File

@ -0,0 +1,15 @@
#
# Copyright (c) 2011 The Chromium OS Authors.
# (C) Copyright 2008
# Graeme Russ, graeme.russ@gmail.com.
#
# (C) Copyright 2006
# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
#
# (C) Copyright 2002
# Daniel Engström, Omicron Ceti AB, daniel@omicron.se.
#
# SPDX-License-Identifier: GPL-2.0+
#
obj-y += link.o

124
board/google/chromebook_link/link.c Normal file
View File

@ -0,0 +1,124 @@
/*
* Copyright (C) 2014 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <asm/gpio.h>
int arch_early_init_r(void)
{
return 0;
}
int board_early_init_r(void)
{
return 0;
}
static const struct pch_gpio_set1 pch_gpio_set1_mode = {
.gpio0 = GPIO_MODE_GPIO, /* NMI_DBG# */
.gpio3 = GPIO_MODE_GPIO, /* ALS_INT# */
.gpio5 = GPIO_MODE_GPIO, /* SIM_DET */
.gpio7 = GPIO_MODE_GPIO, /* EC_SCI# */
.gpio8 = GPIO_MODE_GPIO, /* EC_SMI# */
.gpio9 = GPIO_MODE_GPIO, /* RECOVERY# */
.gpio10 = GPIO_MODE_GPIO, /* SPD vector D3 */
.gpio11 = GPIO_MODE_GPIO, /* smbalert#, let's keep it initialized */
.gpio12 = GPIO_MODE_GPIO, /* TP_INT# */
.gpio14 = GPIO_MODE_GPIO, /* Touch_INT_L */
.gpio15 = GPIO_MODE_GPIO, /* EC_LID_OUT# (EC_WAKE#) */
.gpio21 = GPIO_MODE_GPIO, /* EC_IN_RW */
.gpio24 = GPIO_MODE_GPIO, /* DDR3L_EN */
.gpio28 = GPIO_MODE_GPIO, /* SLP_ME_CSW_DEV# */
};
static const struct pch_gpio_set1 pch_gpio_set1_direction = {
.gpio0 = GPIO_DIR_INPUT,
.gpio3 = GPIO_DIR_INPUT,
.gpio5 = GPIO_DIR_INPUT,
.gpio7 = GPIO_DIR_INPUT,
.gpio8 = GPIO_DIR_INPUT,
.gpio9 = GPIO_DIR_INPUT,
.gpio10 = GPIO_DIR_INPUT,
.gpio11 = GPIO_DIR_INPUT,
.gpio12 = GPIO_DIR_INPUT,
.gpio14 = GPIO_DIR_INPUT,
.gpio15 = GPIO_DIR_INPUT,
.gpio21 = GPIO_DIR_INPUT,
.gpio24 = GPIO_DIR_OUTPUT,
.gpio28 = GPIO_DIR_INPUT,
};
static const struct pch_gpio_set1 pch_gpio_set1_level = {
.gpio1 = GPIO_LEVEL_HIGH,
.gpio6 = GPIO_LEVEL_HIGH,
.gpio24 = GPIO_LEVEL_LOW,
};
static const struct pch_gpio_set1 pch_gpio_set1_invert = {
.gpio7 = GPIO_INVERT,
.gpio8 = GPIO_INVERT,
.gpio12 = GPIO_INVERT,
.gpio14 = GPIO_INVERT,
.gpio15 = GPIO_INVERT,
};
static const struct pch_gpio_set2 pch_gpio_set2_mode = {
.gpio36 = GPIO_MODE_GPIO, /* W_DISABLE_L */
.gpio41 = GPIO_MODE_GPIO, /* SPD vector D0 */
.gpio42 = GPIO_MODE_GPIO, /* SPD vector D1 */
.gpio43 = GPIO_MODE_GPIO, /* SPD vector D2 */
.gpio57 = GPIO_MODE_GPIO, /* PCH_SPI_WP_D */
.gpio60 = GPIO_MODE_GPIO, /* DRAMRST_CNTRL_PCH */
};
static const struct pch_gpio_set2 pch_gpio_set2_direction = {
.gpio36 = GPIO_DIR_OUTPUT,
.gpio41 = GPIO_DIR_INPUT,
.gpio42 = GPIO_DIR_INPUT,
.gpio43 = GPIO_DIR_INPUT,
.gpio57 = GPIO_DIR_INPUT,
.gpio60 = GPIO_DIR_OUTPUT,
};
static const struct pch_gpio_set2 pch_gpio_set2_level = {
.gpio36 = GPIO_LEVEL_HIGH,
.gpio60 = GPIO_LEVEL_HIGH,
};
static const struct pch_gpio_set3 pch_gpio_set3_mode = {
};
static const struct pch_gpio_set3 pch_gpio_set3_direction = {
};
static const struct pch_gpio_set3 pch_gpio_set3_level = {
};
static const struct pch_gpio_map link_gpio_map = {
.set1 = {
.mode = &pch_gpio_set1_mode,
.direction = &pch_gpio_set1_direction,
.level = &pch_gpio_set1_level,
.invert = &pch_gpio_set1_invert,
},
.set2 = {
.mode = &pch_gpio_set2_mode,
.direction = &pch_gpio_set2_direction,
.level = &pch_gpio_set2_level,
},
.set3 = {
.mode = &pch_gpio_set3_mode,
.direction = &pch_gpio_set3_direction,
.level = &pch_gpio_set3_level,
},
};
int board_early_init_f(void)
{
ich_gpio_set_gpio_map(&link_gpio_map);
return 0;
}

7
board/google/common/Makefile Normal file
View File

@ -0,0 +1,7 @@
#
# Copyright (c) 2014 Google, Inc
#
# SPDX-License-Identifier: GPL-2.0+
#
obj-y += early_init.o

29
board/google/common/early_init.S Normal file
View File

@ -0,0 +1,29 @@
/*
* Copyright (c) 2014 Google, Inc
*
* SPDX-License-Identifier: GPL-2.0+
*/
.globl early_board_init
early_board_init:
/* Enable post codes to EC */
#ifdef CONFIG_EARLY_POST_CROS_EC
mov $0x1b, %ecx
rdmsr
and $0x100, %eax
test %eax, %eax
je 1f
mov $0x8000f8f0, %eax
mov $0xcf8, %dx
out %eax, (%dx)
mov $0xfed1c001, %eax
mov $0xcfc, %dx
out %eax, (%dx)
mov $0xfed1f410, %esp
mov (%esp), %eax
and $0xfffffffb, %eax
mov %eax, (%esp)
1:
#endif
jmp early_board_init_ret

14
common/board_f.c
View File

@ -820,22 +820,16 @@ static init_fnc_t init_sequence_f[] = {
setup_mon_len,
setup_fdt,
trace_early_init,
initf_malloc,
#if defined(CONFIG_MPC85xx) || defined(CONFIG_MPC86xx)
/* TODO: can this go into arch_cpu_init()? */
probecpu,
#endif
arch_cpu_init, /* basic arch cpu dependent setup */
#ifdef CONFIG_X86
cpu_init_f, /* TODO(sjg@chromium.org): remove */
# ifdef CONFIG_OF_CONTROL
find_fdt, /* TODO(sjg@chromium.org): remove */
# endif
#endif
mark_bootstage,
#ifdef CONFIG_OF_CONTROL
fdtdec_check_fdt,
#endif
initf_malloc,
initf_dm,
#if defined(CONFIG_BOARD_EARLY_INIT_F)
board_early_init_f,
@ -910,14 +904,10 @@ static init_fnc_t init_sequence_f[] = {
#endif
#if defined(CONFIG_HARD_SPI)
init_func_spi,
#endif
#ifdef CONFIG_X86
dram_init_f, /* configure available RAM banks */
calculate_relocation_address,
#endif
announce_dram_init,
/* TODO: unify all these dram functions? */
#ifdef CONFIG_ARM
#if defined(CONFIG_ARM) || defined(CONFIG_X86)
dram_init, /* configure available RAM banks */
#endif
#if defined(CONFIG_MIPS) || defined(CONFIG_PPC)

10
configs/chromebook_link_defconfig Normal file
View File

@ -0,0 +1,10 @@
CONFIG_SYS_EXTRA_OPTIONS="SYS_TEXT_BASE=0xfff00000"
CONFIG_X86=y
CONFIG_TARGET_CHROMEBOOK_LINK=y
CONFIG_OF_CONTROL=y
CONFIG_OF_SEPARATE=y
CONFIG_DEFAULT_DEVICE_TREE="chromebook_link"
CONFIG_HAVE_MRC=y
CONFIG_SMM_TSEG_SIZE=0x800000
CONFIG_FRAMEBUFFER_SET_VESA_MODE=y
CONFIG_FRAMEBUFFER_VESA_MODE_11A=y

23
doc/device-tree-bindings/misc/intel-lpc.txt Normal file
View File

@ -0,0 +1,23 @@
Intel LPC Device Binding
========================
The device tree node which describes the operation of the Intel Low Pin
Count device is as follows:
Required properties :
- compatible = "intel,lpc"
- gen-dec : Specifies the values for the gen-dec registers. Up to four cell
pairs can be provided - the first of each pair is the base address and
the second is the size. These are written into the GENx_DEC registers of
the LPC device
Example
-------
lpc {
compatible = "intel,lpc";
#address-cells = <1>;
#size-cells = <1>;
gen-dec = <0x800 0xfc 0x900 0xfc>;
};

19
drivers/gpio/gpio-uclass.c
View File

@ -390,6 +390,25 @@ int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize)
return 0;
}
/*
* get a number comprised of multiple GPIO values. gpio_num_array points to
* the array of gpio pin numbers to scan, terminated by -1.
*/
unsigned gpio_get_values_as_int(const int *gpio_num_array)
{
int gpio;
unsigned bitmask = 1;
unsigned vector = 0;
while (bitmask &&
((gpio = *gpio_num_array++) != -1)) {
if (gpio_get_value(gpio))
vector |= bitmask;
bitmask <<= 1;
}
return vector;
}
/* We need to renumber the GPIOs when any driver is probed/removed */
static int gpio_renumber(struct udevice *removed_dev)
{

79
drivers/gpio/intel_ich6_gpio.c
View File

@ -33,6 +33,11 @@
#include <pci.h>
#include <asm/gpio.h>
#include <asm/io.h>
#include <asm/pci.h>
#ifdef CONFIG_X86_RESET_VECTOR
#include <asm/arch/pch.h>
#define SUPPORT_GPIO_SETUP
#endif
#define GPIO_PER_BANK 32
@ -46,6 +51,53 @@ struct ich6_bank_priv {
uint32_t lvl;
};
#ifdef SUPPORT_GPIO_SETUP
static void setup_pch_gpios(const struct pch_gpio_map *gpio)
{
u16 gpiobase = pci_read_config16(PCH_LPC_DEV, GPIO_BASE) & 0xfffc;
/* GPIO Set 1 */
if (gpio->set1.level)
outl(*((u32 *)gpio->set1.level), gpiobase + GP_LVL);
if (gpio->set1.mode)
outl(*((u32 *)gpio->set1.mode), gpiobase + GPIO_USE_SEL);
if (gpio->set1.direction)
outl(*((u32 *)gpio->set1.direction), gpiobase + GP_IO_SEL);
if (gpio->set1.reset)
outl(*((u32 *)gpio->set1.reset), gpiobase + GP_RST_SEL1);
if (gpio->set1.invert)
outl(*((u32 *)gpio->set1.invert), gpiobase + GPI_INV);
if (gpio->set1.blink)
outl(*((u32 *)gpio->set1.blink), gpiobase + GPO_BLINK);
/* GPIO Set 2 */
if (gpio->set2.level)
outl(*((u32 *)gpio->set2.level), gpiobase + GP_LVL2);
if (gpio->set2.mode)
outl(*((u32 *)gpio->set2.mode), gpiobase + GPIO_USE_SEL2);
if (gpio->set2.direction)
outl(*((u32 *)gpio->set2.direction), gpiobase + GP_IO_SEL2);
if (gpio->set2.reset)
outl(*((u32 *)gpio->set2.reset), gpiobase + GP_RST_SEL2);
/* GPIO Set 3 */
if (gpio->set3.level)
outl(*((u32 *)gpio->set3.level), gpiobase + GP_LVL3);
if (gpio->set3.mode)
outl(*((u32 *)gpio->set3.mode), gpiobase + GPIO_USE_SEL3);
if (gpio->set3.direction)
outl(*((u32 *)gpio->set3.direction), gpiobase + GP_IO_SEL3);
if (gpio->set3.reset)
outl(*((u32 *)gpio->set3.reset), gpiobase + GP_RST_SEL3);
}
/* TODO: Move this to device tree, or platform data */
void ich_gpio_set_gpio_map(const struct pch_gpio_map *map)
{
gd->arch.gpio_map = map;
}
#endif /* SUPPORT_GPIO_SETUP */
static int gpio_ich6_ofdata_to_platdata(struct udevice *dev)
{
struct ich6_bank_platdata *plat = dev_get_platdata(dev);
@ -60,13 +112,13 @@ static int gpio_ich6_ofdata_to_platdata(struct udevice *dev)
pci_dev = PCI_BDF(0, 0x1f, 0);
/* Is the device present? */
pci_read_config_word(pci_dev, PCI_VENDOR_ID, &tmpword);
tmpword = pci_read_config16(pci_dev, PCI_VENDOR_ID);
if (tmpword != PCI_VENDOR_ID_INTEL) {
debug("%s: wrong VendorID\n", __func__);
return -ENODEV;
}
pci_read_config_word(pci_dev, PCI_DEVICE_ID, &tmpword);
tmpword = pci_read_config16(pci_dev, PCI_DEVICE_ID);
debug("Found %04x:%04x\n", PCI_VENDOR_ID_INTEL, tmpword);
/*
* We'd like to validate the Device ID too, but pretty much any
@ -76,34 +128,34 @@ static int gpio_ich6_ofdata_to_platdata(struct udevice *dev)
*/
/* I/O should already be enabled (it's a RO bit). */
pci_read_config_word(pci_dev, PCI_COMMAND, &tmpword);
tmpword = pci_read_config16(pci_dev, PCI_COMMAND);
if (!(tmpword & PCI_COMMAND_IO)) {
debug("%s: device IO not enabled\n", __func__);
return -ENODEV;
}
/* Header Type must be normal (bits 6-0 only; see spec.) */
pci_read_config_byte(pci_dev, PCI_HEADER_TYPE, &tmpbyte);
tmpbyte = pci_read_config8(pci_dev, PCI_HEADER_TYPE);
if ((tmpbyte & 0x7f) != PCI_HEADER_TYPE_NORMAL) {
debug("%s: invalid Header type\n", __func__);
return -ENODEV;
}
/* Base Class must be a bridge device */
pci_read_config_byte(pci_dev, PCI_CLASS_CODE, &tmpbyte);
tmpbyte = pci_read_config8(pci_dev, PCI_CLASS_CODE);
if (tmpbyte != PCI_CLASS_CODE_BRIDGE) {
debug("%s: invalid class\n", __func__);
return -ENODEV;
}
/* Sub Class must be ISA */
pci_read_config_byte(pci_dev, PCI_CLASS_SUB_CODE, &tmpbyte);
tmpbyte = pci_read_config8(pci_dev, PCI_CLASS_SUB_CODE);
if (tmpbyte != PCI_CLASS_SUB_CODE_BRIDGE_ISA) {
debug("%s: invalid subclass\n", __func__);
return -ENODEV;
}
/* Programming Interface must be 0x00 (no others exist) */
pci_read_config_byte(pci_dev, PCI_CLASS_PROG, &tmpbyte);
tmpbyte = pci_read_config8(pci_dev, PCI_CLASS_PROG);
if (tmpbyte != 0x00) {
debug("%s: invalid interface type\n", __func__);
return -ENODEV;
@ -114,7 +166,7 @@ static int gpio_ich6_ofdata_to_platdata(struct udevice *dev)
* that it was unused (or undocumented). Check that it looks
* okay: not all ones or zeros, and mapped to I/O space (bit 0).
*/
pci_read_config_dword(pci_dev, PCI_CFG_GPIOBASE, &tmplong);
tmplong = pci_read_config32(pci_dev, PCI_CFG_GPIOBASE);
if (tmplong == 0x00000000 || tmplong == 0xffffffff ||
!(tmplong & 0x00000001)) {
debug("%s: unexpected GPIOBASE value\n", __func__);
@ -140,12 +192,18 @@ static int gpio_ich6_ofdata_to_platdata(struct udevice *dev)
return 0;
}
int ich6_gpio_probe(struct udevice *dev)
static int ich6_gpio_probe(struct udevice *dev)
{
struct ich6_bank_platdata *plat = dev_get_platdata(dev);
struct gpio_dev_priv *uc_priv = dev->uclass_priv;
struct ich6_bank_priv *bank = dev_get_priv(dev);
#ifdef SUPPORT_GPIO_SETUP
if (gd->arch.gpio_map) {
setup_pch_gpios(gd->arch.gpio_map);
gd->arch.gpio_map = NULL;
}
#endif
uc_priv->gpio_count = GPIO_PER_BANK;
uc_priv->bank_name = plat->bank_name;
bank->use_sel = plat->base_addr;
@ -155,7 +213,8 @@ int ich6_gpio_probe(struct udevice *dev)
return 0;
}
int ich6_gpio_request(struct udevice *dev, unsigned offset, const char *label)
static int ich6_gpio_request(struct udevice *dev, unsigned offset,
const char *label)
{
struct ich6_bank_priv *bank = dev_get_priv(dev);
u32 tmplong;

35
drivers/serial/serial-uclass.c
View File

@ -19,15 +19,14 @@
DECLARE_GLOBAL_DATA_PTR;
/* The currently-selected console serial device */
struct udevice *cur_dev __attribute__ ((section(".data")));
#ifndef CONFIG_SYS_MALLOC_F_LEN
#error "Serial is required before relocation - define CONFIG_SYS_MALLOC_F_LEN to make this work"
#endif
static void serial_find_console_or_panic(void)
{
struct udevice *dev;
#ifdef CONFIG_OF_CONTROL
int node;
@ -35,18 +34,21 @@ static void serial_find_console_or_panic(void)
node = fdtdec_get_chosen_node(gd->fdt_blob, "stdout-path");
if (node < 0)
node = fdtdec_get_alias_node(gd->fdt_blob, "console");
if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, &cur_dev))
if (!uclass_get_device_by_of_offset(UCLASS_SERIAL, node, &dev)) {
gd->cur_serial_dev = dev;
return;
}
/*
* If the console is not marked to be bound before relocation, bind
* it anyway.
*/
if (node > 0 &&
!lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &cur_dev)) {
if (!device_probe(cur_dev))
!lists_bind_fdt(gd->dm_root, gd->fdt_blob, node, &dev)) {
if (!device_probe(dev)) {
gd->cur_serial_dev = dev;
return;
cur_dev = NULL;
}
}
#endif
/*
@ -61,11 +63,12 @@ static void serial_find_console_or_panic(void)
#else
#define INDEX 0
#endif
if (uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &cur_dev) &&
uclass_get_device(UCLASS_SERIAL, INDEX, &cur_dev) &&
(uclass_first_device(UCLASS_SERIAL, &cur_dev) || !cur_dev))
if (uclass_get_device_by_seq(UCLASS_SERIAL, INDEX, &dev) &&
uclass_get_device(UCLASS_SERIAL, INDEX, &dev) &&
(uclass_first_device(UCLASS_SERIAL, &dev) || !dev))
panic("No serial driver found");
#undef INDEX
gd->cur_serial_dev = dev;
}
/* Called prior to relocation */
@ -127,30 +130,30 @@ static int _serial_tstc(struct udevice *dev)
void serial_putc(char ch)
{
_serial_putc(cur_dev, ch);
_serial_putc(gd->cur_serial_dev, ch);
}
void serial_puts(const char *str)
{
_serial_puts(cur_dev, str);
_serial_puts(gd->cur_serial_dev, str);
}
int serial_getc(void)
{
return _serial_getc(cur_dev);
return _serial_getc(gd->cur_serial_dev);
}
int serial_tstc(void)
{
return _serial_tstc(cur_dev);
return _serial_tstc(gd->cur_serial_dev);
}
void serial_setbrg(void)
{
struct dm_serial_ops *ops = serial_get_ops(cur_dev);
struct dm_serial_ops *ops = serial_get_ops(gd->cur_serial_dev);
if (ops->setbrg)
ops->setbrg(cur_dev, gd->baudrate);
ops->setbrg(gd->cur_serial_dev, gd->baudrate);
}
void serial_stdio_init(void)

1
include/asm-generic/global_data.h
View File

@ -91,6 +91,7 @@ typedef struct global_data {
unsigned long malloc_limit; /* limit address */
unsigned long malloc_ptr; /* current address */
#endif
struct udevice *cur_serial_dev; /* current serial device */
struct arch_global_data arch; /* architecture-specific data */
} gd_t;
#endif

11
include/asm-generic/gpio.h
View File

@ -257,6 +257,15 @@ const char *gpio_get_bank_info(struct udevice *dev, int *offset_count);
int gpio_lookup_name(const char *name, struct udevice **devp,
unsigned int *offsetp, unsigned int *gpiop);
int name_to_gpio(const char *name);
/**
* get_gpios() - Turn the values of a list of GPIOs into an integer
*
* This puts the value of the first GPIO into bit 0, the second into bit 1,
* etc. then returns the resulting integer.
*
* @gpio_list: List of GPIOs to collect
* @return resulting integer value
*/
unsigned gpio_get_values_as_int(const int *gpio_list);
#endif /* _ASM_GENERIC_GPIO_H_ */

74
include/configs/chromebook_link.h Normal file
View File

@ -0,0 +1,74 @@
/*
* Copyright (c) 2011 The Chromium OS Authors.
* (C) Copyright 2008
* Graeme Russ, graeme.russ@gmail.com.
*
* SPDX-License-Identifier: GPL-2.0+
*/
/*
* board/config.h - configuration options, board specific
*/
#ifndef __CONFIG_H
#define __CONFIG_H
#include <configs/x86-common.h>
#define CONFIG_SYS_CAR_ADDR 0xff7e0000
#define CONFIG_SYS_CAR_SIZE (128 * 1024)
#define CONFIG_SYS_MONITOR_LEN (1 << 20)
#define CONFIG_DCACHE_RAM_MRC_VAR_SIZE 0x4000
#define CONFIG_SYS_X86_START16 0xfffff800
#define CONFIG_BOARD_EARLY_INIT_F
#define CONFIG_BOARD_EARLY_INIT_R
#define CONFIG_DISPLAY_CPUINFO
#define CONFIG_X86_RESET_VECTOR
#define CONFIG_NR_DRAM_BANKS 8
#define CONFIG_X86_MRC_START 0xfffa0000
#define CONFIG_CACHE_MRC_SIZE_KB 512
#define CONFIG_COREBOOT_SERIAL
#define CONFIG_SCSI_DEV_LIST {PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_NM10_AHCI}, \
{PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_COUGARPOINT_AHCI_MOBILE}, \
{PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_COUGARPOINT_AHCI_SERIES6}, \
{PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_PANTHERPOINT_AHCI_MOBILE}
/*
* These common x86 features are not yet supported, but are added in
* follow-on patches in this series. Add undefs here to avoid every patch
* having to put things back into x86-common.h
*/
#undef CONFIG_VIDEO
#undef CONFIG_CFB_CONSOLE
#undef CONFIG_ICH_SPI
#undef CONFIG_SPI
#undef CONFIG_CMD_SPI
#undef CONFIG_CMD_SF
#undef CONFIG_USB_EHCI
#undef CONFIG_CMD_USB
#undef CONFIG_CMD_SCSI
#define CONFIG_PCI_MEM_BUS 0xe0000000
#define CONFIG_PCI_MEM_PHYS CONFIG_PCI_MEM_BUS
#define CONFIG_PCI_MEM_SIZE 0x10000000
#define CONFIG_PCI_PREF_BUS 0xd0000000
#define CONFIG_PCI_PREF_PHYS CONFIG_PCI_PREF_BUS
#define CONFIG_PCI_PREF_SIZE 0x10000000
#define CONFIG_PCI_IO_BUS 0x1000
#define CONFIG_PCI_IO_PHYS CONFIG_PCI_IO_BUS
#define CONFIG_PCI_IO_SIZE 0xefff
#define CONFIG_STD_DEVICES_SETTINGS "stdin=usbkbd,vga,serial\0" \
"stdout=vga,serial\0" \
"stderr=vga,serial\0"
#endif /* __CONFIG_H */

265
include/configs/coreboot.h
View File

@ -6,7 +6,6 @@
* SPDX-License-Identifier: GPL-2.0+
*/
#include <asm/ibmpc.h>
/*
* board/config.h - configuration options, board specific
*/
@ -14,27 +13,23 @@
#ifndef __CONFIG_H
#define __CONFIG_H
#include <configs/x86-common.h>
/*
* High Level Configuration Options
* (easy to change)
*/
#define CONFIG_SYS_COREBOOT
#define CONFIG_SHOW_BOOT_PROGRESS
#define CONFIG_LAST_STAGE_INIT
#define CONFIG_SYS_VSNPRINTF
#define CONFIG_ZBOOT_32
#define CONFIG_PHYSMEM
#define CONFIG_SYS_EARLY_PCI_INIT
#define CONFIG_DISPLAY_BOARDINFO_LATE
#define CONFIG_DISPLAY_CPUINFO
#define CONFIG_DM
#define CONFIG_CMD_DM
#define CONFIG_DM_GPIO
#define CONFIG_DM_SERIAL
#define CONFIG_SYS_CAR_ADDR 0x19200000
#define CONFIG_SYS_CAR_SIZE (16 * 1024)
#define CONFIG_SYS_MONITOR_LEN (256 * 1024)
#define CONFIG_LMB
#define CONFIG_OF_LIBFDT
#define CONFIG_TRACE_EARLY_SIZE (8 << 20)
#define CONFIG_TRACE_EARLY
#define CONFIG_TRACE_EARLY_ADDR 0x01400000
#define CONFIG_BOOTSTAGE
#define CONFIG_BOOTSTAGE_REPORT
@ -45,26 +40,6 @@
#define CONFIG_BOOTSTAGE_STASH_SIZE 0x7fc
#define CONFIG_BOOTSTAGE_USER_COUNT 60
#define CONFIG_LZO
#define CONFIG_FIT
#undef CONFIG_ZLIB
#undef CONFIG_GZIP
#define CONFIG_SYS_BOOTM_LEN (16 << 20)
/*-----------------------------------------------------------------------
* Watchdog Configuration
*/
#undef CONFIG_WATCHDOG
#undef CONFIG_HW_WATCHDOG
/* SATA AHCI storage */
#define CONFIG_SCSI_AHCI
#ifdef CONFIG_SCSI_AHCI
#define CONFIG_LIBATA
#define CONFIG_SYS_64BIT_LBA
#define CONFIG_SATA_INTEL 1
#define CONFIG_SCSI_DEV_LIST {PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_NM10_AHCI}, \
{PCI_VENDOR_ID_INTEL, \
@ -74,249 +49,27 @@
{PCI_VENDOR_ID_INTEL, \
PCI_DEVICE_ID_INTEL_PANTHERPOINT_AHCI_MOBILE}
#define CONFIG_SYS_SCSI_MAX_SCSI_ID 2
#define CONFIG_SYS_SCSI_MAX_LUN 1
#define CONFIG_SYS_SCSI_MAX_DEVICE (CONFIG_SYS_SCSI_MAX_SCSI_ID * \
CONFIG_SYS_SCSI_MAX_LUN)
#endif
/* Generic TPM interfaced through LPC bus */
#define CONFIG_TPM
#define CONFIG_TPM_TIS_LPC
#define CONFIG_TPM_TIS_BASE_ADDRESS 0xfed40000
/*-----------------------------------------------------------------------
* Real Time Clock Configuration
*/
#define CONFIG_RTC_MC146818
#define CONFIG_SYS_ISA_IO_BASE_ADDRESS 0
#define CONFIG_SYS_ISA_IO CONFIG_SYS_ISA_IO_BASE_ADDRESS
/*-----------------------------------------------------------------------
* Serial Configuration
*/
#define CONFIG_COREBOOT_SERIAL
#define CONFIG_SYS_NS16550
#define CONFIG_BAUDRATE 115200
#define CONFIG_SYS_BAUDRATE_TABLE {300, 600, 1200, 2400, 4800, \
9600, 19200, 38400, 115200}
#define CONFIG_SYS_NS16550_PORT_MAPPED
#define CONFIG_STD_DEVICES_SETTINGS "stdin=usbkbd,vga,serial\0" \
"stdout=vga,serial,cbmem\0" \
"stderr=vga,serial,cbmem\0"
#define CONFIG_CONSOLE_MUX
#define CONFIG_SYS_CONSOLE_IS_IN_ENV
#define CONFIG_SYS_STDIO_DEREGISTER
#define CONFIG_CBMEM_CONSOLE
#define CONFIG_CMDLINE_EDITING
#define CONFIG_COMMAND_HISTORY
#define CONFIG_AUTO_COMPLETE
#define CONFIG_SYS_HUSH_PARSER
#define CONFIG_SUPPORT_VFAT
/************************************************************
* ATAPI support (experimental)
************************************************************/
#define CONFIG_ATAPI
/************************************************************
* DISK Partition support
************************************************************/
#define CONFIG_EFI_PARTITION
#define CONFIG_DOS_PARTITION
#define CONFIG_MAC_PARTITION
#define CONFIG_ISO_PARTITION /* Experimental */
#define CONFIG_CMD_PART
#define CONFIG_CMD_CBFS
#define CONFIG_CMD_EXT4
#define CONFIG_CMD_EXT4_WRITE
#define CONFIG_PARTITION_UUIDS
/*-----------------------------------------------------------------------
* Video Configuration
*/
#define CONFIG_VIDEO
#define CONFIG_VIDEO_COREBOOT
#define CONFIG_VIDEO_SW_CURSOR
#define VIDEO_FB_16BPP_WORD_SWAP
#define CONFIG_I8042_KBD
#define CONFIG_CFB_CONSOLE
#define CONFIG_SYS_CONSOLE_INFO_QUIET
/* x86 GPIOs are accessed through a PCI device */
#define CONFIG_INTEL_ICH6_GPIO
/*-----------------------------------------------------------------------
* Command line configuration.
*/
#include <config_cmd_default.h>
#define CONFIG_NR_DRAM_BANKS 4
#define CONFIG_TRACE
#define CONFIG_CMD_TRACE
#define CONFIG_TRACE_BUFFER_SIZE (16 << 20)
#define CONFIG_TRACE_EARLY_SIZE (8 << 20)
#define CONFIG_TRACE_EARLY
#define CONFIG_TRACE_EARLY_ADDR 0x01400000
#define CONFIG_CMD_BDI
#define CONFIG_CMD_BOOTD
#define CONFIG_CMD_CONSOLE
#define CONFIG_CMD_DATE
#define CONFIG_CMD_ECHO
#undef CONFIG_CMD_FLASH
#define CONFIG_CMD_FPGA
#define CONFIG_CMD_FPGA_LOADMK
#define CONFIG_CMD_GPIO
#define CONFIG_CMD_IMI
#undef CONFIG_CMD_IMLS
#define CONFIG_CMD_IO
#define CONFIG_CMD_IRQ
#define CONFIG_CMD_ITEST
#define CONFIG_CMD_LOADB
#define CONFIG_CMD_LOADS
#define CONFIG_CMD_MEMORY
#define CONFIG_CMD_MISC
#define CONFIG_CMD_NET
#undef CONFIG_CMD_NFS
#define CONFIG_CMD_PCI
#define CONFIG_CMD_PING
#define CONFIG_CMD_RUN
#define CONFIG_CMD_SAVEENV
#define CONFIG_CMD_SETGETDCR
#define CONFIG_CMD_SOURCE
#define CONFIG_CMD_TIME
#define CONFIG_CMD_GETTIME
#define CONFIG_CMD_XIMG
#define CONFIG_CMD_SCSI
#define CONFIG_CMD_FAT
#define CONFIG_CMD_EXT2
#define CONFIG_CMD_ZBOOT
#define CONFIG_CMD_ELF
#define CONFIG_BOOTDELAY 2
#define CONFIG_BOOTARGS \
"root=/dev/sdb3 init=/sbin/init rootwait ro"
#define CONFIG_BOOTCOMMAND \
"ext2load scsi 0:3 01000000 /boot/vmlinuz; zboot 01000000"
#if defined(CONFIG_CMD_KGDB)
#define CONFIG_KGDB_BAUDRATE 115200
#endif
/*
* Miscellaneous configurable options
*/
#define CONFIG_SYS_LONGHELP
#define CONFIG_SYS_CBSIZE 512
#define CONFIG_SYS_PBSIZE (CONFIG_SYS_CBSIZE + \
sizeof(CONFIG_SYS_PROMPT) + \
16)
#define CONFIG_SYS_MAXARGS 16
#define CONFIG_SYS_BARGSIZE CONFIG_SYS_CBSIZE
#define CONFIG_SYS_MEMTEST_START 0x00100000
#define CONFIG_SYS_MEMTEST_END 0x01000000
#define CONFIG_SYS_LOAD_ADDR 0x20000000
/*-----------------------------------------------------------------------
* SDRAM Configuration
*/
#define CONFIG_NR_DRAM_BANKS 4
/* CONFIG_SYS_SDRAM_DRCTMCTL Overrides the following*/
#undef CONFIG_SYS_SDRAM_PRECHARGE_DELAY
#undef CONFIG_SYS_SDRAM_RAS_CAS_DELAY
#undef CONFIG_SYS_SDRAM_CAS_LATENCY_2T
#undef CONFIG_SYS_SDRAM_CAS_LATENCY_3T
/*-----------------------------------------------------------------------
* CPU Features
*/
#define CONFIG_SYS_X86_TSC_TIMER
#define CONFIG_SYS_PCAT_INTERRUPTS
#define CONFIG_SYS_PCAT_TIMER
#define CONFIG_SYS_NUM_IRQS 16
/*-----------------------------------------------------------------------
* Memory organization:
* 32kB Stack
* 16kB Cache-As-RAM @ 0x19200000
* 256kB Monitor
* (128kB + Environment Sector Size) malloc pool
*/
#define CONFIG_SYS_STACK_SIZE (32 * 1024)
#define CONFIG_SYS_CAR_ADDR 0x19200000
#define CONFIG_SYS_CAR_SIZE (16 * 1024)
#define CONFIG_SYS_MONITOR_BASE CONFIG_SYS_TEXT_BASE
#define CONFIG_SYS_MONITOR_LEN (256 * 1024)
#define CONFIG_SYS_MALLOC_LEN (0x20000 + 128 * 1024)
#define CONFIG_SYS_MALLOC_F_LEN (1 << 10)
/* allow to overwrite serial and ethaddr */
#define CONFIG_ENV_OVERWRITE
/*-----------------------------------------------------------------------
* FLASH configuration
*/
#define CONFIG_ICH_SPI
#define CONFIG_SPI_FLASH
#define CONFIG_SPI_FLASH_MACRONIX
#define CONFIG_SPI_FLASH_WINBOND
#define CONFIG_SPI_FLASH_GIGADEVICE
#define CONFIG_SYS_NO_FLASH
#define CONFIG_CMD_SF
#define CONFIG_CMD_SF_TEST
#define CONFIG_CMD_SPI
#define CONFIG_SPI
/*-----------------------------------------------------------------------
* Environment configuration
*/
#define CONFIG_ENV_IS_NOWHERE
#define CONFIG_ENV_SIZE 0x01000
/*-----------------------------------------------------------------------
* PCI configuration
*/
#define CONFIG_PCI
#define CONFIG_CROS_EC
#define CONFIG_CROS_EC_LPC
#define CONFIG_CMD_CROS_EC
#define CONFIG_ARCH_EARLY_INIT_R
/*-----------------------------------------------------------------------
* USB configuration
*/
#define CONFIG_USB_EHCI
#define CONFIG_USB_EHCI_PCI
#define CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS 12
#define CONFIG_USB_MAX_CONTROLLER_COUNT 2
#define CONFIG_USB_STORAGE
#define CONFIG_USB_KEYBOARD
#define CONFIG_SYS_USB_EVENT_POLL
#define CONFIG_USB_HOST_ETHER
#define CONFIG_USB_ETHER_ASIX
#define CONFIG_USB_ETHER_SMSC95XX
#define CONFIG_TFTP_TSIZE
#define CONFIG_CMD_DHCP
#define CONFIG_BOOTP_BOOTFILESIZE
#define CONFIG_BOOTP_BOOTPATH
#define CONFIG_BOOTP_GATEWAY
#define CONFIG_BOOTP_HOSTNAME
#define CONFIG_CMD_USB
#define CONFIG_EXTRA_ENV_SETTINGS \
CONFIG_STD_DEVICES_SETTINGS
#endif /* __CONFIG_H */

251
include/configs/x86-common.h Normal file
View File

@ -0,0 +1,251 @@
/*
* Copyright (c) 2011 The Chromium OS Authors.
* (C) Copyright 2008
* Graeme Russ, graeme.russ@gmail.com.
*
* SPDX-License-Identifier: GPL-2.0+
*/
#include <asm/ibmpc.h>
#ifndef __CONFIG_X86_COMMON_H
#define __CONFIG_X86_COMMON_H
/*
* High Level Configuration Options
* (easy to change)
*/
#define CONFIG_SHOW_BOOT_PROGRESS
#define CONFIG_SYS_VSNPRINTF
#define CONFIG_ZBOOT_32
#define CONFIG_PHYSMEM
#define CONFIG_DISPLAY_BOARDINFO_LATE
#define CONFIG_DISPLAY_CPUINFO
#define CONFIG_DM
#define CONFIG_CMD_DM
#define CONFIG_DM_GPIO
#define CONFIG_DM_SERIAL
#define CONFIG_LMB
#define CONFIG_OF_LIBFDT
#define CONFIG_LZO
#define CONFIG_FIT
#undef CONFIG_ZLIB
#undef CONFIG_GZIP
#define CONFIG_SYS_BOOTM_LEN (16 << 20)
/* SATA AHCI storage */
#define CONFIG_SCSI_AHCI
#define CONFIG_SATA_INTEL
#ifdef CONFIG_SCSI_AHCI
#define CONFIG_LIBATA
#define CONFIG_SYS_64BIT_LBA
#define CONFIG_SYS_SCSI_MAX_SCSI_ID 2
#define CONFIG_SYS_SCSI_MAX_LUN 1
#define CONFIG_SYS_SCSI_MAX_DEVICE (CONFIG_SYS_SCSI_MAX_SCSI_ID * \
CONFIG_SYS_SCSI_MAX_LUN)
#endif
/* Generic TPM interfaced through LPC bus */
#define CONFIG_TPM
#define CONFIG_TPM_TIS_LPC
#define CONFIG_TPM_TIS_BASE_ADDRESS 0xfed40000
/*-----------------------------------------------------------------------
* Real Time Clock Configuration
*/
#define CONFIG_RTC_MC146818
#define CONFIG_SYS_ISA_IO_BASE_ADDRESS 0
#define CONFIG_SYS_ISA_IO CONFIG_SYS_ISA_IO_BASE_ADDRESS
/*-----------------------------------------------------------------------
* Serial Configuration
*/
#define CONFIG_SYS_NS16550
#define CONFIG_BAUDRATE 115200
#define CONFIG_SYS_BAUDRATE_TABLE {300, 600, 1200, 2400, 4800, \
9600, 19200, 38400, 115200}
#define CONFIG_SYS_NS16550_PORT_MAPPED
#define CONFIG_CONSOLE_MUX
#define CONFIG_SYS_CONSOLE_IS_IN_ENV
#define CONFIG_SYS_STDIO_DEREGISTER
#define CONFIG_CMDLINE_EDITING
#define CONFIG_COMMAND_HISTORY
#define CONFIG_AUTO_COMPLETE
#define CONFIG_SYS_HUSH_PARSER
#define CONFIG_SUPPORT_VFAT
/************************************************************
* ATAPI support (experimental)
************************************************************/
#define CONFIG_ATAPI
/************************************************************
* DISK Partition support
************************************************************/
#define CONFIG_EFI_PARTITION
#define CONFIG_DOS_PARTITION
#define CONFIG_MAC_PARTITION
#define CONFIG_ISO_PARTITION /* Experimental */
#define CONFIG_CMD_PART
#define CONFIG_CMD_CBFS
#define CONFIG_CMD_EXT4
#define CONFIG_CMD_EXT4_WRITE
#define CONFIG_PARTITION_UUIDS
#define CONFIG_SYS_CONSOLE_INFO_QUIET
/* x86 GPIOs are accessed through a PCI device */
#define CONFIG_INTEL_ICH6_GPIO
/*-----------------------------------------------------------------------
* Command line configuration.
*/
#include <config_cmd_default.h>
#define CONFIG_CMD_BDI
#define CONFIG_CMD_BOOTD
#define CONFIG_CMD_CONSOLE
#define CONFIG_CMD_DATE
#define CONFIG_CMD_ECHO
#undef CONFIG_CMD_FLASH
#define CONFIG_CMD_FPGA
#define CONFIG_CMD_FPGA_LOADMK
#define CONFIG_CMD_GPIO
#define CONFIG_CMD_IMI
#undef CONFIG_CMD_IMLS
#define CONFIG_CMD_IO
#define CONFIG_CMD_IRQ
#define CONFIG_CMD_ITEST
#define CONFIG_CMD_LOADB
#define CONFIG_CMD_LOADS
#define CONFIG_CMD_MEMORY
#define CONFIG_CMD_MISC
#define CONFIG_CMD_NET
#undef CONFIG_CMD_NFS
#define CONFIG_CMD_PCI
#define CONFIG_CMD_PING
#define CONFIG_CMD_RUN
#define CONFIG_CMD_SAVEENV
#define CONFIG_CMD_SETGETDCR
#define CONFIG_CMD_SOURCE
#define CONFIG_CMD_TIME
#define CONFIG_CMD_GETTIME
#define CONFIG_CMD_XIMG
#define CONFIG_CMD_SCSI
#define CONFIG_CMD_FAT
#define CONFIG_CMD_EXT2
#define CONFIG_CMD_ZBOOT
#define CONFIG_CMD_ELF
#define CONFIG_BOOTARGS \
"root=/dev/sdb3 init=/sbin/init rootwait ro"
#define CONFIG_BOOTCOMMAND \
"ext2load scsi 0:3 01000000 /boot/vmlinuz; zboot 01000000"
#if defined(CONFIG_CMD_KGDB)
#define CONFIG_KGDB_BAUDRATE 115200
#endif
/*
* Miscellaneous configurable options
*/
#define CONFIG_SYS_LONGHELP
#define CONFIG_SYS_CBSIZE 512
#define CONFIG_SYS_PBSIZE (CONFIG_SYS_CBSIZE + \
sizeof(CONFIG_SYS_PROMPT) + \
16)
#define CONFIG_SYS_MAXARGS 16
#define CONFIG_SYS_BARGSIZE CONFIG_SYS_CBSIZE
#define CONFIG_SYS_MEMTEST_START 0x00100000
#define CONFIG_SYS_MEMTEST_END 0x01000000
#define CONFIG_SYS_LOAD_ADDR 0x20000000
/*-----------------------------------------------------------------------
* Video Configuration
*/
#define CONFIG_VIDEO
#define CONFIG_VIDEO_SW_CURSOR
#define VIDEO_FB_16BPP_WORD_SWAP
#define CONFIG_I8042_KBD
#define CONFIG_CFB_CONSOLE
/*-----------------------------------------------------------------------
* CPU Features
*/
#define CONFIG_SYS_X86_TSC_TIMER
#define CONFIG_SYS_PCAT_INTERRUPTS
#define CONFIG_SYS_PCAT_TIMER
#define CONFIG_SYS_NUM_IRQS 16
#define CONFIG_SYS_STACK_SIZE (32 * 1024)
#define CONFIG_SYS_MONITOR_BASE CONFIG_SYS_TEXT_BASE
#define CONFIG_SYS_MALLOC_LEN 0x200000
#define CONFIG_SYS_MALLOC_F_LEN (2 << 10)
/* allow to overwrite serial and ethaddr */
#define CONFIG_ENV_OVERWRITE
/*-----------------------------------------------------------------------
* FLASH configuration
*/
#define CONFIG_ICH_SPI
#define CONFIG_SPI_FLASH
#define CONFIG_SPI_FLASH_MACRONIX
#define CONFIG_SPI_FLASH_WINBOND
#define CONFIG_SPI_FLASH_GIGADEVICE
#define CONFIG_SYS_NO_FLASH
#define CONFIG_CMD_SF
#define CONFIG_CMD_SF_TEST
#define CONFIG_CMD_SPI
#define CONFIG_SPI
/*-----------------------------------------------------------------------
* Environment configuration
*/
#define CONFIG_ENV_IS_NOWHERE
#define CONFIG_ENV_SIZE 0x01000
/*-----------------------------------------------------------------------
* PCI configuration
*/
#define CONFIG_PCI
/*-----------------------------------------------------------------------
* USB configuration
*/
#define CONFIG_USB_EHCI
#define CONFIG_USB_EHCI_PCI
#define CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS 12
#define CONFIG_USB_MAX_CONTROLLER_COUNT 2
#define CONFIG_USB_STORAGE
#define CONFIG_USB_KEYBOARD
#define CONFIG_SYS_USB_EVENT_POLL
#define CONFIG_USB_HOST_ETHER
#define CONFIG_USB_ETHER_ASIX
#define CONFIG_USB_ETHER_SMSC95XX
#define CONFIG_TFTP_TSIZE
#define CONFIG_CMD_DHCP
#define CONFIG_BOOTP_BOOTFILESIZE
#define CONFIG_BOOTP_BOOTPATH
#define CONFIG_BOOTP_GATEWAY
#define CONFIG_BOOTP_HOSTNAME
#define CONFIG_CMD_USB
#define CONFIG_EXTRA_ENV_SETTINGS \
CONFIG_STD_DEVICES_SETTINGS
#endif /* __CONFIG_H */

18
include/fdtdec.h
View File

@ -118,6 +118,8 @@ enum fdt_compat_id {
COMPAT_SAMSUNG_EXYNOS_SYSMMU, /* Exynos sysmmu */
COMPAT_PARADE_PS8625, /* Parade PS8622 EDP->LVDS bridge */
COMPAT_INTEL_LPC, /* Intel Low Pin Count I/F */
COMPAT_INTEL_MICROCODE, /* Intel microcode update */
COMPAT_MEMORY_SPD, /* Memory SPD information */
COMPAT_COUNT,
};
@ -444,6 +446,22 @@ int fdtdec_lookup_phandle(const void *blob, int node, const char *prop_name);
int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
u32 *array, int count);
/**
* Look up a property in a node and return its contents in an integer
* array of given length. The property must exist but may have less data that
* expected (4*count bytes). It may have more, but this will be ignored.
*
* @param blob FDT blob
* @param node node to examine
* @param prop_name name of property to find
* @param array array to fill with data
* @param count number of array elements
* @return number of array elements if ok, or -FDT_ERR_NOTFOUND if the
* property is not found
*/
int fdtdec_get_int_array_count(const void *blob, int node,
const char *prop_name, u32 *array, int count);
/**
* Look up a property in a node and return a pointer to its contents as a
* unsigned int array of given length. The property must have at least enough

3
lib/asm-offsets.c
View File

@ -31,6 +31,9 @@ int main(void)
#ifdef CONFIG_SYS_MALLOC_F_LEN
DEFINE(GD_MALLOC_BASE, offsetof(struct global_data, malloc_base));
#endif
#ifdef CONFIG_X86
DEFINE(GD_BIST, offsetof(struct global_data, arch.bist));
#endif
#if defined(CONFIG_ARM)

22
lib/fdtdec.c
View File

@ -73,6 +73,8 @@ static const char * const compat_names[COMPAT_COUNT] = {
COMPAT(SAMSUNG_EXYNOS_SYSMMU, "samsung,sysmmu-v3.3"),
COMPAT(PARADE_PS8625, "parade,ps8625"),
COMPAT(COMPAT_INTEL_LPC, "intel,lpc"),
COMPAT(INTEL_MICROCODE, "intel,microcode"),
COMPAT(MEMORY_SPD, "memory-spd"),
};
const char *fdtdec_get_compatible(enum fdt_compat_id id)
@ -485,6 +487,26 @@ int fdtdec_get_int_array(const void *blob, int node, const char *prop_name,
return err;
}
int fdtdec_get_int_array_count(const void *blob, int node,
const char *prop_name, u32 *array, int count)
{
const u32 *cell;
int len, elems;
int i;
debug("%s: %s\n", __func__, prop_name);
cell = fdt_getprop(blob, node, prop_name, &len);
if (!cell)
return -FDT_ERR_NOTFOUND;
elems = len / sizeof(u32);
if (count > elems)
count = elems;
for (i = 0; i < count; i++)
array[i] = fdt32_to_cpu(cell[i]);
return count;
}
const u32 *fdtdec_locate_array(const void *blob, int node,
const char *prop_name, int count)
{

2
tools/Makefile
View File

@ -126,6 +126,8 @@ hostprogs-$(CONFIG_EXYNOS5250) += mkexynosspl
hostprogs-$(CONFIG_EXYNOS5420) += mkexynosspl
HOSTCFLAGS_mkexynosspl.o := -pedantic
hostprogs-$(CONFIG_X86) += ifdtool
hostprogs-$(CONFIG_MX23) += mxsboot
hostprogs-$(CONFIG_MX28) += mxsboot
HOSTCFLAGS_mxsboot.o := -pedantic

1039
tools/ifdtool.c Normal file
View File

File diff suppressed because it is too large Load Diff

88
tools/ifdtool.h Normal file
View File

@ -0,0 +1,88 @@
/*
* ifdtool - Manage Intel Firmware Descriptor information
*
* Copyright (C) 2011 The ChromiumOS Authors.
*
* SPDX-License-Identifier: GPL-2.0
*
* From Coreboot project
*/
#include <stdint.h>
#define __packed __attribute__((packed))
#define IFDTOOL_VERSION "1.1-U-Boot"
enum spi_frequency {
SPI_FREQUENCY_20MHZ = 0,
SPI_FREQUENCY_33MHZ = 1,
SPI_FREQUENCY_50MHZ = 4,
};
enum component_density {
COMPONENT_DENSITY_512KB = 0,
COMPONENT_DENSITY_1MB = 1,
COMPONENT_DENSITY_2MB = 2,
COMPONENT_DENSITY_4MB = 3,
COMPONENT_DENSITY_8MB = 4,
COMPONENT_DENSITY_16MB = 5,
};
/* flash descriptor */
struct __packed fdbar_t {
uint32_t flvalsig;
uint32_t flmap0;
uint32_t flmap1;
uint32_t flmap2;
uint8_t reserved[0xefc - 0x20];
uint32_t flumap1;
};
#define MAX_REGIONS 5
/* regions */
struct __packed frba_t {
uint32_t flreg[MAX_REGIONS];
};
/* component section */
struct __packed fcba_t {
uint32_t flcomp;
uint32_t flill;
uint32_t flpb;
};
#define MAX_STRAPS 18
/* pch strap */
struct __packed fpsba_t {
uint32_t pchstrp[MAX_STRAPS];
};
/* master */
struct __packed fmba_t {
uint32_t flmstr1;
uint32_t flmstr2;
uint32_t flmstr3;
};
/* processor strap */
struct __packed fmsba_t {
uint32_t data[8];
};
/* ME VSCC */
struct vscc_t {
uint32_t jid;
uint32_t vscc;
};
struct vtba_t {
/* Actual number of entries specified in vtl */
struct vscc_t entry[8];
};
struct region_t {
int base, limit, size;
};