hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[media] rj54n1cb0c: convert to the control framework 

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
[g.liakhovetski@gmx.de: simplified pointer arithmetic]
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
This commit is contained in:
Hans Verkuil 2011-09-07 05:20:33 -03:00 committed by Mauro Carvalho Chehab
parent 7b9d8c3c4c
commit 25e965ad27
1 changed files with 38 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
drivers/media/video/rj54n1cb0c.c
View File

@ -18,6 +18,7 @@
#include <media/soc_mediabus.h> #include <media/soc_mediabus.h>
#include <media/v4l2-subdev.h> #include <media/v4l2-subdev.h>
#include <media/v4l2-chip-ident.h> #include <media/v4l2-chip-ident.h>
#include <media/v4l2-ctrls.h>
#define RJ54N1_DEV_CODE 0x0400 #define RJ54N1_DEV_CODE 0x0400
#define RJ54N1_DEV_CODE2 0x0401 #define RJ54N1_DEV_CODE2 0x0401
@ -148,6 +149,7 @@ struct rj54n1_clock_div {
struct rj54n1 { struct rj54n1 {
struct v4l2_subdev subdev; struct v4l2_subdev subdev;
struct v4l2_ctrl_handler hdl;
struct rj54n1_clock_div clk_div; struct rj54n1_clock_div clk_div;
const struct rj54n1_datafmt *fmt; const struct rj54n1_datafmt *fmt;
struct v4l2_rect rect; /* Sensor window */ struct v4l2_rect rect; /* Sensor window */
@ -1177,132 +1179,51 @@ static int rj54n1_s_register(struct v4l2_subdev *sd,
} }
#endif #endif
static const struct v4l2_queryctrl rj54n1_controls[] = { static int rj54n1_s_ctrl(struct v4l2_ctrl *ctrl)
{
.id = V4L2_CID_VFLIP,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Flip Vertically",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
}, {
.id = V4L2_CID_HFLIP,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Flip Horizontally",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 0,
}, {
.id = V4L2_CID_GAIN,
.type = V4L2_CTRL_TYPE_INTEGER,
.name = "Gain",
.minimum = 0,
.maximum = 127,
.step = 1,
.default_value = 66,
.flags = V4L2_CTRL_FLAG_SLIDER,
}, {
.id = V4L2_CID_AUTO_WHITE_BALANCE,
.type = V4L2_CTRL_TYPE_BOOLEAN,
.name = "Auto white balance",
.minimum = 0,
.maximum = 1,
.step = 1,
.default_value = 1,
},
};
static struct soc_camera_ops rj54n1_ops = {
.controls = rj54n1_controls,
.num_controls = ARRAY_SIZE(rj54n1_controls),
};
static int rj54n1_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{ {
struct rj54n1 *rj54n1 = container_of(ctrl->handler, struct rj54n1, hdl);
struct v4l2_subdev *sd = &rj54n1->subdev;
struct i2c_client *client = v4l2_get_subdevdata(sd); struct i2c_client *client = v4l2_get_subdevdata(sd);
struct rj54n1 *rj54n1 = to_rj54n1(client);
int data; int data;
switch (ctrl->id) { switch (ctrl->id) {
case V4L2_CID_VFLIP: case V4L2_CID_VFLIP:
data = reg_read(client, RJ54N1_MIRROR_STILL_MODE); if (ctrl->val)
if (data < 0)
return -EIO;
ctrl->value = !(data & 1);
break;
case V4L2_CID_HFLIP:
data = reg_read(client, RJ54N1_MIRROR_STILL_MODE);
if (data < 0)
return -EIO;
ctrl->value = !(data & 2);
break;
case V4L2_CID_GAIN:
data = reg_read(client, RJ54N1_Y_GAIN);
if (data < 0)
return -EIO;
ctrl->value = data / 2;
break;
case V4L2_CID_AUTO_WHITE_BALANCE:
ctrl->value = rj54n1->auto_wb;
break;
}
return 0;
}
static int rj54n1_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
int data;
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct rj54n1 *rj54n1 = to_rj54n1(client);
const struct v4l2_queryctrl *qctrl;
qctrl = soc_camera_find_qctrl(&rj54n1_ops, ctrl->id);
if (!qctrl)
return -EINVAL;
switch (ctrl->id) {
case V4L2_CID_VFLIP:
if (ctrl->value)
data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 1); data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 1);
else else
data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 1, 1); data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 1, 1);
if (data < 0) if (data < 0)
return -EIO; return -EIO;
break; return 0;
case V4L2_CID_HFLIP: case V4L2_CID_HFLIP:
if (ctrl->value) if (ctrl->val)
data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 2); data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 0, 2);
else else
data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 2, 2); data = reg_set(client, RJ54N1_MIRROR_STILL_MODE, 2, 2);
if (data < 0) if (data < 0)
return -EIO; return -EIO;
break; return 0;
case V4L2_CID_GAIN: case V4L2_CID_GAIN:
if (ctrl->value > qctrl->maximum || if (reg_write(client, RJ54N1_Y_GAIN, ctrl->val * 2) < 0)
ctrl->value < qctrl->minimum)
return -EINVAL;
else if (reg_write(client, RJ54N1_Y_GAIN, ctrl->value * 2) < 0)
return -EIO; return -EIO;
break; return 0;
case V4L2_CID_AUTO_WHITE_BALANCE: case V4L2_CID_AUTO_WHITE_BALANCE:
/* Auto WB area - whole image */ /* Auto WB area - whole image */
if (reg_set(client, RJ54N1_WB_SEL_WEIGHT_I, ctrl->value << 7, if (reg_set(client, RJ54N1_WB_SEL_WEIGHT_I, ctrl->val << 7,
0x80) < 0) 0x80) < 0)
return -EIO; return -EIO;
rj54n1->auto_wb = ctrl->value; rj54n1->auto_wb = ctrl->val;
break; return 0;
} }
return 0; return -EINVAL;
} }
static const struct v4l2_ctrl_ops rj54n1_ctrl_ops = {
.s_ctrl = rj54n1_s_ctrl,
};
static struct v4l2_subdev_core_ops rj54n1_subdev_core_ops = { static struct v4l2_subdev_core_ops rj54n1_subdev_core_ops = {
.g_ctrl = rj54n1_g_ctrl,
.s_ctrl = rj54n1_s_ctrl,
.g_chip_ident = rj54n1_g_chip_ident, .g_chip_ident = rj54n1_g_chip_ident,
#ifdef CONFIG_VIDEO_ADV_DEBUG #ifdef CONFIG_VIDEO_ADV_DEBUG
.g_register = rj54n1_g_register, .g_register = rj54n1_g_register,
@ -1432,8 +1353,22 @@ static int rj54n1_probe(struct i2c_client *client,
return -ENOMEM; return -ENOMEM;
v4l2_i2c_subdev_init(&rj54n1->subdev, client, &rj54n1_subdev_ops); v4l2_i2c_subdev_init(&rj54n1->subdev, client, &rj54n1_subdev_ops);
v4l2_ctrl_handler_init(&rj54n1->hdl, 4);
v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
V4L2_CID_VFLIP, 0, 1, 1, 0);
v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
V4L2_CID_HFLIP, 0, 1, 1, 0);
v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
V4L2_CID_GAIN, 0, 127, 1, 66);
v4l2_ctrl_new_std(&rj54n1->hdl, &rj54n1_ctrl_ops,
V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
rj54n1->subdev.ctrl_handler = &rj54n1->hdl;
if (rj54n1->hdl.error) {
int err = rj54n1->hdl.error;
icd->ops = &rj54n1_ops; kfree(rj54n1);
return err;
}
rj54n1->clk_div = clk_div; rj54n1->clk_div = clk_div;
rj54n1->rect.left = RJ54N1_COLUMN_SKIP; rj54n1->rect.left = RJ54N1_COLUMN_SKIP;
@ -1449,12 +1384,11 @@ static int rj54n1_probe(struct i2c_client *client,
ret = rj54n1_video_probe(icd, client, rj54n1_priv); ret = rj54n1_video_probe(icd, client, rj54n1_priv);
if (ret < 0) { if (ret < 0) {
icd->ops = NULL; v4l2_ctrl_handler_free(&rj54n1->hdl);
kfree(rj54n1); kfree(rj54n1);
return ret; return ret;
} }
return v4l2_ctrl_handler_setup(&rj54n1->hdl);
return ret;
} }
static int rj54n1_remove(struct i2c_client *client) static int rj54n1_remove(struct i2c_client *client)
@ -1463,9 +1397,10 @@ static int rj54n1_remove(struct i2c_client *client)
struct soc_camera_device *icd = client->dev.platform_data; struct soc_camera_device *icd = client->dev.platform_data;
struct soc_camera_link *icl = to_soc_camera_link(icd); struct soc_camera_link *icl = to_soc_camera_link(icd);
icd->ops = NULL; v4l2_device_unregister_subdev(&rj54n1->subdev);
if (icl->free_bus) if (icl->free_bus)
icl->free_bus(icl); icl->free_bus(icl);
v4l2_ctrl_handler_free(&rj54n1->hdl);
kfree(rj54n1); kfree(rj54n1);
return 0; return 0;