mc-devnode.c 8.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328
  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. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21. #include <linux/errno.h>
  22. #include <linux/init.h>
  23. #include <linux/module.h>
  24. #include <linux/kernel.h>
  25. #include <linux/kmod.h>
  26. #include <linux/slab.h>
  27. #include <linux/mm.h>
  28. #include <linux/string.h>
  29. #include <linux/types.h>
  30. #include <linux/uaccess.h>
  31. #include <media/media-devnode.h>
  32. #include <media/media-device.h>
  33. #define MEDIA_NUM_DEVICES 256
  34. #define MEDIA_NAME "media"
  35. static dev_t media_dev_t;
  36. /*
  37. * Active devices
  38. */
  39. static DEFINE_MUTEX(media_devnode_lock);
  40. static DECLARE_BITMAP(media_devnode_nums, MEDIA_NUM_DEVICES);
  41. /* Called when the last user of the media device exits. */
  42. static void media_devnode_release(struct device *cd)
  43. {
  44. struct media_devnode *devnode = to_media_devnode(cd);
  45. mutex_lock(&media_devnode_lock);
  46. /* Mark device node number as free */
  47. clear_bit(devnode->minor, media_devnode_nums);
  48. mutex_unlock(&media_devnode_lock);
  49. /* Release media_devnode and perform other cleanups as needed. */
  50. if (devnode->release)
  51. devnode->release(devnode);
  52. kfree(devnode);
  53. pr_debug("%s: Media Devnode Deallocated\n", __func__);
  54. }
  55. static struct bus_type media_bus_type = {
  56. .name = MEDIA_NAME,
  57. };
  58. static ssize_t media_read(struct file *filp, char __user *buf,
  59. size_t sz, loff_t *off)
  60. {
  61. struct media_devnode *devnode = media_devnode_data(filp);
  62. if (!devnode->fops->read)
  63. return -EINVAL;
  64. if (!media_devnode_is_registered(devnode))
  65. return -EIO;
  66. return devnode->fops->read(filp, buf, sz, off);
  67. }
  68. static ssize_t media_write(struct file *filp, const char __user *buf,
  69. size_t sz, loff_t *off)
  70. {
  71. struct media_devnode *devnode = media_devnode_data(filp);
  72. if (!devnode->fops->write)
  73. return -EINVAL;
  74. if (!media_devnode_is_registered(devnode))
  75. return -EIO;
  76. return devnode->fops->write(filp, buf, sz, off);
  77. }
  78. static __poll_t media_poll(struct file *filp,
  79. struct poll_table_struct *poll)
  80. {
  81. struct media_devnode *devnode = media_devnode_data(filp);
  82. if (!media_devnode_is_registered(devnode))
  83. return EPOLLERR | EPOLLHUP;
  84. if (!devnode->fops->poll)
  85. return DEFAULT_POLLMASK;
  86. return devnode->fops->poll(filp, poll);
  87. }
  88. static long
  89. __media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg,
  90. long (*ioctl_func)(struct file *filp, unsigned int cmd,
  91. unsigned long arg))
  92. {
  93. struct media_devnode *devnode = media_devnode_data(filp);
  94. if (!ioctl_func)
  95. return -ENOTTY;
  96. if (!media_devnode_is_registered(devnode))
  97. return -EIO;
  98. return ioctl_func(filp, cmd, arg);
  99. }
  100. static long media_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  101. {
  102. struct media_devnode *devnode = media_devnode_data(filp);
  103. return __media_ioctl(filp, cmd, arg, devnode->fops->ioctl);
  104. }
  105. #ifdef CONFIG_COMPAT
  106. static long media_compat_ioctl(struct file *filp, unsigned int cmd,
  107. unsigned long arg)
  108. {
  109. struct media_devnode *devnode = media_devnode_data(filp);
  110. return __media_ioctl(filp, cmd, arg, devnode->fops->compat_ioctl);
  111. }
  112. #endif /* CONFIG_COMPAT */
  113. /* Override for the open function */
  114. static int media_open(struct inode *inode, struct file *filp)
  115. {
  116. struct media_devnode *devnode;
  117. int ret;
  118. /* Check if the media device is available. This needs to be done with
  119. * the media_devnode_lock held to prevent an open/unregister race:
  120. * without the lock, the device could be unregistered and freed between
  121. * the media_devnode_is_registered() and get_device() calls, leading to
  122. * a crash.
  123. */
  124. mutex_lock(&media_devnode_lock);
  125. devnode = container_of(inode->i_cdev, struct media_devnode, cdev);
  126. /* return ENXIO if the media device has been removed
  127. already or if it is not registered anymore. */
  128. if (!media_devnode_is_registered(devnode)) {
  129. mutex_unlock(&media_devnode_lock);
  130. return -ENXIO;
  131. }
  132. /* and increase the device refcount */
  133. get_device(&devnode->dev);
  134. mutex_unlock(&media_devnode_lock);
  135. filp->private_data = devnode;
  136. if (devnode->fops->open) {
  137. ret = devnode->fops->open(filp);
  138. if (ret) {
  139. put_device(&devnode->dev);
  140. filp->private_data = NULL;
  141. return ret;
  142. }
  143. }
  144. return 0;
  145. }
  146. /* Override for the release function */
  147. static int media_release(struct inode *inode, struct file *filp)
  148. {
  149. struct media_devnode *devnode = media_devnode_data(filp);
  150. if (devnode->fops->release)
  151. devnode->fops->release(filp);
  152. filp->private_data = NULL;
  153. /* decrease the refcount unconditionally since the release()
  154. return value is ignored. */
  155. put_device(&devnode->dev);
  156. pr_debug("%s: Media Release\n", __func__);
  157. return 0;
  158. }
  159. static const struct file_operations media_devnode_fops = {
  160. .owner = THIS_MODULE,
  161. .read = media_read,
  162. .write = media_write,
  163. .open = media_open,
  164. .unlocked_ioctl = media_ioctl,
  165. #ifdef CONFIG_COMPAT
  166. .compat_ioctl = media_compat_ioctl,
  167. #endif /* CONFIG_COMPAT */
  168. .release = media_release,
  169. .poll = media_poll,
  170. .llseek = no_llseek,
  171. };
  172. int __must_check media_devnode_register(struct media_device *mdev,
  173. struct media_devnode *devnode,
  174. struct module *owner)
  175. {
  176. int minor;
  177. int ret;
  178. /* Part 1: Find a free minor number */
  179. mutex_lock(&media_devnode_lock);
  180. minor = find_next_zero_bit(media_devnode_nums, MEDIA_NUM_DEVICES, 0);
  181. if (minor == MEDIA_NUM_DEVICES) {
  182. mutex_unlock(&media_devnode_lock);
  183. pr_err("could not get a free minor\n");
  184. kfree(devnode);
  185. return -ENFILE;
  186. }
  187. set_bit(minor, media_devnode_nums);
  188. mutex_unlock(&media_devnode_lock);
  189. devnode->minor = minor;
  190. devnode->media_dev = mdev;
  191. /* Part 1: Initialize dev now to use dev.kobj for cdev.kobj.parent */
  192. devnode->dev.bus = &media_bus_type;
  193. devnode->dev.devt = MKDEV(MAJOR(media_dev_t), devnode->minor);
  194. devnode->dev.release = media_devnode_release;
  195. if (devnode->parent)
  196. devnode->dev.parent = devnode->parent;
  197. dev_set_name(&devnode->dev, "media%d", devnode->minor);
  198. device_initialize(&devnode->dev);
  199. /* Part 2: Initialize the character device */
  200. cdev_init(&devnode->cdev, &media_devnode_fops);
  201. devnode->cdev.owner = owner;
  202. kobject_set_name(&devnode->cdev.kobj, "media%d", devnode->minor);
  203. /* Part 3: Add the media and char device */
  204. ret = cdev_device_add(&devnode->cdev, &devnode->dev);
  205. if (ret < 0) {
  206. pr_err("%s: cdev_device_add failed\n", __func__);
  207. goto cdev_add_error;
  208. }
  209. /* Part 4: Activate this minor. The char device can now be used. */
  210. set_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
  211. return 0;
  212. cdev_add_error:
  213. mutex_lock(&media_devnode_lock);
  214. clear_bit(devnode->minor, media_devnode_nums);
  215. devnode->media_dev = NULL;
  216. mutex_unlock(&media_devnode_lock);
  217. put_device(&devnode->dev);
  218. return ret;
  219. }
  220. void media_devnode_unregister_prepare(struct media_devnode *devnode)
  221. {
  222. /* Check if devnode was ever registered at all */
  223. if (!media_devnode_is_registered(devnode))
  224. return;
  225. mutex_lock(&media_devnode_lock);
  226. clear_bit(MEDIA_FLAG_REGISTERED, &devnode->flags);
  227. mutex_unlock(&media_devnode_lock);
  228. }
  229. void media_devnode_unregister(struct media_devnode *devnode)
  230. {
  231. mutex_lock(&media_devnode_lock);
  232. /* Delete the cdev on this minor as well */
  233. cdev_device_del(&devnode->cdev, &devnode->dev);
  234. devnode->media_dev = NULL;
  235. mutex_unlock(&media_devnode_lock);
  236. put_device(&devnode->dev);
  237. }
  238. /*
  239. * Initialise media for linux
  240. */
  241. static int __init media_devnode_init(void)
  242. {
  243. int ret;
  244. pr_info("Linux media interface: v0.10\n");
  245. ret = alloc_chrdev_region(&media_dev_t, 0, MEDIA_NUM_DEVICES,
  246. MEDIA_NAME);
  247. if (ret < 0) {
  248. pr_warn("unable to allocate major\n");
  249. return ret;
  250. }
  251. ret = bus_register(&media_bus_type);
  252. if (ret < 0) {
  253. unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
  254. pr_warn("bus_register failed\n");
  255. return -EIO;
  256. }
  257. return 0;
  258. }
  259. static void __exit media_devnode_exit(void)
  260. {
  261. bus_unregister(&media_bus_type);
  262. unregister_chrdev_region(media_dev_t, MEDIA_NUM_DEVICES);
  263. }
  264. subsys_initcall(media_devnode_init);
  265. module_exit(media_devnode_exit)
  266. MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
  267. MODULE_DESCRIPTION("Device node registration for media drivers");
  268. MODULE_LICENSE("GPL");