Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 676fdd85 authored by Hans de Goede's avatar Hans de Goede Committed by Mauro Carvalho Chehab
Browse files

[media] gscpa_gl860: Convert to the control framework 



Signed-off-by: default avatarHans de Goede <hdegoede@redhat.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@redhat.com>
parent c1f07ab2

drivers/media/usb/gspca/gl860/gl860.c

+119 −103
Original line number Diff line number Diff line
@@ -58,115 +58,135 @@ MODULE_PARM_DESC(sensor, 


/*============================ webcam controls =============================*/



/* Functions to get and set a control value */

#define SD_SETGET(thename) \

static int sd_set_##thename(struct gspca_dev *gspca_dev, s32 val)\

{\

	struct sd *sd = (struct sd *) gspca_dev;\

\

	sd->vcur.thename = val;\

	if (gspca_dev->streaming)\

		sd->waitSet = 1;\

	return 0;\

} \

static int sd_get_##thename(struct gspca_dev *gspca_dev, s32 *val)\

{\

	struct sd *sd = (struct sd *) gspca_dev;\

\

	*val = sd->vcur.thename;\

	return 0;\

}



SD_SETGET(mirror)

SD_SETGET(flip)

SD_SETGET(AC50Hz)

SD_SETGET(backlight)

SD_SETGET(brightness)

SD_SETGET(gamma)

SD_SETGET(hue)

SD_SETGET(saturation)

SD_SETGET(sharpness)

SD_SETGET(whitebal)

SD_SETGET(contrast)



#define GL860_NCTRLS 11



/* control table */

static struct ctrl sd_ctrls_mi1320[GL860_NCTRLS];

static struct ctrl sd_ctrls_mi2020[GL860_NCTRLS];

static struct ctrl sd_ctrls_ov2640[GL860_NCTRLS];

static struct ctrl sd_ctrls_ov9655[GL860_NCTRLS];



#define SET_MY_CTRL(theid, \

	thetype, thelabel, thename) \

	if (sd->vmax.thename != 0) {\

		sd_ctrls[nCtrls].qctrl.id   = theid;\

		sd_ctrls[nCtrls].qctrl.type = thetype;\

		strcpy(sd_ctrls[nCtrls].qctrl.name, thelabel);\

		sd_ctrls[nCtrls].qctrl.minimum = 0;\

		sd_ctrls[nCtrls].qctrl.maximum = sd->vmax.thename;\

		sd_ctrls[nCtrls].qctrl.default_value = sd->vcur.thename;\

		sd_ctrls[nCtrls].qctrl.step = \

			(sd->vmax.thename < 16) ? 1 : sd->vmax.thename/16;\

		sd_ctrls[nCtrls].set = sd_set_##thename;\

		sd_ctrls[nCtrls].get = sd_get_##thename;\

		nCtrls++;\

	}



static int gl860_build_control_table(struct gspca_dev *gspca_dev)

static int sd_s_ctrl(struct v4l2_ctrl *ctrl)

{

	struct gspca_dev *gspca_dev =

		container_of(ctrl->handler, struct gspca_dev, ctrl_handler);

	struct sd *sd = (struct sd *) gspca_dev;

	struct ctrl *sd_ctrls;

	int nCtrls = 0;



	if (_MI1320_)

		sd_ctrls = sd_ctrls_mi1320;

	else if (_MI2020_)

		sd_ctrls = sd_ctrls_mi2020;

	else if (_OV2640_)

		sd_ctrls = sd_ctrls_ov2640;

	else if (_OV9655_)

		sd_ctrls = sd_ctrls_ov9655;

	else



	switch (ctrl->id) {

	case V4L2_CID_BRIGHTNESS:

		sd->vcur.brightness = ctrl->val;

		break;

	case V4L2_CID_CONTRAST:

		sd->vcur.contrast = ctrl->val;

		break;

	case V4L2_CID_SATURATION:

		sd->vcur.saturation = ctrl->val;

		break;

	case V4L2_CID_HUE:

		sd->vcur.hue = ctrl->val;

		break;

	case V4L2_CID_GAMMA:

		sd->vcur.gamma = ctrl->val;

		break;

	case V4L2_CID_HFLIP:

		sd->vcur.mirror = ctrl->val;

		break;

	case V4L2_CID_VFLIP:

		sd->vcur.flip = ctrl->val;

		break;

	case V4L2_CID_POWER_LINE_FREQUENCY:

		sd->vcur.AC50Hz = ctrl->val;

		break;

	case V4L2_CID_WHITE_BALANCE_TEMPERATURE:

		sd->vcur.whitebal = ctrl->val;

		break;

	case V4L2_CID_SHARPNESS:

		sd->vcur.sharpness = ctrl->val;

		break;

	case V4L2_CID_BACKLIGHT_COMPENSATION:

		sd->vcur.backlight = ctrl->val;

		break;

	default:

		return -EINVAL;

	}



	if (gspca_dev->streaming)

		sd->waitSet = 1;



	return 0;

}



	memset(sd_ctrls, 0, GL860_NCTRLS * sizeof(struct ctrl));



	SET_MY_CTRL(V4L2_CID_BRIGHTNESS,

		V4L2_CTRL_TYPE_INTEGER, "Brightness", brightness)

	SET_MY_CTRL(V4L2_CID_SHARPNESS,

		V4L2_CTRL_TYPE_INTEGER, "Sharpness", sharpness)

	SET_MY_CTRL(V4L2_CID_CONTRAST,

		V4L2_CTRL_TYPE_INTEGER, "Contrast", contrast)

	SET_MY_CTRL(V4L2_CID_GAMMA,

		V4L2_CTRL_TYPE_INTEGER, "Gamma", gamma)

	SET_MY_CTRL(V4L2_CID_HUE,

		V4L2_CTRL_TYPE_INTEGER, "Palette", hue)

	SET_MY_CTRL(V4L2_CID_SATURATION,

		V4L2_CTRL_TYPE_INTEGER, "Saturation", saturation)

	SET_MY_CTRL(V4L2_CID_WHITE_BALANCE_TEMPERATURE,

		V4L2_CTRL_TYPE_INTEGER, "White Bal.", whitebal)

	SET_MY_CTRL(V4L2_CID_BACKLIGHT_COMPENSATION,

		V4L2_CTRL_TYPE_INTEGER, "Backlight" , backlight)



	SET_MY_CTRL(V4L2_CID_HFLIP,

		V4L2_CTRL_TYPE_BOOLEAN, "Mirror", mirror)

	SET_MY_CTRL(V4L2_CID_VFLIP,

		V4L2_CTRL_TYPE_BOOLEAN, "Flip", flip)

	SET_MY_CTRL(V4L2_CID_POWER_LINE_FREQUENCY,

		V4L2_CTRL_TYPE_BOOLEAN, "AC power 50Hz", AC50Hz)



	return nCtrls;

static const struct v4l2_ctrl_ops sd_ctrl_ops = {

	.s_ctrl = sd_s_ctrl,

};



static int sd_init_controls(struct gspca_dev *gspca_dev)

{

	struct sd *sd = (struct sd *) gspca_dev;

	struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;



	gspca_dev->vdev.ctrl_handler = hdl;

	v4l2_ctrl_handler_init(hdl, 11);



	if (sd->vmax.brightness)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_BRIGHTNESS,

				  0, sd->vmax.brightness, 1,

				  sd->vcur.brightness);



	if (sd->vmax.contrast)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_CONTRAST,

				  0, sd->vmax.contrast, 1,

				  sd->vcur.contrast);



	if (sd->vmax.saturation)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SATURATION,

				  0, sd->vmax.saturation, 1,

				  sd->vcur.saturation);



	if (sd->vmax.hue)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HUE,

				  0, sd->vmax.hue, 1, sd->vcur.hue);



	if (sd->vmax.gamma)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_GAMMA,

				  0, sd->vmax.gamma, 1, sd->vcur.gamma);



	if (sd->vmax.mirror)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_HFLIP,

				  0, sd->vmax.mirror, 1, sd->vcur.mirror);



	if (sd->vmax.flip)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_VFLIP,

				  0, sd->vmax.flip, 1, sd->vcur.flip);



	if (sd->vmax.AC50Hz)

		v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,

				  V4L2_CID_POWER_LINE_FREQUENCY,

				  sd->vmax.AC50Hz, 0, sd->vcur.AC50Hz);



	if (sd->vmax.whitebal)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,

				  V4L2_CID_WHITE_BALANCE_TEMPERATURE,

				  0, sd->vmax.whitebal, 1, sd->vcur.whitebal);



	if (sd->vmax.sharpness)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, V4L2_CID_SHARPNESS,

				  0, sd->vmax.sharpness, 1,

				  sd->vcur.sharpness);



	if (sd->vmax.backlight)

		v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,

				  V4L2_CID_BACKLIGHT_COMPENSATION,

				  0, sd->vmax.backlight, 1,

				  sd->vcur.backlight);



	if (hdl->error) {

		pr_err("Could not initialize controls\n");

		return hdl->error;

	}



	return 0;

}



/*==================== sud-driver structure initialisation =================*/



static const struct sd_desc sd_desc_mi1320 = {

	.name        = MODULE_NAME,

	.ctrls       = sd_ctrls_mi1320,

	.nctrls      = GL860_NCTRLS,

	.config      = sd_config,

	.init        = sd_init,

	.init_controls = sd_init_controls,

	.isoc_init   = sd_isoc_init,

	.start       = sd_start,

	.stop0       = sd_stop0,
@@ -176,10 +196,9 @@ static const struct sd_desc sd_desc_mi1320 = { 


static const struct sd_desc sd_desc_mi2020 = {

	.name        = MODULE_NAME,

	.ctrls       = sd_ctrls_mi2020,

	.nctrls      = GL860_NCTRLS,

	.config      = sd_config,

	.init        = sd_init,

	.init_controls = sd_init_controls,

	.isoc_init   = sd_isoc_init,

	.start       = sd_start,

	.stop0       = sd_stop0,
@@ -189,10 +208,9 @@ static const struct sd_desc sd_desc_mi2020 = { 


static const struct sd_desc sd_desc_ov2640 = {

	.name        = MODULE_NAME,

	.ctrls       = sd_ctrls_ov2640,

	.nctrls      = GL860_NCTRLS,

	.config      = sd_config,

	.init        = sd_init,

	.init_controls = sd_init_controls,

	.isoc_init   = sd_isoc_init,

	.start       = sd_start,

	.stop0       = sd_stop0,
@@ -202,10 +220,9 @@ static const struct sd_desc sd_desc_ov2640 = { 


static const struct sd_desc sd_desc_ov9655 = {

	.name        = MODULE_NAME,

	.ctrls       = sd_ctrls_ov9655,

	.nctrls      = GL860_NCTRLS,

	.config      = sd_config,

	.init        = sd_init,

	.init_controls = sd_init_controls,

	.isoc_init   = sd_isoc_init,

	.start       = sd_start,

	.stop0       = sd_stop0,
@@ -371,7 +388,6 @@ static int sd_config(struct gspca_dev *gspca_dev, 
	dev_init_settings(gspca_dev);

	if (AC50Hz != 0xff)

		((struct sd *) gspca_dev)->vcur.AC50Hz = AC50Hz;

	gl860_build_control_table(gspca_dev);



	return 0;

}