sound/usb/mixer_quirks.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   USB Audio Driver for ALSA
   4  *
   5  *   Quirks and vendor-specific extensions for mixer interfaces
   6  *
   7  *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
   8  *
   9  *   Many codes borrowed from audio.c by
  10  *          Alan Cox (alan@lxorguk.ukuu.org.uk)
  11  *          Thomas Sailer (sailer@ife.ee.ethz.ch)
  12  *
  13  *   Audio Advantage Micro II support added by:
  14  *          Przemek Rudy (prudy1@o2.pl)
  15  */
  16
  17 #include <linux/hid.h>
  18 #include <linux/init.h>
  19 #include <linux/math64.h>
  20 #include <linux/slab.h>
  21 #include <linux/usb.h>
  22 #include <linux/usb/audio.h>
  23
  24 #include <sound/asoundef.h>
  25 #include <sound/core.h>
  26 #include <sound/control.h>
  27 #include <sound/hda_verbs.h>
  28 #include <sound/hwdep.h>
  29 #include <sound/info.h>
  30 #include <sound/tlv.h>
  31
  32 #include "usbaudio.h"
  33 #include "mixer.h"
  34 #include "mixer_quirks.h"
  35 #include "mixer_scarlett.h"
  36 #include "mixer_scarlett_gen2.h"
  37 #include "mixer_us16x08.h"
  38 #include "mixer_s1810c.h"
  39 #include "helper.h"
  40
  41 struct std_mono_table {
  42         unsigned int unitid, control, cmask;
  43         int val_type;
  44         const char *name;
  45         snd_kcontrol_tlv_rw_t *tlv_callback;
  46 };
  47
  48 /* This function allows for the creation of standard UAC controls.
  49  * See the quirks for M-Audio FTUs or Ebox-44.
  50  * If you don't want to set a TLV callback pass NULL.
  51  *
  52  * Since there doesn't seem to be a devices that needs a multichannel
  53  * version, we keep it mono for simplicity.
  54  */
  55 static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
  56                                 unsigned int unitid,
  57                                 unsigned int control,
  58                                 unsigned int cmask,
  59                                 int val_type,
  60                                 unsigned int idx_off,
  61                                 const char *name,
  62                                 snd_kcontrol_tlv_rw_t *tlv_callback)
  63 {
  64         struct usb_mixer_elem_info *cval;
  65         struct snd_kcontrol *kctl;
  66
  67         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
  68         if (!cval)
  69                 return -ENOMEM;
  70
  71         snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
  72         cval->val_type = val_type;
  73         cval->channels = 1;
  74         cval->control = control;
  75         cval->cmask = cmask;
  76         cval->idx_off = idx_off;
  77
  78         /* get_min_max() is called only for integer volumes later,
  79          * so provide a short-cut for booleans */
  80         cval->min = 0;
  81         cval->max = 1;
  82         cval->res = 0;
  83         cval->dBmin = 0;
  84         cval->dBmax = 0;
  85
  86         /* Create control */
  87         kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
  88         if (!kctl) {
  89                 kfree(cval);
  90                 return -ENOMEM;
  91         }
  92
  93         /* Set name */
  94         snprintf(kctl->id.name, sizeof(kctl->id.name), name);
  95         kctl->private_free = snd_usb_mixer_elem_free;
  96
  97         /* set TLV */
  98         if (tlv_callback) {
  99                 kctl->tlv.c = tlv_callback;
 100                 kctl->vd[0].access |=
 101                         SNDRV_CTL_ELEM_ACCESS_TLV_READ |
 102                         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
 103         }
 104         /* Add control to mixer */
 105         return snd_usb_mixer_add_control(&cval->head, kctl);
 106 }
 107
 108 static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
 109                                 unsigned int unitid,
 110                                 unsigned int control,
 111                                 unsigned int cmask,
 112                                 int val_type,
 113                                 const char *name,
 114                                 snd_kcontrol_tlv_rw_t *tlv_callback)
 115 {
 116         return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
 117                 val_type, 0 /* Offset */, name, tlv_callback);
 118 }
 119
 120 /*
 121  * Create a set of standard UAC controls from a table
 122  */
 123 static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
 124                                      const struct std_mono_table *t)
 125 {
 126         int err;
 127
 128         while (t->name != NULL) {
 129                 err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
 130                                 t->cmask, t->val_type, t->name, t->tlv_callback);
 131                 if (err < 0)
 132                         return err;
 133                 t++;
 134         }
 135
 136         return 0;
 137 }
 138
 139 static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
 140                                       int id,
 141                                       usb_mixer_elem_resume_func_t resume,
 142                                       const struct snd_kcontrol_new *knew,
 143                                       struct usb_mixer_elem_list **listp)
 144 {
 145         struct usb_mixer_elem_list *list;
 146         struct snd_kcontrol *kctl;
 147
 148         list = kzalloc(sizeof(*list), GFP_KERNEL);
 149         if (!list)
 150                 return -ENOMEM;
 151         if (listp)
 152                 *listp = list;
 153         list->mixer = mixer;
 154         list->id = id;
 155         list->resume = resume;
 156         kctl = snd_ctl_new1(knew, list);
 157         if (!kctl) {
 158                 kfree(list);
 159                 return -ENOMEM;
 160         }
 161         kctl->private_free = snd_usb_mixer_elem_free;
 162         /* don't use snd_usb_mixer_add_control() here, this is a special list element */
 163         return snd_usb_mixer_add_list(list, kctl, false);
 164 }
 165
 166 /*
 167  * Sound Blaster remote control configuration
 168  *
 169  * format of remote control data:
 170  * Extigy:       xx 00
 171  * Audigy 2 NX:  06 80 xx 00 00 00
 172  * Live! 24-bit: 06 80 xx yy 22 83
 173  */
 174 static const struct rc_config {
 175         u32 usb_id;
 176         u8  offset;
 177         u8  length;
 178         u8  packet_length;
 179         u8  min_packet_length; /* minimum accepted length of the URB result */
 180         u8  mute_mixer_id;
 181         u32 mute_code;
 182 } rc_configs[] = {
 183         { USB_ID(0x041e, 0x3000), 0, 1, 2, 1,  18, 0x0013 }, /* Extigy       */
 184         { USB_ID(0x041e, 0x3020), 2, 1, 6, 6,  18, 0x0013 }, /* Audigy 2 NX  */
 185         { USB_ID(0x041e, 0x3040), 2, 2, 6, 6,  2,  0x6e91 }, /* Live! 24-bit */
 186         { USB_ID(0x041e, 0x3042), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 */
 187         { USB_ID(0x041e, 0x30df), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 Pro */
 188         { USB_ID(0x041e, 0x3237), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 Pro */
 189         { USB_ID(0x041e, 0x3263), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 Pro */
 190         { USB_ID(0x041e, 0x3048), 2, 2, 6, 6,  2,  0x6e91 }, /* Toshiba SB0500 */
 191 };
 192
 193 static void snd_usb_soundblaster_remote_complete(struct urb *urb)
 194 {
 195         struct usb_mixer_interface *mixer = urb->context;
 196         const struct rc_config *rc = mixer->rc_cfg;
 197         u32 code;
 198
 199         if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
 200                 return;
 201
 202         code = mixer->rc_buffer[rc->offset];
 203         if (rc->length == 2)
 204                 code |= mixer->rc_buffer[rc->offset + 1] << 8;
 205
 206         /* the Mute button actually changes the mixer control */
 207         if (code == rc->mute_code)
 208                 snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
 209         mixer->rc_code = code;
 210         wmb();
 211         wake_up(&mixer->rc_waitq);
 212 }
 213
 214 static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
 215                                      long count, loff_t *offset)
 216 {
 217         struct usb_mixer_interface *mixer = hw->private_data;
 218         int err;
 219         u32 rc_code;
 220
 221         if (count != 1 && count != 4)
 222                 return -EINVAL;
 223         err = wait_event_interruptible(mixer->rc_waitq,
 224                                        (rc_code = xchg(&mixer->rc_code, 0)) != 0);
 225         if (err == 0) {
 226                 if (count == 1)
 227                         err = put_user(rc_code, buf);
 228                 else
 229                         err = put_user(rc_code, (u32 __user *)buf);
 230         }
 231         return err < 0 ? err : count;
 232 }
 233
 234 static __poll_t snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
 235                                             poll_table *wait)
 236 {
 237         struct usb_mixer_interface *mixer = hw->private_data;
 238
 239         poll_wait(file, &mixer->rc_waitq, wait);
 240         return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
 241 }
 242
 243 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
 244 {
 245         struct snd_hwdep *hwdep;
 246         int err, len, i;
 247
 248         for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
 249                 if (rc_configs[i].usb_id == mixer->chip->usb_id)
 250                         break;
 251         if (i >= ARRAY_SIZE(rc_configs))
 252                 return 0;
 253         mixer->rc_cfg = &rc_configs[i];
 254
 255         len = mixer->rc_cfg->packet_length;
 256
 257         init_waitqueue_head(&mixer->rc_waitq);
 258         err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
 259         if (err < 0)
 260                 return err;
 261         snprintf(hwdep->name, sizeof(hwdep->name),
 262                  "%s remote control", mixer->chip->card->shortname);
 263         hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
 264         hwdep->private_data = mixer;
 265         hwdep->ops.read = snd_usb_sbrc_hwdep_read;
 266         hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
 267         hwdep->exclusive = 1;
 268
 269         mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
 270         if (!mixer->rc_urb)
 271                 return -ENOMEM;
 272         mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
 273         if (!mixer->rc_setup_packet) {
 274                 usb_free_urb(mixer->rc_urb);
 275                 mixer->rc_urb = NULL;
 276                 return -ENOMEM;
 277         }
 278         mixer->rc_setup_packet->bRequestType =
 279                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
 280         mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
 281         mixer->rc_setup_packet->wValue = cpu_to_le16(0);
 282         mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
 283         mixer->rc_setup_packet->wLength = cpu_to_le16(len);
 284         usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
 285                              usb_rcvctrlpipe(mixer->chip->dev, 0),
 286                              (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
 287                              snd_usb_soundblaster_remote_complete, mixer);
 288         return 0;
 289 }
 290
 291 #define snd_audigy2nx_led_info          snd_ctl_boolean_mono_info
 292
 293 static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
 294 {
 295         ucontrol->value.integer.value[0] = kcontrol->private_value >> 8;
 296         return 0;
 297 }
 298
 299 static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
 300                                     int value, int index)
 301 {
 302         struct snd_usb_audio *chip = mixer->chip;
 303         int err;
 304
 305         err = snd_usb_lock_shutdown(chip);
 306         if (err < 0)
 307                 return err;
 308
 309         if (chip->usb_id == USB_ID(0x041e, 0x3042))
 310                 err = snd_usb_ctl_msg(chip->dev,
 311                               usb_sndctrlpipe(chip->dev, 0), 0x24,
 312                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 313                               !value, 0, NULL, 0);
 314         /* USB X-Fi S51 Pro */
 315         if (chip->usb_id == USB_ID(0x041e, 0x30df))
 316                 err = snd_usb_ctl_msg(chip->dev,
 317                               usb_sndctrlpipe(chip->dev, 0), 0x24,
 318                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 319                               !value, 0, NULL, 0);
 320         else
 321                 err = snd_usb_ctl_msg(chip->dev,
 322                               usb_sndctrlpipe(chip->dev, 0), 0x24,
 323                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 324                               value, index + 2, NULL, 0);
 325         snd_usb_unlock_shutdown(chip);
 326         return err;
 327 }
 328
 329 static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol,
 330                                  struct snd_ctl_elem_value *ucontrol)
 331 {
 332         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
 333         struct usb_mixer_interface *mixer = list->mixer;
 334         int index = kcontrol->private_value & 0xff;
 335         unsigned int value = ucontrol->value.integer.value[0];
 336         int old_value = kcontrol->private_value >> 8;
 337         int err;
 338
 339         if (value > 1)
 340                 return -EINVAL;
 341         if (value == old_value)
 342                 return 0;
 343         kcontrol->private_value = (value << 8) | index;
 344         err = snd_audigy2nx_led_update(mixer, value, index);
 345         return err < 0 ? err : 1;
 346 }
 347
 348 static int snd_audigy2nx_led_resume(struct usb_mixer_elem_list *list)
 349 {
 350         int priv_value = list->kctl->private_value;
 351
 352         return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
 353                                         priv_value & 0xff);
 354 }
 355
 356 /* name and private_value are set dynamically */
 357 static const struct snd_kcontrol_new snd_audigy2nx_control = {
 358         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 359         .info = snd_audigy2nx_led_info,
 360         .get = snd_audigy2nx_led_get,
 361         .put = snd_audigy2nx_led_put,
 362 };
 363
 364 static const char * const snd_audigy2nx_led_names[] = {
 365         "CMSS LED Switch",
 366         "Power LED Switch",
 367         "Dolby Digital LED Switch",
 368 };
 369
 370 static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
 371 {
 372         int i, err;
 373
 374         for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_led_names); ++i) {
 375                 struct snd_kcontrol_new knew;
 376
 377                 /* USB X-Fi S51 doesn't have a CMSS LED */
 378                 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
 379                         continue;
 380                 /* USB X-Fi S51 Pro doesn't have one either */
 381                 if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
 382                         continue;
 383                 if (i > 1 && /* Live24ext has 2 LEDs only */
 384                         (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
 385                          mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
 386                          mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
 387                          mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
 388                         break;
 389
 390                 knew = snd_audigy2nx_control;
 391                 knew.name = snd_audigy2nx_led_names[i];
 392                 knew.private_value = (1 << 8) | i; /* LED on as default */
 393                 err = add_single_ctl_with_resume(mixer, 0,
 394                                                  snd_audigy2nx_led_resume,
 395                                                  &knew, NULL);
 396                 if (err < 0)
 397                         return err;
 398         }
 399         return 0;
 400 }
 401
 402 static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
 403                                     struct snd_info_buffer *buffer)
 404 {
 405         static const struct sb_jack {
 406                 int unitid;
 407                 const char *name;
 408         }  jacks_audigy2nx[] = {
 409                 {4,  "dig in "},
 410                 {7,  "line in"},
 411                 {19, "spk out"},
 412                 {20, "hph out"},
 413                 {-1, NULL}
 414         }, jacks_live24ext[] = {
 415                 {4,  "line in"}, /* &1=Line, &2=Mic*/
 416                 {3,  "hph out"}, /* headphones */
 417                 {0,  "RC     "}, /* last command, 6 bytes see rc_config above */
 418                 {-1, NULL}
 419         };
 420         const struct sb_jack *jacks;
 421         struct usb_mixer_interface *mixer = entry->private_data;
 422         int i, err;
 423         u8 buf[3];
 424
 425         snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
 426         if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
 427                 jacks = jacks_audigy2nx;
 428         else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
 429                  mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
 430                 jacks = jacks_live24ext;
 431         else
 432                 return;
 433
 434         for (i = 0; jacks[i].name; ++i) {
 435                 snd_iprintf(buffer, "%s: ", jacks[i].name);
 436                 err = snd_usb_lock_shutdown(mixer->chip);
 437                 if (err < 0)
 438                         return;
 439                 err = snd_usb_ctl_msg(mixer->chip->dev,
 440                                       usb_rcvctrlpipe(mixer->chip->dev, 0),
 441                                       UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
 442                                       USB_RECIP_INTERFACE, 0,
 443                                       jacks[i].unitid << 8, buf, 3);
 444                 snd_usb_unlock_shutdown(mixer->chip);
 445                 if (err == 3 && (buf[0] == 3 || buf[0] == 6))
 446                         snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
 447                 else
 448                         snd_iprintf(buffer, "?\n");
 449         }
 450 }
 451
 452 /* EMU0204 */
 453 static int snd_emu0204_ch_switch_info(struct snd_kcontrol *kcontrol,
 454                                       struct snd_ctl_elem_info *uinfo)
 455 {
 456         static const char * const texts[2] = {"1/2", "3/4"};
 457
 458         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
 459 }
 460
 461 static int snd_emu0204_ch_switch_get(struct snd_kcontrol *kcontrol,
 462                                      struct snd_ctl_elem_value *ucontrol)
 463 {
 464         ucontrol->value.enumerated.item[0] = kcontrol->private_value;
 465         return 0;
 466 }
 467
 468 static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
 469                                         int value)
 470 {
 471         struct snd_usb_audio *chip = mixer->chip;
 472         int err;
 473         unsigned char buf[2];
 474
 475         err = snd_usb_lock_shutdown(chip);
 476         if (err < 0)
 477                 return err;
 478
 479         buf[0] = 0x01;
 480         buf[1] = value ? 0x02 : 0x01;
 481         err = snd_usb_ctl_msg(chip->dev,
 482                       usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
 483                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 484                       0x0400, 0x0e00, buf, 2);
 485         snd_usb_unlock_shutdown(chip);
 486         return err;
 487 }
 488
 489 static int snd_emu0204_ch_switch_put(struct snd_kcontrol *kcontrol,
 490                                      struct snd_ctl_elem_value *ucontrol)
 491 {
 492         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
 493         struct usb_mixer_interface *mixer = list->mixer;
 494         unsigned int value = ucontrol->value.enumerated.item[0];
 495         int err;
 496
 497         if (value > 1)
 498                 return -EINVAL;
 499
 500         if (value == kcontrol->private_value)
 501                 return 0;
 502
 503         kcontrol->private_value = value;
 504         err = snd_emu0204_ch_switch_update(mixer, value);
 505         return err < 0 ? err : 1;
 506 }
 507
 508 static int snd_emu0204_ch_switch_resume(struct usb_mixer_elem_list *list)
 509 {
 510         return snd_emu0204_ch_switch_update(list->mixer,
 511                                             list->kctl->private_value);
 512 }
 513
 514 static const struct snd_kcontrol_new snd_emu0204_control = {
 515         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 516         .name = "Front Jack Channels",
 517         .info = snd_emu0204_ch_switch_info,
 518         .get = snd_emu0204_ch_switch_get,
 519         .put = snd_emu0204_ch_switch_put,
 520         .private_value = 0,
 521 };
 522
 523 static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
 524 {
 525         return add_single_ctl_with_resume(mixer, 0,
 526                                           snd_emu0204_ch_switch_resume,
 527                                           &snd_emu0204_control, NULL);
 528 }
 529
 530 /* ASUS Xonar U1 / U3 controls */
 531
 532 static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
 533                                    struct snd_ctl_elem_value *ucontrol)
 534 {
 535         ucontrol->value.integer.value[0] = !!(kcontrol->private_value & 0x02);
 536         return 0;
 537 }
 538
 539 static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
 540                                       unsigned char status)
 541 {
 542         struct snd_usb_audio *chip = mixer->chip;
 543         int err;
 544
 545         err = snd_usb_lock_shutdown(chip);
 546         if (err < 0)
 547                 return err;
 548         err = snd_usb_ctl_msg(chip->dev,
 549                               usb_sndctrlpipe(chip->dev, 0), 0x08,
 550                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
 551                               50, 0, &status, 1);
 552         snd_usb_unlock_shutdown(chip);
 553         return err;
 554 }
 555
 556 static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
 557                                    struct snd_ctl_elem_value *ucontrol)
 558 {
 559         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
 560         u8 old_status, new_status;
 561         int err;
 562
 563         old_status = kcontrol->private_value;
 564         if (ucontrol->value.integer.value[0])
 565                 new_status = old_status | 0x02;
 566         else
 567                 new_status = old_status & ~0x02;
 568         if (new_status == old_status)
 569                 return 0;
 570
 571         kcontrol->private_value = new_status;
 572         err = snd_xonar_u1_switch_update(list->mixer, new_status);
 573         return err < 0 ? err : 1;
 574 }
 575
 576 static int snd_xonar_u1_switch_resume(struct usb_mixer_elem_list *list)
 577 {
 578         return snd_xonar_u1_switch_update(list->mixer,
 579                                           list->kctl->private_value);
 580 }
 581
 582 static const struct snd_kcontrol_new snd_xonar_u1_output_switch = {
 583         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 584         .name = "Digital Playback Switch",
 585         .info = snd_ctl_boolean_mono_info,
 586         .get = snd_xonar_u1_switch_get,
 587         .put = snd_xonar_u1_switch_put,
 588         .private_value = 0x05,
 589 };
 590
 591 static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
 592 {
 593         return add_single_ctl_with_resume(mixer, 0,
 594                                           snd_xonar_u1_switch_resume,
 595                                           &snd_xonar_u1_output_switch, NULL);
 596 }
 597
 598 /* Digidesign Mbox 1 helper functions */
 599
 600 static int snd_mbox1_is_spdif_synced(struct snd_usb_audio *chip)
 601 {
 602         unsigned char buff[3];
 603         int err;
 604         int is_spdif_synced;
 605
 606         /* Read clock source */
 607         err = snd_usb_ctl_msg(chip->dev,
 608                               usb_rcvctrlpipe(chip->dev, 0), 0x81,
 609                               USB_DIR_IN |
 610                               USB_TYPE_CLASS |
 611                               USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
 612         if (err < 0)
 613                 return err;
 614
 615         /* spdif sync: buff is all zeroes */
 616         is_spdif_synced = !(buff[0] | buff[1] | buff[2]);
 617         return is_spdif_synced;
 618 }
 619
 620 static int snd_mbox1_set_clk_source(struct snd_usb_audio *chip, int rate_or_zero)
 621 {
 622         /* 2 possibilities:     Internal    -> expects sample rate
 623          *                      S/PDIF sync -> expects rate = 0
 624          */
 625         unsigned char buff[3];
 626
 627         buff[0] = (rate_or_zero >>  0) & 0xff;
 628         buff[1] = (rate_or_zero >>  8) & 0xff;
 629         buff[2] = (rate_or_zero >> 16) & 0xff;
 630
 631         /* Set clock source */
 632         return snd_usb_ctl_msg(chip->dev,
 633                                usb_sndctrlpipe(chip->dev, 0), 0x1,
 634                                USB_TYPE_CLASS |
 635                                USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
 636 }
 637
 638 static int snd_mbox1_is_spdif_input(struct snd_usb_audio *chip)
 639 {
 640         /* Hardware gives 2 possibilities:      ANALOG Source  -> 0x01
 641          *                                      S/PDIF Source  -> 0x02
 642          */
 643         int err;
 644         unsigned char source[1];
 645
 646         /* Read input source */
 647         err = snd_usb_ctl_msg(chip->dev,
 648                               usb_rcvctrlpipe(chip->dev, 0), 0x81,
 649                               USB_DIR_IN |
 650                               USB_TYPE_CLASS |
 651                               USB_RECIP_INTERFACE, 0x00, 0x500, source, 1);
 652         if (err < 0)
 653                 return err;
 654
 655         return (source[0] == 2);
 656 }
 657
 658 static int snd_mbox1_set_input_source(struct snd_usb_audio *chip, int is_spdif)
 659 {
 660         /* NB: Setting the input source to S/PDIF resets the clock source to S/PDIF
 661          * Hardware expects 2 possibilities:    ANALOG Source  -> 0x01
 662          *                                      S/PDIF Source  -> 0x02
 663          */
 664         unsigned char buff[1];
 665
 666         buff[0] = (is_spdif & 1) + 1;
 667
 668         /* Set input source */
 669         return snd_usb_ctl_msg(chip->dev,
 670                                usb_sndctrlpipe(chip->dev, 0), 0x1,
 671                                USB_TYPE_CLASS |
 672                                USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
 673 }
 674
 675 /* Digidesign Mbox 1 clock source switch (internal/spdif) */
 676
 677 static int snd_mbox1_clk_switch_get(struct snd_kcontrol *kctl,
 678                                     struct snd_ctl_elem_value *ucontrol)
 679 {
 680         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 681         struct snd_usb_audio *chip = list->mixer->chip;
 682         int err;
 683
 684         err = snd_usb_lock_shutdown(chip);
 685         if (err < 0)
 686                 goto err;
 687
 688         err = snd_mbox1_is_spdif_synced(chip);
 689         if (err < 0)
 690                 goto err;
 691
 692         kctl->private_value = err;
 693         err = 0;
 694         ucontrol->value.enumerated.item[0] = kctl->private_value;
 695 err:
 696         snd_usb_unlock_shutdown(chip);
 697         return err;
 698 }
 699
 700 static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync)
 701 {
 702         struct snd_usb_audio *chip = mixer->chip;
 703         int err;
 704
 705         err = snd_usb_lock_shutdown(chip);
 706         if (err < 0)
 707                 return err;
 708
 709         err = snd_mbox1_is_spdif_input(chip);
 710         if (err < 0)
 711                 goto err;
 712
 713         err = snd_mbox1_is_spdif_synced(chip);
 714         if (err < 0)
 715                 goto err;
 716
 717         /* FIXME: hardcoded sample rate */
 718         err = snd_mbox1_set_clk_source(chip, is_spdif_sync ? 0 : 48000);
 719         if (err < 0)
 720                 goto err;
 721
 722         err = snd_mbox1_is_spdif_synced(chip);
 723 err:
 724         snd_usb_unlock_shutdown(chip);
 725         return err;
 726 }
 727
 728 static int snd_mbox1_clk_switch_put(struct snd_kcontrol *kctl,
 729                                     struct snd_ctl_elem_value *ucontrol)
 730 {
 731         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 732         struct usb_mixer_interface *mixer = list->mixer;
 733         int err;
 734         bool cur_val, new_val;
 735
 736         cur_val = kctl->private_value;
 737         new_val = ucontrol->value.enumerated.item[0];
 738         if (cur_val == new_val)
 739                 return 0;
 740
 741         kctl->private_value = new_val;
 742         err = snd_mbox1_clk_switch_update(mixer, new_val);
 743         return err < 0 ? err : 1;
 744 }
 745
 746 static int snd_mbox1_clk_switch_info(struct snd_kcontrol *kcontrol,
 747                                      struct snd_ctl_elem_info *uinfo)
 748 {
 749         static const char *const texts[2] = {
 750                 "Internal",
 751                 "S/PDIF"
 752         };
 753
 754         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
 755 }
 756
 757 static int snd_mbox1_clk_switch_resume(struct usb_mixer_elem_list *list)
 758 {
 759         return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value);
 760 }
 761
 762 /* Digidesign Mbox 1 input source switch (analog/spdif) */
 763
 764 static int snd_mbox1_src_switch_get(struct snd_kcontrol *kctl,
 765                                     struct snd_ctl_elem_value *ucontrol)
 766 {
 767         ucontrol->value.enumerated.item[0] = kctl->private_value;
 768         return 0;
 769 }
 770
 771 static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input)
 772 {
 773         struct snd_usb_audio *chip = mixer->chip;
 774         int err;
 775
 776         err = snd_usb_lock_shutdown(chip);
 777         if (err < 0)
 778                 return err;
 779
 780         err = snd_mbox1_is_spdif_input(chip);
 781         if (err < 0)
 782                 goto err;
 783
 784         err = snd_mbox1_set_input_source(chip, is_spdif_input);
 785         if (err < 0)
 786                 goto err;
 787
 788         err = snd_mbox1_is_spdif_input(chip);
 789         if (err < 0)
 790                 goto err;
 791
 792         err = snd_mbox1_is_spdif_synced(chip);
 793 err:
 794         snd_usb_unlock_shutdown(chip);
 795         return err;
 796 }
 797
 798 static int snd_mbox1_src_switch_put(struct snd_kcontrol *kctl,
 799                                     struct snd_ctl_elem_value *ucontrol)
 800 {
 801         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 802         struct usb_mixer_interface *mixer = list->mixer;
 803         int err;
 804         bool cur_val, new_val;
 805
 806         cur_val = kctl->private_value;
 807         new_val = ucontrol->value.enumerated.item[0];
 808         if (cur_val == new_val)
 809                 return 0;
 810
 811         kctl->private_value = new_val;
 812         err = snd_mbox1_src_switch_update(mixer, new_val);
 813         return err < 0 ? err : 1;
 814 }
 815
 816 static int snd_mbox1_src_switch_info(struct snd_kcontrol *kcontrol,
 817                                      struct snd_ctl_elem_info *uinfo)
 818 {
 819         static const char *const texts[2] = {
 820                 "Analog",
 821                 "S/PDIF"
 822         };
 823
 824         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
 825 }
 826
 827 static int snd_mbox1_src_switch_resume(struct usb_mixer_elem_list *list)
 828 {
 829         return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value);
 830 }
 831
 832 static const struct snd_kcontrol_new snd_mbox1_clk_switch = {
 833         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 834         .name = "Clock Source",
 835         .index = 0,
 836         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 837         .info = snd_mbox1_clk_switch_info,
 838         .get = snd_mbox1_clk_switch_get,
 839         .put = snd_mbox1_clk_switch_put,
 840         .private_value = 0
 841 };
 842
 843 static const struct snd_kcontrol_new snd_mbox1_src_switch = {
 844         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 845         .name = "Input Source",
 846         .index = 1,
 847         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 848         .info = snd_mbox1_src_switch_info,
 849         .get = snd_mbox1_src_switch_get,
 850         .put = snd_mbox1_src_switch_put,
 851         .private_value = 0
 852 };
 853
 854 static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer)
 855 {
 856         int err;
 857         err = add_single_ctl_with_resume(mixer, 0,
 858                                          snd_mbox1_clk_switch_resume,
 859                                          &snd_mbox1_clk_switch, NULL);
 860         if (err < 0)
 861                 return err;
 862
 863         return add_single_ctl_with_resume(mixer, 1,
 864                                           snd_mbox1_src_switch_resume,
 865                                           &snd_mbox1_src_switch, NULL);
 866 }
 867
 868 /* Native Instruments device quirks */
 869
 870 #define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
 871
 872 static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
 873                                    struct snd_kcontrol *kctl)
 874 {
 875         struct usb_device *dev = mixer->chip->dev;
 876         unsigned int pval = kctl->private_value;
 877         u8 value;
 878         int err;
 879
 880         err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 881                               (pval >> 16) & 0xff,
 882                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 883                               0, pval & 0xffff, &value, 1);
 884         if (err < 0) {
 885                 dev_err(&dev->dev,
 886                         "unable to issue vendor read request (ret = %d)", err);
 887                 return err;
 888         }
 889
 890         kctl->private_value |= ((unsigned int)value << 24);
 891         return 0;
 892 }
 893
 894 static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
 895                                              struct snd_ctl_elem_value *ucontrol)
 896 {
 897         ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
 898         return 0;
 899 }
 900
 901 static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
 902 {
 903         struct snd_usb_audio *chip = list->mixer->chip;
 904         unsigned int pval = list->kctl->private_value;
 905         int err;
 906
 907         err = snd_usb_lock_shutdown(chip);
 908         if (err < 0)
 909                 return err;
 910         err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
 911                               (pval >> 16) & 0xff,
 912                               USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 913                               pval >> 24, pval & 0xffff, NULL, 0, 1000);
 914         snd_usb_unlock_shutdown(chip);
 915         return err;
 916 }
 917
 918 static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
 919                                              struct snd_ctl_elem_value *ucontrol)
 920 {
 921         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
 922         u8 oldval = (kcontrol->private_value >> 24) & 0xff;
 923         u8 newval = ucontrol->value.integer.value[0];
 924         int err;
 925
 926         if (oldval == newval)
 927                 return 0;
 928
 929         kcontrol->private_value &= ~(0xff << 24);
 930         kcontrol->private_value |= (unsigned int)newval << 24;
 931         err = snd_ni_update_cur_val(list);
 932         return err < 0 ? err : 1;
 933 }
 934
 935 static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
 936         {
 937                 .name = "Direct Thru Channel A",
 938                 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
 939         },
 940         {
 941                 .name = "Direct Thru Channel B",
 942                 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
 943         },
 944         {
 945                 .name = "Phono Input Channel A",
 946                 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
 947         },
 948         {
 949                 .name = "Phono Input Channel B",
 950                 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
 951         },
 952 };
 953
 954 static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
 955         {
 956                 .name = "Direct Thru Channel A",
 957                 .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
 958         },
 959         {
 960                 .name = "Direct Thru Channel B",
 961                 .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
 962         },
 963         {
 964                 .name = "Direct Thru Channel C",
 965                 .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
 966         },
 967         {
 968                 .name = "Direct Thru Channel D",
 969                 .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
 970         },
 971         {
 972                 .name = "Phono Input Channel A",
 973                 .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
 974         },
 975         {
 976                 .name = "Phono Input Channel B",
 977                 .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
 978         },
 979         {
 980                 .name = "Phono Input Channel C",
 981                 .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
 982         },
 983         {
 984                 .name = "Phono Input Channel D",
 985                 .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
 986         },
 987 };
 988
 989 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
 990                                               const struct snd_kcontrol_new *kc,
 991                                               unsigned int count)
 992 {
 993         int i, err = 0;
 994         struct snd_kcontrol_new template = {
 995                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 996                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 997                 .get = snd_nativeinstruments_control_get,
 998                 .put = snd_nativeinstruments_control_put,
 999                 .info = snd_ctl_boolean_mono_info,
1000         };
1001
1002         for (i = 0; i < count; i++) {
1003                 struct usb_mixer_elem_list *list;
1004
1005                 template.name = kc[i].name;
1006                 template.private_value = kc[i].private_value;
1007
1008                 err = add_single_ctl_with_resume(mixer, 0,
1009                                                  snd_ni_update_cur_val,
1010                                                  &template, &list);
1011                 if (err < 0)
1012                         break;
1013                 snd_ni_control_init_val(mixer, list->kctl);
1014         }
1015
1016         return err;
1017 }
1018
1019 /* M-Audio FastTrack Ultra quirks */
1020 /* FTU Effect switch (also used by C400/C600) */
1021 static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
1022                                         struct snd_ctl_elem_info *uinfo)
1023 {
1024         static const char *const texts[8] = {
1025                 "Room 1", "Room 2", "Room 3", "Hall 1",
1026                 "Hall 2", "Plate", "Delay", "Echo"
1027         };
1028
1029         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1030 }
1031
1032 static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
1033                                    struct snd_kcontrol *kctl)
1034 {
1035         struct usb_device *dev = mixer->chip->dev;
1036         unsigned int pval = kctl->private_value;
1037         int err;
1038         unsigned char value[2];
1039
1040         value[0] = 0x00;
1041         value[1] = 0x00;
1042
1043         err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
1044                               USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1045                               pval & 0xff00,
1046                               snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
1047                               value, 2);
1048         if (err < 0)
1049                 return err;
1050
1051         kctl->private_value |= (unsigned int)value[0] << 24;
1052         return 0;
1053 }
1054
1055 static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
1056                                         struct snd_ctl_elem_value *ucontrol)
1057 {
1058         ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
1059         return 0;
1060 }
1061
1062 static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
1063 {
1064         struct snd_usb_audio *chip = list->mixer->chip;
1065         unsigned int pval = list->kctl->private_value;
1066         unsigned char value[2];
1067         int err;
1068
1069         value[0] = pval >> 24;
1070         value[1] = 0;
1071
1072         err = snd_usb_lock_shutdown(chip);
1073         if (err < 0)
1074                 return err;
1075         err = snd_usb_ctl_msg(chip->dev,
1076                               usb_sndctrlpipe(chip->dev, 0),
1077                               UAC_SET_CUR,
1078                               USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1079                               pval & 0xff00,
1080                               snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
1081                               value, 2);
1082         snd_usb_unlock_shutdown(chip);
1083         return err;
1084 }
1085
1086 static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
1087                                         struct snd_ctl_elem_value *ucontrol)
1088 {
1089         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
1090         unsigned int pval = list->kctl->private_value;
1091         int cur_val, err, new_val;
1092
1093         cur_val = pval >> 24;
1094         new_val = ucontrol->value.enumerated.item[0];
1095         if (cur_val == new_val)
1096                 return 0;
1097
1098         kctl->private_value &= ~(0xff << 24);
1099         kctl->private_value |= new_val << 24;
1100         err = snd_ftu_eff_switch_update(list);
1101         return err < 0 ? err : 1;
1102 }
1103
1104 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
1105         int validx, int bUnitID)
1106 {
1107         static struct snd_kcontrol_new template = {
1108                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1109                 .name = "Effect Program Switch",
1110                 .index = 0,
1111                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1112                 .info = snd_ftu_eff_switch_info,
1113                 .get = snd_ftu_eff_switch_get,
1114                 .put = snd_ftu_eff_switch_put
1115         };
1116         struct usb_mixer_elem_list *list;
1117         int err;
1118
1119         err = add_single_ctl_with_resume(mixer, bUnitID,
1120                                          snd_ftu_eff_switch_update,
1121                                          &template, &list);
1122         if (err < 0)
1123                 return err;
1124         list->kctl->private_value = (validx << 8) | bUnitID;
1125         snd_ftu_eff_switch_init(mixer, list->kctl);
1126         return 0;
1127 }
1128
1129 /* Create volume controls for FTU devices*/
1130 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
1131 {
1132         char name[64];
1133         unsigned int control, cmask;
1134         int in, out, err;
1135
1136         const unsigned int id = 5;
1137         const int val_type = USB_MIXER_S16;
1138
1139         for (out = 0; out < 8; out++) {
1140                 control = out + 1;
1141                 for (in = 0; in < 8; in++) {
1142                         cmask = 1 << in;
1143                         snprintf(name, sizeof(name),
1144                                 "AIn%d - Out%d Capture Volume",
1145                                 in  + 1, out + 1);
1146                         err = snd_create_std_mono_ctl(mixer, id, control,
1147                                                         cmask, val_type, name,
1148                                                         &snd_usb_mixer_vol_tlv);
1149                         if (err < 0)
1150                                 return err;
1151                 }
1152                 for (in = 8; in < 16; in++) {
1153                         cmask = 1 << in;
1154                         snprintf(name, sizeof(name),
1155                                 "DIn%d - Out%d Playback Volume",
1156                                 in - 7, out + 1);
1157                         err = snd_create_std_mono_ctl(mixer, id, control,
1158                                                         cmask, val_type, name,
1159                                                         &snd_usb_mixer_vol_tlv);
1160                         if (err < 0)
1161                                 return err;
1162                 }
1163         }
1164
1165         return 0;
1166 }
1167
1168 /* This control needs a volume quirk, see mixer.c */
1169 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1170 {
1171         static const char name[] = "Effect Volume";
1172         const unsigned int id = 6;
1173         const int val_type = USB_MIXER_U8;
1174         const unsigned int control = 2;
1175         const unsigned int cmask = 0;
1176
1177         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1178                                         name, snd_usb_mixer_vol_tlv);
1179 }
1180
1181 /* This control needs a volume quirk, see mixer.c */
1182 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1183 {
1184         static const char name[] = "Effect Duration";
1185         const unsigned int id = 6;
1186         const int val_type = USB_MIXER_S16;
1187         const unsigned int control = 3;
1188         const unsigned int cmask = 0;
1189
1190         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1191                                         name, snd_usb_mixer_vol_tlv);
1192 }
1193
1194 /* This control needs a volume quirk, see mixer.c */
1195 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1196 {
1197         static const char name[] = "Effect Feedback Volume";
1198         const unsigned int id = 6;
1199         const int val_type = USB_MIXER_U8;
1200         const unsigned int control = 4;
1201         const unsigned int cmask = 0;
1202
1203         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1204                                         name, NULL);
1205 }
1206
1207 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1208 {
1209         unsigned int cmask;
1210         int err, ch;
1211         char name[48];
1212
1213         const unsigned int id = 7;
1214         const int val_type = USB_MIXER_S16;
1215         const unsigned int control = 7;
1216
1217         for (ch = 0; ch < 4; ++ch) {
1218                 cmask = 1 << ch;
1219                 snprintf(name, sizeof(name),
1220                         "Effect Return %d Volume", ch + 1);
1221                 err = snd_create_std_mono_ctl(mixer, id, control,
1222                                                 cmask, val_type, name,
1223                                                 snd_usb_mixer_vol_tlv);
1224                 if (err < 0)
1225                         return err;
1226         }
1227
1228         return 0;
1229 }
1230
1231 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1232 {
1233         unsigned int  cmask;
1234         int err, ch;
1235         char name[48];
1236
1237         const unsigned int id = 5;
1238         const int val_type = USB_MIXER_S16;
1239         const unsigned int control = 9;
1240
1241         for (ch = 0; ch < 8; ++ch) {
1242                 cmask = 1 << ch;
1243                 snprintf(name, sizeof(name),
1244                         "Effect Send AIn%d Volume", ch + 1);
1245                 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1246                                                 val_type, name,
1247                                                 snd_usb_mixer_vol_tlv);
1248                 if (err < 0)
1249                         return err;
1250         }
1251         for (ch = 8; ch < 16; ++ch) {
1252                 cmask = 1 << ch;
1253                 snprintf(name, sizeof(name),
1254                         "Effect Send DIn%d Volume", ch - 7);
1255                 err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1256                                                 val_type, name,
1257                                                 snd_usb_mixer_vol_tlv);
1258                 if (err < 0)
1259                         return err;
1260         }
1261         return 0;
1262 }
1263
1264 static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1265 {
1266         int err;
1267
1268         err = snd_ftu_create_volume_ctls(mixer);
1269         if (err < 0)
1270                 return err;
1271
1272         err = snd_ftu_create_effect_switch(mixer, 1, 6);
1273         if (err < 0)
1274                 return err;
1275
1276         err = snd_ftu_create_effect_volume_ctl(mixer);
1277         if (err < 0)
1278                 return err;
1279
1280         err = snd_ftu_create_effect_duration_ctl(mixer);
1281         if (err < 0)
1282                 return err;
1283
1284         err = snd_ftu_create_effect_feedback_ctl(mixer);
1285         if (err < 0)
1286                 return err;
1287
1288         err = snd_ftu_create_effect_return_ctls(mixer);
1289         if (err < 0)
1290                 return err;
1291
1292         err = snd_ftu_create_effect_send_ctls(mixer);
1293         if (err < 0)
1294                 return err;
1295
1296         return 0;
1297 }
1298
1299 void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1300                                unsigned char samplerate_id)
1301 {
1302         struct usb_mixer_interface *mixer;
1303         struct usb_mixer_elem_info *cval;
1304         int unitid = 12; /* SampleRate ExtensionUnit ID */
1305
1306         list_for_each_entry(mixer, &chip->mixer_list, list) {
1307                 if (mixer->id_elems[unitid]) {
1308                         cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1309                         snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1310                                                     cval->control << 8,
1311                                                     samplerate_id);
1312                         snd_usb_mixer_notify_id(mixer, unitid);
1313                         break;
1314                 }
1315         }
1316 }
1317
1318 /* M-Audio Fast Track C400/C600 */
1319 /* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1320 static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1321 {
1322         char name[64];
1323         unsigned int cmask, offset;
1324         int out, chan, err;
1325         int num_outs = 0;
1326         int num_ins = 0;
1327
1328         const unsigned int id = 0x40;
1329         const int val_type = USB_MIXER_S16;
1330         const int control = 1;
1331
1332         switch (mixer->chip->usb_id) {
1333         case USB_ID(0x0763, 0x2030):
1334                 num_outs = 6;
1335                 num_ins = 4;
1336                 break;
1337         case USB_ID(0x0763, 0x2031):
1338                 num_outs = 8;
1339                 num_ins = 6;
1340                 break;
1341         }
1342
1343         for (chan = 0; chan < num_outs + num_ins; chan++) {
1344                 for (out = 0; out < num_outs; out++) {
1345                         if (chan < num_outs) {
1346                                 snprintf(name, sizeof(name),
1347                                         "PCM%d-Out%d Playback Volume",
1348                                         chan + 1, out + 1);
1349                         } else {
1350                                 snprintf(name, sizeof(name),
1351                                         "In%d-Out%d Playback Volume",
1352                                         chan - num_outs + 1, out + 1);
1353                         }
1354
1355                         cmask = (out == 0) ? 0 : 1 << (out - 1);
1356                         offset = chan * num_outs;
1357                         err = snd_create_std_mono_ctl_offset(mixer, id, control,
1358                                                 cmask, val_type, offset, name,
1359                                                 &snd_usb_mixer_vol_tlv);
1360                         if (err < 0)
1361                                 return err;
1362                 }
1363         }
1364
1365         return 0;
1366 }
1367
1368 /* This control needs a volume quirk, see mixer.c */
1369 static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1370 {
1371         static const char name[] = "Effect Volume";
1372         const unsigned int id = 0x43;
1373         const int val_type = USB_MIXER_U8;
1374         const unsigned int control = 3;
1375         const unsigned int cmask = 0;
1376
1377         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1378                                         name, snd_usb_mixer_vol_tlv);
1379 }
1380
1381 /* This control needs a volume quirk, see mixer.c */
1382 static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1383 {
1384         static const char name[] = "Effect Duration";
1385         const unsigned int id = 0x43;
1386         const int val_type = USB_MIXER_S16;
1387         const unsigned int control = 4;
1388         const unsigned int cmask = 0;
1389
1390         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1391                                         name, snd_usb_mixer_vol_tlv);
1392 }
1393
1394 /* This control needs a volume quirk, see mixer.c */
1395 static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1396 {
1397         static const char name[] = "Effect Feedback Volume";
1398         const unsigned int id = 0x43;
1399         const int val_type = USB_MIXER_U8;
1400         const unsigned int control = 5;
1401         const unsigned int cmask = 0;
1402
1403         return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1404                                         name, NULL);
1405 }
1406
1407 static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1408 {
1409         char name[64];
1410         unsigned int cmask;
1411         int chan, err;
1412         int num_outs = 0;
1413         int num_ins = 0;
1414
1415         const unsigned int id = 0x42;
1416         const int val_type = USB_MIXER_S16;
1417         const int control = 1;
1418
1419         switch (mixer->chip->usb_id) {
1420         case USB_ID(0x0763, 0x2030):
1421                 num_outs = 6;
1422                 num_ins = 4;
1423                 break;
1424         case USB_ID(0x0763, 0x2031):
1425                 num_outs = 8;
1426                 num_ins = 6;
1427                 break;
1428         }
1429
1430         for (chan = 0; chan < num_outs + num_ins; chan++) {
1431                 if (chan < num_outs) {
1432                         snprintf(name, sizeof(name),
1433                                 "Effect Send DOut%d",
1434                                 chan + 1);
1435                 } else {
1436                         snprintf(name, sizeof(name),
1437                                 "Effect Send AIn%d",
1438                                 chan - num_outs + 1);
1439                 }
1440
1441                 cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1442                 err = snd_create_std_mono_ctl(mixer, id, control,
1443                                                 cmask, val_type, name,
1444                                                 &snd_usb_mixer_vol_tlv);
1445                 if (err < 0)
1446                         return err;
1447         }
1448
1449         return 0;
1450 }
1451
1452 static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1453 {
1454         char name[64];
1455         unsigned int cmask;
1456         int chan, err;
1457         int num_outs = 0;
1458         int offset = 0;
1459
1460         const unsigned int id = 0x40;
1461         const int val_type = USB_MIXER_S16;
1462         const int control = 1;
1463
1464         switch (mixer->chip->usb_id) {
1465         case USB_ID(0x0763, 0x2030):
1466                 num_outs = 6;
1467                 offset = 0x3c;
1468                 /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1469                 break;
1470         case USB_ID(0x0763, 0x2031):
1471                 num_outs = 8;
1472                 offset = 0x70;
1473                 /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1474                 break;
1475         }
1476
1477         for (chan = 0; chan < num_outs; chan++) {
1478                 snprintf(name, sizeof(name),
1479                         "Effect Return %d",
1480                         chan + 1);
1481
1482                 cmask = (chan == 0) ? 0 :
1483                         1 << (chan + (chan % 2) * num_outs - 1);
1484                 err = snd_create_std_mono_ctl_offset(mixer, id, control,
1485                                                 cmask, val_type, offset, name,
1486                                                 &snd_usb_mixer_vol_tlv);
1487                 if (err < 0)
1488                         return err;
1489         }
1490
1491         return 0;
1492 }
1493
1494 static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1495 {
1496         int err;
1497
1498         err = snd_c400_create_vol_ctls(mixer);
1499         if (err < 0)
1500                 return err;
1501
1502         err = snd_c400_create_effect_vol_ctls(mixer);
1503         if (err < 0)
1504                 return err;
1505
1506         err = snd_c400_create_effect_ret_vol_ctls(mixer);
1507         if (err < 0)
1508                 return err;
1509
1510         err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1511         if (err < 0)
1512                 return err;
1513
1514         err = snd_c400_create_effect_volume_ctl(mixer);
1515         if (err < 0)
1516                 return err;
1517
1518         err = snd_c400_create_effect_duration_ctl(mixer);
1519         if (err < 0)
1520                 return err;
1521
1522         err = snd_c400_create_effect_feedback_ctl(mixer);
1523         if (err < 0)
1524                 return err;
1525
1526         return 0;
1527 }
1528
1529 /*
1530  * The mixer units for Ebox-44 are corrupt, and even where they
1531  * are valid they presents mono controls as L and R channels of
1532  * stereo. So we provide a good mixer here.
1533  */
1534 static const struct std_mono_table ebox44_table[] = {
1535         {
1536                 .unitid = 4,
1537                 .control = 1,
1538                 .cmask = 0x0,
1539                 .val_type = USB_MIXER_INV_BOOLEAN,
1540                 .name = "Headphone Playback Switch"
1541         },
1542         {
1543                 .unitid = 4,
1544                 .control = 2,
1545                 .cmask = 0x1,
1546                 .val_type = USB_MIXER_S16,
1547                 .name = "Headphone A Mix Playback Volume"
1548         },
1549         {
1550                 .unitid = 4,
1551                 .control = 2,
1552                 .cmask = 0x2,
1553                 .val_type = USB_MIXER_S16,
1554                 .name = "Headphone B Mix Playback Volume"
1555         },
1556
1557         {
1558                 .unitid = 7,
1559                 .control = 1,
1560                 .cmask = 0x0,
1561                 .val_type = USB_MIXER_INV_BOOLEAN,
1562                 .name = "Output Playback Switch"
1563         },
1564         {
1565                 .unitid = 7,
1566                 .control = 2,
1567                 .cmask = 0x1,
1568                 .val_type = USB_MIXER_S16,
1569                 .name = "Output A Playback Volume"
1570         },
1571         {
1572                 .unitid = 7,
1573                 .control = 2,
1574                 .cmask = 0x2,
1575                 .val_type = USB_MIXER_S16,
1576                 .name = "Output B Playback Volume"
1577         },
1578
1579         {
1580                 .unitid = 10,
1581                 .control = 1,
1582                 .cmask = 0x0,
1583                 .val_type = USB_MIXER_INV_BOOLEAN,
1584                 .name = "Input Capture Switch"
1585         },
1586         {
1587                 .unitid = 10,
1588                 .control = 2,
1589                 .cmask = 0x1,
1590                 .val_type = USB_MIXER_S16,
1591                 .name = "Input A Capture Volume"
1592         },
1593         {
1594                 .unitid = 10,
1595                 .control = 2,
1596                 .cmask = 0x2,
1597                 .val_type = USB_MIXER_S16,
1598                 .name = "Input B Capture Volume"
1599         },
1600
1601         {}
1602 };
1603
1604 /* Audio Advantage Micro II findings:
1605  *
1606  * Mapping spdif AES bits to vendor register.bit:
1607  * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1608  * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1609  * AES2: [0 0 0 0 0 0 0 0]
1610  * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1611  *                           (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1612  *
1613  * power on values:
1614  * r2: 0x10
1615  * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1616  *           just after it to 0xa0, presumably it disables/mutes some analog
1617  *           parts when there is no audio.)
1618  * r9: 0x28
1619  *
1620  * Optical transmitter on/off:
1621  * vendor register.bit: 9.1
1622  * 0 - on (0x28 register value)
1623  * 1 - off (0x2a register value)
1624  *
1625  */
1626 static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1627         struct snd_ctl_elem_info *uinfo)
1628 {
1629         uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1630         uinfo->count = 1;
1631         return 0;
1632 }
1633
1634 static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1635         struct snd_ctl_elem_value *ucontrol)
1636 {
1637         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1638         struct snd_usb_audio *chip = list->mixer->chip;
1639         int err;
1640         struct usb_interface *iface;
1641         struct usb_host_interface *alts;
1642         unsigned int ep;
1643         unsigned char data[3];
1644         int rate;
1645
1646         err = snd_usb_lock_shutdown(chip);
1647         if (err < 0)
1648                 return err;
1649
1650         ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1651         ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1652         ucontrol->value.iec958.status[2] = 0x00;
1653
1654         /* use known values for that card: interface#1 altsetting#1 */
1655         iface = usb_ifnum_to_if(chip->dev, 1);
1656         if (!iface || iface->num_altsetting < 2) {
1657                 err = -EINVAL;
1658                 goto end;
1659         }
1660         alts = &iface->altsetting[1];
1661         if (get_iface_desc(alts)->bNumEndpoints < 1) {
1662                 err = -EINVAL;
1663                 goto end;
1664         }
1665         ep = get_endpoint(alts, 0)->bEndpointAddress;
1666
1667         err = snd_usb_ctl_msg(chip->dev,
1668                         usb_rcvctrlpipe(chip->dev, 0),
1669                         UAC_GET_CUR,
1670                         USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1671                         UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1672                         ep,
1673                         data,
1674                         sizeof(data));
1675         if (err < 0)
1676                 goto end;
1677
1678         rate = data[0] | (data[1] << 8) | (data[2] << 16);
1679         ucontrol->value.iec958.status[3] = (rate == 48000) ?
1680                         IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1681
1682         err = 0;
1683  end:
1684         snd_usb_unlock_shutdown(chip);
1685         return err;
1686 }
1687
1688 static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1689 {
1690         struct snd_usb_audio *chip = list->mixer->chip;
1691         unsigned int pval = list->kctl->private_value;
1692         u8 reg;
1693         int err;
1694
1695         err = snd_usb_lock_shutdown(chip);
1696         if (err < 0)
1697                 return err;
1698
1699         reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1700         err = snd_usb_ctl_msg(chip->dev,
1701                         usb_sndctrlpipe(chip->dev, 0),
1702                         UAC_SET_CUR,
1703                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1704                         reg,
1705                         2,
1706                         NULL,
1707                         0);
1708         if (err < 0)
1709                 goto end;
1710
1711         reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1712         reg |= (pval >> 12) & 0x0f;
1713         err = snd_usb_ctl_msg(chip->dev,
1714                         usb_sndctrlpipe(chip->dev, 0),
1715                         UAC_SET_CUR,
1716                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1717                         reg,
1718                         3,
1719                         NULL,
1720                         0);
1721         if (err < 0)
1722                 goto end;
1723
1724  end:
1725         snd_usb_unlock_shutdown(chip);
1726         return err;
1727 }
1728
1729 static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1730         struct snd_ctl_elem_value *ucontrol)
1731 {
1732         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1733         unsigned int pval, pval_old;
1734         int err;
1735
1736         pval = pval_old = kcontrol->private_value;
1737         pval &= 0xfffff0f0;
1738         pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1739         pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1740
1741         pval &= 0xffff0fff;
1742         pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1743
1744         /* The frequency bits in AES3 cannot be set via register access. */
1745
1746         /* Silently ignore any bits from the request that cannot be set. */
1747
1748         if (pval == pval_old)
1749                 return 0;
1750
1751         kcontrol->private_value = pval;
1752         err = snd_microii_spdif_default_update(list);
1753         return err < 0 ? err : 1;
1754 }
1755
1756 static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1757         struct snd_ctl_elem_value *ucontrol)
1758 {
1759         ucontrol->value.iec958.status[0] = 0x0f;
1760         ucontrol->value.iec958.status[1] = 0xff;
1761         ucontrol->value.iec958.status[2] = 0x00;
1762         ucontrol->value.iec958.status[3] = 0x00;
1763
1764         return 0;
1765 }
1766
1767 static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1768         struct snd_ctl_elem_value *ucontrol)
1769 {
1770         ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1771
1772         return 0;
1773 }
1774
1775 static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1776 {
1777         struct snd_usb_audio *chip = list->mixer->chip;
1778         u8 reg = list->kctl->private_value;
1779         int err;
1780
1781         err = snd_usb_lock_shutdown(chip);
1782         if (err < 0)
1783                 return err;
1784
1785         err = snd_usb_ctl_msg(chip->dev,
1786                         usb_sndctrlpipe(chip->dev, 0),
1787                         UAC_SET_CUR,
1788                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1789                         reg,
1790                         9,
1791                         NULL,
1792                         0);
1793
1794         snd_usb_unlock_shutdown(chip);
1795         return err;
1796 }
1797
1798 static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1799         struct snd_ctl_elem_value *ucontrol)
1800 {
1801         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1802         u8 reg;
1803         int err;
1804
1805         reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1806         if (reg != list->kctl->private_value)
1807                 return 0;
1808
1809         kcontrol->private_value = reg;
1810         err = snd_microii_spdif_switch_update(list);
1811         return err < 0 ? err : 1;
1812 }
1813
1814 static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1815         {
1816                 .iface =    SNDRV_CTL_ELEM_IFACE_PCM,
1817                 .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1818                 .info =     snd_microii_spdif_info,
1819                 .get =      snd_microii_spdif_default_get,
1820                 .put =      snd_microii_spdif_default_put,
1821                 .private_value = 0x00000100UL,/* reset value */
1822         },
1823         {
1824                 .access =   SNDRV_CTL_ELEM_ACCESS_READ,
1825                 .iface =    SNDRV_CTL_ELEM_IFACE_PCM,
1826                 .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1827                 .info =     snd_microii_spdif_info,
1828                 .get =      snd_microii_spdif_mask_get,
1829         },
1830         {
1831                 .iface =    SNDRV_CTL_ELEM_IFACE_MIXER,
1832                 .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1833                 .info =     snd_ctl_boolean_mono_info,
1834                 .get =      snd_microii_spdif_switch_get,
1835                 .put =      snd_microii_spdif_switch_put,
1836                 .private_value = 0x00000028UL,/* reset value */
1837         }
1838 };
1839
1840 static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1841 {
1842         int err, i;
1843         static const usb_mixer_elem_resume_func_t resume_funcs[] = {
1844                 snd_microii_spdif_default_update,
1845                 NULL,
1846                 snd_microii_spdif_switch_update
1847         };
1848
1849         for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1850                 err = add_single_ctl_with_resume(mixer, 0,
1851                                                  resume_funcs[i],
1852                                                  &snd_microii_mixer_spdif[i],
1853                                                  NULL);
1854                 if (err < 0)
1855                         return err;
1856         }
1857
1858         return 0;
1859 }
1860
1861 /* Creative Sound Blaster E1 */
1862
1863 static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1864                                           struct snd_ctl_elem_value *ucontrol)
1865 {
1866         ucontrol->value.integer.value[0] = kcontrol->private_value;
1867         return 0;
1868 }
1869
1870 static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1871                                              unsigned char state)
1872 {
1873         struct snd_usb_audio *chip = mixer->chip;
1874         int err;
1875         unsigned char buff[2];
1876
1877         buff[0] = 0x02;
1878         buff[1] = state ? 0x02 : 0x00;
1879
1880         err = snd_usb_lock_shutdown(chip);
1881         if (err < 0)
1882                 return err;
1883         err = snd_usb_ctl_msg(chip->dev,
1884                         usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1885                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1886                         0x0202, 3, buff, 2);
1887         snd_usb_unlock_shutdown(chip);
1888         return err;
1889 }
1890
1891 static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1892                                           struct snd_ctl_elem_value *ucontrol)
1893 {
1894         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1895         unsigned char value = !!ucontrol->value.integer.value[0];
1896         int err;
1897
1898         if (kcontrol->private_value == value)
1899                 return 0;
1900         kcontrol->private_value = value;
1901         err = snd_soundblaster_e1_switch_update(list->mixer, value);
1902         return err < 0 ? err : 1;
1903 }
1904
1905 static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1906 {
1907         return snd_soundblaster_e1_switch_update(list->mixer,
1908                                                  list->kctl->private_value);
1909 }
1910
1911 static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1912                                            struct snd_ctl_elem_info *uinfo)
1913 {
1914         static const char *const texts[2] = {
1915                 "Mic", "Aux"
1916         };
1917
1918         return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1919 }
1920
1921 static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1922         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1923         .name = "Input Source",
1924         .info = snd_soundblaster_e1_switch_info,
1925         .get = snd_soundblaster_e1_switch_get,
1926         .put = snd_soundblaster_e1_switch_put,
1927         .private_value = 0,
1928 };
1929
1930 static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1931 {
1932         return add_single_ctl_with_resume(mixer, 0,
1933                                           snd_soundblaster_e1_switch_resume,
1934                                           &snd_soundblaster_e1_input_switch,
1935                                           NULL);
1936 }
1937
1938 /*
1939  * Dell WD15 dock jack detection
1940  *
1941  * The WD15 contains an ALC4020 USB audio controller and ALC3263 audio codec
1942  * from Realtek. It is a UAC 1 device, and UAC 1 does not support jack
1943  * detection. Instead, jack detection works by sending HD Audio commands over
1944  * vendor-type USB messages.
1945  */
1946
1947 #define HDA_VERB_CMD(V, N, D) (((N) << 20) | ((V) << 8) | (D))
1948
1949 #define REALTEK_HDA_VALUE 0x0038
1950
1951 #define REALTEK_HDA_SET         62
1952 #define REALTEK_MANUAL_MODE     72
1953 #define REALTEK_HDA_GET_OUT     88
1954 #define REALTEK_HDA_GET_IN      89
1955
1956 #define REALTEK_AUDIO_FUNCTION_GROUP    0x01
1957 #define REALTEK_LINE1                   0x1a
1958 #define REALTEK_VENDOR_REGISTERS        0x20
1959 #define REALTEK_HP_OUT                  0x21
1960
1961 #define REALTEK_CBJ_CTRL2 0x50
1962
1963 #define REALTEK_JACK_INTERRUPT_NODE 5
1964
1965 #define REALTEK_MIC_FLAG 0x100
1966
1967 static int realtek_hda_set(struct snd_usb_audio *chip, u32 cmd)
1968 {
1969         struct usb_device *dev = chip->dev;
1970         __be32 buf = cpu_to_be32(cmd);
1971
1972         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_SET,
1973                                USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
1974                                REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1975 }
1976
1977 static int realtek_hda_get(struct snd_usb_audio *chip, u32 cmd, u32 *value)
1978 {
1979         struct usb_device *dev = chip->dev;
1980         int err;
1981         __be32 buf = cpu_to_be32(cmd);
1982
1983         err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_HDA_GET_OUT,
1984                               USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
1985                               REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1986         if (err < 0)
1987                 return err;
1988         err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), REALTEK_HDA_GET_IN,
1989                               USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_IN,
1990                               REALTEK_HDA_VALUE, 0, &buf, sizeof(buf));
1991         if (err < 0)
1992                 return err;
1993
1994         *value = be32_to_cpu(buf);
1995         return 0;
1996 }
1997
1998 static int realtek_ctl_connector_get(struct snd_kcontrol *kcontrol,
1999                                      struct snd_ctl_elem_value *ucontrol)
2000 {
2001         struct usb_mixer_elem_info *cval = kcontrol->private_data;
2002         struct snd_usb_audio *chip = cval->head.mixer->chip;
2003         u32 pv = kcontrol->private_value;
2004         u32 node_id = pv & 0xff;
2005         u32 sense;
2006         u32 cbj_ctrl2;
2007         bool presence;
2008         int err;
2009
2010         err = snd_usb_lock_shutdown(chip);
2011         if (err < 0)
2012                 return err;
2013         err = realtek_hda_get(chip,
2014                               HDA_VERB_CMD(AC_VERB_GET_PIN_SENSE, node_id, 0),
2015                               &sense);
2016         if (err < 0)
2017                 goto err;
2018         if (pv & REALTEK_MIC_FLAG) {
2019                 err = realtek_hda_set(chip,
2020                                       HDA_VERB_CMD(AC_VERB_SET_COEF_INDEX,
2021                                                    REALTEK_VENDOR_REGISTERS,
2022                                                    REALTEK_CBJ_CTRL2));
2023                 if (err < 0)
2024                         goto err;
2025                 err = realtek_hda_get(chip,
2026                                       HDA_VERB_CMD(AC_VERB_GET_PROC_COEF,
2027                                                    REALTEK_VENDOR_REGISTERS, 0),
2028                                       &cbj_ctrl2);
2029                 if (err < 0)
2030                         goto err;
2031         }
2032 err:
2033         snd_usb_unlock_shutdown(chip);
2034         if (err < 0)
2035                 return err;
2036
2037         presence = sense & AC_PINSENSE_PRESENCE;
2038         if (pv & REALTEK_MIC_FLAG)
2039                 presence = presence && (cbj_ctrl2 & 0x0070) == 0x0070;
2040         ucontrol->value.integer.value[0] = presence;
2041         return 0;
2042 }
2043
2044 static const struct snd_kcontrol_new realtek_connector_ctl_ro = {
2045         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
2046         .name = "", /* will be filled later manually */
2047         .access = SNDRV_CTL_ELEM_ACCESS_READ,
2048         .info = snd_ctl_boolean_mono_info,
2049         .get = realtek_ctl_connector_get,
2050 };
2051
2052 static int realtek_resume_jack(struct usb_mixer_elem_list *list)
2053 {
2054         snd_ctl_notify(list->mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
2055                        &list->kctl->id);
2056         return 0;
2057 }
2058
2059 static int realtek_add_jack(struct usb_mixer_interface *mixer,
2060                             char *name, u32 val)
2061 {
2062         struct usb_mixer_elem_info *cval;
2063         struct snd_kcontrol *kctl;
2064
2065         cval = kzalloc(sizeof(*cval), GFP_KERNEL);
2066         if (!cval)
2067                 return -ENOMEM;
2068         snd_usb_mixer_elem_init_std(&cval->head, mixer,
2069                                     REALTEK_JACK_INTERRUPT_NODE);
2070         cval->head.resume = realtek_resume_jack;
2071         cval->val_type = USB_MIXER_BOOLEAN;
2072         cval->channels = 1;
2073         cval->min = 0;
2074         cval->max = 1;
2075         kctl = snd_ctl_new1(&realtek_connector_ctl_ro, cval);
2076         if (!kctl) {
2077                 kfree(cval);
2078                 return -ENOMEM;
2079         }
2080         kctl->private_value = val;
2081         strscpy(kctl->id.name, name, sizeof(kctl->id.name));
2082         kctl->private_free = snd_usb_mixer_elem_free;
2083         return snd_usb_mixer_add_control(&cval->head, kctl);
2084 }
2085
2086 static int dell_dock_mixer_create(struct usb_mixer_interface *mixer)
2087 {
2088         int err;
2089         struct usb_device *dev = mixer->chip->dev;
2090
2091         /* Power down the audio codec to avoid loud pops in the next step. */
2092         realtek_hda_set(mixer->chip,
2093                         HDA_VERB_CMD(AC_VERB_SET_POWER_STATE,
2094                                      REALTEK_AUDIO_FUNCTION_GROUP,
2095                                      AC_PWRST_D3));
2096
2097         /*
2098          * Turn off 'manual mode' in case it was enabled. This removes the need
2099          * to power cycle the dock after it was attached to a Windows machine.
2100          */
2101         snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), REALTEK_MANUAL_MODE,
2102                         USB_RECIP_DEVICE | USB_TYPE_VENDOR | USB_DIR_OUT,
2103                         0, 0, NULL, 0);
2104
2105         err = realtek_add_jack(mixer, "Line Out Jack", REALTEK_LINE1);
2106         if (err < 0)
2107                 return err;
2108         err = realtek_add_jack(mixer, "Headphone Jack", REALTEK_HP_OUT);
2109         if (err < 0)
2110                 return err;
2111         err = realtek_add_jack(mixer, "Headset Mic Jack",
2112                                REALTEK_HP_OUT | REALTEK_MIC_FLAG);
2113         if (err < 0)
2114                 return err;
2115         return 0;
2116 }
2117
2118 static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id)
2119 {
2120         u16 buf = 0;
2121
2122         snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
2123                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
2124                         (UAC_FU_VOLUME << 8) | ch,
2125                         snd_usb_ctrl_intf(chip) | (id << 8),
2126                         &buf, 2);
2127 }
2128
2129 static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
2130 {
2131         /* fix to 0dB playback volumes */
2132         dell_dock_init_vol(mixer->chip, 1, 16);
2133         dell_dock_init_vol(mixer->chip, 2, 16);
2134         dell_dock_init_vol(mixer->chip, 1, 19);
2135         dell_dock_init_vol(mixer->chip, 2, 19);
2136         return 0;
2137 }
2138
2139 /* RME Class Compliant device quirks */
2140
2141 #define SND_RME_GET_STATUS1                     23
2142 #define SND_RME_GET_CURRENT_FREQ                17
2143 #define SND_RME_CLK_SYSTEM_SHIFT                16
2144 #define SND_RME_CLK_SYSTEM_MASK                 0x1f
2145 #define SND_RME_CLK_AES_SHIFT                   8
2146 #define SND_RME_CLK_SPDIF_SHIFT                 12
2147 #define SND_RME_CLK_AES_SPDIF_MASK              0xf
2148 #define SND_RME_CLK_SYNC_SHIFT                  6
2149 #define SND_RME_CLK_SYNC_MASK                   0x3
2150 #define SND_RME_CLK_FREQMUL_SHIFT               18
2151 #define SND_RME_CLK_FREQMUL_MASK                0x7
2152 #define SND_RME_CLK_SYSTEM(x) \
2153         ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
2154 #define SND_RME_CLK_AES(x) \
2155         ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
2156 #define SND_RME_CLK_SPDIF(x) \
2157         ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
2158 #define SND_RME_CLK_SYNC(x) \
2159         ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
2160 #define SND_RME_CLK_FREQMUL(x) \
2161         ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
2162 #define SND_RME_CLK_AES_LOCK                    0x1
2163 #define SND_RME_CLK_AES_SYNC                    0x4
2164 #define SND_RME_CLK_SPDIF_LOCK                  0x2
2165 #define SND_RME_CLK_SPDIF_SYNC                  0x8
2166 #define SND_RME_SPDIF_IF_SHIFT                  4
2167 #define SND_RME_SPDIF_FORMAT_SHIFT              5
2168 #define SND_RME_BINARY_MASK                     0x1
2169 #define SND_RME_SPDIF_IF(x) \
2170         ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
2171 #define SND_RME_SPDIF_FORMAT(x) \
2172         ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
2173
2174 static const u32 snd_rme_rate_table[] = {
2175         32000, 44100, 48000, 50000,
2176         64000, 88200, 96000, 100000,
2177         128000, 176400, 192000, 200000,
2178         256000, 352800, 384000, 400000,
2179         512000, 705600, 768000, 800000
2180 };
2181 /* maximum number of items for AES and S/PDIF rates for above table */
2182 #define SND_RME_RATE_IDX_AES_SPDIF_NUM          12
2183
2184 enum snd_rme_domain {
2185         SND_RME_DOMAIN_SYSTEM,
2186         SND_RME_DOMAIN_AES,
2187         SND_RME_DOMAIN_SPDIF
2188 };
2189
2190 enum snd_rme_clock_status {
2191         SND_RME_CLOCK_NOLOCK,
2192         SND_RME_CLOCK_LOCK,
2193         SND_RME_CLOCK_SYNC
2194 };
2195
2196 static int snd_rme_read_value(struct snd_usb_audio *chip,
2197                               unsigned int item,
2198                               u32 *value)
2199 {
2200         struct usb_device *dev = chip->dev;
2201         int err;
2202
2203         err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
2204                               item,
2205                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2206                               0, 0,
2207                               value, sizeof(*value));
2208         if (err < 0)
2209                 dev_err(&dev->dev,
2210                         "unable to issue vendor read request %d (ret = %d)",
2211                         item, err);
2212         return err;
2213 }
2214
2215 static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
2216                                u32 *status1)
2217 {
2218         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2219         struct snd_usb_audio *chip = list->mixer->chip;
2220         int err;
2221
2222         err = snd_usb_lock_shutdown(chip);
2223         if (err < 0)
2224                 return err;
2225         err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
2226         snd_usb_unlock_shutdown(chip);
2227         return err;
2228 }
2229
2230 static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
2231                             struct snd_ctl_elem_value *ucontrol)
2232 {
2233         u32 status1;
2234         u32 rate = 0;
2235         int idx;
2236         int err;
2237
2238         err = snd_rme_get_status1(kcontrol, &status1);
2239         if (err < 0)
2240                 return err;
2241         switch (kcontrol->private_value) {
2242         case SND_RME_DOMAIN_SYSTEM:
2243                 idx = SND_RME_CLK_SYSTEM(status1);
2244                 if (idx < ARRAY_SIZE(snd_rme_rate_table))
2245                         rate = snd_rme_rate_table[idx];
2246                 break;
2247         case SND_RME_DOMAIN_AES:
2248                 idx = SND_RME_CLK_AES(status1);
2249                 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2250                         rate = snd_rme_rate_table[idx];
2251                 break;
2252         case SND_RME_DOMAIN_SPDIF:
2253                 idx = SND_RME_CLK_SPDIF(status1);
2254                 if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2255                         rate = snd_rme_rate_table[idx];
2256                 break;
2257         default:
2258                 return -EINVAL;
2259         }
2260         ucontrol->value.integer.value[0] = rate;
2261         return 0;
2262 }
2263
2264 static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
2265                                   struct snd_ctl_elem_value *ucontrol)
2266 {
2267         u32 status1;
2268         int idx = SND_RME_CLOCK_NOLOCK;
2269         int err;
2270
2271         err = snd_rme_get_status1(kcontrol, &status1);
2272         if (err < 0)
2273                 return err;
2274         switch (kcontrol->private_value) {
2275         case SND_RME_DOMAIN_AES:  /* AES */
2276                 if (status1 & SND_RME_CLK_AES_SYNC)
2277                         idx = SND_RME_CLOCK_SYNC;
2278                 else if (status1 & SND_RME_CLK_AES_LOCK)
2279                         idx = SND_RME_CLOCK_LOCK;
2280                 break;
2281         case SND_RME_DOMAIN_SPDIF:  /* SPDIF */
2282                 if (status1 & SND_RME_CLK_SPDIF_SYNC)
2283                         idx = SND_RME_CLOCK_SYNC;
2284                 else if (status1 & SND_RME_CLK_SPDIF_LOCK)
2285                         idx = SND_RME_CLOCK_LOCK;
2286                 break;
2287         default:
2288                 return -EINVAL;
2289         }
2290         ucontrol->value.enumerated.item[0] = idx;
2291         return 0;
2292 }
2293
2294 static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
2295                                 struct snd_ctl_elem_value *ucontrol)
2296 {
2297         u32 status1;
2298         int err;
2299
2300         err = snd_rme_get_status1(kcontrol, &status1);
2301         if (err < 0)
2302                 return err;
2303         ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
2304         return 0;
2305 }
2306
2307 static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
2308                                     struct snd_ctl_elem_value *ucontrol)
2309 {
2310         u32 status1;
2311         int err;
2312
2313         err = snd_rme_get_status1(kcontrol, &status1);
2314         if (err < 0)
2315                 return err;
2316         ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
2317         return 0;
2318 }
2319
2320 static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
2321                                    struct snd_ctl_elem_value *ucontrol)
2322 {
2323         u32 status1;
2324         int err;
2325
2326         err = snd_rme_get_status1(kcontrol, &status1);
2327         if (err < 0)
2328                 return err;
2329         ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2330         return 0;
2331 }
2332
2333 static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2334                                     struct snd_ctl_elem_value *ucontrol)
2335 {
2336         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2337         struct snd_usb_audio *chip = list->mixer->chip;
2338         u32 status1;
2339         const u64 num = 104857600000000ULL;
2340         u32 den;
2341         unsigned int freq;
2342         int err;
2343
2344         err = snd_usb_lock_shutdown(chip);
2345         if (err < 0)
2346                 return err;
2347         err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2348         if (err < 0)
2349                 goto end;
2350         err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2351         if (err < 0)
2352                 goto end;
2353         freq = (den == 0) ? 0 : div64_u64(num, den);
2354         freq <<= SND_RME_CLK_FREQMUL(status1);
2355         ucontrol->value.integer.value[0] = freq;
2356
2357 end:
2358         snd_usb_unlock_shutdown(chip);
2359         return err;
2360 }
2361
2362 static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2363                              struct snd_ctl_elem_info *uinfo)
2364 {
2365         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2366         uinfo->count = 1;
2367         switch (kcontrol->private_value) {
2368         case SND_RME_DOMAIN_SYSTEM:
2369                 uinfo->value.integer.min = 32000;
2370                 uinfo->value.integer.max = 800000;
2371                 break;
2372         case SND_RME_DOMAIN_AES:
2373         case SND_RME_DOMAIN_SPDIF:
2374         default:
2375                 uinfo->value.integer.min = 0;
2376                 uinfo->value.integer.max = 200000;
2377         }
2378         uinfo->value.integer.step = 0;
2379         return 0;
2380 }
2381
2382 static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2383                                    struct snd_ctl_elem_info *uinfo)
2384 {
2385         static const char *const sync_states[] = {
2386                 "No Lock", "Lock", "Sync"
2387         };
2388
2389         return snd_ctl_enum_info(uinfo, 1,
2390                                  ARRAY_SIZE(sync_states), sync_states);
2391 }
2392
2393 static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2394                                  struct snd_ctl_elem_info *uinfo)
2395 {
2396         static const char *const spdif_if[] = {
2397                 "Coaxial", "Optical"
2398         };
2399
2400         return snd_ctl_enum_info(uinfo, 1,
2401                                  ARRAY_SIZE(spdif_if), spdif_if);
2402 }
2403
2404 static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2405                                      struct snd_ctl_elem_info *uinfo)
2406 {
2407         static const char *const optical_type[] = {
2408                 "Consumer", "Professional"
2409         };
2410
2411         return snd_ctl_enum_info(uinfo, 1,
2412                                  ARRAY_SIZE(optical_type), optical_type);
2413 }
2414
2415 static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2416                                     struct snd_ctl_elem_info *uinfo)
2417 {
2418         static const char *const sync_sources[] = {
2419                 "Internal", "AES", "SPDIF", "Internal"
2420         };
2421
2422         return snd_ctl_enum_info(uinfo, 1,
2423                                  ARRAY_SIZE(sync_sources), sync_sources);
2424 }
2425
2426 static const struct snd_kcontrol_new snd_rme_controls[] = {
2427         {
2428                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2429                 .name = "AES Rate",
2430                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2431                 .info = snd_rme_rate_info,
2432                 .get = snd_rme_rate_get,
2433                 .private_value = SND_RME_DOMAIN_AES
2434         },
2435         {
2436                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2437                 .name = "AES Sync",
2438                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2439                 .info = snd_rme_sync_state_info,
2440                 .get = snd_rme_sync_state_get,
2441                 .private_value = SND_RME_DOMAIN_AES
2442         },
2443         {
2444                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2445                 .name = "SPDIF Rate",
2446                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2447                 .info = snd_rme_rate_info,
2448                 .get = snd_rme_rate_get,
2449                 .private_value = SND_RME_DOMAIN_SPDIF
2450         },
2451         {
2452                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2453                 .name = "SPDIF Sync",
2454                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2455                 .info = snd_rme_sync_state_info,
2456                 .get = snd_rme_sync_state_get,
2457                 .private_value = SND_RME_DOMAIN_SPDIF
2458         },
2459         {
2460                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2461                 .name = "SPDIF Interface",
2462                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2463                 .info = snd_rme_spdif_if_info,
2464                 .get = snd_rme_spdif_if_get,
2465         },
2466         {
2467                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2468                 .name = "SPDIF Format",
2469                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2470                 .info = snd_rme_spdif_format_info,
2471                 .get = snd_rme_spdif_format_get,
2472         },
2473         {
2474                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2475                 .name = "Sync Source",
2476                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2477                 .info = snd_rme_sync_source_info,
2478                 .get = snd_rme_sync_source_get
2479         },
2480         {
2481                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2482                 .name = "System Rate",
2483                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2484                 .info = snd_rme_rate_info,
2485                 .get = snd_rme_rate_get,
2486                 .private_value = SND_RME_DOMAIN_SYSTEM
2487         },
2488         {
2489                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2490                 .name = "Current Frequency",
2491                 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2492                 .info = snd_rme_rate_info,
2493                 .get = snd_rme_current_freq_get
2494         }
2495 };
2496
2497 static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2498 {
2499         int err, i;
2500
2501         for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2502                 err = add_single_ctl_with_resume(mixer, 0,
2503                                                  NULL,
2504                                                  &snd_rme_controls[i],
2505                                                  NULL);
2506                 if (err < 0)
2507                         return err;
2508         }
2509
2510         return 0;
2511 }
2512
2513 /*
2514  * RME Babyface Pro (FS)
2515  *
2516  * These devices exposes a couple of DSP functions via request to EP0.
2517  * Switches are available via control registers, while routing is controlled
2518  * by controlling the volume on each possible crossing point.
2519  * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with
2520  * 0dB being at dec. 32768.
2521  */
2522 enum {
2523         SND_BBFPRO_CTL_REG1 = 0,
2524         SND_BBFPRO_CTL_REG2
2525 };
2526
2527 #define SND_BBFPRO_CTL_REG_MASK 1
2528 #define SND_BBFPRO_CTL_IDX_MASK 0xff
2529 #define SND_BBFPRO_CTL_IDX_SHIFT 1
2530 #define SND_BBFPRO_CTL_VAL_MASK 1
2531 #define SND_BBFPRO_CTL_VAL_SHIFT 9
2532 #define SND_BBFPRO_CTL_REG1_CLK_MASTER 0
2533 #define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1
2534 #define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7
2535 #define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8
2536 #define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10
2537 #define SND_BBFPRO_CTL_REG2_48V_AN1 0
2538 #define SND_BBFPRO_CTL_REG2_48V_AN2 1
2539 #define SND_BBFPRO_CTL_REG2_SENS_IN3 2
2540 #define SND_BBFPRO_CTL_REG2_SENS_IN4 3
2541 #define SND_BBFPRO_CTL_REG2_PAD_AN1 4
2542 #define SND_BBFPRO_CTL_REG2_PAD_AN2 5
2543
2544 #define SND_BBFPRO_MIXER_IDX_MASK 0x1ff
2545 #define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff
2546 #define SND_BBFPRO_MIXER_VAL_SHIFT 9
2547 #define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf
2548 #define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB
2549
2550 #define SND_BBFPRO_USBREQ_CTL_REG1 0x10
2551 #define SND_BBFPRO_USBREQ_CTL_REG2 0x17
2552 #define SND_BBFPRO_USBREQ_MIXER 0x12
2553
2554 static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2555                                  u8 index, u8 value)
2556 {
2557         int err;
2558         u16 usb_req, usb_idx, usb_val;
2559         struct snd_usb_audio *chip = mixer->chip;
2560
2561         err = snd_usb_lock_shutdown(chip);
2562         if (err < 0)
2563                 return err;
2564
2565         if (reg == SND_BBFPRO_CTL_REG1) {
2566                 usb_req = SND_BBFPRO_USBREQ_CTL_REG1;
2567                 if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2568                         usb_idx = 3;
2569                         usb_val = value ? 3 : 0;
2570                 } else {
2571                         usb_idx = 1 << index;
2572                         usb_val = value ? usb_idx : 0;
2573                 }
2574         } else {
2575                 usb_req = SND_BBFPRO_USBREQ_CTL_REG2;
2576                 usb_idx = 1 << index;
2577                 usb_val = value ? usb_idx : 0;
2578         }
2579
2580         err = snd_usb_ctl_msg(chip->dev,
2581                               usb_sndctrlpipe(chip->dev, 0), usb_req,
2582                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2583                               usb_val, usb_idx, NULL, 0);
2584
2585         snd_usb_unlock_shutdown(chip);
2586         return err;
2587 }
2588
2589 static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol,
2590                               struct snd_ctl_elem_value *ucontrol)
2591 {
2592         u8 reg, idx, val;
2593         int pv;
2594
2595         pv = kcontrol->private_value;
2596         reg = pv & SND_BBFPRO_CTL_REG_MASK;
2597         idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2598         val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT;
2599
2600         if ((reg == SND_BBFPRO_CTL_REG1 &&
2601              idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2602             (reg == SND_BBFPRO_CTL_REG2 &&
2603             (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2604              idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2605                 ucontrol->value.enumerated.item[0] = val;
2606         } else {
2607                 ucontrol->value.integer.value[0] = val;
2608         }
2609         return 0;
2610 }
2611
2612 static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol,
2613                                struct snd_ctl_elem_info *uinfo)
2614 {
2615         u8 reg, idx;
2616         int pv;
2617
2618         pv = kcontrol->private_value;
2619         reg = pv & SND_BBFPRO_CTL_REG_MASK;
2620         idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2621
2622         if (reg == SND_BBFPRO_CTL_REG1 &&
2623             idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2624                 static const char * const texts[2] = {
2625                         "AutoSync",
2626                         "Internal"
2627                 };
2628                 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2629         } else if (reg == SND_BBFPRO_CTL_REG2 &&
2630                    (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2631                     idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) {
2632                 static const char * const texts[2] = {
2633                         "-10dBV",
2634                         "+4dBu"
2635                 };
2636                 return snd_ctl_enum_info(uinfo, 1, 2, texts);
2637         }
2638
2639         uinfo->count = 1;
2640         uinfo->value.integer.min = 0;
2641         uinfo->value.integer.max = 1;
2642         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2643         return 0;
2644 }
2645
2646 static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol,
2647                               struct snd_ctl_elem_value *ucontrol)
2648 {
2649         int err;
2650         u8 reg, idx;
2651         int old_value, pv, val;
2652
2653         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2654         struct usb_mixer_interface *mixer = list->mixer;
2655
2656         pv = kcontrol->private_value;
2657         reg = pv & SND_BBFPRO_CTL_REG_MASK;
2658         idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2659         old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2660
2661         if ((reg == SND_BBFPRO_CTL_REG1 &&
2662              idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2663             (reg == SND_BBFPRO_CTL_REG2 &&
2664             (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2665              idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2666                 val = ucontrol->value.enumerated.item[0];
2667         } else {
2668                 val = ucontrol->value.integer.value[0];
2669         }
2670
2671         if (val > 1)
2672                 return -EINVAL;
2673
2674         if (val == old_value)
2675                 return 0;
2676
2677         kcontrol->private_value = reg
2678                 | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT)
2679                 | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT);
2680
2681         err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2682         return err < 0 ? err : 1;
2683 }
2684
2685 static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list)
2686 {
2687         u8 reg, idx;
2688         int value, pv;
2689
2690         pv = list->kctl->private_value;
2691         reg = pv & SND_BBFPRO_CTL_REG_MASK;
2692         idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2693         value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2694
2695         return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2696 }
2697
2698 static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2699                                  u32 value)
2700 {
2701         struct snd_usb_audio *chip = mixer->chip;
2702         int err;
2703         u16 idx;
2704         u16 usb_idx, usb_val;
2705         u32 v;
2706
2707         err = snd_usb_lock_shutdown(chip);
2708         if (err < 0)
2709                 return err;
2710
2711         idx = index & SND_BBFPRO_MIXER_IDX_MASK;
2712         // 18 bit linear volume, split so 2 bits end up in index.
2713         v = value & SND_BBFPRO_MIXER_VAL_MASK;
2714         usb_idx = idx | (v & 0x3) << 14;
2715         usb_val = (v >> 2) & 0xffff;
2716
2717         err = snd_usb_ctl_msg(chip->dev,
2718                               usb_sndctrlpipe(chip->dev, 0),
2719                               SND_BBFPRO_USBREQ_MIXER,
2720                               USB_DIR_OUT | USB_TYPE_VENDOR |
2721                               USB_RECIP_DEVICE,
2722                               usb_val, usb_idx, NULL, 0);
2723
2724         snd_usb_unlock_shutdown(chip);
2725         return err;
2726 }
2727
2728 static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol,
2729                               struct snd_ctl_elem_value *ucontrol)
2730 {
2731         ucontrol->value.integer.value[0] =
2732                 kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2733         return 0;
2734 }
2735
2736 static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol,
2737                                struct snd_ctl_elem_info *uinfo)
2738 {
2739         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2740         uinfo->count = 1;
2741         uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN;
2742         uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX;
2743         return 0;
2744 }
2745
2746 static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol,
2747                               struct snd_ctl_elem_value *ucontrol)
2748 {
2749         int err;
2750         u16 idx;
2751         u32 new_val, old_value, uvalue;
2752         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2753         struct usb_mixer_interface *mixer = list->mixer;
2754
2755         uvalue = ucontrol->value.integer.value[0];
2756         idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK;
2757         old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2758
2759         if (uvalue > SND_BBFPRO_MIXER_VAL_MAX)
2760                 return -EINVAL;
2761
2762         if (uvalue == old_value)
2763                 return 0;
2764
2765         new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK;
2766
2767         kcontrol->private_value = idx
2768                 | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT);
2769
2770         err = snd_bbfpro_vol_update(mixer, idx, new_val);
2771         return err < 0 ? err : 1;
2772 }
2773
2774 static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list)
2775 {
2776         int pv = list->kctl->private_value;
2777         u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK;
2778         u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT)
2779                 & SND_BBFPRO_MIXER_VAL_MASK;
2780         return snd_bbfpro_vol_update(list->mixer, idx, val);
2781 }
2782
2783 // Predfine elements
2784 static const struct snd_kcontrol_new snd_bbfpro_ctl_control = {
2785         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2786         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2787         .index = 0,
2788         .info = snd_bbfpro_ctl_info,
2789         .get = snd_bbfpro_ctl_get,
2790         .put = snd_bbfpro_ctl_put
2791 };
2792
2793 static const struct snd_kcontrol_new snd_bbfpro_vol_control = {
2794         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2795         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2796         .index = 0,
2797         .info = snd_bbfpro_vol_info,
2798         .get = snd_bbfpro_vol_get,
2799         .put = snd_bbfpro_vol_put
2800 };
2801
2802 static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2803                               u8 index, char *name)
2804 {
2805         struct snd_kcontrol_new knew = snd_bbfpro_ctl_control;
2806
2807         knew.name = name;
2808         knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK)
2809                 | ((index & SND_BBFPRO_CTL_IDX_MASK)
2810                         << SND_BBFPRO_CTL_IDX_SHIFT);
2811
2812         return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2813                 &knew, NULL);
2814 }
2815
2816 static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2817                               char *name)
2818 {
2819         struct snd_kcontrol_new knew = snd_bbfpro_vol_control;
2820
2821         knew.name = name;
2822         knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK;
2823
2824         return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2825                 &knew, NULL);
2826 }
2827
2828 static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2829 {
2830         int err, i, o;
2831         char name[48];
2832
2833         static const char * const input[] = {
2834                 "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3",
2835                 "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2836
2837         static const char * const output[] = {
2838                 "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4",
2839                 "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2840
2841         for (o = 0 ; o < 12 ; ++o) {
2842                 for (i = 0 ; i < 12 ; ++i) {
2843                         // Line routing
2844                         snprintf(name, sizeof(name),
2845                                  "%s-%s-%s Playback Volume",
2846                                  (i < 2 ? "Mic" : "Line"),
2847                                  input[i], output[o]);
2848                         err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2849                         if (err < 0)
2850                                 return err;
2851
2852                         // PCM routing... yes, it is output remapping
2853                         snprintf(name, sizeof(name),
2854                                  "PCM-%s-%s Playback Volume",
2855                                  output[i], output[o]);
2856                         err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2857                                                  name);
2858                         if (err < 0)
2859                                 return err;
2860                 }
2861         }
2862
2863         // Control Reg 1
2864         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2865                                  SND_BBFPRO_CTL_REG1_CLK_OPTICAL,
2866                                  "Sample Clock Source");
2867         if (err < 0)
2868                 return err;
2869
2870         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2871                                  SND_BBFPRO_CTL_REG1_SPDIF_PRO,
2872                                  "IEC958 Pro Mask");
2873         if (err < 0)
2874                 return err;
2875
2876         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2877                                  SND_BBFPRO_CTL_REG1_SPDIF_EMPH,
2878                                  "IEC958 Emphasis");
2879         if (err < 0)
2880                 return err;
2881
2882         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2883                                  SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL,
2884                                  "IEC958 Switch");
2885         if (err < 0)
2886                 return err;
2887
2888         // Control Reg 2
2889         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2890                                  SND_BBFPRO_CTL_REG2_48V_AN1,
2891                                  "Mic-AN1 48V");
2892         if (err < 0)
2893                 return err;
2894
2895         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2896                                  SND_BBFPRO_CTL_REG2_48V_AN2,
2897                                  "Mic-AN2 48V");
2898         if (err < 0)
2899                 return err;
2900
2901         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2902                                  SND_BBFPRO_CTL_REG2_SENS_IN3,
2903                                  "Line-IN3 Sens.");
2904         if (err < 0)
2905                 return err;
2906
2907         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2908                                  SND_BBFPRO_CTL_REG2_SENS_IN4,
2909                                  "Line-IN4 Sens.");
2910         if (err < 0)
2911                 return err;
2912
2913         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2914                                  SND_BBFPRO_CTL_REG2_PAD_AN1,
2915                                  "Mic-AN1 PAD");
2916         if (err < 0)
2917                 return err;
2918
2919         err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2920                                  SND_BBFPRO_CTL_REG2_PAD_AN2,
2921                                  "Mic-AN2 PAD");
2922         if (err < 0)
2923                 return err;
2924
2925         return 0;
2926 }
2927
2928 /*
2929  * Pioneer DJ DJM Mixers
2930  *
2931  * These devices generally have options for soft-switching the playback and
2932  * capture sources in addition to the recording level. Although different
2933  * devices have different configurations, there seems to be canonical values
2934  * for specific capture/playback types:  See the definitions of these below.
2935  *
2936  * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to
2937  * capture phono would be 0x0203. Capture, playback and capture level have
2938  * different wIndexes.
2939  */
2940
2941 // Capture types
2942 #define SND_DJM_CAP_LINE        0x00
2943 #define SND_DJM_CAP_CDLINE      0x01
2944 #define SND_DJM_CAP_DIGITAL     0x02
2945 #define SND_DJM_CAP_PHONO       0x03
2946 #define SND_DJM_CAP_PFADER      0x06
2947 #define SND_DJM_CAP_XFADERA     0x07
2948 #define SND_DJM_CAP_XFADERB     0x08
2949 #define SND_DJM_CAP_MIC         0x09
2950 #define SND_DJM_CAP_AUX         0x0d
2951 #define SND_DJM_CAP_RECOUT      0x0a
2952 #define SND_DJM_CAP_NONE        0x0f
2953 #define SND_DJM_CAP_CH1PFADER   0x11
2954 #define SND_DJM_CAP_CH2PFADER   0x12
2955 #define SND_DJM_CAP_CH3PFADER   0x13
2956 #define SND_DJM_CAP_CH4PFADER   0x14
2957
2958 // Playback types
2959 #define SND_DJM_PB_CH1          0x00
2960 #define SND_DJM_PB_CH2          0x01
2961 #define SND_DJM_PB_AUX          0x04
2962
2963 #define SND_DJM_WINDEX_CAP      0x8002
2964 #define SND_DJM_WINDEX_CAPLVL   0x8003
2965 #define SND_DJM_WINDEX_PB       0x8016
2966
2967 // kcontrol->private_value layout
2968 #define SND_DJM_VALUE_MASK      0x0000ffff
2969 #define SND_DJM_GROUP_MASK      0x00ff0000
2970 #define SND_DJM_DEVICE_MASK     0xff000000
2971 #define SND_DJM_GROUP_SHIFT     16
2972 #define SND_DJM_DEVICE_SHIFT    24
2973
2974 // device table index
2975 // used for the snd_djm_devices table, so please update accordingly
2976 #define SND_DJM_250MK2_IDX      0x0
2977 #define SND_DJM_750_IDX         0x1
2978 #define SND_DJM_850_IDX         0x2
2979 #define SND_DJM_900NXS2_IDX     0x3
2980 #define SND_DJM_750MK2_IDX      0x4
2981
2982
2983 #define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \
2984         .name = _name, \
2985         .options = snd_djm_opts_##suffix, \
2986         .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \
2987         .default_value = _default_value, \
2988         .wIndex = _windex }
2989
2990 #define SND_DJM_DEVICE(suffix) { \
2991         .controls = snd_djm_ctls_##suffix, \
2992         .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) }
2993
2994
2995 struct snd_djm_device {
2996         const char *name;
2997         const struct snd_djm_ctl *controls;
2998         size_t ncontrols;
2999 };
3000
3001 struct snd_djm_ctl {
3002         const char *name;
3003         const u16 *options;
3004         size_t noptions;
3005         u16 default_value;
3006         u16 wIndex;
3007 };
3008
3009 static const char *snd_djm_get_label_caplevel(u16 wvalue)
3010 {
3011         switch (wvalue) {
3012         case 0x0000:    return "-19dB";
3013         case 0x0100:    return "-15dB";
3014         case 0x0200:    return "-10dB";
3015         case 0x0300:    return "-5dB";
3016         default:        return NULL;
3017         }
3018 };
3019
3020 static const char *snd_djm_get_label_cap_common(u16 wvalue)
3021 {
3022         switch (wvalue & 0x00ff) {
3023         case SND_DJM_CAP_LINE:          return "Control Tone LINE";
3024         case SND_DJM_CAP_CDLINE:        return "Control Tone CD/LINE";
3025         case SND_DJM_CAP_DIGITAL:       return "Control Tone DIGITAL";
3026         case SND_DJM_CAP_PHONO:         return "Control Tone PHONO";
3027         case SND_DJM_CAP_PFADER:        return "Post Fader";
3028         case SND_DJM_CAP_XFADERA:       return "Cross Fader A";
3029         case SND_DJM_CAP_XFADERB:       return "Cross Fader B";
3030         case SND_DJM_CAP_MIC:           return "Mic";
3031         case SND_DJM_CAP_RECOUT:        return "Rec Out";
3032         case SND_DJM_CAP_AUX:           return "Aux";
3033         case SND_DJM_CAP_NONE:          return "None";
3034         case SND_DJM_CAP_CH1PFADER:     return "Post Fader Ch1";
3035         case SND_DJM_CAP_CH2PFADER:     return "Post Fader Ch2";
3036         case SND_DJM_CAP_CH3PFADER:     return "Post Fader Ch3";
3037         case SND_DJM_CAP_CH4PFADER:     return "Post Fader Ch4";
3038         default:                        return NULL;
3039         }
3040 };
3041
3042 // The DJM-850 has different values for CD/LINE and LINE capture
3043 // control options than the other DJM declared in this file.
3044 static const char *snd_djm_get_label_cap_850(u16 wvalue)
3045 {
3046         switch (wvalue & 0x00ff) {
3047         case 0x00:              return "Control Tone CD/LINE";
3048         case 0x01:              return "Control Tone LINE";
3049         default:                return snd_djm_get_label_cap_common(wvalue);
3050         }
3051 };
3052
3053 static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue)
3054 {
3055         switch (device_idx) {
3056         case SND_DJM_850_IDX:           return snd_djm_get_label_cap_850(wvalue);
3057         default:                        return snd_djm_get_label_cap_common(wvalue);
3058         }
3059 };
3060
3061 static const char *snd_djm_get_label_pb(u16 wvalue)
3062 {
3063         switch (wvalue & 0x00ff) {
3064         case SND_DJM_PB_CH1:    return "Ch1";
3065         case SND_DJM_PB_CH2:    return "Ch2";
3066         case SND_DJM_PB_AUX:    return "Aux";
3067         default:                return NULL;
3068         }
3069 };
3070
3071 static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex)
3072 {
3073         switch (windex) {
3074         case SND_DJM_WINDEX_CAPLVL:     return snd_djm_get_label_caplevel(wvalue);
3075         case SND_DJM_WINDEX_CAP:        return snd_djm_get_label_cap(device_idx, wvalue);
3076         case SND_DJM_WINDEX_PB:         return snd_djm_get_label_pb(wvalue);
3077         default:                        return NULL;
3078         }
3079 };
3080
3081 // common DJM capture level option values
3082 static const u16 snd_djm_opts_cap_level[] = {
3083         0x0000, 0x0100, 0x0200, 0x0300 };
3084
3085
3086 // DJM-250MK2
3087 static const u16 snd_djm_opts_250mk2_cap1[] = {
3088         0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a };
3089
3090 static const u16 snd_djm_opts_250mk2_cap2[] = {
3091         0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a };
3092
3093 static const u16 snd_djm_opts_250mk2_cap3[] = {
3094         0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d };
3095
3096 static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
3097 static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
3098 static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
3099
3100 static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = {
3101         SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3102         SND_DJM_CTL("Ch1 Input",   250mk2_cap1, 2, SND_DJM_WINDEX_CAP),
3103         SND_DJM_CTL("Ch2 Input",   250mk2_cap2, 2, SND_DJM_WINDEX_CAP),
3104         SND_DJM_CTL("Ch3 Input",   250mk2_cap3, 0, SND_DJM_WINDEX_CAP),
3105         SND_DJM_CTL("Ch1 Output",   250mk2_pb1, 0, SND_DJM_WINDEX_PB),
3106         SND_DJM_CTL("Ch2 Output",   250mk2_pb2, 1, SND_DJM_WINDEX_PB),
3107         SND_DJM_CTL("Ch3 Output",   250mk2_pb3, 2, SND_DJM_WINDEX_PB)
3108 };
3109
3110
3111 // DJM-750
3112 static const u16 snd_djm_opts_750_cap1[] = {
3113         0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
3114 static const u16 snd_djm_opts_750_cap2[] = {
3115         0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
3116 static const u16 snd_djm_opts_750_cap3[] = {
3117         0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
3118 static const u16 snd_djm_opts_750_cap4[] = {
3119         0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
3120
3121 static const struct snd_djm_ctl snd_djm_ctls_750[] = {
3122         SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3123         SND_DJM_CTL("Ch1 Input",   750_cap1, 2, SND_DJM_WINDEX_CAP),
3124         SND_DJM_CTL("Ch2 Input",   750_cap2, 2, SND_DJM_WINDEX_CAP),
3125         SND_DJM_CTL("Ch3 Input",   750_cap3, 0, SND_DJM_WINDEX_CAP),
3126         SND_DJM_CTL("Ch4 Input",   750_cap4, 0, SND_DJM_WINDEX_CAP)
3127 };
3128
3129
3130 // DJM-850
3131 static const u16 snd_djm_opts_850_cap1[] = {
3132         0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
3133 static const u16 snd_djm_opts_850_cap2[] = {
3134         0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
3135 static const u16 snd_djm_opts_850_cap3[] = {
3136         0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
3137 static const u16 snd_djm_opts_850_cap4[] = {
3138         0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
3139
3140 static const struct snd_djm_ctl snd_djm_ctls_850[] = {
3141         SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3142         SND_DJM_CTL("Ch1 Input",   850_cap1, 1, SND_DJM_WINDEX_CAP),
3143         SND_DJM_CTL("Ch2 Input",   850_cap2, 0, SND_DJM_WINDEX_CAP),
3144         SND_DJM_CTL("Ch3 Input",   850_cap3, 0, SND_DJM_WINDEX_CAP),
3145         SND_DJM_CTL("Ch4 Input",   850_cap4, 1, SND_DJM_WINDEX_CAP)
3146 };
3147
3148
3149 // DJM-900NXS2
3150 static const u16 snd_djm_opts_900nxs2_cap1[] = {
3151         0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
3152 static const u16 snd_djm_opts_900nxs2_cap2[] = {
3153         0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
3154 static const u16 snd_djm_opts_900nxs2_cap3[] = {
3155         0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
3156 static const u16 snd_djm_opts_900nxs2_cap4[] = {
3157         0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
3158 static const u16 snd_djm_opts_900nxs2_cap5[] = {
3159         0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
3160
3161 static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = {
3162         SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3163         SND_DJM_CTL("Ch1 Input",   900nxs2_cap1, 2, SND_DJM_WINDEX_CAP),
3164         SND_DJM_CTL("Ch2 Input",   900nxs2_cap2, 2, SND_DJM_WINDEX_CAP),
3165         SND_DJM_CTL("Ch3 Input",   900nxs2_cap3, 2, SND_DJM_WINDEX_CAP),
3166         SND_DJM_CTL("Ch4 Input",   900nxs2_cap4, 2, SND_DJM_WINDEX_CAP),
3167         SND_DJM_CTL("Ch5 Input",   900nxs2_cap5, 3, SND_DJM_WINDEX_CAP)
3168 };
3169
3170 // DJM-750MK2
3171 static const u16 snd_djm_opts_750mk2_cap1[] = {
3172         0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
3173 static const u16 snd_djm_opts_750mk2_cap2[] = {
3174         0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
3175 static const u16 snd_djm_opts_750mk2_cap3[] = {
3176         0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
3177 static const u16 snd_djm_opts_750mk2_cap4[] = {
3178         0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
3179 static const u16 snd_djm_opts_750mk2_cap5[] = {
3180         0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
3181
3182 static const u16 snd_djm_opts_750mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
3183 static const u16 snd_djm_opts_750mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
3184 static const u16 snd_djm_opts_750mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
3185
3186
3187 static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = {
3188         SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3189         SND_DJM_CTL("Ch1 Input",   750mk2_cap1, 2, SND_DJM_WINDEX_CAP),
3190         SND_DJM_CTL("Ch2 Input",   750mk2_cap2, 2, SND_DJM_WINDEX_CAP),
3191         SND_DJM_CTL("Ch3 Input",   750mk2_cap3, 2, SND_DJM_WINDEX_CAP),
3192         SND_DJM_CTL("Ch4 Input",   750mk2_cap4, 2, SND_DJM_WINDEX_CAP),
3193         SND_DJM_CTL("Ch5 Input",   750mk2_cap5, 3, SND_DJM_WINDEX_CAP),
3194         SND_DJM_CTL("Ch1 Output",   750mk2_pb1, 0, SND_DJM_WINDEX_PB),
3195         SND_DJM_CTL("Ch2 Output",   750mk2_pb2, 1, SND_DJM_WINDEX_PB),
3196         SND_DJM_CTL("Ch3 Output",   750mk2_pb3, 2, SND_DJM_WINDEX_PB)
3197 };
3198
3199
3200 static const struct snd_djm_device snd_djm_devices[] = {
3201         [SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2),
3202         [SND_DJM_750_IDX] = SND_DJM_DEVICE(750),
3203         [SND_DJM_850_IDX] = SND_DJM_DEVICE(850),
3204         [SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2),
3205         [SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2),
3206 };
3207
3208
3209 static int snd_djm_controls_info(struct snd_kcontrol *kctl,
3210                                 struct snd_ctl_elem_info *info)
3211 {
3212         unsigned long private_value = kctl->private_value;
3213         u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3214         u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3215         const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3216         const char *name;
3217         const struct snd_djm_ctl *ctl;
3218         size_t noptions;
3219
3220         if (ctl_idx >= device->ncontrols)
3221                 return -EINVAL;
3222
3223         ctl = &device->controls[ctl_idx];
3224         noptions = ctl->noptions;
3225         if (info->value.enumerated.item >= noptions)
3226                 info->value.enumerated.item = noptions - 1;
3227
3228         name = snd_djm_get_label(device_idx,
3229                                 ctl->options[info->value.enumerated.item],
3230                                 ctl->wIndex);
3231         if (!name)
3232                 return -EINVAL;
3233
3234         strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name));
3235         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3236         info->count = 1;
3237         info->value.enumerated.items = noptions;
3238         return 0;
3239 }
3240
3241 static int snd_djm_controls_update(struct usb_mixer_interface *mixer,
3242                                 u8 device_idx, u8 group, u16 value)
3243 {
3244         int err;
3245         const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3246
3247         if ((group >= device->ncontrols) || value >= device->controls[group].noptions)
3248                 return -EINVAL;
3249
3250         err = snd_usb_lock_shutdown(mixer->chip);
3251         if (err)
3252                 return err;
3253
3254         err = snd_usb_ctl_msg(
3255                 mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0),
3256                 USB_REQ_SET_FEATURE,
3257                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3258                 device->controls[group].options[value],
3259                 device->controls[group].wIndex,
3260                 NULL, 0);
3261
3262         snd_usb_unlock_shutdown(mixer->chip);
3263         return err;
3264 }
3265
3266 static int snd_djm_controls_get(struct snd_kcontrol *kctl,
3267                                 struct snd_ctl_elem_value *elem)
3268 {
3269         elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK;
3270         return 0;
3271 }
3272
3273 static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem)
3274 {
3275         struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
3276         struct usb_mixer_interface *mixer = list->mixer;
3277         unsigned long private_value = kctl->private_value;
3278
3279         u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3280         u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3281         u16 value = elem->value.enumerated.item[0];
3282
3283         kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) |
3284                               (group << SND_DJM_GROUP_SHIFT) |
3285                               value);
3286
3287         return snd_djm_controls_update(mixer, device, group, value);
3288 }
3289
3290 static int snd_djm_controls_resume(struct usb_mixer_elem_list *list)
3291 {
3292         unsigned long private_value = list->kctl->private_value;
3293         u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3294         u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3295         u16 value = (private_value & SND_DJM_VALUE_MASK);
3296
3297         return snd_djm_controls_update(list->mixer, device, group, value);
3298 }
3299
3300 static int snd_djm_controls_create(struct usb_mixer_interface *mixer,
3301                 const u8 device_idx)
3302 {
3303         int err, i;
3304         u16 value;
3305
3306         const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3307
3308         struct snd_kcontrol_new knew = {
3309                 .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
3310                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3311                 .index = 0,
3312                 .info = snd_djm_controls_info,
3313                 .get  = snd_djm_controls_get,
3314                 .put  = snd_djm_controls_put
3315         };
3316
3317         for (i = 0; i < device->ncontrols; i++) {
3318                 value = device->controls[i].default_value;
3319                 knew.name = device->controls[i].name;
3320                 knew.private_value = (
3321                         ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) |
3322                         (i << SND_DJM_GROUP_SHIFT) |
3323                         value);
3324                 err = snd_djm_controls_update(mixer, device_idx, i, value);
3325                 if (err)
3326                         return err;
3327                 err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume,
3328                                                  &knew, NULL);
3329                 if (err)
3330                         return err;
3331         }
3332         return 0;
3333 }
3334
3335 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
3336 {
3337         int err = 0;
3338
3339         err = snd_usb_soundblaster_remote_init(mixer);
3340         if (err < 0)
3341                 return err;
3342
3343         switch (mixer->chip->usb_id) {
3344         /* Tascam US-16x08 */
3345         case USB_ID(0x0644, 0x8047):
3346                 err = snd_us16x08_controls_create(mixer);
3347                 break;
3348         case USB_ID(0x041e, 0x3020):
3349         case USB_ID(0x041e, 0x3040):
3350         case USB_ID(0x041e, 0x3042):
3351         case USB_ID(0x041e, 0x30df):
3352         case USB_ID(0x041e, 0x3048):
3353                 err = snd_audigy2nx_controls_create(mixer);
3354                 if (err < 0)
3355                         break;
3356                 snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
3357                                      mixer, snd_audigy2nx_proc_read);
3358                 break;
3359
3360         /* EMU0204 */
3361         case USB_ID(0x041e, 0x3f19):
3362                 err = snd_emu0204_controls_create(mixer);
3363                 break;
3364
3365         case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
3366         case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
3367                 err = snd_c400_create_mixer(mixer);
3368                 break;
3369
3370         case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
3371         case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
3372                 err = snd_ftu_create_mixer(mixer);
3373                 break;
3374
3375         case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
3376         case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
3377         case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
3378                 err = snd_xonar_u1_controls_create(mixer);
3379                 break;
3380
3381         case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
3382                 err = snd_microii_controls_create(mixer);
3383                 break;
3384
3385         case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
3386                 err = snd_mbox1_controls_create(mixer);
3387                 break;
3388
3389         case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
3390                 err = snd_nativeinstruments_create_mixer(mixer,
3391                                 snd_nativeinstruments_ta6_mixers,
3392                                 ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
3393                 break;
3394
3395         case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
3396                 err = snd_nativeinstruments_create_mixer(mixer,
3397                                 snd_nativeinstruments_ta10_mixers,
3398                                 ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
3399                 break;
3400
3401         case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
3402                 /* detection is disabled in mixer_maps.c */
3403                 err = snd_create_std_mono_table(mixer, ebox44_table);
3404                 break;
3405
3406         case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
3407         case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
3408         case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
3409         case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
3410         case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
3411                 err = snd_scarlett_controls_create(mixer);
3412                 break;
3413
3414         case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
3415         case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
3416         case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
3417         case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */
3418         case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */
3419         case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */
3420         case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */
3421         case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */
3422         case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */
3423         case USB_ID(0x1235, 0x820c): /* Focusrite Clarett+ 8Pre */
3424                 err = snd_scarlett_gen2_init(mixer);
3425                 break;
3426
3427         case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
3428                 err = snd_soundblaster_e1_switch_create(mixer);
3429                 break;
3430         case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3431                 err = dell_dock_mixer_create(mixer);
3432                 if (err < 0)
3433                         break;
3434                 err = dell_dock_mixer_init(mixer);
3435                 break;
3436
3437         case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
3438         case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
3439         case USB_ID(0x2a39, 0x3fd4): /* RME */
3440                 err = snd_rme_controls_create(mixer);
3441                 break;
3442
3443         case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */
3444                 err = snd_sc1810_init_mixer(mixer);
3445                 break;
3446         case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */
3447                 err = snd_bbfpro_controls_create(mixer);
3448                 break;
3449         case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
3450                 err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX);
3451                 break;
3452         case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */
3453                 err = snd_djm_controls_create(mixer, SND_DJM_750_IDX);
3454                 break;
3455         case USB_ID(0x2b73, 0x001b): /* Pioneer DJ DJM-750MK2 */
3456                 err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX);
3457                 break;
3458         case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */
3459                 err = snd_djm_controls_create(mixer, SND_DJM_850_IDX);
3460                 break;
3461         case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
3462                 err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX);
3463                 break;
3464         }
3465
3466         return err;
3467 }
3468
3469 void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
3470 {
3471         switch (mixer->chip->usb_id) {
3472         case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3473                 dell_dock_mixer_init(mixer);
3474                 break;
3475         }
3476 }
3477
3478 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
3479                                     int unitid)
3480 {
3481         if (!mixer->rc_cfg)
3482                 return;
3483         /* unit ids specific to Extigy/Audigy 2 NX: */
3484         switch (unitid) {
3485         case 0: /* remote control */
3486                 mixer->rc_urb->dev = mixer->chip->dev;
3487                 usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
3488                 break;
3489         case 4: /* digital in jack */
3490         case 7: /* line in jacks */
3491         case 19: /* speaker out jacks */
3492         case 20: /* headphones out jack */
3493                 break;
3494         /* live24ext: 4 = line-in jack */
3495         case 3: /* hp-out jack (may actuate Mute) */
3496                 if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
3497                     mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
3498                         snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
3499                 break;
3500         default:
3501                 usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
3502                 break;
3503         }
3504 }
3505
3506 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
3507                                          struct usb_mixer_elem_info *cval,
3508                                          struct snd_kcontrol *kctl)
3509 {
3510         /* Approximation using 10 ranges based on output measurement on hw v1.2.
3511          * This seems close to the cubic mapping e.g. alsamixer uses. */
3512         static const DECLARE_TLV_DB_RANGE(scale,
3513                  0,  1, TLV_DB_MINMAX_ITEM(-5300, -4970),
3514                  2,  5, TLV_DB_MINMAX_ITEM(-4710, -4160),
3515                  6,  7, TLV_DB_MINMAX_ITEM(-3884, -3710),
3516                  8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
3517                 15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
3518                 17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
3519                 20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
3520                 27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
3521                 32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
3522                 41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
3523         );
3524
3525         if (cval->min == 0 && cval->max == 50) {
3526                 usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
3527                 kctl->tlv.p = scale;
3528                 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
3529                 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3530
3531         } else if (cval->min == 0 && cval->max <= 1000) {
3532                 /* Some other clearly broken DragonFly variant.
3533                  * At least a 0..53 variant (hw v1.0) exists.
3534                  */
3535                 usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
3536                 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3537         }
3538 }
3539
3540 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
3541                                   struct usb_mixer_elem_info *cval, int unitid,
3542                                   struct snd_kcontrol *kctl)
3543 {
3544         switch (mixer->chip->usb_id) {
3545         case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
3546                 if (unitid == 7 && cval->control == UAC_FU_VOLUME)
3547                         snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
3548                 break;
3549         /* lowest playback value is muted on some devices */
3550         case USB_ID(0x0d8c, 0x000c): /* C-Media */
3551         case USB_ID(0x0d8c, 0x0014): /* C-Media */
3552         case USB_ID(0x19f7, 0x0003): /* RODE NT-USB */
3553                 if (strstr(kctl->id.name, "Playback"))
3554                         cval->min_mute = 1;
3555                 break;
3556         }
3557 }
3558