linux驱动:设备驱动模型综述

设备驱动模型综述

 已经停顿了好多天了，这部分很难看的。到现在也是懵懵懂懂，不能彻底弄清楚。很多事情是不能一步到位的，暂时这样吧，回头再搞，就此总结一下我对于linux设备驱动模型的一些理解
    linux内核的设备驱动模型在网上有诸多文章介绍，但是多数是互相摘抄修改的，我也不例外的引用其中的一些说法，毕竟东西就那么一个，再怎么理解也玩不改头换面的花样。
    设备驱动模型是一个用c实现c++继承的代码模型。其最底层的也可以理解为基类的结构体是kobject，之后所有的其他结构里面都直接或者间接的内嵌了一个kobject。可以认为kobject是最基本最底层的原型。在此基础上进行如下的扩充。
    1，kobject是最基本的原型，是个基类
    2，kobject表示的各个对象可以用链表连接起来，（用的还是linux老一套的内嵌一个list_head），然后把这个链表头赋值给kset结构体，也就是kset结构体除了包含有一个自身的kobject基类部分以外，还包含有一个链表头，该链表链出了一系列的kobject对象。
    3，再上一层有个subsystem结构，该结构很简单就是封装了一个kset和一把读写锁。
    4，除了上面这一条线以外，还有一条bus线，bus线我们从上往下说吧。bus_type包含了2个kset对象分别命名为devices和drivers，顾名思义，还包含了一个subsystem成员，该subsystem成员自然是描述了自身的属性，而2个kset最重要的是驱动和设备的2条链表来用。当进行bus_register的时候这2条链表中的keset->kobject->keset指针都指向bus_type->subsys->kset从而把这两条链表当中可以直接链接到bus_type最基本的kset当中来。而bus_type->subsys->kset->kobject->keset指针也无疑例外有所指向，这个指向不是自身，而是通过
#define decl_subsys(_name,_type,_hotplug_ops) \
struct subsystem _name##_subsys = { \
 .kset = { \
  .kobj = { .name = __stringify(_name) }, \
  .ktype = _type, \
  .hotplug_ops =_hotplug_ops, \
 } \
}声明的一个bus_subsys的kset上。这样所有新注册的bus在系统总的bus_subsys当中链接着。bus_subsys在系统初始化的时候初始化
    5，device是bus_type下面的kset的一条链表devices的内容，毫无疑问的含有一个kobject基本对象，和指向自身bus_type的指针关联的driver等
    6，device_driver是bus_type下面的kset的一条链表drivers的内容，也毫无例外的含有一个kobject基本对象，和指向自身bus_type的指针关联的devices（这里带s哦，说明一个驱动可能驱动好多设备，但是一个设备只有一个驱动，这点区别在驱动和设备初始化的关联过程中也有体现）等和一些基本操作。

设备驱动模型kobject

 kobject
    定义如下：
struct kobject {
 char   * k_name;
 char   name[KOBJ_NAME_LEN];
 struct kref  kref;/* 生命周期（引用计数）管理 */
 struct list_head entry;/* 用于链入所属kset 的链表 */
 struct kobject  * parent;
 struct kset  * kset;/* 所属kset */
 struct kobj_type * ktype;/* 所属ktype */
 struct dentry  * dentry;
};
    我们来看分析这个结构
    1，kref指明了该对象被引用的次数，是一个模拟智能指针的做法，只有当引用次数为0，才销毁对象。所以，当其他对象的指针指向该object的时候，应该使用函数
extern struct kobject * kobject_get(struct kobject *);
extern void kobject_put(struct kobject *);
来提取和释放，这两个函数分别增加和减小了计数引用次数，并返回kobject基本对象，另外其他派生对象是没有引用计数成员的，因为他们包含了一个kobject对象。拿kset来说，系统提供了以下函数
static inline struct kset * to_kset(struct kobject * kobj)
{
 return kobj ? container_of(kobj,struct kset,kobj) : NULL;
}
static inline struct kset * kset_get(struct kset * k)
{
 return k ? to_kset(kobject_get(&k->kobj)) : NULL;
}
static inline void kset_put(struct kset * k)
{
 kobject_put(&k->kobj);
}
分别来引用或者销毁对应的kset对象，这里可以看出kset_get等也是间接引用kobject_get，linux利用成员指针获取父结构指针，从而层层索引，然而最重的计数功能还是落在了对应的kobject成员kref上面
    2， struct list_head entry;/* 用于链入所属kset 的链表 */在初始化的时候肯定要把pre指向next，next指向pre的孤立做法。而作为其他对象子对象成员添加的时候，就要把该链表指向该指向的地方了。所以kobject有init和add 2个主要的初始化函数，代码如下。
/**
 * kobject_init - initialize object.
 * @kobj: object in question.
 */
void kobject_init(struct kobject * kobj)
{
 kref_init(&kobj->kref);//初始化计数为1
 INIT_LIST_HEAD(&kobj->entry);//链表初始化
 kobj->kset = kset_get(kobj->kset);//引用计数加加
}
 
 
/**
 * kobject_add - add an object to the hierarchy.
 * @kobj: object.
 */
int kobject_add(struct kobject * kobj)
{
 int error = 0;
 struct kobject * parent;
 if (!(kobj = kobject_get(kobj))));//获取对象一定要用对应的get，增加计数
  return -ENOENT;
 if (!kobj->k_name)
  kobj->k_name = kobj->name;
 parent = kobject_get(kobj->parent);//获取对象一定要用对应的get，增加计数
 pr_debug("kobject %s: registering. parent: %s, set: %s\n",
   kobject_name(kobj), parent ? kobject_name(parent) : "<NULL>", 
   kobj->kset ? kobj->kset->kobj.name : "<NULL>" );
 if (kobj->kset) {//如果该kobject属于某个kset的话，就把他的entry增加到对应的kset的list当中
  down_write(&kobj->kset->subsys->rwsem);
  if (!parent)
   parent = kobject_get(&kobj->kset->kobj);//成功增加的kobject一定有parent，至少是kset的kobj
  list_add_tail(&kobj->entry,&kobj->kset->list);
  up_write(&kobj->kset->subsys->rwsem);
 }
 kobj->parent = parent;
 error = create_dir(kobj);//这里确实还没看
 if (error) {
  /* unlink does the kobject_put() for us */
  unlink(kobj);
  if (parent)
   kobject_put(parent);//释放对象一定要用对应的put，减少计数
 } else {
  kobject_hotplug(kobj, KOBJ_ADD);
 }
 return error;
}
我们会发现kset对象、device、driver等对象的初始化都要用到这两个函数，为了方便使用，这两个函数合成了一个kobject_register供所有高级对象毫无例外的使用着
/**
 * kobject_register - initialize and add an object.
 * @kobj: object in question.
 */
int kobject_register(struct kobject * kobj)
{
 int error = 0;
 if (kobj) {
  kobject_init(kobj);
  error = kobject_add(kobj);
  if (error) {
   printk("kobject_register failed for %s (%d)\n",
          kobject_name(kobj),error);
   dump_stack();
  }
 } else
  error = -EINVAL;
 return error;
}
    3，kobject对象还提供以下操作
void kobject_del(struct kobject * kobj)
int kobject_set_name(struct kobject * kobj, const char * fmt, ...)

设备驱动模型kset

kset的分析
先看结构体代码
struct kset {
 struct subsystem * subsys;//所属subsystem
 struct kobj_type * ktype;//所属ktype
 struct list_head list;//所包含的kobject链表
 struct kobject  kobj;//所包含的子对象kobject，往往是list各kobject的parent
 struct kset_hotplug_ops * hotplug_ops;
};
    1，kset的初始化也有2个函数init和add
/**
 * kset_init - initialize a kset for use
 * @k: kset 
 */
void kset_init(struct kset * k)
{
 kobject_init(&k->kobj);//init则调用init函数
 INIT_LIST_HEAD(&k->list);
}
 /**
 * kset_add - add a kset object to the hierarchy.
 * @k: kset.
 *
 * Simply, this adds the kset's embedded kobject to the 
 * hierarchy. 
 * We also try to make sure that the kset's embedded kobject
 * has a parent before it is added. We only care if the embedded
 * kobject is not part of a kset itself, since kobject_add()
 * assigns a parent in that case. 
 * If that is the case, and the kset has a controlling subsystem,
 * then we set the kset's parent to be said subsystem. 
 */
int kset_add(struct kset * k)
{
 if (!k->kobj.parent && !k->kobj.kset && k->subsys)
  k->kobj.parent = &k->subsys->kset.kobj;//如果有所属subsystem且无father，则模仿kobject对象为parent赋值
 return kobject_add(&k->kobj);//add调用add
}
 
同样合成了一个register
/**
 * kset_register - initialize and add a kset.
 * @k: kset.
 */
int kset_register(struct kset * k)
{
 kset_init(k);
 return kset_add(k);
}
    2，同样支持的操作包括
    void kset_unregister(struct kset * k)
    struct set * kset_get(struct kobject * kobj)
    void kset_put(struct kobject * kobj)

设备驱动模型subsystem

subsystem
    定义非常简单
struct subsystem {
 struct kset  kset;
 struct rw_semaphore rwsem;
};
    1，一个读写锁加一个kset变量的定义使得这个结构非常简单，可以很明显的感觉到，这里最主要的目的是在kset当中增加了一个读写锁了，所以在设备驱动模型链表修改过程中，几乎毫无疑问的都要用到这个读写锁，subsystem下面的读写锁
    2，初始化函数
void subsystem_init(struct subsystem * s)
{
 init_rwsem(&s->rwsem);
 kset_init(&s->kset);
}
/**
 * subsystem_register - register a subsystem.
 * @s: the subsystem we're registering.
 *
 * Once we register the subsystem, we want to make sure that 
 * the kset points back to this subsystem for correct usage of 
 * the rwsem. 
 */
int subsystem_register(struct subsystem * s)
{
 int error;
 subsystem_init(s);
 pr_debug("subsystem %s: registering\n",s->kset.kobj.name);
 if (!(error = kset_add(&s->kset))) {
  if (!s->kset.subsys)
   s->kset.subsys = s;
 }
 return error;
}
    3，同样支持void subsystem_unregister(struct subsystem * s)

设备驱动模型device

device
结构说明
struct device {
 struct list_head node;  /* node in sibling list */
 struct list_head bus_list; /* node in bus's list */
 struct list_head driver_list;
 struct list_head children;
 struct device  * parent;/* 父设备 */
 struct kobject kobj;/* 内嵌的kobject */
 char bus_id[BUS_ID_SIZE]; /* position on parent bus */
 struct bus_type * bus;  /* type of bus device is on */
 struct device_driver *driver; /* which driver has allocated this
        device */
 void  *driver_data; /* data private to the driver */
 void  *platform_data; /* Platform specific data (e.g. ACPI,
        BIOS data relevant to device) */
 struct dev_pm_info power;
 u32  detach_state; /* State to enter when device is
        detached from its driver. */
 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 list_head dma_pools; /* dma pools (if dma'ble) */
 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
          override */
 void (*release)(struct device * dev);
};
    1，一如既往的初始化分为2个步骤init和add
/**
 * device_initialize - init device structure.
 * @dev: device.
 *
 * This prepares the device for use by other layers,
 * including adding it to the device hierarchy.
 * It is the first half of device_register(), if called by
 * that, though it can also be called separately, so one
 * may use @dev's fields (e.g. the refcount).
 */
void device_initialize(struct device *dev)
{
 kobj_set_kset_s(dev, devices_subsys);//把dev->object->kset指向decl_subsys声明的devices_subsys
 kobject_init(&dev->kobj);
 INIT_LIST_HEAD(&dev->node);
 INIT_LIST_HEAD(&dev->children);
 INIT_LIST_HEAD(&dev->driver_list);
 INIT_LIST_HEAD(&dev->bus_list);
 INIT_LIST_HEAD(&dev->dma_pools);
}

/**
 * device_add - add device to device hierarchy.
 * @dev: device.
 *
 * This is part 2 of device_register(), though may be called
 * separately _iff_ device_initialize() has been called separately.
 *
 * This adds it to the kobject hierarchy via kobject_add(), adds it
 * to the global and sibling lists for the device, then
 * adds it to the other relevant subsystems of the driver model.
 */
int device_add(struct device *dev)
{
 struct device *parent = NULL;
 int error = -EINVAL;
 dev = get_device(dev);//利用get获取device增加计数
 if (!dev || !strlen(dev->bus_id))
  goto Error;
 parent = get_device(dev->parent);//利用get获取device增加计数
 pr_debug("DEV: registering device: ID = '%s'\n", dev->bus_id);
 /* first, register with generic layer. */
 kobject_set_name(&dev->kobj, "%s", dev->bus_id);//设置子kobject对象名称也就是自身name
 if (parent)
  dev->kobj.parent = &parent->kobj;
 if ((error = kobject_add(&dev->kobj)))//调用kobject_add增加子对象
  goto Error;
 if ((error = device_pm_add(dev)))
  goto PMError;
 if ((error = bus_add_device(dev)))//增加device到总线，并探测驱动
  goto BusError;
 down_write(&devices_subsys.rwsem);
 if (parent)
  list_add_tail(&dev->node, &parent->children);//如果有父设备，则添加到其子对象列表
 up_write(&devices_subsys.rwsem);
 /* notify platform of device entry */
 if (platform_notify)
  platform_notify(dev);
 Done:
 put_device(dev);
 return error;
 BusError:
 device_pm_remove(dev);
 PMError:
 kobject_del(&dev->kobj);
 Error:
 if (parent)
  put_device(parent);
 goto Done;
}
两部合一就是个register
/**
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
 *
 * This happens in two clean steps - initialize the device
 * and add it to the system. The two steps can be called
 * separately, but this is the easiest and most common.
 * I.e. you should only call the two helpers separately if
 * have a clearly defined need to use and refcount the device
 * before it is added to the hierarchy.
 */
int device_register(struct device *dev)
{
 device_initialize(dev);
 return device_add(dev);
}
    2，同样支持的操作包括
    struct device * get_device(struct device * dev)
    struct device * get_device(struct device * dev)
    void device_del(struct device * dev)
    void device_unregister(struct device * dev)
    3，初始化函数bus_add_device在bus当中提到

设备驱动模型device_driver

device_driver
struct device_driver {
 char   * name;
 struct bus_type  * bus;
 struct completion unload_done;
 struct kobject  kobj;
 struct list_head devices;
 struct module   * owner;
 int (*probe) (struct device * dev);
 int  (*remove) (struct device * dev);
 void (*shutdown) (struct device * dev);
 int (*suspend) (struct device * dev, u32 state, u32 level);
 int (*resume) (struct device * dev, u32 level);
};
    1，这个是看起来最简单的结构了，初始化只有个register

/**
 * driver_register - register driver with bus
 * @drv: driver to register
 *
 * We pass off most of the work to the bus_add_driver() call,
 * since most of the things we have to do deal with the bus
 * structures.
 *
 * We init the completion strcut here. When the reference 
 * count reaches zero, complete() is called from bus_release().
 */
int driver_register(struct device_driver * drv)
{
 INIT_LIST_HEAD(&drv->devices);
 init_completion(&drv->unload_done);
 return bus_add_driver(drv);
}
    2，同样支持void put_driver(struct device_driver * drv)
    struct device_driver * get_driver(struct device_driver * drv)
    void driver_unregister(struct device_driver * drv)

设备驱动模型bus_type

bus_type
struct bus_type {
 char   * name;
 struct subsystem subsys;
 struct kset  drivers;
 struct kset  devices;
 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  (*hotplug) (struct device *dev, char **envp, 
        int num_envp, char *buffer, int buffer_size);
 int  (*suspend)(struct device * dev, u32 state);
 int  (*resume)(struct device * dev);
};
    1,bus_type自身包含一个subsystem和2个kset，所以其初始化要一一完成
/**
 * bus_register - register a bus with the system.
 * @bus: bus.
 *
 * Once we have that, we registered the bus with the kobject
 * infrastructure, then register the children subsystems it has:
 * the devices and drivers that belong to the bus.
 */
int bus_register(struct bus_type * bus)
{
 int retval;
 retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);//设置自身kobj的name
 if (retval)
  goto out;
 subsys_set_kset(bus, bus_subsys);//同样关联到decl_subsys申明的bus_subsys上，kobj->kset
 retval = subsystem_register(&bus->subsys);//subsys初始化
 if (retval)
  goto out;
 kobject_set_name(&bus->devices.kobj, "devices");//设置成员devices的名字
 bus->devices.subsys = &bus->subsys;//device的subsys置为自己的subsys
 retval = kset_register(&bus->devices);//注册kset
 if (retval)
  goto bus_devices_fail;
 kobject_set_name(&bus->drivers.kobj, "drivers");//设置成员drivers的名字
 bus->drivers.subsys = &bus->subsys;//设置driver的subsys为自己的subsys
 bus->drivers.ktype = &ktype_driver;//设置driver的ktype为自己的ktype
retval = kset_register(&bus->drivers);//注册kset
 if (retval)
  goto bus_drivers_fail;
 bus_add_attrs(bus);
 pr_debug("bus type '%s' registered\n", bus->name);
 return 0;
bus_drivers_fail:
 kset_unregister(&bus->devices);
bus_devices_fail:
 subsystem_unregister(&bus->subsys);
out:
 return retval;
}
    2，同样支持void bus_unregister(struct bus_type * bus)
    extern struct bus_type * get_bus(struct bus_type * bus);
extern void put_bus(struct bus_type * bus);
extern struct bus_type * find_bus(char * name);
    3，bus_add_device函数
/**
 * bus_add_device - add device to bus
 * @dev: device being added
 *
 * - Add the device to its bus's list of devices.
 * - Try to attach to driver.
 * - Create link to device's physical location.
 */
int bus_add_device(struct device * dev)
{
 struct bus_type * bus = get_bus(dev->bus);//用get获取bus增加计数
 int error = 0;
 if (bus) {
  down_write(&dev->bus->subsys.rwsem);
  pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
  list_add_tail(&dev->bus_list, &dev->bus->devices.list);//自身的bus_list增加到bus_type->kset.list
  device_attach(dev);//搜索匹配的驱动
  up_write(&dev->bus->subsys.rwsem);
  device_add_attrs(bus, dev);
  sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
 }
 return error;
}
/**
 * device_attach - try to attach device to a driver.
 * @dev: device.
 *
 * Walk the list of drivers that the bus has and call
 * driver_probe_device() for each pair. If a compatible
 * pair is found, break out and return.
 */
int device_attach(struct device * dev)
{
  struct bus_type * bus = dev->bus;
 struct list_head * entry;
 int error;
 if (dev->driver) {//已经定义好了驱动，则直接绑定
  device_bind_driver(dev);
  return 1;
 }
 if (bus->match) {
  list_for_each(entry, &bus->drivers.list) {//否则搜索并绑定
   struct device_driver * drv = to_drv(entry);
   error = driver_probe_device(drv, dev);
   if (!error)
    /* success, driver matched */
    return 1;
   if (error != -ENODEV)
    /* driver matched but the probe failed */
    printk(KERN_WARNING
        "%s: probe of %s failed with error %d\n",
        drv->name, dev->bus_id, error);
  }
 }
 return 0;
}
int driver_probe_device(struct device_driver * drv, struct device * dev)
{
 if (drv->bus->match && !drv->bus->match(dev, drv))
  return -ENODEV;
 dev->driver = drv;
 if (drv->probe) {
  int error = drv->probe(dev);
  if (error) {
   dev->driver = NULL;
   return error;
  }
 }
 device_bind_driver(dev);
 return 0;
}
    4,类似的还有bus_add_driver不再细表了

目前分析了kobject、kset、subsystem、device、device_driver、bus_type还缺少kobj_type、class_type、attr等等，暂时不想看了，因为多数的关于devide.hkobject.c bus.c driver.c等已经分析了，还有一些其他的总线，如platform等暂时没办法一一了解，以后继续。