sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial import.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
bbahnsen
2006-04-21 22:54:32 +00:00
commit 878ddf1fc3
2651 changed files with 624620 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
EdkModulePkg/Universal/Variable/Pei/Ia32/VarMachine.h Normal file
View File

@@ -0,0 +1,27 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
VarMachine.h
Abstract:
Variable Machine Type
--*/
#ifndef _VAR_MACHINE_H
#define _VAR_MACHINE_H
#define ALIGNMENT 1
#endif

27
EdkModulePkg/Universal/Variable/Pei/Ipf/VarMachine.h Normal file
View File

@@ -0,0 +1,27 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
VarMachine.h
Abstract:
Variable Machine Type
--*/
#ifndef _VAR_MACHINE_H
#define _VAR_MACHINE_H
#define ALIGNMENT 8
#endif

563
EdkModulePkg/Universal/Variable/Pei/Variable.c Normal file
View File

@@ -0,0 +1,563 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Variable.c
Abstract:
Framework PEIM to provide the Variable functionality
--*/
#include <Ppi/ReadOnlyVariable.h>
#include <Variable.h>
#include <Library/BaseLib.h>
//
// Module globals
//
static EFI_PEI_READ_ONLY_VARIABLE_PPI mVariablePpi = {
PeiGetVariable,
PeiGetNextVariableName
};
static EFI_PEI_PPI_DESCRIPTOR mPpiListVariable = {
(EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST),
&gEfiPeiReadOnlyVariablePpiGuid,
&mVariablePpi
};
EFI_GUID gEfiVariableIndexTableGuid = EFI_VARIABLE_INDEX_TABLE_GUID;
EFI_STATUS
EFIAPI
PeimInitializeVariableServices (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
/*++
Routine Description:
Provide the functionality of the variable services.
Arguments:
FfsHeadher - The FFS file header
PeiServices - General purpose services available to every PEIM.
Returns:
Status - EFI_SUCCESS if the interface could be successfully
installed
--*/
{
//
// Publish the variable capability to other modules
//
return (**PeiServices).InstallPpi (PeiServices, &mPpiListVariable);
}
VARIABLE_HEADER *
GetNextVariablePtr (
IN VARIABLE_HEADER *Variable
)
/*++
Routine Description:
This code checks if variable header is valid or not.
Arguments:
Variable Pointer to the Variable Header.
Returns:
TRUE Variable header is valid.
FALSE Variable header is not valid.
--*/
{
return (VARIABLE_HEADER *) ((UINTN) GET_VARIABLE_DATA_PTR (Variable) + Variable->DataSize + GET_PAD_SIZE (Variable->DataSize));
}
BOOLEAN
EFIAPI
IsValidVariableHeader (
IN VARIABLE_HEADER *Variable
)
/*++
Routine Description:
This code checks if variable header is valid or not.
Arguments:
Variable Pointer to the Variable Header.
Returns:
TRUE Variable header is valid.
FALSE Variable header is not valid.
--*/
{
if (Variable == NULL ||
Variable->StartId != VARIABLE_DATA ||
(sizeof (VARIABLE_HEADER) + Variable->DataSize + Variable->NameSize) > MAX_VARIABLE_SIZE
) {
return FALSE;
}
return TRUE;
}
VARIABLE_STORE_STATUS
EFIAPI
GetVariableStoreStatus (
IN VARIABLE_STORE_HEADER *VarStoreHeader
)
/*++
Routine Description:
This code gets the pointer to the variable name.
Arguments:
VarStoreHeader Pointer to the Variable Store Header.
Returns:
EfiRaw Variable store is raw
EfiValid Variable store is valid
EfiInvalid Variable store is invalid
--*/
{
if (VarStoreHeader->Signature == VARIABLE_STORE_SIGNATURE &&
VarStoreHeader->Format == VARIABLE_STORE_FORMATTED &&
VarStoreHeader->State == VARIABLE_STORE_HEALTHY
) {
return EfiValid;
}
if (VarStoreHeader->Signature == 0xffffffff &&
VarStoreHeader->Size == 0xffffffff &&
VarStoreHeader->Format == 0xff &&
VarStoreHeader->State == 0xff
) {
return EfiRaw;
} else {
return EfiInvalid;
}
}
EFI_STATUS
CompareWithValidVariable (
IN VARIABLE_HEADER *Variable,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack
)
/*++
Routine Description:
This function compares a variable with variable entries in database
Arguments:
Variable - Pointer to the variable in our database
VariableName - Name of the variable to compare to 'Variable'
VendorGuid - GUID of the variable to compare to 'Variable'
PtrTrack - Variable Track Pointer structure that contains
Variable Information.
Returns:
EFI_SUCCESS - Found match variable
EFI_NOT_FOUND - Variable not found
--*/
{
if (VariableName[0] == 0) {
PtrTrack->CurrPtr = Variable;
return EFI_SUCCESS;
} else {
//
// Don't use CompareGuid function here for performance reasons.
// Instead we compare the GUID a UINT32 at a time and branch
// on the first failed comparison.
//
if ((((INT32 *) VendorGuid)[0] == ((INT32 *) &Variable->VendorGuid)[0]) &&
(((INT32 *) VendorGuid)[1] == ((INT32 *) &Variable->VendorGuid)[1]) &&
(((INT32 *) VendorGuid)[2] == ((INT32 *) &Variable->VendorGuid)[2]) &&
(((INT32 *) VendorGuid)[3] == ((INT32 *) &Variable->VendorGuid)[3])
) {
if (!StrCmp (VariableName, GET_VARIABLE_NAME_PTR (Variable))) {
PtrTrack->CurrPtr = Variable;
return EFI_SUCCESS;
}
}
}
return EFI_NOT_FOUND;
}
EFI_STATUS
EFIAPI
FindVariable (
IN EFI_PEI_SERVICES **PeiServices,
IN CHAR16 *VariableName,
IN EFI_GUID *VendorGuid,
OUT VARIABLE_POINTER_TRACK *PtrTrack
)
/*++
Routine Description:
This code finds variable in storage blocks (Non-Volatile)
Arguments:
PeiServices - General purpose services available to every PEIM.
VariableName - Name of the variable to be found
VendorGuid - Vendor GUID to be found.
PtrTrack - Variable Track Pointer structure that contains
Variable Information.
Returns:
EFI_SUCCESS - Variable found successfully
EFI_NOT_FOUND - Variable not found
EFI_INVALID_PARAMETER - Invalid variable name
--*/
{
PEI_FLASH_MAP_PPI *FlashMapPpi;
EFI_FLASH_SUBAREA_ENTRY *VariableStoreEntry;
UINT32 NumEntries;
EFI_HOB_GUID_TYPE *GuidHob;
VARIABLE_STORE_HEADER *VariableStoreHeader;
VARIABLE_HEADER *Variable;
EFI_STATUS Status;
VARIABLE_HEADER *MaxIndex;
VARIABLE_INDEX_TABLE *IndexTable;
UINT32 Count;
if (VariableName != 0 && VendorGuid == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// No Variable Address equals zero, so 0 as initial value is safe.
//
MaxIndex = 0;
GuidHob = GetFirstGuidHob (&gEfiVariableIndexTableGuid);
if (GuidHob == NULL) {
IndexTable = BuildGuidHob (&gEfiVariableIndexTableGuid, sizeof (VARIABLE_INDEX_TABLE));
IndexTable->Length = 0;
IndexTable->StartPtr = NULL;
IndexTable->EndPtr = NULL;
IndexTable->GoneThrough = 0;
} else {
IndexTable = GET_GUID_HOB_DATA (GuidHob);
for (Count = 0; Count < IndexTable->Length; Count++)
{
#if ALIGNMENT <= 1
MaxIndex = (VARIABLE_HEADER *) (UINTN) (IndexTable->Index[Count] + ((UINTN) IndexTable->StartPtr & 0xFFFF0000));
#else
#if ALIGNMENT >= 4
MaxIndex = (VARIABLE_HEADER *) (UINTN) ((((UINT32)IndexTable->Index[Count]) << 2) + ((UINT32)(UINTN)IndexTable->StartPtr & 0xFFFC0000) );
#endif
#endif
if (CompareWithValidVariable (MaxIndex, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
PtrTrack->StartPtr = IndexTable->StartPtr;
PtrTrack->EndPtr = IndexTable->EndPtr;
return EFI_SUCCESS;
}
}
if (IndexTable->GoneThrough) {
return EFI_NOT_FOUND;
}
}
//
// If not found in HOB, then let's start from the MaxIndex we've found.
//
if (MaxIndex != NULL) {
Variable = GetNextVariablePtr (MaxIndex);
} else {
if (IndexTable->StartPtr || IndexTable->EndPtr) {
Variable = IndexTable->StartPtr;
} else {
//
// Locate FlashMap PPI
//
Status = (**PeiServices).LocatePpi (
PeiServices,
&gPeiFlashMapPpiGuid,
0,
NULL,
(VOID **) &FlashMapPpi
);
ASSERT_EFI_ERROR (Status);
//
// Get flash area info for variables
//
Status = FlashMapPpi->GetAreaInfo (
PeiServices,
FlashMapPpi,
EFI_FLASH_AREA_EFI_VARIABLES,
NULL,
&NumEntries,
&VariableStoreEntry
);
//
// Currently only one non-volatile variable store is supported
//
if (NumEntries != 1) {
return EFI_UNSUPPORTED;
}
VariableStoreHeader = (VARIABLE_STORE_HEADER *) (UINTN) (VariableStoreEntry->Base);
if (GetVariableStoreStatus (VariableStoreHeader) != EfiValid) {
return EFI_UNSUPPORTED;
}
if (~VariableStoreHeader->Size == 0) {
return EFI_NOT_FOUND;
}
//
// Find the variable by walk through non-volatile variable store
//
IndexTable->StartPtr = (VARIABLE_HEADER *) (VariableStoreHeader + 1);
IndexTable->EndPtr = (VARIABLE_HEADER *) ((UINTN) VariableStoreHeader + VariableStoreHeader->Size);
//
// Start Pointers for the variable.
// Actual Data Pointer where data can be written.
//
Variable = IndexTable->StartPtr;
}
}
//
// Find the variable by walk through non-volatile variable store
//
PtrTrack->StartPtr = IndexTable->StartPtr;
PtrTrack->EndPtr = IndexTable->EndPtr;
while (IsValidVariableHeader (Variable) && (Variable <= IndexTable->EndPtr)) {
if (Variable->State == VAR_ADDED) {
//
// Record Variable in VariableIndex HOB
//
if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME)
{
#if ALIGNMENT <= 1
IndexTable->Index[IndexTable->Length++] = (UINT16) (UINTN) Variable;
#else
#if ALIGNMENT >= 4
IndexTable->Index[IndexTable->Length++] = (UINT16) (((UINT32)(UINTN) Variable) >> 2);
#endif
#endif
}
if (CompareWithValidVariable (Variable, VariableName, VendorGuid, PtrTrack) == EFI_SUCCESS) {
return EFI_SUCCESS;
}
}
Variable = GetNextVariablePtr (Variable);
}
//
// If gone through the VariableStore, that means we never find in Firmware any more.
//
if (IndexTable->Length < VARIABLE_INDEX_TABLE_VOLUME) {
IndexTable->GoneThrough = 1;
}
PtrTrack->CurrPtr = NULL;
return EFI_NOT_FOUND;
}
EFI_STATUS
EFIAPI
PeiGetVariable (
IN EFI_PEI_SERVICES **PeiServices,
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data
)
/*++
Routine Description:
Provide the read variable functionality of the variable services.
Arguments:
PeiServices - General purpose services available to every PEIM.
VariableName - The variable name
VendorGuid - The vendor's GUID
Attributes - Pointer to the attribute
DataSize - Size of data
Data - Pointer to data
Returns:
EFI_SUCCESS - The interface could be successfully installed
EFI_NOT_FOUND - The variable could not be discovered
EFI_BUFFER_TOO_SMALL - The caller buffer is not large enough
--*/
{
VARIABLE_POINTER_TRACK Variable;
UINTN VarDataSize;
EFI_STATUS Status;
if (VariableName == NULL || VendorGuid == NULL) {
return EFI_INVALID_PARAMETER;
}
//
// Find existing variable
//
Status = FindVariable (PeiServices, VariableName, VendorGuid, &Variable);
if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
return Status;
}
//
// Get data size
//
VarDataSize = Variable.CurrPtr->DataSize;
if (*DataSize >= VarDataSize) {
(*PeiServices)->CopyMem (Data, GET_VARIABLE_DATA_PTR (Variable.CurrPtr), VarDataSize);
if (Attributes != NULL) {
*Attributes = Variable.CurrPtr->Attributes;
}
*DataSize = VarDataSize;
return EFI_SUCCESS;
} else {
*DataSize = VarDataSize;
return EFI_BUFFER_TOO_SMALL;
}
}
EFI_STATUS
EFIAPI
PeiGetNextVariableName (
IN EFI_PEI_SERVICES **PeiServices,
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
)
/*++
Routine Description:
Provide the get next variable functionality of the variable services.
Arguments:
PeiServices - General purpose services available to every PEIM.
VariabvleNameSize - The variable name's size.
VariableName - A pointer to the variable's name.
VendorGuid - A pointer to the EFI_GUID structure.
VariableNameSize - Size of the variable name
VariableName - The variable name
VendorGuid - The vendor's GUID
Returns:
EFI_SUCCESS - The interface could be successfully installed
EFI_NOT_FOUND - The variable could not be discovered
--*/
{
VARIABLE_POINTER_TRACK Variable;
UINTN VarNameSize;
EFI_STATUS Status;
if (VariableName == NULL) {
return EFI_INVALID_PARAMETER;
}
Status = FindVariable (PeiServices, VariableName, VendorGuid, &Variable);
if (Variable.CurrPtr == NULL || Status != EFI_SUCCESS) {
return Status;
}
if (VariableName[0] != 0) {
//
// If variable name is not NULL, get next variable
//
Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
}
while (!(Variable.CurrPtr >= Variable.EndPtr || Variable.CurrPtr == NULL)) {
if (IsValidVariableHeader (Variable.CurrPtr)) {
if (Variable.CurrPtr->State == VAR_ADDED) {
VarNameSize = (UINTN) Variable.CurrPtr->NameSize;
if (VarNameSize <= *VariableNameSize) {
(*PeiServices)->CopyMem (VariableName, GET_VARIABLE_NAME_PTR (Variable.CurrPtr), VarNameSize);
(*PeiServices)->CopyMem (VendorGuid, &Variable.CurrPtr->VendorGuid, sizeof (EFI_GUID));
Status = EFI_SUCCESS;
} else {
Status = EFI_BUFFER_TOO_SMALL;
}
*VariableNameSize = VarNameSize;
return Status;
//
// Variable is found
//
} else {
Variable.CurrPtr = GetNextVariablePtr (Variable.CurrPtr);
}
} else {
break;
}
}
return EFI_NOT_FOUND;
}

28
EdkModulePkg/Universal/Variable/Pei/Variable.dxs Normal file
View File

@@ -0,0 +1,28 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Variable.dxs
Abstract:
Dependency expression file for Variable PEIM.
--*/
#include <AutoGen.h>
#include <PeimDepex.h>
DEPENDENCY_START
PEI_FLASH_MAP_PPI_GUID
DEPENDENCY_END

154
EdkModulePkg/Universal/Variable/Pei/Variable.h Normal file
View File

@@ -0,0 +1,154 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Variable.h
Abstract:
Tiano PEIM to provide the variable functionality
--*/
#ifndef _PEI_VARIABLE_H
#define _PEI_VARIABLE_H
//
// BugBug: We need relcate the head file.
//
#include <Common/Variable.h>
#define ALIGNMENT 1
//
// Define GET_PAD_SIZE to optimize compiler
//
#if ((ALIGNMENT == 0) || (ALIGNMENT == 1))
#define GET_PAD_SIZE(a) (0)
#else
#define GET_PAD_SIZE(a) (((~a) + 1) & (ALIGNMENT - 1))
#endif
#define GET_VARIABLE_NAME_PTR(a) (CHAR16 *) ((UINTN) (a) + sizeof (VARIABLE_HEADER))
#define GET_VARIABLE_DATA_PTR(a) \
(UINT8 *) ((UINTN) GET_VARIABLE_NAME_PTR (a) + (a)->NameSize + GET_PAD_SIZE ((a)->NameSize))
typedef struct {
VARIABLE_HEADER *CurrPtr;
VARIABLE_HEADER *EndPtr;
VARIABLE_HEADER *StartPtr;
} VARIABLE_POINTER_TRACK;
#define VARIABLE_INDEX_TABLE_VOLUME 122
#define EFI_VARIABLE_INDEX_TABLE_GUID \
{ 0x8cfdb8c8, 0xd6b2, 0x40f3, { 0x8e, 0x97, 0x02, 0x30, 0x7c, 0xc9, 0x8b, 0x7c } }
typedef struct {
UINT16 Length;
UINT16 GoneThrough;
VARIABLE_HEADER *EndPtr;
VARIABLE_HEADER *StartPtr;
UINT16 Index[VARIABLE_INDEX_TABLE_VOLUME];
} VARIABLE_INDEX_TABLE;
extern EFI_GUID gEfiVariableIndexTableGuid;
//
// Functions
//
EFI_STATUS
EFIAPI
PeimInitializeVariableServices (
IN EFI_FFS_FILE_HEADER *FfsHeader,
IN EFI_PEI_SERVICES **PeiServices
)
/*++
Routine Description:
TODO: Add function description
Arguments:
FfsHeader - TODO: add argument description
PeiServices - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
PeiGetVariable (
IN EFI_PEI_SERVICES **PeiServices,
IN CHAR16 *VariableName,
IN EFI_GUID * VendorGuid,
OUT UINT32 *Attributes OPTIONAL,
IN OUT UINTN *DataSize,
OUT VOID *Data
)
/*++
Routine Description:
TODO: Add function description
Arguments:
PeiServices - TODO: add argument description
VariableName - TODO: add argument description
VendorGuid - TODO: add argument description
Attributes - TODO: add argument description
DataSize - TODO: add argument description
Data - TODO: add argument description
Returns:
TODO: add return values
--*/
;
EFI_STATUS
EFIAPI
PeiGetNextVariableName (
IN EFI_PEI_SERVICES **PeiServices,
IN OUT UINTN *VariableNameSize,
IN OUT CHAR16 *VariableName,
IN OUT EFI_GUID *VendorGuid
)
/*++
Routine Description:
TODO: Add function description
Arguments:
PeiServices - TODO: add argument description
VariableNameSize - TODO: add argument description
VariableName - TODO: add argument description
VendorGuid - TODO: add argument description
Returns:
TODO: add return values
--*/
;
#endif // _PEI_VARIABLE_H

43
EdkModulePkg/Universal/Variable/Pei/Variable.mbd Normal file
View File

@@ -0,0 +1,43 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-->
<ModuleBuildDescription xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0 http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">
<MbdHeader>
<BaseName>PeiVariable</BaseName>
<Guid>34C8C28F-B61C-45a2-8F2E-89E46BECC63B</Guid>
<Version>0</Version>
<Description>FIX ME!</Description>
<Copyright>Copyright (c) 2004-2006, Intel Corporation</Copyright>
<License>
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
</License>
<Created>2006-03-12 17:09</Created>
<Modified>2006-03-19 15:19</Modified>
</MbdHeader>
<Libraries>
<Library>PeiReportStatusCodeLib</Library>
<Library>BaseDebugLibReportStatusCode</Library>
<Library>BaseLib</Library>
<Library>PeiMemoryLib</Library>
<Library>PeiCoreLib</Library>
<Library>PeiServicesTablePointerLib</Library>
<Library>PeiHobLib</Library>
<Library>PeimEntryPoint</Library>
</Libraries>
<BuildOptions ToolChain="MSFT">
<ImageEntryPoint>_ModuleEntryPoint</ImageEntryPoint>
</BuildOptions>
</ModuleBuildDescription>

57
EdkModulePkg/Universal/Variable/Pei/Variable.msa Normal file
View File

@@ -0,0 +1,57 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-->
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0 http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">
<MsaHeader>
<BaseName>PeiVariable</BaseName>
<ModuleType>PEIM</ModuleType>
<ComponentType>PE32_PEIM</ComponentType>
<Guid>34C8C28F-B61C-45a2-8F2E-89E46BECC63B</Guid>
<Version>0</Version>
<Abstract>Component description file for DiskIo module.</Abstract>
<Description>FIX ME!</Description>
<Copyright>Copyright (c) 2004-2006, Intel Corporation</Copyright>
<License>
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
</License>
<Specification>0</Specification>
<Created>2006-03-12 17:09</Created>
<Updated>2006-03-19 15:19</Updated>
</MsaHeader>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_CONSUMED">DebugLib</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">PeimEntryPoint</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">PeiCoreLib</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">HobLib</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Filename>Variable.c</Filename>
<Filename>Variable.dxs</Filename>
</SourceFiles>
<Includes>
<PackageName>MdePkg</PackageName>
<PackageName>EdkModulePkg</PackageName>
</Includes>
<PPIs>
<Ppi Usage="ALWAYS_CONSUMED">FlashMap</Ppi>
<Ppi Usage="ALWAYS_CONSUMED">ReadOnlyVariable</Ppi>
</PPIs>
<Externs>
<Extern>
<ModuleEntryPoint>PeimInitializeVariableServices</ModuleEntryPoint>
</Extern>
</Externs>
</ModuleSurfaceArea>

47
EdkModulePkg/Universal/Variable/Pei/build.xml Normal file
View File

@@ -0,0 +1,47 @@
<?xml version="1.0" encoding="UTF-8"?><!-- Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.-->
<project basedir="." default="PeiVariable"><!--Apply external ANT tasks-->
<taskdef resource="GenBuild.tasks"/>
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
<property environment="env"/>
<property name="WORKSPACE_DIR" value="${env.WORKSPACE}"/>
<import file="${WORKSPACE_DIR}\Tools\Conf\BuildMacro.xml"/><!--MODULE_RELATIVE PATH is relative to PACKAGE_DIR-->
<property name="MODULE_RELATIVE_PATH" value="Universal\Variable\Pei"/>
<property name="MODULE_DIR" value="${PACKAGE_DIR}\${MODULE_RELATIVE_PATH}"/>
<property name="COMMON_FILE" value="${WORKSPACE_DIR}\Tools\Conf\Common.xml"/>
<target name="PeiVariable">
<GenBuild baseName="PeiVariable" mbdFilename="${MODULE_DIR}\Variable.mbd" msaFilename="${MODULE_DIR}\Variable.msa"/>
</target>
<target depends="PeiVariable_clean" name="clean"/>
<target depends="PeiVariable_cleanall" name="cleanall"/>
<target name="PeiVariable_clean">
<OutputDirSetup baseName="PeiVariable" mbdFilename="${MODULE_DIR}\Variable.mbd" msaFilename="${MODULE_DIR}\Variable.msa"/>
<if>
<available file="${DEST_DIR_OUTPUT}\PeiVariable_build.xml"/>
<then>
<ant antfile="${DEST_DIR_OUTPUT}\PeiVariable_build.xml" target="clean"/>
</then>
</if>
<delete dir="${DEST_DIR_OUTPUT}" excludes="*.xml"/>
</target>
<target name="PeiVariable_cleanall">
<OutputDirSetup baseName="PeiVariable" mbdFilename="${MODULE_DIR}\Variable.mbd" msaFilename="${MODULE_DIR}\Variable.msa"/>
<if>
<available file="${DEST_DIR_OUTPUT}\PeiVariable_build.xml"/>
<then>
<ant antfile="${DEST_DIR_OUTPUT}\PeiVariable_build.xml" target="cleanall"/>
</then>
</if>
<delete dir="${DEST_DIR_OUTPUT}"/>
<delete dir="${DEST_DIR_DEBUG}"/>
<delete>
<fileset dir="${BIN_DIR}" includes="**PeiVariable*"/>
</delete>
</target>
</project>

27
EdkModulePkg/Universal/Variable/Pei/x64/VarMachine.h Normal file
View File

@@ -0,0 +1,27 @@
/*++
Copyright (c) 2006, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
VarMachine.h
Abstract:
Variable Machine Type
--*/
#ifndef _VAR_MACHINE_H
#define _VAR_MACHINE_H
#define ALIGNMENT 1
#endif