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