1 .. SPDX-License-Identifier: GPL-2.0
2
3 V4L2 sub-devices
4 ----------------
5
6 Many drivers need to communicate with sub-devi
7 sort of tasks, but most commonly they handle a
8 encoding or decoding. For webcams common sub-d
9 controllers.
10
11 Usually these are I2C devices, but not necessa
12 driver with a consistent interface to these su
13 :c:type:`v4l2_subdev` struct (v4l2-subdev.h) w
14
15 Each sub-device driver must have a :c:type:`v4
16 can be stand-alone for simple sub-devices or i
17 struct if more state information needs to be s
18 low-level device struct (e.g. ``i2c_client``)
19 setup by the kernel. It is recommended to stor
20 data of :c:type:`v4l2_subdev` using :c:func:`v
21 it easy to go from a :c:type:`v4l2_subdev` to
22 device data.
23
24 You also need a way to go from the low-level s
25 For the common i2c_client struct the i2c_set_c
26 a :c:type:`v4l2_subdev` pointer, for other bus
27 methods.
28
29 Bridges might also need to store per-subdev pr
30 bridge-specific per-subdev private data. The :
31 provides host private data for that purpose th
32 :c:func:`v4l2_get_subdev_hostdata` and :c:func
33
34 From the bridge driver perspective, you load t
35 obtain the :c:type:`v4l2_subdev` pointer. For
36 ``i2c_get_clientdata()``. For other buses some
37 Helper functions exist for sub-devices on an I
38 tricky work for you.
39
40 Each :c:type:`v4l2_subdev` contains function p
41 can implement (or leave ``NULL`` if it is not
42 do so many different things and you do not wan
43 of which only a handful of ops are commonly im
44 are sorted according to category and each cate
45
46 The top-level ops struct contains pointers to
47 may be NULL if the subdev driver does not supp
48
49 It looks like this:
50
51 .. code-block:: c
52
53 struct v4l2_subdev_core_ops {
54 int (*log_status)(struct v4l2_
55 int (*init)(struct v4l2_subdev
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_
77 const struct v4l2_subdev_tuner
78 const struct v4l2_subdev_audio
79 const struct v4l2_subdev_video
80 const struct v4l2_subdev_pad_o
81 };
82
83 The core ops are common to all subdevs, the ot
84 depending on the sub-device. E.g. a video devi
85 audio ops and vice versa.
86
87 This setup limits the number of function point
88 to add new ops and categories.
89
90 A sub-device driver initializes the :c:type:`v
91
92 :c:func:`v4l2_subdev_init <v4l2_subdev
93 (:c:type:`sd <v4l2_subdev>`, &\ :c:typ
94
95
96 Afterwards you need to initialize :c:type:`sd
97 unique name and set the module owner. This is
98 i2c helper functions.
99
100 If integration with the media framework is nee
101 :c:type:`media_entity` struct embedded in the
102 (entity field) by calling :c:func:`media_entit
103 pads:
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->enti
111
112 The pads array must have been previously initi
113 manually set the struct media_entity function
114 revision field must be initialized if needed.
115
116 A reference to the entity will be automaticall
117 subdev device node (if any) is opened/closed.
118
119 Don't forget to cleanup the media entity befor
120
121 .. code-block:: c
122
123 media_entity_cleanup(&sd->entity);
124
125 If a sub-device driver implements sink pads, t
126 link_validate field in :c:type:`v4l2_subdev_pa
127 validation function. For every link in the pip
128 operation of the sink end of the link is calle
129 still responsible for validating the correctne
130 between sub-devices and video nodes.
131
132 If link_validate op is not set, the default fu
133 :c:func:`v4l2_subdev_link_validate_default` is
134 ensures that width, height and the media bus p
135 and sink of the link. Subdev drivers are also
136 perform the checks mentioned above in addition
137
138 Subdev registration
139 ~~~~~~~~~~~~~~~~~~~
140
141 There are currently two ways to register subde
142 first (traditional) possibility is to have sub
143 drivers. This can be done when the bridge driv
144 about subdevices connected to it and knows exa
145 is typically the case for internal subdevices,
146 within SoCs or complex PCI(e) boards, camera s
147 to SoCs, which pass information about them to
148 platform data.
149
150 There are however also situations where subdev
151 asynchronously to bridge devices. An example o
152 Tree based system where information about subd
153 system independently from the bridge devices,
154 in DT as I2C device nodes. The API used in thi
155 below.
156
157 Using one or the other registration method onl
158 run-time bridge-subdevice interaction is in bo
159
160 Registering synchronous sub-devices
161 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
162
163 In the **synchronous** case a device (bridge)
164 :c:type:`v4l2_subdev` with the v4l2_device:
165
166 :c:func:`v4l2_device_register_subdev <
167 (:c:type:`v4l2_dev <v4l2_device>`, :c:
168
169 This can fail if the subdev module disappeared
170 After this function was called successfully th
171 the :c:type:`v4l2_device`.
172
173 If the v4l2_device parent device has a non-NUL
174 entity will be automatically registered with t
175
176 You can unregister a sub-device using:
177
178 :c:func:`v4l2_device_unregister_subdev
179 (:c:type:`sd <v4l2_subdev>`).
180
181 Afterwards the subdev module can be unloaded a
182 :c:type:`sd <v4l2_subdev>`->dev == ``NULL``.
183
184 .. _media-registering-async-subdevs:
185
186 Registering asynchronous sub-devices
187 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
188
189 In the **asynchronous** case subdevice probing
190 the bridge driver availability. The subdevice
191 all the requirements for a successful probing
192 check for a master clock availability. If any
193 the driver might decide to return ``-EPROBE_DE
194 attempts. Once all conditions are met the subd
195 the :c:func:`v4l2_async_register_subdev` funct
196 performed using the :c:func:`v4l2_async_unregi
197 registered this way are stored in a global lis
198 picked up by bridge drivers.
199
200 Drivers must complete all initialization of th
201 registering it using :c:func:`v4l2_async_regis
202 enabling runtime PM. This is because the sub-d
203 as soon as it gets registered.
204
205 Asynchronous sub-device notifiers
206 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
207
208 Bridge drivers in turn have to register a noti
209 using the :c:func:`v4l2_async_nf_register` cal
210 driver has to call :c:func:`v4l2_async_nf_unre
211 of an unregister notifier, it must be cleaned
212 :c:func:`v4l2_async_nf_cleanup`.
213
214 Before registering the notifier, bridge driver
215 notifier must be initialized using the :c:func
216 bridge drivers can then begin to form a list o
217 that the bridge device needs for its
218 operation. :c:func:`v4l2_async_nf_add_fwnode`,
219 :c:func:`v4l2_async_nf_add_fwnode_remote` and
220
221 Async connection descriptors describe connecti
222 drivers for which are not yet probed. Based on
223 or ancillary link may be created when the rela
224 available. There may be one or more async conn
225 this is not known at the time of adding the co
226 connections are bound as matching async sub-de
227
228 Asynchronous sub-device notifier for sub-devic
229 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
230
231 A driver that registers an asynchronous sub-de
232 asynchronous notifier. This is called an async
233 process is similar to that of a bridge driver
234 initialised using :c:func:`v4l2_async_subdev_n
235 notifier may complete only after the V4L2 devi
236 a path via async sub-devices and notifiers to
237 asynchronous sub-device notifier.
238
239 Asynchronous sub-device registration helper fo
240 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
241
242 :c:func:`v4l2_async_register_subdev_sensor` is
243 drivers registering their own async connection
244 and further registers async connections for le
245 firmware. The notifier for the sub-device is u
246 the async sub-device, using :c:func:`v4l2_asyn
247
248 Asynchronous sub-device notifier example
249 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
250
251 These functions allocate an async connection d
252 :c:type:`v4l2_async_connection` embedded in a
253 :c:type:`v4l2_async_connection` shall be the f
254
255 .. code-block:: c
256
257 struct my_async_connection {
258 struct v4l2_async_connection a
259 ...
260 };
261
262 struct my_async_connection *my_asc;
263 struct fwnode_handle *ep;
264
265 ...
266
267 my_asc = v4l2_async_nf_add_fwnode_remo
268
269 fwnode_handle_put(ep);
270
271 if (IS_ERR(my_asc))
272 return PTR_ERR(my_asc);
273
274 Asynchronous sub-device notifier callbacks
275 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
276
277 The V4L2 core will then use these connection d
278 registered subdevices to them. If a match is d
279 callback is called. After all connections have
280 callback is called. When a connection is remov
281 ``.unbind()`` method is called. All three call
282
283 Drivers can store any type of custom data in t
284 :c:type:`v4l2_async_connection` wrapper. If an
285 handling when the structure is freed, drivers
286 notifier callback. The framework will call it
287 :c:type:`v4l2_async_connection`.
288
289 Calling subdev operations
290 ~~~~~~~~~~~~~~~~~~~~~~~~~
291
292 The advantage of using :c:type:`v4l2_subdev` i
293 does not contain any knowledge about the under
294 contain several subdevs that use an I2C bus, b
295 controlled through GPIO pins. This distinction
296 up the device, but once the subdev is register
297
298 Once the subdev has been registered you can ca
299 directly:
300
301 .. code-block:: c
302
303 err = sd->ops->core->g_std(sd, &norm);
304
305 but it is better and easier to use this macro:
306
307 .. code-block:: c
308
309 err = v4l2_subdev_call(sd, core, g_std
310
311 The macro will do the right ``NULL`` pointer c
312 if :c:type:`sd <v4l2_subdev>` is ``NULL``, ``-
313 :c:type:`sd <v4l2_subdev>`->core or :c:type:`s
314 :c:type:`sd <v4l2_subdev>`->ops->core->g_std o
315
316 It is also possible to call all or a subset of
317
318 .. code-block:: c
319
320 v4l2_device_call_all(v4l2_dev, 0, core
321
322 Any subdev that does not support this ops is s
323 ignored. If you want to check for errors use t
324
325 .. code-block:: c
326
327 err = v4l2_device_call_until_err(v4l2_
328
329 Any error except ``-ENOIOCTLCMD`` will exit th
330 errors (except ``-ENOIOCTLCMD``) occurred, the
331
332 The second argument to both calls is a group I
333 called. If non-zero, then only those whose gro
334 be called. Before a bridge driver registers a
335 :c:type:`sd <v4l2_subdev>`->grp_id to whatever
336 default). This value is owned by the bridge dr
337 will never modify or use it.
338
339 The group ID gives the bridge driver more cont
340 For example, there may be multiple audio chips
341 changing the volume. But usually only one will
342 user want to change the volume. You can set th
343 e.g. AUDIO_CONTROLLER and specify that as the
344 ``v4l2_device_call_all()``. That ensures that
345 that needs it.
346
347 If the sub-device needs to notify its v4l2_dev
348 it can call ``v4l2_subdev_notify(sd, notificat
349 whether there is a ``notify()`` callback defin
350 Otherwise the result of the ``notify()`` call
351
352 V4L2 sub-device userspace API
353 -----------------------------
354
355 Bridge drivers traditionally expose one or mul
356 and control subdevices through the :c:type:`v4
357 response to video node operations. This hides
358 hardware from applications. For complex device
359 device than what the video nodes offer may be
360 drivers that implement :ref:`the media control
361 opt for making the subdevice operations direct
362
363 Device nodes named ``v4l-subdev``\ *X* can be
364 sub-devices directly. If a sub-device supports
365 it must set the ``V4L2_SUBDEV_FL_HAS_DEVNODE``
366
367 After registering sub-devices, the :c:type:`v4
368 device nodes for all registered sub-devices ma
369 ``V4L2_SUBDEV_FL_HAS_DEVNODE`` by calling
370 :c:func:`v4l2_device_register_subdev_nodes`. T
371 automatically removed when sub-devices are unr
372
373 The device node handles a subset of the V4L2 A
374
375 ``VIDIOC_QUERYCTRL``,
376 ``VIDIOC_QUERYMENU``,
377 ``VIDIOC_G_CTRL``,
378 ``VIDIOC_S_CTRL``,
379 ``VIDIOC_G_EXT_CTRLS``,
380 ``VIDIOC_S_EXT_CTRLS`` and
381 ``VIDIOC_TRY_EXT_CTRLS``:
382
383 The controls ioctls are identical to t
384 behave identically, with the only exce
385 controls implemented in the sub-device
386 controls can be also be accessed throu
387 nodes.
388
389 ``VIDIOC_DQEVENT``,
390 ``VIDIOC_SUBSCRIBE_EVENT`` and
391 ``VIDIOC_UNSUBSCRIBE_EVENT``
392
393 The events ioctls are identical to the
394 behave identically, with the only exce
395 events generated by the sub-device. De
396 events can also be reported by one (or
397
398 Sub-device drivers that want to use ev
399 ``V4L2_SUBDEV_FL_HAS_EVENTS`` :c:type:
400 the sub-device. After registration eve
401 :c:type:`v4l2_subdev`.devnode device n
402
403 To properly support events, the ``poll
404 implemented.
405
406 Private ioctls
407
408 All ioctls not in the above list are p
409 driver through the core::ioctl operati
410
411 Read-only sub-device userspace API
412 ----------------------------------
413
414 Bridge drivers that control their connected su
415 the kernel API realized by :c:type:`v4l2_subde
416 want userspace to be able to change the same p
417 device node and thus do not usually register a
418
419 It is sometimes useful to report to userspace
420 configuration through a read-only API, that do
421 change to the device parameters but allows int
422 node to inspect them.
423
424 For instance, to implement cameras based on co
425 needs to know the detailed camera sensor confi
426 binning, cropping and scaling) for each suppor
427 such use cases, bridge drivers may expose the
428 through a read-only API.
429
430 To create a read-only device node for all the
431 ``V4L2_SUBDEV_FL_HAS_DEVNODE`` set, the :c:typ
432 :c:func:`v4l2_device_register_ro_subdev_nodes`
433
434 Access to the following ioctls for userspace a
435 sub-device device nodes registered with
436 :c:func:`v4l2_device_register_ro_subdev_nodes`
437
438 ``VIDIOC_SUBDEV_S_FMT``,
439 ``VIDIOC_SUBDEV_S_CROP``,
440 ``VIDIOC_SUBDEV_S_SELECTION``:
441
442 These ioctls are only allowed on a rea
443 for the :ref:`V4L2_SUBDEV_FORMAT_TRY <
444 formats and selection rectangles.
445
446 ``VIDIOC_SUBDEV_S_FRAME_INTERVAL``,
447 ``VIDIOC_SUBDEV_S_DV_TIMINGS``,
448 ``VIDIOC_SUBDEV_S_STD``:
449
450 These ioctls are not allowed on a read
451
452 In case the ioctl is not allowed, or the forma
453 ``V4L2_SUBDEV_FORMAT_ACTIVE``, the core return
454 the errno variable is set to ``-EPERM``.
455
456 I2C sub-device drivers
457 ----------------------
458
459 Since these drivers are so common, special hel
460 ease the use of these drivers (``v4l2-common.h
461
462 The recommended method of adding :c:type:`v4l2
463 is to embed the :c:type:`v4l2_subdev` struct i
464 created for each I2C device instance. Very sim
465 struct and in that case you can just create a
466
467 A typical state struct would look like this (w
468 the name of the chip):
469
470 .. code-block:: c
471
472 struct chipname_state {
473 struct v4l2_subdev sd;
474 ... /* additional state field
475 };
476
477 Initialize the :c:type:`v4l2_subdev` struct as
478
479 .. code-block:: c
480
481 v4l2_i2c_subdev_init(&state->sd, clien
482
483 This function will fill in all the fields of :
484 the :c:type:`v4l2_subdev` and i2c_client both
485
486 You should also add a helper inline function t
487 pointer to a chipname_state struct:
488
489 .. code-block:: c
490
491 static inline struct chipname_state *t
492 {
493 return container_of(sd, struct
494 }
495
496 Use this to go from the :c:type:`v4l2_subdev`
497 struct:
498
499 .. code-block:: c
500
501 struct i2c_client *client = v4l2_get_s
502
503 And this to go from an ``i2c_client`` to a :c:
504
505 .. code-block:: c
506
507 struct v4l2_subdev *sd = i2c_get_clien
508
509 Make sure to call
510 :c:func:`v4l2_device_unregister_subdev`\ (:c:t
511 when the ``remove()`` callback is called. This
512 from the bridge driver. It is safe to call thi
513 never registered.
514
515 You need to do this because when the bridge dr
516 the ``remove()`` callbacks are called of the i
517 After that the corresponding v4l2_subdev struc
518 have to be unregistered first. Calling
519 :c:func:`v4l2_device_unregister_subdev`\ (:c:t
520 from the ``remove()`` callback ensures that th
521
522
523 The bridge driver also has some helper functio
524
525 .. code-block:: c
526
527 struct v4l2_subdev *sd = v4l2_i2c_new_
528 "modul
529
530 This loads the given module (can be ``NULL`` i
531 and calls :c:func:`i2c_new_client_device` with
532 chip/address arguments. If all goes well, then
533 the v4l2_device.
534
535 You can also use the last argument of :c:func:
536 an array of possible I2C addresses that it sho
537 are only used if the previous argument is 0. A
538 know the exact i2c address so in that case no
539
540 Both functions return ``NULL`` if something we
541
542 Note that the chipid you pass to :c:func:`v4l2
543 the same as the module name. It allows you to
544 "saa7114" or "saa7115". In general though the
545 The use of chipid is something that needs to b
546 later date. It differs between i2c drivers and
547 To see which chip variants are supported you c
548 for the i2c_device_id table. This lists all th
549
550 There are one more helper function:
551
552 :c:func:`v4l2_i2c_new_subdev_board` uses an :c
553 which is passed to the i2c driver and replaces
554 arguments.
555
556 If the subdev supports the s_config core ops,
557 the irq and platform_data arguments after the
558
559 The :c:func:`v4l2_i2c_new_subdev` function wil
560 :c:func:`v4l2_i2c_new_subdev_board`, internall
561 :c:type:`i2c_board_info` structure using the `
562 ``addr`` to fill it.
563
564 Centrally managed subdev active state
565 -------------------------------------
566
567 Traditionally V4L2 subdev drivers maintained i
568 device configuration. This is often implemente
569 v4l2_mbus_framefmt, one entry for each pad, an
570 rectangles.
571
572 In addition to the active configuration, each
573 v4l2_subdev_state, managed by the V4L2 core, w
574 configuration.
575
576 To simplify the subdev drivers the V4L2 subdev
577 centrally managed active configuration represe
578 :c:type:`v4l2_subdev_state`. One instance of s
579 device configuration, is stored in the sub-dev
580 the :c:type:`v4l2_subdev` structure, while the
581 each open file handle, to store the try config
582 handle.
583
584 Sub-device drivers can opt-in and use state to
585 by initializing the subdevice state with a cal
586 before registering the sub-device. They must a
587 to release all the allocated resources before
588 The core automatically allocates and initializ
589 handle to store the try configurations and fre
590 handle.
591
592 V4L2 sub-device operations that use both the :
593 <v4l2-subdev-format-whence>` receive the corre
594 the 'state' parameter. The state must be locke
595 caller by calling :c:func:`v4l2_subdev_lock_st
596 :c:func:`v4l2_subdev_unlock_state()`. The call
597 operation through the :c:func:`v4l2_subdev_cal
598
599 Operations that do not receive a state paramet
600 subdevice active state, which drivers can excl
601 calling :c:func:`v4l2_subdev_lock_and_get_acti
602 state must equally be released by calling :c:f
603
604 Drivers must never manually access the state s
605 or in the file handle without going through th
606
607 While the V4L2 core passes the correct try or
608 operations, many existing device drivers pass
609 operations with :c:func:`v4l2_subdev_call()`.
610 issues with subdevice drivers that let the V4L
611 as they expect to receive the appropriate stat
612 conversion of subdevice drivers to a managed a
613 convert all callers at the same time, an addit
614 added to v4l2_subdev_call(), which handles the
615 the callee's active state with :c:func:`v4l2_s
616 and unlocking the state after the call.
617
618 The whole subdev state is in reality split int
619 v4l2_subdev_state, subdev controls and subdev
620 future these parts should be combined into a s
621 we need a way to handle the locking for these
622 by sharing a lock. The v4l2_ctrl_handler alrea
623 pointer and the same model is used with states
624 before calling v4l2_subdev_init_finalize():
625
626 .. code-block:: c
627
628 sd->ctrl_handler->lock = &priv->mutex;
629 sd->state_lock = &priv->mutex;
630
631 This shares the driver's private mutex between
632
633 Streams, multiplexed media pads and internal r
634 ----------------------------------------------
635
636 A subdevice driver can implement support for m
637 the V4L2_SUBDEV_FL_STREAMS subdev flag and imp
638 centrally managed subdev active state, routing
639 configuration.
640
641 V4L2 sub-device functions and data structures
642 ---------------------------------------------
643
644 .. kernel-doc:: include/media/v4l2-subdev.h
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.