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