1
2
3
4
5
6
7
8
9
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
36
37
38
39 if (sps->chroma_format_idc > 1)
40
41 return -EINVAL;
42 if (sps->bit_depth_luma_minus8 != sps->bit_depth_chroma_minus8)
43
44 return -EINVAL;
45 if (sps->bit_depth_luma_minus8 != 0)
46
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
220
221
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
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
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
327
328
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
346
347
348
349
350
351
352
353 rkvdec_reset_decoded_fmt(ctx);
354
355
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
487
488
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
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
700
701
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 { }
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
998
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
