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 }