sound/usb/mixer_scarlett.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *   Scarlett Driver for ALSA
   4  *
   5  *   Copyright (c) 2013 by Tobias Hoffmann
   6  *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
   7  *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
   8  *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
   9  *
  10  *   Many codes borrowed from audio.c by
  11  *          Alan Cox (alan at lxorguk.ukuu.org.uk)
  12  *          Thomas Sailer (sailer at ife.ee.ethz.ch)
  13  *
  14  *   Code cleanup:
  15  *   David Henningsson <david.henningsson at canonical.com>
  16  */
  17
  18 /*
  19  * Rewritten and extended to support more models, e.g. Scarlett 18i8.
  20  *
  21  * Auto-detection via UAC2 is not feasible to properly discover the vast
  22  * majority of features. It's related to both Linux/ALSA's UAC2 as well as
  23  * Focusrite's implementation of it. Eventually quirks may be sufficient but
  24  * right now it's a major headache to work arount these things.
  25  *
  26  * NB. Neither the OSX nor the win driver provided by Focusrite performs
  27  * discovery, they seem to operate the same as this driver.
  28  */
  29
  30 /* Mixer Interface for the Focusrite Scarlett 18i6 audio interface.
  31  *
  32  * The protocol was reverse engineered by looking at communication between
  33  * Scarlett MixControl (v 1.2.128.0) and the Focusrite(R) Scarlett 18i6
  34  * (firmware v305) using wireshark and usbmon in January 2013.
  35  * Extended in July 2013.
  36  *
  37  * this mixer gives complete access to all features of the device:
  38  *  - change Impedance of inputs (Line-in, Mic / Instrument, Hi-Z)
  39  *  - select clock source
  40  *  - dynamic input to mixer-matrix assignment
  41  *  - 18 x 6 mixer-matrix gain stages
  42  *  - bus routing & volume control
  43  *  - automatic re-initialization on connect if device was power-cycled
  44  *
  45  * USB URB commands overview (bRequest = 0x01 = UAC2_CS_CUR)
  46  * wIndex
  47  * 0x01 Analog Input line/instrument impedance switch, wValue=0x0901 +
  48  *      channel, data=Line/Inst (2bytes)
  49  *      pad (-10dB) switch, wValue=0x0b01 + channel, data=Off/On (2bytes)
  50  *      ?? wValue=0x0803/04, ?? (2bytes)
  51  * 0x0a Master Volume, wValue=0x0200+bus[0:all + only 1..4?] data(2bytes)
  52  *      Bus Mute/Unmute wValue=0x0100+bus[0:all + only 1..4?], data(2bytes)
  53  * 0x28 Clock source, wValue=0x0100, data={1:int,2:spdif,3:adat} (1byte)
  54  * 0x29 Set Sample-rate, wValue=0x0100, data=sample-rate(4bytes)
  55  * 0x32 Mixer mux, wValue=0x0600 + mixer-channel, data=input-to-connect(2bytes)
  56  * 0x33 Output mux, wValue=bus, data=input-to-connect(2bytes)
  57  * 0x34 Capture mux, wValue=0...18, data=input-to-connect(2bytes)
  58  * 0x3c Matrix Mixer gains, wValue=mixer-node  data=gain(2bytes)
  59  *      ?? [sometimes](4bytes, e.g 0x000003be 0x000003bf ...03ff)
  60  *
  61  * USB reads: (i.e. actually issued by original software)
  62  * 0x01 wValue=0x0901+channel (1byte!!), wValue=0x0b01+channed (1byte!!)
  63  * 0x29 wValue=0x0100 sample-rate(4bytes)
  64  *      wValue=0x0200 ?? 1byte (only once)
  65  * 0x2a wValue=0x0100 ?? 4bytes, sample-rate2 ??
  66  *
  67  * USB reads with bRequest = 0x03 = UAC2_CS_MEM
  68  * 0x3c wValue=0x0002 1byte: sync status (locked=1)
  69  *      wValue=0x0000 18*2byte: peak meter (inputs)
  70  *      wValue=0x0001 8(?)*2byte: peak meter (mix)
  71  *      wValue=0x0003 6*2byte: peak meter (pcm/daw)
  72  *
  73  * USB write with bRequest = 0x03
  74  * 0x3c Save settings to hardware: wValue=0x005a, data=0xa5
  75  *
  76  *
  77  * <ditaa>
  78  *  /--------------\    18chn            6chn    /--------------\
  79  *  | Hardware  in +--+-------\        /------+--+ ALSA PCM out |
  80  *  \--------------/  |       |        |      |  \--------------/
  81  *                    |       |        |      |
  82  *                    |       v        v      |
  83  *                    |   +---------------+   |
  84  *                    |    \ Matrix  Mux /    |
  85  *                    |     +-----+-----+     |
  86  *                    |           |           |
  87  *                    |           | 18chn     |
  88  *                    |           v           |
  89  *                    |     +-----------+     |
  90  *                    |     | Mixer     |     |
  91  *                    |     |    Matrix |     |
  92  *                    |     |           |     |
  93  *                    |     | 18x6 Gain |     |
  94  *                    |     |   stages  |     |
  95  *                    |     +-----+-----+     |
  96  *                    |           |           |
  97  *                    |           |           |
  98  *                    | 18chn     | 6chn      | 6chn
  99  *                    v           v           v
 100  *                    =========================
 101  *             +---------------+     +--—------------+
 102  *              \ Output  Mux /       \ Capture Mux /
 103  *               +-----+-----+         +-----+-----+
 104  *                     |                     |
 105  *                     | 6chn                |
 106  *                     v                     |
 107  *              +-------------+              |
 108  *              | Master Gain |              |
 109  *              +------+------+              |
 110  *                     |                     |
 111  *                     | 6chn                | 18chn
 112  *                     | (3 stereo pairs)    |
 113  *  /--------------\   |                     |   /--------------\
 114  *  | Hardware out |<--/                     \-->| ALSA PCM  in |
 115  *  \--------------/                             \--------------/
 116  * </ditaa>
 117  *
 118  */
 119
 120 #include <linux/slab.h>
 121 #include <linux/usb.h>
 122 #include <linux/usb/audio-v2.h>
 123
 124 #include <sound/core.h>
 125 #include <sound/control.h>
 126 #include <sound/tlv.h>
 127
 128 #include "usbaudio.h"
 129 #include "mixer.h"
 130 #include "helper.h"
 131 #include "power.h"
 132
 133 #include "mixer_scarlett.h"
 134
 135 /* some gui mixers can't handle negative ctl values */
 136 #define SND_SCARLETT_LEVEL_BIAS 128
 137 #define SND_SCARLETT_MATRIX_IN_MAX 18
 138 #define SND_SCARLETT_CONTROLS_MAX 10
 139 #define SND_SCARLETT_OFFSETS_MAX 5
 140
 141 enum {
 142         SCARLETT_OUTPUTS,
 143         SCARLETT_SWITCH_IMPEDANCE,
 144         SCARLETT_SWITCH_PAD,
 145 };
 146
 147 enum {
 148         SCARLETT_OFFSET_PCM = 0,
 149         SCARLETT_OFFSET_ANALOG = 1,
 150         SCARLETT_OFFSET_SPDIF = 2,
 151         SCARLETT_OFFSET_ADAT = 3,
 152         SCARLETT_OFFSET_MIX = 4,
 153 };
 154
 155 struct scarlett_mixer_elem_enum_info {
 156         int start;
 157         int len;
 158         int offsets[SND_SCARLETT_OFFSETS_MAX];
 159         char const * const *names;
 160 };
 161
 162 struct scarlett_mixer_control {
 163         unsigned char num;
 164         unsigned char type;
 165         const char *name;
 166 };
 167
 168 struct scarlett_device_info {
 169         int matrix_in;
 170         int matrix_out;
 171         int input_len;
 172         int output_len;
 173
 174         struct scarlett_mixer_elem_enum_info opt_master;
 175         struct scarlett_mixer_elem_enum_info opt_matrix;
 176
 177         /* initial values for matrix mux */
 178         int matrix_mux_init[SND_SCARLETT_MATRIX_IN_MAX];
 179
 180         int num_controls;       /* number of items in controls */
 181         const struct scarlett_mixer_control controls[SND_SCARLETT_CONTROLS_MAX];
 182 };
 183
 184 /********************** Enum Strings *************************/
 185
 186 static const struct scarlett_mixer_elem_enum_info opt_pad = {
 187         .start = 0,
 188         .len = 2,
 189         .offsets = {},
 190         .names = (char const * const []){
 191                 "0dB", "-10dB"
 192         }
 193 };
 194
 195 static const struct scarlett_mixer_elem_enum_info opt_impedance = {
 196         .start = 0,
 197         .len = 2,
 198         .offsets = {},
 199         .names = (char const * const []){
 200                 "Line", "Hi-Z"
 201         }
 202 };
 203
 204 static const struct scarlett_mixer_elem_enum_info opt_clock = {
 205         .start = 1,
 206         .len = 3,
 207         .offsets = {},
 208         .names = (char const * const []){
 209                 "Internal", "SPDIF", "ADAT"
 210         }
 211 };
 212
 213 static const struct scarlett_mixer_elem_enum_info opt_sync = {
 214         .start = 0,
 215         .len = 2,
 216         .offsets = {},
 217         .names = (char const * const []){
 218                 "No Lock", "Locked"
 219         }
 220 };
 221
 222 static int scarlett_ctl_switch_info(struct snd_kcontrol *kctl,
 223                 struct snd_ctl_elem_info *uinfo)
 224 {
 225         struct usb_mixer_elem_info *elem = kctl->private_data;
 226
 227         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 228         uinfo->count = elem->channels;
 229         uinfo->value.integer.min = 0;
 230         uinfo->value.integer.max = 1;
 231         return 0;
 232 }
 233
 234 static int scarlett_ctl_switch_get(struct snd_kcontrol *kctl,
 235                 struct snd_ctl_elem_value *ucontrol)
 236 {
 237         struct usb_mixer_elem_info *elem = kctl->private_data;
 238         int i, err, val;
 239
 240         for (i = 0; i < elem->channels; i++) {
 241                 err = snd_usb_get_cur_mix_value(elem, i, i, &val);
 242                 if (err < 0)
 243                         return err;
 244
 245                 val = !val; /* invert mute logic for mixer */
 246                 ucontrol->value.integer.value[i] = val;
 247         }
 248
 249         return 0;
 250 }
 251
 252 static int scarlett_ctl_switch_put(struct snd_kcontrol *kctl,
 253                 struct snd_ctl_elem_value *ucontrol)
 254 {
 255         struct usb_mixer_elem_info *elem = kctl->private_data;
 256         int i, changed = 0;
 257         int err, oval, val;
 258
 259         for (i = 0; i < elem->channels; i++) {
 260                 err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
 261                 if (err < 0)
 262                         return err;
 263
 264                 val = ucontrol->value.integer.value[i];
 265                 val = !val;
 266                 if (oval != val) {
 267                         err = snd_usb_set_cur_mix_value(elem, i, i, val);
 268                         if (err < 0)
 269                                 return err;
 270
 271                         changed = 1;
 272                 }
 273         }
 274
 275         return changed;
 276 }
 277
 278 static int scarlett_ctl_resume(struct usb_mixer_elem_list *list)
 279 {
 280         struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
 281         int i;
 282
 283         for (i = 0; i < elem->channels; i++)
 284                 if (elem->cached & (1 << i))
 285                         snd_usb_set_cur_mix_value(elem, i, i,
 286                                                   elem->cache_val[i]);
 287         return 0;
 288 }
 289
 290 static int scarlett_ctl_info(struct snd_kcontrol *kctl,
 291                              struct snd_ctl_elem_info *uinfo)
 292 {
 293         struct usb_mixer_elem_info *elem = kctl->private_data;
 294
 295         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 296         uinfo->count = elem->channels;
 297         uinfo->value.integer.min = 0;
 298         uinfo->value.integer.max = (int)kctl->private_value +
 299                 SND_SCARLETT_LEVEL_BIAS;
 300         uinfo->value.integer.step = 1;
 301         return 0;
 302 }
 303
 304 static int scarlett_ctl_get(struct snd_kcontrol *kctl,
 305                             struct snd_ctl_elem_value *ucontrol)
 306 {
 307         struct usb_mixer_elem_info *elem = kctl->private_data;
 308         int i, err, val;
 309
 310         for (i = 0; i < elem->channels; i++) {
 311                 err = snd_usb_get_cur_mix_value(elem, i, i, &val);
 312                 if (err < 0)
 313                         return err;
 314
 315                 val = clamp(val / 256, -128, (int)kctl->private_value) +
 316                                     SND_SCARLETT_LEVEL_BIAS;
 317                 ucontrol->value.integer.value[i] = val;
 318         }
 319
 320         return 0;
 321 }
 322
 323 static int scarlett_ctl_put(struct snd_kcontrol *kctl,
 324                             struct snd_ctl_elem_value *ucontrol)
 325 {
 326         struct usb_mixer_elem_info *elem = kctl->private_data;
 327         int i, changed = 0;
 328         int err, oval, val;
 329
 330         for (i = 0; i < elem->channels; i++) {
 331                 err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
 332                 if (err < 0)
 333                         return err;
 334
 335                 val = ucontrol->value.integer.value[i] -
 336                         SND_SCARLETT_LEVEL_BIAS;
 337                 val = val * 256;
 338                 if (oval != val) {
 339                         err = snd_usb_set_cur_mix_value(elem, i, i, val);
 340                         if (err < 0)
 341                                 return err;
 342
 343                         changed = 1;
 344                 }
 345         }
 346
 347         return changed;
 348 }
 349
 350 static void scarlett_generate_name(int i, char *dst, int offsets[])
 351 {
 352         if (i > offsets[SCARLETT_OFFSET_MIX])
 353                 sprintf(dst, "Mix %c",
 354                         'A'+(i - offsets[SCARLETT_OFFSET_MIX] - 1));
 355         else if (i > offsets[SCARLETT_OFFSET_ADAT])
 356                 sprintf(dst, "ADAT %d", i - offsets[SCARLETT_OFFSET_ADAT]);
 357         else if (i > offsets[SCARLETT_OFFSET_SPDIF])
 358                 sprintf(dst, "SPDIF %d", i - offsets[SCARLETT_OFFSET_SPDIF]);
 359         else if (i > offsets[SCARLETT_OFFSET_ANALOG])
 360                 sprintf(dst, "Analog %d", i - offsets[SCARLETT_OFFSET_ANALOG]);
 361         else if (i > offsets[SCARLETT_OFFSET_PCM])
 362                 sprintf(dst, "PCM %d", i - offsets[SCARLETT_OFFSET_PCM]);
 363         else
 364                 sprintf(dst, "Off");
 365 }
 366
 367 static int scarlett_ctl_enum_dynamic_info(struct snd_kcontrol *kctl,
 368                                           struct snd_ctl_elem_info *uinfo)
 369 {
 370         struct usb_mixer_elem_info *elem = kctl->private_data;
 371         struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
 372         unsigned int items = opt->len;
 373
 374         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 375         uinfo->count = elem->channels;
 376         uinfo->value.enumerated.items = items;
 377
 378         if (uinfo->value.enumerated.item >= items)
 379                 uinfo->value.enumerated.item = items - 1;
 380
 381         /* generate name dynamically based on item number and offset info */
 382         scarlett_generate_name(uinfo->value.enumerated.item,
 383                                uinfo->value.enumerated.name,
 384                                opt->offsets);
 385
 386         return 0;
 387 }
 388
 389 static int scarlett_ctl_enum_info(struct snd_kcontrol *kctl,
 390                                   struct snd_ctl_elem_info *uinfo)
 391 {
 392         struct usb_mixer_elem_info *elem = kctl->private_data;
 393         struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
 394
 395         return snd_ctl_enum_info(uinfo, elem->channels, opt->len,
 396                                  (const char * const *)opt->names);
 397 }
 398
 399 static int scarlett_ctl_enum_get(struct snd_kcontrol *kctl,
 400                                  struct snd_ctl_elem_value *ucontrol)
 401 {
 402         struct usb_mixer_elem_info *elem = kctl->private_data;
 403         struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
 404         int err, val;
 405
 406         err = snd_usb_get_cur_mix_value(elem, 0, 0, &val);
 407         if (err < 0)
 408                 return err;
 409
 410         val = clamp(val - opt->start, 0, opt->len-1);
 411
 412         ucontrol->value.enumerated.item[0] = val;
 413
 414         return 0;
 415 }
 416
 417 static int scarlett_ctl_enum_put(struct snd_kcontrol *kctl,
 418                                  struct snd_ctl_elem_value *ucontrol)
 419 {
 420         struct usb_mixer_elem_info *elem = kctl->private_data;
 421         struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
 422         int err, oval, val;
 423
 424         err = snd_usb_get_cur_mix_value(elem, 0, 0, &oval);
 425         if (err < 0)
 426                 return err;
 427
 428         val = ucontrol->value.integer.value[0];
 429         val = val + opt->start;
 430         if (val != oval) {
 431                 snd_usb_set_cur_mix_value(elem, 0, 0, val);
 432                 return 1;
 433         }
 434         return 0;
 435 }
 436
 437 static int scarlett_ctl_enum_resume(struct usb_mixer_elem_list *list)
 438 {
 439         struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
 440
 441         if (elem->cached)
 442                 snd_usb_set_cur_mix_value(elem, 0, 0, *elem->cache_val);
 443         return 0;
 444 }
 445
 446 static int scarlett_ctl_meter_get(struct snd_kcontrol *kctl,
 447                                   struct snd_ctl_elem_value *ucontrol)
 448 {
 449         struct usb_mixer_elem_info *elem = kctl->private_data;
 450         struct snd_usb_audio *chip = elem->head.mixer->chip;
 451         unsigned char buf[2 * MAX_CHANNELS] = {0, };
 452         int wValue = (elem->control << 8) | elem->idx_off;
 453         int idx = snd_usb_ctrl_intf(chip) | (elem->head.id << 8);
 454         int err;
 455
 456         err = snd_usb_ctl_msg(chip->dev,
 457                                 usb_rcvctrlpipe(chip->dev, 0),
 458                                 UAC2_CS_MEM,
 459                                 USB_RECIP_INTERFACE | USB_TYPE_CLASS |
 460                                 USB_DIR_IN, wValue, idx, buf, elem->channels);
 461         if (err < 0)
 462                 return err;
 463
 464         ucontrol->value.enumerated.item[0] = clamp((int)buf[0], 0, 1);
 465         return 0;
 466 }
 467
 468 static const struct snd_kcontrol_new usb_scarlett_ctl_switch = {
 469         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 470         .name = "",
 471         .info = scarlett_ctl_switch_info,
 472         .get =  scarlett_ctl_switch_get,
 473         .put =  scarlett_ctl_switch_put,
 474 };
 475
 476 static const DECLARE_TLV_DB_SCALE(db_scale_scarlett_gain, -12800, 100, 0);
 477
 478 static const struct snd_kcontrol_new usb_scarlett_ctl = {
 479         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 480         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 481                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 482         .name = "",
 483         .info = scarlett_ctl_info,
 484         .get =  scarlett_ctl_get,
 485         .put =  scarlett_ctl_put,
 486         .private_value = 6,  /* max value */
 487         .tlv = { .p = db_scale_scarlett_gain }
 488 };
 489
 490 static const struct snd_kcontrol_new usb_scarlett_ctl_master = {
 491         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 492         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
 493                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
 494         .name = "",
 495         .info = scarlett_ctl_info,
 496         .get =  scarlett_ctl_get,
 497         .put =  scarlett_ctl_put,
 498         .private_value = 6,  /* max value */
 499         .tlv = { .p = db_scale_scarlett_gain }
 500 };
 501
 502 static const struct snd_kcontrol_new usb_scarlett_ctl_enum = {
 503         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 504         .name = "",
 505         .info = scarlett_ctl_enum_info,
 506         .get =  scarlett_ctl_enum_get,
 507         .put =  scarlett_ctl_enum_put,
 508 };
 509
 510 static const struct snd_kcontrol_new usb_scarlett_ctl_dynamic_enum = {
 511         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 512         .name = "",
 513         .info = scarlett_ctl_enum_dynamic_info,
 514         .get =  scarlett_ctl_enum_get,
 515         .put =  scarlett_ctl_enum_put,
 516 };
 517
 518 static const struct snd_kcontrol_new usb_scarlett_ctl_sync = {
 519         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 520         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
 521         .name = "",
 522         .info = scarlett_ctl_enum_info,
 523         .get =  scarlett_ctl_meter_get,
 524 };
 525
 526 static int add_new_ctl(struct usb_mixer_interface *mixer,
 527                        const struct snd_kcontrol_new *ncontrol,
 528                        usb_mixer_elem_resume_func_t resume,
 529                        int index, int offset, int num,
 530                        int val_type, int channels, const char *name,
 531                        const struct scarlett_mixer_elem_enum_info *opt,
 532                        struct usb_mixer_elem_info **elem_ret
 533 )
 534 {
 535         struct snd_kcontrol *kctl;
 536         struct usb_mixer_elem_info *elem;
 537         int err;
 538
 539         elem = kzalloc(sizeof(*elem), GFP_KERNEL);
 540         if (!elem)
 541                 return -ENOMEM;
 542
 543         elem->head.mixer = mixer;
 544         elem->head.resume = resume;
 545         elem->control = offset;
 546         elem->idx_off = num;
 547         elem->head.id = index;
 548         elem->val_type = val_type;
 549
 550         elem->channels = channels;
 551
 552         /* add scarlett_mixer_elem_enum_info struct */
 553         elem->private_data = (void *)opt;
 554
 555         kctl = snd_ctl_new1(ncontrol, elem);
 556         if (!kctl) {
 557                 kfree(elem);
 558                 return -ENOMEM;
 559         }
 560         kctl->private_free = snd_usb_mixer_elem_free;
 561
 562         strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
 563
 564         err = snd_usb_mixer_add_control(&elem->head, kctl);
 565         if (err < 0)
 566                 return err;
 567
 568         if (elem_ret)
 569                 *elem_ret = elem;
 570
 571         return 0;
 572 }
 573
 574 static int add_output_ctls(struct usb_mixer_interface *mixer,
 575                            int index, const char *name,
 576                            const struct scarlett_device_info *info)
 577 {
 578         int err;
 579         char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 580         struct usb_mixer_elem_info *elem;
 581
 582         /* Add mute switch */
 583         snprintf(mx, sizeof(mx), "Master %d (%s) Playback Switch",
 584                 index + 1, name);
 585         err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
 586                           scarlett_ctl_resume, 0x0a, 0x01,
 587                           2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
 588         if (err < 0)
 589                 return err;
 590
 591         /* Add volume control and initialize to 0 */
 592         snprintf(mx, sizeof(mx), "Master %d (%s) Playback Volume",
 593                 index + 1, name);
 594         err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
 595                           scarlett_ctl_resume, 0x0a, 0x02,
 596                           2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
 597         if (err < 0)
 598                 return err;
 599
 600         /* Add L channel source playback enumeration */
 601         snprintf(mx, sizeof(mx), "Master %dL (%s) Source Playback Enum",
 602                 index + 1, name);
 603         err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
 604                           scarlett_ctl_enum_resume, 0x33, 0x00,
 605                           2*index, USB_MIXER_S16, 1, mx, &info->opt_master,
 606                           &elem);
 607         if (err < 0)
 608                 return err;
 609
 610         /* Add R channel source playback enumeration */
 611         snprintf(mx, sizeof(mx), "Master %dR (%s) Source Playback Enum",
 612                 index + 1, name);
 613         err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
 614                           scarlett_ctl_enum_resume, 0x33, 0x00,
 615                           2*index+1, USB_MIXER_S16, 1, mx, &info->opt_master,
 616                           &elem);
 617         if (err < 0)
 618                 return err;
 619
 620         return 0;
 621 }
 622
 623 /********************** device-specific config *************************/
 624
 625 /*  untested...  */
 626 static struct scarlett_device_info s6i6_info = {
 627         .matrix_in = 18,
 628         .matrix_out = 8,
 629         .input_len = 6,
 630         .output_len = 6,
 631
 632         .opt_master = {
 633                 .start = -1,
 634                 .len = 27,
 635                 .offsets = {0, 12, 16, 18, 18},
 636                 .names = NULL
 637         },
 638
 639         .opt_matrix = {
 640                 .start = -1,
 641                 .len = 19,
 642                 .offsets = {0, 12, 16, 18, 18},
 643                 .names = NULL
 644         },
 645
 646         .num_controls = 9,
 647         .controls = {
 648                 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
 649                 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
 650                 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
 651                 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 652                 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 653                 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 654                 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 655                 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 656                 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 657         },
 658
 659         .matrix_mux_init = {
 660                 12, 13, 14, 15,                 /* Analog -> 1..4 */
 661                 16, 17,                          /* SPDIF -> 5,6 */
 662                 0, 1, 2, 3, 4, 5, 6, 7,     /* PCM[1..12] -> 7..18 */
 663                 8, 9, 10, 11
 664         }
 665 };
 666
 667 /*  untested...  */
 668 static struct scarlett_device_info s8i6_info = {
 669         .matrix_in = 18,
 670         .matrix_out = 6,
 671         .input_len = 8,
 672         .output_len = 6,
 673
 674         .opt_master = {
 675                 .start = -1,
 676                 .len = 25,
 677                 .offsets = {0, 12, 16, 18, 18},
 678                 .names = NULL
 679         },
 680
 681         .opt_matrix = {
 682                 .start = -1,
 683                 .len = 19,
 684                 .offsets = {0, 12, 16, 18, 18},
 685                 .names = NULL
 686         },
 687
 688         .num_controls = 7,
 689         .controls = {
 690                 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
 691                 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
 692                 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
 693                 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 694                 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 695                 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 696                 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 697         },
 698
 699         .matrix_mux_init = {
 700                 12, 13, 14, 15,                 /* Analog -> 1..4 */
 701                 16, 17,                          /* SPDIF -> 5,6 */
 702                 0, 1, 2, 3, 4, 5, 6, 7,     /* PCM[1..12] -> 7..18 */
 703                 8, 9, 10, 11
 704         }
 705 };
 706
 707 static struct scarlett_device_info s18i6_info = {
 708         .matrix_in = 18,
 709         .matrix_out = 6,
 710         .input_len = 18,
 711         .output_len = 6,
 712
 713         .opt_master = {
 714                 .start = -1,
 715                 .len = 31,
 716                 .offsets = {0, 6, 14, 16, 24},
 717                 .names = NULL,
 718         },
 719
 720         .opt_matrix = {
 721                 .start = -1,
 722                 .len = 25,
 723                 .offsets = {0, 6, 14, 16, 24},
 724                 .names = NULL,
 725         },
 726
 727         .num_controls = 5,
 728         .controls = {
 729                 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
 730                 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
 731                 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
 732                 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 733                 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 734         },
 735
 736         .matrix_mux_init = {
 737                  6,  7,  8,  9, 10, 11, 12, 13, /* Analog -> 1..8 */
 738                 16, 17, 18, 19, 20, 21,     /* ADAT[1..6] -> 9..14 */
 739                 14, 15,                          /* SPDIF -> 15,16 */
 740                 0, 1                          /* PCM[1,2] -> 17,18 */
 741         }
 742 };
 743
 744 static struct scarlett_device_info s18i8_info = {
 745         .matrix_in = 18,
 746         .matrix_out = 8,
 747         .input_len = 18,
 748         .output_len = 8,
 749
 750         .opt_master = {
 751                 .start = -1,
 752                 .len = 35,
 753                 .offsets = {0, 8, 16, 18, 26},
 754                 .names = NULL
 755         },
 756
 757         .opt_matrix = {
 758                 .start = -1,
 759                 .len = 27,
 760                 .offsets = {0, 8, 16, 18, 26},
 761                 .names = NULL
 762         },
 763
 764         .num_controls = 10,
 765         .controls = {
 766                 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
 767                 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone 1" },
 768                 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Headphone 2" },
 769                 { .num = 3, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
 770                 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 771                 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 772                 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 773                 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 774                 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 775                 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 776         },
 777
 778         .matrix_mux_init = {
 779                  8,  9, 10, 11, 12, 13, 14, 15, /* Analog -> 1..8 */
 780                 18, 19, 20, 21, 22, 23,     /* ADAT[1..6] -> 9..14 */
 781                 16, 17,                          /* SPDIF -> 15,16 */
 782                 0, 1                          /* PCM[1,2] -> 17,18 */
 783         }
 784 };
 785
 786 static struct scarlett_device_info s18i20_info = {
 787         .matrix_in = 18,
 788         .matrix_out = 8,
 789         .input_len = 18,
 790         .output_len = 20,
 791
 792         .opt_master = {
 793                 .start = -1,
 794                 .len = 47,
 795                 .offsets = {0, 20, 28, 30, 38},
 796                 .names = NULL
 797         },
 798
 799         .opt_matrix = {
 800                 .start = -1,
 801                 .len = 39,
 802                 .offsets = {0, 20, 28, 30, 38},
 803                 .names = NULL
 804         },
 805
 806         .num_controls = 10,
 807         .controls = {
 808                 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
 809                 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Line 3/4" },
 810                 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Line 5/6" },
 811                 { .num = 3, .type = SCARLETT_OUTPUTS, .name = "Line 7/8" },
 812                 { .num = 4, .type = SCARLETT_OUTPUTS, .name = "Line 9/10" },
 813                 { .num = 5, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
 814                 { .num = 6, .type = SCARLETT_OUTPUTS, .name = "ADAT 1/2" },
 815                 { .num = 7, .type = SCARLETT_OUTPUTS, .name = "ADAT 3/4" },
 816                 { .num = 8, .type = SCARLETT_OUTPUTS, .name = "ADAT 5/6" },
 817                 { .num = 9, .type = SCARLETT_OUTPUTS, .name = "ADAT 7/8" },
 818                 /*{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 819                 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 820                 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
 821                 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 822                 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
 823                 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},*/
 824         },
 825
 826         .matrix_mux_init = {
 827                 20, 21, 22, 23, 24, 25, 26, 27, /* Analog -> 1..8 */
 828                 30, 31, 32, 33, 34, 35,     /* ADAT[1..6] -> 9..14 */
 829                 28, 29,                          /* SPDIF -> 15,16 */
 830                 0, 1                          /* PCM[1,2] -> 17,18 */
 831         }
 832 };
 833
 834
 835 static int scarlett_controls_create_generic(struct usb_mixer_interface *mixer,
 836         struct scarlett_device_info *info)
 837 {
 838         int i, err;
 839         char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 840         const struct scarlett_mixer_control *ctl;
 841         struct usb_mixer_elem_info *elem;
 842
 843         /* create master switch and playback volume */
 844         err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
 845                           scarlett_ctl_resume, 0x0a, 0x01, 0,
 846                           USB_MIXER_S16, 1, "Master Playback Switch", NULL,
 847                           &elem);
 848         if (err < 0)
 849                 return err;
 850
 851         err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
 852                           scarlett_ctl_resume, 0x0a, 0x02, 0,
 853                           USB_MIXER_S16, 1, "Master Playback Volume", NULL,
 854                           &elem);
 855         if (err < 0)
 856                 return err;
 857
 858         /* iterate through controls in info struct and create each one */
 859         for (i = 0; i < info->num_controls; i++) {
 860                 ctl = &info->controls[i];
 861
 862                 switch (ctl->type) {
 863                 case SCARLETT_OUTPUTS:
 864                         err = add_output_ctls(mixer, ctl->num, ctl->name, info);
 865                         if (err < 0)
 866                                 return err;
 867                         break;
 868                 case SCARLETT_SWITCH_IMPEDANCE:
 869                         sprintf(mx, "Input %d Impedance Switch", ctl->num);
 870                         err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
 871                                           scarlett_ctl_enum_resume, 0x01,
 872                                           0x09, ctl->num, USB_MIXER_S16, 1, mx,
 873                                           &opt_impedance, &elem);
 874                         if (err < 0)
 875                                 return err;
 876                         break;
 877                 case SCARLETT_SWITCH_PAD:
 878                         sprintf(mx, "Input %d Pad Switch", ctl->num);
 879                         err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
 880                                           scarlett_ctl_enum_resume, 0x01,
 881                                           0x0b, ctl->num, USB_MIXER_S16, 1, mx,
 882                                           &opt_pad, &elem);
 883                         if (err < 0)
 884                                 return err;
 885                         break;
 886                 }
 887         }
 888
 889         return 0;
 890 }
 891
 892 /*
 893  * Create and initialize a mixer for the Focusrite(R) Scarlett
 894  */
 895 int snd_scarlett_controls_create(struct usb_mixer_interface *mixer)
 896 {
 897         int err, i, o;
 898         char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
 899         struct scarlett_device_info *info;
 900         struct usb_mixer_elem_info *elem;
 901         static char sample_rate_buffer[4] = { '\x80', '\xbb', '\x00', '\x00' };
 902
 903         /* only use UAC_VERSION_2 */
 904         if (!mixer->protocol)
 905                 return 0;
 906
 907         switch (mixer->chip->usb_id) {
 908         case USB_ID(0x1235, 0x8012):
 909                 info = &s6i6_info;
 910                 break;
 911         case USB_ID(0x1235, 0x8002):
 912                 info = &s8i6_info;
 913                 break;
 914         case USB_ID(0x1235, 0x8004):
 915                 info = &s18i6_info;
 916                 break;
 917         case USB_ID(0x1235, 0x8014):
 918                 info = &s18i8_info;
 919                 break;
 920         case USB_ID(0x1235, 0x800c):
 921                 info = &s18i20_info;
 922                 break;
 923         default: /* device not (yet) supported */
 924                 return -EINVAL;
 925         }
 926
 927         /* generic function to create controls */
 928         err = scarlett_controls_create_generic(mixer, info);
 929         if (err < 0)
 930                 return err;
 931
 932         /* setup matrix controls */
 933         for (i = 0; i < info->matrix_in; i++) {
 934                 snprintf(mx, sizeof(mx), "Matrix %02d Input Playback Route",
 935                          i+1);
 936                 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
 937                                   scarlett_ctl_enum_resume, 0x32,
 938                                   0x06, i, USB_MIXER_S16, 1, mx,
 939                                   &info->opt_matrix, &elem);
 940                 if (err < 0)
 941                         return err;
 942
 943                 for (o = 0; o < info->matrix_out; o++) {
 944                         sprintf(mx, "Matrix %02d Mix %c Playback Volume", i+1,
 945                                 o+'A');
 946                         err = add_new_ctl(mixer, &usb_scarlett_ctl,
 947                                           scarlett_ctl_resume, 0x3c, 0x00,
 948                                           (i << 3) + (o & 0x07), USB_MIXER_S16,
 949                                           1, mx, NULL, &elem);
 950                         if (err < 0)
 951                                 return err;
 952
 953                 }
 954         }
 955
 956         for (i = 0; i < info->input_len; i++) {
 957                 snprintf(mx, sizeof(mx), "Input Source %02d Capture Route",
 958                          i+1);
 959                 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
 960                                   scarlett_ctl_enum_resume, 0x34,
 961                                   0x00, i, USB_MIXER_S16, 1, mx,
 962                                   &info->opt_master, &elem);
 963                 if (err < 0)
 964                         return err;
 965         }
 966
 967         /* val_len == 1 needed here */
 968         err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
 969                           scarlett_ctl_enum_resume, 0x28, 0x01, 0,
 970                           USB_MIXER_U8, 1, "Sample Clock Source",
 971                           &opt_clock, &elem);
 972         if (err < 0)
 973                 return err;
 974
 975         /* val_len == 1 and UAC2_CS_MEM */
 976         err = add_new_ctl(mixer, &usb_scarlett_ctl_sync, NULL, 0x3c, 0x00, 2,
 977                           USB_MIXER_U8, 1, "Sample Clock Sync Status",
 978                           &opt_sync, &elem);
 979         if (err < 0)
 980                 return err;
 981
 982         /* initialize sampling rate to 48000 */
 983         err = snd_usb_ctl_msg(mixer->chip->dev,
 984                 usb_sndctrlpipe(mixer->chip->dev, 0), UAC2_CS_CUR,
 985                 USB_RECIP_INTERFACE | USB_TYPE_CLASS |
 986                 USB_DIR_OUT, 0x0100, snd_usb_ctrl_intf(mixer->chip) |
 987                 (0x29 << 8), sample_rate_buffer, 4);
 988         if (err < 0)
 989                 return err;
 990
 991         return err;
 992 }