src/subdev.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/ioctl.h>
  21 #include <sys/stat.h>
  22 #include <sys/types.h>
  23
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29
  30 #include <linux/v4l2-subdev.h>
  31
  32 #include "media.h"
  33 #include "subdev.h"
  34 #include "tools.h"
  35
  36 int v4l2_subdev_open(struct media_entity *entity)
  37 {
  38         if (entity->fd != -1)
  39                 return 0;
  40
  41         entity->fd = open(entity->devname, O_RDWR);
  42         if (entity->fd == -1) {
  43                 printf("%s: Failed to open subdev device node %s\n", __func__,
  44                         entity->devname);
  45                 return -errno;
  46         }
  47
  48         return 0;
  49 }
  50
  51 void v4l2_subdev_close(struct media_entity *entity)
  52 {
  53         close(entity->fd);
  54         entity->fd = -1;
  55 }
  56
  57 int v4l2_subdev_get_format(struct media_entity *entity,
  58         struct v4l2_mbus_framefmt *format, unsigned int pad,
  59         enum v4l2_subdev_format_whence which)
  60 {
  61         struct v4l2_subdev_format fmt;
  62         int ret;
  63
  64         ret = v4l2_subdev_open(entity);
  65         if (ret < 0)
  66                 return ret;
  67
  68         memset(&fmt, 0, sizeof(fmt));
  69         fmt.pad = pad;
  70         fmt.which = which;
  71
  72         ret = ioctl(entity->fd, VIDIOC_SUBDEV_G_FMT, &fmt);
  73         if (ret < 0)
  74                 return -errno;
  75
  76         *format = fmt.format;
  77         return 0;
  78 }
  79
  80 int v4l2_subdev_set_format(struct media_entity *entity,
  81         struct v4l2_mbus_framefmt *format, unsigned int pad,
  82         enum v4l2_subdev_format_whence which)
  83 {
  84         struct v4l2_subdev_format fmt;
  85         int ret;
  86
  87         ret = v4l2_subdev_open(entity);
  88         if (ret < 0)
  89                 return ret;
  90
  91         memset(&fmt, 0, sizeof(fmt));
  92         fmt.pad = pad;
  93         fmt.which = which;
  94         fmt.format = *format;
  95
  96         ret = ioctl(entity->fd, VIDIOC_SUBDEV_S_FMT, &fmt);
  97         if (ret < 0)
  98                 return -errno;
  99
 100         *format = fmt.format;
 101         return 0;
 102 }
 103
 104 int v4l2_subdev_get_crop(struct media_entity *entity, struct v4l2_rect *rect,
 105                          unsigned int pad, enum v4l2_subdev_format_whence which)
 106 {
 107         struct v4l2_subdev_crop crop;
 108         int ret;
 109
 110         ret = v4l2_subdev_open(entity);
 111         if (ret < 0)
 112                 return ret;
 113
 114         memset(&crop, 0, sizeof(crop));
 115         crop.pad = pad;
 116         crop.which = which;
 117
 118         ret = ioctl(entity->fd, VIDIOC_SUBDEV_G_CROP, &crop);
 119         if (ret < 0)
 120                 return -errno;
 121
 122         *rect = crop.rect;
 123         return 0;
 124 }
 125
 126 int v4l2_subdev_set_crop(struct media_entity *entity, struct v4l2_rect *rect,
 127                          unsigned int pad, enum v4l2_subdev_format_whence which)
 128 {
 129         struct v4l2_subdev_crop crop;
 130         int ret;
 131
 132         ret = v4l2_subdev_open(entity);
 133         if (ret < 0)
 134                 return ret;
 135
 136         memset(&crop, 0, sizeof(crop));
 137         crop.pad = pad;
 138         crop.which = which;
 139         crop.rect = *rect;
 140
 141         ret = ioctl(entity->fd, VIDIOC_SUBDEV_S_CROP, &crop);
 142         if (ret < 0)
 143                 return -errno;
 144
 145         *rect = crop.rect;
 146         return 0;
 147 }
 148
 149 int v4l2_subdev_get_frame_interval(struct media_entity *entity,
 150                                    struct v4l2_fract *interval)
 151 {
 152         struct v4l2_subdev_frame_interval ival;
 153         int ret;
 154
 155         ret = v4l2_subdev_open(entity);
 156         if (ret < 0)
 157                 return ret;
 158
 159         memset(&ival, 0, sizeof(ival));
 160
 161         ret = ioctl(entity->fd, VIDIOC_SUBDEV_G_FRAME_INTERVAL, &ival);
 162         if (ret < 0)
 163                 return -errno;
 164
 165         *interval = ival.interval;
 166         return 0;
 167 }
 168
 169 int v4l2_subdev_set_frame_interval(struct media_entity *entity,
 170                                    struct v4l2_fract *interval)
 171 {
 172         struct v4l2_subdev_frame_interval ival;
 173         int ret;
 174
 175         ret = v4l2_subdev_open(entity);
 176         if (ret < 0)
 177                 return ret;
 178
 179         memset(&ival, 0, sizeof(ival));
 180         ival.interval = *interval;
 181
 182         ret = ioctl(entity->fd, VIDIOC_SUBDEV_S_FRAME_INTERVAL, &ival);
 183         if (ret < 0)
 184                 return -errno;
 185
 186         *interval = ival.interval;
 187         return 0;
 188 }