sound/usb/mixer.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   (Tentative) USB Audio Driver for ALSA
0004  *
0005  *   Mixer control part
0006  *
0007  *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
0008  *
0009  *   Many codes borrowed from audio.c by
0010  *      Alan Cox (alan@lxorguk.ukuu.org.uk)
0011  *      Thomas Sailer (sailer@ife.ee.ethz.ch)
0012  */
0013
0014 /*
0015  * TODOs, for both the mixer and the streaming interfaces:
0016  *
0017  *  - support for UAC2 effect units
0018  *  - support for graphical equalizers
0019  *  - RANGE and MEM set commands (UAC2)
0020  *  - RANGE and MEM interrupt dispatchers (UAC2)
0021  *  - audio channel clustering (UAC2)
0022  *  - audio sample rate converter units (UAC2)
0023  *  - proper handling of clock multipliers (UAC2)
0024  *  - dispatch clock change notifications (UAC2)
0025  *      - stop PCM streams which use a clock that became invalid
0026  *      - stop PCM streams which use a clock selector that has changed
0027  *      - parse available sample rates again when clock sources changed
0028  */
0029
0030 #include <linux/bitops.h>
0031 #include <linux/init.h>
0032 #include <linux/list.h>
0033 #include <linux/log2.h>
0034 #include <linux/slab.h>
0035 #include <linux/string.h>
0036 #include <linux/usb.h>
0037 #include <linux/usb/audio.h>
0038 #include <linux/usb/audio-v2.h>
0039 #include <linux/usb/audio-v3.h>
0040
0041 #include <sound/core.h>
0042 #include <sound/control.h>
0043 #include <sound/hwdep.h>
0044 #include <sound/info.h>
0045 #include <sound/tlv.h>
0046
0047 #include "usbaudio.h"
0048 #include "mixer.h"
0049 #include "helper.h"
0050 #include "mixer_quirks.h"
0051 #include "power.h"
0052
0053 #define MAX_ID_ELEMS    256
0054
0055 struct usb_audio_term {
0056     int id;
0057     int type;
0058     int channels;
0059     unsigned int chconfig;
0060     int name;
0061 };
0062
0063 struct usbmix_name_map;
0064
0065 struct mixer_build {
0066     struct snd_usb_audio *chip;
0067     struct usb_mixer_interface *mixer;
0068     unsigned char *buffer;
0069     unsigned int buflen;
0070     DECLARE_BITMAP(unitbitmap, MAX_ID_ELEMS);
0071     DECLARE_BITMAP(termbitmap, MAX_ID_ELEMS);
0072     struct usb_audio_term oterm;
0073     const struct usbmix_name_map *map;
0074     const struct usbmix_selector_map *selector_map;
0075 };
0076
0077 /*E-mu 0202/0404/0204 eXtension Unit(XU) control*/
0078 enum {
0079     USB_XU_CLOCK_RATE       = 0xe301,
0080     USB_XU_CLOCK_SOURCE     = 0xe302,
0081     USB_XU_DIGITAL_IO_STATUS    = 0xe303,
0082     USB_XU_DEVICE_OPTIONS       = 0xe304,
0083     USB_XU_DIRECT_MONITORING    = 0xe305,
0084     USB_XU_METERING         = 0xe306
0085 };
0086 enum {
0087     USB_XU_CLOCK_SOURCE_SELECTOR = 0x02,    /* clock source*/
0088     USB_XU_CLOCK_RATE_SELECTOR = 0x03,  /* clock rate */
0089     USB_XU_DIGITAL_FORMAT_SELECTOR = 0x01,  /* the spdif format */
0090     USB_XU_SOFT_LIMIT_SELECTOR = 0x03   /* soft limiter */
0091 };
0092
0093 /*
0094  * manual mapping of mixer names
0095  * if the mixer topology is too complicated and the parsed names are
0096  * ambiguous, add the entries in usbmixer_maps.c.
0097  */
0098 #include "mixer_maps.c"
0099
0100 static const struct usbmix_name_map *
0101 find_map(const struct usbmix_name_map *p, int unitid, int control)
0102 {
0103     if (!p)
0104         return NULL;
0105
0106     for (; p->id; p++) {
0107         if (p->id == unitid &&
0108             (!control || !p->control || control == p->control))
0109             return p;
0110     }
0111     return NULL;
0112 }
0113
0114 /* get the mapped name if the unit matches */
0115 static int
0116 check_mapped_name(const struct usbmix_name_map *p, char *buf, int buflen)
0117 {
0118     int len;
0119
0120     if (!p || !p->name)
0121         return 0;
0122
0123     buflen--;
0124     len = strscpy(buf, p->name, buflen);
0125     return len < 0 ? buflen : len;
0126 }
0127
0128 /* ignore the error value if ignore_ctl_error flag is set */
0129 #define filter_error(cval, err) \
0130     ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
0131
0132 /* check whether the control should be ignored */
0133 static inline int
0134 check_ignored_ctl(const struct usbmix_name_map *p)
0135 {
0136     if (!p || p->name || p->dB)
0137         return 0;
0138     return 1;
0139 }
0140
0141 /* dB mapping */
0142 static inline void check_mapped_dB(const struct usbmix_name_map *p,
0143                    struct usb_mixer_elem_info *cval)
0144 {
0145     if (p && p->dB) {
0146         cval->dBmin = p->dB->min;
0147         cval->dBmax = p->dB->max;
0148         cval->min_mute = p->dB->min_mute;
0149         cval->initialized = 1;
0150     }
0151 }
0152
0153 /* get the mapped selector source name */
0154 static int check_mapped_selector_name(struct mixer_build *state, int unitid,
0155                       int index, char *buf, int buflen)
0156 {
0157     const struct usbmix_selector_map *p;
0158     int len;
0159
0160     if (!state->selector_map)
0161         return 0;
0162     for (p = state->selector_map; p->id; p++) {
0163         if (p->id == unitid && index < p->count) {
0164             len = strscpy(buf, p->names[index], buflen);
0165             return len < 0 ? buflen : len;
0166         }
0167     }
0168     return 0;
0169 }
0170
0171 /*
0172  * find an audio control unit with the given unit id
0173  */
0174 static void *find_audio_control_unit(struct mixer_build *state,
0175                      unsigned char unit)
0176 {
0177     /* we just parse the header */
0178     struct uac_feature_unit_descriptor *hdr = NULL;
0179
0180     while ((hdr = snd_usb_find_desc(state->buffer, state->buflen, hdr,
0181                     USB_DT_CS_INTERFACE)) != NULL) {
0182         if (hdr->bLength >= 4 &&
0183             hdr->bDescriptorSubtype >= UAC_INPUT_TERMINAL &&
0184             hdr->bDescriptorSubtype <= UAC3_SAMPLE_RATE_CONVERTER &&
0185             hdr->bUnitID == unit)
0186             return hdr;
0187     }
0188
0189     return NULL;
0190 }
0191
0192 /*
0193  * copy a string with the given id
0194  */
0195 static int snd_usb_copy_string_desc(struct snd_usb_audio *chip,
0196                     int index, char *buf, int maxlen)
0197 {
0198     int len = usb_string(chip->dev, index, buf, maxlen - 1);
0199
0200     if (len < 0)
0201         return 0;
0202
0203     buf[len] = 0;
0204     return len;
0205 }
0206
0207 /*
0208  * convert from the byte/word on usb descriptor to the zero-based integer
0209  */
0210 static int convert_signed_value(struct usb_mixer_elem_info *cval, int val)
0211 {
0212     switch (cval->val_type) {
0213     case USB_MIXER_BOOLEAN:
0214         return !!val;
0215     case USB_MIXER_INV_BOOLEAN:
0216         return !val;
0217     case USB_MIXER_U8:
0218         val &= 0xff;
0219         break;
0220     case USB_MIXER_S8:
0221         val &= 0xff;
0222         if (val >= 0x80)
0223             val -= 0x100;
0224         break;
0225     case USB_MIXER_U16:
0226         val &= 0xffff;
0227         break;
0228     case USB_MIXER_S16:
0229         val &= 0xffff;
0230         if (val >= 0x8000)
0231             val -= 0x10000;
0232         break;
0233     }
0234     return val;
0235 }
0236
0237 /*
0238  * convert from the zero-based int to the byte/word for usb descriptor
0239  */
0240 static int convert_bytes_value(struct usb_mixer_elem_info *cval, int val)
0241 {
0242     switch (cval->val_type) {
0243     case USB_MIXER_BOOLEAN:
0244         return !!val;
0245     case USB_MIXER_INV_BOOLEAN:
0246         return !val;
0247     case USB_MIXER_S8:
0248     case USB_MIXER_U8:
0249         return val & 0xff;
0250     case USB_MIXER_S16:
0251     case USB_MIXER_U16:
0252         return val & 0xffff;
0253     }
0254     return 0; /* not reached */
0255 }
0256
0257 static int get_relative_value(struct usb_mixer_elem_info *cval, int val)
0258 {
0259     if (!cval->res)
0260         cval->res = 1;
0261     if (val < cval->min)
0262         return 0;
0263     else if (val >= cval->max)
0264         return DIV_ROUND_UP(cval->max - cval->min, cval->res);
0265     else
0266         return (val - cval->min) / cval->res;
0267 }
0268
0269 static int get_abs_value(struct usb_mixer_elem_info *cval, int val)
0270 {
0271     if (val < 0)
0272         return cval->min;
0273     if (!cval->res)
0274         cval->res = 1;
0275     val *= cval->res;
0276     val += cval->min;
0277     if (val > cval->max)
0278         return cval->max;
0279     return val;
0280 }
0281
0282 static int uac2_ctl_value_size(int val_type)
0283 {
0284     switch (val_type) {
0285     case USB_MIXER_S32:
0286     case USB_MIXER_U32:
0287         return 4;
0288     case USB_MIXER_S16:
0289     case USB_MIXER_U16:
0290         return 2;
0291     default:
0292         return 1;
0293     }
0294     return 0; /* unreachable */
0295 }
0296
0297
0298 /*
0299  * retrieve a mixer value
0300  */
0301
0302 static inline int mixer_ctrl_intf(struct usb_mixer_interface *mixer)
0303 {
0304     return get_iface_desc(mixer->hostif)->bInterfaceNumber;
0305 }
0306
0307 static int get_ctl_value_v1(struct usb_mixer_elem_info *cval, int request,
0308                 int validx, int *value_ret)
0309 {
0310     struct snd_usb_audio *chip = cval->head.mixer->chip;
0311     unsigned char buf[2];
0312     int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
0313     int timeout = 10;
0314     int idx = 0, err;
0315
0316     err = snd_usb_lock_shutdown(chip);
0317     if (err < 0)
0318         return -EIO;
0319
0320     while (timeout-- > 0) {
0321         idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
0322         err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), request,
0323                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
0324                       validx, idx, buf, val_len);
0325         if (err >= val_len) {
0326             *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
0327             err = 0;
0328             goto out;
0329         } else if (err == -ETIMEDOUT) {
0330             goto out;
0331         }
0332     }
0333     usb_audio_dbg(chip,
0334         "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
0335         request, validx, idx, cval->val_type);
0336     err = -EINVAL;
0337
0338  out:
0339     snd_usb_unlock_shutdown(chip);
0340     return err;
0341 }
0342
0343 static int get_ctl_value_v2(struct usb_mixer_elem_info *cval, int request,
0344                 int validx, int *value_ret)
0345 {
0346     struct snd_usb_audio *chip = cval->head.mixer->chip;
0347     /* enough space for one range */
0348     unsigned char buf[sizeof(__u16) + 3 * sizeof(__u32)];
0349     unsigned char *val;
0350     int idx = 0, ret, val_size, size;
0351     __u8 bRequest;
0352
0353     val_size = uac2_ctl_value_size(cval->val_type);
0354
0355     if (request == UAC_GET_CUR) {
0356         bRequest = UAC2_CS_CUR;
0357         size = val_size;
0358     } else {
0359         bRequest = UAC2_CS_RANGE;
0360         size = sizeof(__u16) + 3 * val_size;
0361     }
0362
0363     memset(buf, 0, sizeof(buf));
0364
0365     if (snd_usb_lock_shutdown(chip))
0366         return -EIO;
0367
0368     idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
0369     ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), bRequest,
0370                   USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
0371                   validx, idx, buf, size);
0372     snd_usb_unlock_shutdown(chip);
0373
0374     if (ret < 0) {
0375         usb_audio_dbg(chip,
0376             "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
0377             request, validx, idx, cval->val_type);
0378         return ret;
0379     }
0380
0381     /* FIXME: how should we handle multiple triplets here? */
0382
0383     switch (request) {
0384     case UAC_GET_CUR:
0385         val = buf;
0386         break;
0387     case UAC_GET_MIN:
0388         val = buf + sizeof(__u16);
0389         break;
0390     case UAC_GET_MAX:
0391         val = buf + sizeof(__u16) + val_size;
0392         break;
0393     case UAC_GET_RES:
0394         val = buf + sizeof(__u16) + val_size * 2;
0395         break;
0396     default:
0397         return -EINVAL;
0398     }
0399
0400     *value_ret = convert_signed_value(cval,
0401                       snd_usb_combine_bytes(val, val_size));
0402
0403     return 0;
0404 }
0405
0406 static int get_ctl_value(struct usb_mixer_elem_info *cval, int request,
0407              int validx, int *value_ret)
0408 {
0409     validx += cval->idx_off;
0410
0411     return (cval->head.mixer->protocol == UAC_VERSION_1) ?
0412         get_ctl_value_v1(cval, request, validx, value_ret) :
0413         get_ctl_value_v2(cval, request, validx, value_ret);
0414 }
0415
0416 static int get_cur_ctl_value(struct usb_mixer_elem_info *cval,
0417                  int validx, int *value)
0418 {
0419     return get_ctl_value(cval, UAC_GET_CUR, validx, value);
0420 }
0421
0422 /* channel = 0: master, 1 = first channel */
0423 static inline int get_cur_mix_raw(struct usb_mixer_elem_info *cval,
0424                   int channel, int *value)
0425 {
0426     return get_ctl_value(cval, UAC_GET_CUR,
0427                  (cval->control << 8) | channel,
0428                  value);
0429 }
0430
0431 int snd_usb_get_cur_mix_value(struct usb_mixer_elem_info *cval,
0432                  int channel, int index, int *value)
0433 {
0434     int err;
0435
0436     if (cval->cached & (1 << channel)) {
0437         *value = cval->cache_val[index];
0438         return 0;
0439     }
0440     err = get_cur_mix_raw(cval, channel, value);
0441     if (err < 0) {
0442         if (!cval->head.mixer->ignore_ctl_error)
0443             usb_audio_dbg(cval->head.mixer->chip,
0444                 "cannot get current value for control %d ch %d: err = %d\n",
0445                       cval->control, channel, err);
0446         return err;
0447     }
0448     cval->cached |= 1 << channel;
0449     cval->cache_val[index] = *value;
0450     return 0;
0451 }
0452
0453 /*
0454  * set a mixer value
0455  */
0456
0457 int snd_usb_mixer_set_ctl_value(struct usb_mixer_elem_info *cval,
0458                 int request, int validx, int value_set)
0459 {
0460     struct snd_usb_audio *chip = cval->head.mixer->chip;
0461     unsigned char buf[4];
0462     int idx = 0, val_len, err, timeout = 10;
0463
0464     validx += cval->idx_off;
0465
0466
0467     if (cval->head.mixer->protocol == UAC_VERSION_1) {
0468         val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
0469     } else { /* UAC_VERSION_2/3 */
0470         val_len = uac2_ctl_value_size(cval->val_type);
0471
0472         /* FIXME */
0473         if (request != UAC_SET_CUR) {
0474             usb_audio_dbg(chip, "RANGE setting not yet supported\n");
0475             return -EINVAL;
0476         }
0477
0478         request = UAC2_CS_CUR;
0479     }
0480
0481     value_set = convert_bytes_value(cval, value_set);
0482     buf[0] = value_set & 0xff;
0483     buf[1] = (value_set >> 8) & 0xff;
0484     buf[2] = (value_set >> 16) & 0xff;
0485     buf[3] = (value_set >> 24) & 0xff;
0486
0487     err = snd_usb_lock_shutdown(chip);
0488     if (err < 0)
0489         return -EIO;
0490
0491     while (timeout-- > 0) {
0492         idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
0493         err = snd_usb_ctl_msg(chip->dev,
0494                       usb_sndctrlpipe(chip->dev, 0), request,
0495                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
0496                       validx, idx, buf, val_len);
0497         if (err >= 0) {
0498             err = 0;
0499             goto out;
0500         } else if (err == -ETIMEDOUT) {
0501             goto out;
0502         }
0503     }
0504     usb_audio_dbg(chip, "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
0505               request, validx, idx, cval->val_type, buf[0], buf[1]);
0506     err = -EINVAL;
0507
0508  out:
0509     snd_usb_unlock_shutdown(chip);
0510     return err;
0511 }
0512
0513 static int set_cur_ctl_value(struct usb_mixer_elem_info *cval,
0514                  int validx, int value)
0515 {
0516     return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
0517 }
0518
0519 int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
0520                  int index, int value)
0521 {
0522     int err;
0523     unsigned int read_only = (channel == 0) ?
0524         cval->master_readonly :
0525         cval->ch_readonly & (1 << (channel - 1));
0526
0527     if (read_only) {
0528         usb_audio_dbg(cval->head.mixer->chip,
0529                   "%s(): channel %d of control %d is read_only\n",
0530                 __func__, channel, cval->control);
0531         return 0;
0532     }
0533
0534     err = snd_usb_mixer_set_ctl_value(cval,
0535                       UAC_SET_CUR, (cval->control << 8) | channel,
0536                       value);
0537     if (err < 0)
0538         return err;
0539     cval->cached |= 1 << channel;
0540     cval->cache_val[index] = value;
0541     return 0;
0542 }
0543
0544 /*
0545  * TLV callback for mixer volume controls
0546  */
0547 int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
0548              unsigned int size, unsigned int __user *_tlv)
0549 {
0550     struct usb_mixer_elem_info *cval = kcontrol->private_data;
0551     DECLARE_TLV_DB_MINMAX(scale, 0, 0);
0552
0553     if (size < sizeof(scale))
0554         return -ENOMEM;
0555     if (cval->min_mute)
0556         scale[0] = SNDRV_CTL_TLVT_DB_MINMAX_MUTE;
0557     scale[2] = cval->dBmin;
0558     scale[3] = cval->dBmax;
0559     if (copy_to_user(_tlv, scale, sizeof(scale)))
0560         return -EFAULT;
0561     return 0;
0562 }
0563
0564 /*
0565  * parser routines begin here...
0566  */
0567
0568 static int parse_audio_unit(struct mixer_build *state, int unitid);
0569
0570
0571 /*
0572  * check if the input/output channel routing is enabled on the given bitmap.
0573  * used for mixer unit parser
0574  */
0575 static int check_matrix_bitmap(unsigned char *bmap,
0576                    int ich, int och, int num_outs)
0577 {
0578     int idx = ich * num_outs + och;
0579     return bmap[idx >> 3] & (0x80 >> (idx & 7));
0580 }
0581
0582 /*
0583  * add an alsa control element
0584  * search and increment the index until an empty slot is found.
0585  *
0586  * if failed, give up and free the control instance.
0587  */
0588
0589 int snd_usb_mixer_add_list(struct usb_mixer_elem_list *list,
0590                struct snd_kcontrol *kctl,
0591                bool is_std_info)
0592 {
0593     struct usb_mixer_interface *mixer = list->mixer;
0594     int err;
0595
0596     while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
0597         kctl->id.index++;
0598     err = snd_ctl_add(mixer->chip->card, kctl);
0599     if (err < 0) {
0600         usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n",
0601                   err);
0602         return err;
0603     }
0604     list->kctl = kctl;
0605     list->is_std_info = is_std_info;
0606     list->next_id_elem = mixer->id_elems[list->id];
0607     mixer->id_elems[list->id] = list;
0608     return 0;
0609 }
0610
0611 /*
0612  * get a terminal name string
0613  */
0614
0615 static struct iterm_name_combo {
0616     int type;
0617     char *name;
0618 } iterm_names[] = {
0619     { 0x0300, "Output" },
0620     { 0x0301, "Speaker" },
0621     { 0x0302, "Headphone" },
0622     { 0x0303, "HMD Audio" },
0623     { 0x0304, "Desktop Speaker" },
0624     { 0x0305, "Room Speaker" },
0625     { 0x0306, "Com Speaker" },
0626     { 0x0307, "LFE" },
0627     { 0x0600, "External In" },
0628     { 0x0601, "Analog In" },
0629     { 0x0602, "Digital In" },
0630     { 0x0603, "Line" },
0631     { 0x0604, "Legacy In" },
0632     { 0x0605, "IEC958 In" },
0633     { 0x0606, "1394 DA Stream" },
0634     { 0x0607, "1394 DV Stream" },
0635     { 0x0700, "Embedded" },
0636     { 0x0701, "Noise Source" },
0637     { 0x0702, "Equalization Noise" },
0638     { 0x0703, "CD" },
0639     { 0x0704, "DAT" },
0640     { 0x0705, "DCC" },
0641     { 0x0706, "MiniDisk" },
0642     { 0x0707, "Analog Tape" },
0643     { 0x0708, "Phonograph" },
0644     { 0x0709, "VCR Audio" },
0645     { 0x070a, "Video Disk Audio" },
0646     { 0x070b, "DVD Audio" },
0647     { 0x070c, "TV Tuner Audio" },
0648     { 0x070d, "Satellite Rec Audio" },
0649     { 0x070e, "Cable Tuner Audio" },
0650     { 0x070f, "DSS Audio" },
0651     { 0x0710, "Radio Receiver" },
0652     { 0x0711, "Radio Transmitter" },
0653     { 0x0712, "Multi-Track Recorder" },
0654     { 0x0713, "Synthesizer" },
0655     { 0 },
0656 };
0657
0658 static int get_term_name(struct snd_usb_audio *chip, struct usb_audio_term *iterm,
0659              unsigned char *name, int maxlen, int term_only)
0660 {
0661     struct iterm_name_combo *names;
0662     int len;
0663
0664     if (iterm->name) {
0665         len = snd_usb_copy_string_desc(chip, iterm->name,
0666                         name, maxlen);
0667         if (len)
0668             return len;
0669     }
0670
0671     /* virtual type - not a real terminal */
0672     if (iterm->type >> 16) {
0673         if (term_only)
0674             return 0;
0675         switch (iterm->type >> 16) {
0676         case UAC3_SELECTOR_UNIT:
0677             strcpy(name, "Selector");
0678             return 8;
0679         case UAC3_PROCESSING_UNIT:
0680             strcpy(name, "Process Unit");
0681             return 12;
0682         case UAC3_EXTENSION_UNIT:
0683             strcpy(name, "Ext Unit");
0684             return 8;
0685         case UAC3_MIXER_UNIT:
0686             strcpy(name, "Mixer");
0687             return 5;
0688         default:
0689             return sprintf(name, "Unit %d", iterm->id);
0690         }
0691     }
0692
0693     switch (iterm->type & 0xff00) {
0694     case 0x0100:
0695         strcpy(name, "PCM");
0696         return 3;
0697     case 0x0200:
0698         strcpy(name, "Mic");
0699         return 3;
0700     case 0x0400:
0701         strcpy(name, "Headset");
0702         return 7;
0703     case 0x0500:
0704         strcpy(name, "Phone");
0705         return 5;
0706     }
0707
0708     for (names = iterm_names; names->type; names++) {
0709         if (names->type == iterm->type) {
0710             strcpy(name, names->name);
0711             return strlen(names->name);
0712         }
0713     }
0714
0715     return 0;
0716 }
0717
0718 /*
0719  * Get logical cluster information for UAC3 devices.
0720  */
0721 static int get_cluster_channels_v3(struct mixer_build *state, unsigned int cluster_id)
0722 {
0723     struct uac3_cluster_header_descriptor c_header;
0724     int err;
0725
0726     err = snd_usb_ctl_msg(state->chip->dev,
0727             usb_rcvctrlpipe(state->chip->dev, 0),
0728             UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR,
0729             USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
0730             cluster_id,
0731             snd_usb_ctrl_intf(state->chip),
0732             &c_header, sizeof(c_header));
0733     if (err < 0)
0734         goto error;
0735     if (err != sizeof(c_header)) {
0736         err = -EIO;
0737         goto error;
0738     }
0739
0740     return c_header.bNrChannels;
0741
0742 error:
0743     usb_audio_err(state->chip, "cannot request logical cluster ID: %d (err: %d)\n", cluster_id, err);
0744     return err;
0745 }
0746
0747 /*
0748  * Get number of channels for a Mixer Unit.
0749  */
0750 static int uac_mixer_unit_get_channels(struct mixer_build *state,
0751                        struct uac_mixer_unit_descriptor *desc)
0752 {
0753     int mu_channels;
0754
0755     switch (state->mixer->protocol) {
0756     case UAC_VERSION_1:
0757     case UAC_VERSION_2:
0758     default:
0759         if (desc->bLength < sizeof(*desc) + desc->bNrInPins + 1)
0760             return 0; /* no bmControls -> skip */
0761         mu_channels = uac_mixer_unit_bNrChannels(desc);
0762         break;
0763     case UAC_VERSION_3:
0764         mu_channels = get_cluster_channels_v3(state,
0765                 uac3_mixer_unit_wClusterDescrID(desc));
0766         break;
0767     }
0768
0769     return mu_channels;
0770 }
0771
0772 /*
0773  * Parse Input Terminal Unit
0774  */
0775 static int __check_input_term(struct mixer_build *state, int id,
0776                   struct usb_audio_term *term);
0777
0778 static int parse_term_uac1_iterm_unit(struct mixer_build *state,
0779                       struct usb_audio_term *term,
0780                       void *p1, int id)
0781 {
0782     struct uac_input_terminal_descriptor *d = p1;
0783
0784     term->type = le16_to_cpu(d->wTerminalType);
0785     term->channels = d->bNrChannels;
0786     term->chconfig = le16_to_cpu(d->wChannelConfig);
0787     term->name = d->iTerminal;
0788     return 0;
0789 }
0790
0791 static int parse_term_uac2_iterm_unit(struct mixer_build *state,
0792                       struct usb_audio_term *term,
0793                       void *p1, int id)
0794 {
0795     struct uac2_input_terminal_descriptor *d = p1;
0796     int err;
0797
0798     /* call recursively to verify the referenced clock entity */
0799     err = __check_input_term(state, d->bCSourceID, term);
0800     if (err < 0)
0801         return err;
0802
0803     /* save input term properties after recursion,
0804      * to ensure they are not overriden by the recursion calls
0805      */
0806     term->id = id;
0807     term->type = le16_to_cpu(d->wTerminalType);
0808     term->channels = d->bNrChannels;
0809     term->chconfig = le32_to_cpu(d->bmChannelConfig);
0810     term->name = d->iTerminal;
0811     return 0;
0812 }
0813
0814 static int parse_term_uac3_iterm_unit(struct mixer_build *state,
0815                       struct usb_audio_term *term,
0816                       void *p1, int id)
0817 {
0818     struct uac3_input_terminal_descriptor *d = p1;
0819     int err;
0820
0821     /* call recursively to verify the referenced clock entity */
0822     err = __check_input_term(state, d->bCSourceID, term);
0823     if (err < 0)
0824         return err;
0825
0826     /* save input term properties after recursion,
0827      * to ensure they are not overriden by the recursion calls
0828      */
0829     term->id = id;
0830     term->type = le16_to_cpu(d->wTerminalType);
0831
0832     err = get_cluster_channels_v3(state, le16_to_cpu(d->wClusterDescrID));
0833     if (err < 0)
0834         return err;
0835     term->channels = err;
0836
0837     /* REVISIT: UAC3 IT doesn't have channels cfg */
0838     term->chconfig = 0;
0839
0840     term->name = le16_to_cpu(d->wTerminalDescrStr);
0841     return 0;
0842 }
0843
0844 static int parse_term_mixer_unit(struct mixer_build *state,
0845                  struct usb_audio_term *term,
0846                  void *p1, int id)
0847 {
0848     struct uac_mixer_unit_descriptor *d = p1;
0849     int protocol = state->mixer->protocol;
0850     int err;
0851
0852     err = uac_mixer_unit_get_channels(state, d);
0853     if (err <= 0)
0854         return err;
0855
0856     term->type = UAC3_MIXER_UNIT << 16; /* virtual type */
0857     term->channels = err;
0858     if (protocol != UAC_VERSION_3) {
0859         term->chconfig = uac_mixer_unit_wChannelConfig(d, protocol);
0860         term->name = uac_mixer_unit_iMixer(d);
0861     }
0862     return 0;
0863 }
0864
0865 static int parse_term_selector_unit(struct mixer_build *state,
0866                     struct usb_audio_term *term,
0867                     void *p1, int id)
0868 {
0869     struct uac_selector_unit_descriptor *d = p1;
0870     int err;
0871
0872     /* call recursively to retrieve the channel info */
0873     err = __check_input_term(state, d->baSourceID[0], term);
0874     if (err < 0)
0875         return err;
0876     term->type = UAC3_SELECTOR_UNIT << 16; /* virtual type */
0877     term->id = id;
0878     if (state->mixer->protocol != UAC_VERSION_3)
0879         term->name = uac_selector_unit_iSelector(d);
0880     return 0;
0881 }
0882
0883 static int parse_term_proc_unit(struct mixer_build *state,
0884                 struct usb_audio_term *term,
0885                 void *p1, int id, int vtype)
0886 {
0887     struct uac_processing_unit_descriptor *d = p1;
0888     int protocol = state->mixer->protocol;
0889     int err;
0890
0891     if (d->bNrInPins) {
0892         /* call recursively to retrieve the channel info */
0893         err = __check_input_term(state, d->baSourceID[0], term);
0894         if (err < 0)
0895             return err;
0896     }
0897
0898     term->type = vtype << 16; /* virtual type */
0899     term->id = id;
0900
0901     if (protocol == UAC_VERSION_3)
0902         return 0;
0903
0904     if (!term->channels) {
0905         term->channels = uac_processing_unit_bNrChannels(d);
0906         term->chconfig = uac_processing_unit_wChannelConfig(d, protocol);
0907     }
0908     term->name = uac_processing_unit_iProcessing(d, protocol);
0909     return 0;
0910 }
0911
0912 static int parse_term_effect_unit(struct mixer_build *state,
0913                   struct usb_audio_term *term,
0914                   void *p1, int id)
0915 {
0916     struct uac2_effect_unit_descriptor *d = p1;
0917     int err;
0918
0919     err = __check_input_term(state, d->bSourceID, term);
0920     if (err < 0)
0921         return err;
0922     term->type = UAC3_EFFECT_UNIT << 16; /* virtual type */
0923     term->id = id;
0924     return 0;
0925 }
0926
0927 static int parse_term_uac2_clock_source(struct mixer_build *state,
0928                     struct usb_audio_term *term,
0929                     void *p1, int id)
0930 {
0931     struct uac_clock_source_descriptor *d = p1;
0932
0933     term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */
0934     term->id = id;
0935     term->name = d->iClockSource;
0936     return 0;
0937 }
0938
0939 static int parse_term_uac3_clock_source(struct mixer_build *state,
0940                     struct usb_audio_term *term,
0941                     void *p1, int id)
0942 {
0943     struct uac3_clock_source_descriptor *d = p1;
0944
0945     term->type = UAC3_CLOCK_SOURCE << 16; /* virtual type */
0946     term->id = id;
0947     term->name = le16_to_cpu(d->wClockSourceStr);
0948     return 0;
0949 }
0950
0951 #define PTYPE(a, b) ((a) << 8 | (b))
0952
0953 /*
0954  * parse the source unit recursively until it reaches to a terminal
0955  * or a branched unit.
0956  */
0957 static int __check_input_term(struct mixer_build *state, int id,
0958                   struct usb_audio_term *term)
0959 {
0960     int protocol = state->mixer->protocol;
0961     void *p1;
0962     unsigned char *hdr;
0963
0964     for (;;) {
0965         /* a loop in the terminal chain? */
0966         if (test_and_set_bit(id, state->termbitmap))
0967             return -EINVAL;
0968
0969         p1 = find_audio_control_unit(state, id);
0970         if (!p1)
0971             break;
0972         if (!snd_usb_validate_audio_desc(p1, protocol))
0973             break; /* bad descriptor */
0974
0975         hdr = p1;
0976         term->id = id;
0977
0978         switch (PTYPE(protocol, hdr[2])) {
0979         case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT):
0980         case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT):
0981         case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT): {
0982             /* the header is the same for all versions */
0983             struct uac_feature_unit_descriptor *d = p1;
0984
0985             id = d->bSourceID;
0986             break; /* continue to parse */
0987         }
0988         case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL):
0989             return parse_term_uac1_iterm_unit(state, term, p1, id);
0990         case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL):
0991             return parse_term_uac2_iterm_unit(state, term, p1, id);
0992         case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL):
0993             return parse_term_uac3_iterm_unit(state, term, p1, id);
0994         case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT):
0995         case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT):
0996         case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT):
0997             return parse_term_mixer_unit(state, term, p1, id);
0998         case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT):
0999         case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT):
1000         case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR):
1001         case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT):
1002         case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR):
1003             return parse_term_selector_unit(state, term, p1, id);
1004         case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT):
1005         case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2):
1006         case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT):
1007             return parse_term_proc_unit(state, term, p1, id,
1008                             UAC3_PROCESSING_UNIT);
1009         case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT):
1010         case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT):
1011             return parse_term_effect_unit(state, term, p1, id);
1012         case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT):
1013         case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2):
1014         case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT):
1015             return parse_term_proc_unit(state, term, p1, id,
1016                             UAC3_EXTENSION_UNIT);
1017         case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE):
1018             return parse_term_uac2_clock_source(state, term, p1, id);
1019         case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE):
1020             return parse_term_uac3_clock_source(state, term, p1, id);
1021         default:
1022             return -ENODEV;
1023         }
1024     }
1025     return -ENODEV;
1026 }
1027
1028
1029 static int check_input_term(struct mixer_build *state, int id,
1030                 struct usb_audio_term *term)
1031 {
1032     memset(term, 0, sizeof(*term));
1033     memset(state->termbitmap, 0, sizeof(state->termbitmap));
1034     return __check_input_term(state, id, term);
1035 }
1036
1037 /*
1038  * Feature Unit
1039  */
1040
1041 /* feature unit control information */
1042 struct usb_feature_control_info {
1043     int control;
1044     const char *name;
1045     int type;   /* data type for uac1 */
1046     int type_uac2;  /* data type for uac2 if different from uac1, else -1 */
1047 };
1048
1049 static const struct usb_feature_control_info audio_feature_info[] = {
1050     { UAC_FU_MUTE,          "Mute",         USB_MIXER_INV_BOOLEAN, -1 },
1051     { UAC_FU_VOLUME,        "Volume",       USB_MIXER_S16, -1 },
1052     { UAC_FU_BASS,          "Tone Control - Bass",  USB_MIXER_S8, -1 },
1053     { UAC_FU_MID,           "Tone Control - Mid",   USB_MIXER_S8, -1 },
1054     { UAC_FU_TREBLE,        "Tone Control - Treble", USB_MIXER_S8, -1 },
1055     { UAC_FU_GRAPHIC_EQUALIZER, "Graphic Equalizer",    USB_MIXER_S8, -1 }, /* FIXME: not implemented yet */
1056     { UAC_FU_AUTOMATIC_GAIN,    "Auto Gain Control",    USB_MIXER_BOOLEAN, -1 },
1057     { UAC_FU_DELAY,         "Delay Control",    USB_MIXER_U16, USB_MIXER_U32 },
1058     { UAC_FU_BASS_BOOST,        "Bass Boost",       USB_MIXER_BOOLEAN, -1 },
1059     { UAC_FU_LOUDNESS,      "Loudness",     USB_MIXER_BOOLEAN, -1 },
1060     /* UAC2 specific */
1061     { UAC2_FU_INPUT_GAIN,       "Input Gain Control",   USB_MIXER_S16, -1 },
1062     { UAC2_FU_INPUT_GAIN_PAD,   "Input Gain Pad Control", USB_MIXER_S16, -1 },
1063     { UAC2_FU_PHASE_INVERTER,    "Phase Inverter Control", USB_MIXER_BOOLEAN, -1 },
1064 };
1065
1066 static void usb_mixer_elem_info_free(struct usb_mixer_elem_info *cval)
1067 {
1068     kfree(cval);
1069 }
1070
1071 /* private_free callback */
1072 void snd_usb_mixer_elem_free(struct snd_kcontrol *kctl)
1073 {
1074     usb_mixer_elem_info_free(kctl->private_data);
1075     kctl->private_data = NULL;
1076 }
1077
1078 /*
1079  * interface to ALSA control for feature/mixer units
1080  */
1081
1082 /* volume control quirks */
1083 static void volume_control_quirks(struct usb_mixer_elem_info *cval,
1084                   struct snd_kcontrol *kctl)
1085 {
1086     struct snd_usb_audio *chip = cval->head.mixer->chip;
1087     switch (chip->usb_id) {
1088     case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
1089     case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
1090         if (strcmp(kctl->id.name, "Effect Duration") == 0) {
1091             cval->min = 0x0000;
1092             cval->max = 0xffff;
1093             cval->res = 0x00e6;
1094             break;
1095         }
1096         if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
1097             strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
1098             cval->min = 0x00;
1099             cval->max = 0xff;
1100             break;
1101         }
1102         if (strstr(kctl->id.name, "Effect Return") != NULL) {
1103             cval->min = 0xb706;
1104             cval->max = 0xff7b;
1105             cval->res = 0x0073;
1106             break;
1107         }
1108         if ((strstr(kctl->id.name, "Playback Volume") != NULL) ||
1109             (strstr(kctl->id.name, "Effect Send") != NULL)) {
1110             cval->min = 0xb5fb; /* -73 dB = 0xb6ff */
1111             cval->max = 0xfcfe;
1112             cval->res = 0x0073;
1113         }
1114         break;
1115
1116     case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
1117     case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
1118         if (strcmp(kctl->id.name, "Effect Duration") == 0) {
1119             usb_audio_info(chip,
1120                        "set quirk for FTU Effect Duration\n");
1121             cval->min = 0x0000;
1122             cval->max = 0x7f00;
1123             cval->res = 0x0100;
1124             break;
1125         }
1126         if (strcmp(kctl->id.name, "Effect Volume") == 0 ||
1127             strcmp(kctl->id.name, "Effect Feedback Volume") == 0) {
1128             usb_audio_info(chip,
1129                        "set quirks for FTU Effect Feedback/Volume\n");
1130             cval->min = 0x00;
1131             cval->max = 0x7f;
1132             break;
1133         }
1134         break;
1135
1136     case USB_ID(0x0d8c, 0x0103):
1137         if (!strcmp(kctl->id.name, "PCM Playback Volume")) {
1138             usb_audio_info(chip,
1139                  "set volume quirk for CM102-A+/102S+\n");
1140             cval->min = -256;
1141         }
1142         break;
1143
1144     case USB_ID(0x0471, 0x0101):
1145     case USB_ID(0x0471, 0x0104):
1146     case USB_ID(0x0471, 0x0105):
1147     case USB_ID(0x0672, 0x1041):
1148     /* quirk for UDA1321/N101.
1149      * note that detection between firmware 2.1.1.7 (N101)
1150      * and later 2.1.1.21 is not very clear from datasheets.
1151      * I hope that the min value is -15360 for newer firmware --jk
1152      */
1153         if (!strcmp(kctl->id.name, "PCM Playback Volume") &&
1154             cval->min == -15616) {
1155             usb_audio_info(chip,
1156                  "set volume quirk for UDA1321/N101 chip\n");
1157             cval->max = -256;
1158         }
1159         break;
1160
1161     case USB_ID(0x046d, 0x09a4):
1162         if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
1163             usb_audio_info(chip,
1164                 "set volume quirk for QuickCam E3500\n");
1165             cval->min = 6080;
1166             cval->max = 8768;
1167             cval->res = 192;
1168         }
1169         break;
1170
1171     case USB_ID(0x046d, 0x0807): /* Logitech Webcam C500 */
1172     case USB_ID(0x046d, 0x0808):
1173     case USB_ID(0x046d, 0x0809):
1174     case USB_ID(0x046d, 0x0819): /* Logitech Webcam C210 */
1175     case USB_ID(0x046d, 0x081b): /* HD Webcam c310 */
1176     case USB_ID(0x046d, 0x081d): /* HD Webcam c510 */
1177     case USB_ID(0x046d, 0x0825): /* HD Webcam c270 */
1178     case USB_ID(0x046d, 0x0826): /* HD Webcam c525 */
1179     case USB_ID(0x046d, 0x08ca): /* Logitech Quickcam Fusion */
1180     case USB_ID(0x046d, 0x0991):
1181     case USB_ID(0x046d, 0x09a2): /* QuickCam Communicate Deluxe/S7500 */
1182     /* Most audio usb devices lie about volume resolution.
1183      * Most Logitech webcams have res = 384.
1184      * Probably there is some logitech magic behind this number --fishor
1185      */
1186         if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
1187             usb_audio_info(chip,
1188                 "set resolution quirk: cval->res = 384\n");
1189             cval->res = 384;
1190         }
1191         break;
1192     case USB_ID(0x0495, 0x3042): /* ESS Technology Asus USB DAC */
1193         if ((strstr(kctl->id.name, "Playback Volume") != NULL) ||
1194             strstr(kctl->id.name, "Capture Volume") != NULL) {
1195             cval->min >>= 8;
1196             cval->max = 0;
1197             cval->res = 1;
1198         }
1199         break;
1200     case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */
1201         if (!strcmp(kctl->id.name, "Mic Capture Volume")) {
1202             usb_audio_info(chip,
1203                 "set resolution quirk: cval->res = 16\n");
1204             cval->res = 16;
1205         }
1206         break;
1207     }
1208 }
1209
1210 /* forcibly initialize the current mixer value; if GET_CUR fails, set to
1211  * the minimum as default
1212  */
1213 static void init_cur_mix_raw(struct usb_mixer_elem_info *cval, int ch, int idx)
1214 {
1215     int val, err;
1216
1217     err = snd_usb_get_cur_mix_value(cval, ch, idx, &val);
1218     if (!err)
1219         return;
1220     if (!cval->head.mixer->ignore_ctl_error)
1221         usb_audio_warn(cval->head.mixer->chip,
1222                    "%d:%d: failed to get current value for ch %d (%d)\n",
1223                    cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1224                    ch, err);
1225     snd_usb_set_cur_mix_value(cval, ch, idx, cval->min);
1226 }
1227
1228 /*
1229  * retrieve the minimum and maximum values for the specified control
1230  */
1231 static int get_min_max_with_quirks(struct usb_mixer_elem_info *cval,
1232                    int default_min, struct snd_kcontrol *kctl)
1233 {
1234     int i, idx;
1235
1236     /* for failsafe */
1237     cval->min = default_min;
1238     cval->max = cval->min + 1;
1239     cval->res = 1;
1240     cval->dBmin = cval->dBmax = 0;
1241
1242     if (cval->val_type == USB_MIXER_BOOLEAN ||
1243         cval->val_type == USB_MIXER_INV_BOOLEAN) {
1244         cval->initialized = 1;
1245     } else {
1246         int minchn = 0;
1247         if (cval->cmask) {
1248             for (i = 0; i < MAX_CHANNELS; i++)
1249                 if (cval->cmask & (1 << i)) {
1250                     minchn = i + 1;
1251                     break;
1252                 }
1253         }
1254         if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
1255             get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
1256             usb_audio_err(cval->head.mixer->chip,
1257                       "%d:%d: cannot get min/max values for control %d (id %d)\n",
1258                    cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1259                                    cval->control, cval->head.id);
1260             return -EINVAL;
1261         }
1262         if (get_ctl_value(cval, UAC_GET_RES,
1263                   (cval->control << 8) | minchn,
1264                   &cval->res) < 0) {
1265             cval->res = 1;
1266         } else if (cval->head.mixer->protocol == UAC_VERSION_1) {
1267             int last_valid_res = cval->res;
1268
1269             while (cval->res > 1) {
1270                 if (snd_usb_mixer_set_ctl_value(cval, UAC_SET_RES,
1271                                 (cval->control << 8) | minchn,
1272                                 cval->res / 2) < 0)
1273                     break;
1274                 cval->res /= 2;
1275             }
1276             if (get_ctl_value(cval, UAC_GET_RES,
1277                       (cval->control << 8) | minchn, &cval->res) < 0)
1278                 cval->res = last_valid_res;
1279         }
1280         if (cval->res == 0)
1281             cval->res = 1;
1282
1283         /* Additional checks for the proper resolution
1284          *
1285          * Some devices report smaller resolutions than actually
1286          * reacting.  They don't return errors but simply clip
1287          * to the lower aligned value.
1288          */
1289         if (cval->min + cval->res < cval->max) {
1290             int last_valid_res = cval->res;
1291             int saved, test, check;
1292             if (get_cur_mix_raw(cval, minchn, &saved) < 0)
1293                 goto no_res_check;
1294             for (;;) {
1295                 test = saved;
1296                 if (test < cval->max)
1297                     test += cval->res;
1298                 else
1299                     test -= cval->res;
1300                 if (test < cval->min || test > cval->max ||
1301                     snd_usb_set_cur_mix_value(cval, minchn, 0, test) ||
1302                     get_cur_mix_raw(cval, minchn, &check)) {
1303                     cval->res = last_valid_res;
1304                     break;
1305                 }
1306                 if (test == check)
1307                     break;
1308                 cval->res *= 2;
1309             }
1310             snd_usb_set_cur_mix_value(cval, minchn, 0, saved);
1311         }
1312
1313 no_res_check:
1314         cval->initialized = 1;
1315     }
1316
1317     if (kctl)
1318         volume_control_quirks(cval, kctl);
1319
1320     /* USB descriptions contain the dB scale in 1/256 dB unit
1321      * while ALSA TLV contains in 1/100 dB unit
1322      */
1323     cval->dBmin = (convert_signed_value(cval, cval->min) * 100) / 256;
1324     cval->dBmax = (convert_signed_value(cval, cval->max) * 100) / 256;
1325     if (cval->dBmin > cval->dBmax) {
1326         /* something is wrong; assume it's either from/to 0dB */
1327         if (cval->dBmin < 0)
1328             cval->dBmax = 0;
1329         else if (cval->dBmin > 0)
1330             cval->dBmin = 0;
1331         if (cval->dBmin > cval->dBmax) {
1332             /* totally crap, return an error */
1333             return -EINVAL;
1334         }
1335     } else {
1336         /* if the max volume is too low, it's likely a bogus range;
1337          * here we use -96dB as the threshold
1338          */
1339         if (cval->dBmax <= -9600) {
1340             usb_audio_info(cval->head.mixer->chip,
1341                        "%d:%d: bogus dB values (%d/%d), disabling dB reporting\n",
1342                        cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1343                        cval->dBmin, cval->dBmax);
1344             cval->dBmin = cval->dBmax = 0;
1345         }
1346     }
1347
1348     /* initialize all elements */
1349     if (!cval->cmask) {
1350         init_cur_mix_raw(cval, 0, 0);
1351     } else {
1352         idx = 0;
1353         for (i = 0; i < MAX_CHANNELS; i++) {
1354             if (cval->cmask & (1 << i)) {
1355                 init_cur_mix_raw(cval, i + 1, idx);
1356                 idx++;
1357             }
1358         }
1359     }
1360
1361     return 0;
1362 }
1363
1364 #define get_min_max(cval, def)  get_min_max_with_quirks(cval, def, NULL)
1365
1366 /* get a feature/mixer unit info */
1367 static int mixer_ctl_feature_info(struct snd_kcontrol *kcontrol,
1368                   struct snd_ctl_elem_info *uinfo)
1369 {
1370     struct usb_mixer_elem_info *cval = kcontrol->private_data;
1371
1372     if (cval->val_type == USB_MIXER_BOOLEAN ||
1373         cval->val_type == USB_MIXER_INV_BOOLEAN)
1374         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1375     else
1376         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1377     uinfo->count = cval->channels;
1378     if (cval->val_type == USB_MIXER_BOOLEAN ||
1379         cval->val_type == USB_MIXER_INV_BOOLEAN) {
1380         uinfo->value.integer.min = 0;
1381         uinfo->value.integer.max = 1;
1382     } else {
1383         if (!cval->initialized) {
1384             get_min_max_with_quirks(cval, 0, kcontrol);
1385             if (cval->initialized && cval->dBmin >= cval->dBmax) {
1386                 kcontrol->vd[0].access &=
1387                     ~(SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1388                       SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK);
1389                 snd_ctl_notify(cval->head.mixer->chip->card,
1390                            SNDRV_CTL_EVENT_MASK_INFO,
1391                            &kcontrol->id);
1392             }
1393         }
1394         uinfo->value.integer.min = 0;
1395         uinfo->value.integer.max =
1396             DIV_ROUND_UP(cval->max - cval->min, cval->res);
1397     }
1398     return 0;
1399 }
1400
1401 /* get the current value from feature/mixer unit */
1402 static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol,
1403                  struct snd_ctl_elem_value *ucontrol)
1404 {
1405     struct usb_mixer_elem_info *cval = kcontrol->private_data;
1406     int c, cnt, val, err;
1407
1408     ucontrol->value.integer.value[0] = cval->min;
1409     if (cval->cmask) {
1410         cnt = 0;
1411         for (c = 0; c < MAX_CHANNELS; c++) {
1412             if (!(cval->cmask & (1 << c)))
1413                 continue;
1414             err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &val);
1415             if (err < 0)
1416                 return filter_error(cval, err);
1417             val = get_relative_value(cval, val);
1418             ucontrol->value.integer.value[cnt] = val;
1419             cnt++;
1420         }
1421         return 0;
1422     } else {
1423         /* master channel */
1424         err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1425         if (err < 0)
1426             return filter_error(cval, err);
1427         val = get_relative_value(cval, val);
1428         ucontrol->value.integer.value[0] = val;
1429     }
1430     return 0;
1431 }
1432
1433 /* put the current value to feature/mixer unit */
1434 static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
1435                  struct snd_ctl_elem_value *ucontrol)
1436 {
1437     struct usb_mixer_elem_info *cval = kcontrol->private_data;
1438     int c, cnt, val, oval, err;
1439     int changed = 0;
1440
1441     if (cval->cmask) {
1442         cnt = 0;
1443         for (c = 0; c < MAX_CHANNELS; c++) {
1444             if (!(cval->cmask & (1 << c)))
1445                 continue;
1446             err = snd_usb_get_cur_mix_value(cval, c + 1, cnt, &oval);
1447             if (err < 0)
1448                 return filter_error(cval, err);
1449             val = ucontrol->value.integer.value[cnt];
1450             val = get_abs_value(cval, val);
1451             if (oval != val) {
1452                 snd_usb_set_cur_mix_value(cval, c + 1, cnt, val);
1453                 changed = 1;
1454             }
1455             cnt++;
1456         }
1457     } else {
1458         /* master channel */
1459         err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval);
1460         if (err < 0)
1461             return filter_error(cval, err);
1462         val = ucontrol->value.integer.value[0];
1463         val = get_abs_value(cval, val);
1464         if (val != oval) {
1465             snd_usb_set_cur_mix_value(cval, 0, 0, val);
1466             changed = 1;
1467         }
1468     }
1469     return changed;
1470 }
1471
1472 /* get the boolean value from the master channel of a UAC control */
1473 static int mixer_ctl_master_bool_get(struct snd_kcontrol *kcontrol,
1474                      struct snd_ctl_elem_value *ucontrol)
1475 {
1476     struct usb_mixer_elem_info *cval = kcontrol->private_data;
1477     int val, err;
1478
1479     err = snd_usb_get_cur_mix_value(cval, 0, 0, &val);
1480     if (err < 0)
1481         return filter_error(cval, err);
1482     val = (val != 0);
1483     ucontrol->value.integer.value[0] = val;
1484     return 0;
1485 }
1486
1487 static int get_connector_value(struct usb_mixer_elem_info *cval,
1488                    char *name, int *val)
1489 {
1490     struct snd_usb_audio *chip = cval->head.mixer->chip;
1491     int idx = 0, validx, ret;
1492
1493     validx = cval->control << 8 | 0;
1494
1495     ret = snd_usb_lock_shutdown(chip) ? -EIO : 0;
1496     if (ret)
1497         goto error;
1498
1499     idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
1500     if (cval->head.mixer->protocol == UAC_VERSION_2) {
1501         struct uac2_connectors_ctl_blk uac2_conn;
1502
1503         ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR,
1504                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1505                       validx, idx, &uac2_conn, sizeof(uac2_conn));
1506         if (val)
1507             *val = !!uac2_conn.bNrChannels;
1508     } else { /* UAC_VERSION_3 */
1509         struct uac3_insertion_ctl_blk uac3_conn;
1510
1511         ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), UAC2_CS_CUR,
1512                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1513                       validx, idx, &uac3_conn, sizeof(uac3_conn));
1514         if (val)
1515             *val = !!uac3_conn.bmConInserted;
1516     }
1517
1518     snd_usb_unlock_shutdown(chip);
1519
1520     if (ret < 0) {
1521         if (name && strstr(name, "Speaker")) {
1522             if (val)
1523                 *val = 1;
1524             return 0;
1525         }
1526 error:
1527         usb_audio_err(chip,
1528             "cannot get connectors status: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
1529             UAC_GET_CUR, validx, idx, cval->val_type);
1530
1531         if (val)
1532             *val = 0;
1533
1534         return filter_error(cval, ret);
1535     }
1536
1537     return ret;
1538 }
1539
1540 /* get the connectors status and report it as boolean type */
1541 static int mixer_ctl_connector_get(struct snd_kcontrol *kcontrol,
1542                    struct snd_ctl_elem_value *ucontrol)
1543 {
1544     struct usb_mixer_elem_info *cval = kcontrol->private_data;
1545     int ret, val;
1546
1547     ret = get_connector_value(cval, kcontrol->id.name, &val);
1548
1549     if (ret < 0)
1550         return ret;
1551
1552     ucontrol->value.integer.value[0] = val;
1553     return 0;
1554 }
1555
1556 static const struct snd_kcontrol_new usb_feature_unit_ctl = {
1557     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1558     .name = "", /* will be filled later manually */
1559     .info = mixer_ctl_feature_info,
1560     .get = mixer_ctl_feature_get,
1561     .put = mixer_ctl_feature_put,
1562 };
1563
1564 /* the read-only variant */
1565 static const struct snd_kcontrol_new usb_feature_unit_ctl_ro = {
1566     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1567     .name = "", /* will be filled later manually */
1568     .info = mixer_ctl_feature_info,
1569     .get = mixer_ctl_feature_get,
1570     .put = NULL,
1571 };
1572
1573 /*
1574  * A control which shows the boolean value from reading a UAC control on
1575  * the master channel.
1576  */
1577 static const struct snd_kcontrol_new usb_bool_master_control_ctl_ro = {
1578     .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1579     .name = "", /* will be filled later manually */
1580     .access = SNDRV_CTL_ELEM_ACCESS_READ,
1581     .info = snd_ctl_boolean_mono_info,
1582     .get = mixer_ctl_master_bool_get,
1583     .put = NULL,
1584 };
1585
1586 static const struct snd_kcontrol_new usb_connector_ctl_ro = {
1587     .iface = SNDRV_CTL_ELEM_IFACE_CARD,
1588     .name = "", /* will be filled later manually */
1589     .access = SNDRV_CTL_ELEM_ACCESS_READ,
1590     .info = snd_ctl_boolean_mono_info,
1591     .get = mixer_ctl_connector_get,
1592     .put = NULL,
1593 };
1594
1595 /*
1596  * This symbol is exported in order to allow the mixer quirks to
1597  * hook up to the standard feature unit control mechanism
1598  */
1599 const struct snd_kcontrol_new *snd_usb_feature_unit_ctl = &usb_feature_unit_ctl;
1600
1601 /*
1602  * build a feature control
1603  */
1604 static size_t append_ctl_name(struct snd_kcontrol *kctl, const char *str)
1605 {
1606     return strlcat(kctl->id.name, str, sizeof(kctl->id.name));
1607 }
1608
1609 /*
1610  * A lot of headsets/headphones have a "Speaker" mixer. Make sure we
1611  * rename it to "Headphone". We determine if something is a headphone
1612  * similar to how udev determines form factor.
1613  */
1614 static void check_no_speaker_on_headset(struct snd_kcontrol *kctl,
1615                     struct snd_card *card)
1616 {
1617     static const char * const names_to_check[] = {
1618         "Headset", "headset", "Headphone", "headphone", NULL};
1619     const char * const *s;
1620     bool found = false;
1621
1622     if (strcmp("Speaker", kctl->id.name))
1623         return;
1624
1625     for (s = names_to_check; *s; s++)
1626         if (strstr(card->shortname, *s)) {
1627             found = true;
1628             break;
1629         }
1630
1631     if (!found)
1632         return;
1633
1634     strscpy(kctl->id.name, "Headphone", sizeof(kctl->id.name));
1635 }
1636
1637 static const struct usb_feature_control_info *get_feature_control_info(int control)
1638 {
1639     int i;
1640
1641     for (i = 0; i < ARRAY_SIZE(audio_feature_info); ++i) {
1642         if (audio_feature_info[i].control == control)
1643             return &audio_feature_info[i];
1644     }
1645     return NULL;
1646 }
1647
1648 static void __build_feature_ctl(struct usb_mixer_interface *mixer,
1649                 const struct usbmix_name_map *imap,
1650                 unsigned int ctl_mask, int control,
1651                 struct usb_audio_term *iterm,
1652                 struct usb_audio_term *oterm,
1653                 int unitid, int nameid, int readonly_mask)
1654 {
1655     const struct usb_feature_control_info *ctl_info;
1656     unsigned int len = 0;
1657     int mapped_name = 0;
1658     struct snd_kcontrol *kctl;
1659     struct usb_mixer_elem_info *cval;
1660     const struct usbmix_name_map *map;
1661     unsigned int range;
1662
1663     if (control == UAC_FU_GRAPHIC_EQUALIZER) {
1664         /* FIXME: not supported yet */
1665         return;
1666     }
1667
1668     map = find_map(imap, unitid, control);
1669     if (check_ignored_ctl(map))
1670         return;
1671
1672     cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1673     if (!cval)
1674         return;
1675     snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1676     cval->control = control;
1677     cval->cmask = ctl_mask;
1678
1679     ctl_info = get_feature_control_info(control);
1680     if (!ctl_info) {
1681         usb_mixer_elem_info_free(cval);
1682         return;
1683     }
1684     if (mixer->protocol == UAC_VERSION_1)
1685         cval->val_type = ctl_info->type;
1686     else /* UAC_VERSION_2 */
1687         cval->val_type = ctl_info->type_uac2 >= 0 ?
1688             ctl_info->type_uac2 : ctl_info->type;
1689
1690     if (ctl_mask == 0) {
1691         cval->channels = 1; /* master channel */
1692         cval->master_readonly = readonly_mask;
1693     } else {
1694         int i, c = 0;
1695         for (i = 0; i < 16; i++)
1696             if (ctl_mask & (1 << i))
1697                 c++;
1698         cval->channels = c;
1699         cval->ch_readonly = readonly_mask;
1700     }
1701
1702     /*
1703      * If all channels in the mask are marked read-only, make the control
1704      * read-only. snd_usb_set_cur_mix_value() will check the mask again and won't
1705      * issue write commands to read-only channels.
1706      */
1707     if (cval->channels == readonly_mask)
1708         kctl = snd_ctl_new1(&usb_feature_unit_ctl_ro, cval);
1709     else
1710         kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
1711
1712     if (!kctl) {
1713         usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1714         usb_mixer_elem_info_free(cval);
1715         return;
1716     }
1717     kctl->private_free = snd_usb_mixer_elem_free;
1718
1719     len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
1720     mapped_name = len != 0;
1721     if (!len && nameid)
1722         len = snd_usb_copy_string_desc(mixer->chip, nameid,
1723                 kctl->id.name, sizeof(kctl->id.name));
1724
1725     switch (control) {
1726     case UAC_FU_MUTE:
1727     case UAC_FU_VOLUME:
1728         /*
1729          * determine the control name.  the rule is:
1730          * - if a name id is given in descriptor, use it.
1731          * - if the connected input can be determined, then use the name
1732          *   of terminal type.
1733          * - if the connected output can be determined, use it.
1734          * - otherwise, anonymous name.
1735          */
1736         if (!len) {
1737             if (iterm)
1738                 len = get_term_name(mixer->chip, iterm,
1739                             kctl->id.name,
1740                             sizeof(kctl->id.name), 1);
1741             if (!len && oterm)
1742                 len = get_term_name(mixer->chip, oterm,
1743                             kctl->id.name,
1744                             sizeof(kctl->id.name), 1);
1745             if (!len)
1746                 snprintf(kctl->id.name, sizeof(kctl->id.name),
1747                      "Feature %d", unitid);
1748         }
1749
1750         if (!mapped_name)
1751             check_no_speaker_on_headset(kctl, mixer->chip->card);
1752
1753         /*
1754          * determine the stream direction:
1755          * if the connected output is USB stream, then it's likely a
1756          * capture stream.  otherwise it should be playback (hopefully :)
1757          */
1758         if (!mapped_name && oterm && !(oterm->type >> 16)) {
1759             if ((oterm->type & 0xff00) == 0x0100)
1760                 append_ctl_name(kctl, " Capture");
1761             else
1762                 append_ctl_name(kctl, " Playback");
1763         }
1764         append_ctl_name(kctl, control == UAC_FU_MUTE ?
1765                 " Switch" : " Volume");
1766         break;
1767     default:
1768         if (!len)
1769             strscpy(kctl->id.name, audio_feature_info[control-1].name,
1770                 sizeof(kctl->id.name));
1771         break;
1772     }
1773
1774     /* get min/max values */
1775     get_min_max_with_quirks(cval, 0, kctl);
1776
1777     /* skip a bogus volume range */
1778     if (cval->max <= cval->min) {
1779         usb_audio_dbg(mixer->chip,
1780                   "[%d] FU [%s] skipped due to invalid volume\n",
1781                   cval->head.id, kctl->id.name);
1782         snd_ctl_free_one(kctl);
1783         return;
1784     }
1785
1786
1787     if (control == UAC_FU_VOLUME) {
1788         check_mapped_dB(map, cval);
1789         if (cval->dBmin < cval->dBmax || !cval->initialized) {
1790             kctl->tlv.c = snd_usb_mixer_vol_tlv;
1791             kctl->vd[0].access |=
1792                 SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1793                 SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1794         }
1795     }
1796
1797     snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
1798
1799     range = (cval->max - cval->min) / cval->res;
1800     /*
1801      * Are there devices with volume range more than 255? I use a bit more
1802      * to be sure. 384 is a resolution magic number found on Logitech
1803      * devices. It will definitively catch all buggy Logitech devices.
1804      */
1805     if (range > 384) {
1806         usb_audio_warn(mixer->chip,
1807                    "Warning! Unlikely big volume range (=%u), cval->res is probably wrong.",
1808                    range);
1809         usb_audio_warn(mixer->chip,
1810                    "[%d] FU [%s] ch = %d, val = %d/%d/%d",
1811                    cval->head.id, kctl->id.name, cval->channels,
1812                    cval->min, cval->max, cval->res);
1813     }
1814
1815     usb_audio_dbg(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1816               cval->head.id, kctl->id.name, cval->channels,
1817               cval->min, cval->max, cval->res);
1818     snd_usb_mixer_add_control(&cval->head, kctl);
1819 }
1820
1821 static void build_feature_ctl(struct mixer_build *state, void *raw_desc,
1822                   unsigned int ctl_mask, int control,
1823                   struct usb_audio_term *iterm, int unitid,
1824                   int readonly_mask)
1825 {
1826     struct uac_feature_unit_descriptor *desc = raw_desc;
1827     int nameid = uac_feature_unit_iFeature(desc);
1828
1829     __build_feature_ctl(state->mixer, state->map, ctl_mask, control,
1830             iterm, &state->oterm, unitid, nameid, readonly_mask);
1831 }
1832
1833 static void build_feature_ctl_badd(struct usb_mixer_interface *mixer,
1834                   unsigned int ctl_mask, int control, int unitid,
1835                   const struct usbmix_name_map *badd_map)
1836 {
1837     __build_feature_ctl(mixer, badd_map, ctl_mask, control,
1838             NULL, NULL, unitid, 0, 0);
1839 }
1840
1841 static void get_connector_control_name(struct usb_mixer_interface *mixer,
1842                        struct usb_audio_term *term,
1843                        bool is_input, char *name, int name_size)
1844 {
1845     int name_len = get_term_name(mixer->chip, term, name, name_size, 0);
1846
1847     if (name_len == 0)
1848         strscpy(name, "Unknown", name_size);
1849
1850     /*
1851      *  sound/core/ctljack.c has a convention of naming jack controls
1852      * by ending in " Jack".  Make it slightly more useful by
1853      * indicating Input or Output after the terminal name.
1854      */
1855     if (is_input)
1856         strlcat(name, " - Input Jack", name_size);
1857     else
1858         strlcat(name, " - Output Jack", name_size);
1859 }
1860
1861 /* get connector value to "wake up" the USB audio */
1862 static int connector_mixer_resume(struct usb_mixer_elem_list *list)
1863 {
1864     struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
1865
1866     get_connector_value(cval, NULL, NULL);
1867     return 0;
1868 }
1869
1870 /* Build a mixer control for a UAC connector control (jack-detect) */
1871 static void build_connector_control(struct usb_mixer_interface *mixer,
1872                     const struct usbmix_name_map *imap,
1873                     struct usb_audio_term *term, bool is_input)
1874 {
1875     struct snd_kcontrol *kctl;
1876     struct usb_mixer_elem_info *cval;
1877     const struct usbmix_name_map *map;
1878
1879     map = find_map(imap, term->id, 0);
1880     if (check_ignored_ctl(map))
1881         return;
1882
1883     cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1884     if (!cval)
1885         return;
1886     snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
1887
1888     /* set up a specific resume callback */
1889     cval->head.resume = connector_mixer_resume;
1890
1891     /*
1892      * UAC2: The first byte from reading the UAC2_TE_CONNECTOR control returns the
1893      * number of channels connected.
1894      *
1895      * UAC3: The first byte specifies size of bitmap for the inserted controls. The
1896      * following byte(s) specifies which connectors are inserted.
1897      *
1898      * This boolean ctl will simply report if any channels are connected
1899      * or not.
1900      */
1901     if (mixer->protocol == UAC_VERSION_2)
1902         cval->control = UAC2_TE_CONNECTOR;
1903     else /* UAC_VERSION_3 */
1904         cval->control = UAC3_TE_INSERTION;
1905
1906     cval->val_type = USB_MIXER_BOOLEAN;
1907     cval->channels = 1; /* report true if any channel is connected */
1908     cval->min = 0;
1909     cval->max = 1;
1910     kctl = snd_ctl_new1(&usb_connector_ctl_ro, cval);
1911     if (!kctl) {
1912         usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1913         usb_mixer_elem_info_free(cval);
1914         return;
1915     }
1916
1917     if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name)))
1918         strlcat(kctl->id.name, " Jack", sizeof(kctl->id.name));
1919     else
1920         get_connector_control_name(mixer, term, is_input, kctl->id.name,
1921                        sizeof(kctl->id.name));
1922     kctl->private_free = snd_usb_mixer_elem_free;
1923     snd_usb_mixer_add_control(&cval->head, kctl);
1924 }
1925
1926 static int parse_clock_source_unit(struct mixer_build *state, int unitid,
1927                    void *_ftr)
1928 {
1929     struct uac_clock_source_descriptor *hdr = _ftr;
1930     struct usb_mixer_elem_info *cval;
1931     struct snd_kcontrol *kctl;
1932     char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1933     int ret;
1934
1935     if (state->mixer->protocol != UAC_VERSION_2)
1936         return -EINVAL;
1937
1938     /*
1939      * The only property of this unit we are interested in is the
1940      * clock source validity. If that isn't readable, just bail out.
1941      */
1942     if (!uac_v2v3_control_is_readable(hdr->bmControls,
1943                       UAC2_CS_CONTROL_CLOCK_VALID))
1944         return 0;
1945
1946     cval = kzalloc(sizeof(*cval), GFP_KERNEL);
1947     if (!cval)
1948         return -ENOMEM;
1949
1950     snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
1951
1952     cval->min = 0;
1953     cval->max = 1;
1954     cval->channels = 1;
1955     cval->val_type = USB_MIXER_BOOLEAN;
1956     cval->control = UAC2_CS_CONTROL_CLOCK_VALID;
1957
1958     cval->master_readonly = 1;
1959     /* From UAC2 5.2.5.1.2 "Only the get request is supported." */
1960     kctl = snd_ctl_new1(&usb_bool_master_control_ctl_ro, cval);
1961
1962     if (!kctl) {
1963         usb_mixer_elem_info_free(cval);
1964         return -ENOMEM;
1965     }
1966
1967     kctl->private_free = snd_usb_mixer_elem_free;
1968     ret = snd_usb_copy_string_desc(state->chip, hdr->iClockSource,
1969                        name, sizeof(name));
1970     if (ret > 0)
1971         snprintf(kctl->id.name, sizeof(kctl->id.name),
1972              "%s Validity", name);
1973     else
1974         snprintf(kctl->id.name, sizeof(kctl->id.name),
1975              "Clock Source %d Validity", hdr->bClockID);
1976
1977     return snd_usb_mixer_add_control(&cval->head, kctl);
1978 }
1979
1980 /*
1981  * parse a feature unit
1982  *
1983  * most of controls are defined here.
1984  */
1985 static int parse_audio_feature_unit(struct mixer_build *state, int unitid,
1986                     void *_ftr)
1987 {
1988     int channels, i, j;
1989     struct usb_audio_term iterm;
1990     unsigned int master_bits;
1991     int err, csize;
1992     struct uac_feature_unit_descriptor *hdr = _ftr;
1993     __u8 *bmaControls;
1994
1995     if (state->mixer->protocol == UAC_VERSION_1) {
1996         csize = hdr->bControlSize;
1997         channels = (hdr->bLength - 7) / csize - 1;
1998         bmaControls = hdr->bmaControls;
1999     } else if (state->mixer->protocol == UAC_VERSION_2) {
2000         struct uac2_feature_unit_descriptor *ftr = _ftr;
2001         csize = 4;
2002         channels = (hdr->bLength - 6) / 4 - 1;
2003         bmaControls = ftr->bmaControls;
2004     } else { /* UAC_VERSION_3 */
2005         struct uac3_feature_unit_descriptor *ftr = _ftr;
2006
2007         csize = 4;
2008         channels = (ftr->bLength - 7) / 4 - 1;
2009         bmaControls = ftr->bmaControls;
2010     }
2011
2012     /* parse the source unit */
2013     err = parse_audio_unit(state, hdr->bSourceID);
2014     if (err < 0)
2015         return err;
2016
2017     /* determine the input source type and name */
2018     err = check_input_term(state, hdr->bSourceID, &iterm);
2019     if (err < 0)
2020         return err;
2021
2022     master_bits = snd_usb_combine_bytes(bmaControls, csize);
2023     /* master configuration quirks */
2024     switch (state->chip->usb_id) {
2025     case USB_ID(0x08bb, 0x2702):
2026         usb_audio_info(state->chip,
2027                    "usbmixer: master volume quirk for PCM2702 chip\n");
2028         /* disable non-functional volume control */
2029         master_bits &= ~UAC_CONTROL_BIT(UAC_FU_VOLUME);
2030         break;
2031     case USB_ID(0x1130, 0xf211):
2032         usb_audio_info(state->chip,
2033                    "usbmixer: volume control quirk for Tenx TP6911 Audio Headset\n");
2034         /* disable non-functional volume control */
2035         channels = 0;
2036         break;
2037
2038     }
2039
2040     if (state->mixer->protocol == UAC_VERSION_1) {
2041         /* check all control types */
2042         for (i = 0; i < 10; i++) {
2043             unsigned int ch_bits = 0;
2044             int control = audio_feature_info[i].control;
2045
2046             for (j = 0; j < channels; j++) {
2047                 unsigned int mask;
2048
2049                 mask = snd_usb_combine_bytes(bmaControls +
2050                                  csize * (j+1), csize);
2051                 if (mask & (1 << i))
2052                     ch_bits |= (1 << j);
2053             }
2054             /* audio class v1 controls are never read-only */
2055
2056             /*
2057              * The first channel must be set
2058              * (for ease of programming).
2059              */
2060             if (ch_bits & 1)
2061                 build_feature_ctl(state, _ftr, ch_bits, control,
2062                           &iterm, unitid, 0);
2063             if (master_bits & (1 << i))
2064                 build_feature_ctl(state, _ftr, 0, control,
2065                           &iterm, unitid, 0);
2066         }
2067     } else { /* UAC_VERSION_2/3 */
2068         for (i = 0; i < ARRAY_SIZE(audio_feature_info); i++) {
2069             unsigned int ch_bits = 0;
2070             unsigned int ch_read_only = 0;
2071             int control = audio_feature_info[i].control;
2072
2073             for (j = 0; j < channels; j++) {
2074                 unsigned int mask;
2075
2076                 mask = snd_usb_combine_bytes(bmaControls +
2077                                  csize * (j+1), csize);
2078                 if (uac_v2v3_control_is_readable(mask, control)) {
2079                     ch_bits |= (1 << j);
2080                     if (!uac_v2v3_control_is_writeable(mask, control))
2081                         ch_read_only |= (1 << j);
2082                 }
2083             }
2084
2085             /*
2086              * NOTE: build_feature_ctl() will mark the control
2087              * read-only if all channels are marked read-only in
2088              * the descriptors. Otherwise, the control will be
2089              * reported as writeable, but the driver will not
2090              * actually issue a write command for read-only
2091              * channels.
2092              */
2093
2094             /*
2095              * The first channel must be set
2096              * (for ease of programming).
2097              */
2098             if (ch_bits & 1)
2099                 build_feature_ctl(state, _ftr, ch_bits, control,
2100                           &iterm, unitid, ch_read_only);
2101             if (uac_v2v3_control_is_readable(master_bits, control))
2102                 build_feature_ctl(state, _ftr, 0, control,
2103                           &iterm, unitid,
2104                           !uac_v2v3_control_is_writeable(master_bits,
2105                                          control));
2106         }
2107     }
2108
2109     return 0;
2110 }
2111
2112 /*
2113  * Mixer Unit
2114  */
2115
2116 /* check whether the given in/out overflows bmMixerControls matrix */
2117 static bool mixer_bitmap_overflow(struct uac_mixer_unit_descriptor *desc,
2118                   int protocol, int num_ins, int num_outs)
2119 {
2120     u8 *hdr = (u8 *)desc;
2121     u8 *c = uac_mixer_unit_bmControls(desc, protocol);
2122     size_t rest; /* remaining bytes after bmMixerControls */
2123
2124     switch (protocol) {
2125     case UAC_VERSION_1:
2126     default:
2127         rest = 1; /* iMixer */
2128         break;
2129     case UAC_VERSION_2:
2130         rest = 2; /* bmControls + iMixer */
2131         break;
2132     case UAC_VERSION_3:
2133         rest = 6; /* bmControls + wMixerDescrStr */
2134         break;
2135     }
2136
2137     /* overflow? */
2138     return c + (num_ins * num_outs + 7) / 8 + rest > hdr + hdr[0];
2139 }
2140
2141 /*
2142  * build a mixer unit control
2143  *
2144  * the callbacks are identical with feature unit.
2145  * input channel number (zero based) is given in control field instead.
2146  */
2147 static void build_mixer_unit_ctl(struct mixer_build *state,
2148                  struct uac_mixer_unit_descriptor *desc,
2149                  int in_pin, int in_ch, int num_outs,
2150                  int unitid, struct usb_audio_term *iterm)
2151 {
2152     struct usb_mixer_elem_info *cval;
2153     unsigned int i, len;
2154     struct snd_kcontrol *kctl;
2155     const struct usbmix_name_map *map;
2156
2157     map = find_map(state->map, unitid, 0);
2158     if (check_ignored_ctl(map))
2159         return;
2160
2161     cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2162     if (!cval)
2163         return;
2164
2165     snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2166     cval->control = in_ch + 1; /* based on 1 */
2167     cval->val_type = USB_MIXER_S16;
2168     for (i = 0; i < num_outs; i++) {
2169         __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
2170
2171         if (check_matrix_bitmap(c, in_ch, i, num_outs)) {
2172             cval->cmask |= (1 << i);
2173             cval->channels++;
2174         }
2175     }
2176
2177     /* get min/max values */
2178     get_min_max(cval, 0);
2179
2180     kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
2181     if (!kctl) {
2182         usb_audio_err(state->chip, "cannot malloc kcontrol\n");
2183         usb_mixer_elem_info_free(cval);
2184         return;
2185     }
2186     kctl->private_free = snd_usb_mixer_elem_free;
2187
2188     len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
2189     if (!len)
2190         len = get_term_name(state->chip, iterm, kctl->id.name,
2191                     sizeof(kctl->id.name), 0);
2192     if (!len)
2193         len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
2194     append_ctl_name(kctl, " Volume");
2195
2196     usb_audio_dbg(state->chip, "[%d] MU [%s] ch = %d, val = %d/%d\n",
2197             cval->head.id, kctl->id.name, cval->channels, cval->min, cval->max);
2198     snd_usb_mixer_add_control(&cval->head, kctl);
2199 }
2200
2201 static int parse_audio_input_terminal(struct mixer_build *state, int unitid,
2202                       void *raw_desc)
2203 {
2204     struct usb_audio_term iterm;
2205     unsigned int control, bmctls, term_id;
2206
2207     if (state->mixer->protocol == UAC_VERSION_2) {
2208         struct uac2_input_terminal_descriptor *d_v2 = raw_desc;
2209         control = UAC2_TE_CONNECTOR;
2210         term_id = d_v2->bTerminalID;
2211         bmctls = le16_to_cpu(d_v2->bmControls);
2212     } else if (state->mixer->protocol == UAC_VERSION_3) {
2213         struct uac3_input_terminal_descriptor *d_v3 = raw_desc;
2214         control = UAC3_TE_INSERTION;
2215         term_id = d_v3->bTerminalID;
2216         bmctls = le32_to_cpu(d_v3->bmControls);
2217     } else {
2218         return 0; /* UAC1. No Insertion control */
2219     }
2220
2221     check_input_term(state, term_id, &iterm);
2222
2223     /* Check for jack detection. */
2224     if ((iterm.type & 0xff00) != 0x0100 &&
2225         uac_v2v3_control_is_readable(bmctls, control))
2226         build_connector_control(state->mixer, state->map, &iterm, true);
2227
2228     return 0;
2229 }
2230
2231 /*
2232  * parse a mixer unit
2233  */
2234 static int parse_audio_mixer_unit(struct mixer_build *state, int unitid,
2235                   void *raw_desc)
2236 {
2237     struct uac_mixer_unit_descriptor *desc = raw_desc;
2238     struct usb_audio_term iterm;
2239     int input_pins, num_ins, num_outs;
2240     int pin, ich, err;
2241
2242     err = uac_mixer_unit_get_channels(state, desc);
2243     if (err < 0) {
2244         usb_audio_err(state->chip,
2245                   "invalid MIXER UNIT descriptor %d\n",
2246                   unitid);
2247         return err;
2248     }
2249
2250     num_outs = err;
2251     input_pins = desc->bNrInPins;
2252
2253     num_ins = 0;
2254     ich = 0;
2255     for (pin = 0; pin < input_pins; pin++) {
2256         err = parse_audio_unit(state, desc->baSourceID[pin]);
2257         if (err < 0)
2258             continue;
2259         /* no bmControls field (e.g. Maya44) -> ignore */
2260         if (!num_outs)
2261             continue;
2262         err = check_input_term(state, desc->baSourceID[pin], &iterm);
2263         if (err < 0)
2264             return err;
2265         num_ins += iterm.channels;
2266         if (mixer_bitmap_overflow(desc, state->mixer->protocol,
2267                       num_ins, num_outs))
2268             break;
2269         for (; ich < num_ins; ich++) {
2270             int och, ich_has_controls = 0;
2271
2272             for (och = 0; och < num_outs; och++) {
2273                 __u8 *c = uac_mixer_unit_bmControls(desc,
2274                         state->mixer->protocol);
2275
2276                 if (check_matrix_bitmap(c, ich, och, num_outs)) {
2277                     ich_has_controls = 1;
2278                     break;
2279                 }
2280             }
2281             if (ich_has_controls)
2282                 build_mixer_unit_ctl(state, desc, pin, ich, num_outs,
2283                              unitid, &iterm);
2284         }
2285     }
2286     return 0;
2287 }
2288
2289 /*
2290  * Processing Unit / Extension Unit
2291  */
2292
2293 /* get callback for processing/extension unit */
2294 static int mixer_ctl_procunit_get(struct snd_kcontrol *kcontrol,
2295                   struct snd_ctl_elem_value *ucontrol)
2296 {
2297     struct usb_mixer_elem_info *cval = kcontrol->private_data;
2298     int err, val;
2299
2300     err = get_cur_ctl_value(cval, cval->control << 8, &val);
2301     if (err < 0) {
2302         ucontrol->value.integer.value[0] = cval->min;
2303         return filter_error(cval, err);
2304     }
2305     val = get_relative_value(cval, val);
2306     ucontrol->value.integer.value[0] = val;
2307     return 0;
2308 }
2309
2310 /* put callback for processing/extension unit */
2311 static int mixer_ctl_procunit_put(struct snd_kcontrol *kcontrol,
2312                   struct snd_ctl_elem_value *ucontrol)
2313 {
2314     struct usb_mixer_elem_info *cval = kcontrol->private_data;
2315     int val, oval, err;
2316
2317     err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2318     if (err < 0)
2319         return filter_error(cval, err);
2320     val = ucontrol->value.integer.value[0];
2321     val = get_abs_value(cval, val);
2322     if (val != oval) {
2323         set_cur_ctl_value(cval, cval->control << 8, val);
2324         return 1;
2325     }
2326     return 0;
2327 }
2328
2329 /* alsa control interface for processing/extension unit */
2330 static const struct snd_kcontrol_new mixer_procunit_ctl = {
2331     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2332     .name = "", /* will be filled later */
2333     .info = mixer_ctl_feature_info,
2334     .get = mixer_ctl_procunit_get,
2335     .put = mixer_ctl_procunit_put,
2336 };
2337
2338 /*
2339  * predefined data for processing units
2340  */
2341 struct procunit_value_info {
2342     int control;
2343     const char *suffix;
2344     int val_type;
2345     int min_value;
2346 };
2347
2348 struct procunit_info {
2349     int type;
2350     char *name;
2351     const struct procunit_value_info *values;
2352 };
2353
2354 static const struct procunit_value_info undefined_proc_info[] = {
2355     { 0x00, "Control Undefined", 0 },
2356     { 0 }
2357 };
2358
2359 static const struct procunit_value_info updown_proc_info[] = {
2360     { UAC_UD_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2361     { UAC_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
2362     { 0 }
2363 };
2364 static const struct procunit_value_info prologic_proc_info[] = {
2365     { UAC_DP_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2366     { UAC_DP_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
2367     { 0 }
2368 };
2369 static const struct procunit_value_info threed_enh_proc_info[] = {
2370     { UAC_3D_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2371     { UAC_3D_SPACE, "Spaciousness", USB_MIXER_U8 },
2372     { 0 }
2373 };
2374 static const struct procunit_value_info reverb_proc_info[] = {
2375     { UAC_REVERB_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2376     { UAC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
2377     { UAC_REVERB_TIME, "Time", USB_MIXER_U16 },
2378     { UAC_REVERB_FEEDBACK, "Feedback", USB_MIXER_U8 },
2379     { 0 }
2380 };
2381 static const struct procunit_value_info chorus_proc_info[] = {
2382     { UAC_CHORUS_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2383     { UAC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
2384     { UAC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
2385     { UAC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
2386     { 0 }
2387 };
2388 static const struct procunit_value_info dcr_proc_info[] = {
2389     { UAC_DCR_ENABLE, "Switch", USB_MIXER_BOOLEAN },
2390     { UAC_DCR_RATE, "Ratio", USB_MIXER_U16 },
2391     { UAC_DCR_MAXAMPL, "Max Amp", USB_MIXER_S16 },
2392     { UAC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
2393     { UAC_DCR_ATTACK_TIME, "Attack Time", USB_MIXER_U16 },
2394     { UAC_DCR_RELEASE_TIME, "Release Time", USB_MIXER_U16 },
2395     { 0 }
2396 };
2397
2398 static const struct procunit_info procunits[] = {
2399     { UAC_PROCESS_UP_DOWNMIX, "Up Down", updown_proc_info },
2400     { UAC_PROCESS_DOLBY_PROLOGIC, "Dolby Prologic", prologic_proc_info },
2401     { UAC_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", threed_enh_proc_info },
2402     { UAC_PROCESS_REVERB, "Reverb", reverb_proc_info },
2403     { UAC_PROCESS_CHORUS, "Chorus", chorus_proc_info },
2404     { UAC_PROCESS_DYN_RANGE_COMP, "DCR", dcr_proc_info },
2405     { 0 },
2406 };
2407
2408 static const struct procunit_value_info uac3_updown_proc_info[] = {
2409     { UAC3_UD_MODE_SELECT, "Mode Select", USB_MIXER_U8, 1 },
2410     { 0 }
2411 };
2412 static const struct procunit_value_info uac3_stereo_ext_proc_info[] = {
2413     { UAC3_EXT_WIDTH_CONTROL, "Width Control", USB_MIXER_U8 },
2414     { 0 }
2415 };
2416
2417 static const struct procunit_info uac3_procunits[] = {
2418     { UAC3_PROCESS_UP_DOWNMIX, "Up Down", uac3_updown_proc_info },
2419     { UAC3_PROCESS_STEREO_EXTENDER, "3D Stereo Extender", uac3_stereo_ext_proc_info },
2420     { UAC3_PROCESS_MULTI_FUNCTION, "Multi-Function", undefined_proc_info },
2421     { 0 },
2422 };
2423
2424 /*
2425  * predefined data for extension units
2426  */
2427 static const struct procunit_value_info clock_rate_xu_info[] = {
2428     { USB_XU_CLOCK_RATE_SELECTOR, "Selector", USB_MIXER_U8, 0 },
2429     { 0 }
2430 };
2431 static const struct procunit_value_info clock_source_xu_info[] = {
2432     { USB_XU_CLOCK_SOURCE_SELECTOR, "External", USB_MIXER_BOOLEAN },
2433     { 0 }
2434 };
2435 static const struct procunit_value_info spdif_format_xu_info[] = {
2436     { USB_XU_DIGITAL_FORMAT_SELECTOR, "SPDIF/AC3", USB_MIXER_BOOLEAN },
2437     { 0 }
2438 };
2439 static const struct procunit_value_info soft_limit_xu_info[] = {
2440     { USB_XU_SOFT_LIMIT_SELECTOR, " ", USB_MIXER_BOOLEAN },
2441     { 0 }
2442 };
2443 static const struct procunit_info extunits[] = {
2444     { USB_XU_CLOCK_RATE, "Clock rate", clock_rate_xu_info },
2445     { USB_XU_CLOCK_SOURCE, "DigitalIn CLK source", clock_source_xu_info },
2446     { USB_XU_DIGITAL_IO_STATUS, "DigitalOut format:", spdif_format_xu_info },
2447     { USB_XU_DEVICE_OPTIONS, "AnalogueIn Soft Limit", soft_limit_xu_info },
2448     { 0 }
2449 };
2450
2451 /*
2452  * build a processing/extension unit
2453  */
2454 static int build_audio_procunit(struct mixer_build *state, int unitid,
2455                 void *raw_desc, const struct procunit_info *list,
2456                 bool extension_unit)
2457 {
2458     struct uac_processing_unit_descriptor *desc = raw_desc;
2459     int num_ins;
2460     struct usb_mixer_elem_info *cval;
2461     struct snd_kcontrol *kctl;
2462     int i, err, nameid, type, len, val;
2463     const struct procunit_info *info;
2464     const struct procunit_value_info *valinfo;
2465     const struct usbmix_name_map *map;
2466     static const struct procunit_value_info default_value_info[] = {
2467         { 0x01, "Switch", USB_MIXER_BOOLEAN },
2468         { 0 }
2469     };
2470     static const struct procunit_info default_info = {
2471         0, NULL, default_value_info
2472     };
2473     const char *name = extension_unit ?
2474         "Extension Unit" : "Processing Unit";
2475
2476     num_ins = desc->bNrInPins;
2477     for (i = 0; i < num_ins; i++) {
2478         err = parse_audio_unit(state, desc->baSourceID[i]);
2479         if (err < 0)
2480             return err;
2481     }
2482
2483     type = le16_to_cpu(desc->wProcessType);
2484     for (info = list; info && info->type; info++)
2485         if (info->type == type)
2486             break;
2487     if (!info || !info->type)
2488         info = &default_info;
2489
2490     for (valinfo = info->values; valinfo->control; valinfo++) {
2491         __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
2492
2493         if (state->mixer->protocol == UAC_VERSION_1) {
2494             if (!(controls[valinfo->control / 8] &
2495                     (1 << ((valinfo->control % 8) - 1))))
2496                 continue;
2497         } else { /* UAC_VERSION_2/3 */
2498             if (!uac_v2v3_control_is_readable(controls[valinfo->control / 8],
2499                               valinfo->control))
2500                 continue;
2501         }
2502
2503         map = find_map(state->map, unitid, valinfo->control);
2504         if (check_ignored_ctl(map))
2505             continue;
2506         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2507         if (!cval)
2508             return -ENOMEM;
2509         snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2510         cval->control = valinfo->control;
2511         cval->val_type = valinfo->val_type;
2512         cval->channels = 1;
2513
2514         if (state->mixer->protocol > UAC_VERSION_1 &&
2515             !uac_v2v3_control_is_writeable(controls[valinfo->control / 8],
2516                            valinfo->control))
2517             cval->master_readonly = 1;
2518
2519         /* get min/max values */
2520         switch (type) {
2521         case UAC_PROCESS_UP_DOWNMIX: {
2522             bool mode_sel = false;
2523
2524             switch (state->mixer->protocol) {
2525             case UAC_VERSION_1:
2526             case UAC_VERSION_2:
2527             default:
2528                 if (cval->control == UAC_UD_MODE_SELECT)
2529                     mode_sel = true;
2530                 break;
2531             case UAC_VERSION_3:
2532                 if (cval->control == UAC3_UD_MODE_SELECT)
2533                     mode_sel = true;
2534                 break;
2535             }
2536
2537             if (mode_sel) {
2538                 __u8 *control_spec = uac_processing_unit_specific(desc,
2539                                 state->mixer->protocol);
2540                 cval->min = 1;
2541                 cval->max = control_spec[0];
2542                 cval->res = 1;
2543                 cval->initialized = 1;
2544                 break;
2545             }
2546
2547             get_min_max(cval, valinfo->min_value);
2548             break;
2549         }
2550         case USB_XU_CLOCK_RATE:
2551             /*
2552              * E-Mu USB 0404/0202/TrackerPre/0204
2553              * samplerate control quirk
2554              */
2555             cval->min = 0;
2556             cval->max = 5;
2557             cval->res = 1;
2558             cval->initialized = 1;
2559             break;
2560         default:
2561             get_min_max(cval, valinfo->min_value);
2562             break;
2563         }
2564
2565         err = get_cur_ctl_value(cval, cval->control << 8, &val);
2566         if (err < 0) {
2567             usb_mixer_elem_info_free(cval);
2568             return -EINVAL;
2569         }
2570
2571         kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
2572         if (!kctl) {
2573             usb_mixer_elem_info_free(cval);
2574             return -ENOMEM;
2575         }
2576         kctl->private_free = snd_usb_mixer_elem_free;
2577
2578         if (check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name))) {
2579             /* nothing */ ;
2580         } else if (info->name) {
2581             strscpy(kctl->id.name, info->name, sizeof(kctl->id.name));
2582         } else {
2583             if (extension_unit)
2584                 nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol);
2585             else
2586                 nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
2587             len = 0;
2588             if (nameid)
2589                 len = snd_usb_copy_string_desc(state->chip,
2590                                    nameid,
2591                                    kctl->id.name,
2592                                    sizeof(kctl->id.name));
2593             if (!len)
2594                 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
2595         }
2596         append_ctl_name(kctl, " ");
2597         append_ctl_name(kctl, valinfo->suffix);
2598
2599         usb_audio_dbg(state->chip,
2600                   "[%d] PU [%s] ch = %d, val = %d/%d\n",
2601                   cval->head.id, kctl->id.name, cval->channels,
2602                   cval->min, cval->max);
2603
2604         err = snd_usb_mixer_add_control(&cval->head, kctl);
2605         if (err < 0)
2606             return err;
2607     }
2608     return 0;
2609 }
2610
2611 static int parse_audio_processing_unit(struct mixer_build *state, int unitid,
2612                        void *raw_desc)
2613 {
2614     switch (state->mixer->protocol) {
2615     case UAC_VERSION_1:
2616     case UAC_VERSION_2:
2617     default:
2618         return build_audio_procunit(state, unitid, raw_desc,
2619                         procunits, false);
2620     case UAC_VERSION_3:
2621         return build_audio_procunit(state, unitid, raw_desc,
2622                         uac3_procunits, false);
2623     }
2624 }
2625
2626 static int parse_audio_extension_unit(struct mixer_build *state, int unitid,
2627                       void *raw_desc)
2628 {
2629     /*
2630      * Note that we parse extension units with processing unit descriptors.
2631      * That's ok as the layout is the same.
2632      */
2633     return build_audio_procunit(state, unitid, raw_desc, extunits, true);
2634 }
2635
2636 /*
2637  * Selector Unit
2638  */
2639
2640 /*
2641  * info callback for selector unit
2642  * use an enumerator type for routing
2643  */
2644 static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol,
2645                    struct snd_ctl_elem_info *uinfo)
2646 {
2647     struct usb_mixer_elem_info *cval = kcontrol->private_data;
2648     const char **itemlist = (const char **)kcontrol->private_value;
2649
2650     if (snd_BUG_ON(!itemlist))
2651         return -EINVAL;
2652     return snd_ctl_enum_info(uinfo, 1, cval->max, itemlist);
2653 }
2654
2655 /* get callback for selector unit */
2656 static int mixer_ctl_selector_get(struct snd_kcontrol *kcontrol,
2657                   struct snd_ctl_elem_value *ucontrol)
2658 {
2659     struct usb_mixer_elem_info *cval = kcontrol->private_data;
2660     int val, err;
2661
2662     err = get_cur_ctl_value(cval, cval->control << 8, &val);
2663     if (err < 0) {
2664         ucontrol->value.enumerated.item[0] = 0;
2665         return filter_error(cval, err);
2666     }
2667     val = get_relative_value(cval, val);
2668     ucontrol->value.enumerated.item[0] = val;
2669     return 0;
2670 }
2671
2672 /* put callback for selector unit */
2673 static int mixer_ctl_selector_put(struct snd_kcontrol *kcontrol,
2674                   struct snd_ctl_elem_value *ucontrol)
2675 {
2676     struct usb_mixer_elem_info *cval = kcontrol->private_data;
2677     int val, oval, err;
2678
2679     err = get_cur_ctl_value(cval, cval->control << 8, &oval);
2680     if (err < 0)
2681         return filter_error(cval, err);
2682     val = ucontrol->value.enumerated.item[0];
2683     val = get_abs_value(cval, val);
2684     if (val != oval) {
2685         set_cur_ctl_value(cval, cval->control << 8, val);
2686         return 1;
2687     }
2688     return 0;
2689 }
2690
2691 /* alsa control interface for selector unit */
2692 static const struct snd_kcontrol_new mixer_selectunit_ctl = {
2693     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2694     .name = "", /* will be filled later */
2695     .info = mixer_ctl_selector_info,
2696     .get = mixer_ctl_selector_get,
2697     .put = mixer_ctl_selector_put,
2698 };
2699
2700 /*
2701  * private free callback.
2702  * free both private_data and private_value
2703  */
2704 static void usb_mixer_selector_elem_free(struct snd_kcontrol *kctl)
2705 {
2706     int i, num_ins = 0;
2707
2708     if (kctl->private_data) {
2709         struct usb_mixer_elem_info *cval = kctl->private_data;
2710         num_ins = cval->max;
2711         usb_mixer_elem_info_free(cval);
2712         kctl->private_data = NULL;
2713     }
2714     if (kctl->private_value) {
2715         char **itemlist = (char **)kctl->private_value;
2716         for (i = 0; i < num_ins; i++)
2717             kfree(itemlist[i]);
2718         kfree(itemlist);
2719         kctl->private_value = 0;
2720     }
2721 }
2722
2723 /*
2724  * parse a selector unit
2725  */
2726 static int parse_audio_selector_unit(struct mixer_build *state, int unitid,
2727                      void *raw_desc)
2728 {
2729     struct uac_selector_unit_descriptor *desc = raw_desc;
2730     unsigned int i, nameid, len;
2731     int err;
2732     struct usb_mixer_elem_info *cval;
2733     struct snd_kcontrol *kctl;
2734     const struct usbmix_name_map *map;
2735     char **namelist;
2736
2737     for (i = 0; i < desc->bNrInPins; i++) {
2738         err = parse_audio_unit(state, desc->baSourceID[i]);
2739         if (err < 0)
2740             return err;
2741     }
2742
2743     if (desc->bNrInPins == 1) /* only one ? nonsense! */
2744         return 0;
2745
2746     map = find_map(state->map, unitid, 0);
2747     if (check_ignored_ctl(map))
2748         return 0;
2749
2750     cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2751     if (!cval)
2752         return -ENOMEM;
2753     snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2754     cval->val_type = USB_MIXER_U8;
2755     cval->channels = 1;
2756     cval->min = 1;
2757     cval->max = desc->bNrInPins;
2758     cval->res = 1;
2759     cval->initialized = 1;
2760
2761     switch (state->mixer->protocol) {
2762     case UAC_VERSION_1:
2763     default:
2764         cval->control = 0;
2765         break;
2766     case UAC_VERSION_2:
2767     case UAC_VERSION_3:
2768         if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR ||
2769             desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR)
2770             cval->control = UAC2_CX_CLOCK_SELECTOR;
2771         else /* UAC2/3_SELECTOR_UNIT */
2772             cval->control = UAC2_SU_SELECTOR;
2773         break;
2774     }
2775
2776     namelist = kcalloc(desc->bNrInPins, sizeof(char *), GFP_KERNEL);
2777     if (!namelist) {
2778         err = -ENOMEM;
2779         goto error_cval;
2780     }
2781 #define MAX_ITEM_NAME_LEN   64
2782     for (i = 0; i < desc->bNrInPins; i++) {
2783         struct usb_audio_term iterm;
2784         namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
2785         if (!namelist[i]) {
2786             err = -ENOMEM;
2787             goto error_name;
2788         }
2789         len = check_mapped_selector_name(state, unitid, i, namelist[i],
2790                          MAX_ITEM_NAME_LEN);
2791         if (! len && check_input_term(state, desc->baSourceID[i], &iterm) >= 0)
2792             len = get_term_name(state->chip, &iterm, namelist[i],
2793                         MAX_ITEM_NAME_LEN, 0);
2794         if (! len)
2795             sprintf(namelist[i], "Input %u", i);
2796     }
2797
2798     kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
2799     if (! kctl) {
2800         usb_audio_err(state->chip, "cannot malloc kcontrol\n");
2801         err = -ENOMEM;
2802         goto error_name;
2803     }
2804     kctl->private_value = (unsigned long)namelist;
2805     kctl->private_free = usb_mixer_selector_elem_free;
2806
2807     /* check the static mapping table at first */
2808     len = check_mapped_name(map, kctl->id.name, sizeof(kctl->id.name));
2809     if (!len) {
2810         /* no mapping ? */
2811         switch (state->mixer->protocol) {
2812         case UAC_VERSION_1:
2813         case UAC_VERSION_2:
2814         default:
2815         /* if iSelector is given, use it */
2816             nameid = uac_selector_unit_iSelector(desc);
2817             if (nameid)
2818                 len = snd_usb_copy_string_desc(state->chip,
2819                             nameid, kctl->id.name,
2820                             sizeof(kctl->id.name));
2821             break;
2822         case UAC_VERSION_3:
2823             /* TODO: Class-Specific strings not yet supported */
2824             break;
2825         }
2826
2827         /* ... or pick up the terminal name at next */
2828         if (!len)
2829             len = get_term_name(state->chip, &state->oterm,
2830                     kctl->id.name, sizeof(kctl->id.name), 0);
2831         /* ... or use the fixed string "USB" as the last resort */
2832         if (!len)
2833             strscpy(kctl->id.name, "USB", sizeof(kctl->id.name));
2834
2835         /* and add the proper suffix */
2836         if (desc->bDescriptorSubtype == UAC2_CLOCK_SELECTOR ||
2837             desc->bDescriptorSubtype == UAC3_CLOCK_SELECTOR)
2838             append_ctl_name(kctl, " Clock Source");
2839         else if ((state->oterm.type & 0xff00) == 0x0100)
2840             append_ctl_name(kctl, " Capture Source");
2841         else
2842             append_ctl_name(kctl, " Playback Source");
2843     }
2844
2845     usb_audio_dbg(state->chip, "[%d] SU [%s] items = %d\n",
2846             cval->head.id, kctl->id.name, desc->bNrInPins);
2847     return snd_usb_mixer_add_control(&cval->head, kctl);
2848
2849  error_name:
2850     for (i = 0; i < desc->bNrInPins; i++)
2851         kfree(namelist[i]);
2852     kfree(namelist);
2853  error_cval:
2854     usb_mixer_elem_info_free(cval);
2855     return err;
2856 }
2857
2858 /*
2859  * parse an audio unit recursively
2860  */
2861
2862 static int parse_audio_unit(struct mixer_build *state, int unitid)
2863 {
2864     unsigned char *p1;
2865     int protocol = state->mixer->protocol;
2866
2867     if (test_and_set_bit(unitid, state->unitbitmap))
2868         return 0; /* the unit already visited */
2869
2870     p1 = find_audio_control_unit(state, unitid);
2871     if (!p1) {
2872         usb_audio_err(state->chip, "unit %d not found!\n", unitid);
2873         return -EINVAL;
2874     }
2875
2876     if (!snd_usb_validate_audio_desc(p1, protocol)) {
2877         usb_audio_dbg(state->chip, "invalid unit %d\n", unitid);
2878         return 0; /* skip invalid unit */
2879     }
2880
2881     switch (PTYPE(protocol, p1[2])) {
2882     case PTYPE(UAC_VERSION_1, UAC_INPUT_TERMINAL):
2883     case PTYPE(UAC_VERSION_2, UAC_INPUT_TERMINAL):
2884     case PTYPE(UAC_VERSION_3, UAC_INPUT_TERMINAL):
2885         return parse_audio_input_terminal(state, unitid, p1);
2886     case PTYPE(UAC_VERSION_1, UAC_MIXER_UNIT):
2887     case PTYPE(UAC_VERSION_2, UAC_MIXER_UNIT):
2888     case PTYPE(UAC_VERSION_3, UAC3_MIXER_UNIT):
2889         return parse_audio_mixer_unit(state, unitid, p1);
2890     case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SOURCE):
2891     case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SOURCE):
2892         return parse_clock_source_unit(state, unitid, p1);
2893     case PTYPE(UAC_VERSION_1, UAC_SELECTOR_UNIT):
2894     case PTYPE(UAC_VERSION_2, UAC_SELECTOR_UNIT):
2895     case PTYPE(UAC_VERSION_3, UAC3_SELECTOR_UNIT):
2896     case PTYPE(UAC_VERSION_2, UAC2_CLOCK_SELECTOR):
2897     case PTYPE(UAC_VERSION_3, UAC3_CLOCK_SELECTOR):
2898         return parse_audio_selector_unit(state, unitid, p1);
2899     case PTYPE(UAC_VERSION_1, UAC_FEATURE_UNIT):
2900     case PTYPE(UAC_VERSION_2, UAC_FEATURE_UNIT):
2901     case PTYPE(UAC_VERSION_3, UAC3_FEATURE_UNIT):
2902         return parse_audio_feature_unit(state, unitid, p1);
2903     case PTYPE(UAC_VERSION_1, UAC1_PROCESSING_UNIT):
2904     case PTYPE(UAC_VERSION_2, UAC2_PROCESSING_UNIT_V2):
2905     case PTYPE(UAC_VERSION_3, UAC3_PROCESSING_UNIT):
2906         return parse_audio_processing_unit(state, unitid, p1);
2907     case PTYPE(UAC_VERSION_1, UAC1_EXTENSION_UNIT):
2908     case PTYPE(UAC_VERSION_2, UAC2_EXTENSION_UNIT_V2):
2909     case PTYPE(UAC_VERSION_3, UAC3_EXTENSION_UNIT):
2910         return parse_audio_extension_unit(state, unitid, p1);
2911     case PTYPE(UAC_VERSION_2, UAC2_EFFECT_UNIT):
2912     case PTYPE(UAC_VERSION_3, UAC3_EFFECT_UNIT):
2913         return 0; /* FIXME - effect units not implemented yet */
2914     default:
2915         usb_audio_err(state->chip,
2916                   "unit %u: unexpected type 0x%02x\n",
2917                   unitid, p1[2]);
2918         return -EINVAL;
2919     }
2920 }
2921
2922 static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2923 {
2924     /* kill pending URBs */
2925     snd_usb_mixer_disconnect(mixer);
2926
2927     kfree(mixer->id_elems);
2928     if (mixer->urb) {
2929         kfree(mixer->urb->transfer_buffer);
2930         usb_free_urb(mixer->urb);
2931     }
2932     usb_free_urb(mixer->rc_urb);
2933     kfree(mixer->rc_setup_packet);
2934     kfree(mixer);
2935 }
2936
2937 static int snd_usb_mixer_dev_free(struct snd_device *device)
2938 {
2939     struct usb_mixer_interface *mixer = device->device_data;
2940     snd_usb_mixer_free(mixer);
2941     return 0;
2942 }
2943
2944 /* UAC3 predefined channels configuration */
2945 struct uac3_badd_profile {
2946     int subclass;
2947     const char *name;
2948     int c_chmask;   /* capture channels mask */
2949     int p_chmask;   /* playback channels mask */
2950     int st_chmask;  /* side tone mixing channel mask */
2951 };
2952
2953 static const struct uac3_badd_profile uac3_badd_profiles[] = {
2954     {
2955         /*
2956          * BAIF, BAOF or combination of both
2957          * IN: Mono or Stereo cfg, Mono alt possible
2958          * OUT: Mono or Stereo cfg, Mono alt possible
2959          */
2960         .subclass = UAC3_FUNCTION_SUBCLASS_GENERIC_IO,
2961         .name = "GENERIC IO",
2962         .c_chmask = -1,     /* dynamic channels */
2963         .p_chmask = -1,     /* dynamic channels */
2964     },
2965     {
2966         /* BAOF; Stereo only cfg, Mono alt possible */
2967         .subclass = UAC3_FUNCTION_SUBCLASS_HEADPHONE,
2968         .name = "HEADPHONE",
2969         .p_chmask = 3,
2970     },
2971     {
2972         /* BAOF; Mono or Stereo cfg, Mono alt possible */
2973         .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKER,
2974         .name = "SPEAKER",
2975         .p_chmask = -1,     /* dynamic channels */
2976     },
2977     {
2978         /* BAIF; Mono or Stereo cfg, Mono alt possible */
2979         .subclass = UAC3_FUNCTION_SUBCLASS_MICROPHONE,
2980         .name = "MICROPHONE",
2981         .c_chmask = -1,     /* dynamic channels */
2982     },
2983     {
2984         /*
2985          * BAIOF topology
2986          * IN: Mono only
2987          * OUT: Mono or Stereo cfg, Mono alt possible
2988          */
2989         .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET,
2990         .name = "HEADSET",
2991         .c_chmask = 1,
2992         .p_chmask = -1,     /* dynamic channels */
2993         .st_chmask = 1,
2994     },
2995     {
2996         /* BAIOF; IN: Mono only; OUT: Stereo only, Mono alt possible */
2997         .subclass = UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER,
2998         .name = "HEADSET ADAPTER",
2999         .c_chmask = 1,
3000         .p_chmask = 3,
3001         .st_chmask = 1,
3002     },
3003     {
3004         /* BAIF + BAOF; IN: Mono only; OUT: Mono only */
3005         .subclass = UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE,
3006         .name = "SPEAKERPHONE",
3007         .c_chmask = 1,
3008         .p_chmask = 1,
3009     },
3010     { 0 } /* terminator */
3011 };
3012
3013 static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer,
3014                           const struct uac3_badd_profile *f,
3015                           int c_chmask, int p_chmask)
3016 {
3017     /*
3018      * If both playback/capture channels are dynamic, make sure
3019      * at least one channel is present
3020      */
3021     if (f->c_chmask < 0 && f->p_chmask < 0) {
3022         if (!c_chmask && !p_chmask) {
3023             usb_audio_warn(mixer->chip, "BAAD %s: no channels?",
3024                        f->name);
3025             return false;
3026         }
3027         return true;
3028     }
3029
3030     if ((f->c_chmask < 0 && !c_chmask) ||
3031         (f->c_chmask >= 0 && f->c_chmask != c_chmask)) {
3032         usb_audio_warn(mixer->chip, "BAAD %s c_chmask mismatch",
3033                    f->name);
3034         return false;
3035     }
3036     if ((f->p_chmask < 0 && !p_chmask) ||
3037         (f->p_chmask >= 0 && f->p_chmask != p_chmask)) {
3038         usb_audio_warn(mixer->chip, "BAAD %s p_chmask mismatch",
3039                    f->name);
3040         return false;
3041     }
3042     return true;
3043 }
3044
3045 /*
3046  * create mixer controls for UAC3 BADD profiles
3047  *
3048  * UAC3 BADD device doesn't contain CS descriptors thus we will guess everything
3049  *
3050  * BADD device may contain Mixer Unit, which doesn't have any controls, skip it
3051  */
3052 static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer,
3053                        int ctrlif)
3054 {
3055     struct usb_device *dev = mixer->chip->dev;
3056     struct usb_interface_assoc_descriptor *assoc;
3057     int badd_profile = mixer->chip->badd_profile;
3058     const struct uac3_badd_profile *f;
3059     const struct usbmix_ctl_map *map;
3060     int p_chmask = 0, c_chmask = 0, st_chmask = 0;
3061     int i;
3062
3063     assoc = usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
3064
3065     /* Detect BADD capture/playback channels from AS EP descriptors */
3066     for (i = 0; i < assoc->bInterfaceCount; i++) {
3067         int intf = assoc->bFirstInterface + i;
3068
3069         struct usb_interface *iface;
3070         struct usb_host_interface *alts;
3071         struct usb_interface_descriptor *altsd;
3072         unsigned int maxpacksize;
3073         char dir_in;
3074         int chmask, num;
3075
3076         if (intf == ctrlif)
3077             continue;
3078
3079         iface = usb_ifnum_to_if(dev, intf);
3080         if (!iface)
3081             continue;
3082
3083         num = iface->num_altsetting;
3084
3085         if (num < 2)
3086             return -EINVAL;
3087
3088         /*
3089          * The number of Channels in an AudioStreaming interface
3090          * and the audio sample bit resolution (16 bits or 24
3091          * bits) can be derived from the wMaxPacketSize field in
3092          * the Standard AS Audio Data Endpoint descriptor in
3093          * Alternate Setting 1
3094          */
3095         alts = &iface->altsetting[1];
3096         altsd = get_iface_desc(alts);
3097
3098         if (altsd->bNumEndpoints < 1)
3099             return -EINVAL;
3100
3101         /* check direction */
3102         dir_in = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN);
3103         maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
3104
3105         switch (maxpacksize) {
3106         default:
3107             usb_audio_err(mixer->chip,
3108                 "incorrect wMaxPacketSize 0x%x for BADD profile\n",
3109                 maxpacksize);
3110             return -EINVAL;
3111         case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16:
3112         case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16:
3113         case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24:
3114         case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24:
3115             chmask = 1;
3116             break;
3117         case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16:
3118         case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16:
3119         case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24:
3120         case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24:
3121             chmask = 3;
3122             break;
3123         }
3124
3125         if (dir_in)
3126             c_chmask = chmask;
3127         else
3128             p_chmask = chmask;
3129     }
3130
3131     usb_audio_dbg(mixer->chip,
3132         "UAC3 BADD profile 0x%x: detected c_chmask=%d p_chmask=%d\n",
3133         badd_profile, c_chmask, p_chmask);
3134
3135     /* check the mapping table */
3136     for (map = uac3_badd_usbmix_ctl_maps; map->id; map++) {
3137         if (map->id == badd_profile)
3138             break;
3139     }
3140
3141     if (!map->id)
3142         return -EINVAL;
3143
3144     for (f = uac3_badd_profiles; f->name; f++) {
3145         if (badd_profile == f->subclass)
3146             break;
3147     }
3148     if (!f->name)
3149         return -EINVAL;
3150     if (!uac3_badd_func_has_valid_channels(mixer, f, c_chmask, p_chmask))
3151         return -EINVAL;
3152     st_chmask = f->st_chmask;
3153
3154     /* Playback */
3155     if (p_chmask) {
3156         /* Master channel, always writable */
3157         build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3158                        UAC3_BADD_FU_ID2, map->map);
3159         /* Mono/Stereo volume channels, always writable */
3160         build_feature_ctl_badd(mixer, p_chmask, UAC_FU_VOLUME,
3161                        UAC3_BADD_FU_ID2, map->map);
3162     }
3163
3164     /* Capture */
3165     if (c_chmask) {
3166         /* Master channel, always writable */
3167         build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3168                        UAC3_BADD_FU_ID5, map->map);
3169         /* Mono/Stereo volume channels, always writable */
3170         build_feature_ctl_badd(mixer, c_chmask, UAC_FU_VOLUME,
3171                        UAC3_BADD_FU_ID5, map->map);
3172     }
3173
3174     /* Side tone-mixing */
3175     if (st_chmask) {
3176         /* Master channel, always writable */
3177         build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3178                        UAC3_BADD_FU_ID7, map->map);
3179         /* Mono volume channel, always writable */
3180         build_feature_ctl_badd(mixer, 1, UAC_FU_VOLUME,
3181                        UAC3_BADD_FU_ID7, map->map);
3182     }
3183
3184     /* Insertion Control */
3185     if (f->subclass == UAC3_FUNCTION_SUBCLASS_HEADSET_ADAPTER) {
3186         struct usb_audio_term iterm, oterm;
3187
3188         /* Input Term - Insertion control */
3189         memset(&iterm, 0, sizeof(iterm));
3190         iterm.id = UAC3_BADD_IT_ID4;
3191         iterm.type = UAC_BIDIR_TERMINAL_HEADSET;
3192         build_connector_control(mixer, map->map, &iterm, true);
3193
3194         /* Output Term - Insertion control */
3195         memset(&oterm, 0, sizeof(oterm));
3196         oterm.id = UAC3_BADD_OT_ID3;
3197         oterm.type = UAC_BIDIR_TERMINAL_HEADSET;
3198         build_connector_control(mixer, map->map, &oterm, false);
3199     }
3200
3201     return 0;
3202 }
3203
3204 /*
3205  * create mixer controls
3206  *
3207  * walk through all UAC_OUTPUT_TERMINAL descriptors to search for mixers
3208  */
3209 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
3210 {
3211     struct mixer_build state;
3212     int err;
3213     const struct usbmix_ctl_map *map;
3214     void *p;
3215
3216     memset(&state, 0, sizeof(state));
3217     state.chip = mixer->chip;
3218     state.mixer = mixer;
3219     state.buffer = mixer->hostif->extra;
3220     state.buflen = mixer->hostif->extralen;
3221
3222     /* check the mapping table */
3223     for (map = usbmix_ctl_maps; map->id; map++) {
3224         if (map->id == state.chip->usb_id) {
3225             state.map = map->map;
3226             state.selector_map = map->selector_map;
3227             mixer->connector_map = map->connector_map;
3228             break;
3229         }
3230     }
3231
3232     p = NULL;
3233     while ((p = snd_usb_find_csint_desc(mixer->hostif->extra,
3234                         mixer->hostif->extralen,
3235                         p, UAC_OUTPUT_TERMINAL)) != NULL) {
3236         if (!snd_usb_validate_audio_desc(p, mixer->protocol))
3237             continue; /* skip invalid descriptor */
3238
3239         if (mixer->protocol == UAC_VERSION_1) {
3240             struct uac1_output_terminal_descriptor *desc = p;
3241
3242             /* mark terminal ID as visited */
3243             set_bit(desc->bTerminalID, state.unitbitmap);
3244             state.oterm.id = desc->bTerminalID;
3245             state.oterm.type = le16_to_cpu(desc->wTerminalType);
3246             state.oterm.name = desc->iTerminal;
3247             err = parse_audio_unit(&state, desc->bSourceID);
3248             if (err < 0 && err != -EINVAL)
3249                 return err;
3250         } else if (mixer->protocol == UAC_VERSION_2) {
3251             struct uac2_output_terminal_descriptor *desc = p;
3252
3253             /* mark terminal ID as visited */
3254             set_bit(desc->bTerminalID, state.unitbitmap);
3255             state.oterm.id = desc->bTerminalID;
3256             state.oterm.type = le16_to_cpu(desc->wTerminalType);
3257             state.oterm.name = desc->iTerminal;
3258             err = parse_audio_unit(&state, desc->bSourceID);
3259             if (err < 0 && err != -EINVAL)
3260                 return err;
3261
3262             /*
3263              * For UAC2, use the same approach to also add the
3264              * clock selectors
3265              */
3266             err = parse_audio_unit(&state, desc->bCSourceID);
3267             if (err < 0 && err != -EINVAL)
3268                 return err;
3269
3270             if ((state.oterm.type & 0xff00) != 0x0100 &&
3271                 uac_v2v3_control_is_readable(le16_to_cpu(desc->bmControls),
3272                              UAC2_TE_CONNECTOR)) {
3273                 build_connector_control(state.mixer, state.map,
3274                             &state.oterm, false);
3275             }
3276         } else {  /* UAC_VERSION_3 */
3277             struct uac3_output_terminal_descriptor *desc = p;
3278
3279             /* mark terminal ID as visited */
3280             set_bit(desc->bTerminalID, state.unitbitmap);
3281             state.oterm.id = desc->bTerminalID;
3282             state.oterm.type = le16_to_cpu(desc->wTerminalType);
3283             state.oterm.name = le16_to_cpu(desc->wTerminalDescrStr);
3284             err = parse_audio_unit(&state, desc->bSourceID);
3285             if (err < 0 && err != -EINVAL)
3286                 return err;
3287
3288             /*
3289              * For UAC3, use the same approach to also add the
3290              * clock selectors
3291              */
3292             err = parse_audio_unit(&state, desc->bCSourceID);
3293             if (err < 0 && err != -EINVAL)
3294                 return err;
3295
3296             if ((state.oterm.type & 0xff00) != 0x0100 &&
3297                 uac_v2v3_control_is_readable(le32_to_cpu(desc->bmControls),
3298                              UAC3_TE_INSERTION)) {
3299                 build_connector_control(state.mixer, state.map,
3300                             &state.oterm, false);
3301             }
3302         }
3303     }
3304
3305     return 0;
3306 }
3307
3308 static int delegate_notify(struct usb_mixer_interface *mixer, int unitid,
3309                u8 *control, u8 *channel)
3310 {
3311     const struct usbmix_connector_map *map = mixer->connector_map;
3312
3313     if (!map)
3314         return unitid;
3315
3316     for (; map->id; map++) {
3317         if (map->id == unitid) {
3318             if (control && map->control)
3319                 *control = map->control;
3320             if (channel && map->channel)
3321                 *channel = map->channel;
3322             return map->delegated_id;
3323         }
3324     }
3325     return unitid;
3326 }
3327
3328 void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
3329 {
3330     struct usb_mixer_elem_list *list;
3331
3332     unitid = delegate_notify(mixer, unitid, NULL, NULL);
3333
3334     for_each_mixer_elem(list, mixer, unitid) {
3335         struct usb_mixer_elem_info *info;
3336
3337         if (!list->is_std_info)
3338             continue;
3339         info = mixer_elem_list_to_info(list);
3340         /* invalidate cache, so the value is read from the device */
3341         info->cached = 0;
3342         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3343                    &list->kctl->id);
3344     }
3345 }
3346
3347 static void snd_usb_mixer_dump_cval(struct snd_info_buffer *buffer,
3348                     struct usb_mixer_elem_list *list)
3349 {
3350     struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3351     static const char * const val_types[] = {
3352         [USB_MIXER_BOOLEAN] = "BOOLEAN",
3353         [USB_MIXER_INV_BOOLEAN] = "INV_BOOLEAN",
3354         [USB_MIXER_S8] = "S8",
3355         [USB_MIXER_U8] = "U8",
3356         [USB_MIXER_S16] = "S16",
3357         [USB_MIXER_U16] = "U16",
3358         [USB_MIXER_S32] = "S32",
3359         [USB_MIXER_U32] = "U32",
3360         [USB_MIXER_BESPOKEN] = "BESPOKEN",
3361     };
3362     snd_iprintf(buffer, "    Info: id=%i, control=%i, cmask=0x%x, "
3363                 "channels=%i, type=\"%s\"\n", cval->head.id,
3364                 cval->control, cval->cmask, cval->channels,
3365                 val_types[cval->val_type]);
3366     snd_iprintf(buffer, "    Volume: min=%i, max=%i, dBmin=%i, dBmax=%i\n",
3367                 cval->min, cval->max, cval->dBmin, cval->dBmax);
3368 }
3369
3370 static void snd_usb_mixer_proc_read(struct snd_info_entry *entry,
3371                     struct snd_info_buffer *buffer)
3372 {
3373     struct snd_usb_audio *chip = entry->private_data;
3374     struct usb_mixer_interface *mixer;
3375     struct usb_mixer_elem_list *list;
3376     int unitid;
3377
3378     list_for_each_entry(mixer, &chip->mixer_list, list) {
3379         snd_iprintf(buffer,
3380             "USB Mixer: usb_id=0x%08x, ctrlif=%i, ctlerr=%i\n",
3381                 chip->usb_id, mixer_ctrl_intf(mixer),
3382                 mixer->ignore_ctl_error);
3383         snd_iprintf(buffer, "Card: %s\n", chip->card->longname);
3384         for (unitid = 0; unitid < MAX_ID_ELEMS; unitid++) {
3385             for_each_mixer_elem(list, mixer, unitid) {
3386                 snd_iprintf(buffer, "  Unit: %i\n", list->id);
3387                 if (list->kctl)
3388                     snd_iprintf(buffer,
3389                             "    Control: name=\"%s\", index=%i\n",
3390                             list->kctl->id.name,
3391                             list->kctl->id.index);
3392                 if (list->dump)
3393                     list->dump(buffer, list);
3394             }
3395         }
3396     }
3397 }
3398
3399 static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
3400                        int attribute, int value, int index)
3401 {
3402     struct usb_mixer_elem_list *list;
3403     __u8 unitid = (index >> 8) & 0xff;
3404     __u8 control = (value >> 8) & 0xff;
3405     __u8 channel = value & 0xff;
3406     unsigned int count = 0;
3407
3408     if (channel >= MAX_CHANNELS) {
3409         usb_audio_dbg(mixer->chip,
3410             "%s(): bogus channel number %d\n",
3411             __func__, channel);
3412         return;
3413     }
3414
3415     unitid = delegate_notify(mixer, unitid, &control, &channel);
3416
3417     for_each_mixer_elem(list, mixer, unitid)
3418         count++;
3419
3420     if (count == 0)
3421         return;
3422
3423     for_each_mixer_elem(list, mixer, unitid) {
3424         struct usb_mixer_elem_info *info;
3425
3426         if (!list->kctl)
3427             continue;
3428         if (!list->is_std_info)
3429             continue;
3430
3431         info = mixer_elem_list_to_info(list);
3432         if (count > 1 && info->control != control)
3433             continue;
3434
3435         switch (attribute) {
3436         case UAC2_CS_CUR:
3437             /* invalidate cache, so the value is read from the device */
3438             if (channel)
3439                 info->cached &= ~(1 << channel);
3440             else /* master channel */
3441                 info->cached = 0;
3442
3443             snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3444                        &info->head.kctl->id);
3445             break;
3446
3447         case UAC2_CS_RANGE:
3448             /* TODO */
3449             break;
3450
3451         case UAC2_CS_MEM:
3452             /* TODO */
3453             break;
3454
3455         default:
3456             usb_audio_dbg(mixer->chip,
3457                 "unknown attribute %d in interrupt\n",
3458                 attribute);
3459             break;
3460         } /* switch */
3461     }
3462 }
3463
3464 static void snd_usb_mixer_interrupt(struct urb *urb)
3465 {
3466     struct usb_mixer_interface *mixer = urb->context;
3467     int len = urb->actual_length;
3468     int ustatus = urb->status;
3469
3470     if (ustatus != 0)
3471         goto requeue;
3472
3473     if (mixer->protocol == UAC_VERSION_1) {
3474         struct uac1_status_word *status;
3475
3476         for (status = urb->transfer_buffer;
3477              len >= sizeof(*status);
3478              len -= sizeof(*status), status++) {
3479             dev_dbg(&urb->dev->dev, "status interrupt: %02x %02x\n",
3480                         status->bStatusType,
3481                         status->bOriginator);
3482
3483             /* ignore any notifications not from the control interface */
3484             if ((status->bStatusType & UAC1_STATUS_TYPE_ORIG_MASK) !=
3485                 UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF)
3486                 continue;
3487
3488             if (status->bStatusType & UAC1_STATUS_TYPE_MEM_CHANGED)
3489                 snd_usb_mixer_rc_memory_change(mixer, status->bOriginator);
3490             else
3491                 snd_usb_mixer_notify_id(mixer, status->bOriginator);
3492         }
3493     } else { /* UAC_VERSION_2 */
3494         struct uac2_interrupt_data_msg *msg;
3495
3496         for (msg = urb->transfer_buffer;
3497              len >= sizeof(*msg);
3498              len -= sizeof(*msg), msg++) {
3499             /* drop vendor specific and endpoint requests */
3500             if ((msg->bInfo & UAC2_INTERRUPT_DATA_MSG_VENDOR) ||
3501                 (msg->bInfo & UAC2_INTERRUPT_DATA_MSG_EP))
3502                 continue;
3503
3504             snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute,
3505                            le16_to_cpu(msg->wValue),
3506                            le16_to_cpu(msg->wIndex));
3507         }
3508     }
3509
3510 requeue:
3511     if (ustatus != -ENOENT &&
3512         ustatus != -ECONNRESET &&
3513         ustatus != -ESHUTDOWN) {
3514         urb->dev = mixer->chip->dev;
3515         usb_submit_urb(urb, GFP_ATOMIC);
3516     }
3517 }
3518
3519 /* create the handler for the optional status interrupt endpoint */
3520 static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
3521 {
3522     struct usb_endpoint_descriptor *ep;
3523     void *transfer_buffer;
3524     int buffer_length;
3525     unsigned int epnum;
3526
3527     /* we need one interrupt input endpoint */
3528     if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1)
3529         return 0;
3530     ep = get_endpoint(mixer->hostif, 0);
3531     if (!usb_endpoint_dir_in(ep) || !usb_endpoint_xfer_int(ep))
3532         return 0;
3533
3534     epnum = usb_endpoint_num(ep);
3535     buffer_length = le16_to_cpu(ep->wMaxPacketSize);
3536     transfer_buffer = kmalloc(buffer_length, GFP_KERNEL);
3537     if (!transfer_buffer)
3538         return -ENOMEM;
3539     mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3540     if (!mixer->urb) {
3541         kfree(transfer_buffer);
3542         return -ENOMEM;
3543     }
3544     usb_fill_int_urb(mixer->urb, mixer->chip->dev,
3545              usb_rcvintpipe(mixer->chip->dev, epnum),
3546              transfer_buffer, buffer_length,
3547              snd_usb_mixer_interrupt, mixer, ep->bInterval);
3548     usb_submit_urb(mixer->urb, GFP_KERNEL);
3549     return 0;
3550 }
3551
3552 int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif)
3553 {
3554     static const struct snd_device_ops dev_ops = {
3555         .dev_free = snd_usb_mixer_dev_free
3556     };
3557     struct usb_mixer_interface *mixer;
3558     int err;
3559
3560     strcpy(chip->card->mixername, "USB Mixer");
3561
3562     mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
3563     if (!mixer)
3564         return -ENOMEM;
3565     mixer->chip = chip;
3566     mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR);
3567     mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
3568                   GFP_KERNEL);
3569     if (!mixer->id_elems) {
3570         kfree(mixer);
3571         return -ENOMEM;
3572     }
3573
3574     mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
3575     switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) {
3576     case UAC_VERSION_1:
3577     default:
3578         mixer->protocol = UAC_VERSION_1;
3579         break;
3580     case UAC_VERSION_2:
3581         mixer->protocol = UAC_VERSION_2;
3582         break;
3583     case UAC_VERSION_3:
3584         mixer->protocol = UAC_VERSION_3;
3585         break;
3586     }
3587
3588     if (mixer->protocol == UAC_VERSION_3 &&
3589             chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) {
3590         err = snd_usb_mixer_controls_badd(mixer, ctrlif);
3591         if (err < 0)
3592             goto _error;
3593     } else {
3594         err = snd_usb_mixer_controls(mixer);
3595         if (err < 0)
3596             goto _error;
3597     }
3598
3599     err = snd_usb_mixer_status_create(mixer);
3600     if (err < 0)
3601         goto _error;
3602
3603     err = snd_usb_mixer_apply_create_quirk(mixer);
3604     if (err < 0)
3605         goto _error;
3606
3607     err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops);
3608     if (err < 0)
3609         goto _error;
3610
3611     if (list_empty(&chip->mixer_list))
3612         snd_card_ro_proc_new(chip->card, "usbmixer", chip,
3613                      snd_usb_mixer_proc_read);
3614
3615     list_add(&mixer->list, &chip->mixer_list);
3616     return 0;
3617
3618 _error:
3619     snd_usb_mixer_free(mixer);
3620     return err;
3621 }
3622
3623 void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
3624 {
3625     if (mixer->disconnected)
3626         return;
3627     if (mixer->urb)
3628         usb_kill_urb(mixer->urb);
3629     if (mixer->rc_urb)
3630         usb_kill_urb(mixer->rc_urb);
3631     if (mixer->private_free)
3632         mixer->private_free(mixer);
3633     mixer->disconnected = true;
3634 }
3635
3636 /* stop any bus activity of a mixer */
3637 static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
3638 {
3639     usb_kill_urb(mixer->urb);
3640     usb_kill_urb(mixer->rc_urb);
3641 }
3642
3643 static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
3644 {
3645     int err;
3646
3647     if (mixer->urb) {
3648         err = usb_submit_urb(mixer->urb, GFP_NOIO);
3649         if (err < 0)
3650             return err;
3651     }
3652
3653     return 0;
3654 }
3655
3656 int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
3657 {
3658     snd_usb_mixer_inactivate(mixer);
3659     if (mixer->private_suspend)
3660         mixer->private_suspend(mixer);
3661     return 0;
3662 }
3663
3664 static int restore_mixer_value(struct usb_mixer_elem_list *list)
3665 {
3666     struct usb_mixer_elem_info *cval = mixer_elem_list_to_info(list);
3667     int c, err, idx;
3668
3669     if (cval->val_type == USB_MIXER_BESPOKEN)
3670         return 0;
3671
3672     if (cval->cmask) {
3673         idx = 0;
3674         for (c = 0; c < MAX_CHANNELS; c++) {
3675             if (!(cval->cmask & (1 << c)))
3676                 continue;
3677             if (cval->cached & (1 << (c + 1))) {
3678                 err = snd_usb_set_cur_mix_value(cval, c + 1, idx,
3679                             cval->cache_val[idx]);
3680                 if (err < 0)
3681                     break;
3682             }
3683             idx++;
3684         }
3685     } else {
3686         /* master */
3687         if (cval->cached)
3688             snd_usb_set_cur_mix_value(cval, 0, 0, *cval->cache_val);
3689     }
3690
3691     return 0;
3692 }
3693
3694 int snd_usb_mixer_resume(struct usb_mixer_interface *mixer)
3695 {
3696     struct usb_mixer_elem_list *list;
3697     int id, err;
3698
3699     /* restore cached mixer values */
3700     for (id = 0; id < MAX_ID_ELEMS; id++) {
3701         for_each_mixer_elem(list, mixer, id) {
3702             if (list->resume) {
3703                 err = list->resume(list);
3704                 if (err < 0)
3705                     return err;
3706             }
3707         }
3708     }
3709
3710     snd_usb_mixer_resume_quirk(mixer);
3711
3712     return snd_usb_mixer_activate(mixer);
3713 }
3714
3715 void snd_usb_mixer_elem_init_std(struct usb_mixer_elem_list *list,
3716                  struct usb_mixer_interface *mixer,
3717                  int unitid)
3718 {
3719     list->mixer = mixer;
3720     list->id = unitid;
3721     list->dump = snd_usb_mixer_dump_cval;
3722     list->resume = restore_mixer_value;
3723 }