Add the Rangeley FSP include & srx directories

These are the .h and .c files from Intel that support interaction
with the FSP.  These have been modified from the FSP distribution
only to strip trailing whitespace.

Intel® Firmware Support Package for Intel® Atom™ Processor C2000
Product Family (Formerly Rangeley)

"Intel® Firmware Support Package (Intel® FSP) provides key
programming information for initializing Intel® silicon and can be
easily integrated into a boot loader of the developer’s choice.
It is easy to adopt, scalable to design, reduces time-to-market, and
is economical to build."

http://www.intel.com/fsp

Change-Id: I9ed94cb92909c3681cc88bf10b85a9ba25e8fc55
Signed-off-by: Martin Roth <martin.roth@se-eng.com>
Signed-off-by: Martin Roth <gaumless@gmail.com>
Reviewed-on: http://review.coreboot.org/5457
Tested-by: build bot (Jenkins)
Reviewed-by: Marc Jones <marc.jones@se-eng.com>

12 files changed, 2581 insertions, 0 deletions

diff --git a/src/vendorcode/intel/Kconfig b/src/vendorcode/intel/Kconfig
index b386e6f5ad..37d5c80431 100644
--- a/src/vendorcode/intel/Kconfig
+++ b/src/vendorcode/intel/Kconfig
@@ -22,3 +22,4 @@ config FSP_VENDORCODE_HEADER_PATH
 	default "fsp/ivybridge_bd82x6x/" if CPU_INTEL_FSP_MODEL_306AX && SOUTHBRIDGE_INTEL_FSP_BD82X6X
 	default "fsp/ivybridge_i89xx/" if CPU_INTEL_FSP_MODEL_306AX && SOUTHBRIDGE_INTEL_FSP_I89XX
 	default "fsp/baytrail/" if SOC_INTEL_FSP_BAYTRAIL
+	default "fsp/rangeley/" if CPU_INTEL_FSP_MODEL_406DX
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspapi.h b/src/vendorcode/intel/fsp/rangeley/include/fspapi.h
new file mode 100644
index 0000000000..5378b2acbc
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspapi.h
@@ -0,0 +1,65 @@
+/**
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef _FSP_API_H_
+#define _FSP_API_H_
+
+#pragma pack(1)
+
+typedef VOID (* CONTINUATION_PROC)(EFI_STATUS Status, VOID *HobListPtr);
+
+typedef struct {
+  VOID               *NvsBufferPtr;
+  VOID               *RtBufferPtr;
+  CONTINUATION_PROC   ContinuationFunc;
+} FSP_INIT_PARAMS;
+
+typedef struct {
+  UINT32            *StackTop;
+  UINT32             BootMode;  /* Refer to boot mode defined in MdePkg\Include\Pi\PiBootMode.h */
+  VOID              *UpdDataRgnPtr;
+  UINT32             Reserved[7];
+} FSP_INIT_RT_COMMON_BUFFER;
+
+typedef enum {
+  EnumInitPhaseAfterPciEnumeration = 0x20,
+  EnumInitPhaseReadyToBoot = 0x40
+} FSP_INIT_PHASE;
+
+typedef struct {
+  FSP_INIT_PHASE     Phase;
+} NOTIFY_PHASE_PARAMS;
+
+#pragma pack()
+
+typedef FSP_STATUS (FSPAPI *FSP_FSP_INIT)    (FSP_INIT_PARAMS     *FspInitParamPtr);
+typedef FSP_STATUS (FSPAPI *FSP_NOTFY_PHASE) (NOTIFY_PHASE_PARAMS *NotifyPhaseParamPtr);
+
+#endif
\ No newline at end of file
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspbootmode.h b/src/vendorcode/intel/fsp/rangeley/include/fspbootmode.h
new file mode 100644
index 0000000000..16cddf073d
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspbootmode.h
@@ -0,0 +1,54 @@
+/** @file
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef __PI_BOOT_MODE_H__
+#define __PI_BOOT_MODE_H__
+
+///
+/// EFI boot mode
+///
+typedef UINT32  EFI_BOOT_MODE;
+
+//
+// 0x21 - 0xf..f are reserved.
+//
+#define BOOT_WITH_FULL_CONFIGURATION                  0x00
+#define BOOT_WITH_MINIMAL_CONFIGURATION               0x01
+#define BOOT_ASSUMING_NO_CONFIGURATION_CHANGES        0x02
+#define BOOT_WITH_FULL_CONFIGURATION_PLUS_DIAGNOSTICS 0x03
+#define BOOT_WITH_DEFAULT_SETTINGS                    0x04
+#define BOOT_ON_S4_RESUME                             0x05
+#define BOOT_ON_S5_RESUME                             0x06
+#define BOOT_ON_S2_RESUME                             0x10
+#define BOOT_ON_S3_RESUME                             0x11
+#define BOOT_ON_FLASH_UPDATE                          0x12
+#define BOOT_IN_RECOVERY_MODE                         0x20
+
+#endif
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspffs.h b/src/vendorcode/intel/fsp/rangeley/include/fspffs.h
new file mode 100644
index 0000000000..83c5e85e24
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspffs.h
@@ -0,0 +1,507 @@
+/** @file
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+
+#ifndef __PI_FIRMWARE_FILE_H__
+#define __PI_FIRMWARE_FILE_H__
+
+#pragma pack(1)
+///
+/// Used to verify the integrity of the file.
+///
+typedef union {
+  struct {
+    ///
+    /// The IntegrityCheck.Checksum.Header field is an 8-bit checksum of the file
+    /// header. The State and IntegrityCheck.Checksum.File fields are assumed
+    /// to be zero and the checksum is calculated such that the entire header sums to zero.
+    ///
+    UINT8   Header;
+    ///
+    /// If the FFS_ATTRIB_CHECKSUM (see definition below) bit of the Attributes
+    /// field is set to one, the IntegrityCheck.Checksum.File field is an 8-bit
+    /// checksum of the file data.
+    /// If the FFS_ATTRIB_CHECKSUM bit of the Attributes field is cleared to zero,
+    /// the IntegrityCheck.Checksum.File field must be initialized with a value of
+    /// 0xAA. The IntegrityCheck.Checksum.File field is valid any time the
+    /// EFI_FILE_DATA_VALID bit is set in the State field.
+    ///
+    UINT8   File;
+  } Checksum;
+  ///
+  /// This is the full 16 bits of the IntegrityCheck field.
+  ///
+  UINT16    Checksum16;
+} EFI_FFS_INTEGRITY_CHECK;
+
+///
+/// FFS_FIXED_CHECKSUM is the checksum value used when the
+/// FFS_ATTRIB_CHECKSUM attribute bit is clear.
+///
+#define FFS_FIXED_CHECKSUM  0xAA
+
+typedef UINT8 EFI_FV_FILETYPE;
+typedef UINT8 EFI_FFS_FILE_ATTRIBUTES;
+typedef UINT8 EFI_FFS_FILE_STATE;
+
+///
+/// File Types Definitions
+///
+#define EFI_FV_FILETYPE_ALL                   0x00
+#define EFI_FV_FILETYPE_RAW                   0x01
+#define EFI_FV_FILETYPE_FREEFORM              0x02
+#define EFI_FV_FILETYPE_SECURITY_CORE         0x03
+#define EFI_FV_FILETYPE_PEI_CORE              0x04
+#define EFI_FV_FILETYPE_DXE_CORE              0x05
+#define EFI_FV_FILETYPE_PEIM                  0x06
+#define EFI_FV_FILETYPE_DRIVER                0x07
+#define EFI_FV_FILETYPE_COMBINED_PEIM_DRIVER  0x08
+#define EFI_FV_FILETYPE_APPLICATION           0x09
+#define EFI_FV_FILETYPE_SMM                   0x0A
+#define EFI_FV_FILETYPE_FIRMWARE_VOLUME_IMAGE 0x0B
+#define EFI_FV_FILETYPE_COMBINED_SMM_DXE      0x0C
+#define EFI_FV_FILETYPE_SMM_CORE              0x0D
+#define EFI_FV_FILETYPE_OEM_MIN               0xc0
+#define EFI_FV_FILETYPE_OEM_MAX               0xdf
+#define EFI_FV_FILETYPE_DEBUG_MIN             0xe0
+#define EFI_FV_FILETYPE_DEBUG_MAX             0xef
+#define EFI_FV_FILETYPE_FFS_MIN               0xf0
+#define EFI_FV_FILETYPE_FFS_MAX               0xff
+#define EFI_FV_FILETYPE_FFS_PAD               0xf0
+///
+/// FFS File Attributes.
+///
+#define FFS_ATTRIB_LARGE_FILE         0x01
+#define FFS_ATTRIB_FIXED              0x04
+#define FFS_ATTRIB_DATA_ALIGNMENT     0x38
+#define FFS_ATTRIB_CHECKSUM           0x40
+
+///
+/// FFS File State Bits.
+///
+#define EFI_FILE_HEADER_CONSTRUCTION  0x01
+#define EFI_FILE_HEADER_VALID         0x02
+#define EFI_FILE_DATA_VALID           0x04
+#define EFI_FILE_MARKED_FOR_UPDATE    0x08
+#define EFI_FILE_DELETED              0x10
+#define EFI_FILE_HEADER_INVALID       0x20
+
+
+///
+/// Each file begins with the header that describe the
+/// contents and state of the files.
+///
+typedef struct {
+  ///
+  /// This GUID is the file name. It is used to uniquely identify the file.
+  ///
+  EFI_GUID                Name;
+  ///
+  /// Used to verify the integrity of the file.
+  ///
+  EFI_FFS_INTEGRITY_CHECK IntegrityCheck;
+  ///
+  /// Identifies the type of file.
+  ///
+  EFI_FV_FILETYPE         Type;
+  ///
+  /// Declares various file attribute bits.
+  ///
+  EFI_FFS_FILE_ATTRIBUTES Attributes;
+  ///
+  /// The length of the file in bytes, including the FFS header.
+  ///
+  UINT8                   Size[3];
+  ///
+  /// Used to track the state of the file throughout the life of the file from creation to deletion.
+  ///
+  EFI_FFS_FILE_STATE      State;
+} EFI_FFS_FILE_HEADER;
+
+typedef struct {
+  ///
+  /// This GUID is the file name. It is used to uniquely identify the file. There may be only
+  /// one instance of a file with the file name GUID of Name in any given firmware
+  /// volume, except if the file type is EFI_FV_FILETYPE_FFS_PAD.
+  ///
+  EFI_GUID                  Name;
+
+  ///
+  /// Used to verify the integrity of the file.
+  ///
+  EFI_FFS_INTEGRITY_CHECK   IntegrityCheck;
+
+  ///
+  /// Identifies the type of file.
+  ///
+  EFI_FV_FILETYPE           Type;
+
+  ///
+  /// Declares various file attribute bits.
+  ///
+  EFI_FFS_FILE_ATTRIBUTES   Attributes;
+
+  ///
+  /// The length of the file in bytes, including the FFS header.
+  /// The length of the file data is either (Size - sizeof(EFI_FFS_FILE_HEADER)). This calculation means a
+  /// zero-length file has a Size of 24 bytes, which is sizeof(EFI_FFS_FILE_HEADER).
+  /// Size is not required to be a multiple of 8 bytes. Given a file F, the next file header is
+  /// located at the next 8-byte aligned firmware volume offset following the last byte of the file F.
+  ///
+  UINT8                     Size[3];
+
+  ///
+  /// Used to track the state of the file throughout the life of the file from creation to deletion.
+  ///
+  EFI_FFS_FILE_STATE        State;
+
+  ///
+  /// If FFS_ATTRIB_LARGE_FILE is set in Attributes, then ExtendedSize exists and Size must be set to zero.
+  /// If FFS_ATTRIB_LARGE_FILE is not set then EFI_FFS_FILE_HEADER is used.
+  ///
+  UINT32                    ExtendedSize;
+} EFI_FFS_FILE_HEADER2;
+
+#define IS_FFS_FILE2(FfsFileHeaderPtr) \
+    (((((EFI_FFS_FILE_HEADER *) (UINTN) FfsFileHeaderPtr)->Attributes) & FFS_ATTRIB_LARGE_FILE) == FFS_ATTRIB_LARGE_FILE)
+
+#define FFS_FILE_SIZE(FfsFileHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_FFS_FILE_HEADER *) (UINTN) FfsFileHeaderPtr)->Size) & 0x00ffffff))
+
+#define FFS_FILE2_SIZE(FfsFileHeaderPtr) \
+    (((EFI_FFS_FILE_HEADER2 *) (UINTN) FfsFileHeaderPtr)->ExtendedSize)
+
+typedef UINT8 EFI_SECTION_TYPE;
+
+///
+/// Pseudo type. It is used as a wild card when retrieving sections.
+///  The section type EFI_SECTION_ALL matches all section types.
+///
+#define EFI_SECTION_ALL                   0x00
+
+///
+/// Encapsulation section Type values.
+///
+#define EFI_SECTION_COMPRESSION           0x01
+
+#define EFI_SECTION_GUID_DEFINED          0x02
+
+#define EFI_SECTION_DISPOSABLE            0x03
+
+///
+/// Leaf section Type values.
+///
+#define EFI_SECTION_PE32                  0x10
+#define EFI_SECTION_PIC                   0x11
+#define EFI_SECTION_TE                    0x12
+#define EFI_SECTION_DXE_DEPEX             0x13
+#define EFI_SECTION_VERSION               0x14
+#define EFI_SECTION_USER_INTERFACE        0x15
+#define EFI_SECTION_COMPATIBILITY16       0x16
+#define EFI_SECTION_FIRMWARE_VOLUME_IMAGE 0x17
+#define EFI_SECTION_FREEFORM_SUBTYPE_GUID 0x18
+#define EFI_SECTION_RAW                   0x19
+#define EFI_SECTION_PEI_DEPEX             0x1B
+#define EFI_SECTION_SMM_DEPEX             0x1C
+
+///
+/// Common section header.
+///
+typedef struct {
+  ///
+  /// A 24-bit unsigned integer that contains the total size of the section in bytes,
+  /// including the EFI_COMMON_SECTION_HEADER.
+  ///
+  UINT8             Size[3];
+  EFI_SECTION_TYPE  Type;
+  ///
+  /// Declares the section type.
+  ///
+} EFI_COMMON_SECTION_HEADER;
+
+typedef struct {
+  ///
+  /// A 24-bit unsigned integer that contains the total size of the section in bytes,
+  /// including the EFI_COMMON_SECTION_HEADER.
+  ///
+  UINT8             Size[3];
+
+  EFI_SECTION_TYPE  Type;
+
+  ///
+  /// If Size is 0xFFFFFF, then ExtendedSize contains the size of the section. If
+  /// Size is not equal to 0xFFFFFF, then this field does not exist.
+  ///
+  UINT32            ExtendedSize;
+} EFI_COMMON_SECTION_HEADER2;
+
+///
+/// Leaf section type that contains an
+/// IA-32 16-bit executable image.
+///
+typedef EFI_COMMON_SECTION_HEADER  EFI_COMPATIBILITY16_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2 EFI_COMPATIBILITY16_SECTION2;
+
+///
+/// CompressionType of EFI_COMPRESSION_SECTION.
+///
+#define EFI_NOT_COMPRESSED        0x00
+#define EFI_STANDARD_COMPRESSION  0x01
+///
+/// An encapsulation section type in which the
+/// section data is compressed.
+///
+typedef struct {
+  ///
+  /// Usual common section header. CommonHeader.Type = EFI_SECTION_COMPRESSION.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// The UINT32 that indicates the size of the section data after decompression.
+  ///
+  UINT32                      UncompressedLength;
+  ///
+  /// Indicates which compression algorithm is used.
+  ///
+  UINT8                       CompressionType;
+} EFI_COMPRESSION_SECTION;
+
+typedef struct {
+  ///
+  /// Usual common section header. CommonHeader.Type = EFI_SECTION_COMPRESSION.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// UINT32 that indicates the size of the section data after decompression.
+  ///
+  UINT32                        UncompressedLength;
+  ///
+  /// Indicates which compression algorithm is used.
+  ///
+  UINT8                         CompressionType;
+} EFI_COMPRESSION_SECTION2;
+
+///
+/// An encapsulation section type in which the section data is disposable.
+/// A disposable section is an encapsulation section in which the section data may be disposed of during
+/// the process of creating or updating a firmware image without significant impact on the usefulness of
+/// the file. The Type field in the section header is set to EFI_SECTION_DISPOSABLE. This
+/// allows optional or descriptive data to be included with the firmware file which can be removed in
+/// order to conserve space. The contents of this section are implementation specific, but might contain
+/// debug data or detailed integration instructions.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_DISPOSABLE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_DISPOSABLE_SECTION2;
+
+///
+/// The leaf section which could be used to determine the dispatch order of DXEs.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_DXE_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_DXE_DEPEX_SECTION2;
+
+///
+/// The leaf section which contains a PI FV.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_FIRMWARE_VOLUME_IMAGE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_FIRMWARE_VOLUME_IMAGE_SECTION2;
+
+///
+/// The leaf section which contains a single GUID.
+///
+typedef struct {
+  ///
+  /// Common section header. CommonHeader.Type = EFI_SECTION_FREEFORM_SUBTYPE_GUID.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// This GUID is defined by the creator of the file. It is a vendor-defined file type.
+  ///
+  EFI_GUID                    SubTypeGuid;
+} EFI_FREEFORM_SUBTYPE_GUID_SECTION;
+
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_FREEFORM_SUBTYPE_GUID.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// This GUID is defined by the creator of the file. It is a vendor-defined file type.
+  ///
+  EFI_GUID                      SubTypeGuid;
+} EFI_FREEFORM_SUBTYPE_GUID_SECTION2;
+
+///
+/// Attributes of EFI_GUID_DEFINED_SECTION.
+///
+#define EFI_GUIDED_SECTION_PROCESSING_REQUIRED  0x01
+#define EFI_GUIDED_SECTION_AUTH_STATUS_VALID    0x02
+///
+/// The leaf section which is encapsulation defined by specific GUID.
+///
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_GUID_DEFINED.
+  ///
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  ///
+  /// The GUID that defines the format of the data that follows. It is a vendor-defined section type.
+  ///
+  EFI_GUID                    SectionDefinitionGuid;
+  ///
+  /// Contains the offset in bytes from the beginning of the common header to the first byte of the data.
+  ///
+  UINT16                      DataOffset;
+  ///
+  /// The bit field that declares some specific characteristics of the section contents.
+  ///
+  UINT16                      Attributes;
+} EFI_GUID_DEFINED_SECTION;
+
+typedef struct {
+  ///
+  /// The common section header. CommonHeader.Type = EFI_SECTION_GUID_DEFINED.
+  ///
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// The GUID that defines the format of the data that follows. It is a vendor-defined section type.
+  ///
+  EFI_GUID                      SectionDefinitionGuid;
+  ///
+  /// Contains the offset in bytes from the beginning of the common header to the first byte of the data.
+  ///
+  UINT16                        DataOffset;
+  ///
+  /// The bit field that declares some specific characteristics of the section contents.
+  ///
+  UINT16                        Attributes;
+} EFI_GUID_DEFINED_SECTION2;
+
+///
+/// The leaf section which contains PE32+ image.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PE32_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PE32_SECTION2;
+
+///
+/// The leaf section used to determine the dispatch order of PEIMs.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PEI_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PEI_DEPEX_SECTION2;
+
+///
+/// A leaf section type that contains a position-independent-code (PIC) image.
+/// A PIC image section is a leaf section that contains a position-independent-code (PIC) image.
+/// In addition to normal PE32+ images that contain relocation information, PEIM executables may be
+/// PIC and are referred to as PIC images. A PIC image is the same as a PE32+ image except that all
+/// relocation information has been stripped from the image and the image can be moved and will
+/// execute correctly without performing any relocation or other fix-ups. EFI_PIC_SECTION2 must
+/// be used if the section is 16MB or larger.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_PIC_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_PIC_SECTION2;
+
+///
+/// The leaf section which constains the position-independent-code image.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_TE_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_TE_SECTION2;
+
+///
+/// The leaf section which contains an array of zero or more bytes.
+///
+typedef EFI_COMMON_SECTION_HEADER   EFI_RAW_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2  EFI_RAW_SECTION2;
+
+///
+/// The SMM dependency expression section is a leaf section that contains a dependency expression that
+/// is used to determine the dispatch order for SMM drivers. Before the SMRAM invocation of the
+/// SMM driver's entry point, this dependency expression must evaluate to TRUE. See the Platform
+/// Initialization Specification, Volume 2, for details regarding the format of the dependency expression.
+/// The dependency expression may refer to protocols installed in either the UEFI or the SMM protocol
+/// database. EFI_SMM_DEPEX_SECTION2 must be used if the section is 16MB or larger.
+///
+typedef EFI_COMMON_SECTION_HEADER EFI_SMM_DEPEX_SECTION;
+typedef EFI_COMMON_SECTION_HEADER2 EFI_SMM_DEPEX_SECTION2;
+
+///
+/// The leaf section which contains a unicode string that
+/// is human readable file name.
+///
+typedef struct {
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+
+  ///
+  /// Array of unicode string.
+  ///
+  CHAR16                      FileNameString[1];
+} EFI_USER_INTERFACE_SECTION;
+
+typedef struct {
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  CHAR16                        FileNameString[1];
+} EFI_USER_INTERFACE_SECTION2;
+
+///
+/// The leaf section which contains a numeric build number and
+/// an optional unicode string that represents the file revision.
+///
+typedef struct {
+  EFI_COMMON_SECTION_HEADER   CommonHeader;
+  UINT16                      BuildNumber;
+
+  ///
+  /// Array of unicode string.
+  ///
+  CHAR16                      VersionString[1];
+} EFI_VERSION_SECTION;
+
+typedef struct {
+  EFI_COMMON_SECTION_HEADER2    CommonHeader;
+  ///
+  /// A UINT16 that represents a particular build. Subsequent builds have monotonically
+  /// increasing build numbers relative to earlier builds.
+  ///
+  UINT16                        BuildNumber;
+  CHAR16                        VersionString[1];
+} EFI_VERSION_SECTION2;
+
+#define IS_SECTION2(SectionHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) (UINTN) SectionHeaderPtr)->Size) & 0x00ffffff) == 0x00ffffff)
+
+#define SECTION_SIZE(SectionHeaderPtr) \
+    ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) (UINTN) SectionHeaderPtr)->Size) & 0x00ffffff))
+
+#define SECTION2_SIZE(SectionHeaderPtr) \
+    (((EFI_COMMON_SECTION_HEADER2 *) (UINTN) SectionHeaderPtr)->ExtendedSize)
+
+#pragma pack()
+
+#endif
+
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspfv.h b/src/vendorcode/intel/fsp/rangeley/include/fspfv.h
new file mode 100644
index 0000000000..75d17faa6a
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspfv.h
@@ -0,0 +1,247 @@
+/** @file
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef __PI_FIRMWAREVOLUME_H__
+#define __PI_FIRMWAREVOLUME_H__
+
+///
+/// EFI_FV_FILE_ATTRIBUTES
+///
+typedef UINT32  EFI_FV_FILE_ATTRIBUTES;
+
+//
+// Value of EFI_FV_FILE_ATTRIBUTES.
+//
+#define EFI_FV_FILE_ATTRIB_ALIGNMENT      0x0000001F
+#define EFI_FV_FILE_ATTRIB_FIXED          0x00000100
+#define EFI_FV_FILE_ATTRIB_MEMORY_MAPPED  0x00000200
+
+///
+/// type of EFI FVB attribute
+///
+typedef UINT32  EFI_FVB_ATTRIBUTES_2;
+
+//
+// Attributes bit definitions
+//
+#define EFI_FVB2_READ_DISABLED_CAP  0x00000001
+#define EFI_FVB2_READ_ENABLED_CAP   0x00000002
+#define EFI_FVB2_READ_STATUS        0x00000004
+#define EFI_FVB2_WRITE_DISABLED_CAP 0x00000008
+#define EFI_FVB2_WRITE_ENABLED_CAP  0x00000010
+#define EFI_FVB2_WRITE_STATUS       0x00000020
+#define EFI_FVB2_LOCK_CAP           0x00000040
+#define EFI_FVB2_LOCK_STATUS        0x00000080
+#define EFI_FVB2_STICKY_WRITE       0x00000200
+#define EFI_FVB2_MEMORY_MAPPED      0x00000400
+#define EFI_FVB2_ERASE_POLARITY     0x00000800
+#define EFI_FVB2_READ_LOCK_CAP      0x00001000
+#define EFI_FVB2_READ_LOCK_STATUS   0x00002000
+#define EFI_FVB2_WRITE_LOCK_CAP     0x00004000
+#define EFI_FVB2_WRITE_LOCK_STATUS  0x00008000
+#define EFI_FVB2_ALIGNMENT          0x001F0000
+#define EFI_FVB2_ALIGNMENT_1        0x00000000
+#define EFI_FVB2_ALIGNMENT_2        0x00010000
+#define EFI_FVB2_ALIGNMENT_4        0x00020000
+#define EFI_FVB2_ALIGNMENT_8        0x00030000
+#define EFI_FVB2_ALIGNMENT_16       0x00040000
+#define EFI_FVB2_ALIGNMENT_32       0x00050000
+#define EFI_FVB2_ALIGNMENT_64       0x00060000
+#define EFI_FVB2_ALIGNMENT_128      0x00070000
+#define EFI_FVB2_ALIGNMENT_256      0x00080000
+#define EFI_FVB2_ALIGNMENT_512      0x00090000
+#define EFI_FVB2_ALIGNMENT_1K       0x000A0000
+#define EFI_FVB2_ALIGNMENT_2K       0x000B0000
+#define EFI_FVB2_ALIGNMENT_4K       0x000C0000
+#define EFI_FVB2_ALIGNMENT_8K       0x000D0000
+#define EFI_FVB2_ALIGNMENT_16K      0x000E0000
+#define EFI_FVB2_ALIGNMENT_32K      0x000F0000
+#define EFI_FVB2_ALIGNMENT_64K      0x00100000
+#define EFI_FVB2_ALIGNMENT_128K     0x00110000
+#define EFI_FVB2_ALIGNMENT_256K     0x00120000
+#define EFI_FVB2_ALIGNMENT_512K     0x00130000
+#define EFI_FVB2_ALIGNMENT_1M       0x00140000
+#define EFI_FVB2_ALIGNMENT_2M       0x00150000
+#define EFI_FVB2_ALIGNMENT_4M       0x00160000
+#define EFI_FVB2_ALIGNMENT_8M       0x00170000
+#define EFI_FVB2_ALIGNMENT_16M      0x00180000
+#define EFI_FVB2_ALIGNMENT_32M      0x00190000
+#define EFI_FVB2_ALIGNMENT_64M      0x001A0000
+#define EFI_FVB2_ALIGNMENT_128M     0x001B0000
+#define EFI_FVB2_ALIGNMENT_256M     0x001C0000
+#define EFI_FVB2_ALIGNMENT_512M     0x001D0000
+#define EFI_FVB2_ALIGNMENT_1G       0x001E0000
+#define EFI_FVB2_ALIGNMENT_2G       0x001F0000
+
+
+typedef struct {
+  ///
+  /// The number of sequential blocks which are of the same size.
+  ///
+  UINT32 NumBlocks;
+  ///
+  /// The size of the blocks.
+  ///
+  UINT32 Length;
+} EFI_FV_BLOCK_MAP_ENTRY;
+
+///
+/// Describes the features and layout of the firmware volume.
+///
+typedef struct {
+  ///
+  /// The first 16 bytes are reserved to allow for the reset vector of
+  /// processors whose reset vector is at address 0.
+  ///
+  UINT8                     ZeroVector[16];
+  ///
+  /// Declares the file system with which the firmware volume is formatted.
+  ///
+  EFI_GUID                  FileSystemGuid;
+  ///
+  /// Length in bytes of the complete firmware volume, including the header.
+  ///
+  UINT64                    FvLength;
+  ///
+  /// Set to EFI_FVH_SIGNATURE
+  ///
+  UINT32                    Signature;
+  ///
+  /// Declares capabilities and power-on defaults for the firmware volume.
+  ///
+  EFI_FVB_ATTRIBUTES_2      Attributes;
+  ///
+  /// Length in bytes of the complete firmware volume header.
+  ///
+  UINT16                    HeaderLength;
+  ///
+  /// A 16-bit checksum of the firmware volume header. A valid header sums to zero.
+  ///
+  UINT16                    Checksum;
+  ///
+  /// Offset, relative to the start of the header, of the extended header
+  /// (EFI_FIRMWARE_VOLUME_EXT_HEADER) or zero if there is no extended header.
+  ///
+  UINT16                    ExtHeaderOffset;
+  ///
+  /// This field must always be set to zero.
+  ///
+  UINT8                     Reserved[1];
+  ///
+  /// Set to 2. Future versions of this specification may define new header fields and will
+  /// increment the Revision field accordingly.
+  ///
+  UINT8                     Revision;
+  ///
+  /// An array of run-length encoded FvBlockMapEntry structures. The array is
+  /// terminated with an entry of {0,0}.
+  ///
+  EFI_FV_BLOCK_MAP_ENTRY    BlockMap[1];
+} EFI_FIRMWARE_VOLUME_HEADER;
+
+#define EFI_FVH_SIGNATURE SIGNATURE_32 ('_', 'F', 'V', 'H')
+
+///
+/// Firmware Volume Header Revision definition
+///
+#define EFI_FVH_REVISION  0x02
+
+///
+/// Extension header pointed by ExtHeaderOffset of volume header.
+///
+typedef struct {
+  ///
+  /// Firmware volume name.
+  ///
+  EFI_GUID  FvName;
+  ///
+  /// Size of the rest of the extension header, including this structure.
+  ///
+  UINT32    ExtHeaderSize;
+} EFI_FIRMWARE_VOLUME_EXT_HEADER;
+
+///
+/// Entry struture for describing FV extension header
+///
+typedef struct {
+  ///
+  /// Size of this header extension.
+  ///
+  UINT16    ExtEntrySize;
+  ///
+  /// Type of the header.
+  ///
+  UINT16    ExtEntryType;
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY;
+
+#define EFI_FV_EXT_TYPE_OEM_TYPE  0x01
+///
+/// This extension header provides a mapping between a GUID and an OEM file type.
+///
+typedef struct {
+  ///
+  /// Standard extension entry, with the type EFI_FV_EXT_TYPE_OEM_TYPE.
+  ///
+  EFI_FIRMWARE_VOLUME_EXT_ENTRY Hdr;
+  ///
+  /// A bit mask, one bit for each file type between 0xC0 (bit 0) and 0xDF (bit 31). If a bit
+  /// is '1', then the GUID entry exists in Types. If a bit is '0' then no GUID entry exists in Types.
+  ///
+  UINT32    TypeMask;
+  ///
+  /// An array of GUIDs, each GUID representing an OEM file type.
+  ///
+  /// EFI_GUID  Types[1];
+  ///
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY_OEM_TYPE;
+
+#define EFI_FV_EXT_TYPE_GUID_TYPE 0x0002
+
+///
+/// This extension header EFI_FIRMWARE_VOLUME_EXT_ENTRY_GUID_TYPE provides a vendor specific
+/// GUID FormatType type which includes a length and a successive series of data bytes.
+///
+typedef struct {
+  ///
+  /// Standard extension entry, with the type EFI_FV_EXT_TYPE_OEM_TYPE.
+  ///
+  EFI_FIRMWARE_VOLUME_EXT_ENTRY     Hdr;
+  ///
+  /// Vendor-specific GUID.
+  ///
+  EFI_GUID                          FormatType;
+  ///
+  /// An arry of bytes of length Length.
+  ///
+  /// UINT8                             Data[1];
+  ///
+} EFI_FIRMWARE_VOLUME_EXT_ENTRY_GUID_TYPE;
+
+#endif
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fsphob.h b/src/vendorcode/intel/fsp/rangeley/include/fsphob.h
new file mode 100644
index 0000000000..a9c0bceb92
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fsphob.h
@@ -0,0 +1,542 @@
+/** @file
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef __PI_HOB_H__
+#define __PI_HOB_H__
+
+//
+// HobType of EFI_HOB_GENERIC_HEADER.
+//
+#define EFI_HOB_TYPE_MEMORY_ALLOCATION    0x0002
+#define EFI_HOB_TYPE_RESOURCE_DESCRIPTOR  0x0003
+#define EFI_HOB_TYPE_GUID_EXTENSION       0x0004
+#define EFI_HOB_TYPE_UNUSED               0xFFFE
+#define EFI_HOB_TYPE_END_OF_HOB_LIST      0xFFFF
+
+///
+/// Describes the format and size of the data inside the HOB.
+/// All HOBs must contain this generic HOB header.
+///
+typedef struct {
+  ///
+  /// Identifies the HOB data structure type.
+  ///
+  UINT16    HobType;
+  ///
+  /// The length in bytes of the HOB.
+  ///
+  UINT16    HobLength;
+  ///
+  /// This field must always be set to zero.
+  ///
+  UINT32    Reserved;
+} EFI_HOB_GENERIC_HEADER;
+
+///
+/// Enumeration of memory types introduced in UEFI.
+///
+typedef enum {
+  ///
+  /// Not used.
+  ///
+  EfiReservedMemoryType,
+  ///
+  /// The code portions of a loaded application.
+  /// (Note that UEFI OS loaders are UEFI applications.)
+  ///
+  EfiLoaderCode,
+  ///
+  /// The data portions of a loaded application and the default data allocation
+  /// type used by an application to allocate pool memory.
+  ///
+  EfiLoaderData,
+  ///
+  /// The code portions of a loaded Boot Services Driver.
+  ///
+  EfiBootServicesCode,
+  ///
+  /// The data portions of a loaded Boot Serves Driver, and the default data
+  /// allocation type used by a Boot Services Driver to allocate pool memory.
+  ///
+  EfiBootServicesData,
+  ///
+  /// The code portions of a loaded Runtime Services Driver.
+  ///
+  EfiRuntimeServicesCode,
+  ///
+  /// The data portions of a loaded Runtime Services Driver and the default
+  /// data allocation type used by a Runtime Services Driver to allocate pool memory.
+  ///
+  EfiRuntimeServicesData,
+  ///
+  /// Free (unallocated) memory.
+  ///
+  EfiConventionalMemory,
+  ///
+  /// Memory in which errors have been detected.
+  ///
+  EfiUnusableMemory,
+  ///
+  /// Memory that holds the ACPI tables.
+  ///
+  EfiACPIReclaimMemory,
+  ///
+  /// Address space reserved for use by the firmware.
+  ///
+  EfiACPIMemoryNVS,
+  ///
+  /// Used by system firmware to request that a memory-mapped IO region
+  /// be mapped by the OS to a virtual address so it can be accessed by EFI runtime services.
+  ///
+  EfiMemoryMappedIO,
+  ///
+  /// System memory-mapped IO region that is used to translate memory
+  /// cycles to IO cycles by the processor.
+  ///
+  EfiMemoryMappedIOPortSpace,
+  ///
+  /// Address space reserved by the firmware for code that is part of the processor.
+  ///
+  EfiPalCode,
+  EfiMaxMemoryType
+} EFI_MEMORY_TYPE;
+
+///
+/// EFI_HOB_MEMORY_ALLOCATION_HEADER describes the
+/// various attributes of the logical memory allocation. The type field will be used for
+/// subsequent inclusion in the UEFI memory map.
+///
+typedef struct {
+  ///
+  /// A GUID that defines the memory allocation region's type and purpose, as well as
+  /// other fields within the memory allocation HOB. This GUID is used to define the
+  /// additional data within the HOB that may be present for the memory allocation HOB.
+  /// Type EFI_GUID is defined in InstallProtocolInterface() in the UEFI 2.0
+  /// specification.
+  ///
+  EFI_GUID              Name;
+
+  ///
+  /// The base address of memory allocated by this HOB. Type
+  /// EFI_PHYSICAL_ADDRESS is defined in AllocatePages() in the UEFI 2.0
+  /// specification.
+  ///
+  EFI_PHYSICAL_ADDRESS  MemoryBaseAddress;
+
+  ///
+  /// The length in bytes of memory allocated by this HOB.
+  ///
+  UINT64                MemoryLength;
+
+  ///
+  /// Defines the type of memory allocated by this HOB. The memory type definition
+  /// follows the EFI_MEMORY_TYPE definition. Type EFI_MEMORY_TYPE is defined
+  /// in AllocatePages() in the UEFI 2.0 specification.
+  ///
+  EFI_MEMORY_TYPE       MemoryType;
+
+  ///
+  /// Padding for Itanium processor family
+  ///
+  UINT8                 Reserved[4];
+} EFI_HOB_MEMORY_ALLOCATION_HEADER;
+
+///
+/// Describes all memory ranges used during the HOB producer
+/// phase that exist outside the HOB list. This HOB type
+/// describes how memory is used, not the physical attributes of memory.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_MEMORY_ALLOCATION.
+  ///
+  EFI_HOB_GENERIC_HEADER            Header;
+  ///
+  /// An instance of the EFI_HOB_MEMORY_ALLOCATION_HEADER that describes the
+  /// various attributes of the logical memory allocation.
+  ///
+  EFI_HOB_MEMORY_ALLOCATION_HEADER  AllocDescriptor;
+  //
+  // Additional data pertaining to the "Name" Guid memory
+  // may go here.
+  //
+} EFI_HOB_MEMORY_ALLOCATION;
+
+///
+/// The resource type.
+///
+typedef UINT32 EFI_RESOURCE_TYPE;
+
+//
+// Value of ResourceType in EFI_HOB_RESOURCE_DESCRIPTOR.
+//
+#define EFI_RESOURCE_SYSTEM_MEMORY          0x00000000
+#define EFI_RESOURCE_MEMORY_MAPPED_IO       0x00000001
+#define EFI_RESOURCE_IO                     0x00000002
+#define EFI_RESOURCE_FIRMWARE_DEVICE        0x00000003
+#define EFI_RESOURCE_MEMORY_MAPPED_IO_PORT  0x00000004
+#define EFI_RESOURCE_MEMORY_RESERVED        0x00000005
+#define EFI_RESOURCE_IO_RESERVED            0x00000006
+#define EFI_RESOURCE_MAX_MEMORY_TYPE        0x00000007
+
+///
+/// A type of recount attribute type.
+///
+typedef UINT32 EFI_RESOURCE_ATTRIBUTE_TYPE;
+
+//
+// These types can be ORed together as needed.
+//
+// The first three enumerations describe settings
+//
+#define EFI_RESOURCE_ATTRIBUTE_PRESENT              0x00000001
+#define EFI_RESOURCE_ATTRIBUTE_INITIALIZED          0x00000002
+#define EFI_RESOURCE_ATTRIBUTE_TESTED               0x00000004
+//
+// The rest of the settings describe capabilities
+//
+#define EFI_RESOURCE_ATTRIBUTE_SINGLE_BIT_ECC           0x00000008
+#define EFI_RESOURCE_ATTRIBUTE_MULTIPLE_BIT_ECC         0x00000010
+#define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_1           0x00000020
+#define EFI_RESOURCE_ATTRIBUTE_ECC_RESERVED_2           0x00000040
+#define EFI_RESOURCE_ATTRIBUTE_READ_PROTECTED           0x00000080
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_PROTECTED          0x00000100
+#define EFI_RESOURCE_ATTRIBUTE_EXECUTION_PROTECTED      0x00000200
+#define EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE              0x00000400
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE        0x00000800
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE  0x00001000
+#define EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE     0x00002000
+#define EFI_RESOURCE_ATTRIBUTE_16_BIT_IO                0x00004000
+#define EFI_RESOURCE_ATTRIBUTE_32_BIT_IO                0x00008000
+#define EFI_RESOURCE_ATTRIBUTE_64_BIT_IO                0x00010000
+#define EFI_RESOURCE_ATTRIBUTE_UNCACHED_EXPORTED        0x00020000
+
+///
+/// Describes the resource properties of all fixed,
+/// nonrelocatable resource ranges found on the processor
+/// host bus during the HOB producer phase.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_RESOURCE_DESCRIPTOR.
+  ///
+  EFI_HOB_GENERIC_HEADER      Header;
+  ///
+  /// A GUID representing the owner of the resource. This GUID is used by HOB
+  /// consumer phase components to correlate device ownership of a resource.
+  ///
+  EFI_GUID                    Owner;
+  ///
+  /// The resource type enumeration as defined by EFI_RESOURCE_TYPE.
+  ///
+  EFI_RESOURCE_TYPE           ResourceType;
+  ///
+  /// Resource attributes as defined by EFI_RESOURCE_ATTRIBUTE_TYPE.
+  ///
+  EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute;
+  ///
+  /// The physical start address of the resource region.
+  ///
+  EFI_PHYSICAL_ADDRESS        PhysicalStart;
+  ///
+  /// The number of bytes of the resource region.
+  ///
+  UINT64                      ResourceLength;
+} EFI_HOB_RESOURCE_DESCRIPTOR;
+
+///
+/// Allows writers of executable content in the HOB producer phase to
+/// maintain and manage HOBs with specific GUID.
+///
+typedef struct {
+  ///
+  /// The HOB generic header. Header.HobType = EFI_HOB_TYPE_GUID_EXTENSION.
+  ///
+  EFI_HOB_GENERIC_HEADER      Header;
+  ///
+  /// A GUID that defines the contents of this HOB.
+  ///
+  EFI_GUID                    Name;
+  //
+  // Guid specific data goes here
+  //
+} EFI_HOB_GUID_TYPE;
+
+///
+/// Union of all the possible HOB Types.
+///
+typedef union {
+  EFI_HOB_GENERIC_HEADER              *Header;
+  EFI_HOB_MEMORY_ALLOCATION           *MemoryAllocation;
+  EFI_HOB_RESOURCE_DESCRIPTOR         *ResourceDescriptor;
+  EFI_HOB_GUID_TYPE                   *Guid;
+  UINT8                               *Raw;
+} EFI_PEI_HOB_POINTERS;
+
+
+/**
+  Returns the type of a HOB.
+
+  This macro returns the HobType field from the HOB header for the
+  HOB specified by HobStart.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return HobType.
+
+**/
+#define GET_HOB_TYPE(HobStart) \
+  ((*(EFI_HOB_GENERIC_HEADER **)&(HobStart))->HobType)
+
+/**
+  Returns the length, in bytes, of a HOB.
+
+  This macro returns the HobLength field from the HOB header for the
+  HOB specified by HobStart.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return HobLength.
+
+**/
+#define GET_HOB_LENGTH(HobStart) \
+  ((*(EFI_HOB_GENERIC_HEADER **)&(HobStart))->HobLength)
+
+/**
+  Returns a pointer to the next HOB in the HOB list.
+
+  This macro returns a pointer to HOB that follows the
+  HOB specified by HobStart in the HOB List.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @return A pointer to the next HOB in the HOB list.
+
+**/
+#define GET_NEXT_HOB(HobStart) \
+  (VOID *)(*(UINT8 **)&(HobStart) + GET_HOB_LENGTH (HobStart))
+
+/**
+  Determines if a HOB is the last HOB in the HOB list.
+
+  This macro determine if the HOB specified by HobStart is the
+  last HOB in the HOB list.  If HobStart is last HOB in the HOB list,
+  then TRUE is returned.  Otherwise, FALSE is returned.
+
+  @param  HobStart   A pointer to a HOB.
+
+  @retval TRUE       The HOB specified by HobStart is the last HOB in the HOB list.
+  @retval FALSE      The HOB specified by HobStart is not the last HOB in the HOB list.
+
+**/
+#define END_OF_HOB_LIST(HobStart)  (GET_HOB_TYPE (HobStart) == (UINT16)EFI_HOB_TYPE_END_OF_HOB_LIST)
+
+/**
+  Returns a pointer to data buffer from a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  This macro returns a pointer to the data buffer in a HOB specified by HobStart.
+  HobStart is assumed to be a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  @param   GuidHob   A pointer to a HOB.
+
+  @return  A pointer to the data buffer in a HOB.
+
+**/
+#define GET_GUID_HOB_DATA(HobStart) \
+  (VOID *)(*(UINT8 **)&(HobStart) + sizeof (EFI_HOB_GUID_TYPE))
+
+/**
+  Returns the size of the data buffer from a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  This macro returns the size, in bytes, of the data buffer in a HOB specified by HobStart.
+  HobStart is assumed to be a HOB of type EFI_HOB_TYPE_GUID_EXTENSION.
+
+  @param   GuidHob   A pointer to a HOB.
+
+  @return  The size of the data buffer.
+**/
+#define GET_GUID_HOB_DATA_SIZE(HobStart) \
+  (UINT16)(GET_HOB_LENGTH (HobStart) - sizeof (EFI_HOB_GUID_TYPE))
+
+/**
+  Returns the pointer to the HOB list.
+
+  This function returns the pointer to first HOB in the list.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @return The pointer to the HOB list.
+
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  );
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+
+  This function searches the first instance of a HOB type from the starting HOB pointer.
+  If there does not exist such HOB type from the starting HOB pointer, it will return NULL.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+
+  If HobStart is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+  @param  HobStart      The starting HOB pointer to search from.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  UINT16                 Type,
+  CONST VOID             *HobStart
+  );
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+
+  This function searches the first instance of a HOB type among the whole HOB list.
+  If there does not exist such HOB type in the HOB list, it will return NULL.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+
+  @param  Type          The HOB type to return.
+
+  @return The next instance of a HOB type from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  UINT16                 Type
+  );
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+
+  This function searches the first instance of a HOB from the starting HOB pointer.
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size info respectively.
+  In contrast with macro GET_NEXT_HOB(), this function does not skip the starting HOB pointer
+  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
+  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.
+
+  If Guid is NULL, then ASSERT().
+  If HobStart is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+  @param  HobStart      A pointer to a Guid.
+
+  @return The next instance of the matched GUID HOB from the starting HOB.
+
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  CONST EFI_GUID         *Guid,
+  CONST VOID             *HobStart
+  );
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+
+  This function searches the first instance of a HOB among the whole HOB list.
+  Such HOB should satisfy two conditions:
+  its HOB type is EFI_HOB_TYPE_GUID_EXTENSION and its GUID Name equals to the input Guid.
+  If there does not exist such HOB from the starting HOB pointer, it will return NULL.
+  Caller is required to apply GET_GUID_HOB_DATA () and GET_GUID_HOB_DATA_SIZE ()
+  to extract the data section and its size info respectively.
+
+  If the pointer to the HOB list is NULL, then ASSERT().
+  If Guid is NULL, then ASSERT().
+
+  @param  Guid          The GUID to match with in the HOB list.
+
+  @return The first instance of the matched GUID HOB among the whole HOB list.
+
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  CONST EFI_GUID         *Guid
+  );
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  CONST EFI_GUID  *Guid1,
+  CONST EFI_GUID  *Guid2
+  );
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  Pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  CONST UINT64              *Buffer
+  );
+
+#endif
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspinfoheader.h b/src/vendorcode/intel/fsp/rangeley/include/fspinfoheader.h
new file mode 100644
index 0000000000..28382cf20e
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspinfoheader.h
@@ -0,0 +1,62 @@
+/*++
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef _FSP_INFO_HEADER_H_
+#define _FSP_INFO_HEADER_H_
+
+#pragma pack(1)
+
+typedef struct  {
+
+  UINT32  Signature;       // Off 0x94
+  UINT32  HeaderLength;
+  UINT8   Reserved1[3];
+  UINT8   HeaderRevision;
+  UINT32  ImageRevision;
+
+  CHAR8   ImageId[8];      // Off 0xA4
+  UINT32  ImageSize;
+  UINT32  ImageBase;
+
+  UINT32  ImageAttribute;  // Off 0xB4
+  UINT32  CfgRegionOffset;
+  UINT32  CfgRegionSize;
+  UINT32  ApiEntryNum;
+
+  UINT32  NemInitEntry;    // Off 0xC4
+  UINT32  FspInitEntry;
+  UINT32  NotifyPhaseEntry;
+  UINT32  Reserved2;
+
+} FSP_INFO_HEADER;
+
+#pragma pack()
+
+#endif
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspplatform.h b/src/vendorcode/intel/fsp/rangeley/include/fspplatform.h
new file mode 100644
index 0000000000..ce479bf9f8
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspplatform.h
@@ -0,0 +1,113 @@
+/**
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+**/
+
+#ifndef _FSP_PLATFORM_H_
+#define _FSP_PLATFORM_H_
+
+#include "fsptypes.h"
+#include "fspapi.h"
+
+//
+// Maximum number of SDRAM channels supported by each CPU
+//
+#define MAX_CHANNELS                 2
+//
+// Maximum number of DIMM sockets supported by each channel
+//
+#define MAX_DIMMS                    2
+
+#pragma pack(1)
+//
+// SPD DDR3 structure
+//
+typedef struct {
+  UINT8  DRAMDeviceType;                 // 2   DRAM Device Type
+  UINT8  ModuleType;                     // 3   Module Type
+  UINT8  SDRAMDensityAndBanks;           // 4   SDRAM Density and Banks
+  UINT8  SDRAMAddressing;                // 5   SDRAM Addressing
+  UINT8  VDD;                            // 6   Module Nominal Voltage
+  UINT8  ModuleOrganization;             // 7   Module Organization
+  UINT8  ModuleMemoryBusWidth;           // 8   Module Memory Bus Width
+  UINT8  TimebaseDividend;               // 10  Medium Timebase (MTB) Dividend
+  UINT8  TimebaseDivisor;                // 11  Medium Timebase (MTB) Divisor
+  UINT8  SDRAMMinimumCycleTime;          // 12  SDRAM Minimum Cycle Time (tCKmin)
+  UINT8  CASLatenciesLSB;                // 14  CAS Latencies Supported, Least Significant Byte
+  UINT8  CASLatenciesMSB;                // 15  CAS Latencies Supported, Most Significant Byte
+  UINT8  MinimumCASLatencyTime;          // 16  Minimum CAS Latency Time (tAAmin)
+  UINT8  MinimumWriteRecoveryTime;       // 17  Minimum Write Recovery Time (tWRmin)
+  UINT8  MinimumRASToCASDelayTime;       // 18  Minimum RAS# to CAS# Delay Time (tRCDmin)
+  UINT8  MinimumRowToRowDelayTime;       // 19  Minimum Row Active to Row Active Delay Time (tRRDmin)
+  UINT8  MinimumRowPrechargeDelayTime;   // 20  Minimum Row Precharge Delay Time (tRPmin)
+  UINT8  UpperNibblesFortRASAndtRC;      // 21  Upper Nibbles for tRAS and tRC
+  UINT8  tRASmin;                        // 22  Minimum Active to Precharge Delay Time (tRASmin), Least Significant Byte
+  UINT8  tRCmin;                         // 23  Minimum Active to Active/Refresh Delay Time (tRCmin), Least Significant Byte
+  UINT8  tRFCminLeastSignificantByte;    // 24  Minimum Refresh Recovery Delay Time (tRFCmin), Least Significant Byte
+  UINT8  tRFCminMostSignificantByte;     // 25  Minimum Refresh Recovery Delay Time (tRFCmin), Most Significant Byte
+  UINT8  tWTRmin;                        // 26  Minimum Internal Write to Read Command Delay Time (tWTRmin)
+  UINT8  tRTPmin;                        // 27  Minimum Internal Read to Precharge Command Delay Time (tRTPmin)
+  UINT8  UpperNibbleFortFAW;             // 28  Upper Nibble for tFAW
+  UINT8  tFAWmin;                        // 29  Minimum Four Activate Window Delay Time (tFAWmin)
+  UINT8  ModuleThermalSensor;            // 32  ModuleThermalSensor
+  UINT8  SDRAMDeviceType;                // 33  SDRAM Device Type
+  UINT8  tCKminFine;                     // 34  Fine Offset for SDRAM Minimum Cycle Time (tCKmin)
+  UINT8  tAAminFine;                     // 35  Fine Offset for Minimum CAS Latency Time (tAAmin)
+  UINT8  MACCount;                       // 41  Maximum Activate Count
+  UINT8  ReferenceRawCardUsed;           // 62  Reference Raw Card Used
+  UINT8  AddressMappingEdgeConnector;    // 63  Address Mapping from Edge Connector to DRAM
+  UINT8  ModuleManufacturerIdCodeLsb;    // 117 Module Manufacturer ID Code, Least Significant Byte
+  UINT8  ModuleManufacturerIdCodeMsb;    // 118 Module Manufacturer ID Code, Most Significant Byte
+  UINT8  ModuleManufacturingLocation;    // 119 Module Manufacturing Location
+  UINT8  ModuleManufacturingDateYear;    // 120 Module Manufacturing Date Year
+  UINT8  ModuleManufacturingDateWW;      // 121 Module Manufacturing Date creation work week
+  UINT8  ModuleSerialNumberA;            // 122 Module Serial Number A
+  UINT8  ModuleSerialNumberB;            // 123 Module Serial Number B
+  UINT8  ModuleSerialNumberC;            // 124 Module Serial Number C
+  UINT8  ModuleSerialNumberD;            // 125 Module Serial Number D
+  UINT8  DramManufacturerIdLsb;          // 148 DRAM Manufacturer ID Code, LSB
+  UINT8  DramManufacturerIdMsb;          // 149 DRAM Manufacturer ID Code, MSB
+} MEM_DOWN_DIMM_SPD_DATA;
+
+typedef struct {
+  UINT32   MemoryDownDimmPopulation;  // 0 - Empty, 1 - DIMM populated
+  MEM_DOWN_DIMM_SPD_DATA   MemoryDownDimmSpdData;
+} MEM_DOWN_DIMM_CONFIG;
+
+typedef struct {
+  CONST MEM_DOWN_DIMM_CONFIG  *MemDownDimmConfig[MAX_CHANNELS][MAX_DIMMS];
+} FSP_INIT_RT_PLATFORM_BUFFER;
+
+typedef struct {
+  FSP_INIT_RT_COMMON_BUFFER  Common;
+  FSP_INIT_RT_PLATFORM_BUFFER Platform;
+} FSP_INIT_RT_BUFFER;
+
+#pragma pack()
+
+#endif
\ No newline at end of file
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fsptypes.h b/src/vendorcode/intel/fsp/rangeley/include/fsptypes.h
new file mode 100644
index 0000000000..3d2e6631a1
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fsptypes.h
@@ -0,0 +1,183 @@
+/******************************************************************************
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+ *****************************************************************************/
+
+/** \file  fsptypes.h
+ *
+ *
+ */
+
+#ifndef __FSP_TYPES_H__
+#define __FSP_TYPES_H__
+
+///
+/// 8-byte unsigned value.
+///
+typedef unsigned long long  UINT64;
+///
+/// 8-byte signed value.
+///
+typedef long long           INT64;
+///
+/// 4-byte unsigned value.
+///
+typedef unsigned int        UINT32;
+///
+/// 4-byte signed value.
+///
+typedef int                 INT32;
+///
+/// 2-byte unsigned value.
+///
+typedef unsigned short      UINT16;
+///
+/// 2-byte Character.  Unless otherwise specified all strings are stored in the
+/// UTF-16 encoding format as defined by Unicode 2.1 and ISO/IEC 10646 standards.
+///
+typedef unsigned short      CHAR16;
+///
+/// 2-byte signed value.
+///
+typedef short               INT16;
+///
+/// Logical Boolean.  1-byte value containing 0 for FALSE or a 1 for TRUE.  Other
+/// values are undefined.
+///
+typedef unsigned char       BOOLEAN;
+///
+/// 1-byte unsigned value.
+///
+typedef unsigned char       UINT8;
+///
+/// 1-byte Character
+///
+typedef char                CHAR8;
+///
+/// 1-byte signed value
+///
+typedef char                INT8;
+
+typedef void                VOID;
+
+typedef UINT64              EFI_PHYSICAL_ADDRESS;
+
+typedef struct {
+  UINT32  Data1;
+  UINT16  Data2;
+  UINT16  Data3;
+  UINT8   Data4[8];
+} EFI_GUID;
+
+#define CONST     const
+#define STATIC    static
+
+#define TRUE  ((BOOLEAN)(1==1))
+#define FALSE ((BOOLEAN)(0==1))
+
+static inline void DebugDeadLoop(void) {
+  for (;;);
+}
+
+#define FSPAPI __attribute__((cdecl))
+#define EFIAPI __attribute__((cdecl))
+
+#define _ASSERT(Expression)  DebugDeadLoop()
+#define ASSERT(Expression)      \
+  do {                          \
+    if (!(Expression)) {        \
+      _ASSERT (Expression);     \
+    }                           \
+  } while (FALSE)
+
+typedef UINT32 FSP_STATUS;
+typedef UINT32 EFI_STATUS;
+
+///
+/// Compatiable with EFI_STATUS defined in PI Spec.
+#define FSP_SUCCESS               0
+#define FSP_INVALID_PARAMETER     0x80000002
+#define FSP_UNSUPPORTED           0x80000003
+#define FSP_DEVICE_ERROR          0x80000007
+#define FSP_NOT_FOUND             0x8000000E
+#define FSP_ALREADY_STARTED       0x80000014
+
+/**
+  Returns a 16-bit signature built from 2 ASCII characters.
+
+  This macro returns a 16-bit value built from the two ASCII characters specified
+  by A and B.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+
+  @return A 16-bit value built from the two ASCII characters specified by A and B.
+
+**/
+#define SIGNATURE_16(A, B)        ((A) | (B << 8))
+
+/**
+  Returns a 32-bit signature built from 4 ASCII characters.
+
+  This macro returns a 32-bit value built from the four ASCII characters specified
+  by A, B, C, and D.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+  @param  C    The third ASCII character.
+  @param  D    The fourth ASCII character.
+
+  @return A 32-bit value built from the two ASCII characters specified by A, B,
+          C and D.
+
+**/
+#define SIGNATURE_32(A, B, C, D)  (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))
+
+/**
+  Returns a 64-bit signature built from 8 ASCII characters.
+
+  This macro returns a 64-bit value built from the eight ASCII characters specified
+  by A, B, C, D, E, F, G,and H.
+
+  @param  A    The first ASCII character.
+  @param  B    The second ASCII character.
+  @param  C    The third ASCII character.
+  @param  D    The fourth ASCII character.
+  @param  E    The fifth ASCII character.
+  @param  F    The sixth ASCII character.
+  @param  G    The seventh ASCII character.
+  @param  H    The eighth ASCII character.
+
+  @return A 64-bit value built from the two ASCII characters specified by A, B,
+          C, D, E, F, G and H.
+
+**/
+#define SIGNATURE_64(A, B, C, D, E, F, G, H) \
+    (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))
+
+#endif
\ No newline at end of file
diff --git a/src/vendorcode/intel/fsp/rangeley/include/fspvpd.h b/src/vendorcode/intel/fsp/rangeley/include/fspvpd.h
new file mode 100644
index 0000000000..12ac2be35e
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/include/fspvpd.h
@@ -0,0 +1,82 @@
+/** @file
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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 file is automatically generated. Please do NOT modify !!!
+
+**/
+
+#ifndef __FSP_VPD_H__
+#define __FSP_VPD_H__
+
+#pragma pack(1)
+
+
+
+typedef struct _UPD_DATA_REGION {
+  UINT64                      Signature;                     /* Offset 0x0000 */
+  UINT64                      Reserved;                      /* Offset 0x0008 */
+  UINT8                       UnusedUpdSpace0[16];           /* Offset 0x0010 */
+  UINT8                       PcdMrcInitTsegSize;            /* Offset 0x0020 */
+  UINT8                       PcdMemoryDown;                 /* Offset 0x0021 */
+  UINT8                       PcdMrcRmtSupport;              /* Offset 0x0022 */
+  UINT8                       PcdMrcRmtCpgcExpLoopCntValue;  /* Offset 0x0023 */
+  UINT8                       PcdMrcRmtCpgcNumBursts;        /* Offset 0x0024 */
+  UINT8                       PcdSpdBaseAddress_0_0;         /* Offset 0x0025 */
+  UINT8                       PcdSpdBaseAddress_0_1;         /* Offset 0x0026 */
+  UINT8                       PcdSpdBaseAddress_1_0;         /* Offset 0x0027 */
+  UINT8                       PcdSpdBaseAddress_1_1;         /* Offset 0x0028 */
+  UINT8                       UnusedUpdSpace1[7];            /* Offset 0x0029 */
+  UINT8                       PcdEnableLan;                  /* Offset 0x0030 */
+  UINT8                       PcdEnableSata2;                /* Offset 0x0031 */
+  UINT8                       PcdEnableSata3;                /* Offset 0x0032 */
+  UINT8                       PcdEnableIQAT;                 /* Offset 0x0033 */
+  UINT8                       PcdEnableUsb20;                /* Offset 0x0034 */
+  UINT8                       PcdBifurcation;                /* Offset 0x0035 */
+  UINT8                       UnusedUpdSpace2[10];           /* Offset 0x0036 */
+  UINT8                       PcdPrintDebugMessages;         /* Offset 0x0040 */
+  UINT8                       PcdFastboot;                   /* Offset 0x0041 */
+  UINT8                       PcdEccSupport;                 /* Offset 0x0042 */
+  UINT8                       UnusedUpdSpace3[13];           /* Offset 0x0043 */
+  UINT16                      PcdRegionTerminator;           /* Offset 0x0050 */
+} UPD_DATA_REGION;
+
+#define VPD_IMAGE_ID    0x562D474E524E5641        /* 'AVNRNG-V' */
+#define VPD_IMAGE_REV   0x00000101
+
+typedef struct _VPD_DATA_REGION {
+  UINT64                      PcdVpdRegionSign;              /* Offset 0x0000 */
+  UINT32                      PcdImageRevision;              /* Offset 0x0008 */
+  UINT32                      PcdUpdRegionOffset;            /* Offset 0x000C */
+  UINT8                       UnusedVpdSpace0[16];           /* Offset 0x0010 */
+  UINT32                      PcdFspReservedMemoryLength;    /* Offset 0x0020 */
+  UINT8                       PcdSpdWriteProtect;            /* Offset 0x0024 */
+} VPD_DATA_REGION;
+
+#pragma pack()
+
+#endif
diff --git a/src/vendorcode/intel/fsp/rangeley/srx/fspapi.c b/src/vendorcode/intel/fsp/rangeley/srx/fspapi.c
new file mode 100644
index 0000000000..78978f576e
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/srx/fspapi.c
@@ -0,0 +1,521 @@
+/*
+ * This file is part of the coreboot project.
+ *
+ * Copyright (C) 2007-2008 coresystems GmbH
+ * Copyright (C) 2013, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+// __PRE_RAM__ means: use "unsigned" for device, not a struct.
+
+#include <stdint.h>
+#include <string.h>
+#include <arch/io.h>
+#include <arch/romcc_io.h>
+#include <device/pci_def.h>
+#include <device/pnp_def.h>
+#include <cpu/x86/lapic.h>
+#include <cpu/x86/stack.h>
+#include <pc80/mc146818rtc.h>
+#include <console/console.h>
+#include <spi.h>
+#include <spi_flash.h>
+#include <cbmem.h>
+#include <ip_checksum.h>
+
+#include "fsptypes.h"
+#include "fspfv.h"
+#include "fspffs.h"
+#include "fsphob.h"
+#include "fspvpd.h"
+#include "fspapi.h"
+#include "fspplatform.h"
+#include "fspinfoheader.h"
+#include "fspbootmode.h"
+#include "northbridge/intel/rangeley/northbridge.h"
+
+void find_fsp_header(void);
+void early_init(FSP_INFO_HEADER *fsp_info);
+void FspNotifyPhase(uint32_t Phase);
+void UpdateFspUpdConfigs (
+  UPD_DATA_REGION        *FspUpdRgn
+);
+
+//
+// Spd Data table for Memory Down
+//
+#ifdef __PRE_RAM__
+#if CONFIG_MEMORY_DOWN_ENABLE
+/*
+  * MEM_DOWN_DIMM_CONFIG
+  *   MemoryDownDimmPopulation - 0: Empty 1: Populated.
+  *   MemoryDownDimmSpdData - structure MEM_DOWN_DIMM_SPD_DATA for spd data.
+ */
+  /* Apacer 2GB PC3-12800 DDR3-1600MHz ECC Unbuffered CL11 240-Pin DIMM Single Rank Memory Module Mfr P/N 78.A1GG3.AF20C  */
+static const MEM_DOWN_DIMM_CONFIG OemMemoryDownDimmConfig = {
+0x01, // MemoryDownDimmPopulation
+{  // MemoryDownDimmSpdData
+  0xB,    //Byte   2  Dram Device Type
+  0x2,    //Byte   3  Module type (3:0)
+  0x3,    //Byte   4  Density and Banks
+  0x19,   //Byte   5  Addressing
+  0x2,    //Byte   6  Nominal Voltage, VDD
+  0x1,    //Byte   7  Module Organization
+  0xB,    //Byte   8  Memory Bus Width
+  0x1,    //Byte  10  Medium Timebase (MTB) Dividend
+  0x8,    //Byte  11  Medium Timebase (MTB) Divisor
+  0xA,    //Byte  12  Minimum cycle time (tCKmin)
+  0xFC,   //Byte  14  CAS latency supported, low byte
+  0,      //Byte  15  CAS latency supported, high byte
+  0x69,   //Byte  16  Minimum CAS latency time (tAA)
+  0x78,   //Byte  17  Minimum write recovery time (tWR)
+  0x69,   //Byte  18  Minimum RAS to CAS time (tRCD)
+  0x30,   //Byte  19  Minimum RA to RA time (tRRD)
+  0x69,   //Byte  20  Minimum precharge time (tRP)
+  0x11,   //Byte  21  Upper nibbles for tRAS (7:4), tRC (3:0)
+  0x18,   //Byte  22  Minimum active to precharge (tRAS)
+  0x81,   //Byte  23  Minimum active to active/refresh (tRC)
+  0,      //Byte  24  Minimum refresh recovery (tRFC), low byte
+  0x5,    //Byte  25  Minimum refresh recovery (tRFC), high byte
+  0x3C,   //Byte  26  Minimum internal wr to rd cmd (tWTR)
+  0x3C,   //Byte  27  Minimum internal rd to pc cmd (tRTP)
+  0,      //Byte  28  Upper Nibble for tFAW
+  0xF0,   //Byte  29  Minimum Four Activate Window Delay Time (tFAWmin), Least Significant Byte
+  0x80,   //Byte  32
+  0,      //Byte  33
+  0,      //Byte  34
+  0,      //Byte  35
+  0,      //Byte  41
+  0x3,    //Byte  62
+  0,      //Byte  63
+  0x1,    //Byte 117
+  0x7A,   //Byte 118
+  0,      //Byte 119
+  0x13,   //Byte 120
+  0x15,   //Byte 121
+  0x2,    //Byte 122
+  0x1,    //Byte 123
+  0x31,   //Byte 124
+  0x52,   //Byte 125
+  0,      //Byte 148
+  0,      //Byte 149
+}
+};
+
+  /* Dummy structure  */
+static const MEM_DOWN_DIMM_CONFIG DummyMemoryDownDimmConfig = {
+0x00, // MemoryDownDimmPopulation
+{  // MemoryDownDimmSpdData
+  0,    //Byte   2  Dram Device Type
+  0,    //Byte   3  Module type (3:0)
+  0,    //Byte   4  Density and Banks
+  0,   //Byte   5  Addressing
+  0,    //Byte   6  Nominal Voltage, VDD
+  0,    //Byte   7  Module Organization
+  0,    //Byte   8  Memory Bus Width
+  0,    //Byte  10  Medium Timebase (MTB) Dividend
+  0,    //Byte  11  Medium Timebase (MTB) Divisor
+  0,    //Byte  12  Minimum cycle time (tCKmin)
+  0,   //Byte  14  CAS latency supported, low byte
+  0,      //Byte  15  CAS latency supported, high byte
+  0,   //Byte  16  Minimum CAS latency time (tAA)
+  0,   //Byte  17  Minimum write recovery time (tWR)
+  0,   //Byte  18  Minimum RAS to CAS time (tRCD)
+  0,   //Byte  19  Minimum RA to RA time (tRRD)
+  0,   //Byte  20  Minimum precharge time (tRP)
+  0,   //Byte  21  Upper nibbles for tRAS (7:4), tRC (3:0)
+  0,   //Byte  22  Minimum active to precharge (tRAS)
+  0,   //Byte  23  Minimum active to active/refresh (tRC)
+  0,      //Byte  24  Minimum refresh recovery (tRFC), low byte
+  0,    //Byte  25  Minimum refresh recovery (tRFC), high byte
+  0,   //Byte  26  Minimum internal wr to rd cmd (tWTR)
+  0,   //Byte  27  Minimum internal rd to pc cmd (tRTP)
+  0,      //Byte  28  Upper Nibble for tFAW
+  0,   //Byte  29  Minimum Four Activate Window Delay Time (tFAWmin), Least Significant Byte
+  0,   //Byte  32
+  0,      //Byte  33
+  0,      //Byte  34
+  0,      //Byte  35
+  0,      //Byte  41
+  0,    //Byte  62
+  0,      //Byte  63
+  0,    //Byte 117
+  0,   //Byte 118
+  0,    //Byte 119
+  0,   //Byte 120
+  0,   //Byte 121
+  0,    //Byte 122
+  0,    //Byte 123
+  0,   //Byte 124
+  0,   //Byte 125
+  0,      //Byte 148
+  0,      //Byte 149
+}
+};
+#endif
+#endif
+
+//
+// FSP_INFO_HEADER GUID
+//
+#define FSP_INFO_HEADER_GUID \
+  { \
+  0x912740BE, 0x2284, 0x4734, {0xB9, 0x71, 0x84, 0xB0, 0x27, 0x35, 0x3F, 0x0C} \
+  }
+
+//
+// FSP_NON_VOLATILE_STORAGE_HOB_GUID
+//
+#define FSP_NON_VOLATILE_STORAGE_HOB_GUID \
+  { \
+  0x721acf02, 0x4d77, 0x4c2a, { 0xb3, 0xdc, 0x27, 0xb, 0x7b, 0xa9, 0xe4, 0xb0} \
+  }
+
+static EFI_GUID  gFspInfoHeaderGuid = FSP_INFO_HEADER_GUID;
+#ifdef __PRE_RAM__
+static EFI_GUID  gEfiMemoryConfigDataGuid = FSP_NON_VOLATILE_STORAGE_HOB_GUID;
+#endif
+
+/*
+  * Compares two GUIDs.
+  * Input:
+  *   Guid1       a 128 bit GUID.
+  *   Guid2       a 128 bit GUID.
+  * Return:
+  *   TRUE      Guid1 and Guid2 are identical.
+  *   FALSE     Guid1 and Guid2 are not identical.
+ */
+#define CompareGuid(Guid1, Guid2) (	\
+	(Guid1.Data1 == Guid2.Data1) &&	\
+	(Guid1.Data2 == Guid2.Data2) &&	\
+	(Guid1.Data3 == Guid2.Data3) &&	\
+	(Guid1.Data4[0] == Guid2.Data4[0]) &&	\
+	(Guid1.Data4[1] == Guid2.Data4[1]) &&	\
+	(Guid1.Data4[2] == Guid2.Data4[2]) &&	\
+	(Guid1.Data4[3] == Guid2.Data4[3]) &&	\
+	(Guid1.Data4[4] == Guid2.Data4[4]) &&	\
+	(Guid1.Data4[5] == Guid2.Data4[5]) &&	\
+	(Guid1.Data4[6] == Guid2.Data4[6]) &&	\
+	(Guid1.Data4[7] == Guid2.Data4[7])	\
+  )
+
+/*
+  * Compares two GUIDs.
+  * Input:
+  *   Guid1       A pointer to a 128 bit GUID.
+  *   Guid2       A pointer to a 128 bit GUID.
+  * Return:
+  *   TRUE      Guid1 and Guid2 are identical.
+  *   FALSE     Guid1 and Guid2 are not identical.
+ */
+#define CompareGuidPtr(Guid1, Guid2) (	\
+        (((UINT32 *) Guid1)[0] == ((UINT32 *) Guid2)[0]) && \
+        (((UINT32 *) Guid1)[1] == ((UINT32 *) Guid2)[1]) && \
+        (((UINT32 *) Guid1)[2] == ((UINT32 *) Guid2)[2]) && \
+        (((UINT32 *) Guid1)[3] == ((UINT32 *) Guid2)[3]) \
+  )
+
+/*
+ * Platform configuration pointer/structure here.
+ */
+
+#ifdef __PRE_RAM__
+static void ContinuationFunc (EFI_STATUS Status, void *HobListPtr)
+{
+  /* Should add the necessary code here! */
+
+  EFI_HOB_GUID_TYPE            *GuidHob;
+
+  /*
+   * DO NOT know why the following code always fail to build.
+   *
+   * GuidHob = GetNextGuidHob (&gEfiMemoryConfigDataGuid, HobListPtr);
+   *
+   * The error message as below,
+   *
+   *   .data is non-zero size in romstage which is not allowed -- global variable?
+   *
+   * OR,
+   *
+   *   .bss is non-zero size in romstage which is not allowed -- global variable?
+   *
+   * It's replaced with the following code.
+   */
+
+  /* Get the Memory Configure Data HOB */
+  EFI_PEI_HOB_POINTERS      mGuidHob;
+
+  mGuidHob.Raw = (UINT8 *) HobListPtr;
+  while ((mGuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, mGuidHob.Raw)) != NULL) {
+    if (CompareGuid(gEfiMemoryConfigDataGuid, mGuidHob.Guid->Name)) {
+      break;
+    }
+    mGuidHob.Raw = GET_NEXT_HOB (mGuidHob);
+  }
+  GuidHob = (EFI_HOB_GUID_TYPE *) mGuidHob.Raw;
+
+  if (GuidHob == NULL) {
+
+    /* Avoid store Hob to CBMEM if NVRAM Hob not exist */
+    printk(BIOS_DEBUG, "FSP NVRAM Hob NOT found.\n");
+
+  } else {
+
+  /* Get Guid Hob size and Guid Hob Data pointer */
+  void             *GuidHobData;
+  uint32_t         GuidHobSize;
+  GuidHobData = (VOID *)(*(UINT8 **)&(mGuidHob.Raw) + sizeof (EFI_HOB_GUID_TYPE));
+  GuidHobSize = (uint32_t) ((((EFI_HOB_GUID_TYPE *)(mGuidHob.Raw))->Header.HobLength) - sizeof(EFI_HOB_GUID_TYPE));
+
+  /* DEBUG INFO */
+  printk(BIOS_DEBUG, "FSP NVRAM Hob at 0x%x (size = 0x%x).\n", (uint32_t)GuidHobData, (uint32_t)GuidHobSize);
+
+#if CONFIG_EARLY_CBMEM_INIT
+  struct mrc_data_container *mrcdata;
+  int output_len = ALIGN(GuidHobSize, 16);
+
+  /* Save the MRC S3/Fastboot/ADR restore data to cbmem */
+  cbmem_initialize();
+  mrcdata = cbmem_add
+      (CBMEM_ID_MRCDATA,
+      output_len + sizeof(struct mrc_data_container));
+
+  printk(BIOS_DEBUG, "Relocate MRC DATA from %p to %p (%u bytes)\n",
+      (void *)GuidHobData, mrcdata, output_len);
+
+  mrcdata->mrc_signature = MRC_DATA_SIGNATURE;
+  mrcdata->mrc_data_size = output_len;
+  mrcdata->reserved = 0;
+  memcpy(mrcdata->mrc_data, (void *)GuidHobData,
+      GuidHobSize);
+
+  /* Zero the unused space in aligned buffer. */
+  if (output_len > GuidHobSize)
+      memset(mrcdata->mrc_data + GuidHobSize, 0,
+         output_len - GuidHobSize);
+
+  mrcdata->mrc_checksum = compute_ip_checksum(mrcdata->mrc_data,
+      mrcdata->mrc_data_size);
+#endif
+  }
+
+  /* Rangeley early init */
+  rangeley_early_initialization();
+
+  /* Notify FSP for PostPciEnumeration */
+  FspNotifyPhase (EnumInitPhaseAfterPciEnumeration);
+
+  /* Return to coreboot boot process. */
+  __asm__ __volatile__ (
+      "jmp fsp_init_done\n\t"
+    );
+}
+
+/** C Based Basic Initialization
+ *
+ * Platform configuration with Temp Stack starts here.
+ *
+ */
+void early_init (FSP_INFO_HEADER *fsp_info)
+{
+  FSP_FSP_INIT              FspInitApi;
+  FSP_INIT_PARAMS           FspInitParams;
+  FSP_INIT_RT_BUFFER        FspRtBuffer;
+  VPD_DATA_REGION     *FspVpdRgn;
+  UPD_DATA_REGION     FspUpdRgn;
+  struct mrc_data_container *mrc_cache;
+
+  memset((void*)&FspRtBuffer, 0, sizeof(FSP_INIT_RT_BUFFER));
+  FspRtBuffer.Common.StackTop = (uint32_t *) ROMSTAGE_STACK;
+  FspRtBuffer.Common.UpdDataRgnPtr = (UPD_DATA_REGION *)&FspUpdRgn;
+
+  /* find_current_mrc_cache */
+  if (((mrc_cache = find_current_mrc_cache()) == NULL) || (mrc_cache->mrc_data_size == -1UL)) {
+    printk(BIOS_DEBUG, "MRC cache not present.\n");
+    FspInitParams.NvsBufferPtr = (void *) NULL;
+    FspRtBuffer.Common.BootMode = BOOT_WITH_FULL_CONFIGURATION;
+  } else {
+    printk(BIOS_DEBUG, "MRC cache present at %x.\n", (uint32_t)mrc_cache);
+    FspInitParams.NvsBufferPtr = (void *) (EFI_HOB_GUID_TYPE *) mrc_cache->mrc_data;
+    FspRtBuffer.Common.BootMode = BOOT_WITH_FULL_CONFIGURATION;
+  }
+
+  /* Get VPD region start */
+  FspVpdRgn = (VPD_DATA_REGION *)(fsp_info->ImageBase + fsp_info->CfgRegionOffset);
+
+  /* Verifify the VPD data region is valid */
+  ASSERT((FspVpdRgn->PcdImageRevision == VPD_IMAGE_REV) && (FspVpdRgn->PcdVpdRegionSign == VPD_IMAGE_ID));
+
+  /* Copy default data from Flash */
+  memcpy ((void*)&FspUpdRgn, (void *)(fsp_info->ImageBase + FspVpdRgn->PcdUpdRegionOffset), sizeof(UPD_DATA_REGION));
+
+  /* Verifify the UPD data region is valid */
+  ASSERT(FspUpdRgn.PcdRegionTerminator == 0x55AA);
+
+  /* Override any UPD setting if required */
+  UpdateFspUpdConfigs (&FspUpdRgn);
+
+#if CONFIG_MEMORY_DOWN_ENABLE
+ /*
+  * Setup platform specific structure
+  */
+
+  /* Channel0/Dimm0, DIMM populated */
+  FspRtBuffer.Platform.MemDownDimmConfig[0][0] = (MEM_DOWN_DIMM_CONFIG *)&OemMemoryDownDimmConfig;
+  /* Channel0/Dimm1, not populated */
+  FspRtBuffer.Platform.MemDownDimmConfig[0][1] = (MEM_DOWN_DIMM_CONFIG *)&DummyMemoryDownDimmConfig;
+  /* Channel1/Dimm0, DIMM populated */
+  FspRtBuffer.Platform.MemDownDimmConfig[1][0] = (MEM_DOWN_DIMM_CONFIG *)&OemMemoryDownDimmConfig;
+  /* Channel1/Dimm1, not populated */
+  FspRtBuffer.Platform.MemDownDimmConfig[1][1] = (MEM_DOWN_DIMM_CONFIG *)&DummyMemoryDownDimmConfig;
+#endif
+
+  FspInitParams.RtBufferPtr  = (FSP_INIT_RT_BUFFER *)&FspRtBuffer;
+  FspInitParams.ContinuationFunc = (CONTINUATION_PROC)ContinuationFunc;
+  FspInitApi = (FSP_FSP_INIT)(fsp_info->ImageBase + fsp_info->FspInitEntry);
+  FspInitApi(&FspInitParams);
+
+  /* Should never return. Control will continue from ContinuationFunc */
+  while (1);
+}
+#endif
+
+/** C Based Basic Initialization
+ *
+ * Find FSP header
+ *
+ */
+void __attribute__((optimize("O0"))) find_fsp_header ()
+{
+  volatile register UINT8 *ptr asm ("eax");
+
+#ifdef __PRE_RAM__
+  __asm__ __volatile__ (
+      ".global find_fsp_entry\n\t"
+      "find_fsp_entry:\n\t"
+    );
+#endif
+
+  //
+  // Start at the FSP / FV Header base
+  //
+  ptr = (UINT8 *)CONFIG_FSP_BIN_BASE;
+
+  //
+  // Validate FV signature _FVH
+  //
+  if (((EFI_FIRMWARE_VOLUME_HEADER *)ptr)-> Signature != EFI_FVH_SIGNATURE) {
+    ptr = 0;
+    goto NotFound;
+  }
+
+  //
+  // Add the Ext Header size to the Ext Header base to go to the end of FV
+  // header
+  //
+  ptr += ((EFI_FIRMWARE_VOLUME_HEADER *)ptr)->ExtHeaderOffset;
+  ptr += ((EFI_FIRMWARE_VOLUME_EXT_HEADER *)ptr)->ExtHeaderSize;
+
+  //
+  // Align the end of FV header address to 8 bytes
+  //
+  ptr  = (UINT8 *)(((uint32_t)ptr + 7) & 0xFFFFFFF8);
+
+  //
+  // Now ptr is pointing to thr FFS Header. Verify if the GUID
+  // matches the FSP_INFO_HEADER GUID
+  //
+  if (!CompareGuid(((EFI_GUID) (((EFI_FFS_FILE_HEADER *)ptr)->Name)), ((EFI_GUID) gFspInfoHeaderGuid))) {
+      ptr = 0;
+      goto NotFound;
+  }
+
+  //
+  // Add the FFS Header size to the base to find the Raw section Header
+  //
+  ptr += sizeof(EFI_FFS_FILE_HEADER);
+  if (((EFI_RAW_SECTION *)ptr)->Type != EFI_SECTION_RAW) {
+      ptr = 0;
+      goto NotFound;
+  }
+
+  //
+  // Add the Raw Header size to the base to find the FSP INFO Header
+  //
+  ptr += sizeof(EFI_RAW_SECTION);
+
+NotFound:
+  __asm__ __volatile__ ("ret");
+}
+
+/** C Based Basic Initialization
+ *
+ * Notify Phase for different stage.
+ *
+ */
+void FspNotifyPhase (uint32_t Phase)
+{
+    FSP_NOTFY_PHASE        NotifyPhaseProc;
+    NOTIFY_PHASE_PARAMS    NotifyPhaseParams;
+    FSP_INFO_HEADER *fsp_info_header;
+    EFI_STATUS             Status;
+
+  __asm__ __volatile__ (
+        "call  find_fsp_header      \n\t" /* Call FSP Notify API */
+        "movl %%eax, %0\n\t"
+	: "=m"(fsp_info_header) ::
+	);
+
+    /* call FSP PEI to Notify PostPciEnumeration */
+    NotifyPhaseProc   = (FSP_NOTFY_PHASE)(fsp_info_header->ImageBase + fsp_info_header->NotifyPhaseEntry);
+    NotifyPhaseParams.Phase = Phase;
+    Status = NotifyPhaseProc (&NotifyPhaseParams);
+    if (Status != 0) {
+	printk(BIOS_DEBUG, "FSP API NotifyPhase failed for phase %d!\n", Phase);
+    }
+}
+
+/*
+ * Board Specific routine before handling over to boot loader.
+ */
+#if !defined(__PRE_RAM__)
+void mainboard_cbmem_post_handling(void)
+{
+
+  /* Notify FSP for ReadyToBoot */
+  FspNotifyPhase (EnumInitPhaseReadyToBoot);
+}
+#endif
+
+/**
+  This function overrides the default configurations in the UPD data region.
+
+  @param   UpdDataRgn   A pointer to the UPD_DATA_REGION data strcture.
+
+  @return  None
+**/
+VOID
+UpdateFspUpdConfigs (
+  UPD_DATA_REGION        *FspUpdRgn
+)
+{
+  /* Override any UPD setting if required */
+
+  //
+  // Uncomment the line below to disable LAN device
+  //
+  //FspUpdRgn->PcdEnableLan = 0;
+
+}
diff --git a/src/vendorcode/intel/fsp/rangeley/srx/fsphob.c b/src/vendorcode/intel/fsp/rangeley/srx/fsphob.c
new file mode 100644
index 0000000000..4986d52436
--- /dev/null
+++ b/src/vendorcode/intel/fsp/rangeley/srx/fsphob.c
@@ -0,0 +1,204 @@
+/******************************************************************************
+
+Copyright (C) 2013, Intel Corporation
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions 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 contributors may
+  be used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+  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.
+
+ ******************************************************************************/
+
+/***********************************************************************
+ *
+ * fsphob.c
+ *
+ * HOB infrastructure code.
+ *
+ **********************************************************************/
+#include <string.h>
+
+#include "fsptypes.h"
+#include "fsphob.h"
+
+//
+// Pointer to the HOB should be initialized with the output of FSP INIT PARAMS
+//
+#ifndef __PRE_RAM__
+extern volatile void *FspHobListPtr;
+#endif
+
+/**
+  Reads a 64-bit value from memory that may be unaligned.
+
+  This function returns the 64-bit value pointed to by Buffer. The function
+  guarantees that the read operation does not produce an alignment fault.
+
+  If the Buffer is NULL, then ASSERT().
+
+  @param  Buffer  Pointer to a 64-bit value that may be unaligned.
+
+  @return The 64-bit value read from Buffer.
+
+**/
+UINT64
+EFIAPI
+ReadUnaligned64 (
+  CONST UINT64              *Buffer
+  )
+{
+  ASSERT (Buffer != NULL);
+
+  return *Buffer;
+}
+
+/**
+  Compares two GUIDs.
+
+  This function compares Guid1 to Guid2.  If the GUIDs are identical then TRUE is returned.
+  If there are any bit differences in the two GUIDs, then FALSE is returned.
+
+  If Guid1 is NULL, then ASSERT().
+  If Guid2 is NULL, then ASSERT().
+
+  @param  Guid1       A pointer to a 128 bit GUID.
+  @param  Guid2       A pointer to a 128 bit GUID.
+
+  @retval TRUE        Guid1 and Guid2 are identical.
+  @retval FALSE       Guid1 and Guid2 are not identical.
+
+**/
+BOOLEAN
+EFIAPI
+CompareGuid (
+  CONST EFI_GUID  *Guid1,
+  CONST EFI_GUID  *Guid2
+  )
+{
+  UINT64  LowPartOfGuid1;
+  UINT64  LowPartOfGuid2;
+  UINT64  HighPartOfGuid1;
+  UINT64  HighPartOfGuid2;
+
+  LowPartOfGuid1  = ReadUnaligned64 ((CONST UINT64*) Guid1);
+  LowPartOfGuid2  = ReadUnaligned64 ((CONST UINT64*) Guid2);
+  HighPartOfGuid1 = ReadUnaligned64 ((CONST UINT64*) Guid1 + 1);
+  HighPartOfGuid2 = ReadUnaligned64 ((CONST UINT64*) Guid2 + 1);
+
+  return (BOOLEAN) (LowPartOfGuid1 == LowPartOfGuid2 && HighPartOfGuid1 == HighPartOfGuid2);
+}
+
+/**
+  Returns the pointer to the HOB list.
+**/
+VOID *
+EFIAPI
+GetHobList (
+  VOID
+  )
+{
+#ifndef __PRE_RAM__
+  ASSERT (FspHobListPtr != NULL);
+  return ((VOID *)FspHobListPtr);
+#else
+  return ((VOID *)NULL);
+#endif
+}
+
+/**
+  Returns the next instance of a HOB type from the starting HOB.
+**/
+VOID *
+EFIAPI
+GetNextHob (
+  UINT16                 Type,
+  CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  Hob;
+
+  ASSERT (HobStart != NULL);
+
+  Hob.Raw = (UINT8 *) HobStart;
+  //
+  // Parse the HOB list until end of list or matching type is found.
+  //
+  while (!END_OF_HOB_LIST (Hob)) {
+    if (Hob.Header->HobType == Type) {
+      return Hob.Raw;
+    }
+    Hob.Raw = GET_NEXT_HOB (Hob);
+  }
+  return NULL;
+}
+
+/**
+  Returns the first instance of a HOB type among the whole HOB list.
+**/
+VOID *
+EFIAPI
+GetFirstHob (
+  UINT16                 Type
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextHob (Type, HobList);
+}
+
+/**
+  Returns the next instance of the matched GUID HOB from the starting HOB.
+**/
+VOID *
+EFIAPI
+GetNextGuidHob (
+  CONST EFI_GUID         *Guid,
+  CONST VOID             *HobStart
+  )
+{
+  EFI_PEI_HOB_POINTERS  GuidHob;
+
+  GuidHob.Raw = (UINT8 *) HobStart;
+  while ((GuidHob.Raw = GetNextHob (EFI_HOB_TYPE_GUID_EXTENSION, GuidHob.Raw)) != NULL) {
+    if (CompareGuid (Guid, &GuidHob.Guid->Name)) {
+      break;
+    }
+    GuidHob.Raw = GET_NEXT_HOB (GuidHob);
+  }
+  return GuidHob.Raw;
+}
+
+/**
+  Returns the first instance of the matched GUID HOB among the whole HOB list.
+**/
+VOID *
+EFIAPI
+GetFirstGuidHob (
+  CONST EFI_GUID         *Guid
+  )
+{
+  VOID      *HobList;
+
+  HobList = GetHobList ();
+  return GetNextGuidHob (Guid, HobList);
+}