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