From b6d47a83ac311c8980472f3d83ff477f58491a7c Mon Sep 17 00:00:00 2001 From: mdkinney Date: Mon, 13 Jul 2009 00:18:41 +0000 Subject: [PATCH] Add Framework MP Services Protocol Change EFI_AP_PROCEDURE to FRAMEWORK_EFI_AP_PROCEDURE to remove name collision with PI 1.2 MP Services Protocol in MdePkg git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8912 6f19259b-4bc3-4df7-8a09-765794883524 --- IntelFrameworkPkg/Include/Framework/DxeCis.h | 30 +- IntelFrameworkPkg/Include/Framework/SmmCis.h | 3 +- .../Include/Protocol/FrameworkMpService.h | 660 ++++++++++++++++++ IntelFrameworkPkg/IntelFrameworkPkg.dec | 3 + 4 files changed, 682 insertions(+), 14 deletions(-) create mode 100644 IntelFrameworkPkg/Include/Protocol/FrameworkMpService.h diff --git a/IntelFrameworkPkg/Include/Framework/DxeCis.h b/IntelFrameworkPkg/Include/Framework/DxeCis.h index f0f8f7e295..86d96ddd41 100644 --- a/IntelFrameworkPkg/Include/Framework/DxeCis.h +++ b/IntelFrameworkPkg/Include/Framework/DxeCis.h @@ -18,19 +18,23 @@ #include -// -// Function prototype for invoking a function on an Application Processor -// Used by both the SMM infrastructure and the MP Services Protocol -// +/** + Functions of this type are used with the Framework MP Services Protocol and + the SMM Services Table to execute a procedure on enabled APs. The context + the AP should use durng execution is specified by Buffer. + + @param[in] Buffer Pointer to the procedure's argument. + +**/ typedef VOID -(EFIAPI *EFI_AP_PROCEDURE)( - IN VOID *Buffer +(EFIAPI *FRAMEWORK_EFI_AP_PROCEDURE)( + IN VOID *Buffer ); -// -// Framework EFI Runtime Services Table as extension to EFI 1.10 Runtime Services Table -// +/// +/// Framework EFI Runtime Services Table as extension to EFI 1.10 Runtime Services Table +/// typedef struct { // // Table header for the Framework EFI Runtime Services Table @@ -59,10 +63,10 @@ typedef struct { // EFI_GET_NEXT_HIGH_MONO_COUNT GetNextHighMonotonicCount; EFI_RESET_SYSTEM ResetSystem; - // - // Framework extension to EFI 1.10 runtime table - // It was moved to a protocol to not conflict with UEFI 2.0 - // + /// + /// Framework extension to EFI 1.10 runtime table + /// It was moved to a protocol to not conflict with UEFI 2.0 + /// EFI_REPORT_STATUS_CODE ReportStatusCode; } FRAMEWORK_EFI_RUNTIME_SERVICES; diff --git a/IntelFrameworkPkg/Include/Framework/SmmCis.h b/IntelFrameworkPkg/Include/Framework/SmmCis.h index 11d6a6b07e..122c471add 100644 --- a/IntelFrameworkPkg/Include/Framework/SmmCis.h +++ b/IntelFrameworkPkg/Include/Framework/SmmCis.h @@ -180,6 +180,7 @@ EFI_STATUS IN EFI_PHYSICAL_ADDRESS Memory, IN UINTN NumberOfPages ); + /** Frees memory pages for the system. @@ -203,7 +204,7 @@ EFI_STATUS typedef EFI_STATUS (EFIAPI *EFI_SMM_STARTUP_THIS_AP)( - IN EFI_AP_PROCEDURE Procedure, + IN FRAMEWORK_EFI_AP_PROCEDURE Procedure, IN UINTN CpuNumber, IN OUT VOID *ProcArguments OPTIONAL ); diff --git a/IntelFrameworkPkg/Include/Protocol/FrameworkMpService.h b/IntelFrameworkPkg/Include/Protocol/FrameworkMpService.h new file mode 100644 index 0000000000..e11bb7047a --- /dev/null +++ b/IntelFrameworkPkg/Include/Protocol/FrameworkMpService.h @@ -0,0 +1,660 @@ +/** @file + When installed, the Framework MP Services Protocol produces a collection of + services that are needed for MP management, such as initialization and management + of application processors. + + @par Note: + This protocol has been deprecated and has been replaced by the MP Services + Protocol from the UEFI Platform Initialization Specification 1.2, Volume 2: + Driver Execution Environment Core Interface. + + The MP Services Protocol provides a generalized way of performing following tasks: + - Retrieving information of multi-processor environment and MP-related status of + specific processors. + - Dispatching user-provided function to APs. + - Maintain MP-related processor status. + + The MP Services Protocol must be produced on any system with more than one logical + processor. + + The Protocol is available only during boot time. + + MP Services Protocol is hardware-independent. Most of the logic of this protocol + is architecturally neutral. It abstracts the multi-processor environment and + status of processors, and provides interfaces to retrieve information, maintain, + and dispatch. + + MP Services Protocol may be consumed by ACPI module. The ACPI module may use this + protocol to retrieve data that are needed for an MP platform and report them to OS. + MP Services Protocol may also be used to program and configure processors, such + as MTRR synchronization for memory space attributes setting in DXE Services. + MP Services Protocol may be used by non-CPU DXE drivers to speed up platform boot + by taking advantage of the processing capabilities of the APs, for example, using + APs to help test system memory in parallel with other device initialization. + Diagnostics applications may also use this protocol for multi-processor. + + Copyright (c) 1999 - 2002, 2009, Intel Corporation.
+ All rights reserved. This program and the accompanying materials + are licensed and made available under the terms and conditions of the BSD License + which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php + + THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, + WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. + +--*/ + +#ifndef _FRAMEWORK_MP_SERVICE_PROTOCOL_H_ +#define _FRAMEWORK_MP_SERVICE_PROTOCOL_H_ + +/// +/// Global ID for the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL +/// +#define FRAMEWORK_EFI_MP_SERVICES_PROTOCOL_GUID \ + { \ + 0xf33261e7, 0x23cb, 0x11d5, {0xbd, 0x5c, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81} \ + } + +/// +/// Forward declaration for the EFI_MP_SERVICES_PROTOCOL +/// +typedef struct _FRAMEWORK_EFI_MP_SERVICES_PROTOCOL FRAMEWORK_EFI_MP_SERVICES_PROTOCOL; + +/// +/// Fixed delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_FIXED 0x0 + +/// +/// Lowest priority delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_LOWEST_PRIORITY 0x1 + +/// +/// SMI delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_SMI 0x2 + +/// +/// Remote read delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_REMOTE_READ 0x3 + +/// +/// NMI delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_NMI 0x4 + +/// +/// INIT delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_INIT 0x5 + +/// +/// Startup IPI delivery mode that may be used as the DeliveryMode parameter in SendIpi() +/// +#define DELIVERY_MODE_SIPI 0x6 + +/// +/// The DeliveryMode parameter in SendIpi() bust be less than this maximum value +/// +#define DELIVERY_MODE_MAX 0x7 + +/// +/// IPF specific value for the state field of the Self Test State Parameter +/// +#define EFI_MP_HEALTH_FLAGS_STATUS_HEALTHY 0x0 + +/// +/// IPF specific value for the state field of the Self Test State Parameter +/// +#define EFI_MP_HEALTH_FLAGS_STATUS_PERFORMANCE_RESTRICTED 0x1 + +/// +/// IPF specific value for the state field of the Self Test State Parameter +/// +#define EFI_MP_HEALTH_FLAGS_STATUS_FUNCTIONALLY_RESTRICTED 0x2 + +typedef union { + /// + /// Bitfield structure for the IPF Self Test State Parameter + /// + struct { + UINT32 Status:2; + UINT32 Tested:1; + UINT32 Reserved1:13; + UINT32 VirtualMemoryUnavailable:1; + UINT32 Ia32ExecutionUnavailable:1; + UINT32 FloatingPointUnavailable:1; + UINT32 MiscFeaturesUnavailable:1; + UINT32 Reserved2:12; + } Bits; + /// + /// IA32 and X64 BIST data of the processor + /// + UINT32 Uint32; +} EFI_MP_HEALTH_FLAGS; + +typedef struct { + /// + /// @par IA32, X64: + /// BIST (built-in self test) data of the processor. + /// + /// @par IPF: + /// Lower 32 bits of self test state parameter. For definition of self test + /// state parameter, please refer to Intel(R) Itanium(R) Architecture Software + /// Developer’s Manual, Volume 2: System Architecture. + /// + EFI_MP_HEALTH_FLAGS Flags; + /// + /// @par IA32, X64: + /// Not used. + /// + /// @par IPF: + /// Higher 32 bits of self test state parameter. + /// + UINT32 TestStatus; +} EFI_MP_HEALTH; + +typedef enum { + EfiCpuAP = 0, ///< The CPU is an AP (Application Processor) + EfiCpuBSP, ///< The CPU is the BSP (Boot-Strap Processor) + EfiCpuDesignationMaximum +} EFI_CPU_DESIGNATION; + +typedef struct { + /// + /// @par IA32, X64: + /// The lower 8 bits contains local APIC ID, and higher bits are reserved. + /// + /// @par IPF: + /// The lower 16 bits contains id/eid as physical address of local SAPIC + /// unit, and higher bits are reserved. + /// + UINT32 ApicID; + /// + /// This field indicates whether the processor is enabled. If the value is + /// TRUE, then the processor is enabled. Otherwise, it is disabled. + /// + BOOLEAN Enabled; + /// + /// This field indicates whether the processor is playing the role of BSP. + /// If the value is EfiCpuAP, then the processor is AP. If the value is + /// EfiCpuBSP, then the processor is BSP. + /// + EFI_CPU_DESIGNATION Designation; + /// + /// @par IA32, X64: + /// The Flags field of this EFI_MP_HEALTH data structure holds BIST (built-in + /// self test) data of the processor. The TestStatus field is not used, and + /// the value is always zero. + /// + /// @par IPF: + /// Bit format of this field is the same as the definition of self-test state + /// parameter, in Intel® Itanium® Architecture Software Developer’s Manual, + /// Volume 2: System Architecture. + /// + EFI_MP_HEALTH Health; + /// + /// Zero-based physical package number that identifies the cartridge of the + /// processor. + /// + UINTN PackageNumber; + /// + /// Zero-based physical core number within package of the processor. + /// + UINTN NumberOfCores; + /// + /// Zero-based logical thread number within core of the processor. + /// + UINTN NumberOfThreads; + /// + /// This field is reserved. + /// + UINT64 ProcessorPALCompatibilityFlags; + /// + /// @par IA32, X64: + /// This field is not used, and the value is always zero. + /// + /// @par IPF: + /// This field is a mask number that is handed off by the PAL about which + /// processor tests are performed and which are masked. + /// + UINT64 ProcessorTestMask; +} EFI_MP_PROC_CONTEXT; + +/** + This service retrieves general information of multiprocessors in the system. + + This function is used to get the following information: + - Number of logical processors in system + - Maximal number of logical processors supported by system + - Number of enabled logical processors. + - Rendezvous interrupt number (IPF-specific) + - Length of the rendezvous procedure. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[out] NumberOfCPUs Pointer to the total number of logical processors + in the system, including the BSP and disabled + APs. If NULL, this parameter is ignored. + @param[out] MaximumNumberOfCPUs Pointer to the maximum number of processors + supported by the system. If NULL, this + parameter is ignored. + @param[out] NumberOfEnabledCPUs Pointer to the number of enabled logical + processors that exist in system, including + the BSP. If NULL, this parameter is ignored. + @param[out] RendezvousIntNumber This parameter is only meaningful for IPF. + - IA32, X64: The returned value is zero. + If NULL, this parameter is ignored. + - IPF: Pointer to the rendezvous interrupt + number that is used for AP wake-up. + @param[out] RendezvousProcLength Pointer to the length of rendezvous procedure. + - IA32, X64: The returned value is 0x1000. + If NULL, this parameter is ignored. + - IPF: The returned value is zero. + + @retval EFI_SUCCESS Multiprocessor general information successfully retrieved. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_GET_GENERAL_MP_INFO)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + OUT UINTN *NumberOfCPUs OPTIONAL, + OUT UINTN *MaximumNumberOfCPUs OPTIONAL, + OUT UINTN *NumberOfEnabledCPUs OPTIONAL, + OUT UINTN *RendezvousIntNumber OPTIONAL, + OUT UINTN *RendezvousProcLength OPTIONAL + ); + +/** + This service gets detailed MP-related information of the requested processor. + + This service gets detailed MP-related information of the requested processor + at the instant this call is made. Note the following: + - The processor information may change during the course of a boot session. + - The data of information presented here is entirely MP related. + Information regarding the number of caches and their sizes, frequency of operation, + slot numbers is all considered platform-related information and will not be + presented here. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] ProcessorNumber The handle number of the processor. The range + is from 0 to the total number of logical + processors minus 1. The total number of + logical processors can be retrieved by + GetGeneralMPInfo(). + @param[in,out] BufferLength On input, pointer to the size in bytes of + ProcessorContextBuffer. On output, if the + size of ProcessorContextBuffer is not large + enough, the value pointed by this parameter + is updated to size in bytes that is needed. + If the size of ProcessorContextBuffer is + sufficient, the value is not changed from + input. + @param[out] ProcessorContextBuffer Pointer to the buffer where the data of + requested processor will be deposited. + The buffer is allocated by caller. + + @retval EFI_SUCCESS Processor information successfully returned. + @retval EFI_BUFFER_TOO_SMALL The size of ProcessorContextBuffer is too small. + Value pointed by BufferLength has been updated + to size in bytes that is needed. + @retval EFI_INVALID_PARAMETER IA32, X64:BufferLength is NULL. + @retval EFI_INVALID_PARAMETER IA32, X64:ProcessorContextBuffer is NULL. + @retval EFI_INVALID_PARAMETER IA32, X64:Processor with the handle specified by + ProcessorNumber does not exist + @retval EFI_NOT_FOUND IPF: Processor with the handle specified by + ProcessorNumber does not exist + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_GET_PROCESSOR_CONTEXT)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN UINTN ProcessorNumber, + IN OUT UINTN *BufferLength, + OUT EFI_MP_PROC_CONTEXT *ProcessorContextBuffer + ); + +/** + This function is used to dispatch all enabled APs to the function specified + by Procedure. APs can run either simultaneously or one by one. The caller can + also configure the BSP to either wait for APs or just proceed with the next + task. It is the responsibility of the caller of the StartupAllAPs() to make + sure that the nature of the code that will be run on the BSP and the dispatched + APs is well controlled. The MP Services Protocol does not guarantee that the + function that either processor is executing is MP-safe. Hence, the tasks that + can be run in parallel are limited to certain independent tasks and well- + controlled exclusive code. EFI services and protocols may not be called by APs + unless otherwise specified. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] Procedure A pointer to the function to be run on enabled + APs of the system. + @param[in] SingleThread Flag that requests APs to execute one at a + time or simultaneously. + - IA32, X64: + If TRUE, then all the enabled APs execute + the function specified by Procedure one by + one, in ascending order of processor handle + number. If FALSE, then all the enabled APs + execute the function specified by Procedure + simultaneously. + - IPF: + If TRUE, then all the enabled APs execute + the function specified by Procedure simultaneously. + If FALSE, then all the enabled APs execute the + function specified by Procedure one by one, in + ascending order of processor handle number. The + time interval of AP dispatching is determined + by WaitEvent and TimeoutInMicrosecs. + @param[in] WaitEvent Event to signal when APs have finished. + - IA32, X64: + If not NULL, when all APs finish after timeout + expires, the event will be signaled. If NULL, + the parameter is ignored. + - IPF: + If SingleThread is TRUE, this parameter + is ignored. If SingleThread is FALSE (i.e. + dispatch APs one by one), this parameter + determines whether the BSP waits after each + AP is dispatched. If it is NULL, the BSP + does not wait after each AP is dispatched. + If it is not NULL, the BSP waits after each + AP is dispatched, and the time interval is + determined by TimeoutInMicrosecs. Type + EFI_EVENT is defined in CreateEvent() in + the Unified Extensible Firmware Interface + Specification. + @param[in] TimeoutInMicrosecsond Time to wait for APs to finish. + - IA32, X64: + If the value is zero, it means no timeout + limit. The BSP waits until all APs finish. + If the value is not zero, the BSP waits + until all APs finish or timeout expires. + If timeout expires, EFI_TIMEOUT is returned, + and the BSP will then check APs’ status + periodically, with time interval of 16 + microseconds. + - IPF: + If SingleThread is TRUE and FailedCPUList + is NULL, this parameter is ignored. If + SingleThread is TRUE and FailedCPUList is + not NULL, this parameter determines whether + the BSP waits until all APs finish their + procedure. If it is zero, the BSP does not + wait for APs. If it is non-zero, it waits + until all APs finish. If SingleThread is + FALSE and WaitEvent is NULL, this parameter + is ignored. If SingleThread is FALSE and + WaitEvent is not NULL, the BSP waits after + each AP is dispatched and this value + determines time interval. If the value is + zero, the length of time interval is 10ms. + If the value is non-zero, the BSP waits + until dispatched AP finishes and then + dispatch the next. + @param[in] ProcedureArgument Pointer to the optional parameter of the + function specified by Procedure. + @param[out] FailedCPUList List of APs that did not finish. + - IA32, X64: + If not NULL, it records handle numbers of + all logical processors that fail to accept + caller-provided function (busy or disabled). + If NULL, this parameter is ignored. + - IPF: + If not NULL, it records status of all + logical processors, with processor handle + number as index. If a logical processor + fails to accept caller-provided function + because it is busy, the status is EFI_NOT_READY. + If it fails to accept function due to other + reasons, the status is EFI_NOT_AVAILABLE_YET. + If timeout expires, the status is EFI_TIMEOUT. + Otherwise, the value is EFI_SUCCESS. If NULL, + this parameter is ignored. + + @retval EFI_SUCCESS IA32, X64: All dispatched APs have finished + before the timeout expires. + @retval EFI_SUCCESS IA32, X64: Only 1 logical processor exists + in system. + @retval EFI_INVALID_PARAMETER IA32, X64: Procedure is NULL. + @retval EFI_TIMEOUT IA32, X64: The timeout expires before all + dispatched APs have finished. + @retval EFI_SUCCESS IPF: This function always returns EFI_SUCCESS. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_STARTUP_ALL_APS)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN FRAMEWORK_EFI_AP_PROCEDURE Procedure, + IN BOOLEAN SingleThread, + IN EFI_EVENT WaitEvent OPTIONAL, + IN UINTN TimeoutInMicroSecs, + IN VOID *ProcArguments OPTIONAL, + OUT UINTN *FailedCPUList OPTIONAL + ); + +/** + This function is used to dispatch one enabled AP to the function provided by + the caller. The caller can request the BSP to either wait for the AP or just + proceed with the next task. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] Procedure A pointer to the function to be run on the + designated AP. + @param[in] ProcessorNumber The handle number of AP. The range is from + 0 to the total number of logical processors + minus 1. The total number of logical + processors can be retrieved by GetGeneralMPInfo(). + @param[in] WaitEvent Event to signal when APs have finished. + - IA32, X64: + If not NULL, when the AP finishes after timeout + expires, the event will be signaled. If NULL, + the parameter is ignored. + - IPF: + This parameter determines whether the BSP + waits after the AP is dispatched. If it is + NULL, the BSP does not wait after the AP + is dispatched. If it is not NULL, the BSP + waits after the AP is dispatched, and the + time interval is determined by TimeoutInMicrosecs. + Type EFI_EVENT is defined in CreateEvent() + in the Unified Extensible Firmware Interface + Specification. + @param[in] TimeoutInMicrosecsond Time to wait for APs to finish. + - IA32, X64: + If the value is zero, it means no timeout + limit. The BSP waits until the AP finishes. + If the value is not zero, the BSP waits until + the AP finishes or timeout expires. If timeout + expires, EFI_TIMEOUT is returned, and the + BSP will then check the AP’s status periodically, + with time interval of 16 microseconds. + - IPF: + If WaitEvent is NULL, this parameter is ignored. + If WaitEvent is not NULL, the BSP waits after + the AP is dispatched and this value determines + time interval. If the value is zero, the length + of time interval is 10ms. If the value is + non-zero, the BSP waits until the AP finishes. + @param[in] ProcedureArgument Pointer to the optional parameter of the + function specified by Procedure. + + @retval EFI_SUCCESS Specified AP has finished before the timeout + expires. + @retval EFI_TIMEOUT The timeout expires before specified AP has + finished. + @retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified + by ProcessorNumber does not exist. + @retval EFI_INVALID_PARAMETER IA32, X64: Specified AP is busy or disabled. + @retval EFI_INVALID_PARAMETER IA32, X64: Procedure is NULL. + @retval EFI_INVALID_PARAMETER IA32, X64: ProcessorNumber specifies the BSP + @retval EFI_NOT_READY IPF: Specified AP is busy + @retval EFI_NOT_AVAILABLE_YET IPF: ProcessorNumber specifies the BSP + @retval EFI_NOT_AVAILABLE_YET IPF: Specified AP is disabled. + @retval EFI_NOT_AVAILABLE_YET IPF: Specified AP is unhealthy or untested. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_STARTUP_THIS_AP)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN FRAMEWORK_EFI_AP_PROCEDURE Procedure, + IN UINTN ProcessorNumber, + IN EFI_EVENT WaitEvent OPTIONAL, + IN UINTN TimeoutInMicroSecs, + IN OUT VOID *ProcArguments OPTIONAL + ); + +/** + This service switches the requested AP to be the BSP from that point onward. + The new BSP can take over the execution of the old BSP and continue seamlessly + from where the old one left off. This call can only be performed by the + current BSP. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] ProcessorNumber The handle number of AP. The range is from 0 to + the total number of logical processors minus 1. + The total number of logical processors can be + retrieved by GetGeneralMPInfo(). + @param[in] EnableOldBSP If TRUE, then the old BSP will be listed as an + enabled AP. Otherwise, it will be disabled. + + @retval EFI_SUCCESS BSP successfully switched. + @retval EFI_INVALID_PARAMETER Processor with the handle specified by + ProcessorNumber does not exist. + @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP. + @retval EFI_NOT_READY IA32, X64: Specified AP is busy or disabled. + @retval EFI_INVALID_PARAMETER IPF: Specified AP is disabled. + @retval EFI_INVALID_PARAMETER IPF: Specified AP is unhealthy or untested. + @retval EFI_NOT_READY IPF: Specified AP is busy. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_SWITCH_BSP)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN UINTN ProcessorNumber, + IN BOOLEAN EnableOldBSP + ); + +/** + This service sends an IPI to a specified AP. Caller can specify vector number + and delivery mode of the interrupt. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] ProcessorNumber The handle number of AP. The range is from 0 to + the total number of logical processors minus 1. + The total number of logical processors can be + retrieved by GetGeneralMPInfo(). + @param[in] VectorNumber Vector number of the interrupt. + @param[in] DeliveryMode Delivery mode of the interrupt. + + @retval EFI_SUCCESS IPI is successfully sent. + @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP. + @retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified + by ProcessorNumber does not exist. + @retval EFI_INVALID_PARAMETER IA32, X64: VectorNumber is greater than 255. + @retval EFI_INVALID_PARAMETER IA32, X64: DeliveryMode is greater than or equal + to DELIVERY_MODE_MAX. + @retval EFI_NOT_READY IA32, X64: IPI is not accepted by the target + processor within 10 microseconds. + @retval EFI_INVALID_PARAMETER IPF: Specified AP is disabled. + @retval EFI_INVALID_PARAMETER IPF: Specified AP is unhealthy or untested. + @retval EFI_NOT_READY IPF: Specified AP is busy. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_SEND_IPI)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN UINTN ProcessorNumber, + IN UINTN VectorNumber, + IN UINTN DeliveryMode + ); + +/** + This service lets the caller enable or disable an AP. The caller can optionally + specify the health status of the AP by Health. It is usually used to update the + health status of the processor after some processor test. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[in] ProcessorNumber The handle number of AP. The range is from 0 to + the total number of logical processors minus 1. + The total number of logical processors can be + retrieved by GetGeneralMPInfo(). + @param[in] NewAPState Indicates whether the new, desired state of the + AP is enabled or disabled. TRUE for enabling, + FALSE otherwise. + @param[in] HealthState If not NULL, it points to the value that specifies + the new health status of the AP. If it is NULL, + this parameter is ignored. + + @retval EFI_SUCCESS AP successfully enabled or disabled. + @retval EFI_INVALID_PARAMETER ProcessorNumber specifies the BSP. + @retval EFI_INVALID_PARAMETER IA32, X64: Processor with the handle specified + by ProcessorNumber does not exist. + @retval EFI_INVALID_PARAMETER IPF: If an unhealthy or untested AP is to be + enabled. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_ENABLEDISABLEAP)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + IN UINTN ProcessorNumber, + IN BOOLEAN NewAPState, + IN EFI_MP_HEALTH *HealthState OPTIONAL + ); + +/** + This service lets the caller processor get its handle number, with which any + processor in the system can be uniquely identified. The range is from 0 to the + total number of logical processors minus 1. The total number of logical + processors can be retrieved by GetGeneralMPInfo(). This service may be called + from the BSP and APs. + + @param[in] This Pointer to the FRAMEWORK_EFI_MP_SERVICES_PROTOCOL + instance. + @param[out] ProcessorNumber A pointer to the handle number of AP. The range is + from 0 to the total number of logical processors + minus 1. The total number of logical processors + can be retrieved by GetGeneralMPInfo(). + +@retval EFI_SUCCESS This function always returns EFI_SUCCESS. + +**/ +typedef +EFI_STATUS +(EFIAPI *FRAMEWORK_EFI_MP_SERVICES_WHOAMI)( + IN FRAMEWORK_EFI_MP_SERVICES_PROTOCOL *This, + OUT UINTN *ProcessorNumber + ); + +/// +/// Framework MP Services Protocol structure +/// +typedef struct _FRAMEWORK_EFI_MP_SERVICES_PROTOCOL { + FRAMEWORK_EFI_MP_SERVICES_GET_GENERAL_MP_INFO GetGeneralMPInfo; + FRAMEWORK_EFI_MP_SERVICES_GET_PROCESSOR_CONTEXT GetProcessorContext; + FRAMEWORK_EFI_MP_SERVICES_STARTUP_ALL_APS StartupAllAPs; + FRAMEWORK_EFI_MP_SERVICES_STARTUP_THIS_AP StartupThisAP; + FRAMEWORK_EFI_MP_SERVICES_SWITCH_BSP SwitchBSP; + FRAMEWORK_EFI_MP_SERVICES_SEND_IPI SendIPI; + FRAMEWORK_EFI_MP_SERVICES_ENABLEDISABLEAP EnableDisableAP; + FRAMEWORK_EFI_MP_SERVICES_WHOAMI WhoAmI; +}; + +extern EFI_GUID gFrameworkEfiMpServiceProtocolGuid; + +#endif diff --git a/IntelFrameworkPkg/IntelFrameworkPkg.dec b/IntelFrameworkPkg/IntelFrameworkPkg.dec index 33305d275a..82254e44e5 100644 --- a/IntelFrameworkPkg/IntelFrameworkPkg.dec +++ b/IntelFrameworkPkg/IntelFrameworkPkg.dec @@ -108,6 +108,9 @@ ## Include/Protocol/FrameworkHii.h gEfiHiiCompatibilityProtocolGuid = { 0x5542cce1, 0xdf5c, 0x4d1b, { 0xab, 0xca, 0x36, 0x4f, 0x77, 0xd3, 0x99, 0xfb }} + + ## Include/Protocol/FrameworkMpService.h + gFrameworkEfiMpServiceProtocolGuid = { 0xf33261e7, 0x23cb, 0x11d5, {0xbd, 0x5c, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81}} ## Include/Protocol/IdeControllerInit.h gEfiIdeControllerInitProtocolGuid = { 0xa1e37052, 0x80d9, 0x4e65, { 0xa3, 0x17, 0x3e, 0x9a, 0x55, 0xc4, 0x3e, 0xc9 }} -- 2.39.2