dahdi wctdm24xxp 驱动学习笔记
wctdm24xxp.c
//wctdm24xxp 驱动学习笔记
static struct pci_driver wctdm_driver = {
.name = "wctdm24xxp",
.probe = wctdm_init_one,
.remove = __devexit_p(wctdm_remove_one),
.shutdown = wctdm_shutdown,
.suspend = wctdm_suspend,
.id_table = wctdm_pci_tbl,
};
module_init(wctdm_init);
//驱动注册过程
wctdm_init
-> res = dahdi_pci_module(&wctdm_driver);
-> pci_register_driver(&wctdm_driver);
-> __pci_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
-> drv->driver.name = drv->name; // drv->driver 是struct device_driver 结构
drv->driver.bus = &pci_bus_type; // [1] bus里的match后面会用到
drv->driver.owner = owner;
drv->driver.mod_name = mod_name; // [2]
return driver_register(&drv->driver);
-> ret = bus_add_driver(drv);
-> error = driver_attach(drv);
-> return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
-> __driver_attach
-> if (!driver_match_device(drv, dev)) return 0
-> return drv->bus->match ? drv->bus->match(dev, drv) : 1;
-> if (!dev->driver) driver_probe_device(drv, dev);
-> ret = really_probe(dev, drv);
-> if (dev->bus->probe) { //如果dev->bus里定义了probe函数，则用 dev->bus->probe
ret = dev->bus->probe(dev);
if (ret)
goto probe_failed;
} else if (drv->probe) { //否则 看是否定义了drv->probe; 从上面[2]可以看出此处没有定义
ret = drv->probe(dev);
if (ret)
goto probe_failed;
}
-> 展开dev->bus->probe 先看pci_bus_type
struct bus_type pci_bus_type = {
.name = "pci",
.match = pci_bus_match,
.uevent = pci_uevent,
.probe = pci_device_probe,
.remove = pci_device_remove,
.shutdown = pci_device_shutdown,
.dev_groups = pci_dev_groups,
.bus_groups = pci_bus_groups,
.drv_groups = pci_drv_groups,
.pm = PCI_PM_OPS_PTR,
};
pci_device_probe(struct device *dev)
-> error = __pci_device_probe(drv, pci_dev);
-> error = pci_call_probe(drv, pci_dev, id);
-> error = local_pci_probe(&ddi);
-> rc = pci_drv->probe(pci_dev, ddi->id); // pci_drv 是struct pci_driver 结构
-> 也就是最终调用的是wctdm_driver.probe
// PCI 设备注册过程
struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn) //(drivers/pci/probe.c)
{
struct pci_dev *dev;
dev = pci_get_slot(bus, devfn);
if (dev) {
pci_dev_put(dev);
return dev;
}
dev = pci_scan_device(bus, devfn);
if (!dev)
return NULL;
pci_device_add(dev, bus);
return dev;
}
-> pci_device_add(dev, bus);
-> ret = device_add(&dev->dev);
-> bus_probe_device(dev);
-> ret = device_attach(dev);
-> ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
-> __device_attach
-> return driver_probe_device(drv, dev);
-> ret = really_probe(dev, drv);
-> ret = dev->bus->probe(dev);
-> 到这里和前面一样了
//probe 函数分悉
.probe = wctdm_init_one
-> return __wctdm_init_one(pdev, ent);
-> pci_set_drvdata(pdev, wc); // 将wc结构关联到pci_dev中
wc->vb.pdev = pdev;
ret = voicebus_init(&wc->vb, wc->board_name); //voicebus_init
create_sysfs_files(wc); //
voicebus_start(&wc->vb); //
wctdm_init_span(wc, curspan, curchan, wc->desc->ports, 0, pos);//wctdm24xxp_analog_span_ops 在里面引用
-> wctdm_init_chan()
wc->ddev = dahdi_create_device(); // 这里ddev包含一个新的struct device dev
dahdi_register_device(wc->ddev, &wc->vb.pdev->dev)
-> ret = _dahdi_register_device(ddev, parent);
-> ret = dahdi_sysfs_add_device(ddev, parent);
-> struct device *const dev = &ddev->dev;
dev->parent = parent;
dev->bus = &dahdi_device_bus; //[3]
ret = device_add(dev); //这个是ddev->dev 也就是wc->ddev->dev
-> 之后跟上面基本一样，不过这里dev->bus->probe 没有定义,drv也应该没有，所以不会再probe
static struct bus_type dahdi_device_bus = {
.name = "dahdi_devices",
.uevent = device_uevent,
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 13, 0)
.dev_attrs = dahdi_device_attrs,
#else
.dev_groups = dahdi_device_groups,
#endif
-> list_for_each_entry(s, &ddev->spans, device_node)
ret = _dahdi_assign_span(s, 0, 0, 1);
-> res = span_sysfs_create(span);
-> span_device->bus = &spans_bus_type;
span_device->parent = &span->parent->dev;
dev_set_name(span_device, "span-%d", span->spanno);
dev_set_drvdata(span_device, span);
span_device->release = span_release;
res = device_register(span_device);
for (x = 0; x < span->channels; x++) {
res = chan_sysfs_create(span->chans[x]);
}
-> span = chan->span;
devt = MKDEV(MAJOR(dahdi_channels_devt), chan->channo);
dev = &chan->chan_device;
memset(dev, 0, sizeof(*dev));
dev->devt = devt; // 与dahdi_init 时cdev_add的dev进行关联
dev->bus = &chan_bus_type;
dev->parent = span->span_device;
/*
* FIXME: the name cannot be longer than KOBJ_NAME_LEN
*/
dev_set_name(dev, "dahdi!chan!%03d!%03d", span->spanno, chan->chanpos);
dev_set_drvdata(dev, chan);
dev->release = chan_release;
res = device_register(dev); //注册设备
}
};
再来看 dahdi_base.c ，wctdm24xxp.c 要依赖这个模块（dahdi.ko）
// dahdi_fops
static const struct file_operations dahdi_fops = {
.owner = THIS_MODULE,
.open = dahdi_open,
.release = dahdi_release,
#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = dahdi_unlocked_ioctl,
#ifdef HAVE_COMPAT_IOCTL
.compat_ioctl = dahdi_ioctl_compat,
#endif
#else
.ioctl = dahdi_ioctl,
#endif
.poll = dahdi_poll,
.read = dahdi_no_read,
.write = dahdi_no_write,
};
//-------------------------------------------------------------------------------
module_init(dahdi_init);
-> static int __init dahdi_init(void)
-> res = dahdi_sysfs_init(&dahdi_fops);
-> res = bus_register(&dahdi_device_bus); // [1] 注册bus
res = register_chrdev(DAHDI_MAJOR, "dahdi", dahdi_fops); //注册一个字符设备，暂时不明白用途
res = dahdi_sysfs_chan_init(dahdi_fops); // [2] sysfs_chan_init
-> res = bus_register(&chan_bus_type);
res = driver_register(&chan_driver);
dahdi_class = class_create(THIS_MODULE, "dahdi"); // dahdi_class 被 fixed_devfiles_create 引用
res = fixed_devfiles_create(); //Creates /dev/dahdi/{ctl,timer,channel,pseudo}
res = alloc_chrdev_region(&dahdi_channels_devt,
0,
DAHDI_MAX_CHANNELS,
"dahdi_channels");
cdev_init(&dahdi_channels_cdev, fops); //dahdi_channels_devt 被 chan_sysfs_create 引用
res = cdev_add(&dahdi_channels_cdev, dahdi_channels_devt,
DAHDI_MAX_CHANNELS);
-> res = bus_register(&spans_bus_type); // [3]
res = driver_register(&dahdi_driver);
笔记：
1.wctdm24xxp.c （wctdm24xxp.ko）主要注册了一个PCI 驱动，驱动实现PCI 设备的probe 函数，当系统扫描到匹配的PCI设备时，会调用probe 函数。probe函数进行设备的初始化，生成可以供应用层进行文件操作的字符设备文件。
2.wctdm24xxp.ko 依赖于dahdi.ko (其实还依赖于voice_bus.ko)，所以驱动安装时要先安装dahdi.ko ，dahdi.ko 创建好/dev/dahdi 下的一些文件，并分配好 dahdi_channels_cdev。
时光如梭，已经是2019年了，加油继续前行！