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