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