Commit | Line | Data |
---|---|---|
a10e763b | 1 | // SPDX-License-Identifier: GPL-2.0-only |
3b0a5f22 | 2 | /* |
9ab0cb30 | 3 | * Virtual master and follower controls |
3b0a5f22 TI |
4 | * |
5 | * Copyright (c) 2008 by Takashi Iwai <tiwai@suse.de> | |
3b0a5f22 TI |
6 | */ |
7 | ||
8 | #include <linux/slab.h> | |
d81a6d71 | 9 | #include <linux/export.h> |
3b0a5f22 TI |
10 | #include <sound/core.h> |
11 | #include <sound/control.h> | |
1c82ed1b | 12 | #include <sound/tlv.h> |
3b0a5f22 TI |
13 | |
14 | /* | |
15 | * a subset of information returned via ctl info callback | |
16 | */ | |
17 | struct link_ctl_info { | |
fea952e5 | 18 | snd_ctl_elem_type_t type; /* value type */ |
3b0a5f22 TI |
19 | int count; /* item count */ |
20 | int min_val, max_val; /* min, max values */ | |
21 | }; | |
22 | ||
23 | /* | |
9ab0cb30 | 24 | * link master - this contains a list of follower controls that are |
3b0a5f22 TI |
25 | * identical types, i.e. info returns the same value type and value |
26 | * ranges, but may have different number of counts. | |
27 | * | |
28 | * The master control is so far only mono volume/switch for simplicity. | |
9ab0cb30 | 29 | * The same value will be applied to all followers. |
3b0a5f22 TI |
30 | */ |
31 | struct link_master { | |
9ab0cb30 | 32 | struct list_head followers; |
3b0a5f22 TI |
33 | struct link_ctl_info info; |
34 | int val; /* the master value */ | |
1c82ed1b | 35 | unsigned int tlv[4]; |
2ad787e9 TI |
36 | void (*hook)(void *private_data, int); |
37 | void *hook_private_data; | |
3b0a5f22 TI |
38 | }; |
39 | ||
40 | /* | |
9ab0cb30 | 41 | * link follower - this contains a follower control element |
3b0a5f22 | 42 | * |
9ab0cb30 TI |
43 | * It fakes the control callbacks with additional attenuation by the |
44 | * master control. A follower may have either one or two channels. | |
3b0a5f22 TI |
45 | */ |
46 | ||
9ab0cb30 | 47 | struct link_follower { |
3b0a5f22 TI |
48 | struct list_head list; |
49 | struct link_master *master; | |
50 | struct link_ctl_info info; | |
51 | int vals[2]; /* current values */ | |
f5b1db63 | 52 | unsigned int flags; |
9e226b4b | 53 | struct snd_kcontrol *kctl; /* original kcontrol pointer */ |
9ab0cb30 | 54 | struct snd_kcontrol follower; /* the copy of original control entry */ |
3b0a5f22 TI |
55 | }; |
56 | ||
9ab0cb30 | 57 | static int follower_update(struct link_follower *follower) |
f5b1db63 TI |
58 | { |
59 | struct snd_ctl_elem_value *uctl; | |
60 | int err, ch; | |
61 | ||
7a33a02f | 62 | uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); |
f5b1db63 TI |
63 | if (!uctl) |
64 | return -ENOMEM; | |
9ab0cb30 TI |
65 | uctl->id = follower->follower.id; |
66 | err = follower->follower.get(&follower->follower, uctl); | |
2e2c177c TI |
67 | if (err < 0) |
68 | goto error; | |
9ab0cb30 TI |
69 | for (ch = 0; ch < follower->info.count; ch++) |
70 | follower->vals[ch] = uctl->value.integer.value[ch]; | |
2e2c177c | 71 | error: |
f5b1db63 | 72 | kfree(uctl); |
2e2c177c | 73 | return err < 0 ? err : 0; |
f5b1db63 TI |
74 | } |
75 | ||
9ab0cb30 TI |
76 | /* get the follower ctl info and save the initial values */ |
77 | static int follower_init(struct link_follower *follower) | |
3b0a5f22 TI |
78 | { |
79 | struct snd_ctl_elem_info *uinfo; | |
f5b1db63 | 80 | int err; |
3b0a5f22 | 81 | |
9ab0cb30 | 82 | if (follower->info.count) { |
f5b1db63 | 83 | /* already initialized */ |
9ab0cb30 TI |
84 | if (follower->flags & SND_CTL_FOLLOWER_NEED_UPDATE) |
85 | return follower_update(follower); | |
f5b1db63 TI |
86 | return 0; |
87 | } | |
3b0a5f22 TI |
88 | |
89 | uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL); | |
90 | if (!uinfo) | |
91 | return -ENOMEM; | |
9ab0cb30 TI |
92 | uinfo->id = follower->follower.id; |
93 | err = follower->follower.info(&follower->follower, uinfo); | |
3b0a5f22 TI |
94 | if (err < 0) { |
95 | kfree(uinfo); | |
96 | return err; | |
97 | } | |
9ab0cb30 TI |
98 | follower->info.type = uinfo->type; |
99 | follower->info.count = uinfo->count; | |
100 | if (follower->info.count > 2 || | |
101 | (follower->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER && | |
102 | follower->info.type != SNDRV_CTL_ELEM_TYPE_BOOLEAN)) { | |
103 | pr_err("ALSA: vmaster: invalid follower element\n"); | |
3b0a5f22 TI |
104 | kfree(uinfo); |
105 | return -EINVAL; | |
106 | } | |
9ab0cb30 TI |
107 | follower->info.min_val = uinfo->value.integer.min; |
108 | follower->info.max_val = uinfo->value.integer.max; | |
3b0a5f22 TI |
109 | kfree(uinfo); |
110 | ||
9ab0cb30 | 111 | return follower_update(follower); |
3b0a5f22 TI |
112 | } |
113 | ||
114 | /* initialize master volume */ | |
115 | static int master_init(struct link_master *master) | |
116 | { | |
9ab0cb30 | 117 | struct link_follower *follower; |
3b0a5f22 TI |
118 | |
119 | if (master->info.count) | |
120 | return 0; /* already initialized */ | |
121 | ||
9ab0cb30 TI |
122 | list_for_each_entry(follower, &master->followers, list) { |
123 | int err = follower_init(follower); | |
3b0a5f22 TI |
124 | if (err < 0) |
125 | return err; | |
9ab0cb30 | 126 | master->info = follower->info; |
3b0a5f22 TI |
127 | master->info.count = 1; /* always mono */ |
128 | /* set full volume as default (= no attenuation) */ | |
129 | master->val = master->info.max_val; | |
2ad787e9 TI |
130 | if (master->hook) |
131 | master->hook(master->hook_private_data, master->val); | |
132 | return 1; | |
3b0a5f22 TI |
133 | } |
134 | return -ENOENT; | |
135 | } | |
136 | ||
9ab0cb30 TI |
137 | static int follower_get_val(struct link_follower *follower, |
138 | struct snd_ctl_elem_value *ucontrol) | |
3b0a5f22 TI |
139 | { |
140 | int err, ch; | |
141 | ||
9ab0cb30 | 142 | err = follower_init(follower); |
3b0a5f22 TI |
143 | if (err < 0) |
144 | return err; | |
9ab0cb30 TI |
145 | for (ch = 0; ch < follower->info.count; ch++) |
146 | ucontrol->value.integer.value[ch] = follower->vals[ch]; | |
3b0a5f22 TI |
147 | return 0; |
148 | } | |
149 | ||
9ab0cb30 TI |
150 | static int follower_put_val(struct link_follower *follower, |
151 | struct snd_ctl_elem_value *ucontrol) | |
3b0a5f22 TI |
152 | { |
153 | int err, ch, vol; | |
154 | ||
9ab0cb30 | 155 | err = master_init(follower->master); |
3b0a5f22 TI |
156 | if (err < 0) |
157 | return err; | |
158 | ||
9ab0cb30 | 159 | switch (follower->info.type) { |
3b0a5f22 | 160 | case SNDRV_CTL_ELEM_TYPE_BOOLEAN: |
9ab0cb30 | 161 | for (ch = 0; ch < follower->info.count; ch++) |
3b0a5f22 | 162 | ucontrol->value.integer.value[ch] &= |
9ab0cb30 | 163 | !!follower->master->val; |
3b0a5f22 TI |
164 | break; |
165 | case SNDRV_CTL_ELEM_TYPE_INTEGER: | |
9ab0cb30 | 166 | for (ch = 0; ch < follower->info.count; ch++) { |
3b0a5f22 TI |
167 | /* max master volume is supposed to be 0 dB */ |
168 | vol = ucontrol->value.integer.value[ch]; | |
9ab0cb30 TI |
169 | vol += follower->master->val - follower->master->info.max_val; |
170 | if (vol < follower->info.min_val) | |
171 | vol = follower->info.min_val; | |
172 | else if (vol > follower->info.max_val) | |
173 | vol = follower->info.max_val; | |
3b0a5f22 TI |
174 | ucontrol->value.integer.value[ch] = vol; |
175 | } | |
176 | break; | |
177 | } | |
9ab0cb30 | 178 | return follower->follower.put(&follower->follower, ucontrol); |
3b0a5f22 TI |
179 | } |
180 | ||
181 | /* | |
9ab0cb30 | 182 | * ctl callbacks for followers |
3b0a5f22 | 183 | */ |
9ab0cb30 TI |
184 | static int follower_info(struct snd_kcontrol *kcontrol, |
185 | struct snd_ctl_elem_info *uinfo) | |
3b0a5f22 | 186 | { |
9ab0cb30 TI |
187 | struct link_follower *follower = snd_kcontrol_chip(kcontrol); |
188 | return follower->follower.info(&follower->follower, uinfo); | |
3b0a5f22 TI |
189 | } |
190 | ||
9ab0cb30 TI |
191 | static int follower_get(struct snd_kcontrol *kcontrol, |
192 | struct snd_ctl_elem_value *ucontrol) | |
3b0a5f22 | 193 | { |
9ab0cb30 TI |
194 | struct link_follower *follower = snd_kcontrol_chip(kcontrol); |
195 | return follower_get_val(follower, ucontrol); | |
3b0a5f22 TI |
196 | } |
197 | ||
9ab0cb30 TI |
198 | static int follower_put(struct snd_kcontrol *kcontrol, |
199 | struct snd_ctl_elem_value *ucontrol) | |
3b0a5f22 | 200 | { |
9ab0cb30 | 201 | struct link_follower *follower = snd_kcontrol_chip(kcontrol); |
3b0a5f22 TI |
202 | int err, ch, changed = 0; |
203 | ||
9ab0cb30 | 204 | err = follower_init(follower); |
3b0a5f22 TI |
205 | if (err < 0) |
206 | return err; | |
9ab0cb30 TI |
207 | for (ch = 0; ch < follower->info.count; ch++) { |
208 | if (follower->vals[ch] != ucontrol->value.integer.value[ch]) { | |
3b0a5f22 | 209 | changed = 1; |
9ab0cb30 | 210 | follower->vals[ch] = ucontrol->value.integer.value[ch]; |
3b0a5f22 TI |
211 | } |
212 | } | |
213 | if (!changed) | |
214 | return 0; | |
9ab0cb30 | 215 | err = follower_put_val(follower, ucontrol); |
2069d483 TI |
216 | if (err < 0) |
217 | return err; | |
218 | return 1; | |
3b0a5f22 TI |
219 | } |
220 | ||
9ab0cb30 TI |
221 | static int follower_tlv_cmd(struct snd_kcontrol *kcontrol, |
222 | int op_flag, unsigned int size, | |
223 | unsigned int __user *tlv) | |
3b0a5f22 | 224 | { |
9ab0cb30 | 225 | struct link_follower *follower = snd_kcontrol_chip(kcontrol); |
3b0a5f22 | 226 | /* FIXME: this assumes that the max volume is 0 dB */ |
9ab0cb30 | 227 | return follower->follower.tlv.c(&follower->follower, op_flag, size, tlv); |
3b0a5f22 TI |
228 | } |
229 | ||
9ab0cb30 | 230 | static void follower_free(struct snd_kcontrol *kcontrol) |
3b0a5f22 | 231 | { |
9ab0cb30 TI |
232 | struct link_follower *follower = snd_kcontrol_chip(kcontrol); |
233 | if (follower->follower.private_free) | |
234 | follower->follower.private_free(&follower->follower); | |
235 | if (follower->master) | |
236 | list_del(&follower->list); | |
237 | kfree(follower); | |
3b0a5f22 TI |
238 | } |
239 | ||
240 | /* | |
9ab0cb30 | 241 | * Add a follower control to the group with the given master control |
3b0a5f22 | 242 | * |
9ab0cb30 | 243 | * All followers must be the same type (returning the same information |
25985edc | 244 | * via info callback). The function doesn't check it, so it's your |
3b0a5f22 TI |
245 | * responsibility. |
246 | * | |
247 | * Also, some additional limitations: | |
248 | * - at most two channels | |
249 | * - logarithmic volume control (dB level), no linear volume | |
250 | * - master can only attenuate the volume, no gain | |
251 | */ | |
9ab0cb30 TI |
252 | int _snd_ctl_add_follower(struct snd_kcontrol *master, |
253 | struct snd_kcontrol *follower, | |
254 | unsigned int flags) | |
3b0a5f22 TI |
255 | { |
256 | struct link_master *master_link = snd_kcontrol_chip(master); | |
9ab0cb30 | 257 | struct link_follower *srec; |
3b0a5f22 | 258 | |
9ab0cb30 | 259 | srec = kzalloc(struct_size(srec, follower.vd, follower->count), |
acafe7e3 | 260 | GFP_KERNEL); |
3b0a5f22 TI |
261 | if (!srec) |
262 | return -ENOMEM; | |
9ab0cb30 TI |
263 | srec->kctl = follower; |
264 | srec->follower = *follower; | |
265 | memcpy(srec->follower.vd, follower->vd, follower->count * sizeof(*follower->vd)); | |
3b0a5f22 | 266 | srec->master = master_link; |
f5b1db63 | 267 | srec->flags = flags; |
3b0a5f22 TI |
268 | |
269 | /* override callbacks */ | |
9ab0cb30 TI |
270 | follower->info = follower_info; |
271 | follower->get = follower_get; | |
272 | follower->put = follower_put; | |
273 | if (follower->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) | |
274 | follower->tlv.c = follower_tlv_cmd; | |
275 | follower->private_data = srec; | |
276 | follower->private_free = follower_free; | |
277 | ||
278 | list_add_tail(&srec->list, &master_link->followers); | |
3b0a5f22 TI |
279 | return 0; |
280 | } | |
9ab0cb30 | 281 | EXPORT_SYMBOL(_snd_ctl_add_follower); |
e922b002 | 282 | |
3b0a5f22 TI |
283 | /* |
284 | * ctl callbacks for master controls | |
285 | */ | |
286 | static int master_info(struct snd_kcontrol *kcontrol, | |
287 | struct snd_ctl_elem_info *uinfo) | |
288 | { | |
289 | struct link_master *master = snd_kcontrol_chip(kcontrol); | |
290 | int ret; | |
291 | ||
292 | ret = master_init(master); | |
293 | if (ret < 0) | |
294 | return ret; | |
295 | uinfo->type = master->info.type; | |
296 | uinfo->count = master->info.count; | |
297 | uinfo->value.integer.min = master->info.min_val; | |
298 | uinfo->value.integer.max = master->info.max_val; | |
299 | return 0; | |
300 | } | |
301 | ||
302 | static int master_get(struct snd_kcontrol *kcontrol, | |
303 | struct snd_ctl_elem_value *ucontrol) | |
304 | { | |
305 | struct link_master *master = snd_kcontrol_chip(kcontrol); | |
306 | int err = master_init(master); | |
307 | if (err < 0) | |
308 | return err; | |
309 | ucontrol->value.integer.value[0] = master->val; | |
310 | return 0; | |
311 | } | |
312 | ||
9ab0cb30 | 313 | static int sync_followers(struct link_master *master, int old_val, int new_val) |
3b0a5f22 | 314 | { |
9ab0cb30 | 315 | struct link_follower *follower; |
3b0a5f22 | 316 | struct snd_ctl_elem_value *uval; |
3b0a5f22 TI |
317 | |
318 | uval = kmalloc(sizeof(*uval), GFP_KERNEL); | |
319 | if (!uval) | |
320 | return -ENOMEM; | |
9ab0cb30 | 321 | list_for_each_entry(follower, &master->followers, list) { |
3b0a5f22 | 322 | master->val = old_val; |
9ab0cb30 TI |
323 | uval->id = follower->follower.id; |
324 | follower_get_val(follower, uval); | |
1ca2f2ec | 325 | master->val = new_val; |
9ab0cb30 | 326 | follower_put_val(follower, uval); |
3b0a5f22 TI |
327 | } |
328 | kfree(uval); | |
1ca2f2ec TI |
329 | return 0; |
330 | } | |
331 | ||
332 | static int master_put(struct snd_kcontrol *kcontrol, | |
333 | struct snd_ctl_elem_value *ucontrol) | |
334 | { | |
335 | struct link_master *master = snd_kcontrol_chip(kcontrol); | |
336 | int err, new_val, old_val; | |
337 | bool first_init; | |
338 | ||
339 | err = master_init(master); | |
340 | if (err < 0) | |
341 | return err; | |
342 | first_init = err; | |
343 | old_val = master->val; | |
344 | new_val = ucontrol->value.integer.value[0]; | |
345 | if (new_val == old_val) | |
346 | return 0; | |
347 | ||
9ab0cb30 | 348 | err = sync_followers(master, old_val, new_val); |
1ca2f2ec TI |
349 | if (err < 0) |
350 | return err; | |
1ba65ae4 | 351 | if (master->hook && !first_init) |
2ad787e9 | 352 | master->hook(master->hook_private_data, master->val); |
3b0a5f22 TI |
353 | return 1; |
354 | } | |
355 | ||
356 | static void master_free(struct snd_kcontrol *kcontrol) | |
357 | { | |
358 | struct link_master *master = snd_kcontrol_chip(kcontrol); | |
9ab0cb30 | 359 | struct link_follower *follower, *n; |
9e226b4b | 360 | |
9ab0cb30 TI |
361 | /* free all follower links and retore the original follower kctls */ |
362 | list_for_each_entry_safe(follower, n, &master->followers, list) { | |
363 | struct snd_kcontrol *sctl = follower->kctl; | |
9e226b4b | 364 | struct list_head olist = sctl->list; |
9ab0cb30 TI |
365 | memcpy(sctl, &follower->follower, sizeof(*sctl)); |
366 | memcpy(sctl->vd, follower->follower.vd, | |
9e226b4b TI |
367 | sctl->count * sizeof(*sctl->vd)); |
368 | sctl->list = olist; /* keep the current linked-list */ | |
9ab0cb30 | 369 | kfree(follower); |
9e226b4b | 370 | } |
3b0a5f22 TI |
371 | kfree(master); |
372 | } | |
373 | ||
374 | ||
79c7cdd5 TI |
375 | /** |
376 | * snd_ctl_make_virtual_master - Create a virtual master control | |
377 | * @name: name string of the control element to create | |
378 | * @tlv: optional TLV int array for dB information | |
379 | * | |
eb7c06e8 | 380 | * Creates a virtual master control with the given name string. |
79c7cdd5 | 381 | * |
9ab0cb30 TI |
382 | * After creating a vmaster element, you can add the follower controls |
383 | * via snd_ctl_add_follower() or snd_ctl_add_follower_uncached(). | |
79c7cdd5 TI |
384 | * |
385 | * The optional argument @tlv can be used to specify the TLV information | |
386 | * for dB scale of the master control. It should be a single element | |
085f3065 TI |
387 | * with #SNDRV_CTL_TLVT_DB_SCALE, #SNDRV_CTL_TLV_DB_MINMAX or |
388 | * #SNDRV_CTL_TLVT_DB_MINMAX_MUTE type, and should be the max 0dB. | |
eb7c06e8 YB |
389 | * |
390 | * Return: The created control element, or %NULL for errors (ENOMEM). | |
3b0a5f22 TI |
391 | */ |
392 | struct snd_kcontrol *snd_ctl_make_virtual_master(char *name, | |
393 | const unsigned int *tlv) | |
394 | { | |
395 | struct link_master *master; | |
396 | struct snd_kcontrol *kctl; | |
397 | struct snd_kcontrol_new knew; | |
398 | ||
399 | memset(&knew, 0, sizeof(knew)); | |
400 | knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; | |
401 | knew.name = name; | |
402 | knew.info = master_info; | |
403 | ||
404 | master = kzalloc(sizeof(*master), GFP_KERNEL); | |
405 | if (!master) | |
406 | return NULL; | |
9ab0cb30 | 407 | INIT_LIST_HEAD(&master->followers); |
3b0a5f22 TI |
408 | |
409 | kctl = snd_ctl_new1(&knew, master); | |
410 | if (!kctl) { | |
411 | kfree(master); | |
412 | return NULL; | |
413 | } | |
414 | /* override some callbacks */ | |
415 | kctl->info = master_info; | |
416 | kctl->get = master_get; | |
417 | kctl->put = master_put; | |
418 | kctl->private_free = master_free; | |
419 | ||
420 | /* additional (constant) TLV read */ | |
841bdb7c TS |
421 | if (tlv) { |
422 | unsigned int type = tlv[SNDRV_CTL_TLVO_TYPE]; | |
423 | if (type == SNDRV_CTL_TLVT_DB_SCALE || | |
424 | type == SNDRV_CTL_TLVT_DB_MINMAX || | |
425 | type == SNDRV_CTL_TLVT_DB_MINMAX_MUTE) { | |
426 | kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; | |
427 | memcpy(master->tlv, tlv, sizeof(master->tlv)); | |
428 | kctl->tlv.p = master->tlv; | |
429 | } | |
3b0a5f22 | 430 | } |
1c82ed1b | 431 | |
3b0a5f22 TI |
432 | return kctl; |
433 | } | |
e922b002 | 434 | EXPORT_SYMBOL(snd_ctl_make_virtual_master); |
2ad787e9 TI |
435 | |
436 | /** | |
437 | * snd_ctl_add_vmaster_hook - Add a hook to a vmaster control | |
438 | * @kcontrol: vmaster kctl element | |
439 | * @hook: the hook function | |
f2ec52d4 | 440 | * @private_data: the private_data pointer to be saved |
2ad787e9 TI |
441 | * |
442 | * Adds the given hook to the vmaster control element so that it's called | |
443 | * at each time when the value is changed. | |
eb7c06e8 YB |
444 | * |
445 | * Return: Zero. | |
2ad787e9 TI |
446 | */ |
447 | int snd_ctl_add_vmaster_hook(struct snd_kcontrol *kcontrol, | |
448 | void (*hook)(void *private_data, int), | |
449 | void *private_data) | |
450 | { | |
451 | struct link_master *master = snd_kcontrol_chip(kcontrol); | |
452 | master->hook = hook; | |
453 | master->hook_private_data = private_data; | |
454 | return 0; | |
455 | } | |
456 | EXPORT_SYMBOL_GPL(snd_ctl_add_vmaster_hook); | |
457 | ||
458 | /** | |
9ab0cb30 | 459 | * snd_ctl_sync_vmaster - Sync the vmaster followers and hook |
2ad787e9 | 460 | * @kcontrol: vmaster kctl element |
1ca2f2ec | 461 | * @hook_only: sync only the hook |
2ad787e9 | 462 | * |
9ab0cb30 | 463 | * Forcibly call the put callback of each follower and call the hook function |
1ca2f2ec TI |
464 | * to synchronize with the current value of the given vmaster element. |
465 | * NOP when NULL is passed to @kcontrol. | |
2ad787e9 | 466 | */ |
1ca2f2ec | 467 | void snd_ctl_sync_vmaster(struct snd_kcontrol *kcontrol, bool hook_only) |
2ad787e9 TI |
468 | { |
469 | struct link_master *master; | |
1ca2f2ec TI |
470 | bool first_init = false; |
471 | ||
2ad787e9 TI |
472 | if (!kcontrol) |
473 | return; | |
474 | master = snd_kcontrol_chip(kcontrol); | |
1ca2f2ec TI |
475 | if (!hook_only) { |
476 | int err = master_init(master); | |
477 | if (err < 0) | |
478 | return; | |
479 | first_init = err; | |
9ab0cb30 | 480 | err = sync_followers(master, master->val, master->val); |
1ca2f2ec TI |
481 | if (err < 0) |
482 | return; | |
483 | } | |
484 | ||
485 | if (master->hook && !first_init) | |
2ad787e9 TI |
486 | master->hook(master->hook_private_data, master->val); |
487 | } | |
1ca2f2ec | 488 | EXPORT_SYMBOL_GPL(snd_ctl_sync_vmaster); |
a91d6612 TI |
489 | |
490 | /** | |
9ab0cb30 | 491 | * snd_ctl_apply_vmaster_followers - Apply function to each vmaster follower |
a91d6612 TI |
492 | * @kctl: vmaster kctl element |
493 | * @func: function to apply | |
494 | * @arg: optional function argument | |
495 | * | |
9ab0cb30 | 496 | * Apply the function @func to each follower kctl of the given vmaster kctl. |
281dee67 TI |
497 | * |
498 | * Return: 0 if successful, or a negative error code | |
a91d6612 | 499 | */ |
9ab0cb30 TI |
500 | int snd_ctl_apply_vmaster_followers(struct snd_kcontrol *kctl, |
501 | int (*func)(struct snd_kcontrol *vfollower, | |
502 | struct snd_kcontrol *follower, | |
503 | void *arg), | |
504 | void *arg) | |
a91d6612 TI |
505 | { |
506 | struct link_master *master; | |
9ab0cb30 | 507 | struct link_follower *follower; |
a91d6612 TI |
508 | int err; |
509 | ||
510 | master = snd_kcontrol_chip(kctl); | |
511 | err = master_init(master); | |
512 | if (err < 0) | |
513 | return err; | |
9ab0cb30 TI |
514 | list_for_each_entry(follower, &master->followers, list) { |
515 | err = func(follower->kctl, &follower->follower, arg); | |
a91d6612 TI |
516 | if (err < 0) |
517 | return err; | |
518 | } | |
519 | ||
520 | return 0; | |
521 | } | |
9ab0cb30 | 522 | EXPORT_SYMBOL_GPL(snd_ctl_apply_vmaster_followers); |