Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : /*
       3                 :            :  *
       4                 :            :  *      V 4 L 2   D R I V E R   H E L P E R   A P I
       5                 :            :  *
       6                 :            :  * Moved from videodev2.h
       7                 :            :  *
       8                 :            :  *      Some commonly needed functions for drivers (v4l2-common.o module)
       9                 :            :  */
      10                 :            : #ifndef _V4L2_DEV_H
      11                 :            : #define _V4L2_DEV_H
      12                 :            : 
      13                 :            : #include <linux/poll.h>
      14                 :            : #include <linux/fs.h>
      15                 :            : #include <linux/device.h>
      16                 :            : #include <linux/cdev.h>
      17                 :            : #include <linux/mutex.h>
      18                 :            : #include <linux/videodev2.h>
      19                 :            : 
      20                 :            : #include <media/media-entity.h>
      21                 :            : 
      22                 :            : #define VIDEO_MAJOR     81
      23                 :            : 
      24                 :            : /**
      25                 :            :  * enum vfl_devnode_type - type of V4L2 device node
      26                 :            :  *
      27                 :            :  * @VFL_TYPE_GRABBER:   for video input/output devices
      28                 :            :  * @VFL_TYPE_VBI:       for vertical blank data (i.e. closed captions, teletext)
      29                 :            :  * @VFL_TYPE_RADIO:     for radio tuners
      30                 :            :  * @VFL_TYPE_SUBDEV:    for V4L2 subdevices
      31                 :            :  * @VFL_TYPE_SDR:       for Software Defined Radio tuners
      32                 :            :  * @VFL_TYPE_TOUCH:     for touch sensors
      33                 :            :  * @VFL_TYPE_MAX:       number of VFL types, must always be last in the enum
      34                 :            :  */
      35                 :            : enum vfl_devnode_type {
      36                 :            :         VFL_TYPE_GRABBER        = 0,
      37                 :            :         VFL_TYPE_VIDEO = VFL_TYPE_GRABBER,
      38                 :            :         VFL_TYPE_VBI,
      39                 :            :         VFL_TYPE_RADIO,
      40                 :            :         VFL_TYPE_SUBDEV,
      41                 :            :         VFL_TYPE_SDR,
      42                 :            :         VFL_TYPE_TOUCH,
      43                 :            :         VFL_TYPE_MAX /* Shall be the last one */
      44                 :            : };
      45                 :            : 
      46                 :            : /**
      47                 :            :  * enum  vfl_direction - Identifies if a &struct video_device corresponds
      48                 :            :  *      to a receiver, a transmitter or a mem-to-mem device.
      49                 :            :  *
      50                 :            :  * @VFL_DIR_RX:         device is a receiver.
      51                 :            :  * @VFL_DIR_TX:         device is a transmitter.
      52                 :            :  * @VFL_DIR_M2M:        device is a memory to memory device.
      53                 :            :  *
      54                 :            :  * Note: Ignored if &enum vfl_devnode_type is %VFL_TYPE_SUBDEV.
      55                 :            :  */
      56                 :            : enum vfl_devnode_direction {
      57                 :            :         VFL_DIR_RX,
      58                 :            :         VFL_DIR_TX,
      59                 :            :         VFL_DIR_M2M,
      60                 :            : };
      61                 :            : 
      62                 :            : struct v4l2_ioctl_callbacks;
      63                 :            : struct video_device;
      64                 :            : struct v4l2_device;
      65                 :            : struct v4l2_ctrl_handler;
      66                 :            : 
      67                 :            : /**
      68                 :            :  * enum v4l2_video_device_flags - Flags used by &struct video_device
      69                 :            :  *
      70                 :            :  * @V4L2_FL_REGISTERED:
      71                 :            :  *      indicates that a &struct video_device is registered.
      72                 :            :  *      Drivers can clear this flag if they want to block all future
      73                 :            :  *      device access. It is cleared by video_unregister_device.
      74                 :            :  * @V4L2_FL_USES_V4L2_FH:
      75                 :            :  *      indicates that file->private_data points to &struct v4l2_fh.
      76                 :            :  *      This flag is set by the core when v4l2_fh_init() is called.
      77                 :            :  *      All new drivers should use it.
      78                 :            :  * @V4L2_FL_QUIRK_INVERTED_CROP:
      79                 :            :  *      some old M2M drivers use g/s_crop/cropcap incorrectly: crop and
      80                 :            :  *      compose are swapped. If this flag is set, then the selection
      81                 :            :  *      targets are swapped in the g/s_crop/cropcap functions in v4l2-ioctl.c.
      82                 :            :  *      This allows those drivers to correctly implement the selection API,
      83                 :            :  *      but the old crop API will still work as expected in order to preserve
      84                 :            :  *      backwards compatibility.
      85                 :            :  *      Never set this flag for new drivers.
      86                 :            :  * @V4L2_FL_SUBDEV_RO_DEVNODE:
      87                 :            :  *      indicates that the video device node is registered in read-only mode.
      88                 :            :  *      The flag only applies to device nodes registered for sub-devices, it is
      89                 :            :  *      set by the core when the sub-devices device nodes are registered with
      90                 :            :  *      v4l2_device_register_ro_subdev_nodes() and used by the sub-device ioctl
      91                 :            :  *      handler to restrict access to some ioctl calls.
      92                 :            :  */
      93                 :            : enum v4l2_video_device_flags {
      94                 :            :         V4L2_FL_REGISTERED              = 0,
      95                 :            :         V4L2_FL_USES_V4L2_FH            = 1,
      96                 :            :         V4L2_FL_QUIRK_INVERTED_CROP     = 2,
      97                 :            :         V4L2_FL_SUBDEV_RO_DEVNODE       = 3,
      98                 :            : };
      99                 :            : 
     100                 :            : /* Priority helper functions */
     101                 :            : 
     102                 :            : /**
     103                 :            :  * struct v4l2_prio_state - stores the priority states
     104                 :            :  *
     105                 :            :  * @prios: array with elements to store the array priorities
     106                 :            :  *
     107                 :            :  *
     108                 :            :  * .. note::
     109                 :            :  *    The size of @prios array matches the number of priority types defined
     110                 :            :  *    by enum &v4l2_priority.
     111                 :            :  */
     112                 :            : struct v4l2_prio_state {
     113                 :            :         atomic_t prios[4];
     114                 :            : };
     115                 :            : 
     116                 :            : /**
     117                 :            :  * v4l2_prio_init - initializes a struct v4l2_prio_state
     118                 :            :  *
     119                 :            :  * @global: pointer to &struct v4l2_prio_state
     120                 :            :  */
     121                 :            : void v4l2_prio_init(struct v4l2_prio_state *global);
     122                 :            : 
     123                 :            : /**
     124                 :            :  * v4l2_prio_change - changes the v4l2 file handler priority
     125                 :            :  *
     126                 :            :  * @global: pointer to the &struct v4l2_prio_state of the device node.
     127                 :            :  * @local: pointer to the desired priority, as defined by enum &v4l2_priority
     128                 :            :  * @new: Priority type requested, as defined by enum &v4l2_priority.
     129                 :            :  *
     130                 :            :  * .. note::
     131                 :            :  *      This function should be used only by the V4L2 core.
     132                 :            :  */
     133                 :            : int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
     134                 :            :                      enum v4l2_priority new);
     135                 :            : 
     136                 :            : /**
     137                 :            :  * v4l2_prio_open - Implements the priority logic for a file handler open
     138                 :            :  *
     139                 :            :  * @global: pointer to the &struct v4l2_prio_state of the device node.
     140                 :            :  * @local: pointer to the desired priority, as defined by enum &v4l2_priority
     141                 :            :  *
     142                 :            :  * .. note::
     143                 :            :  *      This function should be used only by the V4L2 core.
     144                 :            :  */
     145                 :            : void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
     146                 :            : 
     147                 :            : /**
     148                 :            :  * v4l2_prio_close - Implements the priority logic for a file handler close
     149                 :            :  *
     150                 :            :  * @global: pointer to the &struct v4l2_prio_state of the device node.
     151                 :            :  * @local: priority to be released, as defined by enum &v4l2_priority
     152                 :            :  *
     153                 :            :  * .. note::
     154                 :            :  *      This function should be used only by the V4L2 core.
     155                 :            :  */
     156                 :            : void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local);
     157                 :            : 
     158                 :            : /**
     159                 :            :  * v4l2_prio_max - Return the maximum priority, as stored at the @global array.
     160                 :            :  *
     161                 :            :  * @global: pointer to the &struct v4l2_prio_state of the device node.
     162                 :            :  *
     163                 :            :  * .. note::
     164                 :            :  *      This function should be used only by the V4L2 core.
     165                 :            :  */
     166                 :            : enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
     167                 :            : 
     168                 :            : /**
     169                 :            :  * v4l2_prio_check - Implements the priority logic for a file handler close
     170                 :            :  *
     171                 :            :  * @global: pointer to the &struct v4l2_prio_state of the device node.
     172                 :            :  * @local: desired priority, as defined by enum &v4l2_priority local
     173                 :            :  *
     174                 :            :  * .. note::
     175                 :            :  *      This function should be used only by the V4L2 core.
     176                 :            :  */
     177                 :            : int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local);
     178                 :            : 
     179                 :            : /**
     180                 :            :  * struct v4l2_file_operations - fs operations used by a V4L2 device
     181                 :            :  *
     182                 :            :  * @owner: pointer to struct module
     183                 :            :  * @read: operations needed to implement the read() syscall
     184                 :            :  * @write: operations needed to implement the write() syscall
     185                 :            :  * @poll: operations needed to implement the poll() syscall
     186                 :            :  * @unlocked_ioctl: operations needed to implement the ioctl() syscall
     187                 :            :  * @compat_ioctl32: operations needed to implement the ioctl() syscall for
     188                 :            :  *      the special case where the Kernel uses 64 bits instructions, but
     189                 :            :  *      the userspace uses 32 bits.
     190                 :            :  * @get_unmapped_area: called by the mmap() syscall, used when %!CONFIG_MMU
     191                 :            :  * @mmap: operations needed to implement the mmap() syscall
     192                 :            :  * @open: operations needed to implement the open() syscall
     193                 :            :  * @release: operations needed to implement the release() syscall
     194                 :            :  *
     195                 :            :  * .. note::
     196                 :            :  *
     197                 :            :  *      Those operations are used to implemente the fs struct file_operations
     198                 :            :  *      at the V4L2 drivers. The V4L2 core overrides the fs ops with some
     199                 :            :  *      extra logic needed by the subsystem.
     200                 :            :  */
     201                 :            : struct v4l2_file_operations {
     202                 :            :         struct module *owner;
     203                 :            :         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
     204                 :            :         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
     205                 :            :         __poll_t (*poll) (struct file *, struct poll_table_struct *);
     206                 :            :         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
     207                 :            : #ifdef CONFIG_COMPAT
     208                 :            :         long (*compat_ioctl32) (struct file *, unsigned int, unsigned long);
     209                 :            : #endif
     210                 :            :         unsigned long (*get_unmapped_area) (struct file *, unsigned long,
     211                 :            :                                 unsigned long, unsigned long, unsigned long);
     212                 :            :         int (*mmap) (struct file *, struct vm_area_struct *);
     213                 :            :         int (*open) (struct file *);
     214                 :            :         int (*release) (struct file *);
     215                 :            : };
     216                 :            : 
     217                 :            : /*
     218                 :            :  * Newer version of video_device, handled by videodev2.c
     219                 :            :  *      This version moves redundant code from video device code to
     220                 :            :  *      the common handler
     221                 :            :  */
     222                 :            : 
     223                 :            : /**
     224                 :            :  * struct video_device - Structure used to create and manage the V4L2 device
     225                 :            :  *      nodes.
     226                 :            :  *
     227                 :            :  * @entity: &struct media_entity
     228                 :            :  * @intf_devnode: pointer to &struct media_intf_devnode
     229                 :            :  * @pipe: &struct media_pipeline
     230                 :            :  * @fops: pointer to &struct v4l2_file_operations for the video device
     231                 :            :  * @device_caps: device capabilities as used in v4l2_capabilities
     232                 :            :  * @dev: &struct device for the video device
     233                 :            :  * @cdev: character device
     234                 :            :  * @v4l2_dev: pointer to &struct v4l2_device parent
     235                 :            :  * @dev_parent: pointer to &struct device parent
     236                 :            :  * @ctrl_handler: Control handler associated with this device node.
     237                 :            :  *       May be NULL.
     238                 :            :  * @queue: &struct vb2_queue associated with this device node. May be NULL.
     239                 :            :  * @prio: pointer to &struct v4l2_prio_state with device's Priority state.
     240                 :            :  *       If NULL, then v4l2_dev->prio will be used.
     241                 :            :  * @name: video device name
     242                 :            :  * @vfl_type: V4L device type, as defined by &enum vfl_devnode_type
     243                 :            :  * @vfl_dir: V4L receiver, transmitter or m2m
     244                 :            :  * @minor: device node 'minor'. It is set to -1 if the registration failed
     245                 :            :  * @num: number of the video device node
     246                 :            :  * @flags: video device flags. Use bitops to set/clear/test flags.
     247                 :            :  *         Contains a set of &enum v4l2_video_device_flags.
     248                 :            :  * @index: attribute to differentiate multiple indices on one physical device
     249                 :            :  * @fh_lock: Lock for all v4l2_fhs
     250                 :            :  * @fh_list: List of &struct v4l2_fh
     251                 :            :  * @dev_debug: Internal device debug flags, not for use by drivers
     252                 :            :  * @tvnorms: Supported tv norms
     253                 :            :  *
     254                 :            :  * @release: video device release() callback
     255                 :            :  * @ioctl_ops: pointer to &struct v4l2_ioctl_ops with ioctl callbacks
     256                 :            :  *
     257                 :            :  * @valid_ioctls: bitmap with the valid ioctls for this device
     258                 :            :  * @lock: pointer to &struct mutex serialization lock
     259                 :            :  *
     260                 :            :  * .. note::
     261                 :            :  *      Only set @dev_parent if that can't be deduced from @v4l2_dev.
     262                 :            :  */
     263                 :            : 
     264                 :            : struct video_device
     265                 :            : {
     266                 :            : #if defined(CONFIG_MEDIA_CONTROLLER)
     267                 :            :         struct media_entity entity;
     268                 :            :         struct media_intf_devnode *intf_devnode;
     269                 :            :         struct media_pipeline pipe;
     270                 :            : #endif
     271                 :            :         const struct v4l2_file_operations *fops;
     272                 :            : 
     273                 :            :         u32 device_caps;
     274                 :            : 
     275                 :            :         /* sysfs */
     276                 :            :         struct device dev;
     277                 :            :         struct cdev *cdev;
     278                 :            : 
     279                 :            :         struct v4l2_device *v4l2_dev;
     280                 :            :         struct device *dev_parent;
     281                 :            : 
     282                 :            :         struct v4l2_ctrl_handler *ctrl_handler;
     283                 :            : 
     284                 :            :         struct vb2_queue *queue;
     285                 :            : 
     286                 :            :         struct v4l2_prio_state *prio;
     287                 :            : 
     288                 :            :         /* device info */
     289                 :            :         char name[32];
     290                 :            :         enum vfl_devnode_type vfl_type;
     291                 :            :         enum vfl_devnode_direction vfl_dir;
     292                 :            :         int minor;
     293                 :            :         u16 num;
     294                 :            :         unsigned long flags;
     295                 :            :         int index;
     296                 :            : 
     297                 :            :         /* V4L2 file handles */
     298                 :            :         spinlock_t              fh_lock;
     299                 :            :         struct list_head        fh_list;
     300                 :            : 
     301                 :            :         int dev_debug;
     302                 :            : 
     303                 :            :         v4l2_std_id tvnorms;
     304                 :            : 
     305                 :            :         /* callbacks */
     306                 :            :         void (*release)(struct video_device *vdev);
     307                 :            :         const struct v4l2_ioctl_ops *ioctl_ops;
     308                 :            :         DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
     309                 :            : 
     310                 :            :         struct mutex *lock;
     311                 :            : };
     312                 :            : 
     313                 :            : /**
     314                 :            :  * media_entity_to_video_device - Returns a &struct video_device from
     315                 :            :  *      the &struct media_entity embedded on it.
     316                 :            :  *
     317                 :            :  * @__entity: pointer to &struct media_entity
     318                 :            :  */
     319                 :            : #define media_entity_to_video_device(__entity) \
     320                 :            :         container_of(__entity, struct video_device, entity)
     321                 :            : 
     322                 :            : /**
     323                 :            :  * to_video_device - Returns a &struct video_device from the
     324                 :            :  *      &struct device embedded on it.
     325                 :            :  *
     326                 :            :  * @cd: pointer to &struct device
     327                 :            :  */
     328                 :            : #define to_video_device(cd) container_of(cd, struct video_device, dev)
     329                 :            : 
     330                 :            : /**
     331                 :            :  * __video_register_device - register video4linux devices
     332                 :            :  *
     333                 :            :  * @vdev: struct video_device to register
     334                 :            :  * @type: type of device to register, as defined by &enum vfl_devnode_type
     335                 :            :  * @nr:   which device node number is desired:
     336                 :            :  *      (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
     337                 :            :  * @warn_if_nr_in_use: warn if the desired device node number
     338                 :            :  *        was already in use and another number was chosen instead.
     339                 :            :  * @owner: module that owns the video device node
     340                 :            :  *
     341                 :            :  * The registration code assigns minor numbers and device node numbers
     342                 :            :  * based on the requested type and registers the new device node with
     343                 :            :  * the kernel.
     344                 :            :  *
     345                 :            :  * This function assumes that struct video_device was zeroed when it
     346                 :            :  * was allocated and does not contain any stale date.
     347                 :            :  *
     348                 :            :  * An error is returned if no free minor or device node number could be
     349                 :            :  * found, or if the registration of the device node failed.
     350                 :            :  *
     351                 :            :  * Returns 0 on success.
     352                 :            :  *
     353                 :            :  * .. note::
     354                 :            :  *
     355                 :            :  *      This function is meant to be used only inside the V4L2 core.
     356                 :            :  *      Drivers should use video_register_device() or
     357                 :            :  *      video_register_device_no_warn().
     358                 :            :  */
     359                 :            : int __must_check __video_register_device(struct video_device *vdev,
     360                 :            :                                          enum vfl_devnode_type type,
     361                 :            :                                          int nr, int warn_if_nr_in_use,
     362                 :            :                                          struct module *owner);
     363                 :            : 
     364                 :            : /**
     365                 :            :  *  video_register_device - register video4linux devices
     366                 :            :  *
     367                 :            :  * @vdev: struct video_device to register
     368                 :            :  * @type: type of device to register, as defined by &enum vfl_devnode_type
     369                 :            :  * @nr:   which device node number is desired:
     370                 :            :  *      (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
     371                 :            :  *
     372                 :            :  * Internally, it calls __video_register_device(). Please see its
     373                 :            :  * documentation for more details.
     374                 :            :  *
     375                 :            :  * .. note::
     376                 :            :  *      if video_register_device fails, the release() callback of
     377                 :            :  *      &struct video_device structure is *not* called, so the caller
     378                 :            :  *      is responsible for freeing any data. Usually that means that
     379                 :            :  *      you video_device_release() should be called on failure.
     380                 :            :  */
     381                 :            : static inline int __must_check video_register_device(struct video_device *vdev,
     382                 :            :                                                      enum vfl_devnode_type type,
     383                 :            :                                                      int nr)
     384                 :            : {
     385                 :          3 :         return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
     386                 :            : }
     387                 :            : 
     388                 :            : /**
     389                 :            :  *  video_register_device_no_warn - register video4linux devices
     390                 :            :  *
     391                 :            :  * @vdev: struct video_device to register
     392                 :            :  * @type: type of device to register, as defined by &enum vfl_devnode_type
     393                 :            :  * @nr:   which device node number is desired:
     394                 :            :  *      (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
     395                 :            :  *
     396                 :            :  * This function is identical to video_register_device() except that no
     397                 :            :  * warning is issued if the desired device node number was already in use.
     398                 :            :  *
     399                 :            :  * Internally, it calls __video_register_device(). Please see its
     400                 :            :  * documentation for more details.
     401                 :            :  *
     402                 :            :  * .. note::
     403                 :            :  *      if video_register_device fails, the release() callback of
     404                 :            :  *      &struct video_device structure is *not* called, so the caller
     405                 :            :  *      is responsible for freeing any data. Usually that means that
     406                 :            :  *      you video_device_release() should be called on failure.
     407                 :            :  */
     408                 :            : static inline int __must_check
     409                 :            : video_register_device_no_warn(struct video_device *vdev,
     410                 :            :                               enum vfl_devnode_type type, int nr)
     411                 :            : {
     412                 :            :         return __video_register_device(vdev, type, nr, 0, vdev->fops->owner);
     413                 :            : }
     414                 :            : 
     415                 :            : /**
     416                 :            :  * video_unregister_device - Unregister video devices.
     417                 :            :  *
     418                 :            :  * @vdev: &struct video_device to register
     419                 :            :  *
     420                 :            :  * Does nothing if vdev == NULL or if video_is_registered() returns false.
     421                 :            :  */
     422                 :            : void video_unregister_device(struct video_device *vdev);
     423                 :            : 
     424                 :            : /**
     425                 :            :  * video_device_alloc - helper function to alloc &struct video_device
     426                 :            :  *
     427                 :            :  * Returns NULL if %-ENOMEM or a &struct video_device on success.
     428                 :            :  */
     429                 :            : struct video_device * __must_check video_device_alloc(void);
     430                 :            : 
     431                 :            : /**
     432                 :            :  * video_device_release - helper function to release &struct video_device
     433                 :            :  *
     434                 :            :  * @vdev: pointer to &struct video_device
     435                 :            :  *
     436                 :            :  * Can also be used for video_device->release\(\).
     437                 :            :  */
     438                 :            : void video_device_release(struct video_device *vdev);
     439                 :            : 
     440                 :            : /**
     441                 :            :  * video_device_release_empty - helper function to implement the
     442                 :            :  *      video_device->release\(\) callback.
     443                 :            :  *
     444                 :            :  * @vdev: pointer to &struct video_device
     445                 :            :  *
     446                 :            :  * This release function does nothing.
     447                 :            :  *
     448                 :            :  * It should be used when the video_device is a static global struct.
     449                 :            :  *
     450                 :            :  * .. note::
     451                 :            :  *      Having a static video_device is a dubious construction at best.
     452                 :            :  */
     453                 :            : void video_device_release_empty(struct video_device *vdev);
     454                 :            : 
     455                 :            : /**
     456                 :            :  * v4l2_disable_ioctl- mark that a given command isn't implemented.
     457                 :            :  *      shouldn't use core locking
     458                 :            :  *
     459                 :            :  * @vdev: pointer to &struct video_device
     460                 :            :  * @cmd: ioctl command
     461                 :            :  *
     462                 :            :  * This function allows drivers to provide just one v4l2_ioctl_ops struct, but
     463                 :            :  * disable ioctls based on the specific card that is actually found.
     464                 :            :  *
     465                 :            :  * .. note::
     466                 :            :  *
     467                 :            :  *    This must be called before video_register_device.
     468                 :            :  *    See also the comments for determine_valid_ioctls().
     469                 :            :  */
     470                 :            : static inline void v4l2_disable_ioctl(struct video_device *vdev,
     471                 :            :                                       unsigned int cmd)
     472                 :            : {
     473                 :            :         if (_IOC_NR(cmd) < BASE_VIDIOC_PRIVATE)
     474                 :          3 :                 set_bit(_IOC_NR(cmd), vdev->valid_ioctls);
     475                 :            : }
     476                 :            : 
     477                 :            : /**
     478                 :            :  * video_get_drvdata - gets private data from &struct video_device.
     479                 :            :  *
     480                 :            :  * @vdev: pointer to &struct video_device
     481                 :            :  *
     482                 :            :  * returns a pointer to the private data
     483                 :            :  */
     484                 :            : static inline void *video_get_drvdata(struct video_device *vdev)
     485                 :            : {
     486                 :            :         return dev_get_drvdata(&vdev->dev);
     487                 :            : }
     488                 :            : 
     489                 :            : /**
     490                 :            :  * video_set_drvdata - sets private data from &struct video_device.
     491                 :            :  *
     492                 :            :  * @vdev: pointer to &struct video_device
     493                 :            :  * @data: private data pointer
     494                 :            :  */
     495                 :            : static inline void video_set_drvdata(struct video_device *vdev, void *data)
     496                 :            : {
     497                 :            :         dev_set_drvdata(&vdev->dev, data);
     498                 :            : }
     499                 :            : 
     500                 :            : /**
     501                 :            :  * video_devdata - gets &struct video_device from struct file.
     502                 :            :  *
     503                 :            :  * @file: pointer to struct file
     504                 :            :  */
     505                 :            : struct video_device *video_devdata(struct file *file);
     506                 :            : 
     507                 :            : /**
     508                 :            :  * video_drvdata - gets private data from &struct video_device using the
     509                 :            :  *      struct file.
     510                 :            :  *
     511                 :            :  * @file: pointer to struct file
     512                 :            :  *
     513                 :            :  * This is function combines both video_get_drvdata() and video_devdata()
     514                 :            :  * as this is used very often.
     515                 :            :  */
     516                 :            : static inline void *video_drvdata(struct file *file)
     517                 :            : {
     518                 :          3 :         return video_get_drvdata(video_devdata(file));
     519                 :            : }
     520                 :            : 
     521                 :            : /**
     522                 :            :  * video_device_node_name - returns the video device name
     523                 :            :  *
     524                 :            :  * @vdev: pointer to &struct video_device
     525                 :            :  *
     526                 :            :  * Returns the device name string
     527                 :            :  */
     528                 :            : static inline const char *video_device_node_name(struct video_device *vdev)
     529                 :            : {
     530                 :            :         return dev_name(&vdev->dev);
     531                 :            : }
     532                 :            : 
     533                 :            : /**
     534                 :            :  * video_is_registered - returns true if the &struct video_device is registered.
     535                 :            :  *
     536                 :            :  *
     537                 :            :  * @vdev: pointer to &struct video_device
     538                 :            :  */
     539                 :            : static inline int video_is_registered(struct video_device *vdev)
     540                 :            : {
     541                 :            :         return test_bit(V4L2_FL_REGISTERED, &vdev->flags);
     542                 :            : }
     543                 :            : 
     544                 :            : #endif /* _V4L2_DEV_H */