1 .. SPDX-License-Identifier: GPL-2.0
6 Many drivers need to communicate with sub-devices. These devices can do all
7 sort of tasks, but most commonly they handle audio and/or video muxing,
8 encoding or decoding. For webcams common sub-devices are sensors and camera
11 Usually these are I2C devices, but not necessarily. In order to provide the
12 driver with a consistent interface to these sub-devices the
13 :c:type:`v4l2_subdev` struct (v4l2-subdev.h) was created.
15 Each sub-device driver must have a :c:type:`v4l2_subdev` struct. This struct
16 can be stand-alone for simple sub-devices or it might be embedded in a larger
17 struct if more state information needs to be stored. Usually there is a
18 low-level device struct (e.g. ``i2c_client``) that contains the device data as
19 setup by the kernel. It is recommended to store that pointer in the private
20 data of :c:type:`v4l2_subdev` using :c:func:`v4l2_set_subdevdata`. That makes
21 it easy to go from a :c:type:`v4l2_subdev` to the actual low-level bus-specific
24 You also need a way to go from the low-level struct to :c:type:`v4l2_subdev`.
25 For the common i2c_client struct the i2c_set_clientdata() call is used to store
26 a :c:type:`v4l2_subdev` pointer, for other buses you may have to use other
29 Bridges might also need to store per-subdev private data, such as a pointer to
30 bridge-specific per-subdev private data. The :c:type:`v4l2_subdev` structure
31 provides host private data for that purpose that can be accessed with
32 :c:func:`v4l2_get_subdev_hostdata` and :c:func:`v4l2_set_subdev_hostdata`.
34 From the bridge driver perspective, you load the sub-device module and somehow
35 obtain the :c:type:`v4l2_subdev` pointer. For i2c devices this is easy: you call
36 ``i2c_get_clientdata()``. For other buses something similar needs to be done.
37 Helper functions exist for sub-devices on an I2C bus that do most of this
40 Each :c:type:`v4l2_subdev` contains function pointers that sub-device drivers
41 can implement (or leave ``NULL`` if it is not applicable). Since sub-devices can
42 do so many different things and you do not want to end up with a huge ops struct
43 of which only a handful of ops are commonly implemented, the function pointers
44 are sorted according to category and each category has its own ops struct.
46 The top-level ops struct contains pointers to the category ops structs, which
47 may be NULL if the subdev driver does not support anything from that category.
53 struct v4l2_subdev_core_ops {
54 int (*log_status)(struct v4l2_subdev *sd);
55 int (*init)(struct v4l2_subdev *sd, u32 val);
59 struct v4l2_subdev_tuner_ops {
63 struct v4l2_subdev_audio_ops {
67 struct v4l2_subdev_video_ops {
71 struct v4l2_subdev_pad_ops {
75 struct v4l2_subdev_ops {
76 const struct v4l2_subdev_core_ops *core;
77 const struct v4l2_subdev_tuner_ops *tuner;
78 const struct v4l2_subdev_audio_ops *audio;
79 const struct v4l2_subdev_video_ops *video;
80 const struct v4l2_subdev_pad_ops *video;
83 The core ops are common to all subdevs, the other categories are implemented
84 depending on the sub-device. E.g. a video device is unlikely to support the
85 audio ops and vice versa.
87 This setup limits the number of function pointers while still making it easy
88 to add new ops and categories.
90 A sub-device driver initializes the :c:type:`v4l2_subdev` struct using:
92 :c:func:`v4l2_subdev_init <v4l2_subdev_init>`
93 (:c:type:`sd <v4l2_subdev>`, &\ :c:type:`ops <v4l2_subdev_ops>`).
96 Afterwards you need to initialize :c:type:`sd <v4l2_subdev>`->name with a
97 unique name and set the module owner. This is done for you if you use the
100 If integration with the media framework is needed, you must initialize the
101 :c:type:`media_entity` struct embedded in the :c:type:`v4l2_subdev` struct
102 (entity field) by calling :c:func:`media_entity_pads_init`, if the entity has
107 struct media_pad *pads = &my_sd->pads;
110 err = media_entity_pads_init(&sd->entity, npads, pads);
112 The pads array must have been previously initialized. There is no need to
113 manually set the struct media_entity function and name fields, but the
114 revision field must be initialized if needed.
116 A reference to the entity will be automatically acquired/released when the
117 subdev device node (if any) is opened/closed.
119 Don't forget to cleanup the media entity before the sub-device is destroyed:
123 media_entity_cleanup(&sd->entity);
125 If a sub-device driver implements sink pads, the subdev driver may set the
126 link_validate field in :c:type:`v4l2_subdev_pad_ops` to provide its own link
127 validation function. For every link in the pipeline, the link_validate pad
128 operation of the sink end of the link is called. In both cases the driver is
129 still responsible for validating the correctness of the format configuration
130 between sub-devices and video nodes.
132 If link_validate op is not set, the default function
133 :c:func:`v4l2_subdev_link_validate_default` is used instead. This function
134 ensures that width, height and the media bus pixel code are equal on both source
135 and sink of the link. Subdev drivers are also free to use this function to
136 perform the checks mentioned above in addition to their own checks.
141 There are currently two ways to register subdevices with the V4L2 core. The
142 first (traditional) possibility is to have subdevices registered by bridge
143 drivers. This can be done when the bridge driver has the complete information
144 about subdevices connected to it and knows exactly when to register them. This
145 is typically the case for internal subdevices, like video data processing units
146 within SoCs or complex PCI(e) boards, camera sensors in USB cameras or connected
147 to SoCs, which pass information about them to bridge drivers, usually in their
150 There are however also situations where subdevices have to be registered
151 asynchronously to bridge devices. An example of such a configuration is a Device
152 Tree based system where information about subdevices is made available to the
153 system independently from the bridge devices, e.g. when subdevices are defined
154 in DT as I2C device nodes. The API used in this second case is described further
157 Using one or the other registration method only affects the probing process, the
158 run-time bridge-subdevice interaction is in both cases the same.
160 In the **synchronous** case a device (bridge) driver needs to register the
161 :c:type:`v4l2_subdev` with the v4l2_device:
163 :c:func:`v4l2_device_register_subdev <v4l2_device_register_subdev>`
164 (:c:type:`v4l2_dev <v4l2_device>`, :c:type:`sd <v4l2_subdev>`).
166 This can fail if the subdev module disappeared before it could be registered.
167 After this function was called successfully the subdev->dev field points to
168 the :c:type:`v4l2_device`.
170 If the v4l2_device parent device has a non-NULL mdev field, the sub-device
171 entity will be automatically registered with the media device.
173 You can unregister a sub-device using:
175 :c:func:`v4l2_device_unregister_subdev <v4l2_device_unregister_subdev>`
176 (:c:type:`sd <v4l2_subdev>`).
179 Afterwards the subdev module can be unloaded and
180 :c:type:`sd <v4l2_subdev>`->dev == ``NULL``.
182 In the **asynchronous** case subdevice probing can be invoked independently of
183 the bridge driver availability. The subdevice driver then has to verify whether
184 all the requirements for a successful probing are satisfied. This can include a
185 check for a master clock availability. If any of the conditions aren't satisfied
186 the driver might decide to return ``-EPROBE_DEFER`` to request further reprobing
187 attempts. Once all conditions are met the subdevice shall be registered using
188 the :c:func:`v4l2_async_register_subdev` function. Unregistration is
189 performed using the :c:func:`v4l2_async_unregister_subdev` call. Subdevices
190 registered this way are stored in a global list of subdevices, ready to be
191 picked up by bridge drivers.
193 Bridge drivers in turn have to register a notifier object. This is
194 performed using the :c:func:`v4l2_async_nf_register` call. To
195 unregister the notifier the driver has to call
196 :c:func:`v4l2_async_nf_unregister`. The former of the two functions
197 takes two arguments: a pointer to struct :c:type:`v4l2_device` and a
198 pointer to struct :c:type:`v4l2_async_notifier`.
200 Before registering the notifier, bridge drivers must do two things: first, the
201 notifier must be initialized using the :c:func:`v4l2_async_nf_init`.
202 Second, bridge drivers can then begin to form a list of subdevice descriptors
203 that the bridge device needs for its operation. Several functions are available
204 to add subdevice descriptors to a notifier, depending on the type of device and
205 the needs of the driver.
207 :c:func:`v4l2_async_nf_add_fwnode_remote` and
208 :c:func:`v4l2_async_nf_add_i2c` are for bridge and ISP drivers for
209 registering their async sub-devices with the notifier.
211 :c:func:`v4l2_async_register_subdev_sensor` is a helper function for
212 sensor drivers registering their own async sub-device, but it also registers a
213 notifier and further registers async sub-devices for lens and flash devices
214 found in firmware. The notifier for the sub-device is unregistered with the
217 These functions allocate an async sub-device descriptor which is of type struct
218 :c:type:`v4l2_async_subdev` embedded in a driver-specific struct. The &struct
219 :c:type:`v4l2_async_subdev` shall be the first member of this struct:
223 struct my_async_subdev {
224 struct v4l2_async_subdev asd;
228 struct my_async_subdev *my_asd;
229 struct fwnode_handle *ep;
233 my_asd = v4l2_async_nf_add_fwnode_remote(¬ifier, ep,
234 struct my_async_subdev);
235 fwnode_handle_put(ep);
240 The V4L2 core will then use these descriptors to match asynchronously
241 registered subdevices to them. If a match is detected the ``.bound()``
242 notifier callback is called. After all subdevices have been located the
243 .complete() callback is called. When a subdevice is removed from the
244 system the .unbind() method is called. All three callbacks are optional.
246 Drivers can store any type of custom data in their driver-specific
247 :c:type:`v4l2_async_subdev` wrapper. If any of that data requires special
248 handling when the structure is freed, drivers must implement the ``.destroy()``
249 notifier callback. The framework will call it right before freeing the
250 :c:type:`v4l2_async_subdev`.
252 Calling subdev operations
253 ~~~~~~~~~~~~~~~~~~~~~~~~~
255 The advantage of using :c:type:`v4l2_subdev` is that it is a generic struct and
256 does not contain any knowledge about the underlying hardware. So a driver might
257 contain several subdevs that use an I2C bus, but also a subdev that is
258 controlled through GPIO pins. This distinction is only relevant when setting
259 up the device, but once the subdev is registered it is completely transparent.
261 Once the subdev has been registered you can call an ops function either
266 err = sd->ops->core->g_std(sd, &norm);
268 but it is better and easier to use this macro:
272 err = v4l2_subdev_call(sd, core, g_std, &norm);
274 The macro will do the right ``NULL`` pointer checks and returns ``-ENODEV``
275 if :c:type:`sd <v4l2_subdev>` is ``NULL``, ``-ENOIOCTLCMD`` if either
276 :c:type:`sd <v4l2_subdev>`->core or :c:type:`sd <v4l2_subdev>`->core->g_std is ``NULL``, or the actual result of the
277 :c:type:`sd <v4l2_subdev>`->ops->core->g_std ops.
279 It is also possible to call all or a subset of the sub-devices:
283 v4l2_device_call_all(v4l2_dev, 0, core, g_std, &norm);
285 Any subdev that does not support this ops is skipped and error results are
286 ignored. If you want to check for errors use this:
290 err = v4l2_device_call_until_err(v4l2_dev, 0, core, g_std, &norm);
292 Any error except ``-ENOIOCTLCMD`` will exit the loop with that error. If no
293 errors (except ``-ENOIOCTLCMD``) occurred, then 0 is returned.
295 The second argument to both calls is a group ID. If 0, then all subdevs are
296 called. If non-zero, then only those whose group ID match that value will
297 be called. Before a bridge driver registers a subdev it can set
298 :c:type:`sd <v4l2_subdev>`->grp_id to whatever value it wants (it's 0 by
299 default). This value is owned by the bridge driver and the sub-device driver
300 will never modify or use it.
302 The group ID gives the bridge driver more control how callbacks are called.
303 For example, there may be multiple audio chips on a board, each capable of
304 changing the volume. But usually only one will actually be used when the
305 user want to change the volume. You can set the group ID for that subdev to
306 e.g. AUDIO_CONTROLLER and specify that as the group ID value when calling
307 ``v4l2_device_call_all()``. That ensures that it will only go to the subdev
310 If the sub-device needs to notify its v4l2_device parent of an event, then
311 it can call ``v4l2_subdev_notify(sd, notification, arg)``. This macro checks
312 whether there is a ``notify()`` callback defined and returns ``-ENODEV`` if not.
313 Otherwise the result of the ``notify()`` call is returned.
315 V4L2 sub-device userspace API
316 -----------------------------
318 Bridge drivers traditionally expose one or multiple video nodes to userspace,
319 and control subdevices through the :c:type:`v4l2_subdev_ops` operations in
320 response to video node operations. This hides the complexity of the underlying
321 hardware from applications. For complex devices, finer-grained control of the
322 device than what the video nodes offer may be required. In those cases, bridge
323 drivers that implement :ref:`the media controller API <media_controller>` may
324 opt for making the subdevice operations directly accessible from userspace.
326 Device nodes named ``v4l-subdev``\ *X* can be created in ``/dev`` to access
327 sub-devices directly. If a sub-device supports direct userspace configuration
328 it must set the ``V4L2_SUBDEV_FL_HAS_DEVNODE`` flag before being registered.
330 After registering sub-devices, the :c:type:`v4l2_device` driver can create
331 device nodes for all registered sub-devices marked with
332 ``V4L2_SUBDEV_FL_HAS_DEVNODE`` by calling
333 :c:func:`v4l2_device_register_subdev_nodes`. Those device nodes will be
334 automatically removed when sub-devices are unregistered.
336 The device node handles a subset of the V4L2 API.
338 ``VIDIOC_QUERYCTRL``,
339 ``VIDIOC_QUERYMENU``,
342 ``VIDIOC_G_EXT_CTRLS``,
343 ``VIDIOC_S_EXT_CTRLS`` and
344 ``VIDIOC_TRY_EXT_CTRLS``:
346 The controls ioctls are identical to the ones defined in V4L2. They
347 behave identically, with the only exception that they deal only with
348 controls implemented in the sub-device. Depending on the driver, those
349 controls can be also be accessed through one (or several) V4L2 device
353 ``VIDIOC_SUBSCRIBE_EVENT`` and
354 ``VIDIOC_UNSUBSCRIBE_EVENT``
356 The events ioctls are identical to the ones defined in V4L2. They
357 behave identically, with the only exception that they deal only with
358 events generated by the sub-device. Depending on the driver, those
359 events can also be reported by one (or several) V4L2 device nodes.
361 Sub-device drivers that want to use events need to set the
362 ``V4L2_SUBDEV_FL_HAS_EVENTS`` :c:type:`v4l2_subdev`.flags before registering
363 the sub-device. After registration events can be queued as usual on the
364 :c:type:`v4l2_subdev`.devnode device node.
366 To properly support events, the ``poll()`` file operation is also
371 All ioctls not in the above list are passed directly to the sub-device
372 driver through the core::ioctl operation.
374 Read-only sub-device userspace API
375 ----------------------------------
377 Bridge drivers that control their connected subdevices through direct calls to
378 the kernel API realized by :c:type:`v4l2_subdev_ops` structure do not usually
379 want userspace to be able to change the same parameters through the subdevice
380 device node and thus do not usually register any.
382 It is sometimes useful to report to userspace the current subdevice
383 configuration through a read-only API, that does not permit applications to
384 change to the device parameters but allows interfacing to the subdevice device
385 node to inspect them.
387 For instance, to implement cameras based on computational photography, userspace
388 needs to know the detailed camera sensor configuration (in terms of skipping,
389 binning, cropping and scaling) for each supported output resolution. To support
390 such use cases, bridge drivers may expose the subdevice operations to userspace
391 through a read-only API.
393 To create a read-only device node for all the subdevices registered with the
394 ``V4L2_SUBDEV_FL_HAS_DEVNODE`` set, the :c:type:`v4l2_device` driver should call
395 :c:func:`v4l2_device_register_ro_subdev_nodes`.
397 Access to the following ioctls for userspace applications is restricted on
398 sub-device device nodes registered with
399 :c:func:`v4l2_device_register_ro_subdev_nodes`.
401 ``VIDIOC_SUBDEV_S_FMT``,
402 ``VIDIOC_SUBDEV_S_CROP``,
403 ``VIDIOC_SUBDEV_S_SELECTION``:
405 These ioctls are only allowed on a read-only subdevice device node
406 for the :ref:`V4L2_SUBDEV_FORMAT_TRY <v4l2-subdev-format-whence>`
407 formats and selection rectangles.
409 ``VIDIOC_SUBDEV_S_FRAME_INTERVAL``,
410 ``VIDIOC_SUBDEV_S_DV_TIMINGS``,
411 ``VIDIOC_SUBDEV_S_STD``:
413 These ioctls are not allowed on a read-only subdevice node.
415 In case the ioctl is not allowed, or the format to modify is set to
416 ``V4L2_SUBDEV_FORMAT_ACTIVE``, the core returns a negative error code and
417 the errno variable is set to ``-EPERM``.
419 I2C sub-device drivers
420 ----------------------
422 Since these drivers are so common, special helper functions are available to
423 ease the use of these drivers (``v4l2-common.h``).
425 The recommended method of adding :c:type:`v4l2_subdev` support to an I2C driver
426 is to embed the :c:type:`v4l2_subdev` struct into the state struct that is
427 created for each I2C device instance. Very simple devices have no state
428 struct and in that case you can just create a :c:type:`v4l2_subdev` directly.
430 A typical state struct would look like this (where 'chipname' is replaced by
431 the name of the chip):
435 struct chipname_state {
436 struct v4l2_subdev sd;
437 ... /* additional state fields */
440 Initialize the :c:type:`v4l2_subdev` struct as follows:
444 v4l2_i2c_subdev_init(&state->sd, client, subdev_ops);
446 This function will fill in all the fields of :c:type:`v4l2_subdev` ensure that
447 the :c:type:`v4l2_subdev` and i2c_client both point to one another.
449 You should also add a helper inline function to go from a :c:type:`v4l2_subdev`
450 pointer to a chipname_state struct:
454 static inline struct chipname_state *to_state(struct v4l2_subdev *sd)
456 return container_of(sd, struct chipname_state, sd);
459 Use this to go from the :c:type:`v4l2_subdev` struct to the ``i2c_client``
464 struct i2c_client *client = v4l2_get_subdevdata(sd);
466 And this to go from an ``i2c_client`` to a :c:type:`v4l2_subdev` struct:
470 struct v4l2_subdev *sd = i2c_get_clientdata(client);
473 :c:func:`v4l2_device_unregister_subdev`\ (:c:type:`sd <v4l2_subdev>`)
474 when the ``remove()`` callback is called. This will unregister the sub-device
475 from the bridge driver. It is safe to call this even if the sub-device was
478 You need to do this because when the bridge driver destroys the i2c adapter
479 the ``remove()`` callbacks are called of the i2c devices on that adapter.
480 After that the corresponding v4l2_subdev structures are invalid, so they
481 have to be unregistered first. Calling
482 :c:func:`v4l2_device_unregister_subdev`\ (:c:type:`sd <v4l2_subdev>`)
483 from the ``remove()`` callback ensures that this is always done correctly.
486 The bridge driver also has some helper functions it can use:
490 struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter,
491 "module_foo", "chipid", 0x36, NULL);
493 This loads the given module (can be ``NULL`` if no module needs to be loaded)
494 and calls :c:func:`i2c_new_client_device` with the given ``i2c_adapter`` and
495 chip/address arguments. If all goes well, then it registers the subdev with
498 You can also use the last argument of :c:func:`v4l2_i2c_new_subdev` to pass
499 an array of possible I2C addresses that it should probe. These probe addresses
500 are only used if the previous argument is 0. A non-zero argument means that you
501 know the exact i2c address so in that case no probing will take place.
503 Both functions return ``NULL`` if something went wrong.
505 Note that the chipid you pass to :c:func:`v4l2_i2c_new_subdev` is usually
506 the same as the module name. It allows you to specify a chip variant, e.g.
507 "saa7114" or "saa7115". In general though the i2c driver autodetects this.
508 The use of chipid is something that needs to be looked at more closely at a
509 later date. It differs between i2c drivers and as such can be confusing.
510 To see which chip variants are supported you can look in the i2c driver code
511 for the i2c_device_id table. This lists all the possibilities.
513 There are one more helper function:
515 :c:func:`v4l2_i2c_new_subdev_board` uses an :c:type:`i2c_board_info` struct
516 which is passed to the i2c driver and replaces the irq, platform_data and addr
519 If the subdev supports the s_config core ops, then that op is called with
520 the irq and platform_data arguments after the subdev was setup.
522 The :c:func:`v4l2_i2c_new_subdev` function will call
523 :c:func:`v4l2_i2c_new_subdev_board`, internally filling a
524 :c:type:`i2c_board_info` structure using the ``client_type`` and the
527 Centrally managed subdev active state
528 -------------------------------------
530 Traditionally V4L2 subdev drivers maintained internal state for the active
531 device configuration. This is often implemented as e.g. an array of struct
532 v4l2_mbus_framefmt, one entry for each pad, and similarly for crop and compose
535 In addition to the active configuration, each subdev file handle has an array of
536 struct v4l2_subdev_pad_config, managed by the V4L2 core, which contains the try
539 To simplify the subdev drivers the V4L2 subdev API now optionally supports a
540 centrally managed active configuration represented by
541 :c:type:`v4l2_subdev_state`. One instance of state, which contains the active
542 device configuration, is stored in the sub-device itself as part of
543 the :c:type:`v4l2_subdev` structure, while the core associates a try state to
544 each open file handle, to store the try configuration related to that file
547 Sub-device drivers can opt-in and use state to manage their active configuration
548 by initializing the subdevice state with a call to v4l2_subdev_init_finalize()
549 before registering the sub-device. They must also call v4l2_subdev_cleanup()
550 to release all the allocated resources before unregistering the sub-device.
551 The core automatically allocates and initializes a state for each open file
552 handle to store the try configurations and frees it when closing the file
555 V4L2 sub-device operations that use both the :ref:`ACTIVE and TRY formats
556 <v4l2-subdev-format-whence>` receive the correct state to operate on through
557 the 'state' parameter. The state must be locked and unlocked by the
558 caller by calling :c:func:`v4l2_subdev_lock_state()` and
559 :c:func:`v4l2_subdev_unlock_state()`. The caller can do so by calling the subdev
560 operation through the :c:func:`v4l2_subdev_call_state_active()` macro.
562 Operations that do not receive a state parameter implicitly operate on the
563 subdevice active state, which drivers can exclusively access by
564 calling :c:func:`v4l2_subdev_lock_and_get_active_state()`. The sub-device active
565 state must equally be released by calling :c:func:`v4l2_subdev_unlock_state()`.
567 Drivers must never manually access the state stored in the :c:type:`v4l2_subdev`
568 or in the file handle without going through the designated helpers.
570 While the V4L2 core passes the correct try or active state to the subdevice
571 operations, many existing device drivers pass a NULL state when calling
572 operations with :c:func:`v4l2_subdev_call()`. This legacy construct causes
573 issues with subdevice drivers that let the V4L2 core manage the active state,
574 as they expect to receive the appropriate state as a parameter. To help the
575 conversion of subdevice drivers to a managed active state without having to
576 convert all callers at the same time, an additional wrapper layer has been
577 added to v4l2_subdev_call(), which handles the NULL case by getting and locking
578 the callee's active state with :c:func:`v4l2_subdev_lock_and_get_active_state()`,
579 and unlocking the state after the call.
581 The whole subdev state is in reality split into three parts: the
582 v4l2_subdev_state, subdev controls and subdev driver's internal state. In the
583 future these parts should be combined into a single state. For the time being
584 we need a way to handle the locking for these parts. This can be accomplished
585 by sharing a lock. The v4l2_ctrl_handler already supports this via its 'lock'
586 pointer and the same model is used with states. The driver can do the following
587 before calling v4l2_subdev_init_finalize():
591 sd->ctrl_handler->lock = &priv->mutex;
592 sd->state_lock = &priv->mutex;
594 This shares the driver's private mutex between the controls and the states.
596 Streams, multiplexed media pads and internal routing
597 ----------------------------------------------------
599 A subdevice driver can implement support for multiplexed streams by setting
600 the V4L2_SUBDEV_FL_STREAMS subdev flag and implementing support for
601 centrally managed subdev active state, routing and stream based
604 V4L2 sub-device functions and data structures
605 ---------------------------------------------
607 .. kernel-doc:: include/media/v4l2-subdev.h