• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Media entity
3  *
4  * Copyright (C) 2010 Nokia Corporation
5  *
6  * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
7  *	     Sakari Ailus <sakari.ailus@iki.fi>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22 
23 #include <linux/bitmap.h>
24 #include <linux/module.h>
25 #include <linux/slab.h>
26 #include <media/media-entity.h>
27 #include <media/media-device.h>
28 
gobj_type(enum media_gobj_type type)29 static inline const char *gobj_type(enum media_gobj_type type)
30 {
31 	switch (type) {
32 	case MEDIA_GRAPH_ENTITY:
33 		return "entity";
34 	case MEDIA_GRAPH_PAD:
35 		return "pad";
36 	case MEDIA_GRAPH_LINK:
37 		return "link";
38 	case MEDIA_GRAPH_INTF_DEVNODE:
39 		return "intf-devnode";
40 	default:
41 		return "unknown";
42 	}
43 }
44 
intf_type(struct media_interface * intf)45 static inline const char *intf_type(struct media_interface *intf)
46 {
47 	switch (intf->type) {
48 	case MEDIA_INTF_T_DVB_FE:
49 		return "dvb-frontend";
50 	case MEDIA_INTF_T_DVB_DEMUX:
51 		return "dvb-demux";
52 	case MEDIA_INTF_T_DVB_DVR:
53 		return "dvb-dvr";
54 	case MEDIA_INTF_T_DVB_CA:
55 		return  "dvb-ca";
56 	case MEDIA_INTF_T_DVB_NET:
57 		return "dvb-net";
58 	case MEDIA_INTF_T_V4L_VIDEO:
59 		return "v4l-video";
60 	case MEDIA_INTF_T_V4L_VBI:
61 		return "v4l-vbi";
62 	case MEDIA_INTF_T_V4L_RADIO:
63 		return "v4l-radio";
64 	case MEDIA_INTF_T_V4L_SUBDEV:
65 		return "v4l-subdev";
66 	case MEDIA_INTF_T_V4L_SWRADIO:
67 		return "v4l-swradio";
68 	case MEDIA_INTF_T_V4L_TOUCH:
69 		return "v4l-touch";
70 	case MEDIA_INTF_T_ALSA_PCM_CAPTURE:
71 		return "alsa-pcm-capture";
72 	case MEDIA_INTF_T_ALSA_PCM_PLAYBACK:
73 		return "alsa-pcm-playback";
74 	case MEDIA_INTF_T_ALSA_CONTROL:
75 		return "alsa-control";
76 	case MEDIA_INTF_T_ALSA_COMPRESS:
77 		return "alsa-compress";
78 	case MEDIA_INTF_T_ALSA_RAWMIDI:
79 		return "alsa-rawmidi";
80 	case MEDIA_INTF_T_ALSA_HWDEP:
81 		return "alsa-hwdep";
82 	case MEDIA_INTF_T_ALSA_SEQUENCER:
83 		return "alsa-sequencer";
84 	case MEDIA_INTF_T_ALSA_TIMER:
85 		return "alsa-timer";
86 	default:
87 		return "unknown-intf";
88 	}
89 };
90 
__media_entity_enum_init(struct media_entity_enum * ent_enum,int idx_max)91 __must_check int __media_entity_enum_init(struct media_entity_enum *ent_enum,
92 					  int idx_max)
93 {
94 	idx_max = ALIGN(idx_max, BITS_PER_LONG);
95 	ent_enum->bmap = kcalloc(idx_max / BITS_PER_LONG, sizeof(long),
96 				 GFP_KERNEL);
97 	if (!ent_enum->bmap)
98 		return -ENOMEM;
99 
100 	bitmap_zero(ent_enum->bmap, idx_max);
101 	ent_enum->idx_max = idx_max;
102 
103 	return 0;
104 }
105 EXPORT_SYMBOL_GPL(__media_entity_enum_init);
106 
media_entity_enum_cleanup(struct media_entity_enum * ent_enum)107 void media_entity_enum_cleanup(struct media_entity_enum *ent_enum)
108 {
109 	kfree(ent_enum->bmap);
110 }
111 EXPORT_SYMBOL_GPL(media_entity_enum_cleanup);
112 
113 /**
114  *  dev_dbg_obj - Prints in debug mode a change on some object
115  *
116  * @event_name:	Name of the event to report. Could be __func__
117  * @gobj:	Pointer to the object
118  *
119  * Enabled only if DEBUG or CONFIG_DYNAMIC_DEBUG. Otherwise, it
120  * won't produce any code.
121  */
dev_dbg_obj(const char * event_name,struct media_gobj * gobj)122 static void dev_dbg_obj(const char *event_name,  struct media_gobj *gobj)
123 {
124 #if defined(DEBUG) || defined (CONFIG_DYNAMIC_DEBUG)
125 	switch (media_type(gobj)) {
126 	case MEDIA_GRAPH_ENTITY:
127 		dev_dbg(gobj->mdev->dev,
128 			"%s id %u: entity '%s'\n",
129 			event_name, media_id(gobj),
130 			gobj_to_entity(gobj)->name);
131 		break;
132 	case MEDIA_GRAPH_LINK:
133 	{
134 		struct media_link *link = gobj_to_link(gobj);
135 
136 		dev_dbg(gobj->mdev->dev,
137 			"%s id %u: %s link id %u ==> id %u\n",
138 			event_name, media_id(gobj),
139 			media_type(link->gobj0) == MEDIA_GRAPH_PAD ?
140 				"data" : "interface",
141 			media_id(link->gobj0),
142 			media_id(link->gobj1));
143 		break;
144 	}
145 	case MEDIA_GRAPH_PAD:
146 	{
147 		struct media_pad *pad = gobj_to_pad(gobj);
148 
149 		dev_dbg(gobj->mdev->dev,
150 			"%s id %u: %s%spad '%s':%d\n",
151 			event_name, media_id(gobj),
152 			pad->flags & MEDIA_PAD_FL_SINK   ? "sink " : "",
153 			pad->flags & MEDIA_PAD_FL_SOURCE ? "source " : "",
154 			pad->entity->name, pad->index);
155 		break;
156 	}
157 	case MEDIA_GRAPH_INTF_DEVNODE:
158 	{
159 		struct media_interface *intf = gobj_to_intf(gobj);
160 		struct media_intf_devnode *devnode = intf_to_devnode(intf);
161 
162 		dev_dbg(gobj->mdev->dev,
163 			"%s id %u: intf_devnode %s - major: %d, minor: %d\n",
164 			event_name, media_id(gobj),
165 			intf_type(intf),
166 			devnode->major, devnode->minor);
167 		break;
168 	}
169 	}
170 #endif
171 }
172 
media_gobj_create(struct media_device * mdev,enum media_gobj_type type,struct media_gobj * gobj)173 void media_gobj_create(struct media_device *mdev,
174 			   enum media_gobj_type type,
175 			   struct media_gobj *gobj)
176 {
177 	BUG_ON(!mdev);
178 
179 	gobj->mdev = mdev;
180 
181 	/* Create a per-type unique object ID */
182 	gobj->id = media_gobj_gen_id(type, ++mdev->id);
183 
184 	switch (type) {
185 	case MEDIA_GRAPH_ENTITY:
186 		list_add_tail(&gobj->list, &mdev->entities);
187 		break;
188 	case MEDIA_GRAPH_PAD:
189 		list_add_tail(&gobj->list, &mdev->pads);
190 		break;
191 	case MEDIA_GRAPH_LINK:
192 		list_add_tail(&gobj->list, &mdev->links);
193 		break;
194 	case MEDIA_GRAPH_INTF_DEVNODE:
195 		list_add_tail(&gobj->list, &mdev->interfaces);
196 		break;
197 	}
198 
199 	mdev->topology_version++;
200 
201 	dev_dbg_obj(__func__, gobj);
202 }
203 
media_gobj_destroy(struct media_gobj * gobj)204 void media_gobj_destroy(struct media_gobj *gobj)
205 {
206 	dev_dbg_obj(__func__, gobj);
207 
208 	gobj->mdev->topology_version++;
209 
210 	/* Remove the object from mdev list */
211 	list_del(&gobj->list);
212 }
213 
media_entity_pads_init(struct media_entity * entity,u16 num_pads,struct media_pad * pads)214 int media_entity_pads_init(struct media_entity *entity, u16 num_pads,
215 			   struct media_pad *pads)
216 {
217 	struct media_device *mdev = entity->graph_obj.mdev;
218 	unsigned int i;
219 
220 	entity->num_pads = num_pads;
221 	entity->pads = pads;
222 
223 	if (mdev)
224 		mutex_lock(&mdev->graph_mutex);
225 
226 	for (i = 0; i < num_pads; i++) {
227 		pads[i].entity = entity;
228 		pads[i].index = i;
229 		if (mdev)
230 			media_gobj_create(mdev, MEDIA_GRAPH_PAD,
231 					&entity->pads[i].graph_obj);
232 	}
233 
234 	if (mdev)
235 		mutex_unlock(&mdev->graph_mutex);
236 
237 	return 0;
238 }
239 EXPORT_SYMBOL_GPL(media_entity_pads_init);
240 
241 /* -----------------------------------------------------------------------------
242  * Graph traversal
243  */
244 
245 static struct media_entity *
media_entity_other(struct media_entity * entity,struct media_link * link)246 media_entity_other(struct media_entity *entity, struct media_link *link)
247 {
248 	if (link->source->entity == entity)
249 		return link->sink->entity;
250 	else
251 		return link->source->entity;
252 }
253 
254 /* push an entity to traversal stack */
stack_push(struct media_entity_graph * graph,struct media_entity * entity)255 static void stack_push(struct media_entity_graph *graph,
256 		       struct media_entity *entity)
257 {
258 	if (graph->top == MEDIA_ENTITY_ENUM_MAX_DEPTH - 1) {
259 		WARN_ON(1);
260 		return;
261 	}
262 	graph->top++;
263 	graph->stack[graph->top].link = entity->links.next;
264 	graph->stack[graph->top].entity = entity;
265 }
266 
stack_pop(struct media_entity_graph * graph)267 static struct media_entity *stack_pop(struct media_entity_graph *graph)
268 {
269 	struct media_entity *entity;
270 
271 	entity = graph->stack[graph->top].entity;
272 	graph->top--;
273 
274 	return entity;
275 }
276 
277 #define link_top(en)	((en)->stack[(en)->top].link)
278 #define stack_top(en)	((en)->stack[(en)->top].entity)
279 
280 /*
281  * TODO: Get rid of this.
282  */
283 #define MEDIA_ENTITY_MAX_PADS		512
284 
285 /**
286  * media_entity_graph_walk_init - Allocate resources for graph walk
287  * @graph: Media graph structure that will be used to walk the graph
288  * @mdev: Media device
289  *
290  * Reserve resources for graph walk in media device's current
291  * state. The memory must be released using
292  * media_entity_graph_walk_free().
293  *
294  * Returns error on failure, zero on success.
295  */
media_entity_graph_walk_init(struct media_entity_graph * graph,struct media_device * mdev)296 __must_check int media_entity_graph_walk_init(
297 	struct media_entity_graph *graph, struct media_device *mdev)
298 {
299 	return media_entity_enum_init(&graph->ent_enum, mdev);
300 }
301 EXPORT_SYMBOL_GPL(media_entity_graph_walk_init);
302 
303 /**
304  * media_entity_graph_walk_cleanup - Release resources related to graph walking
305  * @graph: Media graph structure that was used to walk the graph
306  */
media_entity_graph_walk_cleanup(struct media_entity_graph * graph)307 void media_entity_graph_walk_cleanup(struct media_entity_graph *graph)
308 {
309 	media_entity_enum_cleanup(&graph->ent_enum);
310 }
311 EXPORT_SYMBOL_GPL(media_entity_graph_walk_cleanup);
312 
media_entity_graph_walk_start(struct media_entity_graph * graph,struct media_entity * entity)313 void media_entity_graph_walk_start(struct media_entity_graph *graph,
314 				   struct media_entity *entity)
315 {
316 	media_entity_enum_zero(&graph->ent_enum);
317 	media_entity_enum_set(&graph->ent_enum, entity);
318 
319 	graph->top = 0;
320 	graph->stack[graph->top].entity = NULL;
321 	stack_push(graph, entity);
322 }
323 EXPORT_SYMBOL_GPL(media_entity_graph_walk_start);
324 
325 struct media_entity *
media_entity_graph_walk_next(struct media_entity_graph * graph)326 media_entity_graph_walk_next(struct media_entity_graph *graph)
327 {
328 	if (stack_top(graph) == NULL)
329 		return NULL;
330 
331 	/*
332 	 * Depth first search. Push entity to stack and continue from
333 	 * top of the stack until no more entities on the level can be
334 	 * found.
335 	 */
336 	while (link_top(graph) != &stack_top(graph)->links) {
337 		struct media_entity *entity = stack_top(graph);
338 		struct media_link *link;
339 		struct media_entity *next;
340 
341 		link = list_entry(link_top(graph), typeof(*link), list);
342 
343 		/* The link is not enabled so we do not follow. */
344 		if (!(link->flags & MEDIA_LNK_FL_ENABLED)) {
345 			link_top(graph) = link_top(graph)->next;
346 			continue;
347 		}
348 
349 		/* Get the entity in the other end of the link . */
350 		next = media_entity_other(entity, link);
351 
352 		/* Has the entity already been visited? */
353 		if (media_entity_enum_test_and_set(&graph->ent_enum, next)) {
354 			link_top(graph) = link_top(graph)->next;
355 			continue;
356 		}
357 
358 		/* Push the new entity to stack and start over. */
359 		link_top(graph) = link_top(graph)->next;
360 		stack_push(graph, next);
361 	}
362 
363 	return stack_pop(graph);
364 }
365 EXPORT_SYMBOL_GPL(media_entity_graph_walk_next);
366 
367 /* -----------------------------------------------------------------------------
368  * Pipeline management
369  */
370 
__media_entity_pipeline_start(struct media_entity * entity,struct media_pipeline * pipe)371 __must_check int __media_entity_pipeline_start(struct media_entity *entity,
372 					       struct media_pipeline *pipe)
373 {
374 	struct media_device *mdev = entity->graph_obj.mdev;
375 	struct media_entity_graph *graph = &pipe->graph;
376 	struct media_entity *entity_err = entity;
377 	struct media_link *link;
378 	int ret;
379 
380 	if (!pipe->streaming_count++) {
381 		ret = media_entity_graph_walk_init(&pipe->graph, mdev);
382 		if (ret)
383 			goto error_graph_walk_start;
384 	}
385 
386 	media_entity_graph_walk_start(&pipe->graph, entity);
387 
388 	while ((entity = media_entity_graph_walk_next(graph))) {
389 		DECLARE_BITMAP(active, MEDIA_ENTITY_MAX_PADS);
390 		DECLARE_BITMAP(has_no_links, MEDIA_ENTITY_MAX_PADS);
391 
392 		entity->stream_count++;
393 
394 		if (WARN_ON(entity->pipe && entity->pipe != pipe)) {
395 			ret = -EBUSY;
396 			goto error;
397 		}
398 
399 		entity->pipe = pipe;
400 
401 		/* Already streaming --- no need to check. */
402 		if (entity->stream_count > 1)
403 			continue;
404 
405 		if (!entity->ops || !entity->ops->link_validate)
406 			continue;
407 
408 		bitmap_zero(active, entity->num_pads);
409 		bitmap_fill(has_no_links, entity->num_pads);
410 
411 		list_for_each_entry(link, &entity->links, list) {
412 			struct media_pad *pad = link->sink->entity == entity
413 						? link->sink : link->source;
414 
415 			/* Mark that a pad is connected by a link. */
416 			bitmap_clear(has_no_links, pad->index, 1);
417 
418 			/*
419 			 * Pads that either do not need to connect or
420 			 * are connected through an enabled link are
421 			 * fine.
422 			 */
423 			if (!(pad->flags & MEDIA_PAD_FL_MUST_CONNECT) ||
424 			    link->flags & MEDIA_LNK_FL_ENABLED)
425 				bitmap_set(active, pad->index, 1);
426 
427 			/*
428 			 * Link validation will only take place for
429 			 * sink ends of the link that are enabled.
430 			 */
431 			if (link->sink != pad ||
432 			    !(link->flags & MEDIA_LNK_FL_ENABLED))
433 				continue;
434 
435 			ret = entity->ops->link_validate(link);
436 			if (ret < 0 && ret != -ENOIOCTLCMD) {
437 				dev_dbg(entity->graph_obj.mdev->dev,
438 					"link validation failed for \"%s\":%u -> \"%s\":%u, error %d\n",
439 					link->source->entity->name,
440 					link->source->index,
441 					entity->name, link->sink->index, ret);
442 				goto error;
443 			}
444 		}
445 
446 		/* Either no links or validated links are fine. */
447 		bitmap_or(active, active, has_no_links, entity->num_pads);
448 
449 		if (!bitmap_full(active, entity->num_pads)) {
450 			ret = -ENOLINK;
451 			dev_dbg(entity->graph_obj.mdev->dev,
452 				"\"%s\":%u must be connected by an enabled link\n",
453 				entity->name,
454 				(unsigned)find_first_zero_bit(
455 					active, entity->num_pads));
456 			goto error;
457 		}
458 	}
459 
460 	return 0;
461 
462 error:
463 	/*
464 	 * Link validation on graph failed. We revert what we did and
465 	 * return the error.
466 	 */
467 	media_entity_graph_walk_start(graph, entity_err);
468 
469 	while ((entity_err = media_entity_graph_walk_next(graph))) {
470 		/* don't let the stream_count go negative */
471 		if (entity_err->stream_count > 0) {
472 			entity_err->stream_count--;
473 			if (entity_err->stream_count == 0)
474 				entity_err->pipe = NULL;
475 		}
476 
477 		/*
478 		 * We haven't increased stream_count further than this
479 		 * so we quit here.
480 		 */
481 		if (entity_err == entity)
482 			break;
483 	}
484 
485 error_graph_walk_start:
486 	if (!--pipe->streaming_count)
487 		media_entity_graph_walk_cleanup(graph);
488 
489 	return ret;
490 }
491 EXPORT_SYMBOL_GPL(__media_entity_pipeline_start);
492 
media_entity_pipeline_start(struct media_entity * entity,struct media_pipeline * pipe)493 __must_check int media_entity_pipeline_start(struct media_entity *entity,
494 					     struct media_pipeline *pipe)
495 {
496 	struct media_device *mdev = entity->graph_obj.mdev;
497 	int ret;
498 
499 	mutex_lock(&mdev->graph_mutex);
500 	ret = __media_entity_pipeline_start(entity, pipe);
501 	mutex_unlock(&mdev->graph_mutex);
502 	return ret;
503 }
504 EXPORT_SYMBOL_GPL(media_entity_pipeline_start);
505 
__media_entity_pipeline_stop(struct media_entity * entity)506 void __media_entity_pipeline_stop(struct media_entity *entity)
507 {
508 	struct media_entity_graph *graph = &entity->pipe->graph;
509 	struct media_pipeline *pipe = entity->pipe;
510 
511 
512 	WARN_ON(!pipe->streaming_count);
513 	media_entity_graph_walk_start(graph, entity);
514 
515 	while ((entity = media_entity_graph_walk_next(graph))) {
516 		/* don't let the stream_count go negative */
517 		if (entity->stream_count > 0) {
518 			entity->stream_count--;
519 			if (entity->stream_count == 0)
520 				entity->pipe = NULL;
521 		}
522 	}
523 
524 	if (!--pipe->streaming_count)
525 		media_entity_graph_walk_cleanup(graph);
526 
527 }
528 EXPORT_SYMBOL_GPL(__media_entity_pipeline_stop);
529 
media_entity_pipeline_stop(struct media_entity * entity)530 void media_entity_pipeline_stop(struct media_entity *entity)
531 {
532 	struct media_device *mdev = entity->graph_obj.mdev;
533 
534 	mutex_lock(&mdev->graph_mutex);
535 	__media_entity_pipeline_stop(entity);
536 	mutex_unlock(&mdev->graph_mutex);
537 }
538 EXPORT_SYMBOL_GPL(media_entity_pipeline_stop);
539 
540 /* -----------------------------------------------------------------------------
541  * Module use count
542  */
543 
media_entity_get(struct media_entity * entity)544 struct media_entity *media_entity_get(struct media_entity *entity)
545 {
546 	if (entity == NULL)
547 		return NULL;
548 
549 	if (entity->graph_obj.mdev->dev &&
550 	    !try_module_get(entity->graph_obj.mdev->dev->driver->owner))
551 		return NULL;
552 
553 	return entity;
554 }
555 EXPORT_SYMBOL_GPL(media_entity_get);
556 
media_entity_put(struct media_entity * entity)557 void media_entity_put(struct media_entity *entity)
558 {
559 	if (entity == NULL)
560 		return;
561 
562 	if (entity->graph_obj.mdev->dev)
563 		module_put(entity->graph_obj.mdev->dev->driver->owner);
564 }
565 EXPORT_SYMBOL_GPL(media_entity_put);
566 
567 /* -----------------------------------------------------------------------------
568  * Links management
569  */
570 
media_add_link(struct list_head * head)571 static struct media_link *media_add_link(struct list_head *head)
572 {
573 	struct media_link *link;
574 
575 	link = kzalloc(sizeof(*link), GFP_KERNEL);
576 	if (link == NULL)
577 		return NULL;
578 
579 	list_add_tail(&link->list, head);
580 
581 	return link;
582 }
583 
__media_entity_remove_link(struct media_entity * entity,struct media_link * link)584 static void __media_entity_remove_link(struct media_entity *entity,
585 				       struct media_link *link)
586 {
587 	struct media_link *rlink, *tmp;
588 	struct media_entity *remote;
589 
590 	if (link->source->entity == entity)
591 		remote = link->sink->entity;
592 	else
593 		remote = link->source->entity;
594 
595 	list_for_each_entry_safe(rlink, tmp, &remote->links, list) {
596 		if (rlink != link->reverse)
597 			continue;
598 
599 		if (link->source->entity == entity)
600 			remote->num_backlinks--;
601 
602 		/* Remove the remote link */
603 		list_del(&rlink->list);
604 		media_gobj_destroy(&rlink->graph_obj);
605 		kfree(rlink);
606 
607 		if (--remote->num_links == 0)
608 			break;
609 	}
610 	list_del(&link->list);
611 	media_gobj_destroy(&link->graph_obj);
612 	kfree(link);
613 }
614 
615 int
media_create_pad_link(struct media_entity * source,u16 source_pad,struct media_entity * sink,u16 sink_pad,u32 flags)616 media_create_pad_link(struct media_entity *source, u16 source_pad,
617 			 struct media_entity *sink, u16 sink_pad, u32 flags)
618 {
619 	struct media_link *link;
620 	struct media_link *backlink;
621 
622 	BUG_ON(source == NULL || sink == NULL);
623 	BUG_ON(source_pad >= source->num_pads);
624 	BUG_ON(sink_pad >= sink->num_pads);
625 
626 	link = media_add_link(&source->links);
627 	if (link == NULL)
628 		return -ENOMEM;
629 
630 	link->source = &source->pads[source_pad];
631 	link->sink = &sink->pads[sink_pad];
632 	link->flags = flags & ~MEDIA_LNK_FL_INTERFACE_LINK;
633 
634 	/* Initialize graph object embedded at the new link */
635 	media_gobj_create(source->graph_obj.mdev, MEDIA_GRAPH_LINK,
636 			&link->graph_obj);
637 
638 	/* Create the backlink. Backlinks are used to help graph traversal and
639 	 * are not reported to userspace.
640 	 */
641 	backlink = media_add_link(&sink->links);
642 	if (backlink == NULL) {
643 		__media_entity_remove_link(source, link);
644 		return -ENOMEM;
645 	}
646 
647 	backlink->source = &source->pads[source_pad];
648 	backlink->sink = &sink->pads[sink_pad];
649 	backlink->flags = flags;
650 	backlink->is_backlink = true;
651 
652 	/* Initialize graph object embedded at the new link */
653 	media_gobj_create(sink->graph_obj.mdev, MEDIA_GRAPH_LINK,
654 			&backlink->graph_obj);
655 
656 	link->reverse = backlink;
657 	backlink->reverse = link;
658 
659 	sink->num_backlinks++;
660 	sink->num_links++;
661 	source->num_links++;
662 
663 	return 0;
664 }
665 EXPORT_SYMBOL_GPL(media_create_pad_link);
666 
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)667 int media_create_pad_links(const struct media_device *mdev,
668 			   const u32 source_function,
669 			   struct media_entity *source,
670 			   const u16 source_pad,
671 			   const u32 sink_function,
672 			   struct media_entity *sink,
673 			   const u16 sink_pad,
674 			   u32 flags,
675 			   const bool allow_both_undefined)
676 {
677 	struct media_entity *entity;
678 	unsigned function;
679 	int ret;
680 
681 	/* Trivial case: 1:1 relation */
682 	if (source && sink)
683 		return media_create_pad_link(source, source_pad,
684 					     sink, sink_pad, flags);
685 
686 	/* Worse case scenario: n:n relation */
687 	if (!source && !sink) {
688 		if (!allow_both_undefined)
689 			return 0;
690 		media_device_for_each_entity(source, mdev) {
691 			if (source->function != source_function)
692 				continue;
693 			media_device_for_each_entity(sink, mdev) {
694 				if (sink->function != sink_function)
695 					continue;
696 				ret = media_create_pad_link(source, source_pad,
697 							    sink, sink_pad,
698 							    flags);
699 				if (ret)
700 					return ret;
701 				flags &= ~(MEDIA_LNK_FL_ENABLED |
702 					   MEDIA_LNK_FL_IMMUTABLE);
703 			}
704 		}
705 		return 0;
706 	}
707 
708 	/* Handle 1:n and n:1 cases */
709 	if (source)
710 		function = sink_function;
711 	else
712 		function = source_function;
713 
714 	media_device_for_each_entity(entity, mdev) {
715 		if (entity->function != function)
716 			continue;
717 
718 		if (source)
719 			ret = media_create_pad_link(source, source_pad,
720 						    entity, sink_pad, flags);
721 		else
722 			ret = media_create_pad_link(entity, source_pad,
723 						    sink, sink_pad, flags);
724 		if (ret)
725 			return ret;
726 		flags &= ~(MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
727 	}
728 	return 0;
729 }
730 EXPORT_SYMBOL_GPL(media_create_pad_links);
731 
__media_entity_remove_links(struct media_entity * entity)732 void __media_entity_remove_links(struct media_entity *entity)
733 {
734 	struct media_link *link, *tmp;
735 
736 	list_for_each_entry_safe(link, tmp, &entity->links, list)
737 		__media_entity_remove_link(entity, link);
738 
739 	entity->num_links = 0;
740 	entity->num_backlinks = 0;
741 }
742 EXPORT_SYMBOL_GPL(__media_entity_remove_links);
743 
media_entity_remove_links(struct media_entity * entity)744 void media_entity_remove_links(struct media_entity *entity)
745 {
746 	struct media_device *mdev = entity->graph_obj.mdev;
747 
748 	/* Do nothing if the entity is not registered. */
749 	if (mdev == NULL)
750 		return;
751 
752 	mutex_lock(&mdev->graph_mutex);
753 	__media_entity_remove_links(entity);
754 	mutex_unlock(&mdev->graph_mutex);
755 }
756 EXPORT_SYMBOL_GPL(media_entity_remove_links);
757 
__media_entity_setup_link_notify(struct media_link * link,u32 flags)758 static int __media_entity_setup_link_notify(struct media_link *link, u32 flags)
759 {
760 	int ret;
761 
762 	/* Notify both entities. */
763 	ret = media_entity_call(link->source->entity, link_setup,
764 				link->source, link->sink, flags);
765 	if (ret < 0 && ret != -ENOIOCTLCMD)
766 		return ret;
767 
768 	ret = media_entity_call(link->sink->entity, link_setup,
769 				link->sink, link->source, flags);
770 	if (ret < 0 && ret != -ENOIOCTLCMD) {
771 		media_entity_call(link->source->entity, link_setup,
772 				  link->source, link->sink, link->flags);
773 		return ret;
774 	}
775 
776 	link->flags = flags;
777 	link->reverse->flags = link->flags;
778 
779 	return 0;
780 }
781 
__media_entity_setup_link(struct media_link * link,u32 flags)782 int __media_entity_setup_link(struct media_link *link, u32 flags)
783 {
784 	const u32 mask = MEDIA_LNK_FL_ENABLED;
785 	struct media_device *mdev;
786 	struct media_entity *source, *sink;
787 	int ret = -EBUSY;
788 
789 	if (link == NULL)
790 		return -EINVAL;
791 
792 	/* The non-modifiable link flags must not be modified. */
793 	if ((link->flags & ~mask) != (flags & ~mask))
794 		return -EINVAL;
795 
796 	if (link->flags & MEDIA_LNK_FL_IMMUTABLE)
797 		return link->flags == flags ? 0 : -EINVAL;
798 
799 	if (link->flags == flags)
800 		return 0;
801 
802 	source = link->source->entity;
803 	sink = link->sink->entity;
804 
805 	if (!(link->flags & MEDIA_LNK_FL_DYNAMIC) &&
806 	    (source->stream_count || sink->stream_count))
807 		return -EBUSY;
808 
809 	mdev = source->graph_obj.mdev;
810 
811 	if (mdev->ops && mdev->ops->link_notify) {
812 		ret = mdev->ops->link_notify(link, flags,
813 					     MEDIA_DEV_NOTIFY_PRE_LINK_CH);
814 		if (ret < 0)
815 			return ret;
816 	}
817 
818 	ret = __media_entity_setup_link_notify(link, flags);
819 
820 	if (mdev->ops && mdev->ops->link_notify)
821 		mdev->ops->link_notify(link, flags,
822 				       MEDIA_DEV_NOTIFY_POST_LINK_CH);
823 
824 	return ret;
825 }
826 EXPORT_SYMBOL_GPL(__media_entity_setup_link);
827 
media_entity_setup_link(struct media_link * link,u32 flags)828 int media_entity_setup_link(struct media_link *link, u32 flags)
829 {
830 	int ret;
831 
832 	mutex_lock(&link->graph_obj.mdev->graph_mutex);
833 	ret = __media_entity_setup_link(link, flags);
834 	mutex_unlock(&link->graph_obj.mdev->graph_mutex);
835 
836 	return ret;
837 }
838 EXPORT_SYMBOL_GPL(media_entity_setup_link);
839 
840 struct media_link *
media_entity_find_link(struct media_pad * source,struct media_pad * sink)841 media_entity_find_link(struct media_pad *source, struct media_pad *sink)
842 {
843 	struct media_link *link;
844 
845 	list_for_each_entry(link, &source->entity->links, list) {
846 		if (link->source->entity == source->entity &&
847 		    link->source->index == source->index &&
848 		    link->sink->entity == sink->entity &&
849 		    link->sink->index == sink->index)
850 			return link;
851 	}
852 
853 	return NULL;
854 }
855 EXPORT_SYMBOL_GPL(media_entity_find_link);
856 
media_entity_remote_pad(struct media_pad * pad)857 struct media_pad *media_entity_remote_pad(struct media_pad *pad)
858 {
859 	struct media_link *link;
860 
861 	list_for_each_entry(link, &pad->entity->links, list) {
862 		if (!(link->flags & MEDIA_LNK_FL_ENABLED))
863 			continue;
864 
865 		if (link->source == pad)
866 			return link->sink;
867 
868 		if (link->sink == pad)
869 			return link->source;
870 	}
871 
872 	return NULL;
873 
874 }
875 EXPORT_SYMBOL_GPL(media_entity_remote_pad);
876 
media_interface_init(struct media_device * mdev,struct media_interface * intf,u32 gobj_type,u32 intf_type,u32 flags)877 static void media_interface_init(struct media_device *mdev,
878 				 struct media_interface *intf,
879 				 u32 gobj_type,
880 				 u32 intf_type, u32 flags)
881 {
882 	intf->type = intf_type;
883 	intf->flags = flags;
884 	INIT_LIST_HEAD(&intf->links);
885 
886 	media_gobj_create(mdev, gobj_type, &intf->graph_obj);
887 }
888 
889 /* Functions related to the media interface via device nodes */
890 
media_devnode_create(struct media_device * mdev,u32 type,u32 flags,u32 major,u32 minor)891 struct media_intf_devnode *media_devnode_create(struct media_device *mdev,
892 						u32 type, u32 flags,
893 						u32 major, u32 minor)
894 {
895 	struct media_intf_devnode *devnode;
896 
897 	devnode = kzalloc(sizeof(*devnode), GFP_KERNEL);
898 	if (!devnode)
899 		return NULL;
900 
901 	devnode->major = major;
902 	devnode->minor = minor;
903 
904 	media_interface_init(mdev, &devnode->intf, MEDIA_GRAPH_INTF_DEVNODE,
905 			     type, flags);
906 
907 	return devnode;
908 }
909 EXPORT_SYMBOL_GPL(media_devnode_create);
910 
media_devnode_remove(struct media_intf_devnode * devnode)911 void media_devnode_remove(struct media_intf_devnode *devnode)
912 {
913 	media_remove_intf_links(&devnode->intf);
914 	media_gobj_destroy(&devnode->intf.graph_obj);
915 	kfree(devnode);
916 }
917 EXPORT_SYMBOL_GPL(media_devnode_remove);
918 
media_create_intf_link(struct media_entity * entity,struct media_interface * intf,u32 flags)919 struct media_link *media_create_intf_link(struct media_entity *entity,
920 					    struct media_interface *intf,
921 					    u32 flags)
922 {
923 	struct media_link *link;
924 
925 	link = media_add_link(&intf->links);
926 	if (link == NULL)
927 		return NULL;
928 
929 	link->intf = intf;
930 	link->entity = entity;
931 	link->flags = flags | MEDIA_LNK_FL_INTERFACE_LINK;
932 
933 	/* Initialize graph object embedded at the new link */
934 	media_gobj_create(intf->graph_obj.mdev, MEDIA_GRAPH_LINK,
935 			&link->graph_obj);
936 
937 	return link;
938 }
939 EXPORT_SYMBOL_GPL(media_create_intf_link);
940 
__media_remove_intf_link(struct media_link * link)941 void __media_remove_intf_link(struct media_link *link)
942 {
943 	list_del(&link->list);
944 	media_gobj_destroy(&link->graph_obj);
945 	kfree(link);
946 }
947 EXPORT_SYMBOL_GPL(__media_remove_intf_link);
948 
media_remove_intf_link(struct media_link * link)949 void media_remove_intf_link(struct media_link *link)
950 {
951 	struct media_device *mdev = link->graph_obj.mdev;
952 
953 	/* Do nothing if the intf is not registered. */
954 	if (mdev == NULL)
955 		return;
956 
957 	mutex_lock(&mdev->graph_mutex);
958 	__media_remove_intf_link(link);
959 	mutex_unlock(&mdev->graph_mutex);
960 }
961 EXPORT_SYMBOL_GPL(media_remove_intf_link);
962 
__media_remove_intf_links(struct media_interface * intf)963 void __media_remove_intf_links(struct media_interface *intf)
964 {
965 	struct media_link *link, *tmp;
966 
967 	list_for_each_entry_safe(link, tmp, &intf->links, list)
968 		__media_remove_intf_link(link);
969 
970 }
971 EXPORT_SYMBOL_GPL(__media_remove_intf_links);
972 
media_remove_intf_links(struct media_interface * intf)973 void media_remove_intf_links(struct media_interface *intf)
974 {
975 	struct media_device *mdev = intf->graph_obj.mdev;
976 
977 	/* Do nothing if the intf is not registered. */
978 	if (mdev == NULL)
979 		return;
980 
981 	mutex_lock(&mdev->graph_mutex);
982 	__media_remove_intf_links(intf);
983 	mutex_unlock(&mdev->graph_mutex);
984 }
985 EXPORT_SYMBOL_GPL(media_remove_intf_links);
986