Scmi.c

Go to the documentation of this file.

 
#include <Library/ArmMtlLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
 
#include "ScmiPrivate.h"
 
// Arbitrary timeout value 20ms.
#define  RESPONSE_TIMEOUT  20000
 
EFI_STATUS
ScmiCommandGetPayload (
  OUT UINT32  **Payload
  )
{
  EFI_STATUS   Status;
  MTL_CHANNEL  *Channel;
 
  // Get handle to the Channel.
  Status = MtlGetChannel (MTL_CHANNEL_TYPE_LOW, &Channel);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Payload will not be populated until channel is free.
  Status = MtlWaitUntilChannelFree (Channel, RESPONSE_TIMEOUT);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Get the address of the payload.
  *Payload = MtlGetChannelPayload (Channel);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
ScmiCommandExecute (
  IN     SCMI_COMMAND  *Command,
  IN OUT UINT32        *PayloadLength,
  OUT    UINT32        **ReturnValues OPTIONAL
  )
{
  EFI_STATUS             Status;
  SCMI_MESSAGE_RESPONSE  *Response;
  UINT32                 MessageHeader;
  UINT32                 ResponseHeader;
  MTL_CHANNEL            *Channel;
 
  ASSERT (PayloadLength != NULL);
 
  Status = MtlGetChannel (MTL_CHANNEL_TYPE_LOW, &Channel);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Fill in message header.
  MessageHeader = SCMI_MESSAGE_HEADER (
                    Command->MessageId,
                    ScmiMessageTypeCommand,
                    Command->ProtocolId
                    );
 
  // Send payload using MTL channel.
  Status = MtlSendMessage (
             Channel,
             MessageHeader,
             *PayloadLength
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Wait for the response on the channel.
  Status = MtlReceiveMessage (Channel, &ResponseHeader, PayloadLength);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // SCMI must return MessageHeader unmodified.
  if (MessageHeader != ResponseHeader) {
    ASSERT (FALSE);
    return EFI_DEVICE_ERROR;
  }
 
  Response = (SCMI_MESSAGE_RESPONSE *)MtlGetChannelPayload (Channel);
 
  if (Response->Status != ScmiSuccess) {
    DEBUG ((
      DEBUG_ERROR,
      "SCMI error: ProtocolId = 0x%x, MessageId = 0x%x, error = %d\n",
      Command->ProtocolId,
      Command->MessageId,
      Response->Status
      ));
 
    ASSERT (FALSE);
    return EFI_DEVICE_ERROR;
  }
 
  if (ReturnValues != NULL) {
    *ReturnValues = Response->ReturnValues;
  }
 
  return EFI_SUCCESS;
}
 
STATIC
EFI_STATUS
ScmiProtocolDiscoveryCommon (
  IN SCMI_PROTOCOL_ID  ProtocolId,
  IN SCMI_MESSAGE_ID   MessageId,
  OUT UINT32           **ReturnValues
  )
{
  SCMI_COMMAND  Command;
  UINT32        PayloadLength;
 
  PayloadLength      = 0;
  Command.ProtocolId = ProtocolId;
  Command.MessageId  = MessageId;
 
  return ScmiCommandExecute (
           &Command,
           &PayloadLength,
           ReturnValues
           );
}
 
EFI_STATUS
ScmiGetProtocolVersion (
  IN  SCMI_PROTOCOL_ID  ProtocolId,
  OUT UINT32            *Version
  )
{
  EFI_STATUS  Status;
  UINT32      *ProtocolVersion;
 
  Status = ScmiProtocolDiscoveryCommon (
             ProtocolId,
             ScmiMessageIdProtocolVersion,
             (UINT32 **)&ProtocolVersion
             );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  *Version = *ProtocolVersion;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
ScmiGetProtocolAttributes (
  IN  SCMI_PROTOCOL_ID  ProtocolId,
  OUT UINT32            **ReturnValues
  )
{
  return ScmiProtocolDiscoveryCommon (
           ProtocolId,
           ScmiMessageIdProtocolAttributes,
           ReturnValues
           );
}
 
EFI_STATUS
ScmiGetProtocolMessageAttributes (
  IN  SCMI_PROTOCOL_ID  ProtocolId,
  OUT UINT32            **ReturnValues
  )
{
  return ScmiProtocolDiscoveryCommon (
           ProtocolId,
           ScmiMessageIdProtocolMessageAttributes,
           ReturnValues
           );
}