/** @file
|
|
@copyright
|
Copyright 1999 - 2021 Intel Corporation. <BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
**/
|
|
#include <Guid/SocketPciResourceData.h>
|
#include <Guid/SocketIioVariable.h>
|
#include <Protocol/IioUds.h>
|
|
#include "PciHostBridge.h"
|
#include "PciRootBridge.h"
|
#include "PciRebalance.h"
|
|
|
extern EFI_IIO_UDS_PROTOCOL *mIioUds;
|
|
/**
|
Return TRUE if the specified socket/stack combination exists,
|
otherwise return FALSE
|
|
@param Socket - the socket to be checked
|
@param Stack - the stack of the socket to be checked
|
|
@retval TRUE - the socket/stack combination exists
|
@retval FALSE - the socket/stack combination does not exist
|
*/
|
STATIC BOOLEAN
|
IsStackPresent (
|
UINT8 Socket,
|
UINT8 Stack
|
)
|
{
|
BOOLEAN Result;
|
UINT64 Mask;
|
|
ASSERT (Socket < ARRAY_SIZE (mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo)); // simple overrun check
|
if (Socket >= ARRAY_SIZE (mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo)) {
|
Result = FALSE;
|
goto err_exit;
|
}
|
|
//
|
// if the StackPresentBitmap is a single byte, then we can track 8 stacks,
|
// the sizeof will tell us how many bytes we have, we scale by 8 to
|
// determine the maximum number of stacks we can track. Stacks larger
|
// than this are not present essentially by definition, but could also
|
// be a sign that we need a wider type to store the information; hence we
|
// assert
|
//
|
ASSERT (Stack < 8 * sizeof(mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[0].stackPresentBitmap));
|
if (Stack >= 8 * sizeof(mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[0].stackPresentBitmap)) {
|
Result = FALSE;
|
goto err_exit;
|
}
|
|
Mask = 1;
|
Mask <<= Stack;
|
Result = (Mask & mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[Socket].stackPresentBitmap) != 0;
|
|
err_exit:
|
return Result;
|
}
|
|
|
/**
|
Adjust resource assignment among sockets to fit the IO
|
resources from the PCI() devices in the system
|
|
@param SocketResources - CPU_RESOURCE structure pointer that stores all resources need per socket
|
@param ResourceType - type of resource that requires alignment
|
@param ValidSockets - Number of Valid Sockets, need it
|
to calculate how resources need to
|
be split
|
|
@retval EFI_SUCCESS - Succeed.
|
@retval EFI_OUT_OF_RESOURCES - Not enough resources to be adjusted within the socket.
|
**/
|
EFI_STATUS
|
AdjustSocketIo (
|
CPU_RESOURCE *SocketResources,
|
UINT8 ResourceType,
|
UINT8 ValidSockets
|
)
|
{
|
UINT64 Base; ///< Next base I/O port number to use
|
UINT64 Limit; ///< Most recent limit for I/O port numbers
|
CONST UINT64 MaxLimit = ((UINT64)1 << 16) - 1; ///< Maximum value for limit; used to ensure we don't overflow
|
CPU_RESOURCE *CurSocketResources; ///< Pointer to the CPU_RESOURE structure for the CPU we
|
///< are examining
|
STACK_RESOURCE *CurStackResources; ///< Pointer to the STACK_RESOURCE structure for the CPU/Stack
|
///< we are examining
|
UINT16 NumFreePorts; ///< Number of i/o ports allocated to sockets that are not used
|
UINT8 LastStack; ///< Last enabled stack of the last enabled socket
|
CONST UINT8 LastSocketIndex = ValidSockets - 1; ///< Index of the last socket
|
UINT64 TotalResourceSize;
|
UINT64 ResourceSize;
|
UINT8 Socket; ///< Loop variable used to iterate over the sockets
|
UINT8 Stack; ///< Loop variable used to iterate over the stacks of a given socket
|
|
NumFreePorts = 0;
|
for (Socket = 0; Socket < ValidSockets; Socket++) {
|
CurSocketResources = &SocketResources[Socket];
|
if (CurSocketResources->IoResourceNeeds == 0 && CurSocketResources->IoResourcesLeft != 0) {
|
ASSERT (NumFreePorts < NumFreePorts + CurSocketResources->IoResourcesLeft + 1); // check for overflow
|
NumFreePorts += CurSocketResources->IoResourcesLeft + 1;
|
CurSocketResources->IoResourcesLeft = 0;
|
}
|
}
|
|
for (Socket = 0; Socket < ValidSockets; Socket++) {
|
CurSocketResources = &SocketResources[Socket];
|
if (CurSocketResources->IoResourceNeeds != 0 && NumFreePorts >= CurSocketResources->IoResourceNeeds) {
|
ASSERT (NumFreePorts > NumFreePorts - CurSocketResources->IoResourceNeeds); // check for underflow
|
NumFreePorts -= CurSocketResources->IoResourceNeeds;
|
CurSocketResources->IoResourceNeeds = 0;
|
}
|
}
|
|
LastStack = LastStackOfSocket (LastSocketIndex);
|
|
if (NumFreePorts > 0) {
|
CurStackResources = &SocketResources[LastSocketIndex].StackRes[LastStack];
|
if (CurStackResources->NumIoPortsDesired != 0) {
|
CurStackResources->NumIoPortsDesired += NumFreePorts;
|
} else {
|
CurStackResources->NumIoPortsDesired += NumFreePorts - 1;
|
}
|
}
|
|
//
|
// Verify all resource requested can fit into the systems address range.
|
//
|
TotalResourceSize = 0;
|
for (Socket = 0; Socket < ValidSockets; Socket ++) {
|
LastStackWithResources (&SocketResources[Socket], Socket, ResourceType, &LastStack, &ResourceSize);
|
TotalResourceSize += ResourceSize;
|
}
|
DEBUG ((DEBUG_INFO, "Total Request IO Range = %xh\n", TotalResourceSize));
|
DEBUG ((DEBUG_INFO, "Total System IO Range = %xh\n", MaxLimit));
|
if (TotalResourceSize > MaxLimit) {
|
//
|
// Not enough system resources to support the request.
|
// Remove all request to update NVRAM variable for this resource type.
|
//
|
for (Socket = 0; Socket < ValidSockets; Socket ++) {
|
for (Stack = 0; Stack < MAX_IIO_STACK; Stack ++) {
|
if (!(mIioUds->IioUdsPtr->PlatformData.CpuQpiInfo[Socket].stackPresentBitmap & (1 << Stack))) {
|
continue;
|
}
|
SocketResources[Socket].StackRes[Stack].NeedIoUpdate = 0;
|
}
|
}
|
DEBUG ((DEBUG_ERROR, "ERROR: Out of adjustable IO resources. Can't adjust across sockets\n"));
|
return EFI_OUT_OF_RESOURCES;
|
}
|
|
DEBUG((DEBUG_ERROR, "Assigning new socket i/o range...\n"));
|
|
Base = mIioUds->IioUdsPtr->PlatformData.IIO_resource[0].PciResourceIoBase;
|
Limit = Base; // assume no resources are allocated
|
for (Socket = 0, CurSocketResources = SocketResources; Socket < ValidSockets; Socket++, CurSocketResources++) {
|
DEBUG ((DEBUG_INFO, "socket = %d, Base = %x, Limit =%x, MaxLimit = %x\n", Socket, Base, Limit, MaxLimit));
|
ASSERT (Base < MaxLimit);
|
CurSocketResources->IoBase = (UINT16)Base;
|
DEBUG ((DEBUG_INFO, "set socket io base to %x\n", Base));
|
|
for (Stack = 0, CurStackResources = CurSocketResources->StackRes;
|
Stack < MAX_IIO_STACK;
|
Stack++, CurStackResources++) {
|
if (!IsStackPresent (Socket, Stack)) {
|
DEBUG ((DEBUG_INFO, " Stack %d not present, setting base/limit to 0xffff/0\n", Stack));
|
CurStackResources->IoBase = 0xffff;
|
CurStackResources->IoLimit = 0;
|
continue;
|
}
|
|
if (CurStackResources->NumIoPortsDesired == 0) {
|
DEBUG ((DEBUG_INFO, " Stack %d doesn't need i/o resources, setting base/limit to 0xffff/0\n", Stack));
|
CurStackResources->IoBase = 0xffff;
|
CurStackResources->IoLimit = 0;
|
CurStackResources->NeedIoUpdate = TRUE;
|
continue;
|
}
|
|
DEBUG((DEBUG_INFO, " Stack %d setting i/o base to %x, ports desired was %x\n",
|
Stack, Base, CurStackResources->NumIoPortsDesired));
|
ASSERT (Base < MaxLimit);
|
CurStackResources->IoBase = (UINT16)Base;
|
Limit = Base + CurStackResources->NumIoPortsDesired;
|
DEBUG ((DEBUG_INFO, " limit set to %x (var and stack)\n", Limit));
|
ASSERT (Base <= Limit);
|
ASSERT (Limit <= MaxLimit);
|
CurStackResources->IoLimit = (UINT16)Limit;
|
CurStackResources->NeedIoUpdate = TRUE;
|
Base = Limit + 1;
|
DEBUG ((DEBUG_INFO, " Base variable updated to %x\n", Base));
|
}
|
ASSERT (Limit <= MaxLimit);
|
DEBUG ((DEBUG_INFO, " Socket %d limit set to %x\n", Socket, Limit));
|
CurSocketResources->IoLimit = (UINT16)Limit;
|
}
|
|
DEBUG ((DEBUG_INFO, "Dumping new I/O requests\n"));
|
for (Socket = 0, CurSocketResources = SocketResources; Socket < ValidSockets; Socket++, CurSocketResources++) {
|
DEBUG((DEBUG_INFO, "socket %d %x/%x\n", Socket, CurSocketResources->IoBase, CurSocketResources->IoLimit));
|
for (Stack = 0, CurStackResources = CurSocketResources->StackRes;
|
Stack < MAX_IIO_STACK;
|
Stack++, CurStackResources++) {
|
DEBUG ((DEBUG_INFO, "%d/%d: %x/%x\n", Socket, Stack, CurStackResources->IoBase, CurStackResources->IoLimit));
|
}
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
