2 * Media Controller ancillary functions
4 * Copyright (c) 2016 Mauro Carvalho Chehab <mchehab@kernel.org>
5 * Copyright (C) 2016 Shuah Khan <shuahkh@osg.samsung.com>
6 * Copyright (C) 2006-2010 Nokia Corporation
7 * Copyright (c) 2016 Intel Corporation.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 #include <linux/module.h>
21 #include <linux/pci.h>
22 #include <linux/usb.h>
23 #include <media/media-device.h>
24 #include <media/media-entity.h>
25 #include <media/v4l2-fh.h>
26 #include <media/v4l2-mc.h>
27 #include <media/v4l2-subdev.h>
28 #include <media/media-device.h>
29 #include <media/v4l2-mc.h>
30 #include <media/videobuf2-core.h>
32 int v4l2_mc_create_media_graph(struct media_device *mdev)
35 struct media_entity *entity;
36 struct media_entity *if_vid = NULL, *if_aud = NULL;
37 struct media_entity *tuner = NULL, *decoder = NULL;
38 struct media_entity *io_v4l = NULL, *io_vbi = NULL, *io_swradio = NULL;
39 bool is_webcam = false;
46 media_device_for_each_entity(entity, mdev) {
47 switch (entity->function) {
48 case MEDIA_ENT_F_IF_VID_DECODER:
51 case MEDIA_ENT_F_IF_AUD_DECODER:
54 case MEDIA_ENT_F_TUNER:
57 case MEDIA_ENT_F_ATV_DECODER:
60 case MEDIA_ENT_F_IO_V4L:
63 case MEDIA_ENT_F_IO_VBI:
66 case MEDIA_ENT_F_IO_SWRADIO:
69 case MEDIA_ENT_F_CAM_SENSOR:
75 /* It should have at least one I/O entity */
76 if (!io_v4l && !io_vbi && !io_swradio)
80 * Here, webcams are modelled on a very simple way: the sensor is
81 * connected directly to the I/O entity. All dirty details, like
82 * scaler and crop HW are hidden. While such mapping is not enough
83 * for mc-centric hardware, it is enough for v4l2 interface centric
84 * PC-consumer's hardware.
90 media_device_for_each_entity(entity, mdev) {
91 if (entity->function != MEDIA_ENT_F_CAM_SENSOR)
93 ret = media_create_pad_link(entity, 0,
95 MEDIA_LNK_FL_ENABLED);
103 /* The device isn't a webcam. So, it should have a decoder */
107 /* Link the tuner and IF video output pads */
110 ret = media_create_pad_link(tuner, TUNER_PAD_OUTPUT,
112 IF_VID_DEC_PAD_IF_INPUT,
113 MEDIA_LNK_FL_ENABLED);
116 ret = media_create_pad_link(if_vid, IF_VID_DEC_PAD_OUT,
117 decoder, DEMOD_PAD_IF_INPUT,
118 MEDIA_LNK_FL_ENABLED);
122 ret = media_create_pad_link(tuner, TUNER_PAD_OUTPUT,
123 decoder, DEMOD_PAD_IF_INPUT,
124 MEDIA_LNK_FL_ENABLED);
130 ret = media_create_pad_link(tuner, TUNER_PAD_AUD_OUT,
132 IF_AUD_DEC_PAD_IF_INPUT,
133 MEDIA_LNK_FL_ENABLED);
142 /* Create demod to V4L, VBI and SDR radio links */
144 ret = media_create_pad_link(decoder, DEMOD_PAD_VID_OUT,
146 MEDIA_LNK_FL_ENABLED);
152 ret = media_create_pad_link(decoder, DEMOD_PAD_VID_OUT,
154 MEDIA_LNK_FL_ENABLED);
160 ret = media_create_pad_link(decoder, DEMOD_PAD_VBI_OUT,
162 MEDIA_LNK_FL_ENABLED);
167 /* Create links for the media connectors */
168 flags = MEDIA_LNK_FL_ENABLED;
169 media_device_for_each_entity(entity, mdev) {
170 switch (entity->function) {
171 case MEDIA_ENT_F_CONN_RF:
175 ret = media_create_pad_link(entity, 0, tuner,
179 case MEDIA_ENT_F_CONN_SVIDEO:
180 case MEDIA_ENT_F_CONN_COMPOSITE:
181 ret = media_create_pad_link(entity, 0, decoder,
196 EXPORT_SYMBOL_GPL(v4l2_mc_create_media_graph);
198 int v4l_enable_media_source(struct video_device *vdev)
200 struct media_device *mdev = vdev->entity.graph_obj.mdev;
203 if (!mdev || !mdev->enable_source)
205 ret = mdev->enable_source(&vdev->entity, &vdev->pipe);
210 EXPORT_SYMBOL_GPL(v4l_enable_media_source);
212 void v4l_disable_media_source(struct video_device *vdev)
214 struct media_device *mdev = vdev->entity.graph_obj.mdev;
216 if (mdev && mdev->disable_source)
217 mdev->disable_source(&vdev->entity);
219 EXPORT_SYMBOL_GPL(v4l_disable_media_source);
221 int v4l_vb2q_enable_media_source(struct vb2_queue *q)
223 struct v4l2_fh *fh = q->owner;
226 return v4l_enable_media_source(fh->vdev);
229 EXPORT_SYMBOL_GPL(v4l_vb2q_enable_media_source);
231 /* -----------------------------------------------------------------------------
232 * Pipeline power management
234 * Entities must be powered up when part of a pipeline that contains at least
235 * one open video device node.
237 * To achieve this use the entity use_count field to track the number of users.
238 * For entities corresponding to video device nodes the use_count field stores
239 * the users count of the node. For entities corresponding to subdevs the
240 * use_count field stores the total number of users of all video device nodes
243 * The v4l2_pipeline_pm_use() function must be called in the open() and
244 * close() handlers of video device nodes. It increments or decrements the use
245 * count of all subdev entities in the pipeline.
247 * To react to link management on powered pipelines, the link setup notification
248 * callback updates the use count of all entities in the source and sink sides
253 * pipeline_pm_use_count - Count the number of users of a pipeline
254 * @entity: The entity
256 * Return the total number of users of all video device nodes in the pipeline.
258 static int pipeline_pm_use_count(struct media_entity *entity,
259 struct media_entity_graph *graph)
263 media_entity_graph_walk_start(graph, entity);
265 while ((entity = media_entity_graph_walk_next(graph))) {
266 if (is_media_entity_v4l2_video_device(entity))
267 use += entity->use_count;
274 * pipeline_pm_power_one - Apply power change to an entity
275 * @entity: The entity
276 * @change: Use count change
278 * Change the entity use count by @change. If the entity is a subdev update its
279 * power state by calling the core::s_power operation when the use count goes
280 * from 0 to != 0 or from != 0 to 0.
282 * Return 0 on success or a negative error code on failure.
284 static int pipeline_pm_power_one(struct media_entity *entity, int change)
286 struct v4l2_subdev *subdev;
289 subdev = is_media_entity_v4l2_subdev(entity)
290 ? media_entity_to_v4l2_subdev(entity) : NULL;
292 if (entity->use_count == 0 && change > 0 && subdev != NULL) {
293 ret = v4l2_subdev_call(subdev, core, s_power, 1);
294 if (ret < 0 && ret != -ENOIOCTLCMD)
298 entity->use_count += change;
299 WARN_ON(entity->use_count < 0);
301 if (entity->use_count == 0 && change < 0 && subdev != NULL)
302 v4l2_subdev_call(subdev, core, s_power, 0);
308 * pipeline_pm_power - Apply power change to all entities in a pipeline
309 * @entity: The entity
310 * @change: Use count change
312 * Walk the pipeline to update the use count and the power state of all non-node
315 * Return 0 on success or a negative error code on failure.
317 static int pipeline_pm_power(struct media_entity *entity, int change,
318 struct media_entity_graph *graph)
320 struct media_entity *first = entity;
326 media_entity_graph_walk_start(graph, entity);
328 while (!ret && (entity = media_entity_graph_walk_next(graph)))
329 if (is_media_entity_v4l2_subdev(entity))
330 ret = pipeline_pm_power_one(entity, change);
335 media_entity_graph_walk_start(graph, first);
337 while ((first = media_entity_graph_walk_next(graph))
339 if (is_media_entity_v4l2_subdev(first))
340 pipeline_pm_power_one(first, -change);
345 int v4l2_pipeline_pm_use(struct media_entity *entity, int use)
347 struct media_device *mdev = entity->graph_obj.mdev;
348 int change = use ? 1 : -1;
351 mutex_lock(&mdev->graph_mutex);
353 /* Apply use count to node. */
354 entity->use_count += change;
355 WARN_ON(entity->use_count < 0);
357 /* Apply power change to connected non-nodes. */
358 ret = pipeline_pm_power(entity, change, &mdev->pm_count_walk);
360 entity->use_count -= change;
362 mutex_unlock(&mdev->graph_mutex);
366 EXPORT_SYMBOL_GPL(v4l2_pipeline_pm_use);
368 int v4l2_pipeline_link_notify(struct media_link *link, u32 flags,
369 unsigned int notification)
371 struct media_entity_graph *graph = &link->graph_obj.mdev->pm_count_walk;
372 struct media_entity *source = link->source->entity;
373 struct media_entity *sink = link->sink->entity;
378 source_use = pipeline_pm_use_count(source, graph);
379 sink_use = pipeline_pm_use_count(sink, graph);
381 if (notification == MEDIA_DEV_NOTIFY_POST_LINK_CH &&
382 !(flags & MEDIA_LNK_FL_ENABLED)) {
383 /* Powering off entities is assumed to never fail. */
384 pipeline_pm_power(source, -sink_use, graph);
385 pipeline_pm_power(sink, -source_use, graph);
389 if (notification == MEDIA_DEV_NOTIFY_PRE_LINK_CH &&
390 (flags & MEDIA_LNK_FL_ENABLED)) {
392 ret = pipeline_pm_power(source, sink_use, graph);
396 ret = pipeline_pm_power(sink, source_use, graph);
398 pipeline_pm_power(source, -sink_use, graph);
403 EXPORT_SYMBOL_GPL(v4l2_pipeline_link_notify);