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