src/devices/board/drivers/x86/pci_irqs.cc - fuchsia - Git at Google

 // Copyright 2020 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include <assert.h>
 #include <fuchsia/hardware/pciroot/c/banjo.h>
 #include <lib/fitx/result.h>
 #include <lib/pci/pciroot.h>
 #include <stdio.h>

 #include <array>
 #include <cstring>
 #include <optional>

 #include <acpica/acpi.h>

 #include "acpi-buffer.h"
 #include "acpi-private.h"
 #include "pci.h"

 // Legacy PCI device functions have a single interrupt that was traditionally
 // wired directly into the interrupt controller. There are only four interrupt
 // lines shared among devices, labeled A through D. When an interrupt is
 // triggered on one of these lines it's the responsibility of system software to
 // look at all devices using the line wired to that vector and check which
 // device has their interrupt status bit flipped. To properly configure these
 // legacy interrupts at the platform level we need to read the PCI Routing
 // Tables (_PRT) for each root port found. PCI Routing Tables represent a
 // mapping between a root device/function adddress and an Interrupt Link Device
 // (ILD) or hardware vector. This ILD contains a resource that details how it is
 // wired up, and how the interrupt needs to be configured. Using this we can
 // build a routing table between a given BDF pin and a hard vector in the bus
 // driver.

 namespace {

 struct PortInfo {
   uint8_t dev_id;
   uint8_t func_id;
 };

 constexpr const char* im_to_str(uint32_t irq_mode) {
   switch (irq_mode) {
     case ZX_INTERRUPT_MODE_EDGE_LOW:
       return "edge triggered, active low";
     case ZX_INTERRUPT_MODE_EDGE_HIGH:
       return "edge triggered, active high";
     case ZX_INTERRUPT_MODE_LEVEL_HIGH:
       return "level triggered, active high";
     case ZX_INTERRUPT_MODE_LEVEL_LOW:
       return "level triggered, active low";
     default:
       return "<unsupported irq mode>";
   }
 }

 // Find Extended IRQ information for a PRT's Interrupt Link Device.
 fitx::result<ACPI_STATUS, ACPI_RESOURCE_EXTENDED_IRQ> FindExtendedIrqResource(ACPI_HANDLE parent,
                                                                               char source[4]) {
   // If this method is called then we're attempting to find the Interrupt Link Device referenced by
   // a given PRT entry.
   ACPI_HANDLE ild;
   ACPI_STATUS status = AcpiGetHandle(parent, source, &ild);
   if (status != AE_OK) {
     return fitx::error(status);
   }

   acpi::AcpiBuffer<ACPI_RESOURCE> crs_buffer;
   status = AcpiGetCurrentResources(ild, &crs_buffer);
   if (status != AE_OK) {
     return fitx::error(status);
   }

   for (auto& res : crs_buffer) {
     if (res.Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
       return fitx::ok(res.Data.ExtendedIrq);
     }
   }
   return fitx::error(AE_NOT_FOUND);
 }

 // Take a PRT entry and return a usable acpi_legacy_irq based on the type of IRQ
 // source information we were able to find in the ACPI table.
 acpi_legacy_irq PrtEntryToIrq(ACPI_HANDLE object, ACPI_PCI_ROUTING_TABLE* entry) {
   // By default, SourceIndex refers to a global IRQ number that the pin is
   // connected to and we assume the legacy defaults of Level-triggered / Active Low.
   // PCI Local Bus Specification 3.0 section 2.2.6
   acpi_legacy_irq new_irq = {.vector = entry->SourceIndex, .options = ZX_INTERRUPT_MODE_LEVEL_LOW};
   // If the PRT contains a Source entry than we can attempt to find an Extended
   // IRQ Resource describing it.
   if (entry->Source[0]) {
     if (auto result = FindExtendedIrqResource(object, entry->Source); result.is_ok()) {
       new_irq.vector = result->Interrupts[0];
       if (result->Triggering == ACPI_LEVEL_SENSITIVE) {
         if (result->Polarity == ACPI_ACTIVE_HIGH) {
           new_irq.options = ZX_INTERRUPT_MODE_LEVEL_HIGH;
         } else {
           new_irq.options = ZX_INTERRUPT_MODE_LEVEL_LOW;
         }
       } else {
         if (result->Polarity == ACPI_ACTIVE_HIGH) {
           new_irq.options = ZX_INTERRUPT_MODE_EDGE_HIGH;
         } else {
           new_irq.options = ZX_INTERRUPT_MODE_EDGE_LOW;
         }
       }
     }
   }

   return new_irq;
 }

 void AddIrqToAccounting(acpi_legacy_irq irq, x64Pciroot::Context* context,
                         ACPI_PCI_ROUTING_TABLE* entry, std::optional<PortInfo> port,
                         uint8_t local_dev_id) {
   // The first time we find an irq in a PRT it should be stored in the root's
   // context so that later it can be passed to the PCI bus driver.
   auto vector_entry = context->irqs.find(irq.vector);
   if (vector_entry == context->irqs.end()) {
     context->irqs[irq.vector] = irq;
     zxlogf(DEBUG, "added vector %#x { %s } from PRT", irq.vector, im_to_str(irq.options));
   } else if (vector_entry->second.options != irq.options) {
     // This may not be fatal, but it would represent a misconfiguration that
     // would likely result in some devices wired to this pin to have
     // malfunctioning IRQs. It would most likely reflect an error in an ACPI
     // table, but we cannot do much about it without knowing which configuration
     // is correct. In lieu of that, go with the first.
     zxlogf(WARNING, "Multiple IRQ configurations found in PRT for vector %#x!", irq.vector);
   }

   auto& routing_vec = context->routing;
   auto find_fn = [local_dev_id, port](auto& e) -> bool {
     return ((port) ? port->dev_id : PCI_IRQ_ROUTING_NO_PARENT) == e.port_device_id &&
            ((port) ? port->func_id : PCI_IRQ_ROUTING_NO_PARENT) == e.port_function_id &&
            local_dev_id == e.device_id;
   };

   // Lastly, based on the device / function address provided we need to update the routing
   // table to reflect the new information we've found. If we have a valid device / function
   // address then we can update that entry, otherwise a new entry needs to be made for that
   // combination of port and child device. This would be easier in a map, but a vector allows us to
   // directly point to the backing storage in the pciroot protocol implementation.
   if (auto found_entry = std::find_if(routing_vec.begin(), routing_vec.end(), find_fn);
       found_entry != std::end(routing_vec)) {
     found_entry->pins[entry->Pin] = irq.vector;
   } else {
     pci_irq_routing_entry_t new_entry = {
         .port_device_id = (port) ? port->dev_id : static_cast<uint8_t>(PCI_IRQ_ROUTING_NO_PARENT),
         .port_function_id =
             (port) ? port->func_id : static_cast<uint8_t>(PCI_IRQ_ROUTING_NO_PARENT),
         .device_id = local_dev_id,
         .pins = {0},
     };
     new_entry.pins[entry->Pin] = irq.vector;
     routing_vec.push_back(new_entry);
   }
 }

 ACPI_STATUS ReadPciRoutingTable(ACPI_HANDLE object, x64Pciroot::Context* context,
                                 std::optional<PortInfo> port) {
   acpi::AcpiBuffer<ACPI_PCI_ROUTING_TABLE> irt_buffer;
   ACPI_STATUS status = AcpiGetIrqRoutingTable(object, &irt_buffer);
   if (status != AE_OK) {
     return status;
   }

   for (auto& entry : irt_buffer) {
     if (entry.Pin >= PCI_MAX_LEGACY_IRQ_PINS) {
       zxlogf(ERROR, "PRT entry contains an invalid pin: %#x", entry.Pin);
       return AE_ERROR;
     }

     zxlogf(TRACE,
            "_PRT Entry RootPort %02x.%1x: .Address = 0x%05llx, .Pin = %u, .SourceIndex = %u, "
            ".Source = \"%s\"",
            (port) ? port->dev_id : 0, (port) ? port->func_id : 0, entry.Address, entry.Pin,
            entry.SourceIndex, entry.Source);

     // Per ACPI Spec 6.2.13, all _PRT entries must have a function address of
     // 0xFFFF representing all functions in the device. In effect, this means we
     // only care about the entry's dev id.
     uint8_t dev_id = (entry.Address >> 16) & (PCI_MAX_DEVICES_PER_BUS - 1);
     // Either we're handling the root complex (port_dev_id == UINT8_MAX), or
     // we're handling a root port, and if it's a root port, dev_id should
     // be 0. If not, the entry is strange and we'll warn / skip it.
     if (port && dev_id != 0) {
       zxlogf(WARNING, "PRT entry for root %.*s unexpected contains device address: %#x",
              static_cast<int>(sizeof(context->name)), context->name, dev_id);
       continue;
     }

     acpi_legacy_irq new_irq = PrtEntryToIrq(object, &entry);
     AddIrqToAccounting(new_irq, context, &entry, port, dev_id);
   }

   return AE_OK;
 }

 }  // namespace

 namespace acpi {

 ACPI_STATUS GetPciRootIrqRouting(ACPI_HANDLE root_obj, x64Pciroot::Context* context) {
   // Start with the Root's _PRT. The spec requires that one exists.
   ACPI_STATUS status = ReadPciRoutingTable(root_obj, context, std::nullopt);
   if (status != AE_OK) {
     zxlogf(DEBUG, "Couldn't find an IRQ routing table for root %.*s",
            static_cast<int>(sizeof(context->name)), context->name);
     return status;
   }

   // If there are any host bridges / pcie-to-pci bridges or other ports under
   // the root then check them for PRTs as well. This is unncecessary in most
   // configurations.
   ACPI_HANDLE child = nullptr;
   while ((status = AcpiGetNextObject(ACPI_TYPE_DEVICE, root_obj, child, &child)) == AE_OK) {
     if (auto res = acpi::GetObjectInfo(child); res.is_ok()) {
       // If the object we're examining has a PCI address then use that as the
       // basis for the routing table we're inspecting.
       // Format: Acpi 6.1 section 6.1.1 "_ADR (Address)"
       PortInfo port{
           .dev_id = static_cast<uint8_t>((res->Address >> 16) & (PCI_MAX_DEVICES_PER_BUS - 1)),
           .func_id = static_cast<uint8_t>(res->Address & (PCI_MAX_FUNCTIONS_PER_DEVICE - 1)),
       };
       zxlogf(DEBUG, "Processing _PRT for %02x.%1x (%.*s)", port.dev_id, port.func_id, 4,
              reinterpret_cast<char*>(&res->Name));
       // Ignore the return value of this, since if child is not a root port, it
       // will fail and we don't care.
       ReadPciRoutingTable(child, context, port);
     }
   }

   return AE_OK;
 }

 }  // namespace acpi
	// Copyright 2020 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	#include <assert.h>
	#include <fuchsia/hardware/pciroot/c/banjo.h>
	#include <lib/fitx/result.h>
	#include <lib/pci/pciroot.h>
	#include <stdio.h>

	#include <array>
	#include <cstring>
	#include <optional>

	#include <acpica/acpi.h>

	#include "acpi-buffer.h"
	#include "acpi-private.h"
	#include "pci.h"

	// Legacy PCI device functions have a single interrupt that was traditionally
	// wired directly into the interrupt controller. There are only four interrupt
	// lines shared among devices, labeled A through D. When an interrupt is
	// triggered on one of these lines it's the responsibility of system software to
	// look at all devices using the line wired to that vector and check which
	// device has their interrupt status bit flipped. To properly configure these
	// legacy interrupts at the platform level we need to read the PCI Routing
	// Tables (_PRT) for each root port found. PCI Routing Tables represent a
	// mapping between a root device/function adddress and an Interrupt Link Device
	// (ILD) or hardware vector. This ILD contains a resource that details how it is
	// wired up, and how the interrupt needs to be configured. Using this we can
	// build a routing table between a given BDF pin and a hard vector in the bus
	// driver.

	namespace {

	struct PortInfo {
	uint8_t dev_id;
	uint8_t func_id;
	};

	constexpr const char* im_to_str(uint32_t irq_mode) {
	switch (irq_mode) {
	case ZX_INTERRUPT_MODE_EDGE_LOW:
	return "edge triggered, active low";
	case ZX_INTERRUPT_MODE_EDGE_HIGH:
	return "edge triggered, active high";
	case ZX_INTERRUPT_MODE_LEVEL_HIGH:
	return "level triggered, active high";
	case ZX_INTERRUPT_MODE_LEVEL_LOW:
	return "level triggered, active low";
	default:
	return "<unsupported irq mode>";
	}
	}

	// Find Extended IRQ information for a PRT's Interrupt Link Device.
	fitx::result<ACPI_STATUS, ACPI_RESOURCE_EXTENDED_IRQ> FindExtendedIrqResource(ACPI_HANDLE parent,
	char source[4]) {
	// If this method is called then we're attempting to find the Interrupt Link Device referenced by
	// a given PRT entry.
	ACPI_HANDLE ild;
	ACPI_STATUS status = AcpiGetHandle(parent, source, &ild);
	if (status != AE_OK) {
	return fitx::error(status);
	}

	acpi::AcpiBuffer<ACPI_RESOURCE> crs_buffer;
	status = AcpiGetCurrentResources(ild, &crs_buffer);
	if (status != AE_OK) {
	return fitx::error(status);
	}

	for (auto& res : crs_buffer) {
	if (res.Type == ACPI_RESOURCE_TYPE_EXTENDED_IRQ) {
	return fitx::ok(res.Data.ExtendedIrq);
	}
	}
	return fitx::error(AE_NOT_FOUND);
	}

	// Take a PRT entry and return a usable acpi_legacy_irq based on the type of IRQ
	// source information we were able to find in the ACPI table.
	acpi_legacy_irq PrtEntryToIrq(ACPI_HANDLE object, ACPI_PCI_ROUTING_TABLE* entry) {
	// By default, SourceIndex refers to a global IRQ number that the pin is
	// connected to and we assume the legacy defaults of Level-triggered / Active Low.
	// PCI Local Bus Specification 3.0 section 2.2.6
	acpi_legacy_irq new_irq = {.vector = entry->SourceIndex, .options = ZX_INTERRUPT_MODE_LEVEL_LOW};
	// If the PRT contains a Source entry than we can attempt to find an Extended
	// IRQ Resource describing it.
	if (entry->Source[0]) {
	if (auto result = FindExtendedIrqResource(object, entry->Source); result.is_ok()) {
	new_irq.vector = result->Interrupts[0];
	if (result->Triggering == ACPI_LEVEL_SENSITIVE) {
	if (result->Polarity == ACPI_ACTIVE_HIGH) {
	new_irq.options = ZX_INTERRUPT_MODE_LEVEL_HIGH;
	} else {
	new_irq.options = ZX_INTERRUPT_MODE_LEVEL_LOW;
	}
	} else {
	if (result->Polarity == ACPI_ACTIVE_HIGH) {
	new_irq.options = ZX_INTERRUPT_MODE_EDGE_HIGH;
	} else {
	new_irq.options = ZX_INTERRUPT_MODE_EDGE_LOW;
	}
	}
	}
	}

	return new_irq;
	}

	void AddIrqToAccounting(acpi_legacy_irq irq, x64Pciroot::Context* context,
	ACPI_PCI_ROUTING_TABLE* entry, std::optional<PortInfo> port,
	uint8_t local_dev_id) {
	// The first time we find an irq in a PRT it should be stored in the root's
	// context so that later it can be passed to the PCI bus driver.
	auto vector_entry = context->irqs.find(irq.vector);
	if (vector_entry == context->irqs.end()) {
	context->irqs[irq.vector] = irq;
	zxlogf(DEBUG, "added vector %#x { %s } from PRT", irq.vector, im_to_str(irq.options));
	} else if (vector_entry->second.options != irq.options) {
	// This may not be fatal, but it would represent a misconfiguration that
	// would likely result in some devices wired to this pin to have
	// malfunctioning IRQs. It would most likely reflect an error in an ACPI
	// table, but we cannot do much about it without knowing which configuration
	// is correct. In lieu of that, go with the first.
	zxlogf(WARNING, "Multiple IRQ configurations found in PRT for vector %#x!", irq.vector);
	}

	auto& routing_vec = context->routing;
	auto find_fn = [local_dev_id, port](auto& e) -> bool {
	return ((port) ? port->dev_id : PCI_IRQ_ROUTING_NO_PARENT) == e.port_device_id &&
	((port) ? port->func_id : PCI_IRQ_ROUTING_NO_PARENT) == e.port_function_id &&
	local_dev_id == e.device_id;
	};

	// Lastly, based on the device / function address provided we need to update the routing
	// table to reflect the new information we've found. If we have a valid device / function
	// address then we can update that entry, otherwise a new entry needs to be made for that
	// combination of port and child device. This would be easier in a map, but a vector allows us to
	// directly point to the backing storage in the pciroot protocol implementation.
	if (auto found_entry = std::find_if(routing_vec.begin(), routing_vec.end(), find_fn);
	found_entry != std::end(routing_vec)) {
	found_entry->pins[entry->Pin] = irq.vector;
	} else {
	pci_irq_routing_entry_t new_entry = {
	.port_device_id = (port) ? port->dev_id : static_cast<uint8_t>(PCI_IRQ_ROUTING_NO_PARENT),
	.port_function_id =
	(port) ? port->func_id : static_cast<uint8_t>(PCI_IRQ_ROUTING_NO_PARENT),
	.device_id = local_dev_id,
	.pins = {0},
	};
	new_entry.pins[entry->Pin] = irq.vector;
	routing_vec.push_back(new_entry);
	}
	}

	ACPI_STATUS ReadPciRoutingTable(ACPI_HANDLE object, x64Pciroot::Context* context,
	std::optional<PortInfo> port) {
	acpi::AcpiBuffer<ACPI_PCI_ROUTING_TABLE> irt_buffer;
	ACPI_STATUS status = AcpiGetIrqRoutingTable(object, &irt_buffer);
	if (status != AE_OK) {
	return status;
	}

	for (auto& entry : irt_buffer) {
	if (entry.Pin >= PCI_MAX_LEGACY_IRQ_PINS) {
	zxlogf(ERROR, "PRT entry contains an invalid pin: %#x", entry.Pin);
	return AE_ERROR;
	}

	zxlogf(TRACE,
	"_PRT Entry RootPort %02x.%1x: .Address = 0x%05llx, .Pin = %u, .SourceIndex = %u, "
	".Source = \"%s\"",
	(port) ? port->dev_id : 0, (port) ? port->func_id : 0, entry.Address, entry.Pin,
	entry.SourceIndex, entry.Source);

	// Per ACPI Spec 6.2.13, all _PRT entries must have a function address of
	// 0xFFFF representing all functions in the device. In effect, this means we
	// only care about the entry's dev id.
	uint8_t dev_id = (entry.Address >> 16) & (PCI_MAX_DEVICES_PER_BUS - 1);
	// Either we're handling the root complex (port_dev_id == UINT8_MAX), or
	// we're handling a root port, and if it's a root port, dev_id should
	// be 0. If not, the entry is strange and we'll warn / skip it.
	if (port && dev_id != 0) {
	zxlogf(WARNING, "PRT entry for root %.*s unexpected contains device address: %#x",
	static_cast<int>(sizeof(context->name)), context->name, dev_id);
	continue;
	}

	acpi_legacy_irq new_irq = PrtEntryToIrq(object, &entry);
	AddIrqToAccounting(new_irq, context, &entry, port, dev_id);
	}

	return AE_OK;
	}

	} // namespace

	namespace acpi {

	ACPI_STATUS GetPciRootIrqRouting(ACPI_HANDLE root_obj, x64Pciroot::Context* context) {
	// Start with the Root's _PRT. The spec requires that one exists.
	ACPI_STATUS status = ReadPciRoutingTable(root_obj, context, std::nullopt);
	if (status != AE_OK) {
	zxlogf(DEBUG, "Couldn't find an IRQ routing table for root %.*s",
	static_cast<int>(sizeof(context->name)), context->name);
	return status;
	}

	// If there are any host bridges / pcie-to-pci bridges or other ports under
	// the root then check them for PRTs as well. This is unncecessary in most
	// configurations.
	ACPI_HANDLE child = nullptr;
	while ((status = AcpiGetNextObject(ACPI_TYPE_DEVICE, root_obj, child, &child)) == AE_OK) {
	if (auto res = acpi::GetObjectInfo(child); res.is_ok()) {
	// If the object we're examining has a PCI address then use that as the
	// basis for the routing table we're inspecting.
	// Format: Acpi 6.1 section 6.1.1 "_ADR (Address)"
	PortInfo port{
	.dev_id = static_cast<uint8_t>((res->Address >> 16) & (PCI_MAX_DEVICES_PER_BUS - 1)),
	.func_id = static_cast<uint8_t>(res->Address & (PCI_MAX_FUNCTIONS_PER_DEVICE - 1)),
	};
	zxlogf(DEBUG, "Processing _PRT for %02x.%1x (%.*s)", port.dev_id, port.func_id, 4,
	reinterpret_cast<char*>(&res->Name));
	// Ignore the return value of this, since if child is not a root port, it
	// will fail and we don't care.
	ReadPciRoutingTable(child, context, port);
	}
	}

	return AE_OK;
	}

	} // namespace acpi