Root/
1 | /* |
2 | * Virtual master and slave controls |
3 | * |
4 | * Copyright (c) 2008 by Takashi Iwai <tiwai@suse.de> |
5 | * |
6 | * This program is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU General Public License as |
8 | * published by the Free Software Foundation, version 2. |
9 | * |
10 | */ |
11 | |
12 | #include <linux/slab.h> |
13 | #include <sound/core.h> |
14 | #include <sound/control.h> |
15 | #include <sound/tlv.h> |
16 | |
17 | /* |
18 | * a subset of information returned via ctl info callback |
19 | */ |
20 | struct link_ctl_info { |
21 | snd_ctl_elem_type_t type; /* value type */ |
22 | int count; /* item count */ |
23 | int min_val, max_val; /* min, max values */ |
24 | }; |
25 | |
26 | /* |
27 | * link master - this contains a list of slave controls that are |
28 | * identical types, i.e. info returns the same value type and value |
29 | * ranges, but may have different number of counts. |
30 | * |
31 | * The master control is so far only mono volume/switch for simplicity. |
32 | * The same value will be applied to all slaves. |
33 | */ |
34 | struct link_master { |
35 | struct list_head slaves; |
36 | struct link_ctl_info info; |
37 | int val; /* the master value */ |
38 | unsigned int tlv[4]; |
39 | }; |
40 | |
41 | /* |
42 | * link slave - this contains a slave control element |
43 | * |
44 | * It fakes the control callbacsk with additional attenuation by the |
45 | * master control. A slave may have either one or two channels. |
46 | */ |
47 | |
48 | struct link_slave { |
49 | struct list_head list; |
50 | struct link_master *master; |
51 | struct link_ctl_info info; |
52 | int vals[2]; /* current values */ |
53 | unsigned int flags; |
54 | struct snd_kcontrol slave; /* the copy of original control entry */ |
55 | }; |
56 | |
57 | static int slave_update(struct link_slave *slave) |
58 | { |
59 | struct snd_ctl_elem_value *uctl; |
60 | int err, ch; |
61 | |
62 | uctl = kmalloc(sizeof(*uctl), GFP_KERNEL); |
63 | if (!uctl) |
64 | return -ENOMEM; |
65 | uctl->id = slave->slave.id; |
66 | err = slave->slave.get(&slave->slave, uctl); |
67 | for (ch = 0; ch < slave->info.count; ch++) |
68 | slave->vals[ch] = uctl->value.integer.value[ch]; |
69 | kfree(uctl); |
70 | return 0; |
71 | } |
72 | |
73 | /* get the slave ctl info and save the initial values */ |
74 | static int slave_init(struct link_slave *slave) |
75 | { |
76 | struct snd_ctl_elem_info *uinfo; |
77 | int err; |
78 | |
79 | if (slave->info.count) { |
80 | /* already initialized */ |
81 | if (slave->flags & SND_CTL_SLAVE_NEED_UPDATE) |
82 | return slave_update(slave); |
83 | return 0; |
84 | } |
85 | |
86 | uinfo = kmalloc(sizeof(*uinfo), GFP_KERNEL); |
87 | if (!uinfo) |
88 | return -ENOMEM; |
89 | uinfo->id = slave->slave.id; |
90 | err = slave->slave.info(&slave->slave, uinfo); |
91 | if (err < 0) { |
92 | kfree(uinfo); |
93 | return err; |
94 | } |
95 | slave->info.type = uinfo->type; |
96 | slave->info.count = uinfo->count; |
97 | if (slave->info.count > 2 || |
98 | (slave->info.type != SNDRV_CTL_ELEM_TYPE_INTEGER && |
99 | slave->info.type != SNDRV_CTL_ELEM_TYPE_BOOLEAN)) { |
100 | snd_printk(KERN_ERR "invalid slave element\n"); |
101 | kfree(uinfo); |
102 | return -EINVAL; |
103 | } |
104 | slave->info.min_val = uinfo->value.integer.min; |
105 | slave->info.max_val = uinfo->value.integer.max; |
106 | kfree(uinfo); |
107 | |
108 | return slave_update(slave); |
109 | } |
110 | |
111 | /* initialize master volume */ |
112 | static int master_init(struct link_master *master) |
113 | { |
114 | struct link_slave *slave; |
115 | |
116 | if (master->info.count) |
117 | return 0; /* already initialized */ |
118 | |
119 | list_for_each_entry(slave, &master->slaves, list) { |
120 | int err = slave_init(slave); |
121 | if (err < 0) |
122 | return err; |
123 | master->info = slave->info; |
124 | master->info.count = 1; /* always mono */ |
125 | /* set full volume as default (= no attenuation) */ |
126 | master->val = master->info.max_val; |
127 | return 0; |
128 | } |
129 | return -ENOENT; |
130 | } |
131 | |
132 | static int slave_get_val(struct link_slave *slave, |
133 | struct snd_ctl_elem_value *ucontrol) |
134 | { |
135 | int err, ch; |
136 | |
137 | err = slave_init(slave); |
138 | if (err < 0) |
139 | return err; |
140 | for (ch = 0; ch < slave->info.count; ch++) |
141 | ucontrol->value.integer.value[ch] = slave->vals[ch]; |
142 | return 0; |
143 | } |
144 | |
145 | static int slave_put_val(struct link_slave *slave, |
146 | struct snd_ctl_elem_value *ucontrol) |
147 | { |
148 | int err, ch, vol; |
149 | |
150 | err = master_init(slave->master); |
151 | if (err < 0) |
152 | return err; |
153 | |
154 | switch (slave->info.type) { |
155 | case SNDRV_CTL_ELEM_TYPE_BOOLEAN: |
156 | for (ch = 0; ch < slave->info.count; ch++) |
157 | ucontrol->value.integer.value[ch] &= |
158 | !!slave->master->val; |
159 | break; |
160 | case SNDRV_CTL_ELEM_TYPE_INTEGER: |
161 | for (ch = 0; ch < slave->info.count; ch++) { |
162 | /* max master volume is supposed to be 0 dB */ |
163 | vol = ucontrol->value.integer.value[ch]; |
164 | vol += slave->master->val - slave->master->info.max_val; |
165 | if (vol < slave->info.min_val) |
166 | vol = slave->info.min_val; |
167 | else if (vol > slave->info.max_val) |
168 | vol = slave->info.max_val; |
169 | ucontrol->value.integer.value[ch] = vol; |
170 | } |
171 | break; |
172 | } |
173 | return slave->slave.put(&slave->slave, ucontrol); |
174 | } |
175 | |
176 | /* |
177 | * ctl callbacks for slaves |
178 | */ |
179 | static int slave_info(struct snd_kcontrol *kcontrol, |
180 | struct snd_ctl_elem_info *uinfo) |
181 | { |
182 | struct link_slave *slave = snd_kcontrol_chip(kcontrol); |
183 | return slave->slave.info(&slave->slave, uinfo); |
184 | } |
185 | |
186 | static int slave_get(struct snd_kcontrol *kcontrol, |
187 | struct snd_ctl_elem_value *ucontrol) |
188 | { |
189 | struct link_slave *slave = snd_kcontrol_chip(kcontrol); |
190 | return slave_get_val(slave, ucontrol); |
191 | } |
192 | |
193 | static int slave_put(struct snd_kcontrol *kcontrol, |
194 | struct snd_ctl_elem_value *ucontrol) |
195 | { |
196 | struct link_slave *slave = snd_kcontrol_chip(kcontrol); |
197 | int err, ch, changed = 0; |
198 | |
199 | err = slave_init(slave); |
200 | if (err < 0) |
201 | return err; |
202 | for (ch = 0; ch < slave->info.count; ch++) { |
203 | if (slave->vals[ch] != ucontrol->value.integer.value[ch]) { |
204 | changed = 1; |
205 | slave->vals[ch] = ucontrol->value.integer.value[ch]; |
206 | } |
207 | } |
208 | if (!changed) |
209 | return 0; |
210 | return slave_put_val(slave, ucontrol); |
211 | } |
212 | |
213 | static int slave_tlv_cmd(struct snd_kcontrol *kcontrol, |
214 | int op_flag, unsigned int size, |
215 | unsigned int __user *tlv) |
216 | { |
217 | struct link_slave *slave = snd_kcontrol_chip(kcontrol); |
218 | /* FIXME: this assumes that the max volume is 0 dB */ |
219 | return slave->slave.tlv.c(&slave->slave, op_flag, size, tlv); |
220 | } |
221 | |
222 | static void slave_free(struct snd_kcontrol *kcontrol) |
223 | { |
224 | struct link_slave *slave = snd_kcontrol_chip(kcontrol); |
225 | if (slave->slave.private_free) |
226 | slave->slave.private_free(&slave->slave); |
227 | if (slave->master) |
228 | list_del(&slave->list); |
229 | kfree(slave); |
230 | } |
231 | |
232 | /* |
233 | * Add a slave control to the group with the given master control |
234 | * |
235 | * All slaves must be the same type (returning the same information |
236 | * via info callback). The function doesn't check it, so it's your |
237 | * responsibility. |
238 | * |
239 | * Also, some additional limitations: |
240 | * - at most two channels |
241 | * - logarithmic volume control (dB level), no linear volume |
242 | * - master can only attenuate the volume, no gain |
243 | */ |
244 | int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave, |
245 | unsigned int flags) |
246 | { |
247 | struct link_master *master_link = snd_kcontrol_chip(master); |
248 | struct link_slave *srec; |
249 | |
250 | srec = kzalloc(sizeof(*srec) + |
251 | slave->count * sizeof(*slave->vd), GFP_KERNEL); |
252 | if (!srec) |
253 | return -ENOMEM; |
254 | srec->slave = *slave; |
255 | memcpy(srec->slave.vd, slave->vd, slave->count * sizeof(*slave->vd)); |
256 | srec->master = master_link; |
257 | srec->flags = flags; |
258 | |
259 | /* override callbacks */ |
260 | slave->info = slave_info; |
261 | slave->get = slave_get; |
262 | slave->put = slave_put; |
263 | if (slave->vd[0].access & SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) |
264 | slave->tlv.c = slave_tlv_cmd; |
265 | slave->private_data = srec; |
266 | slave->private_free = slave_free; |
267 | |
268 | list_add_tail(&srec->list, &master_link->slaves); |
269 | return 0; |
270 | } |
271 | EXPORT_SYMBOL(_snd_ctl_add_slave); |
272 | |
273 | /* |
274 | * ctl callbacks for master controls |
275 | */ |
276 | static int master_info(struct snd_kcontrol *kcontrol, |
277 | struct snd_ctl_elem_info *uinfo) |
278 | { |
279 | struct link_master *master = snd_kcontrol_chip(kcontrol); |
280 | int ret; |
281 | |
282 | ret = master_init(master); |
283 | if (ret < 0) |
284 | return ret; |
285 | uinfo->type = master->info.type; |
286 | uinfo->count = master->info.count; |
287 | uinfo->value.integer.min = master->info.min_val; |
288 | uinfo->value.integer.max = master->info.max_val; |
289 | return 0; |
290 | } |
291 | |
292 | static int master_get(struct snd_kcontrol *kcontrol, |
293 | struct snd_ctl_elem_value *ucontrol) |
294 | { |
295 | struct link_master *master = snd_kcontrol_chip(kcontrol); |
296 | int err = master_init(master); |
297 | if (err < 0) |
298 | return err; |
299 | ucontrol->value.integer.value[0] = master->val; |
300 | return 0; |
301 | } |
302 | |
303 | static int master_put(struct snd_kcontrol *kcontrol, |
304 | struct snd_ctl_elem_value *ucontrol) |
305 | { |
306 | struct link_master *master = snd_kcontrol_chip(kcontrol); |
307 | struct link_slave *slave; |
308 | struct snd_ctl_elem_value *uval; |
309 | int err, old_val; |
310 | |
311 | err = master_init(master); |
312 | if (err < 0) |
313 | return err; |
314 | old_val = master->val; |
315 | if (ucontrol->value.integer.value[0] == old_val) |
316 | return 0; |
317 | |
318 | uval = kmalloc(sizeof(*uval), GFP_KERNEL); |
319 | if (!uval) |
320 | return -ENOMEM; |
321 | list_for_each_entry(slave, &master->slaves, list) { |
322 | master->val = old_val; |
323 | uval->id = slave->slave.id; |
324 | slave_get_val(slave, uval); |
325 | master->val = ucontrol->value.integer.value[0]; |
326 | slave_put_val(slave, uval); |
327 | } |
328 | kfree(uval); |
329 | return 1; |
330 | } |
331 | |
332 | static void master_free(struct snd_kcontrol *kcontrol) |
333 | { |
334 | struct link_master *master = snd_kcontrol_chip(kcontrol); |
335 | struct link_slave *slave; |
336 | |
337 | list_for_each_entry(slave, &master->slaves, list) |
338 | slave->master = NULL; |
339 | kfree(master); |
340 | } |
341 | |
342 | |
343 | /** |
344 | * snd_ctl_make_virtual_master - Create a virtual master control |
345 | * @name: name string of the control element to create |
346 | * @tlv: optional TLV int array for dB information |
347 | * |
348 | * Creates a virtual matster control with the given name string. |
349 | * Returns the created control element, or NULL for errors (ENOMEM). |
350 | * |
351 | * After creating a vmaster element, you can add the slave controls |
352 | * via snd_ctl_add_slave() or snd_ctl_add_slave_uncached(). |
353 | * |
354 | * The optional argument @tlv can be used to specify the TLV information |
355 | * for dB scale of the master control. It should be a single element |
356 | * with #SNDRV_CTL_TLVT_DB_SCALE, #SNDRV_CTL_TLV_DB_MINMAX or |
357 | * #SNDRV_CTL_TLVT_DB_MINMAX_MUTE type, and should be the max 0dB. |
358 | */ |
359 | struct snd_kcontrol *snd_ctl_make_virtual_master(char *name, |
360 | const unsigned int *tlv) |
361 | { |
362 | struct link_master *master; |
363 | struct snd_kcontrol *kctl; |
364 | struct snd_kcontrol_new knew; |
365 | |
366 | memset(&knew, 0, sizeof(knew)); |
367 | knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER; |
368 | knew.name = name; |
369 | knew.info = master_info; |
370 | |
371 | master = kzalloc(sizeof(*master), GFP_KERNEL); |
372 | if (!master) |
373 | return NULL; |
374 | INIT_LIST_HEAD(&master->slaves); |
375 | |
376 | kctl = snd_ctl_new1(&knew, master); |
377 | if (!kctl) { |
378 | kfree(master); |
379 | return NULL; |
380 | } |
381 | /* override some callbacks */ |
382 | kctl->info = master_info; |
383 | kctl->get = master_get; |
384 | kctl->put = master_put; |
385 | kctl->private_free = master_free; |
386 | |
387 | /* additional (constant) TLV read */ |
388 | if (tlv && |
389 | (tlv[0] == SNDRV_CTL_TLVT_DB_SCALE || |
390 | tlv[0] == SNDRV_CTL_TLVT_DB_MINMAX || |
391 | tlv[0] == SNDRV_CTL_TLVT_DB_MINMAX_MUTE)) { |
392 | kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ; |
393 | memcpy(master->tlv, tlv, sizeof(master->tlv)); |
394 | kctl->tlv.p = master->tlv; |
395 | } |
396 | |
397 | return kctl; |
398 | } |
399 | EXPORT_SYMBOL(snd_ctl_make_virtual_master); |
400 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9