[media] sr030pc30: convert to the control framework

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Acked-by: Sylwester Nawrocki <s.nawrocki@samsung.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

1 files changed, 88 insertions, 188 deletions

diff --git a/drivers/media/i2c/sr030pc30.c b/drivers/media/i2c/sr030pc30.c
index 4c5a9ee60c3e..ae9432637fcb 100644
--- a/drivers/media/i2c/sr030pc30.c
+++ b/drivers/media/i2c/sr030pc30.c
@@ -23,6 +23,7 @@
 #include <media/v4l2-device.h>
 #include <media/v4l2-subdev.h>
 #include <media/v4l2-mediabus.h>
+#include <media/v4l2-ctrls.h>
 #include <media/sr030pc30.h>
 
 static int debug;
@@ -142,17 +143,24 @@ module_param(debug, int, 0644);
 
 struct sr030pc30_info {
         struct v4l2_subdev sd;
+        struct v4l2_ctrl_handler hdl;
         const struct sr030pc30_platform_data *pdata;
         const struct sr030pc30_format *curr_fmt;
         const struct sr030pc30_frmsize *curr_win;
-        unsigned int auto_wb:1;
-        unsigned int auto_exp:1;
         unsigned int hflip:1;
         unsigned int vflip:1;
         unsigned int sleep:1;
-        unsigned int exposure;
-        u8 blue_balance;
-        u8 red_balance;
+        struct {
+                /* auto whitebalance control cluster */
+                struct v4l2_ctrl *awb;
+                struct v4l2_ctrl *red;
+                struct v4l2_ctrl *blue;
+        };
+        struct {
+                /* auto exposure control cluster */
+                struct v4l2_ctrl *autoexp;
+                struct v4l2_ctrl *exp;
+        };
         u8 i2c_reg_page;
 };
 
@@ -173,52 +181,6 @@ struct i2c_regval {
         u16 val;
 };
 
-static const struct v4l2_queryctrl sr030pc30_ctrl[] = {
-        {
-                .id             = V4L2_CID_AUTO_WHITE_BALANCE,
-                .type           = V4L2_CTRL_TYPE_BOOLEAN,
-                .name           = "Auto White Balance",
-                .minimum        = 0,
-                .maximum        = 1,
-                .step           = 1,
-                .default_value  = 1,
-        }, {
-                .id             = V4L2_CID_RED_BALANCE,
-                .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Red Balance",
-                .minimum        = 0,
-                .maximum        = 127,
-                .step           = 1,
-                .default_value  = 64,
-                .flags          = 0,
-        }, {
-                .id             = V4L2_CID_BLUE_BALANCE,
-                .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Blue Balance",
-                .minimum        = 0,
-                .maximum        = 127,
-                .step           = 1,
-                .default_value  = 64,
-        }, {
-                .id             = V4L2_CID_EXPOSURE_AUTO,
-                .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Auto Exposure",
-                .minimum        = 0,
-                .maximum        = 1,
-                .step           = 1,
-                .default_value  = 1,
-        }, {
-                .id             = V4L2_CID_EXPOSURE,
-                .type           = V4L2_CTRL_TYPE_INTEGER,
-                .name           = "Exposure",
-                .minimum        = EXPOS_MIN_MS,
-                .maximum        = EXPOS_MAX_MS,
-                .step           = 1,
-                .default_value  = 1,
-        }, {
-        }
-};
-
 /* supported resolutions */
 static const struct sr030pc30_frmsize sr030pc30_sizes[] = {
         {
@@ -394,48 +356,6 @@ static int sr030pc30_pwr_ctrl(struct v4l2_subdev *sd,
         return ret;
 }
 
-static inline int sr030pc30_enable_autoexposure(struct v4l2_subdev *sd, int on)
-{
-        struct sr030pc30_info *info = to_sr030pc30(sd);
-        /* auto anti-flicker is also enabled here */
-        int ret = cam_i2c_write(sd, AE_CTL1_REG, on ? 0xDC : 0x0C);
-        if (!ret)
-                info->auto_exp = on;
-        return ret;
-}
-
-static int sr030pc30_set_exposure(struct v4l2_subdev *sd, int value)
-{
-        struct sr030pc30_info *info = to_sr030pc30(sd);
-
-        unsigned long expos = value * info->pdata->clk_rate / (8 * 1000);
-
-        int ret = cam_i2c_write(sd, EXP_TIMEH_REG, expos >> 16 & 0xFF);
-        if (!ret)
-                ret = cam_i2c_write(sd, EXP_TIMEM_REG, expos >> 8 & 0xFF);
-        if (!ret)
-                ret = cam_i2c_write(sd, EXP_TIMEL_REG, expos & 0xFF);
-        if (!ret) { /* Turn off AE */
-                info->exposure = value;
-                ret = sr030pc30_enable_autoexposure(sd, 0);
-        }
-        return ret;
-}
-
-/* Automatic white balance control */
-static int sr030pc30_enable_autowhitebalance(struct v4l2_subdev *sd, int on)
-{
-        struct sr030pc30_info *info = to_sr030pc30(sd);
-
-        int ret = cam_i2c_write(sd, AWB_CTL2_REG, on ? 0x2E : 0x2F);
-        if (!ret)
-                ret = cam_i2c_write(sd, AWB_CTL1_REG, on ? 0xFB : 0x7B);
-        if (!ret)
-                info->auto_wb = on;
-
-        return ret;
-}
-
 static int sr030pc30_set_flip(struct v4l2_subdev *sd)
 {
         struct sr030pc30_info *info = to_sr030pc30(sd);
@@ -498,107 +418,56 @@ static int sr030pc30_try_frame_size(struct v4l2_mbus_framefmt *mf)
         return -EINVAL;
 }
 
-static int sr030pc30_queryctrl(struct v4l2_subdev *sd,
-                               struct v4l2_queryctrl *qc)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(sr030pc30_ctrl); i++)
-                if (qc->id == sr030pc30_ctrl[i].id) {
-                        *qc = sr030pc30_ctrl[i];
-                        v4l2_dbg(1, debug, sd, "%s id: %d\n",
-                                 __func__, qc->id);
-                        return 0;
-                }
-
-        return -EINVAL;
-}
-
-static inline int sr030pc30_set_bluebalance(struct v4l2_subdev *sd, int value)
-{
-        int ret = cam_i2c_write(sd, MWB_BGAIN_REG, value);
-        if (!ret)
-                to_sr030pc30(sd)->blue_balance = value;
-        return ret;
-}
-
-static inline int sr030pc30_set_redbalance(struct v4l2_subdev *sd, int value)
-{
-        int ret = cam_i2c_write(sd, MWB_RGAIN_REG, value);
-        if (!ret)
-                to_sr030pc30(sd)->red_balance = value;
-        return ret;
-}
-
-static int sr030pc30_s_ctrl(struct v4l2_subdev *sd,
-                            struct v4l2_control *ctrl)
+static int sr030pc30_s_ctrl(struct v4l2_ctrl *ctrl)
 {
-        int i, ret = 0;
-
-        for (i = 0; i < ARRAY_SIZE(sr030pc30_ctrl); i++)
-                if (ctrl->id == sr030pc30_ctrl[i].id)
-                        break;
-
-        if (i == ARRAY_SIZE(sr030pc30_ctrl))
-                return -EINVAL;
-
-        if (ctrl->value < sr030pc30_ctrl[i].minimum ||
-                ctrl->value > sr030pc30_ctrl[i].maximum)
-                        return -ERANGE;
+        struct sr030pc30_info *info =
+                container_of(ctrl->handler, struct sr030pc30_info, hdl);
+        struct v4l2_subdev *sd = &info->sd;
+        int ret = 0;
 
         v4l2_dbg(1, debug, sd, "%s: ctrl_id: %d, value: %d\n",
-                         __func__, ctrl->id, ctrl->value);
+                         __func__, ctrl->id, ctrl->val);
 
         switch (ctrl->id) {
         case V4L2_CID_AUTO_WHITE_BALANCE:
-                sr030pc30_enable_autowhitebalance(sd, ctrl->value);
-                break;
-        case V4L2_CID_BLUE_BALANCE:
-                ret = sr030pc30_set_bluebalance(sd, ctrl->value);
-                break;
-        case V4L2_CID_RED_BALANCE:
-                ret = sr030pc30_set_redbalance(sd, ctrl->value);
-                break;
-        case V4L2_CID_EXPOSURE_AUTO:
-                sr030pc30_enable_autoexposure(sd,
-                        ctrl->value == V4L2_EXPOSURE_AUTO);
-                break;
-        case V4L2_CID_EXPOSURE:
-                ret = sr030pc30_set_exposure(sd, ctrl->value);
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        return ret;
-}
-
-static int sr030pc30_g_ctrl(struct v4l2_subdev *sd,
-                            struct v4l2_control *ctrl)
-{
-        struct sr030pc30_info *info = to_sr030pc30(sd);
-
-        v4l2_dbg(1, debug, sd, "%s: id: %d\n", __func__, ctrl->id);
+                if (ctrl->is_new) {
+                        ret = cam_i2c_write(sd, AWB_CTL2_REG,
+                                        ctrl->val ? 0x2E : 0x2F);
+                        if (!ret)
+                                ret = cam_i2c_write(sd, AWB_CTL1_REG,
+                                                ctrl->val ? 0xFB : 0x7B);
+                }
+                if (!ret && info->blue->is_new)
+                        ret = cam_i2c_write(sd, MWB_BGAIN_REG, info->blue->val);
+                if (!ret && info->red->is_new)
+                        ret = cam_i2c_write(sd, MWB_RGAIN_REG, info->red->val);
+                return ret;
 
-        switch (ctrl->id) {
-        case V4L2_CID_AUTO_WHITE_BALANCE:
-                ctrl->value = info->auto_wb;
-                break;
-        case V4L2_CID_BLUE_BALANCE:
-                ctrl->value = info->blue_balance;
-                break;
-        case V4L2_CID_RED_BALANCE:
-                ctrl->value = info->red_balance;
-                break;
         case V4L2_CID_EXPOSURE_AUTO:
-                ctrl->value = info->auto_exp;
-                break;
-        case V4L2_CID_EXPOSURE:
-                ctrl->value = info->exposure;
-                break;
+                /* auto anti-flicker is also enabled here */
+                if (ctrl->is_new)
+                        ret = cam_i2c_write(sd, AE_CTL1_REG,
+                                ctrl->val == V4L2_EXPOSURE_AUTO ? 0xDC : 0x0C);
+                if (info->exp->is_new) {
+                        unsigned long expos = info->exp->val;
+
+                        expos = expos * info->pdata->clk_rate / (8 * 1000);
+
+                        if (!ret)
+                                ret = cam_i2c_write(sd, EXP_TIMEH_REG,
+                                                expos >> 16 & 0xFF);
+                        if (!ret)
+                                ret = cam_i2c_write(sd, EXP_TIMEM_REG,
+                                                expos >> 8 & 0xFF);
+                        if (!ret)
+                                ret = cam_i2c_write(sd, EXP_TIMEL_REG,
+                                                expos & 0xFF);
+                }
+                return ret;
         default:
                 return -EINVAL;
         }
+
         return 0;
 }
 
@@ -752,11 +621,19 @@ static int sr030pc30_s_power(struct v4l2_subdev *sd, int on)
         return ret;
 }
 
+static const struct v4l2_ctrl_ops sr030pc30_ctrl_ops = {
+        .s_ctrl = sr030pc30_s_ctrl,
+};
+
 static const struct v4l2_subdev_core_ops sr030pc30_core_ops = {
         .s_power        = sr030pc30_s_power,
-        .queryctrl      = sr030pc30_queryctrl,
-        .s_ctrl         = sr030pc30_s_ctrl,
-        .g_ctrl         = sr030pc30_g_ctrl,
+        .g_ext_ctrls = v4l2_subdev_g_ext_ctrls,
+        .try_ext_ctrls = v4l2_subdev_try_ext_ctrls,
+        .s_ext_ctrls = v4l2_subdev_s_ext_ctrls,
+        .g_ctrl = v4l2_subdev_g_ctrl,
+        .s_ctrl = v4l2_subdev_s_ctrl,
+        .queryctrl = v4l2_subdev_queryctrl,
+        .querymenu = v4l2_subdev_querymenu,
 };
 
 static const struct v4l2_subdev_video_ops sr030pc30_video_ops = {
@@ -807,6 +684,7 @@ static int sr030pc30_probe(struct i2c_client *client,
 {
         struct sr030pc30_info *info;
         struct v4l2_subdev *sd;
+        struct v4l2_ctrl_handler *hdl;
         const struct sr030pc30_platform_data *pdata
                 = client->dev.platform_data;
         int ret;
@@ -830,10 +708,31 @@ static int sr030pc30_probe(struct i2c_client *client,
 
         v4l2_i2c_subdev_init(sd, client, &sr030pc30_ops);
 
+        hdl = &info->hdl;
+        v4l2_ctrl_handler_init(hdl, 6);
+        info->awb = v4l2_ctrl_new_std(hdl, &sr030pc30_ctrl_ops,
+                        V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1);
+        info->red = v4l2_ctrl_new_std(hdl, &sr030pc30_ctrl_ops,
+                        V4L2_CID_RED_BALANCE, 0, 127, 1, 64);
+        info->blue = v4l2_ctrl_new_std(hdl, &sr030pc30_ctrl_ops,
+                        V4L2_CID_BLUE_BALANCE, 0, 127, 1, 64);
+        info->autoexp = v4l2_ctrl_new_std(hdl, &sr030pc30_ctrl_ops,
+                        V4L2_CID_EXPOSURE_AUTO, 0, 1, 1, 1);
+        info->exp = v4l2_ctrl_new_std(hdl, &sr030pc30_ctrl_ops,
+                        V4L2_CID_EXPOSURE, EXPOS_MIN_MS, EXPOS_MAX_MS, 1, 30);
+        sd->ctrl_handler = hdl;
+        if (hdl->error) {
+                int err = hdl->error;
+
+                v4l2_ctrl_handler_free(hdl);
+                return err;
+        }
+        v4l2_ctrl_auto_cluster(3, &info->awb, 0, false);
+        v4l2_ctrl_auto_cluster(2, &info->autoexp, V4L2_EXPOSURE_MANUAL, false);
+        v4l2_ctrl_handler_setup(hdl);
+
         info->i2c_reg_page      = -1;
         info->hflip             = 1;
-        info->auto_exp          = 1;
-        info->exposure          = 30;
 
         return 0;
 }
@@ -843,6 +742,7 @@ static int sr030pc30_remove(struct i2c_client *client)
         struct v4l2_subdev *sd = i2c_get_clientdata(client);
 
         v4l2_device_unregister_subdev(sd);
+        v4l2_ctrl_handler_free(sd->ctrl_handler);
         return 0;
 }