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