自学教程：C++ v4l2_ctrl_handler_init函数代码示例

int gsc_ctrls_create(struct gsc_ctx *ctx){	if (ctx->ctrls_rdy) {		pr_err("Control handler of this context was created already");		return 0;	}	v4l2_ctrl_handler_init(&ctx->ctrl_handler, GSC_MAX_CTRL_NUM);	ctx->gsc_ctrls.rotate = v4l2_ctrl_new_std(&ctx->ctrl_handler,				&gsc_ctrl_ops, V4L2_CID_ROTATE, 0, 270, 90, 0);	ctx->gsc_ctrls.hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,				&gsc_ctrl_ops, V4L2_CID_HFLIP, 0, 1, 1, 0);	ctx->gsc_ctrls.vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,				&gsc_ctrl_ops, V4L2_CID_VFLIP, 0, 1, 1, 0);	ctx->gsc_ctrls.global_alpha = v4l2_ctrl_new_std(&ctx->ctrl_handler,			&gsc_ctrl_ops, V4L2_CID_ALPHA_COMPONENT, 0, 255, 1, 0);	ctx->ctrls_rdy = ctx->ctrl_handler.error == 0;	if (ctx->ctrl_handler.error) {		int err = ctx->ctrl_handler.error;		v4l2_ctrl_handler_free(&ctx->ctrl_handler);		pr_err("Failed to create G-Scaler control handlers");		return err;	}	return 0;}

static int adv748x_afe_init_controls(struct adv748x_afe *afe){	struct adv748x_state *state = adv748x_afe_to_state(afe);	v4l2_ctrl_handler_init(&afe->ctrl_hdl, 5);	/* Use our mutex for the controls */	afe->ctrl_hdl.lock = &state->mutex;	v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,			  V4L2_CID_BRIGHTNESS, ADV748X_SDP_BRI_MIN,			  ADV748X_SDP_BRI_MAX, 1, ADV748X_SDP_BRI_DEF);	v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,			  V4L2_CID_CONTRAST, ADV748X_SDP_CON_MIN,			  ADV748X_SDP_CON_MAX, 1, ADV748X_SDP_CON_DEF);	v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,			  V4L2_CID_SATURATION, ADV748X_SDP_SAT_MIN,			  ADV748X_SDP_SAT_MAX, 1, ADV748X_SDP_SAT_DEF);	v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,			  V4L2_CID_HUE, ADV748X_SDP_HUE_MIN,			  ADV748X_SDP_HUE_MAX, 1, ADV748X_SDP_HUE_DEF);	v4l2_ctrl_new_std_menu_items(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,				     V4L2_CID_TEST_PATTERN,				     ARRAY_SIZE(afe_ctrl_frp_menu) - 1,				     0, 0, afe_ctrl_frp_menu);	afe->sd.ctrl_handler = &afe->ctrl_hdl;	if (afe->ctrl_hdl.error) {		v4l2_ctrl_handler_free(&afe->ctrl_hdl);		return afe->ctrl_hdl.error;	}	return v4l2_ctrl_handler_setup(&afe->ctrl_hdl);}

static int init_fim_controls(struct imx_media_fim *fim){	struct v4l2_ctrl_handler *hdlr = &fim->ctrl_handler;	int i, ret;	v4l2_ctrl_handler_init(hdlr, FIM_NUM_CONTROLS + FIM_NUM_ICAP_CONTROLS);	for (i = 0; i < FIM_NUM_CONTROLS; i++)		fim->ctrl[i] = v4l2_ctrl_new_custom(hdlr,						    &fim_ctrl[i],						    NULL);	for (i = 0; i < FIM_NUM_ICAP_CONTROLS; i++)		fim->icap_ctrl[i] = v4l2_ctrl_new_custom(hdlr,							 &fim_icap_ctrl[i],							 NULL);	if (hdlr->error) {		ret = hdlr->error;		goto err_free;	}	v4l2_ctrl_cluster(FIM_NUM_CONTROLS, fim->ctrl);	v4l2_ctrl_cluster(FIM_NUM_ICAP_CONTROLS, fim->icap_ctrl);	return 0;err_free:	v4l2_ctrl_handler_free(hdlr);	return ret;}

static int adv7180_init_controls(struct adv7180_state *state){	v4l2_ctrl_handler_init(&state->ctrl_hdl, 4);	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,			  V4L2_CID_BRIGHTNESS, ADV7180_BRI_MIN,			  ADV7180_BRI_MAX, 1, ADV7180_BRI_DEF);	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,			  V4L2_CID_CONTRAST, ADV7180_CON_MIN,			  ADV7180_CON_MAX, 1, ADV7180_CON_DEF);	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,			  V4L2_CID_SATURATION, ADV7180_SAT_MIN,			  ADV7180_SAT_MAX, 1, ADV7180_SAT_DEF);	v4l2_ctrl_new_std(&state->ctrl_hdl, &adv7180_ctrl_ops,			  V4L2_CID_HUE, ADV7180_HUE_MIN,			  ADV7180_HUE_MAX, 1, ADV7180_HUE_DEF);	v4l2_ctrl_new_custom(&state->ctrl_hdl, &adv7180_ctrl_fast_switch, NULL);	state->sd.ctrl_handler = &state->ctrl_hdl;	if (state->ctrl_hdl.error) {		int err = state->ctrl_hdl.error;		v4l2_ctrl_handler_free(&state->ctrl_hdl);		return err;	}	v4l2_ctrl_handler_setup(&state->ctrl_hdl);	return 0;}

static int vdic_init_controls(struct vdic_priv *priv){	struct v4l2_ctrl_handler *hdlr = &priv->ctrl_hdlr;	int ret;	v4l2_ctrl_handler_init(hdlr, 1);	v4l2_ctrl_new_std_menu_items(hdlr, &vdic_ctrl_ops,				     V4L2_CID_DEINTERLACING_MODE,				     HIGH_MOTION, 0, HIGH_MOTION,				     vdic_ctrl_motion_menu);	priv->sd.ctrl_handler = hdlr;	if (hdlr->error) {		ret = hdlr->error;		goto out_free;	}	v4l2_ctrl_handler_setup(hdlr);	return 0;out_free:	v4l2_ctrl_handler_free(hdlr);	return ret;}

int ov7660_init_controls(struct sd *sd){	struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;	sd->gspca_dev.vdev.ctrl_handler = hdl;	v4l2_ctrl_handler_init(hdl, 6);	v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,			  0, 1, 1, 1);	v4l2_ctrl_new_std_menu(hdl, &ov7660_ctrl_ops,			  V4L2_CID_EXPOSURE_AUTO, 1, 0, V4L2_EXPOSURE_AUTO);	sd->autogain = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops,					 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);	sd->gain = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_GAIN, 0,				     255, 1, OV7660_DEFAULT_GAIN);	sd->hflip = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_HFLIP,				      0, 1, 1, 0);	sd->vflip = v4l2_ctrl_new_std(hdl, &ov7660_ctrl_ops, V4L2_CID_VFLIP,				      0, 1, 1, 0);	if (hdl->error) {		pr_err("Could not initialize controls/n");		return hdl->error;	}	v4l2_ctrl_auto_cluster(2, &sd->autogain, 0, false);	v4l2_ctrl_cluster(2, &sd->hflip);	return 0;}

int ivtv_gpio_init(struct ivtv *itv){	u16 pin = 0;	if (itv->card->xceive_pin)		pin = 1 << itv->card->xceive_pin;	if ((itv->card->gpio_init.direction | pin) == 0)		return 0;	IVTV_DEBUG_INFO("GPIO initial dir: %08x out: %08x/n",		   read_reg(IVTV_REG_GPIO_DIR), read_reg(IVTV_REG_GPIO_OUT));	/* init output data then direction */	write_reg(itv->card->gpio_init.initial_value | pin, IVTV_REG_GPIO_OUT);	write_reg(itv->card->gpio_init.direction | pin, IVTV_REG_GPIO_DIR);	v4l2_subdev_init(&itv->sd_gpio, &subdev_ops);	snprintf(itv->sd_gpio.name, sizeof(itv->sd_gpio.name), "%s-gpio", itv->v4l2_dev.name);	itv->sd_gpio.grp_id = IVTV_HW_GPIO;	v4l2_ctrl_handler_init(&itv->hdl_gpio, 1);	v4l2_ctrl_new_std(&itv->hdl_gpio, &gpio_ctrl_ops,			V4L2_CID_AUDIO_MUTE, 0, 1, 1, 0);	if (itv->hdl_gpio.error)		return itv->hdl_gpio.error;	itv->sd_gpio.ctrl_handler = &itv->hdl_gpio;	v4l2_ctrl_handler_setup(&itv->hdl_gpio);	return v4l2_device_register_subdev(&itv->v4l2_dev, &itv->sd_gpio);}

static int g2d_setup_ctrls(struct g2d_ctx *ctx){	struct g2d_dev *dev = ctx->dev;	v4l2_ctrl_handler_init(&ctx->ctrl_handler, 3);	ctx->ctrl_hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler, &g2d_ctrl_ops,						V4L2_CID_HFLIP, 0, 1, 1, 0);	ctx->ctrl_vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler, &g2d_ctrl_ops,						V4L2_CID_VFLIP, 0, 1, 1, 0);	v4l2_ctrl_new_std_menu(		&ctx->ctrl_handler,		&g2d_ctrl_ops,		V4L2_CID_COLORFX,		V4L2_COLORFX_NEGATIVE,		~((1 << V4L2_COLORFX_NONE) | (1 << V4L2_COLORFX_NEGATIVE)),		V4L2_COLORFX_NONE);	if (ctx->ctrl_handler.error) {		int err = ctx->ctrl_handler.error;		v4l2_err(&dev->v4l2_dev, "g2d_setup_ctrls failed/n");		v4l2_ctrl_handler_free(&ctx->ctrl_handler);		return err;	}	v4l2_ctrl_cluster(2, &ctx->ctrl_hflip);	return 0;}

int s5k83a_init_controls(struct sd *sd){	struct v4l2_ctrl_handler *hdl = &sd->gspca_dev.ctrl_handler;	sd->gspca_dev.vdev.ctrl_handler = hdl;	v4l2_ctrl_handler_init(hdl, 6);	v4l2_ctrl_new_std(hdl, &s5k83a_ctrl_ops, V4L2_CID_BRIGHTNESS,			  0, 255, 1, S5K83A_DEFAULT_BRIGHTNESS);	v4l2_ctrl_new_std(hdl, &s5k83a_ctrl_ops, V4L2_CID_EXPOSURE,			  0, S5K83A_MAXIMUM_EXPOSURE, 1,			  S5K83A_DEFAULT_EXPOSURE);	v4l2_ctrl_new_std(hdl, &s5k83a_ctrl_ops, V4L2_CID_GAIN,			  0, 255, 1, S5K83A_DEFAULT_GAIN);	sd->hflip = v4l2_ctrl_new_std(hdl, &s5k83a_ctrl_ops, V4L2_CID_HFLIP,				      0, 1, 1, 0);	sd->vflip = v4l2_ctrl_new_std(hdl, &s5k83a_ctrl_ops, V4L2_CID_VFLIP,				      0, 1, 1, 0);	if (hdl->error) {		pr_err("Could not initialize controls/n");		return hdl->error;	}	v4l2_ctrl_cluster(2, &sd->hflip);	return 0;}

static int imx7_csi_link_setup(struct media_entity *entity,			       const struct media_pad *local,			       const struct media_pad *remote, u32 flags){	struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);	struct imx7_csi *csi = v4l2_get_subdevdata(sd);	struct v4l2_subdev *remote_sd;	int ret = 0;	dev_dbg(csi->dev, "link setup %s -> %s/n", remote->entity->name,		local->entity->name);	mutex_lock(&csi->lock);	if (local->flags & MEDIA_PAD_FL_SINK) {		if (!is_media_entity_v4l2_subdev(remote->entity)) {			ret = -EINVAL;			goto unlock;		}		remote_sd = media_entity_to_v4l2_subdev(remote->entity);		if (flags & MEDIA_LNK_FL_ENABLED) {			if (csi->src_sd) {				ret = -EBUSY;				goto unlock;			}			csi->src_sd = remote_sd;		} else {			csi->src_sd = NULL;		}		goto init;	}	/* source pad */	if (flags & MEDIA_LNK_FL_ENABLED) {		if (csi->sink) {			ret = -EBUSY;			goto unlock;		}		csi->sink = remote->entity;	} else {		v4l2_ctrl_handler_free(&csi->ctrl_hdlr);		v4l2_ctrl_handler_init(&csi->ctrl_hdlr, 0);		csi->sink = NULL;	}init:	if (csi->sink || csi->src_sd)		ret = imx7_csi_init(csi);	else		imx7_csi_deinit(csi);unlock:	mutex_unlock(&csi->lock);	return ret;}

static int lm3560_init_controls(struct lm3560_flash *flash,				enum lm3560_led_id led_no){	struct v4l2_ctrl *fault;	u32 max_flash_brt = flash->pdata->max_flash_brt[led_no];	u32 max_torch_brt = flash->pdata->max_torch_brt[led_no];	struct v4l2_ctrl_handler *hdl = &flash->ctrls_led[led_no];	const struct v4l2_ctrl_ops *ops = &lm3560_led_ctrl_ops[led_no];	v4l2_ctrl_handler_init(hdl, 8);	/* flash mode */	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,			       V4L2_FLASH_LED_MODE_TORCH, ~0x7,			       V4L2_FLASH_LED_MODE_NONE);	flash->led_mode = V4L2_FLASH_LED_MODE_NONE;	/* flash source */	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,			       0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);	/* flash strobe */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);	/* flash strobe stop */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);	/* flash strobe timeout */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,			  LM3560_FLASH_TOUT_MIN,			  flash->pdata->max_flash_timeout,			  LM3560_FLASH_TOUT_STEP,			  flash->pdata->max_flash_timeout);	/* flash brt */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,			  LM3560_FLASH_BRT_MIN, max_flash_brt,			  LM3560_FLASH_BRT_STEP, max_flash_brt);	/* torch brt */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,			  LM3560_TORCH_BRT_MIN, max_torch_brt,			  LM3560_TORCH_BRT_STEP, max_torch_brt);	/* fault */	fault = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_FAULT, 0,				  V4L2_FLASH_FAULT_OVER_VOLTAGE				  | V4L2_FLASH_FAULT_OVER_TEMPERATURE				  | V4L2_FLASH_FAULT_SHORT_CIRCUIT				  | V4L2_FLASH_FAULT_TIMEOUT, 0, 0);	if (fault != NULL)		fault->flags |= V4L2_CTRL_FLAG_VOLATILE;	if (hdl->error)		return hdl->error;	flash->subdev_led[led_no].ctrl_handler = hdl;	return 0;}

/* * i2c_driver function */static int aksensor_probe(struct i2c_client *client,			const struct i2c_device_id *did){	struct aksensor_priv        *priv;	struct soc_camera_link	*icl = soc_camera_i2c_to_link(client);	struct i2c_adapter        *adapter = to_i2c_adapter(client->dev.parent);	int i, ret;	SENDBG("entry %s/n", __func__);	if (!icl || !icl->priv) {		dev_err(&client->dev, "AKSENSOR: missing platform data!/n");		return -EINVAL;	}	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {		dev_err(&adapter->dev,			"I2C-Adapter doesn't support "			"I2C_FUNC_SMBUS_BYTE_DATA/n");		return -EIO;	}	priv = kzalloc(sizeof(*priv), GFP_KERNEL);	if (!priv) {		return -ENOMEM;	}		priv->info = icl->priv;	v4l2_i2c_subdev_init(&priv->subdev, client, &aksensor_subdev_ops);	ret = aksensor_video_probe(client);		if (ret) {		kfree(priv);		return ret;	}	v4l2_ctrl_handler_init(&priv->hdl, cur_sensor_info->nr_ctrls);	for (i = 0; i < cur_sensor_info->nr_ctrls; i++)		v4l2_ctrl_new_custom(&priv->hdl, &cur_sensor_info->ctrls[i], NULL);	priv->subdev.ctrl_handler = &priv->hdl;	if (priv->hdl.error) {		int err = priv->hdl.error;		v4l2_ctrl_handler_free(&priv->hdl);		kfree(priv);		return err;	}	// init sensor resolution, default VGA	for (i = 0; i < cur_sensor_info->num_resolution; i++)		if (!strcmp(cur_sensor_info->resolution[i].name, "VGA")) {		priv->win.width = cur_sensor_info->resolution[i].width; 		priv->win.height = cur_sensor_info->resolution[i].height;	}	sensor_dbg("%s: priv->win.width=%d priv->win.height=%d/n",			__func__, priv->win.width, priv->win.height);	return ret;}

/* * m5mols_init_controls - initialization using v4l2_ctrl. */static int m5mols_init_controls(struct m5mols_info *info){	struct v4l2_subdev *sd = &info->sd;	struct i2c_client *client = v4l2_get_subdevdata(sd);	u16 max_ex_mon;	int ret;	/* check minimum & maximum of M5MOLS controls */	ret = i2c_r16_ae(sd, CAT3_MAX_GAIN_MON, (u32 *)&max_ex_mon);	if (ret)		return ret;	/* set the controls using v4l2 control frameworks */	v4l2_ctrl_handler_init(&info->handle, 9);	info->colorfx = v4l2_ctrl_new_std_menu(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_COLORFX,			9, 1, V4L2_COLORFX_NONE);	info->autoexposure = v4l2_ctrl_new_std_menu(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,			1, 0, V4L2_EXPOSURE_AUTO);	info->exposure = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_EXPOSURE,			0, max_ex_mon, 1, (int)max_ex_mon/2);	info->autofocus = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_FOCUS_AUTO,			0, 1, 1, 0);	info->autowb = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,			0, 1, 1, 1);	info->saturation = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_SATURATION,			0, 6, 1, 3);	info->zoom = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_ZOOM_ABSOLUTE,			0, 70, 1, 0);	info->jpeg_size = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[0],			NULL);	info->encoded_size = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[1],			NULL);	sd->ctrl_handler = &info->handle;	if (info->handle.error) {		dev_err(&client->dev, "Failed to init controls, %d/n", ret);		v4l2_ctrl_handler_free(&info->handle);		return info->handle.error;	}	v4l2_ctrl_cluster(2, &info->autoexposure);	/* If above ctrl value is not good image, so it is better that not set */	v4l2_ctrl_handler_setup(&info->handle);	return 0;}

static int adp1653_init_controls(struct adp1653_flash *flash){	struct v4l2_ctrl *fault;	v4l2_ctrl_handler_init(&flash->ctrls, 9);	flash->led_mode =		v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,				       V4L2_CID_FLASH_LED_MODE,				       V4L2_FLASH_LED_MODE_TORCH, ~0x7, 0);	v4l2_ctrl_new_std_menu(&flash->ctrls, &adp1653_ctrl_ops,			       V4L2_CID_FLASH_STROBE_SOURCE,			       V4L2_FLASH_STROBE_SOURCE_SOFTWARE, ~0x1, 0);	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,			  V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);	v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,			  V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);	flash->flash_timeout =		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,				  V4L2_CID_FLASH_TIMEOUT, TIMEOUT_MIN,				  flash->platform_data->max_flash_timeout,				  TIMEOUT_STEP,				  flash->platform_data->max_flash_timeout);	flash->flash_intensity =		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,				  V4L2_CID_FLASH_INTENSITY,				  ADP1653_FLASH_INTENSITY_MIN,				  flash->platform_data->max_flash_intensity,				  1, flash->platform_data->max_flash_intensity);	flash->torch_intensity =		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,				  V4L2_CID_FLASH_TORCH_INTENSITY,				  ADP1653_TORCH_INTENSITY_MIN,				  flash->platform_data->max_torch_intensity,				  ADP1653_FLASH_INTENSITY_STEP,				  flash->platform_data->max_torch_intensity);	flash->indicator_intensity =		v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,				  V4L2_CID_FLASH_INDICATOR_INTENSITY,				  ADP1653_INDICATOR_INTENSITY_MIN,				  flash->platform_data->max_indicator_intensity,				  ADP1653_INDICATOR_INTENSITY_STEP,				  ADP1653_INDICATOR_INTENSITY_MIN);	fault = v4l2_ctrl_new_std(&flash->ctrls, &adp1653_ctrl_ops,				  V4L2_CID_FLASH_FAULT, 0,				  V4L2_FLASH_FAULT_OVER_VOLTAGE				  | V4L2_FLASH_FAULT_OVER_TEMPERATURE				  | V4L2_FLASH_FAULT_SHORT_CIRCUIT, 0, 0);	if (flash->ctrls.error)		return flash->ctrls.error;	fault->flags |= V4L2_CTRL_FLAG_VOLATILE;	flash->subdev.ctrl_handler = &flash->ctrls;	return 0;}

struct vsp1_rwpf *vsp1_rpf_create(struct vsp1_device *vsp1, unsigned int index){	struct v4l2_subdev *subdev;	struct vsp1_rwpf *rpf;	int ret;	rpf = devm_kzalloc(vsp1->dev, sizeof(*rpf), GFP_KERNEL);	if (rpf == NULL)		return ERR_PTR(-ENOMEM);	rpf->ops = &rpf_vdev_ops;	rpf->max_width = RPF_MAX_WIDTH;	rpf->max_height = RPF_MAX_HEIGHT;	rpf->entity.type = VSP1_ENTITY_RPF;	rpf->entity.index = index;	ret = vsp1_entity_init(vsp1, &rpf->entity, 2);	if (ret < 0)		return ERR_PTR(ret);	/* Initialize the V4L2 subdev. */	subdev = &rpf->entity.subdev;	v4l2_subdev_init(subdev, &rpf_ops);	subdev->entity.ops = &vsp1->media_ops;	subdev->internal_ops = &vsp1_subdev_internal_ops;	snprintf(subdev->name, sizeof(subdev->name), "%s rpf.%u",		 dev_name(vsp1->dev), index);	v4l2_set_subdevdata(subdev, rpf);	subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;	vsp1_entity_init_formats(subdev, NULL);	/* Initialize the control handler. */	v4l2_ctrl_handler_init(&rpf->ctrls, 1);	rpf->alpha = v4l2_ctrl_new_std(&rpf->ctrls, &rpf_ctrl_ops,				       V4L2_CID_ALPHA_COMPONENT,				       0, 255, 1, 255);	rpf->entity.subdev.ctrl_handler = &rpf->ctrls;	if (rpf->ctrls.error) {		dev_err(vsp1->dev, "rpf%u: failed to initialize controls/n",			index);		ret = rpf->ctrls.error;		goto error;	}	return rpf;error:	vsp1_entity_destroy(&rpf->entity);	return ERR_PTR(ret);}

static int lm3646_init_controls(struct lm3646_flash *flash){	struct v4l2_ctrl *fault;	struct v4l2_ctrl_handler *hdl = &flash->ctrls_led;	const struct v4l2_ctrl_ops *ops = &lm3646_led_ctrl_ops;	v4l2_ctrl_handler_init(hdl, 8);	/* flash mode */	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_LED_MODE,			       V4L2_FLASH_LED_MODE_TORCH, ~0x7,			       V4L2_FLASH_LED_MODE_NONE);	/* flash source */	v4l2_ctrl_new_std_menu(hdl, ops, V4L2_CID_FLASH_STROBE_SOURCE,			       0x1, ~0x3, V4L2_FLASH_STROBE_SOURCE_SOFTWARE);	/* flash strobe */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE, 0, 0, 0, 0);	/* flash strobe stop */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_STROBE_STOP, 0, 0, 0, 0);	/* flash strobe timeout */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TIMEOUT,			  LM3646_FLASH_TOUT_MIN,			  LM3646_FLASH_TOUT_MAX,			  LM3646_FLASH_TOUT_STEP, flash->pdata->flash_timeout);	/* max flash current */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_INTENSITY,			  LM3646_TOTAL_FLASH_BRT_MIN,			  LM3646_TOTAL_FLASH_BRT_MAX,			  LM3646_TOTAL_FLASH_BRT_STEP,			  LM3646_TOTAL_FLASH_BRT_MAX);	/* max torch current */	v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_TORCH_INTENSITY,			  LM3646_TOTAL_TORCH_BRT_MIN,			  LM3646_TOTAL_TORCH_BRT_MAX,			  LM3646_TOTAL_TORCH_BRT_STEP,			  LM3646_TOTAL_TORCH_BRT_MAX);	/* fault */	fault = v4l2_ctrl_new_std(hdl, ops, V4L2_CID_FLASH_FAULT, 0,				  V4L2_FLASH_FAULT_OVER_VOLTAGE				  | V4L2_FLASH_FAULT_OVER_TEMPERATURE				  | V4L2_FLASH_FAULT_SHORT_CIRCUIT				  | V4L2_FLASH_FAULT_TIMEOUT, 0, 0);	if (fault != NULL)		fault->flags |= V4L2_CTRL_FLAG_VOLATILE;	if (hdl->error)		return hdl->error;	flash->subdev_led.ctrl_handler = hdl;	return 0;}

/* * sensor_init_controls - initialization using v4l2_ctrl. */static int sensor_init_controls(struct sensor_info *info){	struct v4l2_subdev *sd = &info->sd;	int num_of_ctl_hint = ARRAY_SIZE(ctrl_private);	/* set the controls using v4l2 control frameworks */	v4l2_ctrl_handler_init(&info->handle, num_of_ctl_hint);	/* Vision mode only support simple AE */	info->ae_target = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[0], NULL);	info->ae_weight[0] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[1], NULL);	info->ae_weight[1] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[2], NULL);	info->ae_weight[2] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[3], NULL);	info->ae_weight[3] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[4], NULL);	info->ae_weight[4] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[5], NULL);	info->ae_weight[5] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[6], NULL);	info->ae_weight[6] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[7], NULL);	info->ae_weight[7] = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[8], NULL);	info->rg_weight = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[9], NULL);	info->ae_speed = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[10], NULL);	info->shutter = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[11], NULL);	info->gain = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[12], NULL);	info->bit_converting = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[13], NULL);	info->autoexposure = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[14], NULL);	info->framerate = v4l2_ctrl_new_custom(&info->handle,			&ctrl_private[15], NULL);	sd->ctrl_handler = &info->handle;	if (info->handle.error) {		sensor_err("Failed to init controls, %d/n", info->handle.error);		v4l2_ctrl_handler_free(&info->handle);		return info->handle.error;	}	return 0;}

static int ad5823_init_controls(struct ad5823 *vcm){    struct v4l2_ctrl *ctrl;    v4l2_ctrl_handler_init(&vcm->ctrls, 1);    /* V4L2_CID_FOCUS_ABSOLUTE */    ctrl = v4l2_ctrl_new_std(&vcm->ctrls, &ad5823_ctrl_ops,                             V4L2_CID_FOCUS_ABSOLUTE, 0, (1<<16)-1, 1, 0x8000);    if (ctrl != NULL)        ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;    vcm->subdev.ctrl_handler = &vcm->ctrls;    return vcm->ctrls.error;}

struct vsp1_brx *vsp1_brx_create(struct vsp1_device *vsp1,				 enum vsp1_entity_type type){	struct vsp1_brx *brx;	unsigned int num_pads;	const char *name;	int ret;	brx = devm_kzalloc(vsp1->dev, sizeof(*brx), GFP_KERNEL);	if (brx == NULL)		return ERR_PTR(-ENOMEM);	brx->base = type == VSP1_ENTITY_BRU ? VI6_BRU_BASE : VI6_BRS_BASE;	brx->entity.ops = &brx_entity_ops;	brx->entity.type = type;	if (type == VSP1_ENTITY_BRU) {		num_pads = vsp1->info->num_bru_inputs + 1;		name = "bru";	} else {		num_pads = 3;		name = "brs";	}	ret = vsp1_entity_init(vsp1, &brx->entity, name, num_pads, &brx_ops,			       MEDIA_ENT_F_PROC_VIDEO_COMPOSER);	if (ret < 0)		return ERR_PTR(ret);	/* Initialize the control handler. */	v4l2_ctrl_handler_init(&brx->ctrls, 1);	v4l2_ctrl_new_std(&brx->ctrls, &brx_ctrl_ops, V4L2_CID_BG_COLOR,			  0, 0xffffff, 1, 0);	brx->bgcolor = 0;	brx->entity.subdev.ctrl_handler = &brx->ctrls;	if (brx->ctrls.error) {		dev_err(vsp1->dev, "%s: failed to initialize controls/n", name);		ret = brx->ctrls.error;		vsp1_entity_destroy(&brx->entity);		return ERR_PTR(ret);	}	return brx;}

struct vsp1_bru *vsp1_bru_create(struct vsp1_device *vsp1){	struct v4l2_subdev *subdev;	struct vsp1_bru *bru;	int ret;	bru = devm_kzalloc(vsp1->dev, sizeof(*bru), GFP_KERNEL);	if (bru == NULL)		return ERR_PTR(-ENOMEM);	bru->entity.type = VSP1_ENTITY_BRU;	ret = vsp1_entity_init(vsp1, &bru->entity,			       vsp1->info->num_bru_inputs + 1);	if (ret < 0)		return ERR_PTR(ret);	/* Initialize the V4L2 subdev. */	subdev = &bru->entity.subdev;	v4l2_subdev_init(subdev, &bru_ops);	subdev->entity.ops = &vsp1->media_ops;	subdev->internal_ops = &vsp1_subdev_internal_ops;	snprintf(subdev->name, sizeof(subdev->name), "%s bru",		 dev_name(vsp1->dev));	v4l2_set_subdevdata(subdev, bru);	subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;	vsp1_entity_init_formats(subdev, NULL);	/* Initialize the control handler. */	v4l2_ctrl_handler_init(&bru->ctrls, 1);	v4l2_ctrl_new_std(&bru->ctrls, &bru_ctrl_ops, V4L2_CID_BG_COLOR,			  0, 0xffffff, 1, 0);	bru->entity.subdev.ctrl_handler = &bru->ctrls;	if (bru->ctrls.error) {		dev_err(vsp1->dev, "bru: failed to initialize controls/n");		ret = bru->ctrls.error;		vsp1_entity_destroy(&bru->entity);		return ERR_PTR(ret);	}	return bru;}

static int m5mols_init_controls(struct m5mols_info *info){	struct v4l2_subdev *sd = &info->sd;	u16 max_exposure;	u16 step_zoom;	int ret;	/* Determine value's range & step of controls for various FW version */	ret = m5mols_read_u16(sd, AE_MAX_GAIN_MON, &max_exposure);	if (!ret)		step_zoom = is_manufacturer(info, REG_SAMSUNG_OPTICS) ? 31 : 1;	if (ret)		return ret;	v4l2_ctrl_handler_init(&info->handle, 6);	info->autowb = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_AUTO_WHITE_BALANCE,			0, 1, 1, 0);	info->saturation = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_SATURATION,			1, 5, 1, 3);	info->zoom = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_ZOOM_ABSOLUTE,			1, 70, step_zoom, 1);	info->exposure = v4l2_ctrl_new_std(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_EXPOSURE,			0, max_exposure, 1, (int)max_exposure/2);	info->colorfx = v4l2_ctrl_new_std_menu(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_COLORFX,			4, (1 << V4L2_COLORFX_BW), V4L2_COLORFX_NONE);	info->autoexposure = v4l2_ctrl_new_std_menu(&info->handle,			&m5mols_ctrl_ops, V4L2_CID_EXPOSURE_AUTO,			1, 0, V4L2_EXPOSURE_MANUAL);	sd->ctrl_handler = &info->handle;	if (info->handle.error) {		v4l2_err(sd, "Failed to initialize controls: %d/n", ret);		v4l2_ctrl_handler_free(&info->handle);		return info->handle.error;	}	v4l2_ctrl_cluster(2, &info->autoexposure);	return 0;}

static int msm_gesture_init_ctrl(struct v4l2_subdev *sd,	struct msm_gesture_ctrl *p_gesture_ctrl){	int rc = 0;	p_gesture_ctrl->num_ctrls = 1;	p_gesture_ctrl->ctrl_handler.error = 0;	v4l2_ctrl_handler_init(&p_gesture_ctrl->ctrl_handler,		p_gesture_ctrl->num_ctrls);	v4l2_ctrl_new_custom(&p_gesture_ctrl->ctrl_handler,		&msm_gesture_ctrl_filter, p_gesture_ctrl);	if (p_gesture_ctrl->ctrl_handler.error) {		int err = p_gesture_ctrl->ctrl_handler.error;		D("%s: error adding control %d", __func__, err);		p_gesture_ctrl->ctrl_handler.error = 0;	}	sd->ctrl_handler = &p_gesture_ctrl->ctrl_handler;	return rc;}

static int rockchip_vpu_ctrls_setup(struct rockchip_vpu_dev *vpu,				    struct rockchip_vpu_ctx *ctx){	v4l2_ctrl_handler_init(&ctx->ctrl_handler, 1);	if (vpu->variant->codec & RK_VPU_CODEC_JPEG) {		v4l2_ctrl_new_std(&ctx->ctrl_handler, &rockchip_vpu_ctrl_ops,				  V4L2_CID_JPEG_COMPRESSION_QUALITY,				  5, 100, 1, 50);		if (ctx->ctrl_handler.error) {			vpu_err("Adding JPEG control failed %d/n",				ctx->ctrl_handler.error);			v4l2_ctrl_handler_free(&ctx->ctrl_handler);			return ctx->ctrl_handler.error;		}	}	return v4l2_ctrl_handler_setup(&ctx->ctrl_handler);}

static int register_v4l2_device(void){  int ret;  struct fmdev *fmdev = NULL;	struct video_device *radio = video_device_alloc();	if (!radio)	{		TROUT_PRINT("Could not allocate video_device");		return -EINVAL;	}	strlcpy(radio->name, DRIVER_NAME, sizeof(radio->name));	radio->fops = &trout_fops;	radio->release = video_device_release;	radio->ioctl_ops = &trout_ioctl_ops;	if (video_register_device(radio, VFL_TYPE_RADIO, -1))	{		TROUT_PRINT("Could not register video_device");		video_device_release(radio);	  return -EINVAL;	}  s_radio = radio;  fmdev = (struct fmdev *)kzalloc(sizeof(struct fmdev), GFP_KERNEL);  if (!fmdev)  {    TROUT_PRINT("Could not allocate fmdev");    return -EINVAL;  }  video_set_drvdata(radio, fmdev);  radio->ctrl_handler = &fmdev->ctrl_handler;  ret = v4l2_ctrl_handler_init(&fmdev->ctrl_handler, 1);  if (ret < 0)  {    TROUT_PRINT("Failed to int v4l2_ctrl_handler");    v4l2_ctrl_handler_free(&fmdev->ctrl_handler);    return -EINVAL;  }  v4l2_ctrl_new_std(&fmdev->ctrl_handler, &trout_ctrl_ops,      V4L2_CID_PRIVATE_FM_AUDIO, 0, 1, 1, 0);	TROUT_PRINT("Registered Trout FM Receiver.");	return 0;}

/* * i2c_driver function */static int ov9640_probe(struct i2c_client *client,			const struct i2c_device_id *did){	struct ov9640_priv *priv;	struct soc_camera_link *icl = soc_camera_i2c_to_link(client);	int ret;	if (!icl) {		dev_err(&client->dev, "Missing platform_data for driver/n");		return -EINVAL;	}	priv = kzalloc(sizeof(struct ov9640_priv), GFP_KERNEL);	if (!priv) {		dev_err(&client->dev,			"Failed to allocate memory for private data!/n");		return -ENOMEM;	}	v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops);	v4l2_ctrl_handler_init(&priv->hdl, 2);	v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,			V4L2_CID_VFLIP, 0, 1, 1, 0);	v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,			V4L2_CID_HFLIP, 0, 1, 1, 0);	priv->subdev.ctrl_handler = &priv->hdl;	if (priv->hdl.error) {		int err = priv->hdl.error;		kfree(priv);		return err;	}	ret = ov9640_video_probe(client);	if (ret) {		v4l2_ctrl_handler_free(&priv->hdl);		kfree(priv);	}	return ret;}

int mtk_vcodec_enc_ctrls_setup(struct mtk_vcodec_ctx *ctx){	const struct v4l2_ctrl_ops *ops = &mtk_vcodec_enc_ctrl_ops;	struct v4l2_ctrl_handler *handler = &ctx->ctrl_hdl;	v4l2_ctrl_handler_init(handler, MTK_MAX_CTRLS_HINT);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_BITRATE,			1, 4000000, 1, 4000000);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_B_FRAMES,			0, 2, 1, 0);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE,			0, 1, 1, 1);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_H264_MAX_QP,			0, 51, 1, 51);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,			0, 65535, 1, 0);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_GOP_SIZE,			0, 65535, 1, 0);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE,			0, 1, 1, 0);	v4l2_ctrl_new_std(handler, ops, V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,			0, 0, 0, 0);	v4l2_ctrl_new_std_menu(handler, ops,			V4L2_CID_MPEG_VIDEO_HEADER_MODE,			V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,			0, V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE);	v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_H264_PROFILE,			V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,			0, V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);	v4l2_ctrl_new_std_menu(handler, ops, V4L2_CID_MPEG_VIDEO_H264_LEVEL,			V4L2_MPEG_VIDEO_H264_LEVEL_4_2,			0, V4L2_MPEG_VIDEO_H264_LEVEL_4_0);	if (handler->error) {		mtk_v4l2_err("Init control handler fail %d",				handler->error);		return handler->error;	}	v4l2_ctrl_handler_setup(&ctx->ctrl_hdl);	return 0;}

/* * i2c_driver function */static int ov9640_probe(struct i2c_client *client,			const struct i2c_device_id *did){	struct ov9640_priv *priv;	struct soc_camera_subdev_desc *ssdd = soc_camera_i2c_to_desc(client);	int ret;	if (!ssdd) {		dev_err(&client->dev, "Missing platform_data for driver/n");		return -EINVAL;	}	priv = devm_kzalloc(&client->dev, sizeof(*priv), GFP_KERNEL);	if (!priv)		return -ENOMEM;	v4l2_i2c_subdev_init(&priv->subdev, client, &ov9640_subdev_ops);	v4l2_ctrl_handler_init(&priv->hdl, 2);	v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,			V4L2_CID_VFLIP, 0, 1, 1, 0);	v4l2_ctrl_new_std(&priv->hdl, &ov9640_ctrl_ops,			V4L2_CID_HFLIP, 0, 1, 1, 0);	priv->subdev.ctrl_handler = &priv->hdl;	if (priv->hdl.error)		return priv->hdl.error;	priv->clk = v4l2_clk_get(&client->dev, "mclk");	if (IS_ERR(priv->clk)) {		ret = PTR_ERR(priv->clk);		goto eclkget;	}	ret = ov9640_video_probe(client);	if (ret) {		v4l2_clk_put(priv->clk);eclkget:		v4l2_ctrl_handler_free(&priv->hdl);	}	return ret;}

static int bdisp_ctrls_create(struct bdisp_ctx *ctx){	if (ctx->ctrls_rdy)		return 0;	v4l2_ctrl_handler_init(&ctx->ctrl_handler, BDISP_MAX_CTRL_NUM);	ctx->bdisp_ctrls.hflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,				&bdisp_c_ops, V4L2_CID_HFLIP, 0, 1, 1, 0);	ctx->bdisp_ctrls.vflip = v4l2_ctrl_new_std(&ctx->ctrl_handler,				&bdisp_c_ops, V4L2_CID_VFLIP, 0, 1, 1, 0);	if (ctx->ctrl_handler.error) {		int err = ctx->ctrl_handler.error;		v4l2_ctrl_handler_free(&ctx->ctrl_handler);		return err;	}	ctx->ctrls_rdy = true;	return 0;}