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 void rkvdec_remove(struct platform_device *pdev) 1066 { 1067 struct rkvdec_dev *rkvdec = platform_get_drvdata(pdev); 1068 1069 cancel_delayed_work_sync(&rkvdec->watchdog_work); 1070 1071 rkvdec_v4l2_cleanup(rkvdec); 1072 pm_runtime_disable(&pdev->dev); 1073 pm_runtime_dont_use_autosuspend(&pdev->dev); 1074 } 1075 1076 #ifdef CONFIG_PM 1077 static int rkvdec_runtime_resume(struct device *dev) 1078 { 1079 struct rkvdec_dev *rkvdec = dev_get_drvdata(dev); 1080 1081 return clk_bulk_prepare_enable(ARRAY_SIZE(rkvdec_clk_names), 1082 rkvdec->clocks); 1083 } 1084 1085 static int rkvdec_runtime_suspend(struct device *dev) 1086 { 1087 struct rkvdec_dev *rkvdec = dev_get_drvdata(dev); 1088 1089 clk_bulk_disable_unprepare(ARRAY_SIZE(rkvdec_clk_names), 1090 rkvdec->clocks); 1091 return 0; 1092 } 1093 #endif 1094 1095 static const struct dev_pm_ops rkvdec_pm_ops = { 1096 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1097 pm_runtime_force_resume) 1098 SET_RUNTIME_PM_OPS(rkvdec_runtime_suspend, rkvdec_runtime_resume, NULL) 1099 }; 1100 1101 static struct platform_driver rkvdec_driver = { 1102 .probe = rkvdec_probe, 1103 .remove_new = rkvdec_remove, 1104 .driver = { 1105 .name = "rkvdec", 1106 .of_match_table = of_rkvdec_match, 1107 .pm = &rkvdec_pm_ops, 1108 }, 1109 }; 1110 module_platform_driver(rkvdec_driver); 1111 1112 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@collabora.com>"); 1113 MODULE_DESCRIPTION("Rockchip Video Decoder driver"); 1114 MODULE_LICENSE("GPL v2"); 1115