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 dev_dbg(walk->mdev->dev,
623 "media pipeline: exploring link '%s':%u -> '%s':%u\n",
624 link->source->entity->name, link->source->index,
625 link->sink->entity->name, link->sink->index);
626
627 /* Get the local pad and remote pad. */
628 if (link->source->entity == origin->entity) {
629 local = link->source;
630 remote = link->sink;
631 } else {
632 local = link->sink;
633 remote = link->source;
634 }
635
636 /*
637 * Skip links that originate from a different pad than the incoming pad
638 * that is not connected internally in the entity to the incoming pad.
639 */
640 if (origin != local &&
641 !media_entity_has_pad_interdep(origin->entity, origin->index,
642 local->index)) {
643 dev_dbg(walk->mdev->dev,
644 "media pipeline: skipping link (no route)\n");
645 goto done;
646 }
647
648 /*
649 * Add the local pad of the link to the pipeline and push it to the
650 * stack, if not already present.
651 */
652 ret = media_pipeline_add_pad(pipe, walk, local);
653 if (ret)
654 return ret;
655
656 /* Similarly, add the remote pad, but only if the link is enabled. */
657 if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
658 dev_dbg(walk->mdev->dev,
659 "media pipeline: skipping link (disabled)\n");
660 goto done;
661 }
662
663 ret = media_pipeline_add_pad(pipe, walk, remote);
664 if (ret)
665 return ret;
666
667 done:
668 /*
669 * If we're done iterating over links, iterate over pads of the entity.
670 * This is necessary to discover pads that are not connected with any
671 * link. Those are dead ends from a pipeline exploration point of view,
672 * but are still part of the pipeline and need to be added to enable
673 * proper validation.
674 */
675 if (!last_link)
676 return 0;
677
678 dev_dbg(walk->mdev->dev,
679 "media pipeline: adding unconnected pads of '%s'\n",
680 local->entity->name);
681
682 media_entity_for_each_pad(origin->entity, local) {
683 /*
684 * Skip the origin pad (already handled), pad that have links
685 * (already discovered through iterating over links) and pads
686 * not internally connected.
687 */
688 if (origin == local || !local->num_links ||
689 !media_entity_has_pad_interdep(origin->entity, origin->index,
690 local->index))
691 continue;
692
693 ret = media_pipeline_add_pad(pipe, walk, local);
694 if (ret)
695 return ret;
696 }
697
698 return 0;
699 }
700
media_pipeline_cleanup(struct media_pipeline * pipe)701 static void media_pipeline_cleanup(struct media_pipeline *pipe)
702 {
703 while (!list_empty(&pipe->pads)) {
704 struct media_pipeline_pad *ppad;
705
706 ppad = list_first_entry(&pipe->pads, typeof(*ppad), list);
707 list_del(&ppad->list);
708 kfree(ppad);
709 }
710 }
711
media_pipeline_populate(struct media_pipeline * pipe,struct media_pad * pad)712 static int media_pipeline_populate(struct media_pipeline *pipe,
713 struct media_pad *pad)
714 {
715 struct media_pipeline_walk walk = { };
716 struct media_pipeline_pad *ppad;
717 int ret;
718
719 /*
720 * Populate the media pipeline by walking the media graph, starting
721 * from @pad.
722 */
723 INIT_LIST_HEAD(&pipe->pads);
724 pipe->mdev = pad->graph_obj.mdev;
725
726 walk.mdev = pipe->mdev;
727 walk.stack.top = -1;
728 ret = media_pipeline_add_pad(pipe, &walk, pad);
729 if (ret)
730 goto done;
731
732 /*
733 * Use a depth-first search algorithm: as long as the stack is not
734 * empty, explore the next link of the top entry. The
735 * media_pipeline_explore_next_link() function will either move to the
736 * next link, pop the entry if fully visited, or add new entries on
737 * top.
738 */
739 while (!media_pipeline_walk_empty(&walk)) {
740 ret = media_pipeline_explore_next_link(pipe, &walk);
741 if (ret)
742 goto done;
743 }
744
745 dev_dbg(pad->graph_obj.mdev->dev,
746 "media pipeline populated, found pads:\n");
747
748 list_for_each_entry(ppad, &pipe->pads, list)
749 dev_dbg(pad->graph_obj.mdev->dev, "- '%s':%u\n",
750 ppad->pad->entity->name, ppad->pad->index);
751
752 WARN_ON(walk.stack.top != -1);
753
754 ret = 0;
755
756 done:
757 media_pipeline_walk_destroy(&walk);
758
759 if (ret)
760 media_pipeline_cleanup(pipe);
761
762 return ret;
763 }
764
__media_pipeline_start(struct media_pad * pad,struct media_pipeline * pipe)765 __must_check int __media_pipeline_start(struct media_pad *pad,
766 struct media_pipeline *pipe)
767 {
768 struct media_device *mdev = pad->graph_obj.mdev;
769 struct media_pipeline_pad *err_ppad;
770 struct media_pipeline_pad *ppad;
771 int ret;
772
773 lockdep_assert_held(&mdev->graph_mutex);
774
775 /*
776 * If the pad is already part of a pipeline, that pipeline must be the
777 * same as the pipe given to media_pipeline_start().
778 */
779 if (WARN_ON(pad->pipe && pad->pipe != pipe))
780 return -EINVAL;
781
782 /*
783 * If the pipeline has already been started, it is guaranteed to be
784 * valid, so just increase the start count.
785 */
786 if (pipe->start_count) {
787 pipe->start_count++;
788 return 0;
789 }
790
791 /*
792 * Populate the pipeline. This populates the media_pipeline pads list
793 * with media_pipeline_pad instances for each pad found during graph
794 * walk.
795 */
796 ret = media_pipeline_populate(pipe, pad);
797 if (ret)
798 return ret;
799
800 /*
801 * Now that all the pads in the pipeline have been gathered, perform
802 * the validation steps.
803 */
804
805 list_for_each_entry(ppad, &pipe->pads, list) {
806 struct media_pad *pad = ppad->pad;
807 struct media_entity *entity = pad->entity;
808 bool has_enabled_link = false;
809 struct media_link *link;
810
811 dev_dbg(mdev->dev, "Validating pad '%s':%u\n", pad->entity->name,
812 pad->index);
813
814 /*
815 * 1. Ensure that the pad doesn't already belong to a different
816 * pipeline.
817 */
818 if (pad->pipe) {
819 dev_dbg(mdev->dev, "Failed to start pipeline: pad '%s':%u busy\n",
820 pad->entity->name, pad->index);
821 ret = -EBUSY;
822 goto error;
823 }
824
825 /*
826 * 2. Validate all active links whose sink is the current pad.
827 * Validation of the source pads is performed in the context of
828 * the connected sink pad to avoid duplicating checks.
829 */
830 for_each_media_entity_data_link(entity, link) {
831 /* Skip links unrelated to the current pad. */
832 if (link->sink != pad && link->source != pad)
833 continue;
834
835 /* Record if the pad has links and enabled links. */
836 if (link->flags & MEDIA_LNK_FL_ENABLED)
837 has_enabled_link = true;
838
839 /*
840 * Validate the link if it's enabled and has the
841 * current pad as its sink.
842 */
843 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
844 continue;
845
846 if (link->sink != pad)
847 continue;
848
849 if (!entity->ops || !entity->ops->link_validate)
850 continue;
851
852 ret = entity->ops->link_validate(link);
853 if (ret) {
854 dev_dbg(mdev->dev,
855 "Link '%s':%u -> '%s':%u failed validation: %d\n",
856 link->source->entity->name,
857 link->source->index,
858 link->sink->entity->name,
859 link->sink->index, ret);
860 goto error;
861 }
862
863 dev_dbg(mdev->dev,
864 "Link '%s':%u -> '%s':%u is valid\n",
865 link->source->entity->name,
866 link->source->index,
867 link->sink->entity->name,
868 link->sink->index);
869 }
870
871 /*
872 * 3. If the pad has the MEDIA_PAD_FL_MUST_CONNECT flag set,
873 * ensure that it has either no link or an enabled link.
874 */
875 if ((pad->flags & MEDIA_PAD_FL_MUST_CONNECT) &&
876 !has_enabled_link) {
877 dev_dbg(mdev->dev,
878 "Pad '%s':%u must be connected by an enabled link\n",
879 pad->entity->name, pad->index);
880 ret = -ENOLINK;
881 goto error;
882 }
883
884 /* Validation passed, store the pipe pointer in the pad. */
885 pad->pipe = pipe;
886 }
887
888 pipe->start_count++;
889
890 return 0;
891
892 error:
893 /*
894 * Link validation on graph failed. We revert what we did and
895 * return the error.
896 */
897
898 list_for_each_entry(err_ppad, &pipe->pads, list) {
899 if (err_ppad == ppad)
900 break;
901
902 err_ppad->pad->pipe = NULL;
903 }
904
905 media_pipeline_cleanup(pipe);
906
907 return ret;
908 }
909 EXPORT_SYMBOL_GPL(__media_pipeline_start);
910
media_pipeline_start(struct media_pad * pad,struct media_pipeline * pipe)911 __must_check int media_pipeline_start(struct media_pad *pad,
912 struct media_pipeline *pipe)
913 {
914 struct media_device *mdev = pad->graph_obj.mdev;
915 int ret;
916
917 mutex_lock(&mdev->graph_mutex);
918 ret = __media_pipeline_start(pad, pipe);
919 mutex_unlock(&mdev->graph_mutex);
920 return ret;
921 }
922 EXPORT_SYMBOL_GPL(media_pipeline_start);
923
__media_pipeline_stop(struct media_pad * pad)924 void __media_pipeline_stop(struct media_pad *pad)
925 {
926 struct media_pipeline *pipe = pad->pipe;
927 struct media_pipeline_pad *ppad;
928
929 /*
930 * If the following check fails, the driver has performed an
931 * unbalanced call to media_pipeline_stop()
932 */
933 if (WARN_ON(!pipe))
934 return;
935
936 if (--pipe->start_count)
937 return;
938
939 list_for_each_entry(ppad, &pipe->pads, list)
940 ppad->pad->pipe = NULL;
941
942 media_pipeline_cleanup(pipe);
943
944 if (pipe->allocated)
945 kfree(pipe);
946 }
947 EXPORT_SYMBOL_GPL(__media_pipeline_stop);
948
media_pipeline_stop(struct media_pad * pad)949 void media_pipeline_stop(struct media_pad *pad)
950 {
951 struct media_device *mdev = pad->graph_obj.mdev;
952
953 mutex_lock(&mdev->graph_mutex);
954 __media_pipeline_stop(pad);
955 mutex_unlock(&mdev->graph_mutex);
956 }
957 EXPORT_SYMBOL_GPL(media_pipeline_stop);
958
media_pipeline_alloc_start(struct media_pad * pad)959 __must_check int media_pipeline_alloc_start(struct media_pad *pad)
960 {
961 struct media_device *mdev = pad->graph_obj.mdev;
962 struct media_pipeline *new_pipe = NULL;
963 struct media_pipeline *pipe;
964 int ret;
965
966 mutex_lock(&mdev->graph_mutex);
967
968 /*
969 * Is the pad already part of a pipeline? If not, we need to allocate
970 * a pipe.
971 */
972 pipe = media_pad_pipeline(pad);
973 if (!pipe) {
974 new_pipe = kzalloc(sizeof(*new_pipe), GFP_KERNEL);
975 if (!new_pipe) {
976 ret = -ENOMEM;
977 goto out;
978 }
979
980 pipe = new_pipe;
981 pipe->allocated = true;
982 }
983
984 ret = __media_pipeline_start(pad, pipe);
985 if (ret)
986 kfree(new_pipe);
987
988 out:
989 mutex_unlock(&mdev->graph_mutex);
990
991 return ret;
992 }
993 EXPORT_SYMBOL_GPL(media_pipeline_alloc_start);
994
995 struct media_pad *
__media_pipeline_pad_iter_next(struct media_pipeline * pipe,struct media_pipeline_pad_iter * iter,struct media_pad * pad)996 __media_pipeline_pad_iter_next(struct media_pipeline *pipe,
997 struct media_pipeline_pad_iter *iter,
998 struct media_pad *pad)
999 {
1000 if (!pad)
1001 iter->cursor = pipe->pads.next;
1002
1003 if (iter->cursor == &pipe->pads)
1004 return NULL;
1005
1006 pad = list_entry(iter->cursor, struct media_pipeline_pad, list)->pad;
1007 iter->cursor = iter->cursor->next;
1008
1009 return pad;
1010 }
1011 EXPORT_SYMBOL_GPL(__media_pipeline_pad_iter_next);
1012
media_pipeline_entity_iter_init(struct media_pipeline * pipe,struct media_pipeline_entity_iter * iter)1013 int media_pipeline_entity_iter_init(struct media_pipeline *pipe,
1014 struct media_pipeline_entity_iter *iter)
1015 {
1016 return media_entity_enum_init(&iter->ent_enum, pipe->mdev);
1017 }
1018 EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_init);
1019
media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter * iter)1020 void media_pipeline_entity_iter_cleanup(struct media_pipeline_entity_iter *iter)
1021 {
1022 media_entity_enum_cleanup(&iter->ent_enum);
1023 }
1024 EXPORT_SYMBOL_GPL(media_pipeline_entity_iter_cleanup);
1025
1026 struct media_entity *
__media_pipeline_entity_iter_next(struct media_pipeline * pipe,struct media_pipeline_entity_iter * iter,struct media_entity * entity)1027 __media_pipeline_entity_iter_next(struct media_pipeline *pipe,
1028 struct media_pipeline_entity_iter *iter,
1029 struct media_entity *entity)
1030 {
1031 if (!entity)
1032 iter->cursor = pipe->pads.next;
1033
1034 while (iter->cursor != &pipe->pads) {
1035 struct media_pipeline_pad *ppad;
1036 struct media_entity *entity;
1037
1038 ppad = list_entry(iter->cursor, struct media_pipeline_pad, list);
1039 entity = ppad->pad->entity;
1040 iter->cursor = iter->cursor->next;
1041
1042 if (!media_entity_enum_test_and_set(&iter->ent_enum, entity))
1043 return entity;
1044 }
1045
1046 return NULL;
1047 }
1048 EXPORT_SYMBOL_GPL(__media_pipeline_entity_iter_next);
1049
1050 /* -----------------------------------------------------------------------------
1051 * Links management
1052 */
1053
media_add_link(struct list_head * head)1054 static struct media_link *media_add_link(struct list_head *head)
1055 {
1056 struct media_link *link;
1057
1058 link = kzalloc(sizeof(*link), GFP_KERNEL);
1059 if (link == NULL)
1060 return NULL;
1061
1062 list_add_tail(&link->list, head);
1063
1064 return link;
1065 }
1066
__media_entity_remove_link(struct media_entity * entity,struct media_link * link)1067 static void __media_entity_remove_link(struct media_entity *entity,
1068 struct media_link *link)
1069 {
1070 struct media_link *rlink, *tmp;
1071 struct media_entity *remote;
1072
1073 /* Remove the reverse links for a data link. */
1074 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) == MEDIA_LNK_FL_DATA_LINK) {
1075 link->source->num_links--;
1076 link->sink->num_links--;
1077
1078 if (link->source->entity == entity)
1079 remote = link->sink->entity;
1080 else
1081 remote = link->source->entity;
1082
1083 list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
1084 if (rlink != link->reverse)
1085 continue;
1086
1087 if (link->source->entity == entity)
1088 remote->num_backlinks--;
1089
1090 /* Remove the remote link */
1091 list_del(&rlink->list);
1092 media_gobj_destroy(&rlink->graph_obj);
1093 kfree(rlink);
1094
1095 if (--remote->num_links == 0)
1096 break;
1097 }
1098 }
1099
1100 list_del(&link->list);
1101 media_gobj_destroy(&link->graph_obj);
1102 kfree(link);
1103 }
1104
media_get_pad_index(struct media_entity * entity,u32 pad_type,enum media_pad_signal_type sig_type)1105 int media_get_pad_index(struct media_entity *entity, u32 pad_type,
1106 enum media_pad_signal_type sig_type)
1107 {
1108 unsigned int i;
1109
1110 if (!entity)
1111 return -EINVAL;
1112
1113 for (i = 0; i < entity->num_pads; i++) {
1114 if ((entity->pads[i].flags &
1115 (MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_SOURCE)) != pad_type)
1116 continue;
1117
1118 if (entity->pads[i].sig_type == sig_type)
1119 return i;
1120 }
1121 return -EINVAL;
1122 }
1123 EXPORT_SYMBOL_GPL(media_get_pad_index);
1124
1125 int
media_create_pad_link(struct media_entity * source,u16 source_pad,struct media_entity * sink,u16 sink_pad,u32 flags)1126 media_create_pad_link(struct media_entity *source, u16 source_pad,
1127 struct media_entity *sink, u16 sink_pad, u32 flags)
1128 {
1129 struct media_link *link;
1130 struct media_link *backlink;
1131
1132 if (flags & MEDIA_LNK_FL_LINK_TYPE)
1133 return -EINVAL;
1134
1135 flags |= MEDIA_LNK_FL_DATA_LINK;
1136
1137 if (WARN_ON(!source || !sink) ||
1138 WARN_ON(source_pad >= source->num_pads) ||
1139 WARN_ON(sink_pad >= sink->num_pads))
1140 return -EINVAL;
1141 if (WARN_ON(!(source->pads[source_pad].flags & MEDIA_PAD_FL_SOURCE)))
1142 return -EINVAL;
1143 if (WARN_ON(!(sink->pads[sink_pad].flags & MEDIA_PAD_FL_SINK)))
1144 return -EINVAL;
1145
1146 link = media_add_link(&source->links);
1147 if (link == NULL)
1148 return -ENOMEM;
1149
1150 link->source = &source->pads[source_pad];
1151 link->sink = &sink->pads[sink_pad];
1152 link->flags = flags;
1153
1154 /* Initialize graph object embedded at the new link */
1155 media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
1156 &link->graph_obj);
1157
1158 /* Create the backlink. Backlinks are used to help graph traversal and
1159 * are not reported to userspace.
1160 */
1161 backlink = media_add_link(&sink->links);
1162 if (backlink == NULL) {
1163 __media_entity_remove_link(source, link);
1164 return -ENOMEM;
1165 }
1166
1167 backlink->source = &source->pads[source_pad];
1168 backlink->sink = &sink->pads[sink_pad];
1169 backlink->flags = flags;
1170 backlink->is_backlink = true;
1171
1172 /* Initialize graph object embedded at the new link */
1173 media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
1174 &backlink->graph_obj);
1175
1176 link->reverse = backlink;
1177 backlink->reverse = link;
1178
1179 sink->num_backlinks++;
1180 sink->num_links++;
1181 source->num_links++;
1182
1183 link->source->num_links++;
1184 link->sink->num_links++;
1185
1186 return 0;
1187 }
1188 EXPORT_SYMBOL_GPL(media_create_pad_link);
1189
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)1190 int media_create_pad_links(const struct media_device *mdev,
1191 const u32 source_function,
1192 struct media_entity *source,
1193 const u16 source_pad,
1194 const u32 sink_function,
1195 struct media_entity *sink,
1196 const u16 sink_pad,
1197 u32 flags,
1198 const bool allow_both_undefined)
1199 {
1200 struct media_entity *entity;
1201 unsigned function;
1202 int ret;
1203
1204 /* Trivial case: 1:1 relation */
1205 if (source && sink)
1206 return media_create_pad_link(source, source_pad,
1207 sink, sink_pad, flags);
1208
1209 /* Worse case scenario: n:n relation */
1210 if (!source && !sink) {
1211 if (!allow_both_undefined)
1212 return 0;
1213 media_device_for_each_entity(source, mdev) {
1214 if (source->function != source_function)
1215 continue;
1216 media_device_for_each_entity(sink, mdev) {
1217 if (sink->function != sink_function)
1218 continue;
1219 ret = media_create_pad_link(source, source_pad,
1220 sink, sink_pad,
1221 flags);
1222 if (ret)
1223 return ret;
1224 flags &= ~(MEDIA_LNK_FL_ENABLED |
1225 MEDIA_LNK_FL_IMMUTABLE);
1226 }
1227 }
1228 return 0;
1229 }
1230
1231 /* Handle 1:n and n:1 cases */
1232 if (source)
1233 function = sink_function;
1234 else
1235 function = source_function;
1236
1237 media_device_for_each_entity(entity, mdev) {
1238 if (entity->function != function)
1239 continue;
1240
1241 if (source)
1242 ret = media_create_pad_link(source, source_pad,
1243 entity, sink_pad, flags);
1244 else
1245 ret = media_create_pad_link(entity, source_pad,
1246 sink, sink_pad, flags);
1247 if (ret)
1248 return ret;
1249 flags &= ~(MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
1250 }
1251 return 0;
1252 }
1253 EXPORT_SYMBOL_GPL(media_create_pad_links);
1254
__media_entity_remove_links(struct media_entity * entity)1255 void __media_entity_remove_links(struct media_entity *entity)
1256 {
1257 struct media_link *link, *tmp;
1258
1259 list_for_each_entry_safe(link, tmp, &entity->links, list)
1260 __media_entity_remove_link(entity, link);
1261
1262 entity->num_links = 0;
1263 entity->num_backlinks = 0;
1264 }
1265 EXPORT_SYMBOL_GPL(__media_entity_remove_links);
1266
media_entity_remove_links(struct media_entity * entity)1267 void media_entity_remove_links(struct media_entity *entity)
1268 {
1269 struct media_device *mdev = entity->graph_obj.mdev;
1270
1271 /* Do nothing if the entity is not registered. */
1272 if (mdev == NULL)
1273 return;
1274
1275 mutex_lock(&mdev->graph_mutex);
1276 __media_entity_remove_links(entity);
1277 mutex_unlock(&mdev->graph_mutex);
1278 }
1279 EXPORT_SYMBOL_GPL(media_entity_remove_links);
1280
__media_entity_setup_link_notify(struct media_link * link,u32 flags)1281 static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
1282 {
1283 int ret;
1284
1285 /* Notify both entities. */
1286 ret = media_entity_call(link->source->entity, link_setup,
1287 link->source, link->sink, flags);
1288 if (ret < 0 && ret != -ENOIOCTLCMD)
1289 return ret;
1290
1291 ret = media_entity_call(link->sink->entity, link_setup,
1292 link->sink, link->source, flags);
1293 if (ret < 0 && ret != -ENOIOCTLCMD) {
1294 media_entity_call(link->source->entity, link_setup,
1295 link->source, link->sink, link->flags);
1296 return ret;
1297 }
1298
1299 link->flags = flags;
1300 link->reverse->flags = link->flags;
1301
1302 return 0;
1303 }
1304
__media_entity_setup_link(struct media_link * link,u32 flags)1305 int __media_entity_setup_link(struct media_link *link, u32 flags)
1306 {
1307 const u32 mask = MEDIA_LNK_FL_ENABLED;
1308 struct media_device *mdev;
1309 struct media_pad *source, *sink;
1310 int ret = -EBUSY;
1311
1312 if (link == NULL)
1313 return -EINVAL;
1314
1315 /* The non-modifiable link flags must not be modified. */
1316 if ((link->flags & ~mask) != (flags & ~mask))
1317 return -EINVAL;
1318
1319 if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
1320 return link->flags == flags ? 0 : -EINVAL;
1321
1322 if (link->flags == flags)
1323 return 0;
1324
1325 source = link->source;
1326 sink = link->sink;
1327
1328 if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) &&
1329 (media_pad_is_streaming(source) || media_pad_is_streaming(sink)))
1330 return -EBUSY;
1331
1332 mdev = source->graph_obj.mdev;
1333
1334 if (mdev->ops && mdev->ops->link_notify) {
1335 ret = mdev->ops->link_notify(link, flags,
1336 MEDIA_DEV_NOTIFY_PRE_LINK_CH);
1337 if (ret < 0)
1338 return ret;
1339 }
1340
1341 ret = __media_entity_setup_link_notify(link, flags);
1342
1343 if (mdev->ops && mdev->ops->link_notify)
1344 mdev->ops->link_notify(link, flags,
1345 MEDIA_DEV_NOTIFY_POST_LINK_CH);
1346
1347 return ret;
1348 }
1349 EXPORT_SYMBOL_GPL(__media_entity_setup_link);
1350
media_entity_setup_link(struct media_link * link,u32 flags)1351 int media_entity_setup_link(struct media_link *link, u32 flags)
1352 {
1353 int ret;
1354
1355 mutex_lock(&link->graph_obj.mdev->graph_mutex);
1356 ret = __media_entity_setup_link(link, flags);
1357 mutex_unlock(&link->graph_obj.mdev->graph_mutex);
1358
1359 return ret;
1360 }
1361 EXPORT_SYMBOL_GPL(media_entity_setup_link);
1362
1363 struct media_link *
media_entity_find_link(struct media_pad * source,struct media_pad * sink)1364 media_entity_find_link(struct media_pad *source, struct media_pad *sink)
1365 {
1366 struct media_link *link;
1367
1368 for_each_media_entity_data_link(source->entity, link) {
1369 if (link->source->entity == source->entity &&
1370 link->source->index == source->index &&
1371 link->sink->entity == sink->entity &&
1372 link->sink->index == sink->index)
1373 return link;
1374 }
1375
1376 return NULL;
1377 }
1378 EXPORT_SYMBOL_GPL(media_entity_find_link);
1379
media_pad_remote_pad_first(const struct media_pad * pad)1380 struct media_pad *media_pad_remote_pad_first(const struct media_pad *pad)
1381 {
1382 struct media_link *link;
1383
1384 for_each_media_entity_data_link(pad->entity, link) {
1385 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
1386 continue;
1387
1388 if (link->source == pad)
1389 return link->sink;
1390
1391 if (link->sink == pad)
1392 return link->source;
1393 }
1394
1395 return NULL;
1396
1397 }
1398 EXPORT_SYMBOL_GPL(media_pad_remote_pad_first);
1399
1400 struct media_pad *
media_entity_remote_pad_unique(const struct media_entity * entity,unsigned int type)1401 media_entity_remote_pad_unique(const struct media_entity *entity,
1402 unsigned int type)
1403 {
1404 struct media_pad *pad = NULL;
1405 struct media_link *link;
1406
1407 list_for_each_entry(link, &entity->links, list) {
1408 struct media_pad *local_pad;
1409 struct media_pad *remote_pad;
1410
1411 if (((link->flags & MEDIA_LNK_FL_LINK_TYPE) !=
1412 MEDIA_LNK_FL_DATA_LINK) ||
1413 !(link->flags & MEDIA_LNK_FL_ENABLED))
1414 continue;
1415
1416 if (type == MEDIA_PAD_FL_SOURCE) {
1417 local_pad = link->sink;
1418 remote_pad = link->source;
1419 } else {
1420 local_pad = link->source;
1421 remote_pad = link->sink;
1422 }
1423
1424 if (local_pad->entity == entity) {
1425 if (pad)
1426 return ERR_PTR(-ENOTUNIQ);
1427
1428 pad = remote_pad;
1429 }
1430 }
1431
1432 if (!pad)
1433 return ERR_PTR(-ENOLINK);
1434
1435 return pad;
1436 }
1437 EXPORT_SYMBOL_GPL(media_entity_remote_pad_unique);
1438
media_pad_remote_pad_unique(const struct media_pad * pad)1439 struct media_pad *media_pad_remote_pad_unique(const struct media_pad *pad)
1440 {
1441 struct media_pad *found_pad = NULL;
1442 struct media_link *link;
1443
1444 list_for_each_entry(link, &pad->entity->links, list) {
1445 struct media_pad *remote_pad;
1446
1447 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
1448 continue;
1449
1450 if (link->sink == pad)
1451 remote_pad = link->source;
1452 else if (link->source == pad)
1453 remote_pad = link->sink;
1454 else
1455 continue;
1456
1457 if (found_pad)
1458 return ERR_PTR(-ENOTUNIQ);
1459
1460 found_pad = remote_pad;
1461 }
1462
1463 if (!found_pad)
1464 return ERR_PTR(-ENOLINK);
1465
1466 return found_pad;
1467 }
1468 EXPORT_SYMBOL_GPL(media_pad_remote_pad_unique);
1469
media_entity_get_fwnode_pad(struct media_entity * entity,const struct fwnode_handle * fwnode,unsigned long direction_flags)1470 int media_entity_get_fwnode_pad(struct media_entity *entity,
1471 const struct fwnode_handle *fwnode,
1472 unsigned long direction_flags)
1473 {
1474 struct fwnode_endpoint endpoint;
1475 unsigned int i;
1476 int ret;
1477
1478 if (!entity->ops || !entity->ops->get_fwnode_pad) {
1479 for (i = 0; i < entity->num_pads; i++) {
1480 if (entity->pads[i].flags & direction_flags)
1481 return i;
1482 }
1483
1484 return -ENXIO;
1485 }
1486
1487 ret = fwnode_graph_parse_endpoint(fwnode, &endpoint);
1488 if (ret)
1489 return ret;
1490
1491 ret = entity->ops->get_fwnode_pad(entity, &endpoint);
1492 if (ret < 0)
1493 return ret;
1494
1495 if (ret >= entity->num_pads)
1496 return -ENXIO;
1497
1498 if (!(entity->pads[ret].flags & direction_flags))
1499 return -ENXIO;
1500
1501 return ret;
1502 }
1503 EXPORT_SYMBOL_GPL(media_entity_get_fwnode_pad);
1504
media_entity_pipeline(struct media_entity * entity)1505 struct media_pipeline *media_entity_pipeline(struct media_entity *entity)
1506 {
1507 struct media_pad *pad;
1508
1509 media_entity_for_each_pad(entity, pad) {
1510 if (pad->pipe)
1511 return pad->pipe;
1512 }
1513
1514 return NULL;
1515 }
1516 EXPORT_SYMBOL_GPL(media_entity_pipeline);
1517
media_pad_pipeline(struct media_pad * pad)1518 struct media_pipeline *media_pad_pipeline(struct media_pad *pad)
1519 {
1520 return pad->pipe;
1521 }
1522 EXPORT_SYMBOL_GPL(media_pad_pipeline);
1523
media_interface_init(struct media_device * mdev,struct media_interface * intf,u32 gobj_type,u32 intf_type,u32 flags)1524 static void media_interface_init(struct media_device *mdev,
1525 struct media_interface *intf,
1526 u32 gobj_type,
1527 u32 intf_type, u32 flags)
1528 {
1529 intf->type = intf_type;
1530 intf->flags = flags;
1531 INIT_LIST_HEAD(&intf->links);
1532
1533 media_gobj_create(mdev, gobj_type, &intf->graph_obj);
1534 }
1535
1536 /* Functions related to the media interface via device nodes */
1537
media_devnode_create(struct media_device * mdev,u32 type,u32 flags,u32 major,u32 minor)1538 struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
1539 u32 type, u32 flags,
1540 u32 major, u32 minor)
1541 {
1542 struct media_intf_devnode *devnode;
1543
1544 devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
1545 if (!devnode)
1546 return NULL;
1547
1548 devnode->major = major;
1549 devnode->minor = minor;
1550
1551 media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
1552 type, flags);
1553
1554 return devnode;
1555 }
1556 EXPORT_SYMBOL_GPL(media_devnode_create);
1557
media_devnode_remove(struct media_intf_devnode * devnode)1558 void media_devnode_remove(struct media_intf_devnode *devnode)
1559 {
1560 media_remove_intf_links(&devnode->intf);
1561 media_gobj_destroy(&devnode->intf.graph_obj);
1562 kfree(devnode);
1563 }
1564 EXPORT_SYMBOL_GPL(media_devnode_remove);
1565
media_create_intf_link(struct media_entity * entity,struct media_interface * intf,u32 flags)1566 struct media_link *media_create_intf_link(struct media_entity *entity,
1567 struct media_interface *intf,
1568 u32 flags)
1569 {
1570 struct media_link *link;
1571
1572 link = media_add_link(&intf->links);
1573 if (link == NULL)
1574 return NULL;
1575
1576 link->intf = intf;
1577 link->entity = entity;
1578 link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK;
1579
1580 /* Initialize graph object embedded at the new link */
1581 media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
1582 &link->graph_obj);
1583
1584 return link;
1585 }
1586 EXPORT_SYMBOL_GPL(media_create_intf_link);
1587
__media_remove_intf_link(struct media_link * link)1588 void __media_remove_intf_link(struct media_link *link)
1589 {
1590 list_del(&link->list);
1591 media_gobj_destroy(&link->graph_obj);
1592 kfree(link);
1593 }
1594 EXPORT_SYMBOL_GPL(__media_remove_intf_link);
1595
media_remove_intf_link(struct media_link * link)1596 void media_remove_intf_link(struct media_link *link)
1597 {
1598 struct media_device *mdev = link->graph_obj.mdev;
1599
1600 /* Do nothing if the intf is not registered. */
1601 if (mdev == NULL)
1602 return;
1603
1604 mutex_lock(&mdev->graph_mutex);
1605 __media_remove_intf_link(link);
1606 mutex_unlock(&mdev->graph_mutex);
1607 }
1608 EXPORT_SYMBOL_GPL(media_remove_intf_link);
1609
__media_remove_intf_links(struct media_interface * intf)1610 void __media_remove_intf_links(struct media_interface *intf)
1611 {
1612 struct media_link *link, *tmp;
1613
1614 list_for_each_entry_safe(link, tmp, &intf->links, list)
1615 __media_remove_intf_link(link);
1616
1617 }
1618 EXPORT_SYMBOL_GPL(__media_remove_intf_links);
1619
media_remove_intf_links(struct media_interface * intf)1620 void media_remove_intf_links(struct media_interface *intf)
1621 {
1622 struct media_device *mdev = intf->graph_obj.mdev;
1623
1624 /* Do nothing if the intf is not registered. */
1625 if (mdev == NULL)
1626 return;
1627
1628 mutex_lock(&mdev->graph_mutex);
1629 __media_remove_intf_links(intf);
1630 mutex_unlock(&mdev->graph_mutex);
1631 }
1632 EXPORT_SYMBOL_GPL(media_remove_intf_links);
1633
media_create_ancillary_link(struct media_entity * primary,struct media_entity * ancillary)1634 struct media_link *media_create_ancillary_link(struct media_entity *primary,
1635 struct media_entity *ancillary)
1636 {
1637 struct media_link *link;
1638
1639 link = media_add_link(&primary->links);
1640 if (!link)
1641 return ERR_PTR(-ENOMEM);
1642
1643 link->gobj0 = &primary->graph_obj;
1644 link->gobj1 = &ancillary->graph_obj;
1645 link->flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED |
1646 MEDIA_LNK_FL_ANCILLARY_LINK;
1647
1648 /* Initialize graph object embedded in the new link */
1649 media_gobj_create(primary->graph_obj.mdev, MEDIA_GRAPH_LINK,
1650 &link->graph_obj);
1651
1652 return link;
1653 }
1654 EXPORT_SYMBOL_GPL(media_create_ancillary_link);
1655
__media_entity_next_link(struct media_entity * entity,struct media_link * link,unsigned long link_type)1656 struct media_link *__media_entity_next_link(struct media_entity *entity,
1657 struct media_link *link,
1658 unsigned long link_type)
1659 {
1660 link = link ? list_next_entry(link, list)
1661 : list_first_entry(&entity->links, typeof(*link), list);
1662
1663 list_for_each_entry_from(link, &entity->links, list)
1664 if ((link->flags & MEDIA_LNK_FL_LINK_TYPE) == link_type)
1665 return link;
1666
1667 return NULL;
1668 }
1669 EXPORT_SYMBOL_GPL(__media_entity_next_link);
1670