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         int ret;
1290
1291         if (eb->mem_offset < DST_QUEUE_OFF_BASE)
1292                 return vb2_expbuf(&ctx->vq_src, eb);
1293
1294         eb->mem_offset -= DST_QUEUE_OFF_BASE;
1295         ret = vb2_expbuf(&ctx->vq_dst, eb);
1296         eb->mem_offset += DST_QUEUE_OFF_BASE;
1297
1298         return ret;
1299 }
1300
1301 /* Stream on */
1302 static int vidioc_streamon(struct file *file, void *priv,
1303                            enum v4l2_buf_type type)
1304 {
1305         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1306
1307         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1308                 return vb2_streamon(&ctx->vq_src, type);
1309         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1310                 return vb2_streamon(&ctx->vq_dst, type);
1311         return -EINVAL;
1312 }
1313
1314 /* Stream off, which equals to a pause */
1315 static int vidioc_streamoff(struct file *file, void *priv,
1316                             enum v4l2_buf_type type)
1317 {
1318         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1319
1320         if (type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1321                 return vb2_streamoff(&ctx->vq_src, type);
1322         else if (type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1323                 return vb2_streamoff(&ctx->vq_dst, type);
1324         return -EINVAL;
1325 }
1326
1327 static inline int h264_level(enum v4l2_mpeg_video_h264_level lvl)
1328 {
1329         static unsigned int t[V4L2_MPEG_VIDEO_H264_LEVEL_4_0 + 1] = {
1330                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_0   */ 10,
1331                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1B    */ 9,
1332                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_1   */ 11,
1333                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_2   */ 12,
1334                 /* V4L2_MPEG_VIDEO_H264_LEVEL_1_3   */ 13,
1335                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_0   */ 20,
1336                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_1   */ 21,
1337                 /* V4L2_MPEG_VIDEO_H264_LEVEL_2_2   */ 22,
1338                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_0   */ 30,
1339                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_1   */ 31,
1340                 /* V4L2_MPEG_VIDEO_H264_LEVEL_3_2   */ 32,
1341                 /* V4L2_MPEG_VIDEO_H264_LEVEL_4_0   */ 40,
1342         };
1343         return t[lvl];
1344 }
1345
1346 static inline int mpeg4_level(enum v4l2_mpeg_video_mpeg4_level lvl)
1347 {
1348         static unsigned int t[V4L2_MPEG_VIDEO_MPEG4_LEVEL_5 + 1] = {
1349                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0    */ 0,
1350                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B   */ 9,
1351                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_1    */ 1,
1352                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_2    */ 2,
1353                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3    */ 3,
1354                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_3B   */ 7,
1355                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_4    */ 4,
1356                 /* V4L2_MPEG_VIDEO_MPEG4_LEVEL_5    */ 5,
1357         };
1358         return t[lvl];
1359 }
1360
1361 static inline int vui_sar_idc(enum v4l2_mpeg_video_h264_vui_sar_idc sar)
1362 {
1363         static unsigned int t[V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED + 1] = {
1364                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_UNSPECIFIED     */ 0,
1365                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_1x1             */ 1,
1366                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_12x11           */ 2,
1367                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_10x11           */ 3,
1368                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_16x11           */ 4,
1369                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_40x33           */ 5,
1370                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_24x11           */ 6,
1371                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_20x11           */ 7,
1372                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_32x11           */ 8,
1373                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_80x33           */ 9,
1374                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_18x11           */ 10,
1375                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_15x11           */ 11,
1376                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_64x33           */ 12,
1377                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_160x99          */ 13,
1378                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_4x3             */ 14,
1379                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_3x2             */ 15,
1380                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_2x1             */ 16,
1381                 /* V4L2_MPEG_VIDEO_H264_VUI_SAR_IDC_EXTENDED        */ 255,
1382         };
1383         return t[sar];
1384 }
1385
1386 static int s5p_mfc_enc_s_ctrl(struct v4l2_ctrl *ctrl)
1387 {
1388         struct s5p_mfc_ctx *ctx = ctrl_to_ctx(ctrl);
1389         struct s5p_mfc_dev *dev = ctx->dev;
1390         struct s5p_mfc_enc_params *p = &ctx->enc_params;
1391         int ret = 0;
1392
1393         switch (ctrl->id) {
1394         case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1395                 p->gop_size = ctrl->val;
1396                 break;
1397         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
1398                 p->slice_mode = ctrl->val;
1399                 break;
1400         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
1401                 p->slice_mb = ctrl->val;
1402                 break;
1403         case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BITS:
1404                 p->slice_bit = ctrl->val * 8;
1405                 break;
1406         case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB:
1407                 p->intra_refresh_mb = ctrl->val;
1408                 break;
1409         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING:
1410                 p->pad = ctrl->val;
1411                 break;
1412         case V4L2_CID_MPEG_MFC51_VIDEO_PADDING_YUV:
1413                 p->pad_luma = (ctrl->val >> 16) & 0xff;
1414                 p->pad_cb = (ctrl->val >> 8) & 0xff;
1415                 p->pad_cr = (ctrl->val >> 0) & 0xff;
1416                 break;
1417         case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
1418                 p->rc_frame = ctrl->val;
1419                 break;
1420         case V4L2_CID_MPEG_VIDEO_BITRATE:
1421                 p->rc_bitrate = ctrl->val;
1422                 break;
1423         case V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF:
1424                 p->rc_reaction_coeff = ctrl->val;
1425                 break;
1426         case V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE:
1427                 ctx->force_frame_type = ctrl->val;
1428                 break;
1429         case V4L2_CID_MPEG_VIDEO_VBV_SIZE:
1430                 p->vbv_size = ctrl->val;
1431                 break;
1432         case V4L2_CID_MPEG_VIDEO_H264_CPB_SIZE:
1433                 p->codec.h264.cpb_size = ctrl->val;
1434                 break;
1435         case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
1436                 p->seq_hdr_mode = ctrl->val;
1437                 break;
1438         case V4L2_CID_MPEG_MFC51_VIDEO_FRAME_SKIP_MODE:
1439                 p->frame_skip_mode = ctrl->val;
1440                 break;
1441         case V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT:
1442                 p->fixed_target_bit = ctrl->val;
1443                 break;
1444         case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1445                 p->num_b_frame = ctrl->val;
1446                 break;
1447         case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
1448                 switch (ctrl->val) {
1449                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1450                         p->codec.h264.profile =
1451                                         S5P_FIMV_ENC_PROFILE_H264_MAIN;
1452                         break;
1453                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1454                         p->codec.h264.profile =
1455                                         S5P_FIMV_ENC_PROFILE_H264_HIGH;
1456                         break;
1457                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1458                         p->codec.h264.profile =
1459                                 S5P_FIMV_ENC_PROFILE_H264_BASELINE;
1460                         break;
1461                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1462                         if (IS_MFCV6(dev))
1463                                 p->codec.h264.profile =
1464                                         S5P_FIMV_ENC_PROFILE_H264_CONSTRAINED_BASELINE;
1465                         else
1466                                 ret = -EINVAL;
1467                         break;
1468                 default:
1469                         ret = -EINVAL;
1470                 }
1471                 break;
1472         case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
1473                 p->codec.h264.level_v4l2 = ctrl->val;
1474                 p->codec.h264.level = h264_level(ctrl->val);
1475                 if (p->codec.h264.level < 0) {
1476                         mfc_err("Level number is wrong\n");
1477                         ret = p->codec.h264.level;
1478                 }
1479                 break;
1480         case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1481                 p->codec.mpeg4.level_v4l2 = ctrl->val;
1482                 p->codec.mpeg4.level = mpeg4_level(ctrl->val);
1483                 if (p->codec.mpeg4.level < 0) {
1484                         mfc_err("Level number is wrong\n");
1485                         ret = p->codec.mpeg4.level;
1486                 }
1487                 break;
1488         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
1489                 p->codec.h264.loop_filter_mode = ctrl->val;
1490                 break;
1491         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
1492                 p->codec.h264.loop_filter_alpha = ctrl->val;
1493                 break;
1494         case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
1495                 p->codec.h264.loop_filter_beta = ctrl->val;
1496                 break;
1497         case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
1498                 p->codec.h264.entropy_mode = ctrl->val;
1499                 break;
1500         case V4L2_CID_MPEG_MFC51_VIDEO_H264_NUM_REF_PIC_FOR_P:
1501                 p->codec.h264.num_ref_pic_4p = ctrl->val;
1502                 break;
1503         case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
1504                 p->codec.h264._8x8_transform = ctrl->val;
1505                 break;
1506         case V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE:
1507                 p->codec.h264.rc_mb = ctrl->val;
1508                 break;
1509         case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
1510                 p->codec.h264.rc_frame_qp = ctrl->val;
1511                 break;
1512         case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
1513                 p->codec.h264.rc_min_qp = ctrl->val;
1514                 break;
1515         case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
1516                 p->codec.h264.rc_max_qp = ctrl->val;
1517                 break;
1518         case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
1519                 p->codec.h264.rc_p_frame_qp = ctrl->val;
1520                 break;
1521         case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
1522                 p->codec.h264.rc_b_frame_qp = ctrl->val;
1523                 break;
1524         case V4L2_CID_MPEG_VIDEO_MPEG4_I_FRAME_QP:
1525         case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP:
1526                 p->codec.mpeg4.rc_frame_qp = ctrl->val;
1527                 break;
1528         case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP:
1529         case V4L2_CID_MPEG_VIDEO_H263_MIN_QP:
1530                 p->codec.mpeg4.rc_min_qp = ctrl->val;
1531                 break;
1532         case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP:
1533         case V4L2_CID_MPEG_VIDEO_H263_MAX_QP:
1534                 p->codec.mpeg4.rc_max_qp = ctrl->val;
1535                 break;
1536         case V4L2_CID_MPEG_VIDEO_MPEG4_P_FRAME_QP:
1537         case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP:
1538                 p->codec.mpeg4.rc_p_frame_qp = ctrl->val;
1539                 break;
1540         case V4L2_CID_MPEG_VIDEO_MPEG4_B_FRAME_QP:
1541         case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP:
1542                 p->codec.mpeg4.rc_b_frame_qp = ctrl->val;
1543                 break;
1544         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_DARK:
1545                 p->codec.h264.rc_mb_dark = ctrl->val;
1546                 break;
1547         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_SMOOTH:
1548                 p->codec.h264.rc_mb_smooth = ctrl->val;
1549                 break;
1550         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_STATIC:
1551                 p->codec.h264.rc_mb_static = ctrl->val;
1552                 break;
1553         case V4L2_CID_MPEG_MFC51_VIDEO_H264_ADAPTIVE_RC_ACTIVITY:
1554                 p->codec.h264.rc_mb_activity = ctrl->val;
1555                 break;
1556         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_ENABLE:
1557                 p->codec.h264.vui_sar = ctrl->val;
1558                 break;
1559         case V4L2_CID_MPEG_VIDEO_H264_VUI_SAR_IDC:
1560                 p->codec.h264.vui_sar_idc = vui_sar_idc(ctrl->val);
1561                 break;
1562         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_WIDTH:
1563                 p->codec.h264.vui_ext_sar_width = ctrl->val;
1564                 break;
1565         case V4L2_CID_MPEG_VIDEO_H264_VUI_EXT_SAR_HEIGHT:
1566                 p->codec.h264.vui_ext_sar_height = ctrl->val;
1567                 break;
1568         case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1569                 p->codec.h264.open_gop = !ctrl->val;
1570                 break;
1571         case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
1572                 p->codec.h264.open_gop_size = ctrl->val;
1573                 break;
1574         case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
1575                 switch (ctrl->val) {
1576                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
1577                         p->codec.mpeg4.profile =
1578                                 S5P_FIMV_ENC_PROFILE_MPEG4_SIMPLE;
1579                         break;
1580                 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
1581                         p->codec.mpeg4.profile =
1582                         S5P_FIMV_ENC_PROFILE_MPEG4_ADVANCED_SIMPLE;
1583                         break;
1584                 default:
1585                         ret = -EINVAL;
1586                 }
1587                 break;
1588         case V4L2_CID_MPEG_VIDEO_MPEG4_QPEL:
1589                 p->codec.mpeg4.quarter_pixel = ctrl->val;
1590                 break;
1591         case V4L2_CID_MPEG_VIDEO_H264_SEI_FRAME_PACKING:
1592                 p->codec.h264.sei_frame_packing = ctrl->val;
1593                 break;
1594         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_CURRENT_FRAME_0:
1595                 p->codec.h264.sei_fp_curr_frame_0 = ctrl->val;
1596                 break;
1597         case V4L2_CID_MPEG_VIDEO_H264_SEI_FP_ARRANGEMENT_TYPE:
1598                 p->codec.h264.sei_fp_arrangement_type = ctrl->val;
1599                 break;
1600         case V4L2_CID_MPEG_VIDEO_H264_FMO:
1601                 p->codec.h264.fmo = ctrl->val;
1602                 break;
1603         case V4L2_CID_MPEG_VIDEO_H264_FMO_MAP_TYPE:
1604                 p->codec.h264.fmo_map_type = ctrl->val;
1605                 break;
1606         case V4L2_CID_MPEG_VIDEO_H264_FMO_SLICE_GROUP:
1607                 p->codec.h264.fmo_slice_grp = ctrl->val;
1608                 break;
1609         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_DIRECTION:
1610                 p->codec.h264.fmo_chg_dir = ctrl->val;
1611                 break;
1612         case V4L2_CID_MPEG_VIDEO_H264_FMO_CHANGE_RATE:
1613                 p->codec.h264.fmo_chg_rate = ctrl->val;
1614                 break;
1615         case V4L2_CID_MPEG_VIDEO_H264_FMO_RUN_LENGTH:
1616                 p->codec.h264.fmo_run_len[ctrl->val >> 30]
1617                         = ctrl->val & 0x3FFFFFFF;
1618                 break;
1619         case V4L2_CID_MPEG_VIDEO_H264_ASO:
1620                 p->codec.h264.aso = ctrl->val;
1621                 break;
1622         case V4L2_CID_MPEG_VIDEO_H264_ASO_SLICE_ORDER:
1623                 p->codec.h264.aso_slice_order[(ctrl->val >> 18) & 0x7]
1624                         |= (ctrl->val & 0xFF) << (((ctrl->val >> 16) & 0x3) << 3);
1625                 break;
1626         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:
1627                 p->codec.h264.hier_qp = ctrl->val;
1628                 break;
1629         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
1630                 p->codec.h264.hier_qp_type = ctrl->val;
1631                 break;
1632         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:
1633                 p->codec.h264.hier_qp_layer = ctrl->val;
1634                 break;
1635         case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER_QP:
1636                 p->codec.h264.hier_qp_layer_qp[(ctrl->val >> 16) & 0x7]
1637                         = ctrl->val & 0xFF;
1638                 break;
1639         default:
1640                 v4l2_err(&dev->v4l2_dev, "Invalid control, id=%d, val=%d\n",
1641                                                         ctrl->id, ctrl->val);
1642                 ret = -EINVAL;
1643         }
1644         return ret;
1645 }
1646
1647 static const struct v4l2_ctrl_ops s5p_mfc_enc_ctrl_ops = {
1648         .s_ctrl = s5p_mfc_enc_s_ctrl,
1649 };
1650
1651 int vidioc_s_parm(struct file *file, void *priv, struct v4l2_streamparm *a)
1652 {
1653         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1654
1655         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1656                 ctx->enc_params.rc_framerate_num =
1657                                         a->parm.output.timeperframe.denominator;
1658                 ctx->enc_params.rc_framerate_denom =
1659                                         a->parm.output.timeperframe.numerator;
1660         } else {
1661                 mfc_err("Setting FPS is only possible for the output queue\n");
1662                 return -EINVAL;
1663         }
1664         return 0;
1665 }
1666
1667 int vidioc_g_parm(struct file *file, void *priv, struct v4l2_streamparm *a)
1668 {
1669         struct s5p_mfc_ctx *ctx = fh_to_ctx(priv);
1670
1671         if (a->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1672                 a->parm.output.timeperframe.denominator =
1673                                         ctx->enc_params.rc_framerate_num;
1674                 a->parm.output.timeperframe.numerator =
1675                                         ctx->enc_params.rc_framerate_denom;
1676         } else {
1677                 mfc_err("Setting FPS is only possible for the output queue\n");
1678                 return -EINVAL;
1679         }
1680         return 0;
1681 }
1682
1683 static const struct v4l2_ioctl_ops s5p_mfc_enc_ioctl_ops = {
1684         .vidioc_querycap = vidioc_querycap,
1685         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1686         .vidioc_enum_fmt_vid_cap_mplane = vidioc_enum_fmt_vid_cap_mplane,
1687         .vidioc_enum_fmt_vid_out = vidioc_enum_fmt_vid_out,
1688         .vidioc_enum_fmt_vid_out_mplane = vidioc_enum_fmt_vid_out_mplane,
1689         .vidioc_g_fmt_vid_cap_mplane = vidioc_g_fmt,
1690         .vidioc_g_fmt_vid_out_mplane = vidioc_g_fmt,
1691         .vidioc_try_fmt_vid_cap_mplane = vidioc_try_fmt,
1692         .vidioc_try_fmt_vid_out_mplane = vidioc_try_fmt,
1693         .vidioc_s_fmt_vid_cap_mplane = vidioc_s_fmt,
1694         .vidioc_s_fmt_vid_out_mplane = vidioc_s_fmt,
1695         .vidioc_reqbufs = vidioc_reqbufs,
1696         .vidioc_querybuf = vidioc_querybuf,
1697         .vidioc_qbuf = vidioc_qbuf,
1698         .vidioc_dqbuf = vidioc_dqbuf,
1699         .vidioc_expbuf = vidioc_expbuf,
1700         .vidioc_streamon = vidioc_streamon,
1701         .vidioc_streamoff = vidioc_streamoff,
1702         .vidioc_s_parm = vidioc_s_parm,
1703         .vidioc_g_parm = vidioc_g_parm,
1704 };
1705
1706 static int check_vb_with_fmt(struct s5p_mfc_fmt *fmt, struct vb2_buffer *vb)
1707 {
1708         int i;
1709
1710         if (!fmt)
1711                 return -EINVAL;
1712         if (fmt->num_planes != vb->num_planes) {
1713                 mfc_err("invalid plane number for the format\n");
1714                 return -EINVAL;
1715         }
1716         for (i = 0; i < fmt->num_planes; i++) {
1717                 if (!vb2_dma_contig_plane_dma_addr(vb, i)) {
1718                         mfc_err("failed to get plane cookie\n");
1719                         return -EINVAL;
1720                 }
1721                 mfc_debug(2, "index: %d, plane[%d] cookie: 0x%08zx",
1722                                 vb->v4l2_buf.index, i,
1723                                 vb2_dma_contig_plane_dma_addr(vb, i));
1724         }
1725         return 0;
1726 }
1727
1728 static int s5p_mfc_queue_setup(struct vb2_queue *vq,
1729                         const struct v4l2_format *fmt,
1730                         unsigned int *buf_count, unsigned int *plane_count,
1731                         unsigned int psize[], void *allocators[])
1732 {
1733         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1734         struct s5p_mfc_dev *dev = ctx->dev;
1735
1736         if (ctx->state != MFCINST_GOT_INST) {
1737                 mfc_err("inavlid state: %d\n", ctx->state);
1738                 return -EINVAL;
1739         }
1740         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1741                 if (ctx->dst_fmt)
1742                         *plane_count = ctx->dst_fmt->num_planes;
1743                 else
1744                         *plane_count = MFC_ENC_CAP_PLANE_COUNT;
1745                 if (*buf_count < 1)
1746                         *buf_count = 1;
1747                 if (*buf_count > MFC_MAX_BUFFERS)
1748                         *buf_count = MFC_MAX_BUFFERS;
1749                 psize[0] = ctx->enc_dst_buf_size;
1750                 allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1751         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1752                 if (ctx->src_fmt)
1753                         *plane_count = ctx->src_fmt->num_planes;
1754                 else
1755                         *plane_count = MFC_ENC_OUT_PLANE_COUNT;
1756
1757                 if (*buf_count < 1)
1758                         *buf_count = 1;
1759                 if (*buf_count > MFC_MAX_BUFFERS)
1760                         *buf_count = MFC_MAX_BUFFERS;
1761                 psize[0] = ctx->luma_size;
1762                 psize[1] = ctx->chroma_size;
1763                 if (IS_MFCV6(dev)) {
1764                         allocators[0] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1765                         allocators[1] = ctx->dev->alloc_ctx[MFC_BANK1_ALLOC_CTX];
1766                 } else {
1767                         allocators[0] = ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1768                         allocators[1] = ctx->dev->alloc_ctx[MFC_BANK2_ALLOC_CTX];
1769                 }
1770         } else {
1771                 mfc_err("inavlid queue type: %d\n", vq->type);
1772                 return -EINVAL;
1773         }
1774         return 0;
1775 }
1776
1777 static void s5p_mfc_unlock(struct vb2_queue *q)
1778 {
1779         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1780         struct s5p_mfc_dev *dev = ctx->dev;
1781
1782         mutex_unlock(&dev->mfc_mutex);
1783 }
1784
1785 static void s5p_mfc_lock(struct vb2_queue *q)
1786 {
1787         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1788         struct s5p_mfc_dev *dev = ctx->dev;
1789
1790         mutex_lock(&dev->mfc_mutex);
1791 }
1792
1793 static int s5p_mfc_buf_init(struct vb2_buffer *vb)
1794 {
1795         struct vb2_queue *vq = vb->vb2_queue;
1796         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1797         unsigned int i;
1798         int ret;
1799
1800         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1801                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1802                 if (ret < 0)
1803                         return ret;
1804                 i = vb->v4l2_buf.index;
1805                 ctx->dst_bufs[i].b = vb;
1806                 ctx->dst_bufs[i].cookie.stream =
1807                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1808                 ctx->dst_bufs_cnt++;
1809         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1810                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1811                 if (ret < 0)
1812                         return ret;
1813                 i = vb->v4l2_buf.index;
1814                 ctx->src_bufs[i].b = vb;
1815                 ctx->src_bufs[i].cookie.raw.luma =
1816                                         vb2_dma_contig_plane_dma_addr(vb, 0);
1817                 ctx->src_bufs[i].cookie.raw.chroma =
1818                                         vb2_dma_contig_plane_dma_addr(vb, 1);
1819                 ctx->src_bufs_cnt++;
1820         } else {
1821                 mfc_err("inavlid queue type: %d\n", vq->type);
1822                 return -EINVAL;
1823         }
1824         return 0;
1825 }
1826
1827 static int s5p_mfc_buf_prepare(struct vb2_buffer *vb)
1828 {
1829         struct vb2_queue *vq = vb->vb2_queue;
1830         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1831         int ret;
1832
1833         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1834                 ret = check_vb_with_fmt(ctx->dst_fmt, vb);
1835                 if (ret < 0)
1836                         return ret;
1837                 mfc_debug(2, "plane size: %ld, dst size: %d\n",
1838                         vb2_plane_size(vb, 0), ctx->enc_dst_buf_size);
1839                 if (vb2_plane_size(vb, 0) < ctx->enc_dst_buf_size) {
1840                         mfc_err("plane size is too small for capture\n");
1841                         return -EINVAL;
1842                 }
1843         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1844                 ret = check_vb_with_fmt(ctx->src_fmt, vb);
1845                 if (ret < 0)
1846                         return ret;
1847                 mfc_debug(2, "plane size: %ld, luma size: %d\n",
1848                         vb2_plane_size(vb, 0), ctx->luma_size);
1849                 mfc_debug(2, "plane size: %ld, chroma size: %d\n",
1850                         vb2_plane_size(vb, 1), ctx->chroma_size);
1851                 if (vb2_plane_size(vb, 0) < ctx->luma_size ||
1852                     vb2_plane_size(vb, 1) < ctx->chroma_size) {
1853                         mfc_err("plane size is too small for output\n");
1854                         return -EINVAL;
1855                 }
1856         } else {
1857                 mfc_err("inavlid queue type: %d\n", vq->type);
1858                 return -EINVAL;
1859         }
1860         return 0;
1861 }
1862
1863 static int s5p_mfc_start_streaming(struct vb2_queue *q, unsigned int count)
1864 {
1865         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1866         struct s5p_mfc_dev *dev = ctx->dev;
1867         unsigned long flags;
1868
1869         v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
1870         /* If context is ready then dev = work->data;schedule it to run */
1871         if (s5p_mfc_ctx_ready(ctx)) {
1872                 spin_lock_irqsave(&dev->condlock, flags);
1873                 set_bit(ctx->num, &dev->ctx_work_bits);
1874                 spin_unlock_irqrestore(&dev->condlock, flags);
1875         }
1876         s5p_mfc_try_run(dev);
1877         return 0;
1878 }
1879
1880 static int s5p_mfc_stop_streaming(struct vb2_queue *q)
1881 {
1882         unsigned long flags;
1883         struct s5p_mfc_ctx *ctx = fh_to_ctx(q->drv_priv);
1884         struct s5p_mfc_dev *dev = ctx->dev;
1885
1886         if ((ctx->state == MFCINST_FINISHING ||
1887                 ctx->state == MFCINST_RUNNING) &&
1888                 dev->curr_ctx == ctx->num && dev->hw_lock) {
1889                 ctx->state = MFCINST_ABORT;
1890                 s5p_mfc_wait_for_done_ctx(ctx, S5P_FIMV_R2H_CMD_FRAME_DONE_RET,
1891                                           0);
1892         }
1893         ctx->state = MFCINST_FINISHED;
1894         spin_lock_irqsave(&dev->irqlock, flags);
1895         if (q->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1896                 s5p_mfc_cleanup_queue(&ctx->dst_queue, &ctx->vq_dst);
1897                 INIT_LIST_HEAD(&ctx->dst_queue);
1898                 ctx->dst_queue_cnt = 0;
1899         }
1900         if (q->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1901                 cleanup_ref_queue(ctx);
1902                 s5p_mfc_cleanup_queue(&ctx->src_queue, &ctx->vq_src);
1903                 INIT_LIST_HEAD(&ctx->src_queue);
1904                 ctx->src_queue_cnt = 0;
1905         }
1906         spin_unlock_irqrestore(&dev->irqlock, flags);
1907         return 0;
1908 }
1909
1910 static void s5p_mfc_buf_queue(struct vb2_buffer *vb)
1911 {
1912         struct vb2_queue *vq = vb->vb2_queue;
1913         struct s5p_mfc_ctx *ctx = fh_to_ctx(vq->drv_priv);
1914         struct s5p_mfc_dev *dev = ctx->dev;
1915         unsigned long flags;
1916         struct s5p_mfc_buf *mfc_buf;
1917
1918         if (ctx->state == MFCINST_ERROR) {
1919                 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
1920                 cleanup_ref_queue(ctx);
1921                 return;
1922         }
1923         if (vq->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
1924                 mfc_buf = &ctx->dst_bufs[vb->v4l2_buf.index];
1925                 mfc_buf->used = 0;
1926                 /* Mark destination as available for use by MFC */
1927                 spin_lock_irqsave(&dev->irqlock, flags);
1928                 list_add_tail(&mfc_buf->list, &ctx->dst_queue);
1929                 ctx->dst_queue_cnt++;
1930                 spin_unlock_irqrestore(&dev->irqlock, flags);
1931         } else if (vq->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
1932                 mfc_buf = &ctx->src_bufs[vb->v4l2_buf.index];
1933                 mfc_buf->used = 0;
1934                 spin_lock_irqsave(&dev->irqlock, flags);
1935                 if (vb->v4l2_planes[0].bytesused == 0) {
1936                         mfc_debug(1, "change state to FINISHING\n");
1937                         ctx->state = MFCINST_FINISHING;
1938                         vb2_buffer_done(vb, VB2_BUF_STATE_DONE);
1939                         cleanup_ref_queue(ctx);
1940                 } else {
1941                         list_add_tail(&mfc_buf->list, &ctx->src_queue);
1942                         ctx->src_queue_cnt++;
1943                 }
1944                 spin_unlock_irqrestore(&dev->irqlock, flags);
1945         } else {
1946                 mfc_err("unsupported buffer type (%d)\n", vq->type);
1947         }
1948         if (s5p_mfc_ctx_ready(ctx)) {
1949                 spin_lock_irqsave(&dev->condlock, flags);
1950                 set_bit(ctx->num, &dev->ctx_work_bits);
1951                 spin_unlock_irqrestore(&dev->condlock, flags);
1952         }
1953         s5p_mfc_try_run(dev);
1954 }
1955
1956 static struct vb2_ops s5p_mfc_enc_qops = {
1957         .queue_setup            = s5p_mfc_queue_setup,
1958         .wait_prepare           = s5p_mfc_unlock,
1959         .wait_finish            = s5p_mfc_lock,
1960         .buf_init               = s5p_mfc_buf_init,
1961         .buf_prepare            = s5p_mfc_buf_prepare,
1962         .start_streaming        = s5p_mfc_start_streaming,
1963         .stop_streaming         = s5p_mfc_stop_streaming,
1964         .buf_queue              = s5p_mfc_buf_queue,
1965 };
1966
1967 struct s5p_mfc_codec_ops *get_enc_codec_ops(void)
1968 {
1969         return &encoder_codec_ops;
1970 }
1971
1972 struct vb2_ops *get_enc_queue_ops(void)
1973 {
1974         return &s5p_mfc_enc_qops;
1975 }
1976
1977 const struct v4l2_ioctl_ops *get_enc_v4l2_ioctl_ops(void)
1978 {
1979         return &s5p_mfc_enc_ioctl_ops;
1980 }
1981
1982 #define IS_MFC51_PRIV(x) ((V4L2_CTRL_ID2CLASS(x) == V4L2_CTRL_CLASS_MPEG) \
1983                                                 && V4L2_CTRL_DRIVER_PRIV(x))
1984
1985 int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
1986 {
1987         struct v4l2_ctrl_config cfg;
1988         int i;
1989
1990         v4l2_ctrl_handler_init(&ctx->ctrl_handler, NUM_CTRLS);
1991         if (ctx->ctrl_handler.error) {
1992                 mfc_err("v4l2_ctrl_handler_init failed\n");
1993                 return ctx->ctrl_handler.error;
1994         }
1995         for (i = 0; i < NUM_CTRLS; i++) {
1996                 if (IS_MFC51_PRIV(controls[i].id)) {
1997                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
1998                         cfg.id = controls[i].id;
1999                         cfg.min = controls[i].minimum;
2000                         cfg.max = controls[i].maximum;
2001                         cfg.def = controls[i].default_value;
2002                         cfg.name = controls[i].name;
2003                         cfg.type = controls[i].type;
2004                         cfg.flags = 0;
2005
2006                         if (cfg.type == V4L2_CTRL_TYPE_MENU) {
2007                                 cfg.step = 0;
2008                                 cfg.menu_skip_mask = cfg.menu_skip_mask;
2009                                 cfg.qmenu = mfc51_get_menu(cfg.id);
2010                         } else {
2011                                 cfg.step = controls[i].step;
2012                                 cfg.menu_skip_mask = 0;
2013                         }
2014                         ctx->ctrls[i] = v4l2_ctrl_new_custom(&ctx->ctrl_handler,
2015                                         &cfg, NULL);
2016                 } else {
2017                         if (controls[i].type == V4L2_CTRL_TYPE_MENU) {
2018                                 ctx->ctrls[i] = v4l2_ctrl_new_std_menu(
2019                                         &ctx->ctrl_handler,
2020                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2021                                         controls[i].maximum, 0,
2022                                         controls[i].default_value);
2023                         } else {
2024                                 ctx->ctrls[i] = v4l2_ctrl_new_std(
2025                                         &ctx->ctrl_handler,
2026                                         &s5p_mfc_enc_ctrl_ops, controls[i].id,
2027                                         controls[i].minimum,
2028                                         controls[i].maximum, controls[i].step,
2029                                         controls[i].default_value);
2030                         }
2031                 }
2032                 if (ctx->ctrl_handler.error) {
2033                         mfc_err("Adding control (%d) failed\n", i);
2034                         return ctx->ctrl_handler.error;
2035                 }
2036                 if (controls[i].is_volatile && ctx->ctrls[i])
2037                         ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
2038         }
2039         return 0;
2040 }
2041
2042 void s5p_mfc_enc_ctrls_delete(struct s5p_mfc_ctx *ctx)
2043 {
2044         int i;
2045
2046         v4l2_ctrl_handler_free(&ctx->ctrl_handler);
2047         for (i = 0; i < NUM_CTRLS; i++)
2048                 ctx->ctrls[i] = NULL;
2049 }
2050
2051 void s5p_mfc_enc_init(struct s5p_mfc_ctx *ctx)
2052 {
2053         ctx->src_fmt = &formats[DEF_SRC_FMT];
2054         ctx->dst_fmt = &formats[DEF_DST_FMT];
2055 }
2056