projects/linux·blob master · refs

326 lines · 8.2 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Media device node
4 *
5 * Copyright (C) 2010 Nokia Corporation
6 *
7 * Based on drivers/media/video/v4l2_dev.c code authored by
8 * Mauro Carvalho Chehab <[email protected]> (version 2)
9 * Alan Cox, <[email protected]> (version 1)
10 *
11 * Contacts: Laurent Pinchart <[email protected]>
12 * Sakari Ailus <[email protected]>
13 *
14 * --
15 *
16 * Generic media device node infrastructure to register and unregister
17 * character devices using a dynamic major number and proper reference
18 * counting.
19 */
20
21#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
22
23#include <linux/errno.h>
24#include <linux/init.h>
25#include <linux/module.h>
26#include <linux/kernel.h>
27#include <linux/kmod.h>
28#include <linux/slab.h>
29#include <linux/mm.h>
30#include <linux/string.h>
31#include <linux/types.h>
32#include <linux/uaccess.h>
33
34#include <media/media-devnode.h>
35#include <media/media-device.h>
36
37#define MEDIA_NUM_DEVICES 256
38#define MEDIA_NAME "media"
39
40static dev_t media_dev_t;
41
42/*
43 * Active devices
44 */
45static DEFINE_MUTEX(media_devnode_lock);
46static DECLARE_BITMAP(media_devnode_nums, MEDIA_NUM_DEVICES);
47
48/* debugfs */
49struct dentry *media_debugfs_root;
50
51/* Called when the last user of the media device exits. */
52static void media_devnode_release(struct device *cd)
53{
54 struct media_devnode *devnode = to_media_devnode(cd);
55
56 /* Release media_devnode and perform other cleanups as needed. */
57 if (devnode->release)
58 devnode->release(devnode);
59
60 kfree(devnode);
61 pr_debug("%s: Media Devnode Deallocated\n", __func__);
62}
63
64static const struct bus_type media_bus_type = {
65 .name = MEDIA_NAME,
66};
67
68static ssize_t media_read(struct file *filp, char __user *buf,
69 size_t sz, loff_t *off)
70{
71 struct media_devnode *devnode = media_devnode_data(filp);
72
73 if (!devnode->fops->read)
74 return -EINVAL;
75 if (!media_devnode_is_registered(devnode))
76 return -EIO;
77 return devnode->fops->read(filp, buf, sz, off);
78}
79
80static ssize_t media_write(struct file *filp, const char __user *buf,
81 size_t sz, loff_t *off)
82{
83 struct media_devnode *devnode = media_devnode_data(filp);
84
85 if (!devnode->fops->write)
86 return -EINVAL;
87 if (!media_devnode_is_registered(devnode))
88 return -EIO;
89 return devnode->fops->write(filp, buf, sz, off);
90}
91
92static __poll_t media_poll(struct file *filp,
93 struct poll_table_struct *poll)
94{
95 struct media_devnode *devnode = media_devnode_data(filp);
96
97 if (!media_devnode_is_registered(devnode))
98 return EPOLLERR | EPOLLHUP;
99 if (!devnode->fops->poll)
100 return DEFAULT_POLLMASK;
101 return devnode->fops->poll(filp, poll);
102}
103
104static long
105__media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg,
106 long (*ioctl_func)(struct file *filp, unsigned int cmd,
107 unsigned long arg))
108{
109 struct media_devnode *devnode = media_devnode_data(filp);
110
111 if (!ioctl_func)
112 return -ENOTTY;
113
114 if (!media_devnode_is_registered(devnode))
115 return -EIO;
116
117 return ioctl_func(filp, cmd, arg);
118}
119
120static long media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
121{
122 struct media_devnode *devnode = media_devnode_data(filp);
123
124 return __media_ioctl(filp, cmd, arg, devnode->fops->ioctl);
125}
126
127#ifdef CONFIG_COMPAT
128
129static long media_compat_ioctl(struct file *filp, unsigned int cmd,
130 unsigned long arg)
131{
132 struct media_devnode *devnode = media_devnode_data(filp);
133
134 return __media_ioctl(filp, cmd, arg, devnode->fops->compat_ioctl);
135}
136
137#endif /* CONFIG_COMPAT */
138
139/* Override for the open function */
140static int media_open(struct inode *inode, struct file *filp)
141{
142 struct media_devnode *devnode;
143 int ret;
144
145 /* Check if the media device is available. This needs to be done with
146 * the media_devnode_lock held to prevent an open/unregister race:
147 * without the lock, the device could be unregistered and freed between
148 * the media_devnode_is_registered() and get_device() calls, leading to
149 * a crash.
150 */
151 mutex_lock(&media_devnode_lock);
152 devnode = container_of(inode->i_cdev, struct media_devnode, cdev);
153 /* return ENXIO if the media device has been removed
154 already or if it is not registered anymore. */
155 if (!media_devnode_is_registered(devnode)) {
156 mutex_unlock(&media_devnode_lock);
157 return -ENXIO;
158 }
159 /* and increase the device refcount */
160 get_device(&devnode->dev);
161 mutex_unlock(&media_devnode_lock);
162
163 filp->private_data = devnode;
164
165 if (devnode->fops->open) {
166 ret = devnode->fops->open(filp);
167 if (ret) {
168 put_device(&devnode->dev);
169 filp->private_data = NULL;
170 return ret;
171 }
172 }
173
174 return 0;
175}
176
177/* Override for the release function */
178static int media_release(struct inode *inode, struct file *filp)
179{
180 struct media_devnode *devnode = media_devnode_data(filp);
181
182 if (devnode->fops->release)
183 devnode->fops->release(filp);
184
185 filp->private_data = NULL;
186
187 /* decrease the refcount unconditionally since the release()
188 return value is ignored. */
189 put_device(&devnode->dev);
190
191 return 0;
192}
193
194static const struct file_operations media_devnode_fops = {
195 .owner = THIS_MODULE,
196 .read = media_read,
197 .write = media_write,
198 .open = media_open,
199 .unlocked_ioctl = media_ioctl,
200#ifdef CONFIG_COMPAT
201 .compat_ioctl = media_compat_ioctl,
202#endif /* CONFIG_COMPAT */
203 .release = media_release,
204 .poll = media_poll,
205};
206
207int __must_check media_devnode_register(struct media_device *mdev,
208 struct media_devnode *devnode,
209 struct module *owner)
210{
211 int minor;
212 int ret;
213
214 /* Part 1: Find a free minor number */
215 mutex_lock(&media_devnode_lock);
216 minor = find_first_zero_bit(media_devnode_nums, MEDIA_NUM_DEVICES);
217 if (minor == MEDIA_NUM_DEVICES) {
218 mutex_unlock(&media_devnode_lock);
219 pr_err("could not get a free minor\n");
220 kfree(devnode);
221 return -ENFILE;
222 }
223
224 set_bit(minor, media_devnode_nums);
225 mutex_unlock(&media_devnode_lock);
226
227 devnode->minor = minor;
228 devnode->media_dev = mdev;
229
230 /* Part 1: Initialize dev now to use dev.kobj for cdev.kobj.parent */
231 devnode->dev.bus = &media_bus_type;
232 devnode->dev.devt = MKDEV(MAJOR(media_dev_t), devnode->minor);
233 devnode->dev.release = media_devnode_release;
234 if (devnode->parent)
235 devnode->dev.parent = devnode->parent;
236 dev_set_name(&devnode->dev, "media%d", devnode->minor);
237 dev_set_drvdata(&devnode->dev, mdev);
238 device_initialize(&devnode->dev);
239
240 /* Part 2: Initialize the character device */
241 cdev_init(&devnode->cdev, &media_devnode_fops);
242 devnode->cdev.owner = owner;
243 kobject_set_name(&devnode->cdev.kobj, "media%d", devnode->minor);
244
245 /* Part 3: Add the media and char device */
246 set_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
247 ret = cdev_device_add(&devnode->cdev, &devnode->dev);
248 if (ret < 0) {
249 clear_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
250 pr_err("%s: cdev_device_add failed\n", __func__);
251 goto cdev_add_error;
252 }
253
254 return 0;
255
256cdev_add_error:
257 mutex_lock(&media_devnode_lock);
258 clear_bit(devnode->minor, media_devnode_nums);
259 devnode->media_dev = NULL;
260 mutex_unlock(&media_devnode_lock);
261
262 put_device(&devnode->dev);
263 return ret;
264}
265
266void media_devnode_unregister_prepare(struct media_devnode *devnode)
267{
268 /* Check if devnode was ever registered at all */
269 if (!media_devnode_is_registered(devnode))
270 return;
271
272 mutex_lock(&media_devnode_lock);
273 clear_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
274 mutex_unlock(&media_devnode_lock);
275}
276
277void media_devnode_unregister(struct media_devnode *devnode)
278{
279 mutex_lock(&media_devnode_lock);
280 /* Delete the cdev on this minor as well */
281 cdev_device_del(&devnode->cdev, &devnode->dev);
282 devnode->media_dev = NULL;
283 clear_bit(devnode->minor, media_devnode_nums);
284 mutex_unlock(&media_devnode_lock);
285
286 put_device(&devnode->dev);
287}
288
289/*
290 * Initialise media for linux
291 */
292static int __init media_devnode_init(void)
293{
294 int ret;
295
296 pr_info("Linux media interface: v0.10\n");
297 ret = alloc_chrdev_region(&media_dev_t, 0, MEDIA_NUM_DEVICES,
298 MEDIA_NAME);
299 if (ret < 0) {
300 pr_warn("unable to allocate major\n");
301 return ret;
302 }
303
304 ret = bus_register(&media_bus_type);
305 if (ret < 0) {
306 unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
307 pr_warn("bus_register failed\n");
308 return -EIO;
309 }
310
311 return 0;
312}
313
314static void __exit media_devnode_exit(void)
315{
316 debugfs_remove_recursive(media_debugfs_root);
317 bus_unregister(&media_bus_type);
318 unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
319}
320
321subsys_initcall(media_devnode_init);
322module_exit(media_devnode_exit)
323
324MODULE_AUTHOR("Laurent Pinchart <[email protected]>");
325MODULE_DESCRIPTION("Device node registration for media drivers");
326MODULE_LICENSE("GPL");