/** @file
|
File to contain all the hardware specific stuff for the Periodical Timer dispatch protocol.
|
|
Copyright (c) 2013-2016 Intel Corporation.
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
**/
|
|
//
|
// Include common header file for this module.
|
//
|
#include "CommonHeader.h"
|
|
#include "QNCSmmHelpers.h"
|
|
typedef enum {
|
PERIODIC_TIMER = 0,
|
NUM_TIMERS
|
} SUPPORTED_TIMER;
|
|
typedef struct _TIMER_INTERVAL
|
{
|
UINT64 Interval;
|
UINT8 AssociatedTimer;
|
} TIMER_INTERVAL;
|
|
//
|
// Time constants, in 100 nano-second units
|
//
|
#define TIME_64s 640000000 /* 64 s */
|
#define TIME_32s 320000000 /* 32 s */
|
#define TIME_16s 160000000 /* 16 s */
|
#define TIME_8s 80000000 /* 8 s */
|
#define TIME_64ms 640000 /* 64 ms */
|
#define TIME_32ms 320000 /* 32 ms */
|
#define TIME_16ms 160000 /* 16 ms */
|
#define TIME_1_5ms 15000 /* 1.5 ms */
|
|
// PMCW (GPE+28h) [2:0] Periodic SMI Rate selection
|
// 000 1.5ms
|
// 001 16ms
|
// 010 32ms
|
// 011 64ms
|
// 100 8s
|
// 101 16s
|
// 110 32s
|
// 111 64s
|
|
typedef enum {
|
INDEX_TIME_1_5ms = 0,
|
INDEX_TIME_16ms,
|
INDEX_TIME_32ms,
|
INDEX_TIME_64ms,
|
INDEX_TIME_8s,
|
INDEX_TIME_16s,
|
INDEX_TIME_32s,
|
INDEX_TIME_64s,
|
INDEX_TIME_MAX
|
} TIMER_INTERVAL_INDEX;
|
|
TIMER_INTERVAL mSmmPeriodicTimerIntervals[INDEX_TIME_MAX] = {
|
{TIME_1_5ms, PERIODIC_TIMER},
|
{TIME_16ms, PERIODIC_TIMER},
|
{TIME_32ms, PERIODIC_TIMER},
|
{TIME_64ms, PERIODIC_TIMER},
|
{ TIME_8s, PERIODIC_TIMER },
|
{TIME_16s, PERIODIC_TIMER},
|
{TIME_32s, PERIODIC_TIMER},
|
{TIME_64s, PERIODIC_TIMER}
|
};
|
|
typedef struct _TIMER_INFO {
|
UINTN NumChildren; // number of children using this timer
|
UINT64 MinReqInterval; // minimum interval required by children
|
UINTN CurrentSetting; // interval this timer is set at right now (index into interval table)
|
} TIMER_INFO;
|
|
TIMER_INFO mTimers[NUM_TIMERS];
|
|
QNC_SMM_SOURCE_DESC mTIMER_SOURCE_DESCS[NUM_TIMERS] = {
|
{
|
QNC_SMM_NO_FLAGS,
|
{
|
{{GPE_ADDR_TYPE, {R_QNC_GPE0BLK_SMIE}}, S_QNC_GPE0BLK_SMIE, N_QNC_GPE0BLK_SMIE_SWT},
|
NULL_BIT_DESC_INITIALIZER
|
},
|
{
|
{{GPE_ADDR_TYPE, {R_QNC_GPE0BLK_SMIS}}, S_QNC_GPE0BLK_SMIS, N_QNC_GPE0BLK_SMIS_SWT}
|
}
|
}
|
};
|
|
VOID
|
QNCSmmPeriodicTimerProgramTimers(
|
VOID
|
);
|
|
|
TIMER_INTERVAL *
|
ContextToTimerInterval (
|
IN QNC_SMM_CONTEXT *RegisterContext
|
)
|
{
|
UINTN loopvar;
|
|
//
|
// Determine which timer this child is using
|
//
|
for (loopvar = 0; loopvar < INDEX_TIME_MAX; loopvar++) {
|
if (((RegisterContext->PeriodicTimer.SmiTickInterval == 0) && (RegisterContext->PeriodicTimer.Period >= mSmmPeriodicTimerIntervals[loopvar].Interval)) ||
|
(RegisterContext->PeriodicTimer.SmiTickInterval == mSmmPeriodicTimerIntervals[loopvar].Interval)
|
) {
|
return &mSmmPeriodicTimerIntervals[loopvar];
|
}
|
}
|
|
//
|
// If this assertion fires, then either:
|
// (1) the context contains an invalid interval
|
// (2) the timer interval table is corrupt
|
//
|
// ASSERT (FALSE);
|
|
return NULL;
|
}
|
|
EFI_STATUS
|
MapPeriodicTimerToSrcDesc (
|
IN QNC_SMM_CONTEXT *RegisterContext,
|
OUT QNC_SMM_SOURCE_DESC *SrcDesc
|
)
|
{
|
TIMER_INTERVAL *TimerInterval;
|
|
//
|
// Figure out which timer the child is requesting and
|
// send back the source description
|
//
|
TimerInterval = ContextToTimerInterval (RegisterContext);
|
if (TimerInterval == NULL) {
|
return EFI_INVALID_PARAMETER;
|
}
|
CopyMem (SrcDesc, &mTIMER_SOURCE_DESCS[TimerInterval->AssociatedTimer], sizeof (QNC_SMM_SOURCE_DESC));;
|
|
//
|
// Program the value of the interval into hardware
|
//
|
QNCSmmPeriodicTimerProgramTimers ();
|
|
return EFI_SUCCESS;
|
}
|
|
VOID
|
PeriodicTimerGetContext (
|
IN DATABASE_RECORD *Record,
|
OUT QNC_SMM_CONTEXT *HwContext
|
)
|
{
|
TIMER_INTERVAL *TimerInterval;
|
|
ASSERT (Record->ProtocolType == PeriodicTimerType);
|
|
TimerInterval = ContextToTimerInterval (&Record->ChildContext);
|
|
if (TimerInterval != NULL) {
|
//
|
// Ignore the hardware context. It's not required for this protocol.
|
// Instead, just increment the child's context.
|
// Update the elapsed time w/ the data from our tables
|
//
|
Record->CommBuffer.PeriodicTimer.ElapsedTime += TimerInterval->Interval;
|
CopyMem (HwContext, &Record->ChildContext, sizeof (QNC_SMM_CONTEXT));
|
}
|
}
|
|
BOOLEAN
|
PeriodicTimerCmpContext (
|
IN QNC_SMM_CONTEXT *HwContext,
|
IN QNC_SMM_CONTEXT *ChildContext
|
)
|
{
|
DATABASE_RECORD *Record;
|
|
Record = DATABASE_RECORD_FROM_CONTEXT (ChildContext);
|
|
if (Record->CommBuffer.PeriodicTimer.ElapsedTime >= ChildContext->PeriodicTimer.Period) {
|
//
|
// This child should be dispatched
|
// The timer will be restarted on the "ClearSource" call.
|
//
|
return TRUE;
|
} else {
|
return FALSE;
|
}
|
}
|
|
VOID
|
PeriodicTimerGetBuffer (
|
IN DATABASE_RECORD * Record
|
)
|
{
|
//
|
// CommBuffer has been updated by PeriodicTimerGetContext, so return directly
|
//
|
return;
|
}
|
|
VOID
|
QNCSmmPeriodicTimerProgramTimers (
|
VOID
|
)
|
{
|
UINT32 GpePmcwValue;
|
SUPPORTED_TIMER Timer;
|
DATABASE_RECORD *RecordInDb;
|
LIST_ENTRY *LinkInDb;
|
TIMER_INTERVAL *TimerInterval;
|
|
//
|
// Find the minimum required interval for each timer
|
//
|
for (Timer = (SUPPORTED_TIMER)0; Timer < NUM_TIMERS; Timer++) {
|
mTimers[Timer].MinReqInterval = ~(UINT64)0x0;
|
mTimers[Timer].NumChildren = 0;
|
}
|
LinkInDb = GetFirstNode (&mPrivateData.CallbackDataBase);
|
while (!IsNull (&mPrivateData.CallbackDataBase, LinkInDb)) {
|
RecordInDb = DATABASE_RECORD_FROM_LINK (LinkInDb);
|
if (RecordInDb->ProtocolType == PeriodicTimerType) {
|
//
|
// This child is registerd with the PeriodicTimer protocol
|
//
|
TimerInterval = ContextToTimerInterval (&RecordInDb->ChildContext);
|
|
if(TimerInterval != NULL) {
|
Timer = (SUPPORTED_TIMER)((TIMER_INTERVAL *) (TimerInterval))->AssociatedTimer;
|
|
ASSERT (Timer >= 0 && Timer < NUM_TIMERS);
|
|
if (mTimers[Timer].MinReqInterval > RecordInDb->ChildContext.PeriodicTimer.SmiTickInterval) {
|
mTimers[Timer].MinReqInterval = RecordInDb->ChildContext.PeriodicTimer.SmiTickInterval;
|
}
|
mTimers[Timer].NumChildren++;
|
}
|
}
|
LinkInDb = GetNextNode (&mPrivateData.CallbackDataBase, &RecordInDb->Link);
|
}
|
|
//
|
// Program the hardware
|
//
|
GpePmcwValue = 0;
|
if (mTimers[PERIODIC_TIMER].NumChildren > 0) {
|
switch (mTimers[PERIODIC_TIMER].MinReqInterval) {
|
|
case TIME_64s:
|
GpePmcwValue = INDEX_TIME_64s;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_64s;
|
break;
|
|
case TIME_32s:
|
GpePmcwValue = INDEX_TIME_32s;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_32s;
|
break;
|
|
case TIME_16s:
|
GpePmcwValue = INDEX_TIME_16s;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_16s;
|
break;
|
|
case TIME_8s:
|
GpePmcwValue = INDEX_TIME_8s;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_8s;
|
break;
|
|
case TIME_64ms:
|
GpePmcwValue = INDEX_TIME_64ms;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_64ms;
|
break;
|
|
case TIME_32ms:
|
GpePmcwValue = INDEX_TIME_32ms;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_32ms;
|
break;
|
|
case TIME_16ms:
|
GpePmcwValue = INDEX_TIME_16ms;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_16ms;
|
break;
|
|
case TIME_1_5ms:
|
GpePmcwValue = INDEX_TIME_1_5ms;
|
mTimers[PERIODIC_TIMER].CurrentSetting = INDEX_TIME_1_5ms;
|
break;
|
|
default:
|
ASSERT (FALSE);
|
break;
|
};
|
|
GpePmcwValue |= B_QNC_GPE0BLK_PMCW_PSE;
|
|
IoOr32(((UINT16)(LpcPciCfg32 (R_QNC_LPC_GPE0BLK) & 0xFFFF) + R_QNC_GPE0BLK_PMCW), GpePmcwValue);
|
|
//
|
// Restart the timer here, just need to clear the SMI
|
//
|
QNCSmmClearSource (&mTIMER_SOURCE_DESCS[PERIODIC_TIMER]);
|
} else {
|
QNCSmmDisableSource (&mTIMER_SOURCE_DESCS[PERIODIC_TIMER]);
|
}
|
}
|
|
EFI_STATUS
|
QNCSmmPeriodicTimerDispatchGetNextShorterInterval (
|
IN CONST EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL *This,
|
IN OUT UINT64 **SmiTickInterval
|
)
|
/*++
|
|
Routine Description:
|
|
This services returns the next SMI tick period that is supported by the chipset.
|
The order returned is from longest to shortest interval period.
|
|
Arguments:
|
|
This - Pointer to the EFI_SMM_PERIODIC_TIMER_DISPATCH2_PROTOCOL instance.
|
SmiTickInterval - Pointer to pointer of the next shorter SMI interval period that is supported by the child.
|
|
Returns:
|
|
EFI_SUCCESS - The service returned successfully.
|
EFI_INVALID_PARAMETER - The parameter SmiTickInterval is invalid.
|
|
--*/
|
{
|
TIMER_INTERVAL *IntervalPointer;
|
|
ASSERT (SmiTickInterval != NULL);
|
|
IntervalPointer = (TIMER_INTERVAL*)*SmiTickInterval;
|
|
if (IntervalPointer == NULL) {
|
//
|
// The first time child requesting an interval
|
//
|
IntervalPointer = &mSmmPeriodicTimerIntervals[0];
|
} else if (IntervalPointer == &mSmmPeriodicTimerIntervals[INDEX_TIME_MAX - 1]) {
|
//
|
// At end of the list
|
//
|
IntervalPointer = NULL;
|
} else {
|
if ((IntervalPointer >= &mSmmPeriodicTimerIntervals[0]) &&
|
(IntervalPointer < &mSmmPeriodicTimerIntervals[INDEX_TIME_MAX - 1])) {
|
//
|
// Get the next interval in the list
|
//
|
IntervalPointer++;
|
} else {
|
//
|
// Input is out of range
|
//
|
return EFI_INVALID_PARAMETER;
|
}
|
}
|
|
if (IntervalPointer != NULL) {
|
*SmiTickInterval = &IntervalPointer->Interval;
|
} else {
|
*SmiTickInterval = NULL;
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
VOID
|
QNCSmmPeriodicTimerClearSource (
|
IN QNC_SMM_SOURCE_DESC *SrcDesc
|
)
|
/*++
|
|
Routine Description:
|
|
This function is responsible for calculating and enabling any timers that are required
|
to dispatch messages to children. The SrcDesc argument isn't acutally used.
|
|
Arguments:
|
|
SrcDesc - Pointer to the QNC_SMM_SOURCE_DESC instance.
|
|
Returns:
|
|
None.
|
|
--*/
|
{
|
DATABASE_RECORD *RecordInDb;
|
LIST_ENTRY *LinkInDb;
|
|
QNCSmmPeriodicTimerProgramTimers ();
|
|
//
|
// Reset Elapsed time
|
//
|
LinkInDb = GetFirstNode (&mPrivateData.CallbackDataBase);
|
while (!IsNull (&mPrivateData.CallbackDataBase, LinkInDb)) {
|
RecordInDb = DATABASE_RECORD_FROM_LINK (LinkInDb);
|
if (RecordInDb->ProtocolType == PeriodicTimerType) {
|
//
|
// This child is registerd with the PeriodicTimer protocol and Callback
|
// has been invoked, so reset the ElapsedTime to 0
|
//
|
if (RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime >= RecordInDb->ChildContext.PeriodicTimer.Period) {
|
RecordInDb->CommBuffer.PeriodicTimer.ElapsedTime = 0;
|
}
|
}
|
LinkInDb = GetNextNode (&mPrivateData.CallbackDataBase, &RecordInDb->Link);
|
}
|
}
|
|
