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