kernel/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         vsp1_sru_write(sru, VI6_SRU_CTRL0, ctrl0);
 158         mutex_unlock(sru->ctrls.lock);
 159
 160         vsp1_sru_write(sru, VI6_SRU_CTRL1, VI6_SRU_CTRL1_PARAM5);
 161
 162         return 0;
 163 }
 164
 165 /* -----------------------------------------------------------------------------
 166  * V4L2 Subdevice Pad Operations
 167  */
 168
 169 static int sru_enum_mbus_code(struct v4l2_subdev *subdev,
 170                               struct v4l2_subdev_pad_config *cfg,
 171                               struct v4l2_subdev_mbus_code_enum *code)
 172 {
 173         static const unsigned int codes[] = {
 174                 MEDIA_BUS_FMT_ARGB8888_1X32,
 175                 MEDIA_BUS_FMT_AYUV8_1X32,
 176         };
 177         struct vsp1_sru *sru = to_sru(subdev);
 178         struct v4l2_mbus_framefmt *format;
 179
 180         if (code->pad == SRU_PAD_SINK) {
 181                 if (code->index >= ARRAY_SIZE(codes))
 182                         return -EINVAL;
 183
 184                 code->code = codes[code->index];
 185         } else {
 186                 /* The SRU can't perform format conversion, the sink format is
 187                  * always identical to the source format.
 188                  */
 189                 if (code->index)
 190                         return -EINVAL;
 191
 192                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 193                                                     SRU_PAD_SINK, code->which);
 194                 code->code = format->code;
 195         }
 196
 197         return 0;
 198 }
 199
 200 static int sru_enum_frame_size(struct v4l2_subdev *subdev,
 201                                struct v4l2_subdev_pad_config *cfg,
 202                                struct v4l2_subdev_frame_size_enum *fse)
 203 {
 204         struct vsp1_sru *sru = to_sru(subdev);
 205         struct v4l2_mbus_framefmt *format;
 206
 207         format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 208                                             SRU_PAD_SINK, fse->which);
 209
 210         if (fse->index || fse->code != format->code)
 211                 return -EINVAL;
 212
 213         if (fse->pad == SRU_PAD_SINK) {
 214                 fse->min_width = SRU_MIN_SIZE;
 215                 fse->max_width = SRU_MAX_SIZE;
 216                 fse->min_height = SRU_MIN_SIZE;
 217                 fse->max_height = SRU_MAX_SIZE;
 218         } else {
 219                 fse->min_width = format->width;
 220                 fse->min_height = format->height;
 221                 if (format->width <= SRU_MAX_SIZE / 2 &&
 222                     format->height <= SRU_MAX_SIZE / 2) {
 223                         fse->max_width = format->width * 2;
 224                         fse->max_height = format->height * 2;
 225                 } else {
 226                         fse->max_width = format->width;
 227                         fse->max_height = format->height;
 228                 }
 229         }
 230
 231         return 0;
 232 }
 233
 234 static int sru_get_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg,
 235                           struct v4l2_subdev_format *fmt)
 236 {
 237         struct vsp1_sru *sru = to_sru(subdev);
 238
 239         fmt->format = *vsp1_entity_get_pad_format(&sru->entity, cfg, fmt->pad,
 240                                                   fmt->which);
 241
 242         return 0;
 243 }
 244
 245 static void sru_try_format(struct vsp1_sru *sru, struct v4l2_subdev_pad_config *cfg,
 246                            unsigned int pad, struct v4l2_mbus_framefmt *fmt,
 247                            enum v4l2_subdev_format_whence which)
 248 {
 249         struct v4l2_mbus_framefmt *format;
 250         unsigned int input_area;
 251         unsigned int output_area;
 252
 253         switch (pad) {
 254         case SRU_PAD_SINK:
 255                 /* Default to YUV if the requested format is not supported. */
 256                 if (fmt->code != MEDIA_BUS_FMT_ARGB8888_1X32 &&
 257                     fmt->code != MEDIA_BUS_FMT_AYUV8_1X32)
 258                         fmt->code = MEDIA_BUS_FMT_AYUV8_1X32;
 259
 260                 fmt->width = clamp(fmt->width, SRU_MIN_SIZE, SRU_MAX_SIZE);
 261                 fmt->height = clamp(fmt->height, SRU_MIN_SIZE, SRU_MAX_SIZE);
 262                 break;
 263
 264         case SRU_PAD_SOURCE:
 265                 /* The SRU can't perform format conversion. */
 266                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 267                                                     SRU_PAD_SINK, which);
 268                 fmt->code = format->code;
 269
 270                 /* We can upscale by 2 in both direction, but not independently.
 271                  * Compare the input and output rectangles areas (avoiding
 272                  * integer overflows on the output): if the requested output
 273                  * area is larger than 1.5^2 the input area upscale by two,
 274                  * otherwise don't scale.
 275                  */
 276                 input_area = format->width * format->height;
 277                 output_area = min(fmt->width, SRU_MAX_SIZE)
 278                             * min(fmt->height, SRU_MAX_SIZE);
 279
 280                 if (fmt->width <= SRU_MAX_SIZE / 2 &&
 281                     fmt->height <= SRU_MAX_SIZE / 2 &&
 282                     output_area > input_area * 9 / 4) {
 283                         fmt->width = format->width * 2;
 284                         fmt->height = format->height * 2;
 285                 } else {
 286                         fmt->width = format->width;
 287                         fmt->height = format->height;
 288                 }
 289                 break;
 290         }
 291
 292         fmt->field = V4L2_FIELD_NONE;
 293         fmt->colorspace = V4L2_COLORSPACE_SRGB;
 294 }
 295
 296 static int sru_set_format(struct v4l2_subdev *subdev, struct v4l2_subdev_pad_config *cfg,
 297                           struct v4l2_subdev_format *fmt)
 298 {
 299         struct vsp1_sru *sru = to_sru(subdev);
 300         struct v4l2_mbus_framefmt *format;
 301
 302         sru_try_format(sru, cfg, fmt->pad, &fmt->format, fmt->which);
 303
 304         format = vsp1_entity_get_pad_format(&sru->entity, cfg, fmt->pad,
 305                                             fmt->which);
 306         *format = fmt->format;
 307
 308         if (fmt->pad == SRU_PAD_SINK) {
 309                 /* Propagate the format to the source pad. */
 310                 format = vsp1_entity_get_pad_format(&sru->entity, cfg,
 311                                                     SRU_PAD_SOURCE, fmt->which);
 312                 *format = fmt->format;
 313
 314                 sru_try_format(sru, cfg, SRU_PAD_SOURCE, format, fmt->which);
 315         }
 316
 317         return 0;
 318 }
 319
 320 /* -----------------------------------------------------------------------------
 321  * V4L2 Subdevice Operations
 322  */
 323
 324 static struct v4l2_subdev_video_ops sru_video_ops = {
 325         .s_stream = sru_s_stream,
 326 };
 327
 328 static struct v4l2_subdev_pad_ops sru_pad_ops = {
 329         .enum_mbus_code = sru_enum_mbus_code,
 330         .enum_frame_size = sru_enum_frame_size,
 331         .get_fmt = sru_get_format,
 332         .set_fmt = sru_set_format,
 333 };
 334
 335 static struct v4l2_subdev_ops sru_ops = {
 336         .video  = &sru_video_ops,
 337         .pad    = &sru_pad_ops,
 338 };
 339
 340 /* -----------------------------------------------------------------------------
 341  * Initialization and Cleanup
 342  */
 343
 344 struct vsp1_sru *vsp1_sru_create(struct vsp1_device *vsp1)
 345 {
 346         struct v4l2_subdev *subdev;
 347         struct vsp1_sru *sru;
 348         int ret;
 349
 350         sru = devm_kzalloc(vsp1->dev, sizeof(*sru), GFP_KERNEL);
 351         if (sru == NULL)
 352                 return ERR_PTR(-ENOMEM);
 353
 354         sru->entity.type = VSP1_ENTITY_SRU;
 355
 356         ret = vsp1_entity_init(vsp1, &sru->entity, 2);
 357         if (ret < 0)
 358                 return ERR_PTR(ret);
 359
 360         /* Initialize the V4L2 subdev. */
 361         subdev = &sru->entity.subdev;
 362         v4l2_subdev_init(subdev, &sru_ops);
 363
 364         subdev->entity.ops = &vsp1_media_ops;
 365         subdev->internal_ops = &vsp1_subdev_internal_ops;
 366         snprintf(subdev->name, sizeof(subdev->name), "%s sru",
 367                  dev_name(vsp1->dev));
 368         v4l2_set_subdevdata(subdev, sru);
 369         subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
 370
 371         vsp1_entity_init_formats(subdev, NULL);
 372
 373         /* Initialize the control handler. */
 374         v4l2_ctrl_handler_init(&sru->ctrls, 1);
 375         v4l2_ctrl_new_custom(&sru->ctrls, &sru_intensity_control, NULL);
 376
 377         sru->entity.subdev.ctrl_handler = &sru->ctrls;
 378
 379         if (sru->ctrls.error) {
 380                 dev_err(vsp1->dev, "sru: failed to initialize controls\n");
 381                 ret = sru->ctrls.error;
 382                 vsp1_entity_destroy(&sru->entity);
 383                 return ERR_PTR(ret);
 384         }
 385
 386         return sru;
 387 }