Linux内核中的V4L2核心框架分析（V4L2 framework，video for linux 2，linux视频子系统） .

驱动的结构
------------------------------------------------------
1）一个为设备实例定义的，并且包含设备状态信息的结构；
2）一种初始化和命令子设备（sub-devices）的方式；
3）创建V4L2设备节点（/dev/videoX, /dev/vbiX, /dev/radioX and /dev/vtxX）
   并且 keeping track of device-node specific data.
4）Filehandle-specific structs containing per-filehandle data;
5）视频buffer处理；

下面有个大略的关系描述图：

    device instances
      |
      +-sub-device instances
      |
      \-V4L2 device nodes
      |
      \-filehandle instances

 

框架的结构
------------------------------------------------------------
框架结构与驱动结构类似：
它有：
    一个用于device实例数据的结构体： v4l2_device ；
    一个用于sub-device实例的结构体：v4l2_subdev ；
    一个存储设备节点数据的结构体：video_device ；
    将来会用于保持对文件操作实例的追踪的结构体：v4l2_fh ；

 

v4l2_device结构体（struct v4l2_device）
-----------------------------------------------------------------------
每个设备实例是由一个struct v4l2_device结构（v4l2-device.h）来描述的。
很简单的设备可以只分配这个结构，但是，大部分时候，你将嵌入这个结构到一个更大的与描述特定设备的结构。
你必须注册设备实例（在drivers/media/video/v4l2-device.c中）：
 

v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev);

  v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev);

 

注册将初始化v4l2_device结构，和连接（link） dev->driver_data 到v4l2_dev。
如果v4l2_dev->name 是空的，那么它将被设置成一个值，这个值是由dev参数得到的（严格来说，驱动名跟随bus_id）。
如果你在调用v4l2_device_register()之前设置了v4l2_dev->name，那么v4l2_dev->name将不被改变（即使用你之前设置的值）。
如果dev是NULL，那么你必须在调用v4l2_device_register()之前填充v4l2_dev->name。

你可以使用 v4l2_device_set_name()来设置这个名称为驱动的名字 和 一个  driver-global atomic_t instance。
这将产生一些名字如： ivtv0, ivtv1 等。如果这些名字（ivtv0中的ivtv就是一个名字）以一个数字结束，那么它将插入一个“-”，然后跟上一个顺序的编号。
v4l2_device_set_name()这个函数返回这个实例号。

 

 

int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
                        atomic_t *instance)
{
    int num = atomic_inc_return(instance) - 1;
    int len = strlen(basename);

    if (basename[len - 1] >= '0' && basename[len - 1] <= '9')//如果名字的最后是数字；
        snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
                "%s-%d", basename, num);//那么名字后面加“-”
    else
        snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
                "%s%d", basename, num);
    return num;
}
EXPORT_SYMBOL_GPL(v4l2_device_set_name);

    int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
                            atomic_t *instance)
    {
        int num = atomic_inc_return(instance) - 1;
        int len = strlen(basename);

        if (basename[len - 1] >= '0' && basename[len - 1] <= '9')//如果名字的最后是数字；
            snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
                    "%s-%d", basename, num);//那么名字后面加“-”
        else
            snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
                    "%s%d", basename, num);
        return num;
    }
    EXPORT_SYMBOL_GPL(v4l2_device_set_name);

 

现在回头说v4l2_device_register函数。它的第一个参数dev通常都是一个pci_dev
、usb_interface 或者 platform_device 的“struct device”类型的指针。
dev基本上不会是NULL，但是在ISA devices或者当一个设备创建了多个PCI设备的时候，这是可能发生的。
这时候它与v4l2_dev产生了关系，v4l2_dev下可能有个dev成员（即v4l2_dev是父，dev是子）。

你也可以提供一个 notify()的回调函数，子设备（sub-devices）可以调用这个回调函数通知你一些事件（events）；
你是否需要设置这个回调函数，取决于这个子设备。一个子设备支持的任何通知（notifications）必须被定义在头文件“include/media/<subdevice>.h”当中。
比如include/media/ 下有如下文件：
    v4l2-chip-ident.h  v4l2-fh.h          v4l2-mem2mem.h         videobuf-dvb.h
    v4l2-common.h      v4l2-i2c-drv.h     v4l2-subdev.h          videobuf-vmalloc.h
    v4l2-dev.h         v4l2-int-device.h  videobuf-core.h            tvp5150.h（这个就是subdevice的头文件）
    v4l2-device.h      v4l2-ioctl.h       videobuf-dma-contig.h
    v4l2-event.h       v4l2-mediabus.h    videobuf-dma-sg.h     …………

有注册，就有反注册。那对应的反注册的函数是：

v4l2_device_unregister(struct v4l2_device *v4l2_dev);

    v4l2_device_unregister(struct v4l2_device *v4l2_dev);

 

反注册，也将会自动从设备反注册掉所有的子设备（subdevs）。

如果你有一个可热插拔的（hotpluggable）的设备（例如USB设备），那么的那个一个disconnect（断开）发生时，父设备变成无效的（invalid）。
因为v4l2_device中有一个指针指向父设备，所以他可以同时被清除掉，并且标记父设备is gone（这里应该是在父设备的结构里标记子设备已经无效了）。
    v4l2_device_disconnect(struct v4l2_device *v4l2_dev); //热插拔使用的断开函数

 

void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
{
    if (v4l2_dev->dev) {//这个函数制式标记了父设备那边告诉子设备已经无效。
        dev_set_drvdata(v4l2_dev->dev, NULL);
        v4l2_dev->dev = NULL;
    }
}
EXPORT_SYMBOL_GPL(v4l2_device_disconnect);

    void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
    {
        if (v4l2_dev->dev) {//这个函数制式标记了父设备那边告诉子设备已经无效。
            dev_set_drvdata(v4l2_dev->dev, NULL);
            v4l2_dev->dev = NULL;
        }
    }
    EXPORT_SYMBOL_GPL(v4l2_device_disconnect);

v4l2_device_disconnect不会反注册掉子设备，所以你依然需要为子设备调用v4l2_device_unregister这个函数。
事实上，v4l2_device_unregister函数中还是会调用v4l2_device_disconnect的。

void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
{
    struct v4l2_subdev *sd, *next;

    if (v4l2_dev == NULL)
        return;
    v4l2_device_disconnect(v4l2_dev);
        …………
}

    void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
    {
        struct v4l2_subdev *sd, *next;

        if (v4l2_dev == NULL)
            return;
        v4l2_device_disconnect(v4l2_dev);
            …………
    }

 

如果你的设备不支持热插拔，那么就不需要调用v4l2_device_disconnect()了。

有时候，你需要迭代把所有的设备通过一个特定的驱动注册。这种情况通常发生在，多个设备驱动使用同一个硬件（hardware）的时候。
例如（E.g.），ivtvfb 驱动是一个 帧缓冲(framebuffer)设备驱动，这个驱动使用ivtv这个硬件。类似的 alsa驱动也是一样。

你可以像如下这样迭代所有已注册的设备：

 

static int callback(struct device *dev, void *p)
{
    struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);

    /* test if this device was inited */
    if (v4l2_dev == NULL)
        return 0;
    ...
    return 0;
}

int iterate(void *p)
{
    struct device_driver *drv;
    int err;

    /* Find driver 'ivtv' on the PCI bus.
       pci_bus_type is a global. For USB busses use usb_bus_type. */
    drv = driver_find("ivtv", &pci_bus_type);//在&pci_bus_type上查找ivtv的驱动，并返回驱动的指针drv
    /* iterate over all ivtv device instances */
    err = driver_for_each_device(drv, NULL, p, callback);//这里用到了callback，和drv
    put_driver(drv);//在争用的那个硬件上使用驱动drv；
    return err;
}

    static int callback(struct device *dev, void *p)
    {
        struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);

        /* test if this device was inited */
        if (v4l2_dev == NULL)
            return 0;
        ...
        return 0;
    }

    int iterate(void *p)
    {
        struct device_driver *drv;
        int err;

        /* Find driver 'ivtv' on the PCI bus.
           pci_bus_type is a global. For USB busses use usb_bus_type. */
        drv = driver_find("ivtv", &pci_bus_type);//在&pci_bus_type上查找ivtv的驱动，并返回驱动的指针drv
        /* iterate over all ivtv device instances */
        err = driver_for_each_device(drv, NULL, p, callback);//这里用到了callback，和drv
        put_driver(drv);//在争用的那个硬件上使用驱动drv；
        return err;
    }

有时候你需要保持一个正在运行的设备实例的计数器（counter）。这个计数器经常用于映射（map）一个设备实例到一个模块可选数组的索引（an index of a module option array）。
建议的方法如下：

static atomic_t drv_instance = ATOMIC_INIT(0);

static int __devinit drv_probe(struct pci_dev *pdev,
                const struct pci_device_id *pci_id)
{
    ...
    state->instance = atomic_inc_return(&drv_instance) - 1;//atomic_inc_return(&drv_instance)自加的同时返回值
}

    static atomic_t drv_instance = ATOMIC_INIT(0);

    static int __devinit drv_probe(struct pci_dev *pdev,
                    const struct pci_device_id *pci_id)
    {
        ...
        state->instance = atomic_inc_return(&drv_instance) - 1;//atomic_inc_return(&drv_instance)自加的同时返回值
    }

 

 

子设备结构（struct v4l2_subdev）
-----------------------------------------------------------------------------------
       许多驱动需要与子设备（sub-devices）通信。这些设备可以对任务进行排序，但是更常见的是，它们处理audio and/or video复用（muxing），以及编码和解码。
对于webcams网络摄像头通常子设备是传感器（sensors）和摄像头控制器（camera controllers）。
通常这些是I2C设备，但不一定就是I2C设备。为了提供一个具有一致接口的驱动给这些子设备， v4l2_subdev 结构(v4l2-subdev.h)就是为此而诞生的.

        每个子设备驱动必须有一个 v4l2_subdev 结构。这个结构可以让简单的子设备保持独立，或者可以被嵌入到一个更大的结构体（如果更多的状态信息需要被存储的话）。
通常，有一个低层次的（low-level）设备结构（例如：i2c_client），包含了这个设备数据（device data），它由内核建立。
建议使用v4l2_set_subdevdata()函数存储一个i2c_client的指针到“v4l2_subdev”结构中的私有数据区域（ private data）。
这样使得很容易从v4l2_subdev交互到一个实际的低层次的特定总线（low-level bus-specific）设备数据。

你也需要一种方法去从低层次的结构 走到 v4l2_subdev。对于共有的i2c_client 结构，i2c_set_clientdata()这个函数调用可以被用来存储一个v4l2_subdev类型的指针，对于其他总线，你可能必须使用其他方法。

从桥接驱动的观点上来看（From the bridge driver perspective），你要加载子设备模块，并且以某种方式（somehow）获得v4l2_subdev的指针。
对于i2c设备这是很容易的：你调用i2c_get_clientdata()函数就可以了。对于其他总线，有类似的的做法。
在一个I2C总线的子设备中有帮助函数存在，这些函数会帮你做大部分繁琐复杂的工作。

每个v4l2_subdev包含了若干函数指针，子设备驱动可以实现这些函数（或者让它为 NULL，如果不用到它的话）。因为子设备可以做任何这样的事情，并且你不想以一个巨大的ops结构（一大串通常已经实现的ops，ops即包含上述函数指针的结构体）。这些函数指针已经按照分类排序了，并且每个分类具有它自己的ops结构体。

顶层的（top-level）的ops结构体包含了到分类ops结构体的指针，它们可以是NULL，如果子设备驱动（subdev driver）不支持这个分类的任何功能的话。

这些ops看起来是这样：

 

struct v4l2_subdev_core_ops {
    int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);     int (*log_status)(struct v4l2_subdev *sd);
    int (*init)(struct v4l2_subdev *sd, u32 val);
    ...
};

struct v4l2_subdev_tuner_ops {
    ...
};

struct v4l2_subdev_audio_ops {
    ...
};

struct v4l2_subdev_video_ops {
    ...
};

//最后这个子设备的 ops 包含了 core_ops 、tuner_ops、audio_ops、video_ops 的指针。
struct v4l2_subdev_ops {
    const struct v4l2_subdev_core_ops  *core;
    const struct v4l2_subdev_tuner_ops *tuner;
    const struct v4l2_subdev_audio_ops *audio;
    const struct v4l2_subdev_video_ops *video;
};

struct v4l2_subdev_core_ops {
    int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip);     int (*log_status)(struct v4l2_subdev *sd);
    int (*init)(struct v4l2_subdev *sd, u32 val);
    ...
};

struct v4l2_subdev_tuner_ops {
    ...
};

struct v4l2_subdev_audio_ops {
    ...
};

struct v4l2_subdev_video_ops {
    ...
};

//最后这个子设备的 ops 包含了 core_ops 、tuner_ops、audio_ops、video_ops 的指针。
struct v4l2_subdev_ops {
    const struct v4l2_subdev_core_ops  *core;
    const struct v4l2_subdev_tuner_ops *tuner;
    const struct v4l2_subdev_audio_ops *audio;
    const struct v4l2_subdev_video_ops *video;
};

核心ops（core_ops）是所有子设备（subdevs）公用的，其他分类的ops是否试下取决于子设备。例如，一个视频设备不太可能去支持一个 audio ops 和vice versa。那么就不用事先相应分类的ops。

这种建立ops关系的方式，在依然保持它们易于添加新的ops和分类的同时，也限制了函数指针的数量。

一个子设备驱动使用如下函数初始化 v4l2_subdev结构：

v4l2_subdev_init(sd, &ops);

        v4l2_subdev_init(sd, &ops);

然后，你需要初始化 使用一个唯一的名字来初始化 subdev->name，并且设置这个 module owner。如果你使用I2C帮助函数，那么这些帮助函数都已经为你做了这些工作了。

一个设备（桥接）驱动，需要使用如下函数去把 v4l2_subdev 与 v4l2_device 注册到一起：

int err = v4l2_device_register_subdev(v4l2_dev, sd);//sd代表v4l2_subdev；v4l2_dev代表：v4l2_device

    int err = v4l2_device_register_subdev(v4l2_dev, sd);//sd代表v4l2_subdev；v4l2_dev代表：v4l2_device

 如果子设备模块在它成功注册之前消失了，那这个注册函数肯定会失败的。
这个函数成功执行之后， subdev->dev 就会指向 v4l2_device。于是就关联起来了。

  

/*******2012年8月14日10:00 更新*********/
 
子设备移除（反注册）；你也可以通过这个函数反注册掉之前注册的子设备：
 v4l2_device_unregister_subdev(sd);
在这个函数执行之后，子设备模块就被卸载了(be unloaded)，并且sd->dev==NULL;

你可以也可以直接调用ops函数：
   err = sd->ops->core->g_chip_ident(sd, &chip);
但是，用下面这个宏的话，更方便，更快捷：
    err = v4l2_subdev_call(sd, core, g_chip_ident, &chip);
 
 这个宏将做NULL指针的检查，并且返回错误码 -ENODEV（如果子设备（subdev）是NULL的话）；
  subdev->core 或 subdev->core->g_chip_ident 是NULL的话，就会返回 -ENOIOCTLCMD；
 如果输入参数都没有问题，那就会返回 subdev->ops->core->g_chip_ident 这个操作的返回值。

一般也会调用 sub-devices中的所有函数，或是一个子集（某类函数）：
    v4l2_device_call_all(v4l2_dev, 0, core, g_chip_ident, &chip);
 任何不支持这个ops的子设备（subdev），会被跳过，并且错误的结果也会被忽略。

 如果你想检查错误，请使用：
    err = v4l2_device_call_until_err(v4l2_dev, 0, core, g_chip_ident, &chip);
 除了-ENOIOCTLCMD的任何错误，将带着错误退出循环（loop）。除了-ENOIOCTLCMD以外，如果没有错误发生，那么就返回0。

 以上两个函数（v4l2_device_call_all，v4l2_device_call_until_err）的第二个参数是一个group ID。如果是0，那么所有的 subdevs被调用。如果是“非零”，那么这个非零的数字就是group ID，并且执行这个groupID内的所有的函数。
 在一个桥接驱动注册一个subdev之前，它可以设置sd->grp_id为任意它希望的值（默认是0）.这个值是桥接驱动（bridge driver）所拥有的，并且子设备驱动（sub-device driver）将不会修改或者使用它。

group ID 给了桥接驱动更多的控制，这些控制就是回调函数（callbacks）。
例如，现在有多个audio芯片在板上，每个都由改变音量的能力。但是，通常实际被使用的仅有一个（当用户需要去改变音量的时候）。那么你可以为那个子设备（subdev）设置 group ID 。例如，AUDIO_CONTROLLER，并且在调用v4l2_device_call_all()时，可以指定AUDIO_CONTROLLER 为group ID 值（第二个入参）。这样可以确保，它仅操作它需要的子设备（subdev）。

如果子设备需要通知（notify …… of ……） 它的父设备 v4l2_device 一个事件，那么就可以调用： v4l2_subdev_notify(sd, notification, arg)。这个宏会检查是否有一个 notify() 的回调函数已经定义，如果没有定义的话，就返回错误码：-ENODEV。否则，当然就是有定义notify() 回调，那自然就调用这个回调。

使用v4l2_subdev这个结构的优势是，它是一个通用的结构，并且没有包含任何底层硬件的特性（does
not contain any knowledge about the underlying hardware）。也就是说它是硬件无关，完全不用改动就可移植的。所以一个驱动包含了若干个subdevs，这些子设备（subdevs）都使用同一个I2C总线。但是也有一个subdev，它是可以被GPIO引脚来控制的。这些差别仅当设置设备的时候才有关系。但是一旦这个子设备被注册，它就是完全透明的。

 

 

I2C子设备驱动（I2C sub-device drivers）
---------------------------------------------------------------------------
因为这些驱动是公用的，这里提供了特别的帮助函数，它能有效的提升使用这些驱动的易用性（v4l2-common.h）。

在一个I2C驱动中添加v4l2_subdev支持，一个建议的方法是把v4l2_subdev结构体嵌入到为每个I2C设备实例创建的状态结构（state struct ）当中去。很简单的设备可能没有状态结构（state struct），并且在这样的情况下，你可以直接创建一个v4l2_subdev。

一个典型的状态结构（state struct ）将看起来像这样的（里面的“chipname”，应该是由 实际chip的名字来替代的）：

struct chipname_state {
    struct v4l2_subdev sd;
    ...  /* additional state fields */
};

初始化 v4l2_subdev 结构：

    v4l2_i2c_subdev_init(&state->sd, client, subdev_ops);

这个函数将填充所有v4l2_subdev的字段（fields），并且确保v4l2_subdev 和i2c_client 都指向对方。

你应该也添加一个内联帮助函数去从 v4l2_subdev 指针跳转到 chipname_state 的结构（即获得chipname_state结构的指针）：

 static inline struct chipname_state *to_state(struct v4l2_subdev *sd)
 {
  return container_of(sd, struct chipname_state, sd);//实际上是使用container_of跳转的；ddl3这本书里有说明这个宏是怎么用的。
 }

使用如下函数从 v4l2_subdev 跳转到 i2c_client 结构（即获得指向i2c_client结构的指针）：
    struct i2c_client *client = v4l2_get_subdevdata(sd);

使用如下函数反过来从 i2c_client 跳转到 v4l2_subdev结构：
    struct v4l2_subdev *sd = i2c_get_clientdata(client);

确保当remove()回调函数被调用的时候，调用 v4l2_device_unregister_subdev(sd) 来反注册子设备。
这将从桥接驱动（bridge driver）反注册掉子设备（sub-device）。如果子设备从未被注册，那这个调用也是安全的。

你需要这么做，因为当桥接驱动从销毁I2C adapter的时候， 这个remove()回调会被在哪个adapter上的i2c设备调用。
在这之后，相应的v4l2_subdev结构，是无效的，所以它们需要被先反注册掉。在 remove()回调函数中，调用v4l2_device_unregister_subdev(sd) 可以确保总是正确的（不会忘记，或者在不恰当的地方调用反注册）。

桥接驱动也具有一些帮助性的函数：
struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter,
                            "module_foo", "chipid", 0x36, NULL);

这个加载了一些给出的模块（可以是NULL，如果没有模块需要被加载的话），并且调用
 i2c_new_device() ，
 使用给定的i2c_adapter 和 chip/address 作为入参。
如果一切没有问题的话，那么把subdev与v4l2_device 注册到一起的话就肯定会成功了。

你也可以使用
 v4l2_i2c_new_subdev()
的最后一个参数来传递一个 可能的I2C addresses的数组，而且应该probe。
如果前一个参数是0的话，那么仅使用这些probe addresses。一个非零的参数，意味着你知道确切的I2C地址，所以，在那种情况下probing将不会发生。

如果有错误的话，i2c_new_device() 和 v4l2_i2c_new_subdev() 两个函数，都返回NULL。

注意 传递给 v4l2_i2c_new_subdev() 的 chipid 通常是与模块名是一样的。 这允许你制定一个chip的变量。例如"saa7114" 和 "saa7115"。通常第，尽管i2c驱动自动探测名字。
chipid的使用是为了满足需要去更近的查看一个最新的日期。它区别了i2c驱动和可能混淆的东西。
要看被支持的chip variants（变量），你可以查看  i2c driver 的代码，查找 i2c_device_id 这个表。i2c_device_id中列出了所有可能的。

这里有更多帮助的函数：
    v4l2_i2c_new_subdev_cfg() // 位于 driver/media/video/v4l2-common.c
    这个 函数添加了新的irq和platform_data 参数，和 'addr' 和 'probed_addrs' 两个参数。
 如果addr不是0，“non-probing variant”将被使用，否则，“probed_addrs” 被probed。
 
 例如：这里将probe addresse 0x10：
 struct v4l2_subdev *sd = v4l2_i2c_new_subdev_cfg(v4l2_dev, adapter,
           "module_foo", "chipid", 0, NULL, 0, I2C_ADDRS(0x10));

v4l2_i2c_new_subdev_board 使用一个 i2c_board_info 结构（是被传递到i2c driver，并且替代 irq, platform_data 和 addr 这三个参数的）。

如果subdev 支持  s_config core ops ，那么在子设备建立之后，那个op是被调用，并传入 irq 和  platform_data 两个参数。更早的一个函数v4l2_i2c_new_(probed_)subdev ，也会调用 s_config ，但是入参 irq是0，platform_data是NULL。

 

video_device结构体（struct video_device）
------------------------------------------------------------------------------------
实际的设备节点 被创建（使用video_device 结构体(v4l2-dev.h)）在 /dev 目录。这个结构体也可以被动态分配，或是嵌入到更大的结构体。

 

 

struct video_device
{
    /* device ops */
    const struct v4l2_file_operations *fops;
    /* sysfs */
    struct device dev;      /* v4l device */
    struct cdev *cdev;      /* character device */
    /* Set either parent or v4l2_dev if your driver uses v4l2_device */
    struct device *parent;      /* device parent */
    struct v4l2_device *v4l2_dev;   /* v4l2_device parent */
    /* device info */
    char name[32];
    int vfl_type;
    /* 'minor' is set to -1 if the registration failed */
    int minor;
    u16 num;
    /* use bitops to set/clear/test flags */
    unsigned long flags;
    /* attribute to differentiate multiple indices on one physical device */
    int index;
    /* V4L2 file handles */
    spinlock_t      fh_lock; /* Lock for all v4l2_fhs */
    struct list_head    fh_list; /* List of struct v4l2_fh */
    int debug;          /* Activates debug level*/
    /* Video standard vars */
    v4l2_std_id tvnorms;        /* Supported tv norms */
    v4l2_std_id current_norm;   /* Current tvnorm */
    /* callbacks */
    void (*release)(struct video_device *vdev);
    /* ioctl callbacks */
    const struct v4l2_ioctl_ops *ioctl_ops;
};

struct video_device
{
    /* device ops */
    const struct v4l2_file_operations *fops;
    /* sysfs */
    struct device dev;      /* v4l device */
    struct cdev *cdev;      /* character device */
    /* Set either parent or v4l2_dev if your driver uses v4l2_device */
    struct device *parent;      /* device parent */
    struct v4l2_device *v4l2_dev;   /* v4l2_device parent */
    /* device info */
    char name[32];
    int vfl_type;
    /* 'minor' is set to -1 if the registration failed */
    int minor;
    u16 num;
    /* use bitops to set/clear/test flags */
    unsigned long flags;
    /* attribute to differentiate multiple indices on one physical device */
    int index;
    /* V4L2 file handles */
    spinlock_t      fh_lock; /* Lock for all v4l2_fhs */
    struct list_head    fh_list; /* List of struct v4l2_fh */
    int debug;          /* Activates debug level*/
    /* Video standard vars */
    v4l2_std_id tvnorms;        /* Supported tv norms */
    v4l2_std_id current_norm;   /* Current tvnorm */
    /* callbacks */
    void (*release)(struct video_device *vdev);
    /* ioctl callbacks */
    const struct v4l2_ioctl_ops *ioctl_ops;
};

 

 动态分配使用：

    struct video_device *vdev = video_device_alloc();

    if (vdev == NULL)
        return -ENOMEM;

    vdev->release = video_device_release;

如果嵌入它到一个更大的结构体，那么你必须设置  release() 回调函数为你自己的函数。

    struct video_device *vdev = &my_vdev->vdev;

    vdev->release = my_vdev_release;

这个 release() 回调函数 必须被设置，并且他是在最后一次使用video设备退出的时候被调用的。

默认的  video_device_release()  回调函数 仅在 调用kfree 去 释放被分配的内存的时候，才调用。

你也需要设置如下字段：
 - v4l2_dev： 设置为 v4l2_device 父设备；
 - name：  设置为某个描述名字，保证唯一性；
 - fops ： 设置为 v4l2_file_operations 结构体；
 - ioctl_ops： 如果你使用这个 v4l2_ioctl_ops 去简化 ioctl 的维护，那么设置它为 你的 v4l2_ioctl_ops 结构体。强烈建议使用 v4l2_ioctl_ops 结构体，这在将来是必须的。
 - parent： 如果 v4l2_device 使用 NULL的作为父设备的结构体参数，如果没有父设备的话。这样也是可以被注册的。但是这仅发生在一个硬件具有多个PCI设备，并且所有的都共享同一个 v4l2_device core 的情况下。

 cx88 驱动就是这样一个例子：一个 核心的v4l2_device结构体，但是，它只被一个  raw video PCI device (cx8800) 和 a MPEG PCI device (cx8802) 使用。因为 v4l2_device 不能与特殊的 没有父设备的PCI设备 关联起来。 但是，当 v4l2_device 被建立，你可以知道使用哪个父PCI设备。

如果你使用 v4l2_ioctl_ops 那么你需要设置 v4l2_file_operations 结构体内的 .unlocked_ioctl 或 .ioctl   为 video_ioctl2 。

v4l2_file_operations结构体 是一个 file_operations 的子集。主要的不同在于，inode  参数被忽略了，因为它从未被使用到。

 

video_device的注册（video_device registration）
----------------------------------------------------------------------------
你注册一个视频设备的时候，会创建一个字符设备。

    err = video_register_device(vdev, VFL_TYPE_GRABBER, -1); //在这个函数里使用了cdev_add()
    if (err) {
        video_device_release(vdev); /* or kfree(my_vdev); */
        return err;
    }

 被注册的设备取决于 type这个参数（第二个参数）。有如下的类型存在：
 VFL_TYPE_GRABBER:

                  videoX for video input/output devices //视频输入输出设备
 

VFL_TYPE_VBI:

                  vbiX for vertical blank data (i.e. closed captions, teletext)//用于垂直块数据的VBI

 VFL_TYPE_RADIO:

                  radioX for radio tuners //radio调谐设备

 VFL_TYPE_VTX:

                   vtxX for teletext devices (deprecated, don't use //vtx 图文电视广播设备

 

最后的参数（第三个参数）给出一个被使用的确定的在设备的设备节点号（如videoX 中的 “X”）。通常，你要传-1 使 v4l2框架选择第一个未使用的数字。但是，有时候，用户希望选择一个特定的节点号。通常，驱动允许用户通过一个驱动选项，去选择一个特定的设备节点号（device node number）。这个节点号，会被传递到这个函数，video_register_device 将试图去选择哪个设备节点号。如果那么节点号已经在使用的那个中，那么下一个临近的没有使用的设备节点号将被选择，并且它发送一个警告到kernel 的log。

另外一个使用情况是，如果一个驱动创建了许多设备（many devices）。在这种情况下，它（video_register_device）可以把不同的视频设备放置到不同独立的范围（in separate ranges）。例如，视频捕获设备(video capture devices)是从0 开始，视频输出设备是从16开始。所以你可以使用最近的参数去指定一个最小的设备节点号，并且v4l2框架将尝试去选择第一个空闲的没有被使用的数字，那可能等于或者大于你传递进来的数字（设备节点号）。
如果申请等于或大于你传递进来的数字失败（因为之前可能已经被申请过了），那么它将会选择第一个没被使用的数字。

如果在这种情况下，你不关心这样的警告（不能选择特定设备节点号的警告），你可以调用这个函数：
 video_register_device_no_warn() //忽略警告

无论什么时候创建设备节点，一些属性同时也会被创建。如果你查看  /sys/class/video4linux 这个目录，你会看到这些设备。 如 video0，和 你将看到 “name” 和 “index” 属性。“name”属性是 video_device 结构体的 “name” 字段。

“index”属性是这个设备节点的索引（index）：
每一次调用 video_register_device() 成功，index就加1 。 第一个视频设备节点，你总可以从索引值为0的数字开始注册。

用户可以建立 udev 规则（rules） ，利用index属性去制作一个 喜爱的设备名（比如mpegX。 用于 MPEG 视频捕获节点）。

在设备成功注册之后，你可以使用如下字段（都是video_device结构体中的字段）：

 - vfl_type: 传递给 video_register_device 的设备类型.
 - minor: 最后被分配的次设备号
 - num: 设备节点号 the device node number (i.e. the X in videoX).
 - index: 设备索引号 the device index number.

如果注册失败，那么你需要去调用 video_device_release() 来 释放分配的video_device结构体，或者 释放你自己的结构 ，如果 video_device 被嵌入在其中的话。  vdev->release() 回调将永远不会被调用， 如果注册失败的话。也你也不应该尝试反注册（unregister）这个设备，如果注册失败了。

 

 

video_device清理（video_device cleanup）
--------------------------------------------------------------------
当视频设备节点必须被移除的时候，可以在驱动的卸载器件，或者USB设备断开连接的时候，反注册它们（unregister them）：
    video_unregister_device(vdev);
这将从sysfs移除设备节点（导致udev从 /dev 移除它们）。

在  video_unregister_device() 返回之后，不能进行新的 open，即不能再打开这个设备。然而，USB设备的某些应用在这种情况下，依然有一个打开的设备节点。所以，在unregister所有的文件操作（all file operations ）之后，将返回一个错误，除了ioctl 和 unlocked_ioctl 文件操作：
 这些将依然被传递，因为一些 buffer ioctls 可能依然被需要。

 当最后一个用户使用的视频设备节点存在时， vdev->release() 回调函数被调用，并且你可以在这个函数里做最后的清理（final cleanup）。
 

 
video_device帮助函数（video_device helper functions）
------------------------------------------------------------------------------------------
有一些使用的帮助函数：

*- file/video_device private data

你可以  set/get  驱动的私有数据（private data，在 video_device 结构中）：

 void *video_get_drvdata(struct video_device *vdev);
 void video_set_drvdata(struct video_device *vdev, void *data);

注意，你可以在 video_register_device() 调用之前，安全的调用  video_set_drvdata()

下面这个video_devdata函数：
 struct video_device *video_devdata(struct file *file);
返回了 属于这个 file结构的 video_device 结构。

video_drvdata 函数包含了 video_get_drvdata 和 video_devdata：
 void *video_drvdata(struct file *file);

 你可以从 video_device 结构 跳转至 v4l2_device 使用：
 struct v4l2_device *v4l2_dev = vdev->v4l2_dev;

 
*- 设备节点名 （Device node name）

 video_device的节点 内核名，可以被使用如下函数检索：
 const char *video_device_node_name(struct video_device *vdev);

名字是被用作用户空间工具的示意，例如 udev （udev貌似是用户控件操作驱动的一类工具？）。这个函数应该在“可能代替访问 video_device::num h 和 video_device::minor 这两个字段的地方” 使用。

 

 

video buffer 帮助函数（ helper functions）
--------------------------------------------------------------------------
v4l2内核API为处理video buffers 提供了一系列的标准方法（被叫做"videobuf"）。这些方法允许一个驱动以常见的方式实现 read(), mmap() 和 overlay() 这些函数。当前已经有一些方法用于在设备上使用video buffers ，这些设备支持DMA；而DMA支持 scatter/gather 方法（videobuf-dma-sg）、线性访问（videobuf-dma-contig）、 vmalloced buffers ，通常被用在USB驱动上（videobuf-vmalloc）。

更多关于如何使用 videobuf 层的信息，请参考 Documentation/video4linux/videobuf 。

 

v4l2_fh结构体（struct v4l2_fh）
-----------------------------------------------------------
v4l2_fh结构体（fh 是 file handle的缩写）提供了一种方式使得“保持文件处理（file handle）特定的数据”变得容易（被V4L2框架使用的数据）。对于驱动来说是否使用 v4l2_fh结构体 是可选的。

v4l2_fh结构体（在V4L2框架中，而不是驱动中） 的使用者通过测试 video_device->flags 的 V4L2_FL_USES_V4L2_FH bit位 来知道是否一个驱动应该使用 v4l2_fh结构体 （file->private_data 指针指向v4l2_fh）。

很有用的函数：

- v4l2_fh_init()
  初始化文件处理（file handle）。这些 *MUST* 由驱动中的 v4l2_file_operations->open() 来处理。

- v4l2_fh_add()
  添加一个 v4l2_fh 结构体到 video_device 的文件处理列表（file handle list）。它可能在初始化文件处理（file handle）之后被调用。

- v4l2_fh_del()
  从 video_device() 取消对 v4l2_fh 的关联。文件处理退出函数可能在此时被调用。

- v4l2_fh_exit()
  反初始化（Uninitialise）文件处理。在反初始化操作之后，v4l2_fh 结构体所占的内存被释放。

v4l2_fh结构体被当做驱动自己的文件处理结构的一部分 被分配内存。并且它在驱动的 open函数中，被驱动设置v4l2_fh指针为 file->private_data 。也就是说 一旦open函数被调用之后， file->private_data 这个指针就指向 v4l2_fh 。驱动可以通过使用 container_of 这个宏来提取（extract）他们自己的文件处理结构。

比如 ：

 

struct my_fh {
    int blah;
    struct v4l2_fh fh;
};

...

int my_open(struct file *file)
{
    struct my_fh *my_fh;
    struct video_device *vfd;
    int ret;

    ...

    ret = v4l2_fh_init(&my_fh->fh, vfd);
    if (ret)
        return ret;

    v4l2_fh_add(&my_fh->fh);

    file->private_data = &my_fh->fh;

    ...
}

int my_release(struct file *file)
{
    struct v4l2_fh *fh = file->private_data;
    struct my_fh *my_fh = container_of(fh, struct my_fh, fh); //container_of宏取出my_fh的地址

    ...
}

 

 

V4L2事件（V4L2 events）
----------------------------------------------------
V4L2的事件提供了一种通用的方式去 传递事件到用户空间。驱动必须使用v4l2_fh 结构体才能支持 V4L2事件。
 
很有用的函数：

- v4l2_event_alloc()
  要使用事件，驱动必须为文件处理（file handle）分配事件。通过不止一次调用v4l2_event_alloc()函数，驱动能确保总共至少n个事件被分配。这个函数不能再原子上下文（atomic context）中调用。

- v4l2_event_queue()
  到 视频设备（video device）的 事件队列（Queue events）。驱动仅负责去填充 type 和data 字段。别的字段将由 V4L2填充。

- v4l2_event_subscribe()
  如果 video_device->ioctl_ops->vidioc_subscribe_event 必须检查驱动是否具备处理 具有指定事件ID（event id）的事件过程（produce events ）的能力。那么它可以调用v4l2_event_subscribe() 去 签名（subscribe） 这些事件。

- v4l2_event_unsubscribe()
  vidioc_unsubscribe_event 位于 v4l2_ioctl_ops 结构中。 一个驱动可以直接地使用 v4l2_event_unsubscribe() ，除非它想在 unsubscription 进程中被调用。

  这些特殊的类型 V4L2_EVENT_ALL 可以被使用 来对所有事件进行 解除签名（unsubscribe）的操作。驱动希望可以以一个特殊的方式来处理这些。
 
- v4l2_event_pending()
  返回 pending事件（pending events）的 number 。当实现 poll 函数时很有用。

驱动不直接初始化事件。video_device->ioctl_ops->vidioc_subscribe_event 不是NULL的话，这些事件是通过  v4l2_fh_init() 函数来初始化的。这些 *MUST* 是在 驱动的 v4l2_file_operations->open() 处理中进行的。

事件是通过poll系统调用被传递至用户空间的。驱动可以使用 v4l2_fh->events->wait（wait_queue_head_t） 的 作为poll_wait()的一个参数。

事件分为：标准事件 （standard events）和 私密事件（private events）。新的标准事件必须使用最小有效的事件类型（the smallest available event type）。驱动必须从它们自己的类（从基类开始their own class starting from class base）中分配它们的事件。 这里所说的”基类（class base）“ V4L2_EVENT_PRIVATE_START + n * 1000  （n 是 最低有效的数字 ）。在class中的第一个事件类型是保留给将来使用的，所以第一个有效的事件类型是 'class base + 1' 。

一个关于如何使用 V4L2 events 的例子，可以在 OMAP 3 ISP 驱动中看到 （ at <URL:http://gitorious.org/omap3camera> ）。