初识V4l2（二）-------浅析video_register_device

/* Register video devices. Note that if video_register_device fails,
   the release() callback of the video_device structure is *not* called, so
   the caller is responsible for freeing any data. Usually that means that
   you call video_device_release() on failure. */
   //该函数的作用就是注册video devices,有一点注意，video_device_release函数需要开发者手动调用

static inline int video_register_device(struct video_device *vdev,
        int type, int nr)
{
    return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
}

define VFL_TYPE_GRABBER  0   图像采集设备，包括摄像头、调谐器 

define VFL_TYPE_VBI1     1   从视频消隐的时间段取得信息的设备(1)

#define VFL_TYPE_RADIO   2   无线电设备 

#define VFL_TYPE_SUBDEV  3   视频传播设备 

#define VFL_TYPE_MAX     4 

/**
 *    __video_register_device - register video4linux devices
 *    @vdev: video device structure we want to register
 *    @type: type of device to register
 *    @nr:   which device node number (0 == /dev/video0, 1 == /dev/video1, ...
 *             -1 == first free)
 *    @warn_if_nr_in_use: warn if the desired device node number
 *           was already in use and another number was chosen instead.
 *    @owner: module that owns the video device node
 *
 *    The registration code assigns minor numbers and device node numbers
 *    based on the requested type and registers the new device node with
 *    the kernel.
 *
 *    This function assumes that struct video_device was zeroed when it
 *    was allocated and does not contain any stale date.
 *
 *    An error is returned if no free minor or device node number could be
 *    found, or if the registration of the device node failed.
 *
 *    Zero is returned on success.
 *
 *    Valid types are
 *
 *    %VFL_TYPE_GRABBER - A frame grabber
 *
 *    %VFL_TYPE_VBI - Vertical blank data (undecoded)
 *
 *    %VFL_TYPE_RADIO - A radio card
 *
 *    %VFL_TYPE_SUBDEV - A subdevice
 */
int __video_register_device(struct video_device *vdev, int type, int nr,
        int warn_if_nr_in_use, struct module *owner)
{
    int i = 0;
    int ret;
    int minor_offset = 0;//次设备号的偏移量，对于不同类型的设备，次设备号的基数是不同的，最终minor = i + minor_offset
    int minor_cnt = VIDEO_NUM_DEVICES;
    const char *name_base; //设备的名称，会根据传入的type来选择

    /* A minor value of -1 marks this video device as never
       having been registered */
    vdev->minor = -1;  //次设备号为-1，表明这个设备没有被注册

    /* the release callback MUST be present */
    if (WARN_ON(!vdev->release)) //如果video_device结构体中没有提供release函数，就会返回出错。因此该函数必须存在
        return -EINVAL;

    /* v4l2_fh support */
    spin_lock_init(&vdev->fh_lock);
    INIT_LIST_HEAD(&vdev->fh_list); //初始化链表fh_list

    /* Part 1: check device type */
    //1.1 根据传入的设备类型，给name_base赋值。从这个地方看设备的名称就是以下的4种之一。
    switch (type) {
    case VFL_TYPE_GRABBER:
        name_base = "video";
        break;
    case VFL_TYPE_VBI:
        name_base = "vbi";
        break;
    case VFL_TYPE_RADIO:
        name_base = "radio";
        break;
    case VFL_TYPE_SUBDEV:
        name_base = "v4l-subdev";
        break;
    default:
        printk(KERN_ERR "%s called with unknown type: %d
",
               __func__, type);
        return -EINVAL;
    }
   //1.2
    vdev->vfl_type = type;
    vdev->cdev = NULL;
    if (vdev->v4l2_dev) {
        if (vdev->v4l2_dev->dev)
            vdev->parent = vdev->v4l2_dev->dev;

    /*
    在app应用程序中，可以通过Ioctl来设置、获得亮度等信息。那么驱动程序谁来接收/存储/ 设置到硬件，或从硬件中获得这些信息?
　　在驱动程序里面抽象出一个结构体V4L2_ctrl。
　　那么谁来管理v4l2_ctrl呢？
　　是利用v4l2_ctrl_handler进行管理的，它像链表一样，里面需要填充各个属 性，也可理解为设置各个属性。
　　在注册video_device之前的vivi_create_instance()函数中，
　　初始化v4l2_ctrl_handler
　　v4l2_ctrl_handler_init(hdl, 11);
　　创建v4l2_ctrl 并放入到v4l2_ctrl_handler链表
　　v4l2_ctrl_new_std()
　　v4l2_ctrl_new_custom()
　　dev->v4l2_dev.ctrl_handler = hdl;       //dev->v4l2_dev : v4l2_device 每一个v4l2设备都用这个结构来描述
　　下面的代码是将v4l2_ctrl_handler与video_device进行了关联
    */
        
        if (vdev->ctrl_handler == NULL)
            vdev->ctrl_handler = vdev->v4l2_dev->ctrl_handler;
        /* If the prio state pointer is NULL, then use the v4l2_device
           prio state. */
        if (vdev->prio == NULL)
            vdev->prio = &vdev->v4l2_dev->prio;
    }

    /* Part 2: find a free minor, device node number and device index. */
#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
    /* Keep the ranges for the first four types for historical
     * reasons.
     * Newer devices (not yet in place) should use the range
     * of 128-191 and just pick the first free minor there
     * (new style). */
     //2.1得到各类设备的次设备的偏移量，为的就是求次设备号
    switch (type) {
    case VFL_TYPE_GRABBER:
        minor_offset = 0;   //对于图像采集类设备，次设备号的偏移量是0
        minor_cnt = 64;
        break;
    case VFL_TYPE_RADIO:
        minor_offset = 64;  //对于radio类设备，次设备号的偏移量为64
        minor_cnt = 64;
        break;
    case VFL_TYPE_VBI:  //对于VBI类设备，次设备号的偏移量为224
        minor_offset = 224;
        minor_cnt = 32;
        break;
    default:
        minor_offset = 128;  //对于其他类的设备，次设备号的偏移量为128
        minor_cnt = 64;
        break;
    }
#endif

//2.2 得到设备节点的号
    /* Pick a device node number */
    mutex_lock(&videodev_lock);
   /*获取一个没有被使用的设备节点序号，如果传入的nr=-1,就会从0-64中选择，将选择一个没有被使用的设备节点序号并返回*/
    nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt);
    if (nr == minor_cnt)  //如果设备节点号正好等于64，那么就会从0-64中选择一个设备节点号，为什么又执行一次
        nr = devnode_find(vdev, 0, minor_cnt);
    if (nr == minor_cnt) {    //如果nr=64，那么说明没有空的设备节点号。因为是做多就是64个设备节点号，下标0-63。
        printk(KERN_ERR "could not get a free device node number
");
        mutex_unlock(&videodev_lock);
        return -ENFILE;
    }
#ifdef CONFIG_VIDEO_FIXED_MINOR_RANGES
    /* 1-on-1 mapping of device node number to minor number */
    i = nr;
#else
    /* The device node number and minor numbers are independent, so
       we just find the first free minor number. */
    for (i = 0; i < VIDEO_NUM_DEVICES; i++)
        //在video_device数组中找到一个空项。0-63存放的是VFL_TYPE_GRABBER，64-127存放的是VFL_TYPE_RADIO, 
        if (video_device[i] == NULL)    
            break;
    if (i == VIDEO_NUM_DEVICES) {
        mutex_unlock(&videodev_lock);
        printk(KERN_ERR "could not get a free minor
");
        return -ENFILE;
    }
#endif
    vdev->minor = i + minor_offset;    //次设备号就等于基数i + 次设备号的偏移量
    vdev->num = nr;      //设备号的结点，比如说nr=10,对应的类型是VFL_TYPE_GRABBER,那么最后应该看到/dev/video10
    devnode_set(vdev);

    /* Should not happen since we thought this minor was free */
    WARN_ON(video_device[vdev->minor] != NULL);
    vdev->index = get_index(vdev);
    mutex_unlock(&videodev_lock);

    /* Part 3: Initialize the character device ，这个地方就是注册一个字符设备的常规操作*/
    vdev->cdev = cdev_alloc();
    if (vdev->cdev == NULL) {
        ret = -ENOMEM;
        goto cleanup;
    }
    vdev->cdev->ops = &v4l2_fops;
    vdev->cdev->owner = owner;
    /*添加字符设备到系统*/
    ret = cdev_add(vdev->cdev, MKDEV(VIDEO_MAJOR, vdev->minor), 1);
    if (ret < 0) {
        printk(KERN_ERR "%s: cdev_add failed
", __func__);
        kfree(vdev->cdev);
        vdev->cdev = NULL;
        goto cleanup;
    }

    /* Part 4: register the device with sysfs */
    // 设置video_device所属的类，会在/sys/class/下创建目录
    vdev->dev.class = &video_class;
    /*通过主设备号和次设备号生成dev_t，表示的是一个设备号*/
    vdev->dev.devt = MKDEV(VIDEO_MAJOR, vdev->minor);
    if (vdev->parent)
        vdev->dev.parent = vdev->parent;
    dev_set_name(&vdev->dev, "%s%d", name_base, vdev->num);   //假设对应的是VFL_TYPE_GRABBER类设备，那么name_base就是video，即最后看到的应是/dev/videoxx
   /*利用device_register，注册字符设备驱动。这个地方和我们写的字符设备驱动程序是一样的*/
    ret = device_register(&vdev->dev);
    if (ret < 0) {
        printk(KERN_ERR "%s: device_register failed
", __func__);
        goto cleanup;
    }
    /* Register the release callback that will be called when the last
       reference to the device goes away. */
    vdev->dev.release = v4l2_device_release;

    if (nr != -1 && nr != vdev->num && warn_if_nr_in_use)
        printk(KERN_WARNING "%s: requested %s%d, got %s
", __func__,
            name_base, nr, video_device_node_name(vdev));

    /* Increase v4l2_device refcount */
    if (vdev->v4l2_dev)
        v4l2_device_get(vdev->v4l2_dev);

#if defined(CONFIG_MEDIA_CONTROLLER)
    /* Part 5: Register the entity. */
    if (vdev->v4l2_dev && vdev->v4l2_dev->mdev &&
        vdev->vfl_type != VFL_TYPE_SUBDEV) {
        vdev->entity.type = MEDIA_ENT_T_DEVNODE_V4L;
        vdev->entity.name = vdev->name;
        vdev->entity.info.v4l.major = VIDEO_MAJOR;
        vdev->entity.info.v4l.minor = vdev->minor;
        ret = media_device_register_entity(vdev->v4l2_dev->mdev,
            &vdev->entity);
        if (ret < 0)
            printk(KERN_WARNING
                   "%s: media_device_register_entity failed
",
                   __func__);
    }
#endif
    /* Part 6: Activate this minor. The char device can now be used. */
   /* Flag to mark the video_device struct as registered.
   Drivers can clear this flag if they want to block all future
   device access. It is cleared by video_unregister_device. 
 
   #define V4L2_FL_REGISTERED    (0)

    将这个unsigned long flags 的第0 位 置1，表示这个video_device 是注册过的了，
    在其他位置，会调用video_is_registeried( ) 来判断，其依据 还是测试这个flags的第0位。
    */
    set_bit(V4L2_FL_REGISTERED, &vdev->flags);
    mutex_lock(&videodev_lock);
    //依据次设备号为下标，将设置好的video_device放入到video_device[]中，其他函数会依据次设备号从这个数组中获取对应的video_device,这个和registered_fb[]设计的类似   static struct video_device*video_device[256];
    video_device[vdev->minor] = vdev;
    mutex_unlock(&videodev_lock);

    return 0;

cleanup:
    mutex_lock(&videodev_lock);
    if (vdev->cdev)
        cdev_del(vdev->cdev);
    devnode_clear(vdev);
    mutex_unlock(&videodev_lock);
    /* Mark this video device as never having been registered. */
    vdev->minor = -1;
    return ret;
}
EXPORT_SYMBOL(__video_register_device);