ArmVirtPkg/VirtFdtDxe: remove handling of fw_cfg DT node

[mirror_edk2.git] / ArmVirtPkg / VirtFdtDxe / VirtFdtDxe.c

/** @file\r
*  Device tree enumeration DXE driver for ARM Virtual Machines\r
*\r
*  Copyright (c) 2014, Linaro Ltd. All rights reserved.<BR>\r
*\r
*  This program and the accompanying materials are\r
*  licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/UefiDriverEntryPoint.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/VirtioMmioDeviceLib.h>\r
#include <Library/DevicePathLib.h>\r
#include <Library/PcdLib.h>\r
#include <Library/DxeServicesLib.h>\r
#include <Library/HobLib.h>\r
#include <libfdt.h>\r
#include <Library/XenIoMmioLib.h>\r
\r
#include <Guid/Fdt.h>\r
#include <Guid/VirtioMmioTransport.h>\r
#include <Guid/FdtHob.h>\r
\r
#pragma pack (1)\r
typedef struct {\r
  VENDOR_DEVICE_PATH                  Vendor;\r
  UINT64                              PhysBase;\r
  EFI_DEVICE_PATH_PROTOCOL            End;\r
} VIRTIO_TRANSPORT_DEVICE_PATH;\r
#pragma pack ()\r
\r
typedef enum {\r
  PropertyTypeUnknown,\r
  PropertyTypeRtc,\r
  PropertyTypeVirtio,\r
  PropertyTypeUart,\r
  PropertyTypePciHost,\r
  PropertyTypeXen,\r
} PROPERTY_TYPE;\r
\r
typedef struct {\r
  PROPERTY_TYPE Type;\r
  CHAR8         Compatible[32];\r
} PROPERTY;\r
\r
STATIC CONST PROPERTY CompatibleProperties[] = {\r
  { PropertyTypeRtc,     "arm,pl031"             },\r
  { PropertyTypeVirtio,  "virtio,mmio"           },\r
  { PropertyTypeUart,    "arm,pl011"             },\r
  { PropertyTypePciHost, "pci-host-ecam-generic" },\r
  { PropertyTypeXen,     "xen,xen"               },\r
  { PropertyTypeUnknown, ""                      }\r
};\r
\r
STATIC\r
PROPERTY_TYPE\r
GetTypeFromNode (\r
  IN CONST CHAR8 *NodeType,\r
  IN UINTN       Size\r
  )\r
{\r
  CONST CHAR8    *Compatible;\r
  CONST PROPERTY *CompatibleProperty;\r
\r
  //\r
  // A 'compatible' node may contain a sequence of NULL terminated\r
  // compatible strings so check each one\r
  //\r
  for (Compatible = NodeType; Compatible < NodeType + Size && *Compatible;\r
       Compatible += 1 + AsciiStrLen (Compatible)) {\r
    for (CompatibleProperty = CompatibleProperties; CompatibleProperty->Compatible[0]; CompatibleProperty++) {\r
      if (AsciiStrCmp (CompatibleProperty->Compatible, Compatible) == 0) {\r
        return CompatibleProperty->Type;\r
      }\r
    }\r
  }\r
  return PropertyTypeUnknown;\r
}\r
\r
//\r
// We expect the "ranges" property of "pci-host-ecam-generic" to consist of\r
// records like this.\r
//\r
#pragma pack (1)\r
typedef struct {\r
  UINT32 Type;\r
  UINT64 ChildBase;\r
  UINT64 CpuBase;\r
  UINT64 Size;\r
} DTB_PCI_HOST_RANGE_RECORD;\r
#pragma pack ()\r
\r
#define DTB_PCI_HOST_RANGE_RELOCATABLE  BIT31\r
#define DTB_PCI_HOST_RANGE_PREFETCHABLE BIT30\r
#define DTB_PCI_HOST_RANGE_ALIASED      BIT29\r
#define DTB_PCI_HOST_RANGE_MMIO32       BIT25\r
#define DTB_PCI_HOST_RANGE_MMIO64       (BIT25 | BIT24)\r
#define DTB_PCI_HOST_RANGE_IO           BIT24\r
#define DTB_PCI_HOST_RANGE_TYPEMASK     (BIT31 | BIT30 | BIT29 | BIT25 | BIT24)\r
\r
/**\r
  Process the device tree node describing the generic PCI host controller.\r
\r
  param[in] DeviceTreeBase  Pointer to the device tree.\r
\r
  param[in] Node            Offset of the device tree node whose "compatible"\r
                            property is "pci-host-ecam-generic".\r
\r
  param[in] RegProp         Pointer to the "reg" property of Node. The caller\r
                            is responsible for ensuring that the size of the\r
                            property is 4 UINT32 cells.\r
\r
  @retval EFI_SUCCESS         Parsing successful, properties parsed from Node\r
                              have been stored in dynamic PCDs.\r
\r
  @retval EFI_PROTOCOL_ERROR  Parsing failed. PCDs are left unchanged.\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
ProcessPciHost (\r
  IN CONST VOID *DeviceTreeBase,\r
  IN INT32      Node,\r
  IN CONST VOID *RegProp\r
  )\r
{\r
  UINT64     ConfigBase, ConfigSize;\r
  CONST VOID *Prop;\r
  INT32      Len;\r
  UINT32     BusMin, BusMax;\r
  UINT32     RecordIdx;\r
  UINT64     IoBase, IoSize, IoTranslation;\r
  UINT64     MmioBase, MmioSize, MmioTranslation;\r
\r
  //\r
  // Fetch the ECAM window.\r
  //\r
  ConfigBase = fdt64_to_cpu (((CONST UINT64 *)RegProp)[0]);\r
  ConfigSize = fdt64_to_cpu (((CONST UINT64 *)RegProp)[1]);\r
\r
  //\r
  // Fetch the bus range (note: inclusive).\r
  //\r
  Prop = fdt_getprop (DeviceTreeBase, Node, "bus-range", &Len);\r
  if (Prop == NULL || Len != 2 * sizeof(UINT32)) {\r
    DEBUG ((EFI_D_ERROR, "%a: 'bus-range' not found or invalid\n",\r
      __FUNCTION__));\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
  BusMin = fdt32_to_cpu (((CONST UINT32 *)Prop)[0]);\r
  BusMax = fdt32_to_cpu (((CONST UINT32 *)Prop)[1]);\r
\r
  //\r
  // Sanity check: the config space must accommodate all 4K register bytes of\r
  // all 8 functions of all 32 devices of all buses.\r
  //\r
  if (BusMax < BusMin || BusMax - BusMin == MAX_UINT32 ||\r
      DivU64x32 (ConfigSize, SIZE_4KB * 8 * 32) < BusMax - BusMin + 1) {\r
    DEBUG ((EFI_D_ERROR, "%a: invalid 'bus-range' and/or 'reg'\n",\r
      __FUNCTION__));\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
\r
  //\r
  // Iterate over "ranges".\r
  //\r
  Prop = fdt_getprop (DeviceTreeBase, Node, "ranges", &Len);\r
  if (Prop == NULL || Len == 0 ||\r
      Len % sizeof (DTB_PCI_HOST_RANGE_RECORD) != 0) {\r
    DEBUG ((EFI_D_ERROR, "%a: 'ranges' not found or invalid\n", __FUNCTION__));\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
\r
  //\r
  // IoBase, IoTranslation, MmioBase and MmioTranslation are initialized only\r
  // in order to suppress '-Werror=maybe-uninitialized' warnings *incorrectly*\r
  // emitted by some gcc versions.\r
  //\r
  IoBase = 0;\r
  IoTranslation = 0;\r
  MmioBase = 0;\r
  MmioTranslation = 0;\r
\r
  //\r
  // IoSize and MmioSize are initialized to zero because the logic below\r
  // requires it.\r
  //\r
  IoSize = 0;\r
  MmioSize = 0;\r
  for (RecordIdx = 0; RecordIdx < Len / sizeof (DTB_PCI_HOST_RANGE_RECORD);\r
       ++RecordIdx) {\r
    CONST DTB_PCI_HOST_RANGE_RECORD *Record;\r
\r
    Record = (CONST DTB_PCI_HOST_RANGE_RECORD *)Prop + RecordIdx;\r
    switch (fdt32_to_cpu (Record->Type) & DTB_PCI_HOST_RANGE_TYPEMASK) {\r
    case DTB_PCI_HOST_RANGE_IO:\r
      IoBase = fdt64_to_cpu (Record->ChildBase);\r
      IoSize = fdt64_to_cpu (Record->Size);\r
      IoTranslation = fdt64_to_cpu (Record->CpuBase) - IoBase;\r
      break;\r
\r
    case DTB_PCI_HOST_RANGE_MMIO32:\r
      MmioBase = fdt64_to_cpu (Record->ChildBase);\r
      MmioSize = fdt64_to_cpu (Record->Size);\r
      MmioTranslation = fdt64_to_cpu (Record->CpuBase) - MmioBase;\r
\r
      if (MmioBase > MAX_UINT32 || MmioSize > MAX_UINT32 ||\r
          MmioBase + MmioSize > SIZE_4GB) {\r
        DEBUG ((EFI_D_ERROR, "%a: MMIO32 space invalid\n", __FUNCTION__));\r
        return EFI_PROTOCOL_ERROR;\r
      }\r
\r
      if (MmioTranslation != 0) {\r
        DEBUG ((EFI_D_ERROR, "%a: unsupported nonzero MMIO32 translation "\r
          "0x%Lx\n", __FUNCTION__, MmioTranslation));\r
        return EFI_UNSUPPORTED;\r
      }\r
\r
      break;\r
    }\r
  }\r
  if (IoSize == 0 || MmioSize == 0) {\r
    DEBUG ((EFI_D_ERROR, "%a: %a space empty\n", __FUNCTION__,\r
      (IoSize == 0) ? "IO" : "MMIO32"));\r
    return EFI_PROTOCOL_ERROR;\r
  }\r
\r
  PcdSet64 (PcdPciExpressBaseAddress, ConfigBase);\r
\r
  PcdSet32 (PcdPciBusMin, BusMin);\r
  PcdSet32 (PcdPciBusMax, BusMax);\r
\r
  PcdSet64 (PcdPciIoBase,        IoBase);\r
  PcdSet64 (PcdPciIoSize,        IoSize);\r
  PcdSet64 (PcdPciIoTranslation, IoTranslation);\r
\r
  PcdSet32 (PcdPciMmio32Base, (UINT32)MmioBase);\r
  PcdSet32 (PcdPciMmio32Size, (UINT32)MmioSize);\r
\r
  PcdSetBool (PcdPciDisableBusEnumeration, FALSE);\r
\r
  DEBUG ((EFI_D_INFO, "%a: Config[0x%Lx+0x%Lx) Bus[0x%x..0x%x] "\r
    "Io[0x%Lx+0x%Lx)@0x%Lx Mem[0x%Lx+0x%Lx)@0x%Lx\n", __FUNCTION__, ConfigBase,\r
    ConfigSize, BusMin, BusMax, IoBase, IoSize, IoTranslation, MmioBase,\r
    MmioSize, MmioTranslation));\r
  return EFI_SUCCESS;\r
}\r
\r
\r
EFI_STATUS\r
EFIAPI\r
InitializeVirtFdtDxe (\r
  IN EFI_HANDLE           ImageHandle,\r
  IN EFI_SYSTEM_TABLE     *SystemTable\r
  )\r
{\r
  VOID                           *Hob;\r
  VOID                           *DeviceTreeBase;\r
  INT32                          Node, Prev;\r
  INT32                          RtcNode;\r
  EFI_STATUS                     Status;\r
  CONST CHAR8                    *Type;\r
  INT32                          Len;\r
  PROPERTY_TYPE                  PropType;\r
  CONST VOID                     *RegProp;\r
  VIRTIO_TRANSPORT_DEVICE_PATH   *DevicePath;\r
  EFI_HANDLE                     Handle;\r
  UINT64                         RegBase;\r
  BOOLEAN                        HavePci;\r
\r
  Hob = GetFirstGuidHob(&gFdtHobGuid);\r
  if (Hob == NULL || GET_GUID_HOB_DATA_SIZE (Hob) != sizeof (UINT64)) {\r
    return EFI_NOT_FOUND;\r
  }\r
  DeviceTreeBase = (VOID *)(UINTN)*(UINT64 *)GET_GUID_HOB_DATA (Hob);\r
\r
  if (fdt_check_header (DeviceTreeBase) != 0) {\r
    DEBUG ((EFI_D_ERROR, "%a: No DTB found @ 0x%p\n", __FUNCTION__, DeviceTreeBase));\r
    return EFI_NOT_FOUND;\r
  }\r
\r
  DEBUG ((EFI_D_INFO, "%a: DTB @ 0x%p\n", __FUNCTION__, DeviceTreeBase));\r
\r
  RtcNode = -1;\r
  HavePci = FALSE;\r
  //\r
  // Now enumerate the nodes and install peripherals that we are interested in,\r
  // i.e., GIC, RTC and virtio MMIO nodes\r
  //\r
  for (Prev = 0;; Prev = Node) {\r
    Node = fdt_next_node (DeviceTreeBase, Prev, NULL);\r
    if (Node < 0) {\r
      break;\r
    }\r
\r
    Type = fdt_getprop (DeviceTreeBase, Node, "compatible", &Len);\r
    if (Type == NULL) {\r
      continue;\r
    }\r
\r
    PropType = GetTypeFromNode (Type, Len);\r
    if (PropType == PropertyTypeUnknown) {\r
      continue;\r
    }\r
\r
    //\r
    // Get the 'reg' property of this node. For now, we will assume\r
    // 8 byte quantities for base and size, respectively.\r
    // TODO use #cells root properties instead\r
    //\r
    RegProp = fdt_getprop (DeviceTreeBase, Node, "reg", &Len);\r
    ASSERT (RegProp != NULL);\r
\r
    switch (PropType) {\r
    case PropertyTypePciHost:\r
      ASSERT (Len == 2 * sizeof (UINT64));\r
      Status = ProcessPciHost (DeviceTreeBase, Node, RegProp);\r
      ASSERT_EFI_ERROR (Status);\r
      HavePci = TRUE;\r
      break;\r
\r
    case PropertyTypeVirtio:\r
      ASSERT (Len == 16);\r
      //\r
      // Create a unique device path for this transport on the fly\r
      //\r
      RegBase = fdt64_to_cpu (((UINT64 *)RegProp)[0]);\r
      DevicePath = (VIRTIO_TRANSPORT_DEVICE_PATH *)CreateDeviceNode (\r
                                    HARDWARE_DEVICE_PATH,\r
                                    HW_VENDOR_DP,\r
                                    sizeof (VIRTIO_TRANSPORT_DEVICE_PATH));\r
      if (DevicePath == NULL) {\r
        DEBUG ((EFI_D_ERROR, "%a: Out of memory\n", __FUNCTION__));\r
        break;\r
      }\r
\r
      CopyMem (&DevicePath->Vendor.Guid, &gVirtioMmioTransportGuid,\r
        sizeof (EFI_GUID));\r
      DevicePath->PhysBase = RegBase;\r
      SetDevicePathNodeLength (&DevicePath->Vendor,\r
                               sizeof (*DevicePath) - sizeof (DevicePath->End));\r
      SetDevicePathEndNode (&DevicePath->End);\r
\r
      Handle = NULL;\r
      Status = gBS->InstallProtocolInterface (&Handle,\r
                     &gEfiDevicePathProtocolGuid, EFI_NATIVE_INTERFACE,\r
                     DevicePath);\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "%a: Failed to install the EFI_DEVICE_PATH "\r
          "protocol on a new handle (Status == %r)\n",\r
          __FUNCTION__, Status));\r
        FreePool (DevicePath);\r
        break;\r
      }\r
\r
      Status = VirtioMmioInstallDevice (RegBase, Handle);\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "%a: Failed to install VirtIO transport @ 0x%Lx "\r
          "on handle %p (Status == %r)\n", __FUNCTION__, RegBase,\r
          Handle, Status));\r
\r
        Status = gBS->UninstallProtocolInterface (Handle,\r
                        &gEfiDevicePathProtocolGuid, DevicePath);\r
        ASSERT_EFI_ERROR (Status);\r
        FreePool (DevicePath);\r
      }\r
      break;\r
\r
    case PropertyTypeRtc:\r
      ASSERT (Len == 16);\r
\r
      RegBase = fdt64_to_cpu (((UINT64 *)RegProp)[0]);\r
      ASSERT (RegBase < MAX_UINT32);\r
\r
      PcdSet32 (PcdPL031RtcBase, (UINT32)RegBase);\r
\r
      DEBUG ((EFI_D_INFO, "Found PL031 RTC @ 0x%Lx\n", RegBase));\r
      RtcNode = Node;\r
      break;\r
\r
    case PropertyTypeXen:\r
      ASSERT (Len == 16);\r
\r
      //\r
      // Retrieve the reg base from this node and wire it up to the\r
      // MMIO flavor of the XenBus root device I/O protocol\r
      //\r
      RegBase = fdt64_to_cpu (((UINT64 *)RegProp)[0]);\r
      Handle = NULL;\r
      Status = XenIoMmioInstall (&Handle, RegBase);\r
      if (EFI_ERROR (Status)) {\r
        DEBUG ((EFI_D_ERROR, "%a: XenIoMmioInstall () failed on a new handle "\r
          "(Status == %r)\n", __FUNCTION__, Status));\r
        break;\r
      }\r
\r
      DEBUG ((EFI_D_INFO, "Found Xen node with Grant table @ 0x%Lx\n", RegBase));\r
\r
      break;\r
\r
    default:\r
      break;\r
    }\r
  }\r
\r
  if (!FeaturePcdGet (PcdPureAcpiBoot)) {\r
    //\r
    // Only install the FDT as a configuration table if we want to leave it up\r
    // to the OS to decide whether it prefers ACPI over DT.\r
    //\r
    Status = gBS->InstallConfigurationTable (&gFdtTableGuid, DeviceTreeBase);\r
    ASSERT_EFI_ERROR (Status);\r
\r
    //\r
    // UEFI takes ownership of the RTC hardware, and exposes its functionality\r
    // through the UEFI Runtime Services GetTime, SetTime, etc. This means we\r
    // need to disable it in the device tree to prevent the OS from attaching its\r
    // device driver as well.\r
    //\r
    if ((RtcNode != -1) &&\r
        fdt_setprop_string (DeviceTreeBase, RtcNode, "status",\r
          "disabled") != 0) {\r
      DEBUG ((EFI_D_WARN, "Failed to set PL031 status to 'disabled'\n"));\r
    }\r
\r
    if (HavePci) {\r
      //\r
      // Set the /chosen/linux,pci-probe-only property to 1, so that the PCI\r
      // setup we will perform in the firmware is honored by the Linux OS,\r
      // rather than torn down and done from scratch. This is generally a more\r
      // sensible approach, and aligns with what ACPI based OSes do in general.\r
      //\r
      // In case we are exposing an emulated VGA PCI device to the guest, which\r
      // may subsequently get exposed via the Graphics Output protocol and\r
      // driven as an efifb by Linux, we need this setting to prevent the\r
      // framebuffer from becoming unresponsive.\r
      //\r
      Node = fdt_path_offset (DeviceTreeBase, "/chosen");\r
      if (Node < 0) {\r
        Node = fdt_add_subnode (DeviceTreeBase, 0, "/chosen");\r
      }\r
      if (Node < 0 ||\r
          fdt_setprop_u32 (DeviceTreeBase, Node, "linux,pci-probe-only", 1) < 0) {\r
        DEBUG ((EFI_D_WARN, "Failed to set /chosen/linux,pci-probe-only property\n"));\r
      }\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r