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