2 * linux/drivers/media/platform/s5p-mfc/s5p_mfc_dec.c
4 * Copyright (C) 2011 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
6 * Kamil Debski, <k.debski@samsung.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 #include <linux/clk.h>
15 #include <linux/interrupt.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/sched.h>
20 #include <linux/slab.h>
21 #include <linux/version.h>
22 #include <linux/videodev2.h>
23 #include <linux/workqueue.h>
24 #include <media/v4l2-ctrls.h>
25 #include <media/v4l2-event.h>
26 #include <media/videobuf2-core.h>
27 #include "s5p_mfc_common.h"
28 #include "s5p_mfc_debug.h"
29 #include "s5p_mfc_dec.h"
30 #include "s5p_mfc_intr.h"
31 #include "s5p_mfc_opr.h"
32 #include "s5p_mfc_pm.h"
34 #define DEF_SRC_FMT_DEC V4L2_PIX_FMT_H264
35 #define DEF_DST_FMT_DEC V4L2_PIX_FMT_NV12MT_16X16
37 static struct s5p_mfc_fmt formats
[] = {
39 .name
= "4:2:0 2 Planes 16x16 Tiles",
40 .fourcc
= V4L2_PIX_FMT_NV12MT_16X16
,
41 .codec_mode
= S5P_MFC_CODEC_NONE
,
46 .name
= "4:2:0 2 Planes 64x32 Tiles",
47 .fourcc
= V4L2_PIX_FMT_NV12MT
,
48 .codec_mode
= S5P_MFC_CODEC_NONE
,
53 .name
= "4:2:0 2 Planes Y/CbCr",
54 .fourcc
= V4L2_PIX_FMT_NV12M
,
55 .codec_mode
= S5P_MFC_CODEC_NONE
,
60 .name
= "4:2:0 2 Planes Y/CrCb",
61 .fourcc
= V4L2_PIX_FMT_NV21M
,
62 .codec_mode
= S5P_MFC_CODEC_NONE
,
67 .name
= "H264 Encoded Stream",
68 .fourcc
= V4L2_PIX_FMT_H264
,
69 .codec_mode
= S5P_MFC_CODEC_H264_DEC
,
74 .name
= "H264/MVC Encoded Stream",
75 .fourcc
= V4L2_PIX_FMT_H264_MVC
,
76 .codec_mode
= S5P_MFC_CODEC_H264_MVC_DEC
,
81 .name
= "H263 Encoded Stream",
82 .fourcc
= V4L2_PIX_FMT_H263
,
83 .codec_mode
= S5P_MFC_CODEC_H263_DEC
,
88 .name
= "MPEG1 Encoded Stream",
89 .fourcc
= V4L2_PIX_FMT_MPEG1
,
90 .codec_mode
= S5P_MFC_CODEC_MPEG2_DEC
,
95 .name
= "MPEG2 Encoded Stream",
96 .fourcc
= V4L2_PIX_FMT_MPEG2
,
97 .codec_mode
= S5P_MFC_CODEC_MPEG2_DEC
,
102 .name
= "MPEG4 Encoded Stream",
103 .fourcc
= V4L2_PIX_FMT_MPEG4
,
104 .codec_mode
= S5P_MFC_CODEC_MPEG4_DEC
,
109 .name
= "XviD Encoded Stream",
110 .fourcc
= V4L2_PIX_FMT_XVID
,
111 .codec_mode
= S5P_MFC_CODEC_MPEG4_DEC
,
116 .name
= "VC1 Encoded Stream",
117 .fourcc
= V4L2_PIX_FMT_VC1_ANNEX_G
,
118 .codec_mode
= S5P_MFC_CODEC_VC1_DEC
,
123 .name
= "VC1 RCV Encoded Stream",
124 .fourcc
= V4L2_PIX_FMT_VC1_ANNEX_L
,
125 .codec_mode
= S5P_MFC_CODEC_VC1RCV_DEC
,
130 .name
= "VP8 Encoded Stream",
131 .fourcc
= V4L2_PIX_FMT_VP8
,
132 .codec_mode
= S5P_MFC_CODEC_VP8_DEC
,
138 #define NUM_FORMATS ARRAY_SIZE(formats)
140 /* Find selected format description */
141 static struct s5p_mfc_fmt
*find_format(struct v4l2_format
*f
, unsigned int t
)
145 for (i
= 0; i
< NUM_FORMATS
; i
++) {
146 if (formats
[i
].fourcc
== f
->fmt
.pix_mp
.pixelformat
&&
147 formats
[i
].type
== t
)
153 static struct mfc_control controls
[] = {
155 .id
= V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY
,
156 .type
= V4L2_CTRL_TYPE_INTEGER
,
157 .name
= "H264 Display Delay",
164 .id
= V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE
,
165 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
166 .name
= "H264 Display Delay Enable",
173 .id
= V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER
,
174 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
175 .name
= "Mpeg4 Loop Filter Enable",
182 .id
= V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE
,
183 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
184 .name
= "Slice Interface Enable",
191 .id
= V4L2_CID_MIN_BUFFERS_FOR_CAPTURE
,
192 .type
= V4L2_CTRL_TYPE_INTEGER
,
193 .name
= "Minimum number of cap bufs",
202 #define NUM_CTRLS ARRAY_SIZE(controls)
204 /* Check whether a context should be run on hardware */
205 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx
*ctx
)
207 /* Context is to parse header */
208 if (ctx
->src_queue_cnt
>= 1 && ctx
->state
== MFCINST_GOT_INST
)
210 /* Context is to decode a frame */
211 if (ctx
->src_queue_cnt
>= 1 &&
212 ctx
->state
== MFCINST_RUNNING
&&
213 ctx
->dst_queue_cnt
>= ctx
->pb_count
)
215 /* Context is to return last frame */
216 if (ctx
->state
== MFCINST_FINISHING
&&
217 ctx
->dst_queue_cnt
>= ctx
->pb_count
)
219 /* Context is to set buffers */
220 if (ctx
->src_queue_cnt
>= 1 &&
221 ctx
->state
== MFCINST_HEAD_PARSED
&&
222 ctx
->capture_state
== QUEUE_BUFS_MMAPED
)
224 /* Resolution change */
225 if ((ctx
->state
== MFCINST_RES_CHANGE_INIT
||
226 ctx
->state
== MFCINST_RES_CHANGE_FLUSH
) &&
227 ctx
->dst_queue_cnt
>= ctx
->pb_count
)
229 if (ctx
->state
== MFCINST_RES_CHANGE_END
&&
230 ctx
->src_queue_cnt
>= 1)
232 mfc_debug(2, "ctx is not ready\n");
236 static struct s5p_mfc_codec_ops decoder_codec_ops
= {
237 .pre_seq_start
= NULL
,
238 .post_seq_start
= NULL
,
239 .pre_frame_start
= NULL
,
240 .post_frame_start
= NULL
,
243 /* Query capabilities of the device */
244 static int vidioc_querycap(struct file
*file
, void *priv
,
245 struct v4l2_capability
*cap
)
247 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
249 strncpy(cap
->driver
, dev
->plat_dev
->name
, sizeof(cap
->driver
) - 1);
250 strncpy(cap
->card
, dev
->plat_dev
->name
, sizeof(cap
->card
) - 1);
251 cap
->bus_info
[0] = 0;
252 cap
->version
= KERNEL_VERSION(1, 0, 0);
254 * This is only a mem-to-mem video device. The capture and output
255 * device capability flags are left only for backward compatibility
256 * and are scheduled for removal.
258 cap
->capabilities
= V4L2_CAP_VIDEO_M2M_MPLANE
| V4L2_CAP_STREAMING
|
259 V4L2_CAP_VIDEO_CAPTURE_MPLANE
|
260 V4L2_CAP_VIDEO_OUTPUT_MPLANE
;
264 /* Enumerate format */
265 static int vidioc_enum_fmt(struct v4l2_fmtdesc
*f
, bool mplane
, bool out
)
267 struct s5p_mfc_fmt
*fmt
;
270 for (i
= 0; i
< ARRAY_SIZE(formats
); ++i
) {
271 if (mplane
&& formats
[i
].num_planes
== 1)
273 else if (!mplane
&& formats
[i
].num_planes
> 1)
275 if (out
&& formats
[i
].type
!= MFC_FMT_DEC
)
277 else if (!out
&& formats
[i
].type
!= MFC_FMT_RAW
)
284 if (i
== ARRAY_SIZE(formats
))
287 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
288 f
->pixelformat
= fmt
->fourcc
;
292 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *pirv
,
293 struct v4l2_fmtdesc
*f
)
295 return vidioc_enum_fmt(f
, false, false);
298 static int vidioc_enum_fmt_vid_cap_mplane(struct file
*file
, void *pirv
,
299 struct v4l2_fmtdesc
*f
)
301 return vidioc_enum_fmt(f
, true, false);
304 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *prov
,
305 struct v4l2_fmtdesc
*f
)
307 return vidioc_enum_fmt(f
, false, true);
310 static int vidioc_enum_fmt_vid_out_mplane(struct file
*file
, void *prov
,
311 struct v4l2_fmtdesc
*f
)
313 return vidioc_enum_fmt(f
, true, true);
317 static int vidioc_g_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
319 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
320 struct v4l2_pix_format_mplane
*pix_mp
;
323 pix_mp
= &f
->fmt
.pix_mp
;
324 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
&&
325 (ctx
->state
== MFCINST_GOT_INST
|| ctx
->state
==
326 MFCINST_RES_CHANGE_END
)) {
327 /* If the MFC is parsing the header,
328 * so wait until it is finished */
329 s5p_mfc_clean_ctx_int_flags(ctx
);
330 s5p_mfc_wait_for_done_ctx(ctx
, S5P_MFC_R2H_CMD_SEQ_DONE_RET
,
333 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
&&
334 ctx
->state
>= MFCINST_HEAD_PARSED
&&
335 ctx
->state
< MFCINST_ABORT
) {
336 /* This is run on CAPTURE (decode output) */
337 /* Width and height are set to the dimensions
338 of the movie, the buffer is bigger and
339 further processing stages should crop to this
341 pix_mp
->width
= ctx
->buf_width
;
342 pix_mp
->height
= ctx
->buf_height
;
343 pix_mp
->field
= V4L2_FIELD_NONE
;
344 pix_mp
->num_planes
= 2;
345 /* Set pixelformat to the format in which MFC
346 outputs the decoded frame */
347 pix_mp
->pixelformat
= ctx
->dst_fmt
->fourcc
;
348 pix_mp
->plane_fmt
[0].bytesperline
= ctx
->buf_width
;
349 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->luma_size
;
350 pix_mp
->plane_fmt
[1].bytesperline
= ctx
->buf_width
;
351 pix_mp
->plane_fmt
[1].sizeimage
= ctx
->chroma_size
;
352 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
353 /* This is run on OUTPUT
354 The buffer contains compressed image
355 so width and height have no meaning */
358 pix_mp
->field
= V4L2_FIELD_NONE
;
359 pix_mp
->plane_fmt
[0].bytesperline
= ctx
->dec_src_buf_size
;
360 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->dec_src_buf_size
;
361 pix_mp
->pixelformat
= ctx
->src_fmt
->fourcc
;
362 pix_mp
->num_planes
= ctx
->src_fmt
->num_planes
;
364 mfc_err("Format could not be read\n");
365 mfc_debug(2, "%s-- with error\n", __func__
);
373 static int vidioc_try_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
375 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
376 struct s5p_mfc_fmt
*fmt
;
378 mfc_debug(2, "Type is %d\n", f
->type
);
379 if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
380 fmt
= find_format(f
, MFC_FMT_DEC
);
382 mfc_err("Unsupported format for source.\n");
385 if (fmt
->codec_mode
== S5P_FIMV_CODEC_NONE
) {
386 mfc_err("Unknown codec\n");
389 if (!IS_MFCV6(dev
)) {
390 if (fmt
->fourcc
== V4L2_PIX_FMT_VP8
) {
391 mfc_err("Not supported format.\n");
395 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
396 fmt
= find_format(f
, MFC_FMT_RAW
);
398 mfc_err("Unsupported format for destination.\n");
401 if (IS_MFCV6(dev
) && (fmt
->fourcc
== V4L2_PIX_FMT_NV12MT
)) {
402 mfc_err("Not supported format.\n");
404 } else if (!IS_MFCV6(dev
) &&
405 (fmt
->fourcc
!= V4L2_PIX_FMT_NV12MT
)) {
406 mfc_err("Not supported format.\n");
415 static int vidioc_s_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
417 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
418 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
420 struct v4l2_pix_format_mplane
*pix_mp
;
423 ret
= vidioc_try_fmt(file
, priv
, f
);
424 pix_mp
= &f
->fmt
.pix_mp
;
427 if (ctx
->vq_src
.streaming
|| ctx
->vq_dst
.streaming
) {
428 v4l2_err(&dev
->v4l2_dev
, "%s queue busy\n", __func__
);
432 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
433 /* dst_fmt is validated by call to vidioc_try_fmt */
434 ctx
->dst_fmt
= find_format(f
, MFC_FMT_RAW
);
437 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
438 /* src_fmt is validated by call to vidioc_try_fmt */
439 ctx
->src_fmt
= find_format(f
, MFC_FMT_DEC
);
440 ctx
->codec_mode
= ctx
->src_fmt
->codec_mode
;
441 mfc_debug(2, "The codec number is: %d\n", ctx
->codec_mode
);
444 if (pix_mp
->plane_fmt
[0].sizeimage
)
445 ctx
->dec_src_buf_size
= pix_mp
->plane_fmt
[0].sizeimage
;
447 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->dec_src_buf_size
=
449 pix_mp
->plane_fmt
[0].bytesperline
= 0;
450 ctx
->state
= MFCINST_INIT
;
454 mfc_err("Wrong type error for S_FMT : %d", f
->type
);
464 /* Reqeust buffers */
465 static int vidioc_reqbufs(struct file
*file
, void *priv
,
466 struct v4l2_requestbuffers
*reqbufs
)
468 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
469 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
472 if (reqbufs
->memory
!= V4L2_MEMORY_MMAP
) {
473 mfc_err("Only V4L2_MEMORY_MAP is supported\n");
476 if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
477 /* Can only request buffers after an instance has been opened.*/
478 if (ctx
->state
== MFCINST_INIT
) {
479 ctx
->src_bufs_cnt
= 0;
480 if (reqbufs
->count
== 0) {
481 mfc_debug(2, "Freeing buffers\n");
483 ret
= vb2_reqbufs(&ctx
->vq_src
, reqbufs
);
488 if (ctx
->output_state
!= QUEUE_FREE
) {
489 mfc_err("Bufs have already been requested\n");
493 ret
= vb2_reqbufs(&ctx
->vq_src
, reqbufs
);
496 mfc_err("vb2_reqbufs on output failed\n");
499 mfc_debug(2, "vb2_reqbufs: %d\n", ret
);
500 ctx
->output_state
= QUEUE_BUFS_REQUESTED
;
502 } else if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
503 ctx
->dst_bufs_cnt
= 0;
504 if (reqbufs
->count
== 0) {
505 mfc_debug(2, "Freeing buffers\n");
507 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
511 if (ctx
->capture_state
!= QUEUE_FREE
) {
512 mfc_err("Bufs have already been requested\n");
515 ctx
->capture_state
= QUEUE_BUFS_REQUESTED
;
517 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
520 mfc_err("vb2_reqbufs on capture failed\n");
523 if (reqbufs
->count
< ctx
->pb_count
) {
524 mfc_err("Not enough buffers allocated\n");
527 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
531 ctx
->total_dpb_count
= reqbufs
->count
;
532 ret
= s5p_mfc_hw_call(dev
->mfc_ops
, alloc_codec_buffers
, ctx
);
534 mfc_err("Failed to allocate decoding buffers\n");
537 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
541 if (ctx
->dst_bufs_cnt
== ctx
->total_dpb_count
) {
542 ctx
->capture_state
= QUEUE_BUFS_MMAPED
;
544 mfc_err("Not all buffers passed to buf_init\n");
547 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
548 s5p_mfc_hw_call(dev
->mfc_ops
, release_codec_buffers
,
553 if (s5p_mfc_ctx_ready(ctx
))
554 set_work_bit_irqsave(ctx
);
555 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
556 s5p_mfc_wait_for_done_ctx(ctx
,
557 S5P_MFC_R2H_CMD_INIT_BUFFERS_RET
, 0);
563 static int vidioc_querybuf(struct file
*file
, void *priv
,
564 struct v4l2_buffer
*buf
)
566 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
570 if (buf
->memory
!= V4L2_MEMORY_MMAP
) {
571 mfc_err("Only mmaped buffers can be used\n");
574 mfc_debug(2, "State: %d, buf->type: %d\n", ctx
->state
, buf
->type
);
575 if (ctx
->state
== MFCINST_INIT
&&
576 buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
577 ret
= vb2_querybuf(&ctx
->vq_src
, buf
);
578 } else if (ctx
->state
== MFCINST_RUNNING
&&
579 buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
580 ret
= vb2_querybuf(&ctx
->vq_dst
, buf
);
581 for (i
= 0; i
< buf
->length
; i
++)
582 buf
->m
.planes
[i
].m
.mem_offset
+= DST_QUEUE_OFF_BASE
;
584 mfc_err("vidioc_querybuf called in an inappropriate state\n");
592 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
594 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
596 if (ctx
->state
== MFCINST_ERROR
) {
597 mfc_err("Call on QBUF after unrecoverable error\n");
600 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
601 return vb2_qbuf(&ctx
->vq_src
, buf
);
602 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
603 return vb2_qbuf(&ctx
->vq_dst
, buf
);
607 /* Dequeue a buffer */
608 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
610 const struct v4l2_event ev
= {
611 .type
= V4L2_EVENT_EOS
613 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
616 if (ctx
->state
== MFCINST_ERROR
) {
617 mfc_err("Call on DQBUF after unrecoverable error\n");
620 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
621 ret
= vb2_dqbuf(&ctx
->vq_src
, buf
, file
->f_flags
& O_NONBLOCK
);
622 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
623 ret
= vb2_dqbuf(&ctx
->vq_dst
, buf
, file
->f_flags
& O_NONBLOCK
);
624 if (ret
== 0 && ctx
->state
== MFCINST_FINISHED
&&
625 list_empty(&ctx
->vq_dst
.done_list
))
626 v4l2_event_queue_fh(&ctx
->fh
, &ev
);
633 /* Export DMA buffer */
634 static int vidioc_expbuf(struct file
*file
, void *priv
,
635 struct v4l2_exportbuffer
*eb
)
637 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
639 if (eb
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
640 return vb2_expbuf(&ctx
->vq_src
, eb
);
641 if (eb
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
642 return vb2_expbuf(&ctx
->vq_dst
, eb
);
647 static int vidioc_streamon(struct file
*file
, void *priv
,
648 enum v4l2_buf_type type
)
650 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
651 struct s5p_mfc_dev
*dev
= ctx
->dev
;
655 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
657 if (ctx
->state
== MFCINST_INIT
) {
658 ctx
->dst_bufs_cnt
= 0;
659 ctx
->src_bufs_cnt
= 0;
660 ctx
->capture_state
= QUEUE_FREE
;
661 ctx
->output_state
= QUEUE_FREE
;
662 s5p_mfc_hw_call(dev
->mfc_ops
, alloc_instance_buffer
,
664 s5p_mfc_hw_call(dev
->mfc_ops
, alloc_dec_temp_buffers
,
666 set_work_bit_irqsave(ctx
);
667 s5p_mfc_clean_ctx_int_flags(ctx
);
668 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
670 if (s5p_mfc_wait_for_done_ctx(ctx
,
671 S5P_MFC_R2H_CMD_OPEN_INSTANCE_RET
, 0)) {
672 /* Error or timeout */
673 mfc_err("Error getting instance from hardware\n");
674 s5p_mfc_hw_call(dev
->mfc_ops
,
675 release_instance_buffer
, ctx
);
676 s5p_mfc_hw_call(dev
->mfc_ops
,
677 release_dec_desc_buffer
, ctx
);
680 mfc_debug(2, "Got instance number: %d\n", ctx
->inst_no
);
682 ret
= vb2_streamon(&ctx
->vq_src
, type
);
684 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
685 ret
= vb2_streamon(&ctx
->vq_dst
, type
);
690 /* Stream off, which equals to a pause */
691 static int vidioc_streamoff(struct file
*file
, void *priv
,
692 enum v4l2_buf_type type
)
694 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
696 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
697 return vb2_streamoff(&ctx
->vq_src
, type
);
698 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
699 return vb2_streamoff(&ctx
->vq_dst
, type
);
703 /* Set controls - v4l2 control framework */
704 static int s5p_mfc_dec_s_ctrl(struct v4l2_ctrl
*ctrl
)
706 struct s5p_mfc_ctx
*ctx
= ctrl_to_ctx(ctrl
);
709 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY
:
710 ctx
->display_delay
= ctrl
->val
;
712 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE
:
713 ctx
->display_delay_enable
= ctrl
->val
;
715 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER
:
716 ctx
->loop_filter_mpeg4
= ctrl
->val
;
718 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE
:
719 ctx
->slice_interface
= ctrl
->val
;
722 mfc_err("Invalid control 0x%08x\n", ctrl
->id
);
728 static int s5p_mfc_dec_g_v_ctrl(struct v4l2_ctrl
*ctrl
)
730 struct s5p_mfc_ctx
*ctx
= ctrl_to_ctx(ctrl
);
731 struct s5p_mfc_dev
*dev
= ctx
->dev
;
734 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE
:
735 if (ctx
->state
>= MFCINST_HEAD_PARSED
&&
736 ctx
->state
< MFCINST_ABORT
) {
737 ctrl
->val
= ctx
->pb_count
;
739 } else if (ctx
->state
!= MFCINST_INIT
) {
740 v4l2_err(&dev
->v4l2_dev
, "Decoding not initialised\n");
743 /* Should wait for the header to be parsed */
744 s5p_mfc_clean_ctx_int_flags(ctx
);
745 s5p_mfc_wait_for_done_ctx(ctx
,
746 S5P_MFC_R2H_CMD_SEQ_DONE_RET
, 0);
747 if (ctx
->state
>= MFCINST_HEAD_PARSED
&&
748 ctx
->state
< MFCINST_ABORT
) {
749 ctrl
->val
= ctx
->pb_count
;
751 v4l2_err(&dev
->v4l2_dev
, "Decoding not initialised\n");
760 static const struct v4l2_ctrl_ops s5p_mfc_dec_ctrl_ops
= {
761 .s_ctrl
= s5p_mfc_dec_s_ctrl
,
762 .g_volatile_ctrl
= s5p_mfc_dec_g_v_ctrl
,
765 /* Get cropping information */
766 static int vidioc_g_crop(struct file
*file
, void *priv
,
767 struct v4l2_crop
*cr
)
769 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
770 struct s5p_mfc_dev
*dev
= ctx
->dev
;
771 u32 left
, right
, top
, bottom
;
773 if (ctx
->state
!= MFCINST_HEAD_PARSED
&&
774 ctx
->state
!= MFCINST_RUNNING
&& ctx
->state
!= MFCINST_FINISHING
775 && ctx
->state
!= MFCINST_FINISHED
) {
776 mfc_err("Cannont set crop\n");
779 if (ctx
->src_fmt
->fourcc
== V4L2_PIX_FMT_H264
) {
780 left
= s5p_mfc_hw_call(dev
->mfc_ops
, get_crop_info_h
, ctx
);
781 right
= left
>> S5P_FIMV_SHARED_CROP_RIGHT_SHIFT
;
782 left
= left
& S5P_FIMV_SHARED_CROP_LEFT_MASK
;
783 top
= s5p_mfc_hw_call(dev
->mfc_ops
, get_crop_info_v
, ctx
);
784 bottom
= top
>> S5P_FIMV_SHARED_CROP_BOTTOM_SHIFT
;
785 top
= top
& S5P_FIMV_SHARED_CROP_TOP_MASK
;
788 cr
->c
.width
= ctx
->img_width
- left
- right
;
789 cr
->c
.height
= ctx
->img_height
- top
- bottom
;
790 mfc_debug(2, "Cropping info [h264]: l=%d t=%d "
791 "w=%d h=%d (r=%d b=%d fw=%d fh=%d\n", left
, top
,
792 cr
->c
.width
, cr
->c
.height
, right
, bottom
,
793 ctx
->buf_width
, ctx
->buf_height
);
797 cr
->c
.width
= ctx
->img_width
;
798 cr
->c
.height
= ctx
->img_height
;
799 mfc_debug(2, "Cropping info: w=%d h=%d fw=%d "
800 "fh=%d\n", cr
->c
.width
, cr
->c
.height
, ctx
->buf_width
,
806 int vidioc_decoder_cmd(struct file
*file
, void *priv
,
807 struct v4l2_decoder_cmd
*cmd
)
809 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
810 struct s5p_mfc_dev
*dev
= ctx
->dev
;
811 struct s5p_mfc_buf
*buf
;
815 case V4L2_ENC_CMD_STOP
:
819 if (!ctx
->vq_src
.streaming
)
822 spin_lock_irqsave(&dev
->irqlock
, flags
);
823 if (list_empty(&ctx
->src_queue
)) {
824 mfc_err("EOS: empty src queue, entering finishing state");
825 ctx
->state
= MFCINST_FINISHING
;
826 if (s5p_mfc_ctx_ready(ctx
))
827 set_work_bit_irqsave(ctx
);
828 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
829 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
831 mfc_err("EOS: marking last buffer of stream");
832 buf
= list_entry(ctx
->src_queue
.prev
,
833 struct s5p_mfc_buf
, list
);
834 if (buf
->flags
& MFC_BUF_FLAG_USED
)
835 ctx
->state
= MFCINST_FINISHING
;
837 buf
->flags
|= MFC_BUF_FLAG_EOS
;
838 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
847 static int vidioc_subscribe_event(struct v4l2_fh
*fh
,
848 const struct v4l2_event_subscription
*sub
)
852 return v4l2_event_subscribe(fh
, sub
, 2, NULL
);
860 static const struct v4l2_ioctl_ops s5p_mfc_dec_ioctl_ops
= {
861 .vidioc_querycap
= vidioc_querycap
,
862 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
863 .vidioc_enum_fmt_vid_cap_mplane
= vidioc_enum_fmt_vid_cap_mplane
,
864 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
865 .vidioc_enum_fmt_vid_out_mplane
= vidioc_enum_fmt_vid_out_mplane
,
866 .vidioc_g_fmt_vid_cap_mplane
= vidioc_g_fmt
,
867 .vidioc_g_fmt_vid_out_mplane
= vidioc_g_fmt
,
868 .vidioc_try_fmt_vid_cap_mplane
= vidioc_try_fmt
,
869 .vidioc_try_fmt_vid_out_mplane
= vidioc_try_fmt
,
870 .vidioc_s_fmt_vid_cap_mplane
= vidioc_s_fmt
,
871 .vidioc_s_fmt_vid_out_mplane
= vidioc_s_fmt
,
872 .vidioc_reqbufs
= vidioc_reqbufs
,
873 .vidioc_querybuf
= vidioc_querybuf
,
874 .vidioc_qbuf
= vidioc_qbuf
,
875 .vidioc_dqbuf
= vidioc_dqbuf
,
876 .vidioc_expbuf
= vidioc_expbuf
,
877 .vidioc_streamon
= vidioc_streamon
,
878 .vidioc_streamoff
= vidioc_streamoff
,
879 .vidioc_g_crop
= vidioc_g_crop
,
880 .vidioc_decoder_cmd
= vidioc_decoder_cmd
,
881 .vidioc_subscribe_event
= vidioc_subscribe_event
,
882 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
885 static int s5p_mfc_queue_setup(struct vb2_queue
*vq
,
886 const struct v4l2_format
*fmt
, unsigned int *buf_count
,
887 unsigned int *plane_count
, unsigned int psize
[],
890 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
891 struct s5p_mfc_dev
*dev
= ctx
->dev
;
893 /* Video output for decoding (source)
894 * this can be set after getting an instance */
895 if (ctx
->state
== MFCINST_INIT
&&
896 vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
897 /* A single plane is required for input */
901 if (*buf_count
> MFC_MAX_BUFFERS
)
902 *buf_count
= MFC_MAX_BUFFERS
;
903 /* Video capture for decoding (destination)
904 * this can be set after the header was parsed */
905 } else if (ctx
->state
== MFCINST_HEAD_PARSED
&&
906 vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
907 /* Output plane count is 2 - one for Y and one for CbCr */
909 /* Setup buffer count */
910 if (*buf_count
< ctx
->pb_count
)
911 *buf_count
= ctx
->pb_count
;
912 if (*buf_count
> ctx
->pb_count
+ MFC_MAX_EXTRA_DPB
)
913 *buf_count
= ctx
->pb_count
+ MFC_MAX_EXTRA_DPB
;
914 if (*buf_count
> MFC_MAX_BUFFERS
)
915 *buf_count
= MFC_MAX_BUFFERS
;
917 mfc_err("State seems invalid. State = %d, vq->type = %d\n",
918 ctx
->state
, vq
->type
);
921 mfc_debug(2, "Buffer count=%d, plane count=%d\n",
922 *buf_count
, *plane_count
);
923 if (ctx
->state
== MFCINST_HEAD_PARSED
&&
924 vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
925 psize
[0] = ctx
->luma_size
;
926 psize
[1] = ctx
->chroma_size
;
930 ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
933 ctx
->dev
->alloc_ctx
[MFC_BANK2_ALLOC_CTX
];
934 allocators
[1] = ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
935 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
&&
936 ctx
->state
== MFCINST_INIT
) {
937 psize
[0] = ctx
->dec_src_buf_size
;
938 allocators
[0] = ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
940 mfc_err("This video node is dedicated to decoding. Decoding not initialized\n");
946 static void s5p_mfc_unlock(struct vb2_queue
*q
)
948 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
949 struct s5p_mfc_dev
*dev
= ctx
->dev
;
951 mutex_unlock(&dev
->mfc_mutex
);
954 static void s5p_mfc_lock(struct vb2_queue
*q
)
956 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
957 struct s5p_mfc_dev
*dev
= ctx
->dev
;
959 mutex_lock(&dev
->mfc_mutex
);
962 static int s5p_mfc_buf_init(struct vb2_buffer
*vb
)
964 struct vb2_queue
*vq
= vb
->vb2_queue
;
965 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
968 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
969 if (ctx
->capture_state
== QUEUE_BUFS_MMAPED
)
971 for (i
= 0; i
<= ctx
->src_fmt
->num_planes
; i
++) {
972 if (IS_ERR_OR_NULL(ERR_PTR(
973 vb2_dma_contig_plane_dma_addr(vb
, i
)))) {
974 mfc_err("Plane mem not allocated\n");
978 if (vb2_plane_size(vb
, 0) < ctx
->luma_size
||
979 vb2_plane_size(vb
, 1) < ctx
->chroma_size
) {
980 mfc_err("Plane buffer (CAPTURE) is too small\n");
983 i
= vb
->v4l2_buf
.index
;
984 ctx
->dst_bufs
[i
].b
= vb
;
985 ctx
->dst_bufs
[i
].cookie
.raw
.luma
=
986 vb2_dma_contig_plane_dma_addr(vb
, 0);
987 ctx
->dst_bufs
[i
].cookie
.raw
.chroma
=
988 vb2_dma_contig_plane_dma_addr(vb
, 1);
990 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
991 if (IS_ERR_OR_NULL(ERR_PTR(
992 vb2_dma_contig_plane_dma_addr(vb
, 0)))) {
993 mfc_err("Plane memory not allocated\n");
996 if (vb2_plane_size(vb
, 0) < ctx
->dec_src_buf_size
) {
997 mfc_err("Plane buffer (OUTPUT) is too small\n");
1001 i
= vb
->v4l2_buf
.index
;
1002 ctx
->src_bufs
[i
].b
= vb
;
1003 ctx
->src_bufs
[i
].cookie
.stream
=
1004 vb2_dma_contig_plane_dma_addr(vb
, 0);
1005 ctx
->src_bufs_cnt
++;
1007 mfc_err("s5p_mfc_buf_init: unknown queue type\n");
1013 static int s5p_mfc_start_streaming(struct vb2_queue
*q
, unsigned int count
)
1015 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1016 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1018 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
1019 if (ctx
->state
== MFCINST_FINISHING
||
1020 ctx
->state
== MFCINST_FINISHED
)
1021 ctx
->state
= MFCINST_RUNNING
;
1022 /* If context is ready then dev = work->data;schedule it to run */
1023 if (s5p_mfc_ctx_ready(ctx
))
1024 set_work_bit_irqsave(ctx
);
1025 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
1029 static int s5p_mfc_stop_streaming(struct vb2_queue
*q
)
1031 unsigned long flags
;
1032 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1033 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1036 if ((ctx
->state
== MFCINST_FINISHING
||
1037 ctx
->state
== MFCINST_RUNNING
) &&
1038 dev
->curr_ctx
== ctx
->num
&& dev
->hw_lock
) {
1039 ctx
->state
= MFCINST_ABORT
;
1040 s5p_mfc_wait_for_done_ctx(ctx
,
1041 S5P_MFC_R2H_CMD_FRAME_DONE_RET
, 0);
1044 if (q
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1045 spin_lock_irqsave(&dev
->irqlock
, flags
);
1046 s5p_mfc_hw_call(dev
->mfc_ops
, cleanup_queue
, &ctx
->dst_queue
,
1048 INIT_LIST_HEAD(&ctx
->dst_queue
);
1049 ctx
->dst_queue_cnt
= 0;
1050 ctx
->dpb_flush_flag
= 1;
1051 ctx
->dec_dst_flag
= 0;
1052 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1053 if (IS_MFCV6(dev
) && (ctx
->state
== MFCINST_RUNNING
)) {
1054 ctx
->state
= MFCINST_FLUSH
;
1055 set_work_bit_irqsave(ctx
);
1056 s5p_mfc_clean_ctx_int_flags(ctx
);
1057 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
1058 if (s5p_mfc_wait_for_done_ctx(ctx
,
1059 S5P_MFC_R2H_CMD_DPB_FLUSH_RET
, 0))
1060 mfc_err("Err flushing buffers\n");
1063 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1064 spin_lock_irqsave(&dev
->irqlock
, flags
);
1065 s5p_mfc_hw_call(dev
->mfc_ops
, cleanup_queue
, &ctx
->src_queue
,
1067 INIT_LIST_HEAD(&ctx
->src_queue
);
1068 ctx
->src_queue_cnt
= 0;
1069 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1072 ctx
->state
= MFCINST_RUNNING
;
1077 static void s5p_mfc_buf_queue(struct vb2_buffer
*vb
)
1079 struct vb2_queue
*vq
= vb
->vb2_queue
;
1080 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
1081 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1082 unsigned long flags
;
1083 struct s5p_mfc_buf
*mfc_buf
;
1085 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1086 mfc_buf
= &ctx
->src_bufs
[vb
->v4l2_buf
.index
];
1087 mfc_buf
->flags
&= ~MFC_BUF_FLAG_USED
;
1088 spin_lock_irqsave(&dev
->irqlock
, flags
);
1089 list_add_tail(&mfc_buf
->list
, &ctx
->src_queue
);
1090 ctx
->src_queue_cnt
++;
1091 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1092 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1093 mfc_buf
= &ctx
->dst_bufs
[vb
->v4l2_buf
.index
];
1094 mfc_buf
->flags
&= ~MFC_BUF_FLAG_USED
;
1095 /* Mark destination as available for use by MFC */
1096 spin_lock_irqsave(&dev
->irqlock
, flags
);
1097 set_bit(vb
->v4l2_buf
.index
, &ctx
->dec_dst_flag
);
1098 list_add_tail(&mfc_buf
->list
, &ctx
->dst_queue
);
1099 ctx
->dst_queue_cnt
++;
1100 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1102 mfc_err("Unsupported buffer type (%d)\n", vq
->type
);
1104 if (s5p_mfc_ctx_ready(ctx
))
1105 set_work_bit_irqsave(ctx
);
1106 s5p_mfc_hw_call(dev
->mfc_ops
, try_run
, dev
);
1109 static struct vb2_ops s5p_mfc_dec_qops
= {
1110 .queue_setup
= s5p_mfc_queue_setup
,
1111 .wait_prepare
= s5p_mfc_unlock
,
1112 .wait_finish
= s5p_mfc_lock
,
1113 .buf_init
= s5p_mfc_buf_init
,
1114 .start_streaming
= s5p_mfc_start_streaming
,
1115 .stop_streaming
= s5p_mfc_stop_streaming
,
1116 .buf_queue
= s5p_mfc_buf_queue
,
1119 struct s5p_mfc_codec_ops
*get_dec_codec_ops(void)
1121 return &decoder_codec_ops
;
1124 struct vb2_ops
*get_dec_queue_ops(void)
1126 return &s5p_mfc_dec_qops
;
1129 const struct v4l2_ioctl_ops
*get_dec_v4l2_ioctl_ops(void)
1131 return &s5p_mfc_dec_ioctl_ops
;
1134 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
1135 && V4L2_CTRL_DRIVER_PRIV(x))
1137 int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx
*ctx
)
1139 struct v4l2_ctrl_config cfg
;
1142 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, NUM_CTRLS
);
1143 if (ctx
->ctrl_handler
.error
) {
1144 mfc_err("v4l2_ctrl_handler_init failed\n");
1145 return ctx
->ctrl_handler
.error
;
1148 for (i
= 0; i
< NUM_CTRLS
; i
++) {
1149 if (IS_MFC51_PRIV(controls
[i
].id
)) {
1150 memset(&cfg
, 0, sizeof(struct v4l2_ctrl_config
));
1151 cfg
.ops
= &s5p_mfc_dec_ctrl_ops
;
1152 cfg
.id
= controls
[i
].id
;
1153 cfg
.min
= controls
[i
].minimum
;
1154 cfg
.max
= controls
[i
].maximum
;
1155 cfg
.def
= controls
[i
].default_value
;
1156 cfg
.name
= controls
[i
].name
;
1157 cfg
.type
= controls
[i
].type
;
1159 cfg
.step
= controls
[i
].step
;
1160 cfg
.menu_skip_mask
= 0;
1162 ctx
->ctrls
[i
] = v4l2_ctrl_new_custom(&ctx
->ctrl_handler
,
1165 ctx
->ctrls
[i
] = v4l2_ctrl_new_std(&ctx
->ctrl_handler
,
1166 &s5p_mfc_dec_ctrl_ops
,
1167 controls
[i
].id
, controls
[i
].minimum
,
1168 controls
[i
].maximum
, controls
[i
].step
,
1169 controls
[i
].default_value
);
1171 if (ctx
->ctrl_handler
.error
) {
1172 mfc_err("Adding control (%d) failed\n", i
);
1173 return ctx
->ctrl_handler
.error
;
1175 if (controls
[i
].is_volatile
&& ctx
->ctrls
[i
])
1176 ctx
->ctrls
[i
]->flags
|= V4L2_CTRL_FLAG_VOLATILE
;
1181 void s5p_mfc_dec_ctrls_delete(struct s5p_mfc_ctx
*ctx
)
1185 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
1186 for (i
= 0; i
< NUM_CTRLS
; i
++)
1187 ctx
->ctrls
[i
] = NULL
;
1190 void s5p_mfc_dec_init(struct s5p_mfc_ctx
*ctx
)
1192 struct v4l2_format f
;
1193 f
.fmt
.pix_mp
.pixelformat
= DEF_SRC_FMT_DEC
;
1194 ctx
->src_fmt
= find_format(&f
, MFC_FMT_DEC
);
1195 f
.fmt
.pix_mp
.pixelformat
= DEF_DST_FMT_DEC
;
1196 ctx
->dst_fmt
= find_format(&f
, MFC_FMT_RAW
);
1197 mfc_debug(2, "Default src_fmt is %x, dest_fmt is %x\n",
1198 (unsigned int)ctx
->src_fmt
, (unsigned int)ctx
->dst_fmt
);