[media] media: videobuf2: Restructure vb2_buffer
[sfrench/cifs-2.6.git] / drivers / media / platform / s5p-mfc / s5p_mfc_enc.c
1 /*
2  * linux/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c
3  *
4  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
5  *              http://www.samsung.com/
6  *
7  * Jeongtae Park        <jtp.park@samsung.com>
8  * Kamil Debski         <k.debski@samsung.com>
9  *
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.
14  */
15
16 #include <linux/clk.h>
17 #include <linux/interrupt.h>
18 #include <linux/io.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"
33
34 #define DEF_SRC_FMT_ENC V4L2_PIX_FMT_NV12M
35 #define DEF_DST_FMT_ENC V4L2_PIX_FMT_H264
36
37 static struct s5p_mfc_fmt formats[] = {
38         {
39                 .name           = "4:2:0 2 Planes 16x16 Tiles",
40                 .fourcc         = V4L2_PIX_FMT_NV12MT_16X16,
41                 .codec_mode     = S5P_MFC_CODEC_NONE,
42                 .type           = MFC_FMT_RAW,
43                 .num_planes     = 2,
44                 .versions       = MFC_V6_BIT | MFC_V7_BIT,
45         },
46         {
47                 .name           = "4:2:0 2 Planes 64x32 Tiles",
48                 .fourcc         = V4L2_PIX_FMT_NV12MT,
49                 .codec_mode     = S5P_MFC_CODEC_NONE,
50                 .type           = MFC_FMT_RAW,
51                 .num_planes     = 2,
52                 .versions       = MFC_V5_BIT,
53         },
54         {
55                 .name           = "4:2:0 2 Planes Y/CbCr",
56                 .fourcc         = V4L2_PIX_FMT_NV12M,
57                 .codec_mode     = S5P_MFC_CODEC_NONE,
58                 .type           = MFC_FMT_RAW,
59                 .num_planes     = 2,
60                 .versions       = MFC_V5_BIT | MFC_V6_BIT | MFC_V7_BIT |
61                                                                 MFC_V8_BIT,
62         },
63         {
64                 .name           = "4:2:0 2 Planes Y/CrCb",
65                 .fourcc         = V4L2_PIX_FMT_NV21M,
66                 .codec_mode     = S5P_MFC_CODEC_NONE,
67                 .type           = MFC_FMT_RAW,
68                 .num_planes     = 2,
69                 .versions       = MFC_V6_BIT | MFC_V7_BIT | MFC_V8_BIT,
70         },
71         {
72                 .name           = "H264 Encoded Stream",
73                 .fourcc         = V4L2_PIX_FMT_H264,
74                 .codec_mode     = S5P_MFC_CODEC_H264_ENC,
75                 .type           = MFC_FMT_ENC,
76                 .num_planes     = 1,
77                 .versions       = MFC_V5_BIT | MFC_V6_BIT | MFC_V7_BIT |
78                                                                 MFC_V8_BIT,
79         },
80         {
81                 .name           = "MPEG4 Encoded Stream",
82                 .fourcc         = V4L2_PIX_FMT_MPEG4,
83                 .codec_mode     = S5P_MFC_CODEC_MPEG4_ENC,
84                 .type           = MFC_FMT_ENC,
85                 .num_planes     = 1,
86                 .versions       = MFC_V5_BIT | MFC_V6_BIT | MFC_V7_BIT |
87                                                                 MFC_V8_BIT,
88         },
89         {
90                 .name           = "H263 Encoded Stream",
91                 .fourcc         = V4L2_PIX_FMT_H263,
92                 .codec_mode     = S5P_MFC_CODEC_H263_ENC,
93                 .type           = MFC_FMT_ENC,
94                 .num_planes     = 1,
95                 .versions       = MFC_V5_BIT | MFC_V6_BIT | MFC_V7_BIT |
96                                                                 MFC_V8_BIT,
97         },
98         {
99                 .name           = "VP8 Encoded Stream",
100                 .fourcc         = V4L2_PIX_FMT_VP8,
101                 .codec_mode     = S5P_MFC_CODEC_VP8_ENC,
102                 .type           = MFC_FMT_ENC,
103                 .num_planes     = 1,
104                 .versions       = MFC_V7_BIT | MFC_V8_BIT,
105         },
106 };
107
108 #define NUM_FORMATS ARRAY_SIZE(formats)
109 static struct s5p_mfc_fmt *find_format(struct v4l2_format *f, unsigned int t)
110 {
111         unsigned int i;
112
113         for (i = 0; i < NUM_FORMATS; i++) {
114                 if (formats[i].fourcc == f->fmt.pix_mp.pixelformat &&
115                     formats[i].type == t)
116                         return &formats[i];
117         }
118         return NULL;
119 }
120
121 static struct mfc_control controls[] = {
122         {
123                 .id = V4L2_CID_MPEG_VIDEO_GOP_SIZE,
124                 .type = V4L2_CTRL_TYPE_INTEGER,
125                 .minimum = 0,
126                 .maximum = (1 << 16) - 1,
127                 .step = 1,
128                 .default_value = 12,
129         },
130         {
131                 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
132                 .type = V4L2_CTRL_TYPE_MENU,
133                 .minimum = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
134                 .maximum = V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES,
135                 .default_value = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
136                 .menu_skip_mask = 0,
137         },
138         {
139                 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB,
140                 .type = V4L2_CTRL_TYPE_INTEGER,
141                 .minimum = 1,
142                 .maximum = (1 << 16) - 1,
143                 .step = 1,
144                 .default_value = 1,
145         },
146         {
147                 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES,
148                 .type = V4L2_CTRL_TYPE_INTEGER,
149                 .minimum = 1900,
150                 .maximum = (1 << 30) - 1,
151                 .step = 1,
152                 .default_value = 1900,
153         },
154         {
155                 .id = V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB,
156                 .type = V4L2_CTRL_TYPE_INTEGER,
157                 .minimum = 0,
158                 .maximum = (1 << 16) - 1,
159                 .step = 1,
160                 .default_value = 0,
161         },
162         {
163                 .id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING,
164                 .type = V4L2_CTRL_TYPE_BOOLEAN,
165                 .name = "Padding Control Enable",
166                 .minimum = 0,
167                 .maximum = 1,
168                 .step = 1,
169                 .default_value = 0,
170         },
171         {
172                 .id = V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV,
173                 .type = V4L2_CTRL_TYPE_INTEGER,
174                 .name = "Padding Color YUV Value",
175                 .minimum = 0,
176                 .maximum = (1 << 25) - 1,
177                 .step = 1,
178                 .default_value = 0,
179         },
180         {
181                 .id = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,
182                 .type = V4L2_CTRL_TYPE_BOOLEAN,
183                 .minimum = 0,
184                 .maximum = 1,
185                 .step = 1,
186                 .default_value = 0,
187         },
188         {
189                 .id = V4L2_CID_MPEG_VIDEO_BITRATE,
190                 .type = V4L2_CTRL_TYPE_INTEGER,
191                 .minimum = 1,
192                 .maximum = (1 << 30) - 1,
193                 .step = 1,
194                 .default_value = 1,
195         },
196         {
197                 .id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF,
198                 .type = V4L2_CTRL_TYPE_INTEGER,
199                 .name = "Rate Control Reaction Coeff.",
200                 .minimum = 1,
201                 .maximum = (1 << 16) - 1,
202                 .step = 1,
203                 .default_value = 1,
204         },
205         {
206                 .id = V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE,
207                 .type = V4L2_CTRL_TYPE_MENU,
208                 .name = "Force frame type",
209                 .minimum = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED,
210                 .maximum = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_NOT_CODED,
211                 .default_value = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_DISABLED,
212                 .menu_skip_mask = 0,
213         },
214         {
215                 .id = V4L2_CID_MPEG_VIDEO_VBV_SIZE,
216                 .type = V4L2_CTRL_TYPE_INTEGER,
217                 .minimum = 0,
218                 .maximum = (1 << 16) - 1,
219                 .step = 1,
220                 .default_value = 0,
221         },
222         {
223                 .id = V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE,
224                 .type = V4L2_CTRL_TYPE_INTEGER,
225                 .name = "Horizontal MV Search Range",
226                 .minimum = 16,
227                 .maximum = 128,
228                 .step = 16,
229                 .default_value = 32,
230         },
231         {
232                 .id = V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE,
233                 .type = V4L2_CTRL_TYPE_INTEGER,
234                 .name = "Vertical MV Search Range",
235                 .minimum = 16,
236                 .maximum = 128,
237                 .step = 16,
238                 .default_value = 32,
239         },
240         {
241                 .id = V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE,
242                 .type = V4L2_CTRL_TYPE_INTEGER,
243                 .minimum = 0,
244                 .maximum = (1 << 16) - 1,
245                 .step = 1,
246                 .default_value = 0,
247         },
248         {
249                 .id = V4L2_CID_MPEG_VIDEO_HEADER_MODE,
250                 .type = V4L2_CTRL_TYPE_MENU,
251                 .minimum = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
252                 .maximum = V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
253                 .default_value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
254                 .menu_skip_mask = 0,
255         },
256         {
257                 .id = V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE,
258                 .type = V4L2_CTRL_TYPE_MENU,
259                 .name = "Frame Skip Enable",
260                 .minimum = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED,
261                 .maximum = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
262                 .menu_skip_mask = 0,
263                 .default_value = V4L2_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE_DISABLED,
264         },
265         {
266                 .id = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT,
267                 .type = V4L2_CTRL_TYPE_BOOLEAN,
268                 .name = "Fixed Target Bit Enable",
269                 .minimum = 0,
270                 .maximum = 1,
271                 .default_value = 0,
272                 .step = 1,
273                 .menu_skip_mask = 0,
274         },
275         {
276                 .id = V4L2_CID_MPEG_VIDEO_B_FRAMES,
277                 .type = V4L2_CTRL_TYPE_INTEGER,
278                 .minimum = 0,
279                 .maximum = 2,
280                 .step = 1,
281                 .default_value = 0,
282         },
283         {
284                 .id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
285                 .type = V4L2_CTRL_TYPE_MENU,
286                 .minimum = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
287                 .maximum = V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH,
288                 .default_value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
289                 .menu_skip_mask = ~(
290                                 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
291                                 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
292                                 (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)
293                                 ),
294         },
295         {
296                 .id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
297                 .type = V4L2_CTRL_TYPE_MENU,
298                 .minimum = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
299                 .maximum = V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
300                 .default_value = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
301         },
302         {
303                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
304                 .type = V4L2_CTRL_TYPE_MENU,
305                 .minimum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
306                 .maximum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
307                 .default_value = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
308                 .menu_skip_mask = 0,
309         },
310         {
311                 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
312                 .type = V4L2_CTRL_TYPE_MENU,
313                 .minimum = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
314                 .maximum = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY,
315                 .default_value = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
316                 .menu_skip_mask = 0,
317         },
318         {
319                 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA,
320                 .type = V4L2_CTRL_TYPE_INTEGER,
321                 .minimum = -6,
322                 .maximum = 6,
323                 .step = 1,
324                 .default_value = 0,
325         },
326         {
327                 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA,
328                 .type = V4L2_CTRL_TYPE_INTEGER,
329                 .minimum = -6,
330                 .maximum = 6,
331                 .step = 1,
332                 .default_value = 0,
333         },
334         {
335                 .id = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
336                 .type = V4L2_CTRL_TYPE_MENU,
337                 .minimum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
338                 .maximum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
339                 .default_value = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
340                 .menu_skip_mask = 0,
341         },
342         {
343                 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P,
344                 .type = V4L2_CTRL_TYPE_INTEGER,
345                 .name = "The Number of Ref. Pic for P",
346                 .minimum = 1,
347                 .maximum = 2,
348                 .step = 1,
349                 .default_value = 1,
350         },
351         {
352                 .id = V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM,
353                 .type = V4L2_CTRL_TYPE_BOOLEAN,
354                 .minimum = 0,
355                 .maximum = 1,
356                 .step = 1,
357                 .default_value = 0,
358         },
359         {
360                 .id = V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,
361                 .type = V4L2_CTRL_TYPE_BOOLEAN,
362                 .minimum = 0,
363                 .maximum = 1,
364                 .step = 1,
365                 .default_value = 0,
366         },
367         {
368                 .id = V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
369                 .type = V4L2_CTRL_TYPE_INTEGER,
370                 .minimum = 0,
371                 .maximum = 51,
372                 .step = 1,
373                 .default_value = 1,
374         },
375         {
376                 .id = V4L2_CID_MPEG_VIDEO_H264_MIN_QP,
377                 .type = V4L2_CTRL_TYPE_INTEGER,
378                 .minimum = 0,
379                 .maximum = 51,
380                 .step = 1,
381                 .default_value = 1,
382         },
383         {
384                 .id = V4L2_CID_MPEG_VIDEO_H264_MAX_QP,
385                 .type = V4L2_CTRL_TYPE_INTEGER,
386                 .minimum = 0,
387                 .maximum = 51,
388                 .step = 1,
389                 .default_value = 51,
390         },
391         {
392                 .id = V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
393                 .type = V4L2_CTRL_TYPE_INTEGER,
394                 .minimum = 0,
395                 .maximum = 51,
396                 .step = 1,
397                 .default_value = 1,
398         },
399         {
400                 .id = V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP,
401                 .type = V4L2_CTRL_TYPE_INTEGER,
402                 .minimum = 0,
403                 .maximum = 51,
404                 .step = 1,
405                 .default_value = 1,
406         },
407         {
408                 .id = V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP,
409                 .type = V4L2_CTRL_TYPE_INTEGER,
410                 .name = "H263 I-Frame QP value",
411                 .minimum = 1,
412                 .maximum = 31,
413                 .step = 1,
414                 .default_value = 1,
415         },
416         {
417                 .id = V4L2_CID_MPEG_VIDEO_H263_MIN_QP,
418                 .type = V4L2_CTRL_TYPE_INTEGER,
419                 .name = "H263 Minimum QP value",
420                 .minimum = 1,
421                 .maximum = 31,
422                 .step = 1,
423                 .default_value = 1,
424         },
425         {
426                 .id = V4L2_CID_MPEG_VIDEO_H263_MAX_QP,
427                 .type = V4L2_CTRL_TYPE_INTEGER,
428                 .name = "H263 Maximum QP value",
429                 .minimum = 1,
430                 .maximum = 31,
431                 .step = 1,
432                 .default_value = 31,
433         },
434         {
435                 .id = V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP,
436                 .type = V4L2_CTRL_TYPE_INTEGER,
437                 .name = "H263 P frame QP value",
438                 .minimum = 1,
439                 .maximum = 31,
440                 .step = 1,
441                 .default_value = 1,
442         },
443         {
444                 .id = V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP,
445                 .type = V4L2_CTRL_TYPE_INTEGER,
446                 .name = "H263 B frame QP value",
447                 .minimum = 1,
448                 .maximum = 31,
449                 .step = 1,
450                 .default_value = 1,
451         },
452         {
453                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP,
454                 .type = V4L2_CTRL_TYPE_INTEGER,
455                 .name = "MPEG4 I-Frame QP value",
456                 .minimum = 1,
457                 .maximum = 31,
458                 .step = 1,
459                 .default_value = 1,
460         },
461         {
462                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP,
463                 .type = V4L2_CTRL_TYPE_INTEGER,
464                 .name = "MPEG4 Minimum QP value",
465                 .minimum = 1,
466                 .maximum = 31,
467                 .step = 1,
468                 .default_value = 1,
469         },
470         {
471                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP,
472                 .type = V4L2_CTRL_TYPE_INTEGER,
473                 .name = "MPEG4 Maximum QP value",
474                 .minimum = 0,
475                 .maximum = 51,
476                 .step = 1,
477                 .default_value = 51,
478         },
479         {
480                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP,
481                 .type = V4L2_CTRL_TYPE_INTEGER,
482                 .name = "MPEG4 P frame QP value",
483                 .minimum = 1,
484                 .maximum = 31,
485                 .step = 1,
486                 .default_value = 1,
487         },
488         {
489                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP,
490                 .type = V4L2_CTRL_TYPE_INTEGER,
491                 .name = "MPEG4 B frame QP value",
492                 .minimum = 1,
493                 .maximum = 31,
494                 .step = 1,
495                 .default_value = 1,
496         },
497         {
498                 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK,
499                 .type = V4L2_CTRL_TYPE_BOOLEAN,
500                 .name = "H264 Dark Reg Adaptive RC",
501                 .minimum = 0,
502                 .maximum = 1,
503                 .step = 1,
504                 .default_value = 0,
505         },
506         {
507                 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH,
508                 .type = V4L2_CTRL_TYPE_BOOLEAN,
509                 .name = "H264 Smooth Reg Adaptive RC",
510                 .minimum = 0,
511                 .maximum = 1,
512                 .step = 1,
513                 .default_value = 0,
514         },
515         {
516                 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC,
517                 .type = V4L2_CTRL_TYPE_BOOLEAN,
518                 .name = "H264 Static Reg Adaptive RC",
519                 .minimum = 0,
520                 .maximum = 1,
521                 .step = 1,
522                 .default_value = 0,
523         },
524         {
525                 .id = V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY,
526                 .type = V4L2_CTRL_TYPE_BOOLEAN,
527                 .name = "H264 Activity Reg Adaptive RC",
528                 .minimum = 0,
529                 .maximum = 1,
530                 .step = 1,
531                 .default_value = 0,
532         },
533         {
534                 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE,
535                 .type = V4L2_CTRL_TYPE_BOOLEAN,
536                 .minimum = 0,
537                 .maximum = 1,
538                 .step = 1,
539                 .default_value = 0,
540         },
541         {
542                 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC,
543                 .type = V4L2_CTRL_TYPE_MENU,
544                 .minimum = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED,
545                 .maximum = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED,
546                 .default_value = V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED,
547                 .menu_skip_mask = 0,
548         },
549         {
550                 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH,
551                 .type = V4L2_CTRL_TYPE_INTEGER,
552                 .minimum = 0,
553                 .maximum = (1 << 16) - 1,
554                 .step = 1,
555                 .default_value = 0,
556         },
557         {
558                 .id = V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT,
559                 .type = V4L2_CTRL_TYPE_INTEGER,
560                 .minimum = 0,
561                 .maximum = (1 << 16) - 1,
562                 .step = 1,
563                 .default_value = 0,
564         },
565         {
566                 .id = V4L2_CID_MPEG_VIDEO_GOP_CLOSURE,
567                 .type = V4L2_CTRL_TYPE_BOOLEAN,
568                 .minimum = 0,
569                 .maximum = 1,
570                 .step = 1,
571                 .default_value = 1,
572         },
573         {
574                 .id = V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,
575                 .type = V4L2_CTRL_TYPE_INTEGER,
576                 .minimum = 0,
577                 .maximum = (1 << 16) - 1,
578                 .step = 1,
579                 .default_value = 0,
580         },
581         {
582                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
583                 .type = V4L2_CTRL_TYPE_MENU,
584                 .minimum = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
585                 .maximum = V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE,
586                 .default_value = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
587                 .menu_skip_mask = 0,
588         },
589         {
590                 .id = V4L2_CID_MPEG_VIDEO_MPEG4_QPEL,
591                 .type = V4L2_CTRL_TYPE_BOOLEAN,
592                 .minimum = 0,
593                 .maximum = 1,
594                 .step = 1,
595                 .default_value = 0,
596         },
597         {
598                 .id = V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS,
599                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
600                 .maximum = V4L2_CID_MPEG_VIDEO_VPX_8_PARTITIONS,
601                 .default_value = V4L2_CID_MPEG_VIDEO_VPX_1_PARTITION,
602                 .menu_skip_mask = 0,
603         },
604         {
605                 .id = V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4,
606                 .type = V4L2_CTRL_TYPE_BOOLEAN,
607                 .minimum = 0,
608                 .maximum = 1,
609                 .step = 1,
610                 .default_value = 0,
611         },
612         {
613                 .id = V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES,
614                 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
615                 .maximum = V4L2_CID_MPEG_VIDEO_VPX_2_REF_FRAME,
616                 .default_value = V4L2_CID_MPEG_VIDEO_VPX_1_REF_FRAME,
617                 .menu_skip_mask = 0,
618         },
619         {
620                 .id = V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL,
621                 .type = V4L2_CTRL_TYPE_INTEGER,
622                 .minimum = 0,
623                 .maximum = 63,
624                 .step = 1,
625                 .default_value = 0,
626         },
627         {
628                 .id = V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS,
629                 .type = V4L2_CTRL_TYPE_INTEGER,
630                 .minimum = 0,
631                 .maximum = 7,
632                 .step = 1,
633                 .default_value = 0,
634         },
635         {
636                 .id = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD,
637                 .type = V4L2_CTRL_TYPE_INTEGER,
638                 .minimum = 0,
639                 .maximum = (1 << 16) - 1,
640                 .step = 1,
641                 .default_value = 0,
642         },
643         {
644                 .id = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL,
645                 .type = V4L2_CTRL_TYPE_MENU,
646                 .minimum = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_PREV,
647                 .maximum = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_REF_PERIOD,
648                 .default_value = V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_USE_PREV,
649                 .menu_skip_mask = 0,
650         },
651         {
652                 .id = V4L2_CID_MPEG_VIDEO_VPX_MAX_QP,
653                 .type = V4L2_CTRL_TYPE_INTEGER,
654                 .minimum = 0,
655                 .maximum = 127,
656                 .step = 1,
657                 .default_value = 127,
658         },
659         {
660                 .id = V4L2_CID_MPEG_VIDEO_VPX_MIN_QP,
661                 .type = V4L2_CTRL_TYPE_INTEGER,
662                 .minimum = 0,
663                 .maximum = 11,
664                 .step = 1,
665                 .default_value = 0,
666         },
667         {
668                 .id = V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP,
669                 .type = V4L2_CTRL_TYPE_INTEGER,
670                 .minimum = 0,
671                 .maximum = 127,
672                 .step = 1,
673                 .default_value = 10,
674         },
675         {
676                 .id = V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP,
677                 .type = V4L2_CTRL_TYPE_INTEGER,
678                 .minimum = 0,
679                 .maximum = 127,
680                 .step = 1,
681                 .default_value = 10,
682         },
683         {
684                 .id = V4L2_CID_MPEG_VIDEO_VPX_PROFILE,
685                 .type = V4L2_CTRL_TYPE_INTEGER,
686                 .minimum = 0,
687                 .maximum = 3,
688                 .step = 1,
689                 .default_value = 0,
690         },
691         {
692                 .id = V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,
693                 .type = V4L2_CTRL_TYPE_INTEGER,
694                 .name = "Minimum number of output bufs",
695                 .minimum = 1,
696                 .maximum = 32,
697                 .step = 1,
698                 .default_value = 1,
699                 .is_volatile = 1,
700         },
701 };
702
703 #define NUM_CTRLS ARRAY_SIZE(controls)
704 static const char * const *mfc51_get_menu(u32 id)
705 {
706         static const char * const mfc51_video_frame_skip[] = {
707                 "Disabled",
708                 "Level Limit",
709                 "VBV/CPB Limit",
710                 NULL,
711         };
712         static const char * const mfc51_video_force_frame[] = {
713                 "Disabled",
714                 "I Frame",
715                 "Not Coded",
716                 NULL,
717         };
718         switch (id) {
719         case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
720                 return mfc51_video_frame_skip;
721         case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
722                 return mfc51_video_force_frame;
723         }
724         return NULL;
725 }
726
727 static int s5p_mfc_ctx_ready(struct s5p_mfc_ctx *ctx)
728 {
729         mfc_debug(2, "src=%d, dst=%d, state=%d\n",
730                   ctx->src_queue_cnt, ctx->dst_queue_cnt, ctx->state);
731         /* context is ready to make header */
732         if (ctx->state == MFCINST_GOT_INST && ctx->dst_queue_cnt >= 1)
733                 return 1;
734         /* context is ready to encode a frame */
735         if ((ctx->state == MFCINST_RUNNING ||
736                 ctx->state == MFCINST_HEAD_PRODUCED) &&
737                 ctx->src_queue_cnt >= 1 && ctx->dst_queue_cnt >= 1)
738                 return 1;
739         /* context is ready to encode remaining frames */
740         if (ctx->state == MFCINST_FINISHING &&
741                 ctx->dst_queue_cnt >= 1)
742                 return 1;
743         mfc_debug(2, "ctx is not ready\n");
744         return 0;
745 }
746
747 static void cleanup_ref_queue(struct s5p_mfc_ctx *ctx)
748 {
749         struct s5p_mfc_buf *mb_entry;
750
751         /* move buffers in ref queue to src queue */
752         while (!list_empty(&ctx->ref_queue)) {
753                 mb_entry = list_entry((&ctx->ref_queue)->next,
754                                                 struct s5p_mfc_buf, list);
755                 list_del(&mb_entry->list);
756                 ctx->ref_queue_cnt--;
757                 list_add_tail(&mb_entry->list, &ctx->src_queue);
758                 ctx->src_queue_cnt++;
759         }
760         mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
761                   ctx->src_queue_cnt, ctx->ref_queue_cnt);
762         INIT_LIST_HEAD(&ctx->ref_queue);
763         ctx->ref_queue_cnt = 0;
764 }
765
766 static int enc_pre_seq_start(struct s5p_mfc_ctx *ctx)
767 {
768         struct s5p_mfc_dev *dev = ctx->dev;
769         struct s5p_mfc_buf *dst_mb;
770         unsigned long dst_addr;
771         unsigned int dst_size;
772         unsigned long flags;
773
774         spin_lock_irqsave(&dev->irqlock, flags);
775         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
776         dst_addr = vb2_dma_contig_plane_dma_addr(&dst_mb->b->vb2_buf, 0);
777         dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 0);
778         s5p_mfc_hw_call_void(dev->mfc_ops, set_enc_stream_buffer, ctx, dst_addr,
779                         dst_size);
780         spin_unlock_irqrestore(&dev->irqlock, flags);
781         return 0;
782 }
783
784 static int enc_post_seq_start(struct s5p_mfc_ctx *ctx)
785 {
786         struct s5p_mfc_dev *dev = ctx->dev;
787         struct s5p_mfc_enc_params *p = &ctx->enc_params;
788         struct s5p_mfc_buf *dst_mb;
789         unsigned long flags;
790         unsigned int enc_pb_count;
791
792         if (p->seq_hdr_mode == V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) {
793                 spin_lock_irqsave(&dev->irqlock, flags);
794                 if (!list_empty(&ctx->dst_queue)) {
795                         dst_mb = list_entry(ctx->dst_queue.next,
796                                         struct s5p_mfc_buf, list);
797                         list_del(&dst_mb->list);
798                         ctx->dst_queue_cnt--;
799                         vb2_set_plane_payload(&dst_mb->b->vb2_buf, 0,
800                                 s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size,
801                                                 dev));
802                         vb2_buffer_done(&dst_mb->b->vb2_buf,
803                                         VB2_BUF_STATE_DONE);
804                 }
805                 spin_unlock_irqrestore(&dev->irqlock, flags);
806         }
807
808         if (!IS_MFCV6_PLUS(dev)) {
809                 ctx->state = MFCINST_RUNNING;
810                 if (s5p_mfc_ctx_ready(ctx))
811                         set_work_bit_irqsave(ctx);
812                 s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
813         } else {
814                 enc_pb_count = s5p_mfc_hw_call(dev->mfc_ops,
815                                 get_enc_dpb_count, dev);
816                 if (ctx->pb_count < enc_pb_count)
817                         ctx->pb_count = enc_pb_count;
818                 ctx->state = MFCINST_HEAD_PRODUCED;
819         }
820
821         return 0;
822 }
823
824 static int enc_pre_frame_start(struct s5p_mfc_ctx *ctx)
825 {
826         struct s5p_mfc_dev *dev = ctx->dev;
827         struct s5p_mfc_buf *dst_mb;
828         struct s5p_mfc_buf *src_mb;
829         unsigned long flags;
830         unsigned long src_y_addr, src_c_addr, dst_addr;
831         unsigned int dst_size;
832
833         spin_lock_irqsave(&dev->irqlock, flags);
834         src_mb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
835         src_y_addr = vb2_dma_contig_plane_dma_addr(&src_mb->b->vb2_buf, 0);
836         src_c_addr = vb2_dma_contig_plane_dma_addr(&src_mb->b->vb2_buf, 1);
837         s5p_mfc_hw_call_void(dev->mfc_ops, set_enc_frame_buffer, ctx,
838                                                         src_y_addr, src_c_addr);
839         spin_unlock_irqrestore(&dev->irqlock, flags);
840
841         spin_lock_irqsave(&dev->irqlock, flags);
842         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
843         dst_addr = vb2_dma_contig_plane_dma_addr(&dst_mb->b->vb2_buf, 0);
844         dst_size = vb2_plane_size(&dst_mb->b->vb2_buf, 0);
845         s5p_mfc_hw_call_void(dev->mfc_ops, set_enc_stream_buffer, ctx, dst_addr,
846                         dst_size);
847         spin_unlock_irqrestore(&dev->irqlock, flags);
848
849         return 0;
850 }
851
852 static int enc_post_frame_start(struct s5p_mfc_ctx *ctx)
853 {
854         struct s5p_mfc_dev *dev = ctx->dev;
855         struct s5p_mfc_buf *mb_entry;
856         unsigned long enc_y_addr, enc_c_addr;
857         unsigned long mb_y_addr, mb_c_addr;
858         int slice_type;
859         unsigned int strm_size;
860         unsigned long flags;
861
862         slice_type = s5p_mfc_hw_call(dev->mfc_ops, get_enc_slice_type, dev);
863         strm_size = s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size, dev);
864         mfc_debug(2, "Encoded slice type: %d\n", slice_type);
865         mfc_debug(2, "Encoded stream size: %d\n", strm_size);
866         mfc_debug(2, "Display order: %d\n",
867                   mfc_read(dev, S5P_FIMV_ENC_SI_PIC_CNT));
868         spin_lock_irqsave(&dev->irqlock, flags);
869         if (slice_type >= 0) {
870                 s5p_mfc_hw_call_void(dev->mfc_ops, get_enc_frame_buffer, ctx,
871                                 &enc_y_addr, &enc_c_addr);
872                 list_for_each_entry(mb_entry, &ctx->src_queue, list) {
873                         mb_y_addr = vb2_dma_contig_plane_dma_addr(
874                                         &mb_entry->b->vb2_buf, 0);
875                         mb_c_addr = vb2_dma_contig_plane_dma_addr(
876                                         &mb_entry->b->vb2_buf, 1);
877                         if ((enc_y_addr == mb_y_addr) &&
878                                                 (enc_c_addr == mb_c_addr)) {
879                                 list_del(&mb_entry->list);
880                                 ctx->src_queue_cnt--;
881                                 vb2_buffer_done(&mb_entry->b->vb2_buf,
882                                                         VB2_BUF_STATE_DONE);
883                                 break;
884                         }
885                 }
886                 list_for_each_entry(mb_entry, &ctx->ref_queue, list) {
887                         mb_y_addr = vb2_dma_contig_plane_dma_addr(
888                                         &mb_entry->b->vb2_buf, 0);
889                         mb_c_addr = vb2_dma_contig_plane_dma_addr(
890                                         &mb_entry->b->vb2_buf, 1);
891                         if ((enc_y_addr == mb_y_addr) &&
892                                                 (enc_c_addr == mb_c_addr)) {
893                                 list_del(&mb_entry->list);
894                                 ctx->ref_queue_cnt--;
895                                 vb2_buffer_done(&mb_entry->b->vb2_buf,
896                                                         VB2_BUF_STATE_DONE);
897                                 break;
898                         }
899                 }
900         }
901         if ((ctx->src_queue_cnt > 0) && (ctx->state == MFCINST_RUNNING)) {
902                 mb_entry = list_entry(ctx->src_queue.next, struct s5p_mfc_buf,
903                                                                         list);
904                 if (mb_entry->flags & MFC_BUF_FLAG_USED) {
905                         list_del(&mb_entry->list);
906                         ctx->src_queue_cnt--;
907                         list_add_tail(&mb_entry->list, &ctx->ref_queue);
908                         ctx->ref_queue_cnt++;
909                 }
910                 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
911                           ctx->src_queue_cnt, ctx->ref_queue_cnt);
912         }
913         if ((ctx->dst_queue_cnt > 0) && (strm_size > 0)) {
914                 mb_entry = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf,
915                                                                         list);
916                 list_del(&mb_entry->list);
917                 ctx->dst_queue_cnt--;
918                 switch (slice_type) {
919                 case S5P_FIMV_ENC_SI_SLICE_TYPE_I:
920                         mb_entry->b->flags |= V4L2_BUF_FLAG_KEYFRAME;
921                         break;
922                 case S5P_FIMV_ENC_SI_SLICE_TYPE_P:
923                         mb_entry->b->flags |= V4L2_BUF_FLAG_PFRAME;
924                         break;
925                 case S5P_FIMV_ENC_SI_SLICE_TYPE_B:
926                         mb_entry->b->flags |= V4L2_BUF_FLAG_BFRAME;
927                         break;
928                 }
929                 vb2_set_plane_payload(&mb_entry->b->vb2_buf, 0, strm_size);
930                 vb2_buffer_done(&mb_entry->b->vb2_buf, VB2_BUF_STATE_DONE);
931         }
932         spin_unlock_irqrestore(&dev->irqlock, flags);
933         if ((ctx->src_queue_cnt == 0) || (ctx->dst_queue_cnt == 0))
934                 clear_work_bit(ctx);
935         return 0;
936 }
937
938 static struct s5p_mfc_codec_ops encoder_codec_ops = {
939         .pre_seq_start          = enc_pre_seq_start,
940         .post_seq_start         = enc_post_seq_start,
941         .pre_frame_start        = enc_pre_frame_start,
942         .post_frame_start       = enc_post_frame_start,
943 };
944
945 /* Query capabilities of the device */
946 static int vidioc_querycap(struct file *file, void *priv,
947                            struct v4l2_capability *cap)
948 {
949         struct s5p_mfc_dev *dev = video_drvdata(file);
950
951         strncpy(cap->driver, dev->plat_dev->name, sizeof(cap->driver) - 1);
952         strncpy(cap->card, dev->plat_dev->name, sizeof(cap->card) - 1);
953         cap->bus_info[0] = 0;
954         /*
955          * This is only a mem-to-mem video device. The capture and output
956          * device capability flags are left only for backward compatibility
957          * and are scheduled for removal.
958          */
959         cap->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
960         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
961         return 0;
962 }
963
964 static int vidioc_enum_fmt(struct file *file, struct v4l2_fmtdesc *f,
965                                                         bool out)
966 {
967         struct s5p_mfc_dev *dev = video_drvdata(file);
968         struct s5p_mfc_fmt *fmt;
969         int i, j = 0;
970
971         for (i = 0; i < ARRAY_SIZE(formats); ++i) {
972                 if (out && formats[i].type != MFC_FMT_RAW)
973                         continue;
974                 else if (!out && formats[i].type != MFC_FMT_ENC)
975                         continue;
976                 else if ((dev->variant->version_bit & formats[i].versions) == 0)
977                         continue;
978
979                 if (j == f->index) {
980                         fmt = &formats[i];
981                         strlcpy(f->description, fmt->name,
982                                 sizeof(f->description));
983                         f->pixelformat = fmt->fourcc;
984                         return 0;
985                 }
986                 ++j;
987         }
988         return -EINVAL;
989 }
990
991 static int vidioc_enum_fmt_vid_cap_mplane(struct file *file, void *pirv,
992                                           struct v4l2_fmtdesc *f)
993 {
994         return vidioc_enum_fmt(file, f, false);
995 }
996
997 static int vidioc_enum_fmt_vid_out_mplane(struct file *file, void *prov,
998                                           struct v4l2_fmtdesc *f)
999 {
1000         return vidioc_enum_fmt(file, f, true);
1001 }
1002
1003 static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
1004 {
1005         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1006         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1007
1008         mfc_debug(2, "f->type = %d ctx->state = %d\n", f->type, ctx->state);
1009         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1010                 /* This is run on output (encoder dest) */
1011                 pix_fmt_mp->width = 0;
1012                 pix_fmt_mp->height = 0;
1013                 pix_fmt_mp->field = V4L2_FIELD_NONE;
1014                 pix_fmt_mp->pixelformat = ctx->dst_fmt->fourcc;
1015                 pix_fmt_mp->num_planes = ctx->dst_fmt->num_planes;
1016
1017                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->enc_dst_buf_size;
1018                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->enc_dst_buf_size;
1019         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1020                 /* This is run on capture (encoder src) */
1021                 pix_fmt_mp->width = ctx->img_width;
1022                 pix_fmt_mp->height = ctx->img_height;
1023
1024                 pix_fmt_mp->field = V4L2_FIELD_NONE;
1025                 pix_fmt_mp->pixelformat = ctx->src_fmt->fourcc;
1026                 pix_fmt_mp->num_planes = ctx->src_fmt->num_planes;
1027
1028                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1029                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1030                 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1031                 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1032         } else {
1033                 mfc_err("invalid buf type\n");
1034                 return -EINVAL;
1035         }
1036         return 0;
1037 }
1038
1039 static int vidioc_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
1040 {
1041         struct s5p_mfc_dev *dev = video_drvdata(file);
1042         struct s5p_mfc_fmt *fmt;
1043         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1044
1045         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1046                 fmt = find_format(f, MFC_FMT_ENC);
1047                 if (!fmt) {
1048                         mfc_err("failed to try output format\n");
1049                         return -EINVAL;
1050                 }
1051                 if (pix_fmt_mp->plane_fmt[0].sizeimage == 0) {
1052                         mfc_err("must be set encoding output size\n");
1053                         return -EINVAL;
1054                 }
1055                 if ((dev->variant->version_bit & fmt->versions) == 0) {
1056                         mfc_err("Unsupported format by this MFC version.\n");
1057                         return -EINVAL;
1058                 }
1059
1060                 pix_fmt_mp->plane_fmt[0].bytesperline =
1061                         pix_fmt_mp->plane_fmt[0].sizeimage;
1062         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1063                 fmt = find_format(f, MFC_FMT_RAW);
1064                 if (!fmt) {
1065                         mfc_err("failed to try output format\n");
1066                         return -EINVAL;
1067                 }
1068
1069                 if (fmt->num_planes != pix_fmt_mp->num_planes) {
1070                         mfc_err("failed to try output format\n");
1071                         return -EINVAL;
1072                 }
1073                 if ((dev->variant->version_bit & fmt->versions) == 0) {
1074                         mfc_err("Unsupported format by this MFC version.\n");
1075                         return -EINVAL;
1076                 }
1077
1078                 v4l_bound_align_image(&pix_fmt_mp->width, 8, 1920, 1,
1079                         &pix_fmt_mp->height, 4, 1080, 1, 0);
1080         } else {
1081                 mfc_err("invalid buf type\n");
1082                 return -EINVAL;
1083         }
1084         return 0;
1085 }
1086
1087 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
1088 {
1089         struct s5p_mfc_dev *dev = video_drvdata(file);
1090         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1091         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1092         int ret = 0;
1093
1094         ret = vidioc_try_fmt(file, priv, f);
1095         if (ret)
1096                 return ret;
1097         if (ctx->vq_src.streaming || ctx->vq_dst.streaming) {
1098                 v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__);
1099                 ret = -EBUSY;
1100                 goto out;
1101         }
1102         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1103                 /* dst_fmt is validated by call to vidioc_try_fmt */
1104                 ctx->dst_fmt = find_format(f, MFC_FMT_ENC);
1105                 ctx->state = MFCINST_INIT;
1106                 ctx->codec_mode = ctx->dst_fmt->codec_mode;
1107                 ctx->enc_dst_buf_size = pix_fmt_mp->plane_fmt[0].sizeimage;
1108                 pix_fmt_mp->plane_fmt[0].bytesperline = 0;
1109                 ctx->dst_bufs_cnt = 0;
1110                 ctx->capture_state = QUEUE_FREE;
1111                 ret = s5p_mfc_open_mfc_inst(dev, ctx);
1112         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1113                 /* src_fmt is validated by call to vidioc_try_fmt */
1114                 ctx->src_fmt = find_format(f, MFC_FMT_RAW);
1115                 ctx->img_width = pix_fmt_mp->width;
1116                 ctx->img_height = pix_fmt_mp->height;
1117                 mfc_debug(2, "codec number: %d\n", ctx->src_fmt->codec_mode);
1118                 mfc_debug(2, "fmt - w: %d, h: %d, ctx - w: %d, h: %d\n",
1119                         pix_fmt_mp->width, pix_fmt_mp->height,
1120                         ctx->img_width, ctx->img_height);
1121
1122                 s5p_mfc_hw_call_void(dev->mfc_ops, enc_calc_src_size, ctx);
1123                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1124                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1125                 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1126                 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1127
1128                 ctx->src_bufs_cnt = 0;
1129                 ctx->output_state = QUEUE_FREE;
1130         } else {
1131                 mfc_err("invalid buf type\n");
1132                 ret = -EINVAL;
1133         }
1134 out:
1135         mfc_debug_leave();
1136         return ret;
1137 }
1138
1139 static int vidioc_reqbufs(struct file *file, void *priv,
1140                                           struct v4l2_requestbuffers *reqbufs)
1141 {
1142         struct s5p_mfc_dev *dev = video_drvdata(file);
1143         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1144         int ret = 0;
1145
1146         /* if memory is not mmp or userptr return error */
1147         if ((reqbufs->memory != V4L2_MEMORY_MMAP) &&
1148                 (reqbufs->memory != V4L2_MEMORY_USERPTR))
1149                 return -EINVAL;
1150         if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1151                 if (reqbufs->count == 0) {
1152                         ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1153                         ctx->capture_state = QUEUE_FREE;
1154                         return ret;
1155                 }
1156                 if (ctx->capture_state != QUEUE_FREE) {
1157                         mfc_err("invalid capture state: %d\n",
1158                                                         ctx->capture_state);
1159                         return -EINVAL;
1160                 }
1161                 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1162                 if (ret != 0) {
1163                         mfc_err("error in vb2_reqbufs() for E(D)\n");
1164                         return ret;
1165                 }
1166                 ctx->capture_state = QUEUE_BUFS_REQUESTED;
1167
1168                 ret = s5p_mfc_hw_call(ctx->dev->mfc_ops,
1169                                 alloc_codec_buffers, ctx);
1170                 if (ret) {
1171                         mfc_err("Failed to allocate encoding buffers\n");
1172                         reqbufs->count = 0;
1173                         ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1174                         return -ENOMEM;
1175                 }
1176         } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1177                 if (reqbufs->count == 0) {
1178                         mfc_debug(2, "Freeing buffers\n");
1179                         ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1180                         s5p_mfc_hw_call_void(dev->mfc_ops, release_codec_buffers,
1181                                         ctx);
1182                         ctx->output_state = QUEUE_FREE;
1183                         return ret;
1184                 }
1185                 if (ctx->output_state != QUEUE_FREE) {
1186                         mfc_err("invalid output state: %d\n",
1187                                                         ctx->output_state);
1188                         return -EINVAL;
1189                 }
1190
1191                 if (IS_MFCV6_PLUS(dev)) {
1192                         /* Check for min encoder buffers */
1193                         if (ctx->pb_count &&
1194                                 (reqbufs->count < ctx->pb_count)) {
1195                                 reqbufs->count = ctx->pb_count;
1196                                 mfc_debug(2, "Minimum %d output buffers needed\n",
1197                                                 ctx->pb_count);
1198                         } else {
1199                                 ctx->pb_count = reqbufs->count;
1200                         }
1201                 }
1202
1203                 ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1204                 if (ret != 0) {
1205                         mfc_err("error in vb2_reqbufs() for E(S)\n");
1206                         return ret;
1207                 }
1208                 ctx->output_state = QUEUE_BUFS_REQUESTED;
1209         } else {
1210                 mfc_err("invalid buf type\n");
1211                 return -EINVAL;
1212         }
1213         return ret;
1214 }
1215
1216 static int vidioc_querybuf(struct file *file, void *priv,
1217                                                    struct v4l2_buffer *buf)
1218 {
1219         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1220         int ret = 0;
1221
1222         /* if memory is not mmp or userptr return error */
1223         if ((buf->memory != V4L2_MEMORY_MMAP) &&
1224                 (buf->memory != V4L2_MEMORY_USERPTR))
1225                 return -EINVAL;
1226         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1227                 if (ctx->state != MFCINST_GOT_INST) {
1228                         mfc_err("invalid context state: %d\n", ctx->state);
1229                         return -EINVAL;
1230                 }
1231                 ret = vb2_querybuf(&ctx->vq_dst, buf);
1232                 if (ret != 0) {
1233                         mfc_err("error in vb2_querybuf() for E(D)\n");
1234                         return ret;
1235                 }
1236                 buf->m.planes[0].m.mem_offset += DST_QUEUE_OFF_BASE;
1237         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1238                 ret = vb2_querybuf(&ctx->vq_src, buf);
1239                 if (ret != 0) {
1240                         mfc_err("error in vb2_querybuf() for E(S)\n");
1241                         return ret;
1242                 }
1243         } else {
1244                 mfc_err("invalid buf type\n");
1245                 return -EINVAL;
1246         }
1247         return ret;
1248 }
1249
1250 /* Queue a buffer */
1251 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1252 {
1253         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1254
1255         if (ctx->state == MFCINST_ERROR) {
1256                 mfc_err("Call on QBUF after unrecoverable error\n");
1257                 return -EIO;
1258         }
1259         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1260                 if (ctx->state == MFCINST_FINISHING) {
1261                         mfc_err("Call on QBUF after EOS command\n");
1262                         return -EIO;
1263                 }
1264                 return vb2_qbuf(&ctx->vq_src, buf);
1265         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1266                 return vb2_qbuf(&ctx->vq_dst, buf);
1267         }
1268         return -EINVAL;
1269 }
1270
1271 /* Dequeue a buffer */
1272 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1273 {
1274         const struct v4l2_event ev = {
1275                 .type = V4L2_EVENT_EOS
1276         };
1277         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1278         int ret;
1279
1280         if (ctx->state == MFCINST_ERROR) {
1281                 mfc_err("Call on DQBUF after unrecoverable error\n");
1282                 return -EIO;
1283         }
1284         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1285                 ret = vb2_dqbuf(&ctx->vq_src, buf, file->f_flags & O_NONBLOCK);
1286         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1287                 ret = vb2_dqbuf(&ctx->vq_dst, buf, file->f_flags & O_NONBLOCK);
1288                 if (ret == 0 && ctx->state == MFCINST_FINISHED
1289                                         && list_empty(&ctx->vq_dst.done_list))
1290                         v4l2_event_queue_fh(&ctx->fh, &ev);
1291         } else {
1292                 ret = -EINVAL;
1293         }
1294
1295         return ret;
1296 }
1297
1298 /* Export DMA buffer */
1299 static int vidioc_expbuf(struct file *file, void *priv,
1300         struct v4l2_exportbuffer *eb)
1301 {
1302         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1303
1304         if (eb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1305                 return vb2_expbuf(&ctx->vq_src, eb);
1306         if (eb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1307                 return vb2_expbuf(&ctx->vq_dst, eb);
1308         return -EINVAL;
1309 }
1310
1311 /* Stream on */
1312 static int vidioc_streamon(struct file *file, void *priv,
1313                            enum v4l2_buf_type type)
1314 {
1315         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1316
1317         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1318                 return vb2_streamon(&ctx->vq_src, type);
1319         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1320                 return vb2_streamon(&ctx->vq_dst, type);
1321         return -EINVAL;
1322 }
1323
1324 /* Stream off, which equals to a pause */
1325 static int vidioc_streamoff(struct file *file, void *priv,
1326                             enum v4l2_buf_type type)
1327 {
1328         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1329
1330         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1331                 return vb2_streamoff(&ctx->vq_src, type);
1332         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1333                 return vb2_streamoff(&ctx->vq_dst, type);
1334         return -EINVAL;
1335 }
1336
1337 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl)
1338 {
1339         static unsigned int t[V4L2_MPEG_VIDEO_H264_LEVEL_4_0 + 1] = {
1340                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0   */ 10,
1341                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B    */ 9,
1342                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1   */ 11,
1343                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2   */ 12,
1344                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3   */ 13,
1345                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0   */ 20,
1346                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1   */ 21,
1347                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2   */ 22,
1348                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0   */ 30,
1349                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1   */ 31,
1350                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2   */ 32,
1351                 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0   */ 40,
1352         };
1353         return t[lvl];
1354 }
1355
1356 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl)
1357 {
1358         static unsigned int t[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 + 1] = {
1359                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0    */ 0,
1360                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B   */ 9,
1361                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1    */ 1,
1362                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2    */ 2,
1363                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3    */ 3,
1364                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B   */ 7,
1365                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4    */ 4,
1366                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5    */ 5,
1367         };
1368         return t[lvl];
1369 }
1370
1371 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar)
1372 {
1373         static unsigned int t[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED + 1] = {
1374                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED     */ 0,
1375                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1             */ 1,
1376                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11           */ 2,
1377                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11           */ 3,
1378                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11           */ 4,
1379                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33           */ 5,
1380                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11           */ 6,
1381                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11           */ 7,
1382                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11           */ 8,
1383                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33           */ 9,
1384                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11           */ 10,
1385                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11           */ 11,
1386                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33           */ 12,
1387                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99          */ 13,
1388                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3             */ 14,
1389                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2             */ 15,
1390                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1             */ 16,
1391                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED        */ 255,
1392         };
1393         return t[sar];
1394 }
1395
1396 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
1397 {
1398         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1399         struct s5p_mfc_dev *dev = ctx->dev;
1400         struct s5p_mfc_enc_params *p = &ctx->enc_params;
1401         int ret = 0;
1402
1403         switch (ctrl->id) {
1404         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1405                 p->gop_size = ctrl->val;
1406                 break;
1407         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1408                 p->slice_mode = ctrl->val;
1409                 break;
1410         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1411                 p->slice_mb = ctrl->val;
1412                 break;
1413         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
1414                 p->slice_bit = ctrl->val * 8;
1415                 break;
1416         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1417                 p->intra_refresh_mb = ctrl->val;
1418                 break;
1419         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING:
1420                 p->pad = ctrl->val;
1421                 break;
1422         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV:
1423                 p->pad_luma = (ctrl->val >> 16) & 0xff;
1424                 p->pad_cb = (ctrl->val >> 8) & 0xff;
1425                 p->pad_cr = (ctrl->val >> 0) & 0xff;
1426                 break;
1427         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1428                 p->rc_frame = ctrl->val;
1429                 break;
1430         case V4L2_CID_MPEG_VIDEO_BITRATE:
1431                 p->rc_bitrate = ctrl->val;
1432                 break;
1433         case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF:
1434                 p->rc_reaction_coeff = ctrl->val;
1435                 break;
1436         case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1437                 ctx->force_frame_type = ctrl->val;
1438                 break;
1439         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:
1440                 p->vbv_size = ctrl->val;
1441                 break;
1442         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1443                 p->mv_h_range = ctrl->val;
1444                 break;
1445         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1446                 p->mv_v_range = ctrl->val;
1447                 break;
1448         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
1449                 p->codec.h264.cpb_size = ctrl->val;
1450                 break;
1451         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1452                 p->seq_hdr_mode = ctrl->val;
1453                 break;
1454         case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1455                 p->frame_skip_mode = ctrl->val;
1456                 break;
1457         case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT:
1458                 p->fixed_target_bit = ctrl->val;
1459                 break;
1460         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1461                 p->num_b_frame = ctrl->val;
1462                 break;
1463         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1464                 switch (ctrl->val) {
1465                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1466                         p->codec.h264.profile =
1467                                         S5P_FIMV_ENC_PROFILE_H264_MAIN;
1468                         break;
1469                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1470                         p->codec.h264.profile =
1471                                         S5P_FIMV_ENC_PROFILE_H264_HIGH;
1472                         break;
1473                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1474                         p->codec.h264.profile =
1475                                 S5P_FIMV_ENC_PROFILE_H264_BASELINE;
1476                         break;
1477                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1478                         if (IS_MFCV6_PLUS(dev))
1479                                 p->codec.h264.profile =
1480                                 S5P_FIMV_ENC_PROFILE_H264_CONSTRAINED_BASELINE;
1481                         else
1482                                 ret = -EINVAL;
1483                         break;
1484                 default:
1485                         ret = -EINVAL;
1486                 }
1487                 break;
1488         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1489                 p->codec.h264.level_v4l2 = ctrl->val;
1490                 p->codec.h264.level = h264_level(ctrl->val);
1491                 if (p->codec.h264.level < 0) {
1492                         mfc_err("Level number is wrong\n");
1493                         ret = p->codec.h264.level;
1494                 }
1495                 break;
1496         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1497                 p->codec.mpeg4.level_v4l2 = ctrl->val;
1498                 p->codec.mpeg4.level = mpeg4_level(ctrl->val);
1499                 if (p->codec.mpeg4.level < 0) {
1500                         mfc_err("Level number is wrong\n");
1501                         ret = p->codec.mpeg4.level;
1502                 }
1503                 break;
1504         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1505                 p->codec.h264.loop_filter_mode = ctrl->val;
1506                 break;
1507         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1508                 p->codec.h264.loop_filter_alpha = ctrl->val;
1509                 break;
1510         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1511                 p->codec.h264.loop_filter_beta = ctrl->val;
1512                 break;
1513         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1514                 p->codec.h264.entropy_mode = ctrl->val;
1515                 break;
1516         case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P:
1517                 p->codec.h264.num_ref_pic_4p = ctrl->val;
1518                 break;
1519         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1520                 p->codec.h264._8x8_transform = ctrl->val;
1521                 break;
1522         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1523                 p->rc_mb = ctrl->val;
1524                 break;
1525         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1526                 p->codec.h264.rc_frame_qp = ctrl->val;
1527                 break;
1528         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1529                 p->codec.h264.rc_min_qp = ctrl->val;
1530                 break;
1531         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1532                 p->codec.h264.rc_max_qp = ctrl->val;
1533                 break;
1534         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1535                 p->codec.h264.rc_p_frame_qp = ctrl->val;
1536                 break;
1537         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
1538                 p->codec.h264.rc_b_frame_qp = ctrl->val;
1539                 break;
1540         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1541         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:
1542                 p->codec.mpeg4.rc_frame_qp = ctrl->val;
1543                 break;
1544         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:
1545         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:
1546                 p->codec.mpeg4.rc_min_qp = ctrl->val;
1547                 break;
1548         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:
1549         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:
1550                 p->codec.mpeg4.rc_max_qp = ctrl->val;
1551                 break;
1552         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1553         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:
1554                 p->codec.mpeg4.rc_p_frame_qp = ctrl->val;
1555                 break;
1556         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:
1557         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:
1558                 p->codec.mpeg4.rc_b_frame_qp = ctrl->val;
1559                 break;
1560         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK:
1561                 p->codec.h264.rc_mb_dark = ctrl->val;
1562                 break;
1563         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH:
1564                 p->codec.h264.rc_mb_smooth = ctrl->val;
1565                 break;
1566         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC:
1567                 p->codec.h264.rc_mb_static = ctrl->val;
1568                 break;
1569         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY:
1570                 p->codec.h264.rc_mb_activity = ctrl->val;
1571                 break;
1572         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1573                 p->codec.h264.vui_sar = ctrl->val;
1574                 break;
1575         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1576                 p->codec.h264.vui_sar_idc = vui_sar_idc(ctrl->val);
1577                 break;
1578         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
1579                 p->codec.h264.vui_ext_sar_width = ctrl->val;
1580                 break;
1581         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
1582                 p->codec.h264.vui_ext_sar_height = ctrl->val;
1583                 break;
1584         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1585                 p->codec.h264.open_gop = !ctrl->val;
1586                 break;
1587         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
1588                 p->codec.h264.open_gop_size = ctrl->val;
1589                 break;
1590         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1591                 switch (ctrl->val) {
1592                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
1593                         p->codec.mpeg4.profile =
1594                                 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE;
1595                         break;
1596                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
1597                         p->codec.mpeg4.profile =
1598                         S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE;
1599                         break;
1600                 default:
1601                         ret = -EINVAL;
1602                 }
1603                 break;
1604         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1605                 p->codec.mpeg4.quarter_pixel = ctrl->val;
1606                 break;
1607         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1608                 p->codec.vp8.num_partitions = ctrl->val;
1609                 break;
1610         case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:
1611                 p->codec.vp8.imd_4x4 = ctrl->val;
1612                 break;
1613         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1614                 p->codec.vp8.num_ref = ctrl->val;
1615                 break;
1616         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:
1617                 p->codec.vp8.filter_level = ctrl->val;
1618                 break;
1619         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:
1620                 p->codec.vp8.filter_sharpness = ctrl->val;
1621                 break;
1622         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:
1623                 p->codec.vp8.golden_frame_ref_period = ctrl->val;
1624                 break;
1625         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1626                 p->codec.vp8.golden_frame_sel = ctrl->val;
1627                 break;
1628         case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:
1629                 p->codec.vp8.rc_min_qp = ctrl->val;
1630                 break;
1631         case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:
1632                 p->codec.vp8.rc_max_qp = ctrl->val;
1633                 break;
1634         case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:
1635                 p->codec.vp8.rc_frame_qp = ctrl->val;
1636                 break;
1637         case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:
1638                 p->codec.vp8.rc_p_frame_qp = ctrl->val;
1639                 break;
1640         case V4L2_CID_MPEG_VIDEO_VPX_PROFILE:
1641                 p->codec.vp8.profile = ctrl->val;
1642                 break;
1643         default:
1644                 v4l2_err(&dev->v4l2_dev, "Invalid control, id=%d, val=%d\n",
1645                                                         ctrl->id, ctrl->val);
1646                 ret = -EINVAL;
1647         }
1648         return ret;
1649 }
1650
1651 static int s5p_mfc_enc_g_v_ctrl(struct v4l2_ctrl *ctrl)
1652 {
1653         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1654         struct s5p_mfc_dev *dev = ctx->dev;
1655
1656         switch (ctrl->id) {
1657         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1658                 if (ctx->state >= MFCINST_HEAD_PARSED &&
1659                     ctx->state < MFCINST_ABORT) {
1660                         ctrl->val = ctx->pb_count;
1661                         break;
1662                 } else if (ctx->state != MFCINST_INIT) {
1663                         v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
1664                         return -EINVAL;
1665                 }
1666                 /* Should wait for the header to be produced */
1667                 s5p_mfc_wait_for_done_ctx(ctx,
1668                                 S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0);
1669                 if (ctx->state >= MFCINST_HEAD_PARSED &&
1670                     ctx->state < MFCINST_ABORT) {
1671                         ctrl->val = ctx->pb_count;
1672                 } else {
1673                         v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
1674                         return -EINVAL;
1675                 }
1676                 break;
1677         }
1678         return 0;
1679 }
1680
1681 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
1682         .s_ctrl = s5p_mfc_enc_s_ctrl,
1683         .g_volatile_ctrl = s5p_mfc_enc_g_v_ctrl,
1684 };
1685
1686 static int vidioc_s_parm(struct file *file, void *priv,
1687                          struct v4l2_streamparm *a)
1688 {
1689         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1690
1691         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1692                 ctx->enc_params.rc_framerate_num =
1693                                         a->parm.output.timeperframe.denominator;
1694                 ctx->enc_params.rc_framerate_denom =
1695                                         a->parm.output.timeperframe.numerator;
1696         } else {
1697                 mfc_err("Setting FPS is only possible for the output queue\n");
1698                 return -EINVAL;
1699         }
1700         return 0;
1701 }
1702
1703 static int vidioc_g_parm(struct file *file, void *priv,
1704                          struct v4l2_streamparm *a)
1705 {
1706         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1707
1708         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1709                 a->parm.output.timeperframe.denominator =
1710                                         ctx->enc_params.rc_framerate_num;
1711                 a->parm.output.timeperframe.numerator =
1712                                         ctx->enc_params.rc_framerate_denom;
1713         } else {
1714                 mfc_err("Setting FPS is only possible for the output queue\n");
1715                 return -EINVAL;
1716         }
1717         return 0;
1718 }
1719
1720 static int vidioc_encoder_cmd(struct file *file, void *priv,
1721                               struct v4l2_encoder_cmd *cmd)
1722 {
1723         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1724         struct s5p_mfc_dev *dev = ctx->dev;
1725         struct s5p_mfc_buf *buf;
1726         unsigned long flags;
1727
1728         switch (cmd->cmd) {
1729         case V4L2_ENC_CMD_STOP:
1730                 if (cmd->flags != 0)
1731                         return -EINVAL;
1732
1733                 if (!ctx->vq_src.streaming)
1734                         return -EINVAL;
1735
1736                 spin_lock_irqsave(&dev->irqlock, flags);
1737                 if (list_empty(&ctx->src_queue)) {
1738                         mfc_debug(2, "EOS: empty src queue, entering finishing state\n");
1739                         ctx->state = MFCINST_FINISHING;
1740                         if (s5p_mfc_ctx_ready(ctx))
1741                                 set_work_bit_irqsave(ctx);
1742                         spin_unlock_irqrestore(&dev->irqlock, flags);
1743                         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
1744                 } else {
1745                         mfc_debug(2, "EOS: marking last buffer of stream\n");
1746                         buf = list_entry(ctx->src_queue.prev,
1747                                                 struct s5p_mfc_buf, list);
1748                         if (buf->flags & MFC_BUF_FLAG_USED)
1749                                 ctx->state = MFCINST_FINISHING;
1750                         else
1751                                 buf->flags |= MFC_BUF_FLAG_EOS;
1752                         spin_unlock_irqrestore(&dev->irqlock, flags);
1753                 }
1754                 break;
1755         default:
1756                 return -EINVAL;
1757
1758         }
1759         return 0;
1760 }
1761
1762 static int vidioc_subscribe_event(struct v4l2_fh *fh,
1763                                   const struct v4l2_event_subscription *sub)
1764 {
1765         switch (sub->type) {
1766         case V4L2_EVENT_EOS:
1767                 return v4l2_event_subscribe(fh, sub, 2, NULL);
1768         default:
1769                 return -EINVAL;
1770         }
1771 }
1772
1773 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops = {
1774         .vidioc_querycap = vidioc_querycap,
1775         .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_cap_mplane,
1776         .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_out_mplane,
1777         .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt,
1778         .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt,
1779         .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt,
1780         .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt,
1781         .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt,
1782         .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt,
1783         .vidioc_reqbufs = vidioc_reqbufs,
1784         .vidioc_querybuf = vidioc_querybuf,
1785         .vidioc_qbuf = vidioc_qbuf,
1786         .vidioc_dqbuf = vidioc_dqbuf,
1787         .vidioc_expbuf = vidioc_expbuf,
1788         .vidioc_streamon = vidioc_streamon,
1789         .vidioc_streamoff = vidioc_streamoff,
1790         .vidioc_s_parm = vidioc_s_parm,
1791         .vidioc_g_parm = vidioc_g_parm,
1792         .vidioc_encoder_cmd = vidioc_encoder_cmd,
1793         .vidioc_subscribe_event = vidioc_subscribe_event,
1794         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1795 };
1796
1797 static int check_vb_with_fmt(struct s5p_mfc_fmt *fmt, struct vb2_buffer *vb)
1798 {
1799         int i;
1800
1801         if (!fmt)
1802                 return -EINVAL;
1803         if (fmt->num_planes != vb->num_planes) {
1804                 mfc_err("invalid plane number for the format\n");
1805                 return -EINVAL;
1806         }
1807         for (i = 0; i < fmt->num_planes; i++) {
1808                 dma_addr_t dma = vb2_dma_contig_plane_dma_addr(vb, i);
1809                 if (!dma) {
1810                         mfc_err("failed to get plane cookie\n");
1811                         return -EINVAL;
1812                 }
1813                 mfc_debug(2, "index: %d, plane[%d] cookie: %pad\n",
1814                           vb->index, i, &dma);
1815         }
1816         return 0;
1817 }
1818
1819 static int s5p_mfc_queue_setup(struct vb2_queue *vq,
1820                         const struct v4l2_format *fmt,
1821                         unsigned int *buf_count, unsigned int *plane_count,
1822                         unsigned int psize[], void *allocators[])
1823 {
1824         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1825         struct s5p_mfc_dev *dev = ctx->dev;
1826
1827         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1828                 if (ctx->state != MFCINST_GOT_INST) {
1829                         mfc_err("inavlid state: %d\n", ctx->state);
1830                         return -EINVAL;
1831                 }
1832
1833                 if (ctx->dst_fmt)
1834                         *plane_count = ctx->dst_fmt->num_planes;
1835                 else
1836                         *plane_count = MFC_ENC_CAP_PLANE_COUNT;
1837                 if (*buf_count < 1)
1838                         *buf_count = 1;
1839                 if (*buf_count > MFC_MAX_BUFFERS)
1840                         *buf_count = MFC_MAX_BUFFERS;
1841                 psize[0] = ctx->enc_dst_buf_size;
1842                 allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1843         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1844                 if (ctx->src_fmt)
1845                         *plane_count = ctx->src_fmt->num_planes;
1846                 else
1847                         *plane_count = MFC_ENC_OUT_PLANE_COUNT;
1848
1849                 if (*buf_count < 1)
1850                         *buf_count = 1;
1851                 if (*buf_count > MFC_MAX_BUFFERS)
1852                         *buf_count = MFC_MAX_BUFFERS;
1853
1854                 psize[0] = ctx->luma_size;
1855                 psize[1] = ctx->chroma_size;
1856
1857                 if (IS_MFCV6_PLUS(dev)) {
1858                         allocators[0] =
1859                                 ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1860                         allocators[1] =
1861                                 ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1862                 } else {
1863                         allocators[0] =
1864                                 ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1865                         allocators[1] =
1866                                 ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1867                 }
1868         } else {
1869                 mfc_err("inavlid queue type: %d\n", vq->type);
1870                 return -EINVAL;
1871         }
1872         return 0;
1873 }
1874
1875 static int s5p_mfc_buf_init(struct vb2_buffer *vb)
1876 {
1877         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1878         struct vb2_queue *vq = vb->vb2_queue;
1879         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1880         unsigned int i;
1881         int ret;
1882
1883         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1884                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1885                 if (ret < 0)
1886                         return ret;
1887                 i = vb->index;
1888                 ctx->dst_bufs[i].b = vbuf;
1889                 ctx->dst_bufs[i].cookie.stream =
1890                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1891                 ctx->dst_bufs_cnt++;
1892         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1893                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1894                 if (ret < 0)
1895                         return ret;
1896                 i = vb->index;
1897                 ctx->src_bufs[i].b = vbuf;
1898                 ctx->src_bufs[i].cookie.raw.luma =
1899                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1900                 ctx->src_bufs[i].cookie.raw.chroma =
1901                                         vb2_dma_contig_plane_dma_addr(vb, 1);
1902                 ctx->src_bufs_cnt++;
1903         } else {
1904                 mfc_err("inavlid queue type: %d\n", vq->type);
1905                 return -EINVAL;
1906         }
1907         return 0;
1908 }
1909
1910 static int s5p_mfc_buf_prepare(struct vb2_buffer *vb)
1911 {
1912         struct vb2_queue *vq = vb->vb2_queue;
1913         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1914         int ret;
1915
1916         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1917                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1918                 if (ret < 0)
1919                         return ret;
1920                 mfc_debug(2, "plane size: %ld, dst size: %zu\n",
1921                         vb2_plane_size(vb, 0), ctx->enc_dst_buf_size);
1922                 if (vb2_plane_size(vb, 0) < ctx->enc_dst_buf_size) {
1923                         mfc_err("plane size is too small for capture\n");
1924                         return -EINVAL;
1925                 }
1926         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1927                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1928                 if (ret < 0)
1929                         return ret;
1930                 mfc_debug(2, "plane size: %ld, luma size: %d\n",
1931                         vb2_plane_size(vb, 0), ctx->luma_size);
1932                 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
1933                         vb2_plane_size(vb, 1), ctx->chroma_size);
1934                 if (vb2_plane_size(vb, 0) < ctx->luma_size ||
1935                     vb2_plane_size(vb, 1) < ctx->chroma_size) {
1936                         mfc_err("plane size is too small for output\n");
1937                         return -EINVAL;
1938                 }
1939         } else {
1940                 mfc_err("inavlid queue type: %d\n", vq->type);
1941                 return -EINVAL;
1942         }
1943         return 0;
1944 }
1945
1946 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count)
1947 {
1948         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1949         struct s5p_mfc_dev *dev = ctx->dev;
1950
1951         if (IS_MFCV6_PLUS(dev) &&
1952                         (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)) {
1953
1954                 if ((ctx->state == MFCINST_GOT_INST) &&
1955                         (dev->curr_ctx == ctx->num) && dev->hw_lock) {
1956                         s5p_mfc_wait_for_done_ctx(ctx,
1957                                                 S5P_MFC_R2H_CMD_SEQ_DONE_RET,
1958                                                 0);
1959                 }
1960
1961                 if (ctx->src_bufs_cnt < ctx->pb_count) {
1962                         mfc_err("Need minimum %d OUTPUT buffers\n",
1963                                         ctx->pb_count);
1964                         return -ENOBUFS;
1965                 }
1966         }
1967
1968         /* If context is ready then dev = work->data;schedule it to run */
1969         if (s5p_mfc_ctx_ready(ctx))
1970                 set_work_bit_irqsave(ctx);
1971         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
1972
1973         return 0;
1974 }
1975
1976 static void s5p_mfc_stop_streaming(struct vb2_queue *q)
1977 {
1978         unsigned long flags;
1979         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1980         struct s5p_mfc_dev *dev = ctx->dev;
1981
1982         if ((ctx->state == MFCINST_FINISHING ||
1983                 ctx->state == MFCINST_RUNNING) &&
1984                 dev->curr_ctx == ctx->num && dev->hw_lock) {
1985                 ctx->state = MFCINST_ABORT;
1986                 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_FRAME_DONE_RET,
1987                                           0);
1988         }
1989         ctx->state = MFCINST_FINISHED;
1990         spin_lock_irqsave(&dev->irqlock, flags);
1991         if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1992                 s5p_mfc_hw_call_void(dev->mfc_ops, cleanup_queue,
1993                                                 &ctx->dst_queue, &ctx->vq_dst);
1994                 INIT_LIST_HEAD(&ctx->dst_queue);
1995                 ctx->dst_queue_cnt = 0;
1996         }
1997         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1998                 cleanup_ref_queue(ctx);
1999                 s5p_mfc_hw_call_void(dev->mfc_ops, cleanup_queue, &ctx->src_queue,
2000                                 &ctx->vq_src);
2001                 INIT_LIST_HEAD(&ctx->src_queue);
2002                 ctx->src_queue_cnt = 0;
2003         }
2004         spin_unlock_irqrestore(&dev->irqlock, flags);
2005 }
2006
2007 static void s5p_mfc_buf_queue(struct vb2_buffer *vb)
2008 {
2009         struct vb2_queue *vq = vb->vb2_queue;
2010         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2011         struct s5p_mfc_dev *dev = ctx->dev;
2012         unsigned long flags;
2013         struct s5p_mfc_buf *mfc_buf;
2014
2015         if (ctx->state == MFCINST_ERROR) {
2016                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2017                 cleanup_ref_queue(ctx);
2018                 return;
2019         }
2020         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2021                 mfc_buf = &ctx->dst_bufs[vb->index];
2022                 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2023                 /* Mark destination as available for use by MFC */
2024                 spin_lock_irqsave(&dev->irqlock, flags);
2025                 list_add_tail(&mfc_buf->list, &ctx->dst_queue);
2026                 ctx->dst_queue_cnt++;
2027                 spin_unlock_irqrestore(&dev->irqlock, flags);
2028         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2029                 mfc_buf = &ctx->src_bufs[vb->index];
2030                 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2031                 spin_lock_irqsave(&dev->irqlock, flags);
2032                 list_add_tail(&mfc_buf->list, &ctx->src_queue);
2033                 ctx->src_queue_cnt++;
2034                 spin_unlock_irqrestore(&dev->irqlock, flags);
2035         } else {
2036                 mfc_err("unsupported buffer type (%d)\n", vq->type);
2037         }
2038         if (s5p_mfc_ctx_ready(ctx))
2039                 set_work_bit_irqsave(ctx);
2040         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
2041 }
2042
2043 static struct vb2_ops s5p_mfc_enc_qops = {
2044         .queue_setup            = s5p_mfc_queue_setup,
2045         .wait_prepare           = vb2_ops_wait_prepare,
2046         .wait_finish            = vb2_ops_wait_finish,
2047         .buf_init               = s5p_mfc_buf_init,
2048         .buf_prepare            = s5p_mfc_buf_prepare,
2049         .start_streaming        = s5p_mfc_start_streaming,
2050         .stop_streaming         = s5p_mfc_stop_streaming,
2051         .buf_queue              = s5p_mfc_buf_queue,
2052 };
2053
2054 struct s5p_mfc_codec_ops *get_enc_codec_ops(void)
2055 {
2056         return &encoder_codec_ops;
2057 }
2058
2059 struct vb2_ops *get_enc_queue_ops(void)
2060 {
2061         return &s5p_mfc_enc_qops;
2062 }
2063
2064 const struct v4l2_ioctl_ops *get_enc_v4l2_ioctl_ops(void)
2065 {
2066         return &s5p_mfc_enc_ioctl_ops;
2067 }
2068
2069 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
2070                                                 && V4L2_CTRL_DRIVER_PRIV(x))
2071
2072 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
2073 {
2074         struct v4l2_ctrl_config cfg;
2075         int i;
2076
2077         v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS);
2078         if (ctx->ctrl_handler.error) {
2079                 mfc_err("v4l2_ctrl_handler_init failed\n");
2080                 return ctx->ctrl_handler.error;
2081         }
2082         for (i = 0; i < NUM_CTRLS; i++) {
2083                 if (IS_MFC51_PRIV(controls[i].id)) {
2084                         memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
2085                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
2086                         cfg.id = controls[i].id;
2087                         cfg.min = controls[i].minimum;
2088                         cfg.max = controls[i].maximum;
2089                         cfg.def = controls[i].default_value;
2090                         cfg.name = controls[i].name;
2091                         cfg.type = controls[i].type;
2092                         cfg.flags = 0;
2093
2094                         if (cfg.type == V4L2_CTRL_TYPE_MENU) {
2095                                 cfg.step = 0;
2096                                 cfg.menu_skip_mask = cfg.menu_skip_mask;
2097                                 cfg.qmenu = mfc51_get_menu(cfg.id);
2098                         } else {
2099                                 cfg.step = controls[i].step;
2100                                 cfg.menu_skip_mask = 0;
2101                         }
2102                         ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler,
2103                                         &cfg, NULL);
2104                 } else {
2105                         if ((controls[i].type == V4L2_CTRL_TYPE_MENU) ||
2106                                 (controls[i].type ==
2107                                         V4L2_CTRL_TYPE_INTEGER_MENU)) {
2108                                 ctx->ctrls[i] = v4l2_ctrl_new_std_menu(
2109                                         &ctx->ctrl_handler,
2110                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2111                                         controls[i].maximum, 0,
2112                                         controls[i].default_value);
2113                         } else {
2114                                 ctx->ctrls[i] = v4l2_ctrl_new_std(
2115                                         &ctx->ctrl_handler,
2116                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2117                                         controls[i].minimum,
2118                                         controls[i].maximum, controls[i].step,
2119                                         controls[i].default_value);
2120                         }
2121                 }
2122                 if (ctx->ctrl_handler.error) {
2123                         mfc_err("Adding control (%d) failed\n", i);
2124                         return ctx->ctrl_handler.error;
2125                 }
2126                 if (controls[i].is_volatile && ctx->ctrls[i])
2127                         ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
2128         }
2129         v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
2130         return 0;
2131 }
2132
2133 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx *ctx)
2134 {
2135         int i;
2136
2137         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2138         for (i = 0; i < NUM_CTRLS; i++)
2139                 ctx->ctrls[i] = NULL;
2140 }
2141
2142 void s5p_mfc_enc_init(struct s5p_mfc_ctx *ctx)
2143 {
2144         struct v4l2_format f;
2145         f.fmt.pix_mp.pixelformat = DEF_SRC_FMT_ENC;
2146         ctx->src_fmt = find_format(&f, MFC_FMT_RAW);
2147         f.fmt.pix_mp.pixelformat = DEF_DST_FMT_ENC;
2148         ctx->dst_fmt = find_format(&f, MFC_FMT_ENC);
2149 }
2150