drivers/staging/vc04_services/bcm2835-camera/controls.c

   1 /*
   2  * Broadcom BM2835 V4L2 driver
   3  *
   4  * Copyright © 2013 Raspberry Pi (Trading) Ltd.
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  *
  10  * Authors: Vincent Sanders <vincent.sanders@collabora.co.uk>
  11  *          Dave Stevenson <dsteve@broadcom.com>
  12  *          Simon Mellor <simellor@broadcom.com>
  13  *          Luke Diamand <luked@broadcom.com>
  14  */
  15
  16 #include <linux/errno.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/slab.h>
  20 #include <media/videobuf2-vmalloc.h>
  21 #include <media/v4l2-device.h>
  22 #include <media/v4l2-ioctl.h>
  23 #include <media/v4l2-ctrls.h>
  24 #include <media/v4l2-fh.h>
  25 #include <media/v4l2-event.h>
  26 #include <media/v4l2-common.h>
  27
  28 #include "mmal-common.h"
  29 #include "mmal-vchiq.h"
  30 #include "mmal-parameters.h"
  31 #include "bcm2835-camera.h"
  32
  33 /* The supported V4L2_CID_AUTO_EXPOSURE_BIAS values are from -4.0 to +4.0.
  34  * MMAL values are in 1/6th increments so the MMAL range is -24 to +24.
  35  * V4L2 docs say value "is expressed in terms of EV, drivers should interpret
  36  * the values as 0.001 EV units, where the value 1000 stands for +1 EV."
  37  * V4L2 is limited to a max of 32 values in a menu, so count in 1/3rds from
  38  * -4 to +4
  39  */
  40 static const s64 ev_bias_qmenu[] = {
  41         -4000, -3667, -3333,
  42         -3000, -2667, -2333,
  43         -2000, -1667, -1333,
  44         -1000,  -667,  -333,
  45             0,   333,   667,
  46          1000,  1333,  1667,
  47          2000,  2333,  2667,
  48          3000,  3333,  3667,
  49          4000
  50 };
  51
  52 /* Supported ISO values (*1000)
  53  * ISOO = auto ISO
  54  */
  55 static const s64 iso_qmenu[] = {
  56         0, 100000, 200000, 400000, 800000,
  57 };
  58 static const uint32_t iso_values[] = {
  59         0, 100, 200, 400, 800,
  60 };
  61
  62 static const s64 mains_freq_qmenu[] = {
  63         V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
  64         V4L2_CID_POWER_LINE_FREQUENCY_50HZ,
  65         V4L2_CID_POWER_LINE_FREQUENCY_60HZ,
  66         V4L2_CID_POWER_LINE_FREQUENCY_AUTO
  67 };
  68
  69 /* Supported video encode modes */
  70 static const s64 bitrate_mode_qmenu[] = {
  71         (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
  72         (s64)V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
  73 };
  74
  75 enum bm2835_mmal_ctrl_type {
  76         MMAL_CONTROL_TYPE_STD,
  77         MMAL_CONTROL_TYPE_STD_MENU,
  78         MMAL_CONTROL_TYPE_INT_MENU,
  79         MMAL_CONTROL_TYPE_CLUSTER, /* special cluster entry */
  80 };
  81
  82 struct bm2835_mmal_v4l2_ctrl;
  83
  84 typedef int(bm2835_mmal_v4l2_ctrl_cb)(
  85                                 struct bm2835_mmal_dev *dev,
  86                                 struct v4l2_ctrl *ctrl,
  87                                 const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl);
  88
  89 struct bm2835_mmal_v4l2_ctrl {
  90         u32 id; /* v4l2 control identifier */
  91         enum bm2835_mmal_ctrl_type type;
  92         /* control minimum value or
  93          * mask for MMAL_CONTROL_TYPE_STD_MENU
  94          */
  95         s32 min;
  96         s32 max; /* maximum value of control */
  97         s32 def;  /* default value of control */
  98         s32 step; /* step size of the control */
  99         const s64 *imenu; /* integer menu array */
 100         u32 mmal_id; /* mmal parameter id */
 101         bm2835_mmal_v4l2_ctrl_cb *setter;
 102         bool ignore_errors;
 103 };
 104
 105 struct v4l2_to_mmal_effects_setting {
 106         u32 v4l2_effect;
 107         u32 mmal_effect;
 108         s32 col_fx_enable;
 109         s32 col_fx_fixed_cbcr;
 110         u32 u;
 111         u32 v;
 112         u32 num_effect_params;
 113         u32 effect_params[MMAL_MAX_IMAGEFX_PARAMETERS];
 114 };
 115
 116 static const struct v4l2_to_mmal_effects_setting
 117         v4l2_to_mmal_effects_values[] = {
 118         {  V4L2_COLORFX_NONE,         MMAL_PARAM_IMAGEFX_NONE,
 119                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 120         {  V4L2_COLORFX_BW,           MMAL_PARAM_IMAGEFX_NONE,
 121                 1,   0,    128,  128, 0, {0, 0, 0, 0, 0} },
 122         {  V4L2_COLORFX_SEPIA,        MMAL_PARAM_IMAGEFX_NONE,
 123                 1,   0,    87,   151, 0, {0, 0, 0, 0, 0} },
 124         {  V4L2_COLORFX_NEGATIVE,     MMAL_PARAM_IMAGEFX_NEGATIVE,
 125                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 126         {  V4L2_COLORFX_EMBOSS,       MMAL_PARAM_IMAGEFX_EMBOSS,
 127                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 128         {  V4L2_COLORFX_SKETCH,       MMAL_PARAM_IMAGEFX_SKETCH,
 129                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 130         {  V4L2_COLORFX_SKY_BLUE,     MMAL_PARAM_IMAGEFX_PASTEL,
 131                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 132         {  V4L2_COLORFX_GRASS_GREEN,  MMAL_PARAM_IMAGEFX_WATERCOLOUR,
 133                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 134         {  V4L2_COLORFX_SKIN_WHITEN,  MMAL_PARAM_IMAGEFX_WASHEDOUT,
 135                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 136         {  V4L2_COLORFX_VIVID,        MMAL_PARAM_IMAGEFX_SATURATION,
 137                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 138         {  V4L2_COLORFX_AQUA,         MMAL_PARAM_IMAGEFX_NONE,
 139                 1,   0,    171,  121, 0, {0, 0, 0, 0, 0} },
 140         {  V4L2_COLORFX_ART_FREEZE,   MMAL_PARAM_IMAGEFX_HATCH,
 141                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 142         {  V4L2_COLORFX_SILHOUETTE,   MMAL_PARAM_IMAGEFX_FILM,
 143                 0,   0,    0,    0,   0, {0, 0, 0, 0, 0} },
 144         {  V4L2_COLORFX_SOLARIZATION, MMAL_PARAM_IMAGEFX_SOLARIZE,
 145                 0,   0,    0,    0,   5, {1, 128, 160, 160, 48} },
 146         {  V4L2_COLORFX_ANTIQUE,      MMAL_PARAM_IMAGEFX_COLOURBALANCE,
 147                 0,   0,    0,    0,   3, {108, 274, 238, 0, 0} },
 148         {  V4L2_COLORFX_SET_CBCR,     MMAL_PARAM_IMAGEFX_NONE,
 149                 1,   1,    0,    0,   0, {0, 0, 0, 0, 0} }
 150 };
 151
 152 struct v4l2_mmal_scene_config {
 153         enum v4l2_scene_mode                    v4l2_scene;
 154         enum mmal_parameter_exposuremode        exposure_mode;
 155         enum mmal_parameter_exposuremeteringmode metering_mode;
 156 };
 157
 158 static const struct v4l2_mmal_scene_config scene_configs[] = {
 159         /* V4L2_SCENE_MODE_NONE automatically added */
 160         {
 161                 V4L2_SCENE_MODE_NIGHT,
 162                 MMAL_PARAM_EXPOSUREMODE_NIGHT,
 163                 MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
 164         },
 165         {
 166                 V4L2_SCENE_MODE_SPORTS,
 167                 MMAL_PARAM_EXPOSUREMODE_SPORTS,
 168                 MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE
 169         },
 170 };
 171
 172 /* control handlers*/
 173
 174 static int ctrl_set_rational(struct bm2835_mmal_dev *dev,
 175                              struct v4l2_ctrl *ctrl,
 176                              const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 177 {
 178         struct mmal_parameter_rational rational_value;
 179         struct vchiq_mmal_port *control;
 180
 181         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 182
 183         rational_value.num = ctrl->val;
 184         rational_value.den = 100;
 185
 186         return vchiq_mmal_port_parameter_set(dev->instance, control,
 187                                              mmal_ctrl->mmal_id,
 188                                              &rational_value,
 189                                              sizeof(rational_value));
 190 }
 191
 192 static int ctrl_set_value(struct bm2835_mmal_dev *dev,
 193                           struct v4l2_ctrl *ctrl,
 194                           const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 195 {
 196         u32 u32_value;
 197         struct vchiq_mmal_port *control;
 198
 199         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 200
 201         u32_value = ctrl->val;
 202
 203         return vchiq_mmal_port_parameter_set(dev->instance, control,
 204                                              mmal_ctrl->mmal_id,
 205                                              &u32_value, sizeof(u32_value));
 206 }
 207
 208 static int ctrl_set_iso(struct bm2835_mmal_dev *dev,
 209                         struct v4l2_ctrl *ctrl,
 210                         const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 211 {
 212         u32 u32_value;
 213         struct vchiq_mmal_port *control;
 214
 215         if (ctrl->val > mmal_ctrl->max || ctrl->val < mmal_ctrl->min)
 216                 return 1;
 217
 218         if (ctrl->id == V4L2_CID_ISO_SENSITIVITY)
 219                 dev->iso = iso_values[ctrl->val];
 220         else if (ctrl->id == V4L2_CID_ISO_SENSITIVITY_AUTO)
 221                 dev->manual_iso_enabled =
 222                                 (ctrl->val == V4L2_ISO_SENSITIVITY_MANUAL);
 223
 224         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 225
 226         if (dev->manual_iso_enabled)
 227                 u32_value = dev->iso;
 228         else
 229                 u32_value = 0;
 230
 231         return vchiq_mmal_port_parameter_set(dev->instance, control,
 232                                              MMAL_PARAMETER_ISO,
 233                                              &u32_value, sizeof(u32_value));
 234 }
 235
 236 static int ctrl_set_value_ev(struct bm2835_mmal_dev *dev,
 237                              struct v4l2_ctrl *ctrl,
 238                              const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 239 {
 240         s32 s32_value;
 241         struct vchiq_mmal_port *control;
 242
 243         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 244
 245         s32_value = (ctrl->val - 12) * 2;       /* Convert from index to 1/6ths */
 246
 247         return vchiq_mmal_port_parameter_set(dev->instance, control,
 248                                              mmal_ctrl->mmal_id,
 249                                              &s32_value, sizeof(s32_value));
 250 }
 251
 252 static int ctrl_set_rotate(struct bm2835_mmal_dev *dev,
 253                            struct v4l2_ctrl *ctrl,
 254                            const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 255 {
 256         int ret;
 257         u32 u32_value;
 258         struct vchiq_mmal_component *camera;
 259
 260         camera = dev->component[MMAL_COMPONENT_CAMERA];
 261
 262         u32_value = ((ctrl->val % 360) / 90) * 90;
 263
 264         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[0],
 265                                             mmal_ctrl->mmal_id,
 266                                             &u32_value, sizeof(u32_value));
 267         if (ret < 0)
 268                 return ret;
 269
 270         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[1],
 271                                             mmal_ctrl->mmal_id,
 272                                             &u32_value, sizeof(u32_value));
 273         if (ret < 0)
 274                 return ret;
 275
 276         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[2],
 277                                             mmal_ctrl->mmal_id,
 278                                             &u32_value, sizeof(u32_value));
 279
 280         return ret;
 281 }
 282
 283 static int ctrl_set_flip(struct bm2835_mmal_dev *dev,
 284                          struct v4l2_ctrl *ctrl,
 285                          const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 286 {
 287         int ret;
 288         u32 u32_value;
 289         struct vchiq_mmal_component *camera;
 290
 291         if (ctrl->id == V4L2_CID_HFLIP)
 292                 dev->hflip = ctrl->val;
 293         else
 294                 dev->vflip = ctrl->val;
 295
 296         camera = dev->component[MMAL_COMPONENT_CAMERA];
 297
 298         if (dev->hflip && dev->vflip)
 299                 u32_value = MMAL_PARAM_MIRROR_BOTH;
 300         else if (dev->hflip)
 301                 u32_value = MMAL_PARAM_MIRROR_HORIZONTAL;
 302         else if (dev->vflip)
 303                 u32_value = MMAL_PARAM_MIRROR_VERTICAL;
 304         else
 305                 u32_value = MMAL_PARAM_MIRROR_NONE;
 306
 307         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[0],
 308                                             mmal_ctrl->mmal_id,
 309                                             &u32_value, sizeof(u32_value));
 310         if (ret < 0)
 311                 return ret;
 312
 313         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[1],
 314                                             mmal_ctrl->mmal_id,
 315                                             &u32_value, sizeof(u32_value));
 316         if (ret < 0)
 317                 return ret;
 318
 319         ret = vchiq_mmal_port_parameter_set(dev->instance, &camera->output[2],
 320                                             mmal_ctrl->mmal_id,
 321                                             &u32_value, sizeof(u32_value));
 322
 323         return ret;
 324 }
 325
 326 static int ctrl_set_exposure(struct bm2835_mmal_dev *dev,
 327                              struct v4l2_ctrl *ctrl,
 328                              const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 329 {
 330         enum mmal_parameter_exposuremode exp_mode = dev->exposure_mode_user;
 331         u32 shutter_speed = 0;
 332         struct vchiq_mmal_port *control;
 333         int ret = 0;
 334
 335         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 336
 337         if (mmal_ctrl->mmal_id == MMAL_PARAMETER_SHUTTER_SPEED) {
 338                 /* V4L2 is in 100usec increments.
 339                  * MMAL is 1usec.
 340                  */
 341                 dev->manual_shutter_speed = ctrl->val * 100;
 342         } else if (mmal_ctrl->mmal_id == MMAL_PARAMETER_EXPOSURE_MODE) {
 343                 switch (ctrl->val) {
 344                 case V4L2_EXPOSURE_AUTO:
 345                         exp_mode = MMAL_PARAM_EXPOSUREMODE_AUTO;
 346                         break;
 347
 348                 case V4L2_EXPOSURE_MANUAL:
 349                         exp_mode = MMAL_PARAM_EXPOSUREMODE_OFF;
 350                         break;
 351                 }
 352                 dev->exposure_mode_user = exp_mode;
 353                 dev->exposure_mode_v4l2_user = ctrl->val;
 354         } else if (mmal_ctrl->id == V4L2_CID_EXPOSURE_AUTO_PRIORITY) {
 355                 dev->exp_auto_priority = ctrl->val;
 356         }
 357
 358         if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
 359                 if (exp_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
 360                         shutter_speed = dev->manual_shutter_speed;
 361
 362                 ret = vchiq_mmal_port_parameter_set(dev->instance,
 363                                                     control,
 364                                                     MMAL_PARAMETER_SHUTTER_SPEED,
 365                                                     &shutter_speed,
 366                                                     sizeof(shutter_speed));
 367                 ret += vchiq_mmal_port_parameter_set(dev->instance,
 368                                                      control,
 369                                                      MMAL_PARAMETER_EXPOSURE_MODE,
 370                                                      &exp_mode,
 371                                                      sizeof(u32));
 372                 dev->exposure_mode_active = exp_mode;
 373         }
 374         /* exposure_dynamic_framerate (V4L2_CID_EXPOSURE_AUTO_PRIORITY) should
 375          * always apply irrespective of scene mode.
 376          */
 377         ret += set_framerate_params(dev);
 378
 379         return ret;
 380 }
 381
 382 static int ctrl_set_metering_mode(struct bm2835_mmal_dev *dev,
 383                                   struct v4l2_ctrl *ctrl,
 384                                   const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 385 {
 386         switch (ctrl->val) {
 387         case V4L2_EXPOSURE_METERING_AVERAGE:
 388                 dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_AVERAGE;
 389                 break;
 390
 391         case V4L2_EXPOSURE_METERING_CENTER_WEIGHTED:
 392                 dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_BACKLIT;
 393                 break;
 394
 395         case V4L2_EXPOSURE_METERING_SPOT:
 396                 dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_SPOT;
 397                 break;
 398
 399         /* todo matrix weighting not added to Linux API till 3.9
 400          * case V4L2_EXPOSURE_METERING_MATRIX:
 401          *      dev->metering_mode = MMAL_PARAM_EXPOSUREMETERINGMODE_MATRIX;
 402          *      break;
 403          */
 404         }
 405
 406         if (dev->scene_mode == V4L2_SCENE_MODE_NONE) {
 407                 struct vchiq_mmal_port *control;
 408                 u32 u32_value = dev->metering_mode;
 409
 410                 control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 411
 412                 return vchiq_mmal_port_parameter_set(dev->instance, control,
 413                                              mmal_ctrl->mmal_id,
 414                                              &u32_value, sizeof(u32_value));
 415         } else
 416                 return 0;
 417 }
 418
 419 static int ctrl_set_flicker_avoidance(struct bm2835_mmal_dev *dev,
 420                                       struct v4l2_ctrl *ctrl,
 421                                       const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 422 {
 423         u32 u32_value;
 424         struct vchiq_mmal_port *control;
 425
 426         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 427
 428         switch (ctrl->val) {
 429         case V4L2_CID_POWER_LINE_FREQUENCY_DISABLED:
 430                 u32_value = MMAL_PARAM_FLICKERAVOID_OFF;
 431                 break;
 432         case V4L2_CID_POWER_LINE_FREQUENCY_50HZ:
 433                 u32_value = MMAL_PARAM_FLICKERAVOID_50HZ;
 434                 break;
 435         case V4L2_CID_POWER_LINE_FREQUENCY_60HZ:
 436                 u32_value = MMAL_PARAM_FLICKERAVOID_60HZ;
 437                 break;
 438         case V4L2_CID_POWER_LINE_FREQUENCY_AUTO:
 439                 u32_value = MMAL_PARAM_FLICKERAVOID_AUTO;
 440                 break;
 441         }
 442
 443         return vchiq_mmal_port_parameter_set(dev->instance, control,
 444                                              mmal_ctrl->mmal_id,
 445                                              &u32_value, sizeof(u32_value));
 446 }
 447
 448 static int ctrl_set_awb_mode(struct bm2835_mmal_dev *dev,
 449                              struct v4l2_ctrl *ctrl,
 450                              const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 451 {
 452         u32 u32_value;
 453         struct vchiq_mmal_port *control;
 454
 455         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 456
 457         switch (ctrl->val) {
 458         case V4L2_WHITE_BALANCE_MANUAL:
 459                 u32_value = MMAL_PARAM_AWBMODE_OFF;
 460                 break;
 461
 462         case V4L2_WHITE_BALANCE_AUTO:
 463                 u32_value = MMAL_PARAM_AWBMODE_AUTO;
 464                 break;
 465
 466         case V4L2_WHITE_BALANCE_INCANDESCENT:
 467                 u32_value = MMAL_PARAM_AWBMODE_INCANDESCENT;
 468                 break;
 469
 470         case V4L2_WHITE_BALANCE_FLUORESCENT:
 471                 u32_value = MMAL_PARAM_AWBMODE_FLUORESCENT;
 472                 break;
 473
 474         case V4L2_WHITE_BALANCE_FLUORESCENT_H:
 475                 u32_value = MMAL_PARAM_AWBMODE_TUNGSTEN;
 476                 break;
 477
 478         case V4L2_WHITE_BALANCE_HORIZON:
 479                 u32_value = MMAL_PARAM_AWBMODE_HORIZON;
 480                 break;
 481
 482         case V4L2_WHITE_BALANCE_DAYLIGHT:
 483                 u32_value = MMAL_PARAM_AWBMODE_SUNLIGHT;
 484                 break;
 485
 486         case V4L2_WHITE_BALANCE_FLASH:
 487                 u32_value = MMAL_PARAM_AWBMODE_FLASH;
 488                 break;
 489
 490         case V4L2_WHITE_BALANCE_CLOUDY:
 491                 u32_value = MMAL_PARAM_AWBMODE_CLOUDY;
 492                 break;
 493
 494         case V4L2_WHITE_BALANCE_SHADE:
 495                 u32_value = MMAL_PARAM_AWBMODE_SHADE;
 496                 break;
 497         }
 498
 499         return vchiq_mmal_port_parameter_set(dev->instance, control,
 500                                              mmal_ctrl->mmal_id,
 501                                              &u32_value, sizeof(u32_value));
 502 }
 503
 504 static int ctrl_set_awb_gains(struct bm2835_mmal_dev *dev,
 505                               struct v4l2_ctrl *ctrl,
 506                               const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 507 {
 508         struct vchiq_mmal_port *control;
 509         struct mmal_parameter_awbgains gains;
 510
 511         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 512
 513         if (ctrl->id == V4L2_CID_RED_BALANCE)
 514                 dev->red_gain = ctrl->val;
 515         else if (ctrl->id == V4L2_CID_BLUE_BALANCE)
 516                 dev->blue_gain = ctrl->val;
 517
 518         gains.r_gain.num = dev->red_gain;
 519         gains.b_gain.num = dev->blue_gain;
 520         gains.r_gain.den = gains.b_gain.den = 1000;
 521
 522         return vchiq_mmal_port_parameter_set(dev->instance, control,
 523                                              mmal_ctrl->mmal_id,
 524                                              &gains, sizeof(gains));
 525 }
 526
 527 static int ctrl_set_image_effect(struct bm2835_mmal_dev *dev,
 528                                  struct v4l2_ctrl *ctrl,
 529                                  const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 530 {
 531         int ret = -EINVAL;
 532         int i, j;
 533         struct vchiq_mmal_port *control;
 534         struct mmal_parameter_imagefx_parameters imagefx;
 535
 536         for (i = 0; i < ARRAY_SIZE(v4l2_to_mmal_effects_values); i++) {
 537                 if (ctrl->val == v4l2_to_mmal_effects_values[i].v4l2_effect) {
 538                         imagefx.effect =
 539                                 v4l2_to_mmal_effects_values[i].mmal_effect;
 540                         imagefx.num_effect_params =
 541                                 v4l2_to_mmal_effects_values[i].num_effect_params;
 542
 543                         if (imagefx.num_effect_params > MMAL_MAX_IMAGEFX_PARAMETERS)
 544                                 imagefx.num_effect_params = MMAL_MAX_IMAGEFX_PARAMETERS;
 545
 546                         for (j = 0; j < imagefx.num_effect_params; j++)
 547                                 imagefx.effect_parameter[j] =
 548                                         v4l2_to_mmal_effects_values[i].effect_params[j];
 549
 550                         dev->colourfx.enable =
 551                                 v4l2_to_mmal_effects_values[i].col_fx_enable;
 552                         if (!v4l2_to_mmal_effects_values[i].col_fx_fixed_cbcr) {
 553                                 dev->colourfx.u =
 554                                         v4l2_to_mmal_effects_values[i].u;
 555                                 dev->colourfx.v =
 556                                         v4l2_to_mmal_effects_values[i].v;
 557                         }
 558
 559                         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 560
 561                         ret = vchiq_mmal_port_parameter_set(
 562                                         dev->instance, control,
 563                                         MMAL_PARAMETER_IMAGE_EFFECT_PARAMETERS,
 564                                         &imagefx, sizeof(imagefx));
 565                         if (ret)
 566                                 goto exit;
 567
 568                         ret = vchiq_mmal_port_parameter_set(
 569                                         dev->instance, control,
 570                                         MMAL_PARAMETER_COLOUR_EFFECT,
 571                                         &dev->colourfx, sizeof(dev->colourfx));
 572                 }
 573         }
 574
 575 exit:
 576         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 577                  "mmal_ctrl:%p ctrl id:0x%x ctrl val:%d imagefx:0x%x color_effect:%s u:%d v:%d ret %d(%d)\n",
 578                                 mmal_ctrl, ctrl->id, ctrl->val, imagefx.effect,
 579                                 dev->colourfx.enable ? "true" : "false",
 580                                 dev->colourfx.u, dev->colourfx.v,
 581                                 ret, (ret == 0 ? 0 : -EINVAL));
 582         return (ret == 0 ? 0 : -EINVAL);
 583 }
 584
 585 static int ctrl_set_colfx(struct bm2835_mmal_dev *dev,
 586                           struct v4l2_ctrl *ctrl,
 587                           const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 588 {
 589         int ret = -EINVAL;
 590         struct vchiq_mmal_port *control;
 591
 592         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 593
 594         dev->colourfx.enable = (ctrl->val & 0xff00) >> 8;
 595         dev->colourfx.enable = ctrl->val & 0xff;
 596
 597         ret = vchiq_mmal_port_parameter_set(dev->instance, control,
 598                                             MMAL_PARAMETER_COLOUR_EFFECT,
 599                                             &dev->colourfx,
 600                                             sizeof(dev->colourfx));
 601
 602         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 603                  "%s: After: mmal_ctrl:%p ctrl id:0x%x ctrl val:%d ret %d(%d)\n",
 604                         __func__, mmal_ctrl, ctrl->id, ctrl->val, ret,
 605                         (ret == 0 ? 0 : -EINVAL));
 606         return (ret == 0 ? 0 : -EINVAL);
 607 }
 608
 609 static int ctrl_set_bitrate(struct bm2835_mmal_dev *dev,
 610                             struct v4l2_ctrl *ctrl,
 611                             const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 612 {
 613         int ret;
 614         struct vchiq_mmal_port *encoder_out;
 615
 616         dev->capture.encode_bitrate = ctrl->val;
 617
 618         encoder_out = &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
 619
 620         ret = vchiq_mmal_port_parameter_set(dev->instance, encoder_out,
 621                                             mmal_ctrl->mmal_id,
 622                                             &ctrl->val, sizeof(ctrl->val));
 623         ret = 0;
 624         return ret;
 625 }
 626
 627 static int ctrl_set_bitrate_mode(struct bm2835_mmal_dev *dev,
 628                                  struct v4l2_ctrl *ctrl,
 629                                  const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 630 {
 631         u32 bitrate_mode;
 632         struct vchiq_mmal_port *encoder_out;
 633
 634         encoder_out = &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
 635
 636         dev->capture.encode_bitrate_mode = ctrl->val;
 637         switch (ctrl->val) {
 638         default:
 639         case V4L2_MPEG_VIDEO_BITRATE_MODE_VBR:
 640                 bitrate_mode = MMAL_VIDEO_RATECONTROL_VARIABLE;
 641                 break;
 642         case V4L2_MPEG_VIDEO_BITRATE_MODE_CBR:
 643                 bitrate_mode = MMAL_VIDEO_RATECONTROL_CONSTANT;
 644                 break;
 645         }
 646
 647         vchiq_mmal_port_parameter_set(dev->instance, encoder_out,
 648                                       mmal_ctrl->mmal_id,
 649                                              &bitrate_mode,
 650                                              sizeof(bitrate_mode));
 651         return 0;
 652 }
 653
 654 static int ctrl_set_image_encode_output(struct bm2835_mmal_dev *dev,
 655                                         struct v4l2_ctrl *ctrl,
 656                                         const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 657 {
 658         u32 u32_value;
 659         struct vchiq_mmal_port *jpeg_out;
 660
 661         jpeg_out = &dev->component[MMAL_COMPONENT_IMAGE_ENCODE]->output[0];
 662
 663         u32_value = ctrl->val;
 664
 665         return vchiq_mmal_port_parameter_set(dev->instance, jpeg_out,
 666                                              mmal_ctrl->mmal_id,
 667                                              &u32_value, sizeof(u32_value));
 668 }
 669
 670 static int ctrl_set_video_encode_param_output(struct bm2835_mmal_dev *dev,
 671                                               struct v4l2_ctrl *ctrl,
 672                                               const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 673 {
 674         u32 u32_value;
 675         struct vchiq_mmal_port *vid_enc_ctl;
 676
 677         vid_enc_ctl = &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0];
 678
 679         u32_value = ctrl->val;
 680
 681         return vchiq_mmal_port_parameter_set(dev->instance, vid_enc_ctl,
 682                                              mmal_ctrl->mmal_id,
 683                                              &u32_value, sizeof(u32_value));
 684 }
 685
 686 static int ctrl_set_video_encode_profile_level(struct bm2835_mmal_dev *dev,
 687                                                struct v4l2_ctrl *ctrl,
 688                                                const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 689 {
 690         struct mmal_parameter_video_profile param;
 691         int ret = 0;
 692
 693         if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_PROFILE) {
 694                 switch (ctrl->val) {
 695                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
 696                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
 697                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
 698                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
 699                         dev->capture.enc_profile = ctrl->val;
 700                         break;
 701                 default:
 702                         ret = -EINVAL;
 703                         break;
 704                 }
 705         } else if (ctrl->id == V4L2_CID_MPEG_VIDEO_H264_LEVEL) {
 706                 switch (ctrl->val) {
 707                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
 708                 case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
 709                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
 710                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
 711                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
 712                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
 713                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
 714                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
 715                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
 716                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
 717                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
 718                 case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
 719                         dev->capture.enc_level = ctrl->val;
 720                         break;
 721                 default:
 722                         ret = -EINVAL;
 723                         break;
 724                 }
 725         }
 726
 727         if (!ret) {
 728                 switch (dev->capture.enc_profile) {
 729                 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
 730                         param.profile = MMAL_VIDEO_PROFILE_H264_BASELINE;
 731                         break;
 732                 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
 733                         param.profile =
 734                                 MMAL_VIDEO_PROFILE_H264_CONSTRAINED_BASELINE;
 735                         break;
 736                 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
 737                         param.profile = MMAL_VIDEO_PROFILE_H264_MAIN;
 738                         break;
 739                 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
 740                         param.profile = MMAL_VIDEO_PROFILE_H264_HIGH;
 741                         break;
 742                 default:
 743                         /* Should never get here */
 744                         break;
 745                 }
 746
 747                 switch (dev->capture.enc_level) {
 748                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
 749                         param.level = MMAL_VIDEO_LEVEL_H264_1;
 750                         break;
 751                 case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
 752                         param.level = MMAL_VIDEO_LEVEL_H264_1b;
 753                         break;
 754                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
 755                         param.level = MMAL_VIDEO_LEVEL_H264_11;
 756                         break;
 757                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
 758                         param.level = MMAL_VIDEO_LEVEL_H264_12;
 759                         break;
 760                 case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
 761                         param.level = MMAL_VIDEO_LEVEL_H264_13;
 762                         break;
 763                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
 764                         param.level = MMAL_VIDEO_LEVEL_H264_2;
 765                         break;
 766                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
 767                         param.level = MMAL_VIDEO_LEVEL_H264_21;
 768                         break;
 769                 case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
 770                         param.level = MMAL_VIDEO_LEVEL_H264_22;
 771                         break;
 772                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
 773                         param.level = MMAL_VIDEO_LEVEL_H264_3;
 774                         break;
 775                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
 776                         param.level = MMAL_VIDEO_LEVEL_H264_31;
 777                         break;
 778                 case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
 779                         param.level = MMAL_VIDEO_LEVEL_H264_32;
 780                         break;
 781                 case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
 782                         param.level = MMAL_VIDEO_LEVEL_H264_4;
 783                         break;
 784                 default:
 785                         /* Should never get here */
 786                         break;
 787                 }
 788
 789                 ret = vchiq_mmal_port_parameter_set(dev->instance,
 790                                                     &dev->component[MMAL_COMPONENT_VIDEO_ENCODE]->output[0],
 791                         mmal_ctrl->mmal_id,
 792                         &param, sizeof(param));
 793         }
 794         return ret;
 795 }
 796
 797 static int ctrl_set_scene_mode(struct bm2835_mmal_dev *dev,
 798                                struct v4l2_ctrl *ctrl,
 799                                const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl)
 800 {
 801         int ret = 0;
 802         int shutter_speed;
 803         struct vchiq_mmal_port *control;
 804
 805         v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
 806                  "scene mode selected %d, was %d\n", ctrl->val,
 807                  dev->scene_mode);
 808         control = &dev->component[MMAL_COMPONENT_CAMERA]->control;
 809
 810         if (ctrl->val == dev->scene_mode)
 811                 return 0;
 812
 813         if (ctrl->val == V4L2_SCENE_MODE_NONE) {
 814                 /* Restore all user selections */
 815                 dev->scene_mode = V4L2_SCENE_MODE_NONE;
 816
 817                 if (dev->exposure_mode_user == MMAL_PARAM_EXPOSUREMODE_OFF)
 818                         shutter_speed = dev->manual_shutter_speed;
 819                 else
 820                         shutter_speed = 0;
 821
 822                 v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
 823                          "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
 824                          __func__, shutter_speed, dev->exposure_mode_user,
 825                          dev->metering_mode);
 826                 ret = vchiq_mmal_port_parameter_set(dev->instance,
 827                                                     control,
 828                                                     MMAL_PARAMETER_SHUTTER_SPEED,
 829                                                     &shutter_speed,
 830                                                     sizeof(shutter_speed));
 831                 ret += vchiq_mmal_port_parameter_set(dev->instance,
 832                                                      control,
 833                                                      MMAL_PARAMETER_EXPOSURE_MODE,
 834                                                      &dev->exposure_mode_user,
 835                                                      sizeof(u32));
 836                 dev->exposure_mode_active = dev->exposure_mode_user;
 837                 ret += vchiq_mmal_port_parameter_set(dev->instance,
 838                                                      control,
 839                                                      MMAL_PARAMETER_EXP_METERING_MODE,
 840                                                      &dev->metering_mode,
 841                                                      sizeof(u32));
 842                 ret += set_framerate_params(dev);
 843         } else {
 844                 /* Set up scene mode */
 845                 int i;
 846                 const struct v4l2_mmal_scene_config *scene = NULL;
 847                 int shutter_speed;
 848                 enum mmal_parameter_exposuremode exposure_mode;
 849                 enum mmal_parameter_exposuremeteringmode metering_mode;
 850
 851                 for (i = 0; i < ARRAY_SIZE(scene_configs); i++) {
 852                         if (scene_configs[i].v4l2_scene ==
 853                                 ctrl->val) {
 854                                 scene = &scene_configs[i];
 855                                 break;
 856                         }
 857                 }
 858                 if (!scene)
 859                         return -EINVAL;
 860                 if (i >= ARRAY_SIZE(scene_configs))
 861                         return -EINVAL;
 862
 863                 /* Set all the values */
 864                 dev->scene_mode = ctrl->val;
 865
 866                 if (scene->exposure_mode == MMAL_PARAM_EXPOSUREMODE_OFF)
 867                         shutter_speed = dev->manual_shutter_speed;
 868                 else
 869                         shutter_speed = 0;
 870                 exposure_mode = scene->exposure_mode;
 871                 metering_mode = scene->metering_mode;
 872
 873                 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 874                          "%s: scene mode none: shut_speed %d, exp_mode %d, metering %d\n",
 875                          __func__, shutter_speed, exposure_mode, metering_mode);
 876
 877                 ret = vchiq_mmal_port_parameter_set(dev->instance, control,
 878                                                     MMAL_PARAMETER_SHUTTER_SPEED,
 879                                                     &shutter_speed,
 880                                                     sizeof(shutter_speed));
 881                 ret += vchiq_mmal_port_parameter_set(dev->instance, control,
 882                                                      MMAL_PARAMETER_EXPOSURE_MODE,
 883                                                      &exposure_mode,
 884                                                      sizeof(u32));
 885                 dev->exposure_mode_active = exposure_mode;
 886                 ret += vchiq_mmal_port_parameter_set(dev->instance, control,
 887                                                      MMAL_PARAMETER_EXPOSURE_MODE,
 888                                                      &exposure_mode,
 889                                                      sizeof(u32));
 890                 ret += vchiq_mmal_port_parameter_set(dev->instance, control,
 891                                                      MMAL_PARAMETER_EXP_METERING_MODE,
 892                                                      &metering_mode,
 893                                                      sizeof(u32));
 894                 ret += set_framerate_params(dev);
 895         }
 896         if (ret) {
 897                 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
 898                          "%s: Setting scene to %d, ret=%d\n",
 899                          __func__, ctrl->val, ret);
 900                 ret = -EINVAL;
 901         }
 902         return 0;
 903 }
 904
 905 static int bm2835_mmal_s_ctrl(struct v4l2_ctrl *ctrl)
 906 {
 907         struct bm2835_mmal_dev *dev =
 908                 container_of(ctrl->handler, struct bm2835_mmal_dev,
 909                              ctrl_handler);
 910         const struct bm2835_mmal_v4l2_ctrl *mmal_ctrl = ctrl->priv;
 911         int ret;
 912
 913         if (!mmal_ctrl || mmal_ctrl->id != ctrl->id || !mmal_ctrl->setter) {
 914                 pr_warn("mmal_ctrl:%p ctrl id:%d\n", mmal_ctrl, ctrl->id);
 915                 return -EINVAL;
 916         }
 917
 918         ret = mmal_ctrl->setter(dev, ctrl, mmal_ctrl);
 919         if (ret)
 920                 pr_warn("ctrl id:%d/MMAL param %08X- returned ret %d\n",
 921                         ctrl->id, mmal_ctrl->mmal_id, ret);
 922         if (mmal_ctrl->ignore_errors)
 923                 ret = 0;
 924         return ret;
 925 }
 926
 927 static const struct v4l2_ctrl_ops bm2835_mmal_ctrl_ops = {
 928         .s_ctrl = bm2835_mmal_s_ctrl,
 929 };
 930
 931 static const struct bm2835_mmal_v4l2_ctrl v4l2_ctrls[V4L2_CTRL_COUNT] = {
 932         {
 933                 V4L2_CID_SATURATION, MMAL_CONTROL_TYPE_STD,
 934                 -100, 100, 0, 1, NULL,
 935                 MMAL_PARAMETER_SATURATION,
 936                 &ctrl_set_rational,
 937                 false
 938         },
 939         {
 940                 V4L2_CID_SHARPNESS, MMAL_CONTROL_TYPE_STD,
 941                 -100, 100, 0, 1, NULL,
 942                 MMAL_PARAMETER_SHARPNESS,
 943                 &ctrl_set_rational,
 944                 false
 945         },
 946         {
 947                 V4L2_CID_CONTRAST, MMAL_CONTROL_TYPE_STD,
 948                 -100, 100, 0, 1, NULL,
 949                 MMAL_PARAMETER_CONTRAST,
 950                 &ctrl_set_rational,
 951                 false
 952         },
 953         {
 954                 V4L2_CID_BRIGHTNESS, MMAL_CONTROL_TYPE_STD,
 955                 0, 100, 50, 1, NULL,
 956                 MMAL_PARAMETER_BRIGHTNESS,
 957                 &ctrl_set_rational,
 958                 false
 959         },
 960         {
 961                 V4L2_CID_ISO_SENSITIVITY, MMAL_CONTROL_TYPE_INT_MENU,
 962                 0, ARRAY_SIZE(iso_qmenu) - 1, 0, 1, iso_qmenu,
 963                 MMAL_PARAMETER_ISO,
 964                 &ctrl_set_iso,
 965                 false
 966         },
 967         {
 968                 V4L2_CID_ISO_SENSITIVITY_AUTO, MMAL_CONTROL_TYPE_STD_MENU,
 969                 0, 1, V4L2_ISO_SENSITIVITY_AUTO, 1, NULL,
 970                 MMAL_PARAMETER_ISO,
 971                 &ctrl_set_iso,
 972                 false
 973         },
 974         {
 975                 V4L2_CID_IMAGE_STABILIZATION, MMAL_CONTROL_TYPE_STD,
 976                 0, 1, 0, 1, NULL,
 977                 MMAL_PARAMETER_VIDEO_STABILISATION,
 978                 &ctrl_set_value,
 979                 false
 980         },
 981 /*      {
 982  *              0, MMAL_CONTROL_TYPE_CLUSTER, 3, 1, 0, NULL, 0, NULL
 983  *      },
 984  */
 985         {
 986                 V4L2_CID_EXPOSURE_AUTO, MMAL_CONTROL_TYPE_STD_MENU,
 987                 ~0x03, 3, V4L2_EXPOSURE_AUTO, 0, NULL,
 988                 MMAL_PARAMETER_EXPOSURE_MODE,
 989                 &ctrl_set_exposure,
 990                 false
 991         },
 992 /* todo this needs mixing in with set exposure
 993  *      {
 994  *              V4L2_CID_SCENE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
 995  *      },
 996  */
 997         {
 998                 V4L2_CID_EXPOSURE_ABSOLUTE, MMAL_CONTROL_TYPE_STD,
 999                 /* Units of 100usecs */
1000                 1, 1 * 1000 * 10, 100 * 10, 1, NULL,
1001                 MMAL_PARAMETER_SHUTTER_SPEED,
1002                 &ctrl_set_exposure,
1003                 false
1004         },
1005         {
1006                 V4L2_CID_AUTO_EXPOSURE_BIAS, MMAL_CONTROL_TYPE_INT_MENU,
1007                 0, ARRAY_SIZE(ev_bias_qmenu) - 1,
1008                 (ARRAY_SIZE(ev_bias_qmenu) + 1) / 2 - 1, 0, ev_bias_qmenu,
1009                 MMAL_PARAMETER_EXPOSURE_COMP,
1010                 &ctrl_set_value_ev,
1011                 false
1012         },
1013         {
1014                 V4L2_CID_EXPOSURE_AUTO_PRIORITY, MMAL_CONTROL_TYPE_STD,
1015                 0, 1,
1016                 0, 1, NULL,
1017                 0,      /* Dummy MMAL ID as it gets mapped into FPS range*/
1018                 &ctrl_set_exposure,
1019                 false
1020         },
1021         {
1022                 V4L2_CID_EXPOSURE_METERING,
1023                 MMAL_CONTROL_TYPE_STD_MENU,
1024                 ~0x7, 2, V4L2_EXPOSURE_METERING_AVERAGE, 0, NULL,
1025                 MMAL_PARAMETER_EXP_METERING_MODE,
1026                 &ctrl_set_metering_mode,
1027                 false
1028         },
1029         {
1030                 V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
1031                 MMAL_CONTROL_TYPE_STD_MENU,
1032                 ~0x3ff, 9, V4L2_WHITE_BALANCE_AUTO, 0, NULL,
1033                 MMAL_PARAMETER_AWB_MODE,
1034                 &ctrl_set_awb_mode,
1035                 false
1036         },
1037         {
1038                 V4L2_CID_RED_BALANCE, MMAL_CONTROL_TYPE_STD,
1039                 1, 7999, 1000, 1, NULL,
1040                 MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1041                 &ctrl_set_awb_gains,
1042                 false
1043         },
1044         {
1045                 V4L2_CID_BLUE_BALANCE, MMAL_CONTROL_TYPE_STD,
1046                 1, 7999, 1000, 1, NULL,
1047                 MMAL_PARAMETER_CUSTOM_AWB_GAINS,
1048                 &ctrl_set_awb_gains,
1049                 false
1050         },
1051         {
1052                 V4L2_CID_COLORFX, MMAL_CONTROL_TYPE_STD_MENU,
1053                 0, 15, V4L2_COLORFX_NONE, 0, NULL,
1054                 MMAL_PARAMETER_IMAGE_EFFECT,
1055                 &ctrl_set_image_effect,
1056                 false
1057         },
1058         {
1059                 V4L2_CID_COLORFX_CBCR, MMAL_CONTROL_TYPE_STD,
1060                 0, 0xffff, 0x8080, 1, NULL,
1061                 MMAL_PARAMETER_COLOUR_EFFECT,
1062                 &ctrl_set_colfx,
1063                 false
1064         },
1065         {
1066                 V4L2_CID_ROTATE, MMAL_CONTROL_TYPE_STD,
1067                 0, 360, 0, 90, NULL,
1068                 MMAL_PARAMETER_ROTATION,
1069                 &ctrl_set_rotate,
1070                 false
1071         },
1072         {
1073                 V4L2_CID_HFLIP, MMAL_CONTROL_TYPE_STD,
1074                 0, 1, 0, 1, NULL,
1075                 MMAL_PARAMETER_MIRROR,
1076                 &ctrl_set_flip,
1077                 false
1078         },
1079         {
1080                 V4L2_CID_VFLIP, MMAL_CONTROL_TYPE_STD,
1081                 0, 1, 0, 1, NULL,
1082                 MMAL_PARAMETER_MIRROR,
1083                 &ctrl_set_flip,
1084                 false
1085         },
1086         {
1087                 V4L2_CID_MPEG_VIDEO_BITRATE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
1088                 0, ARRAY_SIZE(bitrate_mode_qmenu) - 1,
1089                 0, 0, bitrate_mode_qmenu,
1090                 MMAL_PARAMETER_RATECONTROL,
1091                 &ctrl_set_bitrate_mode,
1092                 false
1093         },
1094         {
1095                 V4L2_CID_MPEG_VIDEO_BITRATE, MMAL_CONTROL_TYPE_STD,
1096                 25 * 1000, 25 * 1000 * 1000, 10 * 1000 * 1000, 25 * 1000, NULL,
1097                 MMAL_PARAMETER_VIDEO_BIT_RATE,
1098                 &ctrl_set_bitrate,
1099                 false
1100         },
1101         {
1102                 V4L2_CID_JPEG_COMPRESSION_QUALITY, MMAL_CONTROL_TYPE_STD,
1103                 1, 100,
1104                 30, 1, NULL,
1105                 MMAL_PARAMETER_JPEG_Q_FACTOR,
1106                 &ctrl_set_image_encode_output,
1107                 false
1108         },
1109         {
1110                 V4L2_CID_POWER_LINE_FREQUENCY, MMAL_CONTROL_TYPE_STD_MENU,
1111                 0, ARRAY_SIZE(mains_freq_qmenu) - 1,
1112                 1, 1, NULL,
1113                 MMAL_PARAMETER_FLICKER_AVOID,
1114                 &ctrl_set_flicker_avoidance,
1115                 false
1116         },
1117         {
1118                 V4L2_CID_MPEG_VIDEO_REPEAT_SEQ_HEADER, MMAL_CONTROL_TYPE_STD,
1119                 0, 1,
1120                 0, 1, NULL,
1121                 MMAL_PARAMETER_VIDEO_ENCODE_INLINE_HEADER,
1122                 &ctrl_set_video_encode_param_output,
1123                 true    /* Errors ignored as requires latest firmware to work */
1124         },
1125         {
1126                 V4L2_CID_MPEG_VIDEO_H264_PROFILE,
1127                 MMAL_CONTROL_TYPE_STD_MENU,
1128                 ~((1<<V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
1129                         (1<<V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
1130                         (1<<V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
1131                         (1<<V4L2_MPEG_VIDEO_H264_PROFILE_HIGH)),
1132                 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
1133                 V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, 1, NULL,
1134                 MMAL_PARAMETER_PROFILE,
1135                 &ctrl_set_video_encode_profile_level,
1136                 false
1137         },
1138         {
1139                 V4L2_CID_MPEG_VIDEO_H264_LEVEL, MMAL_CONTROL_TYPE_STD_MENU,
1140                 ~((1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_0) |
1141                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1B) |
1142                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_1) |
1143                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_2) |
1144                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_1_3) |
1145                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_0) |
1146                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_1) |
1147                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_2_2) |
1148                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_0) |
1149                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_1) |
1150                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_3_2) |
1151                         (1<<V4L2_MPEG_VIDEO_H264_LEVEL_4_0)),
1152                 V4L2_MPEG_VIDEO_H264_LEVEL_4_0,
1153                 V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 1, NULL,
1154                 MMAL_PARAMETER_PROFILE,
1155                 &ctrl_set_video_encode_profile_level,
1156                 false
1157         },
1158         {
1159                 V4L2_CID_SCENE_MODE, MMAL_CONTROL_TYPE_STD_MENU,
1160                 -1,     /* Min is computed at runtime */
1161                 V4L2_SCENE_MODE_TEXT,
1162                 V4L2_SCENE_MODE_NONE, 1, NULL,
1163                 MMAL_PARAMETER_PROFILE,
1164                 &ctrl_set_scene_mode,
1165                 false
1166         },
1167         {
1168                 V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, MMAL_CONTROL_TYPE_STD,
1169                 0, 0x7FFFFFFF, 60, 1, NULL,
1170                 MMAL_PARAMETER_INTRAPERIOD,
1171                 &ctrl_set_video_encode_param_output,
1172                 false
1173         },
1174 };
1175
1176 int bm2835_mmal_set_all_camera_controls(struct bm2835_mmal_dev *dev)
1177 {
1178         int c;
1179         int ret = 0;
1180
1181         for (c = 0; c < V4L2_CTRL_COUNT; c++) {
1182                 if ((dev->ctrls[c]) && (v4l2_ctrls[c].setter)) {
1183                         ret = v4l2_ctrls[c].setter(dev, dev->ctrls[c],
1184                                                    &v4l2_ctrls[c]);
1185                         if (!v4l2_ctrls[c].ignore_errors && ret) {
1186                                 v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1187                                          "Failed when setting default values for ctrl %d\n",
1188                                          c);
1189                                 break;
1190                         }
1191                 }
1192         }
1193         return ret;
1194 }
1195
1196 int set_framerate_params(struct bm2835_mmal_dev *dev)
1197 {
1198         struct mmal_parameter_fps_range fps_range;
1199         int ret;
1200
1201         if ((dev->exposure_mode_active != MMAL_PARAM_EXPOSUREMODE_OFF) &&
1202             (dev->exp_auto_priority)) {
1203                 /* Variable FPS. Define min FPS as 1fps.
1204                  * Max as max defined FPS.
1205                  */
1206                 fps_range.fps_low.num = 1;
1207                 fps_range.fps_low.den = 1;
1208                 fps_range.fps_high.num = dev->capture.timeperframe.denominator;
1209                 fps_range.fps_high.den = dev->capture.timeperframe.numerator;
1210         } else {
1211                 /* Fixed FPS - set min and max to be the same */
1212                 fps_range.fps_low.num = fps_range.fps_high.num =
1213                         dev->capture.timeperframe.denominator;
1214                 fps_range.fps_low.den = fps_range.fps_high.den =
1215                         dev->capture.timeperframe.numerator;
1216         }
1217
1218         v4l2_dbg(1, bcm2835_v4l2_debug, &dev->v4l2_dev,
1219                  "Set fps range to %d/%d to %d/%d\n",
1220                  fps_range.fps_low.num,
1221                  fps_range.fps_low.den,
1222                  fps_range.fps_high.num,
1223                  fps_range.fps_high.den);
1224
1225         ret = vchiq_mmal_port_parameter_set(dev->instance,
1226                                             &dev->component[MMAL_COMPONENT_CAMERA]->
1227                                             output[MMAL_CAMERA_PORT_PREVIEW],
1228                                             MMAL_PARAMETER_FPS_RANGE,
1229                                             &fps_range, sizeof(fps_range));
1230         ret += vchiq_mmal_port_parameter_set(dev->instance,
1231                                              &dev->component[MMAL_COMPONENT_CAMERA]->
1232                                              output[MMAL_CAMERA_PORT_VIDEO],
1233                                              MMAL_PARAMETER_FPS_RANGE,
1234                                              &fps_range, sizeof(fps_range));
1235         ret += vchiq_mmal_port_parameter_set(dev->instance,
1236                                              &dev->component[MMAL_COMPONENT_CAMERA]->
1237                                              output[MMAL_CAMERA_PORT_CAPTURE],
1238                                              MMAL_PARAMETER_FPS_RANGE,
1239                                              &fps_range, sizeof(fps_range));
1240         if (ret)
1241                 v4l2_dbg(0, bcm2835_v4l2_debug, &dev->v4l2_dev,
1242                          "Failed to set fps ret %d\n", ret);
1243
1244         return ret;
1245 }
1246
1247 int bm2835_mmal_init_controls(struct bm2835_mmal_dev *dev,
1248                               struct v4l2_ctrl_handler *hdl)
1249 {
1250         int c;
1251         const struct bm2835_mmal_v4l2_ctrl *ctrl;
1252
1253         v4l2_ctrl_handler_init(hdl, V4L2_CTRL_COUNT);
1254
1255         for (c = 0; c < V4L2_CTRL_COUNT; c++) {
1256                 ctrl = &v4l2_ctrls[c];
1257
1258                 switch (ctrl->type) {
1259                 case MMAL_CONTROL_TYPE_STD:
1260                         dev->ctrls[c] = v4l2_ctrl_new_std(hdl,
1261                                 &bm2835_mmal_ctrl_ops, ctrl->id,
1262                                 ctrl->min, ctrl->max, ctrl->step, ctrl->def);
1263                         break;
1264
1265                 case MMAL_CONTROL_TYPE_STD_MENU:
1266                 {
1267                         int mask = ctrl->min;
1268
1269                         if (ctrl->id == V4L2_CID_SCENE_MODE) {
1270                                 /* Special handling to work out the mask
1271                                  * value based on the scene_configs array
1272                                  * at runtime. Reduces the chance of
1273                                  * mismatches.
1274                                  */
1275                                 int i;
1276                                 mask = 1 << V4L2_SCENE_MODE_NONE;
1277                                 for (i = 0;
1278                                      i < ARRAY_SIZE(scene_configs);
1279                                      i++) {
1280                                         mask |= 1 << scene_configs[i].v4l2_scene;
1281                                 }
1282                                 mask = ~mask;
1283                         }
1284
1285                         dev->ctrls[c] = v4l2_ctrl_new_std_menu(hdl,
1286                         &bm2835_mmal_ctrl_ops, ctrl->id,
1287                         ctrl->max, mask, ctrl->def);
1288                         break;
1289                 }
1290
1291                 case MMAL_CONTROL_TYPE_INT_MENU:
1292                         dev->ctrls[c] = v4l2_ctrl_new_int_menu(hdl,
1293                                 &bm2835_mmal_ctrl_ops, ctrl->id,
1294                                 ctrl->max, ctrl->def, ctrl->imenu);
1295                         break;
1296
1297                 case MMAL_CONTROL_TYPE_CLUSTER:
1298                         /* skip this entry when constructing controls */
1299                         continue;
1300                 }
1301
1302                 if (hdl->error)
1303                         break;
1304
1305                 dev->ctrls[c]->priv = (void *)ctrl;
1306         }
1307
1308         if (hdl->error) {
1309                 pr_err("error adding control %d/%d id 0x%x\n", c,
1310                        V4L2_CTRL_COUNT, ctrl->id);
1311                 return hdl->error;
1312         }
1313
1314         for (c = 0; c < V4L2_CTRL_COUNT; c++) {
1315                 ctrl = &v4l2_ctrls[c];
1316
1317                 switch (ctrl->type) {
1318                 case MMAL_CONTROL_TYPE_CLUSTER:
1319                         v4l2_ctrl_auto_cluster(ctrl->min,
1320                                                &dev->ctrls[c + 1],
1321                                                ctrl->max,
1322                                                ctrl->def);
1323                         break;
1324
1325                 case MMAL_CONTROL_TYPE_STD:
1326                 case MMAL_CONTROL_TYPE_STD_MENU:
1327                 case MMAL_CONTROL_TYPE_INT_MENU:
1328                         break;
1329                 }
1330         }
1331
1332         return 0;
1333 }