kernel/drivers/media/platform/vivid/vivid-ctrls.c

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