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 "tools.h"
  42
  43 struct media_pad *media_entity_remote_source(struct media_pad *pad)
  44 {
  45         unsigned int i;
  46
  47         if (!(pad->flags & MEDIA_PAD_FL_SINK))
  48                 return NULL;
  49
  50         for (i = 0; i < pad->entity->num_links; ++i) {
  51                 struct media_link *link = &pad->entity->links[i];
  52
  53                 if (!(link->flags & MEDIA_LNK_FL_ENABLED))
  54                         continue;
  55
  56                 if (link->sink == pad)
  57                         return link->source;
  58         }
  59
  60         return NULL;
  61 }
  62
  63 struct media_entity *media_get_entity_by_name(struct media_device *media,
  64                                               const char *name, size_t length)
  65 {
  66         unsigned int i;
  67
  68         /* A match is impossible if the entity name is longer than the maximum
  69          * size we can get from the kernel.
  70          */
  71         if (length >= FIELD_SIZEOF(struct media_entity_desc, name))
  72                 return NULL;
  73
  74         for (i = 0; i < media->entities_count; ++i) {
  75                 struct media_entity *entity = &media->entities[i];
  76
  77                 if (strncmp(entity->info.name, name, length) == 0 &&
  78                     entity->info.name[length] == '\0')
  79                         return entity;
  80         }
  81
  82         return NULL;
  83 }
  84
  85 struct media_entity *media_get_entity_by_id(struct media_device *media,
  86                                             __u32 id)
  87 {
  88         bool next = id & MEDIA_ENT_ID_FLAG_NEXT;
  89         unsigned int i;
  90
  91         id &= ~MEDIA_ENT_ID_FLAG_NEXT;
  92
  93         for (i = 0; i < media->entities_count; ++i) {
  94                 struct media_entity *entity = &media->entities[i];
  95
  96                 if ((entity->info.id == id && !next) ||
  97                     (entity->info.id > id && next))
  98                         return entity;
  99         }
 100
 101         return NULL;
 102 }
 103
 104 int media_setup_link(struct media_device *media,
 105                      struct media_pad *source,
 106                      struct media_pad *sink,
 107                      __u32 flags)
 108 {
 109         struct media_link *link;
 110         struct media_link_desc ulink;
 111         unsigned int i;
 112         int ret;
 113
 114         for (i = 0; i < source->entity->num_links; i++) {
 115                 link = &source->entity->links[i];
 116
 117                 if (link->source->entity == source->entity &&
 118                     link->source->index == source->index &&
 119                     link->sink->entity == sink->entity &&
 120                     link->sink->index == sink->index)
 121                         break;
 122         }
 123
 124         if (i == source->entity->num_links) {
 125                 media_dbg(media, "%s: Link not found\n", __func__);
 126                 return -ENOENT;
 127         }
 128
 129         /* source pad */
 130         ulink.source.entity = source->entity->info.id;
 131         ulink.source.index = source->index;
 132         ulink.source.flags = MEDIA_PAD_FL_SOURCE;
 133
 134         /* sink pad */
 135         ulink.sink.entity = sink->entity->info.id;
 136         ulink.sink.index = sink->index;
 137         ulink.sink.flags = MEDIA_PAD_FL_SINK;
 138
 139         ulink.flags = flags | (link->flags & MEDIA_LNK_FL_IMMUTABLE);
 140
 141         ret = ioctl(media->fd, MEDIA_IOC_SETUP_LINK, &ulink);
 142         if (ret == -1) {
 143                 media_dbg(media, "%s: Unable to setup link (%s)\n",
 144                           __func__, strerror(errno));
 145                 return -errno;
 146         }
 147
 148         link->flags = ulink.flags;
 149         link->twin->flags = ulink.flags;
 150         return 0;
 151 }
 152
 153 int media_reset_links(struct media_device *media)
 154 {
 155         unsigned int i, j;
 156         int ret;
 157
 158         for (i = 0; i < media->entities_count; ++i) {
 159                 struct media_entity *entity = &media->entities[i];
 160
 161                 for (j = 0; j < entity->num_links; j++) {
 162                         struct media_link *link = &entity->links[j];
 163
 164                         if (link->flags & MEDIA_LNK_FL_IMMUTABLE ||
 165                             link->source->entity != entity)
 166                                 continue;
 167
 168                         ret = media_setup_link(media, link->source, link->sink,
 169                                                link->flags & ~MEDIA_LNK_FL_ENABLED);
 170                         if (ret < 0)
 171                                 return ret;
 172                 }
 173         }
 174
 175         return 0;
 176 }
 177
 178 static struct media_link *media_entity_add_link(struct media_entity *entity)
 179 {
 180         if (entity->num_links >= entity->max_links) {
 181                 struct media_link *links = entity->links;
 182                 unsigned int max_links = entity->max_links * 2;
 183                 unsigned int i;
 184
 185                 links = realloc(links, max_links * sizeof *links);
 186                 if (links == NULL)
 187                         return NULL;
 188
 189                 for (i = 0; i < entity->num_links; ++i)
 190                         links[i].twin->twin = &links[i];
 191
 192                 entity->max_links = max_links;
 193                 entity->links = links;
 194         }
 195
 196         return &entity->links[entity->num_links++];
 197 }
 198
 199 static int media_enum_links(struct media_device *media)
 200 {
 201         __u32 id;
 202         int ret = 0;
 203
 204         for (id = 1; id <= media->entities_count; id++) {
 205                 struct media_entity *entity = &media->entities[id - 1];
 206                 struct media_links_enum links;
 207                 unsigned int i;
 208
 209                 links.entity = entity->info.id;
 210                 links.pads = calloc(entity->info.pads, sizeof(struct media_pad_desc));
 211                 links.links = calloc(entity->info.links, sizeof(struct media_link_desc));
 212
 213                 if (ioctl(media->fd, MEDIA_IOC_ENUM_LINKS, &links) < 0) {
 214                         media_dbg(media,
 215                                   "%s: Unable to enumerate pads and links (%s).\n",
 216                                   __func__, strerror(errno));
 217                         free(links.pads);
 218                         free(links.links);
 219                         return -errno;
 220                 }
 221
 222                 for (i = 0; i < entity->info.pads; ++i) {
 223                         entity->pads[i].entity = entity;
 224                         entity->pads[i].index = links.pads[i].index;
 225                         entity->pads[i].flags = links.pads[i].flags;
 226                 }
 227
 228                 for (i = 0; i < entity->info.links; ++i) {
 229                         struct media_link_desc *link = &links.links[i];
 230                         struct media_link *fwdlink;
 231                         struct media_link *backlink;
 232                         struct media_entity *source;
 233                         struct media_entity *sink;
 234
 235                         source = media_get_entity_by_id(media, link->source.entity);
 236                         sink = media_get_entity_by_id(media, link->sink.entity);
 237
 238                         if (source == NULL || sink == NULL) {
 239                                 media_dbg(media,
 240                                           "WARNING entity %u link %u from %u/%u to %u/%u is invalid!\n",
 241                                           id, i, link->source.entity,
 242                                           link->source.index,
 243                                           link->sink.entity,
 244                                           link->sink.index);
 245                                 ret = -EINVAL;
 246                         } else {
 247                                 fwdlink = media_entity_add_link(source);
 248                                 fwdlink->source = &source->pads[link->source.index];
 249                                 fwdlink->sink = &sink->pads[link->sink.index];
 250                                 fwdlink->flags = link->flags;
 251
 252                                 backlink = media_entity_add_link(sink);
 253                                 backlink->source = &source->pads[link->source.index];
 254                                 backlink->sink = &sink->pads[link->sink.index];
 255                                 backlink->flags = link->flags;
 256
 257                                 fwdlink->twin = backlink;
 258                                 backlink->twin = fwdlink;
 259                         }
 260                 }
 261
 262                 free(links.pads);
 263                 free(links.links);
 264         }
 265
 266         return ret;
 267 }
 268
 269 #ifdef HAVE_LIBUDEV
 270
 271 #include <libudev.h>
 272
 273 static inline int media_udev_open(struct udev **udev)
 274 {
 275         *udev = udev_new();
 276         if (*udev == NULL)
 277                 return -ENOMEM;
 278         return 0;
 279 }
 280
 281 static inline void media_udev_close(struct udev *udev)
 282 {
 283         if (udev != NULL)
 284                 udev_unref(udev);
 285 }
 286
 287 static int media_get_devname_udev(struct udev *udev,
 288                 struct media_entity *entity)
 289 {
 290         struct udev_device *device;
 291         dev_t devnum;
 292         const char *p;
 293         int ret = -ENODEV;
 294
 295         if (udev == NULL)
 296                 return -EINVAL;
 297
 298         devnum = makedev(entity->info.v4l.major, entity->info.v4l.minor);
 299         media_dbg(entity->media, "looking up device: %u:%u\n",
 300                   major(devnum), minor(devnum));
 301         device = udev_device_new_from_devnum(udev, 'c', devnum);
 302         if (device) {
 303                 p = udev_device_get_devnode(device);
 304                 if (p) {
 305                         strncpy(entity->devname, p, sizeof(entity->devname));
 306                         entity->devname[sizeof(entity->devname) - 1] = '\0';
 307                 }
 308                 ret = 0;
 309         }
 310
 311         udev_device_unref(device);
 312
 313         return ret;
 314 }
 315
 316 #else   /* HAVE_LIBUDEV */
 317
 318 struct udev;
 319
 320 static inline int media_udev_open(struct udev **udev) { return 0; }
 321
 322 static inline void media_udev_close(struct udev *udev) { }
 323
 324 static inline int media_get_devname_udev(struct udev *udev,
 325                 struct media_entity *entity)
 326 {
 327         return -ENOTSUP;
 328 }
 329
 330 #endif  /* HAVE_LIBUDEV */
 331
 332 static int media_get_devname_sysfs(struct media_entity *entity)
 333 {
 334         struct stat devstat;
 335         char devname[32];
 336         char sysname[32];
 337         char target[1024];
 338         char *p;
 339         int ret;
 340
 341         sprintf(sysname, "/sys/dev/char/%u:%u", entity->info.v4l.major,
 342                 entity->info.v4l.minor);
 343         ret = readlink(sysname, target, sizeof(target));
 344         if (ret < 0)
 345                 return -errno;
 346
 347         target[ret] = '\0';
 348         p = strrchr(target, '/');
 349         if (p == NULL)
 350                 return -EINVAL;
 351
 352         sprintf(devname, "/dev/%s", p + 1);
 353         ret = stat(devname, &devstat);
 354         if (ret < 0)
 355                 return -errno;
 356
 357         /* Sanity check: udev might have reordered the device nodes.
 358          * Make sure the major/minor match. We should really use
 359          * libudev.
 360          */
 361         if (major(devstat.st_rdev) == entity->info.v4l.major &&
 362             minor(devstat.st_rdev) == entity->info.v4l.minor)
 363                 strcpy(entity->devname, devname);
 364
 365         return 0;
 366 }
 367
 368 static int media_enum_entities(struct media_device *media)
 369 {
 370         struct media_entity *entity;
 371         struct udev *udev;
 372         unsigned int size;
 373         __u32 id;
 374         int ret;
 375
 376         ret = media_udev_open(&udev);
 377         if (ret < 0)
 378                 media_dbg(media, "Can't get udev context\n");
 379
 380         for (id = 0, ret = 0; ; id = entity->info.id) {
 381                 size = (media->entities_count + 1) * sizeof(*media->entities);
 382                 media->entities = realloc(media->entities, size);
 383
 384                 entity = &media->entities[media->entities_count];
 385                 memset(entity, 0, sizeof(*entity));
 386                 entity->fd = -1;
 387                 entity->info.id = id | MEDIA_ENT_ID_FLAG_NEXT;
 388                 entity->media = media;
 389
 390                 ret = ioctl(media->fd, MEDIA_IOC_ENUM_ENTITIES, &entity->info);
 391                 if (ret < 0) {
 392                         ret = errno != EINVAL ? -errno : 0;
 393                         break;
 394                 }
 395
 396                 /* Number of links (for outbound links) plus number of pads (for
 397                  * inbound links) is a good safe initial estimate of the total
 398                  * number of links.
 399                  */
 400                 entity->max_links = entity->info.pads + entity->info.links;
 401
 402                 entity->pads = malloc(entity->info.pads * sizeof(*entity->pads));
 403                 entity->links = malloc(entity->max_links * sizeof(*entity->links));
 404                 if (entity->pads == NULL || entity->links == NULL) {
 405                         ret = -ENOMEM;
 406                         break;
 407                 }
 408
 409                 media->entities_count++;
 410
 411                 /* Find the corresponding device name. */
 412                 if (media_entity_type(entity) != MEDIA_ENT_T_DEVNODE &&
 413                     media_entity_type(entity) != MEDIA_ENT_T_V4L2_SUBDEV)
 414                         continue;
 415
 416                 /* Try to get the device name via udev */
 417                 if (!media_get_devname_udev(udev, entity))
 418                         continue;
 419
 420                 /* Fall back to get the device name via sysfs */
 421                 media_get_devname_sysfs(entity);
 422         }
 423
 424         media_udev_close(udev);
 425         return ret;
 426 }
 427
 428 static void media_debug_default(void *ptr, ...)
 429 {
 430 }
 431
 432 void media_debug_set_handler(struct media_device *media,
 433                              void (*debug_handler)(void *, ...),
 434                              void *debug_priv)
 435 {
 436         if (debug_handler) {
 437                 media->debug_handler = debug_handler;
 438                 media->debug_priv = debug_priv;
 439         } else {
 440                 media->debug_handler = media_debug_default;
 441                 media->debug_priv = NULL;
 442         }
 443 }
 444
 445 struct media_device *media_open_debug(
 446         const char *name, void (*debug_handler)(void *, ...),
 447         void *debug_priv)
 448 {
 449         struct media_device *media;
 450         int ret;
 451
 452         media = calloc(1, sizeof(*media));
 453         if (media == NULL)
 454                 return NULL;
 455
 456         media_debug_set_handler(media, debug_handler, debug_priv);
 457
 458         media_dbg(media, "Opening media device %s\n", name);
 459
 460         media->fd = open(name, O_RDWR);
 461         if (media->fd < 0) {
 462                 media_close(media);
 463                 media_dbg(media, "%s: Can't open media device %s\n",
 464                           __func__, name);
 465                 return NULL;
 466         }
 467
 468         ret = ioctl(media->fd, MEDIA_IOC_DEVICE_INFO, &media->info);
 469         if (ret < 0) {
 470                 media_dbg(media, "%s: Unable to retrieve media device "
 471                           "information for device %s (%s)\n", __func__,
 472                           name, strerror(errno));
 473                 media_close(media);
 474                 return NULL;
 475         }
 476
 477         media_dbg(media, "Enumerating entities\n");
 478
 479         ret = media_enum_entities(media);
 480
 481         if (ret < 0) {
 482                 media_dbg(media,
 483                           "%s: Unable to enumerate entities for device %s (%s)\n",
 484                           __func__, name, strerror(-ret));
 485                 media_close(media);
 486                 return NULL;
 487         }
 488
 489         media_dbg(media, "Found %u entities\n", media->entities_count);
 490         media_dbg(media, "Enumerating pads and links\n");
 491
 492         ret = media_enum_links(media);
 493         if (ret < 0) {
 494                 media_dbg(media,
 495                           "%s: Unable to enumerate pads and linksfor device %s\n",
 496                           __func__, name);
 497                 media_close(media);
 498                 return NULL;
 499         }
 500
 501         return media;
 502 }
 503
 504 struct media_device *media_open(const char *name)
 505 {
 506         return media_open_debug(name, NULL, NULL);
 507 }
 508
 509 void media_close(struct media_device *media)
 510 {
 511         unsigned int i;
 512
 513         if (media->fd != -1)
 514                 close(media->fd);
 515
 516         for (i = 0; i < media->entities_count; ++i) {
 517                 struct media_entity *entity = &media->entities[i];
 518
 519                 free(entity->pads);
 520                 free(entity->links);
 521                 if (entity->fd != -1)
 522                         close(entity->fd);
 523         }
 524
 525         free(media->entities);
 526         free(media);
 527 }
 528
 529 struct media_pad *media_parse_pad(struct media_device *media,
 530                                   const char *p, char **endp)
 531 {
 532         unsigned int entity_id, pad;
 533         struct media_entity *entity;
 534         char *end;
 535
 536         for (; isspace(*p); ++p);
 537
 538         if (*p == '"') {
 539                 for (end = (char *)p + 1; *end && *end != '"'; ++end);
 540                 if (*end != '"') {
 541                         media_dbg(media, "missing matching '\"'\n");
 542                         return NULL;
 543                 }
 544
 545                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
 546                 if (entity == NULL) {
 547                         media_dbg(media, "no such entity \"%.*s\"\n", end - p - 1, p + 1);
 548                         return NULL;
 549                 }
 550
 551                 ++end;
 552         } else {
 553                 entity_id = strtoul(p, &end, 10);
 554                 entity = media_get_entity_by_id(media, entity_id);
 555                 if (entity == NULL) {
 556                         media_dbg(media, "no such entity %d\n", entity_id);
 557                         return NULL;
 558                 }
 559         }
 560         for (; isspace(*end); ++end);
 561
 562         if (*end != ':') {
 563                 media_dbg(media, "Expected ':'\n", *end);
 564                 return NULL;
 565         }
 566
 567         for (p = end + 1; isspace(*p); ++p);
 568
 569         pad = strtoul(p, &end, 10);
 570
 571         if (pad >= entity->info.pads) {
 572                 media_dbg(media, "No pad '%d' on entity \"%s\". Maximum pad number is %d\n",
 573                                 pad, entity->info.name, entity->info.pads - 1);
 574                 return NULL;
 575         }
 576
 577         for (p = end; isspace(*p); ++p);
 578         if (endp)
 579                 *endp = (char *)p;
 580
 581         return &entity->pads[pad];
 582 }
 583
 584 struct media_link *media_parse_link(struct media_device *media,
 585                                     const char *p, char **endp)
 586 {
 587         struct media_link *link;
 588         struct media_pad *source;
 589         struct media_pad *sink;
 590         unsigned int i;
 591         char *end;
 592
 593         source = media_parse_pad(media, p, &end);
 594         if (source == NULL)
 595                 return NULL;
 596
 597         if (end[0] != '-' || end[1] != '>') {
 598                 media_dbg(media, "Expected '->'\n");
 599                 return NULL;
 600         }
 601
 602         p = end + 2;
 603
 604         sink = media_parse_pad(media, p, &end);
 605         if (sink == NULL)
 606                 return NULL;
 607
 608         *endp = end;
 609
 610         for (i = 0; i < source->entity->num_links; i++) {
 611                 link = &source->entity->links[i];
 612
 613                 if (link->source == source && link->sink == sink)
 614                         return link;
 615         }
 616
 617         media_dbg(media, "No link between \"%s\":%d and \"%s\":%d\n",
 618                         source->entity->info.name, source->index,
 619                         sink->entity->info.name, sink->index);
 620         return NULL;
 621 }
 622
 623 int media_parse_setup_link(struct media_device *media,
 624                            const char *p, char **endp)
 625 {
 626         struct media_link *link;
 627         __u32 flags;
 628         char *end;
 629
 630         link = media_parse_link(media, p, &end);
 631         if (link == NULL) {
 632                 media_dbg(media,
 633                           "%s: Unable to parse link\n", __func__);
 634                 return -EINVAL;
 635         }
 636
 637         p = end;
 638         if (*p++ != '[') {
 639                 media_dbg(media, "Unable to parse link flags: expected '['.\n");
 640                 return -EINVAL;
 641         }
 642
 643         flags = strtoul(p, &end, 10);
 644         for (p = end; isspace(*p); p++);
 645         if (*p++ != ']') {
 646                 media_dbg(media, "Unable to parse link flags: expected ']'.\n");
 647                 return -EINVAL;
 648         }
 649
 650         for (; isspace(*p); p++);
 651         *endp = (char *)p;
 652
 653         media_dbg(media,
 654                   "Setting up link %u:%u -> %u:%u [%u]\n",
 655                   link->source->entity->info.id, link->source->index,
 656                   link->sink->entity->info.id, link->sink->index,
 657                   flags);
 658
 659         return media_setup_link(media, link->source, link->sink, flags);
 660 }
 661
 662 int media_parse_setup_links(struct media_device *media, const char *p)
 663 {
 664         char *end;
 665         int ret;
 666
 667         do {
 668                 ret = media_parse_setup_link(media, p, &end);
 669                 if (ret < 0)
 670                         return ret;
 671
 672                 p = end + 1;
 673         } while (*end == ',');
 674
 675         return *end ? -EINVAL : 0;
 676 }