target/linux/brcm2708/patches-3.10/0169-V4L2-H264-profile-level-ctrls-FPS-control-and-auto-e.patch

   1 From 6b3c057ec5705d3c7556d4755103a2650d3aaaf5 Mon Sep 17 00:00:00 2001
   2 From: Dave Stevenson <dsteve@broadcom.com>
   3 Date: Wed, 12 Feb 2014 11:18:20 +0000
   4 Subject: [PATCH 169/174] V4L2: H264 profile & level ctrls, FPS control and
   5  auto exp pri
   6
   7 Several control handling updates.
   8 H264 profile and level controls.
   9 Timeperframe/FPS reworked to add V4L2_CID_EXPOSURE_AUTO_PRIORITY to
  10 select whether AE is allowed to override the framerate specified.
  11
  12 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  13 ---
  14  drivers/media/platform/bcm2835/bcm2835-camera.c  | 107 ++++++-----
  15  drivers/media/platform/bcm2835/bcm2835-camera.h  |  12 +-
  16  drivers/media/platform/bcm2835/controls.c        | 225 ++++++++++++++++++++++-
  17  drivers/media/platform/bcm2835/mmal-parameters.h |  87 +++++++++
  18  4 files changed, 383 insertions(+), 48 deletions(-)
  19
  20 --- a/drivers/media/platform/bcm2835/bcm2835-camera.c
  21 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.c
  22 @@ -36,7 +36,8 @@
  23
  24  #define BM2835_MMAL_VERSION "0.0.2"
  25  #define BM2835_MMAL_MODULE_NAME "bcm2835-v4l2"
  26 -
  27 +#define MIN_WIDTH 16
  28 +#define MIN_HEIGHT 16
  29  #define MAX_WIDTH 2592
  30  #define MAX_HEIGHT 1944
  31  #define MIN_BUFFER_SIZE (80*1024)
  32 @@ -56,7 +57,7 @@ MODULE_PARM_DESC(bcm2835_v4l2_debug, "De
  33  static struct bm2835_mmal_dev *gdev;   /* global device data */
  34
  35  #define FPS_MIN 1
  36 -#define FPS_MAX 30
  37 +#define FPS_MAX 90
  38
  39  /* timeperframe: min/max and default */
  40  static const struct v4l2_fract
  41 @@ -903,10 +904,8 @@ static int mmal_setup_components(struct
  42         camera_port->es.video.crop.y = 0;
  43         camera_port->es.video.crop.width = f->fmt.pix.width;
  44         camera_port->es.video.crop.height = f->fmt.pix.height;
  45 -       camera_port->es.video.frame_rate.num =
  46 -                       dev->capture.timeperframe.denominator;
  47 -       camera_port->es.video.frame_rate.den =
  48 -                       dev->capture.timeperframe.numerator;
  49 +       camera_port->es.video.frame_rate.num = 0;
  50 +       camera_port->es.video.frame_rate.den = 1;
  51
  52         ret = vchiq_mmal_port_set_format(dev->instance, camera_port);
  53
  54 @@ -940,8 +939,10 @@ static int mmal_setup_components(struct
  55                 preview_port->es.video.crop.y = 0;
  56                 preview_port->es.video.crop.width = f->fmt.pix.width;
  57                 preview_port->es.video.crop.height = f->fmt.pix.height;
  58 -               preview_port->es.video.frame_rate.num = 30;
  59 -               preview_port->es.video.frame_rate.den = 1;
  60 +               preview_port->es.video.frame_rate.num =
  61 +                                         dev->capture.timeperframe.denominator;
  62 +               preview_port->es.video.frame_rate.den =
  63 +                                         dev->capture.timeperframe.numerator;
  64                 ret = vchiq_mmal_port_set_format(dev->instance, preview_port);
  65                 if (overlay_enabled) {
  66                         ret = vchiq_mmal_port_connect_tunnel(
  67 @@ -1116,22 +1117,56 @@ static int vidioc_s_fmt_vid_cap(struct f
  68         }
  69
  70         ret = mmal_setup_components(dev, f);
  71 -       if (ret != 0)
  72 +       if (ret != 0) {
  73                 v4l2_err(&dev->v4l2_dev,
  74                          "%s: failed to setup mmal components: %d\n",
  75                          __func__, ret);
  76 +               ret = -EINVAL;
  77 +       }
  78
  79         return ret;
  80  }
  81
  82 +int vidioc_enum_framesizes(struct file *file, void *fh,
  83 +                          struct v4l2_frmsizeenum *fsize)
  84 +{
  85 +       static const struct v4l2_frmsize_stepwise sizes = {
  86 +               MIN_WIDTH, MAX_WIDTH, 2,
  87 +               MIN_HEIGHT, MAX_HEIGHT, 2
  88 +       };
  89 +       int i;
  90 +
  91 +       if (fsize->index)
  92 +               return -EINVAL;
  93 +       for (i = 0; i < ARRAY_SIZE(formats); i++)
  94 +               if (formats[i].fourcc == fsize->pixel_format)
  95 +                       break;
  96 +       if (i == ARRAY_SIZE(formats))
  97 +               return -EINVAL;
  98 +       fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
  99 +       fsize->stepwise = sizes;
 100 +       return 0;
 101 +}
 102 +
 103  /* timeperframe is arbitrary and continous */
 104  static int vidioc_enum_frameintervals(struct file *file, void *priv,
 105                                              struct v4l2_frmivalenum *fival)
 106  {
 107 +       int i;
 108 +
 109         if (fival->index)
 110                 return -EINVAL;
 111
 112 -       /* regarding width & height - we support any */
 113 +       for (i = 0; i < ARRAY_SIZE(formats); i++)
 114 +               if (formats[i].fourcc == fival->pixel_format)
 115 +                       break;
 116 +       if (i == ARRAY_SIZE(formats))
 117 +               return -EINVAL;
 118 +
 119 +       /* regarding width & height - we support any within range */
 120 +       if (fival->width < MIN_WIDTH || fival->width > MAX_WIDTH ||
 121 +           fival->height < MIN_HEIGHT || fival->height > MAX_HEIGHT)
 122 +               return -EINVAL;
 123
 124         fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
 125
 126 @@ -1167,7 +1202,6 @@ static int vidioc_s_parm(struct file *fi
 127         struct bm2835_mmal_dev *dev = video_drvdata(file);
 128         struct v4l2_fract tpf;
 129         struct mmal_parameter_rational fps_param;
 130 -       int ret;
 131
 132         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 133                 return -EINVAL;
 134 @@ -1183,27 +1217,11 @@ static int vidioc_s_parm(struct file *fi
 135         parm->parm.capture.timeperframe = tpf;
 136         parm->parm.capture.readbuffers  = 1;
 137
 138 -       fps_param.num = dev->capture.timeperframe.denominator;
 139 -       fps_param.den = dev->capture.timeperframe.numerator;
 140 -       ret = vchiq_mmal_port_parameter_set(dev->instance,
 141 -                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 142 -                                       output[MMAL_CAMERA_PORT_PREVIEW],
 143 -                                     MMAL_PARAMETER_VIDEO_FRAME_RATE,
 144 -                                     &fps_param, sizeof(fps_param));
 145 -       ret += vchiq_mmal_port_parameter_set(dev->instance,
 146 -                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 147 -                                       output[MMAL_CAMERA_PORT_VIDEO],
 148 -                                     MMAL_PARAMETER_VIDEO_FRAME_RATE,
 149 -                                     &fps_param, sizeof(fps_param));
 150 -       ret += vchiq_mmal_port_parameter_set(dev->instance,
 151 -                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 152 -                                       output[MMAL_CAMERA_PORT_CAPTURE],
 153 -                                     MMAL_PARAMETER_VIDEO_FRAME_RATE,
 154 -                                     &fps_param, sizeof(fps_param));
 155 -       if (ret)
 156 -               v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
 157 -                "Failed to set fps ret %d\n",
 158 -                ret);
 159 +       fps_param.num = 0;      /* Select variable fps, and then use
 160 +                                * FPS_RANGE to select the actual limits.
 161 +                                */
 162 +       fps_param.den = 1;
 163 +       set_framerate_params(dev);
 164
 165         return 0;
 166  }
 167 @@ -1236,6 +1254,7 @@ static const struct v4l2_ioctl_ops camer
 168         .vidioc_querybuf = vb2_ioctl_querybuf,
 169         .vidioc_qbuf = vb2_ioctl_qbuf,
 170         .vidioc_dqbuf = vb2_ioctl_dqbuf,
 171 +       .vidioc_enum_framesizes = vidioc_enum_framesizes,
 172         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
 173         .vidioc_g_parm        = vidioc_g_parm,
 174         .vidioc_s_parm        = vidioc_s_parm,
 175 @@ -1331,10 +1350,8 @@ static int __init mmal_init(struct bm283
 176         format->es->video.crop.y = 0;
 177         format->es->video.crop.width = 1024;
 178         format->es->video.crop.height = 768;
 179 -       format->es->video.frame_rate.num =
 180 -                       dev->capture.timeperframe.denominator;
 181 -       format->es->video.frame_rate.den =
 182 -                       dev->capture.timeperframe.numerator;
 183 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
 184 +       format->es->video.frame_rate.den = 1;
 185
 186         format =
 187             &dev->component[MMAL_COMPONENT_CAMERA]->
 188 @@ -1349,10 +1366,8 @@ static int __init mmal_init(struct bm283
 189         format->es->video.crop.y = 0;
 190         format->es->video.crop.width = 1024;
 191         format->es->video.crop.height = 768;
 192 -       format->es->video.frame_rate.num =
 193 -                       dev->capture.timeperframe.denominator;
 194 -       format->es->video.frame_rate.den =
 195 -                       dev->capture.timeperframe.numerator;
 196 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
 197 +       format->es->video.frame_rate.den = 1;
 198
 199         format =
 200             &dev->component[MMAL_COMPONENT_CAMERA]->
 201 @@ -1366,7 +1381,7 @@ static int __init mmal_init(struct bm283
 202         format->es->video.crop.y = 0;
 203         format->es->video.crop.width = 2592;
 204         format->es->video.crop.height = 1944;
 205 -       format->es->video.frame_rate.num = 30;
 206 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
 207         format->es->video.frame_rate.den = 1;
 208
 209         dev->capture.width = format->es->video.width;
 210 @@ -1374,6 +1389,8 @@ static int __init mmal_init(struct bm283
 211         dev->capture.fmt = &formats[0];
 212         dev->capture.encode_component = NULL;
 213         dev->capture.timeperframe = tpf_default;
 214 +       dev->capture.enc_profile = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
 215 +       dev->capture.enc_level = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
 216
 217         /* get the preview component ready */
 218         ret = vchiq_mmal_component_init(
 219 @@ -1420,6 +1437,14 @@ static int __init mmal_init(struct bm283
 220         }
 221
 222         {
 223 +               struct vchiq_mmal_port *encoder_port =
 224 +                       &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
 225 +               encoder_port->format.encoding = MMAL_ENCODING_H264;
 226 +               ret = vchiq_mmal_port_set_format(dev->instance,
 227 +                       encoder_port);
 228 +       }
 229 +
 230 +       {
 231                 unsigned int enable = 1;
 232                 vchiq_mmal_port_parameter_set(
 233                         dev->instance,
 234 --- a/drivers/media/platform/bcm2835/bcm2835-camera.h
 235 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.h
 236 @@ -15,7 +15,7 @@
 237   * core driver device
 238   */
 239
 240 -#define V4L2_CTRL_COUNT 21 /* number of v4l controls */
 241 +#define V4L2_CTRL_COUNT 24 /* number of v4l controls */
 242
 243  enum {
 244         MMAL_COMPONENT_CAMERA = 0,
 245 @@ -49,7 +49,9 @@ struct bm2835_mmal_dev {
 246         int                       hflip;
 247         int                       vflip;
 248         enum mmal_parameter_exposuremode exposure_mode;
 249 +       enum v4l2_exposure_auto_type exposure_mode_v4l2;
 250         unsigned int              manual_shutter_speed;
 251 +       bool                      exp_auto_priority;
 252
 253         /* allocated mmal instance and components */
 254         struct vchiq_mmal_instance   *instance;
 255 @@ -63,12 +65,16 @@ struct bm2835_mmal_dev {
 256                 unsigned int     height;  /* height */
 257                 unsigned int     stride;  /* stride */
 258                 struct mmal_fmt  *fmt;
 259 -               struct v4l2_fract          timeperframe;
 260 +               struct v4l2_fract timeperframe;
 261
 262                 /* H264 encode bitrate */
 263                 int         encode_bitrate;
 264                 /* H264 bitrate mode. CBR/VBR */
 265                 int         encode_bitrate_mode;
 266 +               /* H264 profile */
 267 +               enum v4l2_mpeg_video_h264_profile enc_profile;
 268 +               /* H264 level */
 269 +               enum v4l2_mpeg_video_h264_level enc_level;
 270                 /* JPEG Q-factor */
 271                 int         q_factor;
 272
 273 @@ -98,7 +104,7 @@ int bm2835_mmal_init_controls(
 274                         struct v4l2_ctrl_handler *hdl);
 275
 276  int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev);
 277 -
 278 +int set_framerate_params(struct bm2835_mmal_dev *dev);
 279
 280  /* Debug helpers */
 281
 282 --- a/drivers/media/platform/bcm2835/controls.c
 283 +++ b/drivers/media/platform/bcm2835/controls.c
 284 @@ -69,7 +69,6 @@ static const s64 bitrate_mode_qmenu[] =
 285         (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
 286  };
 287
 288 -
 289  enum bm2835_mmal_ctrl_type {
 290         MMAL_CONTROL_TYPE_STD,
 291         MMAL_CONTROL_TYPE_STD_MENU,
 292 @@ -329,6 +328,9 @@ static int ctrl_set_exposure(struct bm28
 293
 294                 }
 295                 dev->exposure_mode = exp_mode;
 296 +               dev->exposure_mode_v4l2 = ctrl->val;
 297 +       } else if (mmal_ctrl->id == V4L2_CID_EXPOSURE_AUTO_PRIORITY) {
 298 +               dev->exp_auto_priority = ctrl->val;
 299         }
 300
 301         if (dev->exposure_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
 302 @@ -340,6 +342,8 @@ static int ctrl_set_exposure(struct bm28
 303         ret += vchiq_mmal_port_parameter_set(dev->instance, control,
 304                                              MMAL_PARAMETER_EXPOSURE_MODE,
 305                                              &exp_mode, sizeof(u32));
 306 +       ret += set_framerate_params(dev);
 307 +
 308         return ret;
 309  }
 310
 311 @@ -540,8 +544,8 @@ static int ctrl_set_colfx(struct bm2835_
 312                                         &dev->colourfx, sizeof(dev->colourfx));
 313
 314         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 315 -                "After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
 316 -                       mmal_ctrl, ctrl->id, ctrl->val, ret,
 317 +                "%s: After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
 318 +                       __func__, mmal_ctrl, ctrl->id, ctrl->val, ret,
 319                         (ret == 0 ? 0 : -EINVAL));
 320         return (ret == 0 ? 0 : EINVAL);
 321  }
 322 @@ -623,6 +627,117 @@ static int ctrl_set_video_encode_param_o
 323                                              &u32_value, sizeof(u32_value));
 324  }
 325
 326 +static int ctrl_set_video_encode_profile_level(struct bm2835_mmal_dev *dev,
 327 +                     struct v4l2_ctrl *ctrl,
 328 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 329 +{
 330 +       struct mmal_parameter_video_profile param;
 331 +       int ret = 0;
 332 +
 333 +       if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_PROFILE) {
 334 +               switch (ctrl->val) {
 335 +               case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
 336 +               case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
 337 +               case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
 338 +               case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
 339 +                       dev->capture.enc_profile = ctrl->val;
 340 +                       break;
 341 +               default:
 342 +                       ret = -EINVAL;
 343 +                       break;
 344 +               }
 345 +       } else if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_LEVEL) {
 346 +               switch (ctrl->val) {
 347 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
 348 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
 349 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
 350 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
 351 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
 352 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
 353 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
 354 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
 355 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
 356 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
 357 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
 358 +               case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
 359 +                       dev->capture.enc_level = ctrl->val;
 360 +                       break;
 361 +               default:
 362 +                       ret = -EINVAL;
 363 +                       break;
 364 +               }
 365 +       }
 366 +
 367 +       if (!ret) {
 368 +               switch (dev->capture.enc_profile) {
 369 +               case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
 370 +                       param.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
 371 +                       break;
 372 +               case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
 373 +                       param.profile =
 374 +                               MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE;
 375 +                       break;
 376 +               case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
 377 +                       param.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
 378 +                       break;
 379 +               case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
 380 +                       param.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
 381 +                       break;
 382 +               default:
 383 +                       /* Should never get here */
 384 +                       break;
 385 +               }
 386 +
 387 +               switch (dev->capture.enc_level) {
 388 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
 389 +                       param.level = MMAL_VIDEO_LEVEL_H264_1;
 390 +                       break;
 391 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
 392 +                       param.level = MMAL_VIDEO_LEVEL_H264_1b;
 393 +                       break;
 394 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
 395 +                       param.level = MMAL_VIDEO_LEVEL_H264_11;
 396 +                       break;
 397 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
 398 +                       param.level = MMAL_VIDEO_LEVEL_H264_12;
 399 +                       break;
 400 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
 401 +                       param.level = MMAL_VIDEO_LEVEL_H264_13;
 402 +                       break;
 403 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
 404 +                       param.level = MMAL_VIDEO_LEVEL_H264_2;
 405 +                       break;
 406 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
 407 +                       param.level = MMAL_VIDEO_LEVEL_H264_21;
 408 +                       break;
 409 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
 410 +                       param.level = MMAL_VIDEO_LEVEL_H264_22;
 411 +                       break;
 412 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
 413 +                       param.level = MMAL_VIDEO_LEVEL_H264_3;
 414 +                       break;
 415 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
 416 +                       param.level = MMAL_VIDEO_LEVEL_H264_31;
 417 +                       break;
 418 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
 419 +                       param.level = MMAL_VIDEO_LEVEL_H264_32;
 420 +                       break;
 421 +               case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
 422 +                       param.level = MMAL_VIDEO_LEVEL_H264_4;
 423 +                       break;
 424 +               default:
 425 +                       /* Should never get here */
 426 +                       break;
 427 +               }
 428 +
 429 +               ret = vchiq_mmal_port_parameter_set(dev->instance,
 430 +                       &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0],
 431 +                       mmal_ctrl->mmal_id,
 432 +                       &param, sizeof(param));
 433 +       }
 434 +       return ret;
 435 +}
 436 +
 437  static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
 438  {
 439         struct bm2835_mmal_dev *dev =
 440 @@ -639,6 +754,9 @@ static int bm2835_mmal_s_ctrl(struct v4l
 441         }
 442
 443         ret = mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
 444 +       if (ret)
 445 +               pr_warn("ctrl id:%d/MMAL param %08X- returned ret %d\n",
 446 +                               ctrl->id, mmal_ctrl->mmal_id, ret);
 447         if (mmal_ctrl->ignore_errors)
 448                 ret = 0;
 449         return ret;
 450 @@ -725,6 +843,14 @@ static const struct bm2835_mmal_v4l2_ctr
 451                 false
 452         },
 453         {
 454 +               V4L2_CID_EXPOSURE_AUTO_PRIORITY, MMAL_CONTROL_TYPE_STD,
 455 +               0, 1,
 456 +               0, 1, NULL,
 457 +               0,      /* Dummy MMAL ID as it gets mapped into FPS range*/
 458 +               &ctrl_set_exposure,
 459 +               false
 460 +       },
 461 +       {
 462                 V4L2_CID_EXPOSURE_METERING,
 463                 MMAL_CONTROL_TYPE_STD_MENU,
 464                 ~0x7, 2, V4L2_EXPOSURE_METERING_AVERAGE, 0, NULL,
 465 @@ -814,6 +940,39 @@ static const struct bm2835_mmal_v4l2_ctr
 466                 &ctrl_set_video_encode_param_output,
 467                 true    /* Errors ignored as requires latest firmware to work */
 468         },
 469 +       {
 470 +               V4L2_CID_MPEG_VIDEO_H264_PROFILE,
 471 +               MMAL_CONTROL_TYPE_STD_MENU,
 472 +               ~((1<<V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
 473 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
 474 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
 475 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
 476 +               V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
 477 +               V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 1, NULL,
 478 +               MMAL_PARAMETER_PROFILE,
 479 +               &ctrl_set_video_encode_profile_level,
 480 +               false
 481 +       },
 482 +       {
 483 +               V4L2_CID_MPEG_VIDEO_H264_LEVEL, MMAL_CONTROL_TYPE_STD_MENU,
 484 +               ~((1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |
 485 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1B) |
 486 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_1) |
 487 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_2) |
 488 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_3) |
 489 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |
 490 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_1) |
 491 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_2) |
 492 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |
 493 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_1) |
 494 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_2) |
 495 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_4_0)),
 496 +               V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
 497 +               V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 1, NULL,
 498 +               MMAL_PARAMETER_PROFILE,
 499 +               &ctrl_set_video_encode_profile_level,
 500 +               false
 501 +       },
 502  };
 503
 504  int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev)
 505 @@ -825,13 +984,71 @@ int bm2835_mmal_set_all_camera_controls(
 506                 if ((dev->ctrls[c]) && (v4l2_ctrls[c].setter)) {
 507                         ret = v4l2_ctrls[c].setter(dev, dev->ctrls[c],
 508                                                    &v4l2_ctrls[c]);
 509 -                       if (!v4l2_ctrls[c]. ignore_errors && ret)
 510 +                       if (!v4l2_ctrls[c].ignore_errors && ret) {
 511 +                               v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 512 +                                       "Failed when setting default values for ctrl %d\n",
 513 +                                       c);
 514                                 break;
 515 +                       }
 516                 }
 517         }
 518         return ret;
 519  }
 520
 521 +int set_framerate_params(struct bm2835_mmal_dev *dev)
 522 +{
 523 +       struct mmal_parameter_fps_range fps_range;
 524 +       int ret;
 525 +
 526 +       if ((dev->exposure_mode_v4l2 == V4L2_EXPOSURE_AUTO ||
 527 +            dev->exposure_mode_v4l2 == V4L2_EXPOSURE_APERTURE_PRIORITY) &&
 528 +            (dev->exp_auto_priority)) {
 529 +               /* Variable FPS. Define min FPS as 1fps.
 530 +                * Max as max defined FPS.
 531 +                */
 532 +               fps_range.fps_low.num = 1;
 533 +               fps_range.fps_low.den = 1;
 534 +               fps_range.fps_high.num = dev->capture.timeperframe.denominator;
 535 +               fps_range.fps_high.den = dev->capture.timeperframe.numerator;
 536 +       } else {
 537 +               /* Fixed FPS - set min and max to be the same */
 538 +               fps_range.fps_low.num = fps_range.fps_high.num =
 539 +                       dev->capture.timeperframe.denominator;
 540 +               fps_range.fps_low.den = fps_range.fps_high.den =
 541 +                       dev->capture.timeperframe.numerator;
 542 +       }
 543 +
 544 +       v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 545 +                        "Set fps range to %d/%d to %d/%d\n",
 546 +                        fps_range.fps_low.num,
 547 +                        fps_range.fps_low.den,
 548 +                        fps_range.fps_high.num,
 549 +                        fps_range.fps_high.den
 550 +                );
 551 +
 552 +       ret = vchiq_mmal_port_parameter_set(dev->instance,
 553 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 554 +                                       output[MMAL_CAMERA_PORT_PREVIEW],
 555 +                                     MMAL_PARAMETER_FPS_RANGE,
 556 +                                     &fps_range, sizeof(fps_range));
 557 +       ret += vchiq_mmal_port_parameter_set(dev->instance,
 558 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 559 +                                       output[MMAL_CAMERA_PORT_VIDEO],
 560 +                                     MMAL_PARAMETER_FPS_RANGE,
 561 +                                     &fps_range, sizeof(fps_range));
 562 +       ret += vchiq_mmal_port_parameter_set(dev->instance,
 563 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
 564 +                                       output[MMAL_CAMERA_PORT_CAPTURE],
 565 +                                     MMAL_PARAMETER_FPS_RANGE,
 566 +                                     &fps_range, sizeof(fps_range));
 567 +       if (ret)
 568 +               v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
 569 +                "Failed to set fps ret %d\n",
 570 +                ret);
 571 +
 572 +       return ret;
 573 +
 574 +}
 575  int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
 576                               struct v4l2_ctrl_handler *hdl)
 577  {
 578 --- a/drivers/media/platform/bcm2835/mmal-parameters.h
 579 +++ b/drivers/media/platform/bcm2835/mmal-parameters.h
 580 @@ -182,6 +182,14 @@ enum mmal_parameter_camera_config_timest
 581                                               */
 582  };
 583
 584 +struct mmal_parameter_fps_range {
 585 +       /**< Low end of the permitted framerate range */
 586 +       struct mmal_parameter_rational  fps_low;
 587 +       /**< High end of the permitted framerate range */
 588 +       struct mmal_parameter_rational  fps_high;
 589 +};
 590 +
 591 +
 592  /* camera configuration parameter */
 593  struct mmal_parameter_camera_config {
 594         /* Parameters for setting up the image pools */
 595 @@ -293,6 +301,85 @@ enum mmal_parameter_rate_control_mode {
 596         MMAL_VIDEO_RATECONTROL_CONSTANT_SKIP_FRAMES
 597  };
 598
 599 +enum mmal_video_profile {
 600 +       MMAL_VIDEO_PROFILE_H263_BASELINE,
 601 +       MMAL_VIDEO_PROFILE_H263_H320CODING,
 602 +       MMAL_VIDEO_PROFILE_H263_BACKWARDCOMPATIBLE,
 603 +       MMAL_VIDEO_PROFILE_H263_ISWV2,
 604 +       MMAL_VIDEO_PROFILE_H263_ISWV3,
 605 +       MMAL_VIDEO_PROFILE_H263_HIGHCOMPRESSION,
 606 +       MMAL_VIDEO_PROFILE_H263_INTERNET,
 607 +       MMAL_VIDEO_PROFILE_H263_INTERLACE,
 608 +       MMAL_VIDEO_PROFILE_H263_HIGHLATENCY,
 609 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLE,
 610 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLESCALABLE,
 611 +       MMAL_VIDEO_PROFILE_MP4V_CORE,
 612 +       MMAL_VIDEO_PROFILE_MP4V_MAIN,
 613 +       MMAL_VIDEO_PROFILE_MP4V_NBIT,
 614 +       MMAL_VIDEO_PROFILE_MP4V_SCALABLETEXTURE,
 615 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLEFACE,
 616 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLEFBA,
 617 +       MMAL_VIDEO_PROFILE_MP4V_BASICANIMATED,
 618 +       MMAL_VIDEO_PROFILE_MP4V_HYBRID,
 619 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDREALTIME,
 620 +       MMAL_VIDEO_PROFILE_MP4V_CORESCALABLE,
 621 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCODING,
 622 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCORE,
 623 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSCALABLE,
 624 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSIMPLE,
 625 +       MMAL_VIDEO_PROFILE_H264_BASELINE,
 626 +       MMAL_VIDEO_PROFILE_H264_MAIN,
 627 +       MMAL_VIDEO_PROFILE_H264_EXTENDED,
 628 +       MMAL_VIDEO_PROFILE_H264_HIGH,
 629 +       MMAL_VIDEO_PROFILE_H264_HIGH10,
 630 +       MMAL_VIDEO_PROFILE_H264_HIGH422,
 631 +       MMAL_VIDEO_PROFILE_H264_HIGH444,
 632 +       MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE,
 633 +       MMAL_VIDEO_PROFILE_DUMMY = 0x7FFFFFFF
 634 +};
 635 +
 636 +enum mmal_video_level {
 637 +       MMAL_VIDEO_LEVEL_H263_10,
 638 +       MMAL_VIDEO_LEVEL_H263_20,
 639 +       MMAL_VIDEO_LEVEL_H263_30,
 640 +       MMAL_VIDEO_LEVEL_H263_40,
 641 +       MMAL_VIDEO_LEVEL_H263_45,
 642 +       MMAL_VIDEO_LEVEL_H263_50,
 643 +       MMAL_VIDEO_LEVEL_H263_60,
 644 +       MMAL_VIDEO_LEVEL_H263_70,
 645 +       MMAL_VIDEO_LEVEL_MP4V_0,
 646 +       MMAL_VIDEO_LEVEL_MP4V_0b,
 647 +       MMAL_VIDEO_LEVEL_MP4V_1,
 648 +       MMAL_VIDEO_LEVEL_MP4V_2,
 649 +       MMAL_VIDEO_LEVEL_MP4V_3,
 650 +       MMAL_VIDEO_LEVEL_MP4V_4,
 651 +       MMAL_VIDEO_LEVEL_MP4V_4a,
 652 +       MMAL_VIDEO_LEVEL_MP4V_5,
 653 +       MMAL_VIDEO_LEVEL_MP4V_6,
 654 +       MMAL_VIDEO_LEVEL_H264_1,
 655 +       MMAL_VIDEO_LEVEL_H264_1b,
 656 +       MMAL_VIDEO_LEVEL_H264_11,
 657 +       MMAL_VIDEO_LEVEL_H264_12,
 658 +       MMAL_VIDEO_LEVEL_H264_13,
 659 +       MMAL_VIDEO_LEVEL_H264_2,
 660 +       MMAL_VIDEO_LEVEL_H264_21,
 661 +       MMAL_VIDEO_LEVEL_H264_22,
 662 +       MMAL_VIDEO_LEVEL_H264_3,
 663 +       MMAL_VIDEO_LEVEL_H264_31,
 664 +       MMAL_VIDEO_LEVEL_H264_32,
 665 +       MMAL_VIDEO_LEVEL_H264_4,
 666 +       MMAL_VIDEO_LEVEL_H264_41,
 667 +       MMAL_VIDEO_LEVEL_H264_42,
 668 +       MMAL_VIDEO_LEVEL_H264_5,
 669 +       MMAL_VIDEO_LEVEL_H264_51,
 670 +       MMAL_VIDEO_LEVEL_DUMMY = 0x7FFFFFFF
 671 +};
 672 +
 673 +struct mmal_parameter_video_profile {
 674 +       enum mmal_video_profile profile;
 675 +       enum mmal_video_level level;
 676 +};
 677 +
 678  /* video parameters */
 679
 680  enum mmal_parameter_video_type {