linux设备驱动模型 - device/bus/driver，linuxbus
linux设备驱动模型 - device/bus/driver，linuxbus
在linux驱动模型中，为了便于管理各种设备，我们把不同设备分别挂在他们对应的总线上，设备对应的驱动程序也在总线上找，这样就提出了deivce-bus-driver的模型，硬件上有许多设备总线，那么我们就在设备模型上抽象出bus概念，相应的device就代表设备，driver表示驱动，在代码中它们对应的结构体下面介绍，对于实际的设备及总线，这些结构体就可以嵌入到实际总线上。
1. bus
了解bus，就要先介绍下bus的结构体，一条总线定义完后要注册到系统中，第二节介绍注册函数，最后再介绍下其他一些相关API
1.1 struct bus_type
struct bus_type {
const char *name;--------------------------------------------总线名字
const char *dev_name;
struct device *dev_root;
struct device_attribute *dev_attrs; /* use dev_groups instead */
const struct attribute_group **bus_groups;
const struct attribute_group **dev_groups;
const struct attribute_group **drv_groups;
int (*match)(struct device *dev, struct device_driver *drv);-------匹配函数(用于匹配device&driver)
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 (*online)(struct device *dev);
int (*offline)(struct device *dev);
int (*suspend)(struct device *dev, pm_message_t state);-----------PM相关
int (*resume)(struct device *dev);--------------------------------PM相关
const struct dev_pm_ops *pm;--------------------------------------PM相关
const struct iommu_ops *iommu_ops;
struct subsys_private *p;
struct lock_class_key lock_key;
};
1.2 注册总线
int bus_register(struct bus_type *bus)
{
int retval;
struct subsys_private *priv;
struct lock_class_key *key = &bus->lock_key;
priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->bus = bus;
bus->p = priv;
BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
if (retval)
goto out;
priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;
retval = kset_register(&priv->subsys);--------------------在/sys/bus目录下创建当前总线目录
if (retval)
goto out;
retval = bus_create_file(bus, &bus_attr_uevent);----------在当前总线目录下创建文件uevent
if (retval)
goto bus_uevent_fail;
priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);-----------------在当前总线目录下创建devices目录
if (!priv->devices_kset) {
retval = -ENOMEM;
goto bus_devices_fail;
}
priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);----------------在当前总线目录下创建drivers目录
if (!priv->drivers_kset) {
retval = -ENOMEM;
goto bus_drivers_fail;
}
INIT_LIST_HEAD(&priv->interfaces);
__mutex_init(&priv->mutex, "subsys mutex", key);
klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&priv->klist_drivers, NULL, NULL);
retval = add_probe_files(bus);-------------------------在当前总线目录下创建probe相关文件
if (retval)
goto bus_probe_files_fail;
retval = bus_add_groups(bus, bus->bus_groups);
if (retval)
goto bus_groups_fail;
pr_debug("bus: '%s': registered\n", bus->name);
return 0;
。。。。。。
}
1.3 其他API
总线卸载函数
extern void bus_unregister(struct bus_type *bus);
2. device
先介绍devices结构体，在介绍注册函数
2.1 struct device
struct device {
struct device *parent;-------------------------父设备
struct device_private *p;
struct kobject kobj;--------------------------------嵌入的kobject
const char *init_name; /* initial name of the device */
const struct device_type *type;---------------------所属的device类型
struct mutex mutex; /* mutex to synchronize calls to
* its driver.
*/
struct bus_type *bus; /* type of bus device is on */---所属的bus
struct device_driver *driver; /* which driver has allocated this
device */---------------------------------对应的驱动driver
void *platform_data; /* Platform specific data, device
core doesn't touch it */------------------私有platform数据
void *driver_data; /* Driver data, set and get with
dev_set/get_drvdata */--------------------私有driver数据
struct dev_pm_info power;-----------------------------------PM相关
struct dev_pm_domain *pm_domain;--------------------------PM相关
#ifdef CONFIG_PINCTRL
struct dev_pin_info *pins;
#endif
#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;/* Like dma_mask, but for
alloc_coherent mappings as
not all hardware supports
64 bit addresses for consistent
allocations such descriptors. */
unsigned long dma_pfn_offset;
struct device_dma_parameters *dma_parms;
struct list_head dma_pools; /* dma pools (if dma'ble) */
struct dma_coherent_mem *dma_mem; /* internal for coherent mem
override */
#ifdef CONFIG_DMA_CMA
struct cma *cma_area; /* contiguous memory area for dma
allocations */
#endif
/* arch specific additions */
struct dev_archdata archdata;
struct device_node *of_node; /* associated device tree node */------设备树相关
struct fwnode_handle *fwnode; /* firmware device node */
dev_t devt; /* dev_t, creates the sysfs "dev" */
u32 id; /* device instance */
spinlock_t devres_lock;
struct list_head devres_head;-----------------------------------devres相关
struct klist_node knode_class;
struct class *class;----------------------------------------所属的class
const struct attribute_group **groups; /* optional groups */
void (*release)(struct device *dev);
struct iommu_group *iommu_group;
bool offline_disabled:1;
bool offline:1;
};
2.2 设备注册函数
device的注册函数device_register分两步，先初始化device_initialize，主要是初始化所属的kset为/sys/devices目录，及其他（如PM相关），然后再注册，函数为device_add
int device_add(struct device *dev)
{
struct device *parent = NULL;
struct kobject *kobj;
struct class_interface *class_intf;
int error = -EINVAL;
dev = get_device(dev);
if (!dev)
goto done;
if (!dev->p) {
error = device_private_init(dev);
if (error)
goto done;
}
/*
* for statically allocated devices, which should all be converted
* some day, we need to initialize the name. We prevent reading back
* the name, and force the use of dev_name()
*/
if (dev->init_name) {
dev_set_name(dev, "%s", dev->init_name);------------------有初始name就设置
dev->init_name = NULL;
}
/* subsystems can specify simple device enumeration */
if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);---没有初始name就设置默认的
if (!dev_name(dev)) {
error = -EINVAL;
goto name_error;
}
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
parent = get_device(dev->parent);
kobj = get_device_parent(dev, parent);
if (kobj)
dev->kobj.parent = kobj;
/* use parent numa_node */
if (parent && (dev_to_node(dev) == NUMA_NO_NODE))
set_dev_node(dev, dev_to_node(parent));
/* first, register with generic layer. */
/* we require the name to be set before, and pass NULL */
error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);---在/sys/devices目录下创建当前设备目录
if (error)
goto Error;
/* notify platform of device entry */
if (platform_notify)
platform_notify(dev);
error = device_create_file(dev, &dev_attr_uevent);--------在当前设备目录下创建文件uevent
if (error)
goto attrError;
error = device_add_class_symlinks(dev);-------------------创建链接文件
if (error)
goto SymlinkError;
error = device_add_attrs(dev);----------------------------创建其他文件，如在class目录下
if (error)
goto AttrsError;
error = bus_add_device(dev);------------------------------device加入到bus-device的链表中
if (error)
goto BusError;
error = dpm_sysfs_add(dev);
if (error)
goto DPMError;
device_pm_add(dev);
if (MAJOR(dev->devt)) {
error = device_create_file(dev, &dev_attr_dev);
if (error)
goto DevAttrError;
error = device_create_sys_dev_entry(dev);
if (error)
goto SysEntryError;
devtmpfs_create_node(dev);
}
/* Notify clients of device addition. This call must come
* after dpm_sysfs_add() and before kobject_uevent().
*/
if (dev->bus)
blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
BUS_NOTIFY_ADD_DEVICE, dev);
kobject_uevent(&dev->kobj, KOBJ_ADD);
bus_probe_device(dev);--------__device_attach-------调用此函数来和driver进行匹配
if (parent)-----------------------------------------加入到父设备链表中
klist_add_tail(&dev->p->knode_parent,
&parent->p->klist_children);
if (dev->class) {-----------------------------------和class相关的操作
mutex_lock(&dev->class->p->mutex);
/* tie the class to the device */
klist_add_tail(&dev->knode_class,
&dev->class->p->klist_devices);
/* notify any interfaces that the device is here */
list_for_each_entry(class_intf,
&dev->class->p->interfaces, node)
if (class_intf->add_dev)
class_intf->add_dev(dev, class_intf);
mutex_unlock(&dev->class->p->mutex);
}
。。。。。。
}
具体device如何匹配到对应的driver在函数__device_attach中进行，加入开始device没有driver，那么会在bus中找到对应的driver，看下函数__device_attach
static int __device_attach(struct device *dev, bool allow_async)
{
int ret = 0;
device_lock(dev);
if (dev->driver) {
if (device_is_bound(dev)) {
ret = 1;
goto out_unlock;
}
ret = device_bind_driver(dev);---------如果已经有driver，那么就绑定到device并进行probe
if (ret == 0)
ret = 1;
else {
dev->driver = NULL;
ret = 0;
}
} else {
struct device_attach_data data = {
.dev = dev,
.check_async = allow_async,
.want_async = false,
};
if (dev->parent)
pm_runtime_get_sync(dev->parent);
ret = bus_for_each_drv(dev->bus, NULL, &data,
__device_attach_driver);----如果没有driver，就遍历总线上的driver，直到找到并进行probe
if (!ret && allow_async && data.have_async) {
/*
* If we could not find appropriate driver
* synchronously and we are allowed to do
* async probes and there are drivers that
* want to probe asynchronously, we'll
* try them.
*/
dev_dbg(dev, "scheduling asynchronous probe\n");
get_device(dev);
async_schedule(__device_attach_async_helper, dev);
} else {
pm_request_idle(dev);
}
if (dev->parent)
pm_runtime_put(dev->parent);
}
out_unlock:
device_unlock(dev);
return ret;
}
2.3 其他API
device卸载函数
extern void device_unregister(struct device *dev);
3. driver
先介绍driver的结构体，再介绍注册函数
3.1 struct device_driver
struct device_driver {
const char *name;-----------------------------driver名字
struct bus_type *bus;--------------------------所属总线
struct module *owner;
const char *mod_name; /* used for built-in modules */
bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
enum probe_type probe_type;
const struct of_device_id *of_match_table;
const struct acpi_device_id *acpi_match_table;
int (*probe) (struct device *dev);----------------探测初始化函数
int (*remove) (struct device *dev);---------------删除函数
void (*shutdown) (struct device *dev);
int (*suspend) (struct device *dev, pm_message_t state);---PM相关
int (*resume) (struct device *dev);------------------------PM相关
const struct attribute_group **groups;
const struct dev_pm_ops *pm;-------------------------------PM相关
struct driver_private *p;
};
3.2 注册函数
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;
}
kobject_uevent(&drv->p->kobj, KOBJ_ADD);
return ret;
}
看下函数bus_add_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;-------设置所属总线的drivers
error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
"%s", drv->name);------------在所属总线的drivers目录下创建本驱动目录
if (error)
goto out_unregister;
klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);---把本驱动加入到总线驱动链表中
if (drv->bus->p->drivers_autoprobe) {
if (driver_allows_async_probing(drv)) {
pr_debug("bus: '%s': probing driver %s asynchronously\n",
drv->bus->name, drv->name);
async_schedule(driver_attach_async, drv);
} else {
error = driver_attach(drv);
if (error)
goto out_unregister;
}
}------------------__driver_attach--------------调用此函数来进行探测初始化
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_groups(drv, bus->drv_groups);
if (error) {
/* How the hell do we get out of this pickle? Give up */
printk(KERN_ERR "%s: driver_create_groups(%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);
}
}
return 0;
。。。。。。。。
}
那么驱动是如何匹配到对应的device的，继续探索函数__driver_attach
（drivers/base/dd.c）
static int __driver_attach(struct device *dev, void *data)
{
struct device_driver *drv = data;
int ret;
/*
* 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.
*/
ret = driver_match_device(drv, dev);--------调用总线的match函数来进行匹配
if (ret == 0) {
/* no match */
return 0;
} else if (ret == -EPROBE_DEFER) {
dev_dbg(dev, "Device match requests probe deferral\n");
driver_deferred_probe_add(dev);
} else if (ret < 0) {
dev_dbg(dev, "Bus failed to match device: %d", ret);
return ret;
} /* ret > 0 means positive match */
if (dev->parent) /* Needed for USB */
device_lock(dev->parent);
device_lock(dev);
if (!dev->driver)
driver_probe_device(drv, dev);------没有driver就设置此driver为device的driver，然后调用驱动probe初始化
device_unlock(dev);
if (dev->parent)
device_unlock(dev->parent);
return 0;
}
3.3 其他API
卸载函数
extern void driver_unregister(struct device_driver *drv);
评论暂时关闭