projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: usb-audio: add control index offset
[deliverable/linux.git] / sound / usb / mixer.c
CommitLineData
1da177e4
LT		 1/*
2 * (Tentative) USB Audio Driver for ALSA
3 *
4 * Mixer control part
5 *
6 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
7 *
8 * Many codes borrowed from audio.c by
9 * Alan Cox (alan@lxorguk.ukuu.org.uk)
10 * Thomas Sailer (sailer@ife.ee.ethz.ch)
11 *
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 *
27 */
28
157a57b6
DM		 29/*
30 * TODOs, for both the mixer and the streaming interfaces:
31 *
32 * - support for UAC2 effect units
33 * - support for graphical equalizers
34 * - RANGE and MEM set commands (UAC2)
35 * - RANGE and MEM interrupt dispatchers (UAC2)
36 * - audio channel clustering (UAC2)
37 * - audio sample rate converter units (UAC2)
38 * - proper handling of clock multipliers (UAC2)
39 * - dispatch clock change notifications (UAC2)
40 * - stop PCM streams which use a clock that became invalid
41 * - stop PCM streams which use a clock selector that has changed
42 * - parse available sample rates again when clock sources changed
43 */
44
1da177e4
LT		 45#include <linux/bitops.h>
46#include <linux/init.h>
47#include <linux/list.h>
48#include <linux/slab.h>
49#include <linux/string.h>
50#include <linux/usb.h>
28e1b773 51#include <linux/usb/audio.h>
23caaf19 52#include <linux/usb/audio-v2.h>
28e1b773 53
1da177e4
LT		 54#include <sound/core.h>
55#include <sound/control.h>
b259b10c 56#include <sound/hwdep.h>
aafad562 57#include <sound/info.h>
7bc5ba7e 58#include <sound/tlv.h>
1da177e4
LT		 59
60#include "usbaudio.h"
f0b5e634 61#include "mixer.h"
e5779998 62#include "helper.h"
7b1eda22 63#include "mixer_quirks.h"
88a8516a 64#include "power.h"
4d1a70da 65
ebfdeea3
JK		 66#define MAX_ID_ELEMS 256
67
1da177e4
LT		 68struct usb_audio_term {
69 int id;
70 int type;
71 int channels;
72 unsigned int chconfig;
73 int name;
74};
75
76struct usbmix_name_map;
77
86e07d34
TI		 78struct mixer_build {
79 struct snd_usb_audio *chip;
84957a8a 80 struct usb_mixer_interface *mixer;
1da177e4
LT		 81 unsigned char *buffer;
82 unsigned int buflen;
291186e0 83 DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
86e07d34 84 struct usb_audio_term oterm;
1da177e4 85 const struct usbmix_name_map *map;
8e062ec7 86 const struct usbmix_selector_map *selector_map;
1da177e4
LT		 87};
88
1cdfa9f3 89/*E-mu 0202/0404/0204 eXtension Unit(XU) control*/
7d2b451e
SK		 90enum {
91 USB_XU_CLOCK_RATE = 0xe301,
92 USB_XU_CLOCK_SOURCE = 0xe302,
93 USB_XU_DIGITAL_IO_STATUS = 0xe303,
94 USB_XU_DEVICE_OPTIONS = 0xe304,
95 USB_XU_DIRECT_MONITORING = 0xe305,
96 USB_XU_METERING = 0xe306
97};
98enum {
99 USB_XU_CLOCK_SOURCE_SELECTOR = 0x02, /* clock source*/
100 USB_XU_CLOCK_RATE_SELECTOR = 0x03, /* clock rate */
101 USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01, /* the spdif format */
102 USB_XU_SOFT_LIMIT_SELECTOR = 0x03 /* soft limiter */
103};
1da177e4
LT		 104
105/*
106 * manual mapping of mixer names
107 * if the mixer topology is too complicated and the parsed names are
108 * ambiguous, add the entries in usbmixer_maps.c.
109 */
f0b5e634 110#include "mixer_maps.c"
1da177e4 111
c3a3e040
JK		 112static const struct usbmix_name_map *
113find_map(struct mixer_build *state, int unitid, int control)
1da177e4 114{
c3a3e040 115 const struct usbmix_name_map *p = state->map;
1da177e4 116
c3a3e040
JK		 117 if (!p)
118 return NULL;
1da177e4
LT		 119
120 for (p = state->map; p->id; p++) {
c3a3e040
JK		 121 if (p->id == unitid &&
122 (!control || !p->control || control == p->control))
123 return p;
1da177e4 124 }
c3a3e040 125 return NULL;
1da177e4
LT		 126}
127
c3a3e040
JK		 128/* get the mapped name if the unit matches */
129static int
130check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
1da177e4 131{
c3a3e040
JK		 132 if (!p || !p->name)
133 return 0;
1da177e4 134
c3a3e040
JK		 135 buflen--;
136 return strlcpy(buf, p->name, buflen);
137}
138
139/* check whether the control should be ignored */
140static inline int
141check_ignored_ctl(const struct usbmix_name_map *p)
142{
143 if (!p || p->name || p->dB)
1da177e4 144 return 0;
c3a3e040
JK		 145 return 1;
146}
147
148/* dB mapping */
149static inline void check_mapped_dB(const struct usbmix_name_map *p,
150 struct usb_mixer_elem_info *cval)
151{
152 if (p && p->dB) {
153 cval->dBmin = p->dB->min;
154 cval->dBmax = p->dB->max;
38b65190 155 cval->initialized = 1;
1da177e4 156 }
1da177e4
LT		 157}
158
8e062ec7 159/* get the mapped selector source name */
86e07d34 160static int check_mapped_selector_name(struct mixer_build *state, int unitid,
8e062ec7
CL		 161 int index, char *buf, int buflen)
162{
163 const struct usbmix_selector_map *p;
164
165 if (! state->selector_map)
166 return 0;
167 for (p = state->selector_map; p->id; p++) {
168 if (p->id == unitid && index < p->count)
169 return strlcpy(buf, p->names[index], buflen);
170 }
171 return 0;
172}
173
1da177e4
LT		 174/*
175 * find an audio control unit with the given unit id
176 */
86e07d34 177static void *find_audio_control_unit(struct mixer_build *state, unsigned char unit)
1da177e4 178{
67e1daa0
DM		 179 /* we just parse the header */
180 struct uac_feature_unit_descriptor *hdr = NULL;
181
182 while ((hdr = snd_usb_find_desc(state->buffer, state->buflen, hdr,
183 USB_DT_CS_INTERFACE)) != NULL) {
184 if (hdr->bLength >= 4 &&
185 hdr->bDescriptorSubtype >= UAC_INPUT_TERMINAL &&
186 hdr->bDescriptorSubtype <= UAC2_SAMPLE_RATE_CONVERTER &&
187 hdr->bUnitID == unit)
188 return hdr;
1da177e4 189 }
67e1daa0 190
1da177e4
LT		 191 return NULL;
192}
193
1da177e4
LT		 194/*
195 * copy a string with the given id
196 */
86e07d34 197static int snd_usb_copy_string_desc(struct mixer_build *state, int index, char *buf, int maxlen)
1da177e4
LT		 198{
199 int len = usb_string(state->chip->dev, index, buf, maxlen - 1);
200 buf[len] = 0;
201 return len;
202}
203
204/*
205 * convert from the byte/word on usb descriptor to the zero-based integer
206 */
86e07d34 207static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
1da177e4
LT		 208{
209 switch (cval->val_type) {
210 case USB_MIXER_BOOLEAN:
211 return !!val;
212 case USB_MIXER_INV_BOOLEAN:
213 return !val;
214 case USB_MIXER_U8:
215 val &= 0xff;
216 break;
217 case USB_MIXER_S8:
218 val &= 0xff;
219 if (val >= 0x80)
220 val -= 0x100;
221 break;
222 case USB_MIXER_U16:
223 val &= 0xffff;
224 break;
225 case USB_MIXER_S16:
226 val &= 0xffff;
227 if (val >= 0x8000)
228 val -= 0x10000;
229 break;
230 }
231 return val;
232}
233
234/*
235 * convert from the zero-based int to the byte/word for usb descriptor
236 */
86e07d34 237static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
1da177e4
LT		 238{
239 switch (cval->val_type) {
240 case USB_MIXER_BOOLEAN:
241 return !!val;
242 case USB_MIXER_INV_BOOLEAN:
243 return !val;
244 case USB_MIXER_S8:
245 case USB_MIXER_U8:
246 return val & 0xff;
247 case USB_MIXER_S16:
248 case USB_MIXER_U16:
249 return val & 0xffff;
250 }
251 return 0; /* not reached */
252}
253
86e07d34 254static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
1da177e4
LT		 255{
256 if (! cval->res)
257 cval->res = 1;
258 if (val < cval->min)
259 return 0;
14790f1c
TI		 260 else if (val >= cval->max)
261 return (cval->max - cval->min + cval->res - 1) / cval->res;
1da177e4
LT		 262 else
263 return (val - cval->min) / cval->res;
264}
265
86e07d34 266static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
1da177e4
LT		 267{
268 if (val < 0)
269 return cval->min;
270 if (! cval->res)
271 cval->res = 1;
272 val *= cval->res;
273 val += cval->min;
274 if (val > cval->max)
275 return cval->max;
276 return val;
277}
278
279
280/*
281 * retrieve a mixer value
282 */
283
23caaf19 284static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
1da177e4 285{
3d8d4dcf 286 struct snd_usb_audio *chip = cval->mixer->chip;
1da177e4
LT		 287 unsigned char buf[2];
288 int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
289 int timeout = 10;
978520b7 290 int idx = 0, err;
1da177e4 291
88a8516a
ON		 292 err = snd_usb_autoresume(cval->mixer->chip);
293 if (err < 0)
294 return -EIO;
34f3c89f 295 down_read(&chip->shutdown_rwsem);
1da177e4 296 while (timeout-- > 0) {
978520b7
TI		 297 if (chip->shutdown)
298 break;
299 idx = snd_usb_ctrl_intf(chip) | (cval->id << 8);
3d8d4dcf 300 if (snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
1da177e4 301 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
978520b7 302 validx, idx, buf, val_len) >= val_len) {
1da177e4 303 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
978520b7
TI		 304 err = 0;
305 goto out;
1da177e4
LT		 306 }
307 }
84957a8a 308 snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
978520b7
TI		 309 request, validx, idx, cval->val_type);
310 err = -EINVAL;
311
312 out:
34f3c89f 313 up_read(&chip->shutdown_rwsem);
978520b7
TI		 314 snd_usb_autosuspend(cval->mixer->chip);
315 return err;
1da177e4
LT		 316}
317
23caaf19
DM		 318static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
319{
3d8d4dcf 320 struct snd_usb_audio *chip = cval->mixer->chip;
e8bdb6bb 321 unsigned char buf[2 + 3*sizeof(__u16)]; /* enough space for one range */
23caaf19 322 unsigned char *val;
978520b7 323 int idx = 0, ret, size;
23caaf19
DM		 324 __u8 bRequest;
325
e8bdb6bb
DM		 326 if (request == UAC_GET_CUR) {
327 bRequest = UAC2_CS_CUR;
328 size = sizeof(__u16);
329 } else {
330 bRequest = UAC2_CS_RANGE;
331 size = sizeof(buf);
332 }
333
334 memset(buf, 0, sizeof(buf));
23caaf19 335
88a8516a
ON		 336 ret = snd_usb_autoresume(chip) ? -EIO : 0;
337 if (ret)
338 goto error;
339
34f3c89f 340 down_read(&chip->shutdown_rwsem);
978520b7
TI		 341 if (chip->shutdown)
342 ret = -ENODEV;
343 else {
344 idx = snd_usb_ctrl_intf(chip) | (cval->id << 8);
345 ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest,
23caaf19 346 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
978520b7
TI		 347 validx, idx, buf, size);
348 }
34f3c89f 349 up_read(&chip->shutdown_rwsem);
88a8516a 350 snd_usb_autosuspend(chip);
23caaf19
DM		 351
352 if (ret < 0) {
88a8516a 353error:
09414207 354 snd_printk(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
978520b7 355 request, validx, idx, cval->val_type);
23caaf19
DM		 356 return ret;
357 }
358
e8bdb6bb
DM		 359 /* FIXME: how should we handle multiple triplets here? */
360
23caaf19
DM		 361 switch (request) {
362 case UAC_GET_CUR:
363 val = buf;
364 break;
365 case UAC_GET_MIN:
366 val = buf + sizeof(__u16);
367 break;
368 case UAC_GET_MAX:
369 val = buf + sizeof(__u16) * 2;
370 break;
371 case UAC_GET_RES:
372 val = buf + sizeof(__u16) * 3;
373 break;
374 default:
375 return -EINVAL;
376 }
377
378 *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(val, sizeof(__u16)));
379
380 return 0;
381}
382
383static int get_ctl_value(struct usb_mixer_elem_info *cval, int request, int validx, int *value_ret)
384{
9f814105
EZ		 385 validx += cval->idx_off;
386
23caaf19
DM		 387 return (cval->mixer->protocol == UAC_VERSION_1) ?
388 get_ctl_value_v1(cval, request, validx, value_ret) :
389 get_ctl_value_v2(cval, request, validx, value_ret);
390}
391
86e07d34 392static int get_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int *value)
1da177e4 393{
de48c7bc 394 return get_ctl_value(cval, UAC_GET_CUR, validx, value);
1da177e4
LT		 395}
396
397/* channel = 0: master, 1 = first channel */
641b4879
TI		 398static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
399 int channel, int *value)
1da177e4 400{
de48c7bc 401 return get_ctl_value(cval, UAC_GET_CUR, (cval->control << 8) | channel, value);
1da177e4
LT		 402}
403
641b4879
TI		 404static int get_cur_mix_value(struct usb_mixer_elem_info *cval,
405 int channel, int index, int *value)
406{
407 int err;
408
409 if (cval->cached & (1 << channel)) {
410 *value = cval->cache_val[index];
411 return 0;
412 }
413 err = get_cur_mix_raw(cval, channel, value);
414 if (err < 0) {
415 if (!cval->mixer->ignore_ctl_error)
23caaf19 416 snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n",
641b4879
TI		 417 cval->control, channel, err);
418 return err;
419 }
420 cval->cached |= 1 << channel;
421 cval->cache_val[index] = *value;
422 return 0;
423}
424
425
1da177e4
LT		 426/*
427 * set a mixer value
428 */
429
7b1eda22
DM		 430int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
431 int request, int validx, int value_set)
1da177e4 432{
3d8d4dcf 433 struct snd_usb_audio *chip = cval->mixer->chip;
1da177e4 434 unsigned char buf[2];
978520b7 435 int idx = 0, val_len, err, timeout = 10;
23caaf19 436
9f814105
EZ		 437 validx += cval->idx_off;
438
23caaf19
DM		 439 if (cval->mixer->protocol == UAC_VERSION_1) {
440 val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
441 } else { /* UAC_VERSION_2 */
442 /* audio class v2 controls are always 2 bytes in size */
443 val_len = sizeof(__u16);
444
445 /* FIXME */
446 if (request != UAC_SET_CUR) {
447 snd_printdd(KERN_WARNING "RANGE setting not yet supported\n");
448 return -EINVAL;
449 }
450
451 request = UAC2_CS_CUR;
452 }
1da177e4
LT		 453
454 value_set = convert_bytes_value(cval, value_set);
455 buf[0] = value_set & 0xff;
456 buf[1] = (value_set >> 8) & 0xff;
88a8516a
ON		 457 err = snd_usb_autoresume(chip);
458 if (err < 0)
459 return -EIO;
34f3c89f 460 down_read(&chip->shutdown_rwsem);
978520b7
TI		 461 while (timeout-- > 0) {
462 if (chip->shutdown)
463 break;
464 idx = snd_usb_ctrl_intf(chip) | (cval->id << 8);
3d8d4dcf
DM		 465 if (snd_usb_ctl_msg(chip->dev,
466 usb_sndctrlpipe(chip->dev, 0), request,
1da177e4 467 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
978520b7
TI		 468 validx, idx, buf, val_len) >= 0) {
469 err = 0;
470 goto out;
88a8516a 471 }
978520b7 472 }
84957a8a 473 snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
978520b7
TI		 474 request, validx, idx, cval->val_type, buf[0], buf[1]);
475 err = -EINVAL;
476
477 out:
34f3c89f 478 up_read(&chip->shutdown_rwsem);
978520b7
TI		 479 snd_usb_autosuspend(chip);
480 return err;
1da177e4
LT		 481}
482
86e07d34 483static int set_cur_ctl_value(struct usb_mixer_elem_info *cval, int validx, int value)
1da177e4 484{
7b1eda22 485 return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
1da177e4
LT		 486}
487
641b4879
TI		 488static int set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
489 int index, int value)
1da177e4 490{
641b4879 491 int err;
a6a33259
DM		 492 unsigned int read_only = (channel == 0) ?
493 cval->master_readonly :
494 cval->ch_readonly & (1 << (channel - 1));
495
496 if (read_only) {
497 snd_printdd(KERN_INFO "%s(): channel %d of control %d is read_only\n",
498 __func__, channel, cval->control);
499 return 0;
500 }
501
7b1eda22 502 err = snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, (cval->control << 8) | channel,
641b4879
TI		 503 value);
504 if (err < 0)
505 return err;
506 cval->cached |= 1 << channel;
507 cval->cache_val[index] = value;
508 return 0;
1da177e4
LT		 509}
510
7bc5ba7e
TI		 511/*
512 * TLV callback for mixer volume controls
513 */
285de9c0 514int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
7bc5ba7e
TI		 515 unsigned int size, unsigned int __user *_tlv)
516{
517 struct usb_mixer_elem_info *cval = kcontrol->private_data;
b8e1c73f 518 DECLARE_TLV_DB_MINMAX(scale, 0, 0);
7bc5ba7e
TI		 519
520 if (size < sizeof(scale))
521 return -ENOMEM;
c3a3e040
JK		 522 scale[2] = cval->dBmin;
523 scale[3] = cval->dBmax;
7bc5ba7e
TI		 524 if (copy_to_user(_tlv, scale, sizeof(scale)))
525 return -EFAULT;
526 return 0;
527}
1da177e4
LT		 528
529/*
530 * parser routines begin here...
531 */
532
86e07d34 533static int parse_audio_unit(struct mixer_build *state, int unitid);
1da177e4
LT		 534
535
536/*
537 * check if the input/output channel routing is enabled on the given bitmap.
538 * used for mixer unit parser
539 */
540static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_outs)
541{
542 int idx = ich * num_outs + och;
543 return bmap[idx >> 3] & (0x80 >> (idx & 7));
544}
545
546
547/*
548 * add an alsa control element
549 * search and increment the index until an empty slot is found.
550 *
551 * if failed, give up and free the control instance.
552 */
553
ef9d5970
DM		 554int snd_usb_mixer_add_control(struct usb_mixer_interface *mixer,
555 struct snd_kcontrol *kctl)
1da177e4 556{
86e07d34 557 struct usb_mixer_elem_info *cval = kctl->private_data;
1da177e4 558 int err;
84957a8a 559
ef9d5970 560 while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
1da177e4 561 kctl->id.index++;
ef9d5970 562 if ((err = snd_ctl_add(mixer->chip->card, kctl)) < 0) {
1da177e4 563 snd_printd(KERN_ERR "cannot add control (err = %d)\n", err);
6639b6c2 564 return err;
1da177e4 565 }
6639b6c2 566 cval->elem_id = &kctl->id;
ef9d5970
DM		 567 cval->next_id_elem = mixer->id_elems[cval->id];
568 mixer->id_elems[cval->id] = cval;
6639b6c2 569 return 0;
1da177e4
LT		 570}
571
572
573/*
574 * get a terminal name string
575 */
576
577static struct iterm_name_combo {
578 int type;
579 char *name;
580} iterm_names[] = {
581 { 0x0300, "Output" },
582 { 0x0301, "Speaker" },
583 { 0x0302, "Headphone" },
584 { 0x0303, "HMD Audio" },
585 { 0x0304, "Desktop Speaker" },
586 { 0x0305, "Room Speaker" },
587 { 0x0306, "Com Speaker" },
588 { 0x0307, "LFE" },
589 { 0x0600, "External In" },
590 { 0x0601, "Analog In" },
591 { 0x0602, "Digital In" },
592 { 0x0603, "Line" },
593 { 0x0604, "Legacy In" },
594 { 0x0605, "IEC958 In" },
595 { 0x0606, "1394 DA Stream" },
596 { 0x0607, "1394 DV Stream" },
597 { 0x0700, "Embedded" },
598 { 0x0701, "Noise Source" },
599 { 0x0702, "Equalization Noise" },
600 { 0x0703, "CD" },
601 { 0x0704, "DAT" },
602 { 0x0705, "DCC" },
603 { 0x0706, "MiniDisk" },
604 { 0x0707, "Analog Tape" },
605 { 0x0708, "Phonograph" },
606 { 0x0709, "VCR Audio" },
607 { 0x070a, "Video Disk Audio" },
608 { 0x070b, "DVD Audio" },
609 { 0x070c, "TV Tuner Audio" },
610 { 0x070d, "Satellite Rec Audio" },
611 { 0x070e, "Cable Tuner Audio" },
612 { 0x070f, "DSS Audio" },
613 { 0x0710, "Radio Receiver" },
614 { 0x0711, "Radio Transmitter" },
615 { 0x0712, "Multi-Track Recorder" },
616 { 0x0713, "Synthesizer" },
617 { 0 },
618};
619
86e07d34 620static int get_term_name(struct mixer_build *state, struct usb_audio_term *iterm,
1da177e4
LT		 621 unsigned char *name, int maxlen, int term_only)
622{
623 struct iterm_name_combo *names;
624
625 if (iterm->name)
626 return snd_usb_copy_string_desc(state, iterm->name, name, maxlen);
627
628 /* virtual type - not a real terminal */
629 if (iterm->type >> 16) {
630 if (term_only)
631 return 0;
632 switch (iterm->type >> 16) {
de48c7bc 633 case UAC_SELECTOR_UNIT:
1da177e4 634 strcpy(name, "Selector"); return 8;
69da9bcb 635 case UAC1_PROCESSING_UNIT:
1da177e4 636 strcpy(name, "Process Unit"); return 12;
69da9bcb 637 case UAC1_EXTENSION_UNIT:
1da177e4 638 strcpy(name, "Ext Unit"); return 8;
de48c7bc 639 case UAC_MIXER_UNIT:
1da177e4
LT		 640 strcpy(name, "Mixer"); return 5;
641 default:
642 return sprintf(name, "Unit %d", iterm->id);
643 }
644 }
645
646 switch (iterm->type & 0xff00) {
647 case 0x0100:
648 strcpy(name, "PCM"); return 3;
649 case 0x0200:
650 strcpy(name, "Mic"); return 3;
651 case 0x0400:
652 strcpy(name, "Headset"); return 7;
653 case 0x0500:
654 strcpy(name, "Phone"); return 5;
655 }
656
657 for (names = iterm_names; names->type; names++)
658 if (names->type == iterm->type) {
659 strcpy(name, names->name);
660 return strlen(names->name);
661 }
662 return 0;
663}
664
665
666/*
667 * parse the source unit recursively until it reaches to a terminal
668 * or a branched unit.
669 */
86e07d34 670static int check_input_term(struct mixer_build *state, int id, struct usb_audio_term *term)
1da177e4 671{
09414207 672 int err;
23caaf19 673 void *p1;
1da177e4
LT		 674
675 memset(term, 0, sizeof(*term));
676 while ((p1 = find_audio_control_unit(state, id)) != NULL) {
23caaf19 677 unsigned char *hdr = p1;
1da177e4 678 term->id = id;
23caaf19 679 switch (hdr[2]) {
de48c7bc 680 case UAC_INPUT_TERMINAL:
23caaf19
DM		 681 if (state->mixer->protocol == UAC_VERSION_1) {
682 struct uac_input_terminal_descriptor *d = p1;
683 term->type = le16_to_cpu(d->wTerminalType);
684 term->channels = d->bNrChannels;
685 term->chconfig = le16_to_cpu(d->wChannelConfig);
686 term->name = d->iTerminal;
687 } else { /* UAC_VERSION_2 */
688 struct uac2_input_terminal_descriptor *d = p1;
689 term->type = le16_to_cpu(d->wTerminalType);
690 term->channels = d->bNrChannels;
691 term->chconfig = le32_to_cpu(d->bmChannelConfig);
692 term->name = d->iTerminal;
09414207
DM		 693
694 /* call recursively to get the clock selectors */
695 err = check_input_term(state, d->bCSourceID, term);
696 if (err < 0)
697 return err;
23caaf19 698 }
1da177e4 699 return 0;
23caaf19
DM		 700 case UAC_FEATURE_UNIT: {
701 /* the header is the same for v1 and v2 */
702 struct uac_feature_unit_descriptor *d = p1;
5e688883 703 id = d->bSourceID;
1da177e4 704 break; /* continue to parse */
23caaf19
DM		 705 }
706 case UAC_MIXER_UNIT: {
707 struct uac_mixer_unit_descriptor *d = p1;
708 term->type = d->bDescriptorSubtype << 16; /* virtual type */
709 term->channels = uac_mixer_unit_bNrChannels(d);
710 term->chconfig = uac_mixer_unit_wChannelConfig(d, state->mixer->protocol);
711 term->name = uac_mixer_unit_iMixer(d);
1da177e4 712 return 0;
23caaf19 713 }
09414207
DM		 714 case UAC_SELECTOR_UNIT:
715 case UAC2_CLOCK_SELECTOR: {
23caaf19 716 struct uac_selector_unit_descriptor *d = p1;
1da177e4 717 /* call recursively to retrieve the channel info */
23caaf19 718 if (check_input_term(state, d->baSourceID[0], term) < 0)
1da177e4 719 return -ENODEV;
23caaf19 720 term->type = d->bDescriptorSubtype << 16; /* virtual type */
1da177e4 721 term->id = id;
23caaf19 722 term->name = uac_selector_unit_iSelector(d);
1da177e4 723 return 0;
23caaf19 724 }
69da9bcb
DM		 725 case UAC1_PROCESSING_UNIT:
726 case UAC1_EXTENSION_UNIT: {
23caaf19
DM		 727 struct uac_processing_unit_descriptor *d = p1;
728 if (d->bNrInPins) {
729 id = d->baSourceID[0];
1da177e4
LT		 730 break; /* continue to parse */
731 }
23caaf19
DM		 732 term->type = d->bDescriptorSubtype << 16; /* virtual type */
733 term->channels = uac_processing_unit_bNrChannels(d);
734 term->chconfig = uac_processing_unit_wChannelConfig(d, state->mixer->protocol);
735 term->name = uac_processing_unit_iProcessing(d, state->mixer->protocol);
1da177e4 736 return 0;
23caaf19 737 }
09414207
DM		 738 case UAC2_CLOCK_SOURCE: {
739 struct uac_clock_source_descriptor *d = p1;
740 term->type = d->bDescriptorSubtype << 16; /* virtual type */
741 term->id = id;
742 term->name = d->iClockSource;
743 return 0;
744 }
1da177e4
LT		 745 default:
746 return -ENODEV;
747 }
748 }
749 return -ENODEV;
750}
751
752
753/*
754 * Feature Unit
755 */
756
757/* feature unit control information */
758struct usb_feature_control_info {
759 const char *name;
760 unsigned int type; /* control type (mute, volume, etc.) */
761};
762
763static struct usb_feature_control_info audio_feature_info[] = {
2e0281d1
DM		 764 { "Mute", USB_MIXER_INV_BOOLEAN },
765 { "Volume", USB_MIXER_S16 },
1da177e4
LT		 766 { "Tone Control - Bass", USB_MIXER_S8 },
767 { "Tone Control - Mid", USB_MIXER_S8 },
768 { "Tone Control - Treble", USB_MIXER_S8 },
769 { "Graphic Equalizer", USB_MIXER_S8 }, /* FIXME: not implemeted yet */
2e0281d1
DM		 770 { "Auto Gain Control", USB_MIXER_BOOLEAN },
771 { "Delay Control", USB_MIXER_U16 },
772 { "Bass Boost", USB_MIXER_BOOLEAN },
773 { "Loudness", USB_MIXER_BOOLEAN },
774 /* UAC2 specific */
775 { "Input Gain Control", USB_MIXER_U16 },
776 { "Input Gain Pad Control", USB_MIXER_BOOLEAN },
777 { "Phase Inverter Control", USB_MIXER_BOOLEAN },
1da177e4
LT		 778};
779
780
781/* private_free callback */
86e07d34 782static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
1da177e4 783{
4d572776
JJ		 784 kfree(kctl->private_data);
785 kctl->private_data = NULL;
1da177e4
LT		 786}
787
788
789/*
790 * interface to ALSA control for feature/mixer units
791 */
792
dcaaf9f2
TI		 793/* volume control quirks */
794static void volume_control_quirks(struct usb_mixer_elem_info *cval,
795 struct snd_kcontrol *kctl)
796{
797 switch (cval->mixer->chip->usb_id) {
d34bf148
FH		 798 case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
799 case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
800 if (strcmp(kctl->id.name, "Effect Duration") == 0) {
801 snd_printk(KERN_INFO
802 "usb-audio: set quirk for FTU Effect Duration\n");
803 cval->min = 0x0000;
804 cval->max = 0x7f00;
805 cval->res = 0x0100;
806 break;
807 }
808 if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
809 strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
810 snd_printk(KERN_INFO
811 "usb-audio: set quirks for FTU Effect Feedback/Volume\n");
812 cval->min = 0x00;
813 cval->max = 0x7f;
814 break;
815 }
816 break;
817
dcaaf9f2
TI		 818 case USB_ID(0x0471, 0x0101):
819 case USB_ID(0x0471, 0x0104):
820 case USB_ID(0x0471, 0x0105):
821 case USB_ID(0x0672, 0x1041):
822 /* quirk for UDA1321/N101.
823 * note that detection between firmware 2.1.1.7 (N101)
824 * and later 2.1.1.21 is not very clear from datasheets.
825 * I hope that the min value is -15360 for newer firmware --jk
826 */
827 if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
828 cval->min == -15616) {
829 snd_printk(KERN_INFO
830 "set volume quirk for UDA1321/N101 chip\n");
831 cval->max = -256;
832 }
833 break;
834
835 case USB_ID(0x046d, 0x09a4):
836 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
837 snd_printk(KERN_INFO
838 "set volume quirk for QuickCam E3500\n");
839 cval->min = 6080;
840 cval->max = 8768;
841 cval->res = 192;
842 }
843 break;
844
845 case USB_ID(0x046d, 0x0808):
846 case USB_ID(0x046d, 0x0809):
55c0008b 847 case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
dcaaf9f2
TI		 848 case USB_ID(0x046d, 0x0991):
849 /* Most audio usb devices lie about volume resolution.
850 * Most Logitech webcams have res = 384.
851 * Proboly there is some logitech magic behind this number --fishor
852 */
853 if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
854 snd_printk(KERN_INFO
855 "set resolution quirk: cval->res = 384\n");
856 cval->res = 384;
857 }
858 break;
859
860 }
861}
862
1da177e4
LT		 863/*
864 * retrieve the minimum and maximum values for the specified control
865 */
dcaaf9f2
TI		 866static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
867 int default_min, struct snd_kcontrol *kctl)
1da177e4
LT		 868{
869 /* for failsafe */
870 cval->min = default_min;
871 cval->max = cval->min + 1;
872 cval->res = 1;
c3a3e040 873 cval->dBmin = cval->dBmax = 0;
1da177e4
LT		 874
875 if (cval->val_type == USB_MIXER_BOOLEAN ||
876 cval->val_type == USB_MIXER_INV_BOOLEAN) {
877 cval->initialized = 1;
878 } else {
879 int minchn = 0;
880 if (cval->cmask) {
881 int i;
882 for (i = 0; i < MAX_CHANNELS; i++)
883 if (cval->cmask & (1 << i)) {
884 minchn = i + 1;
885 break;
886 }
887 }
de48c7bc
DM		 888 if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
889 get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
84957a8a 890 snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
1a4e34e6 891 cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id);
1da177e4
LT		 892 return -EINVAL;
893 }
de48c7bc 894 if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
1da177e4
LT		 895 cval->res = 1;
896 } else {
897 int last_valid_res = cval->res;
898
899 while (cval->res > 1) {
7b1eda22
DM		 900 if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
901 (cval->control << 8) | minchn, cval->res / 2) < 0)
1da177e4
LT		 902 break;
903 cval->res /= 2;
904 }
de48c7bc 905 if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
1da177e4
LT		 906 cval->res = last_valid_res;
907 }
908 if (cval->res == 0)
909 cval->res = 1;
14790f1c
TI		 910
911 /* Additional checks for the proper resolution
912 *
913 * Some devices report smaller resolutions than actually
914 * reacting. They don't return errors but simply clip
915 * to the lower aligned value.
916 */
917 if (cval->min + cval->res < cval->max) {
918 int last_valid_res = cval->res;
919 int saved, test, check;
641b4879 920 get_cur_mix_raw(cval, minchn, &saved);
14790f1c
TI		 921 for (;;) {
922 test = saved;
923 if (test < cval->max)
924 test += cval->res;
925 else
926 test -= cval->res;
927 if (test < cval->min || test > cval->max ||
641b4879
TI		 928 set_cur_mix_value(cval, minchn, 0, test) ||
929 get_cur_mix_raw(cval, minchn, &check)) {
14790f1c
TI		 930 cval->res = last_valid_res;
931 break;
932 }
933 if (test == check)
934 break;
935 cval->res *= 2;
936 }
641b4879 937 set_cur_mix_value(cval, minchn, 0, saved);
14790f1c
TI		 938 }
939
1da177e4
LT		 940 cval->initialized = 1;
941 }
c3a3e040 942
dcaaf9f2
TI		 943 if (kctl)
944 volume_control_quirks(cval, kctl);
945
c3a3e040
JK		 946 /* USB descriptions contain the dB scale in 1/256 dB unit
947 * while ALSA TLV contains in 1/100 dB unit
948 */
949 cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
950 cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
951 if (cval->dBmin > cval->dBmax) {
952 /* something is wrong; assume it's either from/to 0dB */
953 if (cval->dBmin < 0)
954 cval->dBmax = 0;
955 else if (cval->dBmin > 0)
956 cval->dBmin = 0;
957 if (cval->dBmin > cval->dBmax) {
958 /* totally crap, return an error */
959 return -EINVAL;
960 }
961 }
962
1da177e4
LT		 963 return 0;
964}
965
dcaaf9f2 966#define get_min_max(cval, def) get_min_max_with_quirks(cval, def, NULL)
1da177e4
LT		 967
968/* get a feature/mixer unit info */
86e07d34 969static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1da177e4 970{
86e07d34 971 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 972
973 if (cval->val_type == USB_MIXER_BOOLEAN ||
974 cval->val_type == USB_MIXER_INV_BOOLEAN)
975 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
976 else
977 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
978 uinfo->count = cval->channels;
979 if (cval->val_type == USB_MIXER_BOOLEAN ||
980 cval->val_type == USB_MIXER_INV_BOOLEAN) {
981 uinfo->value.integer.min = 0;
982 uinfo->value.integer.max = 1;
983 } else {
9fcd0ab1 984 if (!cval->initialized) {
dcaaf9f2 985 get_min_max_with_quirks(cval, 0, kcontrol);
9fcd0ab1
TI		 986 if (cval->initialized && cval->dBmin >= cval->dBmax) {
987 kcontrol->vd[0].access &=
988 ~(SNDRV_CTL_ELEM_ACCESS_TLV_READ |
989 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK);
990 snd_ctl_notify(cval->mixer->chip->card,
991 SNDRV_CTL_EVENT_MASK_INFO,
992 &kcontrol->id);
993 }
994 }
1da177e4 995 uinfo->value.integer.min = 0;
14790f1c
TI		 996 uinfo->value.integer.max =
997 (cval->max - cval->min + cval->res - 1) / cval->res;
1da177e4
LT		 998 }
999 return 0;
1000}
1001
1002/* get the current value from feature/mixer unit */
86e07d34 1003static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1004{
86e07d34 1005 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1006 int c, cnt, val, err;
1007
641b4879 1008 ucontrol->value.integer.value[0] = cval->min;
1da177e4
LT		 1009 if (cval->cmask) {
1010 cnt = 0;
1011 for (c = 0; c < MAX_CHANNELS; c++) {
641b4879
TI		 1012 if (!(cval->cmask & (1 << c)))
1013 continue;
1014 err = get_cur_mix_value(cval, c + 1, cnt, &val);
1015 if (err < 0)
1016 return cval->mixer->ignore_ctl_error ? 0 : err;
1017 val = get_relative_value(cval, val);
1018 ucontrol->value.integer.value[cnt] = val;
1019 cnt++;
1da177e4 1020 }
641b4879 1021 return 0;
1da177e4
LT		 1022 } else {
1023 /* master channel */
641b4879
TI		 1024 err = get_cur_mix_value(cval, 0, 0, &val);
1025 if (err < 0)
1026 return cval->mixer->ignore_ctl_error ? 0 : err;
1da177e4
LT		 1027 val = get_relative_value(cval, val);
1028 ucontrol->value.integer.value[0] = val;
1029 }
1030 return 0;
1031}
1032
1033/* put the current value to feature/mixer unit */
86e07d34 1034static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1035{
86e07d34 1036 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1037 int c, cnt, val, oval, err;
1038 int changed = 0;
1039
1040 if (cval->cmask) {
1041 cnt = 0;
1042 for (c = 0; c < MAX_CHANNELS; c++) {
641b4879
TI		 1043 if (!(cval->cmask & (1 << c)))
1044 continue;
1045 err = get_cur_mix_value(cval, c + 1, cnt, &oval);
1046 if (err < 0)
1047 return cval->mixer->ignore_ctl_error ? 0 : err;
1048 val = ucontrol->value.integer.value[cnt];
1049 val = get_abs_value(cval, val);
1050 if (oval != val) {
1051 set_cur_mix_value(cval, c + 1, cnt, val);
1052 changed = 1;
1da177e4 1053 }
641b4879 1054 cnt++;
1da177e4
LT		 1055 }
1056 } else {
1057 /* master channel */
641b4879 1058 err = get_cur_mix_value(cval, 0, 0, &oval);
1da177e4 1059 if (err < 0)
641b4879 1060 return cval->mixer->ignore_ctl_error ? 0 : err;
1da177e4
LT		 1061 val = ucontrol->value.integer.value[0];
1062 val = get_abs_value(cval, val);
1063 if (val != oval) {
641b4879 1064 set_cur_mix_value(cval, 0, 0, val);
1da177e4
LT		 1065 changed = 1;
1066 }
1067 }
1068 return changed;
1069}
1070
86e07d34 1071static struct snd_kcontrol_new usb_feature_unit_ctl = {
1da177e4
LT		 1072 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1073 .name = "", /* will be filled later manually */
1074 .info = mixer_ctl_feature_info,
1075 .get = mixer_ctl_feature_get,
1076 .put = mixer_ctl_feature_put,
1077};
1078
23caaf19
DM		 1079/* the read-only variant */
1080static struct snd_kcontrol_new usb_feature_unit_ctl_ro = {
1081 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1082 .name = "", /* will be filled later manually */
1083 .info = mixer_ctl_feature_info,
1084 .get = mixer_ctl_feature_get,
1085 .put = NULL,
1086};
1087
9e38658f
DM		 1088/* This symbol is exported in order to allow the mixer quirks to
1089 * hook up to the standard feature unit control mechanism */
1090struct snd_kcontrol_new *snd_usb_feature_unit_ctl = &usb_feature_unit_ctl;
1da177e4
LT		 1091
1092/*
1093 * build a feature control
1094 */
1095
08d1e635
TI		 1096static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
1097{
1098 return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
1099}
1100
99fc8645 1101static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
1da177e4 1102 unsigned int ctl_mask, int control,
23caaf19 1103 struct usb_audio_term *iterm, int unitid,
a6a33259 1104 int readonly_mask)
1da177e4 1105{
99fc8645 1106 struct uac_feature_unit_descriptor *desc = raw_desc;
1da177e4
LT		 1107 unsigned int len = 0;
1108 int mapped_name = 0;
99fc8645 1109 int nameid = uac_feature_unit_iFeature(desc);
86e07d34
TI		 1110 struct snd_kcontrol *kctl;
1111 struct usb_mixer_elem_info *cval;
c3a3e040 1112 const struct usbmix_name_map *map;
80acefff 1113 unsigned int range;
1da177e4
LT		 1114
1115 control++; /* change from zero-based to 1-based value */
1116
65f25da4 1117 if (control == UAC_FU_GRAPHIC_EQUALIZER) {
1da177e4
LT		 1118 /* FIXME: not supported yet */
1119 return;
1120 }
1121
c3a3e040
JK		 1122 map = find_map(state, unitid, control);
1123 if (check_ignored_ctl(map))
1da177e4
LT		 1124 return;
1125
561b220a 1126 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1da177e4
LT		 1127 if (! cval) {
1128 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1129 return;
1130 }
84957a8a 1131 cval->mixer = state->mixer;
1da177e4
LT		 1132 cval->id = unitid;
1133 cval->control = control;
1134 cval->cmask = ctl_mask;
1135 cval->val_type = audio_feature_info[control-1].type;
a6a33259 1136 if (ctl_mask == 0) {
1da177e4 1137 cval->channels = 1; /* master channel */
a6a33259
DM		 1138 cval->master_readonly = readonly_mask;
1139 } else {
1da177e4
LT		 1140 int i, c = 0;
1141 for (i = 0; i < 16; i++)
1142 if (ctl_mask & (1 << i))
1143 c++;
1144 cval->channels = c;
a6a33259 1145 cval->ch_readonly = readonly_mask;
1da177e4
LT		 1146 }
1147
a6a33259
DM		 1148 /* if all channels in the mask are marked read-only, make the control
1149 * read-only. set_cur_mix_value() will check the mask again and won't
1150 * issue write commands to read-only channels. */
1151 if (cval->channels == readonly_mask)
23caaf19
DM		 1152 kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1153 else
1154 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1155
1da177e4
LT		 1156 if (! kctl) {
1157 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1158 kfree(cval);
1159 return;
1160 }
1161 kctl->private_free = usb_mixer_elem_free;
1162
c3a3e040 1163 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1da177e4
LT		 1164 mapped_name = len != 0;
1165 if (! len && nameid)
c3a3e040
JK		 1166 len = snd_usb_copy_string_desc(state, nameid,
1167 kctl->id.name, sizeof(kctl->id.name));
1da177e4
LT		 1168
1169 switch (control) {
65f25da4
DM		 1170 case UAC_FU_MUTE:
1171 case UAC_FU_VOLUME:
1da177e4
LT		 1172 /* determine the control name. the rule is:
1173 * - if a name id is given in descriptor, use it.
1174 * - if the connected input can be determined, then use the name
1175 * of terminal type.
1176 * - if the connected output can be determined, use it.
1177 * - otherwise, anonymous name.
1178 */
1179 if (! len) {
1180 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 1);
1181 if (! len)
1182 len = get_term_name(state, &state->oterm, kctl->id.name, sizeof(kctl->id.name), 1);
1183 if (! len)
1184 len = snprintf(kctl->id.name, sizeof(kctl->id.name),
1185 "Feature %d", unitid);
1186 }
1187 /* determine the stream direction:
1188 * if the connected output is USB stream, then it's likely a
1189 * capture stream. otherwise it should be playback (hopefully :)
1190 */
1191 if (! mapped_name && ! (state->oterm.type >> 16)) {
1192 if ((state->oterm.type & 0xff00) == 0x0100) {
08d1e635 1193 len = append_ctl_name(kctl, " Capture");
1da177e4 1194 } else {
08d1e635 1195 len = append_ctl_name(kctl, " Playback");
1da177e4
LT		 1196 }
1197 }
65f25da4 1198 append_ctl_name(kctl, control == UAC_FU_MUTE ?
08d1e635 1199 " Switch" : " Volume");
1da177e4 1200 break;
1da177e4
LT		 1201 default:
1202 if (! len)
1203 strlcpy(kctl->id.name, audio_feature_info[control-1].name,
1204 sizeof(kctl->id.name));
1205 break;
1206 }
1207
e182534d
TI		 1208 /* get min/max values */
1209 get_min_max_with_quirks(cval, 0, kctl);
1210
1211 if (control == UAC_FU_VOLUME) {
1212 check_mapped_dB(map, cval);
1213 if (cval->dBmin < cval->dBmax || !cval->initialized) {
1214 kctl->tlv.c = snd_usb_mixer_vol_tlv;
1215 kctl->vd[0].access |=
1216 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1217 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1218 }
1219 }
1220
80acefff
AF		 1221 range = (cval->max - cval->min) / cval->res;
1222 /* Are there devices with volume range more than 255? I use a bit more
1223 * to be sure. 384 is a resolution magic number found on Logitech
1224 * devices. It will definitively catch all buggy Logitech devices.
1225 */
1226 if (range > 384) {
1227 snd_printk(KERN_WARNING "usb_audio: Warning! Unlikely big "
1228 "volume range (=%u), cval->res is probably wrong.",
1229 range);
1230 snd_printk(KERN_WARNING "usb_audio: [%d] FU [%s] ch = %d, "
1231 "val = %d/%d/%d", cval->id,
1232 kctl->id.name, cval->channels,
1233 cval->min, cval->max, cval->res);
1234 }
1235
1da177e4
LT		 1236 snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1237 cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
ef9d5970 1238 snd_usb_mixer_add_control(state->mixer, kctl);
1da177e4
LT		 1239}
1240
1241
1242
1243/*
1244 * parse a feature unit
1245 *
25985edc 1246 * most of controls are defined here.
1da177e4 1247 */
28e1b773 1248static int parse_audio_feature_unit(struct mixer_build *state, int unitid, void *_ftr)
1da177e4
LT		 1249{
1250 int channels, i, j;
86e07d34 1251 struct usb_audio_term iterm;
1da177e4
LT		 1252 unsigned int master_bits, first_ch_bits;
1253 int err, csize;
23caaf19
DM		 1254 struct uac_feature_unit_descriptor *hdr = _ftr;
1255 __u8 *bmaControls;
1256
1257 if (state->mixer->protocol == UAC_VERSION_1) {
1258 csize = hdr->bControlSize;
60c961a9
NK		 1259 if (!csize) {
1260 snd_printdd(KERN_ERR "usbaudio: unit %u: "
1261 "invalid bControlSize == 0\n", unitid);
1262 return -EINVAL;
1263 }
23caaf19
DM		 1264 channels = (hdr->bLength - 7) / csize - 1;
1265 bmaControls = hdr->bmaControls;
1266 } else {
1267 struct uac2_feature_unit_descriptor *ftr = _ftr;
1268 csize = 4;
e8d0fee7 1269 channels = (hdr->bLength - 6) / 4 - 1;
23caaf19
DM		 1270 bmaControls = ftr->bmaControls;
1271 }
1da177e4 1272
23caaf19 1273 if (hdr->bLength < 7 || !csize || hdr->bLength < 7 + csize) {
de48c7bc 1274 snd_printk(KERN_ERR "usbaudio: unit %u: invalid UAC_FEATURE_UNIT descriptor\n", unitid);
1da177e4
LT		 1275 return -EINVAL;
1276 }
1277
1278 /* parse the source unit */
23caaf19 1279 if ((err = parse_audio_unit(state, hdr->bSourceID)) < 0)
1da177e4
LT		 1280 return err;
1281
1282 /* determine the input source type and name */
23caaf19 1283 if (check_input_term(state, hdr->bSourceID, &iterm) < 0)
1da177e4
LT		 1284 return -EINVAL;
1285
23caaf19 1286 master_bits = snd_usb_combine_bytes(bmaControls, csize);
0c3cee57
JK		 1287 /* master configuration quirks */
1288 switch (state->chip->usb_id) {
1289 case USB_ID(0x08bb, 0x2702):
1290 snd_printk(KERN_INFO
1291 "usbmixer: master volume quirk for PCM2702 chip\n");
1292 /* disable non-functional volume control */
65f25da4 1293 master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
0c3cee57 1294 break;
c1051439
DH		 1295 case USB_ID(0x1130, 0xf211):
1296 snd_printk(KERN_INFO
1297 "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
1298 /* disable non-functional volume control */
1299 channels = 0;
1300 break;
1301
0c3cee57 1302 }
1da177e4 1303 if (channels > 0)
23caaf19 1304 first_ch_bits = snd_usb_combine_bytes(bmaControls + csize, csize);
1da177e4
LT		 1305 else
1306 first_ch_bits = 0;
23caaf19
DM		 1307
1308 if (state->mixer->protocol == UAC_VERSION_1) {
1309 /* check all control types */
1310 for (i = 0; i < 10; i++) {
1311 unsigned int ch_bits = 0;
1312 for (j = 0; j < channels; j++) {
1313 unsigned int mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize);
1314 if (mask & (1 << i))
1315 ch_bits |= (1 << j);
1316 }
1317 /* audio class v1 controls are never read-only */
1318 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
1319 build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, 0);
1320 if (master_bits & (1 << i))
1321 build_feature_ctl(state, _ftr, 0, i, &iterm, unitid, 0);
1322 }
1323 } else { /* UAC_VERSION_2 */
d09c06c6 1324 for (i = 0; i < ARRAY_SIZE(audio_feature_info); i++) {
23caaf19
DM		 1325 unsigned int ch_bits = 0;
1326 unsigned int ch_read_only = 0;
1327
1328 for (j = 0; j < channels; j++) {
1329 unsigned int mask = snd_usb_combine_bytes(bmaControls + csize * (j+1), csize);
dcbe7bcf 1330 if (uac2_control_is_readable(mask, i)) {
23caaf19 1331 ch_bits |= (1 << j);
dcbe7bcf 1332 if (!uac2_control_is_writeable(mask, i))
23caaf19
DM		 1333 ch_read_only |= (1 << j);
1334 }
1335 }
1336
a6a33259
DM		 1337 /* NOTE: build_feature_ctl() will mark the control read-only if all channels
1338 * are marked read-only in the descriptors. Otherwise, the control will be
1339 * reported as writeable, but the driver will not actually issue a write
1340 * command for read-only channels */
23caaf19 1341 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
a6a33259 1342 build_feature_ctl(state, _ftr, ch_bits, i, &iterm, unitid, ch_read_only);
dcbe7bcf 1343 if (uac2_control_is_readable(master_bits, i))
23caaf19 1344 build_feature_ctl(state, _ftr, 0, i, &iterm, unitid,
dcbe7bcf 1345 !uac2_control_is_writeable(master_bits, i));
1da177e4 1346 }
1da177e4
LT		 1347 }
1348
1349 return 0;
1350}
1351
1352
1353/*
1354 * Mixer Unit
1355 */
1356
1357/*
1358 * build a mixer unit control
1359 *
1360 * the callbacks are identical with feature unit.
1361 * input channel number (zero based) is given in control field instead.
1362 */
1363
99fc8645
DM		 1364static void build_mixer_unit_ctl(struct mixer_build *state,
1365 struct uac_mixer_unit_descriptor *desc,
1da177e4 1366 int in_pin, int in_ch, int unitid,
86e07d34 1367 struct usb_audio_term *iterm)
1da177e4 1368{
86e07d34 1369 struct usb_mixer_elem_info *cval;
99fc8645 1370 unsigned int num_outs = uac_mixer_unit_bNrChannels(desc);
1da177e4 1371 unsigned int i, len;
86e07d34 1372 struct snd_kcontrol *kctl;
c3a3e040 1373 const struct usbmix_name_map *map;
1da177e4 1374
c3a3e040
JK		 1375 map = find_map(state, unitid, 0);
1376 if (check_ignored_ctl(map))
1da177e4
LT		 1377 return;
1378
561b220a 1379 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1da177e4
LT		 1380 if (! cval)
1381 return;
1382
84957a8a 1383 cval->mixer = state->mixer;
1da177e4
LT		 1384 cval->id = unitid;
1385 cval->control = in_ch + 1; /* based on 1 */
1386 cval->val_type = USB_MIXER_S16;
1387 for (i = 0; i < num_outs; i++) {
23caaf19 1388 if (check_matrix_bitmap(uac_mixer_unit_bmControls(desc, state->mixer->protocol), in_ch, i, num_outs)) {
1da177e4
LT		 1389 cval->cmask |= (1 << i);
1390 cval->channels++;
1391 }
1392 }
1393
1394 /* get min/max values */
1395 get_min_max(cval, 0);
1396
1397 kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1398 if (! kctl) {
1399 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1400 kfree(cval);
1401 return;
1402 }
1403 kctl->private_free = usb_mixer_elem_free;
1404
c3a3e040 1405 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1da177e4
LT		 1406 if (! len)
1407 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
1408 if (! len)
1409 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
08d1e635 1410 append_ctl_name(kctl, " Volume");
1da177e4
LT		 1411
1412 snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
1413 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
ef9d5970 1414 snd_usb_mixer_add_control(state->mixer, kctl);
1da177e4
LT		 1415}
1416
1417
1418/*
1419 * parse a mixer unit
1420 */
99fc8645 1421static int parse_audio_mixer_unit(struct mixer_build *state, int unitid, void *raw_desc)
1da177e4 1422{
99fc8645 1423 struct uac_mixer_unit_descriptor *desc = raw_desc;
86e07d34 1424 struct usb_audio_term iterm;
1da177e4
LT		 1425 int input_pins, num_ins, num_outs;
1426 int pin, ich, err;
1427
99fc8645 1428 if (desc->bLength < 11 || ! (input_pins = desc->bNrInPins) || ! (num_outs = uac_mixer_unit_bNrChannels(desc))) {
1da177e4
LT		 1429 snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
1430 return -EINVAL;
1431 }
1432 /* no bmControls field (e.g. Maya44) -> ignore */
99fc8645 1433 if (desc->bLength <= 10 + input_pins) {
1da177e4
LT		 1434 snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
1435 return 0;
1436 }
1437
1438 num_ins = 0;
1439 ich = 0;
1440 for (pin = 0; pin < input_pins; pin++) {
99fc8645 1441 err = parse_audio_unit(state, desc->baSourceID[pin]);
1da177e4 1442 if (err < 0)
284a8dd6 1443 continue;
99fc8645 1444 err = check_input_term(state, desc->baSourceID[pin], &iterm);
1da177e4
LT		 1445 if (err < 0)
1446 return err;
1447 num_ins += iterm.channels;
1448 for (; ich < num_ins; ++ich) {
1449 int och, ich_has_controls = 0;
1450
1451 for (och = 0; och < num_outs; ++och) {
23caaf19 1452 if (check_matrix_bitmap(uac_mixer_unit_bmControls(desc, state->mixer->protocol),
1da177e4
LT		 1453 ich, och, num_outs)) {
1454 ich_has_controls = 1;
1455 break;
1456 }
1457 }
1458 if (ich_has_controls)
1459 build_mixer_unit_ctl(state, desc, pin, ich,
1460 unitid, &iterm);
1461 }
1462 }
1463 return 0;
1464}
1465
1466
1467/*
1468 * Processing Unit / Extension Unit
1469 */
1470
1471/* get callback for processing/extension unit */
86e07d34 1472static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1473{
86e07d34 1474 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1475 int err, val;
1476
1477 err = get_cur_ctl_value(cval, cval->control << 8, &val);
84957a8a 1478 if (err < 0 && cval->mixer->ignore_ctl_error) {
1da177e4
LT		 1479 ucontrol->value.integer.value[0] = cval->min;
1480 return 0;
1481 }
1482 if (err < 0)
1483 return err;
1484 val = get_relative_value(cval, val);
1485 ucontrol->value.integer.value[0] = val;
1486 return 0;
1487}
1488
1489/* put callback for processing/extension unit */
86e07d34 1490static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1491{
86e07d34 1492 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1493 int val, oval, err;
1494
1495 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
1496 if (err < 0) {
84957a8a 1497 if (cval->mixer->ignore_ctl_error)
1da177e4
LT		 1498 return 0;
1499 return err;
1500 }
1501 val = ucontrol->value.integer.value[0];
1502 val = get_abs_value(cval, val);
1503 if (val != oval) {
1504 set_cur_ctl_value(cval, cval->control << 8, val);
1505 return 1;
1506 }
1507 return 0;
1508}
1509
1510/* alsa control interface for processing/extension unit */
86e07d34 1511static struct snd_kcontrol_new mixer_procunit_ctl = {
1da177e4
LT		 1512 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1513 .name = "", /* will be filled later */
1514 .info = mixer_ctl_feature_info,
1515 .get = mixer_ctl_procunit_get,
1516 .put = mixer_ctl_procunit_put,
1517};
1518
1519
1520/*
1521 * predefined data for processing units
1522 */
1523struct procunit_value_info {
1524 int control;
1525 char *suffix;
1526 int val_type;
1527 int min_value;
1528};
1529
1530struct procunit_info {
1531 int type;
1532 char *name;
1533 struct procunit_value_info *values;
1534};
1535
1536static struct procunit_value_info updown_proc_info[] = {
65f25da4
DM		 1537 { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1538 { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
1da177e4
LT		 1539 { 0 }
1540};
1541static struct procunit_value_info prologic_proc_info[] = {
65f25da4
DM		 1542 { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1543 { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
1da177e4
LT		 1544 { 0 }
1545};
1546static struct procunit_value_info threed_enh_proc_info[] = {
65f25da4
DM		 1547 { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1548 { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 },
1da177e4
LT		 1549 { 0 }
1550};
1551static struct procunit_value_info reverb_proc_info[] = {
65f25da4
DM		 1552 { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1553 { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
1554 { UAC_REVERB_TIME, "Time", USB_MIXER_U16 },
1555 { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 },
1da177e4
LT		 1556 { 0 }
1557};
1558static struct procunit_value_info chorus_proc_info[] = {
65f25da4
DM		 1559 { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1560 { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
1561 { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
1562 { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
1da177e4
LT		 1563 { 0 }
1564};
1565static struct procunit_value_info dcr_proc_info[] = {
65f25da4
DM		 1566 { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN },
1567 { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 },
1568 { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 },
1569 { UAC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
1570 { UAC_DCR_ATTACK_TIME, "Attack Time", USB_MIXER_U16 },
1571 { UAC_DCR_RELEASE_TIME, "Release Time", USB_MIXER_U16 },
1da177e4
LT		 1572 { 0 }
1573};
1574
1575static struct procunit_info procunits[] = {
65f25da4
DM		 1576 { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info },
1577 { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info },
1578 { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info },
1579 { UAC_PROCESS_REVERB, "Reverb", reverb_proc_info },
1580 { UAC_PROCESS_CHORUS, "Chorus", chorus_proc_info },
1581 { UAC_PROCESS_DYN_RANGE_COMP, "DCR", dcr_proc_info },
1da177e4
LT		 1582 { 0 },
1583};
7d2b451e
SK		 1584/*
1585 * predefined data for extension units
1586 */
1587static struct procunit_value_info clock_rate_xu_info[] = {
e213e9cf
DM		 1588 { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
1589 { 0 }
7d2b451e
SK		 1590};
1591static struct procunit_value_info clock_source_xu_info[] = {
1592 { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
1593 { 0 }
1594};
1595static struct procunit_value_info spdif_format_xu_info[] = {
1596 { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
1597 { 0 }
1598};
1599static struct procunit_value_info soft_limit_xu_info[] = {
1600 { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
1601 { 0 }
1602};
1603static struct procunit_info extunits[] = {
1604 { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
1605 { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
1606 { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
1607 { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
1608 { 0 }
1609};
1da177e4
LT		 1610/*
1611 * build a processing/extension unit
1612 */
99fc8645 1613static int build_audio_procunit(struct mixer_build *state, int unitid, void *raw_desc, struct procunit_info *list, char *name)
1da177e4 1614{
99fc8645
DM		 1615 struct uac_processing_unit_descriptor *desc = raw_desc;
1616 int num_ins = desc->bNrInPins;
86e07d34
TI		 1617 struct usb_mixer_elem_info *cval;
1618 struct snd_kcontrol *kctl;
1da177e4
LT		 1619 int i, err, nameid, type, len;
1620 struct procunit_info *info;
1621 struct procunit_value_info *valinfo;
c3a3e040 1622 const struct usbmix_name_map *map;
1da177e4
LT		 1623 static struct procunit_value_info default_value_info[] = {
1624 { 0x01, "Switch", USB_MIXER_BOOLEAN },
1625 { 0 }
1626 };
1627 static struct procunit_info default_info = {
1628 0, NULL, default_value_info
1629 };
1630
23caaf19
DM		 1631 if (desc->bLength < 13 || desc->bLength < 13 + num_ins ||
1632 desc->bLength < num_ins + uac_processing_unit_bControlSize(desc, state->mixer->protocol)) {
1da177e4
LT		 1633 snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid);
1634 return -EINVAL;
1635 }
1636
1637 for (i = 0; i < num_ins; i++) {
99fc8645 1638 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1da177e4
LT		 1639 return err;
1640 }
1641
99fc8645 1642 type = le16_to_cpu(desc->wProcessType);
1da177e4
LT		 1643 for (info = list; info && info->type; info++)
1644 if (info->type == type)
1645 break;
1646 if (! info || ! info->type)
1647 info = &default_info;
1648
1649 for (valinfo = info->values; valinfo->control; valinfo++) {
23caaf19 1650 __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
99fc8645
DM		 1651
1652 if (! (controls[valinfo->control / 8] & (1 << ((valinfo->control % 8) - 1))))
1da177e4 1653 continue;
c3a3e040
JK		 1654 map = find_map(state, unitid, valinfo->control);
1655 if (check_ignored_ctl(map))
1da177e4 1656 continue;
561b220a 1657 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1da177e4
LT		 1658 if (! cval) {
1659 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1660 return -ENOMEM;
1661 }
84957a8a 1662 cval->mixer = state->mixer;
1da177e4
LT		 1663 cval->id = unitid;
1664 cval->control = valinfo->control;
1665 cval->val_type = valinfo->val_type;
1666 cval->channels = 1;
1667
1668 /* get min/max values */
65f25da4 1669 if (type == UAC_PROCESS_UP_DOWNMIX && cval->control == UAC_UD_MODE_SELECT) {
23caaf19 1670 __u8 *control_spec = uac_processing_unit_specific(desc, state->mixer->protocol);
1da177e4
LT		 1671 /* FIXME: hard-coded */
1672 cval->min = 1;
99fc8645 1673 cval->max = control_spec[0];
1da177e4
LT		 1674 cval->res = 1;
1675 cval->initialized = 1;
7d2b451e
SK		 1676 } else {
1677 if (type == USB_XU_CLOCK_RATE) {
1cdfa9f3 1678 /* E-Mu USB 0404/0202/TrackerPre/0204
7d2b451e
SK		 1679 * samplerate control quirk
1680 */
1681 cval->min = 0;
1682 cval->max = 5;
1683 cval->res = 1;
1684 cval->initialized = 1;
1685 } else
1686 get_min_max(cval, valinfo->min_value);
1687 }
1da177e4
LT		 1688
1689 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
1690 if (! kctl) {
1691 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1692 kfree(cval);
1693 return -ENOMEM;
1694 }
1695 kctl->private_free = usb_mixer_elem_free;
1696
c3a3e040
JK		 1697 if (check_mapped_name(map, kctl->id.name,
1698 sizeof(kctl->id.name)))
1699 /* nothing */ ;
1da177e4
LT		 1700 else if (info->name)
1701 strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
1702 else {
23caaf19 1703 nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
1da177e4
LT		 1704 len = 0;
1705 if (nameid)
1706 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1707 if (! len)
1708 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
1709 }
08d1e635
TI		 1710 append_ctl_name(kctl, " ");
1711 append_ctl_name(kctl, valinfo->suffix);
1da177e4
LT		 1712
1713 snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
1714 cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
ef9d5970 1715 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
1da177e4
LT		 1716 return err;
1717 }
1718 return 0;
1719}
1720
1721
99fc8645 1722static int parse_audio_processing_unit(struct mixer_build *state, int unitid, void *raw_desc)
1da177e4 1723{
99fc8645 1724 return build_audio_procunit(state, unitid, raw_desc, procunits, "Processing Unit");
1da177e4
LT		 1725}
1726
99fc8645 1727static int parse_audio_extension_unit(struct mixer_build *state, int unitid, void *raw_desc)
1da177e4 1728{
99fc8645
DM		 1729 /* Note that we parse extension units with processing unit descriptors.
1730 * That's ok as the layout is the same */
1731 return build_audio_procunit(state, unitid, raw_desc, extunits, "Extension Unit");
1da177e4
LT		 1732}
1733
1734
1735/*
1736 * Selector Unit
1737 */
1738
1739/* info callback for selector unit
1740 * use an enumerator type for routing
1741 */
86e07d34 1742static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
1da177e4 1743{
86e07d34 1744 struct usb_mixer_elem_info *cval = kcontrol->private_data;
2a1803a7 1745 const char **itemlist = (const char **)kcontrol->private_value;
1da177e4 1746
5e246b85
TI		 1747 if (snd_BUG_ON(!itemlist))
1748 return -EINVAL;
2a1803a7 1749 return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist);
1da177e4
LT		 1750}
1751
1752/* get callback for selector unit */
86e07d34 1753static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1754{
86e07d34 1755 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1756 int val, err;
1757
09414207 1758 err = get_cur_ctl_value(cval, cval->control << 8, &val);
1da177e4 1759 if (err < 0) {
84957a8a 1760 if (cval->mixer->ignore_ctl_error) {
1da177e4
LT		 1761 ucontrol->value.enumerated.item[0] = 0;
1762 return 0;
1763 }
1764 return err;
1765 }
1766 val = get_relative_value(cval, val);
1767 ucontrol->value.enumerated.item[0] = val;
1768 return 0;
1769}
1770
1771/* put callback for selector unit */
86e07d34 1772static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
1da177e4 1773{
86e07d34 1774 struct usb_mixer_elem_info *cval = kcontrol->private_data;
1da177e4
LT		 1775 int val, oval, err;
1776
09414207 1777 err = get_cur_ctl_value(cval, cval->control << 8, &oval);
1da177e4 1778 if (err < 0) {
84957a8a 1779 if (cval->mixer->ignore_ctl_error)
1da177e4
LT		 1780 return 0;
1781 return err;
1782 }
1783 val = ucontrol->value.enumerated.item[0];
1784 val = get_abs_value(cval, val);
1785 if (val != oval) {
09414207 1786 set_cur_ctl_value(cval, cval->control << 8, val);
1da177e4
LT		 1787 return 1;
1788 }
1789 return 0;
1790}
1791
1792/* alsa control interface for selector unit */
86e07d34 1793static struct snd_kcontrol_new mixer_selectunit_ctl = {
1da177e4
LT		 1794 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1795 .name = "", /* will be filled later */
1796 .info = mixer_ctl_selector_info,
1797 .get = mixer_ctl_selector_get,
1798 .put = mixer_ctl_selector_put,
1799};
1800
1801
1802/* private free callback.
1803 * free both private_data and private_value
1804 */
86e07d34 1805static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
1da177e4
LT		 1806{
1807 int i, num_ins = 0;
1808
1809 if (kctl->private_data) {
86e07d34 1810 struct usb_mixer_elem_info *cval = kctl->private_data;
1da177e4
LT		 1811 num_ins = cval->max;
1812 kfree(cval);
1813 kctl->private_data = NULL;
1814 }
1815 if (kctl->private_value) {
1816 char **itemlist = (char **)kctl->private_value;
1817 for (i = 0; i < num_ins; i++)
1818 kfree(itemlist[i]);
1819 kfree(itemlist);
1820 kctl->private_value = 0;
1821 }
1822}
1823
1824/*
1825 * parse a selector unit
1826 */
99fc8645 1827static int parse_audio_selector_unit(struct mixer_build *state, int unitid, void *raw_desc)
1da177e4 1828{
99fc8645 1829 struct uac_selector_unit_descriptor *desc = raw_desc;
1da177e4
LT		 1830 unsigned int i, nameid, len;
1831 int err;
86e07d34
TI		 1832 struct usb_mixer_elem_info *cval;
1833 struct snd_kcontrol *kctl;
c3a3e040 1834 const struct usbmix_name_map *map;
1da177e4
LT		 1835 char **namelist;
1836
99fc8645 1837 if (!desc->bNrInPins || desc->bLength < 5 + desc->bNrInPins) {
1da177e4
LT		 1838 snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
1839 return -EINVAL;
1840 }
1841
99fc8645
DM		 1842 for (i = 0; i < desc->bNrInPins; i++) {
1843 if ((err = parse_audio_unit(state, desc->baSourceID[i])) < 0)
1da177e4
LT		 1844 return err;
1845 }
1846
99fc8645 1847 if (desc->bNrInPins == 1) /* only one ? nonsense! */
1da177e4
LT		 1848 return 0;
1849
c3a3e040
JK		 1850 map = find_map(state, unitid, 0);
1851 if (check_ignored_ctl(map))
1da177e4
LT		 1852 return 0;
1853
561b220a 1854 cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1da177e4
LT		 1855 if (! cval) {
1856 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1857 return -ENOMEM;
1858 }
84957a8a 1859 cval->mixer = state->mixer;
1da177e4
LT		 1860 cval->id = unitid;
1861 cval->val_type = USB_MIXER_U8;
1862 cval->channels = 1;
1863 cval->min = 1;
99fc8645 1864 cval->max = desc->bNrInPins;
1da177e4
LT		 1865 cval->res = 1;
1866 cval->initialized = 1;
1867
09414207
DM		 1868 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
1869 cval->control = UAC2_CX_CLOCK_SELECTOR;
1870 else
1871 cval->control = 0;
1872
99fc8645 1873 namelist = kmalloc(sizeof(char *) * desc->bNrInPins, GFP_KERNEL);
1da177e4
LT		 1874 if (! namelist) {
1875 snd_printk(KERN_ERR "cannot malloc\n");
1876 kfree(cval);
1877 return -ENOMEM;
1878 }
1879#define MAX_ITEM_NAME_LEN 64
99fc8645 1880 for (i = 0; i < desc->bNrInPins; i++) {
86e07d34 1881 struct usb_audio_term iterm;
1da177e4
LT		 1882 len = 0;
1883 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
1884 if (! namelist[i]) {
1885 snd_printk(KERN_ERR "cannot malloc\n");
7fbe3ca5 1886 while (i--)
1da177e4
LT		 1887 kfree(namelist[i]);
1888 kfree(namelist);
1889 kfree(cval);
1890 return -ENOMEM;
1891 }
8e062ec7
CL		 1892 len = check_mapped_selector_name(state, unitid, i, namelist[i],
1893 MAX_ITEM_NAME_LEN);
99fc8645 1894 if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
1da177e4
LT		 1895 len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
1896 if (! len)
1897 sprintf(namelist[i], "Input %d", i);
1898 }
1899
1900 kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
1901 if (! kctl) {
1902 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
878b4789 1903 kfree(namelist);
1da177e4
LT		 1904 kfree(cval);
1905 return -ENOMEM;
1906 }
1907 kctl->private_value = (unsigned long)namelist;
1908 kctl->private_free = usb_mixer_selector_elem_free;
1909
99fc8645 1910 nameid = uac_selector_unit_iSelector(desc);
c3a3e040 1911 len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1da177e4
LT		 1912 if (len)
1913 ;
1914 else if (nameid)
1915 snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1916 else {
1917 len = get_term_name(state, &state->oterm,
1918 kctl->id.name, sizeof(kctl->id.name), 0);
1919 if (! len)
1920 strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name));
1921
09414207
DM		 1922 if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR)
1923 append_ctl_name(kctl, " Clock Source");
1924 else if ((state->oterm.type & 0xff00) == 0x0100)
08d1e635 1925 append_ctl_name(kctl, " Capture Source");
1da177e4 1926 else
08d1e635 1927 append_ctl_name(kctl, " Playback Source");
1da177e4
LT		 1928 }
1929
1930 snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
99fc8645 1931 cval->id, kctl->id.name, desc->bNrInPins);
ef9d5970 1932 if ((err = snd_usb_mixer_add_control(state->mixer, kctl)) < 0)
1da177e4
LT		 1933 return err;
1934
1935 return 0;
1936}
1937
1938
1939/*
1940 * parse an audio unit recursively
1941 */
1942
86e07d34 1943static int parse_audio_unit(struct mixer_build *state, int unitid)
1da177e4
LT		 1944{
1945 unsigned char *p1;
1946
1947 if (test_and_set_bit(unitid, state->unitbitmap))
1948 return 0; /* the unit already visited */
1949
1950 p1 = find_audio_control_unit(state, unitid);
1951 if (!p1) {
1952 snd_printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
1953 return -EINVAL;
1954 }
1955
1956 switch (p1[2]) {
de48c7bc 1957 case UAC_INPUT_TERMINAL:
09414207 1958 case UAC2_CLOCK_SOURCE:
1da177e4 1959 return 0; /* NOP */
de48c7bc 1960 case UAC_MIXER_UNIT:
1da177e4 1961 return parse_audio_mixer_unit(state, unitid, p1);
de48c7bc 1962 case UAC_SELECTOR_UNIT:
09414207 1963 case UAC2_CLOCK_SELECTOR:
1da177e4 1964 return parse_audio_selector_unit(state, unitid, p1);
de48c7bc 1965 case UAC_FEATURE_UNIT:
1da177e4 1966 return parse_audio_feature_unit(state, unitid, p1);
69da9bcb 1967 case UAC1_PROCESSING_UNIT:
23caaf19
DM		 1968 /* UAC2_EFFECT_UNIT has the same value */
1969 if (state->mixer->protocol == UAC_VERSION_1)
1970 return parse_audio_processing_unit(state, unitid, p1);
1971 else
1972 return 0; /* FIXME - effect units not implemented yet */
69da9bcb 1973 case UAC1_EXTENSION_UNIT:
23caaf19
DM		 1974 /* UAC2_PROCESSING_UNIT_V2 has the same value */
1975 if (state->mixer->protocol == UAC_VERSION_1)
1976 return parse_audio_extension_unit(state, unitid, p1);
1977 else /* UAC_VERSION_2 */
1978 return parse_audio_processing_unit(state, unitid, p1);
1da177e4
LT		 1979 default:
1980 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
1981 return -EINVAL;
1982 }
1983}
1984
84957a8a
CL		 1985static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
1986{
6639b6c2
CL		 1987 kfree(mixer->id_elems);
1988 if (mixer->urb) {
1989 kfree(mixer->urb->transfer_buffer);
1990 usb_free_urb(mixer->urb);
1991 }
68df9de1 1992 usb_free_urb(mixer->rc_urb);
b259b10c 1993 kfree(mixer->rc_setup_packet);
84957a8a
CL		 1994 kfree(mixer);
1995}
1996
86e07d34 1997static int snd_usb_mixer_dev_free(struct snd_device *device)
84957a8a
CL		 1998{
1999 struct usb_mixer_interface *mixer = device->device_data;
2000 snd_usb_mixer_free(mixer);
2001 return 0;
2002}
2003
1da177e4
LT		 2004/*
2005 * create mixer controls
2006 *
de48c7bc 2007 * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
1da177e4 2008 */
84957a8a 2009static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
1da177e4 2010{
86e07d34 2011 struct mixer_build state;
1da177e4
LT		 2012 int err;
2013 const struct usbmix_ctl_map *map;
23caaf19 2014 void *p;
1da177e4
LT		 2015
2016 memset(&state, 0, sizeof(state));
84957a8a
CL		 2017 state.chip = mixer->chip;
2018 state.mixer = mixer;
1faa5d07
DM		 2019 state.buffer = mixer->hostif->extra;
2020 state.buflen = mixer->hostif->extralen;
1da177e4
LT		 2021
2022 /* check the mapping table */
27d10f56
CL		 2023 for (map = usbmix_ctl_maps; map->id; map++) {
2024 if (map->id == state.chip->usb_id) {
1da177e4 2025 state.map = map->map;
8e062ec7 2026 state.selector_map = map->selector_map;
84957a8a 2027 mixer->ignore_ctl_error = map->ignore_ctl_error;
1da177e4
LT		 2028 break;
2029 }
2030 }
1da177e4 2031
23caaf19 2032 p = NULL;
1faa5d07
DM		 2033 while ((p = snd_usb_find_csint_desc(mixer->hostif->extra, mixer->hostif->extralen,
2034 p, UAC_OUTPUT_TERMINAL)) != NULL) {
23caaf19 2035 if (mixer->protocol == UAC_VERSION_1) {
69da9bcb 2036 struct uac1_output_terminal_descriptor *desc = p;
23caaf19
DM		 2037
2038 if (desc->bLength < sizeof(*desc))
2039 continue; /* invalid descriptor? */
2040 set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */
2041 state.oterm.id = desc->bTerminalID;
2042 state.oterm.type = le16_to_cpu(desc->wTerminalType);
2043 state.oterm.name = desc->iTerminal;
2044 err = parse_audio_unit(&state, desc->bSourceID);
2045 if (err < 0)
2046 return err;
2047 } else { /* UAC_VERSION_2 */
2048 struct uac2_output_terminal_descriptor *desc = p;
2049
2050 if (desc->bLength < sizeof(*desc))
2051 continue; /* invalid descriptor? */
2052 set_bit(desc->bTerminalID, state.unitbitmap); /* mark terminal ID as visited */
2053 state.oterm.id = desc->bTerminalID;
2054 state.oterm.type = le16_to_cpu(desc->wTerminalType);
2055 state.oterm.name = desc->iTerminal;
2056 err = parse_audio_unit(&state, desc->bSourceID);
2057 if (err < 0)
2058 return err;
09414207
DM		 2059
2060 /* for UAC2, use the same approach to also add the clock selectors */
2061 err = parse_audio_unit(&state, desc->bCSourceID);
2062 if (err < 0)
2063 return err;
23caaf19 2064 }
1da177e4 2065 }
23caaf19 2066
1da177e4
LT		 2067 return 0;
2068}
84957a8a 2069
7b1eda22 2070void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
6639b6c2 2071{
86e07d34 2072 struct usb_mixer_elem_info *info;
6639b6c2
CL		 2073
2074 for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem)
2075 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
2076 info->elem_id);
2077}
2078
ebfdeea3
JK		 2079static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
2080 int unitid,
2081 struct usb_mixer_elem_info *cval)
2082{
2083 static char *val_types[] = {"BOOLEAN", "INV_BOOLEAN",
2084 "S8", "U8", "S16", "U16"};
2085 snd_iprintf(buffer, " Unit: %i\n", unitid);
2086 if (cval->elem_id)
2087 snd_iprintf(buffer, " Control: name=\"%s\", index=%i\n",
2088 cval->elem_id->name, cval->elem_id->index);
2089 snd_iprintf(buffer, " Info: id=%i, control=%i, cmask=0x%x, "
2090 "channels=%i, type=\"%s\"\n", cval->id,
2091 cval->control, cval->cmask, cval->channels,
2092 val_types[cval->val_type]);
2093 snd_iprintf(buffer, " Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
2094 cval->min, cval->max, cval->dBmin, cval->dBmax);
2095}
2096
2097static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
2098 struct snd_info_buffer *buffer)
2099{
2100 struct snd_usb_audio *chip = entry->private_data;
2101 struct usb_mixer_interface *mixer;
2102 struct usb_mixer_elem_info *cval;
2103 int unitid;
2104
2105 list_for_each_entry(mixer, &chip->mixer_list, list) {
2106 snd_iprintf(buffer,
7affdc17 2107 "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
3d8d4dcf 2108 chip->usb_id, snd_usb_ctrl_intf(chip),
7affdc17 2109 mixer->ignore_ctl_error);
ebfdeea3
JK		 2110 snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
2111 for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
2112 for (cval = mixer->id_elems[unitid]; cval;
2113 cval = cval->next_id_elem)
2114 snd_usb_mixer_dump_cval(buffer, unitid, cval);
2115 }
2116 }
2117}
2118
e213e9cf
DM		 2119static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
2120 int attribute, int value, int index)
2121{
2122 struct usb_mixer_elem_info *info;
2123 __u8 unitid = (index >> 8) & 0xff;
2124 __u8 control = (value >> 8) & 0xff;
2125 __u8 channel = value & 0xff;
2126
2127 if (channel >= MAX_CHANNELS) {
2128 snd_printk(KERN_DEBUG "%s(): bogus channel number %d\n",
2129 __func__, channel);
2130 return;
2131 }
2132
2133 for (info = mixer->id_elems[unitid]; info; info = info->next_id_elem) {
2134 if (info->control != control)
2135 continue;
2136
2137 switch (attribute) {
2138 case UAC2_CS_CUR:
2139 /* invalidate cache, so the value is read from the device */
2140 if (channel)
2141 info->cached &= ~(1 << channel);
2142 else /* master channel */
2143 info->cached = 0;
2144
2145 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
2146 info->elem_id);
2147 break;
2148
2149 case UAC2_CS_RANGE:
2150 /* TODO */
2151 break;
2152
2153 case UAC2_CS_MEM:
2154 /* TODO */
2155 break;
2156
2157 default:
2158 snd_printk(KERN_DEBUG "unknown attribute %d in interrupt\n",
2159 attribute);
2160 break;
2161 } /* switch */
2162 }
2163}
2164
2165static void snd_usb_mixer_interrupt(struct urb *urb)
6639b6c2
CL		 2166{
2167 struct usb_mixer_interface *mixer = urb->context;
e213e9cf 2168 int len = urb->actual_length;
edf7de31 2169 int ustatus = urb->status;
e213e9cf 2170
edf7de31 2171 if (ustatus != 0)
e213e9cf 2172 goto requeue;
6639b6c2 2173
e213e9cf
DM		 2174 if (mixer->protocol == UAC_VERSION_1) {
2175 struct uac1_status_word *status;
6639b6c2 2176
e213e9cf
DM		 2177 for (status = urb->transfer_buffer;
2178 len >= sizeof(*status);
2179 len -= sizeof(*status), status++) {
6639b6c2 2180 snd_printd(KERN_DEBUG "status interrupt: %02x %02x\n",
e213e9cf
DM		 2181 status->bStatusType,
2182 status->bOriginator);
2183
6639b6c2 2184 /* ignore any notifications not from the control interface */
e213e9cf
DM		 2185 if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) !=
2186 UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF)
6639b6c2 2187 continue;
e213e9cf
DM		 2188
2189 if (status->bStatusType & UAC1_STATUS_TYPE_MEM_CHANGED)
2190 snd_usb_mixer_rc_memory_change(mixer, status->bOriginator);
b259b10c 2191 else
e213e9cf
DM		 2192 snd_usb_mixer_notify_id(mixer, status->bOriginator);
2193 }
2194 } else { /* UAC_VERSION_2 */
2195 struct uac2_interrupt_data_msg *msg;
2196
2197 for (msg = urb->transfer_buffer;
2198 len >= sizeof(*msg);
2199 len -= sizeof(*msg), msg++) {
2200 /* drop vendor specific and endpoint requests */
2201 if ((msg->bInfo & UAC2_INTERRUPT_DATA_MSG_VENDOR) ||
2202 (msg->bInfo & UAC2_INTERRUPT_DATA_MSG_EP))
2203 continue;
2204
2205 snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute,
2206 le16_to_cpu(msg->wValue),
2207 le16_to_cpu(msg->wIndex));
6639b6c2
CL		 2208 }
2209 }
e213e9cf
DM		 2210
2211requeue:
edf7de31 2212 if (ustatus != -ENOENT && ustatus != -ECONNRESET && ustatus != -ESHUTDOWN) {
6639b6c2
CL		 2213 urb->dev = mixer->chip->dev;
2214 usb_submit_urb(urb, GFP_ATOMIC);
2215 }
2216}
2217
edf7de31
ON		 2218/* stop any bus activity of a mixer */
2219void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
2220{
2221 usb_kill_urb(mixer->urb);
2222 usb_kill_urb(mixer->rc_urb);
2223}
2224
2225int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
2226{
2227 int err;
2228
2229 if (mixer->urb) {
2230 err = usb_submit_urb(mixer->urb, GFP_NOIO);
2231 if (err < 0)
2232 return err;
2233 }
2234
2235 return 0;
2236}
2237
6639b6c2
CL		 2238/* create the handler for the optional status interrupt endpoint */
2239static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
2240{
6639b6c2
CL		 2241 struct usb_endpoint_descriptor *ep;
2242 void *transfer_buffer;
2243 int buffer_length;
2244 unsigned int epnum;
2245
6639b6c2 2246 /* we need one interrupt input endpoint */
1faa5d07 2247 if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1)
6639b6c2 2248 return 0;
1faa5d07 2249 ep = get_endpoint(mixer->hostif, 0);
913ae5a2 2250 if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_int(ep))
6639b6c2
CL		 2251 return 0;
2252
42a6e66f 2253 epnum = usb_endpoint_num(ep);
6639b6c2
CL		 2254 buffer_length = le16_to_cpu(ep->wMaxPacketSize);
2255 transfer_buffer = kmalloc(buffer_length, GFP_KERNEL);
2256 if (!transfer_buffer)
2257 return -ENOMEM;
2258 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
2259 if (!mixer->urb) {
2260 kfree(transfer_buffer);
2261 return -ENOMEM;
2262 }
2263 usb_fill_int_urb(mixer->urb, mixer->chip->dev,
2264 usb_rcvintpipe(mixer->chip->dev, epnum),
2265 transfer_buffer, buffer_length,
e213e9cf 2266 snd_usb_mixer_interrupt, mixer, ep->bInterval);
6639b6c2
CL		 2267 usb_submit_urb(mixer->urb, GFP_KERNEL);
2268 return 0;
2269}
2270
7a9b8063
TI		 2271int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif,
2272 int ignore_error)
84957a8a 2273{
86e07d34 2274 static struct snd_device_ops dev_ops = {
84957a8a
CL		 2275 .dev_free = snd_usb_mixer_dev_free
2276 };
2277 struct usb_mixer_interface *mixer;
ebfdeea3 2278 struct snd_info_entry *entry;
23caaf19 2279 int err;
84957a8a
CL		 2280
2281 strcpy(chip->card->mixername, "USB Mixer");
2282
561b220a 2283 mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
84957a8a
CL		 2284 if (!mixer)
2285 return -ENOMEM;
2286 mixer->chip = chip;
7a9b8063 2287 mixer->ignore_ctl_error = ignore_error;
291186e0
JK		 2288 mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
2289 GFP_KERNEL);
6639b6c2
CL		 2290 if (!mixer->id_elems) {
2291 kfree(mixer);
2292 return -ENOMEM;
2293 }
84957a8a 2294
1faa5d07
DM		 2295 mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
2296 switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) {
a2acad82
CL		 2297 case UAC_VERSION_1:
2298 default:
2299 mixer->protocol = UAC_VERSION_1;
2300 break;
2301 case UAC_VERSION_2:
2302 mixer->protocol = UAC_VERSION_2;
2303 break;
2304 }
7b8a043f 2305
6639b6c2 2306 if ((err = snd_usb_mixer_controls(mixer)) < 0 ||
93446edc
CL		 2307 (err = snd_usb_mixer_status_create(mixer)) < 0)
2308 goto _error;
84957a8a 2309
7b1eda22 2310 snd_usb_mixer_apply_create_quirk(mixer);
468b8fde 2311
84957a8a 2312 err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
93446edc
CL		 2313 if (err < 0)
2314 goto _error;
ebfdeea3
JK		 2315
2316 if (list_empty(&chip->mixer_list) &&
2317 !snd_card_proc_new(chip->card, "usbmixer", &entry))
2318 snd_info_set_text_ops(entry, chip, snd_usb_mixer_proc_read);
2319
84957a8a
CL		 2320 list_add(&mixer->list, &chip->mixer_list);
2321 return 0;
93446edc
CL		 2322
2323_error:
2324 snd_usb_mixer_free(mixer);
2325 return err;
84957a8a
CL		 2326}
2327
2328void snd_usb_mixer_disconnect(struct list_head *p)
2329{
6639b6c2 2330 struct usb_mixer_interface *mixer;
7b1eda22 2331
6639b6c2 2332 mixer = list_entry(p, struct usb_mixer_interface, list);
68df9de1
MK		 2333 usb_kill_urb(mixer->urb);
2334 usb_kill_urb(mixer->rc_urb);
84957a8a 2335}
Linux kernel - Deliverables
This page took 0.900477 seconds and 5 git commands to generate.