概念
PCI设备：遵循PCI规范，工作在PCI局部总线环境下的设备。PCI局部总线规范指出，每个PCI设备可以包含最多8个PCI功能，每个PCI功能是一个逻辑设备
PCI桥设备：由于电子负载限制，每条PCI总线上可以挂载的设备数目是有限的因此使用了一种特殊的设备，即PCI-PCI桥设备将两条独立的PCI总线连接起来，PCI-PCI桥设备简称PCI桥
主桥设备：和CPU以及内存连在一起的Host-PCI桥设备为主桥设备，主桥设备引出的总线也称为PCI根总线。
通讯：PCI设备也有自己内存空间和IO空间，这些空间被映射到CPU的内存空间和IO空间，在映射之后，PCI设备上的物理资源“变成”了CPU的本地资源
配置
每个PCI桥设备在接收到配置事务后，判断配置目标是否在它的下游总线。若不是，则忽略该事务；若在它引出的总线上，则在这条局部总线上广播事务，否则向下游传播。而每个PCI事务决定是否认领这个配置事务，通常最终会有一个PCI设备会对这个配置事务做出响应
配置事务的一般布局
通过在IO地址空间特定寄存器写总线，设备号，功能，字节号，数据
static int falcon_pcie_hw_wr_cfg(struct falcon_pcie_port *port, u32 bus, u32 devfn,
int where, int size, u32 *val)
{
int ret;
u32 value;
mutex_lock(&port->lock);
if (PCI_FUNC(devfn) == 0) {
if (bus == 1) {
if ((where != CFG_BAR0_REG) && (where != CFG_BAR1_REG)) {
value = readl(port->base + PCIE_CFGNUM);
writel((value|(0x1<<8)), port->base + PCIE_CFGNUM);
ret = cfg_write(port->base + FALCON_PCIE_CONFIG_OFFSET
+ (where & ~0x3), where, size, val);
}
} else if (bus == 0){
/* avoid CFG_BAR0_REG/CFG_BAR1_REG to be overwritten later */
if ((where != CFG_BAR0_REG) && (where != CFG_BAR1_REG)) {
value = readl(port->base + PCIE_CFGNUM);
writel((value&(~(0x1<<8))), port->base + PCIE_CFGNUM);
ret = cfg_write(port->base + FALCON_PCIE_CONFIG_OFFSET
+ (where & ~0x3), where, size, val);
}
}
}
mutex_unlock(&port->lock);
return ret;
}linux的通用配置接口位于drivers/pci/access.c
#define PCI_OP_READ(size, type, len) \
int noinline pci_bus_read_config_##size \
(struct pci_bus *bus, unsigned int devfn, int pos, type *value) \
{ \
int res; \
unsigned long flags; \
u32 data = 0; \
if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \
pci_lock_config(flags); \
res = bus->ops->read(bus, devfn, pos, len, &data); \
*value = (type)data; \
pci_unlock_config(flags); \
return res; \
}
#define PCI_OP_WRITE(size, type, len) \
int noinline pci_bus_write_config_##size \
(struct pci_bus *bus, unsigned int devfn, int pos, type value) \
{ \
int res; \
unsigned long flags; \
if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \
pci_lock_config(flags); \
res = bus->ops->write(bus, devfn, pos, len, value); \
pci_unlock_config(flags); \
return res; \
}
PCI_OP_READ(byte, u8, 1)
PCI_OP_READ(word, u16, 2)
PCI_OP_READ(dword, u32, 4)
PCI_OP_WRITE(byte, u8, 1)
PCI_OP_WRITE(word, u16, 2)
PCI_OP_WRITE(dword, u32, 4)
EXPORT_SYMBOL(pci_bus_read_config_byte);
EXPORT_SYMBOL(pci_bus_read_config_word);
EXPORT_SYMBOL(pci_bus_read_config_dword);
EXPORT_SYMBOL(pci_bus_write_config_byte);
EXPORT_SYMBOL(pci_bus_write_config_word);
EXPORT_SYMBOL(pci_bus_write_config_dword);主机驱动
探测函数
直接看探测函数的主要功能如下：
pci_host_bridge_priv将平台相关数据，填充到主机桥的private成员；
platform_set_drvdata再将平台相关数据，填充到device的driver_data成员
devm_pinctrl_get_select_default设置pinctrl为默认状态的设备树节点
pm_qos_add_request设定该控制器对性能的期望
device_init_wakeup将该设备设置成唤醒源，休眠的时候，会将该设备的中断使能唤醒功能
pci_host_probe注册pci主机
device_create_file给设备创建属性文件
static int pcie_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct falcon_pcie *pcie;
struct pci_host_bridge *host;
int err;
host = devm_pci_alloc_host_bridge(dev, sizeof(*pcie));
if (!host)
return -ENOMEM;
pcie = pci_host_bridge_priv(host);
pcie->dev = dev;
pcie->soc = of_device_get_match_data(dev);
devm_pinctrl_get_select_default(dev);
err = falcon_pcie_setup(pcie);
if (err)
return -ENODEV;
platform_set_drvdata(pdev, pcie);
host->busnr = pcie->busnr;
host->dev.parent = pcie->dev;
host->ops = pcie->soc->ops;
host->map_irq = of_irq_parse_and_map_pci;
host->swizzle_irq = pci_common_swizzle;
host->sysdata = pcie;
pcie->host = host;
pm_qos_add_request(&pcie->qos_idle, PM_QOS_CPUIDLE_BLOCK,
PM_QOS_CPUIDLE_BLOCK_DEFAULT_VALUE);
pcie->qos_idle.name = pdev->name;
device_init_wakeup(&pdev->dev, 1);
err = pci_host_probe(host);
pm_qos_update_request(&pcie->qos_idle, pcie->port->lpm_qos);
device_create_file(&pdev->dev, &dev_attr_pwr_ctrl);
if (err)
goto put_resources;
return 0;
put_resources:
falcon_pcie_put_resources(pcie);
return err;
}
static struct platform_driver pcie_driver = {
.probe = falcon_pcie_probe,
.remove = falcon_pcie_remove,
.driver = {
.name = "pcie-test",
.of_match_table = pcie_ids,
.suppress_bind_attrs = true,
.pm = &falcon_pcie_pm_ops,
},
};
/* Falcon PCIe driver does not allow module unload */
static int __init falcon_pcie_init(void)
{
return platform_driver_probe(&falcon_pcie_driver, falcon_pcie_probe);
}
device_initcall_sync(falcon_pcie_init);
//module_platform_driver(falcon_pcie_driver);platform_driver_probe
看下面注释和代码：设备注册要先于驱动注册；只做一次探测，不支持延迟探测；一般用于soc的控制器驱动
/**
* __platform_driver_probe - register driver for non-hotpluggable device
* @drv: platform driver structure
* @probe: the driver probe routine, probably from an __init section
* @module: module which will be the owner of the driver
*
* Use this instead of platform_driver_register() when you know the device
* is not hotpluggable and has already been registered, and you want to
* remove its run-once probe() infrastructure from memory after the driver
* has bound to the device.
*
* One typical use for this would be with drivers for controllers integrated
* into system-on-chip processors, where the controller devices have been
* configured as part of board setup.
*
* Note that this is incompatible with deferred probing.
*
* Returns zero if the driver registered and bound to a device, else returns
* a negative error code and with the driver not registered.
*/
int __init_or_module __platform_driver_probe(struct platform_driver *drv,
int (*probe)(struct platform_device *), struct module *module)
{
int retval, code;
if (drv->driver.probe_type == PROBE_PREFER_ASYNCHRONOUS) {
pr_err("%s: drivers registered with %s can not be probed asynchronously\n",
drv->driver.name, __func__);
return -EINVAL;
}
/*
* We have to run our probes synchronously because we check if
* we find any devices to bind to and exit with error if there
* are any.
*/
drv->driver.probe_type = PROBE_FORCE_SYNCHRONOUS;
/*
* Prevent driver from requesting probe deferral to avoid further
* futile probe attempts.
*/
drv->prevent_deferred_probe = true;
/* make sure driver won't have bind/unbind attributes */
drv->driver.suppress_bind_attrs = true;
/* temporary section violation during probe() */
drv->probe = probe;
retval = code = __platform_driver_register(drv, module);
if (retval)
return retval;
/*
* Fixup that section violation, being paranoid about code scanning
* the list of drivers in order to probe new devices. Check to see
* if the probe was successful, and make sure any forced probes of
* new devices fail.
*/
spin_lock(&drv->driver.bus->p->klist_drivers.k_lock);
drv->probe = NULL;
if (code == 0 && list_empty(&drv->driver.p->klist_devices.k_list))
retval = -ENODEV;
drv->driver.probe = platform_drv_probe_fail;
spin_unlock(&drv->driver.bus->p->klist_drivers.k_lock);
if (code != retval)
platform_driver_unregister(drv);
return retval;
}
EXPORT_SYMBOL_GPL(__platform_driver_probe);pci_host_probe
主机去注册一个主机桥设备和bus 0；然后从这个bus递归扫描设备
pci_host_probe(bridge)
pci_scan_root_bus_bridge
pci_register_host_bridge
pci_alloc_bus
device_add(&bridge->dev); // 添加device(host bridge)
pcibios_add_bus(bus) // 添加bus (local bus 0)
pci_scan_child_bus/pci_scan_child_bus_extend(bus,0)
bus = bridge->bus;
pci_bus_add_devices(bus);pci_scan_child_bus_extend
先扫描普通设备，扫描就根据设备的配置空间来配置和添加设备；
再扫描桥，扫描到就添加总线。然后继续递归扫描。
pci_scan_child_bus_extend
for (devfn = 0; devfn < 256; devfn += 8) // 针对每个device
nr_devs = pci_scan_slot(bus, devfn);
for (fn = 1; fn < 8; fn++) { // 针对每个function
pci_scan_single_device(bus, devfn + fn); // 对一个function 枚举
struct pci_dev *dev = pci_scan_device // 通过配置空间来枚举设备
struct pci_dev *dev = pci_alloc_dev(bus);
dev->devfn = devfn;
pci_setup_device(dev) // 修改基址、数据寄存器，实际下发配置修改
pci_device_add(dev) // 添加 device(pci bridge或者普通pci设备)
pci_scan_bridge_extend
pci_add_new_bus // 添加 pci bus
pci_scan_child_bus_extend
