drivers/staging/media/rkvdec/rkvdec.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Rockchip Video Decoder driver
   4  *
   5  * Copyright (C) 2019 Collabora, Ltd.
   6  *
   7  * Based on rkvdec driver by Google LLC. (Tomasz Figa <tfiga@chromium.org>)
   8  * Based on s5p-mfc driver by Samsung Electronics Co., Ltd.
   9  * Copyright (C) 2011 Samsung Electronics Co., Ltd.
  10  */
  11
  12 #include <linux/clk.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/slab.h>
  20 #include <linux/videodev2.h>
  21 #include <linux/workqueue.h>
  22 #include <media/v4l2-event.h>
  23 #include <media/v4l2-mem2mem.h>
  24 #include <media/videobuf2-core.h>
  25 #include <media/videobuf2-vmalloc.h>
  26
  27 #include "rkvdec.h"
  28 #include "rkvdec-regs.h"
  29
  30 static int rkvdec_try_ctrl(struct v4l2_ctrl *ctrl)
  31 {
  32         struct rkvdec_ctx *ctx = container_of(ctrl->handler, struct rkvdec_ctx, ctrl_hdl);
  33         const struct rkvdec_coded_fmt_desc *desc = ctx->coded_fmt_desc;
  34
  35         if (desc->ops->try_ctrl)
  36                 return desc->ops->try_ctrl(ctx, ctrl);
  37
  38         return 0;
  39 }
  40
  41 static const struct v4l2_ctrl_ops rkvdec_ctrl_ops = {
  42         .try_ctrl = rkvdec_try_ctrl,
  43 };
  44
  45 static const struct rkvdec_ctrl_desc rkvdec_h264_ctrl_descs[] = {
  46         {
  47                 .cfg.id = V4L2_CID_STATELESS_H264_DECODE_PARAMS,
  48         },
  49         {
  50                 .cfg.id = V4L2_CID_STATELESS_H264_SPS,
  51                 .cfg.ops = &rkvdec_ctrl_ops,
  52         },
  53         {
  54                 .cfg.id = V4L2_CID_STATELESS_H264_PPS,
  55         },
  56         {
  57                 .cfg.id = V4L2_CID_STATELESS_H264_SCALING_MATRIX,
  58         },
  59         {
  60                 .cfg.id = V4L2_CID_STATELESS_H264_DECODE_MODE,
  61                 .cfg.min = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
  62                 .cfg.max = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
  63                 .cfg.def = V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED,
  64         },
  65         {
  66                 .cfg.id = V4L2_CID_STATELESS_H264_START_CODE,
  67                 .cfg.min = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
  68                 .cfg.def = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
  69                 .cfg.max = V4L2_STATELESS_H264_START_CODE_ANNEX_B,
  70         },
  71         {
  72                 .cfg.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
  73                 .cfg.min = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
  74                 .cfg.max = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
  75                 .cfg.menu_skip_mask =
  76                         BIT(V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED),
  77                 .cfg.def = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN,
  78         },
  79         {
  80                 .cfg.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
  81                 .cfg.min = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
  82                 .cfg.max = V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
  83         },
  84 };
  85
  86 static const struct rkvdec_ctrls rkvdec_h264_ctrls = {
  87         .ctrls = rkvdec_h264_ctrl_descs,
  88         .num_ctrls = ARRAY_SIZE(rkvdec_h264_ctrl_descs),
  89 };
  90
  91 static const u32 rkvdec_h264_vp9_decoded_fmts[] = {
  92         V4L2_PIX_FMT_NV12,
  93 };
  94
  95 static const struct rkvdec_ctrl_desc rkvdec_vp9_ctrl_descs[] = {
  96         {
  97                 .cfg.id = V4L2_CID_STATELESS_VP9_FRAME,
  98         },
  99         {
 100                 .cfg.id = V4L2_CID_STATELESS_VP9_COMPRESSED_HDR,
 101         },
 102         {
 103                 .cfg.id = V4L2_CID_MPEG_VIDEO_VP9_PROFILE,
 104                 .cfg.min = V4L2_MPEG_VIDEO_VP9_PROFILE_0,
 105                 .cfg.max = V4L2_MPEG_VIDEO_VP9_PROFILE_0,
 106                 .cfg.def = V4L2_MPEG_VIDEO_VP9_PROFILE_0,
 107         },
 108 };
 109
 110 static const struct rkvdec_ctrls rkvdec_vp9_ctrls = {
 111         .ctrls = rkvdec_vp9_ctrl_descs,
 112         .num_ctrls = ARRAY_SIZE(rkvdec_vp9_ctrl_descs),
 113 };
 114
 115 static const struct rkvdec_coded_fmt_desc rkvdec_coded_fmts[] = {
 116         {
 117                 .fourcc = V4L2_PIX_FMT_H264_SLICE,
 118                 .frmsize = {
 119                         .min_width = 48,
 120                         .max_width = 4096,
 121                         .step_width = 16,
 122                         .min_height = 48,
 123                         .max_height = 2304,
 124                         .step_height = 16,
 125                 },
 126                 .ctrls = &rkvdec_h264_ctrls,
 127                 .ops = &rkvdec_h264_fmt_ops,
 128                 .num_decoded_fmts = ARRAY_SIZE(rkvdec_h264_vp9_decoded_fmts),
 129                 .decoded_fmts = rkvdec_h264_vp9_decoded_fmts,
 130                 .subsystem_flags = VB2_V4L2_FL_SUPPORTS_M2M_HOLD_CAPTURE_BUF,
 131         },
 132         {
 133                 .fourcc = V4L2_PIX_FMT_VP9_FRAME,
 134                 .frmsize = {
 135                         .min_width = 64,
 136                         .max_width = 4096,
 137                         .step_width = 64,
 138                         .min_height = 64,
 139                         .max_height = 2304,
 140                         .step_height = 64,
 141                 },
 142                 .ctrls = &rkvdec_vp9_ctrls,
 143                 .ops = &rkvdec_vp9_fmt_ops,
 144                 .num_decoded_fmts = ARRAY_SIZE(rkvdec_h264_vp9_decoded_fmts),
 145                 .decoded_fmts = rkvdec_h264_vp9_decoded_fmts,
 146         }
 147 };
 148
 149 static const struct rkvdec_coded_fmt_desc *
 150 rkvdec_find_coded_fmt_desc(u32 fourcc)
 151 {
 152         unsigned int i;
 153
 154         for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++) {
 155                 if (rkvdec_coded_fmts[i].fourcc == fourcc)
 156                         return &rkvdec_coded_fmts[i];
 157         }
 158
 159         return NULL;
 160 }
 161
 162 static void rkvdec_reset_fmt(struct rkvdec_ctx *ctx, struct v4l2_format *f,
 163                              u32 fourcc)
 164 {
 165         memset(f, 0, sizeof(*f));
 166         f->fmt.pix_mp.pixelformat = fourcc;
 167         f->fmt.pix_mp.field = V4L2_FIELD_NONE;
 168         f->fmt.pix_mp.colorspace = V4L2_COLORSPACE_REC709;
 169         f->fmt.pix_mp.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT;
 170         f->fmt.pix_mp.quantization = V4L2_QUANTIZATION_DEFAULT;
 171         f->fmt.pix_mp.xfer_func = V4L2_XFER_FUNC_DEFAULT;
 172 }
 173
 174 static void rkvdec_reset_coded_fmt(struct rkvdec_ctx *ctx)
 175 {
 176         struct v4l2_format *f = &ctx->coded_fmt;
 177
 178         ctx->coded_fmt_desc = &rkvdec_coded_fmts[0];
 179         rkvdec_reset_fmt(ctx, f, ctx->coded_fmt_desc->fourcc);
 180
 181         f->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 182         f->fmt.pix_mp.width = ctx->coded_fmt_desc->frmsize.min_width;
 183         f->fmt.pix_mp.height = ctx->coded_fmt_desc->frmsize.min_height;
 184
 185         if (ctx->coded_fmt_desc->ops->adjust_fmt)
 186                 ctx->coded_fmt_desc->ops->adjust_fmt(ctx, f);
 187 }
 188
 189 static void rkvdec_reset_decoded_fmt(struct rkvdec_ctx *ctx)
 190 {
 191         struct v4l2_format *f = &ctx->decoded_fmt;
 192
 193         rkvdec_reset_fmt(ctx, f, ctx->coded_fmt_desc->decoded_fmts[0]);
 194         f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 195         v4l2_fill_pixfmt_mp(&f->fmt.pix_mp,
 196                             ctx->coded_fmt_desc->decoded_fmts[0],
 197                             ctx->coded_fmt.fmt.pix_mp.width,
 198                             ctx->coded_fmt.fmt.pix_mp.height);
 199         f->fmt.pix_mp.plane_fmt[0].sizeimage += 128 *
 200                 DIV_ROUND_UP(f->fmt.pix_mp.width, 16) *
 201                 DIV_ROUND_UP(f->fmt.pix_mp.height, 16);
 202 }
 203
 204 static int rkvdec_enum_framesizes(struct file *file, void *priv,
 205                                   struct v4l2_frmsizeenum *fsize)
 206 {
 207         const struct rkvdec_coded_fmt_desc *fmt;
 208
 209         if (fsize->index != 0)
 210                 return -EINVAL;
 211
 212         fmt = rkvdec_find_coded_fmt_desc(fsize->pixel_format);
 213         if (!fmt)
 214                 return -EINVAL;
 215
 216         fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
 217         fsize->stepwise = fmt->frmsize;
 218         return 0;
 219 }
 220
 221 static int rkvdec_querycap(struct file *file, void *priv,
 222                            struct v4l2_capability *cap)
 223 {
 224         struct rkvdec_dev *rkvdec = video_drvdata(file);
 225         struct video_device *vdev = video_devdata(file);
 226
 227         strscpy(cap->driver, rkvdec->dev->driver->name,
 228                 sizeof(cap->driver));
 229         strscpy(cap->card, vdev->name, sizeof(cap->card));
 230         snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
 231                  rkvdec->dev->driver->name);
 232         return 0;
 233 }
 234
 235 static int rkvdec_try_capture_fmt(struct file *file, void *priv,
 236                                   struct v4l2_format *f)
 237 {
 238         struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
 239         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 240         const struct rkvdec_coded_fmt_desc *coded_desc;
 241         unsigned int i;
 242
 243         /*
 244          * The codec context should point to a coded format desc, if the format
 245          * on the coded end has not been set yet, it should point to the
 246          * default value.
 247          */
 248         coded_desc = ctx->coded_fmt_desc;
 249         if (WARN_ON(!coded_desc))
 250                 return -EINVAL;
 251
 252         for (i = 0; i < coded_desc->num_decoded_fmts; i++) {
 253                 if (coded_desc->decoded_fmts[i] == pix_mp->pixelformat)
 254                         break;
 255         }
 256
 257         if (i == coded_desc->num_decoded_fmts)
 258                 pix_mp->pixelformat = coded_desc->decoded_fmts[0];
 259
 260         /* Always apply the frmsize constraint of the coded end. */
 261         pix_mp->width = max(pix_mp->width, ctx->coded_fmt.fmt.pix_mp.width);
 262         pix_mp->height = max(pix_mp->height, ctx->coded_fmt.fmt.pix_mp.height);
 263         v4l2_apply_frmsize_constraints(&pix_mp->width,
 264                                        &pix_mp->height,
 265                                        &coded_desc->frmsize);
 266
 267         v4l2_fill_pixfmt_mp(pix_mp, pix_mp->pixelformat,
 268                             pix_mp->width, pix_mp->height);
 269         pix_mp->plane_fmt[0].sizeimage +=
 270                 128 *
 271                 DIV_ROUND_UP(pix_mp->width, 16) *
 272                 DIV_ROUND_UP(pix_mp->height, 16);
 273         pix_mp->field = V4L2_FIELD_NONE;
 274
 275         return 0;
 276 }
 277
 278 static int rkvdec_try_output_fmt(struct file *file, void *priv,
 279                                  struct v4l2_format *f)
 280 {
 281         struct v4l2_pix_format_mplane *pix_mp = &f->fmt.pix_mp;
 282         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 283         const struct rkvdec_coded_fmt_desc *desc;
 284
 285         desc = rkvdec_find_coded_fmt_desc(pix_mp->pixelformat);
 286         if (!desc) {
 287                 pix_mp->pixelformat = rkvdec_coded_fmts[0].fourcc;
 288                 desc = &rkvdec_coded_fmts[0];
 289         }
 290
 291         v4l2_apply_frmsize_constraints(&pix_mp->width,
 292                                        &pix_mp->height,
 293                                        &desc->frmsize);
 294
 295         pix_mp->field = V4L2_FIELD_NONE;
 296         /* All coded formats are considered single planar for now. */
 297         pix_mp->num_planes = 1;
 298
 299         if (desc->ops->adjust_fmt) {
 300                 int ret;
 301
 302                 ret = desc->ops->adjust_fmt(ctx, f);
 303                 if (ret)
 304                         return ret;
 305         }
 306
 307         return 0;
 308 }
 309
 310 static int rkvdec_s_capture_fmt(struct file *file, void *priv,
 311                                 struct v4l2_format *f)
 312 {
 313         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 314         struct vb2_queue *vq;
 315         int ret;
 316
 317         /* Change not allowed if queue is busy */
 318         vq = v4l2_m2m_get_vq(ctx->fh.m2m_ctx,
 319                              V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 320         if (vb2_is_busy(vq))
 321                 return -EBUSY;
 322
 323         ret = rkvdec_try_capture_fmt(file, priv, f);
 324         if (ret)
 325                 return ret;
 326
 327         ctx->decoded_fmt = *f;
 328         return 0;
 329 }
 330
 331 static int rkvdec_s_output_fmt(struct file *file, void *priv,
 332                                struct v4l2_format *f)
 333 {
 334         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 335         struct v4l2_m2m_ctx *m2m_ctx = ctx->fh.m2m_ctx;
 336         const struct rkvdec_coded_fmt_desc *desc;
 337         struct v4l2_format *cap_fmt;
 338         struct vb2_queue *peer_vq, *vq;
 339         int ret;
 340
 341         /*
 342          * In order to support dynamic resolution change, the decoder admits
 343          * a resolution change, as long as the pixelformat remains. Can't be
 344          * done if streaming.
 345          */
 346         vq = v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
 347         if (vb2_is_streaming(vq) ||
 348             (vb2_is_busy(vq) &&
 349              f->fmt.pix_mp.pixelformat != ctx->coded_fmt.fmt.pix_mp.pixelformat))
 350                 return -EBUSY;
 351
 352         /*
 353          * Since format change on the OUTPUT queue will reset the CAPTURE
 354          * queue, we can't allow doing so when the CAPTURE queue has buffers
 355          * allocated.
 356          */
 357         peer_vq = v4l2_m2m_get_vq(m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
 358         if (vb2_is_busy(peer_vq))
 359                 return -EBUSY;
 360
 361         ret = rkvdec_try_output_fmt(file, priv, f);
 362         if (ret)
 363                 return ret;
 364
 365         desc = rkvdec_find_coded_fmt_desc(f->fmt.pix_mp.pixelformat);
 366         if (!desc)
 367                 return -EINVAL;
 368         ctx->coded_fmt_desc = desc;
 369         ctx->coded_fmt = *f;
 370
 371         /*
 372          * Current decoded format might have become invalid with newly
 373          * selected codec, so reset it to default just to be safe and
 374          * keep internal driver state sane. User is mandated to set
 375          * the decoded format again after we return, so we don't need
 376          * anything smarter.
 377          *
 378          * Note that this will propagates any size changes to the decoded format.
 379          */
 380         rkvdec_reset_decoded_fmt(ctx);
 381
 382         /* Propagate colorspace information to capture. */
 383         cap_fmt = &ctx->decoded_fmt;
 384         cap_fmt->fmt.pix_mp.colorspace = f->fmt.pix_mp.colorspace;
 385         cap_fmt->fmt.pix_mp.xfer_func = f->fmt.pix_mp.xfer_func;
 386         cap_fmt->fmt.pix_mp.ycbcr_enc = f->fmt.pix_mp.ycbcr_enc;
 387         cap_fmt->fmt.pix_mp.quantization = f->fmt.pix_mp.quantization;
 388
 389         /* Enable format specific queue features */
 390         vq->subsystem_flags |= desc->subsystem_flags;
 391
 392         return 0;
 393 }
 394
 395 static int rkvdec_g_output_fmt(struct file *file, void *priv,
 396                                struct v4l2_format *f)
 397 {
 398         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 399
 400         *f = ctx->coded_fmt;
 401         return 0;
 402 }
 403
 404 static int rkvdec_g_capture_fmt(struct file *file, void *priv,
 405                                 struct v4l2_format *f)
 406 {
 407         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 408
 409         *f = ctx->decoded_fmt;
 410         return 0;
 411 }
 412
 413 static int rkvdec_enum_output_fmt(struct file *file, void *priv,
 414                                   struct v4l2_fmtdesc *f)
 415 {
 416         if (f->index >= ARRAY_SIZE(rkvdec_coded_fmts))
 417                 return -EINVAL;
 418
 419         f->pixelformat = rkvdec_coded_fmts[f->index].fourcc;
 420         return 0;
 421 }
 422
 423 static int rkvdec_enum_capture_fmt(struct file *file, void *priv,
 424                                    struct v4l2_fmtdesc *f)
 425 {
 426         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(priv);
 427
 428         if (WARN_ON(!ctx->coded_fmt_desc))
 429                 return -EINVAL;
 430
 431         if (f->index >= ctx->coded_fmt_desc->num_decoded_fmts)
 432                 return -EINVAL;
 433
 434         f->pixelformat = ctx->coded_fmt_desc->decoded_fmts[f->index];
 435         return 0;
 436 }
 437
 438 static const struct v4l2_ioctl_ops rkvdec_ioctl_ops = {
 439         .vidioc_querycap = rkvdec_querycap,
 440         .vidioc_enum_framesizes = rkvdec_enum_framesizes,
 441
 442         .vidioc_try_fmt_vid_cap_mplane = rkvdec_try_capture_fmt,
 443         .vidioc_try_fmt_vid_out_mplane = rkvdec_try_output_fmt,
 444         .vidioc_s_fmt_vid_out_mplane = rkvdec_s_output_fmt,
 445         .vidioc_s_fmt_vid_cap_mplane = rkvdec_s_capture_fmt,
 446         .vidioc_g_fmt_vid_out_mplane = rkvdec_g_output_fmt,
 447         .vidioc_g_fmt_vid_cap_mplane = rkvdec_g_capture_fmt,
 448         .vidioc_enum_fmt_vid_out = rkvdec_enum_output_fmt,
 449         .vidioc_enum_fmt_vid_cap = rkvdec_enum_capture_fmt,
 450
 451         .vidioc_reqbufs = v4l2_m2m_ioctl_reqbufs,
 452         .vidioc_querybuf = v4l2_m2m_ioctl_querybuf,
 453         .vidioc_qbuf = v4l2_m2m_ioctl_qbuf,
 454         .vidioc_dqbuf = v4l2_m2m_ioctl_dqbuf,
 455         .vidioc_prepare_buf = v4l2_m2m_ioctl_prepare_buf,
 456         .vidioc_create_bufs = v4l2_m2m_ioctl_create_bufs,
 457         .vidioc_expbuf = v4l2_m2m_ioctl_expbuf,
 458
 459         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 460         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 461
 462         .vidioc_streamon = v4l2_m2m_ioctl_streamon,
 463         .vidioc_streamoff = v4l2_m2m_ioctl_streamoff,
 464 };
 465
 466 static int rkvdec_queue_setup(struct vb2_queue *vq, unsigned int *num_buffers,
 467                               unsigned int *num_planes, unsigned int sizes[],
 468                               struct device *alloc_devs[])
 469 {
 470         struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
 471         struct v4l2_format *f;
 472         unsigned int i;
 473
 474         if (V4L2_TYPE_IS_OUTPUT(vq->type))
 475                 f = &ctx->coded_fmt;
 476         else
 477                 f = &ctx->decoded_fmt;
 478
 479         if (*num_planes) {
 480                 if (*num_planes != f->fmt.pix_mp.num_planes)
 481                         return -EINVAL;
 482
 483                 for (i = 0; i < f->fmt.pix_mp.num_planes; i++) {
 484                         if (sizes[i] < f->fmt.pix_mp.plane_fmt[i].sizeimage)
 485                                 return -EINVAL;
 486                 }
 487         } else {
 488                 *num_planes = f->fmt.pix_mp.num_planes;
 489                 for (i = 0; i < f->fmt.pix_mp.num_planes; i++)
 490                         sizes[i] = f->fmt.pix_mp.plane_fmt[i].sizeimage;
 491         }
 492
 493         return 0;
 494 }
 495
 496 static int rkvdec_buf_prepare(struct vb2_buffer *vb)
 497 {
 498         struct vb2_queue *vq = vb->vb2_queue;
 499         struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
 500         struct v4l2_format *f;
 501         unsigned int i;
 502
 503         if (V4L2_TYPE_IS_OUTPUT(vq->type))
 504                 f = &ctx->coded_fmt;
 505         else
 506                 f = &ctx->decoded_fmt;
 507
 508         for (i = 0; i < f->fmt.pix_mp.num_planes; ++i) {
 509                 u32 sizeimage = f->fmt.pix_mp.plane_fmt[i].sizeimage;
 510
 511                 if (vb2_plane_size(vb, i) < sizeimage)
 512                         return -EINVAL;
 513         }
 514
 515         /*
 516          * Buffer's bytesused must be written by driver for CAPTURE buffers.
 517          * (for OUTPUT buffers, if userspace passes 0 bytesused, v4l2-core sets
 518          * it to buffer length).
 519          */
 520         if (V4L2_TYPE_IS_CAPTURE(vq->type))
 521                 vb2_set_plane_payload(vb, 0, f->fmt.pix_mp.plane_fmt[0].sizeimage);
 522
 523         return 0;
 524 }
 525
 526 static void rkvdec_buf_queue(struct vb2_buffer *vb)
 527 {
 528         struct rkvdec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 529         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 530
 531         v4l2_m2m_buf_queue(ctx->fh.m2m_ctx, vbuf);
 532 }
 533
 534 static int rkvdec_buf_out_validate(struct vb2_buffer *vb)
 535 {
 536         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 537
 538         vbuf->field = V4L2_FIELD_NONE;
 539         return 0;
 540 }
 541
 542 static void rkvdec_buf_request_complete(struct vb2_buffer *vb)
 543 {
 544         struct rkvdec_ctx *ctx = vb2_get_drv_priv(vb->vb2_queue);
 545
 546         v4l2_ctrl_request_complete(vb->req_obj.req, &ctx->ctrl_hdl);
 547 }
 548
 549 static int rkvdec_start_streaming(struct vb2_queue *q, unsigned int count)
 550 {
 551         struct rkvdec_ctx *ctx = vb2_get_drv_priv(q);
 552         const struct rkvdec_coded_fmt_desc *desc;
 553         int ret;
 554
 555         if (V4L2_TYPE_IS_CAPTURE(q->type))
 556                 return 0;
 557
 558         desc = ctx->coded_fmt_desc;
 559         if (WARN_ON(!desc))
 560                 return -EINVAL;
 561
 562         if (desc->ops->start) {
 563                 ret = desc->ops->start(ctx);
 564                 if (ret)
 565                         return ret;
 566         }
 567
 568         return 0;
 569 }
 570
 571 static void rkvdec_queue_cleanup(struct vb2_queue *vq, u32 state)
 572 {
 573         struct rkvdec_ctx *ctx = vb2_get_drv_priv(vq);
 574
 575         while (true) {
 576                 struct vb2_v4l2_buffer *vbuf;
 577
 578                 if (V4L2_TYPE_IS_OUTPUT(vq->type))
 579                         vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
 580                 else
 581                         vbuf = v4l2_m2m_dst_buf_remove(ctx->fh.m2m_ctx);
 582
 583                 if (!vbuf)
 584                         break;
 585
 586                 v4l2_ctrl_request_complete(vbuf->vb2_buf.req_obj.req,
 587                                            &ctx->ctrl_hdl);
 588                 v4l2_m2m_buf_done(vbuf, state);
 589         }
 590 }
 591
 592 static void rkvdec_stop_streaming(struct vb2_queue *q)
 593 {
 594         struct rkvdec_ctx *ctx = vb2_get_drv_priv(q);
 595
 596         if (V4L2_TYPE_IS_OUTPUT(q->type)) {
 597                 const struct rkvdec_coded_fmt_desc *desc = ctx->coded_fmt_desc;
 598
 599                 if (WARN_ON(!desc))
 600                         return;
 601
 602                 if (desc->ops->stop)
 603                         desc->ops->stop(ctx);
 604         }
 605
 606         rkvdec_queue_cleanup(q, VB2_BUF_STATE_ERROR);
 607 }
 608
 609 static const struct vb2_ops rkvdec_queue_ops = {
 610         .queue_setup = rkvdec_queue_setup,
 611         .buf_prepare = rkvdec_buf_prepare,
 612         .buf_queue = rkvdec_buf_queue,
 613         .buf_out_validate = rkvdec_buf_out_validate,
 614         .buf_request_complete = rkvdec_buf_request_complete,
 615         .start_streaming = rkvdec_start_streaming,
 616         .stop_streaming = rkvdec_stop_streaming,
 617         .wait_prepare = vb2_ops_wait_prepare,
 618         .wait_finish = vb2_ops_wait_finish,
 619 };
 620
 621 static int rkvdec_request_validate(struct media_request *req)
 622 {
 623         unsigned int count;
 624
 625         count = vb2_request_buffer_cnt(req);
 626         if (!count)
 627                 return -ENOENT;
 628         else if (count > 1)
 629                 return -EINVAL;
 630
 631         return vb2_request_validate(req);
 632 }
 633
 634 static const struct media_device_ops rkvdec_media_ops = {
 635         .req_validate = rkvdec_request_validate,
 636         .req_queue = v4l2_m2m_request_queue,
 637 };
 638
 639 static void rkvdec_job_finish_no_pm(struct rkvdec_ctx *ctx,
 640                                     enum vb2_buffer_state result)
 641 {
 642         if (ctx->coded_fmt_desc->ops->done) {
 643                 struct vb2_v4l2_buffer *src_buf, *dst_buf;
 644
 645                 src_buf = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 646                 dst_buf = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
 647                 ctx->coded_fmt_desc->ops->done(ctx, src_buf, dst_buf, result);
 648         }
 649
 650         v4l2_m2m_buf_done_and_job_finish(ctx->dev->m2m_dev, ctx->fh.m2m_ctx,
 651                                          result);
 652 }
 653
 654 static void rkvdec_job_finish(struct rkvdec_ctx *ctx,
 655                               enum vb2_buffer_state result)
 656 {
 657         struct rkvdec_dev *rkvdec = ctx->dev;
 658
 659         pm_runtime_mark_last_busy(rkvdec->dev);
 660         pm_runtime_put_autosuspend(rkvdec->dev);
 661         rkvdec_job_finish_no_pm(ctx, result);
 662 }
 663
 664 void rkvdec_run_preamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)
 665 {
 666         struct media_request *src_req;
 667
 668         memset(run, 0, sizeof(*run));
 669
 670         run->bufs.src = v4l2_m2m_next_src_buf(ctx->fh.m2m_ctx);
 671         run->bufs.dst = v4l2_m2m_next_dst_buf(ctx->fh.m2m_ctx);
 672
 673         /* Apply request(s) controls if needed. */
 674         src_req = run->bufs.src->vb2_buf.req_obj.req;
 675         if (src_req)
 676                 v4l2_ctrl_request_setup(src_req, &ctx->ctrl_hdl);
 677
 678         v4l2_m2m_buf_copy_metadata(run->bufs.src, run->bufs.dst, true);
 679 }
 680
 681 void rkvdec_run_postamble(struct rkvdec_ctx *ctx, struct rkvdec_run *run)
 682 {
 683         struct media_request *src_req = run->bufs.src->vb2_buf.req_obj.req;
 684
 685         if (src_req)
 686                 v4l2_ctrl_request_complete(src_req, &ctx->ctrl_hdl);
 687 }
 688
 689 static void rkvdec_device_run(void *priv)
 690 {
 691         struct rkvdec_ctx *ctx = priv;
 692         struct rkvdec_dev *rkvdec = ctx->dev;
 693         const struct rkvdec_coded_fmt_desc *desc = ctx->coded_fmt_desc;
 694         int ret;
 695
 696         if (WARN_ON(!desc))
 697                 return;
 698
 699         ret = pm_runtime_resume_and_get(rkvdec->dev);
 700         if (ret < 0) {
 701                 rkvdec_job_finish_no_pm(ctx, VB2_BUF_STATE_ERROR);
 702                 return;
 703         }
 704
 705         ret = desc->ops->run(ctx);
 706         if (ret)
 707                 rkvdec_job_finish(ctx, VB2_BUF_STATE_ERROR);
 708 }
 709
 710 static const struct v4l2_m2m_ops rkvdec_m2m_ops = {
 711         .device_run = rkvdec_device_run,
 712 };
 713
 714 static int rkvdec_queue_init(void *priv,
 715                              struct vb2_queue *src_vq,
 716                              struct vb2_queue *dst_vq)
 717 {
 718         struct rkvdec_ctx *ctx = priv;
 719         struct rkvdec_dev *rkvdec = ctx->dev;
 720         int ret;
 721
 722         src_vq->type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 723         src_vq->io_modes = VB2_MMAP | VB2_DMABUF;
 724         src_vq->drv_priv = ctx;
 725         src_vq->ops = &rkvdec_queue_ops;
 726         src_vq->mem_ops = &vb2_dma_contig_memops;
 727
 728         /*
 729          * Driver does mostly sequential access, so sacrifice TLB efficiency
 730          * for faster allocation. Also, no CPU access on the source queue,
 731          * so no kernel mapping needed.
 732          */
 733         src_vq->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES |
 734                             DMA_ATTR_NO_KERNEL_MAPPING;
 735         src_vq->buf_struct_size = sizeof(struct v4l2_m2m_buffer);
 736         src_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
 737         src_vq->lock = &rkvdec->vdev_lock;
 738         src_vq->dev = rkvdec->v4l2_dev.dev;
 739         src_vq->supports_requests = true;
 740         src_vq->requires_requests = true;
 741
 742         ret = vb2_queue_init(src_vq);
 743         if (ret)
 744                 return ret;
 745
 746         dst_vq->bidirectional = true;
 747         dst_vq->mem_ops = &vb2_dma_contig_memops;
 748         dst_vq->dma_attrs = DMA_ATTR_ALLOC_SINGLE_PAGES |
 749                             DMA_ATTR_NO_KERNEL_MAPPING;
 750         dst_vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 751         dst_vq->io_modes = VB2_MMAP | VB2_DMABUF;
 752         dst_vq->drv_priv = ctx;
 753         dst_vq->ops = &rkvdec_queue_ops;
 754         dst_vq->buf_struct_size = sizeof(struct rkvdec_decoded_buffer);
 755         dst_vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY;
 756         dst_vq->lock = &rkvdec->vdev_lock;
 757         dst_vq->dev = rkvdec->v4l2_dev.dev;
 758
 759         return vb2_queue_init(dst_vq);
 760 }
 761
 762 static int rkvdec_add_ctrls(struct rkvdec_ctx *ctx,
 763                             const struct rkvdec_ctrls *ctrls)
 764 {
 765         unsigned int i;
 766
 767         for (i = 0; i < ctrls->num_ctrls; i++) {
 768                 const struct v4l2_ctrl_config *cfg = &ctrls->ctrls[i].cfg;
 769
 770                 v4l2_ctrl_new_custom(&ctx->ctrl_hdl, cfg, ctx);
 771                 if (ctx->ctrl_hdl.error)
 772                         return ctx->ctrl_hdl.error;
 773         }
 774
 775         return 0;
 776 }
 777
 778 static int rkvdec_init_ctrls(struct rkvdec_ctx *ctx)
 779 {
 780         unsigned int i, nctrls = 0;
 781         int ret;
 782
 783         for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++)
 784                 nctrls += rkvdec_coded_fmts[i].ctrls->num_ctrls;
 785
 786         v4l2_ctrl_handler_init(&ctx->ctrl_hdl, nctrls);
 787
 788         for (i = 0; i < ARRAY_SIZE(rkvdec_coded_fmts); i++) {
 789                 ret = rkvdec_add_ctrls(ctx, rkvdec_coded_fmts[i].ctrls);
 790                 if (ret)
 791                         goto err_free_handler;
 792         }
 793
 794         ret = v4l2_ctrl_handler_setup(&ctx->ctrl_hdl);
 795         if (ret)
 796                 goto err_free_handler;
 797
 798         ctx->fh.ctrl_handler = &ctx->ctrl_hdl;
 799         return 0;
 800
 801 err_free_handler:
 802         v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
 803         return ret;
 804 }
 805
 806 static int rkvdec_open(struct file *filp)
 807 {
 808         struct rkvdec_dev *rkvdec = video_drvdata(filp);
 809         struct rkvdec_ctx *ctx;
 810         int ret;
 811
 812         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 813         if (!ctx)
 814                 return -ENOMEM;
 815
 816         ctx->dev = rkvdec;
 817         rkvdec_reset_coded_fmt(ctx);
 818         rkvdec_reset_decoded_fmt(ctx);
 819         v4l2_fh_init(&ctx->fh, video_devdata(filp));
 820
 821         ret = rkvdec_init_ctrls(ctx);
 822         if (ret)
 823                 goto err_free_ctx;
 824
 825         ctx->fh.m2m_ctx = v4l2_m2m_ctx_init(rkvdec->m2m_dev, ctx,
 826                                             rkvdec_queue_init);
 827         if (IS_ERR(ctx->fh.m2m_ctx)) {
 828                 ret = PTR_ERR(ctx->fh.m2m_ctx);
 829                 goto err_cleanup_ctrls;
 830         }
 831
 832         filp->private_data = &ctx->fh;
 833         v4l2_fh_add(&ctx->fh);
 834
 835         return 0;
 836
 837 err_cleanup_ctrls:
 838         v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
 839
 840 err_free_ctx:
 841         kfree(ctx);
 842         return ret;
 843 }
 844
 845 static int rkvdec_release(struct file *filp)
 846 {
 847         struct rkvdec_ctx *ctx = fh_to_rkvdec_ctx(filp->private_data);
 848
 849         v4l2_fh_del(&ctx->fh);
 850         v4l2_m2m_ctx_release(ctx->fh.m2m_ctx);
 851         v4l2_ctrl_handler_free(&ctx->ctrl_hdl);
 852         v4l2_fh_exit(&ctx->fh);
 853         kfree(ctx);
 854
 855         return 0;
 856 }
 857
 858 static const struct v4l2_file_operations rkvdec_fops = {
 859         .owner = THIS_MODULE,
 860         .open = rkvdec_open,
 861         .release = rkvdec_release,
 862         .poll = v4l2_m2m_fop_poll,
 863         .unlocked_ioctl = video_ioctl2,
 864         .mmap = v4l2_m2m_fop_mmap,
 865 };
 866
 867 static int rkvdec_v4l2_init(struct rkvdec_dev *rkvdec)
 868 {
 869         int ret;
 870
 871         ret = v4l2_device_register(rkvdec->dev, &rkvdec->v4l2_dev);
 872         if (ret) {
 873                 dev_err(rkvdec->dev, "Failed to register V4L2 device\n");
 874                 return ret;
 875         }
 876
 877         rkvdec->m2m_dev = v4l2_m2m_init(&rkvdec_m2m_ops);
 878         if (IS_ERR(rkvdec->m2m_dev)) {
 879                 v4l2_err(&rkvdec->v4l2_dev, "Failed to init mem2mem device\n");
 880                 ret = PTR_ERR(rkvdec->m2m_dev);
 881                 goto err_unregister_v4l2;
 882         }
 883
 884         rkvdec->mdev.dev = rkvdec->dev;
 885         strscpy(rkvdec->mdev.model, "rkvdec", sizeof(rkvdec->mdev.model));
 886         strscpy(rkvdec->mdev.bus_info, "platform:rkvdec",
 887                 sizeof(rkvdec->mdev.bus_info));
 888         media_device_init(&rkvdec->mdev);
 889         rkvdec->mdev.ops = &rkvdec_media_ops;
 890         rkvdec->v4l2_dev.mdev = &rkvdec->mdev;
 891
 892         rkvdec->vdev.lock = &rkvdec->vdev_lock;
 893         rkvdec->vdev.v4l2_dev = &rkvdec->v4l2_dev;
 894         rkvdec->vdev.fops = &rkvdec_fops;
 895         rkvdec->vdev.release = video_device_release_empty;
 896         rkvdec->vdev.vfl_dir = VFL_DIR_M2M;
 897         rkvdec->vdev.device_caps = V4L2_CAP_STREAMING |
 898                                    V4L2_CAP_VIDEO_M2M_MPLANE;
 899         rkvdec->vdev.ioctl_ops = &rkvdec_ioctl_ops;
 900         video_set_drvdata(&rkvdec->vdev, rkvdec);
 901         strscpy(rkvdec->vdev.name, "rkvdec", sizeof(rkvdec->vdev.name));
 902
 903         ret = video_register_device(&rkvdec->vdev, VFL_TYPE_VIDEO, -1);
 904         if (ret) {
 905                 v4l2_err(&rkvdec->v4l2_dev, "Failed to register video device\n");
 906                 goto err_cleanup_mc;
 907         }
 908
 909         ret = v4l2_m2m_register_media_controller(rkvdec->m2m_dev, &rkvdec->vdev,
 910                                                  MEDIA_ENT_F_PROC_VIDEO_DECODER);
 911         if (ret) {
 912                 v4l2_err(&rkvdec->v4l2_dev,
 913                          "Failed to initialize V4L2 M2M media controller\n");
 914                 goto err_unregister_vdev;
 915         }
 916
 917         ret = media_device_register(&rkvdec->mdev);
 918         if (ret) {
 919                 v4l2_err(&rkvdec->v4l2_dev, "Failed to register media device\n");
 920                 goto err_unregister_mc;
 921         }
 922
 923         return 0;
 924
 925 err_unregister_mc:
 926         v4l2_m2m_unregister_media_controller(rkvdec->m2m_dev);
 927
 928 err_unregister_vdev:
 929         video_unregister_device(&rkvdec->vdev);
 930
 931 err_cleanup_mc:
 932         media_device_cleanup(&rkvdec->mdev);
 933         v4l2_m2m_release(rkvdec->m2m_dev);
 934
 935 err_unregister_v4l2:
 936         v4l2_device_unregister(&rkvdec->v4l2_dev);
 937         return ret;
 938 }
 939
 940 static void rkvdec_v4l2_cleanup(struct rkvdec_dev *rkvdec)
 941 {
 942         media_device_unregister(&rkvdec->mdev);
 943         v4l2_m2m_unregister_media_controller(rkvdec->m2m_dev);
 944         video_unregister_device(&rkvdec->vdev);
 945         media_device_cleanup(&rkvdec->mdev);
 946         v4l2_m2m_release(rkvdec->m2m_dev);
 947         v4l2_device_unregister(&rkvdec->v4l2_dev);
 948 }
 949
 950 static irqreturn_t rkvdec_irq_handler(int irq, void *priv)
 951 {
 952         struct rkvdec_dev *rkvdec = priv;
 953         enum vb2_buffer_state state;
 954         u32 status;
 955
 956         status = readl(rkvdec->regs + RKVDEC_REG_INTERRUPT);
 957         state = (status & RKVDEC_RDY_STA) ?
 958                 VB2_BUF_STATE_DONE : VB2_BUF_STATE_ERROR;
 959
 960         writel(0, rkvdec->regs + RKVDEC_REG_INTERRUPT);
 961         if (cancel_delayed_work(&rkvdec->watchdog_work)) {
 962                 struct rkvdec_ctx *ctx;
 963
 964                 ctx = v4l2_m2m_get_curr_priv(rkvdec->m2m_dev);
 965                 rkvdec_job_finish(ctx, state);
 966         }
 967
 968         return IRQ_HANDLED;
 969 }
 970
 971 static void rkvdec_watchdog_func(struct work_struct *work)
 972 {
 973         struct rkvdec_dev *rkvdec;
 974         struct rkvdec_ctx *ctx;
 975
 976         rkvdec = container_of(to_delayed_work(work), struct rkvdec_dev,
 977                               watchdog_work);
 978         ctx = v4l2_m2m_get_curr_priv(rkvdec->m2m_dev);
 979         if (ctx) {
 980                 dev_err(rkvdec->dev, "Frame processing timed out!\n");
 981                 writel(RKVDEC_IRQ_DIS, rkvdec->regs + RKVDEC_REG_INTERRUPT);
 982                 writel(0, rkvdec->regs + RKVDEC_REG_SYSCTRL);
 983                 rkvdec_job_finish(ctx, VB2_BUF_STATE_ERROR);
 984         }
 985 }
 986
 987 static const struct of_device_id of_rkvdec_match[] = {
 988         { .compatible = "rockchip,rk3399-vdec" },
 989         { /* sentinel */ }
 990 };
 991 MODULE_DEVICE_TABLE(of, of_rkvdec_match);
 992
 993 static const char * const rkvdec_clk_names[] = {
 994         "axi", "ahb", "cabac", "core"
 995 };
 996
 997 static int rkvdec_probe(struct platform_device *pdev)
 998 {
 999         struct rkvdec_dev *rkvdec;
1000         unsigned int i;
1001         int ret, irq;
1002
1003         rkvdec = devm_kzalloc(&pdev->dev, sizeof(*rkvdec), GFP_KERNEL);
1004         if (!rkvdec)
1005                 return -ENOMEM;
1006
1007         platform_set_drvdata(pdev, rkvdec);
1008         rkvdec->dev = &pdev->dev;
1009         mutex_init(&rkvdec->vdev_lock);
1010         INIT_DELAYED_WORK(&rkvdec->watchdog_work, rkvdec_watchdog_func);
1011
1012         rkvdec->clocks = devm_kcalloc(&pdev->dev, ARRAY_SIZE(rkvdec_clk_names),
1013                                       sizeof(*rkvdec->clocks), GFP_KERNEL);
1014         if (!rkvdec->clocks)
1015                 return -ENOMEM;
1016
1017         for (i = 0; i < ARRAY_SIZE(rkvdec_clk_names); i++)
1018                 rkvdec->clocks[i].id = rkvdec_clk_names[i];
1019
1020         ret = devm_clk_bulk_get(&pdev->dev, ARRAY_SIZE(rkvdec_clk_names),
1021                                 rkvdec->clocks);
1022         if (ret)
1023                 return ret;
1024
1025         rkvdec->regs = devm_platform_ioremap_resource(pdev, 0);
1026         if (IS_ERR(rkvdec->regs))
1027                 return PTR_ERR(rkvdec->regs);
1028
1029         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
1030         if (ret) {
1031                 dev_err(&pdev->dev, "Could not set DMA coherent mask.\n");
1032                 return ret;
1033         }
1034
1035         vb2_dma_contig_set_max_seg_size(&pdev->dev, DMA_BIT_MASK(32));
1036
1037         irq = platform_get_irq(pdev, 0);
1038         if (irq <= 0)
1039                 return -ENXIO;
1040
1041         ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1042                                         rkvdec_irq_handler, IRQF_ONESHOT,
1043                                         dev_name(&pdev->dev), rkvdec);
1044         if (ret) {
1045                 dev_err(&pdev->dev, "Could not request vdec IRQ\n");
1046                 return ret;
1047         }
1048
1049         pm_runtime_set_autosuspend_delay(&pdev->dev, 100);
1050         pm_runtime_use_autosuspend(&pdev->dev);
1051         pm_runtime_enable(&pdev->dev);
1052
1053         ret = rkvdec_v4l2_init(rkvdec);
1054         if (ret)
1055                 goto err_disable_runtime_pm;
1056
1057         return 0;
1058
1059 err_disable_runtime_pm:
1060         pm_runtime_dont_use_autosuspend(&pdev->dev);
1061         pm_runtime_disable(&pdev->dev);
1062         return ret;
1063 }
1064
1065 static int rkvdec_remove(struct platform_device *pdev)
1066 {
1067         struct rkvdec_dev *rkvdec = platform_get_drvdata(pdev);
1068
1069         rkvdec_v4l2_cleanup(rkvdec);
1070         pm_runtime_disable(&pdev->dev);
1071         pm_runtime_dont_use_autosuspend(&pdev->dev);
1072         return 0;
1073 }
1074
1075 #ifdef CONFIG_PM
1076 static int rkvdec_runtime_resume(struct device *dev)
1077 {
1078         struct rkvdec_dev *rkvdec = dev_get_drvdata(dev);
1079
1080         return clk_bulk_prepare_enable(ARRAY_SIZE(rkvdec_clk_names),
1081                                        rkvdec->clocks);
1082 }
1083
1084 static int rkvdec_runtime_suspend(struct device *dev)
1085 {
1086         struct rkvdec_dev *rkvdec = dev_get_drvdata(dev);
1087
1088         clk_bulk_disable_unprepare(ARRAY_SIZE(rkvdec_clk_names),
1089                                    rkvdec->clocks);
1090         return 0;
1091 }
1092 #endif
1093
1094 static const struct dev_pm_ops rkvdec_pm_ops = {
1095         SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1096                                 pm_runtime_force_resume)
1097         SET_RUNTIME_PM_OPS(rkvdec_runtime_suspend, rkvdec_runtime_resume, NULL)
1098 };
1099
1100 static struct platform_driver rkvdec_driver = {
1101         .probe = rkvdec_probe,
1102         .remove = rkvdec_remove,
1103         .driver = {
1104                    .name = "rkvdec",
1105                    .of_match_table = of_rkvdec_match,
1106                    .pm = &rkvdec_pm_ops,
1107         },
1108 };
1109 module_platform_driver(rkvdec_driver);
1110
1111 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@collabora.com>");
1112 MODULE_DESCRIPTION("Rockchip Video Decoder driver");
1113 MODULE_LICENSE("GPL v2");