Files
rt-thread/components/drivers/pci/probe.c
T
GUI 7bf01ae18d [DM/OFW][PCI] Fix address translation and PCI resource enumeration (#11677)
* [DM/OFW][PCI] Fix address translation and PCI resource enumeration

Rework OFW address translation to walk nested bus ranges in the correct
direction and cache "ranges" and "dma-ranges" independently. Handle PCI
three-cell addresses without treating the PCI flags cell as part of the
address, and fix CPU-to-DMA and DMA-to-CPU translation across nested
buses.

Fix PCI BAR sizing and assignment by disabling address decoding during
probing, preserving BAR attribute bits, and programming 64-bit BARs
correctly. Add device enable and disable helpers so resources and bus
mastering are enabled before driver probe.

Program bridge memory and prefetch windows while scanning downstream
buses, correctly link child buses into the PCI bus hierarchy, and avoid
unnecessary PCIe link retraining when the link is already active.

Allow host bridges without a device-tree pci-domain property by
allocating unique domains dynamically, while preserving explicit domain
assignments.

Fix MSI and MSI-X IRQ setup, rollback, vector addressing, and affinity
selection.

Add the Raspberry Pi PCI vendor ID for RP1 and other downstream devices.

Signed-off-by: GuEe-GUI <2991707448@qq.com>

* style: format code with clang-format

* style: format complete changed files with clang-format

* drivers: pci: address OFW review feedback

* style: format PCI and OFW changes for current master

---------

Signed-off-by: GuEe-GUI <2991707448@qq.com>
2026-08-14 12:42:32 +08:00

1087 lines
24 KiB
C

/*
* Copyright (c) 2006-2022, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2022-10-24 GuEe-GUI first version
*/
#include <rtthread.h>
#define DBG_TAG "pci.probe"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>
#include <drivers/pci.h>
#include <drivers/core/bus.h>
#include "procfs.h"
static struct rt_dm_ida pci_domain_ida = RT_DM_IDA_INIT(CUSTOM);
rt_inline void spin_lock(struct rt_spinlock *spinlock)
{
rt_hw_spin_lock(&spinlock->lock);
}
rt_inline void spin_unlock(struct rt_spinlock *spinlock)
{
rt_hw_spin_unlock(&spinlock->lock);
}
struct rt_pci_host_bridge *rt_pci_host_bridge_alloc(rt_size_t priv_size)
{
struct rt_pci_host_bridge *bridge = rt_calloc(1, sizeof(*bridge) + priv_size);
return bridge;
}
rt_err_t rt_pci_host_bridge_free(struct rt_pci_host_bridge *bridge)
{
if (!bridge)
{
return -RT_EINVAL;
}
if (bridge->bus_regions)
{
rt_free(bridge->bus_regions);
}
if (bridge->dma_regions)
{
rt_free(bridge->dma_regions);
}
rt_free(bridge);
return RT_EOK;
}
rt_err_t rt_pci_host_bridge_init(struct rt_pci_host_bridge *host_bridge)
{
rt_err_t err = RT_EOK;
if (host_bridge->parent.ofw_node)
{
err = rt_pci_ofw_host_bridge_init(host_bridge->parent.ofw_node, host_bridge);
if (err)
{
return err;
}
if (host_bridge->domain == RT_UINT32_MAX)
{
host_bridge->domain = rt_dm_ida_alloc(&pci_domain_ida);
if ((int)(host_bridge->domain) < 0)
{
return -RT_EFULL;
}
}
else
{
if (!rt_dm_ida_take(&pci_domain_ida, host_bridge->domain))
{
LOG_E("Failed to take domain %u", host_bridge->domain);
return -RT_ERROR;
}
}
}
return err;
}
struct rt_pci_device *rt_pci_alloc_device(struct rt_pci_bus *bus)
{
struct rt_pci_device *pdev = rt_calloc(1, sizeof(*pdev));
if (!pdev)
{
return RT_NULL;
}
rt_list_init(&pdev->list);
pdev->bus = bus;
if (bus)
{
spin_lock(&bus->lock);
rt_list_insert_before(&bus->devices_nodes, &pdev->list);
spin_unlock(&bus->lock);
}
pdev->subsystem_vendor = PCI_ANY_ID;
pdev->subsystem_device = PCI_ANY_ID;
pdev->irq = -1;
for (int i = 0; i < RT_ARRAY_SIZE(pdev->resource); ++i)
{
pdev->resource[i].flags = PCI_BUS_REGION_F_NONE;
}
#ifdef RT_PCI_MSI
rt_list_init(&pdev->msi_desc_nodes);
rt_spin_lock_init(&pdev->msi_lock);
#endif
return pdev;
}
struct rt_pci_device *rt_pci_scan_single_device(struct rt_pci_bus *bus, rt_uint32_t devfn)
{
rt_err_t err;
struct rt_pci_device *pdev = RT_NULL;
rt_uint16_t vendor = PCI_ANY_ID, device = PCI_ANY_ID;
if (!bus)
{
goto _end;
}
err = rt_pci_bus_read_config_u16(bus, devfn, PCIR_VENDOR, &vendor);
rt_pci_bus_read_config_u16(bus, devfn, PCIR_DEVICE, &device);
if (vendor == (typeof(vendor))PCI_ANY_ID ||
vendor == (typeof(vendor))0x0000 || err)
{
goto _end;
}
if (!(pdev = rt_pci_alloc_device(bus)))
{
goto _end;
}
pdev->devfn = devfn;
pdev->vendor = vendor;
pdev->device = device;
rt_dm_dev_set_name(&pdev->parent, "%04x:%02x:%02x.%u",
rt_pci_domain(pdev), pdev->bus->number,
RT_PCI_SLOT(pdev->devfn), RT_PCI_FUNC(pdev->devfn));
if (rt_pci_setup_device(pdev))
{
rt_free(pdev);
pdev = RT_NULL;
goto _end;
}
pci_procfs_attach(pdev);
rt_pci_device_register(pdev);
_end:
return pdev;
}
static rt_bool_t pci_intx_mask_broken(struct rt_pci_device *pdev)
{
rt_bool_t res = RT_FALSE;
rt_uint16_t orig, toggle, new;
rt_pci_read_config_u16(pdev, PCIR_COMMAND, &orig);
toggle = orig ^ PCIM_CMD_INTxDIS;
rt_pci_write_config_u16(pdev, PCIR_COMMAND, toggle);
rt_pci_read_config_u16(pdev, PCIR_COMMAND, &new);
rt_pci_write_config_u16(pdev, PCIR_COMMAND, orig);
if (new != toggle)
{
res = RT_TRUE;
}
return res;
}
static void pci_read_irq(struct rt_pci_device *pdev)
{
rt_uint8_t irq = 0;
rt_pci_read_config_u8(pdev, PCIR_INTPIN, &irq);
pdev->pin = irq;
if (irq)
{
rt_pci_read_config_u8(pdev, PCIR_INTLINE, &irq);
}
pdev->irq = irq;
}
static void pcie_set_port_type(struct rt_pci_device *pdev)
{
int pos;
if (!(pos = rt_pci_find_capability(pdev, PCIY_EXPRESS)))
{
return;
}
pdev->pcie_cap = pos;
}
static void pci_configure_ari(struct rt_pci_device *pdev)
{
rt_uint32_t cap, ctl2_ari;
struct rt_pci_device *bridge;
if (!rt_pci_is_pcie(pdev) || pdev->devfn)
{
return;
}
bridge = pdev->bus->self;
if (rt_pci_is_root_bus(pdev->bus) || !bridge)
{
return;
}
rt_pci_read_config_u32(bridge, bridge->pcie_cap + PCIER_DEVICE_CAP2, &cap);
if (!(cap & PCIEM_CAP2_ARI))
{
return;
}
rt_pci_read_config_u32(bridge, bridge->pcie_cap + PCIER_DEVICE_CTL2, &ctl2_ari);
if (rt_pci_find_ext_capability(pdev, PCIZ_ARI))
{
ctl2_ari |= PCIEM_CTL2_ARI;
bridge->ari_enabled = RT_TRUE;
}
else
{
ctl2_ari &= ~PCIEM_CTL2_ARI;
bridge->ari_enabled = RT_FALSE;
}
rt_pci_write_config_u32(bridge, bridge->pcie_cap + PCIER_DEVICE_CTL2, ctl2_ari);
}
static rt_uint16_t pci_cfg_space_size_ext(struct rt_pci_device *pdev)
{
rt_uint32_t status;
if (rt_pci_read_config_u32(pdev, PCI_REGMAX + 1, &status))
{
return PCI_REGMAX + 1;
}
return PCIE_REGMAX + 1;
}
static rt_uint16_t pci_cfg_space_size(struct rt_pci_device *pdev)
{
int pos;
rt_uint32_t status;
rt_uint16_t class = pdev->class >> 8;
if (class == PCIS_BRIDGE_HOST)
{
return pci_cfg_space_size_ext(pdev);
}
if (rt_pci_is_pcie(pdev))
{
return pci_cfg_space_size_ext(pdev);
}
pos = rt_pci_find_capability(pdev, PCIY_PCIX);
if (!pos)
{
return PCI_REGMAX + 1;
}
rt_pci_read_config_u32(pdev, pos + PCIXR_STATUS, &status);
if (status & (PCIXM_STATUS_266CAP | PCIXM_STATUS_533CAP))
{
return pci_cfg_space_size_ext(pdev);
}
return PCI_REGMAX + 1;
}
static void pci_init_capabilities(struct rt_pci_device *pdev)
{
rt_pci_pme_init(pdev);
#ifdef RT_PCI_MSI
rt_pci_msi_init(pdev); /* Disable MSI */
rt_pci_msix_init(pdev); /* Disable MSI-X */
#endif
pcie_set_port_type(pdev);
pdev->cfg_size = pci_cfg_space_size(pdev);
pci_configure_ari(pdev);
pdev->no_msi = RT_FALSE;
pdev->msi_enabled = RT_FALSE;
pdev->msix_enabled = RT_FALSE;
}
rt_err_t rt_pci_setup_device(struct rt_pci_device *pdev)
{
rt_uint8_t pos;
rt_uint32_t class = 0;
struct rt_pci_host_bridge *host_bridge;
if (!pdev)
{
return -RT_EINVAL;
}
if (!(host_bridge = rt_pci_find_host_bridge(pdev->bus)))
{
return -RT_EINVAL;
}
rt_pci_ofw_device_init(pdev);
rt_pci_read_config_u32(pdev, PCIR_REVID, &class);
pdev->revision = class & 0xff;
pdev->class = class >> 8; /* Upper 3 bytes */
rt_pci_read_config_u8(pdev, PCIR_HDRTYPE, &pdev->hdr_type);
/* Clear errors left from system firmware */
rt_pci_write_config_u16(pdev, PCIR_STATUS, 0xffff);
if (pdev->hdr_type & 0x80)
{
pdev->multi_function = RT_TRUE;
}
pdev->hdr_type &= PCIM_HDRTYPE;
if (pci_intx_mask_broken(pdev))
{
pdev->broken_intx_masking = RT_TRUE;
}
rt_dm_dev_set_name(&pdev->parent, "%04x:%02x:%02x.%u", rt_pci_domain(pdev),
pdev->bus->number, RT_PCI_SLOT(pdev->devfn), RT_PCI_FUNC(pdev->devfn));
class = pdev->class >> 8;
switch (pdev->hdr_type)
{
case PCIM_HDRTYPE_NORMAL:
if (class == PCIS_BRIDGE_PCI)
{
goto error;
}
pci_read_irq(pdev);
rt_pci_device_alloc_resource(host_bridge, pdev);
rt_pci_read_config_u16(pdev, PCIR_SUBVEND_0, &pdev->subsystem_vendor);
rt_pci_read_config_u16(pdev, PCIR_SUBDEV_0, &pdev->subsystem_device);
break;
case PCIM_HDRTYPE_BRIDGE:
pci_read_irq(pdev);
rt_pci_device_alloc_resource(host_bridge, pdev);
pos = rt_pci_find_capability(pdev, PCIY_SUBVENDOR);
if (pos)
{
rt_pci_read_config_u16(pdev, PCIR_SUBVENDCAP, &pdev->subsystem_vendor);
rt_pci_read_config_u16(pdev, PCIR_SUBDEVCAP, &pdev->subsystem_device);
}
break;
case PCIM_HDRTYPE_CARDBUS:
if (class != PCIS_BRIDGE_CARDBUS)
{
goto error;
}
pci_read_irq(pdev);
rt_pci_device_alloc_resource(host_bridge, pdev);
rt_pci_read_config_u16(pdev, PCIR_SUBVEND_2, &pdev->subsystem_vendor);
rt_pci_read_config_u16(pdev, PCIR_SUBDEV_2, &pdev->subsystem_device);
break;
default:
LOG_E("Ignoring device unknown header type %02x", pdev->hdr_type);
return -RT_EIO;
error:
LOG_E("Ignoring class %08x (doesn't match header type %02x)", pdev->class, pdev->hdr_type);
pdev->class = PCIC_NOT_DEFINED << 8;
}
pci_init_capabilities(pdev);
if (rt_pci_is_pcie(pdev))
{
rt_pci_read_config_u16(pdev, pdev->pcie_cap + PCIER_FLAGS, &pdev->exp_flags);
}
return RT_EOK;
}
static struct rt_pci_bus *pci_alloc_bus(struct rt_pci_bus *parent);
static rt_err_t pci_child_bus_init(struct rt_pci_bus *bus, rt_uint32_t bus_no,
struct rt_pci_host_bridge *host_bridge, struct rt_pci_device *pdev)
{
rt_err_t err;
struct rt_pci_bus *parent_bus = bus->parent;
bus->sysdata = parent_bus->sysdata;
bus->self = pdev;
bus->ops = host_bridge->child_ops ?: parent_bus->ops;
bus->number = bus_no;
rt_sprintf(bus->name, "%04x:%02x", host_bridge->domain, bus_no);
rt_pci_ofw_bus_init(bus);
if (bus->ops->add)
{
if ((err = bus->ops->add(bus)))
{
rt_pci_ofw_bus_free(bus);
LOG_E("PCI-Bus<%s> add bus failed with err = %s",
bus->name, rt_strerror(err));
return err;
}
}
return RT_EOK;
}
static rt_bool_t pci_ea_fixed_busnrs(struct rt_pci_device *pdev,
rt_uint8_t *sec, rt_uint8_t *sub)
{
int pos, offset;
rt_uint32_t dw;
rt_uint8_t ea_sec, ea_sub;
pos = rt_pci_find_capability(pdev, PCIY_EA);
if (!pos)
{
return RT_FALSE;
}
offset = pos + PCIR_EA_FIRST_ENT;
rt_pci_read_config_u32(pdev, offset, &dw);
ea_sec = PCIM_EA_SEC_NR(dw);
ea_sub = PCIM_EA_SUB_NR(dw);
if (ea_sec == 0 || ea_sub < ea_sec)
{
return RT_FALSE;
}
*sec = ea_sec;
*sub = ea_sub;
return RT_TRUE;
}
static rt_bool_t pci_is_pcie_port(struct rt_pci_device *pdev)
{
rt_uint16_t exp_type;
if (!pdev || !rt_pci_is_pcie(pdev))
{
return RT_FALSE;
}
exp_type = pdev->exp_flags & PCIEM_FLAGS_TYPE;
return exp_type == PCIEM_TYPE_ROOT_PORT ||
exp_type == PCIEM_TYPE_DOWNSTREAM_PORT ||
exp_type == PCIEM_TYPE_PCIE_BRIDGE;
}
static void pcie_fixup_link(struct rt_pci_device *pdev)
{
int pos = pdev->pcie_cap;
rt_uint16_t exp_lnkctl, exp_lnkctl2, exp_lnksta;
if ((pdev->exp_flags & PCIEM_FLAGS_VERSION) < 2)
{
return;
}
if (!pci_is_pcie_port(pdev))
{
return;
}
rt_pci_read_config_u16(pdev, pos + PCIER_LINK_CTL, &exp_lnkctl);
rt_pci_read_config_u16(pdev, pos + PCIER_LINK_CTL2, &exp_lnkctl2);
rt_pci_read_config_u16(pdev, pos + PCIER_LINK_STA, &exp_lnksta);
if (exp_lnksta & PCIEM_LINK_STA_DL_ACTIVE)
{
return;
}
rt_pci_write_config_u16(pdev, pos + PCIER_LINK_CTL2,
(exp_lnkctl2 & ~PCIEM_LNKCTL2_TLS) | PCIEM_LNKCTL2_TLS_2_5GT);
rt_pci_write_config_u16(pdev, pos + PCIER_LINK_CTL,
exp_lnkctl | PCIEM_LINK_CTL_RETRAIN_LINK);
for (int i = 0; i < 20; ++i)
{
rt_pci_read_config_u16(pdev, pos + PCIER_LINK_STA, &exp_lnksta);
if (!!(exp_lnksta & PCIEM_LINK_STA_DL_ACTIVE))
{
goto _status_sync;
}
rt_thread_mdelay(10);
}
/* Fail, restore */
rt_pci_write_config_u16(pdev, pos + PCIER_LINK_CTL2, exp_lnkctl2);
rt_pci_write_config_u16(pdev, pos + PCIER_LINK_CTL,
exp_lnkctl | PCIEM_LINK_CTL_RETRAIN_LINK);
_status_sync:
/* Wait a while for success or failure */
rt_thread_mdelay(100);
}
static rt_bool_t pci_needs_bridge_window(struct rt_pci_device *pdev)
{
if (!pdev)
{
return RT_FALSE;
}
if (pdev->hdr_type == PCIM_HDRTYPE_BRIDGE)
{
return RT_TRUE;
}
return pci_is_pcie_port(pdev);
}
static void pci_program_bridge_windows(struct rt_pci_device *bridge,
rt_uint64_t mem_start, rt_uint64_t mem_end,
rt_uint64_t pref_start, rt_uint64_t pref_end)
{
rt_uint32_t l;
rt_uint16_t cmd;
if (!bridge || !pci_needs_bridge_window(bridge))
{
return;
}
if (mem_start <= mem_end)
{
l = ((rt_uint32_t)(mem_start >> 16) & 0xfff0) | (rt_uint32_t)(mem_end & 0xfff00000);
rt_pci_write_config_u32(bridge, PCIR_MEMBASE_1, l);
}
else
{
rt_pci_write_config_u32(bridge, PCIR_MEMBASE_1, 0x0000fff0);
}
if (pref_start <= pref_end)
{
rt_uint32_t bu = 0, lu = 0;
rt_pci_write_config_u32(bridge, PCIR_PMLIMITH_1, 0);
l = ((rt_uint32_t)(pref_start >> 16) & 0xfff0) | (rt_uint32_t)(pref_end & 0xfff00000);
if (pref_end > 0xffffffffULL || pref_start > 0xffffffffULL)
{
bu = rt_upper_32_bits(pref_start);
lu = rt_upper_32_bits(pref_end);
}
rt_pci_write_config_u32(bridge, PCIR_PMBASEL_1, l);
rt_pci_write_config_u32(bridge, PCIR_PMBASEH_1, bu);
rt_pci_write_config_u32(bridge, PCIR_PMLIMITH_1, lu);
}
else
{
rt_pci_write_config_u32(bridge, PCIR_PMBASEL_1, 0x0000fff0);
rt_pci_write_config_u32(bridge, PCIR_PMBASEH_1, 0);
rt_pci_write_config_u32(bridge, PCIR_PMLIMITH_1, 0);
}
rt_pci_read_config_u16(bridge, PCIR_COMMAND, &cmd);
cmd |= PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN;
rt_pci_write_config_u16(bridge, PCIR_COMMAND, cmd);
}
static void pci_bridge_program_host_windows(struct rt_pci_device *bridge,
struct rt_pci_host_bridge *host_bridge)
{
rt_uint64_t mem_start = ~0ULL, mem_end = 0;
rt_uint64_t pref_start = ~0ULL, pref_end = 0;
if (!bridge || !host_bridge)
{
return;
}
for (int i = 0; i < host_bridge->bus_regions_nr; ++i)
{
rt_uint64_t start, end;
struct rt_pci_bus_region *region = &host_bridge->bus_regions[i];
start = region->phy_addr;
end = region->phy_addr + region->size - 1;
if (region->flags == PCI_BUS_REGION_F_PREFETCH)
{
if (start < pref_start)
{
pref_start = start;
}
if (end > pref_end)
{
pref_end = end;
}
}
else if (region->flags == PCI_BUS_REGION_F_MEM)
{
if (start < mem_start)
{
mem_start = start;
}
if (end > mem_end)
{
mem_end = end;
}
}
}
pci_program_bridge_windows(bridge, mem_start, mem_end, pref_start, pref_end);
}
static rt_uint32_t pci_scan_bridge_extend(struct rt_pci_bus *bus, struct rt_pci_device *pdev,
rt_uint32_t bus_no_start, rt_uint32_t buses, rt_bool_t reconfigured)
{
rt_bool_t fixed_buses;
rt_uint8_t fixed_sub, fixed_sec;
rt_uint8_t primary, secondary, subordinate;
rt_uint32_t value, bus_no = bus_no_start;
struct rt_pci_bus *next_bus;
struct rt_pci_host_bridge *host_bridge;
/* We not supported init CardBus, it always used in the PC servers. */
if (pdev->hdr_type == PCIM_HDRTYPE_CARDBUS)
{
LOG_E("CardBus is not supported in system");
goto _end;
}
rt_pci_read_config_u32(pdev, PCIR_PRIBUS_1, &value);
primary = value & 0xff;
secondary = (value >> 8) & 0xff;
subordinate = (value >> 16) & 0xff;
if (primary == bus->number && bus->number > secondary && secondary > subordinate)
{
if (!reconfigured)
{
goto _end;
}
LOG_I("Bridge configuration: primary(%02x) secondary(%02x) subordinate(%02x)",
primary, secondary, subordinate);
}
if (pdev->pcie_cap)
{
pcie_fixup_link(pdev);
}
++bus_no;
/* Count of subordinate */
buses -= !!buses;
host_bridge = rt_pci_find_host_bridge(bus);
RT_ASSERT(host_bridge != RT_NULL);
/* Clear errors */
rt_pci_write_config_u16(pdev, PCIR_STATUS, RT_UINT16_MAX);
fixed_buses = pci_ea_fixed_busnrs(pdev, &fixed_sec, &fixed_sub);
if (!(next_bus = pci_alloc_bus(bus)))
{
goto _end;
}
/* Clear bus info */
rt_pci_write_config_u32(pdev, PCIR_PRIBUS_1, value & ~0xffffff);
if (pci_child_bus_init(next_bus, bus_no, host_bridge, pdev))
{
goto _end;
}
spin_lock(&bus->lock);
rt_list_insert_before(&bus->children_nodes, &next_bus->list);
spin_unlock(&bus->lock);
/* Fill primary, secondary */
value = (buses & 0xff000000) | (bus->number << 0) | (next_bus->number << 8);
rt_pci_write_config_u32(pdev, PCIR_PRIBUS_1, value);
/*
* Open bridge MEM/prefetch windows to host ranges before downstream
* scan (BAR sizing/assign touches MMIO), then again after scan in
* case config writes disturbed the aperture.
*/
pci_bridge_program_host_windows(pdev, host_bridge);
bus_no = rt_pci_scan_child_buses(next_bus, buses);
pci_bridge_program_host_windows(pdev, host_bridge);
/* Fill subordinate */
value |= next_bus->number + rt_list_len(&next_bus->children_nodes);
rt_pci_write_config_u32(pdev, PCIR_PRIBUS_1, value);
if (fixed_buses)
{
bus_no = fixed_sub;
}
rt_pci_write_config_u8(pdev, PCIR_SUBBUS_1, bus_no);
_end:
return bus_no;
}
rt_uint32_t rt_pci_scan_bridge(struct rt_pci_bus *bus, struct rt_pci_device *pdev,
rt_uint32_t bus_no_start, rt_bool_t reconfigured)
{
if (!bus || !pdev)
{
return RT_UINT32_MAX;
}
return pci_scan_bridge_extend(bus, pdev, bus_no_start, 0, reconfigured);
}
rt_inline rt_bool_t only_one_child(struct rt_pci_bus *bus)
{
if (rt_pci_is_root_bus(bus))
{
return RT_FALSE;
}
return pci_is_pcie_port(bus->self);
}
static int next_fn(struct rt_pci_bus *bus, struct rt_pci_device *pdev, int fn)
{
if (!rt_pci_is_root_bus(bus) && bus->self->ari_enabled)
{
int pos, next_fn;
rt_uint16_t cap = 0;
if (!pdev)
{
return -RT_EINVAL;
}
pos = rt_pci_find_ext_capability(pdev, PCIZ_ARI);
if (!pos)
{
return -RT_EINVAL;
}
rt_pci_read_config_u16(pdev, pos + PCIR_ARI_CAP, &cap);
next_fn = PCIM_ARI_CAP_NFN(cap);
if (next_fn <= fn)
{
return -RT_EINVAL;
}
return next_fn;
}
if (fn >= RT_PCI_FUNCTION_MAX - 1)
{
return -RT_EINVAL;
}
if (pdev && !pdev->multi_function)
{
return -RT_EINVAL;
}
return fn + 1;
}
rt_size_t rt_pci_scan_slot(struct rt_pci_bus *bus, rt_uint32_t devfn)
{
rt_size_t nr = 0;
struct rt_pci_device *pdev = RT_NULL;
if (!bus)
{
return nr;
}
if (devfn > 0 && only_one_child(bus))
{
return nr;
}
for (int func = 0; func >= 0; func = next_fn(bus, pdev, func))
{
pdev = rt_pci_scan_single_device(bus, devfn + func);
if (pdev)
{
++nr;
if (func > 0)
{
pdev->multi_function = RT_TRUE;
}
}
else if (func == 0)
{
break;
}
}
return nr;
}
rt_uint32_t rt_pci_scan_child_buses(struct rt_pci_bus *bus, rt_size_t buses)
{
rt_uint32_t bus_no;
struct rt_pci_device *pdev = RT_NULL;
if (!bus)
{
bus_no = RT_UINT32_MAX;
goto _end;
}
bus_no = bus->number;
for (rt_uint32_t devfn = 0;
devfn < RT_PCI_DEVFN(RT_PCI_DEVICE_MAX - 1, RT_PCI_FUNCTION_MAX - 1);
devfn += RT_PCI_FUNCTION_MAX)
{
rt_pci_scan_slot(bus, devfn);
}
rt_pci_foreach_bridge(pdev, bus)
{
int offset;
bus_no = pci_scan_bridge_extend(bus, pdev, bus_no, buses, RT_TRUE);
offset = bus_no - bus->number;
if (buses > offset)
{
buses -= offset;
}
else
{
break;
}
}
_end:
return bus_no;
}
rt_uint32_t rt_pci_scan_child_bus(struct rt_pci_bus *bus)
{
return rt_pci_scan_child_buses(bus, 0);
}
static struct rt_pci_bus *pci_alloc_bus(struct rt_pci_bus *parent)
{
struct rt_pci_bus *bus = rt_calloc(1, sizeof(*bus));
if (!bus)
{
return RT_NULL;
}
bus->parent = parent;
rt_list_init(&bus->list);
rt_list_init(&bus->children_nodes);
rt_list_init(&bus->devices_nodes);
rt_spin_lock_init(&bus->lock);
return bus;
}
rt_err_t rt_pci_host_bridge_register(struct rt_pci_host_bridge *host_bridge)
{
struct rt_pci_bus *bus = pci_alloc_bus(RT_NULL);
if (!bus)
{
return -RT_ENOMEM;
}
host_bridge->root_bus = bus;
bus->sysdata = host_bridge->sysdata;
bus->host_bridge = host_bridge;
bus->ops = host_bridge->ops;
bus->number = host_bridge->bus_range[0];
rt_sprintf(bus->name, "%04x:%02x", host_bridge->domain, bus->number);
if (bus->ops->add)
{
rt_err_t err = bus->ops->add(bus);
if (err)
{
LOG_E("PCI-Bus<%s> add bus failed with err = %s", bus->name, rt_strerror(err));
}
}
return RT_EOK;
}
rt_err_t rt_pci_scan_root_bus_bridge(struct rt_pci_host_bridge *host_bridge)
{
rt_err_t err;
if ((err = rt_pci_host_bridge_register(host_bridge)))
{
return err;
}
rt_pci_scan_child_bus(host_bridge->root_bus);
return err;
}
rt_err_t rt_pci_host_bridge_probe(struct rt_pci_host_bridge *host_bridge)
{
rt_err_t err;
err = rt_pci_scan_root_bus_bridge(host_bridge);
return err;
}
static rt_bool_t pci_remove_bus_device(struct rt_pci_device *pdev, void *data)
{
/* Bus will free if this is the last device */
rt_bus_remove_device(&pdev->parent);
/* To find all devices, always return false */
return RT_FALSE;
}
rt_err_t rt_pci_host_bridge_remove(struct rt_pci_host_bridge *host_bridge)
{
if (!host_bridge)
{
return -RT_EINVAL;
}
if (host_bridge->root_bus)
{
rt_pci_enum_device(host_bridge->root_bus, pci_remove_bus_device, RT_NULL);
host_bridge->root_bus = RT_NULL;
}
if (host_bridge->domain != RT_UINT32_MAX)
{
rt_dm_ida_free(&pci_domain_ida, host_bridge->domain);
host_bridge->domain = RT_UINT32_MAX;
}
return RT_EOK;
}
rt_err_t rt_pci_bus_remove(struct rt_pci_bus *bus)
{
rt_err_t err = RT_EOK;
if (bus)
{
spin_lock(&bus->lock);
if (rt_list_isempty(&bus->children_nodes) &&
rt_list_isempty(&bus->devices_nodes))
{
rt_list_remove(&bus->list);
spin_unlock(&bus->lock);
if (bus->ops->remove)
{
bus->ops->remove(bus);
}
rt_pci_ofw_bus_free(bus);
rt_free(bus);
}
else
{
spin_unlock(&bus->lock);
err = -RT_EBUSY;
}
}
else
{
err = -RT_EINVAL;
}
return err;
}
rt_err_t rt_pci_device_remove(struct rt_pci_device *pdev)
{
rt_err_t err = RT_EOK;
if (pdev)
{
struct rt_pci_bus *bus = pdev->bus;
pci_procfs_detach(pdev);
spin_lock(&bus->lock);
while (pdev->parent.ref_count > 1)
{
spin_unlock(&bus->lock);
rt_thread_yield();
spin_lock(&bus->lock);
}
rt_list_remove(&pdev->list);
spin_unlock(&bus->lock);
rt_free(pdev);
}
else
{
err = -RT_EINVAL;
}
return err;
}