OvmfPkg: Apply uncrustify changes

[mirror_edk2.git] / OvmfPkg / Virtio10Dxe / Virtio10.c

/** @file\r
  A non-transitional driver for VirtIo 1.0 PCI devices.\r
\r
  Copyright (C) 2016, Red Hat, Inc.\r
  Copyright (C) 2017, AMD Inc, All rights reserved.<BR>\r
\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
**/\r
\r
#include <IndustryStandard/Pci.h>\r
#include <IndustryStandard/Virtio.h>\r
#include <Protocol/PciIo.h>\r
#include <Protocol/PciRootBridgeIo.h>\r
#include <Protocol/VirtioDevice.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/PciCapLib.h>\r
#include <Library/PciCapPciIoLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
#include <Library/UefiLib.h>\r
\r
#include "Virtio10.h"\r
\r
//\r
// Utility functions\r
//\r
\r
/**\r
  Transfer data between the caller and a register in a virtio-1.0 register\r
  block.\r
\r
  @param[in]     PciIo        The EFI_PCI_IO_PROTOCOL instance that represents\r
                              the device.\r
\r
  @param[in]     Config       The "fat pointer" structure that identifies the\r
                              register block to access.\r
\r
  @param[in]     Write        TRUE if the register should be written, FALSE if\r
                              the register should be read.\r
\r
  @param[in]     FieldOffset  The offset of the register within the register\r
                              block.\r
\r
  @param[in]     FieldSize    The size of the register within the register\r
                              block. Can be one of 1, 2, 4 and 8. Accesses to\r
                              8-byte registers are broken up into two 4-byte\r
                              accesses.\r
\r
  @param[in,out] Buffer       When Write is TRUE, the register is written with\r
                              data from Buffer. When Write is FALSE, the caller\r
                              receives the register value into Buffer.\r
\r
  @retval  EFI_SUCCESS            Register access successful.\r
\r
  @retval  EFI_INVALID_PARAMETER  The register block pointed-to by Config\r
                                  doesn't exist; or FieldOffset and FieldSize\r
                                  would overflow the register block; or\r
                                  FieldSize is invalid.\r
\r
  @return                         Error codes from\r
                                  EFI_PCI_IO_PROTOCOL.(Io|Mem).(Read|Write)\r
                                  member functions.\r
**/\r
STATIC\r
EFI_STATUS\r
Virtio10Transfer (\r
  IN     EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN     VIRTIO_1_0_CONFIG    *Config,\r
  IN     BOOLEAN              Write,\r
  IN     UINTN                FieldOffset,\r
  IN     UINTN                FieldSize,\r
  IN OUT VOID                 *Buffer\r
  )\r
{\r
  UINTN                       Count;\r
  EFI_PCI_IO_PROTOCOL_WIDTH   Width;\r
  EFI_PCI_IO_PROTOCOL_ACCESS  *BarType;\r
  EFI_PCI_IO_PROTOCOL_IO_MEM  Access;\r
\r
  if (!Config->Exists ||\r
      (FieldSize > Config->Length) ||\r
      (FieldOffset > Config->Length - FieldSize))\r
  {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Count = 1;\r
  switch (FieldSize) {\r
    case 1:\r
      Width = EfiPciIoWidthUint8;\r
      break;\r
\r
    case 2:\r
      Width = EfiPciIoWidthUint16;\r
      break;\r
\r
    case 8:\r
      Count = 2;\r
    //\r
    // fall through\r
    //\r
\r
    case 4:\r
      Width = EfiPciIoWidthUint32;\r
      break;\r
\r
    default:\r
      return EFI_INVALID_PARAMETER;\r
  }\r
\r
  BarType = (Config->BarType == Virtio10BarTypeMem) ? &PciIo->Mem : &PciIo->Io;\r
  Access  = Write ? BarType->Write : BarType->Read;\r
\r
  return Access (\r
           PciIo,\r
           Width,\r
           Config->Bar,\r
           Config->Offset + FieldOffset,\r
           Count,\r
           Buffer\r
           );\r
}\r
\r
/**\r
  Determine if a PCI BAR is IO or MMIO.\r
\r
  @param[in]  PciIo     The EFI_PCI_IO_PROTOCOL instance that represents the\r
                        device.\r
\r
  @param[in]  BarIndex  The number of the BAR whose type the caller is\r
                        interested in.\r
\r
  @param[out] BarType   On output, a VIRTIO_1_0_BAR_TYPE value that gives the\r
                        type of the BAR.\r
\r
  @retval EFI_SUCCESS      The BAR type has been recognized and stored in\r
                           BarType.\r
\r
  @retval EFI_UNSUPPORTED  The BAR type couldn't be identified.\r
\r
  @return                  Error codes from\r
                           EFI_PCI_IO_PROTOCOL.GetBarAttributes().\r
**/\r
STATIC\r
EFI_STATUS\r
GetBarType (\r
  IN  EFI_PCI_IO_PROTOCOL  *PciIo,\r
  IN  UINT8                BarIndex,\r
  OUT VIRTIO_1_0_BAR_TYPE  *BarType\r
  )\r
{\r
  EFI_STATUS  Status;\r
  VOID        *Resources;\r
\r
  Status = PciIo->GetBarAttributes (PciIo, BarIndex, NULL, &Resources);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = EFI_UNSUPPORTED;\r
\r
  if (*(UINT8 *)Resources == ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR) {\r
    EFI_ACPI_QWORD_ADDRESS_SPACE_DESCRIPTOR  *Descriptor;\r
\r
    Descriptor = Resources;\r
    switch (Descriptor->ResType) {\r
      case ACPI_ADDRESS_SPACE_TYPE_MEM:\r
        *BarType = Virtio10BarTypeMem;\r
        Status   = EFI_SUCCESS;\r
        break;\r
\r
      case ACPI_ADDRESS_SPACE_TYPE_IO:\r
        *BarType = Virtio10BarTypeIo;\r
        Status   = EFI_SUCCESS;\r
        break;\r
\r
      default:\r
        break;\r
    }\r
  }\r
\r
  FreePool (Resources);\r
  return Status;\r
}\r
\r
/*\r
  Traverse the PCI capabilities list of a virtio-1.0 device, and capture the\r
  locations of the interesting virtio-1.0 register blocks.\r
\r
  @param[in,out] Device         The VIRTIO_1_0_DEV structure that identifies\r
                                the device. On input, the caller is responsible\r
                                that the Device->PciIo member be live, and that\r
                                the CommonConfig, NotifyConfig,\r
                                NotifyOffsetMultiplier and SpecificConfig\r
                                members be zeroed. On output,  said members\r
                                will have been updated from the PCI\r
                                capabilities found.\r
\r
  @retval EFI_SUCCESS  Traversal successful.\r
\r
  @return              Error codes from PciCapPciIoLib, PciCapLib, and the\r
                       GetBarType() helper function.\r
*/\r
STATIC\r
EFI_STATUS\r
ParseCapabilities (\r
  IN OUT VIRTIO_1_0_DEV  *Device\r
  )\r
{\r
  EFI_STATUS    Status;\r
  PCI_CAP_DEV   *PciDevice;\r
  PCI_CAP_LIST  *CapList;\r
  UINT16        VendorInstance;\r
  PCI_CAP       *VendorCap;\r
\r
  Status = PciCapPciIoDeviceInit (Device->PciIo, &PciDevice);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = PciCapListInit (PciDevice, &CapList);\r
  if (EFI_ERROR (Status)) {\r
    goto UninitPciDevice;\r
  }\r
\r
  for (VendorInstance = 0;\r
       !EFI_ERROR (\r
          PciCapListFindCap (\r
            CapList,\r
            PciCapNormal,\r
            EFI_PCI_CAPABILITY_ID_VENDOR,\r
            VendorInstance,\r
            &VendorCap\r
            )\r
          );\r
       VendorInstance++)\r
  {\r
    UINT8              CapLen;\r
    VIRTIO_PCI_CAP     VirtIoCap;\r
    VIRTIO_1_0_CONFIG  *ParsedConfig;\r
\r
    //\r
    // Big enough to accommodate a VIRTIO_PCI_CAP structure?\r
    //\r
    Status = PciCapRead (\r
               PciDevice,\r
               VendorCap,\r
               OFFSET_OF (EFI_PCI_CAPABILITY_VENDOR_HDR, Length),\r
               &CapLen,\r
               sizeof CapLen\r
               );\r
    if (EFI_ERROR (Status)) {\r
      goto UninitCapList;\r
    }\r
\r
    if (CapLen < sizeof VirtIoCap) {\r
      //\r
      // Too small, move to next.\r
      //\r
      continue;\r
    }\r
\r
    //\r
    // Read interesting part of capability.\r
    //\r
    Status = PciCapRead (PciDevice, VendorCap, 0, &VirtIoCap, sizeof VirtIoCap);\r
    if (EFI_ERROR (Status)) {\r
      goto UninitCapList;\r
    }\r
\r
    switch (VirtIoCap.ConfigType) {\r
      case VIRTIO_PCI_CAP_COMMON_CFG:\r
        ParsedConfig = &Device->CommonConfig;\r
        break;\r
      case VIRTIO_PCI_CAP_NOTIFY_CFG:\r
        ParsedConfig = &Device->NotifyConfig;\r
        break;\r
      case VIRTIO_PCI_CAP_DEVICE_CFG:\r
        ParsedConfig = &Device->SpecificConfig;\r
        break;\r
      default:\r
        //\r
        // Capability is not interesting.\r
        //\r
        continue;\r
    }\r
\r
    //\r
    // Save the location of the register block into ParsedConfig.\r
    //\r
    Status = GetBarType (Device->PciIo, VirtIoCap.Bar, &ParsedConfig->BarType);\r
    if (EFI_ERROR (Status)) {\r
      goto UninitCapList;\r
    }\r
\r
    ParsedConfig->Bar    = VirtIoCap.Bar;\r
    ParsedConfig->Offset = VirtIoCap.Offset;\r
    ParsedConfig->Length = VirtIoCap.Length;\r
\r
    if (VirtIoCap.ConfigType == VIRTIO_PCI_CAP_NOTIFY_CFG) {\r
      //\r
      // This capability has an additional field called NotifyOffsetMultiplier;\r
      // parse it too.\r
      //\r
      if (CapLen < sizeof VirtIoCap + sizeof Device->NotifyOffsetMultiplier) {\r
        //\r
        // Too small, move to next.\r
        //\r
        continue;\r
      }\r
\r
      Status = PciCapRead (\r
                 PciDevice,\r
                 VendorCap,\r
                 sizeof VirtIoCap,\r
                 &Device->NotifyOffsetMultiplier,\r
                 sizeof Device->NotifyOffsetMultiplier\r
                 );\r
      if (EFI_ERROR (Status)) {\r
        goto UninitCapList;\r
      }\r
    }\r
\r
    //\r
    // Capability parsed successfully.\r
    //\r
    ParsedConfig->Exists = TRUE;\r
  }\r
\r
  ASSERT_EFI_ERROR (Status);\r
\r
UninitCapList:\r
  PciCapListUninit (CapList);\r
\r
UninitPciDevice:\r
  PciCapPciIoDeviceUninit (PciDevice);\r
\r
  return Status;\r
}\r
\r
/**\r
  Accumulate the BAR type of a virtio-1.0 register block into a UINT64\r
  attribute map, such that the latter is suitable for enabling IO / MMIO\r
  decoding with EFI_PCI_IO_PROTOCOL.Attributes().\r
\r
  @param[in]     Config      The "fat pointer" structure that identifies the\r
                             register block. It is allowed for the register\r
                             block not to exist.\r
\r
  @param[in,out] Attributes  On output, if the register block exists,\r
                             EFI_PCI_IO_ATTRIBUTE_MEMORY or\r
                             EFI_PCI_IO_ATTRIBUTE_IO is OR-ed into Attributes,\r
                             according to the register block's BAR type.\r
**/\r
STATIC\r
VOID\r
UpdateAttributes (\r
  IN     VIRTIO_1_0_CONFIG  *Config,\r
  IN OUT UINT64             *Attributes\r
  )\r
{\r
  if (Config->Exists) {\r
    *Attributes |= (Config->BarType == Virtio10BarTypeMem) ?\r
                   EFI_PCI_IO_ATTRIBUTE_MEMORY :\r
                   EFI_PCI_IO_ATTRIBUTE_IO;\r
  }\r
}\r
\r
//\r
// VIRTIO_DEVICE_PROTOCOL member functions\r
//\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10GetDeviceFeatures (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  OUT UINT64                 *DeviceFeatures\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  UINT32          Selector;\r
  UINT32          Features32[2];\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  for (Selector = 0; Selector < 2; ++Selector) {\r
    EFI_STATUS  Status;\r
\r
    //\r
    // Select the low or high half of the features.\r
    //\r
    Status = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceFeatureSelect),\r
               sizeof Selector,\r
               &Selector\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Fetch that half.\r
    //\r
    Status = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               FALSE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceFeature),\r
               sizeof Features32[Selector],\r
               &Features32[Selector]\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  *DeviceFeatures = LShiftU64 (Features32[1], 32) | Features32[0];\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetGuestFeatures (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT64                  Features\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  UINT32          Selector;\r
  UINT32          Features32[2];\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Features32[0] = (UINT32)Features;\r
  Features32[1] = (UINT32)RShiftU64 (Features, 32);\r
\r
  for (Selector = 0; Selector < 2; ++Selector) {\r
    EFI_STATUS  Status;\r
\r
    //\r
    // Select the low or high half of the features.\r
    //\r
    Status = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DriverFeatureSelect),\r
               sizeof Selector,\r
               &Selector\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
\r
    //\r
    // Write that half.\r
    //\r
    Status = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DriverFeature),\r
               sizeof Features32[Selector],\r
               &Features32[Selector]\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetQueueAddress (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN VRING                   *Ring,\r
  IN UINT64                  RingBaseShift\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
  UINT64          Address;\r
  UINT16          Enable;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Address  = (UINTN)Ring->Desc;\r
  Address += RingBaseShift;\r
  Status   = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueDesc),\r
               sizeof Address,\r
               &Address\r
               );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Address  = (UINTN)Ring->Avail.Flags;\r
  Address += RingBaseShift;\r
  Status   = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueAvail),\r
               sizeof Address,\r
               &Address\r
               );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Address  = (UINTN)Ring->Used.Flags;\r
  Address += RingBaseShift;\r
  Status   = Virtio10Transfer (\r
               Dev->PciIo,\r
               &Dev->CommonConfig,\r
               TRUE,\r
               OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueUsed),\r
               sizeof Address,\r
               &Address\r
               );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Enable = 1;\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             TRUE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueEnable),\r
             sizeof Enable,\r
             &Enable\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetQueueSel (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT16                  Index\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             TRUE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),\r
             sizeof Index,\r
             &Index\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetQueueNotify (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT16                  Index\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
  UINT16          SavedQueueSelect;\r
  UINT16          NotifyOffset;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  //\r
  // Read NotifyOffset first. NotifyOffset is queue specific, so we have\r
  // to stash & restore the current queue selector around it.\r
  //\r
  // So, start with saving the current queue selector.\r
  //\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             FALSE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),\r
             sizeof SavedQueueSelect,\r
             &SavedQueueSelect\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Select the requested queue.\r
  //\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             TRUE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),\r
             sizeof Index,\r
             &Index\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Read the QueueNotifyOff field.\r
  //\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             FALSE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueNotifyOff),\r
             sizeof NotifyOffset,\r
             &NotifyOffset\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Re-select the original queue.\r
  //\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             TRUE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSelect),\r
             sizeof SavedQueueSelect,\r
             &SavedQueueSelect\r
             );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // We can now kick the queue.\r
  //\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->NotifyConfig,\r
             TRUE,\r
             NotifyOffset * Dev->NotifyOffsetMultiplier,\r
             sizeof Index,\r
             &Index\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetQueueAlign (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT32                  Alignment\r
  )\r
{\r
  return (Alignment == EFI_PAGE_SIZE) ? EFI_SUCCESS : EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetPageSize (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT32                  PageSize\r
  )\r
{\r
  return (PageSize == EFI_PAGE_SIZE) ? EFI_SUCCESS : EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10GetQueueNumMax (\r
  IN  VIRTIO_DEVICE_PROTOCOL  *This,\r
  OUT UINT16                  *QueueNumMax\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             FALSE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, QueueSize),\r
             sizeof *QueueNumMax,\r
             QueueNumMax\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetQueueNum (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT16                  QueueSize\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT16      CurrentSize;\r
\r
  //\r
  // This member function is required for VirtIo MMIO, and a no-op in\r
  // VirtIo PCI 0.9.5. In VirtIo 1.0, drivers can theoretically use this\r
  // member to reduce memory consumption, but none of our drivers do. So\r
  // just check that they set the size that is already in effect.\r
  //\r
  Status = Virtio10GetQueueNumMax (This, &CurrentSize);\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  return (CurrentSize == QueueSize) ? EFI_SUCCESS : EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10GetDeviceStatus (\r
  IN  VIRTIO_DEVICE_PROTOCOL  *This,\r
  OUT UINT8                   *DeviceStatus\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             FALSE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceStatus),\r
             sizeof *DeviceStatus,\r
             DeviceStatus\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10SetDeviceStatus (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINT8                   DeviceStatus\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->CommonConfig,\r
             TRUE,\r
             OFFSET_OF (VIRTIO_PCI_COMMON_CFG, DeviceStatus),\r
             sizeof DeviceStatus,\r
             &DeviceStatus\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10WriteDevice (\r
  IN VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN UINTN                   FieldOffset,\r
  IN UINTN                   FieldSize,\r
  IN UINT64                  Value\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->SpecificConfig,\r
             TRUE,\r
             FieldOffset,\r
             FieldSize,\r
             &Value\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10ReadDevice (\r
  IN  VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN  UINTN                   FieldOffset,\r
  IN  UINTN                   FieldSize,\r
  IN  UINTN                   BufferSize,\r
  OUT VOID                    *Buffer\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  if (FieldSize != BufferSize) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Virtio10Transfer (\r
             Dev->PciIo,\r
             &Dev->SpecificConfig,\r
             FALSE,\r
             FieldOffset,\r
             FieldSize,\r
             Buffer\r
             );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10AllocateSharedPages (\r
  IN     VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN     UINTN                   Pages,\r
  IN OUT VOID                    **HostAddress\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
  EFI_STATUS      Status;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Dev->PciIo->AllocateBuffer (\r
                         Dev->PciIo,\r
                         AllocateAnyPages,\r
                         EfiBootServicesData,\r
                         Pages,\r
                         HostAddress,\r
                         EFI_PCI_ATTRIBUTE_MEMORY_CACHED\r
                         );\r
  return Status;\r
}\r
\r
STATIC\r
VOID\r
EFIAPI\r
Virtio10FreeSharedPages (\r
  IN  VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN  UINTN                   Pages,\r
  IN  VOID                    *HostAddress\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Dev;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Dev->PciIo->FreeBuffer (\r
                Dev->PciIo,\r
                Pages,\r
                HostAddress\r
                );\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10MapSharedBuffer (\r
  IN     VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN     VIRTIO_MAP_OPERATION    Operation,\r
  IN     VOID                    *HostAddress,\r
  IN OUT UINTN                   *NumberOfBytes,\r
  OUT    EFI_PHYSICAL_ADDRESS    *DeviceAddress,\r
  OUT    VOID                    **Mapping\r
  )\r
{\r
  EFI_STATUS                     Status;\r
  VIRTIO_1_0_DEV                 *Dev;\r
  EFI_PCI_IO_PROTOCOL_OPERATION  PciIoOperation;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  //\r
  // Map VIRTIO_MAP_OPERATION to EFI_PCI_IO_PROTOCOL_OPERATION\r
  //\r
  switch (Operation) {\r
    case VirtioOperationBusMasterRead:\r
      PciIoOperation = EfiPciIoOperationBusMasterRead;\r
      break;\r
    case VirtioOperationBusMasterWrite:\r
      PciIoOperation = EfiPciIoOperationBusMasterWrite;\r
      break;\r
    case VirtioOperationBusMasterCommonBuffer:\r
      PciIoOperation = EfiPciIoOperationBusMasterCommonBuffer;\r
      break;\r
    default:\r
      return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Status = Dev->PciIo->Map (\r
                         Dev->PciIo,\r
                         PciIoOperation,\r
                         HostAddress,\r
                         NumberOfBytes,\r
                         DeviceAddress,\r
                         Mapping\r
                         );\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10UnmapSharedBuffer (\r
  IN  VIRTIO_DEVICE_PROTOCOL  *This,\r
  IN  VOID                    *Mapping\r
  )\r
{\r
  EFI_STATUS      Status;\r
  VIRTIO_1_0_DEV  *Dev;\r
\r
  Dev = VIRTIO_1_0_FROM_VIRTIO_DEVICE (This);\r
\r
  Status = Dev->PciIo->Unmap (\r
                         Dev->PciIo,\r
                         Mapping\r
                         );\r
\r
  return Status;\r
}\r
\r
STATIC CONST VIRTIO_DEVICE_PROTOCOL  mVirtIoTemplate = {\r
  VIRTIO_SPEC_REVISION (1,     0, 0),\r
  0,                           // SubSystemDeviceId, filled in dynamically\r
  Virtio10GetDeviceFeatures,\r
  Virtio10SetGuestFeatures,\r
  Virtio10SetQueueAddress,\r
  Virtio10SetQueueSel,\r
  Virtio10SetQueueNotify,\r
  Virtio10SetQueueAlign,\r
  Virtio10SetPageSize,\r
  Virtio10GetQueueNumMax,\r
  Virtio10SetQueueNum,\r
  Virtio10GetDeviceStatus,\r
  Virtio10SetDeviceStatus,\r
  Virtio10WriteDevice,\r
  Virtio10ReadDevice,\r
  Virtio10AllocateSharedPages,\r
  Virtio10FreeSharedPages,\r
  Virtio10MapSharedBuffer,\r
  Virtio10UnmapSharedBuffer\r
};\r
\r
//\r
// EFI_DRIVER_BINDING_PROTOCOL member functions\r
//\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10BindingSupported (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   DeviceHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  EFI_STATUS           Status;\r
  EFI_PCI_IO_PROTOCOL  *PciIo;\r
  PCI_TYPE00           Pci;\r
\r
  Status = gBS->OpenProtocol (\r
                  DeviceHandle,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&PciIo,\r
                  This->DriverBindingHandle,\r
                  DeviceHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Status = PciIo->Pci.Read (\r
                        PciIo,\r
                        EfiPciIoWidthUint32,\r
                        0,\r
                        sizeof Pci / sizeof (UINT32),\r
                        &Pci\r
                        );\r
  if (EFI_ERROR (Status)) {\r
    goto CloseProtocol;\r
  }\r
\r
  Status = EFI_UNSUPPORTED;\r
  //\r
  // Recognize non-transitional modern devices. Also, we'll have to parse the\r
  // PCI capability list, so make sure the CapabilityPtr field will be valid.\r
  //\r
  if ((Pci.Hdr.VendorId == VIRTIO_VENDOR_ID) &&\r
      (Pci.Hdr.DeviceId >= 0x1040) &&\r
      (Pci.Hdr.DeviceId <= 0x107F) &&\r
      (Pci.Hdr.RevisionID >= 0x01) &&\r
      (Pci.Device.SubsystemID >= 0x40) &&\r
      ((Pci.Hdr.Status & EFI_PCI_STATUS_CAPABILITY) != 0))\r
  {\r
    //\r
    // The virtio-vga device is special. It can be driven both as a VGA device\r
    // with a linear framebuffer, and through its underlying, modern,\r
    // virtio-gpu-pci device, which has no linear framebuffer itself. For\r
    // compatibility with guest OSes that insist on inheriting a linear\r
    // framebuffer from the firmware, we should leave virtio-vga to\r
    // QemuVideoDxe, and support only virtio-gpu-pci here.\r
    //\r
    // Both virtio-vga and virtio-gpu-pci have DeviceId 0x1050, but only the\r
    // former has device class PCI_CLASS_DISPLAY_VGA.\r
    //\r
    if ((Pci.Hdr.DeviceId != 0x1050) || !IS_PCI_VGA (&Pci)) {\r
      Status = EFI_SUCCESS;\r
    }\r
  }\r
\r
CloseProtocol:\r
  gBS->CloseProtocol (\r
         DeviceHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         DeviceHandle\r
         );\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10BindingStart (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   DeviceHandle,\r
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath\r
  )\r
{\r
  VIRTIO_1_0_DEV  *Device;\r
  EFI_STATUS      Status;\r
  PCI_TYPE00      Pci;\r
  UINT64          SetAttributes;\r
\r
  Device = AllocateZeroPool (sizeof *Device);\r
  if (Device == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Device->Signature = VIRTIO_1_0_SIGNATURE;\r
  CopyMem (&Device->VirtIo, &mVirtIoTemplate, sizeof mVirtIoTemplate);\r
\r
  Status = gBS->OpenProtocol (\r
                  DeviceHandle,\r
                  &gEfiPciIoProtocolGuid,\r
                  (VOID **)&Device->PciIo,\r
                  This->DriverBindingHandle,\r
                  DeviceHandle,\r
                  EFI_OPEN_PROTOCOL_BY_DRIVER\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto FreeDevice;\r
  }\r
\r
  Status = Device->PciIo->Pci.Read (\r
                                Device->PciIo,\r
                                EfiPciIoWidthUint32,\r
                                0,\r
                                sizeof Pci / sizeof (UINT32),\r
                                &Pci\r
                                );\r
  if (EFI_ERROR (Status)) {\r
    goto ClosePciIo;\r
  }\r
\r
  Device->VirtIo.SubSystemDeviceId = Pci.Hdr.DeviceId - 0x1040;\r
\r
  Status = ParseCapabilities (Device);\r
  if (EFI_ERROR (Status)) {\r
    goto ClosePciIo;\r
  }\r
\r
  Status = Device->PciIo->Attributes (\r
                            Device->PciIo,\r
                            EfiPciIoAttributeOperationGet,\r
                            0,\r
                            &Device->OriginalPciAttributes\r
                            );\r
  if (EFI_ERROR (Status)) {\r
    goto ClosePciIo;\r
  }\r
\r
  SetAttributes = (EFI_PCI_IO_ATTRIBUTE_BUS_MASTER |\r
                   EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE);\r
  UpdateAttributes (&Device->CommonConfig, &SetAttributes);\r
  UpdateAttributes (&Device->NotifyConfig, &SetAttributes);\r
  UpdateAttributes (&Device->SpecificConfig, &SetAttributes);\r
  Status = Device->PciIo->Attributes (\r
                            Device->PciIo,\r
                            EfiPciIoAttributeOperationEnable,\r
                            SetAttributes,\r
                            NULL\r
                            );\r
  if (EFI_ERROR (Status)) {\r
    goto ClosePciIo;\r
  }\r
\r
  Status = gBS->InstallProtocolInterface (\r
                  &DeviceHandle,\r
                  &gVirtioDeviceProtocolGuid,\r
                  EFI_NATIVE_INTERFACE,\r
                  &Device->VirtIo\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    goto RestorePciAttributes;\r
  }\r
\r
  return EFI_SUCCESS;\r
\r
RestorePciAttributes:\r
  Device->PciIo->Attributes (\r
                   Device->PciIo,\r
                   EfiPciIoAttributeOperationSet,\r
                   Device->OriginalPciAttributes,\r
                   NULL\r
                   );\r
\r
ClosePciIo:\r
  gBS->CloseProtocol (\r
         DeviceHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         DeviceHandle\r
         );\r
\r
FreeDevice:\r
  FreePool (Device);\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10BindingStop (\r
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,\r
  IN EFI_HANDLE                   DeviceHandle,\r
  IN UINTN                        NumberOfChildren,\r
  IN EFI_HANDLE                   *ChildHandleBuffer\r
  )\r
{\r
  EFI_STATUS              Status;\r
  VIRTIO_DEVICE_PROTOCOL  *VirtIo;\r
  VIRTIO_1_0_DEV          *Device;\r
\r
  Status = gBS->OpenProtocol (\r
                  DeviceHandle,\r
                  &gVirtioDeviceProtocolGuid,\r
                  (VOID **)&VirtIo,\r
                  This->DriverBindingHandle,\r
                  DeviceHandle,\r
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Device = VIRTIO_1_0_FROM_VIRTIO_DEVICE (VirtIo);\r
\r
  Status = gBS->UninstallProtocolInterface (\r
                  DeviceHandle,\r
                  &gVirtioDeviceProtocolGuid,\r
                  &Device->VirtIo\r
                  );\r
  if (EFI_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  Device->PciIo->Attributes (\r
                   Device->PciIo,\r
                   EfiPciIoAttributeOperationSet,\r
                   Device->OriginalPciAttributes,\r
                   NULL\r
                   );\r
  gBS->CloseProtocol (\r
         DeviceHandle,\r
         &gEfiPciIoProtocolGuid,\r
         This->DriverBindingHandle,\r
         DeviceHandle\r
         );\r
  FreePool (Device);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC EFI_DRIVER_BINDING_PROTOCOL  mDriverBinding = {\r
  &Virtio10BindingSupported,\r
  &Virtio10BindingStart,\r
  &Virtio10BindingStop,\r
  0x10, // Version\r
  NULL, // ImageHandle, to be overwritten\r
  NULL  // DriverBindingHandle, to be overwritten\r
};\r
\r
//\r
// EFI_COMPONENT_NAME_PROTOCOL and EFI_COMPONENT_NAME2_PROTOCOL\r
// implementations\r
//\r
\r
STATIC\r
EFI_UNICODE_STRING_TABLE  mDriverNameTable[] = {\r
  { "eng;en", L"Virtio 1.0 PCI Driver" },\r
  { NULL,     NULL                     }\r
};\r
\r
STATIC\r
EFI_COMPONENT_NAME_PROTOCOL  mComponentName;\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10GetDriverName (\r
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,\r
  IN  CHAR8                        *Language,\r
  OUT CHAR16                       **DriverName\r
  )\r
{\r
  return LookupUnicodeString2 (\r
           Language,\r
           This->SupportedLanguages,\r
           mDriverNameTable,\r
           DriverName,\r
           (BOOLEAN)(This == &mComponentName) // Iso639Language\r
           );\r
}\r
\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
Virtio10GetDeviceName (\r
  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,\r
  IN  EFI_HANDLE                   DeviceHandle,\r
  IN  EFI_HANDLE                   ChildHandle,\r
  IN  CHAR8                        *Language,\r
  OUT CHAR16                       **ControllerName\r
  )\r
{\r
  return EFI_UNSUPPORTED;\r
}\r
\r
STATIC\r
EFI_COMPONENT_NAME_PROTOCOL  mComponentName = {\r
  &Virtio10GetDriverName,\r
  &Virtio10GetDeviceName,\r
  "eng"\r
};\r
\r
STATIC\r
EFI_COMPONENT_NAME2_PROTOCOL  mComponentName2 = {\r
  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME)&Virtio10GetDriverName,\r
  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME)&Virtio10GetDeviceName,\r
  "en"\r
};\r
\r
//\r
// Entry point of this driver\r
//\r
\r
EFI_STATUS\r
EFIAPI\r
Virtio10EntryPoint (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  return EfiLibInstallDriverBindingComponentName2 (\r
           ImageHandle,\r
           SystemTable,\r
           &mDriverBinding,\r
           ImageHandle,\r
           &mComponentName,\r
           &mComponentName2\r
           );\r
}\r