2 * linux/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
4 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
5 * http://www.samsung.com/
7 * Jeongtae Park <jtp.park@samsung.com>
8 * Kamil Debski <k.debski@samsung.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
16 #include <linux/clk.h>
17 #include <linux/interrupt.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/sched.h>
22 #include <linux/videodev2.h>
23 #include <media/v4l2-event.h>
24 #include <linux/workqueue.h>
25 #include <media/v4l2-ctrls.h>
26 #include <media/videobuf2-v4l2.h>
27 #include "s5p_mfc_common.h"
28 #include "s5p_mfc_ctrl.h"
29 #include "s5p_mfc_debug.h"
30 #include "s5p_mfc_enc.h"
31 #include "s5p_mfc_intr.h"
32 #include "s5p_mfc_opr.h"
34 #define DEF_SRC_FMT_ENC V4L2_PIX_FMT_NV12M
35 #define DEF_DST_FMT_ENC V4L2_PIX_FMT_H264
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,
44 .versions = MFC_V6_BIT | MFC_V7_BIT,
47 .name = "4:2:0 2 Planes 64x32 Tiles",
48 .fourcc = V4L2_PIX_FMT_NV12MT,
49 .codec_mode = S5P_MFC_CODEC_NONE,
52 .versions = MFC_V5_BIT,
55 .name = "4:2:0 2 Planes Y/CbCr",
56 .fourcc = V4L2_PIX_FMT_NV12M,
57 .codec_mode = S5P_MFC_CODEC_NONE,
60 .versions = MFC_V5PLUS_BITS,
63 .name = "4:2:0 2 Planes Y/CrCb",
64 .fourcc = V4L2_PIX_FMT_NV21M,
65 .codec_mode = S5P_MFC_CODEC_NONE,
68 .versions = MFC_V6PLUS_BITS,
71 .name = "H264 Encoded Stream",
72 .fourcc = V4L2_PIX_FMT_H264,
73 .codec_mode = S5P_MFC_CODEC_H264_ENC,
76 .versions = MFC_V5PLUS_BITS,
79 .name = "MPEG4 Encoded Stream",
80 .fourcc = V4L2_PIX_FMT_MPEG4,
81 .codec_mode = S5P_MFC_CODEC_MPEG4_ENC,
84 .versions = MFC_V5PLUS_BITS,
87 .name = "H263 Encoded Stream",
88 .fourcc = V4L2_PIX_FMT_H263,
89 .codec_mode = S5P_MFC_CODEC_H263_ENC,
92 .versions = MFC_V5PLUS_BITS,
95 .name = "VP8 Encoded Stream",
96 .fourcc = V4L2_PIX_FMT_VP8,
97 .codec_mode = S5P_MFC_CODEC_VP8_ENC,
100 .versions = MFC_V7PLUS_BITS,
103 .fourcc = V4L2_PIX_FMT_HEVC,
104 .codec_mode = S5P_FIMV_CODEC_HEVC_ENC,
107 .versions = MFC_V10_BIT,
111 #define NUM_FORMATS ARRAY_SIZE(formats)
112 static struct s5p_mfc_fmt *find_format(struct v4l2_format *f, unsigned int t)
116 for (i = 0; i < NUM_FORMATS; i++) {
117 if (formats[i].fourcc == f->fmt.pix_mp.pixelformat &&
118 formats[i].type == t)
124 static struct mfc_control controls[] = {
126 .id = V4L2_CID_MPEG_VIDEO_GOP_SIZE,
127 .type = V4L2_CTRL_TYPE_INTEGER,
129 .maximum = (1 << 16) - 1,
134 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
135 .type = V4L2_CTRL_TYPE_MENU,
136 .minimum = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
137 .maximum = V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES,
138 .default_value = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
142 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB,
143 .type = V4L2_CTRL_TYPE_INTEGER,
145 .maximum = (1 << 16) - 1,
150 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES,
151 .type = V4L2_CTRL_TYPE_INTEGER,
153 .maximum = (1 << 30) - 1,
155 .default_value = 1900,
158 .id = V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB,
159 .type = V4L2_CTRL_TYPE_INTEGER,
161 .maximum = (1 << 16) - 1,
166 .id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING,
167 .type = V4L2_CTRL_TYPE_BOOLEAN,
168 .name = "Padding Control Enable",
175 .id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV,
176 .type = V4L2_CTRL_TYPE_INTEGER,
177 .name = "Padding Color YUV Value",
179 .maximum = (1 << 25) - 1,
184 .id = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,
185 .type = V4L2_CTRL_TYPE_BOOLEAN,
192 .id = V4L2_CID_MPEG_VIDEO_BITRATE,
193 .type = V4L2_CTRL_TYPE_INTEGER,
195 .maximum = (1 << 30) - 1,
200 .id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF,
201 .type = V4L2_CTRL_TYPE_INTEGER,
202 .name = "Rate Control Reaction Coeff.",
204 .maximum = (1 << 16) - 1,
209 .id = V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE,
210 .type = V4L2_CTRL_TYPE_MENU,
211 .name = "Force frame type",
212 .minimum = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED,
213 .maximum = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED,
214 .default_value = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED,
218 .id = V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,
219 .type = V4L2_CTRL_TYPE_BUTTON,
226 .id = V4L2_CID_MPEG_VIDEO_VBV_SIZE,
227 .type = V4L2_CTRL_TYPE_INTEGER,
229 .maximum = (1 << 16) - 1,
234 .id = V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE,
235 .type = V4L2_CTRL_TYPE_INTEGER,
236 .name = "Horizontal MV Search Range",
243 .id = V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE,
244 .type = V4L2_CTRL_TYPE_INTEGER,
245 .name = "Vertical MV Search Range",
252 .id = V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE,
253 .type = V4L2_CTRL_TYPE_INTEGER,
255 .maximum = (1 << 16) - 1,
260 .id = V4L2_CID_MPEG_VIDEO_HEADER_MODE,
261 .type = V4L2_CTRL_TYPE_MENU,
262 .minimum = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
263 .maximum = V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
264 .default_value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
268 .id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE,
269 .type = V4L2_CTRL_TYPE_MENU,
270 .name = "Frame Skip Enable",
271 .minimum = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED,
272 .maximum = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
274 .default_value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED,
277 .id = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT,
278 .type = V4L2_CTRL_TYPE_BOOLEAN,
279 .name = "Fixed Target Bit Enable",
287 .id = V4L2_CID_MPEG_VIDEO_B_FRAMES,
288 .type = V4L2_CTRL_TYPE_INTEGER,
295 .id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
296 .type = V4L2_CTRL_TYPE_MENU,
297 .minimum = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
298 .maximum = V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH,
299 .default_value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
301 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
302 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
303 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)
307 .id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
308 .type = V4L2_CTRL_TYPE_MENU,
309 .minimum = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
310 .maximum = V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
311 .default_value = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
314 .id = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
315 .type = V4L2_CTRL_TYPE_MENU,
316 .minimum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
317 .maximum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
318 .default_value = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
322 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
323 .type = V4L2_CTRL_TYPE_MENU,
324 .minimum = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
325 .maximum = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY,
326 .default_value = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
330 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA,
331 .type = V4L2_CTRL_TYPE_INTEGER,
338 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA,
339 .type = V4L2_CTRL_TYPE_INTEGER,
346 .id = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
347 .type = V4L2_CTRL_TYPE_MENU,
348 .minimum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
349 .maximum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
350 .default_value = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
354 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P,
355 .type = V4L2_CTRL_TYPE_INTEGER,
356 .name = "The Number of Ref. Pic for P",
363 .id = V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM,
364 .type = V4L2_CTRL_TYPE_BOOLEAN,
371 .id = V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,
372 .type = V4L2_CTRL_TYPE_BOOLEAN,
379 .id = V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
380 .type = V4L2_CTRL_TYPE_INTEGER,
387 .id = V4L2_CID_MPEG_VIDEO_H264_MIN_QP,
388 .type = V4L2_CTRL_TYPE_INTEGER,
395 .id = V4L2_CID_MPEG_VIDEO_H264_MAX_QP,
396 .type = V4L2_CTRL_TYPE_INTEGER,
403 .id = V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
404 .type = V4L2_CTRL_TYPE_INTEGER,
411 .id = V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP,
412 .type = V4L2_CTRL_TYPE_INTEGER,
419 .id = V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP,
420 .type = V4L2_CTRL_TYPE_INTEGER,
421 .name = "H263 I-Frame QP value",
428 .id = V4L2_CID_MPEG_VIDEO_H263_MIN_QP,
429 .type = V4L2_CTRL_TYPE_INTEGER,
430 .name = "H263 Minimum QP value",
437 .id = V4L2_CID_MPEG_VIDEO_H263_MAX_QP,
438 .type = V4L2_CTRL_TYPE_INTEGER,
439 .name = "H263 Maximum QP value",
446 .id = V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP,
447 .type = V4L2_CTRL_TYPE_INTEGER,
448 .name = "H263 P frame QP value",
455 .id = V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP,
456 .type = V4L2_CTRL_TYPE_INTEGER,
457 .name = "H263 B frame QP value",
464 .id = V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP,
465 .type = V4L2_CTRL_TYPE_INTEGER,
466 .name = "MPEG4 I-Frame QP value",
473 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP,
474 .type = V4L2_CTRL_TYPE_INTEGER,
475 .name = "MPEG4 Minimum QP value",
482 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP,
483 .type = V4L2_CTRL_TYPE_INTEGER,
484 .name = "MPEG4 Maximum QP value",
491 .id = V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP,
492 .type = V4L2_CTRL_TYPE_INTEGER,
493 .name = "MPEG4 P frame QP value",
500 .id = V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP,
501 .type = V4L2_CTRL_TYPE_INTEGER,
502 .name = "MPEG4 B frame QP value",
509 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK,
510 .type = V4L2_CTRL_TYPE_BOOLEAN,
511 .name = "H264 Dark Reg Adaptive RC",
518 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH,
519 .type = V4L2_CTRL_TYPE_BOOLEAN,
520 .name = "H264 Smooth Reg Adaptive RC",
527 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC,
528 .type = V4L2_CTRL_TYPE_BOOLEAN,
529 .name = "H264 Static Reg Adaptive RC",
536 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY,
537 .type = V4L2_CTRL_TYPE_BOOLEAN,
538 .name = "H264 Activity Reg Adaptive RC",
545 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE,
546 .type = V4L2_CTRL_TYPE_BOOLEAN,
553 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC,
554 .type = V4L2_CTRL_TYPE_MENU,
555 .minimum = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED,
556 .maximum = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED,
557 .default_value = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED,
561 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH,
562 .type = V4L2_CTRL_TYPE_INTEGER,
564 .maximum = (1 << 16) - 1,
569 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT,
570 .type = V4L2_CTRL_TYPE_INTEGER,
572 .maximum = (1 << 16) - 1,
577 .id = V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
578 .type = V4L2_CTRL_TYPE_BOOLEAN,
585 .id = V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,
586 .type = V4L2_CTRL_TYPE_INTEGER,
588 .maximum = (1 << 16) - 1,
593 .id = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
594 .type = V4L2_CTRL_TYPE_MENU,
595 .minimum = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
596 .maximum = V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE,
597 .default_value = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
601 .id = V4L2_CID_MPEG_VIDEO_MPEG4_QPEL,
602 .type = V4L2_CTRL_TYPE_BOOLEAN,
609 .id = V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS,
610 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
611 .maximum = V4L2_CID_MPEG_VIDEO_VPX_8_PARTITIONS,
612 .default_value = V4L2_CID_MPEG_VIDEO_VPX_1_PARTITION,
616 .id = V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4,
617 .type = V4L2_CTRL_TYPE_BOOLEAN,
624 .id = V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES,
625 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
626 .maximum = V4L2_CID_MPEG_VIDEO_VPX_2_REF_FRAME,
627 .default_value = V4L2_CID_MPEG_VIDEO_VPX_1_REF_FRAME,
631 .id = V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL,
632 .type = V4L2_CTRL_TYPE_INTEGER,
639 .id = V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS,
640 .type = V4L2_CTRL_TYPE_INTEGER,
647 .id = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD,
648 .type = V4L2_CTRL_TYPE_INTEGER,
650 .maximum = (1 << 16) - 1,
655 .id = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL,
656 .type = V4L2_CTRL_TYPE_MENU,
657 .minimum = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_PREV,
658 .maximum = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_REF_PERIOD,
659 .default_value = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_PREV,
663 .id = V4L2_CID_MPEG_VIDEO_VPX_MAX_QP,
664 .type = V4L2_CTRL_TYPE_INTEGER,
668 .default_value = 127,
671 .id = V4L2_CID_MPEG_VIDEO_VPX_MIN_QP,
672 .type = V4L2_CTRL_TYPE_INTEGER,
679 .id = V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP,
680 .type = V4L2_CTRL_TYPE_INTEGER,
687 .id = V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP,
688 .type = V4L2_CTRL_TYPE_INTEGER,
695 .id = V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
696 .type = V4L2_CTRL_TYPE_MENU,
697 .minimum = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
698 .maximum = V4L2_MPEG_VIDEO_VP8_PROFILE_3,
699 .default_value = V4L2_MPEG_VIDEO_VP8_PROFILE_0,
703 .id = V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP,
704 .type = V4L2_CTRL_TYPE_INTEGER,
705 .name = "HEVC I Frame QP Value",
712 .id = V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP,
713 .type = V4L2_CTRL_TYPE_INTEGER,
714 .name = "HEVC P Frame QP Value",
721 .id = V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP,
722 .type = V4L2_CTRL_TYPE_INTEGER,
729 .id = V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP,
730 .type = V4L2_CTRL_TYPE_INTEGER,
737 .id = V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP,
738 .type = V4L2_CTRL_TYPE_INTEGER,
745 .id = V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
746 .type = V4L2_CTRL_TYPE_MENU,
747 .minimum = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
748 .maximum = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE,
750 .default_value = V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN,
753 .id = V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
754 .type = V4L2_CTRL_TYPE_MENU,
755 .minimum = V4L2_MPEG_VIDEO_HEVC_LEVEL_1,
756 .maximum = V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
758 .default_value = V4L2_MPEG_VIDEO_HEVC_LEVEL_1,
761 .id = V4L2_CID_MPEG_VIDEO_HEVC_TIER,
762 .type = V4L2_CTRL_TYPE_MENU,
763 .minimum = V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
764 .maximum = V4L2_MPEG_VIDEO_HEVC_TIER_HIGH,
766 .default_value = V4L2_MPEG_VIDEO_HEVC_TIER_MAIN,
769 .id = V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION,
770 .type = V4L2_CTRL_TYPE_INTEGER,
772 .maximum = (1 << 16) - 1,
777 .id = V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH,
778 .type = V4L2_CTRL_TYPE_INTEGER,
785 .id = V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES,
786 .type = V4L2_CTRL_TYPE_INTEGER,
793 .id = V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE,
794 .type = V4L2_CTRL_TYPE_MENU,
795 .minimum = V4L2_MPEG_VIDEO_HEVC_REFRESH_NONE,
796 .maximum = V4L2_MPEG_VIDEO_HEVC_REFRESH_IDR,
798 .default_value = V4L2_MPEG_VIDEO_HEVC_REFRESH_NONE,
801 .id = V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED,
802 .type = V4L2_CTRL_TYPE_BOOLEAN,
809 .id = V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU,
810 .type = V4L2_CTRL_TYPE_BOOLEAN,
817 .id = V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT,
818 .type = V4L2_CTRL_TYPE_BOOLEAN,
825 .id = V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE,
826 .type = V4L2_CTRL_TYPE_MENU,
827 .minimum = V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED,
828 .maximum = V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY,
830 .default_value = V4L2_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE_DISABLED,
833 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP,
834 .type = V4L2_CTRL_TYPE_BOOLEAN,
841 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE,
842 .type = V4L2_CTRL_TYPE_MENU,
843 .minimum = V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_B,
844 .maximum = V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_P,
846 .default_value = V4L2_MPEG_VIDEO_HEVC_HIERARCHICAL_CODING_B,
849 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER,
850 .type = V4L2_CTRL_TYPE_INTEGER,
857 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP,
858 .type = V4L2_CTRL_TYPE_INTEGER,
865 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP,
866 .type = V4L2_CTRL_TYPE_INTEGER,
873 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP,
874 .type = V4L2_CTRL_TYPE_INTEGER,
881 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP,
882 .type = V4L2_CTRL_TYPE_INTEGER,
889 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP,
890 .type = V4L2_CTRL_TYPE_INTEGER,
897 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP,
898 .type = V4L2_CTRL_TYPE_INTEGER,
905 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP,
906 .type = V4L2_CTRL_TYPE_INTEGER,
913 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR,
914 .type = V4L2_CTRL_TYPE_INTEGER,
921 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR,
922 .type = V4L2_CTRL_TYPE_INTEGER,
929 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR,
930 .type = V4L2_CTRL_TYPE_INTEGER,
937 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR,
938 .type = V4L2_CTRL_TYPE_INTEGER,
945 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR,
946 .type = V4L2_CTRL_TYPE_INTEGER,
953 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR,
954 .type = V4L2_CTRL_TYPE_INTEGER,
961 .id = V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR,
962 .type = V4L2_CTRL_TYPE_INTEGER,
969 .id = V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB,
970 .type = V4L2_CTRL_TYPE_BOOLEAN,
977 .id = V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID,
978 .type = V4L2_CTRL_TYPE_BOOLEAN,
985 .id = V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING,
986 .type = V4L2_CTRL_TYPE_BOOLEAN,
993 .id = V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT,
994 .type = V4L2_CTRL_TYPE_BOOLEAN,
1001 .id = V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION,
1002 .type = V4L2_CTRL_TYPE_BOOLEAN,
1009 .id = V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1,
1010 .type = V4L2_CTRL_TYPE_INTEGER,
1017 .id = V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE,
1018 .type = V4L2_CTRL_TYPE_BOOLEAN,
1025 .id = V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD,
1026 .type = V4L2_CTRL_TYPE_INTEGER,
1028 .maximum = (1 << 16) - 1,
1033 .id = V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2,
1034 .type = V4L2_CTRL_TYPE_INTEGER,
1041 .id = V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2,
1042 .type = V4L2_CTRL_TYPE_INTEGER,
1049 .id = V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD,
1050 .type = V4L2_CTRL_TYPE_MENU,
1051 .minimum = V4L2_MPEG_VIDEO_HEVC_SIZE_0,
1052 .maximum = V4L2_MPEG_VIDEO_HEVC_SIZE_4,
1054 .default_value = V4L2_MPEG_VIDEO_HEVC_SIZE_0,
1057 .id = V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR,
1058 .type = V4L2_CTRL_TYPE_INTEGER,
1065 .id = V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,
1066 .type = V4L2_CTRL_TYPE_INTEGER,
1067 .name = "Minimum number of output bufs",
1076 #define NUM_CTRLS ARRAY_SIZE(controls)
1077 static const char * const *mfc51_get_menu(u32 id)
1079 static const char * const mfc51_video_frame_skip[] = {
1085 static const char * const mfc51_video_force_frame[] = {
1092 case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1093 return mfc51_video_frame_skip;
1094 case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1095 return mfc51_video_force_frame;
1100 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx *ctx)
1102 mfc_debug(2, "src=%d, dst=%d, state=%d\n",
1103 ctx->src_queue_cnt, ctx->dst_queue_cnt, ctx->state);
1104 /* context is ready to make header */
1105 if (ctx->state == MFCINST_GOT_INST && ctx->dst_queue_cnt >= 1)
1107 /* context is ready to encode a frame */
1108 if ((ctx->state == MFCINST_RUNNING ||
1109 ctx->state == MFCINST_HEAD_PRODUCED) &&
1110 ctx->src_queue_cnt >= 1 && ctx->dst_queue_cnt >= 1)
1112 /* context is ready to encode remaining frames */
1113 if (ctx->state == MFCINST_FINISHING &&
1114 ctx->dst_queue_cnt >= 1)
1116 mfc_debug(2, "ctx is not ready\n");
1120 static void cleanup_ref_queue(struct s5p_mfc_ctx *ctx)
1122 struct s5p_mfc_buf *mb_entry;
1124 /* move buffers in ref queue to src queue */
1125 while (!list_empty(&ctx->ref_queue)) {
1126 mb_entry = list_entry((&ctx->ref_queue)->next,
1127 struct s5p_mfc_buf, list);
1128 list_del(&mb_entry->list);
1129 ctx->ref_queue_cnt--;
1130 list_add_tail(&mb_entry->list, &ctx->src_queue);
1131 ctx->src_queue_cnt++;
1133 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
1134 ctx->src_queue_cnt, ctx->ref_queue_cnt);
1135 INIT_LIST_HEAD(&ctx->ref_queue);
1136 ctx->ref_queue_cnt = 0;
1139 static int enc_pre_seq_start(struct s5p_mfc_ctx *ctx)
1141 struct s5p_mfc_dev *dev = ctx->dev;
1142 struct s5p_mfc_buf *dst_mb;
1143 unsigned long dst_addr;
1144 unsigned int dst_size;
1146 dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
1147 dst_addr = vb2_dma_contig_plane_dma_addr(&dst_mb->b->vb2_buf, 0);
1148 dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 0);
1149 s5p_mfc_hw_call(dev->mfc_ops, set_enc_stream_buffer, ctx, dst_addr,
1154 static int enc_post_seq_start(struct s5p_mfc_ctx *ctx)
1156 struct s5p_mfc_dev *dev = ctx->dev;
1157 struct s5p_mfc_enc_params *p = &ctx->enc_params;
1158 struct s5p_mfc_buf *dst_mb;
1159 unsigned int enc_pb_count;
1161 if (p->seq_hdr_mode == V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) {
1162 if (!list_empty(&ctx->dst_queue)) {
1163 dst_mb = list_entry(ctx->dst_queue.next,
1164 struct s5p_mfc_buf, list);
1165 list_del(&dst_mb->list);
1166 ctx->dst_queue_cnt--;
1167 vb2_set_plane_payload(&dst_mb->b->vb2_buf, 0,
1168 s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size,
1170 vb2_buffer_done(&dst_mb->b->vb2_buf,
1171 VB2_BUF_STATE_DONE);
1175 if (!IS_MFCV6_PLUS(dev)) {
1176 ctx->state = MFCINST_RUNNING;
1177 if (s5p_mfc_ctx_ready(ctx))
1178 set_work_bit_irqsave(ctx);
1179 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
1181 enc_pb_count = s5p_mfc_hw_call(dev->mfc_ops,
1182 get_enc_dpb_count, dev);
1183 if (ctx->pb_count < enc_pb_count)
1184 ctx->pb_count = enc_pb_count;
1185 if (FW_HAS_E_MIN_SCRATCH_BUF(dev)) {
1186 ctx->scratch_buf_size = s5p_mfc_hw_call(dev->mfc_ops,
1187 get_e_min_scratch_buf_size, dev);
1188 ctx->bank1.size += ctx->scratch_buf_size;
1190 ctx->state = MFCINST_HEAD_PRODUCED;
1196 static int enc_pre_frame_start(struct s5p_mfc_ctx *ctx)
1198 struct s5p_mfc_dev *dev = ctx->dev;
1199 struct s5p_mfc_buf *dst_mb;
1200 struct s5p_mfc_buf *src_mb;
1201 unsigned long src_y_addr, src_c_addr, dst_addr;
1202 unsigned int dst_size;
1204 src_mb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
1205 src_y_addr = vb2_dma_contig_plane_dma_addr(&src_mb->b->vb2_buf, 0);
1206 src_c_addr = vb2_dma_contig_plane_dma_addr(&src_mb->b->vb2_buf, 1);
1207 s5p_mfc_hw_call(dev->mfc_ops, set_enc_frame_buffer, ctx,
1208 src_y_addr, src_c_addr);
1210 dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
1211 dst_addr = vb2_dma_contig_plane_dma_addr(&dst_mb->b->vb2_buf, 0);
1212 dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 0);
1213 s5p_mfc_hw_call(dev->mfc_ops, set_enc_stream_buffer, ctx, dst_addr,
1219 static int enc_post_frame_start(struct s5p_mfc_ctx *ctx)
1221 struct s5p_mfc_dev *dev = ctx->dev;
1222 struct s5p_mfc_buf *mb_entry;
1223 unsigned long enc_y_addr = 0, enc_c_addr = 0;
1224 unsigned long mb_y_addr, mb_c_addr;
1226 unsigned int strm_size;
1229 slice_type = s5p_mfc_hw_call(dev->mfc_ops, get_enc_slice_type, dev);
1230 strm_size = s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size, dev);
1231 mfc_debug(2, "Encoded slice type: %d\n", slice_type);
1232 mfc_debug(2, "Encoded stream size: %d\n", strm_size);
1233 mfc_debug(2, "Display order: %d\n",
1234 mfc_read(dev, S5P_FIMV_ENC_SI_PIC_CNT));
1235 if (slice_type >= 0) {
1236 s5p_mfc_hw_call(dev->mfc_ops, get_enc_frame_buffer, ctx,
1237 &enc_y_addr, &enc_c_addr);
1238 list_for_each_entry(mb_entry, &ctx->src_queue, list) {
1239 mb_y_addr = vb2_dma_contig_plane_dma_addr(
1240 &mb_entry->b->vb2_buf, 0);
1241 mb_c_addr = vb2_dma_contig_plane_dma_addr(
1242 &mb_entry->b->vb2_buf, 1);
1243 if ((enc_y_addr == mb_y_addr) &&
1244 (enc_c_addr == mb_c_addr)) {
1245 list_del(&mb_entry->list);
1246 ctx->src_queue_cnt--;
1247 vb2_buffer_done(&mb_entry->b->vb2_buf,
1248 VB2_BUF_STATE_DONE);
1252 list_for_each_entry(mb_entry, &ctx->ref_queue, list) {
1253 mb_y_addr = vb2_dma_contig_plane_dma_addr(
1254 &mb_entry->b->vb2_buf, 0);
1255 mb_c_addr = vb2_dma_contig_plane_dma_addr(
1256 &mb_entry->b->vb2_buf, 1);
1257 if ((enc_y_addr == mb_y_addr) &&
1258 (enc_c_addr == mb_c_addr)) {
1259 list_del(&mb_entry->list);
1260 ctx->ref_queue_cnt--;
1261 vb2_buffer_done(&mb_entry->b->vb2_buf,
1262 VB2_BUF_STATE_DONE);
1267 if (ctx->src_queue_cnt > 0 && (ctx->state == MFCINST_RUNNING ||
1268 ctx->state == MFCINST_FINISHING)) {
1269 mb_entry = list_entry(ctx->src_queue.next, struct s5p_mfc_buf,
1271 if (mb_entry->flags & MFC_BUF_FLAG_USED) {
1272 list_del(&mb_entry->list);
1273 ctx->src_queue_cnt--;
1274 list_add_tail(&mb_entry->list, &ctx->ref_queue);
1275 ctx->ref_queue_cnt++;
1278 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
1279 ctx->src_queue_cnt, ctx->ref_queue_cnt);
1280 if ((ctx->dst_queue_cnt > 0) && (strm_size > 0)) {
1281 mb_entry = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf,
1283 list_del(&mb_entry->list);
1284 ctx->dst_queue_cnt--;
1285 switch (slice_type) {
1286 case S5P_FIMV_ENC_SI_SLICE_TYPE_I:
1287 mb_entry->b->flags |= V4L2_BUF_FLAG_KEYFRAME;
1289 case S5P_FIMV_ENC_SI_SLICE_TYPE_P:
1290 mb_entry->b->flags |= V4L2_BUF_FLAG_PFRAME;
1292 case S5P_FIMV_ENC_SI_SLICE_TYPE_B:
1293 mb_entry->b->flags |= V4L2_BUF_FLAG_BFRAME;
1296 vb2_set_plane_payload(&mb_entry->b->vb2_buf, 0, strm_size);
1297 vb2_buffer_done(&mb_entry->b->vb2_buf, VB2_BUF_STATE_DONE);
1301 if (ctx->state == MFCINST_RUNNING && ctx->src_queue_cnt == 0)
1303 if (ctx->state == MFCINST_FINISHING && ctx->ref_queue_cnt == 0)
1305 if (!src_ready || ctx->dst_queue_cnt == 0)
1306 clear_work_bit(ctx);
1311 static const struct s5p_mfc_codec_ops encoder_codec_ops = {
1312 .pre_seq_start = enc_pre_seq_start,
1313 .post_seq_start = enc_post_seq_start,
1314 .pre_frame_start = enc_pre_frame_start,
1315 .post_frame_start = enc_post_frame_start,
1318 /* Query capabilities of the device */
1319 static int vidioc_querycap(struct file *file, void *priv,
1320 struct v4l2_capability *cap)
1322 struct s5p_mfc_dev *dev = video_drvdata(file);
1324 strlcpy(cap->driver, S5P_MFC_NAME, sizeof(cap->driver));
1325 strlcpy(cap->card, dev->vfd_enc->name, sizeof(cap->card));
1326 snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
1327 dev_name(&dev->plat_dev->dev));
1329 * This is only a mem-to-mem video device. The capture and output
1330 * device capability flags are left only for backward compatibility
1331 * and are scheduled for removal.
1333 cap->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
1334 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
1338 static int vidioc_enum_fmt(struct file *file, struct v4l2_fmtdesc *f,
1341 struct s5p_mfc_dev *dev = video_drvdata(file);
1342 struct s5p_mfc_fmt *fmt;
1345 for (i = 0; i < ARRAY_SIZE(formats); ++i) {
1346 if (out && formats[i].type != MFC_FMT_RAW)
1348 else if (!out && formats[i].type != MFC_FMT_ENC)
1350 else if ((dev->variant->version_bit & formats[i].versions) == 0)
1353 if (j == f->index) {
1355 strlcpy(f->description, fmt->name,
1356 sizeof(f->description));
1357 f->pixelformat = fmt->fourcc;
1365 static int vidioc_enum_fmt_vid_cap_mplane(struct file *file, void *pirv,
1366 struct v4l2_fmtdesc *f)
1368 return vidioc_enum_fmt(file, f, false);
1371 static int vidioc_enum_fmt_vid_out_mplane(struct file *file, void *prov,
1372 struct v4l2_fmtdesc *f)
1374 return vidioc_enum_fmt(file, f, true);
1377 static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1379 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1380 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1382 mfc_debug(2, "f->type = %d ctx->state = %d\n", f->type, ctx->state);
1383 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1384 /* This is run on output (encoder dest) */
1385 pix_fmt_mp->width = 0;
1386 pix_fmt_mp->height = 0;
1387 pix_fmt_mp->field = V4L2_FIELD_NONE;
1388 pix_fmt_mp->pixelformat = ctx->dst_fmt->fourcc;
1389 pix_fmt_mp->num_planes = ctx->dst_fmt->num_planes;
1391 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->enc_dst_buf_size;
1392 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->enc_dst_buf_size;
1393 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1394 /* This is run on capture (encoder src) */
1395 pix_fmt_mp->width = ctx->img_width;
1396 pix_fmt_mp->height = ctx->img_height;
1398 pix_fmt_mp->field = V4L2_FIELD_NONE;
1399 pix_fmt_mp->pixelformat = ctx->src_fmt->fourcc;
1400 pix_fmt_mp->num_planes = ctx->src_fmt->num_planes;
1402 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1403 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1404 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1405 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1407 mfc_err("invalid buf type\n");
1413 static int vidioc_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
1415 struct s5p_mfc_dev *dev = video_drvdata(file);
1416 struct s5p_mfc_fmt *fmt;
1417 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1419 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1420 fmt = find_format(f, MFC_FMT_ENC);
1422 mfc_err("failed to try output format\n");
1425 if ((dev->variant->version_bit & fmt->versions) == 0) {
1426 mfc_err("Unsupported format by this MFC version.\n");
1430 pix_fmt_mp->plane_fmt[0].bytesperline =
1431 pix_fmt_mp->plane_fmt[0].sizeimage;
1432 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1433 fmt = find_format(f, MFC_FMT_RAW);
1435 mfc_err("failed to try output format\n");
1438 if ((dev->variant->version_bit & fmt->versions) == 0) {
1439 mfc_err("Unsupported format by this MFC version.\n");
1443 v4l_bound_align_image(&pix_fmt_mp->width, 8, 1920, 1,
1444 &pix_fmt_mp->height, 4, 1080, 1, 0);
1446 mfc_err("invalid buf type\n");
1452 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
1454 struct s5p_mfc_dev *dev = video_drvdata(file);
1455 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1456 struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1459 ret = vidioc_try_fmt(file, priv, f);
1462 if (ctx->vq_src.streaming || ctx->vq_dst.streaming) {
1463 v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__);
1467 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1468 /* dst_fmt is validated by call to vidioc_try_fmt */
1469 ctx->dst_fmt = find_format(f, MFC_FMT_ENC);
1470 ctx->state = MFCINST_INIT;
1471 ctx->codec_mode = ctx->dst_fmt->codec_mode;
1472 ctx->enc_dst_buf_size = pix_fmt_mp->plane_fmt[0].sizeimage;
1473 pix_fmt_mp->plane_fmt[0].bytesperline = 0;
1474 ctx->dst_bufs_cnt = 0;
1475 ctx->capture_state = QUEUE_FREE;
1476 ret = s5p_mfc_open_mfc_inst(dev, ctx);
1477 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1478 /* src_fmt is validated by call to vidioc_try_fmt */
1479 ctx->src_fmt = find_format(f, MFC_FMT_RAW);
1480 ctx->img_width = pix_fmt_mp->width;
1481 ctx->img_height = pix_fmt_mp->height;
1482 mfc_debug(2, "codec number: %d\n", ctx->src_fmt->codec_mode);
1483 mfc_debug(2, "fmt - w: %d, h: %d, ctx - w: %d, h: %d\n",
1484 pix_fmt_mp->width, pix_fmt_mp->height,
1485 ctx->img_width, ctx->img_height);
1487 s5p_mfc_hw_call(dev->mfc_ops, enc_calc_src_size, ctx);
1488 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1489 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1490 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1491 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1493 ctx->src_bufs_cnt = 0;
1494 ctx->output_state = QUEUE_FREE;
1496 mfc_err("invalid buf type\n");
1504 static int vidioc_reqbufs(struct file *file, void *priv,
1505 struct v4l2_requestbuffers *reqbufs)
1507 struct s5p_mfc_dev *dev = video_drvdata(file);
1508 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1511 /* if memory is not mmp or userptr return error */
1512 if ((reqbufs->memory != V4L2_MEMORY_MMAP) &&
1513 (reqbufs->memory != V4L2_MEMORY_USERPTR))
1515 if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1516 if (reqbufs->count == 0) {
1517 mfc_debug(2, "Freeing buffers\n");
1518 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1519 s5p_mfc_hw_call(dev->mfc_ops, release_codec_buffers,
1521 ctx->capture_state = QUEUE_FREE;
1524 if (ctx->capture_state != QUEUE_FREE) {
1525 mfc_err("invalid capture state: %d\n",
1526 ctx->capture_state);
1529 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1531 mfc_err("error in vb2_reqbufs() for E(D)\n");
1534 ctx->capture_state = QUEUE_BUFS_REQUESTED;
1536 ret = s5p_mfc_hw_call(ctx->dev->mfc_ops,
1537 alloc_codec_buffers, ctx);
1539 mfc_err("Failed to allocate encoding buffers\n");
1541 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1544 } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1545 if (reqbufs->count == 0) {
1546 mfc_debug(2, "Freeing buffers\n");
1547 ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1548 s5p_mfc_hw_call(dev->mfc_ops, release_codec_buffers,
1550 ctx->output_state = QUEUE_FREE;
1553 if (ctx->output_state != QUEUE_FREE) {
1554 mfc_err("invalid output state: %d\n",
1559 if (IS_MFCV6_PLUS(dev)) {
1560 /* Check for min encoder buffers */
1561 if (ctx->pb_count &&
1562 (reqbufs->count < ctx->pb_count)) {
1563 reqbufs->count = ctx->pb_count;
1564 mfc_debug(2, "Minimum %d output buffers needed\n",
1567 ctx->pb_count = reqbufs->count;
1571 ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1573 mfc_err("error in vb2_reqbufs() for E(S)\n");
1576 ctx->output_state = QUEUE_BUFS_REQUESTED;
1578 mfc_err("invalid buf type\n");
1584 static int vidioc_querybuf(struct file *file, void *priv,
1585 struct v4l2_buffer *buf)
1587 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1590 /* if memory is not mmp or userptr return error */
1591 if ((buf->memory != V4L2_MEMORY_MMAP) &&
1592 (buf->memory != V4L2_MEMORY_USERPTR))
1594 if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1595 if (ctx->state != MFCINST_GOT_INST) {
1596 mfc_err("invalid context state: %d\n", ctx->state);
1599 ret = vb2_querybuf(&ctx->vq_dst, buf);
1601 mfc_err("error in vb2_querybuf() for E(D)\n");
1604 buf->m.planes[0].m.mem_offset += DST_QUEUE_OFF_BASE;
1605 } else if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1606 ret = vb2_querybuf(&ctx->vq_src, buf);
1608 mfc_err("error in vb2_querybuf() for E(S)\n");
1612 mfc_err("invalid buf type\n");
1618 /* Queue a buffer */
1619 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1621 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1623 if (ctx->state == MFCINST_ERROR) {
1624 mfc_err("Call on QBUF after unrecoverable error\n");
1627 if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1628 if (ctx->state == MFCINST_FINISHING) {
1629 mfc_err("Call on QBUF after EOS command\n");
1632 return vb2_qbuf(&ctx->vq_src, buf);
1633 } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1634 return vb2_qbuf(&ctx->vq_dst, buf);
1639 /* Dequeue a buffer */
1640 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1642 const struct v4l2_event ev = {
1643 .type = V4L2_EVENT_EOS
1645 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1648 if (ctx->state == MFCINST_ERROR) {
1649 mfc_err_limited("Call on DQBUF after unrecoverable error\n");
1652 if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1653 ret = vb2_dqbuf(&ctx->vq_src, buf, file->f_flags & O_NONBLOCK);
1654 } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1655 ret = vb2_dqbuf(&ctx->vq_dst, buf, file->f_flags & O_NONBLOCK);
1656 if (ret == 0 && ctx->state == MFCINST_FINISHED
1657 && list_empty(&ctx->vq_dst.done_list))
1658 v4l2_event_queue_fh(&ctx->fh, &ev);
1666 /* Export DMA buffer */
1667 static int vidioc_expbuf(struct file *file, void *priv,
1668 struct v4l2_exportbuffer *eb)
1670 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1672 if (eb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1673 return vb2_expbuf(&ctx->vq_src, eb);
1674 if (eb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1675 return vb2_expbuf(&ctx->vq_dst, eb);
1680 static int vidioc_streamon(struct file *file, void *priv,
1681 enum v4l2_buf_type type)
1683 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1685 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1686 return vb2_streamon(&ctx->vq_src, type);
1687 else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1688 return vb2_streamon(&ctx->vq_dst, type);
1692 /* Stream off, which equals to a pause */
1693 static int vidioc_streamoff(struct file *file, void *priv,
1694 enum v4l2_buf_type type)
1696 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1698 if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1699 return vb2_streamoff(&ctx->vq_src, type);
1700 else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1701 return vb2_streamoff(&ctx->vq_dst, type);
1705 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl)
1707 static unsigned int t[V4L2_MPEG_VIDEO_H264_LEVEL_4_0 + 1] = {
1708 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0 */ 10,
1709 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B */ 9,
1710 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1 */ 11,
1711 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2 */ 12,
1712 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3 */ 13,
1713 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0 */ 20,
1714 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1 */ 21,
1715 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2 */ 22,
1716 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0 */ 30,
1717 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1 */ 31,
1718 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2 */ 32,
1719 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0 */ 40,
1724 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl)
1726 static unsigned int t[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 + 1] = {
1727 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0 */ 0,
1728 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B */ 9,
1729 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1 */ 1,
1730 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2 */ 2,
1731 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3 */ 3,
1732 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B */ 7,
1733 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4 */ 4,
1734 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 */ 5,
1739 static inline int hevc_level(enum v4l2_mpeg_video_hevc_level lvl)
1741 static unsigned int t[] = {
1742 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_1 */ 10,
1743 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_2 */ 20,
1744 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_2_1 */ 21,
1745 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_3 */ 30,
1746 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_3_1 */ 31,
1747 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_4 */ 40,
1748 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_4_1 */ 41,
1749 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_5 */ 50,
1750 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_5_1 */ 51,
1751 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_5_2 */ 52,
1752 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_6 */ 60,
1753 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_6_1 */ 61,
1754 /* V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2 */ 62,
1759 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar)
1761 static unsigned int t[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED + 1] = {
1762 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED */ 0,
1763 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1 */ 1,
1764 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11 */ 2,
1765 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11 */ 3,
1766 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11 */ 4,
1767 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33 */ 5,
1768 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11 */ 6,
1769 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11 */ 7,
1770 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11 */ 8,
1771 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33 */ 9,
1772 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11 */ 10,
1773 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11 */ 11,
1774 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33 */ 12,
1775 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99 */ 13,
1776 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3 */ 14,
1777 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2 */ 15,
1778 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1 */ 16,
1779 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED */ 255,
1785 * Update range of all HEVC quantization parameter controls that depend on the
1786 * V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP, V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP controls.
1788 static void __enc_update_hevc_qp_ctrls_range(struct s5p_mfc_ctx *ctx,
1791 static const int __hevc_qp_ctrls[] = {
1792 V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP,
1793 V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP,
1794 V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP,
1795 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP,
1796 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP,
1797 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP,
1798 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP,
1799 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP,
1800 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP,
1801 V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP,
1803 struct v4l2_ctrl *ctrl = NULL;
1806 for (i = 0; i < ARRAY_SIZE(__hevc_qp_ctrls); i++) {
1807 for (j = 0; j < ARRAY_SIZE(ctx->ctrls); j++) {
1808 if (ctx->ctrls[j]->id == __hevc_qp_ctrls[i]) {
1809 ctrl = ctx->ctrls[j];
1816 __v4l2_ctrl_modify_range(ctrl, min, max, ctrl->step, min);
1820 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
1822 struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1823 struct s5p_mfc_dev *dev = ctx->dev;
1824 struct s5p_mfc_enc_params *p = &ctx->enc_params;
1828 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1829 p->gop_size = ctrl->val;
1831 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1832 p->slice_mode = ctrl->val;
1834 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1835 p->slice_mb = ctrl->val;
1837 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
1838 p->slice_bit = ctrl->val * 8;
1840 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1841 p->intra_refresh_mb = ctrl->val;
1843 case V4L2_CID_MPEG_MFC51_VIDEO_PADDING:
1846 case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV:
1847 p->pad_luma = (ctrl->val >> 16) & 0xff;
1848 p->pad_cb = (ctrl->val >> 8) & 0xff;
1849 p->pad_cr = (ctrl->val >> 0) & 0xff;
1851 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1852 p->rc_frame = ctrl->val;
1854 case V4L2_CID_MPEG_VIDEO_BITRATE:
1855 p->rc_bitrate = ctrl->val;
1857 case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF:
1858 p->rc_reaction_coeff = ctrl->val;
1860 case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1861 ctx->force_frame_type = ctrl->val;
1863 case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
1864 ctx->force_frame_type =
1865 V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME;
1867 case V4L2_CID_MPEG_VIDEO_VBV_SIZE:
1868 p->vbv_size = ctrl->val;
1870 case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1871 p->mv_h_range = ctrl->val;
1873 case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1874 p->mv_v_range = ctrl->val;
1876 case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
1877 p->codec.h264.cpb_size = ctrl->val;
1879 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1880 p->seq_hdr_mode = ctrl->val;
1882 case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1883 p->frame_skip_mode = ctrl->val;
1885 case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT:
1886 p->fixed_target_bit = ctrl->val;
1888 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1889 p->num_b_frame = ctrl->val;
1891 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1892 switch (ctrl->val) {
1893 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1894 p->codec.h264.profile =
1895 S5P_FIMV_ENC_PROFILE_H264_MAIN;
1897 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1898 p->codec.h264.profile =
1899 S5P_FIMV_ENC_PROFILE_H264_HIGH;
1901 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1902 p->codec.h264.profile =
1903 S5P_FIMV_ENC_PROFILE_H264_BASELINE;
1905 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1906 if (IS_MFCV6_PLUS(dev))
1907 p->codec.h264.profile =
1908 S5P_FIMV_ENC_PROFILE_H264_CONSTRAINED_BASELINE;
1916 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1917 p->codec.h264.level_v4l2 = ctrl->val;
1918 p->codec.h264.level = h264_level(ctrl->val);
1919 if (p->codec.h264.level < 0) {
1920 mfc_err("Level number is wrong\n");
1921 ret = p->codec.h264.level;
1924 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1925 p->codec.mpeg4.level_v4l2 = ctrl->val;
1926 p->codec.mpeg4.level = mpeg4_level(ctrl->val);
1927 if (p->codec.mpeg4.level < 0) {
1928 mfc_err("Level number is wrong\n");
1929 ret = p->codec.mpeg4.level;
1932 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1933 p->codec.h264.loop_filter_mode = ctrl->val;
1935 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1936 p->codec.h264.loop_filter_alpha = ctrl->val;
1938 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1939 p->codec.h264.loop_filter_beta = ctrl->val;
1941 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1942 p->codec.h264.entropy_mode = ctrl->val;
1944 case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P:
1945 p->codec.h264.num_ref_pic_4p = ctrl->val;
1947 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1948 p->codec.h264._8x8_transform = ctrl->val;
1950 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1951 p->rc_mb = ctrl->val;
1953 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1954 p->codec.h264.rc_frame_qp = ctrl->val;
1956 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1957 p->codec.h264.rc_min_qp = ctrl->val;
1959 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1960 p->codec.h264.rc_max_qp = ctrl->val;
1962 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1963 p->codec.h264.rc_p_frame_qp = ctrl->val;
1965 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
1966 p->codec.h264.rc_b_frame_qp = ctrl->val;
1968 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1969 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:
1970 p->codec.mpeg4.rc_frame_qp = ctrl->val;
1972 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:
1973 case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:
1974 p->codec.mpeg4.rc_min_qp = ctrl->val;
1976 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:
1977 case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:
1978 p->codec.mpeg4.rc_max_qp = ctrl->val;
1980 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1981 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:
1982 p->codec.mpeg4.rc_p_frame_qp = ctrl->val;
1984 case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:
1985 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:
1986 p->codec.mpeg4.rc_b_frame_qp = ctrl->val;
1988 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK:
1989 p->codec.h264.rc_mb_dark = ctrl->val;
1991 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH:
1992 p->codec.h264.rc_mb_smooth = ctrl->val;
1994 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC:
1995 p->codec.h264.rc_mb_static = ctrl->val;
1997 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY:
1998 p->codec.h264.rc_mb_activity = ctrl->val;
2000 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
2001 p->codec.h264.vui_sar = ctrl->val;
2003 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
2004 p->codec.h264.vui_sar_idc = vui_sar_idc(ctrl->val);
2006 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
2007 p->codec.h264.vui_ext_sar_width = ctrl->val;
2009 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
2010 p->codec.h264.vui_ext_sar_height = ctrl->val;
2012 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
2013 p->codec.h264.open_gop = !ctrl->val;
2015 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
2016 p->codec.h264.open_gop_size = ctrl->val;
2018 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
2019 switch (ctrl->val) {
2020 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
2021 p->codec.mpeg4.profile =
2022 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE;
2024 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
2025 p->codec.mpeg4.profile =
2026 S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE;
2032 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
2033 p->codec.mpeg4.quarter_pixel = ctrl->val;
2035 case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
2036 p->codec.vp8.num_partitions = ctrl->val;
2038 case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:
2039 p->codec.vp8.imd_4x4 = ctrl->val;
2041 case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
2042 p->codec.vp8.num_ref = ctrl->val;
2044 case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:
2045 p->codec.vp8.filter_level = ctrl->val;
2047 case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:
2048 p->codec.vp8.filter_sharpness = ctrl->val;
2050 case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:
2051 p->codec.vp8.golden_frame_ref_period = ctrl->val;
2053 case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
2054 p->codec.vp8.golden_frame_sel = ctrl->val;
2056 case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:
2057 p->codec.vp8.rc_min_qp = ctrl->val;
2059 case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:
2060 p->codec.vp8.rc_max_qp = ctrl->val;
2062 case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:
2063 p->codec.vp8.rc_frame_qp = ctrl->val;
2065 case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:
2066 p->codec.vp8.rc_p_frame_qp = ctrl->val;
2068 case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
2069 p->codec.vp8.profile = ctrl->val;
2071 case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:
2072 p->codec.hevc.rc_frame_qp = ctrl->val;
2074 case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP:
2075 p->codec.hevc.rc_p_frame_qp = ctrl->val;
2077 case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP:
2078 p->codec.hevc.rc_b_frame_qp = ctrl->val;
2080 case V4L2_CID_MPEG_VIDEO_HEVC_FRAME_RATE_RESOLUTION:
2081 p->codec.hevc.rc_framerate = ctrl->val;
2083 case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP:
2084 p->codec.hevc.rc_min_qp = ctrl->val;
2085 __enc_update_hevc_qp_ctrls_range(ctx, ctrl->val,
2086 p->codec.hevc.rc_max_qp);
2088 case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP:
2089 p->codec.hevc.rc_max_qp = ctrl->val;
2090 __enc_update_hevc_qp_ctrls_range(ctx, p->codec.hevc.rc_min_qp,
2093 case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
2094 p->codec.hevc.level_v4l2 = ctrl->val;
2095 p->codec.hevc.level = hevc_level(ctrl->val);
2097 case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
2098 switch (ctrl->val) {
2099 case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN:
2100 p->codec.hevc.profile =
2101 V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN;
2103 case V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE:
2104 p->codec.hevc.profile =
2105 V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE;
2111 case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
2112 p->codec.hevc.tier = ctrl->val;
2114 case V4L2_CID_MPEG_VIDEO_HEVC_MAX_PARTITION_DEPTH:
2115 p->codec.hevc.max_partition_depth = ctrl->val;
2117 case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES:
2118 p->codec.hevc.num_refs_for_p = ctrl->val;
2120 case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_TYPE:
2121 p->codec.hevc.refreshtype = ctrl->val;
2123 case V4L2_CID_MPEG_VIDEO_HEVC_CONST_INTRA_PRED:
2124 p->codec.hevc.const_intra_period_enable = ctrl->val;
2126 case V4L2_CID_MPEG_VIDEO_HEVC_LOSSLESS_CU:
2127 p->codec.hevc.lossless_cu_enable = ctrl->val;
2129 case V4L2_CID_MPEG_VIDEO_HEVC_WAVEFRONT:
2130 p->codec.hevc.wavefront_enable = ctrl->val;
2132 case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
2133 p->codec.hevc.loopfilter = ctrl->val;
2135 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_QP:
2136 p->codec.hevc.hier_qp_enable = ctrl->val;
2138 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_TYPE:
2139 p->codec.hevc.hier_qp_type = ctrl->val;
2141 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_LAYER:
2142 p->codec.hevc.num_hier_layer = ctrl->val;
2144 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_QP:
2145 p->codec.hevc.hier_qp_layer[0] = ctrl->val;
2147 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_QP:
2148 p->codec.hevc.hier_qp_layer[1] = ctrl->val;
2150 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_QP:
2151 p->codec.hevc.hier_qp_layer[2] = ctrl->val;
2153 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_QP:
2154 p->codec.hevc.hier_qp_layer[3] = ctrl->val;
2156 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_QP:
2157 p->codec.hevc.hier_qp_layer[4] = ctrl->val;
2159 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_QP:
2160 p->codec.hevc.hier_qp_layer[5] = ctrl->val;
2162 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_QP:
2163 p->codec.hevc.hier_qp_layer[6] = ctrl->val;
2165 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L0_BR:
2166 p->codec.hevc.hier_bit_layer[0] = ctrl->val;
2168 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L1_BR:
2169 p->codec.hevc.hier_bit_layer[1] = ctrl->val;
2171 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L2_BR:
2172 p->codec.hevc.hier_bit_layer[2] = ctrl->val;
2174 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L3_BR:
2175 p->codec.hevc.hier_bit_layer[3] = ctrl->val;
2177 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L4_BR:
2178 p->codec.hevc.hier_bit_layer[4] = ctrl->val;
2180 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L5_BR:
2181 p->codec.hevc.hier_bit_layer[5] = ctrl->val;
2183 case V4L2_CID_MPEG_VIDEO_HEVC_HIER_CODING_L6_BR:
2184 p->codec.hevc.hier_bit_layer[6] = ctrl->val;
2186 case V4L2_CID_MPEG_VIDEO_HEVC_GENERAL_PB:
2187 p->codec.hevc.general_pb_enable = ctrl->val;
2189 case V4L2_CID_MPEG_VIDEO_HEVC_TEMPORAL_ID:
2190 p->codec.hevc.temporal_id_enable = ctrl->val;
2192 case V4L2_CID_MPEG_VIDEO_HEVC_STRONG_SMOOTHING:
2193 p->codec.hevc.strong_intra_smooth = ctrl->val;
2195 case V4L2_CID_MPEG_VIDEO_HEVC_INTRA_PU_SPLIT:
2196 p->codec.hevc.intra_pu_split_disable = ctrl->val;
2198 case V4L2_CID_MPEG_VIDEO_HEVC_TMV_PREDICTION:
2199 p->codec.hevc.tmv_prediction_disable = !ctrl->val;
2201 case V4L2_CID_MPEG_VIDEO_HEVC_MAX_NUM_MERGE_MV_MINUS1:
2202 p->codec.hevc.max_num_merge_mv = ctrl->val;
2204 case V4L2_CID_MPEG_VIDEO_HEVC_WITHOUT_STARTCODE:
2205 p->codec.hevc.encoding_nostartcode_enable = ctrl->val;
2207 case V4L2_CID_MPEG_VIDEO_HEVC_REFRESH_PERIOD:
2208 p->codec.hevc.refreshperiod = ctrl->val;
2210 case V4L2_CID_MPEG_VIDEO_HEVC_LF_BETA_OFFSET_DIV2:
2211 p->codec.hevc.lf_beta_offset_div2 = ctrl->val;
2213 case V4L2_CID_MPEG_VIDEO_HEVC_LF_TC_OFFSET_DIV2:
2214 p->codec.hevc.lf_tc_offset_div2 = ctrl->val;
2216 case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
2217 p->codec.hevc.size_of_length_field = ctrl->val;
2219 case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR:
2220 p->codec.hevc.prepend_sps_pps_to_idr = ctrl->val;
2223 v4l2_err(&dev->v4l2_dev, "Invalid control, id=%d, val=%d\n",
2224 ctrl->id, ctrl->val);
2230 static int s5p_mfc_enc_g_v_ctrl(struct v4l2_ctrl *ctrl)
2232 struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
2233 struct s5p_mfc_dev *dev = ctx->dev;
2236 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
2237 if (ctx->state >= MFCINST_HEAD_PARSED &&
2238 ctx->state < MFCINST_ABORT) {
2239 ctrl->val = ctx->pb_count;
2241 } else if (ctx->state != MFCINST_INIT) {
2242 v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
2245 /* Should wait for the header to be produced */
2246 s5p_mfc_wait_for_done_ctx(ctx,
2247 S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0);
2248 if (ctx->state >= MFCINST_HEAD_PARSED &&
2249 ctx->state < MFCINST_ABORT) {
2250 ctrl->val = ctx->pb_count;
2252 v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
2260 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
2261 .s_ctrl = s5p_mfc_enc_s_ctrl,
2262 .g_volatile_ctrl = s5p_mfc_enc_g_v_ctrl,
2265 static int vidioc_s_parm(struct file *file, void *priv,
2266 struct v4l2_streamparm *a)
2268 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
2270 if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2271 ctx->enc_params.rc_framerate_num =
2272 a->parm.output.timeperframe.denominator;
2273 ctx->enc_params.rc_framerate_denom =
2274 a->parm.output.timeperframe.numerator;
2276 mfc_err("Setting FPS is only possible for the output queue\n");
2282 static int vidioc_g_parm(struct file *file, void *priv,
2283 struct v4l2_streamparm *a)
2285 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
2287 if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2288 a->parm.output.timeperframe.denominator =
2289 ctx->enc_params.rc_framerate_num;
2290 a->parm.output.timeperframe.numerator =
2291 ctx->enc_params.rc_framerate_denom;
2293 mfc_err("Setting FPS is only possible for the output queue\n");
2299 static int vidioc_encoder_cmd(struct file *file, void *priv,
2300 struct v4l2_encoder_cmd *cmd)
2302 struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
2303 struct s5p_mfc_dev *dev = ctx->dev;
2304 struct s5p_mfc_buf *buf;
2305 unsigned long flags;
2308 case V4L2_ENC_CMD_STOP:
2309 if (cmd->flags != 0)
2312 if (!ctx->vq_src.streaming)
2315 spin_lock_irqsave(&dev->irqlock, flags);
2316 if (list_empty(&ctx->src_queue)) {
2317 mfc_debug(2, "EOS: empty src queue, entering finishing state\n");
2318 ctx->state = MFCINST_FINISHING;
2319 if (s5p_mfc_ctx_ready(ctx))
2320 set_work_bit_irqsave(ctx);
2321 spin_unlock_irqrestore(&dev->irqlock, flags);
2322 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
2324 mfc_debug(2, "EOS: marking last buffer of stream\n");
2325 buf = list_entry(ctx->src_queue.prev,
2326 struct s5p_mfc_buf, list);
2327 if (buf->flags & MFC_BUF_FLAG_USED)
2328 ctx->state = MFCINST_FINISHING;
2330 buf->flags |= MFC_BUF_FLAG_EOS;
2331 spin_unlock_irqrestore(&dev->irqlock, flags);
2341 static int vidioc_subscribe_event(struct v4l2_fh *fh,
2342 const struct v4l2_event_subscription *sub)
2344 switch (sub->type) {
2345 case V4L2_EVENT_EOS:
2346 return v4l2_event_subscribe(fh, sub, 2, NULL);
2352 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops = {
2353 .vidioc_querycap = vidioc_querycap,
2354 .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_cap_mplane,
2355 .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_out_mplane,
2356 .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt,
2357 .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt,
2358 .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt,
2359 .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt,
2360 .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt,
2361 .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt,
2362 .vidioc_reqbufs = vidioc_reqbufs,
2363 .vidioc_querybuf = vidioc_querybuf,
2364 .vidioc_qbuf = vidioc_qbuf,
2365 .vidioc_dqbuf = vidioc_dqbuf,
2366 .vidioc_expbuf = vidioc_expbuf,
2367 .vidioc_streamon = vidioc_streamon,
2368 .vidioc_streamoff = vidioc_streamoff,
2369 .vidioc_s_parm = vidioc_s_parm,
2370 .vidioc_g_parm = vidioc_g_parm,
2371 .vidioc_encoder_cmd = vidioc_encoder_cmd,
2372 .vidioc_subscribe_event = vidioc_subscribe_event,
2373 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
2376 static int check_vb_with_fmt(struct s5p_mfc_fmt *fmt, struct vb2_buffer *vb)
2382 if (fmt->num_planes != vb->num_planes) {
2383 mfc_err("invalid plane number for the format\n");
2386 for (i = 0; i < fmt->num_planes; i++) {
2387 dma_addr_t dma = vb2_dma_contig_plane_dma_addr(vb, i);
2389 mfc_err("failed to get plane cookie\n");
2392 mfc_debug(2, "index: %d, plane[%d] cookie: %pad\n",
2393 vb->index, i, &dma);
2398 static int s5p_mfc_queue_setup(struct vb2_queue *vq,
2399 unsigned int *buf_count, unsigned int *plane_count,
2400 unsigned int psize[], struct device *alloc_devs[])
2402 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2403 struct s5p_mfc_dev *dev = ctx->dev;
2405 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2406 if (ctx->state != MFCINST_GOT_INST) {
2407 mfc_err("invalid state: %d\n", ctx->state);
2412 *plane_count = ctx->dst_fmt->num_planes;
2414 *plane_count = MFC_ENC_CAP_PLANE_COUNT;
2417 if (*buf_count > MFC_MAX_BUFFERS)
2418 *buf_count = MFC_MAX_BUFFERS;
2419 psize[0] = ctx->enc_dst_buf_size;
2420 alloc_devs[0] = ctx->dev->mem_dev[BANK_L_CTX];
2421 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2423 *plane_count = ctx->src_fmt->num_planes;
2425 *plane_count = MFC_ENC_OUT_PLANE_COUNT;
2429 if (*buf_count > MFC_MAX_BUFFERS)
2430 *buf_count = MFC_MAX_BUFFERS;
2432 psize[0] = ctx->luma_size;
2433 psize[1] = ctx->chroma_size;
2435 if (IS_MFCV6_PLUS(dev)) {
2436 alloc_devs[0] = ctx->dev->mem_dev[BANK_L_CTX];
2437 alloc_devs[1] = ctx->dev->mem_dev[BANK_L_CTX];
2439 alloc_devs[0] = ctx->dev->mem_dev[BANK_R_CTX];
2440 alloc_devs[1] = ctx->dev->mem_dev[BANK_R_CTX];
2443 mfc_err("invalid queue type: %d\n", vq->type);
2449 static int s5p_mfc_buf_init(struct vb2_buffer *vb)
2451 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
2452 struct vb2_queue *vq = vb->vb2_queue;
2453 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2457 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2458 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
2462 ctx->dst_bufs[i].b = vbuf;
2463 ctx->dst_bufs[i].cookie.stream =
2464 vb2_dma_contig_plane_dma_addr(vb, 0);
2465 ctx->dst_bufs_cnt++;
2466 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2467 ret = check_vb_with_fmt(ctx->src_fmt, vb);
2471 ctx->src_bufs[i].b = vbuf;
2472 ctx->src_bufs[i].cookie.raw.luma =
2473 vb2_dma_contig_plane_dma_addr(vb, 0);
2474 ctx->src_bufs[i].cookie.raw.chroma =
2475 vb2_dma_contig_plane_dma_addr(vb, 1);
2476 ctx->src_bufs_cnt++;
2478 mfc_err("invalid queue type: %d\n", vq->type);
2484 static int s5p_mfc_buf_prepare(struct vb2_buffer *vb)
2486 struct vb2_queue *vq = vb->vb2_queue;
2487 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2490 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2491 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
2494 mfc_debug(2, "plane size: %ld, dst size: %zu\n",
2495 vb2_plane_size(vb, 0), ctx->enc_dst_buf_size);
2496 if (vb2_plane_size(vb, 0) < ctx->enc_dst_buf_size) {
2497 mfc_err("plane size is too small for capture\n");
2500 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2501 ret = check_vb_with_fmt(ctx->src_fmt, vb);
2504 mfc_debug(2, "plane size: %ld, luma size: %d\n",
2505 vb2_plane_size(vb, 0), ctx->luma_size);
2506 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
2507 vb2_plane_size(vb, 1), ctx->chroma_size);
2508 if (vb2_plane_size(vb, 0) < ctx->luma_size ||
2509 vb2_plane_size(vb, 1) < ctx->chroma_size) {
2510 mfc_err("plane size is too small for output\n");
2514 mfc_err("invalid queue type: %d\n", vq->type);
2520 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count)
2522 struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
2523 struct s5p_mfc_dev *dev = ctx->dev;
2525 if (IS_MFCV6_PLUS(dev) &&
2526 (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)) {
2528 if ((ctx->state == MFCINST_GOT_INST) &&
2529 (dev->curr_ctx == ctx->num) && dev->hw_lock) {
2530 s5p_mfc_wait_for_done_ctx(ctx,
2531 S5P_MFC_R2H_CMD_SEQ_DONE_RET,
2535 if (ctx->src_bufs_cnt < ctx->pb_count) {
2536 mfc_err("Need minimum %d OUTPUT buffers\n",
2542 /* If context is ready then dev = work->data;schedule it to run */
2543 if (s5p_mfc_ctx_ready(ctx))
2544 set_work_bit_irqsave(ctx);
2545 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
2550 static void s5p_mfc_stop_streaming(struct vb2_queue *q)
2552 unsigned long flags;
2553 struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
2554 struct s5p_mfc_dev *dev = ctx->dev;
2556 if ((ctx->state == MFCINST_FINISHING ||
2557 ctx->state == MFCINST_RUNNING) &&
2558 dev->curr_ctx == ctx->num && dev->hw_lock) {
2559 ctx->state = MFCINST_ABORT;
2560 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_FRAME_DONE_RET,
2563 ctx->state = MFCINST_FINISHED;
2564 spin_lock_irqsave(&dev->irqlock, flags);
2565 if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2566 s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst);
2567 INIT_LIST_HEAD(&ctx->dst_queue);
2568 ctx->dst_queue_cnt = 0;
2570 if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2571 cleanup_ref_queue(ctx);
2572 s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src);
2573 INIT_LIST_HEAD(&ctx->src_queue);
2574 ctx->src_queue_cnt = 0;
2576 spin_unlock_irqrestore(&dev->irqlock, flags);
2579 static void s5p_mfc_buf_queue(struct vb2_buffer *vb)
2581 struct vb2_queue *vq = vb->vb2_queue;
2582 struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2583 struct s5p_mfc_dev *dev = ctx->dev;
2584 unsigned long flags;
2585 struct s5p_mfc_buf *mfc_buf;
2587 if (ctx->state == MFCINST_ERROR) {
2588 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2589 cleanup_ref_queue(ctx);
2592 if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2593 mfc_buf = &ctx->dst_bufs[vb->index];
2594 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2595 /* Mark destination as available for use by MFC */
2596 spin_lock_irqsave(&dev->irqlock, flags);
2597 list_add_tail(&mfc_buf->list, &ctx->dst_queue);
2598 ctx->dst_queue_cnt++;
2599 spin_unlock_irqrestore(&dev->irqlock, flags);
2600 } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2601 mfc_buf = &ctx->src_bufs[vb->index];
2602 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2603 spin_lock_irqsave(&dev->irqlock, flags);
2604 list_add_tail(&mfc_buf->list, &ctx->src_queue);
2605 ctx->src_queue_cnt++;
2606 spin_unlock_irqrestore(&dev->irqlock, flags);
2608 mfc_err("unsupported buffer type (%d)\n", vq->type);
2610 if (s5p_mfc_ctx_ready(ctx))
2611 set_work_bit_irqsave(ctx);
2612 s5p_mfc_hw_call(dev->mfc_ops, try_run, dev);
2615 static struct vb2_ops s5p_mfc_enc_qops = {
2616 .queue_setup = s5p_mfc_queue_setup,
2617 .wait_prepare = vb2_ops_wait_prepare,
2618 .wait_finish = vb2_ops_wait_finish,
2619 .buf_init = s5p_mfc_buf_init,
2620 .buf_prepare = s5p_mfc_buf_prepare,
2621 .start_streaming = s5p_mfc_start_streaming,
2622 .stop_streaming = s5p_mfc_stop_streaming,
2623 .buf_queue = s5p_mfc_buf_queue,
2626 const struct s5p_mfc_codec_ops *get_enc_codec_ops(void)
2628 return &encoder_codec_ops;
2631 struct vb2_ops *get_enc_queue_ops(void)
2633 return &s5p_mfc_enc_qops;
2636 const struct v4l2_ioctl_ops *get_enc_v4l2_ioctl_ops(void)
2638 return &s5p_mfc_enc_ioctl_ops;
2641 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2WHICH(x) == V4L2_CTRL_CLASS_MPEG) \
2642 && V4L2_CTRL_DRIVER_PRIV(x))
2644 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
2646 struct v4l2_ctrl_config cfg;
2649 v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS);
2650 if (ctx->ctrl_handler.error) {
2651 mfc_err("v4l2_ctrl_handler_init failed\n");
2652 return ctx->ctrl_handler.error;
2654 for (i = 0; i < NUM_CTRLS; i++) {
2655 if (IS_MFC51_PRIV(controls[i].id)) {
2656 memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
2657 cfg.ops = &s5p_mfc_enc_ctrl_ops;
2658 cfg.id = controls[i].id;
2659 cfg.min = controls[i].minimum;
2660 cfg.max = controls[i].maximum;
2661 cfg.def = controls[i].default_value;
2662 cfg.name = controls[i].name;
2663 cfg.type = controls[i].type;
2666 if (cfg.type == V4L2_CTRL_TYPE_MENU) {
2668 cfg.menu_skip_mask = controls[i].menu_skip_mask;
2669 cfg.qmenu = mfc51_get_menu(cfg.id);
2671 cfg.step = controls[i].step;
2672 cfg.menu_skip_mask = 0;
2674 ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler,
2677 if ((controls[i].type == V4L2_CTRL_TYPE_MENU) ||
2678 (controls[i].type ==
2679 V4L2_CTRL_TYPE_INTEGER_MENU)) {
2680 ctx->ctrls[i] = v4l2_ctrl_new_std_menu(
2682 &s5p_mfc_enc_ctrl_ops, controls[i].id,
2683 controls[i].maximum, 0,
2684 controls[i].default_value);
2686 ctx->ctrls[i] = v4l2_ctrl_new_std(
2688 &s5p_mfc_enc_ctrl_ops, controls[i].id,
2689 controls[i].minimum,
2690 controls[i].maximum, controls[i].step,
2691 controls[i].default_value);
2694 if (ctx->ctrl_handler.error) {
2695 mfc_err("Adding control (%d) failed\n", i);
2696 return ctx->ctrl_handler.error;
2698 if (controls[i].is_volatile && ctx->ctrls[i])
2699 ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
2701 v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
2705 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx *ctx)
2709 v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2710 for (i = 0; i < NUM_CTRLS; i++)
2711 ctx->ctrls[i] = NULL;
2714 void s5p_mfc_enc_init(struct s5p_mfc_ctx *ctx)
2716 struct v4l2_format f;
2717 f.fmt.pix_mp.pixelformat = DEF_SRC_FMT_ENC;
2718 ctx->src_fmt = find_format(&f, MFC_FMT_RAW);
2719 f.fmt.pix_mp.pixelformat = DEF_DST_FMT_ENC;
2720 ctx->dst_fmt = find_format(&f, MFC_FMT_ENC);