a980324709
PciHotPlugInitDxe has a static variable called "mPadding" (of type RESOURCE_PADDING), which describes two constant resource reservations: - MmioPadding: 2MB of non-prefetchable (hence 32-bit) MMIO space, - IoPadding: 512B of IO space. In the GetResourcePadding() member function of EFI_PCI_HOT_PLUG_INIT_PROTOCOL, the driver outputs a dynamically allocated verbatim copy of "mPadding", for PciBusDxe to consume in its ApplyResourcePadding() function. In a later patch, we're going to compose the set of resource reservations dynamically, based on QEMU hints. Generalize the RESOURCE_PADDING structure so that we may generate (or not generate) each resource type individually: - Replace the named "MmioPadding" and "IoPadding" fields in RESOURCE_PADDING with an array of descriptors, - remove "mPadding", - in GetResourcePadding(), request the same (default) reservations as before, as if we attempted and failed to fetch the QEMU hints. Cc: Jordan Justen <jordan.l.justen@intel.com> Cc: Marcel Apfelbaum <marcel@redhat.com> Cc: Ruiyu Ni <ruiyu.ni@intel.com> Contributed-under: TianoCore Contribution Agreement 1.1 Signed-off-by: Laszlo Ersek <lersek@redhat.com> Reviewed-by: Jordan Justen <jordan.l.justen@intel.com>
376 lines
13 KiB
C
376 lines
13 KiB
C
/** @file
|
|
This driver implements EFI_PCI_HOT_PLUG_INIT_PROTOCOL, providing the PCI bus
|
|
driver with resource padding information, for PCIe hotplug purposes.
|
|
|
|
Copyright (C) 2016, Red Hat, Inc.
|
|
|
|
This program and the accompanying materials are licensed and made available
|
|
under the terms and conditions of the BSD License which accompanies this
|
|
distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
|
|
WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
**/
|
|
|
|
#include <IndustryStandard/Acpi10.h>
|
|
|
|
#include <Library/BaseMemoryLib.h>
|
|
#include <Library/DebugLib.h>
|
|
#include <Library/DevicePathLib.h>
|
|
#include <Library/MemoryAllocationLib.h>
|
|
#include <Library/UefiBootServicesTableLib.h>
|
|
|
|
#include <Protocol/PciHotPlugInit.h>
|
|
#include <Protocol/PciRootBridgeIo.h>
|
|
|
|
//
|
|
// The protocol interface this driver produces.
|
|
//
|
|
// Refer to 12.6 "PCI Hot Plug PCI Initialization Protocol" in the Platform
|
|
// Init 1.4a Spec, Volume 5.
|
|
//
|
|
STATIC EFI_PCI_HOT_PLUG_INIT_PROTOCOL mPciHotPlugInit;
|
|
|
|
|
|
//
|
|
// Resource padding template for the GetResourcePadding() protocol member
|
|
// function.
|
|
//
|
|
// Refer to Table 8 "ACPI 2.0 & 3.0 QWORD Address Space Descriptor Usage" in
|
|
// the Platform Init 1.4a Spec, Volume 5.
|
|
//
|
|
// This structure is interpreted by the ApplyResourcePadding() function in the
|
|
// edk2 PCI Bus UEFI_DRIVER.
|
|
//
|
|
// We can request padding for at most four resource types, each of which is
|
|
// optional, independently of the others:
|
|
// (a) bus numbers,
|
|
// (b) IO space,
|
|
// (c) non-prefetchable MMIO space (32-bit only),
|
|
// (d) prefetchable MMIO space (either 32-bit or 64-bit, never both).
|
|
//
|
|
#pragma pack (1)
|
|
typedef struct {
|
|
EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR Padding[4];
|
|
EFI_ACPI_END_TAG_DESCRIPTOR EndDesc;
|
|
} RESOURCE_PADDING;
|
|
#pragma pack ()
|
|
|
|
|
|
/**
|
|
Initialize a RESOURCE_PADDING object.
|
|
|
|
@param[out] ResourcePadding The caller-allocated RESOURCE_PADDING object to
|
|
initialize.
|
|
**/
|
|
STATIC
|
|
VOID
|
|
InitializeResourcePadding (
|
|
OUT RESOURCE_PADDING *ResourcePadding
|
|
)
|
|
{
|
|
UINTN Index;
|
|
|
|
ZeroMem (ResourcePadding, sizeof *ResourcePadding);
|
|
|
|
//
|
|
// Fill in the Padding fields that don't vary across resource types.
|
|
//
|
|
for (Index = 0; Index < ARRAY_SIZE (ResourcePadding->Padding); ++Index) {
|
|
EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Descriptor;
|
|
|
|
Descriptor = ResourcePadding->Padding + Index;
|
|
Descriptor->Desc = ACPI_ADDRESS_SPACE_DESCRIPTOR;
|
|
Descriptor->Len = (UINT16)(
|
|
sizeof (EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR) -
|
|
OFFSET_OF (
|
|
EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR,
|
|
ResType
|
|
)
|
|
);
|
|
}
|
|
|
|
//
|
|
// Fill in the End Tag.
|
|
//
|
|
ResourcePadding->EndDesc.Desc = ACPI_END_TAG_DESCRIPTOR;
|
|
}
|
|
|
|
|
|
/**
|
|
Returns a list of root Hot Plug Controllers (HPCs) that require
|
|
initialization during the boot process.
|
|
|
|
This procedure returns a list of root HPCs. The PCI bus driver must
|
|
initialize these controllers during the boot process. The PCI bus driver may
|
|
or may not be able to detect these HPCs. If the platform includes a
|
|
PCI-to-CardBus bridge, it can be included in this list if it requires
|
|
initialization. The HpcList must be self consistent. An HPC cannot control
|
|
any of its parent buses. Only one HPC can control a PCI bus. Because this
|
|
list includes only root HPCs, no HPC in the list can be a child of another
|
|
HPC. This policy must be enforced by the EFI_PCI_HOT_PLUG_INIT_PROTOCOL.
|
|
The PCI bus driver may not check for such invalid conditions. The callee
|
|
allocates the buffer HpcList
|
|
|
|
@param[in] This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
|
|
instance.
|
|
@param[out] HpcCount The number of root HPCs that were returned.
|
|
@param[out] HpcList The list of root HPCs. HpcCount defines the number of
|
|
elements in this list.
|
|
|
|
@retval EFI_SUCCESS HpcList was returned.
|
|
@retval EFI_OUT_OF_RESOURCES HpcList was not returned due to insufficient
|
|
resources.
|
|
@retval EFI_INVALID_PARAMETER HpcCount is NULL or HpcList is NULL.
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
GetRootHpcList (
|
|
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
|
|
OUT UINTN *HpcCount,
|
|
OUT EFI_HPC_LOCATION **HpcList
|
|
)
|
|
{
|
|
if (HpcCount == NULL || HpcList == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
//
|
|
// There are no top-level (i.e., un-enumerable) hot-plug controllers in QEMU
|
|
// that would require special initialization.
|
|
//
|
|
*HpcCount = 0;
|
|
*HpcList = NULL;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Initializes one root Hot Plug Controller (HPC). This process may causes
|
|
initialization of its subordinate buses.
|
|
|
|
This function initializes the specified HPC. At the end of initialization,
|
|
the hot-plug slots or sockets (controlled by this HPC) are powered and are
|
|
connected to the bus. All the necessary registers in the HPC are set up. For
|
|
a Standard (PCI) Hot Plug Controller (SHPC), the registers that must be set
|
|
up are defined in the PCI Standard Hot Plug Controller and Subsystem
|
|
Specification.
|
|
|
|
@param[in] This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
|
|
instance.
|
|
@param[in] HpcDevicePath The device path to the HPC that is being
|
|
initialized.
|
|
@param[in] HpcPciAddress The address of the HPC function on the PCI bus.
|
|
@param[in] Event The event that should be signaled when the HPC
|
|
initialization is complete. Set to NULL if the
|
|
caller wants to wait until the entire
|
|
initialization process is complete.
|
|
@param[out] HpcState The state of the HPC hardware. The state is
|
|
EFI_HPC_STATE_INITIALIZED or
|
|
EFI_HPC_STATE_ENABLED.
|
|
|
|
@retval EFI_SUCCESS If Event is NULL, the specific HPC was
|
|
successfully initialized. If Event is not
|
|
NULL, Event will be signaled at a later time
|
|
when initialization is complete.
|
|
@retval EFI_UNSUPPORTED This instance of
|
|
EFI_PCI_HOT_PLUG_INIT_PROTOCOL does not
|
|
support the specified HPC.
|
|
@retval EFI_OUT_OF_RESOURCES Initialization failed due to insufficient
|
|
resources.
|
|
@retval EFI_INVALID_PARAMETER HpcState is NULL.
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
InitializeRootHpc (
|
|
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *HpcDevicePath,
|
|
IN UINT64 HpcPciAddress,
|
|
IN EFI_EVENT Event, OPTIONAL
|
|
OUT EFI_HPC_STATE *HpcState
|
|
)
|
|
{
|
|
//
|
|
// This function should never be called, due to the information returned by
|
|
// GetRootHpcList().
|
|
//
|
|
ASSERT (FALSE);
|
|
|
|
if (HpcState == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
|
|
/**
|
|
Returns the resource padding that is required by the PCI bus that is
|
|
controlled by the specified Hot Plug Controller (HPC).
|
|
|
|
This function returns the resource padding that is required by the PCI bus
|
|
that is controlled by the specified HPC. This member function is called for
|
|
all the root HPCs and nonroot HPCs that are detected by the PCI bus
|
|
enumerator. This function will be called before PCI resource allocation is
|
|
completed. This function must be called after all the root HPCs, with the
|
|
possible exception of a PCI-to-CardBus bridge, have completed
|
|
initialization.
|
|
|
|
@param[in] This Pointer to the EFI_PCI_HOT_PLUG_INIT_PROTOCOL
|
|
instance.
|
|
@param[in] HpcDevicePath The device path to the HPC.
|
|
@param[in] HpcPciAddress The address of the HPC function on the PCI bus.
|
|
@param[in] HpcState The state of the HPC hardware.
|
|
@param[out] Padding The amount of resource padding that is required
|
|
by the PCI bus under the control of the specified
|
|
HPC.
|
|
@param[out] Attributes Describes how padding is accounted for. The
|
|
padding is returned in the form of ACPI 2.0
|
|
resource descriptors.
|
|
|
|
@retval EFI_SUCCESS The resource padding was successfully
|
|
returned.
|
|
@retval EFI_UNSUPPORTED This instance of the
|
|
EFI_PCI_HOT_PLUG_INIT_PROTOCOL does not
|
|
support the specified HPC.
|
|
@retval EFI_NOT_READY This function was called before HPC
|
|
initialization is complete.
|
|
@retval EFI_INVALID_PARAMETER HpcState or Padding or Attributes is NULL.
|
|
@retval EFI_OUT_OF_RESOURCES ACPI 2.0 resource descriptors for Padding
|
|
cannot be allocated due to insufficient
|
|
resources.
|
|
**/
|
|
STATIC
|
|
EFI_STATUS
|
|
EFIAPI
|
|
GetResourcePadding (
|
|
IN EFI_PCI_HOT_PLUG_INIT_PROTOCOL *This,
|
|
IN EFI_DEVICE_PATH_PROTOCOL *HpcDevicePath,
|
|
IN UINT64 HpcPciAddress,
|
|
OUT EFI_HPC_STATE *HpcState,
|
|
OUT VOID **Padding,
|
|
OUT EFI_HPC_PADDING_ATTRIBUTES *Attributes
|
|
)
|
|
{
|
|
BOOLEAN DefaultIo;
|
|
BOOLEAN DefaultMmio;
|
|
RESOURCE_PADDING ReservationRequest;
|
|
EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *FirstResource;
|
|
|
|
DEBUG_CODE (
|
|
EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS *Address;
|
|
CHAR16 *DevicePathString;
|
|
|
|
Address = (EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_PCI_ADDRESS *)&HpcPciAddress;
|
|
DevicePathString = ConvertDevicePathToText (HpcDevicePath, FALSE, FALSE);
|
|
|
|
DEBUG ((EFI_D_VERBOSE, "%a: Address=%02x:%02x.%x DevicePath=%s\n",
|
|
__FUNCTION__, Address->Bus, Address->Device, Address->Function,
|
|
(DevicePathString == NULL) ? L"<unavailable>" : DevicePathString));
|
|
|
|
if (DevicePathString != NULL) {
|
|
FreePool (DevicePathString);
|
|
}
|
|
);
|
|
|
|
if (HpcState == NULL || Padding == NULL || Attributes == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
DefaultIo = TRUE;
|
|
DefaultMmio = TRUE;
|
|
|
|
//
|
|
// Init ReservationRequest, and point FirstResource one past the last
|
|
// descriptor entry. We're going to build the entries backwards from
|
|
// ReservationRequest.EndDesc.
|
|
//
|
|
InitializeResourcePadding (&ReservationRequest);
|
|
FirstResource = ReservationRequest.Padding +
|
|
ARRAY_SIZE (ReservationRequest.Padding);
|
|
|
|
//
|
|
// (b) Reserve IO space.
|
|
//
|
|
if (DefaultIo) {
|
|
//
|
|
// Request defaults.
|
|
//
|
|
--FirstResource;
|
|
FirstResource->ResType = ACPI_ADDRESS_SPACE_TYPE_IO;
|
|
FirstResource->AddrRangeMax = 512 - 1; // align at 512 IO ports
|
|
FirstResource->AddrLen = 512; // 512 IO ports
|
|
}
|
|
|
|
//
|
|
// (c) Reserve non-prefetchable MMIO space (32-bit only).
|
|
//
|
|
if (DefaultMmio) {
|
|
//
|
|
// Request defaults.
|
|
//
|
|
--FirstResource;
|
|
FirstResource->ResType = ACPI_ADDRESS_SPACE_TYPE_MEM;
|
|
FirstResource->SpecificFlag = 0; // non-prefetchable
|
|
FirstResource->AddrSpaceGranularity = 32; // 32-bit aperture
|
|
FirstResource->AddrRangeMax = SIZE_2MB - 1; // align at 2MB
|
|
FirstResource->AddrLen = SIZE_2MB; // 2MB padding
|
|
}
|
|
|
|
//
|
|
// Output a copy of ReservationRequest from the lowest-address populated
|
|
// entry until the end of the structure (including
|
|
// ReservationRequest.EndDesc). If no reservations are necessary, we'll only
|
|
// output the End Tag.
|
|
//
|
|
*Padding = AllocateCopyPool (
|
|
(UINT8 *)(&ReservationRequest + 1) - (UINT8 *)FirstResource,
|
|
FirstResource
|
|
);
|
|
if (*Padding == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Resource padding is required.
|
|
//
|
|
*HpcState = EFI_HPC_STATE_INITIALIZED | EFI_HPC_STATE_ENABLED;
|
|
|
|
//
|
|
// The padding should be applied at PCI bus level, and considered by upstream
|
|
// bridges, recursively.
|
|
//
|
|
*Attributes = EfiPaddingPciBus;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Entry point for this driver.
|
|
|
|
@param[in] ImageHandle Image handle of this driver.
|
|
@param[in] SystemTable Pointer to SystemTable.
|
|
|
|
@retval EFI_SUCESS Driver has loaded successfully.
|
|
@return Error codes from lower level functions.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
DriverInitialize (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN EFI_SYSTEM_TABLE *SystemTable
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
|
|
mPciHotPlugInit.GetRootHpcList = GetRootHpcList;
|
|
mPciHotPlugInit.InitializeRootHpc = InitializeRootHpc;
|
|
mPciHotPlugInit.GetResourcePadding = GetResourcePadding;
|
|
Status = gBS->InstallMultipleProtocolInterfaces (&ImageHandle,
|
|
&gEfiPciHotPlugInitProtocolGuid, &mPciHotPlugInit, NULL);
|
|
return Status;
|
|
}
|