blob: 96dd0f6ccd0d0ae96af84a8620e1ec07945e607d [file] [log] [blame]
Thomas Gleixner1802d0b2019-05-27 08:55:21 +02001// SPDX-License-Identifier: GPL-2.0-only
Laurent Pinchart53e269c2009-12-09 08:40:00 -03002/*
3 * Media entity
4 *
5 * Copyright (C) 2010 Nokia Corporation
6 *
7 * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
8 * Sakari Ailus <sakari.ailus@iki.fi>
Laurent Pinchart53e269c2009-12-09 08:40:00 -03009 */
10
Laurent Pinchart5c7b25b2013-06-07 12:45:11 -030011#include <linux/bitmap.h>
Daniel Scally1ed3d642022-07-07 23:47:32 +010012#include <linux/list.h>
Niklas Söderlundd295c6a2017-06-15 06:17:26 -030013#include <linux/property.h>
Laurent Pinchart53e269c2009-12-09 08:40:00 -030014#include <linux/slab.h>
15#include <media/media-entity.h>
Laurent Pinchart503c3d822010-03-07 15:04:59 -030016#include <media/media-device.h>
Laurent Pinchart53e269c2009-12-09 08:40:00 -030017
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030018static inline const char *intf_type(struct media_interface *intf)
19{
20 switch (intf->type) {
21 case MEDIA_INTF_T_DVB_FE:
Shuah Khan66c1db12016-03-04 18:14:05 -030022 return "dvb-frontend";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030023 case MEDIA_INTF_T_DVB_DEMUX:
Shuah Khan66c1db12016-03-04 18:14:05 -030024 return "dvb-demux";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030025 case MEDIA_INTF_T_DVB_DVR:
Shuah Khan66c1db12016-03-04 18:14:05 -030026 return "dvb-dvr";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030027 case MEDIA_INTF_T_DVB_CA:
Shuah Khan66c1db12016-03-04 18:14:05 -030028 return "dvb-ca";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030029 case MEDIA_INTF_T_DVB_NET:
Shuah Khan66c1db12016-03-04 18:14:05 -030030 return "dvb-net";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030031 case MEDIA_INTF_T_V4L_VIDEO:
Shuah Khan66c1db12016-03-04 18:14:05 -030032 return "v4l-video";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030033 case MEDIA_INTF_T_V4L_VBI:
Shuah Khan66c1db12016-03-04 18:14:05 -030034 return "v4l-vbi";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030035 case MEDIA_INTF_T_V4L_RADIO:
Shuah Khan66c1db12016-03-04 18:14:05 -030036 return "v4l-radio";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030037 case MEDIA_INTF_T_V4L_SUBDEV:
Shuah Khan66c1db12016-03-04 18:14:05 -030038 return "v4l-subdev";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030039 case MEDIA_INTF_T_V4L_SWRADIO:
Shuah Khan66c1db12016-03-04 18:14:05 -030040 return "v4l-swradio";
Nick Dyerb2fe22d2016-07-18 18:10:30 -030041 case MEDIA_INTF_T_V4L_TOUCH:
42 return "v4l-touch";
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -030043 default:
44 return "unknown-intf";
45 }
46};
47
Daniel Scally9d0c23b2022-03-02 22:03:02 +000048static inline const char *link_type_name(struct media_link *link)
49{
50 switch (link->flags & MEDIA_LNK_FL_LINK_TYPE) {
51 case MEDIA_LNK_FL_DATA_LINK:
52 return "data";
53 case MEDIA_LNK_FL_INTERFACE_LINK:
54 return "interface";
55 case MEDIA_LNK_FL_ANCILLARY_LINK:
56 return "ancillary";
57 default:
58 return "unknown";
59 }
60}
61
Laurent Pinchart49b38942022-08-31 16:13:29 +020062__must_check int media_entity_enum_init(struct media_entity_enum *ent_enum,
63 struct media_device *mdev)
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020064{
Laurent Pinchart49b38942022-08-31 16:13:29 +020065 int idx_max;
66
67 idx_max = ALIGN(mdev->entity_internal_idx_max + 1, BITS_PER_LONG);
Christophe JAILLETce560ee2021-12-01 23:19:40 +010068 ent_enum->bmap = bitmap_zalloc(idx_max, GFP_KERNEL);
Sakari Ailus030e89e2015-12-16 11:32:36 -020069 if (!ent_enum->bmap)
70 return -ENOMEM;
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020071
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020072 ent_enum->idx_max = idx_max;
73
74 return 0;
75}
Laurent Pinchart49b38942022-08-31 16:13:29 +020076EXPORT_SYMBOL_GPL(media_entity_enum_init);
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020077
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020078void media_entity_enum_cleanup(struct media_entity_enum *ent_enum)
79{
Christophe JAILLETce560ee2021-12-01 23:19:40 +010080 bitmap_free(ent_enum->bmap);
Sakari Ailusc8d54cd2015-12-16 11:44:32 -020081}
82EXPORT_SYMBOL_GPL(media_entity_enum_cleanup);
83
84/**
Mauro Carvalho Chehab1fc25d32015-12-11 12:14:58 -020085 * dev_dbg_obj - Prints in debug mode a change on some object
86 *
87 * @event_name: Name of the event to report. Could be __func__
88 * @gobj: Pointer to the object
89 *
90 * Enabled only if DEBUG or CONFIG_DYNAMIC_DEBUG. Otherwise, it
91 * won't produce any code.
92 */
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -030093static void dev_dbg_obj(const char *event_name, struct media_gobj *gobj)
94{
95#if defined(DEBUG) || defined (CONFIG_DYNAMIC_DEBUG)
96 switch (media_type(gobj)) {
97 case MEDIA_GRAPH_ENTITY:
98 dev_dbg(gobj->mdev->dev,
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -020099 "%s id %u: entity '%s'\n",
100 event_name, media_id(gobj),
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300101 gobj_to_entity(gobj)->name);
102 break;
103 case MEDIA_GRAPH_LINK:
104 {
105 struct media_link *link = gobj_to_link(gobj);
106
107 dev_dbg(gobj->mdev->dev,
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -0200108 "%s id %u: %s link id %u ==> id %u\n",
Daniel Scally9d0c23b2022-03-02 22:03:02 +0000109 event_name, media_id(gobj), link_type_name(link),
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -0200110 media_id(link->gobj0),
111 media_id(link->gobj1));
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300112 break;
113 }
114 case MEDIA_GRAPH_PAD:
115 {
116 struct media_pad *pad = gobj_to_pad(gobj);
117
118 dev_dbg(gobj->mdev->dev,
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -0200119 "%s id %u: %s%spad '%s':%d\n",
120 event_name, media_id(gobj),
121 pad->flags & MEDIA_PAD_FL_SINK ? "sink " : "",
Mauro Carvalho Chehab6c24d462015-08-21 18:26:42 -0300122 pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "",
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300123 pad->entity->name, pad->index);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -0300124 break;
125 }
126 case MEDIA_GRAPH_INTF_DEVNODE:
127 {
128 struct media_interface *intf = gobj_to_intf(gobj);
129 struct media_intf_devnode *devnode = intf_to_devnode(intf);
130
131 dev_dbg(gobj->mdev->dev,
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -0200132 "%s id %u: intf_devnode %s - major: %d, minor: %d\n",
133 event_name, media_id(gobj),
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -0300134 intf_type(intf),
135 devnode->major, devnode->minor);
136 break;
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300137 }
138 }
139#endif
140}
141
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -0200142void media_gobj_create(struct media_device *mdev,
Mauro Carvalho Chehabec6e4c92015-08-25 10:28:36 -0300143 enum media_gobj_type type,
144 struct media_gobj *gobj)
145{
Mauro Carvalho Chehab8f6d3682015-08-19 20:18:35 -0300146 BUG_ON(!mdev);
147
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300148 gobj->mdev = mdev;
149
Mauro Carvalho Chehabbfab2aac2015-08-14 12:47:48 -0300150 /* Create a per-type unique object ID */
Mauro Carvalho Chehab05b3b772015-12-16 14:28:01 -0200151 gobj->id = media_gobj_gen_id(type, ++mdev->id);
152
Mauro Carvalho Chehabbfab2aac2015-08-14 12:47:48 -0300153 switch (type) {
154 case MEDIA_GRAPH_ENTITY:
Mauro Carvalho Chehab05bfa9f2015-08-23 07:51:33 -0300155 list_add_tail(&gobj->list, &mdev->entities);
Mauro Carvalho Chehabbfab2aac2015-08-14 12:47:48 -0300156 break;
Mauro Carvalho Chehab18710dc2015-08-14 12:50:08 -0300157 case MEDIA_GRAPH_PAD:
Mauro Carvalho Chehab9155d852015-08-23 08:00:33 -0300158 list_add_tail(&gobj->list, &mdev->pads);
Mauro Carvalho Chehab18710dc2015-08-14 12:50:08 -0300159 break;
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -0300160 case MEDIA_GRAPH_LINK:
Mauro Carvalho Chehab9155d852015-08-23 08:00:33 -0300161 list_add_tail(&gobj->list, &mdev->links);
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -0300162 break;
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -0300163 case MEDIA_GRAPH_INTF_DEVNODE:
Mauro Carvalho Chehab9155d852015-08-23 08:00:33 -0300164 list_add_tail(&gobj->list, &mdev->interfaces);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -0300165 break;
Mauro Carvalho Chehabbfab2aac2015-08-14 12:47:48 -0300166 }
Mauro Carvalho Chehab2521fda2015-08-23 09:40:26 -0300167
168 mdev->topology_version++;
169
Mauro Carvalho Chehab39a956c2015-08-13 14:42:42 -0300170 dev_dbg_obj(__func__, gobj);
Mauro Carvalho Chehabec6e4c92015-08-25 10:28:36 -0300171}
172
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -0200173void media_gobj_destroy(struct media_gobj *gobj)
Mauro Carvalho Chehabec6e4c92015-08-25 10:28:36 -0300174{
Max Kellermann67537432016-08-09 23:32:57 +0200175 /* Do nothing if the object is not linked. */
176 if (gobj->mdev == NULL)
177 return;
178
Helen Fornazier8d1d3d02017-04-06 16:25:15 -0300179 dev_dbg_obj(__func__, gobj);
180
Mauro Carvalho Chehab2521fda2015-08-23 09:40:26 -0300181 gobj->mdev->topology_version++;
182
Mauro Carvalho Chehab9155d852015-08-23 08:00:33 -0300183 /* Remove the object from mdev list */
184 list_del(&gobj->list);
Max Kellermann67537432016-08-09 23:32:57 +0200185
186 gobj->mdev = NULL;
Mauro Carvalho Chehabec6e4c92015-08-25 10:28:36 -0300187}
188
Sakari Ailus885ca802015-10-05 12:45:29 -0300189/*
190 * TODO: Get rid of this.
191 */
192#define MEDIA_ENTITY_MAX_PADS 512
193
Mauro Carvalho Chehab1fc25d32015-12-11 12:14:58 -0200194int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
195 struct media_pad *pads)
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300196{
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300197 struct media_device *mdev = entity->graph_obj.mdev;
Jacopo Mondi8db465f2022-08-31 16:13:28 +0200198 struct media_pad *iter;
199 unsigned int i = 0;
Sakari Ailusdeb866f92023-04-25 12:30:45 +0300200 int ret = 0;
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300201
Sakari Ailus885ca802015-10-05 12:45:29 -0300202 if (num_pads >= MEDIA_ENTITY_MAX_PADS)
203 return -E2BIG;
204
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300205 entity->num_pads = num_pads;
206 entity->pads = pads;
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300207
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300208 if (mdev)
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -0300209 mutex_lock(&mdev->graph_mutex);
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300210
Jacopo Mondi8db465f2022-08-31 16:13:28 +0200211 media_entity_for_each_pad(entity, iter) {
212 iter->entity = entity;
213 iter->index = i++;
Sakari Ailusdeb866f92023-04-25 12:30:45 +0300214
215 if (hweight32(iter->flags & (MEDIA_PAD_FL_SINK |
216 MEDIA_PAD_FL_SOURCE)) != 1) {
217 ret = -EINVAL;
218 break;
219 }
220
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300221 if (mdev)
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -0200222 media_gobj_create(mdev, MEDIA_GRAPH_PAD,
Jacopo Mondi8db465f2022-08-31 16:13:28 +0200223 &iter->graph_obj);
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300224 }
225
Sakari Ailusdeb866f92023-04-25 12:30:45 +0300226 if (ret && mdev) {
227 media_entity_for_each_pad(entity, iter)
228 media_gobj_destroy(&iter->graph_obj);
229 }
230
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300231 if (mdev)
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -0300232 mutex_unlock(&mdev->graph_mutex);
Javier Martinez Canillasdb141a32015-09-08 14:10:56 -0300233
Sakari Ailusdeb866f92023-04-25 12:30:45 +0300234 return ret;
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300235}
Mauro Carvalho Chehabab22e772015-12-11 07:44:40 -0200236EXPORT_SYMBOL_GPL(media_entity_pads_init);
Laurent Pinchart53e269c2009-12-09 08:40:00 -0300237
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300238/* -----------------------------------------------------------------------------
239 * Graph traversal
240 */
241
Laurent Pinchart1ec06122022-01-14 01:26:26 +0100242/**
243 * media_entity_has_pad_interdep - Check interdependency between two pads
244 *
245 * @entity: The entity
246 * @pad0: The first pad index
247 * @pad1: The second pad index
248 *
Laurent Pinchartae219872022-08-31 16:13:37 +0200249 * This function checks the interdependency inside the entity between @pad0
250 * and @pad1. If two pads are interdependent they are part of the same pipeline
251 * and enabling one of the pads means that the other pad will become "locked"
252 * and doesn't allow configuration changes.
253 *
Tomi Valkeinen5b4f9a72022-08-31 16:13:38 +0200254 * This function uses the &media_entity_operations.has_pad_interdep() operation
255 * to check the dependency inside the entity between @pad0 and @pad1. If the
256 * has_pad_interdep operation is not implemented, all pads of the entity are
257 * considered to be interdependent.
Laurent Pinchart1ec06122022-01-14 01:26:26 +0100258 *
259 * One of @pad0 and @pad1 must be a sink pad and the other one a source pad.
260 * The function returns false if both pads are sinks or sources.
261 *
262 * The caller must hold entity->graph_obj.mdev->mutex.
263 *
264 * Return: true if the pads are connected internally and false otherwise.
Laurent Pinchartae219872022-08-31 16:13:37 +0200265 */
266static bool media_entity_has_pad_interdep(struct media_entity *entity,
267 unsigned int pad0, unsigned int pad1)
268{
269 if (pad0 >= entity->num_pads || pad1 >= entity->num_pads)
270 return false;
271
272 if (entity->pads[pad0].flags & entity->pads[pad1].flags &
273 (MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_SOURCE))
274 return false;
275
Tomi Valkeinen5b4f9a72022-08-31 16:13:38 +0200276 if (!entity->ops || !entity->ops->has_pad_interdep)
277 return true;
278
279 return entity->ops->has_pad_interdep(entity, pad0, pad1);
Laurent Pinchartae219872022-08-31 16:13:37 +0200280}
281
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300282static struct media_entity *
283media_entity_other(struct media_entity *entity, struct media_link *link)
284{
285 if (link->source->entity == entity)
286 return link->sink->entity;
287 else
288 return link->source->entity;
289}
290
291/* push an entity to traversal stack */
Sakari Ailus20b85222016-11-21 14:48:30 -0200292static void stack_push(struct media_graph *graph,
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300293 struct media_entity *entity)
294{
295 if (graph->top == MEDIA_ENTITY_ENUM_MAX_DEPTH - 1) {
296 WARN_ON(1);
297 return;
298 }
299 graph->top++;
Javier Martinez Canillas313895f2015-12-11 15:16:36 -0200300 graph->stack[graph->top].link = entity->links.next;
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300301 graph->stack[graph->top].entity = entity;
302}
303
Sakari Ailus20b85222016-11-21 14:48:30 -0200304static struct media_entity *stack_pop(struct media_graph *graph)
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300305{
306 struct media_entity *entity;
307
308 entity = graph->stack[graph->top].entity;
309 graph->top--;
310
311 return entity;
312}
313
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300314#define link_top(en) ((en)->stack[(en)->top].link)
315#define stack_top(en) ((en)->stack[(en)->top].entity)
316
Sakari Ailuse03d2202015-12-16 11:32:22 -0200317/**
Sakari Ailus20b85222016-11-21 14:48:30 -0200318 * media_graph_walk_init - Allocate resources for graph walk
Sakari Ailuse03d2202015-12-16 11:32:22 -0200319 * @graph: Media graph structure that will be used to walk the graph
320 * @mdev: Media device
321 *
322 * Reserve resources for graph walk in media device's current
323 * state. The memory must be released using
Miaoqian Lin25ba6442022-12-17 15:31:13 +0100324 * media_graph_walk_cleanup().
Sakari Ailuse03d2202015-12-16 11:32:22 -0200325 *
326 * Returns error on failure, zero on success.
327 */
Sakari Ailus20b85222016-11-21 14:48:30 -0200328__must_check int media_graph_walk_init(
329 struct media_graph *graph, struct media_device *mdev)
Sakari Ailuse03d2202015-12-16 11:32:22 -0200330{
Sakari Ailus29d8da02015-12-16 11:32:28 -0200331 return media_entity_enum_init(&graph->ent_enum, mdev);
Sakari Ailuse03d2202015-12-16 11:32:22 -0200332}
Sakari Ailus20b85222016-11-21 14:48:30 -0200333EXPORT_SYMBOL_GPL(media_graph_walk_init);
Sakari Ailuse03d2202015-12-16 11:32:22 -0200334
335/**
Sakari Ailus20b85222016-11-21 14:48:30 -0200336 * media_graph_walk_cleanup - Release resources related to graph walking
Sakari Ailuse03d2202015-12-16 11:32:22 -0200337 * @graph: Media graph structure that was used to walk the graph
338 */
Sakari Ailus20b85222016-11-21 14:48:30 -0200339void media_graph_walk_cleanup(struct media_graph *graph)
Sakari Ailuse03d2202015-12-16 11:32:22 -0200340{
Sakari Ailus29d8da02015-12-16 11:32:28 -0200341 media_entity_enum_cleanup(&graph->ent_enum);
Sakari Ailuse03d2202015-12-16 11:32:22 -0200342}
Sakari Ailus20b85222016-11-21 14:48:30 -0200343EXPORT_SYMBOL_GPL(media_graph_walk_cleanup);
Sakari Ailuse03d2202015-12-16 11:32:22 -0200344
Sakari Ailus20b85222016-11-21 14:48:30 -0200345void media_graph_walk_start(struct media_graph *graph,
346 struct media_entity *entity)
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300347{
Sakari Ailus29d8da02015-12-16 11:32:28 -0200348 media_entity_enum_zero(&graph->ent_enum);
349 media_entity_enum_set(&graph->ent_enum, entity);
350
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300351 graph->top = 0;
352 graph->stack[graph->top].entity = NULL;
353 stack_push(graph, entity);
Sakari Ailusaa79a842016-07-20 12:39:02 -0300354 dev_dbg(entity->graph_obj.mdev->dev,
355 "begin graph walk at '%s'\n", entity->name);
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300356}
Sakari Ailus20b85222016-11-21 14:48:30 -0200357EXPORT_SYMBOL_GPL(media_graph_walk_start);
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300358
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300359static void media_graph_walk_iter(struct media_graph *graph)
360{
361 struct media_entity *entity = stack_top(graph);
362 struct media_link *link;
363 struct media_entity *next;
364
365 link = list_entry(link_top(graph), typeof(*link), list);
366
Daniel Scallyaf3ed782022-03-02 22:03:00 +0000367 /* If the link is not a data link, don't follow it */
368 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) != MEDIA_LNK_FL_DATA_LINK) {
369 link_top(graph) = link_top(graph)->next;
370 return;
371 }
372
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300373 /* The link is not enabled so we do not follow. */
374 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
375 link_top(graph) = link_top(graph)->next;
Sakari Ailusaa79a842016-07-20 12:39:02 -0300376 dev_dbg(entity->graph_obj.mdev->dev,
377 "walk: skipping disabled link '%s':%u -> '%s':%u\n",
378 link->source->entity->name, link->source->index,
379 link->sink->entity->name, link->sink->index);
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300380 return;
381 }
382
Sebastian Frickeb07006f2021-04-17 15:34:38 +0200383 /* Get the entity at the other end of the link. */
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300384 next = media_entity_other(entity, link);
385
386 /* Has the entity already been visited? */
387 if (media_entity_enum_test_and_set(&graph->ent_enum, next)) {
388 link_top(graph) = link_top(graph)->next;
Sakari Ailusaa79a842016-07-20 12:39:02 -0300389 dev_dbg(entity->graph_obj.mdev->dev,
390 "walk: skipping entity '%s' (already seen)\n",
391 next->name);
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300392 return;
393 }
394
395 /* Push the new entity to stack and start over. */
396 link_top(graph) = link_top(graph)->next;
397 stack_push(graph, next);
Sakari Ailusaa79a842016-07-20 12:39:02 -0300398 dev_dbg(entity->graph_obj.mdev->dev, "walk: pushing '%s' on stack\n",
399 next->name);
Sakari Ailus4ebddb72021-03-12 10:05:44 +0100400 lockdep_assert_held(&entity->graph_obj.mdev->graph_mutex);
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300401}
402
Sakari Ailus20b85222016-11-21 14:48:30 -0200403struct media_entity *media_graph_walk_next(struct media_graph *graph)
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300404{
Sakari Ailusaa79a842016-07-20 12:39:02 -0300405 struct media_entity *entity;
406
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300407 if (stack_top(graph) == NULL)
408 return NULL;
409
410 /*
411 * Depth first search. Push entity to stack and continue from
412 * top of the stack until no more entities on the level can be
413 * found.
414 */
Sakari Ailus5b1f8322016-07-20 12:31:39 -0300415 while (link_top(graph) != &stack_top(graph)->links)
416 media_graph_walk_iter(graph);
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300417
Sakari Ailusaa79a842016-07-20 12:39:02 -0300418 entity = stack_pop(graph);
419 dev_dbg(entity->graph_obj.mdev->dev,
420 "walk: returning entity '%s'\n", entity->name);
421
422 return entity;
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300423}
Sakari Ailus20b85222016-11-21 14:48:30 -0200424EXPORT_SYMBOL_GPL(media_graph_walk_next);
Sakari Ailusa5ccc482010-03-07 16:14:14 -0300425
426/* -----------------------------------------------------------------------------
Laurent Pincharte02188c2010-08-25 09:00:41 -0300427 * Pipeline management
428 */
429
Laurent Pinchartae219872022-08-31 16:13:37 +0200430/*
431 * The pipeline traversal stack stores pads that are reached during graph
432 * traversal, with a list of links to be visited to continue the traversal.
433 * When a new pad is reached, an entry is pushed on the top of the stack and
434 * points to the incoming pad and the first link of the entity.
435 *
436 * To find further pads in the pipeline, the traversal algorithm follows
437 * internal pad dependencies in the entity, and then links in the graph. It
438 * does so by iterating over all links of the entity, and following enabled
439 * links that originate from a pad that is internally connected to the incoming
440 * pad, as reported by the media_entity_has_pad_interdep() function.
441 */
442
443/**
444 * struct media_pipeline_walk_entry - Entry in the pipeline traversal stack
445 *
446 * @pad: The media pad being visited
447 * @links: Links left to be visited
448 */
449struct media_pipeline_walk_entry {
450 struct media_pad *pad;
451 struct list_head *links;
452};
453
454/**
455 * struct media_pipeline_walk - State used by the media pipeline traversal
456 * algorithm
457 *
458 * @mdev: The media device
459 * @stack: Depth-first search stack
460 * @stack.size: Number of allocated entries in @stack.entries
461 * @stack.top: Index of the top stack entry (-1 if the stack is empty)
462 * @stack.entries: Stack entries
463 */
464struct media_pipeline_walk {
465 struct media_device *mdev;
466
467 struct {
468 unsigned int size;
469 int top;
470 struct media_pipeline_walk_entry *entries;
471 } stack;
472};
473
474#define MEDIA_PIPELINE_STACK_GROW_STEP 16
475
476static struct media_pipeline_walk_entry *
477media_pipeline_walk_top(struct media_pipeline_walk *walk)
478{
479 return &walk->stack.entries[walk->stack.top];
480}
481
482static bool media_pipeline_walk_empty(struct media_pipeline_walk *walk)
483{
484 return walk->stack.top == -1;
485}
486
487/* Increase the stack size by MEDIA_PIPELINE_STACK_GROW_STEP elements. */
488static int media_pipeline_walk_resize(struct media_pipeline_walk *walk)
489{
490 struct media_pipeline_walk_entry *entries;
491 unsigned int new_size;
492
493 /* Safety check, to avoid stack overflows in case of bugs. */
494 if (walk->stack.size >= 256)
495 return -E2BIG;
496
497 new_size = walk->stack.size + MEDIA_PIPELINE_STACK_GROW_STEP;
498
499 entries = krealloc(walk->stack.entries,
500 new_size * sizeof(*walk->stack.entries),
501 GFP_KERNEL);
502 if (!entries)
503 return -ENOMEM;
504
505 walk->stack.entries = entries;
506 walk->stack.size = new_size;
507
508 return 0;
509}
510
511/* Push a new entry on the stack. */
512static int media_pipeline_walk_push(struct media_pipeline_walk *walk,
513 struct media_pad *pad)
514{
515 struct media_pipeline_walk_entry *entry;
516 int ret;
517
518 if (walk->stack.top + 1 >= walk->stack.size) {
519 ret = media_pipeline_walk_resize(walk);
520 if (ret)
521 return ret;
522 }
523
524 walk->stack.top++;
525 entry = media_pipeline_walk_top(walk);
526 entry->pad = pad;
527 entry->links = pad->entity->links.next;
528
529 dev_dbg(walk->mdev->dev,
530 "media pipeline: pushed entry %u: '%s':%u\n",
531 walk->stack.top, pad->entity->name, pad->index);
532
533 return 0;
534}
535
536/*
537 * Move the top entry link cursor to the next link. If all links of the entry
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200538 * have been visited, pop the entry itself. Return true if the entry has been
539 * popped.
Laurent Pinchartae219872022-08-31 16:13:37 +0200540 */
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200541static bool media_pipeline_walk_pop(struct media_pipeline_walk *walk)
Laurent Pinchartae219872022-08-31 16:13:37 +0200542{
543 struct media_pipeline_walk_entry *entry;
544
545 if (WARN_ON(walk->stack.top < 0))
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200546 return false;
Laurent Pinchartae219872022-08-31 16:13:37 +0200547
548 entry = media_pipeline_walk_top(walk);
549
550 if (entry->links->next == &entry->pad->entity->links) {
551 dev_dbg(walk->mdev->dev,
552 "media pipeline: entry %u has no more links, popping\n",
553 walk->stack.top);
554
555 walk->stack.top--;
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200556 return true;
Laurent Pinchartae219872022-08-31 16:13:37 +0200557 }
558
559 entry->links = entry->links->next;
560
561 dev_dbg(walk->mdev->dev,
562 "media pipeline: moved entry %u to next link\n",
563 walk->stack.top);
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200564
565 return false;
Laurent Pinchartae219872022-08-31 16:13:37 +0200566}
567
568/* Free all memory allocated while walking the pipeline. */
569static void media_pipeline_walk_destroy(struct media_pipeline_walk *walk)
570{
571 kfree(walk->stack.entries);
572}
573
574/* Add a pad to the pipeline and push it to the stack. */
575static int media_pipeline_add_pad(struct media_pipeline *pipe,
576 struct media_pipeline_walk *walk,
577 struct media_pad *pad)
578{
579 struct media_pipeline_pad *ppad;
580
581 list_for_each_entry(ppad, &pipe->pads, list) {
582 if (ppad->pad == pad) {
583 dev_dbg(pad->graph_obj.mdev->dev,
584 "media pipeline: already contains pad '%s':%u\n",
585 pad->entity->name, pad->index);
586 return 0;
587 }
588 }
589
590 ppad = kzalloc(sizeof(*ppad), GFP_KERNEL);
591 if (!ppad)
592 return -ENOMEM;
593
594 ppad->pipe = pipe;
595 ppad->pad = pad;
596
597 list_add_tail(&ppad->list, &pipe->pads);
598
599 dev_dbg(pad->graph_obj.mdev->dev,
600 "media pipeline: added pad '%s':%u\n",
601 pad->entity->name, pad->index);
602
603 return media_pipeline_walk_push(walk, pad);
604}
605
606/* Explore the next link of the entity at the top of the stack. */
607static int media_pipeline_explore_next_link(struct media_pipeline *pipe,
608 struct media_pipeline_walk *walk)
609{
610 struct media_pipeline_walk_entry *entry = media_pipeline_walk_top(walk);
Laurent Pinchart9ec91092024-01-15 00:30:02 +0200611 struct media_pad *origin;
Laurent Pinchartae219872022-08-31 16:13:37 +0200612 struct media_link *link;
613 struct media_pad *local;
614 struct media_pad *remote;
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200615 bool last_link;
Laurent Pinchartae219872022-08-31 16:13:37 +0200616 int ret;
617
Laurent Pinchart9ec91092024-01-15 00:30:02 +0200618 origin = entry->pad;
Laurent Pinchartae219872022-08-31 16:13:37 +0200619 link = list_entry(entry->links, typeof(*link), list);
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200620 last_link = media_pipeline_walk_pop(walk);
Laurent Pinchartae219872022-08-31 16:13:37 +0200621
Tomi Valkeinen8a9d4202024-03-18 11:50:59 +0200622 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) != MEDIA_LNK_FL_DATA_LINK) {
623 dev_dbg(walk->mdev->dev,
624 "media pipeline: skipping link (not data-link)\n");
625 return 0;
626 }
627
Laurent Pinchartae219872022-08-31 16:13:37 +0200628 dev_dbg(walk->mdev->dev,
629 "media pipeline: exploring link '%s':%u -> '%s':%u\n",
630 link->source->entity->name, link->source->index,
631 link->sink->entity->name, link->sink->index);
632
Laurent Pinchartae219872022-08-31 16:13:37 +0200633 /* Get the local pad and remote pad. */
Laurent Pinchart9ec91092024-01-15 00:30:02 +0200634 if (link->source->entity == origin->entity) {
Laurent Pinchartae219872022-08-31 16:13:37 +0200635 local = link->source;
636 remote = link->sink;
637 } else {
638 local = link->sink;
639 remote = link->source;
640 }
641
642 /*
643 * Skip links that originate from a different pad than the incoming pad
644 * that is not connected internally in the entity to the incoming pad.
645 */
Laurent Pinchart9ec91092024-01-15 00:30:02 +0200646 if (origin != local &&
647 !media_entity_has_pad_interdep(origin->entity, origin->index,
648 local->index)) {
Laurent Pinchartae219872022-08-31 16:13:37 +0200649 dev_dbg(walk->mdev->dev,
650 "media pipeline: skipping link (no route)\n");
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200651 goto done;
Laurent Pinchartae219872022-08-31 16:13:37 +0200652 }
653
654 /*
Laurent Pinchart78f0daa02024-01-14 15:55:40 +0200655 * Add the local pad of the link to the pipeline and push it to the
656 * stack, if not already present.
Laurent Pinchartae219872022-08-31 16:13:37 +0200657 */
658 ret = media_pipeline_add_pad(pipe, walk, local);
659 if (ret)
660 return ret;
661
Laurent Pinchart78f0daa02024-01-14 15:55:40 +0200662 /* Similarly, add the remote pad, but only if the link is enabled. */
663 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
664 dev_dbg(walk->mdev->dev,
665 "media pipeline: skipping link (disabled)\n");
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200666 goto done;
Laurent Pinchart78f0daa02024-01-14 15:55:40 +0200667 }
668
Laurent Pinchartae219872022-08-31 16:13:37 +0200669 ret = media_pipeline_add_pad(pipe, walk, remote);
670 if (ret)
671 return ret;
672
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200673done:
674 /*
675 * If we're done iterating over links, iterate over pads of the entity.
676 * This is necessary to discover pads that are not connected with any
677 * link. Those are dead ends from a pipeline exploration point of view,
678 * but are still part of the pipeline and need to be added to enable
679 * proper validation.
680 */
681 if (!last_link)
682 return 0;
683
684 dev_dbg(walk->mdev->dev,
685 "media pipeline: adding unconnected pads of '%s'\n",
686 local->entity->name);
687
688 media_entity_for_each_pad(origin->entity, local) {
689 /*
690 * Skip the origin pad (already handled), pad that have links
691 * (already discovered through iterating over links) and pads
692 * not internally connected.
693 */
694 if (origin == local || !local->num_links ||
695 !media_entity_has_pad_interdep(origin->entity, origin->index,
696 local->index))
697 continue;
698
699 ret = media_pipeline_add_pad(pipe, walk, local);
700 if (ret)
701 return ret;
702 }
703
Laurent Pinchartae219872022-08-31 16:13:37 +0200704 return 0;
705}
706
707static void media_pipeline_cleanup(struct media_pipeline *pipe)
708{
709 while (!list_empty(&pipe->pads)) {
710 struct media_pipeline_pad *ppad;
711
712 ppad = list_first_entry(&pipe->pads, typeof(*ppad), list);
713 list_del(&ppad->list);
714 kfree(ppad);
715 }
716}
717
718static int media_pipeline_populate(struct media_pipeline *pipe,
719 struct media_pad *pad)
720{
721 struct media_pipeline_walk walk = { };
722 struct media_pipeline_pad *ppad;
723 int ret;
724
725 /*
726 * Populate the media pipeline by walking the media graph, starting
727 * from @pad.
728 */
729 INIT_LIST_HEAD(&pipe->pads);
730 pipe->mdev = pad->graph_obj.mdev;
731
732 walk.mdev = pipe->mdev;
733 walk.stack.top = -1;
734 ret = media_pipeline_add_pad(pipe, &walk, pad);
735 if (ret)
736 goto done;
737
738 /*
739 * Use a depth-first search algorithm: as long as the stack is not
740 * empty, explore the next link of the top entry. The
741 * media_pipeline_explore_next_link() function will either move to the
742 * next link, pop the entry if fully visited, or add new entries on
743 * top.
744 */
745 while (!media_pipeline_walk_empty(&walk)) {
746 ret = media_pipeline_explore_next_link(pipe, &walk);
747 if (ret)
748 goto done;
749 }
750
751 dev_dbg(pad->graph_obj.mdev->dev,
752 "media pipeline populated, found pads:\n");
753
754 list_for_each_entry(ppad, &pipe->pads, list)
755 dev_dbg(pad->graph_obj.mdev->dev, "- '%s':%u\n",
756 ppad->pad->entity->name, ppad->pad->index);
757
758 WARN_ON(walk.stack.top != -1);
759
760 ret = 0;
761
762done:
763 media_pipeline_walk_destroy(&walk);
764
765 if (ret)
766 media_pipeline_cleanup(pipe);
767
768 return ret;
769}
770
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200771__must_check int __media_pipeline_start(struct media_pad *pad,
Sakari Ailus20b85222016-11-21 14:48:30 -0200772 struct media_pipeline *pipe)
Laurent Pincharte02188c2010-08-25 09:00:41 -0300773{
Laurent Pincharta967a3a2022-12-12 14:25:04 +0100774 struct media_device *mdev = pad->graph_obj.mdev;
Laurent Pinchartae219872022-08-31 16:13:37 +0200775 struct media_pipeline_pad *err_ppad;
776 struct media_pipeline_pad *ppad;
Sakari Ailusaf88be32012-01-11 06:25:15 -0300777 int ret;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300778
Laurent Pinchartae219872022-08-31 16:13:37 +0200779 lockdep_assert_held(&mdev->graph_mutex);
780
781 /*
Laurent Pinchartb5163542022-12-12 14:25:05 +0100782 * If the pad is already part of a pipeline, that pipeline must be the
783 * same as the pipe given to media_pipeline_start().
Laurent Pinchartae219872022-08-31 16:13:37 +0200784 */
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200785 if (WARN_ON(pad->pipe && pad->pipe != pipe))
Laurent Pinchartae219872022-08-31 16:13:37 +0200786 return -EINVAL;
787
788 /*
789 * If the pipeline has already been started, it is guaranteed to be
790 * valid, so just increase the start count.
791 */
Tomi Valkeinenb7319e22022-08-31 16:13:27 +0200792 if (pipe->start_count) {
793 pipe->start_count++;
Laurent Pinchart3056a8e2022-01-13 17:00:42 +0200794 return 0;
Sakari Ailus106b9902015-12-16 15:32:23 +0200795 }
796
Laurent Pinchartae219872022-08-31 16:13:37 +0200797 /*
798 * Populate the pipeline. This populates the media_pipeline pads list
799 * with media_pipeline_pad instances for each pad found during graph
800 * walk.
801 */
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200802 ret = media_pipeline_populate(pipe, pad);
Laurent Pinchart3056a8e2022-01-13 17:00:42 +0200803 if (ret)
804 return ret;
805
Laurent Pinchartae219872022-08-31 16:13:37 +0200806 /*
807 * Now that all the pads in the pipeline have been gathered, perform
808 * the validation steps.
809 */
Laurent Pincharte02188c2010-08-25 09:00:41 -0300810
Laurent Pinchartae219872022-08-31 16:13:37 +0200811 list_for_each_entry(ppad, &pipe->pads, list) {
812 struct media_pad *pad = ppad->pad;
813 struct media_entity *entity = pad->entity;
814 bool has_enabled_link = false;
Laurent Pinchartae219872022-08-31 16:13:37 +0200815 struct media_link *link;
Sakari Ailusaf88be32012-01-11 06:25:15 -0300816
Laurent Pinchartae219872022-08-31 16:13:37 +0200817 dev_dbg(mdev->dev, "Validating pad '%s':%u\n", pad->entity->name,
818 pad->index);
819
820 /*
821 * 1. Ensure that the pad doesn't already belong to a different
822 * pipeline.
823 */
824 if (pad->pipe) {
825 dev_dbg(mdev->dev, "Failed to start pipeline: pad '%s':%u busy\n",
826 pad->entity->name, pad->index);
Sakari Ailus8aaf62b2015-11-29 17:20:02 -0200827 ret = -EBUSY;
828 goto error;
829 }
830
Laurent Pinchartae219872022-08-31 16:13:37 +0200831 /*
832 * 2. Validate all active links whose sink is the current pad.
833 * Validation of the source pads is performed in the context of
834 * the connected sink pad to avoid duplicating checks.
835 */
Daniel Scally549e6222022-07-07 23:47:33 +0100836 for_each_media_entity_data_link(entity, link) {
Laurent Pinchartae219872022-08-31 16:13:37 +0200837 /* Skip links unrelated to the current pad. */
838 if (link->sink != pad && link->source != pad)
839 continue;
Sakari Ailusaf88be32012-01-11 06:25:15 -0300840
Laurent Pinchartae219872022-08-31 16:13:37 +0200841 /* Record if the pad has links and enabled links. */
842 if (link->flags & MEDIA_LNK_FL_ENABLED)
843 has_enabled_link = true;
Sakari Ailusaf88be32012-01-11 06:25:15 -0300844
Sakari Ailusde49c282013-10-13 08:00:26 -0300845 /*
Laurent Pinchartae219872022-08-31 16:13:37 +0200846 * Validate the link if it's enabled and has the
847 * current pad as its sink.
Sakari Ailusde49c282013-10-13 08:00:26 -0300848 */
Laurent Pinchartae219872022-08-31 16:13:37 +0200849 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
850 continue;
Sakari Ailusde49c282013-10-13 08:00:26 -0300851
Laurent Pinchartae219872022-08-31 16:13:37 +0200852 if (link->sink != pad)
853 continue;
854
855 if (!entity->ops || !entity->ops->link_validate)
Sakari Ailusaf88be32012-01-11 06:25:15 -0300856 continue;
857
858 ret = entity->ops->link_validate(link);
Laurent Pinchartae219872022-08-31 16:13:37 +0200859 if (ret) {
860 dev_dbg(mdev->dev,
861 "Link '%s':%u -> '%s':%u failed validation: %d\n",
Sakari Ailus823ea2a2015-02-12 11:43:11 -0200862 link->source->entity->name,
863 link->source->index,
Laurent Pinchartae219872022-08-31 16:13:37 +0200864 link->sink->entity->name,
865 link->sink->index, ret);
Sakari Ailusaf88be32012-01-11 06:25:15 -0300866 goto error;
Sakari Ailusfab9d302014-10-28 20:35:04 -0300867 }
Laurent Pinchartae219872022-08-31 16:13:37 +0200868
869 dev_dbg(mdev->dev,
870 "Link '%s':%u -> '%s':%u is valid\n",
871 link->source->entity->name,
872 link->source->index,
873 link->sink->entity->name,
874 link->sink->index);
Sakari Ailusaf88be32012-01-11 06:25:15 -0300875 }
Sakari Ailusde49c282013-10-13 08:00:26 -0300876
Laurent Pinchartae219872022-08-31 16:13:37 +0200877 /*
878 * 3. If the pad has the MEDIA_PAD_FL_MUST_CONNECT flag set,
879 * ensure that it has either no link or an enabled link.
880 */
Laurent Pinchartb3decc52024-01-15 01:04:52 +0200881 if ((pad->flags & MEDIA_PAD_FL_MUST_CONNECT) &&
Laurent Pinchartae219872022-08-31 16:13:37 +0200882 !has_enabled_link) {
883 dev_dbg(mdev->dev,
884 "Pad '%s':%u must be connected by an enabled link\n",
885 pad->entity->name, pad->index);
Helen Mae Koike Fornazier47dfdb32015-06-28 16:14:10 -0300886 ret = -ENOLINK;
Sakari Ailusde49c282013-10-13 08:00:26 -0300887 goto error;
888 }
Laurent Pinchartae219872022-08-31 16:13:37 +0200889
890 /* Validation passed, store the pipe pointer in the pad. */
891 pad->pipe = pipe;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300892 }
893
Tomi Valkeinenb7319e22022-08-31 16:13:27 +0200894 pipe->start_count++;
Laurent Pinchart3056a8e2022-01-13 17:00:42 +0200895
Sakari Ailusaf88be32012-01-11 06:25:15 -0300896 return 0;
897
898error:
899 /*
900 * Link validation on graph failed. We revert what we did and
901 * return the error.
902 */
Sakari Ailusaf88be32012-01-11 06:25:15 -0300903
Laurent Pinchartae219872022-08-31 16:13:37 +0200904 list_for_each_entry(err_ppad, &pipe->pads, list) {
905 if (err_ppad == ppad)
Sakari Ailusaf88be32012-01-11 06:25:15 -0300906 break;
Laurent Pinchartae219872022-08-31 16:13:37 +0200907
908 err_ppad->pad->pipe = NULL;
Sakari Ailusaf88be32012-01-11 06:25:15 -0300909 }
910
Laurent Pinchartae219872022-08-31 16:13:37 +0200911 media_pipeline_cleanup(pipe);
Sakari Ailus106b9902015-12-16 15:32:23 +0200912
Shuah Khanfb49f202016-02-11 21:41:24 -0200913 return ret;
914}
Sakari Ailus20b85222016-11-21 14:48:30 -0200915EXPORT_SYMBOL_GPL(__media_pipeline_start);
Sakari Ailusaf88be32012-01-11 06:25:15 -0300916
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200917__must_check int media_pipeline_start(struct media_pad *pad,
Sakari Ailus20b85222016-11-21 14:48:30 -0200918 struct media_pipeline *pipe)
Shuah Khanfb49f202016-02-11 21:41:24 -0200919{
Laurent Pincharta967a3a2022-12-12 14:25:04 +0100920 struct media_device *mdev = pad->graph_obj.mdev;
Shuah Khanfb49f202016-02-11 21:41:24 -0200921 int ret;
922
923 mutex_lock(&mdev->graph_mutex);
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200924 ret = __media_pipeline_start(pad, pipe);
Shuah Khanfb49f202016-02-11 21:41:24 -0200925 mutex_unlock(&mdev->graph_mutex);
Sakari Ailusaf88be32012-01-11 06:25:15 -0300926 return ret;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300927}
Sakari Ailus20b85222016-11-21 14:48:30 -0200928EXPORT_SYMBOL_GPL(media_pipeline_start);
Laurent Pincharte02188c2010-08-25 09:00:41 -0300929
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200930void __media_pipeline_stop(struct media_pad *pad)
Laurent Pincharte02188c2010-08-25 09:00:41 -0300931{
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200932 struct media_pipeline *pipe = pad->pipe;
Laurent Pinchartae219872022-08-31 16:13:37 +0200933 struct media_pipeline_pad *ppad;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300934
Kieran Bingham2a2599c2017-01-03 11:12:11 -0200935 /*
936 * If the following check fails, the driver has performed an
937 * unbalanced call to media_pipeline_stop()
938 */
939 if (WARN_ON(!pipe))
940 return;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300941
Tomi Valkeinenb7319e22022-08-31 16:13:27 +0200942 if (--pipe->start_count)
Laurent Pinchart3056a8e2022-01-13 17:00:42 +0200943 return;
944
Laurent Pinchartae219872022-08-31 16:13:37 +0200945 list_for_each_entry(ppad, &pipe->pads, list)
946 ppad->pad->pipe = NULL;
Laurent Pincharte02188c2010-08-25 09:00:41 -0300947
Laurent Pinchartae219872022-08-31 16:13:37 +0200948 media_pipeline_cleanup(pipe);
Sakari Ailus106b9902015-12-16 15:32:23 +0200949
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200950 if (pipe->allocated)
951 kfree(pipe);
Shuah Khanfb49f202016-02-11 21:41:24 -0200952}
Sakari Ailus20b85222016-11-21 14:48:30 -0200953EXPORT_SYMBOL_GPL(__media_pipeline_stop);
Shuah Khanfb49f202016-02-11 21:41:24 -0200954
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200955void media_pipeline_stop(struct media_pad *pad)
Shuah Khanfb49f202016-02-11 21:41:24 -0200956{
Laurent Pincharta967a3a2022-12-12 14:25:04 +0100957 struct media_device *mdev = pad->graph_obj.mdev;
Shuah Khanfb49f202016-02-11 21:41:24 -0200958
959 mutex_lock(&mdev->graph_mutex);
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200960 __media_pipeline_stop(pad);
Laurent Pincharte02188c2010-08-25 09:00:41 -0300961 mutex_unlock(&mdev->graph_mutex);
962}
Sakari Ailus20b85222016-11-21 14:48:30 -0200963EXPORT_SYMBOL_GPL(media_pipeline_stop);
Laurent Pincharte02188c2010-08-25 09:00:41 -0300964
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200965__must_check int media_pipeline_alloc_start(struct media_pad *pad)
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200966{
Laurent Pincharta967a3a2022-12-12 14:25:04 +0100967 struct media_device *mdev = pad->graph_obj.mdev;
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200968 struct media_pipeline *new_pipe = NULL;
969 struct media_pipeline *pipe;
970 int ret;
971
972 mutex_lock(&mdev->graph_mutex);
973
974 /*
Laurent Pinchartb5163542022-12-12 14:25:05 +0100975 * Is the pad already part of a pipeline? If not, we need to allocate
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200976 * a pipe.
977 */
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200978 pipe = media_pad_pipeline(pad);
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200979 if (!pipe) {
980 new_pipe = kzalloc(sizeof(*new_pipe), GFP_KERNEL);
981 if (!new_pipe) {
982 ret = -ENOMEM;
983 goto out;
984 }
985
986 pipe = new_pipe;
987 pipe->allocated = true;
988 }
989
Tomi Valkeinen9e3576a2022-08-31 16:13:39 +0200990 ret = __media_pipeline_start(pad, pipe);
Tomi Valkeinend9f44342022-08-31 16:13:35 +0200991 if (ret)
992 kfree(new_pipe);
993
994out:
995 mutex_unlock(&mdev->graph_mutex);
996
997 return ret;
998}
999EXPORT_SYMBOL_GPL(media_pipeline_alloc_start);
1000
Laurent Pinchartd10ac512022-12-21 10:33:37 +01001001struct media_pad *
1002__media_pipeline_pad_iter_next(struct media_pipeline *pipe,
1003 struct media_pipeline_pad_iter *iter,
1004 struct media_pad *pad)
1005{
1006 if (!pad)
1007 iter->cursor = pipe->pads.next;
1008
1009 if (iter->cursor == &pipe->pads)
1010 return NULL;
1011
1012 pad = list_entry(iter->cursor, struct media_pipeline_pad, list)->pad;
1013 iter->cursor = iter->cursor->next;
1014
1015 return pad;
1016}
1017EXPORT_SYMBOL_GPL(__media_pipeline_pad_iter_next);
1018
Laurent Pincharteac564d2022-12-21 10:33:38 +01001019int media_pipeline_entity_iter_init(struct media_pipeline *pipe,
1020 struct media_pipeline_entity_iter *iter)
1021{
1022 return media_entity_enum_init(&iter->ent_enum, pipe->mdev);
1023}
1024EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_init);
1025
1026void media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter *iter)
1027{
1028 media_entity_enum_cleanup(&iter->ent_enum);
1029}
1030EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_cleanup);
1031
1032struct media_entity *
1033__media_pipeline_entity_iter_next(struct media_pipeline *pipe,
1034 struct media_pipeline_entity_iter *iter,
1035 struct media_entity *entity)
1036{
1037 if (!entity)
1038 iter->cursor = pipe->pads.next;
1039
1040 while (iter->cursor != &pipe->pads) {
1041 struct media_pipeline_pad *ppad;
1042 struct media_entity *entity;
1043
1044 ppad = list_entry(iter->cursor, struct media_pipeline_pad, list);
1045 entity = ppad->pad->entity;
1046 iter->cursor = iter->cursor->next;
1047
1048 if (!media_entity_enum_test_and_set(&iter->ent_enum, entity))
1049 return entity;
1050 }
1051
1052 return NULL;
1053}
1054EXPORT_SYMBOL_GPL(__media_pipeline_entity_iter_next);
1055
Laurent Pincharte02188c2010-08-25 09:00:41 -03001056/* -----------------------------------------------------------------------------
Sakari Ailusa5ccc482010-03-07 16:14:14 -03001057 * Links management
1058 */
1059
Mauro Carvalho Chehab23615de2015-08-20 08:21:35 -03001060static struct media_link *media_add_link(struct list_head *head)
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001061{
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001062 struct media_link *link;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001063
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001064 link = kzalloc(sizeof(*link), GFP_KERNEL);
1065 if (link == NULL)
1066 return NULL;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001067
Mauro Carvalho Chehab23615de2015-08-20 08:21:35 -03001068 list_add_tail(&link->list, head);
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001069
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001070 return link;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001071}
1072
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001073static void __media_entity_remove_link(struct media_entity *entity,
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001074 struct media_link *link)
1075{
1076 struct media_link *rlink, *tmp;
1077 struct media_entity *remote;
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001078
Yunke Cao6008dea2022-04-12 07:23:13 +01001079 /* Remove the reverse links for a data link. */
1080 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) == MEDIA_LNK_FL_DATA_LINK) {
Laurent Pinchartbaeddf92024-01-15 00:30:02 +02001081 link->source->num_links--;
1082 link->sink->num_links--;
1083
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001084 if (link->source->entity == entity)
Yunke Cao6008dea2022-04-12 07:23:13 +01001085 remote = link->sink->entity;
1086 else
1087 remote = link->source->entity;
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001088
Yunke Cao6008dea2022-04-12 07:23:13 +01001089 list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
1090 if (rlink != link->reverse)
1091 continue;
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001092
Yunke Cao6008dea2022-04-12 07:23:13 +01001093 if (link->source->entity == entity)
1094 remote->num_backlinks--;
1095
1096 /* Remove the remote link */
1097 list_del(&rlink->list);
1098 media_gobj_destroy(&rlink->graph_obj);
1099 kfree(rlink);
1100
1101 if (--remote->num_links == 0)
1102 break;
1103 }
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001104 }
Yunke Cao6008dea2022-04-12 07:23:13 +01001105
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001106 list_del(&link->list);
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001107 media_gobj_destroy(&link->graph_obj);
Mauro Carvalho Chehab5abad222015-12-11 11:19:38 -02001108 kfree(link);
1109}
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001110
Sakari Ailus4fd463e2023-04-25 13:23:00 +03001111int media_get_pad_index(struct media_entity *entity, u32 pad_type,
Mauro Carvalho Chehab9d6d20e2018-07-31 09:22:40 -04001112 enum media_pad_signal_type sig_type)
1113{
Sakari Ailus4fd463e2023-04-25 13:23:00 +03001114 unsigned int i;
Mauro Carvalho Chehab9d6d20e2018-07-31 09:22:40 -04001115
1116 if (!entity)
1117 return -EINVAL;
1118
1119 for (i = 0; i < entity->num_pads; i++) {
Sakari Ailus4fd463e2023-04-25 13:23:00 +03001120 if ((entity->pads[i].flags &
1121 (MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_SOURCE)) != pad_type)
Mauro Carvalho Chehab9d6d20e2018-07-31 09:22:40 -04001122 continue;
Sakari Ailus4fd463e2023-04-25 13:23:00 +03001123
Mauro Carvalho Chehab9d6d20e2018-07-31 09:22:40 -04001124 if (entity->pads[i].sig_type == sig_type)
1125 return i;
1126 }
1127 return -EINVAL;
1128}
1129EXPORT_SYMBOL_GPL(media_get_pad_index);
1130
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001131int
Mauro Carvalho Chehab8df00a12015-08-07 08:14:38 -03001132media_create_pad_link(struct media_entity *source, u16 source_pad,
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001133 struct media_entity *sink, u16 sink_pad, u32 flags)
1134{
1135 struct media_link *link;
1136 struct media_link *backlink;
1137
Laurent Pinchart422f7af2024-01-15 00:24:12 +02001138 if (flags & MEDIA_LNK_FL_LINK_TYPE)
1139 return -EINVAL;
1140
1141 flags |= MEDIA_LNK_FL_DATA_LINK;
1142
Hans Verkuila3fbc2e2020-02-04 19:13:13 +01001143 if (WARN_ON(!source || !sink) ||
1144 WARN_ON(source_pad >= source->num_pads) ||
1145 WARN_ON(sink_pad >= sink->num_pads))
1146 return -EINVAL;
1147 if (WARN_ON(!(source->pads[source_pad].flags & MEDIA_PAD_FL_SOURCE)))
1148 return -EINVAL;
1149 if (WARN_ON(!(sink->pads[sink_pad].flags & MEDIA_PAD_FL_SINK)))
1150 return -EINVAL;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001151
Mauro Carvalho Chehab23615de2015-08-20 08:21:35 -03001152 link = media_add_link(&source->links);
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001153 if (link == NULL)
1154 return -ENOMEM;
1155
1156 link->source = &source->pads[source_pad];
1157 link->sink = &sink->pads[sink_pad];
Laurent Pinchart422f7af2024-01-15 00:24:12 +02001158 link->flags = flags;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001159
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -03001160 /* Initialize graph object embedded at the new link */
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001161 media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
Javier Martinez Canillasd10c9892015-08-19 12:35:21 -03001162 &link->graph_obj);
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -03001163
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001164 /* Create the backlink. Backlinks are used to help graph traversal and
1165 * are not reported to userspace.
1166 */
Mauro Carvalho Chehab23615de2015-08-20 08:21:35 -03001167 backlink = media_add_link(&sink->links);
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001168 if (backlink == NULL) {
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001169 __media_entity_remove_link(source, link);
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001170 return -ENOMEM;
1171 }
1172
1173 backlink->source = &source->pads[source_pad];
1174 backlink->sink = &sink->pads[sink_pad];
1175 backlink->flags = flags;
Mauro Carvalho Chehab39d1ebc62015-08-30 09:53:57 -03001176 backlink->is_backlink = true;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001177
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -03001178 /* Initialize graph object embedded at the new link */
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001179 media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
Javier Martinez Canillasd10c9892015-08-19 12:35:21 -03001180 &backlink->graph_obj);
Mauro Carvalho Chehab6b6a4272015-08-14 12:54:36 -03001181
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001182 link->reverse = backlink;
1183 backlink->reverse = link;
1184
1185 sink->num_backlinks++;
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001186 sink->num_links++;
1187 source->num_links++;
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001188
Laurent Pinchartbaeddf92024-01-15 00:30:02 +02001189 link->source->num_links++;
1190 link->sink->num_links++;
1191
Laurent Pinchart53e269c2009-12-09 08:40:00 -03001192 return 0;
1193}
Mauro Carvalho Chehab8df00a12015-08-07 08:14:38 -03001194EXPORT_SYMBOL_GPL(media_create_pad_link);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001195
Mauro Carvalho Chehabb01cc9c2015-12-30 09:45:48 -02001196int media_create_pad_links(const struct media_device *mdev,
1197 const u32 source_function,
1198 struct media_entity *source,
1199 const u16 source_pad,
1200 const u32 sink_function,
1201 struct media_entity *sink,
1202 const u16 sink_pad,
1203 u32 flags,
1204 const bool allow_both_undefined)
1205{
1206 struct media_entity *entity;
1207 unsigned function;
1208 int ret;
1209
1210 /* Trivial case: 1:1 relation */
1211 if (source && sink)
1212 return media_create_pad_link(source, source_pad,
1213 sink, sink_pad, flags);
1214
1215 /* Worse case scenario: n:n relation */
1216 if (!source && !sink) {
1217 if (!allow_both_undefined)
1218 return 0;
1219 media_device_for_each_entity(source, mdev) {
1220 if (source->function != source_function)
1221 continue;
1222 media_device_for_each_entity(sink, mdev) {
1223 if (sink->function != sink_function)
1224 continue;
1225 ret = media_create_pad_link(source, source_pad,
1226 sink, sink_pad,
1227 flags);
1228 if (ret)
1229 return ret;
1230 flags &= ~(MEDIA_LNK_FL_ENABLED |
1231 MEDIA_LNK_FL_IMMUTABLE);
1232 }
1233 }
1234 return 0;
1235 }
1236
1237 /* Handle 1:n and n:1 cases */
1238 if (source)
1239 function = sink_function;
1240 else
1241 function = source_function;
1242
1243 media_device_for_each_entity(entity, mdev) {
1244 if (entity->function != function)
1245 continue;
1246
1247 if (source)
1248 ret = media_create_pad_link(source, source_pad,
1249 entity, sink_pad, flags);
1250 else
1251 ret = media_create_pad_link(entity, source_pad,
1252 sink, sink_pad, flags);
1253 if (ret)
1254 return ret;
1255 flags &= ~(MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
1256 }
1257 return 0;
1258}
1259EXPORT_SYMBOL_GPL(media_create_pad_links);
1260
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001261void __media_entity_remove_links(struct media_entity *entity)
1262{
1263 struct media_link *link, *tmp;
1264
1265 list_for_each_entry_safe(link, tmp, &entity->links, list)
1266 __media_entity_remove_link(entity, link);
Sylwester Nawrocki7349cec2013-05-09 08:29:32 -03001267
1268 entity->num_links = 0;
1269 entity->num_backlinks = 0;
1270}
1271EXPORT_SYMBOL_GPL(__media_entity_remove_links);
1272
1273void media_entity_remove_links(struct media_entity *entity)
1274{
Mauro Carvalho Chehabcc4a8252015-12-15 08:01:13 -02001275 struct media_device *mdev = entity->graph_obj.mdev;
1276
Sylwester Nawrocki7349cec2013-05-09 08:29:32 -03001277 /* Do nothing if the entity is not registered. */
Mauro Carvalho Chehabcc4a8252015-12-15 08:01:13 -02001278 if (mdev == NULL)
Sylwester Nawrocki7349cec2013-05-09 08:29:32 -03001279 return;
1280
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001281 mutex_lock(&mdev->graph_mutex);
Sylwester Nawrocki7349cec2013-05-09 08:29:32 -03001282 __media_entity_remove_links(entity);
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001283 mutex_unlock(&mdev->graph_mutex);
Sylwester Nawrocki7349cec2013-05-09 08:29:32 -03001284}
1285EXPORT_SYMBOL_GPL(media_entity_remove_links);
1286
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001287static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
1288{
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001289 int ret;
1290
1291 /* Notify both entities. */
1292 ret = media_entity_call(link->source->entity, link_setup,
1293 link->source, link->sink, flags);
1294 if (ret < 0 && ret != -ENOIOCTLCMD)
1295 return ret;
1296
1297 ret = media_entity_call(link->sink->entity, link_setup,
1298 link->sink, link->source, flags);
1299 if (ret < 0 && ret != -ENOIOCTLCMD) {
1300 media_entity_call(link->source->entity, link_setup,
1301 link->source, link->sink, link->flags);
1302 return ret;
1303 }
1304
Laurent Pinchart7a6f0b22011-03-11 11:34:35 -03001305 link->flags = flags;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001306 link->reverse->flags = link->flags;
1307
1308 return 0;
1309}
1310
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001311int __media_entity_setup_link(struct media_link *link, u32 flags)
1312{
Laurent Pinchart7a6f0b22011-03-11 11:34:35 -03001313 const u32 mask = MEDIA_LNK_FL_ENABLED;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001314 struct media_device *mdev;
Laurent Pinchartae219872022-08-31 16:13:37 +02001315 struct media_pad *source, *sink;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001316 int ret = -EBUSY;
1317
1318 if (link == NULL)
1319 return -EINVAL;
1320
Laurent Pinchart7a6f0b22011-03-11 11:34:35 -03001321 /* The non-modifiable link flags must not be modified. */
1322 if ((link->flags & ~mask) != (flags & ~mask))
1323 return -EINVAL;
1324
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001325 if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
1326 return link->flags == flags ? 0 : -EINVAL;
1327
1328 if (link->flags == flags)
1329 return 0;
1330
Laurent Pinchartae219872022-08-31 16:13:37 +02001331 source = link->source;
1332 sink = link->sink;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001333
Laurent Pincharte02188c2010-08-25 09:00:41 -03001334 if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) &&
Laurent Pinchartae219872022-08-31 16:13:37 +02001335 (media_pad_is_streaming(source) || media_pad_is_streaming(sink)))
Laurent Pincharte02188c2010-08-25 09:00:41 -03001336 return -EBUSY;
1337
Javier Martinez Canillasd10c9892015-08-19 12:35:21 -03001338 mdev = source->graph_obj.mdev;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001339
Laurent Pinchart68429f52015-11-03 00:27:51 -02001340 if (mdev->ops && mdev->ops->link_notify) {
1341 ret = mdev->ops->link_notify(link, flags,
1342 MEDIA_DEV_NOTIFY_PRE_LINK_CH);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001343 if (ret < 0)
1344 return ret;
1345 }
1346
1347 ret = __media_entity_setup_link_notify(link, flags);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001348
Laurent Pinchart68429f52015-11-03 00:27:51 -02001349 if (mdev->ops && mdev->ops->link_notify)
1350 mdev->ops->link_notify(link, flags,
1351 MEDIA_DEV_NOTIFY_POST_LINK_CH);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001352
1353 return ret;
1354}
Shuah Khanefc70272016-02-11 21:41:23 -02001355EXPORT_SYMBOL_GPL(__media_entity_setup_link);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001356
1357int media_entity_setup_link(struct media_link *link, u32 flags)
1358{
1359 int ret;
1360
Mauro Carvalho Chehab5c883ed2015-12-15 07:58:18 -02001361 mutex_lock(&link->graph_obj.mdev->graph_mutex);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001362 ret = __media_entity_setup_link(link, flags);
Mauro Carvalho Chehab5c883ed2015-12-15 07:58:18 -02001363 mutex_unlock(&link->graph_obj.mdev->graph_mutex);
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001364
1365 return ret;
1366}
1367EXPORT_SYMBOL_GPL(media_entity_setup_link);
1368
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001369struct media_link *
1370media_entity_find_link(struct media_pad *source, struct media_pad *sink)
1371{
1372 struct media_link *link;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001373
Daniel Scally549e6222022-07-07 23:47:33 +01001374 for_each_media_entity_data_link(source->entity, link) {
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001375 if (link->source->entity == source->entity &&
1376 link->source->index == source->index &&
1377 link->sink->entity == sink->entity &&
1378 link->sink->index == sink->index)
1379 return link;
1380 }
1381
1382 return NULL;
1383}
1384EXPORT_SYMBOL_GPL(media_entity_find_link);
1385
Laurent Pinchartb2e44432022-06-25 18:02:24 +01001386struct media_pad *media_pad_remote_pad_first(const struct media_pad *pad)
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001387{
Mauro Carvalho Chehab57208e52015-08-07 06:55:40 -03001388 struct media_link *link;
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001389
Daniel Scally549e6222022-07-07 23:47:33 +01001390 for_each_media_entity_data_link(pad->entity, link) {
Laurent Pinchart97548ed2009-12-09 08:40:03 -03001391 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
1392 continue;
1393
1394 if (link->source == pad)
1395 return link->sink;
1396
1397 if (link->sink == pad)
1398 return link->source;
1399 }
1400
1401 return NULL;
1402
1403}
Laurent Pinchartb2e44432022-06-25 18:02:24 +01001404EXPORT_SYMBOL_GPL(media_pad_remote_pad_first);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001405
Laurent Pinchart5680fe42022-06-14 20:11:09 +01001406struct media_pad *
1407media_entity_remote_pad_unique(const struct media_entity *entity,
1408 unsigned int type)
1409{
1410 struct media_pad *pad = NULL;
1411 struct media_link *link;
1412
1413 list_for_each_entry(link, &entity->links, list) {
1414 struct media_pad *local_pad;
1415 struct media_pad *remote_pad;
1416
1417 if (((link->flags & MEDIA_LNK_FL_LINK_TYPE) !=
1418 MEDIA_LNK_FL_DATA_LINK) ||
1419 !(link->flags & MEDIA_LNK_FL_ENABLED))
1420 continue;
1421
1422 if (type == MEDIA_PAD_FL_SOURCE) {
1423 local_pad = link->sink;
1424 remote_pad = link->source;
1425 } else {
1426 local_pad = link->source;
1427 remote_pad = link->sink;
1428 }
1429
1430 if (local_pad->entity == entity) {
1431 if (pad)
1432 return ERR_PTR(-ENOTUNIQ);
1433
1434 pad = remote_pad;
1435 }
1436 }
1437
1438 if (!pad)
1439 return ERR_PTR(-ENOLINK);
1440
1441 return pad;
1442}
1443EXPORT_SYMBOL_GPL(media_entity_remote_pad_unique);
1444
Laurent Pinchart03b28282022-06-14 20:11:10 +01001445struct media_pad *media_pad_remote_pad_unique(const struct media_pad *pad)
1446{
1447 struct media_pad *found_pad = NULL;
1448 struct media_link *link;
1449
1450 list_for_each_entry(link, &pad->entity->links, list) {
1451 struct media_pad *remote_pad;
1452
1453 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
1454 continue;
1455
1456 if (link->sink == pad)
1457 remote_pad = link->source;
1458 else if (link->source == pad)
1459 remote_pad = link->sink;
1460 else
1461 continue;
1462
1463 if (found_pad)
1464 return ERR_PTR(-ENOTUNIQ);
1465
1466 found_pad = remote_pad;
1467 }
1468
1469 if (!found_pad)
1470 return ERR_PTR(-ENOLINK);
1471
1472 return found_pad;
1473}
1474EXPORT_SYMBOL_GPL(media_pad_remote_pad_unique);
1475
Laurent Pinchart612589a2022-08-31 16:13:30 +02001476int media_entity_get_fwnode_pad(struct media_entity *entity,
Sakari Ailusec178312023-05-05 16:27:49 +03001477 const struct fwnode_handle *fwnode,
Laurent Pinchart612589a2022-08-31 16:13:30 +02001478 unsigned long direction_flags)
1479{
1480 struct fwnode_endpoint endpoint;
1481 unsigned int i;
1482 int ret;
1483
1484 if (!entity->ops || !entity->ops->get_fwnode_pad) {
1485 for (i = 0; i < entity->num_pads; i++) {
1486 if (entity->pads[i].flags & direction_flags)
1487 return i;
1488 }
1489
1490 return -ENXIO;
1491 }
1492
1493 ret = fwnode_graph_parse_endpoint(fwnode, &endpoint);
1494 if (ret)
1495 return ret;
1496
1497 ret = entity->ops->get_fwnode_pad(entity, &endpoint);
1498 if (ret < 0)
1499 return ret;
1500
1501 if (ret >= entity->num_pads)
1502 return -ENXIO;
1503
1504 if (!(entity->pads[ret].flags & direction_flags))
1505 return -ENXIO;
1506
1507 return ret;
1508}
1509EXPORT_SYMBOL_GPL(media_entity_get_fwnode_pad);
1510
Laurent Pinchart72b60332022-08-31 16:13:31 +02001511struct media_pipeline *media_entity_pipeline(struct media_entity *entity)
1512{
Laurent Pinchartae219872022-08-31 16:13:37 +02001513 struct media_pad *pad;
1514
1515 media_entity_for_each_pad(entity, pad) {
1516 if (pad->pipe)
1517 return pad->pipe;
1518 }
1519
1520 return NULL;
Laurent Pinchart72b60332022-08-31 16:13:31 +02001521}
1522EXPORT_SYMBOL_GPL(media_entity_pipeline);
1523
Laurent Pinchartae219872022-08-31 16:13:37 +02001524struct media_pipeline *media_pad_pipeline(struct media_pad *pad)
1525{
1526 return pad->pipe;
1527}
1528EXPORT_SYMBOL_GPL(media_pad_pipeline);
1529
Mauro Carvalho Chehab1283f842015-08-28 15:43:36 -03001530static void media_interface_init(struct media_device *mdev,
1531 struct media_interface *intf,
1532 u32 gobj_type,
1533 u32 intf_type, u32 flags)
1534{
1535 intf->type = intf_type;
1536 intf->flags = flags;
1537 INIT_LIST_HEAD(&intf->links);
1538
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001539 media_gobj_create(mdev, gobj_type, &intf->graph_obj);
Mauro Carvalho Chehab1283f842015-08-28 15:43:36 -03001540}
1541
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001542/* Functions related to the media interface via device nodes */
1543
1544struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
1545 u32 type, u32 flags,
Mauro Carvalho Chehab0b3b72df92015-09-09 08:19:25 -03001546 u32 major, u32 minor)
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001547{
1548 struct media_intf_devnode *devnode;
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001549
Mauro Carvalho Chehab0b3b72df92015-09-09 08:19:25 -03001550 devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001551 if (!devnode)
1552 return NULL;
1553
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001554 devnode->major = major;
1555 devnode->minor = minor;
1556
Mauro Carvalho Chehab1283f842015-08-28 15:43:36 -03001557 media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
1558 type, flags);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001559
1560 return devnode;
1561}
1562EXPORT_SYMBOL_GPL(media_devnode_create);
1563
1564void media_devnode_remove(struct media_intf_devnode *devnode)
1565{
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001566 media_remove_intf_links(&devnode->intf);
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001567 media_gobj_destroy(&devnode->intf.graph_obj);
Mauro Carvalho Chehab27e543f2015-08-20 09:07:34 -03001568 kfree(devnode);
1569}
1570EXPORT_SYMBOL_GPL(media_devnode_remove);
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001571
1572struct media_link *media_create_intf_link(struct media_entity *entity,
1573 struct media_interface *intf,
1574 u32 flags)
1575{
1576 struct media_link *link;
1577
1578 link = media_add_link(&intf->links);
1579 if (link == NULL)
1580 return NULL;
1581
1582 link->intf = intf;
1583 link->entity = entity;
Mauro Carvalho Chehab82ae2a52015-12-11 18:09:13 -02001584 link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK;
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001585
1586 /* Initialize graph object embedded at the new link */
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001587 media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001588 &link->graph_obj);
1589
1590 return link;
1591}
1592EXPORT_SYMBOL_GPL(media_create_intf_link);
1593
Mauro Carvalho Chehabd47109f2015-08-29 21:23:44 -03001594void __media_remove_intf_link(struct media_link *link)
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001595{
Mauro Carvalho Chehabd47109f2015-08-29 21:23:44 -03001596 list_del(&link->list);
Mauro Carvalho Chehabc350ef82015-12-11 11:55:40 -02001597 media_gobj_destroy(&link->graph_obj);
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001598 kfree(link);
1599}
Mauro Carvalho Chehabd47109f2015-08-29 21:23:44 -03001600EXPORT_SYMBOL_GPL(__media_remove_intf_link);
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001601
1602void media_remove_intf_link(struct media_link *link)
1603{
Mauro Carvalho Chehabcc4a8252015-12-15 08:01:13 -02001604 struct media_device *mdev = link->graph_obj.mdev;
1605
1606 /* Do nothing if the intf is not registered. */
1607 if (mdev == NULL)
1608 return;
1609
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001610 mutex_lock(&mdev->graph_mutex);
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001611 __media_remove_intf_link(link);
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001612 mutex_unlock(&mdev->graph_mutex);
Mauro Carvalho Chehab86e26622015-08-07 10:36:25 -03001613}
1614EXPORT_SYMBOL_GPL(media_remove_intf_link);
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001615
1616void __media_remove_intf_links(struct media_interface *intf)
1617{
1618 struct media_link *link, *tmp;
1619
1620 list_for_each_entry_safe(link, tmp, &intf->links, list)
1621 __media_remove_intf_link(link);
1622
1623}
1624EXPORT_SYMBOL_GPL(__media_remove_intf_links);
1625
1626void media_remove_intf_links(struct media_interface *intf)
1627{
Mauro Carvalho Chehabcc4a8252015-12-15 08:01:13 -02001628 struct media_device *mdev = intf->graph_obj.mdev;
1629
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001630 /* Do nothing if the intf is not registered. */
Mauro Carvalho Chehabcc4a8252015-12-15 08:01:13 -02001631 if (mdev == NULL)
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001632 return;
1633
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001634 mutex_lock(&mdev->graph_mutex);
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001635 __media_remove_intf_links(intf);
Mauro Carvalho Chehabe2c91d42016-04-06 10:55:24 -03001636 mutex_unlock(&mdev->graph_mutex);
Mauro Carvalho Chehab7c4696a2015-08-24 08:46:46 -03001637}
1638EXPORT_SYMBOL_GPL(media_remove_intf_links);
Daniel Scally012c87f2022-03-02 22:03:03 +00001639
1640struct media_link *media_create_ancillary_link(struct media_entity *primary,
1641 struct media_entity *ancillary)
1642{
1643 struct media_link *link;
1644
1645 link = media_add_link(&primary->links);
1646 if (!link)
1647 return ERR_PTR(-ENOMEM);
1648
1649 link->gobj0 = &primary->graph_obj;
1650 link->gobj1 = &ancillary->graph_obj;
1651 link->flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED |
1652 MEDIA_LNK_FL_ANCILLARY_LINK;
1653
1654 /* Initialize graph object embedded in the new link */
1655 media_gobj_create(primary->graph_obj.mdev, MEDIA_GRAPH_LINK,
1656 &link->graph_obj);
1657
1658 return link;
1659}
1660EXPORT_SYMBOL_GPL(media_create_ancillary_link);
Daniel Scally1ed3d642022-07-07 23:47:32 +01001661
1662struct media_link *__media_entity_next_link(struct media_entity *entity,
1663 struct media_link *link,
1664 unsigned long link_type)
1665{
1666 link = link ? list_next_entry(link, list)
1667 : list_first_entry(&entity->links, typeof(*link), list);
1668
1669 list_for_each_entry_from(link, &entity->links, list)
1670 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) == link_type)
1671 return link;
1672
1673 return NULL;
1674}
1675EXPORT_SYMBOL_GPL(__media_entity_next_link);