kernel/sound/usb/mixer_scarlett.c

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