xref: /linux/drivers/media/mc/mc-entity.c (revision 6fd600d742744dc7ef7fc65ca26daa2b1163158a)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
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>
9  */
10 
11 #include <linux/bitmap.h>
12 #include <linux/list.h>
13 #include <linux/property.h>
14 #include <linux/slab.h>
15 #include <media/media-entity.h>
16 #include <media/media-device.h>
17 
intf_type(struct media_interface * intf)18 static inline const char *intf_type(struct media_interface *intf)
19 {
20 	switch (intf->type) {
21 	case MEDIA_INTF_T_DVB_FE:
22 		return "dvb-frontend";
23 	case MEDIA_INTF_T_DVB_DEMUX:
24 		return "dvb-demux";
25 	case MEDIA_INTF_T_DVB_DVR:
26 		return "dvb-dvr";
27 	case MEDIA_INTF_T_DVB_CA:
28 		return  "dvb-ca";
29 	case MEDIA_INTF_T_DVB_NET:
30 		return "dvb-net";
31 	case MEDIA_INTF_T_V4L_VIDEO:
32 		return "v4l-video";
33 	case MEDIA_INTF_T_V4L_VBI:
34 		return "v4l-vbi";
35 	case MEDIA_INTF_T_V4L_RADIO:
36 		return "v4l-radio";
37 	case MEDIA_INTF_T_V4L_SUBDEV:
38 		return "v4l-subdev";
39 	case MEDIA_INTF_T_V4L_SWRADIO:
40 		return "v4l-swradio";
41 	case MEDIA_INTF_T_V4L_TOUCH:
42 		return "v4l-touch";
43 	default:
44 		return "unknown-intf";
45 	}
46 };
47 
link_type_name(struct media_link * link)48 static 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 
media_entity_enum_init(struct media_entity_enum * ent_enum,struct media_device * mdev)62 __must_check int media_entity_enum_init(struct media_entity_enum *ent_enum,
63 					struct media_device *mdev)
64 {
65 	int idx_max;
66 
67 	idx_max = ALIGN(mdev->entity_internal_idx_max + 1, BITS_PER_LONG);
68 	ent_enum->bmap = bitmap_zalloc(idx_max, GFP_KERNEL);
69 	if (!ent_enum->bmap)
70 		return -ENOMEM;
71 
72 	ent_enum->idx_max = idx_max;
73 
74 	return 0;
75 }
76 EXPORT_SYMBOL_GPL(media_entity_enum_init);
77 
media_entity_enum_cleanup(struct media_entity_enum * ent_enum)78 void media_entity_enum_cleanup(struct media_entity_enum *ent_enum)
79 {
80 	bitmap_free(ent_enum->bmap);
81 }
82 EXPORT_SYMBOL_GPL(media_entity_enum_cleanup);
83 
84 /**
85  *  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  */
dev_dbg_obj(const char * event_name,struct media_gobj * gobj)93 static 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,
99 			"%s id %u: entity '%s'\n",
100 			event_name, media_id(gobj),
101 			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,
108 			"%s id %u: %s link id %u ==> id %u\n",
109 			event_name, media_id(gobj), link_type_name(link),
110 			media_id(link->gobj0),
111 			media_id(link->gobj1));
112 		break;
113 	}
114 	case MEDIA_GRAPH_PAD:
115 	{
116 		struct media_pad *pad = gobj_to_pad(gobj);
117 
118 		dev_dbg(gobj->mdev->dev,
119 			"%s id %u: %s%spad '%s':%d\n",
120 			event_name, media_id(gobj),
121 			pad->flags & MEDIA_PAD_FL_SINK   ? "sink " : "",
122 			pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "",
123 			pad->entity->name, pad->index);
124 		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,
132 			"%s id %u: intf_devnode %s - major: %d, minor: %d\n",
133 			event_name, media_id(gobj),
134 			intf_type(intf),
135 			devnode->major, devnode->minor);
136 		break;
137 	}
138 	}
139 #endif
140 }
141 
media_gobj_create(struct media_device * mdev,enum media_gobj_type type,struct media_gobj * gobj)142 void media_gobj_create(struct media_device *mdev,
143 			   enum media_gobj_type type,
144 			   struct media_gobj *gobj)
145 {
146 	BUG_ON(!mdev);
147 
148 	gobj->mdev = mdev;
149 
150 	/* Create a per-type unique object ID */
151 	gobj->id = media_gobj_gen_id(type, ++mdev->id);
152 
153 	switch (type) {
154 	case MEDIA_GRAPH_ENTITY:
155 		list_add_tail(&gobj->list, &mdev->entities);
156 		break;
157 	case MEDIA_GRAPH_PAD:
158 		list_add_tail(&gobj->list, &mdev->pads);
159 		break;
160 	case MEDIA_GRAPH_LINK:
161 		list_add_tail(&gobj->list, &mdev->links);
162 		break;
163 	case MEDIA_GRAPH_INTF_DEVNODE:
164 		list_add_tail(&gobj->list, &mdev->interfaces);
165 		break;
166 	}
167 
168 	mdev->topology_version++;
169 
170 	dev_dbg_obj(__func__, gobj);
171 }
172 
media_gobj_destroy(struct media_gobj * gobj)173 void media_gobj_destroy(struct media_gobj *gobj)
174 {
175 	/* Do nothing if the object is not linked. */
176 	if (gobj->mdev == NULL)
177 		return;
178 
179 	dev_dbg_obj(__func__, gobj);
180 
181 	gobj->mdev->topology_version++;
182 
183 	/* Remove the object from mdev list */
184 	list_del(&gobj->list);
185 
186 	gobj->mdev = NULL;
187 }
188 
189 /*
190  * TODO: Get rid of this.
191  */
192 #define MEDIA_ENTITY_MAX_PADS		512
193 
media_entity_pads_init(struct media_entity * entity,u16 num_pads,struct media_pad * pads)194 int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
195 			   struct media_pad *pads)
196 {
197 	struct media_device *mdev = entity->graph_obj.mdev;
198 	struct media_pad *iter;
199 	unsigned int i = 0;
200 	int ret = 0;
201 
202 	if (num_pads >= MEDIA_ENTITY_MAX_PADS)
203 		return -E2BIG;
204 
205 	entity->num_pads = num_pads;
206 	entity->pads = pads;
207 
208 	if (mdev)
209 		mutex_lock(&mdev->graph_mutex);
210 
211 	media_entity_for_each_pad(entity, iter) {
212 		iter->entity = entity;
213 		iter->index = i++;
214 
215 		if (hweight32(iter->flags & (MEDIA_PAD_FL_SINK |
216 					     MEDIA_PAD_FL_SOURCE)) != 1) {
217 			ret = -EINVAL;
218 			break;
219 		}
220 
221 		if (mdev)
222 			media_gobj_create(mdev, MEDIA_GRAPH_PAD,
223 					  &iter->graph_obj);
224 	}
225 
226 	if (ret && mdev) {
227 		media_entity_for_each_pad(entity, iter)
228 			media_gobj_destroy(&iter->graph_obj);
229 	}
230 
231 	if (mdev)
232 		mutex_unlock(&mdev->graph_mutex);
233 
234 	return ret;
235 }
236 EXPORT_SYMBOL_GPL(media_entity_pads_init);
237 
238 /* -----------------------------------------------------------------------------
239  * Graph traversal
240  */
241 
242 /**
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  *
249  * 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  *
254  * 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.
258  *
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.
265  */
media_entity_has_pad_interdep(struct media_entity * entity,unsigned int pad0,unsigned int pad1)266 static 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 
276 	if (!entity->ops || !entity->ops->has_pad_interdep)
277 		return true;
278 
279 	return entity->ops->has_pad_interdep(entity, pad0, pad1);
280 }
281 
282 static struct media_entity *
media_entity_other(struct media_entity * entity,struct media_link * link)283 media_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 */
stack_push(struct media_graph * graph,struct media_entity * entity)292 static void stack_push(struct media_graph *graph,
293 		       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++;
300 	graph->stack[graph->top].link = entity->links.next;
301 	graph->stack[graph->top].entity = entity;
302 }
303 
stack_pop(struct media_graph * graph)304 static struct media_entity *stack_pop(struct media_graph *graph)
305 {
306 	struct media_entity *entity;
307 
308 	entity = graph->stack[graph->top].entity;
309 	graph->top--;
310 
311 	return entity;
312 }
313 
314 #define link_top(en)	((en)->stack[(en)->top].link)
315 #define stack_top(en)	((en)->stack[(en)->top].entity)
316 
317 /**
318  * media_graph_walk_init - Allocate resources for graph walk
319  * @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
324  * media_graph_walk_cleanup().
325  *
326  * Returns error on failure, zero on success.
327  */
media_graph_walk_init(struct media_graph * graph,struct media_device * mdev)328 __must_check int media_graph_walk_init(
329 	struct media_graph *graph, struct media_device *mdev)
330 {
331 	return media_entity_enum_init(&graph->ent_enum, mdev);
332 }
333 EXPORT_SYMBOL_GPL(media_graph_walk_init);
334 
335 /**
336  * media_graph_walk_cleanup - Release resources related to graph walking
337  * @graph: Media graph structure that was used to walk the graph
338  */
media_graph_walk_cleanup(struct media_graph * graph)339 void media_graph_walk_cleanup(struct media_graph *graph)
340 {
341 	media_entity_enum_cleanup(&graph->ent_enum);
342 }
343 EXPORT_SYMBOL_GPL(media_graph_walk_cleanup);
344 
media_graph_walk_start(struct media_graph * graph,struct media_entity * entity)345 void media_graph_walk_start(struct media_graph *graph,
346 			    struct media_entity *entity)
347 {
348 	media_entity_enum_zero(&graph->ent_enum);
349 	media_entity_enum_set(&graph->ent_enum, entity);
350 
351 	graph->top = 0;
352 	graph->stack[graph->top].entity = NULL;
353 	stack_push(graph, entity);
354 	dev_dbg(entity->graph_obj.mdev->dev,
355 		"begin graph walk at '%s'\n", entity->name);
356 }
357 EXPORT_SYMBOL_GPL(media_graph_walk_start);
358 
media_graph_walk_iter(struct media_graph * graph)359 static 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 
367 	/* 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 
373 	/* 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;
376 		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);
380 		return;
381 	}
382 
383 	/* Get the entity at the other end of the link. */
384 	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;
389 		dev_dbg(entity->graph_obj.mdev->dev,
390 			"walk: skipping entity '%s' (already seen)\n",
391 			next->name);
392 		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);
398 	dev_dbg(entity->graph_obj.mdev->dev, "walk: pushing '%s' on stack\n",
399 		next->name);
400 	lockdep_assert_held(&entity->graph_obj.mdev->graph_mutex);
401 }
402 
media_graph_walk_next(struct media_graph * graph)403 struct media_entity *media_graph_walk_next(struct media_graph *graph)
404 {
405 	struct media_entity *entity;
406 
407 	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 	 */
415 	while (link_top(graph) != &stack_top(graph)->links)
416 		media_graph_walk_iter(graph);
417 
418 	entity = stack_pop(graph);
419 	dev_dbg(entity->graph_obj.mdev->dev,
420 		"walk: returning entity '%s'\n", entity->name);
421 
422 	return entity;
423 }
424 EXPORT_SYMBOL_GPL(media_graph_walk_next);
425 
426 /* -----------------------------------------------------------------------------
427  * Pipeline management
428  */
429 
430 /*
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  */
449 struct 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  */
464 struct 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 
476 static struct media_pipeline_walk_entry *
media_pipeline_walk_top(struct media_pipeline_walk * walk)477 media_pipeline_walk_top(struct media_pipeline_walk *walk)
478 {
479 	return &walk->stack.entries[walk->stack.top];
480 }
481 
media_pipeline_walk_empty(struct media_pipeline_walk * walk)482 static 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. */
media_pipeline_walk_resize(struct media_pipeline_walk * walk)488 static 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. */
media_pipeline_walk_push(struct media_pipeline_walk * walk,struct media_pad * pad)512 static 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
538  * have been visited, pop the entry itself. Return true if the entry has been
539  * popped.
540  */
media_pipeline_walk_pop(struct media_pipeline_walk * walk)541 static bool media_pipeline_walk_pop(struct media_pipeline_walk *walk)
542 {
543 	struct media_pipeline_walk_entry *entry;
544 
545 	if (WARN_ON(walk->stack.top < 0))
546 		return false;
547 
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--;
556 		return true;
557 	}
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);
564 
565 	return false;
566 }
567 
568 /* Free all memory allocated while walking the pipeline. */
media_pipeline_walk_destroy(struct media_pipeline_walk * walk)569 static 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. */
media_pipeline_add_pad(struct media_pipeline * pipe,struct media_pipeline_walk * walk,struct media_pad * pad)575 static 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. */
media_pipeline_explore_next_link(struct media_pipeline * pipe,struct media_pipeline_walk * walk)607 static 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);
611 	struct media_pad *origin;
612 	struct media_link *link;
613 	struct media_pad *local;
614 	struct media_pad *remote;
615 	bool last_link;
616 	int ret;
617 
618 	origin = entry->pad;
619 	link = list_entry(entry->links, typeof(*link), list);
620 	last_link = media_pipeline_walk_pop(walk);
621 
622 	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 
628 	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 
633 	/* Get the local pad and remote pad. */
634 	if (link->source->entity == origin->entity) {
635 		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 	 */
646 	if (origin != local &&
647 	    !media_entity_has_pad_interdep(origin->entity, origin->index,
648 					   local->index)) {
649 		dev_dbg(walk->mdev->dev,
650 			"media pipeline: skipping link (no route)\n");
651 		goto done;
652 	}
653 
654 	/*
655 	 * Add the local pad of the link to the pipeline and push it to the
656 	 * stack, if not already present.
657 	 */
658 	ret = media_pipeline_add_pad(pipe, walk, local);
659 	if (ret)
660 		return ret;
661 
662 	/* 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");
666 		goto done;
667 	}
668 
669 	ret = media_pipeline_add_pad(pipe, walk, remote);
670 	if (ret)
671 		return ret;
672 
673 done:
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 
704 	return 0;
705 }
706 
media_pipeline_cleanup(struct media_pipeline * pipe)707 static 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 
media_pipeline_populate(struct media_pipeline * pipe,struct media_pad * pad)718 static 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 
762 done:
763 	media_pipeline_walk_destroy(&walk);
764 
765 	if (ret)
766 		media_pipeline_cleanup(pipe);
767 
768 	return ret;
769 }
770 
__media_pipeline_start(struct media_pad * pad,struct media_pipeline * pipe)771 __must_check int __media_pipeline_start(struct media_pad *pad,
772 					struct media_pipeline *pipe)
773 {
774 	struct media_device *mdev = pad->graph_obj.mdev;
775 	struct media_pipeline_pad *err_ppad;
776 	struct media_pipeline_pad *ppad;
777 	int ret;
778 
779 	lockdep_assert_held(&mdev->graph_mutex);
780 
781 	/*
782 	 * If the pad is already part of a pipeline, that pipeline must be the
783 	 * same as the pipe given to media_pipeline_start().
784 	 */
785 	if (WARN_ON(pad->pipe && pad->pipe != pipe))
786 		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 	 */
792 	if (pipe->start_count) {
793 		pipe->start_count++;
794 		return 0;
795 	}
796 
797 	/*
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 	 */
802 	ret = media_pipeline_populate(pipe, pad);
803 	if (ret)
804 		return ret;
805 
806 	/*
807 	 * Now that all the pads in the pipeline have been gathered, perform
808 	 * the validation steps.
809 	 */
810 
811 	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;
815 		struct media_link *link;
816 
817 		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);
827 			ret = -EBUSY;
828 			goto error;
829 		}
830 
831 		/*
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 		 */
836 		for_each_media_entity_data_link(entity, link) {
837 			/* Skip links unrelated to the current pad. */
838 			if (link->sink != pad && link->source != pad)
839 				continue;
840 
841 			/* Record if the pad has links and enabled links. */
842 			if (link->flags & MEDIA_LNK_FL_ENABLED)
843 				has_enabled_link = true;
844 
845 			/*
846 			 * Validate the link if it's enabled and has the
847 			 * current pad as its sink.
848 			 */
849 			if (!(link->flags & MEDIA_LNK_FL_ENABLED))
850 				continue;
851 
852 			if (link->sink != pad)
853 				continue;
854 
855 			if (!entity->ops || !entity->ops->link_validate)
856 				continue;
857 
858 			ret = entity->ops->link_validate(link);
859 			if (ret) {
860 				dev_dbg(mdev->dev,
861 					"Link '%s':%u -> '%s':%u failed validation: %d\n",
862 					link->source->entity->name,
863 					link->source->index,
864 					link->sink->entity->name,
865 					link->sink->index, ret);
866 				goto error;
867 			}
868 
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);
875 		}
876 
877 		/*
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 		 */
881 		if ((pad->flags & MEDIA_PAD_FL_MUST_CONNECT) &&
882 		    !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);
886 			ret = -ENOLINK;
887 			goto error;
888 		}
889 
890 		/* Validation passed, store the pipe pointer in the pad. */
891 		pad->pipe = pipe;
892 	}
893 
894 	pipe->start_count++;
895 
896 	return 0;
897 
898 error:
899 	/*
900 	 * Link validation on graph failed. We revert what we did and
901 	 * return the error.
902 	 */
903 
904 	list_for_each_entry(err_ppad, &pipe->pads, list) {
905 		if (err_ppad == ppad)
906 			break;
907 
908 		err_ppad->pad->pipe = NULL;
909 	}
910 
911 	media_pipeline_cleanup(pipe);
912 
913 	return ret;
914 }
915 EXPORT_SYMBOL_GPL(__media_pipeline_start);
916 
media_pipeline_start(struct media_pad * pad,struct media_pipeline * pipe)917 __must_check int media_pipeline_start(struct media_pad *pad,
918 				      struct media_pipeline *pipe)
919 {
920 	struct media_device *mdev = pad->graph_obj.mdev;
921 	int ret;
922 
923 	mutex_lock(&mdev->graph_mutex);
924 	ret = __media_pipeline_start(pad, pipe);
925 	mutex_unlock(&mdev->graph_mutex);
926 	return ret;
927 }
928 EXPORT_SYMBOL_GPL(media_pipeline_start);
929 
__media_pipeline_stop(struct media_pad * pad)930 void __media_pipeline_stop(struct media_pad *pad)
931 {
932 	struct media_pipeline *pipe = pad->pipe;
933 	struct media_pipeline_pad *ppad;
934 
935 	/*
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;
941 
942 	if (--pipe->start_count)
943 		return;
944 
945 	list_for_each_entry(ppad, &pipe->pads, list)
946 		ppad->pad->pipe = NULL;
947 
948 	media_pipeline_cleanup(pipe);
949 
950 	if (pipe->allocated)
951 		kfree(pipe);
952 }
953 EXPORT_SYMBOL_GPL(__media_pipeline_stop);
954 
media_pipeline_stop(struct media_pad * pad)955 void media_pipeline_stop(struct media_pad *pad)
956 {
957 	struct media_device *mdev = pad->graph_obj.mdev;
958 
959 	mutex_lock(&mdev->graph_mutex);
960 	__media_pipeline_stop(pad);
961 	mutex_unlock(&mdev->graph_mutex);
962 }
963 EXPORT_SYMBOL_GPL(media_pipeline_stop);
964 
media_pipeline_alloc_start(struct media_pad * pad)965 __must_check int media_pipeline_alloc_start(struct media_pad *pad)
966 {
967 	struct media_device *mdev = pad->graph_obj.mdev;
968 	struct media_pipeline *new_pipe = NULL;
969 	struct media_pipeline *pipe;
970 	int ret;
971 
972 	mutex_lock(&mdev->graph_mutex);
973 
974 	/*
975 	 * Is the pad already part of a pipeline? If not, we need to allocate
976 	 * a pipe.
977 	 */
978 	pipe = media_pad_pipeline(pad);
979 	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 
990 	ret = __media_pipeline_start(pad, pipe);
991 	if (ret)
992 		kfree(new_pipe);
993 
994 out:
995 	mutex_unlock(&mdev->graph_mutex);
996 
997 	return ret;
998 }
999 EXPORT_SYMBOL_GPL(media_pipeline_alloc_start);
1000 
1001 struct media_pad *
__media_pipeline_pad_iter_next(struct media_pipeline * pipe,struct media_pipeline_pad_iter * iter,struct media_pad * 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 }
1017 EXPORT_SYMBOL_GPL(__media_pipeline_pad_iter_next);
1018 
media_pipeline_entity_iter_init(struct media_pipeline * pipe,struct media_pipeline_entity_iter * iter)1019 int 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 }
1024 EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_init);
1025 
media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter * iter)1026 void media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter *iter)
1027 {
1028 	media_entity_enum_cleanup(&iter->ent_enum);
1029 }
1030 EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_cleanup);
1031 
1032 struct media_entity *
__media_pipeline_entity_iter_next(struct media_pipeline * pipe,struct media_pipeline_entity_iter * iter,struct media_entity * 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 }
1054 EXPORT_SYMBOL_GPL(__media_pipeline_entity_iter_next);
1055 
1056 /* -----------------------------------------------------------------------------
1057  * Links management
1058  */
1059 
media_add_link(struct list_head * head)1060 static struct media_link *media_add_link(struct list_head *head)
1061 {
1062 	struct media_link *link;
1063 
1064 	link = kzalloc(sizeof(*link), GFP_KERNEL);
1065 	if (link == NULL)
1066 		return NULL;
1067 
1068 	list_add_tail(&link->list, head);
1069 
1070 	return link;
1071 }
1072 
__media_entity_remove_link(struct media_entity * entity,struct media_link * link)1073 static void __media_entity_remove_link(struct media_entity *entity,
1074 				       struct media_link *link)
1075 {
1076 	struct media_link *rlink, *tmp;
1077 	struct media_entity *remote;
1078 
1079 	/* Remove the reverse links for a data link. */
1080 	if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) == MEDIA_LNK_FL_DATA_LINK) {
1081 		link->source->num_links--;
1082 		link->sink->num_links--;
1083 
1084 		if (link->source->entity == entity)
1085 			remote = link->sink->entity;
1086 		else
1087 			remote = link->source->entity;
1088 
1089 		list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
1090 			if (rlink != link->reverse)
1091 				continue;
1092 
1093 			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 		}
1104 	}
1105 
1106 	list_del(&link->list);
1107 	media_gobj_destroy(&link->graph_obj);
1108 	kfree(link);
1109 }
1110 
media_get_pad_index(struct media_entity * entity,u32 pad_type,enum media_pad_signal_type sig_type)1111 int media_get_pad_index(struct media_entity *entity, u32 pad_type,
1112 			enum media_pad_signal_type sig_type)
1113 {
1114 	unsigned int i;
1115 
1116 	if (!entity)
1117 		return -EINVAL;
1118 
1119 	for (i = 0; i < entity->num_pads; i++) {
1120 		if ((entity->pads[i].flags &
1121 		     (MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_SOURCE)) != pad_type)
1122 			continue;
1123 
1124 		if (entity->pads[i].sig_type == sig_type)
1125 			return i;
1126 	}
1127 	return -EINVAL;
1128 }
1129 EXPORT_SYMBOL_GPL(media_get_pad_index);
1130 
1131 int
media_create_pad_link(struct media_entity * source,u16 source_pad,struct media_entity * sink,u16 sink_pad,u32 flags)1132 media_create_pad_link(struct media_entity *source, u16 source_pad,
1133 			 struct media_entity *sink, u16 sink_pad, u32 flags)
1134 {
1135 	struct media_link *link;
1136 	struct media_link *backlink;
1137 
1138 	if (flags & MEDIA_LNK_FL_LINK_TYPE)
1139 		return -EINVAL;
1140 
1141 	flags |= MEDIA_LNK_FL_DATA_LINK;
1142 
1143 	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;
1151 
1152 	link = media_add_link(&source->links);
1153 	if (link == NULL)
1154 		return -ENOMEM;
1155 
1156 	link->source = &source->pads[source_pad];
1157 	link->sink = &sink->pads[sink_pad];
1158 	link->flags = flags;
1159 
1160 	/* Initialize graph object embedded at the new link */
1161 	media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
1162 			&link->graph_obj);
1163 
1164 	/* Create the backlink. Backlinks are used to help graph traversal and
1165 	 * are not reported to userspace.
1166 	 */
1167 	backlink = media_add_link(&sink->links);
1168 	if (backlink == NULL) {
1169 		__media_entity_remove_link(source, link);
1170 		return -ENOMEM;
1171 	}
1172 
1173 	backlink->source = &source->pads[source_pad];
1174 	backlink->sink = &sink->pads[sink_pad];
1175 	backlink->flags = flags;
1176 	backlink->is_backlink = true;
1177 
1178 	/* Initialize graph object embedded at the new link */
1179 	media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
1180 			&backlink->graph_obj);
1181 
1182 	link->reverse = backlink;
1183 	backlink->reverse = link;
1184 
1185 	sink->num_backlinks++;
1186 	sink->num_links++;
1187 	source->num_links++;
1188 
1189 	link->source->num_links++;
1190 	link->sink->num_links++;
1191 
1192 	return 0;
1193 }
1194 EXPORT_SYMBOL_GPL(media_create_pad_link);
1195 
media_create_pad_links(const struct media_device * mdev,const u32 source_function,struct media_entity * source,const u16 source_pad,const u32 sink_function,struct media_entity * sink,const u16 sink_pad,u32 flags,const bool allow_both_undefined)1196 int 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 }
1259 EXPORT_SYMBOL_GPL(media_create_pad_links);
1260 
__media_entity_remove_links(struct media_entity * entity)1261 void __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);
1267 
1268 	entity->num_links = 0;
1269 	entity->num_backlinks = 0;
1270 }
1271 EXPORT_SYMBOL_GPL(__media_entity_remove_links);
1272 
media_entity_remove_links(struct media_entity * entity)1273 void media_entity_remove_links(struct media_entity *entity)
1274 {
1275 	struct media_device *mdev = entity->graph_obj.mdev;
1276 
1277 	/* Do nothing if the entity is not registered. */
1278 	if (mdev == NULL)
1279 		return;
1280 
1281 	mutex_lock(&mdev->graph_mutex);
1282 	__media_entity_remove_links(entity);
1283 	mutex_unlock(&mdev->graph_mutex);
1284 }
1285 EXPORT_SYMBOL_GPL(media_entity_remove_links);
1286 
__media_entity_setup_link_notify(struct media_link * link,u32 flags)1287 static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
1288 {
1289 	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 
1305 	link->flags = flags;
1306 	link->reverse->flags = link->flags;
1307 
1308 	return 0;
1309 }
1310 
__media_entity_setup_link(struct media_link * link,u32 flags)1311 int __media_entity_setup_link(struct media_link *link, u32 flags)
1312 {
1313 	const u32 mask = MEDIA_LNK_FL_ENABLED;
1314 	struct media_device *mdev;
1315 	struct media_pad *source, *sink;
1316 	int ret = -EBUSY;
1317 
1318 	if (link == NULL)
1319 		return -EINVAL;
1320 
1321 	/* The non-modifiable link flags must not be modified. */
1322 	if ((link->flags & ~mask) != (flags & ~mask))
1323 		return -EINVAL;
1324 
1325 	if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
1326 		return link->flags == flags ? 0 : -EINVAL;
1327 
1328 	if (link->flags == flags)
1329 		return 0;
1330 
1331 	source = link->source;
1332 	sink = link->sink;
1333 
1334 	if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) &&
1335 	    (media_pad_is_streaming(source) || media_pad_is_streaming(sink)))
1336 		return -EBUSY;
1337 
1338 	mdev = source->graph_obj.mdev;
1339 
1340 	if (mdev->ops && mdev->ops->link_notify) {
1341 		ret = mdev->ops->link_notify(link, flags,
1342 					     MEDIA_DEV_NOTIFY_PRE_LINK_CH);
1343 		if (ret < 0)
1344 			return ret;
1345 	}
1346 
1347 	ret = __media_entity_setup_link_notify(link, flags);
1348 
1349 	if (mdev->ops && mdev->ops->link_notify)
1350 		mdev->ops->link_notify(link, flags,
1351 				       MEDIA_DEV_NOTIFY_POST_LINK_CH);
1352 
1353 	return ret;
1354 }
1355 EXPORT_SYMBOL_GPL(__media_entity_setup_link);
1356 
media_entity_setup_link(struct media_link * link,u32 flags)1357 int media_entity_setup_link(struct media_link *link, u32 flags)
1358 {
1359 	int ret;
1360 
1361 	mutex_lock(&link->graph_obj.mdev->graph_mutex);
1362 	ret = __media_entity_setup_link(link, flags);
1363 	mutex_unlock(&link->graph_obj.mdev->graph_mutex);
1364 
1365 	return ret;
1366 }
1367 EXPORT_SYMBOL_GPL(media_entity_setup_link);
1368 
1369 struct media_link *
media_entity_find_link(struct media_pad * source,struct media_pad * sink)1370 media_entity_find_link(struct media_pad *source, struct media_pad *sink)
1371 {
1372 	struct media_link *link;
1373 
1374 	for_each_media_entity_data_link(source->entity, link) {
1375 		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 }
1384 EXPORT_SYMBOL_GPL(media_entity_find_link);
1385 
media_pad_remote_pad_first(const struct media_pad * pad)1386 struct media_pad *media_pad_remote_pad_first(const struct media_pad *pad)
1387 {
1388 	struct media_link *link;
1389 
1390 	for_each_media_entity_data_link(pad->entity, link) {
1391 		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 }
1404 EXPORT_SYMBOL_GPL(media_pad_remote_pad_first);
1405 
1406 struct media_pad *
media_entity_remote_pad_unique(const struct media_entity * entity,unsigned int type)1407 media_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 }
1443 EXPORT_SYMBOL_GPL(media_entity_remote_pad_unique);
1444 
media_pad_remote_pad_unique(const struct media_pad * pad)1445 struct 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 }
1474 EXPORT_SYMBOL_GPL(media_pad_remote_pad_unique);
1475 
media_entity_get_fwnode_pad(struct media_entity * entity,const struct fwnode_handle * fwnode,unsigned long direction_flags)1476 int media_entity_get_fwnode_pad(struct media_entity *entity,
1477 				const struct fwnode_handle *fwnode,
1478 				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 }
1509 EXPORT_SYMBOL_GPL(media_entity_get_fwnode_pad);
1510 
media_entity_pipeline(struct media_entity * entity)1511 struct media_pipeline *media_entity_pipeline(struct media_entity *entity)
1512 {
1513 	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;
1521 }
1522 EXPORT_SYMBOL_GPL(media_entity_pipeline);
1523 
media_pad_pipeline(struct media_pad * pad)1524 struct media_pipeline *media_pad_pipeline(struct media_pad *pad)
1525 {
1526 	return pad->pipe;
1527 }
1528 EXPORT_SYMBOL_GPL(media_pad_pipeline);
1529 
media_interface_init(struct media_device * mdev,struct media_interface * intf,u32 gobj_type,u32 intf_type,u32 flags)1530 static 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 
1539 	media_gobj_create(mdev, gobj_type, &intf->graph_obj);
1540 }
1541 
1542 /* Functions related to the media interface via device nodes */
1543 
media_devnode_create(struct media_device * mdev,u32 type,u32 flags,u32 major,u32 minor)1544 struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
1545 						u32 type, u32 flags,
1546 						u32 major, u32 minor)
1547 {
1548 	struct media_intf_devnode *devnode;
1549 
1550 	devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
1551 	if (!devnode)
1552 		return NULL;
1553 
1554 	devnode->major = major;
1555 	devnode->minor = minor;
1556 
1557 	media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
1558 			     type, flags);
1559 
1560 	return devnode;
1561 }
1562 EXPORT_SYMBOL_GPL(media_devnode_create);
1563 
media_devnode_remove(struct media_intf_devnode * devnode)1564 void media_devnode_remove(struct media_intf_devnode *devnode)
1565 {
1566 	media_remove_intf_links(&devnode->intf);
1567 	media_gobj_destroy(&devnode->intf.graph_obj);
1568 	kfree(devnode);
1569 }
1570 EXPORT_SYMBOL_GPL(media_devnode_remove);
1571 
media_create_intf_link(struct media_entity * entity,struct media_interface * intf,u32 flags)1572 struct 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;
1584 	link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK;
1585 
1586 	/* Initialize graph object embedded at the new link */
1587 	media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
1588 			&link->graph_obj);
1589 
1590 	return link;
1591 }
1592 EXPORT_SYMBOL_GPL(media_create_intf_link);
1593 
__media_remove_intf_link(struct media_link * link)1594 void __media_remove_intf_link(struct media_link *link)
1595 {
1596 	list_del(&link->list);
1597 	media_gobj_destroy(&link->graph_obj);
1598 	kfree(link);
1599 }
1600 EXPORT_SYMBOL_GPL(__media_remove_intf_link);
1601 
media_remove_intf_link(struct media_link * link)1602 void media_remove_intf_link(struct media_link *link)
1603 {
1604 	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 
1610 	mutex_lock(&mdev->graph_mutex);
1611 	__media_remove_intf_link(link);
1612 	mutex_unlock(&mdev->graph_mutex);
1613 }
1614 EXPORT_SYMBOL_GPL(media_remove_intf_link);
1615 
__media_remove_intf_links(struct media_interface * intf)1616 void __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 }
1624 EXPORT_SYMBOL_GPL(__media_remove_intf_links);
1625 
media_remove_intf_links(struct media_interface * intf)1626 void media_remove_intf_links(struct media_interface *intf)
1627 {
1628 	struct media_device *mdev = intf->graph_obj.mdev;
1629 
1630 	/* Do nothing if the intf is not registered. */
1631 	if (mdev == NULL)
1632 		return;
1633 
1634 	mutex_lock(&mdev->graph_mutex);
1635 	__media_remove_intf_links(intf);
1636 	mutex_unlock(&mdev->graph_mutex);
1637 }
1638 EXPORT_SYMBOL_GPL(media_remove_intf_links);
1639 
media_create_ancillary_link(struct media_entity * primary,struct media_entity * ancillary)1640 struct 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 }
1660 EXPORT_SYMBOL_GPL(media_create_ancillary_link);
1661 
__media_entity_next_link(struct media_entity * entity,struct media_link * link,unsigned long link_type)1662 struct 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 }
1675 EXPORT_SYMBOL_GPL(__media_entity_next_link);
1676