SpmiGenerator.c

Go to the documentation of this file.

 
#include <IndustryStandard/ServiceProcessorManagementInterfaceTable.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Protocol/AcpiTable.h>
 
// Module specific include files.
#include <AcpiTableGenerator.h>
#include <ConfigurationManagerObject.h>
#include <ConfigurationManagerHelper.h>
#include <Library/TableHelperLib.h>
#include <IndustryStandard/IpmiNetFnApp.h>
#include <Library/IpmiCommandLib.h>
#include <Protocol/ConfigurationManagerProtocol.h>
 
GET_OBJECT_LIST (
  EObjNameSpaceArchCommon,
  EArchCommonObjSpmiInterfaceInfo,
  CM_ARCH_COMMON_SPMI_INTERFACE_INFO
  );
 
GET_OBJECT_LIST (
  EObjNameSpaceArchCommon,
  EArchCommonObjSpmiInterruptDeviceInfo,
  CM_ARCH_COMMON_SPMI_INTERRUPT_DEVICE_INFO
  );
 
STATIC
EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_TABLE  AcpiSpmi = {
  ACPI_HEADER (
    EFI_ACPI_6_5_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE,
    EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_TABLE,
    EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_5_TABLE_REVISION
    ),
  0x00,
  0x01,
  0x0200,
  0x00,
  0x00,
  0x00,
  0x00,
  0x00,
  { 0,                                                                0,0, 0, 0 },
  {
    { 0x00 }
  },
  0x00
};
 
STATIC
EFI_STATUS
EFIAPI
BuildSpmiTable (
  IN  CONST ACPI_TABLE_GENERATOR                  *CONST  This,
  IN  CONST CM_STD_OBJ_ACPI_TABLE_INFO            *CONST  AcpiTableInfo,
  IN  CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL  *CONST  CfgMgrProtocol,
  OUT       EFI_ACPI_DESCRIPTION_HEADER          **CONST  Table
  )
{
  EFI_STATUS                                 Status;
  CM_ARCH_COMMON_SPMI_INTERFACE_INFO         *SpmiInfo;
  CM_ARCH_COMMON_SPMI_INTERRUPT_DEVICE_INFO  *SpmiIntrDeviceInfo;
  IPMI_GET_DEVICE_ID_RESPONSE                DeviceId;
 
  ASSERT (This != NULL);
  ASSERT (AcpiTableInfo != NULL);
  ASSERT (CfgMgrProtocol != NULL);
  ASSERT (Table != NULL);
  ASSERT (AcpiTableInfo->TableGeneratorId == This->GeneratorID);
  ASSERT (AcpiTableInfo->AcpiTableSignature == This->AcpiTableSignature);
 
  if ((AcpiTableInfo->AcpiTableRevision < This->MinAcpiTableRevision) ||
      (AcpiTableInfo->AcpiTableRevision > This->AcpiTableRevision))
  {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: Requested table revision = %d, is not supported."
      "Supported table revision: Minimum = %d, Maximum = %d\n",
      AcpiTableInfo->AcpiTableRevision,
      This->MinAcpiTableRevision,
      This->AcpiTableRevision
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  *Table = NULL;
 
  Status = GetEArchCommonObjSpmiInterfaceInfo (
             CfgMgrProtocol,
             CM_NULL_TOKEN,
             &SpmiInfo,
             NULL
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: Failed to retrieve interface type and base address.\n"
      ));
    return Status;
  }
 
  if ((SpmiInfo->InterfaceType < EFI_ACPI_SPMI_INTERFACE_TYPE_KCS) ||
      (SpmiInfo->InterfaceType > EFI_ACPI_SPMI_INTERFACE_TYPE_SSIF))
  {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: The Interface Type is invalid. Type = %d\n",
      SpmiInfo->InterfaceType
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  if ((SpmiInfo->InterfaceType == EFI_ACPI_SPMI_INTERFACE_TYPE_SSIF) &&
      (SpmiInfo->BaseAddress.AddressSpaceId != EFI_ACPI_6_5_SMBUS))
  {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: Invalid Address Space ID for SSIF. ID = %d\n",
      SpmiInfo->BaseAddress.AddressSpaceId
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  if ((SpmiInfo->InterfaceType != EFI_ACPI_SPMI_INTERFACE_TYPE_SSIF) &&
      ((SpmiInfo->BaseAddress.AddressSpaceId != EFI_ACPI_6_5_SYSTEM_MEMORY) &&
       (SpmiInfo->BaseAddress.AddressSpaceId != EFI_ACPI_6_5_SYSTEM_IO)))
  {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: Invalid Address Space ID. ID = %d\n",
      SpmiInfo->BaseAddress.AddressSpaceId
      ));
    return EFI_INVALID_PARAMETER;
  }
 
  Status = GetEArchCommonObjSpmiInterruptDeviceInfo (
             CfgMgrProtocol,
             CM_NULL_TOKEN,
             &SpmiIntrDeviceInfo,
             NULL
             );
  if (!EFI_ERROR (Status)) {
    if ((SpmiIntrDeviceInfo->InterruptType >> 2) != 0 ) {
      DEBUG ((
        DEBUG_ERROR,
        "ERROR: SPMI: The Interrupt Type has non-zero reserved bits. InterruptType = 0x%x\n",
        SpmiIntrDeviceInfo->InterruptType
        ));
      return EFI_INVALID_PARAMETER;
    }
 
    if (SpmiInfo->InterfaceType == EFI_ACPI_SPMI_INTERFACE_TYPE_SSIF) {
      if ((SpmiIntrDeviceInfo->InterruptType & BIT0) != 0) {
        DEBUG ((
          DEBUG_ERROR,
          "ERROR: SPMI: The Interrupt Type bit0 should be zero for SSIF interface type.\n"
          ));
        return EFI_INVALID_PARAMETER;
      }
 
      if ((SpmiIntrDeviceInfo->PciDeviceFlag & BIT0) != 0) {
        DEBUG ((
          DEBUG_ERROR,
          "ERROR: SPMI: PCI Device Flag is invalid for SSIF interface type.\n"
          ));
        return EFI_INVALID_PARAMETER;
      }
    }
 
    if ((SpmiIntrDeviceInfo->Gpe != 0) &&
        ((SpmiIntrDeviceInfo->InterruptType & BIT0) == 0))
    {
      DEBUG ((
        DEBUG_ERROR,
        "ERROR: SPMI: The Interrupt Type bit0 should be set if a GPE number is provided.\n"
        ));
      return EFI_INVALID_PARAMETER;
    }
 
    if ((SpmiIntrDeviceInfo->GlobalSystemInterrupt != 0) &&
        ((SpmiIntrDeviceInfo->InterruptType & BIT1) ==  0))
    {
      DEBUG ((
        DEBUG_ERROR,
        "ERROR: SPMI: Invalid interrupt type = 0x%x for GSI 0x%x\n",
        SpmiIntrDeviceInfo->InterruptType,
        SpmiIntrDeviceInfo->GlobalSystemInterrupt
        ));
      return EFI_INVALID_PARAMETER;
    }
 
    AcpiSpmi.InterruptType         = SpmiIntrDeviceInfo->InterruptType;
    AcpiSpmi.Gpe                   = SpmiIntrDeviceInfo->Gpe;
    AcpiSpmi.PciDeviceFlag         = SpmiIntrDeviceInfo->PciDeviceFlag;
    AcpiSpmi.GlobalSystemInterrupt = SpmiIntrDeviceInfo->GlobalSystemInterrupt;
    AcpiSpmi.DeviceId.Uid          = SpmiIntrDeviceInfo->DeviceId;
  } else {
    DEBUG ((
      DEBUG_INFO,
      "INFO: SPMI: The platform does not provide interrupt and PCI device information.\n"
      ));
    DEBUG ((
      DEBUG_INFO,
      "Using default values (0) for the interrupt and PCI device information.\n"
      ));
  }
 
  Status = IpmiGetDeviceId (&DeviceId);
  if (!EFI_ERROR (Status) && (DeviceId.CompletionCode == IPMI_COMP_CODE_NORMAL)) {
    AcpiSpmi.SpecificationRevision  = DeviceId.SpecificationVersion & 0xF0;
    AcpiSpmi.SpecificationRevision |= (DeviceId.SpecificationVersion & 0xF) << 8;
  }
 
  AcpiSpmi.InterfaceType = SpmiInfo->InterfaceType;
  CopyMem (
    &AcpiSpmi.BaseAddress,
    &SpmiInfo->BaseAddress,
    sizeof (EFI_ACPI_6_5_GENERIC_ADDRESS_STRUCTURE)
    );
 
  Status = AddAcpiHeader (
             CfgMgrProtocol,
             This,
             (EFI_ACPI_DESCRIPTION_HEADER *)&AcpiSpmi,
             AcpiTableInfo,
             sizeof (EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_TABLE)
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((
      DEBUG_ERROR,
      "ERROR: SPMI: Failed to add ACPI header. Status = %r\n",
      Status
      ));
  }
 
  *Table = (EFI_ACPI_DESCRIPTION_HEADER *)&AcpiSpmi;
  return Status;
}
 
#define SPMI_GENERATOR_REVISION  CREATE_REVISION (1, 0)
 
STATIC
CONST
ACPI_TABLE_GENERATOR  SpmiGenerator = {
  // Generator ID
  CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdSpmi),
  // Generator Description
  L"ACPI.STD.SPMI.GENERATOR",
  // ACPI Table Signature
  EFI_ACPI_6_5_SERVER_PLATFORM_MANAGEMENT_INTERFACE_TABLE_SIGNATURE,
  // ACPI Table Revision supported by this Generator
  EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_5_TABLE_REVISION,
  // Minimum supported ACPI Table Revision
  EFI_ACPI_SERVICE_PROCESSOR_MANAGEMENT_INTERFACE_5_TABLE_REVISION,
  // Creator ID
  TABLE_GENERATOR_CREATOR_ID,
  // Creator Revision
  SPMI_GENERATOR_REVISION,
  // Build Table function
  BuildSpmiTable,
  // Free Resource function
  NULL,
  // Extended build function not needed
  NULL,
  // Extended build function not implemented by the generator.
  // Hence extended free resource function is not required.
  NULL
};
 
EFI_STATUS
EFIAPI
AcpiSpmiLibConstructor (
  IN  EFI_HANDLE        ImageHandle,
  IN  EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = RegisterAcpiTableGenerator (&SpmiGenerator);
  DEBUG ((DEBUG_INFO, "SPMI: Register Generator. Status = %r\n", Status));
  ASSERT_EFI_ERROR (Status);
  return Status;
}
 
EFI_STATUS
EFIAPI
AcpiSpmiLibDestructor (
  IN  EFI_HANDLE        ImageHandle,
  IN  EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  Status = DeregisterAcpiTableGenerator (&SpmiGenerator);
  DEBUG ((DEBUG_INFO, "SPMI: Deregister Generator. Status = %r\n", Status));
  ASSERT_EFI_ERROR (Status);
  return Status;
}