linux内核学习之总线、驱动、设备、kset、kobject
最近在研究总线的注册、设备与驱动在总线上的注册、驱动如何找到总线上的设备进行匹配、设备又如何找到总线上的设备进行匹配，在linux2.6以后，这些过程都离不开设备驱动模型，所以也与kset、kobjcet有关。
kobject就是一个对象，kset就是所有相同对象的集合，linux的设备驱动模型是用C语言实现面向对象。用linux时使用ls命令查看的文件和目录就是对应每一个kobject。
一.设备device、驱动device_driver、总线bus_type、kobject、kset结构如下：
(1)struct device
struct device {
struct device *parent;
struct device_private *p;
struct kobject kobj;
const char *init_name; /* initial name of the device */
struct device_type *type;
struct mutex mutex; /* mutex to synchronize calls to
* its driver.
*/
struct bus_type *bus; /* type of bus device is on */
struct device_driver *driver; /* which driver has allocated this
device */
void *platform_data; /* Platform specific data, device
core doesn't touch it */
struct dev_pm_info power;
#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. */
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 */
/* arch specific additions */
struct dev_archdata archdata;
#ifdef CONFIG_OF
struct device_node *of_node;
#endif
dev_t devt; /* dev_t, creates the sysfs "dev" */
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);
};
struct device_private
struct device_private {
struct klist klist_children;
struct klist_node knode_parent;
struct klist_node knode_driver;
/* knode_bus:
* 1.注册设备时会将knode_bus成员加入到设备所在总线bus->p->klist_devices链,表示已注册到总线
* 2.同理,注销设备时会在设备所在总线bus->p->klist_devices链寻找设备->p->knode_bus节点并移除
*/
struct klist_node knode_bus;
void *driver_data;
/* device:
* 常指向设备自己,这样就可以通过device_private找到device
*/
struct device *device;
};
(2)struct device_driver
struct device_driver {
const char *name;
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 */
#if defined(CONFIG_OF)
const struct of_device_id *of_match_table;
#endif
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 attribute_group **groups;
const struct dev_pm_ops *pm;
struct driver_private *p;
};
struct driver_private
struct driver_private {
struct kobject kobj;
struct klist klist_devices;
/* knode_bus:
* 1.注册设备时会将knode_bus成员加入到设备所在总线bus->p->klist_devices链,表示已注册到总线
* 2.同理,注销设备时会在设备所在总线bus->p->klist_devices链寻找设备->p->knode_bus节点并移除
*/
struct klist_node knode_bus;
struct module_kobject *mkobj;
/* driver:
* 常指向驱动自己, 这样就可以通过driver_private找到device_driver
*/
struct device_driver *driver;
};
(3)struct bus_type
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
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;
};
(4)struct kobject
struct kobject {
const char *name;
struct list_head entry;
struct kobject *parent;
struct kset *kset;
struct kobj_type *ktype;
struct sysfs_dirent *sd;
struct kref kref;
unsigned int state_initialized:1;
unsigned int state_in_sysfs:1;
unsigned int state_add_uevent_sent:1;
unsigned int state_remove_uevent_sent:1;
unsigned int uevent_suppress:1;
};
(5)struct kset
struct kset {
struct list_head list;
spinlock_t list_lock;
struct kobject kobj;
const struct kset_uevent_ops *uevent_ops;
};
设备、驱动、总线结构都含有1个kobject结构。(device->kobj, device_driver->driver_private->kobj, bus_type->p->subsys->kobj).
在说注册之前，先说一下二个结构bus_kset、devices_kset。这二个结构是在启动内核时调用driver_init中，调用devices_init和buses_init函数初始化的。bus_kset管理所有总线的，devices管理所有物理设备的。其中有一个例外，就是platform_bus结构，平台总线本来就是不存在的，是虚拟出来的一条总线，是一个设备。这里不详说这个。
二.设备、总线、驱动注册
这里我简单的说一下它们在注册时在干什么，以注册platform_bus、platform_dev、platform_driver为例子，其中platform_dev包含device结构，platform_driver包含device_driver结构。不贴代码，详细看内核源码。
(1)总线注册device_register(&platform_bus)与bus_register(&platform_bus_type)。
注册platform_bus时:
初始化platform_bus->p私有数据。
platform_bus的kobject->kset指向devices_kset。
platform_bus的kobject->parent指向devices_kset->kobj。
platform_bus的kobject->entry节点加入到devices_kset->list链表中。
注册platform_bus_type时:
初始化platform_bus_type->p私有数据。
platform_bus_type的kobject->kset指向bus_kset。
platform_bus_type的kobject->parent指向bus_kset->kobj,。
platform_bus_type的kobject->entry节点加入到bus_kset->list链表中。
初始化platform_bus_type->p->drivers_kset(用来管理总线下的驱动的集合)。
初始化platform_bus_type->p->devices_kset(总线下的设备的kobject不会加入这个集合, 但是利用软连接链入这个集合)。
(2)设备注册到总线platform_device_register
我先贴个device_register函数源码出来:
int device_register(struct device *dev)
{
device_initialize(dev);
return device_add(dev);
}
而注册platform_device是用platform_device_register函数的:
int platform_device_register(struct platform_device *pdev)
{
device_initialize(&pdev->dev);
return platform_device_add(pdev);
}
int platform_device_add(struct platform_device *pdev)
{
int i, ret = 0;
if (!pdev)
return -EINVAL;
if (!pdev->dev.parent)
pdev->dev.parent = &platform_bus;
pdev->dev.bus = &platform_bus_type;
...
...
ret = device_add(&pdev->dev);
...
...
}
两者相差指定父设备与总线。device_register只是简单的注册一个设备，然后kobject交给device_kset管理。platform_device_register是注册一个platform_device到platform_bus_type总线下，kobject加入到device_kset但由platform_bus_type总线管理。
所以注册一个platform_device时:
初始化platform_device->dev->p私有数据。
platform_device的kobject->kset指向devices_kset。
platform_device->dev->parent指向platform_bus。
platform_device->dev->bus指向platform_bus_type。
因为platform_device->dev->parent指向platform_bus， 所以platform_device的kobject->parent指向platform_bus->kobj。
platform_device的kobject->entry节点加入到device_kset->list链表中。
platform_device->dev->kobj软连接到platform_bus->p->devices_kset中。
platform_device->dev->p->knode_parent节点加入到platform_bus->p->klist_children链表(klist)中。
platform_device->dev->p->knode_bus节点加入到platform_bus_type->p->klist_devices链表(klist)中。
注册platform_device会遍历platform_bus_type下的所有驱动进行匹配操作。
(3)注册驱动到总线platform_driver_register
贴个platform_driver_register出来，指定总线并最后调用的driver_register
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); }
所以注册platform_driver时:
初始化platform_driver->driver->私有数据。
platform_driver->driver->bus指向platform_bus_type。
platform_driver的kobject->kset指向platform_bus_type->p->drivers_kset
platform_driver的kobject->entry节点加入到platform_bus_type->p->drivers_kset->list链表中。
platform_driver->driver->p->knode_bus节点加入到platform_bus_type->p->klist_drivers链表(klist)中。
注册platform_driver会遍历platform_bus_type下的所有设备进行匹配操作。
三、平台总线、驱动、设备注册后的图如下。
