drivers/media/v4l2-core/v4l2-ctrls-request.c

   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 <[email protected]>
   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);