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 #include "tools.h"
  43
  44 /* -----------------------------------------------------------------------------
  45  * Links setup
  46  */
  47
  48 static struct media_entity_pad *parse_pad(struct media_device *media, const char *p, char **endp)
  49 {
  50         unsigned int entity_id, pad;
  51         struct media_entity *entity;
  52         char *end;
  53
  54         for (; isspace(*p); ++p);
  55
  56         if (*p == '"') {
  57                 for (end = (char *)p + 1; *end && *end != '"'; ++end);
  58                 if (*end != '"')
  59                         return NULL;
  60
  61                 entity = media_get_entity_by_name(media, p + 1, end - p - 1);
  62                 if (entity == NULL)
  63                         return NULL;
  64
  65                 for (++end; isspace(*end); ++end);
  66         } else {
  67                 entity_id = strtoul(p, &end, 10) - 1;
  68                 if (entity_id >= media->entities_count)
  69                         return NULL;
  70
  71                 entity = &media->entities[entity_id];
  72         }
  73
  74         if (*end != ':')
  75                 return NULL;
  76         for (p = end + 1; isspace(*p); ++p);
  77
  78         pad = strtoul(p, &end, 10);
  79         for (p = end; isspace(*p); ++p);
  80
  81         if (pad >= entity->info.pads)
  82                 return NULL;
  83
  84         for (p = end; isspace(*p); ++p);
  85         *endp = (char *)p;
  86
  87         return &entity->pads[pad];
  88 }
  89
  90 static struct media_entity_link *parse_link(struct media_device *media, const char *p, char **endp)
  91 {
  92         struct media_entity_link *link;
  93         struct media_entity_pad *source;
  94         struct media_entity_pad *sink;
  95         unsigned int i;
  96         char *end;
  97
  98         source = parse_pad(media, p, &end);
  99         if (source == NULL)
 100                 return NULL;
 101
 102         if (end[0] != '-' || end[1] != '>')
 103                 return NULL;
 104         p = end + 2;
 105
 106         sink = parse_pad(media, p, &end);
 107         if (sink == NULL)
 108                 return NULL;
 109
 110         *endp = end;
 111
 112         for (i = 0; i < source->entity->info.links; i++) {
 113                 link = &source->entity->links[i];
 114
 115                 if (link->source == source && link->sink == sink)
 116                         return link;
 117         }
 118
 119         return NULL;
 120 }
 121
 122 static int setup_link(struct media_device *media, const char *p, char **endp)
 123 {
 124         struct media_entity_link *link;
 125         __u32 flags;
 126         char *end;
 127
 128         link = parse_link(media, p, &end);
 129         if (link == NULL) {
 130                 printf("Unable to parse link\n");
 131                 return -EINVAL;
 132         }
 133
 134         p = end;
 135         if (*p++ != '[') {
 136                 printf("Unable to parse link flags\n");
 137                 return -EINVAL;
 138         }
 139
 140         flags = strtoul(p, &end, 10);
 141         for (p = end; isspace(*p); p++);
 142         if (*p++ != ']') {
 143                 printf("Unable to parse link flags\n");
 144                 return -EINVAL;
 145         }
 146
 147         for (; isspace(*p); p++);
 148         *endp = (char *)p;
 149
 150         printf("Setting up link %u:%u -> %u:%u [%u]\n",
 151                 link->source->entity->info.id, link->source->index,
 152                 link->sink->entity->info.id, link->sink->index,
 153                 flags);
 154
 155         return media_setup_link(media, link->source, link->sink, flags);
 156 }
 157
 158 static int setup_links(struct media_device *media, const char *p)
 159 {
 160         char *end;
 161         int ret;
 162
 163         do {
 164                 ret = setup_link(media, p, &end);
 165                 if (ret < 0)
 166                         return ret;
 167
 168                 p = end + 1;
 169         } while (*end == ',');
 170
 171         return *end ? -EINVAL : 0;
 172 }
 173
 174 /* -----------------------------------------------------------------------------
 175  * Formats setup
 176  */
 177
 178 static struct {
 179         const char *name;
 180         enum v4l2_mbus_pixelcode code;
 181 } mbus_formats[] = {
 182         { "YUYV", V4L2_MBUS_FMT_YUYV16_1X16 },
 183         { "UYVY", V4L2_MBUS_FMT_UYVY16_1X16 },
 184         { "SGRBG10", V4L2_MBUS_FMT_SGRBG10_1X10 },
 185         { "SGRBG10_DPCM8", V4L2_MBUS_FMT_SGRBG10_DPCM8_1X8 },
 186 };
 187
 188 static const char *pixelcode_to_string(enum v4l2_mbus_pixelcode code)
 189 {
 190         unsigned int i;
 191
 192         for (i = 0; i < ARRAY_SIZE(mbus_formats); ++i) {
 193                 if (mbus_formats[i].code == code)
 194                         return mbus_formats[i].name;
 195         }
 196
 197         return "unknown";
 198 }
 199
 200 static int parse_format(struct v4l2_mbus_framefmt *format, const char *p, char **endp)
 201 {
 202         unsigned int width, height;
 203         unsigned int i;
 204         char *end;
 205
 206         for (; isspace(*p); ++p);
 207         for (end = (char *)p; !isspace(*end) && *end != '\0'; ++end);
 208
 209         for (i = 0; i < ARRAY_SIZE(mbus_formats); ++i) {
 210                 if (strncmp(mbus_formats[i].name, p, end - p) == 0)
 211                         break;
 212         }
 213
 214         if (i == ARRAY_SIZE(mbus_formats))
 215                 return -EINVAL;
 216
 217         for (p = end; isspace(*p); ++p);
 218         width = strtoul(p, &end, 10);
 219         if (*end != 'x')
 220                 return -EINVAL;
 221
 222         p = end + 1;
 223         height = strtoul(p, &end, 10);
 224         *endp = end;
 225
 226         memset(format, 0, sizeof(*format));
 227         format->width = width;
 228         format->height = height;
 229         format->code = mbus_formats[i].code;
 230
 231         return 0;
 232 }
 233
 234 static struct media_entity_pad *parse_pad_format(struct media_device *media,
 235         struct v4l2_mbus_framefmt *format, const char *p, char **endp)
 236 {
 237         struct media_entity_pad *pad;
 238         char *end;
 239         int ret;
 240
 241         for (; isspace(*p); ++p);
 242
 243         pad = parse_pad(media, p, &end);
 244         if (pad == NULL)
 245                 return NULL;
 246
 247         for (p = end; isspace(*p); ++p);
 248         if (*p++ != '[')
 249                 return NULL;
 250
 251         ret = parse_format(format, p, &end);
 252         if (ret < 0)
 253                 return NULL;
 254
 255         for (p = end; isspace(*p); p++);
 256         if (*p++ != ']')
 257                 return NULL;
 258
 259         *endp = (char *)p;
 260         return pad;
 261 }
 262
 263 static int set_format(struct media_entity_pad *pad, struct v4l2_mbus_framefmt *format)
 264 {
 265         int ret;
 266
 267         printf("Setting up format %s %ux%u on pad %s/%u\n",
 268                 pixelcode_to_string(format->code), format->width, format->height,
 269                 pad->entity->info.name, pad->index);
 270
 271         ret = v4l2_subdev_set_format(pad->entity, format, pad->index,
 272                                      V4L2_SUBDEV_FORMAT_ACTIVE);
 273         if (ret < 0) {
 274                 printf("Unable to set format: %s(%u)", strerror(ret), ret);
 275                 return ret;
 276         }
 277
 278         printf("Format set: %s %ux%u\n",
 279                 pixelcode_to_string(format->code), format->width, format->height);
 280
 281         return 0;
 282 }
 283
 284 static int setup_format(struct media_device *media, const char *p, char **endp)
 285 {
 286         struct v4l2_mbus_framefmt format;
 287         struct media_entity_pad *pad;
 288         unsigned int i;
 289         char *end;
 290         int ret;
 291
 292         pad = parse_pad_format(media, &format, p, &end);
 293         if (pad == NULL) {
 294                 printf("Unable to parse format\n");
 295                 return -EINVAL;
 296         }
 297
 298         ret = set_format(pad, &format);
 299         if (ret < 0)
 300                 return ret;
 301
 302         /* If the pad is an output pad, automatically set the same format on
 303          * the remote inputs, if any.
 304          */
 305         if (pad->type == MEDIA_PAD_TYPE_OUTPUT) {
 306                 for (i = 0; i < pad->entity->info.links; ++i) {
 307                         struct media_entity_link *link = &pad->entity->links[i];
 308                         struct v4l2_mbus_framefmt remote_format;
 309
 310                         if (!(link->flags & MEDIA_LINK_FLAG_ACTIVE))
 311                                 continue;
 312
 313                         if (link->source == pad) {
 314                                 remote_format = format;
 315                                 set_format(link->sink, &remote_format);
 316                         }
 317                 }
 318         }
 319
 320         *endp = end;
 321         return 0;
 322 }
 323
 324 static int setup_formats(struct media_device *media, const char *p)
 325 {
 326         char *end;
 327         int ret;
 328
 329         do {
 330                 ret = setup_format(media, p, &end);
 331                 if (ret < 0) {
 332                         printf("Unable to parse format\n");
 333                         return ret;
 334                 }
 335
 336                 p = end + 1;
 337         } while (*end == ',');
 338
 339         return *end ? -EINVAL : 0;
 340 }
 341
 342 int main(int argc, char **argv)
 343 {
 344         struct media_device *media;
 345
 346         if (parse_cmdline(argc, argv))
 347                 return EXIT_FAILURE;
 348
 349         /* Open the media device and enumerate entities, pads and links. */
 350         media = media_open(media_opts.devname, media_opts.verbose);
 351         if (media == NULL)
 352                 goto out;
 353
 354         if (media_opts.entity) {
 355                 struct media_entity *entity;
 356
 357                 entity = media_get_entity_by_name(media, media_opts.entity,
 358                                                   strlen(media_opts.entity));
 359                 if (entity != NULL)
 360                         printf("%s\n", entity->devname);
 361                 else
 362                         printf("Entity '%s' not found\n", media_opts.entity);
 363         }
 364
 365         if (media_opts.print) {
 366                 media_print_topology(media);
 367                 printf("\n");
 368         }
 369
 370         if (media_opts.reset) {
 371                 printf("Resetting all links to inactive\n");
 372                 media_reset_links(media);
 373         }
 374
 375         if (media_opts.links)
 376                 setup_links(media, media_opts.links);
 377
 378         if (media_opts.formats)
 379                 setup_formats(media, media_opts.formats);
 380
 381         if (media_opts.interactive) {
 382                 while (1) {
 383                         char buffer[32];
 384                         char *end;
 385
 386                         printf("Enter a link to modify or enter to stop\n");
 387                         if (fgets(buffer, sizeof buffer, stdin) == NULL)
 388                                 break;
 389
 390                         if (buffer[0] == '\n')
 391                                 break;
 392
 393                         setup_link(media, buffer, &end);
 394                 }
 395         }
 396
 397 out:
 398         if (media)
 399                 media_close(media);
 400
 401         exit(EXIT_SUCCESS);
 402 }
 403