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.
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 busses 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 busses something similar needs to be done. Helper functions exists for sub-devices on an I2C bus that do most of this tricky work for you.
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:
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:
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:
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:
media_entity_cleanup(&sd->entity);
If the subdev driver intends to process video and integrate with the media framework, it must implement format related functionality using v4l2_subdev_pad_ops instead of v4l2_subdev_video_ops.
In that case, the subdev driver may set the link_validate field to provide its own link validation function. The link validation function is called for every link in the pipeline where both of the ends of the links are V4L2 sub-devices. 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.
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.
In the synchronous case a device (bridge) driver needs to register the v4l2_subdev with the v4l2_device:
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:
Afterwards the subdev module can be unloaded and sd->dev == NULL.
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 to 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.
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.
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.
Bridge drivers in turn have to register a notifier object with an array of subdevice descriptors that the bridge device needs for its operation. This is performed using the v4l2_async_notifier_register() call. To unregister the notifier the driver has to call v4l2_async_notifier_unregister(). The former of the two functions takes two arguments: a pointer to struct v4l2_device and a pointer to struct v4l2_async_notifier. The latter contains a pointer to an array of pointers to subdevice descriptors of type struct v4l2_async_subdev type. The V4L2 core will then use these descriptors to match asynchronously registered subdevices to them. If a match is detected the .bound() notifier callback is called. After all subdevices have been located the .complete() callback is called. When a subdevice is removed from the system the .unbind() method is called. All three callbacks are optional.
Beside exposing a kernel API through the v4l2_subdev_ops structure, V4L2 sub-devices can also be controlled directly by userspace applications.
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.
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.
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_USES_EVENTS v4l2_subdev.flags and initialize v4l2_subdev.nevents to events queue depth 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.
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_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.
used to decode_vbi_line
Definition
struct v4l2_decode_vbi_line {
u32 is_second_field;
u8 * p;
u32 line;
u32 type;
};
Members
Subdevice external IO pin configuration
Definition
struct v4l2_subdev_io_pin_config {
u32 flags;
u8 pin;
u8 function;
u8 value;
u8 strength;
};
Members
Define core ops callbacks for subdevs
Definition
struct v4l2_subdev_core_ops {
int (* log_status) (struct v4l2_subdev *sd);
int (* s_io_pin_config) (struct v4l2_subdev *sd, size_t n,struct v4l2_subdev_io_pin_config *pincfg);
int (* init) (struct v4l2_subdev *sd, u32 val);
int (* load_fw) (struct v4l2_subdev *sd);
int (* reset) (struct v4l2_subdev *sd, u32 val);
int (* s_gpio) (struct v4l2_subdev *sd, u32 val);
long (* ioctl) (struct v4l2_subdev *sd, unsigned int cmd, void *arg);
#ifdef CONFIG_COMPAT
long (* compat_ioctl32) (struct v4l2_subdev *sd, unsigned int cmd,unsigned long arg);
#endif
#ifdef CONFIG_VIDEO_ADV_DEBUG
int (* g_register) (struct v4l2_subdev *sd, struct v4l2_dbg_register *reg);
int (* s_register) (struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg);
#endif
int (* s_power) (struct v4l2_subdev *sd, int on);
int (* interrupt_service_routine) (struct v4l2_subdev *sd,u32 status, bool *handled);
int (* subscribe_event) (struct v4l2_subdev *sd, struct v4l2_fh *fh,struct v4l2_event_subscription *sub);
int (* unsubscribe_event) (struct v4l2_subdev *sd, struct v4l2_fh *fh,struct v4l2_event_subscription *sub);
};
Members
Callbacks used when v4l device was opened in radio mode.
Definition
struct v4l2_subdev_tuner_ops {
int (* s_radio) (struct v4l2_subdev *sd);
int (* s_frequency) (struct v4l2_subdev *sd, const struct v4l2_frequency *freq);
int (* g_frequency) (struct v4l2_subdev *sd, struct v4l2_frequency *freq);
int (* enum_freq_bands) (struct v4l2_subdev *sd, struct v4l2_frequency_band *band);
int (* g_tuner) (struct v4l2_subdev *sd, struct v4l2_tuner *vt);
int (* s_tuner) (struct v4l2_subdev *sd, const struct v4l2_tuner *vt);
int (* g_modulator) (struct v4l2_subdev *sd, struct v4l2_modulator *vm);
int (* s_modulator) (struct v4l2_subdev *sd, const struct v4l2_modulator *vm);
int (* s_type_addr) (struct v4l2_subdev *sd, struct tuner_setup *type);
int (* s_config) (struct v4l2_subdev *sd, const struct v4l2_priv_tun_config *config);
};
Members
Callbacks used for audio-related settings
Definition
struct v4l2_subdev_audio_ops {
int (* s_clock_freq) (struct v4l2_subdev *sd, u32 freq);
int (* s_i2s_clock_freq) (struct v4l2_subdev *sd, u32 freq);
int (* s_routing) (struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
int (* s_stream) (struct v4l2_subdev *sd, int enable);
};
Members
media bus frame description structure
Definition
struct v4l2_mbus_frame_desc_entry {
u16 flags;
u32 pixelcode;
u32 length;
};
Members
media bus data frame description
Definition
struct v4l2_mbus_frame_desc {
struct v4l2_mbus_frame_desc_entry entry[V4L2_FRAME_DESC_ENTRY_MAX];
unsigned short num_entries;
};
Members
Callbacks used when v4l device was opened in video mode.
Definition
struct v4l2_subdev_video_ops {
int (* s_routing) (struct v4l2_subdev *sd, u32 input, u32 output, u32 config);
int (* s_crystal_freq) (struct v4l2_subdev *sd, u32 freq, u32 flags);
int (* g_std) (struct v4l2_subdev *sd, v4l2_std_id *norm);
int (* s_std) (struct v4l2_subdev *sd, v4l2_std_id norm);
int (* s_std_output) (struct v4l2_subdev *sd, v4l2_std_id std);
int (* g_std_output) (struct v4l2_subdev *sd, v4l2_std_id *std);
int (* querystd) (struct v4l2_subdev *sd, v4l2_std_id *std);
int (* g_tvnorms) (struct v4l2_subdev *sd, v4l2_std_id *std);
int (* g_tvnorms_output) (struct v4l2_subdev *sd, v4l2_std_id *std);
int (* g_input_status) (struct v4l2_subdev *sd, u32 *status);
int (* s_stream) (struct v4l2_subdev *sd, int enable);
int (* g_pixelaspect) (struct v4l2_subdev *sd, struct v4l2_fract *aspect);
int (* g_parm) (struct v4l2_subdev *sd, struct v4l2_streamparm *param);
int (* s_parm) (struct v4l2_subdev *sd, struct v4l2_streamparm *param);
int (* g_frame_interval) (struct v4l2_subdev *sd,struct v4l2_subdev_frame_interval *interval);
int (* s_frame_interval) (struct v4l2_subdev *sd,struct v4l2_subdev_frame_interval *interval);
int (* s_dv_timings) (struct v4l2_subdev *sd,struct v4l2_dv_timings *timings);
int (* g_dv_timings) (struct v4l2_subdev *sd,struct v4l2_dv_timings *timings);
int (* query_dv_timings) (struct v4l2_subdev *sd,struct v4l2_dv_timings *timings);
int (* g_mbus_config) (struct v4l2_subdev *sd,struct v4l2_mbus_config *cfg);
int (* s_mbus_config) (struct v4l2_subdev *sd,const struct v4l2_mbus_config *cfg);
int (* s_rx_buffer) (struct v4l2_subdev *sd, void *buf,unsigned int *size);
};
Members
Callbacks used when v4l device was opened in video mode via the vbi device node.
Definition
struct v4l2_subdev_vbi_ops {
int (* decode_vbi_line) (struct v4l2_subdev *sd, struct v4l2_decode_vbi_line *vbi_line);
int (* s_vbi_data) (struct v4l2_subdev *sd, const struct v4l2_sliced_vbi_data *vbi_data);
int (* g_vbi_data) (struct v4l2_subdev *sd, struct v4l2_sliced_vbi_data *vbi_data);
int (* g_sliced_vbi_cap) (struct v4l2_subdev *sd, struct v4l2_sliced_vbi_cap *cap);
int (* s_raw_fmt) (struct v4l2_subdev *sd, struct v4l2_vbi_format *fmt);
int (* g_sliced_fmt) (struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt);
int (* s_sliced_fmt) (struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *fmt);
};
Members
v4l2-subdev sensor operations
Definition
struct v4l2_subdev_sensor_ops {
int (* g_skip_top_lines) (struct v4l2_subdev *sd, u32 *lines);
int (* g_skip_frames) (struct v4l2_subdev *sd, u32 *frames);
};
Members
describes the type of IR supported
Constants
Parameters for IR TX or TX
Definition
struct v4l2_subdev_ir_parameters {
unsigned int bytes_per_data_element;
enum v4l2_subdev_ir_mode mode;
bool enable;
bool interrupt_enable;
bool shutdown;
bool modulation;
u32 max_pulse_width;
unsigned int carrier_freq;
unsigned int duty_cycle;
bool invert_level;
bool invert_carrier_sense;
u32 noise_filter_min_width;
unsigned int carrier_range_lower;
unsigned int carrier_range_upper;
u32 resolution;
};
Members
operations for IR subdevices
Definition
struct v4l2_subdev_ir_ops {
int (* rx_read) (struct v4l2_subdev *sd, u8 *buf, size_t count,ssize_t *num);
int (* rx_g_parameters) (struct v4l2_subdev *sd,struct v4l2_subdev_ir_parameters *params);
int (* rx_s_parameters) (struct v4l2_subdev *sd,struct v4l2_subdev_ir_parameters *params);
int (* tx_write) (struct v4l2_subdev *sd, u8 *buf, size_t count,ssize_t *num);
int (* tx_g_parameters) (struct v4l2_subdev *sd,struct v4l2_subdev_ir_parameters *params);
int (* tx_s_parameters) (struct v4l2_subdev *sd,struct v4l2_subdev_ir_parameters *params);
};
Members
Used for storing subdev pad information.
Definition
struct v4l2_subdev_pad_config {
struct v4l2_mbus_framefmt try_fmt;
struct v4l2_rect try_crop;
struct v4l2_rect try_compose;
};
Members
Description
This structure only needs to be passed to the pad op if the ‘which’ field of the main argument is set to V4L2_SUBDEV_FORMAT_TRY. For V4L2_SUBDEV_FORMAT_ACTIVE it is safe to pass NULL.
v4l2-subdev pad level operations
Definition
struct v4l2_subdev_pad_ops {
int (* init_cfg) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg);
int (* enum_mbus_code) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_mbus_code_enum *code);
int (* enum_frame_size) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_frame_size_enum *fse);
int (* enum_frame_interval) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_frame_interval_enum *fie);
int (* get_fmt) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_format *format);
int (* set_fmt) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_format *format);
int (* get_selection) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_selection *sel);
int (* set_selection) (struct v4l2_subdev *sd,struct v4l2_subdev_pad_config *cfg,struct v4l2_subdev_selection *sel);
int (* get_edid) (struct v4l2_subdev *sd, struct v4l2_edid *edid);
int (* set_edid) (struct v4l2_subdev *sd, struct v4l2_edid *edid);
int (* dv_timings_cap) (struct v4l2_subdev *sd,struct v4l2_dv_timings_cap *cap);
int (* enum_dv_timings) (struct v4l2_subdev *sd,struct v4l2_enum_dv_timings *timings);
#ifdef CONFIG_MEDIA_CONTROLLER
int (* link_validate) (struct v4l2_subdev *sd, struct media_link *link,struct v4l2_subdev_format *source_fmt,struct v4l2_subdev_format *sink_fmt);
#endif
int (* get_frame_desc) (struct v4l2_subdev *sd, unsigned int pad,struct v4l2_mbus_frame_desc *fd);
int (* set_frame_desc) (struct v4l2_subdev *sd, unsigned int pad,struct v4l2_mbus_frame_desc *fd);
};
Members
Subdev operations
Definition
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_vbi_ops * vbi;
const struct v4l2_subdev_ir_ops * ir;
const struct v4l2_subdev_sensor_ops * sensor;
const struct v4l2_subdev_pad_ops * pad;
};
Members
V4L2 subdev internal ops
Definition
struct v4l2_subdev_internal_ops {
int (* registered) (struct v4l2_subdev *sd);
void (* unregistered) (struct v4l2_subdev *sd);
int (* open) (struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh);
int (* close) (struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh);
};
Members
Description
Note
Never call this from drivers, only the v4l2 framework can call these ops.
regulators config struct
Definition
struct v4l2_subdev_platform_data {
struct regulator_bulk_data * regulators;
int num_regulators;
void * host_priv;
};
Members
describes a V4L2 sub-device
Definition
struct v4l2_subdev {
#if defined(CONFIG_MEDIA_CONTROLLER)
struct media_entity entity;
#endif
struct list_head list;
struct module * owner;
bool owner_v4l2_dev;
u32 flags;
struct v4l2_device * v4l2_dev;
const struct v4l2_subdev_ops * ops;
const struct v4l2_subdev_internal_ops * internal_ops;
struct v4l2_ctrl_handler * ctrl_handler;
char name[V4L2_SUBDEV_NAME_SIZE];
u32 grp_id;
void * dev_priv;
void * host_priv;
struct video_device * devnode;
struct device * dev;
struct device_node * of_node;
struct list_head async_list;
struct v4l2_async_subdev * asd;
struct v4l2_async_notifier * notifier;
struct v4l2_subdev_platform_data * pdata;
};
Members
Description
Each instance of a subdev driver should create this struct, either stand-alone or embedded in a larger struct.
This structure should be initialized by v4l2_subdev_init() or one of its variants: v4l2_spi_subdev_init(), v4l2_i2c_subdev_init().
Used for storing subdev information per file handle
Definition
struct v4l2_subdev_fh {
struct v4l2_fh vfh;
#if defined(CONFIG_VIDEO_V4L2_SUBDEV_API)
struct v4l2_subdev_pad_config * pad;
#endif
};
Members
Sets V4L2 dev private device data
Parameters
Gets V4L2 dev private device data
Parameters
Description
Returns the pointer to the private device data to be stored.
Sets V4L2 dev private host data
Parameters
Gets V4L2 dev private data
Parameters
Description
Returns the pointer to the private host data to be stored.
validates a media link
Parameters
Description
This function ensures that width, height and the media bus pixel code are equal on both source and sink of the link.
validates a media link
Parameters
Description
This function calls the subdev’s link_validate ops to validate if a media link is valid for streaming. It also internally calls v4l2_subdev_link_validate_default() to ensure that width, height and the media bus pixel code are equal on both source and sink of the link.
Allocates memory for pad config
Parameters
Frees memory allocated by v4l2_subdev_alloc_pad_config().
Parameters
initializes the sub-device struct
Parameters
Delivers event notification for subdevice
Parameters
Description
Will deliver the specified event to all userspace event listeners which are subscribed to the v42l subdev event queue as well as to the bridge driver using the notify callback. The notification type for the notify callback will be V4L2_DEVICE_NOTIFY_EVENT.
type of asynchronous subdevice logic to be used in order to identify a match
Constants
Description
This enum is used by the asyncrhronous sub-device logic to define the algorithm that will be used to match an asynchronous device.
sub-device descriptor, as known to a bridge
Definition
struct v4l2_async_subdev {
enum v4l2_async_match_type match_type;
union match;
struct list_head list;
};
Members
v4l2_device notifier data
Definition
struct v4l2_async_notifier {
unsigned int num_subdevs;
struct v4l2_async_subdev ** subdevs;
struct v4l2_device * v4l2_dev;
struct list_head waiting;
struct list_head done;
struct list_head list;
int (* bound) (struct v4l2_async_notifier *notifier,struct v4l2_subdev *subdev,struct v4l2_async_subdev *asd);
int (* complete) (struct v4l2_async_notifier *notifier);
void (* unbind) (struct v4l2_async_notifier *notifier,struct v4l2_subdev *subdev,struct v4l2_async_subdev *asd);
};
Members
registers a subdevice asynchronous notifier
Parameters
unregisters a subdevice asynchronous notifier
Parameters
registers a sub-device to the asynchronous subdevice framework
Parameters
unregisters a sub-device to the asynchronous subdevice framework
Parameters