drivers/staging/media/imx/imx-ic-prp.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * V4L2 Capture IC Preprocess Subdev for Freescale i.MX5/6 SOC
   4  *
   5  * This subdevice handles capture of video frames from the CSI or VDIC,
   6  * which are routed directly to the Image Converter preprocess tasks,
   7  * for resizing, colorspace conversion, and rotation.
   8  *
   9  * Copyright (c) 2012-2017 Mentor Graphics Inc.
  10  */
  11 #include <linux/delay.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/module.h>
  14 #include <linux/sched.h>
  15 #include <linux/slab.h>
  16 #include <linux/spinlock.h>
  17 #include <linux/timer.h>
  18 #include <media/v4l2-ctrls.h>
  19 #include <media/v4l2-device.h>
  20 #include <media/v4l2-ioctl.h>
  21 #include <media/v4l2-subdev.h>
  22 #include <media/imx.h>
  23 #include "imx-media.h"
  24 #include "imx-ic.h"
  25
  26 /*
  27  * Min/Max supported width and heights.
  28  */
  29 #define MIN_W        32
  30 #define MIN_H        32
  31 #define MAX_W      4096
  32 #define MAX_H      4096
  33 #define W_ALIGN    4 /* multiple of 16 pixels */
  34 #define H_ALIGN    1 /* multiple of 2 lines */
  35 #define S_ALIGN    1 /* multiple of 2 */
  36
  37 struct prp_priv {
  38         struct imx_ic_priv *ic_priv;
  39         struct media_pad pad[PRP_NUM_PADS];
  40
  41         /* lock to protect all members below */
  42         struct mutex lock;
  43
  44         struct v4l2_subdev *src_sd;
  45         struct v4l2_subdev *sink_sd_prpenc;
  46         struct v4l2_subdev *sink_sd_prpvf;
  47
  48         /* the CSI id at link validate */
  49         int csi_id;
  50
  51         struct v4l2_mbus_framefmt format_mbus;
  52         struct v4l2_fract frame_interval;
  53
  54         int stream_count;
  55 };
  56
  57 static inline struct prp_priv *sd_to_priv(struct v4l2_subdev *sd)
  58 {
  59         struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);
  60
  61         return ic_priv->task_priv;
  62 }
  63
  64 static int prp_start(struct prp_priv *priv)
  65 {
  66         struct imx_ic_priv *ic_priv = priv->ic_priv;
  67         bool src_is_vdic;
  68
  69         /* set IC to receive from CSI or VDI depending on source */
  70         src_is_vdic = !!(priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC);
  71
  72         ipu_set_ic_src_mux(ic_priv->ipu, priv->csi_id, src_is_vdic);
  73
  74         return 0;
  75 }
  76
  77 static void prp_stop(struct prp_priv *priv)
  78 {
  79 }
  80
  81 static struct v4l2_mbus_framefmt *
  82 __prp_get_fmt(struct prp_priv *priv, struct v4l2_subdev_state *sd_state,
  83               unsigned int pad, enum v4l2_subdev_format_whence which)
  84 {
  85         struct imx_ic_priv *ic_priv = priv->ic_priv;
  86
  87         if (which == V4L2_SUBDEV_FORMAT_TRY)
  88                 return v4l2_subdev_get_try_format(&ic_priv->sd, sd_state, pad);
  89         else
  90                 return &priv->format_mbus;
  91 }
  92
  93 /*
  94  * V4L2 subdev operations.
  95  */
  96
  97 static int prp_enum_mbus_code(struct v4l2_subdev *sd,
  98                               struct v4l2_subdev_state *sd_state,
  99                               struct v4l2_subdev_mbus_code_enum *code)
 100 {
 101         struct prp_priv *priv = sd_to_priv(sd);
 102         struct v4l2_mbus_framefmt *infmt;
 103         int ret = 0;
 104
 105         mutex_lock(&priv->lock);
 106
 107         switch (code->pad) {
 108         case PRP_SINK_PAD:
 109                 ret = imx_media_enum_ipu_formats(&code->code, code->index,
 110                                                  PIXFMT_SEL_YUV_RGB);
 111                 break;
 112         case PRP_SRC_PAD_PRPENC:
 113         case PRP_SRC_PAD_PRPVF:
 114                 if (code->index != 0) {
 115                         ret = -EINVAL;
 116                         goto out;
 117                 }
 118                 infmt = __prp_get_fmt(priv, sd_state, PRP_SINK_PAD,
 119                                       code->which);
 120                 code->code = infmt->code;
 121                 break;
 122         default:
 123                 ret = -EINVAL;
 124         }
 125 out:
 126         mutex_unlock(&priv->lock);
 127         return ret;
 128 }
 129
 130 static int prp_get_fmt(struct v4l2_subdev *sd,
 131                        struct v4l2_subdev_state *sd_state,
 132                        struct v4l2_subdev_format *sdformat)
 133 {
 134         struct prp_priv *priv = sd_to_priv(sd);
 135         struct v4l2_mbus_framefmt *fmt;
 136         int ret = 0;
 137
 138         if (sdformat->pad >= PRP_NUM_PADS)
 139                 return -EINVAL;
 140
 141         mutex_lock(&priv->lock);
 142
 143         fmt = __prp_get_fmt(priv, sd_state, sdformat->pad, sdformat->which);
 144         if (!fmt) {
 145                 ret = -EINVAL;
 146                 goto out;
 147         }
 148
 149         sdformat->format = *fmt;
 150 out:
 151         mutex_unlock(&priv->lock);
 152         return ret;
 153 }
 154
 155 static int prp_set_fmt(struct v4l2_subdev *sd,
 156                        struct v4l2_subdev_state *sd_state,
 157                        struct v4l2_subdev_format *sdformat)
 158 {
 159         struct prp_priv *priv = sd_to_priv(sd);
 160         struct v4l2_mbus_framefmt *fmt, *infmt;
 161         const struct imx_media_pixfmt *cc;
 162         int ret = 0;
 163         u32 code;
 164
 165         if (sdformat->pad >= PRP_NUM_PADS)
 166                 return -EINVAL;
 167
 168         mutex_lock(&priv->lock);
 169
 170         if (priv->stream_count > 0) {
 171                 ret = -EBUSY;
 172                 goto out;
 173         }
 174
 175         infmt = __prp_get_fmt(priv, sd_state, PRP_SINK_PAD, sdformat->which);
 176
 177         switch (sdformat->pad) {
 178         case PRP_SINK_PAD:
 179                 v4l_bound_align_image(&sdformat->format.width, MIN_W, MAX_W,
 180                                       W_ALIGN, &sdformat->format.height,
 181                                       MIN_H, MAX_H, H_ALIGN, S_ALIGN);
 182
 183                 cc = imx_media_find_ipu_format(sdformat->format.code,
 184                                                PIXFMT_SEL_YUV_RGB);
 185                 if (!cc) {
 186                         imx_media_enum_ipu_formats(&code, 0,
 187                                                    PIXFMT_SEL_YUV_RGB);
 188                         cc = imx_media_find_ipu_format(code,
 189                                                        PIXFMT_SEL_YUV_RGB);
 190                         sdformat->format.code = cc->codes[0];
 191                 }
 192
 193                 if (sdformat->format.field == V4L2_FIELD_ANY)
 194                         sdformat->format.field = V4L2_FIELD_NONE;
 195                 break;
 196         case PRP_SRC_PAD_PRPENC:
 197         case PRP_SRC_PAD_PRPVF:
 198                 /* Output pads mirror input pad */
 199                 sdformat->format = *infmt;
 200                 break;
 201         }
 202
 203         imx_media_try_colorimetry(&sdformat->format, true);
 204
 205         fmt = __prp_get_fmt(priv, sd_state, sdformat->pad, sdformat->which);
 206         *fmt = sdformat->format;
 207 out:
 208         mutex_unlock(&priv->lock);
 209         return ret;
 210 }
 211
 212 static int prp_link_setup(struct media_entity *entity,
 213                           const struct media_pad *local,
 214                           const struct media_pad *remote, u32 flags)
 215 {
 216         struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
 217         struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);
 218         struct prp_priv *priv = ic_priv->task_priv;
 219         struct v4l2_subdev *remote_sd;
 220         int ret = 0;
 221
 222         dev_dbg(ic_priv->ipu_dev, "%s: link setup %s -> %s",
 223                 ic_priv->sd.name, remote->entity->name, local->entity->name);
 224
 225         remote_sd = media_entity_to_v4l2_subdev(remote->entity);
 226
 227         mutex_lock(&priv->lock);
 228
 229         if (local->flags & MEDIA_PAD_FL_SINK) {
 230                 if (flags & MEDIA_LNK_FL_ENABLED) {
 231                         if (priv->src_sd) {
 232                                 ret = -EBUSY;
 233                                 goto out;
 234                         }
 235                         if (priv->sink_sd_prpenc &&
 236                             (remote_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC)) {
 237                                 ret = -EINVAL;
 238                                 goto out;
 239                         }
 240                         priv->src_sd = remote_sd;
 241                 } else {
 242                         priv->src_sd = NULL;
 243                 }
 244
 245                 goto out;
 246         }
 247
 248         /* this is a source pad */
 249         if (flags & MEDIA_LNK_FL_ENABLED) {
 250                 switch (local->index) {
 251                 case PRP_SRC_PAD_PRPENC:
 252                         if (priv->sink_sd_prpenc) {
 253                                 ret = -EBUSY;
 254                                 goto out;
 255                         }
 256                         if (priv->src_sd && (priv->src_sd->grp_id &
 257                                              IMX_MEDIA_GRP_ID_IPU_VDIC)) {
 258                                 ret = -EINVAL;
 259                                 goto out;
 260                         }
 261                         priv->sink_sd_prpenc = remote_sd;
 262                         break;
 263                 case PRP_SRC_PAD_PRPVF:
 264                         if (priv->sink_sd_prpvf) {
 265                                 ret = -EBUSY;
 266                                 goto out;
 267                         }
 268                         priv->sink_sd_prpvf = remote_sd;
 269                         break;
 270                 default:
 271                         ret = -EINVAL;
 272                 }
 273         } else {
 274                 switch (local->index) {
 275                 case PRP_SRC_PAD_PRPENC:
 276                         priv->sink_sd_prpenc = NULL;
 277                         break;
 278                 case PRP_SRC_PAD_PRPVF:
 279                         priv->sink_sd_prpvf = NULL;
 280                         break;
 281                 default:
 282                         ret = -EINVAL;
 283                 }
 284         }
 285
 286 out:
 287         mutex_unlock(&priv->lock);
 288         return ret;
 289 }
 290
 291 static int prp_link_validate(struct v4l2_subdev *sd,
 292                              struct media_link *link,
 293                              struct v4l2_subdev_format *source_fmt,
 294                              struct v4l2_subdev_format *sink_fmt)
 295 {
 296         struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);
 297         struct prp_priv *priv = ic_priv->task_priv;
 298         struct v4l2_subdev *csi;
 299         int ret;
 300
 301         ret = v4l2_subdev_link_validate_default(sd, link,
 302                                                 source_fmt, sink_fmt);
 303         if (ret)
 304                 return ret;
 305
 306         csi = imx_media_pipeline_subdev(&ic_priv->sd.entity,
 307                                         IMX_MEDIA_GRP_ID_IPU_CSI, true);
 308         if (IS_ERR(csi))
 309                 csi = NULL;
 310
 311         mutex_lock(&priv->lock);
 312
 313         if (priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC) {
 314                 /*
 315                  * the ->PRPENC link cannot be enabled if the source
 316                  * is the VDIC
 317                  */
 318                 if (priv->sink_sd_prpenc) {
 319                         ret = -EINVAL;
 320                         goto out;
 321                 }
 322         } else {
 323                 /* the source is a CSI */
 324                 if (!csi) {
 325                         ret = -EINVAL;
 326                         goto out;
 327                 }
 328         }
 329
 330         if (csi) {
 331                 switch (csi->grp_id) {
 332                 case IMX_MEDIA_GRP_ID_IPU_CSI0:
 333                         priv->csi_id = 0;
 334                         break;
 335                 case IMX_MEDIA_GRP_ID_IPU_CSI1:
 336                         priv->csi_id = 1;
 337                         break;
 338                 default:
 339                         ret = -EINVAL;
 340                 }
 341         } else {
 342                 priv->csi_id = 0;
 343         }
 344
 345 out:
 346         mutex_unlock(&priv->lock);
 347         return ret;
 348 }
 349
 350 static int prp_s_stream(struct v4l2_subdev *sd, int enable)
 351 {
 352         struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd);
 353         struct prp_priv *priv = ic_priv->task_priv;
 354         int ret = 0;
 355
 356         mutex_lock(&priv->lock);
 357
 358         if (!priv->src_sd || (!priv->sink_sd_prpenc && !priv->sink_sd_prpvf)) {
 359                 ret = -EPIPE;
 360                 goto out;
 361         }
 362
 363         /*
 364          * enable/disable streaming only if stream_count is
 365          * going from 0 to 1 / 1 to 0.
 366          */
 367         if (priv->stream_count != !enable)
 368                 goto update_count;
 369
 370         dev_dbg(ic_priv->ipu_dev, "%s: stream %s\n", sd->name,
 371                 enable ? "ON" : "OFF");
 372
 373         if (enable)
 374                 ret = prp_start(priv);
 375         else
 376                 prp_stop(priv);
 377         if (ret)
 378                 goto out;
 379
 380         /* start/stop upstream */
 381         ret = v4l2_subdev_call(priv->src_sd, video, s_stream, enable);
 382         ret = (ret && ret != -ENOIOCTLCMD) ? ret : 0;
 383         if (ret) {
 384                 if (enable)
 385                         prp_stop(priv);
 386                 goto out;
 387         }
 388
 389 update_count:
 390         priv->stream_count += enable ? 1 : -1;
 391         if (priv->stream_count < 0)
 392                 priv->stream_count = 0;
 393 out:
 394         mutex_unlock(&priv->lock);
 395         return ret;
 396 }
 397
 398 static int prp_g_frame_interval(struct v4l2_subdev *sd,
 399                                 struct v4l2_subdev_frame_interval *fi)
 400 {
 401         struct prp_priv *priv = sd_to_priv(sd);
 402
 403         if (fi->pad >= PRP_NUM_PADS)
 404                 return -EINVAL;
 405
 406         mutex_lock(&priv->lock);
 407         fi->interval = priv->frame_interval;
 408         mutex_unlock(&priv->lock);
 409
 410         return 0;
 411 }
 412
 413 static int prp_s_frame_interval(struct v4l2_subdev *sd,
 414                                 struct v4l2_subdev_frame_interval *fi)
 415 {
 416         struct prp_priv *priv = sd_to_priv(sd);
 417
 418         if (fi->pad >= PRP_NUM_PADS)
 419                 return -EINVAL;
 420
 421         mutex_lock(&priv->lock);
 422
 423         /* No limits on valid frame intervals */
 424         if (fi->interval.numerator == 0 || fi->interval.denominator == 0)
 425                 fi->interval = priv->frame_interval;
 426         else
 427                 priv->frame_interval = fi->interval;
 428
 429         mutex_unlock(&priv->lock);
 430
 431         return 0;
 432 }
 433
 434 static int prp_registered(struct v4l2_subdev *sd)
 435 {
 436         struct prp_priv *priv = sd_to_priv(sd);
 437         u32 code;
 438
 439         /* init default frame interval */
 440         priv->frame_interval.numerator = 1;
 441         priv->frame_interval.denominator = 30;
 442
 443         /* set a default mbus format  */
 444         imx_media_enum_ipu_formats(&code, 0, PIXFMT_SEL_YUV);
 445
 446         return imx_media_init_mbus_fmt(&priv->format_mbus,
 447                                        IMX_MEDIA_DEF_PIX_WIDTH,
 448                                        IMX_MEDIA_DEF_PIX_HEIGHT, code,
 449                                        V4L2_FIELD_NONE, NULL);
 450 }
 451
 452 static const struct v4l2_subdev_pad_ops prp_pad_ops = {
 453         .init_cfg = imx_media_init_cfg,
 454         .enum_mbus_code = prp_enum_mbus_code,
 455         .get_fmt = prp_get_fmt,
 456         .set_fmt = prp_set_fmt,
 457         .link_validate = prp_link_validate,
 458 };
 459
 460 static const struct v4l2_subdev_video_ops prp_video_ops = {
 461         .g_frame_interval = prp_g_frame_interval,
 462         .s_frame_interval = prp_s_frame_interval,
 463         .s_stream = prp_s_stream,
 464 };
 465
 466 static const struct media_entity_operations prp_entity_ops = {
 467         .link_setup = prp_link_setup,
 468         .link_validate = v4l2_subdev_link_validate,
 469 };
 470
 471 static const struct v4l2_subdev_ops prp_subdev_ops = {
 472         .video = &prp_video_ops,
 473         .pad = &prp_pad_ops,
 474 };
 475
 476 static const struct v4l2_subdev_internal_ops prp_internal_ops = {
 477         .registered = prp_registered,
 478 };
 479
 480 static int prp_init(struct imx_ic_priv *ic_priv)
 481 {
 482         struct prp_priv *priv;
 483         int i;
 484
 485         priv = devm_kzalloc(ic_priv->ipu_dev, sizeof(*priv), GFP_KERNEL);
 486         if (!priv)
 487                 return -ENOMEM;
 488
 489         mutex_init(&priv->lock);
 490         ic_priv->task_priv = priv;
 491         priv->ic_priv = ic_priv;
 492
 493         for (i = 0; i < PRP_NUM_PADS; i++)
 494                 priv->pad[i].flags = (i == PRP_SINK_PAD) ?
 495                         MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
 496
 497         return media_entity_pads_init(&ic_priv->sd.entity, PRP_NUM_PADS,
 498                                       priv->pad);
 499 }
 500
 501 static void prp_remove(struct imx_ic_priv *ic_priv)
 502 {
 503         struct prp_priv *priv = ic_priv->task_priv;
 504
 505         mutex_destroy(&priv->lock);
 506 }
 507
 508 struct imx_ic_ops imx_ic_prp_ops = {
 509         .subdev_ops = &prp_subdev_ops,
 510         .internal_ops = &prp_internal_ops,
 511         .entity_ops = &prp_entity_ops,
 512         .init = prp_init,
 513         .remove = prp_remove,
 514 };