target/linux/brcm2708/patches-3.18/0028-V4L2-Fixes-from-6by9.patch

   1 From c8fb291144efa1ab7f0628119894a1e72f08bce4 Mon Sep 17 00:00:00 2001
   2 From: Dave Stevenson <dsteve@broadcom.com>
   3 Date: Mon, 9 Dec 2013 10:58:01 +0000
   4 Subject: [PATCH 028/114] V4L2: Fixes from 6by9
   5
   6 V4L2: Fix EV values. Add manual shutter speed control
   7
   8 V4L2 EV values should be in units of 1/1000. Corrected.
   9 Add support for V4L2_CID_EXPOSURE_ABSOLUTE which should
  10 give manual shutter control. Requires manual exposure mode
  11 to be selected first.
  12
  13 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  14
  15 V4L2: Correct JPEG Q-factor range
  16
  17 Should be 1-100, not 0-100
  18
  19 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  20
  21 V4L2: Fix issue of driver jamming if STREAMON failed.
  22
  23 Fix issue where the driver was left in a partially enabled
  24 state if STREAMON failed, and would then reject many IOCTLs
  25 as it thought it was streaming.
  26
  27 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  28
  29 V4L2: Fix ISO controls.
  30
  31 Driver was passing the index to the GPU, and not the desired
  32 ISO value.
  33
  34 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  35
  36 V4L2: Add flicker avoidance controls
  37
  38 Add support for V4L2_CID_POWER_LINE_FREQUENCY to set flicker
  39 avoidance frequencies.
  40
  41 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  42
  43 V4L2: Add support for frame rate control.
  44
  45 Add support for frame rate (or time per frame as V4L2
  46 inverts it) control via s_parm.
  47
  48 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  49
  50 V4L2: Improve G_FBUF handling so we pass conformance
  51
  52 Return some sane numbers for get framebuffer so that
  53 we pass conformance.
  54
  55 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  56
  57 V4L2: Fix information advertised through g_vidfmt
  58
  59 Width and height were being stored based on incorrect
  60 values.
  61
  62 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  63
  64 V4L2: Add support for inline H264 headers
  65
  66 Add support for V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER
  67 to control H264 inline headers.
  68 Requires firmware fix to work correctly, otherwise format
  69 has to be set to H264 before this parameter is set.
  70
  71 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  72
  73 V4L2: Fix JPEG timestamp issue
  74
  75 JPEG images were coming through from the GPU with timestamp
  76 of 0. Detect this and give current system time instead
  77 of some invalid value.
  78
  79 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  80
  81 V4L2: Fix issue when switching down JPEG resolution.
  82
  83 JPEG buffer size calculation is based on input resolution.
  84 Input resolution was being configured after output port
  85 format. Caused failures if switching from one JPEG resolution
  86 to a smaller one.
  87
  88 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  89
  90 V4L2: Enable MJPEG encoding
  91
  92 Requires GPU firmware update to support MJPEG encoder.
  93
  94 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
  95
  96 V4L2: Correct flag settings for compressed formats
  97
  98 Set flags field correctly on enum_fmt_vid_cap for compressed
  99 image formats.
 100
 101 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 102
 103 V4L2: H264 profile & level ctrls, FPS control and auto exp pri
 104
 105 Several control handling updates.
 106 H264 profile and level controls.
 107 Timeperframe/FPS reworked to add V4L2_CID_EXPOSURE_AUTO_PRIORITY to
 108 select whether AE is allowed to override the framerate specified.
 109
 110 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 111
 112 V4L2: Correct BGR24 to RGB24 in format table
 113
 114 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 115
 116 V4L2: Add additional pixel formats. Correct colourspace
 117
 118 Adds the other flavours of YUYV, and NV12.
 119 Corrects the overlay advertised colourspace.
 120
 121 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 122
 123 V4L2: Drop logging msg from info to debug
 124
 125 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 126
 127 V4L2: Initial pass at scene modes.
 128
 129 Only supports exposure mode and metering modes.
 130
 131 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 132
 133 V4L2: Add manual white balance control.
 134
 135 Adds support for V4L2_CID_RED_BALANCE and
 136 V4L2_CID_BLUE_BALANCE. Only has an effect if
 137 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE has
 138 V4L2_WHITE_BALANCE_MANUAL selected.
 139
 140 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 141
 142 config: Enable V4L / MMAL driver
 143
 144 V4L2: Increase the MMAL timeout to 3sec
 145
 146 MJPEG codec flush is now taking longer and results
 147 in a kernel panic if the driver has stopped waiting for
 148 the result when it finally completes.
 149 Increase the timeout value from 1 to 3secs.
 150
 151 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 152
 153 V4L2: Add support for setting H264_I_PERIOD
 154
 155 Adds support for the parameter V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
 156 to set the frequency with which I frames are produced.
 157
 158 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 159
 160 V4L2: Enable GPU function for removing padding from images.
 161
 162 GPU can now support arbitrary strides, although may require
 163 additional processing to achieve it. Enable this feature
 164 so that the images delivered are the size requested.
 165
 166 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 167
 168 V4L2: Add support for V4L2_PIX_FMT_BGR32
 169
 170 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 171
 172 V4L2: Set the colourspace to avoid odd YUV-RGB conversions
 173
 174 Removes the amiguity from the conversion routines and stops
 175 them dropping back to the SD vs HD choice of coeffs.
 176
 177 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 178
 179 V4L2: Make video/still threshold a run-time param
 180
 181 Move the define for at what resolution the driver
 182 switches from a video mode capture to a stills mode
 183 capture to module parameters.
 184
 185 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 186
 187 V4L2: Fix incorrect pool sizing
 188
 189 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 190
 191 V4L2: Add option to disable enum_framesizes.
 192
 193 Gstreamer's handling of a driver that advertises
 194 V4L2_FRMSIZE_TYPE_STEPWISE to define the supported
 195 resolutions is broken. See bug
 196 https://bugzilla.gnome.org/show_bug.cgi?id=726521
 197
 198 Optional parameter of gst_v4l2src_is_broken added.
 199 If non-zero, the driver claims not to support that
 200 ioctl, and gstreamer should be happy again (it
 201 guesses a set of defaults for itself).
 202
 203 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 204
 205 V4L2: Add support for more image formats
 206
 207 Adds YVU420 (YV12), YVU420SP (NV21), and BGR888.
 208
 209 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 210
 211 V4L2: Extend range for V4L2_CID_MPEG_VIDEO_H264_I_PERIOD
 212
 213 Request to extend the range from the fairly arbitrary
 214 1000 frames (33 seconds at 30fps). Extend out to the
 215 max range supported (int32 value).
 216 Also allow 0, which is handled by the codec as only
 217 send an I-frame on the first frame and never again.
 218 There may be an exception if it detects a significant
 219 scene change, but there's no easy way around that.
 220
 221 Signed-off-by: Dave Stevenson <dsteve@broadcom.com>
 222
 223 bcm2835-camera: stop_streaming now has a void return
 224 ---
 225  arch/arm/configs/bcmrpi_defconfig                |   3 +
 226  drivers/media/platform/bcm2835/bcm2835-camera.c  | 578 ++++++++++++++----
 227  drivers/media/platform/bcm2835/bcm2835-camera.h  |  23 +-
 228  drivers/media/platform/bcm2835/controls.c        | 723 +++++++++++++++++++++--
 229  drivers/media/platform/bcm2835/mmal-common.h     |   1 +
 230  drivers/media/platform/bcm2835/mmal-encodings.h  |  34 ++
 231  drivers/media/platform/bcm2835/mmal-parameters.h | 121 +++-
 232  drivers/media/platform/bcm2835/mmal-vchiq.c      |   4 +-
 233  8 files changed, 1300 insertions(+), 187 deletions(-)
 234
 235 diff --git a/arch/arm/configs/bcmrpi_defconfig b/arch/arm/configs/bcmrpi_defconfig
 236 index 897616c..3f99687 100644
 237 --- a/arch/arm/configs/bcmrpi_defconfig
 238 +++ b/arch/arm/configs/bcmrpi_defconfig
 239 @@ -708,6 +708,9 @@ CONFIG_DVB_AS102=m
 240  CONFIG_VIDEO_EM28XX=m
 241  CONFIG_VIDEO_EM28XX_ALSA=m
 242  CONFIG_VIDEO_EM28XX_DVB=m
 243 +CONFIG_V4L_PLATFORM_DRIVERS=y
 244 +CONFIG_VIDEO_BCM2835=y
 245 +CONFIG_VIDEO_BCM2835_MMAL=m
 246  CONFIG_RADIO_SI470X=y
 247  CONFIG_USB_SI470X=m
 248  CONFIG_I2C_SI470X=m
 249 diff --git a/drivers/media/platform/bcm2835/bcm2835-camera.c b/drivers/media/platform/bcm2835/bcm2835-camera.c
 250 index 1c9d9d5..e5a0010 100644
 251 --- a/drivers/media/platform/bcm2835/bcm2835-camera.c
 252 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.c
 253 @@ -36,7 +36,8 @@
 254
 255  #define BM2835_MMAL_VERSION "0.0.2"
 256  #define BM2835_MMAL_MODULE_NAME "bcm2835-v4l2"
 257 -
 258 +#define MIN_WIDTH 16
 259 +#define MIN_HEIGHT 16
 260  #define MAX_WIDTH 2592
 261  #define MAX_HEIGHT 1944
 262  #define MIN_BUFFER_SIZE (80*1024)
 263 @@ -53,13 +54,43 @@ int bcm2835_v4l2_debug;
 264  module_param_named(debug, bcm2835_v4l2_debug, int, 0644);
 265  MODULE_PARM_DESC(bcm2835_v4l2_debug, "Debug level 0-2");
 266
 267 +int max_video_width = MAX_VIDEO_MODE_WIDTH;
 268 +int max_video_height = MAX_VIDEO_MODE_HEIGHT;
 269 +module_param(max_video_width, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 270 +MODULE_PARM_DESC(max_video_width, "Threshold for video mode");
 271 +module_param(max_video_height, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 272 +MODULE_PARM_DESC(max_video_height, "Threshold for video mode");
 273 +
 274 +/* Gstreamer bug https://bugzilla.gnome.org/show_bug.cgi?id=726521
 275 + * v4l2src does bad (and actually wrong) things when the vidioc_enum_framesizes
 276 + * function says type V4L2_FRMSIZE_TYPE_STEPWISE, which we do by default.
 277 + * It's happier if we just don't say anything at all, when it then
 278 + * sets up a load of defaults that it thinks might work.
 279 + * If gst_v4l2src_is_broken is non-zero, then we remove the function from
 280 + * our function table list (actually switch to an alternate set, but same
 281 + * result).
 282 + */
 283 +int gst_v4l2src_is_broken = 0;
 284 +module_param(gst_v4l2src_is_broken, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 285 +MODULE_PARM_DESC(gst_v4l2src_is_broken, "If non-zero, enable workaround for Gstreamer");
 286 +
 287  static struct bm2835_mmal_dev *gdev;   /* global device data */
 288
 289 +#define FPS_MIN 1
 290 +#define FPS_MAX 90
 291 +
 292 +/* timeperframe: min/max and default */
 293 +static const struct v4l2_fract
 294 +       tpf_min     = {.numerator = 1,          .denominator = FPS_MAX},
 295 +       tpf_max     = {.numerator = 1,          .denominator = FPS_MIN},
 296 +       tpf_default = {.numerator = 1000,       .denominator = 30000};
 297 +
 298  /* video formats */
 299  static struct mmal_fmt formats[] = {
 300         {
 301          .name = "4:2:0, packed YUV",
 302          .fourcc = V4L2_PIX_FMT_YUV420,
 303 +        .flags = 0,
 304          .mmal = MMAL_ENCODING_I420,
 305          .depth = 12,
 306          .mmal_component = MMAL_COMPONENT_CAMERA,
 307 @@ -67,13 +98,15 @@ static struct mmal_fmt formats[] = {
 308         {
 309          .name = "4:2:2, packed, YUYV",
 310          .fourcc = V4L2_PIX_FMT_YUYV,
 311 +        .flags = 0,
 312          .mmal = MMAL_ENCODING_YUYV,
 313          .depth = 16,
 314          .mmal_component = MMAL_COMPONENT_CAMERA,
 315          },
 316         {
 317 -        .name = "RGB24 (BE)",
 318 -        .fourcc = V4L2_PIX_FMT_BGR24,
 319 +        .name = "RGB24 (LE)",
 320 +        .fourcc = V4L2_PIX_FMT_RGB24,
 321 +        .flags = 0,
 322          .mmal = MMAL_ENCODING_BGR24,
 323          .depth = 24,
 324          .mmal_component = MMAL_COMPONENT_CAMERA,
 325 @@ -81,6 +114,7 @@ static struct mmal_fmt formats[] = {
 326         {
 327          .name = "JPEG",
 328          .fourcc = V4L2_PIX_FMT_JPEG,
 329 +        .flags = V4L2_FMT_FLAG_COMPRESSED,
 330          .mmal = MMAL_ENCODING_JPEG,
 331          .depth = 8,
 332          .mmal_component = MMAL_COMPONENT_IMAGE_ENCODE,
 333 @@ -88,10 +122,83 @@ static struct mmal_fmt formats[] = {
 334         {
 335          .name = "H264",
 336          .fourcc = V4L2_PIX_FMT_H264,
 337 +        .flags = V4L2_FMT_FLAG_COMPRESSED,
 338          .mmal = MMAL_ENCODING_H264,
 339          .depth = 8,
 340          .mmal_component = MMAL_COMPONENT_VIDEO_ENCODE,
 341 -        }
 342 +        },
 343 +       {
 344 +        .name = "MJPEG",
 345 +        .fourcc = V4L2_PIX_FMT_MJPEG,
 346 +        .flags = V4L2_FMT_FLAG_COMPRESSED,
 347 +        .mmal = MMAL_ENCODING_MJPEG,
 348 +        .depth = 8,
 349 +        .mmal_component = MMAL_COMPONENT_VIDEO_ENCODE,
 350 +        },
 351 +       {
 352 +        .name = "4:2:2, packed, YVYU",
 353 +        .fourcc = V4L2_PIX_FMT_YVYU,
 354 +        .flags = 0,
 355 +        .mmal = MMAL_ENCODING_YVYU,
 356 +        .depth = 16,
 357 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 358 +        },
 359 +       {
 360 +        .name = "4:2:2, packed, VYUY",
 361 +        .fourcc = V4L2_PIX_FMT_VYUY,
 362 +        .flags = 0,
 363 +        .mmal = MMAL_ENCODING_VYUY,
 364 +        .depth = 16,
 365 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 366 +        },
 367 +       {
 368 +        .name = "4:2:2, packed, UYVY",
 369 +        .fourcc = V4L2_PIX_FMT_UYVY,
 370 +        .flags = 0,
 371 +        .mmal = MMAL_ENCODING_UYVY,
 372 +        .depth = 16,
 373 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 374 +        },
 375 +       {
 376 +        .name = "4:2:0, packed, NV12",
 377 +        .fourcc = V4L2_PIX_FMT_NV12,
 378 +        .flags = 0,
 379 +        .mmal = MMAL_ENCODING_NV12,
 380 +        .depth = 12,
 381 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 382 +        },
 383 +       {
 384 +        .name = "RGB24 (BE)",
 385 +        .fourcc = V4L2_PIX_FMT_BGR24,
 386 +        .flags = 0,
 387 +        .mmal = MMAL_ENCODING_RGB24,
 388 +        .depth = 24,
 389 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 390 +        },
 391 +       {
 392 +        .name = "4:2:0, packed YVU",
 393 +        .fourcc = V4L2_PIX_FMT_YVU420,
 394 +        .flags = 0,
 395 +        .mmal = MMAL_ENCODING_YV12,
 396 +        .depth = 12,
 397 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 398 +        },
 399 +       {
 400 +        .name = "4:2:0, packed, NV21",
 401 +        .fourcc = V4L2_PIX_FMT_NV21,
 402 +        .flags = 0,
 403 +        .mmal = MMAL_ENCODING_NV21,
 404 +        .depth = 12,
 405 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 406 +        },
 407 +       {
 408 +        .name = "RGB32 (BE)",
 409 +        .fourcc = V4L2_PIX_FMT_BGR32,
 410 +        .flags = 0,
 411 +        .mmal = MMAL_ENCODING_BGRA,
 412 +        .depth = 32,
 413 +        .mmal_component = MMAL_COMPONENT_CAMERA,
 414 +        },
 415  };
 416
 417  static struct mmal_fmt *get_format(struct v4l2_format *f)
 418 @@ -229,7 +336,8 @@ static void buffer_cb(struct vchiq_mmal_instance *instance,
 419                 }
 420         } else {
 421                 if (dev->capture.frame_count) {
 422 -                       if (dev->capture.vc_start_timestamp != -1) {
 423 +                       if (dev->capture.vc_start_timestamp != -1 &&
 424 +                           pts != 0) {
 425                                 s64 runtime_us = pts -
 426                                     dev->capture.vc_start_timestamp;
 427                                 u32 div = 0;
 428 @@ -250,7 +358,7 @@ static void buffer_cb(struct vchiq_mmal_instance *instance,
 429                                             USEC_PER_SEC;
 430                                 }
 431                                 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 432 -                                        "Convert start time %d.%06d and %llu"
 433 +                                        "Convert start time %d.%06d and %llu "
 434                                          "with offset %llu to %d.%06d\n",
 435                                          (int)dev->capture.kernel_start_ts.
 436                                          tv_sec,
 437 @@ -425,7 +533,15 @@ static int start_streaming(struct vb2_queue *vq, unsigned int count)
 438             vchiq_mmal_port_enable(dev->instance, dev->capture.port, buffer_cb);
 439         if (ret) {
 440                 v4l2_err(&dev->v4l2_dev,
 441 -                        "Failed to enable capture port - error %d\n", ret);
 442 +                       "Failed to enable capture port - error %d. "
 443 +                       "Disabling camera port again\n", ret);
 444 +
 445 +               vchiq_mmal_port_disable(dev->instance,
 446 +                                       dev->capture.camera_port);
 447 +               if (disable_camera(dev) < 0) {
 448 +                       v4l2_err(&dev->v4l2_dev, "Failed to disable camera\n");
 449 +                       return -EINVAL;
 450 +               }
 451                 return -1;
 452         }
 453
 454 @@ -439,7 +555,7 @@ static int start_streaming(struct vb2_queue *vq, unsigned int count)
 455  }
 456
 457  /* abort streaming and wait for last buffer */
 458 -static int stop_streaming(struct vb2_queue *vq)
 459 +static void stop_streaming(struct vb2_queue *vq)
 460  {
 461         int ret;
 462         struct bm2835_mmal_dev *dev = vb2_get_drv_priv(vq);
 463 @@ -451,8 +567,11 @@ static int stop_streaming(struct vb2_queue *vq)
 464         dev->capture.frame_count = 0;
 465
 466         /* ensure a format has actually been set */
 467 -       if (dev->capture.port == NULL)
 468 -               return -EINVAL;
 469 +       if (dev->capture.port == NULL) {
 470 +               v4l2_err(&dev->v4l2_dev,
 471 +                        "no capture port - stream not started?\n");
 472 +               return;
 473 +       }
 474
 475         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev, "stopping capturing\n");
 476
 477 @@ -483,12 +602,8 @@ static int stop_streaming(struct vb2_queue *vq)
 478                          ret);
 479         }
 480
 481 -       if (disable_camera(dev) < 0) {
 482 -               v4l2_err(&dev->v4l2_dev, "Failed to disable camera");
 483 -               return -EINVAL;
 484 -       }
 485 -
 486 -       return ret;
 487 +       if (disable_camera(dev) < 0)
 488 +               v4l2_err(&dev->v4l2_dev, "Failed to disable camera\n");
 489  }
 490
 491  static void bm2835_mmal_lock(struct vb2_queue *vq)
 492 @@ -530,6 +645,7 @@ static int vidioc_enum_fmt_vid_overlay(struct file *file, void *priv,
 493
 494         strlcpy(f->description, fmt->name, sizeof(f->description));
 495         f->pixelformat = fmt->fourcc;
 496 +       f->flags = fmt->flags;
 497
 498         return 0;
 499  }
 500 @@ -647,10 +763,18 @@ static int vidioc_g_fbuf(struct file *file, void *fh,
 501  {
 502         /* The video overlay must stay within the framebuffer and can't be
 503            positioned independently. */
 504 +       struct bm2835_mmal_dev *dev = video_drvdata(file);
 505 +       struct vchiq_mmal_port *preview_port =
 506 +                   &dev->component[MMAL_COMPONENT_CAMERA]->
 507 +                   output[MMAL_CAMERA_PORT_PREVIEW];
 508         a->flags = V4L2_FBUF_FLAG_OVERLAY;
 509 -
 510 -       /* todo: v4l2_framebuffer still needs more info filling in
 511 -        *       in order to pass the v4l2-compliance test. */
 512 +       a->fmt.width = preview_port->es.video.width;
 513 +       a->fmt.height = preview_port->es.video.height;
 514 +       a->fmt.pixelformat = V4L2_PIX_FMT_YUV420;
 515 +       a->fmt.bytesperline = (preview_port->es.video.width * 3)>>1;
 516 +       a->fmt.sizeimage = (preview_port->es.video.width *
 517 +                              preview_port->es.video.height * 3)>>1;
 518 +       a->fmt.colorspace = V4L2_COLORSPACE_JPEG;
 519
 520         return 0;
 521  }
 522 @@ -717,6 +841,8 @@ static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
 523
 524         strlcpy(f->description, fmt->name, sizeof(f->description));
 525         f->pixelformat = fmt->fourcc;
 526 +       f->flags = fmt->flags;
 527 +
 528         return 0;
 529  }
 530
 531 @@ -729,20 +855,13 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 532         f->fmt.pix.height = dev->capture.height;
 533         f->fmt.pix.field = V4L2_FIELD_NONE;
 534         f->fmt.pix.pixelformat = dev->capture.fmt->fourcc;
 535 -       f->fmt.pix.bytesperline =
 536 -           (f->fmt.pix.width * dev->capture.fmt->depth) >> 3;
 537 -       f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 538 -       if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_JPEG
 539 -           && f->fmt.pix.sizeimage < (100 << 10)) {
 540 -               /* Need a minimum size for JPEG to account for EXIF. */
 541 -               f->fmt.pix.sizeimage = (100 << 10);
 542 -       }
 543 +       f->fmt.pix.bytesperline = dev->capture.stride;
 544 +       f->fmt.pix.sizeimage = dev->capture.buffersize;
 545
 546 -       if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_YUYV ||
 547 -           dev->capture.fmt->fourcc == V4L2_PIX_FMT_UYVY)
 548 -               f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 549 -       else
 550 +       if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_RGB24)
 551                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 552 +       else
 553 +               f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 554         f->fmt.pix.priv = 0;
 555
 556         v4l2_dump_pix_format(1, bcm2835_v4l2_debug, &dev->v4l2_dev, &f->fmt.pix,
 557 @@ -766,21 +885,35 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 558         }
 559
 560         f->fmt.pix.field = V4L2_FIELD_NONE;
 561 -       /* image must be a multiple of 32 pixels wide and 16 lines high */
 562 -       v4l_bound_align_image(&f->fmt.pix.width, 48, MAX_WIDTH, 5,
 563 -                             &f->fmt.pix.height, 32, MAX_HEIGHT, 4, 0);
 564 -       f->fmt.pix.bytesperline = (f->fmt.pix.width * mfmt->depth) >> 3;
 565 -       f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 566 -       if (f->fmt.pix.sizeimage < MIN_BUFFER_SIZE)
 567 +
 568 +       v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 569 +               "Clipping/aligning %dx%d format %08X\n",
 570 +               f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat);
 571 +
 572 +       v4l_bound_align_image(&f->fmt.pix.width, MIN_WIDTH, MAX_WIDTH, 1,
 573 +                             &f->fmt.pix.height, MIN_HEIGHT, MAX_HEIGHT, 1, 0);
 574 +       f->fmt.pix.bytesperline = (f->fmt.pix.width * mfmt->depth)>>3;
 575 +
 576 +       /* Image buffer has to be padded to allow for alignment, even though
 577 +        * we then remove that padding before delivering the buffer.
 578 +        */
 579 +       f->fmt.pix.sizeimage = ((f->fmt.pix.height+15)&~15) *
 580 +                       (((f->fmt.pix.width+31)&~31) * mfmt->depth) >> 3;
 581 +
 582 +       if ((mfmt->flags & V4L2_FMT_FLAG_COMPRESSED) &&
 583 +           f->fmt.pix.sizeimage < MIN_BUFFER_SIZE)
 584                 f->fmt.pix.sizeimage = MIN_BUFFER_SIZE;
 585
 586 -       if (mfmt->fourcc == V4L2_PIX_FMT_YUYV ||
 587 -           mfmt->fourcc == V4L2_PIX_FMT_UYVY)
 588 -               f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 589 -       else
 590 +       if (dev->capture.fmt->fourcc == V4L2_PIX_FMT_RGB24)
 591                 f->fmt.pix.colorspace = V4L2_COLORSPACE_SRGB;
 592 +       else
 593 +               f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
 594         f->fmt.pix.priv = 0;
 595
 596 +       v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 597 +               "Now %dx%d format %08X\n",
 598 +               f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.pixelformat);
 599 +
 600         v4l2_dump_pix_format(1, bcm2835_v4l2_debug, &dev->v4l2_dev, &f->fmt.pix,
 601                              __func__);
 602         return 0;
 603 @@ -818,8 +951,8 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 604         switch (mfmt->mmal_component) {
 605         case MMAL_COMPONENT_CAMERA:
 606                 /* Make a further decision on port based on resolution */
 607 -               if (f->fmt.pix.width <= MAX_VIDEO_MODE_WIDTH
 608 -                   && f->fmt.pix.height <= MAX_VIDEO_MODE_HEIGHT)
 609 +               if (f->fmt.pix.width <= max_video_width
 610 +                   && f->fmt.pix.height <= max_video_height)
 611                         camera_port = port =
 612                             &dev->component[MMAL_COMPONENT_CAMERA]->
 613                             output[MMAL_CAMERA_PORT_VIDEO];
 614 @@ -861,8 +994,9 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 615         camera_port->es.video.crop.y = 0;
 616         camera_port->es.video.crop.width = f->fmt.pix.width;
 617         camera_port->es.video.crop.height = f->fmt.pix.height;
 618 -       camera_port->es.video.frame_rate.num = 30;
 619 +       camera_port->es.video.frame_rate.num = 0;
 620         camera_port->es.video.frame_rate.den = 1;
 621 +       camera_port->es.video.color_space = MMAL_COLOR_SPACE_JPEG_JFIF;
 622
 623         ret = vchiq_mmal_port_set_format(dev->instance, camera_port);
 624
 625 @@ -896,8 +1030,10 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 626                 preview_port->es.video.crop.y = 0;
 627                 preview_port->es.video.crop.width = f->fmt.pix.width;
 628                 preview_port->es.video.crop.height = f->fmt.pix.height;
 629 -               preview_port->es.video.frame_rate.num = 30;
 630 -               preview_port->es.video.frame_rate.den = 1;
 631 +               preview_port->es.video.frame_rate.num =
 632 +                                         dev->capture.timeperframe.denominator;
 633 +               preview_port->es.video.frame_rate.den =
 634 +                                         dev->capture.timeperframe.numerator;
 635                 ret = vchiq_mmal_port_set_format(dev->instance, preview_port);
 636                 if (overlay_enabled) {
 637                         ret = vchiq_mmal_port_connect_tunnel(
 638 @@ -913,7 +1049,9 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 639
 640         if (ret) {
 641                 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 642 -                        "%s failed to set format\n", __func__);
 643 +                        "%s failed to set format %dx%d %08X\n", __func__,
 644 +                        f->fmt.pix.width, f->fmt.pix.height,
 645 +                        f->fmt.pix.pixelformat);
 646                 /* ensure capture is not going to be tried */
 647                 dev->capture.port = NULL;
 648         } else {
 649 @@ -927,69 +1065,91 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 650                         camera_port->current_buffer.num =
 651                             camera_port->recommended_buffer.num;
 652
 653 -                       port->format.encoding = mfmt->mmal;
 654 -                       port->format.encoding_variant = 0;
 655 -                       /* Set any encoding specific parameters */
 656 -                       switch (mfmt->mmal_component) {
 657 -                       case MMAL_COMPONENT_VIDEO_ENCODE:
 658 -                               port->format.bitrate =
 659 -                                   dev->capture.encode_bitrate;
 660 -                               break;
 661 -                       case MMAL_COMPONENT_IMAGE_ENCODE:
 662 -                               /* Could set EXIF parameters here */
 663 -                               break;
 664 -                       default:
 665 -                               break;
 666 -                       }
 667 -                       ret = vchiq_mmal_port_set_format(dev->instance, port);
 668 -
 669 +                       ret =
 670 +                           vchiq_mmal_port_connect_tunnel(
 671 +                                       dev->instance,
 672 +                                       camera_port,
 673 +                                       &encode_component->input[0]);
 674                         if (ret) {
 675 -                               v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 676 -                                        "%s failed to set format\n", __func__);
 677 +                               v4l2_dbg(1, bcm2835_v4l2_debug,
 678 +                                        &dev->v4l2_dev,
 679 +                                        "%s failed to create connection\n",
 680 +                                        __func__);
 681 +                               /* ensure capture is not going to be tried */
 682 +                               dev->capture.port = NULL;
 683                         } else {
 684 +                               port->es.video.width = f->fmt.pix.width;
 685 +                               port->es.video.height = f->fmt.pix.height;
 686 +                               port->es.video.crop.x = 0;
 687 +                               port->es.video.crop.y = 0;
 688 +                               port->es.video.crop.width = f->fmt.pix.width;
 689 +                               port->es.video.crop.height = f->fmt.pix.height;
 690 +                               port->es.video.frame_rate.num =
 691 +                                         dev->capture.timeperframe.denominator;
 692 +                               port->es.video.frame_rate.den =
 693 +                                         dev->capture.timeperframe.numerator;
 694 +
 695 +                               port->format.encoding = mfmt->mmal;
 696 +                               port->format.encoding_variant = 0;
 697 +                               /* Set any encoding specific parameters */
 698 +                               switch (mfmt->mmal_component) {
 699 +                               case MMAL_COMPONENT_VIDEO_ENCODE:
 700 +                                       port->format.bitrate =
 701 +                                           dev->capture.encode_bitrate;
 702 +                                       break;
 703 +                               case MMAL_COMPONENT_IMAGE_ENCODE:
 704 +                                       /* Could set EXIF parameters here */
 705 +                                       break;
 706 +                               default:
 707 +                                       break;
 708 +                               }
 709 +                               ret = vchiq_mmal_port_set_format(dev->instance,
 710 +                                                                port);
 711 +                               if (ret)
 712 +                                       v4l2_dbg(1, bcm2835_v4l2_debug,
 713 +                                                &dev->v4l2_dev,
 714 +                                                "%s failed to set format %dx%d fmt %08X\n",
 715 +                                                __func__,
 716 +                                                f->fmt.pix.width,
 717 +                                                f->fmt.pix.height,
 718 +                                                f->fmt.pix.pixelformat
 719 +                                                );
 720 +                       }
 721 +
 722 +                       if (!ret) {
 723                                 ret = vchiq_mmal_component_enable(
 724                                                 dev->instance,
 725                                                 encode_component);
 726                                 if (ret) {
 727                                         v4l2_dbg(1, bcm2835_v4l2_debug,
 728 -                                                &dev->v4l2_dev,
 729 -                                                "%s Failed to enable encode components\n",
 730 -                                                __func__);
 731 -                               } else {
 732 -                                       /* configure buffering */
 733 -                                       port->current_buffer.num = 1;
 734 -                                       port->current_buffer.size =
 735 -                                           f->fmt.pix.sizeimage;
 736 -                                       if (port->format.encoding ==
 737 -                                           MMAL_ENCODING_JPEG) {
 738 -                                               v4l2_dbg(1, bcm2835_v4l2_debug,
 739 -                                                        &dev->v4l2_dev,
 740 -                                                        "JPEG - fiddle buffer size\n");
 741 -                                               port->current_buffer.size =
 742 -                                                   (f->fmt.pix.sizeimage <
 743 -                                                    (100 << 10))
 744 -                                                   ? (100 << 10) : f->fmt.pix.
 745 -                                                   sizeimage;
 746 -                                       }
 747 +                                          &dev->v4l2_dev,
 748 +                                          "%s Failed to enable encode components\n",
 749 +                                          __func__);
 750 +                               }
 751 +                       }
 752 +                       if (!ret) {
 753 +                               /* configure buffering */
 754 +                               port->current_buffer.num = 1;
 755 +                               port->current_buffer.size =
 756 +                                   f->fmt.pix.sizeimage;
 757 +                               if (port->format.encoding ==
 758 +                                   MMAL_ENCODING_JPEG) {
 759                                         v4l2_dbg(1, bcm2835_v4l2_debug,
 760 -                                                &dev->v4l2_dev,
 761 -                                                "vid_cap - current_buffer.size being set to %d\n",
 762 -                                                f->fmt.pix.sizeimage);
 763 -                                       port->current_buffer.alignment = 0;
 764 -                                       ret =
 765 -                                           vchiq_mmal_port_connect_tunnel(
 766 -                                                       dev->instance,
 767 -                                                       camera_port,
 768 -                                                       &encode_component->input[0]);
 769 -                                       if (ret) {
 770 -                                               v4l2_dbg(1, bcm2835_v4l2_debug,
 771 -                                                        &dev->v4l2_dev,
 772 -                                                        "%s failed to create connection\n",
 773 -                                                        __func__);
 774 -                                               /* ensure capture is not going to be tried */
 775 -                                               dev->capture.port = NULL;
 776 -                                       }
 777 +                                           &dev->v4l2_dev,
 778 +                                           "JPG - buf size now %d was %d\n",
 779 +                                           f->fmt.pix.sizeimage,
 780 +                                           port->current_buffer.size);
 781 +                                       port->current_buffer.size =
 782 +                                           (f->fmt.pix.sizeimage <
 783 +                                            (100 << 10))
 784 +                                           ? (100 << 10) : f->fmt.pix.
 785 +                                           sizeimage;
 786                                 }
 787 +                               v4l2_dbg(1, bcm2835_v4l2_debug,
 788 +                                        &dev->v4l2_dev,
 789 +                                        "vid_cap - cur_buf.size set to %d\n",
 790 +                                        f->fmt.pix.sizeimage);
 791 +                               port->current_buffer.alignment = 0;
 792                         }
 793                 } else {
 794                         /* configure buffering */
 795 @@ -1001,13 +1161,20 @@ static int mmal_setup_components(struct bm2835_mmal_dev *dev,
 796                 if (!ret) {
 797                         dev->capture.fmt = mfmt;
 798                         dev->capture.stride = f->fmt.pix.bytesperline;
 799 -                       dev->capture.width = port->es.video.crop.width;
 800 -                       dev->capture.height = port->es.video.crop.height;
 801 +                       dev->capture.width = camera_port->es.video.crop.width;
 802 +                       dev->capture.height = camera_port->es.video.crop.height;
 803 +                       dev->capture.buffersize = port->current_buffer.size;
 804
 805                         /* select port for capture */
 806                         dev->capture.port = port;
 807                         dev->capture.camera_port = camera_port;
 808                         dev->capture.encode_component = encode_component;
 809 +                       v4l2_dbg(1, bcm2835_v4l2_debug,
 810 +                                &dev->v4l2_dev,
 811 +                               "Set dev->capture.fmt %08X, %dx%d, stride %d, size %d",
 812 +                               port->format.encoding,
 813 +                               dev->capture.width, dev->capture.height,
 814 +                               dev->capture.stride, dev->capture.buffersize);
 815                 }
 816         }
 817
 818 @@ -1048,14 +1215,115 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 819         }
 820
 821         ret = mmal_setup_components(dev, f);
 822 -       if (ret != 0)
 823 +       if (ret != 0) {
 824                 v4l2_err(&dev->v4l2_dev,
 825                          "%s: failed to setup mmal components: %d\n",
 826                          __func__, ret);
 827 +               ret = -EINVAL;
 828 +       }
 829
 830         return ret;
 831  }
 832
 833 +int vidioc_enum_framesizes(struct file *file, void *fh,
 834 +                          struct v4l2_frmsizeenum *fsize)
 835 +{
 836 +       static const struct v4l2_frmsize_stepwise sizes = {
 837 +               MIN_WIDTH, MAX_WIDTH, 2,
 838 +               MIN_HEIGHT, MAX_HEIGHT, 2
 839 +       };
 840 +       int i;
 841 +
 842 +       if (fsize->index)
 843 +               return -EINVAL;
 844 +       for (i = 0; i < ARRAY_SIZE(formats); i++)
 845 +               if (formats[i].fourcc == fsize->pixel_format)
 846 +                       break;
 847 +       if (i == ARRAY_SIZE(formats))
 848 +               return -EINVAL;
 849 +       fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
 850 +       fsize->stepwise = sizes;
 851 +       return 0;
 852 +}
 853 +
 854 +/* timeperframe is arbitrary and continous */
 855 +static int vidioc_enum_frameintervals(struct file *file, void *priv,
 856 +                                            struct v4l2_frmivalenum *fival)
 857 +{
 858 +       int i;
 859 +
 860 +       if (fival->index)
 861 +               return -EINVAL;
 862 +
 863 +       for (i = 0; i < ARRAY_SIZE(formats); i++)
 864 +               if (formats[i].fourcc == fival->pixel_format)
 865 +                       break;
 866 +       if (i == ARRAY_SIZE(formats))
 867 +               return -EINVAL;
 868 +
 869 +       /* regarding width & height - we support any within range */
 870 +       if (fival->width < MIN_WIDTH || fival->width > MAX_WIDTH ||
 871 +           fival->height < MIN_HEIGHT || fival->height > MAX_HEIGHT)
 872 +               return -EINVAL;
 873 +
 874 +       fival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
 875 +
 876 +       /* fill in stepwise (step=1.0 is requred by V4L2 spec) */
 877 +       fival->stepwise.min  = tpf_min;
 878 +       fival->stepwise.max  = tpf_max;
 879 +       fival->stepwise.step = (struct v4l2_fract) {1, 1};
 880 +
 881 +       return 0;
 882 +}
 883 +
 884 +static int vidioc_g_parm(struct file *file, void *priv,
 885 +                         struct v4l2_streamparm *parm)
 886 +{
 887 +       struct bm2835_mmal_dev *dev = video_drvdata(file);
 888 +
 889 +       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 890 +               return -EINVAL;
 891 +
 892 +       parm->parm.capture.capability   = V4L2_CAP_TIMEPERFRAME;
 893 +       parm->parm.capture.timeperframe = dev->capture.timeperframe;
 894 +       parm->parm.capture.readbuffers  = 1;
 895 +       return 0;
 896 +}
 897 +
 898 +#define FRACT_CMP(a, OP, b)    \
 899 +       ((u64)(a).numerator * (b).denominator  OP  \
 900 +        (u64)(b).numerator * (a).denominator)
 901 +
 902 +static int vidioc_s_parm(struct file *file, void *priv,
 903 +                         struct v4l2_streamparm *parm)
 904 +{
 905 +       struct bm2835_mmal_dev *dev = video_drvdata(file);
 906 +       struct v4l2_fract tpf;
 907 +       struct mmal_parameter_rational fps_param;
 908 +
 909 +       if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 910 +               return -EINVAL;
 911 +
 912 +       tpf = parm->parm.capture.timeperframe;
 913 +
 914 +       /* tpf: {*, 0} resets timing; clip to [min, max]*/
 915 +       tpf = tpf.denominator ? tpf : tpf_default;
 916 +       tpf = FRACT_CMP(tpf, <, tpf_min) ? tpf_min : tpf;
 917 +       tpf = FRACT_CMP(tpf, >, tpf_max) ? tpf_max : tpf;
 918 +
 919 +       dev->capture.timeperframe = tpf;
 920 +       parm->parm.capture.timeperframe = tpf;
 921 +       parm->parm.capture.readbuffers  = 1;
 922 +
 923 +       fps_param.num = 0;      /* Select variable fps, and then use
 924 +                                * FPS_RANGE to select the actual limits.
 925 +                                */
 926 +       fps_param.den = 1;
 927 +       set_framerate_params(dev);
 928 +
 929 +       return 0;
 930 +}
 931 +
 932  static const struct v4l2_ioctl_ops camera0_ioctl_ops = {
 933         /* overlay */
 934         .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
 935 @@ -1084,6 +1352,51 @@ static const struct v4l2_ioctl_ops camera0_ioctl_ops = {
 936         .vidioc_querybuf = vb2_ioctl_querybuf,
 937         .vidioc_qbuf = vb2_ioctl_qbuf,
 938         .vidioc_dqbuf = vb2_ioctl_dqbuf,
 939 +       .vidioc_enum_framesizes = vidioc_enum_framesizes,
 940 +       .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
 941 +       .vidioc_g_parm        = vidioc_g_parm,
 942 +       .vidioc_s_parm        = vidioc_s_parm,
 943 +       .vidioc_streamon = vb2_ioctl_streamon,
 944 +       .vidioc_streamoff = vb2_ioctl_streamoff,
 945 +
 946 +       .vidioc_log_status = v4l2_ctrl_log_status,
 947 +       .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
 948 +       .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 949 +};
 950 +
 951 +static const struct v4l2_ioctl_ops camera0_ioctl_ops_gstreamer = {
 952 +       /* overlay */
 953 +       .vidioc_enum_fmt_vid_overlay = vidioc_enum_fmt_vid_overlay,
 954 +       .vidioc_g_fmt_vid_overlay = vidioc_g_fmt_vid_overlay,
 955 +       .vidioc_try_fmt_vid_overlay = vidioc_try_fmt_vid_overlay,
 956 +       .vidioc_s_fmt_vid_overlay = vidioc_s_fmt_vid_overlay,
 957 +       .vidioc_overlay = vidioc_overlay,
 958 +       .vidioc_g_fbuf = vidioc_g_fbuf,
 959 +
 960 +       /* inputs */
 961 +       .vidioc_enum_input = vidioc_enum_input,
 962 +       .vidioc_g_input = vidioc_g_input,
 963 +       .vidioc_s_input = vidioc_s_input,
 964 +
 965 +       /* capture */
 966 +       .vidioc_querycap = vidioc_querycap,
 967 +       .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
 968 +       .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
 969 +       .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
 970 +       .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
 971 +
 972 +       /* buffer management */
 973 +       .vidioc_reqbufs = vb2_ioctl_reqbufs,
 974 +       .vidioc_create_bufs = vb2_ioctl_create_bufs,
 975 +       .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
 976 +       .vidioc_querybuf = vb2_ioctl_querybuf,
 977 +       .vidioc_qbuf = vb2_ioctl_qbuf,
 978 +       .vidioc_dqbuf = vb2_ioctl_dqbuf,
 979 +       /* Remove this function ptr to fix gstreamer bug
 980 +       .vidioc_enum_framesizes = vidioc_enum_framesizes, */
 981 +       .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
 982 +       .vidioc_g_parm        = vidioc_g_parm,
 983 +       .vidioc_s_parm        = vidioc_s_parm,
 984         .vidioc_streamon = vb2_ioctl_streamon,
 985         .vidioc_streamoff = vb2_ioctl_streamoff,
 986
 987 @@ -1122,8 +1435,10 @@ static int set_camera_parameters(struct vchiq_mmal_instance *instance,
 988                 .max_stills_h = MAX_HEIGHT,
 989                 .stills_yuv422 = 1,
 990                 .one_shot_stills = 1,
 991 -               .max_preview_video_w = 1920,
 992 -               .max_preview_video_h = 1088,
 993 +               .max_preview_video_w = (max_video_width > 1920) ?
 994 +                                               max_video_width : 1920,
 995 +               .max_preview_video_h = (max_video_height > 1088) ?
 996 +                                               max_video_height : 1088,
 997                 .num_preview_video_frames = 3,
 998                 .stills_capture_circular_buffer_height = 0,
 999                 .fast_preview_resume = 0,
1000 @@ -1141,6 +1456,7 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1001  {
1002         int ret;
1003         struct mmal_es_format *format;
1004 +       u32 bool_true = 1;
1005
1006         ret = vchiq_mmal_init(&dev->instance);
1007         if (ret < 0)
1008 @@ -1176,8 +1492,8 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1009         format->es->video.crop.y = 0;
1010         format->es->video.crop.width = 1024;
1011         format->es->video.crop.height = 768;
1012 -       format->es->video.frame_rate.num = PREVIEW_FRAME_RATE_NUM;
1013 -       format->es->video.frame_rate.den = PREVIEW_FRAME_RATE_DEN;
1014 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
1015 +       format->es->video.frame_rate.den = 1;
1016
1017         format =
1018             &dev->component[MMAL_COMPONENT_CAMERA]->
1019 @@ -1192,8 +1508,14 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1020         format->es->video.crop.y = 0;
1021         format->es->video.crop.width = 1024;
1022         format->es->video.crop.height = 768;
1023 -       format->es->video.frame_rate.num = PREVIEW_FRAME_RATE_NUM;
1024 -       format->es->video.frame_rate.den = PREVIEW_FRAME_RATE_DEN;
1025 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
1026 +       format->es->video.frame_rate.den = 1;
1027 +
1028 +       vchiq_mmal_port_parameter_set(dev->instance,
1029 +               &dev->component[MMAL_COMPONENT_CAMERA]->
1030 +                               output[MMAL_CAMERA_PORT_VIDEO],
1031 +               MMAL_PARAMETER_NO_IMAGE_PADDING,
1032 +               &bool_true, sizeof(bool_true));
1033
1034         format =
1035             &dev->component[MMAL_COMPONENT_CAMERA]->
1036 @@ -1207,13 +1529,22 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1037         format->es->video.crop.y = 0;
1038         format->es->video.crop.width = 2592;
1039         format->es->video.crop.height = 1944;
1040 -       format->es->video.frame_rate.num = 30;
1041 +       format->es->video.frame_rate.num = 0; /* Rely on fps_range */
1042         format->es->video.frame_rate.den = 1;
1043
1044         dev->capture.width = format->es->video.width;
1045         dev->capture.height = format->es->video.height;
1046         dev->capture.fmt = &formats[0];
1047         dev->capture.encode_component = NULL;
1048 +       dev->capture.timeperframe = tpf_default;
1049 +       dev->capture.enc_profile = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
1050 +       dev->capture.enc_level = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
1051 +
1052 +       vchiq_mmal_port_parameter_set(dev->instance,
1053 +               &dev->component[MMAL_COMPONENT_CAMERA]->
1054 +                       output[MMAL_CAMERA_PORT_CAPTURE],
1055 +               MMAL_PARAMETER_NO_IMAGE_PADDING,
1056 +               &bool_true, sizeof(bool_true));
1057
1058         /* get the preview component ready */
1059         ret = vchiq_mmal_component_init(
1060 @@ -1260,6 +1591,14 @@ static int __init mmal_init(struct bm2835_mmal_dev *dev)
1061         }
1062
1063         {
1064 +               struct vchiq_mmal_port *encoder_port =
1065 +                       &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
1066 +               encoder_port->format.encoding = MMAL_ENCODING_H264;
1067 +               ret = vchiq_mmal_port_set_format(dev->instance,
1068 +                       encoder_port);
1069 +       }
1070 +
1071 +       {
1072                 unsigned int enable = 1;
1073                 vchiq_mmal_port_parameter_set(
1074                         dev->instance,
1075 @@ -1312,6 +1651,11 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1076         int ret;
1077
1078         *vfd = vdev_template;
1079 +       if (gst_v4l2src_is_broken) {
1080 +               v4l2_info(&dev->v4l2_dev,
1081 +                 "Work-around for gstreamer issue is active.\n");
1082 +               vfd->ioctl_ops = &camera0_ioctl_ops_gstreamer;
1083 +       }
1084
1085         vfd->v4l2_dev = &dev->v4l2_dev;
1086
1087 @@ -1326,8 +1670,9 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1088         if (ret < 0)
1089                 return ret;
1090
1091 -       v4l2_info(vfd->v4l2_dev, "V4L2 device registered as %s\n",
1092 -                 video_device_node_name(vfd));
1093 +       v4l2_info(vfd->v4l2_dev,
1094 +               "V4L2 device registered as %s - stills mode > %dx%d\n",
1095 +               video_device_node_name(vfd), max_video_width, max_video_height);
1096
1097         return 0;
1098  }
1099 @@ -1335,9 +1680,9 @@ static int __init bm2835_mmal_init_device(struct bm2835_mmal_dev *dev,
1100  static struct v4l2_format default_v4l2_format = {
1101         .fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG,
1102         .fmt.pix.width = 1024,
1103 -       .fmt.pix.bytesperline = 1024 * 3 / 2,
1104 +       .fmt.pix.bytesperline = 1024,
1105         .fmt.pix.height = 768,
1106 -       .fmt.pix.sizeimage = 1<<18,
1107 +       .fmt.pix.sizeimage = 1024*768,
1108  };
1109
1110  static int __init bm2835_mmal_init(void)
1111 @@ -1400,6 +1745,9 @@ static int __init bm2835_mmal_init(void)
1112         if (ret < 0)
1113                 goto unreg_dev;
1114
1115 +       /* Really want to call vidioc_s_fmt_vid_cap with the default
1116 +        * format, but currently the APIs don't join up.
1117 +        */
1118         ret = mmal_setup_components(dev, &default_v4l2_format);
1119         if (ret < 0) {
1120                 v4l2_err(&dev->v4l2_dev,
1121 diff --git a/drivers/media/platform/bcm2835/bcm2835-camera.h b/drivers/media/platform/bcm2835/bcm2835-camera.h
1122 index 883eab7..7fe9f65 100644
1123 --- a/drivers/media/platform/bcm2835/bcm2835-camera.h
1124 +++ b/drivers/media/platform/bcm2835/bcm2835-camera.h
1125 @@ -15,7 +15,7 @@
1126   * core driver device
1127   */
1128
1129 -#define V4L2_CTRL_COUNT 18 /* number of v4l controls */
1130 +#define V4L2_CTRL_COUNT 28 /* number of v4l controls */
1131
1132  enum {
1133         MMAL_COMPONENT_CAMERA = 0,
1134 @@ -32,9 +32,6 @@ enum {
1135         MMAL_CAMERA_PORT_COUNT
1136  };
1137
1138 -#define PREVIEW_FRAME_RATE_NUM 30
1139 -#define PREVIEW_FRAME_RATE_DEN 1
1140 -
1141  #define PREVIEW_LAYER      2
1142
1143  extern int bcm2835_v4l2_debug;
1144 @@ -48,9 +45,19 @@ struct bm2835_mmal_dev {
1145         /* controls */
1146         struct v4l2_ctrl_handler  ctrl_handler;
1147         struct v4l2_ctrl          *ctrls[V4L2_CTRL_COUNT];
1148 +       enum v4l2_scene_mode      scene_mode;
1149         struct mmal_colourfx      colourfx;
1150         int                       hflip;
1151         int                       vflip;
1152 +       int                       red_gain;
1153 +       int                       blue_gain;
1154 +       enum mmal_parameter_exposuremode exposure_mode_user;
1155 +       enum v4l2_exposure_auto_type exposure_mode_v4l2_user;
1156 +       /* active exposure mode may differ if selected via a scene mode */
1157 +       enum mmal_parameter_exposuremode exposure_mode_active;
1158 +       enum mmal_parameter_exposuremeteringmode metering_mode;
1159 +       unsigned int              manual_shutter_speed;
1160 +       bool                      exp_auto_priority;
1161
1162         /* allocated mmal instance and components */
1163         struct vchiq_mmal_instance   *instance;
1164 @@ -63,12 +70,18 @@ struct bm2835_mmal_dev {
1165                 unsigned int     width;  /* width */
1166                 unsigned int     height;  /* height */
1167                 unsigned int     stride;  /* stride */
1168 +               unsigned int     buffersize; /* buffer size with padding */
1169                 struct mmal_fmt  *fmt;
1170 +               struct v4l2_fract timeperframe;
1171
1172                 /* H264 encode bitrate */
1173                 int         encode_bitrate;
1174                 /* H264 bitrate mode. CBR/VBR */
1175                 int         encode_bitrate_mode;
1176 +               /* H264 profile */
1177 +               enum v4l2_mpeg_video_h264_profile enc_profile;
1178 +               /* H264 level */
1179 +               enum v4l2_mpeg_video_h264_level enc_level;
1180                 /* JPEG Q-factor */
1181                 int         q_factor;
1182
1183 @@ -98,7 +111,7 @@ int bm2835_mmal_init_controls(
1184                         struct v4l2_ctrl_handler *hdl);
1185
1186  int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev);
1187 -
1188 +int set_framerate_params(struct bm2835_mmal_dev *dev);
1189
1190  /* Debug helpers */
1191
1192 diff --git a/drivers/media/platform/bcm2835/controls.c b/drivers/media/platform/bcm2835/controls.c
1193 index d1408e5..3017b94 100644
1194 --- a/drivers/media/platform/bcm2835/controls.c
1195 +++ b/drivers/media/platform/bcm2835/controls.c
1196 @@ -30,11 +30,23 @@
1197  #include "mmal-parameters.h"
1198  #include "bcm2835-camera.h"
1199
1200 -/* The supported V4L2_CID_AUTO_EXPOSURE_BIAS values are from -24 to +24.
1201 - * These are in 1/6th increments so the effective range is -4.0EV to +4.0EV.
1202 +/* The supported V4L2_CID_AUTO_EXPOSURE_BIAS values are from -4.0 to +4.0.
1203 + * MMAL values are in 1/6th increments so the MMAL range is -24 to +24.
1204 + * V4L2 docs say value "is expressed in terms of EV, drivers should interpret
1205 + * the values as 0.001 EV units, where the value 1000 stands for +1 EV."
1206 + * V4L2 is limited to a max of 32 values in a menu, so count in 1/3rds from
1207 + * -4 to +4
1208   */
1209  static const s64 ev_bias_qmenu[] = {
1210 -       -24, -21, -18, -15, -12, -9, -6, -3, 0, 3, 6, 9, 12, 15, 18, 21, 24
1211 +       -4000, -3667, -3333,
1212 +       -3000, -2667, -2333,
1213 +       -2000, -1667, -1333,
1214 +       -1000,  -667,  -333,
1215 +           0,   333,   667,
1216 +        1000,  1333,  1667,
1217 +        2000,  2333,  2667,
1218 +        3000,  3333,  3667,
1219 +        4000
1220  };
1221
1222  /* Supported ISO values
1223 @@ -44,13 +56,19 @@ static const s64 iso_qmenu[] = {
1224         0, 100, 200, 400, 800,
1225  };
1226
1227 +static const s64 mains_freq_qmenu[] = {
1228 +       V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
1229 +       V4L2_CID_POWER_LINE_FREQUENCY_50HZ,
1230 +       V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
1231 +       V4L2_CID_POWER_LINE_FREQUENCY_AUTO
1232 +};
1233 +
1234  /* Supported video encode modes */
1235  static const s64 bitrate_mode_qmenu[] = {
1236         (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1237         (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
1238  };
1239
1240 -
1241  enum bm2835_mmal_ctrl_type {
1242         MMAL_CONTROL_TYPE_STD,
1243         MMAL_CONTROL_TYPE_STD_MENU,
1244 @@ -77,6 +95,7 @@ struct bm2835_mmal_v4l2_ctrl {
1245         const s64 *imenu; /* integer menu array */
1246         u32 mmal_id; /* mmal parameter id */
1247         bm2835_mmal_v4l2_ctrl_cb *setter;
1248 +       bool ignore_errors;
1249  };
1250
1251  struct v4l2_to_mmal_effects_setting {
1252 @@ -126,6 +145,25 @@ static const struct v4l2_to_mmal_effects_setting
1253                 1,   1,    0,    0,   0, {0, 0, 0, 0, 0} }
1254  };
1255
1256 +struct v4l2_mmal_scene_config {
1257 +       enum v4l2_scene_mode                    v4l2_scene;
1258 +       enum mmal_parameter_exposuremode        exposure_mode;
1259 +       enum mmal_parameter_exposuremeteringmode metering_mode;
1260 +};
1261 +
1262 +static const struct v4l2_mmal_scene_config scene_configs[] = {
1263 +       /* V4L2_SCENE_MODE_NONE automatically added */
1264 +       {
1265 +               V4L2_SCENE_MODE_NIGHT,
1266 +               MMAL_PARAM_EXPOSUREMODE_NIGHT,
1267 +               MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
1268 +       },
1269 +       {
1270 +               V4L2_SCENE_MODE_SPORTS,
1271 +               MMAL_PARAM_EXPOSUREMODE_SPORTS,
1272 +               MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
1273 +       },
1274 +};
1275
1276  /* control handlers*/
1277
1278 @@ -133,10 +171,7 @@ static int ctrl_set_rational(struct bm2835_mmal_dev *dev,
1279                       struct v4l2_ctrl *ctrl,
1280                       const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1281  {
1282 -       struct  {
1283 -               s32 num;    /**< Numerator */
1284 -               s32 den;    /**< Denominator */
1285 -       } rational_value;
1286 +       struct mmal_parameter_rational rational_value;
1287         struct vchiq_mmal_port *control;
1288
1289         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1290 @@ -166,6 +201,41 @@ static int ctrl_set_value(struct bm2835_mmal_dev *dev,
1291                                              &u32_value, sizeof(u32_value));
1292  }
1293
1294 +static int ctrl_set_value_menu(struct bm2835_mmal_dev *dev,
1295 +                     struct v4l2_ctrl *ctrl,
1296 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1297 +{
1298 +       u32 u32_value;
1299 +       struct vchiq_mmal_port *control;
1300 +
1301 +       if (ctrl->val > mmal_ctrl->max || ctrl->val < mmal_ctrl->min)
1302 +               return 1;
1303 +
1304 +       control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1305 +
1306 +       u32_value = mmal_ctrl->imenu[ctrl->val];
1307 +
1308 +       return vchiq_mmal_port_parameter_set(dev->instance, control,
1309 +                                            mmal_ctrl->mmal_id,
1310 +                                            &u32_value, sizeof(u32_value));
1311 +}
1312 +
1313 +static int ctrl_set_value_ev(struct bm2835_mmal_dev *dev,
1314 +                     struct v4l2_ctrl *ctrl,
1315 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1316 +{
1317 +       s32 s32_value;
1318 +       struct vchiq_mmal_port *control;
1319 +
1320 +       control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1321 +
1322 +       s32_value = (ctrl->val-12)*2;   /* Convert from index to 1/6ths */
1323 +
1324 +       return vchiq_mmal_port_parameter_set(dev->instance, control,
1325 +                                            mmal_ctrl->mmal_id,
1326 +                                            &s32_value, sizeof(s32_value));
1327 +}
1328 +
1329  static int ctrl_set_rotate(struct bm2835_mmal_dev *dev,
1330                       struct v4l2_ctrl *ctrl,
1331                       const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1332 @@ -245,37 +315,97 @@ static int ctrl_set_exposure(struct bm2835_mmal_dev *dev,
1333                       struct v4l2_ctrl *ctrl,
1334                       const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1335  {
1336 -       u32 u32_value;
1337 +       enum mmal_parameter_exposuremode exp_mode = dev->exposure_mode_user;
1338 +       u32 shutter_speed = 0;
1339         struct vchiq_mmal_port *control;
1340 +       int ret = 0;
1341
1342         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1343
1344 +       if (mmal_ctrl->mmal_id == MMAL_PARAMETER_SHUTTER_SPEED) {
1345 +               /* V4L2 is in 100usec increments.
1346 +                * MMAL is 1usec.
1347 +                */
1348 +               dev->manual_shutter_speed = ctrl->val * 100;
1349 +       } else if (mmal_ctrl->mmal_id == MMAL_PARAMETER_EXPOSURE_MODE) {
1350 +               switch (ctrl->val) {
1351 +               case V4L2_EXPOSURE_AUTO:
1352 +                       exp_mode = MMAL_PARAM_EXPOSUREMODE_AUTO;
1353 +                       break;
1354 +
1355 +               case V4L2_EXPOSURE_MANUAL:
1356 +                       exp_mode = MMAL_PARAM_EXPOSUREMODE_OFF;
1357 +                       break;
1358 +               }
1359 +               dev->exposure_mode_user = exp_mode;
1360 +               dev->exposure_mode_v4l2_user = ctrl->val;
1361 +       } else if (mmal_ctrl->id == V4L2_CID_EXPOSURE_AUTO_PRIORITY) {
1362 +               dev->exp_auto_priority = ctrl->val;
1363 +       }
1364 +
1365 +       if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
1366 +               if (exp_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
1367 +                       shutter_speed = dev->manual_shutter_speed;
1368 +
1369 +               ret = vchiq_mmal_port_parameter_set(dev->instance,
1370 +                                       control,
1371 +                                       MMAL_PARAMETER_SHUTTER_SPEED,
1372 +                                       &shutter_speed,
1373 +                                       sizeof(shutter_speed));
1374 +               ret += vchiq_mmal_port_parameter_set(dev->instance,
1375 +                                       control,
1376 +                                       MMAL_PARAMETER_EXPOSURE_MODE,
1377 +                                       &exp_mode,
1378 +                                       sizeof(u32));
1379 +               dev->exposure_mode_active = exp_mode;
1380 +       }
1381 +       /* exposure_dynamic_framerate (V4L2_CID_EXPOSURE_AUTO_PRIORITY) should
1382 +        * always apply irrespective of scene mode.
1383 +        */
1384 +       ret += set_framerate_params(dev);
1385 +
1386 +       return ret;
1387 +}
1388 +
1389 +static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1390 +                          struct v4l2_ctrl *ctrl,
1391 +                          const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1392 +{
1393         switch (ctrl->val) {
1394 -       case V4L2_EXPOSURE_AUTO:
1395 -               u32_value = MMAL_PARAM_EXPOSUREMODE_AUTO;
1396 +       case V4L2_EXPOSURE_METERING_AVERAGE:
1397 +               dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
1398                 break;
1399
1400 -       case V4L2_EXPOSURE_MANUAL:
1401 -               u32_value = MMAL_PARAM_EXPOSUREMODE_OFF;
1402 +       case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
1403 +               dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT;
1404                 break;
1405
1406 -       case V4L2_EXPOSURE_SHUTTER_PRIORITY:
1407 -               u32_value = MMAL_PARAM_EXPOSUREMODE_SPORTS;
1408 +       case V4L2_EXPOSURE_METERING_SPOT:
1409 +               dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT;
1410                 break;
1411
1412 -       case V4L2_EXPOSURE_APERTURE_PRIORITY:
1413 -               u32_value = MMAL_PARAM_EXPOSUREMODE_NIGHT;
1414 +       /* todo matrix weighting not added to Linux API till 3.9
1415 +       case V4L2_EXPOSURE_METERING_MATRIX:
1416 +               dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX;
1417                 break;
1418 +       */
1419
1420         }
1421
1422 -       /* todo: what about the other ten modes there are MMAL parameters for */
1423 -       return vchiq_mmal_port_parameter_set(dev->instance, control,
1424 +       if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
1425 +               struct vchiq_mmal_port *control;
1426 +               u32 u32_value = dev->metering_mode;
1427 +
1428 +               control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1429 +
1430 +               return vchiq_mmal_port_parameter_set(dev->instance, control,
1431                                              mmal_ctrl->mmal_id,
1432                                              &u32_value, sizeof(u32_value));
1433 +       } else
1434 +               return 0;
1435  }
1436
1437 -static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1438 +static int ctrl_set_flicker_avoidance(struct bm2835_mmal_dev *dev,
1439                            struct v4l2_ctrl *ctrl,
1440                            const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1441  {
1442 @@ -285,24 +415,18 @@ static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
1443         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1444
1445         switch (ctrl->val) {
1446 -       case V4L2_EXPOSURE_METERING_AVERAGE:
1447 -               u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
1448 +       case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
1449 +               u32_value = MMAL_PARAM_FLICKERAVOID_OFF;
1450                 break;
1451 -
1452 -       case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
1453 -               u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT;
1454 +       case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
1455 +               u32_value = MMAL_PARAM_FLICKERAVOID_50HZ;
1456                 break;
1457 -
1458 -       case V4L2_EXPOSURE_METERING_SPOT:
1459 -               u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT;
1460 +       case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
1461 +               u32_value = MMAL_PARAM_FLICKERAVOID_60HZ;
1462                 break;
1463 -
1464 -       /* todo matrix weighting not added to Linux API till 3.9
1465 -       case V4L2_EXPOSURE_METERING_MATRIX:
1466 -               u32_value = MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX;
1467 +       case V4L2_CID_POWER_LINE_FREQUENCY_AUTO:
1468 +               u32_value = MMAL_PARAM_FLICKERAVOID_AUTO;
1469                 break;
1470 -       */
1471 -
1472         }
1473
1474         return vchiq_mmal_port_parameter_set(dev->instance, control,
1475 @@ -367,6 +491,29 @@ static int ctrl_set_awb_mode(struct bm2835_mmal_dev *dev,
1476                                              &u32_value, sizeof(u32_value));
1477  }
1478
1479 +static int ctrl_set_awb_gains(struct bm2835_mmal_dev *dev,
1480 +                     struct v4l2_ctrl *ctrl,
1481 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1482 +{
1483 +       struct vchiq_mmal_port *control;
1484 +       struct mmal_parameter_awbgains gains;
1485 +
1486 +       control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1487 +
1488 +       if (ctrl->id == V4L2_CID_RED_BALANCE)
1489 +               dev->red_gain = ctrl->val;
1490 +       else if (ctrl->id == V4L2_CID_BLUE_BALANCE)
1491 +               dev->blue_gain = ctrl->val;
1492 +
1493 +       gains.r_gain.num = dev->red_gain;
1494 +       gains.b_gain.num = dev->blue_gain;
1495 +       gains.r_gain.den = gains.b_gain.den = 1000;
1496 +
1497 +       return vchiq_mmal_port_parameter_set(dev->instance, control,
1498 +                                            mmal_ctrl->mmal_id,
1499 +                                            &gains, sizeof(gains));
1500 +}
1501 +
1502  static int ctrl_set_image_effect(struct bm2835_mmal_dev *dev,
1503                    struct v4l2_ctrl *ctrl,
1504                    const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1505 @@ -443,8 +590,8 @@ static int ctrl_set_colfx(struct bm2835_mmal_dev *dev,
1506                                         &dev->colourfx, sizeof(dev->colourfx));
1507
1508         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1509 -                "After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
1510 -                       mmal_ctrl, ctrl->id, ctrl->val, ret,
1511 +                "%s: After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
1512 +                       __func__, mmal_ctrl, ctrl->id, ctrl->val, ret,
1513                         (ret == 0 ? 0 : -EINVAL));
1514         return (ret == 0 ? 0 : EINVAL);
1515  }
1516 @@ -494,7 +641,7 @@ static int ctrl_set_bitrate_mode(struct bm2835_mmal_dev *dev,
1517         return 0;
1518  }
1519
1520 -static int ctrl_set_q_factor(struct bm2835_mmal_dev *dev,
1521 +static int ctrl_set_image_encode_output(struct bm2835_mmal_dev *dev,
1522                       struct v4l2_ctrl *ctrl,
1523                       const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1524  {
1525 @@ -510,12 +657,247 @@ static int ctrl_set_q_factor(struct bm2835_mmal_dev *dev,
1526                                              &u32_value, sizeof(u32_value));
1527  }
1528
1529 +static int ctrl_set_video_encode_param_output(struct bm2835_mmal_dev *dev,
1530 +                     struct v4l2_ctrl *ctrl,
1531 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1532 +{
1533 +       u32 u32_value;
1534 +       struct vchiq_mmal_port *vid_enc_ctl;
1535 +
1536 +       vid_enc_ctl = &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
1537 +
1538 +       u32_value = ctrl->val;
1539 +
1540 +       return vchiq_mmal_port_parameter_set(dev->instance, vid_enc_ctl,
1541 +                                            mmal_ctrl->mmal_id,
1542 +                                            &u32_value, sizeof(u32_value));
1543 +}
1544 +
1545 +static int ctrl_set_video_encode_profile_level(struct bm2835_mmal_dev *dev,
1546 +                     struct v4l2_ctrl *ctrl,
1547 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1548 +{
1549 +       struct mmal_parameter_video_profile param;
1550 +       int ret = 0;
1551 +
1552 +       if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_PROFILE) {
1553 +               switch (ctrl->val) {
1554 +               case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1555 +               case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1556 +               case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1557 +               case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1558 +                       dev->capture.enc_profile = ctrl->val;
1559 +                       break;
1560 +               default:
1561 +                       ret = -EINVAL;
1562 +                       break;
1563 +               }
1564 +       } else if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_LEVEL) {
1565 +               switch (ctrl->val) {
1566 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
1567 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
1568 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
1569 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
1570 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
1571 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
1572 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
1573 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
1574 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
1575 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
1576 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
1577 +               case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
1578 +                       dev->capture.enc_level = ctrl->val;
1579 +                       break;
1580 +               default:
1581 +                       ret = -EINVAL;
1582 +                       break;
1583 +               }
1584 +       }
1585 +
1586 +       if (!ret) {
1587 +               switch (dev->capture.enc_profile) {
1588 +               case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
1589 +                       param.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
1590 +                       break;
1591 +               case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
1592 +                       param.profile =
1593 +                               MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE;
1594 +                       break;
1595 +               case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
1596 +                       param.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
1597 +                       break;
1598 +               case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
1599 +                       param.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
1600 +                       break;
1601 +               default:
1602 +                       /* Should never get here */
1603 +                       break;
1604 +               }
1605 +
1606 +               switch (dev->capture.enc_level) {
1607 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
1608 +                       param.level = MMAL_VIDEO_LEVEL_H264_1;
1609 +                       break;
1610 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
1611 +                       param.level = MMAL_VIDEO_LEVEL_H264_1b;
1612 +                       break;
1613 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
1614 +                       param.level = MMAL_VIDEO_LEVEL_H264_11;
1615 +                       break;
1616 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
1617 +                       param.level = MMAL_VIDEO_LEVEL_H264_12;
1618 +                       break;
1619 +               case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
1620 +                       param.level = MMAL_VIDEO_LEVEL_H264_13;
1621 +                       break;
1622 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
1623 +                       param.level = MMAL_VIDEO_LEVEL_H264_2;
1624 +                       break;
1625 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
1626 +                       param.level = MMAL_VIDEO_LEVEL_H264_21;
1627 +                       break;
1628 +               case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
1629 +                       param.level = MMAL_VIDEO_LEVEL_H264_22;
1630 +                       break;
1631 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
1632 +                       param.level = MMAL_VIDEO_LEVEL_H264_3;
1633 +                       break;
1634 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
1635 +                       param.level = MMAL_VIDEO_LEVEL_H264_31;
1636 +                       break;
1637 +               case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
1638 +                       param.level = MMAL_VIDEO_LEVEL_H264_32;
1639 +                       break;
1640 +               case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
1641 +                       param.level = MMAL_VIDEO_LEVEL_H264_4;
1642 +                       break;
1643 +               default:
1644 +                       /* Should never get here */
1645 +                       break;
1646 +               }
1647 +
1648 +               ret = vchiq_mmal_port_parameter_set(dev->instance,
1649 +                       &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0],
1650 +                       mmal_ctrl->mmal_id,
1651 +                       &param, sizeof(param));
1652 +       }
1653 +       return ret;
1654 +}
1655 +
1656 +static int ctrl_set_scene_mode(struct bm2835_mmal_dev *dev,
1657 +                     struct v4l2_ctrl *ctrl,
1658 +                     const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
1659 +{
1660 +       int ret = 0;
1661 +       int shutter_speed;
1662 +       struct vchiq_mmal_port *control;
1663 +
1664 +       v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
1665 +               "scene mode selected %d, was %d\n", ctrl->val,
1666 +               dev->scene_mode);
1667 +       control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
1668 +
1669 +       if (ctrl->val == dev->scene_mode)
1670 +               return 0;
1671 +
1672 +       if (ctrl->val == V4L2_SCENE_MODE_NONE) {
1673 +               /* Restore all user selections */
1674 +               dev->scene_mode = V4L2_SCENE_MODE_NONE;
1675 +
1676 +               if (dev->exposure_mode_user == MMAL_PARAM_EXPOSUREMODE_OFF)
1677 +                       shutter_speed = dev->manual_shutter_speed;
1678 +               else
1679 +                       shutter_speed = 0;
1680 +
1681 +               v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
1682 +                       "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
1683 +                       __func__, shutter_speed, dev->exposure_mode_user,
1684 +                       dev->metering_mode);
1685 +               ret = vchiq_mmal_port_parameter_set(dev->instance,
1686 +                                       control,
1687 +                                       MMAL_PARAMETER_SHUTTER_SPEED,
1688 +                                       &shutter_speed,
1689 +                                       sizeof(shutter_speed));
1690 +               ret += vchiq_mmal_port_parameter_set(dev->instance,
1691 +                                       control,
1692 +                                       MMAL_PARAMETER_EXPOSURE_MODE,
1693 +                                       &dev->exposure_mode_user,
1694 +                                       sizeof(u32));
1695 +               dev->exposure_mode_active = dev->exposure_mode_user;
1696 +               ret += vchiq_mmal_port_parameter_set(dev->instance,
1697 +                                       control,
1698 +                                       MMAL_PARAMETER_EXP_METERING_MODE,
1699 +                                       &dev->metering_mode,
1700 +                                       sizeof(u32));
1701 +               ret += set_framerate_params(dev);
1702 +       } else {
1703 +               /* Set up scene mode */
1704 +               int i;
1705 +               const struct v4l2_mmal_scene_config *scene = NULL;
1706 +               int shutter_speed;
1707 +               enum mmal_parameter_exposuremode exposure_mode;
1708 +               enum mmal_parameter_exposuremeteringmode metering_mode;
1709 +
1710 +               for (i = 0; i < ARRAY_SIZE(scene_configs); i++) {
1711 +                       if (scene_configs[i].v4l2_scene ==
1712 +                               ctrl->val) {
1713 +                               scene = &scene_configs[i];
1714 +                               break;
1715 +                       }
1716 +               }
1717 +               if (i >= ARRAY_SIZE(scene_configs))
1718 +                       return -EINVAL;
1719 +
1720 +               /* Set all the values */
1721 +               dev->scene_mode = ctrl->val;
1722 +
1723 +               if (scene->exposure_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
1724 +                       shutter_speed = dev->manual_shutter_speed;
1725 +               else
1726 +                       shutter_speed = 0;
1727 +               exposure_mode = scene->exposure_mode;
1728 +               metering_mode = scene->metering_mode;
1729 +
1730 +               v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1731 +                       "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
1732 +                       __func__, shutter_speed, exposure_mode, metering_mode);
1733 +
1734 +               ret = vchiq_mmal_port_parameter_set(dev->instance, control,
1735 +                                       MMAL_PARAMETER_SHUTTER_SPEED,
1736 +                                       &shutter_speed,
1737 +                                       sizeof(shutter_speed));
1738 +               ret += vchiq_mmal_port_parameter_set(dev->instance,
1739 +                                       control,
1740 +                                       MMAL_PARAMETER_EXPOSURE_MODE,
1741 +                                       &exposure_mode,
1742 +                                       sizeof(u32));
1743 +               dev->exposure_mode_active = exposure_mode;
1744 +               ret += vchiq_mmal_port_parameter_set(dev->instance, control,
1745 +                                       MMAL_PARAMETER_EXPOSURE_MODE,
1746 +                                       &exposure_mode,
1747 +                                       sizeof(u32));
1748 +               ret += vchiq_mmal_port_parameter_set(dev->instance, control,
1749 +                                       MMAL_PARAMETER_EXP_METERING_MODE,
1750 +                                       &metering_mode,
1751 +                                       sizeof(u32));
1752 +               ret += set_framerate_params(dev);
1753 +       }
1754 +       if (ret) {
1755 +               v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1756 +                       "%s: Setting scene to %d, ret=%d\n",
1757 +                       __func__, ctrl->val, ret);
1758 +               ret = -EINVAL;
1759 +       }
1760 +       return 0;
1761 +}
1762 +
1763  static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
1764  {
1765         struct bm2835_mmal_dev *dev =
1766                 container_of(ctrl->handler, struct bm2835_mmal_dev,
1767                              ctrl_handler);
1768         const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl = ctrl->priv;
1769 +       int ret;
1770
1771         if ((mmal_ctrl == NULL) ||
1772             (mmal_ctrl->id != ctrl->id) ||
1773 @@ -524,7 +906,13 @@ static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
1774                 return -EINVAL;
1775         }
1776
1777 -       return mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
1778 +       ret = mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
1779 +       if (ret)
1780 +               pr_warn("ctrl id:%d/MMAL param %08X- returned ret %d\n",
1781 +                               ctrl->id, mmal_ctrl->mmal_id, ret);
1782 +       if (mmal_ctrl->ignore_errors)
1783 +               ret = 0;
1784 +       return ret;
1785  }
1786
1787  static const struct v4l2_ctrl_ops bm2835_mmal_ctrl_ops = {
1788 @@ -537,40 +925,54 @@ static const struct bm2835_mmal_v4l2_ctrl v4l2_ctrls[V4L2_CTRL_COUNT] = {
1789         {
1790                 V4L2_CID_SATURATION, MMAL_CONTROL_TYPE_STD,
1791                 -100, 100, 0, 1, NULL,
1792 -               MMAL_PARAMETER_SATURATION, &ctrl_set_rational
1793 +               MMAL_PARAMETER_SATURATION,
1794 +               &ctrl_set_rational,
1795 +               false
1796         },
1797         {
1798                 V4L2_CID_SHARPNESS, MMAL_CONTROL_TYPE_STD,
1799                 -100, 100, 0, 1, NULL,
1800 -               MMAL_PARAMETER_SHARPNESS, &ctrl_set_rational
1801 +               MMAL_PARAMETER_SHARPNESS,
1802 +               &ctrl_set_rational,
1803 +               false
1804         },
1805         {
1806                 V4L2_CID_CONTRAST, MMAL_CONTROL_TYPE_STD,
1807                 -100, 100, 0, 1, NULL,
1808 -               MMAL_PARAMETER_CONTRAST, &ctrl_set_rational
1809 +               MMAL_PARAMETER_CONTRAST,
1810 +               &ctrl_set_rational,
1811 +               false
1812         },
1813         {
1814                 V4L2_CID_BRIGHTNESS, MMAL_CONTROL_TYPE_STD,
1815                 0, 100, 50, 1, NULL,
1816 -               MMAL_PARAMETER_BRIGHTNESS, &ctrl_set_rational
1817 +               MMAL_PARAMETER_BRIGHTNESS,
1818 +               &ctrl_set_rational,
1819 +               false
1820         },
1821         {
1822                 V4L2_CID_ISO_SENSITIVITY, MMAL_CONTROL_TYPE_INT_MENU,
1823                 0, ARRAY_SIZE(iso_qmenu) - 1, 0, 1, iso_qmenu,
1824 -               MMAL_PARAMETER_ISO, &ctrl_set_value
1825 +               MMAL_PARAMETER_ISO,
1826 +               &ctrl_set_value_menu,
1827 +               false
1828         },
1829         {
1830                 V4L2_CID_IMAGE_STABILIZATION, MMAL_CONTROL_TYPE_STD,
1831                 0, 1, 0, 1, NULL,
1832 -               MMAL_PARAMETER_VIDEO_STABILISATION, &ctrl_set_value
1833 +               MMAL_PARAMETER_VIDEO_STABILISATION,
1834 +               &ctrl_set_value,
1835 +               false
1836         },
1837  /*     {
1838                 0, MMAL_CONTROL_TYPE_CLUSTER, 3, 1, 0, NULL, 0, NULL
1839 -       },
1840 -*/     {
1841 +       }, */
1842 +       {
1843                 V4L2_CID_EXPOSURE_AUTO, MMAL_CONTROL_TYPE_STD_MENU,
1844                 ~0x03, 3, V4L2_EXPOSURE_AUTO, 0, NULL,
1845 -               MMAL_PARAMETER_EXPOSURE_MODE, &ctrl_set_exposure
1846 +               MMAL_PARAMETER_EXPOSURE_MODE,
1847 +               &ctrl_set_exposure,
1848 +               false
1849         },
1850  /* todo this needs mixing in with set exposure
1851         {
1852 @@ -578,83 +980,258 @@ static const struct bm2835_mmal_v4l2_ctrl v4l2_ctrls[V4L2_CTRL_COUNT] = {
1853         },
1854   */
1855         {
1856 +               V4L2_CID_EXPOSURE_ABSOLUTE, MMAL_CONTROL_TYPE_STD,
1857 +               /* Units of 100usecs */
1858 +               1, 1*1000*10, 100*10, 1, NULL,
1859 +               MMAL_PARAMETER_SHUTTER_SPEED,
1860 +               &ctrl_set_exposure,
1861 +               false
1862 +       },
1863 +       {
1864                 V4L2_CID_AUTO_EXPOSURE_BIAS, MMAL_CONTROL_TYPE_INT_MENU,
1865                 0, ARRAY_SIZE(ev_bias_qmenu) - 1,
1866                 (ARRAY_SIZE(ev_bias_qmenu)+1)/2 - 1, 0, ev_bias_qmenu,
1867 -               MMAL_PARAMETER_EXPOSURE_COMP, &ctrl_set_value
1868 +               MMAL_PARAMETER_EXPOSURE_COMP,
1869 +               &ctrl_set_value_ev,
1870 +               false
1871 +       },
1872 +       {
1873 +               V4L2_CID_EXPOSURE_AUTO_PRIORITY, MMAL_CONTROL_TYPE_STD,
1874 +               0, 1,
1875 +               0, 1, NULL,
1876 +               0,      /* Dummy MMAL ID as it gets mapped into FPS range*/
1877 +               &ctrl_set_exposure,
1878 +               false
1879         },
1880         {
1881                 V4L2_CID_EXPOSURE_METERING,
1882                 MMAL_CONTROL_TYPE_STD_MENU,
1883                 ~0x7, 2, V4L2_EXPOSURE_METERING_AVERAGE, 0, NULL,
1884 -               MMAL_PARAMETER_EXP_METERING_MODE, &ctrl_set_metering_mode
1885 +               MMAL_PARAMETER_EXP_METERING_MODE,
1886 +               &ctrl_set_metering_mode,
1887 +               false
1888         },
1889         {
1890                 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
1891                 MMAL_CONTROL_TYPE_STD_MENU,
1892 -               ~0x3fe, 9, V4L2_WHITE_BALANCE_AUTO, 0, NULL,
1893 -               MMAL_PARAMETER_AWB_MODE, &ctrl_set_awb_mode
1894 +               ~0x3ff, 9, V4L2_WHITE_BALANCE_AUTO, 0, NULL,
1895 +               MMAL_PARAMETER_AWB_MODE,
1896 +               &ctrl_set_awb_mode,
1897 +               false
1898 +       },
1899 +       {
1900 +               V4L2_CID_RED_BALANCE, MMAL_CONTROL_TYPE_STD,
1901 +               1, 7999, 1000, 1, NULL,
1902 +               MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1903 +               &ctrl_set_awb_gains,
1904 +               false
1905 +       },
1906 +       {
1907 +               V4L2_CID_BLUE_BALANCE, MMAL_CONTROL_TYPE_STD,
1908 +               1, 7999, 1000, 1, NULL,
1909 +               MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1910 +               &ctrl_set_awb_gains,
1911 +               false
1912         },
1913         {
1914                 V4L2_CID_COLORFX, MMAL_CONTROL_TYPE_STD_MENU,
1915                 0, 15, V4L2_COLORFX_NONE, 0, NULL,
1916 -               MMAL_PARAMETER_IMAGE_EFFECT, &ctrl_set_image_effect
1917 +               MMAL_PARAMETER_IMAGE_EFFECT,
1918 +               &ctrl_set_image_effect,
1919 +               false
1920         },
1921         {
1922                 V4L2_CID_COLORFX_CBCR, MMAL_CONTROL_TYPE_STD,
1923                 0, 0xffff, 0x8080, 1, NULL,
1924 -               MMAL_PARAMETER_COLOUR_EFFECT, &ctrl_set_colfx
1925 +               MMAL_PARAMETER_COLOUR_EFFECT,
1926 +               &ctrl_set_colfx,
1927 +               false
1928         },
1929         {
1930                 V4L2_CID_ROTATE, MMAL_CONTROL_TYPE_STD,
1931                 0, 360, 0, 90, NULL,
1932 -               MMAL_PARAMETER_ROTATION, &ctrl_set_rotate
1933 +               MMAL_PARAMETER_ROTATION,
1934 +               &ctrl_set_rotate,
1935 +               false
1936         },
1937         {
1938                 V4L2_CID_HFLIP, MMAL_CONTROL_TYPE_STD,
1939                 0, 1, 0, 1, NULL,
1940 -               MMAL_PARAMETER_MIRROR, &ctrl_set_flip
1941 +               MMAL_PARAMETER_MIRROR,
1942 +               &ctrl_set_flip,
1943 +               false
1944         },
1945         {
1946                 V4L2_CID_VFLIP, MMAL_CONTROL_TYPE_STD,
1947                 0, 1, 0, 1, NULL,
1948 -               MMAL_PARAMETER_MIRROR, &ctrl_set_flip
1949 +               MMAL_PARAMETER_MIRROR,
1950 +               &ctrl_set_flip,
1951 +               false
1952         },
1953         {
1954                 V4L2_CID_MPEG_VIDEO_BITRATE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
1955                 0, ARRAY_SIZE(bitrate_mode_qmenu) - 1,
1956                 0, 0, bitrate_mode_qmenu,
1957 -               MMAL_PARAMETER_RATECONTROL, &ctrl_set_bitrate_mode
1958 +               MMAL_PARAMETER_RATECONTROL,
1959 +               &ctrl_set_bitrate_mode,
1960 +               false
1961         },
1962         {
1963                 V4L2_CID_MPEG_VIDEO_BITRATE, MMAL_CONTROL_TYPE_STD,
1964                 25*1000, 25*1000*1000, 10*1000*1000, 25*1000, NULL,
1965 -               MMAL_PARAMETER_VIDEO_BIT_RATE, &ctrl_set_bitrate
1966 +               MMAL_PARAMETER_VIDEO_BIT_RATE,
1967 +               &ctrl_set_bitrate,
1968 +               false
1969         },
1970         {
1971                 V4L2_CID_JPEG_COMPRESSION_QUALITY, MMAL_CONTROL_TYPE_STD,
1972 -               0, 100,
1973 +               1, 100,
1974                 30, 1, NULL,
1975 -               MMAL_PARAMETER_JPEG_Q_FACTOR, &ctrl_set_q_factor
1976 +               MMAL_PARAMETER_JPEG_Q_FACTOR,
1977 +               &ctrl_set_image_encode_output,
1978 +               false
1979 +       },
1980 +       {
1981 +               V4L2_CID_POWER_LINE_FREQUENCY, MMAL_CONTROL_TYPE_STD_MENU,
1982 +               0, ARRAY_SIZE(mains_freq_qmenu) - 1,
1983 +               1, 1, NULL,
1984 +               MMAL_PARAMETER_FLICKER_AVOID,
1985 +               &ctrl_set_flicker_avoidance,
1986 +               false
1987 +       },
1988 +       {
1989 +               V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, MMAL_CONTROL_TYPE_STD,
1990 +               0, 1,
1991 +               0, 1, NULL,
1992 +               MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER,
1993 +               &ctrl_set_video_encode_param_output,
1994 +               true    /* Errors ignored as requires latest firmware to work */
1995 +       },
1996 +       {
1997 +               V4L2_CID_MPEG_VIDEO_H264_PROFILE,
1998 +               MMAL_CONTROL_TYPE_STD_MENU,
1999 +               ~((1<<V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
2000 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
2001 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
2002 +                       (1<<V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
2003 +               V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
2004 +               V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 1, NULL,
2005 +               MMAL_PARAMETER_PROFILE,
2006 +               &ctrl_set_video_encode_profile_level,
2007 +               false
2008 +       },
2009 +       {
2010 +               V4L2_CID_MPEG_VIDEO_H264_LEVEL, MMAL_CONTROL_TYPE_STD_MENU,
2011 +               ~((1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |
2012 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1B) |
2013 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_1) |
2014 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_2) |
2015 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_3) |
2016 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |
2017 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_1) |
2018 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_2) |
2019 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |
2020 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_1) |
2021 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_2) |
2022 +                       (1<<V4L2_MPEG_VIDEO_H264_LEVEL_4_0)),
2023 +               V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
2024 +               V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 1, NULL,
2025 +               MMAL_PARAMETER_PROFILE,
2026 +               &ctrl_set_video_encode_profile_level,
2027 +               false
2028 +       },
2029 +       {
2030 +               V4L2_CID_SCENE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
2031 +               -1,     /* Min is computed at runtime */
2032 +               V4L2_SCENE_MODE_TEXT,
2033 +               V4L2_SCENE_MODE_NONE, 1, NULL,
2034 +               MMAL_PARAMETER_PROFILE,
2035 +               &ctrl_set_scene_mode,
2036 +               false
2037 +       },
2038 +       {
2039 +               V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, MMAL_CONTROL_TYPE_STD,
2040 +               0, 0x7FFFFFFF, 60, 1, NULL,
2041 +               MMAL_PARAMETER_INTRAPERIOD,
2042 +               &ctrl_set_video_encode_param_output,
2043 +               false
2044         },
2045  };
2046
2047  int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev)
2048  {
2049         int c;
2050 -       int ret;
2051 +       int ret = 0;
2052
2053         for (c = 0; c < V4L2_CTRL_COUNT; c++) {
2054                 if ((dev->ctrls[c]) && (v4l2_ctrls[c].setter)) {
2055                         ret = v4l2_ctrls[c].setter(dev, dev->ctrls[c],
2056                                                    &v4l2_ctrls[c]);
2057 -                       if (ret)
2058 +                       if (!v4l2_ctrls[c].ignore_errors && ret) {
2059 +                               v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
2060 +                                       "Failed when setting default values for ctrl %d\n",
2061 +                                       c);
2062                                 break;
2063 +                       }
2064                 }
2065         }
2066         return ret;
2067  }
2068
2069 +int set_framerate_params(struct bm2835_mmal_dev *dev)
2070 +{
2071 +       struct mmal_parameter_fps_range fps_range;
2072 +       int ret;
2073 +
2074 +       if ((dev->exposure_mode_active != MMAL_PARAM_EXPOSUREMODE_OFF) &&
2075 +            (dev->exp_auto_priority)) {
2076 +               /* Variable FPS. Define min FPS as 1fps.
2077 +                * Max as max defined FPS.
2078 +                */
2079 +               fps_range.fps_low.num = 1;
2080 +               fps_range.fps_low.den = 1;
2081 +               fps_range.fps_high.num = dev->capture.timeperframe.denominator;
2082 +               fps_range.fps_high.den = dev->capture.timeperframe.numerator;
2083 +       } else {
2084 +               /* Fixed FPS - set min and max to be the same */
2085 +               fps_range.fps_low.num = fps_range.fps_high.num =
2086 +                       dev->capture.timeperframe.denominator;
2087 +               fps_range.fps_low.den = fps_range.fps_high.den =
2088 +                       dev->capture.timeperframe.numerator;
2089 +       }
2090 +
2091 +       v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
2092 +                        "Set fps range to %d/%d to %d/%d\n",
2093 +                        fps_range.fps_low.num,
2094 +                        fps_range.fps_low.den,
2095 +                        fps_range.fps_high.num,
2096 +                        fps_range.fps_high.den
2097 +                );
2098 +
2099 +       ret = vchiq_mmal_port_parameter_set(dev->instance,
2100 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
2101 +                                       output[MMAL_CAMERA_PORT_PREVIEW],
2102 +                                     MMAL_PARAMETER_FPS_RANGE,
2103 +                                     &fps_range, sizeof(fps_range));
2104 +       ret += vchiq_mmal_port_parameter_set(dev->instance,
2105 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
2106 +                                       output[MMAL_CAMERA_PORT_VIDEO],
2107 +                                     MMAL_PARAMETER_FPS_RANGE,
2108 +                                     &fps_range, sizeof(fps_range));
2109 +       ret += vchiq_mmal_port_parameter_set(dev->instance,
2110 +                                     &dev->component[MMAL_COMPONENT_CAMERA]->
2111 +                                       output[MMAL_CAMERA_PORT_CAPTURE],
2112 +                                     MMAL_PARAMETER_FPS_RANGE,
2113 +                                     &fps_range, sizeof(fps_range));
2114 +       if (ret)
2115 +               v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
2116 +                "Failed to set fps ret %d\n",
2117 +                ret);
2118 +
2119 +       return ret;
2120 +
2121 +}
2122 +
2123  int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
2124                               struct v4l2_ctrl_handler *hdl)
2125  {
2126 @@ -674,10 +1251,30 @@ int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
2127                         break;
2128
2129                 case MMAL_CONTROL_TYPE_STD_MENU:
2130 +               {
2131 +                       int mask = ctrl->min;
2132 +
2133 +                       if (ctrl->id == V4L2_CID_SCENE_MODE) {
2134 +                               /* Special handling to work out the mask
2135 +                                * value based on the scene_configs array
2136 +                                * at runtime. Reduces the chance of
2137 +                                * mismatches.
2138 +                                */
2139 +                               int i;
2140 +                               mask = 1<<V4L2_SCENE_MODE_NONE;
2141 +                               for (i = 0;
2142 +                                    i < ARRAY_SIZE(scene_configs);
2143 +                                    i++) {
2144 +                                       mask |= 1<<scene_configs[i].v4l2_scene;
2145 +                               }
2146 +                               mask = ~mask;
2147 +                       }
2148 +
2149                         dev->ctrls[c] = v4l2_ctrl_new_std_menu(hdl,
2150                         &bm2835_mmal_ctrl_ops, ctrl->id,
2151 -                       ctrl->max, ctrl->min, ctrl->def);
2152 +                       ctrl->max, mask, ctrl->def);
2153                         break;
2154 +               }
2155
2156                 case MMAL_CONTROL_TYPE_INT_MENU:
2157                         dev->ctrls[c] = v4l2_ctrl_new_int_menu(hdl,
2158 diff --git a/drivers/media/platform/bcm2835/mmal-common.h b/drivers/media/platform/bcm2835/mmal-common.h
2159 index 84abbb3..35698c8 100644
2160 --- a/drivers/media/platform/bcm2835/mmal-common.h
2161 +++ b/drivers/media/platform/bcm2835/mmal-common.h
2162 @@ -26,6 +26,7 @@
2163  struct mmal_fmt {
2164         char  *name;
2165         u32   fourcc;          /* v4l2 format id */
2166 +       int   flags;           /* v4l2 flags field */
2167         u32   mmal;
2168         int   depth;
2169         u32   mmal_component;  /* MMAL component index to be used to encode */
2170 diff --git a/drivers/media/platform/bcm2835/mmal-encodings.h b/drivers/media/platform/bcm2835/mmal-encodings.h
2171 index 856e80e..024d620 100644
2172 --- a/drivers/media/platform/bcm2835/mmal-encodings.h
2173 +++ b/drivers/media/platform/bcm2835/mmal-encodings.h
2174 @@ -12,6 +12,8 @@
2175   *          Simon Mellor <simellor@broadcom.com>
2176   *          Luke Diamand <luked@broadcom.com>
2177   */
2178 +#ifndef MMAL_ENCODINGS_H
2179 +#define MMAL_ENCODINGS_H
2180
2181  #define MMAL_ENCODING_H264             MMAL_FOURCC('H', '2', '6', '4')
2182  #define MMAL_ENCODING_H263             MMAL_FOURCC('H', '2', '6', '3')
2183 @@ -27,6 +29,7 @@
2184  #define MMAL_ENCODING_VP6              MMAL_FOURCC('V', 'P', '6', ' ')
2185  #define MMAL_ENCODING_THEORA           MMAL_FOURCC('T', 'H', 'E', 'O')
2186  #define MMAL_ENCODING_SPARK            MMAL_FOURCC('S', 'P', 'R', 'K')
2187 +#define MMAL_ENCODING_MJPEG            MMAL_FOURCC('M', 'J', 'P', 'G')
2188
2189  #define MMAL_ENCODING_JPEG             MMAL_FOURCC('J', 'P', 'E', 'G')
2190  #define MMAL_ENCODING_GIF              MMAL_FOURCC('G', 'I', 'F', ' ')
2191 @@ -91,3 +94,34 @@
2192  #define MMAL_ENCODING_VARIANT_H264_AVC1      MMAL_FOURCC('A', 'V', 'C', '1')
2193  /** Implicitly delineated NAL units without emulation prevention */
2194  #define MMAL_ENCODING_VARIANT_H264_RAW       MMAL_FOURCC('R', 'A', 'W', ' ')
2195 +
2196 +
2197 +/** \defgroup MmalColorSpace List of pre-defined video color spaces
2198 + * This defines a list of common color spaces. This list isn't exhaustive and
2199 + * is only provided as a convenience to avoid clients having to use FourCC
2200 + * codes directly. However components are allowed to define and use their own
2201 + * FourCC codes.
2202 + */
2203 +/* @{ */
2204 +
2205 +/** Unknown color space */
2206 +#define MMAL_COLOR_SPACE_UNKNOWN       0
2207 +/** ITU-R BT.601-5 [SDTV] */
2208 +#define MMAL_COLOR_SPACE_ITUR_BT601    MMAL_FOURCC('Y', '6', '0', '1')
2209 +/** ITU-R BT.709-3 [HDTV] */
2210 +#define MMAL_COLOR_SPACE_ITUR_BT709    MMAL_FOURCC('Y', '7', '0', '9')
2211 +/** JPEG JFIF */
2212 +#define MMAL_COLOR_SPACE_JPEG_JFIF     MMAL_FOURCC('Y', 'J', 'F', 'I')
2213 +/** Title 47 Code of Federal Regulations (2003) 73.682 (a) (20) */
2214 +#define MMAL_COLOR_SPACE_FCC           MMAL_FOURCC('Y', 'F', 'C', 'C')
2215 +/** Society of Motion Picture and Television Engineers 240M (1999) */
2216 +#define MMAL_COLOR_SPACE_SMPTE240M     MMAL_FOURCC('Y', '2', '4', '0')
2217 +/** ITU-R BT.470-2 System M */
2218 +#define MMAL_COLOR_SPACE_BT470_2_M     MMAL_FOURCC('Y', '_', '_', 'M')
2219 +/** ITU-R BT.470-2 System BG */
2220 +#define MMAL_COLOR_SPACE_BT470_2_BG    MMAL_FOURCC('Y', '_', 'B', 'G')
2221 +/** JPEG JFIF, but with 16..255 luma */
2222 +#define MMAL_COLOR_SPACE_JFIF_Y16_255  MMAL_FOURCC('Y', 'Y', '1', '6')
2223 +/* @} MmalColorSpace List */
2224 +
2225 +#endif /* MMAL_ENCODINGS_H */
2226 diff --git a/drivers/media/platform/bcm2835/mmal-parameters.h b/drivers/media/platform/bcm2835/mmal-parameters.h
2227 index c611b58..aa0fd18 100644
2228 --- a/drivers/media/platform/bcm2835/mmal-parameters.h
2229 +++ b/drivers/media/platform/bcm2835/mmal-parameters.h
2230 @@ -57,7 +57,8 @@ enum mmal_parameter_common_type {
2231         MMAL_PARAMETER_SEEK, /**< MMAL_PARAMETER_SEEK_T */
2232         MMAL_PARAMETER_POWERMON_ENABLE, /**< MMAL_PARAMETER_BOOLEAN_T */
2233         MMAL_PARAMETER_LOGGING, /**< MMAL_PARAMETER_LOGGING_T */
2234 -       MMAL_PARAMETER_SYSTEM_TIME /**< MMAL_PARAMETER_UINT64_T */
2235 +       MMAL_PARAMETER_SYSTEM_TIME, /**< MMAL_PARAMETER_UINT64_T */
2236 +       MMAL_PARAMETER_NO_IMAGE_PADDING  /**< MMAL_PARAMETER_BOOLEAN_T */
2237  };
2238
2239  /* camera parameters */
2240 @@ -161,6 +162,13 @@ enum mmal_parameter_camera_type {
2241         MMAL_PARAMETER_SW_SHARPEN_DISABLE, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2242         MMAL_PARAMETER_FLASH_REQUIRED, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2243         MMAL_PARAMETER_SW_SATURATION_DISABLE, /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2244 +       MMAL_PARAMETER_SHUTTER_SPEED,             /**< Takes a @ref MMAL_PARAMETER_UINT32_T */
2245 +       MMAL_PARAMETER_CUSTOM_AWB_GAINS,          /**< Takes a @ref MMAL_PARAMETER_AWB_GAINS_T */
2246 +};
2247 +
2248 +struct mmal_parameter_rational {
2249 +       s32 num;    /**< Numerator */
2250 +       s32 den;    /**< Denominator */
2251  };
2252
2253  enum mmal_parameter_camera_config_timestamp_mode {
2254 @@ -176,6 +184,14 @@ enum mmal_parameter_camera_config_timestamp_mode {
2255                                               */
2256  };
2257
2258 +struct mmal_parameter_fps_range {
2259 +       /**< Low end of the permitted framerate range */
2260 +       struct mmal_parameter_rational  fps_low;
2261 +       /**< High end of the permitted framerate range */
2262 +       struct mmal_parameter_rational  fps_high;
2263 +};
2264 +
2265 +
2266  /* camera configuration parameter */
2267  struct mmal_parameter_camera_config {
2268         /* Parameters for setting up the image pools */
2269 @@ -270,6 +286,19 @@ enum mmal_parameter_imagefx {
2270         MMAL_PARAM_IMAGEFX_CARTOON,
2271  };
2272
2273 +enum MMAL_PARAM_FLICKERAVOID_T {
2274 +       MMAL_PARAM_FLICKERAVOID_OFF,
2275 +       MMAL_PARAM_FLICKERAVOID_AUTO,
2276 +       MMAL_PARAM_FLICKERAVOID_50HZ,
2277 +       MMAL_PARAM_FLICKERAVOID_60HZ,
2278 +       MMAL_PARAM_FLICKERAVOID_MAX = 0x7FFFFFFF
2279 +};
2280 +
2281 +struct mmal_parameter_awbgains {
2282 +       struct mmal_parameter_rational r_gain;  /**< Red gain */
2283 +       struct mmal_parameter_rational b_gain;  /**< Blue gain */
2284 +};
2285 +
2286  /** Manner of video rate control */
2287  enum mmal_parameter_rate_control_mode {
2288         MMAL_VIDEO_RATECONTROL_DEFAULT,
2289 @@ -279,6 +308,85 @@ enum mmal_parameter_rate_control_mode {
2290         MMAL_VIDEO_RATECONTROL_CONSTANT_SKIP_FRAMES
2291  };
2292
2293 +enum mmal_video_profile {
2294 +       MMAL_VIDEO_PROFILE_H263_BASELINE,
2295 +       MMAL_VIDEO_PROFILE_H263_H320CODING,
2296 +       MMAL_VIDEO_PROFILE_H263_BACKWARDCOMPATIBLE,
2297 +       MMAL_VIDEO_PROFILE_H263_ISWV2,
2298 +       MMAL_VIDEO_PROFILE_H263_ISWV3,
2299 +       MMAL_VIDEO_PROFILE_H263_HIGHCOMPRESSION,
2300 +       MMAL_VIDEO_PROFILE_H263_INTERNET,
2301 +       MMAL_VIDEO_PROFILE_H263_INTERLACE,
2302 +       MMAL_VIDEO_PROFILE_H263_HIGHLATENCY,
2303 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLE,
2304 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLESCALABLE,
2305 +       MMAL_VIDEO_PROFILE_MP4V_CORE,
2306 +       MMAL_VIDEO_PROFILE_MP4V_MAIN,
2307 +       MMAL_VIDEO_PROFILE_MP4V_NBIT,
2308 +       MMAL_VIDEO_PROFILE_MP4V_SCALABLETEXTURE,
2309 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLEFACE,
2310 +       MMAL_VIDEO_PROFILE_MP4V_SIMPLEFBA,
2311 +       MMAL_VIDEO_PROFILE_MP4V_BASICANIMATED,
2312 +       MMAL_VIDEO_PROFILE_MP4V_HYBRID,
2313 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDREALTIME,
2314 +       MMAL_VIDEO_PROFILE_MP4V_CORESCALABLE,
2315 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCODING,
2316 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDCORE,
2317 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSCALABLE,
2318 +       MMAL_VIDEO_PROFILE_MP4V_ADVANCEDSIMPLE,
2319 +       MMAL_VIDEO_PROFILE_H264_BASELINE,
2320 +       MMAL_VIDEO_PROFILE_H264_MAIN,
2321 +       MMAL_VIDEO_PROFILE_H264_EXTENDED,
2322 +       MMAL_VIDEO_PROFILE_H264_HIGH,
2323 +       MMAL_VIDEO_PROFILE_H264_HIGH10,
2324 +       MMAL_VIDEO_PROFILE_H264_HIGH422,
2325 +       MMAL_VIDEO_PROFILE_H264_HIGH444,
2326 +       MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE,
2327 +       MMAL_VIDEO_PROFILE_DUMMY = 0x7FFFFFFF
2328 +};
2329 +
2330 +enum mmal_video_level {
2331 +       MMAL_VIDEO_LEVEL_H263_10,
2332 +       MMAL_VIDEO_LEVEL_H263_20,
2333 +       MMAL_VIDEO_LEVEL_H263_30,
2334 +       MMAL_VIDEO_LEVEL_H263_40,
2335 +       MMAL_VIDEO_LEVEL_H263_45,
2336 +       MMAL_VIDEO_LEVEL_H263_50,
2337 +       MMAL_VIDEO_LEVEL_H263_60,
2338 +       MMAL_VIDEO_LEVEL_H263_70,
2339 +       MMAL_VIDEO_LEVEL_MP4V_0,
2340 +       MMAL_VIDEO_LEVEL_MP4V_0b,
2341 +       MMAL_VIDEO_LEVEL_MP4V_1,
2342 +       MMAL_VIDEO_LEVEL_MP4V_2,
2343 +       MMAL_VIDEO_LEVEL_MP4V_3,
2344 +       MMAL_VIDEO_LEVEL_MP4V_4,
2345 +       MMAL_VIDEO_LEVEL_MP4V_4a,
2346 +       MMAL_VIDEO_LEVEL_MP4V_5,
2347 +       MMAL_VIDEO_LEVEL_MP4V_6,
2348 +       MMAL_VIDEO_LEVEL_H264_1,
2349 +       MMAL_VIDEO_LEVEL_H264_1b,
2350 +       MMAL_VIDEO_LEVEL_H264_11,
2351 +       MMAL_VIDEO_LEVEL_H264_12,
2352 +       MMAL_VIDEO_LEVEL_H264_13,
2353 +       MMAL_VIDEO_LEVEL_H264_2,
2354 +       MMAL_VIDEO_LEVEL_H264_21,
2355 +       MMAL_VIDEO_LEVEL_H264_22,
2356 +       MMAL_VIDEO_LEVEL_H264_3,
2357 +       MMAL_VIDEO_LEVEL_H264_31,
2358 +       MMAL_VIDEO_LEVEL_H264_32,
2359 +       MMAL_VIDEO_LEVEL_H264_4,
2360 +       MMAL_VIDEO_LEVEL_H264_41,
2361 +       MMAL_VIDEO_LEVEL_H264_42,
2362 +       MMAL_VIDEO_LEVEL_H264_5,
2363 +       MMAL_VIDEO_LEVEL_H264_51,
2364 +       MMAL_VIDEO_LEVEL_DUMMY = 0x7FFFFFFF
2365 +};
2366 +
2367 +struct mmal_parameter_video_profile {
2368 +       enum mmal_video_profile profile;
2369 +       enum mmal_video_level level;
2370 +};
2371 +
2372  /* video parameters */
2373
2374  enum mmal_parameter_video_type {
2375 @@ -407,7 +515,16 @@ enum mmal_parameter_video_type {
2376         MMAL_PARAMETER_VIDEO_DRM_PROTECT_BUFFER,
2377
2378         /** @ref MMAL_PARAMETER_BYTES_T */
2379 -       MMAL_PARAMETER_VIDEO_DECODE_CONFIG_VD3
2380 +       MMAL_PARAMETER_VIDEO_DECODE_CONFIG_VD3,
2381 +
2382 +       /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2383 +       MMAL_PARAMETER_VIDEO_ENCODE_H264_VCL_HRD_PARAMETERS,
2384 +
2385 +       /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2386 +       MMAL_PARAMETER_VIDEO_ENCODE_H264_LOW_DELAY_HRD_FLAG,
2387 +
2388 +       /**< @ref MMAL_PARAMETER_BOOLEAN_T */
2389 +       MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER
2390  };
2391
2392  /** Valid mirror modes */
2393 diff --git a/drivers/media/platform/bcm2835/mmal-vchiq.c b/drivers/media/platform/bcm2835/mmal-vchiq.c
2394 index a06fb44..76f249e 100644
2395 --- a/drivers/media/platform/bcm2835/mmal-vchiq.c
2396 +++ b/drivers/media/platform/bcm2835/mmal-vchiq.c
2397 @@ -742,7 +742,7 @@ static int send_synchronous_mmal_msg(struct vchiq_mmal_instance *instance,
2398                 return ret;
2399         }
2400
2401 -       ret = wait_for_completion_timeout(&msg_context.u.sync.cmplt, HZ);
2402 +       ret = wait_for_completion_timeout(&msg_context.u.sync.cmplt, 3*HZ);
2403         if (ret <= 0) {
2404                 pr_err("error %d waiting for sync completion\n", ret);
2405                 if (ret == 0)
2406 @@ -1326,7 +1326,7 @@ static int port_parameter_get(struct vchiq_mmal_instance *instance,
2407                 memcpy(value, &rmsg->u.port_parameter_get_reply.value,
2408                        rmsg->u.port_parameter_get_reply.size);
2409
2410 -       pr_info("%s:result:%d component:0x%x port:%d parameter:%d\n", __func__,
2411 +       pr_debug("%s:result:%d component:0x%x port:%d parameter:%d\n", __func__,
2412                 ret, port->component->handle, port->handle, parameter_id);
2413
2414  release_msg:
2415 --
2416 1.8.3.2
2417