rt-thread/components/drivers/pci/probe.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>

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);
    }

    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;
    }

    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));

    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 void pcie_fixup_link(struct rt_pci_device *pdev)
{
    int pos = pdev->pcie_cap;
    rt_uint16_t exp_lnkctl, exp_lnkctl2, exp_lnksta;
    rt_uint16_t exp_type = pdev->exp_flags & PCIEM_FLAGS_TYPE;

    if ((pdev->exp_flags & PCIEM_FLAGS_VERSION) < 2)
    {
        return;
    }

    if (exp_type != PCIEM_TYPE_ROOT_PORT &&
        exp_type != PCIEM_TYPE_DOWNSTREAM_PORT &&
        exp_type != PCIEM_TYPE_PCIE_BRIDGE)
    {
        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_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_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 (!(next_bus = pci_alloc_bus(bus)))
    {
        LOG_E("Alloc bus(%02x) fail", bus_no);
        goto _end;
    }

    if (pci_child_bus_init(next_bus, bus_no, host_bridge, pdev))
    {
        goto _end;
    }

    /* Fill primary, secondary */
    value = (buses & 0xff000000) | (bus->number << 0) | (next_bus->number << 8);
    rt_pci_write_config_u32(pdev, PCIR_PRIBUS_1, value);

    bus_no = rt_pci_scan_child_buses(next_bus, buses);

    /* 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)
{
    struct rt_pci_device *pdev;

    if (rt_pci_is_root_bus(bus))
    {
        return RT_FALSE;
    }

    pdev = bus->self;

    if (rt_pci_is_pcie(pdev))
    {
        rt_uint16_t exp_type = pdev->exp_flags & PCIEM_FLAGS_TYPE;

        if (exp_type == PCIEM_TYPE_ROOT_PORT ||
            exp_type == PCIEM_TYPE_DOWNSTREAM_PORT ||
            exp_type == PCIEM_TYPE_PCIE_BRIDGE)
        {
            return RT_TRUE;
        }
    }

    return RT_FALSE;
}

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)
{
    rt_err_t err = RT_EOK;

    if (host_bridge && host_bridge->root_bus)
    {
        rt_pci_enum_device(host_bridge->root_bus, pci_remove_bus_device, RT_NULL);
        host_bridge->root_bus = RT_NULL;
    }
    else
    {
        err = -RT_EINVAL;
    }

    return err;
}

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;

        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;
}