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

EmulatorPkg: formalize line endings

Browse Source 
The patch is the result of running
"BaseTools/Scripts/FormatDosFiles.py EmulatorPkg/"

No functionality impact.

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Ruiyu Ni <ruiyu.ni@intel.com>
Reviewed-by: Hao A Wu <hao.a.wu@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
This commit is contained in:
Ruiyu Ni
2018-08-29 11:39:06 +08:00
parent a07533fab1
commit 79e4f2a56a
51 changed files with 10351 additions and 10351 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
EmulatorPkg/CpuRuntimeDxe/Cpu.c
View File

@ -63,7 +63,7 @@ SMBIOS_TABLE_TYPE4 mCpuSmbiosType4 = {
0, // ProcessorXModel: 4; 0, // ProcessorXModel: 4;
0, // ProcessorXFamily: 8; 0, // ProcessorXFamily: 8;
0, // ProcessorReserved2: 4; 0, // ProcessorReserved2: 4;
}, },
{ // PROCESSOR_FEATURE_FLAGS { // PROCESSOR_FEATURE_FLAGS
0, // ProcessorFpu :1; 0, // ProcessorFpu :1;
0, // ProcessorVme :1; 0, // ProcessorVme :1;
@ -100,13 +100,13 @@ SMBIOS_TABLE_TYPE4 mCpuSmbiosType4 = {
}, },
3, // ProcessorVersion String; 3, // ProcessorVersion String;
{ // Voltage; { // Voltage;
1, // ProcessorVoltageCapability5V :1; 1, // ProcessorVoltageCapability5V :1;
1, // ProcessorVoltageCapability3_3V :1; 1, // ProcessorVoltageCapability3_3V :1;
1, // ProcessorVoltageCapability2_9V :1; 1, // ProcessorVoltageCapability2_9V :1;
0, // ProcessorVoltageCapabilityReserved :1; ///< Bit 3, must be zero. 0, // ProcessorVoltageCapabilityReserved :1; ///< Bit 3, must be zero.
0, // ProcessorVoltageReserved :3; ///< Bits 4-6, must be zero. 0, // ProcessorVoltageReserved :3; ///< Bits 4-6, must be zero.
0 // ProcessorVoltageIndicateLegacy :1; 0 // ProcessorVoltageIndicateLegacy :1;
}, },
0, // ExternalClock; 0, // ExternalClock;
0, // MaxSpeed; 0, // MaxSpeed;
0, // CurrentSpeed; 0, // CurrentSpeed;
@ -151,26 +151,26 @@ CHAR8 *mCpuSmbiosType4Strings[] = {
"Not Found", "Not Found",
NULL NULL
}; };
... ...
LogSmbiosData ( LogSmbiosData (
(EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12, (EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12,
gSmbiosType12Strings gSmbiosType12Strings
); );
@param Template Fixed SMBIOS structure, required. @param Template Fixed SMBIOS structure, required.
@param StringArray Array of strings to convert to an SMBIOS string pack. @param StringArray Array of strings to convert to an SMBIOS string pack.
NULL is OK. NULL is OK.
**/ **/
EFI_STATUS EFI_STATUS
LogSmbiosData ( LogSmbiosData (
IN EFI_SMBIOS_TABLE_HEADER *Template, IN EFI_SMBIOS_TABLE_HEADER *Template,
IN CHAR8 **StringPack IN CHAR8 **StringPack
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_SMBIOS_PROTOCOL *Smbios; EFI_SMBIOS_PROTOCOL *Smbios;
EFI_SMBIOS_HANDLE SmbiosHandle; EFI_SMBIOS_HANDLE SmbiosHandle;
EFI_SMBIOS_TABLE_HEADER *Record; EFI_SMBIOS_TABLE_HEADER *Record;
UINTN Index; UINTN Index;
@ -219,7 +219,7 @@ LogSmbiosData (
Str += StringSize; Str += StringSize;
} }
*Str = 0; *Str = 0;
SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED; SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add ( Status = Smbios->Add (
Smbios, Smbios,
@ -228,7 +228,7 @@ LogSmbiosData (
Record Record
); );
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
FreePool (Record); FreePool (Record);
return Status; return Status;
} }

2
EmulatorPkg/EmuBlockIoDxe/EmuBlockIo.c
View File

@ -61,7 +61,7 @@ EmuBlockIo2Reset (
@param[in] MediaId Id of the media, changes every time the media is @param[in] MediaId Id of the media, changes every time the media is
replaced. replaced.
@param[in] Lba The starting Logical Block Address to read from. @param[in] Lba The starting Logical Block Address to read from.
@param[in, out] Token A pointer to the token associated with the transaction. @param[in, out] Token A pointer to the token associated with the transaction.
@param[in] BufferSize Size of Buffer, must be a multiple of device block size. @param[in] BufferSize Size of Buffer, must be a multiple of device block size.
@param[out] Buffer A pointer to the destination buffer for the data. The @param[out] Buffer A pointer to the destination buffer for the data. The
caller is responsible for either having implicit or caller is responsible for either having implicit or

390
EmulatorPkg/EmuGopDxe/Gop.h
View File

@ -1,195 +1,195 @@
/*++ @file /*++ @file
Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR> Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2010,Apple Inc. All rights reserved.<BR> Portions copyright (c) 2010,Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef __UGA_H_ #ifndef __UGA_H_
#define __UGA_H_ #define __UGA_H_
#include <PiDxe.h> #include <PiDxe.h>
#include <Protocol/GraphicsOutput.h> #include <Protocol/GraphicsOutput.h>
#include <Protocol/SimpleTextIn.h> #include <Protocol/SimpleTextIn.h>
#include <Protocol/SimpleTextInEx.h> #include <Protocol/SimpleTextInEx.h>
#include <Protocol/SimplePointer.h> #include <Protocol/SimplePointer.h>
#include <Protocol/EmuIoThunk.h> #include <Protocol/EmuIoThunk.h>
#include <Protocol/EmuGraphicsWindow.h> #include <Protocol/EmuGraphicsWindow.h>
#include <Guid/EventGroup.h> #include <Guid/EventGroup.h>
#include <Library/DebugLib.h> #include <Library/DebugLib.h>
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
#include <Library/UefiDriverEntryPoint.h> #include <Library/UefiDriverEntryPoint.h>
#include <Library/UefiLib.h> #include <Library/UefiLib.h>
#include <Library/BaseMemoryLib.h> #include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h> #include <Library/UefiBootServicesTableLib.h>
#include <Library/KeyMapLib.h> #include <Library/KeyMapLib.h>
#define MAX_Q 256 #define MAX_Q 256
typedef struct { typedef struct {
UINTN Front; UINTN Front;
UINTN Rear; UINTN Rear;
UINTN Count; UINTN Count;
EFI_INPUT_KEY Q[MAX_Q]; EFI_INPUT_KEY Q[MAX_Q];
} GOP_QUEUE_FIXED; } GOP_QUEUE_FIXED;
#define EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE SIGNATURE_32 ('U', 'g', 'S', 'n') #define EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE SIGNATURE_32 ('U', 'g', 'S', 'n')
typedef struct _EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY { typedef struct _EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY {
UINTN Signature; UINTN Signature;
EFI_HANDLE NotifyHandle; EFI_HANDLE NotifyHandle;
EFI_KEY_DATA KeyData; EFI_KEY_DATA KeyData;
EFI_KEY_NOTIFY_FUNCTION KeyNotificationFn; EFI_KEY_NOTIFY_FUNCTION KeyNotificationFn;
EFI_EVENT Event; EFI_EVENT Event;
LIST_ENTRY NotifyEntry; LIST_ENTRY NotifyEntry;
} EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY; } EMU_GOP_SIMPLE_TEXTIN_EX_NOTIFY;
#define GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER 0xffff #define GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER 0xffff
typedef struct { typedef struct {
UINT32 HorizontalResolution; UINT32 HorizontalResolution;
UINT32 VerticalResolution; UINT32 VerticalResolution;
UINT32 ColorDepth; UINT32 ColorDepth;
UINT32 RefreshRate; UINT32 RefreshRate;
} GOP_MODE_DATA; } GOP_MODE_DATA;
extern EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding; extern EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding;
extern EFI_COMPONENT_NAME_PROTOCOL gEmuGopComponentName; extern EFI_COMPONENT_NAME_PROTOCOL gEmuGopComponentName;
#define EMU_UGA_CLASS_NAME L"EmuGopWindow" #define EMU_UGA_CLASS_NAME L"EmuGopWindow"
#define GOP_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('G', 'o', 'p', 'N') #define GOP_PRIVATE_DATA_SIGNATURE SIGNATURE_32 ('G', 'o', 'p', 'N')
typedef struct { typedef struct {
UINT64 Signature; UINT64 Signature;
EFI_HANDLE Handle; EFI_HANDLE Handle;
EFI_GRAPHICS_OUTPUT_PROTOCOL GraphicsOutput; EFI_GRAPHICS_OUTPUT_PROTOCOL GraphicsOutput;
EFI_SIMPLE_TEXT_INPUT_PROTOCOL SimpleTextIn; EFI_SIMPLE_TEXT_INPUT_PROTOCOL SimpleTextIn;
EFI_SIMPLE_POINTER_PROTOCOL SimplePointer; EFI_SIMPLE_POINTER_PROTOCOL SimplePointer;
EMU_IO_THUNK_PROTOCOL *EmuIoThunk; EMU_IO_THUNK_PROTOCOL *EmuIoThunk;
EMU_GRAPHICS_WINDOW_PROTOCOL *EmuGraphicsWindow; EMU_GRAPHICS_WINDOW_PROTOCOL *EmuGraphicsWindow;
EFI_UNICODE_STRING_TABLE *ControllerNameTable; EFI_UNICODE_STRING_TABLE *ControllerNameTable;
EFI_SIMPLE_POINTER_MODE PointerMode; EFI_SIMPLE_POINTER_MODE PointerMode;
// //
// GOP Private Data for QueryMode () // GOP Private Data for QueryMode ()
// //
GOP_MODE_DATA *ModeData; GOP_MODE_DATA *ModeData;
// //
// UGA Private Data knowing when to start hardware // UGA Private Data knowing when to start hardware
// //
BOOLEAN HardwareNeedsStarting; BOOLEAN HardwareNeedsStarting;
CHAR16 *WindowName; CHAR16 *WindowName;
GOP_QUEUE_FIXED Queue; GOP_QUEUE_FIXED Queue;
EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL SimpleTextInEx; EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL SimpleTextInEx;
EFI_KEY_STATE KeyState; EFI_KEY_STATE KeyState;
LIST_ENTRY NotifyList; LIST_ENTRY NotifyList;
} GOP_PRIVATE_DATA; } GOP_PRIVATE_DATA;
#define GOP_PRIVATE_DATA_FROM_THIS(a) \ #define GOP_PRIVATE_DATA_FROM_THIS(a) \
CR(a, GOP_PRIVATE_DATA, GraphicsOutput, GOP_PRIVATE_DATA_SIGNATURE) CR(a, GOP_PRIVATE_DATA, GraphicsOutput, GOP_PRIVATE_DATA_SIGNATURE)
#define GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS(a) \ #define GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS(a) \
CR(a, GOP_PRIVATE_DATA, SimpleTextIn, GOP_PRIVATE_DATA_SIGNATURE) CR(a, GOP_PRIVATE_DATA, SimpleTextIn, GOP_PRIVATE_DATA_SIGNATURE)
#define GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS(a) \ #define GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS(a) \
CR(a, GOP_PRIVATE_DATA, SimpleTextInEx, GOP_PRIVATE_DATA_SIGNATURE) CR(a, GOP_PRIVATE_DATA, SimpleTextInEx, GOP_PRIVATE_DATA_SIGNATURE)
#define GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS(a) \ #define GOP_PRIVATE_DATA_FROM_POINTER_MODE_THIS(a) \
CR(a, GOP_PRIVATE_DATA, SimplePointer, GOP_PRIVATE_DATA_SIGNATURE) CR(a, GOP_PRIVATE_DATA, SimplePointer, GOP_PRIVATE_DATA_SIGNATURE)
// //
// Global Protocol Variables // Global Protocol Variables
// //
extern EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding; extern EFI_DRIVER_BINDING_PROTOCOL gEmuGopDriverBinding;
extern EFI_COMPONENT_NAME_PROTOCOL gEmuGopComponentName; extern EFI_COMPONENT_NAME_PROTOCOL gEmuGopComponentName;
extern EFI_COMPONENT_NAME2_PROTOCOL gEmuGopComponentName2; extern EFI_COMPONENT_NAME2_PROTOCOL gEmuGopComponentName2;
// //
// Gop Hardware abstraction internal worker functions // Gop Hardware abstraction internal worker functions
// //
EFI_STATUS EFI_STATUS
EmuGopSupported ( EmuGopSupported (
IN EMU_IO_THUNK_PROTOCOL *EmuIoThunk IN EMU_IO_THUNK_PROTOCOL *EmuIoThunk
); );
EFI_STATUS EFI_STATUS
EmuGopConstructor ( EmuGopConstructor (
IN GOP_PRIVATE_DATA *Private IN GOP_PRIVATE_DATA *Private
); );
EFI_STATUS EFI_STATUS
EmuGopDestructor ( EmuGopDestructor (
IN GOP_PRIVATE_DATA *Private IN GOP_PRIVATE_DATA *Private
); );
EFI_STATUS EFI_STATUS
GopPrivateAddQ ( GopPrivateAddQ (
IN GOP_PRIVATE_DATA *Private, IN GOP_PRIVATE_DATA *Private,
IN EFI_INPUT_KEY Key IN EFI_INPUT_KEY Key
); );
EFI_STATUS EFI_STATUS
EmuGopInitializeSimpleTextInForWindow ( EmuGopInitializeSimpleTextInForWindow (
IN GOP_PRIVATE_DATA *Private IN GOP_PRIVATE_DATA *Private
); );
EFI_STATUS EFI_STATUS
EmuGopInitializeSimplePointerForWindow ( EmuGopInitializeSimplePointerForWindow (
IN GOP_PRIVATE_DATA *Private IN GOP_PRIVATE_DATA *Private
); );
EFI_STATUS EFI_STATUS
EmuGopStartWindow ( EmuGopStartWindow (
IN GOP_PRIVATE_DATA *Private, IN GOP_PRIVATE_DATA *Private,
IN UINT32 HorizontalResolution, IN UINT32 HorizontalResolution,
IN UINT32 VerticalResolution, IN UINT32 VerticalResolution,
IN UINT32 ColorDepth, IN UINT32 ColorDepth,
IN UINT32 RefreshRate IN UINT32 RefreshRate
); );
VOID VOID
EFIAPI EFIAPI
ShutdownGopEvent ( ShutdownGopEvent (
IN EFI_EVENT Event, IN EFI_EVENT Event,
IN VOID *Context IN VOID *Context
); );
VOID VOID
EFIAPI EFIAPI
GopPrivateMakeCallbackFunction ( GopPrivateMakeCallbackFunction (
IN VOID *Context, IN VOID *Context,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
VOID VOID
EFIAPI EFIAPI
GopPrivateBreakCallbackFunction ( GopPrivateBreakCallbackFunction (
IN VOID *Context, IN VOID *Context,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
#endif #endif

1800
EmulatorPkg/EmuGopDxe/GopInput.c
View File

File diff suppressed because it is too large Load Diff

832
EmulatorPkg/EmuGopDxe/GopScreen.c
View File

@ -1,416 +1,416 @@
/*++ @file /*++ @file
Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR> Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2010 - 2011, Apple Inc. All rights reserved. Portions copyright (c) 2010 - 2011, Apple Inc. All rights reserved.
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name: Module Name:
EmuGopScreen.c EmuGopScreen.c
Abstract: Abstract:
This file produces the graphics abstration of UGA. It is called by This file produces the graphics abstration of UGA. It is called by
EmuGopDriver.c file which deals with the EFI 1.1 driver model. EmuGopDriver.c file which deals with the EFI 1.1 driver model.
This file just does graphics. This file just does graphics.
**/ **/
#include "Gop.h" #include "Gop.h"
EFI_EVENT mGopScreenExitBootServicesEvent; EFI_EVENT mGopScreenExitBootServicesEvent;
GOP_MODE_DATA mGopModeData[] = { GOP_MODE_DATA mGopModeData[] = {
{ 800, 600, 0, 0 }, { 800, 600, 0, 0 },
{ 640, 480, 0, 0 }, { 640, 480, 0, 0 },
{ 720, 400, 0, 0 }, { 720, 400, 0, 0 },
{1024, 768, 0, 0 }, {1024, 768, 0, 0 },
{1280, 1024, 0, 0 } {1280, 1024, 0, 0 }
}; };
/** /**
Returns information for an available graphics mode that the graphics device Returns information for an available graphics mode that the graphics device
and the set of active video output devices supports. and the set of active video output devices supports.
@param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance. @param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
@param ModeNumber The mode number to return information on. @param ModeNumber The mode number to return information on.
@param SizeOfInfo A pointer to the size, in bytes, of the Info buffer. @param SizeOfInfo A pointer to the size, in bytes, of the Info buffer.
@param Info A pointer to callee allocated buffer that returns information about ModeNumber. @param Info A pointer to callee allocated buffer that returns information about ModeNumber.
@retval EFI_SUCCESS Mode information returned. @retval EFI_SUCCESS Mode information returned.
@retval EFI_BUFFER_TOO_SMALL The Info buffer was too small. @retval EFI_BUFFER_TOO_SMALL The Info buffer was too small.
@retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the video mode. @retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the video mode.
@retval EFI_NOT_STARTED Video display is not initialized. Call SetMode () @retval EFI_NOT_STARTED Video display is not initialized. Call SetMode ()
@retval EFI_INVALID_PARAMETER One of the input args was NULL. @retval EFI_INVALID_PARAMETER One of the input args was NULL.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
EmuGopQuerytMode ( EmuGopQuerytMode (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN UINT32 ModeNumber, IN UINT32 ModeNumber,
OUT UINTN *SizeOfInfo, OUT UINTN *SizeOfInfo,
OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION **Info
) )
{ {
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
Private = GOP_PRIVATE_DATA_FROM_THIS (This); Private = GOP_PRIVATE_DATA_FROM_THIS (This);
if (Info == NULL || SizeOfInfo == NULL || (UINTN) ModeNumber >= This->Mode->MaxMode) { if (Info == NULL || SizeOfInfo == NULL || (UINTN) ModeNumber >= This->Mode->MaxMode) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
*Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)); *Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
if (*Info == NULL) { if (*Info == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
*SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION); *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
(*Info)->Version = 0; (*Info)->Version = 0;
(*Info)->HorizontalResolution = Private->ModeData[ModeNumber].HorizontalResolution; (*Info)->HorizontalResolution = Private->ModeData[ModeNumber].HorizontalResolution;
(*Info)->VerticalResolution = Private->ModeData[ModeNumber].VerticalResolution; (*Info)->VerticalResolution = Private->ModeData[ModeNumber].VerticalResolution;
(*Info)->PixelFormat = PixelBltOnly; (*Info)->PixelFormat = PixelBltOnly;
(*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution; (*Info)->PixelsPerScanLine = (*Info)->HorizontalResolution;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
/** /**
Set the video device into the specified mode and clears the visible portions of Set the video device into the specified mode and clears the visible portions of
the output display to black. the output display to black.
@param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance. @param This The EFI_GRAPHICS_OUTPUT_PROTOCOL instance.
@param ModeNumber Abstraction that defines the current video mode. @param ModeNumber Abstraction that defines the current video mode.
@retval EFI_SUCCESS The graphics mode specified by ModeNumber was selected. @retval EFI_SUCCESS The graphics mode specified by ModeNumber was selected.
@retval EFI_DEVICE_ERROR The device had an error and could not complete the request. @retval EFI_DEVICE_ERROR The device had an error and could not complete the request.
@retval EFI_UNSUPPORTED ModeNumber is not supported by this device. @retval EFI_UNSUPPORTED ModeNumber is not supported by this device.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
EmuGopSetMode ( EmuGopSetMode (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN UINT32 ModeNumber IN UINT32 ModeNumber
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
GOP_MODE_DATA *ModeData; GOP_MODE_DATA *ModeData;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL Fill; EFI_GRAPHICS_OUTPUT_BLT_PIXEL Fill;
Private = GOP_PRIVATE_DATA_FROM_THIS (This); Private = GOP_PRIVATE_DATA_FROM_THIS (This);
if (ModeNumber >= This->Mode->MaxMode) { if (ModeNumber >= This->Mode->MaxMode) {
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
} }
ModeData = &Private->ModeData[ModeNumber]; ModeData = &Private->ModeData[ModeNumber];
This->Mode->Mode = ModeNumber; This->Mode->Mode = ModeNumber;
Private->GraphicsOutput.Mode->Info->HorizontalResolution = ModeData->HorizontalResolution; Private->GraphicsOutput.Mode->Info->HorizontalResolution = ModeData->HorizontalResolution;
Private->GraphicsOutput.Mode->Info->VerticalResolution = ModeData->VerticalResolution; Private->GraphicsOutput.Mode->Info->VerticalResolution = ModeData->VerticalResolution;
Private->GraphicsOutput.Mode->Info->PixelsPerScanLine = ModeData->HorizontalResolution; Private->GraphicsOutput.Mode->Info->PixelsPerScanLine = ModeData->HorizontalResolution;
if (Private->HardwareNeedsStarting) { if (Private->HardwareNeedsStarting) {
Status = EmuGopStartWindow ( Status = EmuGopStartWindow (
Private, Private,
ModeData->HorizontalResolution, ModeData->HorizontalResolution,
ModeData->VerticalResolution, ModeData->VerticalResolution,
ModeData->ColorDepth, ModeData->ColorDepth,
ModeData->RefreshRate ModeData->RefreshRate
); );
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {
return EFI_DEVICE_ERROR; return EFI_DEVICE_ERROR;
} }
Private->HardwareNeedsStarting = FALSE; Private->HardwareNeedsStarting = FALSE;
} }
Status = Private->EmuGraphicsWindow->Size( Status = Private->EmuGraphicsWindow->Size(
Private->EmuGraphicsWindow, Private->EmuGraphicsWindow,
ModeData->HorizontalResolution, ModeData->HorizontalResolution,
ModeData->VerticalResolution ModeData->VerticalResolution
); );
Fill.Red = 0x7f; Fill.Red = 0x7f;
Fill.Green = 0x7F; Fill.Green = 0x7F;
Fill.Blue = 0x7f; Fill.Blue = 0x7f;
This->Blt ( This->Blt (
This, This,
&Fill, &Fill,
EfiBltVideoFill, EfiBltVideoFill,
0, 0,
0, 0,
0, 0,
0, 0,
ModeData->HorizontalResolution, ModeData->HorizontalResolution,
ModeData->VerticalResolution, ModeData->VerticalResolution,
ModeData->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) ModeData->HorizontalResolution * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
); );
return EFI_SUCCESS; return EFI_SUCCESS;
} }
/** /**
Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer. Blt a rectangle of pixels on the graphics screen. Blt stands for BLock Transfer.
@param This Protocol instance pointer. @param This Protocol instance pointer.
@param BltBuffer Buffer containing data to blit into video buffer. This @param BltBuffer Buffer containing data to blit into video buffer. This
buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL) buffer has a size of Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
@param BltOperation Operation to perform on BlitBuffer and video memory @param BltOperation Operation to perform on BlitBuffer and video memory
@param SourceX X coordinate of source for the BltBuffer. @param SourceX X coordinate of source for the BltBuffer.
@param SourceY Y coordinate of source for the BltBuffer. @param SourceY Y coordinate of source for the BltBuffer.
@param DestinationX X coordinate of destination for the BltBuffer. @param DestinationX X coordinate of destination for the BltBuffer.
@param DestinationY Y coordinate of destination for the BltBuffer. @param DestinationY Y coordinate of destination for the BltBuffer.
@param Width Width of rectangle in BltBuffer in pixels. @param Width Width of rectangle in BltBuffer in pixels.
@param Height Hight of rectangle in BltBuffer in pixels. @param Height Hight of rectangle in BltBuffer in pixels.
@param Delta OPTIONAL @param Delta OPTIONAL
@retval EFI_SUCCESS The Blt operation completed. @retval EFI_SUCCESS The Blt operation completed.
@retval EFI_INVALID_PARAMETER BltOperation is not valid. @retval EFI_INVALID_PARAMETER BltOperation is not valid.
@retval EFI_DEVICE_ERROR A hardware error occured writting to the video buffer. @retval EFI_DEVICE_ERROR A hardware error occured writting to the video buffer.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
EmuGopBlt ( EmuGopBlt (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This, IN EFI_GRAPHICS_OUTPUT_PROTOCOL *This,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer, OPTIONAL
IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation, IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation,
IN UINTN SourceX, IN UINTN SourceX,
IN UINTN SourceY, IN UINTN SourceY,
IN UINTN DestinationX, IN UINTN DestinationX,
IN UINTN DestinationY, IN UINTN DestinationY,
IN UINTN Width, IN UINTN Width,
IN UINTN Height, IN UINTN Height,
IN UINTN Delta OPTIONAL IN UINTN Delta OPTIONAL
) )
{ {
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
EFI_TPL OriginalTPL; EFI_TPL OriginalTPL;
EFI_STATUS Status; EFI_STATUS Status;
EMU_GRAPHICS_WINDOWS__BLT_ARGS GopBltArgs; EMU_GRAPHICS_WINDOWS__BLT_ARGS GopBltArgs;
Private = GOP_PRIVATE_DATA_FROM_THIS (This); Private = GOP_PRIVATE_DATA_FROM_THIS (This);
if ((UINT32)BltOperation >= EfiGraphicsOutputBltOperationMax) { if ((UINT32)BltOperation >= EfiGraphicsOutputBltOperationMax) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (Width == 0 || Height == 0) { if (Width == 0 || Height == 0) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
// //
// If Delta is zero, then the entire BltBuffer is being used, so Delta // If Delta is zero, then the entire BltBuffer is being used, so Delta
// is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size, // is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size,
// the number of bytes in each row can be computed. // the number of bytes in each row can be computed.
// //
if (Delta == 0) { if (Delta == 0) {
Delta = Width * sizeof (EFI_UGA_PIXEL); Delta = Width * sizeof (EFI_UGA_PIXEL);
} }
// //
// We have to raise to TPL Notify, so we make an atomic write the frame buffer. // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
// We would not want a timer based event (Cursor, ...) to come in while we are // We would not want a timer based event (Cursor, ...) to come in while we are
// doing this operation. // doing this operation.
// //
OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY); OriginalTPL = gBS->RaiseTPL (TPL_NOTIFY);
// //
// Pack UGA Draw protocol parameters to EMU_GRAPHICS_WINDOWS__BLT_ARGS structure to adapt to // Pack UGA Draw protocol parameters to EMU_GRAPHICS_WINDOWS__BLT_ARGS structure to adapt to
// GopBlt() API of Unix UGA IO protocol. // GopBlt() API of Unix UGA IO protocol.
// //
GopBltArgs.DestinationX = DestinationX; GopBltArgs.DestinationX = DestinationX;
GopBltArgs.DestinationY = DestinationY; GopBltArgs.DestinationY = DestinationY;
GopBltArgs.Height = Height; GopBltArgs.Height = Height;
GopBltArgs.Width = Width; GopBltArgs.Width = Width;
GopBltArgs.SourceX = SourceX; GopBltArgs.SourceX = SourceX;
GopBltArgs.SourceY = SourceY; GopBltArgs.SourceY = SourceY;
GopBltArgs.Delta = Delta; GopBltArgs.Delta = Delta;
Status = Private->EmuGraphicsWindow->Blt ( Status = Private->EmuGraphicsWindow->Blt (
Private->EmuGraphicsWindow, Private->EmuGraphicsWindow,
(EFI_UGA_PIXEL *)BltBuffer, (EFI_UGA_PIXEL *)BltBuffer,
(EFI_UGA_BLT_OPERATION)BltOperation, (EFI_UGA_BLT_OPERATION)BltOperation,
&GopBltArgs &GopBltArgs
); );
gBS->RestoreTPL (OriginalTPL); gBS->RestoreTPL (OriginalTPL);
return Status; return Status;
} }
// //
// Construction and Destruction functions // Construction and Destruction functions
// //
EFI_STATUS EFI_STATUS
EmuGopSupported ( EmuGopSupported (
IN EMU_IO_THUNK_PROTOCOL *EmuIoThunk IN EMU_IO_THUNK_PROTOCOL *EmuIoThunk
) )
{ {
// //
// Check to see if the IO abstraction represents a device type we support. // Check to see if the IO abstraction represents a device type we support.
// //
// This would be replaced a check of PCI subsystem ID, etc. // This would be replaced a check of PCI subsystem ID, etc.
// //
if (!CompareGuid (EmuIoThunk->Protocol, &gEmuGraphicsWindowProtocolGuid)) { if (!CompareGuid (EmuIoThunk->Protocol, &gEmuGraphicsWindowProtocolGuid)) {
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
} }
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
EmuGopStartWindow ( EmuGopStartWindow (
IN GOP_PRIVATE_DATA *Private, IN GOP_PRIVATE_DATA *Private,
IN UINT32 HorizontalResolution, IN UINT32 HorizontalResolution,
IN UINT32 VerticalResolution, IN UINT32 VerticalResolution,
IN UINT32 ColorDepth, IN UINT32 ColorDepth,
IN UINT32 RefreshRate IN UINT32 RefreshRate
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
// //
// Register to be notified on exit boot services so we can destroy the window. // Register to be notified on exit boot services so we can destroy the window.
// //
Status = gBS->CreateEvent ( Status = gBS->CreateEvent (
EVT_SIGNAL_EXIT_BOOT_SERVICES, EVT_SIGNAL_EXIT_BOOT_SERVICES,
TPL_CALLBACK, TPL_CALLBACK,
ShutdownGopEvent, ShutdownGopEvent,
Private, Private,
&mGopScreenExitBootServicesEvent &mGopScreenExitBootServicesEvent
); );
Status = Private->EmuIoThunk->Open (Private->EmuIoThunk); Status = Private->EmuIoThunk->Open (Private->EmuIoThunk);
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
Private->EmuGraphicsWindow = Private->EmuIoThunk->Interface; Private->EmuGraphicsWindow = Private->EmuIoThunk->Interface;
// Register callback to support RegisterKeyNotify() // Register callback to support RegisterKeyNotify()
Status = Private->EmuGraphicsWindow->RegisterKeyNotify ( Status = Private->EmuGraphicsWindow->RegisterKeyNotify (
Private->EmuGraphicsWindow, Private->EmuGraphicsWindow,
GopPrivateMakeCallbackFunction, GopPrivateMakeCallbackFunction,
GopPrivateBreakCallbackFunction, GopPrivateBreakCallbackFunction,
Private Private
); );
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
} }
return Status; return Status;
} }
EFI_STATUS EFI_STATUS
EmuGopConstructor ( EmuGopConstructor (
GOP_PRIVATE_DATA *Private GOP_PRIVATE_DATA *Private
) )
{ {
Private->ModeData = mGopModeData; Private->ModeData = mGopModeData;
Private->GraphicsOutput.QueryMode = EmuGopQuerytMode; Private->GraphicsOutput.QueryMode = EmuGopQuerytMode;
Private->GraphicsOutput.SetMode = EmuGopSetMode; Private->GraphicsOutput.SetMode = EmuGopSetMode;
Private->GraphicsOutput.Blt = EmuGopBlt; Private->GraphicsOutput.Blt = EmuGopBlt;
// //
// Allocate buffer for Graphics Output Protocol mode information // Allocate buffer for Graphics Output Protocol mode information
// //
Private->GraphicsOutput.Mode = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE)); Private->GraphicsOutput.Mode = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE));
if (Private->GraphicsOutput.Mode == NULL) { if (Private->GraphicsOutput.Mode == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
Private->GraphicsOutput.Mode->Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION)); Private->GraphicsOutput.Mode->Info = AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION));
if (Private->GraphicsOutput.Mode->Info == NULL) { if (Private->GraphicsOutput.Mode->Info == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
Private->GraphicsOutput.Mode->MaxMode = sizeof(mGopModeData) / sizeof(GOP_MODE_DATA); Private->GraphicsOutput.Mode->MaxMode = sizeof(mGopModeData) / sizeof(GOP_MODE_DATA);
// //
// Till now, we have no idea about the window size. // Till now, we have no idea about the window size.
// //
Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER; Private->GraphicsOutput.Mode->Mode = GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER;
Private->GraphicsOutput.Mode->Info->Version = 0; Private->GraphicsOutput.Mode->Info->Version = 0;
Private->GraphicsOutput.Mode->Info->HorizontalResolution = 0; Private->GraphicsOutput.Mode->Info->HorizontalResolution = 0;
Private->GraphicsOutput.Mode->Info->VerticalResolution = 0; Private->GraphicsOutput.Mode->Info->VerticalResolution = 0;
Private->GraphicsOutput.Mode->Info->PixelFormat = PixelBltOnly; Private->GraphicsOutput.Mode->Info->PixelFormat = PixelBltOnly;
Private->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION); Private->GraphicsOutput.Mode->SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);
Private->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL; Private->GraphicsOutput.Mode->FrameBufferBase = (EFI_PHYSICAL_ADDRESS) (UINTN) NULL;
Private->GraphicsOutput.Mode->FrameBufferSize = 0; Private->GraphicsOutput.Mode->FrameBufferSize = 0;
Private->HardwareNeedsStarting = TRUE; Private->HardwareNeedsStarting = TRUE;
Private->EmuGraphicsWindow = NULL; Private->EmuGraphicsWindow = NULL;
EmuGopInitializeSimpleTextInForWindow (Private); EmuGopInitializeSimpleTextInForWindow (Private);
EmuGopInitializeSimplePointerForWindow (Private); EmuGopInitializeSimplePointerForWindow (Private);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
EmuGopDestructor ( EmuGopDestructor (
GOP_PRIVATE_DATA *Private GOP_PRIVATE_DATA *Private
) )
{ {
if (!Private->HardwareNeedsStarting) { if (!Private->HardwareNeedsStarting) {
Private->EmuIoThunk->Close (Private->EmuIoThunk); Private->EmuIoThunk->Close (Private->EmuIoThunk);
Private->EmuGraphicsWindow = NULL; Private->EmuGraphicsWindow = NULL;
} }
// //
// Free graphics output protocol occupied resource // Free graphics output protocol occupied resource
// //
if (Private->GraphicsOutput.Mode != NULL) { if (Private->GraphicsOutput.Mode != NULL) {
if (Private->GraphicsOutput.Mode->Info != NULL) { if (Private->GraphicsOutput.Mode->Info != NULL) {
FreePool (Private->GraphicsOutput.Mode->Info); FreePool (Private->GraphicsOutput.Mode->Info);
} }
FreePool (Private->GraphicsOutput.Mode); FreePool (Private->GraphicsOutput.Mode);
} }
return EFI_SUCCESS; return EFI_SUCCESS;
} }
VOID VOID
EFIAPI EFIAPI
ShutdownGopEvent ( ShutdownGopEvent (
IN EFI_EVENT Event, IN EFI_EVENT Event,
IN VOID *Context IN VOID *Context
) )
/*++ /*++
Routine Description: Routine Description:
This is the UGA screen's callback notification function for exit-boot-services. This is the UGA screen's callback notification function for exit-boot-services.
All we do here is call EmuGopDestructor(). All we do here is call EmuGopDestructor().
Arguments: Arguments:
Event - not used Event - not used
Context - pointer to the Private structure. Context - pointer to the Private structure.
Returns: Returns:
None. None.
**/ **/
{ {
EmuGopDestructor (Context); EmuGopDestructor (Context);
} }

2
EmulatorPkg/EmuSnpDxe/EmuSnpDxe.c
View File

@ -42,7 +42,7 @@ EFI_SIMPLE_NETWORK_PROTOCOL gEmuSnpTemplate = {
NULL // Mode NULL // Mode
}; };
EFI_SIMPLE_NETWORK_MODE gEmuSnpModeTemplate = { EFI_SIMPLE_NETWORK_MODE gEmuSnpModeTemplate = {
EfiSimpleNetworkStopped, // State EfiSimpleNetworkStopped, // State
NET_ETHER_ADDR_LEN, // HwAddressSize NET_ETHER_ADDR_LEN, // HwAddressSize
NET_ETHER_HEADER_SIZE, // MediaHeaderSize NET_ETHER_HEADER_SIZE, // MediaHeaderSize

76
EmulatorPkg/Include/Library/EmuMagicPageLib.h
View File

@ -1,38 +1,38 @@
/*++ @file /*++ @file
The PCD, gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage, points to a magic page The PCD, gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage, points to a magic page
of memory that is like SRAM on an embedded system. This file defines what goes of memory that is like SRAM on an embedded system. This file defines what goes
where in the magic page. where in the magic page.
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef __EMU_MAGIC_PAGE_LIB_H__ #ifndef __EMU_MAGIC_PAGE_LIB_H__
#define __EMU_MAGIC_PAGE_LIB_H__ #define __EMU_MAGIC_PAGE_LIB_H__
#include <PiPei.h> #include <PiPei.h>
#include <Library/PcdLib.h> #include <Library/PcdLib.h>
#include <Protocol/EmuThunk.h> #include <Protocol/EmuThunk.h>
typedef struct { typedef struct {
// Used by PEI Core and PEIMs to store the PEI Services pointer. // Used by PEI Core and PEIMs to store the PEI Services pointer.
// Privilege issues prevent using the PI mechanism in the emulator. // Privilege issues prevent using the PI mechanism in the emulator.
CONST EFI_PEI_SERVICES **PeiServicesTablePointer; CONST EFI_PEI_SERVICES **PeiServicesTablePointer;
// Used by SecPeiServicesLib // Used by SecPeiServicesLib
EFI_PEI_PPI_DESCRIPTOR *PpiList; EFI_PEI_PPI_DESCRIPTOR *PpiList;
// Needed by PEI PEI PeCoffLoaderExtraActionLib // Needed by PEI PEI PeCoffLoaderExtraActionLib
EMU_THUNK_PROTOCOL *Thunk; EMU_THUNK_PROTOCOL *Thunk;
} EMU_MAGIC_PAGE_LAYOUT; } EMU_MAGIC_PAGE_LAYOUT;
#define EMU_MAGIC_PAGE() ((EMU_MAGIC_PAGE_LAYOUT *)((UINTN)PcdGet64 (PcdPeiServicesTablePage))) #define EMU_MAGIC_PAGE() ((EMU_MAGIC_PAGE_LAYOUT *)((UINTN)PcdGet64 (PcdPeiServicesTablePage)))
#endif #endif

84
EmulatorPkg/Include/Library/EmuThunkLib.h
View File

@ -1,42 +1,42 @@
/*++ @file /*++ @file
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef __EMU_THUNK_LIB_H__ #ifndef __EMU_THUNK_LIB_H__
#define __EMU_THUNK_LIB_H__ #define __EMU_THUNK_LIB_H__
#include <Protocol/EmuThunk.h> #include <Protocol/EmuThunk.h>
extern EMU_THUNK_PROTOCOL *gEmuThunk; extern EMU_THUNK_PROTOCOL *gEmuThunk;
/** /**
Serach the EMU IO Thunk database for a matching EMU IO Thunk Serach the EMU IO Thunk database for a matching EMU IO Thunk
Protocol instance. Protocol instance.
@param Protocol Protocol to search for. @param Protocol Protocol to search for.
@param Instance Instance of protocol to search for. @param Instance Instance of protocol to search for.
@retval NULL Protocol and Instance not found. @retval NULL Protocol and Instance not found.
@retval other EMU IO Thunk protocol that matched. @retval other EMU IO Thunk protocol that matched.
**/ **/
EMU_IO_THUNK_PROTOCOL * EMU_IO_THUNK_PROTOCOL *
EFIAPI EFIAPI
GetIoThunkInstance ( GetIoThunkInstance (
IN EFI_GUID *Protocol, IN EFI_GUID *Protocol,
IN UINTN Instance IN UINTN Instance
); );
#endif #endif

42
EmulatorPkg/Include/Library/PpiListLib.h
View File

@ -1,21 +1,21 @@
/*++ @file /*++ @file
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef __PPI_LIST_LIB_H__ #ifndef __PPI_LIST_LIB_H__
#define __PPI_LIST_LIB_H__ #define __PPI_LIST_LIB_H__
extern CONST EFI_PEI_PPI_DESCRIPTOR *gPpiList; extern CONST EFI_PEI_PPI_DESCRIPTOR *gPpiList;
#endif #endif

404
EmulatorPkg/Include/Library/SmbiosLib.h
View File

@ -1,202 +1,202 @@
/** @file /** @file
Provides library functions for common SMBIOS operations. Only available to DXE Provides library functions for common SMBIOS operations. Only available to DXE
and UEFI module types. and UEFI module types.
Copyright (c) 2012, Apple Inc. All rights reserved. Copyright (c) 2012, Apple Inc. All rights reserved.
Portitions Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR> Portitions Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution. the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php. http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef _SMBIOS_LIB_H__ #ifndef _SMBIOS_LIB_H__
#define _SMBIOS_LIB_H__ #define _SMBIOS_LIB_H__
#include <IndustryStandard/SmBios.h> #include <IndustryStandard/SmBios.h>
#include <Protocol/Smbios.h> #include <Protocol/Smbios.h>
/// ///
/// Cache copy of the SMBIOS Protocol pointer /// Cache copy of the SMBIOS Protocol pointer
/// ///
extern EFI_SMBIOS_PROTOCOL *gSmbios; extern EFI_SMBIOS_PROTOCOL *gSmbios;
/// ///
/// Template for SMBIOS table initialization. /// Template for SMBIOS table initialization.
/// The SMBIOS_TABLE_STRING types in the formated area must match the /// The SMBIOS_TABLE_STRING types in the formated area must match the
/// StringArray sequene. /// StringArray sequene.
/// ///
typedef struct { typedef struct {
// //
// formatted area of a given SMBIOS record // formatted area of a given SMBIOS record
// //
SMBIOS_STRUCTURE *Entry; SMBIOS_STRUCTURE *Entry;
// //
// NULL terminated array of ASCII strings to be added to the SMBIOS record. // NULL terminated array of ASCII strings to be added to the SMBIOS record.
// //
CHAR8 **StringArray; CHAR8 **StringArray;
} SMBIOS_TEMPLATE_ENTRY; } SMBIOS_TEMPLATE_ENTRY;
/** /**
Create an initial SMBIOS Table from an array of SMBIOS_TEMPLATE_ENTRY Create an initial SMBIOS Table from an array of SMBIOS_TEMPLATE_ENTRY
entries. SMBIOS_TEMPLATE_ENTRY.NULL indicates the end of the table. entries. SMBIOS_TEMPLATE_ENTRY.NULL indicates the end of the table.
@param Template Array of SMBIOS_TEMPLATE_ENTRY entries. @param Template Array of SMBIOS_TEMPLATE_ENTRY entries.
@retval EFI_SUCCESS New SMBIOS tables were created. @retval EFI_SUCCESS New SMBIOS tables were created.
@retval EFI_OUT_OF_RESOURCES New SMBIOS tables were not created. @retval EFI_OUT_OF_RESOURCES New SMBIOS tables were not created.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibInitializeFromTemplate ( SmbiosLibInitializeFromTemplate (
IN SMBIOS_TEMPLATE_ENTRY *Template IN SMBIOS_TEMPLATE_ENTRY *Template
); );
/** /**
Create SMBIOS record. Create SMBIOS record.
Converts a fixed SMBIOS structure and an array of pointers to strings into Converts a fixed SMBIOS structure and an array of pointers to strings into
an SMBIOS record where the strings are cat'ed on the end of the fixed record an SMBIOS record where the strings are cat'ed on the end of the fixed record
and terminated via a double NULL and add to SMBIOS table. and terminated via a double NULL and add to SMBIOS table.
SMBIOS_TABLE_TYPE32 gSmbiosType12 = { SMBIOS_TABLE_TYPE32 gSmbiosType12 = {
{ EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 }, { EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 },
1 // StringCount 1 // StringCount
}; };
CHAR8 *gSmbiosType12Strings[] = { CHAR8 *gSmbiosType12Strings[] = {
"Not Found", "Not Found",
NULL NULL
}; };
... ...
AddSmbiosEntryFromTemplate ( AddSmbiosEntryFromTemplate (
(EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12, (EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12,
gSmbiosType12Strings gSmbiosType12Strings
); );
@param SmbiosEntry Fixed SMBIOS structure @param SmbiosEntry Fixed SMBIOS structure
@param StringArray Array of strings to convert to an SMBIOS string pack. @param StringArray Array of strings to convert to an SMBIOS string pack.
NULL is OK. NULL is OK.
@retval EFI_SUCCESS New SmbiosEntry was added to SMBIOS table. @retval EFI_SUCCESS New SmbiosEntry was added to SMBIOS table.
@retval EFI_OUT_OF_RESOURCES SmbiosEntry was not added. @retval EFI_OUT_OF_RESOURCES SmbiosEntry was not added.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibCreateEntry ( SmbiosLibCreateEntry (
IN SMBIOS_STRUCTURE *SmbiosEntry, IN SMBIOS_STRUCTURE *SmbiosEntry,
IN CHAR8 **StringArray IN CHAR8 **StringArray
); );
/** /**
Update the string associated with an existing SMBIOS record. Update the string associated with an existing SMBIOS record.
This function allows the update of specific SMBIOS strings. The number of valid strings for any This function allows the update of specific SMBIOS strings. The number of valid strings for any
SMBIOS record is defined by how many strings were present when Add() was called. SMBIOS record is defined by how many strings were present when Add() was called.
@param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated. @param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated.
@param[in] StringNumber The non-zero string number of the string to update. @param[in] StringNumber The non-zero string number of the string to update.
@param[in] String Update the StringNumber string with String. @param[in] String Update the StringNumber string with String.
@retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated. @retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid. @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid.
@retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports. @retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports.
@retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record. @retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibUpdateString ( SmbiosLibUpdateString (
IN EFI_SMBIOS_HANDLE SmbiosHandle, IN EFI_SMBIOS_HANDLE SmbiosHandle,
IN SMBIOS_TABLE_STRING StringNumber, IN SMBIOS_TABLE_STRING StringNumber,
IN CHAR8 *String IN CHAR8 *String
); );
/** /**
Update the string associated with an existing SMBIOS record. Update the string associated with an existing SMBIOS record.
This function allows the update of specific SMBIOS strings. The number of valid strings for any This function allows the update of specific SMBIOS strings. The number of valid strings for any
SMBIOS record is defined by how many strings were present when Add() was called. SMBIOS record is defined by how many strings were present when Add() was called.
@param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated. @param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated.
@param[in] StringNumber The non-zero string number of the string to update. @param[in] StringNumber The non-zero string number of the string to update.
@param[in] String Update the StringNumber string with String. @param[in] String Update the StringNumber string with String.
@retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated. @retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid. @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid.
@retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports. @retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports.
@retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record. @retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibUpdateUnicodeString ( SmbiosLibUpdateUnicodeString (
IN EFI_SMBIOS_HANDLE SmbiosHandle, IN EFI_SMBIOS_HANDLE SmbiosHandle,
IN SMBIOS_TABLE_STRING StringNumber, IN SMBIOS_TABLE_STRING StringNumber,
IN CHAR16 *String IN CHAR16 *String
); );
/** /**
Allow caller to read a specific SMBIOS string Allow caller to read a specific SMBIOS string
@param[in] Header SMBIOS record that contains the string. @param[in] Header SMBIOS record that contains the string.
@param[in[ StringNumber Instance of SMBIOS string 1 - N. @param[in[ StringNumber Instance of SMBIOS string 1 - N.
@retval NULL Instance of Type SMBIOS string was not found. @retval NULL Instance of Type SMBIOS string was not found.
@retval Other Pointer to matching SMBIOS string. @retval Other Pointer to matching SMBIOS string.
**/ **/
CHAR8 * CHAR8 *
EFIAPI EFIAPI
SmbiosLibReadString ( SmbiosLibReadString (
IN SMBIOS_STRUCTURE *Header, IN SMBIOS_STRUCTURE *Header,
IN EFI_SMBIOS_STRING StringNumber IN EFI_SMBIOS_STRING StringNumber
); );
/** /**
Allow the caller to discover a specific SMBIOS entry, and patch it if necissary. Allow the caller to discover a specific SMBIOS entry, and patch it if necissary.
@param[in] Type Type of the next SMBIOS record to return. @param[in] Type Type of the next SMBIOS record to return.
@param[in[ Instance Instance of SMBIOS record 0 - N-1. @param[in[ Instance Instance of SMBIOS record 0 - N-1.
@param[out] SmbiosHandle Returns SMBIOS handle for the matching record. @param[out] SmbiosHandle Returns SMBIOS handle for the matching record.
@retval NULL Instance of Type SMBIOS record was not found. @retval NULL Instance of Type SMBIOS record was not found.
@retval Other Pointer to matching SMBIOS record. @retval Other Pointer to matching SMBIOS record.
**/ **/
SMBIOS_STRUCTURE * SMBIOS_STRUCTURE *
EFIAPI EFIAPI
SmbiosLibGetRecord ( SmbiosLibGetRecord (
IN EFI_SMBIOS_TYPE Type, IN EFI_SMBIOS_TYPE Type,
IN UINTN Instance, IN UINTN Instance,
OUT EFI_SMBIOS_HANDLE *SmbiosHandle OUT EFI_SMBIOS_HANDLE *SmbiosHandle
); );
/** /**
Remove an SMBIOS record. Remove an SMBIOS record.
This function removes an SMBIOS record using the handle specified by SmbiosHandle. This function removes an SMBIOS record using the handle specified by SmbiosHandle.
@param[in] SmbiosHandle The handle of the SMBIOS record to remove. @param[in] SmbiosHandle The handle of the SMBIOS record to remove.
@retval EFI_SUCCESS SMBIOS record was removed. @retval EFI_SUCCESS SMBIOS record was removed.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record. @retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibRemove ( SmbiosLibRemove (
OUT EFI_SMBIOS_HANDLE SmbiosHandle OUT EFI_SMBIOS_HANDLE SmbiosHandle
); );
#endif #endif

2
EmulatorPkg/Include/Protocol/EmuBlockIo.h
View File

@ -62,7 +62,7 @@ EFI_STATUS
@param[in] MediaId Id of the media, changes every time the media is @param[in] MediaId Id of the media, changes every time the media is
replaced. replaced.
@param[in] Lba The starting Logical Block Address to read from. @param[in] Lba The starting Logical Block Address to read from.
@param[in, out] Token A pointer to the token associated with the transaction. @param[in, out] Token A pointer to the token associated with the transaction.
@param[in] BufferSize Size of Buffer, must be a multiple of device block size. @param[in] BufferSize Size of Buffer, must be a multiple of device block size.
@param[out] Buffer A pointer to the destination buffer for the data. The @param[out] Buffer A pointer to the destination buffer for the data. The
caller is responsible for either having implicit or caller is responsible for either having implicit or

280
EmulatorPkg/Include/Protocol/EmuFileSystem.h
View File

@ -1,140 +1,140 @@
/** @file /** @file
SimpleFileSystem protocol as defined in the UEFI 2.0 specification. SimpleFileSystem protocol as defined in the UEFI 2.0 specification.
The SimpleFileSystem protocol is the programmatic access to the FAT (12,16,32) The SimpleFileSystem protocol is the programmatic access to the FAT (12,16,32)
file system specified in UEFI 2.0. It can also be used to abstract a file file system specified in UEFI 2.0. It can also be used to abstract a file
system other than FAT. system other than FAT.
UEFI 2.0 can boot from any valid EFI image contained in a SimpleFileSystem. UEFI 2.0 can boot from any valid EFI image contained in a SimpleFileSystem.
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2011, Apple Inc. All rights reserved. Portions copyright (c) 2011, Apple Inc. All rights reserved.
This program and the accompanying materials are licensed and made available under This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution. the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php. http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef _EMU_UGA_IO_H_ #ifndef _EMU_UGA_IO_H_
#define _EMU_UGA_IO_H_ #define _EMU_UGA_IO_H_
#include <Protocol/SimplePointer.h> #include <Protocol/SimplePointer.h>
#include <Protocol/SimpleTextIn.h> #include <Protocol/SimpleTextIn.h>
#include <Protocol/SimpleTextInEx.h> #include <Protocol/SimpleTextInEx.h>
#include <Protocol/UgaDraw.h> #include <Protocol/UgaDraw.h>
#define EMU_GRAPHICS_WINDOW_PROTOCOL_GUID \ #define EMU_GRAPHICS_WINDOW_PROTOCOL_GUID \
{ 0x30FD316A, 0x6728, 0x2E41, { 0xA6, 0x90, 0x0D, 0x13, 0x33, 0xD8, 0xCA, 0xC1 } } { 0x30FD316A, 0x6728, 0x2E41, { 0xA6, 0x90, 0x0D, 0x13, 0x33, 0xD8, 0xCA, 0xC1 } }
typedef struct _EMU_GRAPHICS_WINDOW_PROTOCOL EMU_GRAPHICS_WINDOW_PROTOCOL; typedef struct _EMU_GRAPHICS_WINDOW_PROTOCOL EMU_GRAPHICS_WINDOW_PROTOCOL;
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CLOSE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CLOSE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga EMU_GRAPHICS_WINDOW_PROTOCOL *Uga
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_SIZE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_SIZE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga, EMU_GRAPHICS_WINDOW_PROTOCOL *Uga,
UINT32 Width, UINT32 Width,
UINT32 Height UINT32 Height
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_KEY)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_KEY)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga EMU_GRAPHICS_WINDOW_PROTOCOL *Uga
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_GET_KEY)( (EFIAPI *EMU_GRAPHICS_WINDOWS_GET_KEY)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga, EMU_GRAPHICS_WINDOW_PROTOCOL *Uga,
EFI_KEY_DATA *key EFI_KEY_DATA *key
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_KEY_SET_STATE) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_KEY_SET_STATE) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState IN EFI_KEY_TOGGLE_STATE *KeyToggleState
); );
typedef typedef
VOID VOID
(EFIAPI *EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK) ( (EFIAPI *EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK) (
IN VOID *Context, IN VOID *Context,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK CallBack, IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK CallBack,
IN VOID *Context IN VOID *Context
); );
typedef struct { typedef struct {
UINTN SourceX; UINTN SourceX;
UINTN SourceY; UINTN SourceY;
UINTN DestinationX; UINTN DestinationX;
UINTN DestinationY; UINTN DestinationY;
UINTN Width; UINTN Width;
UINTN Height; UINTN Height;
UINTN Delta; UINTN Delta;
} EMU_GRAPHICS_WINDOWS__BLT_ARGS; } EMU_GRAPHICS_WINDOWS__BLT_ARGS;
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_BLT)( (EFIAPI *EMU_GRAPHICS_WINDOWS_BLT)(
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_UGA_PIXEL *BltBuffer OPTIONAL, IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
IN EFI_UGA_BLT_OPERATION BltOperation, IN EFI_UGA_BLT_OPERATION BltOperation,
IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args
); );
typedef typedef
BOOLEAN BOOLEAN
(EFIAPI *EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_POINTER)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_POINTER)(
EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
EFI_SIMPLE_POINTER_STATE *state EFI_SIMPLE_POINTER_STATE *state
); );
struct _EMU_GRAPHICS_WINDOW_PROTOCOL { struct _EMU_GRAPHICS_WINDOW_PROTOCOL {
EMU_GRAPHICS_WINDOWS_SIZE Size; EMU_GRAPHICS_WINDOWS_SIZE Size;
EMU_GRAPHICS_WINDOWS_CHECK_KEY CheckKey; EMU_GRAPHICS_WINDOWS_CHECK_KEY CheckKey;
EMU_GRAPHICS_WINDOWS_KEY_SET_STATE KeySetState; EMU_GRAPHICS_WINDOWS_KEY_SET_STATE KeySetState;
EMU_GRAPHICS_WINDOWS_GET_KEY GetKey; EMU_GRAPHICS_WINDOWS_GET_KEY GetKey;
EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY RegisterKeyNotify; EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY RegisterKeyNotify;
EMU_GRAPHICS_WINDOWS_BLT Blt; EMU_GRAPHICS_WINDOWS_BLT Blt;
EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED IsKeyPressed; EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED IsKeyPressed;
EMU_GRAPHICS_WINDOWS_CHECK_POINTER CheckPointer; EMU_GRAPHICS_WINDOWS_CHECK_POINTER CheckPointer;
EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE GetPointerState; EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE GetPointerState;
}; };
extern EFI_GUID gEmuGraphicsWindowProtocolGuid; extern EFI_GUID gEmuGraphicsWindowProtocolGuid;
#endif #endif

268
EmulatorPkg/Include/Protocol/EmuGraphicsWindow.h
View File

@ -1,134 +1,134 @@
/*++ @file /*++ @file
Copyright (c) 2006, Tristan Gingold. All rights reserved.<BR> Copyright (c) 2006, Tristan Gingold. All rights reserved.<BR>
Portitions copyright (c) 2010 - 2011, Apple Inc. All rights reserved. Portitions copyright (c) 2010 - 2011, Apple Inc. All rights reserved.
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the are licensed and made available under the terms and conditions of the
BSD License which accompanies this distribution. The full text 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 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, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef _EMU_UGA_IO_H_ #ifndef _EMU_UGA_IO_H_
#define _EMU_UGA_IO_H_ #define _EMU_UGA_IO_H_
#include <Protocol/SimplePointer.h> #include <Protocol/SimplePointer.h>
#include <Protocol/SimpleTextIn.h> #include <Protocol/SimpleTextIn.h>
#include <Protocol/SimpleTextInEx.h> #include <Protocol/SimpleTextInEx.h>
#include <Protocol/UgaDraw.h> #include <Protocol/UgaDraw.h>
#define EMU_GRAPHICS_WINDOW_PROTOCOL_GUID \ #define EMU_GRAPHICS_WINDOW_PROTOCOL_GUID \
{ 0x30FD316A, 0x6728, 0x2E41, { 0xA6, 0x90, 0x0D, 0x13, 0x33, 0xD8, 0xCA, 0xC1 } } { 0x30FD316A, 0x6728, 0x2E41, { 0xA6, 0x90, 0x0D, 0x13, 0x33, 0xD8, 0xCA, 0xC1 } }
typedef struct _EMU_GRAPHICS_WINDOW_PROTOCOL EMU_GRAPHICS_WINDOW_PROTOCOL; typedef struct _EMU_GRAPHICS_WINDOW_PROTOCOL EMU_GRAPHICS_WINDOW_PROTOCOL;
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CLOSE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CLOSE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga EMU_GRAPHICS_WINDOW_PROTOCOL *Uga
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_SIZE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_SIZE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga, EMU_GRAPHICS_WINDOW_PROTOCOL *Uga,
UINT32 Width, UINT32 Width,
UINT32 Height UINT32 Height
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_KEY)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_KEY)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga EMU_GRAPHICS_WINDOW_PROTOCOL *Uga
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_GET_KEY)( (EFIAPI *EMU_GRAPHICS_WINDOWS_GET_KEY)(
EMU_GRAPHICS_WINDOW_PROTOCOL *Uga, EMU_GRAPHICS_WINDOW_PROTOCOL *Uga,
EFI_KEY_DATA *key EFI_KEY_DATA *key
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_KEY_SET_STATE) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_KEY_SET_STATE) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_KEY_TOGGLE_STATE *KeyToggleState IN EFI_KEY_TOGGLE_STATE *KeyToggleState
); );
typedef typedef
VOID VOID
(EFIAPI *EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK) ( (EFIAPI *EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK) (
IN VOID *Context, IN VOID *Context,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack, IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK MakeCallBack,
IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack, IN EMU_GRAPHICS_WINDOW_REGISTER_KEY_NOTIFY_CALLBACK BreakCallBack,
IN VOID *Context IN VOID *Context
); );
typedef struct { typedef struct {
UINTN SourceX; UINTN SourceX;
UINTN SourceY; UINTN SourceY;
UINTN DestinationX; UINTN DestinationX;
UINTN DestinationY; UINTN DestinationY;
UINTN Width; UINTN Width;
UINTN Height; UINTN Height;
UINTN Delta; UINTN Delta;
} EMU_GRAPHICS_WINDOWS__BLT_ARGS; } EMU_GRAPHICS_WINDOWS__BLT_ARGS;
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_BLT)( (EFIAPI *EMU_GRAPHICS_WINDOWS_BLT)(
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_UGA_PIXEL *BltBuffer OPTIONAL, IN EFI_UGA_PIXEL *BltBuffer OPTIONAL,
IN EFI_UGA_BLT_OPERATION BltOperation, IN EFI_UGA_BLT_OPERATION BltOperation,
IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args IN EMU_GRAPHICS_WINDOWS__BLT_ARGS *Args
); );
typedef typedef
BOOLEAN BOOLEAN
(EFIAPI *EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED) ( (EFIAPI *EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED) (
IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, IN EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
IN EFI_KEY_DATA *KeyData IN EFI_KEY_DATA *KeyData
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_POINTER)( (EFIAPI *EMU_GRAPHICS_WINDOWS_CHECK_POINTER)(
EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows
); );
typedef typedef
EFI_STATUS EFI_STATUS
(EFIAPI *EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE)( (EFIAPI *EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE)(
EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows, EMU_GRAPHICS_WINDOW_PROTOCOL *GraphicsWindows,
EFI_SIMPLE_POINTER_STATE *state EFI_SIMPLE_POINTER_STATE *state
); );
struct _EMU_GRAPHICS_WINDOW_PROTOCOL { struct _EMU_GRAPHICS_WINDOW_PROTOCOL {
EMU_GRAPHICS_WINDOWS_SIZE Size; EMU_GRAPHICS_WINDOWS_SIZE Size;
EMU_GRAPHICS_WINDOWS_CHECK_KEY CheckKey; EMU_GRAPHICS_WINDOWS_CHECK_KEY CheckKey;
EMU_GRAPHICS_WINDOWS_KEY_SET_STATE KeySetState; EMU_GRAPHICS_WINDOWS_KEY_SET_STATE KeySetState;
EMU_GRAPHICS_WINDOWS_GET_KEY GetKey; EMU_GRAPHICS_WINDOWS_GET_KEY GetKey;
EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY RegisterKeyNotify; EMU_GRAPHICS_WINDOWS_REGISTER_KEY_NOTIFY RegisterKeyNotify;
EMU_GRAPHICS_WINDOWS_BLT Blt; EMU_GRAPHICS_WINDOWS_BLT Blt;
EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED IsKeyPressed; EMU_GRAPHICS_WINDOWS_IS_KEY_PRESSED IsKeyPressed;
EMU_GRAPHICS_WINDOWS_CHECK_POINTER CheckPointer; EMU_GRAPHICS_WINDOWS_CHECK_POINTER CheckPointer;
EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE GetPointerState; EMU_GRAPHICS_WINDOWS_GET_POINTER_STATE GetPointerState;
}; };
extern EFI_GUID gEmuGraphicsWindowProtocolGuid; extern EFI_GUID gEmuGraphicsWindowProtocolGuid;
#endif #endif

2
EmulatorPkg/Library/DevicePathTextLib/DevicePathTextLib.c
View File

@ -180,4 +180,4 @@ DevicePathToTextLibConstructor (
DevicePathFromTextAddFilter (L"EmuThread", DevPathFromTextEmuThread); DevicePathFromTextAddFilter (L"EmuThread", DevPathFromTextEmuThread);
DevicePathFromTextAddFilter (L"EmuFs", DevPathFromTextEmuFs); DevicePathFromTextAddFilter (L"EmuFs", DevPathFromTextEmuFs);
return EFI_SUCCESS; return EFI_SUCCESS;
} }

2
EmulatorPkg/Library/DevicePathTextLib/DevicePathTextLib.inf
View File

@ -45,4 +45,4 @@
gEmuGraphicsWindowProtocolGuid gEmuGraphicsWindowProtocolGuid
gEfiSimpleFileSystemProtocolGuid gEfiSimpleFileSystemProtocolGuid
gEmuBlockIoProtocolGuid gEmuBlockIoProtocolGuid
gEmuThreadThunkProtocolGuid gEmuThreadThunkProtocolGuid

2
EmulatorPkg/Library/DxeEmuLib/DxeEmuLib.c
View File

@ -85,4 +85,4 @@ GetIoThunkInstance (
} }
return NULL; return NULL;
} }

96
EmulatorPkg/Library/DxeEmuPeCoffExtraActionLib/DxeEmuPeCoffExtraActionLib.inf
View File

@ -1,48 +1,48 @@
## @file ## @file
# PeCoff extra action libary for DXE phase that run Emu emulator. # PeCoff extra action libary for DXE phase that run Emu emulator.
# #
# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
# Portions copyright (c) 2011, Apple Inc. All rights reserved. # Portions copyright (c) 2011, Apple Inc. All rights reserved.
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # 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 # which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php # http://opensource.org/licenses/bsd-license.php
# #
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
# #
# #
## ##
[Defines] [Defines]
INF_VERSION = 0x00010005 INF_VERSION = 0x00010005
BASE_NAME = DxeEmuPeCoffExtraActionLib BASE_NAME = DxeEmuPeCoffExtraActionLib
FILE_GUID = 68FCD487-D230-6846-95B1-5E1F2EF942C4 FILE_GUID = 68FCD487-D230-6846-95B1-5E1F2EF942C4
MODULE_TYPE = DXE_DRIVER MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0 VERSION_STRING = 1.0
LIBRARY_CLASS = PeCoffExtraActionLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER UEFI_DRIVER LIBRARY_CLASS = PeCoffExtraActionLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER UEFI_DRIVER
CONSTRUCTOR = DxeEmuPeCoffLibExtraActionConstructor CONSTRUCTOR = DxeEmuPeCoffLibExtraActionConstructor
# #
# The following information is for reference only and not required by the build tools. # The following information is for reference only and not required by the build tools.
# #
# VALID_ARCHITECTURES = IA32 # VALID_ARCHITECTURES = IA32
# #
[Sources] [Sources]
DxeEmuPeCoffExtraActionLib.c DxeEmuPeCoffExtraActionLib.c
[Packages] [Packages]
MdePkg/MdePkg.dec MdePkg/MdePkg.dec
EmulatorPkg/EmulatorPkg.dec EmulatorPkg/EmulatorPkg.dec
[LibraryClasses] [LibraryClasses]
DebugLib DebugLib
HobLib HobLib
BaseMemoryLib BaseMemoryLib
[Protocols] [Protocols]
gEmuThunkProtocolGuid # PROTOCOL ALWAYS_CONSUMED gEmuThunkProtocolGuid # PROTOCOL ALWAYS_CONSUMED

2
EmulatorPkg/Library/DxeEmuStdErrSerialPortLib/DxeEmuStdErrSerialPortLib.c
View File

@ -69,7 +69,7 @@ SerialPortWrite (
if (gEmuThunk == NULL) { if (gEmuThunk == NULL) {
return NumberOfBytes; return NumberOfBytes;
} }
return gEmuThunk->WriteStdErr (Buffer, NumberOfBytes); return gEmuThunk->WriteStdErr (Buffer, NumberOfBytes);
} }

2
EmulatorPkg/Library/KeyMapLibNull/KeyMapLibNull.c
View File

@ -47,4 +47,4 @@ KeyMapBreak (
) )
{ {
return EFI_SUCCESS; return EFI_SUCCESS;
} }

12
EmulatorPkg/Library/PeiCoreServicesTablePointerLib/PeiServicesTablePointer.c
View File

@ -89,16 +89,16 @@ PeiServicesTablePointerLibConstructor (
} }
/** /**
Perform CPU specific actions required to migrate the PEI Services Table Perform CPU specific actions required to migrate the PEI Services Table
pointer from temporary RAM to permanent RAM. pointer from temporary RAM to permanent RAM.
For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
a dedicated CPU register. This means that there is no memory storage a dedicated CPU register. This means that there is no memory storage
associated with storing the PEI Services Table pointer, so no additional associated with storing the PEI Services Table pointer, so no additional
migration actions are required for Itanium or ARM CPUs. migration actions are required for Itanium or ARM CPUs.
**/ **/
@ -109,7 +109,7 @@ MigratePeiServicesTablePointer (
) )
{ {
// //
// PEI Services Table pointer is cached in the global variable. No additional // PEI Services Table pointer is cached in the global variable. No additional
// migration actions are required. // migration actions are required.
// //
return; return;

98
EmulatorPkg/Library/PeiEmuPeCoffExtraActionLib/PeiEmuPeCoffExtraActionLib.inf
View File

@ -1,49 +1,49 @@
## @file ## @file
# PeCoff extra action libary for Pei phase that run Emu emulator. # PeCoff extra action libary for Pei phase that run Emu emulator.
# #
# Lib to provide memory journal status code reporting Routines # Lib to provide memory journal status code reporting Routines
# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR> # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
# Portions copyright (c) 2011, Apple Inc. All rights reserved. # Portions copyright (c) 2011, Apple Inc. All rights reserved.
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # 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 # which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php # http://opensource.org/licenses/bsd-license.php
# #
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
# #
# #
## ##
[Defines] [Defines]
INF_VERSION = 0x00010005 INF_VERSION = 0x00010005
BASE_NAME = PeiEmuPeCoffExtraActionLib BASE_NAME = PeiEmuPeCoffExtraActionLib
FILE_GUID = 79C4E72A-730B-F040-8129-95877B3A97A8 FILE_GUID = 79C4E72A-730B-F040-8129-95877B3A97A8
MODULE_TYPE = PEIM MODULE_TYPE = PEIM
VERSION_STRING = 1.0 VERSION_STRING = 1.0
LIBRARY_CLASS = PeCoffExtraActionLib|PEI_CORE PEIM LIBRARY_CLASS = PeCoffExtraActionLib|PEI_CORE PEIM
# #
# The following information is for reference only and not required by the build tools. # The following information is for reference only and not required by the build tools.
# #
# VALID_ARCHITECTURES = IA32 # VALID_ARCHITECTURES = IA32
# #
[Sources] [Sources]
PeiEmuPeCoffExtraActionLib.c PeiEmuPeCoffExtraActionLib.c
[Packages] [Packages]
MdePkg/MdePkg.dec MdePkg/MdePkg.dec
EmulatorPkg/EmulatorPkg.dec EmulatorPkg/EmulatorPkg.dec
[LibraryClasses] [LibraryClasses]
BaseLib BaseLib
PeiServicesLib PeiServicesLib
DebugLib DebugLib
[Ppis] [Ppis]
gEmuThunkPpiGuid # PPI ALWAYS_CONSUMED gEmuThunkPpiGuid # PPI ALWAYS_CONSUMED
[Pcd] [Pcd]
gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage gEmulatorPkgTokenSpaceGuid.PcdPeiServicesTablePage

12
EmulatorPkg/Library/PeiServicesTablePointerLib/PeiServicesTablePointer.c
View File

@ -134,16 +134,16 @@ PeiServicesTablePointerLibConstructor (
} }
/** /**
Perform CPU specific actions required to migrate the PEI Services Table Perform CPU specific actions required to migrate the PEI Services Table
pointer from temporary RAM to permanent RAM. pointer from temporary RAM to permanent RAM.
For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
a dedicated CPU register. This means that there is no memory storage a dedicated CPU register. This means that there is no memory storage
associated with storing the PEI Services Table pointer, so no additional associated with storing the PEI Services Table pointer, so no additional
migration actions are required for Itanium or ARM CPUs. migration actions are required for Itanium or ARM CPUs.
**/ **/
@ -154,7 +154,7 @@ MigratePeiServicesTablePointer (
) )
{ {
// //
// PEI Services Table pointer is cached in the global variable. No additional // PEI Services Table pointer is cached in the global variable. No additional
// migration actions are required. // migration actions are required.
// //
return; return;

12
EmulatorPkg/Library/PeiServicesTablePointerLibMagicPage/PeiServicesTablePointer.c
View File

@ -72,16 +72,16 @@ GetPeiServicesTablePointer (
} }
/** /**
Perform CPU specific actions required to migrate the PEI Services Table Perform CPU specific actions required to migrate the PEI Services Table
pointer from temporary RAM to permanent RAM. pointer from temporary RAM to permanent RAM.
For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes For IA32 CPUs, the PEI Services Table pointer is stored in the 4 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes For X64 CPUs, the PEI Services Table pointer is stored in the 8 bytes
immediately preceding the Interrupt Descriptor Table (IDT) in memory. immediately preceding the Interrupt Descriptor Table (IDT) in memory.
For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in For Itanium and ARM CPUs, a the PEI Services Table Pointer is stored in
a dedicated CPU register. This means that there is no memory storage a dedicated CPU register. This means that there is no memory storage
associated with storing the PEI Services Table pointer, so no additional associated with storing the PEI Services Table pointer, so no additional
migration actions are required for Itanium or ARM CPUs. migration actions are required for Itanium or ARM CPUs.
**/ **/
@ -92,7 +92,7 @@ MigratePeiServicesTablePointer (
) )
{ {
// //
// PEI Services Table pointer is cached in SRAM. No additional // PEI Services Table pointer is cached in SRAM. No additional
// migration actions are required. // migration actions are required.
// //
return; return;

2
EmulatorPkg/Library/PeiTimerLib/PeiTimerLib.inf
View File

@ -44,4 +44,4 @@
PeiServicesLib PeiServicesLib
[Ppis] [Ppis]
gEmuThunkPpiGuid gEmuThunkPpiGuid

562
EmulatorPkg/Library/SecPeiServicesLib/FwVol.c
View File

@ -1,281 +1,281 @@
/*++ @file /*++ @file
A simple FV stack so the SEC can extract the SEC Core from an A simple FV stack so the SEC can extract the SEC Core from an
FV. FV.
Copyright (c) 2006, Intel Corporation. All rights reserved.<BR> Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include <PiPei.h> #include <PiPei.h>
#define GET_OCCUPIED_SIZE(ActualSize, Alignment) \ #define GET_OCCUPIED_SIZE(ActualSize, Alignment) \
(ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1)) (ActualSize) + (((Alignment) - ((ActualSize) & ((Alignment) - 1))) & ((Alignment) - 1))
EFI_FFS_FILE_STATE EFI_FFS_FILE_STATE
GetFileState ( GetFileState (
IN UINT8 ErasePolarity, IN UINT8 ErasePolarity,
IN EFI_FFS_FILE_HEADER *FfsHeader IN EFI_FFS_FILE_HEADER *FfsHeader
) )
/*++ /*++
Routine Description: Routine Description:
Returns the highest bit set of the State field Returns the highest bit set of the State field
Arguments: Arguments:
ErasePolarity - Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY ErasePolarity - Erase Polarity as defined by EFI_FVB2_ERASE_POLARITY
in the Attributes field. in the Attributes field.
FfsHeader - Pointer to FFS File Header. FfsHeader - Pointer to FFS File Header.
Returns: Returns:
Returns the highest bit in the State field Returns the highest bit in the State field
**/ **/
{ {
EFI_FFS_FILE_STATE FileState; EFI_FFS_FILE_STATE FileState;
EFI_FFS_FILE_STATE HighestBit; EFI_FFS_FILE_STATE HighestBit;
FileState = FfsHeader->State; FileState = FfsHeader->State;
if (ErasePolarity != 0) { if (ErasePolarity != 0) {
FileState = (EFI_FFS_FILE_STATE)~FileState; FileState = (EFI_FFS_FILE_STATE)~FileState;
} }
HighestBit = 0x80; HighestBit = 0x80;
while (HighestBit != 0 && (HighestBit & FileState) == 0) { while (HighestBit != 0 && (HighestBit & FileState) == 0) {
HighestBit >>= 1; HighestBit >>= 1;
} }
return HighestBit; return HighestBit;
} }
UINT8 UINT8
CalculateHeaderChecksum ( CalculateHeaderChecksum (
IN EFI_FFS_FILE_HEADER *FileHeader IN EFI_FFS_FILE_HEADER *FileHeader
) )
/*++ /*++
Routine Description: Routine Description:
Calculates the checksum of the header of a file. Calculates the checksum of the header of a file.
Arguments: Arguments:
FileHeader - Pointer to FFS File Header. FileHeader - Pointer to FFS File Header.
Returns: Returns:
Checksum of the header. Checksum of the header.
**/ **/
{ {
UINT8 *ptr; UINT8 *ptr;
UINTN Index; UINTN Index;
UINT8 Sum; UINT8 Sum;
Sum = 0; Sum = 0;
ptr = (UINT8 *) FileHeader; ptr = (UINT8 *) FileHeader;
for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) { for (Index = 0; Index < sizeof (EFI_FFS_FILE_HEADER) - 3; Index += 4) {
Sum = (UINT8) (Sum + ptr[Index]); Sum = (UINT8) (Sum + ptr[Index]);
Sum = (UINT8) (Sum + ptr[Index + 1]); Sum = (UINT8) (Sum + ptr[Index + 1]);
Sum = (UINT8) (Sum + ptr[Index + 2]); Sum = (UINT8) (Sum + ptr[Index + 2]);
Sum = (UINT8) (Sum + ptr[Index + 3]); Sum = (UINT8) (Sum + ptr[Index + 3]);
} }
for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) { for (; Index < sizeof (EFI_FFS_FILE_HEADER); Index++) {
Sum = (UINT8) (Sum + ptr[Index]); Sum = (UINT8) (Sum + ptr[Index]);
} }
// //
// State field (since this indicates the different state of file). // State field (since this indicates the different state of file).
// //
Sum = (UINT8) (Sum - FileHeader->State); Sum = (UINT8) (Sum - FileHeader->State);
// //
// Checksum field of the file is not part of the header checksum. // Checksum field of the file is not part of the header checksum.
// //
Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File); Sum = (UINT8) (Sum - FileHeader->IntegrityCheck.Checksum.File);
return Sum; return Sum;
} }
EFI_STATUS EFI_STATUS
SecFfsFindNextFile ( SecFfsFindNextFile (
IN EFI_FV_FILETYPE SearchType, IN EFI_FV_FILETYPE SearchType,
IN EFI_PEI_FV_HANDLE FvHandle, IN EFI_PEI_FV_HANDLE FvHandle,
IN OUT EFI_PEI_FILE_HANDLE *FileHandle IN OUT EFI_PEI_FILE_HANDLE *FileHandle
) )
/*++ /*++
Routine Description: Routine Description:
Given the input file pointer, search for the next matching file in the Given the input file pointer, search for the next matching file in the
FFS volume as defined by SearchType. The search starts from FileHeader inside FFS volume as defined by SearchType. The search starts from FileHeader inside
the Firmware Volume defined by FwVolHeader. the Firmware Volume defined by FwVolHeader.
Arguments: Arguments:
SearchType - Filter to find only files of this type. SearchType - Filter to find only files of this type.
Type EFI_FV_FILETYPE_ALL causes no filtering to be done. Type EFI_FV_FILETYPE_ALL causes no filtering to be done.
FwVolHeader - Pointer to the FV header of the volume to search. FwVolHeader - Pointer to the FV header of the volume to search.
This parameter must point to a valid FFS volume. This parameter must point to a valid FFS volume.
FileHeader - Pointer to the current file from which to begin searching. FileHeader - Pointer to the current file from which to begin searching.
This pointer will be updated upon return to reflect the file This pointer will be updated upon return to reflect the file
found. found.
Returns: Returns:
EFI_NOT_FOUND - No files matching the search criteria were found EFI_NOT_FOUND - No files matching the search criteria were found
EFI_SUCCESS EFI_SUCCESS
**/ **/
{ {
EFI_FFS_FILE_HEADER *FfsFileHeader; EFI_FFS_FILE_HEADER *FfsFileHeader;
UINT32 FileLength; UINT32 FileLength;
UINT32 FileOccupiedSize; UINT32 FileOccupiedSize;
UINT32 FileOffset; UINT32 FileOffset;
UINT64 FvLength; UINT64 FvLength;
UINT8 ErasePolarity; UINT8 ErasePolarity;
UINT8 FileState; UINT8 FileState;
EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader; EFI_FIRMWARE_VOLUME_HEADER *FwVolHeader;
EFI_FFS_FILE_HEADER **FileHeader; EFI_FFS_FILE_HEADER **FileHeader;
// //
// Convert the handle of FV to FV header for memory-mapped firmware volume // Convert the handle of FV to FV header for memory-mapped firmware volume
// //
FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FvHandle; FwVolHeader = (EFI_FIRMWARE_VOLUME_HEADER *) FvHandle;
FileHeader = (EFI_FFS_FILE_HEADER **)FileHandle; FileHeader = (EFI_FFS_FILE_HEADER **)FileHandle;
FvLength = FwVolHeader->FvLength; FvLength = FwVolHeader->FvLength;
if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) { if (FwVolHeader->Attributes & EFI_FVB2_ERASE_POLARITY) {
ErasePolarity = 1; ErasePolarity = 1;
} else { } else {
ErasePolarity = 0; ErasePolarity = 0;
} }
// //
// If FileHeader is not specified (NULL) start with the first file in the // If FileHeader is not specified (NULL) start with the first file in the
// firmware volume. Otherwise, start from the FileHeader. // firmware volume. Otherwise, start from the FileHeader.
// //
if (*FileHeader == NULL) { if (*FileHeader == NULL) {
FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FwVolHeader + FwVolHeader->HeaderLength); FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FwVolHeader + FwVolHeader->HeaderLength);
} else { } else {
// //
// Length is 24 bits wide so mask upper 8 bits // Length is 24 bits wide so mask upper 8 bits
// FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned. // FileLength is adjusted to FileOccupiedSize as it is 8 byte aligned.
// //
FileLength = *(UINT32 *) (*FileHeader)->Size & 0x00FFFFFF; FileLength = *(UINT32 *) (*FileHeader)->Size & 0x00FFFFFF;
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) *FileHeader + FileOccupiedSize); FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) *FileHeader + FileOccupiedSize);
} }
FileOffset = (UINT32) ((UINT8 *) FfsFileHeader - (UINT8 *) FwVolHeader); FileOffset = (UINT32) ((UINT8 *) FfsFileHeader - (UINT8 *) FwVolHeader);
while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) { while (FileOffset < (FvLength - sizeof (EFI_FFS_FILE_HEADER))) {
// //
// Get FileState which is the highest bit of the State // Get FileState which is the highest bit of the State
// //
FileState = GetFileState (ErasePolarity, FfsFileHeader); FileState = GetFileState (ErasePolarity, FfsFileHeader);
switch (FileState) { switch (FileState) {
case EFI_FILE_HEADER_INVALID: case EFI_FILE_HEADER_INVALID:
FileOffset += sizeof (EFI_FFS_FILE_HEADER); FileOffset += sizeof (EFI_FFS_FILE_HEADER);
FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER)); FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + sizeof (EFI_FFS_FILE_HEADER));
break; break;
case EFI_FILE_DATA_VALID: case EFI_FILE_DATA_VALID:
case EFI_FILE_MARKED_FOR_UPDATE: case EFI_FILE_MARKED_FOR_UPDATE:
if (CalculateHeaderChecksum (FfsFileHeader) == 0) { if (CalculateHeaderChecksum (FfsFileHeader) == 0) {
FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
if ((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) { if ((SearchType == FfsFileHeader->Type) || (SearchType == EFI_FV_FILETYPE_ALL)) {
*FileHeader = FfsFileHeader; *FileHeader = FfsFileHeader;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
FileOffset += FileOccupiedSize; FileOffset += FileOccupiedSize;
FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize); FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);
} else { } else {
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
break; break;
case EFI_FILE_DELETED: case EFI_FILE_DELETED:
FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; FileLength = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8); FileOccupiedSize = GET_OCCUPIED_SIZE (FileLength, 8);
FileOffset += FileOccupiedSize; FileOffset += FileOccupiedSize;
FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize); FfsFileHeader = (EFI_FFS_FILE_HEADER *) ((UINT8 *) FfsFileHeader + FileOccupiedSize);
break; break;
default: default:
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
} }
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
EFI_STATUS EFI_STATUS
SecFfsFindSectionData ( SecFfsFindSectionData (
IN EFI_SECTION_TYPE SectionType, IN EFI_SECTION_TYPE SectionType,
IN EFI_FFS_FILE_HEADER *FfsFileHeader, IN EFI_FFS_FILE_HEADER *FfsFileHeader,
IN OUT VOID **SectionData IN OUT VOID **SectionData
) )
/*++ /*++
Routine Description: Routine Description:
Given the input file pointer, search for the next matching section in the Given the input file pointer, search for the next matching section in the
FFS volume. FFS volume.
Arguments: Arguments:
SearchType - Filter to find only sections of this type. SearchType - Filter to find only sections of this type.
FfsFileHeader - Pointer to the current file to search. FfsFileHeader - Pointer to the current file to search.
SectionData - Pointer to the Section matching SectionType in FfsFileHeader. SectionData - Pointer to the Section matching SectionType in FfsFileHeader.
NULL if section not found NULL if section not found
Returns: Returns:
EFI_NOT_FOUND - No files matching the search criteria were found EFI_NOT_FOUND - No files matching the search criteria were found
EFI_SUCCESS EFI_SUCCESS
**/ **/
{ {
UINT32 FileSize; UINT32 FileSize;
EFI_COMMON_SECTION_HEADER *Section; EFI_COMMON_SECTION_HEADER *Section;
UINT32 SectionLength; UINT32 SectionLength;
UINT32 ParsedLength; UINT32 ParsedLength;
// //
// Size is 24 bits wide so mask upper 8 bits. // Size is 24 bits wide so mask upper 8 bits.
// Does not include FfsFileHeader header size // Does not include FfsFileHeader header size
// FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned. // FileSize is adjusted to FileOccupiedSize as it is 8 byte aligned.
// //
Section = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1); Section = (EFI_COMMON_SECTION_HEADER *) (FfsFileHeader + 1);
FileSize = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF; FileSize = *(UINT32 *) (FfsFileHeader->Size) & 0x00FFFFFF;
FileSize -= sizeof (EFI_FFS_FILE_HEADER); FileSize -= sizeof (EFI_FFS_FILE_HEADER);
*SectionData = NULL; *SectionData = NULL;
ParsedLength = 0; ParsedLength = 0;
while (ParsedLength < FileSize) { while (ParsedLength < FileSize) {
if (Section->Type == SectionType) { if (Section->Type == SectionType) {
*SectionData = (VOID *) (Section + 1); *SectionData = (VOID *) (Section + 1);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
// //
// Size is 24 bits wide so mask upper 8 bits. // Size is 24 bits wide so mask upper 8 bits.
// SectionLength is adjusted it is 4 byte aligned. // SectionLength is adjusted it is 4 byte aligned.
// Go to the next section // Go to the next section
// //
SectionLength = *(UINT32 *) Section->Size & 0x00FFFFFF; SectionLength = *(UINT32 *) Section->Size & 0x00FFFFFF;
SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4); SectionLength = GET_OCCUPIED_SIZE (SectionLength, 4);
ParsedLength += SectionLength; ParsedLength += SectionLength;
Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + SectionLength); Section = (EFI_COMMON_SECTION_HEADER *) ((UINT8 *) Section + SectionLength);
} }
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }

34
EmulatorPkg/Library/SecPpiListLib/PpiListLib.c
View File

@ -1,17 +1,17 @@
/*++ @file /*++ @file
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include <PiPei.h> #include <PiPei.h>
CONST EFI_PEI_PPI_DESCRIPTOR *gPpiList = NULL; CONST EFI_PEI_PPI_DESCRIPTOR *gPpiList = NULL;

704
EmulatorPkg/Library/SmbiosLib/SmbiosLib.c
View File

@ -1,352 +1,352 @@
/** @file /** @file
Provides library functions for common SMBIOS operations. Only available to DXE Provides library functions for common SMBIOS operations. Only available to DXE
and UEFI module types. and UEFI module types.
Copyright (c) 2012, Apple Inc. All rights reserved. Copyright (c) 2012, Apple Inc. All rights reserved.
Portitions Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR> Portitions Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials are licensed and made available under This program and the accompanying materials are licensed and made available under
the terms and conditions of the BSD License that accompanies this distribution. the terms and conditions of the BSD License that accompanies this distribution.
The full text of the license may be found at The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php. http://opensource.org/licenses/bsd-license.php.
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include <PiDxe.h> #include <PiDxe.h>
#include <Library/BaseLib.h> #include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h> #include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h> #include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h> #include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h> #include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h> #include <Library/UefiLib.h>
#include <Library/SmbiosLib.h> #include <Library/SmbiosLib.h>
EFI_SMBIOS_PROTOCOL *gSmbios = NULL; EFI_SMBIOS_PROTOCOL *gSmbios = NULL;
/** /**
Create an initial SMBIOS Table from an array of SMBIOS_TEMPLATE_ENTRY Create an initial SMBIOS Table from an array of SMBIOS_TEMPLATE_ENTRY
entries. SMBIOS_TEMPLATE_ENTRY.NULL indicates the end of the table. entries. SMBIOS_TEMPLATE_ENTRY.NULL indicates the end of the table.
@param Template Array of SMBIOS_TEMPLATE_ENTRY entries. @param Template Array of SMBIOS_TEMPLATE_ENTRY entries.
@retval EFI_SUCCESS New SMBIOS tables were created. @retval EFI_SUCCESS New SMBIOS tables were created.
@retval EFI_OUT_OF_RESOURCES New SMBIOS tables were not created. @retval EFI_OUT_OF_RESOURCES New SMBIOS tables were not created.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibInitializeFromTemplate ( SmbiosLibInitializeFromTemplate (
IN SMBIOS_TEMPLATE_ENTRY *Template IN SMBIOS_TEMPLATE_ENTRY *Template
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
UINTN Index; UINTN Index;
if (Template == NULL) { if (Template == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
Status = EFI_SUCCESS; Status = EFI_SUCCESS;
for (Index = 0; Template[Index].Entry != NULL; Index++) { for (Index = 0; Template[Index].Entry != NULL; Index++) {
Status = SmbiosLibCreateEntry (Template[Index].Entry, Template[Index].StringArray); Status = SmbiosLibCreateEntry (Template[Index].Entry, Template[Index].StringArray);
} }
return Status; return Status;
} }
/** /**
Create SMBIOS record. Create SMBIOS record.
Converts a fixed SMBIOS structure and an array of pointers to strings into Converts a fixed SMBIOS structure and an array of pointers to strings into
an SMBIOS record where the strings are cat'ed on the end of the fixed record an SMBIOS record where the strings are cat'ed on the end of the fixed record
and terminated via a double NULL and add to SMBIOS table. and terminated via a double NULL and add to SMBIOS table.
SMBIOS_TABLE_TYPE32 gSmbiosType12 = { SMBIOS_TABLE_TYPE32 gSmbiosType12 = {
{ EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 }, { EFI_SMBIOS_TYPE_SYSTEM_CONFIGURATION_OPTIONS, sizeof (SMBIOS_TABLE_TYPE12), 0 },
1 // StringCount 1 // StringCount
}; };
CHAR8 *gSmbiosType12Strings[] = { CHAR8 *gSmbiosType12Strings[] = {
"Not Found", "Not Found",
NULL NULL
}; };
... ...
CreateSmbiosEntry ( CreateSmbiosEntry (
(EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12, (EFI_SMBIOS_TABLE_HEADER*)&gSmbiosType12,
gSmbiosType12Strings gSmbiosType12Strings
); );
@param SmbiosEntry Fixed SMBIOS structure @param SmbiosEntry Fixed SMBIOS structure
@param StringArray Array of strings to convert to an SMBIOS string pack. @param StringArray Array of strings to convert to an SMBIOS string pack.
NULL is OK. NULL is OK.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibCreateEntry ( SmbiosLibCreateEntry (
IN SMBIOS_STRUCTURE *SmbiosEntry, IN SMBIOS_STRUCTURE *SmbiosEntry,
IN CHAR8 **StringArray IN CHAR8 **StringArray
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_SMBIOS_HANDLE SmbiosHandle; EFI_SMBIOS_HANDLE SmbiosHandle;
EFI_SMBIOS_TABLE_HEADER *Record; EFI_SMBIOS_TABLE_HEADER *Record;
UINTN Index; UINTN Index;
UINTN StringSize; UINTN StringSize;
UINTN Size; UINTN Size;
CHAR8 *Str; CHAR8 *Str;
// Calculate the size of the fixed record and optional string pack // Calculate the size of the fixed record and optional string pack
Size = SmbiosEntry->Length; Size = SmbiosEntry->Length;
if (StringArray == NULL) { if (StringArray == NULL) {
Size += 2; // Min string section is double null Size += 2; // Min string section is double null
} else if (StringArray[0] == NULL) { } else if (StringArray[0] == NULL) {
Size += 2; // Min string section is double null Size += 2; // Min string section is double null
} else { } else {
for (Index = 0; StringArray[Index] != NULL; Index++) { for (Index = 0; StringArray[Index] != NULL; Index++) {
StringSize = AsciiStrSize (StringArray[Index]); StringSize = AsciiStrSize (StringArray[Index]);
Size += StringSize; Size += StringSize;
} }
// Don't forget the terminating double null // Don't forget the terminating double null
Size += 1; Size += 1;
} }
// Copy over Template // Copy over Template
Record = (EFI_SMBIOS_TABLE_HEADER *)AllocateZeroPool (Size); Record = (EFI_SMBIOS_TABLE_HEADER *)AllocateZeroPool (Size);
if (Record == NULL) { if (Record == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
CopyMem (Record, SmbiosEntry, SmbiosEntry->Length); CopyMem (Record, SmbiosEntry, SmbiosEntry->Length);
if (StringArray != NULL) { if (StringArray != NULL) {
// Append string pack // Append string pack
Str = ((CHAR8 *)Record) + Record->Length; Str = ((CHAR8 *)Record) + Record->Length;
for (Index = 0; StringArray[Index] != NULL; Index++) { for (Index = 0; StringArray[Index] != NULL; Index++) {
StringSize = AsciiStrSize (StringArray[Index]); StringSize = AsciiStrSize (StringArray[Index]);
CopyMem (Str, StringArray[Index], StringSize); CopyMem (Str, StringArray[Index], StringSize);
Str += StringSize; Str += StringSize;
} }
*Str = 0; *Str = 0;
} }
SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED; SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = gSmbios->Add ( Status = gSmbios->Add (
gSmbios, gSmbios,
gImageHandle, gImageHandle,
&SmbiosHandle, &SmbiosHandle,
Record Record
); );
FreePool (Record); FreePool (Record);
return Status; return Status;
} }
/** /**
Update the string associated with an existing SMBIOS record. Update the string associated with an existing SMBIOS record.
This function allows the update of specific SMBIOS strings. The number of valid strings for any This function allows the update of specific SMBIOS strings. The number of valid strings for any
SMBIOS record is defined by how many strings were present when Add() was called. SMBIOS record is defined by how many strings were present when Add() was called.
@param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated. @param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated.
@param[in] StringNumber The non-zero string number of the string to update. @param[in] StringNumber The non-zero string number of the string to update.
@param[in] String Update the StringNumber string with String. @param[in] String Update the StringNumber string with String.
@retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated. @retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid. @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid.
@retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports. @retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports.
@retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record. @retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibUpdateString ( SmbiosLibUpdateString (
IN EFI_SMBIOS_HANDLE SmbiosHandle, IN EFI_SMBIOS_HANDLE SmbiosHandle,
IN SMBIOS_TABLE_STRING StringNumber, IN SMBIOS_TABLE_STRING StringNumber,
IN CHAR8 *String IN CHAR8 *String
) )
{ {
UINTN StringIndex; UINTN StringIndex;
if (String == NULL) { if (String == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (*String == '\0') { if (*String == '\0') {
// A string with no data is not legal in SMBIOS // A string with no data is not legal in SMBIOS
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
StringIndex = StringNumber; StringIndex = StringNumber;
return gSmbios->UpdateString (gSmbios, &SmbiosHandle, &StringIndex, String); return gSmbios->UpdateString (gSmbios, &SmbiosHandle, &StringIndex, String);
} }
/** /**
Update the string associated with an existing SMBIOS record. Update the string associated with an existing SMBIOS record.
This function allows the update of specific SMBIOS strings. The number of valid strings for any This function allows the update of specific SMBIOS strings. The number of valid strings for any
SMBIOS record is defined by how many strings were present when Add() was called. SMBIOS record is defined by how many strings were present when Add() was called.
@param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated. @param[in] SmbiosHandle SMBIOS Handle of structure that will have its string updated.
@param[in] StringNumber The non-zero string number of the string to update. @param[in] StringNumber The non-zero string number of the string to update.
@param[in] String Update the StringNumber string with String. @param[in] String Update the StringNumber string with String.
@retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated. @retval EFI_SUCCESS SmbiosHandle had its StringNumber String updated.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid. @retval EFI_INVALID_PARAMETER SmbiosHandle does not exist. Or String is invalid.
@retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports. @retval EFI_UNSUPPORTED String was not added because it is longer than the SMBIOS Table supports.
@retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record. @retval EFI_NOT_FOUND The StringNumber.is not valid for this SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibUpdateUnicodeString ( SmbiosLibUpdateUnicodeString (
IN EFI_SMBIOS_HANDLE SmbiosHandle, IN EFI_SMBIOS_HANDLE SmbiosHandle,
IN SMBIOS_TABLE_STRING StringNumber, IN SMBIOS_TABLE_STRING StringNumber,
IN CHAR16 *String IN CHAR16 *String
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
UINTN StringIndex; UINTN StringIndex;
CHAR8 *Ascii; CHAR8 *Ascii;
if (String == NULL) { if (String == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (*String == '\0') { if (*String == '\0') {
// A string with no data is not legal in SMBIOS // A string with no data is not legal in SMBIOS
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
Ascii = AllocateZeroPool (StrSize (String)); Ascii = AllocateZeroPool (StrSize (String));
if (Ascii == NULL) { if (Ascii == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
UnicodeStrToAsciiStr (String, Ascii); UnicodeStrToAsciiStr (String, Ascii);
StringIndex = StringNumber; StringIndex = StringNumber;
Status = gSmbios->UpdateString (gSmbios, &SmbiosHandle, &StringIndex, Ascii); Status = gSmbios->UpdateString (gSmbios, &SmbiosHandle, &StringIndex, Ascii);
FreePool (Ascii); FreePool (Ascii);
return Status; return Status;
} }
/** /**
Allow caller to read a specific SMBIOS string Allow caller to read a specific SMBIOS string
@param[in] Header SMBIOS record that contains the string. @param[in] Header SMBIOS record that contains the string.
@param[in[ StringNumber Instance of SMBIOS string 1 - N. @param[in[ StringNumber Instance of SMBIOS string 1 - N.
@retval NULL Instance of Type SMBIOS string was not found. @retval NULL Instance of Type SMBIOS string was not found.
@retval Other Pointer to matching SMBIOS string. @retval Other Pointer to matching SMBIOS string.
**/ **/
CHAR8 * CHAR8 *
EFIAPI EFIAPI
SmbiosLibReadString ( SmbiosLibReadString (
IN SMBIOS_STRUCTURE *Header, IN SMBIOS_STRUCTURE *Header,
IN EFI_SMBIOS_STRING StringNumber IN EFI_SMBIOS_STRING StringNumber
) )
{ {
CHAR8 *Data; CHAR8 *Data;
UINTN Match; UINTN Match;
Data = (CHAR8 *)Header + Header->Length; Data = (CHAR8 *)Header + Header->Length;
for (Match = 1;!(*Data == 0 && *(Data+1) == 0); ) { for (Match = 1;!(*Data == 0 && *(Data+1) == 0); ) {
if (StringNumber == Match) { if (StringNumber == Match) {
return Data; return Data;
} }
Data++; Data++;
if (*(Data - 1) == '\0') { if (*(Data - 1) == '\0') {
Match++; Match++;
} }
} }
return NULL; return NULL;
} }
/** /**
Allow the caller to discover a specific SMBIOS entry, and patch it if necissary. Allow the caller to discover a specific SMBIOS entry, and patch it if necissary.
@param[in] Type Type of the next SMBIOS record to return. @param[in] Type Type of the next SMBIOS record to return.
@param[in[ Instance Instance of SMBIOS record 0 - N-1. @param[in[ Instance Instance of SMBIOS record 0 - N-1.
@param[out] SmbiosHandle Returns SMBIOS handle for the matching record. @param[out] SmbiosHandle Returns SMBIOS handle for the matching record.
@retval NULL Instance of Type SMBIOS record was not found. @retval NULL Instance of Type SMBIOS record was not found.
@retval Other Pointer to matching SMBIOS record. @retval Other Pointer to matching SMBIOS record.
**/ **/
SMBIOS_STRUCTURE * SMBIOS_STRUCTURE *
EFIAPI EFIAPI
SmbiosLibGetRecord ( SmbiosLibGetRecord (
IN EFI_SMBIOS_TYPE Type, IN EFI_SMBIOS_TYPE Type,
IN UINTN Instance, IN UINTN Instance,
OUT EFI_SMBIOS_HANDLE *SmbiosHandle OUT EFI_SMBIOS_HANDLE *SmbiosHandle
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_SMBIOS_TABLE_HEADER *Record; EFI_SMBIOS_TABLE_HEADER *Record;
UINTN Match; UINTN Match;
Match = 0; Match = 0;
*SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED; *SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
do { do {
Status = gSmbios->GetNext (gSmbios, SmbiosHandle, &Type, &Record, NULL); Status = gSmbios->GetNext (gSmbios, SmbiosHandle, &Type, &Record, NULL);
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
if (Match == Instance) { if (Match == Instance) {
return (SMBIOS_STRUCTURE *)Record; return (SMBIOS_STRUCTURE *)Record;
} }
Match++; Match++;
} }
} while (!EFI_ERROR (Status)); } while (!EFI_ERROR (Status));
return NULL; return NULL;
} }
/** /**
Remove an SMBIOS record. Remove an SMBIOS record.
This function removes an SMBIOS record using the handle specified by SmbiosHandle. This function removes an SMBIOS record using the handle specified by SmbiosHandle.
@param[in] SmbiosHandle The handle of the SMBIOS record to remove. @param[in] SmbiosHandle The handle of the SMBIOS record to remove.
@retval EFI_SUCCESS SMBIOS record was removed. @retval EFI_SUCCESS SMBIOS record was removed.
@retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record. @retval EFI_INVALID_PARAMETER SmbiosHandle does not specify a valid SMBIOS record.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibRemove ( SmbiosLibRemove (
OUT EFI_SMBIOS_HANDLE SmbiosHandle OUT EFI_SMBIOS_HANDLE SmbiosHandle
) )
{ {
return gSmbios->Remove (gSmbios, SmbiosHandle); return gSmbios->Remove (gSmbios, SmbiosHandle);
} }
/** /**
@param ImageHandle ImageHandle of the loaded driver. @param ImageHandle ImageHandle of the loaded driver.
@param SystemTable Pointer to the EFI System Table. @param SystemTable Pointer to the EFI System Table.
@retval EFI_SUCCESS Register successfully. @retval EFI_SUCCESS Register successfully.
@retval EFI_OUT_OF_RESOURCES No enough memory to register this handler. @retval EFI_OUT_OF_RESOURCES No enough memory to register this handler.
**/ **/
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SmbiosLibConstructor ( SmbiosLibConstructor (
IN EFI_HANDLE ImageHandle, IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable IN EFI_SYSTEM_TABLE *SystemTable
) )
{ {
return gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&gSmbios); return gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID **)&gSmbios);
} }

94
EmulatorPkg/Library/SmbiosLib/SmbiosLib.inf
View File

@ -1,47 +1,47 @@
## @file ## @file
# SMBIOS Library # SMBIOS Library
# #
# Copyright (c) 2012, Apple Inc. All rights reserved. # Copyright (c) 2012, Apple Inc. All rights reserved.
# Portions copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
# #
# This program and the accompanying materials # This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License # 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 # which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php # http://opensource.org/licenses/bsd-license.php
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
# #
# #
## ##
[Defines] [Defines]
INF_VERSION = 0x00010005 INF_VERSION = 0x00010005
BASE_NAME = SmbiosLib BASE_NAME = SmbiosLib
FILE_GUID = 881863A2-09FD-3E44-8D62-7AE038D03747 FILE_GUID = 881863A2-09FD-3E44-8D62-7AE038D03747
MODULE_TYPE = DXE_DRIVER MODULE_TYPE = DXE_DRIVER
VERSION_STRING = 1.0 VERSION_STRING = 1.0
LIBRARY_CLASS = SmbiosLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER SMM_CORE UEFI_APPLICATION UEFI_DRIVER LIBRARY_CLASS = SmbiosLib|DXE_CORE DXE_DRIVER DXE_RUNTIME_DRIVER DXE_SAL_DRIVER DXE_SMM_DRIVER SMM_CORE UEFI_APPLICATION UEFI_DRIVER
CONSTRUCTOR = SmbiosLibConstructor CONSTRUCTOR = SmbiosLibConstructor
[Sources] [Sources]
SmbiosLib.c SmbiosLib.c
[Packages] [Packages]
MdePkg/MdePkg.dec MdePkg/MdePkg.dec
EmulatorPkg/EmulatorPkg.dec EmulatorPkg/EmulatorPkg.dec
[LibraryClasses] [LibraryClasses]
BaseLib BaseLib
BaseMemoryLib BaseMemoryLib
DebugLib DebugLib
MemoryAllocationLib MemoryAllocationLib
UefiBootServicesTableLib UefiBootServicesTableLib
UefiLib UefiLib
[Protocols] [Protocols]
gEfiSmbiosProtocolGuid gEfiSmbiosProtocolGuid
[Depex] [Depex]
gEfiSmbiosProtocolGuid gEfiSmbiosProtocolGuid

4
EmulatorPkg/MiscSubClassPlatformDxe/MiscSubClassDriver.h
View File

@ -112,8 +112,8 @@ extern EFI_HII_HANDLE mHiiHandle;
@param Smbios The EFI_SMBIOS_PROTOCOL instance. @param Smbios The EFI_SMBIOS_PROTOCOL instance.
@param SmbiosHandle A unique handle will be assigned to the SMBIOS record. @param SmbiosHandle A unique handle will be assigned to the SMBIOS record.
@param Record The data for the fixed portion of the SMBIOS record. The format of the record is @param Record The data for the fixed portion of the SMBIOS record. The format of the record is
determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined
by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or
a set of null terminated strings and a null. a set of null terminated strings and a null.
@retval EFI_SUCCESS Record was added. @retval EFI_SUCCESS Record was added.

4
EmulatorPkg/MiscSubClassPlatformDxe/MiscSubclassDriverEntryPoint.c
View File

@ -174,8 +174,8 @@ Returns:
@param Smbios The EFI_SMBIOS_PROTOCOL instance. @param Smbios The EFI_SMBIOS_PROTOCOL instance.
@param SmbiosHandle A unique handle will be assigned to the SMBIOS record. @param SmbiosHandle A unique handle will be assigned to the SMBIOS record.
@param Record The data for the fixed portion of the SMBIOS record. The format of the record is @param Record The data for the fixed portion of the SMBIOS record. The format of the record is
determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined determined by EFI_SMBIOS_TABLE_HEADER.Type. The size of the formatted area is defined
by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or by EFI_SMBIOS_TABLE_HEADER.Length and either followed by a double-null (0x0000) or
a set of null terminated strings and a null. a set of null terminated strings and a null.
@retval EFI_SUCCESS Record was added. @retval EFI_SUCCESS Record was added.

18
EmulatorPkg/PlatformSmbiosDxe/PlatformSmbiosDxe.c
View File

@ -66,10 +66,10 @@ CreatePlatformSmbiosMemoryRecords (
while ((HobPtr.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, HobPtr.Raw)) != NULL) { while ((HobPtr.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, HobPtr.Raw)) != NULL) {
if (HobPtr.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) { if (HobPtr.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) {
gSmbiosType19Template.ExtendedStartingAddress = HobPtr.ResourceDescriptor->PhysicalStart; gSmbiosType19Template.ExtendedStartingAddress = HobPtr.ResourceDescriptor->PhysicalStart;
gSmbiosType19Template.ExtendedEndingAddress = gSmbiosType19Template.ExtendedEndingAddress =
HobPtr.ResourceDescriptor->PhysicalStart + HobPtr.ResourceDescriptor->PhysicalStart +
HobPtr.ResourceDescriptor->ResourceLength - 1; HobPtr.ResourceDescriptor->ResourceLength - 1;
SmbiosLibCreateEntry ((SMBIOS_STRUCTURE *)&gSmbiosType19Template, NULL); SmbiosLibCreateEntry ((SMBIOS_STRUCTURE *)&gSmbiosType19Template, NULL);
} }
HobPtr.Raw = GET_NEXT_HOB (HobPtr); HobPtr.Raw = GET_NEXT_HOB (HobPtr);
@ -97,7 +97,7 @@ PlatfomrSmbiosDriverEntryPoint (
EFI_SMBIOS_HANDLE SmbiosHandle; EFI_SMBIOS_HANDLE SmbiosHandle;
SMBIOS_STRUCTURE_POINTER Smbios; SMBIOS_STRUCTURE_POINTER Smbios;
// Phase 0 - Patch table to make SMBIOS 2.7 structures smaller to conform // Phase 0 - Patch table to make SMBIOS 2.7 structures smaller to conform
// to an early version of the specification. // to an early version of the specification.
// Phase 1 - Initialize SMBIOS tables from template // Phase 1 - Initialize SMBIOS tables from template
@ -112,18 +112,18 @@ PlatfomrSmbiosDriverEntryPoint (
Smbios.Type0->BiosSize = (UINT8)DivU64x32 (FixedPcdGet64 (PcdEmuFirmwareFdSize), 64*1024) - 1; Smbios.Type0->BiosSize = (UINT8)DivU64x32 (FixedPcdGet64 (PcdEmuFirmwareFdSize), 64*1024) - 1;
SmbiosLibUpdateUnicodeString ( SmbiosLibUpdateUnicodeString (
SmbiosHandle, SmbiosHandle,
Smbios.Type0->BiosVersion, Smbios.Type0->BiosVersion,
(CHAR16 *) PcdGetPtr (PcdFirmwareVersionString) (CHAR16 *) PcdGetPtr (PcdFirmwareVersionString)
); );
SmbiosLibUpdateUnicodeString ( SmbiosLibUpdateUnicodeString (
SmbiosHandle, SmbiosHandle,
Smbios.Type0->BiosReleaseDate, Smbios.Type0->BiosReleaseDate,
(CHAR16 *) PcdGetPtr (PcdFirmwareReleaseDateString) (CHAR16 *) PcdGetPtr (PcdFirmwareReleaseDateString)
); );
} }
// Phase 3 - Create tables from scratch // Phase 3 - Create tables from scratch
// Create Type 13 record from EFI Variables // Create Type 13 record from EFI Variables
// Do we need this record for EFI as the info is available from EFI varaibles // Do we need this record for EFI as the info is available from EFI varaibles

4
EmulatorPkg/PlatformSmbiosDxe/PlatformSmbiosDxe.inf
View File

@ -1,7 +1,7 @@
## @file ## @file
# Platform SMBIOS driver that fills in SMBIOS table entries. # Platform SMBIOS driver that fills in SMBIOS table entries.
# #
# Copyright (c) 2012, Apple Inc. All rights reserved. # Copyright (c) 2012, Apple Inc. All rights reserved.
# Portions copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> # Portions copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
# #
# This program and the accompanying materials # This program and the accompanying materials
@ -52,4 +52,4 @@
gEmulatorPkgTokenSpaceGuid.PcdEmuFirmwareFdSize gEmulatorPkgTokenSpaceGuid.PcdEmuFirmwareFdSize
[Depex] [Depex]
TRUE TRUE

26
EmulatorPkg/PlatformSmbiosDxe/SmbiosTable.c
View File

@ -8,7 +8,7 @@
Processor Information (Type 4) - CPU Driver Processor Information (Type 4) - CPU Driver
Cache Information (Type 7) - For cache that is external to processor Cache Information (Type 7) - For cache that is external to processor
System Slots (Type 9) - If system has slots System Slots (Type 9) - If system has slots
Physical Memory Array (Type 16) Physical Memory Array (Type 16)
Memory Device (Type 17) - For each socketed system-memory Device Memory Device (Type 17) - For each socketed system-memory Device
Memory Array Mapped Address (Type 19) - One per contiguous block per Physical Memroy Array Memory Array Mapped Address (Type 19) - One per contiguous block per Physical Memroy Array
System Boot Information (Type 32) System Boot Information (Type 32)
@ -69,9 +69,9 @@ SMBIOS_TABLE_TYPE0 gSmbiosType0Template = {
0, // PrinterIsSupported :1; 0, // PrinterIsSupported :1;
0, // CgaMonoIsSupported :1; 0, // CgaMonoIsSupported :1;
0, // NecPc98 :1; 0, // NecPc98 :1;
0 // ReservedForVendor :32; ///< Bits 32-63. Bits 32-47 reserved for BIOS vendor 0 // ReservedForVendor :32; ///< Bits 32-63. Bits 32-47 reserved for BIOS vendor
///< and bits 48-63 reserved for System Vendor. ///< and bits 48-63 reserved for System Vendor.
}, },
{ // BIOSCharacteristicsExtensionBytes[] { // BIOSCharacteristicsExtensionBytes[]
0x81, // AcpiIsSupported :1; 0x81, // AcpiIsSupported :1;
// UsbLegacyIsSupported :1; // UsbLegacyIsSupported :1;
@ -108,7 +108,7 @@ SMBIOS_TABLE_TYPE1 gSmbiosType1Template = {
3, // Version String 3, // Version String
4, // SerialNumber String 4, // SerialNumber String
{ 0x25EF0280, 0xEC82, 0x42B0, { 0x8F, 0xB6, 0x10, 0xAD, 0xCC, 0xC6, 0x7C, 0x02 } }, { 0x25EF0280, 0xEC82, 0x42B0, { 0x8F, 0xB6, 0x10, 0xAD, 0xCC, 0xC6, 0x7C, 0x02 } },
SystemWakeupTypePowerSwitch, SystemWakeupTypePowerSwitch,
5, // SKUNumber String 5, // SKUNumber String
6, // Family String 6, // Family String
}; };
@ -119,7 +119,7 @@ CHAR8 *gSmbiosType1Strings[] = {
"System Serial#", "System Serial#",
"System SKU#", "System SKU#",
"edk2", "edk2",
NULL NULL
}; };
SMBIOS_TABLE_TYPE2 gSmbiosType2Template = { SMBIOS_TABLE_TYPE2 gSmbiosType2Template = {
@ -139,7 +139,7 @@ SMBIOS_TABLE_TYPE2 gSmbiosType2Template = {
}, },
6, // LocationInChassis String 6, // LocationInChassis String
0, // ChassisHandle; 0, // ChassisHandle;
BaseBoardTypeMotherBoard, // BoardType; BaseBoardTypeMotherBoard, // BoardType;
0, // NumberOfContainedObjectHandles; 0, // NumberOfContainedObjectHandles;
{ 0 } // ContainedObjectHandles[1]; { 0 } // ContainedObjectHandles[1];
}; };
@ -150,7 +150,7 @@ CHAR8 *gSmbiosType2Strings[] = {
"Base Board Serial#", "Base Board Serial#",
"Base Board Asset Tag#", "Base Board Asset Tag#",
"Part Component", "Part Component",
NULL NULL
}; };
SMBIOS_TABLE_TYPE3 gSmbiosType3Template = { SMBIOS_TABLE_TYPE3 gSmbiosType3Template = {
@ -160,10 +160,10 @@ SMBIOS_TABLE_TYPE3 gSmbiosType3Template = {
2, // Version String 2, // Version String
3, // SerialNumber String 3, // SerialNumber String
4, // AssetTag String 4, // AssetTag String
ChassisStateSafe, // BootupState; ChassisStateSafe, // BootupState;
ChassisStateSafe, // PowerSupplyState; ChassisStateSafe, // PowerSupplyState;
ChassisStateSafe, // ThermalState; ChassisStateSafe, // ThermalState;
ChassisSecurityStatusNone,// SecurityStatus; ChassisSecurityStatusNone,// SecurityStatus;
{ 0, 0, 0, 0 }, // OemDefined[4]; { 0, 0, 0, 0 }, // OemDefined[4];
0, // Height; 0, // Height;
0, // NumberofPowerCords; 0, // NumberofPowerCords;
@ -176,7 +176,7 @@ CHAR8 *gSmbiosType3Strings[] = {
"EmulatorPkg", "EmulatorPkg",
"Chassis Board Serial#", "Chassis Board Serial#",
"Chassis Board Asset Tag#", "Chassis Board Asset Tag#",
NULL NULL
}; };
SMBIOS_TABLE_TYPE8 gSmbiosType8Template1 = { SMBIOS_TABLE_TYPE8 gSmbiosType8Template1 = {

26
EmulatorPkg/Sec/Ia32/SwitchRam.asm
View File

@ -22,7 +22,7 @@
.586p .586p
.model flat,C .model flat,C
.code .code
;------------------------------------------------------------------------------ ;------------------------------------------------------------------------------
; VOID ; VOID
; EFIAPI ; EFIAPI
@ -30,7 +30,7 @@
; UINT32 TemporaryMemoryBase, ; UINT32 TemporaryMemoryBase,
; UINT32 PermenentMemoryBase ; UINT32 PermenentMemoryBase
; ); ; );
;------------------------------------------------------------------------------ ;------------------------------------------------------------------------------
SecSwitchStack PROC SecSwitchStack PROC
; ;
; Save three register: eax, ebx, ecx ; Save three register: eax, ebx, ecx
@ -39,16 +39,16 @@ SecSwitchStack PROC
push ebx push ebx
push ecx push ecx
push edx push edx
; ;
; !!CAUTION!! this function address's is pushed into stack after ; !!CAUTION!! this function address's is pushed into stack after
; migration of whole temporary memory, so need save it to permenent ; migration of whole temporary memory, so need save it to permenent
; memory at first! ; memory at first!
; ;
mov ebx, [esp + 20] ; Save the first parameter mov ebx, [esp + 20] ; Save the first parameter
mov ecx, [esp + 24] ; Save the second parameter mov ecx, [esp + 24] ; Save the second parameter
; ;
; Save this function's return address into permenent memory at first. ; Save this function's return address into permenent memory at first.
; Then, Fixup the esp point to permenent memory ; Then, Fixup the esp point to permenent memory
@ -57,17 +57,17 @@ SecSwitchStack PROC
sub eax, ebx sub eax, ebx
add eax, ecx add eax, ecx
mov edx, dword ptr [esp] ; copy pushed register's value to permenent memory mov edx, dword ptr [esp] ; copy pushed register's value to permenent memory
mov dword ptr [eax], edx mov dword ptr [eax], edx
mov edx, dword ptr [esp + 4] mov edx, dword ptr [esp + 4]
mov dword ptr [eax + 4], edx mov dword ptr [eax + 4], edx
mov edx, dword ptr [esp + 8] mov edx, dword ptr [esp + 8]
mov dword ptr [eax + 8], edx mov dword ptr [eax + 8], edx
mov edx, dword ptr [esp + 12] mov edx, dword ptr [esp + 12]
mov dword ptr [eax + 12], edx mov dword ptr [eax + 12], edx
mov edx, dword ptr [esp + 16] ; Update this function's return address into permenent memory mov edx, dword ptr [esp + 16] ; Update this function's return address into permenent memory
mov dword ptr [eax + 16], edx mov dword ptr [eax + 16], edx
mov esp, eax ; From now, esp is pointed to permenent memory mov esp, eax ; From now, esp is pointed to permenent memory
; ;
; Fixup the ebp point to permenent memory ; Fixup the ebp point to permenent memory
; ;
@ -75,7 +75,7 @@ SecSwitchStack PROC
sub eax, ebx sub eax, ebx
add eax, ecx add eax, ecx
mov ebp, eax ; From now, ebp is pointed to permenent memory mov ebp, eax ; From now, ebp is pointed to permenent memory
; ;
; Fixup callee's ebp point for PeiDispatch ; Fixup callee's ebp point for PeiDispatch
; ;
@ -83,7 +83,7 @@ SecSwitchStack PROC
sub eax, ebx sub eax, ebx
add eax, ecx add eax, ecx
mov dword ptr [ebp], eax ; From now, Temporary's PPI caller's stack is in permenent memory mov dword ptr [ebp], eax ; From now, Temporary's PPI caller's stack is in permenent memory
pop edx pop edx
pop ecx pop ecx
pop ebx pop ebx

298
EmulatorPkg/Sec/Sec.c
View File

@ -1,149 +1,149 @@
/*++ @file /*++ @file
Stub SEC that is called from the OS appliation that is the root of the emulator. Stub SEC that is called from the OS appliation that is the root of the emulator.
The OS application will call the SEC with the PEI Entry Point API. The OS application will call the SEC with the PEI Entry Point API.
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include "Sec.h" #include "Sec.h"
EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mSecTemporaryRamSupportPpi = { EFI_PEI_TEMPORARY_RAM_SUPPORT_PPI mSecTemporaryRamSupportPpi = {
SecTemporaryRamSupport SecTemporaryRamSupport
}; };
EFI_PEI_PPI_DESCRIPTOR gPrivateDispatchTable[] = { EFI_PEI_PPI_DESCRIPTOR gPrivateDispatchTable[] = {
{ {
EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST, EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
&gEfiTemporaryRamSupportPpiGuid, &gEfiTemporaryRamSupportPpiGuid,
&mSecTemporaryRamSupportPpi &mSecTemporaryRamSupportPpi
} }
}; };
/** /**
The entry point of PE/COFF Image for the PEI Core, that has been hijacked by this The entry point of PE/COFF Image for the PEI Core, that has been hijacked by this
SEC that sits on top of an OS application. So the entry and exit of this module SEC that sits on top of an OS application. So the entry and exit of this module
has the same API. has the same API.
This function is the entry point for the PEI Foundation, which allows the SEC phase This function is the entry point for the PEI Foundation, which allows the SEC phase
to pass information about the stack, temporary RAM and the Boot Firmware Volume. to pass information about the stack, temporary RAM and the Boot Firmware Volume.
In addition, it also allows the SEC phase to pass services and data forward for use In addition, it also allows the SEC phase to pass services and data forward for use
during the PEI phase in the form of one or more PPIs. during the PEI phase in the form of one or more PPIs.
There is no limit to the number of additional PPIs that can be passed from SEC into There is no limit to the number of additional PPIs that can be passed from SEC into
the PEI Foundation. As part of its initialization phase, the PEI Foundation will add the PEI Foundation. As part of its initialization phase, the PEI Foundation will add
these SEC-hosted PPIs to its PPI database such that both the PEI Foundation and any these SEC-hosted PPIs to its PPI database such that both the PEI Foundation and any
modules can leverage the associated service calls and/or code in these early PPIs. modules can leverage the associated service calls and/or code in these early PPIs.
This function is required to call ProcessModuleEntryPointList() with the Context This function is required to call ProcessModuleEntryPointList() with the Context
parameter set to NULL. ProcessModuleEntryPoint() is never expected to return. parameter set to NULL. ProcessModuleEntryPoint() is never expected to return.
The PEI Core is responsible for calling ProcessLibraryConstructorList() as soon as The PEI Core is responsible for calling ProcessLibraryConstructorList() as soon as
the PEI Services Table and the file handle for the PEI Core itself have been established. the PEI Services Table and the file handle for the PEI Core itself have been established.
If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system. If ProcessModuleEntryPointList() returns, then ASSERT() and halt the system.
@param SecCoreData Points to a data structure containing information about the PEI @param SecCoreData Points to a data structure containing information about the PEI
core's operating environment, such as the size and location of core's operating environment, such as the size and location of
temporary RAM, the stack location and the BFV location. temporary RAM, the stack location and the BFV location.
@param PpiList Points to a list of one or more PPI descriptors to be installed @param PpiList Points to a list of one or more PPI descriptors to be installed
initially by the PEI core. An empty PPI list consists of a single initially by the PEI core. An empty PPI list consists of a single
descriptor with the end-tag EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST. descriptor with the end-tag EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST.
As part of its initialization phase, the PEI Foundation will add As part of its initialization phase, the PEI Foundation will add
these SEC-hosted PPIs to its PPI database such that both the PEI these SEC-hosted PPIs to its PPI database such that both the PEI
Foundation and any modules can leverage the associated service calls Foundation and any modules can leverage the associated service calls
and/or code in these early PPIs. and/or code in these early PPIs.
**/ **/
VOID VOID
EFIAPI EFIAPI
_ModuleEntryPoint ( _ModuleEntryPoint (
IN EFI_SEC_PEI_HAND_OFF *SecCoreData, IN EFI_SEC_PEI_HAND_OFF *SecCoreData,
IN EFI_PEI_PPI_DESCRIPTOR *PpiList IN EFI_PEI_PPI_DESCRIPTOR *PpiList
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_PEI_FV_HANDLE VolumeHandle; EFI_PEI_FV_HANDLE VolumeHandle;
EFI_PEI_FILE_HANDLE FileHandle; EFI_PEI_FILE_HANDLE FileHandle;
VOID *PeCoffImage; VOID *PeCoffImage;
EFI_PEI_CORE_ENTRY_POINT EntryPoint; EFI_PEI_CORE_ENTRY_POINT EntryPoint;
EFI_PEI_PPI_DESCRIPTOR *Ppi; EFI_PEI_PPI_DESCRIPTOR *Ppi;
EFI_PEI_PPI_DESCRIPTOR *SecPpiList; EFI_PEI_PPI_DESCRIPTOR *SecPpiList;
UINTN SecReseveredMemorySize; UINTN SecReseveredMemorySize;
UINTN Index; UINTN Index;
EMU_MAGIC_PAGE()->PpiList = PpiList; EMU_MAGIC_PAGE()->PpiList = PpiList;
ProcessLibraryConstructorList (); ProcessLibraryConstructorList ();
DEBUG ((EFI_D_ERROR, "SEC Has Started\n")); DEBUG ((EFI_D_ERROR, "SEC Has Started\n"));
// //
// Add Our PPIs to the list // Add Our PPIs to the list
// //
SecReseveredMemorySize = sizeof (gPrivateDispatchTable); SecReseveredMemorySize = sizeof (gPrivateDispatchTable);
for (Ppi = PpiList, Index = 1; ; Ppi++, Index++) { for (Ppi = PpiList, Index = 1; ; Ppi++, Index++) {
SecReseveredMemorySize += sizeof (EFI_PEI_PPI_DESCRIPTOR); SecReseveredMemorySize += sizeof (EFI_PEI_PPI_DESCRIPTOR);
if ((Ppi->Flags & EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST) == EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST) { if ((Ppi->Flags & EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST) == EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST) {
// Since we are appending, need to clear out privious list terminator. // Since we are appending, need to clear out privious list terminator.
Ppi->Flags &= ~EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST; Ppi->Flags &= ~EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST;
break; break;
} }
} }
// Keep everything on a good alignment // Keep everything on a good alignment
SecReseveredMemorySize = ALIGN_VALUE (SecReseveredMemorySize, CPU_STACK_ALIGNMENT); SecReseveredMemorySize = ALIGN_VALUE (SecReseveredMemorySize, CPU_STACK_ALIGNMENT);
#if 0 #if 0
// Tell the PEI Core to not use our buffer in temp RAM // Tell the PEI Core to not use our buffer in temp RAM
SecPpiList = (EFI_PEI_PPI_DESCRIPTOR *)SecCoreData->PeiTemporaryRamBase; SecPpiList = (EFI_PEI_PPI_DESCRIPTOR *)SecCoreData->PeiTemporaryRamBase;
SecCoreData->PeiTemporaryRamBase = (VOID *)((UINTN)SecCoreData->PeiTemporaryRamBase + SecReseveredMemorySize); SecCoreData->PeiTemporaryRamBase = (VOID *)((UINTN)SecCoreData->PeiTemporaryRamBase + SecReseveredMemorySize);
SecCoreData->PeiTemporaryRamSize -= SecReseveredMemorySize; SecCoreData->PeiTemporaryRamSize -= SecReseveredMemorySize;
#else #else
{ {
// //
// When I subtrack from SecCoreData->PeiTemporaryRamBase PEI Core crashes? Either there is a bug // When I subtrack from SecCoreData->PeiTemporaryRamBase PEI Core crashes? Either there is a bug
// or I don't understand temp RAM correctly? // or I don't understand temp RAM correctly?
// //
EFI_PEI_PPI_DESCRIPTOR PpiArray[10]; EFI_PEI_PPI_DESCRIPTOR PpiArray[10];
SecPpiList = &PpiArray[0]; SecPpiList = &PpiArray[0];
ASSERT (sizeof (PpiArray) >= SecReseveredMemorySize); ASSERT (sizeof (PpiArray) >= SecReseveredMemorySize);
} }
#endif #endif
// Copy existing list, and append our entries. // Copy existing list, and append our entries.
CopyMem (SecPpiList, PpiList, sizeof (EFI_PEI_PPI_DESCRIPTOR) * Index); CopyMem (SecPpiList, PpiList, sizeof (EFI_PEI_PPI_DESCRIPTOR) * Index);
CopyMem (&SecPpiList[Index], gPrivateDispatchTable, sizeof (gPrivateDispatchTable)); CopyMem (&SecPpiList[Index], gPrivateDispatchTable, sizeof (gPrivateDispatchTable));
// Find PEI Core and transfer control // Find PEI Core and transfer control
VolumeHandle = (EFI_PEI_FV_HANDLE)(UINTN)SecCoreData->BootFirmwareVolumeBase; VolumeHandle = (EFI_PEI_FV_HANDLE)(UINTN)SecCoreData->BootFirmwareVolumeBase;
FileHandle = NULL; FileHandle = NULL;
Status = PeiServicesFfsFindNextFile (EFI_FV_FILETYPE_PEI_CORE, VolumeHandle, &FileHandle); Status = PeiServicesFfsFindNextFile (EFI_FV_FILETYPE_PEI_CORE, VolumeHandle, &FileHandle);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
Status = PeiServicesFfsFindSectionData (EFI_SECTION_PE32, FileHandle, &PeCoffImage); Status = PeiServicesFfsFindSectionData (EFI_SECTION_PE32, FileHandle, &PeCoffImage);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
Status = PeCoffLoaderGetEntryPoint (PeCoffImage, (VOID **)&EntryPoint); Status = PeCoffLoaderGetEntryPoint (PeCoffImage, (VOID **)&EntryPoint);
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
// Transfer control to PEI Core // Transfer control to PEI Core
EntryPoint (SecCoreData, SecPpiList); EntryPoint (SecCoreData, SecPpiList);
// PEI Core never returns // PEI Core never returns
ASSERT (FALSE); ASSERT (FALSE);
return; return;
} }

102
EmulatorPkg/Sec/Sec.h
View File

@ -1,51 +1,51 @@
/*++ @file /*++ @file
Stub SEC that is called from the OS appliation that is the root of the emulator. Stub SEC that is called from the OS appliation that is the root of the emulator.
The OS application will call the SEC with the PEI Entry Point API. The OS application will call the SEC with the PEI Entry Point API.
Copyright (c) 2011, Apple Inc. All rights reserved.<BR> Copyright (c) 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#ifndef __SEC_H___ #ifndef __SEC_H___
#define __SEC_H___ #define __SEC_H___
#include <PiPei.h> #include <PiPei.h>
#include <Library/EmuMagicPageLib.h> #include <Library/EmuMagicPageLib.h>
#include <Library/DebugLib.h> #include <Library/DebugLib.h>
#include <Library/PeiServicesLib.h> #include <Library/PeiServicesLib.h>
#include <Library/PeCoffGetEntryPointLib.h> #include <Library/PeCoffGetEntryPointLib.h>
#include <Library/BaseMemoryLib.h> #include <Library/BaseMemoryLib.h>
#include <Ppi/TemporaryRamSupport.h> #include <Ppi/TemporaryRamSupport.h>
// //
// I think this shold be defined in a MdePkg include file? // I think this shold be defined in a MdePkg include file?
// //
VOID VOID
EFIAPI EFIAPI
ProcessLibraryConstructorList ( ProcessLibraryConstructorList (
VOID VOID
); );
EFI_STATUS EFI_STATUS
EFIAPI EFIAPI
SecTemporaryRamSupport ( SecTemporaryRamSupport (
IN CONST EFI_PEI_SERVICES **PeiServices, IN CONST EFI_PEI_SERVICES **PeiServices,
IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase, IN EFI_PHYSICAL_ADDRESS TemporaryMemoryBase,
IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase, IN EFI_PHYSICAL_ADDRESS PermanentMemoryBase,
IN UINTN CopySize IN UINTN CopySize
); );
#endif #endif

74
EmulatorPkg/Unix/Host/BerkeleyPacketFilter.c
View File

@ -47,8 +47,8 @@ typedef struct {
VOID *CurrentReadPointer; VOID *CurrentReadPointer;
VOID *EndReadPointer; VOID *EndReadPointer;
UINT32 ReceivedPackets; UINT32 ReceivedPackets;
UINT32 DroppedPackets; UINT32 DroppedPackets;
} EMU_SNP_PRIVATE; } EMU_SNP_PRIVATE;
@ -200,8 +200,8 @@ EmuSnpStart (
struct ifreq BoundIf; struct ifreq BoundIf;
struct bpf_program BpfProgram; struct bpf_program BpfProgram;
struct bpf_insn *FilterProgram; struct bpf_insn *FilterProgram;
u_int Value; u_int Value;
u_int ReadBufferSize; u_int ReadBufferSize;
UINT16 Temp16; UINT16 Temp16;
UINT32 Temp32; UINT32 Temp32;
@ -229,23 +229,23 @@ EmuSnpStart (
} }
// //
// Get the read buffer size. // Get the read buffer size.
// //
if (ioctl (Private->BpfFd, BIOCGBLEN, &ReadBufferSize) < 0) { if (ioctl (Private->BpfFd, BIOCGBLEN, &ReadBufferSize) < 0) {
goto DeviceErrorExit; goto DeviceErrorExit;
} }
// //
// Default value from BIOCGBLEN is usually too small, so use a much larger size, if necessary. // Default value from BIOCGBLEN is usually too small, so use a much larger size, if necessary.
// //
if (ReadBufferSize < FixedPcdGet32 (PcdNetworkPacketFilterSize)) { if (ReadBufferSize < FixedPcdGet32 (PcdNetworkPacketFilterSize)) {
ReadBufferSize = FixedPcdGet32 (PcdNetworkPacketFilterSize); ReadBufferSize = FixedPcdGet32 (PcdNetworkPacketFilterSize);
if (ioctl (Private->BpfFd, BIOCSBLEN, &ReadBufferSize) < 0) { if (ioctl (Private->BpfFd, BIOCSBLEN, &ReadBufferSize) < 0) {
goto DeviceErrorExit; goto DeviceErrorExit;
} }
} }
// //
// Associate our interface with this BPF file descriptor. // Associate our interface with this BPF file descriptor.
// //
AsciiStrCpy (BoundIf.ifr_name, Private->InterfaceName); AsciiStrCpy (BoundIf.ifr_name, Private->InterfaceName);
@ -254,7 +254,7 @@ EmuSnpStart (
} }
// //
// Enable immediate mode. // Enable immediate mode.
// //
Value = 1; Value = 1;
if (ioctl (Private->BpfFd, BIOCIMMEDIATE, &Value) < 0) { if (ioctl (Private->BpfFd, BIOCIMMEDIATE, &Value) < 0) {
@ -286,8 +286,8 @@ EmuSnpStart (
// //
// Allocate read buffer. // Allocate read buffer.
// //
Private->ReadBufferSize = ReadBufferSize; Private->ReadBufferSize = ReadBufferSize;
Private->ReadBuffer = malloc (Private->ReadBufferSize); Private->ReadBuffer = malloc (Private->ReadBufferSize);
if (Private->ReadBuffer == NULL) { if (Private->ReadBuffer == NULL) {
goto ErrorExit; goto ErrorExit;
} }
@ -295,7 +295,7 @@ EmuSnpStart (
Private->CurrentReadPointer = Private->EndReadPointer = Private->ReadBuffer; Private->CurrentReadPointer = Private->EndReadPointer = Private->ReadBuffer;
// //
// Install our packet filter: successful reads should only produce broadcast or unicast // Install our packet filter: successful reads should only produce broadcast or unicast
// packets directed to our fake MAC address. // packets directed to our fake MAC address.
// //
FilterProgram = malloc (sizeof (mFilterInstructionTemplate)) ; FilterProgram = malloc (sizeof (mFilterInstructionTemplate)) ;
@ -906,7 +906,7 @@ EmuSnpReceive (
{ {
EMU_SNP_PRIVATE *Private; EMU_SNP_PRIVATE *Private;
struct bpf_hdr *BpfHeader; struct bpf_hdr *BpfHeader;
struct bpf_stat BpfStats; struct bpf_stat BpfStats;
ETHERNET_HEADER *EnetHeader; ETHERNET_HEADER *EnetHeader;
ssize_t Result; ssize_t Result;
@ -916,19 +916,19 @@ EmuSnpReceive (
return EFI_NOT_STARTED; return EFI_NOT_STARTED;
} }
ZeroMem (&BpfStats, sizeof( BpfStats)); ZeroMem (&BpfStats, sizeof( BpfStats));
if (ioctl (Private->BpfFd, BIOCGSTATS, &BpfStats) == 0) { if (ioctl (Private->BpfFd, BIOCGSTATS, &BpfStats) == 0) {
Private->ReceivedPackets += BpfStats.bs_recv; Private->ReceivedPackets += BpfStats.bs_recv;
if (BpfStats.bs_drop > Private->DroppedPackets) { if (BpfStats.bs_drop > Private->DroppedPackets) {
printf ( printf (
"SNP: STATS: RCVD = %d DROPPED = %d. Probably need to increase BPF PcdNetworkPacketFilterSize?\n", "SNP: STATS: RCVD = %d DROPPED = %d. Probably need to increase BPF PcdNetworkPacketFilterSize?\n",
BpfStats.bs_recv, BpfStats.bs_recv,
BpfStats.bs_drop - Private->DroppedPackets BpfStats.bs_drop - Private->DroppedPackets
); );
Private->DroppedPackets = BpfStats.bs_drop; Private->DroppedPackets = BpfStats.bs_drop;
} }
} }
// //
// Do we have any remaining packets from the previous read? // Do we have any remaining packets from the previous read?
@ -1004,7 +1004,7 @@ GetInterfaceMacAddr (
EMU_SNP_PRIVATE *Private EMU_SNP_PRIVATE *Private
) )
{ {
EFI_STATUS Status; EFI_STATUS Status;
struct ifaddrs *IfAddrs; struct ifaddrs *IfAddrs;
struct ifaddrs *If; struct ifaddrs *If;
struct sockaddr_dl *IfSdl; struct sockaddr_dl *IfSdl;

2
EmulatorPkg/Unix/Host/BlockIo.c
View File

@ -347,7 +347,7 @@ EmuBlockIoReadWriteCommon (
@param[in] MediaId Id of the media, changes every time the media is @param[in] MediaId Id of the media, changes every time the media is
replaced. replaced.
@param[in] Lba The starting Logical Block Address to read from. @param[in] Lba The starting Logical Block Address to read from.
@param[in, out] Token A pointer to the token associated with the transaction. @param[in, out] Token A pointer to the token associated with the transaction.
@param[in] BufferSize Size of Buffer, must be a multiple of device block size. @param[in] BufferSize Size of Buffer, must be a multiple of device block size.
@param[out] Buffer A pointer to the destination buffer for the data. The @param[out] Buffer A pointer to the destination buffer for the data. The
caller is responsible for either having implicit or caller is responsible for either having implicit or

880
EmulatorPkg/Unix/Host/EmuThunk.c
View File

@ -1,440 +1,440 @@
/*++ @file /*++ @file
Since the SEC is the only program in our emulation we Since the SEC is the only program in our emulation we
must use a UEFI/PI mechanism to export APIs to other modules. must use a UEFI/PI mechanism to export APIs to other modules.
This is the role of the EFI_EMU_THUNK_PROTOCOL. This is the role of the EFI_EMU_THUNK_PROTOCOL.
The mUnixThunkTable exists so that a change to EFI_EMU_THUNK_PROTOCOL The mUnixThunkTable exists so that a change to EFI_EMU_THUNK_PROTOCOL
will cause an error in initializing the array if all the member functions will cause an error in initializing the array if all the member functions
are not added. It looks like adding a element to end and not initializing are not added. It looks like adding a element to end and not initializing
it may cause the table to be initaliized with the members at the end being it may cause the table to be initaliized with the members at the end being
set to zero. This is bad as jumping to zero will crash. set to zero. This is bad as jumping to zero will crash.
Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR> Copyright (c) 2004 - 2009, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR> Portions copyright (c) 2008 - 2011, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include "Host.h" #include "Host.h"
#ifdef __APPLE__ #ifdef __APPLE__
#define DebugAssert _Mangle__DebugAssert #define DebugAssert _Mangle__DebugAssert
#include <assert.h> #include <assert.h>
#include <CoreServices/CoreServices.h> #include <CoreServices/CoreServices.h>
#include <mach/mach.h> #include <mach/mach.h>
#include <mach/mach_time.h> #include <mach/mach_time.h>
#undef DebugAssert #undef DebugAssert
#endif #endif
int settimer_initialized; int settimer_initialized;
struct timeval settimer_timeval; struct timeval settimer_timeval;
void (*settimer_callback)(UINT64 delta); void (*settimer_callback)(UINT64 delta);
BOOLEAN gEmulatorInterruptEnabled = FALSE; BOOLEAN gEmulatorInterruptEnabled = FALSE;
UINTN UINTN
SecWriteStdErr ( SecWriteStdErr (
IN UINT8 *Buffer, IN UINT8 *Buffer,
IN UINTN NumberOfBytes IN UINTN NumberOfBytes
) )
{ {
ssize_t Return; ssize_t Return;
Return = write (STDERR_FILENO, (const void *)Buffer, (size_t)NumberOfBytes); Return = write (STDERR_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
return (Return == -1) ? 0 : Return; return (Return == -1) ? 0 : Return;
} }
EFI_STATUS EFI_STATUS
SecConfigStdIn ( SecConfigStdIn (
VOID VOID
) )
{ {
struct termios tty; struct termios tty;
// //
// Need to turn off line buffering, ECHO, and make it unbuffered. // Need to turn off line buffering, ECHO, and make it unbuffered.
// //
tcgetattr (STDIN_FILENO, &tty); tcgetattr (STDIN_FILENO, &tty);
tty.c_lflag &= ~(ICANON | ECHO); tty.c_lflag &= ~(ICANON | ECHO);
tcsetattr (STDIN_FILENO, TCSANOW, &tty); tcsetattr (STDIN_FILENO, TCSANOW, &tty);
// setvbuf (STDIN_FILENO, NULL, _IONBF, 0); // setvbuf (STDIN_FILENO, NULL, _IONBF, 0);
// now ioctl FIONREAD will do what we need // now ioctl FIONREAD will do what we need
return EFI_SUCCESS; return EFI_SUCCESS;
} }
UINTN UINTN
SecWriteStdOut ( SecWriteStdOut (
IN UINT8 *Buffer, IN UINT8 *Buffer,
IN UINTN NumberOfBytes IN UINTN NumberOfBytes
) )
{ {
ssize_t Return; ssize_t Return;
Return = write (STDOUT_FILENO, (const void *)Buffer, (size_t)NumberOfBytes); Return = write (STDOUT_FILENO, (const void *)Buffer, (size_t)NumberOfBytes);
return (Return == -1) ? 0 : Return; return (Return == -1) ? 0 : Return;
} }
UINTN UINTN
SecReadStdIn ( SecReadStdIn (
IN UINT8 *Buffer, IN UINT8 *Buffer,
IN UINTN NumberOfBytes IN UINTN NumberOfBytes
) )
{ {
ssize_t Return; ssize_t Return;
Return = read (STDIN_FILENO, Buffer, (size_t)NumberOfBytes); Return = read (STDIN_FILENO, Buffer, (size_t)NumberOfBytes);
return (Return == -1) ? 0 : Return; return (Return == -1) ? 0 : Return;
} }
BOOLEAN BOOLEAN
SecPollStdIn ( SecPollStdIn (
VOID VOID
) )
{ {
int Result; int Result;
int Bytes; int Bytes;
Result = ioctl (STDIN_FILENO, FIONREAD, &Bytes); Result = ioctl (STDIN_FILENO, FIONREAD, &Bytes);
if (Result == -1) { if (Result == -1) {
return FALSE; return FALSE;
} }
return (BOOLEAN)(Bytes > 0); return (BOOLEAN)(Bytes > 0);
} }
VOID * VOID *
SecMalloc ( SecMalloc (
IN UINTN Size IN UINTN Size
) )
{ {
return malloc ((size_t)Size); return malloc ((size_t)Size);
} }
VOID * VOID *
SecValloc ( SecValloc (
IN UINTN Size IN UINTN Size
) )
{ {
return valloc ((size_t)Size); return valloc ((size_t)Size);
} }
BOOLEAN BOOLEAN
SecFree ( SecFree (
IN VOID *Ptr IN VOID *Ptr
) )
{ {
if (EfiSystemMemoryRange (Ptr)) { if (EfiSystemMemoryRange (Ptr)) {
// If an address range is in the EFI memory map it was alloced via EFI. // If an address range is in the EFI memory map it was alloced via EFI.
// So don't free those ranges and let the caller know. // So don't free those ranges and let the caller know.
return FALSE; return FALSE;
} }
free (Ptr); free (Ptr);
return TRUE; return TRUE;
} }
void void
settimer_handler (int sig) settimer_handler (int sig)
{ {
struct timeval timeval; struct timeval timeval;
UINT64 delta; UINT64 delta;
gettimeofday (&timeval, NULL); gettimeofday (&timeval, NULL);
delta = ((UINT64)timeval.tv_sec * 1000) + (timeval.tv_usec / 1000) delta = ((UINT64)timeval.tv_sec * 1000) + (timeval.tv_usec / 1000)
- ((UINT64)settimer_timeval.tv_sec * 1000) - ((UINT64)settimer_timeval.tv_sec * 1000)
- (settimer_timeval.tv_usec / 1000); - (settimer_timeval.tv_usec / 1000);
settimer_timeval = timeval; settimer_timeval = timeval;
if (settimer_callback) { if (settimer_callback) {
ReverseGasketUint64 (settimer_callback, delta); ReverseGasketUint64 (settimer_callback, delta);
} }
} }
VOID VOID
SecSetTimer ( SecSetTimer (
IN UINT64 PeriodMs, IN UINT64 PeriodMs,
IN EMU_SET_TIMER_CALLBACK CallBack IN EMU_SET_TIMER_CALLBACK CallBack
) )
{ {
struct itimerval timerval; struct itimerval timerval;
UINT32 remainder; UINT32 remainder;
if (!settimer_initialized) { if (!settimer_initialized) {
struct sigaction act; struct sigaction act;
settimer_initialized = 1; settimer_initialized = 1;
act.sa_handler = settimer_handler; act.sa_handler = settimer_handler;
act.sa_flags = 0; act.sa_flags = 0;
sigemptyset (&act.sa_mask); sigemptyset (&act.sa_mask);
gEmulatorInterruptEnabled = TRUE; gEmulatorInterruptEnabled = TRUE;
if (sigaction (SIGALRM, &act, NULL) != 0) { if (sigaction (SIGALRM, &act, NULL) != 0) {
printf ("SetTimer: sigaction error %s\n", strerror (errno)); printf ("SetTimer: sigaction error %s\n", strerror (errno));
} }
if (gettimeofday (&settimer_timeval, NULL) != 0) { if (gettimeofday (&settimer_timeval, NULL) != 0) {
printf ("SetTimer: gettimeofday error %s\n", strerror (errno)); printf ("SetTimer: gettimeofday error %s\n", strerror (errno));
} }
} }
timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000); timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
DivU64x32Remainder(PeriodMs, 1000, &remainder); DivU64x32Remainder(PeriodMs, 1000, &remainder);
timerval.it_value.tv_usec = remainder * 1000; timerval.it_value.tv_usec = remainder * 1000;
timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000); timerval.it_value.tv_sec = DivU64x32(PeriodMs, 1000);
timerval.it_interval = timerval.it_value; timerval.it_interval = timerval.it_value;
if (setitimer (ITIMER_REAL, &timerval, NULL) != 0) { if (setitimer (ITIMER_REAL, &timerval, NULL) != 0) {
printf ("SetTimer: setitimer error %s\n", strerror (errno)); printf ("SetTimer: setitimer error %s\n", strerror (errno));
} }
settimer_callback = CallBack; settimer_callback = CallBack;
} }
VOID VOID
SecEnableInterrupt ( SecEnableInterrupt (
VOID VOID
) )
{ {
sigset_t sigset; sigset_t sigset;
gEmulatorInterruptEnabled = TRUE; gEmulatorInterruptEnabled = TRUE;
// Since SetTimer() uses SIGALRM we emulate turning on and off interrupts // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
// by enabling/disabling SIGALRM. // by enabling/disabling SIGALRM.
sigemptyset (&sigset); sigemptyset (&sigset);
sigaddset (&sigset, SIGALRM); sigaddset (&sigset, SIGALRM);
pthread_sigmask (SIG_UNBLOCK, &sigset, NULL); pthread_sigmask (SIG_UNBLOCK, &sigset, NULL);
} }
VOID VOID
SecDisableInterrupt ( SecDisableInterrupt (
VOID VOID
) )
{ {
sigset_t sigset; sigset_t sigset;
// Since SetTimer() uses SIGALRM we emulate turning on and off interrupts // Since SetTimer() uses SIGALRM we emulate turning on and off interrupts
// by enabling/disabling SIGALRM. // by enabling/disabling SIGALRM.
sigemptyset (&sigset); sigemptyset (&sigset);
sigaddset (&sigset, SIGALRM); sigaddset (&sigset, SIGALRM);
pthread_sigmask (SIG_BLOCK, &sigset, NULL); pthread_sigmask (SIG_BLOCK, &sigset, NULL);
gEmulatorInterruptEnabled = FALSE; gEmulatorInterruptEnabled = FALSE;
} }
BOOLEAN BOOLEAN
SecInterruptEanbled (void) SecInterruptEanbled (void)
{ {
return gEmulatorInterruptEnabled; return gEmulatorInterruptEnabled;
} }
UINT64 UINT64
QueryPerformanceFrequency ( QueryPerformanceFrequency (
VOID VOID
) )
{ {
// Hard code to nanoseconds // Hard code to nanoseconds
return 1000000000ULL; return 1000000000ULL;
} }
UINT64 UINT64
QueryPerformanceCounter ( QueryPerformanceCounter (
VOID VOID
) )
{ {
#if __APPLE__ #if __APPLE__
UINT64 Start; UINT64 Start;
static mach_timebase_info_data_t sTimebaseInfo; static mach_timebase_info_data_t sTimebaseInfo;
Start = mach_absolute_time (); Start = mach_absolute_time ();
// Convert to nanoseconds. // Convert to nanoseconds.
// If this is the first time we've run, get the timebase. // If this is the first time we've run, get the timebase.
// We can use denom == 0 to indicate that sTimebaseInfo is // We can use denom == 0 to indicate that sTimebaseInfo is
// uninitialised because it makes no sense to have a zero // uninitialised because it makes no sense to have a zero
// denominator is a fraction. // denominator is a fraction.
if ( sTimebaseInfo.denom == 0 ) { if ( sTimebaseInfo.denom == 0 ) {
(void) mach_timebase_info(&sTimebaseInfo); (void) mach_timebase_info(&sTimebaseInfo);
} }
// Do the maths. We hope that the multiplication doesn't // Do the maths. We hope that the multiplication doesn't
// overflow; the price you pay for working in fixed point. // overflow; the price you pay for working in fixed point.
return (Start * sTimebaseInfo.numer) / sTimebaseInfo.denom; return (Start * sTimebaseInfo.numer) / sTimebaseInfo.denom;
#else #else
// Need to figure out what to do for Linux? // Need to figure out what to do for Linux?
return 0; return 0;
#endif #endif
} }
VOID VOID
SecSleep ( SecSleep (
IN UINT64 Nanoseconds IN UINT64 Nanoseconds
) )
{ {
struct timespec rq, rm; struct timespec rq, rm;
struct timeval start, end; struct timeval start, end;
unsigned long MicroSec; unsigned long MicroSec;
rq.tv_sec = DivU64x32 (Nanoseconds, 1000000000); rq.tv_sec = DivU64x32 (Nanoseconds, 1000000000);
rq.tv_nsec = ModU64x32 (Nanoseconds, 1000000000); rq.tv_nsec = ModU64x32 (Nanoseconds, 1000000000);
// //
// nanosleep gets interrupted by our timer tic. // nanosleep gets interrupted by our timer tic.
// we need to track wall clock time or we will stall for way too long // we need to track wall clock time or we will stall for way too long
// //
gettimeofday (&start, NULL); gettimeofday (&start, NULL);
end.tv_sec = start.tv_sec + rq.tv_sec; end.tv_sec = start.tv_sec + rq.tv_sec;
MicroSec = (start.tv_usec + rq.tv_nsec/1000); MicroSec = (start.tv_usec + rq.tv_nsec/1000);
end.tv_usec = MicroSec % 1000000; end.tv_usec = MicroSec % 1000000;
if (MicroSec > 1000000) { if (MicroSec > 1000000) {
end.tv_sec++; end.tv_sec++;
} }
while (nanosleep (&rq, &rm) == -1) { while (nanosleep (&rq, &rm) == -1) {
if (errno != EINTR) { if (errno != EINTR) {
break; break;
} }
gettimeofday (&start, NULL); gettimeofday (&start, NULL);
if (start.tv_sec > end.tv_sec) { if (start.tv_sec > end.tv_sec) {
break; break;
} if ((start.tv_sec == end.tv_sec) && (start.tv_usec > end.tv_usec)) { } if ((start.tv_sec == end.tv_sec) && (start.tv_usec > end.tv_usec)) {
break; break;
} }
rq = rm; rq = rm;
} }
} }
VOID VOID
SecCpuSleep ( SecCpuSleep (
VOID VOID
) )
{ {
struct timespec rq, rm; struct timespec rq, rm;
// nanosleep gets interrupted by the timer tic // nanosleep gets interrupted by the timer tic
rq.tv_sec = 1; rq.tv_sec = 1;
rq.tv_nsec = 0; rq.tv_nsec = 0;
nanosleep (&rq, &rm); nanosleep (&rq, &rm);
} }
VOID VOID
SecExit ( SecExit (
UINTN Status UINTN Status
) )
{ {
exit (Status); exit (Status);
} }
VOID VOID
SecGetTime ( SecGetTime (
OUT EFI_TIME *Time, OUT EFI_TIME *Time,
OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL OUT EFI_TIME_CAPABILITIES *Capabilities OPTIONAL
) )
{ {
struct tm *tm; struct tm *tm;
time_t t; time_t t;
t = time (NULL); t = time (NULL);
tm = localtime (&t); tm = localtime (&t);
Time->Year = 1900 + tm->tm_year; Time->Year = 1900 + tm->tm_year;
Time->Month = tm->tm_mon + 1; Time->Month = tm->tm_mon + 1;
Time->Day = tm->tm_mday; Time->Day = tm->tm_mday;
Time->Hour = tm->tm_hour; Time->Hour = tm->tm_hour;
Time->Minute = tm->tm_min; Time->Minute = tm->tm_min;
Time->Second = tm->tm_sec; Time->Second = tm->tm_sec;
Time->Nanosecond = 0; Time->Nanosecond = 0;
Time->TimeZone = timezone; Time->TimeZone = timezone;
Time->Daylight = (daylight ? EFI_TIME_ADJUST_DAYLIGHT : 0) Time->Daylight = (daylight ? EFI_TIME_ADJUST_DAYLIGHT : 0)
| (tm->tm_isdst > 0 ? EFI_TIME_IN_DAYLIGHT : 0); | (tm->tm_isdst > 0 ? EFI_TIME_IN_DAYLIGHT : 0);
if (Capabilities != NULL) { if (Capabilities != NULL) {
Capabilities->Resolution = 1; Capabilities->Resolution = 1;
Capabilities->Accuracy = 50000000; Capabilities->Accuracy = 50000000;
Capabilities->SetsToZero = FALSE; Capabilities->SetsToZero = FALSE;
} }
} }
VOID VOID
SecSetTime ( SecSetTime (
IN EFI_TIME *Time IN EFI_TIME *Time
) )
{ {
// Don't change the time on the system // Don't change the time on the system
// We could save delta to localtime() and have SecGetTime adjust return values? // We could save delta to localtime() and have SecGetTime adjust return values?
return; return;
} }
EFI_STATUS EFI_STATUS
SecGetNextProtocol ( SecGetNextProtocol (
IN BOOLEAN EmuBusDriver, IN BOOLEAN EmuBusDriver,
OUT EMU_IO_THUNK_PROTOCOL **Instance OPTIONAL OUT EMU_IO_THUNK_PROTOCOL **Instance OPTIONAL
) )
{ {
return GetNextThunkProtocol (EmuBusDriver, Instance); return GetNextThunkProtocol (EmuBusDriver, Instance);
} }
EMU_THUNK_PROTOCOL gEmuThunkProtocol = { EMU_THUNK_PROTOCOL gEmuThunkProtocol = {
GasketSecWriteStdErr, GasketSecWriteStdErr,
GasketSecConfigStdIn, GasketSecConfigStdIn,
GasketSecWriteStdOut, GasketSecWriteStdOut,
GasketSecReadStdIn, GasketSecReadStdIn,
GasketSecPollStdIn, GasketSecPollStdIn,
GasketSecMalloc, GasketSecMalloc,
GasketSecValloc, GasketSecValloc,
GasketSecFree, GasketSecFree,
GasketSecPeCoffGetEntryPoint, GasketSecPeCoffGetEntryPoint,
GasketSecPeCoffRelocateImageExtraAction, GasketSecPeCoffRelocateImageExtraAction,
GasketSecPeCoffUnloadImageExtraAction, GasketSecPeCoffUnloadImageExtraAction,
GasketSecEnableInterrupt, GasketSecEnableInterrupt,
GasketSecDisableInterrupt, GasketSecDisableInterrupt,
GasketQueryPerformanceFrequency, GasketQueryPerformanceFrequency,
GasketQueryPerformanceCounter, GasketQueryPerformanceCounter,
GasketSecSleep, GasketSecSleep,
GasketSecCpuSleep, GasketSecCpuSleep,
GasketSecExit, GasketSecExit,
GasketSecGetTime, GasketSecGetTime,
GasketSecSetTime, GasketSecSetTime,
GasketSecSetTimer, GasketSecSetTimer,
GasketSecGetNextProtocol GasketSecGetNextProtocol
}; };
VOID VOID
SecInitThunkProtocol ( SecInitThunkProtocol (
VOID VOID
) )
{ {
// timezone and daylight lib globals depend on tzset be called 1st. // timezone and daylight lib globals depend on tzset be called 1st.
tzset (); tzset ();
} }

14
EmulatorPkg/Unix/Host/Host.c
View File

@ -1148,7 +1148,7 @@ GdbScriptAddImage (
if (ImageContext->PdbPointer != NULL && !IsPdbFile (ImageContext->PdbPointer)) { if (ImageContext->PdbPointer != NULL && !IsPdbFile (ImageContext->PdbPointer)) {
FILE *GdbTempFile; FILE *GdbTempFile;
if (FeaturePcdGet (PcdEmulatorLazyLoadSymbols)) { if (FeaturePcdGet (PcdEmulatorLazyLoadSymbols)) {
GdbTempFile = fopen (gGdbWorkingFileName, "a"); GdbTempFile = fopen (gGdbWorkingFileName, "a");
if (GdbTempFile != NULL) { if (GdbTempFile != NULL) {
long unsigned int SymbolsAddr = (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders); long unsigned int SymbolsAddr = (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders);
@ -1170,13 +1170,13 @@ GdbScriptAddImage (
GdbTempFile = fopen (gGdbWorkingFileName, "w"); GdbTempFile = fopen (gGdbWorkingFileName, "w");
if (GdbTempFile != NULL) { if (GdbTempFile != NULL) {
fprintf ( fprintf (
GdbTempFile, GdbTempFile,
"add-symbol-file %s 0x%08lx\n", "add-symbol-file %s 0x%08lx\n",
ImageContext->PdbPointer, ImageContext->PdbPointer,
(long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders) (long unsigned int)(ImageContext->ImageAddress + ImageContext->SizeOfHeaders)
); );
fclose (GdbTempFile); fclose (GdbTempFile);
// //
// Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint. // Target for gdb breakpoint in a script that uses gGdbWorkingFileName to set a breakpoint.
// Hey what can you say scripting in gdb is not that great.... // Hey what can you say scripting in gdb is not that great....
@ -1225,7 +1225,7 @@ GdbScriptRemoveImage (
return; return;
} }
if (FeaturePcdGet (PcdEmulatorLazyLoadSymbols)) { if (FeaturePcdGet (PcdEmulatorLazyLoadSymbols)) {
// //
// Write the file we need for the gdb script // Write the file we need for the gdb script
// //
@ -1256,7 +1256,7 @@ GdbScriptRemoveImage (
SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, 0, 0); SecGdbScriptBreak (ImageContext->PdbPointer, strlen (ImageContext->PdbPointer) + 1, 0, 0);
} else { } else {
ASSERT (FALSE); ASSERT (FALSE);
} }
} }
} }

2
EmulatorPkg/Unix/Host/Host.h
View File

@ -82,7 +82,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#undef NTOHS #undef NTOHS
#undef HTONS #undef HTONS
#undef B0 #undef B0
#undef CR3 #undef CR3
#include <PiPei.h> #include <PiPei.h>
#include <Uefi.h> #include <Uefi.h>

2984
EmulatorPkg/Unix/Host/Ia32/Gasket.S
View File

File diff suppressed because it is too large Load Diff

148
EmulatorPkg/Unix/Host/Ia32/SwitchStack.c
View File

@ -1,74 +1,74 @@
/*++ /*++
Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR> Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR> Portions copyright (c) 2008 - 2009, Apple Inc. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
--*/ --*/
#include "Host.h" #include "Host.h"
/** /**
Transfers control to a function starting with a new stack. Transfers control to a function starting with a new stack.
Transfers control to the function specified by EntryPoint using the new stack Transfers control to the function specified by EntryPoint using the new stack
specified by NewStack and passing in the parameters specified by Context1 and specified by NewStack and passing in the parameters specified by Context1 and
Context2. Context1 and Context2 are optional and may be NULL. The function Context2. Context1 and Context2 are optional and may be NULL. The function
EntryPoint must never return. EntryPoint must never return.
If EntryPoint is NULL, then ASSERT(). If EntryPoint is NULL, then ASSERT().
If NewStack is NULL, then ASSERT(). If NewStack is NULL, then ASSERT().
@param EntryPoint A pointer to function to call with the new stack. @param EntryPoint A pointer to function to call with the new stack.
@param Context1 A pointer to the context to pass into the EntryPoint @param Context1 A pointer to the context to pass into the EntryPoint
function. function.
@param Context2 A pointer to the context to pass into the EntryPoint @param Context2 A pointer to the context to pass into the EntryPoint
function. function.
@param NewStack A pointer to the new stack to use for the EntryPoint @param NewStack A pointer to the new stack to use for the EntryPoint
function. function.
**/ **/
VOID VOID
EFIAPI EFIAPI
PeiSwitchStacks ( PeiSwitchStacks (
IN SWITCH_STACK_ENTRY_POINT EntryPoint, IN SWITCH_STACK_ENTRY_POINT EntryPoint,
IN VOID *Context1, OPTIONAL IN VOID *Context1, OPTIONAL
IN VOID *Context2, OPTIONAL IN VOID *Context2, OPTIONAL
IN VOID *NewStack IN VOID *NewStack
) )
{ {
BASE_LIBRARY_JUMP_BUFFER JumpBuffer; BASE_LIBRARY_JUMP_BUFFER JumpBuffer;
ASSERT (EntryPoint != NULL); ASSERT (EntryPoint != NULL);
ASSERT (NewStack != NULL); ASSERT (NewStack != NULL);
// //
// Stack should be aligned with CPU_STACK_ALIGNMENT // Stack should be aligned with CPU_STACK_ALIGNMENT
// //
ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0); ASSERT (((UINTN)NewStack & (CPU_STACK_ALIGNMENT - 1)) == 0);
JumpBuffer.Eip = (UINTN)EntryPoint; JumpBuffer.Eip = (UINTN)EntryPoint;
JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*); JumpBuffer.Esp = (UINTN)NewStack - sizeof (VOID*);
JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2); JumpBuffer.Esp -= sizeof (Context1) + sizeof (Context2);
((VOID**)JumpBuffer.Esp)[1] = Context1; ((VOID**)JumpBuffer.Esp)[1] = Context1;
((VOID**)JumpBuffer.Esp)[2] = Context2; ((VOID**)JumpBuffer.Esp)[2] = Context2;
LongJump (&JumpBuffer, (UINTN)-1); LongJump (&JumpBuffer, (UINTN)-1);
// //
// PeiSwitchStacks () will never return // PeiSwitchStacks () will never return
// //
ASSERT (FALSE); ASSERT (FALSE);
} }

290
EmulatorPkg/Unix/Host/MemoryAllocationLib.c
View File

@ -1,145 +1,145 @@
/*++ @file /*++ @file
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR> Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include "Base.h" #include "Base.h"
#include "Library/BaseMemoryLib.h" #include "Library/BaseMemoryLib.h"
#include "Library/MemoryAllocationLib.h" #include "Library/MemoryAllocationLib.h"
#include <stdlib.h> #include <stdlib.h>
/** /**
Allocates a buffer of type EfiBootServicesData. Allocates a buffer of type EfiBootServicesData.
Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a Allocates the number bytes specified by AllocationSize of type EfiBootServicesData and returns a
pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is pointer to the allocated buffer. If AllocationSize is 0, then a valid buffer of 0 size is
returned. If there is not enough memory remaining to satisfy the request, then NULL is returned. returned. If there is not enough memory remaining to satisfy the request, then NULL is returned.
@param AllocationSize The number of bytes to allocate. @param AllocationSize The number of bytes to allocate.
@return A pointer to the allocated buffer or NULL if allocation fails. @return A pointer to the allocated buffer or NULL if allocation fails.
**/ **/
VOID * VOID *
EFIAPI EFIAPI
AllocatePool ( AllocatePool (
IN UINTN AllocationSize IN UINTN AllocationSize
) )
{ {
return (VOID*) malloc (AllocationSize); return (VOID*) malloc (AllocationSize);
} }
/** /**
Allocates and zeros a buffer of type EfiBootServicesData. Allocates and zeros a buffer of type EfiBootServicesData.
Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the Allocates the number bytes specified by AllocationSize of type EfiBootServicesData, clears the
buffer with zeros, and returns a pointer to the allocated buffer. If AllocationSize is 0, then a buffer with zeros, and returns a pointer to the allocated buffer. If AllocationSize is 0, then a
valid buffer of 0 size is returned. If there is not enough memory remaining to satisfy the valid buffer of 0 size is returned. If there is not enough memory remaining to satisfy the
request, then NULL is returned. request, then NULL is returned.
@param AllocationSize The number of bytes to allocate and zero. @param AllocationSize The number of bytes to allocate and zero.
@return A pointer to the allocated buffer or NULL if allocation fails. @return A pointer to the allocated buffer or NULL if allocation fails.
**/ **/
VOID * VOID *
EFIAPI EFIAPI
AllocateZeroPool ( AllocateZeroPool (
IN UINTN AllocationSize IN UINTN AllocationSize
) )
{ {
VOID *Buffer; VOID *Buffer;
Buffer = AllocatePool (AllocationSize); Buffer = AllocatePool (AllocationSize);
if (Buffer == NULL) { if (Buffer == NULL) {
return NULL; return NULL;
} }
ZeroMem (Buffer, AllocationSize); ZeroMem (Buffer, AllocationSize);
return Buffer; return Buffer;
} }
/** /**
Reallocates a buffer of type EfiBootServicesData. Reallocates a buffer of type EfiBootServicesData.
Allocates and zeros the number bytes specified by NewSize from memory of type Allocates and zeros the number bytes specified by NewSize from memory of type
EfiBootServicesData. If OldBuffer is not NULL, then the smaller of OldSize and EfiBootServicesData. If OldBuffer is not NULL, then the smaller of OldSize and
NewSize bytes are copied from OldBuffer to the newly allocated buffer, and NewSize bytes are copied from OldBuffer to the newly allocated buffer, and
OldBuffer is freed. A pointer to the newly allocated buffer is returned. OldBuffer is freed. A pointer to the newly allocated buffer is returned.
If NewSize is 0, then a valid buffer of 0 size is returned. If there is not If NewSize is 0, then a valid buffer of 0 size is returned. If there is not
enough memory remaining to satisfy the request, then NULL is returned. enough memory remaining to satisfy the request, then NULL is returned.
If the allocation of the new buffer is successful and the smaller of NewSize and OldSize If the allocation of the new buffer is successful and the smaller of NewSize and OldSize
is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT(). is greater than (MAX_ADDRESS - OldBuffer + 1), then ASSERT().
@param OldSize The size, in bytes, of OldBuffer. @param OldSize The size, in bytes, of OldBuffer.
@param NewSize The size, in bytes, of the buffer to reallocate. @param NewSize The size, in bytes, of the buffer to reallocate.
@param OldBuffer The buffer to copy to the allocated buffer. This is an optional @param OldBuffer The buffer to copy to the allocated buffer. This is an optional
parameter that may be NULL. parameter that may be NULL.
@return A pointer to the allocated buffer or NULL if allocation fails. @return A pointer to the allocated buffer or NULL if allocation fails.
**/ **/
VOID * VOID *
EFIAPI EFIAPI
ReallocatePool ( ReallocatePool (
IN UINTN OldSize, IN UINTN OldSize,
IN UINTN NewSize, IN UINTN NewSize,
IN VOID *OldBuffer OPTIONAL IN VOID *OldBuffer OPTIONAL
) )
{ {
VOID *NewBuffer; VOID *NewBuffer;
NewBuffer = AllocatePool (NewSize); NewBuffer = AllocatePool (NewSize);
if (NewBuffer == NULL) { if (NewBuffer == NULL) {
return NULL; return NULL;
} }
if (OldBuffer != NULL) { if (OldBuffer != NULL) {
if (OldSize > 0) { if (OldSize > 0) {
CopyMem (NewBuffer, OldBuffer, OldSize); CopyMem (NewBuffer, OldBuffer, OldSize);
} }
FreePool (OldBuffer); FreePool (OldBuffer);
} }
return NewBuffer; return NewBuffer;
} }
/** /**
Frees a buffer that was previously allocated with one of the pool allocation functions in the Frees a buffer that was previously allocated with one of the pool allocation functions in the
Memory Allocation Library. Memory Allocation Library.
Frees the buffer specified by Buffer. Buffer must have been allocated on a previous call to the Frees the buffer specified by Buffer. Buffer must have been allocated on a previous call to the
pool allocation services of the Memory Allocation Library. If it is not possible to free pool pool allocation services of the Memory Allocation Library. If it is not possible to free pool
resources, then this function will perform no actions. resources, then this function will perform no actions.
If Buffer was not allocated with a pool allocation function in the Memory Allocation Library, If Buffer was not allocated with a pool allocation function in the Memory Allocation Library,
then ASSERT(). then ASSERT().
@param Buffer Pointer to the buffer to free. @param Buffer Pointer to the buffer to free.
**/ **/
VOID VOID
EFIAPI EFIAPI
FreePool ( FreePool (
IN VOID *Buffer IN VOID *Buffer
) )
{ {
free ((void *) Buffer); free ((void *) Buffer);
} }

3112
EmulatorPkg/Unix/Host/PosixFileSystem.c
View File

File diff suppressed because it is too large Load Diff

470
EmulatorPkg/Unix/Host/Pthreads.c
View File

@ -1,235 +1,235 @@
/*++ @file /*++ @file
POSIX Pthreads to emulate APs and implement threads POSIX Pthreads to emulate APs and implement threads
Copyright (c) 2011, Apple Inc. All rights reserved. Copyright (c) 2011, Apple Inc. All rights reserved.
Copyright (c) 2011, Intel Corporation. All rights reserved.<BR> Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
This program and the accompanying materials This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License 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 which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/ **/
#include "Host.h" #include "Host.h"
#include <pthread.h> #include <pthread.h>
UINTN UINTN
EFIAPI EFIAPI
PthreadMutexLock ( PthreadMutexLock (
IN VOID *Mutex IN VOID *Mutex
) )
{ {
return (UINTN)pthread_mutex_lock ((pthread_mutex_t *)Mutex); return (UINTN)pthread_mutex_lock ((pthread_mutex_t *)Mutex);
} }
UINTN UINTN
EFIAPI EFIAPI
PthreadMutexUnLock ( PthreadMutexUnLock (
IN VOID *Mutex IN VOID *Mutex
) )
{ {
return (UINTN)pthread_mutex_unlock ((pthread_mutex_t *)Mutex); return (UINTN)pthread_mutex_unlock ((pthread_mutex_t *)Mutex);
} }
UINTN UINTN
EFIAPI EFIAPI
PthreadMutexTryLock ( PthreadMutexTryLock (
IN VOID *Mutex IN VOID *Mutex
) )
{ {
return (UINTN)pthread_mutex_trylock ((pthread_mutex_t *)Mutex); return (UINTN)pthread_mutex_trylock ((pthread_mutex_t *)Mutex);
} }
VOID * VOID *
PthreadMutexInit ( PthreadMutexInit (
IN VOID IN VOID
) )
{ {
pthread_mutex_t *Mutex; pthread_mutex_t *Mutex;
int err; int err;
Mutex = malloc (sizeof (pthread_mutex_t)); Mutex = malloc (sizeof (pthread_mutex_t));
err = pthread_mutex_init (Mutex, NULL); err = pthread_mutex_init (Mutex, NULL);
if (err == 0) { if (err == 0) {
return Mutex; return Mutex;
} }
return NULL; return NULL;
} }
UINTN UINTN
PthreadMutexDestroy ( PthreadMutexDestroy (
IN VOID *Mutex IN VOID *Mutex
) )
{ {
if (Mutex != NULL) { if (Mutex != NULL) {
return pthread_mutex_destroy ((pthread_mutex_t *)Mutex); return pthread_mutex_destroy ((pthread_mutex_t *)Mutex);
} }
return -1; return -1;
} }
// Can't store this data on PthreadCreate stack so we need a global // Can't store this data on PthreadCreate stack so we need a global
typedef struct { typedef struct {
pthread_mutex_t Mutex; pthread_mutex_t Mutex;
THREAD_THUNK_THREAD_ENTRY Start; THREAD_THUNK_THREAD_ENTRY Start;
} THREAD_MANGLE; } THREAD_MANGLE;
THREAD_MANGLE mThreadMangle = { THREAD_MANGLE mThreadMangle = {
PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_INITIALIZER,
NULL NULL
}; };
VOID * VOID *
SecFakePthreadStart ( SecFakePthreadStart (
VOID *Context VOID *Context
) )
{ {
THREAD_THUNK_THREAD_ENTRY Start; THREAD_THUNK_THREAD_ENTRY Start;
sigset_t SigMask; sigset_t SigMask;
// Save global on the stack before we unlock // Save global on the stack before we unlock
Start = mThreadMangle.Start; Start = mThreadMangle.Start;
pthread_mutex_unlock (&mThreadMangle.Mutex); pthread_mutex_unlock (&mThreadMangle.Mutex);
// Mask all signals to the APs // Mask all signals to the APs
sigfillset (&SigMask); sigfillset (&SigMask);
pthread_sigmask (SIG_BLOCK, &SigMask, NULL); pthread_sigmask (SIG_BLOCK, &SigMask, NULL);
// //
// We have to start the thread in SEC as we need to follow // We have to start the thread in SEC as we need to follow
// OS X calling conventions. We can then call back into // OS X calling conventions. We can then call back into
// to the callers Start. // to the callers Start.
// //
// This is a great example of how all problems in computer // This is a great example of how all problems in computer
// science can be solved by adding another level of indirection // science can be solved by adding another level of indirection
// //
return (VOID *)ReverseGasketUint64 ((CALL_BACK)Start, (UINTN)Context); return (VOID *)ReverseGasketUint64 ((CALL_BACK)Start, (UINTN)Context);
} }
UINTN UINTN
PthreadCreate ( PthreadCreate (
IN VOID *Thread, IN VOID *Thread,
IN VOID *Attribute, IN VOID *Attribute,
IN THREAD_THUNK_THREAD_ENTRY Start, IN THREAD_THUNK_THREAD_ENTRY Start,
IN VOID *Context IN VOID *Context
) )
{ {
int err; int err;
BOOLEAN EnabledOnEntry; BOOLEAN EnabledOnEntry;
// //
// Threads inherit interrupt state so disable interrupts before we start thread // Threads inherit interrupt state so disable interrupts before we start thread
// //
if (SecInterruptEanbled ()) { if (SecInterruptEanbled ()) {
SecDisableInterrupt (); SecDisableInterrupt ();
EnabledOnEntry = TRUE; EnabledOnEntry = TRUE;
} else { } else {
EnabledOnEntry = FALSE; EnabledOnEntry = FALSE;
} }
// Aquire lock for global, SecFakePthreadStart runs in a different thread. // Aquire lock for global, SecFakePthreadStart runs in a different thread.
pthread_mutex_lock (&mThreadMangle.Mutex); pthread_mutex_lock (&mThreadMangle.Mutex);
mThreadMangle.Start = Start; mThreadMangle.Start = Start;
err = pthread_create (Thread, Attribute, SecFakePthreadStart, Context); err = pthread_create (Thread, Attribute, SecFakePthreadStart, Context);
if (err != 0) { if (err != 0) {
// Thread failed to launch so release the lock; // Thread failed to launch so release the lock;
pthread_mutex_unlock (&mThreadMangle.Mutex); pthread_mutex_unlock (&mThreadMangle.Mutex);
} }
if (EnabledOnEntry) { if (EnabledOnEntry) {
// Restore interrupt state // Restore interrupt state
SecEnableInterrupt (); SecEnableInterrupt ();
} }
return err; return err;
} }
VOID VOID
PthreadExit ( PthreadExit (
IN VOID *ValuePtr IN VOID *ValuePtr
) )
{ {
pthread_exit (ValuePtr); pthread_exit (ValuePtr);
return; return;
} }
UINTN UINTN
PthreadSelf ( PthreadSelf (
VOID VOID
) )
{ {
// POSIX currently allows pthread_t to be a structure or arithmetic type. // POSIX currently allows pthread_t to be a structure or arithmetic type.
// Check out sys/types.h to make sure this will work if you are porting. // Check out sys/types.h to make sure this will work if you are porting.
// On OS X (Darwin) pthread_t is a pointer to a structure so this code works. // On OS X (Darwin) pthread_t is a pointer to a structure so this code works.
return (UINTN)pthread_self (); return (UINTN)pthread_self ();
} }
EMU_THREAD_THUNK_PROTOCOL gPthreadThunk = { EMU_THREAD_THUNK_PROTOCOL gPthreadThunk = {
GasketPthreadMutexLock, GasketPthreadMutexLock,
GasketPthreadMutexUnLock, GasketPthreadMutexUnLock,
GasketPthreadMutexTryLock, GasketPthreadMutexTryLock,
GasketPthreadMutexInit, GasketPthreadMutexInit,
GasketPthreadMutexDestroy, GasketPthreadMutexDestroy,
GasketPthreadCreate, GasketPthreadCreate,
GasketPthreadExit, GasketPthreadExit,
GasketPthreadSelf GasketPthreadSelf
}; };
EFI_STATUS EFI_STATUS
PthreadOpen ( PthreadOpen (
IN EMU_IO_THUNK_PROTOCOL *This IN EMU_IO_THUNK_PROTOCOL *This
) )
{ {
if (This->Instance != 0) { if (This->Instance != 0) {
// Only single instance is supported // Only single instance is supported
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
if (This->ConfigString[0] == L'0') { if (This->ConfigString[0] == L'0') {
// If AP count is zero no need for threads // If AP count is zero no need for threads
return EFI_NOT_FOUND; return EFI_NOT_FOUND;
} }
This->Interface = &gPthreadThunk; This->Interface = &gPthreadThunk;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
PthreadClose ( PthreadClose (
IN EMU_IO_THUNK_PROTOCOL *This IN EMU_IO_THUNK_PROTOCOL *This
) )
{ {
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EMU_IO_THUNK_PROTOCOL gPthreadThunkIo = { EMU_IO_THUNK_PROTOCOL gPthreadThunkIo = {
&gEmuThreadThunkProtocolGuid, &gEmuThreadThunkProtocolGuid,
NULL, NULL,
NULL, NULL,
0, 0,
GasketPthreadOpen, GasketPthreadOpen,
GasketPthreadClose, GasketPthreadClose,
NULL NULL
}; };

2056
EmulatorPkg/Unix/Host/X11GraphicsWindow.c
View File

File diff suppressed because it is too large Load Diff

3262
EmulatorPkg/Unix/Host/X64/Gasket.S
View File

File diff suppressed because it is too large Load Diff

1080
EmulatorPkg/Unix/lldbefi.py
View File

File diff suppressed because it is too large Load Diff

2
EmulatorPkg/Win/Host/WinBlockIo.c
View File

@ -270,7 +270,7 @@ WinNtSignalToken (
@param[in] MediaId Id of the media, changes every time the media is @param[in] MediaId Id of the media, changes every time the media is
replaced. replaced.
@param[in] Lba The starting Logical Block Address to read from. @param[in] Lba The starting Logical Block Address to read from.
@param[in, out] Token A pointer to the token associated with the transaction. @param[in, out] Token A pointer to the token associated with the transaction.
@param[in] BufferSize Size of Buffer, must be a multiple of device block size. @param[in] BufferSize Size of Buffer, must be a multiple of device block size.
@param[out] Buffer A pointer to the destination buffer for the data. The @param[out] Buffer A pointer to the destination buffer for the data. The
caller is responsible for either having implicit or caller is responsible for either having implicit or

2
EmulatorPkg/Win/Host/WinHost.h
View File

@ -206,4 +206,4 @@ extern EMU_THUNK_PROTOCOL gEmuThunkProtocol;
extern EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo; extern EMU_IO_THUNK_PROTOCOL mWinNtWndThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtFileSystemThunkIo; extern EMU_IO_THUNK_PROTOCOL mWinNtFileSystemThunkIo;
extern EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo; extern EMU_IO_THUNK_PROTOCOL mWinNtBlockIoThunkIo;
#endif #endif