1.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.

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 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. 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.

Before registering the notifier, bridge drivers must do two things: first, the notifier must be initialized using the v4l2_async_notifier_init(). Second, bridge drivers can then begin to form a list of subdevice descriptors that the bridge device needs for its operation. Subdevice descriptors are added to the notifier using the v4l2_async_notifier_add_subdev() call. This function takes two arguments: a pointer to struct v4l2_async_notifier, and a pointer to the subdevice descripter, which is of type struct v4l2_async_subdev.

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.

1.8. V4L2 sub-device userspace API

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.

1.9. 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_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.

1.10. V4L2 sub-device functions and data structures

struct v4l2_decode_vbi_line

used to decode_vbi_line

Definition

struct v4l2_decode_vbi_line {
  u32 is_second_field;
  u8 *p;
  u32 line;
  u32 type;
};

Members

is_second_field
Set to 0 for the first (odd) field; set to 1 for the second (even) field.
p
Pointer to the sliced VBI data from the decoder. On exit, points to the start of the payload.
line
Line number of the sliced VBI data (1-23)
type
VBI service type (V4L2_SLICED_*). 0 if no service found
enum v4l2_subdev_io_pin_bits

Subdevice external IO pin configuration bits

Constants

V4L2_SUBDEV_IO_PIN_DISABLE
disables a pin config. ENABLE assumed.
V4L2_SUBDEV_IO_PIN_OUTPUT
set it if pin is an output.
V4L2_SUBDEV_IO_PIN_INPUT
set it if pin is an input.
V4L2_SUBDEV_IO_PIN_SET_VALUE
to set the output value via struct v4l2_subdev_io_pin_config->value.
V4L2_SUBDEV_IO_PIN_ACTIVE_LOW
pin active is bit 0. Otherwise, ACTIVE HIGH is assumed.
struct v4l2_subdev_io_pin_config

Subdevice external IO pin configuration

Definition

struct v4l2_subdev_io_pin_config {
  u32 flags;
  u8 pin;
  u8 function;
  u8 value;
  u8 strength;
};

Members

flags
bitmask with flags for this pin's config, whose bits are defined by enum v4l2_subdev_io_pin_bits.
pin
Chip external IO pin to configure
function
Internal signal pad/function to route to IO pin
value
Initial value for pin - e.g. GPIO output value
strength
Pin drive strength
struct v4l2_subdev_core_ops

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

log_status
callback for VIDIOC_LOG_STATUS() ioctl handler code.
s_io_pin_config
configure one or more chip I/O pins for chips that multiplex different internal signal pads out to IO pins. This function takes a pointer to an array of 'n' pin configuration entries, one for each pin being configured. This function could be called at times other than just subdevice initialization.
init
initialize the sensor registers to some sort of reasonable default values. Do not use for new drivers and should be removed in existing drivers.
load_fw
load firmware.
reset
generic reset command. The argument selects which subsystems to reset. Passing 0 will always reset the whole chip. Do not use for new drivers without discussing this first on the linux-media mailinglist. There should be no reason normally to reset a device.
s_gpio
set GPIO pins. Very simple right now, might need to be extended with a direction argument if needed.
ioctl
called at the end of ioctl() syscall handler at the V4L2 core. used to provide support for private ioctls used on the driver.
compat_ioctl32
called when a 32 bits application uses a 64 bits Kernel, in order to fix data passed from/to userspace.
g_register
callback for VIDIOC_DBG_G_REGISTER() ioctl handler code.
s_register
callback for VIDIOC_DBG_S_REGISTER() ioctl handler code.
s_power
puts subdevice in power saving mode (on == 0) or normal operation mode (on == 1).
interrupt_service_routine
Called by the bridge chip's interrupt service handler, when an interrupt status has be raised due to this subdev, so that this subdev can handle the details. It may schedule work to be performed later. It must not sleep. Called from an IRQ context.
subscribe_event
used by the drivers to request the control framework that for it to be warned when the value of a control changes.
unsubscribe_event
remove event subscription from the control framework.
struct v4l2_subdev_tuner_ops

Callbacks used when v4l device was opened in radio mode.

Definition

struct v4l2_subdev_tuner_ops {
  int (*standby)(struct v4l2_subdev *sd);
  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

standby
puts the tuner in standby mode. It will be woken up automatically the next time it is used.
s_radio
callback that switches the tuner to radio mode. drivers should explicitly call it when a tuner ops should operate on radio mode, before being able to handle it. Used on devices that have both AM/FM radio receiver and TV.
s_frequency
callback for VIDIOC_S_FREQUENCY() ioctl handler code.
g_frequency
callback for VIDIOC_G_FREQUENCY() ioctl handler code. freq->type must be filled in. Normally done by video_ioctl2() or the bridge driver.
enum_freq_bands
callback for VIDIOC_ENUM_FREQ_BANDS() ioctl handler code.
g_tuner
callback for VIDIOC_G_TUNER() ioctl handler code.
s_tuner
callback for VIDIOC_S_TUNER() ioctl handler code. vt->type must be filled in. Normally done by video_ioctl2 or the bridge driver.
g_modulator
callback for VIDIOC_G_MODULATOR() ioctl handler code.
s_modulator
callback for VIDIOC_S_MODULATOR() ioctl handler code.
s_type_addr
sets tuner type and its I2C addr.
s_config
sets tda9887 specific stuff, like port1, port2 and qss

Description

Note

On devices that have both AM/FM and TV, it is up to the driver to explicitly call s_radio when the tuner should be switched to radio mode, before handling other struct v4l2_subdev_tuner_ops that would require it. An example of such usage is:

static void s_frequency(void *priv, const struct v4l2_frequency *f)
{
      ...
      if (f.type == V4L2_TUNER_RADIO)
              v4l2_device_call_all(v4l2_dev, 0, tuner, s_radio);
      ...
      v4l2_device_call_all(v4l2_dev, 0, tuner, s_frequency);
}
struct v4l2_subdev_audio_ops

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

s_clock_freq
set the frequency (in Hz) of the audio clock output. Used to slave an audio processor to the video decoder, ensuring that audio and video remain synchronized. Usual values for the frequency are 48000, 44100 or 32000 Hz. If the frequency is not supported, then -EINVAL is returned.
s_i2s_clock_freq
sets I2S speed in bps. This is used to provide a standard way to select I2S clock used by driving digital audio streams at some board designs. Usual values for the frequency are 1024000 and 2048000. If the frequency is not supported, then -EINVAL is returned.
s_routing
used to define the input and/or output pins of an audio chip, and any additional configuration data. Never attempt to use user-level input IDs (e.g. Composite, S-Video, Tuner) at this level. An i2c device shouldn't know about whether an input pin is connected to a Composite connector, become on another board or platform it might be connected to something else entirely. The calling driver is responsible for mapping a user-level input to the right pins on the i2c device.
s_stream
used to notify the audio code that stream will start or has stopped.
enum v4l2_mbus_frame_desc_flags

media bus frame description flags

Constants

V4L2_MBUS_FRAME_DESC_FL_LEN_MAX
Indicates that struct v4l2_mbus_frame_desc_entry->length field specifies maximum data length.
V4L2_MBUS_FRAME_DESC_FL_BLOB
Indicates that the format does not have line offsets, i.e. the receiver should use 1D DMA.
struct v4l2_mbus_frame_desc_entry

media bus frame description structure

Definition

struct v4l2_mbus_frame_desc_entry {
  enum v4l2_mbus_frame_desc_flags flags;
  u32 pixelcode;
  u32 length;
};

Members

flags
bitmask flags, as defined by enum v4l2_mbus_frame_desc_flags.
pixelcode
media bus pixel code, valid if flags FRAME_DESC_FL_BLOB is not set.
length
number of octets per frame, valid if flags V4L2_MBUS_FRAME_DESC_FL_LEN_MAX is set.
struct v4l2_mbus_frame_desc

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

entry
frame descriptors array
num_entries
number of entries in entry array
struct v4l2_subdev_video_ops

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_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

s_routing
see s_routing in audio_ops, except this version is for video devices.
s_crystal_freq
sets the frequency of the crystal used to generate the clocks in Hz. An extra flags field allows device specific configuration regarding clock frequency dividers, etc. If not used, then set flags to 0. If the frequency is not supported, then -EINVAL is returned.
g_std
callback for VIDIOC_G_STD() ioctl handler code.
s_std
callback for VIDIOC_S_STD() ioctl handler code.
s_std_output
set v4l2_std_id for video OUTPUT devices. This is ignored by video input devices.
g_std_output
get current standard for video OUTPUT devices. This is ignored by video input devices.
querystd
callback for VIDIOC_QUERYSTD() ioctl handler code.
g_tvnorms
get v4l2_std_id with all standards supported by the video CAPTURE device. This is ignored by video output devices.
g_tvnorms_output
get v4l2_std_id with all standards supported by the video OUTPUT device. This is ignored by video capture devices.
g_input_status
get input status. Same as the status field in the struct v4l2_input
s_stream
used to notify the driver that a video stream will start or has stopped.
g_pixelaspect
callback to return the pixelaspect ratio.
g_frame_interval
callback for VIDIOC_SUBDEV_G_FRAME_INTERVAL() ioctl handler code.
s_frame_interval
callback for VIDIOC_SUBDEV_S_FRAME_INTERVAL() ioctl handler code.
s_dv_timings
Set custom dv timings in the sub device. This is used when sub device is capable of setting detailed timing information in the hardware to generate/detect the video signal.
g_dv_timings
Get custom dv timings in the sub device.
query_dv_timings
callback for VIDIOC_QUERY_DV_TIMINGS() ioctl handler code.
g_mbus_config
get supported mediabus configurations
s_mbus_config
set a certain mediabus configuration. This operation is added for compatibility with soc-camera drivers and should not be used by new software.
s_rx_buffer
set a host allocated memory buffer for the subdev. The subdev can adjust size to a lower value and must not write more data to the buffer starting at data than the original value of size.
struct v4l2_subdev_vbi_ops

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

decode_vbi_line
video decoders that support sliced VBI need to implement this ioctl. Field p of the struct v4l2_decode_vbi_line is set to the start of the VBI data that was generated by the decoder. The driver then parses the sliced VBI data and sets the other fields in the struct accordingly. The pointer p is updated to point to the start of the payload which can be copied verbatim into the data field of the struct v4l2_sliced_vbi_data. If no valid VBI data was found, then the type field is set to 0 on return.
s_vbi_data
used to generate VBI signals on a video signal. struct v4l2_sliced_vbi_data is filled with the data packets that should be output. Note that if you set the line field to 0, then that VBI signal is disabled. If no valid VBI data was found, then the type field is set to 0 on return.
g_vbi_data
used to obtain the sliced VBI packet from a readback register. Not all video decoders support this. If no data is available because the readback register contains invalid or erroneous data -EIO is returned. Note that you must fill in the 'id' member and the 'field' member (to determine whether CC data from the first or second field should be obtained).
g_sliced_vbi_cap
callback for VIDIOC_G_SLICED_VBI_CAP() ioctl handler code.
s_raw_fmt
setup the video encoder/decoder for raw VBI.
g_sliced_fmt
retrieve the current sliced VBI settings.
s_sliced_fmt
setup the sliced VBI settings.
struct v4l2_subdev_sensor_ops

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

g_skip_top_lines
number of lines at the top of the image to be skipped. This is needed for some sensors, which always corrupt several top lines of the output image, or which send their metadata in them.
g_skip_frames
number of frames to skip at stream start. This is needed for buggy sensors that generate faulty frames when they are turned on.
enum v4l2_subdev_ir_mode

describes the type of IR supported

Constants

V4L2_SUBDEV_IR_MODE_PULSE_WIDTH
IR uses struct ir_raw_event records
struct v4l2_subdev_ir_parameters

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

bytes_per_data_element
bytes per data element of data in read or write call.
mode
IR mode as defined by enum v4l2_subdev_ir_mode.
enable
device is active if true
interrupt_enable
IR interrupts are enabled if true
shutdown
if true: set hardware to low/no power, false: normal mode
modulation
if true, it uses carrier, if false: baseband
max_pulse_width
maximum pulse width in ns, valid only for baseband signal
carrier_freq
carrier frequency in Hz, valid only for modulated signal
duty_cycle
duty cycle percentage, valid only for modulated signal
invert_level
invert signal level
invert_carrier_sense
Send 0/space as a carrier burst. used only in TX.
noise_filter_min_width
min time of a valid pulse, in ns. Used only for RX.
carrier_range_lower
Lower carrier range, in Hz, valid only for modulated signal. Used only for RX.
carrier_range_upper
Upper carrier range, in Hz, valid only for modulated signal. Used only for RX.
resolution
The receive resolution, in ns . Used only for RX.
struct v4l2_subdev_ir_ops

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

rx_read
Reads received codes or pulse width data. The semantics are similar to a non-blocking read() call.
rx_g_parameters
Get the current operating parameters and state of the the IR receiver.
rx_s_parameters
Set the current operating parameters and state of the the IR receiver. It is recommended to call [rt]x_g_parameters first to fill out the current state, and only change the fields that need to be changed. Upon return, the actual device operating parameters and state will be returned. Note that hardware limitations may prevent the actual settings from matching the requested settings - e.g. an actual carrier setting of 35,904 Hz when 36,000 Hz was requested. An exception is when the shutdown parameter is true. The last used operational parameters will be returned, but the actual state of the hardware be different to minimize power consumption and processing when shutdown is true.
tx_write
Writes codes or pulse width data for transmission. The semantics are similar to a non-blocking write() call.
tx_g_parameters
Get the current operating parameters and state of the the IR transmitter.
tx_s_parameters
Set the current operating parameters and state of the the IR transmitter. It is recommended to call [rt]x_g_parameters first to fill out the current state, and only change the fields that need to be changed. Upon return, the actual device operating parameters and state will be returned. Note that hardware limitations may prevent the actual settings from matching the requested settings - e.g. an actual carrier setting of 35,904 Hz when 36,000 Hz was requested. An exception is when the shutdown parameter is true. The last used operational parameters will be returned, but the actual state of the hardware be different to minimize power consumption and processing when shutdown is true.
struct v4l2_subdev_pad_config

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

try_fmt
struct v4l2_mbus_framefmt
try_crop
struct v4l2_rect to be used for crop
try_compose
struct v4l2_rect to be used for compose

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.

struct v4l2_subdev_pad_ops

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

init_cfg
initialize the pad config to default values
enum_mbus_code
callback for VIDIOC_SUBDEV_ENUM_MBUS_CODE() ioctl handler code.
enum_frame_size
callback for VIDIOC_SUBDEV_ENUM_FRAME_SIZE() ioctl handler code.
enum_frame_interval
callback for VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL() ioctl handler code.
get_fmt
callback for VIDIOC_SUBDEV_G_FMT() ioctl handler code.
set_fmt
callback for VIDIOC_SUBDEV_S_FMT() ioctl handler code.
get_selection
callback for VIDIOC_SUBDEV_G_SELECTION() ioctl handler code.
set_selection
callback for VIDIOC_SUBDEV_S_SELECTION() ioctl handler code.
get_edid
callback for VIDIOC_SUBDEV_G_EDID() ioctl handler code.
set_edid
callback for VIDIOC_SUBDEV_S_EDID() ioctl handler code.
dv_timings_cap
callback for VIDIOC_SUBDEV_DV_TIMINGS_CAP() ioctl handler code.
enum_dv_timings
callback for VIDIOC_SUBDEV_ENUM_DV_TIMINGS() ioctl handler code.
link_validate
used by the media controller code to check if the links that belongs to a pipeline can be used for stream.
get_frame_desc
get the current low level media bus frame parameters.
set_frame_desc
set the low level media bus frame parameters, fd array may be adjusted by the subdev driver to device capabilities.
struct v4l2_subdev_ops

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

core
pointer to struct v4l2_subdev_core_ops. Can be NULL
tuner
pointer to struct v4l2_subdev_tuner_ops. Can be NULL
audio
pointer to struct v4l2_subdev_audio_ops. Can be NULL
video
pointer to struct v4l2_subdev_video_ops. Can be NULL
vbi
pointer to struct v4l2_subdev_vbi_ops. Can be NULL
ir
pointer to struct v4l2_subdev_ir_ops. Can be NULL
sensor
pointer to struct v4l2_subdev_sensor_ops. Can be NULL
pad
pointer to struct v4l2_subdev_pad_ops. Can be NULL
struct v4l2_subdev_internal_ops

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);
  void (*release)(struct v4l2_subdev *sd);
};

Members

registered
called when this subdev is registered. When called the v4l2_dev field is set to the correct v4l2_device.
unregistered
called when this subdev is unregistered. When called the v4l2_dev field is still set to the correct v4l2_device.
open
called when the subdev device node is opened by an application.
close
called when the subdev device node is closed. Please note that it is possible for close to be called after unregistered!
release
called when the last user of the subdev device is gone. This happens after the unregistered callback and when the last open filehandle to the v4l-subdevX device node was closed. If no device node was created for this sub-device, then the release callback is called right after the unregistered callback. The release callback is typically used to free the memory containing the v4l2_subdev structure. It is almost certainly required for any sub-device that sets the V4L2_SUBDEV_FL_HAS_DEVNODE flag.

Description

Note

Never call this from drivers, only the v4l2 framework can call these ops.

struct v4l2_subdev_platform_data

regulators config struct

Definition

struct v4l2_subdev_platform_data {
  struct regulator_bulk_data *regulators;
  int num_regulators;
  void *host_priv;
};

Members

regulators
Optional regulators used to power on/off the subdevice
num_regulators
Number of regululators
host_priv
Per-subdevice data, specific for a certain video host device
struct v4l2_subdev

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 fwnode_handle *fwnode;
  struct list_head async_list;
  struct v4l2_async_subdev *asd;
  struct v4l2_async_notifier *notifier;
  struct v4l2_async_notifier *subdev_notifier;
  struct v4l2_subdev_platform_data *pdata;
};

Members

entity
pointer to struct media_entity
list
List of sub-devices
owner
The owner is the same as the driver's struct device owner.
owner_v4l2_dev
true if the sd->owner matches the owner of v4l2_dev->dev owner. Initialized by v4l2_device_register_subdev().
flags
subdev flags. Can be: V4L2_SUBDEV_FL_IS_I2C - Set this flag if this subdev is a i2c device; V4L2_SUBDEV_FL_IS_SPI - Set this flag if this subdev is a spi device; V4L2_SUBDEV_FL_HAS_DEVNODE - Set this flag if this subdev needs a device node; V4L2_SUBDEV_FL_HAS_EVENTS - Set this flag if this subdev generates events.
v4l2_dev
pointer to struct v4l2_device
ops
pointer to struct v4l2_subdev_ops
internal_ops
pointer to struct v4l2_subdev_internal_ops. Never call these internal ops from within a driver!
ctrl_handler
The control handler of this subdev. May be NULL.
name
Name of the sub-device. Please notice that the name must be unique.
grp_id
can be used to group similar subdevs. Value is driver-specific
dev_priv
pointer to private data
host_priv
pointer to private data used by the device where the subdev is attached.
devnode
subdev device node
dev
pointer to the physical device, if any
fwnode
The fwnode_handle of the subdev, usually the same as either dev->of_node->fwnode or dev->fwnode (whichever is non-NULL).
async_list
Links this subdev to a global subdev_list or notifier->done list.
asd
Pointer to respective struct v4l2_async_subdev.
notifier
Pointer to the managing notifier.
subdev_notifier
A sub-device notifier implicitly registered for the sub- device using v4l2_device_register_sensor_subdev().
pdata
common part of subdevice platform data

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().

media_entity_to_v4l2_subdev(ent)

Returns a struct v4l2_subdev from the struct media_entity embedded in it.

Parameters

ent
pointer to struct media_entity.
vdev_to_v4l2_subdev(vdev)

Returns a struct v4l2_subdev from the struct video_device embedded on it.

Parameters

vdev
pointer to struct video_device
struct v4l2_subdev_fh

Used for storing subdev information per file handle

Definition

struct v4l2_subdev_fh {
  struct v4l2_fh vfh;
  struct module *owner;
#if defined(CONFIG_VIDEO_V4L2_SUBDEV_API);
  struct v4l2_subdev_pad_config *pad;
#endif;
};

Members

vfh
pointer to struct v4l2_fh
owner
module pointer to the owner of this file handle
pad
pointer to struct v4l2_subdev_pad_config
to_v4l2_subdev_fh(fh)

Returns a struct v4l2_subdev_fh from the struct v4l2_fh embedded on it.

Parameters

fh
pointer to struct v4l2_fh
struct v4l2_mbus_framefmt * v4l2_subdev_get_try_format(struct v4l2_subdev * sd, struct v4l2_subdev_pad_config * cfg, unsigned int pad)

ancillary routine to call struct v4l2_subdev_pad_config->try_fmt

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
struct v4l2_subdev_pad_config * cfg
pointer to struct v4l2_subdev_pad_config array.
unsigned int pad
index of the pad in the cfg array.
struct v4l2_rect * v4l2_subdev_get_try_crop(struct v4l2_subdev * sd, struct v4l2_subdev_pad_config * cfg, unsigned int pad)

ancillary routine to call struct v4l2_subdev_pad_config->try_crop

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
struct v4l2_subdev_pad_config * cfg
pointer to struct v4l2_subdev_pad_config array.
unsigned int pad
index of the pad in the cfg array.
struct v4l2_rect * v4l2_subdev_get_try_compose(struct v4l2_subdev * sd, struct v4l2_subdev_pad_config * cfg, unsigned int pad)

ancillary routine to call struct v4l2_subdev_pad_config->try_compose

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
struct v4l2_subdev_pad_config * cfg
pointer to struct v4l2_subdev_pad_config array.
unsigned int pad
index of the pad in the cfg array.
void v4l2_set_subdevdata(struct v4l2_subdev * sd, void * p)

Sets V4L2 dev private device data

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
void * p
pointer to the private device data to be stored.
void * v4l2_get_subdevdata(const struct v4l2_subdev * sd)

Gets V4L2 dev private device data

Parameters

const struct v4l2_subdev * sd
pointer to struct v4l2_subdev

Description

Returns the pointer to the private device data to be stored.

void v4l2_set_subdev_hostdata(struct v4l2_subdev * sd, void * p)

Sets V4L2 dev private host data

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
void * p
pointer to the private data to be stored.
void * v4l2_get_subdev_hostdata(const struct v4l2_subdev * sd)

Gets V4L2 dev private data

Parameters

const struct v4l2_subdev * sd
pointer to struct v4l2_subdev

Description

Returns the pointer to the private host data to be stored.

validates a media link

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
struct media_link * link
pointer to struct media_link
struct v4l2_subdev_format * source_fmt
pointer to struct v4l2_subdev_format
struct v4l2_subdev_format * sink_fmt
pointer to struct v4l2_subdev_format

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

struct media_link * link
pointer to struct media_link

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.

struct v4l2_subdev_pad_config * v4l2_subdev_alloc_pad_config(struct v4l2_subdev * sd)

Allocates memory for pad config

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
void v4l2_subdev_free_pad_config(struct v4l2_subdev_pad_config * cfg)

Frees memory allocated by v4l2_subdev_alloc_pad_config().

Parameters

struct v4l2_subdev_pad_config * cfg
pointer to struct v4l2_subdev_pad_config
void v4l2_subdev_init(struct v4l2_subdev * sd, const struct v4l2_subdev_ops * ops)

initializes the sub-device struct

Parameters

struct v4l2_subdev * sd
pointer to the struct v4l2_subdev to be initialized
const struct v4l2_subdev_ops * ops
pointer to struct v4l2_subdev_ops.
v4l2_subdev_call(sd, o, f, args...)

call an operation of a v4l2_subdev.

Parameters

sd
pointer to the struct v4l2_subdev
o
name of the element at struct v4l2_subdev_ops that contains f. Each element there groups a set of callbacks functions.
f
callback function that will be called if cond matches. The callback functions are defined in groups, according to each element at struct v4l2_subdev_ops.
args...
arguments for f.

Example

err = v4l2_subdev_call(sd, video, s_std, norm);

v4l2_subdev_has_op(sd, o, f)

Checks if a subdev defines a certain operation.

Parameters

sd
pointer to the struct v4l2_subdev
o
The group of callback functions in struct v4l2_subdev_ops which f is a part of.
f
callback function to be checked for its existence.
void v4l2_subdev_notify_event(struct v4l2_subdev * sd, const struct v4l2_event * ev)

Delivers event notification for subdevice

Parameters

struct v4l2_subdev * sd
The subdev for which to deliver the event
const struct v4l2_event * ev
The event to deliver

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.

enum v4l2_async_match_type

type of asynchronous subdevice logic to be used in order to identify a match

Constants

V4L2_ASYNC_MATCH_CUSTOM
Match will use the logic provided by struct v4l2_async_subdev.match ops
V4L2_ASYNC_MATCH_DEVNAME
Match will use the device name
V4L2_ASYNC_MATCH_I2C
Match will check for I2C adapter ID and address
V4L2_ASYNC_MATCH_FWNODE
Match will use firmware node

Description

This enum is used by the asyncrhronous sub-device logic to define the algorithm that will be used to match an asynchronous device.

struct v4l2_async_subdev

sub-device descriptor, as known to a bridge

Definition

struct v4l2_async_subdev {
  enum v4l2_async_match_type match_type;
  union {
    struct fwnode_handle *fwnode;
    const char *device_name;
    struct {
      int adapter_id;
      unsigned short address;
    } i2c;
    struct {
      bool (*match)(struct device *dev, struct v4l2_async_subdev *sd);
      void *priv;
    } custom;
  } match;
  struct list_head list;
  struct list_head asd_list;
};

Members

match_type
type of match that will be used
match
union of per-bus type matching data sets
match.fwnode
pointer to struct fwnode_handle to be matched. Used if match_type is V4L2_ASYNC_MATCH_FWNODE.
match.device_name
string containing the device name to be matched. Used if match_type is V4L2_ASYNC_MATCH_DEVNAME.
match.i2c
embedded struct with I2C parameters to be matched. Both match.i2c.adapter_id and match.i2c.address should be matched. Used if match_type is V4L2_ASYNC_MATCH_I2C.
match.i2c.adapter_id
I2C adapter ID to be matched. Used if match_type is V4L2_ASYNC_MATCH_I2C.
match.i2c.address
I2C address to be matched. Used if match_type is V4L2_ASYNC_MATCH_I2C.
match.custom
Driver-specific match criteria. Used if match_type is V4L2_ASYNC_MATCH_CUSTOM.
match.custom.match
Driver-specific match function to be used if V4L2_ASYNC_MATCH_CUSTOM.
match.custom.priv
Driver-specific private struct with match parameters to be used if V4L2_ASYNC_MATCH_CUSTOM.
list
used to link struct v4l2_async_subdev objects, waiting to be probed, to a notifier->waiting list
asd_list
used to add struct v4l2_async_subdev objects to the master notifier asd_list

Description

When this struct is used as a member in a driver specific struct, the driver specific struct shall contain the struct v4l2_async_subdev as its first member.

struct v4l2_async_notifier_operations

Asynchronous V4L2 notifier operations

Definition

struct v4l2_async_notifier_operations {
  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

bound
a subdevice driver has successfully probed one of the subdevices
complete
All subdevices have been probed successfully. The complete callback is only executed for the root notifier.
unbind
a subdevice is leaving
struct v4l2_async_notifier

v4l2_device notifier data

Definition

struct v4l2_async_notifier {
  const struct v4l2_async_notifier_operations *ops;
  struct v4l2_device *v4l2_dev;
  struct v4l2_subdev *sd;
  struct v4l2_async_notifier *parent;
  struct list_head asd_list;
  struct list_head waiting;
  struct list_head done;
  struct list_head list;
};

Members

ops
notifier operations
v4l2_dev
v4l2_device of the root notifier, NULL otherwise
sd
sub-device that registered the notifier, NULL otherwise
parent
parent notifier
asd_list
master list of struct v4l2_async_subdev
waiting
list of struct v4l2_async_subdev, waiting for their drivers
done
list of struct v4l2_subdev, already probed
list
member in a global list of notifiers
void v4l2_async_notifier_init(struct v4l2_async_notifier * notifier)

Initialize a notifier.

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier

Description

This function initializes the notifier asd_list. It must be called before the first call to v4l2_async_notifier_add_subdev.

int v4l2_async_notifier_add_subdev(struct v4l2_async_notifier * notifier, struct v4l2_async_subdev * asd)

Add an async subdev to the notifier's master asd list.

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
struct v4l2_async_subdev * asd
pointer to struct v4l2_async_subdev

Description

Call this function before registering a notifier to link the provided asd to the notifiers master asd_list.

struct v4l2_async_subdev * v4l2_async_notifier_add_fwnode_subdev(struct v4l2_async_notifier * notifier, struct fwnode_handle * fwnode, unsigned int asd_struct_size)

Allocate and add a fwnode async subdev to the notifier's master asd_list.

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
struct fwnode_handle * fwnode
fwnode handle of the sub-device to be matched
unsigned int asd_struct_size
size of the driver's async sub-device struct, including sizeof(struct v4l2_async_subdev). The struct v4l2_async_subdev shall be the first member of the driver's async sub-device struct, i.e. both begin at the same memory address.

Description

Allocate a fwnode-matched asd of size asd_struct_size, and add it to the notifiers asd_list. The function also gets a reference of the fwnode which is released later at notifier cleanup time.

int v4l2_async_notifier_add_fwnode_remote_subdev(struct v4l2_async_notifier * notif, struct fwnode_handle * endpoint, struct v4l2_async_subdev * asd)

Allocate and add a fwnode remote async subdev to the notifier's master asd_list.

Parameters

struct v4l2_async_notifier * notif
pointer to struct v4l2_async_notifier
struct fwnode_handle * endpoint
local endpoint pointing to the remote sub-device to be matched
struct v4l2_async_subdev * asd
Async sub-device struct allocated by the caller. The struct v4l2_async_subdev shall be the first member of the driver's async sub-device struct, i.e. both begin at the same memory address.

Description

Gets the remote endpoint of a given local endpoint, set it up for fwnode matching and adds the async sub-device to the notifier's asd_list. The function also gets a reference of the fwnode which is released later at notifier cleanup time.

This is just like v4l2_async_notifier_add_fwnode_subdev, but with the exception that the fwnode refers to a local endpoint, not the remote one, and the function relies on the caller to allocate the async sub-device struct.

struct v4l2_async_subdev * v4l2_async_notifier_add_i2c_subdev(struct v4l2_async_notifier * notifier, int adapter_id, unsigned short address, unsigned int asd_struct_size)

Allocate and add an i2c async subdev to the notifier's master asd_list.

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
int adapter_id
I2C adapter ID to be matched
unsigned short address
I2C address of sub-device to be matched
unsigned int asd_struct_size
size of the driver's async sub-device struct, including sizeof(struct v4l2_async_subdev). The struct v4l2_async_subdev shall be the first member of the driver's async sub-device struct, i.e. both begin at the same memory address.

Description

Same as above but for I2C matched sub-devices.

struct v4l2_async_subdev * v4l2_async_notifier_add_devname_subdev(struct v4l2_async_notifier * notifier, const char * device_name, unsigned int asd_struct_size)

Allocate and add a device-name async subdev to the notifier's master asd_list.

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
const char * device_name
device name string to be matched
unsigned int asd_struct_size
size of the driver's async sub-device struct, including sizeof(struct v4l2_async_subdev). The struct v4l2_async_subdev shall be the first member of the driver's async sub-device struct, i.e. both begin at the same memory address.

Description

Same as above but for device-name matched sub-devices.

int v4l2_async_notifier_register(struct v4l2_device * v4l2_dev, struct v4l2_async_notifier * notifier)

registers a subdevice asynchronous notifier

Parameters

struct v4l2_device * v4l2_dev
pointer to struct v4l2_device
struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
int v4l2_async_subdev_notifier_register(struct v4l2_subdev * sd, struct v4l2_async_notifier * notifier)

registers a subdevice asynchronous notifier for a sub-device

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
void v4l2_async_notifier_unregister(struct v4l2_async_notifier * notifier)

unregisters a subdevice asynchronous notifier

Parameters

struct v4l2_async_notifier * notifier
pointer to struct v4l2_async_notifier
void v4l2_async_notifier_cleanup(struct v4l2_async_notifier * notifier)

clean up notifier resources

Parameters

struct v4l2_async_notifier * notifier
the notifier the resources of which are to be cleaned up

Description

Release memory resources related to a notifier, including the async sub-devices allocated for the purposes of the notifier but not the notifier itself. The user is responsible for calling this function to clean up the notifier after calling v4l2_async_notifier_add_subdev, v4l2_async_notifier_parse_fwnode_endpoints or v4l2_fwnode_reference_parse_sensor_common.

There is no harm from calling v4l2_async_notifier_cleanup in other cases as long as its memory has been zeroed after it has been allocated.

int v4l2_async_register_subdev(struct v4l2_subdev * sd)

registers a sub-device to the asynchronous subdevice framework

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev
int v4l2_async_register_subdev_sensor_common(struct v4l2_subdev * sd)

registers a sensor sub-device to the asynchronous sub-device framework and parse set up common sensor related devices

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev

Description

This function is just like v4l2_async_register_subdev() with the exception that calling it will also parse firmware interfaces for remote references using v4l2_async_notifier_parse_fwnode_sensor_common() and registers the async sub-devices. The sub-device is similarly unregistered by calling v4l2_async_unregister_subdev().

While registered, the subdev module is marked as in-use.

An error is returned if the module is no longer loaded on any attempts to register it.

void v4l2_async_unregister_subdev(struct v4l2_subdev * sd)

unregisters a sub-device to the asynchronous subdevice framework

Parameters

struct v4l2_subdev * sd
pointer to struct v4l2_subdev