s5p_mfc_enc.c revision 79aeb3f3083a8a795467eae429cb2d6faf482f32
1/* 2 * linux/drivers/media/platform/s5p-mfc/s5p_mfc_enc.c 3 * 4 * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd. 5 * http://www.samsung.com/ 6 * 7 * Jeongtae Park <jtp.park@samsung.com> 8 * Kamil Debski <k.debski@samsung.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 */ 15 16#include <linux/clk.h> 17#include <linux/interrupt.h> 18#include <linux/io.h> 19#include <linux/module.h> 20#include <linux/platform_device.h> 21#include <linux/sched.h> 22#include <linux/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 = 12, 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 = 51, 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 = 31, 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 = 51, 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 /* context is ready to make header */ 652 if (ctx->state == MFCINST_GOT_INST && ctx->dst_queue_cnt >= 1) 653 return 1; 654 /* context is ready to encode a frame */ 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 /* context is ready to encode remaining frames */ 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 /* move buffers in ref queue to src queue */ 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 /* at least one more dest. buffers exist always */ 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/* Query capabilities of the device */ 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 * This is only a mem-to-mem video device. The capture and output 873 * device capability flags are left only for backward compatibility 874 * and are scheduled for removal. 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 /* This is run on output (encoder dest) */ 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 /* This is run on capture (encoder src) */ 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 /* dst_fmt is validated by call to vidioc_try_fmt */ 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 /* Error or timeout */ 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 /* src_fmt is validated by call to vidioc_try_fmt */ 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 /* if memory is not mmp or userptr return error */ 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 /* Check for min encoder buffers */ 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 /* if memory is not mmp or userptr return error */ 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/* Queue a buffer */ 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/* Dequeue a buffer */ 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/* Export DMA buffer */ 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/* Stream on */ 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/* Stream off, which equals to a pause */ 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 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0 */ 10, 1279 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B */ 9, 1280 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1 */ 11, 1281 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2 */ 12, 1282 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3 */ 13, 1283 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0 */ 20, 1284 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1 */ 21, 1285 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2 */ 22, 1286 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0 */ 30, 1287 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1 */ 31, 1288 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2 */ 32, 1289 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0 */ 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 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0 */ 0, 1298 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B */ 9, 1299 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1 */ 1, 1300 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2 */ 2, 1301 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3 */ 3, 1302 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B */ 7, 1303 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4 */ 4, 1304 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 */ 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 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED */ 0, 1313 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1 */ 1, 1314 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11 */ 2, 1315 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11 */ 3, 1316 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11 */ 4, 1317 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33 */ 5, 1318 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11 */ 6, 1319 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11 */ 7, 1320 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11 */ 8, 1321 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33 */ 9, 1322 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11 */ 10, 1323 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11 */ 11, 1324 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33 */ 12, 1325 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99 */ 13, 1326 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3 */ 14, 1327 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2 */ 15, 1328 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1 */ 16, 1329 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED */ 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 -ENOBUFS; 1867 } 1868 } 1869 1870 /* If context is ready then dev = work->data;schedule it to run */ 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 /* Mark destination as available for use by MFC */ 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