原文链接
https://docs.kernel.org/driver-api/media/v4l2-subdev.html#calling-subdev-operations

2.7. V4L2 sub-devices
Many drivers need to communicate with sub-devices. These devices can do all sort of tasks, but most commonly they handle audio and/or video muxing, encoding or decoding. For webcams common sub-devices are sensors and camera controllers.

Usually these are I2C devices, but not necessarily. In order to provide the driver with a consistent interface to these sub-devices the v4l2_subdev struct (v4l2-subdev.h) was created.

许多驱动需要同sub-devices通信，这些设备可以做所有各种任务，但是最常见的它们处理音频和/或视频多路切换，编码，或解码。对webcams一般sub-devices是传感器和相机。
通常这些都是I2C 设备，但不一定。为了提供驱动一致性的接口给这些sub-devices，v4l2_subdev 这个结构被创建了。

Each sub-device driver must have a v4l2_subdev struct. This struct can be stand-alone for simple sub-devices or it might be embedded in a larger struct if more state information needs to be stored. Usually there is a low-level device struct (e.g. i2c_client) that contains the device data as setup by the kernel. It is recommended to store that pointer in the private data of v4l2_subdev using v4l2_set_subdevdata(). That makes it easy to go from a v4l2_subdev to the actual low-level bus-specific device data.

You also need a way to go from the low-level struct to v4l2_subdev. For the common i2c_client struct the i2c_set_clientdata() call is used to store a v4l2_subdev pointer, for other buses you may have to use other methods.

Bridges might also need to store per-subdev private data, such as a pointer to bridge-specific per-subdev private data. The v4l2_subdev structure provides host private data for that purpose that can be accessed with v4l2_get_subdev_hostdata() and v4l2_set_subdev_hostdata().

From the bridge driver perspective, you load the sub-device module and somehow obtain the v4l2_subdev pointer. For i2c devices this is easy: you call i2c_get_clientdata(). For other buses something similar needs to be done. Helper functions exist for sub-devices on an I2C bus that do most of this tricky work for you.

每个 sub-device驱动必须有一个v4l2_subdev结构体。这个结构体可以是单独的，对简单的
sub-devices来说，或者可以被嵌入到大结构体，如果更多的状态信息需要被存贮。通常，
一个低级的device结构体（比如i2c_client），当建立内核的时候就包含了这个设备数据。
建议使用v4l2_set_subdevdata函数保存v4l2_subdev私有数据。这样使从v4l2_subdev’到实际的低级总线特定的设备数据容易运行。
另外你也需要一种途径，运行从低级结构体到v4l2_subdev。对于一般的 i2c_client
结构体，i2c_set_clientdata()调用被使用来存储v4l2_subdev指针。对于其他总线，你必须选择另外的方法。
桥接有可能另外你需要保存每个subdev 特定的数据，比如一个桥特定subdev特定的数据指针。 v4l2_subdev 结构体提供了host特定数据，这能通过v4l2_get_subdev_hostdata、v4l2_get_subdev_hostdata访问来达成。
从桥接驱动来看，你可以加载sub-device模块且获取v4l2_subdev 指针。对于i2c 设备比较简单：你可以调用i2c_get_clientdata()。对于其他类型的总线，类似的操作。存在的 i2c总线上的sub-devices帮助函数做了大部分的设计。

Each v4l2_subdev contains function pointers that sub-device drivers can implement (or leave NULL if it is not applicable). Since sub-devices can do so many different things and you do not want to end up with a huge ops struct of which only a handful of ops are commonly implemented, the function pointers are sorted according to category and each category has its own ops struct.

The top-level ops struct contains pointers to the category ops structs, which may be NULL if the subdev driver does not support anything from that category.

It looks like this:

每个v4l2_subdev包含了一组函数指针，sub-device驱动可以实现（NULL如果没用上）。因此sub-devices可以能处理许多不同的事情，你不可以使用大操作 结构体，然而只有一个小操作结构体被实现。函数指针根据类别保存，每个类别有自己单独的ops 结构
顶层的ops 结构包含了分类ops结构的指针，这些可能是NULL，如果subdev 不支持这些类别。
这看起来像这样

struct v4l2_subdev_core_ops {
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 {
…
};

struct v4l2_subdev_pad_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;
const struct v4l2_subdev_pad_ops *video;
};
The core ops are common to all subdevs, the other categories are implemented depending on the sub-device. E.g. a video device is unlikely to support the audio ops and vice versa.

This setup limits the number of function pointers while still making it easy to add new ops and categories.

A sub-device driver initializes the v4l2_subdev struct using:

core ops 是所有subdevs共有的，其他分类根据sub-device来实现。比如视频设备不可能支持音频ops，反过来也成立。
这种安排限制了函数指针的数量，同时仍然使添加新的ops 和类别更容易。
一个sub-device驱动初始化v4l2_subdev 结构体，使用

v4l2_subdev_init (sd, &ops).

Afterwards you need to initialize sd->name with a unique name and set the module owner. This is done for you if you use the i2c helper functions.

If integration with the media framework is needed, you must initialize the media_entity struct embedded in the v4l2_subdev struct (entity field) by calling media_entity_pads_init(), if the entity has pads:

最终，你必须初始化sd->name，用一个独一无二的命名，设置模块owner。这对你有用如果你要使用i2c帮助函数。
如果需要集成media框架，你必须通过media_entity_pads_init初始化嵌入到v4l2_subdev结构中的 media_entity`结构，如果这个entity 有pad

struct media_pad *pads = &my_sd->pads;
int err;

err = media_entity_pads_init(&sd->entity, npads, pads);
The pads array must have been previously initialized. There is no need to manually set the struct media_entity function and name fields, but the revision field must be initialized if needed.

A reference to the entity will be automatically acquired/released when the subdev device node (if any) is opened/closed.

Don’t forget to cleanup the media entity before the sub-device is destroyed:

pads 数组必须在之前已经初始化，没有必要手工设置 media_entity函数和name 字段，但是 revision必须初始化如果需要
一个entity 的引用计数将会自动的获取/释放，当subdev 设备被打开/关闭
不要忘记在sub-device销毁前清理media 的entity

media_entity_cleanup(&sd->entity);
If a sub-device driver implements sink pads, the subdev driver may set the link_validate field in v4l2_subdev_pad_ops to provide its own link validation function. For every link in the pipeline, the link_validate pad operation of the sink end of the link is called. In both cases the driver is still responsible for validating the correctness of the format configuration between sub-devices and video nodes.

If link_validate op is not set, the default function v4l2_subdev_link_validate_default() is used instead. This function ensures that width, height and the media bus pixel code are equal on both source and sink of the link. Subdev drivers are also free to use this function to perform the checks mentioned above in addition to their own checks.

如果sub-device实现了下游pad，subdev驱动可以设置v4l2_subdev_pad_ops的link_validate字段，来提供自身link的validation功能。对于pipeline中的每个link，link 的下游终端 link_validate
pad操作被调用。在这两种情形下，驱动仍然需要负责确认sub-devices和视频节点格式配置的正确。
如果link_validate op没有设置，默认的v4l2_subdev_link_validate_default将被使用。这个函数确保宽，高，媒体总线像素码等于源和link下游。Subdev驱动还可以自由使用这个函数执行上述提到的检查，另外还有他们自身的。

2.7.1. Subdev registration
There are currently two ways to register subdevices with the V4L2 core. The first (traditional) possibility is to have subdevices registered by bridge drivers. This can be done when the bridge driver has the complete information about subdevices connected to it and knows exactly when to register them. This is typically the case for internal subdevices, like video data processing units within SoCs or complex PCI(e) boards, camera sensors in USB cameras or connected to SoCs, which pass information about them to bridge drivers, usually in their platform data.

There are however also situations where subdevices have to be registered asynchronously to bridge devices. An example of such a configuration is a Device Tree based system where information about subdevices is made available to the system independently from the bridge devices, e.g. when subdevices are defined in DT as I2C device nodes. The API used in this second case is described further below.

Using one or the other registration method only affects the probing process, the run-time bridge-subdevice interaction is in both cases the same.

有两种使用V4L2 注册subdevices 的方法。第一种（传统的）通过桥接驱动注册 subdevices。这可以实施，当桥接驱动对链接到他的subdevices有全面的信息感知，并且精确的知道什么时候注册他们。这对内部subdevices是典型的情形，像在SOC或复合PCI(e)板上的视频数据处理单元，usb相机中的或者链接到SoC的相机传感器，这些传递他们的信息给桥接驱动，通常是他们的平台数据。
另外一类subdevices 不得不异步注册到桥接驱动。这样配置的一个案例是基于设备树的系统，这里关于subdevices 的信息建立可靠是和桥接驱动系统不相关的，比如这时subdevices 被定义为在DT 上的I2C 设备。这第二种情形的API后续将会描述。
使用这两种注册方法影响probing 进程，运行时桥-subdevice 互动是一样的

2.7.1.1. Registering synchronous sub-devices
In the synchronous case a device (bridge) driver needs to register the v4l2_subdev with the v4l2_device:

v4l2_device_register_subdev (v4l2_dev, sd).

This can fail if the subdev module disappeared before it could be registered. After this function was called successfully the subdev->dev field points to the v4l2_device.

If the v4l2_device parent device has a non-NULL mdev field, the sub-device entity will be automatically registered with the media device.

You can unregister a sub-device using:

v4l2_device_unregister_subdev (sd).

Afterwards the subdev module can be unloaded and sd->dev == NULL.

2.7.1.2. Registering asynchronous sub-devices
In the asynchronous case subdevice probing can be invoked independently of the bridge driver availability. The subdevice driver then has to verify whether all the requirements for a successful probing are satisfied. This can include a check for a master clock availability. If any of the conditions aren’t satisfied the driver might decide to return -EPROBE_DEFER to request further reprobing attempts. Once all conditions are met the subdevice shall be registered using the v4l2_async_register_subdev() function. Unregistration is performed using the v4l2_async_unregister_subdev() call. Subdevices registered this way are stored in a global list of subdevices, ready to be picked up by bridge drivers.

Drivers must complete all initialization of the sub-device before registering it using v4l2_async_register_subdev(), including enabling runtime PM. This is because the sub-device becomes accessible as soon as it gets registered.

2.7.1.3. Asynchronous sub-device notifiers
Bridge drivers in turn have to register a notifier object. This is performed using the v4l2_async_nf_register() call. To unregister the notifier the driver has to call v4l2_async_nf_unregister(). Before releasing memory of an unregister notifier, it must be cleaned up by calling v4l2_async_nf_cleanup().

Before registering the notifier, bridge drivers must do two things: first, the notifier must be initialized using the v4l2_async_nf_init(). Second, bridge drivers can then begin to form a list of async connection descriptors that the bridge device needs for its operation. v4l2_async_nf_add_fwnode(), v4l2_async_nf_add_fwnode_remote() and v4l2_async_nf_add_i2c()

Async connection descriptors describe connections to external sub-devices the drivers for which are not yet probed. Based on an async connection, a media data or ancillary link may be created when the related sub-device becomes available. There may be one or more async connections to a given sub-device but this is not known at the time of adding the connections to the notifier. Async connections are bound as matching async sub-devices are found, one by one.

2.7.1.4. Asynchronous sub-device notifier for sub-devices
A driver that registers an asynchronous sub-device may also register an asynchronous notifier. This is called an asynchronous sub-device notifier and the process is similar to that of a bridge driver apart from that the notifier is initialised using v4l2_async_subdev_nf_init() instead. A sub-device notifier may complete only after the V4L2 device becomes available, i.e. there’s a path via async sub-devices and notifiers to a notifier that is not an asynchronous sub-device notifier.

2.7.1.5. Asynchronous sub-device registration helper for camera sensor drivers
v4l2_async_register_subdev_sensor() is a helper function for sensor drivers registering their own async connection, but it also registers a notifier and further registers async connections for lens and flash devices found in firmware. The notifier for the sub-device is unregistered and cleaned up with the async sub-device, using v4l2_async_unregister_subdev().

2.7.1.6. Asynchronous sub-device notifier example
These functions allocate an async connection descriptor which is of type struct v4l2_async_connection embedded in a driver-specific struct. The &struct v4l2_async_connection shall be the first member of this struct:

struct my_async_connection {
struct v4l2_async_connection asc;
…
};

struct my_async_connection *my_asc;
struct fwnode_handle *ep;

…

my_asc = v4l2_async_nf_add_fwnode_remote(&notifier, ep,
struct my_async_connection);
fwnode_handle_put(ep);

if (IS_ERR(my_asc))
return PTR_ERR(my_asc);
2.7.1.7. Asynchronous sub-device notifier callbacks
The V4L2 core will then use these connection descriptors to match asynchronously registered subdevices to them. If a match is detected the .bound() notifier callback is called. After all connections have been bound the .complete() callback is called. When a connection is removed from the system the .unbind() method is called. All three callbacks are optional.

Drivers can store any type of custom data in their driver-specific v4l2_async_connection wrapper. If any of that data requires special handling when the structure is freed, drivers must implement the .destroy() notifier callback. The framework will call it right before freeing the v4l2_async_connection.

2.7.2. Calling subdev operations
The advantage of using v4l2_subdev is that it is a generic struct and does not contain any knowledge about the underlying hardware. So a driver might contain several subdevs that use an I2C bus, but also a subdev that is controlled through GPIO pins. This distinction is only relevant when setting up the device, but once the subdev is registered it is completely transparent.

Once the subdev has been registered you can call an ops function either directly:

err = sd->ops->core->g_std(sd, &norm);
but it is better and easier to use this macro:

err = v4l2_subdev_call(sd, core, g_std, &norm);
The macro will do the right NULL pointer checks and returns -ENODEV if sd is NULL, -ENOIOCTLCMD if either sd->core or sd->core->g_std is NULL, or the actual result of the sd->ops->core->g_std ops.

It is also possible to call all or a subset of the sub-devices:

v4l2_device_call_all(v4l2_dev, 0, core, g_std, &norm);
Any subdev that does not support this ops is skipped and error results are ignored. If you want to check for errors use this:

err = v4l2_device_call_until_err(v4l2_dev, 0, core, g_std, &norm);
Any error except -ENOIOCTLCMD will exit the loop with that error. If no errors (except -ENOIOCTLCMD) occurred, then 0 is returned.

The second argument to both calls is a group ID. If 0, then all subdevs are called. If non-zero, then only those whose group ID match that value will be called. Before a bridge driver registers a subdev it can set sd->grp_id to whatever value it wants (it’s 0 by default). This value is owned by the bridge driver and the sub-device driver will never modify or use it.

The group ID gives the bridge driver more control how callbacks are called. For example, there may be multiple audio chips on a board, each capable of changing the volume. But usually only one will actually be used when the user want to change the volume. You can set the group ID for that subdev to e.g. AUDIO_CONTROLLER and specify that as the group ID value when calling v4l2_device_call_all(). That ensures that it will only go to the subdev that needs it.

If the sub-device needs to notify its v4l2_device parent of an event, then it can call v4l2_subdev_notify(sd, notification, arg). This macro checks whether there is a notify() callback defined and returns -ENODEV if not. Otherwise the result of the notify() call is returned.

2.8. V4L2 sub-device userspace API
Bridge drivers traditionally expose one or multiple video nodes to userspace, and control subdevices through the v4l2_subdev_ops operations in response to video node operations. This hides the complexity of the underlying hardware from applications. For complex devices, finer-grained control of the device than what the video nodes offer may be required. In those cases, bridge drivers that implement the media controller API may opt for making the subdevice operations directly accessible from userspace.

桥接驱动传统上暴露一个或多个视频节点给用户空间，通过v4l2_subdev_ops操作控制subdevices来响应视频节点操作。这隐藏了底层硬件来自应用的复杂度。对复杂设备，优于视频节点提供的细粒度的设备控制可以获取到。在这些情形下，桥接驱动实现了媒体控制器API可以选择subdevice 操作 使直接来自用户空间的可以访问。

Device nodes named v4l-subdevX can be created in /dev to access sub-devices directly. If a sub-device supports direct userspace configuration it must set the V4L2_SUBDEV_FL_HAS_DEVNODE flag before being registered.

After registering sub-devices, the v4l2_device driver can create device nodes for all registered sub-devices marked with V4L2_SUBDEV_FL_HAS_DEVNODE by calling v4l2_device_register_subdev_nodes(). Those device nodes will be automatically removed when sub-devices are unregistered.

The device node handles a subset of the V4L2 API.

设备节点命名为v4l-subdevX能被创建在 /dev 来直接访问sub-devices。如果一个sub-devices支持直接用户空间配置，他在注册前必须设置V4L2_SUBDEV_FL_HAS_DEVNODE 标志。
sub-devices注册后, v4l2_device驱动能给所有打上V4L2_SUBDEV_FL_HAS_DEVNODE标志的注册sub-devices 创建设备节点。这些设备节点当 sub-devices 取消注册时将会自动删除
设备节点处理V4L2 API的一个子集

VIDIOC_QUERYCTRL, VIDIOC_QUERYMENU, VIDIOC_G_CTRL, VIDIOC_S_CTRL, VIDIOC_G_EXT_CTRLS, VIDIOC_S_EXT_CTRLS and VIDIOC_TRY_EXT_CTRLS:

The controls ioctls are identical to the ones defined in V4L2. They behave identically, with the only exception that they deal only with controls implemented in the sub-device. Depending on the driver, those controls can be also be accessed through one (or several) V4L2 device nodes.

这些控制和定义在V4L2中的是类似的。行为类似，唯一例外的是处理是现在 sub-device的控制。依赖于不同驱动，这些控制能通过V4L2 设备节点被访问。

VIDIOC_DQEVENT, VIDIOC_SUBSCRIBE_EVENT and VIDIOC_UNSUBSCRIBE_EVENT

The events ioctls are identical to the ones defined in V4L2. They behave identically, with the only exception that they deal only with events generated by the sub-device. Depending on the driver, those events can also be reported by one (or several) V4L2 device nodes.

Sub-device drivers that want to use events need to set the V4L2_SUBDEV_FL_HAS_EVENTS v4l2_subdev.flags before registering the sub-device. After registration events can be queued as usual on the v4l2_subdev.devnode device node.

To properly support events, the poll() file operation is also implemented.

Private ioctls

All ioctls not in the above list are passed directly to the sub-device driver through the core::ioctl operation.

2.9. Read-only sub-device userspace API
Bridge drivers that control their connected subdevices through direct calls to the kernel API realized by v4l2_subdev_ops structure do not usually want userspace to be able to change the same parameters through the subdevice device node and thus do not usually register any.

It is sometimes useful to report to userspace the current subdevice configuration through a read-only API, that does not permit applications to change to the device parameters but allows interfacing to the subdevice device node to inspect them.

For instance, to implement cameras based on computational photography, userspace needs to know the detailed camera sensor configuration (in terms of skipping, binning, cropping and scaling) for each supported output resolution. To support such use cases, bridge drivers may expose the subdevice operations to userspace through a read-only API.

To create a read-only device node for all the subdevices registered with the V4L2_SUBDEV_FL_HAS_DEVNODE set, the v4l2_device driver should call v4l2_device_register_ro_subdev_nodes().

Access to the following ioctls for userspace applications is restricted on sub-device device nodes registered with v4l2_device_register_ro_subdev_nodes().

VIDIOC_SUBDEV_S_FMT, VIDIOC_SUBDEV_S_CROP, VIDIOC_SUBDEV_S_SELECTION:

These ioctls are only allowed on a read-only subdevice device node for the V4L2_SUBDEV_FORMAT_TRY formats and selection rectangles.

VIDIOC_SUBDEV_S_FRAME_INTERVAL, VIDIOC_SUBDEV_S_DV_TIMINGS, VIDIOC_SUBDEV_S_STD:

These ioctls are not allowed on a read-only subdevice node.

In case the ioctl is not allowed, or the format to modify is set to V4L2_SUBDEV_FORMAT_ACTIVE, the core returns a negative error code and the errno variable is set to -EPERM.

2.10. I2C sub-device drivers
Since these drivers are so common, special helper functions are available to ease the use of these drivers (v4l2-common.h).

The recommended method of adding v4l2_subdev support to an I2C driver is to embed the v4l2_subdev struct into the state struct that is created for each I2C device instance. Very simple devices have no state struct and in that case you can just create a v4l2_subdev directly.

A typical state struct would look like this (where ‘chipname’ is replaced by the name of the chip):

struct chipname_state {
struct v4l2_subdev sd;
… /* additional state fields */
};
Initialize the v4l2_subdev struct as follows:

v4l2_i2c_subdev_init(&state->sd, client, subdev_ops);
This function will fill in all the fields of v4l2_subdev ensure that the v4l2_subdev and i2c_client both point to one another.

You should also add a helper inline function to go from a v4l2_subdev pointer to a chipname_state struct:

static inline struct chipname_state *to_state(struct v4l2_subdev *sd)
{
return container_of(sd, struct chipname_state, sd);
}
Use this to go from the v4l2_subdev struct to the i2c_client struct:

struct i2c_client *client = v4l2_get_subdevdata(sd);
And this to go from an i2c_client to a v4l2_subdev struct:

struct v4l2_subdev *sd = i2c_get_clientdata(client);
Make sure to call v4l2_device_unregister_subdev()(sd) when the remove() callback is called. This will unregister the sub-device from the bridge driver. It is safe to call this even if the sub-device was never registered.

You need to do this because when the bridge driver destroys the i2c adapter the remove() callbacks are called of the i2c devices on that adapter. After that the corresponding v4l2_subdev structures are invalid, so they have to be unregistered first. Calling v4l2_device_unregister_subdev()(sd) from the remove() callback ensures that this is always done correctly.

The bridge driver also has some helper functions it can use:

struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter,
“module_foo”, “chipid”, 0x36, NULL);
This loads the given module (can be NULL if no module needs to be loaded) and calls i2c_new_client_device() with the given i2c_adapter and chip/address arguments. If all goes well, then it registers the subdev with the v4l2_device.

You can also use the last argument of v4l2_i2c_new_subdev() to pass an array of possible I2C addresses that it should probe. These probe addresses are only used if the previous argument is 0. A non-zero argument means that you know the exact i2c address so in that case no probing will take place.

Both functions return NULL if something went wrong.

Note that the chipid you pass to v4l2_i2c_new_subdev() is usually the same as the module name. It allows you to specify a chip variant, e.g. “saa7114” or “saa7115”. In general though the i2c driver autodetects this. The use of chipid is something that needs to be looked at more closely at a later date. It differs between i2c drivers and as such can be confusing. To see which chip variants are supported you can look in the i2c driver code for the i2c_device_id table. This lists all the possibilities.

There are one more helper function:

v4l2_i2c_new_subdev_board() uses an i2c_board_info struct which is passed to the i2c driver and replaces the irq, platform_data and addr arguments.

If the subdev supports the s_config core ops, then that op is called with the irq and platform_data arguments after the subdev was setup.

The v4l2_i2c_new_subdev() function will call v4l2_i2c_new_subdev_board(), internally filling a i2c_board_info structure using the client_type and the addr to fill it.

2.11. Centrally managed subdev active state
Traditionally V4L2 subdev drivers maintained internal state for the active device configuration. This is often implemented as e.g. an array of struct v4l2_mbus_framefmt, one entry for each pad, and similarly for crop and compose rectangles.

In addition to the active configuration, each subdev file handle has a struct v4l2_subdev_state, managed by the V4L2 core, which contains the try configuration.

To simplify the subdev drivers the V4L2 subdev API now optionally supports a centrally managed active configuration represented by v4l2_subdev_state. One instance of state, which contains the active device configuration, is stored in the sub-device itself as part of the v4l2_subdev structure, while the core associates a try state to each open file handle, to store the try configuration related to that file handle.

Sub-device drivers can opt-in and use state to manage their active configuration by initializing the subdevice state with a call to v4l2_subdev_init_finalize() before registering the sub-device. They must also call v4l2_subdev_cleanup() to release all the allocated resources before unregistering the sub-device. The core automatically allocates and initializes a state for each open file handle to store the try configurations and frees it when closing the file handle.

V4L2 sub-device operations that use both the ACTIVE and TRY formats receive the correct state to operate on through the ‘state’ parameter. The state must be locked and unlocked by the caller by calling v4l2_subdev_lock_state() and v4l2_subdev_unlock_state(). The caller can do so by calling the subdev operation through the v4l2_subdev_call_state_active() macro.

Operations that do not receive a state parameter implicitly operate on the subdevice active state, which drivers can exclusively access by calling v4l2_subdev_lock_and_get_active_state(). The sub-device active state must equally be released by calling v4l2_subdev_unlock_state().

Drivers must never manually access the state stored in the v4l2_subdev or in the file handle without going through the designated helpers.

While the V4L2 core passes the correct try or active state to the subdevice operations, many existing device drivers pass a NULL state when calling operations with v4l2_subdev_call(). This legacy construct causes issues with subdevice drivers that let the V4L2 core manage the active state, as they expect to receive the appropriate state as a parameter. To help the conversion of subdevice drivers to a managed active state without having to convert all callers at the same time, an additional wrapper layer has been added to v4l2_subdev_call(), which handles the NULL case by getting and locking the callee’s active state with v4l2_subdev_lock_and_get_active_state(), and unlocking the state after the call.

The whole subdev state is in reality split into three parts: the v4l2_subdev_state, subdev controls and subdev driver’s internal state. In the future these parts should be combined into a single state. For the time being we need a way to handle the locking for these parts. This can be accomplished by sharing a lock. The v4l2_ctrl_handler already supports this via its ‘lock’ pointer and the same model is used with states. The driver can do the following before calling v4l2_subdev_init_finalize():

sd->ctrl_handler->lock = &priv->mutex;
sd->state_lock = &priv->mutex;
This shares the driver’s private mutex between the controls and the states.

2.12. Streams, multiplexed media pads and internal routing
A subdevice driver can implement support for multiplexed streams by setting the V4L2_SUBDEV_FL_STREAMS subdev flag and implementing support for centrally managed subdev active state, routing and stream based configuration.

2.13. V4L2 sub-device functions and data structures