drivers/media/platform/vsp1/vsp1_sru.c

   1 /*
   2  * vsp1_sru.c  --  R-Car VSP1 Super Resolution Unit
   3  *
   4  * Copyright (C) 2013 Renesas Corporation
   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 General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/device.h>
  15 #include <linux/gfp.h>
  16
  17 #include <media/v4l2-subdev.h>
  18
  19 #include "vsp1.h"
  20 #include "vsp1_sru.h"
  21
  22 #define SRU_MIN_SIZE                            4U
  23 #define SRU_MAX_SIZE                            8190U
  24
  25 /* -----------------------------------------------------------------------------
  26  * Device Access
  27  */
  28
  29 static inline u32 vsp1_sru_read(struct vsp1_sru *sru, u32 reg)
  30 {
  31         return vsp1_read(sru->entity.vsp1, reg);
  32 }
  33
  34 static inline void vsp1_sru_write(struct vsp1_sru *sru, u32 reg, u32 data)
  35 {
  36         vsp1_write(sru->entity.vsp1, reg, data);
  37 }
  38
  39 /* -----------------------------------------------------------------------------
  40  * Controls
  41  */
  42
  43 #define V4L2_CID_VSP1_SRU_INTENSITY             (V4L2_CID_USER_BASE + 1)
  44
  45 struct vsp1_sru_param {
  46         u32 ctrl0;
  47         u32 ctrl2;
  48 };
  49
  50 #define VI6_SRU_CTRL0_PARAMS(p0, p1)                    \
  51         (((p0) << VI6_SRU_CTRL0_PARAM0_SHIFT) |         \
  52          ((p1) << VI6_SRU_CTRL0_PARAM1_SHIFT))
  53
  54 #define VI6_SRU_CTRL2_PARAMS(p6, p7, p8)                \
  55         (((p6) << VI6_SRU_CTRL2_PARAM6_SHIFT) |         \
  56          ((p7) << VI6_SRU_CTRL2_PARAM7_SHIFT) |         \
  57          ((p8) << VI6_SRU_CTRL2_PARAM8_SHIFT))
  58
  59 static const struct vsp1_sru_param vsp1_sru_params[] = {
  60         {
  61                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(256, 4) | VI6_SRU_CTRL0_EN,
  62                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(24, 40, 255),
  63         }, {
  64                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(256, 4) | VI6_SRU_CTRL0_EN,
  65                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(8, 16, 255),
  66         }, {
  67                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(384, 5) | VI6_SRU_CTRL0_EN,
  68                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(36, 60, 255),
  69         }, {
  70                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(384, 5) | VI6_SRU_CTRL0_EN,
  71                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(12, 27, 255),
  72         }, {
  73                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(511, 6) | VI6_SRU_CTRL0_EN,
  74                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(48, 80, 255),
  75         }, {
  76                 .ctrl0 = VI6_SRU_CTRL0_PARAMS(511, 6) | VI6_SRU_CTRL0_EN,
  77                 .ctrl2 = VI6_SRU_CTRL2_PARAMS(16, 36, 255),
  78         },
  79 };
  80
  81 static int sru_s_ctrl(struct v4l2_ctrl *ctrl)
  82 {
  83         struct vsp1_sru *sru =
  84                 container_of(ctrl->handler, struct vsp1_sru, ctrls);
  85         const struct vsp1_sru_param *param;
  86         u32 value;
  87
  88         switch (ctrl->id) {
  89         case V4L2_CID_VSP1_SRU_INTENSITY:
  90                 param = &vsp1_sru_params[ctrl->val - 1];
  91
  92                 value = vsp1_sru_read(sru, VI6_SRU_CTRL0);
  93                 value &= ~(VI6_SRU_CTRL0_PARAM0_MASK |
  94                            VI6_SRU_CTRL0_PARAM1_MASK);
  95                 value |= param->ctrl0;
  96                 vsp1_sru_write(sru, VI6_SRU_CTRL0, value);
  97
  98                 vsp1_sru_write(sru, VI6_SRU_CTRL2, param->ctrl2);
  99                 break;
 100         }
 101
 102         return 0;
 103 }
 104
 105 static const struct v4l2_ctrl_ops sru_ctrl_ops = {
 106         .s_ctrl = sru_s_ctrl,
 107 };
 108
 109 static const struct v4l2_ctrl_config sru_intensity_control = {
 110         .ops = &sru_ctrl_ops,
 111         .id = V4L2_CID_VSP1_SRU_INTENSITY,
 112         .name = "Intensity",
 113         .type = V4L2_CTRL_TYPE_INTEGER,
 114         .min = 1,
 115         .max = 6,
 116         .def = 1,
 117         .step = 1,
 118 };
 119
 120 /* -----------------------------------------------------------------------------
 121  * V4L2 Subdevice Core Operations
 122  */
 123
 124 static int sru_s_stream(struct v4l2_subdev *subdev, int enable)
 125 {
 126         struct vsp1_sru *sru = to_sru(subdev);
 127         struct v4l2_mbus_framefmt *input;
 128         struct v4l2_mbus_framefmt *output;
 129         u32 ctrl0;
 130         int ret;
 131
 132         ret = vsp1_entity_set_streaming(&sru->entity, enable);
 133         if (ret < 0)
 134                 return ret;
 135
 136         if (!enable)
 137                 return 0;
 138
 139         input = &sru->entity.formats[SRU_PAD_SINK];
 140         output = &sru->entity.formats[SRU_PAD_SOURCE];
 141
 142         if (input->code == MEDIA_BUS_FMT_ARGB8888_1X32)
 143                 ctrl0 = VI6_SRU_CTRL0_PARAM2 | VI6_SRU_CTRL0_PARAM3
 144                       | VI6_SRU_CTRL0_PARAM4;
 145         else
 146                 ctrl0 = VI6_SRU_CTRL0_PARAM3;
 147
 148         if (input->width != output->width)
 149                 ctrl0 |= VI6_SRU_CTRL0_MODE_UPSCALE;
 150
 151         /* Take the control handler lock to ensure that the CTRL0 value won't be
 152          * changed behind our back by a set control operation.
 153          */
 154         mutex_lock(sru->ctrls.lock);
 155         ctrl0 |= vsp1_sru_read(sru, VI6_SRU_CTRL0)
 156                & (VI6_SRU_CTRL0_PARAM0_MASK | VI6_SRU_CTRL0_PARAM1_MASK);
 157         mutex_unlock(sru->ctrls.lock);
 158
 159         vsp1_sru_write(sru, VI6_SRU_CTRL1, VI6_SRU_CTRL1_PARAM5);
 160
 161         return 0;
 162 }
 163
 164 /* -----------------------------------------------------------------------------
 165  * V4L2 Subdevice Pad Operations
 166  */
 167
 168 static int sru_enum_mbus_code(struct v4l2_subdev *subdev,
 169                               struct v4l2_subdev_pad_config *cfg,
 170                               struct v4l2_subdev_mbus_code_enum *code)
 171 {
 172         static const unsigned int codes[] = {
 173                 MEDIA_BUS_FMT_ARGB8888_1X32,
 174                 MEDIA_BUS_FMT_AYUV8_1X32,
 175         };
 176         struct vsp1_sru *sru = to_sru(subdev);
 177         struct v4l2_mbus_framefmt *format;
 178
 179         if (code->pad == SRU_PAD_SINK) {
 180                 if (code->index >= ARRAY_SIZE(codes))
 181                         return -EINVAL;
 182
 183                 code->code = codes[code->index];
 184         } else {
 185                 /* The SRU can't perform format conversion, the sink format is
 186                  * always identical to the source format.
 187                  */
 188                 if (code->index)
 189                         return -EINVAL;
 190
 191                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 192                                                     SRU_PAD_SINK, code->which);
 193                 code->code = format->code;
 194         }
 195
 196         return 0;
 197 }
 198
 199 static int sru_enum_frame_size(struct v4l2_subdev *subdev,
 200                                struct v4l2_subdev_pad_config *cfg,
 201                                struct v4l2_subdev_frame_size_enum *fse)
 202 {
 203         struct vsp1_sru *sru = to_sru(subdev);
 204         struct v4l2_mbus_framefmt *format;
 205
 206         format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 207                                             SRU_PAD_SINK, fse->which);
 208
 209         if (fse->index || fse->code != format->code)
 210                 return -EINVAL;
 211
 212         if (fse->pad == SRU_PAD_SINK) {
 213                 fse->min_width = SRU_MIN_SIZE;
 214                 fse->max_width = SRU_MAX_SIZE;
 215                 fse->min_height = SRU_MIN_SIZE;
 216                 fse->max_height = SRU_MAX_SIZE;
 217         } else {
 218                 fse->min_width = format->width;
 219                 fse->min_height = format->height;
 220                 if (format->width <= SRU_MAX_SIZE / 2 &&
 221                     format->height <= SRU_MAX_SIZE / 2) {
 222                         fse->max_width = format->width * 2;
 223                         fse->max_height = format->height * 2;
 224                 } else {
 225                         fse->max_width = format->width;
 226                         fse->max_height = format->height;
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 static int sru_get_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg,
 234                           struct v4l2_subdev_format *fmt)
 235 {
 236         struct vsp1_sru *sru = to_sru(subdev);
 237
 238         fmt->format = *vsp1_entity_get_pad_format(&sru->entity, cfg, fmt->pad,
 239                                                   fmt->which);
 240
 241         return 0;
 242 }
 243
 244 static void sru_try_format(struct vsp1_sru *sru, struct v4l2_subdev_pad_config *cfg,
 245                            unsigned int pad, struct v4l2_mbus_framefmt *fmt,
 246                            enum v4l2_subdev_format_whence which)
 247 {
 248         struct v4l2_mbus_framefmt *format;
 249         unsigned int input_area;
 250         unsigned int output_area;
 251
 252         switch (pad) {
 253         case SRU_PAD_SINK:
 254                 /* Default to YUV if the requested format is not supported. */
 255                 if (fmt->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
 256                     fmt->code != MEDIA_BUS_FMT_AYUV8_1X32)
 257                         fmt->code = MEDIA_BUS_FMT_AYUV8_1X32;
 258
 259                 fmt->width = clamp(fmt->width, SRU_MIN_SIZE, SRU_MAX_SIZE);
 260                 fmt->height = clamp(fmt->height, SRU_MIN_SIZE, SRU_MAX_SIZE);
 261                 break;
 262
 263         case SRU_PAD_SOURCE:
 264                 /* The SRU can't perform format conversion. */
 265                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 266                                                     SRU_PAD_SINK, which);
 267                 fmt->code = format->code;
 268
 269                 /* We can upscale by 2 in both direction, but not independently.
 270                  * Compare the input and output rectangles areas (avoiding
 271                  * integer overflows on the output): if the requested output
 272                  * area is larger than 1.5^2 the input area upscale by two,
 273                  * otherwise don't scale.
 274                  */
 275                 input_area = format->width * format->height;
 276                 output_area = min(fmt->width, SRU_MAX_SIZE)
 277                             * min(fmt->height, SRU_MAX_SIZE);
 278
 279                 if (fmt->width <= SRU_MAX_SIZE / 2 &&
 280                     fmt->height <= SRU_MAX_SIZE / 2 &&
 281                     output_area > input_area * 9 / 4) {
 282                         fmt->width = format->width * 2;
 283                         fmt->height = format->height * 2;
 284                 } else {
 285                         fmt->width = format->width;
 286                         fmt->height = format->height;
 287                 }
 288                 break;
 289         }
 290
 291         fmt->field = V4L2_FIELD_NONE;
 292         fmt->colorspace = V4L2_COLORSPACE_SRGB;
 293 }
 294
 295 static int sru_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg,
 296                           struct v4l2_subdev_format *fmt)
 297 {
 298         struct vsp1_sru *sru = to_sru(subdev);
 299         struct v4l2_mbus_framefmt *format;
 300
 301         sru_try_format(sru, cfg, fmt->pad, &fmt->format, fmt->which);
 302
 303         format = vsp1_entity_get_pad_format(&sru->entity, cfg, fmt->pad,
 304                                             fmt->which);
 305         *format = fmt->format;
 306
 307         if (fmt->pad == SRU_PAD_SINK) {
 308                 /* Propagate the format to the source pad. */
 309                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 310                                                     SRU_PAD_SOURCE, fmt->which);
 311                 *format = fmt->format;
 312
 313                 sru_try_format(sru, cfg, SRU_PAD_SOURCE, format, fmt->which);
 314         }
 315
 316         return 0;
 317 }
 318
 319 /* -----------------------------------------------------------------------------
 320  * V4L2 Subdevice Operations
 321  */
 322
 323 static struct v4l2_subdev_video_ops sru_video_ops = {
 324         .s_stream = sru_s_stream,
 325 };
 326
 327 static struct v4l2_subdev_pad_ops sru_pad_ops = {
 328         .enum_mbus_code = sru_enum_mbus_code,
 329         .enum_frame_size = sru_enum_frame_size,
 330         .get_fmt = sru_get_format,
 331         .set_fmt = sru_set_format,
 332 };
 333
 334 static struct v4l2_subdev_ops sru_ops = {
 335         .video  = &sru_video_ops,
 336         .pad    = &sru_pad_ops,
 337 };
 338
 339 /* -----------------------------------------------------------------------------
 340  * Initialization and Cleanup
 341  */
 342
 343 struct vsp1_sru *vsp1_sru_create(struct vsp1_device *vsp1)
 344 {
 345         struct v4l2_subdev *subdev;
 346         struct vsp1_sru *sru;
 347         int ret;
 348
 349         sru = devm_kzalloc(vsp1->dev, sizeof(*sru), GFP_KERNEL);
 350         if (sru == NULL)
 351                 return ERR_PTR(-ENOMEM);
 352
 353         sru->entity.type = VSP1_ENTITY_SRU;
 354
 355         ret = vsp1_entity_init(vsp1, &sru->entity, 2);
 356         if (ret < 0)
 357                 return ERR_PTR(ret);
 358
 359         /* Initialize the V4L2 subdev. */
 360         subdev = &sru->entity.subdev;
 361         v4l2_subdev_init(subdev, &sru_ops);
 362
 363         subdev->entity.ops = &vsp1_media_ops;
 364         subdev->internal_ops = &vsp1_subdev_internal_ops;
 365         snprintf(subdev->name, sizeof(subdev->name), "%s sru",
 366                  dev_name(vsp1->dev));
 367         v4l2_set_subdevdata(subdev, sru);
 368         subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 369
 370         vsp1_entity_init_formats(subdev, NULL);
 371
 372         /* Initialize the control handler. */
 373         v4l2_ctrl_handler_init(&sru->ctrls, 1);
 374         v4l2_ctrl_new_custom(&sru->ctrls, &sru_intensity_control, NULL);
 375
 376         sru->entity.subdev.ctrl_handler = &sru->ctrls;
 377
 378         if (sru->ctrls.error) {
 379                 dev_err(vsp1->dev, "sru: failed to initialize controls\n");
 380                 ret = sru->ctrls.error;
 381                 vsp1_entity_destroy(&sru->entity);
 382                 return ERR_PTR(ret);
 383         }
 384
 385         return sru;
 386 }