media: v4l2-ctrls: add core request support

	return ptr_to_user(c, ctrl, ctrl->p_new);

}

/* Helper function: copy the request value back to the caller */

static int req_to_user(struct v4l2_ext_control *c,

		       struct v4l2_ctrl_ref *ref)

{

	return ptr_to_user(c, ref->ctrl, ref->p_req);

}

/* Helper function: copy the initial control value back to the caller */

static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)

{

	ptr_to_ptr(ctrl, ctrl->p_cur, ctrl->p_new);

}

/* Copy the new value to the request value */

static void new_to_req(struct v4l2_ctrl_ref *ref)

{

	if (!ref)

		return;

	ptr_to_ptr(ref->ctrl, ref->ctrl->p_new, ref->p_req);

	ref->req = ref;

}

/* Copy the request value to the new value */

static void req_to_new(struct v4l2_ctrl_ref *ref)

{

	if (!ref)

		return;

	if (ref->req)

		ptr_to_ptr(ref->ctrl, ref->req->p_req, ref->ctrl->p_new);

	else

		ptr_to_ptr(ref->ctrl, ref->ctrl->p_cur, ref->ctrl->p_new);

}

/* Return non-zero if one or more of the controls in the cluster has a new

   value that differs from the current value. */

static int cluster_changed(struct v4l2_ctrl *master)

	lockdep_set_class_and_name(hdl->lock, key, name);

	INIT_LIST_HEAD(&hdl->ctrls);

	INIT_LIST_HEAD(&hdl->ctrl_refs);

	INIT_LIST_HEAD(&hdl->requests);

	INIT_LIST_HEAD(&hdl->requests_queued);

	hdl->request_is_queued = false;

	hdl->nr_of_buckets = 1 + nr_of_controls_hint / 8;

	hdl->buckets = kvmalloc_array(hdl->nr_of_buckets,

				      sizeof(hdl->buckets[0]),

	if (hdl == NULL || hdl->buckets == NULL)

		return;

	if (!hdl->req_obj.req && !list_empty(&hdl->requests)) {

		struct v4l2_ctrl_handler *req, *next_req;

		list_for_each_entry_safe(req, next_req, &hdl->requests, requests) {

			media_request_object_unbind(&req->req_obj);

			media_request_object_put(&req->req_obj);

		}

	}

	mutex_lock(hdl->lock);

	/* Free all nodes */

	list_for_each_entry_safe(ref, next_ref, &hdl->ctrl_refs, node) {

}

EXPORT_SYMBOL(v4l2_querymenu);

static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl,

				   const struct v4l2_ctrl_handler *from)

{

	struct v4l2_ctrl_ref *ref;

	int err;

	if (WARN_ON(!hdl || hdl == from))

		return -EINVAL;

	if (hdl->error)

		return hdl->error;

	WARN_ON(hdl->lock != &hdl->_lock);

	mutex_lock(from->lock);

	list_for_each_entry(ref, &from->ctrl_refs, node) {

		struct v4l2_ctrl *ctrl = ref->ctrl;

		struct v4l2_ctrl_ref *new_ref;

		/* Skip refs inherited from other devices */

		if (ref->from_other_dev)

			continue;

		/* And buttons */

		if (ctrl->type == V4L2_CTRL_TYPE_BUTTON)

			continue;

		err = handler_new_ref(hdl, ctrl, &new_ref, false, true);

		if (err)

			break;

	}

	mutex_unlock(from->lock);

	return err;

}

static void v4l2_ctrl_request_queue(struct media_request_object *obj)

{

	struct v4l2_ctrl_handler *hdl =

		container_of(obj, struct v4l2_ctrl_handler, req_obj);

	struct v4l2_ctrl_handler *main_hdl = obj->priv;

	struct v4l2_ctrl_handler *prev_hdl = NULL;

	struct v4l2_ctrl_ref *ref_ctrl, *ref_ctrl_prev = NULL;

	if (list_empty(&main_hdl->requests_queued))

		goto queue;

	prev_hdl = list_last_entry(&main_hdl->requests_queued,

				   struct v4l2_ctrl_handler, requests_queued);

	/*

	 * Note: prev_hdl and hdl must contain the same list of control

	 * references, so if any differences are detected then that is a

	 * driver bug and the WARN_ON is triggered.

	 */

	mutex_lock(prev_hdl->lock);

	ref_ctrl_prev = list_first_entry(&prev_hdl->ctrl_refs,

					 struct v4l2_ctrl_ref, node);

	list_for_each_entry(ref_ctrl, &hdl->ctrl_refs, node) {

		if (ref_ctrl->req)

			continue;

		while (ref_ctrl_prev->ctrl->id < ref_ctrl->ctrl->id) {

			/* Should never happen, but just in case... */

			if (list_is_last(&ref_ctrl_prev->node,

					 &prev_hdl->ctrl_refs))

				break;

			ref_ctrl_prev = list_next_entry(ref_ctrl_prev, node);

		}

		if (WARN_ON(ref_ctrl_prev->ctrl->id != ref_ctrl->ctrl->id))

			break;

		ref_ctrl->req = ref_ctrl_prev->req;

	}

	mutex_unlock(prev_hdl->lock);

queue:

	list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued);

	hdl->request_is_queued = true;

}

static void v4l2_ctrl_request_unbind(struct media_request_object *obj)

{

	struct v4l2_ctrl_handler *hdl =

		container_of(obj, struct v4l2_ctrl_handler, req_obj);

	list_del_init(&hdl->requests);

	if (hdl->request_is_queued) {

		list_del_init(&hdl->requests_queued);

		hdl->request_is_queued = false;

	}

}

static void v4l2_ctrl_request_release(struct media_request_object *obj)

{

	struct v4l2_ctrl_handler *hdl =

		container_of(obj, struct v4l2_ctrl_handler, req_obj);

	v4l2_ctrl_handler_free(hdl);

	kfree(hdl);

}

static const struct media_request_object_ops req_ops = {

	.queue = v4l2_ctrl_request_queue,

	.unbind = v4l2_ctrl_request_unbind,

	.release = v4l2_ctrl_request_release,

};

static int v4l2_ctrl_request_bind(struct media_request *req,

			   struct v4l2_ctrl_handler *hdl,

			   struct v4l2_ctrl_handler *from)

{

	int ret;

	ret = v4l2_ctrl_request_clone(hdl, from);

	if (!ret) {

		ret = media_request_object_bind(req, &req_ops,

						from, false, &hdl->req_obj);

		if (!ret)

			list_add_tail(&hdl->requests, &from->requests);

	}

	return ret;

}

/* Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:

		if (cs->which &&

		    cs->which != V4L2_CTRL_WHICH_DEF_VAL &&

		    cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&

		    V4L2_CTRL_ID2WHICH(id) != cs->which)

			return -EINVAL;

   whether there are any controls at all. */

static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)

{

	if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL)

	if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||

	    which == V4L2_CTRL_WHICH_REQUEST_VAL)

		return 0;

	return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;

}

/* Get extended controls. Allocates the helpers array if needed. */

int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *cs)

{

			u32 idx = i;

			do {

				if (helpers[idx].ref->req)

					ret = req_to_user(cs->controls + idx,

						helpers[idx].ref->req);

				else

					ret = ctrl_to_user(cs->controls + idx,

						helpers[idx].ref->ctrl);

				idx = helpers[idx].next;

		} while (!ret && idx);

		if (!ret)

			ret = try_or_set_cluster(fh, master, set, 0);

			ret = try_or_set_cluster(fh, master,

						 !hdl->req_obj.req && set, 0);

		if (!ret && hdl->req_obj.req && set) {

			for (j = 0; j < master->ncontrols; j++) {

				struct v4l2_ctrl_ref *ref =

					find_ref(hdl, master->cluster[j]->id);

				new_to_req(ref);

			}

		}

		/* Copy the new values back to userspace. */

		if (!ret) {

}

EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);

void v4l2_ctrl_request_complete(struct media_request *req,

				struct v4l2_ctrl_handler *main_hdl)

{

	struct media_request_object *obj;

	struct v4l2_ctrl_handler *hdl;

	struct v4l2_ctrl_ref *ref;

	if (!req || !main_hdl)

		return;

	/*

	 * Note that it is valid if nothing was found. It means

	 * that this request doesn't have any controls and so just

	 * wants to leave the controls unchanged.

	 */

	obj = media_request_object_find(req, &req_ops, main_hdl);

	if (!obj)

		return;

	hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);

	list_for_each_entry(ref, &hdl->ctrl_refs, node) {

		struct v4l2_ctrl *ctrl = ref->ctrl;

		struct v4l2_ctrl *master = ctrl->cluster[0];

		unsigned int i;

		if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {

			ref->req = ref;

			v4l2_ctrl_lock(master);

			/* g_volatile_ctrl will update the current control values */

			for (i = 0; i < master->ncontrols; i++)

				cur_to_new(master->cluster[i]);

			call_op(master, g_volatile_ctrl);

			new_to_req(ref);

			v4l2_ctrl_unlock(master);

			continue;

		}

		if (ref->req == ref)

			continue;

		v4l2_ctrl_lock(ctrl);

		if (ref->req)

			ptr_to_ptr(ctrl, ref->req->p_req, ref->p_req);

		else

			ptr_to_ptr(ctrl, ctrl->p_cur, ref->p_req);

		v4l2_ctrl_unlock(ctrl);

	}

	WARN_ON(!hdl->request_is_queued);

	list_del_init(&hdl->requests_queued);

	hdl->request_is_queued = false;

	media_request_object_complete(obj);

	media_request_object_put(obj);

}

EXPORT_SYMBOL(v4l2_ctrl_request_complete);

void v4l2_ctrl_request_setup(struct media_request *req,

			     struct v4l2_ctrl_handler *main_hdl)

{

	struct media_request_object *obj;

	struct v4l2_ctrl_handler *hdl;

	struct v4l2_ctrl_ref *ref;

	if (!req || !main_hdl)

		return;

	if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED))

		return;

	/*

	 * Note that it is valid if nothing was found. It means

	 * that this request doesn't have any controls and so just

	 * wants to leave the controls unchanged.

	 */

	obj = media_request_object_find(req, &req_ops, main_hdl);

	if (!obj)

		return;

	if (obj->completed) {

		media_request_object_put(obj);

		return;

	}

	hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);

	list_for_each_entry(ref, &hdl->ctrl_refs, node)

		ref->req_done = false;

	list_for_each_entry(ref, &hdl->ctrl_refs, node) {

		struct v4l2_ctrl *ctrl = ref->ctrl;

		struct v4l2_ctrl *master = ctrl->cluster[0];

		bool have_new_data = false;

		int i;

		/*

		 * Skip if this control was already handled by a cluster.

		 * Skip button controls and read-only controls.

		 */

		if (ref->req_done || ctrl->type == V4L2_CTRL_TYPE_BUTTON ||

		    (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))

			continue;

		v4l2_ctrl_lock(master);

		for (i = 0; i < master->ncontrols; i++) {

			if (master->cluster[i]) {

				struct v4l2_ctrl_ref *r =

					find_ref(hdl, master->cluster[i]->id);

				if (r->req && r == r->req) {

					have_new_data = true;

					break;

				}

			}

		}

		if (!have_new_data) {

			v4l2_ctrl_unlock(master);

			continue;

		}

		for (i = 0; i < master->ncontrols; i++) {

			if (master->cluster[i]) {

				struct v4l2_ctrl_ref *r =

					find_ref(hdl, master->cluster[i]->id);

				req_to_new(r);

				master->cluster[i]->is_new = 1;

				r->req_done = true;

			}

		}

		/*

		 * For volatile autoclusters that are currently in auto mode

		 * we need to discover if it will be set to manual mode.

		 * If so, then we have to copy the current volatile values

		 * first since those will become the new manual values (which

		 * may be overwritten by explicit new values from this set

		 * of controls).

		 */

		if (master->is_auto && master->has_volatiles &&

		    !is_cur_manual(master)) {

			s32 new_auto_val = *master->p_new.p_s32;

			/*

			 * If the new value == the manual value, then copy

			 * the current volatile values.

			 */

			if (new_auto_val == master->manual_mode_value)

				update_from_auto_cluster(master);

		}

		try_or_set_cluster(NULL, master, true, 0);

		v4l2_ctrl_unlock(master);

	}

	media_request_object_put(obj);

}

EXPORT_SYMBOL(v4l2_ctrl_request_setup);

void v4l2_ctrl_notify(struct v4l2_ctrl *ctrl, v4l2_ctrl_notify_fnc notify, void *priv)

{

	if (ctrl == NULL)

 *		``prepare_ext_ctrls`` function at ``v4l2-ctrl.c``.

 * @from_other_dev: If true, then @ctrl was defined in another

 *		device than the &struct v4l2_ctrl_handler.

 * @req_done:	Internal flag: if the control handler containing this control

 *		reference is bound to a media request, then this is set when

 *		the control has been applied. This prevents applying controls

 *		from a cluster with multiple controls twice (when the first

 *		control of a cluster is applied, they all are).

 * @req:	If set, this refers to another request that sets this control.

 * @p_req:	If the control handler containing this control reference

 *		is bound to a media request, then this points to the

 *		value of the control that should be applied when the request

	struct v4l2_ctrl *ctrl;

	struct v4l2_ctrl_helper *helper;

	bool from_other_dev;

	bool req_done;

	struct v4l2_ctrl_ref *req;

	union v4l2_ctrl_ptr p_req;

};

 * @notify_priv: Passed as argument to the v4l2_ctrl notify callback.

 * @nr_of_buckets: Total number of buckets in the array.

 * @error:	The error code of the first failed control addition.

 * @request_is_queued: True if the request was queued.

 * @requests:	List to keep track of open control handler request objects.

 *		For the parent control handler (@req_obj.req == NULL) this

 *		is the list header. When the parent control handler is

 *		removed, it has to unbind and put all these requests since

 *		they refer to the parent.

 * @requests_queued: List of the queued requests. This determines the order

 *		in which these controls are applied. Once the request is

 *		completed it is removed from this list.

 * @req_obj:	The &struct media_request_object, used to link into a

 *		&struct media_request. This request object has a refcount.

 */

	void *notify_priv;

	u16 nr_of_buckets;

	int error;

	bool request_is_queued;

	struct list_head requests;

	struct list_head requests_queued;

	struct media_request_object req_obj;

};

 */

__poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait);

/**

 * v4l2_ctrl_request_setup - helper function to apply control values in a request

 *

 * @req: The request

 * @parent: The parent control handler ('priv' in media_request_object_find())

 *

 * This is a helper function to call the control handler's s_ctrl callback with

 * the control values contained in the request. Do note that this approach of

 * applying control values in a request is only applicable to memory-to-memory

 * devices.

 */

void v4l2_ctrl_request_setup(struct media_request *req,

			     struct v4l2_ctrl_handler *parent);

/**

 * v4l2_ctrl_request_complete - Complete a control handler request object

 *

 * @req: The request

 * @parent: The parent control handler ('priv' in media_request_object_find())

 *

 * This function is to be called on each control handler that may have had a

 * request object associated with it, i.e. control handlers of a driver that

 * supports requests.

 *

 * The function first obtains the values of any volatile controls in the control

 * handler and attach them to the request. Then, the function completes the

 * request object.

 */

void v4l2_ctrl_request_complete(struct media_request *req,

				struct v4l2_ctrl_handler *hdl);

/* Helpers for ioctl_ops */

/**