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