e42014c1cecade01bb4f413eb7c03a2626ce7c0b
[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, 0);
777         dst_size = vb2_plane_size(dst_mb->b, 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, 0,
800                                 s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size,
801                                                 dev));
802                         vb2_buffer_done(dst_mb->b, VB2_BUF_STATE_DONE);
803                 }
804                 spin_unlock_irqrestore(&dev->irqlock, flags);
805         }
806
807         if (!IS_MFCV6_PLUS(dev)) {
808                 ctx->state = MFCINST_RUNNING;
809                 if (s5p_mfc_ctx_ready(ctx))
810                         set_work_bit_irqsave(ctx);
811                 s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
812         } else {
813                 enc_pb_count = s5p_mfc_hw_call(dev->mfc_ops,
814                                 get_enc_dpb_count, dev);
815                 if (ctx->pb_count < enc_pb_count)
816                         ctx->pb_count = enc_pb_count;
817                 ctx->state = MFCINST_HEAD_PRODUCED;
818         }
819
820         return 0;
821 }
822
823 static int enc_pre_frame_start(struct s5p_mfc_ctx *ctx)
824 {
825         struct s5p_mfc_dev *dev = ctx->dev;
826         struct s5p_mfc_buf *dst_mb;
827         struct s5p_mfc_buf *src_mb;
828         unsigned long flags;
829         unsigned long src_y_addr, src_c_addr, dst_addr;
830         unsigned int dst_size;
831
832         spin_lock_irqsave(&dev->irqlock, flags);
833         src_mb = list_entry(ctx->src_queue.next, struct s5p_mfc_buf, list);
834         src_y_addr = vb2_dma_contig_plane_dma_addr(src_mb->b, 0);
835         src_c_addr = vb2_dma_contig_plane_dma_addr(src_mb->b, 1);
836         s5p_mfc_hw_call_void(dev->mfc_ops, set_enc_frame_buffer, ctx,
837                                                         src_y_addr, src_c_addr);
838         spin_unlock_irqrestore(&dev->irqlock, flags);
839
840         spin_lock_irqsave(&dev->irqlock, flags);
841         dst_mb = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf, list);
842         dst_addr = vb2_dma_contig_plane_dma_addr(dst_mb->b, 0);
843         dst_size = vb2_plane_size(dst_mb->b, 0);
844         s5p_mfc_hw_call_void(dev->mfc_ops, set_enc_stream_buffer, ctx, dst_addr,
845                         dst_size);
846         spin_unlock_irqrestore(&dev->irqlock, flags);
847
848         return 0;
849 }
850
851 static int enc_post_frame_start(struct s5p_mfc_ctx *ctx)
852 {
853         struct s5p_mfc_dev *dev = ctx->dev;
854         struct s5p_mfc_buf *mb_entry;
855         unsigned long enc_y_addr, enc_c_addr;
856         unsigned long mb_y_addr, mb_c_addr;
857         int slice_type;
858         unsigned int strm_size;
859         unsigned long flags;
860
861         slice_type = s5p_mfc_hw_call(dev->mfc_ops, get_enc_slice_type, dev);
862         strm_size = s5p_mfc_hw_call(dev->mfc_ops, get_enc_strm_size, dev);
863         mfc_debug(2, "Encoded slice type: %d\n", slice_type);
864         mfc_debug(2, "Encoded stream size: %d\n", strm_size);
865         mfc_debug(2, "Display order: %d\n",
866                   mfc_read(dev, S5P_FIMV_ENC_SI_PIC_CNT));
867         spin_lock_irqsave(&dev->irqlock, flags);
868         if (slice_type >= 0) {
869                 s5p_mfc_hw_call_void(dev->mfc_ops, get_enc_frame_buffer, ctx,
870                                 &enc_y_addr, &enc_c_addr);
871                 list_for_each_entry(mb_entry, &ctx->src_queue, list) {
872                         mb_y_addr = vb2_dma_contig_plane_dma_addr(mb_entry->b, 0);
873                         mb_c_addr = vb2_dma_contig_plane_dma_addr(mb_entry->b, 1);
874                         if ((enc_y_addr == mb_y_addr) &&
875                                                 (enc_c_addr == mb_c_addr)) {
876                                 list_del(&mb_entry->list);
877                                 ctx->src_queue_cnt--;
878                                 vb2_buffer_done(mb_entry->b,
879                                                         VB2_BUF_STATE_DONE);
880                                 break;
881                         }
882                 }
883                 list_for_each_entry(mb_entry, &ctx->ref_queue, list) {
884                         mb_y_addr = vb2_dma_contig_plane_dma_addr(mb_entry->b, 0);
885                         mb_c_addr = vb2_dma_contig_plane_dma_addr(mb_entry->b, 1);
886                         if ((enc_y_addr == mb_y_addr) &&
887                                                 (enc_c_addr == mb_c_addr)) {
888                                 list_del(&mb_entry->list);
889                                 ctx->ref_queue_cnt--;
890                                 vb2_buffer_done(mb_entry->b,
891                                                         VB2_BUF_STATE_DONE);
892                                 break;
893                         }
894                 }
895         }
896         if ((ctx->src_queue_cnt > 0) && (ctx->state == MFCINST_RUNNING)) {
897                 mb_entry = list_entry(ctx->src_queue.next, struct s5p_mfc_buf,
898                                                                         list);
899                 if (mb_entry->flags & MFC_BUF_FLAG_USED) {
900                         list_del(&mb_entry->list);
901                         ctx->src_queue_cnt--;
902                         list_add_tail(&mb_entry->list, &ctx->ref_queue);
903                         ctx->ref_queue_cnt++;
904                 }
905                 mfc_debug(2, "enc src count: %d, enc ref count: %d\n",
906                           ctx->src_queue_cnt, ctx->ref_queue_cnt);
907         }
908         if ((ctx->dst_queue_cnt > 0) && (strm_size > 0)) {
909                 mb_entry = list_entry(ctx->dst_queue.next, struct s5p_mfc_buf,
910                                                                         list);
911                 list_del(&mb_entry->list);
912                 ctx->dst_queue_cnt--;
913                 switch (slice_type) {
914                 case S5P_FIMV_ENC_SI_SLICE_TYPE_I:
915                         mb_entry->b->v4l2_buf.flags |= V4L2_BUF_FLAG_KEYFRAME;
916                         break;
917                 case S5P_FIMV_ENC_SI_SLICE_TYPE_P:
918                         mb_entry->b->v4l2_buf.flags |= V4L2_BUF_FLAG_PFRAME;
919                         break;
920                 case S5P_FIMV_ENC_SI_SLICE_TYPE_B:
921                         mb_entry->b->v4l2_buf.flags |= V4L2_BUF_FLAG_BFRAME;
922                         break;
923                 }
924                 vb2_set_plane_payload(mb_entry->b, 0, strm_size);
925                 vb2_buffer_done(mb_entry->b, VB2_BUF_STATE_DONE);
926         }
927         spin_unlock_irqrestore(&dev->irqlock, flags);
928         if ((ctx->src_queue_cnt == 0) || (ctx->dst_queue_cnt == 0))
929                 clear_work_bit(ctx);
930         return 0;
931 }
932
933 static struct s5p_mfc_codec_ops encoder_codec_ops = {
934         .pre_seq_start          = enc_pre_seq_start,
935         .post_seq_start         = enc_post_seq_start,
936         .pre_frame_start        = enc_pre_frame_start,
937         .post_frame_start       = enc_post_frame_start,
938 };
939
940 /* Query capabilities of the device */
941 static int vidioc_querycap(struct file *file, void *priv,
942                            struct v4l2_capability *cap)
943 {
944         struct s5p_mfc_dev *dev = video_drvdata(file);
945
946         strncpy(cap->driver, dev->plat_dev->name, sizeof(cap->driver) - 1);
947         strncpy(cap->card, dev->plat_dev->name, sizeof(cap->card) - 1);
948         cap->bus_info[0] = 0;
949         /*
950          * This is only a mem-to-mem video device. The capture and output
951          * device capability flags are left only for backward compatibility
952          * and are scheduled for removal.
953          */
954         cap->device_caps = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
955         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
956         return 0;
957 }
958
959 static int vidioc_enum_fmt(struct file *file, struct v4l2_fmtdesc *f,
960                                                         bool out)
961 {
962         struct s5p_mfc_dev *dev = video_drvdata(file);
963         struct s5p_mfc_fmt *fmt;
964         int i, j = 0;
965
966         for (i = 0; i < ARRAY_SIZE(formats); ++i) {
967                 if (out && formats[i].type != MFC_FMT_RAW)
968                         continue;
969                 else if (!out && formats[i].type != MFC_FMT_ENC)
970                         continue;
971                 else if ((dev->variant->version_bit & formats[i].versions) == 0)
972                         continue;
973
974                 if (j == f->index) {
975                         fmt = &formats[i];
976                         strlcpy(f->description, fmt->name,
977                                 sizeof(f->description));
978                         f->pixelformat = fmt->fourcc;
979                         return 0;
980                 }
981                 ++j;
982         }
983         return -EINVAL;
984 }
985
986 static int vidioc_enum_fmt_vid_cap_mplane(struct file *file, void *pirv,
987                                           struct v4l2_fmtdesc *f)
988 {
989         return vidioc_enum_fmt(file, f, false);
990 }
991
992 static int vidioc_enum_fmt_vid_out_mplane(struct file *file, void *prov,
993                                           struct v4l2_fmtdesc *f)
994 {
995         return vidioc_enum_fmt(file, f, true);
996 }
997
998 static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
999 {
1000         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1001         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1002
1003         mfc_debug(2, "f->type = %d ctx->state = %d\n", f->type, ctx->state);
1004         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1005                 /* This is run on output (encoder dest) */
1006                 pix_fmt_mp->width = 0;
1007                 pix_fmt_mp->height = 0;
1008                 pix_fmt_mp->field = V4L2_FIELD_NONE;
1009                 pix_fmt_mp->pixelformat = ctx->dst_fmt->fourcc;
1010                 pix_fmt_mp->num_planes = ctx->dst_fmt->num_planes;
1011
1012                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->enc_dst_buf_size;
1013                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->enc_dst_buf_size;
1014         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1015                 /* This is run on capture (encoder src) */
1016                 pix_fmt_mp->width = ctx->img_width;
1017                 pix_fmt_mp->height = ctx->img_height;
1018
1019                 pix_fmt_mp->field = V4L2_FIELD_NONE;
1020                 pix_fmt_mp->pixelformat = ctx->src_fmt->fourcc;
1021                 pix_fmt_mp->num_planes = ctx->src_fmt->num_planes;
1022
1023                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1024                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1025                 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1026                 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1027         } else {
1028                 mfc_err("invalid buf type\n");
1029                 return -EINVAL;
1030         }
1031         return 0;
1032 }
1033
1034 static int vidioc_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
1035 {
1036         struct s5p_mfc_dev *dev = video_drvdata(file);
1037         struct s5p_mfc_fmt *fmt;
1038         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1039
1040         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1041                 fmt = find_format(f, MFC_FMT_ENC);
1042                 if (!fmt) {
1043                         mfc_err("failed to try output format\n");
1044                         return -EINVAL;
1045                 }
1046                 if (pix_fmt_mp->plane_fmt[0].sizeimage == 0) {
1047                         mfc_err("must be set encoding output size\n");
1048                         return -EINVAL;
1049                 }
1050                 if ((dev->variant->version_bit & fmt->versions) == 0) {
1051                         mfc_err("Unsupported format by this MFC version.\n");
1052                         return -EINVAL;
1053                 }
1054
1055                 pix_fmt_mp->plane_fmt[0].bytesperline =
1056                         pix_fmt_mp->plane_fmt[0].sizeimage;
1057         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1058                 fmt = find_format(f, MFC_FMT_RAW);
1059                 if (!fmt) {
1060                         mfc_err("failed to try output format\n");
1061                         return -EINVAL;
1062                 }
1063
1064                 if (fmt->num_planes != pix_fmt_mp->num_planes) {
1065                         mfc_err("failed to try output format\n");
1066                         return -EINVAL;
1067                 }
1068                 if ((dev->variant->version_bit & fmt->versions) == 0) {
1069                         mfc_err("Unsupported format by this MFC version.\n");
1070                         return -EINVAL;
1071                 }
1072
1073                 v4l_bound_align_image(&pix_fmt_mp->width, 8, 1920, 1,
1074                         &pix_fmt_mp->height, 4, 1080, 1, 0);
1075         } else {
1076                 mfc_err("invalid buf type\n");
1077                 return -EINVAL;
1078         }
1079         return 0;
1080 }
1081
1082 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
1083 {
1084         struct s5p_mfc_dev *dev = video_drvdata(file);
1085         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1086         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1087         int ret = 0;
1088
1089         ret = vidioc_try_fmt(file, priv, f);
1090         if (ret)
1091                 return ret;
1092         if (ctx->vq_src.streaming || ctx->vq_dst.streaming) {
1093                 v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__);
1094                 ret = -EBUSY;
1095                 goto out;
1096         }
1097         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1098                 /* dst_fmt is validated by call to vidioc_try_fmt */
1099                 ctx->dst_fmt = find_format(f, MFC_FMT_ENC);
1100                 ctx->state = MFCINST_INIT;
1101                 ctx->codec_mode = ctx->dst_fmt->codec_mode;
1102                 ctx->enc_dst_buf_size = pix_fmt_mp->plane_fmt[0].sizeimage;
1103                 pix_fmt_mp->plane_fmt[0].bytesperline = 0;
1104                 ctx->dst_bufs_cnt = 0;
1105                 ctx->capture_state = QUEUE_FREE;
1106                 ret = s5p_mfc_open_mfc_inst(dev, ctx);
1107         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1108                 /* src_fmt is validated by call to vidioc_try_fmt */
1109                 ctx->src_fmt = find_format(f, MFC_FMT_RAW);
1110                 ctx->img_width = pix_fmt_mp->width;
1111                 ctx->img_height = pix_fmt_mp->height;
1112                 mfc_debug(2, "codec number: %d\n", ctx->src_fmt->codec_mode);
1113                 mfc_debug(2, "fmt - w: %d, h: %d, ctx - w: %d, h: %d\n",
1114                         pix_fmt_mp->width, pix_fmt_mp->height,
1115                         ctx->img_width, ctx->img_height);
1116
1117                 s5p_mfc_hw_call_void(dev->mfc_ops, enc_calc_src_size, ctx);
1118                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1119                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1120                 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1121                 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1122
1123                 ctx->src_bufs_cnt = 0;
1124                 ctx->output_state = QUEUE_FREE;
1125         } else {
1126                 mfc_err("invalid buf type\n");
1127                 ret = -EINVAL;
1128         }
1129 out:
1130         mfc_debug_leave();
1131         return ret;
1132 }
1133
1134 static int vidioc_reqbufs(struct file *file, void *priv,
1135                                           struct v4l2_requestbuffers *reqbufs)
1136 {
1137         struct s5p_mfc_dev *dev = video_drvdata(file);
1138         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1139         int ret = 0;
1140
1141         /* if memory is not mmp or userptr return error */
1142         if ((reqbufs->memory != V4L2_MEMORY_MMAP) &&
1143                 (reqbufs->memory != V4L2_MEMORY_USERPTR))
1144                 return -EINVAL;
1145         if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1146                 if (reqbufs->count == 0) {
1147                         ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1148                         ctx->capture_state = QUEUE_FREE;
1149                         return ret;
1150                 }
1151                 if (ctx->capture_state != QUEUE_FREE) {
1152                         mfc_err("invalid capture state: %d\n",
1153                                                         ctx->capture_state);
1154                         return -EINVAL;
1155                 }
1156                 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1157                 if (ret != 0) {
1158                         mfc_err("error in vb2_reqbufs() for E(D)\n");
1159                         return ret;
1160                 }
1161                 ctx->capture_state = QUEUE_BUFS_REQUESTED;
1162
1163                 ret = s5p_mfc_hw_call(ctx->dev->mfc_ops,
1164                                 alloc_codec_buffers, ctx);
1165                 if (ret) {
1166                         mfc_err("Failed to allocate encoding buffers\n");
1167                         reqbufs->count = 0;
1168                         ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1169                         return -ENOMEM;
1170                 }
1171         } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1172                 if (reqbufs->count == 0) {
1173                         mfc_debug(2, "Freeing buffers\n");
1174                         ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1175                         s5p_mfc_hw_call_void(dev->mfc_ops, release_codec_buffers,
1176                                         ctx);
1177                         ctx->output_state = QUEUE_FREE;
1178                         return ret;
1179                 }
1180                 if (ctx->output_state != QUEUE_FREE) {
1181                         mfc_err("invalid output state: %d\n",
1182                                                         ctx->output_state);
1183                         return -EINVAL;
1184                 }
1185
1186                 if (IS_MFCV6_PLUS(dev)) {
1187                         /* Check for min encoder buffers */
1188                         if (ctx->pb_count &&
1189                                 (reqbufs->count < ctx->pb_count)) {
1190                                 reqbufs->count = ctx->pb_count;
1191                                 mfc_debug(2, "Minimum %d output buffers needed\n",
1192                                                 ctx->pb_count);
1193                         } else {
1194                                 ctx->pb_count = reqbufs->count;
1195                         }
1196                 }
1197
1198                 ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1199                 if (ret != 0) {
1200                         mfc_err("error in vb2_reqbufs() for E(S)\n");
1201                         return ret;
1202                 }
1203                 ctx->output_state = QUEUE_BUFS_REQUESTED;
1204         } else {
1205                 mfc_err("invalid buf type\n");
1206                 return -EINVAL;
1207         }
1208         return ret;
1209 }
1210
1211 static int vidioc_querybuf(struct file *file, void *priv,
1212                                                    struct v4l2_buffer *buf)
1213 {
1214         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1215         int ret = 0;
1216
1217         /* if memory is not mmp or userptr return error */
1218         if ((buf->memory != V4L2_MEMORY_MMAP) &&
1219                 (buf->memory != V4L2_MEMORY_USERPTR))
1220                 return -EINVAL;
1221         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1222                 if (ctx->state != MFCINST_GOT_INST) {
1223                         mfc_err("invalid context state: %d\n", ctx->state);
1224                         return -EINVAL;
1225                 }
1226                 ret = vb2_querybuf(&ctx->vq_dst, buf);
1227                 if (ret != 0) {
1228                         mfc_err("error in vb2_querybuf() for E(D)\n");
1229                         return ret;
1230                 }
1231                 buf->m.planes[0].m.mem_offset += DST_QUEUE_OFF_BASE;
1232         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1233                 ret = vb2_querybuf(&ctx->vq_src, buf);
1234                 if (ret != 0) {
1235                         mfc_err("error in vb2_querybuf() for E(S)\n");
1236                         return ret;
1237                 }
1238         } else {
1239                 mfc_err("invalid buf type\n");
1240                 return -EINVAL;
1241         }
1242         return ret;
1243 }
1244
1245 /* Queue a buffer */
1246 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1247 {
1248         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1249
1250         if (ctx->state == MFCINST_ERROR) {
1251                 mfc_err("Call on QBUF after unrecoverable error\n");
1252                 return -EIO;
1253         }
1254         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1255                 if (ctx->state == MFCINST_FINISHING) {
1256                         mfc_err("Call on QBUF after EOS command\n");
1257                         return -EIO;
1258                 }
1259                 return vb2_qbuf(&ctx->vq_src, buf);
1260         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1261                 return vb2_qbuf(&ctx->vq_dst, buf);
1262         }
1263         return -EINVAL;
1264 }
1265
1266 /* Dequeue a buffer */
1267 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1268 {
1269         const struct v4l2_event ev = {
1270                 .type = V4L2_EVENT_EOS
1271         };
1272         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1273         int ret;
1274
1275         if (ctx->state == MFCINST_ERROR) {
1276                 mfc_err("Call on DQBUF after unrecoverable error\n");
1277                 return -EIO;
1278         }
1279         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1280                 ret = vb2_dqbuf(&ctx->vq_src, buf, file->f_flags & O_NONBLOCK);
1281         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1282                 ret = vb2_dqbuf(&ctx->vq_dst, buf, file->f_flags & O_NONBLOCK);
1283                 if (ret == 0 && ctx->state == MFCINST_FINISHED
1284                                         && list_empty(&ctx->vq_dst.done_list))
1285                         v4l2_event_queue_fh(&ctx->fh, &ev);
1286         } else {
1287                 ret = -EINVAL;
1288         }
1289
1290         return ret;
1291 }
1292
1293 /* Export DMA buffer */
1294 static int vidioc_expbuf(struct file *file, void *priv,
1295         struct v4l2_exportbuffer *eb)
1296 {
1297         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1298
1299         if (eb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1300                 return vb2_expbuf(&ctx->vq_src, eb);
1301         if (eb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1302                 return vb2_expbuf(&ctx->vq_dst, eb);
1303         return -EINVAL;
1304 }
1305
1306 /* Stream on */
1307 static int vidioc_streamon(struct file *file, void *priv,
1308                            enum v4l2_buf_type type)
1309 {
1310         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1311
1312         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1313                 return vb2_streamon(&ctx->vq_src, type);
1314         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1315                 return vb2_streamon(&ctx->vq_dst, type);
1316         return -EINVAL;
1317 }
1318
1319 /* Stream off, which equals to a pause */
1320 static int vidioc_streamoff(struct file *file, void *priv,
1321                             enum v4l2_buf_type type)
1322 {
1323         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1324
1325         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1326                 return vb2_streamoff(&ctx->vq_src, type);
1327         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1328                 return vb2_streamoff(&ctx->vq_dst, type);
1329         return -EINVAL;
1330 }
1331
1332 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl)
1333 {
1334         static unsigned int t[V4L2_MPEG_VIDEO_H264_LEVEL_4_0 + 1] = {
1335                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0   */ 10,
1336                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B    */ 9,
1337                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1   */ 11,
1338                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2   */ 12,
1339                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3   */ 13,
1340                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0   */ 20,
1341                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1   */ 21,
1342                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2   */ 22,
1343                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0   */ 30,
1344                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1   */ 31,
1345                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2   */ 32,
1346                 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0   */ 40,
1347         };
1348         return t[lvl];
1349 }
1350
1351 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl)
1352 {
1353         static unsigned int t[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 + 1] = {
1354                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0    */ 0,
1355                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B   */ 9,
1356                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1    */ 1,
1357                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2    */ 2,
1358                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3    */ 3,
1359                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B   */ 7,
1360                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4    */ 4,
1361                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5    */ 5,
1362         };
1363         return t[lvl];
1364 }
1365
1366 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar)
1367 {
1368         static unsigned int t[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED + 1] = {
1369                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED     */ 0,
1370                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1             */ 1,
1371                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11           */ 2,
1372                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11           */ 3,
1373                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11           */ 4,
1374                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33           */ 5,
1375                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11           */ 6,
1376                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11           */ 7,
1377                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11           */ 8,
1378                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33           */ 9,
1379                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11           */ 10,
1380                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11           */ 11,
1381                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33           */ 12,
1382                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99          */ 13,
1383                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3             */ 14,
1384                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2             */ 15,
1385                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1             */ 16,
1386                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED        */ 255,
1387         };
1388         return t[sar];
1389 }
1390
1391 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
1392 {
1393         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1394         struct s5p_mfc_dev *dev = ctx->dev;
1395         struct s5p_mfc_enc_params *p = &ctx->enc_params;
1396         int ret = 0;
1397
1398         switch (ctrl->id) {
1399         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1400                 p->gop_size = ctrl->val;
1401                 break;
1402         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1403                 p->slice_mode = ctrl->val;
1404                 break;
1405         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1406                 p->slice_mb = ctrl->val;
1407                 break;
1408         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
1409                 p->slice_bit = ctrl->val * 8;
1410                 break;
1411         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1412                 p->intra_refresh_mb = ctrl->val;
1413                 break;
1414         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING:
1415                 p->pad = ctrl->val;
1416                 break;
1417         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV:
1418                 p->pad_luma = (ctrl->val >> 16) & 0xff;
1419                 p->pad_cb = (ctrl->val >> 8) & 0xff;
1420                 p->pad_cr = (ctrl->val >> 0) & 0xff;
1421                 break;
1422         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1423                 p->rc_frame = ctrl->val;
1424                 break;
1425         case V4L2_CID_MPEG_VIDEO_BITRATE:
1426                 p->rc_bitrate = ctrl->val;
1427                 break;
1428         case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF:
1429                 p->rc_reaction_coeff = ctrl->val;
1430                 break;
1431         case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1432                 ctx->force_frame_type = ctrl->val;
1433                 break;
1434         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:
1435                 p->vbv_size = ctrl->val;
1436                 break;
1437         case V4L2_CID_MPEG_VIDEO_MV_H_SEARCH_RANGE:
1438                 p->mv_h_range = ctrl->val;
1439                 break;
1440         case V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE:
1441                 p->mv_v_range = ctrl->val;
1442                 break;
1443         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
1444                 p->codec.h264.cpb_size = ctrl->val;
1445                 break;
1446         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1447                 p->seq_hdr_mode = ctrl->val;
1448                 break;
1449         case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1450                 p->frame_skip_mode = ctrl->val;
1451                 break;
1452         case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT:
1453                 p->fixed_target_bit = ctrl->val;
1454                 break;
1455         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1456                 p->num_b_frame = ctrl->val;
1457                 break;
1458         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1459                 switch (ctrl->val) {
1460                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1461                         p->codec.h264.profile =
1462                                         S5P_FIMV_ENC_PROFILE_H264_MAIN;
1463                         break;
1464                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1465                         p->codec.h264.profile =
1466                                         S5P_FIMV_ENC_PROFILE_H264_HIGH;
1467                         break;
1468                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1469                         p->codec.h264.profile =
1470                                 S5P_FIMV_ENC_PROFILE_H264_BASELINE;
1471                         break;
1472                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1473                         if (IS_MFCV6_PLUS(dev))
1474                                 p->codec.h264.profile =
1475                                 S5P_FIMV_ENC_PROFILE_H264_CONSTRAINED_BASELINE;
1476                         else
1477                                 ret = -EINVAL;
1478                         break;
1479                 default:
1480                         ret = -EINVAL;
1481                 }
1482                 break;
1483         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1484                 p->codec.h264.level_v4l2 = ctrl->val;
1485                 p->codec.h264.level = h264_level(ctrl->val);
1486                 if (p->codec.h264.level < 0) {
1487                         mfc_err("Level number is wrong\n");
1488                         ret = p->codec.h264.level;
1489                 }
1490                 break;
1491         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1492                 p->codec.mpeg4.level_v4l2 = ctrl->val;
1493                 p->codec.mpeg4.level = mpeg4_level(ctrl->val);
1494                 if (p->codec.mpeg4.level < 0) {
1495                         mfc_err("Level number is wrong\n");
1496                         ret = p->codec.mpeg4.level;
1497                 }
1498                 break;
1499         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1500                 p->codec.h264.loop_filter_mode = ctrl->val;
1501                 break;
1502         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1503                 p->codec.h264.loop_filter_alpha = ctrl->val;
1504                 break;
1505         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1506                 p->codec.h264.loop_filter_beta = ctrl->val;
1507                 break;
1508         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1509                 p->codec.h264.entropy_mode = ctrl->val;
1510                 break;
1511         case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P:
1512                 p->codec.h264.num_ref_pic_4p = ctrl->val;
1513                 break;
1514         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1515                 p->codec.h264._8x8_transform = ctrl->val;
1516                 break;
1517         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1518                 p->rc_mb = ctrl->val;
1519                 break;
1520         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1521                 p->codec.h264.rc_frame_qp = ctrl->val;
1522                 break;
1523         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1524                 p->codec.h264.rc_min_qp = ctrl->val;
1525                 break;
1526         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1527                 p->codec.h264.rc_max_qp = ctrl->val;
1528                 break;
1529         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1530                 p->codec.h264.rc_p_frame_qp = ctrl->val;
1531                 break;
1532         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
1533                 p->codec.h264.rc_b_frame_qp = ctrl->val;
1534                 break;
1535         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1536         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:
1537                 p->codec.mpeg4.rc_frame_qp = ctrl->val;
1538                 break;
1539         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:
1540         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:
1541                 p->codec.mpeg4.rc_min_qp = ctrl->val;
1542                 break;
1543         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:
1544         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:
1545                 p->codec.mpeg4.rc_max_qp = ctrl->val;
1546                 break;
1547         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1548         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:
1549                 p->codec.mpeg4.rc_p_frame_qp = ctrl->val;
1550                 break;
1551         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:
1552         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:
1553                 p->codec.mpeg4.rc_b_frame_qp = ctrl->val;
1554                 break;
1555         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK:
1556                 p->codec.h264.rc_mb_dark = ctrl->val;
1557                 break;
1558         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH:
1559                 p->codec.h264.rc_mb_smooth = ctrl->val;
1560                 break;
1561         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC:
1562                 p->codec.h264.rc_mb_static = ctrl->val;
1563                 break;
1564         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY:
1565                 p->codec.h264.rc_mb_activity = ctrl->val;
1566                 break;
1567         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1568                 p->codec.h264.vui_sar = ctrl->val;
1569                 break;
1570         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1571                 p->codec.h264.vui_sar_idc = vui_sar_idc(ctrl->val);
1572                 break;
1573         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
1574                 p->codec.h264.vui_ext_sar_width = ctrl->val;
1575                 break;
1576         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
1577                 p->codec.h264.vui_ext_sar_height = ctrl->val;
1578                 break;
1579         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1580                 p->codec.h264.open_gop = !ctrl->val;
1581                 break;
1582         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
1583                 p->codec.h264.open_gop_size = ctrl->val;
1584                 break;
1585         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1586                 switch (ctrl->val) {
1587                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
1588                         p->codec.mpeg4.profile =
1589                                 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE;
1590                         break;
1591                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
1592                         p->codec.mpeg4.profile =
1593                         S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE;
1594                         break;
1595                 default:
1596                         ret = -EINVAL;
1597                 }
1598                 break;
1599         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1600                 p->codec.mpeg4.quarter_pixel = ctrl->val;
1601                 break;
1602         case V4L2_CID_MPEG_VIDEO_VPX_NUM_PARTITIONS:
1603                 p->codec.vp8.num_partitions = ctrl->val;
1604                 break;
1605         case V4L2_CID_MPEG_VIDEO_VPX_IMD_DISABLE_4X4:
1606                 p->codec.vp8.imd_4x4 = ctrl->val;
1607                 break;
1608         case V4L2_CID_MPEG_VIDEO_VPX_NUM_REF_FRAMES:
1609                 p->codec.vp8.num_ref = ctrl->val;
1610                 break;
1611         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_LEVEL:
1612                 p->codec.vp8.filter_level = ctrl->val;
1613                 break;
1614         case V4L2_CID_MPEG_VIDEO_VPX_FILTER_SHARPNESS:
1615                 p->codec.vp8.filter_sharpness = ctrl->val;
1616                 break;
1617         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_REF_PERIOD:
1618                 p->codec.vp8.golden_frame_ref_period = ctrl->val;
1619                 break;
1620         case V4L2_CID_MPEG_VIDEO_VPX_GOLDEN_FRAME_SEL:
1621                 p->codec.vp8.golden_frame_sel = ctrl->val;
1622                 break;
1623         case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:
1624                 p->codec.vp8.rc_min_qp = ctrl->val;
1625                 break;
1626         case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:
1627                 p->codec.vp8.rc_max_qp = ctrl->val;
1628                 break;
1629         case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP:
1630                 p->codec.vp8.rc_frame_qp = ctrl->val;
1631                 break;
1632         case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP:
1633                 p->codec.vp8.rc_p_frame_qp = ctrl->val;
1634                 break;
1635         case V4L2_CID_MPEG_VIDEO_VPX_PROFILE:
1636                 p->codec.vp8.profile = ctrl->val;
1637                 break;
1638         default:
1639                 v4l2_err(&dev->v4l2_dev, "Invalid control, id=%d, val=%d\n",
1640                                                         ctrl->id, ctrl->val);
1641                 ret = -EINVAL;
1642         }
1643         return ret;
1644 }
1645
1646 static int s5p_mfc_enc_g_v_ctrl(struct v4l2_ctrl *ctrl)
1647 {
1648         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1649         struct s5p_mfc_dev *dev = ctx->dev;
1650
1651         switch (ctrl->id) {
1652         case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
1653                 if (ctx->state >= MFCINST_HEAD_PARSED &&
1654                     ctx->state < MFCINST_ABORT) {
1655                         ctrl->val = ctx->pb_count;
1656                         break;
1657                 } else if (ctx->state != MFCINST_INIT) {
1658                         v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
1659                         return -EINVAL;
1660                 }
1661                 /* Should wait for the header to be produced */
1662                 s5p_mfc_wait_for_done_ctx(ctx,
1663                                 S5P_MFC_R2H_CMD_SEQ_DONE_RET, 0);
1664                 if (ctx->state >= MFCINST_HEAD_PARSED &&
1665                     ctx->state < MFCINST_ABORT) {
1666                         ctrl->val = ctx->pb_count;
1667                 } else {
1668                         v4l2_err(&dev->v4l2_dev, "Encoding not initialised\n");
1669                         return -EINVAL;
1670                 }
1671                 break;
1672         }
1673         return 0;
1674 }
1675
1676 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
1677         .s_ctrl = s5p_mfc_enc_s_ctrl,
1678         .g_volatile_ctrl = s5p_mfc_enc_g_v_ctrl,
1679 };
1680
1681 static int vidioc_s_parm(struct file *file, void *priv,
1682                          struct v4l2_streamparm *a)
1683 {
1684         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1685
1686         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1687                 ctx->enc_params.rc_framerate_num =
1688                                         a->parm.output.timeperframe.denominator;
1689                 ctx->enc_params.rc_framerate_denom =
1690                                         a->parm.output.timeperframe.numerator;
1691         } else {
1692                 mfc_err("Setting FPS is only possible for the output queue\n");
1693                 return -EINVAL;
1694         }
1695         return 0;
1696 }
1697
1698 static int vidioc_g_parm(struct file *file, void *priv,
1699                          struct v4l2_streamparm *a)
1700 {
1701         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1702
1703         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1704                 a->parm.output.timeperframe.denominator =
1705                                         ctx->enc_params.rc_framerate_num;
1706                 a->parm.output.timeperframe.numerator =
1707                                         ctx->enc_params.rc_framerate_denom;
1708         } else {
1709                 mfc_err("Setting FPS is only possible for the output queue\n");
1710                 return -EINVAL;
1711         }
1712         return 0;
1713 }
1714
1715 static int vidioc_encoder_cmd(struct file *file, void *priv,
1716                               struct v4l2_encoder_cmd *cmd)
1717 {
1718         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1719         struct s5p_mfc_dev *dev = ctx->dev;
1720         struct s5p_mfc_buf *buf;
1721         unsigned long flags;
1722
1723         switch (cmd->cmd) {
1724         case V4L2_ENC_CMD_STOP:
1725                 if (cmd->flags != 0)
1726                         return -EINVAL;
1727
1728                 if (!ctx->vq_src.streaming)
1729                         return -EINVAL;
1730
1731                 spin_lock_irqsave(&dev->irqlock, flags);
1732                 if (list_empty(&ctx->src_queue)) {
1733                         mfc_debug(2, "EOS: empty src queue, entering finishing state\n");
1734                         ctx->state = MFCINST_FINISHING;
1735                         if (s5p_mfc_ctx_ready(ctx))
1736                                 set_work_bit_irqsave(ctx);
1737                         spin_unlock_irqrestore(&dev->irqlock, flags);
1738                         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
1739                 } else {
1740                         mfc_debug(2, "EOS: marking last buffer of stream\n");
1741                         buf = list_entry(ctx->src_queue.prev,
1742                                                 struct s5p_mfc_buf, list);
1743                         if (buf->flags & MFC_BUF_FLAG_USED)
1744                                 ctx->state = MFCINST_FINISHING;
1745                         else
1746                                 buf->flags |= MFC_BUF_FLAG_EOS;
1747                         spin_unlock_irqrestore(&dev->irqlock, flags);
1748                 }
1749                 break;
1750         default:
1751                 return -EINVAL;
1752
1753         }
1754         return 0;
1755 }
1756
1757 static int vidioc_subscribe_event(struct v4l2_fh *fh,
1758                                   const struct v4l2_event_subscription *sub)
1759 {
1760         switch (sub->type) {
1761         case V4L2_EVENT_EOS:
1762                 return v4l2_event_subscribe(fh, sub, 2, NULL);
1763         default:
1764                 return -EINVAL;
1765         }
1766 }
1767
1768 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops = {
1769         .vidioc_querycap = vidioc_querycap,
1770         .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_cap_mplane,
1771         .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_out_mplane,
1772         .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt,
1773         .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt,
1774         .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt,
1775         .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt,
1776         .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt,
1777         .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt,
1778         .vidioc_reqbufs = vidioc_reqbufs,
1779         .vidioc_querybuf = vidioc_querybuf,
1780         .vidioc_qbuf = vidioc_qbuf,
1781         .vidioc_dqbuf = vidioc_dqbuf,
1782         .vidioc_expbuf = vidioc_expbuf,
1783         .vidioc_streamon = vidioc_streamon,
1784         .vidioc_streamoff = vidioc_streamoff,
1785         .vidioc_s_parm = vidioc_s_parm,
1786         .vidioc_g_parm = vidioc_g_parm,
1787         .vidioc_encoder_cmd = vidioc_encoder_cmd,
1788         .vidioc_subscribe_event = vidioc_subscribe_event,
1789         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1790 };
1791
1792 static int check_vb_with_fmt(struct s5p_mfc_fmt *fmt, struct vb2_buffer *vb)
1793 {
1794         int i;
1795
1796         if (!fmt)
1797                 return -EINVAL;
1798         if (fmt->num_planes != vb->num_planes) {
1799                 mfc_err("invalid plane number for the format\n");
1800                 return -EINVAL;
1801         }
1802         for (i = 0; i < fmt->num_planes; i++) {
1803                 dma_addr_t dma = vb2_dma_contig_plane_dma_addr(vb, i);
1804                 if (!dma) {
1805                         mfc_err("failed to get plane cookie\n");
1806                         return -EINVAL;
1807                 }
1808                 mfc_debug(2, "index: %d, plane[%d] cookie: %pad\n",
1809                           vb->v4l2_buf.index, i, &dma);
1810         }
1811         return 0;
1812 }
1813
1814 static int s5p_mfc_queue_setup(struct vb2_queue *vq,
1815                         const struct v4l2_format *fmt,
1816                         unsigned int *buf_count, unsigned int *plane_count,
1817                         unsigned int psize[], void *allocators[])
1818 {
1819         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1820         struct s5p_mfc_dev *dev = ctx->dev;
1821
1822         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1823                 if (ctx->state != MFCINST_GOT_INST) {
1824                         mfc_err("inavlid state: %d\n", ctx->state);
1825                         return -EINVAL;
1826                 }
1827
1828                 if (ctx->dst_fmt)
1829                         *plane_count = ctx->dst_fmt->num_planes;
1830                 else
1831                         *plane_count = MFC_ENC_CAP_PLANE_COUNT;
1832                 if (*buf_count < 1)
1833                         *buf_count = 1;
1834                 if (*buf_count > MFC_MAX_BUFFERS)
1835                         *buf_count = MFC_MAX_BUFFERS;
1836                 psize[0] = ctx->enc_dst_buf_size;
1837                 allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1838         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1839                 if (ctx->src_fmt)
1840                         *plane_count = ctx->src_fmt->num_planes;
1841                 else
1842                         *plane_count = MFC_ENC_OUT_PLANE_COUNT;
1843
1844                 if (*buf_count < 1)
1845                         *buf_count = 1;
1846                 if (*buf_count > MFC_MAX_BUFFERS)
1847                         *buf_count = MFC_MAX_BUFFERS;
1848
1849                 psize[0] = ctx->luma_size;
1850                 psize[1] = ctx->chroma_size;
1851
1852                 if (IS_MFCV6_PLUS(dev)) {
1853                         allocators[0] =
1854                                 ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1855                         allocators[1] =
1856                                 ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1857                 } else {
1858                         allocators[0] =
1859                                 ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1860                         allocators[1] =
1861                                 ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1862                 }
1863         } else {
1864                 mfc_err("inavlid queue type: %d\n", vq->type);
1865                 return -EINVAL;
1866         }
1867         return 0;
1868 }
1869
1870 static int s5p_mfc_buf_init(struct vb2_buffer *vb)
1871 {
1872         struct vb2_queue *vq = vb->vb2_queue;
1873         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1874         unsigned int i;
1875         int ret;
1876
1877         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1878                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1879                 if (ret < 0)
1880                         return ret;
1881                 i = vb->v4l2_buf.index;
1882                 ctx->dst_bufs[i].b = vb;
1883                 ctx->dst_bufs[i].cookie.stream =
1884                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1885                 ctx->dst_bufs_cnt++;
1886         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1887                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1888                 if (ret < 0)
1889                         return ret;
1890                 i = vb->v4l2_buf.index;
1891                 ctx->src_bufs[i].b = vb;
1892                 ctx->src_bufs[i].cookie.raw.luma =
1893                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1894                 ctx->src_bufs[i].cookie.raw.chroma =
1895                                         vb2_dma_contig_plane_dma_addr(vb, 1);
1896                 ctx->src_bufs_cnt++;
1897         } else {
1898                 mfc_err("inavlid queue type: %d\n", vq->type);
1899                 return -EINVAL;
1900         }
1901         return 0;
1902 }
1903
1904 static int s5p_mfc_buf_prepare(struct vb2_buffer *vb)
1905 {
1906         struct vb2_queue *vq = vb->vb2_queue;
1907         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1908         int ret;
1909
1910         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1911                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1912                 if (ret < 0)
1913                         return ret;
1914                 mfc_debug(2, "plane size: %ld, dst size: %zu\n",
1915                         vb2_plane_size(vb, 0), ctx->enc_dst_buf_size);
1916                 if (vb2_plane_size(vb, 0) < ctx->enc_dst_buf_size) {
1917                         mfc_err("plane size is too small for capture\n");
1918                         return -EINVAL;
1919                 }
1920         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1921                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1922                 if (ret < 0)
1923                         return ret;
1924                 mfc_debug(2, "plane size: %ld, luma size: %d\n",
1925                         vb2_plane_size(vb, 0), ctx->luma_size);
1926                 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
1927                         vb2_plane_size(vb, 1), ctx->chroma_size);
1928                 if (vb2_plane_size(vb, 0) < ctx->luma_size ||
1929                     vb2_plane_size(vb, 1) < ctx->chroma_size) {
1930                         mfc_err("plane size is too small for output\n");
1931                         return -EINVAL;
1932                 }
1933         } else {
1934                 mfc_err("inavlid queue type: %d\n", vq->type);
1935                 return -EINVAL;
1936         }
1937         return 0;
1938 }
1939
1940 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count)
1941 {
1942         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1943         struct s5p_mfc_dev *dev = ctx->dev;
1944
1945         if (IS_MFCV6_PLUS(dev) &&
1946                         (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)) {
1947
1948                 if ((ctx->state == MFCINST_GOT_INST) &&
1949                         (dev->curr_ctx == ctx->num) && dev->hw_lock) {
1950                         s5p_mfc_wait_for_done_ctx(ctx,
1951                                                 S5P_MFC_R2H_CMD_SEQ_DONE_RET,
1952                                                 0);
1953                 }
1954
1955                 if (ctx->src_bufs_cnt < ctx->pb_count) {
1956                         mfc_err("Need minimum %d OUTPUT buffers\n",
1957                                         ctx->pb_count);
1958                         return -ENOBUFS;
1959                 }
1960         }
1961
1962         /* If context is ready then dev = work->data;schedule it to run */
1963         if (s5p_mfc_ctx_ready(ctx))
1964                 set_work_bit_irqsave(ctx);
1965         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
1966
1967         return 0;
1968 }
1969
1970 static void s5p_mfc_stop_streaming(struct vb2_queue *q)
1971 {
1972         unsigned long flags;
1973         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1974         struct s5p_mfc_dev *dev = ctx->dev;
1975
1976         if ((ctx->state == MFCINST_FINISHING ||
1977                 ctx->state == MFCINST_RUNNING) &&
1978                 dev->curr_ctx == ctx->num && dev->hw_lock) {
1979                 ctx->state = MFCINST_ABORT;
1980                 s5p_mfc_wait_for_done_ctx(ctx, S5P_MFC_R2H_CMD_FRAME_DONE_RET,
1981                                           0);
1982         }
1983         ctx->state = MFCINST_FINISHED;
1984         spin_lock_irqsave(&dev->irqlock, flags);
1985         if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1986                 s5p_mfc_hw_call_void(dev->mfc_ops, cleanup_queue,
1987                                                 &ctx->dst_queue, &ctx->vq_dst);
1988                 INIT_LIST_HEAD(&ctx->dst_queue);
1989                 ctx->dst_queue_cnt = 0;
1990         }
1991         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1992                 cleanup_ref_queue(ctx);
1993                 s5p_mfc_hw_call_void(dev->mfc_ops, cleanup_queue, &ctx->src_queue,
1994                                 &ctx->vq_src);
1995                 INIT_LIST_HEAD(&ctx->src_queue);
1996                 ctx->src_queue_cnt = 0;
1997         }
1998         spin_unlock_irqrestore(&dev->irqlock, flags);
1999 }
2000
2001 static void s5p_mfc_buf_queue(struct vb2_buffer *vb)
2002 {
2003         struct vb2_queue *vq = vb->vb2_queue;
2004         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
2005         struct s5p_mfc_dev *dev = ctx->dev;
2006         unsigned long flags;
2007         struct s5p_mfc_buf *mfc_buf;
2008
2009         if (ctx->state == MFCINST_ERROR) {
2010                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
2011                 cleanup_ref_queue(ctx);
2012                 return;
2013         }
2014         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
2015                 mfc_buf = &ctx->dst_bufs[vb->v4l2_buf.index];
2016                 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2017                 /* Mark destination as available for use by MFC */
2018                 spin_lock_irqsave(&dev->irqlock, flags);
2019                 list_add_tail(&mfc_buf->list, &ctx->dst_queue);
2020                 ctx->dst_queue_cnt++;
2021                 spin_unlock_irqrestore(&dev->irqlock, flags);
2022         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
2023                 mfc_buf = &ctx->src_bufs[vb->v4l2_buf.index];
2024                 mfc_buf->flags &= ~MFC_BUF_FLAG_USED;
2025                 spin_lock_irqsave(&dev->irqlock, flags);
2026                 list_add_tail(&mfc_buf->list, &ctx->src_queue);
2027                 ctx->src_queue_cnt++;
2028                 spin_unlock_irqrestore(&dev->irqlock, flags);
2029         } else {
2030                 mfc_err("unsupported buffer type (%d)\n", vq->type);
2031         }
2032         if (s5p_mfc_ctx_ready(ctx))
2033                 set_work_bit_irqsave(ctx);
2034         s5p_mfc_hw_call_void(dev->mfc_ops, try_run, dev);
2035 }
2036
2037 static struct vb2_ops s5p_mfc_enc_qops = {
2038         .queue_setup            = s5p_mfc_queue_setup,
2039         .wait_prepare           = vb2_ops_wait_prepare,
2040         .wait_finish            = vb2_ops_wait_finish,
2041         .buf_init               = s5p_mfc_buf_init,
2042         .buf_prepare            = s5p_mfc_buf_prepare,
2043         .start_streaming        = s5p_mfc_start_streaming,
2044         .stop_streaming         = s5p_mfc_stop_streaming,
2045         .buf_queue              = s5p_mfc_buf_queue,
2046 };
2047
2048 struct s5p_mfc_codec_ops *get_enc_codec_ops(void)
2049 {
2050         return &encoder_codec_ops;
2051 }
2052
2053 struct vb2_ops *get_enc_queue_ops(void)
2054 {
2055         return &s5p_mfc_enc_qops;
2056 }
2057
2058 const struct v4l2_ioctl_ops *get_enc_v4l2_ioctl_ops(void)
2059 {
2060         return &s5p_mfc_enc_ioctl_ops;
2061 }
2062
2063 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
2064                                                 && V4L2_CTRL_DRIVER_PRIV(x))
2065
2066 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
2067 {
2068         struct v4l2_ctrl_config cfg;
2069         int i;
2070
2071         v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS);
2072         if (ctx->ctrl_handler.error) {
2073                 mfc_err("v4l2_ctrl_handler_init failed\n");
2074                 return ctx->ctrl_handler.error;
2075         }
2076         for (i = 0; i < NUM_CTRLS; i++) {
2077                 if (IS_MFC51_PRIV(controls[i].id)) {
2078                         memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
2079                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
2080                         cfg.id = controls[i].id;
2081                         cfg.min = controls[i].minimum;
2082                         cfg.max = controls[i].maximum;
2083                         cfg.def = controls[i].default_value;
2084                         cfg.name = controls[i].name;
2085                         cfg.type = controls[i].type;
2086                         cfg.flags = 0;
2087
2088                         if (cfg.type == V4L2_CTRL_TYPE_MENU) {
2089                                 cfg.step = 0;
2090                                 cfg.menu_skip_mask = cfg.menu_skip_mask;
2091                                 cfg.qmenu = mfc51_get_menu(cfg.id);
2092                         } else {
2093                                 cfg.step = controls[i].step;
2094                                 cfg.menu_skip_mask = 0;
2095                         }
2096                         ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler,
2097                                         &cfg, NULL);
2098                 } else {
2099                         if ((controls[i].type == V4L2_CTRL_TYPE_MENU) ||
2100                                 (controls[i].type ==
2101                                         V4L2_CTRL_TYPE_INTEGER_MENU)) {
2102                                 ctx->ctrls[i] = v4l2_ctrl_new_std_menu(
2103                                         &ctx->ctrl_handler,
2104                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2105                                         controls[i].maximum, 0,
2106                                         controls[i].default_value);
2107                         } else {
2108                                 ctx->ctrls[i] = v4l2_ctrl_new_std(
2109                                         &ctx->ctrl_handler,
2110                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2111                                         controls[i].minimum,
2112                                         controls[i].maximum, controls[i].step,
2113                                         controls[i].default_value);
2114                         }
2115                 }
2116                 if (ctx->ctrl_handler.error) {
2117                         mfc_err("Adding control (%d) failed\n", i);
2118                         return ctx->ctrl_handler.error;
2119                 }
2120                 if (controls[i].is_volatile && ctx->ctrls[i])
2121                         ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
2122         }
2123         v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
2124         return 0;
2125 }
2126
2127 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx *ctx)
2128 {
2129         int i;
2130
2131         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2132         for (i = 0; i < NUM_CTRLS; i++)
2133                 ctx->ctrls[i] = NULL;
2134 }
2135
2136 void s5p_mfc_enc_init(struct s5p_mfc_ctx *ctx)
2137 {
2138         struct v4l2_format f;
2139         f.fmt.pix_mp.pixelformat = DEF_SRC_FMT_ENC;
2140         ctx->src_fmt = find_format(&f, MFC_FMT_RAW);
2141         f.fmt.pix_mp.pixelformat = DEF_DST_FMT_ENC;
2142         ctx->dst_fmt = find_format(&f, MFC_FMT_ENC);
2143 }
2144