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