media: split test drivers from platform directory

When the first test device was added (vivi.c), there were just
one file. I was too lazy on that time to create a separate
directory just for it, so I kept it together with platform.

Now, we have vivid, vicodec, vim2m and vimc. Also, a new
virtual driver has been prepared to support DVB API.

So, it is time to solve this mess, by placing test stuff
on a separate directory.

It should be noticed that we also have some skeleton drivers
(for V4L and for DVB). For now, we'll keep them separate,
as they're not really test drivers, but instead, just
examples. The DVB frontend ones will likely be part of a new DVB
test driver. By that time, it should make sense to move them
here as well.

Signed-off-by: Mauro Carvalho Chehab <mchehab+huawei@kernel.org>

1 files changed, 0 insertions, 1939 deletions

diff --git a/drivers/media/platform/vivid/vivid-ctrls.c b/drivers/media/platform/vivid/vivid-ctrls.c
deleted file mode 100644
index 334130568dcb..000000000000
--- a/drivers/media/platform/vivid/vivid-ctrls.c
+++ /dev/null
@@ -1,1939 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0-only
-/*
- * vivid-ctrls.c - control support functions.
- *
- * Copyright 2014 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
- */
-
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/videodev2.h>
-#include <media/v4l2-event.h>
-#include <media/v4l2-common.h>
-
-#include "vivid-core.h"
-#include "vivid-vid-cap.h"
-#include "vivid-vid-out.h"
-#include "vivid-vid-common.h"
-#include "vivid-radio-common.h"
-#include "vivid-osd.h"
-#include "vivid-ctrls.h"
-#include "vivid-cec.h"
-
-#define VIVID_CID_CUSTOM_BASE		(V4L2_CID_USER_BASE | 0xf000)
-#define VIVID_CID_BUTTON		(VIVID_CID_CUSTOM_BASE + 0)
-#define VIVID_CID_BOOLEAN		(VIVID_CID_CUSTOM_BASE + 1)
-#define VIVID_CID_INTEGER		(VIVID_CID_CUSTOM_BASE + 2)
-#define VIVID_CID_INTEGER64		(VIVID_CID_CUSTOM_BASE + 3)
-#define VIVID_CID_MENU			(VIVID_CID_CUSTOM_BASE + 4)
-#define VIVID_CID_STRING		(VIVID_CID_CUSTOM_BASE + 5)
-#define VIVID_CID_BITMASK		(VIVID_CID_CUSTOM_BASE + 6)
-#define VIVID_CID_INTMENU		(VIVID_CID_CUSTOM_BASE + 7)
-#define VIVID_CID_U32_ARRAY		(VIVID_CID_CUSTOM_BASE + 8)
-#define VIVID_CID_U16_MATRIX		(VIVID_CID_CUSTOM_BASE + 9)
-#define VIVID_CID_U8_4D_ARRAY		(VIVID_CID_CUSTOM_BASE + 10)
-#define VIVID_CID_AREA			(VIVID_CID_CUSTOM_BASE + 11)
-
-#define VIVID_CID_VIVID_BASE		(0x00f00000 | 0xf000)
-#define VIVID_CID_VIVID_CLASS		(0x00f00000 | 1)
-#define VIVID_CID_TEST_PATTERN		(VIVID_CID_VIVID_BASE + 0)
-#define VIVID_CID_OSD_TEXT_MODE		(VIVID_CID_VIVID_BASE + 1)
-#define VIVID_CID_HOR_MOVEMENT		(VIVID_CID_VIVID_BASE + 2)
-#define VIVID_CID_VERT_MOVEMENT		(VIVID_CID_VIVID_BASE + 3)
-#define VIVID_CID_SHOW_BORDER		(VIVID_CID_VIVID_BASE + 4)
-#define VIVID_CID_SHOW_SQUARE		(VIVID_CID_VIVID_BASE + 5)
-#define VIVID_CID_INSERT_SAV		(VIVID_CID_VIVID_BASE + 6)
-#define VIVID_CID_INSERT_EAV		(VIVID_CID_VIVID_BASE + 7)
-#define VIVID_CID_VBI_CAP_INTERLACED	(VIVID_CID_VIVID_BASE + 8)
-
-#define VIVID_CID_HFLIP			(VIVID_CID_VIVID_BASE + 20)
-#define VIVID_CID_VFLIP			(VIVID_CID_VIVID_BASE + 21)
-#define VIVID_CID_STD_ASPECT_RATIO	(VIVID_CID_VIVID_BASE + 22)
-#define VIVID_CID_DV_TIMINGS_ASPECT_RATIO	(VIVID_CID_VIVID_BASE + 23)
-#define VIVID_CID_TSTAMP_SRC		(VIVID_CID_VIVID_BASE + 24)
-#define VIVID_CID_COLORSPACE		(VIVID_CID_VIVID_BASE + 25)
-#define VIVID_CID_XFER_FUNC		(VIVID_CID_VIVID_BASE + 26)
-#define VIVID_CID_YCBCR_ENC		(VIVID_CID_VIVID_BASE + 27)
-#define VIVID_CID_QUANTIZATION		(VIVID_CID_VIVID_BASE + 28)
-#define VIVID_CID_LIMITED_RGB_RANGE	(VIVID_CID_VIVID_BASE + 29)
-#define VIVID_CID_ALPHA_MODE		(VIVID_CID_VIVID_BASE + 30)
-#define VIVID_CID_HAS_CROP_CAP		(VIVID_CID_VIVID_BASE + 31)
-#define VIVID_CID_HAS_COMPOSE_CAP	(VIVID_CID_VIVID_BASE + 32)
-#define VIVID_CID_HAS_SCALER_CAP	(VIVID_CID_VIVID_BASE + 33)
-#define VIVID_CID_HAS_CROP_OUT		(VIVID_CID_VIVID_BASE + 34)
-#define VIVID_CID_HAS_COMPOSE_OUT	(VIVID_CID_VIVID_BASE + 35)
-#define VIVID_CID_HAS_SCALER_OUT	(VIVID_CID_VIVID_BASE + 36)
-#define VIVID_CID_LOOP_VIDEO		(VIVID_CID_VIVID_BASE + 37)
-#define VIVID_CID_SEQ_WRAP		(VIVID_CID_VIVID_BASE + 38)
-#define VIVID_CID_TIME_WRAP		(VIVID_CID_VIVID_BASE + 39)
-#define VIVID_CID_MAX_EDID_BLOCKS	(VIVID_CID_VIVID_BASE + 40)
-#define VIVID_CID_PERCENTAGE_FILL	(VIVID_CID_VIVID_BASE + 41)
-#define VIVID_CID_REDUCED_FPS		(VIVID_CID_VIVID_BASE + 42)
-#define VIVID_CID_HSV_ENC		(VIVID_CID_VIVID_BASE + 43)
-#define VIVID_CID_DISPLAY_PRESENT	(VIVID_CID_VIVID_BASE + 44)
-
-#define VIVID_CID_STD_SIGNAL_MODE	(VIVID_CID_VIVID_BASE + 60)
-#define VIVID_CID_STANDARD		(VIVID_CID_VIVID_BASE + 61)
-#define VIVID_CID_DV_TIMINGS_SIGNAL_MODE	(VIVID_CID_VIVID_BASE + 62)
-#define VIVID_CID_DV_TIMINGS		(VIVID_CID_VIVID_BASE + 63)
-#define VIVID_CID_PERC_DROPPED		(VIVID_CID_VIVID_BASE + 64)
-#define VIVID_CID_DISCONNECT		(VIVID_CID_VIVID_BASE + 65)
-#define VIVID_CID_DQBUF_ERROR		(VIVID_CID_VIVID_BASE + 66)
-#define VIVID_CID_QUEUE_SETUP_ERROR	(VIVID_CID_VIVID_BASE + 67)
-#define VIVID_CID_BUF_PREPARE_ERROR	(VIVID_CID_VIVID_BASE + 68)
-#define VIVID_CID_START_STR_ERROR	(VIVID_CID_VIVID_BASE + 69)
-#define VIVID_CID_QUEUE_ERROR		(VIVID_CID_VIVID_BASE + 70)
-#define VIVID_CID_CLEAR_FB		(VIVID_CID_VIVID_BASE + 71)
-#define VIVID_CID_REQ_VALIDATE_ERROR	(VIVID_CID_VIVID_BASE + 72)
-
-#define VIVID_CID_RADIO_SEEK_MODE	(VIVID_CID_VIVID_BASE + 90)
-#define VIVID_CID_RADIO_SEEK_PROG_LIM	(VIVID_CID_VIVID_BASE + 91)
-#define VIVID_CID_RADIO_RX_RDS_RBDS	(VIVID_CID_VIVID_BASE + 92)
-#define VIVID_CID_RADIO_RX_RDS_BLOCKIO	(VIVID_CID_VIVID_BASE + 93)
-
-#define VIVID_CID_RADIO_TX_RDS_BLOCKIO	(VIVID_CID_VIVID_BASE + 94)
-
-#define VIVID_CID_SDR_CAP_FM_DEVIATION	(VIVID_CID_VIVID_BASE + 110)
-
-#define VIVID_CID_META_CAP_GENERATE_PTS	(VIVID_CID_VIVID_BASE + 111)
-#define VIVID_CID_META_CAP_GENERATE_SCR	(VIVID_CID_VIVID_BASE + 112)
-
-/* General User Controls */
-
-static int vivid_user_gen_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_gen);
-
-	switch (ctrl->id) {
-	case VIVID_CID_DISCONNECT:
-		v4l2_info(&dev->v4l2_dev, "disconnect\n");
-		clear_bit(V4L2_FL_REGISTERED, &dev->vid_cap_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->vid_out_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->vbi_cap_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->vbi_out_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->sdr_cap_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->radio_rx_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->radio_tx_dev.flags);
-		clear_bit(V4L2_FL_REGISTERED, &dev->meta_cap_dev.flags);
-		break;
-	case VIVID_CID_BUTTON:
-		dev->button_pressed = 30;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_user_gen_ctrl_ops = {
-	.s_ctrl = vivid_user_gen_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_button = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_BUTTON,
-	.name = "Button",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_boolean = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_BOOLEAN,
-	.name = "Boolean",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.min = 0,
-	.max = 1,
-	.step = 1,
-	.def = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_int32 = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_INTEGER,
-	.name = "Integer 32 Bits",
-	.type = V4L2_CTRL_TYPE_INTEGER,
-	.min = 0xffffffff80000000ULL,
-	.max = 0x7fffffff,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_int64 = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_INTEGER64,
-	.name = "Integer 64 Bits",
-	.type = V4L2_CTRL_TYPE_INTEGER64,
-	.min = 0x8000000000000000ULL,
-	.max = 0x7fffffffffffffffLL,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_u32_array = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_U32_ARRAY,
-	.name = "U32 1 Element Array",
-	.type = V4L2_CTRL_TYPE_U32,
-	.def = 0x18,
-	.min = 0x10,
-	.max = 0x20000,
-	.step = 1,
-	.dims = { 1 },
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_u16_matrix = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_U16_MATRIX,
-	.name = "U16 8x16 Matrix",
-	.type = V4L2_CTRL_TYPE_U16,
-	.def = 0x18,
-	.min = 0x10,
-	.max = 0x2000,
-	.step = 1,
-	.dims = { 8, 16 },
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_u8_4d_array = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_U8_4D_ARRAY,
-	.name = "U8 2x3x4x5 Array",
-	.type = V4L2_CTRL_TYPE_U8,
-	.def = 0x18,
-	.min = 0x10,
-	.max = 0x20,
-	.step = 1,
-	.dims = { 2, 3, 4, 5 },
-};
-
-static const char * const vivid_ctrl_menu_strings[] = {
-	"Menu Item 0 (Skipped)",
-	"Menu Item 1",
-	"Menu Item 2 (Skipped)",
-	"Menu Item 3",
-	"Menu Item 4",
-	"Menu Item 5 (Skipped)",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_menu = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_MENU,
-	.name = "Menu",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.min = 1,
-	.max = 4,
-	.def = 3,
-	.menu_skip_mask = 0x04,
-	.qmenu = vivid_ctrl_menu_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_string = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_STRING,
-	.name = "String",
-	.type = V4L2_CTRL_TYPE_STRING,
-	.min = 2,
-	.max = 4,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_bitmask = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_BITMASK,
-	.name = "Bitmask",
-	.type = V4L2_CTRL_TYPE_BITMASK,
-	.def = 0x80002000,
-	.min = 0,
-	.max = 0x80402010,
-	.step = 0,
-};
-
-static const s64 vivid_ctrl_int_menu_values[] = {
-	1, 1, 2, 3, 5, 8, 13, 21, 42,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_int_menu = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_INTMENU,
-	.name = "Integer Menu",
-	.type = V4L2_CTRL_TYPE_INTEGER_MENU,
-	.min = 1,
-	.max = 8,
-	.def = 4,
-	.menu_skip_mask = 0x02,
-	.qmenu_int = vivid_ctrl_int_menu_values,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_disconnect = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_DISCONNECT,
-	.name = "Disconnect",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_area area = {
-	.width = 1000,
-	.height = 2000,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_area = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.id = VIVID_CID_AREA,
-	.name = "Area",
-	.type = V4L2_CTRL_TYPE_AREA,
-	.p_def.p_const = &area,
-};
-
-/* Framebuffer Controls */
-
-static int vivid_fb_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler,
-					     struct vivid_dev, ctrl_hdl_fb);
-
-	switch (ctrl->id) {
-	case VIVID_CID_CLEAR_FB:
-		vivid_clear_fb(dev);
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_fb_ctrl_ops = {
-	.s_ctrl = vivid_fb_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_clear_fb = {
-	.ops = &vivid_fb_ctrl_ops,
-	.id = VIVID_CID_CLEAR_FB,
-	.name = "Clear Framebuffer",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-
-/* Video User Controls */
-
-static int vivid_user_vid_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
-
-	switch (ctrl->id) {
-	case V4L2_CID_AUTOGAIN:
-		dev->gain->val = (jiffies_to_msecs(jiffies) / 1000) & 0xff;
-		break;
-	}
-	return 0;
-}
-
-static int vivid_user_vid_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_user_vid);
-
-	switch (ctrl->id) {
-	case V4L2_CID_BRIGHTNESS:
-		dev->input_brightness[dev->input] = ctrl->val - dev->input * 128;
-		tpg_s_brightness(&dev->tpg, dev->input_brightness[dev->input]);
-		break;
-	case V4L2_CID_CONTRAST:
-		tpg_s_contrast(&dev->tpg, ctrl->val);
-		break;
-	case V4L2_CID_SATURATION:
-		tpg_s_saturation(&dev->tpg, ctrl->val);
-		break;
-	case V4L2_CID_HUE:
-		tpg_s_hue(&dev->tpg, ctrl->val);
-		break;
-	case V4L2_CID_HFLIP:
-		dev->hflip = ctrl->val;
-		tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
-		break;
-	case V4L2_CID_VFLIP:
-		dev->vflip = ctrl->val;
-		tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
-		break;
-	case V4L2_CID_ALPHA_COMPONENT:
-		tpg_s_alpha_component(&dev->tpg, ctrl->val);
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_user_vid_ctrl_ops = {
-	.g_volatile_ctrl = vivid_user_vid_g_volatile_ctrl,
-	.s_ctrl = vivid_user_vid_s_ctrl,
-};
-
-
-/* Video Capture Controls */
-
-static int vivid_vid_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	static const u32 colorspaces[] = {
-		V4L2_COLORSPACE_SMPTE170M,
-		V4L2_COLORSPACE_REC709,
-		V4L2_COLORSPACE_SRGB,
-		V4L2_COLORSPACE_OPRGB,
-		V4L2_COLORSPACE_BT2020,
-		V4L2_COLORSPACE_DCI_P3,
-		V4L2_COLORSPACE_SMPTE240M,
-		V4L2_COLORSPACE_470_SYSTEM_M,
-		V4L2_COLORSPACE_470_SYSTEM_BG,
-	};
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_cap);
-	unsigned int i, j;
-
-	switch (ctrl->id) {
-	case VIVID_CID_TEST_PATTERN:
-		vivid_update_quality(dev);
-		tpg_s_pattern(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_COLORSPACE:
-		tpg_s_colorspace(&dev->tpg, colorspaces[ctrl->val]);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		vivid_send_source_change(dev, WEBCAM);
-		break;
-	case VIVID_CID_XFER_FUNC:
-		tpg_s_xfer_func(&dev->tpg, ctrl->val);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		vivid_send_source_change(dev, WEBCAM);
-		break;
-	case VIVID_CID_YCBCR_ENC:
-		tpg_s_ycbcr_enc(&dev->tpg, ctrl->val);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		vivid_send_source_change(dev, WEBCAM);
-		break;
-	case VIVID_CID_HSV_ENC:
-		tpg_s_hsv_enc(&dev->tpg, ctrl->val ? V4L2_HSV_ENC_256 :
-						     V4L2_HSV_ENC_180);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		vivid_send_source_change(dev, WEBCAM);
-		break;
-	case VIVID_CID_QUANTIZATION:
-		tpg_s_quantization(&dev->tpg, ctrl->val);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		vivid_send_source_change(dev, WEBCAM);
-		break;
-	case V4L2_CID_DV_RX_RGB_RANGE:
-		if (!vivid_is_hdmi_cap(dev))
-			break;
-		tpg_s_rgb_range(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_LIMITED_RGB_RANGE:
-		tpg_s_real_rgb_range(&dev->tpg, ctrl->val ?
-				V4L2_DV_RGB_RANGE_LIMITED : V4L2_DV_RGB_RANGE_FULL);
-		break;
-	case VIVID_CID_ALPHA_MODE:
-		tpg_s_alpha_mode(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_HOR_MOVEMENT:
-		tpg_s_mv_hor_mode(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_VERT_MOVEMENT:
-		tpg_s_mv_vert_mode(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_OSD_TEXT_MODE:
-		dev->osd_mode = ctrl->val;
-		break;
-	case VIVID_CID_PERCENTAGE_FILL:
-		tpg_s_perc_fill(&dev->tpg, ctrl->val);
-		for (i = 0; i < VIDEO_MAX_FRAME; i++)
-			dev->must_blank[i] = ctrl->val < 100;
-		break;
-	case VIVID_CID_INSERT_SAV:
-		tpg_s_insert_sav(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_INSERT_EAV:
-		tpg_s_insert_eav(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_HFLIP:
-		dev->sensor_hflip = ctrl->val;
-		tpg_s_hflip(&dev->tpg, dev->sensor_hflip ^ dev->hflip);
-		break;
-	case VIVID_CID_VFLIP:
-		dev->sensor_vflip = ctrl->val;
-		tpg_s_vflip(&dev->tpg, dev->sensor_vflip ^ dev->vflip);
-		break;
-	case VIVID_CID_REDUCED_FPS:
-		dev->reduced_fps = ctrl->val;
-		vivid_update_format_cap(dev, true);
-		break;
-	case VIVID_CID_HAS_CROP_CAP:
-		dev->has_crop_cap = ctrl->val;
-		vivid_update_format_cap(dev, true);
-		break;
-	case VIVID_CID_HAS_COMPOSE_CAP:
-		dev->has_compose_cap = ctrl->val;
-		vivid_update_format_cap(dev, true);
-		break;
-	case VIVID_CID_HAS_SCALER_CAP:
-		dev->has_scaler_cap = ctrl->val;
-		vivid_update_format_cap(dev, true);
-		break;
-	case VIVID_CID_SHOW_BORDER:
-		tpg_s_show_border(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_SHOW_SQUARE:
-		tpg_s_show_square(&dev->tpg, ctrl->val);
-		break;
-	case VIVID_CID_STD_ASPECT_RATIO:
-		dev->std_aspect_ratio[dev->input] = ctrl->val;
-		tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
-		break;
-	case VIVID_CID_DV_TIMINGS_SIGNAL_MODE:
-		dev->dv_timings_signal_mode[dev->input] =
-			dev->ctrl_dv_timings_signal_mode->val;
-		dev->query_dv_timings[dev->input] = dev->ctrl_dv_timings->val;
-
-		dev->power_present = 0;
-		for (i = 0, j = 0;
-		     i < ARRAY_SIZE(dev->dv_timings_signal_mode);
-		     i++)
-			if (dev->input_type[i] == HDMI) {
-				if (dev->dv_timings_signal_mode[i] != NO_SIGNAL)
-					dev->power_present |= (1 << j);
-				j++;
-			}
-		__v4l2_ctrl_s_ctrl(dev->ctrl_rx_power_present,
-				   dev->power_present);
-
-		v4l2_ctrl_activate(dev->ctrl_dv_timings,
-			dev->dv_timings_signal_mode[dev->input] ==
-				SELECTED_DV_TIMINGS);
-
-		vivid_update_quality(dev);
-		vivid_send_source_change(dev, HDMI);
-		break;
-	case VIVID_CID_DV_TIMINGS_ASPECT_RATIO:
-		dev->dv_timings_aspect_ratio[dev->input] = ctrl->val;
-		tpg_s_video_aspect(&dev->tpg, vivid_get_video_aspect(dev));
-		break;
-	case VIVID_CID_TSTAMP_SRC:
-		dev->tstamp_src_is_soe = ctrl->val;
-		dev->vb_vid_cap_q.timestamp_flags &= ~V4L2_BUF_FLAG_TSTAMP_SRC_MASK;
-		if (dev->tstamp_src_is_soe)
-			dev->vb_vid_cap_q.timestamp_flags |= V4L2_BUF_FLAG_TSTAMP_SRC_SOE;
-		break;
-	case VIVID_CID_MAX_EDID_BLOCKS:
-		dev->edid_max_blocks = ctrl->val;
-		if (dev->edid_blocks > dev->edid_max_blocks)
-			dev->edid_blocks = dev->edid_max_blocks;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_vid_cap_ctrl_ops = {
-	.s_ctrl = vivid_vid_cap_s_ctrl,
-};
-
-static const char * const vivid_ctrl_hor_movement_strings[] = {
-	"Move Left Fast",
-	"Move Left",
-	"Move Left Slow",
-	"No Movement",
-	"Move Right Slow",
-	"Move Right",
-	"Move Right Fast",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_hor_movement = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HOR_MOVEMENT,
-	.name = "Horizontal Movement",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = TPG_MOVE_POS_FAST,
-	.def = TPG_MOVE_NONE,
-	.qmenu = vivid_ctrl_hor_movement_strings,
-};
-
-static const char * const vivid_ctrl_vert_movement_strings[] = {
-	"Move Up Fast",
-	"Move Up",
-	"Move Up Slow",
-	"No Movement",
-	"Move Down Slow",
-	"Move Down",
-	"Move Down Fast",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_vert_movement = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_VERT_MOVEMENT,
-	.name = "Vertical Movement",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = TPG_MOVE_POS_FAST,
-	.def = TPG_MOVE_NONE,
-	.qmenu = vivid_ctrl_vert_movement_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_show_border = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_SHOW_BORDER,
-	.name = "Show Border",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_show_square = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_SHOW_SQUARE,
-	.name = "Show Square",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const char * const vivid_ctrl_osd_mode_strings[] = {
-	"All",
-	"Counters Only",
-	"None",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_osd_mode = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_OSD_TEXT_MODE,
-	.name = "OSD Text Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_osd_mode_strings) - 2,
-	.qmenu = vivid_ctrl_osd_mode_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_perc_fill = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_PERCENTAGE_FILL,
-	.name = "Fill Percentage of Frame",
-	.type = V4L2_CTRL_TYPE_INTEGER,
-	.min = 0,
-	.max = 100,
-	.def = 100,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_insert_sav = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_INSERT_SAV,
-	.name = "Insert SAV Code in Image",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_insert_eav = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_INSERT_EAV,
-	.name = "Insert EAV Code in Image",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_hflip = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HFLIP,
-	.name = "Sensor Flipped Horizontally",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_vflip = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_VFLIP,
-	.name = "Sensor Flipped Vertically",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_reduced_fps = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_REDUCED_FPS,
-	.name = "Reduced Framerate",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_crop_cap = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HAS_CROP_CAP,
-	.name = "Enable Capture Cropping",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_compose_cap = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HAS_COMPOSE_CAP,
-	.name = "Enable Capture Composing",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_cap = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HAS_SCALER_CAP,
-	.name = "Enable Capture Scaler",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const char * const vivid_ctrl_tstamp_src_strings[] = {
-	"End of Frame",
-	"Start of Exposure",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_tstamp_src = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_TSTAMP_SRC,
-	.name = "Timestamp Source",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_tstamp_src_strings) - 2,
-	.qmenu = vivid_ctrl_tstamp_src_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_std_aspect_ratio = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_STD_ASPECT_RATIO,
-	.name = "Standard Aspect Ratio",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.min = 1,
-	.max = 4,
-	.def = 1,
-	.qmenu = tpg_aspect_strings,
-};
-
-static const char * const vivid_ctrl_dv_timings_signal_mode_strings[] = {
-	"Current DV Timings",
-	"No Signal",
-	"No Lock",
-	"Out of Range",
-	"Selected DV Timings",
-	"Cycle Through All DV Timings",
-	"Custom DV Timings",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_signal_mode = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_DV_TIMINGS_SIGNAL_MODE,
-	.name = "DV Timings Signal Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = 5,
-	.qmenu = vivid_ctrl_dv_timings_signal_mode_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_dv_timings_aspect_ratio = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_DV_TIMINGS_ASPECT_RATIO,
-	.name = "DV Timings Aspect Ratio",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = 3,
-	.qmenu = tpg_aspect_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_max_edid_blocks = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_MAX_EDID_BLOCKS,
-	.name = "Maximum EDID Blocks",
-	.type = V4L2_CTRL_TYPE_INTEGER,
-	.min = 1,
-	.max = 256,
-	.def = 2,
-	.step = 1,
-};
-
-static const char * const vivid_ctrl_colorspace_strings[] = {
-	"SMPTE 170M",
-	"Rec. 709",
-	"sRGB",
-	"opRGB",
-	"BT.2020",
-	"DCI-P3",
-	"SMPTE 240M",
-	"470 System M",
-	"470 System BG",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_colorspace = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_COLORSPACE,
-	.name = "Colorspace",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_colorspace_strings) - 2,
-	.def = 2,
-	.qmenu = vivid_ctrl_colorspace_strings,
-};
-
-static const char * const vivid_ctrl_xfer_func_strings[] = {
-	"Default",
-	"Rec. 709",
-	"sRGB",
-	"opRGB",
-	"SMPTE 240M",
-	"None",
-	"DCI-P3",
-	"SMPTE 2084",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_xfer_func = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_XFER_FUNC,
-	.name = "Transfer Function",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_xfer_func_strings) - 2,
-	.qmenu = vivid_ctrl_xfer_func_strings,
-};
-
-static const char * const vivid_ctrl_ycbcr_enc_strings[] = {
-	"Default",
-	"ITU-R 601",
-	"Rec. 709",
-	"xvYCC 601",
-	"xvYCC 709",
-	"",
-	"BT.2020",
-	"BT.2020 Constant Luminance",
-	"SMPTE 240M",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_ycbcr_enc = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_YCBCR_ENC,
-	.name = "Y'CbCr Encoding",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.menu_skip_mask = 1 << 5,
-	.max = ARRAY_SIZE(vivid_ctrl_ycbcr_enc_strings) - 2,
-	.qmenu = vivid_ctrl_ycbcr_enc_strings,
-};
-
-static const char * const vivid_ctrl_hsv_enc_strings[] = {
-	"Hue 0-179",
-	"Hue 0-256",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_hsv_enc = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_HSV_ENC,
-	.name = "HSV Encoding",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_hsv_enc_strings) - 2,
-	.qmenu = vivid_ctrl_hsv_enc_strings,
-};
-
-static const char * const vivid_ctrl_quantization_strings[] = {
-	"Default",
-	"Full Range",
-	"Limited Range",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_quantization = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_QUANTIZATION,
-	.name = "Quantization",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_quantization_strings) - 2,
-	.qmenu = vivid_ctrl_quantization_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_alpha_mode = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_ALPHA_MODE,
-	.name = "Apply Alpha To Red Only",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_limited_rgb_range = {
-	.ops = &vivid_vid_cap_ctrl_ops,
-	.id = VIVID_CID_LIMITED_RGB_RANGE,
-	.name = "Limited RGB Range (16-235)",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-
-/* Video Loop Control */
-
-static int vivid_loop_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_loop_cap);
-
-	switch (ctrl->id) {
-	case VIVID_CID_LOOP_VIDEO:
-		dev->loop_video = ctrl->val;
-		vivid_update_quality(dev);
-		vivid_send_source_change(dev, SVID);
-		vivid_send_source_change(dev, HDMI);
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_loop_cap_ctrl_ops = {
-	.s_ctrl = vivid_loop_cap_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_loop_video = {
-	.ops = &vivid_loop_cap_ctrl_ops,
-	.id = VIVID_CID_LOOP_VIDEO,
-	.name = "Loop Video",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-
-/* VBI Capture Control */
-
-static int vivid_vbi_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vbi_cap);
-
-	switch (ctrl->id) {
-	case VIVID_CID_VBI_CAP_INTERLACED:
-		dev->vbi_cap_interlaced = ctrl->val;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_vbi_cap_ctrl_ops = {
-	.s_ctrl = vivid_vbi_cap_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_vbi_cap_interlaced = {
-	.ops = &vivid_vbi_cap_ctrl_ops,
-	.id = VIVID_CID_VBI_CAP_INTERLACED,
-	.name = "Interlaced VBI Format",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-
-/* Video Output Controls */
-
-static int vivid_vid_out_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_vid_out);
-	struct v4l2_bt_timings *bt = &dev->dv_timings_out.bt;
-	u32 display_present = 0;
-	unsigned int i, j, bus_idx;
-
-	switch (ctrl->id) {
-	case VIVID_CID_HAS_CROP_OUT:
-		dev->has_crop_out = ctrl->val;
-		vivid_update_format_out(dev);
-		break;
-	case VIVID_CID_HAS_COMPOSE_OUT:
-		dev->has_compose_out = ctrl->val;
-		vivid_update_format_out(dev);
-		break;
-	case VIVID_CID_HAS_SCALER_OUT:
-		dev->has_scaler_out = ctrl->val;
-		vivid_update_format_out(dev);
-		break;
-	case V4L2_CID_DV_TX_MODE:
-		dev->dvi_d_out = ctrl->val == V4L2_DV_TX_MODE_DVI_D;
-		if (!vivid_is_hdmi_out(dev))
-			break;
-		if (!dev->dvi_d_out && (bt->flags & V4L2_DV_FL_IS_CE_VIDEO)) {
-			if (bt->width == 720 && bt->height <= 576)
-				dev->colorspace_out = V4L2_COLORSPACE_SMPTE170M;
-			else
-				dev->colorspace_out = V4L2_COLORSPACE_REC709;
-			dev->quantization_out = V4L2_QUANTIZATION_DEFAULT;
-		} else {
-			dev->colorspace_out = V4L2_COLORSPACE_SRGB;
-			dev->quantization_out = dev->dvi_d_out ?
-					V4L2_QUANTIZATION_LIM_RANGE :
-					V4L2_QUANTIZATION_DEFAULT;
-		}
-		if (dev->loop_video)
-			vivid_send_source_change(dev, HDMI);
-		break;
-	case VIVID_CID_DISPLAY_PRESENT:
-		if (dev->output_type[dev->output] != HDMI)
-			break;
-
-		dev->display_present[dev->output] = ctrl->val;
-		for (i = 0, j = 0; i < dev->num_outputs; i++)
-			if (dev->output_type[i] == HDMI)
-				display_present |=
-					dev->display_present[i] << j++;
-
-		__v4l2_ctrl_s_ctrl(dev->ctrl_tx_rxsense, display_present);
-
-		if (dev->edid_blocks) {
-			__v4l2_ctrl_s_ctrl(dev->ctrl_tx_edid_present,
-					   display_present);
-			__v4l2_ctrl_s_ctrl(dev->ctrl_tx_hotplug,
-					   display_present);
-		}
-
-		bus_idx = dev->cec_output2bus_map[dev->output];
-		if (!dev->cec_tx_adap[bus_idx])
-			break;
-
-		if (ctrl->val && dev->edid_blocks)
-			cec_s_phys_addr(dev->cec_tx_adap[bus_idx],
-					dev->cec_tx_adap[bus_idx]->phys_addr,
-					false);
-		else
-			cec_phys_addr_invalidate(dev->cec_tx_adap[bus_idx]);
-
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_vid_out_ctrl_ops = {
-	.s_ctrl = vivid_vid_out_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_crop_out = {
-	.ops = &vivid_vid_out_ctrl_ops,
-	.id = VIVID_CID_HAS_CROP_OUT,
-	.name = "Enable Output Cropping",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_compose_out = {
-	.ops = &vivid_vid_out_ctrl_ops,
-	.id = VIVID_CID_HAS_COMPOSE_OUT,
-	.name = "Enable Output Composing",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_has_scaler_out = {
-	.ops = &vivid_vid_out_ctrl_ops,
-	.id = VIVID_CID_HAS_SCALER_OUT,
-	.name = "Enable Output Scaler",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_display_present = {
-	.ops = &vivid_vid_out_ctrl_ops,
-	.id = VIVID_CID_DISPLAY_PRESENT,
-	.name = "Display Present",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-/* Streaming Controls */
-
-static int vivid_streaming_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_streaming);
-	u64 rem;
-
-	switch (ctrl->id) {
-	case VIVID_CID_DQBUF_ERROR:
-		dev->dqbuf_error = true;
-		break;
-	case VIVID_CID_PERC_DROPPED:
-		dev->perc_dropped_buffers = ctrl->val;
-		break;
-	case VIVID_CID_QUEUE_SETUP_ERROR:
-		dev->queue_setup_error = true;
-		break;
-	case VIVID_CID_BUF_PREPARE_ERROR:
-		dev->buf_prepare_error = true;
-		break;
-	case VIVID_CID_START_STR_ERROR:
-		dev->start_streaming_error = true;
-		break;
-	case VIVID_CID_REQ_VALIDATE_ERROR:
-		dev->req_validate_error = true;
-		break;
-	case VIVID_CID_QUEUE_ERROR:
-		if (vb2_start_streaming_called(&dev->vb_vid_cap_q))
-			vb2_queue_error(&dev->vb_vid_cap_q);
-		if (vb2_start_streaming_called(&dev->vb_vbi_cap_q))
-			vb2_queue_error(&dev->vb_vbi_cap_q);
-		if (vb2_start_streaming_called(&dev->vb_vid_out_q))
-			vb2_queue_error(&dev->vb_vid_out_q);
-		if (vb2_start_streaming_called(&dev->vb_vbi_out_q))
-			vb2_queue_error(&dev->vb_vbi_out_q);
-		if (vb2_start_streaming_called(&dev->vb_sdr_cap_q))
-			vb2_queue_error(&dev->vb_sdr_cap_q);
-		break;
-	case VIVID_CID_SEQ_WRAP:
-		dev->seq_wrap = ctrl->val;
-		break;
-	case VIVID_CID_TIME_WRAP:
-		dev->time_wrap = ctrl->val;
-		if (ctrl->val == 0) {
-			dev->time_wrap_offset = 0;
-			break;
-		}
-		/*
-		 * We want to set the time 16 seconds before the 32 bit tv_sec
-		 * value of struct timeval would wrap around. So first we
-		 * calculate ktime_get_ns() % ((1 << 32) * NSEC_PER_SEC), and
-		 * then we set the offset to ((1 << 32) - 16) * NSEC_PER_SEC).
-		 */
-		div64_u64_rem(ktime_get_ns(),
-			0x100000000ULL * NSEC_PER_SEC, &rem);
-		dev->time_wrap_offset =
-			(0x100000000ULL - 16) * NSEC_PER_SEC - rem;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_streaming_ctrl_ops = {
-	.s_ctrl = vivid_streaming_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_dqbuf_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_DQBUF_ERROR,
-	.name = "Inject V4L2_BUF_FLAG_ERROR",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_perc_dropped = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_PERC_DROPPED,
-	.name = "Percentage of Dropped Buffers",
-	.type = V4L2_CTRL_TYPE_INTEGER,
-	.min = 0,
-	.max = 100,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_queue_setup_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_QUEUE_SETUP_ERROR,
-	.name = "Inject VIDIOC_REQBUFS Error",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_buf_prepare_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_BUF_PREPARE_ERROR,
-	.name = "Inject VIDIOC_QBUF Error",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_start_streaming_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_START_STR_ERROR,
-	.name = "Inject VIDIOC_STREAMON Error",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_queue_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_QUEUE_ERROR,
-	.name = "Inject Fatal Streaming Error",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-
-#ifdef CONFIG_MEDIA_CONTROLLER
-static const struct v4l2_ctrl_config vivid_ctrl_req_validate_error = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_REQ_VALIDATE_ERROR,
-	.name = "Inject req_validate() Error",
-	.type = V4L2_CTRL_TYPE_BUTTON,
-};
-#endif
-
-static const struct v4l2_ctrl_config vivid_ctrl_seq_wrap = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_SEQ_WRAP,
-	.name = "Wrap Sequence Number",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_time_wrap = {
-	.ops = &vivid_streaming_ctrl_ops,
-	.id = VIVID_CID_TIME_WRAP,
-	.name = "Wrap Timestamp",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-
-/* SDTV Capture Controls */
-
-static int vivid_sdtv_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_sdtv_cap);
-
-	switch (ctrl->id) {
-	case VIVID_CID_STD_SIGNAL_MODE:
-		dev->std_signal_mode[dev->input] =
-			dev->ctrl_std_signal_mode->val;
-		if (dev->std_signal_mode[dev->input] == SELECTED_STD)
-			dev->query_std[dev->input] =
-				vivid_standard[dev->ctrl_standard->val];
-		v4l2_ctrl_activate(dev->ctrl_standard,
-				   dev->std_signal_mode[dev->input] ==
-					SELECTED_STD);
-		vivid_update_quality(dev);
-		vivid_send_source_change(dev, TV);
-		vivid_send_source_change(dev, SVID);
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_sdtv_cap_ctrl_ops = {
-	.s_ctrl = vivid_sdtv_cap_s_ctrl,
-};
-
-static const char * const vivid_ctrl_std_signal_mode_strings[] = {
-	"Current Standard",
-	"No Signal",
-	"No Lock",
-	"",
-	"Selected Standard",
-	"Cycle Through All Standards",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_std_signal_mode = {
-	.ops = &vivid_sdtv_cap_ctrl_ops,
-	.id = VIVID_CID_STD_SIGNAL_MODE,
-	.name = "Standard Signal Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = ARRAY_SIZE(vivid_ctrl_std_signal_mode_strings) - 2,
-	.menu_skip_mask = 1 << 3,
-	.qmenu = vivid_ctrl_std_signal_mode_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_standard = {
-	.ops = &vivid_sdtv_cap_ctrl_ops,
-	.id = VIVID_CID_STANDARD,
-	.name = "Standard",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = 14,
-	.qmenu = vivid_ctrl_standard_strings,
-};
-
-
-
-/* Radio Receiver Controls */
-
-static int vivid_radio_rx_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_rx);
-
-	switch (ctrl->id) {
-	case VIVID_CID_RADIO_SEEK_MODE:
-		dev->radio_rx_hw_seek_mode = ctrl->val;
-		break;
-	case VIVID_CID_RADIO_SEEK_PROG_LIM:
-		dev->radio_rx_hw_seek_prog_lim = ctrl->val;
-		break;
-	case VIVID_CID_RADIO_RX_RDS_RBDS:
-		dev->rds_gen.use_rbds = ctrl->val;
-		break;
-	case VIVID_CID_RADIO_RX_RDS_BLOCKIO:
-		dev->radio_rx_rds_controls = ctrl->val;
-		dev->radio_rx_caps &= ~V4L2_CAP_READWRITE;
-		dev->radio_rx_rds_use_alternates = false;
-		if (!dev->radio_rx_rds_controls) {
-			dev->radio_rx_caps |= V4L2_CAP_READWRITE;
-			__v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, 0);
-			__v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, 0);
-			__v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, 0);
-			__v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, 0);
-			__v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, "");
-			__v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, "");
-		}
-		v4l2_ctrl_activate(dev->radio_rx_rds_pty, dev->radio_rx_rds_controls);
-		v4l2_ctrl_activate(dev->radio_rx_rds_psname, dev->radio_rx_rds_controls);
-		v4l2_ctrl_activate(dev->radio_rx_rds_radiotext, dev->radio_rx_rds_controls);
-		v4l2_ctrl_activate(dev->radio_rx_rds_ta, dev->radio_rx_rds_controls);
-		v4l2_ctrl_activate(dev->radio_rx_rds_tp, dev->radio_rx_rds_controls);
-		v4l2_ctrl_activate(dev->radio_rx_rds_ms, dev->radio_rx_rds_controls);
-		dev->radio_rx_dev.device_caps = dev->radio_rx_caps;
-		break;
-	case V4L2_CID_RDS_RECEPTION:
-		dev->radio_rx_rds_enabled = ctrl->val;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_radio_rx_ctrl_ops = {
-	.s_ctrl = vivid_radio_rx_s_ctrl,
-};
-
-static const char * const vivid_ctrl_radio_rds_mode_strings[] = {
-	"Block I/O",
-	"Controls",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_blockio = {
-	.ops = &vivid_radio_rx_ctrl_ops,
-	.id = VIVID_CID_RADIO_RX_RDS_BLOCKIO,
-	.name = "RDS Rx I/O Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.qmenu = vivid_ctrl_radio_rds_mode_strings,
-	.max = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_radio_rx_rds_rbds = {
-	.ops = &vivid_radio_rx_ctrl_ops,
-	.id = VIVID_CID_RADIO_RX_RDS_RBDS,
-	.name = "Generate RBDS Instead of RDS",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-static const char * const vivid_ctrl_radio_hw_seek_mode_strings[] = {
-	"Bounded",
-	"Wrap Around",
-	"Both",
-	NULL,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_mode = {
-	.ops = &vivid_radio_rx_ctrl_ops,
-	.id = VIVID_CID_RADIO_SEEK_MODE,
-	.name = "Radio HW Seek Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.max = 2,
-	.qmenu = vivid_ctrl_radio_hw_seek_mode_strings,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_radio_hw_seek_prog_lim = {
-	.ops = &vivid_radio_rx_ctrl_ops,
-	.id = VIVID_CID_RADIO_SEEK_PROG_LIM,
-	.name = "Radio Programmable HW Seek",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.step = 1,
-};
-
-
-/* Radio Transmitter Controls */
-
-static int vivid_radio_tx_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_radio_tx);
-
-	switch (ctrl->id) {
-	case VIVID_CID_RADIO_TX_RDS_BLOCKIO:
-		dev->radio_tx_rds_controls = ctrl->val;
-		dev->radio_tx_caps &= ~V4L2_CAP_READWRITE;
-		if (!dev->radio_tx_rds_controls)
-			dev->radio_tx_caps |= V4L2_CAP_READWRITE;
-		dev->radio_tx_dev.device_caps = dev->radio_tx_caps;
-		break;
-	case V4L2_CID_RDS_TX_PTY:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl(dev->radio_rx_rds_pty, ctrl->val);
-		break;
-	case V4L2_CID_RDS_TX_PS_NAME:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_psname, ctrl->p_new.p_char);
-		break;
-	case V4L2_CID_RDS_TX_RADIO_TEXT:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl_string(dev->radio_rx_rds_radiotext, ctrl->p_new.p_char);
-		break;
-	case V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ta, ctrl->val);
-		break;
-	case V4L2_CID_RDS_TX_TRAFFIC_PROGRAM:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl(dev->radio_rx_rds_tp, ctrl->val);
-		break;
-	case V4L2_CID_RDS_TX_MUSIC_SPEECH:
-		if (dev->radio_rx_rds_controls)
-			v4l2_ctrl_s_ctrl(dev->radio_rx_rds_ms, ctrl->val);
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_radio_tx_ctrl_ops = {
-	.s_ctrl = vivid_radio_tx_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_radio_tx_rds_blockio = {
-	.ops = &vivid_radio_tx_ctrl_ops,
-	.id = VIVID_CID_RADIO_TX_RDS_BLOCKIO,
-	.name = "RDS Tx I/O Mode",
-	.type = V4L2_CTRL_TYPE_MENU,
-	.qmenu = vivid_ctrl_radio_rds_mode_strings,
-	.max = 1,
-	.def = 1,
-};
-
-
-/* SDR Capture Controls */
-
-static int vivid_sdr_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev, ctrl_hdl_sdr_cap);
-
-	switch (ctrl->id) {
-	case VIVID_CID_SDR_CAP_FM_DEVIATION:
-		dev->sdr_fm_deviation = ctrl->val;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_sdr_cap_ctrl_ops = {
-	.s_ctrl = vivid_sdr_cap_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_sdr_cap_fm_deviation = {
-	.ops = &vivid_sdr_cap_ctrl_ops,
-	.id = VIVID_CID_SDR_CAP_FM_DEVIATION,
-	.name = "FM Deviation",
-	.type = V4L2_CTRL_TYPE_INTEGER,
-	.min =    100,
-	.max = 200000,
-	.def =  75000,
-	.step =     1,
-};
-
-/* Metadata Capture Control */
-
-static int vivid_meta_cap_s_ctrl(struct v4l2_ctrl *ctrl)
-{
-	struct vivid_dev *dev = container_of(ctrl->handler, struct vivid_dev,
-					     ctrl_hdl_meta_cap);
-
-	switch (ctrl->id) {
-	case VIVID_CID_META_CAP_GENERATE_PTS:
-		dev->meta_pts = ctrl->val;
-		break;
-	case VIVID_CID_META_CAP_GENERATE_SCR:
-		dev->meta_scr = ctrl->val;
-		break;
-	}
-	return 0;
-}
-
-static const struct v4l2_ctrl_ops vivid_meta_cap_ctrl_ops = {
-	.s_ctrl = vivid_meta_cap_s_ctrl,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_meta_has_pts = {
-	.ops = &vivid_meta_cap_ctrl_ops,
-	.id = VIVID_CID_META_CAP_GENERATE_PTS,
-	.name = "Generate PTS",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_meta_has_src_clk = {
-	.ops = &vivid_meta_cap_ctrl_ops,
-	.id = VIVID_CID_META_CAP_GENERATE_SCR,
-	.name = "Generate SCR",
-	.type = V4L2_CTRL_TYPE_BOOLEAN,
-	.max = 1,
-	.def = 1,
-	.step = 1,
-};
-
-static const struct v4l2_ctrl_config vivid_ctrl_class = {
-	.ops = &vivid_user_gen_ctrl_ops,
-	.flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY,
-	.id = VIVID_CID_VIVID_CLASS,
-	.name = "Vivid Controls",
-	.type = V4L2_CTRL_TYPE_CTRL_CLASS,
-};
-
-int vivid_create_controls(struct vivid_dev *dev, bool show_ccs_cap,
-		bool show_ccs_out, bool no_error_inj,
-		bool has_sdtv, bool has_hdmi)
-{
-	struct v4l2_ctrl_handler *hdl_user_gen = &dev->ctrl_hdl_user_gen;
-	struct v4l2_ctrl_handler *hdl_user_vid = &dev->ctrl_hdl_user_vid;
-	struct v4l2_ctrl_handler *hdl_user_aud = &dev->ctrl_hdl_user_aud;
-	struct v4l2_ctrl_handler *hdl_streaming = &dev->ctrl_hdl_streaming;
-	struct v4l2_ctrl_handler *hdl_sdtv_cap = &dev->ctrl_hdl_sdtv_cap;
-	struct v4l2_ctrl_handler *hdl_loop_cap = &dev->ctrl_hdl_loop_cap;
-	struct v4l2_ctrl_handler *hdl_fb = &dev->ctrl_hdl_fb;
-	struct v4l2_ctrl_handler *hdl_vid_cap = &dev->ctrl_hdl_vid_cap;
-	struct v4l2_ctrl_handler *hdl_vid_out = &dev->ctrl_hdl_vid_out;
-	struct v4l2_ctrl_handler *hdl_vbi_cap = &dev->ctrl_hdl_vbi_cap;
-	struct v4l2_ctrl_handler *hdl_vbi_out = &dev->ctrl_hdl_vbi_out;
-	struct v4l2_ctrl_handler *hdl_radio_rx = &dev->ctrl_hdl_radio_rx;
-	struct v4l2_ctrl_handler *hdl_radio_tx = &dev->ctrl_hdl_radio_tx;
-	struct v4l2_ctrl_handler *hdl_sdr_cap = &dev->ctrl_hdl_sdr_cap;
-	struct v4l2_ctrl_handler *hdl_meta_cap = &dev->ctrl_hdl_meta_cap;
-	struct v4l2_ctrl_handler *hdl_meta_out = &dev->ctrl_hdl_meta_out;
-	struct v4l2_ctrl_handler *hdl_tch_cap = &dev->ctrl_hdl_touch_cap;
-
-	struct v4l2_ctrl_config vivid_ctrl_dv_timings = {
-		.ops = &vivid_vid_cap_ctrl_ops,
-		.id = VIVID_CID_DV_TIMINGS,
-		.name = "DV Timings",
-		.type = V4L2_CTRL_TYPE_MENU,
-	};
-	int i;
-
-	v4l2_ctrl_handler_init(hdl_user_gen, 10);
-	v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_user_vid, 9);
-	v4l2_ctrl_new_custom(hdl_user_vid, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_user_aud, 2);
-	v4l2_ctrl_new_custom(hdl_user_aud, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_streaming, 8);
-	v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_sdtv_cap, 2);
-	v4l2_ctrl_new_custom(hdl_sdtv_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_loop_cap, 1);
-	v4l2_ctrl_new_custom(hdl_loop_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_fb, 1);
-	v4l2_ctrl_new_custom(hdl_fb, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_vid_cap, 55);
-	v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_vid_out, 26);
-	if (!no_error_inj || dev->has_fb || dev->num_hdmi_outputs)
-		v4l2_ctrl_new_custom(hdl_vid_out, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_vbi_cap, 21);
-	v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_vbi_out, 19);
-	if (!no_error_inj)
-		v4l2_ctrl_new_custom(hdl_vbi_out, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_radio_rx, 17);
-	v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_radio_tx, 17);
-	v4l2_ctrl_new_custom(hdl_radio_tx, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_sdr_cap, 19);
-	v4l2_ctrl_new_custom(hdl_sdr_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_meta_cap, 2);
-	v4l2_ctrl_new_custom(hdl_meta_cap, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_meta_out, 2);
-	v4l2_ctrl_new_custom(hdl_meta_out, &vivid_ctrl_class, NULL);
-	v4l2_ctrl_handler_init(hdl_tch_cap, 2);
-	v4l2_ctrl_new_custom(hdl_tch_cap, &vivid_ctrl_class, NULL);
-
-	/* User Controls */
-	dev->volume = v4l2_ctrl_new_std(hdl_user_aud, NULL,
-		V4L2_CID_AUDIO_VOLUME, 0, 255, 1, 200);
-	dev->mute = v4l2_ctrl_new_std(hdl_user_aud, NULL,
-		V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);
-	if (dev->has_vid_cap) {
-		dev->brightness = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
-		for (i = 0; i < MAX_INPUTS; i++)
-			dev->input_brightness[i] = 128;
-		dev->contrast = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_CONTRAST, 0, 255, 1, 128);
-		dev->saturation = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_SATURATION, 0, 255, 1, 128);
-		dev->hue = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_HUE, -128, 128, 1, 0);
-		v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_HFLIP, 0, 1, 1, 0);
-		v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_VFLIP, 0, 1, 1, 0);
-		dev->autogain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
-		dev->gain = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_GAIN, 0, 255, 1, 100);
-		dev->alpha = v4l2_ctrl_new_std(hdl_user_vid, &vivid_user_vid_ctrl_ops,
-			V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);
-	}
-	dev->button = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_button, NULL);
-	dev->int32 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int32, NULL);
-	dev->int64 = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int64, NULL);
-	dev->boolean = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_boolean, NULL);
-	dev->menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_menu, NULL);
-	dev->string = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_string, NULL);
-	dev->bitmask = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_bitmask, NULL);
-	dev->int_menu = v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_int_menu, NULL);
-	v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_area, NULL);
-	v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u32_array, NULL);
-	v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u16_matrix, NULL);
-	v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_u8_4d_array, NULL);
-
-	if (dev->has_vid_cap) {
-		/* Image Processing Controls */
-		struct v4l2_ctrl_config vivid_ctrl_test_pattern = {
-			.ops = &vivid_vid_cap_ctrl_ops,
-			.id = VIVID_CID_TEST_PATTERN,
-			.name = "Test Pattern",
-			.type = V4L2_CTRL_TYPE_MENU,
-			.max = TPG_PAT_NOISE,
-			.qmenu = tpg_pattern_strings,
-		};
-
-		dev->test_pattern = v4l2_ctrl_new_custom(hdl_vid_cap,
-				&vivid_ctrl_test_pattern, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_perc_fill, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hor_movement, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vert_movement, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_osd_mode, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_border, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_show_square, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hflip, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_vflip, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_sav, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_insert_eav, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_reduced_fps, NULL);
-		if (show_ccs_cap) {
-			dev->ctrl_has_crop_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
-				&vivid_ctrl_has_crop_cap, NULL);
-			dev->ctrl_has_compose_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
-				&vivid_ctrl_has_compose_cap, NULL);
-			dev->ctrl_has_scaler_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
-				&vivid_ctrl_has_scaler_cap, NULL);
-		}
-
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_tstamp_src, NULL);
-		dev->colorspace = v4l2_ctrl_new_custom(hdl_vid_cap,
-			&vivid_ctrl_colorspace, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_xfer_func, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_ycbcr_enc, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_hsv_enc, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_quantization, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_alpha_mode, NULL);
-	}
-
-	if (dev->has_vid_out && show_ccs_out) {
-		dev->ctrl_has_crop_out = v4l2_ctrl_new_custom(hdl_vid_out,
-			&vivid_ctrl_has_crop_out, NULL);
-		dev->ctrl_has_compose_out = v4l2_ctrl_new_custom(hdl_vid_out,
-			&vivid_ctrl_has_compose_out, NULL);
-		dev->ctrl_has_scaler_out = v4l2_ctrl_new_custom(hdl_vid_out,
-			&vivid_ctrl_has_scaler_out, NULL);
-	}
-
-	/*
-	 * Testing this driver with v4l2-compliance will trigger the error
-	 * injection controls, and after that nothing will work as expected.
-	 * So we have a module option to drop these error injecting controls
-	 * allowing us to run v4l2_compliance again.
-	 */
-	if (!no_error_inj) {
-		v4l2_ctrl_new_custom(hdl_user_gen, &vivid_ctrl_disconnect, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_dqbuf_error, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_perc_dropped, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_setup_error, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_buf_prepare_error, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_start_streaming_error, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_queue_error, NULL);
-#ifdef CONFIG_MEDIA_CONTROLLER
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_req_validate_error, NULL);
-#endif
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_seq_wrap, NULL);
-		v4l2_ctrl_new_custom(hdl_streaming, &vivid_ctrl_time_wrap, NULL);
-	}
-
-	if (has_sdtv && (dev->has_vid_cap || dev->has_vbi_cap)) {
-		if (dev->has_vid_cap)
-			v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_std_aspect_ratio, NULL);
-		dev->ctrl_std_signal_mode = v4l2_ctrl_new_custom(hdl_sdtv_cap,
-			&vivid_ctrl_std_signal_mode, NULL);
-		dev->ctrl_standard = v4l2_ctrl_new_custom(hdl_sdtv_cap,
-			&vivid_ctrl_standard, NULL);
-		if (dev->ctrl_std_signal_mode)
-			v4l2_ctrl_cluster(2, &dev->ctrl_std_signal_mode);
-		if (dev->has_raw_vbi_cap)
-			v4l2_ctrl_new_custom(hdl_vbi_cap, &vivid_ctrl_vbi_cap_interlaced, NULL);
-	}
-
-	if (dev->num_hdmi_inputs) {
-		s64 hdmi_input_mask = GENMASK(dev->num_hdmi_inputs - 1, 0);
-
-		dev->ctrl_dv_timings_signal_mode = v4l2_ctrl_new_custom(hdl_vid_cap,
-					&vivid_ctrl_dv_timings_signal_mode, NULL);
-
-		vivid_ctrl_dv_timings.max = dev->query_dv_timings_size - 1;
-		vivid_ctrl_dv_timings.qmenu =
-			(const char * const *)dev->query_dv_timings_qmenu;
-		dev->ctrl_dv_timings = v4l2_ctrl_new_custom(hdl_vid_cap,
-			&vivid_ctrl_dv_timings, NULL);
-		if (dev->ctrl_dv_timings_signal_mode)
-			v4l2_ctrl_cluster(2, &dev->ctrl_dv_timings_signal_mode);
-
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_dv_timings_aspect_ratio, NULL);
-		v4l2_ctrl_new_custom(hdl_vid_cap, &vivid_ctrl_max_edid_blocks, NULL);
-		dev->real_rgb_range_cap = v4l2_ctrl_new_custom(hdl_vid_cap,
-			&vivid_ctrl_limited_rgb_range, NULL);
-		dev->rgb_range_cap = v4l2_ctrl_new_std_menu(hdl_vid_cap,
-			&vivid_vid_cap_ctrl_ops,
-			V4L2_CID_DV_RX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
-			0, V4L2_DV_RGB_RANGE_AUTO);
-		dev->ctrl_rx_power_present = v4l2_ctrl_new_std(hdl_vid_cap,
-			NULL, V4L2_CID_DV_RX_POWER_PRESENT, 0, hdmi_input_mask,
-			0, hdmi_input_mask);
-
-	}
-	if (dev->num_hdmi_outputs) {
-		s64 hdmi_output_mask = GENMASK(dev->num_hdmi_outputs - 1, 0);
-
-		/*
-		 * We aren't doing anything with this at the moment, but
-		 * HDMI outputs typically have this controls.
-		 */
-		dev->ctrl_tx_rgb_range = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
-			V4L2_CID_DV_TX_RGB_RANGE, V4L2_DV_RGB_RANGE_FULL,
-			0, V4L2_DV_RGB_RANGE_AUTO);
-		dev->ctrl_tx_mode = v4l2_ctrl_new_std_menu(hdl_vid_out, NULL,
-			V4L2_CID_DV_TX_MODE, V4L2_DV_TX_MODE_HDMI,
-			0, V4L2_DV_TX_MODE_HDMI);
-		dev->ctrl_display_present = v4l2_ctrl_new_custom(hdl_vid_out,
-			&vivid_ctrl_display_present, NULL);
-		dev->ctrl_tx_hotplug = v4l2_ctrl_new_std(hdl_vid_out,
-			NULL, V4L2_CID_DV_TX_HOTPLUG, 0, hdmi_output_mask,
-			0, hdmi_output_mask);
-		dev->ctrl_tx_rxsense = v4l2_ctrl_new_std(hdl_vid_out,
-			NULL, V4L2_CID_DV_TX_RXSENSE, 0, hdmi_output_mask,
-			0, hdmi_output_mask);
-		dev->ctrl_tx_edid_present = v4l2_ctrl_new_std(hdl_vid_out,
-			NULL, V4L2_CID_DV_TX_EDID_PRESENT, 0, hdmi_output_mask,
-			0, hdmi_output_mask);
-	}
-	if ((dev->has_vid_cap && dev->has_vid_out) ||
-	    (dev->has_vbi_cap && dev->has_vbi_out))
-		v4l2_ctrl_new_custom(hdl_loop_cap, &vivid_ctrl_loop_video, NULL);
-
-	if (dev->has_fb)
-		v4l2_ctrl_new_custom(hdl_fb, &vivid_ctrl_clear_fb, NULL);
-
-	if (dev->has_radio_rx) {
-		v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_mode, NULL);
-		v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_hw_seek_prog_lim, NULL);
-		v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_blockio, NULL);
-		v4l2_ctrl_new_custom(hdl_radio_rx, &vivid_ctrl_radio_rx_rds_rbds, NULL);
-		v4l2_ctrl_new_std(hdl_radio_rx, &vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RECEPTION, 0, 1, 1, 1);
-		dev->radio_rx_rds_pty = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_PTY, 0, 31, 1, 0);
-		dev->radio_rx_rds_psname = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_PS_NAME, 0, 8, 8, 0);
-		dev->radio_rx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_RADIO_TEXT, 0, 64, 64, 0);
-		dev->radio_rx_rds_ta = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
-		dev->radio_rx_rds_tp = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
-		dev->radio_rx_rds_ms = v4l2_ctrl_new_std(hdl_radio_rx,
-			&vivid_radio_rx_ctrl_ops,
-			V4L2_CID_RDS_RX_MUSIC_SPEECH, 0, 1, 1, 1);
-	}
-	if (dev->has_radio_tx) {
-		v4l2_ctrl_new_custom(hdl_radio_tx,
-			&vivid_ctrl_radio_tx_rds_blockio, NULL);
-		dev->radio_tx_rds_pi = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, 0x8088);
-		dev->radio_tx_rds_pty = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_PTY, 0, 31, 1, 3);
-		dev->radio_tx_rds_psname = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_PS_NAME, 0, 8, 8, 0);
-		if (dev->radio_tx_rds_psname)
-			v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_psname, "VIVID-TX");
-		dev->radio_tx_rds_radiotext = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_RADIO_TEXT, 0, 64 * 2, 64, 0);
-		if (dev->radio_tx_rds_radiotext)
-			v4l2_ctrl_s_ctrl_string(dev->radio_tx_rds_radiotext,
-			       "This is a VIVID default Radio Text template text, change at will");
-		dev->radio_tx_rds_mono_stereo = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
-		dev->radio_tx_rds_art_head = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
-		dev->radio_tx_rds_compressed = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
-		dev->radio_tx_rds_dyn_pty = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
-		dev->radio_tx_rds_ta = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
-		dev->radio_tx_rds_tp = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 1);
-		dev->radio_tx_rds_ms = v4l2_ctrl_new_std(hdl_radio_tx,
-			&vivid_radio_tx_ctrl_ops,
-			V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
-	}
-	if (dev->has_sdr_cap) {
-		v4l2_ctrl_new_custom(hdl_sdr_cap,
-			&vivid_ctrl_sdr_cap_fm_deviation, NULL);
-	}
-	if (dev->has_meta_cap) {
-		v4l2_ctrl_new_custom(hdl_meta_cap,
-				     &vivid_ctrl_meta_has_pts, NULL);
-		v4l2_ctrl_new_custom(hdl_meta_cap,
-				     &vivid_ctrl_meta_has_src_clk, NULL);
-	}
-
-	if (hdl_user_gen->error)
-		return hdl_user_gen->error;
-	if (hdl_user_vid->error)
-		return hdl_user_vid->error;
-	if (hdl_user_aud->error)
-		return hdl_user_aud->error;
-	if (hdl_streaming->error)
-		return hdl_streaming->error;
-	if (hdl_sdr_cap->error)
-		return hdl_sdr_cap->error;
-	if (hdl_loop_cap->error)
-		return hdl_loop_cap->error;
-
-	if (dev->autogain)
-		v4l2_ctrl_auto_cluster(2, &dev->autogain, 0, true);
-
-	if (dev->has_vid_cap) {
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_vid, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_aud, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_streaming, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_sdtv_cap, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_loop_cap, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_cap, hdl_fb, NULL, false);
-		if (hdl_vid_cap->error)
-			return hdl_vid_cap->error;
-		dev->vid_cap_dev.ctrl_handler = hdl_vid_cap;
-	}
-	if (dev->has_vid_out) {
-		v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_aud, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_out, hdl_streaming, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vid_out, hdl_fb, NULL, false);
-		if (hdl_vid_out->error)
-			return hdl_vid_out->error;
-		dev->vid_out_dev.ctrl_handler = hdl_vid_out;
-	}
-	if (dev->has_vbi_cap) {
-		v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_streaming, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_sdtv_cap, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_loop_cap, NULL, false);
-		if (hdl_vbi_cap->error)
-			return hdl_vbi_cap->error;
-		dev->vbi_cap_dev.ctrl_handler = hdl_vbi_cap;
-	}
-	if (dev->has_vbi_out) {
-		v4l2_ctrl_add_handler(hdl_vbi_out, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_vbi_out, hdl_streaming, NULL, false);
-		if (hdl_vbi_out->error)
-			return hdl_vbi_out->error;
-		dev->vbi_out_dev.ctrl_handler = hdl_vbi_out;
-	}
-	if (dev->has_radio_rx) {
-		v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_aud, NULL, false);
-		if (hdl_radio_rx->error)
-			return hdl_radio_rx->error;
-		dev->radio_rx_dev.ctrl_handler = hdl_radio_rx;
-	}
-	if (dev->has_radio_tx) {
-		v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_aud, NULL, false);
-		if (hdl_radio_tx->error)
-			return hdl_radio_tx->error;
-		dev->radio_tx_dev.ctrl_handler = hdl_radio_tx;
-	}
-	if (dev->has_sdr_cap) {
-		v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_streaming, NULL, false);
-		if (hdl_sdr_cap->error)
-			return hdl_sdr_cap->error;
-		dev->sdr_cap_dev.ctrl_handler = hdl_sdr_cap;
-	}
-	if (dev->has_meta_cap) {
-		v4l2_ctrl_add_handler(hdl_meta_cap, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_meta_cap, hdl_streaming, NULL, false);
-		if (hdl_meta_cap->error)
-			return hdl_meta_cap->error;
-		dev->meta_cap_dev.ctrl_handler = hdl_meta_cap;
-	}
-	if (dev->has_meta_out) {
-		v4l2_ctrl_add_handler(hdl_meta_out, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_meta_out, hdl_streaming, NULL, false);
-		if (hdl_meta_out->error)
-			return hdl_meta_out->error;
-		dev->meta_out_dev.ctrl_handler = hdl_meta_out;
-	}
-	if (dev->has_touch_cap) {
-		v4l2_ctrl_add_handler(hdl_tch_cap, hdl_user_gen, NULL, false);
-		v4l2_ctrl_add_handler(hdl_tch_cap, hdl_streaming, NULL, false);
-		if (hdl_tch_cap->error)
-			return hdl_tch_cap->error;
-		dev->touch_cap_dev.ctrl_handler = hdl_tch_cap;
-	}
-	return 0;
-}
-
-void vivid_free_controls(struct vivid_dev *dev)
-{
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_vid_out);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_vbi_out);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_rx);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_radio_tx);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdr_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_gen);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_vid);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_user_aud);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_streaming);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_sdtv_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_loop_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_fb);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_meta_cap);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_meta_out);
-	v4l2_ctrl_handler_free(&dev->ctrl_hdl_touch_cap);
-}