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

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * V4L2 controls framework uAPI implementation:
   4  *
   5  * Copyright (C) 2010-2021  Hans Verkuil <[email protected]>
   6  */
   7
   8 #define pr_fmt(fmt) "v4l2-ctrls: " fmt
   9
  10 #include <linux/export.h>
  11 #include <linux/mm.h>
  12 #include <linux/slab.h>
  13 #include <media/v4l2-ctrls.h>
  14 #include <media/v4l2-dev.h>
  15 #include <media/v4l2-device.h>
  16 #include <media/v4l2-event.h>
  17 #include <media/v4l2-ioctl.h>
  18
  19 #include "v4l2-ctrls-priv.h"
  20
  21 /* Internal temporary helper struct, one for each v4l2_ext_control */
  22 struct v4l2_ctrl_helper {
  23         /* Pointer to the control reference of the master control */
  24         struct v4l2_ctrl_ref *mref;
  25         /* The control ref corresponding to the v4l2_ext_control ID field. */
  26         struct v4l2_ctrl_ref *ref;
  27         /*
  28          * v4l2_ext_control index of the next control belonging to the
  29          * same cluster, or 0 if there isn't any.
  30          */
  31         u32 next;
  32 };
  33
  34 /*
  35  * Helper functions to copy control payload data from kernel space to
  36  * user space and vice versa.
  37  */
  38
  39 /* Helper function: copy the given control value back to the caller */
  40 static int ptr_to_user(struct v4l2_ext_control *c,
  41                        struct v4l2_ctrl *ctrl,
  42                        union v4l2_ctrl_ptr ptr)
  43 {
  44         u32 len;
  45
  46         if (ctrl->is_ptr && !ctrl->is_string)
  47                 return copy_to_user(c->ptr, ptr.p_const, c->size) ?
  48                        -EFAULT : 0;
  49
  50         switch (ctrl->type) {
  51         case V4L2_CTRL_TYPE_STRING:
  52                 len = strlen(ptr.p_char);
  53                 if (c->size < len + 1) {
  54                         c->size = ctrl->elem_size;
  55                         return -ENOSPC;
  56                 }
  57                 return copy_to_user(c->string, ptr.p_char, len + 1) ?
  58                        -EFAULT : 0;
  59         case V4L2_CTRL_TYPE_INTEGER64:
  60                 c->value64 = *ptr.p_s64;
  61                 break;
  62         default:
  63                 c->value = *ptr.p_s32;
  64                 break;
  65         }
  66         return 0;
  67 }
  68
  69 /* Helper function: copy the current control value back to the caller */
  70 static int cur_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
  71 {
  72         return ptr_to_user(c, ctrl, ctrl->p_cur);
  73 }
  74
  75 /* Helper function: copy the new control value back to the caller */
  76 static int new_to_user(struct v4l2_ext_control *c,
  77                        struct v4l2_ctrl *ctrl)
  78 {
  79         return ptr_to_user(c, ctrl, ctrl->p_new);
  80 }
  81
  82 /* Helper function: copy the request value back to the caller */
  83 static int req_to_user(struct v4l2_ext_control *c,
  84                        struct v4l2_ctrl_ref *ref)
  85 {
  86         return ptr_to_user(c, ref->ctrl, ref->p_req);
  87 }
  88
  89 /* Helper function: copy the initial control value back to the caller */
  90 static int def_to_user(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
  91 {
  92         ctrl->type_ops->init(ctrl, 0, ctrl->p_new);
  93
  94         return ptr_to_user(c, ctrl, ctrl->p_new);
  95 }
  96
  97 /* Helper function: copy the caller-provider value as the new control value */
  98 static int user_to_new(struct v4l2_ext_control *c, struct v4l2_ctrl *ctrl)
  99 {
 100         int ret;
 101         u32 size;
 102
 103         ctrl->is_new = 0;
 104         if (ctrl->is_dyn_array &&
 105             c->size > ctrl->p_array_alloc_elems * ctrl->elem_size) {
 106                 void *old = ctrl->p_array;
 107                 void *tmp = kvzalloc(2 * c->size, GFP_KERNEL);
 108
 109                 if (!tmp)
 110                         return -ENOMEM;
 111                 memcpy(tmp, ctrl->p_new.p, ctrl->elems * ctrl->elem_size);
 112                 memcpy(tmp + c->size, ctrl->p_cur.p, ctrl->elems * ctrl->elem_size);
 113                 ctrl->p_new.p = tmp;
 114                 ctrl->p_cur.p = tmp + c->size;
 115                 ctrl->p_array = tmp;
 116                 ctrl->p_array_alloc_elems = c->size / ctrl->elem_size;
 117                 kvfree(old);
 118         }
 119
 120         if (ctrl->is_ptr && !ctrl->is_string) {
 121                 unsigned int elems = c->size / ctrl->elem_size;
 122
 123                 if (copy_from_user(ctrl->p_new.p, c->ptr, c->size))
 124                         return -EFAULT;
 125                 ctrl->is_new = 1;
 126                 if (ctrl->is_dyn_array)
 127                         ctrl->new_elems = elems;
 128                 else if (ctrl->is_array)
 129                         ctrl->type_ops->init(ctrl, elems, ctrl->p_new);
 130                 return 0;
 131         }
 132
 133         switch (ctrl->type) {
 134         case V4L2_CTRL_TYPE_INTEGER64:
 135                 *ctrl->p_new.p_s64 = c->value64;
 136                 break;
 137         case V4L2_CTRL_TYPE_STRING:
 138                 size = c->size;
 139                 if (size == 0)
 140                         return -ERANGE;
 141                 if (size > ctrl->maximum + 1)
 142                         size = ctrl->maximum + 1;
 143                 ret = copy_from_user(ctrl->p_new.p_char, c->string, size) ? -EFAULT : 0;
 144                 if (!ret) {
 145                         char last = ctrl->p_new.p_char[size - 1];
 146
 147                         ctrl->p_new.p_char[size - 1] = 0;
 148                         /*
 149                          * If the string was longer than ctrl->maximum,
 150                          * then return an error.
 151                          */
 152                         if (strlen(ctrl->p_new.p_char) == ctrl->maximum && last)
 153                                 return -ERANGE;
 154                         ctrl->is_new = 1;
 155                 }
 156                 return ret;
 157         default:
 158                 *ctrl->p_new.p_s32 = c->value;
 159                 break;
 160         }
 161         ctrl->is_new = 1;
 162         return 0;
 163 }
 164
 165 /*
 166  * VIDIOC_G/TRY/S_EXT_CTRLS implementation
 167  */
 168
 169 /*
 170  * Some general notes on the atomic requirements of VIDIOC_G/TRY/S_EXT_CTRLS:
 171  *
 172  * It is not a fully atomic operation, just best-effort only. After all, if
 173  * multiple controls have to be set through multiple i2c writes (for example)
 174  * then some initial writes may succeed while others fail. Thus leaving the
 175  * system in an inconsistent state. The question is how much effort you are
 176  * willing to spend on trying to make something atomic that really isn't.
 177  *
 178  * From the point of view of an application the main requirement is that
 179  * when you call VIDIOC_S_EXT_CTRLS and some values are invalid then an
 180  * error should be returned without actually affecting any controls.
 181  *
 182  * If all the values are correct, then it is acceptable to just give up
 183  * in case of low-level errors.
 184  *
 185  * It is important though that the application can tell when only a partial
 186  * configuration was done. The way we do that is through the error_idx field
 187  * of struct v4l2_ext_controls: if that is equal to the count field then no
 188  * controls were affected. Otherwise all controls before that index were
 189  * successful in performing their 'get' or 'set' operation, the control at
 190  * the given index failed, and you don't know what happened with the controls
 191  * after the failed one. Since if they were part of a control cluster they
 192  * could have been successfully processed (if a cluster member was encountered
 193  * at index < error_idx), they could have failed (if a cluster member was at
 194  * error_idx), or they may not have been processed yet (if the first cluster
 195  * member appeared after error_idx).
 196  *
 197  * It is all fairly theoretical, though. In practice all you can do is to
 198  * bail out. If error_idx == count, then it is an application bug. If
 199  * error_idx < count then it is only an application bug if the error code was
 200  * EBUSY. That usually means that something started streaming just when you
 201  * tried to set the controls. In all other cases it is a driver/hardware
 202  * problem and all you can do is to retry or bail out.
 203  *
 204  * Note that these rules do not apply to VIDIOC_TRY_EXT_CTRLS: since that
 205  * never modifies controls the error_idx is just set to whatever control
 206  * has an invalid value.
 207  */
 208
 209 /*
 210  * Prepare for the extended g/s/try functions.
 211  * Find the controls in the control array and do some basic checks.
 212  */
 213 static int prepare_ext_ctrls(struct v4l2_ctrl_handler *hdl,
 214                              struct v4l2_ext_controls *cs,
 215                              struct v4l2_ctrl_helper *helpers,
 216                              struct video_device *vdev,
 217                              bool get)
 218 {
 219         struct v4l2_ctrl_helper *h;
 220         bool have_clusters = false;
 221         u32 i;
 222
 223         for (i = 0, h = helpers; i < cs->count; i++, h++) {
 224                 struct v4l2_ext_control *c = &cs->controls[i];
 225                 struct v4l2_ctrl_ref *ref;
 226                 struct v4l2_ctrl *ctrl;
 227                 u32 id = c->id & V4L2_CTRL_ID_MASK;
 228
 229                 cs->error_idx = i;
 230
 231                 if (cs->which &&
 232                     cs->which != V4L2_CTRL_WHICH_DEF_VAL &&
 233                     cs->which != V4L2_CTRL_WHICH_REQUEST_VAL &&
 234                     V4L2_CTRL_ID2WHICH(id) != cs->which) {
 235                         dprintk(vdev,
 236                                 "invalid which 0x%x or control id 0x%x\n",
 237                                 cs->which, id);
 238                         return -EINVAL;
 239                 }
 240
 241                 /*
 242                  * Old-style private controls are not allowed for
 243                  * extended controls.
 244                  */
 245                 if (id >= V4L2_CID_PRIVATE_BASE) {
 246                         dprintk(vdev,
 247                                 "old-style private controls not allowed\n");
 248                         return -EINVAL;
 249                 }
 250                 ref = find_ref_lock(hdl, id);
 251                 if (!ref) {
 252                         dprintk(vdev, "cannot find control id 0x%x\n", id);
 253                         return -EINVAL;
 254                 }
 255                 h->ref = ref;
 256                 ctrl = ref->ctrl;
 257                 if (ctrl->flags & V4L2_CTRL_FLAG_DISABLED) {
 258                         dprintk(vdev, "control id 0x%x is disabled\n", id);
 259                         return -EINVAL;
 260                 }
 261
 262                 if (ctrl->cluster[0]->ncontrols > 1)
 263                         have_clusters = true;
 264                 if (ctrl->cluster[0] != ctrl)
 265                         ref = find_ref_lock(hdl, ctrl->cluster[0]->id);
 266                 if (ctrl->is_dyn_array) {
 267                         unsigned int max_size = ctrl->dims[0] * ctrl->elem_size;
 268                         unsigned int tot_size = ctrl->elem_size;
 269
 270                         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
 271                                 tot_size *= ref->p_req_elems;
 272                         else
 273                                 tot_size *= ctrl->elems;
 274
 275                         c->size = ctrl->elem_size * (c->size / ctrl->elem_size);
 276                         if (get) {
 277                                 if (c->size < tot_size) {
 278                                         c->size = tot_size;
 279                                         return -ENOSPC;
 280                                 }
 281                                 c->size = tot_size;
 282                         } else {
 283                                 if (c->size > max_size) {
 284                                         c->size = max_size;
 285                                         return -ENOSPC;
 286                                 }
 287                                 if (!c->size)
 288                                         return -EFAULT;
 289                         }
 290                 } else if (ctrl->is_ptr && !ctrl->is_string) {
 291                         unsigned int tot_size = ctrl->elems * ctrl->elem_size;
 292
 293                         if (c->size < tot_size) {
 294                                 /*
 295                                  * In the get case the application first
 296                                  * queries to obtain the size of the control.
 297                                  */
 298                                 if (get) {
 299                                         c->size = tot_size;
 300                                         return -ENOSPC;
 301                                 }
 302                                 dprintk(vdev,
 303                                         "pointer control id 0x%x size too small, %d bytes but %d bytes needed\n",
 304                                         id, c->size, tot_size);
 305                                 return -EFAULT;
 306                         }
 307                         c->size = tot_size;
 308                 }
 309                 /* Store the ref to the master control of the cluster */
 310                 h->mref = ref;
 311                 /*
 312                  * Initially set next to 0, meaning that there is no other
 313                  * control in this helper array belonging to the same
 314                  * cluster.
 315                  */
 316                 h->next = 0;
 317         }
 318
 319         /*
 320          * We are done if there were no controls that belong to a multi-
 321          * control cluster.
 322          */
 323         if (!have_clusters)
 324                 return 0;
 325
 326         /*
 327          * The code below figures out in O(n) time which controls in the list
 328          * belong to the same cluster.
 329          */
 330
 331         /* This has to be done with the handler lock taken. */
 332         mutex_lock(hdl->lock);
 333
 334         /* First zero the helper field in the master control references */
 335         for (i = 0; i < cs->count; i++)
 336                 helpers[i].mref->helper = NULL;
 337         for (i = 0, h = helpers; i < cs->count; i++, h++) {
 338                 struct v4l2_ctrl_ref *mref = h->mref;
 339
 340                 /*
 341                  * If the mref->helper is set, then it points to an earlier
 342                  * helper that belongs to the same cluster.
 343                  */
 344                 if (mref->helper) {
 345                         /*
 346                          * Set the next field of mref->helper to the current
 347                          * index: this means that the earlier helper now
 348                          * points to the next helper in the same cluster.
 349                          */
 350                         mref->helper->next = i;
 351                         /*
 352                          * mref should be set only for the first helper in the
 353                          * cluster, clear the others.
 354                          */
 355                         h->mref = NULL;
 356                 }
 357                 /* Point the mref helper to the current helper struct. */
 358                 mref->helper = h;
 359         }
 360         mutex_unlock(hdl->lock);
 361         return 0;
 362 }
 363
 364 /*
 365  * Handles the corner case where cs->count == 0. It checks whether the
 366  * specified control class exists. If that class ID is 0, then it checks
 367  * whether there are any controls at all.
 368  */
 369 static int class_check(struct v4l2_ctrl_handler *hdl, u32 which)
 370 {
 371         if (which == 0 || which == V4L2_CTRL_WHICH_DEF_VAL ||
 372             which == V4L2_CTRL_WHICH_REQUEST_VAL)
 373                 return 0;
 374         return find_ref_lock(hdl, which | 1) ? 0 : -EINVAL;
 375 }
 376
 377 /*
 378  * Get extended controls. Allocates the helpers array if needed.
 379  *
 380  * Note that v4l2_g_ext_ctrls_common() with 'which' set to
 381  * V4L2_CTRL_WHICH_REQUEST_VAL is only called if the request was
 382  * completed, and in that case p_req_valid is true for all controls.
 383  */
 384 int v4l2_g_ext_ctrls_common(struct v4l2_ctrl_handler *hdl,
 385                             struct v4l2_ext_controls *cs,
 386                             struct video_device *vdev)
 387 {
 388         struct v4l2_ctrl_helper helper[4];
 389         struct v4l2_ctrl_helper *helpers = helper;
 390         int ret;
 391         int i, j;
 392         bool is_default, is_request;
 393
 394         is_default = (cs->which == V4L2_CTRL_WHICH_DEF_VAL);
 395         is_request = (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL);
 396
 397         cs->error_idx = cs->count;
 398         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
 399
 400         if (!hdl)
 401                 return -EINVAL;
 402
 403         if (cs->count == 0)
 404                 return class_check(hdl, cs->which);
 405
 406         if (cs->count > ARRAY_SIZE(helper)) {
 407                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
 408                                          GFP_KERNEL);
 409                 if (!helpers)
 410                         return -ENOMEM;
 411         }
 412
 413         ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, true);
 414         cs->error_idx = cs->count;
 415
 416         for (i = 0; !ret && i < cs->count; i++)
 417                 if (helpers[i].ref->ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
 418                         ret = -EACCES;
 419
 420         for (i = 0; !ret && i < cs->count; i++) {
 421                 struct v4l2_ctrl *master;
 422                 bool is_volatile = false;
 423                 u32 idx = i;
 424
 425                 if (!helpers[i].mref)
 426                         continue;
 427
 428                 master = helpers[i].mref->ctrl;
 429                 cs->error_idx = i;
 430
 431                 v4l2_ctrl_lock(master);
 432
 433                 /*
 434                  * g_volatile_ctrl will update the new control values.
 435                  * This makes no sense for V4L2_CTRL_WHICH_DEF_VAL and
 436                  * V4L2_CTRL_WHICH_REQUEST_VAL. In the case of requests
 437                  * it is v4l2_ctrl_request_complete() that copies the
 438                  * volatile controls at the time of request completion
 439                  * to the request, so you don't want to do that again.
 440                  */
 441                 if (!is_default && !is_request &&
 442                     ((master->flags & V4L2_CTRL_FLAG_VOLATILE) ||
 443                     (master->has_volatiles && !is_cur_manual(master)))) {
 444                         for (j = 0; j < master->ncontrols; j++)
 445                                 cur_to_new(master->cluster[j]);
 446                         ret = call_op(master, g_volatile_ctrl);
 447                         is_volatile = true;
 448                 }
 449
 450                 if (ret) {
 451                         v4l2_ctrl_unlock(master);
 452                         break;
 453                 }
 454
 455                 /*
 456                  * Copy the default value (if is_default is true), the
 457                  * request value (if is_request is true and p_req is valid),
 458                  * the new volatile value (if is_volatile is true) or the
 459                  * current value.
 460                  */
 461                 do {
 462                         struct v4l2_ctrl_ref *ref = helpers[idx].ref;
 463
 464                         if (is_default)
 465                                 ret = def_to_user(cs->controls + idx, ref->ctrl);
 466                         else if (is_request && ref->p_req_array_enomem)
 467                                 ret = -ENOMEM;
 468                         else if (is_request && ref->p_req_valid)
 469                                 ret = req_to_user(cs->controls + idx, ref);
 470                         else if (is_volatile)
 471                                 ret = new_to_user(cs->controls + idx, ref->ctrl);
 472                         else
 473                                 ret = cur_to_user(cs->controls + idx, ref->ctrl);
 474                         idx = helpers[idx].next;
 475                 } while (!ret && idx);
 476
 477                 v4l2_ctrl_unlock(master);
 478         }
 479
 480         if (cs->count > ARRAY_SIZE(helper))
 481                 kvfree(helpers);
 482         return ret;
 483 }
 484
 485 int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct video_device *vdev,
 486                      struct media_device *mdev, struct v4l2_ext_controls *cs)
 487 {
 488         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
 489                 return v4l2_g_ext_ctrls_request(hdl, vdev, mdev, cs);
 490
 491         return v4l2_g_ext_ctrls_common(hdl, cs, vdev);
 492 }
 493 EXPORT_SYMBOL(v4l2_g_ext_ctrls);
 494
 495 /* Validate a new control */
 496 static int validate_new(const struct v4l2_ctrl *ctrl, union v4l2_ctrl_ptr p_new)
 497 {
 498         return ctrl->type_ops->validate(ctrl, p_new);
 499 }
 500
 501 /* Validate controls. */
 502 static int validate_ctrls(struct v4l2_ext_controls *cs,
 503                           struct v4l2_ctrl_helper *helpers,
 504                           struct video_device *vdev,
 505                           bool set)
 506 {
 507         unsigned int i;
 508         int ret = 0;
 509
 510         cs->error_idx = cs->count;
 511         for (i = 0; i < cs->count; i++) {
 512                 struct v4l2_ctrl *ctrl = helpers[i].ref->ctrl;
 513                 union v4l2_ctrl_ptr p_new;
 514
 515                 cs->error_idx = i;
 516
 517                 if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY) {
 518                         dprintk(vdev,
 519                                 "control id 0x%x is read-only\n",
 520                                 ctrl->id);
 521                         return -EACCES;
 522                 }
 523                 /*
 524                  * This test is also done in try_set_control_cluster() which
 525                  * is called in atomic context, so that has the final say,
 526                  * but it makes sense to do an up-front check as well. Once
 527                  * an error occurs in try_set_control_cluster() some other
 528                  * controls may have been set already and we want to do a
 529                  * best-effort to avoid that.
 530                  */
 531                 if (set && (ctrl->flags & V4L2_CTRL_FLAG_GRABBED)) {
 532                         dprintk(vdev,
 533                                 "control id 0x%x is grabbed, cannot set\n",
 534                                 ctrl->id);
 535                         return -EBUSY;
 536                 }
 537                 /*
 538                  * Skip validation for now if the payload needs to be copied
 539                  * from userspace into kernelspace. We'll validate those later.
 540                  */
 541                 if (ctrl->is_ptr)
 542                         continue;
 543                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
 544                         p_new.p_s64 = &cs->controls[i].value64;
 545                 else
 546                         p_new.p_s32 = &cs->controls[i].value;
 547                 ret = validate_new(ctrl, p_new);
 548                 if (ret)
 549                         return ret;
 550         }
 551         return 0;
 552 }
 553
 554 /* Try or try-and-set controls */
 555 int try_set_ext_ctrls_common(struct v4l2_fh *fh,
 556                              struct v4l2_ctrl_handler *hdl,
 557                              struct v4l2_ext_controls *cs,
 558                              struct video_device *vdev, bool set)
 559 {
 560         struct v4l2_ctrl_helper helper[4];
 561         struct v4l2_ctrl_helper *helpers = helper;
 562         unsigned int i, j;
 563         int ret;
 564
 565         cs->error_idx = cs->count;
 566
 567         /* Default value cannot be changed */
 568         if (cs->which == V4L2_CTRL_WHICH_DEF_VAL) {
 569                 dprintk(vdev, "%s: cannot change default value\n",
 570                         video_device_node_name(vdev));
 571                 return -EINVAL;
 572         }
 573
 574         cs->which = V4L2_CTRL_ID2WHICH(cs->which);
 575
 576         if (!hdl) {
 577                 dprintk(vdev, "%s: invalid null control handler\n",
 578                         video_device_node_name(vdev));
 579                 return -EINVAL;
 580         }
 581
 582         if (cs->count == 0)
 583                 return class_check(hdl, cs->which);
 584
 585         if (cs->count > ARRAY_SIZE(helper)) {
 586                 helpers = kvmalloc_array(cs->count, sizeof(helper[0]),
 587                                          GFP_KERNEL);
 588                 if (!helpers)
 589                         return -ENOMEM;
 590         }
 591         ret = prepare_ext_ctrls(hdl, cs, helpers, vdev, false);
 592         if (!ret)
 593                 ret = validate_ctrls(cs, helpers, vdev, set);
 594         if (ret && set)
 595                 cs->error_idx = cs->count;
 596         for (i = 0; !ret && i < cs->count; i++) {
 597                 struct v4l2_ctrl *master;
 598                 u32 idx = i;
 599
 600                 if (!helpers[i].mref)
 601                         continue;
 602
 603                 cs->error_idx = i;
 604                 master = helpers[i].mref->ctrl;
 605                 v4l2_ctrl_lock(master);
 606
 607                 /* Reset the 'is_new' flags of the cluster */
 608                 for (j = 0; j < master->ncontrols; j++)
 609                         if (master->cluster[j])
 610                                 master->cluster[j]->is_new = 0;
 611
 612                 /*
 613                  * For volatile autoclusters that are currently in auto mode
 614                  * we need to discover if it will be set to manual mode.
 615                  * If so, then we have to copy the current volatile values
 616                  * first since those will become the new manual values (which
 617                  * may be overwritten by explicit new values from this set
 618                  * of controls).
 619                  */
 620                 if (master->is_auto && master->has_volatiles &&
 621                     !is_cur_manual(master)) {
 622                         /* Pick an initial non-manual value */
 623                         s32 new_auto_val = master->manual_mode_value + 1;
 624                         u32 tmp_idx = idx;
 625
 626                         do {
 627                                 /*
 628                                  * Check if the auto control is part of the
 629                                  * list, and remember the new value.
 630                                  */
 631                                 if (helpers[tmp_idx].ref->ctrl == master)
 632                                         new_auto_val = cs->controls[tmp_idx].value;
 633                                 tmp_idx = helpers[tmp_idx].next;
 634                         } while (tmp_idx);
 635                         /*
 636                          * If the new value == the manual value, then copy
 637                          * the current volatile values.
 638                          */
 639                         if (new_auto_val == master->manual_mode_value)
 640                                 update_from_auto_cluster(master);
 641                 }
 642
 643                 /*
 644                  * Copy the new caller-supplied control values.
 645                  * user_to_new() sets 'is_new' to 1.
 646                  */
 647                 do {
 648                         struct v4l2_ctrl *ctrl = helpers[idx].ref->ctrl;
 649
 650                         ret = user_to_new(cs->controls + idx, ctrl);
 651                         if (!ret && ctrl->is_ptr) {
 652                                 ret = validate_new(ctrl, ctrl->p_new);
 653                                 if (ret)
 654                                         dprintk(vdev,
 655                                                 "failed to validate control %s (%d)\n",
 656                                                 v4l2_ctrl_get_name(ctrl->id), ret);
 657                         }
 658                         idx = helpers[idx].next;
 659                 } while (!ret && idx);
 660
 661                 if (!ret)
 662                         ret = try_or_set_cluster(fh, master,
 663                                                  !hdl->req_obj.req && set, 0);
 664                 if (!ret && hdl->req_obj.req && set) {
 665                         for (j = 0; j < master->ncontrols; j++) {
 666                                 struct v4l2_ctrl_ref *ref =
 667                                         find_ref(hdl, master->cluster[j]->id);
 668
 669                                 new_to_req(ref);
 670                         }
 671                 }
 672
 673                 /* Copy the new values back to userspace. */
 674                 if (!ret) {
 675                         idx = i;
 676                         do {
 677                                 ret = new_to_user(cs->controls + idx,
 678                                                   helpers[idx].ref->ctrl);
 679                                 idx = helpers[idx].next;
 680                         } while (!ret && idx);
 681                 }
 682                 v4l2_ctrl_unlock(master);
 683         }
 684
 685         if (cs->count > ARRAY_SIZE(helper))
 686                 kvfree(helpers);
 687         return ret;
 688 }
 689
 690 static int try_set_ext_ctrls(struct v4l2_fh *fh,
 691                              struct v4l2_ctrl_handler *hdl,
 692                              struct video_device *vdev,
 693                              struct media_device *mdev,
 694                              struct v4l2_ext_controls *cs, bool set)
 695 {
 696         int ret;
 697
 698         if (cs->which == V4L2_CTRL_WHICH_REQUEST_VAL)
 699                 return try_set_ext_ctrls_request(fh, hdl, vdev, mdev, cs, set);
 700
 701         ret = try_set_ext_ctrls_common(fh, hdl, cs, vdev, set);
 702         if (ret)
 703                 dprintk(vdev,
 704                         "%s: try_set_ext_ctrls_common failed (%d)\n",
 705                         video_device_node_name(vdev), ret);
 706
 707         return ret;
 708 }
 709
 710 int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl,
 711                        struct video_device *vdev,
 712                        struct media_device *mdev,
 713                        struct v4l2_ext_controls *cs)
 714 {
 715         return try_set_ext_ctrls(NULL, hdl, vdev, mdev, cs, false);
 716 }
 717 EXPORT_SYMBOL(v4l2_try_ext_ctrls);
 718
 719 int v4l2_s_ext_ctrls(struct v4l2_fh *fh,
 720                      struct v4l2_ctrl_handler *hdl,
 721                      struct video_device *vdev,
 722                      struct media_device *mdev,
 723                      struct v4l2_ext_controls *cs)
 724 {
 725         return try_set_ext_ctrls(fh, hdl, vdev, mdev, cs, true);
 726 }
 727 EXPORT_SYMBOL(v4l2_s_ext_ctrls);
 728
 729 /*
 730  * VIDIOC_G/S_CTRL implementation
 731  */
 732
 733 /* Helper function to get a single control */
 734 static int get_ctrl(struct v4l2_ctrl *ctrl, struct v4l2_ext_control *c)
 735 {
 736         struct v4l2_ctrl *master = ctrl->cluster[0];
 737         int ret = 0;
 738         int i;
 739
 740         /* Compound controls are not supported. The new_to_user() and
 741          * cur_to_user() calls below would need to be modified not to access
 742          * userspace memory when called from get_ctrl().
 743          */
 744         if (!ctrl->is_int && ctrl->type != V4L2_CTRL_TYPE_INTEGER64)
 745                 return -EINVAL;
 746
 747         if (ctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)
 748                 return -EACCES;
 749
 750         v4l2_ctrl_lock(master);
 751         /* g_volatile_ctrl will update the current control values */
 752         if (ctrl->flags & V4L2_CTRL_FLAG_VOLATILE) {
 753                 for (i = 0; i < master->ncontrols; i++)
 754                         cur_to_new(master->cluster[i]);
 755                 ret = call_op(master, g_volatile_ctrl);
 756                 new_to_user(c, ctrl);
 757         } else {
 758                 cur_to_user(c, ctrl);
 759         }
 760         v4l2_ctrl_unlock(master);
 761         return ret;
 762 }
 763
 764 int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *control)
 765 {
 766         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
 767         struct v4l2_ext_control c;
 768         int ret;
 769
 770         if (!ctrl || !ctrl->is_int)
 771                 return -EINVAL;
 772         ret = get_ctrl(ctrl, &c);
 773         control->value = c.value;
 774         return ret;
 775 }
 776 EXPORT_SYMBOL(v4l2_g_ctrl);
 777
 778 /* Helper function for VIDIOC_S_CTRL compatibility */
 779 static int set_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl, u32 ch_flags)
 780 {
 781         struct v4l2_ctrl *master = ctrl->cluster[0];
 782         int ret;
 783         int i;
 784
 785         /* Reset the 'is_new' flags of the cluster */
 786         for (i = 0; i < master->ncontrols; i++)
 787                 if (master->cluster[i])
 788                         master->cluster[i]->is_new = 0;
 789
 790         ret = validate_new(ctrl, ctrl->p_new);
 791         if (ret)
 792                 return ret;
 793
 794         /*
 795          * For autoclusters with volatiles that are switched from auto to
 796          * manual mode we have to update the current volatile values since
 797          * those will become the initial manual values after such a switch.
 798          */
 799         if (master->is_auto && master->has_volatiles && ctrl == master &&
 800             !is_cur_manual(master) && ctrl->val == master->manual_mode_value)
 801                 update_from_auto_cluster(master);
 802
 803         ctrl->is_new = 1;
 804         return try_or_set_cluster(fh, master, true, ch_flags);
 805 }
 806
 807 /* Helper function for VIDIOC_S_CTRL compatibility */
 808 static int set_ctrl_lock(struct v4l2_fh *fh, struct v4l2_ctrl *ctrl,
 809                          struct v4l2_ext_control *c)
 810 {
 811         int ret;
 812
 813         v4l2_ctrl_lock(ctrl);
 814         user_to_new(c, ctrl);
 815         ret = set_ctrl(fh, ctrl, 0);
 816         if (!ret)
 817                 cur_to_user(c, ctrl);
 818         v4l2_ctrl_unlock(ctrl);
 819         return ret;
 820 }
 821
 822 int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
 823                 struct v4l2_control *control)
 824 {
 825         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, control->id);
 826         struct v4l2_ext_control c = { control->id };
 827         int ret;
 828
 829         if (!ctrl || !ctrl->is_int)
 830                 return -EINVAL;
 831
 832         if (ctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)
 833                 return -EACCES;
 834
 835         c.value = control->value;
 836         ret = set_ctrl_lock(fh, ctrl, &c);
 837         control->value = c.value;
 838         return ret;
 839 }
 840 EXPORT_SYMBOL(v4l2_s_ctrl);
 841
 842 /*
 843  * Helper functions for drivers to get/set controls.
 844  */
 845
 846 s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl)
 847 {
 848         struct v4l2_ext_control c;
 849
 850         /* It's a driver bug if this happens. */
 851         if (WARN_ON(!ctrl->is_int))
 852                 return 0;
 853         c.value = 0;
 854         get_ctrl(ctrl, &c);
 855         return c.value;
 856 }
 857 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl);
 858
 859 s64 v4l2_ctrl_g_ctrl_int64(struct v4l2_ctrl *ctrl)
 860 {
 861         struct v4l2_ext_control c;
 862
 863         /* It's a driver bug if this happens. */
 864         if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
 865                 return 0;
 866         c.value64 = 0;
 867         get_ctrl(ctrl, &c);
 868         return c.value64;
 869 }
 870 EXPORT_SYMBOL(v4l2_ctrl_g_ctrl_int64);
 871
 872 int __v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val)
 873 {
 874         lockdep_assert_held(ctrl->handler->lock);
 875
 876         /* It's a driver bug if this happens. */
 877         if (WARN_ON(!ctrl->is_int))
 878                 return -EINVAL;
 879         ctrl->val = val;
 880         return set_ctrl(NULL, ctrl, 0);
 881 }
 882 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl);
 883
 884 int __v4l2_ctrl_s_ctrl_int64(struct v4l2_ctrl *ctrl, s64 val)
 885 {
 886         lockdep_assert_held(ctrl->handler->lock);
 887
 888         /* It's a driver bug if this happens. */
 889         if (WARN_ON(ctrl->is_ptr || ctrl->type != V4L2_CTRL_TYPE_INTEGER64))
 890                 return -EINVAL;
 891         *ctrl->p_new.p_s64 = val;
 892         return set_ctrl(NULL, ctrl, 0);
 893 }
 894 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_int64);
 895
 896 int __v4l2_ctrl_s_ctrl_string(struct v4l2_ctrl *ctrl, const char *s)
 897 {
 898         lockdep_assert_held(ctrl->handler->lock);
 899
 900         /* It's a driver bug if this happens. */
 901         if (WARN_ON(ctrl->type != V4L2_CTRL_TYPE_STRING))
 902                 return -EINVAL;
 903         strscpy(ctrl->p_new.p_char, s, ctrl->maximum + 1);
 904         return set_ctrl(NULL, ctrl, 0);
 905 }
 906 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_string);
 907
 908 int __v4l2_ctrl_s_ctrl_compound(struct v4l2_ctrl *ctrl,
 909                                 enum v4l2_ctrl_type type, const void *p)
 910 {
 911         lockdep_assert_held(ctrl->handler->lock);
 912
 913         /* It's a driver bug if this happens. */
 914         if (WARN_ON(ctrl->type != type))
 915                 return -EINVAL;
 916         /* Setting dynamic arrays is not (yet?) supported. */
 917         if (WARN_ON(ctrl->is_dyn_array))
 918                 return -EINVAL;
 919         memcpy(ctrl->p_new.p, p, ctrl->elems * ctrl->elem_size);
 920         return set_ctrl(NULL, ctrl, 0);
 921 }
 922 EXPORT_SYMBOL(__v4l2_ctrl_s_ctrl_compound);
 923
 924 /*
 925  * Modify the range of a control.
 926  */
 927 int __v4l2_ctrl_modify_range(struct v4l2_ctrl *ctrl,
 928                              s64 min, s64 max, u64 step, s64 def)
 929 {
 930         bool value_changed;
 931         bool range_changed = false;
 932         int ret;
 933
 934         lockdep_assert_held(ctrl->handler->lock);
 935
 936         switch (ctrl->type) {
 937         case V4L2_CTRL_TYPE_INTEGER:
 938         case V4L2_CTRL_TYPE_INTEGER64:
 939         case V4L2_CTRL_TYPE_BOOLEAN:
 940         case V4L2_CTRL_TYPE_MENU:
 941         case V4L2_CTRL_TYPE_INTEGER_MENU:
 942         case V4L2_CTRL_TYPE_BITMASK:
 943         case V4L2_CTRL_TYPE_U8:
 944         case V4L2_CTRL_TYPE_U16:
 945         case V4L2_CTRL_TYPE_U32:
 946                 if (ctrl->is_array)
 947                         return -EINVAL;
 948                 ret = check_range(ctrl->type, min, max, step, def);
 949                 if (ret)
 950                         return ret;
 951                 break;
 952         default:
 953                 return -EINVAL;
 954         }
 955         if (ctrl->minimum != min || ctrl->maximum != max ||
 956             ctrl->step != step || ctrl->default_value != def) {
 957                 range_changed = true;
 958                 ctrl->minimum = min;
 959                 ctrl->maximum = max;
 960                 ctrl->step = step;
 961                 ctrl->default_value = def;
 962         }
 963         cur_to_new(ctrl);
 964         if (validate_new(ctrl, ctrl->p_new)) {
 965                 if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
 966                         *ctrl->p_new.p_s64 = def;
 967                 else
 968                         *ctrl->p_new.p_s32 = def;
 969         }
 970
 971         if (ctrl->type == V4L2_CTRL_TYPE_INTEGER64)
 972                 value_changed = *ctrl->p_new.p_s64 != *ctrl->p_cur.p_s64;
 973         else
 974                 value_changed = *ctrl->p_new.p_s32 != *ctrl->p_cur.p_s32;
 975         if (value_changed)
 976                 ret = set_ctrl(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
 977         else if (range_changed)
 978                 send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_RANGE);
 979         return ret;
 980 }
 981 EXPORT_SYMBOL(__v4l2_ctrl_modify_range);
 982
 983 int __v4l2_ctrl_modify_dimensions(struct v4l2_ctrl *ctrl,
 984                                   u32 dims[V4L2_CTRL_MAX_DIMS])
 985 {
 986         unsigned int elems = 1;
 987         unsigned int i;
 988         void *p_array;
 989
 990         lockdep_assert_held(ctrl->handler->lock);
 991
 992         if (!ctrl->is_array || ctrl->is_dyn_array)
 993                 return -EINVAL;
 994
 995         for (i = 0; i < ctrl->nr_of_dims; i++)
 996                 elems *= dims[i];
 997         if (elems == 0)
 998                 return -EINVAL;
 999         p_array = kvzalloc(2 * elems * ctrl->elem_size, GFP_KERNEL);
1000         if (!p_array)
1001                 return -ENOMEM;
1002         kvfree(ctrl->p_array);
1003         ctrl->p_array_alloc_elems = elems;
1004         ctrl->elems = elems;
1005         ctrl->new_elems = elems;
1006         ctrl->p_array = p_array;
1007         ctrl->p_new.p = p_array;
1008         ctrl->p_cur.p = p_array + elems * ctrl->elem_size;
1009         for (i = 0; i < ctrl->nr_of_dims; i++)
1010                 ctrl->dims[i] = dims[i];
1011         ctrl->type_ops->init(ctrl, 0, ctrl->p_cur);
1012         cur_to_new(ctrl);
1013         send_event(NULL, ctrl, V4L2_EVENT_CTRL_CH_VALUE |
1014                                V4L2_EVENT_CTRL_CH_DIMENSIONS);
1015         return 0;
1016 }
1017 EXPORT_SYMBOL(__v4l2_ctrl_modify_dimensions);
1018
1019 /* Implement VIDIOC_QUERY_EXT_CTRL */
1020 int v4l2_query_ext_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_query_ext_ctrl *qc)
1021 {
1022         const unsigned int next_flags = V4L2_CTRL_FLAG_NEXT_CTRL | V4L2_CTRL_FLAG_NEXT_COMPOUND;
1023         u32 id = qc->id & V4L2_CTRL_ID_MASK;
1024         struct v4l2_ctrl_ref *ref;
1025         struct v4l2_ctrl *ctrl;
1026
1027         if (!hdl)
1028                 return -EINVAL;
1029
1030         mutex_lock(hdl->lock);
1031
1032         /* Try to find it */
1033         ref = find_ref(hdl, id);
1034
1035         if ((qc->id & next_flags) && !list_empty(&hdl->ctrl_refs)) {
1036                 bool is_compound;
1037                 /* Match any control that is not hidden */
1038                 unsigned int mask = 1;
1039                 bool match = false;
1040
1041                 if ((qc->id & next_flags) == V4L2_CTRL_FLAG_NEXT_COMPOUND) {
1042                         /* Match any hidden control */
1043                         match = true;
1044                 } else if ((qc->id & next_flags) == next_flags) {
1045                         /* Match any control, compound or not */
1046                         mask = 0;
1047                 }
1048
1049                 /* Find the next control with ID > qc->id */
1050
1051                 /* Did we reach the end of the control list? */
1052                 if (id >= node2id(hdl->ctrl_refs.prev)) {
1053                         ref = NULL; /* Yes, so there is no next control */
1054                 } else if (ref) {
1055                         /*
1056                          * We found a control with the given ID, so just get
1057                          * the next valid one in the list.
1058                          */
1059                         list_for_each_entry_continue(ref, &hdl->ctrl_refs, node) {
1060                                 is_compound = ref->ctrl->is_array ||
1061                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
1062                                 if (id < ref->ctrl->id &&
1063                                     (is_compound & mask) == match)
1064                                         break;
1065                         }
1066                         if (&ref->node == &hdl->ctrl_refs)
1067                                 ref = NULL;
1068                 } else {
1069                         /*
1070                          * No control with the given ID exists, so start
1071                          * searching for the next largest ID. We know there
1072                          * is one, otherwise the first 'if' above would have
1073                          * been true.
1074                          */
1075                         list_for_each_entry(ref, &hdl->ctrl_refs, node) {
1076                                 is_compound = ref->ctrl->is_array ||
1077                                         ref->ctrl->type >= V4L2_CTRL_COMPOUND_TYPES;
1078                                 if (id < ref->ctrl->id &&
1079                                     (is_compound & mask) == match)
1080                                         break;
1081                         }
1082                         if (&ref->node == &hdl->ctrl_refs)
1083                                 ref = NULL;
1084                 }
1085         }
1086         mutex_unlock(hdl->lock);
1087
1088         if (!ref)
1089                 return -EINVAL;
1090
1091         ctrl = ref->ctrl;
1092         memset(qc, 0, sizeof(*qc));
1093         if (id >= V4L2_CID_PRIVATE_BASE)
1094                 qc->id = id;
1095         else
1096                 qc->id = ctrl->id;
1097         strscpy(qc->name, ctrl->name, sizeof(qc->name));
1098         qc->flags = user_flags(ctrl);
1099         qc->type = ctrl->type;
1100         qc->elem_size = ctrl->elem_size;
1101         qc->elems = ctrl->elems;
1102         qc->nr_of_dims = ctrl->nr_of_dims;
1103         memcpy(qc->dims, ctrl->dims, qc->nr_of_dims * sizeof(qc->dims[0]));
1104         qc->minimum = ctrl->minimum;
1105         qc->maximum = ctrl->maximum;
1106         qc->default_value = ctrl->default_value;
1107         if (ctrl->type == V4L2_CTRL_TYPE_MENU ||
1108             ctrl->type == V4L2_CTRL_TYPE_INTEGER_MENU)
1109                 qc->step = 1;
1110         else
1111                 qc->step = ctrl->step;
1112         return 0;
1113 }
1114 EXPORT_SYMBOL(v4l2_query_ext_ctrl);
1115
1116 /* Implement VIDIOC_QUERYCTRL */
1117 int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc)
1118 {
1119         struct v4l2_query_ext_ctrl qec = { qc->id };
1120         int rc;
1121
1122         rc = v4l2_query_ext_ctrl(hdl, &qec);
1123         if (rc)
1124                 return rc;
1125
1126         qc->id = qec.id;
1127         qc->type = qec.type;
1128         qc->flags = qec.flags;
1129         strscpy(qc->name, qec.name, sizeof(qc->name));
1130         switch (qc->type) {
1131         case V4L2_CTRL_TYPE_INTEGER:
1132         case V4L2_CTRL_TYPE_BOOLEAN:
1133         case V4L2_CTRL_TYPE_MENU:
1134         case V4L2_CTRL_TYPE_INTEGER_MENU:
1135         case V4L2_CTRL_TYPE_STRING:
1136         case V4L2_CTRL_TYPE_BITMASK:
1137                 qc->minimum = qec.minimum;
1138                 qc->maximum = qec.maximum;
1139                 qc->step = qec.step;
1140                 qc->default_value = qec.default_value;
1141                 break;
1142         default:
1143                 qc->minimum = 0;
1144                 qc->maximum = 0;
1145                 qc->step = 0;
1146                 qc->default_value = 0;
1147                 break;
1148         }
1149         return 0;
1150 }
1151 EXPORT_SYMBOL(v4l2_queryctrl);
1152
1153 /* Implement VIDIOC_QUERYMENU */
1154 int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm)
1155 {
1156         struct v4l2_ctrl *ctrl;
1157         u32 i = qm->index;
1158
1159         ctrl = v4l2_ctrl_find(hdl, qm->id);
1160         if (!ctrl)
1161                 return -EINVAL;
1162
1163         qm->reserved = 0;
1164         /* Sanity checks */
1165         switch (ctrl->type) {
1166         case V4L2_CTRL_TYPE_MENU:
1167                 if (!ctrl->qmenu)
1168                         return -EINVAL;
1169                 break;
1170         case V4L2_CTRL_TYPE_INTEGER_MENU:
1171                 if (!ctrl->qmenu_int)
1172                         return -EINVAL;
1173                 break;
1174         default:
1175                 return -EINVAL;
1176         }
1177
1178         if (i < ctrl->minimum || i > ctrl->maximum)
1179                 return -EINVAL;
1180
1181         /* Use mask to see if this menu item should be skipped */
1182         if (ctrl->menu_skip_mask & (1ULL << i))
1183                 return -EINVAL;
1184         /* Empty menu items should also be skipped */
1185         if (ctrl->type == V4L2_CTRL_TYPE_MENU) {
1186                 if (!ctrl->qmenu[i] || ctrl->qmenu[i][0] == '\0')
1187                         return -EINVAL;
1188                 strscpy(qm->name, ctrl->qmenu[i], sizeof(qm->name));
1189         } else {
1190                 qm->value = ctrl->qmenu_int[i];
1191         }
1192         return 0;
1193 }
1194 EXPORT_SYMBOL(v4l2_querymenu);
1195
1196 /*
1197  * VIDIOC_LOG_STATUS helpers
1198  */
1199
1200 int v4l2_ctrl_log_status(struct file *file, void *fh)
1201 {
1202         struct video_device *vfd = video_devdata(file);
1203         struct v4l2_fh *vfh = file->private_data;
1204
1205         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) && vfd->v4l2_dev)
1206                 v4l2_ctrl_handler_log_status(vfh->ctrl_handler,
1207                                              vfd->v4l2_dev->name);
1208         return 0;
1209 }
1210 EXPORT_SYMBOL(v4l2_ctrl_log_status);
1211
1212 int v4l2_ctrl_subdev_log_status(struct v4l2_subdev *sd)
1213 {
1214         v4l2_ctrl_handler_log_status(sd->ctrl_handler, sd->name);
1215         return 0;
1216 }
1217 EXPORT_SYMBOL(v4l2_ctrl_subdev_log_status);
1218
1219 /*
1220  * VIDIOC_(UN)SUBSCRIBE_EVENT implementation
1221  */
1222
1223 static int v4l2_ctrl_add_event(struct v4l2_subscribed_event *sev,
1224                                unsigned int elems)
1225 {
1226         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
1227
1228         if (!ctrl)
1229                 return -EINVAL;
1230
1231         v4l2_ctrl_lock(ctrl);
1232         list_add_tail(&sev->node, &ctrl->ev_subs);
1233         if (ctrl->type != V4L2_CTRL_TYPE_CTRL_CLASS &&
1234             (sev->flags & V4L2_EVENT_SUB_FL_SEND_INITIAL))
1235                 send_initial_event(sev->fh, ctrl);
1236         v4l2_ctrl_unlock(ctrl);
1237         return 0;
1238 }
1239
1240 static void v4l2_ctrl_del_event(struct v4l2_subscribed_event *sev)
1241 {
1242         struct v4l2_ctrl *ctrl = v4l2_ctrl_find(sev->fh->ctrl_handler, sev->id);
1243
1244         if (!ctrl)
1245                 return;
1246
1247         v4l2_ctrl_lock(ctrl);
1248         list_del(&sev->node);
1249         v4l2_ctrl_unlock(ctrl);
1250 }
1251
1252 void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new)
1253 {
1254         u32 old_changes = old->u.ctrl.changes;
1255
1256         old->u.ctrl = new->u.ctrl;
1257         old->u.ctrl.changes |= old_changes;
1258 }
1259 EXPORT_SYMBOL(v4l2_ctrl_replace);
1260
1261 void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new)
1262 {
1263         new->u.ctrl.changes |= old->u.ctrl.changes;
1264 }
1265 EXPORT_SYMBOL(v4l2_ctrl_merge);
1266
1267 const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops = {
1268         .add = v4l2_ctrl_add_event,
1269         .del = v4l2_ctrl_del_event,
1270         .replace = v4l2_ctrl_replace,
1271         .merge = v4l2_ctrl_merge,
1272 };
1273 EXPORT_SYMBOL(v4l2_ctrl_sub_ev_ops);
1274
1275 int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
1276                               const struct v4l2_event_subscription *sub)
1277 {
1278         if (sub->type == V4L2_EVENT_CTRL)
1279                 return v4l2_event_subscribe(fh, sub, 0, &v4l2_ctrl_sub_ev_ops);
1280         return -EINVAL;
1281 }
1282 EXPORT_SYMBOL(v4l2_ctrl_subscribe_event);
1283
1284 int v4l2_ctrl_subdev_subscribe_event(struct v4l2_subdev *sd, struct v4l2_fh *fh,
1285                                      struct v4l2_event_subscription *sub)
1286 {
1287         if (!sd->ctrl_handler)
1288                 return -EINVAL;
1289         return v4l2_ctrl_subscribe_event(fh, sub);
1290 }
1291 EXPORT_SYMBOL(v4l2_ctrl_subdev_subscribe_event);
1292
1293 /*
1294  * poll helper
1295  */
1296 __poll_t v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait)
1297 {
1298         struct v4l2_fh *fh = file->private_data;
1299
1300         poll_wait(file, &fh->wait, wait);
1301         if (v4l2_event_pending(fh))
1302                 return EPOLLPRI;
1303         return 0;
1304 }
1305 EXPORT_SYMBOL(v4l2_ctrl_poll);