Move media-ctl to git://linuxtv.org/v4l-utils.git
[media-ctl.git] / src / mediactl.c
1 /*
2  * Media controller interface library
3  *
4  * Copyright (C) 2010-2011 Ideas on board SPRL
5  *
6  * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser General Public License as published
10  * by the Free Software Foundation; either version 2.1 of the License, or
11  * (at your option) any later version.
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 Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program. If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include "config.h"
23
24 #include <sys/ioctl.h>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27
28 #include <ctype.h>
29 #include <errno.h>
30 #include <fcntl.h>
31 #include <stdbool.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include <linux/media.h>
38 #include <linux/videodev2.h>
39
40 #include "mediactl.h"
41 #include "mediactl-priv.h"
42 #include "tools.h"
43
44 /* -----------------------------------------------------------------------------
45  * Graph access
46  */
47
48 struct media_pad *media_entity_remote_source(struct media_pad *pad)
49 {
50         unsigned int i;
51
52         if (!(pad->flags & MEDIA_PAD_FL_SINK))
53                 return NULL;
54
55         for (i = 0; i < pad->entity->num_links; ++i) {
56                 struct media_link *link = &pad->entity->links[i];
57
58                 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
59                         continue;
60
61                 if (link->sink == pad)
62                         return link->source;
63         }
64
65         return NULL;
66 }
67
68 struct media_entity *media_get_entity_by_name(struct media_device *media,
69                                               const char *name, size_t length)
70 {
71         unsigned int i;
72
73         /* A match is impossible if the entity name is longer than the maximum
74          * size we can get from the kernel.
75          */
76         if (length >= FIELD_SIZEOF(struct media_entity_desc, name))
77                 return NULL;
78
79         for (i = 0; i < media->entities_count; ++i) {
80                 struct media_entity *entity = &media->entities[i];
81
82                 if (strncmp(entity->info.name, name, length) == 0 &&
83                     entity->info.name[length] == '\0')
84                         return entity;
85         }
86
87         return NULL;
88 }
89
90 struct media_entity *media_get_entity_by_id(struct media_device *media,
91                                             __u32 id)
92 {
93         bool next = id & MEDIA_ENT_ID_FLAG_NEXT;
94         unsigned int i;
95
96         id &= ~MEDIA_ENT_ID_FLAG_NEXT;
97
98         for (i = 0; i < media->entities_count; ++i) {
99                 struct media_entity *entity = &media->entities[i];
100
101                 if ((entity->info.id == id && !next) ||
102                     (entity->info.id > id && next))
103                         return entity;
104         }
105
106         return NULL;
107 }
108
109 unsigned int media_get_entities_count(struct media_device *media)
110 {
111         return media->entities_count;
112 }
113
114 struct media_entity *media_get_entity(struct media_device *media, unsigned int index)
115 {
116         if (index >= media->entities_count)
117                 return NULL;
118
119         return &media->entities[index];
120 }
121
122 const struct media_pad *media_entity_get_pad(struct media_entity *entity, unsigned int index)
123 {
124         if (index >= entity->info.pads)
125                 return NULL;
126
127         return &entity->pads[index];
128 }
129
130 unsigned int media_entity_get_links_count(struct media_entity *entity)
131 {
132         return entity->num_links;
133 }
134
135 const struct media_link *media_entity_get_link(struct media_entity *entity, unsigned int index)
136 {
137         if (index >= entity->num_links)
138                 return NULL;
139
140         return &entity->links[index];
141 }
142
143 const char *media_entity_get_devname(struct media_entity *entity)
144 {
145         return entity->devname[0] ? entity->devname : NULL;
146 }
147
148 struct media_entity *media_get_default_entity(struct media_device *media,
149                                               unsigned int type)
150 {
151         switch (type) {
152         case MEDIA_ENT_T_DEVNODE_V4L:
153                 return media->def.v4l;
154         case MEDIA_ENT_T_DEVNODE_FB:
155                 return media->def.fb;
156         case MEDIA_ENT_T_DEVNODE_ALSA:
157                 return media->def.alsa;
158         case MEDIA_ENT_T_DEVNODE_DVB:
159                 return media->def.dvb;
160         }
161
162         return NULL;
163 }
164
165 const struct media_device_info *media_get_info(struct media_device *media)
166 {
167         return &media->info;
168 }
169
170 const char *media_get_devnode(struct media_device *media)
171 {
172         return media->devnode;
173 }
174
175 const struct media_entity_desc *media_entity_get_info(struct media_entity *entity)
176 {
177         return &entity->info;
178 }
179
180 /* -----------------------------------------------------------------------------
181  * Open/close
182  */
183
184 static int media_device_open(struct media_device *media)
185 {
186         int ret;
187
188         if (media->fd != -1)
189                 return 0;
190
191         media_dbg(media, "Opening media device %s\n", media->devnode);
192
193         media->fd = open(media->devnode, O_RDWR);
194         if (media->fd < 0) {
195                 ret = -errno;
196                 media_dbg(media, "%s: Can't open media device %s\n",
197                           __func__, media->devnode);
198                 return ret;
199         }
200
201         return 0;
202 }
203
204 static void media_device_close(struct media_device *media)
205 {
206         if (media->fd != -1) {
207                 close(media->fd);
208                 media->fd = -1;
209         }
210 }
211
212 /* -----------------------------------------------------------------------------
213  * Link setup
214  */
215
216 int media_setup_link(struct media_device *media,
217                      struct media_pad *source,
218                      struct media_pad *sink,
219                      __u32 flags)
220 {
221         struct media_link *link;
222         struct media_link_desc ulink;
223         unsigned int i;
224         int ret;
225
226         ret = media_device_open(media);
227         if (ret < 0)
228                 goto done;
229
230         for (i = 0; i < source->entity->num_links; i++) {
231                 link = &source->entity->links[i];
232
233                 if (link->source->entity == source->entity &&
234                     link->source->index == source->index &&
235                     link->sink->entity == sink->entity &&
236                     link->sink->index == sink->index)
237                         break;
238         }
239
240         if (i == source->entity->num_links) {
241                 media_dbg(media, "%s: Link not found\n", __func__);
242                 ret = -ENOENT;
243                 goto done;
244         }
245
246         /* source pad */
247         ulink.source.entity = source->entity->info.id;
248         ulink.source.index = source->index;
249         ulink.source.flags = MEDIA_PAD_FL_SOURCE;
250
251         /* sink pad */
252         ulink.sink.entity = sink->entity->info.id;
253         ulink.sink.index = sink->index;
254         ulink.sink.flags = MEDIA_PAD_FL_SINK;
255
256         ulink.flags = flags | (link->flags & MEDIA_LNK_FL_IMMUTABLE);
257
258         ret = ioctl(media->fd, MEDIA_IOC_SETUP_LINK, &ulink);
259         if (ret == -1) {
260                 ret = -errno;
261                 media_dbg(media, "%s: Unable to setup link (%s)\n",
262                           __func__, strerror(errno));
263                 goto done;
264         }
265
266         link->flags = ulink.flags;
267         link->twin->flags = ulink.flags;
268
269         ret = 0;
270
271 done:
272         media_device_close(media);
273         return ret;
274 }
275
276 int media_reset_links(struct media_device *media)
277 {
278         unsigned int i, j;
279         int ret;
280
281         for (i = 0; i < media->entities_count; ++i) {
282                 struct media_entity *entity = &media->entities[i];
283
284                 for (j = 0; j < entity->num_links; j++) {
285                         struct media_link *link = &entity->links[j];
286
287                         if (link->flags & MEDIA_LNK_FL_IMMUTABLE ||
288                             link->source->entity != entity)
289                                 continue;
290
291                         ret = media_setup_link(media, link->source, link->sink,
292                                                link->flags & ~MEDIA_LNK_FL_ENABLED);
293                         if (ret < 0)
294                                 return ret;
295                 }
296         }
297
298         return 0;
299 }
300
301 /* -----------------------------------------------------------------------------
302  * Entities, pads and links enumeration
303  */
304
305 static struct media_link *media_entity_add_link(struct media_entity *entity)
306 {
307         if (entity->num_links >= entity->max_links) {
308                 struct media_link *links = entity->links;
309                 unsigned int max_links = entity->max_links * 2;
310                 unsigned int i;
311
312                 links = realloc(links, max_links * sizeof *links);
313                 if (links == NULL)
314                         return NULL;
315
316                 for (i = 0; i < entity->num_links; ++i)
317                         links[i].twin->twin = &links[i];
318
319                 entity->max_links = max_links;
320                 entity->links = links;
321         }
322
323         return &entity->links[entity->num_links++];
324 }
325
326 static int media_enum_links(struct media_device *media)
327 {
328         __u32 id;
329         int ret = 0;
330
331         for (id = 1; id <= media->entities_count; id++) {
332                 struct media_entity *entity = &media->entities[id - 1];
333                 struct media_links_enum links;
334                 unsigned int i;
335
336                 links.entity = entity->info.id;
337                 links.pads = calloc(entity->info.pads, sizeof(struct media_pad_desc));
338                 links.links = calloc(entity->info.links, sizeof(struct media_link_desc));
339
340                 if (ioctl(media->fd, MEDIA_IOC_ENUM_LINKS, &links) < 0) {
341                         ret = -errno;
342                         media_dbg(media,
343                                   "%s: Unable to enumerate pads and links (%s).\n",
344                                   __func__, strerror(errno));
345                         free(links.pads);
346                         free(links.links);
347                         return ret;
348                 }
349
350                 for (i = 0; i < entity->info.pads; ++i) {
351                         entity->pads[i].entity = entity;
352                         entity->pads[i].index = links.pads[i].index;
353                         entity->pads[i].flags = links.pads[i].flags;
354                 }
355
356                 for (i = 0; i < entity->info.links; ++i) {
357                         struct media_link_desc *link = &links.links[i];
358                         struct media_link *fwdlink;
359                         struct media_link *backlink;
360                         struct media_entity *source;
361                         struct media_entity *sink;
362
363                         source = media_get_entity_by_id(media, link->source.entity);
364                         sink = media_get_entity_by_id(media, link->sink.entity);
365
366                         if (source == NULL || sink == NULL) {
367                                 media_dbg(media,
368                                           "WARNING entity %u link %u from %u/%u to %u/%u is invalid!\n",
369                                           id, i, link->source.entity,
370                                           link->source.index,
371                                           link->sink.entity,
372                                           link->sink.index);
373                                 ret = -EINVAL;
374                         } else {
375                                 fwdlink = media_entity_add_link(source);
376                                 fwdlink->source = &source->pads[link->source.index];
377                                 fwdlink->sink = &sink->pads[link->sink.index];
378                                 fwdlink->flags = link->flags;
379
380                                 backlink = media_entity_add_link(sink);
381                                 backlink->source = &source->pads[link->source.index];
382                                 backlink->sink = &sink->pads[link->sink.index];
383                                 backlink->flags = link->flags;
384
385                                 fwdlink->twin = backlink;
386                                 backlink->twin = fwdlink;
387                         }
388                 }
389
390                 free(links.pads);
391                 free(links.links);
392         }
393
394         return ret;
395 }
396
397 #ifdef HAVE_LIBUDEV
398
399 #include <libudev.h>
400
401 static inline int media_udev_open(struct udev **udev)
402 {
403         *udev = udev_new();
404         if (*udev == NULL)
405                 return -ENOMEM;
406         return 0;
407 }
408
409 static inline void media_udev_close(struct udev *udev)
410 {
411         if (udev != NULL)
412                 udev_unref(udev);
413 }
414
415 static int media_get_devname_udev(struct udev *udev,
416                 struct media_entity *entity)
417 {
418         struct udev_device *device;
419         dev_t devnum;
420         const char *p;
421         int ret = -ENODEV;
422
423         if (udev == NULL)
424                 return -EINVAL;
425
426         devnum = makedev(entity->info.v4l.major, entity->info.v4l.minor);
427         media_dbg(entity->media, "looking up device: %u:%u\n",
428                   major(devnum), minor(devnum));
429         device = udev_device_new_from_devnum(udev, 'c', devnum);
430         if (device) {
431                 p = udev_device_get_devnode(device);
432                 if (p) {
433                         strncpy(entity->devname, p, sizeof(entity->devname));
434                         entity->devname[sizeof(entity->devname) - 1] = '\0';
435                 }
436                 ret = 0;
437         }
438
439         udev_device_unref(device);
440
441         return ret;
442 }
443
444 #else   /* HAVE_LIBUDEV */
445
446 struct udev;
447
448 static inline int media_udev_open(struct udev **udev) { return 0; }
449
450 static inline void media_udev_close(struct udev *udev) { }
451
452 static inline int media_get_devname_udev(struct udev *udev,
453                 struct media_entity *entity)
454 {
455         return -ENOTSUP;
456 }
457
458 #endif  /* HAVE_LIBUDEV */
459
460 static int media_get_devname_sysfs(struct media_entity *entity)
461 {
462         struct stat devstat;
463         char devname[32];
464         char sysname[32];
465         char target[1024];
466         char *p;
467         int ret;
468
469         sprintf(sysname, "/sys/dev/char/%u:%u", entity->info.v4l.major,
470                 entity->info.v4l.minor);
471         ret = readlink(sysname, target, sizeof(target));
472         if (ret < 0)
473                 return -errno;
474
475         target[ret] = '\0';
476         p = strrchr(target, '/');
477         if (p == NULL)
478                 return -EINVAL;
479
480         sprintf(devname, "/dev/%s", p + 1);
481         ret = stat(devname, &devstat);
482         if (ret < 0)
483                 return -errno;
484
485         /* Sanity check: udev might have reordered the device nodes.
486          * Make sure the major/minor match. We should really use
487          * libudev.
488          */
489         if (major(devstat.st_rdev) == entity->info.v4l.major &&
490             minor(devstat.st_rdev) == entity->info.v4l.minor)
491                 strcpy(entity->devname, devname);
492
493         return 0;
494 }
495
496 static int media_enum_entities(struct media_device *media)
497 {
498         struct media_entity *entity;
499         struct udev *udev;
500         unsigned int size;
501         __u32 id;
502         int ret;
503
504         ret = media_udev_open(&udev);
505         if (ret < 0)
506                 media_dbg(media, "Can't get udev context\n");
507
508         for (id = 0, ret = 0; ; id = entity->info.id) {
509                 size = (media->entities_count + 1) * sizeof(*media->entities);
510                 media->entities = realloc(media->entities, size);
511
512                 entity = &media->entities[media->entities_count];
513                 memset(entity, 0, sizeof(*entity));
514                 entity->fd = -1;
515                 entity->info.id = id | MEDIA_ENT_ID_FLAG_NEXT;
516                 entity->media = media;
517
518                 ret = ioctl(media->fd, MEDIA_IOC_ENUM_ENTITIES, &entity->info);
519                 if (ret < 0) {
520                         ret = errno != EINVAL ? -errno : 0;
521                         break;
522                 }
523
524                 /* Number of links (for outbound links) plus number of pads (for
525                  * inbound links) is a good safe initial estimate of the total
526                  * number of links.
527                  */
528                 entity->max_links = entity->info.pads + entity->info.links;
529
530                 entity->pads = malloc(entity->info.pads * sizeof(*entity->pads));
531                 entity->links = malloc(entity->max_links * sizeof(*entity->links));
532                 if (entity->pads == NULL || entity->links == NULL) {
533                         ret = -ENOMEM;
534                         break;
535                 }
536
537                 media->entities_count++;
538
539                 if (entity->info.flags & MEDIA_ENT_FL_DEFAULT) {
540                         switch (entity->info.type) {
541                         case MEDIA_ENT_T_DEVNODE_V4L:
542                                 media->def.v4l = entity;
543                                 break;
544                         case MEDIA_ENT_T_DEVNODE_FB:
545                                 media->def.fb = entity;
546                                 break;
547                         case MEDIA_ENT_T_DEVNODE_ALSA:
548                                 media->def.alsa = entity;
549                                 break;
550                         case MEDIA_ENT_T_DEVNODE_DVB:
551                                 media->def.dvb = entity;
552                                 break;
553                         }
554                 }
555
556                 /* Find the corresponding device name. */
557                 if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE &&
558                     media_entity_type(entity) != MEDIA_ENT_T_V4L2_SUBDEV)
559                         continue;
560
561                 /* Try to get the device name via udev */
562                 if (!media_get_devname_udev(udev, entity))
563                         continue;
564
565                 /* Fall back to get the device name via sysfs */
566                 media_get_devname_sysfs(entity);
567         }
568
569         media_udev_close(udev);
570         return ret;
571 }
572
573 int media_device_enumerate(struct media_device *media)
574 {
575         int ret;
576
577         if (media->entities)
578                 return 0;
579
580         ret = media_device_open(media);
581         if (ret < 0)
582                 return ret;
583
584         ret = ioctl(media->fd, MEDIA_IOC_DEVICE_INFO, &media->info);
585         if (ret < 0) {
586                 ret = -errno;
587                 media_dbg(media, "%s: Unable to retrieve media device "
588                           "information for device %s (%s)\n", __func__,
589                           media->devnode, strerror(errno));
590                 goto done;
591         }
592
593         media_dbg(media, "Enumerating entities\n");
594
595         ret = media_enum_entities(media);
596         if (ret < 0) {
597                 media_dbg(media,
598                           "%s: Unable to enumerate entities for device %s (%s)\n",
599                           __func__, media->devnode, strerror(-ret));
600                 goto done;
601         }
602
603         media_dbg(media, "Found %u entities\n", media->entities_count);
604         media_dbg(media, "Enumerating pads and links\n");
605
606         ret = media_enum_links(media);
607         if (ret < 0) {
608                 media_dbg(media,
609                           "%s: Unable to enumerate pads and linksfor device %s\n",
610                           __func__, media->devnode);
611                 goto done;
612         }
613
614         ret = 0;
615
616 done:
617         media_device_close(media);
618         return ret;
619 }
620
621 /* -----------------------------------------------------------------------------
622  * Create/destroy
623  */
624
625 static void media_debug_default(void *ptr, ...)
626 {
627 }
628
629 void media_debug_set_handler(struct media_device *media,
630                              void (*debug_handler)(void *, ...),
631                              void *debug_priv)
632 {
633         if (debug_handler) {
634                 media->debug_handler = debug_handler;
635                 media->debug_priv = debug_priv;
636         } else {
637                 media->debug_handler = media_debug_default;
638                 media->debug_priv = NULL;
639         }
640 }
641
642 static struct media_device *__media_device_new(void)
643 {
644         struct media_device *media;
645
646         media = calloc(1, sizeof(*media));
647         if (media == NULL)
648                 return NULL;
649
650         media->fd = -1;
651         media->refcount = 1;
652
653         media_debug_set_handler(media, NULL, NULL);
654
655         return media;
656 }
657
658 struct media_device *media_device_new(const char *devnode)
659 {
660         struct media_device *media;
661
662         media = __media_device_new();
663         if (media == NULL)
664                 return NULL;
665
666         media->devnode = strdup(devnode);
667         if (media->devnode == NULL) {
668                 media_device_unref(media);
669                 return NULL;
670         }
671
672         return media;
673 }
674
675 struct media_device *media_device_new_emulated(struct media_device_info *info)
676 {
677         struct media_device *media;
678
679         media = __media_device_new();
680         if (media == NULL)
681                 return NULL;
682
683         media->info = *info;
684
685         return media;
686 }
687
688 struct media_device *media_device_ref(struct media_device *media)
689 {
690         media->refcount++;
691         return media;
692 }
693
694 void media_device_unref(struct media_device *media)
695 {
696         unsigned int i;
697
698         media->refcount--;
699         if (media->refcount > 0)
700                 return;
701
702         for (i = 0; i < media->entities_count; ++i) {
703                 struct media_entity *entity = &media->entities[i];
704
705                 free(entity->pads);
706                 free(entity->links);
707                 if (entity->fd != -1)
708                         close(entity->fd);
709         }
710
711         free(media->entities);
712         free(media->devnode);
713         free(media);
714 }
715
716 int media_device_add_entity(struct media_device *media,
717                             const struct media_entity_desc *desc,
718                             const char *devnode)
719 {
720         struct media_entity **defent = NULL;
721         struct media_entity *entity;
722         unsigned int size;
723
724         size = (media->entities_count + 1) * sizeof(*media->entities);
725         entity = realloc(media->entities, size);
726         if (entity == NULL)
727                 return -ENOMEM;
728
729         media->entities = entity;
730         media->entities_count++;
731
732         entity = &media->entities[media->entities_count - 1];
733         memset(entity, 0, sizeof *entity);
734
735         entity->fd = -1;
736         entity->media = media;
737         strncpy(entity->devname, devnode, sizeof entity->devname);
738         entity->devname[sizeof entity->devname - 1] = '\0';
739
740         entity->info.id = 0;
741         entity->info.type = desc->type;
742         entity->info.flags = 0;
743         memcpy(entity->info.name, desc->name, sizeof entity->info.name);
744
745         switch (entity->info.type) {
746         case MEDIA_ENT_T_DEVNODE_V4L:
747                 defent = &media->def.v4l;
748                 entity->info.v4l = desc->v4l;
749                 break;
750         case MEDIA_ENT_T_DEVNODE_FB:
751                 defent = &media->def.fb;
752                 entity->info.fb = desc->fb;
753                 break;
754         case MEDIA_ENT_T_DEVNODE_ALSA:
755                 defent = &media->def.alsa;
756                 entity->info.alsa = desc->alsa;
757                 break;
758         case MEDIA_ENT_T_DEVNODE_DVB:
759                 defent = &media->def.dvb;
760                 entity->info.dvb = desc->dvb;
761                 break;
762         }
763
764         if (desc->flags & MEDIA_ENT_FL_DEFAULT) {
765                 entity->info.flags |= MEDIA_ENT_FL_DEFAULT;
766                 if (defent)
767                         *defent = entity;
768         }
769
770         return 0;
771 }
772
773 struct media_pad *media_parse_pad(struct media_device *media,
774                                   const char *p, char **endp)
775 {
776         unsigned int entity_id, pad;
777         struct media_entity *entity;
778         char *end;
779
780         /* endp can be NULL. To avoid spreading NULL checks across the function,
781          * set endp to &end in that case.
782          */
783         if (endp == NULL)
784                 endp = &end;
785
786         for (; isspace(*p); ++p);
787
788         if (*p == '"' || *p == '\'') {
789                 for (end = (char *)p + 1; *end && *end != '"' && *end != '\''; ++end);
790                 if (*end != '"' && *end != '\'') {
791                         media_dbg(media, "missing matching '\"'\n");
792                         *endp = end;
793                         return NULL;
794                 }
795
796                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
797                 if (entity == NULL) {
798                         media_dbg(media, "no such entity \"%.*s\"\n", end - p - 1, p + 1);
799                         *endp = (char *)p + 1;
800                         return NULL;
801                 }
802
803                 ++end;
804         } else {
805                 entity_id = strtoul(p, &end, 10);
806                 entity = media_get_entity_by_id(media, entity_id);
807                 if (entity == NULL) {
808                         media_dbg(media, "no such entity %d\n", entity_id);
809                         *endp = (char *)p;
810                         return NULL;
811                 }
812         }
813         for (; isspace(*end); ++end);
814
815         if (*end != ':') {
816                 media_dbg(media, "Expected ':'\n", *end);
817                 *endp = end;
818                 return NULL;
819         }
820
821         for (p = end + 1; isspace(*p); ++p);
822
823         pad = strtoul(p, &end, 10);
824
825         if (pad >= entity->info.pads) {
826                 media_dbg(media, "No pad '%d' on entity \"%s\". Maximum pad number is %d\n",
827                                 pad, entity->info.name, entity->info.pads - 1);
828                 *endp = (char *)p;
829                 return NULL;
830         }
831
832         for (p = end; isspace(*p); ++p);
833         *endp = (char *)p;
834
835         return &entity->pads[pad];
836 }
837
838 struct media_link *media_parse_link(struct media_device *media,
839                                     const char *p, char **endp)
840 {
841         struct media_link *link;
842         struct media_pad *source;
843         struct media_pad *sink;
844         unsigned int i;
845         char *end;
846
847         source = media_parse_pad(media, p, &end);
848         if (source == NULL) {
849                 *endp = end;
850                 return NULL;
851         }
852
853         if (end[0] != '-' || end[1] != '>') {
854                 *endp = end;
855                 media_dbg(media, "Expected '->'\n");
856                 return NULL;
857         }
858
859         p = end + 2;
860
861         sink = media_parse_pad(media, p, &end);
862         if (sink == NULL) {
863                 *endp = end;
864                 return NULL;
865         }
866
867         *endp = end;
868
869         for (i = 0; i < source->entity->num_links; i++) {
870                 link = &source->entity->links[i];
871
872                 if (link->source == source && link->sink == sink)
873                         return link;
874         }
875
876         media_dbg(media, "No link between \"%s\":%d and \"%s\":%d\n",
877                         source->entity->info.name, source->index,
878                         sink->entity->info.name, sink->index);
879         return NULL;
880 }
881
882 int media_parse_setup_link(struct media_device *media,
883                            const char *p, char **endp)
884 {
885         struct media_link *link;
886         __u32 flags;
887         char *end;
888
889         link = media_parse_link(media, p, &end);
890         if (link == NULL) {
891                 media_dbg(media,
892                           "%s: Unable to parse link\n", __func__);
893                 *endp = end;
894                 return -EINVAL;
895         }
896
897         p = end;
898         if (*p++ != '[') {
899                 media_dbg(media, "Unable to parse link flags: expected '['.\n");
900                 *endp = (char *)p - 1;
901                 return -EINVAL;
902         }
903
904         flags = strtoul(p, &end, 10);
905         for (p = end; isspace(*p); p++);
906         if (*p++ != ']') {
907                 media_dbg(media, "Unable to parse link flags: expected ']'.\n");
908                 *endp = (char *)p - 1;
909                 return -EINVAL;
910         }
911
912         for (; isspace(*p); p++);
913         *endp = (char *)p;
914
915         media_dbg(media,
916                   "Setting up link %u:%u -> %u:%u [%u]\n",
917                   link->source->entity->info.id, link->source->index,
918                   link->sink->entity->info.id, link->sink->index,
919                   flags);
920
921         return media_setup_link(media, link->source, link->sink, flags);
922 }
923
924 void media_print_streampos(struct media_device *media, const char *p,
925                            const char *end)
926 {
927         int pos;
928
929         pos = end - p + 1;
930
931         if (pos < 0)
932                 pos = 0;
933         if (pos > strlen(p))
934                 pos = strlen(p);
935
936         media_dbg(media, "\n");
937         media_dbg(media, " %s\n", p);
938         media_dbg(media, " %*s\n", pos, "^");
939 }
940
941 int media_parse_setup_links(struct media_device *media, const char *p)
942 {
943         char *end;
944         int ret;
945
946         do {
947                 ret = media_parse_setup_link(media, p, &end);
948                 if (ret < 0) {
949                         media_print_streampos(media, p, end);
950                         return ret;
951                 }
952
953                 p = end + 1;
954         } while (*end == ',');
955
956         return *end ? -EINVAL : 0;
957 }