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