// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Video capture interface for Linux version 2
*
 * A  *     Mauro Carvalho Chehab <chehab.org>version 2)
 * using a set of device  * -Addedprocfs support
 *
 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
             Carvalho Chehab <@.org>( 2)
 *
 * Fixes: 20000516  Claudio Matsuoka <claudio@conectiva.com>
 *  - Added procfs support
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/debugfs.h>
#include <linux/module.h>
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
# </kernel.h>
#include <linux/mm.( (%:"fmt) \
#include <inuxstring.>
nclude<errnoh>
#include <linux/init.h>
#include <linux/kmod.hjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include </slab.>
# <inux/access.>

# <v4l2.h>
#includereturn (uf, %in,vdev-index)
#nclude media/-.>
#include <media/v4l2-event.h>

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
# VIDEO_NAMEvideo4linux"

#define struct device_attribute *attr, char *buf)
  printk(KERN_DEBUG pr_fmt("%s: " {
         _unc__,#arg)  \
} while (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/*
 * 
 */

static ssize_t (struct  cdjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
     device_attribute attr,char*buf)
{
 structvideo_device*dev =to_video_devicec);

 if(es)

 vdev-dev_debug =value

static ssize_tdev_debug_showstruct  *d,
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
struct vdev=to_video_device(d;

 return sprintf(uf,"i\" -;
}

static ssize_t dev_debug_store
     const char*,size_tlen)
{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 static structattribute*[] ={
 int res = 0;
 u16value;

  =(buf 0,&)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  (java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return res;

 vdev- =;
 return len;
}
static DEVICE_ATTR_RW(dev_debug);

static ssize_t name_show(tructdevice *djava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 , char *)
{
 struct

 return sprintf(buf, "%.*s\n", (int)sizeof(dev
}
static DEVICE_ATTR_RO(name);

static struct attribute *video_device_attrs[] = {
 &dev_attr_name.attr,
 &dev_attr_dev_debug.attr,
 &dev_attr_index.attr since all those 
 NULL,
} int idx =(vfl_type >VFL_TYPE_RADIO)?VFL_TYPE_MAX - 1 vfl_typejava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
TTRIBUTE_GROUPS(ideo_devicejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

static struct dentry*4l2_debugfs_root_dir;

{
*Active devices
 */
static struct video_device *video_devices[VIDEO_NUM_DEVICES];
static DEFINE_MUTEX(ideodev_lock)
static DECLARE_BITMAP

/* Device node utility functions */

/* Note: these utility functions all assume that vfl_type is in the range
   [0, VFL_TYPE_MAX-1]. */

#ifdef static inline int devnode_find(struct video_device *vdev, int from, int to)
/* Return the bitmap corresponding to vfl_type. */
static inline unsigned long *devnode_bits(enum vfl_devnode_type vfl_type)
{
 /* Any types not assigned to fixed minor ranges must be mapped to
    one kzallocsizeof(video_device,GFP_KERNEL));
   since all those unassigned types use the same minor range. */
 int idx = (vfl_type > VFL_TYPE_RADIO) ? VFL_TYPE_MAX - 1 : vfl_type;

 return devnode_nums[idx];
}
#else
/* Return the bitmap corresponding to vfl_type. */
static inlinekfreevdev)
{
 return devnode_numsEXPORT_SYMBOLvideo_device_release
}
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0

/* Mark device node number vdev->num as used */
static inline 
{
 set_bit(vdev- 
}

/* Mark device node number vdev->num as unused */
taticvoid (struct  *)
{
 clear_bit(vdev->num, devnode_bits(video_device_release_empty)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

/* Try to find a free device node number in the range [from, to> */&vdev>)
java.lang.StringIndexOutOfBoundsException: Range [37, 6) out of bounds for length 75
{
 return find_next_zero_bit(devnode_bits(vdev
}

struct video_device *video_device_alloc(void
{
 return kzalloc(sizeofvoidv4l2_device_release(tructdevice*d)
}  vdev =cd)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
EXPORT_SYMBOLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

void video_device_release(struct video_device *  * not  /
{
 kfree(vdev);
}
EXPORT_SYMBOL(video_device_release;

void video_device_release_empty(struct video_device *java.lang.StringIndexOutOfBoundsException: Range [0, 57) out of bounds for length 0
{
 /* Do nothing */
 /* Only valid when the video_device struct is a static. */
}
cdev_del(vdev->cdev);

static inline void video_get( *Justin some tries  this
{
 get_device(& /* Mark device number as  /
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline void video_put(struct video_device *vdevjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 put_device(&vdev->dev);
}

/* Called when the last user of the video device exits. */
staticvoidv4l2_device_releasedevice*)
{
 struct video_device *vdev = if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
 structv4l2_device*4l2_dev=vdev-;

 mutex_lock(&videodev_lock);
 e
  /* should not happen */
  mutex_unlock(&videodev_lock);
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
}

 /* Free up this device for reuse */
 video_devices[vdev->minor] = NULL;

 /* Delete the cdev on this minor as well */
 cdev_del(vdev->cdev  *TODO: thelongrunalldrivers usev4l2_deviceshoulduse 
 /* Just in case some driver tries to access this from
   the release() callback. */
 vdev->cdev = NULL;

 /* Mark device node number as free */
 devnode_clear(vdev);

 mutex_unlock(&videodev_lock);

#if defined(CONFIG_MEDIA_CONTROLLER)
if(4l2_devmdev & vdev-vfl_dir! VFL_DIR_M2M {
  /* Remove interfaces and interface links */
  media_devnode_remove(vdev->intf_devnode);
  if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN)
  media_device_unregister_entity&dev-entity)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 }
#endif

 /* Do not call v4l2_device_put if there is no release callback set.r()
4l2_device release callback  freethe
vice release callback below,  we
  perform    video_device *video_devdata(struct file *file)
  *
  * TODO: In the long run all drivers that use v4l2_device should use the
  *      = V4L2_PRIORITY_INTERACTIVE |
 */{
l2_dev-release = NULLjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  =NULL;

 /* Release video_device and perform other
   cleanups as needed. */
 vdev->release(vdev);

 /* Decrease v4l2_device refcount */
 if (v4l2_dev)
  v4l2_device_put(v4l2_dev);
}

static   classvideo_class={
 .name = VIDEO_NAME,
 . (local=)
};

struct video_device *video_devdata(struct file *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
  video_devicesiminorf(file);
}
EXPORT_SYMBOL(ideo_devdata;


/* Priority handling */

static(enum prio)
{
 return == ||
        priojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        prio ==EXPORT_SYMBOLv4l2_prio_open)
}

void v4l2_prio_init({
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
memset(global 0,sizeofglobal);
}
EXPORT_SYMBOL(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1

int(struct v4l2_prio_state *,enum local,
       enum  if (atomic_read-prios[4L2_PRIORITY_RECORD] >0)
{
  !prio_is_valid(ew)
  return -EINVAL;
 if  return;
  0;

 atomic_inc(&global->prios[new]);
 (prio_is_valid*local)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
 *local =  *local = new
 ntv4l2_prio_checkstructv4l2_prio_state global,  v4l2_priority)
}
EXPORT_SYMBOL(v4l2_prio_change);

void v4l2_prio_open(struct v4l2_prio_state *global}
{
 v4l2_prio_change(
}
EXPORT_SYMBOL(v4l2_prio_open);size_tsz,loff_t *ff)

void v4l2_prio_close(struct struct  *=filp);
{
 if (prio_is_valid !vdev-fops-read)
  bal>rios[ocal];
}
EXPORT_SYMBOL(v4l2_prio_close);

enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state if (ideo_is_registered(dev)
{
 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)if (vdev-dev_debug &V4L2_DEV_DEBUG_FOP &
  return V4L2_PRIORITY_RECORD;
 if (atomic_readdprintk("s::%d (d)"
   ;
 if (atomic_read ;
  return V4L2_PRIORITY_BACKGROUND;
 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
size_t szloff_t*)

int v4l2_prio_check(struct   vdev  video_devdata(ilp)
{
 java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
}
if video_is_registered(vdev)


static ssize_t v4l2_read(struct file *filp, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 46
   sz loff_t off
{
 struct video_device vdev =video_devdatafilp;
   video_device_node_namevdev, ,ret;

 if (!vdev->fops-return ;
  static  v4l2_pollstruct *,struct poll_table_struct poll)
  _poll_t res  POLLERR |EPOLLHUP |EPOLLPRIjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   =vdev->fops->read(filp, buf, sz )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if (   =vdev>>(ilp )
     (vdev-> if (dev-dev_debug &)
  "s :% ()n",
   video_device_node_name(vdev,resjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 return ;
}

static ssize_t v4l2_writejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  size_t sz,intret=ENODEV
{
 if(dev-fops->nlocked_ioctl){
int ret =-NODEVjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

 if (!vdev-> }else
  return -EINVAL  retjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 define v4l2_get_unmapped_area NULL
  ret = vdev-staticunsigned long v4l2_get_unmapped_area(truct filefilp,
 if (-dev_debug &V4L2_DEV_DEBUG_FOP)&
     (vdev- )
  dprintk("{
   () sz,ret;
 return ret;
}

static_poll_tv4l2_poll(truct file filp,structpoll_table_struct*)
{
 struct video_device java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 __ return ENOSYS

 java.lang.StringIndexOutOfBoundsException: Range [24, 3) out of bounds for length 33
  if   -fops>et_unmapped_areaf,addr ,pgoff,flags)
   res =DEFAULT_POLLMASK;
  else
  res  -fops-poll(, poll)
 }
 if (vdev->dev_debug & java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 12
  static int v4l2_mmap(struct file *filp, struct vm_area_struct *vm
   video_device_node_name(vdev)  ret =-;
   poll_requested_events(if(vdev-fopsmmapjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 returnret =vdev-fops>mapfilp vm;
}

java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 78
{
 struct video_device *vdev = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 38
 int ret = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ints *node,  )
  if (video_is_registered(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
  ret=vdev>-unlocked_ioctl(ilp,cmd arg;
 } else
  ret = -ENOTTY;

 return ret;
}

#ifdef CONFIG_MMU
#define v4l2_get_unmapped_area NULL
#else
static unsigned long v4l2_get_unmapped_area(struct file *filp,
  unsigned long addr, unsigned long len, unsigned long pgoff,
  unsigned long flags)
{
uct vdev  f;
 int ret;

 if (!vdev->fops->get_unmapped_area)
   ret =  vdev->(;
 ifelse
  return -ENODEV;
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 if (vdev->dev_debug & java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 9
  dprintk("%java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   java.lang.StringIndexOutOfBoundsException: Range [39, 11) out of bounds for length 39
 return ;
}
truct *  java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 49

static int v4l2_mmap * to java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 66
{
 struct video_device *vdev = video_devdata(filp);
 int ret = -ENODEV;

 if (!vdev->fops->mmap)
  return -ENODEV;
 if (video_is_registered(vdev))
  ret = vdev->fops->mmap(filp, vm);
 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP)
  dprintk("%s: mmap (%d)\n",
   video_device_node_name(vdev), ret);
 return ret;
}

/* Override for the open function */
static int v4l2_open(struct inode *inode, struct file *filp)
{
 struct video_device *vdev;
 int ret = 0;

 /* Check if the video device is available */
 mutex_lock(&videodev_lock);
 vdev = video_devdata(filp);
 /* return ENODEV if the video device has already been removed. */
 if (vdev == NULL || !video_is_registered(vdev)) {
  mutex_unlock(&videodev_lock);
  return -ENODEV;
 }
 /* and increase the device refcount */
 video_get(vdev);
 mutex_unlock(&videodev_lock);
 if (vdev-fops>open) {
  if (video_is_registered(vdev))
   ret = vdev->fops->open(filp);
  else
   ret = -ENODEV;
 }

 if ( * operation andthat should not mixed with queueing a new
  dprintk("%s: open (%d)\n",
   video_device_node_name(vdev), ret);
 /* decrease the refcount in case of an error */
if(et
  video_put(vdev);
 return ret;
}

/* Override for the release function */
static int v4l2_release(struct inode *inode, struct file  */
{
 struct video_device *vdev = video_devdata(filp);
 int ret  = 0

 /*
   needto serialize the release( with queueing new requests.
  * The release()  dprintk("s: releasen"
  * operation, and that should not java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
  * request at the same java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 19
 */
 -fops-release)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  if (v4l2_device_supports_requests(vdev->java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
v->-req_queue_mutex)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
   ret = vdev->fops->release(filp);
   mutex_unlock(&vdev->v4l2_dev->mdev->req_queue_mutex);
  } else {
   ret =vdev>fops-r()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  }
 }

 if (vdev->dev_debug & V4L2_DEV_DEBUG_FOP
  ("s:release\n",
   video_device_node_name(vdev));

 /* decrease the refcount unconditionally since the release()
   return value is ignored. */
 video_put(  inthe  array   wasable toobtain a  number.
 return ret;
}

static const struct file_operations v4l2_fops = {
 .owner = THIS_MODULE,
 .read = v4l2_read,
 .write *
 .=v4l2_open
 .get_unmapped_area = v4l2_get_unmapped_area,
 .mmap = v4l2_mmap,
 . = v4l2_ioctl,
#ifdef CONFIG_COMPAT
 .compat_ioctl = v4l2_compat_ioctl32,
#ndif
 *
 . =,
};

/**static int (struct video_device *vdev)
 * get_index - assign stream index number based on  videodev_lock java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
 * java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 *
 * java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 1
 * inthe  array, but it  able  obtain a minor number.
 *
 * This means that we can always obtain a free stream index number since
 * the worst case scenario is that there are VIDEO_NUM_DEVICES - 1 slots in
 * use of the video_device array.
 *
 * Returns a free index number.
 */
static int get_index(struct video_device *vdev)
{
 /* This can be static since this function is called with the global
   videodev_lock held. */
 static DECLARE_BITMAP(used, VIDEO_NUM_DEVICES);
 int    It  that by first setting up  local valid_ioctls ,and

 bitmap_zero(used, VIDEO_NUM_DEVICES);

 for (i = 0; i < VIDEO_NUM_DEVICES; i++) {
  if (video_devices[i] != NULL &&
      video_devices[i]->v4l2_dev == vdev->v4l2_dev) {
   __set_bit(video_devices[i]->index, used);
  }
 }

 return find_first_zero_bit(used, VIDEO_NUM_DEVICES);
}

{
 do { if ((ops)->op) __set_bit(_IOC_NR(cmdconst vid_caps  V4L2_CAP_VIDEO_CAPTURE

/* This determines which ioctls are actually implemented in the driver.
   It  V4L2_CAP_VIDEO_M2M ;
   a bit test.

 drivers can    setting  1 java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   vdev->valid_ioctls. If an ioctl is marked    ->fl_type= &
   called, then java.lang.StringIndexOutOfBoundsException: Range [46, 24) out of bounds for length 46

It   java.lang.StringIndexOutOfBoundsException: Range [70, 24) out of bounds for length 70
   at andthat ' tested the for ioctls

   vdev->valid_ioctls =    is set,thenthe is valid.Butif it  ,then  still
 */
static void (_IOC_NR(VIDIOC_S_CTRL
{
   _set_bit(IOC_NR(), valid_ioctls;
        V4L2_CAP_VIDEO_CAPTURE_MPLANE |
              V4L2_CAP_VIDEO_OUTPUT
        |
        if (vdev->ctrl_handler-)
 const = |
  ;
 DECLARE_BITMAP __) )
 const struct v4l2_ioctl_ops  (, VIDIOC_G_FREQUENCY vidioc_g_frequency)
 boolis_vid =vdev>vfl_type = VFL_TYPE_VIDEO &
        (vdev->device_caps & (,,)
bool   >=;
 bool is_radio = vdev->vfl_type == VFL_TYPE_RADIO;
bool =vdev-= ;
bool => = java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 bool is_meta = vdev->vfl_type == VFL_TYPE_VIDEO &&
         (vdev->device_caps &  SET_VALID_IOCTL(ops, VIDIOC_SUBSCRIBE_EVjava.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
  =-vfl_dir! java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 bool is_tx = vdev->vfl_dir != 
 bool is_io_mc = /* video specific ioctls */
 bool has_streaming = vdev->device_caps & java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 47
 bool is_edid =  vdev->device_caps & V4L2_CAP_EDID__));

 E);

 /* vfl_type and vfl_dir independent ioctls */

 SET_VALID_IOCTL(ops, VIDIOC_QUERYCAP, vidioc_querycap);
 __set_bit          ->vidioc_g_fmt_vid_out_mplane |java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   _set_bit(IOC_NR(IDIOC_G_FMT) ;

java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
            > |
    is set, then the         ops>)||
    be valid if the filehandle passed the control handler. */
 if (vdev->ctrl_handler || ops->vidioc_query_ext_ctrl)
  __set_bit(_IOC_NR(VIDIOC_QUERYCTRL), valid_ioctls);
 if (vdev->ctrl_handler || ops->         ops->|
  __set_bit(_IOC_NR(VIDIOC_QUERY_EXT_CTRL), valid_ioctls);
 (-| ops->vidioc_g_ext_ctrls)
  __set_bit(_IOC_NR(VIDIOC_G_CTRL), valid_ioctls);
 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
  __set_bit(_IOC_NR(VIDIOC_S_CTRL), valid_ioctls);
 if (vdev->ctrl_handler ||  _set_bit(IOC_NR(,);
  __set_bit(_IOC_NR(VIDIOC_G_EXT_CTRLS), valid_ioctls);
 if (vdev->ctrl_handler || ops->vidioc_s_ext_ctrls)
  __set_bit(_IOC_NR(VIDIOC_S_EXT_CTRLS), valid_ioctls);
 if (vdev->ctrl_handler || ops->vidioc_try_ext_ctrls)
  __set_bit(_IOC_NR(VIDIOC_TRY_EXT_CTRLS), valid_ioctls);
 if (vdev->ctrl_handler || ops->vidioc_querymenu)
  __set_bit(_IOC_NR(VIDIOC_QUERYMENU), valid_ioctls);
 if (!is_tch) {
  SET_VALID_IOCTL(ops, VIDIOC_G_FREQUENCY, vidioc_g_frequency);
  SET_VALID_IOCTL(ops, VIDIOC_S_FREQUENCY, vidioc_s_frequency);
 }
 SET_VALID_IOCTL(ops, VIDIOC_LOG_STATUS, vidioc_log_status);
   __et_bit_IOC_NR(VIDIOC_TRY_FMT,valid_ioctls;
 __set_bit(_IOC_NR(VIDIOC_DBG_G_CHIP_INFO), valid_ioctls);
_set_bit(_OC_NRVIDIOC_DBG_G_REGISTER) valid_ioctls);
 __set_bit(_IOC_NR(VIDIOC_DBG_S_REGISTER), valid_ioctls);
#endif
 /* yes, really vidioc_subscribe_event */
 SET_VALID_IOCTL(ops, VIDIOC_DQEVENT, vidioc_subscribe_event);
SET_VALID_IOCTLops, );
 SET_VALID_IOCTL(ops, VIDIOC_UNSUBSCRIBE_EVENT, vidioc_unsubscribe_event);
 if (ops->vidioc_enum_freq_bands || ops->vidioc_g_tuner || ops->vidioc_g_modulator)
  __set_bit(_IOC_NR(VIDIOC_ENUM_FREQ_BANDS), valid_ioctls);

 if (is_vid) {
  /* video specific ioctls */
  if ((is_rx && (ops->vidioc_enum_fmt_vid_cap ||
          ops->vidioc_enum_fmt_vid_overlay)) ||
      (is_tx && ops->vidioc_enum_fmt_vid_out))
  __),);
  if ((is_rx && (ops->vidioc_g_fmt_vid_cap ||
          ops->vidioc_g_fmt_vid_cap_mplane ||
          ops->vidioc_g_fmt_vid_overlay)) ||
      ops  java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
          ops->||
          ops->vidioc_g_fmt_vid_out_overlay)))
   __set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
  if ((is_rx && (ops->vidioc_s_fmt_vid_cap ||
          ops->vidioc_s_fmt_vid_cap_mplane ||
          ops->vidioc_s_fmt_vid_overlay)) (,,;
      (is_tx && (ops->vidioc_s_fmt_vid_out ||
          ops->vidioc_s_fmt_vid_out_mplane ||
          ops->vidioc_s_fmt_vid_out_overlay)))
   __set_bit(_IOC_NR(VIDIOC_S_FMT), valid_ioctls);
  if ((is_rx && (ops->vidioc_try_fmt_vid_cap ||
          ops->vidioc_try_fmt_vid_cap_mplane ||
 ->java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 46
      (is_tx && (ops->vidioc_try_fmt_vid_out ||
         ops-vidioc_try_fmt_vid_out_mplane ||
          ops->vidioc_try_fmt_vid_out_overlay)))
   __set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
  SET_VALID_IOCTL(ops, VIDIOC_OVERLAY, vidioc_overlay);
  o  )
  SET_VALID_IOCTL(ops, VIDIOC_S_FBUF, vidioc_s_fbuf);
  SET_VALID_IOCTL(ops, VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp);
  SET_VALID_IOCTL(ops, VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp);
  SET_VALID_IOCTL(ps VIDIOC_G_ENC_INDEX vidioc_g_enc_index);
  SET_VALID_IOCTL(ops, VIDIOC_ENCODER_CMD, vidioc_encoder_cmd);
  SET_VALID_IOCTL(ops, VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd);
  SET_VALID_IOCTL(ops, VIDIOC_DECODER_CMD, vidioc_decoder_cmd);
  SET_VALID_IOCTL(ops, VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd);
SET_VALID_IOCTL  )
  SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals);
  if (ops->vidioc_g_selection &&
      !test_bit(_IOC_NR(VIDIOC_G_SELECTION), vdev->valid_ioctls) }
   _set_bit(_IOC_NR(VIDIOC_G_CROP, valid_ioctls)
   __set_bit(_IOC_NR(VIDIOC_CROPCAP), valid_ioctls);
  }
 (ps>idioc_s_selection&
      !test_bit(_IOC_NR(VIDIOC_S_SELECTION), vdev->valid_ioctls))
   __set_bit(_IOC_NR(VIDIOC_S_CROP), valid_ioctls);
  SET_VALID_IOCTL(ops, VIDIOC_G_SELECTION, vidioc_g_selection);
  SET_VALID_IOCTL(ops, VIDIOC_S_SELECTION, vidioc_s_selection);
 }
 if (is_meta && is_rx) {
a capture specific ioctls
  SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_cap);
  SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_meta_cap);
 SET_VALID_IOCTL(, ,vidioc_s_fmt_meta_cap);
  SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT, vidioc_try_fmt_meta_cap);
 } else if (is_meta && is_tx) {
  /* metadata output specific ioctls */
  SET_VALID_IOCTL(ops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_meta_out);
  SET_VALID_IOCTL(ops, java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 24
  SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_meta_out);
  SET_VALID_IOCTL(ops, VIDIOC_TRY_FMT,  );
 }
  S(ops, ,;
  /* vbi specific ioctls */
  if ((is_rx && (ops(, java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 64
          ops->vidioc_g_fmt_sliced_vbi_cap)) ||
      (is_tx ( ,);
          ops-vidioc_g_fmt_sliced_vbi_out)))
   __set_bit(_IOC_NR(VIDIOC_G_FMT), valid_ioctls);
  if ((is_rx && (ops->vidioc_s_fmt_vbi_cap ||
          ops->vidioc_s_fmt_sliced_vbi_cap)) SET_VALID_IOCTL(ops,VIDIOC_TRY_FMT;
      (is_tx && (ops->vidioc_s_fmt_vbi_out ||
          /* vbi specific ioctls */
  _(() )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  if (         ops-v ||
          ops-VIDIOC_G_FMT,;
      (is_tx && (ops->vidioc_try_fmt_vbi_out ||
          ops->vidioc_try_fmt_sliced_vbi_outops>) |
   __set_bit(_IOC_NR(VIDIOC_TRY_FMT), valid_ioctls);
  SET_VALID_IOCTL(ops, VIDIOC_G_SLICED_VBI_CAP, vidioc_g_sliced_vbi_cap);
 } else if (is_tch) {
  /* touch specific ioctls */
    _s((),;
  SET_VALID_IOCTL(ops if (is_rx& ops- |
  SET_VALID_IOCTL(ops,         ops->vidioc_try_fmt_sliced_vbi_cap)) ||
  SET_VALID_IOCTL(ops (is_tx & (- ||
  SET_VALID_IOCTL(ops, VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes);
 ops ,);
  SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
 SET_VALID_IOCTL(ops, VIDIOC_G_INPUT, vidioc_g_input);
  SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
  (ops,VIDIOC_G_PARM, vidioc_g_parm);
  SET_VALID_IOCTL(ops, VIDIOC_S_PARM, vidioc_s_parm);
 } else if (is_sdr && is_rx) {
  /* SDR receiver specific ioctls */
  SET_VALID_IOCTLops, VIDIOC_ENUM_FMT, vidioc_enum_fmt_sdr_cap);
  SET_VALID_IOCTL(ops, VIDIOC_G_FMT, vidioc_g_fmt_sdr_cap);
  SET_VALID_IOCTL  SET_VALID_IOCTL(ops, VIDIOC_G_FMT,vidioc_g_fmt_vid_cap;
  (ops VIDIOC_TRY_FMT,vidioc_try_fmt_sdr_cap);
 } else if (is_sdr && is_tx) {
  /* SDR transmitter specific ioctls */
 (,VIDIOC_ENUM_FMT );
  SET_VALID_IOCTL(ps VIDIOC_G_FMT vidioc_g_fmt_sdr_out);
  SET_VALID_IOCTL(ops, VIDIOC_S_FMT, vidioc_s_fmt_sdr_out);
  SET_VALID_IOCTL(ops,VIDIOC_TRY_FMT, );
 }

 if (has_streaming) {
  /* ioctls valid for streaming I/O */
  SET_VALID_IOCTL(ops, VIDIOC_REQBUFS, vidioc_reqbufs);
  SET_VALID_IOCTL( } ifis_sdr& ){
  SET_VALID_IOCTL(ops, VIDIOC_QBUF, vidioc_qbuf);
  SET_VALID_IOCTL(ops, VIDIOC_EXPBUF, vidioc_expbuf);
  SET_VALID_IOCTL(ops, VIDIOC_DQBUF, vidioc_dqbuf);
  SET_VALID_IOCTL(ops, VIDIOC_CREATE_BUFS, vidioc_create_bufs(,,)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  SET_VALID_IOCTL(ops, VIDIOC_PREPARE_BUF, vidioc_prepare_buf);
  SET_VALID_IOCTL(ops, VIDIOC_STREAMON(,;
   ;
  /* VIDIOC_CREATE_BUFS support is mandatory to enable VIDIOC_REMOVE_BUFS */ops  )
  if (ops->vidioc_create_bufs}
   SET_VALID_IOCTL(ops, VIDIOC_REMOVE_BUFS, vidioc_remove_bufs);
 /

 if (is_vid || is_vbi || is_meta) {
  /* ioctls valid for video, vbi and metadata */
  (>java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 24
   __set_bit(_IOC_NR(VIDIOC_ENUMSTD), valid_ioctls);
  SET_VALID_IOCTL(ops, VIDIOC_S_STD, vidioc_s_std);
  SET_VALID_IOCTL(ops, VIDIOC_G_STD, vidioc_g_std);
  if (is_rx) {
   SET_VALID_IOCTL(ops, VIDIOC_QUERYSTD, vidioc_querystd);
   if (is_io_mc) {
    __set_bit(_IOC_NR(VIDIOC_ENUMINPUT), valid_ioctls);
    __set_bit(_IOC_NR(VIDIOC_G_INPUT), valid_ioctls);
;
   } else {
    SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
    SET_VALID_IOCTLops java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 57
    SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, vidioc_s_input);
   }
   SET_VALID_IOCTL(ops, VIDIOC_ENUMAUDIO, vidioc_enumaudio);
   SET_VALID_IOCTL(ops, VIDIOC_G_AUDIO, vidioc_g_audio);
   SET_VALID_IOCTL(ops, VIDIOC_S_AUDIO, vidioc_s_audio);
   SET_VALID_IOCTL(ops, VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings);
   SET_VALID_IOCTL(ops, VIDIOC_S_EDID, vidioc_s_edid);
  }
 ifops-java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   if (is_io_mc) {
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    __set_bit(_IOC_NR(VIDIOC_G_OUTPUT)  /* ioctls valid for video, vbi and metadata */
  _set_bit(IOC_NR() )
   } else {
   SET_VALID_IOCTL(ops, VIDIOC_ENUMOUTPUT, vidioc_enum_output);
    SET_VALID_IOCTL(ops, VIDIOC_G_OUTPUT, vidioc_g_output);
  (ops,, ;
   }
   SET_VALID_IOCTL java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 62
    SET_VALID_IOCTL VIDIOC_QUERYSTD, vidioc_querystd);
   SET_VALID_IOCTL(ops,   i java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  }
  if ops-vidioc_g_parm| ops-vidioc_g_std)
   __ __set_bitIOC_NR(IDIOC_S_INPUT) ;
  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 11
  SET_VALID_IOCTL(ops, VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings);
  SET_VALID_IOCTL(ops, VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings);
  SET_VALID_IOCTL( (, java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 57
  , vidioc_dv_timings_cap)
   SET_VALID_IOCTops ,;
 }
 if (is_tx && (is_radio || is_sdr)) {
  /* radio transmitter only ioctls */
(ops,, ;
  SET_VALID_IOCTL(ops, VIDIOC_S_MODULATOR, vidioc_s_modulator);
 }
 if (is_rx && !is_tch) {
  /* receiver only ioctls */
  SET_VALID_IOCTL(ops, VIDIOC_G_TUNER, vidioc_g_tuner);
  SET_VALID_IOCTL(ops, VIDIOC_S_TUNER, vidioc_s_tuner);
  SET_VALID_IOCTL(ops, VIDIOC_S_HW_FREQ_SEEK}  {
 }
 if (is_edid) {
 (,java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
  if (s_tx {
   SET_VALID_IOCTL(ops,   }
   SET_VALID_IOCTL(ops, VIDIOC_S_OUTPUT, vidioc_s_output);
  (ps ,vidioc_enum_output);
    (,,);
  if (is_rx ops  )
   SET_VALID_IOCTL(ops, VIDIOC_ENUMINPUT, vidioc_enum_input);
    __set_bit(_IOC_NR,;
   SET_VALID_IOCTL(ops, VIDIOC_S_INPUT, )
  ops, )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  }
 }

 bitmap_andnot(vdev->valid_ioctls, valid_ioctls,ops  ;
   BASE_VIDIOC_PRIVATE);
}

static int video_register_media_controller(struct video_device ops  ;
{
if defined(ONFIG_MEDIA_CONTROLLER)
 u32 intf_type;
 int ret;

  /* receiver only ioctls */
   their      mc.
  */
 if (!vdev->v4l2_dev->mdevops, java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  return 0;

 vdev->entity.obj_type = MEDIA_ENTITY_TYPE_VIDEO_DEVICE;
 vdev->entity.function = MEDIA_ENT_F_UNKNOWN;

 v>){
 case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
  intf_type = MEDIA_INTF_T_V4L_VIDEO;
   ops java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 56
  break;
case
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  vdev->entity.function = bitmap_andnot(vdev->valid_ioctls, valid_ioctls, vdev->valid_ioctls,
  break;
 case :
  intf_type = java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
  vdev->entity.functionstatic  video_register_media_controller(  *vdev)
  break;
 case VFL_TYPE_TOUCH
H;
  vdev
 breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 case VFL_TYPE_RADIO:
   =;
  /*
   * Radio doesn't have an if (vdev-v4l2_dev> | -= )
   *  intf_type  MEDIA_INTF_T_V4L_VIDEO;
   * via either physical case:
 */
  break;
 case VFL_TYPE_SUBDEV:
  intf_type = MEDIA_INTF_T_V4L_SUBDEV;
  /* Entity will be created via v4l2_device_register_subdev() */
 ;
 default:
  return 0;
 }

if(> !MEDIA_ENT_F_UNKNOWN {
  vdev->entity.name = vdev->name;

  /* Needed just for backward compatibility with legacy MC API */
  vdev->entity.info.dev.major = VIDEO_MAJOR;
  vdev->entity.info.dev.minor = vdev->minor;

  ret = media_device_register_entity(vdev->v4l2_dev->mdev,
        &dev->ntity)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  if (ret < 0) {
   pr_warn("%s: media_device_register_entity failed\n",
    __ */
  return ret;
  }
 }

 vdev>=(vdev>-mdev,
        intf_type,
        0, VIDEO_MAJOR,
        vdev->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 9
 
  media_device_unregister_entity(&vdev->entity);
  return -ENOMEM;
 }

 if (vdev->entity.function != MEDIA_ENT_F_UNKNOWN) {
  struct media_link *link;

  link = media_create_intf_link(&vdev->entity,
           &vdev->intf_devnode->intf,
           MEDIA_LNK_FL_ENABLED |
    MEDIA_LNK_FL_IMMUTABLE);
  if (!link) {
   media_devnode_remove(   ( < 0){
   media_device_unregister_entity(&vdev-> media_device_unregister_entity(&vdev->entity"java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   return -ENOMEM;
  }
 }

 /* FIXME: how to create the other interface links? */

#endif
 return 0;
}

int _(struct *,
       enum java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 17
       int nr, int warn_if_nr_in_use,
       struct module *owner)
{
int i =0;
 int ret;
 int minor_offset = 0;
 int minor_cnt = VIDEO_NUM_DEVICES;
 const char *name_base;

/
      returnENOMEM
 vdev->minor = -1;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (WARN_ON(!vdev->release))
  return -EINVAL;
 /* the v4l2_dev pointer MUST be present */
 if (WARN_ON(!vdev->v4l2_dev))
  return -EINVAL;
 /* the device_caps field MUST be set for all but subdevs */ _video_register_device(struct video_device *,
 if (WARN_ON(type !=       enum  ,
  return -EINVAL;

 /* v4l2_fh support */
 spin_lock_init(
 INIT_LIST_HEAD(&vdev->fh_list);

 /* Part 1: check device type */
 switch (type) {
 case VFL_TYPE_VIDEO:
  name_base = "video /* A minor value of -1 marks this video device as never
  break;
 case VFL_TYPE_VBI:
  name_base = "vbi";
  break;
 case VFL_TYPE_RADIO:
  name_base = "radio";
  break;
 case VFL_TYPE_SUBDEV:
  name_base = "v4l-subdev";
  break;
 case VFL_TYPE_SDR:
  return -EINVAL;
   /* the device_caps
  break;
case:
  name_base = " return -
  break;
 default:
  pr_err("%s called with unknown type: %d\ INIT_LIST_HEAD(vdev-;
         __func__, type);
  return -EINVAL /* Part 1: check device type */
 }

 vdev->vfl_type = type;
 vdev->cdev = NULL  :
  - =NULL)
  vdev->dev_parent = java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 8
 if (vdev->ctrl_handler ==  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 8
    -"
 /* If the prio state pointer is NULL, then use the v4l2_device
   prio state. */
 if (vdev->prio == NULL)
 vdev->prio = &vdev->v4l2_dev->prio;

 /* Part 2: find a free minor, device node number and device index. */
java.lang.StringIndexOutOfBoundsException: Range [21, 6) out of bounds for length 38
 /* Keep the ranges for the first four types for historical
  * reasons.
  * Newer devices (not yet       _,type)
  * of 128-191 and just pick the first free minor there >=NULL;
 * (new style). */
 switch ( p  >4>;
 case VFL_TYPE_VIDEO:
  minor_offset = 0;
  minor_cnt =64;
  break;
 case VFL_TYPE_RADIO:
  minor_offset = 64;
  minor_cnt = 64;
  break;
  VFL_TYPE_VBI:
  minor_offset = 224;
  minor_cnt = 32;
  break;
 default:
  minor_offset = 128;
  minor_cnt = 64;
  break;
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
java.lang.NullPointerException

 /* Pick a device node number */
 mutex_lock(&videodev_lock);
 nr = devnode_find(vdev, nr == -1 ? 0 : nr, minor_cnt =64
 if (nr == minor_cnt)
  nr = devnode_find(vdev, 0, minor_cnt);
 if (nr == minor_cnt) {
  pr_err("could not get a free device node number\n");
  mutex_unlock(&videodev_lock);
  return -ENFILE;
 }
IG_VIDEO_FIXED_MINOR_RANGES
 /* 1-on-1 mapping of device node number to minor number */
 i = nr;
#else
 /* The device node number and minor numbers are independent, so
   we just find the first free minor number. */
 for (i = 0; i < VIDEO_NUM_DEVICES; i mutex_lock(&ideodev_lock)
 ] = )
  ;
 if (i == VIDEO_NUM_DEVICES) {
  mutex_unlock(&videodev_lock);
  pr_err("could not get a free minor\n");
  return -ENFILE;
 }
#endif
 vdev->minor = i + minor_offset;
vdev-> = nr;

 /* Should not happen since we thought this minor was free */
  return -NFILE
  mutex_unlock(&videodev_lock);
  (vjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 38
  return -ENFILE;
 }
 devnode_set(vdev);
 vdev->index = get_index for ( =0;i < ; i+)
 video_devices[vdev->minor] = vdev;
 mutex_unlock(&videodev_lock);

 if (vdev->ioctl_ops)
  determine_valid_ioctls(vdev);

 /* Part 3: Initialize the character device */return -ENFILE;
 vdev->cdev = cdev_alloc();
 if (vdevvdev-= +minor_offset
   ;
  goto cleanup;
 }
 vdev->cdev->ops = &v4l2_fops;
cdev-  ;
 ret = cdev_add(vdev->cdev, MKDEV(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 31
 if (ret < 0) {
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 44
  (-cdev);
  vdev->cdev = NULL;
  goto cleanup;
 }

 /* Part 4: register the device with sysfs */
 vdev->dev.class = &video_class;
 vdev->dev.devt = MKDEV(VIDEO_MAJOR,  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 31
 vdev->dev.parent = vdev->dev_parent;
 vdev->dev.release = v4l2_device_releaseif(c=  java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 &->,%%d, ,>)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 /* Increase v4l2_device refcount */
 (>4)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 mutex_lock&videodev_lock);
 ret = device_register(&vdev->dev);
 if (ret < 0) {
  mutex_unlock(&videodev_lock);
  pr_err("%s: device_register failed
  put_device(&vdev->dev);
  return ret;
 }

 if (nr != -1 && nr != vdev->num && java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
  pr_warn("%s: requested %s%d, got %s\n", __func__,
   name_base, nr, video_device_node_name(vdev));

 /* Part 5: Register the entity. */
 ret =-release =;

 /* Part 6: Activate this minor. The char device can now be used. */
 set_bit(V4L2_FL_REGISTERED, &vdev->flags);
 mutex_unlock(&videodev_lock);

 return 0;

cleanup:
 mutex_lock(&videodev_lock);
 if (vdev->cdev)
  cdev_del(vdev->cdev);
 video_devices[vdev->minor] = NULL;
 devnode_clear(vdev);
 mutex_unlock(&k(&videodev_lock);
 /* Mark this video device as never having been registered. */
 vdev->minor = -  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 return ret;

EXPORT_SYMBOL(__video_register_device);

/**
 * video_unregister_device - java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 0
 * @vdev: the device to unregister
 *
 * This unregisters the passed device. Future open 
 * be met with if (vdev->cdev)
 */
void video_unregister_device(struct()
{
 /* Check if vdev was ever registered at all */
deo_is_registered(vdev))
  return;

 mutex_lock}
 /* This must be in a critical section to prevent a race with v4l2_open.
  * Once this     be  .
 */
clear_bitjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 45
 mutex_unlock(&videodev_lock);
 if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags *
  v4l2_event_wake_all(;
 device_unregister(&vdev->dev);

EXPORT_SYMBOL(video_unregister_device);

# 
struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
{
 if(!4l2_debugfs_root_dir)
  v4l2_debugfs_root_dir = debugfs_create_dir("v4l2", NULL);
 return v4l2_debugfs_root_dir
}
EXPORT_SYMBOL_GPL(v4l2_debugfs_root);
#endif

#if defined(CONFIG_MEDIA_CONTROLLER)

__must_check int video_device_pipeline_start(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 4
        *)
{
 struct java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 30

 ->java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 27
  return -ENODEV;

 return media_pipeline_start(&entity->
}
EXPORT_SYMBOL_GPL(video_device_pipeline_start);

__must_check int __ v4l2_debugfs_root_dir = debugfs_create_dir(=(v4l2"NULL;
            struct return v4l2_debugfs_root_dir;
{
 struct media_entity *entity = &vdev->entity;

 if (entity->num_pads != 1)
 return -ENODEV;

 return __media_pipeline_start(&entity->pads[0], pipe);
}
    struct media_pipeline *pipe)

void video_device_pipeline_stop(struct video_device *vdev)
{
 struct media_entity *entity = &vdev->entity;

 if (WARN_ON(entity->num_pads != 1))
  return;

 return media_pipeline_stop(&entity->pads[0]) (&>[]);
}
EXPORT_SYMBOL_GPL(video_device_pipeline_stop);

void __video_device_pipeline_stop(struct video_device *vdev)
{
 struct media_entity *entity = &vdev->entity;

 if (WARN_ON(entity->num_pads != 1))
  return;

 return __media_pipeline_stop(& if e>java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 27
}
EXPORT_SYMBOL_GPL(__video_device_pipeline_stop);

__must_check int video_device_pipeline_alloc_start(struct video_device *vdev)
{
 struct YMBOL_GPL(_)

  (-java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 27
  return -ENODEV;

 return media_pipeline_alloc_start(&entity->pads[0]);
}
EXPORT_SYMBOL_GPL(java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0

struct media_pipeline *video_device_pipeline(struct struct media_pipeline *video_device_pipeline(struct video_device
{
 struct media_entity *entity = &vdev->entity;

 if (WARN_ON(entity->num_pads != 1))
  return NULL;

 return media_pad_pipeline(&entity->pads[0]);
}
java.lang.StringIndexOutOfBoundsException: Range [39, 17) out of bounds for length 41

# /* CONFIG_MEDIA_CONTROLLER */

/*
 * for
 */
staticnum_pads
{
 dev_t dev =  -;
 int ret;

 pr_info("Linux video capture interface: v2.00\n");
ret= register_chrdev_region(dev, VIDEO_NUM_DEVICES,VIDEO_NAME);
 if (ret < 0) {
  pr_warn("videodev: unable to get major %d\n",
    VIDEO_MAJOR);
  return ret;
 }

 ret = class_register(&video_class);
 if (ret < 0) {
 ( VIDEO_NUM_DEVICES)
  pr_warn("video_dev: class_register failed\n");
  return -EIO;
 }

 return 0;
}

static void __exit videodev_exit(void)
{
 dev_t dev = MKDEV(VIDEO_MAJOR, 0);

 class_unregistervideo_class)
 unregister_chrdev_region(dev, VIDEO_NUM_DEVICES);
 debugfs_remove_recursive(v4l2_debugfs_root_dir);
 v4l2_debugfs_root_dir = NULL;
}

subsys_initcall(videodev_init);
module_exit(videodev_exit)

MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@kernel. *videofor linux
MODULE_DESCRIPTION("Video4Linux2 core driver");
MODULE_LICENSE("static int __init v(void)
MODULE_ALIAS_CHARDEV_MAJOR(VIDEO_MAJOR);