main.c

   1 /*
   2  * Media controller test application
   3  *
   4  * Copyright (C) 2010 Ideas on board SPRL <laurent.pinchart@ideasonboard.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  */
  19
  20 #include <sys/mman.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/time.h>
  23 #include <sys/stat.h>
  24
  25 #include <ctype.h>
  26 #include <errno.h>
  27 #include <fcntl.h>
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #include <linux/types.h>
  34 #include <linux/media.h>
  35 #include <linux/v4l2-mediabus.h>
  36 #include <linux/v4l2-subdev.h>
  37 #include <linux/videodev2.h>
  38
  39 #include "media.h"
  40 #include "options.h"
  41 #include "subdev.h"
  42
  43 /* -----------------------------------------------------------------------------
  44  * Links setup
  45  */
  46
  47 static struct media_entity_pad *parse_pad(struct media_device *media, const char *p, char **endp)
  48 {
  49         unsigned int entity_id, pad;
  50         struct media_entity *entity;
  51         char *end;
  52
  53         for (; isspace(*p); ++p);
  54
  55         if (*p == '"') {
  56                 for (end = (char *)p + 1; *end && *end != '"'; ++end);
  57                 if (*end != '"')
  58                         return NULL;
  59
  60                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
  61                 if (entity == NULL)
  62                         return NULL;
  63
  64                 for (++end; isspace(*end); ++end);
  65         } else {
  66                 entity_id = strtoul(p, &end, 10);
  67                 entity = media_get_entity_by_id(media, entity_id);
  68                 if (entity == NULL)
  69                         return NULL;
  70         }
  71
  72         if (*end != ':')
  73                 return NULL;
  74         for (p = end + 1; isspace(*p); ++p);
  75
  76         pad = strtoul(p, &end, 10);
  77         for (p = end; isspace(*p); ++p);
  78
  79         if (pad >= entity->info.pads)
  80                 return NULL;
  81
  82         for (p = end; isspace(*p); ++p);
  83         *endp = (char *)p;
  84
  85         return &entity->pads[pad];
  86 }
  87
  88 static struct media_entity_link *parse_link(struct media_device *media, const char *p, char **endp)
  89 {
  90         struct media_entity_link *link;
  91         struct media_entity_pad *source;
  92         struct media_entity_pad *sink;
  93         unsigned int i;
  94         char *end;
  95
  96         source = parse_pad(media, p, &end);
  97         if (source == NULL)
  98                 return NULL;
  99
 100         if (end[0] != '-' || end[1] != '>')
 101                 return NULL;
 102         p = end + 2;
 103
 104         sink = parse_pad(media, p, &end);
 105         if (sink == NULL)
 106                 return NULL;
 107
 108         *endp = end;
 109
 110         for (i = 0; i < source->entity->info.links; i++) {
 111                 link = &source->entity->links[i];
 112
 113                 if (link->source == source && link->sink == sink)
 114                         return link;
 115         }
 116
 117         return NULL;
 118 }
 119
 120 static int setup_link(struct media_device *media, const char *p, char **endp)
 121 {
 122         struct media_entity_link *link;
 123         __u32 flags;
 124         char *end;
 125
 126         link = parse_link(media, p, &end);
 127         if (link == NULL) {
 128                 printf("Unable to parse link\n");
 129                 return -EINVAL;
 130         }
 131
 132         p = end;
 133         if (*p++ != '[') {
 134                 printf("Unable to parse link flags\n");
 135                 return -EINVAL;
 136         }
 137
 138         flags = strtoul(p, &end, 10);
 139         for (p = end; isspace(*p); p++);
 140         if (*p++ != ']') {
 141                 printf("Unable to parse link flags\n");
 142                 return -EINVAL;
 143         }
 144
 145         for (; isspace(*p); p++);
 146         *endp = (char *)p;
 147
 148         printf("Setting up link %u:%u -> %u:%u [%u]\n",
 149                 link->source->entity->info.id, link->source->index,
 150                 link->sink->entity->info.id, link->sink->index,
 151                 flags);
 152
 153         return media_setup_link(media, link->source, link->sink, flags);
 154 }
 155
 156 static int setup_links(struct media_device *media, const char *p)
 157 {
 158         char *end;
 159         int ret;
 160
 161         do {
 162                 ret = setup_link(media, p, &end);
 163                 if (ret < 0)
 164                         return ret;
 165
 166                 p = end + 1;
 167         } while (*end == ',');
 168
 169         return *end ? -EINVAL : 0;
 170 }
 171
 172 /* -----------------------------------------------------------------------------
 173  * Formats setup
 174  */
 175
 176 static int parse_format(struct v4l2_mbus_framefmt *format, const char *p, char **endp)
 177 {
 178         enum v4l2_mbus_pixelcode code;
 179         unsigned int width, height;
 180         char *end;
 181
 182         for (; isspace(*p); ++p);
 183         for (end = (char *)p; !isspace(*end) && *end != '\0'; ++end);
 184
 185         code = string_to_pixelcode(p, end - p);
 186         if (code == (enum v4l2_mbus_pixelcode)-1)
 187                 return -EINVAL;
 188
 189         for (p = end; isspace(*p); ++p);
 190         width = strtoul(p, &end, 10);
 191         if (*end != 'x')
 192                 return -EINVAL;
 193
 194         p = end + 1;
 195         height = strtoul(p, &end, 10);
 196         *endp = end;
 197
 198         memset(format, 0, sizeof(*format));
 199         format->width = width;
 200         format->height = height;
 201         format->code = code;
 202
 203         return 0;
 204 }
 205
 206 static struct media_entity_pad *parse_pad_format(struct media_device *media,
 207         struct v4l2_mbus_framefmt *format, const char *p, char **endp)
 208 {
 209         struct media_entity_pad *pad;
 210         char *end;
 211         int ret;
 212
 213         for (; isspace(*p); ++p);
 214
 215         pad = parse_pad(media, p, &end);
 216         if (pad == NULL)
 217                 return NULL;
 218
 219         for (p = end; isspace(*p); ++p);
 220         if (*p++ != '[')
 221                 return NULL;
 222
 223         ret = parse_format(format, p, &end);
 224         if (ret < 0)
 225                 return NULL;
 226
 227         for (p = end; isspace(*p); p++);
 228         if (*p++ != ']')
 229                 return NULL;
 230
 231         *endp = (char *)p;
 232         return pad;
 233 }
 234
 235 static int set_format(struct media_entity_pad *pad, struct v4l2_mbus_framefmt *format)
 236 {
 237         int ret;
 238
 239         printf("Setting up format %s %ux%u on pad %s/%u\n",
 240                 pixelcode_to_string(format->code), format->width, format->height,
 241                 pad->entity->info.name, pad->index);
 242
 243         ret = v4l2_subdev_set_format(pad->entity, format, pad->index,
 244                                      V4L2_SUBDEV_FORMAT_ACTIVE);
 245         if (ret < 0) {
 246                 printf("Unable to set format: %s (%d)\n", strerror(-ret), ret);
 247                 return ret;
 248         }
 249
 250         printf("Format set: %s %ux%u\n",
 251                 pixelcode_to_string(format->code), format->width, format->height);
 252
 253         return 0;
 254 }
 255
 256 static int setup_format(struct media_device *media, const char *p, char **endp)
 257 {
 258         struct v4l2_mbus_framefmt format;
 259         struct media_entity_pad *pad;
 260         unsigned int i;
 261         char *end;
 262         int ret;
 263
 264         pad = parse_pad_format(media, &format, p, &end);
 265         if (pad == NULL) {
 266                 printf("Unable to parse format\n");
 267                 return -EINVAL;
 268         }
 269
 270         ret = set_format(pad, &format);
 271         if (ret < 0)
 272                 return ret;
 273
 274         /* If the pad is an output pad, automatically set the same format on
 275          * the remote subdev input pads, if any.
 276          */
 277         if (pad->type == MEDIA_PAD_TYPE_OUTPUT) {
 278                 for (i = 0; i < pad->entity->info.links; ++i) {
 279                         struct media_entity_link *link = &pad->entity->links[i];
 280                         struct v4l2_mbus_framefmt remote_format;
 281
 282                         if (!(link->flags & MEDIA_LINK_FLAG_ACTIVE))
 283                                 continue;
 284
 285                         if (link->source == pad &&
 286                             link->sink->entity->info.type == MEDIA_ENTITY_TYPE_SUBDEV) {
 287                                 remote_format = format;
 288                                 set_format(link->sink, &remote_format);
 289                         }
 290                 }
 291         }
 292
 293         *endp = end;
 294         return 0;
 295 }
 296
 297 static int setup_formats(struct media_device *media, const char *p)
 298 {
 299         char *end;
 300         int ret;
 301
 302         do {
 303                 ret = setup_format(media, p, &end);
 304                 if (ret < 0) {
 305                         printf("Unable to parse format\n");
 306                         return ret;
 307                 }
 308
 309                 p = end + 1;
 310         } while (*end == ',');
 311
 312         return *end ? -EINVAL : 0;
 313 }
 314
 315 int main(int argc, char **argv)
 316 {
 317         struct media_device *media;
 318
 319         if (parse_cmdline(argc, argv))
 320                 return EXIT_FAILURE;
 321
 322         /* Open the media device and enumerate entities, pads and links. */
 323         media = media_open(media_opts.devname, media_opts.verbose);
 324         if (media == NULL)
 325                 goto out;
 326
 327         if (media_opts.entity) {
 328                 struct media_entity *entity;
 329
 330                 entity = media_get_entity_by_name(media, media_opts.entity,
 331                                                   strlen(media_opts.entity));
 332                 if (entity != NULL)
 333                         printf("%s\n", entity->devname);
 334                 else
 335                         printf("Entity '%s' not found\n", media_opts.entity);
 336         }
 337
 338         if (media_opts.print || media_opts.print_dot) {
 339                 media_print_topology(media, media_opts.print_dot);
 340                 printf("\n");
 341         }
 342
 343         if (media_opts.reset) {
 344                 printf("Resetting all links to inactive\n");
 345                 media_reset_links(media);
 346         }
 347
 348         if (media_opts.links)
 349                 setup_links(media, media_opts.links);
 350
 351         if (media_opts.formats)
 352                 setup_formats(media, media_opts.formats);
 353
 354         if (media_opts.interactive) {
 355                 while (1) {
 356                         char buffer[32];
 357                         char *end;
 358
 359                         printf("Enter a link to modify or enter to stop\n");
 360                         if (fgets(buffer, sizeof buffer, stdin) == NULL)
 361                                 break;
 362
 363                         if (buffer[0] == '\n')
 364                                 break;
 365
 366                         setup_link(media, buffer, &end);
 367                 }
 368         }
 369
 370 out:
 371         if (media)
 372                 media_close(media);
 373
 374         exit(EXIT_SUCCESS);
 375 }
 376