ScmiPerformanceProtocol.c

Go to the documentation of this file.

 
#include <Library/BaseMemoryLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Protocol/ArmScmiPerformanceProtocol.h>
 
#include "ArmScmiPerformanceProtocolPrivate.h"
#include "ScmiPrivate.h"
 
STATIC
EFI_STATUS
PerformanceGetVersion (
  IN  SCMI_PERFORMANCE_PROTOCOL  *This,
  OUT UINT32                     *Version
  )
{
  return ScmiGetProtocolVersion (ScmiProtocolIdPerformance, Version);
}
 
STATIC
EFI_STATUS
PerformanceGetAttributes (
  IN  SCMI_PERFORMANCE_PROTOCOL             *This,
  OUT SCMI_PERFORMANCE_PROTOCOL_ATTRIBUTES  *Attributes
  )
{
  EFI_STATUS  Status;
  UINT32      *ReturnValues;
 
  Status = ScmiGetProtocolAttributes (
             ScmiProtocolIdPerformance,
             &ReturnValues
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (
    Attributes,
    ReturnValues,
    sizeof (SCMI_PERFORMANCE_PROTOCOL_ATTRIBUTES)
    );
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
PerformanceDomainAttributes (
  IN  SCMI_PERFORMANCE_PROTOCOL           *This,
  IN  UINT32                              DomainId,
  OUT SCMI_PERFORMANCE_DOMAIN_ATTRIBUTES  *DomainAttributes
  )
{
  EFI_STATUS    Status;
  UINT32        *MessageParams;
  UINT32        *ReturnValues;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams = DomainId;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceDomainAttributes;
 
  PayloadLength = sizeof (DomainId);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             &ReturnValues
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (
    DomainAttributes,
    ReturnValues,
    sizeof (SCMI_PERFORMANCE_DOMAIN_ATTRIBUTES)
    );
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
PerformanceDescribeLevels (
  IN     SCMI_PERFORMANCE_PROTOCOL  *This,
  IN     UINT32                     DomainId,
  OUT    UINT32                     *NumLevels,
  IN OUT UINT32                     *LevelArraySize,
  OUT    SCMI_PERFORMANCE_LEVEL     *LevelArray
  )
{
  EFI_STATUS    Status;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
  UINT32        *MessageParams;
  UINT32        LevelIndex;
  UINT32        RequiredSize;
  UINT32        LevelNo;
  UINT32        ReturnNumLevels;
  UINT32        ReturnRemainNumLevels;
 
  PERF_DESCRIBE_LEVELS  *Levels;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  LevelIndex   = 0;
  RequiredSize = 0;
 
  *MessageParams++ = DomainId;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceDescribeLevels;
 
  do {
    *MessageParams = LevelIndex;
 
    // Note, PayloadLength is an IN/OUT parameter.
    PayloadLength = sizeof (DomainId) + sizeof (LevelIndex);
 
    Status = ScmiCommandExecute (
               &Cmd,
               &PayloadLength,
               (UINT32 **)&Levels
               );
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    ReturnNumLevels       = NUM_PERF_LEVELS (Levels->NumLevels);
    ReturnRemainNumLevels = NUM_REMAIN_PERF_LEVELS (Levels->NumLevels);
 
    if (RequiredSize == 0) {
      *NumLevels = ReturnNumLevels + ReturnRemainNumLevels;
 
      RequiredSize =  (*NumLevels) * sizeof (SCMI_PERFORMANCE_LEVEL);
      if (RequiredSize > (*LevelArraySize)) {
        // Update LevelArraySize with required size.
        *LevelArraySize = RequiredSize;
        return EFI_BUFFER_TOO_SMALL;
      }
    }
 
    for (LevelNo = 0; LevelNo < ReturnNumLevels; LevelNo++) {
      CopyMem (
        &LevelArray[LevelIndex++],
        &Levels->PerfLevel[LevelNo],
        sizeof (SCMI_PERFORMANCE_LEVEL)
        );
    }
  } while (ReturnRemainNumLevels != 0);
 
  *LevelArraySize = RequiredSize;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PerformanceLimitsSet (
  IN SCMI_PERFORMANCE_PROTOCOL  *This,
  IN UINT32                     DomainId,
  IN SCMI_PERFORMANCE_LIMITS    *Limits
  )
{
  EFI_STATUS    Status;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
  UINT32        *MessageParams;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams++ = DomainId;
  *MessageParams++ = Limits->RangeMax;
  *MessageParams   = Limits->RangeMin;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceLimitsSet;
 
  PayloadLength = sizeof (DomainId) + sizeof (SCMI_PERFORMANCE_LIMITS);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             NULL
             );
 
  return Status;
}
 
EFI_STATUS
PerformanceLimitsGet (
  SCMI_PERFORMANCE_PROTOCOL  *This,
  UINT32                     DomainId,
  SCMI_PERFORMANCE_LIMITS    *Limits
  )
{
  EFI_STATUS    Status;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
  UINT32        *MessageParams;
 
  SCMI_PERFORMANCE_LIMITS  *ReturnValues;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams = DomainId;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceLimitsGet;
 
  PayloadLength = sizeof (DomainId);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             (UINT32 **)&ReturnValues
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Limits->RangeMax = ReturnValues->RangeMax;
  Limits->RangeMin = ReturnValues->RangeMin;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PerformanceLevelSet (
  IN SCMI_PERFORMANCE_PROTOCOL  *This,
  IN UINT32                     DomainId,
  IN UINT32                     Level
  )
{
  EFI_STATUS    Status;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
  UINT32        *MessageParams;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams++ = DomainId;
  *MessageParams   = Level;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceLevelSet;
 
  PayloadLength = sizeof (DomainId) + sizeof (Level);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             NULL
             );
 
  return Status;
}
 
EFI_STATUS
PerformanceLevelGet (
  IN  SCMI_PERFORMANCE_PROTOCOL  *This,
  IN  UINT32                     DomainId,
  OUT UINT32                     *Level
  )
{
  EFI_STATUS    Status;
  UINT32        PayloadLength;
  SCMI_COMMAND  Cmd;
  UINT32        *ReturnValues;
  UINT32        *MessageParams;
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams = DomainId;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceLevelGet;
 
  PayloadLength = sizeof (DomainId);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             &ReturnValues
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *Level = *ReturnValues;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
DescribeFastchannel (
  IN  SCMI_PERFORMANCE_PROTOCOL     *This,
  IN  UINT32                        DomainId,
  IN  SCMI_MESSAGE_ID_PERFORMANCE   MessageId,
  OUT SCMI_PERFORMANCE_FASTCHANNEL  *FastChannel
  )
{
  EFI_STATUS    Status;
  SCMI_COMMAND  Cmd;
  UINT32        PayloadLength;
  UINT32        *ReturnValues;
  UINT32        *MessageParams;
 
  if ((This == NULL)  ||
      (FastChannel == NULL))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = ScmiCommandGetPayload (&MessageParams);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *MessageParams++ = DomainId;
  *MessageParams   = MessageId;
 
  Cmd.ProtocolId = ScmiProtocolIdPerformance;
  Cmd.MessageId  = ScmiMessageIdPerformanceDescribeFastchannel;
  PayloadLength  = sizeof (DomainId) + sizeof (MessageId);
 
  Status = ScmiCommandExecute (
             &Cmd,
             &PayloadLength,
             &ReturnValues
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  CopyMem (
    FastChannel,
    ReturnValues,
    sizeof (SCMI_PERFORMANCE_FASTCHANNEL)
    );
 
  return Status;
}
 
// Instance of the SCMI performance management protocol.
STATIC CONST SCMI_PERFORMANCE_PROTOCOL  PerformanceProtocol = {
  PerformanceGetVersion,
  PerformanceGetAttributes,
  PerformanceDomainAttributes,
  PerformanceDescribeLevels,
  PerformanceLimitsSet,
  PerformanceLimitsGet,
  PerformanceLevelSet,
  PerformanceLevelGet,
  DescribeFastchannel,
};
 
EFI_STATUS
ScmiPerformanceProtocolInit (
  IN EFI_HANDLE  *Handle
  )
{
  return gBS->InstallMultipleProtocolInterfaces (
                Handle,
                &gArmScmiPerformanceProtocolGuid,
                &PerformanceProtocol,
                NULL
                );
}