2.7.V4L2 sub-devices¶

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

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

Each sub-device driver must have av4l2_subdev struct. Thisstructcan be stand-alone for simple sub-devices or it might be embedded in a largerstruct if more state information needs to be stored. Usually there is alow-level device struct (e.g.i2c_client) that contains the device data assetup by the kernel. It is recommended to store that pointer in the privatedata ofv4l2_subdev usingv4l2_set_subdevdata(). That makesit easy to go from av4l2_subdev to the actual low-level bus-specificdevice data.

You also need a way to go from the low-levelstructtov4l2_subdev.For the common i2c_clientstructthei2c_set_clientdata() call is used to storeav4l2_subdev pointer, for other buses you may have to use othermethods.

Bridges might also need to store per-subdev private data, such as a pointer tobridge-specific per-subdev private data. Thev4l2_subdev structureprovides host private data for that purpose that can be accessed withv4l2_get_subdev_hostdata() andv4l2_set_subdev_hostdata().

From the bridge driver perspective, you load the sub-device module and somehowobtain thev4l2_subdev pointer. For i2c devices this is easy: you calli2c_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 thistricky work for you.

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

The top-level opsstructcontains pointers to the category ops structs, whichmay be NULL if the subdev driver does not support anything from that category.

It looks like this:

structv4l2_subdev_core_ops{int(*log_status)(structv4l2_subdev*sd);int(*init)(structv4l2_subdev*sd,u32val);...};structv4l2_subdev_tuner_ops{...};structv4l2_subdev_audio_ops{...};structv4l2_subdev_video_ops{...};structv4l2_subdev_pad_ops{...};structv4l2_subdev_ops{conststructv4l2_subdev_core_ops*core;conststructv4l2_subdev_tuner_ops*tuner;conststructv4l2_subdev_audio_ops*audio;conststructv4l2_subdev_video_ops*video;conststructv4l2_subdev_pad_ops*video;};

The core ops are common to all subdevs, the other categories are implementeddepending on the sub-device. E.g. a video device is unlikely to support theaudio ops and vice versa.

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

A sub-device driver initializes thev4l2_subdevstructusing:

v4l2_subdev_init(sd, &ops).

Afterwards you need to initializesd->name with aunique name and set the module owner. This is done for you if you use thei2c helper functions.

If integration with the media framework is needed, you must initialize themedia_entitystructembedded in thev4l2_subdev struct(entity field) by callingmedia_entity_pads_init(), if the entity haspads:

structmedia_pad*pads=&my_sd->pads;interr;err=media_entity_pads_init(&sd->entity,npads,pads);

The pads array must have been previously initialized. There is no need tomanually set thestructmedia_entity function and name fields, but therevision field must be initialized if needed.

A reference to the entity will be automatically acquired/released when thesubdev 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 a sub-device driver implements sink pads, the subdev driver may set thelink_validate field inv4l2_subdev_pad_ops to provide its own linkvalidation function. For every link in the pipeline, the link_validate padoperation of the sink end of the link is called. In both cases the driver isstill responsible for validating the correctness of the format configurationbetween sub-devices and video nodes.

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

2.7.1.Subdev registration¶

There are currently two ways to register subdevices with the V4L2 core. Thefirst (traditional) possibility is to have subdevices registered by bridgedrivers. This can be done when the bridge driver has the complete informationabout subdevices connected to it and knows exactly when to register them. Thisis typically the case for internal subdevices, like video data processing unitswithin SoCs or complex PCI(e) boards, camera sensors in USB cameras or connectedto SoCs, which pass information about them to bridge drivers, usually in theirplatform data.

There are however also situations where subdevices have to be registeredasynchronously to bridge devices. An example of such a configuration is a DeviceTree based system where information about subdevices is made available to thesystem independently from the bridge devices, e.g. when subdevices are definedin DT as I2C device nodes. The API used in this second case is described furtherbelow.

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

2.7.1.1.Registering synchronous sub-devices¶

In thesynchronous case a device (bridge) driver needs to register thev4l2_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 tothev4l2_device.

If the v4l2_device parent device has a non-NULL mdev field, the sub-deviceentity 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 andsd->dev ==NULL.

2.7.1.2.Registering asynchronous sub-devices¶

In theasynchronous case subdevice probing can be invoked independently ofthe bridge driver availability. The subdevice driver then has to verify whetherall the requirements for a successful probing are satisfied. This can include acheck for a master clock availability. If any of the conditions aren’t satisfiedthe driver might decide to return-EPROBE_DEFER to request further reprobingattempts. Once all conditions are met the subdevice shall be registered usingthev4l2_async_register_subdev() function. Unregistration isperformed using thev4l2_async_unregister_subdev() call. Subdevicesregistered this way are stored in a global list of subdevices, ready to bepicked up by bridge drivers.

Drivers must complete all initialization of the sub-device beforeregistering it usingv4l2_async_register_subdev(), includingenabling runtime PM. This is because the sub-device becomes accessibleas 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 performedusing thev4l2_async_nf_register() call. To unregister the notifier thedriver has to callv4l2_async_nf_unregister(). Before releasing memoryof an unregister notifier, it must be cleaned up by callingv4l2_async_nf_cleanup().

Before registering the notifier, bridge drivers must do two things: first, thenotifier must be initialized using thev4l2_async_nf_init(). Second,bridge drivers can then begin to form a list of async connection descriptorsthat the bridge device needs for itsoperation.v4l2_async_nf_add_fwnode(),v4l2_async_nf_add_fwnode_remote() andv4l2_async_nf_add_i2c()

Async connection descriptors describe connections to external sub-devices thedrivers for which are not yet probed. Based on an async connection, a media dataor ancillary link may be created when the related sub-device becomesavailable. There may be one or more async connections to a given sub-device butthis is not known at the time of adding the connections to the notifier. Asyncconnections 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 anasynchronous notifier. This is called an asynchronous sub-device notifier and theprocess is similar to that of a bridge driver apart from that the notifier isinitialised usingv4l2_async_subdev_nf_init() instead. A sub-devicenotifier may complete only after the V4L2 device becomes available, i.e. there’sa path via async sub-devices and notifiers to a notifier that is not anasynchronous 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 sensordrivers registering their own async connection, but it also registers a notifierand further registers async connections for lens and flash devices found infirmware. The notifier for the sub-device is unregistered and cleaned up withthe async sub-device, usingv4l2_async_unregister_subdev().

2.7.1.6.Asynchronous sub-device notifier example¶

These functions allocate an async connection descriptor which is of type structv4l2_async_connection embedded in a driver-specific struct. The &structv4l2_async_connection shall be the first member of this struct:

structmy_async_connection{structv4l2_async_connectionasc;...};structmy_async_connection*my_asc;structfwnode_handle*ep;...my_asc=v4l2_async_nf_add_fwnode_remote(&notifier,ep,structmy_async_connection);fwnode_handle_put(ep);if(IS_ERR(my_asc))returnPTR_ERR(my_asc);

2.7.1.7.Asynchronous sub-device notifier callbacks¶

The V4L2 core will then use these connection descriptors to match asynchronouslyregistered subdevices to them. If a match is detected the.bound() notifiercallback 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-specificv4l2_async_connection wrapper. If any of that data requires specialhandling when the structure is freed, drivers must implement the.destroy()notifier callback. The framework will call it right before freeing thev4l2_async_connection.

2.7.2.Calling subdev operations¶

The advantage of usingv4l2_subdev is that it is a genericstructanddoes not contain any knowledge about the underlying hardware. So a driver mightcontain several subdevs that use an I2C bus, but also a subdev that iscontrolled through GPIO pins. This distinction is only relevant when settingup the device, but once the subdev is registered it is completely transparent.

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

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 rightNULL pointer checks and returns-ENODEVifsd isNULL,-ENOIOCTLCMD if eithersd->core orsd->core->g_std isNULL, or the actual result of thesd->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 areignored. 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 noerrors (except-ENOIOCTLCMD) occurred, then 0 is returned.

The second argument to both calls is a group ID. If 0, then all subdevs arecalled. If non-zero, then only those whose group ID match that value willbe called. Before a bridge driver registers a subdev it can setsd->grp_id to whatever value it wants (it’s 0 bydefault). This value is owned by the bridge driver and the sub-device driverwill 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 ofchanging the volume. But usually only one will actually be used when theuser want to change the volume. You can set the group ID for that subdev toe.g. AUDIO_CONTROLLER and specify that as the group ID value when callingv4l2_device_call_all(). That ensures that it will only go to the subdevthat needs it.

If the sub-device needs to notify its v4l2_device parent of an event, thenit can callv4l2_subdev_notify(sd,notification,arg). This macro checkswhether there is anotify() callback defined and returns-ENODEV if not.Otherwise the result of thenotify() 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 thev4l2_subdev_ops operations inresponse to video node operations. This hides the complexity of the underlyinghardware from applications. For complex devices, finer-grained control of thedevice than what the video nodes offer may be required. In those cases, bridgedrivers that implementthe media controller API mayopt for making the subdevice operations directly accessible from userspace.

Device nodes namedv4l-subdevX can be created in/dev to accesssub-devices directly. If a sub-device supports direct userspace configurationit must set theV4L2_SUBDEV_FL_HAS_DEVNODE flag before being registered.

After registering sub-devices, thev4l2_device driver can createdevice nodes for all registered sub-devices marked withV4L2_SUBDEV_FL_HAS_DEVNODE by callingv4l2_device_register_subdev_nodes(). Those device nodes will beautomatically 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 andVIDIOC_TRY_EXT_CTRLS:

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

VIDIOC_DQEVENT,VIDIOC_SUBSCRIBE_EVENT andVIDIOC_UNSUBSCRIBE_EVENT

The events ioctls are identical to the ones defined in V4L2. Theybehave identically, with the only exception that they deal only withevents generated by the sub-device. Depending on the driver, thoseevents can also be reported by one (or several) V4L2 device nodes.
Sub-device drivers that want to use events need to set theV4L2_SUBDEV_FL_HAS_EVENTSv4l2_subdev.flags before registeringthe sub-device. After registration events can be queued as usual on thev4l2_subdev.devnode device node.
To properly support events, thepoll() file operation is alsoimplemented.

Private ioctls

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

2.9.Read-only sub-device userspace API¶

Bridge drivers that control their connected subdevices through direct calls tothe kernel API realized byv4l2_subdev_ops structure do not usuallywant userspace to be able to change the same parameters through the subdevicedevice node and thus do not usually register any.

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

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

To create a read-only device node for all the subdevices registered with theV4L2_SUBDEV_FL_HAS_DEVNODE set, thev4l2_device driver should callv4l2_device_register_ro_subdev_nodes().

Access to the following ioctls for userspace applications is restricted onsub-device device nodes registered withv4l2_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 nodefor theV4L2_SUBDEV_FORMAT_TRYformats 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 toV4L2_SUBDEV_FORMAT_ACTIVE, the core returns a negative error code andthe errno variable is set to-EPERM.

2.10.I2C sub-device drivers¶

Since these drivers are so common, special helper functions are available toease the use of these drivers (v4l2-common.h).

The recommended method of addingv4l2_subdev support to an I2C driveris to embed thev4l2_subdevstructinto the statestructthat iscreated for each I2C device instance. Very simple devices have no statestructand in that case you can just create av4l2_subdev directly.

A typical statestructwould look like this (where ‘chipname’ is replaced bythe name of the chip):

structchipname_state{structv4l2_subdevsd;.../* additional state fields */};

Initialize thev4l2_subdevstructas follows:

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

This function will fill in all the fields ofv4l2_subdev ensure thatthev4l2_subdev and i2c_client both point to one another.

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

staticinlinestructchipname_state*to_state(structv4l2_subdev*sd){returncontainer_of(sd,structchipname_state,sd);}

Use this to go from thev4l2_subdevstructto thei2c_clientstruct:

structi2c_client*client=v4l2_get_subdevdata(sd);

And this to go from ani2c_client to av4l2_subdev struct:

structv4l2_subdev*sd=i2c_get_clientdata(client);

Make sure to callv4l2_device_unregister_subdev()(sd)when theremove() callback is called. This will unregister the sub-devicefrom the bridge driver. It is safe to call this even if the sub-device wasnever registered.

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

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

structv4l2_subdev*sd=v4l2_i2c_new_subdev(v4l2_dev,adapter,"module_foo","chipid",0x36,NULL);

This loads the given module (can beNULL if no module needs to be loaded)and callsi2c_new_client_device() with the giveni2c_adapter andchip/address arguments. If all goes well, then it registers the subdev withthe v4l2_device.

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

Both functions returnNULL if something went wrong.

Note that the chipid you pass tov4l2_i2c_new_subdev() is usuallythe 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 alater 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 codefor the i2c_device_id table. This lists all the possibilities.

There are one more helper function:

v4l2_i2c_new_subdev_board() uses ani2c_board_infostructwhich is passed to the i2c driver and replaces the irq, platform_data and addrarguments.

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

Thev4l2_i2c_new_subdev() function will callv4l2_i2c_new_subdev_board(), internally filling ai2c_board_info structure using theclient_type and theaddr to fill it.

2.11.Centrally managed subdev active state¶

Traditionally V4L2 subdev drivers maintained internal state for the activedevice configuration. This is often implemented as e.g. an array ofstructv4l2_mbus_framefmt, one entry for each pad, and similarly for crop and composerectangles.

In addition to the active configuration, each subdev file handle has astructv4l2_subdev_state, managed by the V4L2 core, which contains the tryconfiguration.

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

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

V4L2 sub-device operations that use both theACTIVE and TRY formats receive the correct state to operate on throughthe ‘state’ parameter. The state must be locked and unlocked by thecaller by callingv4l2_subdev_lock_state() andv4l2_subdev_unlock_state(). The caller can do so by calling the subdevoperation through thev4l2_subdev_call_state_active() macro.

Operations that do not receive a state parameter implicitly operate on thesubdevice active state, which drivers can exclusively access bycallingv4l2_subdev_lock_and_get_active_state(). The sub-device activestate must equally be released by callingv4l2_subdev_unlock_state().

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

While the V4L2 core passes the correct try or active state to the subdeviceoperations, many existing device drivers pass a NULL state when callingoperations withv4l2_subdev_call(). This legacy construct causesissues 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 theconversion of subdevice drivers to a managed active state without having toconvert all callers at the same time, an additional wrapper layer has beenadded tov4l2_subdev_call(), which handles the NULL case by getting and lockingthe callee’s active state withv4l2_subdev_lock_and_get_active_state(),and unlocking the state after the call.

The whole subdev state is in reality split into three parts: thev4l2_subdev_state, subdev controls and subdev driver’s internal state. In thefuture these parts should be combined into a single state. For the time beingwe need a way to handle the locking for these parts. This can be accomplishedby 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 followingbefore callingv4l2_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 settingthe V4L2_SUBDEV_FL_STREAMS subdev flag and implementing support forcentrally managed subdev active state, routing and stream basedconfiguration.

2.13.V4L2 sub-device functions and data structures¶

structv4l2_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 tothe 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

enumv4l2_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 viastructv4l2_subdev_io_pin_config->value.
V4L2_SUBDEV_IO_PIN_ACTIVE_LOW: pin active is bit 0.Otherwise, ACTIVE HIGH is assumed.

structv4l2_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 byenumv4l2_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

structv4l2_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 (*command)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);    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 forVIDIOC_LOG_STATUS() ioctl handler code.
s_io_pin_config: configure one or more chip I/O pins for chips thatmultiplex different internal signal pads out to IO pins. This functiontakes a pointer to an array of ‘n’ pin configuration entries, one foreach pin being configured. This function could be called at timesother than just subdevice initialization.
init: initialize the sensor registers to some sort of reasonable defaultvalues. Do not use for new drivers and should be removed in existingdrivers.
load_fw: load firmware.
reset: generic reset command. The argument selects which subsystems toreset. Passing 0 will always reset the whole chip. Do not use for newdrivers 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 witha direction argument if needed.
command: called by in-kernel drivers in order to call functions internalto subdev drivers driver that have a separate callback.
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 forVIDIOC_DBG_G_REGISTER() ioctl handler code.
s_register: callback forVIDIOC_DBG_S_REGISTER() ioctl handler code.
s_power: puts subdevice in power saving mode (on == 0) or normal operationmode (on == 1). DEPRECATED. SeeWriting camera sensor drivers . pre_streamon andpost_streamoff callbacks can be used for e.g. setting the bus to LP-11mode before s_stream is called.
interrupt_service_routine: Called by the bridge chip’s interrupt servicehandler, when an interrupt status has be raised due to this subdev,so that this subdev can handle the details. It may schedule work to beperformed later. It must not sleep.Called from an IRQ context.
subscribe_event: used by the drivers to request the control framework thatfor it to be warned when the value of a control changes.
unsubscribe_event: remove event subscription from the control framework.

structv4l2_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 upautomatically 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 shouldoperate on radio mode, before being able to handle it.Used on devices that have both AM/FM radio receiver and TV.
s_frequency: callback forVIDIOC_S_FREQUENCY() ioctl handler code.
g_frequency: callback forVIDIOC_G_FREQUENCY() ioctl handler code.freq->type must be filled in. Normally done byvideo_ioctl2()or the bridge driver.
enum_freq_bands: callback forVIDIOC_ENUM_FREQ_BANDS() ioctl handler code.
g_tuner: callback forVIDIOC_G_TUNER() ioctl handler code.
s_tuner: callback forVIDIOC_S_TUNER() ioctl handler code.vt->type must befilled in. Normally done by video_ioctl2 or thebridge driver.
g_modulator: callback forVIDIOC_G_MODULATOR() ioctl handler code.
s_modulator: callback forVIDIOC_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 driverto explicitly call s_radio when the tuner should be switched toradio mode, before handling otherstructv4l2_subdev_tuner_opsthat 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);}

structv4l2_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 thataudio and video remain synchronized. Usual values for the frequencyare 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 standardway to select I2S clock used by driving digital audio streams at someboard 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 aninput pin is connected to a Composite connector, become on anotherboard or platform it might be connected to something else entirely.The calling driver is responsible for mapping a user-level input tothe right pins on the i2c device.
s_stream: used to notify the audio code that stream will start or hasstopped.

structv4l2_mbus_frame_desc_entry_csi2¶

Definition:

struct v4l2_mbus_frame_desc_entry_csi2 {    u8 vc;    u8 dt;};

Members

vc: CSI-2 virtual channel
dt: CSI-2 data type ID

enumv4l2_mbus_frame_desc_flags¶: media bus frame description flags

Constants

V4L2_MBUS_FRAME_DESC_FL_LEN_MAX: Indicates thatstructv4l2_mbus_frame_desc_entry->length fieldspecifies 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.

structv4l2_mbus_frame_desc_entry¶: media bus frame description structure

Definition:

struct v4l2_mbus_frame_desc_entry {    enum v4l2_mbus_frame_desc_flags flags;    u32 stream;    u32 pixelcode;    u32 length;    union {        struct v4l2_mbus_frame_desc_entry_csi2 csi2;    } bus;};

Members

flags: bitmask flags, as defined byenumv4l2_mbus_frame_desc_flags.
stream: stream in routing configuration
pixelcode: media bus pixel code, valid ifflagsFRAME_DESC_FL_BLOB is not set.
length: number of octets per frame, valid ifflagsV4L2_MBUS_FRAME_DESC_FL_LEN_MAX is set.
bus: Bus-specific frame descriptor parameters
bus.csi2: CSI-2-specific bus configuration

enumv4l2_mbus_frame_desc_type¶: media bus frame description type

Constants

V4L2_MBUS_FRAME_DESC_TYPE_UNDEFINED: Undefined frame desc type. Drivers should not use this, it isfor backwards compatibility.
V4L2_MBUS_FRAME_DESC_TYPE_PARALLEL: Parallel media bus.
V4L2_MBUS_FRAME_DESC_TYPE_CSI2: CSI-2 media bus. Frame desc parameters must be set instructv4l2_mbus_frame_desc_entry->csi2.

structv4l2_mbus_frame_desc¶: media bus data frame description

Definition:

struct v4l2_mbus_frame_desc {    enum v4l2_mbus_frame_desc_type type;    struct v4l2_mbus_frame_desc_entry entry[V4L2_FRAME_DESC_ENTRY_MAX];    unsigned short num_entries;};

Members

type: type of the bus (enumv4l2_mbus_frame_desc_type)
entry: frame descriptors array
num_entries: number of entries inentry array

enumv4l2_subdev_pre_streamon_flags¶: Flags for pre_streamon subdev core op

Constants

V4L2_SUBDEV_PRE_STREAMON_FL_MANUAL_LP: Set the transmitter to either LP-11or LP-111 mode before call tos_stream().

structv4l2_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 (*s_rx_buffer)(struct v4l2_subdev *sd, void *buf, unsigned int *size);    int (*pre_streamon)(struct v4l2_subdev *sd, u32 flags);    int (*post_streamoff)(struct v4l2_subdev *sd);};

Members

s_routing: see s_routing in audio_ops, except this version is for videodevices.
s_crystal_freq: sets the frequency of the crystal used to generate theclocks in Hz. An extra flags field allows device specific configurationregarding clock frequency dividers, etc. If not used, then set flagsto 0. If the frequency is not supported, then -EINVAL is returned.
g_std: callback forVIDIOC_G_STD() ioctl handler code.
s_std: callback forVIDIOC_S_STD() ioctl handler code.
s_std_output: set v4l2_std_id for video OUTPUT devices. This is ignored byvideo input devices.
g_std_output: get current standard for video OUTPUT devices. This is ignoredby video input devices.
querystd: callback forVIDIOC_QUERYSTD() ioctl handler code.
g_tvnorms: getv4l2_std_id with all standards supported by the videoCAPTURE device. This is ignored by video output devices.
g_tvnorms_output: get v4l2_std_id with all standards supported by the videoOUTPUT device. This is ignored by video capture devices.
g_input_status: get input status. Same as the status field in thestructv4l2_input
s_stream: start (enabled == 1) or stop (enabled == 0) streaming on thesub-device. Failure on stop will remove any resources acquired instreaming start, while the error code is still returned by the driver.The caller shall track the subdev state, and shall not start or stop analready started or stopped subdev. Also see call_s_stream wrapper inv4l2-subdev.c.
s_rx_buffer: set a host allocated memory buffer for the subdev. The subdevcan adjustsize to a lower value and must not write more data to thebuffer starting atdata than the original value ofsize.
pre_streamon: May be called before streaming is actually started, to helpinitialising the bus. Current usage is to set a CSI-2 transmitter toLP-11 or LP-111 mode before streaming. Seeenumv4l2_subdev_pre_streamon_flags.
post_streamoff: Called after streaming is stopped, but if and only ifpre_streamon was called earlier.

Description

This callback is DEPRECATED. New drivers should instead implementv4l2_subdev_pad_ops.enable_streams andv4l2_subdev_pad_ops.disable_streams operations, and usev4l2_subdev_s_stream_helper for thev4l2_subdev_video_ops.s_streamoperation to support legacy users.
Drivers should also not call the .s_stream() subdev operation directly,but use thev4l2_subdev_enable_streams() andv4l2_subdev_disable_streams() helpers.
pre_streamon shall return error if it cannot perform the operation asindicated by the flags argument. In particular, -EACCES indicates lackof support for the operation. The caller shall call post_streamoff foreach successful call of pre_streamon.

structv4l2_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 implementthis ioctl. Field p of thestructv4l2_decode_vbi_line is set to thestart of the VBI data that was generated by the decoder. The driverthen parses the sliced VBI data and sets the other fields in thestructaccordingly. The pointer p is updated to point to the start ofthe payload which can be copied verbatim into the data field of thestructv4l2_sliced_vbi_data. If no valid VBI data was found, then thetype field is set to 0 on return.
s_vbi_data: used to generate VBI signals on a video signal.structv4l2_sliced_vbi_data is filled with the data packets thatshould be output. Note that if you set the line field to 0, then thatVBI signal is disabled. If no valid VBI data was found, then the typefield 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 becausethe readback register contains invalid or erroneous data-EIO isreturned. Note that you must fill in the ‘id’ member and the ‘field’member (to determine whether CC data from the first or second fieldshould be obtained).
g_sliced_vbi_cap: callback forVIDIOC_G_SLICED_VBI_CAP() ioctl handlercode.
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.

structv4l2_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 corruptseveral top lines of the output image, or which send theirmetadata in them.
g_skip_frames: number of frames to skip at stream start. This is needed forbuggy sensors that generate faulty frames when they areturned on.

enumv4l2_subdev_ir_mode¶: describes the type of IR supported

Constants

V4L2_SUBDEV_IR_MODE_PULSE_WIDTH: IR usesstructir_raw_event records

structv4l2_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 orwrite call.
mode: IR mode as defined byenumv4l2_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 modulatedsignal. Used only for RX.
carrier_range_upper: Upper carrier range, in Hz, valid only for modulatedsignal. Used only for RX.
resolution: The receive resolution, in ns . Used only for RX.

structv4l2_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 ofthe IR receiver.
rx_s_parameters: Set the current operating parameters and state ofthe IR receiver. It is recommended to call[rt]x_g_parameters first to fill out the current state, and only changethe fields that need to be changed. Upon return, the actual deviceoperating parameters and state will be returned. Note that hardwarelimitations may prevent the actual settings from matching the requestedsettings - e.g. an actual carrier setting of 35,904 Hz when 36,000 Hzwas requested. An exception is when the shutdown parameter is true.The last used operational parameters will be returned, but the actualstate of the hardware be different to minimize power consumption andprocessing 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 ofthe IR transmitter.
tx_s_parameters: Set the current operating parameters and state ofthe IR transmitter. It is recommended to call[rt]x_g_parameters first to fill out the current state, and only changethe fields that need to be changed. Upon return, the actual deviceoperating parameters and state will be returned. Note that hardwarelimitations may prevent the actual settings from matching the requestedsettings - e.g. an actual carrier setting of 35,904 Hz when 36,000 Hzwas requested. An exception is when the shutdown parameter is true.The last used operational parameters will be returned, but the actualstate of the hardware be different to minimize power consumption andprocessing when shutdown is true.

structv4l2_subdev_pad_config¶: Used for storing subdev pad information.

Definition:

struct v4l2_subdev_pad_config {    struct v4l2_mbus_framefmt format;    struct v4l2_rect crop;    struct v4l2_rect compose;    struct v4l2_fract interval;};

Members

format: structv4l2_mbus_framefmt
crop: structv4l2_rect to be used for crop
compose: structv4l2_rect to be used for compose
interval: frame interval

structv4l2_subdev_stream_configs¶: A collection of stream configs.

Definition:

struct v4l2_subdev_stream_configs {    u32 num_configs;    struct v4l2_subdev_stream_config *configs;};

Members

num_configs: number of entries inconfig.
configs: an array ofstructv4l2_subdev_stream_configs.

structv4l2_subdev_krouting¶: subdev routing table

Definition:

struct v4l2_subdev_krouting {    unsigned int len_routes;    unsigned int num_routes;    struct v4l2_subdev_route *routes;};

Members

len_routes: length of routes array, in routes
num_routes: number of routes
routes: structv4l2_subdev_route

Description

This structure contains the routing table for a subdev.

structv4l2_subdev_state¶: Used for storing subdev state information.

Definition:

struct v4l2_subdev_state {    struct mutex _lock;    struct mutex *lock;    struct v4l2_subdev *sd;    struct v4l2_subdev_pad_config *pads;    struct v4l2_subdev_krouting routing;    struct v4l2_subdev_stream_configs stream_configs;};

Members

_lock: default for ‘lock’
lock: mutex for the state. May be replaced by the user.
sd: the sub-device which the state is related to
pads: structv4l2_subdev_pad_config array
routing: routing table for the subdev
stream_configs: stream configurations (only for V4L2_SUBDEV_FL_STREAMS)

Description

This structure only needs to be passed to the pad op if the ‘which’ fieldof the main argument is set toV4L2_SUBDEV_FORMAT_TRY. ForV4L2_SUBDEV_FORMAT_ACTIVE it is safe to passNULL.

structv4l2_subdev_pad_ops¶: v4l2-subdev pad level operations

Definition:

struct v4l2_subdev_pad_ops {    int (*enum_mbus_code)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_mbus_code_enum *code);    int (*enum_frame_size)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_frame_size_enum *fse);    int (*enum_frame_interval)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_frame_interval_enum *fie);    int (*get_fmt)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_format *format);    int (*set_fmt)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_format *format);    int (*get_selection)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_selection *sel);    int (*set_selection)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_selection *sel);    int (*get_frame_interval)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_frame_interval *interval);    int (*set_frame_interval)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, struct v4l2_subdev_frame_interval *interval);    int (*get_edid)(struct v4l2_subdev *sd, struct v4l2_edid *edid);    int (*set_edid)(struct v4l2_subdev *sd, struct v4l2_edid *edid);    int (*s_dv_timings)(struct v4l2_subdev *sd, unsigned int pad, struct v4l2_dv_timings *timings);    int (*g_dv_timings)(struct v4l2_subdev *sd, unsigned int pad, struct v4l2_dv_timings *timings);    int (*query_dv_timings)(struct v4l2_subdev *sd, unsigned int pad, struct v4l2_dv_timings *timings);    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);    int (*get_mbus_config)(struct v4l2_subdev *sd, unsigned int pad, struct v4l2_mbus_config *config);    int (*set_routing)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, enum v4l2_subdev_format_whence which, struct v4l2_subdev_krouting *route);    int (*enable_streams)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, u32 pad, u64 streams_mask);    int (*disable_streams)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state, u32 pad, u64 streams_mask);};

Members

enum_mbus_code: callback forVIDIOC_SUBDEV_ENUM_MBUS_CODE() ioctl handlercode.
enum_frame_size: callback forVIDIOC_SUBDEV_ENUM_FRAME_SIZE() ioctl handlercode.
enum_frame_interval: callback forVIDIOC_SUBDEV_ENUM_FRAME_INTERVAL() ioctlhandler code.
get_fmt: callback forVIDIOC_SUBDEV_G_FMT() ioctl handler code.
set_fmt: callback forVIDIOC_SUBDEV_S_FMT() ioctl handler code.
get_selection: callback forVIDIOC_SUBDEV_G_SELECTION() ioctl handler code.
set_selection: callback forVIDIOC_SUBDEV_S_SELECTION() ioctl handler code.
get_frame_interval: callback forVIDIOC_SUBDEV_G_FRAME_INTERVAL()ioctl handler code.
set_frame_interval: callback forVIDIOC_SUBDEV_S_FRAME_INTERVAL()ioctl handler code.
get_edid: callback forVIDIOC_SUBDEV_G_EDID() ioctl handler code.
set_edid: callback forVIDIOC_SUBDEV_S_EDID() ioctl handler code.
s_dv_timings: Set custom dv timings in the sub device. This is usedwhen sub device is capable of setting detailed timing informationin the hardware to generate/detect the video signal.
g_dv_timings: Get custom dv timings in the sub device.
query_dv_timings: callback forVIDIOC_QUERY_DV_TIMINGS() ioctl handler code.
dv_timings_cap: callback forVIDIOC_SUBDEV_DV_TIMINGS_CAP() ioctl handlercode.
enum_dv_timings: callback forVIDIOC_SUBDEV_ENUM_DV_TIMINGS() ioctl handlercode.
link_validate: used by the media controller code to check if the linksthat 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 arraymay be adjusted by the subdev driver to device capabilities.
get_mbus_config: get the media bus configuration of a remote sub-device.The media bus configuration is usually retrieved from thefirmware interface at sub-device probe time, immediatelyapplied to the hardware and eventually adjusted by thedriver. Remote sub-devices (usually video receivers) shalluse this operation to query the transmitting end busconfiguration in order to adjust their own one accordingly.Callers should make sure they get the most up-to-date aspossible configuration from the remote end, likely callingthis operation as close as possible to stream on time. Theoperation shall fail if the pad index it has been called onis not valid or in case of unrecoverable failures. Theconfig argument has been memset to 0 just before callingthe op.
set_routing: Enable or disable data connection routes described in thesubdevice routing table. Subdevs that implement this operationmust set the V4L2_SUBDEV_FL_STREAMS flag.
enable_streams: Enable the streams defined in streams_mask on the givensource pad. Subdevs that implement this operation must use the activestate management provided by the subdev core (enabled through a call tov4l2_subdev_init_finalize() at initialization time). Do not calldirectly, usev4l2_subdev_enable_streams() instead.
disable_streams: Disable the streams defined in streams_mask on the givensource pad. Subdevs that implement this operation must use the activestate management provided by the subdev core (enabled through a call tov4l2_subdev_init_finalize() at initialization time). Do not calldirectly, usev4l2_subdev_disable_streams() instead.

Description

Drivers that support only a single stream without setting theV4L2_SUBDEV_CAP_STREAMS sub-device capability flag can ignore the maskargument.
Drivers that support only a single stream without setting theV4L2_SUBDEV_CAP_STREAMS sub-device capability flag can ignore the maskargument.

structv4l2_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 tostructv4l2_subdev_core_ops. Can beNULL
tuner: pointer tostructv4l2_subdev_tuner_ops. Can beNULL
audio: pointer tostructv4l2_subdev_audio_ops. Can beNULL
video: pointer tostructv4l2_subdev_video_ops. Can beNULL
vbi: pointer tostructv4l2_subdev_vbi_ops. Can beNULL
ir: pointer tostructv4l2_subdev_ir_ops. Can beNULL
sensor: pointer tostructv4l2_subdev_sensor_ops. Can beNULL
pad: pointer tostructv4l2_subdev_pad_ops. Can beNULL

structv4l2_subdev_internal_ops¶: V4L2 subdev internal ops

Definition:

struct v4l2_subdev_internal_ops {    int (*init_state)(struct v4l2_subdev *sd, struct v4l2_subdev_state *state);    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

init_state: initialize the subdev state to default values
registered: called when this subdev is registered. When called the v4l2_devfield is set to the correct v4l2_device.
unregistered: called when this subdev is unregistered. When called thev4l2_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 thatit is possible forclose to be called afterunregistered!
release: called when the last user of the subdev device is gone. Thishappens after theunregistered callback and when the last openfilehandle to the v4l-subdevX device node was closed. If no devicenode was created for this sub-device, then therelease callbackis called right after theunregistered callback.Therelease callback is typically used to free the memory containingthe v4l2_subdev structure. It is almost certainly required for anysub-device that sets the V4L2_SUBDEV_FL_HAS_DEVNODE flag.

Description

Note

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

structv4l2_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

structv4l2_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[52];    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 list_head async_subdev_endpoint_list;    struct v4l2_async_notifier *subdev_notifier;    struct list_head asc_list;    struct v4l2_subdev_platform_data *pdata;    struct mutex *state_lock;    struct led_classdev *privacy_led;    struct v4l2_subdev_state *active_state;    u64 enabled_pads;    bool s_stream_enabled;};

Members

entity: pointer tostructmedia_entity
list: List of sub-devices
owner: The owner is the same as the driver’sstructdevice owner.
owner_v4l2_dev: true if thesd->owner matches the owner ofv4l2_dev->devowner. Initialized byv4l2_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 adevice node;V4L2_SUBDEV_FL_HAS_EVENTS - Set this flag if this subdev generatesevents.
v4l2_dev: pointer to structv4l2_device
ops: pointer to structv4l2_subdev_ops
internal_ops: pointer to structv4l2_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 subdevis attached.
devnode: subdev device node
dev: pointer to the physical device, if any
fwnode: The fwnode_handle of the subdev, usually the same aseither dev->of_node->fwnode or dev->fwnode (whichever is non-NULL).
async_list: Links this subdev to a global subdev_list ornotifier->done_list list.
async_subdev_endpoint_list: List entry in async_subdev_endpoint_entry ofstructv4l2_async_subdev_endpoint.
subdev_notifier: A sub-device notifier implicitly registered for the sub-device usingv4l2_async_register_subdev_sensor().
asc_list: Async connection list, ofstructv4l2_async_connection.subdev_entry.
pdata: common part of subdevice platform data
state_lock: A pointer to a lock used for all the subdev’s states, set by thedriver. This is optional. If NULL, each state instance will geta lock of its own.
privacy_led: Optional pointer to a LED classdev for the privacy LED for sensors.
active_state: Active state for the subdev (NULL for subdevs tracking thestate internally). Initialized by callingv4l2_subdev_init_finalize().
enabled_pads: Bitmask of enabled pads used byv4l2_subdev_enable_streams()andv4l2_subdev_disable_streams() helper functions forfallback cases.
s_stream_enabled: Tracks whether streaming has been enabled with s_stream.This is only forcall_s_stream() internal use.

Description

Each instance of a subdev driver should create this struct, eitherstand-alone or embedded in a larger struct.

This structure should be initialized byv4l2_subdev_init() or one ofits variants:v4l2_spi_subdev_init(),v4l2_i2c_subdev_init().

media_entity_to_v4l2_subdev¶

media_entity_to_v4l2_subdev(ent)

Returns astructv4l2_subdev from thestructmedia_entity embedded in it.

Parameters

ent: pointer tostructmedia_entity.

vdev_to_v4l2_subdev¶

vdev_to_v4l2_subdev(vdev)

Returns astructv4l2_subdev from thestructvideo_device embedded on it.

Parameters

vdev: pointer tostructvideo_device

structv4l2_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_state *state;    u64 client_caps;#endif;};

Members

vfh: pointer tostructv4l2_fh
owner: module pointer to the owner of this file handle
state: pointer tostructv4l2_subdev_state
client_caps: bitmask ofV4L2_SUBDEV_CLIENT_CAP_*

to_v4l2_subdev_fh¶

to_v4l2_subdev_fh(fh)

Returns astructv4l2_subdev_fh from thestructv4l2_fh embedded on it.

Parameters

fh: pointer tostructv4l2_fh

voidv4l2_set_subdevdata(structv4l2_subdev*sd,void*p)¶: Sets V4L2 dev private device data

Parameters

structv4l2_subdev*sd: pointer tostructv4l2_subdev
void*p: pointer to the private device data to be stored.

void*v4l2_get_subdevdata(conststructv4l2_subdev*sd)¶: Gets V4L2 dev private device data

Parameters

conststructv4l2_subdev*sd: pointer tostructv4l2_subdev

Description

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

voidv4l2_set_subdev_hostdata(structv4l2_subdev*sd,void*p)¶: Sets V4L2 dev private host data

Parameters

structv4l2_subdev*sd: pointer tostructv4l2_subdev
void*p: pointer to the private data to be stored.

void*v4l2_get_subdev_hostdata(conststructv4l2_subdev*sd)¶: Gets V4L2 dev private data

Parameters

conststructv4l2_subdev*sd: pointer tostructv4l2_subdev

Description

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

intv4l2_subdev_get_fwnode_pad_1_to_1(structmedia_entity*entity,structfwnode_endpoint*endpoint)¶: Get pad number from a subdev fwnode endpoint, assuming 1:1 port:pad

Parameters

structmedia_entity*entity: Pointer to the subdev entity
structfwnode_endpoint*endpoint: Pointer to a parsed fwnode endpoint

Description

This function can be used as the .get_fwnode_pad operation forsubdevices that map port numbers and pad indexes 1:1. If the endpointis owned by the subdevice, the function returns the endpoint portnumber.

Returns the endpoint port number on success or a negative error code.

intv4l2_subdev_link_validate_default(structv4l2_subdev*sd,structmedia_link*link,structv4l2_subdev_format*source_fmt,structv4l2_subdev_format*sink_fmt)¶: validates a media link

Parameters

structv4l2_subdev*sd: pointer tostructv4l2_subdev
structmedia_link*link: pointer tostructmedia_link
structv4l2_subdev_format*source_fmt: pointer tostructv4l2_subdev_format
structv4l2_subdev_format*sink_fmt: pointer tostructv4l2_subdev_format

Description

This function ensures that width, height and the media bus pixelcode are equal on both source and sink of the link.

intv4l2_subdev_link_validate(structmedia_link*link)¶: validates a media link

Parameters

structmedia_link*link: pointer tostructmedia_link

Description

This function calls the subdev’s link_validate ops to validateif a media link is valid for streaming. It also internallycallsv4l2_subdev_link_validate_default() to ensure thatwidth, height and the media bus pixel code are equal on bothsource and sink of the link.

The function can be used as a drop-inmedia_entity_ops.link_validateimplementation for v4l2_subdev instances. It supports all links betweensubdevs, as well as links between subdevs and video devices, provided thatthe video devices also implement theirmedia_entity_ops.link_validateoperation.

boolv4l2_subdev_has_pad_interdep(structmedia_entity*entity,unsignedintpad0,unsignedintpad1)¶: MC has_pad_interdep implementation for subdevs

Parameters

structmedia_entity*entity: pointer tostructmedia_entity
unsignedintpad0: pad number for the first pad
unsignedintpad1: pad number for the second pad

Description

This function is an implementation of themedia_entity_operations.has_pad_interdep operation for subdevs thatimplement the multiplexed streams API (as indicated by theV4L2_SUBDEV_FL_STREAMS subdev flag).

It considers two pads interdependent if there is an active route between pad0and pad1.

structv4l2_subdev_state*__v4l2_subdev_state_alloc(structv4l2_subdev*sd,constchar*lock_name,structlock_class_key*key)¶: allocate v4l2_subdev_state

Parameters

structv4l2_subdev*sd: pointer tostructv4l2_subdev for which the state is being allocated.
constchar*lock_name: name of the state lock
structlock_class_key*key: lock_class_key for the lock

Description

Must call__v4l2_subdev_state_free() when state is no longer needed.

Not to be called directly by the drivers.

void__v4l2_subdev_state_free(structv4l2_subdev_state*state)¶: free a v4l2_subdev_state

Parameters

structv4l2_subdev_state*state: v4l2_subdev_state to be freed.

Description

Not to be called directly by the drivers.

v4l2_subdev_init_finalize¶

v4l2_subdev_init_finalize(sd)

Finalizes the initialization of the subdevice

Parameters

sd: The subdev

Description

This function finalizes the initialization of the subdev, includingallocation of the active state for the subdev.

This function must be called by the subdev drivers that use the centralizedactive state, after the subdevstructhas been initialized andmedia_entity_pads_init() has been called, but before registering thesubdev.

The user must callv4l2_subdev_cleanup() when the subdev is being removed.

voidv4l2_subdev_cleanup(structv4l2_subdev*sd)¶: Releases the resources allocated by the subdevice

Parameters

structv4l2_subdev*sd: The subdevice

Description

Clean up a V4L2 async sub-device. Must be called for a sub-device as part ofits release if resources have been associated with it usingv4l2_async_subdev_endpoint_add() orv4l2_subdev_init_finalize().

v4l2_subdev_state_get_format¶

v4l2_subdev_state_get_format(state,pad,...)

Get pointer to a stream format

Parameters

state: subdevice state
pad: pad id
...: stream id (optional argument)

Description

This returns a pointer tostructv4l2_mbus_framefmt for the given pad +stream in the subdev state.

For stream-unaware drivers the format for the corresponding pad is returned.If the pad does not exist, NULL is returned.

v4l2_subdev_state_get_crop¶

v4l2_subdev_state_get_crop(state,pad,...)

Get pointer to a stream crop rectangle

Parameters

state: subdevice state
pad: pad id
...: stream id (optional argument)

Description

This returns a pointer to crop rectangle for the given pad + stream in thesubdev state.

For stream-unaware drivers the crop rectangle for the corresponding pad isreturned. If the pad does not exist, NULL is returned.

v4l2_subdev_state_get_compose¶

v4l2_subdev_state_get_compose(state,pad,...)

Get pointer to a stream compose rectangle

Parameters

state: subdevice state
pad: pad id
...: stream id (optional argument)

Description

This returns a pointer to compose rectangle for the given pad + stream in thesubdev state.

For stream-unaware drivers the compose rectangle for the corresponding pad isreturned. If the pad does not exist, NULL is returned.

v4l2_subdev_state_get_interval¶

v4l2_subdev_state_get_interval(state,pad,...)

Get pointer to a stream frame interval

Parameters

state: subdevice state
pad: pad id
...: stream id (optional argument)

Description

This returns a pointer to the frame interval for the given pad + stream inthe subdev state.

For stream-unaware drivers the frame interval for the corresponding pad isreturned. If the pad does not exist, NULL is returned.

intv4l2_subdev_get_fmt(structv4l2_subdev*sd,structv4l2_subdev_state*state,structv4l2_subdev_format*format)¶: Fill format based on state

Parameters

structv4l2_subdev*sd: subdevice
structv4l2_subdev_state*state: subdevice state
structv4l2_subdev_format*format: pointer tostructv4l2_subdev_format

Description

Fillformat->format field based on the information in theformat struct.

This function can be used by the subdev drivers which support active state toimplement v4l2_subdev_pad_ops.get_fmt if the subdev driver does not need todo anything special in their get_fmt op.

Returns 0 on success, error value otherwise.

intv4l2_subdev_get_frame_interval(structv4l2_subdev*sd,structv4l2_subdev_state*state,structv4l2_subdev_frame_interval*fi)¶: Fill frame interval based on state

Parameters

structv4l2_subdev*sd: subdevice
structv4l2_subdev_state*state: subdevice state
structv4l2_subdev_frame_interval*fi: pointer tostructv4l2_subdev_frame_interval

Description

Fillfi->interval field based on the information in thefi struct.

This function can be used by the subdev drivers which support active state toimplement v4l2_subdev_pad_ops.get_frame_interval if the subdev driver doesnot need to do anything special in their get_frame_interval op.

Returns 0 on success, error value otherwise.

intv4l2_subdev_set_routing(structv4l2_subdev*sd,structv4l2_subdev_state*state,conststructv4l2_subdev_krouting*routing)¶: Set given routing to subdev state

Parameters

structv4l2_subdev*sd: The subdevice
structv4l2_subdev_state*state: The subdevice state
conststructv4l2_subdev_krouting*routing: Routing that will be copied to subdev state

Description

This will release old routing table (if any) from the state, allocateenough space for the given routing, and copy the routing.

This can be used from the subdev driver’s set_routing op, after validatingthe routing.

for_each_active_route¶

for_each_active_route(routing,route)

iterate on all active routes of a routing table

Parameters

routing: The routing table
route: The route iterator

intv4l2_subdev_set_routing_with_fmt(structv4l2_subdev*sd,structv4l2_subdev_state*state,conststructv4l2_subdev_krouting*routing,conststructv4l2_mbus_framefmt*fmt)¶: Set given routing and format to subdev state

Parameters

structv4l2_subdev*sd: The subdevice
structv4l2_subdev_state*state: The subdevice state
conststructv4l2_subdev_krouting*routing: Routing that will be copied to subdev state
conststructv4l2_mbus_framefmt*fmt: Format used to initialize all the streams

Description

This is the same as v4l2_subdev_set_routing, but additionally initializesall the streams using the given format.

intv4l2_subdev_routing_find_opposite_end(conststructv4l2_subdev_krouting*routing,u32pad,u32stream,u32*other_pad,u32*other_stream)¶: Find the opposite stream

Parameters

conststructv4l2_subdev_krouting*routing: routing used to find the opposite side
u32pad: pad id
u32stream: stream id
u32*other_pad: pointer used to return the opposite pad
u32*other_stream: pointer used to return the opposite stream

Description

This function uses the routing table to find the pad + stream which isopposite the given pad + stream.

other_pad and/orother_stream can be NULL if the caller does not need thevalue.

Returns 0 on success, or -EINVAL if no matching route is found.

structv4l2_mbus_framefmt*v4l2_subdev_state_get_opposite_stream_format(structv4l2_subdev_state*state,u32pad,u32stream)¶: Get pointer to opposite stream format

Parameters

structv4l2_subdev_state*state: subdevice state
u32pad: pad id
u32stream: stream id

Description

This returns a pointer tostructv4l2_mbus_framefmt for the pad + streamthat is opposite the given pad + stream in the subdev state.

If the state does not contain the given pad + stream, NULL is returned.

u64v4l2_subdev_state_xlate_streams(conststructv4l2_subdev_state*state,u32pad0,u32pad1,u64*streams)¶: Translate streams from one pad to another

Parameters

conststructv4l2_subdev_state*state: Subdevice state
u32pad0: The first pad
u32pad1: The second pad
u64*streams: Streams bitmask on the first pad

Description

Streams on sink pads of a subdev are routed to source pads as expressed inthe subdev state routing table. Stream numbers don’t necessarily match onthe sink and source side of a route. This function translates stream numbersonpad0, expressed as a bitmask instreams, to the corresponding streamsonpad1 using the routing table from thestate. It returns the stream maskonpad1, and updatesstreams with the streams that have been found in therouting table.

pad0 andpad1 must be a sink and a source, in any order.

Return

The bitmask of streams ofpad1 that are routed tostreams onpad0.

enumv4l2_subdev_routing_restriction¶: Subdevice internal routing restrictions

Constants

V4L2_SUBDEV_ROUTING_NO_1_TO_N: an input stream shall not be routed to multiple output streams (streamduplication)
V4L2_SUBDEV_ROUTING_NO_N_TO_1: multiple input streams shall not be routed to the same output stream(stream merging)
V4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX: all streams from a sink pad must be routed to a single source pad
V4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX: all streams on a source pad must originate from a single sink pad
V4L2_SUBDEV_ROUTING_NO_SINK_MULTIPLEXING: sink pads shall not contain multiplexed streams
V4L2_SUBDEV_ROUTING_NO_SOURCE_MULTIPLEXING: source pads shall not contain multiplexed streams
V4L2_SUBDEV_ROUTING_ONLY_1_TO_1: only non-overlapping 1-to-1 stream routing is allowed (a combination ofV4L2_SUBDEV_ROUTING_NO_1_TO_N andV4L2_SUBDEV_ROUTING_NO_N_TO_1)
V4L2_SUBDEV_ROUTING_NO_STREAM_MIX: all streams from a sink pad must be routed to a single source pad, andthat source pad shall not get routes from any other sink pad(a combination ofV4L2_SUBDEV_ROUTING_NO_SINK_STREAM_MIX andV4L2_SUBDEV_ROUTING_NO_SOURCE_STREAM_MIX)
V4L2_SUBDEV_ROUTING_NO_MULTIPLEXING: no multiplexed streams allowed on either source or sink sides.

intv4l2_subdev_routing_validate(structv4l2_subdev*sd,conststructv4l2_subdev_krouting*routing,enumv4l2_subdev_routing_restrictiondisallow)¶: Verify that routes comply with driver constraints

Parameters

structv4l2_subdev*sd: The subdevice
conststructv4l2_subdev_krouting*routing: Routing to verify
enumv4l2_subdev_routing_restrictiondisallow: Restrictions on routes

Description

This verifies that the given routing complies with thedisallow constraints.

Returns 0 on success, error value otherwise.

intv4l2_subdev_enable_streams(structv4l2_subdev*sd,u32pad,u64streams_mask)¶: Enable streams on a pad

Parameters

structv4l2_subdev*sd: The subdevice
u32pad: The pad
u64streams_mask: Bitmask of streams to enable

Description

This function enables streams on a sourcepad of a subdevice. The pad isidentified by its index, while the streams are identified by thestreams_mask bitmask. This allows enabling multiple streams on a pad atonce.

Enabling a stream that is already enabled isn’t allowed. Ifstreams_maskcontains an already enabled stream, this function returns -EALREADY withoutperforming any operation.

Per-stream enable is only available for subdevs that implement the.enable_streams() and .disable_streams() operations. For other subdevs, thisfunction implements a best-effort compatibility by calling the .s_stream()operation, limited to subdevs that have a single source pad.

Drivers that are not stream-aware shall setstreams_mask to BIT_ULL(0).

Return

0: Success
-EALREADY: One of the streams in streams_mask is already enabled
-EINVAL: The pad index is invalid, or doesn’t correspond to a source pad
-EOPNOTSUPP: Falling back to the legacy .s_stream() operation isimpossible because the subdev has multiple source pads

intv4l2_subdev_disable_streams(structv4l2_subdev*sd,u32pad,u64streams_mask)¶: Disable streams on a pad

Parameters

structv4l2_subdev*sd: The subdevice
u32pad: The pad
u64streams_mask: Bitmask of streams to disable

Description

This function disables streams on a sourcepad of a subdevice. The pad isidentified by its index, while the streams are identified by thestreams_mask bitmask. This allows disabling multiple streams on a pad atonce.

Disabling a streams that is not enabled isn’t allowed. Ifstreams_maskcontains a disabled stream, this function returns -EALREADY withoutperforming any operation.

Per-stream disable is only available for subdevs that implement the.enable_streams() and .disable_streams() operations. For other subdevs, thisfunction implements a best-effort compatibility by calling the .s_stream()operation, limited to subdevs that have a single source pad.

Drivers that are not stream-aware shall setstreams_mask to BIT_ULL(0).

Return

0: Success
-EALREADY: One of the streams in streams_mask is not enabled
-EINVAL: The pad index is invalid, or doesn’t correspond to a source pad
-EOPNOTSUPP: Falling back to the legacy .s_stream() operation isimpossible because the subdev has multiple source pads

intv4l2_subdev_s_stream_helper(structv4l2_subdev*sd,intenable)¶: Helper to implement the subdev s_stream operation using enable_streams and disable_streams

Parameters

structv4l2_subdev*sd: The subdevice
intenable: Enable or disable streaming

Description

Subdevice drivers that implement the streams-awarev4l2_subdev_pad_ops.enable_streams andv4l2_subdev_pad_ops.disable_streamsoperations can use this helper to implement the legacyv4l2_subdev_video_ops.s_stream operation.

This helper can only be used by subdevs that have a single source pad.

Return

0 on success, or a negative error code otherwise.

voidv4l2_subdev_lock_state(structv4l2_subdev_state*state)¶: Locks the subdev state

Parameters

structv4l2_subdev_state*state: The subdevice state

Description

Locks the given subdev state.

The state must be unlocked withv4l2_subdev_unlock_state() after use.

voidv4l2_subdev_unlock_state(structv4l2_subdev_state*state)¶: Unlocks the subdev state

Parameters

structv4l2_subdev_state*state: The subdevice state

Description

Unlocks the given subdev state.

voidv4l2_subdev_lock_states(structv4l2_subdev_state*state1,structv4l2_subdev_state*state2)¶: Lock two sub-device states

Parameters

structv4l2_subdev_state*state1: One subdevice state
structv4l2_subdev_state*state2: The other subdevice state

Description

Locks the state of two sub-devices.

The states must be unlocked withv4l2_subdev_unlock_states() after use.

This differs from callingv4l2_subdev_lock_state() on both states so that ifthe states share the same lock, the lock is acquired only once (so nodeadlock occurs). The caller is responsible for ensuring the locks willalways be acquired in the same order.

voidv4l2_subdev_unlock_states(structv4l2_subdev_state*state1,structv4l2_subdev_state*state2)¶: Unlock two sub-device states

Parameters

structv4l2_subdev_state*state1: One subdevice state
structv4l2_subdev_state*state2: The other subdevice state

Description

Unlocks the state of two sub-devices.

This differs from callingv4l2_subdev_unlock_state() on both states so thatif the states share the same lock, the lock is released only once.

structv4l2_subdev_state*v4l2_subdev_get_unlocked_active_state(structv4l2_subdev*sd)¶: Checks that the active subdev state is unlocked and returns it

Parameters

structv4l2_subdev*sd: The subdevice

Description

Returns the active state for the subdevice, or NULL if the subdev does notsupport active state. If the state is not NULL, callslockdep_assert_not_held() to issue a warning if the state is locked.

This function is to be used e.g. when getting the active state for the solepurpose of passing it forward, without accessing the state fields.

structv4l2_subdev_state*v4l2_subdev_get_locked_active_state(structv4l2_subdev*sd)¶: Checks that the active subdev state is locked and returns it

Parameters

structv4l2_subdev*sd: The subdevice

Description

Returns the active state for the subdevice, or NULL if the subdev does notsupport active state. If the state is not NULL, callslockdep_assert_held()to issue a warning if the state is not locked.

This function is to be used when the caller knows that the active state isalready locked.

structv4l2_subdev_state*v4l2_subdev_lock_and_get_active_state(structv4l2_subdev*sd)¶: Locks and returns the active subdev state for the subdevice

Parameters

structv4l2_subdev*sd: The subdevice

Description

Returns the locked active state for the subdevice, or NULL if the subdevdoes not support active state.

The state must be unlocked withv4l2_subdev_unlock_state() after use.

voidv4l2_subdev_init(structv4l2_subdev*sd,conststructv4l2_subdev_ops*ops)¶: initializes the sub-device struct

Parameters

structv4l2_subdev*sd: pointer to thestructv4l2_subdev to be initialized
conststructv4l2_subdev_ops*ops: pointer tostructv4l2_subdev_ops.

v4l2_subdev_call¶

v4l2_subdev_call(sd,o,f,args...)

call an operation of a v4l2_subdev.

Parameters

sd: pointer to thestructv4l2_subdev
o: name of the element atstructv4l2_subdev_ops that containsf.Each element there groups a set of callbacks functions.
f: callback function to be called.The callback functions are defined in groups, according toeach element atstructv4l2_subdev_ops.
args...: arguments forf.

Example

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

v4l2_subdev_call_state_active¶

v4l2_subdev_call_state_active(sd,o,f,args...)

call an operation of a v4l2_subdev which takes state as a parameter, passing the subdev its active state.

Parameters

sd: pointer to thestructv4l2_subdev
o: name of the element atstructv4l2_subdev_ops that containsf.Each element there groups a set of callbacks functions.
f: callback function to be called.The callback functions are defined in groups, according toeach element atstructv4l2_subdev_ops.
args...: arguments forf.

Description

This is similar tov4l2_subdev_call(), except that this version can only beused for ops that take a subdev state as a parameter. The macro will get theactive state, lock it before calling the op and unlock it after the call.

v4l2_subdev_call_state_try¶

v4l2_subdev_call_state_try(sd,o,f,args...)

call an operation of a v4l2_subdev which takes state as a parameter, passing the subdev a newly allocated try state.

Parameters

sd: pointer to thestructv4l2_subdev
o: name of the element atstructv4l2_subdev_ops that containsf.Each element there groups a set of callbacks functions.
f: callback function to be called.The callback functions are defined in groups, according toeach element atstructv4l2_subdev_ops.
args...: arguments forf.

Description

This is similar tov4l2_subdev_call_state_active(), except that as thisversion allocates a new state, this is only usable forV4L2_SUBDEV_FORMAT_TRY use cases.

Note

only legacy non-MC drivers may need this macro.

v4l2_subdev_has_op¶

v4l2_subdev_has_op(sd,o,f)

Checks if a subdev defines a certain operation.

Parameters

sd: pointer to thestructv4l2_subdev
o: The group of callback functions instructv4l2_subdev_opswhichf is a part of.
f: callback function to be checked for its existence.

voidv4l2_subdev_notify_event(structv4l2_subdev*sd,conststructv4l2_event*ev)¶: Delivers event notification for subdevice

Parameters

structv4l2_subdev*sd: The subdev for which to deliver the event
conststructv4l2_event*ev: The event to deliver

Description

Will deliver the specified event to all userspace event listeners which aresubscribed to the v42l subdev event queue as well as to the bridge driverusing the notify callback. The notification type for the notify callbackwill beV4L2_DEVICE_NOTIFY_EVENT.

boolv4l2_subdev_is_streaming(structv4l2_subdev*sd)¶: Returns if the subdevice is streaming

Parameters

structv4l2_subdev*sd: The subdevice

Description

v4l2_subdev_is_streaming() tells if the subdevice is currently streaming.“Streaming” here means whether .s_stream() or .enable_streams() has beensuccessfully called, and the streaming has not yet been disabled.

If the subdevice implements .enable_streams() this function must be calledwhile holding the active state lock.

Movatterモバイル変換

2.7.V4L2 sub-devices¶

2.7.1.Subdev registration¶

2.7.1.1.Registering synchronous sub-devices¶

2.7.1.2.Registering asynchronous sub-devices¶

2.7.1.3.Asynchronous sub-device notifiers¶

2.7.1.4.Asynchronous sub-device notifier for sub-devices¶

2.7.1.5.Asynchronous sub-device registration helper for camera sensor drivers¶

2.7.1.6.Asynchronous sub-device notifier example¶

2.7.1.7.Asynchronous sub-device notifier callbacks¶

2.7.2.Calling subdev operations¶

2.8.V4L2 sub-device userspace API¶

2.9.Read-only sub-device userspace API¶

2.10.I2C sub-device drivers¶

2.11.Centrally managed subdev active state¶

2.12.Streams, multiplexed media pads and internal routing¶

2.13.V4L2 sub-device functions and data structures¶