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