sound/usb/usbmixer.c

   1 /*
   2  *   (Tentative) USB Audio Driver for ALSA
   3  *
   4  *   Mixer control part
   5  *
   6  *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
   7  *
   8  *   Many codes borrowed from audio.c by
   9  *          Alan Cox (alan@lxorguk.ukuu.org.uk)
  10  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  11  *
  12  *
  13  *   This program is free software; you can redistribute it and/or modify
  14  *   it under the terms of the GNU General Public License as published by
  15  *   the Free Software Foundation; either version 2 of the License, or
  16  *   (at your option) any later version.
  17  *
  18  *   This program is distributed in the hope that it will be useful,
  19  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *   GNU General Public License for more details.
  22  *
  23  *   You should have received a copy of the GNU General Public License
  24  *   along with this program; if not, write to the Free Software
  25  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26  *
  27  */
  28
  29 #include <sound/driver.h>
  30 #include <linux/bitops.h>
  31 #include <linux/init.h>
  32 #include <linux/list.h>
  33 #include <linux/slab.h>
  34 #include <linux/string.h>
  35 #include <linux/usb.h>
  36 #include <sound/core.h>
  37 #include <sound/control.h>
  38
  39 #include "usbaudio.h"
  40
  41
  42 /*
  43  */
  44
  45 /* ignore error from controls - for debugging */
  46 /* #define IGNORE_CTL_ERROR */
  47
  48 typedef struct usb_mixer_build mixer_build_t;
  49 typedef struct usb_audio_term usb_audio_term_t;
  50 typedef struct usb_mixer_elem_info usb_mixer_elem_info_t;
  51
  52
  53 struct usb_mixer_interface {
  54         snd_usb_audio_t *chip;
  55         unsigned int ctrlif;
  56         struct list_head list;
  57         unsigned int ignore_ctl_error;
  58 };
  59
  60
  61 struct usb_audio_term {
  62         int id;
  63         int type;
  64         int channels;
  65         unsigned int chconfig;
  66         int name;
  67 };
  68
  69 struct usbmix_name_map;
  70
  71 struct usb_mixer_build {
  72         snd_usb_audio_t *chip;
  73         struct usb_mixer_interface *mixer;
  74         unsigned char *buffer;
  75         unsigned int buflen;
  76         unsigned short vendor;
  77         unsigned short product;
  78         DECLARE_BITMAP(unitbitmap, 256);
  79         usb_audio_term_t oterm;
  80         const struct usbmix_name_map *map;
  81         const struct usbmix_selector_map *selector_map;
  82 };
  83
  84 struct usb_mixer_elem_info {
  85         struct usb_mixer_interface *mixer;
  86         unsigned int id;
  87         unsigned int control;   /* CS or ICN (high byte) */
  88         unsigned int cmask; /* channel mask bitmap: 0 = master */
  89         int channels;
  90         int val_type;
  91         int min, max, res;
  92         unsigned int initialized: 1;
  93 };
  94
  95
  96 enum {
  97         USB_FEATURE_NONE = 0,
  98         USB_FEATURE_MUTE = 1,
  99         USB_FEATURE_VOLUME,
 100         USB_FEATURE_BASS,
 101         USB_FEATURE_MID,
 102         USB_FEATURE_TREBLE,
 103         USB_FEATURE_GEQ,
 104         USB_FEATURE_AGC,
 105         USB_FEATURE_DELAY,
 106         USB_FEATURE_BASSBOOST,
 107         USB_FEATURE_LOUDNESS
 108 };
 109
 110 enum {
 111         USB_MIXER_BOOLEAN,
 112         USB_MIXER_INV_BOOLEAN,
 113         USB_MIXER_S8,
 114         USB_MIXER_U8,
 115         USB_MIXER_S16,
 116         USB_MIXER_U16,
 117 };
 118
 119 enum {
 120         USB_PROC_UPDOWN = 1,
 121         USB_PROC_UPDOWN_SWITCH = 1,
 122         USB_PROC_UPDOWN_MODE_SEL = 2,
 123
 124         USB_PROC_PROLOGIC = 2,
 125         USB_PROC_PROLOGIC_SWITCH = 1,
 126         USB_PROC_PROLOGIC_MODE_SEL = 2,
 127
 128         USB_PROC_3DENH = 3,
 129         USB_PROC_3DENH_SWITCH = 1,
 130         USB_PROC_3DENH_SPACE = 2,
 131
 132         USB_PROC_REVERB = 4,
 133         USB_PROC_REVERB_SWITCH = 1,
 134         USB_PROC_REVERB_LEVEL = 2,
 135         USB_PROC_REVERB_TIME = 3,
 136         USB_PROC_REVERB_DELAY = 4,
 137
 138         USB_PROC_CHORUS = 5,
 139         USB_PROC_CHORUS_SWITCH = 1,
 140         USB_PROC_CHORUS_LEVEL = 2,
 141         USB_PROC_CHORUS_RATE = 3,
 142         USB_PROC_CHORUS_DEPTH = 4,
 143
 144         USB_PROC_DCR = 6,
 145         USB_PROC_DCR_SWITCH = 1,
 146         USB_PROC_DCR_RATIO = 2,
 147         USB_PROC_DCR_MAX_AMP = 3,
 148         USB_PROC_DCR_THRESHOLD = 4,
 149         USB_PROC_DCR_ATTACK = 5,
 150         USB_PROC_DCR_RELEASE = 6,
 151 };
 152
 153 #define MAX_CHANNELS    10      /* max logical channels */
 154
 155
 156 /*
 157  * manual mapping of mixer names
 158  * if the mixer topology is too complicated and the parsed names are
 159  * ambiguous, add the entries in usbmixer_maps.c.
 160  */
 161 #include "usbmixer_maps.c"
 162
 163 /* get the mapped name if the unit matches */
 164 static int check_mapped_name(mixer_build_t *state, int unitid, int control, char *buf, int buflen)
 165 {
 166         const struct usbmix_name_map *p;
 167
 168         if (! state->map)
 169                 return 0;
 170
 171         for (p = state->map; p->id; p++) {
 172                 if (p->id == unitid && p->name &&
 173                     (! control || ! p->control || control == p->control)) {
 174                         buflen--;
 175                         return strlcpy(buf, p->name, buflen);
 176                 }
 177         }
 178         return 0;
 179 }
 180
 181 /* check whether the control should be ignored */
 182 static int check_ignored_ctl(mixer_build_t *state, int unitid, int control)
 183 {
 184         const struct usbmix_name_map *p;
 185
 186         if (! state->map)
 187                 return 0;
 188         for (p = state->map; p->id; p++) {
 189                 if (p->id == unitid && ! p->name &&
 190                     (! control || ! p->control || control == p->control)) {
 191                         // printk("ignored control %d:%d\n", unitid, control);
 192                         return 1;
 193                 }
 194         }
 195         return 0;
 196 }
 197
 198 /* get the mapped selector source name */
 199 static int check_mapped_selector_name(mixer_build_t *state, int unitid,
 200                                       int index, char *buf, int buflen)
 201 {
 202         const struct usbmix_selector_map *p;
 203
 204         if (! state->selector_map)
 205                 return 0;
 206         for (p = state->selector_map; p->id; p++) {
 207                 if (p->id == unitid && index < p->count)
 208                         return strlcpy(buf, p->names[index], buflen);
 209         }
 210         return 0;
 211 }
 212
 213 /*
 214  * find an audio control unit with the given unit id
 215  */
 216 static void *find_audio_control_unit(mixer_build_t *state, unsigned char unit)
 217 {
 218         unsigned char *p;
 219
 220         p = NULL;
 221         while ((p = snd_usb_find_desc(state->buffer, state->buflen, p,
 222                                       USB_DT_CS_INTERFACE)) != NULL) {
 223                 if (p[0] >= 4 && p[2] >= INPUT_TERMINAL && p[2] <= EXTENSION_UNIT && p[3] == unit)
 224                         return p;
 225         }
 226         return NULL;
 227 }
 228
 229
 230 /*
 231  * copy a string with the given id
 232  */
 233 static int snd_usb_copy_string_desc(mixer_build_t *state, int index, char *buf, int maxlen)
 234 {
 235         int len = usb_string(state->chip->dev, index, buf, maxlen - 1);
 236         buf[len] = 0;
 237         return len;
 238 }
 239
 240 /*
 241  * convert from the byte/word on usb descriptor to the zero-based integer
 242  */
 243 static int convert_signed_value(usb_mixer_elem_info_t *cval, int val)
 244 {
 245         switch (cval->val_type) {
 246         case USB_MIXER_BOOLEAN:
 247                 return !!val;
 248         case USB_MIXER_INV_BOOLEAN:
 249                 return !val;
 250         case USB_MIXER_U8:
 251                 val &= 0xff;
 252                 break;
 253         case USB_MIXER_S8:
 254                 val &= 0xff;
 255                 if (val >= 0x80)
 256                         val -= 0x100;
 257                 break;
 258         case USB_MIXER_U16:
 259                 val &= 0xffff;
 260                 break;
 261         case USB_MIXER_S16:
 262                 val &= 0xffff;
 263                 if (val >= 0x8000)
 264                         val -= 0x10000;
 265                 break;
 266         }
 267         return val;
 268 }
 269
 270 /*
 271  * convert from the zero-based int to the byte/word for usb descriptor
 272  */
 273 static int convert_bytes_value(usb_mixer_elem_info_t *cval, int val)
 274 {
 275         switch (cval->val_type) {
 276         case USB_MIXER_BOOLEAN:
 277                 return !!val;
 278         case USB_MIXER_INV_BOOLEAN:
 279                 return !val;
 280         case USB_MIXER_S8:
 281         case USB_MIXER_U8:
 282                 return val & 0xff;
 283         case USB_MIXER_S16:
 284         case USB_MIXER_U16:
 285                 return val & 0xffff;
 286         }
 287         return 0; /* not reached */
 288 }
 289
 290 static int get_relative_value(usb_mixer_elem_info_t *cval, int val)
 291 {
 292         if (! cval->res)
 293                 cval->res = 1;
 294         if (val < cval->min)
 295                 return 0;
 296         else if (val > cval->max)
 297                 return (cval->max - cval->min) / cval->res;
 298         else
 299                 return (val - cval->min) / cval->res;
 300 }
 301
 302 static int get_abs_value(usb_mixer_elem_info_t *cval, int val)
 303 {
 304         if (val < 0)
 305                 return cval->min;
 306         if (! cval->res)
 307                 cval->res = 1;
 308         val *= cval->res;
 309         val += cval->min;
 310         if (val > cval->max)
 311                 return cval->max;
 312         return val;
 313 }
 314
 315
 316 /*
 317  * retrieve a mixer value
 318  */
 319
 320 static int get_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int *value_ret)
 321 {
 322         unsigned char buf[2];
 323         int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
 324         int timeout = 10;
 325
 326         while (timeout-- > 0) {
 327                 if (snd_usb_ctl_msg(cval->mixer->chip->dev,
 328                                     usb_rcvctrlpipe(cval->mixer->chip->dev, 0),
 329                                     request,
 330                                     USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
 331                                     validx, cval->mixer->ctrlif | (cval->id << 8),
 332                                     buf, val_len, 100) >= 0) {
 333                         *value_ret = convert_signed_value(cval, snd_usb_combine_bytes(buf, val_len));
 334                         return 0;
 335                 }
 336         }
 337         snd_printdd(KERN_ERR "cannot get ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d\n",
 338                     request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type);
 339         return -EINVAL;
 340 }
 341
 342 static int get_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int *value)
 343 {
 344         return get_ctl_value(cval, GET_CUR, validx, value);
 345 }
 346
 347 /* channel = 0: master, 1 = first channel */
 348 inline static int get_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int *value)
 349 {
 350         return get_ctl_value(cval, GET_CUR, (cval->control << 8) | channel, value);
 351 }
 352
 353 /*
 354  * set a mixer value
 355  */
 356
 357 static int set_ctl_value(usb_mixer_elem_info_t *cval, int request, int validx, int value_set)
 358 {
 359         unsigned char buf[2];
 360         int val_len = cval->val_type >= USB_MIXER_S16 ? 2 : 1;
 361         int timeout = 10;
 362
 363         value_set = convert_bytes_value(cval, value_set);
 364         buf[0] = value_set & 0xff;
 365         buf[1] = (value_set >> 8) & 0xff;
 366         while (timeout -- > 0)
 367                 if (snd_usb_ctl_msg(cval->mixer->chip->dev,
 368                                     usb_sndctrlpipe(cval->mixer->chip->dev, 0),
 369                                     request,
 370                                     USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 371                                     validx, cval->mixer->ctrlif | (cval->id << 8),
 372                                     buf, val_len, 100) >= 0)
 373                         return 0;
 374         snd_printdd(KERN_ERR "cannot set ctl value: req = %#x, wValue = %#x, wIndex = %#x, type = %d, data = %#x/%#x\n",
 375                     request, validx, cval->mixer->ctrlif | (cval->id << 8), cval->val_type, buf[0], buf[1]);
 376         return -EINVAL;
 377 }
 378
 379 static int set_cur_ctl_value(usb_mixer_elem_info_t *cval, int validx, int value)
 380 {
 381         return set_ctl_value(cval, SET_CUR, validx, value);
 382 }
 383
 384 inline static int set_cur_mix_value(usb_mixer_elem_info_t *cval, int channel, int value)
 385 {
 386         return set_ctl_value(cval, SET_CUR, (cval->control << 8) | channel, value);
 387 }
 388
 389
 390 /*
 391  * parser routines begin here...
 392  */
 393
 394 static int parse_audio_unit(mixer_build_t *state, int unitid);
 395
 396
 397 /*
 398  * check if the input/output channel routing is enabled on the given bitmap.
 399  * used for mixer unit parser
 400  */
 401 static int check_matrix_bitmap(unsigned char *bmap, int ich, int och, int num_outs)
 402 {
 403         int idx = ich * num_outs + och;
 404         return bmap[idx >> 3] & (0x80 >> (idx & 7));
 405 }
 406
 407
 408 /*
 409  * add an alsa control element
 410  * search and increment the index until an empty slot is found.
 411  *
 412  * if failed, give up and free the control instance.
 413  */
 414
 415 static int add_control_to_empty(mixer_build_t *state, snd_kcontrol_t *kctl)
 416 {
 417         int err;
 418
 419         while (snd_ctl_find_id(state->chip->card, &kctl->id))
 420                 kctl->id.index++;
 421         if ((err = snd_ctl_add(state->chip->card, kctl)) < 0) {
 422                 snd_printd(KERN_ERR "cannot add control (err = %d)\n", err);
 423                 snd_ctl_free_one(kctl);
 424         }
 425         return err;
 426 }
 427
 428
 429 /*
 430  * get a terminal name string
 431  */
 432
 433 static struct iterm_name_combo {
 434         int type;
 435         char *name;
 436 } iterm_names[] = {
 437         { 0x0300, "Output" },
 438         { 0x0301, "Speaker" },
 439         { 0x0302, "Headphone" },
 440         { 0x0303, "HMD Audio" },
 441         { 0x0304, "Desktop Speaker" },
 442         { 0x0305, "Room Speaker" },
 443         { 0x0306, "Com Speaker" },
 444         { 0x0307, "LFE" },
 445         { 0x0600, "External In" },
 446         { 0x0601, "Analog In" },
 447         { 0x0602, "Digital In" },
 448         { 0x0603, "Line" },
 449         { 0x0604, "Legacy In" },
 450         { 0x0605, "IEC958 In" },
 451         { 0x0606, "1394 DA Stream" },
 452         { 0x0607, "1394 DV Stream" },
 453         { 0x0700, "Embedded" },
 454         { 0x0701, "Noise Source" },
 455         { 0x0702, "Equalization Noise" },
 456         { 0x0703, "CD" },
 457         { 0x0704, "DAT" },
 458         { 0x0705, "DCC" },
 459         { 0x0706, "MiniDisk" },
 460         { 0x0707, "Analog Tape" },
 461         { 0x0708, "Phonograph" },
 462         { 0x0709, "VCR Audio" },
 463         { 0x070a, "Video Disk Audio" },
 464         { 0x070b, "DVD Audio" },
 465         { 0x070c, "TV Tuner Audio" },
 466         { 0x070d, "Satellite Rec Audio" },
 467         { 0x070e, "Cable Tuner Audio" },
 468         { 0x070f, "DSS Audio" },
 469         { 0x0710, "Radio Receiver" },
 470         { 0x0711, "Radio Transmitter" },
 471         { 0x0712, "Multi-Track Recorder" },
 472         { 0x0713, "Synthesizer" },
 473         { 0 },
 474 };
 475
 476 static int get_term_name(mixer_build_t *state, usb_audio_term_t *iterm,
 477                          unsigned char *name, int maxlen, int term_only)
 478 {
 479         struct iterm_name_combo *names;
 480
 481         if (iterm->name)
 482                 return snd_usb_copy_string_desc(state, iterm->name, name, maxlen);
 483
 484         /* virtual type - not a real terminal */
 485         if (iterm->type >> 16) {
 486                 if (term_only)
 487                         return 0;
 488                 switch (iterm->type >> 16) {
 489                 case SELECTOR_UNIT:
 490                         strcpy(name, "Selector"); return 8;
 491                 case PROCESSING_UNIT:
 492                         strcpy(name, "Process Unit"); return 12;
 493                 case EXTENSION_UNIT:
 494                         strcpy(name, "Ext Unit"); return 8;
 495                 case MIXER_UNIT:
 496                         strcpy(name, "Mixer"); return 5;
 497                 default:
 498                         return sprintf(name, "Unit %d", iterm->id);
 499                 }
 500         }
 501
 502         switch (iterm->type & 0xff00) {
 503         case 0x0100:
 504                 strcpy(name, "PCM"); return 3;
 505         case 0x0200:
 506                 strcpy(name, "Mic"); return 3;
 507         case 0x0400:
 508                 strcpy(name, "Headset"); return 7;
 509         case 0x0500:
 510                 strcpy(name, "Phone"); return 5;
 511         }
 512
 513         for (names = iterm_names; names->type; names++)
 514                 if (names->type == iterm->type) {
 515                         strcpy(name, names->name);
 516                         return strlen(names->name);
 517                 }
 518         return 0;
 519 }
 520
 521
 522 /*
 523  * parse the source unit recursively until it reaches to a terminal
 524  * or a branched unit.
 525  */
 526 static int check_input_term(mixer_build_t *state, int id, usb_audio_term_t *term)
 527 {
 528         unsigned char *p1;
 529
 530         memset(term, 0, sizeof(*term));
 531         while ((p1 = find_audio_control_unit(state, id)) != NULL) {
 532                 term->id = id;
 533                 switch (p1[2]) {
 534                 case INPUT_TERMINAL:
 535                         term->type = combine_word(p1 + 4);
 536                         term->channels = p1[7];
 537                         term->chconfig = combine_word(p1 + 8);
 538                         term->name = p1[11];
 539                         return 0;
 540                 case FEATURE_UNIT:
 541                         id = p1[4];
 542                         break; /* continue to parse */
 543                 case MIXER_UNIT:
 544                         term->type = p1[2] << 16; /* virtual type */
 545                         term->channels = p1[5 + p1[4]];
 546                         term->chconfig = combine_word(p1 + 6 + p1[4]);
 547                         term->name = p1[p1[0] - 1];
 548                         return 0;
 549                 case SELECTOR_UNIT:
 550                         /* call recursively to retrieve the channel info */
 551                         if (check_input_term(state, p1[5], term) < 0)
 552                                 return -ENODEV;
 553                         term->type = p1[2] << 16; /* virtual type */
 554                         term->id = id;
 555                         term->name = p1[9 + p1[0] - 1];
 556                         return 0;
 557                 case PROCESSING_UNIT:
 558                 case EXTENSION_UNIT:
 559                         if (p1[6] == 1) {
 560                                 id = p1[7];
 561                                 break; /* continue to parse */
 562                         }
 563                         term->type = p1[2] << 16; /* virtual type */
 564                         term->channels = p1[7 + p1[6]];
 565                         term->chconfig = combine_word(p1 + 8 + p1[6]);
 566                         term->name = p1[12 + p1[6] + p1[11 + p1[6]]];
 567                         return 0;
 568                 default:
 569                         return -ENODEV;
 570                 }
 571         }
 572         return -ENODEV;
 573 }
 574
 575
 576 /*
 577  * Feature Unit
 578  */
 579
 580 /* feature unit control information */
 581 struct usb_feature_control_info {
 582         const char *name;
 583         unsigned int type;      /* control type (mute, volume, etc.) */
 584 };
 585
 586 static struct usb_feature_control_info audio_feature_info[] = {
 587         { "Mute",               USB_MIXER_INV_BOOLEAN },
 588         { "Volume",             USB_MIXER_S16 },
 589         { "Tone Control - Bass",        USB_MIXER_S8 },
 590         { "Tone Control - Mid",         USB_MIXER_S8 },
 591         { "Tone Control - Treble",      USB_MIXER_S8 },
 592         { "Graphic Equalizer",          USB_MIXER_S8 }, /* FIXME: not implemeted yet */
 593         { "Auto Gain Control",  USB_MIXER_BOOLEAN },
 594         { "Delay Control",      USB_MIXER_U16 },
 595         { "Bass Boost",         USB_MIXER_BOOLEAN },
 596         { "Loudness",           USB_MIXER_BOOLEAN },
 597 };
 598
 599
 600 /* private_free callback */
 601 static void usb_mixer_elem_free(snd_kcontrol_t *kctl)
 602 {
 603         if (kctl->private_data) {
 604                 kfree(kctl->private_data);
 605                 kctl->private_data = NULL;
 606         }
 607 }
 608
 609
 610 /*
 611  * interface to ALSA control for feature/mixer units
 612  */
 613
 614 /*
 615  * retrieve the minimum and maximum values for the specified control
 616  */
 617 static int get_min_max(usb_mixer_elem_info_t *cval, int default_min)
 618 {
 619         /* for failsafe */
 620         cval->min = default_min;
 621         cval->max = cval->min + 1;
 622         cval->res = 1;
 623
 624         if (cval->val_type == USB_MIXER_BOOLEAN ||
 625             cval->val_type == USB_MIXER_INV_BOOLEAN) {
 626                 cval->initialized = 1;
 627         } else {
 628                 int minchn = 0;
 629                 if (cval->cmask) {
 630                         int i;
 631                         for (i = 0; i < MAX_CHANNELS; i++)
 632                                 if (cval->cmask & (1 << i)) {
 633                                         minchn = i + 1;
 634                                         break;
 635                                 }
 636                 }
 637                 if (get_ctl_value(cval, GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 ||
 638                     get_ctl_value(cval, GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) {
 639                         snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n",
 640                                    cval->id, cval->mixer->ctrlif, cval->control, cval->id);
 641                         return -EINVAL;
 642                 }
 643                 if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) {
 644                         cval->res = 1;
 645                 } else {
 646                         int last_valid_res = cval->res;
 647
 648                         while (cval->res > 1) {
 649                                 if (set_ctl_value(cval, SET_RES, (cval->control << 8) | minchn, cval->res / 2) < 0)
 650                                         break;
 651                                 cval->res /= 2;
 652                         }
 653                         if (get_ctl_value(cval, GET_RES, (cval->control << 8) | minchn, &cval->res) < 0)
 654                                 cval->res = last_valid_res;
 655                 }
 656                 if (cval->res == 0)
 657                         cval->res = 1;
 658                 cval->initialized = 1;
 659         }
 660         return 0;
 661 }
 662
 663
 664 /* get a feature/mixer unit info */
 665 static int mixer_ctl_feature_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
 666 {
 667         usb_mixer_elem_info_t *cval = kcontrol->private_data;
 668
 669         if (cval->val_type == USB_MIXER_BOOLEAN ||
 670             cval->val_type == USB_MIXER_INV_BOOLEAN)
 671                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 672         else
 673                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 674         uinfo->count = cval->channels;
 675         if (cval->val_type == USB_MIXER_BOOLEAN ||
 676             cval->val_type == USB_MIXER_INV_BOOLEAN) {
 677                 uinfo->value.integer.min = 0;
 678                 uinfo->value.integer.max = 1;
 679         } else {
 680                 if (! cval->initialized)
 681                         get_min_max(cval,  0);
 682                 uinfo->value.integer.min = 0;
 683                 uinfo->value.integer.max = (cval->max - cval->min) / cval->res;
 684         }
 685         return 0;
 686 }
 687
 688 /* get the current value from feature/mixer unit */
 689 static int mixer_ctl_feature_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 690 {
 691         usb_mixer_elem_info_t *cval = kcontrol->private_data;
 692         int c, cnt, val, err;
 693
 694         if (cval->cmask) {
 695                 cnt = 0;
 696                 for (c = 0; c < MAX_CHANNELS; c++) {
 697                         if (cval->cmask & (1 << c)) {
 698                                 err = get_cur_mix_value(cval, c + 1, &val);
 699                                 if (err < 0) {
 700                                         if (cval->mixer->ignore_ctl_error) {
 701                                                 ucontrol->value.integer.value[0] = cval->min;
 702                                                 return 0;
 703                                         }
 704                                         snd_printd(KERN_ERR "cannot get current value for control %d ch %d: err = %d\n", cval->control, c + 1, err);
 705                                         return err;
 706                                 }
 707                                 val = get_relative_value(cval, val);
 708                                 ucontrol->value.integer.value[cnt] = val;
 709                                 cnt++;
 710                         }
 711                 }
 712         } else {
 713                 /* master channel */
 714                 err = get_cur_mix_value(cval, 0, &val);
 715                 if (err < 0) {
 716                         if (cval->mixer->ignore_ctl_error) {
 717                                 ucontrol->value.integer.value[0] = cval->min;
 718                                 return 0;
 719                         }
 720                         snd_printd(KERN_ERR "cannot get current value for control %d master ch: err = %d\n", cval->control, err);
 721                         return err;
 722                 }
 723                 val = get_relative_value(cval, val);
 724                 ucontrol->value.integer.value[0] = val;
 725         }
 726         return 0;
 727 }
 728
 729 /* put the current value to feature/mixer unit */
 730 static int mixer_ctl_feature_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
 731 {
 732         usb_mixer_elem_info_t *cval = kcontrol->private_data;
 733         int c, cnt, val, oval, err;
 734         int changed = 0;
 735
 736         if (cval->cmask) {
 737                 cnt = 0;
 738                 for (c = 0; c < MAX_CHANNELS; c++) {
 739                         if (cval->cmask & (1 << c)) {
 740                                 err = get_cur_mix_value(cval, c + 1, &oval);
 741                                 if (err < 0) {
 742                                         if (cval->mixer->ignore_ctl_error)
 743                                                 return 0;
 744                                         return err;
 745                                 }
 746                                 val = ucontrol->value.integer.value[cnt];
 747                                 val = get_abs_value(cval, val);
 748                                 if (oval != val) {
 749                                         set_cur_mix_value(cval, c + 1, val);
 750                                         changed = 1;
 751                                 }
 752                                 get_cur_mix_value(cval, c + 1, &val);
 753                                 cnt++;
 754                         }
 755                 }
 756         } else {
 757                 /* master channel */
 758                 err = get_cur_mix_value(cval, 0, &oval);
 759                 if (err < 0 && cval->mixer->ignore_ctl_error)
 760                         return 0;
 761                 if (err < 0)
 762                         return err;
 763                 val = ucontrol->value.integer.value[0];
 764                 val = get_abs_value(cval, val);
 765                 if (val != oval) {
 766                         set_cur_mix_value(cval, 0, val);
 767                         changed = 1;
 768                 }
 769         }
 770         return changed;
 771 }
 772
 773 static snd_kcontrol_new_t usb_feature_unit_ctl = {
 774         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 775         .name = "", /* will be filled later manually */
 776         .info = mixer_ctl_feature_info,
 777         .get = mixer_ctl_feature_get,
 778         .put = mixer_ctl_feature_put,
 779 };
 780
 781
 782 /*
 783  * build a feature control
 784  */
 785
 786 static void build_feature_ctl(mixer_build_t *state, unsigned char *desc,
 787                               unsigned int ctl_mask, int control,
 788                               usb_audio_term_t *iterm, int unitid)
 789 {
 790         unsigned int len = 0;
 791         int mapped_name = 0;
 792         int nameid = desc[desc[0] - 1];
 793         snd_kcontrol_t *kctl;
 794         usb_mixer_elem_info_t *cval;
 795
 796         control++; /* change from zero-based to 1-based value */
 797
 798         if (control == USB_FEATURE_GEQ) {
 799                 /* FIXME: not supported yet */
 800                 return;
 801         }
 802
 803         if (check_ignored_ctl(state, unitid, control))
 804                 return;
 805
 806         cval = kcalloc(1, sizeof(*cval), GFP_KERNEL);
 807         if (! cval) {
 808                 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
 809                 return;
 810         }
 811         cval->mixer = state->mixer;
 812         cval->id = unitid;
 813         cval->control = control;
 814         cval->cmask = ctl_mask;
 815         cval->val_type = audio_feature_info[control-1].type;
 816         if (ctl_mask == 0)
 817                 cval->channels = 1;     /* master channel */
 818         else {
 819                 int i, c = 0;
 820                 for (i = 0; i < 16; i++)
 821                         if (ctl_mask & (1 << i))
 822                                 c++;
 823                 cval->channels = c;
 824         }
 825
 826         /* get min/max values */
 827         get_min_max(cval, 0);
 828
 829         kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
 830         if (! kctl) {
 831                 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
 832                 kfree(cval);
 833                 return;
 834         }
 835         kctl->private_free = usb_mixer_elem_free;
 836
 837         len = check_mapped_name(state, unitid, control, kctl->id.name, sizeof(kctl->id.name));
 838         mapped_name = len != 0;
 839         if (! len && nameid)
 840                 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
 841
 842         switch (control) {
 843         case USB_FEATURE_MUTE:
 844         case USB_FEATURE_VOLUME:
 845                 /* determine the control name.  the rule is:
 846                  * - if a name id is given in descriptor, use it.
 847                  * - if the connected input can be determined, then use the name
 848                  *   of terminal type.
 849                  * - if the connected output can be determined, use it.
 850                  * - otherwise, anonymous name.
 851                  */
 852                 if (! len) {
 853                         len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 1);
 854                         if (! len)
 855                                 len = get_term_name(state, &state->oterm, kctl->id.name, sizeof(kctl->id.name), 1);
 856                         if (! len)
 857                                 len = snprintf(kctl->id.name, sizeof(kctl->id.name),
 858                                                "Feature %d", unitid);
 859                 }
 860                 /* determine the stream direction:
 861                  * if the connected output is USB stream, then it's likely a
 862                  * capture stream.  otherwise it should be playback (hopefully :)
 863                  */
 864                 if (! mapped_name && ! (state->oterm.type >> 16)) {
 865                         if ((state->oterm.type & 0xff00) == 0x0100) {
 866                                 len = strlcat(kctl->id.name, " Capture", sizeof(kctl->id.name));
 867                         } else {
 868                                 len = strlcat(kctl->id.name + len, " Playback", sizeof(kctl->id.name));
 869                         }
 870                 }
 871                 strlcat(kctl->id.name + len, control == USB_FEATURE_MUTE ? " Switch" : " Volume",
 872                         sizeof(kctl->id.name));
 873                 break;
 874
 875         default:
 876                 if (! len)
 877                         strlcpy(kctl->id.name, audio_feature_info[control-1].name,
 878                                 sizeof(kctl->id.name));
 879                 break;
 880         }
 881
 882         /* quirk for UDA1321/N101 */
 883         /* note that detection between firmware 2.1.1.7 (N101) and later 2.1.1.21 */
 884         /* is not very clear from datasheets */
 885         /* I hope that the min value is -15360 for newer firmware --jk */
 886         if (((state->vendor == 0x471 && (state->product == 0x104 || state->product == 0x105 || state->product == 0x101)) ||
 887              (state->vendor == 0x672 && state->product == 0x1041)) && !strcmp(kctl->id.name, "PCM Playback Volume") &&
 888              cval->min == -15616) {
 889                 snd_printk("USB Audio: using volume control quirk for the UDA1321/N101 chip\n");
 890                 cval->max = -256;
 891         }
 892
 893         snd_printdd(KERN_INFO "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
 894                     cval->id, kctl->id.name, cval->channels, cval->min, cval->max, cval->res);
 895         add_control_to_empty(state, kctl);
 896 }
 897
 898
 899
 900 /*
 901  * parse a feature unit
 902  *
 903  * most of controlls are defined here.
 904  */
 905 static int parse_audio_feature_unit(mixer_build_t *state, int unitid, unsigned char *ftr)
 906 {
 907         int channels, i, j;
 908         usb_audio_term_t iterm;
 909         unsigned int master_bits, first_ch_bits;
 910         int err, csize;
 911
 912         if (ftr[0] < 7 || ! (csize = ftr[5]) || ftr[0] < 7 + csize) {
 913                 snd_printk(KERN_ERR "usbaudio: unit %u: invalid FEATURE_UNIT descriptor\n", unitid);
 914                 return -EINVAL;
 915         }
 916
 917         /* parse the source unit */
 918         if ((err = parse_audio_unit(state, ftr[4])) < 0)
 919                 return err;
 920
 921         /* determine the input source type and name */
 922         if (check_input_term(state, ftr[4], &iterm) < 0)
 923                 return -EINVAL;
 924
 925         channels = (ftr[0] - 7) / csize - 1;
 926
 927         master_bits = snd_usb_combine_bytes(ftr + 6, csize);
 928         if (channels > 0)
 929                 first_ch_bits = snd_usb_combine_bytes(ftr + 6 + csize, csize);
 930         else
 931                 first_ch_bits = 0;
 932         /* check all control types */
 933         for (i = 0; i < 10; i++) {
 934                 unsigned int ch_bits = 0;
 935                 for (j = 0; j < channels; j++) {
 936                         unsigned int mask = snd_usb_combine_bytes(ftr + 6 + csize * (j+1), csize);
 937                         if (mask & (1 << i))
 938                                 ch_bits |= (1 << j);
 939                 }
 940                 if (ch_bits & 1) /* the first channel must be set (for ease of programming) */
 941                         build_feature_ctl(state, ftr, ch_bits, i, &iterm, unitid);
 942                 if (master_bits & (1 << i))
 943                         build_feature_ctl(state, ftr, 0, i, &iterm, unitid);
 944         }
 945
 946         return 0;
 947 }
 948
 949
 950 /*
 951  * Mixer Unit
 952  */
 953
 954 /*
 955  * build a mixer unit control
 956  *
 957  * the callbacks are identical with feature unit.
 958  * input channel number (zero based) is given in control field instead.
 959  */
 960
 961 static void build_mixer_unit_ctl(mixer_build_t *state, unsigned char *desc,
 962                                  int in_pin, int in_ch, int unitid,
 963                                  usb_audio_term_t *iterm)
 964 {
 965         usb_mixer_elem_info_t *cval;
 966         unsigned int input_pins = desc[4];
 967         unsigned int num_outs = desc[5 + input_pins];
 968         unsigned int i, len;
 969         snd_kcontrol_t *kctl;
 970
 971         if (check_ignored_ctl(state, unitid, 0))
 972                 return;
 973
 974         cval = kcalloc(1, sizeof(*cval), GFP_KERNEL);
 975         if (! cval)
 976                 return;
 977
 978         cval->mixer = state->mixer;
 979         cval->id = unitid;
 980         cval->control = in_ch + 1; /* based on 1 */
 981         cval->val_type = USB_MIXER_S16;
 982         for (i = 0; i < num_outs; i++) {
 983                 if (check_matrix_bitmap(desc + 9 + input_pins, in_ch, i, num_outs)) {
 984                         cval->cmask |= (1 << i);
 985                         cval->channels++;
 986                 }
 987         }
 988
 989         /* get min/max values */
 990         get_min_max(cval, 0);
 991
 992         kctl = snd_ctl_new1(&usb_feature_unit_ctl, cval);
 993         if (! kctl) {
 994                 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
 995                 kfree(cval);
 996                 return;
 997         }
 998         kctl->private_free = usb_mixer_elem_free;
 999
1000         len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
1001         if (! len)
1002                 len = get_term_name(state, iterm, kctl->id.name, sizeof(kctl->id.name), 0);
1003         if (! len)
1004                 len = sprintf(kctl->id.name, "Mixer Source %d", in_ch + 1);
1005         strlcat(kctl->id.name + len, " Volume", sizeof(kctl->id.name));
1006
1007         snd_printdd(KERN_INFO "[%d] MU [%s] ch = %d, val = %d/%d\n",
1008                     cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1009         add_control_to_empty(state, kctl);
1010 }
1011
1012
1013 /*
1014  * parse a mixer unit
1015  */
1016 static int parse_audio_mixer_unit(mixer_build_t *state, int unitid, unsigned char *desc)
1017 {
1018         usb_audio_term_t iterm;
1019         int input_pins, num_ins, num_outs;
1020         int pin, ich, err;
1021
1022         if (desc[0] < 11 || ! (input_pins = desc[4]) || ! (num_outs = desc[5 + input_pins])) {
1023                 snd_printk(KERN_ERR "invalid MIXER UNIT descriptor %d\n", unitid);
1024                 return -EINVAL;
1025         }
1026         /* no bmControls field (e.g. Maya44) -> ignore */
1027         if (desc[0] <= 10 + input_pins) {
1028                 snd_printdd(KERN_INFO "MU %d has no bmControls field\n", unitid);
1029                 return 0;
1030         }
1031
1032         num_ins = 0;
1033         ich = 0;
1034         for (pin = 0; pin < input_pins; pin++) {
1035                 err = parse_audio_unit(state, desc[5 + pin]);
1036                 if (err < 0)
1037                         return err;
1038                 err = check_input_term(state, desc[5 + pin], &iterm);
1039                 if (err < 0)
1040                         return err;
1041                 num_ins += iterm.channels;
1042                 for (; ich < num_ins; ++ich) {
1043                         int och, ich_has_controls = 0;
1044
1045                         for (och = 0; och < num_outs; ++och) {
1046                                 if (check_matrix_bitmap(desc + 9 + input_pins,
1047                                                         ich, och, num_outs)) {
1048                                         ich_has_controls = 1;
1049                                         break;
1050                                 }
1051                         }
1052                         if (ich_has_controls)
1053                                 build_mixer_unit_ctl(state, desc, pin, ich,
1054                                                      unitid, &iterm);
1055                 }
1056         }
1057         return 0;
1058 }
1059
1060
1061 /*
1062  * Processing Unit / Extension Unit
1063  */
1064
1065 /* get callback for processing/extension unit */
1066 static int mixer_ctl_procunit_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1067 {
1068         usb_mixer_elem_info_t *cval = kcontrol->private_data;
1069         int err, val;
1070
1071         err = get_cur_ctl_value(cval, cval->control << 8, &val);
1072         if (err < 0 && cval->mixer->ignore_ctl_error) {
1073                 ucontrol->value.integer.value[0] = cval->min;
1074                 return 0;
1075         }
1076         if (err < 0)
1077                 return err;
1078         val = get_relative_value(cval, val);
1079         ucontrol->value.integer.value[0] = val;
1080         return 0;
1081 }
1082
1083 /* put callback for processing/extension unit */
1084 static int mixer_ctl_procunit_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1085 {
1086         usb_mixer_elem_info_t *cval = kcontrol->private_data;
1087         int val, oval, err;
1088
1089         err = get_cur_ctl_value(cval, cval->control << 8, &oval);
1090         if (err < 0) {
1091                 if (cval->mixer->ignore_ctl_error)
1092                         return 0;
1093                 return err;
1094         }
1095         val = ucontrol->value.integer.value[0];
1096         val = get_abs_value(cval, val);
1097         if (val != oval) {
1098                 set_cur_ctl_value(cval, cval->control << 8, val);
1099                 return 1;
1100         }
1101         return 0;
1102 }
1103
1104 /* alsa control interface for processing/extension unit */
1105 static snd_kcontrol_new_t mixer_procunit_ctl = {
1106         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1107         .name = "", /* will be filled later */
1108         .info = mixer_ctl_feature_info,
1109         .get = mixer_ctl_procunit_get,
1110         .put = mixer_ctl_procunit_put,
1111 };
1112
1113
1114 /*
1115  * predefined data for processing units
1116  */
1117 struct procunit_value_info {
1118         int control;
1119         char *suffix;
1120         int val_type;
1121         int min_value;
1122 };
1123
1124 struct procunit_info {
1125         int type;
1126         char *name;
1127         struct procunit_value_info *values;
1128 };
1129
1130 static struct procunit_value_info updown_proc_info[] = {
1131         { USB_PROC_UPDOWN_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1132         { USB_PROC_UPDOWN_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
1133         { 0 }
1134 };
1135 static struct procunit_value_info prologic_proc_info[] = {
1136         { USB_PROC_PROLOGIC_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1137         { USB_PROC_PROLOGIC_MODE_SEL, "Mode Select", USB_MIXER_U8, 1 },
1138         { 0 }
1139 };
1140 static struct procunit_value_info threed_enh_proc_info[] = {
1141         { USB_PROC_3DENH_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1142         { USB_PROC_3DENH_SPACE, "Spaciousness", USB_MIXER_U8 },
1143         { 0 }
1144 };
1145 static struct procunit_value_info reverb_proc_info[] = {
1146         { USB_PROC_REVERB_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1147         { USB_PROC_REVERB_LEVEL, "Level", USB_MIXER_U8 },
1148         { USB_PROC_REVERB_TIME, "Time", USB_MIXER_U16 },
1149         { USB_PROC_REVERB_DELAY, "Delay", USB_MIXER_U8 },
1150         { 0 }
1151 };
1152 static struct procunit_value_info chorus_proc_info[] = {
1153         { USB_PROC_CHORUS_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1154         { USB_PROC_CHORUS_LEVEL, "Level", USB_MIXER_U8 },
1155         { USB_PROC_CHORUS_RATE, "Rate", USB_MIXER_U16 },
1156         { USB_PROC_CHORUS_DEPTH, "Depth", USB_MIXER_U16 },
1157         { 0 }
1158 };
1159 static struct procunit_value_info dcr_proc_info[] = {
1160         { USB_PROC_DCR_SWITCH, "Switch", USB_MIXER_BOOLEAN },
1161         { USB_PROC_DCR_RATIO, "Ratio", USB_MIXER_U16 },
1162         { USB_PROC_DCR_MAX_AMP, "Max Amp", USB_MIXER_S16 },
1163         { USB_PROC_DCR_THRESHOLD, "Threshold", USB_MIXER_S16 },
1164         { USB_PROC_DCR_ATTACK, "Attack Time", USB_MIXER_U16 },
1165         { USB_PROC_DCR_RELEASE, "Release Time", USB_MIXER_U16 },
1166         { 0 }
1167 };
1168
1169 static struct procunit_info procunits[] = {
1170         { USB_PROC_UPDOWN, "Up Down", updown_proc_info },
1171         { USB_PROC_PROLOGIC, "Dolby Prologic", prologic_proc_info },
1172         { USB_PROC_3DENH, "3D Stereo Extender", threed_enh_proc_info },
1173         { USB_PROC_REVERB, "Reverb", reverb_proc_info },
1174         { USB_PROC_CHORUS, "Chorus", chorus_proc_info },
1175         { USB_PROC_DCR, "DCR", dcr_proc_info },
1176         { 0 },
1177 };
1178
1179 /*
1180  * build a processing/extension unit
1181  */
1182 static int build_audio_procunit(mixer_build_t *state, int unitid, unsigned char *dsc, struct procunit_info *list, char *name)
1183 {
1184         int num_ins = dsc[6];
1185         usb_mixer_elem_info_t *cval;
1186         snd_kcontrol_t *kctl;
1187         int i, err, nameid, type, len;
1188         struct procunit_info *info;
1189         struct procunit_value_info *valinfo;
1190         static struct procunit_value_info default_value_info[] = {
1191                 { 0x01, "Switch", USB_MIXER_BOOLEAN },
1192                 { 0 }
1193         };
1194         static struct procunit_info default_info = {
1195                 0, NULL, default_value_info
1196         };
1197
1198         if (dsc[0] < 13 || dsc[0] < 13 + num_ins || dsc[0] < num_ins + dsc[11 + num_ins]) {
1199                 snd_printk(KERN_ERR "invalid %s descriptor (id %d)\n", name, unitid);
1200                 return -EINVAL;
1201         }
1202
1203         for (i = 0; i < num_ins; i++) {
1204                 if ((err = parse_audio_unit(state, dsc[7 + i])) < 0)
1205                         return err;
1206         }
1207
1208         type = combine_word(&dsc[4]);
1209         if (! type)
1210                 return 0; /* undefined? */
1211
1212         for (info = list; info && info->type; info++)
1213                 if (info->type == type)
1214                         break;
1215         if (! info || ! info->type)
1216                 info = &default_info;
1217
1218         for (valinfo = info->values; valinfo->control; valinfo++) {
1219                 /* FIXME: bitmap might be longer than 8bit */
1220                 if (! (dsc[12 + num_ins] & (1 << (valinfo->control - 1))))
1221                         continue;
1222                 if (check_ignored_ctl(state, unitid, valinfo->control))
1223                         continue;
1224                 cval = kcalloc(1, sizeof(*cval), GFP_KERNEL);
1225                 if (! cval) {
1226                         snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1227                         return -ENOMEM;
1228                 }
1229                 cval->mixer = state->mixer;
1230                 cval->id = unitid;
1231                 cval->control = valinfo->control;
1232                 cval->val_type = valinfo->val_type;
1233                 cval->channels = 1;
1234
1235                 /* get min/max values */
1236                 if (type == USB_PROC_UPDOWN && cval->control == USB_PROC_UPDOWN_MODE_SEL) {
1237                         /* FIXME: hard-coded */
1238                         cval->min = 1;
1239                         cval->max = dsc[15];
1240                         cval->res = 1;
1241                         cval->initialized = 1;
1242                 } else
1243                         get_min_max(cval, valinfo->min_value);
1244
1245                 kctl = snd_ctl_new1(&mixer_procunit_ctl, cval);
1246                 if (! kctl) {
1247                         snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1248                         kfree(cval);
1249                         return -ENOMEM;
1250                 }
1251                 kctl->private_free = usb_mixer_elem_free;
1252
1253                 if (check_mapped_name(state, unitid, cval->control, kctl->id.name, sizeof(kctl->id.name)))
1254                         ;
1255                 else if (info->name)
1256                         strlcpy(kctl->id.name, info->name, sizeof(kctl->id.name));
1257                 else {
1258                         nameid = dsc[12 + num_ins + dsc[11 + num_ins]];
1259                         len = 0;
1260                         if (nameid)
1261                                 len = snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1262                         if (! len)
1263                                 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
1264                 }
1265                 strlcat(kctl->id.name, " ", sizeof(kctl->id.name));
1266                 strlcat(kctl->id.name, valinfo->suffix, sizeof(kctl->id.name));
1267
1268                 snd_printdd(KERN_INFO "[%d] PU [%s] ch = %d, val = %d/%d\n",
1269                             cval->id, kctl->id.name, cval->channels, cval->min, cval->max);
1270                 if ((err = add_control_to_empty(state, kctl)) < 0)
1271                         return err;
1272         }
1273         return 0;
1274 }
1275
1276
1277 static int parse_audio_processing_unit(mixer_build_t *state, int unitid, unsigned char *desc)
1278 {
1279         return build_audio_procunit(state, unitid, desc, procunits, "Processing Unit");
1280 }
1281
1282 static int parse_audio_extension_unit(mixer_build_t *state, int unitid, unsigned char *desc)
1283 {
1284         return build_audio_procunit(state, unitid, desc, NULL, "Extension Unit");
1285 }
1286
1287
1288 /*
1289  * Selector Unit
1290  */
1291
1292 /* info callback for selector unit
1293  * use an enumerator type for routing
1294  */
1295 static int mixer_ctl_selector_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t *uinfo)
1296 {
1297         usb_mixer_elem_info_t *cval = kcontrol->private_data;
1298         char **itemlist = (char **)kcontrol->private_value;
1299
1300         snd_assert(itemlist, return -EINVAL);
1301         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1302         uinfo->count = 1;
1303         uinfo->value.enumerated.items = cval->max;
1304         if ((int)uinfo->value.enumerated.item >= cval->max)
1305                 uinfo->value.enumerated.item = cval->max - 1;
1306         strcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item]);
1307         return 0;
1308 }
1309
1310 /* get callback for selector unit */
1311 static int mixer_ctl_selector_get(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1312 {
1313         usb_mixer_elem_info_t *cval = kcontrol->private_data;
1314         int val, err;
1315
1316         err = get_cur_ctl_value(cval, 0, &val);
1317         if (err < 0) {
1318                 if (cval->mixer->ignore_ctl_error) {
1319                         ucontrol->value.enumerated.item[0] = 0;
1320                         return 0;
1321                 }
1322                 return err;
1323         }
1324         val = get_relative_value(cval, val);
1325         ucontrol->value.enumerated.item[0] = val;
1326         return 0;
1327 }
1328
1329 /* put callback for selector unit */
1330 static int mixer_ctl_selector_put(snd_kcontrol_t *kcontrol, snd_ctl_elem_value_t *ucontrol)
1331 {
1332         usb_mixer_elem_info_t *cval = kcontrol->private_data;
1333         int val, oval, err;
1334
1335         err = get_cur_ctl_value(cval, 0, &oval);
1336         if (err < 0) {
1337                 if (cval->mixer->ignore_ctl_error)
1338                         return 0;
1339                 return err;
1340         }
1341         val = ucontrol->value.enumerated.item[0];
1342         val = get_abs_value(cval, val);
1343         if (val != oval) {
1344                 set_cur_ctl_value(cval, 0, val);
1345                 return 1;
1346         }
1347         return 0;
1348 }
1349
1350 /* alsa control interface for selector unit */
1351 static snd_kcontrol_new_t mixer_selectunit_ctl = {
1352         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1353         .name = "", /* will be filled later */
1354         .info = mixer_ctl_selector_info,
1355         .get = mixer_ctl_selector_get,
1356         .put = mixer_ctl_selector_put,
1357 };
1358
1359
1360 /* private free callback.
1361  * free both private_data and private_value
1362  */
1363 static void usb_mixer_selector_elem_free(snd_kcontrol_t *kctl)
1364 {
1365         int i, num_ins = 0;
1366
1367         if (kctl->private_data) {
1368                 usb_mixer_elem_info_t *cval = kctl->private_data;
1369                 num_ins = cval->max;
1370                 kfree(cval);
1371                 kctl->private_data = NULL;
1372         }
1373         if (kctl->private_value) {
1374                 char **itemlist = (char **)kctl->private_value;
1375                 for (i = 0; i < num_ins; i++)
1376                         kfree(itemlist[i]);
1377                 kfree(itemlist);
1378                 kctl->private_value = 0;
1379         }
1380 }
1381
1382 /*
1383  * parse a selector unit
1384  */
1385 static int parse_audio_selector_unit(mixer_build_t *state, int unitid, unsigned char *desc)
1386 {
1387         unsigned int num_ins = desc[4];
1388         unsigned int i, nameid, len;
1389         int err;
1390         usb_mixer_elem_info_t *cval;
1391         snd_kcontrol_t *kctl;
1392         char **namelist;
1393
1394         if (! num_ins || desc[0] < 6 + num_ins) {
1395                 snd_printk(KERN_ERR "invalid SELECTOR UNIT descriptor %d\n", unitid);
1396                 return -EINVAL;
1397         }
1398
1399         for (i = 0; i < num_ins; i++) {
1400                 if ((err = parse_audio_unit(state, desc[5 + i])) < 0)
1401                         return err;
1402         }
1403
1404         if (num_ins == 1) /* only one ? nonsense! */
1405                 return 0;
1406
1407         if (check_ignored_ctl(state, unitid, 0))
1408                 return 0;
1409
1410         cval = kcalloc(1, sizeof(*cval), GFP_KERNEL);
1411         if (! cval) {
1412                 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1413                 return -ENOMEM;
1414         }
1415         cval->mixer = state->mixer;
1416         cval->id = unitid;
1417         cval->val_type = USB_MIXER_U8;
1418         cval->channels = 1;
1419         cval->min = 1;
1420         cval->max = num_ins;
1421         cval->res = 1;
1422         cval->initialized = 1;
1423
1424         namelist = kmalloc(sizeof(char *) * num_ins, GFP_KERNEL);
1425         if (! namelist) {
1426                 snd_printk(KERN_ERR "cannot malloc\n");
1427                 kfree(cval);
1428                 return -ENOMEM;
1429         }
1430 #define MAX_ITEM_NAME_LEN       64
1431         for (i = 0; i < num_ins; i++) {
1432                 usb_audio_term_t iterm;
1433                 len = 0;
1434                 namelist[i] = kmalloc(MAX_ITEM_NAME_LEN, GFP_KERNEL);
1435                 if (! namelist[i]) {
1436                         snd_printk(KERN_ERR "cannot malloc\n");
1437                         while (--i > 0)
1438                                 kfree(namelist[i]);
1439                         kfree(namelist);
1440                         kfree(cval);
1441                         return -ENOMEM;
1442                 }
1443                 len = check_mapped_selector_name(state, unitid, i, namelist[i],
1444                                                  MAX_ITEM_NAME_LEN);
1445                 if (! len && check_input_term(state, desc[5 + i], &iterm) >= 0)
1446                         len = get_term_name(state, &iterm, namelist[i], MAX_ITEM_NAME_LEN, 0);
1447                 if (! len)
1448                         sprintf(namelist[i], "Input %d", i);
1449         }
1450
1451         kctl = snd_ctl_new1(&mixer_selectunit_ctl, cval);
1452         if (! kctl) {
1453                 snd_printk(KERN_ERR "cannot malloc kcontrol\n");
1454                 kfree(cval);
1455                 return -ENOMEM;
1456         }
1457         kctl->private_value = (unsigned long)namelist;
1458         kctl->private_free = usb_mixer_selector_elem_free;
1459
1460         nameid = desc[desc[0] - 1];
1461         len = check_mapped_name(state, unitid, 0, kctl->id.name, sizeof(kctl->id.name));
1462         if (len)
1463                 ;
1464         else if (nameid)
1465                 snd_usb_copy_string_desc(state, nameid, kctl->id.name, sizeof(kctl->id.name));
1466         else {
1467                 len = get_term_name(state, &state->oterm,
1468                                     kctl->id.name, sizeof(kctl->id.name), 0);
1469                 if (! len)
1470                         strlcpy(kctl->id.name, "USB", sizeof(kctl->id.name));
1471
1472                 if ((state->oterm.type & 0xff00) == 0x0100)
1473                         strlcat(kctl->id.name, " Capture Source", sizeof(kctl->id.name));
1474                 else
1475                         strlcat(kctl->id.name, " Playback Source", sizeof(kctl->id.name));
1476         }
1477
1478         snd_printdd(KERN_INFO "[%d] SU [%s] items = %d\n",
1479                     cval->id, kctl->id.name, num_ins);
1480         if ((err = add_control_to_empty(state, kctl)) < 0)
1481                 return err;
1482
1483         return 0;
1484 }
1485
1486
1487 /*
1488  * parse an audio unit recursively
1489  */
1490
1491 static int parse_audio_unit(mixer_build_t *state, int unitid)
1492 {
1493         unsigned char *p1;
1494
1495         if (test_and_set_bit(unitid, state->unitbitmap))
1496                 return 0; /* the unit already visited */
1497
1498         p1 = find_audio_control_unit(state, unitid);
1499         if (!p1) {
1500                 snd_printk(KERN_ERR "usbaudio: unit %d not found!\n", unitid);
1501                 return -EINVAL;
1502         }
1503
1504         switch (p1[2]) {
1505         case INPUT_TERMINAL:
1506                 return 0; /* NOP */
1507         case MIXER_UNIT:
1508                 return parse_audio_mixer_unit(state, unitid, p1);
1509         case SELECTOR_UNIT:
1510                 return parse_audio_selector_unit(state, unitid, p1);
1511         case FEATURE_UNIT:
1512                 return parse_audio_feature_unit(state, unitid, p1);
1513         case PROCESSING_UNIT:
1514                 return parse_audio_processing_unit(state, unitid, p1);
1515         case EXTENSION_UNIT:
1516                 return parse_audio_extension_unit(state, unitid, p1);
1517         default:
1518                 snd_printk(KERN_ERR "usbaudio: unit %u: unexpected type 0x%02x\n", unitid, p1[2]);
1519                 return -EINVAL;
1520         }
1521 }
1522
1523 static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
1524 {
1525         kfree(mixer);
1526 }
1527
1528 static int snd_usb_mixer_dev_free(snd_device_t *device)
1529 {
1530         struct usb_mixer_interface *mixer = device->device_data;
1531         snd_usb_mixer_free(mixer);
1532         return 0;
1533 }
1534
1535 /*
1536  * create mixer controls
1537  *
1538  * walk through all OUTPUT_TERMINAL descriptors to search for mixers
1539  */
1540 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
1541 {
1542         unsigned char *desc;
1543         mixer_build_t state;
1544         int err;
1545         const struct usbmix_ctl_map *map;
1546         struct usb_device_descriptor *dev = &mixer->chip->dev->descriptor;
1547         struct usb_host_interface *hostif;
1548
1549         hostif = &usb_ifnum_to_if(mixer->chip->dev, mixer->ctrlif)->altsetting[0];
1550         memset(&state, 0, sizeof(state));
1551         state.chip = mixer->chip;
1552         state.mixer = mixer;
1553         state.buffer = hostif->extra;
1554         state.buflen = hostif->extralen;
1555         state.vendor = le16_to_cpu(dev->idVendor);
1556         state.product = le16_to_cpu(dev->idProduct);
1557
1558         /* check the mapping table */
1559         for (map = usbmix_ctl_maps; map->vendor; map++) {
1560                 if (map->vendor == state.vendor && map->product == state.product) {
1561                         state.map = map->map;
1562                         state.selector_map = map->selector_map;
1563                         mixer->ignore_ctl_error = map->ignore_ctl_error;
1564                         break;
1565                 }
1566         }
1567
1568         desc = NULL;
1569         while ((desc = snd_usb_find_csint_desc(hostif->extra, hostif->extralen, desc, OUTPUT_TERMINAL)) != NULL) {
1570                 if (desc[0] < 9)
1571                         continue; /* invalid descriptor? */
1572                 set_bit(desc[3], state.unitbitmap);  /* mark terminal ID as visited */
1573                 state.oterm.id = desc[3];
1574                 state.oterm.type = combine_word(&desc[4]);
1575                 state.oterm.name = desc[8];
1576                 err = parse_audio_unit(&state, desc[7]);
1577                 if (err < 0)
1578                         return err;
1579         }
1580         return 0;
1581 }
1582
1583 int snd_usb_create_mixer(snd_usb_audio_t *chip, int ctrlif)
1584 {
1585         static snd_device_ops_t dev_ops = {
1586                 .dev_free = snd_usb_mixer_dev_free
1587         };
1588         struct usb_mixer_interface *mixer;
1589         int err;
1590
1591         strcpy(chip->card->mixername, "USB Mixer");
1592
1593         mixer = kcalloc(1, sizeof(*mixer), GFP_KERNEL);
1594         if (!mixer)
1595                 return -ENOMEM;
1596         mixer->chip = chip;
1597         mixer->ctrlif = ctrlif;
1598 #ifdef IGNORE_CTL_ERROR
1599         mixer->ignore_ctl_error = 1;
1600 #endif
1601
1602         if ((err = snd_usb_mixer_controls(mixer)) < 0) {
1603                 snd_usb_mixer_free(mixer);
1604                 return err;
1605         }
1606
1607         err = snd_device_new(chip->card, SNDRV_DEV_LOWLEVEL, mixer, &dev_ops);
1608         if (err < 0) {
1609                 snd_usb_mixer_free(mixer);
1610                 return err;
1611         }
1612         list_add(&mixer->list, &chip->mixer_list);
1613         return 0;
1614 }
1615
1616 void snd_usb_mixer_disconnect(struct list_head *p)
1617 {
1618 }