drivers/media/video/s5p-mfc/s5p_mfc_enc.c

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