1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * V4L2 controls framework Request API implementation.
4  *
5  * Copyright (C) 2018-2021  Hans Verkuil <hverkuil-cisco@xs4all.nl>
6  */
7 
8 #define pr_fmt(fmt) "v4l2-ctrls: " fmt
9 
10 #include <linux/export.h>
11 #include <linux/slab.h>
12 #include <media/v4l2-ctrls.h>
13 #include <media/v4l2-dev.h>
14 #include <media/v4l2-ioctl.h>
15 
16 #include "v4l2-ctrls-priv.h"
17 
18 /* Initialize the request-related fields in a control handler */
19 void v4l2_ctrl_handler_init_request(struct v4l2_ctrl_handler *hdl)
20 {
21 	INIT_LIST_HEAD(&hdl->requests);
22 	INIT_LIST_HEAD(&hdl->requests_queued);
23 	hdl->request_is_queued = false;
24 	media_request_object_init(&hdl->req_obj);
25 }
26 
27 /* Free the request-related fields in a control handler */
28 void v4l2_ctrl_handler_free_request(struct v4l2_ctrl_handler *hdl)
29 {
30 	struct v4l2_ctrl_handler *req, *next_req;
31 
32 	/*
33 	 * Do nothing if this isn't the main handler or the main
34 	 * handler is not used in any request.
35 	 *
36 	 * The main handler can be identified by having a NULL ops pointer in
37 	 * the request object.
38 	 */
39 	if (hdl->req_obj.ops || list_empty(&hdl->requests))
40 		return;
41 
42 	/*
43 	 * If the main handler is freed and it is used by handler objects in
44 	 * outstanding requests, then unbind and put those objects before
45 	 * freeing the main handler.
46 	 */
47 	list_for_each_entry_safe(req, next_req, &hdl->requests, requests) {
48 		media_request_object_unbind(&req->req_obj);
49 		media_request_object_put(&req->req_obj);
50 	}
51 }
52 
53 static int v4l2_ctrl_request_clone(struct v4l2_ctrl_handler *hdl,
54 				   const struct v4l2_ctrl_handler *from)
55 {
56 	struct v4l2_ctrl_ref *ref;
57 	int err = 0;
58 
59 	if (WARN_ON(!hdl || hdl == from))
60 		return -EINVAL;
61 
62 	if (hdl->error)
63 		return hdl->error;
64 
65 	WARN_ON(hdl->lock != &hdl->_lock);
66 
67 	mutex_lock(from->lock);
68 	list_for_each_entry(ref, &from->ctrl_refs, node) {
69 		struct v4l2_ctrl *ctrl = ref->ctrl;
70 		struct v4l2_ctrl_ref *new_ref;
71 
72 		/* Skip refs inherited from other devices */
73 		if (ref->from_other_dev)
74 			continue;
75 		err = handler_new_ref(hdl, ctrl, &new_ref, false, true);
76 		if (err)
77 			break;
78 	}
79 	mutex_unlock(from->lock);
80 	return err;
81 }
82 
83 static void v4l2_ctrl_request_queue(struct media_request_object *obj)
84 {
85 	struct v4l2_ctrl_handler *hdl =
86 		container_of(obj, struct v4l2_ctrl_handler, req_obj);
87 	struct v4l2_ctrl_handler *main_hdl = obj->priv;
88 
89 	mutex_lock(main_hdl->lock);
90 	list_add_tail(&hdl->requests_queued, &main_hdl->requests_queued);
91 	hdl->request_is_queued = true;
92 	mutex_unlock(main_hdl->lock);
93 }
94 
95 static void v4l2_ctrl_request_unbind(struct media_request_object *obj)
96 {
97 	struct v4l2_ctrl_handler *hdl =
98 		container_of(obj, struct v4l2_ctrl_handler, req_obj);
99 	struct v4l2_ctrl_handler *main_hdl = obj->priv;
100 
101 	mutex_lock(main_hdl->lock);
102 	list_del_init(&hdl->requests);
103 	if (hdl->request_is_queued) {
104 		list_del_init(&hdl->requests_queued);
105 		hdl->request_is_queued = false;
106 	}
107 	mutex_unlock(main_hdl->lock);
108 }
109 
110 static void v4l2_ctrl_request_release(struct media_request_object *obj)
111 {
112 	struct v4l2_ctrl_handler *hdl =
113 		container_of(obj, struct v4l2_ctrl_handler, req_obj);
114 
115 	v4l2_ctrl_handler_free(hdl);
116 	kfree(hdl);
117 }
118 
119 static const struct media_request_object_ops req_ops = {
120 	.queue = v4l2_ctrl_request_queue,
121 	.unbind = v4l2_ctrl_request_unbind,
122 	.release = v4l2_ctrl_request_release,
123 };
124 
125 struct v4l2_ctrl_handler *v4l2_ctrl_request_hdl_find(struct media_request *req,
126 						     struct v4l2_ctrl_handler *parent)
127 {
128 	struct media_request_object *obj;
129 
130 	if (WARN_ON(req->state != MEDIA_REQUEST_STATE_VALIDATING &&
131 		    req->state != MEDIA_REQUEST_STATE_QUEUED))
132 		return NULL;
133 
134 	obj = media_request_object_find(req, &req_ops, parent);
135 	if (obj)
136 		return container_of(obj, struct v4l2_ctrl_handler, req_obj);
137 	return NULL;
138 }
139 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_find);
140 
141 struct v4l2_ctrl *
142 v4l2_ctrl_request_hdl_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id)
143 {
144 	struct v4l2_ctrl_ref *ref = find_ref_lock(hdl, id);
145 
146 	return (ref && ref->valid_p_req) ? ref->ctrl : NULL;
147 }
148 EXPORT_SYMBOL_GPL(v4l2_ctrl_request_hdl_ctrl_find);
149 
150 static int v4l2_ctrl_request_bind(struct media_request *req,
151 				  struct v4l2_ctrl_handler *hdl,
152 				  struct v4l2_ctrl_handler *from)
153 {
154 	int ret;
155 
156 	ret = v4l2_ctrl_request_clone(hdl, from);
157 
158 	if (!ret) {
159 		ret = media_request_object_bind(req, &req_ops,
160 						from, false, &hdl->req_obj);
161 		if (!ret) {
162 			mutex_lock(from->lock);
163 			list_add_tail(&hdl->requests, &from->requests);
164 			mutex_unlock(from->lock);
165 		}
166 	}
167 	return ret;
168 }
169 
170 static struct media_request_object *
171 v4l2_ctrls_find_req_obj(struct v4l2_ctrl_handler *hdl,
172 			struct media_request *req, bool set)
173 {
174 	struct media_request_object *obj;
175 	struct v4l2_ctrl_handler *new_hdl;
176 	int ret;
177 
178 	if (IS_ERR(req))
179 		return ERR_CAST(req);
180 
181 	if (set && WARN_ON(req->state != MEDIA_REQUEST_STATE_UPDATING))
182 		return ERR_PTR(-EBUSY);
183 
184 	obj = media_request_object_find(req, &req_ops, hdl);
185 	if (obj)
186 		return obj;
187 	/*
188 	 * If there are no controls in this completed request,
189 	 * then that can only happen if:
190 	 *
191 	 * 1) no controls were present in the queued request, and
192 	 * 2) v4l2_ctrl_request_complete() could not allocate a
193 	 *    control handler object to store the completed state in.
194 	 *
195 	 * So return ENOMEM to indicate that there was an out-of-memory
196 	 * error.
197 	 */
198 	if (!set)
199 		return ERR_PTR(-ENOMEM);
200 
201 	new_hdl = kzalloc(sizeof(*new_hdl), GFP_KERNEL);
202 	if (!new_hdl)
203 		return ERR_PTR(-ENOMEM);
204 
205 	obj = &new_hdl->req_obj;
206 	ret = v4l2_ctrl_handler_init(new_hdl, (hdl->nr_of_buckets - 1) * 8);
207 	if (!ret)
208 		ret = v4l2_ctrl_request_bind(req, new_hdl, hdl);
209 	if (ret) {
210 		v4l2_ctrl_handler_free(new_hdl);
211 		kfree(new_hdl);
212 		return ERR_PTR(ret);
213 	}
214 
215 	media_request_object_get(obj);
216 	return obj;
217 }
218 
219 int v4l2_g_ext_ctrls_request(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
220 			     struct media_device *mdev, struct v4l2_ext_controls *cs)
221 {
222 	struct media_request_object *obj = NULL;
223 	struct media_request *req = NULL;
224 	int ret;
225 
226 	if (!mdev || cs->request_fd < 0)
227 		return -EINVAL;
228 
229 	req = media_request_get_by_fd(mdev, cs->request_fd);
230 	if (IS_ERR(req))
231 		return PTR_ERR(req);
232 
233 	if (req->state != MEDIA_REQUEST_STATE_COMPLETE) {
234 		media_request_put(req);
235 		return -EACCES;
236 	}
237 
238 	ret = media_request_lock_for_access(req);
239 	if (ret) {
240 		media_request_put(req);
241 		return ret;
242 	}
243 
244 	obj = v4l2_ctrls_find_req_obj(hdl, req, false);
245 	if (IS_ERR(obj)) {
246 		media_request_unlock_for_access(req);
247 		media_request_put(req);
248 		return PTR_ERR(obj);
249 	}
250 
251 	hdl = container_of(obj, struct v4l2_ctrl_handler,
252 			   req_obj);
253 	ret = v4l2_g_ext_ctrls_common(hdl, cs, vdev);
254 
255 	media_request_unlock_for_access(req);
256 	media_request_object_put(obj);
257 	media_request_put(req);
258 	return ret;
259 }
260 
261 int try_set_ext_ctrls_request(struct v4l2_fh *fh,
262 			      struct v4l2_ctrl_handler *hdl,
263 			      struct video_device *vdev,
264 			      struct media_device *mdev,
265 			      struct v4l2_ext_controls *cs, bool set)
266 {
267 	struct media_request_object *obj = NULL;
268 	struct media_request *req = NULL;
269 	int ret;
270 
271 	if (!mdev) {
272 		dprintk(vdev, "%s: missing media device\n",
273 			video_device_node_name(vdev));
274 		return -EINVAL;
275 	}
276 
277 	if (cs->request_fd < 0) {
278 		dprintk(vdev, "%s: invalid request fd %d\n",
279 			video_device_node_name(vdev), cs->request_fd);
280 		return -EINVAL;
281 	}
282 
283 	req = media_request_get_by_fd(mdev, cs->request_fd);
284 	if (IS_ERR(req)) {
285 		dprintk(vdev, "%s: cannot find request fd %d\n",
286 			video_device_node_name(vdev), cs->request_fd);
287 		return PTR_ERR(req);
288 	}
289 
290 	ret = media_request_lock_for_update(req);
291 	if (ret) {
292 		dprintk(vdev, "%s: cannot lock request fd %d\n",
293 			video_device_node_name(vdev), cs->request_fd);
294 		media_request_put(req);
295 		return ret;
296 	}
297 
298 	obj = v4l2_ctrls_find_req_obj(hdl, req, set);
299 	if (IS_ERR(obj)) {
300 		dprintk(vdev,
301 			"%s: cannot find request object for request fd %d\n",
302 			video_device_node_name(vdev),
303 			cs->request_fd);
304 		media_request_unlock_for_update(req);
305 		media_request_put(req);
306 		return PTR_ERR(obj);
307 	}
308 
309 	hdl = container_of(obj, struct v4l2_ctrl_handler,
310 			   req_obj);
311 	ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set);
312 	if (ret)
313 		dprintk(vdev,
314 			"%s: try_set_ext_ctrls_common failed (%d)\n",
315 			video_device_node_name(vdev), ret);
316 
317 	media_request_unlock_for_update(req);
318 	media_request_object_put(obj);
319 	media_request_put(req);
320 
321 	return ret;
322 }
323 
324 void v4l2_ctrl_request_complete(struct media_request *req,
325 				struct v4l2_ctrl_handler *main_hdl)
326 {
327 	struct media_request_object *obj;
328 	struct v4l2_ctrl_handler *hdl;
329 	struct v4l2_ctrl_ref *ref;
330 
331 	if (!req || !main_hdl)
332 		return;
333 
334 	/*
335 	 * Note that it is valid if nothing was found. It means
336 	 * that this request doesn't have any controls and so just
337 	 * wants to leave the controls unchanged.
338 	 */
339 	obj = media_request_object_find(req, &req_ops, main_hdl);
340 	if (!obj) {
341 		int ret;
342 
343 		/* Create a new request so the driver can return controls */
344 		hdl = kzalloc(sizeof(*hdl), GFP_KERNEL);
345 		if (!hdl)
346 			return;
347 
348 		ret = v4l2_ctrl_handler_init(hdl, (main_hdl->nr_of_buckets - 1) * 8);
349 		if (!ret)
350 			ret = v4l2_ctrl_request_bind(req, hdl, main_hdl);
351 		if (ret) {
352 			v4l2_ctrl_handler_free(hdl);
353 			kfree(hdl);
354 			return;
355 		}
356 		hdl->request_is_queued = true;
357 		obj = media_request_object_find(req, &req_ops, main_hdl);
358 	}
359 	hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
360 
361 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
362 		struct v4l2_ctrl *ctrl = ref->ctrl;
363 		struct v4l2_ctrl *master = ctrl->cluster[0];
364 		unsigned int i;
365 
366 		if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
367 			v4l2_ctrl_lock(master);
368 			/* g_volatile_ctrl will update the current control values */
369 			for (i = 0; i < master->ncontrols; i++)
370 				cur_to_new(master->cluster[i]);
371 			call_op(master, g_volatile_ctrl);
372 			new_to_req(ref);
373 			v4l2_ctrl_unlock(master);
374 			continue;
375 		}
376 		if (ref->valid_p_req)
377 			continue;
378 
379 		/* Copy the current control value into the request */
380 		v4l2_ctrl_lock(ctrl);
381 		cur_to_req(ref);
382 		v4l2_ctrl_unlock(ctrl);
383 	}
384 
385 	mutex_lock(main_hdl->lock);
386 	WARN_ON(!hdl->request_is_queued);
387 	list_del_init(&hdl->requests_queued);
388 	hdl->request_is_queued = false;
389 	mutex_unlock(main_hdl->lock);
390 	media_request_object_complete(obj);
391 	media_request_object_put(obj);
392 }
393 EXPORT_SYMBOL(v4l2_ctrl_request_complete);
394 
395 int v4l2_ctrl_request_setup(struct media_request *req,
396 			    struct v4l2_ctrl_handler *main_hdl)
397 {
398 	struct media_request_object *obj;
399 	struct v4l2_ctrl_handler *hdl;
400 	struct v4l2_ctrl_ref *ref;
401 	int ret = 0;
402 
403 	if (!req || !main_hdl)
404 		return 0;
405 
406 	if (WARN_ON(req->state != MEDIA_REQUEST_STATE_QUEUED))
407 		return -EBUSY;
408 
409 	/*
410 	 * Note that it is valid if nothing was found. It means
411 	 * that this request doesn't have any controls and so just
412 	 * wants to leave the controls unchanged.
413 	 */
414 	obj = media_request_object_find(req, &req_ops, main_hdl);
415 	if (!obj)
416 		return 0;
417 	if (obj->completed) {
418 		media_request_object_put(obj);
419 		return -EBUSY;
420 	}
421 	hdl = container_of(obj, struct v4l2_ctrl_handler, req_obj);
422 
423 	list_for_each_entry(ref, &hdl->ctrl_refs, node)
424 		ref->req_done = false;
425 
426 	list_for_each_entry(ref, &hdl->ctrl_refs, node) {
427 		struct v4l2_ctrl *ctrl = ref->ctrl;
428 		struct v4l2_ctrl *master = ctrl->cluster[0];
429 		bool have_new_data = false;
430 		int i;
431 
432 		/*
433 		 * Skip if this control was already handled by a cluster.
434 		 * Skip button controls and read-only controls.
435 		 */
436 		if (ref->req_done || (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY))
437 			continue;
438 
439 		v4l2_ctrl_lock(master);
440 		for (i = 0; i < master->ncontrols; i++) {
441 			if (master->cluster[i]) {
442 				struct v4l2_ctrl_ref *r =
443 					find_ref(hdl, master->cluster[i]->id);
444 
445 				if (r->valid_p_req) {
446 					have_new_data = true;
447 					break;
448 				}
449 			}
450 		}
451 		if (!have_new_data) {
452 			v4l2_ctrl_unlock(master);
453 			continue;
454 		}
455 
456 		for (i = 0; i < master->ncontrols; i++) {
457 			if (master->cluster[i]) {
458 				struct v4l2_ctrl_ref *r =
459 					find_ref(hdl, master->cluster[i]->id);
460 
461 				req_to_new(r);
462 				master->cluster[i]->is_new = 1;
463 				r->req_done = true;
464 			}
465 		}
466 		/*
467 		 * For volatile autoclusters that are currently in auto mode
468 		 * we need to discover if it will be set to manual mode.
469 		 * If so, then we have to copy the current volatile values
470 		 * first since those will become the new manual values (which
471 		 * may be overwritten by explicit new values from this set
472 		 * of controls).
473 		 */
474 		if (master->is_auto && master->has_volatiles &&
475 		    !is_cur_manual(master)) {
476 			s32 new_auto_val = *master->p_new.p_s32;
477 
478 			/*
479 			 * If the new value == the manual value, then copy
480 			 * the current volatile values.
481 			 */
482 			if (new_auto_val == master->manual_mode_value)
483 				update_from_auto_cluster(master);
484 		}
485 
486 		ret = try_or_set_cluster(NULL, master, true, 0);
487 		v4l2_ctrl_unlock(master);
488 
489 		if (ret)
490 			break;
491 	}
492 
493 	media_request_object_put(obj);
494 	return ret;
495 }
496 EXPORT_SYMBOL(v4l2_ctrl_request_setup);
497