2 * linux/drivers/media/video/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/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"
33 #include "s5p_mfc_shm.h"
35 static struct s5p_mfc_fmt formats
[] = {
37 .name
= "4:2:0 2 Planes 64x32 Tiles",
38 .fourcc
= V4L2_PIX_FMT_NV12MT
,
39 .codec_mode
= S5P_FIMV_CODEC_NONE
,
44 .name
= "4:2:0 2 Planes",
45 .fourcc
= V4L2_PIX_FMT_NV12M
,
46 .codec_mode
= S5P_FIMV_CODEC_NONE
,
51 .name
= "H264 Encoded Stream",
52 .fourcc
= V4L2_PIX_FMT_H264
,
53 .codec_mode
= S5P_FIMV_CODEC_H264_DEC
,
58 .name
= "H263 Encoded Stream",
59 .fourcc
= V4L2_PIX_FMT_H263
,
60 .codec_mode
= S5P_FIMV_CODEC_H263_DEC
,
65 .name
= "MPEG1 Encoded Stream",
66 .fourcc
= V4L2_PIX_FMT_MPEG1
,
67 .codec_mode
= S5P_FIMV_CODEC_MPEG2_DEC
,
72 .name
= "MPEG2 Encoded Stream",
73 .fourcc
= V4L2_PIX_FMT_MPEG2
,
74 .codec_mode
= S5P_FIMV_CODEC_MPEG2_DEC
,
79 .name
= "MPEG4 Encoded Stream",
80 .fourcc
= V4L2_PIX_FMT_MPEG4
,
81 .codec_mode
= S5P_FIMV_CODEC_MPEG4_DEC
,
86 .name
= "XviD Encoded Stream",
87 .fourcc
= V4L2_PIX_FMT_XVID
,
88 .codec_mode
= S5P_FIMV_CODEC_MPEG4_DEC
,
93 .name
= "VC1 Encoded Stream",
94 .fourcc
= V4L2_PIX_FMT_VC1_ANNEX_G
,
95 .codec_mode
= S5P_FIMV_CODEC_VC1_DEC
,
100 .name
= "VC1 RCV Encoded Stream",
101 .fourcc
= V4L2_PIX_FMT_VC1_ANNEX_L
,
102 .codec_mode
= S5P_FIMV_CODEC_VC1RCV_DEC
,
108 #define NUM_FORMATS ARRAY_SIZE(formats)
110 /* Find selected format description */
111 static struct s5p_mfc_fmt
*find_format(struct v4l2_format
*f
, unsigned int t
)
115 for (i
= 0; i
< NUM_FORMATS
; i
++) {
116 if (formats
[i
].fourcc
== f
->fmt
.pix_mp
.pixelformat
&&
117 formats
[i
].type
== t
)
123 static struct mfc_control controls
[] = {
125 .id
= V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY
,
126 .type
= V4L2_CTRL_TYPE_INTEGER
,
127 .name
= "H264 Display Delay",
134 .id
= V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE
,
135 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
136 .name
= "H264 Display Delay Enable",
143 .id
= V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER
,
144 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
145 .name
= "Mpeg4 Loop Filter Enable",
152 .id
= V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE
,
153 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
154 .name
= "Slice Interface Enable",
161 .id
= V4L2_CID_MIN_BUFFERS_FOR_CAPTURE
,
162 .type
= V4L2_CTRL_TYPE_INTEGER
,
163 .name
= "Minimum number of cap bufs",
172 #define NUM_CTRLS ARRAY_SIZE(controls)
174 /* Check whether a context should be run on hardware */
175 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx
*ctx
)
177 /* Context is to parse header */
178 if (ctx
->src_queue_cnt
>= 1 && ctx
->state
== MFCINST_GOT_INST
)
180 /* Context is to decode a frame */
181 if (ctx
->src_queue_cnt
>= 1 &&
182 ctx
->state
== MFCINST_RUNNING
&&
183 ctx
->dst_queue_cnt
>= ctx
->dpb_count
)
185 /* Context is to return last frame */
186 if (ctx
->state
== MFCINST_FINISHING
&&
187 ctx
->dst_queue_cnt
>= ctx
->dpb_count
)
189 /* Context is to set buffers */
190 if (ctx
->src_queue_cnt
>= 1 &&
191 ctx
->state
== MFCINST_HEAD_PARSED
&&
192 ctx
->capture_state
== QUEUE_BUFS_MMAPED
)
194 /* Resolution change */
195 if ((ctx
->state
== MFCINST_RES_CHANGE_INIT
||
196 ctx
->state
== MFCINST_RES_CHANGE_FLUSH
) &&
197 ctx
->dst_queue_cnt
>= ctx
->dpb_count
)
199 if (ctx
->state
== MFCINST_RES_CHANGE_END
&&
200 ctx
->src_queue_cnt
>= 1)
202 mfc_debug(2, "ctx is not ready\n");
206 static struct s5p_mfc_codec_ops decoder_codec_ops
= {
207 .pre_seq_start
= NULL
,
208 .post_seq_start
= NULL
,
209 .pre_frame_start
= NULL
,
210 .post_frame_start
= NULL
,
213 /* Query capabilities of the device */
214 static int vidioc_querycap(struct file
*file
, void *priv
,
215 struct v4l2_capability
*cap
)
217 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
219 strncpy(cap
->driver
, dev
->plat_dev
->name
, sizeof(cap
->driver
) - 1);
220 strncpy(cap
->card
, dev
->plat_dev
->name
, sizeof(cap
->card
) - 1);
221 cap
->bus_info
[0] = 0;
222 cap
->version
= KERNEL_VERSION(1, 0, 0);
223 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
| V4L2_CAP_VIDEO_OUTPUT
224 | V4L2_CAP_STREAMING
;
228 /* Enumerate format */
229 static int vidioc_enum_fmt(struct v4l2_fmtdesc
*f
, bool mplane
, bool out
)
231 struct s5p_mfc_fmt
*fmt
;
234 for (i
= 0; i
< ARRAY_SIZE(formats
); ++i
) {
235 if (mplane
&& formats
[i
].num_planes
== 1)
237 else if (!mplane
&& formats
[i
].num_planes
> 1)
239 if (out
&& formats
[i
].type
!= MFC_FMT_DEC
)
241 else if (!out
&& formats
[i
].type
!= MFC_FMT_RAW
)
248 if (i
== ARRAY_SIZE(formats
))
251 strlcpy(f
->description
, fmt
->name
, sizeof(f
->description
));
252 f
->pixelformat
= fmt
->fourcc
;
256 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *pirv
,
257 struct v4l2_fmtdesc
*f
)
259 return vidioc_enum_fmt(f
, false, false);
262 static int vidioc_enum_fmt_vid_cap_mplane(struct file
*file
, void *pirv
,
263 struct v4l2_fmtdesc
*f
)
265 return vidioc_enum_fmt(f
, true, false);
268 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *prov
,
269 struct v4l2_fmtdesc
*f
)
271 return vidioc_enum_fmt(f
, false, true);
274 static int vidioc_enum_fmt_vid_out_mplane(struct file
*file
, void *prov
,
275 struct v4l2_fmtdesc
*f
)
277 return vidioc_enum_fmt(f
, true, true);
281 static int vidioc_g_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
283 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
284 struct v4l2_pix_format_mplane
*pix_mp
;
287 pix_mp
= &f
->fmt
.pix_mp
;
288 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
&&
289 (ctx
->state
== MFCINST_GOT_INST
|| ctx
->state
==
290 MFCINST_RES_CHANGE_END
)) {
291 /* If the MFC is parsing the header,
292 * so wait until it is finished */
293 s5p_mfc_clean_ctx_int_flags(ctx
);
294 s5p_mfc_wait_for_done_ctx(ctx
, S5P_FIMV_R2H_CMD_SEQ_DONE_RET
,
297 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
&&
298 ctx
->state
>= MFCINST_HEAD_PARSED
&&
299 ctx
->state
< MFCINST_ABORT
) {
300 /* This is run on CAPTURE (decode output) */
301 /* Width and height are set to the dimensions
302 of the movie, the buffer is bigger and
303 further processing stages should crop to this
305 pix_mp
->width
= ctx
->buf_width
;
306 pix_mp
->height
= ctx
->buf_height
;
307 pix_mp
->field
= V4L2_FIELD_NONE
;
308 pix_mp
->num_planes
= 2;
309 /* Set pixelformat to the format in which MFC
310 outputs the decoded frame */
311 pix_mp
->pixelformat
= V4L2_PIX_FMT_NV12MT
;
312 pix_mp
->plane_fmt
[0].bytesperline
= ctx
->buf_width
;
313 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->luma_size
;
314 pix_mp
->plane_fmt
[1].bytesperline
= ctx
->buf_width
;
315 pix_mp
->plane_fmt
[1].sizeimage
= ctx
->chroma_size
;
316 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
317 /* This is run on OUTPUT
318 The buffer contains compressed image
319 so width and height have no meaning */
322 pix_mp
->field
= V4L2_FIELD_NONE
;
323 pix_mp
->plane_fmt
[0].bytesperline
= ctx
->dec_src_buf_size
;
324 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->dec_src_buf_size
;
325 pix_mp
->pixelformat
= ctx
->src_fmt
->fourcc
;
326 pix_mp
->num_planes
= ctx
->src_fmt
->num_planes
;
328 mfc_err("Format could not be read\n");
329 mfc_debug(2, "%s-- with error\n", __func__
);
337 static int vidioc_try_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
339 struct s5p_mfc_fmt
*fmt
;
341 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
342 mfc_err("This node supports decoding only\n");
345 fmt
= find_format(f
, MFC_FMT_DEC
);
347 mfc_err("Unsupported format\n");
350 if (fmt
->type
!= MFC_FMT_DEC
) {
358 static int vidioc_s_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
360 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
361 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
363 struct s5p_mfc_fmt
*fmt
;
364 struct v4l2_pix_format_mplane
*pix_mp
;
367 ret
= vidioc_try_fmt(file
, priv
, f
);
368 pix_mp
= &f
->fmt
.pix_mp
;
371 if (ctx
->vq_src
.streaming
|| ctx
->vq_dst
.streaming
) {
372 v4l2_err(&dev
->v4l2_dev
, "%s queue busy\n", __func__
);
376 fmt
= find_format(f
, MFC_FMT_DEC
);
377 if (!fmt
|| fmt
->codec_mode
== S5P_FIMV_CODEC_NONE
) {
378 mfc_err("Unknown codec\n");
382 if (fmt
->type
!= MFC_FMT_DEC
) {
383 mfc_err("Wrong format selected, you should choose "
384 "format for decoding\n");
389 ctx
->codec_mode
= fmt
->codec_mode
;
390 mfc_debug(2, "The codec number is: %d\n", ctx
->codec_mode
);
393 if (pix_mp
->plane_fmt
[0].sizeimage
)
394 ctx
->dec_src_buf_size
= pix_mp
->plane_fmt
[0].sizeimage
;
396 pix_mp
->plane_fmt
[0].sizeimage
= ctx
->dec_src_buf_size
=
398 pix_mp
->plane_fmt
[0].bytesperline
= 0;
399 ctx
->state
= MFCINST_INIT
;
405 /* Reqeust buffers */
406 static int vidioc_reqbufs(struct file
*file
, void *priv
,
407 struct v4l2_requestbuffers
*reqbufs
)
409 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
410 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
414 if (reqbufs
->memory
!= V4L2_MEMORY_MMAP
) {
415 mfc_err("Only V4L2_MEMORY_MAP is supported\n");
418 if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
419 /* Can only request buffers after an instance has been opened.*/
420 if (ctx
->state
== MFCINST_INIT
) {
421 ctx
->src_bufs_cnt
= 0;
422 if (reqbufs
->count
== 0) {
423 mfc_debug(2, "Freeing buffers\n");
425 ret
= vb2_reqbufs(&ctx
->vq_src
, reqbufs
);
430 if (ctx
->output_state
!= QUEUE_FREE
) {
431 mfc_err("Bufs have already been requested\n");
435 ret
= vb2_reqbufs(&ctx
->vq_src
, reqbufs
);
438 mfc_err("vb2_reqbufs on output failed\n");
441 mfc_debug(2, "vb2_reqbufs: %d\n", ret
);
442 ctx
->output_state
= QUEUE_BUFS_REQUESTED
;
444 } else if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
445 ctx
->dst_bufs_cnt
= 0;
446 if (reqbufs
->count
== 0) {
447 mfc_debug(2, "Freeing buffers\n");
449 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
453 if (ctx
->capture_state
!= QUEUE_FREE
) {
454 mfc_err("Bufs have already been requested\n");
457 ctx
->capture_state
= QUEUE_BUFS_REQUESTED
;
459 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
462 mfc_err("vb2_reqbufs on capture failed\n");
465 if (reqbufs
->count
< ctx
->dpb_count
) {
466 mfc_err("Not enough buffers allocated\n");
469 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
473 ctx
->total_dpb_count
= reqbufs
->count
;
474 ret
= s5p_mfc_alloc_codec_buffers(ctx
);
476 mfc_err("Failed to allocate decoding buffers\n");
479 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
483 if (ctx
->dst_bufs_cnt
== ctx
->total_dpb_count
) {
484 ctx
->capture_state
= QUEUE_BUFS_MMAPED
;
486 mfc_err("Not all buffers passed to buf_init\n");
489 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
490 s5p_mfc_release_codec_buffers(ctx
);
494 if (s5p_mfc_ctx_ready(ctx
)) {
495 spin_lock_irqsave(&dev
->condlock
, flags
);
496 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
497 spin_unlock_irqrestore(&dev
->condlock
, flags
);
499 s5p_mfc_try_run(dev
);
500 s5p_mfc_wait_for_done_ctx(ctx
,
501 S5P_FIMV_R2H_CMD_INIT_BUFFERS_RET
, 0);
507 static int vidioc_querybuf(struct file
*file
, void *priv
,
508 struct v4l2_buffer
*buf
)
510 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
514 if (buf
->memory
!= V4L2_MEMORY_MMAP
) {
515 mfc_err("Only mmaped buffers can be used\n");
518 mfc_debug(2, "State: %d, buf->type: %d\n", ctx
->state
, buf
->type
);
519 if (ctx
->state
== MFCINST_INIT
&&
520 buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
521 ret
= vb2_querybuf(&ctx
->vq_src
, buf
);
522 } else if (ctx
->state
== MFCINST_RUNNING
&&
523 buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
524 ret
= vb2_querybuf(&ctx
->vq_dst
, buf
);
525 for (i
= 0; i
< buf
->length
; i
++)
526 buf
->m
.planes
[i
].m
.mem_offset
+= DST_QUEUE_OFF_BASE
;
528 mfc_err("vidioc_querybuf called in an inappropriate state\n");
536 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
538 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
540 if (ctx
->state
== MFCINST_ERROR
) {
541 mfc_err("Call on QBUF after unrecoverable error\n");
544 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
545 return vb2_qbuf(&ctx
->vq_src
, buf
);
546 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
547 return vb2_qbuf(&ctx
->vq_dst
, buf
);
551 /* Dequeue a buffer */
552 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
554 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
556 if (ctx
->state
== MFCINST_ERROR
) {
557 mfc_err("Call on DQBUF after unrecoverable error\n");
560 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
561 return vb2_dqbuf(&ctx
->vq_src
, buf
, file
->f_flags
& O_NONBLOCK
);
562 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
563 return vb2_dqbuf(&ctx
->vq_dst
, buf
, file
->f_flags
& O_NONBLOCK
);
568 static int vidioc_streamon(struct file
*file
, void *priv
,
569 enum v4l2_buf_type type
)
571 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
572 struct s5p_mfc_dev
*dev
= ctx
->dev
;
577 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
579 if (ctx
->state
== MFCINST_INIT
) {
580 ctx
->dst_bufs_cnt
= 0;
581 ctx
->src_bufs_cnt
= 0;
582 ctx
->capture_state
= QUEUE_FREE
;
583 ctx
->output_state
= QUEUE_FREE
;
584 s5p_mfc_alloc_instance_buffer(ctx
);
585 s5p_mfc_alloc_dec_temp_buffers(ctx
);
586 spin_lock_irqsave(&dev
->condlock
, flags
);
587 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
588 spin_unlock_irqrestore(&dev
->condlock
, flags
);
589 s5p_mfc_clean_ctx_int_flags(ctx
);
590 s5p_mfc_try_run(dev
);
592 if (s5p_mfc_wait_for_done_ctx(ctx
,
593 S5P_FIMV_R2H_CMD_OPEN_INSTANCE_RET
, 0)) {
594 /* Error or timeout */
595 mfc_err("Error getting instance from hardware\n");
596 s5p_mfc_release_instance_buffer(ctx
);
597 s5p_mfc_release_dec_desc_buffer(ctx
);
600 mfc_debug(2, "Got instance number: %d\n", ctx
->inst_no
);
602 ret
= vb2_streamon(&ctx
->vq_src
, type
);
604 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
605 ret
= vb2_streamon(&ctx
->vq_dst
, type
);
610 /* Stream off, which equals to a pause */
611 static int vidioc_streamoff(struct file
*file
, void *priv
,
612 enum v4l2_buf_type type
)
614 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
616 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
617 return vb2_streamoff(&ctx
->vq_src
, type
);
618 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
619 return vb2_streamoff(&ctx
->vq_dst
, type
);
623 /* Set controls - v4l2 control framework */
624 static int s5p_mfc_dec_s_ctrl(struct v4l2_ctrl
*ctrl
)
626 struct s5p_mfc_ctx
*ctx
= ctrl_to_ctx(ctrl
);
629 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY
:
630 ctx
->loop_filter_mpeg4
= ctrl
->val
;
632 case V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY_ENABLE
:
633 ctx
->display_delay_enable
= ctrl
->val
;
635 case V4L2_CID_MPEG_VIDEO_DECODER_MPEG4_DEBLOCK_FILTER
:
636 ctx
->display_delay
= ctrl
->val
;
638 case V4L2_CID_MPEG_VIDEO_DECODER_SLICE_INTERFACE
:
639 ctx
->slice_interface
= ctrl
->val
;
642 mfc_err("Invalid control 0x%08x\n", ctrl
->id
);
648 static int s5p_mfc_dec_g_v_ctrl(struct v4l2_ctrl
*ctrl
)
650 struct s5p_mfc_ctx
*ctx
= ctrl_to_ctx(ctrl
);
651 struct s5p_mfc_dev
*dev
= ctx
->dev
;
654 case V4L2_CID_MIN_BUFFERS_FOR_CAPTURE
:
655 if (ctx
->state
>= MFCINST_HEAD_PARSED
&&
656 ctx
->state
< MFCINST_ABORT
) {
657 ctrl
->val
= ctx
->dpb_count
;
659 } else if (ctx
->state
!= MFCINST_INIT
) {
660 v4l2_err(&dev
->v4l2_dev
, "Decoding not initialised\n");
663 /* Should wait for the header to be parsed */
664 s5p_mfc_clean_ctx_int_flags(ctx
);
665 s5p_mfc_wait_for_done_ctx(ctx
,
666 S5P_FIMV_R2H_CMD_SEQ_DONE_RET
, 0);
667 if (ctx
->state
>= MFCINST_HEAD_PARSED
&&
668 ctx
->state
< MFCINST_ABORT
) {
669 ctrl
->val
= ctx
->dpb_count
;
671 v4l2_err(&dev
->v4l2_dev
, "Decoding not initialised\n");
680 static const struct v4l2_ctrl_ops s5p_mfc_dec_ctrl_ops
= {
681 .s_ctrl
= s5p_mfc_dec_s_ctrl
,
682 .g_volatile_ctrl
= s5p_mfc_dec_g_v_ctrl
,
685 /* Get cropping information */
686 static int vidioc_g_crop(struct file
*file
, void *priv
,
687 struct v4l2_crop
*cr
)
689 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
690 u32 left
, right
, top
, bottom
;
692 if (ctx
->state
!= MFCINST_HEAD_PARSED
&&
693 ctx
->state
!= MFCINST_RUNNING
&& ctx
->state
!= MFCINST_FINISHING
694 && ctx
->state
!= MFCINST_FINISHED
) {
695 mfc_err("Cannont set crop\n");
698 if (ctx
->src_fmt
->fourcc
== V4L2_PIX_FMT_H264
) {
699 left
= s5p_mfc_read_shm(ctx
, CROP_INFO_H
);
700 right
= left
>> S5P_FIMV_SHARED_CROP_RIGHT_SHIFT
;
701 left
= left
& S5P_FIMV_SHARED_CROP_LEFT_MASK
;
702 top
= s5p_mfc_read_shm(ctx
, CROP_INFO_V
);
703 bottom
= top
>> S5P_FIMV_SHARED_CROP_BOTTOM_SHIFT
;
704 top
= top
& S5P_FIMV_SHARED_CROP_TOP_MASK
;
707 cr
->c
.width
= ctx
->img_width
- left
- right
;
708 cr
->c
.height
= ctx
->img_height
- top
- bottom
;
709 mfc_debug(2, "Cropping info [h264]: l=%d t=%d "
710 "w=%d h=%d (r=%d b=%d fw=%d fh=%d\n", left
, top
,
711 cr
->c
.width
, cr
->c
.height
, right
, bottom
,
712 ctx
->buf_width
, ctx
->buf_height
);
716 cr
->c
.width
= ctx
->img_width
;
717 cr
->c
.height
= ctx
->img_height
;
718 mfc_debug(2, "Cropping info: w=%d h=%d fw=%d "
719 "fh=%d\n", cr
->c
.width
, cr
->c
.height
, ctx
->buf_width
,
726 static const struct v4l2_ioctl_ops s5p_mfc_dec_ioctl_ops
= {
727 .vidioc_querycap
= vidioc_querycap
,
728 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
729 .vidioc_enum_fmt_vid_cap_mplane
= vidioc_enum_fmt_vid_cap_mplane
,
730 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
731 .vidioc_enum_fmt_vid_out_mplane
= vidioc_enum_fmt_vid_out_mplane
,
732 .vidioc_g_fmt_vid_cap_mplane
= vidioc_g_fmt
,
733 .vidioc_g_fmt_vid_out_mplane
= vidioc_g_fmt
,
734 .vidioc_try_fmt_vid_cap_mplane
= vidioc_try_fmt
,
735 .vidioc_try_fmt_vid_out_mplane
= vidioc_try_fmt
,
736 .vidioc_s_fmt_vid_cap_mplane
= vidioc_s_fmt
,
737 .vidioc_s_fmt_vid_out_mplane
= vidioc_s_fmt
,
738 .vidioc_reqbufs
= vidioc_reqbufs
,
739 .vidioc_querybuf
= vidioc_querybuf
,
740 .vidioc_qbuf
= vidioc_qbuf
,
741 .vidioc_dqbuf
= vidioc_dqbuf
,
742 .vidioc_streamon
= vidioc_streamon
,
743 .vidioc_streamoff
= vidioc_streamoff
,
744 .vidioc_g_crop
= vidioc_g_crop
,
747 static int s5p_mfc_queue_setup(struct vb2_queue
*vq
, unsigned int *buf_count
,
748 unsigned int *plane_count
, unsigned long psize
[],
751 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
753 /* Video output for decoding (source)
754 * this can be set after getting an instance */
755 if (ctx
->state
== MFCINST_INIT
&&
756 vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
757 /* A single plane is required for input */
761 if (*buf_count
> MFC_MAX_BUFFERS
)
762 *buf_count
= MFC_MAX_BUFFERS
;
763 /* Video capture for decoding (destination)
764 * this can be set after the header was parsed */
765 } else if (ctx
->state
== MFCINST_HEAD_PARSED
&&
766 vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
767 /* Output plane count is 2 - one for Y and one for CbCr */
769 /* Setup buffer count */
770 if (*buf_count
< ctx
->dpb_count
)
771 *buf_count
= ctx
->dpb_count
;
772 if (*buf_count
> ctx
->dpb_count
+ MFC_MAX_EXTRA_DPB
)
773 *buf_count
= ctx
->dpb_count
+ MFC_MAX_EXTRA_DPB
;
774 if (*buf_count
> MFC_MAX_BUFFERS
)
775 *buf_count
= MFC_MAX_BUFFERS
;
777 mfc_err("State seems invalid. State = %d, vq->type = %d\n",
778 ctx
->state
, vq
->type
);
781 mfc_debug(2, "Buffer count=%d, plane count=%d\n",
782 *buf_count
, *plane_count
);
783 if (ctx
->state
== MFCINST_HEAD_PARSED
&&
784 vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
785 psize
[0] = ctx
->luma_size
;
786 psize
[1] = ctx
->chroma_size
;
787 allocators
[0] = ctx
->dev
->alloc_ctx
[MFC_BANK2_ALLOC_CTX
];
788 allocators
[1] = ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
789 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
&&
790 ctx
->state
== MFCINST_INIT
) {
791 psize
[0] = ctx
->dec_src_buf_size
;
792 allocators
[0] = ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
794 mfc_err("This video node is dedicated to decoding. Decoding not initalised\n");
800 static void s5p_mfc_unlock(struct vb2_queue
*q
)
802 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
803 struct s5p_mfc_dev
*dev
= ctx
->dev
;
805 mutex_unlock(&dev
->mfc_mutex
);
808 static void s5p_mfc_lock(struct vb2_queue
*q
)
810 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
811 struct s5p_mfc_dev
*dev
= ctx
->dev
;
813 mutex_lock(&dev
->mfc_mutex
);
816 static int s5p_mfc_buf_init(struct vb2_buffer
*vb
)
818 struct vb2_queue
*vq
= vb
->vb2_queue
;
819 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
822 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
823 if (ctx
->capture_state
== QUEUE_BUFS_MMAPED
)
825 for (i
= 0; i
<= ctx
->src_fmt
->num_planes
; i
++) {
826 if (IS_ERR_OR_NULL(ERR_PTR(
827 vb2_dma_contig_plane_paddr(vb
, i
)))) {
828 mfc_err("Plane mem not allocated\n");
832 if (vb2_plane_size(vb
, 0) < ctx
->luma_size
||
833 vb2_plane_size(vb
, 1) < ctx
->chroma_size
) {
834 mfc_err("Plane buffer (CAPTURE) is too small\n");
837 i
= vb
->v4l2_buf
.index
;
838 ctx
->dst_bufs
[i
].b
= vb
;
839 ctx
->dst_bufs
[i
].cookie
.raw
.luma
=
840 vb2_dma_contig_plane_paddr(vb
, 0);
841 ctx
->dst_bufs
[i
].cookie
.raw
.chroma
=
842 vb2_dma_contig_plane_paddr(vb
, 1);
844 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
845 if (IS_ERR_OR_NULL(ERR_PTR(
846 vb2_dma_contig_plane_paddr(vb
, 0)))) {
847 mfc_err("Plane memory not allocated\n");
850 if (vb2_plane_size(vb
, 0) < ctx
->dec_src_buf_size
) {
851 mfc_err("Plane buffer (OUTPUT) is too small\n");
855 i
= vb
->v4l2_buf
.index
;
856 ctx
->src_bufs
[i
].b
= vb
;
857 ctx
->src_bufs
[i
].cookie
.stream
=
858 vb2_dma_contig_plane_paddr(vb
, 0);
861 mfc_err("s5p_mfc_buf_init: unknown queue type\n");
867 static int s5p_mfc_start_streaming(struct vb2_queue
*q
)
869 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
870 struct s5p_mfc_dev
*dev
= ctx
->dev
;
873 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
874 if (ctx
->state
== MFCINST_FINISHING
||
875 ctx
->state
== MFCINST_FINISHED
)
876 ctx
->state
= MFCINST_RUNNING
;
877 /* If context is ready then dev = work->data;schedule it to run */
878 if (s5p_mfc_ctx_ready(ctx
)) {
879 spin_lock_irqsave(&dev
->condlock
, flags
);
880 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
881 spin_unlock_irqrestore(&dev
->condlock
, flags
);
883 s5p_mfc_try_run(dev
);
887 static int s5p_mfc_stop_streaming(struct vb2_queue
*q
)
890 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
891 struct s5p_mfc_dev
*dev
= ctx
->dev
;
894 if ((ctx
->state
== MFCINST_FINISHING
||
895 ctx
->state
== MFCINST_RUNNING
) &&
896 dev
->curr_ctx
== ctx
->num
&& dev
->hw_lock
) {
897 ctx
->state
= MFCINST_ABORT
;
898 s5p_mfc_wait_for_done_ctx(ctx
,
899 S5P_FIMV_R2H_CMD_FRAME_DONE_RET
, 0);
902 spin_lock_irqsave(&dev
->irqlock
, flags
);
903 if (q
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
904 s5p_mfc_cleanup_queue(&ctx
->dst_queue
, &ctx
->vq_dst
);
905 INIT_LIST_HEAD(&ctx
->dst_queue
);
906 ctx
->dst_queue_cnt
= 0;
907 ctx
->dpb_flush_flag
= 1;
908 ctx
->dec_dst_flag
= 0;
910 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
911 s5p_mfc_cleanup_queue(&ctx
->src_queue
, &ctx
->vq_src
);
912 INIT_LIST_HEAD(&ctx
->src_queue
);
913 ctx
->src_queue_cnt
= 0;
916 ctx
->state
= MFCINST_RUNNING
;
917 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
922 static void s5p_mfc_buf_queue(struct vb2_buffer
*vb
)
924 struct vb2_queue
*vq
= vb
->vb2_queue
;
925 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
926 struct s5p_mfc_dev
*dev
= ctx
->dev
;
928 struct s5p_mfc_buf
*mfc_buf
;
930 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
931 mfc_buf
= &ctx
->src_bufs
[vb
->v4l2_buf
.index
];
933 spin_lock_irqsave(&dev
->irqlock
, flags
);
934 list_add_tail(&mfc_buf
->list
, &ctx
->src_queue
);
935 ctx
->src_queue_cnt
++;
936 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
937 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
938 mfc_buf
= &ctx
->dst_bufs
[vb
->v4l2_buf
.index
];
940 /* Mark destination as available for use by MFC */
941 spin_lock_irqsave(&dev
->irqlock
, flags
);
942 set_bit(vb
->v4l2_buf
.index
, &ctx
->dec_dst_flag
);
943 list_add_tail(&mfc_buf
->list
, &ctx
->dst_queue
);
944 ctx
->dst_queue_cnt
++;
945 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
947 mfc_err("Unsupported buffer type (%d)\n", vq
->type
);
949 if (s5p_mfc_ctx_ready(ctx
)) {
950 spin_lock_irqsave(&dev
->condlock
, flags
);
951 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
952 spin_unlock_irqrestore(&dev
->condlock
, flags
);
954 s5p_mfc_try_run(dev
);
957 static struct vb2_ops s5p_mfc_dec_qops
= {
958 .queue_setup
= s5p_mfc_queue_setup
,
959 .wait_prepare
= s5p_mfc_unlock
,
960 .wait_finish
= s5p_mfc_lock
,
961 .buf_init
= s5p_mfc_buf_init
,
962 .start_streaming
= s5p_mfc_start_streaming
,
963 .stop_streaming
= s5p_mfc_stop_streaming
,
964 .buf_queue
= s5p_mfc_buf_queue
,
967 struct s5p_mfc_codec_ops
*get_dec_codec_ops(void)
969 return &decoder_codec_ops
;
972 struct vb2_ops
*get_dec_queue_ops(void)
974 return &s5p_mfc_dec_qops
;
977 const struct v4l2_ioctl_ops
*get_dec_v4l2_ioctl_ops(void)
979 return &s5p_mfc_dec_ioctl_ops
;
982 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
983 && V4L2_CTRL_DRIVER_PRIV(x))
985 int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx
*ctx
)
987 struct v4l2_ctrl_config cfg
;
990 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, NUM_CTRLS
);
991 if (ctx
->ctrl_handler
.error
) {
992 mfc_err("v4l2_ctrl_handler_init failed\n");
993 return ctx
->ctrl_handler
.error
;
996 for (i
= 0; i
< NUM_CTRLS
; i
++) {
997 if (IS_MFC51_PRIV(controls
[i
].id
)) {
998 cfg
.ops
= &s5p_mfc_dec_ctrl_ops
;
999 cfg
.id
= controls
[i
].id
;
1000 cfg
.min
= controls
[i
].minimum
;
1001 cfg
.max
= controls
[i
].maximum
;
1002 cfg
.def
= controls
[i
].default_value
;
1003 cfg
.name
= controls
[i
].name
;
1004 cfg
.type
= controls
[i
].type
;
1006 cfg
.step
= controls
[i
].step
;
1007 cfg
.menu_skip_mask
= 0;
1009 ctx
->ctrls
[i
] = v4l2_ctrl_new_custom(&ctx
->ctrl_handler
,
1012 ctx
->ctrls
[i
] = v4l2_ctrl_new_std(&ctx
->ctrl_handler
,
1013 &s5p_mfc_dec_ctrl_ops
,
1014 controls
[i
].id
, controls
[i
].minimum
,
1015 controls
[i
].maximum
, controls
[i
].step
,
1016 controls
[i
].default_value
);
1018 if (ctx
->ctrl_handler
.error
) {
1019 mfc_err("Adding control (%d) failed\n", i
);
1020 return ctx
->ctrl_handler
.error
;
1022 if (controls
[i
].is_volatile
&& ctx
->ctrls
[i
])
1023 ctx
->ctrls
[i
]->is_volatile
= 1;
1028 void s5p_mfc_dec_ctrls_delete(struct s5p_mfc_ctx
*ctx
)
1032 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
1033 for (i
= 0; i
< NUM_CTRLS
; i
++)
1034 ctx
->ctrls
[i
] = NULL
;