linux PCI设备初始化过程
start_kernel->rest_init 这个函数会启动一个核心线程0, 核心线程然后调用init -> do_basic_setup.
然后我们开始看下面的过程
void __init driver_init(void)
{
devices_init();
buses_init();
classes_init();
......
platform_bus_init();
system_bus_init();
......
}
//在drivers/base/core.c
int __init devices_init(void)
{
return subsystem_register(&devices_subsys);
}
我们还看到
decl_subsys(devices, &ktype_device, &device_uevent_ops);
//在kobject.h中
#define decl_subsys(_name,_type,_uevent_ops) \
struct subsystem _name##_subsys = { \
.kset = { \
.kobj = { .name = __stringify(_name) }, \
.ktype = _type, \
.uevent_ops =_uevent_ops, \
} \
}
下面我们看
int subsystem_register(struct subsystem * s)
{
......
subsystem_init(s);
......
if (!(error = kset_add(&s->kset))) {
if (!s->kset.subsys)
s->kset.subsys = s; //指向自己
}
......
}
在subsystem_init中会调用kset_init(&s->kset)在这函数中又主要调用kobject_init(&k->kobj) 这中又kobj->kset = kset_get(kobj->kset);
static inline struct kset * kset_get(struct kset * k)
{
return k ? to_kset(kobject_get(&k->kobj)) : NULL;
}
那么kobj->kset 应该是NULL.
接着
int kset_add(struct kset * k)
{
//现在k->subsys 也是NULL
if (!k->kobj.parent && !k->kobj.kset && k->subsys)
k->kobj.parent = &k->subsys->kset.kobj;
return kobject_add(&k->kobj);
}
在接着
int kobject_add(struct kobject * kobj)
{
......
// 这时是 NULL
parent = kobject_get(kobj->parent);
......
if (kobj->kset) {
......
if (!parent)
parent = kobject_get(&kobj->kset->kobj); //父节点是这个kobject属于的那个kset
list_add_tail(&kobj->entry, &kobj->kset->list); //添加到kset中
......
}
kobj->parent = parent; //指向他属于的那个kset中的kobject, 如果这个kobject在一个kset中
//在sysfs中创建目录
error = create_dir(kobj);
......
}
现在我们了解了子系统注册过程，其他的就容易多了.
int __init buses_init(void)
{
return subsystem_register(&bus_subsys);
}
int __init classes_init(void)
{
......
retval = subsystem_register(&class_subsys);
......
//class_obj_subsys没有在sysfs中显示
subsystem_init(&class_obj_subsys);
if (!class_obj_subsys.kset.subsys)
class_obj_subsys.kset.subsys = &class_obj_subsys;
return ;
}
这个有些不同，我们来看看
int __init platform_bus_init(void)
{
device_register(&platform_bus);
return bus_register(&platform_bus_type);
}
定义
struct device platform_bus = {
.bus_id = "platform",
};
struct bus_type platform_bus_type = {
.name = "platform",
.dev_attrs = platform_dev_attrs,
.match = platform_match,
.uevent = platform_uevent,
.suspend = platform_suspend,
.resume = platform_resume,
};
上面的函数以后如果用到我们会在看.接下来我们继续
int device_register(struct device *dev)
{
device_initialize(dev);
return device_add(dev);
}
void device_initialize(struct device *dev)
{
//定义在kobject.h中
//#define kobj_set_kset_s(obj,subsys) (obj)->kobj.kset = &(subsys).kset
//那么这个设备是在devices_subsys中
kobj_set_kset_s(dev, devices_subsys);
//初始化设备中的kobject
kobject_init(&dev->kobj);
klist_init(&dev->klist_children, klist_children_get, klist_children_put);
}
int device_add(struct device *dev)
{
......
//增加引用计数
dev = get_device(dev);
......
//copy 名字到 kobject 的 name 中
kobject_set_name(&dev->kobj, "%s", dev->bus_id);
......
if ((error = kobject_add(&dev->kobj)))
goto Error;
......
}
下面我们看总线注册.
struct bus_type {
const char * name;
struct subsystem subsys;
......
};
int bus_register(struct bus_type * bus)
{
......
//设置名字
retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
......
//在kobject.h中定义了
// #define subsys_set_kset(obj,_subsys) (obj)->subsys.kset.kobj.kset = &(_subsys).kset
subsys_set_kset(bus, bus_subsys);
//注册这个总线类型中的子系统
retval = subsystem_register(&bus->subsys);
......
//bus中的devices是个kset
kobject_set_name(&bus->devices.kobj, "devices");
bus->devices.subsys = &bus->subsys; //指向总线类型的子系统
retval = kset_register(&bus->devices); //注册kset
......
kobject_set_name(&bus->drivers.kobj, "drivers");
bus->drivers.subsys = &bus->subsys;
bus->drivers.ktype = &ktype_driver; //类型初始化
retval = kset_register(&bus->drivers);
......
//添加属性，属性在sysfs中被作为文件描述
bus_add_attrs(bus);
......
}
我们继续
int __init system_bus_init(void)
{
//这个subsys的parent是devices_subsys的kobj,所以他应该在devices目录下面
system_subsys.kset.kobj.parent = &devices_subsys.kset.kobj;
return subsystem_register(&system_subsys);
}
现在我们看完了的driver_init();中的大多数初始化过程，下面会调用do_initcalls();这个函数会调用module_init等编译的函数，如果不明白看module_init的说明。
下面我们看pci的注册。
struct bus_type pci_bus_type = {
.name = "pci",
.match = pci_bus_match,
.uevent = pci_uevent,
.probe = pci_device_probe,
.remove = pci_device_remove,
.suspend = pci_device_suspend,
.shutdown = pci_device_shutdown,
.resume = pci_device_resume,
.dev_attrs = pci_dev_attrs,
};
static int __init pci_driver_init(void)
{
//pci总线类型也会被添加到bus目录下，上面有为什么.
return bus_register(&pci_bus_type);
}
postcore_initcall(pci_driver_init); //调用优先级高
下一个优先级就是
static __init int pci_access_init(void)
{
......
//会打印 "PCI: PCI BIOS revision ..."
pci_pcbios_init();
......
//会打印 "PCI: Using configuration ..."
pci_direct_init();
......
}
arch_initcall(pci_access_init);//比上面那个还要高
void __init pci_direct_init(void)
{
......
//在 kernel/resource.c
/*struct resource ioport_resource = {
.name = "PCI IO",
.start = 0,
.end = IO_SPACE_LIMIT,
.flags = IORESOURCE_IO,
};
中获取io资源范围，如果成功会把新的范围添加到上面的数据结构中*/
region = request_region(0xCF8, , "PCI conf1");
......
//作一些具体的检测，向io端口查询相关信息
if (pci_check_type1()) {
......
raw_pci_ops = &pci_direct_conf1;
return; //ok
}
......
}
下面到了
//很简单 会打印 "Setting up standard PCI resources" arch/i386/kernel/setup.c
static int __init request_standard_resources(void);
继续
static int __init pci_legacy_init(void)
{
......
pci_root_bus = pcibios_scan_root();
//pci 枚举已经完成
if (pci_root_bus)
pci_bus_add_devices(pci_root_bus);
//寻找剩余的总线，万一有一个主机桥总线
pcibios_fixup_peer_bridges(); //自己看吧，很间单
return ;
}
首先
struct pci_bus * __devinit pcibios_scan_root(int busnum)
{
......
//根据总线号查找总线
while ((bus = pci_find_next_bus(bus)) != NULL) {
if (bus->number == busnum) {
......
}
}
......
return pci_scan_bus_parented(NULL, busnum, &pci_root_ops, NULL);
}
//arch/i386/pci/common.c
struct pci_ops pci_root_ops = {
.read = pci_read,
.write = pci_write,
};
struct pci_bus * __devinit pci_scan_bus_parented(struct device *parent, int bus, struct pci_ops *ops, void *sysdata)
{
......
//创建一个pci总线
b = pci_create_bus(parent, bus, ops, sysdata);
if (b)
b->subordinate = pci_scan_child_bus(b); //最大总线号
return b;
}
struct pci_bus * __devinit pci_create_bus(struct device *parent, int bus, struct pci_ops *ops, void *sysdata)
{
......
struct pci_bus *b;
struct device *dev;
分配pci总线数据结构
b = pci_alloc_bus();
......
//分配设备文件
dev = kmalloc(sizeof(*dev), GFP_KERNEL);
......
b->sysdata = sysdata;
b->ops = ops; //总线操作
//查找是否存在同一总线
if (pci_find_bus(pci_domain_nr(b), bus)) {
......
}
......
//添加这个总线到全局队列中
list_add_tail(&b->node, &pci_root_buses);
......
//bus_id中应该是pci0000:00
sprintf(dev->bus_id, "pci%04x:%02x", pci_domain_nr(b), bus);
error = device_register(dev);
......
//是一个桥设备
b->bridge = get_device(dev);
//pcibus_class 在 driver/pci/probe.c 中已经注册
b->class_dev.class = &pcibus_class;
//0000:00
sprintf(b->class_dev.class_id, "%04x:%02x", pci_domain_nr(b), bus);
//添加这个class device到
error = class_device_register(&b->class_dev);
......
//在这个目录下 0000:00创建一个属性文件 cpuaffinity
error = class_device_create_file(&b->class_dev, &class_device_attr_cpuaffinity);
......
//创建一个软连接到pci0000:00 上面我们已经看到
error = sysfs_create_link(&b->class_dev.kobj, &b->bridge->kobj, "bridge");
......
b->number = b->secondary = bus; //
b->resource[] = &ioport_resource;
b->resource[] = &iomem_resource;
return b;
......
}
下面我们看扫描
unsigned int __devinit pci_scan_child_bus(struct pci_bus *bus)
{
//max = 0
unsigned int devfn, pass, max = bus->secondary;
......
for (devfn = ; devfn < 0x100; devfn += )
pci_scan_slot(bus, devfn);
......
//读取桥的资源
pcibios_fixup_bus(bus);
//扫描完成根总线的所有设备了
//下面进一步扫描桥上的设备
for (pass=; pass < ; pass++)
list_for_each_entry(dev, &bus->devices, bus_list) {
//如果是桥设备
if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
max = pci_scan_bridge(bus, dev, max, pass); //看下面
}
......
}
//扫描pci插槽
int __devinit pci_scan_slot(struct pci_bus *bus, int devfn)
{
......
for (func = ; func < ; func++, devfn++) {
struct pci_dev *dev;
dev = pci_scan_single_device(bus, devfn);
......
}
......
}
struct pci_dev * __devinit pci_scan_single_device(struct pci_bus *bus, int devfn)
{
......
dev = pci_scan_device(bus, devfn);
......
pci_device_add(dev, bus);
pci_scan_msi_device(dev); // ?
......
}
//查找设备
//首先看一看 driver/pci/access.c 中
#define PCI_OP_READ(size,type,len) \
int pci_bus_read_config_##size \
(struct pci_bus *bus, unsigned int devfn, int pos, type *value) \
{ \
int res; \
unsigned long flags; \
u32 data = ; \
if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER; \
spin_lock_irqsave(&pci_lock, flags); \
res = bus->ops->read(bus, devfn, pos, len, &data); \
*value = (type)data; \
spin_unlock_irqrestore(&pci_lock, flags); \
return res; \
}
//上面列的不全，去看文件吧
static struct pci_dev * __devinit pci_scan_device(struct pci_bus *bus, int devfn)
{
......
if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
return NULL;
......
//重试
while (l == 0xffff0001) {
......
if (pci_bus_read_config_dword(bus, devfn, PCI_VENDOR_ID, &l))
......
}
//读类型
if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type))
return NULL;
dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL);
dev->bus = bus;
dev->sysdata = bus->sysdata;
//struct pci_dev 中嵌入了一个 struct device dev;
dev->dev.parent = bus->bridge; //设备的父指针是pci_bus->device设备
dev->dev.bus = &pci_bus_type; //设备的总线类型
dev->devfn = devfn;
dev->hdr_type = hdr_type & 0x7f;
dev->multifunction = !!(hdr_type & 0x80); //
dev->vendor = l & 0xffff;
dev->device = (l >> ) & 0xffff;
dev->cfg_size = pci_cfg_space_size(dev); //读取设备配置空间大小
dev->error_state = pci_channel_io_normal;
dev->dma_mask = 0xffffffff;
//初始化设备资源
if (pci_setup_device(dev) < ) {
......
｝
return dev;
}
static int pci_setup_device(struct pci_dev * dev)
{
......
switch (dev->hdr_type) { /* header type */
case PCI_HEADER_TYPE_NORMAL: /* standard header */
if (class == PCI_CLASS_BRIDGE_PCI)
goto bad;
pci_read_irq(dev); //读取irq
pci_read_bases(dev, , PCI_ROM_ADDRESS); //一会看这个
pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &dev->subsystem_vendor);
pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &dev->subsystem_device);
break;
......
}
......
}
static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
{
......
for(pos=; pos<howmany; pos = next) {
......
res = &dev->resource[pos]; //资源一个个配置
//读取一些信息
......
if ((l & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_MEMORY) { //io内存空间
//调整空间大小
sz = pci_size(l, sz, (u32)PCI_BASE_ADDRESS_MEM_MASK);
if (!sz)
continue;
res->start = l & PCI_BASE_ADDRESS_MEM_MASK; //资源开始
res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
} else {
// io 端口空间，与内存空间类似
......
}
res->end = res->start + (unsigned long) sz;
res->flags |= pci_calc_resource_flags(l);
......
//这还有处理64位地址，略.
}
if (rom) {
dev->rom_base_reg = rom;
res = &dev->resource[PCI_ROM_RESOURCE]; //第6项
...... //差不多一样和上面
}
}
到这我们扫描到了一个设备，也进行了初始化，下面就是
void __devinit pci_device_add(struct pci_dev *dev, struct pci_bus *bus)
{
device_initialize(&dev->dev);
......
//添加到队列中
list_add_tail(&dev->bus_list, &bus->devices);
......
}
//进一步扫描桥设备
int __devinit pci_scan_bridge(struct pci_bus *bus, struct pci_dev * dev, int max, int pass)
{
.....
//总线已经被bios设置好了
if ((buses & 0xffff00) && !pcibios_assign_all_busses() && !is_cardbus) {
if (pass) //第二次
goto out;
......
//已经存在
if (pci_find_bus(pci_domain_nr(bus), busnr)) {
goto out;
}
//不存在分配一个新总线
child = pci_add_new_bus(bus, dev, busnr);
......
//看，又到这了，在这个总线上继续扫描设备或其他总线
cmax = pci_scan_child_bus(child);
......
} else { //总线还没有被设置，会初始化这个总线
if (!pass) { //第一次
......
goto out;
}
......
child = pci_add_new_bus(bus, dev, ++max);
......
if (!is_cardbus) {
max = pci_scan_child_bus(child); //又看到了
} else {
......
}
......
}
......
}
struct pci_bus * __devinit pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev, int busnr)
{
......
child = pci_alloc_child_bus(parent, dev, busnr);
......
list_add_tail(&child->node, &parent->children); //添加到队列中
......
}
static struct pci_bus * __devinit pci_alloc_child_bus(struct pci_bus *parent, struct pci_dev *bridge, int busnr)
{
......
child = pci_alloc_bus();
......
child->self = bridge; //总线自己的设备描述
child->parent = parent;
child->ops = parent->ops;
child->sysdata = parent->sysdata;
child->bus_flags = parent->bus_flags;
child->bridge = get_device(&bridge->dev); //桥也是自己设备pci_dev->device
child->class_dev.class = &pcibus_class; //也是pcibus_class
sprintf(child->class_dev.class_id, "%04x:%02x", pci_domain_nr(child), busnr);
class_device_register(&child->class_dev);
class_device_create_file(&child->class_dev, &class_device_attr_cpuaffinity);
child->number = child->secondary = busnr; //总线号初始化
child->primary = parent->secondary;
child->subordinate = 0xff;
for (i = ; i < ; i++) { //资源初始化 PCI_BRIDGE_RESOURCES ( i386 is 7)
child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
child->resource[i]->name = child->name;
}
bridge->subordinate = child;
return child;
}
现在pci枚举全部完成，到了添加这些设备了
pci_legacy_init ->
void __devinit pci_bus_add_devices(struct pci_bus *bus)
{
......
//遍历总线上的每个设备
list_for_each_entry(dev, &bus->devices, bus_list) {
if (!list_empty(&dev->global_list)) //已经添加
continue;
pci_bus_add_device(dev);
}
list_for_each_entry(dev, &bus->devices, bus_list) {
......
//如果是一个桥设备
if (dev->subordinate) {
if (list_empty(&dev->subordinate->node)) { //这个桥是独立的
......
list_add_tail(&dev->subordinate->node, &dev->bus->children); //添加这个总线到上一级总线队列中
......
}
pci_bus_add_devices(dev->subordinate); //递归调用
//创建连接
sysfs_create_link(&dev->subordinate->class_dev.kobj, &dev->dev.kobj, "bridge");
}
}
}
void __devinit pci_bus_add_device(struct pci_dev *dev)
{
device_add(&dev->dev);
......
list_add_tail(&dev->global_list, &pci_devices); //添加到全局连表
......
}
到此我们全部看完了pci_legacy_init()，也就是pci全部设备枚举与初始化过程，但是你可能想到设备中的struct resource还没有被请求，下面我们就继续看这部分.
这是在pcibios_init(void) -> void __init pcibios_resource_survey(void)中
void __init pcibios_resource_survey(void) //arch/i386/pci/i386.c
{
pcibios_allocate_bus_resources(&pci_root_buses);
pcibios_allocate_resources();
pcibios_allocate_resources();
}
我们还是一个一个看.
static void __init pcibios_allocate_bus_resources(struct list_head *bus_list)
{
......
//查询所有pci总线
list_for_each_entry(bus, bus_list, node) {
if ((dev = bus->self)) {
for (idx = PCI_BRIDGE_RESOURCES; idx < PCI_NUM_RESOURCES; idx++) {
......
r = &dev->resource[idx];
......
//找到包含这个资源的父节点，也就是看总线资源是否包含这个资源
pr = pci_find_parent_resource(dev, r);
//如果有任何错误
if (!r->start || !pr || request_resource(pr, r) < ) {
......
r->flag = ;
}
}
}
pcibios_allocate_bus_resources(&bus->children); //递归调用
}
}
下面看
static void __init pcibios_allocate_resources(int pass) //参数 一次是0, 一次是1
{
......
for_each_pci_dev(dev) { //遍历所有设备
pci_read_config_word(dev, PCI_COMMAND, &command);
for(idx = ; idx < ; idx++) {
......
if (pass == disabled) {
pr = pci_find_parent_resource(dev, r);
if (!pr || request_resource(pr, r) < ) { //如果有错误
......
}
}
if (!pass) {
r = &dev->resource[PCI_ROM_RESOURCE]; //处理这种资源
......
}
}
}
}
看到这里我们可以总结一下了.
所有的 struct class 注册到 class_subsys下
所有的 struct class_device 注册到相应的 class 下
所有的 struct device 注册到 device_subsys 下
所有的 *_sub_type 注册到 bus_subsys 下
任何类型的 *_subsys是*别的对象了，都会在/sys/下展现.
pci_root_buses是所有pci总线连表的头，pci_devices是所有pci设备连表的头.
//还可以继续
fs_initcall(pcibios_assign_resources);