1.. SPDX-License-Identifier: GPL-2.0
2
3V4L2 sub-devices
4----------------
5
6Many drivers need to communicate with sub-devices. These devices can do all
7sort of tasks, but most commonly they handle audio and/or video muxing,
8encoding or decoding. For webcams common sub-devices are sensors and camera
9controllers.
10
11Usually these are I2C devices, but not necessarily. In order to provide the
12driver with a consistent interface to these sub-devices the
13:c:type:`v4l2_subdev` struct (v4l2-subdev.h) was created.
14
15Each sub-device driver must have a :c:type:`v4l2_subdev` struct. This struct
16can be stand-alone for simple sub-devices or it might be embedded in a larger
17struct if more state information needs to be stored. Usually there is a
18low-level device struct (e.g. ``i2c_client``) that contains the device data as
19setup by the kernel. It is recommended to store that pointer in the private
20data of :c:type:`v4l2_subdev` using :c:func:`v4l2_set_subdevdata`. That makes
21it easy to go from a :c:type:`v4l2_subdev` to the actual low-level bus-specific
22device data.
23
24You also need a way to go from the low-level struct to :c:type:`v4l2_subdev`.
25For the common i2c_client struct the i2c_set_clientdata() call is used to store
26a :c:type:`v4l2_subdev` pointer, for other buses you may have to use other
27methods.
28
29Bridges might also need to store per-subdev private data, such as a pointer to
30bridge-specific per-subdev private data. The :c:type:`v4l2_subdev` structure
31provides 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`.
33
34From the bridge driver perspective, you load the sub-device module and somehow
35obtain 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.
37Helper functions exist for sub-devices on an I2C bus that do most of this
38tricky work for you.
39
40Each :c:type:`v4l2_subdev` contains function pointers that sub-device drivers
41can implement (or leave ``NULL`` if it is not applicable). Since sub-devices can
42do so many different things and you do not want to end up with a huge ops struct
43of which only a handful of ops are commonly implemented, the function pointers
44are sorted according to category and each category has its own ops struct.
45
46The top-level ops struct contains pointers to the category ops structs, which
47may be NULL if the subdev driver does not support anything from that category.
48
49It looks like this:
50
51.. code-block:: c
52
53	struct v4l2_subdev_core_ops {
54		int (*log_status)(struct v4l2_subdev *sd);
55		int (*init)(struct v4l2_subdev *sd, u32 val);
56		...
57	};
58
59	struct v4l2_subdev_tuner_ops {
60		...
61	};
62
63	struct v4l2_subdev_audio_ops {
64		...
65	};
66
67	struct v4l2_subdev_video_ops {
68		...
69	};
70
71	struct v4l2_subdev_pad_ops {
72		...
73	};
74
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;
81	};
82
83The core ops are common to all subdevs, the other categories are implemented
84depending on the sub-device. E.g. a video device is unlikely to support the
85audio ops and vice versa.
86
87This setup limits the number of function pointers while still making it easy
88to add new ops and categories.
89
90A sub-device driver initializes the :c:type:`v4l2_subdev` struct using:
91
92	:c:func:`v4l2_subdev_init <v4l2_subdev_init>`
93	(:c:type:`sd <v4l2_subdev>`, &\ :c:type:`ops <v4l2_subdev_ops>`).
94
95
96Afterwards you need to initialize :c:type:`sd <v4l2_subdev>`->name with a
97unique name and set the module owner. This is done for you if you use the
98i2c helper functions.
99
100If 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
103pads:
104
105.. code-block:: c
106
107	struct media_pad *pads = &my_sd->pads;
108	int err;
109
110	err = media_entity_pads_init(&sd->entity, npads, pads);
111
112The pads array must have been previously initialized. There is no need to
113manually set the struct media_entity function and name fields, but the
114revision field must be initialized if needed.
115
116A reference to the entity will be automatically acquired/released when the
117subdev device node (if any) is opened/closed.
118
119Don't forget to cleanup the media entity before the sub-device is destroyed:
120
121.. code-block:: c
122
123	media_entity_cleanup(&sd->entity);
124
125If a sub-device driver implements sink pads, the subdev driver may set the
126link_validate field in :c:type:`v4l2_subdev_pad_ops` to provide its own link
127validation function. For every link in the pipeline, the link_validate pad
128operation of the sink end of the link is called. In both cases the driver is
129still responsible for validating the correctness of the format configuration
130between sub-devices and video nodes.
131
132If link_validate op is not set, the default function
133:c:func:`v4l2_subdev_link_validate_default` is used instead. This function
134ensures that width, height and the media bus pixel code are equal on both source
135and sink of the link. Subdev drivers are also free to use this function to
136perform the checks mentioned above in addition to their own checks.
137
138Subdev registration
139~~~~~~~~~~~~~~~~~~~
140
141There are currently two ways to register subdevices with the V4L2 core. The
142first (traditional) possibility is to have subdevices registered by bridge
143drivers. This can be done when the bridge driver has the complete information
144about subdevices connected to it and knows exactly when to register them. This
145is typically the case for internal subdevices, like video data processing units
146within SoCs or complex PCI(e) boards, camera sensors in USB cameras or connected
147to SoCs, which pass information about them to bridge drivers, usually in their
148platform data.
149
150There are however also situations where subdevices have to be registered
151asynchronously to bridge devices. An example of such a configuration is a Device
152Tree based system where information about subdevices is made available to the
153system independently from the bridge devices, e.g. when subdevices are defined
154in DT as I2C device nodes. The API used in this second case is described further
155below.
156
157Using one or the other registration method only affects the probing process, the
158run-time bridge-subdevice interaction is in both cases the same.
159
160In the **synchronous** case a device (bridge) driver needs to register the
161:c:type:`v4l2_subdev` with the v4l2_device:
162
163	:c:func:`v4l2_device_register_subdev <v4l2_device_register_subdev>`
164	(:c:type:`v4l2_dev <v4l2_device>`, :c:type:`sd <v4l2_subdev>`).
165
166This can fail if the subdev module disappeared before it could be registered.
167After this function was called successfully the subdev->dev field points to
168the :c:type:`v4l2_device`.
169
170If the v4l2_device parent device has a non-NULL mdev field, the sub-device
171entity will be automatically registered with the media device.
172
173You can unregister a sub-device using:
174
175	:c:func:`v4l2_device_unregister_subdev <v4l2_device_unregister_subdev>`
176	(:c:type:`sd <v4l2_subdev>`).
177
178
179Afterwards the subdev module can be unloaded and
180:c:type:`sd <v4l2_subdev>`->dev == ``NULL``.
181
182In the **asynchronous** case subdevice probing can be invoked independently of
183the bridge driver availability. The subdevice driver then has to verify whether
184all the requirements for a successful probing are satisfied. This can include a
185check for a master clock availability. If any of the conditions aren't satisfied
186the driver might decide to return ``-EPROBE_DEFER`` to request further reprobing
187attempts. Once all conditions are met the subdevice shall be registered using
188the :c:func:`v4l2_async_register_subdev` function. Unregistration is
189performed using the :c:func:`v4l2_async_unregister_subdev` call. Subdevices
190registered this way are stored in a global list of subdevices, ready to be
191picked up by bridge drivers.
192
193Bridge drivers in turn have to register a notifier object. This is
194performed using the :c:func:`v4l2_async_nf_register` call. To
195unregister the notifier the driver has to call
196:c:func:`v4l2_async_nf_unregister`. The former of the two functions
197takes two arguments: a pointer to struct :c:type:`v4l2_device` and a
198pointer to struct :c:type:`v4l2_async_notifier`.
199
200Before registering the notifier, bridge drivers must do two things: first, the
201notifier must be initialized using the :c:func:`v4l2_async_nf_init`.
202Second, bridge drivers can then begin to form a list of subdevice descriptors
203that the bridge device needs for its operation. Several functions are available
204to add subdevice descriptors to a notifier, depending on the type of device and
205the needs of the driver.
206
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
209registering their async sub-devices with the notifier.
210
211:c:func:`v4l2_async_register_subdev_sensor` is a helper function for
212sensor drivers registering their own async sub-device, but it also registers a
213notifier and further registers async sub-devices for lens and flash devices
214found in firmware. The notifier for the sub-device is unregistered with the
215async sub-device.
216
217These 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:
220
221.. code-block:: c
222
223	struct my_async_subdev {
224		struct v4l2_async_subdev asd;
225		...
226	};
227
228	struct my_async_subdev *my_asd;
229	struct fwnode_handle *ep;
230
231	...
232
233	my_asd = v4l2_async_nf_add_fwnode_remote(&notifier, ep,
234						 struct my_async_subdev);
235	fwnode_handle_put(ep);
236
237	if (IS_ERR(asd))
238		return PTR_ERR(asd);
239
240The V4L2 core will then use these descriptors to match asynchronously
241registered subdevices to them. If a match is detected the ``.bound()``
242notifier callback is called. After all subdevices have been located the
243.complete() callback is called. When a subdevice is removed from the
244system the .unbind() method is called. All three callbacks are optional.
245
246Calling subdev operations
247~~~~~~~~~~~~~~~~~~~~~~~~~
248
249The advantage of using :c:type:`v4l2_subdev` is that it is a generic struct and
250does not contain any knowledge about the underlying hardware. So a driver might
251contain several subdevs that use an I2C bus, but also a subdev that is
252controlled through GPIO pins. This distinction is only relevant when setting
253up the device, but once the subdev is registered it is completely transparent.
254
255Once the subdev has been registered you can call an ops function either
256directly:
257
258.. code-block:: c
259
260	err = sd->ops->core->g_std(sd, &norm);
261
262but it is better and easier to use this macro:
263
264.. code-block:: c
265
266	err = v4l2_subdev_call(sd, core, g_std, &norm);
267
268The macro will do the right ``NULL`` pointer checks and returns ``-ENODEV``
269if :c:type:`sd <v4l2_subdev>` is ``NULL``, ``-ENOIOCTLCMD`` if either
270:c:type:`sd <v4l2_subdev>`->core or :c:type:`sd <v4l2_subdev>`->core->g_std is ``NULL``, or the actual result of the
271:c:type:`sd <v4l2_subdev>`->ops->core->g_std ops.
272
273It is also possible to call all or a subset of the sub-devices:
274
275.. code-block:: c
276
277	v4l2_device_call_all(v4l2_dev, 0, core, g_std, &norm);
278
279Any subdev that does not support this ops is skipped and error results are
280ignored. If you want to check for errors use this:
281
282.. code-block:: c
283
284	err = v4l2_device_call_until_err(v4l2_dev, 0, core, g_std, &norm);
285
286Any error except ``-ENOIOCTLCMD`` will exit the loop with that error. If no
287errors (except ``-ENOIOCTLCMD``) occurred, then 0 is returned.
288
289The second argument to both calls is a group ID. If 0, then all subdevs are
290called. If non-zero, then only those whose group ID match that value will
291be called. Before a bridge driver registers a subdev it can set
292:c:type:`sd <v4l2_subdev>`->grp_id to whatever value it wants (it's 0 by
293default). This value is owned by the bridge driver and the sub-device driver
294will never modify or use it.
295
296The group ID gives the bridge driver more control how callbacks are called.
297For example, there may be multiple audio chips on a board, each capable of
298changing the volume. But usually only one will actually be used when the
299user want to change the volume. You can set the group ID for that subdev to
300e.g. AUDIO_CONTROLLER and specify that as the group ID value when calling
301``v4l2_device_call_all()``. That ensures that it will only go to the subdev
302that needs it.
303
304If the sub-device needs to notify its v4l2_device parent of an event, then
305it can call ``v4l2_subdev_notify(sd, notification, arg)``. This macro checks
306whether there is a ``notify()`` callback defined and returns ``-ENODEV`` if not.
307Otherwise the result of the ``notify()`` call is returned.
308
309V4L2 sub-device userspace API
310-----------------------------
311
312Bridge drivers traditionally expose one or multiple video nodes to userspace,
313and control subdevices through the :c:type:`v4l2_subdev_ops` operations in
314response to video node operations. This hides the complexity of the underlying
315hardware from applications. For complex devices, finer-grained control of the
316device than what the video nodes offer may be required. In those cases, bridge
317drivers that implement :ref:`the media controller API <media_controller>` may
318opt for making the subdevice operations directly accessible from userpace.
319
320Device nodes named ``v4l-subdev``\ *X* can be created in ``/dev`` to access
321sub-devices directly. If a sub-device supports direct userspace configuration
322it must set the ``V4L2_SUBDEV_FL_HAS_DEVNODE`` flag before being registered.
323
324After registering sub-devices, the :c:type:`v4l2_device` driver can create
325device nodes for all registered sub-devices marked with
326``V4L2_SUBDEV_FL_HAS_DEVNODE`` by calling
327:c:func:`v4l2_device_register_subdev_nodes`. Those device nodes will be
328automatically removed when sub-devices are unregistered.
329
330The device node handles a subset of the V4L2 API.
331
332``VIDIOC_QUERYCTRL``,
333``VIDIOC_QUERYMENU``,
334``VIDIOC_G_CTRL``,
335``VIDIOC_S_CTRL``,
336``VIDIOC_G_EXT_CTRLS``,
337``VIDIOC_S_EXT_CTRLS`` and
338``VIDIOC_TRY_EXT_CTRLS``:
339
340	The controls ioctls are identical to the ones defined in V4L2. They
341	behave identically, with the only exception that they deal only with
342	controls implemented in the sub-device. Depending on the driver, those
343	controls can be also be accessed through one (or several) V4L2 device
344	nodes.
345
346``VIDIOC_DQEVENT``,
347``VIDIOC_SUBSCRIBE_EVENT`` and
348``VIDIOC_UNSUBSCRIBE_EVENT``
349
350	The events ioctls are identical to the ones defined in V4L2. They
351	behave identically, with the only exception that they deal only with
352	events generated by the sub-device. Depending on the driver, those
353	events can also be reported by one (or several) V4L2 device nodes.
354
355	Sub-device drivers that want to use events need to set the
356	``V4L2_SUBDEV_FL_HAS_EVENTS`` :c:type:`v4l2_subdev`.flags before registering
357	the sub-device. After registration events can be queued as usual on the
358	:c:type:`v4l2_subdev`.devnode device node.
359
360	To properly support events, the ``poll()`` file operation is also
361	implemented.
362
363Private ioctls
364
365	All ioctls not in the above list are passed directly to the sub-device
366	driver through the core::ioctl operation.
367
368Read-only sub-device userspace API
369----------------------------------
370
371Bridge drivers that control their connected subdevices through direct calls to
372the kernel API realized by :c:type:`v4l2_subdev_ops` structure do not usually
373want userspace to be able to change the same parameters through the subdevice
374device node and thus do not usually register any.
375
376It is sometimes useful to report to userspace the current subdevice
377configuration through a read-only API, that does not permit applications to
378change to the device parameters but allows interfacing to the subdevice device
379node to inspect them.
380
381For instance, to implement cameras based on computational photography, userspace
382needs to know the detailed camera sensor configuration (in terms of skipping,
383binning, cropping and scaling) for each supported output resolution. To support
384such use cases, bridge drivers may expose the subdevice operations to userspace
385through a read-only API.
386
387To create a read-only device node for all the subdevices registered with the
388``V4L2_SUBDEV_FL_HAS_DEVNODE`` set, the :c:type:`v4l2_device` driver should call
389:c:func:`v4l2_device_register_ro_subdev_nodes`.
390
391Access to the following ioctls for userspace applications is restricted on
392sub-device device nodes registered with
393:c:func:`v4l2_device_register_ro_subdev_nodes`.
394
395``VIDIOC_SUBDEV_S_FMT``,
396``VIDIOC_SUBDEV_S_CROP``,
397``VIDIOC_SUBDEV_S_SELECTION``:
398
399	These ioctls are only allowed on a read-only subdevice device node
400	for the :ref:`V4L2_SUBDEV_FORMAT_TRY <v4l2-subdev-format-whence>`
401	formats and selection rectangles.
402
403``VIDIOC_SUBDEV_S_FRAME_INTERVAL``,
404``VIDIOC_SUBDEV_S_DV_TIMINGS``,
405``VIDIOC_SUBDEV_S_STD``:
406
407	These ioctls are not allowed on a read-only subdevice node.
408
409In case the ioctl is not allowed, or the format to modify is set to
410``V4L2_SUBDEV_FORMAT_ACTIVE``, the core returns a negative error code and
411the errno variable is set to ``-EPERM``.
412
413I2C sub-device drivers
414----------------------
415
416Since these drivers are so common, special helper functions are available to
417ease the use of these drivers (``v4l2-common.h``).
418
419The recommended method of adding :c:type:`v4l2_subdev` support to an I2C driver
420is to embed the :c:type:`v4l2_subdev` struct into the state struct that is
421created for each I2C device instance. Very simple devices have no state
422struct and in that case you can just create a :c:type:`v4l2_subdev` directly.
423
424A typical state struct would look like this (where 'chipname' is replaced by
425the name of the chip):
426
427.. code-block:: c
428
429	struct chipname_state {
430		struct v4l2_subdev sd;
431		...  /* additional state fields */
432	};
433
434Initialize the :c:type:`v4l2_subdev` struct as follows:
435
436.. code-block:: c
437
438	v4l2_i2c_subdev_init(&state->sd, client, subdev_ops);
439
440This function will fill in all the fields of :c:type:`v4l2_subdev` ensure that
441the :c:type:`v4l2_subdev` and i2c_client both point to one another.
442
443You should also add a helper inline function to go from a :c:type:`v4l2_subdev`
444pointer to a chipname_state struct:
445
446.. code-block:: c
447
448	static inline struct chipname_state *to_state(struct v4l2_subdev *sd)
449	{
450		return container_of(sd, struct chipname_state, sd);
451	}
452
453Use this to go from the :c:type:`v4l2_subdev` struct to the ``i2c_client``
454struct:
455
456.. code-block:: c
457
458	struct i2c_client *client = v4l2_get_subdevdata(sd);
459
460And this to go from an ``i2c_client`` to a :c:type:`v4l2_subdev` struct:
461
462.. code-block:: c
463
464	struct v4l2_subdev *sd = i2c_get_clientdata(client);
465
466Make sure to call
467:c:func:`v4l2_device_unregister_subdev`\ (:c:type:`sd <v4l2_subdev>`)
468when the ``remove()`` callback is called. This will unregister the sub-device
469from the bridge driver. It is safe to call this even if the sub-device was
470never registered.
471
472You need to do this because when the bridge driver destroys the i2c adapter
473the ``remove()`` callbacks are called of the i2c devices on that adapter.
474After that the corresponding v4l2_subdev structures are invalid, so they
475have to be unregistered first. Calling
476:c:func:`v4l2_device_unregister_subdev`\ (:c:type:`sd <v4l2_subdev>`)
477from the ``remove()`` callback ensures that this is always done correctly.
478
479
480The bridge driver also has some helper functions it can use:
481
482.. code-block:: c
483
484	struct v4l2_subdev *sd = v4l2_i2c_new_subdev(v4l2_dev, adapter,
485					"module_foo", "chipid", 0x36, NULL);
486
487This loads the given module (can be ``NULL`` if no module needs to be loaded)
488and calls :c:func:`i2c_new_client_device` with the given ``i2c_adapter`` and
489chip/address arguments. If all goes well, then it registers the subdev with
490the v4l2_device.
491
492You can also use the last argument of :c:func:`v4l2_i2c_new_subdev` to pass
493an array of possible I2C addresses that it should probe. These probe addresses
494are only used if the previous argument is 0. A non-zero argument means that you
495know the exact i2c address so in that case no probing will take place.
496
497Both functions return ``NULL`` if something went wrong.
498
499Note that the chipid you pass to :c:func:`v4l2_i2c_new_subdev` is usually
500the same as the module name. It allows you to specify a chip variant, e.g.
501"saa7114" or "saa7115". In general though the i2c driver autodetects this.
502The use of chipid is something that needs to be looked at more closely at a
503later date. It differs between i2c drivers and as such can be confusing.
504To see which chip variants are supported you can look in the i2c driver code
505for the i2c_device_id table. This lists all the possibilities.
506
507There are one more helper function:
508
509:c:func:`v4l2_i2c_new_subdev_board` uses an :c:type:`i2c_board_info` struct
510which is passed to the i2c driver and replaces the irq, platform_data and addr
511arguments.
512
513If the subdev supports the s_config core ops, then that op is called with
514the irq and platform_data arguments after the subdev was setup.
515
516The :c:func:`v4l2_i2c_new_subdev` function will call
517:c:func:`v4l2_i2c_new_subdev_board`, internally filling a
518:c:type:`i2c_board_info` structure using the ``client_type`` and the
519``addr`` to fill it.
520
521V4L2 sub-device functions and data structures
522---------------------------------------------
523
524.. kernel-doc:: include/media/v4l2-subdev.h
525