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;
}
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 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 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;
}
/*
* 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 wpf_init_controls(struct vsp1_rwpf *wpf)
{
struct vsp1_device *vsp1 = wpf->entity.vsp1;
unsigned int num_flip_ctrls;
spin_lock_init(&wpf->flip.lock);
if (wpf->entity.index != 0) {
/* Only WPF0 supports flipping. */
num_flip_ctrls = 0;
} else if (vsp1->info->features & VSP1_HAS_WPF_HFLIP) {
/* When horizontal flip is supported the WPF implements two
* controls (horizontal flip and vertical flip).
*/
num_flip_ctrls = 2;
} else if (vsp1->info->features & VSP1_HAS_WPF_VFLIP) {
/* When only vertical flip is supported the WPF implements a
* single control (vertical flip).
*/
num_flip_ctrls = 1;
} else {
/* Otherwise flipping is not supported. */
num_flip_ctrls = 0;
}
vsp1_rwpf_init_ctrls(wpf, num_flip_ctrls);
if (num_flip_ctrls >= 1) {
wpf->flip.ctrls[WPF_CTRL_VFLIP] =
v4l2_ctrl_new_std(&wpf->ctrls, &vsp1_wpf_ctrl_ops,
V4L2_CID_VFLIP, 0, 1, 1, 0);
}
if (num_flip_ctrls == 2) {
wpf->flip.ctrls[WPF_CTRL_HFLIP] =
v4l2_ctrl_new_std(&wpf->ctrls, &vsp1_wpf_ctrl_ops,
V4L2_CID_HFLIP, 0, 1, 1, 0);
v4l2_ctrl_cluster(2, wpf->flip.ctrls);
}
if (wpf->ctrls.error) {
dev_err(vsp1->dev, "wpf%u: failed to initialize controls\n",
wpf->entity.index);
return wpf->ctrls.error;
}
return 0;
}
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;
}
int mt9m111_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, 7);
sd->auto_white_bal = v4l2_ctrl_new_std(hdl, &mt9m111_ctrl_ops,
V4L2_CID_AUTO_WHITE_BALANCE,
0, 1, 1, 0);
sd->green_bal = v4l2_ctrl_new_custom(hdl, &mt9m111_greenbal_cfg, NULL);
sd->red_bal = v4l2_ctrl_new_std(hdl, &mt9m111_ctrl_ops,
V4L2_CID_RED_BALANCE, 0, 0x7ff, 1,
MT9M111_RED_GAIN_DEFAULT);
sd->blue_bal = v4l2_ctrl_new_std(hdl, &mt9m111_ctrl_ops,
V4L2_CID_BLUE_BALANCE, 0, 0x7ff, 1,
MT9M111_BLUE_GAIN_DEFAULT);
v4l2_ctrl_new_std(hdl, &mt9m111_ctrl_ops, V4L2_CID_GAIN, 0,
(INITIAL_MAX_GAIN - 1) * 2 * 2 * 2, 1,
MT9M111_DEFAULT_GAIN);
sd->hflip = v4l2_ctrl_new_std(hdl, &mt9m111_ctrl_ops, V4L2_CID_HFLIP,
0, 1, 1, 0);
sd->vflip = v4l2_ctrl_new_std(hdl, &mt9m111_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(4, &sd->auto_white_bal, 0, false);
v4l2_ctrl_cluster(2, &sd->hflip);
return 0;
}
int pwc_init_controls(struct pwc_device *pdev)
{
struct v4l2_ctrl_handler *hdl;
struct v4l2_ctrl_config cfg;
int r, def;
hdl = &pdev->ctrl_handler;
r = v4l2_ctrl_handler_init(hdl, 20);
if (r)
return r;
/* Brightness, contrast, saturation, gamma */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, BRIGHTNESS_FORMATTER, &def);
if (r || def > 127)
def = 63;
pdev->brightness = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_BRIGHTNESS, 0, 127, 1, def);
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, CONTRAST_FORMATTER, &def);
if (r || def > 63)
def = 31;
pdev->contrast = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_CONTRAST, 0, 63, 1, def);
if (pdev->type >= 675) {
if (pdev->type < 730)
pdev->saturation_fmt = SATURATION_MODE_FORMATTER2;
else
pdev->saturation_fmt = SATURATION_MODE_FORMATTER1;
r = pwc_get_s8_ctrl(pdev, GET_CHROM_CTL, pdev->saturation_fmt,
&def);
if (r || def < -100 || def > 100)
def = 0;
pdev->saturation = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_SATURATION, -100, 100, 1, def);
}
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, GAMMA_FORMATTER, &def);
if (r || def > 31)
def = 15;
pdev->gamma = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_GAMMA, 0, 31, 1, def);
/* auto white balance, red gain, blue gain */
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL, WB_MODE_FORMATTER, &def);
if (r || def > awb_auto)
def = awb_auto;
cfg = pwc_auto_white_balance_cfg;
cfg.name = v4l2_ctrl_get_name(cfg.id);
cfg.def = def;
pdev->auto_white_balance = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
/* check auto controls to avoid NULL deref in v4l2_ctrl_auto_cluster */
if (!pdev->auto_white_balance)
return hdl->error;
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
PRESET_MANUAL_RED_GAIN_FORMATTER, &def);
if (r)
def = 127;
pdev->red_balance = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_RED_BALANCE, 0, 255, 1, def);
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
PRESET_MANUAL_BLUE_GAIN_FORMATTER, &def);
if (r)
def = 127;
pdev->blue_balance = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_BLUE_BALANCE, 0, 255, 1, def);
v4l2_ctrl_auto_cluster(3, &pdev->auto_white_balance, awb_manual, true);
/* autogain, gain */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, AGC_MODE_FORMATTER, &def);
if (r || (def != 0 && def != 0xff))
def = 0;
/* Note a register value if 0 means auto gain is on */
pdev->autogain = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_AUTOGAIN, 0, 1, 1, def == 0);
if (!pdev->autogain)
return hdl->error;
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, PRESET_AGC_FORMATTER, &def);
if (r || def > 63)
def = 31;
pdev->gain = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_GAIN, 0, 63, 1, def);
/* auto exposure, exposure */
if (DEVICE_USE_CODEC2(pdev->type)) {
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, SHUTTER_MODE_FORMATTER,
&def);
if (r || (def != 0 && def != 0xff))
def = 0;
/*
* def = 0 auto, def = ff manual
* menu idx 0 = auto, idx 1 = manual
*/
pdev->exposure_auto = v4l2_ctrl_new_std_menu(hdl,
&pwc_ctrl_ops,
V4L2_CID_EXPOSURE_AUTO,
1, 0, def != 0);
if (!pdev->exposure_auto)
return hdl->error;
/* GET_LUM_CTL, PRESET_SHUTTER_FORMATTER is unreliable */
r = pwc_get_u16_ctrl(pdev, GET_STATUS_CTL,
READ_SHUTTER_FORMATTER, &def);
if (r || def > 655)
def = 655;
pdev->exposure = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_EXPOSURE, 0, 655, 1, def);
/* CODEC2: separate auto gain & auto exposure */
v4l2_ctrl_auto_cluster(2, &pdev->autogain, 0, true);
v4l2_ctrl_auto_cluster(2, &pdev->exposure_auto,
V4L2_EXPOSURE_MANUAL, true);
} else if (DEVICE_USE_CODEC3(pdev->type)) {
/* GET_LUM_CTL, PRESET_SHUTTER_FORMATTER is unreliable */
r = pwc_get_u16_ctrl(pdev, GET_STATUS_CTL,
READ_SHUTTER_FORMATTER, &def);
if (r || def > 255)
def = 255;
pdev->exposure = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_EXPOSURE, 0, 255, 1, def);
/* CODEC3: both gain and exposure controlled by autogain */
pdev->autogain_expo_cluster[0] = pdev->autogain;
pdev->autogain_expo_cluster[1] = pdev->gain;
pdev->autogain_expo_cluster[2] = pdev->exposure;
v4l2_ctrl_auto_cluster(3, pdev->autogain_expo_cluster,
0, true);
}
/* color / bw setting */
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL, COLOUR_MODE_FORMATTER,
&def);
if (r || (def != 0 && def != 0xff))
def = 0xff;
/* def = 0 bw, def = ff color, menu idx 0 = color, idx 1 = bw */
pdev->colorfx = v4l2_ctrl_new_std_menu(hdl, &pwc_ctrl_ops,
V4L2_CID_COLORFX, 1, 0, def == 0);
/* autocontour, contour */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, AUTO_CONTOUR_FORMATTER, &def);
if (r || (def != 0 && def != 0xff))
def = 0;
cfg = pwc_autocontour_cfg;
cfg.def = def == 0;
pdev->autocontour = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
if (!pdev->autocontour)
return hdl->error;
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL, PRESET_CONTOUR_FORMATTER, &def);
if (r || def > 63)
def = 31;
cfg = pwc_contour_cfg;
cfg.def = def;
pdev->contour = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
v4l2_ctrl_auto_cluster(2, &pdev->autocontour, 0, false);
/* backlight */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL,
BACK_LIGHT_COMPENSATION_FORMATTER, &def);
if (r || (def != 0 && def != 0xff))
def = 0;
cfg = pwc_backlight_cfg;
cfg.name = v4l2_ctrl_get_name(cfg.id);
cfg.def = def == 0;
pdev->backlight = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
/* flikker rediction */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL,
FLICKERLESS_MODE_FORMATTER, &def);
if (r || (def != 0 && def != 0xff))
def = 0;
cfg = pwc_flicker_cfg;
cfg.name = v4l2_ctrl_get_name(cfg.id);
cfg.def = def == 0;
pdev->flicker = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
/* Dynamic noise reduction */
r = pwc_get_u8_ctrl(pdev, GET_LUM_CTL,
DYNAMIC_NOISE_CONTROL_FORMATTER, &def);
if (r || def > 3)
def = 2;
cfg = pwc_noise_reduction_cfg;
cfg.def = def;
pdev->noise_reduction = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
/* Save / Restore User / Factory Settings */
pdev->save_user = v4l2_ctrl_new_custom(hdl, &pwc_save_user_cfg, NULL);
pdev->restore_user = v4l2_ctrl_new_custom(hdl, &pwc_restore_user_cfg,
NULL);
if (pdev->restore_user)
pdev->restore_user->flags |= V4L2_CTRL_FLAG_UPDATE;
pdev->restore_factory = v4l2_ctrl_new_custom(hdl,
&pwc_restore_factory_cfg,
NULL);
if (pdev->restore_factory)
pdev->restore_factory->flags |= V4L2_CTRL_FLAG_UPDATE;
/* Auto White Balance speed & delay */
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
AWB_CONTROL_SPEED_FORMATTER, &def);
if (r || def < 1 || def > 32)
def = 1;
cfg = pwc_awb_speed_cfg;
cfg.def = def;
pdev->awb_speed = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
r = pwc_get_u8_ctrl(pdev, GET_CHROM_CTL,
AWB_CONTROL_DELAY_FORMATTER, &def);
if (r || def > 63)
def = 0;
cfg = pwc_awb_delay_cfg;
cfg.def = def;
pdev->awb_delay = v4l2_ctrl_new_custom(hdl, &cfg, NULL);
if (!(pdev->features & FEATURE_MOTOR_PANTILT))
return hdl->error;
/* Motor pan / tilt / reset */
pdev->motor_pan = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_PAN_RELATIVE, -4480, 4480, 64, 0);
if (!pdev->motor_pan)
return hdl->error;
pdev->motor_tilt = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_TILT_RELATIVE, -1920, 1920, 64, 0);
pdev->motor_pan_reset = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_PAN_RESET, 0, 0, 0, 0);
pdev->motor_tilt_reset = v4l2_ctrl_new_std(hdl, &pwc_ctrl_ops,
V4L2_CID_TILT_RESET, 0, 0, 0, 0);
v4l2_ctrl_cluster(4, &pdev->motor_pan);
return hdl->error;
}
/* si4713_probe - probe for the device */
static int si4713_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct si4713_device *sdev;
struct si4713_platform_data *pdata = client->dev.platform_data;
struct v4l2_ctrl_handler *hdl;
int rval, i;
sdev = kzalloc(sizeof *sdev, GFP_KERNEL);
if (!sdev) {
dev_err(&client->dev, "Failed to alloc video device.\n");
rval = -ENOMEM;
goto exit;
}
sdev->gpio_reset = -1;
if (pdata && gpio_is_valid(pdata->gpio_reset)) {
rval = gpio_request(pdata->gpio_reset, "si4713 reset");
if (rval) {
dev_err(&client->dev,
"Failed to request gpio: %d\n", rval);
goto free_sdev;
}
sdev->gpio_reset = pdata->gpio_reset;
gpio_direction_output(sdev->gpio_reset, 0);
}
for (i = 0; i < ARRAY_SIZE(sdev->supplies); i++)
sdev->supplies[i].supply = si4713_supply_names[i];
rval = regulator_bulk_get(&client->dev, ARRAY_SIZE(sdev->supplies),
sdev->supplies);
if (rval) {
dev_err(&client->dev, "Cannot get regulators: %d\n", rval);
goto free_gpio;
}
v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
init_completion(&sdev->work);
hdl = &sdev->ctrl_handler;
v4l2_ctrl_handler_init(hdl, 20);
sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
10, DEFAULT_RDS_DEVIATION);
/*
* Report step as 8. From RDS spec, psname
* should be 8. But there are receivers which scroll strings
* sized as 8xN.
*/
sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
/*
* Report step as 32 (2A block). From RDS spec,
* radio text should be 32 for 2A block. But there are receivers
* which scroll strings sized as 32xN. Setting default to 32.
*/
sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
DEFAULT_ACOMP_GAIN);
sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_THRESHOLD, MIN_ACOMP_THRESHOLD,
MAX_ACOMP_THRESHOLD, 1,
DEFAULT_ACOMP_THRESHOLD);
sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
10, DEFAULT_PILOT_DEVIATION);
sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1, DEFAULT_PILOT_FREQUENCY);
sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_PREEMPHASIS,
V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_POWER_LEVEL, 0, 120, 1, DEFAULT_POWER_LEVEL);
sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, 191, 1, 0);
if (hdl->error) {
rval = hdl->error;
goto free_ctrls;
}
v4l2_ctrl_cluster(20, &sdev->mute);
sdev->sd.ctrl_handler = hdl;
if (client->irq) {
rval = request_irq(client->irq,
si4713_handler, IRQF_TRIGGER_FALLING | IRQF_DISABLED,
client->name, sdev);
if (rval < 0) {
v4l2_err(&sdev->sd, "Could not request IRQ\n");
goto put_reg;
}
v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
} else {
v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
}
rval = si4713_initialize(sdev);
if (rval < 0) {
v4l2_err(&sdev->sd, "Failed to probe device information.\n");
goto free_irq;
}
return 0;
free_irq:
if (client->irq)
free_irq(client->irq, sdev);
free_ctrls:
v4l2_ctrl_handler_free(hdl);
put_reg:
regulator_bulk_free(ARRAY_SIZE(sdev->supplies), sdev->supplies);
free_gpio:
if (gpio_is_valid(sdev->gpio_reset))
gpio_free(sdev->gpio_reset);
free_sdev:
kfree(sdev);
exit:
return rval;
}
/* si4713_probe - probe for the device */
static int si4713_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct si4713_device *sdev;
struct v4l2_ctrl_handler *hdl;
struct si4713_platform_data *pdata = client->dev.platform_data;
struct device_node *np = client->dev.of_node;
struct radio_si4713_platform_data si4713_pdev_pdata;
struct platform_device *si4713_pdev;
int rval;
sdev = devm_kzalloc(&client->dev, sizeof(*sdev), GFP_KERNEL);
if (!sdev) {
dev_err(&client->dev, "Failed to alloc video device.\n");
rval = -ENOMEM;
goto exit;
}
sdev->gpio_reset = devm_gpiod_get_optional(&client->dev, "reset",
GPIOD_OUT_LOW);
if (IS_ERR(sdev->gpio_reset)) {
rval = PTR_ERR(sdev->gpio_reset);
dev_err(&client->dev, "Failed to request gpio: %d\n", rval);
goto exit;
}
sdev->vdd = devm_regulator_get_optional(&client->dev, "vdd");
if (IS_ERR(sdev->vdd)) {
rval = PTR_ERR(sdev->vdd);
if (rval == -EPROBE_DEFER)
goto exit;
dev_dbg(&client->dev, "no vdd regulator found: %d\n", rval);
sdev->vdd = NULL;
}
sdev->vio = devm_regulator_get_optional(&client->dev, "vio");
if (IS_ERR(sdev->vio)) {
rval = PTR_ERR(sdev->vio);
if (rval == -EPROBE_DEFER)
goto exit;
dev_dbg(&client->dev, "no vio regulator found: %d\n", rval);
sdev->vio = NULL;
}
v4l2_i2c_subdev_init(&sdev->sd, client, &si4713_subdev_ops);
init_completion(&sdev->work);
hdl = &sdev->ctrl_handler;
v4l2_ctrl_handler_init(hdl, 20);
sdev->mute = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_MUTE, 0, 1, 1, DEFAULT_MUTE);
sdev->rds_pi = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PI, 0, 0xffff, 1, DEFAULT_RDS_PI);
sdev->rds_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PTY, 0, 31, 1, DEFAULT_RDS_PTY);
sdev->rds_compressed = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_COMPRESSED, 0, 1, 1, 0);
sdev->rds_art_head = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_ARTIFICIAL_HEAD, 0, 1, 1, 0);
sdev->rds_stereo = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_MONO_STEREO, 0, 1, 1, 1);
sdev->rds_tp = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_TRAFFIC_PROGRAM, 0, 1, 1, 0);
sdev->rds_ta = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_TRAFFIC_ANNOUNCEMENT, 0, 1, 1, 0);
sdev->rds_ms = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_MUSIC_SPEECH, 0, 1, 1, 1);
sdev->rds_dyn_pty = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_DYNAMIC_PTY, 0, 1, 1, 0);
sdev->rds_alt_freqs_enable = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_ALT_FREQS_ENABLE, 0, 1, 1, 0);
sdev->rds_alt_freqs = v4l2_ctrl_new_custom(hdl, &si4713_alt_freqs_ctrl, NULL);
sdev->rds_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_DEVIATION, 0, MAX_RDS_DEVIATION,
10, DEFAULT_RDS_DEVIATION);
/*
* Report step as 8. From RDS spec, psname
* should be 8. But there are receivers which scroll strings
* sized as 8xN.
*/
sdev->rds_ps_name = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_PS_NAME, 0, MAX_RDS_PS_NAME, 8, 0);
/*
* Report step as 32 (2A block). From RDS spec,
* radio text should be 32 for 2A block. But there are receivers
* which scroll strings sized as 32xN. Setting default to 32.
*/
sdev->rds_radio_text = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_RDS_TX_RADIO_TEXT, 0, MAX_RDS_RADIO_TEXT, 32, 0);
sdev->limiter_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_ENABLED, 0, 1, 1, 1);
sdev->limiter_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_RELEASE_TIME, 250,
MAX_LIMITER_RELEASE_TIME, 10, DEFAULT_LIMITER_RTIME);
sdev->limiter_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_LIMITER_DEVIATION, 0,
MAX_LIMITER_DEVIATION, 10, DEFAULT_LIMITER_DEV);
sdev->compression_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_ENABLED, 0, 1, 1, 1);
sdev->compression_gain = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_GAIN, 0, MAX_ACOMP_GAIN, 1,
DEFAULT_ACOMP_GAIN);
sdev->compression_threshold = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_THRESHOLD,
MIN_ACOMP_THRESHOLD, MAX_ACOMP_THRESHOLD, 1,
DEFAULT_ACOMP_THRESHOLD);
sdev->compression_attack_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_ATTACK_TIME, 0,
MAX_ACOMP_ATTACK_TIME, 500, DEFAULT_ACOMP_ATIME);
sdev->compression_release_time = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_AUDIO_COMPRESSION_RELEASE_TIME, 100000,
MAX_ACOMP_RELEASE_TIME, 100000, DEFAULT_ACOMP_RTIME);
sdev->pilot_tone_enabled = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_ENABLED, 0, 1, 1, 1);
sdev->pilot_tone_deviation = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_DEVIATION, 0, MAX_PILOT_DEVIATION,
10, DEFAULT_PILOT_DEVIATION);
sdev->pilot_tone_freq = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_PILOT_TONE_FREQUENCY, 0, MAX_PILOT_FREQUENCY,
1, DEFAULT_PILOT_FREQUENCY);
sdev->tune_preemphasis = v4l2_ctrl_new_std_menu(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_PREEMPHASIS,
V4L2_PREEMPHASIS_75_uS, 0, V4L2_PREEMPHASIS_50_uS);
sdev->tune_pwr_level = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_POWER_LEVEL, 0, SI4713_MAX_POWER,
1, DEFAULT_POWER_LEVEL);
sdev->tune_ant_cap = v4l2_ctrl_new_std(hdl, &si4713_ctrl_ops,
V4L2_CID_TUNE_ANTENNA_CAPACITOR, 0, SI4713_MAX_ANTCAP,
1, 0);
if (hdl->error) {
rval = hdl->error;
goto free_ctrls;
}
v4l2_ctrl_cluster(29, &sdev->mute);
sdev->sd.ctrl_handler = hdl;
if (client->irq) {
rval = devm_request_irq(&client->dev, client->irq,
si4713_handler, IRQF_TRIGGER_FALLING,
client->name, sdev);
if (rval < 0) {
v4l2_err(&sdev->sd, "Could not request IRQ\n");
goto free_ctrls;
}
v4l2_dbg(1, debug, &sdev->sd, "IRQ requested.\n");
} else {
v4l2_warn(&sdev->sd, "IRQ not configured. Using timeouts.\n");
}
rval = si4713_initialize(sdev);
if (rval < 0) {
v4l2_err(&sdev->sd, "Failed to probe device information.\n");
goto free_ctrls;
}
if (!np && (!pdata || !pdata->is_platform_device))
return 0;
si4713_pdev = platform_device_alloc("radio-si4713", -1);
if (!si4713_pdev) {
rval = -ENOMEM;
goto put_main_pdev;
}
si4713_pdev_pdata.subdev = client;
rval = platform_device_add_data(si4713_pdev, &si4713_pdev_pdata,
sizeof(si4713_pdev_pdata));
if (rval)
goto put_main_pdev;
rval = platform_device_add(si4713_pdev);
if (rval)
goto put_main_pdev;
sdev->pd = si4713_pdev;
return 0;
put_main_pdev:
platform_device_put(si4713_pdev);
v4l2_device_unregister_subdev(&sdev->sd);
free_ctrls:
v4l2_ctrl_handler_free(hdl);
exit:
return rval;
}
static int mt9m032_setup_pll(struct mt9m032 *sensor)
{
static const struct aptina_pll_limits limits = {
.ext_clock_min = 8000000,
.ext_clock_max = 16500000,
.int_clock_min = 2000000,
.int_clock_max = 24000000,
.out_clock_min = 322000000,
.out_clock_max = 693000000,
.pix_clock_max = 99000000,
.n_min = 1,
.n_max = 64,
.m_min = 16,
.m_max = 255,
.p1_min = 6,
.p1_max = 7,
};
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
struct mt9m032_platform_data *pdata = sensor->pdata;
struct aptina_pll pll;
u16 reg_val;
int ret;
pll.ext_clock = pdata->ext_clock;
pll.pix_clock = pdata->pix_clock;
ret = aptina_pll_calculate(&client->dev, &limits, &pll);
if (ret < 0)
return ret;
sensor->pix_clock = pdata->pix_clock;
ret = mt9m032_write(client, MT9M032_PLL_CONFIG1,
(pll.m << MT9M032_PLL_CONFIG1_MUL_SHIFT) |
((pll.n - 1) & MT9M032_PLL_CONFIG1_PREDIV_MASK));
if (!ret)
ret = mt9m032_write(client, MT9P031_PLL_CONTROL,
MT9P031_PLL_CONTROL_PWRON |
MT9P031_PLL_CONTROL_USEPLL);
if (!ret) /* more reserved, Continuous, Master Mode */
ret = mt9m032_write(client, MT9M032_READ_MODE1, 0x8000 |
MT9M032_READ_MODE1_STROBE_START_EXP |
MT9M032_READ_MODE1_STROBE_END_SHUTTER);
if (!ret) {
reg_val = (pll.p1 == 6 ? MT9M032_FORMATTER1_PLL_P1_6 : 0)
| MT9M032_FORMATTER1_PARALLEL | 0x001e; /* 14-bit */
ret = mt9m032_write(client, MT9M032_FORMATTER1, reg_val);
}
return ret;
}
/* -----------------------------------------------------------------------------
* Subdev pad operations
*/
static int mt9m032_enum_mbus_code(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_mbus_code_enum *code)
{
if (code->index != 0)
return -EINVAL;
code->code = V4L2_MBUS_FMT_Y8_1X8;
return 0;
}
static int mt9m032_enum_frame_size(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_frame_size_enum *fse)
{
if (fse->index != 0 || fse->code != V4L2_MBUS_FMT_Y8_1X8)
return -EINVAL;
fse->min_width = MT9M032_COLUMN_SIZE_DEF;
fse->max_width = MT9M032_COLUMN_SIZE_DEF;
fse->min_height = MT9M032_ROW_SIZE_DEF;
fse->max_height = MT9M032_ROW_SIZE_DEF;
return 0;
}
/**
* __mt9m032_get_pad_crop() - get crop rect
* @sensor: pointer to the sensor struct
* @fh: file handle for getting the try crop rect from
* @which: select try or active crop rect
*
* Returns a pointer the current active or fh relative try crop rect
*/
static struct v4l2_rect *
__mt9m032_get_pad_crop(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
enum v4l2_subdev_format_whence which)
{
switch (which) {
case V4L2_SUBDEV_FORMAT_TRY:
return v4l2_subdev_get_try_crop(fh, 0);
case V4L2_SUBDEV_FORMAT_ACTIVE:
return &sensor->crop;
default:
return NULL;
}
}
/**
* __mt9m032_get_pad_format() - get format
* @sensor: pointer to the sensor struct
* @fh: file handle for getting the try format from
* @which: select try or active format
*
* Returns a pointer the current active or fh relative try format
*/
static struct v4l2_mbus_framefmt *
__mt9m032_get_pad_format(struct mt9m032 *sensor, struct v4l2_subdev_fh *fh,
enum v4l2_subdev_format_whence which)
{
switch (which) {
case V4L2_SUBDEV_FORMAT_TRY:
return v4l2_subdev_get_try_format(fh, 0);
case V4L2_SUBDEV_FORMAT_ACTIVE:
return &sensor->format;
default:
return NULL;
}
}
static int mt9m032_get_pad_format(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_format *fmt)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_pad_format(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_format *fmt)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
if (sensor->streaming && fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
ret = -EBUSY;
goto done;
}
/* Scaling is not supported, the format is thus fixed. */
fmt->format = *__mt9m032_get_pad_format(sensor, fh, fmt->which);
ret = 0;
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_get_pad_crop(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_crop *crop)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
crop->rect = *__mt9m032_get_pad_crop(sensor, fh, crop->which);
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_pad_crop(struct v4l2_subdev *subdev,
struct v4l2_subdev_fh *fh,
struct v4l2_subdev_crop *crop)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
struct v4l2_mbus_framefmt *format;
struct v4l2_rect *__crop;
struct v4l2_rect rect;
int ret = 0;
mutex_lock(&sensor->lock);
if (sensor->streaming && crop->which == V4L2_SUBDEV_FORMAT_ACTIVE) {
ret = -EBUSY;
goto done;
}
/* Clamp the crop rectangle boundaries and align them to a multiple of 2
* pixels to ensure a GRBG Bayer pattern.
*/
rect.left = clamp(ALIGN(crop->rect.left, 2), MT9M032_COLUMN_START_MIN,
MT9M032_COLUMN_START_MAX);
rect.top = clamp(ALIGN(crop->rect.top, 2), MT9M032_ROW_START_MIN,
MT9M032_ROW_START_MAX);
rect.width = clamp(ALIGN(crop->rect.width, 2), MT9M032_COLUMN_SIZE_MIN,
MT9M032_COLUMN_SIZE_MAX);
rect.height = clamp(ALIGN(crop->rect.height, 2), MT9M032_ROW_SIZE_MIN,
MT9M032_ROW_SIZE_MAX);
rect.width = min(rect.width, MT9M032_PIXEL_ARRAY_WIDTH - rect.left);
rect.height = min(rect.height, MT9M032_PIXEL_ARRAY_HEIGHT - rect.top);
__crop = __mt9m032_get_pad_crop(sensor, fh, crop->which);
if (rect.width != __crop->width || rect.height != __crop->height) {
/* Reset the output image size if the crop rectangle size has
* been modified.
*/
format = __mt9m032_get_pad_format(sensor, fh, crop->which);
format->width = rect.width;
format->height = rect.height;
}
*__crop = rect;
crop->rect = rect;
if (crop->which == V4L2_SUBDEV_FORMAT_ACTIVE)
ret = mt9m032_update_geom_timing(sensor);
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_get_frame_interval(struct v4l2_subdev *subdev,
struct v4l2_subdev_frame_interval *fi)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
mutex_lock(&sensor->lock);
memset(fi, 0, sizeof(*fi));
fi->interval = sensor->frame_interval;
mutex_unlock(&sensor->lock);
return 0;
}
static int mt9m032_set_frame_interval(struct v4l2_subdev *subdev,
struct v4l2_subdev_frame_interval *fi)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
if (sensor->streaming) {
ret = -EBUSY;
goto done;
}
/* Avoid divisions by 0. */
if (fi->interval.denominator == 0)
fi->interval.denominator = 1;
ret = mt9m032_update_timing(sensor, &fi->interval);
if (!ret)
sensor->frame_interval = fi->interval;
done:
mutex_unlock(&sensor->lock);
return ret;
}
static int mt9m032_s_stream(struct v4l2_subdev *subdev, int streaming)
{
struct mt9m032 *sensor = to_mt9m032(subdev);
int ret;
mutex_lock(&sensor->lock);
ret = update_formatter2(sensor, streaming);
if (!ret)
sensor->streaming = streaming;
mutex_unlock(&sensor->lock);
return ret;
}
/* -----------------------------------------------------------------------------
* V4L2 subdev core operations
*/
#ifdef CONFIG_VIDEO_ADV_DEBUG
static int mt9m032_g_register(struct v4l2_subdev *sd,
struct v4l2_dbg_register *reg)
{
struct mt9m032 *sensor = to_mt9m032(sd);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int val;
if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
return -EINVAL;
if (reg->match.addr != client->addr)
return -ENODEV;
val = mt9m032_read(client, reg->reg);
if (val < 0)
return -EIO;
reg->size = 2;
reg->val = val;
return 0;
}
static int mt9m032_s_register(struct v4l2_subdev *sd,
const struct v4l2_dbg_register *reg)
{
struct mt9m032 *sensor = to_mt9m032(sd);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
if (reg->match.type != V4L2_CHIP_MATCH_I2C_ADDR || reg->reg > 0xff)
return -EINVAL;
if (reg->match.addr != client->addr)
return -ENODEV;
return mt9m032_write(client, reg->reg, reg->val);
}
#endif
/* -----------------------------------------------------------------------------
* V4L2 subdev control operations
*/
static int update_read_mode2(struct mt9m032 *sensor, bool vflip, bool hflip)
{
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int reg_val = (vflip << MT9M032_READ_MODE2_VFLIP_SHIFT)
| (hflip << MT9M032_READ_MODE2_HFLIP_SHIFT)
| MT9M032_READ_MODE2_ROW_BLC
| 0x0007;
return mt9m032_write(client, MT9M032_READ_MODE2, reg_val);
}
static int mt9m032_set_gain(struct mt9m032 *sensor, s32 val)
{
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int digital_gain_val; /* in 1/8th (0..127) */
int analog_mul; /* 0 or 1 */
int analog_gain_val; /* in 1/16th. (0..63) */
u16 reg_val;
digital_gain_val = 51; /* from setup example */
if (val < 63) {
analog_mul = 0;
analog_gain_val = val;
} else {
analog_mul = 1;
analog_gain_val = val / 2;
}
/* a_gain = (1 + analog_mul) + (analog_gain_val + 1) / 16 */
/* overall_gain = a_gain * (1 + digital_gain_val / 8) */
reg_val = ((digital_gain_val & MT9M032_GAIN_DIGITAL_MASK)
<< MT9M032_GAIN_DIGITAL_SHIFT)
| ((analog_mul & 1) << MT9M032_GAIN_AMUL_SHIFT)
| (analog_gain_val & MT9M032_GAIN_ANALOG_MASK);
return mt9m032_write(client, MT9M032_GAIN_ALL, reg_val);
}
static int mt9m032_try_ctrl(struct v4l2_ctrl *ctrl)
{
if (ctrl->id == V4L2_CID_GAIN && ctrl->val >= 63) {
/* round because of multiplier used for values >= 63 */
ctrl->val &= ~1;
}
return 0;
}
static int mt9m032_set_ctrl(struct v4l2_ctrl *ctrl)
{
struct mt9m032 *sensor =
container_of(ctrl->handler, struct mt9m032, ctrls);
struct i2c_client *client = v4l2_get_subdevdata(&sensor->subdev);
int ret;
switch (ctrl->id) {
case V4L2_CID_GAIN:
return mt9m032_set_gain(sensor, ctrl->val);
case V4L2_CID_HFLIP:
/* case V4L2_CID_VFLIP: -- In the same cluster */
return update_read_mode2(sensor, sensor->vflip->val,
sensor->hflip->val);
case V4L2_CID_EXPOSURE:
ret = mt9m032_write(client, MT9M032_SHUTTER_WIDTH_HIGH,
(ctrl->val >> 16) & 0xffff);
if (ret < 0)
return ret;
return mt9m032_write(client, MT9M032_SHUTTER_WIDTH_LOW,
ctrl->val & 0xffff);
}
return 0;
}
static struct v4l2_ctrl_ops mt9m032_ctrl_ops = {
.s_ctrl = mt9m032_set_ctrl,
.try_ctrl = mt9m032_try_ctrl,
};
/* -------------------------------------------------------------------------- */
static const struct v4l2_subdev_core_ops mt9m032_core_ops = {
#ifdef CONFIG_VIDEO_ADV_DEBUG
.g_register = mt9m032_g_register,
.s_register = mt9m032_s_register,
#endif
};
static const struct v4l2_subdev_video_ops mt9m032_video_ops = {
.s_stream = mt9m032_s_stream,
.g_frame_interval = mt9m032_get_frame_interval,
.s_frame_interval = mt9m032_set_frame_interval,
};
static const struct v4l2_subdev_pad_ops mt9m032_pad_ops = {
.enum_mbus_code = mt9m032_enum_mbus_code,
.enum_frame_size = mt9m032_enum_frame_size,
.get_fmt = mt9m032_get_pad_format,
.set_fmt = mt9m032_set_pad_format,
.set_crop = mt9m032_set_pad_crop,
.get_crop = mt9m032_get_pad_crop,
};
static const struct v4l2_subdev_ops mt9m032_ops = {
.core = &mt9m032_core_ops,
.video = &mt9m032_video_ops,
.pad = &mt9m032_pad_ops,
};
/* -----------------------------------------------------------------------------
* Driver initialization and probing
*/
static int mt9m032_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct mt9m032_platform_data *pdata = client->dev.platform_data;
struct i2c_adapter *adapter = client->adapter;
struct mt9m032 *sensor;
int chip_version;
int ret;
if (pdata == NULL) {
dev_err(&client->dev, "No platform data\n");
return -EINVAL;
}
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
dev_warn(&client->dev,
"I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
return -EIO;
}
if (!client->dev.platform_data)
return -ENODEV;
sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
if (sensor == NULL)
return -ENOMEM;
mutex_init(&sensor->lock);
sensor->pdata = pdata;
v4l2_i2c_subdev_init(&sensor->subdev, client, &mt9m032_ops);
sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
chip_version = mt9m032_read(client, MT9M032_CHIP_VERSION);
if (chip_version != MT9M032_CHIP_VERSION_VALUE) {
dev_err(&client->dev, "MT9M032 not detected, wrong version "
"0x%04x\n", chip_version);
ret = -ENODEV;
goto error_sensor;
}
dev_info(&client->dev, "MT9M032 detected at address 0x%02x\n",
client->addr);
sensor->frame_interval.numerator = 1;
sensor->frame_interval.denominator = 30;
sensor->crop.left = MT9M032_COLUMN_START_DEF;
sensor->crop.top = MT9M032_ROW_START_DEF;
sensor->crop.width = MT9M032_COLUMN_SIZE_DEF;
sensor->crop.height = MT9M032_ROW_SIZE_DEF;
sensor->format.width = sensor->crop.width;
sensor->format.height = sensor->crop.height;
sensor->format.code = V4L2_MBUS_FMT_Y8_1X8;
sensor->format.field = V4L2_FIELD_NONE;
sensor->format.colorspace = V4L2_COLORSPACE_SRGB;
v4l2_ctrl_handler_init(&sensor->ctrls, 5);
v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
V4L2_CID_GAIN, 0, 127, 1, 64);
sensor->hflip = v4l2_ctrl_new_std(&sensor->ctrls,
&mt9m032_ctrl_ops,
V4L2_CID_HFLIP, 0, 1, 1, 0);
sensor->vflip = v4l2_ctrl_new_std(&sensor->ctrls,
&mt9m032_ctrl_ops,
V4L2_CID_VFLIP, 0, 1, 1, 0);
v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
V4L2_CID_EXPOSURE, MT9M032_SHUTTER_WIDTH_MIN,
MT9M032_SHUTTER_WIDTH_MAX, 1,
MT9M032_SHUTTER_WIDTH_DEF);
v4l2_ctrl_new_std(&sensor->ctrls, &mt9m032_ctrl_ops,
V4L2_CID_PIXEL_RATE, pdata->pix_clock,
pdata->pix_clock, 1, pdata->pix_clock);
if (sensor->ctrls.error) {
ret = sensor->ctrls.error;
dev_err(&client->dev, "control initialization error %d\n", ret);
goto error_ctrl;
}
v4l2_ctrl_cluster(2, &sensor->hflip);
sensor->subdev.ctrl_handler = &sensor->ctrls;
sensor->pad.flags = MEDIA_PAD_FL_SOURCE;
ret = media_entity_init(&sensor->subdev.entity, 1, &sensor->pad, 0);
if (ret < 0)
goto error_ctrl;
ret = mt9m032_write(client, MT9M032_RESET, 1); /* reset on */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, MT9M032_RESET, 0); /* reset off */
if (ret < 0)
goto error_entity;
ret = mt9m032_setup_pll(sensor);
if (ret < 0)
goto error_entity;
usleep_range(10000, 11000);
ret = v4l2_ctrl_handler_setup(&sensor->ctrls);
if (ret < 0)
goto error_entity;
/* SIZE */
ret = mt9m032_update_geom_timing(sensor);
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x41, 0x0000); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x42, 0x0003); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x43, 0x0003); /* reserved !!! */
if (ret < 0)
goto error_entity;
ret = mt9m032_write(client, 0x7f, 0x0000); /* reserved !!! */
if (ret < 0)
goto error_entity;
if (sensor->pdata->invert_pixclock) {
ret = mt9m032_write(client, MT9M032_PIX_CLK_CTRL,
MT9M032_PIX_CLK_CTRL_INV_PIXCLK);
if (ret < 0)
goto error_entity;
}
ret = mt9m032_write(client, MT9M032_RESTART, 1); /* Restart on */
if (ret < 0)
goto error_entity;
msleep(100);
ret = mt9m032_write(client, MT9M032_RESTART, 0); /* Restart off */
if (ret < 0)
goto error_entity;
msleep(100);
ret = update_formatter2(sensor, false);
if (ret < 0)
goto error_entity;
return ret;
error_entity:
media_entity_cleanup(&sensor->subdev.entity);
error_ctrl:
v4l2_ctrl_handler_free(&sensor->ctrls);
error_sensor:
mutex_destroy(&sensor->lock);
kfree(sensor);
return ret;
}
static int mt9m032_remove(struct i2c_client *client)
{
struct v4l2_subdev *subdev = i2c_get_clientdata(client);
struct mt9m032 *sensor = to_mt9m032(subdev);
v4l2_device_unregister_subdev(subdev);
v4l2_ctrl_handler_free(&sensor->ctrls);
media_entity_cleanup(&subdev->entity);
mutex_destroy(&sensor->lock);
kfree(sensor);
return 0;
}
static const struct i2c_device_id mt9m032_id_table[] = {
{ MT9M032_NAME, 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, mt9m032_id_table);
static struct i2c_driver mt9m032_i2c_driver = {
.driver = {
.name = MT9M032_NAME,
},
.probe = mt9m032_probe,
.remove = mt9m032_remove,
.id_table = mt9m032_id_table,
};
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_out = &dev->ctrl_hdl_loop_out;
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_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_out, 1);
v4l2_ctrl_new_custom(hdl_loop_out, &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);
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);
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, 18);
v4l2_ctrl_new_custom(hdl_sdr_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_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);
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_ycbcr_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);
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 (has_hdmi && dev->has_vid_cap) {
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);
}
if (has_hdmi && dev->has_vid_out) {
/*
* 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);
}
if ((dev->has_vid_cap && dev->has_vid_out) ||
(dev->has_vbi_cap && dev->has_vbi_out))
v4l2_ctrl_new_custom(hdl_loop_out, &vivid_ctrl_loop_video, NULL);
if (dev->has_fb)
v4l2_ctrl_new_custom(hdl_user_gen, &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 (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_out->error)
return hdl_loop_out->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);
v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_vid, NULL);
v4l2_ctrl_add_handler(hdl_vid_cap, hdl_user_aud, NULL);
v4l2_ctrl_add_handler(hdl_vid_cap, hdl_streaming, NULL);
v4l2_ctrl_add_handler(hdl_vid_cap, hdl_sdtv_cap, NULL);
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);
v4l2_ctrl_add_handler(hdl_vid_out, hdl_user_aud, NULL);
v4l2_ctrl_add_handler(hdl_vid_out, hdl_streaming, NULL);
v4l2_ctrl_add_handler(hdl_vid_out, hdl_loop_out, NULL);
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);
v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_streaming, NULL);
v4l2_ctrl_add_handler(hdl_vbi_cap, hdl_sdtv_cap, NULL);
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);
v4l2_ctrl_add_handler(hdl_vbi_out, hdl_streaming, NULL);
v4l2_ctrl_add_handler(hdl_vbi_out, hdl_loop_out, NULL);
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);
v4l2_ctrl_add_handler(hdl_radio_rx, hdl_user_aud, NULL);
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);
v4l2_ctrl_add_handler(hdl_radio_tx, hdl_user_aud, NULL);
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);
v4l2_ctrl_add_handler(hdl_sdr_cap, hdl_streaming, NULL);
if (hdl_sdr_cap->error)
return hdl_sdr_cap->error;
dev->sdr_cap_dev.ctrl_handler = hdl_sdr_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_out);
}
static int radio_isa_common_probe(struct radio_isa_card *isa,
struct device *pdev,
int radio_nr, unsigned region_size)
{
const struct radio_isa_driver *drv = isa->drv;
const struct radio_isa_ops *ops = drv->ops;
struct v4l2_device *v4l2_dev = &isa->v4l2_dev;
int res;
if (!request_region(isa->io, region_size, v4l2_dev->name)) {
v4l2_err(v4l2_dev, "port 0x%x already in use\n", isa->io);
kfree(isa);
return -EBUSY;
}
res = v4l2_device_register(pdev, v4l2_dev);
if (res < 0) {
v4l2_err(v4l2_dev, "Could not register v4l2_device\n");
goto err_dev_reg;
}
v4l2_ctrl_handler_init(&isa->hdl, 1);
isa->mute = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
V4L2_CID_AUDIO_MUTE, 0, 1, 1, 1);
if (drv->max_volume)
isa->volume = v4l2_ctrl_new_std(&isa->hdl, &radio_isa_ctrl_ops,
V4L2_CID_AUDIO_VOLUME, 0, drv->max_volume, 1,
drv->max_volume);
v4l2_dev->ctrl_handler = &isa->hdl;
if (isa->hdl.error) {
res = isa->hdl.error;
v4l2_err(v4l2_dev, "Could not register controls\n");
goto err_hdl;
}
if (drv->max_volume)
v4l2_ctrl_cluster(2, &isa->mute);
v4l2_dev->ctrl_handler = &isa->hdl;
mutex_init(&isa->lock);
isa->vdev.lock = &isa->lock;
strscpy(isa->vdev.name, v4l2_dev->name, sizeof(isa->vdev.name));
isa->vdev.v4l2_dev = v4l2_dev;
isa->vdev.fops = &radio_isa_fops;
isa->vdev.ioctl_ops = &radio_isa_ioctl_ops;
isa->vdev.release = video_device_release_empty;
video_set_drvdata(&isa->vdev, isa);
isa->freq = FREQ_LOW;
isa->stereo = drv->has_stereo;
if (ops->init)
res = ops->init(isa);
if (!res)
res = v4l2_ctrl_handler_setup(&isa->hdl);
if (!res)
res = ops->s_frequency(isa, isa->freq);
if (!res && ops->s_stereo)
res = ops->s_stereo(isa, isa->stereo);
if (res < 0) {
v4l2_err(v4l2_dev, "Could not setup card\n");
goto err_hdl;
}
res = video_register_device(&isa->vdev, VFL_TYPE_RADIO, radio_nr);
if (res < 0) {
v4l2_err(v4l2_dev, "Could not register device node\n");
goto err_hdl;
}
v4l2_info(v4l2_dev, "Initialized radio card %s on port 0x%03x\n",
drv->card, isa->io);
return 0;
err_hdl:
v4l2_ctrl_handler_free(&isa->hdl);
err_dev_reg:
release_region(isa->io, region_size);
kfree(isa);
return res;
}
/******************************************************************************
*
* cpia2_register_camera
*
*****************************************************************************/
int cpia2_register_camera(struct camera_data *cam)
{
struct v4l2_ctrl_handler *hdl = &cam->hdl;
struct v4l2_ctrl_config cpia2_usb_alt = {
.ops = &cpia2_ctrl_ops,
.id = CPIA2_CID_USB_ALT,
.name = "USB Alternate",
.type = V4L2_CTRL_TYPE_INTEGER,
.min = USBIF_ISO_1,
.max = USBIF_ISO_6,
.step = 1,
};
int ret;
v4l2_ctrl_handler_init(hdl, 12);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_BRIGHTNESS,
cam->params.pnp_id.device_type == DEVICE_STV_672 ? 1 : 0,
255, 1, DEFAULT_BRIGHTNESS);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_CONTRAST, 0, 255, 1, DEFAULT_CONTRAST);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_SATURATION, 0, 255, 1, DEFAULT_SATURATION);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_HFLIP, 0, 1, 1, 0);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_JPEG_ACTIVE_MARKER, 0,
V4L2_JPEG_ACTIVE_MARKER_DHT, 0,
V4L2_JPEG_ACTIVE_MARKER_DHT);
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_JPEG_COMPRESSION_QUALITY, 1,
100, 1, 100);
cpia2_usb_alt.def = alternate;
cam->usb_alt = v4l2_ctrl_new_custom(hdl, &cpia2_usb_alt, NULL);
/* VP5 Only */
if (cam->params.pnp_id.device_type != DEVICE_STV_672)
v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_VFLIP, 0, 1, 1, 0);
/* Flicker control only valid for 672 */
if (cam->params.pnp_id.device_type == DEVICE_STV_672)
v4l2_ctrl_new_std_menu(hdl, &cpia2_ctrl_ops,
V4L2_CID_POWER_LINE_FREQUENCY,
V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0, 0);
/* Light control only valid for the QX5 Microscope */
if (cam->params.pnp_id.product == 0x151) {
cam->top_light = v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_ILLUMINATORS_1, 0, 1, 1, 0);
cam->bottom_light = v4l2_ctrl_new_std(hdl, &cpia2_ctrl_ops,
V4L2_CID_ILLUMINATORS_2, 0, 1, 1, 0);
v4l2_ctrl_cluster(2, &cam->top_light);
}
if (hdl->error) {
ret = hdl->error;
v4l2_ctrl_handler_free(hdl);
return ret;
}
cam->vdev = cpia2_template;
video_set_drvdata(&cam->vdev, cam);
cam->vdev.lock = &cam->v4l2_lock;
cam->vdev.ctrl_handler = hdl;
cam->vdev.v4l2_dev = &cam->v4l2_dev;
reset_camera_struct_v4l(cam);
/* register v4l device */
if (video_register_device(&cam->vdev, VFL_TYPE_GRABBER, video_nr) < 0) {
ERR("video_register_device failed\n");
return -ENODEV;
}
return 0;
}
/******************************************************************************
*
* cpia2_unregister_camera
*
*****************************************************************************/
void cpia2_unregister_camera(struct camera_data *cam)
{
video_unregister_device(&cam->vdev);
}
