projects/linux·blob master · refs

135 lines · 3.5 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * media-dev-allocator.c - Media Controller Device Allocator API
4 *
5 * Copyright (c) 2019 Shuah Khan <[email protected]>
6 *
7 * Credits: Suggested by Laurent Pinchart <[email protected]>
8 */
9
10/*
11 * This file adds a global refcounted Media Controller Device Instance API.
12 * A system wide global media device list is managed and each media device
13 * includes a kref count. The last put on the media device releases the media
14 * device instance.
15 *
16 */
17
18#include <linux/kref.h>
19#include <linux/module.h>
20#include <linux/slab.h>
21#include <linux/usb.h>
22
23#include <media/media-device.h>
24#include <media/media-dev-allocator.h>
25
26static LIST_HEAD(media_device_list);
27static DEFINE_MUTEX(media_device_lock);
28
29struct media_device_instance {
30 struct media_device mdev;
31 struct module *owner;
32 struct list_head list;
33 struct kref refcount;
34};
35
36static inline struct media_device_instance *
37to_media_device_instance(struct media_device *mdev)
38{
39 return container_of(mdev, struct media_device_instance, mdev);
40}
41
42static void media_device_instance_release(struct kref *kref)
43{
44 struct media_device_instance *mdi =
45 container_of(kref, struct media_device_instance, refcount);
46
47 dev_dbg(mdi->mdev.dev, "%s: releasing Media Device\n", __func__);
48
49 mutex_lock(&media_device_lock);
50
51 media_device_unregister(&mdi->mdev);
52 media_device_cleanup(&mdi->mdev);
53
54 list_del(&mdi->list);
55 mutex_unlock(&media_device_lock);
56
57 kfree(mdi);
58}
59
60/* Callers should hold media_device_lock when calling this function */
61static struct media_device *__media_device_get(struct device *dev,
62 const char *module_name,
63 struct module *owner)
64{
65 struct media_device_instance *mdi;
66
67 list_for_each_entry(mdi, &media_device_list, list) {
68 if (mdi->mdev.dev != dev)
69 continue;
70
71 kref_get(&mdi->refcount);
72
73 /* get module reference for the media_device owner */
74 if (owner != mdi->owner && !try_module_get(mdi->owner))
75 dev_err(dev,
76 "%s: module %s get owner reference error\n",
77 __func__, module_name);
78 else
79 dev_dbg(dev, "%s: module %s got owner reference\n",
80 __func__, module_name);
81 return &mdi->mdev;
82 }
83
84 mdi = kzalloc_obj(*mdi);
85 if (!mdi)
86 return NULL;
87
88 mdi->owner = owner;
89 kref_init(&mdi->refcount);
90 list_add_tail(&mdi->list, &media_device_list);
91
92 dev_dbg(dev, "%s: Allocated media device for owner %s\n",
93 __func__, module_name);
94 return &mdi->mdev;
95}
96
97struct media_device *media_device_usb_allocate(struct usb_device *udev,
98 const char *module_name,
99 struct module *owner)
100{
101 struct media_device *mdev;
102
103 mutex_lock(&media_device_lock);
104 mdev = __media_device_get(&udev->dev, module_name, owner);
105 if (!mdev) {
106 mutex_unlock(&media_device_lock);
107 return ERR_PTR(-ENOMEM);
108 }
109
110 /* check if media device is already initialized */
111 if (!mdev->dev)
112 __media_device_usb_init(mdev, udev, udev->product,
113 module_name);
114 mutex_unlock(&media_device_lock);
115 return mdev;
116}
117EXPORT_SYMBOL_GPL(media_device_usb_allocate);
118
119void media_device_delete(struct media_device *mdev, const char *module_name,
120 struct module *owner)
121{
122 struct media_device_instance *mdi = to_media_device_instance(mdev);
123
124 mutex_lock(&media_device_lock);
125 /* put module reference for the media_device owner */
126 if (mdi->owner != owner) {
127 module_put(mdi->owner);
128 dev_dbg(mdi->mdev.dev,
129 "%s: module %s put owner module reference\n",
130 __func__, module_name);
131 }
132 mutex_unlock(&media_device_lock);
133 kref_put(&mdi->refcount, media_device_instance_release);
134}
135EXPORT_SYMBOL_GPL(media_device_delete);