mc-devnode.c

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