个人对kobject的一点研究[2]-优快云博客

现在到bus_register了

注册的参数platform_bus_type如下所示
struct bus_type platform_bus_type = {
      .name             = "platform",
      .dev_attrs       = platform_dev_attrs,
      .match             = platform_match,
      .uevent             = platform_uevent,
      .suspend             = platform_suspend,
      .suspend_late       = platform_suspend_late,
      .resume_early       = platform_resume_early,
      .resume             = platform_resume,
};

int bus_register(struct bus_type *bus)
{
      int retval;

      //声明一个总线私有数据并分配空间
      struct bus_type_private *priv;
      priv = kzalloc(sizeof(struct bus_type_private), GFP_KERNEL);
      if (!priv)
            return -ENOMEM;

      //互相关联
      priv->bus = bus;
      bus->p = priv;

      BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);

      //设置私有数据中kobj对象的名字
      retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
      if (retval)
            goto out;

      //设置父容器为bus_kset,操作集为bus_ktype
      priv->subsys.kobj.kset = bus_kset;
      priv->subsys.kobj.ktype = &bus_ktype;
      priv->drivers_autoprobe = 1;

      //注册bus容器
      retval = kset_register(&priv->subsys);
      if (retval)
            goto out;

      //建立uevent属性文件
      retval = bus_create_file(bus, &bus_attr_uevent);
      if (retval)
            goto bus_uevent_fail;

      //建立devices目录
      priv->devices_kset = kset_create_and_add("devices", NULL,
                                             &priv->subsys.kobj);
      if (!priv->devices_kset) {
            retval = -ENOMEM;
            goto bus_devices_fail;
      }

      //建立drivers目录
      priv->drivers_kset = kset_create_and_add("drivers", NULL,
                                             &priv->subsys.kobj);
      if (!priv->drivers_kset) {
            retval = -ENOMEM;
            goto bus_drivers_fail;
      }

      //初始化klist_devices和klist_drivers链表
      klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
      klist_init(&priv->klist_drivers, NULL, NULL);

      //增加probe属性文件
      retval = add_probe_files(bus);
      if (retval)
            goto bus_probe_files_fail;

      //增加总线的属性文件
      retval = bus_add_attrs(bus);
      if (retval)
            goto bus_attrs_fail;

      pr_debug("bus: '%s': registered\n", bus->name);
      return 0;

bus_attrs_fail:
      remove_probe_files(bus);
bus_probe_files_fail:
      kset_unregister(bus->p->drivers_kset);
bus_drivers_fail:
      kset_unregister(bus->p->devices_kset);
bus_devices_fail:
      bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
      kset_unregister(&bus->p->subsys);
      kfree(bus->p);
out:
      return retval;
}

在kset_register-> kobject_add_internal中

//提取父对象,因为没有设置父对象,所以为空
parent = kobject_get(kobj->parent);

//父容器存在则设置父对象,在上文中设置了父容器priv->subsys.kobj.kset = bus_kset
if (kobj->kset) {

      //检测是否已经设置父对象
      if (!parent)
            //无则使用父容器为父对象
            parent = kobject_get(&kobj->kset->kobj);

      //添加该kobj到父容器的链表中
      kobj_kset_join(kobj);

      //设置父对象
      kobj->parent = parent;
}

在retval = kset_register(&priv->subsys)完成之后platform在bus下的模型如下图

2009-01-19 01:31 上传

下载附件 (84.78 KB)

有印象的话大家还记得在platform下面有两个目录devices和drivers吧~
现在就到这两个目录的注册了
priv->devices_kset = kset_create_and_add("devices", NULL,&priv->subsys.kobj);
priv->drivers_kset = kset_create_and_add("drivers", NULL, &priv->subsys.kobj);
注意这两条语句的头部
priv->devices_kset = kset_create_and_add
priv->drivers_kset = kset_create_and_add
可以清楚的看到bus_type_private下的devices_kset, drivers_kset分别连接到了devices,drivers的kset上

现在来看kset_create_and_add("devices", NULL,&priv->subsys.kobj);
struct kset *kset_create_and_add(const char *name,
                              struct kset_uevent_ops *uevent_ops,
                              struct kobject *parent_kobj)
//参数为"devices", NULL,&priv->subsys.kobj
{
      struct kset *kset;
      int error;

      //创建一个kset容器
      kset = kset_create(name, uevent_ops, parent_kobj);
      if (!kset)
            return NULL;

      //注册创建的kset容器
      error = kset_register(kset);
      if (error) {
            kfree(kset);
            return NULL;
      }
      return kset;
}
在kset_create 中比较重要的操作为
kset->kobj.ktype = &kset_ktype //设置了ktype,为kset_ktype
kset->kobj.parent = parent_kobj; //设置了父对象,为priv->subsys.kobj,也就是platform_bus_type->p->subsys.kobj
kset->kobj.kset = NULL; //设置父容器为空
在kset_register中

//提取父对象
parent = kobject_get(kobj->parent); //在之前设置为了

//父容器存在则设置父对象,由于父容器为空,不执行以下代码
if (kobj->kset) {

      //检测是否已经设置父对象
      if (!parent)
            //无则使用父容器为父对象
            parent = kobject_get(&kobj->kset->kobj);

      //添加该kobj到父容器的链表中
      kobj_kset_join(kobj);

      //设置父对象
      kobj->parent = parent;
}

至此, devices的模型就建立好了,drivers模型的建立和devices是一致的,只是名字不同而已,我就不复述了,建立好的模型如下

2009-01-19 01:31 上传

下载附件 (111.97 KB)

好了~  到了这里,bus,devices和platform的基础模型就就建立好了,就等设备来注册了
在platform模型设备的建立中,需要2个部分的注册,驱动的注册和设备的注册
platform_device_register(&test_device);
platform_driver_register(&test_driver);
首先看platform_device_register
注册参数为test_device,结构如下
static struct platform_device test_device = {
      .name = "test_ts",
      .id = -1,
      //. resource
      //.dev
};
这个结构主要描述了设备的名字,ID和资源和私有数据,其中资源和私有数据我们在这里不使用,将在别的文章中进行讲解

int platform_device_register(struct platform_device *pdev)
{
      //设备属性的初始化
      device_initialize(&pdev->dev);
      //将设备添加进platform里
      return platform_device_add(pdev);
}

void device_initialize(struct device *dev)
{
      dev->kobj.kset = devices_kset;                //设置kset为devices_kset,则将设备挂接上了devices目录
      kobject_init(&dev->kobj, &device_ktype);                   //初始化kobeject,置ktype为device_ktype
      klist_init(&dev->klist_children, klist_children_get,
               klist_children_put);
      INIT_LIST_HEAD(&dev->dma_pools);
      INIT_LIST_HEAD(&dev->node);
      init_MUTEX(&dev->sem);
      spin_lock_init(&dev->devres_lock);
      INIT_LIST_HEAD(&dev->devres_head);
      device_init_wakeup(dev, 0);
      set_dev_node(dev, -1);
}

int platform_device_add(struct platform_device *pdev)
{
      int i, ret = 0;

      if (!pdev)
            return -EINVAL;

      //检测是否设置了dev中的parent,无则赋为platform_bus
      if (!pdev->dev.parent)
            pdev->dev.parent = &platform_bus;

      //设置dev中的bus为platform_bus_type
      pdev->dev.bus = &platform_bus_type;

      //检测id,id为-1表明该设备只有一个,用设备名为bus_id
      //不为1则表明该设备有数个,需要用序号标明bus_id
      if (pdev->id != -1)
            snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%d", pdev->name,
                     pdev->id);
      else
            strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);

      //增加资源到资源树中
      for (i = 0; i < pdev->num_resources; i++) {
            struct resource *p, *r = &pdev->resource;

            if (r->name == NULL)
                     r->name = pdev->dev.bus_id;

            p = r->parent;
            if (!p) {
                     if (r->flags & IORESOURCE_MEM)
                              p = &iomem_resource;
                     else if (r->flags & IORESOURCE_IO)
                              p = &ioport_resource;
            }

            if (p && insert_resource(p, r)) {
                     printk(KERN_ERR "%s: failed to claim resource %d\n",pdev->dev.bus_id, i);
                     ret = -EBUSY;
                     goto failed;
            }
      }

      pr_debug("Registering platform device '%s'. Parent at %s\n",pdev->dev.bus_id, pdev->dev.parent->bus_id);

      //添加设备到设备层次中
      ret = device_add(&pdev->dev);
      if (ret == 0)
            return ret;

failed:
      while (--i >= 0)
            if (pdev->resource.flags & (IORESOURCE_MEM|IORESOURCE_IO))
                     release_resource(&pdev->resource);
      return ret;
}

int device_add(struct device *dev)
{
      struct device *parent = NULL;
      struct class_interface *class_intf;
      int error;

      dev = get_device(dev);
      if (!dev || !strlen(dev->bus_id)) {
            error = -EINVAL;
            goto Done;
      }

      pr_debug("device: '%s': %s\n", dev->bus_id, __func__);

      //取得上层device,而dev->parent的赋值是在platform_device_add中的pdev->dev.parent = &platform_bus完成的
      parent = get_device(dev->parent);

      //以上层devices为准重设dev->kobj.parent
      setup_parent(dev, parent);

      if (parent)
            set_dev_node(dev, dev_to_node(parent));

      //设置dev->kobj的名字和父对象,并建立相应目录
      error = kobject_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus_id);
      if (error)
            goto Error;

      if (platform_notify)
            platform_notify(dev);

      //一种新型的通知机制,但是platform中没有设置相应的结构,所以在这里跳过
      /* notify clients of device entry (new way) */
      if (dev->bus)
            blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_ADD_DEVICE, dev);

      //建立uevent文件
      error = device_create_file(dev, &uevent_attr);
      if (error)
            goto attrError;

      //设备有设备号则建立dev文件
      if (MAJOR(dev->devt)) {
            error = device_create_file(dev, &devt_attr);
            if (error)
                     goto ueventattrError;
      }
      //建立subsystem连接文件连接到所属class
      error = device_add_class_symlinks(dev);
      if (error)
            goto SymlinkError;
      //添加dev的描述文件
      error = device_add_attrs(dev);
      if (error)
            goto AttrsError;
      //添加链接文件至所属bus
      error = bus_add_device(dev);
      if (error)
            goto BusError;
      //添加power文件
      error = device_pm_add(dev);
      if (error)
            goto PMError;
      kobject_uevent(&dev->kobj, KOBJ_ADD);

      //检测驱动中有无适合的设备进行匹配,现在只添加了设备,还没有加载驱动,所以不会进行匹配
      bus_attach_device(dev);
      if (parent)
            klist_add_tail(&dev->knode_parent, &parent->klist_children);

      if (dev->class) {
            down(&dev->class->sem);
            list_add_tail(&dev->node, &dev->class->devices);

            list_for_each_entry(class_intf, &dev->class->interfaces, node)
                     if (class_intf->add_dev)
                              class_intf->add_dev(dev, class_intf);
            up(&dev->class->sem);
      }
Done:
      put_device(dev);
      return error;
PMError:
      bus_remove_device(dev);
BusError:
      if (dev->bus)
            blocking_notifier_call_chain(&dev->bus->p->bus_notifier,BUS_NOTIFY_DEL_DEVICE, dev);
      device_remove_attrs(dev);
AttrsError:
      device_remove_class_symlinks(dev);
SymlinkError:
      if (MAJOR(dev->devt))
            device_remove_file(dev, &devt_attr);
ueventattrError:
      device_remove_file(dev, &uevent_attr);
attrError:
      kobject_uevent(&dev->kobj, KOBJ_REMOVE);
      kobject_del(&dev->kobj);
Error:
      cleanup_device_parent(dev);
      if (parent)
            put_device(parent);
      goto Done;
}

static void setup_parent(struct device *dev, struct device *parent)
{
      struct kobject *kobj;
      //取得上层device的kobj
      kobj = get_device_parent(dev, parent);
      //kobj不为空则重设dev->kobj.parent
      if (kobj)
            dev->kobj.parent = kobj;
}

static struct kobject *get_device_parent(struct device *dev,
                                       struct device *parent)
{
      int retval;

      //因为dev->class为空,所以跳过这段代码
      if (dev->class) {
            struct kobject *kobj = NULL;
            struct kobject *parent_kobj;
            struct kobject *k;

            if (parent == NULL)
                     parent_kobj = virtual_device_parent(dev);
            else if (parent->class)
                     return &parent->kobj;
            else
                     parent_kobj = &parent->kobj;

            spin_lock(&dev->class->class_dirs.list_lock);
            list_for_each_entry(k, &dev->class->class_dirs.list, entry)
                     if (k->parent == parent_kobj) {
                              kobj = kobject_get(k);
                              break;
                     }
            spin_unlock(&dev->class->class_dirs.list_lock);
            if (kobj)
                     return kobj;

            k = kobject_create();
            if (!k)
                     return NULL;
            k->kset = &dev->class->class_dirs;
            retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
            if (retval < 0) {
                     kobject_put(k);
                     return NULL;
            }
            return k;
      }

      if (parent)
            //返回上层device的kobj
            return &parent->kobj;
      return NULL;
}

在bus_attach_device中虽然没有成功进行匹配,但是有很重要的一步为之后正确的匹配打下基础
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);
      }
}

klist_add_tail(&dev->knode_bus, &bus->p->klist_devices)就是这一行
在这一行代码中将设备挂载到了bus下的devices链表下,这样,当驱动请求匹配的时候,platform总线就会历遍devices链表为驱动寻找合适的设备

现在来看一下test_device的模型

2009-01-19 01:31 上传

下载附件 (141.22 KB)

然后platform_driver_unregister,他的参数 test_driver的结构如下
static struct platform_driver test_driver = {
      .probe             = test_probe,
      .remove             = test_remove,
      .driver             = {
            .name       = "test_ts",
            .owner       = THIS_MODULE,
      },
};

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;
      if (drv->suspend)
            drv->driver.suspend = platform_drv_suspend;
      if (drv->resume)
            drv->driver.resume = platform_drv_resume;
      return driver_register(&drv->driver);
}

从上面代码可以看出,在platform_driver中设置了probe, remove, shutdown, suspend或resume函数的话
则drv->driver也会设置成platform对应的函数

int driver_register(struct device_driver *drv)
{
      int ret;
      struct device_driver *other;

      //检测总线的操作函数和驱动的操作函数是否同时存在,同时存在则提示使用总线提供的操作函数
      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) {
            put_driver(other);
            printk(KERN_ERR "Error: Driver '%s' is already registered, “"aborting...\n", drv->name);
            return -EEXIST;
      }

      //添加驱动到总线上
      ret = bus_add_driver(drv);
      if (ret)
            return ret;


      ret = driver_add_groups(drv, drv->groups);
      if (ret)
            bus_remove_driver(drv);
      return ret;
}

int bus_add_driver(struct device_driver *drv)
{
      struct bus_type *bus;
      struct driver_private *priv;
      int error = 0;

      //取bus结构
      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_devices链表
      klist_init(&priv->klist_devices, NULL, NULL);

      //互相关联
      priv->driver = drv;
      drv->p = priv;

      //设置私有数据的父容器,在这一步中,设置了kset为platform下的drivers_kset结构,也就是drivers呢个目录
      priv->kobj.kset = bus->p->drivers_kset;

      //初始化kobj对象,设置容器操作集并建立相应的目录,这里由于没有提供parent,所以会使用父容器中的kobj为父对象
      error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
                                 "%s", drv->name);
      if (error)
            goto out_unregister;

      //检测所属总线的drivers_autoprobe属性是否为真
      //为真则进行与设备的匹配,到这里,就会与我们之前注册的test_device连接上了,至于如何连接,进行了什么操作,将在别的文章中详细描述
      if (drv->bus->p->drivers_autoprobe) {
            error = driver_attach(drv);
            if (error)
                     goto out_unregister;
      }

      //挂载到所属总线驱动链表上
      klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
      module_add_driver(drv->owner, drv);

      //建立uevent属性文件
      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_attrs(bus, drv);
      if (error) {
            printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",__func__, drv->name);
      }
      error = add_bind_files(drv);
      if (error) {
            printk(KERN_ERR "%s: add_bind_files(%s) failed\n",__func__, drv->name);
      }

      kobject_uevent(&priv->kobj, KOBJ_ADD);
      return error;
out_unregister:
      kobject_put(&priv->kobj);
out_put_bus:
      bus_put(bus);
      return error;
}

到这里test_driver的模型就建立好了,图就是最上面的层次图,我就不再贴了

到这里一个基本的框架就建立起来了~