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 <shuah@kernel.org> |
6 | * |
7 | * Credits: Suggested by Laurent Pinchart <laurent.pinchart@ideasonboard.com> |
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 | |
26 | static LIST_HEAD(media_device_list); |
27 | static DEFINE_MUTEX(media_device_lock); |
28 | |
29 | struct media_device_instance { |
30 | struct media_device mdev; |
31 | struct module *owner; |
32 | struct list_head list; |
33 | struct kref refcount; |
34 | }; |
35 | |
36 | static inline struct media_device_instance * |
37 | to_media_device_instance(struct media_device *mdev) |
38 | { |
39 | return container_of(mdev, struct media_device_instance, mdev); |
40 | } |
41 | |
42 | static 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(mdev: &mdi->mdev); |
52 | media_device_cleanup(mdev: &mdi->mdev); |
53 | |
54 | list_del(entry: &mdi->list); |
55 | mutex_unlock(lock: &media_device_lock); |
56 | |
57 | kfree(objp: mdi); |
58 | } |
59 | |
60 | /* Callers should hold media_device_lock when calling this function */ |
61 | static 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(kref: &mdi->refcount); |
72 | |
73 | /* get module reference for the media_device owner */ |
74 | if (owner != mdi->owner && !try_module_get(module: 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(size: sizeof(*mdi), GFP_KERNEL); |
85 | if (!mdi) |
86 | return NULL; |
87 | |
88 | mdi->owner = owner; |
89 | kref_init(kref: &mdi->refcount); |
90 | list_add_tail(new: &mdi->list, head: &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 | |
97 | struct 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(dev: &udev->dev, module_name, owner); |
105 | if (!mdev) { |
106 | mutex_unlock(lock: &media_device_lock); |
107 | return ERR_PTR(error: -ENOMEM); |
108 | } |
109 | |
110 | /* check if media device is already initialized */ |
111 | if (!mdev->dev) |
112 | __media_device_usb_init(mdev, udev, board_name: udev->product, |
113 | driver_name: module_name); |
114 | mutex_unlock(lock: &media_device_lock); |
115 | return mdev; |
116 | } |
117 | EXPORT_SYMBOL_GPL(media_device_usb_allocate); |
118 | |
119 | void 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(module: 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(lock: &media_device_lock); |
133 | kref_put(kref: &mdi->refcount, release: media_device_instance_release); |
134 | } |
135 | EXPORT_SYMBOL_GPL(media_device_delete); |
136 | |