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