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 fimc_lite_create_capture_subdev(struct fimc_lite *fimc) { struct v4l2_ctrl_handler *handler = &fimc->ctrl_handler; struct v4l2_subdev *sd = &fimc->subdev; int ret; v4l2_subdev_init(sd, &fimc_lite_subdev_ops); sd->flags = V4L2_SUBDEV_FL_HAS_DEVNODE; snprintf(sd->name, sizeof(sd->name), "FIMC-LITE.%d", fimc->index); fimc->subdev_pads[FIMC_SD_PAD_SINK].flags = MEDIA_PAD_FL_SINK; fimc->subdev_pads[FIMC_SD_PAD_SOURCE].flags = MEDIA_PAD_FL_SOURCE; ret = media_entity_init(&sd->entity, FIMC_SD_PADS_NUM, fimc->subdev_pads, 0); if (ret) return ret; v4l2_ctrl_handler_init(handler, 1); fimc->test_pattern = v4l2_ctrl_new_custom(handler, &fimc_lite_ctrl, NULL); if (handler->error) { media_entity_cleanup(&sd->entity); return handler->error; } sd->ctrl_handler = handler; sd->internal_ops = &fimc_lite_subdev_internal_ops; sd->entity.ops = &fimc_lite_subdev_media_ops; v4l2_set_subdevdata(sd, fimc); return 0; }
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; }
/* * ispcsi2_init_entities - Initialize subdev and media entity. * @csi2: Pointer to ispcsi2 structure. * return -ENOMEM or zero on success */ static int isp_csi2_init_entities(struct isp_csi2_device *csi2) { struct v4l2_subdev *sd = &csi2->subdev; struct media_pad *pads = csi2->pads; struct media_entity *me = &sd->entity; int ret; v4l2_subdev_init(sd, &csi2_ops); strlcpy(sd->name, "OMAP3 ISP CSI2a", sizeof(sd->name)); sd->grp_id = 1 << 16; /* group ID for isp subdevs */ v4l2_set_subdevdata(sd, csi2); sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; v4l2_ctrl_handler_init(&csi2->ctrls, 1); sd->ctrl_handler = &csi2->ctrls; pads[CSI2_PAD_SOURCE].flags = MEDIA_PAD_FLAG_OUTPUT; pads[CSI2_PAD_SINK].flags = MEDIA_PAD_FLAG_INPUT; me->ops = &csi2_media_ops; ret = media_entity_init(me, CSI2_PADS_NUM, pads, 0); if (ret < 0) return ret; csi2_init_formats(sd, NULL); /* Video device node */ csi2->video_out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; csi2->video_out.ops = &csi2_ispvideo_ops; csi2->video_out.bpl_alignment = 32; csi2->video_out.bpl_zero_padding = 1; csi2->video_out.bpl_max = 0x1ffe0; csi2->video_out.isp = csi2->isp; csi2->video_out.capture_mem = PAGE_ALIGN(4096 * 4096) * 3; ret = isp_video_init(&csi2->video_out, "CSI2a"); if (ret < 0) return ret; /* Connect the CSI2 subdev to the video node. */ ret = media_entity_create_link(&csi2->subdev.entity, CSI2_PAD_SOURCE, &csi2->video_out.video.entity, 0, 0); if (ret < 0) return ret; return 0; }
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; }