class.c 添加中文注释（3）

 int class_device_register(struct class_device *class_dev)
 {
     /* [cgw]: 初始化一个struct class_device */
     class_device_initialize(class_dev);
     /* [cgw]: 添加一个struct class_device */
     return class_device_add(class_dev);
 }

 /**
  * class_device_create - creates a class device and registers it with sysfs
  * @cls: pointer to the struct class that this device should be registered to.
  * @parent: pointer to the parent struct class_device of this new device, if any.
  * @devt: the dev_t for the char device to be added.
  * @device: a pointer to a struct device that is assiociated with this class device.
  * @fmt: string for the class device's name
  *
  * This function can be used by char device classes.  A struct
  * class_device will be created in sysfs, registered to the specified
  * class.
  * A "dev" file will be created, showing the dev_t for the device, if
  * the dev_t is not 0,0.
  * If a pointer to a parent struct class_device is passed in, the newly
  * created struct class_device will be a child of that device in sysfs.
  * The pointer to the struct class_device will be returned from the
  * call.  Any further sysfs files that might be required can be created
  * using this pointer.
  *
  * Note: the struct class passed to this function must have previously
  * been created with a call to class_create().
  */
 struct class_device *class_device_create(struct class *cls,
                      struct class_device *parent,
                      dev_t devt,
                      struct device *device,
                      const char *fmt, ...)
 {
     va_list args;
     struct class_device *class_dev = NULL;
     int retval = -ENODEV;

     /* [cgw]: cls为空或错误 */
     if (cls == NULL || IS_ERR(cls))
         goto error;

     /* [cgw]: 分配sizeof(*class_dev)字节大小的内存空间 */
     class_dev = kzalloc(sizeof(*class_dev), GFP_KERNEL);
     /* [cgw]: 分配失败 */
     if (!class_dev) {
         retval = -ENOMEM;
         goto error;
     }

     /* [cgw]: 分配设备号 */
     class_dev->devt = devt;
     /* [cgw]: 分配一个struct device */
     class_dev->dev = device;
     /* [cgw]: 分配一个struct class */
     class_dev->class = cls;
     /* [cgw]: 分配一个parent struct class_device */
     class_dev->parent = parent;
     /* [cgw]: 分配release方法 */
     class_dev->release = class_device_create_release;
     /* [cgw]: 分配uevent方法 */
     class_dev->uevent = class_device_create_uevent;

     va_start(args, fmt);
     /* [cgw]: 把args格式化到字符串fmt中，填装到class_dev->class_id */
     vsnprintf(class_dev->class_id, BUS_ID_SIZE, fmt, args);
     va_end(args);
     /* [cgw]: 注册一个class_dev */
     retval = class_device_register(class_dev);
     if (retval)
         goto error;

     return class_dev;

 error:
     /* [cgw]: 释放class_dev的内存空间 */
     kfree(class_dev);
     return ERR_PTR(retval);
 }

 void class_device_del(struct class_device *class_dev)
 {
     struct class *parent_class = class_dev->class;
     struct class_device *parent_device = class_dev->parent;
     struct class_interface *class_intf;

     /* [cgw]: parent_class不为空 */
     if (parent_class) {
         /* [cgw]: 获取信号量 */
         down(&parent_class->sem);
         /* [cgw]: 删除class_dev->node节点 */
         list_del_init(&class_dev->node);
         /* [cgw]: 历遍class_intf->node链表，直到回到parent_class->interfaces节点 */
         list_for_each_entry(class_intf, &parent_class->interfaces, node)
             /* [cgw]: class_intf->remove指针不为空 */
             if (class_intf->remove)
                 /* [cgw]: 调用remove方法 */
                 class_intf->remove(class_dev, class_intf);
         /* [cgw]: 释放信号量 */
         up(&parent_class->sem);
     }

     /* [cgw]: class_dev->dev指针不为空 */
     if (class_dev->dev) {
         /* [cgw] : 从class_dev->dev->kobj对象目录下删除一个名字为
               * class_dev->class->name+class_dev->kobj->k_name的链表
               */
         remove_deprecated_class_device_links(class_dev);
         /* [cgw]: class_dev->kobj目录下，删除名为device的链表 */
         sysfs_remove_link(&class_dev->kobj, "device");
     }
     /* [cgw]: class_dev->kobj目录下，删除名为subsystem的链表 */
     sysfs_remove_link(&class_dev->kobj, "subsystem");

     /* [cgw]: 删除class_dev->kobj对象对应的一个class_dev->uevent_attr->attr
       * 属性文件
       */
     class_device_remove_file(class_dev, &class_dev->uevent_attr);
     /* [cgw]: class_dev->devt_attr指针不为空 */
     if (class_dev->devt_attr)
         /* [cgw]: 删除class_dev->kobj对象对应的一个class_dev->devt_attr->attr
               * 属性文件
               */
         class_device_remove_file(class_dev, class_dev->devt_attr);
     /* [cgw]: 历遍class_dev->class->class_dev_attrs[]数组，如果该属性名字不为空，
       * 则对应地删除一个属性文件
       */
     class_device_remove_attrs(class_dev);
     /* [cgw]: 历遍class_dev->groups[]，删除所有属性组 */
     class_device_remove_groups(class_dev);

     /* [cgw]: 通知用户空间，产生一个KOBJ_REMOVE事件 */
     kobject_uevent(&class_dev->kobj, KOBJ_REMOVE);
     /* [cgw]: 删除kobj对象目录，从kset链表中删除class_dev->kobj */
     kobject_del(&class_dev->kobj);

     /* [cgw]: parent_device->kobj引用计数-1 */
     class_device_put(parent_device);
     /* [cgw]: parent_class->kobj引用计数-1 */
     class_put(parent_class);
 }

 void class_device_unregister(struct class_device *class_dev)
 {
     pr_debug("CLASS: Unregistering class device. ID = '%s'\n",
          class_dev->class_id);
     /* [cgw]: 删除struct class_device */
     class_device_del(class_dev);
     /* [cgw]: class_dev->kobj引用计数-1 */
     class_device_put(class_dev);
 }

 /**
  * class_device_destroy - removes a class device that was created with class_device_create()
  * @cls: the pointer to the struct class that this device was registered * with.
  * @devt: the dev_t of the device that was previously registered.
  *
  * This call unregisters and cleans up a class device that was created with a
  * call to class_device_create()
  */
 void class_device_destroy(struct class *cls, dev_t devt)
 {
     struct class_device *class_dev = NULL;
     struct class_device *class_dev_tmp;

     /* [cgw]: 获得信号量 */
     down(&cls->sem);
     /* [cgw]: 返回class_dev_tmp指针，历遍class_dev_tmp链表，
       * 查找与cls->children相等的节点class_dev_tmp->node
       */
     list_for_each_entry(class_dev_tmp, &cls->children, node) {
         /* [cgw]: 找到该节点，设备号为devt */
         if (class_dev_tmp->devt == devt) {
             /* [cgw]: class_dev指向class_dev_tmp */
             class_dev = class_dev_tmp;
             break;
         }
     }
     /* [cgw]: 释放信号量 */
     up(&cls->sem);

     /* [cgw]: class_dev指针不为空 */
     if (class_dev)
         /* [cgw]: 注销这个class_dev */
         class_device_unregister(class_dev);
 }

 struct class_device * class_device_get(struct class_device *class_dev)
 {
     /* [cgw]: class_dev指针不为空 */
     if (class_dev)
         /* [cgw]: class_dev->kobj引用计数+1
               * 并根据kobj找到包含这个kobj的结构体指针
               */
         return to_class_dev(kobject_get(&class_dev->kobj));
     return NULL;
 }

 void class_device_put(struct class_device *class_dev)
 {
     /* [cgw]: class_dev指针不为空 */
     if (class_dev)
         /* [cgw]: class_dev->kobj引用计数-1 */
         kobject_put(&class_dev->kobj);
 }

 int class_interface_register(struct class_interface *class_intf)
 {
     struct class *parent;
     struct class_device *class_dev;
     struct device *dev;

     /* [cgw]: class_intf或class_intf->class指针为空 */
     if (!class_intf || !class_intf->class)
         return -ENODEV;

     /* [cgw]:  class_intf->class->subsys->kset.kobj引用计数+1，
           * parent指向class_intf->class
           */
     parent = class_get(class_intf->class);
     /* [cgw]: parent指针为空 */
     if (!parent)
         return -EINVAL;

     /* [cgw]: 获取信号量 */
     down(&parent->sem);
     /* [cgw]: 添加一个新节点class_intf->node，位于parent->interfaces节点前 */
     list_add_tail(&class_intf->node, &parent->interfaces);

     /* [cgw]: class_intf->add指针不为空 */
     if (class_intf->add) {
         /* [cgw]: 返回class_dev指针，历遍class_dev链表，
               * 调用每个节点node对应的add方法
               */
         list_for_each_entry(class_dev, &parent->children, node)
             /* [cgw]: 调用与node (class_dev)对应的add方法 */
             class_intf->add(class_dev, class_intf);
     }

     /* [cgw]: class_intf->add_dev指针不为空 */
     if (class_intf->add_dev) {
         /* [cgw]: 返回dev指针，历遍dev链表，
               * 调用每个节点node对应的add_dev方法
               */
         list_for_each_entry(dev, &parent->devices, node)
             /* [cgw]: 调用与node (dev)对应的add_dev方法 */
             class_intf->add_dev(dev, class_intf);
     }
     /* [cgw]: 释放信号量 */
     up(&parent->sem);

     return ;
 }

 void class_interface_unregister(struct class_interface *class_intf)
 {
     /* [cgw]: parent指针指向class_intf->class */
     struct class * parent = class_intf->class;
     struct class_device *class_dev;
     struct device *dev;

     /* [cgw]: parent指针为空 */
     if (!parent)
         return;

     /* [cgw]: 获取信号量 */
     down(&parent->sem);
     /* [cgw]: 删除一个节点class_intf->node */
     list_del_init(&class_intf->node);
     /* [cgw]: class_intf->remove指针不为空 */
     if (class_intf->remove) {
         /* [cgw]: 返回class_dev指针，历遍class_dev链表，
               * 调用每个节点node对应的remove方法
               */
         list_for_each_entry(class_dev, &parent->children, node)
             /* [cgw]: 调用与node (class_dev)对应的remove方法 */
             class_intf->remove(class_dev, class_intf);
     }

     /* [cgw]: class_intf->remove_dev指针不为空 */
     if (class_intf->remove_dev) {
         /* [cgw]: 返回dev指针，历遍dev链表，
               * 调用每个节点node对应的remove_dev方法
               */
         list_for_each_entry(dev, &parent->devices, node)
             /* [cgw]: 调用与node (class_dev)对应的remove_dev方法 */
             class_intf->remove_dev(dev, class_intf);
     }
     /* [cgw]: 释放信号量 */
     up(&parent->sem);

     /* [cgw]: parent->subsys->kobj引用计数-1 */
     class_put(parent);
 }

 int __init classes_init(void)
 {
     int retval;

     retval = subsystem_register(&class_subsys);
     if (retval)
         return retval;

     /* ick, this is ugly, the things we go through to keep from showing up
      * in sysfs... */
     subsystem_init(&class_obj_subsys);
     if (!class_obj_subsys.kobj.parent)
         class_obj_subsys.kobj.parent = &class_obj_subsys.kobj;
     return ;
 }

 EXPORT_SYMBOL_GPL(class_create_file);
 EXPORT_SYMBOL_GPL(class_remove_file);
 EXPORT_SYMBOL_GPL(class_register);
 EXPORT_SYMBOL_GPL(class_unregister);
 EXPORT_SYMBOL_GPL(class_create);
 EXPORT_SYMBOL_GPL(class_destroy);

 EXPORT_SYMBOL_GPL(class_device_register);
 EXPORT_SYMBOL_GPL(class_device_unregister);
 EXPORT_SYMBOL_GPL(class_device_initialize);
 EXPORT_SYMBOL_GPL(class_device_add);
 EXPORT_SYMBOL_GPL(class_device_del);
 EXPORT_SYMBOL_GPL(class_device_get);
 EXPORT_SYMBOL_GPL(class_device_put);
 EXPORT_SYMBOL_GPL(class_device_create);
 EXPORT_SYMBOL_GPL(class_device_destroy);
 EXPORT_SYMBOL_GPL(class_device_create_file);
 EXPORT_SYMBOL_GPL(class_device_remove_file);
 EXPORT_SYMBOL_GPL(class_device_create_bin_file);
 EXPORT_SYMBOL_GPL(class_device_remove_bin_file);

 EXPORT_SYMBOL_GPL(class_interface_register);
 EXPORT_SYMBOL_GPL(class_interface_unregister);