linux/include/media/v4l2-ctrls.h
<<
>>
Prefs
   1/*
   2    V4L2 controls support header.
   3
   4    Copyright (C) 2010  Hans Verkuil <hverkuil@xs4all.nl>
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21#ifndef _V4L2_CTRLS_H
  22#define _V4L2_CTRLS_H
  23
  24#include <linux/list.h>
  25#include <linux/videodev2.h>
  26
  27/* forward references */
  28struct file;
  29struct v4l2_ctrl_handler;
  30struct v4l2_ctrl_helper;
  31struct v4l2_ctrl;
  32struct video_device;
  33struct v4l2_subdev;
  34struct v4l2_subscribed_event;
  35struct v4l2_fh;
  36struct poll_table_struct;
  37
  38/** struct v4l2_ctrl_ops - The control operations that the driver has to provide.
  39  * @g_volatile_ctrl: Get a new value for this control. Generally only relevant
  40  *             for volatile (and usually read-only) controls such as a control
  41  *             that returns the current signal strength which changes
  42  *             continuously.
  43  *             If not set, then the currently cached value will be returned.
  44  * @try_ctrl:  Test whether the control's value is valid. Only relevant when
  45  *             the usual min/max/step checks are not sufficient.
  46  * @s_ctrl:    Actually set the new control value. s_ctrl is compulsory. The
  47  *             ctrl->handler->lock is held when these ops are called, so no
  48  *             one else can access controls owned by that handler.
  49  */
  50struct v4l2_ctrl_ops {
  51        int (*g_volatile_ctrl)(struct v4l2_ctrl *ctrl);
  52        int (*try_ctrl)(struct v4l2_ctrl *ctrl);
  53        int (*s_ctrl)(struct v4l2_ctrl *ctrl);
  54};
  55
  56/** struct v4l2_ctrl - The control structure.
  57  * @node:      The list node.
  58  * @ev_subs:   The list of control event subscriptions.
  59  * @handler:   The handler that owns the control.
  60  * @cluster:   Point to start of cluster array.
  61  * @ncontrols: Number of controls in cluster array.
  62  * @done:      Internal flag: set for each processed control.
  63  * @is_new:    Set when the user specified a new value for this control. It
  64  *             is also set when called from v4l2_ctrl_handler_setup. Drivers
  65  *             should never set this flag.
  66  * @is_private: If set, then this control is private to its handler and it
  67  *             will not be added to any other handlers. Drivers can set
  68  *             this flag.
  69  * @is_auto:   If set, then this control selects whether the other cluster
  70  *             members are in 'automatic' mode or 'manual' mode. This is
  71  *             used for autogain/gain type clusters. Drivers should never
  72  *             set this flag directly.
  73  * @has_volatiles: If set, then one or more members of the cluster are volatile.
  74  *             Drivers should never touch this flag.
  75  * @manual_mode_value: If the is_auto flag is set, then this is the value
  76  *             of the auto control that determines if that control is in
  77  *             manual mode. So if the value of the auto control equals this
  78  *             value, then the whole cluster is in manual mode. Drivers should
  79  *             never set this flag directly.
  80  * @ops:       The control ops.
  81  * @id:        The control ID.
  82  * @name:      The control name.
  83  * @type:      The control type.
  84  * @minimum:   The control's minimum value.
  85  * @maximum:   The control's maximum value.
  86  * @default_value: The control's default value.
  87  * @step:      The control's step value for non-menu controls.
  88  * @menu_skip_mask: The control's skip mask for menu controls. This makes it
  89  *             easy to skip menu items that are not valid. If bit X is set,
  90  *             then menu item X is skipped. Of course, this only works for
  91  *             menus with <= 32 menu items. There are no menus that come
  92  *             close to that number, so this is OK. Should we ever need more,
  93  *             then this will have to be extended to a u64 or a bit array.
  94  * @qmenu:     A const char * array for all menu items. Array entries that are
  95  *             empty strings ("") correspond to non-existing menu items (this
  96  *             is in addition to the menu_skip_mask above). The last entry
  97  *             must be NULL.
  98  * @flags:     The control's flags.
  99  * @cur:       The control's current value.
 100  * @val:       The control's new s32 value.
 101  * @val64:     The control's new s64 value.
 102  * @string:    The control's new string value.
 103  * @priv:      The control's private pointer. For use by the driver. It is
 104  *             untouched by the control framework. Note that this pointer is
 105  *             not freed when the control is deleted. Should this be needed
 106  *             then a new internal bitfield can be added to tell the framework
 107  *             to free this pointer.
 108  */
 109struct v4l2_ctrl {
 110        /* Administrative fields */
 111        struct list_head node;
 112        struct list_head ev_subs;
 113        struct v4l2_ctrl_handler *handler;
 114        struct v4l2_ctrl **cluster;
 115        unsigned ncontrols;
 116        unsigned int done:1;
 117
 118        unsigned int is_new:1;
 119        unsigned int is_private:1;
 120        unsigned int is_auto:1;
 121        unsigned int has_volatiles:1;
 122        unsigned int manual_mode_value:8;
 123
 124        const struct v4l2_ctrl_ops *ops;
 125        u32 id;
 126        const char *name;
 127        enum v4l2_ctrl_type type;
 128        s32 minimum, maximum, default_value;
 129        union {
 130                u32 step;
 131                u32 menu_skip_mask;
 132        };
 133        union {
 134                const char * const *qmenu;
 135                const s64 *qmenu_int;
 136        };
 137        unsigned long flags;
 138        union {
 139                s32 val;
 140                s64 val64;
 141                char *string;
 142        } cur;
 143        union {
 144                s32 val;
 145                s64 val64;
 146                char *string;
 147        };
 148        void *priv;
 149};
 150
 151/** struct v4l2_ctrl_ref - The control reference.
 152  * @node:      List node for the sorted list.
 153  * @next:      Single-link list node for the hash.
 154  * @ctrl:      The actual control information.
 155  * @helper:    Pointer to helper struct. Used internally in prepare_ext_ctrls().
 156  *
 157  * Each control handler has a list of these refs. The list_head is used to
 158  * keep a sorted-by-control-ID list of all controls, while the next pointer
 159  * is used to link the control in the hash's bucket.
 160  */
 161struct v4l2_ctrl_ref {
 162        struct list_head node;
 163        struct v4l2_ctrl_ref *next;
 164        struct v4l2_ctrl *ctrl;
 165        struct v4l2_ctrl_helper *helper;
 166};
 167
 168/** struct v4l2_ctrl_handler - The control handler keeps track of all the
 169  * controls: both the controls owned by the handler and those inherited
 170  * from other handlers.
 171  * @_lock:     Default for "lock".
 172  * @lock:      Lock to control access to this handler and its controls.
 173  *             May be replaced by the user right after init.
 174  * @ctrls:     The list of controls owned by this handler.
 175  * @ctrl_refs: The list of control references.
 176  * @cached:    The last found control reference. It is common that the same
 177  *             control is needed multiple times, so this is a simple
 178  *             optimization.
 179  * @buckets:   Buckets for the hashing. Allows for quick control lookup.
 180  * @nr_of_buckets: Total number of buckets in the array.
 181  * @error:     The error code of the first failed control addition.
 182  */
 183struct v4l2_ctrl_handler {
 184        struct mutex _lock;
 185        struct mutex *lock;
 186        struct list_head ctrls;
 187        struct list_head ctrl_refs;
 188        struct v4l2_ctrl_ref *cached;
 189        struct v4l2_ctrl_ref **buckets;
 190        u16 nr_of_buckets;
 191        int error;
 192};
 193
 194/** struct v4l2_ctrl_config - Control configuration structure.
 195  * @ops:       The control ops.
 196  * @id:        The control ID.
 197  * @name:      The control name.
 198  * @type:      The control type.
 199  * @min:       The control's minimum value.
 200  * @max:       The control's maximum value.
 201  * @step:      The control's step value for non-menu controls.
 202  * @def:       The control's default value.
 203  * @flags:     The control's flags.
 204  * @menu_skip_mask: The control's skip mask for menu controls. This makes it
 205  *             easy to skip menu items that are not valid. If bit X is set,
 206  *             then menu item X is skipped. Of course, this only works for
 207  *             menus with <= 32 menu items. There are no menus that come
 208  *             close to that number, so this is OK. Should we ever need more,
 209  *             then this will have to be extended to a u64 or a bit array.
 210  * @qmenu:     A const char * array for all menu items. Array entries that are
 211  *             empty strings ("") correspond to non-existing menu items (this
 212  *             is in addition to the menu_skip_mask above). The last entry
 213  *             must be NULL.
 214  * @is_private: If set, then this control is private to its handler and it
 215  *             will not be added to any other handlers.
 216  */
 217struct v4l2_ctrl_config {
 218        const struct v4l2_ctrl_ops *ops;
 219        u32 id;
 220        const char *name;
 221        enum v4l2_ctrl_type type;
 222        s32 min;
 223        s32 max;
 224        u32 step;
 225        s32 def;
 226        u32 flags;
 227        u32 menu_skip_mask;
 228        const char * const *qmenu;
 229        const s64 *qmenu_int;
 230        unsigned int is_private:1;
 231};
 232
 233/** v4l2_ctrl_fill() - Fill in the control fields based on the control ID.
 234  *
 235  * This works for all standard V4L2 controls.
 236  * For non-standard controls it will only fill in the given arguments
 237  * and @name will be NULL.
 238  *
 239  * This function will overwrite the contents of @name, @type and @flags.
 240  * The contents of @min, @max, @step and @def may be modified depending on
 241  * the type.
 242  *
 243  * Do not use in drivers! It is used internally for backwards compatibility
 244  * control handling only. Once all drivers are converted to use the new
 245  * control framework this function will no longer be exported.
 246  */
 247void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
 248                    s32 *min, s32 *max, s32 *step, s32 *def, u32 *flags);
 249
 250
 251/** v4l2_ctrl_handler_init() - Initialize the control handler.
 252  * @hdl:       The control handler.
 253  * @nr_of_controls_hint: A hint of how many controls this handler is
 254  *             expected to refer to. This is the total number, so including
 255  *             any inherited controls. It doesn't have to be precise, but if
 256  *             it is way off, then you either waste memory (too many buckets
 257  *             are allocated) or the control lookup becomes slower (not enough
 258  *             buckets are allocated, so there are more slow list lookups).
 259  *             It will always work, though.
 260  *
 261  * Returns an error if the buckets could not be allocated. This error will
 262  * also be stored in @hdl->error.
 263  */
 264int v4l2_ctrl_handler_init(struct v4l2_ctrl_handler *hdl,
 265                           unsigned nr_of_controls_hint);
 266
 267/** v4l2_ctrl_handler_free() - Free all controls owned by the handler and free
 268  * the control list.
 269  * @hdl:       The control handler.
 270  *
 271  * Does nothing if @hdl == NULL.
 272  */
 273void v4l2_ctrl_handler_free(struct v4l2_ctrl_handler *hdl);
 274
 275/** v4l2_ctrl_handler_setup() - Call the s_ctrl op for all controls belonging
 276  * to the handler to initialize the hardware to the current control values.
 277  * @hdl:       The control handler.
 278  *
 279  * Button controls will be skipped, as are read-only controls.
 280  *
 281  * If @hdl == NULL, then this just returns 0.
 282  */
 283int v4l2_ctrl_handler_setup(struct v4l2_ctrl_handler *hdl);
 284
 285/** v4l2_ctrl_handler_log_status() - Log all controls owned by the handler.
 286  * @hdl:       The control handler.
 287  * @prefix:    The prefix to use when logging the control values. If the
 288  *             prefix does not end with a space, then ": " will be added
 289  *             after the prefix. If @prefix == NULL, then no prefix will be
 290  *             used.
 291  *
 292  * For use with VIDIOC_LOG_STATUS.
 293  *
 294  * Does nothing if @hdl == NULL.
 295  */
 296void v4l2_ctrl_handler_log_status(struct v4l2_ctrl_handler *hdl,
 297                                  const char *prefix);
 298
 299/** v4l2_ctrl_new_custom() - Allocate and initialize a new custom V4L2
 300  * control.
 301  * @hdl:       The control handler.
 302  * @cfg:       The control's configuration data.
 303  * @priv:      The control's driver-specific private data.
 304  *
 305  * If the &v4l2_ctrl struct could not be allocated then NULL is returned
 306  * and @hdl->error is set to the error code (if it wasn't set already).
 307  */
 308struct v4l2_ctrl *v4l2_ctrl_new_custom(struct v4l2_ctrl_handler *hdl,
 309                        const struct v4l2_ctrl_config *cfg, void *priv);
 310
 311/** v4l2_ctrl_new_std() - Allocate and initialize a new standard V4L2 non-menu control.
 312  * @hdl:       The control handler.
 313  * @ops:       The control ops.
 314  * @id:        The control ID.
 315  * @min:       The control's minimum value.
 316  * @max:       The control's maximum value.
 317  * @step:      The control's step value
 318  * @def:       The control's default value.
 319  *
 320  * If the &v4l2_ctrl struct could not be allocated, or the control
 321  * ID is not known, then NULL is returned and @hdl->error is set to the
 322  * appropriate error code (if it wasn't set already).
 323  *
 324  * If @id refers to a menu control, then this function will return NULL.
 325  *
 326  * Use v4l2_ctrl_new_std_menu() when adding menu controls.
 327  */
 328struct v4l2_ctrl *v4l2_ctrl_new_std(struct v4l2_ctrl_handler *hdl,
 329                        const struct v4l2_ctrl_ops *ops,
 330                        u32 id, s32 min, s32 max, u32 step, s32 def);
 331
 332/** v4l2_ctrl_new_std_menu() - Allocate and initialize a new standard V4L2 menu control.
 333  * @hdl:       The control handler.
 334  * @ops:       The control ops.
 335  * @id:        The control ID.
 336  * @max:       The control's maximum value.
 337  * @mask:      The control's skip mask for menu controls. This makes it
 338  *             easy to skip menu items that are not valid. If bit X is set,
 339  *             then menu item X is skipped. Of course, this only works for
 340  *             menus with <= 32 menu items. There are no menus that come
 341  *             close to that number, so this is OK. Should we ever need more,
 342  *             then this will have to be extended to a u64 or a bit array.
 343  * @def:       The control's default value.
 344  *
 345  * Same as v4l2_ctrl_new_std(), but @min is set to 0 and the @mask value
 346  * determines which menu items are to be skipped.
 347  *
 348  * If @id refers to a non-menu control, then this function will return NULL.
 349  */
 350struct v4l2_ctrl *v4l2_ctrl_new_std_menu(struct v4l2_ctrl_handler *hdl,
 351                        const struct v4l2_ctrl_ops *ops,
 352                        u32 id, s32 max, s32 mask, s32 def);
 353
 354/** v4l2_ctrl_new_int_menu() - Create a new standard V4L2 integer menu control.
 355  * @hdl:       The control handler.
 356  * @ops:       The control ops.
 357  * @id:        The control ID.
 358  * @max:       The control's maximum value.
 359  * @def:       The control's default value.
 360  * @qmenu_int: The control's menu entries.
 361  *
 362  * Same as v4l2_ctrl_new_std_menu(), but @mask is set to 0 and it additionaly
 363  * takes as an argument an array of integers determining the menu items.
 364  *
 365  * If @id refers to a non-integer-menu control, then this function will return NULL.
 366  */
 367struct v4l2_ctrl *v4l2_ctrl_new_int_menu(struct v4l2_ctrl_handler *hdl,
 368                        const struct v4l2_ctrl_ops *ops,
 369                        u32 id, s32 max, s32 def, const s64 *qmenu_int);
 370
 371/** v4l2_ctrl_add_ctrl() - Add a control from another handler to this handler.
 372  * @hdl:       The control handler.
 373  * @ctrl:      The control to add.
 374  *
 375  * It will return NULL if it was unable to add the control reference.
 376  * If the control already belonged to the handler, then it will do
 377  * nothing and just return @ctrl.
 378  */
 379struct v4l2_ctrl *v4l2_ctrl_add_ctrl(struct v4l2_ctrl_handler *hdl,
 380                                          struct v4l2_ctrl *ctrl);
 381
 382/** v4l2_ctrl_add_handler() - Add all controls from handler @add to
 383  * handler @hdl.
 384  * @hdl:       The control handler.
 385  * @add:       The control handler whose controls you want to add to
 386  *             the @hdl control handler.
 387  *
 388  * Does nothing if either of the two is a NULL pointer.
 389  * In case of an error @hdl->error will be set to the error code (if it
 390  * wasn't set already).
 391  */
 392int v4l2_ctrl_add_handler(struct v4l2_ctrl_handler *hdl,
 393                          struct v4l2_ctrl_handler *add);
 394
 395
 396/** v4l2_ctrl_cluster() - Mark all controls in the cluster as belonging to that cluster.
 397  * @ncontrols: The number of controls in this cluster.
 398  * @controls:  The cluster control array of size @ncontrols.
 399  */
 400void v4l2_ctrl_cluster(unsigned ncontrols, struct v4l2_ctrl **controls);
 401
 402
 403/** v4l2_ctrl_auto_cluster() - Mark all controls in the cluster as belonging to
 404  * that cluster and set it up for autofoo/foo-type handling.
 405  * @ncontrols: The number of controls in this cluster.
 406  * @controls:  The cluster control array of size @ncontrols. The first control
 407  *             must be the 'auto' control (e.g. autogain, autoexposure, etc.)
 408  * @manual_val: The value for the first control in the cluster that equals the
 409  *             manual setting.
 410  * @set_volatile: If true, then all controls except the first auto control will
 411  *             be volatile.
 412  *
 413  * Use for control groups where one control selects some automatic feature and
 414  * the other controls are only active whenever the automatic feature is turned
 415  * off (manual mode). Typical examples: autogain vs gain, auto-whitebalance vs
 416  * red and blue balance, etc.
 417  *
 418  * The behavior of such controls is as follows:
 419  *
 420  * When the autofoo control is set to automatic, then any manual controls
 421  * are set to inactive and any reads will call g_volatile_ctrl (if the control
 422  * was marked volatile).
 423  *
 424  * When the autofoo control is set to manual, then any manual controls will
 425  * be marked active, and any reads will just return the current value without
 426  * going through g_volatile_ctrl.
 427  *
 428  * In addition, this function will set the V4L2_CTRL_FLAG_UPDATE flag
 429  * on the autofoo control and V4L2_CTRL_FLAG_INACTIVE on the foo control(s)
 430  * if autofoo is in auto mode.
 431  */
 432void v4l2_ctrl_auto_cluster(unsigned ncontrols, struct v4l2_ctrl **controls,
 433                        u8 manual_val, bool set_volatile);
 434
 435
 436/** v4l2_ctrl_find() - Find a control with the given ID.
 437  * @hdl:       The control handler.
 438  * @id:        The control ID to find.
 439  *
 440  * If @hdl == NULL this will return NULL as well. Will lock the handler so
 441  * do not use from inside &v4l2_ctrl_ops.
 442  */
 443struct v4l2_ctrl *v4l2_ctrl_find(struct v4l2_ctrl_handler *hdl, u32 id);
 444
 445/** v4l2_ctrl_activate() - Make the control active or inactive.
 446  * @ctrl:      The control to (de)activate.
 447  * @active:    True if the control should become active.
 448  *
 449  * This sets or clears the V4L2_CTRL_FLAG_INACTIVE flag atomically.
 450  * Does nothing if @ctrl == NULL.
 451  * This will usually be called from within the s_ctrl op.
 452  * The V4L2_EVENT_CTRL event will be generated afterwards.
 453  *
 454  * This function assumes that the control handler is locked.
 455  */
 456void v4l2_ctrl_activate(struct v4l2_ctrl *ctrl, bool active);
 457
 458/** v4l2_ctrl_grab() - Mark the control as grabbed or not grabbed.
 459  * @ctrl:      The control to (de)activate.
 460  * @grabbed:   True if the control should become grabbed.
 461  *
 462  * This sets or clears the V4L2_CTRL_FLAG_GRABBED flag atomically.
 463  * Does nothing if @ctrl == NULL.
 464  * The V4L2_EVENT_CTRL event will be generated afterwards.
 465  * This will usually be called when starting or stopping streaming in the
 466  * driver.
 467  *
 468  * This function assumes that the control handler is not locked and will
 469  * take the lock itself.
 470  */
 471void v4l2_ctrl_grab(struct v4l2_ctrl *ctrl, bool grabbed);
 472
 473/** v4l2_ctrl_lock() - Helper function to lock the handler
 474  * associated with the control.
 475  * @ctrl:      The control to lock.
 476  */
 477static inline void v4l2_ctrl_lock(struct v4l2_ctrl *ctrl)
 478{
 479        mutex_lock(ctrl->handler->lock);
 480}
 481
 482/** v4l2_ctrl_lock() - Helper function to unlock the handler
 483  * associated with the control.
 484  * @ctrl:      The control to unlock.
 485  */
 486static inline void v4l2_ctrl_unlock(struct v4l2_ctrl *ctrl)
 487{
 488        mutex_unlock(ctrl->handler->lock);
 489}
 490
 491/** v4l2_ctrl_g_ctrl() - Helper function to get the control's value from within a driver.
 492  * @ctrl:      The control.
 493  *
 494  * This returns the control's value safely by going through the control
 495  * framework. This function will lock the control's handler, so it cannot be
 496  * used from within the &v4l2_ctrl_ops functions.
 497  *
 498  * This function is for integer type controls only.
 499  */
 500s32 v4l2_ctrl_g_ctrl(struct v4l2_ctrl *ctrl);
 501
 502/** v4l2_ctrl_s_ctrl() - Helper function to set the control's value from within a driver.
 503  * @ctrl:      The control.
 504  * @val:       The new value.
 505  *
 506  * This set the control's new value safely by going through the control
 507  * framework. This function will lock the control's handler, so it cannot be
 508  * used from within the &v4l2_ctrl_ops functions.
 509  *
 510  * This function is for integer type controls only.
 511  */
 512int v4l2_ctrl_s_ctrl(struct v4l2_ctrl *ctrl, s32 val);
 513
 514/* Internal helper functions that deal with control events. */
 515extern const struct v4l2_subscribed_event_ops v4l2_ctrl_sub_ev_ops;
 516void v4l2_ctrl_replace(struct v4l2_event *old, const struct v4l2_event *new);
 517void v4l2_ctrl_merge(const struct v4l2_event *old, struct v4l2_event *new);
 518
 519/* Can be used as a vidioc_log_status function that just dumps all controls
 520   associated with the filehandle. */
 521int v4l2_ctrl_log_status(struct file *file, void *fh);
 522
 523/* Can be used as a vidioc_subscribe_event function that just subscribes
 524   control events. */
 525int v4l2_ctrl_subscribe_event(struct v4l2_fh *fh,
 526                                struct v4l2_event_subscription *sub);
 527
 528/* Can be used as a poll function that just polls for control events. */
 529unsigned int v4l2_ctrl_poll(struct file *file, struct poll_table_struct *wait);
 530
 531/* Helpers for ioctl_ops. If hdl == NULL then they will all return -EINVAL. */
 532int v4l2_queryctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_queryctrl *qc);
 533int v4l2_querymenu(struct v4l2_ctrl_handler *hdl, struct v4l2_querymenu *qm);
 534int v4l2_g_ctrl(struct v4l2_ctrl_handler *hdl, struct v4l2_control *ctrl);
 535int v4l2_s_ctrl(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
 536                                                struct v4l2_control *ctrl);
 537int v4l2_g_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *c);
 538int v4l2_try_ext_ctrls(struct v4l2_ctrl_handler *hdl, struct v4l2_ext_controls *c);
 539int v4l2_s_ext_ctrls(struct v4l2_fh *fh, struct v4l2_ctrl_handler *hdl,
 540                                                struct v4l2_ext_controls *c);
 541
 542/* Helpers for subdevices. If the associated ctrl_handler == NULL then they
 543   will all return -EINVAL. */
 544int v4l2_subdev_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc);
 545int v4l2_subdev_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
 546int v4l2_subdev_g_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
 547int v4l2_subdev_try_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
 548int v4l2_subdev_s_ext_ctrls(struct v4l2_subdev *sd, struct v4l2_ext_controls *cs);
 549int v4l2_subdev_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
 550int v4l2_subdev_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
 551
 552#endif
 553
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.