[media] v4l2-ctrl: Add helper function for the controls range update

This patch adds a helper function that allows to modify range, i.e. minimum, maximum, step and default value of a v4l2 control, after the control has been created and initialized. This is helpful in situations when range of a control depends on user configurable parameters, e.g. camera sensor absolute exposure time depending on an output image resolution and frame rate. v4l2_ctrl_modify_range() function allows to modify range of an INTEGER, BOOL, MENU, INTEGER_MENU and BITMASK type controls. Based on a patch from Hans Verkuil http://patchwork.linuxtv.org/patch/8654.

Sylwester Nawrocki committed 13 years ago

Commit 2ccbe771 parent af9bb336 files · +138 −40Browse files

Unified · Split

6 files

Documentation/DocBook/media/v4l/compat.xml +4 −0
Documentation/DocBook/media/v4l/v4l2.xml +3 −1
Documentation/DocBook/media/v4l/vidioc-dqevent.xml +6 −0
drivers/media/v4l2-core/v4l2-ctrls.c +104 −39
include/media/v4l2-ctrls.h +20 −0
include/uapi/linux/videodev2.h +1 −0

Documentation/DocBook/media/v4l/compat.xml+4−0

 	  <structname>v4l2_buffer</structname>. See <xref
 	  linkend="buffer-flags" />.</para>
         </listitem>
+        <listitem>
+	  <para>Added <constant>V4L2_EVENT_CTRL_CH_RANGE</constant> control event
+	  changes flag. See <xref linkend="changes-flags"/>.</para>
+        </listitem>
       </orderedlist>
     </section>

Documentation/DocBook/media/v4l/v4l2.xml+3−1

       <revision>
 	<revnumber>3.9</revnumber>
 	<date>2012-12-03</date>
-	<authorinitials>sa</authorinitials>
+	<authorinitials>sa, sn</authorinitials>
 	<revremark>Added timestamp types to
 	<structname>v4l2_buffer</structname>, see <xref
 	linkend="buffer-flags" />.
+	Added <constant>V4L2_EVENT_CTRL_CH_RANGE</constant> control
+	event changes flag, see <xref linkend="changes-flags"/>.
 	</revremark>
       </revision>

Documentation/DocBook/media/v4l/vidioc-dqevent.xml+6−0

 	    <entry>This control event was triggered because the control flags
 		changed.</entry>
 	  </row>
+	  <row>
+	    <entry><constant>V4L2_EVENT_CTRL_CH_RANGE</constant></entry>
+	    <entry>0x0004</entry>
+	    <entry>This control event was triggered because the minimum,
+	    maximum, step or the default value of the control changed.</entry>
+	  </row>
 	</tbody>
       </tgroup>
     </table>

drivers/media/v4l2-core/v4l2-ctrls.c+104−39

 }
 /* Copy the new value to the current value. */
-static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
+static void new_to_cur(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
-						bool update_inactive)
 {
 	bool changed = false;
 		ctrl->cur.val = ctrl->val;
 		break;
 	}
-	if (update_inactive) {
+	if (ch_flags & V4L2_EVENT_CTRL_CH_FLAGS) {
-		/* Note: update_inactive can only be true for auto clusters. */
+		/* Note: CH_FLAGS is only set for auto clusters. */
 		ctrl->flags &=
 			~(V4L2_CTRL_FLAG_INACTIVE | V4L2_CTRL_FLAG_VOLATILE);
 		if (!is_cur_manual(ctrl->cluster[0])) {
 		}
 		fh = NULL;
 	}
-	if (changed || update_inactive) {
+	if (changed || ch_flags) {
 		/* If a control was changed that was not one of the controls
 		   modified by the application, then send the event to all. */
 		if (!ctrl->is_new)
 			fh = NULL;
 		send_event(fh, ctrl,
-			(changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) |
+			(changed ? V4L2_EVENT_CTRL_CH_VALUE : 0) | ch_flags);
-			(update_inactive ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
 		if (ctrl->call_notify && changed && ctrl->handler->notify)
 			ctrl->handler->notify(ctrl, ctrl->handler->notify_priv);
 	}
 	return diff;
 }
+/* Control range checking */
+static int check_range(enum v4l2_ctrl_type type,
+		s32 min, s32 max, u32 step, s32 def)
+{
+	switch (type) {
+	case V4L2_CTRL_TYPE_BOOLEAN:
+		if (step != 1 || max > 1 || min < 0)
+			return -ERANGE;
+		/* fall through */
+	case V4L2_CTRL_TYPE_INTEGER:
+		if (step <= 0 || min > max || def < min || def > max)
+			return -ERANGE;
+		return 0;
+	case V4L2_CTRL_TYPE_BITMASK:
+		if (step || min || !max || (def & ~max))
+			return -ERANGE;
+		return 0;
+	case V4L2_CTRL_TYPE_MENU:
+	case V4L2_CTRL_TYPE_INTEGER_MENU:
+		if (min > max || def < min || def > max)
+			return -ERANGE;
+		/* Note: step == menu_skip_mask for menu controls.
+		   So here we check if the default value is masked out. */
+		if (step && ((1 << def) & step))
+			return -EINVAL;
+		return 0;
+	case V4L2_CTRL_TYPE_STRING:
+		if (min > max || min < 0 || step < 1 || def)
+			return -ERANGE;
+		return 0;
+	default:
+		return 0;
+	}
+}
 /* Validate a new control */
 static int validate_new(const struct v4l2_ctrl *ctrl,
 			struct v4l2_ext_control *c)
 {
 	struct v4l2_ctrl *ctrl;
 	unsigned sz_extra = 0;
+	int err;
 	if (hdl->error)
 		return NULL;
 	/* Sanity checks */
 	if (id == 0 || name == NULL || id >= V4L2_CID_PRIVATE_BASE ||
-	    (type == V4L2_CTRL_TYPE_INTEGER && step == 0) ||
-	    (type == V4L2_CTRL_TYPE_BITMASK && max == 0) ||
 	    (type == V4L2_CTRL_TYPE_MENU && qmenu == NULL) ||
-	    (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL) ||
+	    (type == V4L2_CTRL_TYPE_INTEGER_MENU && qmenu_int == NULL)) {
-	    (type == V4L2_CTRL_TYPE_STRING && max == 0)) {
-		handler_set_err(hdl, -ERANGE);
-		return NULL;
-	}
-	if (type != V4L2_CTRL_TYPE_BITMASK && max < min) {
 		handler_set_err(hdl, -ERANGE);
 		return NULL;
 	}
-	if ((type == V4L2_CTRL_TYPE_INTEGER ||
+	err = check_range(type, min, max, step, def);
-	     type == V4L2_CTRL_TYPE_MENU ||
+	if (err) {
-	     type == V4L2_CTRL_TYPE_INTEGER_MENU ||
+		handler_set_err(hdl, err);
-	     type == V4L2_CTRL_TYPE_BOOLEAN) &&
-	    (def < min || def > max)) {
-		handler_set_err(hdl, -ERANGE);
 		return NULL;
 	}
 	if (type == V4L2_CTRL_TYPE_BITMASK && ((def & ~max) || min || step)) {
 /* Core function that calls try/s_ctrl and ensures that the new value is
    copied to the current value on a set.
    Must be called with ctrl->handler->lock held. */
-static int try_or_set_cluster(struct v4l2_fh *fh,
+static int try_or_set_cluster(struct v4l2_fh *fh, struct v4l2_ctrl *master,
-			      struct v4l2_ctrl *master, bool set)
+			      bool set, u32 ch_flags)
 {
 	bool update_flag;
 	int ret;
 	/* If OK, then make the new values permanent. */
 	update_flag = is_cur_manual(master) != is_new_manual(master);
 	for (i = 0; i < master->ncontrols; i++)
-		new_to_cur(fh, master->cluster[i], update_flag && i > 0);
+		new_to_cur(fh, master->cluster[i], ch_flags |
+			((update_flag && i > 0) ? V4L2_EVENT_CTRL_CH_FLAGS : 0));
 	return 0;
 }
 		} while (!ret && idx);
 		if (!ret)
-			ret = try_or_set_cluster(fh, master, set);
+			ret = try_or_set_cluster(fh, master, set, 0);
 		/* Copy the new values back to userspace. */
 		if (!ret) {
 /* Helper function for VIDIOC_S_CTRL compatibility */
 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
-		    struct v4l2_ext_control *c)
+		    struct v4l2_ext_control *c, u32 ch_flags)
 {
 	struct v4l2_ctrl *master = ctrl->cluster[0];
-	int ret;
 	int i;
 	/* String controls are not supported. The user_to_new() and
 	if (ctrl->type == V4L2_CTRL_TYPE_STRING)
 		return -EINVAL;
-	ret = validate_new(ctrl, c);
-	if (ret)
-		return ret;
-	v4l2_ctrl_lock(ctrl);
 	/* Reset the 'is_new' flags of the cluster */
 	for (i = 0; i < master->ncontrols; i++)
 		if (master->cluster[i])
 		update_from_auto_cluster(master);
 	user_to_new(c, ctrl);
-	ret = try_or_set_cluster(fh, master, true);
+	return try_or_set_cluster(fh, master, true, ch_flags);
-	cur_to_user(c, ctrl);
+}
-	v4l2_ctrl_unlock(ctrl);
+/* Helper function for VIDIOC_S_CTRL compatibility */
+static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
+			 struct v4l2_ext_control *c)
+{
+	int ret = validate_new(ctrl, c);
+	if (!ret) {
+		v4l2_ctrl_lock(ctrl);
+		ret = set_ctrl(fh, ctrl, c, 0);
+		if (!ret)
+			cur_to_user(c, ctrl);
+		v4l2_ctrl_unlock(ctrl);
+	}
 	return ret;
 }
 		return -EACCES;
 	c.value = control->value;
-	ret = set_ctrl(fh, ctrl, &c);
+	ret = set_ctrl_lock(fh, ctrl, &c);
 	control->value = c.value;
 	return ret;
 }
 	/* It's a driver bug if this happens. */
 	WARN_ON(!type_is_int(ctrl));
 	c.value = val;
-	return set_ctrl(NULL, ctrl, &c);
+	return set_ctrl_lock(NULL, ctrl, &c);
 }
 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl);
 	/* It's a driver bug if this happens. */
 	WARN_ON(ctrl->type != V4L2_CTRL_TYPE_INTEGER64);
 	c.value64 = val;
-	return set_ctrl(NULL, ctrl, &c);
+	return set_ctrl_lock(NULL, ctrl, &c);
 }
 EXPORT_SYMBOL(v4l2_ctrl_s_ctrl_int64);
 }
 EXPORT_SYMBOL(v4l2_ctrl_notify);
+int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
+			s32 min, s32 max, u32 step, s32 def)
+{
+	int ret = check_range(ctrl->type, min, max, step, def);
+	struct v4l2_ext_control c;
+	switch (ctrl->type) {
+	case V4L2_CTRL_TYPE_INTEGER:
+	case V4L2_CTRL_TYPE_BOOLEAN:
+	case V4L2_CTRL_TYPE_MENU:
+	case V4L2_CTRL_TYPE_INTEGER_MENU:
+	case V4L2_CTRL_TYPE_BITMASK:
+		if (ret)
+			return ret;
+		break;
+	default:
+		return -EINVAL;
+	}
+	v4l2_ctrl_lock(ctrl);
+	ctrl->minimum = min;
+	ctrl->maximum = max;
+	ctrl->step = step;
+	ctrl->default_value = def;
+	c.value = ctrl->cur.val;
+	if (validate_new(ctrl, &c))
+		c.value = def;
+	if (c.value != ctrl->cur.val)
+		ret = set_ctrl(NULL, ctrl, &c, V4L2_EVENT_CTRL_CH_RANGE);
+	else
+		send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
+	v4l2_ctrl_unlock(ctrl);
+	return ret;
+}
+EXPORT_SYMBOL(v4l2_ctrl_modify_range);
 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev, unsigned elems)
 {
 	struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);

include/media/v4l2-ctrls.h+20−0

@@ -518,6 +518,26 @@ void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active); · 517 unmodified lines
518	*/	518	*/
519	void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed);	519	void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed);
520		520
		521	/** v4l2_ctrl_modify_range() - Update the range of a control.
		522	* @ctrl: The control to update.
		523	* @min: The control's minimum value.
		524	* @max: The control's maximum value.
		525	* @step: The control's step value
		526	* @def: The control's default value.
		527	*
		528	* Update the range of a control on the fly. This works for control types
		529	* INTEGER, BOOLEAN, MENU, INTEGER MENU and BITMASK. For menu controls the
		530	* @step value is interpreted as a menu_skip_mask.
		531	*
		532	* An error is returned if one of the range arguments is invalid for this
		533	* control type.
		534	*
		535	* This function assumes that the control handler is not locked and will
		536	* take the lock itself.
		537	*/
		538	int v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
		539	s32 min, s32 max, u32 step, s32 def);
		540
521	/** v4l2_ctrl_lock() - Helper function to lock the handler	541	/** v4l2_ctrl_lock() - Helper function to lock the handler
522	* associated with the control.	542	* associated with the control.
523	* @ctrl: The control to lock.	543	* @ctrl: The control to lock.

include/uapi/linux/videodev2.h+1−0

@@ -1822,6 +1822,7 @@ struct v4l2_event_vsync { · 1821 unmodified lines
1822	/* Payload for V4L2_EVENT_CTRL */	1822	/* Payload for V4L2_EVENT_CTRL */
1823	#define V4L2_EVENT_CTRL_CH_VALUE (1 << 0)	1823	#define V4L2_EVENT_CTRL_CH_VALUE (1 << 0)
1824	#define V4L2_EVENT_CTRL_CH_FLAGS (1 << 1)	1824	#define V4L2_EVENT_CTRL_CH_FLAGS (1 << 1)
		1825	#define V4L2_EVENT_CTRL_CH_RANGE (1 << 2)
1825		1826
1826	struct v4l2_event_ctrl {	1827	struct v4l2_event_ctrl {
1827	__u32 changes;	1828	__u32 changes;

[media] v4l2-ctrl: Add helper function for the controls range update

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code