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