Expose default devices
[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
163 const struct media_device_info *media_get_info(struct media_device *media)
164 {
165         return &media->info;
166 }
167
168 const char *media_get_devnode(struct media_device *media)
169 {
170         return media->devnode;
171 }
172
173 const struct media_entity_desc *media_entity_get_info(struct media_entity *entity)
174 {
175         return &entity->info;
176 }
177
178 /* -----------------------------------------------------------------------------
179  * Open/close
180  */
181
182 static int media_device_open(struct media_device *media)
183 {
184         int ret;
185
186         if (media->fd != -1)
187                 return 0;
188
189         media_dbg(media, "Opening media device %s\n", media->devnode);
190
191         media->fd = open(media->devnode, O_RDWR);
192         if (media->fd < 0) {
193                 ret = -errno;
194                 media_dbg(media, "%s: Can't open media device %s\n",
195                           __func__, media->devnode);
196                 return ret;
197         }
198
199         return 0;
200 }
201
202 static void media_device_close(struct media_device *media)
203 {
204         if (media->fd != -1) {
205                 close(media->fd);
206                 media->fd = -1;
207         }
208 }
209
210 /* -----------------------------------------------------------------------------
211  * Link setup
212  */
213
214 int media_setup_link(struct media_device *media,
215                      struct media_pad *source,
216                      struct media_pad *sink,
217                      __u32 flags)
218 {
219         struct media_link *link;
220         struct media_link_desc ulink;
221         unsigned int i;
222         int ret;
223
224         ret = media_device_open(media);
225         if (ret < 0)
226                 goto done;
227
228         for (i = 0; i < source->entity->num_links; i++) {
229                 link = &source->entity->links[i];
230
231                 if (link->source->entity == source->entity &&
232                     link->source->index == source->index &&
233                     link->sink->entity == sink->entity &&
234                     link->sink->index == sink->index)
235                         break;
236         }
237
238         if (i == source->entity->num_links) {
239                 media_dbg(media, "%s: Link not found\n", __func__);
240                 ret = -ENOENT;
241                 goto done;
242         }
243
244         /* source pad */
245         ulink.source.entity = source->entity->info.id;
246         ulink.source.index = source->index;
247         ulink.source.flags = MEDIA_PAD_FL_SOURCE;
248
249         /* sink pad */
250         ulink.sink.entity = sink->entity->info.id;
251         ulink.sink.index = sink->index;
252         ulink.sink.flags = MEDIA_PAD_FL_SINK;
253
254         ulink.flags = flags | (link->flags & MEDIA_LNK_FL_IMMUTABLE);
255
256         ret = ioctl(media->fd, MEDIA_IOC_SETUP_LINK, &ulink);
257         if (ret == -1) {
258                 ret = -errno;
259                 media_dbg(media, "%s: Unable to setup link (%s)\n",
260                           __func__, strerror(errno));
261                 goto done;
262         }
263
264         link->flags = ulink.flags;
265         link->twin->flags = ulink.flags;
266
267         ret = 0;
268
269 done:
270         media_device_close(media);
271         return ret;
272 }
273
274 int media_reset_links(struct media_device *media)
275 {
276         unsigned int i, j;
277         int ret;
278
279         for (i = 0; i < media->entities_count; ++i) {
280                 struct media_entity *entity = &media->entities[i];
281
282                 for (j = 0; j < entity->num_links; j++) {
283                         struct media_link *link = &entity->links[j];
284
285                         if (link->flags & MEDIA_LNK_FL_IMMUTABLE ||
286                             link->source->entity != entity)
287                                 continue;
288
289                         ret = media_setup_link(media, link->source, link->sink,
290                                                link->flags & ~MEDIA_LNK_FL_ENABLED);
291                         if (ret < 0)
292                                 return ret;
293                 }
294         }
295
296         return 0;
297 }
298
299 /* -----------------------------------------------------------------------------
300  * Entities, pads and links enumeration
301  */
302
303 static struct media_link *media_entity_add_link(struct media_entity *entity)
304 {
305         if (entity->num_links >= entity->max_links) {
306                 struct media_link *links = entity->links;
307                 unsigned int max_links = entity->max_links * 2;
308                 unsigned int i;
309
310                 links = realloc(links, max_links * sizeof *links);
311                 if (links == NULL)
312                         return NULL;
313
314                 for (i = 0; i < entity->num_links; ++i)
315                         links[i].twin->twin = &links[i];
316
317                 entity->max_links = max_links;
318                 entity->links = links;
319         }
320
321         return &entity->links[entity->num_links++];
322 }
323
324 static int media_enum_links(struct media_device *media)
325 {
326         __u32 id;
327         int ret = 0;
328
329         for (id = 1; id <= media->entities_count; id++) {
330                 struct media_entity *entity = &media->entities[id - 1];
331                 struct media_links_enum links;
332                 unsigned int i;
333
334                 links.entity = entity->info.id;
335                 links.pads = calloc(entity->info.pads, sizeof(struct media_pad_desc));
336                 links.links = calloc(entity->info.links, sizeof(struct media_link_desc));
337
338                 if (ioctl(media->fd, MEDIA_IOC_ENUM_LINKS, &links) < 0) {
339                         ret = -errno;
340                         media_dbg(media,
341                                   "%s: Unable to enumerate pads and links (%s).\n",
342                                   __func__, strerror(errno));
343                         free(links.pads);
344                         free(links.links);
345                         return ret;
346                 }
347
348                 for (i = 0; i < entity->info.pads; ++i) {
349                         entity->pads[i].entity = entity;
350                         entity->pads[i].index = links.pads[i].index;
351                         entity->pads[i].flags = links.pads[i].flags;
352                 }
353
354                 for (i = 0; i < entity->info.links; ++i) {
355                         struct media_link_desc *link = &links.links[i];
356                         struct media_link *fwdlink;
357                         struct media_link *backlink;
358                         struct media_entity *source;
359                         struct media_entity *sink;
360
361                         source = media_get_entity_by_id(media, link->source.entity);
362                         sink = media_get_entity_by_id(media, link->sink.entity);
363
364                         if (source == NULL || sink == NULL) {
365                                 media_dbg(media,
366                                           "WARNING entity %u link %u from %u/%u to %u/%u is invalid!\n",
367                                           id, i, link->source.entity,
368                                           link->source.index,
369                                           link->sink.entity,
370                                           link->sink.index);
371                                 ret = -EINVAL;
372                         } else {
373                                 fwdlink = media_entity_add_link(source);
374                                 fwdlink->source = &source->pads[link->source.index];
375                                 fwdlink->sink = &sink->pads[link->sink.index];
376                                 fwdlink->flags = link->flags;
377
378                                 backlink = media_entity_add_link(sink);
379                                 backlink->source = &source->pads[link->source.index];
380                                 backlink->sink = &sink->pads[link->sink.index];
381                                 backlink->flags = link->flags;
382
383                                 fwdlink->twin = backlink;
384                                 backlink->twin = fwdlink;
385                         }
386                 }
387
388                 free(links.pads);
389                 free(links.links);
390         }
391
392         return ret;
393 }
394
395 #ifdef HAVE_LIBUDEV
396
397 #include <libudev.h>
398
399 static inline int media_udev_open(struct udev **udev)
400 {
401         *udev = udev_new();
402         if (*udev == NULL)
403                 return -ENOMEM;
404         return 0;
405 }
406
407 static inline void media_udev_close(struct udev *udev)
408 {
409         if (udev != NULL)
410                 udev_unref(udev);
411 }
412
413 static int media_get_devname_udev(struct udev *udev,
414                 struct media_entity *entity)
415 {
416         struct udev_device *device;
417         dev_t devnum;
418         const char *p;
419         int ret = -ENODEV;
420
421         if (udev == NULL)
422                 return -EINVAL;
423
424         devnum = makedev(entity->info.v4l.major, entity->info.v4l.minor);
425         media_dbg(entity->media, "looking up device: %u:%u\n",
426                   major(devnum), minor(devnum));
427         device = udev_device_new_from_devnum(udev, 'c', devnum);
428         if (device) {
429                 p = udev_device_get_devnode(device);
430                 if (p) {
431                         strncpy(entity->devname, p, sizeof(entity->devname));
432                         entity->devname[sizeof(entity->devname) - 1] = '\0';
433                 }
434                 ret = 0;
435         }
436
437         udev_device_unref(device);
438
439         return ret;
440 }
441
442 #else   /* HAVE_LIBUDEV */
443
444 struct udev;
445
446 static inline int media_udev_open(struct udev **udev) { return 0; }
447
448 static inline void media_udev_close(struct udev *udev) { }
449
450 static inline int media_get_devname_udev(struct udev *udev,
451                 struct media_entity *entity)
452 {
453         return -ENOTSUP;
454 }
455
456 #endif  /* HAVE_LIBUDEV */
457
458 static int media_get_devname_sysfs(struct media_entity *entity)
459 {
460         struct stat devstat;
461         char devname[32];
462         char sysname[32];
463         char target[1024];
464         char *p;
465         int ret;
466
467         sprintf(sysname, "/sys/dev/char/%u:%u", entity->info.v4l.major,
468                 entity->info.v4l.minor);
469         ret = readlink(sysname, target, sizeof(target));
470         if (ret < 0)
471                 return -errno;
472
473         target[ret] = '\0';
474         p = strrchr(target, '/');
475         if (p == NULL)
476                 return -EINVAL;
477
478         sprintf(devname, "/dev/%s", p + 1);
479         ret = stat(devname, &devstat);
480         if (ret < 0)
481                 return -errno;
482
483         /* Sanity check: udev might have reordered the device nodes.
484          * Make sure the major/minor match. We should really use
485          * libudev.
486          */
487         if (major(devstat.st_rdev) == entity->info.v4l.major &&
488             minor(devstat.st_rdev) == entity->info.v4l.minor)
489                 strcpy(entity->devname, devname);
490
491         return 0;
492 }
493
494 static int media_enum_entities(struct media_device *media)
495 {
496         struct media_entity *entity;
497         struct udev *udev;
498         unsigned int size;
499         __u32 id;
500         int ret;
501
502         ret = media_udev_open(&udev);
503         if (ret < 0)
504                 media_dbg(media, "Can't get udev context\n");
505
506         for (id = 0, ret = 0; ; id = entity->info.id) {
507                 size = (media->entities_count + 1) * sizeof(*media->entities);
508                 media->entities = realloc(media->entities, size);
509
510                 entity = &media->entities[media->entities_count];
511                 memset(entity, 0, sizeof(*entity));
512                 entity->fd = -1;
513                 entity->info.id = id | MEDIA_ENT_ID_FLAG_NEXT;
514                 entity->media = media;
515
516                 ret = ioctl(media->fd, MEDIA_IOC_ENUM_ENTITIES, &entity->info);
517                 if (ret < 0) {
518                         ret = errno != EINVAL ? -errno : 0;
519                         break;
520                 }
521
522                 /* Number of links (for outbound links) plus number of pads (for
523                  * inbound links) is a good safe initial estimate of the total
524                  * number of links.
525                  */
526                 entity->max_links = entity->info.pads + entity->info.links;
527
528                 entity->pads = malloc(entity->info.pads * sizeof(*entity->pads));
529                 entity->links = malloc(entity->max_links * sizeof(*entity->links));
530                 if (entity->pads == NULL || entity->links == NULL) {
531                         ret = -ENOMEM;
532                         break;
533                 }
534
535                 media->entities_count++;
536
537                 if (entity->info.flags & MEDIA_ENT_FL_DEFAULT) {
538                         switch (entity->info.type) {
539                         case MEDIA_ENT_T_DEVNODE_V4L:
540                                 media->def.v4l = entity;
541                                 break;
542                         case MEDIA_ENT_T_DEVNODE_FB:
543                                 media->def.fb = entity;
544                                 break;
545                         case MEDIA_ENT_T_DEVNODE_ALSA:
546                                 media->def.alsa = entity;
547                                 break;
548                         case MEDIA_ENT_T_DEVNODE_DVB:
549                                 media->def.dvb = entity;
550                                 break;
551                         }
552                 }
553
554                 /* Find the corresponding device name. */
555                 if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE &&
556                     media_entity_type(entity) != MEDIA_ENT_T_V4L2_SUBDEV)
557                         continue;
558
559                 /* Try to get the device name via udev */
560                 if (!media_get_devname_udev(udev, entity))
561                         continue;
562
563                 /* Fall back to get the device name via sysfs */
564                 media_get_devname_sysfs(entity);
565         }
566
567         media_udev_close(udev);
568         return ret;
569 }
570
571 int media_device_enumerate(struct media_device *media)
572 {
573         int ret;
574
575         if (media->entities)
576                 return 0;
577
578         ret = media_device_open(media);
579         if (ret < 0)
580                 return ret;
581
582         ret = ioctl(media->fd, MEDIA_IOC_DEVICE_INFO, &media->info);
583         if (ret < 0) {
584                 ret = -errno;
585                 media_dbg(media, "%s: Unable to retrieve media device "
586                           "information for device %s (%s)\n", __func__,
587                           media->devnode, strerror(errno));
588                 goto done;
589         }
590
591         media_dbg(media, "Enumerating entities\n");
592
593         ret = media_enum_entities(media);
594         if (ret < 0) {
595                 media_dbg(media,
596                           "%s: Unable to enumerate entities for device %s (%s)\n",
597                           __func__, media->devnode, strerror(-ret));
598                 goto done;
599         }
600
601         media_dbg(media, "Found %u entities\n", media->entities_count);
602         media_dbg(media, "Enumerating pads and links\n");
603
604         ret = media_enum_links(media);
605         if (ret < 0) {
606                 media_dbg(media,
607                           "%s: Unable to enumerate pads and linksfor device %s\n",
608                           __func__, media->devnode);
609                 goto done;
610         }
611
612         ret = 0;
613
614 done:
615         media_device_close(media);
616         return ret;
617 }
618
619 /* -----------------------------------------------------------------------------
620  * Create/destroy
621  */
622
623 static void media_debug_default(void *ptr, ...)
624 {
625 }
626
627 void media_debug_set_handler(struct media_device *media,
628                              void (*debug_handler)(void *, ...),
629                              void *debug_priv)
630 {
631         if (debug_handler) {
632                 media->debug_handler = debug_handler;
633                 media->debug_priv = debug_priv;
634         } else {
635                 media->debug_handler = media_debug_default;
636                 media->debug_priv = NULL;
637         }
638 }
639
640 struct media_device *media_device_new(const char *devnode)
641 {
642         struct media_device *media;
643         int ret;
644
645         media = calloc(1, sizeof(*media));
646         if (media == NULL)
647                 return NULL;
648
649         media->fd = -1;
650         media->refcount = 1;
651
652         media_debug_set_handler(media, NULL, NULL);
653
654         media->devnode = strdup(devnode);
655         if (media->devnode == NULL) {
656                 media_device_unref(media);
657                 return NULL;
658         }
659
660         return media;
661 }
662
663 struct media_device *media_device_ref(struct media_device *media)
664 {
665         media->refcount++;
666         return media;
667 }
668
669 void media_device_unref(struct media_device *media)
670 {
671         unsigned int i;
672
673         media->refcount--;
674         if (media->refcount > 0)
675                 return;
676
677         for (i = 0; i < media->entities_count; ++i) {
678                 struct media_entity *entity = &media->entities[i];
679
680                 free(entity->pads);
681                 free(entity->links);
682                 if (entity->fd != -1)
683                         close(entity->fd);
684         }
685
686         free(media->entities);
687         free(media->devnode);
688         free(media);
689 }
690
691 /* -----------------------------------------------------------------------------
692  * Parsing
693  */
694
695 struct media_pad *media_parse_pad(struct media_device *media,
696                                   const char *p, char **endp)
697 {
698         unsigned int entity_id, pad;
699         struct media_entity *entity;
700         char *end;
701
702         /* endp can be NULL. To avoid spreading NULL checks across the function,
703          * set endp to &end in that case.
704          */
705         if (endp == NULL)
706                 endp = &end;
707
708         for (; isspace(*p); ++p);
709
710         if (*p == '"' || *p == '\'') {
711                 for (end = (char *)p + 1; *end && *end != '"' && *end != '\''; ++end);
712                 if (*end != '"' && *end != '\'') {
713                         media_dbg(media, "missing matching '\"'\n");
714                         *endp = end;
715                         return NULL;
716                 }
717
718                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
719                 if (entity == NULL) {
720                         media_dbg(media, "no such entity \"%.*s\"\n", end - p - 1, p + 1);
721                         *endp = (char *)p + 1;
722                         return NULL;
723                 }
724
725                 ++end;
726         } else {
727                 entity_id = strtoul(p, &end, 10);
728                 entity = media_get_entity_by_id(media, entity_id);
729                 if (entity == NULL) {
730                         media_dbg(media, "no such entity %d\n", entity_id);
731                         *endp = (char *)p;
732                         return NULL;
733                 }
734         }
735         for (; isspace(*end); ++end);
736
737         if (*end != ':') {
738                 media_dbg(media, "Expected ':'\n", *end);
739                 *endp = end;
740                 return NULL;
741         }
742
743         for (p = end + 1; isspace(*p); ++p);
744
745         pad = strtoul(p, &end, 10);
746
747         if (pad >= entity->info.pads) {
748                 media_dbg(media, "No pad '%d' on entity \"%s\". Maximum pad number is %d\n",
749                                 pad, entity->info.name, entity->info.pads - 1);
750                 *endp = (char *)p;
751                 return NULL;
752         }
753
754         for (p = end; isspace(*p); ++p);
755         *endp = (char *)p;
756
757         return &entity->pads[pad];
758 }
759
760 struct media_link *media_parse_link(struct media_device *media,
761                                     const char *p, char **endp)
762 {
763         struct media_link *link;
764         struct media_pad *source;
765         struct media_pad *sink;
766         unsigned int i;
767         char *end;
768
769         source = media_parse_pad(media, p, &end);
770         if (source == NULL) {
771                 *endp = end;
772                 return NULL;
773         }
774
775         if (end[0] != '-' || end[1] != '>') {
776                 *endp = end;
777                 media_dbg(media, "Expected '->'\n");
778                 return NULL;
779         }
780
781         p = end + 2;
782
783         sink = media_parse_pad(media, p, &end);
784         if (sink == NULL) {
785                 *endp = end;
786                 return NULL;
787         }
788
789         *endp = end;
790
791         for (i = 0; i < source->entity->num_links; i++) {
792                 link = &source->entity->links[i];
793
794                 if (link->source == source && link->sink == sink)
795                         return link;
796         }
797
798         media_dbg(media, "No link between \"%s\":%d and \"%s\":%d\n",
799                         source->entity->info.name, source->index,
800                         sink->entity->info.name, sink->index);
801         return NULL;
802 }
803
804 int media_parse_setup_link(struct media_device *media,
805                            const char *p, char **endp)
806 {
807         struct media_link *link;
808         __u32 flags;
809         char *end;
810
811         link = media_parse_link(media, p, &end);
812         if (link == NULL) {
813                 media_dbg(media,
814                           "%s: Unable to parse link\n", __func__);
815                 *endp = end;
816                 return -EINVAL;
817         }
818
819         p = end;
820         if (*p++ != '[') {
821                 media_dbg(media, "Unable to parse link flags: expected '['.\n");
822                 *endp = (char *)p - 1;
823                 return -EINVAL;
824         }
825
826         flags = strtoul(p, &end, 10);
827         for (p = end; isspace(*p); p++);
828         if (*p++ != ']') {
829                 media_dbg(media, "Unable to parse link flags: expected ']'.\n");
830                 *endp = (char *)p - 1;
831                 return -EINVAL;
832         }
833
834         for (; isspace(*p); p++);
835         *endp = (char *)p;
836
837         media_dbg(media,
838                   "Setting up link %u:%u -> %u:%u [%u]\n",
839                   link->source->entity->info.id, link->source->index,
840                   link->sink->entity->info.id, link->sink->index,
841                   flags);
842
843         return media_setup_link(media, link->source, link->sink, flags);
844 }
845
846 void media_print_streampos(struct media_device *media, const char *p,
847                            const char *end)
848 {
849         int pos;
850
851         pos = end - p + 1;
852
853         if (pos < 0)
854                 pos = 0;
855         if (pos > strlen(p))
856                 pos = strlen(p);
857
858         media_dbg(media, "\n");
859         media_dbg(media, " %s\n", p);
860         media_dbg(media, " %*s\n", pos, "^");
861 }
862
863 int media_parse_setup_links(struct media_device *media, const char *p)
864 {
865         char *end;
866         int ret;
867
868         do {
869                 ret = media_parse_setup_link(media, p, &end);
870                 if (ret < 0) {
871                         media_print_streampos(media, p, end);
872                         return ret;
873                 }
874
875                 p = end + 1;
876         } while (*end == ',');
877
878         return *end ? -EINVAL : 0;
879 }