Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
2 | /* |
3 | * Device management routines | |
c1017a4c | 4 | * Copyright (c) by Jaroslav Kysela <perex@perex.cz> |
1da177e4 LT |
5 | */ |
6 | ||
1da177e4 LT |
7 | #include <linux/slab.h> |
8 | #include <linux/time.h> | |
d81a6d71 | 9 | #include <linux/export.h> |
1da177e4 LT |
10 | #include <linux/errno.h> |
11 | #include <sound/core.h> | |
12 | ||
13 | /** | |
14 | * snd_device_new - create an ALSA device component | |
15 | * @card: the card instance | |
a3352f01 | 16 | * @type: the device type, SNDRV_DEV_XXX |
1da177e4 LT |
17 | * @device_data: the data pointer of this device |
18 | * @ops: the operator table | |
19 | * | |
20 | * Creates a new device component for the given data pointer. | |
21 | * The device will be assigned to the card and managed together | |
22 | * by the card. | |
23 | * | |
24 | * The data pointer plays a role as the identifier, too, so the | |
25 | * pointer address must be unique and unchanged. | |
26 | * | |
eb7c06e8 | 27 | * Return: Zero if successful, or a negative error code on failure. |
1da177e4 | 28 | */ |
9ce50543 | 29 | int snd_device_new(struct snd_card *card, enum snd_device_type type, |
8b575824 | 30 | void *device_data, const struct snd_device_ops *ops) |
1da177e4 | 31 | { |
512bbd6a | 32 | struct snd_device *dev; |
289ca025 | 33 | struct list_head *p; |
1da177e4 | 34 | |
7eaa943c TI |
35 | if (snd_BUG_ON(!card || !device_data || !ops)) |
36 | return -ENXIO; | |
ca2c0966 | 37 | dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
ec0e9937 | 38 | if (!dev) |
1da177e4 | 39 | return -ENOMEM; |
289ca025 | 40 | INIT_LIST_HEAD(&dev->list); |
1da177e4 LT |
41 | dev->card = card; |
42 | dev->type = type; | |
43 | dev->state = SNDRV_DEV_BUILD; | |
44 | dev->device_data = device_data; | |
45 | dev->ops = ops; | |
289ca025 TI |
46 | |
47 | /* insert the entry in an incrementally sorted list */ | |
48 | list_for_each_prev(p, &card->devices) { | |
49 | struct snd_device *pdev = list_entry(p, struct snd_device, list); | |
50 | if ((unsigned int)pdev->type <= (unsigned int)type) | |
51 | break; | |
52 | } | |
53 | ||
54 | list_add(&dev->list, p); | |
1da177e4 LT |
55 | return 0; |
56 | } | |
c0d3fb39 TI |
57 | EXPORT_SYMBOL(snd_device_new); |
58 | ||
e086e303 | 59 | static void __snd_device_disconnect(struct snd_device *dev) |
72620d60 TI |
60 | { |
61 | if (dev->state == SNDRV_DEV_REGISTERED) { | |
62 | if (dev->ops->dev_disconnect && | |
63 | dev->ops->dev_disconnect(dev)) | |
64 | dev_err(dev->card->dev, "device disconnect failure\n"); | |
65 | dev->state = SNDRV_DEV_DISCONNECTED; | |
66 | } | |
72620d60 TI |
67 | } |
68 | ||
69 | static void __snd_device_free(struct snd_device *dev) | |
70 | { | |
71 | /* unlink */ | |
72 | list_del(&dev->list); | |
73 | ||
74 | __snd_device_disconnect(dev); | |
75 | if (dev->ops->dev_free) { | |
76 | if (dev->ops->dev_free(dev)) | |
77 | dev_err(dev->card->dev, "device free failure\n"); | |
78 | } | |
79 | kfree(dev); | |
80 | } | |
81 | ||
289ca025 TI |
82 | static struct snd_device *look_for_dev(struct snd_card *card, void *device_data) |
83 | { | |
84 | struct snd_device *dev; | |
85 | ||
86 | list_for_each_entry(dev, &card->devices, list) | |
87 | if (dev->device_data == device_data) | |
88 | return dev; | |
89 | ||
90 | return NULL; | |
91 | } | |
92 | ||
e086e303 TI |
93 | /** |
94 | * snd_device_disconnect - disconnect the device | |
95 | * @card: the card instance | |
96 | * @device_data: the data pointer to disconnect | |
97 | * | |
98 | * Turns the device into the disconnection state, invoking | |
99 | * dev_disconnect callback, if the device was already registered. | |
100 | * | |
101 | * Usually called from snd_card_disconnect(). | |
102 | * | |
103 | * Return: Zero if successful, or a negative error code on failure or if the | |
104 | * device not found. | |
105 | */ | |
106 | void snd_device_disconnect(struct snd_card *card, void *device_data) | |
107 | { | |
108 | struct snd_device *dev; | |
109 | ||
110 | if (snd_BUG_ON(!card || !device_data)) | |
111 | return; | |
112 | dev = look_for_dev(card, device_data); | |
113 | if (dev) | |
114 | __snd_device_disconnect(dev); | |
115 | else | |
c8445589 | 116 | dev_dbg(card->dev, "device disconnect %p (from %pS), not found\n", |
e086e303 TI |
117 | device_data, __builtin_return_address(0)); |
118 | } | |
119 | EXPORT_SYMBOL_GPL(snd_device_disconnect); | |
120 | ||
1da177e4 LT |
121 | /** |
122 | * snd_device_free - release the device from the card | |
123 | * @card: the card instance | |
124 | * @device_data: the data pointer to release | |
125 | * | |
126 | * Removes the device from the list on the card and invokes the | |
c461482c | 127 | * callbacks, dev_disconnect and dev_free, corresponding to the state. |
1da177e4 | 128 | * Then release the device. |
1da177e4 | 129 | */ |
72620d60 | 130 | void snd_device_free(struct snd_card *card, void *device_data) |
1da177e4 | 131 | { |
512bbd6a | 132 | struct snd_device *dev; |
1da177e4 | 133 | |
7eaa943c | 134 | if (snd_BUG_ON(!card || !device_data)) |
72620d60 | 135 | return; |
289ca025 | 136 | dev = look_for_dev(card, device_data); |
72620d60 TI |
137 | if (dev) |
138 | __snd_device_free(dev); | |
139 | else | |
c8445589 | 140 | dev_dbg(card->dev, "device free %p (from %pS), not found\n", |
72620d60 | 141 | device_data, __builtin_return_address(0)); |
1da177e4 | 142 | } |
c0d3fb39 TI |
143 | EXPORT_SYMBOL(snd_device_free); |
144 | ||
72620d60 | 145 | static int __snd_device_register(struct snd_device *dev) |
1da177e4 | 146 | { |
72620d60 TI |
147 | if (dev->state == SNDRV_DEV_BUILD) { |
148 | if (dev->ops->dev_register) { | |
149 | int err = dev->ops->dev_register(dev); | |
150 | if (err < 0) | |
151 | return err; | |
1da177e4 | 152 | } |
72620d60 | 153 | dev->state = SNDRV_DEV_REGISTERED; |
1da177e4 | 154 | } |
72620d60 | 155 | return 0; |
1da177e4 LT |
156 | } |
157 | ||
158 | /** | |
159 | * snd_device_register - register the device | |
160 | * @card: the card instance | |
161 | * @device_data: the data pointer to register | |
162 | * | |
163 | * Registers the device which was already created via | |
164 | * snd_device_new(). Usually this is called from snd_card_register(), | |
165 | * but it can be called later if any new devices are created after | |
166 | * invocation of snd_card_register(). | |
167 | * | |
eb7c06e8 | 168 | * Return: Zero if successful, or a negative error code on failure or if the |
1da177e4 LT |
169 | * device not found. |
170 | */ | |
512bbd6a | 171 | int snd_device_register(struct snd_card *card, void *device_data) |
1da177e4 | 172 | { |
512bbd6a | 173 | struct snd_device *dev; |
a3352f01 | 174 | |
7eaa943c TI |
175 | if (snd_BUG_ON(!card || !device_data)) |
176 | return -ENXIO; | |
289ca025 | 177 | dev = look_for_dev(card, device_data); |
72620d60 TI |
178 | if (dev) |
179 | return __snd_device_register(dev); | |
1da177e4 LT |
180 | snd_BUG(); |
181 | return -ENXIO; | |
182 | } | |
c0d3fb39 TI |
183 | EXPORT_SYMBOL(snd_device_register); |
184 | ||
1da177e4 LT |
185 | /* |
186 | * register all the devices on the card. | |
187 | * called from init.c | |
188 | */ | |
512bbd6a | 189 | int snd_device_register_all(struct snd_card *card) |
1da177e4 | 190 | { |
512bbd6a | 191 | struct snd_device *dev; |
1da177e4 LT |
192 | int err; |
193 | ||
7eaa943c TI |
194 | if (snd_BUG_ON(!card)) |
195 | return -ENXIO; | |
9244b2c3 | 196 | list_for_each_entry(dev, &card->devices, list) { |
72620d60 TI |
197 | err = __snd_device_register(dev); |
198 | if (err < 0) | |
199 | return err; | |
1da177e4 LT |
200 | } |
201 | return 0; | |
202 | } | |
203 | ||
204 | /* | |
205 | * disconnect all the devices on the card. | |
206 | * called from init.c | |
207 | */ | |
e086e303 | 208 | void snd_device_disconnect_all(struct snd_card *card) |
1da177e4 | 209 | { |
512bbd6a | 210 | struct snd_device *dev; |
1da177e4 | 211 | |
7eaa943c | 212 | if (snd_BUG_ON(!card)) |
e086e303 TI |
213 | return; |
214 | list_for_each_entry_reverse(dev, &card->devices, list) | |
215 | __snd_device_disconnect(dev); | |
1da177e4 LT |
216 | } |
217 | ||
218 | /* | |
219 | * release all the devices on the card. | |
220 | * called from init.c | |
221 | */ | |
72620d60 | 222 | void snd_device_free_all(struct snd_card *card) |
1da177e4 | 223 | { |
289ca025 | 224 | struct snd_device *dev, *next; |
1da177e4 | 225 | |
7eaa943c | 226 | if (snd_BUG_ON(!card)) |
72620d60 | 227 | return; |
dc82e524 TI |
228 | list_for_each_entry_safe_reverse(dev, next, &card->devices, list) { |
229 | /* exception: free ctl and lowlevel stuff later */ | |
230 | if (dev->type == SNDRV_DEV_CONTROL || | |
231 | dev->type == SNDRV_DEV_LOWLEVEL) | |
232 | continue; | |
233 | __snd_device_free(dev); | |
234 | } | |
235 | ||
236 | /* free all */ | |
72620d60 TI |
237 | list_for_each_entry_safe_reverse(dev, next, &card->devices, list) |
238 | __snd_device_free(dev); | |
1da177e4 | 239 | } |
c208a533 TI |
240 | |
241 | /** | |
242 | * snd_device_get_state - Get the current state of the given device | |
243 | * @card: the card instance | |
244 | * @device_data: the data pointer to release | |
245 | * | |
246 | * Returns the current state of the given device object. For the valid | |
247 | * device, either @SNDRV_DEV_BUILD, @SNDRV_DEV_REGISTERED or | |
248 | * @SNDRV_DEV_DISCONNECTED is returned. | |
249 | * Or for a non-existing device, -1 is returned as an error. | |
250 | */ | |
251 | int snd_device_get_state(struct snd_card *card, void *device_data) | |
252 | { | |
253 | struct snd_device *dev; | |
254 | ||
255 | dev = look_for_dev(card, device_data); | |
256 | if (dev) | |
257 | return dev->state; | |
258 | return -1; | |
259 | } | |
260 | EXPORT_SYMBOL_GPL(snd_device_get_state); |