bus, device, driver属于设备驱动模型的高层部分，驱动程序员直接跟它们打交道，它们构成LINUX设备驱动模型这个建筑的外在表现。
一. 总线及其注册
总线是设备驱动模型的核心，它把设备与驱动紧密的联系起来，完成各自的使命。 总线有具体的物理总线抽象，比如PCI, I2C总线，也有虚拟的总线，比如platform总线。符合LINUX设备驱动模型的设备与驱动必须挂靠在一个总线上，无论是物理总线还是虚拟总线。平台相关的BSP设备驱动(RTC, 看门狗，LCD控制器等)一般是挂靠在platform这个虚拟总线上。
1. 总线数据结构
struct bus_type{
const char *name; //总线名称
const char *dev_name;
struct device *dev_root;
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 iommu_ops *iommu_ops; //对总线的IO内存进行管理
struct subsys_private *p; //管理总线上设备与驱动的数据结构
};
subsys_private数据结构
struct subsys_private{
struct kset subsys; //总线所在的子系统
struct kset *devices_kset; //该总线上所有设备的集合
struct list_head interfaces; //总线子系统接口链表
struct mutex mutex; //对设备进行操作的互斥锁
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; //指向与该bus_type_private对象关联的总线
struct kset glue_dirs;
struct class *class;
};
2. 相关操作函数
(1). int __init buses_init(void); //在系统初始化阶段调用这个函数，它将创建一个名称为"bus"的 kset并将其加入到sysfs 文件树中，即创建目录/sys/bus
(2). int bus_register(struct bus_type *bus); //向系统中注册一个总线，创建一个具体的总线，即在目录/sys/bus下创建一个总线名称的目录，比如/sys/bus/platform，同时在该目录下创建devices与drivers目录，比如/sys/bus/platform/devices与/sys/bus/platform/drivers.
二. 总线的属性
总线属性代表总线特有的信息与配置，通过sysfs 为总线生成属性文件，用户空间程序可以通过文件接口的方式显示或修改总线的属性。根据需要，可以为总线不止创建一个属性文件，每个文件代表总线的一个或一组属性信息。
1. 总线属性的数据结构
struct bus_attribute{
struct attribute attr; //总线的属性信息
ssize_t (*show)(struct bus_type *bus, char *buf); //显示总线的属性
ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); //更改总线的属性
};
#define __ATTR(_name,_mode,_show,_store) { \
.attr = {.name = __stringify(_name), .mode = _mode }, \
.show = _show, \
.store = _store, \
}
#define BUS_ATTR(_name, _mode, _show, _store) \
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
BUS_ATTR定义一个"bus_attr_"开头的总线属性对象。
2. 相关函数，这个函数生成总线属性文件。
int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
{
int error;
if (bus_get(bus)) {
error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
bus_put(bus);
} else
error = -EINVAL;
return error;
}
三. 设备与驱动的绑定
绑定其实就是把设备与它的驱动程序紧密结合到一起，总线在设备与驱动的绑定中发挥着核心的作用。总线为驱动程序员提供一组外在接口，简化驱动程序的开发。在总线上发生的两类事件将导致设备与驱动的绑定行为发生：一个是通过函数device_register向某一个总线上注册一个设备，另一个通过driver_register将某一驱动注册到其所处的总线上。
1. device_register 函数
内核将设备加入到总线的设备链表尾端，同时试图将此设备与总线上的所有驱动对象进行绑定。它会调函数device_bind_driver进行绑定。
2. driver_register
将驱动注册到其所属的总线上，同时将驱动对象加入到总线的所有驱动对象构成的链表的尾端，试图将驱动与总线上的所有设备进行绑定。
四. 设备
1. 数据结构
struct device {
struct device *parent; //当前设备的父设备
struct device_private *p; //该设备驱动相关的数据
struct kobject kobj; //代表struct device的内核对象
const char *init_name; /* initial name of the device */ //设备对象的名称，在sysfs中表现为一个目录
const struct device_type *type;
struct mutex mutex;
struct bus_type *bus; /* type of bus device is on */ //设备所在的总线对象指针
struct device_driver *driver; //当前设备是否已经与它的驱动进行绑定，如果该值为NULL,说明没有找到它的驱动
struct list_head deferred_probe;
void *platform_data;
struct dev_pm_info power;
struct dev_pm_domain *pm_domain;
#ifdef CONFIG_NUMA
int numa_node; /* NUMA node this device is close to */
#endif
u64 *dma_mask; /* dma mask (if dma'able device) */
u64 coherent_dma_mask;
struct device_dma_parameters *dma_parms;
struct list_head dma_pools;
struct dma_coherent_mem *dma_mem;
#ifdef CONFIG_CMA
struct cma *cma_area;
#endif
/* arch specific additions */
struct dev_archdata archdata;
struct device_node *of_node; /* associated device tree node */
dev_t devt; /* dev_t, creates the sysfs "dev" */
u32 id; /* device instance */
spinlock_t devres_lock;
struct list_head devres_head;
struct klist_node knode_class;
struct class *class;
const struct attribute_group **groups; /* optional groups */
void (*release)(struct device *dev);
};
2. 主要操作函数
(1). 设备初始化函数，初始化dev的一些成员，dev->kobj.kset=devices_kset表明dev所属的kset对象为devices_kset.
void device_initialize(struct device *dev)
{
dev->kobj.kset = devices_kset;
kobject_init(&dev->kobj, &device_ktype);
INIT_LIST_HEAD(&dev->deferred_probe);
INIT_LIST_HEAD(&dev->dma_pools);
mutex_init(&dev->mutex);
lockdep_set_novalidate_class(&dev->mutex);
spin_lock_init(&dev->devres_lock);
INIT_LIST_HEAD(&dev->devres_head);
device_pm_init(dev);
set_dev_node(dev, -1);
}
(2). 设备注册函数
int device_register(struct device *dev)
{
device_initialize(dev);
return device_add(dev);
}
先调用device_initialize来初始化dev对象，然后通过device_add将设备对象dev加入到系统。
(3). 设备注销函数
void device_unregister(struct device *dev)
{
device_del(dev);
put_device(dev);
}
将设备从系统中注销，重点在函数device_del中。
五. 驱动
1. 数据结构
struct device_driver{
const char *name; //驱动名称
struct bus_type *bus; //驱动所属总线
struct module *owner; //驱动所在的内核模块
const char *mod_name;
bool suppress_bind_attrs;
const struct of_device_id *of_match_table;
int (*probe) (struct device *dev); //驱动程序的探测函数，在总线对设备与驱动进行绑定时，如果总线没有定义probe函数，内核会调用驱动的probe函数
int (*remove) (struct device *dev); //卸载函数，当driver_unregister卸载驱动时，如果总线没有定义remove函数，在内核调用驱动的remove函数
void (*shutdown) (struct device *dev);
int (*suspend) (struct device *dev, pm_message_t state);
int (*resume) (struct device *dev);
const struct attribute_group **groups;
const struct dev_pm_ops *pm;
struct driver_private *p;
};
2. 操作函数
(1). driver_find, 在总线的driver_kset 集合中查找指定的驱动，name为查找的驱动名称，参数bus 指明在哪个总线上查找，如果成功，返回驱动对象指针，否则返回0
struct device_driver *driver_find(const char *name, struct bus_type *bus)
{
struct kobject *k = kset_find_obj(bus->p->drivers_kset, name);
struct driver_private *priv;
if (k) {
/* Drop reference added by kset_find_obj() */
kobject_put(k);
priv = to_driver(k);
return priv->driver;
}
return NULL;
}
(2). 驱动注册函数，先调用driver_find在总线上查找当前要注册的drv，防止向系统重复注册同一驱动，如果没有注册过，调用bus_add_driver(drv)进行注册。
int driver_register(struct device_driver *drv)
{
int ret;
struct device_driver *other;
BUG_ON(!drv->bus->p);
if ((drv->bus->probe && drv->probe) ||
(drv->bus->remove && drv->remove) ||
(drv->bus->shutdown && drv->shutdown))
printk(KERN_WARNING "Driver '%s' needs updating - please use "
"bus_type methods\n", drv->name);
other = driver_find(drv->name, drv->bus);
if (other) {
printk(KERN_ERR "Error: Driver '%s' is already registered, "
"aborting...\n", drv->name);
return -EBUSY;
}
ret = bus_add_driver(drv);
if (ret)
return ret;
ret = driver_add_groups(drv, drv->groups);
if (ret)
bus_remove_driver(drv);
return ret;
}
(3). 驱动注销函数
void driver_unregister(struct device_driver *drv)
{
if (!drv || !drv->p) {
WARN(1, "Unexpected driver unregister!\n");
return;
}
driver_remove_groups(drv, drv->groups);
bus_remove_driver(drv);
}
参数drv指定要注销的某一驱动对象，函数做的是driver_register的反向工作，主要在bus_remove_driver(drv)函数中完成。在注销一个驱动对象的过程中，如果其所在的总线定义了remove方法，则调用它，否则看驱动的驱动程序中有没有实现该方法，如果实现了则内核调用该函数。
5512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
