License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 21:07:57 +07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2006-06-04 20:06:18 +07:00
|
|
|
/*
|
|
|
|
*
|
|
|
|
* V 4 L 2 D R I V E R H E L P E R A P I
|
|
|
|
*
|
|
|
|
* Moved from videodev2.h
|
|
|
|
*
|
|
|
|
* Some commonly needed functions for drivers (v4l2-common.o module)
|
|
|
|
*/
|
|
|
|
#ifndef _V4L2_DEV_H
|
|
|
|
#define _V4L2_DEV_H
|
|
|
|
|
|
|
|
#include <linux/poll.h>
|
|
|
|
#include <linux/fs.h>
|
|
|
|
#include <linux/device.h>
|
2008-08-30 03:31:35 +07:00
|
|
|
#include <linux/cdev.h>
|
2006-06-04 20:06:18 +07:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/videodev2.h>
|
|
|
|
|
2009-12-09 18:40:10 +07:00
|
|
|
#include <media/media-entity.h>
|
|
|
|
|
2006-06-04 20:06:18 +07:00
|
|
|
#define VIDEO_MAJOR 81
|
2008-08-23 17:48:38 +07:00
|
|
|
|
2017-09-29 05:39:32 +07:00
|
|
|
/**
|
|
|
|
* enum vfl_devnode_type - type of V4L2 device node
|
|
|
|
*
|
|
|
|
* @VFL_TYPE_GRABBER: for video input/output devices
|
|
|
|
* @VFL_TYPE_VBI: for vertical blank data (i.e. closed captions, teletext)
|
|
|
|
* @VFL_TYPE_RADIO: for radio tuners
|
|
|
|
* @VFL_TYPE_SUBDEV: for V4L2 subdevices
|
|
|
|
* @VFL_TYPE_SDR: for Software Defined Radio tuners
|
|
|
|
* @VFL_TYPE_TOUCH: for touch sensors
|
|
|
|
*/
|
|
|
|
enum vfl_devnode_type {
|
|
|
|
VFL_TYPE_GRABBER = 0,
|
2018-04-05 16:51:15 +07:00
|
|
|
VFL_TYPE_VBI,
|
|
|
|
VFL_TYPE_RADIO,
|
|
|
|
VFL_TYPE_SUBDEV,
|
|
|
|
VFL_TYPE_SDR,
|
|
|
|
VFL_TYPE_TOUCH,
|
|
|
|
VFL_TYPE_MAX /* Shall be the last one */
|
2017-09-29 05:39:32 +07:00
|
|
|
};
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2017-10-06 00:52:19 +07:00
|
|
|
/**
|
|
|
|
* enum vfl_direction - Identifies if a &struct video_device corresponds
|
|
|
|
* to a receiver, a transmitter or a mem-to-mem device.
|
|
|
|
*
|
|
|
|
* @VFL_DIR_RX: device is a receiver.
|
|
|
|
* @VFL_DIR_TX: device is a transmitter.
|
|
|
|
* @VFL_DIR_M2M: device is a memory to memory device.
|
|
|
|
*
|
|
|
|
* Note: Ignored if &enum vfl_devnode_type is %VFL_TYPE_SUBDEV.
|
|
|
|
*/
|
|
|
|
enum vfl_devnode_direction {
|
|
|
|
VFL_DIR_RX,
|
|
|
|
VFL_DIR_TX,
|
|
|
|
VFL_DIR_M2M,
|
|
|
|
};
|
2012-09-05 15:33:21 +07:00
|
|
|
|
2008-07-21 12:57:38 +07:00
|
|
|
struct v4l2_ioctl_callbacks;
|
2008-12-30 16:58:20 +07:00
|
|
|
struct video_device;
|
2008-12-23 17:35:17 +07:00
|
|
|
struct v4l2_device;
|
2010-08-02 00:32:42 +07:00
|
|
|
struct v4l2_ctrl_handler;
|
2008-07-21 12:57:38 +07:00
|
|
|
|
2017-10-06 01:05:25 +07:00
|
|
|
/**
|
|
|
|
* enum v4l2_video_device_flags - Flags used by &struct video_device
|
|
|
|
*
|
|
|
|
* @V4L2_FL_REGISTERED:
|
2018-01-04 18:47:28 +07:00
|
|
|
* indicates that a &struct video_device is registered.
|
2017-10-06 01:05:25 +07:00
|
|
|
* Drivers can clear this flag if they want to block all future
|
|
|
|
* device access. It is cleared by video_unregister_device.
|
|
|
|
* @V4L2_FL_USES_V4L2_FH:
|
|
|
|
* indicates that file->private_data points to &struct v4l2_fh.
|
|
|
|
* This flag is set by the core when v4l2_fh_init() is called.
|
|
|
|
* All new drivers should use it.
|
|
|
|
*/
|
|
|
|
enum v4l2_video_device_flags {
|
|
|
|
V4L2_FL_REGISTERED = 0,
|
|
|
|
V4L2_FL_USES_V4L2_FH = 1,
|
|
|
|
};
|
2008-12-20 07:28:27 +07:00
|
|
|
|
2010-12-29 20:05:02 +07:00
|
|
|
/* Priority helper functions */
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* struct v4l2_prio_state - stores the priority states
|
|
|
|
*
|
|
|
|
* @prios: array with elements to store the array priorities
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* The size of @prios array matches the number of priority types defined
|
2016-08-30 04:40:21 +07:00
|
|
|
* by enum &v4l2_priority.
|
2016-07-22 01:30:20 +07:00
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
struct v4l2_prio_state {
|
|
|
|
atomic_t prios[4];
|
|
|
|
};
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* v4l2_prio_init - initializes a struct v4l2_prio_state
|
|
|
|
*
|
|
|
|
* @global: pointer to &struct v4l2_prio_state
|
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
void v4l2_prio_init(struct v4l2_prio_state *global);
|
2016-07-22 01:30:20 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* v4l2_prio_change - changes the v4l2 file handler priority
|
|
|
|
*
|
|
|
|
* @global: pointer to the &struct v4l2_prio_state of the device node.
|
2016-08-30 04:40:21 +07:00
|
|
|
* @local: pointer to the desired priority, as defined by enum &v4l2_priority
|
|
|
|
* @new: Priority type requested, as defined by enum &v4l2_priority.
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* This function should be used only by the V4L2 core.
|
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
|
|
|
|
enum v4l2_priority new);
|
2016-07-22 01:30:20 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* v4l2_prio_open - Implements the priority logic for a file handler open
|
|
|
|
*
|
|
|
|
* @global: pointer to the &struct v4l2_prio_state of the device node.
|
2016-08-30 04:40:21 +07:00
|
|
|
* @local: pointer to the desired priority, as defined by enum &v4l2_priority
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* This function should be used only by the V4L2 core.
|
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
void v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local);
|
2016-07-22 01:30:20 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* v4l2_prio_close - Implements the priority logic for a file handler close
|
|
|
|
*
|
|
|
|
* @global: pointer to the &struct v4l2_prio_state of the device node.
|
2016-08-30 04:40:21 +07:00
|
|
|
* @local: priority to be released, as defined by enum &v4l2_priority
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* This function should be used only by the V4L2 core.
|
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
void v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority local);
|
2016-07-22 01:30:20 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* v4l2_prio_max - Return the maximum priority, as stored at the @global array.
|
|
|
|
*
|
|
|
|
* @global: pointer to the &struct v4l2_prio_state of the device node.
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* This function should be used only by the V4L2 core.
|
|
|
|
*/
|
2010-12-29 20:05:02 +07:00
|
|
|
enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global);
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
2016-09-22 17:59:03 +07:00
|
|
|
* v4l2_prio_check - Implements the priority logic for a file handler close
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* @global: pointer to the &struct v4l2_prio_state of the device node.
|
2016-08-30 04:40:21 +07:00
|
|
|
* @local: desired priority, as defined by enum &v4l2_priority local
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* This function should be used only by the V4L2 core.
|
|
|
|
*/
|
|
|
|
int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority local);
|
2010-12-29 20:05:02 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* struct v4l2_file_operations - fs operations used by a V4L2 device
|
|
|
|
*
|
|
|
|
* @owner: pointer to struct module
|
|
|
|
* @read: operations needed to implement the read() syscall
|
|
|
|
* @write: operations needed to implement the write() syscall
|
|
|
|
* @poll: operations needed to implement the poll() syscall
|
|
|
|
* @unlocked_ioctl: operations needed to implement the ioctl() syscall
|
|
|
|
* @compat_ioctl32: operations needed to implement the ioctl() syscall for
|
|
|
|
* the special case where the Kernel uses 64 bits instructions, but
|
|
|
|
* the userspace uses 32 bits.
|
|
|
|
* @get_unmapped_area: called by the mmap() syscall, used when %!CONFIG_MMU
|
|
|
|
* @mmap: operations needed to implement the mmap() syscall
|
|
|
|
* @open: operations needed to implement the open() syscall
|
|
|
|
* @release: operations needed to implement the release() syscall
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* Those operations are used to implemente the fs struct file_operations
|
|
|
|
* at the V4L2 drivers. The V4L2 core overrides the fs ops with some
|
|
|
|
* extra logic needed by the subsystem.
|
|
|
|
*/
|
2008-12-30 16:58:20 +07:00
|
|
|
struct v4l2_file_operations {
|
|
|
|
struct module *owner;
|
|
|
|
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
|
|
|
|
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
|
2017-07-03 09:22:01 +07:00
|
|
|
__poll_t (*poll) (struct file *, struct poll_table_struct *);
|
2008-12-30 16:58:20 +07:00
|
|
|
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
|
2011-12-19 06:41:19 +07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
long (*compat_ioctl32) (struct file *, unsigned int, unsigned long);
|
|
|
|
#endif
|
2011-05-06 15:20:09 +07:00
|
|
|
unsigned long (*get_unmapped_area) (struct file *, unsigned long,
|
|
|
|
unsigned long, unsigned long, unsigned long);
|
2008-12-30 16:58:20 +07:00
|
|
|
int (*mmap) (struct file *, struct vm_area_struct *);
|
|
|
|
int (*open) (struct file *);
|
|
|
|
int (*release) (struct file *);
|
|
|
|
};
|
|
|
|
|
2006-06-04 20:06:18 +07:00
|
|
|
/*
|
|
|
|
* Newer version of video_device, handled by videodev2.c
|
2018-01-04 18:47:28 +07:00
|
|
|
* This version moves redundant code from video device code to
|
2006-06-04 20:06:18 +07:00
|
|
|
* the common handler
|
|
|
|
*/
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* struct video_device - Structure used to create and manage the V4L2 device
|
|
|
|
* nodes.
|
|
|
|
*
|
|
|
|
* @entity: &struct media_entity
|
|
|
|
* @intf_devnode: pointer to &struct media_intf_devnode
|
|
|
|
* @pipe: &struct media_pipeline
|
|
|
|
* @fops: pointer to &struct v4l2_file_operations for the video device
|
|
|
|
* @device_caps: device capabilities as used in v4l2_capabilities
|
|
|
|
* @dev: &struct device for the video device
|
|
|
|
* @cdev: character device
|
|
|
|
* @v4l2_dev: pointer to &struct v4l2_device parent
|
|
|
|
* @dev_parent: pointer to &struct device parent
|
|
|
|
* @ctrl_handler: Control handler associated with this device node.
|
|
|
|
* May be NULL.
|
|
|
|
* @queue: &struct vb2_queue associated with this device node. May be NULL.
|
|
|
|
* @prio: pointer to &struct v4l2_prio_state with device's Priority state.
|
|
|
|
* If NULL, then v4l2_dev->prio will be used.
|
|
|
|
* @name: video device name
|
2017-09-29 05:39:32 +07:00
|
|
|
* @vfl_type: V4L device type, as defined by &enum vfl_devnode_type
|
2016-07-22 01:30:20 +07:00
|
|
|
* @vfl_dir: V4L receiver, transmitter or m2m
|
|
|
|
* @minor: device node 'minor'. It is set to -1 if the registration failed
|
|
|
|
* @num: number of the video device node
|
2017-10-06 01:05:25 +07:00
|
|
|
* @flags: video device flags. Use bitops to set/clear/test flags.
|
|
|
|
* Contains a set of &enum v4l2_video_device_flags.
|
2016-07-22 01:30:20 +07:00
|
|
|
* @index: attribute to differentiate multiple indices on one physical device
|
|
|
|
* @fh_lock: Lock for all v4l2_fhs
|
|
|
|
* @fh_list: List of &struct v4l2_fh
|
|
|
|
* @dev_debug: Internal device debug flags, not for use by drivers
|
|
|
|
* @tvnorms: Supported tv norms
|
|
|
|
*
|
|
|
|
* @release: video device release() callback
|
|
|
|
* @ioctl_ops: pointer to &struct v4l2_ioctl_ops with ioctl callbacks
|
|
|
|
*
|
|
|
|
* @valid_ioctls: bitmap with the valid ioctls for this device
|
|
|
|
* @disable_locking: bitmap with the ioctls that don't require locking
|
|
|
|
* @lock: pointer to &struct mutex serialization lock
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* Only set @dev_parent if that can't be deduced from @v4l2_dev.
|
|
|
|
*/
|
|
|
|
|
2006-06-04 20:06:18 +07:00
|
|
|
struct video_device
|
|
|
|
{
|
2009-12-09 18:40:10 +07:00
|
|
|
#if defined(CONFIG_MEDIA_CONTROLLER)
|
|
|
|
struct media_entity entity;
|
2015-08-24 18:47:54 +07:00
|
|
|
struct media_intf_devnode *intf_devnode;
|
2016-02-12 06:41:25 +07:00
|
|
|
struct media_pipeline pipe;
|
2009-12-09 18:40:10 +07:00
|
|
|
#endif
|
2008-12-30 16:58:20 +07:00
|
|
|
const struct v4l2_file_operations *fops;
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2016-03-01 21:57:23 +07:00
|
|
|
u32 device_caps;
|
|
|
|
|
2007-10-09 02:26:13 +07:00
|
|
|
/* sysfs */
|
2016-07-22 01:30:20 +07:00
|
|
|
struct device dev;
|
|
|
|
struct cdev *cdev;
|
2008-12-23 17:35:17 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
struct v4l2_device *v4l2_dev;
|
|
|
|
struct device *dev_parent;
|
2007-10-09 02:26:13 +07:00
|
|
|
|
2010-08-02 00:32:42 +07:00
|
|
|
struct v4l2_ctrl_handler *ctrl_handler;
|
|
|
|
|
2012-06-22 17:29:35 +07:00
|
|
|
struct vb2_queue *queue;
|
|
|
|
|
2011-02-24 20:42:24 +07:00
|
|
|
struct v4l2_prio_state *prio;
|
|
|
|
|
2006-06-04 20:06:18 +07:00
|
|
|
/* device info */
|
|
|
|
char name[32];
|
2017-09-29 05:39:32 +07:00
|
|
|
enum vfl_devnode_type vfl_type;
|
2017-10-06 00:52:19 +07:00
|
|
|
enum vfl_devnode_direction vfl_dir;
|
2006-06-04 20:06:18 +07:00
|
|
|
int minor;
|
2008-10-04 18:36:54 +07:00
|
|
|
u16 num;
|
2008-12-20 07:28:27 +07:00
|
|
|
unsigned long flags;
|
2008-06-21 08:58:53 +07:00
|
|
|
int index;
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2010-03-23 19:25:26 +07:00
|
|
|
/* V4L2 file handles */
|
2016-07-22 01:30:20 +07:00
|
|
|
spinlock_t fh_lock;
|
|
|
|
struct list_head fh_list;
|
2010-03-23 19:25:26 +07:00
|
|
|
|
2014-12-01 20:10:44 +07:00
|
|
|
int dev_debug;
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
v4l2_std_id tvnorms;
|
2006-06-04 20:06:18 +07:00
|
|
|
|
|
|
|
/* callbacks */
|
2008-12-20 07:28:27 +07:00
|
|
|
void (*release)(struct video_device *vdev);
|
2008-07-21 12:57:38 +07:00
|
|
|
const struct v4l2_ioctl_ops *ioctl_ops;
|
2012-05-10 15:36:00 +07:00
|
|
|
DECLARE_BITMAP(valid_ioctls, BASE_VIDIOC_PRIVATE);
|
2010-09-26 18:47:38 +07:00
|
|
|
|
2012-05-14 21:32:48 +07:00
|
|
|
DECLARE_BITMAP(disable_locking, BASE_VIDIOC_PRIVATE);
|
2010-09-26 18:47:38 +07:00
|
|
|
struct mutex *lock;
|
2006-06-04 20:06:18 +07:00
|
|
|
};
|
|
|
|
|
2017-09-28 20:34:54 +07:00
|
|
|
/**
|
|
|
|
* media_entity_to_video_device - Returns a &struct video_device from
|
|
|
|
* the &struct media_entity embedded on it.
|
|
|
|
*
|
2018-01-25 20:08:52 +07:00
|
|
|
* @__entity: pointer to &struct media_entity
|
2017-09-28 20:34:54 +07:00
|
|
|
*/
|
2018-01-25 20:08:52 +07:00
|
|
|
#define media_entity_to_video_device(__entity) \
|
|
|
|
container_of(__entity, struct video_device, entity)
|
2017-09-28 20:34:54 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* to_video_device - Returns a &struct video_device from the
|
|
|
|
* &struct device embedded on it.
|
|
|
|
*
|
|
|
|
* @cd: pointer to &struct device
|
|
|
|
*/
|
2008-07-20 16:35:02 +07:00
|
|
|
#define to_video_device(cd) container_of(cd, struct video_device, dev)
|
2007-09-14 07:09:01 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* __video_register_device - register video4linux devices
|
|
|
|
*
|
|
|
|
* @vdev: struct video_device to register
|
2017-09-29 05:39:32 +07:00
|
|
|
* @type: type of device to register, as defined by &enum vfl_devnode_type
|
2016-07-22 01:30:20 +07:00
|
|
|
* @nr: which device node number is desired:
|
2018-01-04 18:47:28 +07:00
|
|
|
* (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
|
2016-07-22 01:30:20 +07:00
|
|
|
* @warn_if_nr_in_use: warn if the desired device node number
|
|
|
|
* was already in use and another number was chosen instead.
|
|
|
|
* @owner: module that owns the video device node
|
|
|
|
*
|
|
|
|
* The registration code assigns minor numbers and device node numbers
|
|
|
|
* based on the requested type and registers the new device node with
|
|
|
|
* the kernel.
|
|
|
|
*
|
|
|
|
* This function assumes that struct video_device was zeroed when it
|
|
|
|
* was allocated and does not contain any stale date.
|
|
|
|
*
|
|
|
|
* An error is returned if no free minor or device node number could be
|
|
|
|
* found, or if the registration of the device node failed.
|
|
|
|
*
|
|
|
|
* Returns 0 on success.
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* This function is meant to be used only inside the V4L2 core.
|
|
|
|
* Drivers should use video_register_device() or
|
|
|
|
* video_register_device_no_warn().
|
|
|
|
*/
|
2017-09-29 05:39:32 +07:00
|
|
|
int __must_check __video_register_device(struct video_device *vdev,
|
|
|
|
enum vfl_devnode_type type,
|
|
|
|
int nr, int warn_if_nr_in_use,
|
|
|
|
struct module *owner);
|
2009-12-09 18:38:49 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_register_device - register video4linux devices
|
|
|
|
*
|
|
|
|
* @vdev: struct video_device to register
|
2017-09-29 05:39:32 +07:00
|
|
|
* @type: type of device to register, as defined by &enum vfl_devnode_type
|
2016-07-22 01:30:20 +07:00
|
|
|
* @nr: which device node number is desired:
|
2018-01-04 18:47:28 +07:00
|
|
|
* (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* Internally, it calls __video_register_device(). Please see its
|
|
|
|
* documentation for more details.
|
|
|
|
*
|
|
|
|
* .. note::
|
2018-01-04 18:47:28 +07:00
|
|
|
* if video_register_device fails, the release() callback of
|
2016-07-22 01:30:20 +07:00
|
|
|
* &struct video_device structure is *not* called, so the caller
|
|
|
|
* is responsible for freeing any data. Usually that means that
|
|
|
|
* you video_device_release() should be called on failure.
|
|
|
|
*/
|
2009-12-09 18:38:49 +07:00
|
|
|
static inline int __must_check video_register_device(struct video_device *vdev,
|
2017-09-29 05:39:32 +07:00
|
|
|
enum vfl_devnode_type type,
|
|
|
|
int nr)
|
2009-12-09 18:38:49 +07:00
|
|
|
{
|
|
|
|
return __video_register_device(vdev, type, nr, 1, vdev->fops->owner);
|
|
|
|
}
|
2008-12-20 07:28:27 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_register_device_no_warn - register video4linux devices
|
|
|
|
*
|
|
|
|
* @vdev: struct video_device to register
|
2017-09-29 05:39:32 +07:00
|
|
|
* @type: type of device to register, as defined by &enum vfl_devnode_type
|
2016-07-22 01:30:20 +07:00
|
|
|
* @nr: which device node number is desired:
|
2018-01-04 18:47:28 +07:00
|
|
|
* (0 == /dev/video0, 1 == /dev/video1, ..., -1 == first free)
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* This function is identical to video_register_device() except that no
|
|
|
|
* warning is issued if the desired device node number was already in use.
|
|
|
|
*
|
|
|
|
* Internally, it calls __video_register_device(). Please see its
|
|
|
|
* documentation for more details.
|
|
|
|
*
|
|
|
|
* .. note::
|
2018-01-04 18:47:28 +07:00
|
|
|
* if video_register_device fails, the release() callback of
|
2016-07-22 01:30:20 +07:00
|
|
|
* &struct video_device structure is *not* called, so the caller
|
|
|
|
* is responsible for freeing any data. Usually that means that
|
|
|
|
* you video_device_release() should be called on failure.
|
|
|
|
*/
|
2017-09-29 05:39:32 +07:00
|
|
|
static inline int __must_check
|
|
|
|
video_register_device_no_warn(struct video_device *vdev,
|
|
|
|
enum vfl_devnode_type type, int nr)
|
2009-12-09 18:38:49 +07:00
|
|
|
{
|
|
|
|
return __video_register_device(vdev, type, nr, 0, vdev->fops->owner);
|
|
|
|
}
|
2009-09-06 17:54:00 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_unregister_device - Unregister video devices.
|
|
|
|
*
|
|
|
|
* @vdev: &struct video_device to register
|
|
|
|
*
|
|
|
|
* Does nothing if vdev == NULL or if video_is_registered() returns false.
|
|
|
|
*/
|
2008-12-20 07:28:27 +07:00
|
|
|
void video_unregister_device(struct video_device *vdev);
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_device_alloc - helper function to alloc &struct video_device
|
|
|
|
*
|
|
|
|
* Returns NULL if %-ENOMEM or a &struct video_device on success.
|
|
|
|
*/
|
2008-08-23 16:38:11 +07:00
|
|
|
struct video_device * __must_check video_device_alloc(void);
|
2008-08-23 17:48:38 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_device_release - helper function to release &struct video_device
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
*
|
2016-07-23 17:12:03 +07:00
|
|
|
* Can also be used for video_device->release\(\).
|
2016-07-22 01:30:20 +07:00
|
|
|
*/
|
2008-12-20 07:28:27 +07:00
|
|
|
void video_device_release(struct video_device *vdev);
|
2008-08-23 17:48:38 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_device_release_empty - helper function to implement the
|
2018-01-04 18:47:28 +07:00
|
|
|
* video_device->release\(\) callback.
|
2016-07-22 01:30:20 +07:00
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
*
|
|
|
|
* This release function does nothing.
|
|
|
|
*
|
|
|
|
* It should be used when the video_device is a static global struct.
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
* Having a static video_device is a dubious construction at best.
|
|
|
|
*/
|
2008-12-20 07:28:27 +07:00
|
|
|
void video_device_release_empty(struct video_device *vdev);
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* v4l2_is_known_ioctl - Checks if a given cmd is a known V4L ioctl
|
|
|
|
*
|
|
|
|
* @cmd: ioctl command
|
|
|
|
*
|
|
|
|
* returns true if cmd is a known V4L2 ioctl
|
|
|
|
*/
|
2012-05-10 12:51:31 +07:00
|
|
|
bool v4l2_is_known_ioctl(unsigned int cmd);
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/** v4l2_disable_ioctl_locking - mark that a given command
|
|
|
|
* shouldn't use core locking
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
* @cmd: ioctl command
|
|
|
|
*/
|
|
|
|
static inline void v4l2_disable_ioctl_locking(struct video_device *vdev,
|
|
|
|
unsigned int cmd)
|
2012-05-10 12:51:31 +07:00
|
|
|
{
|
|
|
|
if (_IOC_NR(cmd) < BASE_VIDIOC_PRIVATE)
|
2012-05-14 21:32:48 +07:00
|
|
|
set_bit(_IOC_NR(cmd), vdev->disable_locking);
|
2012-05-10 12:51:31 +07:00
|
|
|
}
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* v4l2_disable_ioctl- mark that a given command isn't implemented.
|
|
|
|
* shouldn't use core locking
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
* @cmd: ioctl command
|
|
|
|
*
|
|
|
|
* This function allows drivers to provide just one v4l2_ioctl_ops struct, but
|
|
|
|
* disable ioctls based on the specific card that is actually found.
|
|
|
|
*
|
|
|
|
* .. note::
|
|
|
|
*
|
|
|
|
* This must be called before video_register_device.
|
|
|
|
* See also the comments for determine_valid_ioctls().
|
|
|
|
*/
|
|
|
|
static inline void v4l2_disable_ioctl(struct video_device *vdev,
|
|
|
|
unsigned int cmd)
|
2012-05-10 15:36:00 +07:00
|
|
|
{
|
|
|
|
if (_IOC_NR(cmd) < BASE_VIDIOC_PRIVATE)
|
|
|
|
set_bit(_IOC_NR(cmd), vdev->valid_ioctls);
|
|
|
|
}
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_get_drvdata - gets private data from &struct video_device.
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
*
|
|
|
|
* returns a pointer to the private data
|
|
|
|
*/
|
2008-12-20 07:28:27 +07:00
|
|
|
static inline void *video_get_drvdata(struct video_device *vdev)
|
2006-06-04 20:06:18 +07:00
|
|
|
{
|
2008-12-20 07:28:27 +07:00
|
|
|
return dev_get_drvdata(&vdev->dev);
|
2006-06-04 20:06:18 +07:00
|
|
|
}
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_set_drvdata - sets private data from &struct video_device.
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
* @data: private data pointer
|
|
|
|
*/
|
2008-12-20 07:28:27 +07:00
|
|
|
static inline void video_set_drvdata(struct video_device *vdev, void *data)
|
2006-06-04 20:06:18 +07:00
|
|
|
{
|
2008-12-20 07:28:27 +07:00
|
|
|
dev_set_drvdata(&vdev->dev, data);
|
2006-06-04 20:06:18 +07:00
|
|
|
}
|
2006-08-08 19:10:01 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_devdata - gets &struct video_device from struct file.
|
|
|
|
*
|
|
|
|
* @file: pointer to struct file
|
|
|
|
*/
|
2008-08-23 17:48:38 +07:00
|
|
|
struct video_device *video_devdata(struct file *file);
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_drvdata - gets private data from &struct video_device using the
|
|
|
|
* struct file.
|
|
|
|
*
|
|
|
|
* @file: pointer to struct file
|
|
|
|
*
|
|
|
|
* This is function combines both video_get_drvdata() and video_devdata()
|
|
|
|
* as this is used very often.
|
|
|
|
*/
|
2008-08-23 17:48:38 +07:00
|
|
|
static inline void *video_drvdata(struct file *file)
|
|
|
|
{
|
|
|
|
return video_get_drvdata(video_devdata(file));
|
|
|
|
}
|
2006-06-04 20:06:18 +07:00
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_device_node_name - returns the video device name
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
*
|
|
|
|
* Returns the device name string
|
|
|
|
*/
|
2009-11-27 23:56:50 +07:00
|
|
|
static inline const char *video_device_node_name(struct video_device *vdev)
|
|
|
|
{
|
|
|
|
return dev_name(&vdev->dev);
|
|
|
|
}
|
|
|
|
|
2016-07-22 01:30:20 +07:00
|
|
|
/**
|
|
|
|
* video_is_registered - returns true if the &struct video_device is registered.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* @vdev: pointer to &struct video_device
|
|
|
|
*/
|
2009-11-27 23:57:22 +07:00
|
|
|
static inline int video_is_registered(struct video_device *vdev)
|
2008-12-20 07:28:27 +07:00
|
|
|
{
|
2009-11-27 23:57:22 +07:00
|
|
|
return test_bit(V4L2_FL_REGISTERED, &vdev->flags);
|
2008-12-20 07:28:27 +07:00
|
|
|
}
|
|
|
|
|
2006-06-04 20:06:18 +07:00
|
|
|
#endif /* _V4L2_DEV_H */
|