drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2016 NextThing Co
   4  * Copyright (C) 2016-2019 Bootlin
   5  *
   6  * Author: Maxime Ripard <[email protected]>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/pm_runtime.h>
  11
  12 #include <media/v4l2-ioctl.h>
  13 #include <media/v4l2-mc.h>
  14 #include <media/videobuf2-v4l2.h>
  15
  16 #include "sun4i_csi.h"
  17
  18 #define CSI_DEFAULT_WIDTH       640
  19 #define CSI_DEFAULT_HEIGHT      480
  20
  21 static const struct sun4i_csi_format sun4i_csi_formats[] = {
  22         /* YUV422 inputs */
  23         {
  24                 .mbus           = MEDIA_BUS_FMT_YUYV8_2X8,
  25                 .fourcc         = V4L2_PIX_FMT_YUV420M,
  26                 .input          = CSI_INPUT_YUV,
  27                 .output         = CSI_OUTPUT_YUV_420_PLANAR,
  28                 .num_planes     = 3,
  29                 .bpp            = { 8, 8, 8 },
  30                 .hsub           = 2,
  31                 .vsub           = 2,
  32         },
  33 };
  34
  35 const struct sun4i_csi_format *sun4i_csi_find_format(const u32 *fourcc,
  36                                                      const u32 *mbus)
  37 {
  38         unsigned int i;
  39
  40         for (i = 0; i < ARRAY_SIZE(sun4i_csi_formats); i++) {
  41                 if (fourcc && *fourcc != sun4i_csi_formats[i].fourcc)
  42                         continue;
  43
  44                 if (mbus && *mbus != sun4i_csi_formats[i].mbus)
  45                         continue;
  46
  47                 return &sun4i_csi_formats[i];
  48         }
  49
  50         return NULL;
  51 }
  52
  53 static int sun4i_csi_querycap(struct file *file, void *priv,
  54                               struct v4l2_capability *cap)
  55 {
  56         struct sun4i_csi *csi = video_drvdata(file);
  57
  58         strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
  59         strscpy(cap->card, "sun4i-csi", sizeof(cap->card));
  60         snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
  61                  dev_name(csi->dev));
  62
  63         return 0;
  64 }
  65
  66 static int sun4i_csi_enum_input(struct file *file, void *priv,
  67                                 struct v4l2_input *inp)
  68 {
  69         if (inp->index != 0)
  70                 return -EINVAL;
  71
  72         inp->type = V4L2_INPUT_TYPE_CAMERA;
  73         strscpy(inp->name, "Camera", sizeof(inp->name));
  74
  75         return 0;
  76 }
  77
  78 static int sun4i_csi_g_input(struct file *file, void *fh,
  79                              unsigned int *i)
  80 {
  81         *i = 0;
  82
  83         return 0;
  84 }
  85
  86 static int sun4i_csi_s_input(struct file *file, void *fh,
  87                              unsigned int i)
  88 {
  89         if (i != 0)
  90                 return -EINVAL;
  91
  92         return 0;
  93 }
  94
  95 static void _sun4i_csi_try_fmt(struct sun4i_csi *csi,
  96                                struct v4l2_pix_format_mplane *pix)
  97 {
  98         const struct sun4i_csi_format *_fmt;
  99         unsigned int height, width;
 100         unsigned int i;
 101
 102         _fmt = sun4i_csi_find_format(&pix->pixelformat, NULL);
 103         if (!_fmt)
 104                 _fmt = &sun4i_csi_formats[0];
 105
 106         pix->field = V4L2_FIELD_NONE;
 107         pix->colorspace = V4L2_COLORSPACE_SRGB;
 108         pix->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(pix->colorspace);
 109         pix->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(pix->colorspace);
 110         pix->quantization = V4L2_MAP_QUANTIZATION_DEFAULT(true, pix->colorspace,
 111                                                           pix->ycbcr_enc);
 112
 113         pix->num_planes = _fmt->num_planes;
 114         pix->pixelformat = _fmt->fourcc;
 115
 116         memset(pix->reserved, 0, sizeof(pix->reserved));
 117
 118         /* Align the width and height on the subsampling */
 119         width = ALIGN(pix->width, _fmt->hsub);
 120         height = ALIGN(pix->height, _fmt->vsub);
 121
 122         /* Clamp the width and height to our capabilities */
 123         pix->width = clamp(width, _fmt->hsub, CSI_MAX_WIDTH);
 124         pix->height = clamp(height, _fmt->vsub, CSI_MAX_HEIGHT);
 125
 126         for (i = 0; i < _fmt->num_planes; i++) {
 127                 unsigned int hsub = i > 0 ? _fmt->hsub : 1;
 128                 unsigned int vsub = i > 0 ? _fmt->vsub : 1;
 129                 unsigned int bpl;
 130
 131                 bpl = pix->width / hsub * _fmt->bpp[i] / 8;
 132                 pix->plane_fmt[i].bytesperline = bpl;
 133                 pix->plane_fmt[i].sizeimage = bpl * pix->height / vsub;
 134                 memset(pix->plane_fmt[i].reserved, 0,
 135                        sizeof(pix->plane_fmt[i].reserved));
 136         }
 137 }
 138
 139 static int sun4i_csi_try_fmt_vid_cap(struct file *file, void *priv,
 140                                      struct v4l2_format *f)
 141 {
 142         struct sun4i_csi *csi = video_drvdata(file);
 143
 144         _sun4i_csi_try_fmt(csi, &f->fmt.pix_mp);
 145
 146         return 0;
 147 }
 148
 149 static int sun4i_csi_s_fmt_vid_cap(struct file *file, void *priv,
 150                                    struct v4l2_format *f)
 151 {
 152         struct sun4i_csi *csi = video_drvdata(file);
 153
 154         _sun4i_csi_try_fmt(csi, &f->fmt.pix_mp);
 155         csi->fmt = f->fmt.pix_mp;
 156
 157         return 0;
 158 }
 159
 160 static int sun4i_csi_g_fmt_vid_cap(struct file *file, void *priv,
 161                                    struct v4l2_format *f)
 162 {
 163         struct sun4i_csi *csi = video_drvdata(file);
 164
 165         f->fmt.pix_mp = csi->fmt;
 166
 167         return 0;
 168 }
 169
 170 static int sun4i_csi_enum_fmt_vid_cap(struct file *file, void *priv,
 171                                       struct v4l2_fmtdesc *f)
 172 {
 173         if (f->index >= ARRAY_SIZE(sun4i_csi_formats))
 174                 return -EINVAL;
 175
 176         f->pixelformat = sun4i_csi_formats[f->index].fourcc;
 177
 178         return 0;
 179 }
 180
 181 static const struct v4l2_ioctl_ops sun4i_csi_ioctl_ops = {
 182         .vidioc_querycap                = sun4i_csi_querycap,
 183
 184         .vidioc_enum_fmt_vid_cap        = sun4i_csi_enum_fmt_vid_cap,
 185         .vidioc_g_fmt_vid_cap_mplane    = sun4i_csi_g_fmt_vid_cap,
 186         .vidioc_s_fmt_vid_cap_mplane    = sun4i_csi_s_fmt_vid_cap,
 187         .vidioc_try_fmt_vid_cap_mplane  = sun4i_csi_try_fmt_vid_cap,
 188
 189         .vidioc_enum_input              = sun4i_csi_enum_input,
 190         .vidioc_g_input                 = sun4i_csi_g_input,
 191         .vidioc_s_input                 = sun4i_csi_s_input,
 192
 193         .vidioc_reqbufs                 = vb2_ioctl_reqbufs,
 194         .vidioc_create_bufs             = vb2_ioctl_create_bufs,
 195         .vidioc_querybuf                = vb2_ioctl_querybuf,
 196         .vidioc_qbuf                    = vb2_ioctl_qbuf,
 197         .vidioc_dqbuf                   = vb2_ioctl_dqbuf,
 198         .vidioc_expbuf                  = vb2_ioctl_expbuf,
 199         .vidioc_prepare_buf             = vb2_ioctl_prepare_buf,
 200         .vidioc_streamon                = vb2_ioctl_streamon,
 201         .vidioc_streamoff               = vb2_ioctl_streamoff,
 202 };
 203
 204 static int sun4i_csi_open(struct file *file)
 205 {
 206         struct sun4i_csi *csi = video_drvdata(file);
 207         int ret;
 208
 209         ret = mutex_lock_interruptible(&csi->lock);
 210         if (ret)
 211                 return ret;
 212
 213         ret = pm_runtime_get_sync(csi->dev);
 214         if (ret < 0)
 215                 goto err_pm_put;
 216
 217         ret = v4l2_pipeline_pm_get(&csi->vdev.entity);
 218         if (ret)
 219                 goto err_pm_put;
 220
 221         ret = v4l2_fh_open(file);
 222         if (ret)
 223                 goto err_pipeline_pm_put;
 224
 225         mutex_unlock(&csi->lock);
 226
 227         return 0;
 228
 229 err_pipeline_pm_put:
 230         v4l2_pipeline_pm_put(&csi->vdev.entity);
 231
 232 err_pm_put:
 233         pm_runtime_put(csi->dev);
 234         mutex_unlock(&csi->lock);
 235
 236         return ret;
 237 }
 238
 239 static int sun4i_csi_release(struct file *file)
 240 {
 241         struct sun4i_csi *csi = video_drvdata(file);
 242
 243         mutex_lock(&csi->lock);
 244
 245         _vb2_fop_release(file, NULL);
 246
 247         v4l2_pipeline_pm_put(&csi->vdev.entity);
 248         pm_runtime_put(csi->dev);
 249
 250         mutex_unlock(&csi->lock);
 251
 252         return 0;
 253 }
 254
 255 static const struct v4l2_file_operations sun4i_csi_fops = {
 256         .owner          = THIS_MODULE,
 257         .open           = sun4i_csi_open,
 258         .release        = sun4i_csi_release,
 259         .unlocked_ioctl = video_ioctl2,
 260         .poll           = vb2_fop_poll,
 261         .mmap           = vb2_fop_mmap,
 262 };
 263
 264 static const struct v4l2_mbus_framefmt sun4i_csi_pad_fmt_default = {
 265         .width = CSI_DEFAULT_WIDTH,
 266         .height = CSI_DEFAULT_HEIGHT,
 267         .code = MEDIA_BUS_FMT_YUYV8_2X8,
 268         .field = V4L2_FIELD_NONE,
 269         .colorspace = V4L2_COLORSPACE_RAW,
 270         .ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT,
 271         .quantization = V4L2_QUANTIZATION_DEFAULT,
 272         .xfer_func = V4L2_XFER_FUNC_DEFAULT,
 273 };
 274
 275 static int sun4i_csi_subdev_init_cfg(struct v4l2_subdev *subdev,
 276                                      struct v4l2_subdev_pad_config *cfg)
 277 {
 278         struct v4l2_mbus_framefmt *fmt;
 279
 280         fmt = v4l2_subdev_get_try_format(subdev, cfg, CSI_SUBDEV_SINK);
 281         *fmt = sun4i_csi_pad_fmt_default;
 282
 283         return 0;
 284 }
 285
 286 static int sun4i_csi_subdev_get_fmt(struct v4l2_subdev *subdev,
 287                                     struct v4l2_subdev_pad_config *cfg,
 288                                     struct v4l2_subdev_format *fmt)
 289 {
 290         struct sun4i_csi *csi = container_of(subdev, struct sun4i_csi, subdev);
 291         struct v4l2_mbus_framefmt *subdev_fmt;
 292
 293         if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
 294                 subdev_fmt = v4l2_subdev_get_try_format(subdev, cfg, fmt->pad);
 295         else
 296                 subdev_fmt = &csi->subdev_fmt;
 297
 298         fmt->format = *subdev_fmt;
 299
 300         return 0;
 301 }
 302
 303 static int sun4i_csi_subdev_set_fmt(struct v4l2_subdev *subdev,
 304                                     struct v4l2_subdev_pad_config *cfg,
 305                                     struct v4l2_subdev_format *fmt)
 306 {
 307         struct sun4i_csi *csi = container_of(subdev, struct sun4i_csi, subdev);
 308         struct v4l2_mbus_framefmt *subdev_fmt;
 309
 310         if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
 311                 subdev_fmt = v4l2_subdev_get_try_format(subdev, cfg, fmt->pad);
 312         else
 313                 subdev_fmt = &csi->subdev_fmt;
 314
 315         /* We can only set the format on the sink pad */
 316         if (fmt->pad == CSI_SUBDEV_SINK) {
 317                 /* It's the sink, only allow changing the frame size */
 318                 subdev_fmt->width = fmt->format.width;
 319                 subdev_fmt->height = fmt->format.height;
 320                 subdev_fmt->code = fmt->format.code;
 321         }
 322
 323         fmt->format = *subdev_fmt;
 324
 325         return 0;
 326 }
 327
 328 static int
 329 sun4i_csi_subdev_enum_mbus_code(struct v4l2_subdev *subdev,
 330                                 struct v4l2_subdev_pad_config *cfg,
 331                                 struct v4l2_subdev_mbus_code_enum *mbus)
 332 {
 333         if (mbus->index >= ARRAY_SIZE(sun4i_csi_formats))
 334                 return -EINVAL;
 335
 336         mbus->code = sun4i_csi_formats[mbus->index].mbus;
 337
 338         return 0;
 339 }
 340
 341 static const struct v4l2_subdev_pad_ops sun4i_csi_subdev_pad_ops = {
 342         .link_validate  = v4l2_subdev_link_validate_default,
 343         .init_cfg       = sun4i_csi_subdev_init_cfg,
 344         .get_fmt        = sun4i_csi_subdev_get_fmt,
 345         .set_fmt        = sun4i_csi_subdev_set_fmt,
 346         .enum_mbus_code = sun4i_csi_subdev_enum_mbus_code,
 347 };
 348
 349 const struct v4l2_subdev_ops sun4i_csi_subdev_ops = {
 350         .pad = &sun4i_csi_subdev_pad_ops,
 351 };
 352
 353 int sun4i_csi_v4l2_register(struct sun4i_csi *csi)
 354 {
 355         struct video_device *vdev = &csi->vdev;
 356         int ret;
 357
 358         vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_STREAMING;
 359         vdev->v4l2_dev = &csi->v4l;
 360         vdev->queue = &csi->queue;
 361         strscpy(vdev->name, KBUILD_MODNAME, sizeof(vdev->name));
 362         vdev->release = video_device_release_empty;
 363         vdev->lock = &csi->lock;
 364
 365         /* Set a default format */
 366         csi->fmt.pixelformat = sun4i_csi_formats[0].fourcc;
 367         csi->fmt.width = CSI_DEFAULT_WIDTH;
 368         csi->fmt.height = CSI_DEFAULT_HEIGHT;
 369         _sun4i_csi_try_fmt(csi, &csi->fmt);
 370         csi->subdev_fmt = sun4i_csi_pad_fmt_default;
 371
 372         vdev->fops = &sun4i_csi_fops;
 373         vdev->ioctl_ops = &sun4i_csi_ioctl_ops;
 374         video_set_drvdata(vdev, csi);
 375
 376         ret = video_register_device(&csi->vdev, VFL_TYPE_VIDEO, -1);
 377         if (ret)
 378                 return ret;
 379
 380         dev_info(csi->dev, "Device registered as %s\n",
 381                  video_device_node_name(vdev));
 382
 383         return 0;
 384 }