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_fmt *fmt;
1038         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1039
1040         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1041                 fmt = find_format(f, MFC_FMT_ENC);
1042                 if (!fmt) {
1043                         mfc_err("failed to try output format\n");
1044                         return -EINVAL;
1045                 }
1046
1047                 if (pix_fmt_mp->plane_fmt[0].sizeimage == 0) {
1048                         mfc_err("must be set encoding output size\n");
1049                         return -EINVAL;
1050                 }
1051
1052                 pix_fmt_mp->plane_fmt[0].bytesperline =
1053                         pix_fmt_mp->plane_fmt[0].sizeimage;
1054         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1055                 fmt = find_format(f, MFC_FMT_RAW);
1056                 if (!fmt) {
1057                         mfc_err("failed to try output format\n");
1058                         return -EINVAL;
1059                 }
1060
1061                 if (fmt->num_planes != pix_fmt_mp->num_planes) {
1062                         mfc_err("failed to try output format\n");
1063                         return -EINVAL;
1064                 }
1065         } else {
1066                 mfc_err("invalid buf type\n");
1067                 return -EINVAL;
1068         }
1069         return 0;
1070 }
1071
1072 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
1073 {
1074         struct s5p_mfc_dev *dev = video_drvdata(file);
1075         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1076         struct s5p_mfc_fmt *fmt;
1077         struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
1078         unsigned long flags;
1079         int ret = 0;
1080
1081         ret = vidioc_try_fmt(file, priv, f);
1082         if (ret)
1083                 return ret;
1084         if (ctx->vq_src.streaming || ctx->vq_dst.streaming) {
1085                 v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__);
1086                 ret = -EBUSY;
1087                 goto out;
1088         }
1089         if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1090                 fmt = find_format(f, MFC_FMT_ENC);
1091                 if (!fmt) {
1092                         mfc_err("failed to set capture format\n");
1093                         return -EINVAL;
1094                 }
1095                 ctx->state = MFCINST_INIT;
1096                 ctx->dst_fmt = fmt;
1097                 ctx->codec_mode = ctx->dst_fmt->codec_mode;
1098                 ctx->enc_dst_buf_size = pix_fmt_mp->plane_fmt[0].sizeimage;
1099                 pix_fmt_mp->plane_fmt[0].bytesperline = 0;
1100                 ctx->dst_bufs_cnt = 0;
1101                 ctx->capture_state = QUEUE_FREE;
1102                 s5p_mfc_alloc_instance_buffer(ctx);
1103                 spin_lock_irqsave(&dev->condlock, flags);
1104                 set_bit(ctx->num, &dev->ctx_work_bits);
1105                 spin_unlock_irqrestore(&dev->condlock, flags);
1106                 s5p_mfc_clean_ctx_int_flags(ctx);
1107                 s5p_mfc_try_run(dev);
1108                 if (s5p_mfc_wait_for_done_ctx(ctx, \
1109                                 S5P_FIMV_R2H_CMD_OPEN_INSTANCE_RET, 1)) {
1110                                 /* Error or timeout */
1111                         mfc_err("Error getting instance from hardware\n");
1112                         s5p_mfc_release_instance_buffer(ctx);
1113                         ret = -EIO;
1114                         goto out;
1115                 }
1116                 mfc_debug(2, "Got instance number: %d\n", ctx->inst_no);
1117         } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1118                 fmt = find_format(f, MFC_FMT_RAW);
1119                 if (!fmt) {
1120                         mfc_err("failed to set output format\n");
1121                         return -EINVAL;
1122                 }
1123
1124                 if (!IS_MFCV6(dev)) {
1125                         if (fmt->fourcc == V4L2_PIX_FMT_NV12MT_16X16) {
1126                                 mfc_err("Not supported format.\n");
1127                                 return -EINVAL;
1128                         }
1129                 } else if (IS_MFCV6(dev)) {
1130                         if (fmt->fourcc == V4L2_PIX_FMT_NV12MT) {
1131                                 mfc_err("Not supported format.\n");
1132                                 return -EINVAL;
1133                         }
1134                 }
1135
1136                 if (fmt->num_planes != pix_fmt_mp->num_planes) {
1137                         mfc_err("failed to set output format\n");
1138                         ret = -EINVAL;
1139                         goto out;
1140                 }
1141                 ctx->src_fmt = fmt;
1142                 ctx->img_width = pix_fmt_mp->width;
1143                 ctx->img_height = pix_fmt_mp->height;
1144                 mfc_debug(2, "codec number: %d\n", ctx->src_fmt->codec_mode);
1145                 mfc_debug(2, "fmt - w: %d, h: %d, ctx - w: %d, h: %d\n",
1146                         pix_fmt_mp->width, pix_fmt_mp->height,
1147                         ctx->img_width, ctx->img_height);
1148
1149                 s5p_mfc_enc_calc_src_size(ctx);
1150                 pix_fmt_mp->plane_fmt[0].sizeimage = ctx->luma_size;
1151                 pix_fmt_mp->plane_fmt[0].bytesperline = ctx->buf_width;
1152                 pix_fmt_mp->plane_fmt[1].sizeimage = ctx->chroma_size;
1153                 pix_fmt_mp->plane_fmt[1].bytesperline = ctx->buf_width;
1154
1155                 ctx->src_bufs_cnt = 0;
1156                 ctx->output_state = QUEUE_FREE;
1157         } else {
1158                 mfc_err("invalid buf type\n");
1159                 return -EINVAL;
1160         }
1161 out:
1162         mfc_debug_leave();
1163         return ret;
1164 }
1165
1166 static int vidioc_reqbufs(struct file *file, void *priv,
1167                                           struct v4l2_requestbuffers *reqbufs)
1168 {
1169         struct s5p_mfc_dev *dev = video_drvdata(file);
1170         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1171         int ret = 0;
1172
1173         /* if memory is not mmp or userptr return error */
1174         if ((reqbufs->memory != V4L2_MEMORY_MMAP) &&
1175                 (reqbufs->memory != V4L2_MEMORY_USERPTR))
1176                 return -EINVAL;
1177         if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1178                 if (ctx->capture_state != QUEUE_FREE) {
1179                         mfc_err("invalid capture state: %d\n",
1180                                                         ctx->capture_state);
1181                         return -EINVAL;
1182                 }
1183                 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1184                 if (ret != 0) {
1185                         mfc_err("error in vb2_reqbufs() for E(D)\n");
1186                         return ret;
1187                 }
1188                 ctx->capture_state = QUEUE_BUFS_REQUESTED;
1189
1190                 if (!IS_MFCV6(dev)) {
1191                         ret = s5p_mfc_alloc_codec_buffers(ctx);
1192                         if (ret) {
1193                                 mfc_err("Failed to allocate encoding buffers\n");
1194                                 reqbufs->count = 0;
1195                                 ret = vb2_reqbufs(&ctx->vq_dst, reqbufs);
1196                                 return -ENOMEM;
1197                         }
1198                 }
1199         } else if (reqbufs->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1200                 if (ctx->output_state != QUEUE_FREE) {
1201                         mfc_err("invalid output state: %d\n",
1202                                                         ctx->output_state);
1203                         return -EINVAL;
1204                 }
1205                 ret = vb2_reqbufs(&ctx->vq_src, reqbufs);
1206                 if (ret != 0) {
1207                         mfc_err("error in vb2_reqbufs() for E(S)\n");
1208                         return ret;
1209                 }
1210                 ctx->output_state = QUEUE_BUFS_REQUESTED;
1211         } else {
1212                 mfc_err("invalid buf type\n");
1213                 return -EINVAL;
1214         }
1215         return ret;
1216 }
1217
1218 static int vidioc_querybuf(struct file *file, void *priv,
1219                                                    struct v4l2_buffer *buf)
1220 {
1221         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1222         int ret = 0;
1223
1224         /* if memory is not mmp or userptr return error */
1225         if ((buf->memory != V4L2_MEMORY_MMAP) &&
1226                 (buf->memory != V4L2_MEMORY_USERPTR))
1227                 return -EINVAL;
1228         if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1229                 if (ctx->state != MFCINST_GOT_INST) {
1230                         mfc_err("invalid context state: %d\n", ctx->state);
1231                         return -EINVAL;
1232                 }
1233                 ret = vb2_querybuf(&ctx->vq_dst, buf);
1234                 if (ret != 0) {
1235                         mfc_err("error in vb2_querybuf() for E(D)\n");
1236                         return ret;
1237                 }
1238                 buf->m.planes[0].m.mem_offset += DST_QUEUE_OFF_BASE;
1239         } else if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1240                 ret = vb2_querybuf(&ctx->vq_src, buf);
1241                 if (ret != 0) {
1242                         mfc_err("error in vb2_querybuf() for E(S)\n");
1243                         return ret;
1244                 }
1245         } else {
1246                 mfc_err("invalid buf type\n");
1247                 return -EINVAL;
1248         }
1249         return ret;
1250 }
1251
1252 /* Queue a buffer */
1253 static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1254 {
1255         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1256
1257         if (ctx->state == MFCINST_ERROR) {
1258                 mfc_err("Call on QBUF after unrecoverable error\n");
1259                 return -EIO;
1260         }
1261         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1262                 return vb2_qbuf(&ctx->vq_src, buf);
1263         else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1264                 return vb2_qbuf(&ctx->vq_dst, buf);
1265         return -EINVAL;
1266 }
1267
1268 /* Dequeue a buffer */
1269 static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1270 {
1271         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1272
1273         if (ctx->state == MFCINST_ERROR) {
1274                 mfc_err("Call on DQBUF after unrecoverable error\n");
1275                 return -EIO;
1276         }
1277         if (buf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1278                 return vb2_dqbuf(&ctx->vq_src, buf, file->f_flags & O_NONBLOCK);
1279         else if (buf->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1280                 return vb2_dqbuf(&ctx->vq_dst, buf, file->f_flags & O_NONBLOCK);
1281         return -EINVAL;
1282 }
1283
1284 /* Export DMA buffer */
1285 static int vidioc_expbuf(struct file *file, void *priv,
1286         struct v4l2_exportbuffer *eb)
1287 {
1288         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1289
1290         if (eb->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1291                 return vb2_expbuf(&ctx->vq_src, eb);
1292         else if (eb->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1293                 return vb2_expbuf(&ctx->vq_dst, eb);
1294         return -EINVAL;
1295 }
1296
1297 /* Stream on */
1298 static int vidioc_streamon(struct file *file, void *priv,
1299                            enum v4l2_buf_type type)
1300 {
1301         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1302
1303         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1304                 return vb2_streamon(&ctx->vq_src, type);
1305         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1306                 return vb2_streamon(&ctx->vq_dst, type);
1307         return -EINVAL;
1308 }
1309
1310 /* Stream off, which equals to a pause */
1311 static int vidioc_streamoff(struct file *file, void *priv,
1312                             enum v4l2_buf_type type)
1313 {
1314         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1315
1316         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1317                 return vb2_streamoff(&ctx->vq_src, type);
1318         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1319                 return vb2_streamoff(&ctx->vq_dst, type);
1320         return -EINVAL;
1321 }
1322
1323 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl)
1324 {
1325         static unsigned int t[V4L2_MPEG_VIDEO_H264_LEVEL_4_0 + 1] = {
1326                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0   */ 10,
1327                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B    */ 9,
1328                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1   */ 11,
1329                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2   */ 12,
1330                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3   */ 13,
1331                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0   */ 20,
1332                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1   */ 21,
1333                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2   */ 22,
1334                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0   */ 30,
1335                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1   */ 31,
1336                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2   */ 32,
1337                 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0   */ 40,
1338         };
1339         return t[lvl];
1340 }
1341
1342 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl)
1343 {
1344         static unsigned int t[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 + 1] = {
1345                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0    */ 0,
1346                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B   */ 9,
1347                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1    */ 1,
1348                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2    */ 2,
1349                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3    */ 3,
1350                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B   */ 7,
1351                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4    */ 4,
1352                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5    */ 5,
1353         };
1354         return t[lvl];
1355 }
1356
1357 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar)
1358 {
1359         static unsigned int t[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED + 1] = {
1360                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED     */ 0,
1361                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1             */ 1,
1362                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11           */ 2,
1363                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11           */ 3,
1364                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11           */ 4,
1365                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33           */ 5,
1366                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11           */ 6,
1367                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11           */ 7,
1368                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11           */ 8,
1369                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33           */ 9,
1370                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11           */ 10,
1371                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11           */ 11,
1372                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33           */ 12,
1373                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99          */ 13,
1374                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3             */ 14,
1375                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2             */ 15,
1376                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1             */ 16,
1377                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED        */ 255,
1378         };
1379         return t[sar];
1380 }
1381
1382 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
1383 {
1384         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1385         struct s5p_mfc_dev *dev = ctx->dev;
1386         struct s5p_mfc_enc_params *p = &ctx->enc_params;
1387         int ret = 0;
1388
1389         switch (ctrl->id) {
1390         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1391                 p->gop_size = ctrl->val;
1392                 break;
1393         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1394                 p->slice_mode = ctrl->val;
1395                 break;
1396         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1397                 p->slice_mb = ctrl->val;
1398                 break;
1399         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BITS:
1400                 p->slice_bit = ctrl->val * 8;
1401                 break;
1402         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1403                 p->intra_refresh_mb = ctrl->val;
1404                 break;
1405         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING:
1406                 p->pad = ctrl->val;
1407                 break;
1408         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV:
1409                 p->pad_luma = (ctrl->val >> 16) & 0xff;
1410                 p->pad_cb = (ctrl->val >> 8) & 0xff;
1411                 p->pad_cr = (ctrl->val >> 0) & 0xff;
1412                 break;
1413         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1414                 p->rc_frame = ctrl->val;
1415                 break;
1416         case V4L2_CID_MPEG_VIDEO_BITRATE:
1417                 p->rc_bitrate = ctrl->val;
1418                 break;
1419         case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF:
1420                 p->rc_reaction_coeff = ctrl->val;
1421                 break;
1422         case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1423                 ctx->force_frame_type = ctrl->val;
1424                 break;
1425         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:
1426                 p->vbv_size = ctrl->val;
1427                 break;
1428         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
1429                 p->codec.h264.cpb_size = ctrl->val;
1430                 break;
1431         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1432                 p->seq_hdr_mode = ctrl->val;
1433                 break;
1434         case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1435                 p->frame_skip_mode = ctrl->val;
1436                 break;
1437         case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT:
1438                 p->fixed_target_bit = ctrl->val;
1439                 break;
1440         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1441                 p->num_b_frame = ctrl->val;
1442                 break;
1443         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1444                 switch (ctrl->val) {
1445                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1446                         p->codec.h264.profile =
1447                                         S5P_FIMV_ENC_PROFILE_H264_MAIN;
1448                         break;
1449                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1450                         p->codec.h264.profile =
1451                                         S5P_FIMV_ENC_PROFILE_H264_HIGH;
1452                         break;
1453                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1454                         p->codec.h264.profile =
1455                                 S5P_FIMV_ENC_PROFILE_H264_BASELINE;
1456                         break;
1457                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1458                         if (IS_MFCV6(dev))
1459                                 p->codec.h264.profile =
1460                                         S5P_FIMV_ENC_PROFILE_H264_CONSTRAINED_BASELINE;
1461                         else
1462                                 ret = -EINVAL;
1463                         break;
1464                 default:
1465                         ret = -EINVAL;
1466                 }
1467                 break;
1468         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1469                 p->codec.h264.level_v4l2 = ctrl->val;
1470                 p->codec.h264.level = h264_level(ctrl->val);
1471                 if (p->codec.h264.level < 0) {
1472                         mfc_err("Level number is wrong\n");
1473                         ret = p->codec.h264.level;
1474                 }
1475                 break;
1476         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1477                 p->codec.mpeg4.level_v4l2 = ctrl->val;
1478                 p->codec.mpeg4.level = mpeg4_level(ctrl->val);
1479                 if (p->codec.mpeg4.level < 0) {
1480                         mfc_err("Level number is wrong\n");
1481                         ret = p->codec.mpeg4.level;
1482                 }
1483                 break;
1484         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1485                 p->codec.h264.loop_filter_mode = ctrl->val;
1486                 break;
1487         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1488                 p->codec.h264.loop_filter_alpha = ctrl->val;
1489                 break;
1490         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1491                 p->codec.h264.loop_filter_beta = ctrl->val;
1492                 break;
1493         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1494                 p->codec.h264.entropy_mode = ctrl->val;
1495                 break;
1496         case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P:
1497                 p->codec.h264.num_ref_pic_4p = ctrl->val;
1498                 break;
1499         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1500                 p->codec.h264._8x8_transform = ctrl->val;
1501                 break;
1502         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1503                 p->codec.h264.rc_mb = ctrl->val;
1504                 break;
1505         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1506                 p->codec.h264.rc_frame_qp = ctrl->val;
1507                 break;
1508         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1509                 p->codec.h264.rc_min_qp = ctrl->val;
1510                 break;
1511         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1512                 p->codec.h264.rc_max_qp = ctrl->val;
1513                 break;
1514         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1515                 p->codec.h264.rc_p_frame_qp = ctrl->val;
1516                 break;
1517         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
1518                 p->codec.h264.rc_b_frame_qp = ctrl->val;
1519                 break;
1520         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1521         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:
1522                 p->codec.mpeg4.rc_frame_qp = ctrl->val;
1523                 break;
1524         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:
1525         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:
1526                 p->codec.mpeg4.rc_min_qp = ctrl->val;
1527                 break;
1528         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:
1529         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:
1530                 p->codec.mpeg4.rc_max_qp = ctrl->val;
1531                 break;
1532         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1533         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:
1534                 p->codec.mpeg4.rc_p_frame_qp = ctrl->val;
1535                 break;
1536         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:
1537         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:
1538                 p->codec.mpeg4.rc_b_frame_qp = ctrl->val;
1539                 break;
1540         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK:
1541                 p->codec.h264.rc_mb_dark = ctrl->val;
1542                 break;
1543         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH:
1544                 p->codec.h264.rc_mb_smooth = ctrl->val;
1545                 break;
1546         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC:
1547                 p->codec.h264.rc_mb_static = ctrl->val;
1548                 break;
1549         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY:
1550                 p->codec.h264.rc_mb_activity = ctrl->val;
1551                 break;
1552         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1553                 p->codec.h264.vui_sar = ctrl->val;
1554                 break;
1555         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1556                 p->codec.h264.vui_sar_idc = vui_sar_idc(ctrl->val);
1557                 break;
1558         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
1559                 p->codec.h264.vui_ext_sar_width = ctrl->val;
1560                 break;
1561         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
1562                 p->codec.h264.vui_ext_sar_height = ctrl->val;
1563                 break;
1564         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1565                 p->codec.h264.open_gop = !ctrl->val;
1566                 break;
1567         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
1568                 p->codec.h264.open_gop_size = ctrl->val;
1569                 break;
1570         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1571                 switch (ctrl->val) {
1572                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
1573                         p->codec.mpeg4.profile =
1574                                 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE;
1575                         break;
1576                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
1577                         p->codec.mpeg4.profile =
1578                         S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE;
1579                         break;
1580                 default:
1581                         ret = -EINVAL;
1582                 }
1583                 break;
1584         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1585                 p->codec.mpeg4.quarter_pixel = ctrl->val;
1586                 break;
1587         case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:
1588                 p->codec.h264.sei_frame_packing = ctrl->val;
1589                 break;
1590         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:
1591                 p->codec.h264.sei_fp_curr_frame_0 = ctrl->val;
1592                 break;
1593         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1594                 p->codec.h264.sei_fp_arrangement_type = ctrl->val;
1595                 break;
1596         case V4L2_CID_MPEG_VIDEO_H264_FMO:
1597                 p->codec.h264.fmo = ctrl->val;
1598                 break;
1599         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1600                 p->codec.h264.fmo_map_type = ctrl->val;
1601                 break;
1602         case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:
1603                 p->codec.h264.fmo_slice_grp = ctrl->val;
1604                 break;
1605         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:
1606                 p->codec.h264.fmo_chg_dir = ctrl->val;
1607                 break;
1608         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:
1609                 p->codec.h264.fmo_chg_rate = ctrl->val;
1610                 break;
1611         case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:
1612                 p->codec.h264.fmo_run_len[ctrl->val >> 30]
1613                         = ctrl->val & 0x3FFFFFFF;
1614                 break;
1615         case V4L2_CID_MPEG_VIDEO_H264_ASO:
1616                 p->codec.h264.aso = ctrl->val;
1617                 break;
1618         case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:
1619                 p->codec.h264.aso_slice_order[(ctrl->val >> 18) & 0x7]
1620                         |= (ctrl->val & 0xFF) << (((ctrl->val >> 16) & 0x3) << 3);
1621                 break;
1622         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:
1623                 p->codec.h264.hier_qp = ctrl->val;
1624                 break;
1625         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
1626                 p->codec.h264.hier_qp_type = ctrl->val;
1627                 break;
1628         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:
1629                 p->codec.h264.hier_qp_layer = ctrl->val;
1630                 break;
1631         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
1632                 p->codec.h264.hier_qp_layer_qp[(ctrl->val >> 16) & 0x7]
1633                         = ctrl->val & 0xFF;
1634                 break;
1635         default:
1636                 v4l2_err(&dev->v4l2_dev, "Invalid control, id=%d, val=%d\n",
1637                                                         ctrl->id, ctrl->val);
1638                 ret = -EINVAL;
1639         }
1640         return ret;
1641 }
1642
1643 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
1644         .s_ctrl = s5p_mfc_enc_s_ctrl,
1645 };
1646
1647 int vidioc_s_parm(struct file *file, void *priv, struct v4l2_streamparm *a)
1648 {
1649         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1650
1651         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1652                 ctx->enc_params.rc_framerate_num =
1653                                         a->parm.output.timeperframe.denominator;
1654                 ctx->enc_params.rc_framerate_denom =
1655                                         a->parm.output.timeperframe.numerator;
1656         } else {
1657                 mfc_err("Setting FPS is only possible for the output queue\n");
1658                 return -EINVAL;
1659         }
1660         return 0;
1661 }
1662
1663 int vidioc_g_parm(struct file *file, void *priv, struct v4l2_streamparm *a)
1664 {
1665         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1666
1667         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1668                 a->parm.output.timeperframe.denominator =
1669                                         ctx->enc_params.rc_framerate_num;
1670                 a->parm.output.timeperframe.numerator =
1671                                         ctx->enc_params.rc_framerate_denom;
1672         } else {
1673                 mfc_err("Setting FPS is only possible for the output queue\n");
1674                 return -EINVAL;
1675         }
1676         return 0;
1677 }
1678
1679 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops = {
1680         .vidioc_querycap = vidioc_querycap,
1681         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1682         .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_cap_mplane,
1683         .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
1684         .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_out_mplane,
1685         .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt,
1686         .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt,
1687         .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt,
1688         .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt,
1689         .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt,
1690         .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt,
1691         .vidioc_reqbufs = vidioc_reqbufs,
1692         .vidioc_querybuf = vidioc_querybuf,
1693         .vidioc_qbuf = vidioc_qbuf,
1694         .vidioc_dqbuf = vidioc_dqbuf,
1695         .vidioc_expbuf = vidioc_expbuf,
1696         .vidioc_streamon = vidioc_streamon,
1697         .vidioc_streamoff = vidioc_streamoff,
1698         .vidioc_s_parm = vidioc_s_parm,
1699         .vidioc_g_parm = vidioc_g_parm,
1700 };
1701
1702 static int check_vb_with_fmt(struct s5p_mfc_fmt *fmt, struct vb2_buffer *vb)
1703 {
1704         int i;
1705
1706         if (!fmt)
1707                 return -EINVAL;
1708         if (fmt->num_planes != vb->num_planes) {
1709                 mfc_err("invalid plane number for the format\n");
1710                 return -EINVAL;
1711         }
1712         for (i = 0; i < fmt->num_planes; i++) {
1713                 if (!vb2_dma_contig_plane_dma_addr(vb, i)) {
1714                         mfc_err("failed to get plane cookie\n");
1715                         return -EINVAL;
1716                 }
1717                 mfc_debug(2, "index: %d, plane[%d] cookie: 0x%08zx",
1718                                 vb->v4l2_buf.index, i,
1719                                 vb2_dma_contig_plane_dma_addr(vb, i));
1720         }
1721         return 0;
1722 }
1723
1724 static int s5p_mfc_queue_setup(struct vb2_queue *vq,
1725                         const struct v4l2_format *fmt,
1726                         unsigned int *buf_count, unsigned int *plane_count,
1727                         unsigned int psize[], void *allocators[])
1728 {
1729         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1730         struct s5p_mfc_dev *dev = ctx->dev;
1731
1732         if (ctx->state != MFCINST_GOT_INST) {
1733                 mfc_err("inavlid state: %d\n", ctx->state);
1734                 return -EINVAL;
1735         }
1736         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1737                 if (ctx->dst_fmt)
1738                         *plane_count = ctx->dst_fmt->num_planes;
1739                 else
1740                         *plane_count = MFC_ENC_CAP_PLANE_COUNT;
1741                 if (*buf_count < 1)
1742                         *buf_count = 1;
1743                 if (*buf_count > MFC_MAX_BUFFERS)
1744                         *buf_count = MFC_MAX_BUFFERS;
1745                 psize[0] = ctx->enc_dst_buf_size;
1746                 allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1747         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1748                 if (ctx->src_fmt)
1749                         *plane_count = ctx->src_fmt->num_planes;
1750                 else
1751                         *plane_count = MFC_ENC_OUT_PLANE_COUNT;
1752
1753                 if (*buf_count < 1)
1754                         *buf_count = 1;
1755                 if (*buf_count > MFC_MAX_BUFFERS)
1756                         *buf_count = MFC_MAX_BUFFERS;
1757                 psize[0] = ctx->luma_size;
1758                 psize[1] = ctx->chroma_size;
1759                 if (IS_MFCV6(dev)) {
1760                         allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1761                         allocators[1] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1762                 } else {
1763                         allocators[0] = ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1764                         allocators[1] = ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1765                 }
1766         } else {
1767                 mfc_err("inavlid queue type: %d\n", vq->type);
1768                 return -EINVAL;
1769         }
1770         return 0;
1771 }
1772
1773 static void s5p_mfc_unlock(struct vb2_queue *q)
1774 {
1775         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1776         struct s5p_mfc_dev *dev = ctx->dev;
1777
1778         mutex_unlock(&dev->mfc_mutex);
1779 }
1780
1781 static void s5p_mfc_lock(struct vb2_queue *q)
1782 {
1783         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1784         struct s5p_mfc_dev *dev = ctx->dev;
1785
1786         mutex_lock(&dev->mfc_mutex);
1787 }
1788
1789 static int s5p_mfc_buf_init(struct vb2_buffer *vb)
1790 {
1791         struct vb2_queue *vq = vb->vb2_queue;
1792         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1793         unsigned int i;
1794         int ret;
1795
1796         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1797                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1798                 if (ret < 0)
1799                         return ret;
1800                 i = vb->v4l2_buf.index;
1801                 ctx->dst_bufs[i].b = vb;
1802                 ctx->dst_bufs[i].cookie.stream =
1803                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1804                 ctx->dst_bufs_cnt++;
1805         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1806                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1807                 if (ret < 0)
1808                         return ret;
1809                 i = vb->v4l2_buf.index;
1810                 ctx->src_bufs[i].b = vb;
1811                 ctx->src_bufs[i].cookie.raw.luma =
1812                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1813                 ctx->src_bufs[i].cookie.raw.chroma =
1814                                         vb2_dma_contig_plane_dma_addr(vb, 1);
1815                 ctx->src_bufs_cnt++;
1816         } else {
1817                 mfc_err("inavlid queue type: %d\n", vq->type);
1818                 return -EINVAL;
1819         }
1820         return 0;
1821 }
1822
1823 static int s5p_mfc_buf_prepare(struct vb2_buffer *vb)
1824 {
1825         struct vb2_queue *vq = vb->vb2_queue;
1826         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1827         int ret;
1828
1829         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1830                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1831                 if (ret < 0)
1832                         return ret;
1833                 mfc_debug(2, "plane size: %ld, dst size: %d\n",
1834                         vb2_plane_size(vb, 0), ctx->enc_dst_buf_size);
1835                 if (vb2_plane_size(vb, 0) < ctx->enc_dst_buf_size) {
1836                         mfc_err("plane size is too small for capture\n");
1837                         return -EINVAL;
1838                 }
1839         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1840                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1841                 if (ret < 0)
1842                         return ret;
1843                 mfc_debug(2, "plane size: %ld, luma size: %d\n",
1844                         vb2_plane_size(vb, 0), ctx->luma_size);
1845                 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
1846                         vb2_plane_size(vb, 1), ctx->chroma_size);
1847                 if (vb2_plane_size(vb, 0) < ctx->luma_size ||
1848                     vb2_plane_size(vb, 1) < ctx->chroma_size) {
1849                         mfc_err("plane size is too small for output\n");
1850                         return -EINVAL;
1851                 }
1852         } else {
1853                 mfc_err("inavlid queue type: %d\n", vq->type);
1854                 return -EINVAL;
1855         }
1856         return 0;
1857 }
1858
1859 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count)
1860 {
1861         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1862         struct s5p_mfc_dev *dev = ctx->dev;
1863         unsigned long flags;
1864
1865         v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1866         /* If context is ready then dev = work->data;schedule it to run */
1867         if (s5p_mfc_ctx_ready(ctx)) {
1868                 spin_lock_irqsave(&dev->condlock, flags);
1869                 set_bit(ctx->num, &dev->ctx_work_bits);
1870                 spin_unlock_irqrestore(&dev->condlock, flags);
1871         }
1872         s5p_mfc_try_run(dev);
1873         return 0;
1874 }
1875
1876 static int s5p_mfc_stop_streaming(struct vb2_queue *q)
1877 {
1878         unsigned long flags;
1879         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1880         struct s5p_mfc_dev *dev = ctx->dev;
1881
1882         if ((ctx->state == MFCINST_FINISHING ||
1883                 ctx->state == MFCINST_RUNNING) &&
1884                 dev->curr_ctx == ctx->num && dev->hw_lock) {
1885                 ctx->state = MFCINST_ABORT;
1886                 s5p_mfc_wait_for_done_ctx(ctx, S5P_FIMV_R2H_CMD_FRAME_DONE_RET,
1887                                           0);
1888         }
1889         ctx->state = MFCINST_FINISHED;
1890         spin_lock_irqsave(&dev->irqlock, flags);
1891         if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1892                 s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst);
1893                 INIT_LIST_HEAD(&ctx->dst_queue);
1894                 ctx->dst_queue_cnt = 0;
1895         }
1896         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1897                 cleanup_ref_queue(ctx);
1898                 s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src);
1899                 INIT_LIST_HEAD(&ctx->src_queue);
1900                 ctx->src_queue_cnt = 0;
1901         }
1902         spin_unlock_irqrestore(&dev->irqlock, flags);
1903         return 0;
1904 }
1905
1906 static void s5p_mfc_buf_queue(struct vb2_buffer *vb)
1907 {
1908         struct vb2_queue *vq = vb->vb2_queue;
1909         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1910         struct s5p_mfc_dev *dev = ctx->dev;
1911         unsigned long flags;
1912         struct s5p_mfc_buf *mfc_buf;
1913
1914         if (ctx->state == MFCINST_ERROR) {
1915                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
1916                 cleanup_ref_queue(ctx);
1917                 return;
1918         }
1919         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1920                 mfc_buf = &ctx->dst_bufs[vb->v4l2_buf.index];
1921                 mfc_buf->used = 0;
1922                 /* Mark destination as available for use by MFC */
1923                 spin_lock_irqsave(&dev->irqlock, flags);
1924                 list_add_tail(&mfc_buf->list, &ctx->dst_queue);
1925                 ctx->dst_queue_cnt++;
1926                 spin_unlock_irqrestore(&dev->irqlock, flags);
1927         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1928                 mfc_buf = &ctx->src_bufs[vb->v4l2_buf.index];
1929                 mfc_buf->used = 0;
1930                 spin_lock_irqsave(&dev->irqlock, flags);
1931                 if (vb->v4l2_planes[0].bytesused == 0) {
1932                         mfc_debug(1, "change state to FINISHING\n");
1933                         ctx->state = MFCINST_FINISHING;
1934                         vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
1935                         cleanup_ref_queue(ctx);
1936                 } else {
1937                         list_add_tail(&mfc_buf->list, &ctx->src_queue);
1938                         ctx->src_queue_cnt++;
1939                 }
1940                 spin_unlock_irqrestore(&dev->irqlock, flags);
1941         } else {
1942                 mfc_err("unsupported buffer type (%d)\n", vq->type);
1943         }
1944         if (s5p_mfc_ctx_ready(ctx)) {
1945                 spin_lock_irqsave(&dev->condlock, flags);
1946                 set_bit(ctx->num, &dev->ctx_work_bits);
1947                 spin_unlock_irqrestore(&dev->condlock, flags);
1948         }
1949         s5p_mfc_try_run(dev);
1950 }
1951
1952 static struct vb2_ops s5p_mfc_enc_qops = {
1953         .queue_setup            = s5p_mfc_queue_setup,
1954         .wait_prepare           = s5p_mfc_unlock,
1955         .wait_finish            = s5p_mfc_lock,
1956         .buf_init               = s5p_mfc_buf_init,
1957         .buf_prepare            = s5p_mfc_buf_prepare,
1958         .start_streaming        = s5p_mfc_start_streaming,
1959         .stop_streaming         = s5p_mfc_stop_streaming,
1960         .buf_queue              = s5p_mfc_buf_queue,
1961 };
1962
1963 struct s5p_mfc_codec_ops *get_enc_codec_ops(void)
1964 {
1965         return &encoder_codec_ops;
1966 }
1967
1968 struct vb2_ops *get_enc_queue_ops(void)
1969 {
1970         return &s5p_mfc_enc_qops;
1971 }
1972
1973 const struct v4l2_ioctl_ops *get_enc_v4l2_ioctl_ops(void)
1974 {
1975         return &s5p_mfc_enc_ioctl_ops;
1976 }
1977
1978 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
1979                                                 && V4L2_CTRL_DRIVER_PRIV(x))
1980
1981 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
1982 {
1983         struct v4l2_ctrl_config cfg;
1984         int i;
1985
1986         v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS);
1987         if (ctx->ctrl_handler.error) {
1988                 mfc_err("v4l2_ctrl_handler_init failed\n");
1989                 return ctx->ctrl_handler.error;
1990         }
1991         for (i = 0; i < NUM_CTRLS; i++) {
1992                 if (IS_MFC51_PRIV(controls[i].id)) {
1993                         memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
1994                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
1995                         cfg.id = controls[i].id;
1996                         cfg.min = controls[i].minimum;
1997                         cfg.max = controls[i].maximum;
1998                         cfg.def = controls[i].default_value;
1999                         cfg.name = controls[i].name;
2000                         cfg.type = controls[i].type;
2001                         cfg.flags = 0;
2002
2003                         if (cfg.type == V4L2_CTRL_TYPE_MENU) {
2004                                 cfg.step = 0;
2005                                 cfg.menu_skip_mask = cfg.menu_skip_mask;
2006                                 cfg.qmenu = mfc51_get_menu(cfg.id);
2007                         } else {
2008                                 cfg.step = controls[i].step;
2009                                 cfg.menu_skip_mask = 0;
2010                         }
2011                         ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler,
2012                                         &cfg, NULL);
2013                 } else {
2014                         if (controls[i].type == V4L2_CTRL_TYPE_MENU) {
2015                                 ctx->ctrls[i] = v4l2_ctrl_new_std_menu(
2016                                         &ctx->ctrl_handler,
2017                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2018                                         controls[i].maximum, 0,
2019                                         controls[i].default_value);
2020                         } else {
2021                                 ctx->ctrls[i] = v4l2_ctrl_new_std(
2022                                         &ctx->ctrl_handler,
2023                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2024                                         controls[i].minimum,
2025                                         controls[i].maximum, controls[i].step,
2026                                         controls[i].default_value);
2027                         }
2028                 }
2029                 if (ctx->ctrl_handler.error) {
2030                         mfc_err("Adding control (%d) failed\n", i);
2031                         return ctx->ctrl_handler.error;
2032                 }
2033                 if (controls[i].is_volatile && ctx->ctrls[i])
2034                         ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
2035         }
2036         return 0;
2037 }
2038
2039 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx *ctx)
2040 {
2041         int i;
2042
2043         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2044         for (i = 0; i < NUM_CTRLS; i++)
2045                 ctx->ctrls[i] = NULL;
2046 }
2047
2048 void s5p_mfc_enc_init(struct s5p_mfc_ctx *ctx)
2049 {
2050         ctx->src_fmt = &formats[DEF_SRC_FMT];
2051         ctx->dst_fmt = &formats[DEF_DST_FMT];
2052 }
2053