2 * linux/drivers/media/video/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/version.h>
23 #include <linux/videodev2.h>
24 #include <linux/workqueue.h>
25 #include <media/v4l2-ctrls.h>
26 #include <media/videobuf2-core.h>
28 #include "s5p_mfc_common.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 static struct s5p_mfc_fmt formats
[] = {
36 .name
= "4:2:0 2 Planes 64x32 Tiles",
37 .fourcc
= V4L2_PIX_FMT_NV12MT
,
38 .codec_mode
= S5P_FIMV_CODEC_NONE
,
43 .name
= "4:2:0 2 Planes",
44 .fourcc
= V4L2_PIX_FMT_NV12M
,
45 .codec_mode
= S5P_FIMV_CODEC_NONE
,
50 .name
= "H264 Encoded Stream",
51 .fourcc
= V4L2_PIX_FMT_H264
,
52 .codec_mode
= S5P_FIMV_CODEC_H264_ENC
,
57 .name
= "MPEG4 Encoded Stream",
58 .fourcc
= V4L2_PIX_FMT_MPEG4
,
59 .codec_mode
= S5P_FIMV_CODEC_MPEG4_ENC
,
64 .name
= "H264 Encoded Stream",
65 .fourcc
= V4L2_PIX_FMT_H263
,
66 .codec_mode
= S5P_FIMV_CODEC_H263_ENC
,
72 #define NUM_FORMATS ARRAY_SIZE(formats)
73 static struct s5p_mfc_fmt
*find_format(struct v4l2_format
*f
, unsigned int t
)
77 for (i
= 0; i
< NUM_FORMATS
; i
++) {
78 if (formats
[i
].fourcc
== f
->fmt
.pix_mp
.pixelformat
&&
85 static struct mfc_control controls
[] = {
87 .id
= V4L2_CID_MPEG_VIDEO_GOP_SIZE
,
88 .type
= V4L2_CTRL_TYPE_INTEGER
,
90 .maximum
= (1 << 16) - 1,
95 .id
= V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
,
96 .type
= V4L2_CTRL_TYPE_MENU
,
97 .minimum
= V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
,
98 .maximum
= V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES
,
99 .default_value
= V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE
,
103 .id
= V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
,
104 .type
= V4L2_CTRL_TYPE_INTEGER
,
106 .maximum
= (1 << 16) - 1,
111 .id
= V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
,
112 .type
= V4L2_CTRL_TYPE_INTEGER
,
114 .maximum
= (1 << 30) - 1,
116 .default_value
= 1900,
119 .id
= V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
,
120 .type
= V4L2_CTRL_TYPE_INTEGER
,
122 .maximum
= (1 << 16) - 1,
127 .id
= V4L2_CID_MPEG_MFC51_VIDEO_PADDING
,
128 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
129 .name
= "Padding Control Enable",
136 .id
= V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV
,
137 .type
= V4L2_CTRL_TYPE_INTEGER
,
138 .name
= "Padding Color YUV Value",
140 .maximum
= (1 << 25) - 1,
145 .id
= V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE
,
146 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
153 .id
= V4L2_CID_MPEG_VIDEO_BITRATE
,
154 .type
= V4L2_CTRL_TYPE_INTEGER
,
156 .maximum
= (1 << 30) - 1,
161 .id
= V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF
,
162 .type
= V4L2_CTRL_TYPE_INTEGER
,
163 .name
= "Rate Control Reaction Coeff.",
165 .maximum
= (1 << 16) - 1,
170 .id
= V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE
,
171 .type
= V4L2_CTRL_TYPE_MENU
,
172 .name
= "Force frame type",
173 .minimum
= V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED
,
174 .maximum
= V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED
,
175 .default_value
= V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED
,
179 .id
= V4L2_CID_MPEG_VIDEO_VBV_SIZE
,
180 .type
= V4L2_CTRL_TYPE_INTEGER
,
182 .maximum
= (1 << 16) - 1,
187 .id
= V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE
,
188 .type
= V4L2_CTRL_TYPE_INTEGER
,
190 .maximum
= (1 << 16) - 1,
195 .id
= V4L2_CID_MPEG_VIDEO_HEADER_MODE
,
196 .type
= V4L2_CTRL_TYPE_MENU
,
197 .minimum
= V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
,
198 .maximum
= V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME
,
199 .default_value
= V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
,
203 .id
= V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE
,
204 .type
= V4L2_CTRL_TYPE_MENU
,
205 .name
= "Frame Skip Enable",
206 .minimum
= V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED
,
207 .maximum
= V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT
,
209 .default_value
= V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED
,
212 .id
= V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT
,
213 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
214 .name
= "Fixed Target Bit Enable",
221 .id
= V4L2_CID_MPEG_VIDEO_B_FRAMES
,
222 .type
= V4L2_CTRL_TYPE_INTEGER
,
229 .id
= V4L2_CID_MPEG_VIDEO_H264_PROFILE
,
230 .type
= V4L2_CTRL_TYPE_MENU
,
231 .minimum
= V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE
,
232 .maximum
= V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH
,
233 .default_value
= V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE
,
235 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE
) |
236 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN
) |
237 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH
)
241 .id
= V4L2_CID_MPEG_VIDEO_H264_LEVEL
,
242 .type
= V4L2_CTRL_TYPE_MENU
,
243 .minimum
= V4L2_MPEG_VIDEO_H264_LEVEL_1_0
,
244 .maximum
= V4L2_MPEG_VIDEO_H264_LEVEL_4_0
,
245 .default_value
= V4L2_MPEG_VIDEO_H264_LEVEL_1_0
,
247 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_1
) |
248 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_4_2
) |
249 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_5_0
) |
250 (1 << V4L2_MPEG_VIDEO_H264_LEVEL_5_1
)
254 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL
,
255 .type
= V4L2_CTRL_TYPE_MENU
,
256 .minimum
= V4L2_MPEG_VIDEO_MPEG4_LEVEL_0
,
257 .maximum
= V4L2_MPEG_VIDEO_MPEG4_LEVEL_5
,
258 .default_value
= V4L2_MPEG_VIDEO_MPEG4_LEVEL_0
,
262 .id
= V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
,
263 .type
= V4L2_CTRL_TYPE_MENU
,
264 .minimum
= V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
,
265 .maximum
= V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
,
266 .default_value
= V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED
,
270 .id
= V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
,
271 .type
= V4L2_CTRL_TYPE_INTEGER
,
278 .id
= V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
,
279 .type
= V4L2_CTRL_TYPE_INTEGER
,
286 .id
= V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE
,
287 .type
= V4L2_CTRL_TYPE_MENU
,
288 .minimum
= V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC
,
289 .maximum
= V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC
,
290 .default_value
= V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC
,
294 .id
= V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P
,
295 .type
= V4L2_CTRL_TYPE_INTEGER
,
296 .name
= "The Number of Ref. Pic for P",
303 .id
= V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM
,
304 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
311 .id
= V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE
,
312 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
319 .id
= V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
,
320 .type
= V4L2_CTRL_TYPE_INTEGER
,
327 .id
= V4L2_CID_MPEG_VIDEO_H264_MIN_QP
,
328 .type
= V4L2_CTRL_TYPE_INTEGER
,
335 .id
= V4L2_CID_MPEG_VIDEO_H264_MAX_QP
,
336 .type
= V4L2_CTRL_TYPE_INTEGER
,
343 .id
= V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
,
344 .type
= V4L2_CTRL_TYPE_INTEGER
,
351 .id
= V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP
,
352 .type
= V4L2_CTRL_TYPE_INTEGER
,
359 .id
= V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP
,
360 .type
= V4L2_CTRL_TYPE_INTEGER
,
361 .name
= "H263 I-Frame QP value",
368 .id
= V4L2_CID_MPEG_VIDEO_H263_MIN_QP
,
369 .type
= V4L2_CTRL_TYPE_INTEGER
,
370 .name
= "H263 Minimum QP value",
377 .id
= V4L2_CID_MPEG_VIDEO_H263_MAX_QP
,
378 .type
= V4L2_CTRL_TYPE_INTEGER
,
379 .name
= "H263 Maximum QP value",
386 .id
= V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP
,
387 .type
= V4L2_CTRL_TYPE_INTEGER
,
388 .name
= "H263 P frame QP value",
395 .id
= V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP
,
396 .type
= V4L2_CTRL_TYPE_INTEGER
,
397 .name
= "H263 B frame QP value",
404 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
,
405 .type
= V4L2_CTRL_TYPE_INTEGER
,
406 .name
= "MPEG4 I-Frame QP value",
413 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP
,
414 .type
= V4L2_CTRL_TYPE_INTEGER
,
415 .name
= "MPEG4 Minimum QP value",
422 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP
,
423 .type
= V4L2_CTRL_TYPE_INTEGER
,
424 .name
= "MPEG4 Maximum QP value",
431 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
,
432 .type
= V4L2_CTRL_TYPE_INTEGER
,
433 .name
= "MPEG4 P frame QP value",
440 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP
,
441 .type
= V4L2_CTRL_TYPE_INTEGER
,
442 .name
= "MPEG4 B frame QP value",
449 .id
= V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK
,
450 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
451 .name
= "H264 Dark Reg Adaptive RC",
458 .id
= V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH
,
459 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
460 .name
= "H264 Smooth Reg Adaptive RC",
467 .id
= V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC
,
468 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
469 .name
= "H264 Static Reg Adaptive RC",
476 .id
= V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY
,
477 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
478 .name
= "H264 Activity Reg Adaptive RC",
485 .id
= V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE
,
486 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
493 .id
= V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC
,
494 .type
= V4L2_CTRL_TYPE_MENU
,
495 .minimum
= V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED
,
496 .maximum
= V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED
,
501 .id
= V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH
,
502 .type
= V4L2_CTRL_TYPE_INTEGER
,
504 .maximum
= (1 << 16) - 1,
509 .id
= V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT
,
510 .type
= V4L2_CTRL_TYPE_INTEGER
,
512 .maximum
= (1 << 16) - 1,
517 .id
= V4L2_CID_MPEG_VIDEO_GOP_CLOSURE
,
518 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
525 .id
= V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
,
526 .type
= V4L2_CTRL_TYPE_INTEGER
,
528 .maximum
= (1 << 16) - 1,
533 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE
,
534 .type
= V4L2_CTRL_TYPE_MENU
,
535 .minimum
= V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE
,
536 .maximum
= V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE
,
541 .id
= V4L2_CID_MPEG_VIDEO_MPEG4_QPEL
,
542 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
550 #define NUM_CTRLS ARRAY_SIZE(controls)
551 static const char * const *mfc51_get_menu(u32 id
)
553 static const char * const mfc51_video_frame_skip
[] = {
559 static const char * const mfc51_video_force_frame
[] = {
566 case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE
:
567 return mfc51_video_frame_skip
;
568 case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE
:
569 return mfc51_video_force_frame
;
574 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx
*ctx
)
576 mfc_debug(2, "src=%d, dst=%d, state=%d\n",
577 ctx
->src_queue_cnt
, ctx
->dst_queue_cnt
, ctx
->state
);
578 /* context is ready to make header */
579 if (ctx
->state
== MFCINST_GOT_INST
&& ctx
->dst_queue_cnt
>= 1)
581 /* context is ready to encode a frame */
582 if (ctx
->state
== MFCINST_RUNNING
&&
583 ctx
->src_queue_cnt
>= 1 && ctx
->dst_queue_cnt
>= 1)
585 /* context is ready to encode remain frames */
586 if (ctx
->state
== MFCINST_FINISHING
&&
587 ctx
->src_queue_cnt
>= 1 && ctx
->dst_queue_cnt
>= 1)
589 mfc_debug(2, "ctx is not ready\n");
593 static void cleanup_ref_queue(struct s5p_mfc_ctx
*ctx
)
595 struct s5p_mfc_buf
*mb_entry
;
596 unsigned long mb_y_addr
, mb_c_addr
;
598 /* move buffers in ref queue to src queue */
599 while (!list_empty(&ctx
->ref_queue
)) {
600 mb_entry
= list_entry((&ctx
->ref_queue
)->next
,
601 struct s5p_mfc_buf
, list
);
602 mb_y_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 0);
603 mb_c_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 1);
604 list_del(&mb_entry
->list
);
605 ctx
->ref_queue_cnt
--;
606 list_add_tail(&mb_entry
->list
, &ctx
->src_queue
);
607 ctx
->src_queue_cnt
++;
609 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
610 ctx
->src_queue_cnt
, ctx
->ref_queue_cnt
);
611 INIT_LIST_HEAD(&ctx
->ref_queue
);
612 ctx
->ref_queue_cnt
= 0;
615 static int enc_pre_seq_start(struct s5p_mfc_ctx
*ctx
)
617 struct s5p_mfc_dev
*dev
= ctx
->dev
;
618 struct s5p_mfc_buf
*dst_mb
;
619 unsigned long dst_addr
;
620 unsigned int dst_size
;
623 spin_lock_irqsave(&dev
->irqlock
, flags
);
624 dst_mb
= list_entry(ctx
->dst_queue
.next
, struct s5p_mfc_buf
, list
);
625 dst_addr
= vb2_dma_contig_plane_paddr(dst_mb
->b
, 0);
626 dst_size
= vb2_plane_size(dst_mb
->b
, 0);
627 s5p_mfc_set_enc_stream_buffer(ctx
, dst_addr
, dst_size
);
628 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
632 static int enc_post_seq_start(struct s5p_mfc_ctx
*ctx
)
634 struct s5p_mfc_dev
*dev
= ctx
->dev
;
635 struct s5p_mfc_enc_params
*p
= &ctx
->enc_params
;
636 struct s5p_mfc_buf
*dst_mb
;
639 if (p
->seq_hdr_mode
== V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE
) {
640 spin_lock_irqsave(&dev
->irqlock
, flags
);
641 dst_mb
= list_entry(ctx
->dst_queue
.next
,
642 struct s5p_mfc_buf
, list
);
643 list_del(&dst_mb
->list
);
644 ctx
->dst_queue_cnt
--;
645 vb2_set_plane_payload(dst_mb
->b
, 0,
646 s5p_mfc_get_enc_strm_size());
647 vb2_buffer_done(dst_mb
->b
, VB2_BUF_STATE_DONE
);
648 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
650 ctx
->state
= MFCINST_RUNNING
;
651 if (s5p_mfc_ctx_ready(ctx
)) {
652 spin_lock_irqsave(&dev
->condlock
, flags
);
653 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
654 spin_unlock_irqrestore(&dev
->condlock
, flags
);
656 s5p_mfc_try_run(dev
);
660 static int enc_pre_frame_start(struct s5p_mfc_ctx
*ctx
)
662 struct s5p_mfc_dev
*dev
= ctx
->dev
;
663 struct s5p_mfc_buf
*dst_mb
;
664 struct s5p_mfc_buf
*src_mb
;
666 unsigned long src_y_addr
, src_c_addr
, dst_addr
;
667 unsigned int dst_size
;
669 spin_lock_irqsave(&dev
->irqlock
, flags
);
670 src_mb
= list_entry(ctx
->src_queue
.next
, struct s5p_mfc_buf
, list
);
671 src_y_addr
= vb2_dma_contig_plane_paddr(src_mb
->b
, 0);
672 src_c_addr
= vb2_dma_contig_plane_paddr(src_mb
->b
, 1);
673 s5p_mfc_set_enc_frame_buffer(ctx
, src_y_addr
, src_c_addr
);
674 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
676 spin_lock_irqsave(&dev
->irqlock
, flags
);
677 dst_mb
= list_entry(ctx
->dst_queue
.next
, struct s5p_mfc_buf
, list
);
678 dst_addr
= vb2_dma_contig_plane_paddr(dst_mb
->b
, 0);
679 dst_size
= vb2_plane_size(dst_mb
->b
, 0);
680 s5p_mfc_set_enc_stream_buffer(ctx
, dst_addr
, dst_size
);
681 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
686 static int enc_post_frame_start(struct s5p_mfc_ctx
*ctx
)
688 struct s5p_mfc_dev
*dev
= ctx
->dev
;
689 struct s5p_mfc_buf
*mb_entry
;
690 unsigned long enc_y_addr
, enc_c_addr
;
691 unsigned long mb_y_addr
, mb_c_addr
;
693 unsigned int strm_size
;
696 slice_type
= s5p_mfc_get_enc_slice_type();
697 strm_size
= s5p_mfc_get_enc_strm_size();
698 mfc_debug(2, "Encoded slice type: %d", slice_type
);
699 mfc_debug(2, "Encoded stream size: %d", strm_size
);
700 mfc_debug(2, "Display order: %d",
701 mfc_read(dev
, S5P_FIMV_ENC_SI_PIC_CNT
));
702 spin_lock_irqsave(&dev
->irqlock
, flags
);
703 if (slice_type
>= 0) {
704 s5p_mfc_get_enc_frame_buffer(ctx
, &enc_y_addr
, &enc_c_addr
);
705 list_for_each_entry(mb_entry
, &ctx
->src_queue
, list
) {
706 mb_y_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 0);
707 mb_c_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 1);
708 if ((enc_y_addr
== mb_y_addr
) &&
709 (enc_c_addr
== mb_c_addr
)) {
710 list_del(&mb_entry
->list
);
711 ctx
->src_queue_cnt
--;
712 vb2_buffer_done(mb_entry
->b
,
717 list_for_each_entry(mb_entry
, &ctx
->ref_queue
, list
) {
718 mb_y_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 0);
719 mb_c_addr
= vb2_dma_contig_plane_paddr(mb_entry
->b
, 1);
720 if ((enc_y_addr
== mb_y_addr
) &&
721 (enc_c_addr
== mb_c_addr
)) {
722 list_del(&mb_entry
->list
);
723 ctx
->ref_queue_cnt
--;
724 vb2_buffer_done(mb_entry
->b
,
730 if ((ctx
->src_queue_cnt
> 0) && (ctx
->state
== MFCINST_RUNNING
)) {
731 mb_entry
= list_entry(ctx
->src_queue
.next
, struct s5p_mfc_buf
,
733 if (mb_entry
->used
) {
734 list_del(&mb_entry
->list
);
735 ctx
->src_queue_cnt
--;
736 list_add_tail(&mb_entry
->list
, &ctx
->ref_queue
);
737 ctx
->ref_queue_cnt
++;
739 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
740 ctx
->src_queue_cnt
, ctx
->ref_queue_cnt
);
743 /* at least one more dest. buffers exist always */
744 mb_entry
= list_entry(ctx
->dst_queue
.next
, struct s5p_mfc_buf
,
746 list_del(&mb_entry
->list
);
747 ctx
->dst_queue_cnt
--;
748 switch (slice_type
) {
749 case S5P_FIMV_ENC_SI_SLICE_TYPE_I
:
750 mb_entry
->b
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_KEYFRAME
;
752 case S5P_FIMV_ENC_SI_SLICE_TYPE_P
:
753 mb_entry
->b
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_PFRAME
;
755 case S5P_FIMV_ENC_SI_SLICE_TYPE_B
:
756 mb_entry
->b
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_BFRAME
;
759 vb2_set_plane_payload(mb_entry
->b
, 0, strm_size
);
760 vb2_buffer_done(mb_entry
->b
, VB2_BUF_STATE_DONE
);
762 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
763 if ((ctx
->src_queue_cnt
== 0) || (ctx
->dst_queue_cnt
== 0)) {
764 spin_lock(&dev
->condlock
);
765 clear_bit(ctx
->num
, &dev
->ctx_work_bits
);
766 spin_unlock(&dev
->condlock
);
771 static struct s5p_mfc_codec_ops encoder_codec_ops
= {
772 .pre_seq_start
= enc_pre_seq_start
,
773 .post_seq_start
= enc_post_seq_start
,
774 .pre_frame_start
= enc_pre_frame_start
,
775 .post_frame_start
= enc_post_frame_start
,
778 /* Query capabilities of the device */
779 static int vidioc_querycap(struct file
*file
, void *priv
,
780 struct v4l2_capability
*cap
)
782 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
784 strncpy(cap
->driver
, dev
->plat_dev
->name
, sizeof(cap
->driver
) - 1);
785 strncpy(cap
->card
, dev
->plat_dev
->name
, sizeof(cap
->card
) - 1);
786 cap
->bus_info
[0] = 0;
787 cap
->version
= KERNEL_VERSION(1, 0, 0);
788 cap
->capabilities
= V4L2_CAP_VIDEO_CAPTURE
789 | V4L2_CAP_VIDEO_OUTPUT
790 | V4L2_CAP_STREAMING
;
794 static int vidioc_enum_fmt(struct v4l2_fmtdesc
*f
, bool mplane
, bool out
)
796 struct s5p_mfc_fmt
*fmt
;
799 for (i
= 0; i
< ARRAY_SIZE(formats
); ++i
) {
800 if (mplane
&& formats
[i
].num_planes
== 1)
802 else if (!mplane
&& formats
[i
].num_planes
> 1)
804 if (out
&& formats
[i
].type
!= MFC_FMT_RAW
)
806 else if (!out
&& formats
[i
].type
!= MFC_FMT_ENC
)
810 strlcpy(f
->description
, fmt
->name
,
811 sizeof(f
->description
));
812 f
->pixelformat
= fmt
->fourcc
;
820 static int vidioc_enum_fmt_vid_cap(struct file
*file
, void *pirv
,
821 struct v4l2_fmtdesc
*f
)
823 return vidioc_enum_fmt(f
, false, false);
826 static int vidioc_enum_fmt_vid_cap_mplane(struct file
*file
, void *pirv
,
827 struct v4l2_fmtdesc
*f
)
829 return vidioc_enum_fmt(f
, true, false);
832 static int vidioc_enum_fmt_vid_out(struct file
*file
, void *prov
,
833 struct v4l2_fmtdesc
*f
)
835 return vidioc_enum_fmt(f
, false, true);
838 static int vidioc_enum_fmt_vid_out_mplane(struct file
*file
, void *prov
,
839 struct v4l2_fmtdesc
*f
)
841 return vidioc_enum_fmt(f
, true, true);
844 static int vidioc_g_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
846 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
847 struct v4l2_pix_format_mplane
*pix_fmt_mp
= &f
->fmt
.pix_mp
;
849 mfc_debug(2, "f->type = %d ctx->state = %d\n", f
->type
, ctx
->state
);
850 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
851 /* This is run on output (encoder dest) */
852 pix_fmt_mp
->width
= 0;
853 pix_fmt_mp
->height
= 0;
854 pix_fmt_mp
->field
= V4L2_FIELD_NONE
;
855 pix_fmt_mp
->pixelformat
= ctx
->dst_fmt
->fourcc
;
856 pix_fmt_mp
->num_planes
= ctx
->dst_fmt
->num_planes
;
858 pix_fmt_mp
->plane_fmt
[0].bytesperline
= ctx
->enc_dst_buf_size
;
859 pix_fmt_mp
->plane_fmt
[0].sizeimage
= ctx
->enc_dst_buf_size
;
860 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
861 /* This is run on capture (encoder src) */
862 pix_fmt_mp
->width
= ctx
->img_width
;
863 pix_fmt_mp
->height
= ctx
->img_height
;
865 pix_fmt_mp
->field
= V4L2_FIELD_NONE
;
866 pix_fmt_mp
->pixelformat
= ctx
->src_fmt
->fourcc
;
867 pix_fmt_mp
->num_planes
= ctx
->src_fmt
->num_planes
;
869 pix_fmt_mp
->plane_fmt
[0].bytesperline
= ctx
->buf_width
;
870 pix_fmt_mp
->plane_fmt
[0].sizeimage
= ctx
->luma_size
;
871 pix_fmt_mp
->plane_fmt
[1].bytesperline
= ctx
->buf_width
;
872 pix_fmt_mp
->plane_fmt
[1].sizeimage
= ctx
->chroma_size
;
874 mfc_err("invalid buf type\n");
880 static int vidioc_try_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
882 struct s5p_mfc_fmt
*fmt
;
883 struct v4l2_pix_format_mplane
*pix_fmt_mp
= &f
->fmt
.pix_mp
;
885 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
886 fmt
= find_format(f
, MFC_FMT_ENC
);
888 mfc_err("failed to try output format\n");
892 if (pix_fmt_mp
->plane_fmt
[0].sizeimage
== 0) {
893 mfc_err("must be set encoding output size\n");
897 pix_fmt_mp
->plane_fmt
[0].bytesperline
=
898 pix_fmt_mp
->plane_fmt
[0].sizeimage
;
899 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
900 fmt
= find_format(f
, MFC_FMT_RAW
);
902 mfc_err("failed to try output format\n");
906 if (fmt
->num_planes
!= pix_fmt_mp
->num_planes
) {
907 mfc_err("failed to try output format\n");
911 mfc_err("invalid buf type\n");
917 static int vidioc_s_fmt(struct file
*file
, void *priv
, struct v4l2_format
*f
)
919 struct s5p_mfc_dev
*dev
= video_drvdata(file
);
920 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
921 struct s5p_mfc_fmt
*fmt
;
922 struct v4l2_pix_format_mplane
*pix_fmt_mp
= &f
->fmt
.pix_mp
;
926 ret
= vidioc_try_fmt(file
, priv
, f
);
929 if (ctx
->vq_src
.streaming
|| ctx
->vq_dst
.streaming
) {
930 v4l2_err(&dev
->v4l2_dev
, "%s queue busy\n", __func__
);
934 if (f
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
935 fmt
= find_format(f
, MFC_FMT_ENC
);
937 mfc_err("failed to set capture format\n");
940 ctx
->state
= MFCINST_INIT
;
942 ctx
->codec_mode
= ctx
->dst_fmt
->codec_mode
;
943 ctx
->enc_dst_buf_size
= pix_fmt_mp
->plane_fmt
[0].sizeimage
;
944 pix_fmt_mp
->plane_fmt
[0].bytesperline
= 0;
945 ctx
->dst_bufs_cnt
= 0;
946 ctx
->capture_state
= QUEUE_FREE
;
947 s5p_mfc_alloc_instance_buffer(ctx
);
948 spin_lock_irqsave(&dev
->condlock
, flags
);
949 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
950 spin_unlock_irqrestore(&dev
->condlock
, flags
);
951 s5p_mfc_clean_ctx_int_flags(ctx
);
952 s5p_mfc_try_run(dev
);
953 if (s5p_mfc_wait_for_done_ctx(ctx
, \
954 S5P_FIMV_R2H_CMD_OPEN_INSTANCE_RET
, 1)) {
955 /* Error or timeout */
956 mfc_err("Error getting instance from hardware\n");
957 s5p_mfc_release_instance_buffer(ctx
);
961 mfc_debug(2, "Got instance number: %d\n", ctx
->inst_no
);
962 } else if (f
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
963 fmt
= find_format(f
, MFC_FMT_RAW
);
965 mfc_err("failed to set output format\n");
968 if (fmt
->num_planes
!= pix_fmt_mp
->num_planes
) {
969 mfc_err("failed to set output format\n");
974 ctx
->img_width
= pix_fmt_mp
->width
;
975 ctx
->img_height
= pix_fmt_mp
->height
;
976 mfc_debug(2, "codec number: %d\n", ctx
->src_fmt
->codec_mode
);
977 mfc_debug(2, "fmt - w: %d, h: %d, ctx - w: %d, h: %d\n",
978 pix_fmt_mp
->width
, pix_fmt_mp
->height
,
979 ctx
->img_width
, ctx
->img_height
);
980 if (ctx
->src_fmt
->fourcc
== V4L2_PIX_FMT_NV12M
) {
981 ctx
->buf_width
= ALIGN(ctx
->img_width
,
982 S5P_FIMV_NV12M_HALIGN
);
983 ctx
->luma_size
= ALIGN(ctx
->img_width
,
984 S5P_FIMV_NV12M_HALIGN
) * ALIGN(ctx
->img_height
,
985 S5P_FIMV_NV12M_LVALIGN
);
986 ctx
->chroma_size
= ALIGN(ctx
->img_width
,
987 S5P_FIMV_NV12M_HALIGN
) * ALIGN((ctx
->img_height
988 >> 1), S5P_FIMV_NV12M_CVALIGN
);
990 ctx
->luma_size
= ALIGN(ctx
->luma_size
,
991 S5P_FIMV_NV12M_SALIGN
);
992 ctx
->chroma_size
= ALIGN(ctx
->chroma_size
,
993 S5P_FIMV_NV12M_SALIGN
);
995 pix_fmt_mp
->plane_fmt
[0].sizeimage
= ctx
->luma_size
;
996 pix_fmt_mp
->plane_fmt
[0].bytesperline
= ctx
->buf_width
;
997 pix_fmt_mp
->plane_fmt
[1].sizeimage
= ctx
->chroma_size
;
998 pix_fmt_mp
->plane_fmt
[1].bytesperline
= ctx
->buf_width
;
1000 } else if (ctx
->src_fmt
->fourcc
== V4L2_PIX_FMT_NV12MT
) {
1001 ctx
->buf_width
= ALIGN(ctx
->img_width
,
1002 S5P_FIMV_NV12MT_HALIGN
);
1003 ctx
->luma_size
= ALIGN(ctx
->img_width
,
1004 S5P_FIMV_NV12MT_HALIGN
) * ALIGN(ctx
->img_height
,
1005 S5P_FIMV_NV12MT_VALIGN
);
1006 ctx
->chroma_size
= ALIGN(ctx
->img_width
,
1007 S5P_FIMV_NV12MT_HALIGN
) * ALIGN((ctx
->img_height
1008 >> 1), S5P_FIMV_NV12MT_VALIGN
);
1009 ctx
->luma_size
= ALIGN(ctx
->luma_size
,
1010 S5P_FIMV_NV12MT_SALIGN
);
1011 ctx
->chroma_size
= ALIGN(ctx
->chroma_size
,
1012 S5P_FIMV_NV12MT_SALIGN
);
1014 pix_fmt_mp
->plane_fmt
[0].sizeimage
= ctx
->luma_size
;
1015 pix_fmt_mp
->plane_fmt
[0].bytesperline
= ctx
->buf_width
;
1016 pix_fmt_mp
->plane_fmt
[1].sizeimage
= ctx
->chroma_size
;
1017 pix_fmt_mp
->plane_fmt
[1].bytesperline
= ctx
->buf_width
;
1019 ctx
->src_bufs_cnt
= 0;
1020 ctx
->output_state
= QUEUE_FREE
;
1022 mfc_err("invalid buf type\n");
1030 static int vidioc_reqbufs(struct file
*file
, void *priv
,
1031 struct v4l2_requestbuffers
*reqbufs
)
1033 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1036 /* if memory is not mmp or userptr return error */
1037 if ((reqbufs
->memory
!= V4L2_MEMORY_MMAP
) &&
1038 (reqbufs
->memory
!= V4L2_MEMORY_USERPTR
))
1040 if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1041 if (ctx
->capture_state
!= QUEUE_FREE
) {
1042 mfc_err("invalid capture state: %d\n",
1043 ctx
->capture_state
);
1046 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
1048 mfc_err("error in vb2_reqbufs() for E(D)\n");
1051 ctx
->capture_state
= QUEUE_BUFS_REQUESTED
;
1052 ret
= s5p_mfc_alloc_codec_buffers(ctx
);
1054 mfc_err("Failed to allocate encoding buffers\n");
1056 ret
= vb2_reqbufs(&ctx
->vq_dst
, reqbufs
);
1059 } else if (reqbufs
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1060 if (ctx
->output_state
!= QUEUE_FREE
) {
1061 mfc_err("invalid output state: %d\n",
1065 ret
= vb2_reqbufs(&ctx
->vq_src
, reqbufs
);
1067 mfc_err("error in vb2_reqbufs() for E(S)\n");
1070 ctx
->output_state
= QUEUE_BUFS_REQUESTED
;
1072 mfc_err("invalid buf type\n");
1078 static int vidioc_querybuf(struct file
*file
, void *priv
,
1079 struct v4l2_buffer
*buf
)
1081 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1084 /* if memory is not mmp or userptr return error */
1085 if ((buf
->memory
!= V4L2_MEMORY_MMAP
) &&
1086 (buf
->memory
!= V4L2_MEMORY_USERPTR
))
1088 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1089 if (ctx
->state
!= MFCINST_GOT_INST
) {
1090 mfc_err("invalid context state: %d\n", ctx
->state
);
1093 ret
= vb2_querybuf(&ctx
->vq_dst
, buf
);
1095 mfc_err("error in vb2_querybuf() for E(D)\n");
1098 buf
->m
.planes
[0].m
.mem_offset
+= DST_QUEUE_OFF_BASE
;
1099 } else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1100 ret
= vb2_querybuf(&ctx
->vq_src
, buf
);
1102 mfc_err("error in vb2_querybuf() for E(S)\n");
1106 mfc_err("invalid buf type\n");
1112 /* Queue a buffer */
1113 static int vidioc_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
1115 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1117 if (ctx
->state
== MFCINST_ERROR
) {
1118 mfc_err("Call on QBUF after unrecoverable error\n");
1121 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
1122 return vb2_qbuf(&ctx
->vq_src
, buf
);
1123 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1124 return vb2_qbuf(&ctx
->vq_dst
, buf
);
1128 /* Dequeue a buffer */
1129 static int vidioc_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*buf
)
1131 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1133 if (ctx
->state
== MFCINST_ERROR
) {
1134 mfc_err("Call on DQBUF after unrecoverable error\n");
1137 if (buf
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
1138 return vb2_dqbuf(&ctx
->vq_src
, buf
, file
->f_flags
& O_NONBLOCK
);
1139 else if (buf
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1140 return vb2_dqbuf(&ctx
->vq_dst
, buf
, file
->f_flags
& O_NONBLOCK
);
1145 static int vidioc_streamon(struct file
*file
, void *priv
,
1146 enum v4l2_buf_type type
)
1148 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1150 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
1151 return vb2_streamon(&ctx
->vq_src
, type
);
1152 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1153 return vb2_streamon(&ctx
->vq_dst
, type
);
1157 /* Stream off, which equals to a pause */
1158 static int vidioc_streamoff(struct file
*file
, void *priv
,
1159 enum v4l2_buf_type type
)
1161 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1163 if (type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
1164 return vb2_streamoff(&ctx
->vq_src
, type
);
1165 else if (type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1166 return vb2_streamoff(&ctx
->vq_dst
, type
);
1170 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl
)
1172 static unsigned int t
[V4L2_MPEG_VIDEO_H264_LEVEL_4_0
+ 1] = {
1173 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0 */ 10,
1174 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B */ 9,
1175 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1 */ 11,
1176 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2 */ 12,
1177 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3 */ 13,
1178 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0 */ 20,
1179 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1 */ 21,
1180 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2 */ 22,
1181 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0 */ 30,
1182 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1 */ 31,
1183 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2 */ 32,
1184 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0 */ 40,
1189 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl
)
1191 static unsigned int t
[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5
+ 1] = {
1192 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0 */ 0,
1193 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B */ 9,
1194 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1 */ 1,
1195 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2 */ 2,
1196 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3 */ 3,
1197 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B */ 7,
1198 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4 */ 4,
1199 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 */ 5,
1204 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar
)
1206 static unsigned int t
[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED
+ 1] = {
1207 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED */ 0,
1208 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1 */ 1,
1209 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11 */ 2,
1210 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11 */ 3,
1211 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11 */ 4,
1212 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33 */ 5,
1213 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11 */ 6,
1214 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11 */ 7,
1215 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11 */ 8,
1216 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33 */ 9,
1217 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11 */ 10,
1218 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11 */ 11,
1219 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33 */ 12,
1220 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99 */ 13,
1221 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3 */ 14,
1222 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2 */ 15,
1223 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1 */ 16,
1224 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED */ 255,
1229 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl
*ctrl
)
1231 struct s5p_mfc_ctx
*ctx
= ctrl_to_ctx(ctrl
);
1232 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1233 struct s5p_mfc_enc_params
*p
= &ctx
->enc_params
;
1237 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1238 p
->gop_size
= ctrl
->val
;
1240 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE
:
1241 p
->slice_mode
= ctrl
->val
;
1243 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB
:
1244 p
->slice_mb
= ctrl
->val
;
1246 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES
:
1247 p
->slice_bit
= ctrl
->val
* 8;
1249 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB
:
1250 p
->intra_refresh_mb
= ctrl
->val
;
1252 case V4L2_CID_MPEG_MFC51_VIDEO_PADDING
:
1255 case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV
:
1256 p
->pad_luma
= (ctrl
->val
>> 16) & 0xff;
1257 p
->pad_cb
= (ctrl
->val
>> 8) & 0xff;
1258 p
->pad_cr
= (ctrl
->val
>> 0) & 0xff;
1260 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE
:
1261 p
->rc_frame
= ctrl
->val
;
1263 case V4L2_CID_MPEG_VIDEO_BITRATE
:
1264 p
->rc_bitrate
= ctrl
->val
;
1266 case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF
:
1267 p
->rc_reaction_coeff
= ctrl
->val
;
1269 case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE
:
1270 ctx
->force_frame_type
= ctrl
->val
;
1272 case V4L2_CID_MPEG_VIDEO_VBV_SIZE
:
1273 p
->vbv_size
= ctrl
->val
;
1275 case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE
:
1276 p
->codec
.h264
.cpb_size
= ctrl
->val
;
1278 case V4L2_CID_MPEG_VIDEO_HEADER_MODE
:
1279 p
->seq_hdr_mode
= ctrl
->val
;
1281 case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE
:
1282 p
->frame_skip_mode
= ctrl
->val
;
1284 case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT
:
1285 p
->fixed_target_bit
= ctrl
->val
;
1287 case V4L2_CID_MPEG_VIDEO_B_FRAMES
:
1288 p
->num_b_frame
= ctrl
->val
;
1290 case V4L2_CID_MPEG_VIDEO_H264_PROFILE
:
1291 switch (ctrl
->val
) {
1292 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN
:
1293 p
->codec
.h264
.profile
=
1294 S5P_FIMV_ENC_PROFILE_H264_MAIN
;
1296 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH
:
1297 p
->codec
.h264
.profile
=
1298 S5P_FIMV_ENC_PROFILE_H264_HIGH
;
1300 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE
:
1301 p
->codec
.h264
.profile
=
1302 S5P_FIMV_ENC_PROFILE_H264_BASELINE
;
1308 case V4L2_CID_MPEG_VIDEO_H264_LEVEL
:
1309 p
->codec
.h264
.level_v4l2
= ctrl
->val
;
1310 p
->codec
.h264
.level
= h264_level(ctrl
->val
);
1311 if (p
->codec
.h264
.level
< 0) {
1312 mfc_err("Level number is wrong\n");
1313 ret
= p
->codec
.h264
.level
;
1316 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL
:
1317 p
->codec
.mpeg4
.level_v4l2
= ctrl
->val
;
1318 p
->codec
.mpeg4
.level
= mpeg4_level(ctrl
->val
);
1319 if (p
->codec
.mpeg4
.level
< 0) {
1320 mfc_err("Level number is wrong\n");
1321 ret
= p
->codec
.mpeg4
.level
;
1324 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE
:
1325 p
->codec
.h264
.loop_filter_mode
= ctrl
->val
;
1327 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA
:
1328 p
->codec
.h264
.loop_filter_alpha
= ctrl
->val
;
1330 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA
:
1331 p
->codec
.h264
.loop_filter_beta
= ctrl
->val
;
1333 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE
:
1334 p
->codec
.h264
.entropy_mode
= ctrl
->val
;
1336 case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P
:
1337 p
->codec
.h264
.num_ref_pic_4p
= ctrl
->val
;
1339 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM
:
1340 p
->codec
.h264
._8x8_transform
= ctrl
->val
;
1342 case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE
:
1343 p
->codec
.h264
.rc_mb
= ctrl
->val
;
1345 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP
:
1346 p
->codec
.h264
.rc_frame_qp
= ctrl
->val
;
1348 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1349 p
->codec
.h264
.rc_min_qp
= ctrl
->val
;
1351 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP
:
1352 p
->codec
.h264
.rc_max_qp
= ctrl
->val
;
1354 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP
:
1355 p
->codec
.h264
.rc_p_frame_qp
= ctrl
->val
;
1357 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP
:
1358 p
->codec
.h264
.rc_b_frame_qp
= ctrl
->val
;
1360 case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP
:
1361 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP
:
1362 p
->codec
.mpeg4
.rc_frame_qp
= ctrl
->val
;
1364 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP
:
1365 case V4L2_CID_MPEG_VIDEO_H263_MIN_QP
:
1366 p
->codec
.mpeg4
.rc_min_qp
= ctrl
->val
;
1368 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP
:
1369 case V4L2_CID_MPEG_VIDEO_H263_MAX_QP
:
1370 p
->codec
.mpeg4
.rc_max_qp
= ctrl
->val
;
1372 case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP
:
1373 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP
:
1374 p
->codec
.mpeg4
.rc_p_frame_qp
= ctrl
->val
;
1376 case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP
:
1377 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP
:
1378 p
->codec
.mpeg4
.rc_b_frame_qp
= ctrl
->val
;
1380 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK
:
1381 p
->codec
.h264
.rc_mb_dark
= ctrl
->val
;
1383 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH
:
1384 p
->codec
.h264
.rc_mb_smooth
= ctrl
->val
;
1386 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC
:
1387 p
->codec
.h264
.rc_mb_static
= ctrl
->val
;
1389 case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY
:
1390 p
->codec
.h264
.rc_mb_activity
= ctrl
->val
;
1392 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE
:
1393 p
->codec
.h264
.vui_sar
= ctrl
->val
;
1395 case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC
:
1396 p
->codec
.h264
.vui_sar_idc
= vui_sar_idc(ctrl
->val
);
1398 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH
:
1399 p
->codec
.h264
.vui_ext_sar_width
= ctrl
->val
;
1401 case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT
:
1402 p
->codec
.h264
.vui_ext_sar_height
= ctrl
->val
;
1404 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE
:
1405 p
->codec
.h264
.open_gop
= !ctrl
->val
;
1407 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
:
1408 p
->codec
.h264
.open_gop_size
= ctrl
->val
;
1410 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE
:
1411 switch (ctrl
->val
) {
1412 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE
:
1413 p
->codec
.mpeg4
.profile
=
1414 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE
;
1416 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE
:
1417 p
->codec
.mpeg4
.profile
=
1418 S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE
;
1424 case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL
:
1425 p
->codec
.mpeg4
.quarter_pixel
= ctrl
->val
;
1428 v4l2_err(&dev
->v4l2_dev
, "Invalid control, id=%d, val=%d\n",
1429 ctrl
->id
, ctrl
->val
);
1435 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops
= {
1436 .s_ctrl
= s5p_mfc_enc_s_ctrl
,
1439 int vidioc_s_parm(struct file
*file
, void *priv
, struct v4l2_streamparm
*a
)
1441 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1443 if (a
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1444 ctx
->enc_params
.rc_framerate_num
=
1445 a
->parm
.output
.timeperframe
.denominator
;
1446 ctx
->enc_params
.rc_framerate_denom
=
1447 a
->parm
.output
.timeperframe
.numerator
;
1449 mfc_err("Setting FPS is only possible for the output queue\n");
1455 int vidioc_g_parm(struct file
*file
, void *priv
, struct v4l2_streamparm
*a
)
1457 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(priv
);
1459 if (a
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
) {
1460 a
->parm
.output
.timeperframe
.denominator
=
1461 ctx
->enc_params
.rc_framerate_num
;
1462 a
->parm
.output
.timeperframe
.numerator
=
1463 ctx
->enc_params
.rc_framerate_denom
;
1465 mfc_err("Setting FPS is only possible for the output queue\n");
1471 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops
= {
1472 .vidioc_querycap
= vidioc_querycap
,
1473 .vidioc_enum_fmt_vid_cap
= vidioc_enum_fmt_vid_cap
,
1474 .vidioc_enum_fmt_vid_cap_mplane
= vidioc_enum_fmt_vid_cap_mplane
,
1475 .vidioc_enum_fmt_vid_out
= vidioc_enum_fmt_vid_out
,
1476 .vidioc_enum_fmt_vid_out_mplane
= vidioc_enum_fmt_vid_out_mplane
,
1477 .vidioc_g_fmt_vid_cap_mplane
= vidioc_g_fmt
,
1478 .vidioc_g_fmt_vid_out_mplane
= vidioc_g_fmt
,
1479 .vidioc_try_fmt_vid_cap_mplane
= vidioc_try_fmt
,
1480 .vidioc_try_fmt_vid_out_mplane
= vidioc_try_fmt
,
1481 .vidioc_s_fmt_vid_cap_mplane
= vidioc_s_fmt
,
1482 .vidioc_s_fmt_vid_out_mplane
= vidioc_s_fmt
,
1483 .vidioc_reqbufs
= vidioc_reqbufs
,
1484 .vidioc_querybuf
= vidioc_querybuf
,
1485 .vidioc_qbuf
= vidioc_qbuf
,
1486 .vidioc_dqbuf
= vidioc_dqbuf
,
1487 .vidioc_streamon
= vidioc_streamon
,
1488 .vidioc_streamoff
= vidioc_streamoff
,
1489 .vidioc_s_parm
= vidioc_s_parm
,
1490 .vidioc_g_parm
= vidioc_g_parm
,
1493 static int check_vb_with_fmt(struct s5p_mfc_fmt
*fmt
, struct vb2_buffer
*vb
)
1499 if (fmt
->num_planes
!= vb
->num_planes
) {
1500 mfc_err("invalid plane number for the format\n");
1503 for (i
= 0; i
< fmt
->num_planes
; i
++) {
1504 if (!vb2_dma_contig_plane_paddr(vb
, i
)) {
1505 mfc_err("failed to get plane cookie\n");
1508 mfc_debug(2, "index: %d, plane[%d] cookie: 0x%08zx",
1509 vb
->v4l2_buf
.index
, i
,
1510 vb2_dma_contig_plane_paddr(vb
, i
));
1515 static int s5p_mfc_queue_setup(struct vb2_queue
*vq
,
1516 unsigned int *buf_count
, unsigned int *plane_count
,
1517 unsigned long psize
[], void *allocators
[])
1519 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
1521 if (ctx
->state
!= MFCINST_GOT_INST
) {
1522 mfc_err("inavlid state: %d\n", ctx
->state
);
1525 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1527 *plane_count
= ctx
->dst_fmt
->num_planes
;
1529 *plane_count
= MFC_ENC_CAP_PLANE_COUNT
;
1532 if (*buf_count
> MFC_MAX_BUFFERS
)
1533 *buf_count
= MFC_MAX_BUFFERS
;
1534 psize
[0] = ctx
->enc_dst_buf_size
;
1535 allocators
[0] = ctx
->dev
->alloc_ctx
[MFC_BANK1_ALLOC_CTX
];
1536 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1538 *plane_count
= ctx
->src_fmt
->num_planes
;
1540 *plane_count
= MFC_ENC_OUT_PLANE_COUNT
;
1544 if (*buf_count
> MFC_MAX_BUFFERS
)
1545 *buf_count
= MFC_MAX_BUFFERS
;
1546 psize
[0] = ctx
->luma_size
;
1547 psize
[1] = ctx
->chroma_size
;
1548 allocators
[0] = ctx
->dev
->alloc_ctx
[MFC_BANK2_ALLOC_CTX
];
1549 allocators
[1] = ctx
->dev
->alloc_ctx
[MFC_BANK2_ALLOC_CTX
];
1551 mfc_err("inavlid queue type: %d\n", vq
->type
);
1557 static void s5p_mfc_unlock(struct vb2_queue
*q
)
1559 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1560 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1562 mutex_unlock(&dev
->mfc_mutex
);
1565 static void s5p_mfc_lock(struct vb2_queue
*q
)
1567 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1568 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1570 mutex_lock(&dev
->mfc_mutex
);
1573 static int s5p_mfc_buf_init(struct vb2_buffer
*vb
)
1575 struct vb2_queue
*vq
= vb
->vb2_queue
;
1576 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
1580 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1581 ret
= check_vb_with_fmt(ctx
->dst_fmt
, vb
);
1584 i
= vb
->v4l2_buf
.index
;
1585 ctx
->dst_bufs
[i
].b
= vb
;
1586 ctx
->dst_bufs
[i
].cookie
.stream
=
1587 vb2_dma_contig_plane_paddr(vb
, 0);
1588 ctx
->dst_bufs_cnt
++;
1589 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1590 ret
= check_vb_with_fmt(ctx
->src_fmt
, vb
);
1593 i
= vb
->v4l2_buf
.index
;
1594 ctx
->src_bufs
[i
].b
= vb
;
1595 ctx
->src_bufs
[i
].cookie
.raw
.luma
=
1596 vb2_dma_contig_plane_paddr(vb
, 0);
1597 ctx
->src_bufs
[i
].cookie
.raw
.chroma
=
1598 vb2_dma_contig_plane_paddr(vb
, 1);
1599 ctx
->src_bufs_cnt
++;
1601 mfc_err("inavlid queue type: %d\n", vq
->type
);
1607 static int s5p_mfc_buf_prepare(struct vb2_buffer
*vb
)
1609 struct vb2_queue
*vq
= vb
->vb2_queue
;
1610 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
1613 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1614 ret
= check_vb_with_fmt(ctx
->dst_fmt
, vb
);
1617 mfc_debug(2, "plane size: %ld, dst size: %d\n",
1618 vb2_plane_size(vb
, 0), ctx
->enc_dst_buf_size
);
1619 if (vb2_plane_size(vb
, 0) < ctx
->enc_dst_buf_size
) {
1620 mfc_err("plane size is too small for capture\n");
1623 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1624 ret
= check_vb_with_fmt(ctx
->src_fmt
, vb
);
1627 mfc_debug(2, "plane size: %ld, luma size: %d\n",
1628 vb2_plane_size(vb
, 0), ctx
->luma_size
);
1629 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
1630 vb2_plane_size(vb
, 1), ctx
->chroma_size
);
1631 if (vb2_plane_size(vb
, 0) < ctx
->luma_size
||
1632 vb2_plane_size(vb
, 1) < ctx
->chroma_size
) {
1633 mfc_err("plane size is too small for output\n");
1637 mfc_err("inavlid queue type: %d\n", vq
->type
);
1643 static int s5p_mfc_start_streaming(struct vb2_queue
*q
)
1645 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1646 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1647 unsigned long flags
;
1649 v4l2_ctrl_handler_setup(&ctx
->ctrl_handler
);
1650 /* If context is ready then dev = work->data;schedule it to run */
1651 if (s5p_mfc_ctx_ready(ctx
)) {
1652 spin_lock_irqsave(&dev
->condlock
, flags
);
1653 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
1654 spin_unlock_irqrestore(&dev
->condlock
, flags
);
1656 s5p_mfc_try_run(dev
);
1660 static int s5p_mfc_stop_streaming(struct vb2_queue
*q
)
1662 unsigned long flags
;
1663 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(q
->drv_priv
);
1664 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1666 if ((ctx
->state
== MFCINST_FINISHING
||
1667 ctx
->state
== MFCINST_RUNNING
) &&
1668 dev
->curr_ctx
== ctx
->num
&& dev
->hw_lock
) {
1669 ctx
->state
= MFCINST_ABORT
;
1670 s5p_mfc_wait_for_done_ctx(ctx
, S5P_FIMV_R2H_CMD_FRAME_DONE_RET
,
1673 ctx
->state
= MFCINST_FINISHED
;
1674 spin_lock_irqsave(&dev
->irqlock
, flags
);
1675 if (q
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1676 s5p_mfc_cleanup_queue(&ctx
->dst_queue
, &ctx
->vq_dst
);
1677 INIT_LIST_HEAD(&ctx
->dst_queue
);
1678 ctx
->dst_queue_cnt
= 0;
1680 if (q
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1681 cleanup_ref_queue(ctx
);
1682 s5p_mfc_cleanup_queue(&ctx
->src_queue
, &ctx
->vq_src
);
1683 INIT_LIST_HEAD(&ctx
->src_queue
);
1684 ctx
->src_queue_cnt
= 0;
1686 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1690 static void s5p_mfc_buf_queue(struct vb2_buffer
*vb
)
1692 struct vb2_queue
*vq
= vb
->vb2_queue
;
1693 struct s5p_mfc_ctx
*ctx
= fh_to_ctx(vq
->drv_priv
);
1694 struct s5p_mfc_dev
*dev
= ctx
->dev
;
1695 unsigned long flags
;
1696 struct s5p_mfc_buf
*mfc_buf
;
1698 if (ctx
->state
== MFCINST_ERROR
) {
1699 vb2_buffer_done(vb
, VB2_BUF_STATE_ERROR
);
1700 cleanup_ref_queue(ctx
);
1703 if (vq
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
1704 mfc_buf
= &ctx
->dst_bufs
[vb
->v4l2_buf
.index
];
1706 /* Mark destination as available for use by MFC */
1707 spin_lock_irqsave(&dev
->irqlock
, flags
);
1708 list_add_tail(&mfc_buf
->list
, &ctx
->dst_queue
);
1709 ctx
->dst_queue_cnt
++;
1710 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1711 } else if (vq
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
1712 mfc_buf
= &ctx
->src_bufs
[vb
->v4l2_buf
.index
];
1714 spin_lock_irqsave(&dev
->irqlock
, flags
);
1715 if (vb
->v4l2_planes
[0].bytesused
== 0) {
1716 mfc_debug(1, "change state to FINISHING\n");
1717 ctx
->state
= MFCINST_FINISHING
;
1718 vb2_buffer_done(vb
, VB2_BUF_STATE_DONE
);
1719 cleanup_ref_queue(ctx
);
1721 list_add_tail(&mfc_buf
->list
, &ctx
->src_queue
);
1722 ctx
->src_queue_cnt
++;
1724 spin_unlock_irqrestore(&dev
->irqlock
, flags
);
1726 mfc_err("unsupported buffer type (%d)\n", vq
->type
);
1728 if (s5p_mfc_ctx_ready(ctx
)) {
1729 spin_lock_irqsave(&dev
->condlock
, flags
);
1730 set_bit(ctx
->num
, &dev
->ctx_work_bits
);
1731 spin_unlock_irqrestore(&dev
->condlock
, flags
);
1733 s5p_mfc_try_run(dev
);
1736 static struct vb2_ops s5p_mfc_enc_qops
= {
1737 .queue_setup
= s5p_mfc_queue_setup
,
1738 .wait_prepare
= s5p_mfc_unlock
,
1739 .wait_finish
= s5p_mfc_lock
,
1740 .buf_init
= s5p_mfc_buf_init
,
1741 .buf_prepare
= s5p_mfc_buf_prepare
,
1742 .start_streaming
= s5p_mfc_start_streaming
,
1743 .stop_streaming
= s5p_mfc_stop_streaming
,
1744 .buf_queue
= s5p_mfc_buf_queue
,
1747 struct s5p_mfc_codec_ops
*get_enc_codec_ops(void)
1749 return &encoder_codec_ops
;
1752 struct vb2_ops
*get_enc_queue_ops(void)
1754 return &s5p_mfc_enc_qops
;
1757 const struct v4l2_ioctl_ops
*get_enc_v4l2_ioctl_ops(void)
1759 return &s5p_mfc_enc_ioctl_ops
;
1762 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
1763 && V4L2_CTRL_DRIVER_PRIV(x))
1765 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx
*ctx
)
1767 struct v4l2_ctrl_config cfg
;
1770 v4l2_ctrl_handler_init(&ctx
->ctrl_handler
, NUM_CTRLS
);
1771 if (ctx
->ctrl_handler
.error
) {
1772 mfc_err("v4l2_ctrl_handler_init failed\n");
1773 return ctx
->ctrl_handler
.error
;
1775 for (i
= 0; i
< NUM_CTRLS
; i
++) {
1776 if (IS_MFC51_PRIV(controls
[i
].id
)) {
1777 cfg
.ops
= &s5p_mfc_enc_ctrl_ops
;
1778 cfg
.id
= controls
[i
].id
;
1779 cfg
.min
= controls
[i
].minimum
;
1780 cfg
.max
= controls
[i
].maximum
;
1781 cfg
.def
= controls
[i
].default_value
;
1782 cfg
.name
= controls
[i
].name
;
1783 cfg
.type
= controls
[i
].type
;
1786 if (cfg
.type
== V4L2_CTRL_TYPE_MENU
) {
1788 cfg
.menu_skip_mask
= cfg
.menu_skip_mask
;
1789 cfg
.qmenu
= mfc51_get_menu(cfg
.id
);
1791 cfg
.step
= controls
[i
].step
;
1792 cfg
.menu_skip_mask
= 0;
1794 ctx
->ctrls
[i
] = v4l2_ctrl_new_custom(&ctx
->ctrl_handler
,
1797 if (controls
[i
].type
== V4L2_CTRL_TYPE_MENU
) {
1798 ctx
->ctrls
[i
] = v4l2_ctrl_new_std_menu(
1800 &s5p_mfc_enc_ctrl_ops
, controls
[i
].id
,
1801 controls
[i
].maximum
, 0,
1802 controls
[i
].default_value
);
1804 ctx
->ctrls
[i
] = v4l2_ctrl_new_std(
1806 &s5p_mfc_enc_ctrl_ops
, controls
[i
].id
,
1807 controls
[i
].minimum
,
1808 controls
[i
].maximum
, controls
[i
].step
,
1809 controls
[i
].default_value
);
1812 if (ctx
->ctrl_handler
.error
) {
1813 mfc_err("Adding control (%d) failed\n", i
);
1814 return ctx
->ctrl_handler
.error
;
1816 if (controls
[i
].is_volatile
&& ctx
->ctrls
[i
])
1817 ctx
->ctrls
[i
]->is_volatile
= 1;
1822 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx
*ctx
)
1826 v4l2_ctrl_handler_free(&ctx
->ctrl_handler
);
1827 for (i
= 0; i
< NUM_CTRLS
; i
++)
1828 ctx
->ctrls
[i
] = NULL
;