?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / platform / vivid / vivid-ctrls.c
blob334130568dcbddecca24e05343dda2232599a260
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * vivid-ctrls.c - control support functions.
4 *
5 * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
6 */
7
8 #include <linux/errno.h>
9 #include <linux/kernel.h>
10 #include <linux/videodev2.h>
11 #include <media/v4l2-event.h>
12 #include <media/v4l2-common.h>
13
14 #include "vivid-core.h"
15 #include "vivid-vid-cap.h"
16 #include "vivid-vid-out.h"
17 #include "vivid-vid-common.h"
18 #include "vivid-radio-common.h"
19 #include "vivid-osd.h"
20 #include "vivid-ctrls.h"
21 #include "vivid-cec.h"
22
23 #define VIVID_CID_CUSTOM_BASE (V4L2_CID_USER_BASE | 0xf000)
24 #define VIVID_CID_BUTTON (VIVID_CID_CUSTOM_BASE + 0)
25 #define VIVID_CID_BOOLEAN (VIVID_CID_CUSTOM_BASE + 1)
26 #define VIVID_CID_INTEGER (VIVID_CID_CUSTOM_BASE + 2)
27 #define VIVID_CID_INTEGER64 (VIVID_CID_CUSTOM_BASE + 3)
28 #define VIVID_CID_MENU (VIVID_CID_CUSTOM_BASE + 4)
29 #define VIVID_CID_STRING (VIVID_CID_CUSTOM_BASE + 5)
30 #define VIVID_CID_BITMASK (VIVID_CID_CUSTOM_BASE + 6)
31 #define VIVID_CID_INTMENU (VIVID_CID_CUSTOM_BASE + 7)
32 #define VIVID_CID_U32_ARRAY (VIVID_CID_CUSTOM_BASE + 8)
33 #define VIVID_CID_U16_MATRIX (VIVID_CID_CUSTOM_BASE + 9)
34 #define VIVID_CID_U8_4D_ARRAY (VIVID_CID_CUSTOM_BASE + 10)
35 #define VIVID_CID_AREA (VIVID_CID_CUSTOM_BASE + 11)
36
37 #define VIVID_CID_VIVID_BASE (0x00f00000 | 0xf000)
38 #define VIVID_CID_VIVID_CLASS (0x00f00000 | 1)
39 #define VIVID_CID_TEST_PATTERN (VIVID_CID_VIVID_BASE + 0)
40 #define VIVID_CID_OSD_TEXT_MODE (VIVID_CID_VIVID_BASE + 1)
41 #define VIVID_CID_HOR_MOVEMENT (VIVID_CID_VIVID_BASE + 2)
42 #define VIVID_CID_VERT_MOVEMENT (VIVID_CID_VIVID_BASE + 3)
43 #define VIVID_CID_SHOW_BORDER (VIVID_CID_VIVID_BASE + 4)
44 #define VIVID_CID_SHOW_SQUARE (VIVID_CID_VIVID_BASE + 5)
45 #define VIVID_CID_INSERT_SAV (VIVID_CID_VIVID_BASE + 6)
46 #define VIVID_CID_INSERT_EAV (VIVID_CID_VIVID_BASE + 7)
47 #define VIVID_CID_VBI_CAP_INTERLACED (VIVID_CID_VIVID_BASE + 8)
48
49 #define VIVID_CID_HFLIP (VIVID_CID_VIVID_BASE + 20)
50 #define VIVID_CID_VFLIP (VIVID_CID_VIVID_BASE + 21)
51 #define VIVID_CID_STD_ASPECT_RATIO (VIVID_CID_VIVID_BASE + 22)
52 #define VIVID_CID_DV_TIMINGS_ASPECT_RATIO (VIVID_CID_VIVID_BASE + 23)
53 #define VIVID_CID_TSTAMP_SRC (VIVID_CID_VIVID_BASE + 24)
54 #define VIVID_CID_COLORSPACE (VIVID_CID_VIVID_BASE + 25)
55 #define VIVID_CID_XFER_FUNC (VIVID_CID_VIVID_BASE + 26)
56 #define VIVID_CID_YCBCR_ENC (VIVID_CID_VIVID_BASE + 27)
57 #define VIVID_CID_QUANTIZATION (VIVID_CID_VIVID_BASE + 28)
58 #define VIVID_CID_LIMITED_RGB_RANGE (VIVID_CID_VIVID_BASE + 29)
59 #define VIVID_CID_ALPHA_MODE (VIVID_CID_VIVID_BASE + 30)
60 #define VIVID_CID_HAS_CROP_CAP (VIVID_CID_VIVID_BASE + 31)
61 #define VIVID_CID_HAS_COMPOSE_CAP (VIVID_CID_VIVID_BASE + 32)
62 #define VIVID_CID_HAS_SCALER_CAP (VIVID_CID_VIVID_BASE + 33)
63 #define VIVID_CID_HAS_CROP_OUT (VIVID_CID_VIVID_BASE + 34)
64 #define VIVID_CID_HAS_COMPOSE_OUT (VIVID_CID_VIVID_BASE + 35)
65 #define VIVID_CID_HAS_SCALER_OUT (VIVID_CID_VIVID_BASE + 36)
66 #define VIVID_CID_LOOP_VIDEO (VIVID_CID_VIVID_BASE + 37)
67 #define VIVID_CID_SEQ_WRAP (VIVID_CID_VIVID_BASE + 38)
68 #define VIVID_CID_TIME_WRAP (VIVID_CID_VIVID_BASE + 39)
69 #define VIVID_CID_MAX_EDID_BLOCKS (VIVID_CID_VIVID_BASE + 40)
70 #define VIVID_CID_PERCENTAGE_FILL (VIVID_CID_VIVID_BASE + 41)
71 #define VIVID_CID_REDUCED_FPS (VIVID_CID_VIVID_BASE + 42)
72 #define VIVID_CID_HSV_ENC (VIVID_CID_VIVID_BASE + 43)
73 #define VIVID_CID_DISPLAY_PRESENT (VIVID_CID_VIVID_BASE + 44)
74
75 #define VIVID_CID_STD_SIGNAL_MODE (VIVID_CID_VIVID_BASE + 60)
76 #define VIVID_CID_STANDARD (VIVID_CID_VIVID_BASE + 61)
77 #define VIVID_CID_DV_TIMINGS_SIGNAL_MODE (VIVID_CID_VIVID_BASE + 62)
78 #define VIVID_CID_DV_TIMINGS (VIVID_CID_VIVID_BASE + 63)
79 #define VIVID_CID_PERC_DROPPED (VIVID_CID_VIVID_BASE + 64)
80 #define VIVID_CID_DISCONNECT (VIVID_CID_VIVID_BASE + 65)
81 #define VIVID_CID_DQBUF_ERROR (VIVID_CID_VIVID_BASE + 66)
82 #define VIVID_CID_QUEUE_SETUP_ERROR (VIVID_CID_VIVID_BASE + 67)
83 #define VIVID_CID_BUF_PREPARE_ERROR (VIVID_CID_VIVID_BASE + 68)
84 #define VIVID_CID_START_STR_ERROR (VIVID_CID_VIVID_BASE + 69)
85 #define VIVID_CID_QUEUE_ERROR (VIVID_CID_VIVID_BASE + 70)
86 #define VIVID_CID_CLEAR_FB (VIVID_CID_VIVID_BASE + 71)
87 #define VIVID_CID_REQ_VALIDATE_ERROR (VIVID_CID_VIVID_BASE + 72)
88
89 #define VIVID_CID_RADIO_SEEK_MODE (VIVID_CID_VIVID_BASE + 90)
90 #define VIVID_CID_RADIO_SEEK_PROG_LIM (VIVID_CID_VIVID_BASE + 91)
91 #define VIVID_CID_RADIO_RX_RDS_RBDS (VIVID_CID_VIVID_BASE + 92)
92 #define VIVID_CID_RADIO_RX_RDS_BLOCKIO (VIVID_CID_VIVID_BASE + 93)
93
94 #define VIVID_CID_RADIO_TX_RDS_BLOCKIO (VIVID_CID_VIVID_BASE + 94)
95
96 #define VIVID_CID_SDR_CAP_FM_DEVIATION (VIVID_CID_VIVID_BASE + 110)
97
98 #define VIVID_CID_META_CAP_GENERATE_PTS (VIVID_CID_VIVID_BASE + 111)
99 #define VIVID_CID_META_CAP_GENERATE_SCR (VIVID_CID_VIVID_BASE + 112)
100
101 /* General User Controls */
102
103 static int vivid_user_gen_s_ctrl(struct v4l2_ctrl *ctrl)
104 {
105 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_gen);
106
107 switch (ctrl->id) {
108 case VIVID_CID_DISCONNECT:
109 v4l2_info(&dev->v4l2_dev, "disconnect\n");
110 clear_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
111 clear_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
112 clear_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
113 clear_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
114 clear_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
115 clear_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
116 clear_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
117 clear_bit(V4L2_FL_REGISTERED, &dev->meta_cap_dev.flags);
118 break;
119 case VIVID_CID_BUTTON:
120 dev->button_pressed = 30;
121 break;
122 }
123 return 0;
124 }
125
126 static const struct v4l2_ctrl_ops vivid_user_gen_ctrl_ops = {
127 .s_ctrl = vivid_user_gen_s_ctrl,
128 };
129
130 static const struct v4l2_ctrl_config vivid_ctrl_button = {
131 .ops = &vivid_user_gen_ctrl_ops,
132 .id = VIVID_CID_BUTTON,
133 .name = "Button",
134 .type = V4L2_CTRL_TYPE_BUTTON,
135 };
136
137 static const struct v4l2_ctrl_config vivid_ctrl_boolean = {
138 .ops = &vivid_user_gen_ctrl_ops,
139 .id = VIVID_CID_BOOLEAN,
140 .name = "Boolean",
141 .type = V4L2_CTRL_TYPE_BOOLEAN,
142 .min = 0,
143 .max = 1,
144 .step = 1,
145 .def = 1,
146 };
147
148 static const struct v4l2_ctrl_config vivid_ctrl_int32 = {
149 .ops = &vivid_user_gen_ctrl_ops,
150 .id = VIVID_CID_INTEGER,
151 .name = "Integer 32 Bits",
152 .type = V4L2_CTRL_TYPE_INTEGER,
153 .min = 0xffffffff80000000ULL,
154 .max = 0x7fffffff,
155 .step = 1,
156 };
157
158 static const struct v4l2_ctrl_config vivid_ctrl_int64 = {
159 .ops = &vivid_user_gen_ctrl_ops,
160 .id = VIVID_CID_INTEGER64,
161 .name = "Integer 64 Bits",
162 .type = V4L2_CTRL_TYPE_INTEGER64,
163 .min = 0x8000000000000000ULL,
164 .max = 0x7fffffffffffffffLL,
165 .step = 1,
166 };
167
168 static const struct v4l2_ctrl_config vivid_ctrl_u32_array = {
169 .ops = &vivid_user_gen_ctrl_ops,
170 .id = VIVID_CID_U32_ARRAY,
171 .name = "U32 1 Element Array",
172 .type = V4L2_CTRL_TYPE_U32,
173 .def = 0x18,
174 .min = 0x10,
175 .max = 0x20000,
176 .step = 1,
177 .dims = { 1 },
178 };
179
180 static const struct v4l2_ctrl_config vivid_ctrl_u16_matrix = {
181 .ops = &vivid_user_gen_ctrl_ops,
182 .id = VIVID_CID_U16_MATRIX,
183 .name = "U16 8x16 Matrix",
184 .type = V4L2_CTRL_TYPE_U16,
185 .def = 0x18,
186 .min = 0x10,
187 .max = 0x2000,
188 .step = 1,
189 .dims = { 8, 16 },
190 };
191
192 static const struct v4l2_ctrl_config vivid_ctrl_u8_4d_array = {
193 .ops = &vivid_user_gen_ctrl_ops,
194 .id = VIVID_CID_U8_4D_ARRAY,
195 .name = "U8 2x3x4x5 Array",
196 .type = V4L2_CTRL_TYPE_U8,
197 .def = 0x18,
198 .min = 0x10,
199 .max = 0x20,
200 .step = 1,
201 .dims = { 2, 3, 4, 5 },
202 };
203
204 static const char * const vivid_ctrl_menu_strings[] = {
205 "Menu Item 0 (Skipped)",
206 "Menu Item 1",
207 "Menu Item 2 (Skipped)",
208 "Menu Item 3",
209 "Menu Item 4",
210 "Menu Item 5 (Skipped)",
211 NULL,
212 };
213
214 static const struct v4l2_ctrl_config vivid_ctrl_menu = {
215 .ops = &vivid_user_gen_ctrl_ops,
216 .id = VIVID_CID_MENU,
217 .name = "Menu",
218 .type = V4L2_CTRL_TYPE_MENU,
219 .min = 1,
220 .max = 4,
221 .def = 3,
222 .menu_skip_mask = 0x04,
223 .qmenu = vivid_ctrl_menu_strings,
224 };
225
226 static const struct v4l2_ctrl_config vivid_ctrl_string = {
227 .ops = &vivid_user_gen_ctrl_ops,
228 .id = VIVID_CID_STRING,
229 .name = "String",
230 .type = V4L2_CTRL_TYPE_STRING,
231 .min = 2,
232 .max = 4,
233 .step = 1,
234 };
235
236 static const struct v4l2_ctrl_config vivid_ctrl_bitmask = {
237 .ops = &vivid_user_gen_ctrl_ops,
238 .id = VIVID_CID_BITMASK,
239 .name = "Bitmask",
240 .type = V4L2_CTRL_TYPE_BITMASK,
241 .def = 0x80002000,
242 .min = 0,
243 .max = 0x80402010,
244 .step = 0,
245 };
246
247 static const s64 vivid_ctrl_int_menu_values[] = {
248 1, 1, 2, 3, 5, 8, 13, 21, 42,
249 };
250
251 static const struct v4l2_ctrl_config vivid_ctrl_int_menu = {
252 .ops = &vivid_user_gen_ctrl_ops,
253 .id = VIVID_CID_INTMENU,
254 .name = "Integer Menu",
255 .type = V4L2_CTRL_TYPE_INTEGER_MENU,
256 .min = 1,
257 .max = 8,
258 .def = 4,
259 .menu_skip_mask = 0x02,
260 .qmenu_int = vivid_ctrl_int_menu_values,
261 };
262
263 static const struct v4l2_ctrl_config vivid_ctrl_disconnect = {
264 .ops = &vivid_user_gen_ctrl_ops,
265 .id = VIVID_CID_DISCONNECT,
266 .name = "Disconnect",
267 .type = V4L2_CTRL_TYPE_BUTTON,
268 };
269
270 static const struct v4l2_area area = {
271 .width = 1000,
272 .height = 2000,
273 };
274
275 static const struct v4l2_ctrl_config vivid_ctrl_area = {
276 .ops = &vivid_user_gen_ctrl_ops,
277 .id = VIVID_CID_AREA,
278 .name = "Area",
279 .type = V4L2_CTRL_TYPE_AREA,
280 .p_def.p_const = &area,
281 };
282
283 /* Framebuffer Controls */
284
285 static int vivid_fb_s_ctrl(struct v4l2_ctrl *ctrl)
286 {
287 struct vivid_dev *dev = container_of(ctrl->handler,
288 struct vivid_dev, ctrl_hdl_fb);
289
290 switch (ctrl->id) {
291 case VIVID_CID_CLEAR_FB:
292 vivid_clear_fb(dev);
293 break;
294 }
295 return 0;
296 }
297
298 static const struct v4l2_ctrl_ops vivid_fb_ctrl_ops = {
299 .s_ctrl = vivid_fb_s_ctrl,
300 };
301
302 static const struct v4l2_ctrl_config vivid_ctrl_clear_fb = {
303 .ops = &vivid_fb_ctrl_ops,
304 .id = VIVID_CID_CLEAR_FB,
305 .name = "Clear Framebuffer",
306 .type = V4L2_CTRL_TYPE_BUTTON,
307 };
308
309
310 /* Video User Controls */
311
312 static int vivid_user_vid_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
313 {
314 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
315
316 switch (ctrl->id) {
317 case V4L2_CID_AUTOGAIN:
318 dev->gain->val = (jiffies_to_msecs(jiffies) / 1000) & 0xff;
319 break;
320 }
321 return 0;
322 }
323
324 static int vivid_user_vid_s_ctrl(struct v4l2_ctrl *ctrl)
325 {
326 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
327
328 switch (ctrl->id) {
329 case V4L2_CID_BRIGHTNESS:
330 dev->input_brightness[dev->input] = ctrl->val - dev->input * 128;
331 tpg_s_brightness(&dev->tpg, dev->input_brightness[dev->input]);
332 break;
333 case V4L2_CID_CONTRAST:
334 tpg_s_contrast(&dev->tpg, ctrl->val);
335 break;
336 case V4L2_CID_SATURATION:
337 tpg_s_saturation(&dev->tpg, ctrl->val);
338 break;
339 case V4L2_CID_HUE:
340 tpg_s_hue(&dev->tpg, ctrl->val);
341 break;
342 case V4L2_CID_HFLIP:
343 dev->hflip = ctrl->val;
344 tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
345 break;
346 case V4L2_CID_VFLIP:
347 dev->vflip = ctrl->val;
348 tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
349 break;
350 case V4L2_CID_ALPHA_COMPONENT:
351 tpg_s_alpha_component(&dev->tpg, ctrl->val);
352 break;
353 }
354 return 0;
355 }
356
357 static const struct v4l2_ctrl_ops vivid_user_vid_ctrl_ops = {
358 .g_volatile_ctrl = vivid_user_vid_g_volatile_ctrl,
359 .s_ctrl = vivid_user_vid_s_ctrl,
360 };
361
362
363 /* Video Capture Controls */
364
365 static int vivid_vid_cap_s_ctrl(struct v4l2_ctrl *ctrl)
366 {
367 static const u32 colorspaces[] = {
368 V4L2_COLORSPACE_SMPTE170M,
369 V4L2_COLORSPACE_REC709,
370 V4L2_COLORSPACE_SRGB,
371 V4L2_COLORSPACE_OPRGB,
372 V4L2_COLORSPACE_BT2020,
373 V4L2_COLORSPACE_DCI_P3,
374 V4L2_COLORSPACE_SMPTE240M,
375 V4L2_COLORSPACE_470_SYSTEM_M,
376 V4L2_COLORSPACE_470_SYSTEM_BG,
377 };
378 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_cap);
379 unsigned int i, j;
380
381 switch (ctrl->id) {
382 case VIVID_CID_TEST_PATTERN:
383 vivid_update_quality(dev);
384 tpg_s_pattern(&dev->tpg, ctrl->val);
385 break;
386 case VIVID_CID_COLORSPACE:
387 tpg_s_colorspace(&dev->tpg, colorspaces[ctrl->val]);
388 vivid_send_source_change(dev, TV);
389 vivid_send_source_change(dev, SVID);
390 vivid_send_source_change(dev, HDMI);
391 vivid_send_source_change(dev, WEBCAM);
392 break;
393 case VIVID_CID_XFER_FUNC:
394 tpg_s_xfer_func(&dev->tpg, ctrl->val);
395 vivid_send_source_change(dev, TV);
396 vivid_send_source_change(dev, SVID);
397 vivid_send_source_change(dev, HDMI);
398 vivid_send_source_change(dev, WEBCAM);
399 break;
400 case VIVID_CID_YCBCR_ENC:
401 tpg_s_ycbcr_enc(&dev->tpg, ctrl->val);
402 vivid_send_source_change(dev, TV);
403 vivid_send_source_change(dev, SVID);
404 vivid_send_source_change(dev, HDMI);
405 vivid_send_source_change(dev, WEBCAM);
406 break;
407 case VIVID_CID_HSV_ENC:
408 tpg_s_hsv_enc(&dev->tpg, ctrl->val ? V4L2_HSV_ENC_256 :
409 V4L2_HSV_ENC_180);
410 vivid_send_source_change(dev, TV);
411 vivid_send_source_change(dev, SVID);
412 vivid_send_source_change(dev, HDMI);
413 vivid_send_source_change(dev, WEBCAM);
414 break;
415 case VIVID_CID_QUANTIZATION:
416 tpg_s_quantization(&dev->tpg, ctrl->val);
417 vivid_send_source_change(dev, TV);
418 vivid_send_source_change(dev, SVID);
419 vivid_send_source_change(dev, HDMI);
420 vivid_send_source_change(dev, WEBCAM);
421 break;
422 case V4L2_CID_DV_RX_RGB_RANGE:
423 if (!vivid_is_hdmi_cap(dev))
424 break;
425 tpg_s_rgb_range(&dev->tpg, ctrl->val);
426 break;
427 case VIVID_CID_LIMITED_RGB_RANGE:
428 tpg_s_real_rgb_range(&dev->tpg, ctrl->val ?
429 V4L2_DV_RGB_RANGE_LIMITED : V4L2_DV_RGB_RANGE_FULL);
430 break;
431 case VIVID_CID_ALPHA_MODE:
432 tpg_s_alpha_mode(&dev->tpg, ctrl->val);
433 break;
434 case VIVID_CID_HOR_MOVEMENT:
435 tpg_s_mv_hor_mode(&dev->tpg, ctrl->val);
436 break;
437 case VIVID_CID_VERT_MOVEMENT:
438 tpg_s_mv_vert_mode(&dev->tpg, ctrl->val);
439 break;
440 case VIVID_CID_OSD_TEXT_MODE:
441 dev->osd_mode = ctrl->val;
442 break;
443 case VIVID_CID_PERCENTAGE_FILL:
444 tpg_s_perc_fill(&dev->tpg, ctrl->val);
445 for (i = 0; i < VIDEO_MAX_FRAME; i++)
446 dev->must_blank[i] = ctrl->val < 100;
447 break;
448 case VIVID_CID_INSERT_SAV:
449 tpg_s_insert_sav(&dev->tpg, ctrl->val);
450 break;
451 case VIVID_CID_INSERT_EAV:
452 tpg_s_insert_eav(&dev->tpg, ctrl->val);
453 break;
454 case VIVID_CID_HFLIP:
455 dev->sensor_hflip = ctrl->val;
456 tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
457 break;
458 case VIVID_CID_VFLIP:
459 dev->sensor_vflip = ctrl->val;
460 tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
461 break;
462 case VIVID_CID_REDUCED_FPS:
463 dev->reduced_fps = ctrl->val;
464 vivid_update_format_cap(dev, true);
465 break;
466 case VIVID_CID_HAS_CROP_CAP:
467 dev->has_crop_cap = ctrl->val;
468 vivid_update_format_cap(dev, true);
469 break;
470 case VIVID_CID_HAS_COMPOSE_CAP:
471 dev->has_compose_cap = ctrl->val;
472 vivid_update_format_cap(dev, true);
473 break;
474 case VIVID_CID_HAS_SCALER_CAP:
475 dev->has_scaler_cap = ctrl->val;
476 vivid_update_format_cap(dev, true);
477 break;
478 case VIVID_CID_SHOW_BORDER:
479 tpg_s_show_border(&dev->tpg, ctrl->val);
480 break;
481 case VIVID_CID_SHOW_SQUARE:
482 tpg_s_show_square(&dev->tpg, ctrl->val);
483 break;
484 case VIVID_CID_STD_ASPECT_RATIO:
485 dev->std_aspect_ratio[dev->input] = ctrl->val;
486 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
487 break;
488 case VIVID_CID_DV_TIMINGS_SIGNAL_MODE:
489 dev->dv_timings_signal_mode[dev->input] =
490 dev->ctrl_dv_timings_signal_mode->val;
491 dev->query_dv_timings[dev->input] = dev->ctrl_dv_timings->val;
492
493 dev->power_present = 0;
494 for (i = 0, j = 0;
495 i < ARRAY_SIZE(dev->dv_timings_signal_mode);
496 i++)
497 if (dev->input_type[i] == HDMI) {
498 if (dev->dv_timings_signal_mode[i] != NO_SIGNAL)
499 dev->power_present |= (1 << j);
500 j++;
501 }
502 __v4l2_ctrl_s_ctrl(dev->ctrl_rx_power_present,
503 dev->power_present);
504
505 v4l2_ctrl_activate(dev->ctrl_dv_timings,
506 dev->dv_timings_signal_mode[dev->input] ==
507 SELECTED_DV_TIMINGS);
508
509 vivid_update_quality(dev);
510 vivid_send_source_change(dev, HDMI);
511 break;
512 case VIVID_CID_DV_TIMINGS_ASPECT_RATIO:
513 dev->dv_timings_aspect_ratio[dev->input] = ctrl->val;
514 tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
515 break;
516 case VIVID_CID_TSTAMP_SRC:
517 dev->tstamp_src_is_soe = ctrl->val;
518 dev->vb_vid_cap_q.timestamp_flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
519 if (dev->tstamp_src_is_soe)
520 dev->vb_vid_cap_q.timestamp_flags |= V4L2_BUF_FLAG_TSTAMP_SRC_SOE;
521 break;
522 case VIVID_CID_MAX_EDID_BLOCKS:
523 dev->edid_max_blocks = ctrl->val;
524 if (dev->edid_blocks > dev->edid_max_blocks)
525 dev->edid_blocks = dev->edid_max_blocks;
526 break;
527 }
528 return 0;
529 }
530
531 static const struct v4l2_ctrl_ops vivid_vid_cap_ctrl_ops = {
532 .s_ctrl = vivid_vid_cap_s_ctrl,
533 };
534
535 static const char * const vivid_ctrl_hor_movement_strings[] = {
536 "Move Left Fast",
537 "Move Left",
538 "Move Left Slow",
539 "No Movement",
540 "Move Right Slow",
541 "Move Right",
542 "Move Right Fast",
543 NULL,
544 };
545
546 static const struct v4l2_ctrl_config vivid_ctrl_hor_movement = {
547 .ops = &vivid_vid_cap_ctrl_ops,
548 .id = VIVID_CID_HOR_MOVEMENT,
549 .name = "Horizontal Movement",
550 .type = V4L2_CTRL_TYPE_MENU,
551 .max = TPG_MOVE_POS_FAST,
552 .def = TPG_MOVE_NONE,
553 .qmenu = vivid_ctrl_hor_movement_strings,
554 };
555
556 static const char * const vivid_ctrl_vert_movement_strings[] = {
557 "Move Up Fast",
558 "Move Up",
559 "Move Up Slow",
560 "No Movement",
561 "Move Down Slow",
562 "Move Down",
563 "Move Down Fast",
564 NULL,
565 };
566
567 static const struct v4l2_ctrl_config vivid_ctrl_vert_movement = {
568 .ops = &vivid_vid_cap_ctrl_ops,
569 .id = VIVID_CID_VERT_MOVEMENT,
570 .name = "Vertical Movement",
571 .type = V4L2_CTRL_TYPE_MENU,
572 .max = TPG_MOVE_POS_FAST,
573 .def = TPG_MOVE_NONE,
574 .qmenu = vivid_ctrl_vert_movement_strings,
575 };
576
577 static const struct v4l2_ctrl_config vivid_ctrl_show_border = {
578 .ops = &vivid_vid_cap_ctrl_ops,
579 .id = VIVID_CID_SHOW_BORDER,
580 .name = "Show Border",
581 .type = V4L2_CTRL_TYPE_BOOLEAN,
582 .max = 1,
583 .step = 1,
584 };
585
586 static const struct v4l2_ctrl_config vivid_ctrl_show_square = {
587 .ops = &vivid_vid_cap_ctrl_ops,
588 .id = VIVID_CID_SHOW_SQUARE,
589 .name = "Show Square",
590 .type = V4L2_CTRL_TYPE_BOOLEAN,
591 .max = 1,
592 .step = 1,
593 };
594
595 static const char * const vivid_ctrl_osd_mode_strings[] = {
596 "All",
597 "Counters Only",
598 "None",
599 NULL,
600 };
601
602 static const struct v4l2_ctrl_config vivid_ctrl_osd_mode = {
603 .ops = &vivid_vid_cap_ctrl_ops,
604 .id = VIVID_CID_OSD_TEXT_MODE,
605 .name = "OSD Text Mode",
606 .type = V4L2_CTRL_TYPE_MENU,
607 .max = ARRAY_SIZE(vivid_ctrl_osd_mode_strings) - 2,
608 .qmenu = vivid_ctrl_osd_mode_strings,
609 };
610
611 static const struct v4l2_ctrl_config vivid_ctrl_perc_fill = {
612 .ops = &vivid_vid_cap_ctrl_ops,
613 .id = VIVID_CID_PERCENTAGE_FILL,
614 .name = "Fill Percentage of Frame",
615 .type = V4L2_CTRL_TYPE_INTEGER,
616 .min = 0,
617 .max = 100,
618 .def = 100,
619 .step = 1,
620 };
621
622 static const struct v4l2_ctrl_config vivid_ctrl_insert_sav = {
623 .ops = &vivid_vid_cap_ctrl_ops,
624 .id = VIVID_CID_INSERT_SAV,
625 .name = "Insert SAV Code in Image",
626 .type = V4L2_CTRL_TYPE_BOOLEAN,
627 .max = 1,
628 .step = 1,
629 };
630
631 static const struct v4l2_ctrl_config vivid_ctrl_insert_eav = {
632 .ops = &vivid_vid_cap_ctrl_ops,
633 .id = VIVID_CID_INSERT_EAV,
634 .name = "Insert EAV Code in Image",
635 .type = V4L2_CTRL_TYPE_BOOLEAN,
636 .max = 1,
637 .step = 1,
638 };
639
640 static const struct v4l2_ctrl_config vivid_ctrl_hflip = {
641 .ops = &vivid_vid_cap_ctrl_ops,
642 .id = VIVID_CID_HFLIP,
643 .name = "Sensor Flipped Horizontally",
644 .type = V4L2_CTRL_TYPE_BOOLEAN,
645 .max = 1,
646 .step = 1,
647 };
648
649 static const struct v4l2_ctrl_config vivid_ctrl_vflip = {
650 .ops = &vivid_vid_cap_ctrl_ops,
651 .id = VIVID_CID_VFLIP,
652 .name = "Sensor Flipped Vertically",
653 .type = V4L2_CTRL_TYPE_BOOLEAN,
654 .max = 1,
655 .step = 1,
656 };
657
658 static const struct v4l2_ctrl_config vivid_ctrl_reduced_fps = {
659 .ops = &vivid_vid_cap_ctrl_ops,
660 .id = VIVID_CID_REDUCED_FPS,
661 .name = "Reduced Framerate",
662 .type = V4L2_CTRL_TYPE_BOOLEAN,
663 .max = 1,
664 .step = 1,
665 };
666
667 static const struct v4l2_ctrl_config vivid_ctrl_has_crop_cap = {
668 .ops = &vivid_vid_cap_ctrl_ops,
669 .id = VIVID_CID_HAS_CROP_CAP,
670 .name = "Enable Capture Cropping",
671 .type = V4L2_CTRL_TYPE_BOOLEAN,
672 .max = 1,
673 .def = 1,
674 .step = 1,
675 };
676
677 static const struct v4l2_ctrl_config vivid_ctrl_has_compose_cap = {
678 .ops = &vivid_vid_cap_ctrl_ops,
679 .id = VIVID_CID_HAS_COMPOSE_CAP,
680 .name = "Enable Capture Composing",
681 .type = V4L2_CTRL_TYPE_BOOLEAN,
682 .max = 1,
683 .def = 1,
684 .step = 1,
685 };
686
687 static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_cap = {
688 .ops = &vivid_vid_cap_ctrl_ops,
689 .id = VIVID_CID_HAS_SCALER_CAP,
690 .name = "Enable Capture Scaler",
691 .type = V4L2_CTRL_TYPE_BOOLEAN,
692 .max = 1,
693 .def = 1,
694 .step = 1,
695 };
696
697 static const char * const vivid_ctrl_tstamp_src_strings[] = {
698 "End of Frame",
699 "Start of Exposure",
700 NULL,
701 };
702
703 static const struct v4l2_ctrl_config vivid_ctrl_tstamp_src = {
704 .ops = &vivid_vid_cap_ctrl_ops,
705 .id = VIVID_CID_TSTAMP_SRC,
706 .name = "Timestamp Source",
707 .type = V4L2_CTRL_TYPE_MENU,
708 .max = ARRAY_SIZE(vivid_ctrl_tstamp_src_strings) - 2,
709 .qmenu = vivid_ctrl_tstamp_src_strings,
710 };
711
712 static const struct v4l2_ctrl_config vivid_ctrl_std_aspect_ratio = {
713 .ops = &vivid_vid_cap_ctrl_ops,
714 .id = VIVID_CID_STD_ASPECT_RATIO,
715 .name = "Standard Aspect Ratio",
716 .type = V4L2_CTRL_TYPE_MENU,
717 .min = 1,
718 .max = 4,
719 .def = 1,
720 .qmenu = tpg_aspect_strings,
721 };
722
723 static const char * const vivid_ctrl_dv_timings_signal_mode_strings[] = {
724 "Current DV Timings",
725 "No Signal",
726 "No Lock",
727 "Out of Range",
728 "Selected DV Timings",
729 "Cycle Through All DV Timings",
730 "Custom DV Timings",
731 NULL,
732 };
733
734 static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_signal_mode = {
735 .ops = &vivid_vid_cap_ctrl_ops,
736 .id = VIVID_CID_DV_TIMINGS_SIGNAL_MODE,
737 .name = "DV Timings Signal Mode",
738 .type = V4L2_CTRL_TYPE_MENU,
739 .max = 5,
740 .qmenu = vivid_ctrl_dv_timings_signal_mode_strings,
741 };
742
743 static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_aspect_ratio = {
744 .ops = &vivid_vid_cap_ctrl_ops,
745 .id = VIVID_CID_DV_TIMINGS_ASPECT_RATIO,
746 .name = "DV Timings Aspect Ratio",
747 .type = V4L2_CTRL_TYPE_MENU,
748 .max = 3,
749 .qmenu = tpg_aspect_strings,
750 };
751
752 static const struct v4l2_ctrl_config vivid_ctrl_max_edid_blocks = {
753 .ops = &vivid_vid_cap_ctrl_ops,
754 .id = VIVID_CID_MAX_EDID_BLOCKS,
755 .name = "Maximum EDID Blocks",
756 .type = V4L2_CTRL_TYPE_INTEGER,
757 .min = 1,
758 .max = 256,
759 .def = 2,
760 .step = 1,
761 };
762
763 static const char * const vivid_ctrl_colorspace_strings[] = {
764 "SMPTE 170M",
765 "Rec. 709",
766 "sRGB",
767 "opRGB",
768 "BT.2020",
769 "DCI-P3",
770 "SMPTE 240M",
771 "470 System M",
772 "470 System BG",
773 NULL,
774 };
775
776 static const struct v4l2_ctrl_config vivid_ctrl_colorspace = {
777 .ops = &vivid_vid_cap_ctrl_ops,
778 .id = VIVID_CID_COLORSPACE,
779 .name = "Colorspace",
780 .type = V4L2_CTRL_TYPE_MENU,
781 .max = ARRAY_SIZE(vivid_ctrl_colorspace_strings) - 2,
782 .def = 2,
783 .qmenu = vivid_ctrl_colorspace_strings,
784 };
785
786 static const char * const vivid_ctrl_xfer_func_strings[] = {
787 "Default",
788 "Rec. 709",
789 "sRGB",
790 "opRGB",
791 "SMPTE 240M",
792 "None",
793 "DCI-P3",
794 "SMPTE 2084",
795 NULL,
796 };
797
798 static const struct v4l2_ctrl_config vivid_ctrl_xfer_func = {
799 .ops = &vivid_vid_cap_ctrl_ops,
800 .id = VIVID_CID_XFER_FUNC,
801 .name = "Transfer Function",
802 .type = V4L2_CTRL_TYPE_MENU,
803 .max = ARRAY_SIZE(vivid_ctrl_xfer_func_strings) - 2,
804 .qmenu = vivid_ctrl_xfer_func_strings,
805 };
806
807 static const char * const vivid_ctrl_ycbcr_enc_strings[] = {
808 "Default",
809 "ITU-R 601",
810 "Rec. 709",
811 "xvYCC 601",
812 "xvYCC 709",
813 "",
814 "BT.2020",
815 "BT.2020 Constant Luminance",
816 "SMPTE 240M",
817 NULL,
818 };
819
820 static const struct v4l2_ctrl_config vivid_ctrl_ycbcr_enc = {
821 .ops = &vivid_vid_cap_ctrl_ops,
822 .id = VIVID_CID_YCBCR_ENC,
823 .name = "Y'CbCr Encoding",
824 .type = V4L2_CTRL_TYPE_MENU,
825 .menu_skip_mask = 1 << 5,
826 .max = ARRAY_SIZE(vivid_ctrl_ycbcr_enc_strings) - 2,
827 .qmenu = vivid_ctrl_ycbcr_enc_strings,
828 };
829
830 static const char * const vivid_ctrl_hsv_enc_strings[] = {
831 "Hue 0-179",
832 "Hue 0-256",
833 NULL,
834 };
835
836 static const struct v4l2_ctrl_config vivid_ctrl_hsv_enc = {
837 .ops = &vivid_vid_cap_ctrl_ops,
838 .id = VIVID_CID_HSV_ENC,
839 .name = "HSV Encoding",
840 .type = V4L2_CTRL_TYPE_MENU,
841 .max = ARRAY_SIZE(vivid_ctrl_hsv_enc_strings) - 2,
842 .qmenu = vivid_ctrl_hsv_enc_strings,
843 };
844
845 static const char * const vivid_ctrl_quantization_strings[] = {
846 "Default",
847 "Full Range",
848 "Limited Range",
849 NULL,
850 };
851
852 static const struct v4l2_ctrl_config vivid_ctrl_quantization = {
853 .ops = &vivid_vid_cap_ctrl_ops,
854 .id = VIVID_CID_QUANTIZATION,
855 .name = "Quantization",
856 .type = V4L2_CTRL_TYPE_MENU,
857 .max = ARRAY_SIZE(vivid_ctrl_quantization_strings) - 2,
858 .qmenu = vivid_ctrl_quantization_strings,
859 };
860
861 static const struct v4l2_ctrl_config vivid_ctrl_alpha_mode = {
862 .ops = &vivid_vid_cap_ctrl_ops,
863 .id = VIVID_CID_ALPHA_MODE,
864 .name = "Apply Alpha To Red Only",
865 .type = V4L2_CTRL_TYPE_BOOLEAN,
866 .max = 1,
867 .step = 1,
868 };
869
870 static const struct v4l2_ctrl_config vivid_ctrl_limited_rgb_range = {
871 .ops = &vivid_vid_cap_ctrl_ops,
872 .id = VIVID_CID_LIMITED_RGB_RANGE,
873 .name = "Limited RGB Range (16-235)",
874 .type = V4L2_CTRL_TYPE_BOOLEAN,
875 .max = 1,
876 .step = 1,
877 };
878
879
880 /* Video Loop Control */
881
882 static int vivid_loop_cap_s_ctrl(struct v4l2_ctrl *ctrl)
883 {
884 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_loop_cap);
885
886 switch (ctrl->id) {
887 case VIVID_CID_LOOP_VIDEO:
888 dev->loop_video = ctrl->val;
889 vivid_update_quality(dev);
890 vivid_send_source_change(dev, SVID);
891 vivid_send_source_change(dev, HDMI);
892 break;
893 }
894 return 0;
895 }
896
897 static const struct v4l2_ctrl_ops vivid_loop_cap_ctrl_ops = {
898 .s_ctrl = vivid_loop_cap_s_ctrl,
899 };
900
901 static const struct v4l2_ctrl_config vivid_ctrl_loop_video = {
902 .ops = &vivid_loop_cap_ctrl_ops,
903 .id = VIVID_CID_LOOP_VIDEO,
904 .name = "Loop Video",
905 .type = V4L2_CTRL_TYPE_BOOLEAN,
906 .max = 1,
907 .step = 1,
908 };
909
910
911 /* VBI Capture Control */
912
913 static int vivid_vbi_cap_s_ctrl(struct v4l2_ctrl *ctrl)
914 {
915 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vbi_cap);
916
917 switch (ctrl->id) {
918 case VIVID_CID_VBI_CAP_INTERLACED:
919 dev->vbi_cap_interlaced = ctrl->val;
920 break;
921 }
922 return 0;
923 }
924
925 static const struct v4l2_ctrl_ops vivid_vbi_cap_ctrl_ops = {
926 .s_ctrl = vivid_vbi_cap_s_ctrl,
927 };
928
929 static const struct v4l2_ctrl_config vivid_ctrl_vbi_cap_interlaced = {
930 .ops = &vivid_vbi_cap_ctrl_ops,
931 .id = VIVID_CID_VBI_CAP_INTERLACED,
932 .name = "Interlaced VBI Format",
933 .type = V4L2_CTRL_TYPE_BOOLEAN,
934 .max = 1,
935 .step = 1,
936 };
937
938
939 /* Video Output Controls */
940
941 static int vivid_vid_out_s_ctrl(struct v4l2_ctrl *ctrl)
942 {
943 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_out);
944 struct v4l2_bt_timings *bt = &dev->dv_timings_out.bt;
945 u32 display_present = 0;
946 unsigned int i, j, bus_idx;
947
948 switch (ctrl->id) {
949 case VIVID_CID_HAS_CROP_OUT:
950 dev->has_crop_out = ctrl->val;
951 vivid_update_format_out(dev);
952 break;
953 case VIVID_CID_HAS_COMPOSE_OUT:
954 dev->has_compose_out = ctrl->val;
955 vivid_update_format_out(dev);
956 break;
957 case VIVID_CID_HAS_SCALER_OUT:
958 dev->has_scaler_out = ctrl->val;
959 vivid_update_format_out(dev);
960 break;
961 case V4L2_CID_DV_TX_MODE:
962 dev->dvi_d_out = ctrl->val == V4L2_DV_TX_MODE_DVI_D;
963 if (!vivid_is_hdmi_out(dev))
964 break;
965 if (!dev->dvi_d_out && (bt->flags & V4L2_DV_FL_IS_CE_VIDEO)) {
966 if (bt->width == 720 && bt->height <= 576)
967 dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M;
968 else
969 dev->colorspace_out = V4L2_COLORSPACE_REC709;
970 dev->quantization_out = V4L2_QUANTIZATION_DEFAULT;
971 } else {
972 dev->colorspace_out = V4L2_COLORSPACE_SRGB;
973 dev->quantization_out = dev->dvi_d_out ?
974 V4L2_QUANTIZATION_LIM_RANGE :
975 V4L2_QUANTIZATION_DEFAULT;
976 }
977 if (dev->loop_video)
978 vivid_send_source_change(dev, HDMI);
979 break;
980 case VIVID_CID_DISPLAY_PRESENT:
981 if (dev->output_type[dev->output] != HDMI)
982 break;
983
984 dev->display_present[dev->output] = ctrl->val;
985 for (i = 0, j = 0; i < dev->num_outputs; i++)
986 if (dev->output_type[i] == HDMI)
987 display_present |=
988 dev->display_present[i] << j++;
989
990 __v4l2_ctrl_s_ctrl(dev->ctrl_tx_rxsense, display_present);
991
992 if (dev->edid_blocks) {
993 __v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present,
994 display_present);
995 __v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug,
996 display_present);
997 }
998
999 bus_idx = dev->cec_output2bus_map[dev->output];
1000 if (!dev->cec_tx_adap[bus_idx])
1001 break;
1002
1003 if (ctrl->val && dev->edid_blocks)
1004 cec_s_phys_addr(dev->cec_tx_adap[bus_idx],
1005 dev->cec_tx_adap[bus_idx]->phys_addr,
1006 false);
1007 else
1008 cec_phys_addr_invalidate(dev->cec_tx_adap[bus_idx]);
1009
1010 break;
1011 }
1012 return 0;
1013 }
1014
1015 static const struct v4l2_ctrl_ops vivid_vid_out_ctrl_ops = {
1016 .s_ctrl = vivid_vid_out_s_ctrl,
1017 };
1018
1019 static const struct v4l2_ctrl_config vivid_ctrl_has_crop_out = {
1020 .ops = &vivid_vid_out_ctrl_ops,
1021 .id = VIVID_CID_HAS_CROP_OUT,
1022 .name = "Enable Output Cropping",
1023 .type = V4L2_CTRL_TYPE_BOOLEAN,
1024 .max = 1,
1025 .def = 1,
1026 .step = 1,
1027 };
1028
1029 static const struct v4l2_ctrl_config vivid_ctrl_has_compose_out = {
1030 .ops = &vivid_vid_out_ctrl_ops,
1031 .id = VIVID_CID_HAS_COMPOSE_OUT,
1032 .name = "Enable Output Composing",
1033 .type = V4L2_CTRL_TYPE_BOOLEAN,
1034 .max = 1,
1035 .def = 1,
1036 .step = 1,
1037 };
1038
1039 static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_out = {
1040 .ops = &vivid_vid_out_ctrl_ops,
1041 .id = VIVID_CID_HAS_SCALER_OUT,
1042 .name = "Enable Output Scaler",
1043 .type = V4L2_CTRL_TYPE_BOOLEAN,
1044 .max = 1,
1045 .def = 1,
1046 .step = 1,
1047 };
1048
1049 static const struct v4l2_ctrl_config vivid_ctrl_display_present = {
1050 .ops = &vivid_vid_out_ctrl_ops,
1051 .id = VIVID_CID_DISPLAY_PRESENT,
1052 .name = "Display Present",
1053 .type = V4L2_CTRL_TYPE_BOOLEAN,
1054 .max = 1,
1055 .def = 1,
1056 .step = 1,
1057 };
1058
1059 /* Streaming Controls */
1060
1061 static int vivid_streaming_s_ctrl(struct v4l2_ctrl *ctrl)
1062 {
1063 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_streaming);
1064 u64 rem;
1065
1066 switch (ctrl->id) {
1067 case VIVID_CID_DQBUF_ERROR:
1068 dev->dqbuf_error = true;
1069 break;
1070 case VIVID_CID_PERC_DROPPED:
1071 dev->perc_dropped_buffers = ctrl->val;
1072 break;
1073 case VIVID_CID_QUEUE_SETUP_ERROR:
1074 dev->queue_setup_error = true;
1075 break;
1076 case VIVID_CID_BUF_PREPARE_ERROR:
1077 dev->buf_prepare_error = true;
1078 break;
1079 case VIVID_CID_START_STR_ERROR:
1080 dev->start_streaming_error = true;
1081 break;
1082 case VIVID_CID_REQ_VALIDATE_ERROR:
1083 dev->req_validate_error = true;
1084 break;
1085 case VIVID_CID_QUEUE_ERROR:
1086 if (vb2_start_streaming_called(&dev->vb_vid_cap_q))
1087 vb2_queue_error(&dev->vb_vid_cap_q);
1088 if (vb2_start_streaming_called(&dev->vb_vbi_cap_q))
1089 vb2_queue_error(&dev->vb_vbi_cap_q);
1090 if (vb2_start_streaming_called(&dev->vb_vid_out_q))
1091 vb2_queue_error(&dev->vb_vid_out_q);
1092 if (vb2_start_streaming_called(&dev->vb_vbi_out_q))
1093 vb2_queue_error(&dev->vb_vbi_out_q);
1094 if (vb2_start_streaming_called(&dev->vb_sdr_cap_q))
1095 vb2_queue_error(&dev->vb_sdr_cap_q);
1096 break;
1097 case VIVID_CID_SEQ_WRAP:
1098 dev->seq_wrap = ctrl->val;
1099 break;
1100 case VIVID_CID_TIME_WRAP:
1101 dev->time_wrap = ctrl->val;
1102 if (ctrl->val == 0) {
1103 dev->time_wrap_offset = 0;
1104 break;
1105 }
1106 /*
1107 * We want to set the time 16 seconds before the 32 bit tv_sec
1108 * value of struct timeval would wrap around. So first we
1109 * calculate ktime_get_ns() % ((1 << 32) * NSEC_PER_SEC), and
1110 * then we set the offset to ((1 << 32) - 16) * NSEC_PER_SEC).
1111 */
1112 div64_u64_rem(ktime_get_ns(),
1113 0x100000000ULL * NSEC_PER_SEC, &rem);
1114 dev->time_wrap_offset =
1115 (0x100000000ULL - 16) * NSEC_PER_SEC - rem;
1116 break;
1117 }
1118 return 0;
1119 }
1120
1121 static const struct v4l2_ctrl_ops vivid_streaming_ctrl_ops = {
1122 .s_ctrl = vivid_streaming_s_ctrl,
1123 };
1124
1125 static const struct v4l2_ctrl_config vivid_ctrl_dqbuf_error = {
1126 .ops = &vivid_streaming_ctrl_ops,
1127 .id = VIVID_CID_DQBUF_ERROR,
1128 .name = "Inject V4L2_BUF_FLAG_ERROR",
1129 .type = V4L2_CTRL_TYPE_BUTTON,
1130 };
1131
1132 static const struct v4l2_ctrl_config vivid_ctrl_perc_dropped = {
1133 .ops = &vivid_streaming_ctrl_ops,
1134 .id = VIVID_CID_PERC_DROPPED,
1135 .name = "Percentage of Dropped Buffers",
1136 .type = V4L2_CTRL_TYPE_INTEGER,
1137 .min = 0,
1138 .max = 100,
1139 .step = 1,
1140 };
1141
1142 static const struct v4l2_ctrl_config vivid_ctrl_queue_setup_error = {
1143 .ops = &vivid_streaming_ctrl_ops,
1144 .id = VIVID_CID_QUEUE_SETUP_ERROR,
1145 .name = "Inject VIDIOC_REQBUFS Error",
1146 .type = V4L2_CTRL_TYPE_BUTTON,
1147 };
1148
1149 static const struct v4l2_ctrl_config vivid_ctrl_buf_prepare_error = {
1150 .ops = &vivid_streaming_ctrl_ops,
1151 .id = VIVID_CID_BUF_PREPARE_ERROR,
1152 .name = "Inject VIDIOC_QBUF Error",
1153 .type = V4L2_CTRL_TYPE_BUTTON,
1154 };
1155
1156 static const struct v4l2_ctrl_config vivid_ctrl_start_streaming_error = {
1157 .ops = &vivid_streaming_ctrl_ops,
1158 .id = VIVID_CID_START_STR_ERROR,
1159 .name = "Inject VIDIOC_STREAMON Error",
1160 .type = V4L2_CTRL_TYPE_BUTTON,
1161 };
1162
1163 static const struct v4l2_ctrl_config vivid_ctrl_queue_error = {
1164 .ops = &vivid_streaming_ctrl_ops,
1165 .id = VIVID_CID_QUEUE_ERROR,
1166 .name = "Inject Fatal Streaming Error",
1167 .type = V4L2_CTRL_TYPE_BUTTON,
1168 };
1169
1170 #ifdef CONFIG_MEDIA_CONTROLLER
1171 static const struct v4l2_ctrl_config vivid_ctrl_req_validate_error = {
1172 .ops = &vivid_streaming_ctrl_ops,
1173 .id = VIVID_CID_REQ_VALIDATE_ERROR,
1174 .name = "Inject req_validate() Error",
1175 .type = V4L2_CTRL_TYPE_BUTTON,
1176 };
1177 #endif
1178
1179 static const struct v4l2_ctrl_config vivid_ctrl_seq_wrap = {
1180 .ops = &vivid_streaming_ctrl_ops,
1181 .id = VIVID_CID_SEQ_WRAP,
1182 .name = "Wrap Sequence Number",
1183 .type = V4L2_CTRL_TYPE_BOOLEAN,
1184 .max = 1,
1185 .step = 1,
1186 };
1187
1188 static const struct v4l2_ctrl_config vivid_ctrl_time_wrap = {
1189 .ops = &vivid_streaming_ctrl_ops,
1190 .id = VIVID_CID_TIME_WRAP,
1191 .name = "Wrap Timestamp",
1192 .type = V4L2_CTRL_TYPE_BOOLEAN,
1193 .max = 1,
1194 .step = 1,
1195 };
1196
1197
1198 /* SDTV Capture Controls */
1199
1200 static int vivid_sdtv_cap_s_ctrl(struct v4l2_ctrl *ctrl)
1201 {
1202 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_sdtv_cap);
1203
1204 switch (ctrl->id) {
1205 case VIVID_CID_STD_SIGNAL_MODE:
1206 dev->std_signal_mode[dev->input] =
1207 dev->ctrl_std_signal_mode->val;
1208 if (dev->std_signal_mode[dev->input] == SELECTED_STD)
1209 dev->query_std[dev->input] =
1210 vivid_standard[dev->ctrl_standard->val];
1211 v4l2_ctrl_activate(dev->ctrl_standard,
1212 dev->std_signal_mode[dev->input] ==
1213 SELECTED_STD);
1214 vivid_update_quality(dev);
1215 vivid_send_source_change(dev, TV);
1216 vivid_send_source_change(dev, SVID);
1217 break;
1218 }
1219 return 0;
1220 }
1221
1222 static const struct v4l2_ctrl_ops vivid_sdtv_cap_ctrl_ops = {
1223 .s_ctrl = vivid_sdtv_cap_s_ctrl,
1224 };
1225
1226 static const char * const vivid_ctrl_std_signal_mode_strings[] = {
1227 "Current Standard",
1228 "No Signal",
1229 "No Lock",
1230 "",
1231 "Selected Standard",
1232 "Cycle Through All Standards",
1233 NULL,
1234 };
1235
1236 static const struct v4l2_ctrl_config vivid_ctrl_std_signal_mode = {
1237 .ops = &vivid_sdtv_cap_ctrl_ops,
1238 .id = VIVID_CID_STD_SIGNAL_MODE,
1239 .name = "Standard Signal Mode",
1240 .type = V4L2_CTRL_TYPE_MENU,
1241 .max = ARRAY_SIZE(vivid_ctrl_std_signal_mode_strings) - 2,
1242 .menu_skip_mask = 1 << 3,
1243 .qmenu = vivid_ctrl_std_signal_mode_strings,
1244 };
1245
1246 static const struct v4l2_ctrl_config vivid_ctrl_standard = {
1247 .ops = &vivid_sdtv_cap_ctrl_ops,
1248 .id = VIVID_CID_STANDARD,
1249 .name = "Standard",
1250 .type = V4L2_CTRL_TYPE_MENU,
1251 .max = 14,
1252 .qmenu = vivid_ctrl_standard_strings,
1253 };
1254
1255
1256
1257 /* Radio Receiver Controls */
1258
1259 static int vivid_radio_rx_s_ctrl(struct v4l2_ctrl *ctrl)
1260 {
1261 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_rx);
1262
1263 switch (ctrl->id) {
1264 case VIVID_CID_RADIO_SEEK_MODE:
1265 dev->radio_rx_hw_seek_mode = ctrl->val;
1266 break;
1267 case VIVID_CID_RADIO_SEEK_PROG_LIM:
1268 dev->radio_rx_hw_seek_prog_lim = ctrl->val;
1269 break;
1270 case VIVID_CID_RADIO_RX_RDS_RBDS:
1271 dev->rds_gen.use_rbds = ctrl->val;
1272 break;
1273 case VIVID_CID_RADIO_RX_RDS_BLOCKIO:
1274 dev->radio_rx_rds_controls = ctrl->val;
1275 dev->radio_rx_caps &= ~V4L2_CAP_READWRITE;
1276 dev->radio_rx_rds_use_alternates = false;
1277 if (!dev->radio_rx_rds_controls) {
1278 dev->radio_rx_caps |= V4L2_CAP_READWRITE;
1279 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, 0);
1280 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, 0);
1281 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, 0);
1282 __v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, 0);
1283 __v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, "");
1284 __v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, "");
1285 }
1286 v4l2_ctrl_activate(dev->radio_rx_rds_pty, dev->radio_rx_rds_controls);
1287 v4l2_ctrl_activate(dev->radio_rx_rds_psname, dev->radio_rx_rds_controls);
1288 v4l2_ctrl_activate(dev->radio_rx_rds_radiotext, dev->radio_rx_rds_controls);
1289 v4l2_ctrl_activate(dev->radio_rx_rds_ta, dev->radio_rx_rds_controls);
1290 v4l2_ctrl_activate(dev->radio_rx_rds_tp, dev->radio_rx_rds_controls);
1291 v4l2_ctrl_activate(dev->radio_rx_rds_ms, dev->radio_rx_rds_controls);
1292 dev->radio_rx_dev.device_caps = dev->radio_rx_caps;
1293 break;
1294 case V4L2_CID_RDS_RECEPTION:
1295 dev->radio_rx_rds_enabled = ctrl->val;
1296 break;
1297 }
1298 return 0;
1299 }
1300
1301 static const struct v4l2_ctrl_ops vivid_radio_rx_ctrl_ops = {
1302 .s_ctrl = vivid_radio_rx_s_ctrl,
1303 };
1304
1305 static const char * const vivid_ctrl_radio_rds_mode_strings[] = {
1306 "Block I/O",
1307 "Controls",
1308 NULL,
1309 };
1310
1311 static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_blockio = {
1312 .ops = &vivid_radio_rx_ctrl_ops,
1313 .id = VIVID_CID_RADIO_RX_RDS_BLOCKIO,
1314 .name = "RDS Rx I/O Mode",
1315 .type = V4L2_CTRL_TYPE_MENU,
1316 .qmenu = vivid_ctrl_radio_rds_mode_strings,
1317 .max = 1,
1318 };
1319
1320 static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_rbds = {
1321 .ops = &vivid_radio_rx_ctrl_ops,
1322 .id = VIVID_CID_RADIO_RX_RDS_RBDS,
1323 .name = "Generate RBDS Instead of RDS",
1324 .type = V4L2_CTRL_TYPE_BOOLEAN,
1325 .max = 1,
1326 .step = 1,
1327 };
1328
1329 static const char * const vivid_ctrl_radio_hw_seek_mode_strings[] = {
1330 "Bounded",
1331 "Wrap Around",
1332 "Both",
1333 NULL,
1334 };
1335
1336 static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_mode = {
1337 .ops = &vivid_radio_rx_ctrl_ops,
1338 .id = VIVID_CID_RADIO_SEEK_MODE,
1339 .name = "Radio HW Seek Mode",
1340 .type = V4L2_CTRL_TYPE_MENU,
1341 .max = 2,
1342 .qmenu = vivid_ctrl_radio_hw_seek_mode_strings,
1343 };
1344
1345 static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_prog_lim = {
1346 .ops = &vivid_radio_rx_ctrl_ops,
1347 .id = VIVID_CID_RADIO_SEEK_PROG_LIM,
1348 .name = "Radio Programmable HW Seek",
1349 .type = V4L2_CTRL_TYPE_BOOLEAN,
1350 .max = 1,
1351 .step = 1,
1352 };
1353
1354
1355 /* Radio Transmitter Controls */
1356
1357 static int vivid_radio_tx_s_ctrl(struct v4l2_ctrl *ctrl)
1358 {
1359 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_tx);
1360
1361 switch (ctrl->id) {
1362 case VIVID_CID_RADIO_TX_RDS_BLOCKIO:
1363 dev->radio_tx_rds_controls = ctrl->val;
1364 dev->radio_tx_caps &= ~V4L2_CAP_READWRITE;
1365 if (!dev->radio_tx_rds_controls)
1366 dev->radio_tx_caps |= V4L2_CAP_READWRITE;
1367 dev->radio_tx_dev.device_caps = dev->radio_tx_caps;
1368 break;
1369 case V4L2_CID_RDS_TX_PTY:
1370 if (dev->radio_rx_rds_controls)
1371 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, ctrl->val);
1372 break;
1373 case V4L2_CID_RDS_TX_PS_NAME:
1374 if (dev->radio_rx_rds_controls)
1375 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, ctrl->p_new.p_char);
1376 break;
1377 case V4L2_CID_RDS_TX_RADIO_TEXT:
1378 if (dev->radio_rx_rds_controls)
1379 v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, ctrl->p_new.p_char);
1380 break;
1381 case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
1382 if (dev->radio_rx_rds_controls)
1383 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, ctrl->val);
1384 break;
1385 case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
1386 if (dev->radio_rx_rds_controls)
1387 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, ctrl->val);
1388 break;
1389 case V4L2_CID_RDS_TX_MUSIC_SPEECH:
1390 if (dev->radio_rx_rds_controls)
1391 v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, ctrl->val);
1392 break;
1393 }
1394 return 0;
1395 }
1396
1397 static const struct v4l2_ctrl_ops vivid_radio_tx_ctrl_ops = {
1398 .s_ctrl = vivid_radio_tx_s_ctrl,
1399 };
1400
1401 static const struct v4l2_ctrl_config vivid_ctrl_radio_tx_rds_blockio = {
1402 .ops = &vivid_radio_tx_ctrl_ops,
1403 .id = VIVID_CID_RADIO_TX_RDS_BLOCKIO,
1404 .name = "RDS Tx I/O Mode",
1405 .type = V4L2_CTRL_TYPE_MENU,
1406 .qmenu = vivid_ctrl_radio_rds_mode_strings,
1407 .max = 1,
1408 .def = 1,
1409 };
1410
1411
1412 /* SDR Capture Controls */
1413
1414 static int vivid_sdr_cap_s_ctrl(struct v4l2_ctrl *ctrl)
1415 {
1416 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_sdr_cap);
1417
1418 switch (ctrl->id) {
1419 case VIVID_CID_SDR_CAP_FM_DEVIATION:
1420 dev->sdr_fm_deviation = ctrl->val;
1421 break;
1422 }
1423 return 0;
1424 }
1425
1426 static const struct v4l2_ctrl_ops vivid_sdr_cap_ctrl_ops = {
1427 .s_ctrl = vivid_sdr_cap_s_ctrl,
1428 };
1429
1430 static const struct v4l2_ctrl_config vivid_ctrl_sdr_cap_fm_deviation = {
1431 .ops = &vivid_sdr_cap_ctrl_ops,
1432 .id = VIVID_CID_SDR_CAP_FM_DEVIATION,
1433 .name = "FM Deviation",
1434 .type = V4L2_CTRL_TYPE_INTEGER,
1435 .min = 100,
1436 .max = 200000,
1437 .def = 75000,
1438 .step = 1,
1439 };
1440
1441 /* Metadata Capture Control */
1442
1443 static int vivid_meta_cap_s_ctrl(struct v4l2_ctrl *ctrl)
1444 {
1445 struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev,
1446 ctrl_hdl_meta_cap);
1447
1448 switch (ctrl->id) {
1449 case VIVID_CID_META_CAP_GENERATE_PTS:
1450 dev->meta_pts = ctrl->val;
1451 break;
1452 case VIVID_CID_META_CAP_GENERATE_SCR:
1453 dev->meta_scr = ctrl->val;
1454 break;
1455 }
1456 return 0;
1457 }
1458
1459 static const struct v4l2_ctrl_ops vivid_meta_cap_ctrl_ops = {
1460 .s_ctrl = vivid_meta_cap_s_ctrl,
1461 };
1462
1463 static const struct v4l2_ctrl_config vivid_ctrl_meta_has_pts = {
1464 .ops = &vivid_meta_cap_ctrl_ops,
1465 .id = VIVID_CID_META_CAP_GENERATE_PTS,
1466 .name = "Generate PTS",
1467 .type = V4L2_CTRL_TYPE_BOOLEAN,
1468 .max = 1,
1469 .def = 1,
1470 .step = 1,
1471 };
1472
1473 static const struct v4l2_ctrl_config vivid_ctrl_meta_has_src_clk = {
1474 .ops = &vivid_meta_cap_ctrl_ops,
1475 .id = VIVID_CID_META_CAP_GENERATE_SCR,
1476 .name = "Generate SCR",
1477 .type = V4L2_CTRL_TYPE_BOOLEAN,
1478 .max = 1,
1479 .def = 1,
1480 .step = 1,
1481 };
1482
1483 static const struct v4l2_ctrl_config vivid_ctrl_class = {
1484 .ops = &vivid_user_gen_ctrl_ops,
1485 .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY,
1486 .id = VIVID_CID_VIVID_CLASS,
1487 .name = "Vivid Controls",
1488 .type = V4L2_CTRL_TYPE_CTRL_CLASS,
1489 };
1490
1491 int vivid_create_controls(struct vivid_dev *dev, bool show_ccs_cap,
1492 bool show_ccs_out, bool no_error_inj,
1493 bool has_sdtv, bool has_hdmi)
1494 {
1495 struct v4l2_ctrl_handler *hdl_user_gen = &dev->ctrl_hdl_user_gen;
1496 struct v4l2_ctrl_handler *hdl_user_vid = &dev->ctrl_hdl_user_vid;
1497 struct v4l2_ctrl_handler *hdl_user_aud = &dev->ctrl_hdl_user_aud;
1498 struct v4l2_ctrl_handler *hdl_streaming = &dev->ctrl_hdl_streaming;
1499 struct v4l2_ctrl_handler *hdl_sdtv_cap = &dev->ctrl_hdl_sdtv_cap;
1500 struct v4l2_ctrl_handler *hdl_loop_cap = &dev->ctrl_hdl_loop_cap;
1501 struct v4l2_ctrl_handler *hdl_fb = &dev->ctrl_hdl_fb;
1502 struct v4l2_ctrl_handler *hdl_vid_cap = &dev->ctrl_hdl_vid_cap;
1503 struct v4l2_ctrl_handler *hdl_vid_out = &dev->ctrl_hdl_vid_out;
1504 struct v4l2_ctrl_handler *hdl_vbi_cap = &dev->ctrl_hdl_vbi_cap;
1505 struct v4l2_ctrl_handler *hdl_vbi_out = &dev->ctrl_hdl_vbi_out;
1506 struct v4l2_ctrl_handler *hdl_radio_rx = &dev->ctrl_hdl_radio_rx;
1507 struct v4l2_ctrl_handler *hdl_radio_tx = &dev->ctrl_hdl_radio_tx;
1508 struct v4l2_ctrl_handler *hdl_sdr_cap = &dev->ctrl_hdl_sdr_cap;
1509 struct v4l2_ctrl_handler *hdl_meta_cap = &dev->ctrl_hdl_meta_cap;
1510 struct v4l2_ctrl_handler *hdl_meta_out = &dev->ctrl_hdl_meta_out;
1511 struct v4l2_ctrl_handler *hdl_tch_cap = &dev->ctrl_hdl_touch_cap;
1512
1513 struct v4l2_ctrl_config vivid_ctrl_dv_timings = {
1514 .ops = &vivid_vid_cap_ctrl_ops,
1515 .id = VIVID_CID_DV_TIMINGS,
1516 .name = "DV Timings",
1517 .type = V4L2_CTRL_TYPE_MENU,
1518 };
1519 int i;
1520
1521 v4l2_ctrl_handler_init(hdl_user_gen, 10);
1522 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_class, NULL);
1523 v4l2_ctrl_handler_init(hdl_user_vid, 9);
1524 v4l2_ctrl_new_custom(hdl_user_vid, &vivid_ctrl_class, NULL);
1525 v4l2_ctrl_handler_init(hdl_user_aud, 2);
1526 v4l2_ctrl_new_custom(hdl_user_aud, &vivid_ctrl_class, NULL);
1527 v4l2_ctrl_handler_init(hdl_streaming, 8);
1528 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_class, NULL);
1529 v4l2_ctrl_handler_init(hdl_sdtv_cap, 2);
1530 v4l2_ctrl_new_custom(hdl_sdtv_cap, &vivid_ctrl_class, NULL);
1531 v4l2_ctrl_handler_init(hdl_loop_cap, 1);
1532 v4l2_ctrl_new_custom(hdl_loop_cap, &vivid_ctrl_class, NULL);
1533 v4l2_ctrl_handler_init(hdl_fb, 1);
1534 v4l2_ctrl_new_custom(hdl_fb, &vivid_ctrl_class, NULL);
1535 v4l2_ctrl_handler_init(hdl_vid_cap, 55);
1536 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_class, NULL);
1537 v4l2_ctrl_handler_init(hdl_vid_out, 26);
1538 if (!no_error_inj || dev->has_fb || dev->num_hdmi_outputs)
1539 v4l2_ctrl_new_custom(hdl_vid_out, &vivid_ctrl_class, NULL);
1540 v4l2_ctrl_handler_init(hdl_vbi_cap, 21);
1541 v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_class, NULL);
1542 v4l2_ctrl_handler_init(hdl_vbi_out, 19);
1543 if (!no_error_inj)
1544 v4l2_ctrl_new_custom(hdl_vbi_out, &vivid_ctrl_class, NULL);
1545 v4l2_ctrl_handler_init(hdl_radio_rx, 17);
1546 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_class, NULL);
1547 v4l2_ctrl_handler_init(hdl_radio_tx, 17);
1548 v4l2_ctrl_new_custom(hdl_radio_tx, &vivid_ctrl_class, NULL);
1549 v4l2_ctrl_handler_init(hdl_sdr_cap, 19);
1550 v4l2_ctrl_new_custom(hdl_sdr_cap, &vivid_ctrl_class, NULL);
1551 v4l2_ctrl_handler_init(hdl_meta_cap, 2);
1552 v4l2_ctrl_new_custom(hdl_meta_cap, &vivid_ctrl_class, NULL);
1553 v4l2_ctrl_handler_init(hdl_meta_out, 2);
1554 v4l2_ctrl_new_custom(hdl_meta_out, &vivid_ctrl_class, NULL);
1555 v4l2_ctrl_handler_init(hdl_tch_cap, 2);
1556 v4l2_ctrl_new_custom(hdl_tch_cap, &vivid_ctrl_class, NULL);
1557
1558 /* User Controls */
1559 dev->volume = v4l2_ctrl_new_std(hdl_user_aud, NULL,
1560 V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
1561 dev->mute = v4l2_ctrl_new_std(hdl_user_aud, NULL,
1562 V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
1563 if (dev->has_vid_cap) {
1564 dev->brightness = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1565 V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
1566 for (i = 0; i < MAX_INPUTS; i++)
1567 dev->input_brightness[i] = 128;
1568 dev->contrast = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1569 V4L2_CID_CONTRAST, 0, 255, 1, 128);
1570 dev->saturation = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1571 V4L2_CID_SATURATION, 0, 255, 1, 128);
1572 dev->hue = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1573 V4L2_CID_HUE, -128, 128, 1, 0);
1574 v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1575 V4L2_CID_HFLIP, 0, 1, 1, 0);
1576 v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1577 V4L2_CID_VFLIP, 0, 1, 1, 0);
1578 dev->autogain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1579 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
1580 dev->gain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1581 V4L2_CID_GAIN, 0, 255, 1, 100);
1582 dev->alpha = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
1583 V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
1584 }
1585 dev->button = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_button, NULL);
1586 dev->int32 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int32, NULL);
1587 dev->int64 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int64, NULL);
1588 dev->boolean = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_boolean, NULL);
1589 dev->menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_menu, NULL);
1590 dev->string = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_string, NULL);
1591 dev->bitmask = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_bitmask, NULL);
1592 dev->int_menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int_menu, NULL);
1593 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_area, NULL);
1594 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u32_array, NULL);
1595 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u16_matrix, NULL);
1596 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u8_4d_array, NULL);
1597
1598 if (dev->has_vid_cap) {
1599 /* Image Processing Controls */
1600 struct v4l2_ctrl_config vivid_ctrl_test_pattern = {
1601 .ops = &vivid_vid_cap_ctrl_ops,
1602 .id = VIVID_CID_TEST_PATTERN,
1603 .name = "Test Pattern",
1604 .type = V4L2_CTRL_TYPE_MENU,
1605 .max = TPG_PAT_NOISE,
1606 .qmenu = tpg_pattern_strings,
1607 };
1608
1609 dev->test_pattern = v4l2_ctrl_new_custom(hdl_vid_cap,
1610 &vivid_ctrl_test_pattern, NULL);
1611 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_perc_fill, NULL);
1612 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hor_movement, NULL);
1613 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vert_movement, NULL);
1614 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_osd_mode, NULL);
1615 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_border, NULL);
1616 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_square, NULL);
1617 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hflip, NULL);
1618 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vflip, NULL);
1619 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_sav, NULL);
1620 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_eav, NULL);
1621 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_reduced_fps, NULL);
1622 if (show_ccs_cap) {
1623 dev->ctrl_has_crop_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1624 &vivid_ctrl_has_crop_cap, NULL);
1625 dev->ctrl_has_compose_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1626 &vivid_ctrl_has_compose_cap, NULL);
1627 dev->ctrl_has_scaler_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1628 &vivid_ctrl_has_scaler_cap, NULL);
1629 }
1630
1631 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_tstamp_src, NULL);
1632 dev->colorspace = v4l2_ctrl_new_custom(hdl_vid_cap,
1633 &vivid_ctrl_colorspace, NULL);
1634 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_xfer_func, NULL);
1635 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_ycbcr_enc, NULL);
1636 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hsv_enc, NULL);
1637 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_quantization, NULL);
1638 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_alpha_mode, NULL);
1639 }
1640
1641 if (dev->has_vid_out && show_ccs_out) {
1642 dev->ctrl_has_crop_out = v4l2_ctrl_new_custom(hdl_vid_out,
1643 &vivid_ctrl_has_crop_out, NULL);
1644 dev->ctrl_has_compose_out = v4l2_ctrl_new_custom(hdl_vid_out,
1645 &vivid_ctrl_has_compose_out, NULL);
1646 dev->ctrl_has_scaler_out = v4l2_ctrl_new_custom(hdl_vid_out,
1647 &vivid_ctrl_has_scaler_out, NULL);
1648 }
1649
1650 /*
1651 * Testing this driver with v4l2-compliance will trigger the error
1652 * injection controls, and after that nothing will work as expected.
1653 * So we have a module option to drop these error injecting controls
1654 * allowing us to run v4l2_compliance again.
1655 */
1656 if (!no_error_inj) {
1657 v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_disconnect, NULL);
1658 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_dqbuf_error, NULL);
1659 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_perc_dropped, NULL);
1660 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_setup_error, NULL);
1661 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_buf_prepare_error, NULL);
1662 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_start_streaming_error, NULL);
1663 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_error, NULL);
1664 #ifdef CONFIG_MEDIA_CONTROLLER
1665 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_req_validate_error, NULL);
1666 #endif
1667 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_seq_wrap, NULL);
1668 v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_time_wrap, NULL);
1669 }
1670
1671 if (has_sdtv && (dev->has_vid_cap || dev->has_vbi_cap)) {
1672 if (dev->has_vid_cap)
1673 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_std_aspect_ratio, NULL);
1674 dev->ctrl_std_signal_mode = v4l2_ctrl_new_custom(hdl_sdtv_cap,
1675 &vivid_ctrl_std_signal_mode, NULL);
1676 dev->ctrl_standard = v4l2_ctrl_new_custom(hdl_sdtv_cap,
1677 &vivid_ctrl_standard, NULL);
1678 if (dev->ctrl_std_signal_mode)
1679 v4l2_ctrl_cluster(2, &dev->ctrl_std_signal_mode);
1680 if (dev->has_raw_vbi_cap)
1681 v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_vbi_cap_interlaced, NULL);
1682 }
1683
1684 if (dev->num_hdmi_inputs) {
1685 s64 hdmi_input_mask = GENMASK(dev->num_hdmi_inputs - 1, 0);
1686
1687 dev->ctrl_dv_timings_signal_mode = v4l2_ctrl_new_custom(hdl_vid_cap,
1688 &vivid_ctrl_dv_timings_signal_mode, NULL);
1689
1690 vivid_ctrl_dv_timings.max = dev->query_dv_timings_size - 1;
1691 vivid_ctrl_dv_timings.qmenu =
1692 (const char * const *)dev->query_dv_timings_qmenu;
1693 dev->ctrl_dv_timings = v4l2_ctrl_new_custom(hdl_vid_cap,
1694 &vivid_ctrl_dv_timings, NULL);
1695 if (dev->ctrl_dv_timings_signal_mode)
1696 v4l2_ctrl_cluster(2, &dev->ctrl_dv_timings_signal_mode);
1697
1698 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_dv_timings_aspect_ratio, NULL);
1699 v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_max_edid_blocks, NULL);
1700 dev->real_rgb_range_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
1701 &vivid_ctrl_limited_rgb_range, NULL);
1702 dev->rgb_range_cap = v4l2_ctrl_new_std_menu(hdl_vid_cap,
1703 &vivid_vid_cap_ctrl_ops,
1704 V4L2_CID_DV_RX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1705 0, V4L2_DV_RGB_RANGE_AUTO);
1706 dev->ctrl_rx_power_present = v4l2_ctrl_new_std(hdl_vid_cap,
1707 NULL, V4L2_CID_DV_RX_POWER_PRESENT, 0, hdmi_input_mask,
1708 0, hdmi_input_mask);
1709
1710 }
1711 if (dev->num_hdmi_outputs) {
1712 s64 hdmi_output_mask = GENMASK(dev->num_hdmi_outputs - 1, 0);
1713
1714 /*
1715 * We aren't doing anything with this at the moment, but
1716 * HDMI outputs typically have this controls.
1717 */
1718 dev->ctrl_tx_rgb_range = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
1719 V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
1720 0, V4L2_DV_RGB_RANGE_AUTO);
1721 dev->ctrl_tx_mode = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
1722 V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
1723 0, V4L2_DV_TX_MODE_HDMI);
1724 dev->ctrl_display_present = v4l2_ctrl_new_custom(hdl_vid_out,
1725 &vivid_ctrl_display_present, NULL);
1726 dev->ctrl_tx_hotplug = v4l2_ctrl_new_std(hdl_vid_out,
1727 NULL, V4L2_CID_DV_TX_HOTPLUG, 0, hdmi_output_mask,
1728 0, hdmi_output_mask);
1729 dev->ctrl_tx_rxsense = v4l2_ctrl_new_std(hdl_vid_out,
1730 NULL, V4L2_CID_DV_TX_RXSENSE, 0, hdmi_output_mask,
1731 0, hdmi_output_mask);
1732 dev->ctrl_tx_edid_present = v4l2_ctrl_new_std(hdl_vid_out,
1733 NULL, V4L2_CID_DV_TX_EDID_PRESENT, 0, hdmi_output_mask,
1734 0, hdmi_output_mask);
1735 }
1736 if ((dev->has_vid_cap && dev->has_vid_out) ||
1737 (dev->has_vbi_cap && dev->has_vbi_out))
1738 v4l2_ctrl_new_custom(hdl_loop_cap, &vivid_ctrl_loop_video, NULL);
1739
1740 if (dev->has_fb)
1741 v4l2_ctrl_new_custom(hdl_fb, &vivid_ctrl_clear_fb, NULL);
1742
1743 if (dev->has_radio_rx) {
1744 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_mode, NULL);
1745 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_prog_lim, NULL);
1746 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_blockio, NULL);
1747 v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_rbds, NULL);
1748 v4l2_ctrl_new_std(hdl_radio_rx, &vivid_radio_rx_ctrl_ops,
1749 V4L2_CID_RDS_RECEPTION, 0, 1, 1, 1);
1750 dev->radio_rx_rds_pty = v4l2_ctrl_new_std(hdl_radio_rx,
1751 &vivid_radio_rx_ctrl_ops,
1752 V4L2_CID_RDS_RX_PTY, 0, 31, 1, 0);
1753 dev->radio_rx_rds_psname = v4l2_ctrl_new_std(hdl_radio_rx,
1754 &vivid_radio_rx_ctrl_ops,
1755 V4L2_CID_RDS_RX_PS_NAME, 0, 8, 8, 0);
1756 dev->radio_rx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_rx,
1757 &vivid_radio_rx_ctrl_ops,
1758 V4L2_CID_RDS_RX_RADIO_TEXT, 0, 64, 64, 0);
1759 dev->radio_rx_rds_ta = v4l2_ctrl_new_std(hdl_radio_rx,
1760 &vivid_radio_rx_ctrl_ops,
1761 V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1762 dev->radio_rx_rds_tp = v4l2_ctrl_new_std(hdl_radio_rx,
1763 &vivid_radio_rx_ctrl_ops,
1764 V4L2_CID_RDS_RX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
1765 dev->radio_rx_rds_ms = v4l2_ctrl_new_std(hdl_radio_rx,
1766 &vivid_radio_rx_ctrl_ops,
1767 V4L2_CID_RDS_RX_MUSIC_SPEECH, 0, 1, 1, 1);
1768 }
1769 if (dev->has_radio_tx) {
1770 v4l2_ctrl_new_custom(hdl_radio_tx,
1771 &vivid_ctrl_radio_tx_rds_blockio, NULL);
1772 dev->radio_tx_rds_pi = v4l2_ctrl_new_std(hdl_radio_tx,
1773 &vivid_radio_tx_ctrl_ops,
1774 V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, 0x8088);
1775 dev->radio_tx_rds_pty = v4l2_ctrl_new_std(hdl_radio_tx,
1776 &vivid_radio_tx_ctrl_ops,
1777 V4L2_CID_RDS_TX_PTY, 0, 31, 1, 3);
1778 dev->radio_tx_rds_psname = v4l2_ctrl_new_std(hdl_radio_tx,
1779 &vivid_radio_tx_ctrl_ops,
1780 V4L2_CID_RDS_TX_PS_NAME, 0, 8, 8, 0);
1781 if (dev->radio_tx_rds_psname)
1782 v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_psname, "VIVID-TX");
1783 dev->radio_tx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_tx,
1784 &vivid_radio_tx_ctrl_ops,
1785 V4L2_CID_RDS_TX_RADIO_TEXT, 0, 64 * 2, 64, 0);
1786 if (dev->radio_tx_rds_radiotext)
1787 v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_radiotext,
1788 "This is a VIVID default Radio Text template text, change at will");
1789 dev->radio_tx_rds_mono_stereo = v4l2_ctrl_new_std(hdl_radio_tx,
1790 &vivid_radio_tx_ctrl_ops,
1791 V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
1792 dev->radio_tx_rds_art_head = v4l2_ctrl_new_std(hdl_radio_tx,
1793 &vivid_radio_tx_ctrl_ops,
1794 V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
1795 dev->radio_tx_rds_compressed = v4l2_ctrl_new_std(hdl_radio_tx,
1796 &vivid_radio_tx_ctrl_ops,
1797 V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
1798 dev->radio_tx_rds_dyn_pty = v4l2_ctrl_new_std(hdl_radio_tx,
1799 &vivid_radio_tx_ctrl_ops,
1800 V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
1801 dev->radio_tx_rds_ta = v4l2_ctrl_new_std(hdl_radio_tx,
1802 &vivid_radio_tx_ctrl_ops,
1803 V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
1804 dev->radio_tx_rds_tp = v4l2_ctrl_new_std(hdl_radio_tx,
1805 &vivid_radio_tx_ctrl_ops,
1806 V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 1);
1807 dev->radio_tx_rds_ms = v4l2_ctrl_new_std(hdl_radio_tx,
1808 &vivid_radio_tx_ctrl_ops,
1809 V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
1810 }
1811 if (dev->has_sdr_cap) {
1812 v4l2_ctrl_new_custom(hdl_sdr_cap,
1813 &vivid_ctrl_sdr_cap_fm_deviation, NULL);
1814 }
1815 if (dev->has_meta_cap) {
1816 v4l2_ctrl_new_custom(hdl_meta_cap,
1817 &vivid_ctrl_meta_has_pts, NULL);
1818 v4l2_ctrl_new_custom(hdl_meta_cap,
1819 &vivid_ctrl_meta_has_src_clk, NULL);
1820 }
1821
1822 if (hdl_user_gen->error)
1823 return hdl_user_gen->error;
1824 if (hdl_user_vid->error)
1825 return hdl_user_vid->error;
1826 if (hdl_user_aud->error)
1827 return hdl_user_aud->error;
1828 if (hdl_streaming->error)
1829 return hdl_streaming->error;
1830 if (hdl_sdr_cap->error)
1831 return hdl_sdr_cap->error;
1832 if (hdl_loop_cap->error)
1833 return hdl_loop_cap->error;
1834
1835 if (dev->autogain)
1836 v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
1837
1838 if (dev->has_vid_cap) {
1839 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_gen, NULL, false);
1840 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_vid, NULL, false);
1841 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_aud, NULL, false);
1842 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_streaming, NULL, false);
1843 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_sdtv_cap, NULL, false);
1844 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_loop_cap, NULL, false);
1845 v4l2_ctrl_add_handler(hdl_vid_cap, hdl_fb, NULL, false);
1846 if (hdl_vid_cap->error)
1847 return hdl_vid_cap->error;
1848 dev->vid_cap_dev.ctrl_handler = hdl_vid_cap;
1849 }
1850 if (dev->has_vid_out) {
1851 v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_gen, NULL, false);
1852 v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_aud, NULL, false);
1853 v4l2_ctrl_add_handler(hdl_vid_out, hdl_streaming, NULL, false);
1854 v4l2_ctrl_add_handler(hdl_vid_out, hdl_fb, NULL, false);
1855 if (hdl_vid_out->error)
1856 return hdl_vid_out->error;
1857 dev->vid_out_dev.ctrl_handler = hdl_vid_out;
1858 }
1859 if (dev->has_vbi_cap) {
1860 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_user_gen, NULL, false);
1861 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_streaming, NULL, false);
1862 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_sdtv_cap, NULL, false);
1863 v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_loop_cap, NULL, false);
1864 if (hdl_vbi_cap->error)
1865 return hdl_vbi_cap->error;
1866 dev->vbi_cap_dev.ctrl_handler = hdl_vbi_cap;
1867 }
1868 if (dev->has_vbi_out) {
1869 v4l2_ctrl_add_handler(hdl_vbi_out, hdl_user_gen, NULL, false);
1870 v4l2_ctrl_add_handler(hdl_vbi_out, hdl_streaming, NULL, false);
1871 if (hdl_vbi_out->error)
1872 return hdl_vbi_out->error;
1873 dev->vbi_out_dev.ctrl_handler = hdl_vbi_out;
1874 }
1875 if (dev->has_radio_rx) {
1876 v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_gen, NULL, false);
1877 v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_aud, NULL, false);
1878 if (hdl_radio_rx->error)
1879 return hdl_radio_rx->error;
1880 dev->radio_rx_dev.ctrl_handler = hdl_radio_rx;
1881 }
1882 if (dev->has_radio_tx) {
1883 v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_gen, NULL, false);
1884 v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_aud, NULL, false);
1885 if (hdl_radio_tx->error)
1886 return hdl_radio_tx->error;
1887 dev->radio_tx_dev.ctrl_handler = hdl_radio_tx;
1888 }
1889 if (dev->has_sdr_cap) {
1890 v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_user_gen, NULL, false);
1891 v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_streaming, NULL, false);
1892 if (hdl_sdr_cap->error)
1893 return hdl_sdr_cap->error;
1894 dev->sdr_cap_dev.ctrl_handler = hdl_sdr_cap;
1895 }
1896 if (dev->has_meta_cap) {
1897 v4l2_ctrl_add_handler(hdl_meta_cap, hdl_user_gen, NULL, false);
1898 v4l2_ctrl_add_handler(hdl_meta_cap, hdl_streaming, NULL, false);
1899 if (hdl_meta_cap->error)
1900 return hdl_meta_cap->error;
1901 dev->meta_cap_dev.ctrl_handler = hdl_meta_cap;
1902 }
1903 if (dev->has_meta_out) {
1904 v4l2_ctrl_add_handler(hdl_meta_out, hdl_user_gen, NULL, false);
1905 v4l2_ctrl_add_handler(hdl_meta_out, hdl_streaming, NULL, false);
1906 if (hdl_meta_out->error)
1907 return hdl_meta_out->error;
1908 dev->meta_out_dev.ctrl_handler = hdl_meta_out;
1909 }
1910 if (dev->has_touch_cap) {
1911 v4l2_ctrl_add_handler(hdl_tch_cap, hdl_user_gen, NULL, false);
1912 v4l2_ctrl_add_handler(hdl_tch_cap, hdl_streaming, NULL, false);
1913 if (hdl_tch_cap->error)
1914 return hdl_tch_cap->error;
1915 dev->touch_cap_dev.ctrl_handler = hdl_tch_cap;
1916 }
1917 return 0;
1918 }
1919
1920 void vivid_free_controls(struct vivid_dev *dev)
1921 {
1922 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_cap);
1923 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_out);
1924 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_cap);
1925 v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_out);
1926 v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_rx);
1927 v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_tx);
1928 v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdr_cap);
1929 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_gen);
1930 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_vid);
1931 v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_aud);
1932 v4l2_ctrl_handler_free(&dev->ctrl_hdl_streaming);
1933 v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdtv_cap);
1934 v4l2_ctrl_handler_free(&dev->ctrl_hdl_loop_cap);
1935 v4l2_ctrl_handler_free(&dev->ctrl_hdl_fb);
1936 v4l2_ctrl_handler_free(&dev->ctrl_hdl_meta_cap);
1937 v4l2_ctrl_handler_free(&dev->ctrl_hdl_meta_out);
1938 v4l2_ctrl_handler_free(&dev->ctrl_hdl_touch_cap);
1939 }
Linux with added FPC-III support