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