2 * vivid-ctrls.c - control support functions.
4 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 * This program is free software; you may redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
10 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
11 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
12 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
13 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
14 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
15 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
16 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 #include <linux/errno.h>
21 #include <linux/kernel.h>
22 #include <linux/videodev2.h>
23 #include <media/v4l2-event.h>
24 #include <media/v4l2-common.h>
26 #include "vivid-core.h"
27 #include "vivid-vid-cap.h"
28 #include "vivid-vid-out.h"
29 #include "vivid-vid-common.h"
30 #include "vivid-radio-common.h"
31 #include "vivid-osd.h"
32 #include "vivid-ctrls.h"
34 #define VIVID_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
35 #define VIVID_CID_BUTTON (VIVID_CID_CUSTOM_BASE + 0)
36 #define VIVID_CID_BOOLEAN (VIVID_CID_CUSTOM_BASE + 1)
37 #define VIVID_CID_INTEGER (VIVID_CID_CUSTOM_BASE + 2)
38 #define VIVID_CID_INTEGER64 (VIVID_CID_CUSTOM_BASE + 3)
39 #define VIVID_CID_MENU (VIVID_CID_CUSTOM_BASE + 4)
40 #define VIVID_CID_STRING (VIVID_CID_CUSTOM_BASE + 5)
41 #define VIVID_CID_BITMASK (VIVID_CID_CUSTOM_BASE + 6)
42 #define VIVID_CID_INTMENU (VIVID_CID_CUSTOM_BASE + 7)
43 #define VIVID_CID_U32_ARRAY (VIVID_CID_CUSTOM_BASE + 8)
44 #define VIVID_CID_U16_MATRIX (VIVID_CID_CUSTOM_BASE + 9)
45 #define VIVID_CID_U8_4D_ARRAY (VIVID_CID_CUSTOM_BASE + 10)
47 #define VIVID_CID_VIVID_BASE (0x00f00000 | 0xf000)
48 #define VIVID_CID_VIVID_CLASS (0x00f00000 | 1)
49 #define VIVID_CID_TEST_PATTERN (VIVID_CID_VIVID_BASE + 0)
50 #define VIVID_CID_OSD_TEXT_MODE (VIVID_CID_VIVID_BASE + 1)
51 #define VIVID_CID_HOR_MOVEMENT (VIVID_CID_VIVID_BASE + 2)
52 #define VIVID_CID_VERT_MOVEMENT (VIVID_CID_VIVID_BASE + 3)
53 #define VIVID_CID_SHOW_BORDER (VIVID_CID_VIVID_BASE + 4)
54 #define VIVID_CID_SHOW_SQUARE (VIVID_CID_VIVID_BASE + 5)
55 #define VIVID_CID_INSERT_SAV (VIVID_CID_VIVID_BASE + 6)
56 #define VIVID_CID_INSERT_EAV (VIVID_CID_VIVID_BASE + 7)
57 #define VIVID_CID_VBI_CAP_INTERLACED (VIVID_CID_VIVID_BASE + 8)
59 #define VIVID_CID_HFLIP (VIVID_CID_VIVID_BASE + 20)
60 #define VIVID_CID_VFLIP (VIVID_CID_VIVID_BASE + 21)
61 #define VIVID_CID_STD_ASPECT_RATIO (VIVID_CID_VIVID_BASE + 22)
62 #define VIVID_CID_DV_TIMINGS_ASPECT_RATIO (VIVID_CID_VIVID_BASE + 23)
63 #define VIVID_CID_TSTAMP_SRC (VIVID_CID_VIVID_BASE + 24)
64 #define VIVID_CID_COLORSPACE (VIVID_CID_VIVID_BASE + 25)
65 #define VIVID_CID_YCBCR_ENC (VIVID_CID_VIVID_BASE + 26)
66 #define VIVID_CID_QUANTIZATION (VIVID_CID_VIVID_BASE + 27)
67 #define VIVID_CID_LIMITED_RGB_RANGE (VIVID_CID_VIVID_BASE + 28)
68 #define VIVID_CID_ALPHA_MODE (VIVID_CID_VIVID_BASE + 29)
69 #define VIVID_CID_HAS_CROP_CAP (VIVID_CID_VIVID_BASE + 30)
70 #define VIVID_CID_HAS_COMPOSE_CAP (VIVID_CID_VIVID_BASE + 31)
71 #define VIVID_CID_HAS_SCALER_CAP (VIVID_CID_VIVID_BASE + 32)
72 #define VIVID_CID_HAS_CROP_OUT (VIVID_CID_VIVID_BASE + 33)
73 #define VIVID_CID_HAS_COMPOSE_OUT (VIVID_CID_VIVID_BASE + 34)
74 #define VIVID_CID_HAS_SCALER_OUT (VIVID_CID_VIVID_BASE + 35)
75 #define VIVID_CID_LOOP_VIDEO (VIVID_CID_VIVID_BASE + 36)
76 #define VIVID_CID_SEQ_WRAP (VIVID_CID_VIVID_BASE + 37)
77 #define VIVID_CID_TIME_WRAP (VIVID_CID_VIVID_BASE + 38)
78 #define VIVID_CID_MAX_EDID_BLOCKS (VIVID_CID_VIVID_BASE + 39)
79 #define VIVID_CID_PERCENTAGE_FILL (VIVID_CID_VIVID_BASE + 40)
81 #define VIVID_CID_STD_SIGNAL_MODE (VIVID_CID_VIVID_BASE + 60)
82 #define VIVID_CID_STANDARD (VIVID_CID_VIVID_BASE + 61)
83 #define VIVID_CID_DV_TIMINGS_SIGNAL_MODE (VIVID_CID_VIVID_BASE + 62)
84 #define VIVID_CID_DV_TIMINGS (VIVID_CID_VIVID_BASE + 63)
85 #define VIVID_CID_PERC_DROPPED (VIVID_CID_VIVID_BASE + 64)
86 #define VIVID_CID_DISCONNECT (VIVID_CID_VIVID_BASE + 65)
87 #define VIVID_CID_DQBUF_ERROR (VIVID_CID_VIVID_BASE + 66)
88 #define VIVID_CID_QUEUE_SETUP_ERROR (VIVID_CID_VIVID_BASE + 67)
89 #define VIVID_CID_BUF_PREPARE_ERROR (VIVID_CID_VIVID_BASE + 68)
90 #define VIVID_CID_START_STR_ERROR (VIVID_CID_VIVID_BASE + 69)
91 #define VIVID_CID_QUEUE_ERROR (VIVID_CID_VIVID_BASE + 70)
92 #define VIVID_CID_CLEAR_FB (VIVID_CID_VIVID_BASE + 71)
94 #define VIVID_CID_RADIO_SEEK_MODE (VIVID_CID_VIVID_BASE + 90)
95 #define VIVID_CID_RADIO_SEEK_PROG_LIM (VIVID_CID_VIVID_BASE + 91)
96 #define VIVID_CID_RADIO_RX_RDS_RBDS (VIVID_CID_VIVID_BASE + 92)
97 #define VIVID_CID_RADIO_RX_RDS_BLOCKIO (VIVID_CID_VIVID_BASE + 93)
99 #define VIVID_CID_RADIO_TX_RDS_BLOCKIO (VIVID_CID_VIVID_BASE + 94)
102 /* General User Controls */
104 static int vivid_user_gen_s_ctrl(struct v4l2_ctrl *ctrl)
106 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_gen);
109 case VIVID_CID_DISCONNECT:
110 v4l2_info(&dev->v4l2_dev, "disconnect\n");
111 clear_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
112 clear_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
113 clear_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
114 clear_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
115 clear_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
116 clear_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
117 clear_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
119 case VIVID_CID_CLEAR_FB:
122 case VIVID_CID_BUTTON:
123 dev->button_pressed = 30;
129 static const struct v4l2_ctrl_ops vivid_user_gen_ctrl_ops = {
130 .s_ctrl = vivid_user_gen_s_ctrl,
133 static const struct v4l2_ctrl_config vivid_ctrl_button = {
134 .ops = &vivid_user_gen_ctrl_ops,
135 .id = VIVID_CID_BUTTON,
137 .type = V4L2_CTRL_TYPE_BUTTON,
140 static const struct v4l2_ctrl_config vivid_ctrl_boolean = {
141 .ops = &vivid_user_gen_ctrl_ops,
142 .id = VIVID_CID_BOOLEAN,
144 .type = V4L2_CTRL_TYPE_BOOLEAN,
151 static const struct v4l2_ctrl_config vivid_ctrl_int32 = {
152 .ops = &vivid_user_gen_ctrl_ops,
153 .id = VIVID_CID_INTEGER,
154 .name = "Integer 32 Bits",
155 .type = V4L2_CTRL_TYPE_INTEGER,
156 .min = 0xffffffff80000000ULL,
161 static const struct v4l2_ctrl_config vivid_ctrl_int64 = {
162 .ops = &vivid_user_gen_ctrl_ops,
163 .id = VIVID_CID_INTEGER64,
164 .name = "Integer 64 Bits",
165 .type = V4L2_CTRL_TYPE_INTEGER64,
166 .min = 0x8000000000000000ULL,
167 .max = 0x7fffffffffffffffLL,
171 static const struct v4l2_ctrl_config vivid_ctrl_u32_array = {
172 .ops = &vivid_user_gen_ctrl_ops,
173 .id = VIVID_CID_U32_ARRAY,
174 .name = "U32 1 Element Array",
175 .type = V4L2_CTRL_TYPE_U32,
183 static const struct v4l2_ctrl_config vivid_ctrl_u16_matrix = {
184 .ops = &vivid_user_gen_ctrl_ops,
185 .id = VIVID_CID_U16_MATRIX,
186 .name = "U16 8x16 Matrix",
187 .type = V4L2_CTRL_TYPE_U16,
195 static const struct v4l2_ctrl_config vivid_ctrl_u8_4d_array = {
196 .ops = &vivid_user_gen_ctrl_ops,
197 .id = VIVID_CID_U8_4D_ARRAY,
198 .name = "U8 2x3x4x5 Array",
199 .type = V4L2_CTRL_TYPE_U8,
204 .dims = { 2, 3, 4, 5 },
207 static const char * const vivid_ctrl_menu_strings[] = {
208 "Menu Item 0 (Skipped)",
210 "Menu Item 2 (Skipped)",
213 "Menu Item 5 (Skipped)",
217 static const struct v4l2_ctrl_config vivid_ctrl_menu = {
218 .ops = &vivid_user_gen_ctrl_ops,
219 .id = VIVID_CID_MENU,
221 .type = V4L2_CTRL_TYPE_MENU,
225 .menu_skip_mask = 0x04,
226 .qmenu = vivid_ctrl_menu_strings,
229 static const struct v4l2_ctrl_config vivid_ctrl_string = {
230 .ops = &vivid_user_gen_ctrl_ops,
231 .id = VIVID_CID_STRING,
233 .type = V4L2_CTRL_TYPE_STRING,
239 static const struct v4l2_ctrl_config vivid_ctrl_bitmask = {
240 .ops = &vivid_user_gen_ctrl_ops,
241 .id = VIVID_CID_BITMASK,
243 .type = V4L2_CTRL_TYPE_BITMASK,
250 static const s64 vivid_ctrl_int_menu_values[] = {
251 1, 1, 2, 3, 5, 8, 13, 21, 42,
254 static const struct v4l2_ctrl_config vivid_ctrl_int_menu = {
255 .ops = &vivid_user_gen_ctrl_ops,
256 .id = VIVID_CID_INTMENU,
257 .name = "Integer Menu",
258 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
262 .menu_skip_mask = 0x02,
263 .qmenu_int = vivid_ctrl_int_menu_values,
266 static const struct v4l2_ctrl_config vivid_ctrl_disconnect = {
267 .ops = &vivid_user_gen_ctrl_ops,
268 .id = VIVID_CID_DISCONNECT,
269 .name = "Disconnect",
270 .type = V4L2_CTRL_TYPE_BUTTON,
273 static const struct v4l2_ctrl_config vivid_ctrl_clear_fb = {
274 .ops = &vivid_user_gen_ctrl_ops,
275 .id = VIVID_CID_CLEAR_FB,
276 .name = "Clear Framebuffer",
277 .type = V4L2_CTRL_TYPE_BUTTON,
281 /* Video User Controls */
283 static int vivid_user_vid_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
285 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
288 case V4L2_CID_AUTOGAIN:
289 dev->gain->val = dev->jiffies_vid_cap & 0xff;
295 static int vivid_user_vid_s_ctrl(struct v4l2_ctrl *ctrl)
297 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
300 case V4L2_CID_BRIGHTNESS:
301 dev->input_brightness[dev->input] = ctrl->val - dev->input * 128;
302 tpg_s_brightness(&dev->tpg, dev->input_brightness[dev->input]);
304 case V4L2_CID_CONTRAST:
305 tpg_s_contrast(&dev->tpg, ctrl->val);
307 case V4L2_CID_SATURATION:
308 tpg_s_saturation(&dev->tpg, ctrl->val);
311 tpg_s_hue(&dev->tpg, ctrl->val);
314 dev->hflip = ctrl->val;
315 tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
318 dev->vflip = ctrl->val;
319 tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
321 case V4L2_CID_ALPHA_COMPONENT:
322 tpg_s_alpha_component(&dev->tpg, ctrl->val);
328 static const struct v4l2_ctrl_ops vivid_user_vid_ctrl_ops = {
329 .g_volatile_ctrl = vivid_user_vid_g_volatile_ctrl,
330 .s_ctrl = vivid_user_vid_s_ctrl,
334 /* Video Capture Controls */
336 static int vivid_vid_cap_s_ctrl(struct v4l2_ctrl *ctrl)
338 static const u32 colorspaces[] = {
339 V4L2_COLORSPACE_SMPTE170M,
340 V4L2_COLORSPACE_REC709,
341 V4L2_COLORSPACE_SRGB,
342 V4L2_COLORSPACE_ADOBERGB,
343 V4L2_COLORSPACE_BT2020,
344 V4L2_COLORSPACE_SMPTE240M,
345 V4L2_COLORSPACE_470_SYSTEM_M,
346 V4L2_COLORSPACE_470_SYSTEM_BG,
348 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_cap);
352 case VIVID_CID_TEST_PATTERN:
353 vivid_update_quality(dev);
354 tpg_s_pattern(&dev->tpg, ctrl->val);
356 case VIVID_CID_COLORSPACE:
357 tpg_s_colorspace(&dev->tpg, colorspaces[ctrl->val]);
358 vivid_send_source_change(dev, TV);
359 vivid_send_source_change(dev, SVID);
360 vivid_send_source_change(dev, HDMI);
361 vivid_send_source_change(dev, WEBCAM);
363 case VIVID_CID_YCBCR_ENC:
364 tpg_s_ycbcr_enc(&dev->tpg, ctrl->val);
365 vivid_send_source_change(dev, TV);
366 vivid_send_source_change(dev, SVID);
367 vivid_send_source_change(dev, HDMI);
368 vivid_send_source_change(dev, WEBCAM);
370 case VIVID_CID_QUANTIZATION:
371 tpg_s_quantization(&dev->tpg, ctrl->val);
372 vivid_send_source_change(dev, TV);
373 vivid_send_source_change(dev, SVID);
374 vivid_send_source_change(dev, HDMI);
375 vivid_send_source_change(dev, WEBCAM);
377 case V4L2_CID_DV_RX_RGB_RANGE:
378 if (!vivid_is_hdmi_cap(dev))
380 tpg_s_rgb_range(&dev->tpg, ctrl->val);
382 case VIVID_CID_LIMITED_RGB_RANGE:
383 tpg_s_real_rgb_range(&dev->tpg, ctrl->val ?
384 V4L2_DV_RGB_RANGE_LIMITED : V4L2_DV_RGB_RANGE_FULL);
386 case VIVID_CID_ALPHA_MODE:
387 tpg_s_alpha_mode(&dev->tpg, ctrl->val);
389 case VIVID_CID_HOR_MOVEMENT:
390 tpg_s_mv_hor_mode(&dev->tpg, ctrl->val);
392 case VIVID_CID_VERT_MOVEMENT:
393 tpg_s_mv_vert_mode(&dev->tpg, ctrl->val);
395 case VIVID_CID_OSD_TEXT_MODE:
396 dev->osd_mode = ctrl->val;
398 case VIVID_CID_PERCENTAGE_FILL:
399 tpg_s_perc_fill(&dev->tpg, ctrl->val);
400 for (i = 0; i < VIDEO_MAX_FRAME; i++)
401 dev->must_blank[i] = ctrl->val < 100;
403 case VIVID_CID_INSERT_SAV:
404 tpg_s_insert_sav(&dev->tpg, ctrl->val);
406 case VIVID_CID_INSERT_EAV:
407 tpg_s_insert_eav(&dev->tpg, ctrl->val);
409 case VIVID_CID_HFLIP:
410 dev->sensor_hflip = ctrl->val;
411 tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
413 case VIVID_CID_VFLIP:
414 dev->sensor_vflip = ctrl->val;
415 tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
417 case VIVID_CID_HAS_CROP_CAP:
418 dev->has_crop_cap = ctrl->val;
419 vivid_update_format_cap(dev, true);
421 case VIVID_CID_HAS_COMPOSE_CAP:
422 dev->has_compose_cap = ctrl->val;
423 vivid_update_format_cap(dev, true);
425 case VIVID_CID_HAS_SCALER_CAP:
426 dev->has_scaler_cap = ctrl->val;
427 vivid_update_format_cap(dev, true);
429 case VIVID_CID_SHOW_BORDER:
430 tpg_s_show_border(&dev->tpg, ctrl->val);
432 case VIVID_CID_SHOW_SQUARE:
433 tpg_s_show_square(&dev->tpg, ctrl->val);
435 case VIVID_CID_STD_ASPECT_RATIO:
436 dev->std_aspect_ratio = ctrl->val;
437 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
439 case VIVID_CID_DV_TIMINGS_SIGNAL_MODE:
440 dev->dv_timings_signal_mode = dev->ctrl_dv_timings_signal_mode->val;
441 if (dev->dv_timings_signal_mode == SELECTED_DV_TIMINGS)
442 dev->query_dv_timings = dev->ctrl_dv_timings->val;
443 v4l2_ctrl_activate(dev->ctrl_dv_timings,
444 dev->dv_timings_signal_mode == SELECTED_DV_TIMINGS);
445 vivid_update_quality(dev);
446 vivid_send_source_change(dev, HDMI);
448 case VIVID_CID_DV_TIMINGS_ASPECT_RATIO:
449 dev->dv_timings_aspect_ratio = ctrl->val;
450 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
452 case VIVID_CID_TSTAMP_SRC:
453 dev->tstamp_src_is_soe = ctrl->val;
454 dev->vb_vid_cap_q.timestamp_flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
455 if (dev->tstamp_src_is_soe)
456 dev->vb_vid_cap_q.timestamp_flags |= V4L2_BUF_FLAG_TSTAMP_SRC_SOE;
458 case VIVID_CID_MAX_EDID_BLOCKS:
459 dev->edid_max_blocks = ctrl->val;
460 if (dev->edid_blocks > dev->edid_max_blocks)
461 dev->edid_blocks = dev->edid_max_blocks;
467 static const struct v4l2_ctrl_ops vivid_vid_cap_ctrl_ops = {
468 .s_ctrl = vivid_vid_cap_s_ctrl,
471 static const char * const vivid_ctrl_hor_movement_strings[] = {
482 static const struct v4l2_ctrl_config vivid_ctrl_hor_movement = {
483 .ops = &vivid_vid_cap_ctrl_ops,
484 .id = VIVID_CID_HOR_MOVEMENT,
485 .name = "Horizontal Movement",
486 .type = V4L2_CTRL_TYPE_MENU,
487 .max = TPG_MOVE_POS_FAST,
488 .def = TPG_MOVE_NONE,
489 .qmenu = vivid_ctrl_hor_movement_strings,
492 static const char * const vivid_ctrl_vert_movement_strings[] = {
503 static const struct v4l2_ctrl_config vivid_ctrl_vert_movement = {
504 .ops = &vivid_vid_cap_ctrl_ops,
505 .id = VIVID_CID_VERT_MOVEMENT,
506 .name = "Vertical Movement",
507 .type = V4L2_CTRL_TYPE_MENU,
508 .max = TPG_MOVE_POS_FAST,
509 .def = TPG_MOVE_NONE,
510 .qmenu = vivid_ctrl_vert_movement_strings,
513 static const struct v4l2_ctrl_config vivid_ctrl_show_border = {
514 .ops = &vivid_vid_cap_ctrl_ops,
515 .id = VIVID_CID_SHOW_BORDER,
516 .name = "Show Border",
517 .type = V4L2_CTRL_TYPE_BOOLEAN,
522 static const struct v4l2_ctrl_config vivid_ctrl_show_square = {
523 .ops = &vivid_vid_cap_ctrl_ops,
524 .id = VIVID_CID_SHOW_SQUARE,
525 .name = "Show Square",
526 .type = V4L2_CTRL_TYPE_BOOLEAN,
531 static const char * const vivid_ctrl_osd_mode_strings[] = {
538 static const struct v4l2_ctrl_config vivid_ctrl_osd_mode = {
539 .ops = &vivid_vid_cap_ctrl_ops,
540 .id = VIVID_CID_OSD_TEXT_MODE,
541 .name = "OSD Text Mode",
542 .type = V4L2_CTRL_TYPE_MENU,
544 .qmenu = vivid_ctrl_osd_mode_strings,
547 static const struct v4l2_ctrl_config vivid_ctrl_perc_fill = {
548 .ops = &vivid_vid_cap_ctrl_ops,
549 .id = VIVID_CID_PERCENTAGE_FILL,
550 .name = "Fill Percentage of Frame",
551 .type = V4L2_CTRL_TYPE_INTEGER,
558 static const struct v4l2_ctrl_config vivid_ctrl_insert_sav = {
559 .ops = &vivid_vid_cap_ctrl_ops,
560 .id = VIVID_CID_INSERT_SAV,
561 .name = "Insert SAV Code in Image",
562 .type = V4L2_CTRL_TYPE_BOOLEAN,
567 static const struct v4l2_ctrl_config vivid_ctrl_insert_eav = {
568 .ops = &vivid_vid_cap_ctrl_ops,
569 .id = VIVID_CID_INSERT_EAV,
570 .name = "Insert EAV Code in Image",
571 .type = V4L2_CTRL_TYPE_BOOLEAN,
576 static const struct v4l2_ctrl_config vivid_ctrl_hflip = {
577 .ops = &vivid_vid_cap_ctrl_ops,
578 .id = VIVID_CID_HFLIP,
579 .name = "Sensor Flipped Horizontally",
580 .type = V4L2_CTRL_TYPE_BOOLEAN,
585 static const struct v4l2_ctrl_config vivid_ctrl_vflip = {
586 .ops = &vivid_vid_cap_ctrl_ops,
587 .id = VIVID_CID_VFLIP,
588 .name = "Sensor Flipped Vertically",
589 .type = V4L2_CTRL_TYPE_BOOLEAN,
594 static const struct v4l2_ctrl_config vivid_ctrl_has_crop_cap = {
595 .ops = &vivid_vid_cap_ctrl_ops,
596 .id = VIVID_CID_HAS_CROP_CAP,
597 .name = "Enable Capture Cropping",
598 .type = V4L2_CTRL_TYPE_BOOLEAN,
604 static const struct v4l2_ctrl_config vivid_ctrl_has_compose_cap = {
605 .ops = &vivid_vid_cap_ctrl_ops,
606 .id = VIVID_CID_HAS_COMPOSE_CAP,
607 .name = "Enable Capture Composing",
608 .type = V4L2_CTRL_TYPE_BOOLEAN,
614 static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_cap = {
615 .ops = &vivid_vid_cap_ctrl_ops,
616 .id = VIVID_CID_HAS_SCALER_CAP,
617 .name = "Enable Capture Scaler",
618 .type = V4L2_CTRL_TYPE_BOOLEAN,
624 static const char * const vivid_ctrl_tstamp_src_strings[] = {
630 static const struct v4l2_ctrl_config vivid_ctrl_tstamp_src = {
631 .ops = &vivid_vid_cap_ctrl_ops,
632 .id = VIVID_CID_TSTAMP_SRC,
633 .name = "Timestamp Source",
634 .type = V4L2_CTRL_TYPE_MENU,
636 .qmenu = vivid_ctrl_tstamp_src_strings,
639 static const struct v4l2_ctrl_config vivid_ctrl_std_aspect_ratio = {
640 .ops = &vivid_vid_cap_ctrl_ops,
641 .id = VIVID_CID_STD_ASPECT_RATIO,
642 .name = "Standard Aspect Ratio",
643 .type = V4L2_CTRL_TYPE_MENU,
647 .qmenu = tpg_aspect_strings,
650 static const char * const vivid_ctrl_dv_timings_signal_mode_strings[] = {
651 "Current DV Timings",
655 "Selected DV Timings",
656 "Cycle Through All DV Timings",
661 static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_signal_mode = {
662 .ops = &vivid_vid_cap_ctrl_ops,
663 .id = VIVID_CID_DV_TIMINGS_SIGNAL_MODE,
664 .name = "DV Timings Signal Mode",
665 .type = V4L2_CTRL_TYPE_MENU,
667 .qmenu = vivid_ctrl_dv_timings_signal_mode_strings,
670 static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_aspect_ratio = {
671 .ops = &vivid_vid_cap_ctrl_ops,
672 .id = VIVID_CID_DV_TIMINGS_ASPECT_RATIO,
673 .name = "DV Timings Aspect Ratio",
674 .type = V4L2_CTRL_TYPE_MENU,
676 .qmenu = tpg_aspect_strings,
679 static const struct v4l2_ctrl_config vivid_ctrl_max_edid_blocks = {
680 .ops = &vivid_vid_cap_ctrl_ops,
681 .id = VIVID_CID_MAX_EDID_BLOCKS,
682 .name = "Maximum EDID Blocks",
683 .type = V4L2_CTRL_TYPE_INTEGER,
690 static const char * const vivid_ctrl_colorspace_strings[] = {
702 static const struct v4l2_ctrl_config vivid_ctrl_colorspace = {
703 .ops = &vivid_vid_cap_ctrl_ops,
704 .id = VIVID_CID_COLORSPACE,
705 .name = "Colorspace",
706 .type = V4L2_CTRL_TYPE_MENU,
709 .qmenu = vivid_ctrl_colorspace_strings,
712 static const char * const vivid_ctrl_ycbcr_enc_strings[] = {
720 "BT.2020 Constant Luminance",
725 static const struct v4l2_ctrl_config vivid_ctrl_ycbcr_enc = {
726 .ops = &vivid_vid_cap_ctrl_ops,
727 .id = VIVID_CID_YCBCR_ENC,
728 .name = "Y'CbCr Encoding",
729 .type = V4L2_CTRL_TYPE_MENU,
731 .qmenu = vivid_ctrl_ycbcr_enc_strings,
734 static const char * const vivid_ctrl_quantization_strings[] = {
741 static const struct v4l2_ctrl_config vivid_ctrl_quantization = {
742 .ops = &vivid_vid_cap_ctrl_ops,
743 .id = VIVID_CID_QUANTIZATION,
744 .name = "Quantization",
745 .type = V4L2_CTRL_TYPE_MENU,
747 .qmenu = vivid_ctrl_quantization_strings,
750 static const struct v4l2_ctrl_config vivid_ctrl_alpha_mode = {
751 .ops = &vivid_vid_cap_ctrl_ops,
752 .id = VIVID_CID_ALPHA_MODE,
753 .name = "Apply Alpha To Red Only",
754 .type = V4L2_CTRL_TYPE_BOOLEAN,
759 static const struct v4l2_ctrl_config vivid_ctrl_limited_rgb_range = {
760 .ops = &vivid_vid_cap_ctrl_ops,
761 .id = VIVID_CID_LIMITED_RGB_RANGE,
762 .name = "Limited RGB Range (16-235)",
763 .type = V4L2_CTRL_TYPE_BOOLEAN,
769 /* VBI Capture Control */
771 static int vivid_vbi_cap_s_ctrl(struct v4l2_ctrl *ctrl)
773 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vbi_cap);
776 case VIVID_CID_VBI_CAP_INTERLACED:
777 dev->vbi_cap_interlaced = ctrl->val;
783 static const struct v4l2_ctrl_ops vivid_vbi_cap_ctrl_ops = {
784 .s_ctrl = vivid_vbi_cap_s_ctrl,
787 static const struct v4l2_ctrl_config vivid_ctrl_vbi_cap_interlaced = {
788 .ops = &vivid_vbi_cap_ctrl_ops,
789 .id = VIVID_CID_VBI_CAP_INTERLACED,
790 .name = "Interlaced VBI Format",
791 .type = V4L2_CTRL_TYPE_BOOLEAN,
797 /* Video Output Controls */
799 static int vivid_vid_out_s_ctrl(struct v4l2_ctrl *ctrl)
801 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_out);
802 struct v4l2_bt_timings *bt = &dev->dv_timings_out.bt;
805 case VIVID_CID_HAS_CROP_OUT:
806 dev->has_crop_out = ctrl->val;
807 vivid_update_format_out(dev);
809 case VIVID_CID_HAS_COMPOSE_OUT:
810 dev->has_compose_out = ctrl->val;
811 vivid_update_format_out(dev);
813 case VIVID_CID_HAS_SCALER_OUT:
814 dev->has_scaler_out = ctrl->val;
815 vivid_update_format_out(dev);
817 case V4L2_CID_DV_TX_MODE:
818 dev->dvi_d_out = ctrl->val == V4L2_DV_TX_MODE_DVI_D;
819 if (!vivid_is_hdmi_out(dev))
821 if (!dev->dvi_d_out && (bt->flags & V4L2_DV_FL_IS_CE_VIDEO)) {
822 if (bt->width == 720 && bt->height <= 576)
823 dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M;
825 dev->colorspace_out = V4L2_COLORSPACE_REC709;
826 dev->quantization_out = V4L2_QUANTIZATION_DEFAULT;
828 dev->colorspace_out = V4L2_COLORSPACE_SRGB;
829 dev->quantization_out = dev->dvi_d_out ?
830 V4L2_QUANTIZATION_LIM_RANGE :
831 V4L2_QUANTIZATION_DEFAULT;
834 vivid_send_source_change(dev, HDMI);
840 static const struct v4l2_ctrl_ops vivid_vid_out_ctrl_ops = {
841 .s_ctrl = vivid_vid_out_s_ctrl,
844 static const struct v4l2_ctrl_config vivid_ctrl_has_crop_out = {
845 .ops = &vivid_vid_out_ctrl_ops,
846 .id = VIVID_CID_HAS_CROP_OUT,
847 .name = "Enable Output Cropping",
848 .type = V4L2_CTRL_TYPE_BOOLEAN,
854 static const struct v4l2_ctrl_config vivid_ctrl_has_compose_out = {
855 .ops = &vivid_vid_out_ctrl_ops,
856 .id = VIVID_CID_HAS_COMPOSE_OUT,
857 .name = "Enable Output Composing",
858 .type = V4L2_CTRL_TYPE_BOOLEAN,
864 static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_out = {
865 .ops = &vivid_vid_out_ctrl_ops,
866 .id = VIVID_CID_HAS_SCALER_OUT,
867 .name = "Enable Output Scaler",
868 .type = V4L2_CTRL_TYPE_BOOLEAN,
875 /* Streaming Controls */
877 static int vivid_streaming_s_ctrl(struct v4l2_ctrl *ctrl)
879 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_streaming);
883 case VIVID_CID_DQBUF_ERROR:
884 dev->dqbuf_error = true;
886 case VIVID_CID_PERC_DROPPED:
887 dev->perc_dropped_buffers = ctrl->val;
889 case VIVID_CID_QUEUE_SETUP_ERROR:
890 dev->queue_setup_error = true;
892 case VIVID_CID_BUF_PREPARE_ERROR:
893 dev->buf_prepare_error = true;
895 case VIVID_CID_START_STR_ERROR:
896 dev->start_streaming_error = true;
898 case VIVID_CID_QUEUE_ERROR:
899 if (vb2_start_streaming_called(&dev->vb_vid_cap_q))
900 vb2_queue_error(&dev->vb_vid_cap_q);
901 if (vb2_start_streaming_called(&dev->vb_vbi_cap_q))
902 vb2_queue_error(&dev->vb_vbi_cap_q);
903 if (vb2_start_streaming_called(&dev->vb_vid_out_q))
904 vb2_queue_error(&dev->vb_vid_out_q);
905 if (vb2_start_streaming_called(&dev->vb_vbi_out_q))
906 vb2_queue_error(&dev->vb_vbi_out_q);
907 if (vb2_start_streaming_called(&dev->vb_sdr_cap_q))
908 vb2_queue_error(&dev->vb_sdr_cap_q);
910 case VIVID_CID_SEQ_WRAP:
911 dev->seq_wrap = ctrl->val;
913 case VIVID_CID_TIME_WRAP:
914 dev->time_wrap = ctrl->val;
915 if (ctrl->val == 0) {
916 dev->time_wrap_offset = 0;
919 v4l2_get_timestamp(&tv);
920 dev->time_wrap_offset = -tv.tv_sec - 16;
926 static const struct v4l2_ctrl_ops vivid_streaming_ctrl_ops = {
927 .s_ctrl = vivid_streaming_s_ctrl,
930 static const struct v4l2_ctrl_config vivid_ctrl_dqbuf_error = {
931 .ops = &vivid_streaming_ctrl_ops,
932 .id = VIVID_CID_DQBUF_ERROR,
933 .name = "Inject V4L2_BUF_FLAG_ERROR",
934 .type = V4L2_CTRL_TYPE_BUTTON,
937 static const struct v4l2_ctrl_config vivid_ctrl_perc_dropped = {
938 .ops = &vivid_streaming_ctrl_ops,
939 .id = VIVID_CID_PERC_DROPPED,
940 .name = "Percentage of Dropped Buffers",
941 .type = V4L2_CTRL_TYPE_INTEGER,
947 static const struct v4l2_ctrl_config vivid_ctrl_queue_setup_error = {
948 .ops = &vivid_streaming_ctrl_ops,
949 .id = VIVID_CID_QUEUE_SETUP_ERROR,
950 .name = "Inject VIDIOC_REQBUFS Error",
951 .type = V4L2_CTRL_TYPE_BUTTON,
954 static const struct v4l2_ctrl_config vivid_ctrl_buf_prepare_error = {
955 .ops = &vivid_streaming_ctrl_ops,
956 .id = VIVID_CID_BUF_PREPARE_ERROR,
957 .name = "Inject VIDIOC_QBUF Error",
958 .type = V4L2_CTRL_TYPE_BUTTON,
961 static const struct v4l2_ctrl_config vivid_ctrl_start_streaming_error = {
962 .ops = &vivid_streaming_ctrl_ops,
963 .id = VIVID_CID_START_STR_ERROR,
964 .name = "Inject VIDIOC_STREAMON Error",
965 .type = V4L2_CTRL_TYPE_BUTTON,
968 static const struct v4l2_ctrl_config vivid_ctrl_queue_error = {
969 .ops = &vivid_streaming_ctrl_ops,
970 .id = VIVID_CID_QUEUE_ERROR,
971 .name = "Inject Fatal Streaming Error",
972 .type = V4L2_CTRL_TYPE_BUTTON,
975 static const struct v4l2_ctrl_config vivid_ctrl_seq_wrap = {
976 .ops = &vivid_streaming_ctrl_ops,
977 .id = VIVID_CID_SEQ_WRAP,
978 .name = "Wrap Sequence Number",
979 .type = V4L2_CTRL_TYPE_BOOLEAN,
984 static const struct v4l2_ctrl_config vivid_ctrl_time_wrap = {
985 .ops = &vivid_streaming_ctrl_ops,
986 .id = VIVID_CID_TIME_WRAP,
987 .name = "Wrap Timestamp",
988 .type = V4L2_CTRL_TYPE_BOOLEAN,
994 /* SDTV Capture Controls */
996 static int vivid_sdtv_cap_s_ctrl(struct v4l2_ctrl *ctrl)
998 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_sdtv_cap);
1001 case VIVID_CID_STD_SIGNAL_MODE:
1002 dev->std_signal_mode = dev->ctrl_std_signal_mode->val;
1003 if (dev->std_signal_mode == SELECTED_STD)
1004 dev->query_std = vivid_standard[dev->ctrl_standard->val];
1005 v4l2_ctrl_activate(dev->ctrl_standard, dev->std_signal_mode == SELECTED_STD);
1006 vivid_update_quality(dev);
1007 vivid_send_source_change(dev, TV);
1008 vivid_send_source_change(dev, SVID);
1014 static const struct v4l2_ctrl_ops vivid_sdtv_cap_ctrl_ops = {
1015 .s_ctrl = vivid_sdtv_cap_s_ctrl,
1018 static const char * const vivid_ctrl_std_signal_mode_strings[] = {
1023 "Selected Standard",
1024 "Cycle Through All Standards",
1028 static const struct v4l2_ctrl_config vivid_ctrl_std_signal_mode = {
1029 .ops = &vivid_sdtv_cap_ctrl_ops,
1030 .id = VIVID_CID_STD_SIGNAL_MODE,
1031 .name = "Standard Signal Mode",
1032 .type = V4L2_CTRL_TYPE_MENU,
1034 .menu_skip_mask = 1 << 3,
1035 .qmenu = vivid_ctrl_std_signal_mode_strings,
1038 static const struct v4l2_ctrl_config vivid_ctrl_standard = {
1039 .ops = &vivid_sdtv_cap_ctrl_ops,
1040 .id = VIVID_CID_STANDARD,
1042 .type = V4L2_CTRL_TYPE_MENU,
1044 .qmenu = vivid_ctrl_standard_strings,
1049 /* Radio Receiver Controls */
1051 static int vivid_radio_rx_s_ctrl(struct v4l2_ctrl *ctrl)
1053 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_rx);
1056 case VIVID_CID_RADIO_SEEK_MODE:
1057 dev->radio_rx_hw_seek_mode = ctrl->val;
1059 case VIVID_CID_RADIO_SEEK_PROG_LIM:
1060 dev->radio_rx_hw_seek_prog_lim = ctrl->val;
1062 case VIVID_CID_RADIO_RX_RDS_RBDS:
1063 dev->rds_gen.use_rbds = ctrl->val;
1065 case VIVID_CID_RADIO_RX_RDS_BLOCKIO:
1066 dev->radio_rx_rds_controls = ctrl->val;
1067 dev->radio_rx_caps &= ~V4L2_CAP_READWRITE;
1068 dev->radio_rx_rds_use_alternates = false;
1069 if (!dev->radio_rx_rds_controls) {
1070 dev->radio_rx_caps |= V4L2_CAP_READWRITE;
1071 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, 0);
1072 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, 0);
1073 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, 0);
1074 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, 0);
1075 __v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, "");
1076 __v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, "");
1078 v4l2_ctrl_activate(dev->radio_rx_rds_pty, dev->radio_rx_rds_controls);
1079 v4l2_ctrl_activate(dev->radio_rx_rds_psname, dev->radio_rx_rds_controls);
1080 v4l2_ctrl_activate(dev->radio_rx_rds_radiotext, dev->radio_rx_rds_controls);
1081 v4l2_ctrl_activate(dev->radio_rx_rds_ta, dev->radio_rx_rds_controls);
1082 v4l2_ctrl_activate(dev->radio_rx_rds_tp, dev->radio_rx_rds_controls);
1083 v4l2_ctrl_activate(dev->radio_rx_rds_ms, dev->radio_rx_rds_controls);
1085 case V4L2_CID_RDS_RECEPTION:
1086 dev->radio_rx_rds_enabled = ctrl->val;
1092 static const struct v4l2_ctrl_ops vivid_radio_rx_ctrl_ops = {
1093 .s_ctrl = vivid_radio_rx_s_ctrl,
1096 static const char * const vivid_ctrl_radio_rds_mode_strings[] = {
1102 static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_blockio = {
1103 .ops = &vivid_radio_rx_ctrl_ops,
1104 .id = VIVID_CID_RADIO_RX_RDS_BLOCKIO,
1105 .name = "RDS Rx I/O Mode",
1106 .type = V4L2_CTRL_TYPE_MENU,
1107 .qmenu = vivid_ctrl_radio_rds_mode_strings,
1111 static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_rbds = {
1112 .ops = &vivid_radio_rx_ctrl_ops,
1113 .id = VIVID_CID_RADIO_RX_RDS_RBDS,
1114 .name = "Generate RBDS Instead of RDS",
1115 .type = V4L2_CTRL_TYPE_BOOLEAN,
1120 static const char * const vivid_ctrl_radio_hw_seek_mode_strings[] = {
1127 static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_mode = {
1128 .ops = &vivid_radio_rx_ctrl_ops,
1129 .id = VIVID_CID_RADIO_SEEK_MODE,
1130 .name = "Radio HW Seek Mode",
1131 .type = V4L2_CTRL_TYPE_MENU,
1133 .qmenu = vivid_ctrl_radio_hw_seek_mode_strings,
1136 static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_prog_lim = {
1137 .ops = &vivid_radio_rx_ctrl_ops,
1138 .id = VIVID_CID_RADIO_SEEK_PROG_LIM,
1139 .name = "Radio Programmable HW Seek",
1140 .type = V4L2_CTRL_TYPE_BOOLEAN,
1146 /* Radio Transmitter Controls */
1148 static int vivid_radio_tx_s_ctrl(struct v4l2_ctrl *ctrl)
1150 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_tx);
1153 case VIVID_CID_RADIO_TX_RDS_BLOCKIO:
1154 dev->radio_tx_rds_controls = ctrl->val;
1155 dev->radio_tx_caps &= ~V4L2_CAP_READWRITE;
1156 if (!dev->radio_tx_rds_controls)
1157 dev->radio_tx_caps |= V4L2_CAP_READWRITE;
1159 case V4L2_CID_RDS_TX_PTY:
1160 if (dev->radio_rx_rds_controls)
1161 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, ctrl->val);
1163 case V4L2_CID_RDS_TX_PS_NAME:
1164 if (dev->radio_rx_rds_controls)
1165 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, ctrl->p_new.p_char);
1167 case V4L2_CID_RDS_TX_RADIO_TEXT:
1168 if (dev->radio_rx_rds_controls)
1169 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, ctrl->p_new.p_char);
1171 case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1172 if (dev->radio_rx_rds_controls)
1173 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, ctrl->val);
1175 case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1176 if (dev->radio_rx_rds_controls)
1177 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, ctrl->val);
1179 case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1180 if (dev->radio_rx_rds_controls)
1181 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, ctrl->val);
1187 static const struct v4l2_ctrl_ops vivid_radio_tx_ctrl_ops = {
1188 .s_ctrl = vivid_radio_tx_s_ctrl,
1191 static const struct v4l2_ctrl_config vivid_ctrl_radio_tx_rds_blockio = {
1192 .ops = &vivid_radio_tx_ctrl_ops,
1193 .id = VIVID_CID_RADIO_TX_RDS_BLOCKIO,
1194 .name = "RDS Tx I/O Mode",
1195 .type = V4L2_CTRL_TYPE_MENU,
1196 .qmenu = vivid_ctrl_radio_rds_mode_strings,
1203 /* Video Loop Control */
1205 static int vivid_loop_out_s_ctrl(struct v4l2_ctrl *ctrl)
1207 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_loop_out);
1210 case VIVID_CID_LOOP_VIDEO:
1211 dev->loop_video = ctrl->val;
1212 vivid_update_quality(dev);
1213 vivid_send_source_change(dev, SVID);
1214 vivid_send_source_change(dev, HDMI);
1220 static const struct v4l2_ctrl_ops vivid_loop_out_ctrl_ops = {
1221 .s_ctrl = vivid_loop_out_s_ctrl,
1224 static const struct v4l2_ctrl_config vivid_ctrl_loop_video = {
1225 .ops = &vivid_loop_out_ctrl_ops,
1226 .id = VIVID_CID_LOOP_VIDEO,
1227 .name = "Loop Video",
1228 .type = V4L2_CTRL_TYPE_BOOLEAN,
1234 static const struct v4l2_ctrl_config vivid_ctrl_class = {
1235 .ops = &vivid_user_gen_ctrl_ops,
1236 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY,
1237 .id = VIVID_CID_VIVID_CLASS,
1238 .name = "Vivid Controls",
1239 .type = V4L2_CTRL_TYPE_CTRL_CLASS,
1242 int vivid_create_controls(struct vivid_dev *dev, bool show_ccs_cap,
1243 bool show_ccs_out, bool no_error_inj,
1244 bool has_sdtv, bool has_hdmi)
1246 struct v4l2_ctrl_handler *hdl_user_gen = &dev->ctrl_hdl_user_gen;
1247 struct v4l2_ctrl_handler *hdl_user_vid = &dev->ctrl_hdl_user_vid;
1248 struct v4l2_ctrl_handler *hdl_user_aud = &dev->ctrl_hdl_user_aud;
1249 struct v4l2_ctrl_handler *hdl_streaming = &dev->ctrl_hdl_streaming;
1250 struct v4l2_ctrl_handler *hdl_sdtv_cap = &dev->ctrl_hdl_sdtv_cap;
1251 struct v4l2_ctrl_handler *hdl_loop_out = &dev->ctrl_hdl_loop_out;
1252 struct v4l2_ctrl_handler *hdl_vid_cap = &dev->ctrl_hdl_vid_cap;
1253 struct v4l2_ctrl_handler *hdl_vid_out = &dev->ctrl_hdl_vid_out;
1254 struct v4l2_ctrl_handler *hdl_vbi_cap = &dev->ctrl_hdl_vbi_cap;
1255 struct v4l2_ctrl_handler *hdl_vbi_out = &dev->ctrl_hdl_vbi_out;
1256 struct v4l2_ctrl_handler *hdl_radio_rx = &dev->ctrl_hdl_radio_rx;
1257 struct v4l2_ctrl_handler *hdl_radio_tx = &dev->ctrl_hdl_radio_tx;
1258 struct v4l2_ctrl_handler *hdl_sdr_cap = &dev->ctrl_hdl_sdr_cap;
1259 struct v4l2_ctrl_config vivid_ctrl_dv_timings = {
1260 .ops = &vivid_vid_cap_ctrl_ops,
1261 .id = VIVID_CID_DV_TIMINGS,
1262 .name = "DV Timings",
1263 .type = V4L2_CTRL_TYPE_MENU,
1267 v4l2_ctrl_handler_init(hdl_user_gen, 10);
1268 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_class, NULL);
1269 v4l2_ctrl_handler_init(hdl_user_vid, 9);
1270 v4l2_ctrl_new_custom(hdl_user_vid, &vivid_ctrl_class, NULL);
1271 v4l2_ctrl_handler_init(hdl_user_aud, 2);
1272 v4l2_ctrl_new_custom(hdl_user_aud, &vivid_ctrl_class, NULL);
1273 v4l2_ctrl_handler_init(hdl_streaming, 8);
1274 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_class, NULL);
1275 v4l2_ctrl_handler_init(hdl_sdtv_cap, 2);
1276 v4l2_ctrl_new_custom(hdl_sdtv_cap, &vivid_ctrl_class, NULL);
1277 v4l2_ctrl_handler_init(hdl_loop_out, 1);
1278 v4l2_ctrl_new_custom(hdl_loop_out, &vivid_ctrl_class, NULL);
1279 v4l2_ctrl_handler_init(hdl_vid_cap, 55);
1280 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_class, NULL);
1281 v4l2_ctrl_handler_init(hdl_vid_out, 26);
1282 v4l2_ctrl_new_custom(hdl_vid_out, &vivid_ctrl_class, NULL);
1283 v4l2_ctrl_handler_init(hdl_vbi_cap, 21);
1284 v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_class, NULL);
1285 v4l2_ctrl_handler_init(hdl_vbi_out, 19);
1286 v4l2_ctrl_new_custom(hdl_vbi_out, &vivid_ctrl_class, NULL);
1287 v4l2_ctrl_handler_init(hdl_radio_rx, 17);
1288 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_class, NULL);
1289 v4l2_ctrl_handler_init(hdl_radio_tx, 17);
1290 v4l2_ctrl_new_custom(hdl_radio_tx, &vivid_ctrl_class, NULL);
1291 v4l2_ctrl_handler_init(hdl_sdr_cap, 18);
1292 v4l2_ctrl_new_custom(hdl_sdr_cap, &vivid_ctrl_class, NULL);
1295 dev->volume = v4l2_ctrl_new_std(hdl_user_aud, NULL,
1296 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1297 dev->mute = v4l2_ctrl_new_std(hdl_user_aud, NULL,
1298 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
1299 if (dev->has_vid_cap) {
1300 dev->brightness = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1301 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1302 for (i = 0; i < MAX_INPUTS; i++)
1303 dev->input_brightness[i] = 128;
1304 dev->contrast = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1305 V4L2_CID_CONTRAST, 0, 255, 1, 128);
1306 dev->saturation = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1307 V4L2_CID_SATURATION, 0, 255, 1, 128);
1308 dev->hue = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1309 V4L2_CID_HUE, -128, 128, 1, 0);
1310 v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1311 V4L2_CID_HFLIP, 0, 1, 1, 0);
1312 v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1313 V4L2_CID_VFLIP, 0, 1, 1, 0);
1314 dev->autogain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1315 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1316 dev->gain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1317 V4L2_CID_GAIN, 0, 255, 1, 100);
1318 dev->alpha = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1319 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1321 dev->button = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_button, NULL);
1322 dev->int32 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int32, NULL);
1323 dev->int64 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int64, NULL);
1324 dev->boolean = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_boolean, NULL);
1325 dev->menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_menu, NULL);
1326 dev->string = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_string, NULL);
1327 dev->bitmask = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_bitmask, NULL);
1328 dev->int_menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int_menu, NULL);
1329 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u32_array, NULL);
1330 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u16_matrix, NULL);
1331 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u8_4d_array, NULL);
1333 if (dev->has_vid_cap) {
1334 /* Image Processing Controls */
1335 struct v4l2_ctrl_config vivid_ctrl_test_pattern = {
1336 .ops = &vivid_vid_cap_ctrl_ops,
1337 .id = VIVID_CID_TEST_PATTERN,
1338 .name = "Test Pattern",
1339 .type = V4L2_CTRL_TYPE_MENU,
1340 .max = TPG_PAT_NOISE,
1341 .qmenu = tpg_pattern_strings,
1344 dev->test_pattern = v4l2_ctrl_new_custom(hdl_vid_cap,
1345 &vivid_ctrl_test_pattern, NULL);
1346 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_perc_fill, NULL);
1347 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hor_movement, NULL);
1348 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vert_movement, NULL);
1349 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_osd_mode, NULL);
1350 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_border, NULL);
1351 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_square, NULL);
1352 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hflip, NULL);
1353 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vflip, NULL);
1354 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_sav, NULL);
1355 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_eav, NULL);
1357 dev->ctrl_has_crop_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1358 &vivid_ctrl_has_crop_cap, NULL);
1359 dev->ctrl_has_compose_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1360 &vivid_ctrl_has_compose_cap, NULL);
1361 dev->ctrl_has_scaler_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1362 &vivid_ctrl_has_scaler_cap, NULL);
1365 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_tstamp_src, NULL);
1366 dev->colorspace = v4l2_ctrl_new_custom(hdl_vid_cap,
1367 &vivid_ctrl_colorspace, NULL);
1368 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_ycbcr_enc, NULL);
1369 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_quantization, NULL);
1370 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_alpha_mode, NULL);
1373 if (dev->has_vid_out && show_ccs_out) {
1374 dev->ctrl_has_crop_out = v4l2_ctrl_new_custom(hdl_vid_out,
1375 &vivid_ctrl_has_crop_out, NULL);
1376 dev->ctrl_has_compose_out = v4l2_ctrl_new_custom(hdl_vid_out,
1377 &vivid_ctrl_has_compose_out, NULL);
1378 dev->ctrl_has_scaler_out = v4l2_ctrl_new_custom(hdl_vid_out,
1379 &vivid_ctrl_has_scaler_out, NULL);
1383 * Testing this driver with v4l2-compliance will trigger the error
1384 * injection controls, and after that nothing will work as expected.
1385 * So we have a module option to drop these error injecting controls
1386 * allowing us to run v4l2_compliance again.
1388 if (!no_error_inj) {
1389 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_disconnect, NULL);
1390 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_dqbuf_error, NULL);
1391 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_perc_dropped, NULL);
1392 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_setup_error, NULL);
1393 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_buf_prepare_error, NULL);
1394 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_start_streaming_error, NULL);
1395 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_error, NULL);
1396 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_seq_wrap, NULL);
1397 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_time_wrap, NULL);
1400 if (has_sdtv && (dev->has_vid_cap || dev->has_vbi_cap)) {
1401 if (dev->has_vid_cap)
1402 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_std_aspect_ratio, NULL);
1403 dev->ctrl_std_signal_mode = v4l2_ctrl_new_custom(hdl_sdtv_cap,
1404 &vivid_ctrl_std_signal_mode, NULL);
1405 dev->ctrl_standard = v4l2_ctrl_new_custom(hdl_sdtv_cap,
1406 &vivid_ctrl_standard, NULL);
1407 if (dev->ctrl_std_signal_mode)
1408 v4l2_ctrl_cluster(2, &dev->ctrl_std_signal_mode);
1409 if (dev->has_raw_vbi_cap)
1410 v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_vbi_cap_interlaced, NULL);
1413 if (has_hdmi && dev->has_vid_cap) {
1414 dev->ctrl_dv_timings_signal_mode = v4l2_ctrl_new_custom(hdl_vid_cap,
1415 &vivid_ctrl_dv_timings_signal_mode, NULL);
1417 vivid_ctrl_dv_timings.max = dev->query_dv_timings_size - 1;
1418 vivid_ctrl_dv_timings.qmenu =
1419 (const char * const *)dev->query_dv_timings_qmenu;
1420 dev->ctrl_dv_timings = v4l2_ctrl_new_custom(hdl_vid_cap,
1421 &vivid_ctrl_dv_timings, NULL);
1422 if (dev->ctrl_dv_timings_signal_mode)
1423 v4l2_ctrl_cluster(2, &dev->ctrl_dv_timings_signal_mode);
1425 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_dv_timings_aspect_ratio, NULL);
1426 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_max_edid_blocks, NULL);
1427 dev->real_rgb_range_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1428 &vivid_ctrl_limited_rgb_range, NULL);
1429 dev->rgb_range_cap = v4l2_ctrl_new_std_menu(hdl_vid_cap,
1430 &vivid_vid_cap_ctrl_ops,
1431 V4L2_CID_DV_RX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1432 0, V4L2_DV_RGB_RANGE_AUTO);
1434 if (has_hdmi && dev->has_vid_out) {
1436 * We aren't doing anything with this at the moment, but
1437 * HDMI outputs typically have this controls.
1439 dev->ctrl_tx_rgb_range = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
1440 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1441 0, V4L2_DV_RGB_RANGE_AUTO);
1442 dev->ctrl_tx_mode = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
1443 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1444 0, V4L2_DV_TX_MODE_HDMI);
1446 if ((dev->has_vid_cap && dev->has_vid_out) ||
1447 (dev->has_vbi_cap && dev->has_vbi_out))
1448 v4l2_ctrl_new_custom(hdl_loop_out, &vivid_ctrl_loop_video, NULL);
1451 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_clear_fb, NULL);
1453 if (dev->has_radio_rx) {
1454 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_mode, NULL);
1455 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_prog_lim, NULL);
1456 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_blockio, NULL);
1457 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_rbds, NULL);
1458 v4l2_ctrl_new_std(hdl_radio_rx, &vivid_radio_rx_ctrl_ops,
1459 V4L2_CID_RDS_RECEPTION, 0, 1, 1, 1);
1460 dev->radio_rx_rds_pty = v4l2_ctrl_new_std(hdl_radio_rx,
1461 &vivid_radio_rx_ctrl_ops,
1462 V4L2_CID_RDS_RX_PTY, 0, 31, 1, 0);
1463 dev->radio_rx_rds_psname = v4l2_ctrl_new_std(hdl_radio_rx,
1464 &vivid_radio_rx_ctrl_ops,
1465 V4L2_CID_RDS_RX_PS_NAME, 0, 8, 8, 0);
1466 dev->radio_rx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_rx,
1467 &vivid_radio_rx_ctrl_ops,
1468 V4L2_CID_RDS_RX_RADIO_TEXT, 0, 64, 64, 0);
1469 dev->radio_rx_rds_ta = v4l2_ctrl_new_std(hdl_radio_rx,
1470 &vivid_radio_rx_ctrl_ops,
1471 V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1472 dev->radio_rx_rds_tp = v4l2_ctrl_new_std(hdl_radio_rx,
1473 &vivid_radio_rx_ctrl_ops,
1474 V4L2_CID_RDS_RX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1475 dev->radio_rx_rds_ms = v4l2_ctrl_new_std(hdl_radio_rx,
1476 &vivid_radio_rx_ctrl_ops,
1477 V4L2_CID_RDS_RX_MUSIC_SPEECH, 0, 1, 1, 1);
1479 if (dev->has_radio_tx) {
1480 v4l2_ctrl_new_custom(hdl_radio_tx,
1481 &vivid_ctrl_radio_tx_rds_blockio, NULL);
1482 dev->radio_tx_rds_pi = v4l2_ctrl_new_std(hdl_radio_tx,
1483 &vivid_radio_tx_ctrl_ops,
1484 V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, 0x8088);
1485 dev->radio_tx_rds_pty = v4l2_ctrl_new_std(hdl_radio_tx,
1486 &vivid_radio_tx_ctrl_ops,
1487 V4L2_CID_RDS_TX_PTY, 0, 31, 1, 3);
1488 dev->radio_tx_rds_psname = v4l2_ctrl_new_std(hdl_radio_tx,
1489 &vivid_radio_tx_ctrl_ops,
1490 V4L2_CID_RDS_TX_PS_NAME, 0, 8, 8, 0);
1491 if (dev->radio_tx_rds_psname)
1492 v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_psname, "VIVID-TX");
1493 dev->radio_tx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_tx,
1494 &vivid_radio_tx_ctrl_ops,
1495 V4L2_CID_RDS_TX_RADIO_TEXT, 0, 64 * 2, 64, 0);
1496 if (dev->radio_tx_rds_radiotext)
1497 v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_radiotext,
1498 "This is a VIVID default Radio Text template text, change at will");
1499 dev->radio_tx_rds_mono_stereo = v4l2_ctrl_new_std(hdl_radio_tx,
1500 &vivid_radio_tx_ctrl_ops,
1501 V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1502 dev->radio_tx_rds_art_head = v4l2_ctrl_new_std(hdl_radio_tx,
1503 &vivid_radio_tx_ctrl_ops,
1504 V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1505 dev->radio_tx_rds_compressed = v4l2_ctrl_new_std(hdl_radio_tx,
1506 &vivid_radio_tx_ctrl_ops,
1507 V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1508 dev->radio_tx_rds_dyn_pty = v4l2_ctrl_new_std(hdl_radio_tx,
1509 &vivid_radio_tx_ctrl_ops,
1510 V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1511 dev->radio_tx_rds_ta = v4l2_ctrl_new_std(hdl_radio_tx,
1512 &vivid_radio_tx_ctrl_ops,
1513 V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1514 dev->radio_tx_rds_tp = v4l2_ctrl_new_std(hdl_radio_tx,
1515 &vivid_radio_tx_ctrl_ops,
1516 V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 1);
1517 dev->radio_tx_rds_ms = v4l2_ctrl_new_std(hdl_radio_tx,
1518 &vivid_radio_tx_ctrl_ops,
1519 V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1521 if (hdl_user_gen->error)
1522 return hdl_user_gen->error;
1523 if (hdl_user_vid->error)
1524 return hdl_user_vid->error;
1525 if (hdl_user_aud->error)
1526 return hdl_user_aud->error;
1527 if (hdl_streaming->error)
1528 return hdl_streaming->error;
1529 if (hdl_sdr_cap->error)
1530 return hdl_sdr_cap->error;
1531 if (hdl_loop_out->error)
1532 return hdl_loop_out->error;
1535 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1537 if (dev->has_vid_cap) {
1538 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_gen, NULL);
1539 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_vid, NULL);
1540 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_aud, NULL);
1541 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_streaming, NULL);
1542 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_sdtv_cap, NULL);
1543 if (hdl_vid_cap->error)
1544 return hdl_vid_cap->error;
1545 dev->vid_cap_dev.ctrl_handler = hdl_vid_cap;
1547 if (dev->has_vid_out) {
1548 v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_gen, NULL);
1549 v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_aud, NULL);
1550 v4l2_ctrl_add_handler(hdl_vid_out, hdl_streaming, NULL);
1551 v4l2_ctrl_add_handler(hdl_vid_out, hdl_loop_out, NULL);
1552 if (hdl_vid_out->error)
1553 return hdl_vid_out->error;
1554 dev->vid_out_dev.ctrl_handler = hdl_vid_out;
1556 if (dev->has_vbi_cap) {
1557 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_user_gen, NULL);
1558 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_streaming, NULL);
1559 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_sdtv_cap, NULL);
1560 if (hdl_vbi_cap->error)
1561 return hdl_vbi_cap->error;
1562 dev->vbi_cap_dev.ctrl_handler = hdl_vbi_cap;
1564 if (dev->has_vbi_out) {
1565 v4l2_ctrl_add_handler(hdl_vbi_out, hdl_user_gen, NULL);
1566 v4l2_ctrl_add_handler(hdl_vbi_out, hdl_streaming, NULL);
1567 v4l2_ctrl_add_handler(hdl_vbi_out, hdl_loop_out, NULL);
1568 if (hdl_vbi_out->error)
1569 return hdl_vbi_out->error;
1570 dev->vbi_out_dev.ctrl_handler = hdl_vbi_out;
1572 if (dev->has_radio_rx) {
1573 v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_gen, NULL);
1574 v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_aud, NULL);
1575 if (hdl_radio_rx->error)
1576 return hdl_radio_rx->error;
1577 dev->radio_rx_dev.ctrl_handler = hdl_radio_rx;
1579 if (dev->has_radio_tx) {
1580 v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_gen, NULL);
1581 v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_aud, NULL);
1582 if (hdl_radio_tx->error)
1583 return hdl_radio_tx->error;
1584 dev->radio_tx_dev.ctrl_handler = hdl_radio_tx;
1586 if (dev->has_sdr_cap) {
1587 v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_user_gen, NULL);
1588 v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_streaming, NULL);
1589 if (hdl_sdr_cap->error)
1590 return hdl_sdr_cap->error;
1591 dev->sdr_cap_dev.ctrl_handler = hdl_sdr_cap;
1596 void vivid_free_controls(struct vivid_dev *dev)
1598 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_cap);
1599 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_out);
1600 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_cap);
1601 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_out);
1602 v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_rx);
1603 v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_tx);
1604 v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdr_cap);
1605 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_gen);
1606 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_vid);
1607 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_aud);
1608 v4l2_ctrl_handler_free(&dev->ctrl_hdl_streaming);
1609 v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdtv_cap);
1610 v4l2_ctrl_handler_free(&dev->ctrl_hdl_loop_out);