GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / media / media-devnode.c
1 /*
2  * Media device node
3  *
4  * Copyright (C) 2010 Nokia Corporation
5  *
6  * Based on drivers/media/video/v4l2_dev.c code authored by
7  *      Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
8  *      Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
9  *
10  * Contacts: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
11  *           Sakari Ailus <sakari.ailus@iki.fi>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License version 2 as
15  * published by the Free Software Foundation.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  *
26  * --
27  *
28  * Generic media device node infrastructure to register and unregister
29  * character devices using a dynamic major number and proper reference
30  * counting.
31  */
32
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/module.h>
38 #include <linux/kernel.h>
39 #include <linux/kmod.h>
40 #include <linux/slab.h>
41 #include <linux/mm.h>
42 #include <linux/string.h>
43 #include <linux/types.h>
44 #include <linux/uaccess.h>
45
46 #include <media/media-devnode.h>
47 #include <media/media-device.h>
48
49 #define MEDIA_NUM_DEVICES       256
50 #define MEDIA_NAME              "media"
51
52 static dev_t media_dev_t;
53
54 /*
55  *      Active devices
56  */
57 static DEFINE_MUTEX(media_devnode_lock);
58 static DECLARE_BITMAP(media_devnode_nums, MEDIA_NUM_DEVICES);
59
60 /* Called when the last user of the media device exits. */
61 static void media_devnode_release(struct device *cd)
62 {
63         struct media_devnode *devnode = to_media_devnode(cd);
64
65         mutex_lock(&media_devnode_lock);
66         /* Mark device node number as free */
67         clear_bit(devnode->minor, media_devnode_nums);
68         mutex_unlock(&media_devnode_lock);
69
70         /* Release media_devnode and perform other cleanups as needed. */
71         if (devnode->release)
72                 devnode->release(devnode);
73
74         kfree(devnode);
75         pr_debug("%s: Media Devnode Deallocated\n", __func__);
76 }
77
78 static struct bus_type media_bus_type = {
79         .name = MEDIA_NAME,
80 };
81
82 static ssize_t media_read(struct file *filp, char __user *buf,
83                 size_t sz, loff_t *off)
84 {
85         struct media_devnode *devnode = media_devnode_data(filp);
86
87         if (!devnode->fops->read)
88                 return -EINVAL;
89         if (!media_devnode_is_registered(devnode))
90                 return -EIO;
91         return devnode->fops->read(filp, buf, sz, off);
92 }
93
94 static ssize_t media_write(struct file *filp, const char __user *buf,
95                 size_t sz, loff_t *off)
96 {
97         struct media_devnode *devnode = media_devnode_data(filp);
98
99         if (!devnode->fops->write)
100                 return -EINVAL;
101         if (!media_devnode_is_registered(devnode))
102                 return -EIO;
103         return devnode->fops->write(filp, buf, sz, off);
104 }
105
106 static unsigned int media_poll(struct file *filp,
107                                struct poll_table_struct *poll)
108 {
109         struct media_devnode *devnode = media_devnode_data(filp);
110
111         if (!media_devnode_is_registered(devnode))
112                 return POLLERR | POLLHUP;
113         if (!devnode->fops->poll)
114                 return DEFAULT_POLLMASK;
115         return devnode->fops->poll(filp, poll);
116 }
117
118 static long
119 __media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg,
120               long (*ioctl_func)(struct file *filp, unsigned int cmd,
121                                  unsigned long arg))
122 {
123         struct media_devnode *devnode = media_devnode_data(filp);
124
125         if (!ioctl_func)
126                 return -ENOTTY;
127
128         if (!media_devnode_is_registered(devnode))
129                 return -EIO;
130
131         return ioctl_func(filp, cmd, arg);
132 }
133
134 static long media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
135 {
136         struct media_devnode *devnode = media_devnode_data(filp);
137
138         return __media_ioctl(filp, cmd, arg, devnode->fops->ioctl);
139 }
140
141 #ifdef CONFIG_COMPAT
142
143 static long media_compat_ioctl(struct file *filp, unsigned int cmd,
144                                unsigned long arg)
145 {
146         struct media_devnode *devnode = media_devnode_data(filp);
147
148         return __media_ioctl(filp, cmd, arg, devnode->fops->compat_ioctl);
149 }
150
151 #endif /* CONFIG_COMPAT */
152
153 /* Override for the open function */
154 static int media_open(struct inode *inode, struct file *filp)
155 {
156         struct media_devnode *devnode;
157         int ret;
158
159         /* Check if the media device is available. This needs to be done with
160          * the media_devnode_lock held to prevent an open/unregister race:
161          * without the lock, the device could be unregistered and freed between
162          * the media_devnode_is_registered() and get_device() calls, leading to
163          * a crash.
164          */
165         mutex_lock(&media_devnode_lock);
166         devnode = container_of(inode->i_cdev, struct media_devnode, cdev);
167         /* return ENXIO if the media device has been removed
168            already or if it is not registered anymore. */
169         if (!media_devnode_is_registered(devnode)) {
170                 mutex_unlock(&media_devnode_lock);
171                 return -ENXIO;
172         }
173         /* and increase the device refcount */
174         get_device(&devnode->dev);
175         mutex_unlock(&media_devnode_lock);
176
177         filp->private_data = devnode;
178
179         if (devnode->fops->open) {
180                 ret = devnode->fops->open(filp);
181                 if (ret) {
182                         put_device(&devnode->dev);
183                         filp->private_data = NULL;
184                         return ret;
185                 }
186         }
187
188         return 0;
189 }
190
191 /* Override for the release function */
192 static int media_release(struct inode *inode, struct file *filp)
193 {
194         struct media_devnode *devnode = media_devnode_data(filp);
195
196         if (devnode->fops->release)
197                 devnode->fops->release(filp);
198
199         filp->private_data = NULL;
200
201         /* decrease the refcount unconditionally since the release()
202            return value is ignored. */
203         put_device(&devnode->dev);
204
205         pr_debug("%s: Media Release\n", __func__);
206         return 0;
207 }
208
209 static const struct file_operations media_devnode_fops = {
210         .owner = THIS_MODULE,
211         .read = media_read,
212         .write = media_write,
213         .open = media_open,
214         .unlocked_ioctl = media_ioctl,
215 #ifdef CONFIG_COMPAT
216         .compat_ioctl = media_compat_ioctl,
217 #endif /* CONFIG_COMPAT */
218         .release = media_release,
219         .poll = media_poll,
220         .llseek = no_llseek,
221 };
222
223 /**
224  * media_devnode_register - register a media device node
225  * @media_dev: struct media_device we want to register a device node
226  * @devnode: media device node structure we want to register
227  *
228  * The registration code assigns minor numbers and registers the new device node
229  * with the kernel. An error is returned if no free minor number can be found,
230  * or if the registration of the device node fails.
231  *
232  * Zero is returned on success.
233  *
234  * Note that if the media_devnode_register call fails, the release() callback of
235  * the media_devnode structure is *not* called, so the caller is responsible for
236  * freeing any data.
237  */
238 int __must_check media_devnode_register(struct media_device *mdev,
239                                         struct media_devnode *devnode,
240                                         struct module *owner)
241 {
242         int minor;
243         int ret;
244
245         /* Part 1: Find a free minor number */
246         mutex_lock(&media_devnode_lock);
247         minor = find_next_zero_bit(media_devnode_nums, MEDIA_NUM_DEVICES, 0);
248         if (minor == MEDIA_NUM_DEVICES) {
249                 mutex_unlock(&media_devnode_lock);
250                 pr_err("could not get a free minor\n");
251                 kfree(devnode);
252                 return -ENFILE;
253         }
254
255         set_bit(minor, media_devnode_nums);
256         mutex_unlock(&media_devnode_lock);
257
258         devnode->minor = minor;
259         devnode->media_dev = mdev;
260
261         /* Part 1: Initialize dev now to use dev.kobj for cdev.kobj.parent */
262         devnode->dev.bus = &media_bus_type;
263         devnode->dev.devt = MKDEV(MAJOR(media_dev_t), devnode->minor);
264         devnode->dev.release = media_devnode_release;
265         if (devnode->parent)
266                 devnode->dev.parent = devnode->parent;
267         dev_set_name(&devnode->dev, "media%d", devnode->minor);
268         device_initialize(&devnode->dev);
269
270         /* Part 2: Initialize and register the character device */
271         cdev_init(&devnode->cdev, &media_devnode_fops);
272         devnode->cdev.owner = owner;
273         devnode->cdev.kobj.parent = &devnode->dev.kobj;
274
275         ret = cdev_add(&devnode->cdev, MKDEV(MAJOR(media_dev_t), devnode->minor), 1);
276         if (ret < 0) {
277                 pr_err("%s: cdev_add failed\n", __func__);
278                 goto cdev_add_error;
279         }
280
281         /* Part 3: Add the media device */
282         ret = device_add(&devnode->dev);
283         if (ret < 0) {
284                 pr_err("%s: device_add failed\n", __func__);
285                 goto device_add_error;
286         }
287
288         /* Part 4: Activate this minor. The char device can now be used. */
289         set_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
290
291         return 0;
292
293 device_add_error:
294         cdev_del(&devnode->cdev);
295 cdev_add_error:
296         mutex_lock(&media_devnode_lock);
297         clear_bit(devnode->minor, media_devnode_nums);
298         devnode->media_dev = NULL;
299         mutex_unlock(&media_devnode_lock);
300
301         put_device(&devnode->dev);
302         return ret;
303 }
304
305 void media_devnode_unregister_prepare(struct media_devnode *devnode)
306 {
307         /* Check if devnode was ever registered at all */
308         if (!media_devnode_is_registered(devnode))
309                 return;
310
311         mutex_lock(&media_devnode_lock);
312         clear_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
313         mutex_unlock(&media_devnode_lock);
314 }
315
316 /**
317  * media_devnode_unregister - unregister a media device node
318  * @devnode: the device node to unregister
319  *
320  * This unregisters the passed device. Future open calls will be met with
321  * errors.
322  *
323  * Should be called after media_devnode_unregister_prepare()
324  */
325 void media_devnode_unregister(struct media_devnode *devnode)
326 {
327         mutex_lock(&media_devnode_lock);
328         /* Delete the cdev on this minor as well */
329         cdev_del(&devnode->cdev);
330         mutex_unlock(&media_devnode_lock);
331         device_del(&devnode->dev);
332         devnode->media_dev = NULL;
333         put_device(&devnode->dev);
334 }
335
336 /*
337  *      Initialise media for linux
338  */
339 static int __init media_devnode_init(void)
340 {
341         int ret;
342
343         pr_info("Linux media interface: v0.10\n");
344         ret = alloc_chrdev_region(&media_dev_t, 0, MEDIA_NUM_DEVICES,
345                                   MEDIA_NAME);
346         if (ret < 0) {
347                 pr_warn("unable to allocate major\n");
348                 return ret;
349         }
350
351         ret = bus_register(&media_bus_type);
352         if (ret < 0) {
353                 unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
354                 pr_warn("bus_register failed\n");
355                 return -EIO;
356         }
357
358         return 0;
359 }
360
361 static void __exit media_devnode_exit(void)
362 {
363         bus_unregister(&media_bus_type);
364         unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
365 }
366
367 subsys_initcall(media_devnode_init);
368 module_exit(media_devnode_exit)
369
370 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
371 MODULE_DESCRIPTION("Device node registration for media drivers");
372 MODULE_LICENSE("GPL");