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