1 Overview of the V4L2 driver framework
2 =====================================
4 This text documents the various structures provided by the V4L2 framework and
11 The V4L2 drivers tend to be very complex due to the complexity of the
12 hardware: most devices have multiple ICs, export multiple device nodes in
13 /dev, and create also non-V4L2 devices such as DVB, ALSA, FB, I2C and input
16 Especially the fact that V4L2 drivers have to setup supporting ICs to
17 do audio/video muxing/encoding/decoding makes it more complex than most.
18 Usually these ICs are connected to the main bridge driver through one or
19 more I2C busses, but other busses can also be used. Such devices are
22 For a long time the framework was limited to the video_device struct for
23 creating V4L device nodes and video_buf for handling the video buffers
24 (note that this document does not discuss the video_buf framework).
26 This meant that all drivers had to do the setup of device instances and
27 connecting to sub-devices themselves. Some of this is quite complicated
28 to do right and many drivers never did do it correctly.
30 There is also a lot of common code that could never be refactored due to
31 the lack of a framework.
33 So this framework sets up the basic building blocks that all drivers
34 need and this same framework should make it much easier to refactor
35 common code into utility functions shared by all drivers.
41 All drivers have the following structure:
43 1) A struct for each device instance containing the device state.
45 2) A way of initializing and commanding sub-devices (if any).
47 3) Creating V4L2 device nodes (/dev/videoX, /dev/vbiX, /dev/radioX and
48 /dev/vtxX) and keeping track of device-node specific data.
50 4) Filehandle-specific structs containing per-filehandle data.
52 This is a rough schematic of how it all relates:
56 +-sub-device instances
60 \-filehandle instances
63 Structure of the framework
64 --------------------------
66 The framework closely resembles the driver structure: it has a v4l2_device
67 struct for the device instance data, a v4l2_subdev struct to refer to
68 sub-device instances, the video_device struct stores V4L2 device node data
69 and in the future a v4l2_fh struct will keep track of filehandle instances
70 (this is not yet implemented).
76 Each device instance is represented by a struct v4l2_device (v4l2-device.h).
77 Very simple devices can just allocate this struct, but most of the time you
78 would embed this struct inside a larger struct.
80 You must register the device instance:
82 v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev);
84 Registration will initialize the v4l2_device struct and link dev->driver_data
85 to v4l2_dev. Registration will also set v4l2_dev->name to a value derived from
86 dev (driver name followed by the bus_id, to be precise). You may change the
87 name after registration if you want.
91 v4l2_device_unregister(struct v4l2_device *v4l2_dev);
93 Unregistering will also automatically unregister all subdevs from the device.
95 Sometimes you need to iterate over all devices registered by a specific
96 driver. This is usually the case if multiple device drivers use the same
97 hardware. E.g. the ivtvfb driver is a framebuffer driver that uses the ivtv
98 hardware. The same is true for alsa drivers for example.
100 You can iterate over all registered devices as follows:
102 static int callback(struct device *dev, void *p)
104 struct v4l2_device *v4l2_dev = dev_get_drvdata(dev);
106 /* test if this device was inited */
107 if (v4l2_dev == NULL)
115 struct device_driver *drv;
118 /* Find driver 'ivtv' on the PCI bus.
119 pci_bus_type is a global. For USB busses use usb_bus_type. */
120 drv = driver_find("ivtv", &pci_bus_type);
121 /* iterate over all ivtv device instances */
122 err = driver_for_each_device(drv, NULL, p, callback);
127 Sometimes you need to keep a running counter of the device instance. This is
128 commonly used to map a device instance to an index of a module option array.
130 The recommended approach is as follows:
132 static atomic_t drv_instance = ATOMIC_INIT(0);
134 static int __devinit drv_probe(struct pci_dev *dev,
135 const struct pci_device_id *pci_id)
138 state->instance = atomic_inc_return(&drv_instance) - 1;
145 Many drivers need to communicate with sub-devices. These devices can do all
146 sort of tasks, but most commonly they handle audio and/or video muxing,
147 encoding or decoding. For webcams common sub-devices are sensors and camera
150 Usually these are I2C devices, but not necessarily. In order to provide the
151 driver with a consistent interface to these sub-devices the v4l2_subdev struct
152 (v4l2-subdev.h) was created.
154 Each sub-device driver must have a v4l2_subdev struct. This struct can be
155 stand-alone for simple sub-devices or it might be embedded in a larger struct
156 if more state information needs to be stored. Usually there is a low-level
157 device struct (e.g. i2c_client) that contains the device data as setup
158 by the kernel. It is recommended to store that pointer in the private
159 data of v4l2_subdev using v4l2_set_subdevdata(). That makes it easy to go
160 from a v4l2_subdev to the actual low-level bus-specific device data.
162 You also need a way to go from the low-level struct to v4l2_subdev. For the
163 common i2c_client struct the i2c_set_clientdata() call is used to store a
164 v4l2_subdev pointer, for other busses you may have to use other methods.
166 From the bridge driver perspective you load the sub-device module and somehow
167 obtain the v4l2_subdev pointer. For i2c devices this is easy: you call
168 i2c_get_clientdata(). For other busses something similar needs to be done.
169 Helper functions exists for sub-devices on an I2C bus that do most of this
172 Each v4l2_subdev contains function pointers that sub-device drivers can
173 implement (or leave NULL if it is not applicable). Since sub-devices can do
174 so many different things and you do not want to end up with a huge ops struct
175 of which only a handful of ops are commonly implemented, the function pointers
176 are sorted according to category and each category has its own ops struct.
178 The top-level ops struct contains pointers to the category ops structs, which
179 may be NULL if the subdev driver does not support anything from that category.
183 struct v4l2_subdev_core_ops {
184 int (*g_chip_ident)(struct v4l2_subdev *sd, struct v4l2_chip_ident *chip);
185 int (*log_status)(struct v4l2_subdev *sd);
186 int (*init)(struct v4l2_subdev *sd, u32 val);
190 struct v4l2_subdev_tuner_ops {
194 struct v4l2_subdev_audio_ops {
198 struct v4l2_subdev_video_ops {
202 struct v4l2_subdev_ops {
203 const struct v4l2_subdev_core_ops *core;
204 const struct v4l2_subdev_tuner_ops *tuner;
205 const struct v4l2_subdev_audio_ops *audio;
206 const struct v4l2_subdev_video_ops *video;
209 The core ops are common to all subdevs, the other categories are implemented
210 depending on the sub-device. E.g. a video device is unlikely to support the
211 audio ops and vice versa.
213 This setup limits the number of function pointers while still making it easy
214 to add new ops and categories.
216 A sub-device driver initializes the v4l2_subdev struct using:
218 v4l2_subdev_init(subdev, &ops);
220 Afterwards you need to initialize subdev->name with a unique name and set the
221 module owner. This is done for you if you use the i2c helper functions.
223 A device (bridge) driver needs to register the v4l2_subdev with the
226 int err = v4l2_device_register_subdev(device, subdev);
228 This can fail if the subdev module disappeared before it could be registered.
229 After this function was called successfully the subdev->dev field points to
232 You can unregister a sub-device using:
234 v4l2_device_unregister_subdev(subdev);
236 Afterwards the subdev module can be unloaded and subdev->dev == NULL.
238 You can call an ops function either directly:
240 err = subdev->ops->core->g_chip_ident(subdev, &chip);
242 but it is better and easier to use this macro:
244 err = v4l2_subdev_call(subdev, core, g_chip_ident, &chip);
246 The macro will to the right NULL pointer checks and returns -ENODEV if subdev
247 is NULL, -ENOIOCTLCMD if either subdev->core or subdev->core->g_chip_ident is
248 NULL, or the actual result of the subdev->ops->core->g_chip_ident ops.
250 It is also possible to call all or a subset of the sub-devices:
252 v4l2_device_call_all(dev, 0, core, g_chip_ident, &chip);
254 Any subdev that does not support this ops is skipped and error results are
255 ignored. If you want to check for errors use this:
257 err = v4l2_device_call_until_err(dev, 0, core, g_chip_ident, &chip);
259 Any error except -ENOIOCTLCMD will exit the loop with that error. If no
260 errors (except -ENOIOCTLCMD) occured, then 0 is returned.
262 The second argument to both calls is a group ID. If 0, then all subdevs are
263 called. If non-zero, then only those whose group ID match that value will
264 be called. Before a bridge driver registers a subdev it can set subdev->grp_id
265 to whatever value it wants (it's 0 by default). This value is owned by the
266 bridge driver and the sub-device driver will never modify or use it.
268 The group ID gives the bridge driver more control how callbacks are called.
269 For example, there may be multiple audio chips on a board, each capable of
270 changing the volume. But usually only one will actually be used when the
271 user want to change the volume. You can set the group ID for that subdev to
272 e.g. AUDIO_CONTROLLER and specify that as the group ID value when calling
273 v4l2_device_call_all(). That ensures that it will only go to the subdev
276 The advantage of using v4l2_subdev is that it is a generic struct and does
277 not contain any knowledge about the underlying hardware. So a driver might
278 contain several subdevs that use an I2C bus, but also a subdev that is
279 controlled through GPIO pins. This distinction is only relevant when setting
280 up the device, but once the subdev is registered it is completely transparent.
283 I2C sub-device drivers
284 ----------------------
286 Since these drivers are so common, special helper functions are available to
287 ease the use of these drivers (v4l2-common.h).
289 The recommended method of adding v4l2_subdev support to an I2C driver is to
290 embed the v4l2_subdev struct into the state struct that is created for each
291 I2C device instance. Very simple devices have no state struct and in that case
292 you can just create a v4l2_subdev directly.
294 A typical state struct would look like this (where 'chipname' is replaced by
295 the name of the chip):
297 struct chipname_state {
298 struct v4l2_subdev sd;
299 ... /* additional state fields */
302 Initialize the v4l2_subdev struct as follows:
304 v4l2_i2c_subdev_init(&state->sd, client, subdev_ops);
306 This function will fill in all the fields of v4l2_subdev and ensure that the
307 v4l2_subdev and i2c_client both point to one another.
309 You should also add a helper inline function to go from a v4l2_subdev pointer
310 to a chipname_state struct:
312 static inline struct chipname_state *to_state(struct v4l2_subdev *sd)
314 return container_of(sd, struct chipname_state, sd);
317 Use this to go from the v4l2_subdev struct to the i2c_client struct:
319 struct i2c_client *client = v4l2_get_subdevdata(sd);
321 And this to go from an i2c_client to a v4l2_subdev struct:
323 struct v4l2_subdev *sd = i2c_get_clientdata(client);
325 Finally you need to make a command function to make driver->command()
326 call the right subdev_ops functions:
328 static int subdev_command(struct i2c_client *client, unsigned cmd, void *arg)
330 return v4l2_subdev_command(i2c_get_clientdata(client), cmd, arg);
333 If driver->command is never used then you can leave this out. Eventually the
334 driver->command usage should be removed from v4l.
336 Make sure to call v4l2_device_unregister_subdev(sd) when the remove() callback
337 is called. This will unregister the sub-device from the bridge driver. It is
338 safe to call this even if the sub-device was never registered.
341 The bridge driver also has some helper functions it can use:
343 struct v4l2_subdev *sd = v4l2_i2c_new_subdev(adapter, "module_foo", "chipid", 0x36);
345 This loads the given module (can be NULL if no module needs to be loaded) and
346 calls i2c_new_device() with the given i2c_adapter and chip/address arguments.
347 If all goes well, then it registers the subdev with the v4l2_device. It gets
348 the v4l2_device by calling i2c_get_adapdata(adapter), so you should make sure
349 that adapdata is set to v4l2_device when you setup the i2c_adapter in your
352 You can also use v4l2_i2c_new_probed_subdev() which is very similar to
353 v4l2_i2c_new_subdev(), except that it has an array of possible I2C addresses
354 that it should probe. Internally it calls i2c_new_probed_device().
356 Both functions return NULL if something went wrong.