linux/sound/usb/mixer_quirks.c
<<
>>
Prefs
   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
  40struct 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 */
  54static 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
 107static 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 */
 122static 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
 138static 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 */
 173static 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
 192static 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
 213static 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
 233static __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
 242static 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
 292static 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
 298static 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
 328static 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
 347static 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 */
 356static 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
 363static const char * const snd_audigy2nx_led_names[] = {
 364        "CMSS LED Switch",
 365        "Power LED Switch",
 366        "Dolby Digital LED Switch",
 367};
 368
 369static 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
 401static 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 */
 452static 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
 460static 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
 467static 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
 488static 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
 507static 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
 513static 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
 522static 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
 531static 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
 538static 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
 555static 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
 575static 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
 581static 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
 590static 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 helper functions */
 598
 599static int snd_mbox1_is_spdif_synced(struct snd_usb_audio *chip)
 600{
 601        unsigned char buff[3];
 602        int err;
 603        int is_spdif_synced;
 604
 605        /* Read clock source */
 606        err = snd_usb_ctl_msg(chip->dev,
 607                              usb_rcvctrlpipe(chip->dev, 0), 0x81,
 608                              USB_DIR_IN |
 609                              USB_TYPE_CLASS |
 610                              USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
 611        if (err < 0)
 612                return err;
 613
 614        /* spdif sync: buff is all zeroes */
 615        is_spdif_synced = !(buff[0] | buff[1] | buff[2]);
 616        return is_spdif_synced;
 617}
 618
 619static int snd_mbox1_set_clk_source(struct snd_usb_audio *chip, int rate_or_zero)
 620{
 621        /* 2 possibilities:     Internal    -> expects sample rate
 622         *                      S/PDIF sync -> expects rate = 0
 623         */
 624        unsigned char buff[3];
 625
 626        buff[0] = (rate_or_zero >>  0) & 0xff;
 627        buff[1] = (rate_or_zero >>  8) & 0xff;
 628        buff[2] = (rate_or_zero >> 16) & 0xff;
 629
 630        /* Set clock source */
 631        return snd_usb_ctl_msg(chip->dev,
 632                               usb_sndctrlpipe(chip->dev, 0), 0x1,
 633                               USB_TYPE_CLASS |
 634                               USB_RECIP_ENDPOINT, 0x100, 0x81, buff, 3);
 635}
 636
 637static int snd_mbox1_is_spdif_input(struct snd_usb_audio *chip)
 638{
 639        /* Hardware gives 2 possibilities:      ANALOG Source  -> 0x01
 640         *                                      S/PDIF Source  -> 0x02
 641         */
 642        int err;
 643        unsigned char source[1];
 644
 645        /* Read input source */
 646        err = snd_usb_ctl_msg(chip->dev,
 647                              usb_rcvctrlpipe(chip->dev, 0), 0x81,
 648                              USB_DIR_IN |
 649                              USB_TYPE_CLASS |
 650                              USB_RECIP_INTERFACE, 0x00, 0x500, source, 1);
 651        if (err < 0)
 652                return err;
 653
 654        return (source[0] == 2);
 655}
 656
 657static int snd_mbox1_set_input_source(struct snd_usb_audio *chip, int is_spdif)
 658{
 659        /* NB: Setting the input source to S/PDIF resets the clock source to S/PDIF
 660         * Hardware expects 2 possibilities:    ANALOG Source  -> 0x01
 661         *                                      S/PDIF Source  -> 0x02
 662         */
 663        unsigned char buff[1];
 664
 665        buff[0] = (is_spdif & 1) + 1;
 666
 667        /* Set input source */
 668        return snd_usb_ctl_msg(chip->dev,
 669                               usb_sndctrlpipe(chip->dev, 0), 0x1,
 670                               USB_TYPE_CLASS |
 671                               USB_RECIP_INTERFACE, 0x00, 0x500, buff, 1);
 672}
 673
 674/* Digidesign Mbox 1 clock source switch (internal/spdif) */
 675
 676static int snd_mbox1_clk_switch_get(struct snd_kcontrol *kctl,
 677                                    struct snd_ctl_elem_value *ucontrol)
 678{
 679        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 680        struct snd_usb_audio *chip = list->mixer->chip;
 681        int err;
 682
 683        err = snd_usb_lock_shutdown(chip);
 684        if (err < 0)
 685                goto err;
 686
 687        err = snd_mbox1_is_spdif_synced(chip);
 688        if (err < 0)
 689                goto err;
 690
 691        kctl->private_value = err;
 692        err = 0;
 693        ucontrol->value.enumerated.item[0] = kctl->private_value;
 694err:
 695        snd_usb_unlock_shutdown(chip);
 696        return err;
 697}
 698
 699static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync)
 700{
 701        struct snd_usb_audio *chip = mixer->chip;
 702        int err;
 703
 704        err = snd_usb_lock_shutdown(chip);
 705        if (err < 0)
 706                return err;
 707
 708        err = snd_mbox1_is_spdif_input(chip);
 709        if (err < 0)
 710                goto err;
 711
 712        err = snd_mbox1_is_spdif_synced(chip);
 713        if (err < 0)
 714                goto err;
 715
 716        /* FIXME: hardcoded sample rate */
 717        err = snd_mbox1_set_clk_source(chip, is_spdif_sync ? 0 : 48000);
 718        if (err < 0)
 719                goto err;
 720
 721        err = snd_mbox1_is_spdif_synced(chip);
 722err:
 723        snd_usb_unlock_shutdown(chip);
 724        return err;
 725}
 726
 727static int snd_mbox1_clk_switch_put(struct snd_kcontrol *kctl,
 728                                    struct snd_ctl_elem_value *ucontrol)
 729{
 730        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 731        struct usb_mixer_interface *mixer = list->mixer;
 732        int err;
 733        bool cur_val, new_val;
 734
 735        cur_val = kctl->private_value;
 736        new_val = ucontrol->value.enumerated.item[0];
 737        if (cur_val == new_val)
 738                return 0;
 739
 740        kctl->private_value = new_val;
 741        err = snd_mbox1_clk_switch_update(mixer, new_val);
 742        return err < 0 ? err : 1;
 743}
 744
 745static int snd_mbox1_clk_switch_info(struct snd_kcontrol *kcontrol,
 746                                     struct snd_ctl_elem_info *uinfo)
 747{
 748        static const char *const texts[2] = {
 749                "Internal",
 750                "S/PDIF"
 751        };
 752
 753        return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
 754}
 755
 756static int snd_mbox1_clk_switch_resume(struct usb_mixer_elem_list *list)
 757{
 758        return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value);
 759}
 760
 761/* Digidesign Mbox 1 input source switch (analog/spdif) */
 762
 763static int snd_mbox1_src_switch_get(struct snd_kcontrol *kctl,
 764                                    struct snd_ctl_elem_value *ucontrol)
 765{
 766        ucontrol->value.enumerated.item[0] = kctl->private_value;
 767        return 0;
 768}
 769
 770static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input)
 771{
 772        struct snd_usb_audio *chip = mixer->chip;
 773        int err;
 774
 775        err = snd_usb_lock_shutdown(chip);
 776        if (err < 0)
 777                return err;
 778
 779        err = snd_mbox1_is_spdif_input(chip);
 780        if (err < 0)
 781                goto err;
 782
 783        err = snd_mbox1_set_input_source(chip, is_spdif_input);
 784        if (err < 0)
 785                goto err;
 786
 787        err = snd_mbox1_is_spdif_input(chip);
 788        if (err < 0)
 789                goto err;
 790
 791        err = snd_mbox1_is_spdif_synced(chip);
 792err:
 793        snd_usb_unlock_shutdown(chip);
 794        return err;
 795}
 796
 797static int snd_mbox1_src_switch_put(struct snd_kcontrol *kctl,
 798                                    struct snd_ctl_elem_value *ucontrol)
 799{
 800        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
 801        struct usb_mixer_interface *mixer = list->mixer;
 802        int err;
 803        bool cur_val, new_val;
 804
 805        cur_val = kctl->private_value;
 806        new_val = ucontrol->value.enumerated.item[0];
 807        if (cur_val == new_val)
 808                return 0;
 809
 810        kctl->private_value = new_val;
 811        err = snd_mbox1_src_switch_update(mixer, new_val);
 812        return err < 0 ? err : 1;
 813}
 814
 815static int snd_mbox1_src_switch_info(struct snd_kcontrol *kcontrol,
 816                                     struct snd_ctl_elem_info *uinfo)
 817{
 818        static const char *const texts[2] = {
 819                "Analog",
 820                "S/PDIF"
 821        };
 822
 823        return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
 824}
 825
 826static int snd_mbox1_src_switch_resume(struct usb_mixer_elem_list *list)
 827{
 828        return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value);
 829}
 830
 831static const struct snd_kcontrol_new snd_mbox1_clk_switch = {
 832        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 833        .name = "Clock Source",
 834        .index = 0,
 835        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 836        .info = snd_mbox1_clk_switch_info,
 837        .get = snd_mbox1_clk_switch_get,
 838        .put = snd_mbox1_clk_switch_put,
 839        .private_value = 0
 840};
 841
 842static const struct snd_kcontrol_new snd_mbox1_src_switch = {
 843        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 844        .name = "Input Source",
 845        .index = 1,
 846        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 847        .info = snd_mbox1_src_switch_info,
 848        .get = snd_mbox1_src_switch_get,
 849        .put = snd_mbox1_src_switch_put,
 850        .private_value = 0
 851};
 852
 853static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer)
 854{
 855        int err;
 856        err = add_single_ctl_with_resume(mixer, 0,
 857                                         snd_mbox1_clk_switch_resume,
 858                                         &snd_mbox1_clk_switch, NULL);
 859        if (err < 0)
 860                return err;
 861
 862        return add_single_ctl_with_resume(mixer, 1,
 863                                          snd_mbox1_src_switch_resume,
 864                                          &snd_mbox1_src_switch, NULL);
 865}
 866
 867/* Native Instruments device quirks */
 868
 869#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))
 870
 871static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
 872                                   struct snd_kcontrol *kctl)
 873{
 874        struct usb_device *dev = mixer->chip->dev;
 875        unsigned int pval = kctl->private_value;
 876        u8 value;
 877        int err;
 878
 879        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
 880                              (pval >> 16) & 0xff,
 881                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
 882                              0, pval & 0xffff, &value, 1);
 883        if (err < 0) {
 884                dev_err(&dev->dev,
 885                        "unable to issue vendor read request (ret = %d)", err);
 886                return err;
 887        }
 888
 889        kctl->private_value |= ((unsigned int)value << 24);
 890        return 0;
 891}
 892
 893static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
 894                                             struct snd_ctl_elem_value *ucontrol)
 895{
 896        ucontrol->value.integer.value[0] = kcontrol->private_value >> 24;
 897        return 0;
 898}
 899
 900static int snd_ni_update_cur_val(struct usb_mixer_elem_list *list)
 901{
 902        struct snd_usb_audio *chip = list->mixer->chip;
 903        unsigned int pval = list->kctl->private_value;
 904        int err;
 905
 906        err = snd_usb_lock_shutdown(chip);
 907        if (err < 0)
 908                return err;
 909        err = usb_control_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
 910                              (pval >> 16) & 0xff,
 911                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
 912                              pval >> 24, pval & 0xffff, NULL, 0, 1000);
 913        snd_usb_unlock_shutdown(chip);
 914        return err;
 915}
 916
 917static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
 918                                             struct snd_ctl_elem_value *ucontrol)
 919{
 920        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
 921        u8 oldval = (kcontrol->private_value >> 24) & 0xff;
 922        u8 newval = ucontrol->value.integer.value[0];
 923        int err;
 924
 925        if (oldval == newval)
 926                return 0;
 927
 928        kcontrol->private_value &= ~(0xff << 24);
 929        kcontrol->private_value |= (unsigned int)newval << 24;
 930        err = snd_ni_update_cur_val(list);
 931        return err < 0 ? err : 1;
 932}
 933
 934static const struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
 935        {
 936                .name = "Direct Thru Channel A",
 937                .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
 938        },
 939        {
 940                .name = "Direct Thru Channel B",
 941                .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
 942        },
 943        {
 944                .name = "Phono Input Channel A",
 945                .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
 946        },
 947        {
 948                .name = "Phono Input Channel B",
 949                .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
 950        },
 951};
 952
 953static const struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
 954        {
 955                .name = "Direct Thru Channel A",
 956                .private_value = _MAKE_NI_CONTROL(0x01, 0x03),
 957        },
 958        {
 959                .name = "Direct Thru Channel B",
 960                .private_value = _MAKE_NI_CONTROL(0x01, 0x05),
 961        },
 962        {
 963                .name = "Direct Thru Channel C",
 964                .private_value = _MAKE_NI_CONTROL(0x01, 0x07),
 965        },
 966        {
 967                .name = "Direct Thru Channel D",
 968                .private_value = _MAKE_NI_CONTROL(0x01, 0x09),
 969        },
 970        {
 971                .name = "Phono Input Channel A",
 972                .private_value = _MAKE_NI_CONTROL(0x02, 0x03),
 973        },
 974        {
 975                .name = "Phono Input Channel B",
 976                .private_value = _MAKE_NI_CONTROL(0x02, 0x05),
 977        },
 978        {
 979                .name = "Phono Input Channel C",
 980                .private_value = _MAKE_NI_CONTROL(0x02, 0x07),
 981        },
 982        {
 983                .name = "Phono Input Channel D",
 984                .private_value = _MAKE_NI_CONTROL(0x02, 0x09),
 985        },
 986};
 987
 988static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
 989                                              const struct snd_kcontrol_new *kc,
 990                                              unsigned int count)
 991{
 992        int i, err = 0;
 993        struct snd_kcontrol_new template = {
 994                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 995                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
 996                .get = snd_nativeinstruments_control_get,
 997                .put = snd_nativeinstruments_control_put,
 998                .info = snd_ctl_boolean_mono_info,
 999        };
1000
1001        for (i = 0; i < count; i++) {
1002                struct usb_mixer_elem_list *list;
1003
1004                template.name = kc[i].name;
1005                template.private_value = kc[i].private_value;
1006
1007                err = add_single_ctl_with_resume(mixer, 0,
1008                                                 snd_ni_update_cur_val,
1009                                                 &template, &list);
1010                if (err < 0)
1011                        break;
1012                snd_ni_control_init_val(mixer, list->kctl);
1013        }
1014
1015        return err;
1016}
1017
1018/* M-Audio FastTrack Ultra quirks */
1019/* FTU Effect switch (also used by C400/C600) */
1020static int snd_ftu_eff_switch_info(struct snd_kcontrol *kcontrol,
1021                                        struct snd_ctl_elem_info *uinfo)
1022{
1023        static const char *const texts[8] = {
1024                "Room 1", "Room 2", "Room 3", "Hall 1",
1025                "Hall 2", "Plate", "Delay", "Echo"
1026        };
1027
1028        return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1029}
1030
1031static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
1032                                   struct snd_kcontrol *kctl)
1033{
1034        struct usb_device *dev = mixer->chip->dev;
1035        unsigned int pval = kctl->private_value;
1036        int err;
1037        unsigned char value[2];
1038
1039        value[0] = 0x00;
1040        value[1] = 0x00;
1041
1042        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR,
1043                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1044                              pval & 0xff00,
1045                              snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
1046                              value, 2);
1047        if (err < 0)
1048                return err;
1049
1050        kctl->private_value |= (unsigned int)value[0] << 24;
1051        return 0;
1052}
1053
1054static int snd_ftu_eff_switch_get(struct snd_kcontrol *kctl,
1055                                        struct snd_ctl_elem_value *ucontrol)
1056{
1057        ucontrol->value.enumerated.item[0] = kctl->private_value >> 24;
1058        return 0;
1059}
1060
1061static int snd_ftu_eff_switch_update(struct usb_mixer_elem_list *list)
1062{
1063        struct snd_usb_audio *chip = list->mixer->chip;
1064        unsigned int pval = list->kctl->private_value;
1065        unsigned char value[2];
1066        int err;
1067
1068        value[0] = pval >> 24;
1069        value[1] = 0;
1070
1071        err = snd_usb_lock_shutdown(chip);
1072        if (err < 0)
1073                return err;
1074        err = snd_usb_ctl_msg(chip->dev,
1075                              usb_sndctrlpipe(chip->dev, 0),
1076                              UAC_SET_CUR,
1077                              USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1078                              pval & 0xff00,
1079                              snd_usb_ctrl_intf(chip) | ((pval & 0xff) << 8),
1080                              value, 2);
1081        snd_usb_unlock_shutdown(chip);
1082        return err;
1083}
1084
1085static int snd_ftu_eff_switch_put(struct snd_kcontrol *kctl,
1086                                        struct snd_ctl_elem_value *ucontrol)
1087{
1088        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
1089        unsigned int pval = list->kctl->private_value;
1090        int cur_val, err, new_val;
1091
1092        cur_val = pval >> 24;
1093        new_val = ucontrol->value.enumerated.item[0];
1094        if (cur_val == new_val)
1095                return 0;
1096
1097        kctl->private_value &= ~(0xff << 24);
1098        kctl->private_value |= new_val << 24;
1099        err = snd_ftu_eff_switch_update(list);
1100        return err < 0 ? err : 1;
1101}
1102
1103static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
1104        int validx, int bUnitID)
1105{
1106        static struct snd_kcontrol_new template = {
1107                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1108                .name = "Effect Program Switch",
1109                .index = 0,
1110                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
1111                .info = snd_ftu_eff_switch_info,
1112                .get = snd_ftu_eff_switch_get,
1113                .put = snd_ftu_eff_switch_put
1114        };
1115        struct usb_mixer_elem_list *list;
1116        int err;
1117
1118        err = add_single_ctl_with_resume(mixer, bUnitID,
1119                                         snd_ftu_eff_switch_update,
1120                                         &template, &list);
1121        if (err < 0)
1122                return err;
1123        list->kctl->private_value = (validx << 8) | bUnitID;
1124        snd_ftu_eff_switch_init(mixer, list->kctl);
1125        return 0;
1126}
1127
1128/* Create volume controls for FTU devices*/
1129static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
1130{
1131        char name[64];
1132        unsigned int control, cmask;
1133        int in, out, err;
1134
1135        const unsigned int id = 5;
1136        const int val_type = USB_MIXER_S16;
1137
1138        for (out = 0; out < 8; out++) {
1139                control = out + 1;
1140                for (in = 0; in < 8; in++) {
1141                        cmask = 1 << in;
1142                        snprintf(name, sizeof(name),
1143                                "AIn%d - Out%d Capture Volume",
1144                                in  + 1, out + 1);
1145                        err = snd_create_std_mono_ctl(mixer, id, control,
1146                                                        cmask, val_type, name,
1147                                                        &snd_usb_mixer_vol_tlv);
1148                        if (err < 0)
1149                                return err;
1150                }
1151                for (in = 8; in < 16; in++) {
1152                        cmask = 1 << in;
1153                        snprintf(name, sizeof(name),
1154                                "DIn%d - Out%d Playback Volume",
1155                                in - 7, out + 1);
1156                        err = snd_create_std_mono_ctl(mixer, id, control,
1157                                                        cmask, val_type, name,
1158                                                        &snd_usb_mixer_vol_tlv);
1159                        if (err < 0)
1160                                return err;
1161                }
1162        }
1163
1164        return 0;
1165}
1166
1167/* This control needs a volume quirk, see mixer.c */
1168static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1169{
1170        static const char name[] = "Effect Volume";
1171        const unsigned int id = 6;
1172        const int val_type = USB_MIXER_U8;
1173        const unsigned int control = 2;
1174        const unsigned int cmask = 0;
1175
1176        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1177                                        name, snd_usb_mixer_vol_tlv);
1178}
1179
1180/* This control needs a volume quirk, see mixer.c */
1181static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1182{
1183        static const char name[] = "Effect Duration";
1184        const unsigned int id = 6;
1185        const int val_type = USB_MIXER_S16;
1186        const unsigned int control = 3;
1187        const unsigned int cmask = 0;
1188
1189        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1190                                        name, snd_usb_mixer_vol_tlv);
1191}
1192
1193/* This control needs a volume quirk, see mixer.c */
1194static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1195{
1196        static const char name[] = "Effect Feedback Volume";
1197        const unsigned int id = 6;
1198        const int val_type = USB_MIXER_U8;
1199        const unsigned int control = 4;
1200        const unsigned int cmask = 0;
1201
1202        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1203                                        name, NULL);
1204}
1205
1206static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1207{
1208        unsigned int cmask;
1209        int err, ch;
1210        char name[48];
1211
1212        const unsigned int id = 7;
1213        const int val_type = USB_MIXER_S16;
1214        const unsigned int control = 7;
1215
1216        for (ch = 0; ch < 4; ++ch) {
1217                cmask = 1 << ch;
1218                snprintf(name, sizeof(name),
1219                        "Effect Return %d Volume", ch + 1);
1220                err = snd_create_std_mono_ctl(mixer, id, control,
1221                                                cmask, val_type, name,
1222                                                snd_usb_mixer_vol_tlv);
1223                if (err < 0)
1224                        return err;
1225        }
1226
1227        return 0;
1228}
1229
1230static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1231{
1232        unsigned int  cmask;
1233        int err, ch;
1234        char name[48];
1235
1236        const unsigned int id = 5;
1237        const int val_type = USB_MIXER_S16;
1238        const unsigned int control = 9;
1239
1240        for (ch = 0; ch < 8; ++ch) {
1241                cmask = 1 << ch;
1242                snprintf(name, sizeof(name),
1243                        "Effect Send AIn%d Volume", ch + 1);
1244                err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1245                                                val_type, name,
1246                                                snd_usb_mixer_vol_tlv);
1247                if (err < 0)
1248                        return err;
1249        }
1250        for (ch = 8; ch < 16; ++ch) {
1251                cmask = 1 << ch;
1252                snprintf(name, sizeof(name),
1253                        "Effect Send DIn%d Volume", ch - 7);
1254                err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1255                                                val_type, name,
1256                                                snd_usb_mixer_vol_tlv);
1257                if (err < 0)
1258                        return err;
1259        }
1260        return 0;
1261}
1262
1263static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1264{
1265        int err;
1266
1267        err = snd_ftu_create_volume_ctls(mixer);
1268        if (err < 0)
1269                return err;
1270
1271        err = snd_ftu_create_effect_switch(mixer, 1, 6);
1272        if (err < 0)
1273                return err;
1274
1275        err = snd_ftu_create_effect_volume_ctl(mixer);
1276        if (err < 0)
1277                return err;
1278
1279        err = snd_ftu_create_effect_duration_ctl(mixer);
1280        if (err < 0)
1281                return err;
1282
1283        err = snd_ftu_create_effect_feedback_ctl(mixer);
1284        if (err < 0)
1285                return err;
1286
1287        err = snd_ftu_create_effect_return_ctls(mixer);
1288        if (err < 0)
1289                return err;
1290
1291        err = snd_ftu_create_effect_send_ctls(mixer);
1292        if (err < 0)
1293                return err;
1294
1295        return 0;
1296}
1297
1298void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
1299                               unsigned char samplerate_id)
1300{
1301        struct usb_mixer_interface *mixer;
1302        struct usb_mixer_elem_info *cval;
1303        int unitid = 12; /* SampleRate ExtensionUnit ID */
1304
1305        list_for_each_entry(mixer, &chip->mixer_list, list) {
1306                if (mixer->id_elems[unitid]) {
1307                        cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1308                        snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
1309                                                    cval->control << 8,
1310                                                    samplerate_id);
1311                        snd_usb_mixer_notify_id(mixer, unitid);
1312                        break;
1313                }
1314        }
1315}
1316
1317/* M-Audio Fast Track C400/C600 */
1318/* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1319static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1320{
1321        char name[64];
1322        unsigned int cmask, offset;
1323        int out, chan, err;
1324        int num_outs = 0;
1325        int num_ins = 0;
1326
1327        const unsigned int id = 0x40;
1328        const int val_type = USB_MIXER_S16;
1329        const int control = 1;
1330
1331        switch (mixer->chip->usb_id) {
1332        case USB_ID(0x0763, 0x2030):
1333                num_outs = 6;
1334                num_ins = 4;
1335                break;
1336        case USB_ID(0x0763, 0x2031):
1337                num_outs = 8;
1338                num_ins = 6;
1339                break;
1340        }
1341
1342        for (chan = 0; chan < num_outs + num_ins; chan++) {
1343                for (out = 0; out < num_outs; out++) {
1344                        if (chan < num_outs) {
1345                                snprintf(name, sizeof(name),
1346                                        "PCM%d-Out%d Playback Volume",
1347                                        chan + 1, out + 1);
1348                        } else {
1349                                snprintf(name, sizeof(name),
1350                                        "In%d-Out%d Playback Volume",
1351                                        chan - num_outs + 1, out + 1);
1352                        }
1353
1354                        cmask = (out == 0) ? 0 : 1 << (out - 1);
1355                        offset = chan * num_outs;
1356                        err = snd_create_std_mono_ctl_offset(mixer, id, control,
1357                                                cmask, val_type, offset, name,
1358                                                &snd_usb_mixer_vol_tlv);
1359                        if (err < 0)
1360                                return err;
1361                }
1362        }
1363
1364        return 0;
1365}
1366
1367/* This control needs a volume quirk, see mixer.c */
1368static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1369{
1370        static const char name[] = "Effect Volume";
1371        const unsigned int id = 0x43;
1372        const int val_type = USB_MIXER_U8;
1373        const unsigned int control = 3;
1374        const unsigned int cmask = 0;
1375
1376        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1377                                        name, snd_usb_mixer_vol_tlv);
1378}
1379
1380/* This control needs a volume quirk, see mixer.c */
1381static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1382{
1383        static const char name[] = "Effect Duration";
1384        const unsigned int id = 0x43;
1385        const int val_type = USB_MIXER_S16;
1386        const unsigned int control = 4;
1387        const unsigned int cmask = 0;
1388
1389        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1390                                        name, snd_usb_mixer_vol_tlv);
1391}
1392
1393/* This control needs a volume quirk, see mixer.c */
1394static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1395{
1396        static const char name[] = "Effect Feedback Volume";
1397        const unsigned int id = 0x43;
1398        const int val_type = USB_MIXER_U8;
1399        const unsigned int control = 5;
1400        const unsigned int cmask = 0;
1401
1402        return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1403                                        name, NULL);
1404}
1405
1406static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1407{
1408        char name[64];
1409        unsigned int cmask;
1410        int chan, err;
1411        int num_outs = 0;
1412        int num_ins = 0;
1413
1414        const unsigned int id = 0x42;
1415        const int val_type = USB_MIXER_S16;
1416        const int control = 1;
1417
1418        switch (mixer->chip->usb_id) {
1419        case USB_ID(0x0763, 0x2030):
1420                num_outs = 6;
1421                num_ins = 4;
1422                break;
1423        case USB_ID(0x0763, 0x2031):
1424                num_outs = 8;
1425                num_ins = 6;
1426                break;
1427        }
1428
1429        for (chan = 0; chan < num_outs + num_ins; chan++) {
1430                if (chan < num_outs) {
1431                        snprintf(name, sizeof(name),
1432                                "Effect Send DOut%d",
1433                                chan + 1);
1434                } else {
1435                        snprintf(name, sizeof(name),
1436                                "Effect Send AIn%d",
1437                                chan - num_outs + 1);
1438                }
1439
1440                cmask = (chan == 0) ? 0 : 1 << (chan - 1);
1441                err = snd_create_std_mono_ctl(mixer, id, control,
1442                                                cmask, val_type, name,
1443                                                &snd_usb_mixer_vol_tlv);
1444                if (err < 0)
1445                        return err;
1446        }
1447
1448        return 0;
1449}
1450
1451static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1452{
1453        char name[64];
1454        unsigned int cmask;
1455        int chan, err;
1456        int num_outs = 0;
1457        int offset = 0;
1458
1459        const unsigned int id = 0x40;
1460        const int val_type = USB_MIXER_S16;
1461        const int control = 1;
1462
1463        switch (mixer->chip->usb_id) {
1464        case USB_ID(0x0763, 0x2030):
1465                num_outs = 6;
1466                offset = 0x3c;
1467                /* { 0x3c, 0x43, 0x3e, 0x45, 0x40, 0x47 } */
1468                break;
1469        case USB_ID(0x0763, 0x2031):
1470                num_outs = 8;
1471                offset = 0x70;
1472                /* { 0x70, 0x79, 0x72, 0x7b, 0x74, 0x7d, 0x76, 0x7f } */
1473                break;
1474        }
1475
1476        for (chan = 0; chan < num_outs; chan++) {
1477                snprintf(name, sizeof(name),
1478                        "Effect Return %d",
1479                        chan + 1);
1480
1481                cmask = (chan == 0) ? 0 :
1482                        1 << (chan + (chan % 2) * num_outs - 1);
1483                err = snd_create_std_mono_ctl_offset(mixer, id, control,
1484                                                cmask, val_type, offset, name,
1485                                                &snd_usb_mixer_vol_tlv);
1486                if (err < 0)
1487                        return err;
1488        }
1489
1490        return 0;
1491}
1492
1493static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1494{
1495        int err;
1496
1497        err = snd_c400_create_vol_ctls(mixer);
1498        if (err < 0)
1499                return err;
1500
1501        err = snd_c400_create_effect_vol_ctls(mixer);
1502        if (err < 0)
1503                return err;
1504
1505        err = snd_c400_create_effect_ret_vol_ctls(mixer);
1506        if (err < 0)
1507                return err;
1508
1509        err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1510        if (err < 0)
1511                return err;
1512
1513        err = snd_c400_create_effect_volume_ctl(mixer);
1514        if (err < 0)
1515                return err;
1516
1517        err = snd_c400_create_effect_duration_ctl(mixer);
1518        if (err < 0)
1519                return err;
1520
1521        err = snd_c400_create_effect_feedback_ctl(mixer);
1522        if (err < 0)
1523                return err;
1524
1525        return 0;
1526}
1527
1528/*
1529 * The mixer units for Ebox-44 are corrupt, and even where they
1530 * are valid they presents mono controls as L and R channels of
1531 * stereo. So we provide a good mixer here.
1532 */
1533static const struct std_mono_table ebox44_table[] = {
1534        {
1535                .unitid = 4,
1536                .control = 1,
1537                .cmask = 0x0,
1538                .val_type = USB_MIXER_INV_BOOLEAN,
1539                .name = "Headphone Playback Switch"
1540        },
1541        {
1542                .unitid = 4,
1543                .control = 2,
1544                .cmask = 0x1,
1545                .val_type = USB_MIXER_S16,
1546                .name = "Headphone A Mix Playback Volume"
1547        },
1548        {
1549                .unitid = 4,
1550                .control = 2,
1551                .cmask = 0x2,
1552                .val_type = USB_MIXER_S16,
1553                .name = "Headphone B Mix Playback Volume"
1554        },
1555
1556        {
1557                .unitid = 7,
1558                .control = 1,
1559                .cmask = 0x0,
1560                .val_type = USB_MIXER_INV_BOOLEAN,
1561                .name = "Output Playback Switch"
1562        },
1563        {
1564                .unitid = 7,
1565                .control = 2,
1566                .cmask = 0x1,
1567                .val_type = USB_MIXER_S16,
1568                .name = "Output A Playback Volume"
1569        },
1570        {
1571                .unitid = 7,
1572                .control = 2,
1573                .cmask = 0x2,
1574                .val_type = USB_MIXER_S16,
1575                .name = "Output B Playback Volume"
1576        },
1577
1578        {
1579                .unitid = 10,
1580                .control = 1,
1581                .cmask = 0x0,
1582                .val_type = USB_MIXER_INV_BOOLEAN,
1583                .name = "Input Capture Switch"
1584        },
1585        {
1586                .unitid = 10,
1587                .control = 2,
1588                .cmask = 0x1,
1589                .val_type = USB_MIXER_S16,
1590                .name = "Input A Capture Volume"
1591        },
1592        {
1593                .unitid = 10,
1594                .control = 2,
1595                .cmask = 0x2,
1596                .val_type = USB_MIXER_S16,
1597                .name = "Input B Capture Volume"
1598        },
1599
1600        {}
1601};
1602
1603/* Audio Advantage Micro II findings:
1604 *
1605 * Mapping spdif AES bits to vendor register.bit:
1606 * AES0: [0 0 0 0 2.3 2.2 2.1 2.0] - default 0x00
1607 * AES1: [3.3 3.2.3.1.3.0 2.7 2.6 2.5 2.4] - default: 0x01
1608 * AES2: [0 0 0 0 0 0 0 0]
1609 * AES3: [0 0 0 0 0 0 x 0] - 'x' bit is set basing on standard usb request
1610 *                           (UAC_EP_CS_ATTR_SAMPLE_RATE) for Audio Devices
1611 *
1612 * power on values:
1613 * r2: 0x10
1614 * r3: 0x20 (b7 is zeroed just before playback (except IEC61937) and set
1615 *           just after it to 0xa0, presumably it disables/mutes some analog
1616 *           parts when there is no audio.)
1617 * r9: 0x28
1618 *
1619 * Optical transmitter on/off:
1620 * vendor register.bit: 9.1
1621 * 0 - on (0x28 register value)
1622 * 1 - off (0x2a register value)
1623 *
1624 */
1625static int snd_microii_spdif_info(struct snd_kcontrol *kcontrol,
1626        struct snd_ctl_elem_info *uinfo)
1627{
1628        uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
1629        uinfo->count = 1;
1630        return 0;
1631}
1632
1633static int snd_microii_spdif_default_get(struct snd_kcontrol *kcontrol,
1634        struct snd_ctl_elem_value *ucontrol)
1635{
1636        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1637        struct snd_usb_audio *chip = list->mixer->chip;
1638        int err;
1639        struct usb_interface *iface;
1640        struct usb_host_interface *alts;
1641        unsigned int ep;
1642        unsigned char data[3];
1643        int rate;
1644
1645        err = snd_usb_lock_shutdown(chip);
1646        if (err < 0)
1647                return err;
1648
1649        ucontrol->value.iec958.status[0] = kcontrol->private_value & 0xff;
1650        ucontrol->value.iec958.status[1] = (kcontrol->private_value >> 8) & 0xff;
1651        ucontrol->value.iec958.status[2] = 0x00;
1652
1653        /* use known values for that card: interface#1 altsetting#1 */
1654        iface = usb_ifnum_to_if(chip->dev, 1);
1655        if (!iface || iface->num_altsetting < 2) {
1656                err = -EINVAL;
1657                goto end;
1658        }
1659        alts = &iface->altsetting[1];
1660        if (get_iface_desc(alts)->bNumEndpoints < 1) {
1661                err = -EINVAL;
1662                goto end;
1663        }
1664        ep = get_endpoint(alts, 0)->bEndpointAddress;
1665
1666        err = snd_usb_ctl_msg(chip->dev,
1667                        usb_rcvctrlpipe(chip->dev, 0),
1668                        UAC_GET_CUR,
1669                        USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN,
1670                        UAC_EP_CS_ATTR_SAMPLE_RATE << 8,
1671                        ep,
1672                        data,
1673                        sizeof(data));
1674        if (err < 0)
1675                goto end;
1676
1677        rate = data[0] | (data[1] << 8) | (data[2] << 16);
1678        ucontrol->value.iec958.status[3] = (rate == 48000) ?
1679                        IEC958_AES3_CON_FS_48000 : IEC958_AES3_CON_FS_44100;
1680
1681        err = 0;
1682 end:
1683        snd_usb_unlock_shutdown(chip);
1684        return err;
1685}
1686
1687static int snd_microii_spdif_default_update(struct usb_mixer_elem_list *list)
1688{
1689        struct snd_usb_audio *chip = list->mixer->chip;
1690        unsigned int pval = list->kctl->private_value;
1691        u8 reg;
1692        int err;
1693
1694        err = snd_usb_lock_shutdown(chip);
1695        if (err < 0)
1696                return err;
1697
1698        reg = ((pval >> 4) & 0xf0) | (pval & 0x0f);
1699        err = snd_usb_ctl_msg(chip->dev,
1700                        usb_sndctrlpipe(chip->dev, 0),
1701                        UAC_SET_CUR,
1702                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1703                        reg,
1704                        2,
1705                        NULL,
1706                        0);
1707        if (err < 0)
1708                goto end;
1709
1710        reg = (pval & IEC958_AES0_NONAUDIO) ? 0xa0 : 0x20;
1711        reg |= (pval >> 12) & 0x0f;
1712        err = snd_usb_ctl_msg(chip->dev,
1713                        usb_sndctrlpipe(chip->dev, 0),
1714                        UAC_SET_CUR,
1715                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1716                        reg,
1717                        3,
1718                        NULL,
1719                        0);
1720        if (err < 0)
1721                goto end;
1722
1723 end:
1724        snd_usb_unlock_shutdown(chip);
1725        return err;
1726}
1727
1728static int snd_microii_spdif_default_put(struct snd_kcontrol *kcontrol,
1729        struct snd_ctl_elem_value *ucontrol)
1730{
1731        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1732        unsigned int pval, pval_old;
1733        int err;
1734
1735        pval = pval_old = kcontrol->private_value;
1736        pval &= 0xfffff0f0;
1737        pval |= (ucontrol->value.iec958.status[1] & 0x0f) << 8;
1738        pval |= (ucontrol->value.iec958.status[0] & 0x0f);
1739
1740        pval &= 0xffff0fff;
1741        pval |= (ucontrol->value.iec958.status[1] & 0xf0) << 8;
1742
1743        /* The frequency bits in AES3 cannot be set via register access. */
1744
1745        /* Silently ignore any bits from the request that cannot be set. */
1746
1747        if (pval == pval_old)
1748                return 0;
1749
1750        kcontrol->private_value = pval;
1751        err = snd_microii_spdif_default_update(list);
1752        return err < 0 ? err : 1;
1753}
1754
1755static int snd_microii_spdif_mask_get(struct snd_kcontrol *kcontrol,
1756        struct snd_ctl_elem_value *ucontrol)
1757{
1758        ucontrol->value.iec958.status[0] = 0x0f;
1759        ucontrol->value.iec958.status[1] = 0xff;
1760        ucontrol->value.iec958.status[2] = 0x00;
1761        ucontrol->value.iec958.status[3] = 0x00;
1762
1763        return 0;
1764}
1765
1766static int snd_microii_spdif_switch_get(struct snd_kcontrol *kcontrol,
1767        struct snd_ctl_elem_value *ucontrol)
1768{
1769        ucontrol->value.integer.value[0] = !(kcontrol->private_value & 0x02);
1770
1771        return 0;
1772}
1773
1774static int snd_microii_spdif_switch_update(struct usb_mixer_elem_list *list)
1775{
1776        struct snd_usb_audio *chip = list->mixer->chip;
1777        u8 reg = list->kctl->private_value;
1778        int err;
1779
1780        err = snd_usb_lock_shutdown(chip);
1781        if (err < 0)
1782                return err;
1783
1784        err = snd_usb_ctl_msg(chip->dev,
1785                        usb_sndctrlpipe(chip->dev, 0),
1786                        UAC_SET_CUR,
1787                        USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
1788                        reg,
1789                        9,
1790                        NULL,
1791                        0);
1792
1793        snd_usb_unlock_shutdown(chip);
1794        return err;
1795}
1796
1797static int snd_microii_spdif_switch_put(struct snd_kcontrol *kcontrol,
1798        struct snd_ctl_elem_value *ucontrol)
1799{
1800        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1801        u8 reg;
1802        int err;
1803
1804        reg = ucontrol->value.integer.value[0] ? 0x28 : 0x2a;
1805        if (reg != list->kctl->private_value)
1806                return 0;
1807
1808        kcontrol->private_value = reg;
1809        err = snd_microii_spdif_switch_update(list);
1810        return err < 0 ? err : 1;
1811}
1812
1813static const struct snd_kcontrol_new snd_microii_mixer_spdif[] = {
1814        {
1815                .iface =    SNDRV_CTL_ELEM_IFACE_PCM,
1816                .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
1817                .info =     snd_microii_spdif_info,
1818                .get =      snd_microii_spdif_default_get,
1819                .put =      snd_microii_spdif_default_put,
1820                .private_value = 0x00000100UL,/* reset value */
1821        },
1822        {
1823                .access =   SNDRV_CTL_ELEM_ACCESS_READ,
1824                .iface =    SNDRV_CTL_ELEM_IFACE_PCM,
1825                .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, MASK),
1826                .info =     snd_microii_spdif_info,
1827                .get =      snd_microii_spdif_mask_get,
1828        },
1829        {
1830                .iface =    SNDRV_CTL_ELEM_IFACE_MIXER,
1831                .name =     SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
1832                .info =     snd_ctl_boolean_mono_info,
1833                .get =      snd_microii_spdif_switch_get,
1834                .put =      snd_microii_spdif_switch_put,
1835                .private_value = 0x00000028UL,/* reset value */
1836        }
1837};
1838
1839static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1840{
1841        int err, i;
1842        static const usb_mixer_elem_resume_func_t resume_funcs[] = {
1843                snd_microii_spdif_default_update,
1844                NULL,
1845                snd_microii_spdif_switch_update
1846        };
1847
1848        for (i = 0; i < ARRAY_SIZE(snd_microii_mixer_spdif); ++i) {
1849                err = add_single_ctl_with_resume(mixer, 0,
1850                                                 resume_funcs[i],
1851                                                 &snd_microii_mixer_spdif[i],
1852                                                 NULL);
1853                if (err < 0)
1854                        return err;
1855        }
1856
1857        return 0;
1858}
1859
1860/* Creative Sound Blaster E1 */
1861
1862static int snd_soundblaster_e1_switch_get(struct snd_kcontrol *kcontrol,
1863                                          struct snd_ctl_elem_value *ucontrol)
1864{
1865        ucontrol->value.integer.value[0] = kcontrol->private_value;
1866        return 0;
1867}
1868
1869static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1870                                             unsigned char state)
1871{
1872        struct snd_usb_audio *chip = mixer->chip;
1873        int err;
1874        unsigned char buff[2];
1875
1876        buff[0] = 0x02;
1877        buff[1] = state ? 0x02 : 0x00;
1878
1879        err = snd_usb_lock_shutdown(chip);
1880        if (err < 0)
1881                return err;
1882        err = snd_usb_ctl_msg(chip->dev,
1883                        usb_sndctrlpipe(chip->dev, 0), HID_REQ_SET_REPORT,
1884                        USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
1885                        0x0202, 3, buff, 2);
1886        snd_usb_unlock_shutdown(chip);
1887        return err;
1888}
1889
1890static int snd_soundblaster_e1_switch_put(struct snd_kcontrol *kcontrol,
1891                                          struct snd_ctl_elem_value *ucontrol)
1892{
1893        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
1894        unsigned char value = !!ucontrol->value.integer.value[0];
1895        int err;
1896
1897        if (kcontrol->private_value == value)
1898                return 0;
1899        kcontrol->private_value = value;
1900        err = snd_soundblaster_e1_switch_update(list->mixer, value);
1901        return err < 0 ? err : 1;
1902}
1903
1904static int snd_soundblaster_e1_switch_resume(struct usb_mixer_elem_list *list)
1905{
1906        return snd_soundblaster_e1_switch_update(list->mixer,
1907                                                 list->kctl->private_value);
1908}
1909
1910static int snd_soundblaster_e1_switch_info(struct snd_kcontrol *kcontrol,
1911                                           struct snd_ctl_elem_info *uinfo)
1912{
1913        static const char *const texts[2] = {
1914                "Mic", "Aux"
1915        };
1916
1917        return snd_ctl_enum_info(uinfo, 1, ARRAY_SIZE(texts), texts);
1918}
1919
1920static const struct snd_kcontrol_new snd_soundblaster_e1_input_switch = {
1921        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1922        .name = "Input Source",
1923        .info = snd_soundblaster_e1_switch_info,
1924        .get = snd_soundblaster_e1_switch_get,
1925        .put = snd_soundblaster_e1_switch_put,
1926        .private_value = 0,
1927};
1928
1929static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1930{
1931        return add_single_ctl_with_resume(mixer, 0,
1932                                          snd_soundblaster_e1_switch_resume,
1933                                          &snd_soundblaster_e1_input_switch,
1934                                          NULL);
1935}
1936
1937static void dell_dock_init_vol(struct snd_usb_audio *chip, int ch, int id)
1938{
1939        u16 buf = 0;
1940
1941        snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), UAC_SET_CUR,
1942                        USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1943                        ch, snd_usb_ctrl_intf(chip) | (id << 8),
1944                        &buf, 2);
1945}
1946
1947static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
1948{
1949        /* fix to 0dB playback volumes */
1950        dell_dock_init_vol(mixer->chip, 1, 16);
1951        dell_dock_init_vol(mixer->chip, 2, 16);
1952        dell_dock_init_vol(mixer->chip, 1, 19);
1953        dell_dock_init_vol(mixer->chip, 2, 19);
1954        return 0;
1955}
1956
1957/* RME Class Compliant device quirks */
1958
1959#define SND_RME_GET_STATUS1                     23
1960#define SND_RME_GET_CURRENT_FREQ                17
1961#define SND_RME_CLK_SYSTEM_SHIFT                16
1962#define SND_RME_CLK_SYSTEM_MASK                 0x1f
1963#define SND_RME_CLK_AES_SHIFT                   8
1964#define SND_RME_CLK_SPDIF_SHIFT                 12
1965#define SND_RME_CLK_AES_SPDIF_MASK              0xf
1966#define SND_RME_CLK_SYNC_SHIFT                  6
1967#define SND_RME_CLK_SYNC_MASK                   0x3
1968#define SND_RME_CLK_FREQMUL_SHIFT               18
1969#define SND_RME_CLK_FREQMUL_MASK                0x7
1970#define SND_RME_CLK_SYSTEM(x) \
1971        ((x >> SND_RME_CLK_SYSTEM_SHIFT) & SND_RME_CLK_SYSTEM_MASK)
1972#define SND_RME_CLK_AES(x) \
1973        ((x >> SND_RME_CLK_AES_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1974#define SND_RME_CLK_SPDIF(x) \
1975        ((x >> SND_RME_CLK_SPDIF_SHIFT) & SND_RME_CLK_AES_SPDIF_MASK)
1976#define SND_RME_CLK_SYNC(x) \
1977        ((x >> SND_RME_CLK_SYNC_SHIFT) & SND_RME_CLK_SYNC_MASK)
1978#define SND_RME_CLK_FREQMUL(x) \
1979        ((x >> SND_RME_CLK_FREQMUL_SHIFT) & SND_RME_CLK_FREQMUL_MASK)
1980#define SND_RME_CLK_AES_LOCK                    0x1
1981#define SND_RME_CLK_AES_SYNC                    0x4
1982#define SND_RME_CLK_SPDIF_LOCK                  0x2
1983#define SND_RME_CLK_SPDIF_SYNC                  0x8
1984#define SND_RME_SPDIF_IF_SHIFT                  4
1985#define SND_RME_SPDIF_FORMAT_SHIFT              5
1986#define SND_RME_BINARY_MASK                     0x1
1987#define SND_RME_SPDIF_IF(x) \
1988        ((x >> SND_RME_SPDIF_IF_SHIFT) & SND_RME_BINARY_MASK)
1989#define SND_RME_SPDIF_FORMAT(x) \
1990        ((x >> SND_RME_SPDIF_FORMAT_SHIFT) & SND_RME_BINARY_MASK)
1991
1992static const u32 snd_rme_rate_table[] = {
1993        32000, 44100, 48000, 50000,
1994        64000, 88200, 96000, 100000,
1995        128000, 176400, 192000, 200000,
1996        256000, 352800, 384000, 400000,
1997        512000, 705600, 768000, 800000
1998};
1999/* maximum number of items for AES and S/PDIF rates for above table */
2000#define SND_RME_RATE_IDX_AES_SPDIF_NUM          12
2001
2002enum snd_rme_domain {
2003        SND_RME_DOMAIN_SYSTEM,
2004        SND_RME_DOMAIN_AES,
2005        SND_RME_DOMAIN_SPDIF
2006};
2007
2008enum snd_rme_clock_status {
2009        SND_RME_CLOCK_NOLOCK,
2010        SND_RME_CLOCK_LOCK,
2011        SND_RME_CLOCK_SYNC
2012};
2013
2014static int snd_rme_read_value(struct snd_usb_audio *chip,
2015                              unsigned int item,
2016                              u32 *value)
2017{
2018        struct usb_device *dev = chip->dev;
2019        int err;
2020
2021        err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
2022                              item,
2023                              USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2024                              0, 0,
2025                              value, sizeof(*value));
2026        if (err < 0)
2027                dev_err(&dev->dev,
2028                        "unable to issue vendor read request %d (ret = %d)",
2029                        item, err);
2030        return err;
2031}
2032
2033static int snd_rme_get_status1(struct snd_kcontrol *kcontrol,
2034                               u32 *status1)
2035{
2036        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2037        struct snd_usb_audio *chip = list->mixer->chip;
2038        int err;
2039
2040        err = snd_usb_lock_shutdown(chip);
2041        if (err < 0)
2042                return err;
2043        err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, status1);
2044        snd_usb_unlock_shutdown(chip);
2045        return err;
2046}
2047
2048static int snd_rme_rate_get(struct snd_kcontrol *kcontrol,
2049                            struct snd_ctl_elem_value *ucontrol)
2050{
2051        u32 status1;
2052        u32 rate = 0;
2053        int idx;
2054        int err;
2055
2056        err = snd_rme_get_status1(kcontrol, &status1);
2057        if (err < 0)
2058                return err;
2059        switch (kcontrol->private_value) {
2060        case SND_RME_DOMAIN_SYSTEM:
2061                idx = SND_RME_CLK_SYSTEM(status1);
2062                if (idx < ARRAY_SIZE(snd_rme_rate_table))
2063                        rate = snd_rme_rate_table[idx];
2064                break;
2065        case SND_RME_DOMAIN_AES:
2066                idx = SND_RME_CLK_AES(status1);
2067                if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2068                        rate = snd_rme_rate_table[idx];
2069                break;
2070        case SND_RME_DOMAIN_SPDIF:
2071                idx = SND_RME_CLK_SPDIF(status1);
2072                if (idx < SND_RME_RATE_IDX_AES_SPDIF_NUM)
2073                        rate = snd_rme_rate_table[idx];
2074                break;
2075        default:
2076                return -EINVAL;
2077        }
2078        ucontrol->value.integer.value[0] = rate;
2079        return 0;
2080}
2081
2082static int snd_rme_sync_state_get(struct snd_kcontrol *kcontrol,
2083                                  struct snd_ctl_elem_value *ucontrol)
2084{
2085        u32 status1;
2086        int idx = SND_RME_CLOCK_NOLOCK;
2087        int err;
2088
2089        err = snd_rme_get_status1(kcontrol, &status1);
2090        if (err < 0)
2091                return err;
2092        switch (kcontrol->private_value) {
2093        case SND_RME_DOMAIN_AES:  /* AES */
2094                if (status1 & SND_RME_CLK_AES_SYNC)
2095                        idx = SND_RME_CLOCK_SYNC;
2096                else if (status1 & SND_RME_CLK_AES_LOCK)
2097                        idx = SND_RME_CLOCK_LOCK;
2098                break;
2099        case SND_RME_DOMAIN_SPDIF:  /* SPDIF */
2100                if (status1 & SND_RME_CLK_SPDIF_SYNC)
2101                        idx = SND_RME_CLOCK_SYNC;
2102                else if (status1 & SND_RME_CLK_SPDIF_LOCK)
2103                        idx = SND_RME_CLOCK_LOCK;
2104                break;
2105        default:
2106                return -EINVAL;
2107        }
2108        ucontrol->value.enumerated.item[0] = idx;
2109        return 0;
2110}
2111
2112static int snd_rme_spdif_if_get(struct snd_kcontrol *kcontrol,
2113                                struct snd_ctl_elem_value *ucontrol)
2114{
2115        u32 status1;
2116        int err;
2117
2118        err = snd_rme_get_status1(kcontrol, &status1);
2119        if (err < 0)
2120                return err;
2121        ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_IF(status1);
2122        return 0;
2123}
2124
2125static int snd_rme_spdif_format_get(struct snd_kcontrol *kcontrol,
2126                                    struct snd_ctl_elem_value *ucontrol)
2127{
2128        u32 status1;
2129        int err;
2130
2131        err = snd_rme_get_status1(kcontrol, &status1);
2132        if (err < 0)
2133                return err;
2134        ucontrol->value.enumerated.item[0] = SND_RME_SPDIF_FORMAT(status1);
2135        return 0;
2136}
2137
2138static int snd_rme_sync_source_get(struct snd_kcontrol *kcontrol,
2139                                   struct snd_ctl_elem_value *ucontrol)
2140{
2141        u32 status1;
2142        int err;
2143
2144        err = snd_rme_get_status1(kcontrol, &status1);
2145        if (err < 0)
2146                return err;
2147        ucontrol->value.enumerated.item[0] = SND_RME_CLK_SYNC(status1);
2148        return 0;
2149}
2150
2151static int snd_rme_current_freq_get(struct snd_kcontrol *kcontrol,
2152                                    struct snd_ctl_elem_value *ucontrol)
2153{
2154        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2155        struct snd_usb_audio *chip = list->mixer->chip;
2156        u32 status1;
2157        const u64 num = 104857600000000ULL;
2158        u32 den;
2159        unsigned int freq;
2160        int err;
2161
2162        err = snd_usb_lock_shutdown(chip);
2163        if (err < 0)
2164                return err;
2165        err = snd_rme_read_value(chip, SND_RME_GET_STATUS1, &status1);
2166        if (err < 0)
2167                goto end;
2168        err = snd_rme_read_value(chip, SND_RME_GET_CURRENT_FREQ, &den);
2169        if (err < 0)
2170                goto end;
2171        freq = (den == 0) ? 0 : div64_u64(num, den);
2172        freq <<= SND_RME_CLK_FREQMUL(status1);
2173        ucontrol->value.integer.value[0] = freq;
2174
2175end:
2176        snd_usb_unlock_shutdown(chip);
2177        return err;
2178}
2179
2180static int snd_rme_rate_info(struct snd_kcontrol *kcontrol,
2181                             struct snd_ctl_elem_info *uinfo)
2182{
2183        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2184        uinfo->count = 1;
2185        switch (kcontrol->private_value) {
2186        case SND_RME_DOMAIN_SYSTEM:
2187                uinfo->value.integer.min = 32000;
2188                uinfo->value.integer.max = 800000;
2189                break;
2190        case SND_RME_DOMAIN_AES:
2191        case SND_RME_DOMAIN_SPDIF:
2192        default:
2193                uinfo->value.integer.min = 0;
2194                uinfo->value.integer.max = 200000;
2195        }
2196        uinfo->value.integer.step = 0;
2197        return 0;
2198}
2199
2200static int snd_rme_sync_state_info(struct snd_kcontrol *kcontrol,
2201                                   struct snd_ctl_elem_info *uinfo)
2202{
2203        static const char *const sync_states[] = {
2204                "No Lock", "Lock", "Sync"
2205        };
2206
2207        return snd_ctl_enum_info(uinfo, 1,
2208                                 ARRAY_SIZE(sync_states), sync_states);
2209}
2210
2211static int snd_rme_spdif_if_info(struct snd_kcontrol *kcontrol,
2212                                 struct snd_ctl_elem_info *uinfo)
2213{
2214        static const char *const spdif_if[] = {
2215                "Coaxial", "Optical"
2216        };
2217
2218        return snd_ctl_enum_info(uinfo, 1,
2219                                 ARRAY_SIZE(spdif_if), spdif_if);
2220}
2221
2222static int snd_rme_spdif_format_info(struct snd_kcontrol *kcontrol,
2223                                     struct snd_ctl_elem_info *uinfo)
2224{
2225        static const char *const optical_type[] = {
2226                "Consumer", "Professional"
2227        };
2228
2229        return snd_ctl_enum_info(uinfo, 1,
2230                                 ARRAY_SIZE(optical_type), optical_type);
2231}
2232
2233static int snd_rme_sync_source_info(struct snd_kcontrol *kcontrol,
2234                                    struct snd_ctl_elem_info *uinfo)
2235{
2236        static const char *const sync_sources[] = {
2237                "Internal", "AES", "SPDIF", "Internal"
2238        };
2239
2240        return snd_ctl_enum_info(uinfo, 1,
2241                                 ARRAY_SIZE(sync_sources), sync_sources);
2242}
2243
2244static const struct snd_kcontrol_new snd_rme_controls[] = {
2245        {
2246                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2247                .name = "AES Rate",
2248                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2249                .info = snd_rme_rate_info,
2250                .get = snd_rme_rate_get,
2251                .private_value = SND_RME_DOMAIN_AES
2252        },
2253        {
2254                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2255                .name = "AES Sync",
2256                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2257                .info = snd_rme_sync_state_info,
2258                .get = snd_rme_sync_state_get,
2259                .private_value = SND_RME_DOMAIN_AES
2260        },
2261        {
2262                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2263                .name = "SPDIF Rate",
2264                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2265                .info = snd_rme_rate_info,
2266                .get = snd_rme_rate_get,
2267                .private_value = SND_RME_DOMAIN_SPDIF
2268        },
2269        {
2270                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2271                .name = "SPDIF Sync",
2272                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2273                .info = snd_rme_sync_state_info,
2274                .get = snd_rme_sync_state_get,
2275                .private_value = SND_RME_DOMAIN_SPDIF
2276        },
2277        {
2278                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2279                .name = "SPDIF Interface",
2280                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2281                .info = snd_rme_spdif_if_info,
2282                .get = snd_rme_spdif_if_get,
2283        },
2284        {
2285                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2286                .name = "SPDIF Format",
2287                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2288                .info = snd_rme_spdif_format_info,
2289                .get = snd_rme_spdif_format_get,
2290        },
2291        {
2292                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2293                .name = "Sync Source",
2294                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2295                .info = snd_rme_sync_source_info,
2296                .get = snd_rme_sync_source_get
2297        },
2298        {
2299                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2300                .name = "System Rate",
2301                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2302                .info = snd_rme_rate_info,
2303                .get = snd_rme_rate_get,
2304                .private_value = SND_RME_DOMAIN_SYSTEM
2305        },
2306        {
2307                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2308                .name = "Current Frequency",
2309                .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
2310                .info = snd_rme_rate_info,
2311                .get = snd_rme_current_freq_get
2312        }
2313};
2314
2315static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2316{
2317        int err, i;
2318
2319        for (i = 0; i < ARRAY_SIZE(snd_rme_controls); ++i) {
2320                err = add_single_ctl_with_resume(mixer, 0,
2321                                                 NULL,
2322                                                 &snd_rme_controls[i],
2323                                                 NULL);
2324                if (err < 0)
2325                        return err;
2326        }
2327
2328        return 0;
2329}
2330
2331/*
2332 * RME Babyface Pro (FS)
2333 *
2334 * These devices exposes a couple of DSP functions via request to EP0.
2335 * Switches are available via control registers, while routing is controlled
2336 * by controlling the volume on each possible crossing point.
2337 * Volume control is linear, from -inf (dec. 0) to +6dB (dec. 65536) with
2338 * 0dB being at dec. 32768.
2339 */
2340enum {
2341        SND_BBFPRO_CTL_REG1 = 0,
2342        SND_BBFPRO_CTL_REG2
2343};
2344
2345#define SND_BBFPRO_CTL_REG_MASK 1
2346#define SND_BBFPRO_CTL_IDX_MASK 0xff
2347#define SND_BBFPRO_CTL_IDX_SHIFT 1
2348#define SND_BBFPRO_CTL_VAL_MASK 1
2349#define SND_BBFPRO_CTL_VAL_SHIFT 9
2350#define SND_BBFPRO_CTL_REG1_CLK_MASTER 0
2351#define SND_BBFPRO_CTL_REG1_CLK_OPTICAL 1
2352#define SND_BBFPRO_CTL_REG1_SPDIF_PRO 7
2353#define SND_BBFPRO_CTL_REG1_SPDIF_EMPH 8
2354#define SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL 10
2355#define SND_BBFPRO_CTL_REG2_48V_AN1 0
2356#define SND_BBFPRO_CTL_REG2_48V_AN2 1
2357#define SND_BBFPRO_CTL_REG2_SENS_IN3 2
2358#define SND_BBFPRO_CTL_REG2_SENS_IN4 3
2359#define SND_BBFPRO_CTL_REG2_PAD_AN1 4
2360#define SND_BBFPRO_CTL_REG2_PAD_AN2 5
2361
2362#define SND_BBFPRO_MIXER_IDX_MASK 0x1ff
2363#define SND_BBFPRO_MIXER_VAL_MASK 0x3ffff
2364#define SND_BBFPRO_MIXER_VAL_SHIFT 9
2365#define SND_BBFPRO_MIXER_VAL_MIN 0 // -inf
2366#define SND_BBFPRO_MIXER_VAL_MAX 65536 // +6dB
2367
2368#define SND_BBFPRO_USBREQ_CTL_REG1 0x10
2369#define SND_BBFPRO_USBREQ_CTL_REG2 0x17
2370#define SND_BBFPRO_USBREQ_MIXER 0x12
2371
2372static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2373                                 u8 index, u8 value)
2374{
2375        int err;
2376        u16 usb_req, usb_idx, usb_val;
2377        struct snd_usb_audio *chip = mixer->chip;
2378
2379        err = snd_usb_lock_shutdown(chip);
2380        if (err < 0)
2381                return err;
2382
2383        if (reg == SND_BBFPRO_CTL_REG1) {
2384                usb_req = SND_BBFPRO_USBREQ_CTL_REG1;
2385                if (index == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2386                        usb_idx = 3;
2387                        usb_val = value ? 3 : 0;
2388                } else {
2389                        usb_idx = 1 << index;
2390                        usb_val = value ? usb_idx : 0;
2391                }
2392        } else {
2393                usb_req = SND_BBFPRO_USBREQ_CTL_REG2;
2394                usb_idx = 1 << index;
2395                usb_val = value ? usb_idx : 0;
2396        }
2397
2398        err = snd_usb_ctl_msg(chip->dev,
2399                              usb_sndctrlpipe(chip->dev, 0), usb_req,
2400                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
2401                              usb_val, usb_idx, NULL, 0);
2402
2403        snd_usb_unlock_shutdown(chip);
2404        return err;
2405}
2406
2407static int snd_bbfpro_ctl_get(struct snd_kcontrol *kcontrol,
2408                              struct snd_ctl_elem_value *ucontrol)
2409{
2410        u8 reg, idx, val;
2411        int pv;
2412
2413        pv = kcontrol->private_value;
2414        reg = pv & SND_BBFPRO_CTL_REG_MASK;
2415        idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2416        val = kcontrol->private_value >> SND_BBFPRO_CTL_VAL_SHIFT;
2417
2418        if ((reg == SND_BBFPRO_CTL_REG1 &&
2419             idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2420            (reg == SND_BBFPRO_CTL_REG2 &&
2421            (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2422             idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2423                ucontrol->value.enumerated.item[0] = val;
2424        } else {
2425                ucontrol->value.integer.value[0] = val;
2426        }
2427        return 0;
2428}
2429
2430static int snd_bbfpro_ctl_info(struct snd_kcontrol *kcontrol,
2431                               struct snd_ctl_elem_info *uinfo)
2432{
2433        u8 reg, idx;
2434        int pv;
2435
2436        pv = kcontrol->private_value;
2437        reg = pv & SND_BBFPRO_CTL_REG_MASK;
2438        idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2439
2440        if (reg == SND_BBFPRO_CTL_REG1 &&
2441            idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) {
2442                static const char * const texts[2] = {
2443                        "AutoSync",
2444                        "Internal"
2445                };
2446                return snd_ctl_enum_info(uinfo, 1, 2, texts);
2447        } else if (reg == SND_BBFPRO_CTL_REG2 &&
2448                   (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2449                    idx == SND_BBFPRO_CTL_REG2_SENS_IN4)) {
2450                static const char * const texts[2] = {
2451                        "-10dBV",
2452                        "+4dBu"
2453                };
2454                return snd_ctl_enum_info(uinfo, 1, 2, texts);
2455        }
2456
2457        uinfo->count = 1;
2458        uinfo->value.integer.min = 0;
2459        uinfo->value.integer.max = 1;
2460        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2461        return 0;
2462}
2463
2464static int snd_bbfpro_ctl_put(struct snd_kcontrol *kcontrol,
2465                              struct snd_ctl_elem_value *ucontrol)
2466{
2467        int err;
2468        u8 reg, idx;
2469        int old_value, pv, val;
2470
2471        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2472        struct usb_mixer_interface *mixer = list->mixer;
2473
2474        pv = kcontrol->private_value;
2475        reg = pv & SND_BBFPRO_CTL_REG_MASK;
2476        idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2477        old_value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2478
2479        if ((reg == SND_BBFPRO_CTL_REG1 &&
2480             idx == SND_BBFPRO_CTL_REG1_CLK_OPTICAL) ||
2481            (reg == SND_BBFPRO_CTL_REG2 &&
2482            (idx == SND_BBFPRO_CTL_REG2_SENS_IN3 ||
2483             idx == SND_BBFPRO_CTL_REG2_SENS_IN4))) {
2484                val = ucontrol->value.enumerated.item[0];
2485        } else {
2486                val = ucontrol->value.integer.value[0];
2487        }
2488
2489        if (val > 1)
2490                return -EINVAL;
2491
2492        if (val == old_value)
2493                return 0;
2494
2495        kcontrol->private_value = reg
2496                | ((idx & SND_BBFPRO_CTL_IDX_MASK) << SND_BBFPRO_CTL_IDX_SHIFT)
2497                | ((val & SND_BBFPRO_CTL_VAL_MASK) << SND_BBFPRO_CTL_VAL_SHIFT);
2498
2499        err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2500        return err < 0 ? err : 1;
2501}
2502
2503static int snd_bbfpro_ctl_resume(struct usb_mixer_elem_list *list)
2504{
2505        u8 reg, idx;
2506        int value, pv;
2507
2508        pv = list->kctl->private_value;
2509        reg = pv & SND_BBFPRO_CTL_REG_MASK;
2510        idx = (pv >> SND_BBFPRO_CTL_IDX_SHIFT) & SND_BBFPRO_CTL_IDX_MASK;
2511        value = (pv >> SND_BBFPRO_CTL_VAL_SHIFT) & SND_BBFPRO_CTL_VAL_MASK;
2512
2513        return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2514}
2515
2516static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2517                                 u32 value)
2518{
2519        struct snd_usb_audio *chip = mixer->chip;
2520        int err;
2521        u16 idx;
2522        u16 usb_idx, usb_val;
2523        u32 v;
2524
2525        err = snd_usb_lock_shutdown(chip);
2526        if (err < 0)
2527                return err;
2528
2529        idx = index & SND_BBFPRO_MIXER_IDX_MASK;
2530        // 18 bit linear volume, split so 2 bits end up in index.
2531        v = value & SND_BBFPRO_MIXER_VAL_MASK;
2532        usb_idx = idx | (v & 0x3) << 14;
2533        usb_val = (v >> 2) & 0xffff;
2534
2535        err = snd_usb_ctl_msg(chip->dev,
2536                              usb_sndctrlpipe(chip->dev, 0),
2537                              SND_BBFPRO_USBREQ_MIXER,
2538                              USB_DIR_OUT | USB_TYPE_VENDOR |
2539                              USB_RECIP_DEVICE,
2540                              usb_val, usb_idx, NULL, 0);
2541
2542        snd_usb_unlock_shutdown(chip);
2543        return err;
2544}
2545
2546static int snd_bbfpro_vol_get(struct snd_kcontrol *kcontrol,
2547                              struct snd_ctl_elem_value *ucontrol)
2548{
2549        ucontrol->value.integer.value[0] =
2550                kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2551        return 0;
2552}
2553
2554static int snd_bbfpro_vol_info(struct snd_kcontrol *kcontrol,
2555                               struct snd_ctl_elem_info *uinfo)
2556{
2557        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2558        uinfo->count = 1;
2559        uinfo->value.integer.min = SND_BBFPRO_MIXER_VAL_MIN;
2560        uinfo->value.integer.max = SND_BBFPRO_MIXER_VAL_MAX;
2561        return 0;
2562}
2563
2564static int snd_bbfpro_vol_put(struct snd_kcontrol *kcontrol,
2565                              struct snd_ctl_elem_value *ucontrol)
2566{
2567        int err;
2568        u16 idx;
2569        u32 new_val, old_value, uvalue;
2570        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kcontrol);
2571        struct usb_mixer_interface *mixer = list->mixer;
2572
2573        uvalue = ucontrol->value.integer.value[0];
2574        idx = kcontrol->private_value & SND_BBFPRO_MIXER_IDX_MASK;
2575        old_value = kcontrol->private_value >> SND_BBFPRO_MIXER_VAL_SHIFT;
2576
2577        if (uvalue > SND_BBFPRO_MIXER_VAL_MAX)
2578                return -EINVAL;
2579
2580        if (uvalue == old_value)
2581                return 0;
2582
2583        new_val = uvalue & SND_BBFPRO_MIXER_VAL_MASK;
2584
2585        kcontrol->private_value = idx
2586                | (new_val << SND_BBFPRO_MIXER_VAL_SHIFT);
2587
2588        err = snd_bbfpro_vol_update(mixer, idx, new_val);
2589        return err < 0 ? err : 1;
2590}
2591
2592static int snd_bbfpro_vol_resume(struct usb_mixer_elem_list *list)
2593{
2594        int pv = list->kctl->private_value;
2595        u16 idx = pv & SND_BBFPRO_MIXER_IDX_MASK;
2596        u32 val = (pv >> SND_BBFPRO_MIXER_VAL_SHIFT)
2597                & SND_BBFPRO_MIXER_VAL_MASK;
2598        return snd_bbfpro_vol_update(list->mixer, idx, val);
2599}
2600
2601// Predfine elements
2602static const struct snd_kcontrol_new snd_bbfpro_ctl_control = {
2603        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2604        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2605        .index = 0,
2606        .info = snd_bbfpro_ctl_info,
2607        .get = snd_bbfpro_ctl_get,
2608        .put = snd_bbfpro_ctl_put
2609};
2610
2611static const struct snd_kcontrol_new snd_bbfpro_vol_control = {
2612        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2613        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
2614        .index = 0,
2615        .info = snd_bbfpro_vol_info,
2616        .get = snd_bbfpro_vol_get,
2617        .put = snd_bbfpro_vol_put
2618};
2619
2620static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2621                              u8 index, char *name)
2622{
2623        struct snd_kcontrol_new knew = snd_bbfpro_ctl_control;
2624
2625        knew.name = name;
2626        knew.private_value = (reg & SND_BBFPRO_CTL_REG_MASK)
2627                | ((index & SND_BBFPRO_CTL_IDX_MASK)
2628                        << SND_BBFPRO_CTL_IDX_SHIFT);
2629
2630        return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2631                &knew, NULL);
2632}
2633
2634static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2635                              char *name)
2636{
2637        struct snd_kcontrol_new knew = snd_bbfpro_vol_control;
2638
2639        knew.name = name;
2640        knew.private_value = index & SND_BBFPRO_MIXER_IDX_MASK;
2641
2642        return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2643                &knew, NULL);
2644}
2645
2646static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2647{
2648        int err, i, o;
2649        char name[48];
2650
2651        static const char * const input[] = {
2652                "AN1", "AN2", "IN3", "IN4", "AS1", "AS2", "ADAT3",
2653                "ADAT4", "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2654
2655        static const char * const output[] = {
2656                "AN1", "AN2", "PH3", "PH4", "AS1", "AS2", "ADAT3", "ADAT4",
2657                "ADAT5", "ADAT6", "ADAT7", "ADAT8"};
2658
2659        for (o = 0 ; o < 12 ; ++o) {
2660                for (i = 0 ; i < 12 ; ++i) {
2661                        // Line routing
2662                        snprintf(name, sizeof(name),
2663                                 "%s-%s-%s Playback Volume",
2664                                 (i < 2 ? "Mic" : "Line"),
2665                                 input[i], output[o]);
2666                        err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2667                        if (err < 0)
2668                                return err;
2669
2670                        // PCM routing... yes, it is output remapping
2671                        snprintf(name, sizeof(name),
2672                                 "PCM-%s-%s Playback Volume",
2673                                 output[i], output[o]);
2674                        err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2675                                                 name);
2676                        if (err < 0)
2677                                return err;
2678                }
2679        }
2680
2681        // Control Reg 1
2682        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2683                                 SND_BBFPRO_CTL_REG1_CLK_OPTICAL,
2684                                 "Sample Clock Source");
2685        if (err < 0)
2686                return err;
2687
2688        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2689                                 SND_BBFPRO_CTL_REG1_SPDIF_PRO,
2690                                 "IEC958 Pro Mask");
2691        if (err < 0)
2692                return err;
2693
2694        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2695                                 SND_BBFPRO_CTL_REG1_SPDIF_EMPH,
2696                                 "IEC958 Emphasis");
2697        if (err < 0)
2698                return err;
2699
2700        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2701                                 SND_BBFPRO_CTL_REG1_SPDIF_OPTICAL,
2702                                 "IEC958 Switch");
2703        if (err < 0)
2704                return err;
2705
2706        // Control Reg 2
2707        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2708                                 SND_BBFPRO_CTL_REG2_48V_AN1,
2709                                 "Mic-AN1 48V");
2710        if (err < 0)
2711                return err;
2712
2713        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2714                                 SND_BBFPRO_CTL_REG2_48V_AN2,
2715                                 "Mic-AN2 48V");
2716        if (err < 0)
2717                return err;
2718
2719        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2720                                 SND_BBFPRO_CTL_REG2_SENS_IN3,
2721                                 "Line-IN3 Sens.");
2722        if (err < 0)
2723                return err;
2724
2725        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2726                                 SND_BBFPRO_CTL_REG2_SENS_IN4,
2727                                 "Line-IN4 Sens.");
2728        if (err < 0)
2729                return err;
2730
2731        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2732                                 SND_BBFPRO_CTL_REG2_PAD_AN1,
2733                                 "Mic-AN1 PAD");
2734        if (err < 0)
2735                return err;
2736
2737        err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2738                                 SND_BBFPRO_CTL_REG2_PAD_AN2,
2739                                 "Mic-AN2 PAD");
2740        if (err < 0)
2741                return err;
2742
2743        return 0;
2744}
2745
2746/*
2747 * Pioneer DJ DJM Mixers
2748 *
2749 * These devices generally have options for soft-switching the playback and
2750 * capture sources in addition to the recording level. Although different
2751 * devices have different configurations, there seems to be canonical values
2752 * for specific capture/playback types:  See the definitions of these below.
2753 *
2754 * The wValue is masked with the stereo channel number. e.g. Setting Ch2 to
2755 * capture phono would be 0x0203. Capture, playback and capture level have
2756 * different wIndexes.
2757 */
2758
2759// Capture types
2760#define SND_DJM_CAP_LINE        0x00
2761#define SND_DJM_CAP_CDLINE      0x01
2762#define SND_DJM_CAP_DIGITAL     0x02
2763#define SND_DJM_CAP_PHONO       0x03
2764#define SND_DJM_CAP_PFADER      0x06
2765#define SND_DJM_CAP_XFADERA     0x07
2766#define SND_DJM_CAP_XFADERB     0x08
2767#define SND_DJM_CAP_MIC         0x09
2768#define SND_DJM_CAP_AUX         0x0d
2769#define SND_DJM_CAP_RECOUT      0x0a
2770#define SND_DJM_CAP_NONE        0x0f
2771#define SND_DJM_CAP_CH1PFADER   0x11
2772#define SND_DJM_CAP_CH2PFADER   0x12
2773#define SND_DJM_CAP_CH3PFADER   0x13
2774#define SND_DJM_CAP_CH4PFADER   0x14
2775
2776// Playback types
2777#define SND_DJM_PB_CH1          0x00
2778#define SND_DJM_PB_CH2          0x01
2779#define SND_DJM_PB_AUX          0x04
2780
2781#define SND_DJM_WINDEX_CAP      0x8002
2782#define SND_DJM_WINDEX_CAPLVL   0x8003
2783#define SND_DJM_WINDEX_PB       0x8016
2784
2785// kcontrol->private_value layout
2786#define SND_DJM_VALUE_MASK      0x0000ffff
2787#define SND_DJM_GROUP_MASK      0x00ff0000
2788#define SND_DJM_DEVICE_MASK     0xff000000
2789#define SND_DJM_GROUP_SHIFT     16
2790#define SND_DJM_DEVICE_SHIFT    24
2791
2792// device table index
2793// used for the snd_djm_devices table, so please update accordingly
2794#define SND_DJM_250MK2_IDX      0x0
2795#define SND_DJM_750_IDX         0x1
2796#define SND_DJM_850_IDX         0x2
2797#define SND_DJM_900NXS2_IDX     0x3
2798#define SND_DJM_750MK2_IDX      0x4
2799
2800
2801#define SND_DJM_CTL(_name, suffix, _default_value, _windex) { \
2802        .name = _name, \
2803        .options = snd_djm_opts_##suffix, \
2804        .noptions = ARRAY_SIZE(snd_djm_opts_##suffix), \
2805        .default_value = _default_value, \
2806        .wIndex = _windex }
2807
2808#define SND_DJM_DEVICE(suffix) { \
2809        .controls = snd_djm_ctls_##suffix, \
2810        .ncontrols = ARRAY_SIZE(snd_djm_ctls_##suffix) }
2811
2812
2813struct snd_djm_device {
2814        const char *name;
2815        const struct snd_djm_ctl *controls;
2816        size_t ncontrols;
2817};
2818
2819struct snd_djm_ctl {
2820        const char *name;
2821        const u16 *options;
2822        size_t noptions;
2823        u16 default_value;
2824        u16 wIndex;
2825};
2826
2827static const char *snd_djm_get_label_caplevel(u16 wvalue)
2828{
2829        switch (wvalue) {
2830        case 0x0000:    return "-19dB";
2831        case 0x0100:    return "-15dB";
2832        case 0x0200:    return "-10dB";
2833        case 0x0300:    return "-5dB";
2834        default:        return NULL;
2835        }
2836};
2837
2838static const char *snd_djm_get_label_cap_common(u16 wvalue)
2839{
2840        switch (wvalue & 0x00ff) {
2841        case SND_DJM_CAP_LINE:          return "Control Tone LINE";
2842        case SND_DJM_CAP_CDLINE:        return "Control Tone CD/LINE";
2843        case SND_DJM_CAP_DIGITAL:       return "Control Tone DIGITAL";
2844        case SND_DJM_CAP_PHONO:         return "Control Tone PHONO";
2845        case SND_DJM_CAP_PFADER:        return "Post Fader";
2846        case SND_DJM_CAP_XFADERA:       return "Cross Fader A";
2847        case SND_DJM_CAP_XFADERB:       return "Cross Fader B";
2848        case SND_DJM_CAP_MIC:           return "Mic";
2849        case SND_DJM_CAP_RECOUT:        return "Rec Out";
2850        case SND_DJM_CAP_AUX:           return "Aux";
2851        case SND_DJM_CAP_NONE:          return "None";
2852        case SND_DJM_CAP_CH1PFADER:     return "Post Fader Ch1";
2853        case SND_DJM_CAP_CH2PFADER:     return "Post Fader Ch2";
2854        case SND_DJM_CAP_CH3PFADER:     return "Post Fader Ch3";
2855        case SND_DJM_CAP_CH4PFADER:     return "Post Fader Ch4";
2856        default:                        return NULL;
2857        }
2858};
2859
2860// The DJM-850 has different values for CD/LINE and LINE capture
2861// control options than the other DJM declared in this file.
2862static const char *snd_djm_get_label_cap_850(u16 wvalue)
2863{
2864        switch (wvalue & 0x00ff) {
2865        case 0x00:              return "Control Tone CD/LINE";
2866        case 0x01:              return "Control Tone LINE";
2867        default:                return snd_djm_get_label_cap_common(wvalue);
2868        }
2869};
2870
2871static const char *snd_djm_get_label_cap(u8 device_idx, u16 wvalue)
2872{
2873        switch (device_idx) {
2874        case SND_DJM_850_IDX:           return snd_djm_get_label_cap_850(wvalue);
2875        default:                        return snd_djm_get_label_cap_common(wvalue);
2876        }
2877};
2878
2879static const char *snd_djm_get_label_pb(u16 wvalue)
2880{
2881        switch (wvalue & 0x00ff) {
2882        case SND_DJM_PB_CH1:    return "Ch1";
2883        case SND_DJM_PB_CH2:    return "Ch2";
2884        case SND_DJM_PB_AUX:    return "Aux";
2885        default:                return NULL;
2886        }
2887};
2888
2889static const char *snd_djm_get_label(u8 device_idx, u16 wvalue, u16 windex)
2890{
2891        switch (windex) {
2892        case SND_DJM_WINDEX_CAPLVL:     return snd_djm_get_label_caplevel(wvalue);
2893        case SND_DJM_WINDEX_CAP:        return snd_djm_get_label_cap(device_idx, wvalue);
2894        case SND_DJM_WINDEX_PB:         return snd_djm_get_label_pb(wvalue);
2895        default:                        return NULL;
2896        }
2897};
2898
2899// common DJM capture level option values
2900static const u16 snd_djm_opts_cap_level[] = {
2901        0x0000, 0x0100, 0x0200, 0x0300 };
2902
2903
2904// DJM-250MK2
2905static const u16 snd_djm_opts_250mk2_cap1[] = {
2906        0x0103, 0x0100, 0x0106, 0x0107, 0x0108, 0x0109, 0x010d, 0x010a };
2907
2908static const u16 snd_djm_opts_250mk2_cap2[] = {
2909        0x0203, 0x0200, 0x0206, 0x0207, 0x0208, 0x0209, 0x020d, 0x020a };
2910
2911static const u16 snd_djm_opts_250mk2_cap3[] = {
2912        0x030a, 0x0311, 0x0312, 0x0307, 0x0308, 0x0309, 0x030d };
2913
2914static const u16 snd_djm_opts_250mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
2915static const u16 snd_djm_opts_250mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
2916static const u16 snd_djm_opts_250mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
2917
2918static const struct snd_djm_ctl snd_djm_ctls_250mk2[] = {
2919        SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2920        SND_DJM_CTL("Ch1 Input",   250mk2_cap1, 2, SND_DJM_WINDEX_CAP),
2921        SND_DJM_CTL("Ch2 Input",   250mk2_cap2, 2, SND_DJM_WINDEX_CAP),
2922        SND_DJM_CTL("Ch3 Input",   250mk2_cap3, 0, SND_DJM_WINDEX_CAP),
2923        SND_DJM_CTL("Ch1 Output",   250mk2_pb1, 0, SND_DJM_WINDEX_PB),
2924        SND_DJM_CTL("Ch2 Output",   250mk2_pb2, 1, SND_DJM_WINDEX_PB),
2925        SND_DJM_CTL("Ch3 Output",   250mk2_pb3, 2, SND_DJM_WINDEX_PB)
2926};
2927
2928
2929// DJM-750
2930static const u16 snd_djm_opts_750_cap1[] = {
2931        0x0101, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
2932static const u16 snd_djm_opts_750_cap2[] = {
2933        0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
2934static const u16 snd_djm_opts_750_cap3[] = {
2935        0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
2936static const u16 snd_djm_opts_750_cap4[] = {
2937        0x0401, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
2938
2939static const struct snd_djm_ctl snd_djm_ctls_750[] = {
2940        SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2941        SND_DJM_CTL("Ch1 Input",   750_cap1, 2, SND_DJM_WINDEX_CAP),
2942        SND_DJM_CTL("Ch2 Input",   750_cap2, 2, SND_DJM_WINDEX_CAP),
2943        SND_DJM_CTL("Ch3 Input",   750_cap3, 0, SND_DJM_WINDEX_CAP),
2944        SND_DJM_CTL("Ch4 Input",   750_cap4, 0, SND_DJM_WINDEX_CAP)
2945};
2946
2947
2948// DJM-850
2949static const u16 snd_djm_opts_850_cap1[] = {
2950        0x0100, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a, 0x010f };
2951static const u16 snd_djm_opts_850_cap2[] = {
2952        0x0200, 0x0201, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a, 0x020f };
2953static const u16 snd_djm_opts_850_cap3[] = {
2954        0x0300, 0x0301, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030f };
2955static const u16 snd_djm_opts_850_cap4[] = {
2956        0x0400, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a, 0x040f };
2957
2958static const struct snd_djm_ctl snd_djm_ctls_850[] = {
2959        SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2960        SND_DJM_CTL("Ch1 Input",   850_cap1, 1, SND_DJM_WINDEX_CAP),
2961        SND_DJM_CTL("Ch2 Input",   850_cap2, 0, SND_DJM_WINDEX_CAP),
2962        SND_DJM_CTL("Ch3 Input",   850_cap3, 0, SND_DJM_WINDEX_CAP),
2963        SND_DJM_CTL("Ch4 Input",   850_cap4, 1, SND_DJM_WINDEX_CAP)
2964};
2965
2966
2967// DJM-900NXS2
2968static const u16 snd_djm_opts_900nxs2_cap1[] = {
2969        0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
2970static const u16 snd_djm_opts_900nxs2_cap2[] = {
2971        0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
2972static const u16 snd_djm_opts_900nxs2_cap3[] = {
2973        0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
2974static const u16 snd_djm_opts_900nxs2_cap4[] = {
2975        0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
2976static const u16 snd_djm_opts_900nxs2_cap5[] = {
2977        0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
2978
2979static const struct snd_djm_ctl snd_djm_ctls_900nxs2[] = {
2980        SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
2981        SND_DJM_CTL("Ch1 Input",   900nxs2_cap1, 2, SND_DJM_WINDEX_CAP),
2982        SND_DJM_CTL("Ch2 Input",   900nxs2_cap2, 2, SND_DJM_WINDEX_CAP),
2983        SND_DJM_CTL("Ch3 Input",   900nxs2_cap3, 2, SND_DJM_WINDEX_CAP),
2984        SND_DJM_CTL("Ch4 Input",   900nxs2_cap4, 2, SND_DJM_WINDEX_CAP),
2985        SND_DJM_CTL("Ch5 Input",   900nxs2_cap5, 3, SND_DJM_WINDEX_CAP)
2986};
2987
2988// DJM-750MK2
2989static const u16 snd_djm_opts_750mk2_cap1[] = {
2990        0x0100, 0x0102, 0x0103, 0x0106, 0x0107, 0x0108, 0x0109, 0x010a };
2991static const u16 snd_djm_opts_750mk2_cap2[] = {
2992        0x0200, 0x0202, 0x0203, 0x0206, 0x0207, 0x0208, 0x0209, 0x020a };
2993static const u16 snd_djm_opts_750mk2_cap3[] = {
2994        0x0300, 0x0302, 0x0303, 0x0306, 0x0307, 0x0308, 0x0309, 0x030a };
2995static const u16 snd_djm_opts_750mk2_cap4[] = {
2996        0x0400, 0x0402, 0x0403, 0x0406, 0x0407, 0x0408, 0x0409, 0x040a };
2997static const u16 snd_djm_opts_750mk2_cap5[] = {
2998        0x0507, 0x0508, 0x0509, 0x050a, 0x0511, 0x0512, 0x0513, 0x0514 };
2999
3000static const u16 snd_djm_opts_750mk2_pb1[] = { 0x0100, 0x0101, 0x0104 };
3001static const u16 snd_djm_opts_750mk2_pb2[] = { 0x0200, 0x0201, 0x0204 };
3002static const u16 snd_djm_opts_750mk2_pb3[] = { 0x0300, 0x0301, 0x0304 };
3003
3004
3005static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = {
3006        SND_DJM_CTL("Capture Level", cap_level, 0, SND_DJM_WINDEX_CAPLVL),
3007        SND_DJM_CTL("Ch1 Input",   750mk2_cap1, 2, SND_DJM_WINDEX_CAP),
3008        SND_DJM_CTL("Ch2 Input",   750mk2_cap2, 2, SND_DJM_WINDEX_CAP),
3009        SND_DJM_CTL("Ch3 Input",   750mk2_cap3, 2, SND_DJM_WINDEX_CAP),
3010        SND_DJM_CTL("Ch4 Input",   750mk2_cap4, 2, SND_DJM_WINDEX_CAP),
3011        SND_DJM_CTL("Ch5 Input",   750mk2_cap5, 3, SND_DJM_WINDEX_CAP),
3012        SND_DJM_CTL("Ch1 Output",   750mk2_pb1, 0, SND_DJM_WINDEX_PB),
3013        SND_DJM_CTL("Ch2 Output",   750mk2_pb2, 1, SND_DJM_WINDEX_PB),
3014        SND_DJM_CTL("Ch3 Output",   750mk2_pb3, 2, SND_DJM_WINDEX_PB)
3015};
3016
3017
3018static const struct snd_djm_device snd_djm_devices[] = {
3019        [SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2),
3020        [SND_DJM_750_IDX] = SND_DJM_DEVICE(750),
3021        [SND_DJM_850_IDX] = SND_DJM_DEVICE(850),
3022        [SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2),
3023        [SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2),
3024};
3025
3026
3027static int snd_djm_controls_info(struct snd_kcontrol *kctl,
3028                                struct snd_ctl_elem_info *info)
3029{
3030        unsigned long private_value = kctl->private_value;
3031        u8 device_idx = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3032        u8 ctl_idx = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3033        const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3034        const char *name;
3035        const struct snd_djm_ctl *ctl;
3036        size_t noptions;
3037
3038        if (ctl_idx >= device->ncontrols)
3039                return -EINVAL;
3040
3041        ctl = &device->controls[ctl_idx];
3042        noptions = ctl->noptions;
3043        if (info->value.enumerated.item >= noptions)
3044                info->value.enumerated.item = noptions - 1;
3045
3046        name = snd_djm_get_label(device_idx,
3047                                ctl->options[info->value.enumerated.item],
3048                                ctl->wIndex);
3049        if (!name)
3050                return -EINVAL;
3051
3052        strscpy(info->value.enumerated.name, name, sizeof(info->value.enumerated.name));
3053        info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3054        info->count = 1;
3055        info->value.enumerated.items = noptions;
3056        return 0;
3057}
3058
3059static int snd_djm_controls_update(struct usb_mixer_interface *mixer,
3060                                u8 device_idx, u8 group, u16 value)
3061{
3062        int err;
3063        const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3064
3065        if ((group >= device->ncontrols) || value >= device->controls[group].noptions)
3066                return -EINVAL;
3067
3068        err = snd_usb_lock_shutdown(mixer->chip);
3069        if (err)
3070                return err;
3071
3072        err = snd_usb_ctl_msg(
3073                mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0),
3074                USB_REQ_SET_FEATURE,
3075                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
3076                device->controls[group].options[value],
3077                device->controls[group].wIndex,
3078                NULL, 0);
3079
3080        snd_usb_unlock_shutdown(mixer->chip);
3081        return err;
3082}
3083
3084static int snd_djm_controls_get(struct snd_kcontrol *kctl,
3085                                struct snd_ctl_elem_value *elem)
3086{
3087        elem->value.enumerated.item[0] = kctl->private_value & SND_DJM_VALUE_MASK;
3088        return 0;
3089}
3090
3091static int snd_djm_controls_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *elem)
3092{
3093        struct usb_mixer_elem_list *list = snd_kcontrol_chip(kctl);
3094        struct usb_mixer_interface *mixer = list->mixer;
3095        unsigned long private_value = kctl->private_value;
3096
3097        u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3098        u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3099        u16 value = elem->value.enumerated.item[0];
3100
3101        kctl->private_value = (((unsigned long)device << SND_DJM_DEVICE_SHIFT) |
3102                              (group << SND_DJM_GROUP_SHIFT) |
3103                              value);
3104
3105        return snd_djm_controls_update(mixer, device, group, value);
3106}
3107
3108static int snd_djm_controls_resume(struct usb_mixer_elem_list *list)
3109{
3110        unsigned long private_value = list->kctl->private_value;
3111        u8 device = (private_value & SND_DJM_DEVICE_MASK) >> SND_DJM_DEVICE_SHIFT;
3112        u8 group = (private_value & SND_DJM_GROUP_MASK) >> SND_DJM_GROUP_SHIFT;
3113        u16 value = (private_value & SND_DJM_VALUE_MASK);
3114
3115        return snd_djm_controls_update(list->mixer, device, group, value);
3116}
3117
3118static int snd_djm_controls_create(struct usb_mixer_interface *mixer,
3119                const u8 device_idx)
3120{
3121        int err, i;
3122        u16 value;
3123
3124        const struct snd_djm_device *device = &snd_djm_devices[device_idx];
3125
3126        struct snd_kcontrol_new knew = {
3127                .iface  = SNDRV_CTL_ELEM_IFACE_MIXER,
3128                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
3129                .index = 0,
3130                .info = snd_djm_controls_info,
3131                .get  = snd_djm_controls_get,
3132                .put  = snd_djm_controls_put
3133        };
3134
3135        for (i = 0; i < device->ncontrols; i++) {
3136                value = device->controls[i].default_value;
3137                knew.name = device->controls[i].name;
3138                knew.private_value = (
3139                        ((unsigned long)device_idx << SND_DJM_DEVICE_SHIFT) |
3140                        (i << SND_DJM_GROUP_SHIFT) |
3141                        value);
3142                err = snd_djm_controls_update(mixer, device_idx, i, value);
3143                if (err)
3144                        return err;
3145                err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume,
3146                                                 &knew, NULL);
3147                if (err)
3148                        return err;
3149        }
3150        return 0;
3151}
3152
3153int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
3154{
3155        int err = 0;
3156
3157        err = snd_usb_soundblaster_remote_init(mixer);
3158        if (err < 0)
3159                return err;
3160
3161        switch (mixer->chip->usb_id) {
3162        /* Tascam US-16x08 */
3163        case USB_ID(0x0644, 0x8047):
3164                err = snd_us16x08_controls_create(mixer);
3165                break;
3166        case USB_ID(0x041e, 0x3020):
3167        case USB_ID(0x041e, 0x3040):
3168        case USB_ID(0x041e, 0x3042):
3169        case USB_ID(0x041e, 0x30df):
3170        case USB_ID(0x041e, 0x3048):
3171                err = snd_audigy2nx_controls_create(mixer);
3172                if (err < 0)
3173                        break;
3174                snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
3175                                     mixer, snd_audigy2nx_proc_read);
3176                break;
3177
3178        /* EMU0204 */
3179        case USB_ID(0x041e, 0x3f19):
3180                err = snd_emu0204_controls_create(mixer);
3181                break;
3182
3183        case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
3184        case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C400 */
3185                err = snd_c400_create_mixer(mixer);
3186                break;
3187
3188        case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
3189        case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
3190                err = snd_ftu_create_mixer(mixer);
3191                break;
3192
3193        case USB_ID(0x0b05, 0x1739): /* ASUS Xonar U1 */
3194        case USB_ID(0x0b05, 0x1743): /* ASUS Xonar U1 (2) */
3195        case USB_ID(0x0b05, 0x17a0): /* ASUS Xonar U3 */
3196                err = snd_xonar_u1_controls_create(mixer);
3197                break;
3198
3199        case USB_ID(0x0d8c, 0x0103): /* Audio Advantage Micro II */
3200                err = snd_microii_controls_create(mixer);
3201                break;
3202
3203        case USB_ID(0x0dba, 0x1000): /* Digidesign Mbox 1 */
3204                err = snd_mbox1_controls_create(mixer);
3205                break;
3206
3207        case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
3208                err = snd_nativeinstruments_create_mixer(mixer,
3209                                snd_nativeinstruments_ta6_mixers,
3210                                ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
3211                break;
3212
3213        case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
3214                err = snd_nativeinstruments_create_mixer(mixer,
3215                                snd_nativeinstruments_ta10_mixers,
3216                                ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
3217                break;
3218
3219        case USB_ID(0x200c, 0x1018): /* Electrix Ebox-44 */
3220                /* detection is disabled in mixer_maps.c */
3221                err = snd_create_std_mono_table(mixer, ebox44_table);
3222                break;
3223
3224        case USB_ID(0x1235, 0x8012): /* Focusrite Scarlett 6i6 */
3225        case USB_ID(0x1235, 0x8002): /* Focusrite Scarlett 8i6 */
3226        case USB_ID(0x1235, 0x8004): /* Focusrite Scarlett 18i6 */
3227        case USB_ID(0x1235, 0x8014): /* Focusrite Scarlett 18i8 */
3228        case USB_ID(0x1235, 0x800c): /* Focusrite Scarlett 18i20 */
3229                err = snd_scarlett_controls_create(mixer);
3230                break;
3231
3232        case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
3233        case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
3234        case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
3235        case USB_ID(0x1235, 0x8211): /* Focusrite Scarlett Solo 3rd Gen */
3236        case USB_ID(0x1235, 0x8210): /* Focusrite Scarlett 2i2 3rd Gen */
3237        case USB_ID(0x1235, 0x8212): /* Focusrite Scarlett 4i4 3rd Gen */
3238        case USB_ID(0x1235, 0x8213): /* Focusrite Scarlett 8i6 3rd Gen */
3239        case USB_ID(0x1235, 0x8214): /* Focusrite Scarlett 18i8 3rd Gen */
3240        case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */
3241                err = snd_scarlett_gen2_init(mixer);
3242                break;
3243
3244        case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
3245                err = snd_soundblaster_e1_switch_create(mixer);
3246                break;
3247        case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3248                err = dell_dock_mixer_init(mixer);
3249                break;
3250
3251        case USB_ID(0x2a39, 0x3fd2): /* RME ADI-2 Pro */
3252        case USB_ID(0x2a39, 0x3fd3): /* RME ADI-2 DAC */
3253        case USB_ID(0x2a39, 0x3fd4): /* RME */
3254                err = snd_rme_controls_create(mixer);
3255                break;
3256
3257        case USB_ID(0x194f, 0x010c): /* Presonus Studio 1810c */
3258                err = snd_sc1810_init_mixer(mixer);
3259                break;
3260        case USB_ID(0x2a39, 0x3fb0): /* RME Babyface Pro FS */
3261                err = snd_bbfpro_controls_create(mixer);
3262                break;
3263        case USB_ID(0x2b73, 0x0017): /* Pioneer DJ DJM-250MK2 */
3264                err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX);
3265                break;
3266        case USB_ID(0x08e4, 0x017f): /* Pioneer DJ DJM-750 */
3267                err = snd_djm_controls_create(mixer, SND_DJM_750_IDX);
3268                break;
3269        case USB_ID(0x2b73, 0x001b): /* Pioneer DJ DJM-750MK2 */
3270                err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX);
3271                break;
3272        case USB_ID(0x08e4, 0x0163): /* Pioneer DJ DJM-850 */
3273                err = snd_djm_controls_create(mixer, SND_DJM_850_IDX);
3274                break;
3275        case USB_ID(0x2b73, 0x000a): /* Pioneer DJ DJM-900NXS2 */
3276                err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX);
3277                break;
3278        }
3279
3280        return err;
3281}
3282
3283void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
3284{
3285        switch (mixer->chip->usb_id) {
3286        case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
3287                dell_dock_mixer_init(mixer);
3288                break;
3289        }
3290}
3291
3292void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
3293                                    int unitid)
3294{
3295        if (!mixer->rc_cfg)
3296                return;
3297        /* unit ids specific to Extigy/Audigy 2 NX: */
3298        switch (unitid) {
3299        case 0: /* remote control */
3300                mixer->rc_urb->dev = mixer->chip->dev;
3301                usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
3302                break;
3303        case 4: /* digital in jack */
3304        case 7: /* line in jacks */
3305        case 19: /* speaker out jacks */
3306        case 20: /* headphones out jack */
3307                break;
3308        /* live24ext: 4 = line-in jack */
3309        case 3: /* hp-out jack (may actuate Mute) */
3310                if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
3311                    mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
3312                        snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
3313                break;
3314        default:
3315                usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
3316                break;
3317        }
3318}
3319
3320static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
3321                                         struct usb_mixer_elem_info *cval,
3322                                         struct snd_kcontrol *kctl)
3323{
3324        /* Approximation using 10 ranges based on output measurement on hw v1.2.
3325         * This seems close to the cubic mapping e.g. alsamixer uses. */
3326        static const DECLARE_TLV_DB_RANGE(scale,
3327                 0,  1, TLV_DB_MINMAX_ITEM(-5300, -4970),
3328                 2,  5, TLV_DB_MINMAX_ITEM(-4710, -4160),
3329                 6,  7, TLV_DB_MINMAX_ITEM(-3884, -3710),
3330                 8, 14, TLV_DB_MINMAX_ITEM(-3443, -2560),
3331                15, 16, TLV_DB_MINMAX_ITEM(-2475, -2324),
3332                17, 19, TLV_DB_MINMAX_ITEM(-2228, -2031),
3333                20, 26, TLV_DB_MINMAX_ITEM(-1910, -1393),
3334                27, 31, TLV_DB_MINMAX_ITEM(-1322, -1032),
3335                32, 40, TLV_DB_MINMAX_ITEM(-968, -490),
3336                41, 50, TLV_DB_MINMAX_ITEM(-441, 0),
3337        );
3338
3339        if (cval->min == 0 && cval->max == 50) {
3340                usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
3341                kctl->tlv.p = scale;
3342                kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
3343                kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3344
3345        } else if (cval->min == 0 && cval->max <= 1000) {
3346                /* Some other clearly broken DragonFly variant.
3347                 * At least a 0..53 variant (hw v1.0) exists.
3348                 */
3349                usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
3350                kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
3351        }
3352}
3353
3354void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
3355                                  struct usb_mixer_elem_info *cval, int unitid,
3356                                  struct snd_kcontrol *kctl)
3357{
3358        switch (mixer->chip->usb_id) {
3359        case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */
3360                if (unitid == 7 && cval->control == UAC_FU_VOLUME)
3361                        snd_dragonfly_quirk_db_scale(mixer, cval, kctl);
3362                break;
3363        /* lowest playback value is muted on C-Media devices */
3364        case USB_ID(0x0d8c, 0x000c):
3365        case USB_ID(0x0d8c, 0x0014):
3366                if (strstr(kctl->id.name, "Playback"))
3367                        cval->min_mute = 1;
3368                break;
3369        }
3370}
3371
3372