总线时物理存在，Linux系统提供了一种简单的总线flatform。
platform 不是物理存在的总线，而是逻辑概念。现代PC机提供了一条根总线（PCI 总线）管理设备，但是有些设备没有挂载在PCI总线上，不能由PCI总线管理，于是Linux内核虚拟了platform总线来统一管理这种设备。
1、从驱动发现设备的过程
platform总线虽然简单，但有总线的通用功能。我们选的例子是 q40kbd, 在driver/input/serio目录里，这是一个键盘驱动，使用了platform总线。
1.1、驱动的初始化
设备驱动一般从初始化函数进行分析，q40kbd_init作用是把驱动程序注册到系统，代码如下
static int __init q40kbd_init(void)
{
int error;
if (!MACH_IS_Q40)
return -ENODEV;
//驱动作为platform总线驱动 注册
error = platform_driver_register(&q40kbd_driver);
if (error)
return error;
//分配一个platform设备
q40kbd_device = platform_device_alloc("q40kbd", -1);
if (!q40kbd_device)
goto err_unregister_driver;
//platform 设备注册
error = platform_device_add(q40kbd_device);
if (error)
goto err_free_device;
return 0;
err_free_device:
platform_device_put(q40kbd_device);
err_unregister_driver:
platform_driver_unregister(&q40kbd_driver);
return error;
}
1.2、注册驱动
驱动注册调用函数是 platform_driver_register，代码如下：
/**
* platform_driver_register - register a driver for platform-level devices
* @drv: platform driver structure
*/
int platform_driver_register(struct platform_driver *drv)
{
drv->driver.bus = &platform_bus_type;
if (drv->probe)
drv->driver.probe = platform_drv_probe;
if (drv->remove)
drv->driver.remove = platform_drv_remove;
if (drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;
return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(platform_driver_register);1.3、为总线增加一个驱动
bus_add_driver 的作用是为总线增加一个驱动，bus_add_driver代码如下【微差别】：
/**
* bus_add_driver - Add a driver to the bus.
* @drv: driver.
*/
int bus_add_driver(struct device_driver *drv)
{
struct bus_type *bus;
struct driver_private *priv;
int error = 0;
bus = bus_get(drv->bus);
if (!bus)
return -EINVAL;
pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
error = -ENOMEM;
goto out_put_bus;
}
klist_init(&priv->klist_devices, NULL, NULL);
priv->driver = drv;
drv->p = priv;
priv->kobj.kset = bus->p->drivers_kset;
error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
"%s", drv->name);
if (error)
goto out_unregister;
if (drv->bus->p->drivers_autoprobe) {
error = driver_attach(drv);
if (error)
goto out_unregister;
}
klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
module_add_driver(drv->owner, drv);
error = driver_create_file(drv, &driver_attr_uevent);
if (error) {
printk(KERN_ERR "%s: uevent attr (%s) failed\n",
__func__, drv->name);
}
error = driver_add_attrs(bus, drv);
if (error) {
/* How the hell do we get out of this pickle? Give up */
printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
__func__, drv->name);
}
if (!drv->suppress_bind_attrs) {
error = add_bind_files(drv);
if (error) {
/* Ditto */
printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
__func__, drv->name);
}
}
kobject_uevent(&priv->kobj, KOBJ_ADD);
return 0;
out_unregister:
kobject_put(&priv->kobj);
kfree(drv->p);
drv->p = NULL;
out_put_bus:
bus_put(bus);
return error;
}
bus_add_driver函数使用了kobject_register 和 driver_add_attrs等函数为sysfs文件系统创建设备驱动相关的 目录 和 文件。 前面介绍过
1.4、驱动加载
真正执行驱动加载的是 driver_attach 函数，代码如下：
/**
* driver_attach - try to bind driver to devices.
* @drv: driver.
*
* Walk the list of devices that the bus has on it and try to
* match the driver with each one. If driver_probe_device()
* returns 0 and the @dev->driver is set, we've found a
* compatible pair.
*/
int driver_attach(struct device_driver * drv)
{
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
EXPORT_SYMBOL_GPL(driver_attach);/** * bus_for_each_dev - device iterator. * @bus: bus type. * @start: device to start iterating from. * @data: data for the callback. * @fn: function to be called for each device. * * Iterate over @bus's list of devices, and call @fn for each, * passing it @data. If @start is not NULL, we use that device to * begin iterating from. * * We check the return of @fn each time. If it returns anything * other than 0, we break out and return that value. * * NOTE: The device that returns a non-zero value is not retained * in any way, nor is its refcount incremented. If the caller needs * to retain this data, it should do so, and increment the reference * count in the supplied callback. */ int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, int (*fn)(struct device *, void *)) { struct klist_iter i; struct device *dev; int error = 0; if (!bus) return -EINVAL;//初始化一个kList,从设备start开始klist_iter_init_node(&bus->p->klist_devices, &i, (start ? &start->p->knode_bus : NULL));while ((dev = next_device(&i)) && !error)error = fn(dev, data);klist_iter_exit(&i);return error;}EXPORT_SYMBOL_GPL(bus_for_each_dev);
初始化一个kList,从设备start开始:
int bus_for_each_dev (struct bus_type * bus, struct device * start, void *data, int (*fn) (struct device *, void *))
{
struct klist_liter i;
struct device * dev;
int error;
if (!bus)
return -EINVAL;
//初始化一个klist,
klist_iter_init_node( &bus->klist_device, &i, (start ? &start->knode : NULL)) ;
while (( dev = next_device(&i) && !error )
error = fn(dev, data);
klist_iter_exit( &i );
return error;
}
初始化一个kList,从设备start开始:
/lib/Klist.c
/** * klist_iter_init_node - Initialize a klist_iter structure. * @k: klist we're iterating. * @i: klist_iter we're filling. * @n: node to start with. * * Similar to klist_iter_init(), but starts the action off with @n, * instead of with the list head. */ void klist_iter_init_node(struct klist *k, struct klist_iter *i, struct klist_node *n) { i->i_klist = k; i->i_cur = n; if (n) kref_get(&n->n_ref); } //----include/linux/Klist.h struct klist_iter { struct klist *i_klist; struct klist_node *i_cur; }; //----include/linux/Klist.h struct klist_node; struct klist { spinlock_t k_lock; struct list_head k_list; void (*get)(struct klist_node *); void (*put)(struct klist_node *); } __attribute__ ((aligned (sizeof(void *)))); struct klist_node { void *n_klist; /* never access directly */ struct list_head n_node; struct kref n_ref; };
总线类型的结构体定义在 include/linux/Device.h 文件中：
struct bus_type { const char *name; struct bus_attribute *bus_attrs; struct device_attribute *dev_attrs; struct driver_attribute *drv_attrs; int (*match)(struct device *dev, struct device_driver *drv); int (*uevent)(struct device *dev, struct kobj_uevent_env *env); int (*probe)(struct device *dev); int (*remove)(struct device *dev); void (*shutdown)(struct device *dev); int (*suspend)(struct device *dev, pm_message_t state); int (*resume)(struct device *dev); const struct dev_pm_ops *pm; struct subsys_private *p; };
/** * struct subsys_private - structure to hold the private to the driver core portions of the bus_type/class structure. * * @subsys - the struct kset that defines this subsystem * @devices_kset - the list of devices associated * * @drivers_kset - the list of drivers associated * @klist_devices - the klist to iterate over the @devices_kset * @klist_drivers - the klist to iterate over the @drivers_kset * @bus_notifier - the bus notifier list for anything that cares about things * on this bus. * @bus - pointer back to the struct bus_type that this structure is associated * with. * * @class_interfaces - list of class_interfaces associated * @glue_dirs - "glue" directory to put in-between the parent device to * avoid namespace conflicts * @class_mutex - mutex to protect the children, devices, and interfaces lists. * @class - pointer back to the struct class that this structure is associated * with. * * This structure is the one that is the actual kobject allowing struct * bus_type/class to be statically allocated safely. Nothing outside of the * driver core should ever touch these fields. */ struct subsys_private { struct kset subsys; struct kset *devices_kset; struct kset *drivers_kset; struct klist klist_devices; struct klist klist_drivers; struct blocking_notifier_head bus_notifier; unsigned int drivers_autoprobe:1; struct bus_type *bus; struct list_head class_interfaces; struct kset glue_dirs; struct mutex class_mutex; struct class *class; };
struct klist_node; struct klist { spinlock_t k_lock; struct list_head k_list; void (*get)(struct klist_node *); void (*put)(struct klist_node *); } __attribute__ ((aligned (sizeof(void *))));
1.5、遍历总线上已挂载的设备
遍历总线上已挂载的设备，起始位置是初始化klist_iter 结构设置的 start 设备，只遍历这个设备之后挂载的设备。当前场景设置的start设备为空，所以要遍历所有的platform总线设备。 对每个设备调用 fn 函数指针， fn就是传入的函数指针 __driver_attach，它的代码如下：
__driver_attach() ---/drivers/base/Dd.c
static int __driver_attach(struct device *dev, void *data) { struct device_driver *drv = data; /* * Lock device and try to bind to it. We drop the error * here and always return 0, because we need to keep trying * to bind to devices and some drivers will return an error * simply if it didn't support the device. * * driver_probe_device() will spit a warning if there * is an error. */ if (!driver_match_device(drv, dev)) return 0; if (dev->parent) /* Needed for USB */ device_lock(dev->parent); device_lock(dev); if (!dev->driver) driver_probe_device(drv, dev); device_unlock(dev); if (dev->parent) device_unlock(dev->parent); return 0; }static int __driver_attach(struct device *dev, void * data )
{
struct device_driver * drv = data;
if ( dev->parent ) /* need for usb */
down(&dev->parent->sem);
down(&dev->sem);
if (!dev->driver)
driver_probe_device(drv, dev);
return 0;
}
__driver_attach获取设备的锁之后，调用driver_probe_device函数，代码如下：
int driver_proe_device(struct device_driver * drv, struct device *dev)
{
int ret =0;
//调用总线配置的match函数
if ( drv->bus->match && !drv->bus->match( dev, drv) )
goto Done;
pr_debug("%s: Matched Device %s with Driver %s \n", drv->bus->name, dev->bus_id, drv->name );
dev->driver = drv;
//总线的match函数通过后，继续调用总线的probe函数
if (dev->bus->probe) {
ret = dev->bus->probe(dev);
if(ret) {
dev->driver = NULL;
goto ProbeFailed;
}
}else if ( drv->probe ) {
// 如果驱动提供了probe函数，则调用驱动的probe 函数
ret = drv->probe(dev);
if (ret) {
dev->driver = NULL;
goto ProbeFailed;
}
}
//设备发现驱动，通过sysfs创建一些文件，和设备做符号链接
device_bind_driver(dev);
driver_probe_device函数分为两个步骤：
--第一步 调用总线提供的match函数； 如果检测通过，说明设备和驱动匹配，设备所指向的驱动指针要赋予为当前驱动
--第二步 探测probe。首先调用总线提供的probe函数，如果驱动有自己的probe函数，还要调用驱动的probe函数
Probe 目的是 总线或设备的进一步探测。比如硬盘控制器，本身是一个PCI设备，同时又提供硬盘接入的功能。那么它的驱动probe函数就要扫描scsi总线，把所有接入的硬盘都扫描出来。
1.5.1 match函数
platform总线的match函数就是platform_match
platform_match 函数很简单，比较驱动的名字和设备的名字是否相同，相同就可以匹配。
1.5.2 probe函数
platform_drv_probe 是封装的函数，简单调用了 驱动的probe函数，驱动probe函数就是 q40kbd_probe ：
static int __devinit q40kbd_probe(struct platform_device *dev) { q40kbd_port = kzalloc(sizeof(struct serio), GFP_KERNEL); if (!q40kbd_port) return -ENOMEM; q40kbd_port->id.type = SERIO_8042; q40kbd_port->open = q40kbd_open; q40kbd_port->close = q40kbd_close; q40kbd_port->dev.parent = &dev->dev; strlcpy(q40kbd_port->name, "Q40 Kbd Port", sizeof(q40kbd_port->name)); strlcpy(q40kbd_port->phys, "Q40", sizeof(q40kbd_port->phys)); serio_register_port(q40kbd_port); printk(KERN_INFO "serio: Q40 kbd registered\n"); return 0; }q40kbd_probe函数设置了一个serio结构变量，然后注册到系统。
扫一扫
52
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
