device注册

谨以此文纪念过往的岁月。

device和driver是设备管理系统的核心，作为驱动工程师有必要去一探究竟。

1.device
对于上层而言device的注册很简单只要简单的去device_register就ok了，但是对于内核而言，他要去完成很多事情。
int device_register(struct device *dev)
{
 device_initialize(dev);   --负责设备初始化
 return device_add(dev);   --负责将设备加入设备链表
}
在设备管理中kset,kobject,以及ktype占据了很重要的地位。linux内核就是通过kset以及kobject将一个个设备关联起来。
1.1 device_initialize
void device_initialize(struct device *dev)
{
 dev->kobj.kset = devices_kset;             --设置设备的父kset为devices_kset，
 kobject_init(&dev->kobj, &device_ktype);    --这个函数在下面解释
 klist_init(&dev->klist_children, klist_children_get,klist_children_put);  --初始化子设备klist
 INIT_LIST_HEAD(&dev->dma_pools);              --初始化链表
 init_MUTEX(&dev->sem);
 spin_lock_init(&dev->devres_lock);
 INIT_LIST_HEAD(&dev->devres_head);
 下面的主要是对设备电源的管理，暂时不去理解
 device_init_wakeup(dev, 0);              
 device_pm_init(dev);
 set_dev_node(dev, -1);
}
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
{
 kobject_init_internal(kobj);
 kobj->ktype = ktype;                     --指向对象类型描述符的指针为device_ktype ，设置ktype
 return;
}
static void kobject_init_internal(struct kobject *kobj)
{
 if (!kobj)
  return;
 kref_init(&kobj->kref);                 --初始化kobject计数
 INIT_LIST_HEAD(&kobj->entry);
 kobj->state_in_sysfs = 0;
 kobj->state_add_uevent_sent = 0;
 kobj->state_remove_uevent_sent = 0;
 kobj->state_initialized = 1;            --将初始化状态置1
}

上面是设备初始化，说白了就是将device中的kobject以及kset等成员初始化。对于kobject,kset,这些都是设备驱动的根本，linux用这些结构体来屏蔽各个设备的不同。
1.2 device_add
device_add函数比较长，但是其核心依然是kobject和kset，将一些错误处理以及创建文件删掉就看到了device_add的本质。
int device_add(struct device *dev)
{
 struct device *parent = NULL;
 struct class_interface *class_intf;
 int error = -EINVAL;
 
 dev = get_device(dev);              --增加dev的计数，说到底还是增加dev->kobj->kref的计数
 parent = get_device(dev->parent);  --这个函数增加dev->parent的计数，同上
 setup_parent(dev, parent);         --设置dev->kobj.parent,对于这个device的parent还是比较麻烦的，其实device->kobj.parent不一定就是parent->kobj,其原因主要是
                                      如果dev还属于某一个类，那他的parent应该是class的kobj，而不是parent，这时的parent其实升级为祖父了。不过在
                                      一般情况下，dev->kobj.parent = &parent->kobj。具体是如何设置的，在下面仔细看。
 error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));  将设备的kobject加入dev->kobj.parent,至于如何加，下面看。
 error = device_create_file(dev, &uevent_attr);  --以后关于属性文件的创建，咱们就不管了，包括在sysfs下创建文件，因为首先需要了解的是设备在内核中
                                                   怎么去运转的。
 error = bus_add_device(dev);          --从函数名上理解是在总线下添加设备，其实仅仅是在/sys/bus下创建一些属性文件以及软连接。
 device_pm_add(dev);                   --电源管理，不管
 
 if (dev->bus)
  blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_ADD_DEVICE, dev);  --这个函数不太理解做什么用的。
 kobject_uevent(&dev->kobj, KOBJ_ADD);   --这个函数也是一个大的函数，在以后学习中来分析它，他的作用是调用kobject加入时所产生的事件。
 bus_attach_device(dev);                 --这个就是用于设备探测驱动，实现设备与驱动的连接。怎么实现的下面看。
 if (parent)
  klist_add_tail(&dev->knode_parent, &parent->klist_children);   --将节点连接到父设备的子链表上，这里的用词描述可能不准确。
 if (dev->class) {                         --这个是针对设备有存在的类的时候使用。
  mutex_lock(&dev->class->p->class_mutex);
  /* tie the class to the device */
  klist_add_tail(&dev->knode_class,&dev->class->p->class_devices);

/* notify any interfaces that the device is here */
  list_for_each_entry(class_intf,
        &dev->class->p->class_interfaces, node)
   if (class_intf->add_dev)
    class_intf->add_dev(dev, class_intf);
  mutex_unlock(&dev->class->p->class_mutex);
 }
 put_device(dev);                --减少设备计数。
 return error;
}
以上就是一个设备的添加，他将kobject以及kset的处理封装成一个函数来使用。这个就需要向下去一个一个函数去理解。
其实上面的函数的核心就是：
int device_add(struct device *dev)
{
  setup_parent(dev, parent);    --实现设置device的真正父设备
  kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev_name(dev));  --将设备添加到父设备链表中。
  bus_attach_device(dev);    --设备匹配驱动，函数名会定义为bus_attach_device，其实针对不同的总线，其匹配的规则则不同。
}
下面针对上面的几个函数来看。
第一个是设置parent,也许会很奇怪，既然device->parnet存在的话，那dev->kobj.parent = &parent->kobj,那为什么还会有这个函数的存在。但是万一parent不存在的
话，即是这个设备就是老大的时候，也应该是可以的。
static void setup_parent(struct device *dev, struct device *parent)
{
 struct kobject *kobj;
 kobj = get_device_parent(dev, parent);   --获取父kobject
 if (kobj)
  dev->kobj.parent = kobj;
}
在一般情况下，其parent一般为总线设备。而在总线设备加载的时候，则parent为NULL。这个还需要在理解class的作用后才可以彻底的理解。
static struct kobject *get_device_parent(struct device *dev,struct device *parent)
{
 int retval;

if (dev->class) {           --如果设备类存在时
  struct kobject *parent_kobj;
  struct kobject *k; 
  
  if (parent == NULL)     --如果没有parent则设备诞生于虚无，则直接就挂在最古老的设备下。
   parent_kobj = virtual_device_parent(dev);
  else if (parent->class)      --如果父的类也存在的话，则直接返回父的kobj
   return &parent->kobj;
  else                     --父设备存在，而父类不存在。
   parent_kobj = &parent->kobj;

spin_lock(&dev->class->p->class_dirs.list_lock);
  list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
   if (k->parent == parent_kobj) {
    kobj = kobject_get(k);
    break;
   }
  spin_unlock(&dev->class->p->class_dirs.list_lock);
  if (kobj)
   return kobj;
  k = kobject_create();
  if (!k)
   return NULL;
  k->kset = &dev->class->p->class_dirs;
  retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
  if (retval < 0) {
   kobject_put(k);
   return NULL;
  return k;
 }

if (parent)
  return &parent->kobj;
 return NULL;
}

在上面函数中查找到device的父设备后就是kobject_add.在把函数清理后，就会发现
kobject_add->kobject_add_varg
static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,const char *fmt, va_list vargs)
{
 int retval;

retval = kobject_set_name_vargs(kobj, fmt, vargs);  --重新设置kobject的name
 kobj->parent = parent;                              --设置parent
 return kobject_add_internal(kobj);
}
kobject_add_internal这个函数是kobject_add的真正的实现，其余都浮云，不过那些浮云还不能不要。就是不是浮云的浮云。
static int kobject_add_internal(struct kobject *kobj)
{
 int error = 0;
 struct kobject *parent;
 parent = kobject_get(kobj->parent);   
 /* join kset if set, use it as parent if we do not already have one */
 if (kobj->kset) {             --如果kset被设置了
  if (!parent)               --parent为NULL，不过在device_add调用中这个parent一定不是NULL，否则就错了。
   parent = kobject_get(&kobj->kset->kobj);
  kobj_kset_join(kobj);       --将kobject添加到kset的链表
  kobj->parent = parent;      --这里是个冗余
 }
  err=create_dir(kobj);         --创建kobj的文件夹。
  kobj->state_in_sysfs = 1;     --对初始状态赋值。

return error;
}
到此一个kobject就ok了，其正确而无误的添加到parent下了。
对于父亲责任完成了，下面该实现如何匹配驱动了。
void bus_attach_device(struct device *dev)
{
 struct bus_type *bus = dev->bus;  --下面是很理解的
 int ret = 0;
 if (bus) {
  if (bus->p->drivers_autoprobe)
   ret = device_attach(dev);
  WARN_ON(ret < 0);
  if (ret >= 0)
   klist_add_tail(&dev->knode_bus, &bus->p->klist_devices);
 }
}

int device_attach(struct device *dev)
{
 int ret = 0;

down(&dev->sem);
 if (dev->driver) {    --如果设备的driver存在则直接绑定。这个会根据不同的bus之不同match办法实现
  ret = device_bind_driver(dev);
  if (ret == 0)
   ret = 1;
  else {
   dev->driver = NULL;
   ret = 0;
  }
 } else {       --如果不存在则，依次查询bus下的所有driver进行匹配。真正起作用的是__device_attach函数
  ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
 }
 up(&dev->sem);
 return ret;
}

static int __driver_attach(struct device *dev, void *data)
{
 struct device_driver *drv = data;
 if (drv->bus->match && !drv->bus->match(dev, drv))  --这个match是每一个bus所特有的。实现设备与驱动匹配。
  return 0;
 if (dev->parent) /* Needed for USB */
  down(&dev->parent->sem);
 down(&dev->sem);
 if (!dev->driver)   --如果dev->driver为NULL，则调用probe
  driver_probe_device(drv, dev);
 up(&dev->sem);
 if (dev->parent)
  up(&dev->parent->sem);

return 0;
}
函数driver_probe_device ->really_probe
这个函数是真正的探测
static int really_probe(struct device *dev, struct device_driver *drv)
{
 int ret = 0;
 atomic_inc(&probe_count);
 dev->driver = drv;
 if (driver_sysfs_add(dev)) {
  return 0；
 }
 if (dev->bus->probe) {
  ret = dev->bus->probe(dev);    --这个是总线probe
  if (ret)
   goto probe_failed;
 } else if (drv->probe) {   --这个会调用真正的设备probe
  ret = drv->probe(dev);
  if (ret)
   goto probe_failed;
 }
 driver_bound(dev);         --驱动绑定。
 ret = 1;
 atomic_dec(&probe_count);
 wake_up(&probe_waitqueue);
 return ret;
}