11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2f0b5e634SDaniel Mack /*
3f0b5e634SDaniel Mack * (Tentative) USB Audio Driver for ALSA
4f0b5e634SDaniel Mack *
5f0b5e634SDaniel Mack * Mixer control part
6f0b5e634SDaniel Mack *
7f0b5e634SDaniel Mack * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
8f0b5e634SDaniel Mack *
9f0b5e634SDaniel Mack * Many codes borrowed from audio.c by
10f0b5e634SDaniel Mack * Alan Cox (alan@lxorguk.ukuu.org.uk)
11f0b5e634SDaniel Mack * Thomas Sailer (sailer@ife.ee.ethz.ch)
12f0b5e634SDaniel Mack */
13f0b5e634SDaniel Mack
14157a57b6SDaniel Mack /*
15157a57b6SDaniel Mack * TODOs, for both the mixer and the streaming interfaces:
16157a57b6SDaniel Mack *
17157a57b6SDaniel Mack * - support for UAC2 effect units
18157a57b6SDaniel Mack * - support for graphical equalizers
19157a57b6SDaniel Mack * - RANGE and MEM set commands (UAC2)
20157a57b6SDaniel Mack * - RANGE and MEM interrupt dispatchers (UAC2)
21157a57b6SDaniel Mack * - audio channel clustering (UAC2)
22157a57b6SDaniel Mack * - audio sample rate converter units (UAC2)
23157a57b6SDaniel Mack * - proper handling of clock multipliers (UAC2)
24157a57b6SDaniel Mack * - dispatch clock change notifications (UAC2)
25157a57b6SDaniel Mack * - stop PCM streams which use a clock that became invalid
26157a57b6SDaniel Mack * - stop PCM streams which use a clock selector that has changed
27157a57b6SDaniel Mack * - parse available sample rates again when clock sources changed
28157a57b6SDaniel Mack */
29157a57b6SDaniel Mack
30f0b5e634SDaniel Mack #include <linux/bitops.h>
31f0b5e634SDaniel Mack #include <linux/init.h>
32f0b5e634SDaniel Mack #include <linux/list.h>
33cddaafb9SDaniel Mack #include <linux/log2.h>
34f0b5e634SDaniel Mack #include <linux/slab.h>
35f0b5e634SDaniel Mack #include <linux/string.h>
36f0b5e634SDaniel Mack #include <linux/usb.h>
37f0b5e634SDaniel Mack #include <linux/usb/audio.h>
3823caaf19SDaniel Mack #include <linux/usb/audio-v2.h>
399a2fe9b8SRuslan Bilovol #include <linux/usb/audio-v3.h>
40f0b5e634SDaniel Mack
41f0b5e634SDaniel Mack #include <sound/core.h>
42f0b5e634SDaniel Mack #include <sound/control.h>
43f0b5e634SDaniel Mack #include <sound/hwdep.h>
44f0b5e634SDaniel Mack #include <sound/info.h>
45f0b5e634SDaniel Mack #include <sound/tlv.h>
46f0b5e634SDaniel Mack
47f0b5e634SDaniel Mack #include "usbaudio.h"
48f0b5e634SDaniel Mack #include "mixer.h"
49f0b5e634SDaniel Mack #include "helper.h"
50f0b5e634SDaniel Mack #include "mixer_quirks.h"
5188a8516aSOliver Neukum #include "power.h"
52f0b5e634SDaniel Mack
53f0b5e634SDaniel Mack #define MAX_ID_ELEMS 256
54f0b5e634SDaniel Mack
55f0b5e634SDaniel Mack struct usb_audio_term {
56f0b5e634SDaniel Mack int id;
57f0b5e634SDaniel Mack int type;
58f0b5e634SDaniel Mack int channels;
59f0b5e634SDaniel Mack unsigned int chconfig;
60f0b5e634SDaniel Mack int name;
61f0b5e634SDaniel Mack };
62f0b5e634SDaniel Mack
63f0b5e634SDaniel Mack struct usbmix_name_map;
64f0b5e634SDaniel Mack
65f0b5e634SDaniel Mack struct mixer_build {
66f0b5e634SDaniel Mack struct snd_usb_audio *chip;
67f0b5e634SDaniel Mack struct usb_mixer_interface *mixer;
68f0b5e634SDaniel Mack unsigned char *buffer;
69f0b5e634SDaniel Mack unsigned int buflen;
70f0b5e634SDaniel Mack DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
7119bce474SHui Peng DECLARE_BITMAP(termbitmap, MAX_ID_ELEMS);
72f0b5e634SDaniel Mack struct usb_audio_term oterm;
73f0b5e634SDaniel Mack const struct usbmix_name_map *map;
74f0b5e634SDaniel Mack const struct usbmix_selector_map *selector_map;
75f0b5e634SDaniel Mack };
76f0b5e634SDaniel Mack
771cdfa9f3SJoseph Teichman /*E-mu 0202/0404/0204 eXtension Unit(XU) control*/
78f0b5e634SDaniel Mack enum {
79f0b5e634SDaniel Mack USB_XU_CLOCK_RATE = 0xe301,
80f0b5e634SDaniel Mack USB_XU_CLOCK_SOURCE = 0xe302,
81f0b5e634SDaniel Mack USB_XU_DIGITAL_IO_STATUS = 0xe303,
82f0b5e634SDaniel Mack USB_XU_DEVICE_OPTIONS = 0xe304,
83f0b5e634SDaniel Mack USB_XU_DIRECT_MONITORING = 0xe305,
84f0b5e634SDaniel Mack USB_XU_METERING = 0xe306
85f0b5e634SDaniel Mack };
86f0b5e634SDaniel Mack enum {
87f0b5e634SDaniel Mack USB_XU_CLOCK_SOURCE_SELECTOR = 0x02, /* clock source*/
88f0b5e634SDaniel Mack USB_XU_CLOCK_RATE_SELECTOR = 0x03, /* clock rate */
89f0b5e634SDaniel Mack USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01, /* the spdif format */
90f0b5e634SDaniel Mack USB_XU_SOFT_LIMIT_SELECTOR = 0x03 /* soft limiter */
91f0b5e634SDaniel Mack };
92f0b5e634SDaniel Mack
93f0b5e634SDaniel Mack /*
94f0b5e634SDaniel Mack * manual mapping of mixer names
95f0b5e634SDaniel Mack * if the mixer topology is too complicated and the parsed names are
96f0b5e634SDaniel Mack * ambiguous, add the entries in usbmixer_maps.c.
97f0b5e634SDaniel Mack */
98f0b5e634SDaniel Mack #include "mixer_maps.c"
99f0b5e634SDaniel Mack
100f0b5e634SDaniel Mack static const struct usbmix_name_map *
find_map(const struct usbmix_name_map * p,int unitid,int control)10117156f23SRuslan Bilovol find_map(const struct usbmix_name_map *p, int unitid, int control)
102f0b5e634SDaniel Mack {
103f0b5e634SDaniel Mack if (!p)
104f0b5e634SDaniel Mack return NULL;
105f0b5e634SDaniel Mack
10617156f23SRuslan Bilovol for (; p->id; p++) {
107f0b5e634SDaniel Mack if (p->id == unitid &&
108f0b5e634SDaniel Mack (!control || !p->control || control == p->control))
109f0b5e634SDaniel Mack return p;
110f0b5e634SDaniel Mack }
111f0b5e634SDaniel Mack return NULL;
112f0b5e634SDaniel Mack }
113f0b5e634SDaniel Mack
114f0b5e634SDaniel Mack /* get the mapped name if the unit matches */
115f0b5e634SDaniel Mack static int
check_mapped_name(const struct usbmix_name_map * p,char * buf,int buflen)116f0b5e634SDaniel Mack check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
117f0b5e634SDaniel Mack {
118e8afdfdcSTakashi Iwai int len;
119e8afdfdcSTakashi Iwai
120f0b5e634SDaniel Mack if (!p || !p->name)
121f0b5e634SDaniel Mack return 0;
122f0b5e634SDaniel Mack
123f0b5e634SDaniel Mack buflen--;
124e8afdfdcSTakashi Iwai len = strscpy(buf, p->name, buflen);
125e8afdfdcSTakashi Iwai return len < 0 ? buflen : len;
126f0b5e634SDaniel Mack }
127f0b5e634SDaniel Mack
1285aeee342STakashi Iwai /* ignore the error value if ignore_ctl_error flag is set */
1295aeee342STakashi Iwai #define filter_error(cval, err) \
1303360b84bSTakashi Iwai ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
1315aeee342STakashi Iwai
132f0b5e634SDaniel Mack /* check whether the control should be ignored */
133f0b5e634SDaniel Mack static inline int
check_ignored_ctl(const struct usbmix_name_map * p)134f0b5e634SDaniel Mack check_ignored_ctl(const struct usbmix_name_map *p)
135f0b5e634SDaniel Mack {
136f0b5e634SDaniel Mack if (!p || p->name || p->dB)
137f0b5e634SDaniel Mack return 0;
138f0b5e634SDaniel Mack return 1;
139f0b5e634SDaniel Mack }
140f0b5e634SDaniel Mack
141f0b5e634SDaniel Mack /* dB mapping */
check_mapped_dB(const struct usbmix_name_map * p,struct usb_mixer_elem_info * cval)142f0b5e634SDaniel Mack static inline void check_mapped_dB(const struct usbmix_name_map *p,
143f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval)
144f0b5e634SDaniel Mack {
145f0b5e634SDaniel Mack if (p && p->dB) {
146f0b5e634SDaniel Mack cval->dBmin = p->dB->min;
147f0b5e634SDaniel Mack cval->dBmax = p->dB->max;
14885b741c1STakashi Iwai cval->min_mute = p->dB->min_mute;
14938b65190STakashi Iwai cval->initialized = 1;
150f0b5e634SDaniel Mack }
151f0b5e634SDaniel Mack }
152f0b5e634SDaniel Mack
153f0b5e634SDaniel Mack /* get the mapped selector source name */
check_mapped_selector_name(struct mixer_build * state,int unitid,int index,char * buf,int buflen)154f0b5e634SDaniel Mack static int check_mapped_selector_name(struct mixer_build *state, int unitid,
155f0b5e634SDaniel Mack int index, char *buf, int buflen)
156f0b5e634SDaniel Mack {
157f0b5e634SDaniel Mack const struct usbmix_selector_map *p;
158e8afdfdcSTakashi Iwai int len;
159f0b5e634SDaniel Mack
160f0b5e634SDaniel Mack if (!state->selector_map)
161f0b5e634SDaniel Mack return 0;
162f0b5e634SDaniel Mack for (p = state->selector_map; p->id; p++) {
163e8afdfdcSTakashi Iwai if (p->id == unitid && index < p->count) {
164e8afdfdcSTakashi Iwai len = strscpy(buf, p->names[index], buflen);
165e8afdfdcSTakashi Iwai return len < 0 ? buflen : len;
166e8afdfdcSTakashi Iwai }
167f0b5e634SDaniel Mack }
168f0b5e634SDaniel Mack return 0;
169f0b5e634SDaniel Mack }
170f0b5e634SDaniel Mack
171f0b5e634SDaniel Mack /*
172f0b5e634SDaniel Mack * find an audio control unit with the given unit id
173f0b5e634SDaniel Mack */
find_audio_control_unit(struct mixer_build * state,unsigned char unit)1746bc170e4SDaniel Mack static void *find_audio_control_unit(struct mixer_build *state,
1756bc170e4SDaniel Mack unsigned char unit)
176f0b5e634SDaniel Mack {
17767e1daa0SDaniel Mack /* we just parse the header */
17867e1daa0SDaniel Mack struct uac_feature_unit_descriptor *hdr = NULL;
179f0b5e634SDaniel Mack
18067e1daa0SDaniel Mack while ((hdr = snd_usb_find_desc(state->buffer, state->buflen, hdr,
181f0b5e634SDaniel Mack USB_DT_CS_INTERFACE)) != NULL) {
18267e1daa0SDaniel Mack if (hdr->bLength >= 4 &&
18367e1daa0SDaniel Mack hdr->bDescriptorSubtype >= UAC_INPUT_TERMINAL &&
1849a2fe9b8SRuslan Bilovol hdr->bDescriptorSubtype <= UAC3_SAMPLE_RATE_CONVERTER &&
18567e1daa0SDaniel Mack hdr->bUnitID == unit)
18667e1daa0SDaniel Mack return hdr;
187f0b5e634SDaniel Mack }
18867e1daa0SDaniel Mack
189f0b5e634SDaniel Mack return NULL;
190f0b5e634SDaniel Mack }
191f0b5e634SDaniel Mack
192f0b5e634SDaniel Mack /*
193f0b5e634SDaniel Mack * copy a string with the given id
194f0b5e634SDaniel Mack */
snd_usb_copy_string_desc(struct snd_usb_audio * chip,int index,char * buf,int maxlen)195eccfc1b8SRuslan Bilovol static int snd_usb_copy_string_desc(struct snd_usb_audio *chip,
1966bc170e4SDaniel Mack int index, char *buf, int maxlen)
197f0b5e634SDaniel Mack {
198eccfc1b8SRuslan Bilovol int len = usb_string(chip->dev, index, buf, maxlen - 1);
199251552a2SJaejoong Kim
200251552a2SJaejoong Kim if (len < 0)
201251552a2SJaejoong Kim return 0;
202251552a2SJaejoong Kim
203f0b5e634SDaniel Mack buf[len] = 0;
204f0b5e634SDaniel Mack return len;
205f0b5e634SDaniel Mack }
206f0b5e634SDaniel Mack
207f0b5e634SDaniel Mack /*
208f0b5e634SDaniel Mack * convert from the byte/word on usb descriptor to the zero-based integer
209f0b5e634SDaniel Mack */
convert_signed_value(struct usb_mixer_elem_info * cval,int val)210f0b5e634SDaniel Mack static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
211f0b5e634SDaniel Mack {
212f0b5e634SDaniel Mack switch (cval->val_type) {
213f0b5e634SDaniel Mack case USB_MIXER_BOOLEAN:
214f0b5e634SDaniel Mack return !!val;
215f0b5e634SDaniel Mack case USB_MIXER_INV_BOOLEAN:
216f0b5e634SDaniel Mack return !val;
217f0b5e634SDaniel Mack case USB_MIXER_U8:
218f0b5e634SDaniel Mack val &= 0xff;
219f0b5e634SDaniel Mack break;
220f0b5e634SDaniel Mack case USB_MIXER_S8:
221f0b5e634SDaniel Mack val &= 0xff;
222f0b5e634SDaniel Mack if (val >= 0x80)
223f0b5e634SDaniel Mack val -= 0x100;
224f0b5e634SDaniel Mack break;
225f0b5e634SDaniel Mack case USB_MIXER_U16:
226f0b5e634SDaniel Mack val &= 0xffff;
227f0b5e634SDaniel Mack break;
228f0b5e634SDaniel Mack case USB_MIXER_S16:
229f0b5e634SDaniel Mack val &= 0xffff;
230f0b5e634SDaniel Mack if (val >= 0x8000)
231f0b5e634SDaniel Mack val -= 0x10000;
232f0b5e634SDaniel Mack break;
233f0b5e634SDaniel Mack }
234f0b5e634SDaniel Mack return val;
235f0b5e634SDaniel Mack }
236f0b5e634SDaniel Mack
237f0b5e634SDaniel Mack /*
238f0b5e634SDaniel Mack * convert from the zero-based int to the byte/word for usb descriptor
239f0b5e634SDaniel Mack */
convert_bytes_value(struct usb_mixer_elem_info * cval,int val)240f0b5e634SDaniel Mack static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
241f0b5e634SDaniel Mack {
242f0b5e634SDaniel Mack switch (cval->val_type) {
243f0b5e634SDaniel Mack case USB_MIXER_BOOLEAN:
244f0b5e634SDaniel Mack return !!val;
245f0b5e634SDaniel Mack case USB_MIXER_INV_BOOLEAN:
246f0b5e634SDaniel Mack return !val;
247f0b5e634SDaniel Mack case USB_MIXER_S8:
248f0b5e634SDaniel Mack case USB_MIXER_U8:
249f0b5e634SDaniel Mack return val & 0xff;
250f0b5e634SDaniel Mack case USB_MIXER_S16:
251f0b5e634SDaniel Mack case USB_MIXER_U16:
252f0b5e634SDaniel Mack return val & 0xffff;
253f0b5e634SDaniel Mack }
254f0b5e634SDaniel Mack return 0; /* not reached */
255f0b5e634SDaniel Mack }
256f0b5e634SDaniel Mack
get_relative_value(struct usb_mixer_elem_info * cval,int val)257f0b5e634SDaniel Mack static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
258f0b5e634SDaniel Mack {
259f0b5e634SDaniel Mack if (!cval->res)
260f0b5e634SDaniel Mack cval->res = 1;
261f0b5e634SDaniel Mack if (val < cval->min)
262f0b5e634SDaniel Mack return 0;
263f0b5e634SDaniel Mack else if (val >= cval->max)
264e4d8aef2SLars-Peter Clausen return DIV_ROUND_UP(cval->max - cval->min, cval->res);
265f0b5e634SDaniel Mack else
266f0b5e634SDaniel Mack return (val - cval->min) / cval->res;
267f0b5e634SDaniel Mack }
268f0b5e634SDaniel Mack
get_abs_value(struct usb_mixer_elem_info * cval,int val)269f0b5e634SDaniel Mack static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
270f0b5e634SDaniel Mack {
271f0b5e634SDaniel Mack if (val < 0)
272f0b5e634SDaniel Mack return cval->min;
273f0b5e634SDaniel Mack if (!cval->res)
274f0b5e634SDaniel Mack cval->res = 1;
275f0b5e634SDaniel Mack val *= cval->res;
276f0b5e634SDaniel Mack val += cval->min;
277f0b5e634SDaniel Mack if (val > cval->max)
278f0b5e634SDaniel Mack return cval->max;
279f0b5e634SDaniel Mack return val;
280f0b5e634SDaniel Mack }
281f0b5e634SDaniel Mack
uac2_ctl_value_size(int val_type)282bc18e31cSJulian Scheel static int uac2_ctl_value_size(int val_type)
283bc18e31cSJulian Scheel {
284bc18e31cSJulian Scheel switch (val_type) {
285bc18e31cSJulian Scheel case USB_MIXER_S32:
286bc18e31cSJulian Scheel case USB_MIXER_U32:
287bc18e31cSJulian Scheel return 4;
288bc18e31cSJulian Scheel case USB_MIXER_S16:
289bc18e31cSJulian Scheel case USB_MIXER_U16:
290bc18e31cSJulian Scheel return 2;
291bc18e31cSJulian Scheel default:
292bc18e31cSJulian Scheel return 1;
293bc18e31cSJulian Scheel }
294bc18e31cSJulian Scheel return 0; /* unreachable */
295bc18e31cSJulian Scheel }
296bc18e31cSJulian Scheel
297f0b5e634SDaniel Mack
298f0b5e634SDaniel Mack /*
299f0b5e634SDaniel Mack * retrieve a mixer value
300f0b5e634SDaniel Mack */
301f0b5e634SDaniel Mack
mixer_ctrl_intf(struct usb_mixer_interface * mixer)3020aef31b7SChris Wulff static inline int mixer_ctrl_intf(struct usb_mixer_interface *mixer)
3030aef31b7SChris Wulff {
3040aef31b7SChris Wulff return get_iface_desc(mixer->hostif)->bInterfaceNumber;
3050aef31b7SChris Wulff }
3060aef31b7SChris Wulff
get_ctl_value_v1(struct usb_mixer_elem_info * cval,int request,int validx,int * value_ret)3076bc170e4SDaniel Mack static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request,
3086bc170e4SDaniel Mack int validx, int *value_ret)
309f0b5e634SDaniel Mack {
3103360b84bSTakashi Iwai struct snd_usb_audio *chip = cval->head.mixer->chip;
311f0b5e634SDaniel Mack unsigned char buf[2];
312f0b5e634SDaniel Mack int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
313f0b5e634SDaniel Mack int timeout = 10;
314978520b7STakashi Iwai int idx = 0, err;
315f0b5e634SDaniel Mack
31647ab1545STakashi Iwai err = snd_usb_lock_shutdown(chip);
31788a8516aSOliver Neukum if (err < 0)
31888a8516aSOliver Neukum return -EIO;
3196bc170e4SDaniel Mack
320f0b5e634SDaniel Mack while (timeout-- > 0) {
3210aef31b7SChris Wulff idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
3225a9a8ecaSStephen Barber err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
323f0b5e634SDaniel Mack USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
3245a9a8ecaSStephen Barber validx, idx, buf, val_len);
3255a9a8ecaSStephen Barber if (err >= val_len) {
326f0b5e634SDaniel Mack *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
327978520b7STakashi Iwai err = 0;
328978520b7STakashi Iwai goto out;
3295a9a8ecaSStephen Barber } else if (err == -ETIMEDOUT) {
3305a9a8ecaSStephen Barber goto out;
331f0b5e634SDaniel Mack }
332f0b5e634SDaniel Mack }
3330ba41d91STakashi Iwai usb_audio_dbg(chip,
3340ba41d91STakashi Iwai "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
335978520b7STakashi Iwai request, validx, idx, cval->val_type);
336978520b7STakashi Iwai err = -EINVAL;
337978520b7STakashi Iwai
338978520b7STakashi Iwai out:
33947ab1545STakashi Iwai snd_usb_unlock_shutdown(chip);
340978520b7STakashi Iwai return err;
341f0b5e634SDaniel Mack }
342f0b5e634SDaniel Mack
get_ctl_value_v2(struct usb_mixer_elem_info * cval,int request,int validx,int * value_ret)3436bc170e4SDaniel Mack static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request,
3446bc170e4SDaniel Mack int validx, int *value_ret)
34523caaf19SDaniel Mack {
3463360b84bSTakashi Iwai struct snd_usb_audio *chip = cval->head.mixer->chip;
347447cae58SKirill Marinushkin /* enough space for one range */
348447cae58SKirill Marinushkin unsigned char buf[sizeof(__u16) + 3 * sizeof(__u32)];
34923caaf19SDaniel Mack unsigned char *val;
350447cae58SKirill Marinushkin int idx = 0, ret, val_size, size;
35123caaf19SDaniel Mack __u8 bRequest;
35223caaf19SDaniel Mack
353447cae58SKirill Marinushkin val_size = uac2_ctl_value_size(cval->val_type);
354447cae58SKirill Marinushkin
355e8bdb6bbSDaniel Mack if (request == UAC_GET_CUR) {
356e8bdb6bbSDaniel Mack bRequest = UAC2_CS_CUR;
357447cae58SKirill Marinushkin size = val_size;
358e8bdb6bbSDaniel Mack } else {
359e8bdb6bbSDaniel Mack bRequest = UAC2_CS_RANGE;
360447cae58SKirill Marinushkin size = sizeof(__u16) + 3 * val_size;
361e8bdb6bbSDaniel Mack }
362e8bdb6bbSDaniel Mack
363e8bdb6bbSDaniel Mack memset(buf, 0, sizeof(buf));
36423caaf19SDaniel Mack
365509975c7STakashi Iwai if (snd_usb_lock_shutdown(chip))
366509975c7STakashi Iwai return -EIO;
36788a8516aSOliver Neukum
3680aef31b7SChris Wulff idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
3693d8d4dcfSDaniel Mack ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest,
37023caaf19SDaniel Mack USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
371978520b7STakashi Iwai validx, idx, buf, size);
37247ab1545STakashi Iwai snd_usb_unlock_shutdown(chip);
37323caaf19SDaniel Mack
37423caaf19SDaniel Mack if (ret < 0) {
375ac9b019dSTakashi Iwai usb_audio_dbg(chip,
3760ba41d91STakashi Iwai "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
377978520b7STakashi Iwai request, validx, idx, cval->val_type);
37823caaf19SDaniel Mack return ret;
37923caaf19SDaniel Mack }
38023caaf19SDaniel Mack
381e8bdb6bbSDaniel Mack /* FIXME: how should we handle multiple triplets here? */
382e8bdb6bbSDaniel Mack
38323caaf19SDaniel Mack switch (request) {
38423caaf19SDaniel Mack case UAC_GET_CUR:
38523caaf19SDaniel Mack val = buf;
38623caaf19SDaniel Mack break;
38723caaf19SDaniel Mack case UAC_GET_MIN:
38823caaf19SDaniel Mack val = buf + sizeof(__u16);
38923caaf19SDaniel Mack break;
39023caaf19SDaniel Mack case UAC_GET_MAX:
391447cae58SKirill Marinushkin val = buf + sizeof(__u16) + val_size;
39223caaf19SDaniel Mack break;
39323caaf19SDaniel Mack case UAC_GET_RES:
394447cae58SKirill Marinushkin val = buf + sizeof(__u16) + val_size * 2;
39523caaf19SDaniel Mack break;
39623caaf19SDaniel Mack default:
39723caaf19SDaniel Mack return -EINVAL;
39823caaf19SDaniel Mack }
39923caaf19SDaniel Mack
400447cae58SKirill Marinushkin *value_ret = convert_signed_value(cval,
401447cae58SKirill Marinushkin snd_usb_combine_bytes(val, val_size));
40223caaf19SDaniel Mack
40323caaf19SDaniel Mack return 0;
40423caaf19SDaniel Mack }
40523caaf19SDaniel Mack
get_ctl_value(struct usb_mixer_elem_info * cval,int request,int validx,int * value_ret)4066bc170e4SDaniel Mack static int get_ctl_value(struct usb_mixer_elem_info *cval, int request,
4076bc170e4SDaniel Mack int validx, int *value_ret)
40823caaf19SDaniel Mack {
4099f814105SEldad Zack validx += cval->idx_off;
4109f814105SEldad Zack
4113360b84bSTakashi Iwai return (cval->head.mixer->protocol == UAC_VERSION_1) ?
41223caaf19SDaniel Mack get_ctl_value_v1(cval, request, validx, value_ret) :
41323caaf19SDaniel Mack get_ctl_value_v2(cval, request, validx, value_ret);
41423caaf19SDaniel Mack }
41523caaf19SDaniel Mack
get_cur_ctl_value(struct usb_mixer_elem_info * cval,int validx,int * value)4166bc170e4SDaniel Mack static int get_cur_ctl_value(struct usb_mixer_elem_info *cval,
4176bc170e4SDaniel Mack int validx, int *value)
418f0b5e634SDaniel Mack {
419f0b5e634SDaniel Mack return get_ctl_value(cval, UAC_GET_CUR, validx, value);
420f0b5e634SDaniel Mack }
421f0b5e634SDaniel Mack
422f0b5e634SDaniel Mack /* channel = 0: master, 1 = first channel */
get_cur_mix_raw(struct usb_mixer_elem_info * cval,int channel,int * value)423f0b5e634SDaniel Mack static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
424f0b5e634SDaniel Mack int channel, int *value)
425f0b5e634SDaniel Mack {
4266bc170e4SDaniel Mack return get_ctl_value(cval, UAC_GET_CUR,
4276bc170e4SDaniel Mack (cval->control << 8) | channel,
4286bc170e4SDaniel Mack value);
429f0b5e634SDaniel Mack }
430f0b5e634SDaniel Mack
snd_usb_get_cur_mix_value(struct usb_mixer_elem_info * cval,int channel,int index,int * value)431eef90451SChris J Arges int snd_usb_get_cur_mix_value(struct usb_mixer_elem_info *cval,
432f0b5e634SDaniel Mack int channel, int index, int *value)
433f0b5e634SDaniel Mack {
434f0b5e634SDaniel Mack int err;
435f0b5e634SDaniel Mack
436f0b5e634SDaniel Mack if (cval->cached & (1 << channel)) {
437f0b5e634SDaniel Mack *value = cval->cache_val[index];
438f0b5e634SDaniel Mack return 0;
439f0b5e634SDaniel Mack }
440f0b5e634SDaniel Mack err = get_cur_mix_raw(cval, channel, value);
441f0b5e634SDaniel Mack if (err < 0) {
4423360b84bSTakashi Iwai if (!cval->head.mixer->ignore_ctl_error)
4433360b84bSTakashi Iwai usb_audio_dbg(cval->head.mixer->chip,
4440ba41d91STakashi Iwai "cannot get current value for control %d ch %d: err = %d\n",
445f0b5e634SDaniel Mack cval->control, channel, err);
446f0b5e634SDaniel Mack return err;
447f0b5e634SDaniel Mack }
448f0b5e634SDaniel Mack cval->cached |= 1 << channel;
449f0b5e634SDaniel Mack cval->cache_val[index] = *value;
450f0b5e634SDaniel Mack return 0;
451f0b5e634SDaniel Mack }
452f0b5e634SDaniel Mack
453f0b5e634SDaniel Mack /*
454f0b5e634SDaniel Mack * set a mixer value
455f0b5e634SDaniel Mack */
456f0b5e634SDaniel Mack
snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info * cval,int request,int validx,int value_set)457f0b5e634SDaniel Mack int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
458f0b5e634SDaniel Mack int request, int validx, int value_set)
459f0b5e634SDaniel Mack {
4603360b84bSTakashi Iwai struct snd_usb_audio *chip = cval->head.mixer->chip;
461bc18e31cSJulian Scheel unsigned char buf[4];
462978520b7STakashi Iwai int idx = 0, val_len, err, timeout = 10;
46323caaf19SDaniel Mack
4649f814105SEldad Zack validx += cval->idx_off;
4659f814105SEldad Zack
4669a2fe9b8SRuslan Bilovol
4673360b84bSTakashi Iwai if (cval->head.mixer->protocol == UAC_VERSION_1) {
46823caaf19SDaniel Mack val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
4699a2fe9b8SRuslan Bilovol } else { /* UAC_VERSION_2/3 */
470bc18e31cSJulian Scheel val_len = uac2_ctl_value_size(cval->val_type);
47123caaf19SDaniel Mack
47223caaf19SDaniel Mack /* FIXME */
47323caaf19SDaniel Mack if (request != UAC_SET_CUR) {
4740ba41d91STakashi Iwai usb_audio_dbg(chip, "RANGE setting not yet supported\n");
47523caaf19SDaniel Mack return -EINVAL;
47623caaf19SDaniel Mack }
47723caaf19SDaniel Mack
47823caaf19SDaniel Mack request = UAC2_CS_CUR;
47923caaf19SDaniel Mack }
480f0b5e634SDaniel Mack
481f0b5e634SDaniel Mack value_set = convert_bytes_value(cval, value_set);
482f0b5e634SDaniel Mack buf[0] = value_set & 0xff;
483f0b5e634SDaniel Mack buf[1] = (value_set >> 8) & 0xff;
484bc18e31cSJulian Scheel buf[2] = (value_set >> 16) & 0xff;
485bc18e31cSJulian Scheel buf[3] = (value_set >> 24) & 0xff;
48647ab1545STakashi Iwai
48747ab1545STakashi Iwai err = snd_usb_lock_shutdown(chip);
48888a8516aSOliver Neukum if (err < 0)
48988a8516aSOliver Neukum return -EIO;
49047ab1545STakashi Iwai
491978520b7STakashi Iwai while (timeout-- > 0) {
4920aef31b7SChris Wulff idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
4935a9a8ecaSStephen Barber err = snd_usb_ctl_msg(chip->dev,
4943d8d4dcfSDaniel Mack usb_sndctrlpipe(chip->dev, 0), request,
495f0b5e634SDaniel Mack USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
4965a9a8ecaSStephen Barber validx, idx, buf, val_len);
4975a9a8ecaSStephen Barber if (err >= 0) {
498978520b7STakashi Iwai err = 0;
499978520b7STakashi Iwai goto out;
5005a9a8ecaSStephen Barber } else if (err == -ETIMEDOUT) {
5015a9a8ecaSStephen Barber goto out;
50288a8516aSOliver Neukum }
503978520b7STakashi Iwai }
5040ba41d91STakashi Iwai usb_audio_dbg(chip, "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
505978520b7STakashi Iwai request, validx, idx, cval->val_type, buf[0], buf[1]);
506978520b7STakashi Iwai err = -EINVAL;
507978520b7STakashi Iwai
508978520b7STakashi Iwai out:
50947ab1545STakashi Iwai snd_usb_unlock_shutdown(chip);
510978520b7STakashi Iwai return err;
511f0b5e634SDaniel Mack }
512f0b5e634SDaniel Mack
set_cur_ctl_value(struct usb_mixer_elem_info * cval,int validx,int value)5136bc170e4SDaniel Mack static int set_cur_ctl_value(struct usb_mixer_elem_info *cval,
5146bc170e4SDaniel Mack int validx, int value)
515f0b5e634SDaniel Mack {
516f0b5e634SDaniel Mack return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
517f0b5e634SDaniel Mack }
518f0b5e634SDaniel Mack
snd_usb_set_cur_mix_value(struct usb_mixer_elem_info * cval,int channel,int index,int value)519eef90451SChris J Arges int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
520f0b5e634SDaniel Mack int index, int value)
521f0b5e634SDaniel Mack {
522f0b5e634SDaniel Mack int err;
523a6a33259SDaniel Mack unsigned int read_only = (channel == 0) ?
524a6a33259SDaniel Mack cval->master_readonly :
525a6a33259SDaniel Mack cval->ch_readonly & (1 << (channel - 1));
526a6a33259SDaniel Mack
527a6a33259SDaniel Mack if (read_only) {
5283360b84bSTakashi Iwai usb_audio_dbg(cval->head.mixer->chip,
5290ba41d91STakashi Iwai "%s(): channel %d of control %d is read_only\n",
530a6a33259SDaniel Mack __func__, channel, cval->control);
531a6a33259SDaniel Mack return 0;
532a6a33259SDaniel Mack }
533a6a33259SDaniel Mack
5346bc170e4SDaniel Mack err = snd_usb_mixer_set_ctl_value(cval,
5356bc170e4SDaniel Mack UAC_SET_CUR, (cval->control << 8) | channel,
536f0b5e634SDaniel Mack value);
537f0b5e634SDaniel Mack if (err < 0)
538f0b5e634SDaniel Mack return err;
539f0b5e634SDaniel Mack cval->cached |= 1 << channel;
540f0b5e634SDaniel Mack cval->cache_val[index] = value;
541f0b5e634SDaniel Mack return 0;
542f0b5e634SDaniel Mack }
543f0b5e634SDaniel Mack
544f0b5e634SDaniel Mack /*
545f0b5e634SDaniel Mack * TLV callback for mixer volume controls
546f0b5e634SDaniel Mack */
snd_usb_mixer_vol_tlv(struct snd_kcontrol * kcontrol,int op_flag,unsigned int size,unsigned int __user * _tlv)547285de9c0SFelix Homann int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
548f0b5e634SDaniel Mack unsigned int size, unsigned int __user *_tlv)
549f0b5e634SDaniel Mack {
550f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
551f0b5e634SDaniel Mack DECLARE_TLV_DB_MINMAX(scale, 0, 0);
552f0b5e634SDaniel Mack
553f0b5e634SDaniel Mack if (size < sizeof(scale))
554f0b5e634SDaniel Mack return -ENOMEM;
5550f174b35STakashi Iwai if (cval->min_mute)
5560f174b35STakashi Iwai scale[0] = SNDRV_CTL_TLVT_DB_MINMAX_MUTE;
557f0b5e634SDaniel Mack scale[2] = cval->dBmin;
558f0b5e634SDaniel Mack scale[3] = cval->dBmax;
559f0b5e634SDaniel Mack if (copy_to_user(_tlv, scale, sizeof(scale)))
560f0b5e634SDaniel Mack return -EFAULT;
561f0b5e634SDaniel Mack return 0;
562f0b5e634SDaniel Mack }
563f0b5e634SDaniel Mack
564f0b5e634SDaniel Mack /*
565f0b5e634SDaniel Mack * parser routines begin here...
566f0b5e634SDaniel Mack */
567f0b5e634SDaniel Mack
568f0b5e634SDaniel Mack static int parse_audio_unit(struct mixer_build *state, int unitid);
569f0b5e634SDaniel Mack
570f0b5e634SDaniel Mack
571f0b5e634SDaniel Mack /*
572f0b5e634SDaniel Mack * check if the input/output channel routing is enabled on the given bitmap.
573f0b5e634SDaniel Mack * used for mixer unit parser
574f0b5e634SDaniel Mack */
check_matrix_bitmap(unsigned char * bmap,int ich,int och,int num_outs)5756bc170e4SDaniel Mack static int check_matrix_bitmap(unsigned char *bmap,
5766bc170e4SDaniel Mack int ich, int och, int num_outs)
577f0b5e634SDaniel Mack {
578f0b5e634SDaniel Mack int idx = ich * num_outs + och;
579f0b5e634SDaniel Mack return bmap[idx >> 3] & (0x80 >> (idx & 7));
580f0b5e634SDaniel Mack }
581f0b5e634SDaniel Mack
582f0b5e634SDaniel Mack /*
583f0b5e634SDaniel Mack * add an alsa control element
584f0b5e634SDaniel Mack * search and increment the index until an empty slot is found.
585f0b5e634SDaniel Mack *
586f0b5e634SDaniel Mack * if failed, give up and free the control instance.
587f0b5e634SDaniel Mack */
588f0b5e634SDaniel Mack
snd_usb_mixer_add_list(struct usb_mixer_elem_list * list,struct snd_kcontrol * kctl,bool is_std_info)589220345e9STakashi Iwai int snd_usb_mixer_add_list(struct usb_mixer_elem_list *list,
590220345e9STakashi Iwai struct snd_kcontrol *kctl,
591220345e9STakashi Iwai bool is_std_info)
592f0b5e634SDaniel Mack {
5933360b84bSTakashi Iwai struct usb_mixer_interface *mixer = list->mixer;
594f0b5e634SDaniel Mack int err;
595f0b5e634SDaniel Mack
596ef9d5970SDaniel Mack while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
597f0b5e634SDaniel Mack kctl->id.index++;
598f25ecf8fSTakashi Iwai err = snd_ctl_add(mixer->chip->card, kctl);
599f25ecf8fSTakashi Iwai if (err < 0) {
6006bc170e4SDaniel Mack usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n",
6016bc170e4SDaniel Mack err);
602f0b5e634SDaniel Mack return err;
603f0b5e634SDaniel Mack }
6043360b84bSTakashi Iwai list->kctl = kctl;
605220345e9STakashi Iwai list->is_std_info = is_std_info;
6063360b84bSTakashi Iwai list->next_id_elem = mixer->id_elems[list->id];
6073360b84bSTakashi Iwai mixer->id_elems[list->id] = list;
608f0b5e634SDaniel Mack return 0;
609f0b5e634SDaniel Mack }
610f0b5e634SDaniel Mack
611f0b5e634SDaniel Mack /*
612f0b5e634SDaniel Mack * get a terminal name string
613f0b5e634SDaniel Mack */
614f0b5e634SDaniel Mack
615f0b5e634SDaniel Mack static struct iterm_name_combo {
616f0b5e634SDaniel Mack int type;
617f0b5e634SDaniel Mack char *name;
618f0b5e634SDaniel Mack } iterm_names[] = {
619f0b5e634SDaniel Mack { 0x0300, "Output" },
620f0b5e634SDaniel Mack { 0x0301, "Speaker" },
621f0b5e634SDaniel Mack { 0x0302, "Headphone" },
622f0b5e634SDaniel Mack { 0x0303, "HMD Audio" },
623f0b5e634SDaniel Mack { 0x0304, "Desktop Speaker" },
624f0b5e634SDaniel Mack { 0x0305, "Room Speaker" },
625f0b5e634SDaniel Mack { 0x0306, "Com Speaker" },
626f0b5e634SDaniel Mack { 0x0307, "LFE" },
627f0b5e634SDaniel Mack { 0x0600, "External In" },
628f0b5e634SDaniel Mack { 0x0601, "Analog In" },
629f0b5e634SDaniel Mack { 0x0602, "Digital In" },
630f0b5e634SDaniel Mack { 0x0603, "Line" },
631f0b5e634SDaniel Mack { 0x0604, "Legacy In" },
632f0b5e634SDaniel Mack { 0x0605, "IEC958 In" },
633f0b5e634SDaniel Mack { 0x0606, "1394 DA Stream" },
634f0b5e634SDaniel Mack { 0x0607, "1394 DV Stream" },
635f0b5e634SDaniel Mack { 0x0700, "Embedded" },
636f0b5e634SDaniel Mack { 0x0701, "Noise Source" },
637f0b5e634SDaniel Mack { 0x0702, "Equalization Noise" },
638f0b5e634SDaniel Mack { 0x0703, "CD" },
639f0b5e634SDaniel Mack { 0x0704, "DAT" },
640f0b5e634SDaniel Mack { 0x0705, "DCC" },
641f0b5e634SDaniel Mack { 0x0706, "MiniDisk" },
642f0b5e634SDaniel Mack { 0x0707, "Analog Tape" },
643f0b5e634SDaniel Mack { 0x0708, "Phonograph" },
644f0b5e634SDaniel Mack { 0x0709, "VCR Audio" },
645f0b5e634SDaniel Mack { 0x070a, "Video Disk Audio" },
646f0b5e634SDaniel Mack { 0x070b, "DVD Audio" },
647f0b5e634SDaniel Mack { 0x070c, "TV Tuner Audio" },
648f0b5e634SDaniel Mack { 0x070d, "Satellite Rec Audio" },
649f0b5e634SDaniel Mack { 0x070e, "Cable Tuner Audio" },
650f0b5e634SDaniel Mack { 0x070f, "DSS Audio" },
651f0b5e634SDaniel Mack { 0x0710, "Radio Receiver" },
652f0b5e634SDaniel Mack { 0x0711, "Radio Transmitter" },
653f0b5e634SDaniel Mack { 0x0712, "Multi-Track Recorder" },
654f0b5e634SDaniel Mack { 0x0713, "Synthesizer" },
655f0b5e634SDaniel Mack { 0 },
656f0b5e634SDaniel Mack };
657f0b5e634SDaniel Mack
get_term_name(struct snd_usb_audio * chip,struct usb_audio_term * iterm,unsigned char * name,int maxlen,int term_only)658eccfc1b8SRuslan Bilovol static int get_term_name(struct snd_usb_audio *chip, struct usb_audio_term *iterm,
659f0b5e634SDaniel Mack unsigned char *name, int maxlen, int term_only)
660f0b5e634SDaniel Mack {
661f0b5e634SDaniel Mack struct iterm_name_combo *names;
66256a23ee5STakashi Iwai int len;
663f0b5e634SDaniel Mack
66456a23ee5STakashi Iwai if (iterm->name) {
665eccfc1b8SRuslan Bilovol len = snd_usb_copy_string_desc(chip, iterm->name,
6666bc170e4SDaniel Mack name, maxlen);
66756a23ee5STakashi Iwai if (len)
66856a23ee5STakashi Iwai return len;
66956a23ee5STakashi Iwai }
670f0b5e634SDaniel Mack
671f0b5e634SDaniel Mack /* virtual type - not a real terminal */
672f0b5e634SDaniel Mack if (iterm->type >> 16) {
673f0b5e634SDaniel Mack if (term_only)
674f0b5e634SDaniel Mack return 0;
675f0b5e634SDaniel Mack switch (iterm->type >> 16) {
6768b3a087fSJorge Sanjuan case UAC3_SELECTOR_UNIT:
6776bc170e4SDaniel Mack strcpy(name, "Selector");
6786bc170e4SDaniel Mack return 8;
6798b3a087fSJorge Sanjuan case UAC3_PROCESSING_UNIT:
6806bc170e4SDaniel Mack strcpy(name, "Process Unit");
6816bc170e4SDaniel Mack return 12;
6828b3a087fSJorge Sanjuan case UAC3_EXTENSION_UNIT:
6836bc170e4SDaniel Mack strcpy(name, "Ext Unit");
6846bc170e4SDaniel Mack return 8;
6858b3a087fSJorge Sanjuan case UAC3_MIXER_UNIT:
6866bc170e4SDaniel Mack strcpy(name, "Mixer");
6876bc170e4SDaniel Mack return 5;
688f0b5e634SDaniel Mack default:
689f0b5e634SDaniel Mack return sprintf(name, "Unit %d", iterm->id);
690f0b5e634SDaniel Mack }
691f0b5e634SDaniel Mack }
692f0b5e634SDaniel Mack
693f0b5e634SDaniel Mack switch (iterm->type & 0xff00) {
694f0b5e634SDaniel Mack case 0x0100:
6956bc170e4SDaniel Mack strcpy(name, "PCM");
6966bc170e4SDaniel Mack return 3;
697f0b5e634SDaniel Mack case 0x0200:
6986bc170e4SDaniel Mack strcpy(name, "Mic");
6996bc170e4SDaniel Mack return 3;
700f0b5e634SDaniel Mack case 0x0400:
7016bc170e4SDaniel Mack strcpy(name, "Headset");
7026bc170e4SDaniel Mack return 7;
703f0b5e634SDaniel Mack case 0x0500:
7046bc170e4SDaniel Mack strcpy(name, "Phone");
7056bc170e4SDaniel Mack return 5;
706f0b5e634SDaniel Mack }
707f0b5e634SDaniel Mack
7086bc170e4SDaniel Mack for (names = iterm_names; names->type; names++) {
709f0b5e634SDaniel Mack if (names->type == iterm->type) {
710f0b5e634SDaniel Mack strcpy(name, names->name);
711f0b5e634SDaniel Mack return strlen(names->name);
712f0b5e634SDaniel Mack }
713f0b5e634SDaniel Mack }
714f0b5e634SDaniel Mack
7156bc170e4SDaniel Mack return 0;
7166bc170e4SDaniel Mack }
717f0b5e634SDaniel Mack
718f0b5e634SDaniel Mack /*
7196cfd839aSJorge Sanjuan * Get logical cluster information for UAC3 devices.
7206cfd839aSJorge Sanjuan */
get_cluster_channels_v3(struct mixer_build * state,unsigned int cluster_id)7216cfd839aSJorge Sanjuan static int get_cluster_channels_v3(struct mixer_build *state, unsigned int cluster_id)
7226cfd839aSJorge Sanjuan {
7236cfd839aSJorge Sanjuan struct uac3_cluster_header_descriptor c_header;
7246cfd839aSJorge Sanjuan int err;
7256cfd839aSJorge Sanjuan
7266cfd839aSJorge Sanjuan err = snd_usb_ctl_msg(state->chip->dev,
7276cfd839aSJorge Sanjuan usb_rcvctrlpipe(state->chip->dev, 0),
7286cfd839aSJorge Sanjuan UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
7296cfd839aSJorge Sanjuan USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
7306cfd839aSJorge Sanjuan cluster_id,
7316cfd839aSJorge Sanjuan snd_usb_ctrl_intf(state->chip),
7326cfd839aSJorge Sanjuan &c_header, sizeof(c_header));
7336cfd839aSJorge Sanjuan if (err < 0)
7346cfd839aSJorge Sanjuan goto error;
7356cfd839aSJorge Sanjuan if (err != sizeof(c_header)) {
7366cfd839aSJorge Sanjuan err = -EIO;
7376cfd839aSJorge Sanjuan goto error;
7386cfd839aSJorge Sanjuan }
7396cfd839aSJorge Sanjuan
7406cfd839aSJorge Sanjuan return c_header.bNrChannels;
7416cfd839aSJorge Sanjuan
7426cfd839aSJorge Sanjuan error:
7436cfd839aSJorge Sanjuan usb_audio_err(state->chip, "cannot request logical cluster ID: %d (err: %d)\n", cluster_id, err);
7446cfd839aSJorge Sanjuan return err;
7456cfd839aSJorge Sanjuan }
7466cfd839aSJorge Sanjuan
7476cfd839aSJorge Sanjuan /*
7486cfd839aSJorge Sanjuan * Get number of channels for a Mixer Unit.
7496cfd839aSJorge Sanjuan */
uac_mixer_unit_get_channels(struct mixer_build * state,struct uac_mixer_unit_descriptor * desc)7506cfd839aSJorge Sanjuan static int uac_mixer_unit_get_channels(struct mixer_build *state,
7516cfd839aSJorge Sanjuan struct uac_mixer_unit_descriptor *desc)
7526cfd839aSJorge Sanjuan {
7536cfd839aSJorge Sanjuan int mu_channels;
7546cfd839aSJorge Sanjuan
7556cfd839aSJorge Sanjuan switch (state->mixer->protocol) {
7566cfd839aSJorge Sanjuan case UAC_VERSION_1:
7576cfd839aSJorge Sanjuan case UAC_VERSION_2:
7586cfd839aSJorge Sanjuan default:
7590bfe5e43STakashi Iwai if (desc->bLength < sizeof(*desc) + desc->bNrInPins + 1)
7600bfe5e43STakashi Iwai return 0; /* no bmControls -> skip */
7616cfd839aSJorge Sanjuan mu_channels = uac_mixer_unit_bNrChannels(desc);
7626cfd839aSJorge Sanjuan break;
7636cfd839aSJorge Sanjuan case UAC_VERSION_3:
7646cfd839aSJorge Sanjuan mu_channels = get_cluster_channels_v3(state,
7656cfd839aSJorge Sanjuan uac3_mixer_unit_wClusterDescrID(desc));
7666cfd839aSJorge Sanjuan break;
7676cfd839aSJorge Sanjuan }
7686cfd839aSJorge Sanjuan
7696cfd839aSJorge Sanjuan return mu_channels;
7706cfd839aSJorge Sanjuan }
7716cfd839aSJorge Sanjuan
7726cfd839aSJorge Sanjuan /*
773e0ccdef9STakashi Iwai * Parse Input Terminal Unit
774f0b5e634SDaniel Mack */
77519bce474SHui Peng static int __check_input_term(struct mixer_build *state, int id,
776e0ccdef9STakashi Iwai struct usb_audio_term *term);
777e0ccdef9STakashi Iwai
parse_term_uac1_iterm_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)778e0ccdef9STakashi Iwai static int parse_term_uac1_iterm_unit(struct mixer_build *state,
779e0ccdef9STakashi Iwai struct usb_audio_term *term,
780e0ccdef9STakashi Iwai void *p1, int id)
781f0b5e634SDaniel Mack {
78223caaf19SDaniel Mack struct uac_input_terminal_descriptor *d = p1;
7839a2fe9b8SRuslan Bilovol
78423caaf19SDaniel Mack term->type = le16_to_cpu(d->wTerminalType);
78523caaf19SDaniel Mack term->channels = d->bNrChannels;
78623caaf19SDaniel Mack term->chconfig = le16_to_cpu(d->wChannelConfig);
78723caaf19SDaniel Mack term->name = d->iTerminal;
788e0ccdef9STakashi Iwai return 0;
789e0ccdef9STakashi Iwai }
7909430e547SJulian Scheel
parse_term_uac2_iterm_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)791e0ccdef9STakashi Iwai static int parse_term_uac2_iterm_unit(struct mixer_build *state,
792e0ccdef9STakashi Iwai struct usb_audio_term *term,
793e0ccdef9STakashi Iwai void *p1, int id)
794e0ccdef9STakashi Iwai {
795e0ccdef9STakashi Iwai struct uac2_input_terminal_descriptor *d = p1;
796e0ccdef9STakashi Iwai int err;
797e0ccdef9STakashi Iwai
798e0ccdef9STakashi Iwai /* call recursively to verify the referenced clock entity */
79919bce474SHui Peng err = __check_input_term(state, d->bCSourceID, term);
8009430e547SJulian Scheel if (err < 0)
8019430e547SJulian Scheel return err;
8029430e547SJulian Scheel
8039430e547SJulian Scheel /* save input term properties after recursion,
804e0ccdef9STakashi Iwai * to ensure they are not overriden by the recursion calls
805e0ccdef9STakashi Iwai */
8069430e547SJulian Scheel term->id = id;
80723caaf19SDaniel Mack term->type = le16_to_cpu(d->wTerminalType);
80823caaf19SDaniel Mack term->channels = d->bNrChannels;
80923caaf19SDaniel Mack term->chconfig = le32_to_cpu(d->bmChannelConfig);
81023caaf19SDaniel Mack term->name = d->iTerminal;
8115dae5fd2SEldad Zack return 0;
8125dae5fd2SEldad Zack }
8135dae5fd2SEldad Zack
parse_term_uac3_iterm_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)814e0ccdef9STakashi Iwai static int parse_term_uac3_iterm_unit(struct mixer_build *state,
815e0ccdef9STakashi Iwai struct usb_audio_term *term,
816e0ccdef9STakashi Iwai void *p1, int id)
817e0ccdef9STakashi Iwai {
8189a2fe9b8SRuslan Bilovol struct uac3_input_terminal_descriptor *d = p1;
819e0ccdef9STakashi Iwai int err;
8209a2fe9b8SRuslan Bilovol
821e0ccdef9STakashi Iwai /* call recursively to verify the referenced clock entity */
82219bce474SHui Peng err = __check_input_term(state, d->bCSourceID, term);
8239a2fe9b8SRuslan Bilovol if (err < 0)
8249a2fe9b8SRuslan Bilovol return err;
8259a2fe9b8SRuslan Bilovol
8269a2fe9b8SRuslan Bilovol /* save input term properties after recursion,
827e0ccdef9STakashi Iwai * to ensure they are not overriden by the recursion calls
828e0ccdef9STakashi Iwai */
8299a2fe9b8SRuslan Bilovol term->id = id;
8309a2fe9b8SRuslan Bilovol term->type = le16_to_cpu(d->wTerminalType);
8319a2fe9b8SRuslan Bilovol
83271066945SJorge Sanjuan err = get_cluster_channels_v3(state, le16_to_cpu(d->wClusterDescrID));
83371066945SJorge Sanjuan if (err < 0)
83471066945SJorge Sanjuan return err;
83571066945SJorge Sanjuan term->channels = err;
83671066945SJorge Sanjuan
83771066945SJorge Sanjuan /* REVISIT: UAC3 IT doesn't have channels cfg */
8389a2fe9b8SRuslan Bilovol term->chconfig = 0;
8399a2fe9b8SRuslan Bilovol
8409a2fe9b8SRuslan Bilovol term->name = le16_to_cpu(d->wTerminalDescrStr);
8419a2fe9b8SRuslan Bilovol return 0;
8429a2fe9b8SRuslan Bilovol }
8439a2fe9b8SRuslan Bilovol
parse_term_mixer_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)844e0ccdef9STakashi Iwai static int parse_term_mixer_unit(struct mixer_build *state,
845e0ccdef9STakashi Iwai struct usb_audio_term *term,
846e0ccdef9STakashi Iwai void *p1, int id)
847e0ccdef9STakashi Iwai {
848e0ccdef9STakashi Iwai struct uac_mixer_unit_descriptor *d = p1;
849e0ccdef9STakashi Iwai int protocol = state->mixer->protocol;
850e0ccdef9STakashi Iwai int err;
851e0ccdef9STakashi Iwai
852e0ccdef9STakashi Iwai err = uac_mixer_unit_get_channels(state, d);
853e0ccdef9STakashi Iwai if (err <= 0)
854e0ccdef9STakashi Iwai return err;
855e0ccdef9STakashi Iwai
856e0ccdef9STakashi Iwai term->type = UAC3_MIXER_UNIT << 16; /* virtual type */
857e0ccdef9STakashi Iwai term->channels = err;
858e0ccdef9STakashi Iwai if (protocol != UAC_VERSION_3) {
859e0ccdef9STakashi Iwai term->chconfig = uac_mixer_unit_wChannelConfig(d, protocol);
860e0ccdef9STakashi Iwai term->name = uac_mixer_unit_iMixer(d);
8619a2fe9b8SRuslan Bilovol }
862e0ccdef9STakashi Iwai return 0;
863e0ccdef9STakashi Iwai }
864e0ccdef9STakashi Iwai
parse_term_selector_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)865e0ccdef9STakashi Iwai static int parse_term_selector_unit(struct mixer_build *state,
866e0ccdef9STakashi Iwai struct usb_audio_term *term,
867e0ccdef9STakashi Iwai void *p1, int id)
868e0ccdef9STakashi Iwai {
869e0ccdef9STakashi Iwai struct uac_selector_unit_descriptor *d = p1;
870e0ccdef9STakashi Iwai int err;
871e0ccdef9STakashi Iwai
872e0ccdef9STakashi Iwai /* call recursively to retrieve the channel info */
873e0ccdef9STakashi Iwai err = __check_input_term(state, d->baSourceID[0], term);
874e0ccdef9STakashi Iwai if (err < 0)
875e0ccdef9STakashi Iwai return err;
876e0ccdef9STakashi Iwai term->type = UAC3_SELECTOR_UNIT << 16; /* virtual type */
877e0ccdef9STakashi Iwai term->id = id;
878e0ccdef9STakashi Iwai if (state->mixer->protocol != UAC_VERSION_3)
879e0ccdef9STakashi Iwai term->name = uac_selector_unit_iSelector(d);
880e0ccdef9STakashi Iwai return 0;
881e0ccdef9STakashi Iwai }
882e0ccdef9STakashi Iwai
parse_term_proc_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id,int vtype)883e0ccdef9STakashi Iwai static int parse_term_proc_unit(struct mixer_build *state,
884e0ccdef9STakashi Iwai struct usb_audio_term *term,
885e0ccdef9STakashi Iwai void *p1, int id, int vtype)
886e0ccdef9STakashi Iwai {
887e0ccdef9STakashi Iwai struct uac_processing_unit_descriptor *d = p1;
888e0ccdef9STakashi Iwai int protocol = state->mixer->protocol;
889e0ccdef9STakashi Iwai int err;
890e0ccdef9STakashi Iwai
891e0ccdef9STakashi Iwai if (d->bNrInPins) {
892e0ccdef9STakashi Iwai /* call recursively to retrieve the channel info */
893e0ccdef9STakashi Iwai err = __check_input_term(state, d->baSourceID[0], term);
894e0ccdef9STakashi Iwai if (err < 0)
895e0ccdef9STakashi Iwai return err;
896e0ccdef9STakashi Iwai }
897e0ccdef9STakashi Iwai
898e0ccdef9STakashi Iwai term->type = vtype << 16; /* virtual type */
899e0ccdef9STakashi Iwai term->id = id;
900e0ccdef9STakashi Iwai
901e0ccdef9STakashi Iwai if (protocol == UAC_VERSION_3)
902e0ccdef9STakashi Iwai return 0;
903e0ccdef9STakashi Iwai
904e0ccdef9STakashi Iwai if (!term->channels) {
905e0ccdef9STakashi Iwai term->channels = uac_processing_unit_bNrChannels(d);
906e0ccdef9STakashi Iwai term->chconfig = uac_processing_unit_wChannelConfig(d, protocol);
907e0ccdef9STakashi Iwai }
908e0ccdef9STakashi Iwai term->name = uac_processing_unit_iProcessing(d, protocol);
909e0ccdef9STakashi Iwai return 0;
910e0ccdef9STakashi Iwai }
911e0ccdef9STakashi Iwai
parse_term_effect_unit(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)912d75a170fSTakashi Iwai static int parse_term_effect_unit(struct mixer_build *state,
913d75a170fSTakashi Iwai struct usb_audio_term *term,
914d75a170fSTakashi Iwai void *p1, int id)
915d75a170fSTakashi Iwai {
91660081b35STakashi Iwai struct uac2_effect_unit_descriptor *d = p1;
91760081b35STakashi Iwai int err;
91860081b35STakashi Iwai
91960081b35STakashi Iwai err = __check_input_term(state, d->bSourceID, term);
92060081b35STakashi Iwai if (err < 0)
92160081b35STakashi Iwai return err;
922d75a170fSTakashi Iwai term->type = UAC3_EFFECT_UNIT << 16; /* virtual type */
923d75a170fSTakashi Iwai term->id = id;
924d75a170fSTakashi Iwai return 0;
925d75a170fSTakashi Iwai }
926d75a170fSTakashi Iwai
parse_term_uac2_clock_source(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)927e0ccdef9STakashi Iwai static int parse_term_uac2_clock_source(struct mixer_build *state,
928e0ccdef9STakashi Iwai struct usb_audio_term *term,
929e0ccdef9STakashi Iwai void *p1, int id)
930e0ccdef9STakashi Iwai {
931e0ccdef9STakashi Iwai struct uac_clock_source_descriptor *d = p1;
932e0ccdef9STakashi Iwai
933e0ccdef9STakashi Iwai term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */
934e0ccdef9STakashi Iwai term->id = id;
935e0ccdef9STakashi Iwai term->name = d->iClockSource;
936e0ccdef9STakashi Iwai return 0;
937e0ccdef9STakashi Iwai }
938e0ccdef9STakashi Iwai
parse_term_uac3_clock_source(struct mixer_build * state,struct usb_audio_term * term,void * p1,int id)939e0ccdef9STakashi Iwai static int parse_term_uac3_clock_source(struct mixer_build *state,
940e0ccdef9STakashi Iwai struct usb_audio_term *term,
941e0ccdef9STakashi Iwai void *p1, int id)
942e0ccdef9STakashi Iwai {
9439a2fe9b8SRuslan Bilovol struct uac3_clock_source_descriptor *d = p1;
9449a2fe9b8SRuslan Bilovol
9458b3a087fSJorge Sanjuan term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */
9469a2fe9b8SRuslan Bilovol term->id = id;
9479a2fe9b8SRuslan Bilovol term->name = le16_to_cpu(d->wClockSourceStr);
9489a2fe9b8SRuslan Bilovol return 0;
9499a2fe9b8SRuslan Bilovol }
9506cfd839aSJorge Sanjuan
951e0ccdef9STakashi Iwai #define PTYPE(a, b) ((a) << 8 | (b))
9526cfd839aSJorge Sanjuan
953e0ccdef9STakashi Iwai /*
954e0ccdef9STakashi Iwai * parse the source unit recursively until it reaches to a terminal
955e0ccdef9STakashi Iwai * or a branched unit.
956e0ccdef9STakashi Iwai */
__check_input_term(struct mixer_build * state,int id,struct usb_audio_term * term)957e0ccdef9STakashi Iwai static int __check_input_term(struct mixer_build *state, int id,
958e0ccdef9STakashi Iwai struct usb_audio_term *term)
959e0ccdef9STakashi Iwai {
960e0ccdef9STakashi Iwai int protocol = state->mixer->protocol;
961e0ccdef9STakashi Iwai void *p1;
962e0ccdef9STakashi Iwai unsigned char *hdr;
9636cfd839aSJorge Sanjuan
964e0ccdef9STakashi Iwai for (;;) {
965e0ccdef9STakashi Iwai /* a loop in the terminal chain? */
966e0ccdef9STakashi Iwai if (test_and_set_bit(id, state->termbitmap))
9670f292f02SJorge Sanjuan return -EINVAL;
9680f292f02SJorge Sanjuan
969e0ccdef9STakashi Iwai p1 = find_audio_control_unit(state, id);
970e0ccdef9STakashi Iwai if (!p1)
971e0ccdef9STakashi Iwai break;
972e0ccdef9STakashi Iwai if (!snd_usb_validate_audio_desc(p1, protocol))
973e0ccdef9STakashi Iwai break; /* bad descriptor */
9740f292f02SJorge Sanjuan
975e0ccdef9STakashi Iwai hdr = p1;
9760f292f02SJorge Sanjuan term->id = id;
9770f292f02SJorge Sanjuan
978e0ccdef9STakashi Iwai switch (PTYPE(protocol, hdr[2])) {
979e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT):
980e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT):
981e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT): {
982e0ccdef9STakashi Iwai /* the header is the same for all versions */
983e0ccdef9STakashi Iwai struct uac_feature_unit_descriptor *d = p1;
984e0ccdef9STakashi Iwai
985e0ccdef9STakashi Iwai id = d->bSourceID;
986e0ccdef9STakashi Iwai break; /* continue to parse */
9870f292f02SJorge Sanjuan }
988e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL):
989e0ccdef9STakashi Iwai return parse_term_uac1_iterm_unit(state, term, p1, id);
990e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL):
991e0ccdef9STakashi Iwai return parse_term_uac2_iterm_unit(state, term, p1, id);
992e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL):
993e0ccdef9STakashi Iwai return parse_term_uac3_iterm_unit(state, term, p1, id);
994e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT):
995e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT):
996e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT):
997e0ccdef9STakashi Iwai return parse_term_mixer_unit(state, term, p1, id);
998e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT):
999e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT):
1000e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR):
1001e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT):
1002e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR):
1003e0ccdef9STakashi Iwai return parse_term_selector_unit(state, term, p1, id);
1004e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT):
1005e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2):
1006e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT):
1007e0ccdef9STakashi Iwai return parse_term_proc_unit(state, term, p1, id,
1008e0ccdef9STakashi Iwai UAC3_PROCESSING_UNIT);
1009e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT):
1010e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT):
1011d75a170fSTakashi Iwai return parse_term_effect_unit(state, term, p1, id);
1012e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT):
1013e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2):
1014e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT):
1015e0ccdef9STakashi Iwai return parse_term_proc_unit(state, term, p1, id,
1016e0ccdef9STakashi Iwai UAC3_EXTENSION_UNIT);
1017e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE):
1018e0ccdef9STakashi Iwai return parse_term_uac2_clock_source(state, term, p1, id);
1019e0ccdef9STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE):
1020e0ccdef9STakashi Iwai return parse_term_uac3_clock_source(state, term, p1, id);
10219a2fe9b8SRuslan Bilovol default:
10229a2fe9b8SRuslan Bilovol return -ENODEV;
10239a2fe9b8SRuslan Bilovol }
10249a2fe9b8SRuslan Bilovol }
1025f0b5e634SDaniel Mack return -ENODEV;
1026f0b5e634SDaniel Mack }
1027f0b5e634SDaniel Mack
102819bce474SHui Peng
check_input_term(struct mixer_build * state,int id,struct usb_audio_term * term)102919bce474SHui Peng static int check_input_term(struct mixer_build *state, int id,
103019bce474SHui Peng struct usb_audio_term *term)
103119bce474SHui Peng {
103219bce474SHui Peng memset(term, 0, sizeof(*term));
103319bce474SHui Peng memset(state->termbitmap, 0, sizeof(state->termbitmap));
103419bce474SHui Peng return __check_input_term(state, id, term);
103519bce474SHui Peng }
103619bce474SHui Peng
1037f0b5e634SDaniel Mack /*
1038f0b5e634SDaniel Mack * Feature Unit
1039f0b5e634SDaniel Mack */
1040f0b5e634SDaniel Mack
1041f0b5e634SDaniel Mack /* feature unit control information */
1042f0b5e634SDaniel Mack struct usb_feature_control_info {
104321e9b3e9SAndrew Chant int control;
1044f0b5e634SDaniel Mack const char *name;
1045bc18e31cSJulian Scheel int type; /* data type for uac1 */
1046bc18e31cSJulian Scheel int type_uac2; /* data type for uac2 if different from uac1, else -1 */
1047f0b5e634SDaniel Mack };
1048f0b5e634SDaniel Mack
1049a01df925STakashi Iwai static const struct usb_feature_control_info audio_feature_info[] = {
105021e9b3e9SAndrew Chant { UAC_FU_MUTE, "Mute", USB_MIXER_INV_BOOLEAN, -1 },
105121e9b3e9SAndrew Chant { UAC_FU_VOLUME, "Volume", USB_MIXER_S16, -1 },
105221e9b3e9SAndrew Chant { UAC_FU_BASS, "Tone Control - Bass", USB_MIXER_S8, -1 },
105321e9b3e9SAndrew Chant { UAC_FU_MID, "Tone Control - Mid", USB_MIXER_S8, -1 },
105421e9b3e9SAndrew Chant { UAC_FU_TREBLE, "Tone Control - Treble", USB_MIXER_S8, -1 },
105521e9b3e9SAndrew Chant { UAC_FU_GRAPHIC_EQUALIZER, "Graphic Equalizer", USB_MIXER_S8, -1 }, /* FIXME: not implemented yet */
105621e9b3e9SAndrew Chant { UAC_FU_AUTOMATIC_GAIN, "Auto Gain Control", USB_MIXER_BOOLEAN, -1 },
105721e9b3e9SAndrew Chant { UAC_FU_DELAY, "Delay Control", USB_MIXER_U16, USB_MIXER_U32 },
105821e9b3e9SAndrew Chant { UAC_FU_BASS_BOOST, "Bass Boost", USB_MIXER_BOOLEAN, -1 },
105921e9b3e9SAndrew Chant { UAC_FU_LOUDNESS, "Loudness", USB_MIXER_BOOLEAN, -1 },
10602e0281d1SDaniel Mack /* UAC2 specific */
106121e9b3e9SAndrew Chant { UAC2_FU_INPUT_GAIN, "Input Gain Control", USB_MIXER_S16, -1 },
106221e9b3e9SAndrew Chant { UAC2_FU_INPUT_GAIN_PAD, "Input Gain Pad Control", USB_MIXER_S16, -1 },
106321e9b3e9SAndrew Chant { UAC2_FU_PHASE_INVERTER, "Phase Inverter Control", USB_MIXER_BOOLEAN, -1 },
1064f0b5e634SDaniel Mack };
1065f0b5e634SDaniel Mack
usb_mixer_elem_info_free(struct usb_mixer_elem_info * cval)106652c3e317STakashi Iwai static void usb_mixer_elem_info_free(struct usb_mixer_elem_info *cval)
106752c3e317STakashi Iwai {
106852c3e317STakashi Iwai kfree(cval);
106952c3e317STakashi Iwai }
107052c3e317STakashi Iwai
1071f0b5e634SDaniel Mack /* private_free callback */
snd_usb_mixer_elem_free(struct snd_kcontrol * kctl)1072eef90451SChris J Arges void snd_usb_mixer_elem_free(struct snd_kcontrol *kctl)
1073f0b5e634SDaniel Mack {
107452c3e317STakashi Iwai usb_mixer_elem_info_free(kctl->private_data);
1075f0b5e634SDaniel Mack kctl->private_data = NULL;
1076f0b5e634SDaniel Mack }
1077f0b5e634SDaniel Mack
1078f0b5e634SDaniel Mack /*
1079f0b5e634SDaniel Mack * interface to ALSA control for feature/mixer units
1080f0b5e634SDaniel Mack */
1081f0b5e634SDaniel Mack
1082dcaaf9f2STakashi Iwai /* volume control quirks */
volume_control_quirks(struct usb_mixer_elem_info * cval,struct snd_kcontrol * kctl)1083dcaaf9f2STakashi Iwai static void volume_control_quirks(struct usb_mixer_elem_info *cval,
1084dcaaf9f2STakashi Iwai struct snd_kcontrol *kctl)
1085dcaaf9f2STakashi Iwai {
10863360b84bSTakashi Iwai struct snd_usb_audio *chip = cval->head.mixer->chip;
10870ba41d91STakashi Iwai switch (chip->usb_id) {
1088d50ed624SEldad Zack case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
1089e9a25e04SMatt Gruskin case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
1090d50ed624SEldad Zack if (strcmp(kctl->id.name, "Effect Duration") == 0) {
1091d50ed624SEldad Zack cval->min = 0x0000;
1092d50ed624SEldad Zack cval->max = 0xffff;
1093d50ed624SEldad Zack cval->res = 0x00e6;
1094d50ed624SEldad Zack break;
1095d50ed624SEldad Zack }
1096d50ed624SEldad Zack if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
1097d50ed624SEldad Zack strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
1098d50ed624SEldad Zack cval->min = 0x00;
1099d50ed624SEldad Zack cval->max = 0xff;
1100d50ed624SEldad Zack break;
1101d50ed624SEldad Zack }
1102d50ed624SEldad Zack if (strstr(kctl->id.name, "Effect Return") != NULL) {
1103d50ed624SEldad Zack cval->min = 0xb706;
1104d50ed624SEldad Zack cval->max = 0xff7b;
1105d50ed624SEldad Zack cval->res = 0x0073;
1106d50ed624SEldad Zack break;
1107d50ed624SEldad Zack }
1108d50ed624SEldad Zack if ((strstr(kctl->id.name, "Playback Volume") != NULL) ||
1109d50ed624SEldad Zack (strstr(kctl->id.name, "Effect Send") != NULL)) {
1110d50ed624SEldad Zack cval->min = 0xb5fb; /* -73 dB = 0xb6ff */
1111d50ed624SEldad Zack cval->max = 0xfcfe;
1112d50ed624SEldad Zack cval->res = 0x0073;
1113d50ed624SEldad Zack }
1114d50ed624SEldad Zack break;
1115d50ed624SEldad Zack
1116d34bf148SFelix Homann case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
1117d34bf148SFelix Homann case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1118d34bf148SFelix Homann if (strcmp(kctl->id.name, "Effect Duration") == 0) {
11190ba41d91STakashi Iwai usb_audio_info(chip,
11200ba41d91STakashi Iwai "set quirk for FTU Effect Duration\n");
1121d34bf148SFelix Homann cval->min = 0x0000;
1122d34bf148SFelix Homann cval->max = 0x7f00;
1123d34bf148SFelix Homann cval->res = 0x0100;
1124d34bf148SFelix Homann break;
1125d34bf148SFelix Homann }
1126d34bf148SFelix Homann if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
1127d34bf148SFelix Homann strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
11280ba41d91STakashi Iwai usb_audio_info(chip,
11290ba41d91STakashi Iwai "set quirks for FTU Effect Feedback/Volume\n");
1130d34bf148SFelix Homann cval->min = 0x00;
1131d34bf148SFelix Homann cval->max = 0x7f;
1132d34bf148SFelix Homann break;
1133d34bf148SFelix Homann }
1134d34bf148SFelix Homann break;
1135d34bf148SFelix Homann
113621493316SFederico Cuello case USB_ID(0x0d8c, 0x0103):
113721493316SFederico Cuello if (!strcmp(kctl->id.name, "PCM Playback Volume")) {
113821493316SFederico Cuello usb_audio_info(chip,
113921493316SFederico Cuello "set volume quirk for CM102-A+/102S+\n");
114021493316SFederico Cuello cval->min = -256;
114121493316SFederico Cuello }
114221493316SFederico Cuello break;
114321493316SFederico Cuello
1144dcaaf9f2STakashi Iwai case USB_ID(0x0471, 0x0101):
1145dcaaf9f2STakashi Iwai case USB_ID(0x0471, 0x0104):
1146dcaaf9f2STakashi Iwai case USB_ID(0x0471, 0x0105):
1147dcaaf9f2STakashi Iwai case USB_ID(0x0672, 0x1041):
1148dcaaf9f2STakashi Iwai /* quirk for UDA1321/N101.
1149dcaaf9f2STakashi Iwai * note that detection between firmware 2.1.1.7 (N101)
1150dcaaf9f2STakashi Iwai * and later 2.1.1.21 is not very clear from datasheets.
1151dcaaf9f2STakashi Iwai * I hope that the min value is -15360 for newer firmware --jk
1152dcaaf9f2STakashi Iwai */
1153dcaaf9f2STakashi Iwai if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
1154dcaaf9f2STakashi Iwai cval->min == -15616) {
11550ba41d91STakashi Iwai usb_audio_info(chip,
1156dcaaf9f2STakashi Iwai "set volume quirk for UDA1321/N101 chip\n");
1157dcaaf9f2STakashi Iwai cval->max = -256;
1158dcaaf9f2STakashi Iwai }
1159dcaaf9f2STakashi Iwai break;
1160dcaaf9f2STakashi Iwai
1161dcaaf9f2STakashi Iwai case USB_ID(0x046d, 0x09a4):
1162dcaaf9f2STakashi Iwai if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
11630ba41d91STakashi Iwai usb_audio_info(chip,
1164dcaaf9f2STakashi Iwai "set volume quirk for QuickCam E3500\n");
1165dcaaf9f2STakashi Iwai cval->min = 6080;
1166dcaaf9f2STakashi Iwai cval->max = 8768;
1167dcaaf9f2STakashi Iwai cval->res = 192;
1168dcaaf9f2STakashi Iwai }
1169dcaaf9f2STakashi Iwai break;
1170dcaaf9f2STakashi Iwai
1171e805ca8bSTakashi Iwai case USB_ID(0x046d, 0x0807): /* Logitech Webcam C500 */
1172dcaaf9f2STakashi Iwai case USB_ID(0x046d, 0x0808):
1173dcaaf9f2STakashi Iwai case USB_ID(0x046d, 0x0809):
117464559311SJason Lee Cragg case USB_ID(0x046d, 0x0819): /* Logitech Webcam C210 */
117536691e1bSTakashi Iwai case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */
117655c0008bSAlexey Fisher case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
117711e7064fSTakashi Iwai case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */
1178140d37deSMaksim A. Boyko case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */
11791ef9f058SWolfram Sang case USB_ID(0x046d, 0x08ca): /* Logitech Quickcam Fusion */
1180dcaaf9f2STakashi Iwai case USB_ID(0x046d, 0x0991):
118182ffb6fcSCon Kolivas case USB_ID(0x046d, 0x09a2): /* QuickCam Communicate Deluxe/S7500 */
1182dcaaf9f2STakashi Iwai /* Most audio usb devices lie about volume resolution.
1183dcaaf9f2STakashi Iwai * Most Logitech webcams have res = 384.
118482ffb6fcSCon Kolivas * Probably there is some logitech magic behind this number --fishor
1185dcaaf9f2STakashi Iwai */
1186dcaaf9f2STakashi Iwai if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
11870ba41d91STakashi Iwai usb_audio_info(chip,
1188dcaaf9f2STakashi Iwai "set resolution quirk: cval->res = 384\n");
1189dcaaf9f2STakashi Iwai cval->res = 384;
1190dcaaf9f2STakashi Iwai }
1191dcaaf9f2STakashi Iwai break;
11924020d1ccSChris Chiu case USB_ID(0x0495, 0x3042): /* ESS Technology Asus USB DAC */
11934020d1ccSChris Chiu if ((strstr(kctl->id.name, "Playback Volume") != NULL) ||
11944020d1ccSChris Chiu strstr(kctl->id.name, "Capture Volume") != NULL) {
11954020d1ccSChris Chiu cval->min >>= 8;
11964020d1ccSChris Chiu cval->max = 0;
11974020d1ccSChris Chiu cval->res = 1;
11984020d1ccSChris Chiu }
11994020d1ccSChris Chiu break;
120029664923SMarco Giunta case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */
120129664923SMarco Giunta if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
120229664923SMarco Giunta usb_audio_info(chip,
120329664923SMarco Giunta "set resolution quirk: cval->res = 16\n");
120429664923SMarco Giunta cval->res = 16;
120529664923SMarco Giunta }
120629664923SMarco Giunta break;
1207*4a63e68aSChristos Skevis case USB_ID(0x1bcf, 0x2283): /* NexiGo N930AF FHD Webcam */
1208*4a63e68aSChristos Skevis if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
1209*4a63e68aSChristos Skevis usb_audio_info(chip,
1210*4a63e68aSChristos Skevis "set resolution quirk: cval->res = 16\n");
1211*4a63e68aSChristos Skevis cval->res = 16;
1212*4a63e68aSChristos Skevis }
1213*4a63e68aSChristos Skevis break;
1214dcaaf9f2STakashi Iwai }
1215dcaaf9f2STakashi Iwai }
1216dcaaf9f2STakashi Iwai
1217b96681bdSTakashi Iwai /* forcibly initialize the current mixer value; if GET_CUR fails, set to
1218b96681bdSTakashi Iwai * the minimum as default
1219b96681bdSTakashi Iwai */
init_cur_mix_raw(struct usb_mixer_elem_info * cval,int ch,int idx)1220b96681bdSTakashi Iwai static void init_cur_mix_raw(struct usb_mixer_elem_info *cval, int ch, int idx)
1221b96681bdSTakashi Iwai {
1222b96681bdSTakashi Iwai int val, err;
1223b96681bdSTakashi Iwai
1224b96681bdSTakashi Iwai err = snd_usb_get_cur_mix_value(cval, ch, idx, &val);
1225b96681bdSTakashi Iwai if (!err)
1226b96681bdSTakashi Iwai return;
1227b96681bdSTakashi Iwai if (!cval->head.mixer->ignore_ctl_error)
1228b96681bdSTakashi Iwai usb_audio_warn(cval->head.mixer->chip,
1229b96681bdSTakashi Iwai "%d:%d: failed to get current value for ch %d (%d)\n",
1230b96681bdSTakashi Iwai cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1231b96681bdSTakashi Iwai ch, err);
1232b96681bdSTakashi Iwai snd_usb_set_cur_mix_value(cval, ch, idx, cval->min);
1233b96681bdSTakashi Iwai }
1234b96681bdSTakashi Iwai
1235f0b5e634SDaniel Mack /*
1236f0b5e634SDaniel Mack * retrieve the minimum and maximum values for the specified control
1237f0b5e634SDaniel Mack */
get_min_max_with_quirks(struct usb_mixer_elem_info * cval,int default_min,struct snd_kcontrol * kctl)1238dcaaf9f2STakashi Iwai static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
1239dcaaf9f2STakashi Iwai int default_min, struct snd_kcontrol *kctl)
1240f0b5e634SDaniel Mack {
1241b96681bdSTakashi Iwai int i, idx;
1242b96681bdSTakashi Iwai
1243f0b5e634SDaniel Mack /* for failsafe */
1244f0b5e634SDaniel Mack cval->min = default_min;
1245f0b5e634SDaniel Mack cval->max = cval->min + 1;
1246f0b5e634SDaniel Mack cval->res = 1;
1247f0b5e634SDaniel Mack cval->dBmin = cval->dBmax = 0;
1248f0b5e634SDaniel Mack
1249f0b5e634SDaniel Mack if (cval->val_type == USB_MIXER_BOOLEAN ||
1250f0b5e634SDaniel Mack cval->val_type == USB_MIXER_INV_BOOLEAN) {
1251f0b5e634SDaniel Mack cval->initialized = 1;
1252f0b5e634SDaniel Mack } else {
1253f0b5e634SDaniel Mack int minchn = 0;
1254f0b5e634SDaniel Mack if (cval->cmask) {
1255f0b5e634SDaniel Mack for (i = 0; i < MAX_CHANNELS; i++)
1256f0b5e634SDaniel Mack if (cval->cmask & (1 << i)) {
1257f0b5e634SDaniel Mack minchn = i + 1;
1258f0b5e634SDaniel Mack break;
1259f0b5e634SDaniel Mack }
1260f0b5e634SDaniel Mack }
1261f0b5e634SDaniel Mack if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
1262f0b5e634SDaniel Mack get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
12633360b84bSTakashi Iwai usb_audio_err(cval->head.mixer->chip,
12640ba41d91STakashi Iwai "%d:%d: cannot get min/max values for control %d (id %d)\n",
12650aef31b7SChris Wulff cval->head.id, mixer_ctrl_intf(cval->head.mixer),
12663360b84bSTakashi Iwai cval->control, cval->head.id);
1267f0b5e634SDaniel Mack return -EINVAL;
1268f0b5e634SDaniel Mack }
12696bc170e4SDaniel Mack if (get_ctl_value(cval, UAC_GET_RES,
12706bc170e4SDaniel Mack (cval->control << 8) | minchn,
12716bc170e4SDaniel Mack &cval->res) < 0) {
1272f0b5e634SDaniel Mack cval->res = 1;
127385db1cfbSTakashi Iwai } else if (cval->head.mixer->protocol == UAC_VERSION_1) {
1274f0b5e634SDaniel Mack int last_valid_res = cval->res;
1275f0b5e634SDaniel Mack
1276f0b5e634SDaniel Mack while (cval->res > 1) {
1277f0b5e634SDaniel Mack if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
12786bc170e4SDaniel Mack (cval->control << 8) | minchn,
12796bc170e4SDaniel Mack cval->res / 2) < 0)
1280f0b5e634SDaniel Mack break;
1281f0b5e634SDaniel Mack cval->res /= 2;
1282f0b5e634SDaniel Mack }
12836bc170e4SDaniel Mack if (get_ctl_value(cval, UAC_GET_RES,
12846bc170e4SDaniel Mack (cval->control << 8) | minchn, &cval->res) < 0)
1285f0b5e634SDaniel Mack cval->res = last_valid_res;
1286f0b5e634SDaniel Mack }
1287f0b5e634SDaniel Mack if (cval->res == 0)
1288f0b5e634SDaniel Mack cval->res = 1;
1289f0b5e634SDaniel Mack
1290f0b5e634SDaniel Mack /* Additional checks for the proper resolution
1291f0b5e634SDaniel Mack *
1292f0b5e634SDaniel Mack * Some devices report smaller resolutions than actually
1293f0b5e634SDaniel Mack * reacting. They don't return errors but simply clip
1294f0b5e634SDaniel Mack * to the lower aligned value.
1295f0b5e634SDaniel Mack */
1296f0b5e634SDaniel Mack if (cval->min + cval->res < cval->max) {
1297f0b5e634SDaniel Mack int last_valid_res = cval->res;
1298f0b5e634SDaniel Mack int saved, test, check;
1299167beb17STakashi Iwai if (get_cur_mix_raw(cval, minchn, &saved) < 0)
1300167beb17STakashi Iwai goto no_res_check;
1301f0b5e634SDaniel Mack for (;;) {
1302f0b5e634SDaniel Mack test = saved;
1303f0b5e634SDaniel Mack if (test < cval->max)
1304f0b5e634SDaniel Mack test += cval->res;
1305f0b5e634SDaniel Mack else
1306f0b5e634SDaniel Mack test -= cval->res;
1307f0b5e634SDaniel Mack if (test < cval->min || test > cval->max ||
1308eef90451SChris J Arges snd_usb_set_cur_mix_value(cval, minchn, 0, test) ||
1309f0b5e634SDaniel Mack get_cur_mix_raw(cval, minchn, &check)) {
1310f0b5e634SDaniel Mack cval->res = last_valid_res;
1311f0b5e634SDaniel Mack break;
1312f0b5e634SDaniel Mack }
1313f0b5e634SDaniel Mack if (test == check)
1314f0b5e634SDaniel Mack break;
1315f0b5e634SDaniel Mack cval->res *= 2;
1316f0b5e634SDaniel Mack }
1317eef90451SChris J Arges snd_usb_set_cur_mix_value(cval, minchn, 0, saved);
1318f0b5e634SDaniel Mack }
1319f0b5e634SDaniel Mack
1320167beb17STakashi Iwai no_res_check:
1321f0b5e634SDaniel Mack cval->initialized = 1;
1322f0b5e634SDaniel Mack }
1323f0b5e634SDaniel Mack
1324dcaaf9f2STakashi Iwai if (kctl)
1325dcaaf9f2STakashi Iwai volume_control_quirks(cval, kctl);
1326dcaaf9f2STakashi Iwai
1327f0b5e634SDaniel Mack /* USB descriptions contain the dB scale in 1/256 dB unit
1328f0b5e634SDaniel Mack * while ALSA TLV contains in 1/100 dB unit
1329f0b5e634SDaniel Mack */
1330f0b5e634SDaniel Mack cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
1331f0b5e634SDaniel Mack cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
1332f0b5e634SDaniel Mack if (cval->dBmin > cval->dBmax) {
1333f0b5e634SDaniel Mack /* something is wrong; assume it's either from/to 0dB */
1334f0b5e634SDaniel Mack if (cval->dBmin < 0)
1335f0b5e634SDaniel Mack cval->dBmax = 0;
1336f0b5e634SDaniel Mack else if (cval->dBmin > 0)
1337f0b5e634SDaniel Mack cval->dBmin = 0;
1338f0b5e634SDaniel Mack if (cval->dBmin > cval->dBmax) {
1339f0b5e634SDaniel Mack /* totally crap, return an error */
1340f0b5e634SDaniel Mack return -EINVAL;
1341f0b5e634SDaniel Mack }
134221cba9c5STakashi Iwai } else {
134321cba9c5STakashi Iwai /* if the max volume is too low, it's likely a bogus range;
134421cba9c5STakashi Iwai * here we use -96dB as the threshold
134521cba9c5STakashi Iwai */
134621cba9c5STakashi Iwai if (cval->dBmax <= -9600) {
134721cba9c5STakashi Iwai usb_audio_info(cval->head.mixer->chip,
134821cba9c5STakashi Iwai "%d:%d: bogus dB values (%d/%d), disabling dB reporting\n",
134921cba9c5STakashi Iwai cval->head.id, mixer_ctrl_intf(cval->head.mixer),
135021cba9c5STakashi Iwai cval->dBmin, cval->dBmax);
135121cba9c5STakashi Iwai cval->dBmin = cval->dBmax = 0;
135221cba9c5STakashi Iwai }
1353f0b5e634SDaniel Mack }
1354f0b5e634SDaniel Mack
1355b96681bdSTakashi Iwai /* initialize all elements */
1356b96681bdSTakashi Iwai if (!cval->cmask) {
1357b96681bdSTakashi Iwai init_cur_mix_raw(cval, 0, 0);
1358b96681bdSTakashi Iwai } else {
1359b96681bdSTakashi Iwai idx = 0;
1360b96681bdSTakashi Iwai for (i = 0; i < MAX_CHANNELS; i++) {
1361b96681bdSTakashi Iwai if (cval->cmask & (1 << i)) {
1362b96681bdSTakashi Iwai init_cur_mix_raw(cval, i + 1, idx);
1363b96681bdSTakashi Iwai idx++;
1364b96681bdSTakashi Iwai }
1365b96681bdSTakashi Iwai }
1366b96681bdSTakashi Iwai }
1367b96681bdSTakashi Iwai
1368f0b5e634SDaniel Mack return 0;
1369f0b5e634SDaniel Mack }
1370f0b5e634SDaniel Mack
1371dcaaf9f2STakashi Iwai #define get_min_max(cval, def) get_min_max_with_quirks(cval, def, NULL)
1372f0b5e634SDaniel Mack
1373f0b5e634SDaniel Mack /* get a feature/mixer unit info */
mixer_ctl_feature_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)13746bc170e4SDaniel Mack static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol,
13756bc170e4SDaniel Mack struct snd_ctl_elem_info *uinfo)
1376f0b5e634SDaniel Mack {
1377f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
1378f0b5e634SDaniel Mack
1379f0b5e634SDaniel Mack if (cval->val_type == USB_MIXER_BOOLEAN ||
1380f0b5e634SDaniel Mack cval->val_type == USB_MIXER_INV_BOOLEAN)
1381f0b5e634SDaniel Mack uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1382f0b5e634SDaniel Mack else
1383f0b5e634SDaniel Mack uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1384f0b5e634SDaniel Mack uinfo->count = cval->channels;
1385f0b5e634SDaniel Mack if (cval->val_type == USB_MIXER_BOOLEAN ||
1386f0b5e634SDaniel Mack cval->val_type == USB_MIXER_INV_BOOLEAN) {
1387f0b5e634SDaniel Mack uinfo->value.integer.min = 0;
1388f0b5e634SDaniel Mack uinfo->value.integer.max = 1;
1389f0b5e634SDaniel Mack } else {
13909fcd0ab1STakashi Iwai if (!cval->initialized) {
1391dcaaf9f2STakashi Iwai get_min_max_with_quirks(cval, 0, kcontrol);
13929fcd0ab1STakashi Iwai if (cval->initialized && cval->dBmin >= cval->dBmax) {
13939fcd0ab1STakashi Iwai kcontrol->vd[0].access &=
13949fcd0ab1STakashi Iwai ~(SNDRV_CTL_ELEM_ACCESS_TLV_READ |
13959fcd0ab1STakashi Iwai SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK);
13963360b84bSTakashi Iwai snd_ctl_notify(cval->head.mixer->chip->card,
13979fcd0ab1STakashi Iwai SNDRV_CTL_EVENT_MASK_INFO,
13989fcd0ab1STakashi Iwai &kcontrol->id);
13999fcd0ab1STakashi Iwai }
14009fcd0ab1STakashi Iwai }
1401f0b5e634SDaniel Mack uinfo->value.integer.min = 0;
1402f0b5e634SDaniel Mack uinfo->value.integer.max =
1403e4d8aef2SLars-Peter Clausen DIV_ROUND_UP(cval->max - cval->min, cval->res);
1404f0b5e634SDaniel Mack }
1405f0b5e634SDaniel Mack return 0;
1406f0b5e634SDaniel Mack }
1407f0b5e634SDaniel Mack
1408f0b5e634SDaniel Mack /* get the current value from feature/mixer unit */
mixer_ctl_feature_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)14096bc170e4SDaniel Mack static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol,
14106bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
1411f0b5e634SDaniel Mack {
1412f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
1413f0b5e634SDaniel Mack int c, cnt, val, err;
1414f0b5e634SDaniel Mack
1415f0b5e634SDaniel Mack ucontrol->value.integer.value[0] = cval->min;
1416f0b5e634SDaniel Mack if (cval->cmask) {
1417f0b5e634SDaniel Mack cnt = 0;
1418f0b5e634SDaniel Mack for (c = 0; c < MAX_CHANNELS; c++) {
1419f0b5e634SDaniel Mack if (!(cval->cmask & (1 << c)))
1420f0b5e634SDaniel Mack continue;
1421eef90451SChris J Arges err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &val);
1422f0b5e634SDaniel Mack if (err < 0)
14235aeee342STakashi Iwai return filter_error(cval, err);
1424f0b5e634SDaniel Mack val = get_relative_value(cval, val);
1425f0b5e634SDaniel Mack ucontrol->value.integer.value[cnt] = val;
1426f0b5e634SDaniel Mack cnt++;
1427f0b5e634SDaniel Mack }
1428f0b5e634SDaniel Mack return 0;
1429f0b5e634SDaniel Mack } else {
1430f0b5e634SDaniel Mack /* master channel */
1431eef90451SChris J Arges err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1432f0b5e634SDaniel Mack if (err < 0)
14335aeee342STakashi Iwai return filter_error(cval, err);
1434f0b5e634SDaniel Mack val = get_relative_value(cval, val);
1435f0b5e634SDaniel Mack ucontrol->value.integer.value[0] = val;
1436f0b5e634SDaniel Mack }
1437f0b5e634SDaniel Mack return 0;
1438f0b5e634SDaniel Mack }
1439f0b5e634SDaniel Mack
1440f0b5e634SDaniel Mack /* put the current value to feature/mixer unit */
mixer_ctl_feature_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)14416bc170e4SDaniel Mack static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
14426bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
1443f0b5e634SDaniel Mack {
1444f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
1445f0b5e634SDaniel Mack int c, cnt, val, oval, err;
1446f0b5e634SDaniel Mack int changed = 0;
1447f0b5e634SDaniel Mack
1448f0b5e634SDaniel Mack if (cval->cmask) {
1449f0b5e634SDaniel Mack cnt = 0;
1450f0b5e634SDaniel Mack for (c = 0; c < MAX_CHANNELS; c++) {
1451f0b5e634SDaniel Mack if (!(cval->cmask & (1 << c)))
1452f0b5e634SDaniel Mack continue;
1453eef90451SChris J Arges err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &oval);
1454f0b5e634SDaniel Mack if (err < 0)
14555aeee342STakashi Iwai return filter_error(cval, err);
1456f0b5e634SDaniel Mack val = ucontrol->value.integer.value[cnt];
1457f0b5e634SDaniel Mack val = get_abs_value(cval, val);
1458f0b5e634SDaniel Mack if (oval != val) {
1459eef90451SChris J Arges snd_usb_set_cur_mix_value(cval, c + 1, cnt, val);
1460f0b5e634SDaniel Mack changed = 1;
1461f0b5e634SDaniel Mack }
1462f0b5e634SDaniel Mack cnt++;
1463f0b5e634SDaniel Mack }
1464f0b5e634SDaniel Mack } else {
1465f0b5e634SDaniel Mack /* master channel */
1466eef90451SChris J Arges err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval);
1467f0b5e634SDaniel Mack if (err < 0)
14685aeee342STakashi Iwai return filter_error(cval, err);
1469f0b5e634SDaniel Mack val = ucontrol->value.integer.value[0];
1470f0b5e634SDaniel Mack val = get_abs_value(cval, val);
1471f0b5e634SDaniel Mack if (val != oval) {
1472eef90451SChris J Arges snd_usb_set_cur_mix_value(cval, 0, 0, val);
1473f0b5e634SDaniel Mack changed = 1;
1474f0b5e634SDaniel Mack }
1475f0b5e634SDaniel Mack }
1476f0b5e634SDaniel Mack return changed;
1477f0b5e634SDaniel Mack }
1478f0b5e634SDaniel Mack
1479568fa7e0SAndrew Chant /* get the boolean value from the master channel of a UAC control */
mixer_ctl_master_bool_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1480568fa7e0SAndrew Chant static int mixer_ctl_master_bool_get(struct snd_kcontrol *kcontrol,
14815a222e84SAndrew Chant struct snd_ctl_elem_value *ucontrol)
14825a222e84SAndrew Chant {
14835a222e84SAndrew Chant struct usb_mixer_elem_info *cval = kcontrol->private_data;
14845a222e84SAndrew Chant int val, err;
14855a222e84SAndrew Chant
14865a222e84SAndrew Chant err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
14875a222e84SAndrew Chant if (err < 0)
14885a222e84SAndrew Chant return filter_error(cval, err);
14895a222e84SAndrew Chant val = (val != 0);
14905a222e84SAndrew Chant ucontrol->value.integer.value[0] = val;
14915a222e84SAndrew Chant return 0;
14925a222e84SAndrew Chant }
14935a222e84SAndrew Chant
get_connector_value(struct usb_mixer_elem_info * cval,char * name,int * val)149469644fcaSKai-Heng Feng static int get_connector_value(struct usb_mixer_elem_info *cval,
149569644fcaSKai-Heng Feng char *name, int *val)
14961d38f5d8SJorge Sanjuan {
14971d38f5d8SJorge Sanjuan struct snd_usb_audio *chip = cval->head.mixer->chip;
149869644fcaSKai-Heng Feng int idx = 0, validx, ret;
14991d38f5d8SJorge Sanjuan
15001d38f5d8SJorge Sanjuan validx = cval->control << 8 | 0;
15011d38f5d8SJorge Sanjuan
15021d38f5d8SJorge Sanjuan ret = snd_usb_lock_shutdown(chip) ? -EIO : 0;
15031d38f5d8SJorge Sanjuan if (ret)
15041d38f5d8SJorge Sanjuan goto error;
15051d38f5d8SJorge Sanjuan
15060aef31b7SChris Wulff idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
15071d38f5d8SJorge Sanjuan if (cval->head.mixer->protocol == UAC_VERSION_2) {
15081d38f5d8SJorge Sanjuan struct uac2_connectors_ctl_blk uac2_conn;
15091d38f5d8SJorge Sanjuan
15101d38f5d8SJorge Sanjuan ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR,
15111d38f5d8SJorge Sanjuan USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
15121d38f5d8SJorge Sanjuan validx, idx, &uac2_conn, sizeof(uac2_conn));
151369644fcaSKai-Heng Feng if (val)
151469644fcaSKai-Heng Feng *val = !!uac2_conn.bNrChannels;
15151d38f5d8SJorge Sanjuan } else { /* UAC_VERSION_3 */
15161d38f5d8SJorge Sanjuan struct uac3_insertion_ctl_blk uac3_conn;
15171d38f5d8SJorge Sanjuan
15181d38f5d8SJorge Sanjuan ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR,
15191d38f5d8SJorge Sanjuan USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
15201d38f5d8SJorge Sanjuan validx, idx, &uac3_conn, sizeof(uac3_conn));
152169644fcaSKai-Heng Feng if (val)
152269644fcaSKai-Heng Feng *val = !!uac3_conn.bmConInserted;
15231d38f5d8SJorge Sanjuan }
15241d38f5d8SJorge Sanjuan
15251d38f5d8SJorge Sanjuan snd_usb_unlock_shutdown(chip);
15261d38f5d8SJorge Sanjuan
15271d38f5d8SJorge Sanjuan if (ret < 0) {
152869644fcaSKai-Heng Feng if (name && strstr(name, "Speaker")) {
152969644fcaSKai-Heng Feng if (val)
153069644fcaSKai-Heng Feng *val = 1;
1531f8c11eb7SKai-Heng Feng return 0;
1532f8c11eb7SKai-Heng Feng }
15331d38f5d8SJorge Sanjuan error:
15341d38f5d8SJorge Sanjuan usb_audio_err(chip,
15351d38f5d8SJorge Sanjuan "cannot get connectors status: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
15361d38f5d8SJorge Sanjuan UAC_GET_CUR, validx, idx, cval->val_type);
15373da4b740STom Rix
15383da4b740STom Rix if (val)
15393da4b740STom Rix *val = 0;
15403da4b740STom Rix
154148cc4297STakashi Iwai return filter_error(cval, ret);
15421d38f5d8SJorge Sanjuan }
15431d38f5d8SJorge Sanjuan
154469644fcaSKai-Heng Feng return ret;
154569644fcaSKai-Heng Feng }
154669644fcaSKai-Heng Feng
154769644fcaSKai-Heng Feng /* get the connectors status and report it as boolean type */
mixer_ctl_connector_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)154869644fcaSKai-Heng Feng static int mixer_ctl_connector_get(struct snd_kcontrol *kcontrol,
154969644fcaSKai-Heng Feng struct snd_ctl_elem_value *ucontrol)
155069644fcaSKai-Heng Feng {
155169644fcaSKai-Heng Feng struct usb_mixer_elem_info *cval = kcontrol->private_data;
155269644fcaSKai-Heng Feng int ret, val;
155369644fcaSKai-Heng Feng
155469644fcaSKai-Heng Feng ret = get_connector_value(cval, kcontrol->id.name, &val);
155569644fcaSKai-Heng Feng
155669644fcaSKai-Heng Feng if (ret < 0)
155769644fcaSKai-Heng Feng return ret;
155869644fcaSKai-Heng Feng
15591d38f5d8SJorge Sanjuan ucontrol->value.integer.value[0] = val;
15601d38f5d8SJorge Sanjuan return 0;
15611d38f5d8SJorge Sanjuan }
15621d38f5d8SJorge Sanjuan
1563195727e8STakashi Iwai static const struct snd_kcontrol_new usb_feature_unit_ctl = {
1564f0b5e634SDaniel Mack .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1565f0b5e634SDaniel Mack .name = "", /* will be filled later manually */
1566f0b5e634SDaniel Mack .info = mixer_ctl_feature_info,
1567f0b5e634SDaniel Mack .get = mixer_ctl_feature_get,
1568f0b5e634SDaniel Mack .put = mixer_ctl_feature_put,
1569f0b5e634SDaniel Mack };
1570f0b5e634SDaniel Mack
157123caaf19SDaniel Mack /* the read-only variant */
15728fdaebbbSBhumika Goyal static const struct snd_kcontrol_new usb_feature_unit_ctl_ro = {
157323caaf19SDaniel Mack .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
157423caaf19SDaniel Mack .name = "", /* will be filled later manually */
157523caaf19SDaniel Mack .info = mixer_ctl_feature_info,
157623caaf19SDaniel Mack .get = mixer_ctl_feature_get,
157723caaf19SDaniel Mack .put = NULL,
157823caaf19SDaniel Mack };
157923caaf19SDaniel Mack
1580568fa7e0SAndrew Chant /*
1581568fa7e0SAndrew Chant * A control which shows the boolean value from reading a UAC control on
1582568fa7e0SAndrew Chant * the master channel.
1583568fa7e0SAndrew Chant */
1584195727e8STakashi Iwai static const struct snd_kcontrol_new usb_bool_master_control_ctl_ro = {
15855a222e84SAndrew Chant .iface = SNDRV_CTL_ELEM_IFACE_CARD,
15865a222e84SAndrew Chant .name = "", /* will be filled later manually */
15875a222e84SAndrew Chant .access = SNDRV_CTL_ELEM_ACCESS_READ,
15885a222e84SAndrew Chant .info = snd_ctl_boolean_mono_info,
1589568fa7e0SAndrew Chant .get = mixer_ctl_master_bool_get,
15905a222e84SAndrew Chant .put = NULL,
15915a222e84SAndrew Chant };
15925a222e84SAndrew Chant
15931d38f5d8SJorge Sanjuan static const struct snd_kcontrol_new usb_connector_ctl_ro = {
15941d38f5d8SJorge Sanjuan .iface = SNDRV_CTL_ELEM_IFACE_CARD,
15951d38f5d8SJorge Sanjuan .name = "", /* will be filled later manually */
15961d38f5d8SJorge Sanjuan .access = SNDRV_CTL_ELEM_ACCESS_READ,
15971d38f5d8SJorge Sanjuan .info = snd_ctl_boolean_mono_info,
15981d38f5d8SJorge Sanjuan .get = mixer_ctl_connector_get,
15991d38f5d8SJorge Sanjuan .put = NULL,
16001d38f5d8SJorge Sanjuan };
16011d38f5d8SJorge Sanjuan
16026bc170e4SDaniel Mack /*
16036bc170e4SDaniel Mack * This symbol is exported in order to allow the mixer quirks to
16046bc170e4SDaniel Mack * hook up to the standard feature unit control mechanism
16056bc170e4SDaniel Mack */
1606195727e8STakashi Iwai const struct snd_kcontrol_new *snd_usb_feature_unit_ctl = &usb_feature_unit_ctl;
1607f0b5e634SDaniel Mack
1608f0b5e634SDaniel Mack /*
1609f0b5e634SDaniel Mack * build a feature control
1610f0b5e634SDaniel Mack */
append_ctl_name(struct snd_kcontrol * kctl,const char * str)1611f0b5e634SDaniel Mack static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
1612f0b5e634SDaniel Mack {
1613f0b5e634SDaniel Mack return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
1614f0b5e634SDaniel Mack }
1615f0b5e634SDaniel Mack
16166bc170e4SDaniel Mack /*
16176bc170e4SDaniel Mack * A lot of headsets/headphones have a "Speaker" mixer. Make sure we
16186bc170e4SDaniel Mack * rename it to "Headphone". We determine if something is a headphone
16196bc170e4SDaniel Mack * similar to how udev determines form factor.
16206bc170e4SDaniel Mack */
check_no_speaker_on_headset(struct snd_kcontrol * kctl,struct snd_card * card)16219b4ef977SDavid Henningsson static void check_no_speaker_on_headset(struct snd_kcontrol *kctl,
16229b4ef977SDavid Henningsson struct snd_card *card)
16239b4ef977SDavid Henningsson {
1624d1254593SColin Ian King static const char * const names_to_check[] = {
16259b4ef977SDavid Henningsson "Headset", "headset", "Headphone", "headphone", NULL};
1626d1254593SColin Ian King const char * const *s;
1627e0f17c75SPeter Senna Tschudin bool found = false;
16289b4ef977SDavid Henningsson
16299b4ef977SDavid Henningsson if (strcmp("Speaker", kctl->id.name))
16309b4ef977SDavid Henningsson return;
16319b4ef977SDavid Henningsson
16329b4ef977SDavid Henningsson for (s = names_to_check; *s; s++)
16339b4ef977SDavid Henningsson if (strstr(card->shortname, *s)) {
1634e0f17c75SPeter Senna Tschudin found = true;
16359b4ef977SDavid Henningsson break;
16369b4ef977SDavid Henningsson }
16379b4ef977SDavid Henningsson
16389b4ef977SDavid Henningsson if (!found)
16399b4ef977SDavid Henningsson return;
16409b4ef977SDavid Henningsson
16410b4f0debSMaciej S. Szmigiero snd_ctl_rename(card, kctl, "Headphone");
16429b4ef977SDavid Henningsson }
16439b4ef977SDavid Henningsson
get_feature_control_info(int control)1644a01df925STakashi Iwai static const struct usb_feature_control_info *get_feature_control_info(int control)
164521e9b3e9SAndrew Chant {
164621e9b3e9SAndrew Chant int i;
164721e9b3e9SAndrew Chant
164821e9b3e9SAndrew Chant for (i = 0; i < ARRAY_SIZE(audio_feature_info); ++i) {
164921e9b3e9SAndrew Chant if (audio_feature_info[i].control == control)
165021e9b3e9SAndrew Chant return &audio_feature_info[i];
165121e9b3e9SAndrew Chant }
165221e9b3e9SAndrew Chant return NULL;
165321e9b3e9SAndrew Chant }
165421e9b3e9SAndrew Chant
__build_feature_ctl(struct usb_mixer_interface * mixer,const struct usbmix_name_map * imap,unsigned int ctl_mask,int control,struct usb_audio_term * iterm,struct usb_audio_term * oterm,int unitid,int nameid,int readonly_mask)165517156f23SRuslan Bilovol static void __build_feature_ctl(struct usb_mixer_interface *mixer,
165617156f23SRuslan Bilovol const struct usbmix_name_map *imap,
1657f0b5e634SDaniel Mack unsigned int ctl_mask, int control,
165817156f23SRuslan Bilovol struct usb_audio_term *iterm,
165917156f23SRuslan Bilovol struct usb_audio_term *oterm,
166017156f23SRuslan Bilovol int unitid, int nameid, int readonly_mask)
1661f0b5e634SDaniel Mack {
1662a01df925STakashi Iwai const struct usb_feature_control_info *ctl_info;
1663f0b5e634SDaniel Mack unsigned int len = 0;
1664f0b5e634SDaniel Mack int mapped_name = 0;
1665f0b5e634SDaniel Mack struct snd_kcontrol *kctl;
1666f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval;
1667f0b5e634SDaniel Mack const struct usbmix_name_map *map;
166880acefffSAlexey Fisher unsigned int range;
1669f0b5e634SDaniel Mack
167065f25da4SDaniel Mack if (control == UAC_FU_GRAPHIC_EQUALIZER) {
1671f0b5e634SDaniel Mack /* FIXME: not supported yet */
1672f0b5e634SDaniel Mack return;
1673f0b5e634SDaniel Mack }
1674f0b5e634SDaniel Mack
167517156f23SRuslan Bilovol map = find_map(imap, unitid, control);
1676f0b5e634SDaniel Mack if (check_ignored_ctl(map))
1677f0b5e634SDaniel Mack return;
1678f0b5e634SDaniel Mack
1679f0b5e634SDaniel Mack cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1680a860d95fSDaniel Mack if (!cval)
1681f0b5e634SDaniel Mack return;
168217156f23SRuslan Bilovol snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1683f0b5e634SDaniel Mack cval->control = control;
1684f0b5e634SDaniel Mack cval->cmask = ctl_mask;
168521e9b3e9SAndrew Chant
168621e9b3e9SAndrew Chant ctl_info = get_feature_control_info(control);
168762376025SColin Ian King if (!ctl_info) {
168852c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
168921e9b3e9SAndrew Chant return;
169062376025SColin Ian King }
169117156f23SRuslan Bilovol if (mixer->protocol == UAC_VERSION_1)
1692bc18e31cSJulian Scheel cval->val_type = ctl_info->type;
1693bc18e31cSJulian Scheel else /* UAC_VERSION_2 */
1694bc18e31cSJulian Scheel cval->val_type = ctl_info->type_uac2 >= 0 ?
1695bc18e31cSJulian Scheel ctl_info->type_uac2 : ctl_info->type;
1696bc18e31cSJulian Scheel
1697a6a33259SDaniel Mack if (ctl_mask == 0) {
1698f0b5e634SDaniel Mack cval->channels = 1; /* master channel */
1699a6a33259SDaniel Mack cval->master_readonly = readonly_mask;
1700a6a33259SDaniel Mack } else {
1701f0b5e634SDaniel Mack int i, c = 0;
1702f0b5e634SDaniel Mack for (i = 0; i < 16; i++)
1703f0b5e634SDaniel Mack if (ctl_mask & (1 << i))
1704f0b5e634SDaniel Mack c++;
1705f0b5e634SDaniel Mack cval->channels = c;
1706a6a33259SDaniel Mack cval->ch_readonly = readonly_mask;
1707f0b5e634SDaniel Mack }
1708f0b5e634SDaniel Mack
17096bc170e4SDaniel Mack /*
17106bc170e4SDaniel Mack * If all channels in the mask are marked read-only, make the control
1711eef90451SChris J Arges * read-only. snd_usb_set_cur_mix_value() will check the mask again and won't
17126bc170e4SDaniel Mack * issue write commands to read-only channels.
17136bc170e4SDaniel Mack */
1714a6a33259SDaniel Mack if (cval->channels == readonly_mask)
171523caaf19SDaniel Mack kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
171623caaf19SDaniel Mack else
1717f0b5e634SDaniel Mack kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
171823caaf19SDaniel Mack
1719f0b5e634SDaniel Mack if (!kctl) {
172017156f23SRuslan Bilovol usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
172152c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
1722f0b5e634SDaniel Mack return;
1723f0b5e634SDaniel Mack }
1724eef90451SChris J Arges kctl->private_free = snd_usb_mixer_elem_free;
1725f0b5e634SDaniel Mack
1726f0b5e634SDaniel Mack len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1727f0b5e634SDaniel Mack mapped_name = len != 0;
1728f0b5e634SDaniel Mack if (!len && nameid)
172917156f23SRuslan Bilovol len = snd_usb_copy_string_desc(mixer->chip, nameid,
1730f0b5e634SDaniel Mack kctl->id.name, sizeof(kctl->id.name));
1731f0b5e634SDaniel Mack
1732f0b5e634SDaniel Mack switch (control) {
173365f25da4SDaniel Mack case UAC_FU_MUTE:
173465f25da4SDaniel Mack case UAC_FU_VOLUME:
17356bc170e4SDaniel Mack /*
17366bc170e4SDaniel Mack * determine the control name. the rule is:
1737f0b5e634SDaniel Mack * - if a name id is given in descriptor, use it.
1738f0b5e634SDaniel Mack * - if the connected input can be determined, then use the name
1739f0b5e634SDaniel Mack * of terminal type.
1740f0b5e634SDaniel Mack * - if the connected output can be determined, use it.
1741f0b5e634SDaniel Mack * - otherwise, anonymous name.
1742f0b5e634SDaniel Mack */
1743f0b5e634SDaniel Mack if (!len) {
174417156f23SRuslan Bilovol if (iterm)
174517156f23SRuslan Bilovol len = get_term_name(mixer->chip, iterm,
174617156f23SRuslan Bilovol kctl->id.name,
17476bc170e4SDaniel Mack sizeof(kctl->id.name), 1);
174817156f23SRuslan Bilovol if (!len && oterm)
174917156f23SRuslan Bilovol len = get_term_name(mixer->chip, oterm,
17506bc170e4SDaniel Mack kctl->id.name,
17516bc170e4SDaniel Mack sizeof(kctl->id.name), 1);
1752f0b5e634SDaniel Mack if (!len)
175349fd46d2SDaniel Mack snprintf(kctl->id.name, sizeof(kctl->id.name),
1754f0b5e634SDaniel Mack "Feature %d", unitid);
1755f0b5e634SDaniel Mack }
17569b4ef977SDavid Henningsson
17579b4ef977SDavid Henningsson if (!mapped_name)
175817156f23SRuslan Bilovol check_no_speaker_on_headset(kctl, mixer->chip->card);
17599b4ef977SDavid Henningsson
17606bc170e4SDaniel Mack /*
17616bc170e4SDaniel Mack * determine the stream direction:
1762f0b5e634SDaniel Mack * if the connected output is USB stream, then it's likely a
1763f0b5e634SDaniel Mack * capture stream. otherwise it should be playback (hopefully :)
1764f0b5e634SDaniel Mack */
176517156f23SRuslan Bilovol if (!mapped_name && oterm && !(oterm->type >> 16)) {
176617156f23SRuslan Bilovol if ((oterm->type & 0xff00) == 0x0100)
176749fd46d2SDaniel Mack append_ctl_name(kctl, " Capture");
17686bc170e4SDaniel Mack else
176949fd46d2SDaniel Mack append_ctl_name(kctl, " Playback");
1770f0b5e634SDaniel Mack }
177165f25da4SDaniel Mack append_ctl_name(kctl, control == UAC_FU_MUTE ?
1772f0b5e634SDaniel Mack " Switch" : " Volume");
1773e182534dSTakashi Iwai break;
1774e182534dSTakashi Iwai default:
1775e182534dSTakashi Iwai if (!len)
177675b1a8f9SJoe Perches strscpy(kctl->id.name, audio_feature_info[control-1].name,
1777e182534dSTakashi Iwai sizeof(kctl->id.name));
1778e182534dSTakashi Iwai break;
1779e182534dSTakashi Iwai }
1780e182534dSTakashi Iwai
1781e182534dSTakashi Iwai /* get min/max values */
1782e182534dSTakashi Iwai get_min_max_with_quirks(cval, 0, kctl);
1783e182534dSTakashi Iwai
1784e9a0ef0bSTakashi Iwai /* skip a bogus volume range */
1785e9a0ef0bSTakashi Iwai if (cval->max <= cval->min) {
1786e9a0ef0bSTakashi Iwai usb_audio_dbg(mixer->chip,
1787e9a0ef0bSTakashi Iwai "[%d] FU [%s] skipped due to invalid volume\n",
1788e9a0ef0bSTakashi Iwai cval->head.id, kctl->id.name);
1789e9a0ef0bSTakashi Iwai snd_ctl_free_one(kctl);
1790e9a0ef0bSTakashi Iwai return;
1791e9a0ef0bSTakashi Iwai }
1792e9a0ef0bSTakashi Iwai
1793e9a0ef0bSTakashi Iwai
179465f25da4SDaniel Mack if (control == UAC_FU_VOLUME) {
179559bb7f0eSTakashi Iwai check_mapped_dB(map, cval);
179638b65190STakashi Iwai if (cval->dBmin < cval->dBmax || !cval->initialized) {
1797285de9c0SFelix Homann kctl->tlv.c = snd_usb_mixer_vol_tlv;
1798f0b5e634SDaniel Mack kctl->vd[0].access |=
1799f0b5e634SDaniel Mack SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1800f0b5e634SDaniel Mack SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
180159bb7f0eSTakashi Iwai }
1802f0b5e634SDaniel Mack }
1803f0b5e634SDaniel Mack
180417156f23SRuslan Bilovol snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
180542e3121dSAnssi Hannula
180680acefffSAlexey Fisher range = (cval->max - cval->min) / cval->res;
18076bc170e4SDaniel Mack /*
18086bc170e4SDaniel Mack * Are there devices with volume range more than 255? I use a bit more
180980acefffSAlexey Fisher * to be sure. 384 is a resolution magic number found on Logitech
181080acefffSAlexey Fisher * devices. It will definitively catch all buggy Logitech devices.
181180acefffSAlexey Fisher */
181280acefffSAlexey Fisher if (range > 384) {
181317156f23SRuslan Bilovol usb_audio_warn(mixer->chip,
181482c1cf0aSMichał Mirosław "Warning! Unlikely big volume range (=%u), cval->res is probably wrong.",
181580acefffSAlexey Fisher range);
181617156f23SRuslan Bilovol usb_audio_warn(mixer->chip,
181782c1cf0aSMichał Mirosław "[%d] FU [%s] ch = %d, val = %d/%d/%d",
18183360b84bSTakashi Iwai cval->head.id, kctl->id.name, cval->channels,
181980acefffSAlexey Fisher cval->min, cval->max, cval->res);
182080acefffSAlexey Fisher }
182180acefffSAlexey Fisher
182217156f23SRuslan Bilovol usb_audio_dbg(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
18233360b84bSTakashi Iwai cval->head.id, kctl->id.name, cval->channels,
18246bc170e4SDaniel Mack cval->min, cval->max, cval->res);
18253360b84bSTakashi Iwai snd_usb_mixer_add_control(&cval->head, kctl);
1826f0b5e634SDaniel Mack }
1827f0b5e634SDaniel Mack
build_feature_ctl(struct mixer_build * state,void * raw_desc,unsigned int ctl_mask,int control,struct usb_audio_term * iterm,int unitid,int readonly_mask)182817156f23SRuslan Bilovol static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
182917156f23SRuslan Bilovol unsigned int ctl_mask, int control,
183017156f23SRuslan Bilovol struct usb_audio_term *iterm, int unitid,
183117156f23SRuslan Bilovol int readonly_mask)
183217156f23SRuslan Bilovol {
183317156f23SRuslan Bilovol struct uac_feature_unit_descriptor *desc = raw_desc;
183417156f23SRuslan Bilovol int nameid = uac_feature_unit_iFeature(desc);
183517156f23SRuslan Bilovol
183617156f23SRuslan Bilovol __build_feature_ctl(state->mixer, state->map, ctl_mask, control,
183717156f23SRuslan Bilovol iterm, &state->oterm, unitid, nameid, readonly_mask);
183817156f23SRuslan Bilovol }
183917156f23SRuslan Bilovol
build_feature_ctl_badd(struct usb_mixer_interface * mixer,unsigned int ctl_mask,int control,int unitid,const struct usbmix_name_map * badd_map)184017156f23SRuslan Bilovol static void build_feature_ctl_badd(struct usb_mixer_interface *mixer,
184117156f23SRuslan Bilovol unsigned int ctl_mask, int control, int unitid,
184217156f23SRuslan Bilovol const struct usbmix_name_map *badd_map)
184317156f23SRuslan Bilovol {
184417156f23SRuslan Bilovol __build_feature_ctl(mixer, badd_map, ctl_mask, control,
184517156f23SRuslan Bilovol NULL, NULL, unitid, 0, 0);
184617156f23SRuslan Bilovol }
184717156f23SRuslan Bilovol
get_connector_control_name(struct usb_mixer_interface * mixer,struct usb_audio_term * term,bool is_input,char * name,int name_size)1848167e1fb1SJorge Sanjuan static void get_connector_control_name(struct usb_mixer_interface *mixer,
18495a222e84SAndrew Chant struct usb_audio_term *term,
18505a222e84SAndrew Chant bool is_input, char *name, int name_size)
18515a222e84SAndrew Chant {
1852167e1fb1SJorge Sanjuan int name_len = get_term_name(mixer->chip, term, name, name_size, 0);
18535a222e84SAndrew Chant
18545a222e84SAndrew Chant if (name_len == 0)
185575b1a8f9SJoe Perches strscpy(name, "Unknown", name_size);
18565a222e84SAndrew Chant
18575a222e84SAndrew Chant /*
18585a222e84SAndrew Chant * sound/core/ctljack.c has a convention of naming jack controls
18595a222e84SAndrew Chant * by ending in " Jack". Make it slightly more useful by
18605a222e84SAndrew Chant * indicating Input or Output after the terminal name.
18615a222e84SAndrew Chant */
18625a222e84SAndrew Chant if (is_input)
18635a222e84SAndrew Chant strlcat(name, " - Input Jack", name_size);
18645a222e84SAndrew Chant else
18655a222e84SAndrew Chant strlcat(name, " - Output Jack", name_size);
18665a222e84SAndrew Chant }
18675a222e84SAndrew Chant
18688dde723fSTakashi Iwai /* get connector value to "wake up" the USB audio */
connector_mixer_resume(struct usb_mixer_elem_list * list)18698dde723fSTakashi Iwai static int connector_mixer_resume(struct usb_mixer_elem_list *list)
18708dde723fSTakashi Iwai {
18718dde723fSTakashi Iwai struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
18728dde723fSTakashi Iwai
18738dde723fSTakashi Iwai get_connector_value(cval, NULL, NULL);
18748dde723fSTakashi Iwai return 0;
18758dde723fSTakashi Iwai }
18768dde723fSTakashi Iwai
18775a222e84SAndrew Chant /* Build a mixer control for a UAC connector control (jack-detect) */
build_connector_control(struct usb_mixer_interface * mixer,const struct usbmix_name_map * imap,struct usb_audio_term * term,bool is_input)1878167e1fb1SJorge Sanjuan static void build_connector_control(struct usb_mixer_interface *mixer,
1879934b9659STakashi Iwai const struct usbmix_name_map *imap,
18805a222e84SAndrew Chant struct usb_audio_term *term, bool is_input)
18815a222e84SAndrew Chant {
18825a222e84SAndrew Chant struct snd_kcontrol *kctl;
18835a222e84SAndrew Chant struct usb_mixer_elem_info *cval;
1884a43c1c41STakashi Iwai const struct usbmix_name_map *map;
18855a222e84SAndrew Chant
1886a43c1c41STakashi Iwai map = find_map(imap, term->id, 0);
1887a43c1c41STakashi Iwai if (check_ignored_ctl(map))
1888934b9659STakashi Iwai return;
1889934b9659STakashi Iwai
18905a222e84SAndrew Chant cval = kzalloc(sizeof(*cval), GFP_KERNEL);
18915a222e84SAndrew Chant if (!cval)
18925a222e84SAndrew Chant return;
1893167e1fb1SJorge Sanjuan snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
18948dde723fSTakashi Iwai
18958dde723fSTakashi Iwai /* set up a specific resume callback */
18968dde723fSTakashi Iwai cval->head.resume = connector_mixer_resume;
18978dde723fSTakashi Iwai
1898568fa7e0SAndrew Chant /*
18991d38f5d8SJorge Sanjuan * UAC2: The first byte from reading the UAC2_TE_CONNECTOR control returns the
19001d38f5d8SJorge Sanjuan * number of channels connected.
19011d38f5d8SJorge Sanjuan *
19021d38f5d8SJorge Sanjuan * UAC3: The first byte specifies size of bitmap for the inserted controls. The
19031d38f5d8SJorge Sanjuan * following byte(s) specifies which connectors are inserted.
19041d38f5d8SJorge Sanjuan *
19051d38f5d8SJorge Sanjuan * This boolean ctl will simply report if any channels are connected
19061d38f5d8SJorge Sanjuan * or not.
1907568fa7e0SAndrew Chant */
1908167e1fb1SJorge Sanjuan if (mixer->protocol == UAC_VERSION_2)
19095a222e84SAndrew Chant cval->control = UAC2_TE_CONNECTOR;
19101d38f5d8SJorge Sanjuan else /* UAC_VERSION_3 */
19111d38f5d8SJorge Sanjuan cval->control = UAC3_TE_INSERTION;
19121d38f5d8SJorge Sanjuan
19135a222e84SAndrew Chant cval->val_type = USB_MIXER_BOOLEAN;
19145a222e84SAndrew Chant cval->channels = 1; /* report true if any channel is connected */
19155a222e84SAndrew Chant cval->min = 0;
19165a222e84SAndrew Chant cval->max = 1;
19171d38f5d8SJorge Sanjuan kctl = snd_ctl_new1(&usb_connector_ctl_ro, cval);
19185a222e84SAndrew Chant if (!kctl) {
1919167e1fb1SJorge Sanjuan usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
192052c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
19215a222e84SAndrew Chant return;
19225a222e84SAndrew Chant }
1923a43c1c41STakashi Iwai
1924a43c1c41STakashi Iwai if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)))
1925a43c1c41STakashi Iwai strlcat(kctl->id.name, " Jack", sizeof(kctl->id.name));
1926a43c1c41STakashi Iwai else
1927167e1fb1SJorge Sanjuan get_connector_control_name(mixer, term, is_input, kctl->id.name,
19285a222e84SAndrew Chant sizeof(kctl->id.name));
19295a222e84SAndrew Chant kctl->private_free = snd_usb_mixer_elem_free;
19305a222e84SAndrew Chant snd_usb_mixer_add_control(&cval->head, kctl);
19315a222e84SAndrew Chant }
19325a222e84SAndrew Chant
parse_clock_source_unit(struct mixer_build * state,int unitid,void * _ftr)1933cddaafb9SDaniel Mack static int parse_clock_source_unit(struct mixer_build *state, int unitid,
1934cddaafb9SDaniel Mack void *_ftr)
1935cddaafb9SDaniel Mack {
1936cddaafb9SDaniel Mack struct uac_clock_source_descriptor *hdr = _ftr;
1937cddaafb9SDaniel Mack struct usb_mixer_elem_info *cval;
1938cddaafb9SDaniel Mack struct snd_kcontrol *kctl;
1939cddaafb9SDaniel Mack int ret;
1940cddaafb9SDaniel Mack
1941cddaafb9SDaniel Mack if (state->mixer->protocol != UAC_VERSION_2)
1942cddaafb9SDaniel Mack return -EINVAL;
1943cddaafb9SDaniel Mack
1944cddaafb9SDaniel Mack /*
1945cddaafb9SDaniel Mack * The only property of this unit we are interested in is the
1946cddaafb9SDaniel Mack * clock source validity. If that isn't readable, just bail out.
1947cddaafb9SDaniel Mack */
19489a2fe9b8SRuslan Bilovol if (!uac_v2v3_control_is_readable(hdr->bmControls,
194921e9b3e9SAndrew Chant UAC2_CS_CONTROL_CLOCK_VALID))
1950cddaafb9SDaniel Mack return 0;
1951cddaafb9SDaniel Mack
1952cddaafb9SDaniel Mack cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1953cddaafb9SDaniel Mack if (!cval)
1954cddaafb9SDaniel Mack return -ENOMEM;
1955cddaafb9SDaniel Mack
1956cddaafb9SDaniel Mack snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
1957cddaafb9SDaniel Mack
1958cddaafb9SDaniel Mack cval->min = 0;
1959cddaafb9SDaniel Mack cval->max = 1;
1960cddaafb9SDaniel Mack cval->channels = 1;
1961cddaafb9SDaniel Mack cval->val_type = USB_MIXER_BOOLEAN;
1962cddaafb9SDaniel Mack cval->control = UAC2_CS_CONTROL_CLOCK_VALID;
1963cddaafb9SDaniel Mack
1964cddaafb9SDaniel Mack cval->master_readonly = 1;
1965568fa7e0SAndrew Chant /* From UAC2 5.2.5.1.2 "Only the get request is supported." */
1966568fa7e0SAndrew Chant kctl = snd_ctl_new1(&usb_bool_master_control_ctl_ro, cval);
1967cddaafb9SDaniel Mack
1968cddaafb9SDaniel Mack if (!kctl) {
196952c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
1970cddaafb9SDaniel Mack return -ENOMEM;
1971cddaafb9SDaniel Mack }
1972cddaafb9SDaniel Mack
1973cddaafb9SDaniel Mack kctl->private_free = snd_usb_mixer_elem_free;
1974eccfc1b8SRuslan Bilovol ret = snd_usb_copy_string_desc(state->chip, hdr->iClockSource,
197526f7111aSPeter Ujfalusi kctl->id.name, sizeof(kctl->id.name));
1976cddaafb9SDaniel Mack if (ret > 0)
197726f7111aSPeter Ujfalusi append_ctl_name(kctl, " Validity");
1978cddaafb9SDaniel Mack else
1979cddaafb9SDaniel Mack snprintf(kctl->id.name, sizeof(kctl->id.name),
1980cddaafb9SDaniel Mack "Clock Source %d Validity", hdr->bClockID);
1981cddaafb9SDaniel Mack
1982cddaafb9SDaniel Mack return snd_usb_mixer_add_control(&cval->head, kctl);
1983cddaafb9SDaniel Mack }
1984cddaafb9SDaniel Mack
1985f0b5e634SDaniel Mack /*
1986f0b5e634SDaniel Mack * parse a feature unit
1987f0b5e634SDaniel Mack *
198825985edcSLucas De Marchi * most of controls are defined here.
1989f0b5e634SDaniel Mack */
parse_audio_feature_unit(struct mixer_build * state,int unitid,void * _ftr)19906bc170e4SDaniel Mack static int parse_audio_feature_unit(struct mixer_build *state, int unitid,
19916bc170e4SDaniel Mack void *_ftr)
1992f0b5e634SDaniel Mack {
1993f0b5e634SDaniel Mack int channels, i, j;
1994f0b5e634SDaniel Mack struct usb_audio_term iterm;
199536c346e1SYueHaibing unsigned int master_bits;
1996f0b5e634SDaniel Mack int err, csize;
199723caaf19SDaniel Mack struct uac_feature_unit_descriptor *hdr = _ftr;
199823caaf19SDaniel Mack __u8 *bmaControls;
1999f0b5e634SDaniel Mack
200023caaf19SDaniel Mack if (state->mixer->protocol == UAC_VERSION_1) {
200123caaf19SDaniel Mack csize = hdr->bControlSize;
200223caaf19SDaniel Mack channels = (hdr->bLength - 7) / csize - 1;
200323caaf19SDaniel Mack bmaControls = hdr->bmaControls;
20049a2fe9b8SRuslan Bilovol } else if (state->mixer->protocol == UAC_VERSION_2) {
200523caaf19SDaniel Mack struct uac2_feature_unit_descriptor *ftr = _ftr;
200623caaf19SDaniel Mack csize = 4;
2007e8d0fee7SDaniel Mack channels = (hdr->bLength - 6) / 4 - 1;
200823caaf19SDaniel Mack bmaControls = ftr->bmaControls;
20099a2fe9b8SRuslan Bilovol } else { /* UAC_VERSION_3 */
20109a2fe9b8SRuslan Bilovol struct uac3_feature_unit_descriptor *ftr = _ftr;
20119a2fe9b8SRuslan Bilovol
20129a2fe9b8SRuslan Bilovol csize = 4;
20139a2fe9b8SRuslan Bilovol channels = (ftr->bLength - 7) / 4 - 1;
20149a2fe9b8SRuslan Bilovol bmaControls = ftr->bmaControls;
2015d56268fbSClemens Ladisch }
2016f0b5e634SDaniel Mack
2017f0b5e634SDaniel Mack /* parse the source unit */
2018f25ecf8fSTakashi Iwai err = parse_audio_unit(state, hdr->bSourceID);
2019f25ecf8fSTakashi Iwai if (err < 0)
2020f0b5e634SDaniel Mack return err;
2021f0b5e634SDaniel Mack
2022f0b5e634SDaniel Mack /* determine the input source type and name */
20234d7b86c9SDaniel Mack err = check_input_term(state, hdr->bSourceID, &iterm);
20244d7b86c9SDaniel Mack if (err < 0)
20254d7b86c9SDaniel Mack return err;
2026f0b5e634SDaniel Mack
202723caaf19SDaniel Mack master_bits = snd_usb_combine_bytes(bmaControls, csize);
2028f0b5e634SDaniel Mack /* master configuration quirks */
2029f0b5e634SDaniel Mack switch (state->chip->usb_id) {
2030f0b5e634SDaniel Mack case USB_ID(0x08bb, 0x2702):
20310ba41d91STakashi Iwai usb_audio_info(state->chip,
2032f0b5e634SDaniel Mack "usbmixer: master volume quirk for PCM2702 chip\n");
2033f0b5e634SDaniel Mack /* disable non-functional volume control */
203465f25da4SDaniel Mack master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
2035f0b5e634SDaniel Mack break;
2036c1051439SDavid Henningsson case USB_ID(0x1130, 0xf211):
20370ba41d91STakashi Iwai usb_audio_info(state->chip,
2038c1051439SDavid Henningsson "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
2039c1051439SDavid Henningsson /* disable non-functional volume control */
2040c1051439SDavid Henningsson channels = 0;
2041c1051439SDavid Henningsson break;
2042c1051439SDavid Henningsson
2043f0b5e634SDaniel Mack }
204423caaf19SDaniel Mack
204523caaf19SDaniel Mack if (state->mixer->protocol == UAC_VERSION_1) {
2046f0b5e634SDaniel Mack /* check all control types */
2047f0b5e634SDaniel Mack for (i = 0; i < 10; i++) {
2048f0b5e634SDaniel Mack unsigned int ch_bits = 0;
204921e9b3e9SAndrew Chant int control = audio_feature_info[i].control;
205021e9b3e9SAndrew Chant
2051f0b5e634SDaniel Mack for (j = 0; j < channels; j++) {
20526bc170e4SDaniel Mack unsigned int mask;
20536bc170e4SDaniel Mack
20546bc170e4SDaniel Mack mask = snd_usb_combine_bytes(bmaControls +
20556bc170e4SDaniel Mack csize * (j+1), csize);
2056f0b5e634SDaniel Mack if (mask & (1 << i))
2057f0b5e634SDaniel Mack ch_bits |= (1 << j);
2058f0b5e634SDaniel Mack }
205923caaf19SDaniel Mack /* audio class v1 controls are never read-only */
20606bc170e4SDaniel Mack
20616bc170e4SDaniel Mack /*
20626bc170e4SDaniel Mack * The first channel must be set
20636bc170e4SDaniel Mack * (for ease of programming).
20646bc170e4SDaniel Mack */
20656bc170e4SDaniel Mack if (ch_bits & 1)
206621e9b3e9SAndrew Chant build_feature_ctl(state, _ftr, ch_bits, control,
20676bc170e4SDaniel Mack &iterm, unitid, 0);
2068f0b5e634SDaniel Mack if (master_bits & (1 << i))
206921e9b3e9SAndrew Chant build_feature_ctl(state, _ftr, 0, control,
207021e9b3e9SAndrew Chant &iterm, unitid, 0);
207123caaf19SDaniel Mack }
20729a2fe9b8SRuslan Bilovol } else { /* UAC_VERSION_2/3 */
2073d09c06c6STakashi Iwai for (i = 0; i < ARRAY_SIZE(audio_feature_info); i++) {
207423caaf19SDaniel Mack unsigned int ch_bits = 0;
207523caaf19SDaniel Mack unsigned int ch_read_only = 0;
207621e9b3e9SAndrew Chant int control = audio_feature_info[i].control;
207723caaf19SDaniel Mack
207823caaf19SDaniel Mack for (j = 0; j < channels; j++) {
20796bc170e4SDaniel Mack unsigned int mask;
20806bc170e4SDaniel Mack
20816bc170e4SDaniel Mack mask = snd_usb_combine_bytes(bmaControls +
20826bc170e4SDaniel Mack csize * (j+1), csize);
208321e9b3e9SAndrew Chant if (uac_v2v3_control_is_readable(mask, control)) {
208423caaf19SDaniel Mack ch_bits |= (1 << j);
208521e9b3e9SAndrew Chant if (!uac_v2v3_control_is_writeable(mask, control))
208623caaf19SDaniel Mack ch_read_only |= (1 << j);
208723caaf19SDaniel Mack }
208823caaf19SDaniel Mack }
208923caaf19SDaniel Mack
20906bc170e4SDaniel Mack /*
20916bc170e4SDaniel Mack * NOTE: build_feature_ctl() will mark the control
20926bc170e4SDaniel Mack * read-only if all channels are marked read-only in
20936bc170e4SDaniel Mack * the descriptors. Otherwise, the control will be
20946bc170e4SDaniel Mack * reported as writeable, but the driver will not
20956bc170e4SDaniel Mack * actually issue a write command for read-only
20966bc170e4SDaniel Mack * channels.
20976bc170e4SDaniel Mack */
20986bc170e4SDaniel Mack
20996bc170e4SDaniel Mack /*
21006bc170e4SDaniel Mack * The first channel must be set
21016bc170e4SDaniel Mack * (for ease of programming).
21026bc170e4SDaniel Mack */
21036bc170e4SDaniel Mack if (ch_bits & 1)
210421e9b3e9SAndrew Chant build_feature_ctl(state, _ftr, ch_bits, control,
21056bc170e4SDaniel Mack &iterm, unitid, ch_read_only);
210621e9b3e9SAndrew Chant if (uac_v2v3_control_is_readable(master_bits, control))
21072de841efSTakashi Iwai build_feature_ctl(state, _ftr, 0, control,
21082de841efSTakashi Iwai &iterm, unitid,
210921e9b3e9SAndrew Chant !uac_v2v3_control_is_writeable(master_bits,
211021e9b3e9SAndrew Chant control));
211123caaf19SDaniel Mack }
2112f0b5e634SDaniel Mack }
2113f0b5e634SDaniel Mack
2114f0b5e634SDaniel Mack return 0;
2115f0b5e634SDaniel Mack }
2116f0b5e634SDaniel Mack
2117f0b5e634SDaniel Mack /*
2118f0b5e634SDaniel Mack * Mixer Unit
2119f0b5e634SDaniel Mack */
2120f0b5e634SDaniel Mack
2121f9f0e9edSTakashi Iwai /* check whether the given in/out overflows bmMixerControls matrix */
mixer_bitmap_overflow(struct uac_mixer_unit_descriptor * desc,int protocol,int num_ins,int num_outs)2122f9f0e9edSTakashi Iwai static bool mixer_bitmap_overflow(struct uac_mixer_unit_descriptor *desc,
2123f9f0e9edSTakashi Iwai int protocol, int num_ins, int num_outs)
2124f9f0e9edSTakashi Iwai {
2125f9f0e9edSTakashi Iwai u8 *hdr = (u8 *)desc;
2126f9f0e9edSTakashi Iwai u8 *c = uac_mixer_unit_bmControls(desc, protocol);
2127f9f0e9edSTakashi Iwai size_t rest; /* remaining bytes after bmMixerControls */
2128f9f0e9edSTakashi Iwai
2129f9f0e9edSTakashi Iwai switch (protocol) {
2130f9f0e9edSTakashi Iwai case UAC_VERSION_1:
2131f9f0e9edSTakashi Iwai default:
2132f9f0e9edSTakashi Iwai rest = 1; /* iMixer */
2133f9f0e9edSTakashi Iwai break;
2134f9f0e9edSTakashi Iwai case UAC_VERSION_2:
2135f9f0e9edSTakashi Iwai rest = 2; /* bmControls + iMixer */
2136f9f0e9edSTakashi Iwai break;
2137f9f0e9edSTakashi Iwai case UAC_VERSION_3:
2138f9f0e9edSTakashi Iwai rest = 6; /* bmControls + wMixerDescrStr */
2139f9f0e9edSTakashi Iwai break;
2140f9f0e9edSTakashi Iwai }
2141f9f0e9edSTakashi Iwai
2142f9f0e9edSTakashi Iwai /* overflow? */
2143f9f0e9edSTakashi Iwai return c + (num_ins * num_outs + 7) / 8 + rest > hdr + hdr[0];
2144f9f0e9edSTakashi Iwai }
2145f9f0e9edSTakashi Iwai
2146f0b5e634SDaniel Mack /*
2147f0b5e634SDaniel Mack * build a mixer unit control
2148f0b5e634SDaniel Mack *
2149f0b5e634SDaniel Mack * the callbacks are identical with feature unit.
2150f0b5e634SDaniel Mack * input channel number (zero based) is given in control field instead.
2151f0b5e634SDaniel Mack */
build_mixer_unit_ctl(struct mixer_build * state,struct uac_mixer_unit_descriptor * desc,int in_pin,int in_ch,int num_outs,int unitid,struct usb_audio_term * iterm)215299fc8645SDaniel Mack static void build_mixer_unit_ctl(struct mixer_build *state,
215399fc8645SDaniel Mack struct uac_mixer_unit_descriptor *desc,
21546cfd839aSJorge Sanjuan int in_pin, int in_ch, int num_outs,
21556cfd839aSJorge Sanjuan int unitid, struct usb_audio_term *iterm)
2156f0b5e634SDaniel Mack {
2157f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval;
2158f0b5e634SDaniel Mack unsigned int i, len;
2159f0b5e634SDaniel Mack struct snd_kcontrol *kctl;
2160f0b5e634SDaniel Mack const struct usbmix_name_map *map;
2161f0b5e634SDaniel Mack
216217156f23SRuslan Bilovol map = find_map(state->map, unitid, 0);
2163f0b5e634SDaniel Mack if (check_ignored_ctl(map))
2164f0b5e634SDaniel Mack return;
2165f0b5e634SDaniel Mack
2166f0b5e634SDaniel Mack cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2167f0b5e634SDaniel Mack if (!cval)
2168f0b5e634SDaniel Mack return;
2169f0b5e634SDaniel Mack
21703360b84bSTakashi Iwai snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2171f0b5e634SDaniel Mack cval->control = in_ch + 1; /* based on 1 */
2172f0b5e634SDaniel Mack cval->val_type = USB_MIXER_S16;
2173f0b5e634SDaniel Mack for (i = 0; i < num_outs; i++) {
21746bc170e4SDaniel Mack __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
21756bc170e4SDaniel Mack
21766bc170e4SDaniel Mack if (check_matrix_bitmap(c, in_ch, i, num_outs)) {
2177f0b5e634SDaniel Mack cval->cmask |= (1 << i);
2178f0b5e634SDaniel Mack cval->channels++;
2179f0b5e634SDaniel Mack }
2180f0b5e634SDaniel Mack }
2181f0b5e634SDaniel Mack
2182f0b5e634SDaniel Mack /* get min/max values */
2183f0b5e634SDaniel Mack get_min_max(cval, 0);
2184f0b5e634SDaniel Mack
2185f0b5e634SDaniel Mack kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
2186f0b5e634SDaniel Mack if (!kctl) {
21870ba41d91STakashi Iwai usb_audio_err(state->chip, "cannot malloc kcontrol\n");
218852c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
2189f0b5e634SDaniel Mack return;
2190f0b5e634SDaniel Mack }
2191eef90451SChris J Arges kctl->private_free = snd_usb_mixer_elem_free;
2192f0b5e634SDaniel Mack
2193f0b5e634SDaniel Mack len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
2194f0b5e634SDaniel Mack if (!len)
2195eccfc1b8SRuslan Bilovol len = get_term_name(state->chip, iterm, kctl->id.name,
21966bc170e4SDaniel Mack sizeof(kctl->id.name), 0);
2197f0b5e634SDaniel Mack if (!len)
2198f0b5e634SDaniel Mack len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
2199f0b5e634SDaniel Mack append_ctl_name(kctl, " Volume");
2200f0b5e634SDaniel Mack
22010ba41d91STakashi Iwai usb_audio_dbg(state->chip, "[%d] MU [%s] ch = %d, val = %d/%d\n",
22023360b84bSTakashi Iwai cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max);
22033360b84bSTakashi Iwai snd_usb_mixer_add_control(&cval->head, kctl);
2204f0b5e634SDaniel Mack }
2205f0b5e634SDaniel Mack
parse_audio_input_terminal(struct mixer_build * state,int unitid,void * raw_desc)22065a222e84SAndrew Chant static int parse_audio_input_terminal(struct mixer_build *state, int unitid,
22075a222e84SAndrew Chant void *raw_desc)
22085a222e84SAndrew Chant {
22095a222e84SAndrew Chant struct usb_audio_term iterm;
22101d38f5d8SJorge Sanjuan unsigned int control, bmctls, term_id;
22115a222e84SAndrew Chant
22125a222e84SAndrew Chant if (state->mixer->protocol == UAC_VERSION_2) {
22131d38f5d8SJorge Sanjuan struct uac2_input_terminal_descriptor *d_v2 = raw_desc;
22141d38f5d8SJorge Sanjuan control = UAC2_TE_CONNECTOR;
22151d38f5d8SJorge Sanjuan term_id = d_v2->bTerminalID;
22161d38f5d8SJorge Sanjuan bmctls = le16_to_cpu(d_v2->bmControls);
22171d38f5d8SJorge Sanjuan } else if (state->mixer->protocol == UAC_VERSION_3) {
22181d38f5d8SJorge Sanjuan struct uac3_input_terminal_descriptor *d_v3 = raw_desc;
22191d38f5d8SJorge Sanjuan control = UAC3_TE_INSERTION;
22201d38f5d8SJorge Sanjuan term_id = d_v3->bTerminalID;
22211d38f5d8SJorge Sanjuan bmctls = le32_to_cpu(d_v3->bmControls);
22221d38f5d8SJorge Sanjuan } else {
22231d38f5d8SJorge Sanjuan return 0; /* UAC1. No Insertion control */
22241d38f5d8SJorge Sanjuan }
22251d38f5d8SJorge Sanjuan
22261d38f5d8SJorge Sanjuan check_input_term(state, term_id, &iterm);
22271d38f5d8SJorge Sanjuan
22285a222e84SAndrew Chant /* Check for jack detection. */
22297dc3c5a0STakashi Iwai if ((iterm.type & 0xff00) != 0x0100 &&
22307dc3c5a0STakashi Iwai uac_v2v3_control_is_readable(bmctls, control))
2231934b9659STakashi Iwai build_connector_control(state->mixer, state->map, &iterm, true);
22321d38f5d8SJorge Sanjuan
22335a222e84SAndrew Chant return 0;
22345a222e84SAndrew Chant }
22355a222e84SAndrew Chant
2236f0b5e634SDaniel Mack /*
2237f0b5e634SDaniel Mack * parse a mixer unit
2238f0b5e634SDaniel Mack */
parse_audio_mixer_unit(struct mixer_build * state,int unitid,void * raw_desc)22396bc170e4SDaniel Mack static int parse_audio_mixer_unit(struct mixer_build *state, int unitid,
22406bc170e4SDaniel Mack void *raw_desc)
2241f0b5e634SDaniel Mack {
224299fc8645SDaniel Mack struct uac_mixer_unit_descriptor *desc = raw_desc;
2243f0b5e634SDaniel Mack struct usb_audio_term iterm;
2244f0b5e634SDaniel Mack int input_pins, num_ins, num_outs;
2245f0b5e634SDaniel Mack int pin, ich, err;
2246f0b5e634SDaniel Mack
22476cfd839aSJorge Sanjuan err = uac_mixer_unit_get_channels(state, desc);
22486cfd839aSJorge Sanjuan if (err < 0) {
22496bc170e4SDaniel Mack usb_audio_err(state->chip,
22506bc170e4SDaniel Mack "invalid MIXER UNIT descriptor %d\n",
22516bc170e4SDaniel Mack unitid);
22526cfd839aSJorge Sanjuan return err;
2253f0b5e634SDaniel Mack }
2254f0b5e634SDaniel Mack
22556cfd839aSJorge Sanjuan num_outs = err;
22566cfd839aSJorge Sanjuan input_pins = desc->bNrInPins;
22576cfd839aSJorge Sanjuan
2258f0b5e634SDaniel Mack num_ins = 0;
2259f0b5e634SDaniel Mack ich = 0;
2260f0b5e634SDaniel Mack for (pin = 0; pin < input_pins; pin++) {
226199fc8645SDaniel Mack err = parse_audio_unit(state, desc->baSourceID[pin]);
2262f0b5e634SDaniel Mack if (err < 0)
2263284a8dd6SMark Hills continue;
2264ea114fc2SClemens Ladisch /* no bmControls field (e.g. Maya44) -> ignore */
22650bfe5e43STakashi Iwai if (!num_outs)
2266ea114fc2SClemens Ladisch continue;
226799fc8645SDaniel Mack err = check_input_term(state, desc->baSourceID[pin], &iterm);
2268f0b5e634SDaniel Mack if (err < 0)
2269f0b5e634SDaniel Mack return err;
2270f0b5e634SDaniel Mack num_ins += iterm.channels;
2271f9f0e9edSTakashi Iwai if (mixer_bitmap_overflow(desc, state->mixer->protocol,
2272f9f0e9edSTakashi Iwai num_ins, num_outs))
2273f9f0e9edSTakashi Iwai break;
22746bc170e4SDaniel Mack for (; ich < num_ins; ich++) {
2275f0b5e634SDaniel Mack int och, ich_has_controls = 0;
2276f0b5e634SDaniel Mack
22776bc170e4SDaniel Mack for (och = 0; och < num_outs; och++) {
22786bc170e4SDaniel Mack __u8 *c = uac_mixer_unit_bmControls(desc,
22796bc170e4SDaniel Mack state->mixer->protocol);
22806bc170e4SDaniel Mack
22816bc170e4SDaniel Mack if (check_matrix_bitmap(c, ich, och, num_outs)) {
2282f0b5e634SDaniel Mack ich_has_controls = 1;
2283f0b5e634SDaniel Mack break;
2284f0b5e634SDaniel Mack }
2285f0b5e634SDaniel Mack }
2286f0b5e634SDaniel Mack if (ich_has_controls)
22876cfd839aSJorge Sanjuan build_mixer_unit_ctl(state, desc, pin, ich, num_outs,
2288f0b5e634SDaniel Mack unitid, &iterm);
2289f0b5e634SDaniel Mack }
2290f0b5e634SDaniel Mack }
2291f0b5e634SDaniel Mack return 0;
2292f0b5e634SDaniel Mack }
2293f0b5e634SDaniel Mack
2294f0b5e634SDaniel Mack /*
2295f0b5e634SDaniel Mack * Processing Unit / Extension Unit
2296f0b5e634SDaniel Mack */
2297f0b5e634SDaniel Mack
2298f0b5e634SDaniel Mack /* get callback for processing/extension unit */
mixer_ctl_procunit_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)22996bc170e4SDaniel Mack static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol,
23006bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
2301f0b5e634SDaniel Mack {
2302f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
2303f0b5e634SDaniel Mack int err, val;
2304f0b5e634SDaniel Mack
2305f0b5e634SDaniel Mack err = get_cur_ctl_value(cval, cval->control << 8, &val);
23065aeee342STakashi Iwai if (err < 0) {
2307f0b5e634SDaniel Mack ucontrol->value.integer.value[0] = cval->min;
23085aeee342STakashi Iwai return filter_error(cval, err);
2309f0b5e634SDaniel Mack }
2310f0b5e634SDaniel Mack val = get_relative_value(cval, val);
2311f0b5e634SDaniel Mack ucontrol->value.integer.value[0] = val;
2312f0b5e634SDaniel Mack return 0;
2313f0b5e634SDaniel Mack }
2314f0b5e634SDaniel Mack
2315f0b5e634SDaniel Mack /* put callback for processing/extension unit */
mixer_ctl_procunit_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)23166bc170e4SDaniel Mack static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol,
23176bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
2318f0b5e634SDaniel Mack {
2319f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
2320f0b5e634SDaniel Mack int val, oval, err;
2321f0b5e634SDaniel Mack
2322f0b5e634SDaniel Mack err = get_cur_ctl_value(cval, cval->control << 8, &oval);
23235aeee342STakashi Iwai if (err < 0)
23245aeee342STakashi Iwai return filter_error(cval, err);
2325f0b5e634SDaniel Mack val = ucontrol->value.integer.value[0];
2326f0b5e634SDaniel Mack val = get_abs_value(cval, val);
2327f0b5e634SDaniel Mack if (val != oval) {
2328f0b5e634SDaniel Mack set_cur_ctl_value(cval, cval->control << 8, val);
2329f0b5e634SDaniel Mack return 1;
2330f0b5e634SDaniel Mack }
2331f0b5e634SDaniel Mack return 0;
2332f0b5e634SDaniel Mack }
2333f0b5e634SDaniel Mack
2334f0b5e634SDaniel Mack /* alsa control interface for processing/extension unit */
23358fdaebbbSBhumika Goyal static const struct snd_kcontrol_new mixer_procunit_ctl = {
2336f0b5e634SDaniel Mack .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2337f0b5e634SDaniel Mack .name = "", /* will be filled later */
2338f0b5e634SDaniel Mack .info = mixer_ctl_feature_info,
2339f0b5e634SDaniel Mack .get = mixer_ctl_procunit_get,
2340f0b5e634SDaniel Mack .put = mixer_ctl_procunit_put,
2341f0b5e634SDaniel Mack };
2342f0b5e634SDaniel Mack
2343f0b5e634SDaniel Mack /*
2344f0b5e634SDaniel Mack * predefined data for processing units
2345f0b5e634SDaniel Mack */
2346f0b5e634SDaniel Mack struct procunit_value_info {
2347f0b5e634SDaniel Mack int control;
2348a01df925STakashi Iwai const char *suffix;
2349f0b5e634SDaniel Mack int val_type;
2350f0b5e634SDaniel Mack int min_value;
2351f0b5e634SDaniel Mack };
2352f0b5e634SDaniel Mack
2353f0b5e634SDaniel Mack struct procunit_info {
2354f0b5e634SDaniel Mack int type;
2355f0b5e634SDaniel Mack char *name;
2356a01df925STakashi Iwai const struct procunit_value_info *values;
2357f0b5e634SDaniel Mack };
2358f0b5e634SDaniel Mack
2359a01df925STakashi Iwai static const struct procunit_value_info undefined_proc_info[] = {
23600f292f02SJorge Sanjuan { 0x00, "Control Undefined", 0 },
23610f292f02SJorge Sanjuan { 0 }
23620f292f02SJorge Sanjuan };
23630f292f02SJorge Sanjuan
2364a01df925STakashi Iwai static const struct procunit_value_info updown_proc_info[] = {
236565f25da4SDaniel Mack { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN },
236665f25da4SDaniel Mack { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
2367f0b5e634SDaniel Mack { 0 }
2368f0b5e634SDaniel Mack };
2369a01df925STakashi Iwai static const struct procunit_value_info prologic_proc_info[] = {
237065f25da4SDaniel Mack { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN },
237165f25da4SDaniel Mack { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
2372f0b5e634SDaniel Mack { 0 }
2373f0b5e634SDaniel Mack };
2374a01df925STakashi Iwai static const struct procunit_value_info threed_enh_proc_info[] = {
237565f25da4SDaniel Mack { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN },
237665f25da4SDaniel Mack { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 },
2377f0b5e634SDaniel Mack { 0 }
2378f0b5e634SDaniel Mack };
2379a01df925STakashi Iwai static const struct procunit_value_info reverb_proc_info[] = {
238065f25da4SDaniel Mack { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN },
238165f25da4SDaniel Mack { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
238265f25da4SDaniel Mack { UAC_REVERB_TIME, "Time", USB_MIXER_U16 },
238365f25da4SDaniel Mack { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 },
2384f0b5e634SDaniel Mack { 0 }
2385f0b5e634SDaniel Mack };
2386a01df925STakashi Iwai static const struct procunit_value_info chorus_proc_info[] = {
238765f25da4SDaniel Mack { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN },
238865f25da4SDaniel Mack { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
238965f25da4SDaniel Mack { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
239065f25da4SDaniel Mack { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
2391f0b5e634SDaniel Mack { 0 }
2392f0b5e634SDaniel Mack };
2393a01df925STakashi Iwai static const struct procunit_value_info dcr_proc_info[] = {
239465f25da4SDaniel Mack { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN },
239565f25da4SDaniel Mack { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 },
239665f25da4SDaniel Mack { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 },
239765f25da4SDaniel Mack { UAC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
239865f25da4SDaniel Mack { UAC_DCR_ATTACK_TIME, "Attack Time", USB_MIXER_U16 },
239965f25da4SDaniel Mack { UAC_DCR_RELEASE_TIME, "Release Time", USB_MIXER_U16 },
2400f0b5e634SDaniel Mack { 0 }
2401f0b5e634SDaniel Mack };
2402f0b5e634SDaniel Mack
2403a01df925STakashi Iwai static const struct procunit_info procunits[] = {
240465f25da4SDaniel Mack { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info },
240565f25da4SDaniel Mack { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info },
240665f25da4SDaniel Mack { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info },
240765f25da4SDaniel Mack { UAC_PROCESS_REVERB, "Reverb", reverb_proc_info },
240865f25da4SDaniel Mack { UAC_PROCESS_CHORUS, "Chorus", chorus_proc_info },
240965f25da4SDaniel Mack { UAC_PROCESS_DYN_RANGE_COMP, "DCR", dcr_proc_info },
2410f0b5e634SDaniel Mack { 0 },
2411f0b5e634SDaniel Mack };
24120f292f02SJorge Sanjuan
2413a01df925STakashi Iwai static const struct procunit_value_info uac3_updown_proc_info[] = {
24140f292f02SJorge Sanjuan { UAC3_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
24150f292f02SJorge Sanjuan { 0 }
24160f292f02SJorge Sanjuan };
2417a01df925STakashi Iwai static const struct procunit_value_info uac3_stereo_ext_proc_info[] = {
24180f292f02SJorge Sanjuan { UAC3_EXT_WIDTH_CONTROL, "Width Control", USB_MIXER_U8 },
24190f292f02SJorge Sanjuan { 0 }
24200f292f02SJorge Sanjuan };
24210f292f02SJorge Sanjuan
2422a01df925STakashi Iwai static const struct procunit_info uac3_procunits[] = {
24230f292f02SJorge Sanjuan { UAC3_PROCESS_UP_DOWNMIX, "Up Down", uac3_updown_proc_info },
24240f292f02SJorge Sanjuan { UAC3_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", uac3_stereo_ext_proc_info },
24250f292f02SJorge Sanjuan { UAC3_PROCESS_MULTI_FUNCTION, "Multi-Function", undefined_proc_info },
24260f292f02SJorge Sanjuan { 0 },
24270f292f02SJorge Sanjuan };
24280f292f02SJorge Sanjuan
2429f0b5e634SDaniel Mack /*
2430f0b5e634SDaniel Mack * predefined data for extension units
2431f0b5e634SDaniel Mack */
2432a01df925STakashi Iwai static const struct procunit_value_info clock_rate_xu_info[] = {
2433f0b5e634SDaniel Mack { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
2434f0b5e634SDaniel Mack { 0 }
2435f0b5e634SDaniel Mack };
2436a01df925STakashi Iwai static const struct procunit_value_info clock_source_xu_info[] = {
2437f0b5e634SDaniel Mack { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
2438f0b5e634SDaniel Mack { 0 }
2439f0b5e634SDaniel Mack };
2440a01df925STakashi Iwai static const struct procunit_value_info spdif_format_xu_info[] = {
2441f0b5e634SDaniel Mack { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
2442f0b5e634SDaniel Mack { 0 }
2443f0b5e634SDaniel Mack };
2444a01df925STakashi Iwai static const struct procunit_value_info soft_limit_xu_info[] = {
2445f0b5e634SDaniel Mack { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
2446f0b5e634SDaniel Mack { 0 }
2447f0b5e634SDaniel Mack };
2448a01df925STakashi Iwai static const struct procunit_info extunits[] = {
2449f0b5e634SDaniel Mack { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
2450f0b5e634SDaniel Mack { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
2451f0b5e634SDaniel Mack { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
2452f0b5e634SDaniel Mack { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
2453f0b5e634SDaniel Mack { 0 }
2454f0b5e634SDaniel Mack };
24556bc170e4SDaniel Mack
2456f0b5e634SDaniel Mack /*
2457f0b5e634SDaniel Mack * build a processing/extension unit
2458f0b5e634SDaniel Mack */
build_audio_procunit(struct mixer_build * state,int unitid,void * raw_desc,const struct procunit_info * list,bool extension_unit)24596bc170e4SDaniel Mack static int build_audio_procunit(struct mixer_build *state, int unitid,
2460a01df925STakashi Iwai void *raw_desc, const struct procunit_info *list,
2461ca95c7bfSTakashi Iwai bool extension_unit)
2462f0b5e634SDaniel Mack {
246399fc8645SDaniel Mack struct uac_processing_unit_descriptor *desc = raw_desc;
2464f4351a19STakashi Iwai int num_ins;
2465f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval;
2466f0b5e634SDaniel Mack struct snd_kcontrol *kctl;
2467d8d0db7bSTom Yan int i, err, nameid, type, len, val;
2468a01df925STakashi Iwai const struct procunit_info *info;
2469a01df925STakashi Iwai const struct procunit_value_info *valinfo;
2470f0b5e634SDaniel Mack const struct usbmix_name_map *map;
2471a01df925STakashi Iwai static const struct procunit_value_info default_value_info[] = {
2472f0b5e634SDaniel Mack { 0x01, "Switch", USB_MIXER_BOOLEAN },
2473f0b5e634SDaniel Mack { 0 }
2474f0b5e634SDaniel Mack };
2475a01df925STakashi Iwai static const struct procunit_info default_info = {
2476f0b5e634SDaniel Mack 0, NULL, default_value_info
2477f0b5e634SDaniel Mack };
2478ca95c7bfSTakashi Iwai const char *name = extension_unit ?
2479ca95c7bfSTakashi Iwai "Extension Unit" : "Processing Unit";
2480f0b5e634SDaniel Mack
2481f4351a19STakashi Iwai num_ins = desc->bNrInPins;
2482f0b5e634SDaniel Mack for (i = 0; i < num_ins; i++) {
2483f25ecf8fSTakashi Iwai err = parse_audio_unit(state, desc->baSourceID[i]);
2484f25ecf8fSTakashi Iwai if (err < 0)
2485f0b5e634SDaniel Mack return err;
2486f0b5e634SDaniel Mack }
2487f0b5e634SDaniel Mack
248899fc8645SDaniel Mack type = le16_to_cpu(desc->wProcessType);
2489f0b5e634SDaniel Mack for (info = list; info && info->type; info++)
2490f0b5e634SDaniel Mack if (info->type == type)
2491f0b5e634SDaniel Mack break;
2492f0b5e634SDaniel Mack if (!info || !info->type)
2493f0b5e634SDaniel Mack info = &default_info;
2494f0b5e634SDaniel Mack
2495f0b5e634SDaniel Mack for (valinfo = info->values; valinfo->control; valinfo++) {
249623caaf19SDaniel Mack __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
249799fc8645SDaniel Mack
24984e887af3SJorge Sanjuan if (state->mixer->protocol == UAC_VERSION_1) {
24994e887af3SJorge Sanjuan if (!(controls[valinfo->control / 8] &
25004e887af3SJorge Sanjuan (1 << ((valinfo->control % 8) - 1))))
2501f0b5e634SDaniel Mack continue;
25024e887af3SJorge Sanjuan } else { /* UAC_VERSION_2/3 */
25034e887af3SJorge Sanjuan if (!uac_v2v3_control_is_readable(controls[valinfo->control / 8],
25044e887af3SJorge Sanjuan valinfo->control))
25054e887af3SJorge Sanjuan continue;
25064e887af3SJorge Sanjuan }
25074e887af3SJorge Sanjuan
250817156f23SRuslan Bilovol map = find_map(state->map, unitid, valinfo->control);
2509f0b5e634SDaniel Mack if (check_ignored_ctl(map))
2510f0b5e634SDaniel Mack continue;
2511f0b5e634SDaniel Mack cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2512a860d95fSDaniel Mack if (!cval)
2513f0b5e634SDaniel Mack return -ENOMEM;
25143360b84bSTakashi Iwai snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2515f0b5e634SDaniel Mack cval->control = valinfo->control;
2516f0b5e634SDaniel Mack cval->val_type = valinfo->val_type;
2517f0b5e634SDaniel Mack cval->channels = 1;
2518f0b5e634SDaniel Mack
25194e887af3SJorge Sanjuan if (state->mixer->protocol > UAC_VERSION_1 &&
25204e887af3SJorge Sanjuan !uac_v2v3_control_is_writeable(controls[valinfo->control / 8],
25214e887af3SJorge Sanjuan valinfo->control))
25224e887af3SJorge Sanjuan cval->master_readonly = 1;
25234e887af3SJorge Sanjuan
2524f0b5e634SDaniel Mack /* get min/max values */
252555b8cb46SJorge Sanjuan switch (type) {
252655b8cb46SJorge Sanjuan case UAC_PROCESS_UP_DOWNMIX: {
252755b8cb46SJorge Sanjuan bool mode_sel = false;
252855b8cb46SJorge Sanjuan
252955b8cb46SJorge Sanjuan switch (state->mixer->protocol) {
253055b8cb46SJorge Sanjuan case UAC_VERSION_1:
253155b8cb46SJorge Sanjuan case UAC_VERSION_2:
253255b8cb46SJorge Sanjuan default:
253355b8cb46SJorge Sanjuan if (cval->control == UAC_UD_MODE_SELECT)
253455b8cb46SJorge Sanjuan mode_sel = true;
253555b8cb46SJorge Sanjuan break;
253655b8cb46SJorge Sanjuan case UAC_VERSION_3:
253755b8cb46SJorge Sanjuan if (cval->control == UAC3_UD_MODE_SELECT)
253855b8cb46SJorge Sanjuan mode_sel = true;
253955b8cb46SJorge Sanjuan break;
254055b8cb46SJorge Sanjuan }
254155b8cb46SJorge Sanjuan
254255b8cb46SJorge Sanjuan if (mode_sel) {
254355b8cb46SJorge Sanjuan __u8 *control_spec = uac_processing_unit_specific(desc,
254455b8cb46SJorge Sanjuan state->mixer->protocol);
2545f0b5e634SDaniel Mack cval->min = 1;
254699fc8645SDaniel Mack cval->max = control_spec[0];
2547f0b5e634SDaniel Mack cval->res = 1;
2548f0b5e634SDaniel Mack cval->initialized = 1;
254955b8cb46SJorge Sanjuan break;
255055b8cb46SJorge Sanjuan }
255155b8cb46SJorge Sanjuan
255255b8cb46SJorge Sanjuan get_min_max(cval, valinfo->min_value);
255355b8cb46SJorge Sanjuan break;
255455b8cb46SJorge Sanjuan }
255555b8cb46SJorge Sanjuan case USB_XU_CLOCK_RATE:
25566bc170e4SDaniel Mack /*
25576bc170e4SDaniel Mack * E-Mu USB 0404/0202/TrackerPre/0204
2558f0b5e634SDaniel Mack * samplerate control quirk
2559f0b5e634SDaniel Mack */
2560f0b5e634SDaniel Mack cval->min = 0;
2561f0b5e634SDaniel Mack cval->max = 5;
2562f0b5e634SDaniel Mack cval->res = 1;
2563f0b5e634SDaniel Mack cval->initialized = 1;
256455b8cb46SJorge Sanjuan break;
256555b8cb46SJorge Sanjuan default:
2566f0b5e634SDaniel Mack get_min_max(cval, valinfo->min_value);
256755b8cb46SJorge Sanjuan break;
2568f0b5e634SDaniel Mack }
2569f0b5e634SDaniel Mack
2570d8d0db7bSTom Yan err = get_cur_ctl_value(cval, cval->control << 8, &val);
2571d8d0db7bSTom Yan if (err < 0) {
2572d8d0db7bSTom Yan usb_mixer_elem_info_free(cval);
2573d8d0db7bSTom Yan return -EINVAL;
2574d8d0db7bSTom Yan }
2575d8d0db7bSTom Yan
2576f0b5e634SDaniel Mack kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
2577f0b5e634SDaniel Mack if (!kctl) {
257852c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
2579f0b5e634SDaniel Mack return -ENOMEM;
2580f0b5e634SDaniel Mack }
2581eef90451SChris J Arges kctl->private_free = snd_usb_mixer_elem_free;
2582f0b5e634SDaniel Mack
25836bc170e4SDaniel Mack if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name))) {
2584f0b5e634SDaniel Mack /* nothing */ ;
25856bc170e4SDaniel Mack } else if (info->name) {
258675b1a8f9SJoe Perches strscpy(kctl->id.name, info->name, sizeof(kctl->id.name));
25876bc170e4SDaniel Mack } else {
2588ca95c7bfSTakashi Iwai if (extension_unit)
2589ca95c7bfSTakashi Iwai nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol);
2590ca95c7bfSTakashi Iwai else
259123caaf19SDaniel Mack nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
2592f0b5e634SDaniel Mack len = 0;
2593f0b5e634SDaniel Mack if (nameid)
2594eccfc1b8SRuslan Bilovol len = snd_usb_copy_string_desc(state->chip,
2595eccfc1b8SRuslan Bilovol nameid,
25966bc170e4SDaniel Mack kctl->id.name,
25976bc170e4SDaniel Mack sizeof(kctl->id.name));
2598f0b5e634SDaniel Mack if (!len)
259975b1a8f9SJoe Perches strscpy(kctl->id.name, name, sizeof(kctl->id.name));
2600f0b5e634SDaniel Mack }
2601f0b5e634SDaniel Mack append_ctl_name(kctl, " ");
2602f0b5e634SDaniel Mack append_ctl_name(kctl, valinfo->suffix);
2603f0b5e634SDaniel Mack
26040ba41d91STakashi Iwai usb_audio_dbg(state->chip,
26050ba41d91STakashi Iwai "[%d] PU [%s] ch = %d, val = %d/%d\n",
26063360b84bSTakashi Iwai cval->head.id, kctl->id.name, cval->channels,
26076bc170e4SDaniel Mack cval->min, cval->max);
26086bc170e4SDaniel Mack
26093360b84bSTakashi Iwai err = snd_usb_mixer_add_control(&cval->head, kctl);
26106bc170e4SDaniel Mack if (err < 0)
2611f0b5e634SDaniel Mack return err;
2612f0b5e634SDaniel Mack }
2613f0b5e634SDaniel Mack return 0;
2614f0b5e634SDaniel Mack }
2615f0b5e634SDaniel Mack
parse_audio_processing_unit(struct mixer_build * state,int unitid,void * raw_desc)26166bc170e4SDaniel Mack static int parse_audio_processing_unit(struct mixer_build *state, int unitid,
26176bc170e4SDaniel Mack void *raw_desc)
2618f0b5e634SDaniel Mack {
26190f292f02SJorge Sanjuan switch (state->mixer->protocol) {
26200f292f02SJorge Sanjuan case UAC_VERSION_1:
26210f292f02SJorge Sanjuan case UAC_VERSION_2:
26220f292f02SJorge Sanjuan default:
26236bc170e4SDaniel Mack return build_audio_procunit(state, unitid, raw_desc,
2624ca95c7bfSTakashi Iwai procunits, false);
26250f292f02SJorge Sanjuan case UAC_VERSION_3:
26260f292f02SJorge Sanjuan return build_audio_procunit(state, unitid, raw_desc,
2627ca95c7bfSTakashi Iwai uac3_procunits, false);
26280f292f02SJorge Sanjuan }
2629f0b5e634SDaniel Mack }
2630f0b5e634SDaniel Mack
parse_audio_extension_unit(struct mixer_build * state,int unitid,void * raw_desc)26316bc170e4SDaniel Mack static int parse_audio_extension_unit(struct mixer_build *state, int unitid,
26326bc170e4SDaniel Mack void *raw_desc)
2633f0b5e634SDaniel Mack {
26346bc170e4SDaniel Mack /*
26356bc170e4SDaniel Mack * Note that we parse extension units with processing unit descriptors.
26366bc170e4SDaniel Mack * That's ok as the layout is the same.
26376bc170e4SDaniel Mack */
2638ca95c7bfSTakashi Iwai return build_audio_procunit(state, unitid, raw_desc, extunits, true);
2639f0b5e634SDaniel Mack }
2640f0b5e634SDaniel Mack
2641f0b5e634SDaniel Mack /*
2642f0b5e634SDaniel Mack * Selector Unit
2643f0b5e634SDaniel Mack */
2644f0b5e634SDaniel Mack
26456bc170e4SDaniel Mack /*
26466bc170e4SDaniel Mack * info callback for selector unit
2647f0b5e634SDaniel Mack * use an enumerator type for routing
2648f0b5e634SDaniel Mack */
mixer_ctl_selector_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)26496bc170e4SDaniel Mack static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol,
26506bc170e4SDaniel Mack struct snd_ctl_elem_info *uinfo)
2651f0b5e634SDaniel Mack {
2652f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
26532a1803a7SClemens Ladisch const char **itemlist = (const char **)kcontrol->private_value;
2654f0b5e634SDaniel Mack
2655f0b5e634SDaniel Mack if (snd_BUG_ON(!itemlist))
2656f0b5e634SDaniel Mack return -EINVAL;
26572a1803a7SClemens Ladisch return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist);
2658f0b5e634SDaniel Mack }
2659f0b5e634SDaniel Mack
2660f0b5e634SDaniel Mack /* get callback for selector unit */
mixer_ctl_selector_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)26616bc170e4SDaniel Mack static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol,
26626bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
2663f0b5e634SDaniel Mack {
2664f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
2665f0b5e634SDaniel Mack int val, err;
2666f0b5e634SDaniel Mack
266709414207SDaniel Mack err = get_cur_ctl_value(cval, cval->control << 8, &val);
2668f0b5e634SDaniel Mack if (err < 0) {
2669f0b5e634SDaniel Mack ucontrol->value.enumerated.item[0] = 0;
26705aeee342STakashi Iwai return filter_error(cval, err);
2671f0b5e634SDaniel Mack }
2672f0b5e634SDaniel Mack val = get_relative_value(cval, val);
2673f0b5e634SDaniel Mack ucontrol->value.enumerated.item[0] = val;
2674f0b5e634SDaniel Mack return 0;
2675f0b5e634SDaniel Mack }
2676f0b5e634SDaniel Mack
2677f0b5e634SDaniel Mack /* put callback for selector unit */
mixer_ctl_selector_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)26786bc170e4SDaniel Mack static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol,
26796bc170e4SDaniel Mack struct snd_ctl_elem_value *ucontrol)
2680f0b5e634SDaniel Mack {
2681f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kcontrol->private_data;
2682f0b5e634SDaniel Mack int val, oval, err;
2683f0b5e634SDaniel Mack
268409414207SDaniel Mack err = get_cur_ctl_value(cval, cval->control << 8, &oval);
26855aeee342STakashi Iwai if (err < 0)
26865aeee342STakashi Iwai return filter_error(cval, err);
2687f0b5e634SDaniel Mack val = ucontrol->value.enumerated.item[0];
2688f0b5e634SDaniel Mack val = get_abs_value(cval, val);
2689f0b5e634SDaniel Mack if (val != oval) {
269009414207SDaniel Mack set_cur_ctl_value(cval, cval->control << 8, val);
2691f0b5e634SDaniel Mack return 1;
2692f0b5e634SDaniel Mack }
2693f0b5e634SDaniel Mack return 0;
2694f0b5e634SDaniel Mack }
2695f0b5e634SDaniel Mack
2696f0b5e634SDaniel Mack /* alsa control interface for selector unit */
26978fdaebbbSBhumika Goyal static const struct snd_kcontrol_new mixer_selectunit_ctl = {
2698f0b5e634SDaniel Mack .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2699f0b5e634SDaniel Mack .name = "", /* will be filled later */
2700f0b5e634SDaniel Mack .info = mixer_ctl_selector_info,
2701f0b5e634SDaniel Mack .get = mixer_ctl_selector_get,
2702f0b5e634SDaniel Mack .put = mixer_ctl_selector_put,
2703f0b5e634SDaniel Mack };
2704f0b5e634SDaniel Mack
27056bc170e4SDaniel Mack /*
27066bc170e4SDaniel Mack * private free callback.
2707f0b5e634SDaniel Mack * free both private_data and private_value
2708f0b5e634SDaniel Mack */
usb_mixer_selector_elem_free(struct snd_kcontrol * kctl)2709f0b5e634SDaniel Mack static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
2710f0b5e634SDaniel Mack {
2711f0b5e634SDaniel Mack int i, num_ins = 0;
2712f0b5e634SDaniel Mack
2713f0b5e634SDaniel Mack if (kctl->private_data) {
2714f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval = kctl->private_data;
2715f0b5e634SDaniel Mack num_ins = cval->max;
271652c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
2717f0b5e634SDaniel Mack kctl->private_data = NULL;
2718f0b5e634SDaniel Mack }
2719f0b5e634SDaniel Mack if (kctl->private_value) {
2720f0b5e634SDaniel Mack char **itemlist = (char **)kctl->private_value;
2721f0b5e634SDaniel Mack for (i = 0; i < num_ins; i++)
2722f0b5e634SDaniel Mack kfree(itemlist[i]);
2723f0b5e634SDaniel Mack kfree(itemlist);
2724f0b5e634SDaniel Mack kctl->private_value = 0;
2725f0b5e634SDaniel Mack }
2726f0b5e634SDaniel Mack }
2727f0b5e634SDaniel Mack
2728f0b5e634SDaniel Mack /*
2729f0b5e634SDaniel Mack * parse a selector unit
2730f0b5e634SDaniel Mack */
parse_audio_selector_unit(struct mixer_build * state,int unitid,void * raw_desc)27316bc170e4SDaniel Mack static int parse_audio_selector_unit(struct mixer_build *state, int unitid,
27326bc170e4SDaniel Mack void *raw_desc)
2733f0b5e634SDaniel Mack {
273499fc8645SDaniel Mack struct uac_selector_unit_descriptor *desc = raw_desc;
2735f0b5e634SDaniel Mack unsigned int i, nameid, len;
2736f0b5e634SDaniel Mack int err;
2737f0b5e634SDaniel Mack struct usb_mixer_elem_info *cval;
2738f0b5e634SDaniel Mack struct snd_kcontrol *kctl;
2739f0b5e634SDaniel Mack const struct usbmix_name_map *map;
2740f0b5e634SDaniel Mack char **namelist;
2741f0b5e634SDaniel Mack
274299fc8645SDaniel Mack for (i = 0; i < desc->bNrInPins; i++) {
2743f25ecf8fSTakashi Iwai err = parse_audio_unit(state, desc->baSourceID[i]);
2744f25ecf8fSTakashi Iwai if (err < 0)
2745f0b5e634SDaniel Mack return err;
2746f0b5e634SDaniel Mack }
2747f0b5e634SDaniel Mack
274899fc8645SDaniel Mack if (desc->bNrInPins == 1) /* only one ? nonsense! */
2749f0b5e634SDaniel Mack return 0;
2750f0b5e634SDaniel Mack
275117156f23SRuslan Bilovol map = find_map(state->map, unitid, 0);
2752f0b5e634SDaniel Mack if (check_ignored_ctl(map))
2753f0b5e634SDaniel Mack return 0;
2754f0b5e634SDaniel Mack
2755f0b5e634SDaniel Mack cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2756a860d95fSDaniel Mack if (!cval)
2757f0b5e634SDaniel Mack return -ENOMEM;
27583360b84bSTakashi Iwai snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2759f0b5e634SDaniel Mack cval->val_type = USB_MIXER_U8;
2760f0b5e634SDaniel Mack cval->channels = 1;
2761f0b5e634SDaniel Mack cval->min = 1;
276299fc8645SDaniel Mack cval->max = desc->bNrInPins;
2763f0b5e634SDaniel Mack cval->res = 1;
2764f0b5e634SDaniel Mack cval->initialized = 1;
2765f0b5e634SDaniel Mack
2766c77e1ef1SJorge Sanjuan switch (state->mixer->protocol) {
2767c77e1ef1SJorge Sanjuan case UAC_VERSION_1:
2768c77e1ef1SJorge Sanjuan default:
276909414207SDaniel Mack cval->control = 0;
2770c77e1ef1SJorge Sanjuan break;
2771c77e1ef1SJorge Sanjuan case UAC_VERSION_2:
2772c77e1ef1SJorge Sanjuan case UAC_VERSION_3:
2773c77e1ef1SJorge Sanjuan if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR ||
2774c77e1ef1SJorge Sanjuan desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR)
2775c77e1ef1SJorge Sanjuan cval->control = UAC2_CX_CLOCK_SELECTOR;
2776c77e1ef1SJorge Sanjuan else /* UAC2/3_SELECTOR_UNIT */
2777c77e1ef1SJorge Sanjuan cval->control = UAC2_SU_SELECTOR;
2778c77e1ef1SJorge Sanjuan break;
2779c77e1ef1SJorge Sanjuan }
278009414207SDaniel Mack
278152c3e317STakashi Iwai namelist = kcalloc(desc->bNrInPins, sizeof(char *), GFP_KERNEL);
2782f0b5e634SDaniel Mack if (!namelist) {
278352c3e317STakashi Iwai err = -ENOMEM;
278452c3e317STakashi Iwai goto error_cval;
2785f0b5e634SDaniel Mack }
2786f0b5e634SDaniel Mack #define MAX_ITEM_NAME_LEN 64
278799fc8645SDaniel Mack for (i = 0; i < desc->bNrInPins; i++) {
2788f0b5e634SDaniel Mack struct usb_audio_term iterm;
2789f0b5e634SDaniel Mack namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
2790f0b5e634SDaniel Mack if (!namelist[i]) {
279152c3e317STakashi Iwai err = -ENOMEM;
279252c3e317STakashi Iwai goto error_name;
2793f0b5e634SDaniel Mack }
2794f0b5e634SDaniel Mack len = check_mapped_selector_name(state, unitid, i, namelist[i],
2795f0b5e634SDaniel Mack MAX_ITEM_NAME_LEN);
279699fc8645SDaniel Mack if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
2797eccfc1b8SRuslan Bilovol len = get_term_name(state->chip, &iterm, namelist[i],
2798eccfc1b8SRuslan Bilovol MAX_ITEM_NAME_LEN, 0);
2799f0b5e634SDaniel Mack if (! len)
2800af831eefSMasanari Iida sprintf(namelist[i], "Input %u", i);
2801f0b5e634SDaniel Mack }
2802f0b5e634SDaniel Mack
2803f0b5e634SDaniel Mack kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
2804f0b5e634SDaniel Mack if (! kctl) {
28050ba41d91STakashi Iwai usb_audio_err(state->chip, "cannot malloc kcontrol\n");
280652c3e317STakashi Iwai err = -ENOMEM;
280752c3e317STakashi Iwai goto error_name;
2808f0b5e634SDaniel Mack }
2809f0b5e634SDaniel Mack kctl->private_value = (unsigned long)namelist;
2810f0b5e634SDaniel Mack kctl->private_free = usb_mixer_selector_elem_free;
2811f0b5e634SDaniel Mack
28125a15f289STakashi Iwai /* check the static mapping table at first */
2813f0b5e634SDaniel Mack len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
28145a15f289STakashi Iwai if (!len) {
28155a15f289STakashi Iwai /* no mapping ? */
2816c77e1ef1SJorge Sanjuan switch (state->mixer->protocol) {
2817c77e1ef1SJorge Sanjuan case UAC_VERSION_1:
2818c77e1ef1SJorge Sanjuan case UAC_VERSION_2:
2819c77e1ef1SJorge Sanjuan default:
28205a15f289STakashi Iwai /* if iSelector is given, use it */
28215a15f289STakashi Iwai nameid = uac_selector_unit_iSelector(desc);
28225a15f289STakashi Iwai if (nameid)
2823c77e1ef1SJorge Sanjuan len = snd_usb_copy_string_desc(state->chip,
2824c77e1ef1SJorge Sanjuan nameid, kctl->id.name,
28256bc170e4SDaniel Mack sizeof(kctl->id.name));
2826c77e1ef1SJorge Sanjuan break;
2827c77e1ef1SJorge Sanjuan case UAC_VERSION_3:
2828c77e1ef1SJorge Sanjuan /* TODO: Class-Specific strings not yet supported */
2829c77e1ef1SJorge Sanjuan break;
2830c77e1ef1SJorge Sanjuan }
2831c77e1ef1SJorge Sanjuan
28325a15f289STakashi Iwai /* ... or pick up the terminal name at next */
28335a15f289STakashi Iwai if (!len)
2834eccfc1b8SRuslan Bilovol len = get_term_name(state->chip, &state->oterm,
2835f0b5e634SDaniel Mack kctl->id.name, sizeof(kctl->id.name), 0);
28365a15f289STakashi Iwai /* ... or use the fixed string "USB" as the last resort */
2837f0b5e634SDaniel Mack if (!len)
283875b1a8f9SJoe Perches strscpy(kctl->id.name, "USB", sizeof(kctl->id.name));
2839f0b5e634SDaniel Mack
28405a15f289STakashi Iwai /* and add the proper suffix */
2841c77e1ef1SJorge Sanjuan if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR ||
2842c77e1ef1SJorge Sanjuan desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR)
284309414207SDaniel Mack append_ctl_name(kctl, " Clock Source");
284409414207SDaniel Mack else if ((state->oterm.type & 0xff00) == 0x0100)
2845f0b5e634SDaniel Mack append_ctl_name(kctl, " Capture Source");
2846f0b5e634SDaniel Mack else
2847f0b5e634SDaniel Mack append_ctl_name(kctl, " Playback Source");
2848f0b5e634SDaniel Mack }
2849f0b5e634SDaniel Mack
28500ba41d91STakashi Iwai usb_audio_dbg(state->chip, "[%d] SU [%s] items = %d\n",
28513360b84bSTakashi Iwai cval->head.id, kctl->id.name, desc->bNrInPins);
28523360b84bSTakashi Iwai return snd_usb_mixer_add_control(&cval->head, kctl);
285352c3e317STakashi Iwai
285452c3e317STakashi Iwai error_name:
285552c3e317STakashi Iwai for (i = 0; i < desc->bNrInPins; i++)
285652c3e317STakashi Iwai kfree(namelist[i]);
285752c3e317STakashi Iwai kfree(namelist);
285852c3e317STakashi Iwai error_cval:
285952c3e317STakashi Iwai usb_mixer_elem_info_free(cval);
286052c3e317STakashi Iwai return err;
2861f0b5e634SDaniel Mack }
2862f0b5e634SDaniel Mack
2863f0b5e634SDaniel Mack /*
2864f0b5e634SDaniel Mack * parse an audio unit recursively
2865f0b5e634SDaniel Mack */
2866f0b5e634SDaniel Mack
parse_audio_unit(struct mixer_build * state,int unitid)2867f0b5e634SDaniel Mack static int parse_audio_unit(struct mixer_build *state, int unitid)
2868f0b5e634SDaniel Mack {
2869f0b5e634SDaniel Mack unsigned char *p1;
28709a2fe9b8SRuslan Bilovol int protocol = state->mixer->protocol;
2871f0b5e634SDaniel Mack
2872f0b5e634SDaniel Mack if (test_and_set_bit(unitid, state->unitbitmap))
2873f0b5e634SDaniel Mack return 0; /* the unit already visited */
2874f0b5e634SDaniel Mack
2875f0b5e634SDaniel Mack p1 = find_audio_control_unit(state, unitid);
2876f0b5e634SDaniel Mack if (!p1) {
28770ba41d91STakashi Iwai usb_audio_err(state->chip, "unit %d not found!\n", unitid);
2878f0b5e634SDaniel Mack return -EINVAL;
2879f0b5e634SDaniel Mack }
2880f0b5e634SDaniel Mack
288157f87706STakashi Iwai if (!snd_usb_validate_audio_desc(p1, protocol)) {
288257f87706STakashi Iwai usb_audio_dbg(state->chip, "invalid unit %d\n", unitid);
288357f87706STakashi Iwai return 0; /* skip invalid unit */
288457f87706STakashi Iwai }
288557f87706STakashi Iwai
288668e9fde2STakashi Iwai switch (PTYPE(protocol, p1[2])) {
288768e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL):
288868e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL):
288968e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL):
28905a222e84SAndrew Chant return parse_audio_input_terminal(state, unitid, p1);
289168e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT):
289268e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT):
289368e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT):
2894f0b5e634SDaniel Mack return parse_audio_mixer_unit(state, unitid, p1);
289568e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE):
289668e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE):
2897cddaafb9SDaniel Mack return parse_clock_source_unit(state, unitid, p1);
289868e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT):
289968e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT):
290068e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT):
290168e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR):
290268e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR):
2903f0b5e634SDaniel Mack return parse_audio_selector_unit(state, unitid, p1);
290468e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT):
290568e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT):
290668e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT):
2907f0b5e634SDaniel Mack return parse_audio_feature_unit(state, unitid, p1);
290868e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT):
290968e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2):
291068e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT):
2911f0b5e634SDaniel Mack return parse_audio_processing_unit(state, unitid, p1);
291268e9fde2STakashi Iwai case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT):
291368e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2):
291468e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT):
291568e9fde2STakashi Iwai return parse_audio_extension_unit(state, unitid, p1);
291668e9fde2STakashi Iwai case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT):
291768e9fde2STakashi Iwai case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT):
291823caaf19SDaniel Mack return 0; /* FIXME - effect units not implemented yet */
2919f0b5e634SDaniel Mack default:
29200ba41d91STakashi Iwai usb_audio_err(state->chip,
292168e9fde2STakashi Iwai "unit %u: unexpected type 0x%02x\n",
292268e9fde2STakashi Iwai unitid, p1[2]);
2923f0b5e634SDaniel Mack return -EINVAL;
2924f0b5e634SDaniel Mack }
2925f0b5e634SDaniel Mack }
2926f0b5e634SDaniel Mack
snd_usb_mixer_free(struct usb_mixer_interface * mixer)2927f0b5e634SDaniel Mack static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2928f0b5e634SDaniel Mack {
2929124751d5STakashi Iwai /* kill pending URBs */
2930124751d5STakashi Iwai snd_usb_mixer_disconnect(mixer);
2931124751d5STakashi Iwai
2932f0b5e634SDaniel Mack kfree(mixer->id_elems);
2933f0b5e634SDaniel Mack if (mixer->urb) {
2934f0b5e634SDaniel Mack kfree(mixer->urb->transfer_buffer);
2935f0b5e634SDaniel Mack usb_free_urb(mixer->urb);
2936f0b5e634SDaniel Mack }
2937f0b5e634SDaniel Mack usb_free_urb(mixer->rc_urb);
2938f0b5e634SDaniel Mack kfree(mixer->rc_setup_packet);
2939f0b5e634SDaniel Mack kfree(mixer);
2940f0b5e634SDaniel Mack }
2941f0b5e634SDaniel Mack
snd_usb_mixer_dev_free(struct snd_device * device)2942f0b5e634SDaniel Mack static int snd_usb_mixer_dev_free(struct snd_device *device)
2943f0b5e634SDaniel Mack {
2944f0b5e634SDaniel Mack struct usb_mixer_interface *mixer = device->device_data;
2945f0b5e634SDaniel Mack snd_usb_mixer_free(mixer);
2946f0b5e634SDaniel Mack return 0;
2947f0b5e634SDaniel Mack }
2948f0b5e634SDaniel Mack
294917156f23SRuslan Bilovol /* UAC3 predefined channels configuration */
295017156f23SRuslan Bilovol struct uac3_badd_profile {
295117156f23SRuslan Bilovol int subclass;
295217156f23SRuslan Bilovol const char *name;
295317156f23SRuslan Bilovol int c_chmask; /* capture channels mask */
295417156f23SRuslan Bilovol int p_chmask; /* playback channels mask */
295517156f23SRuslan Bilovol int st_chmask; /* side tone mixing channel mask */
295617156f23SRuslan Bilovol };
295717156f23SRuslan Bilovol
2958a01df925STakashi Iwai static const struct uac3_badd_profile uac3_badd_profiles[] = {
295917156f23SRuslan Bilovol {
296017156f23SRuslan Bilovol /*
296117156f23SRuslan Bilovol * BAIF, BAOF or combination of both
296217156f23SRuslan Bilovol * IN: Mono or Stereo cfg, Mono alt possible
296317156f23SRuslan Bilovol * OUT: Mono or Stereo cfg, Mono alt possible
296417156f23SRuslan Bilovol */
296517156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_GENERIC_IO,
296617156f23SRuslan Bilovol .name = "GENERIC IO",
296717156f23SRuslan Bilovol .c_chmask = -1, /* dynamic channels */
296817156f23SRuslan Bilovol .p_chmask = -1, /* dynamic channels */
296917156f23SRuslan Bilovol },
297017156f23SRuslan Bilovol {
297117156f23SRuslan Bilovol /* BAOF; Stereo only cfg, Mono alt possible */
297217156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_HEADPHONE,
297317156f23SRuslan Bilovol .name = "HEADPHONE",
297417156f23SRuslan Bilovol .p_chmask = 3,
297517156f23SRuslan Bilovol },
297617156f23SRuslan Bilovol {
297717156f23SRuslan Bilovol /* BAOF; Mono or Stereo cfg, Mono alt possible */
297817156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKER,
297917156f23SRuslan Bilovol .name = "SPEAKER",
298017156f23SRuslan Bilovol .p_chmask = -1, /* dynamic channels */
298117156f23SRuslan Bilovol },
298217156f23SRuslan Bilovol {
298317156f23SRuslan Bilovol /* BAIF; Mono or Stereo cfg, Mono alt possible */
298417156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_MICROPHONE,
298517156f23SRuslan Bilovol .name = "MICROPHONE",
298617156f23SRuslan Bilovol .c_chmask = -1, /* dynamic channels */
298717156f23SRuslan Bilovol },
298817156f23SRuslan Bilovol {
298917156f23SRuslan Bilovol /*
299017156f23SRuslan Bilovol * BAIOF topology
299117156f23SRuslan Bilovol * IN: Mono only
299217156f23SRuslan Bilovol * OUT: Mono or Stereo cfg, Mono alt possible
299317156f23SRuslan Bilovol */
299417156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET,
299517156f23SRuslan Bilovol .name = "HEADSET",
299617156f23SRuslan Bilovol .c_chmask = 1,
299717156f23SRuslan Bilovol .p_chmask = -1, /* dynamic channels */
299817156f23SRuslan Bilovol .st_chmask = 1,
299917156f23SRuslan Bilovol },
300017156f23SRuslan Bilovol {
300117156f23SRuslan Bilovol /* BAIOF; IN: Mono only; OUT: Stereo only, Mono alt possible */
300217156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER,
300317156f23SRuslan Bilovol .name = "HEADSET ADAPTER",
300417156f23SRuslan Bilovol .c_chmask = 1,
300517156f23SRuslan Bilovol .p_chmask = 3,
300617156f23SRuslan Bilovol .st_chmask = 1,
300717156f23SRuslan Bilovol },
300817156f23SRuslan Bilovol {
300917156f23SRuslan Bilovol /* BAIF + BAOF; IN: Mono only; OUT: Mono only */
301017156f23SRuslan Bilovol .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE,
301117156f23SRuslan Bilovol .name = "SPEAKERPHONE",
301217156f23SRuslan Bilovol .c_chmask = 1,
301317156f23SRuslan Bilovol .p_chmask = 1,
301417156f23SRuslan Bilovol },
301517156f23SRuslan Bilovol { 0 } /* terminator */
301617156f23SRuslan Bilovol };
301717156f23SRuslan Bilovol
uac3_badd_func_has_valid_channels(struct usb_mixer_interface * mixer,const struct uac3_badd_profile * f,int c_chmask,int p_chmask)301817156f23SRuslan Bilovol static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer,
3019a01df925STakashi Iwai const struct uac3_badd_profile *f,
302017156f23SRuslan Bilovol int c_chmask, int p_chmask)
302117156f23SRuslan Bilovol {
302217156f23SRuslan Bilovol /*
302317156f23SRuslan Bilovol * If both playback/capture channels are dynamic, make sure
302417156f23SRuslan Bilovol * at least one channel is present
302517156f23SRuslan Bilovol */
302617156f23SRuslan Bilovol if (f->c_chmask < 0 && f->p_chmask < 0) {
302717156f23SRuslan Bilovol if (!c_chmask && !p_chmask) {
302817156f23SRuslan Bilovol usb_audio_warn(mixer->chip, "BAAD %s: no channels?",
302917156f23SRuslan Bilovol f->name);
303017156f23SRuslan Bilovol return false;
303117156f23SRuslan Bilovol }
303217156f23SRuslan Bilovol return true;
303317156f23SRuslan Bilovol }
303417156f23SRuslan Bilovol
303517156f23SRuslan Bilovol if ((f->c_chmask < 0 && !c_chmask) ||
303617156f23SRuslan Bilovol (f->c_chmask >= 0 && f->c_chmask != c_chmask)) {
303717156f23SRuslan Bilovol usb_audio_warn(mixer->chip, "BAAD %s c_chmask mismatch",
303817156f23SRuslan Bilovol f->name);
303917156f23SRuslan Bilovol return false;
304017156f23SRuslan Bilovol }
304117156f23SRuslan Bilovol if ((f->p_chmask < 0 && !p_chmask) ||
304217156f23SRuslan Bilovol (f->p_chmask >= 0 && f->p_chmask != p_chmask)) {
304317156f23SRuslan Bilovol usb_audio_warn(mixer->chip, "BAAD %s p_chmask mismatch",
304417156f23SRuslan Bilovol f->name);
304517156f23SRuslan Bilovol return false;
304617156f23SRuslan Bilovol }
304717156f23SRuslan Bilovol return true;
304817156f23SRuslan Bilovol }
304917156f23SRuslan Bilovol
305017156f23SRuslan Bilovol /*
305117156f23SRuslan Bilovol * create mixer controls for UAC3 BADD profiles
305217156f23SRuslan Bilovol *
305317156f23SRuslan Bilovol * UAC3 BADD device doesn't contain CS descriptors thus we will guess everything
305417156f23SRuslan Bilovol *
305517156f23SRuslan Bilovol * BADD device may contain Mixer Unit, which doesn't have any controls, skip it
305617156f23SRuslan Bilovol */
snd_usb_mixer_controls_badd(struct usb_mixer_interface * mixer,int ctrlif)305717156f23SRuslan Bilovol static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer,
305817156f23SRuslan Bilovol int ctrlif)
305917156f23SRuslan Bilovol {
306017156f23SRuslan Bilovol struct usb_device *dev = mixer->chip->dev;
306117156f23SRuslan Bilovol struct usb_interface_assoc_descriptor *assoc;
306217156f23SRuslan Bilovol int badd_profile = mixer->chip->badd_profile;
3063a01df925STakashi Iwai const struct uac3_badd_profile *f;
306417156f23SRuslan Bilovol const struct usbmix_ctl_map *map;
306517156f23SRuslan Bilovol int p_chmask = 0, c_chmask = 0, st_chmask = 0;
306617156f23SRuslan Bilovol int i;
306717156f23SRuslan Bilovol
306817156f23SRuslan Bilovol assoc = usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
306917156f23SRuslan Bilovol
307017156f23SRuslan Bilovol /* Detect BADD capture/playback channels from AS EP descriptors */
307117156f23SRuslan Bilovol for (i = 0; i < assoc->bInterfaceCount; i++) {
307217156f23SRuslan Bilovol int intf = assoc->bFirstInterface + i;
307317156f23SRuslan Bilovol
307417156f23SRuslan Bilovol struct usb_interface *iface;
307517156f23SRuslan Bilovol struct usb_host_interface *alts;
307617156f23SRuslan Bilovol struct usb_interface_descriptor *altsd;
307717156f23SRuslan Bilovol unsigned int maxpacksize;
307817156f23SRuslan Bilovol char dir_in;
307917156f23SRuslan Bilovol int chmask, num;
308017156f23SRuslan Bilovol
308117156f23SRuslan Bilovol if (intf == ctrlif)
308217156f23SRuslan Bilovol continue;
308317156f23SRuslan Bilovol
308417156f23SRuslan Bilovol iface = usb_ifnum_to_if(dev, intf);
30859435f2bbSTakashi Iwai if (!iface)
30869435f2bbSTakashi Iwai continue;
30879435f2bbSTakashi Iwai
308817156f23SRuslan Bilovol num = iface->num_altsetting;
308917156f23SRuslan Bilovol
309017156f23SRuslan Bilovol if (num < 2)
309117156f23SRuslan Bilovol return -EINVAL;
309217156f23SRuslan Bilovol
309317156f23SRuslan Bilovol /*
309417156f23SRuslan Bilovol * The number of Channels in an AudioStreaming interface
309517156f23SRuslan Bilovol * and the audio sample bit resolution (16 bits or 24
309617156f23SRuslan Bilovol * bits) can be derived from the wMaxPacketSize field in
309717156f23SRuslan Bilovol * the Standard AS Audio Data Endpoint descriptor in
309817156f23SRuslan Bilovol * Alternate Setting 1
309917156f23SRuslan Bilovol */
310017156f23SRuslan Bilovol alts = &iface->altsetting[1];
310117156f23SRuslan Bilovol altsd = get_iface_desc(alts);
310217156f23SRuslan Bilovol
310317156f23SRuslan Bilovol if (altsd->bNumEndpoints < 1)
310417156f23SRuslan Bilovol return -EINVAL;
310517156f23SRuslan Bilovol
310617156f23SRuslan Bilovol /* check direction */
310717156f23SRuslan Bilovol dir_in = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN);
310817156f23SRuslan Bilovol maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
310917156f23SRuslan Bilovol
311017156f23SRuslan Bilovol switch (maxpacksize) {
311117156f23SRuslan Bilovol default:
311217156f23SRuslan Bilovol usb_audio_err(mixer->chip,
311317156f23SRuslan Bilovol "incorrect wMaxPacketSize 0x%x for BADD profile\n",
311417156f23SRuslan Bilovol maxpacksize);
311517156f23SRuslan Bilovol return -EINVAL;
311617156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16:
311717156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16:
311817156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24:
311917156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24:
312017156f23SRuslan Bilovol chmask = 1;
312117156f23SRuslan Bilovol break;
312217156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16:
312317156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16:
312417156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24:
312517156f23SRuslan Bilovol case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24:
312617156f23SRuslan Bilovol chmask = 3;
312717156f23SRuslan Bilovol break;
312817156f23SRuslan Bilovol }
312917156f23SRuslan Bilovol
313017156f23SRuslan Bilovol if (dir_in)
313117156f23SRuslan Bilovol c_chmask = chmask;
313217156f23SRuslan Bilovol else
313317156f23SRuslan Bilovol p_chmask = chmask;
313417156f23SRuslan Bilovol }
313517156f23SRuslan Bilovol
313617156f23SRuslan Bilovol usb_audio_dbg(mixer->chip,
313717156f23SRuslan Bilovol "UAC3 BADD profile 0x%x: detected c_chmask=%d p_chmask=%d\n",
313817156f23SRuslan Bilovol badd_profile, c_chmask, p_chmask);
313917156f23SRuslan Bilovol
314017156f23SRuslan Bilovol /* check the mapping table */
314117156f23SRuslan Bilovol for (map = uac3_badd_usbmix_ctl_maps; map->id; map++) {
314217156f23SRuslan Bilovol if (map->id == badd_profile)
314317156f23SRuslan Bilovol break;
314417156f23SRuslan Bilovol }
314517156f23SRuslan Bilovol
314617156f23SRuslan Bilovol if (!map->id)
314717156f23SRuslan Bilovol return -EINVAL;
314817156f23SRuslan Bilovol
314917156f23SRuslan Bilovol for (f = uac3_badd_profiles; f->name; f++) {
315017156f23SRuslan Bilovol if (badd_profile == f->subclass)
315117156f23SRuslan Bilovol break;
315217156f23SRuslan Bilovol }
315317156f23SRuslan Bilovol if (!f->name)
315417156f23SRuslan Bilovol return -EINVAL;
315517156f23SRuslan Bilovol if (!uac3_badd_func_has_valid_channels(mixer, f, c_chmask, p_chmask))
315617156f23SRuslan Bilovol return -EINVAL;
315717156f23SRuslan Bilovol st_chmask = f->st_chmask;
315817156f23SRuslan Bilovol
315917156f23SRuslan Bilovol /* Playback */
316017156f23SRuslan Bilovol if (p_chmask) {
316117156f23SRuslan Bilovol /* Master channel, always writable */
316217156f23SRuslan Bilovol build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
316317156f23SRuslan Bilovol UAC3_BADD_FU_ID2, map->map);
316417156f23SRuslan Bilovol /* Mono/Stereo volume channels, always writable */
316517156f23SRuslan Bilovol build_feature_ctl_badd(mixer, p_chmask, UAC_FU_VOLUME,
316617156f23SRuslan Bilovol UAC3_BADD_FU_ID2, map->map);
316717156f23SRuslan Bilovol }
316817156f23SRuslan Bilovol
316917156f23SRuslan Bilovol /* Capture */
317017156f23SRuslan Bilovol if (c_chmask) {
317117156f23SRuslan Bilovol /* Master channel, always writable */
317217156f23SRuslan Bilovol build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
317317156f23SRuslan Bilovol UAC3_BADD_FU_ID5, map->map);
317417156f23SRuslan Bilovol /* Mono/Stereo volume channels, always writable */
317517156f23SRuslan Bilovol build_feature_ctl_badd(mixer, c_chmask, UAC_FU_VOLUME,
317617156f23SRuslan Bilovol UAC3_BADD_FU_ID5, map->map);
317717156f23SRuslan Bilovol }
317817156f23SRuslan Bilovol
317917156f23SRuslan Bilovol /* Side tone-mixing */
318017156f23SRuslan Bilovol if (st_chmask) {
318117156f23SRuslan Bilovol /* Master channel, always writable */
318217156f23SRuslan Bilovol build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
318317156f23SRuslan Bilovol UAC3_BADD_FU_ID7, map->map);
318417156f23SRuslan Bilovol /* Mono volume channel, always writable */
318517156f23SRuslan Bilovol build_feature_ctl_badd(mixer, 1, UAC_FU_VOLUME,
318617156f23SRuslan Bilovol UAC3_BADD_FU_ID7, map->map);
318717156f23SRuslan Bilovol }
318817156f23SRuslan Bilovol
31893528cd8fSJorge Sanjuan /* Insertion Control */
31903528cd8fSJorge Sanjuan if (f->subclass == UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER) {
31913528cd8fSJorge Sanjuan struct usb_audio_term iterm, oterm;
31923528cd8fSJorge Sanjuan
31933528cd8fSJorge Sanjuan /* Input Term - Insertion control */
31943528cd8fSJorge Sanjuan memset(&iterm, 0, sizeof(iterm));
31953528cd8fSJorge Sanjuan iterm.id = UAC3_BADD_IT_ID4;
31963528cd8fSJorge Sanjuan iterm.type = UAC_BIDIR_TERMINAL_HEADSET;
3197934b9659STakashi Iwai build_connector_control(mixer, map->map, &iterm, true);
31983528cd8fSJorge Sanjuan
31993528cd8fSJorge Sanjuan /* Output Term - Insertion control */
32003528cd8fSJorge Sanjuan memset(&oterm, 0, sizeof(oterm));
32013528cd8fSJorge Sanjuan oterm.id = UAC3_BADD_OT_ID3;
32023528cd8fSJorge Sanjuan oterm.type = UAC_BIDIR_TERMINAL_HEADSET;
3203934b9659STakashi Iwai build_connector_control(mixer, map->map, &oterm, false);
32043528cd8fSJorge Sanjuan }
32053528cd8fSJorge Sanjuan
320617156f23SRuslan Bilovol return 0;
320717156f23SRuslan Bilovol }
320817156f23SRuslan Bilovol
3209f0b5e634SDaniel Mack /*
3210f0b5e634SDaniel Mack * create mixer controls
3211f0b5e634SDaniel Mack *
3212f0b5e634SDaniel Mack * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
3213f0b5e634SDaniel Mack */
snd_usb_mixer_controls(struct usb_mixer_interface * mixer)3214f0b5e634SDaniel Mack static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
3215f0b5e634SDaniel Mack {
3216f0b5e634SDaniel Mack struct mixer_build state;
3217f0b5e634SDaniel Mack int err;
3218f0b5e634SDaniel Mack const struct usbmix_ctl_map *map;
321923caaf19SDaniel Mack void *p;
3220f0b5e634SDaniel Mack
3221f0b5e634SDaniel Mack memset(&state, 0, sizeof(state));
3222f0b5e634SDaniel Mack state.chip = mixer->chip;
3223f0b5e634SDaniel Mack state.mixer = mixer;
32241faa5d07SDaniel Mack state.buffer = mixer->hostif->extra;
32251faa5d07SDaniel Mack state.buflen = mixer->hostif->extralen;
3226f0b5e634SDaniel Mack
3227f0b5e634SDaniel Mack /* check the mapping table */
3228f0b5e634SDaniel Mack for (map = usbmix_ctl_maps; map->id; map++) {
3229f0b5e634SDaniel Mack if (map->id == state.chip->usb_id) {
3230f0b5e634SDaniel Mack state.map = map->map;
3231f0b5e634SDaniel Mack state.selector_map = map->selector_map;
3232fef66ae7STakashi Iwai mixer->connector_map = map->connector_map;
3233f0b5e634SDaniel Mack break;
3234f0b5e634SDaniel Mack }
3235f0b5e634SDaniel Mack }
3236f0b5e634SDaniel Mack
323723caaf19SDaniel Mack p = NULL;
32386bc170e4SDaniel Mack while ((p = snd_usb_find_csint_desc(mixer->hostif->extra,
32396bc170e4SDaniel Mack mixer->hostif->extralen,
32401faa5d07SDaniel Mack p, UAC_OUTPUT_TERMINAL)) != NULL) {
324157f87706STakashi Iwai if (!snd_usb_validate_audio_desc(p, mixer->protocol))
324257f87706STakashi Iwai continue; /* skip invalid descriptor */
324357f87706STakashi Iwai
324423caaf19SDaniel Mack if (mixer->protocol == UAC_VERSION_1) {
324569da9bcbSDaniel Mack struct uac1_output_terminal_descriptor *desc = p;
324623caaf19SDaniel Mack
32476bc170e4SDaniel Mack /* mark terminal ID as visited */
32486bc170e4SDaniel Mack set_bit(desc->bTerminalID, state.unitbitmap);
324923caaf19SDaniel Mack state.oterm.id = desc->bTerminalID;
325023caaf19SDaniel Mack state.oterm.type = le16_to_cpu(desc->wTerminalType);
325123caaf19SDaniel Mack state.oterm.name = desc->iTerminal;
325223caaf19SDaniel Mack err = parse_audio_unit(&state, desc->bSourceID);
325383ea5d18SDaniel Mack if (err < 0 && err != -EINVAL)
325423caaf19SDaniel Mack return err;
32559a2fe9b8SRuslan Bilovol } else if (mixer->protocol == UAC_VERSION_2) {
325623caaf19SDaniel Mack struct uac2_output_terminal_descriptor *desc = p;
325723caaf19SDaniel Mack
32586bc170e4SDaniel Mack /* mark terminal ID as visited */
32596bc170e4SDaniel Mack set_bit(desc->bTerminalID, state.unitbitmap);
3260f0b5e634SDaniel Mack state.oterm.id = desc->bTerminalID;
3261f0b5e634SDaniel Mack state.oterm.type = le16_to_cpu(desc->wTerminalType);
3262f0b5e634SDaniel Mack state.oterm.name = desc->iTerminal;
3263f0b5e634SDaniel Mack err = parse_audio_unit(&state, desc->bSourceID);
326483ea5d18SDaniel Mack if (err < 0 && err != -EINVAL)
3265f0b5e634SDaniel Mack return err;
326609414207SDaniel Mack
32676bc170e4SDaniel Mack /*
32686bc170e4SDaniel Mack * For UAC2, use the same approach to also add the
32696bc170e4SDaniel Mack * clock selectors
32706bc170e4SDaniel Mack */
327109414207SDaniel Mack err = parse_audio_unit(&state, desc->bCSourceID);
327283ea5d18SDaniel Mack if (err < 0 && err != -EINVAL)
327309414207SDaniel Mack return err;
32745a222e84SAndrew Chant
32757dc3c5a0STakashi Iwai if ((state.oterm.type & 0xff00) != 0x0100 &&
32767dc3c5a0STakashi Iwai uac_v2v3_control_is_readable(le16_to_cpu(desc->bmControls),
32775a222e84SAndrew Chant UAC2_TE_CONNECTOR)) {
3278934b9659STakashi Iwai build_connector_control(state.mixer, state.map,
3279934b9659STakashi Iwai &state.oterm, false);
32805a222e84SAndrew Chant }
32819a2fe9b8SRuslan Bilovol } else { /* UAC_VERSION_3 */
32829a2fe9b8SRuslan Bilovol struct uac3_output_terminal_descriptor *desc = p;
32839a2fe9b8SRuslan Bilovol
32849a2fe9b8SRuslan Bilovol /* mark terminal ID as visited */
32859a2fe9b8SRuslan Bilovol set_bit(desc->bTerminalID, state.unitbitmap);
32869a2fe9b8SRuslan Bilovol state.oterm.id = desc->bTerminalID;
32879a2fe9b8SRuslan Bilovol state.oterm.type = le16_to_cpu(desc->wTerminalType);
32889a2fe9b8SRuslan Bilovol state.oterm.name = le16_to_cpu(desc->wTerminalDescrStr);
32899a2fe9b8SRuslan Bilovol err = parse_audio_unit(&state, desc->bSourceID);
32909a2fe9b8SRuslan Bilovol if (err < 0 && err != -EINVAL)
32919a2fe9b8SRuslan Bilovol return err;
32929a2fe9b8SRuslan Bilovol
32939a2fe9b8SRuslan Bilovol /*
32949a2fe9b8SRuslan Bilovol * For UAC3, use the same approach to also add the
32959a2fe9b8SRuslan Bilovol * clock selectors
32969a2fe9b8SRuslan Bilovol */
32979a2fe9b8SRuslan Bilovol err = parse_audio_unit(&state, desc->bCSourceID);
32989a2fe9b8SRuslan Bilovol if (err < 0 && err != -EINVAL)
32999a2fe9b8SRuslan Bilovol return err;
33001d38f5d8SJorge Sanjuan
33017dc3c5a0STakashi Iwai if ((state.oterm.type & 0xff00) != 0x0100 &&
33027dc3c5a0STakashi Iwai uac_v2v3_control_is_readable(le32_to_cpu(desc->bmControls),
33031d38f5d8SJorge Sanjuan UAC3_TE_INSERTION)) {
3304934b9659STakashi Iwai build_connector_control(state.mixer, state.map,
3305934b9659STakashi Iwai &state.oterm, false);
33061d38f5d8SJorge Sanjuan }
3307f0b5e634SDaniel Mack }
330823caaf19SDaniel Mack }
330923caaf19SDaniel Mack
3310f0b5e634SDaniel Mack return 0;
3311f0b5e634SDaniel Mack }
3312f0b5e634SDaniel Mack
delegate_notify(struct usb_mixer_interface * mixer,int unitid,u8 * control,u8 * channel)3313fef66ae7STakashi Iwai static int delegate_notify(struct usb_mixer_interface *mixer, int unitid,
3314fef66ae7STakashi Iwai u8 *control, u8 *channel)
3315fef66ae7STakashi Iwai {
3316fef66ae7STakashi Iwai const struct usbmix_connector_map *map = mixer->connector_map;
3317fef66ae7STakashi Iwai
3318fef66ae7STakashi Iwai if (!map)
3319fef66ae7STakashi Iwai return unitid;
3320fef66ae7STakashi Iwai
3321fef66ae7STakashi Iwai for (; map->id; map++) {
3322fef66ae7STakashi Iwai if (map->id == unitid) {
3323fef66ae7STakashi Iwai if (control && map->control)
3324fef66ae7STakashi Iwai *control = map->control;
3325fef66ae7STakashi Iwai if (channel && map->channel)
3326fef66ae7STakashi Iwai *channel = map->channel;
3327fef66ae7STakashi Iwai return map->delegated_id;
3328fef66ae7STakashi Iwai }
3329fef66ae7STakashi Iwai }
3330fef66ae7STakashi Iwai return unitid;
3331fef66ae7STakashi Iwai }
3332fef66ae7STakashi Iwai
snd_usb_mixer_notify_id(struct usb_mixer_interface * mixer,int unitid)3333f0b5e634SDaniel Mack void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
3334f0b5e634SDaniel Mack {
33353360b84bSTakashi Iwai struct usb_mixer_elem_list *list;
3336f0b5e634SDaniel Mack
3337fef66ae7STakashi Iwai unitid = delegate_notify(mixer, unitid, NULL, NULL);
3338fef66ae7STakashi Iwai
33398c558076STakashi Iwai for_each_mixer_elem(list, mixer, unitid) {
3340220345e9STakashi Iwai struct usb_mixer_elem_info *info;
3341220345e9STakashi Iwai
3342220345e9STakashi Iwai if (!list->is_std_info)
3343220345e9STakashi Iwai continue;
3344220345e9STakashi Iwai info = mixer_elem_list_to_info(list);
3345b2500b58SJulian Scheel /* invalidate cache, so the value is read from the device */
3346b2500b58SJulian Scheel info->cached = 0;
3347f0b5e634SDaniel Mack snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
33483360b84bSTakashi Iwai &list->kctl->id);
3349f0b5e634SDaniel Mack }
3350b2500b58SJulian Scheel }
3351f0b5e634SDaniel Mack
snd_usb_mixer_dump_cval(struct snd_info_buffer * buffer,struct usb_mixer_elem_list * list)3352f0b5e634SDaniel Mack static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
33533360b84bSTakashi Iwai struct usb_mixer_elem_list *list)
3354f0b5e634SDaniel Mack {
33558c558076STakashi Iwai struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3356362372ceSTakashi Iwai static const char * const val_types[] = {
335764752a95STakashi Iwai [USB_MIXER_BOOLEAN] = "BOOLEAN",
335864752a95STakashi Iwai [USB_MIXER_INV_BOOLEAN] = "INV_BOOLEAN",
335964752a95STakashi Iwai [USB_MIXER_S8] = "S8",
336064752a95STakashi Iwai [USB_MIXER_U8] = "U8",
336164752a95STakashi Iwai [USB_MIXER_S16] = "S16",
336264752a95STakashi Iwai [USB_MIXER_U16] = "U16",
336364752a95STakashi Iwai [USB_MIXER_S32] = "S32",
336464752a95STakashi Iwai [USB_MIXER_U32] = "U32",
336564752a95STakashi Iwai [USB_MIXER_BESPOKEN] = "BESPOKEN",
3366362372ceSTakashi Iwai };
3367f0b5e634SDaniel Mack snd_iprintf(buffer, " Info: id=%i, control=%i, cmask=0x%x, "
33683360b84bSTakashi Iwai "channels=%i, type=\"%s\"\n", cval->head.id,
3369f0b5e634SDaniel Mack cval->control, cval->cmask, cval->channels,
3370f0b5e634SDaniel Mack val_types[cval->val_type]);
3371f0b5e634SDaniel Mack snd_iprintf(buffer, " Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
3372f0b5e634SDaniel Mack cval->min, cval->max, cval->dBmin, cval->dBmax);
3373f0b5e634SDaniel Mack }
3374f0b5e634SDaniel Mack
snd_usb_mixer_proc_read(struct snd_info_entry * entry,struct snd_info_buffer * buffer)3375f0b5e634SDaniel Mack static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
3376f0b5e634SDaniel Mack struct snd_info_buffer *buffer)
3377f0b5e634SDaniel Mack {
3378f0b5e634SDaniel Mack struct snd_usb_audio *chip = entry->private_data;
3379f0b5e634SDaniel Mack struct usb_mixer_interface *mixer;
33803360b84bSTakashi Iwai struct usb_mixer_elem_list *list;
3381f0b5e634SDaniel Mack int unitid;
3382f0b5e634SDaniel Mack
3383f0b5e634SDaniel Mack list_for_each_entry(mixer, &chip->mixer_list, list) {
3384f0b5e634SDaniel Mack snd_iprintf(buffer,
3385f0b5e634SDaniel Mack "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
33860aef31b7SChris Wulff chip->usb_id, mixer_ctrl_intf(mixer),
3387f0b5e634SDaniel Mack mixer->ignore_ctl_error);
3388f0b5e634SDaniel Mack snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
3389f0b5e634SDaniel Mack for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
33908c558076STakashi Iwai for_each_mixer_elem(list, mixer, unitid) {
33913360b84bSTakashi Iwai snd_iprintf(buffer, " Unit: %i\n", list->id);
33923360b84bSTakashi Iwai if (list->kctl)
33933360b84bSTakashi Iwai snd_iprintf(buffer,
33943360b84bSTakashi Iwai " Control: name=\"%s\", index=%i\n",
33953360b84bSTakashi Iwai list->kctl->id.name,
33963360b84bSTakashi Iwai list->kctl->id.index);
33973360b84bSTakashi Iwai if (list->dump)
33983360b84bSTakashi Iwai list->dump(buffer, list);
33993360b84bSTakashi Iwai }
3400f0b5e634SDaniel Mack }
3401f0b5e634SDaniel Mack }
3402f0b5e634SDaniel Mack }
3403f0b5e634SDaniel Mack
snd_usb_mixer_interrupt_v2(struct usb_mixer_interface * mixer,int attribute,int value,int index)3404e213e9cfSDaniel Mack static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
3405e213e9cfSDaniel Mack int attribute, int value, int index)
3406e213e9cfSDaniel Mack {
34073360b84bSTakashi Iwai struct usb_mixer_elem_list *list;
3408e213e9cfSDaniel Mack __u8 unitid = (index >> 8) & 0xff;
3409e213e9cfSDaniel Mack __u8 control = (value >> 8) & 0xff;
3410e213e9cfSDaniel Mack __u8 channel = value & 0xff;
3411191227d9SDaniel Mack unsigned int count = 0;
3412e213e9cfSDaniel Mack
3413e213e9cfSDaniel Mack if (channel >= MAX_CHANNELS) {
34140ba41d91STakashi Iwai usb_audio_dbg(mixer->chip,
34150ba41d91STakashi Iwai "%s(): bogus channel number %d\n",
3416e213e9cfSDaniel Mack __func__, channel);
3417e213e9cfSDaniel Mack return;
3418e213e9cfSDaniel Mack }
3419e213e9cfSDaniel Mack
3420fef66ae7STakashi Iwai unitid = delegate_notify(mixer, unitid, &control, &channel);
3421fef66ae7STakashi Iwai
34228c558076STakashi Iwai for_each_mixer_elem(list, mixer, unitid)
3423191227d9SDaniel Mack count++;
3424191227d9SDaniel Mack
3425191227d9SDaniel Mack if (count == 0)
3426191227d9SDaniel Mack return;
3427191227d9SDaniel Mack
34288c558076STakashi Iwai for_each_mixer_elem(list, mixer, unitid) {
34293360b84bSTakashi Iwai struct usb_mixer_elem_info *info;
34303360b84bSTakashi Iwai
34313360b84bSTakashi Iwai if (!list->kctl)
34323360b84bSTakashi Iwai continue;
3433220345e9STakashi Iwai if (!list->is_std_info)
3434220345e9STakashi Iwai continue;
34353360b84bSTakashi Iwai
34368c558076STakashi Iwai info = mixer_elem_list_to_info(list);
3437191227d9SDaniel Mack if (count > 1 && info->control != control)
3438e213e9cfSDaniel Mack continue;
3439e213e9cfSDaniel Mack
3440e213e9cfSDaniel Mack switch (attribute) {
3441e213e9cfSDaniel Mack case UAC2_CS_CUR:
3442e213e9cfSDaniel Mack /* invalidate cache, so the value is read from the device */
3443e213e9cfSDaniel Mack if (channel)
3444e213e9cfSDaniel Mack info->cached &= ~(1 << channel);
3445e213e9cfSDaniel Mack else /* master channel */
3446e213e9cfSDaniel Mack info->cached = 0;
3447e213e9cfSDaniel Mack
3448e213e9cfSDaniel Mack snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
34493360b84bSTakashi Iwai &info->head.kctl->id);
3450e213e9cfSDaniel Mack break;
3451e213e9cfSDaniel Mack
3452e213e9cfSDaniel Mack case UAC2_CS_RANGE:
3453e213e9cfSDaniel Mack /* TODO */
3454e213e9cfSDaniel Mack break;
3455e213e9cfSDaniel Mack
3456e213e9cfSDaniel Mack case UAC2_CS_MEM:
3457e213e9cfSDaniel Mack /* TODO */
3458e213e9cfSDaniel Mack break;
3459e213e9cfSDaniel Mack
3460e213e9cfSDaniel Mack default:
34610ba41d91STakashi Iwai usb_audio_dbg(mixer->chip,
34620ba41d91STakashi Iwai "unknown attribute %d in interrupt\n",
3463e213e9cfSDaniel Mack attribute);
3464e213e9cfSDaniel Mack break;
3465e213e9cfSDaniel Mack } /* switch */
3466e213e9cfSDaniel Mack }
3467e213e9cfSDaniel Mack }
3468e213e9cfSDaniel Mack
snd_usb_mixer_interrupt(struct urb * urb)3469e213e9cfSDaniel Mack static void snd_usb_mixer_interrupt(struct urb *urb)
3470f0b5e634SDaniel Mack {
3471f0b5e634SDaniel Mack struct usb_mixer_interface *mixer = urb->context;
3472e213e9cfSDaniel Mack int len = urb->actual_length;
3473edf7de31SOliver Neukum int ustatus = urb->status;
3474f0b5e634SDaniel Mack
3475edf7de31SOliver Neukum if (ustatus != 0)
3476e213e9cfSDaniel Mack goto requeue;
3477f0b5e634SDaniel Mack
3478e213e9cfSDaniel Mack if (mixer->protocol == UAC_VERSION_1) {
3479e213e9cfSDaniel Mack struct uac1_status_word *status;
3480e213e9cfSDaniel Mack
3481e213e9cfSDaniel Mack for (status = urb->transfer_buffer;
3482e213e9cfSDaniel Mack len >= sizeof(*status);
3483e213e9cfSDaniel Mack len -= sizeof(*status), status++) {
34840ba41d91STakashi Iwai dev_dbg(&urb->dev->dev, "status interrupt: %02x %02x\n",
3485e213e9cfSDaniel Mack status->bStatusType,
3486e213e9cfSDaniel Mack status->bOriginator);
3487e213e9cfSDaniel Mack
3488f0b5e634SDaniel Mack /* ignore any notifications not from the control interface */
3489e213e9cfSDaniel Mack if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) !=
3490e213e9cfSDaniel Mack UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF)
3491f0b5e634SDaniel Mack continue;
3492e213e9cfSDaniel Mack
3493e213e9cfSDaniel Mack if (status->bStatusType & UAC1_STATUS_TYPE_MEM_CHANGED)
3494e213e9cfSDaniel Mack snd_usb_mixer_rc_memory_change(mixer, status->bOriginator);
3495f0b5e634SDaniel Mack else
3496e213e9cfSDaniel Mack snd_usb_mixer_notify_id(mixer, status->bOriginator);
3497e213e9cfSDaniel Mack }
3498e213e9cfSDaniel Mack } else { /* UAC_VERSION_2 */
3499e213e9cfSDaniel Mack struct uac2_interrupt_data_msg *msg;
3500e213e9cfSDaniel Mack
3501e213e9cfSDaniel Mack for (msg = urb->transfer_buffer;
3502e213e9cfSDaniel Mack len >= sizeof(*msg);
3503e213e9cfSDaniel Mack len -= sizeof(*msg), msg++) {
3504e213e9cfSDaniel Mack /* drop vendor specific and endpoint requests */
3505e213e9cfSDaniel Mack if ((msg->bInfo & UAC2_INTERRUPT_DATA_MSG_VENDOR) ||
3506e213e9cfSDaniel Mack (msg->bInfo & UAC2_INTERRUPT_DATA_MSG_EP))
3507e213e9cfSDaniel Mack continue;
3508e213e9cfSDaniel Mack
3509e213e9cfSDaniel Mack snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute,
3510e213e9cfSDaniel Mack le16_to_cpu(msg->wValue),
3511e213e9cfSDaniel Mack le16_to_cpu(msg->wIndex));
3512f0b5e634SDaniel Mack }
3513f0b5e634SDaniel Mack }
3514e213e9cfSDaniel Mack
3515e213e9cfSDaniel Mack requeue:
35166bc170e4SDaniel Mack if (ustatus != -ENOENT &&
35176bc170e4SDaniel Mack ustatus != -ECONNRESET &&
35186bc170e4SDaniel Mack ustatus != -ESHUTDOWN) {
3519f0b5e634SDaniel Mack urb->dev = mixer->chip->dev;
3520f0b5e634SDaniel Mack usb_submit_urb(urb, GFP_ATOMIC);
3521f0b5e634SDaniel Mack }
3522f0b5e634SDaniel Mack }
3523f0b5e634SDaniel Mack
3524f0b5e634SDaniel Mack /* create the handler for the optional status interrupt endpoint */
snd_usb_mixer_status_create(struct usb_mixer_interface * mixer)3525f0b5e634SDaniel Mack static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
3526f0b5e634SDaniel Mack {
3527f0b5e634SDaniel Mack struct usb_endpoint_descriptor *ep;
3528f0b5e634SDaniel Mack void *transfer_buffer;
3529f0b5e634SDaniel Mack int buffer_length;
3530f0b5e634SDaniel Mack unsigned int epnum;
3531f0b5e634SDaniel Mack
3532f0b5e634SDaniel Mack /* we need one interrupt input endpoint */
35331faa5d07SDaniel Mack if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1)
3534f0b5e634SDaniel Mack return 0;
35351faa5d07SDaniel Mack ep = get_endpoint(mixer->hostif, 0);
3536f0b5e634SDaniel Mack if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_int(ep))
3537f0b5e634SDaniel Mack return 0;
3538f0b5e634SDaniel Mack
3539f0b5e634SDaniel Mack epnum = usb_endpoint_num(ep);
3540f0b5e634SDaniel Mack buffer_length = le16_to_cpu(ep->wMaxPacketSize);
3541f0b5e634SDaniel Mack transfer_buffer = kmalloc(buffer_length, GFP_KERNEL);
3542f0b5e634SDaniel Mack if (!transfer_buffer)
3543f0b5e634SDaniel Mack return -ENOMEM;
3544f0b5e634SDaniel Mack mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3545f0b5e634SDaniel Mack if (!mixer->urb) {
3546f0b5e634SDaniel Mack kfree(transfer_buffer);
3547f0b5e634SDaniel Mack return -ENOMEM;
3548f0b5e634SDaniel Mack }
3549f0b5e634SDaniel Mack usb_fill_int_urb(mixer->urb, mixer->chip->dev,
3550f0b5e634SDaniel Mack usb_rcvintpipe(mixer->chip->dev, epnum),
3551f0b5e634SDaniel Mack transfer_buffer, buffer_length,
3552e213e9cfSDaniel Mack snd_usb_mixer_interrupt, mixer, ep->bInterval);
3553f0b5e634SDaniel Mack usb_submit_urb(mixer->urb, GFP_KERNEL);
3554f0b5e634SDaniel Mack return 0;
3555f0b5e634SDaniel Mack }
3556f0b5e634SDaniel Mack
snd_usb_create_mixer(struct snd_usb_audio * chip,int ctrlif)35573c69dc91STakashi Iwai int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif)
3558f0b5e634SDaniel Mack {
3559c0a142e2STakashi Iwai static const struct snd_device_ops dev_ops = {
3560f0b5e634SDaniel Mack .dev_free = snd_usb_mixer_dev_free
3561f0b5e634SDaniel Mack };
3562f0b5e634SDaniel Mack struct usb_mixer_interface *mixer;
356323caaf19SDaniel Mack int err;
3564f0b5e634SDaniel Mack
3565f0b5e634SDaniel Mack strcpy(chip->card->mixername, "USB Mixer");
3566f0b5e634SDaniel Mack
3567f0b5e634SDaniel Mack mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
3568f0b5e634SDaniel Mack if (!mixer)
3569f0b5e634SDaniel Mack return -ENOMEM;
3570f0b5e634SDaniel Mack mixer->chip = chip;
35713c69dc91STakashi Iwai mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR);
3572f0b5e634SDaniel Mack mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
3573f0b5e634SDaniel Mack GFP_KERNEL);
3574f0b5e634SDaniel Mack if (!mixer->id_elems) {
3575f0b5e634SDaniel Mack kfree(mixer);
3576f0b5e634SDaniel Mack return -ENOMEM;
3577f0b5e634SDaniel Mack }
3578f0b5e634SDaniel Mack
35791faa5d07SDaniel Mack mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
35801faa5d07SDaniel Mack switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) {
3581a2acad82SClemens Ladisch case UAC_VERSION_1:
3582a2acad82SClemens Ladisch default:
3583a2acad82SClemens Ladisch mixer->protocol = UAC_VERSION_1;
3584a2acad82SClemens Ladisch break;
3585a2acad82SClemens Ladisch case UAC_VERSION_2:
3586a2acad82SClemens Ladisch mixer->protocol = UAC_VERSION_2;
3587a2acad82SClemens Ladisch break;
35889a2fe9b8SRuslan Bilovol case UAC_VERSION_3:
35899a2fe9b8SRuslan Bilovol mixer->protocol = UAC_VERSION_3;
35909a2fe9b8SRuslan Bilovol break;
3591a2acad82SClemens Ladisch }
3592f0b5e634SDaniel Mack
359317156f23SRuslan Bilovol if (mixer->protocol == UAC_VERSION_3 &&
359417156f23SRuslan Bilovol chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
3595f25ecf8fSTakashi Iwai err = snd_usb_mixer_controls_badd(mixer, ctrlif);
3596f25ecf8fSTakashi Iwai if (err < 0)
3597f0b5e634SDaniel Mack goto _error;
3598f25ecf8fSTakashi Iwai } else {
3599f25ecf8fSTakashi Iwai err = snd_usb_mixer_controls(mixer);
3600f25ecf8fSTakashi Iwai if (err < 0)
3601f25ecf8fSTakashi Iwai goto _error;
3602ad6baae6SJorge Sanjuan }
3603ad6baae6SJorge Sanjuan
3604f25ecf8fSTakashi Iwai err = snd_usb_mixer_status_create(mixer);
3605f25ecf8fSTakashi Iwai if (err < 0)
360617156f23SRuslan Bilovol goto _error;
3607ad6baae6SJorge Sanjuan
3608328e9f69STakashi Iwai err = snd_usb_mixer_apply_create_quirk(mixer);
3609328e9f69STakashi Iwai if (err < 0)
3610328e9f69STakashi Iwai goto _error;
3611f0b5e634SDaniel Mack
36129cbb2808STakashi Iwai err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops);
3613f0b5e634SDaniel Mack if (err < 0)
3614f0b5e634SDaniel Mack goto _error;
3615f0b5e634SDaniel Mack
36167449054aSTakashi Iwai if (list_empty(&chip->mixer_list))
36177449054aSTakashi Iwai snd_card_ro_proc_new(chip->card, "usbmixer", chip,
36187449054aSTakashi Iwai snd_usb_mixer_proc_read);
3619f0b5e634SDaniel Mack
3620f0b5e634SDaniel Mack list_add(&mixer->list, &chip->mixer_list);
3621f0b5e634SDaniel Mack return 0;
3622f0b5e634SDaniel Mack
3623f0b5e634SDaniel Mack _error:
3624f0b5e634SDaniel Mack snd_usb_mixer_free(mixer);
3625f0b5e634SDaniel Mack return err;
3626f0b5e634SDaniel Mack }
3627f0b5e634SDaniel Mack
snd_usb_mixer_disconnect(struct usb_mixer_interface * mixer)3628a6cece9dSTakashi Iwai void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
3629f0b5e634SDaniel Mack {
3630124751d5STakashi Iwai if (mixer->disconnected)
3631124751d5STakashi Iwai return;
3632124751d5STakashi Iwai if (mixer->urb)
3633f0b5e634SDaniel Mack usb_kill_urb(mixer->urb);
3634124751d5STakashi Iwai if (mixer->rc_urb)
3635f0b5e634SDaniel Mack usb_kill_urb(mixer->rc_urb);
36369e4d5c1bSGeoffrey D. Bennett if (mixer->private_free)
36379e4d5c1bSGeoffrey D. Bennett mixer->private_free(mixer);
3638124751d5STakashi Iwai mixer->disconnected = true;
3639f0b5e634SDaniel Mack }
3640400362f1STakashi Iwai
3641400362f1STakashi Iwai /* stop any bus activity of a mixer */
snd_usb_mixer_inactivate(struct usb_mixer_interface * mixer)3642400362f1STakashi Iwai static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
3643400362f1STakashi Iwai {
3644400362f1STakashi Iwai usb_kill_urb(mixer->urb);
3645400362f1STakashi Iwai usb_kill_urb(mixer->rc_urb);
3646400362f1STakashi Iwai }
3647400362f1STakashi Iwai
snd_usb_mixer_activate(struct usb_mixer_interface * mixer)3648400362f1STakashi Iwai static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
3649400362f1STakashi Iwai {
3650400362f1STakashi Iwai int err;
3651400362f1STakashi Iwai
3652400362f1STakashi Iwai if (mixer->urb) {
3653400362f1STakashi Iwai err = usb_submit_urb(mixer->urb, GFP_NOIO);
3654400362f1STakashi Iwai if (err < 0)
3655400362f1STakashi Iwai return err;
3656400362f1STakashi Iwai }
3657400362f1STakashi Iwai
3658400362f1STakashi Iwai return 0;
3659400362f1STakashi Iwai }
3660400362f1STakashi Iwai
snd_usb_mixer_suspend(struct usb_mixer_interface * mixer)3661400362f1STakashi Iwai int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
3662400362f1STakashi Iwai {
3663400362f1STakashi Iwai snd_usb_mixer_inactivate(mixer);
36649e4d5c1bSGeoffrey D. Bennett if (mixer->private_suspend)
36659e4d5c1bSGeoffrey D. Bennett mixer->private_suspend(mixer);
3666400362f1STakashi Iwai return 0;
3667400362f1STakashi Iwai }
3668400362f1STakashi Iwai
restore_mixer_value(struct usb_mixer_elem_list * list)36693360b84bSTakashi Iwai static int restore_mixer_value(struct usb_mixer_elem_list *list)
3670400362f1STakashi Iwai {
36718c558076STakashi Iwai struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3672400362f1STakashi Iwai int c, err, idx;
3673400362f1STakashi Iwai
3674785b6f29STakashi Iwai if (cval->val_type == USB_MIXER_BESPOKEN)
3675785b6f29STakashi Iwai return 0;
3676785b6f29STakashi Iwai
3677400362f1STakashi Iwai if (cval->cmask) {
3678400362f1STakashi Iwai idx = 0;
3679400362f1STakashi Iwai for (c = 0; c < MAX_CHANNELS; c++) {
3680400362f1STakashi Iwai if (!(cval->cmask & (1 << c)))
3681400362f1STakashi Iwai continue;
36826aa6925cSYao-Wen Mao if (cval->cached & (1 << (c + 1))) {
3683eef90451SChris J Arges err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
3684400362f1STakashi Iwai cval->cache_val[idx]);
3685400362f1STakashi Iwai if (err < 0)
36869a5adeb2STakashi Iwai break;
3687400362f1STakashi Iwai }
3688400362f1STakashi Iwai idx++;
3689400362f1STakashi Iwai }
3690400362f1STakashi Iwai } else {
3691400362f1STakashi Iwai /* master */
36929a5adeb2STakashi Iwai if (cval->cached)
36939a5adeb2STakashi Iwai snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
3694400362f1STakashi Iwai }
3695400362f1STakashi Iwai
3696400362f1STakashi Iwai return 0;
3697400362f1STakashi Iwai }
3698400362f1STakashi Iwai
snd_usb_mixer_resume(struct usb_mixer_interface * mixer)36997b9cf903STakashi Iwai int snd_usb_mixer_resume(struct usb_mixer_interface *mixer)
3700400362f1STakashi Iwai {
37013360b84bSTakashi Iwai struct usb_mixer_elem_list *list;
3702400362f1STakashi Iwai int id, err;
3703400362f1STakashi Iwai
3704400362f1STakashi Iwai /* restore cached mixer values */
3705400362f1STakashi Iwai for (id = 0; id < MAX_ID_ELEMS; id++) {
37068c558076STakashi Iwai for_each_mixer_elem(list, mixer, id) {
37077b9cf903STakashi Iwai if (list->resume) {
37087b9cf903STakashi Iwai err = list->resume(list);
3709400362f1STakashi Iwai if (err < 0)
3710400362f1STakashi Iwai return err;
3711400362f1STakashi Iwai }
3712400362f1STakashi Iwai }
3713400362f1STakashi Iwai }
3714400362f1STakashi Iwai
3715964af639STakashi Iwai snd_usb_mixer_resume_quirk(mixer);
3716964af639STakashi Iwai
3717400362f1STakashi Iwai return snd_usb_mixer_activate(mixer);
3718400362f1STakashi Iwai }
37193360b84bSTakashi Iwai
snd_usb_mixer_elem_init_std(struct usb_mixer_elem_list * list,struct usb_mixer_interface * mixer,int unitid)37203360b84bSTakashi Iwai void snd_usb_mixer_elem_init_std(struct usb_mixer_elem_list *list,
37213360b84bSTakashi Iwai struct usb_mixer_interface *mixer,
37223360b84bSTakashi Iwai int unitid)
37233360b84bSTakashi Iwai {
37243360b84bSTakashi Iwai list->mixer = mixer;
37253360b84bSTakashi Iwai list->id = unitid;
37263360b84bSTakashi Iwai list->dump = snd_usb_mixer_dump_cval;
37277b9cf903STakashi Iwai list->resume = restore_mixer_value;
37283360b84bSTakashi Iwai }
3729