[media] v4l2-ctrls: replace is_volatile with V4L2_CTRL_FLAG_VOLATILE

With the new flag there is no need anymore to have a separate is_volatile
field. Modify all users to use the new flag.

Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Acked-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

diff --git a/Documentation/video4linux/v4l2-controls.txt b/Documentation/video4linux/v4l2-controls.txt
index 9346fc8cbf2b2323e205f1f8669fd626cfc1047a..f92ee305394084652e44242274a4f63997105f97 100644 (file)
--- a/Documentation/video4linux/v4l2-controls.txt
+++ b/Documentation/video4linux/v4l2-controls.txt
@@ -285,11 +285,11 @@ implement g_volatile_ctrl like this:
 Note that you use the 'new value' union as well in g_volatile_ctrl. In general
 controls that need to implement g_volatile_ctrl are read-only controls.
 
-To mark a control as volatile you have to set the is_volatile flag:
+To mark a control as volatile you have to set V4L2_CTRL_FLAG_VOLATILE:
 
        ctrl = v4l2_ctrl_new_std(&sd->ctrl_handler, ...);
        if (ctrl)
-               ctrl->is_volatile = 1;
+               ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 
 For try/s_ctrl the new values (i.e. as passed by the user) are filled in and
 you can modify them in try_ctrl or set them in s_ctrl. The 'cur' union
@@ -367,8 +367,7 @@ Driver specific controls can be created using v4l2_ctrl_new_custom():
 The last argument is the priv pointer which can be set to driver-specific
 private data.
 
-The v4l2_ctrl_config struct also has fields to set the is_private and is_volatile
-flags.
+The v4l2_ctrl_config struct also has a field to set the is_private flag.
 
 If the name field is not set, then the framework will assume this is a standard
 control and will fill in the name, type and flags fields accordingly.
@@ -506,8 +505,8 @@ operation should return the value that the hardware's automatic mode set up
 automatically.
 
 If the cluster is put in manual mode, then the manual controls should become
-active again and the is_volatile flag should be ignored (so g_volatile_ctrl is
-no longer called while in manual mode).
+active again and V4L2_CTRL_FLAG_VOLATILE should be ignored (so g_volatile_ctrl
+is no longer called while in manual mode).
 
 Finally the V4L2_CTRL_FLAG_UPDATE should be set for the auto control since
 changing that control affects the control flags of the manual controls.
@@ -520,7 +519,7 @@ void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
 
 The first two arguments are identical to v4l2_ctrl_cluster. The third argument
 tells the framework which value switches the cluster into manual mode. The
-last argument will optionally set the is_volatile flag for the non-auto controls.
+last argument will optionally set V4L2_CTRL_FLAG_VOLATILE for the non-auto controls.
 
 The first control of the cluster is assumed to be the 'auto' control.
 

diff --git a/drivers/media/radio/radio-wl1273.c b/drivers/media/radio/radio-wl1273.c
index 46cacf845049941c5ad0efc687e23fd2ad4236d7..6d1e4e750f63a08bd88dca3d305014583b01b925 100644 (file)
--- a/drivers/media/radio/radio-wl1273.c
+++ b/drivers/media/radio/radio-wl1273.c
@@ -2109,7 +2109,7 @@ static int __devinit wl1273_fm_radio_probe(struct platform_device *pdev)
                                 V4L2_CID_TUNE_ANTENNA_CAPACITOR,
                                 0, 255, 1, 255);
        if (ctrl)
-               ctrl->is_volatile = 1;
+               ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 
        if (radio->ctrl_handler.error) {
                r = radio->ctrl_handler.error;

diff --git a/drivers/media/radio/wl128x/fmdrv_v4l2.c b/drivers/media/radio/wl128x/fmdrv_v4l2.c
index 478d1e93ada6f51e7cf2845b33f0cddf4c83b595..aaee74752a858e7eab3b9ee1ea97756017e400fd 100644 (file)
--- a/drivers/media/radio/wl128x/fmdrv_v4l2.c
+++ b/drivers/media/radio/wl128x/fmdrv_v4l2.c
@@ -559,7 +559,7 @@ int fm_v4l2_init_video_device(struct fmdev *fmdev, int radio_nr)
                        255, 1, 255);
 
        if (ctrl)
-               ctrl->is_volatile = 1;
+               ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 
        return 0;
 }

diff --git a/drivers/media/video/adp1653.c b/drivers/media/video/adp1653.c
index 279d75d38188973df832e64beb7e454d308e56ad..d0e8ac1f9cde0ff5caae85a9b5bd6d23c22c2db5 100644 (file)
--- a/drivers/media/video/adp1653.c
+++ b/drivers/media/video/adp1653.c
@@ -258,7 +258,7 @@ static int adp1653_init_controls(struct adp1653_flash *flash)
        if (flash->ctrls.error)
                return flash->ctrls.error;
 
-       fault->is_volatile = 1;
+       fault->flags |= V4L2_CTRL_FLAG_VOLATILE;
 
        flash->subdev.ctrl_handler = &flash->ctrls;
        return 0;

diff --git a/drivers/media/video/pwc/pwc-v4l.c b/drivers/media/video/pwc/pwc-v4l.c
index 8c70e64444e7b38bc03b00fdafb36d7bd43d21e7..6873bf50869f76d18b3bf67b9ab958fa7c89129a 100644 (file)
--- a/drivers/media/video/pwc/pwc-v4l.c
+++ b/drivers/media/video/pwc/pwc-v4l.c
@@ -640,7 +640,7 @@ static int pwc_set_awb(struct pwc_device *pdev)
                        return ret;
 
                /* Update val when coming from auto or going to a preset */
-               if (pdev->red_balance->is_volatile ||
+               if ((pdev->red_balance->flags & V4L2_CTRL_FLAG_VOLATILE) ||
                    pdev->auto_white_balance->val == awb_indoor ||
                    pdev->auto_white_balance->val == awb_outdoor ||
                    pdev->auto_white_balance->val == awb_fl) {
@@ -654,12 +654,12 @@ static int pwc_set_awb(struct pwc_device *pdev)
                                        &pdev->blue_balance->val);
                }
                if (pdev->auto_white_balance->val == awb_auto) {
-                       pdev->red_balance->is_volatile = true;
-                       pdev->blue_balance->is_volatile = true;
+                       pdev->red_balance->flags |= V4L2_CTRL_FLAG_VOLATILE;
+                       pdev->blue_balance->flags |= V4L2_CTRL_FLAG_VOLATILE;
                        pdev->color_bal_valid = false; /* Force cache update */
                } else {
-                       pdev->red_balance->is_volatile = false;
-                       pdev->blue_balance->is_volatile = false;
+                       pdev->red_balance->flags &= ~V4L2_CTRL_FLAG_VOLATILE;
+                       pdev->blue_balance->flags &= ~V4L2_CTRL_FLAG_VOLATILE;
                }
        }
 

diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
index 32f898979809e26e0cc3c2e7975dbf3f8a3fe0f7..bfbe08432050af205ca19d46e7abcfd073ee2df8 100644 (file)
--- a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
@@ -165,7 +165,7 @@ static struct mfc_control controls[] = {
                .maximum = 32,
                .step = 1,
                .default_value = 1,
-               .is_volatile = 1,
+               .flags = V4L2_CTRL_FLAG_VOLATILE,
        },
 };
 
@@ -1020,7 +1020,7 @@ int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx *ctx)
                        return ctx->ctrl_handler.error;
                }
                if (controls[i].is_volatile && ctx->ctrls[i])
-                       ctx->ctrls[i]->is_volatile = 1;
+                       ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
        }
        return 0;
 }

diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
index 14ddbd26ebf4f0e87842f9f140363a3d7067e16d..4c90e53bd96467675c7ab7155773ec7bf590d6c2 100644 (file)
--- a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
@@ -1814,7 +1814,7 @@ int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
                        return ctx->ctrl_handler.error;
                }
                if (controls[i].is_volatile && ctx->ctrls[i])
-                       ctx->ctrls[i]->is_volatile = 1;
+                       ctx->ctrls[i]->flags |= V4L2_CTRL_FLAG_VOLATILE;
        }
        return 0;
 }

diff --git a/drivers/media/video/saa7115.c b/drivers/media/video/saa7115.c
index f2ae405c74ac4186b84bda12a7e8f0b5c48b6ec2..e443d0d54f8fef538a434207be7f8d5cfc7014c6 100644 (file)
--- a/drivers/media/video/saa7115.c
+++ b/drivers/media/video/saa7115.c
@@ -1601,7 +1601,7 @@ static int saa711x_probe(struct i2c_client *client,
                        V4L2_CID_CHROMA_AGC, 0, 1, 1, 1);
        state->gain = v4l2_ctrl_new_std(hdl, &saa711x_ctrl_ops,
                        V4L2_CID_CHROMA_GAIN, 0, 127, 1, 40);
-       state->gain->is_volatile = 1;
+       state->gain->flags |= V4L2_CTRL_FLAG_VOLATILE;
        sd->ctrl_handler = hdl;
        if (hdl->error) {
                int err = hdl->error;

diff --git a/drivers/media/video/v4l2-ctrls.c b/drivers/media/video/v4l2-ctrls.c
index 06b6014d4fb4cda5adb94c54a425c0b08b94019e..166762182f8e1df0e9ebd5275ea4585cf17fe2ad 100644 (file)
--- a/drivers/media/video/v4l2-ctrls.c
+++ b/drivers/media/video/v4l2-ctrls.c
@@ -43,7 +43,7 @@ struct v4l2_ctrl_helper {
 };
 
 /* Small helper function to determine if the autocluster is set to manual
-   mode. In that case the is_volatile flag should be ignored. */
+   mode. */
 static bool is_cur_manual(const struct v4l2_ctrl *master)
 {
        return master->is_auto && master->cur.val == master->manual_mode_value;
@@ -1394,10 +1394,8 @@ struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
                        type, min, max,
                        is_menu ? cfg->menu_skip_mask : step,
                        def, flags, qmenu, priv);
-       if (ctrl) {
+       if (ctrl)
                ctrl->is_private = cfg->is_private;
-               ctrl->is_volatile = cfg->is_volatile;
-       }
        return ctrl;
 }
 EXPORT_SYMBOL(v4l2_ctrl_new_custom);
@@ -1519,12 +1517,12 @@ void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
        master->manual_mode_value = manual_val;
        master->flags |= V4L2_CTRL_FLAG_UPDATE;
        flag = is_cur_manual(master) ? 0 : V4L2_CTRL_FLAG_INACTIVE;
+       if (set_volatile)
+               flag |= V4L2_CTRL_FLAG_VOLATILE;
 
        for (i = 1; i < ncontrols; i++)
-               if (controls[i]) {
-                       controls[i]->is_volatile = set_volatile;
+               if (controls[i])
                        controls[i]->flags |= flag;
-               }
 }
 EXPORT_SYMBOL(v4l2_ctrl_auto_cluster);
 
@@ -1579,9 +1577,6 @@ EXPORT_SYMBOL(v4l2_ctrl_grab);
 static void log_ctrl(const struct v4l2_ctrl *ctrl,
                     const char *prefix, const char *colon)
 {
-       int fl_inact = ctrl->flags & V4L2_CTRL_FLAG_INACTIVE;
-       int fl_grabbed = ctrl->flags & V4L2_CTRL_FLAG_GRABBED;
-
        if (ctrl->flags & (V4L2_CTRL_FLAG_DISABLED | V4L2_CTRL_FLAG_WRITE_ONLY))
                return;
        if (ctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
@@ -1612,14 +1607,17 @@ static void log_ctrl(const struct v4l2_ctrl *ctrl,
                printk(KERN_CONT "unknown type %d", ctrl->type);
                break;
        }
-       if (fl_inact && fl_grabbed)
-               printk(KERN_CONT " (inactive, grabbed)\n");
-       else if (fl_inact)
-               printk(KERN_CONT " (inactive)\n");
-       else if (fl_grabbed)
-               printk(KERN_CONT " (grabbed)\n");
-       else
-               printk(KERN_CONT "\n");
+       if (ctrl->flags & (V4L2_CTRL_FLAG_INACTIVE |
+                          V4L2_CTRL_FLAG_GRABBED |
+                          V4L2_CTRL_FLAG_VOLATILE)) {
+               if (ctrl->flags & V4L2_CTRL_FLAG_INACTIVE)
+                       printk(KERN_CONT " inactive");
+               if (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)
+                       printk(KERN_CONT " grabbed");
+               if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE)
+                       printk(KERN_CONT " volatile");
+       }
+       printk(KERN_CONT "\n");
 }
 
 /* Log all controls owned by the handler */
@@ -2004,7 +2002,7 @@ static int get_ctrl(struct v4l2_ctrl *ctrl, s32 *val)
 
        v4l2_ctrl_lock(master);
        /* g_volatile_ctrl will update the current control values */
-       if (ctrl->is_volatile && !is_cur_manual(master)) {
+       if ((ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) && !is_cur_manual(master)) {
                for (i = 0; i < master->ncontrols; i++)
                        cur_to_new(master->cluster[i]);
                ret = call_op(master, g_volatile_ctrl);

diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
index 13fe4d744aba0563f6664996e584eb9998ab9ed3..bd6a4a7370dfde0a87cdd7b30410d5caf8fa51da 100644 (file)
--- a/include/media/v4l2-ctrls.h
+++ b/include/media/v4l2-ctrls.h
@@ -65,10 +65,6 @@ struct v4l2_ctrl_ops {
   * @is_private: If set, then this control is private to its handler and it
   *            will not be added to any other handlers. Drivers can set
   *            this flag.
-  * @is_volatile: If set, then this control is volatile. This means that the
-  *            control's current value cannot be cached and needs to be
-  *            retrieved through the g_volatile_ctrl op. Drivers can set
-  *            this flag.
   * @is_auto:   If set, then this control selects whether the other cluster
   *            members are in 'automatic' mode or 'manual' mode. This is
   *            used for autogain/gain type clusters. Drivers should never
@@ -118,7 +114,6 @@ struct v4l2_ctrl {
 
        unsigned int is_new:1;
        unsigned int is_private:1;
-       unsigned int is_volatile:1;
        unsigned int is_auto:1;
        unsigned int manual_mode_value:8;
 
@@ -208,9 +203,6 @@ struct v4l2_ctrl_handler {
   *            must be NULL.
   * @is_private: If set, then this control is private to its handler and it
   *            will not be added to any other handlers.
-  * @is_volatile: If set, then this control is volatile. This means that the
-  *            control's current value cannot be cached and needs to be
-  *            retrieved through the g_volatile_ctrl op.
   */
 struct v4l2_ctrl_config {
        const struct v4l2_ctrl_ops *ops;
@@ -225,7 +217,6 @@ struct v4l2_ctrl_config {
        u32 menu_skip_mask;
        const char * const *qmenu;
        unsigned int is_private:1;
-       unsigned int is_volatile:1;
 };
 
 /** v4l2_ctrl_fill() - Fill in the control fields based on the control ID.
@@ -389,8 +380,7 @@ void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls);
   * @manual_val: The value for the first control in the cluster that equals the
   *            manual setting.
   * @set_volatile: If true, then all controls except the first auto control will
-  *            have is_volatile set to true. If false, then is_volatile will not
-  *            be touched.
+  *            be volatile.
   *
   * Use for control groups where one control selects some automatic feature and
   * the other controls are only active whenever the automatic feature is turned