sound/usb/mixer_scarlett_gen2.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *   Focusrite Scarlett Gen 2/3 and Clarett+ Driver for ALSA
   4  *
   5  *   Supported models:
   6  *   - 6i6/18i8/18i20 Gen 2
   7  *   - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
   8  *   - Clarett+ 8Pre
   9  *
  10  *   Copyright (c) 2018-2022 by Geoffrey D. Bennett <g at b4.vu>
  11  *   Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
  12  *   Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com>
  13  *
  14  *   Based on the Scarlett (Gen 1) Driver for ALSA:
  15  *
  16  *   Copyright (c) 2013 by Tobias Hoffmann
  17  *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
  18  *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
  19  *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
  20  *
  21  *   Many codes borrowed from audio.c by
  22  *     Alan Cox (alan at lxorguk.ukuu.org.uk)
  23  *     Thomas Sailer (sailer at ife.ee.ethz.ch)
  24  *
  25  *   Code cleanup:
  26  *   David Henningsson <david.henningsson at canonical.com>
  27  */
  28
  29 /* The protocol was reverse engineered by looking at the communication
  30  * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
  31  * (firmware 1083) using usbmon in July-August 2018.
  32  *
  33  * Scarlett 18i8 support added in April 2019.
  34  *
  35  * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
  36  * for providing usbmon output and testing).
  37  *
  38  * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
  39  * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
  40  * usbmon output and testing).
  41  *
  42  * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
  43  * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon
  44  * output, protocol traces and testing).
  45  *
  46  * Support for loading mixer volume and mux configuration from the
  47  * interface during driver initialisation added in May 2021 (thanks to
  48  * Vladimir Sadovnikov for figuring out how).
  49  *
  50  * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
  51  * Vorona for 2i2 protocol traces).
  52  *
  53  * Support for phantom power, direct monitoring, speaker switching,
  54  * and talkback added in May-June 2021.
  55  *
  56  * Support for Clarett+ 8Pre added in Aug 2022 by Christian
  57  * Colglazier.
  58  *
  59  * This ALSA mixer gives access to (model-dependent):
  60  *  - input, output, mixer-matrix muxes
  61  *  - mixer-matrix gain stages
  62  *  - gain/volume/mute controls
  63  *  - level meters
  64  *  - line/inst level, pad, and air controls
  65  *  - phantom power, direct monitor, speaker switching, and talkback
  66  *    controls
  67  *  - disable/enable MSD mode
  68  *  - disable/enable standalone mode
  69  *
  70  * <ditaa>
  71  *    /--------------\    18chn            20chn     /--------------\
  72  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
  73  *    \--------------/  |      |    |             |  \--------------/
  74  *                      |      |    |    /-----\  |
  75  *                      |      |    |    |     |  |
  76  *                      |      v    v    v     |  |
  77  *                      |   +---------------+  |  |
  78  *                      |    \ Matrix  Mux /   |  |
  79  *                      |     +-----+-----+    |  |
  80  *                      |           |          |  |
  81  *                      |           |18chn     |  |
  82  *                      |           |          |  |
  83  *                      |           |     10chn|  |
  84  *                      |           v          |  |
  85  *                      |     +------------+   |  |
  86  *                      |     | Mixer      |   |  |
  87  *                      |     |     Matrix |   |  |
  88  *                      |     |            |   |  |
  89  *                      |     | 18x10 Gain |   |  |
  90  *                      |     |   stages   |   |  |
  91  *                      |     +-----+------+   |  |
  92  *                      |           |          |  |
  93  *                      |18chn      |10chn     |  |20chn
  94  *                      |           |          |  |
  95  *                      |           +----------/  |
  96  *                      |           |             |
  97  *                      v           v             v
  98  *                      ===========================
  99  *               +---------------+       +--—------------+
 100  *                \ Output  Mux /         \ Capture Mux /
 101  *                 +---+---+---+           +-----+-----+
 102  *                     |   |                     |
 103  *                10chn|   |                     |18chn
 104  *                     |   |                     |
 105  *  /--------------\   |   |                     |   /--------------\
 106  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
 107  *  | Hardware out |       |                         \--------------/
 108  *  \--------------/       |
 109  *                         v
 110  *                  +-------------+    Software gain per channel.
 111  *                  | Master Gain |<-- 18i20 only: Switch per channel
 112  *                  +------+------+    to select HW or SW gain control.
 113  *                         |
 114  *                         |10chn
 115  *  /--------------\       |
 116  *  | Analogue     |<------/
 117  *  | Hardware out |
 118  *  \--------------/
 119  * </ditaa>
 120  *
 121  * Gen 3 devices have a Mass Storage Device (MSD) mode where a small
 122  * disk with registration and driver download information is presented
 123  * to the host. To access the full functionality of the device without
 124  * proprietary software, MSD mode can be disabled by:
 125  * - holding down the 48V button for five seconds while powering on
 126  *   the device, or
 127  * - using this driver and alsamixer to change the "MSD Mode" setting
 128  *   to Off and power-cycling the device
 129  */
 130
 131 #include <linux/slab.h>
 132 #include <linux/usb.h>
 133 #include <linux/moduleparam.h>
 134
 135 #include <sound/control.h>
 136 #include <sound/tlv.h>
 137
 138 #include "usbaudio.h"
 139 #include "mixer.h"
 140 #include "helper.h"
 141
 142 #include "mixer_scarlett_gen2.h"
 143
 144 /* device_setup value to enable */
 145 #define SCARLETT2_ENABLE 0x01
 146
 147 /* device_setup value to allow turning MSD mode back on */
 148 #define SCARLETT2_MSD_ENABLE 0x02
 149
 150 /* some gui mixers can't handle negative ctl values */
 151 #define SCARLETT2_VOLUME_BIAS 127
 152
 153 /* mixer range from -80dB to +6dB in 0.5dB steps */
 154 #define SCARLETT2_MIXER_MIN_DB -80
 155 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
 156 #define SCARLETT2_MIXER_MAX_DB 6
 157 #define SCARLETT2_MIXER_MAX_VALUE \
 158         ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
 159 #define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1)
 160
 161 /* map from (dB + 80) * 2 to mixer value
 162  * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
 163  */
 164 static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = {
 165         0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
 166         2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
 167         9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
 168         23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
 169         54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
 170         122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
 171         244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
 172         487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
 173         973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
 174         1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
 175         3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
 176         5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
 177         9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
 178         16345
 179 };
 180
 181 /* Maximum number of analogue outputs */
 182 #define SCARLETT2_ANALOGUE_MAX 10
 183
 184 /* Maximum number of level and pad switches */
 185 #define SCARLETT2_LEVEL_SWITCH_MAX 2
 186 #define SCARLETT2_PAD_SWITCH_MAX 8
 187 #define SCARLETT2_AIR_SWITCH_MAX 8
 188 #define SCARLETT2_PHANTOM_SWITCH_MAX 2
 189
 190 /* Maximum number of inputs to the mixer */
 191 #define SCARLETT2_INPUT_MIX_MAX 25
 192
 193 /* Maximum number of outputs from the mixer */
 194 #define SCARLETT2_OUTPUT_MIX_MAX 12
 195
 196 /* Maximum size of the data in the USB mux assignment message:
 197  * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare
 198  */
 199 #define SCARLETT2_MUX_MAX 77
 200
 201 /* Maximum number of meters (sum of output port counts) */
 202 #define SCARLETT2_MAX_METERS 65
 203
 204 /* There are three different sets of configuration parameters across
 205  * the devices
 206  */
 207 enum {
 208         SCARLETT2_CONFIG_SET_NO_MIXER = 0,
 209         SCARLETT2_CONFIG_SET_GEN_2 = 1,
 210         SCARLETT2_CONFIG_SET_GEN_3 = 2,
 211         SCARLETT2_CONFIG_SET_CLARETT = 3,
 212         SCARLETT2_CONFIG_SET_COUNT = 4
 213 };
 214
 215 /* Hardware port types:
 216  * - None (no input to mux)
 217  * - Analogue I/O
 218  * - S/PDIF I/O
 219  * - ADAT I/O
 220  * - Mixer I/O
 221  * - PCM I/O
 222  */
 223 enum {
 224         SCARLETT2_PORT_TYPE_NONE     = 0,
 225         SCARLETT2_PORT_TYPE_ANALOGUE = 1,
 226         SCARLETT2_PORT_TYPE_SPDIF    = 2,
 227         SCARLETT2_PORT_TYPE_ADAT     = 3,
 228         SCARLETT2_PORT_TYPE_MIX      = 4,
 229         SCARLETT2_PORT_TYPE_PCM      = 5,
 230         SCARLETT2_PORT_TYPE_COUNT    = 6,
 231 };
 232
 233 /* I/O count of each port type kept in struct scarlett2_ports */
 234 enum {
 235         SCARLETT2_PORT_IN    = 0,
 236         SCARLETT2_PORT_OUT   = 1,
 237         SCARLETT2_PORT_DIRNS = 2,
 238 };
 239
 240 /* Dim/Mute buttons on the 18i20 */
 241 enum {
 242         SCARLETT2_BUTTON_MUTE    = 0,
 243         SCARLETT2_BUTTON_DIM     = 1,
 244         SCARLETT2_DIM_MUTE_COUNT = 2,
 245 };
 246
 247 static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = {
 248         "Mute Playback Switch", "Dim Playback Switch"
 249 };
 250
 251 /* Description of each hardware port type:
 252  * - id: hardware ID of this port type
 253  * - src_descr: printf format string for mux input selections
 254  * - src_num_offset: added to channel number for the fprintf
 255  * - dst_descr: printf format string for mixer controls
 256  */
 257 struct scarlett2_port {
 258         u16 id;
 259         const char * const src_descr;
 260         int src_num_offset;
 261         const char * const dst_descr;
 262 };
 263
 264 static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = {
 265         [SCARLETT2_PORT_TYPE_NONE] = {
 266                 .id = 0x000,
 267                 .src_descr = "Off"
 268         },
 269         [SCARLETT2_PORT_TYPE_ANALOGUE] = {
 270                 .id = 0x080,
 271                 .src_descr = "Analogue %d",
 272                 .src_num_offset = 1,
 273                 .dst_descr = "Analogue Output %02d Playback"
 274         },
 275         [SCARLETT2_PORT_TYPE_SPDIF] = {
 276                 .id = 0x180,
 277                 .src_descr = "S/PDIF %d",
 278                 .src_num_offset = 1,
 279                 .dst_descr = "S/PDIF Output %d Playback"
 280         },
 281         [SCARLETT2_PORT_TYPE_ADAT] = {
 282                 .id = 0x200,
 283                 .src_descr = "ADAT %d",
 284                 .src_num_offset = 1,
 285                 .dst_descr = "ADAT Output %d Playback"
 286         },
 287         [SCARLETT2_PORT_TYPE_MIX] = {
 288                 .id = 0x300,
 289                 .src_descr = "Mix %c",
 290                 .src_num_offset = 'A',
 291                 .dst_descr = "Mixer Input %02d Capture"
 292         },
 293         [SCARLETT2_PORT_TYPE_PCM] = {
 294                 .id = 0x600,
 295                 .src_descr = "PCM %d",
 296                 .src_num_offset = 1,
 297                 .dst_descr = "PCM %02d Capture"
 298         },
 299 };
 300
 301 /* Number of mux tables: one for each band of sample rates
 302  * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz)
 303  */
 304 #define SCARLETT2_MUX_TABLES 3
 305
 306 /* Maximum number of entries in a mux table */
 307 #define SCARLETT2_MAX_MUX_ENTRIES 10
 308
 309 /* One entry within mux_assignment defines the port type and range of
 310  * ports to add to the set_mux message. The end of the list is marked
 311  * with count == 0.
 312  */
 313 struct scarlett2_mux_entry {
 314         u8 port_type;
 315         u8 start;
 316         u8 count;
 317 };
 318
 319 struct scarlett2_device_info {
 320         u32 usb_id; /* USB device identifier */
 321
 322         /* Gen 3 devices have an internal MSD mode switch that needs
 323          * to be disabled in order to access the full functionality of
 324          * the device.
 325          */
 326         u8 has_msd_mode;
 327
 328         /* which set of configuration parameters the device uses */
 329         u8 config_set;
 330
 331         /* line out hw volume is sw controlled */
 332         u8 line_out_hw_vol;
 333
 334         /* support for main/alt speaker switching */
 335         u8 has_speaker_switching;
 336
 337         /* support for talkback microphone */
 338         u8 has_talkback;
 339
 340         /* the number of analogue inputs with a software switchable
 341          * level control that can be set to line or instrument
 342          */
 343         u8 level_input_count;
 344
 345         /* the first input with a level control (0-based) */
 346         u8 level_input_first;
 347
 348         /* the number of analogue inputs with a software switchable
 349          * 10dB pad control
 350          */
 351         u8 pad_input_count;
 352
 353         /* the number of analogue inputs with a software switchable
 354          * "air" control
 355          */
 356         u8 air_input_count;
 357
 358         /* the number of phantom (48V) software switchable controls */
 359         u8 phantom_count;
 360
 361         /* the number of inputs each phantom switch controls */
 362         u8 inputs_per_phantom;
 363
 364         /* the number of direct monitor options
 365          * (0 = none, 1 = mono only, 2 = mono/stereo)
 366          */
 367         u8 direct_monitor;
 368
 369         /* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected
 370          * internally to the analogue 7/8 outputs
 371          */
 372         u8 line_out_remap_enable;
 373         u8 line_out_remap[SCARLETT2_ANALOGUE_MAX];
 374
 375         /* additional description for the line out volume controls */
 376         const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
 377
 378         /* number of sources/destinations of each port type */
 379         const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS];
 380
 381         /* layout/order of the entries in the set_mux message */
 382         struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES]
 383                                                  [SCARLETT2_MAX_MUX_ENTRIES];
 384 };
 385
 386 struct scarlett2_data {
 387         struct usb_mixer_interface *mixer;
 388         struct mutex usb_mutex; /* prevent sending concurrent USB requests */
 389         struct mutex data_mutex; /* lock access to this data */
 390         struct delayed_work work;
 391         const struct scarlett2_device_info *info;
 392         __u8 bInterfaceNumber;
 393         __u8 bEndpointAddress;
 394         __u16 wMaxPacketSize;
 395         __u8 bInterval;
 396         int num_mux_srcs;
 397         int num_mux_dsts;
 398         u16 scarlett2_seq;
 399         u8 sync_updated;
 400         u8 vol_updated;
 401         u8 input_other_updated;
 402         u8 monitor_other_updated;
 403         u8 mux_updated;
 404         u8 speaker_switching_switched;
 405         u8 sync;
 406         u8 master_vol;
 407         u8 vol[SCARLETT2_ANALOGUE_MAX];
 408         u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
 409         u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
 410         u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
 411         u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
 412         u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
 413         u8 air_switch[SCARLETT2_AIR_SWITCH_MAX];
 414         u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX];
 415         u8 phantom_persistence;
 416         u8 direct_monitor_switch;
 417         u8 speaker_switching_switch;
 418         u8 talkback_switch;
 419         u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX];
 420         u8 msd_switch;
 421         u8 standalone_switch;
 422         struct snd_kcontrol *sync_ctl;
 423         struct snd_kcontrol *master_vol_ctl;
 424         struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
 425         struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX];
 426         struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX];
 427         struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT];
 428         struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX];
 429         struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX];
 430         struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX];
 431         struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX];
 432         struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX];
 433         struct snd_kcontrol *direct_monitor_ctl;
 434         struct snd_kcontrol *speaker_switching_ctl;
 435         struct snd_kcontrol *talkback_ctl;
 436         u8 mux[SCARLETT2_MUX_MAX];
 437         u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
 438 };
 439
 440 /*** Model-specific data ***/
 441
 442 static const struct scarlett2_device_info s6i6_gen2_info = {
 443         .usb_id = USB_ID(0x1235, 0x8203),
 444
 445         .config_set = SCARLETT2_CONFIG_SET_GEN_2,
 446         .level_input_count = 2,
 447         .pad_input_count = 2,
 448
 449         .line_out_descrs = {
 450                 "Headphones 1 L",
 451                 "Headphones 1 R",
 452                 "Headphones 2 L",
 453                 "Headphones 2 R",
 454         },
 455
 456         .port_count = {
 457                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 458                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  4,  4 },
 459                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 460                 [SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
 461                 [SCARLETT2_PORT_TYPE_PCM]      = {  6,  6 },
 462         },
 463
 464         .mux_assignment = { {
 465                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 466                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 467                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 468                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 469                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 470                 { 0,                            0,  0 },
 471         }, {
 472                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 473                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 474                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 475                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 476                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 477                 { 0,                            0,  0 },
 478         }, {
 479                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 480                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 481                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 482                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 483                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 484                 { 0,                            0,  0 },
 485         } },
 486 };
 487
 488 static const struct scarlett2_device_info s18i8_gen2_info = {
 489         .usb_id = USB_ID(0x1235, 0x8204),
 490
 491         .config_set = SCARLETT2_CONFIG_SET_GEN_2,
 492         .level_input_count = 2,
 493         .pad_input_count = 4,
 494
 495         .line_out_descrs = {
 496                 "Monitor L",
 497                 "Monitor R",
 498                 "Headphones 1 L",
 499                 "Headphones 1 R",
 500                 "Headphones 2 L",
 501                 "Headphones 2 R",
 502         },
 503
 504         .port_count = {
 505                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 506                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  8,  6 },
 507                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 508                 [SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
 509                 [SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
 510                 [SCARLETT2_PORT_TYPE_PCM]      = {  8, 18 },
 511         },
 512
 513         .mux_assignment = { {
 514                 { SCARLETT2_PORT_TYPE_PCM,      0, 18 },
 515                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
 516                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 517                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 518                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 519                 { 0,                            0,  0 },
 520         }, {
 521                 { SCARLETT2_PORT_TYPE_PCM,      0, 14 },
 522                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
 523                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 524                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 525                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 526                 { 0,                            0,  0 },
 527         }, {
 528                 { SCARLETT2_PORT_TYPE_PCM,      0, 10 },
 529                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
 530                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 531                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 532                 { SCARLETT2_PORT_TYPE_NONE,     0,  4 },
 533                 { 0,                            0,  0 },
 534         } },
 535 };
 536
 537 static const struct scarlett2_device_info s18i20_gen2_info = {
 538         .usb_id = USB_ID(0x1235, 0x8201),
 539
 540         .config_set = SCARLETT2_CONFIG_SET_GEN_2,
 541         .line_out_hw_vol = 1,
 542
 543         .line_out_descrs = {
 544                 "Monitor L",
 545                 "Monitor R",
 546                 NULL,
 547                 NULL,
 548                 NULL,
 549                 NULL,
 550                 "Headphones 1 L",
 551                 "Headphones 1 R",
 552                 "Headphones 2 L",
 553                 "Headphones 2 R",
 554         },
 555
 556         .port_count = {
 557                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 558                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  8, 10 },
 559                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 560                 [SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
 561                 [SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
 562                 [SCARLETT2_PORT_TYPE_PCM]      = { 20, 18 },
 563         },
 564
 565         .mux_assignment = { {
 566                 { SCARLETT2_PORT_TYPE_PCM,      0, 18 },
 567                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 568                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 569                 { SCARLETT2_PORT_TYPE_ADAT,     0,  8 },
 570                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 571                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 572                 { 0,                            0,  0 },
 573         }, {
 574                 { SCARLETT2_PORT_TYPE_PCM,      0, 14 },
 575                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 576                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 577                 { SCARLETT2_PORT_TYPE_ADAT,     0,  4 },
 578                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 579                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 580                 { 0,                            0,  0 },
 581         }, {
 582                 { SCARLETT2_PORT_TYPE_PCM,      0, 10 },
 583                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 584                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 585                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 586                 { SCARLETT2_PORT_TYPE_NONE,     0,  6 },
 587                 { 0,                            0,  0 },
 588         } },
 589 };
 590
 591 static const struct scarlett2_device_info solo_gen3_info = {
 592         .usb_id = USB_ID(0x1235, 0x8211),
 593
 594         .has_msd_mode = 1,
 595         .config_set = SCARLETT2_CONFIG_SET_NO_MIXER,
 596         .level_input_count = 1,
 597         .level_input_first = 1,
 598         .air_input_count = 1,
 599         .phantom_count = 1,
 600         .inputs_per_phantom = 1,
 601         .direct_monitor = 1,
 602 };
 603
 604 static const struct scarlett2_device_info s2i2_gen3_info = {
 605         .usb_id = USB_ID(0x1235, 0x8210),
 606
 607         .has_msd_mode = 1,
 608         .config_set = SCARLETT2_CONFIG_SET_NO_MIXER,
 609         .level_input_count = 2,
 610         .air_input_count = 2,
 611         .phantom_count = 1,
 612         .inputs_per_phantom = 2,
 613         .direct_monitor = 2,
 614 };
 615
 616 static const struct scarlett2_device_info s4i4_gen3_info = {
 617         .usb_id = USB_ID(0x1235, 0x8212),
 618
 619         .has_msd_mode = 1,
 620         .config_set = SCARLETT2_CONFIG_SET_GEN_3,
 621         .level_input_count = 2,
 622         .pad_input_count = 2,
 623         .air_input_count = 2,
 624         .phantom_count = 1,
 625         .inputs_per_phantom = 2,
 626
 627         .line_out_descrs = {
 628                 "Monitor L",
 629                 "Monitor R",
 630                 "Headphones L",
 631                 "Headphones R",
 632         },
 633
 634         .port_count = {
 635                 [SCARLETT2_PORT_TYPE_NONE]     = { 1, 0 },
 636                 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
 637                 [SCARLETT2_PORT_TYPE_MIX]      = { 6, 8 },
 638                 [SCARLETT2_PORT_TYPE_PCM]      = { 4, 6 },
 639         },
 640
 641         .mux_assignment = { {
 642                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 643                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 644                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 645                 { SCARLETT2_PORT_TYPE_NONE,     0, 16 },
 646                 { 0,                            0,  0 },
 647         }, {
 648                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 649                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 650                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 651                 { SCARLETT2_PORT_TYPE_NONE,     0, 16 },
 652                 { 0,                            0,  0 },
 653         }, {
 654                 { SCARLETT2_PORT_TYPE_PCM,      0,  6 },
 655                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 656                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 657                 { SCARLETT2_PORT_TYPE_NONE,     0, 16 },
 658                 { 0,                            0,  0 },
 659         } },
 660 };
 661
 662 static const struct scarlett2_device_info s8i6_gen3_info = {
 663         .usb_id = USB_ID(0x1235, 0x8213),
 664
 665         .has_msd_mode = 1,
 666         .config_set = SCARLETT2_CONFIG_SET_GEN_3,
 667         .level_input_count = 2,
 668         .pad_input_count = 2,
 669         .air_input_count = 2,
 670         .phantom_count = 1,
 671         .inputs_per_phantom = 2,
 672
 673         .line_out_descrs = {
 674                 "Headphones 1 L",
 675                 "Headphones 1 R",
 676                 "Headphones 2 L",
 677                 "Headphones 2 R",
 678         },
 679
 680         .port_count = {
 681                 [SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
 682                 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6,  4 },
 683                 [SCARLETT2_PORT_TYPE_SPDIF]    = { 2,  2 },
 684                 [SCARLETT2_PORT_TYPE_MIX]      = { 8,  8 },
 685                 [SCARLETT2_PORT_TYPE_PCM]      = { 6, 10 },
 686         },
 687
 688         .mux_assignment = { {
 689                 { SCARLETT2_PORT_TYPE_PCM,      0,  8 },
 690                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 691                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 692                 { SCARLETT2_PORT_TYPE_PCM,      8,  2 },
 693                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 694                 { SCARLETT2_PORT_TYPE_NONE,     0, 18 },
 695                 { 0,                            0,  0 },
 696         }, {
 697                 { SCARLETT2_PORT_TYPE_PCM,      0,  8 },
 698                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 699                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 700                 { SCARLETT2_PORT_TYPE_PCM,      8,  2 },
 701                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 702                 { SCARLETT2_PORT_TYPE_NONE,     0, 18 },
 703                 { 0,                            0,  0 },
 704         }, {
 705                 { SCARLETT2_PORT_TYPE_PCM,      0,  8 },
 706                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
 707                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 708                 { SCARLETT2_PORT_TYPE_PCM,      8,  2 },
 709                 { SCARLETT2_PORT_TYPE_MIX,      0,  8 },
 710                 { SCARLETT2_PORT_TYPE_NONE,     0, 18 },
 711                 { 0,                            0,  0 },
 712         } },
 713 };
 714
 715 static const struct scarlett2_device_info s18i8_gen3_info = {
 716         .usb_id = USB_ID(0x1235, 0x8214),
 717
 718         .has_msd_mode = 1,
 719         .config_set = SCARLETT2_CONFIG_SET_GEN_3,
 720         .line_out_hw_vol = 1,
 721         .has_speaker_switching = 1,
 722         .level_input_count = 2,
 723         .pad_input_count = 4,
 724         .air_input_count = 4,
 725         .phantom_count = 2,
 726         .inputs_per_phantom = 2,
 727
 728         .line_out_remap_enable = 1,
 729         .line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 },
 730
 731         .line_out_descrs = {
 732                 "Monitor L",
 733                 "Monitor R",
 734                 "Alt Monitor L",
 735                 "Alt Monitor R",
 736                 "Headphones 1 L",
 737                 "Headphones 1 R",
 738                 "Headphones 2 L",
 739                 "Headphones 2 R",
 740         },
 741
 742         .port_count = {
 743                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 744                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  8,  8 },
 745                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 746                 [SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
 747                 [SCARLETT2_PORT_TYPE_MIX]      = { 10, 20 },
 748                 [SCARLETT2_PORT_TYPE_PCM]      = {  8, 20 },
 749         },
 750
 751         .mux_assignment = { {
 752                 { SCARLETT2_PORT_TYPE_PCM,       0, 10 },
 753                 { SCARLETT2_PORT_TYPE_PCM,      12,  8 },
 754                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
 755                 { SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
 756                 { SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
 757                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 758                 { SCARLETT2_PORT_TYPE_PCM,      10,  2 },
 759                 { SCARLETT2_PORT_TYPE_MIX,       0, 20 },
 760                 { SCARLETT2_PORT_TYPE_NONE,      0, 10 },
 761                 { 0,                             0,  0 },
 762         }, {
 763                 { SCARLETT2_PORT_TYPE_PCM,       0, 10 },
 764                 { SCARLETT2_PORT_TYPE_PCM,      12,  4 },
 765                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
 766                 { SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
 767                 { SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
 768                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 769                 { SCARLETT2_PORT_TYPE_PCM,      10,  2 },
 770                 { SCARLETT2_PORT_TYPE_MIX,       0, 20 },
 771                 { SCARLETT2_PORT_TYPE_NONE,      0, 10 },
 772                 { 0,                             0,  0 },
 773         }, {
 774                 { SCARLETT2_PORT_TYPE_PCM,       0, 10 },
 775                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
 776                 { SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
 777                 { SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
 778                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 779                 { SCARLETT2_PORT_TYPE_MIX,       0, 20 },
 780                 { SCARLETT2_PORT_TYPE_NONE,      0, 10 },
 781                 { 0,                             0,  0 },
 782         } },
 783 };
 784
 785 static const struct scarlett2_device_info s18i20_gen3_info = {
 786         .usb_id = USB_ID(0x1235, 0x8215),
 787
 788         .has_msd_mode = 1,
 789         .config_set = SCARLETT2_CONFIG_SET_GEN_3,
 790         .line_out_hw_vol = 1,
 791         .has_speaker_switching = 1,
 792         .has_talkback = 1,
 793         .level_input_count = 2,
 794         .pad_input_count = 8,
 795         .air_input_count = 8,
 796         .phantom_count = 2,
 797         .inputs_per_phantom = 4,
 798
 799         .line_out_descrs = {
 800                 "Monitor 1 L",
 801                 "Monitor 1 R",
 802                 "Monitor 2 L",
 803                 "Monitor 2 R",
 804                 NULL,
 805                 NULL,
 806                 "Headphones 1 L",
 807                 "Headphones 1 R",
 808                 "Headphones 2 L",
 809                 "Headphones 2 R",
 810         },
 811
 812         .port_count = {
 813                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 814                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  9, 10 },
 815                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 816                 [SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
 817                 [SCARLETT2_PORT_TYPE_MIX]      = { 12, 25 },
 818                 [SCARLETT2_PORT_TYPE_PCM]      = { 20, 20 },
 819         },
 820
 821         .mux_assignment = { {
 822                 { SCARLETT2_PORT_TYPE_PCM,       0,  8 },
 823                 { SCARLETT2_PORT_TYPE_PCM,      10, 10 },
 824                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
 825                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 826                 { SCARLETT2_PORT_TYPE_ADAT,      0,  8 },
 827                 { SCARLETT2_PORT_TYPE_PCM,       8,  2 },
 828                 { SCARLETT2_PORT_TYPE_MIX,       0, 25 },
 829                 { SCARLETT2_PORT_TYPE_NONE,      0, 12 },
 830                 { 0,                             0,  0 },
 831         }, {
 832                 { SCARLETT2_PORT_TYPE_PCM,       0,  8 },
 833                 { SCARLETT2_PORT_TYPE_PCM,      10,  8 },
 834                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
 835                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 836                 { SCARLETT2_PORT_TYPE_ADAT,      0,  8 },
 837                 { SCARLETT2_PORT_TYPE_PCM,       8,  2 },
 838                 { SCARLETT2_PORT_TYPE_MIX,       0, 25 },
 839                 { SCARLETT2_PORT_TYPE_NONE,      0, 10 },
 840                 { 0,                             0,  0 },
 841         }, {
 842                 { SCARLETT2_PORT_TYPE_PCM,       0, 10 },
 843                 { SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
 844                 { SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
 845                 { SCARLETT2_PORT_TYPE_NONE,      0, 24 },
 846                 { 0,                             0,  0 },
 847         } },
 848 };
 849
 850 static const struct scarlett2_device_info clarett_8pre_info = {
 851         .usb_id = USB_ID(0x1235, 0x820c),
 852
 853         .config_set = SCARLETT2_CONFIG_SET_CLARETT,
 854         .line_out_hw_vol = 1,
 855         .level_input_count = 2,
 856         .air_input_count = 8,
 857
 858         .line_out_descrs = {
 859                 "Monitor L",
 860                 "Monitor R",
 861                 NULL,
 862                 NULL,
 863                 NULL,
 864                 NULL,
 865                 "Headphones 1 L",
 866                 "Headphones 1 R",
 867                 "Headphones 2 L",
 868                 "Headphones 2 R",
 869         },
 870
 871         .port_count = {
 872                 [SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
 873                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {  8, 10 },
 874                 [SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
 875                 [SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
 876                 [SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
 877                 [SCARLETT2_PORT_TYPE_PCM]      = { 20, 18 },
 878         },
 879
 880         .mux_assignment = { {
 881                 { SCARLETT2_PORT_TYPE_PCM,      0, 18 },
 882                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 883                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 884                 { SCARLETT2_PORT_TYPE_ADAT,     0,  8 },
 885                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 886                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 887                 { 0,                            0,  0 },
 888         }, {
 889                 { SCARLETT2_PORT_TYPE_PCM,      0, 14 },
 890                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 891                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 892                 { SCARLETT2_PORT_TYPE_ADAT,     0,  4 },
 893                 { SCARLETT2_PORT_TYPE_MIX,      0, 18 },
 894                 { SCARLETT2_PORT_TYPE_NONE,     0,  8 },
 895                 { 0,                            0,  0 },
 896         }, {
 897                 { SCARLETT2_PORT_TYPE_PCM,      0, 12 },
 898                 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
 899                 { SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
 900                 { SCARLETT2_PORT_TYPE_NONE,     0, 22 },
 901                 { 0,                            0,  0 },
 902         } },
 903 };
 904
 905 static const struct scarlett2_device_info *scarlett2_devices[] = {
 906         /* Supported Gen 2 devices */
 907         &s6i6_gen2_info,
 908         &s18i8_gen2_info,
 909         &s18i20_gen2_info,
 910
 911         /* Supported Gen 3 devices */
 912         &solo_gen3_info,
 913         &s2i2_gen3_info,
 914         &s4i4_gen3_info,
 915         &s8i6_gen3_info,
 916         &s18i8_gen3_info,
 917         &s18i20_gen3_info,
 918
 919         /* Supported Clarett+ devices */
 920         &clarett_8pre_info,
 921
 922         /* End of list */
 923         NULL
 924 };
 925
 926 /* get the starting port index number for a given port type/direction */
 927 static int scarlett2_get_port_start_num(
 928         const int port_count[][SCARLETT2_PORT_DIRNS],
 929         int direction, int port_type)
 930 {
 931         int i, num = 0;
 932
 933         for (i = 0; i < port_type; i++)
 934                 num += port_count[i][direction];
 935
 936         return num;
 937 }
 938
 939 /*** USB Interactions ***/
 940
 941 /* Notifications from the interface */
 942 #define SCARLETT2_USB_NOTIFY_SYNC          0x00000008
 943 #define SCARLETT2_USB_NOTIFY_DIM_MUTE      0x00200000
 944 #define SCARLETT2_USB_NOTIFY_MONITOR       0x00400000
 945 #define SCARLETT2_USB_NOTIFY_INPUT_OTHER   0x00800000
 946 #define SCARLETT2_USB_NOTIFY_MONITOR_OTHER 0x01000000
 947
 948 /* Commands for sending/receiving requests/responses */
 949 #define SCARLETT2_USB_CMD_INIT 0
 950 #define SCARLETT2_USB_CMD_REQ  2
 951 #define SCARLETT2_USB_CMD_RESP 3
 952
 953 #define SCARLETT2_USB_INIT_1    0x00000000
 954 #define SCARLETT2_USB_INIT_2    0x00000002
 955 #define SCARLETT2_USB_GET_METER 0x00001001
 956 #define SCARLETT2_USB_GET_MIX   0x00002001
 957 #define SCARLETT2_USB_SET_MIX   0x00002002
 958 #define SCARLETT2_USB_GET_MUX   0x00003001
 959 #define SCARLETT2_USB_SET_MUX   0x00003002
 960 #define SCARLETT2_USB_GET_SYNC  0x00006004
 961 #define SCARLETT2_USB_GET_DATA  0x00800000
 962 #define SCARLETT2_USB_SET_DATA  0x00800001
 963 #define SCARLETT2_USB_DATA_CMD  0x00800002
 964
 965 #define SCARLETT2_USB_CONFIG_SAVE 6
 966
 967 #define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
 968 #define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
 969
 970 /* volume status is read together (matches scarlett2_config_items[1]) */
 971 struct scarlett2_usb_volume_status {
 972         /* dim/mute buttons */
 973         u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
 974
 975         u8 pad1;
 976
 977         /* software volume setting */
 978         s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
 979
 980         /* actual volume of output inc. dim (-18dB) */
 981         s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
 982
 983         /* internal mute buttons */
 984         u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
 985
 986         /* sw (0) or hw (1) controlled */
 987         u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
 988
 989         u8 pad3[6];
 990
 991         /* front panel volume knob */
 992         s16 master_vol;
 993 } __packed;
 994
 995 /* Configuration parameters that can be read and written */
 996 enum {
 997         SCARLETT2_CONFIG_DIM_MUTE = 0,
 998         SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
 999         SCARLETT2_CONFIG_MUTE_SWITCH = 2,
1000         SCARLETT2_CONFIG_SW_HW_SWITCH = 3,
1001         SCARLETT2_CONFIG_LEVEL_SWITCH = 4,
1002         SCARLETT2_CONFIG_PAD_SWITCH = 5,
1003         SCARLETT2_CONFIG_MSD_SWITCH = 6,
1004         SCARLETT2_CONFIG_AIR_SWITCH = 7,
1005         SCARLETT2_CONFIG_STANDALONE_SWITCH = 8,
1006         SCARLETT2_CONFIG_PHANTOM_SWITCH = 9,
1007         SCARLETT2_CONFIG_PHANTOM_PERSISTENCE = 10,
1008         SCARLETT2_CONFIG_DIRECT_MONITOR = 11,
1009         SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH = 12,
1010         SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE = 13,
1011         SCARLETT2_CONFIG_TALKBACK_MAP = 14,
1012         SCARLETT2_CONFIG_COUNT = 15
1013 };
1014
1015 /* Location, size, and activation command number for the configuration
1016  * parameters. Size is in bits and may be 1, 8, or 16.
1017  */
1018 struct scarlett2_config {
1019         u8 offset;
1020         u8 size;
1021         u8 activate;
1022 };
1023
1024 static const struct scarlett2_config
1025         scarlett2_config_items[SCARLETT2_CONFIG_SET_COUNT]
1026                               [SCARLETT2_CONFIG_COUNT] =
1027
1028 /* Devices without a mixer (Gen 3 Solo and 2i2) */
1029 { {
1030         [SCARLETT2_CONFIG_MSD_SWITCH] = {
1031                 .offset = 0x04, .size = 8, .activate = 6 },
1032
1033         [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
1034                 .offset = 0x05, .size = 8, .activate = 6 },
1035
1036         [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
1037                 .offset = 0x06, .size = 8, .activate = 3 },
1038
1039         [SCARLETT2_CONFIG_DIRECT_MONITOR] = {
1040                 .offset = 0x07, .size = 8, .activate = 4 },
1041
1042         [SCARLETT2_CONFIG_LEVEL_SWITCH] = {
1043                 .offset = 0x08, .size = 1, .activate = 7 },
1044
1045         [SCARLETT2_CONFIG_AIR_SWITCH] = {
1046                 .offset = 0x09, .size = 1, .activate = 8 },
1047
1048 /* Gen 2 devices: 6i6, 18i8, 18i20 */
1049 }, {
1050         [SCARLETT2_CONFIG_DIM_MUTE] = {
1051                 .offset = 0x31, .size = 8, .activate = 2 },
1052
1053         [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
1054                 .offset = 0x34, .size = 16, .activate = 1 },
1055
1056         [SCARLETT2_CONFIG_MUTE_SWITCH] = {
1057                 .offset = 0x5c, .size = 8, .activate = 1 },
1058
1059         [SCARLETT2_CONFIG_SW_HW_SWITCH] = {
1060                 .offset = 0x66, .size = 8, .activate = 3 },
1061
1062         [SCARLETT2_CONFIG_LEVEL_SWITCH] = {
1063                 .offset = 0x7c, .size = 8, .activate = 7 },
1064
1065         [SCARLETT2_CONFIG_PAD_SWITCH] = {
1066                 .offset = 0x84, .size = 8, .activate = 8 },
1067
1068         [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
1069                 .offset = 0x8d, .size = 8, .activate = 6 },
1070
1071 /* Gen 3 devices: 4i4, 8i6, 18i8, 18i20 */
1072 }, {
1073         [SCARLETT2_CONFIG_DIM_MUTE] = {
1074                 .offset = 0x31, .size = 8, .activate = 2 },
1075
1076         [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
1077                 .offset = 0x34, .size = 16, .activate = 1 },
1078
1079         [SCARLETT2_CONFIG_MUTE_SWITCH] = {
1080                 .offset = 0x5c, .size = 8, .activate = 1 },
1081
1082         [SCARLETT2_CONFIG_SW_HW_SWITCH] = {
1083                 .offset = 0x66, .size = 8, .activate = 3 },
1084
1085         [SCARLETT2_CONFIG_LEVEL_SWITCH] = {
1086                 .offset = 0x7c, .size = 8, .activate = 7 },
1087
1088         [SCARLETT2_CONFIG_PAD_SWITCH] = {
1089                 .offset = 0x84, .size = 8, .activate = 8 },
1090
1091         [SCARLETT2_CONFIG_AIR_SWITCH] = {
1092                 .offset = 0x8c, .size = 8, .activate = 8 },
1093
1094         [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
1095                 .offset = 0x95, .size = 8, .activate = 6 },
1096
1097         [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
1098                 .offset = 0x9c, .size = 1, .activate = 8 },
1099
1100         [SCARLETT2_CONFIG_MSD_SWITCH] = {
1101                 .offset = 0x9d, .size = 8, .activate = 6 },
1102
1103         [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
1104                 .offset = 0x9e, .size = 8, .activate = 6 },
1105
1106         [SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = {
1107                 .offset = 0x9f, .size = 1, .activate = 10 },
1108
1109         [SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = {
1110                 .offset = 0xa0, .size = 1, .activate = 10 },
1111
1112         [SCARLETT2_CONFIG_TALKBACK_MAP] = {
1113                 .offset = 0xb0, .size = 16, .activate = 10 },
1114
1115 /* Clarett+ 8Pre */
1116 }, {
1117         [SCARLETT2_CONFIG_DIM_MUTE] = {
1118                 .offset = 0x31, .size = 8, .activate = 2 },
1119
1120         [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
1121                 .offset = 0x34, .size = 16, .activate = 1 },
1122
1123         [SCARLETT2_CONFIG_MUTE_SWITCH] = {
1124                 .offset = 0x5c, .size = 8, .activate = 1 },
1125
1126         [SCARLETT2_CONFIG_SW_HW_SWITCH] = {
1127                 .offset = 0x66, .size = 8, .activate = 3 },
1128
1129         [SCARLETT2_CONFIG_LEVEL_SWITCH] = {
1130                 .offset = 0x7c, .size = 8, .activate = 7 },
1131
1132         [SCARLETT2_CONFIG_AIR_SWITCH] = {
1133                 .offset = 0x95, .size = 8, .activate = 8 },
1134
1135         [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
1136                 .offset = 0x8d, .size = 8, .activate = 6 },
1137 } };
1138
1139 /* proprietary request/response format */
1140 struct scarlett2_usb_packet {
1141         __le32 cmd;
1142         __le16 size;
1143         __le16 seq;
1144         __le32 error;
1145         __le32 pad;
1146         u8 data[];
1147 };
1148
1149 static void scarlett2_fill_request_header(struct scarlett2_data *private,
1150                                           struct scarlett2_usb_packet *req,
1151                                           u32 cmd, u16 req_size)
1152 {
1153         /* sequence must go up by 1 for each request */
1154         u16 seq = private->scarlett2_seq++;
1155
1156         req->cmd = cpu_to_le32(cmd);
1157         req->size = cpu_to_le16(req_size);
1158         req->seq = cpu_to_le16(seq);
1159         req->error = 0;
1160         req->pad = 0;
1161 }
1162
1163 static int scarlett2_usb_tx(struct usb_device *dev, int interface,
1164                             void *buf, u16 size)
1165 {
1166         return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1167                         SCARLETT2_USB_CMD_REQ,
1168                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1169                         0, interface, buf, size);
1170 }
1171
1172 static int scarlett2_usb_rx(struct usb_device *dev, int interface,
1173                             u32 usb_req, void *buf, u16 size)
1174 {
1175         return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1176                         usb_req,
1177                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1178                         0, interface, buf, size);
1179 }
1180
1181 /* Send a proprietary format request to the Scarlett interface */
1182 static int scarlett2_usb(
1183         struct usb_mixer_interface *mixer, u32 cmd,
1184         void *req_data, u16 req_size, void *resp_data, u16 resp_size)
1185 {
1186         struct scarlett2_data *private = mixer->private_data;
1187         struct usb_device *dev = mixer->chip->dev;
1188         struct scarlett2_usb_packet *req, *resp = NULL;
1189         size_t req_buf_size = struct_size(req, data, req_size);
1190         size_t resp_buf_size = struct_size(resp, data, resp_size);
1191         int err;
1192
1193         req = kmalloc(req_buf_size, GFP_KERNEL);
1194         if (!req) {
1195                 err = -ENOMEM;
1196                 goto error;
1197         }
1198
1199         resp = kmalloc(resp_buf_size, GFP_KERNEL);
1200         if (!resp) {
1201                 err = -ENOMEM;
1202                 goto error;
1203         }
1204
1205         mutex_lock(&private->usb_mutex);
1206
1207         /* build request message and send it */
1208
1209         scarlett2_fill_request_header(private, req, cmd, req_size);
1210
1211         if (req_size)
1212                 memcpy(req->data, req_data, req_size);
1213
1214         err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
1215                                req, req_buf_size);
1216
1217         if (err != req_buf_size) {
1218                 usb_audio_err(
1219                         mixer->chip,
1220                         "Scarlett Gen 2/3 USB request result cmd %x was %d\n",
1221                         cmd, err);
1222                 err = -EINVAL;
1223                 goto unlock;
1224         }
1225
1226         /* send a second message to get the response */
1227
1228         err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
1229                                SCARLETT2_USB_CMD_RESP,
1230                                resp, resp_buf_size);
1231
1232         /* validate the response */
1233
1234         if (err != resp_buf_size) {
1235                 usb_audio_err(
1236                         mixer->chip,
1237                         "Scarlett Gen 2/3 USB response result cmd %x was %d "
1238                         "expected %zu\n",
1239                         cmd, err, resp_buf_size);
1240                 err = -EINVAL;
1241                 goto unlock;
1242         }
1243
1244         /* cmd/seq/size should match except when initialising
1245          * seq sent = 1, response = 0
1246          */
1247         if (resp->cmd != req->cmd ||
1248             (resp->seq != req->seq &&
1249                 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
1250             resp_size != le16_to_cpu(resp->size) ||
1251             resp->error ||
1252             resp->pad) {
1253                 usb_audio_err(
1254                         mixer->chip,
1255                         "Scarlett Gen 2/3 USB invalid response; "
1256                            "cmd tx/rx %d/%d seq %d/%d size %d/%d "
1257                            "error %d pad %d\n",
1258                         le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
1259                         le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
1260                         resp_size, le16_to_cpu(resp->size),
1261                         le32_to_cpu(resp->error),
1262                         le32_to_cpu(resp->pad));
1263                 err = -EINVAL;
1264                 goto unlock;
1265         }
1266
1267         if (resp_data && resp_size > 0)
1268                 memcpy(resp_data, resp->data, resp_size);
1269
1270 unlock:
1271         mutex_unlock(&private->usb_mutex);
1272 error:
1273         kfree(req);
1274         kfree(resp);
1275         return err;
1276 }
1277
1278 /* Send a USB message to get data; result placed in *buf */
1279 static int scarlett2_usb_get(
1280         struct usb_mixer_interface *mixer,
1281         int offset, void *buf, int size)
1282 {
1283         struct {
1284                 __le32 offset;
1285                 __le32 size;
1286         } __packed req;
1287
1288         req.offset = cpu_to_le32(offset);
1289         req.size = cpu_to_le32(size);
1290         return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
1291                              &req, sizeof(req), buf, size);
1292 }
1293
1294 /* Send a USB message to get configuration parameters; result placed in *buf */
1295 static int scarlett2_usb_get_config(
1296         struct usb_mixer_interface *mixer,
1297         int config_item_num, int count, void *buf)
1298 {
1299         struct scarlett2_data *private = mixer->private_data;
1300         const struct scarlett2_device_info *info = private->info;
1301         const struct scarlett2_config *config_item =
1302                 &scarlett2_config_items[info->config_set][config_item_num];
1303         int size, err, i;
1304         u8 *buf_8;
1305         u8 value;
1306
1307         /* For byte-sized parameters, retrieve directly into buf */
1308         if (config_item->size >= 8) {
1309                 size = config_item->size / 8 * count;
1310                 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
1311                 if (err < 0)
1312                         return err;
1313                 if (size == 2) {
1314                         u16 *buf_16 = buf;
1315
1316                         for (i = 0; i < count; i++, buf_16++)
1317                                 *buf_16 = le16_to_cpu(*(__le16 *)buf_16);
1318                 }
1319                 return 0;
1320         }
1321
1322         /* For bit-sized parameters, retrieve into value */
1323         err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
1324         if (err < 0)
1325                 return err;
1326
1327         /* then unpack from value into buf[] */
1328         buf_8 = buf;
1329         for (i = 0; i < 8 && i < count; i++, value >>= 1)
1330                 *buf_8++ = value & 1;
1331
1332         return 0;
1333 }
1334
1335 /* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
1336 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
1337 {
1338         __le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
1339
1340         int err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
1341                                 &req, sizeof(u32),
1342                                 NULL, 0);
1343         if (err < 0)
1344                 usb_audio_err(mixer->chip, "config save failed: %d\n", err);
1345 }
1346
1347 /* Delayed work to save config */
1348 static void scarlett2_config_save_work(struct work_struct *work)
1349 {
1350         struct scarlett2_data *private =
1351                 container_of(work, struct scarlett2_data, work.work);
1352
1353         scarlett2_config_save(private->mixer);
1354 }
1355
1356 /* Send a USB message to set a SCARLETT2_CONFIG_* parameter */
1357 static int scarlett2_usb_set_config(
1358         struct usb_mixer_interface *mixer,
1359         int config_item_num, int index, int value)
1360 {
1361         struct scarlett2_data *private = mixer->private_data;
1362         const struct scarlett2_device_info *info = private->info;
1363         const struct scarlett2_config *config_item =
1364                &scarlett2_config_items[info->config_set][config_item_num];
1365         struct {
1366                 __le32 offset;
1367                 __le32 bytes;
1368                 __le32 value;
1369         } __packed req;
1370         __le32 req2;
1371         int offset, size;
1372         int err;
1373
1374         /* Cancel any pending NVRAM save */
1375         cancel_delayed_work_sync(&private->work);
1376
1377         /* Convert config_item->size in bits to size in bytes and
1378          * calculate offset
1379          */
1380         if (config_item->size >= 8) {
1381                 size = config_item->size / 8;
1382                 offset = config_item->offset + index * size;
1383
1384         /* If updating a bit, retrieve the old value, set/clear the
1385          * bit as needed, and update value
1386          */
1387         } else {
1388                 u8 tmp;
1389
1390                 size = 1;
1391                 offset = config_item->offset;
1392
1393                 err = scarlett2_usb_get(mixer, offset, &tmp, 1);
1394                 if (err < 0)
1395                         return err;
1396
1397                 if (value)
1398                         tmp |= (1 << index);
1399                 else
1400                         tmp &= ~(1 << index);
1401
1402                 value = tmp;
1403         }
1404
1405         /* Send the configuration parameter data */
1406         req.offset = cpu_to_le32(offset);
1407         req.bytes = cpu_to_le32(size);
1408         req.value = cpu_to_le32(value);
1409         err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
1410                             &req, sizeof(u32) * 2 + size,
1411                             NULL, 0);
1412         if (err < 0)
1413                 return err;
1414
1415         /* Activate the change */
1416         req2 = cpu_to_le32(config_item->activate);
1417         err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
1418                             &req2, sizeof(req2), NULL, 0);
1419         if (err < 0)
1420                 return err;
1421
1422         /* Schedule the change to be written to NVRAM */
1423         if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
1424                 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
1425
1426         return 0;
1427 }
1428
1429 /* Send a USB message to get sync status; result placed in *sync */
1430 static int scarlett2_usb_get_sync_status(
1431         struct usb_mixer_interface *mixer,
1432         u8 *sync)
1433 {
1434         __le32 data;
1435         int err;
1436
1437         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
1438                             NULL, 0, &data, sizeof(data));
1439         if (err < 0)
1440                 return err;
1441
1442         *sync = !!data;
1443         return 0;
1444 }
1445
1446 /* Send a USB message to get volume status; result placed in *buf */
1447 static int scarlett2_usb_get_volume_status(
1448         struct usb_mixer_interface *mixer,
1449         struct scarlett2_usb_volume_status *buf)
1450 {
1451         return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
1452                                  buf, sizeof(*buf));
1453 }
1454
1455 /* Send a USB message to get the volumes for all inputs of one mix
1456  * and put the values into private->mix[]
1457  */
1458 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
1459                                  int mix_num)
1460 {
1461         struct scarlett2_data *private = mixer->private_data;
1462         const struct scarlett2_device_info *info = private->info;
1463
1464         int num_mixer_in =
1465                 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
1466         int err, i, j, k;
1467
1468         struct {
1469                 __le16 mix_num;
1470                 __le16 count;
1471         } __packed req;
1472
1473         __le16 data[SCARLETT2_INPUT_MIX_MAX];
1474
1475         req.mix_num = cpu_to_le16(mix_num);
1476         req.count = cpu_to_le16(num_mixer_in);
1477
1478         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
1479                             &req, sizeof(req),
1480                             data, num_mixer_in * sizeof(u16));
1481         if (err < 0)
1482                 return err;
1483
1484         for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) {
1485                 u16 mixer_value = le16_to_cpu(data[i]);
1486
1487                 for (k = 0; k < SCARLETT2_MIXER_VALUE_COUNT; k++)
1488                         if (scarlett2_mixer_values[k] >= mixer_value)
1489                                 break;
1490                 if (k == SCARLETT2_MIXER_VALUE_COUNT)
1491                         k = SCARLETT2_MIXER_MAX_VALUE;
1492                 private->mix[j] = k;
1493         }
1494
1495         return 0;
1496 }
1497
1498 /* Send a USB message to set the volumes for all inputs of one mix
1499  * (values obtained from private->mix[])
1500  */
1501 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
1502                                  int mix_num)
1503 {
1504         struct scarlett2_data *private = mixer->private_data;
1505         const struct scarlett2_device_info *info = private->info;
1506
1507         struct {
1508                 __le16 mix_num;
1509                 __le16 data[SCARLETT2_INPUT_MIX_MAX];
1510         } __packed req;
1511
1512         int i, j;
1513         int num_mixer_in =
1514                 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
1515
1516         req.mix_num = cpu_to_le16(mix_num);
1517
1518         for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
1519                 req.data[i] = cpu_to_le16(
1520                         scarlett2_mixer_values[private->mix[j]]
1521                 );
1522
1523         return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
1524                              &req, (num_mixer_in + 1) * sizeof(u16),
1525                              NULL, 0);
1526 }
1527
1528 /* Convert a port number index (per info->port_count) to a hardware ID */
1529 static u32 scarlett2_mux_src_num_to_id(
1530         const int port_count[][SCARLETT2_PORT_DIRNS], int num)
1531 {
1532         int port_type;
1533
1534         for (port_type = 0;
1535              port_type < SCARLETT2_PORT_TYPE_COUNT;
1536              port_type++) {
1537                 if (num < port_count[port_type][SCARLETT2_PORT_IN])
1538                         return scarlett2_ports[port_type].id | num;
1539                 num -= port_count[port_type][SCARLETT2_PORT_IN];
1540         }
1541
1542         /* Oops */
1543         return 0;
1544 }
1545
1546 /* Convert a hardware ID to a port number index */
1547 static u32 scarlett2_mux_id_to_num(
1548         const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)
1549 {
1550         int port_type;
1551         int port_num = 0;
1552
1553         for (port_type = 0;
1554              port_type < SCARLETT2_PORT_TYPE_COUNT;
1555              port_type++) {
1556                 int base = scarlett2_ports[port_type].id;
1557                 int count = port_count[port_type][direction];
1558
1559                 if (id >= base && id < base + count)
1560                         return port_num + id - base;
1561                 port_num += count;
1562         }
1563
1564         /* Oops */
1565         return -1;
1566 }
1567
1568 /* Convert one mux entry from the interface and load into private->mux[] */
1569 static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
1570                                        u32 mux_entry)
1571 {
1572         const struct scarlett2_device_info *info = private->info;
1573         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1574
1575         int dst_idx, src_idx;
1576
1577         dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT,
1578                                           mux_entry & 0xFFF);
1579         if (dst_idx < 0)
1580                 return;
1581
1582         if (dst_idx >= private->num_mux_dsts) {
1583                 usb_audio_err(private->mixer->chip,
1584                         "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",
1585                         mux_entry, dst_idx, private->num_mux_dsts);
1586                 return;
1587         }
1588
1589         src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN,
1590                                           mux_entry >> 12);
1591         if (src_idx < 0)
1592                 return;
1593
1594         if (src_idx >= private->num_mux_srcs) {
1595                 usb_audio_err(private->mixer->chip,
1596                         "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",
1597                         mux_entry, src_idx, private->num_mux_srcs);
1598                 return;
1599         }
1600
1601         private->mux[dst_idx] = src_idx;
1602 }
1603
1604 /* Send USB message to get mux inputs and then populate private->mux[] */
1605 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
1606 {
1607         struct scarlett2_data *private = mixer->private_data;
1608         int count = private->num_mux_dsts;
1609         int err, i;
1610
1611         struct {
1612                 __le16 num;
1613                 __le16 count;
1614         } __packed req;
1615
1616         __le32 data[SCARLETT2_MUX_MAX];
1617
1618         private->mux_updated = 0;
1619
1620         req.num = 0;
1621         req.count = cpu_to_le16(count);
1622
1623         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
1624                             &req, sizeof(req),
1625                             data, count * sizeof(u32));
1626         if (err < 0)
1627                 return err;
1628
1629         for (i = 0; i < count; i++)
1630                 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
1631
1632         return 0;
1633 }
1634
1635 /* Send USB messages to set mux inputs */
1636 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
1637 {
1638         struct scarlett2_data *private = mixer->private_data;
1639         const struct scarlett2_device_info *info = private->info;
1640         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1641         int table;
1642
1643         struct {
1644                 __le16 pad;
1645                 __le16 num;
1646                 __le32 data[SCARLETT2_MUX_MAX];
1647         } __packed req;
1648
1649         req.pad = 0;
1650
1651         /* set mux settings for each rate */
1652         for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {
1653                 const struct scarlett2_mux_entry *entry;
1654
1655                 /* i counts over the output array */
1656                 int i = 0, err;
1657
1658                 req.num = cpu_to_le16(table);
1659
1660                 /* loop through each entry */
1661                 for (entry = info->mux_assignment[table];
1662                      entry->count;
1663                      entry++) {
1664                         int j;
1665                         int port_type = entry->port_type;
1666                         int port_idx = entry->start;
1667                         int mux_idx = scarlett2_get_port_start_num(port_count,
1668                                 SCARLETT2_PORT_OUT, port_type) + port_idx;
1669                         int dst_id = scarlett2_ports[port_type].id + port_idx;
1670
1671                         /* Empty slots */
1672                         if (!dst_id) {
1673                                 for (j = 0; j < entry->count; j++)
1674                                         req.data[i++] = 0;
1675                                 continue;
1676                         }
1677
1678                         /* Non-empty mux slots use the lower 12 bits
1679                          * for the destination and next 12 bits for
1680                          * the source
1681                          */
1682                         for (j = 0; j < entry->count; j++) {
1683                                 int src_id = scarlett2_mux_src_num_to_id(
1684                                         port_count, private->mux[mux_idx++]);
1685                                 req.data[i++] = cpu_to_le32(dst_id |
1686                                                             src_id << 12);
1687                                 dst_id++;
1688                         }
1689                 }
1690
1691                 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
1692                                     &req, (i + 1) * sizeof(u32),
1693                                     NULL, 0);
1694                 if (err < 0)
1695                         return err;
1696         }
1697
1698         return 0;
1699 }
1700
1701 /* Send USB message to get meter levels */
1702 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
1703                                           u16 num_meters, u16 *levels)
1704 {
1705         struct {
1706                 __le16 pad;
1707                 __le16 num_meters;
1708                 __le32 magic;
1709         } __packed req;
1710         u32 resp[SCARLETT2_MAX_METERS];
1711         int i, err;
1712
1713         req.pad = 0;
1714         req.num_meters = cpu_to_le16(num_meters);
1715         req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
1716         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
1717                             &req, sizeof(req), resp, num_meters * sizeof(u32));
1718         if (err < 0)
1719                 return err;
1720
1721         /* copy, convert to u16 */
1722         for (i = 0; i < num_meters; i++)
1723                 levels[i] = resp[i];
1724
1725         return 0;
1726 }
1727
1728 /*** Control Functions ***/
1729
1730 /* helper function to create a new control */
1731 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
1732                                  const struct snd_kcontrol_new *ncontrol,
1733                                  int index, int channels, const char *name,
1734                                  struct snd_kcontrol **kctl_return)
1735 {
1736         struct snd_kcontrol *kctl;
1737         struct usb_mixer_elem_info *elem;
1738         int err;
1739
1740         elem = kzalloc(sizeof(*elem), GFP_KERNEL);
1741         if (!elem)
1742                 return -ENOMEM;
1743
1744         /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
1745          * ignores them for resume and other operations.
1746          * Also, the head.id field is set to 0, as we don't use this field.
1747          */
1748         elem->head.mixer = mixer;
1749         elem->control = index;
1750         elem->head.id = 0;
1751         elem->channels = channels;
1752         elem->val_type = USB_MIXER_BESPOKEN;
1753
1754         kctl = snd_ctl_new1(ncontrol, elem);
1755         if (!kctl) {
1756                 kfree(elem);
1757                 return -ENOMEM;
1758         }
1759         kctl->private_free = snd_usb_mixer_elem_free;
1760
1761         strscpy(kctl->id.name, name, sizeof(kctl->id.name));
1762
1763         err = snd_usb_mixer_add_control(&elem->head, kctl);
1764         if (err < 0)
1765                 return err;
1766
1767         if (kctl_return)
1768                 *kctl_return = kctl;
1769
1770         return 0;
1771 }
1772
1773 /*** Sync Control ***/
1774
1775 /* Update sync control after receiving notification that the status
1776  * has changed
1777  */
1778 static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
1779 {
1780         struct scarlett2_data *private = mixer->private_data;
1781
1782         private->sync_updated = 0;
1783         return scarlett2_usb_get_sync_status(mixer, &private->sync);
1784 }
1785
1786 static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,
1787                                    struct snd_ctl_elem_info *uinfo)
1788 {
1789         static const char *texts[2] = {
1790                 "Unlocked", "Locked"
1791         };
1792         return snd_ctl_enum_info(uinfo, 1, 2, texts);
1793 }
1794
1795 static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,
1796                                   struct snd_ctl_elem_value *ucontrol)
1797 {
1798         struct usb_mixer_elem_info *elem = kctl->private_data;
1799         struct usb_mixer_interface *mixer = elem->head.mixer;
1800         struct scarlett2_data *private = mixer->private_data;
1801         int err = 0;
1802
1803         mutex_lock(&private->data_mutex);
1804
1805         if (private->sync_updated) {
1806                 err = scarlett2_update_sync(mixer);
1807                 if (err < 0)
1808                         goto unlock;
1809         }
1810         ucontrol->value.enumerated.item[0] = private->sync;
1811
1812 unlock:
1813         mutex_unlock(&private->data_mutex);
1814         return err;
1815 }
1816
1817 static const struct snd_kcontrol_new scarlett2_sync_ctl = {
1818         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1819         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1820         .name = "",
1821         .info = scarlett2_sync_ctl_info,
1822         .get  = scarlett2_sync_ctl_get
1823 };
1824
1825 static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
1826 {
1827         struct scarlett2_data *private = mixer->private_data;
1828
1829         /* devices without a mixer also don't support reporting sync status */
1830         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
1831                 return 0;
1832
1833         return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
1834                                      0, 1, "Sync Status", &private->sync_ctl);
1835 }
1836
1837 /*** Analogue Line Out Volume Controls ***/
1838
1839 /* Update hardware volume controls after receiving notification that
1840  * they have changed
1841  */
1842 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
1843 {
1844         struct scarlett2_data *private = mixer->private_data;
1845         const struct scarlett2_device_info *info = private->info;
1846         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1847         struct scarlett2_usb_volume_status volume_status;
1848         int num_line_out =
1849                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
1850         int err, i;
1851         int mute;
1852
1853         private->vol_updated = 0;
1854
1855         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
1856         if (err < 0)
1857                 return err;
1858
1859         private->master_vol = clamp(
1860                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1861                 0, SCARLETT2_VOLUME_BIAS);
1862
1863         if (info->line_out_hw_vol)
1864                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
1865                         private->dim_mute[i] = !!volume_status.dim_mute[i];
1866
1867         mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
1868
1869         for (i = 0; i < num_line_out; i++)
1870                 if (private->vol_sw_hw_switch[i]) {
1871                         private->vol[i] = private->master_vol;
1872                         private->mute_switch[i] = mute;
1873                 }
1874
1875         return 0;
1876 }
1877
1878 static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
1879                                      struct snd_ctl_elem_info *uinfo)
1880 {
1881         struct usb_mixer_elem_info *elem = kctl->private_data;
1882
1883         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1884         uinfo->count = elem->channels;
1885         uinfo->value.integer.min = 0;
1886         uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
1887         uinfo->value.integer.step = 1;
1888         return 0;
1889 }
1890
1891 static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
1892                                            struct snd_ctl_elem_value *ucontrol)
1893 {
1894         struct usb_mixer_elem_info *elem = kctl->private_data;
1895         struct usb_mixer_interface *mixer = elem->head.mixer;
1896         struct scarlett2_data *private = mixer->private_data;
1897         int err = 0;
1898
1899         mutex_lock(&private->data_mutex);
1900
1901         if (private->vol_updated) {
1902                 err = scarlett2_update_volumes(mixer);
1903                 if (err < 0)
1904                         goto unlock;
1905         }
1906         ucontrol->value.integer.value[0] = private->master_vol;
1907
1908 unlock:
1909         mutex_unlock(&private->data_mutex);
1910         return err;
1911 }
1912
1913 static int line_out_remap(struct scarlett2_data *private, int index)
1914 {
1915         const struct scarlett2_device_info *info = private->info;
1916         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1917         int line_out_count =
1918                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
1919
1920         if (!info->line_out_remap_enable)
1921                 return index;
1922
1923         if (index >= line_out_count)
1924                 return index;
1925
1926         return info->line_out_remap[index];
1927 }
1928
1929 static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
1930                                     struct snd_ctl_elem_value *ucontrol)
1931 {
1932         struct usb_mixer_elem_info *elem = kctl->private_data;
1933         struct usb_mixer_interface *mixer = elem->head.mixer;
1934         struct scarlett2_data *private = mixer->private_data;
1935         int index = line_out_remap(private, elem->control);
1936         int err = 0;
1937
1938         mutex_lock(&private->data_mutex);
1939
1940         if (private->vol_updated) {
1941                 err = scarlett2_update_volumes(mixer);
1942                 if (err < 0)
1943                         goto unlock;
1944         }
1945         ucontrol->value.integer.value[0] = private->vol[index];
1946
1947 unlock:
1948         mutex_unlock(&private->data_mutex);
1949         return err;
1950 }
1951
1952 static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
1953                                     struct snd_ctl_elem_value *ucontrol)
1954 {
1955         struct usb_mixer_elem_info *elem = kctl->private_data;
1956         struct usb_mixer_interface *mixer = elem->head.mixer;
1957         struct scarlett2_data *private = mixer->private_data;
1958         int index = line_out_remap(private, elem->control);
1959         int oval, val, err = 0;
1960
1961         mutex_lock(&private->data_mutex);
1962
1963         oval = private->vol[index];
1964         val = ucontrol->value.integer.value[0];
1965
1966         if (oval == val)
1967                 goto unlock;
1968
1969         private->vol[index] = val;
1970         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1971                                        index, val - SCARLETT2_VOLUME_BIAS);
1972         if (err == 0)
1973                 err = 1;
1974
1975 unlock:
1976         mutex_unlock(&private->data_mutex);
1977         return err;
1978 }
1979
1980 static const DECLARE_TLV_DB_MINMAX(
1981         db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
1982 );
1983
1984 static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
1985         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1986         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1987                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1988         .name = "",
1989         .info = scarlett2_volume_ctl_info,
1990         .get  = scarlett2_master_volume_ctl_get,
1991         .private_value = 0, /* max value */
1992         .tlv = { .p = db_scale_scarlett2_gain }
1993 };
1994
1995 static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
1996         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1997         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1998                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1999         .name = "",
2000         .info = scarlett2_volume_ctl_info,
2001         .get  = scarlett2_volume_ctl_get,
2002         .put  = scarlett2_volume_ctl_put,
2003         .private_value = 0, /* max value */
2004         .tlv = { .p = db_scale_scarlett2_gain }
2005 };
2006
2007 /*** Mute Switch Controls ***/
2008
2009 static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,
2010                                         struct snd_ctl_elem_value *ucontrol)
2011 {
2012         struct usb_mixer_elem_info *elem = kctl->private_data;
2013         struct usb_mixer_interface *mixer = elem->head.mixer;
2014         struct scarlett2_data *private = mixer->private_data;
2015         int index = line_out_remap(private, elem->control);
2016         int err = 0;
2017
2018         mutex_lock(&private->data_mutex);
2019
2020         if (private->vol_updated) {
2021                 err = scarlett2_update_volumes(mixer);
2022                 if (err < 0)
2023                         goto unlock;
2024         }
2025         ucontrol->value.integer.value[0] = private->mute_switch[index];
2026
2027 unlock:
2028         mutex_unlock(&private->data_mutex);
2029         return err;
2030 }
2031
2032 static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
2033                                         struct snd_ctl_elem_value *ucontrol)
2034 {
2035         struct usb_mixer_elem_info *elem = kctl->private_data;
2036         struct usb_mixer_interface *mixer = elem->head.mixer;
2037         struct scarlett2_data *private = mixer->private_data;
2038         int index = line_out_remap(private, elem->control);
2039         int oval, val, err = 0;
2040
2041         mutex_lock(&private->data_mutex);
2042
2043         oval = private->mute_switch[index];
2044         val = !!ucontrol->value.integer.value[0];
2045
2046         if (oval == val)
2047                 goto unlock;
2048
2049         private->mute_switch[index] = val;
2050
2051         /* Send mute change to the device */
2052         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
2053                                        index, val);
2054         if (err == 0)
2055                 err = 1;
2056
2057 unlock:
2058         mutex_unlock(&private->data_mutex);
2059         return err;
2060 }
2061
2062 static const struct snd_kcontrol_new scarlett2_mute_ctl = {
2063         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2064         .name = "",
2065         .info = snd_ctl_boolean_mono_info,
2066         .get  = scarlett2_mute_ctl_get,
2067         .put  = scarlett2_mute_ctl_put,
2068 };
2069
2070 /*** HW/SW Volume Switch Controls ***/
2071
2072 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
2073 {
2074         private->sw_hw_ctls[index]->vd[0].access &=
2075                 ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2076 }
2077
2078 static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
2079 {
2080         private->sw_hw_ctls[index]->vd[0].access |=
2081                 SNDRV_CTL_ELEM_ACCESS_WRITE;
2082 }
2083
2084 static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
2085                                          struct snd_ctl_elem_info *uinfo)
2086 {
2087         static const char *const values[2] = {
2088                 "SW", "HW"
2089         };
2090
2091         return snd_ctl_enum_info(uinfo, 1, 2, values);
2092 }
2093
2094 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
2095                                         struct snd_ctl_elem_value *ucontrol)
2096 {
2097         struct usb_mixer_elem_info *elem = kctl->private_data;
2098         struct scarlett2_data *private = elem->head.mixer->private_data;
2099         int index = line_out_remap(private, elem->control);
2100
2101         ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
2102         return 0;
2103 }
2104
2105 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
2106                                            int index, int value)
2107 {
2108         struct scarlett2_data *private = mixer->private_data;
2109         struct snd_card *card = mixer->chip->card;
2110
2111         /* Set/Clear write bits */
2112         if (value) {
2113                 private->vol_ctls[index]->vd[0].access |=
2114                         SNDRV_CTL_ELEM_ACCESS_WRITE;
2115                 private->mute_ctls[index]->vd[0].access |=
2116                         SNDRV_CTL_ELEM_ACCESS_WRITE;
2117         } else {
2118                 private->vol_ctls[index]->vd[0].access &=
2119                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2120                 private->mute_ctls[index]->vd[0].access &=
2121                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2122         }
2123
2124         /* Notify of write bit and possible value change */
2125         snd_ctl_notify(card,
2126                        SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
2127                        &private->vol_ctls[index]->id);
2128         snd_ctl_notify(card,
2129                        SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
2130                        &private->mute_ctls[index]->id);
2131 }
2132
2133 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
2134                                   int ctl_index, int val)
2135 {
2136         struct scarlett2_data *private = mixer->private_data;
2137         int index = line_out_remap(private, ctl_index);
2138         int err;
2139
2140         private->vol_sw_hw_switch[index] = val;
2141
2142         /* Change access mode to RO (hardware controlled volume)
2143          * or RW (software controlled volume)
2144          */
2145         scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
2146
2147         /* Reset volume/mute to master volume/mute */
2148         private->vol[index] = private->master_vol;
2149         private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
2150
2151         /* Set SW volume to current HW volume */
2152         err = scarlett2_usb_set_config(
2153                 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
2154                 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
2155         if (err < 0)
2156                 return err;
2157
2158         /* Set SW mute to current HW mute */
2159         err = scarlett2_usb_set_config(
2160                 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
2161                 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
2162         if (err < 0)
2163                 return err;
2164
2165         /* Send SW/HW switch change to the device */
2166         return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
2167                                         index, val);
2168 }
2169
2170 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
2171                                         struct snd_ctl_elem_value *ucontrol)
2172 {
2173         struct usb_mixer_elem_info *elem = kctl->private_data;
2174         struct usb_mixer_interface *mixer = elem->head.mixer;
2175         struct scarlett2_data *private = mixer->private_data;
2176         int ctl_index = elem->control;
2177         int index = line_out_remap(private, ctl_index);
2178         int oval, val, err = 0;
2179
2180         mutex_lock(&private->data_mutex);
2181
2182         oval = private->vol_sw_hw_switch[index];
2183         val = !!ucontrol->value.enumerated.item[0];
2184
2185         if (oval == val)
2186                 goto unlock;
2187
2188         err = scarlett2_sw_hw_change(mixer, ctl_index, val);
2189         if (err == 0)
2190                 err = 1;
2191
2192 unlock:
2193         mutex_unlock(&private->data_mutex);
2194         return err;
2195 }
2196
2197 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
2198         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2199         .name = "",
2200         .info = scarlett2_sw_hw_enum_ctl_info,
2201         .get  = scarlett2_sw_hw_enum_ctl_get,
2202         .put  = scarlett2_sw_hw_enum_ctl_put,
2203 };
2204
2205 /*** Line Level/Instrument Level Switch Controls ***/
2206
2207 static int scarlett2_update_input_other(struct usb_mixer_interface *mixer)
2208 {
2209         struct scarlett2_data *private = mixer->private_data;
2210         const struct scarlett2_device_info *info = private->info;
2211
2212         private->input_other_updated = 0;
2213
2214         if (info->level_input_count) {
2215                 int err = scarlett2_usb_get_config(
2216                         mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2217                         info->level_input_count + info->level_input_first,
2218                         private->level_switch);
2219                 if (err < 0)
2220                         return err;
2221         }
2222
2223         if (info->pad_input_count) {
2224                 int err = scarlett2_usb_get_config(
2225                         mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2226                         info->pad_input_count, private->pad_switch);
2227                 if (err < 0)
2228                         return err;
2229         }
2230
2231         if (info->air_input_count) {
2232                 int err = scarlett2_usb_get_config(
2233                         mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2234                         info->air_input_count, private->air_switch);
2235                 if (err < 0)
2236                         return err;
2237         }
2238
2239         if (info->phantom_count) {
2240                 int err = scarlett2_usb_get_config(
2241                         mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2242                         info->phantom_count, private->phantom_switch);
2243                 if (err < 0)
2244                         return err;
2245
2246                 err = scarlett2_usb_get_config(
2247                         mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
2248                         1, &private->phantom_persistence);
2249                 if (err < 0)
2250                         return err;
2251         }
2252
2253         return 0;
2254 }
2255
2256 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
2257                                          struct snd_ctl_elem_info *uinfo)
2258 {
2259         static const char *const values[2] = {
2260                 "Line", "Inst"
2261         };
2262
2263         return snd_ctl_enum_info(uinfo, 1, 2, values);
2264 }
2265
2266 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
2267                                         struct snd_ctl_elem_value *ucontrol)
2268 {
2269         struct usb_mixer_elem_info *elem = kctl->private_data;
2270         struct usb_mixer_interface *mixer = elem->head.mixer;
2271         struct scarlett2_data *private = mixer->private_data;
2272         const struct scarlett2_device_info *info = private->info;
2273
2274         int index = elem->control + info->level_input_first;
2275         int err = 0;
2276
2277         mutex_lock(&private->data_mutex);
2278
2279         if (private->input_other_updated) {
2280                 err = scarlett2_update_input_other(mixer);
2281                 if (err < 0)
2282                         goto unlock;
2283         }
2284         ucontrol->value.enumerated.item[0] = private->level_switch[index];
2285
2286 unlock:
2287         mutex_unlock(&private->data_mutex);
2288         return err;
2289 }
2290
2291 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
2292                                         struct snd_ctl_elem_value *ucontrol)
2293 {
2294         struct usb_mixer_elem_info *elem = kctl->private_data;
2295         struct usb_mixer_interface *mixer = elem->head.mixer;
2296         struct scarlett2_data *private = mixer->private_data;
2297         const struct scarlett2_device_info *info = private->info;
2298
2299         int index = elem->control + info->level_input_first;
2300         int oval, val, err = 0;
2301
2302         mutex_lock(&private->data_mutex);
2303
2304         oval = private->level_switch[index];
2305         val = !!ucontrol->value.enumerated.item[0];
2306
2307         if (oval == val)
2308                 goto unlock;
2309
2310         private->level_switch[index] = val;
2311
2312         /* Send switch change to the device */
2313         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2314                                        index, val);
2315         if (err == 0)
2316                 err = 1;
2317
2318 unlock:
2319         mutex_unlock(&private->data_mutex);
2320         return err;
2321 }
2322
2323 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
2324         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2325         .name = "",
2326         .info = scarlett2_level_enum_ctl_info,
2327         .get  = scarlett2_level_enum_ctl_get,
2328         .put  = scarlett2_level_enum_ctl_put,
2329 };
2330
2331 /*** Pad Switch Controls ***/
2332
2333 static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
2334                                  struct snd_ctl_elem_value *ucontrol)
2335 {
2336         struct usb_mixer_elem_info *elem = kctl->private_data;
2337         struct usb_mixer_interface *mixer = elem->head.mixer;
2338         struct scarlett2_data *private = mixer->private_data;
2339         int err = 0;
2340
2341         mutex_lock(&private->data_mutex);
2342
2343         if (private->input_other_updated) {
2344                 err = scarlett2_update_input_other(mixer);
2345                 if (err < 0)
2346                         goto unlock;
2347         }
2348         ucontrol->value.integer.value[0] =
2349                 private->pad_switch[elem->control];
2350
2351 unlock:
2352         mutex_unlock(&private->data_mutex);
2353         return err;
2354 }
2355
2356 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
2357                                  struct snd_ctl_elem_value *ucontrol)
2358 {
2359         struct usb_mixer_elem_info *elem = kctl->private_data;
2360         struct usb_mixer_interface *mixer = elem->head.mixer;
2361         struct scarlett2_data *private = mixer->private_data;
2362
2363         int index = elem->control;
2364         int oval, val, err = 0;
2365
2366         mutex_lock(&private->data_mutex);
2367
2368         oval = private->pad_switch[index];
2369         val = !!ucontrol->value.integer.value[0];
2370
2371         if (oval == val)
2372                 goto unlock;
2373
2374         private->pad_switch[index] = val;
2375
2376         /* Send switch change to the device */
2377         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2378                                        index, val);
2379         if (err == 0)
2380                 err = 1;
2381
2382 unlock:
2383         mutex_unlock(&private->data_mutex);
2384         return err;
2385 }
2386
2387 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
2388         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2389         .name = "",
2390         .info = snd_ctl_boolean_mono_info,
2391         .get  = scarlett2_pad_ctl_get,
2392         .put  = scarlett2_pad_ctl_put,
2393 };
2394
2395 /*** Air Switch Controls ***/
2396
2397 static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
2398                                  struct snd_ctl_elem_value *ucontrol)
2399 {
2400         struct usb_mixer_elem_info *elem = kctl->private_data;
2401         struct usb_mixer_interface *mixer = elem->head.mixer;
2402         struct scarlett2_data *private = mixer->private_data;
2403         int err = 0;
2404
2405         mutex_lock(&private->data_mutex);
2406
2407         if (private->input_other_updated) {
2408                 err = scarlett2_update_input_other(mixer);
2409                 if (err < 0)
2410                         goto unlock;
2411         }
2412         ucontrol->value.integer.value[0] = private->air_switch[elem->control];
2413
2414 unlock:
2415         mutex_unlock(&private->data_mutex);
2416         return err;
2417 }
2418
2419 static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
2420                                  struct snd_ctl_elem_value *ucontrol)
2421 {
2422         struct usb_mixer_elem_info *elem = kctl->private_data;
2423         struct usb_mixer_interface *mixer = elem->head.mixer;
2424         struct scarlett2_data *private = mixer->private_data;
2425
2426         int index = elem->control;
2427         int oval, val, err = 0;
2428
2429         mutex_lock(&private->data_mutex);
2430
2431         oval = private->air_switch[index];
2432         val = !!ucontrol->value.integer.value[0];
2433
2434         if (oval == val)
2435                 goto unlock;
2436
2437         private->air_switch[index] = val;
2438
2439         /* Send switch change to the device */
2440         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2441                                        index, val);
2442         if (err == 0)
2443                 err = 1;
2444
2445 unlock:
2446         mutex_unlock(&private->data_mutex);
2447         return err;
2448 }
2449
2450 static const struct snd_kcontrol_new scarlett2_air_ctl = {
2451         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2452         .name = "",
2453         .info = snd_ctl_boolean_mono_info,
2454         .get  = scarlett2_air_ctl_get,
2455         .put  = scarlett2_air_ctl_put,
2456 };
2457
2458 /*** Phantom Switch Controls ***/
2459
2460 static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
2461                                      struct snd_ctl_elem_value *ucontrol)
2462 {
2463         struct usb_mixer_elem_info *elem = kctl->private_data;
2464         struct usb_mixer_interface *mixer = elem->head.mixer;
2465         struct scarlett2_data *private = mixer->private_data;
2466         int err = 0;
2467
2468         mutex_lock(&private->data_mutex);
2469
2470         if (private->input_other_updated) {
2471                 err = scarlett2_update_input_other(mixer);
2472                 if (err < 0)
2473                         goto unlock;
2474         }
2475         ucontrol->value.integer.value[0] =
2476                 private->phantom_switch[elem->control];
2477
2478 unlock:
2479         mutex_unlock(&private->data_mutex);
2480         return err;
2481 }
2482
2483 static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
2484                                      struct snd_ctl_elem_value *ucontrol)
2485 {
2486         struct usb_mixer_elem_info *elem = kctl->private_data;
2487         struct usb_mixer_interface *mixer = elem->head.mixer;
2488         struct scarlett2_data *private = mixer->private_data;
2489
2490         int index = elem->control;
2491         int oval, val, err = 0;
2492
2493         mutex_lock(&private->data_mutex);
2494
2495         oval = private->phantom_switch[index];
2496         val = !!ucontrol->value.integer.value[0];
2497
2498         if (oval == val)
2499                 goto unlock;
2500
2501         private->phantom_switch[index] = val;
2502
2503         /* Send switch change to the device */
2504         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2505                                        index, val);
2506         if (err == 0)
2507                 err = 1;
2508
2509 unlock:
2510         mutex_unlock(&private->data_mutex);
2511         return err;
2512 }
2513
2514 static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
2515         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2516         .name = "",
2517         .info = snd_ctl_boolean_mono_info,
2518         .get  = scarlett2_phantom_ctl_get,
2519         .put  = scarlett2_phantom_ctl_put,
2520 };
2521
2522 /*** Phantom Persistence Control ***/
2523
2524 static int scarlett2_phantom_persistence_ctl_get(
2525         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2526 {
2527         struct usb_mixer_elem_info *elem = kctl->private_data;
2528         struct scarlett2_data *private = elem->head.mixer->private_data;
2529
2530         ucontrol->value.integer.value[0] = private->phantom_persistence;
2531         return 0;
2532 }
2533
2534 static int scarlett2_phantom_persistence_ctl_put(
2535         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2536 {
2537         struct usb_mixer_elem_info *elem = kctl->private_data;
2538         struct usb_mixer_interface *mixer = elem->head.mixer;
2539         struct scarlett2_data *private = mixer->private_data;
2540
2541         int index = elem->control;
2542         int oval, val, err = 0;
2543
2544         mutex_lock(&private->data_mutex);
2545
2546         oval = private->phantom_persistence;
2547         val = !!ucontrol->value.integer.value[0];
2548
2549         if (oval == val)
2550                 goto unlock;
2551
2552         private->phantom_persistence = val;
2553
2554         /* Send switch change to the device */
2555         err = scarlett2_usb_set_config(
2556                 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
2557         if (err == 0)
2558                 err = 1;
2559
2560 unlock:
2561         mutex_unlock(&private->data_mutex);
2562         return err;
2563 }
2564
2565 static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
2566         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2567         .name = "",
2568         .info = snd_ctl_boolean_mono_info,
2569         .get  = scarlett2_phantom_persistence_ctl_get,
2570         .put  = scarlett2_phantom_persistence_ctl_put,
2571 };
2572
2573 /*** Direct Monitor Control ***/
2574
2575 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
2576 {
2577         struct scarlett2_data *private = mixer->private_data;
2578         const struct scarlett2_device_info *info = private->info;
2579         int err;
2580
2581         /* monitor_other_enable[0] enables speaker switching
2582          * monitor_other_enable[1] enables talkback
2583          */
2584         u8 monitor_other_enable[2];
2585
2586         /* monitor_other_switch[0] activates the alternate speakers
2587          * monitor_other_switch[1] activates talkback
2588          */
2589         u8 monitor_other_switch[2];
2590
2591         private->monitor_other_updated = 0;
2592
2593         if (info->direct_monitor)
2594                 return scarlett2_usb_get_config(
2595                         mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
2596                         1, &private->direct_monitor_switch);
2597
2598         /* if it doesn't do speaker switching then it also doesn't do
2599          * talkback
2600          */
2601         if (!info->has_speaker_switching)
2602                 return 0;
2603
2604         err = scarlett2_usb_get_config(
2605                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2606                 2, monitor_other_enable);
2607         if (err < 0)
2608                 return err;
2609
2610         err = scarlett2_usb_get_config(
2611                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2612                 2, monitor_other_switch);
2613         if (err < 0)
2614                 return err;
2615
2616         if (!monitor_other_enable[0])
2617                 private->speaker_switching_switch = 0;
2618         else
2619                 private->speaker_switching_switch = monitor_other_switch[0] + 1;
2620
2621         if (info->has_talkback) {
2622                 const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2623                         info->port_count;
2624                 int num_mixes =
2625                         port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2626                 u16 bitmap;
2627                 int i;
2628
2629                 if (!monitor_other_enable[1])
2630                         private->talkback_switch = 0;
2631                 else
2632                         private->talkback_switch = monitor_other_switch[1] + 1;
2633
2634                 err = scarlett2_usb_get_config(mixer,
2635                                                SCARLETT2_CONFIG_TALKBACK_MAP,
2636                                                1, &bitmap);
2637                 if (err < 0)
2638                         return err;
2639                 for (i = 0; i < num_mixes; i++, bitmap >>= 1)
2640                         private->talkback_map[i] = bitmap & 1;
2641         }
2642
2643         return 0;
2644 }
2645
2646 static int scarlett2_direct_monitor_ctl_get(
2647         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2648 {
2649         struct usb_mixer_elem_info *elem = kctl->private_data;
2650         struct usb_mixer_interface *mixer = elem->head.mixer;
2651         struct scarlett2_data *private = elem->head.mixer->private_data;
2652         int err = 0;
2653
2654         mutex_lock(&private->data_mutex);
2655
2656         if (private->monitor_other_updated) {
2657                 err = scarlett2_update_monitor_other(mixer);
2658                 if (err < 0)
2659                         goto unlock;
2660         }
2661         ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
2662
2663 unlock:
2664         mutex_unlock(&private->data_mutex);
2665         return err;
2666 }
2667
2668 static int scarlett2_direct_monitor_ctl_put(
2669         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2670 {
2671         struct usb_mixer_elem_info *elem = kctl->private_data;
2672         struct usb_mixer_interface *mixer = elem->head.mixer;
2673         struct scarlett2_data *private = mixer->private_data;
2674
2675         int index = elem->control;
2676         int oval, val, err = 0;
2677
2678         mutex_lock(&private->data_mutex);
2679
2680         oval = private->direct_monitor_switch;
2681         val = min(ucontrol->value.enumerated.item[0], 2U);
2682
2683         if (oval == val)
2684                 goto unlock;
2685
2686         private->direct_monitor_switch = val;
2687
2688         /* Send switch change to the device */
2689         err = scarlett2_usb_set_config(
2690                 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
2691         if (err == 0)
2692                 err = 1;
2693
2694 unlock:
2695         mutex_unlock(&private->data_mutex);
2696         return err;
2697 }
2698
2699 static int scarlett2_direct_monitor_stereo_enum_ctl_info(
2700         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2701 {
2702         static const char *const values[3] = {
2703                 "Off", "Mono", "Stereo"
2704         };
2705
2706         return snd_ctl_enum_info(uinfo, 1, 3, values);
2707 }
2708
2709 /* Direct Monitor for Solo is mono-only and only needs a boolean control
2710  * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
2711  */
2712 static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
2713         {
2714                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2715                 .name = "",
2716                 .info = snd_ctl_boolean_mono_info,
2717                 .get  = scarlett2_direct_monitor_ctl_get,
2718                 .put  = scarlett2_direct_monitor_ctl_put,
2719         },
2720         {
2721                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2722                 .name = "",
2723                 .info = scarlett2_direct_monitor_stereo_enum_ctl_info,
2724                 .get  = scarlett2_direct_monitor_ctl_get,
2725                 .put  = scarlett2_direct_monitor_ctl_put,
2726         }
2727 };
2728
2729 static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer)
2730 {
2731         struct scarlett2_data *private = mixer->private_data;
2732         const struct scarlett2_device_info *info = private->info;
2733         const char *s;
2734
2735         if (!info->direct_monitor)
2736                 return 0;
2737
2738         s = info->direct_monitor == 1
2739               ? "Direct Monitor Playback Switch"
2740               : "Direct Monitor Playback Enum";
2741
2742         return scarlett2_add_new_ctl(
2743                 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
2744                 0, 1, s, &private->direct_monitor_ctl);
2745 }
2746
2747 /*** Speaker Switching Control ***/
2748
2749 static int scarlett2_speaker_switch_enum_ctl_info(
2750         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2751 {
2752         static const char *const values[3] = {
2753                 "Off", "Main", "Alt"
2754         };
2755
2756         return snd_ctl_enum_info(uinfo, 1, 3, values);
2757 }
2758
2759 static int scarlett2_speaker_switch_enum_ctl_get(
2760         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2761 {
2762         struct usb_mixer_elem_info *elem = kctl->private_data;
2763         struct usb_mixer_interface *mixer = elem->head.mixer;
2764         struct scarlett2_data *private = mixer->private_data;
2765         int err = 0;
2766
2767         mutex_lock(&private->data_mutex);
2768
2769         if (private->monitor_other_updated) {
2770                 err = scarlett2_update_monitor_other(mixer);
2771                 if (err < 0)
2772                         goto unlock;
2773         }
2774         ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
2775
2776 unlock:
2777         mutex_unlock(&private->data_mutex);
2778         return err;
2779 }
2780
2781 /* when speaker switching gets enabled, switch the main/alt speakers
2782  * to HW volume and disable those controls
2783  */
2784 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
2785 {
2786         struct snd_card *card = mixer->chip->card;
2787         struct scarlett2_data *private = mixer->private_data;
2788         int i, err;
2789
2790         for (i = 0; i < 4; i++) {
2791                 int index = line_out_remap(private, i);
2792
2793                 /* switch the main/alt speakers to HW volume */
2794                 if (!private->vol_sw_hw_switch[index]) {
2795                         err = scarlett2_sw_hw_change(private->mixer, i, 1);
2796                         if (err < 0)
2797                                 return err;
2798                 }
2799
2800                 /* disable the line out SW/HW switch */
2801                 scarlett2_sw_hw_ctl_ro(private, i);
2802                 snd_ctl_notify(card,
2803                                SNDRV_CTL_EVENT_MASK_VALUE |
2804                                  SNDRV_CTL_EVENT_MASK_INFO,
2805                                &private->sw_hw_ctls[i]->id);
2806         }
2807
2808         /* when the next monitor-other notify comes in, update the mux
2809          * configuration
2810          */
2811         private->speaker_switching_switched = 1;
2812
2813         return 0;
2814 }
2815
2816 /* when speaker switching gets disabled, reenable the hw/sw controls
2817  * and invalidate the routing
2818  */
2819 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
2820 {
2821         struct snd_card *card = mixer->chip->card;
2822         struct scarlett2_data *private = mixer->private_data;
2823         int i;
2824
2825         /* enable the line out SW/HW switch */
2826         for (i = 0; i < 4; i++) {
2827                 scarlett2_sw_hw_ctl_rw(private, i);
2828                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2829                                &private->sw_hw_ctls[i]->id);
2830         }
2831
2832         /* when the next monitor-other notify comes in, update the mux
2833          * configuration
2834          */
2835         private->speaker_switching_switched = 1;
2836 }
2837
2838 static int scarlett2_speaker_switch_enum_ctl_put(
2839         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2840 {
2841         struct usb_mixer_elem_info *elem = kctl->private_data;
2842         struct usb_mixer_interface *mixer = elem->head.mixer;
2843         struct scarlett2_data *private = mixer->private_data;
2844
2845         int oval, val, err = 0;
2846
2847         mutex_lock(&private->data_mutex);
2848
2849         oval = private->speaker_switching_switch;
2850         val = min(ucontrol->value.enumerated.item[0], 2U);
2851
2852         if (oval == val)
2853                 goto unlock;
2854
2855         private->speaker_switching_switch = val;
2856
2857         /* enable/disable speaker switching */
2858         err = scarlett2_usb_set_config(
2859                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2860                 0, !!val);
2861         if (err < 0)
2862                 goto unlock;
2863
2864         /* if speaker switching is enabled, select main or alt */
2865         err = scarlett2_usb_set_config(
2866                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2867                 0, val == 2);
2868         if (err < 0)
2869                 goto unlock;
2870
2871         /* update controls if speaker switching gets enabled or disabled */
2872         if (!oval && val)
2873                 err = scarlett2_speaker_switch_enable(mixer);
2874         else if (oval && !val)
2875                 scarlett2_speaker_switch_disable(mixer);
2876
2877         if (err == 0)
2878                 err = 1;
2879
2880 unlock:
2881         mutex_unlock(&private->data_mutex);
2882         return err;
2883 }
2884
2885 static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
2886         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2887         .name = "",
2888         .info = scarlett2_speaker_switch_enum_ctl_info,
2889         .get  = scarlett2_speaker_switch_enum_ctl_get,
2890         .put  = scarlett2_speaker_switch_enum_ctl_put,
2891 };
2892
2893 static int scarlett2_add_speaker_switch_ctl(
2894         struct usb_mixer_interface *mixer)
2895 {
2896         struct scarlett2_data *private = mixer->private_data;
2897         const struct scarlett2_device_info *info = private->info;
2898
2899         if (!info->has_speaker_switching)
2900                 return 0;
2901
2902         return scarlett2_add_new_ctl(
2903                 mixer, &scarlett2_speaker_switch_enum_ctl,
2904                 0, 1, "Speaker Switching Playback Enum",
2905                 &private->speaker_switching_ctl);
2906 }
2907
2908 /*** Talkback and Talkback Map Controls ***/
2909
2910 static int scarlett2_talkback_enum_ctl_info(
2911         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2912 {
2913         static const char *const values[3] = {
2914                 "Disabled", "Off", "On"
2915         };
2916
2917         return snd_ctl_enum_info(uinfo, 1, 3, values);
2918 }
2919
2920 static int scarlett2_talkback_enum_ctl_get(
2921         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2922 {
2923         struct usb_mixer_elem_info *elem = kctl->private_data;
2924         struct usb_mixer_interface *mixer = elem->head.mixer;
2925         struct scarlett2_data *private = mixer->private_data;
2926         int err = 0;
2927
2928         mutex_lock(&private->data_mutex);
2929
2930         if (private->monitor_other_updated) {
2931                 err = scarlett2_update_monitor_other(mixer);
2932                 if (err < 0)
2933                         goto unlock;
2934         }
2935         ucontrol->value.enumerated.item[0] = private->talkback_switch;
2936
2937 unlock:
2938         mutex_unlock(&private->data_mutex);
2939         return err;
2940 }
2941
2942 static int scarlett2_talkback_enum_ctl_put(
2943         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2944 {
2945         struct usb_mixer_elem_info *elem = kctl->private_data;
2946         struct usb_mixer_interface *mixer = elem->head.mixer;
2947         struct scarlett2_data *private = mixer->private_data;
2948
2949         int oval, val, err = 0;
2950
2951         mutex_lock(&private->data_mutex);
2952
2953         oval = private->talkback_switch;
2954         val = min(ucontrol->value.enumerated.item[0], 2U);
2955
2956         if (oval == val)
2957                 goto unlock;
2958
2959         private->talkback_switch = val;
2960
2961         /* enable/disable talkback */
2962         err = scarlett2_usb_set_config(
2963                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2964                 1, !!val);
2965         if (err < 0)
2966                 goto unlock;
2967
2968         /* if talkback is enabled, select main or alt */
2969         err = scarlett2_usb_set_config(
2970                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2971                 1, val == 2);
2972         if (err == 0)
2973                 err = 1;
2974
2975 unlock:
2976         mutex_unlock(&private->data_mutex);
2977         return err;
2978 }
2979
2980 static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
2981         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2982         .name = "",
2983         .info = scarlett2_talkback_enum_ctl_info,
2984         .get  = scarlett2_talkback_enum_ctl_get,
2985         .put  = scarlett2_talkback_enum_ctl_put,
2986 };
2987
2988 static int scarlett2_talkback_map_ctl_get(
2989         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2990 {
2991         struct usb_mixer_elem_info *elem = kctl->private_data;
2992         struct usb_mixer_interface *mixer = elem->head.mixer;
2993         struct scarlett2_data *private = mixer->private_data;
2994         int index = elem->control;
2995
2996         ucontrol->value.integer.value[0] = private->talkback_map[index];
2997
2998         return 0;
2999 }
3000
3001 static int scarlett2_talkback_map_ctl_put(
3002         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3003 {
3004         struct usb_mixer_elem_info *elem = kctl->private_data;
3005         struct usb_mixer_interface *mixer = elem->head.mixer;
3006         struct scarlett2_data *private = mixer->private_data;
3007         const int (*port_count)[SCARLETT2_PORT_DIRNS] =
3008                 private->info->port_count;
3009         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3010
3011         int index = elem->control;
3012         int oval, val, err = 0, i;
3013         u16 bitmap = 0;
3014
3015         mutex_lock(&private->data_mutex);
3016
3017         oval = private->talkback_map[index];
3018         val = !!ucontrol->value.integer.value[0];
3019
3020         if (oval == val)
3021                 goto unlock;
3022
3023         private->talkback_map[index] = val;
3024
3025         for (i = 0; i < num_mixes; i++)
3026                 bitmap |= private->talkback_map[i] << i;
3027
3028         /* Send updated bitmap to the device */
3029         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
3030                                        0, bitmap);
3031         if (err == 0)
3032                 err = 1;
3033
3034 unlock:
3035         mutex_unlock(&private->data_mutex);
3036         return err;
3037 }
3038
3039 static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
3040         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3041         .name = "",
3042         .info = snd_ctl_boolean_mono_info,
3043         .get  = scarlett2_talkback_map_ctl_get,
3044         .put  = scarlett2_talkback_map_ctl_put,
3045 };
3046
3047 static int scarlett2_add_talkback_ctls(
3048         struct usb_mixer_interface *mixer)
3049 {
3050         struct scarlett2_data *private = mixer->private_data;
3051         const struct scarlett2_device_info *info = private->info;
3052         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3053         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3054         int err, i;
3055         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3056
3057         if (!info->has_talkback)
3058                 return 0;
3059
3060         err = scarlett2_add_new_ctl(
3061                 mixer, &scarlett2_talkback_enum_ctl,
3062                 0, 1, "Talkback Playback Enum",
3063                 &private->talkback_ctl);
3064         if (err < 0)
3065                 return err;
3066
3067         for (i = 0; i < num_mixes; i++) {
3068                 snprintf(s, sizeof(s),
3069                          "Talkback Mix %c Playback Switch", i + 'A');
3070                 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
3071                                             i, 1, s, NULL);
3072                 if (err < 0)
3073                         return err;
3074         }
3075
3076         return 0;
3077 }
3078
3079 /*** Dim/Mute Controls ***/
3080
3081 static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
3082                                       struct snd_ctl_elem_value *ucontrol)
3083 {
3084         struct usb_mixer_elem_info *elem = kctl->private_data;
3085         struct usb_mixer_interface *mixer = elem->head.mixer;
3086         struct scarlett2_data *private = mixer->private_data;
3087         int err = 0;
3088
3089         mutex_lock(&private->data_mutex);
3090
3091         if (private->vol_updated) {
3092                 err = scarlett2_update_volumes(mixer);
3093                 if (err < 0)
3094                         goto unlock;
3095         }
3096         ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
3097
3098 unlock:
3099         mutex_unlock(&private->data_mutex);
3100         return err;
3101 }
3102
3103 static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
3104                                       struct snd_ctl_elem_value *ucontrol)
3105 {
3106         struct usb_mixer_elem_info *elem = kctl->private_data;
3107         struct usb_mixer_interface *mixer = elem->head.mixer;
3108         struct scarlett2_data *private = mixer->private_data;
3109         const struct scarlett2_device_info *info = private->info;
3110         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3111         int num_line_out =
3112                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3113
3114         int index = elem->control;
3115         int oval, val, err = 0, i;
3116
3117         mutex_lock(&private->data_mutex);
3118
3119         oval = private->dim_mute[index];
3120         val = !!ucontrol->value.integer.value[0];
3121
3122         if (oval == val)
3123                 goto unlock;
3124
3125         private->dim_mute[index] = val;
3126
3127         /* Send switch change to the device */
3128         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
3129                                        index, val);
3130         if (err == 0)
3131                 err = 1;
3132
3133         if (index == SCARLETT2_BUTTON_MUTE)
3134                 for (i = 0; i < num_line_out; i++) {
3135                         int line_index = line_out_remap(private, i);
3136
3137                         if (private->vol_sw_hw_switch[line_index]) {
3138                                 private->mute_switch[line_index] = val;
3139                                 snd_ctl_notify(mixer->chip->card,
3140                                                SNDRV_CTL_EVENT_MASK_VALUE,
3141                                                &private->mute_ctls[i]->id);
3142                         }
3143                 }
3144
3145 unlock:
3146         mutex_unlock(&private->data_mutex);
3147         return err;
3148 }
3149
3150 static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
3151         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3152         .name = "",
3153         .info = snd_ctl_boolean_mono_info,
3154         .get  = scarlett2_dim_mute_ctl_get,
3155         .put  = scarlett2_dim_mute_ctl_put
3156 };
3157
3158 /*** Create the analogue output controls ***/
3159
3160 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
3161 {
3162         struct scarlett2_data *private = mixer->private_data;
3163         const struct scarlett2_device_info *info = private->info;
3164         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3165         int num_line_out =
3166                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3167         int err, i;
3168         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3169
3170         /* Add R/O HW volume control */
3171         if (info->line_out_hw_vol) {
3172                 snprintf(s, sizeof(s), "Master HW Playback Volume");
3173                 err = scarlett2_add_new_ctl(mixer,
3174                                             &scarlett2_master_volume_ctl,
3175                                             0, 1, s, &private->master_vol_ctl);
3176                 if (err < 0)
3177                         return err;
3178         }
3179
3180         /* Add volume controls */
3181         for (i = 0; i < num_line_out; i++) {
3182                 int index = line_out_remap(private, i);
3183
3184                 /* Fader */
3185                 if (info->line_out_descrs[i])
3186                         snprintf(s, sizeof(s),
3187                                  "Line %02d (%s) Playback Volume",
3188                                  i + 1, info->line_out_descrs[i]);
3189                 else
3190                         snprintf(s, sizeof(s),
3191                                  "Line %02d Playback Volume",
3192                                  i + 1);
3193                 err = scarlett2_add_new_ctl(mixer,
3194                                             &scarlett2_line_out_volume_ctl,
3195                                             i, 1, s, &private->vol_ctls[i]);
3196                 if (err < 0)
3197                         return err;
3198
3199                 /* Mute Switch */
3200                 snprintf(s, sizeof(s),
3201                          "Line %02d Mute Playback Switch",
3202                          i + 1);
3203                 err = scarlett2_add_new_ctl(mixer,
3204                                             &scarlett2_mute_ctl,
3205                                             i, 1, s,
3206                                             &private->mute_ctls[i]);
3207                 if (err < 0)
3208                         return err;
3209
3210                 /* Make the fader and mute controls read-only if the
3211                  * SW/HW switch is set to HW
3212                  */
3213                 if (private->vol_sw_hw_switch[index])
3214                         scarlett2_vol_ctl_set_writable(mixer, i, 0);
3215
3216                 /* SW/HW Switch */
3217                 if (info->line_out_hw_vol) {
3218                         snprintf(s, sizeof(s),
3219                                  "Line Out %02d Volume Control Playback Enum",
3220                                  i + 1);
3221                         err = scarlett2_add_new_ctl(mixer,
3222                                                     &scarlett2_sw_hw_enum_ctl,
3223                                                     i, 1, s,
3224                                                     &private->sw_hw_ctls[i]);
3225                         if (err < 0)
3226                                 return err;
3227
3228                         /* Make the switch read-only if the line is
3229                          * involved in speaker switching
3230                          */
3231                         if (private->speaker_switching_switch && i < 4)
3232                                 scarlett2_sw_hw_ctl_ro(private, i);
3233                 }
3234         }
3235
3236         /* Add dim/mute controls */
3237         if (info->line_out_hw_vol)
3238                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
3239                         err = scarlett2_add_new_ctl(
3240                                 mixer, &scarlett2_dim_mute_ctl,
3241                                 i, 1, scarlett2_dim_mute_names[i],
3242                                 &private->dim_mute_ctls[i]);
3243                         if (err < 0)
3244                                 return err;
3245                 }
3246
3247         return 0;
3248 }
3249
3250 /*** Create the analogue input controls ***/
3251
3252 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
3253 {
3254         struct scarlett2_data *private = mixer->private_data;
3255         const struct scarlett2_device_info *info = private->info;
3256         int err, i;
3257         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3258         const char *fmt = "Line In %d %s Capture %s";
3259         const char *fmt2 = "Line In %d-%d %s Capture %s";
3260
3261         /* Add input level (line/inst) controls */
3262         for (i = 0; i < info->level_input_count; i++) {
3263                 snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
3264                          "Level", "Enum");
3265                 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
3266                                             i, 1, s, &private->level_ctls[i]);
3267                 if (err < 0)
3268                         return err;
3269         }
3270
3271         /* Add input pad controls */
3272         for (i = 0; i < info->pad_input_count; i++) {
3273                 snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
3274                 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
3275                                             i, 1, s, &private->pad_ctls[i]);
3276                 if (err < 0)
3277                         return err;
3278         }
3279
3280         /* Add input air controls */
3281         for (i = 0; i < info->air_input_count; i++) {
3282                 snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch");
3283                 err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl,
3284                                             i, 1, s, &private->air_ctls[i]);
3285                 if (err < 0)
3286                         return err;
3287         }
3288
3289         /* Add input phantom controls */
3290         if (info->inputs_per_phantom == 1) {
3291                 for (i = 0; i < info->phantom_count; i++) {
3292                         scnprintf(s, sizeof(s), fmt, i + 1,
3293                                   "Phantom Power", "Switch");
3294                         err = scarlett2_add_new_ctl(
3295                                 mixer, &scarlett2_phantom_ctl,
3296                                 i, 1, s, &private->phantom_ctls[i]);
3297                         if (err < 0)
3298                                 return err;
3299                 }
3300         } else if (info->inputs_per_phantom > 1) {
3301                 for (i = 0; i < info->phantom_count; i++) {
3302                         int from = i * info->inputs_per_phantom + 1;
3303                         int to = (i + 1) * info->inputs_per_phantom;
3304
3305                         scnprintf(s, sizeof(s), fmt2, from, to,
3306                                   "Phantom Power", "Switch");
3307                         err = scarlett2_add_new_ctl(
3308                                 mixer, &scarlett2_phantom_ctl,
3309                                 i, 1, s, &private->phantom_ctls[i]);
3310                         if (err < 0)
3311                                 return err;
3312                 }
3313         }
3314         if (info->phantom_count) {
3315                 err = scarlett2_add_new_ctl(
3316                         mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
3317                         "Phantom Power Persistence Capture Switch", NULL);
3318                 if (err < 0)
3319                         return err;
3320         }
3321
3322         return 0;
3323 }
3324
3325 /*** Mixer Volume Controls ***/
3326
3327 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
3328                                     struct snd_ctl_elem_info *uinfo)
3329 {
3330         struct usb_mixer_elem_info *elem = kctl->private_data;
3331
3332         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3333         uinfo->count = elem->channels;
3334         uinfo->value.integer.min = 0;
3335         uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
3336         uinfo->value.integer.step = 1;
3337         return 0;
3338 }
3339
3340 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
3341                                    struct snd_ctl_elem_value *ucontrol)
3342 {
3343         struct usb_mixer_elem_info *elem = kctl->private_data;
3344         struct scarlett2_data *private = elem->head.mixer->private_data;
3345
3346         ucontrol->value.integer.value[0] = private->mix[elem->control];
3347         return 0;
3348 }
3349
3350 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
3351                                    struct snd_ctl_elem_value *ucontrol)
3352 {
3353         struct usb_mixer_elem_info *elem = kctl->private_data;
3354         struct usb_mixer_interface *mixer = elem->head.mixer;
3355         struct scarlett2_data *private = mixer->private_data;
3356         const struct scarlett2_device_info *info = private->info;
3357         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3358         int oval, val, num_mixer_in, mix_num, err = 0;
3359         int index = elem->control;
3360
3361         mutex_lock(&private->data_mutex);
3362
3363         oval = private->mix[index];
3364         val = clamp(ucontrol->value.integer.value[0],
3365                     0L, (long)SCARLETT2_MIXER_MAX_VALUE);
3366         num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3367         mix_num = index / num_mixer_in;
3368
3369         if (oval == val)
3370                 goto unlock;
3371
3372         private->mix[index] = val;
3373         err = scarlett2_usb_set_mix(mixer, mix_num);
3374         if (err == 0)
3375                 err = 1;
3376
3377 unlock:
3378         mutex_unlock(&private->data_mutex);
3379         return err;
3380 }
3381
3382 static const DECLARE_TLV_DB_MINMAX(
3383         db_scale_scarlett2_mixer,
3384         SCARLETT2_MIXER_MIN_DB * 100,
3385         SCARLETT2_MIXER_MAX_DB * 100
3386 );
3387
3388 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
3389         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3390         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3391                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3392         .name = "",
3393         .info = scarlett2_mixer_ctl_info,
3394         .get  = scarlett2_mixer_ctl_get,
3395         .put  = scarlett2_mixer_ctl_put,
3396         .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
3397         .tlv = { .p = db_scale_scarlett2_mixer }
3398 };
3399
3400 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
3401 {
3402         struct scarlett2_data *private = mixer->private_data;
3403         const struct scarlett2_device_info *info = private->info;
3404         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3405         int err, i, j;
3406         int index;
3407         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3408
3409         int num_inputs =
3410                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3411         int num_outputs =
3412                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3413
3414         for (i = 0, index = 0; i < num_outputs; i++)
3415                 for (j = 0; j < num_inputs; j++, index++) {
3416                         snprintf(s, sizeof(s),
3417                                  "Mix %c Input %02d Playback Volume",
3418                                  'A' + i, j + 1);
3419                         err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
3420                                                     index, 1, s, NULL);
3421                         if (err < 0)
3422                                 return err;
3423                 }
3424
3425         return 0;
3426 }
3427
3428 /*** Mux Source Selection Controls ***/
3429
3430 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
3431                                            struct snd_ctl_elem_info *uinfo)
3432 {
3433         struct usb_mixer_elem_info *elem = kctl->private_data;
3434         struct scarlett2_data *private = elem->head.mixer->private_data;
3435         const struct scarlett2_device_info *info = private->info;
3436         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3437         unsigned int item = uinfo->value.enumerated.item;
3438         int items = private->num_mux_srcs;
3439         int port_type;
3440
3441         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3442         uinfo->count = elem->channels;
3443         uinfo->value.enumerated.items = items;
3444
3445         if (item >= items)
3446                 item = uinfo->value.enumerated.item = items - 1;
3447
3448         for (port_type = 0;
3449              port_type < SCARLETT2_PORT_TYPE_COUNT;
3450              port_type++) {
3451                 if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
3452                         const struct scarlett2_port *port =
3453                                 &scarlett2_ports[port_type];
3454
3455                         sprintf(uinfo->value.enumerated.name,
3456                                 port->src_descr, item + port->src_num_offset);
3457                         return 0;
3458                 }
3459                 item -= port_count[port_type][SCARLETT2_PORT_IN];
3460         }
3461
3462         return -EINVAL;
3463 }
3464
3465 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
3466                                           struct snd_ctl_elem_value *ucontrol)
3467 {
3468         struct usb_mixer_elem_info *elem = kctl->private_data;
3469         struct usb_mixer_interface *mixer = elem->head.mixer;
3470         struct scarlett2_data *private = mixer->private_data;
3471         int index = line_out_remap(private, elem->control);
3472         int err = 0;
3473
3474         mutex_lock(&private->data_mutex);
3475
3476         if (private->mux_updated) {
3477                 err = scarlett2_usb_get_mux(mixer);
3478                 if (err < 0)
3479                         goto unlock;
3480         }
3481         ucontrol->value.enumerated.item[0] = private->mux[index];
3482
3483 unlock:
3484         mutex_unlock(&private->data_mutex);
3485         return err;
3486 }
3487
3488 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
3489                                           struct snd_ctl_elem_value *ucontrol)
3490 {
3491         struct usb_mixer_elem_info *elem = kctl->private_data;
3492         struct usb_mixer_interface *mixer = elem->head.mixer;
3493         struct scarlett2_data *private = mixer->private_data;
3494         int index = line_out_remap(private, elem->control);
3495         int oval, val, err = 0;
3496
3497         mutex_lock(&private->data_mutex);
3498
3499         oval = private->mux[index];
3500         val = min(ucontrol->value.enumerated.item[0],
3501                   private->num_mux_srcs - 1U);
3502
3503         if (oval == val)
3504                 goto unlock;
3505
3506         private->mux[index] = val;
3507         err = scarlett2_usb_set_mux(mixer);
3508         if (err == 0)
3509                 err = 1;
3510
3511 unlock:
3512         mutex_unlock(&private->data_mutex);
3513         return err;
3514 }
3515
3516 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
3517         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3518         .name = "",
3519         .info = scarlett2_mux_src_enum_ctl_info,
3520         .get  = scarlett2_mux_src_enum_ctl_get,
3521         .put  = scarlett2_mux_src_enum_ctl_put,
3522 };
3523
3524 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
3525 {
3526         struct scarlett2_data *private = mixer->private_data;
3527         const struct scarlett2_device_info *info = private->info;
3528         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3529         int port_type, channel, i;
3530
3531         for (i = 0, port_type = 0;
3532              port_type < SCARLETT2_PORT_TYPE_COUNT;
3533              port_type++) {
3534                 for (channel = 0;
3535                      channel < port_count[port_type][SCARLETT2_PORT_OUT];
3536                      channel++, i++) {
3537                         int err;
3538                         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3539                         const char *const descr =
3540                                 scarlett2_ports[port_type].dst_descr;
3541
3542                         snprintf(s, sizeof(s) - 5, descr, channel + 1);
3543                         strcat(s, " Enum");
3544
3545                         err = scarlett2_add_new_ctl(mixer,
3546                                                     &scarlett2_mux_src_enum_ctl,
3547                                                     i, 1, s,
3548                                                     &private->mux_ctls[i]);
3549                         if (err < 0)
3550                                 return err;
3551                 }
3552         }
3553
3554         return 0;
3555 }
3556
3557 /*** Meter Controls ***/
3558
3559 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
3560                                     struct snd_ctl_elem_info *uinfo)
3561 {
3562         struct usb_mixer_elem_info *elem = kctl->private_data;
3563
3564         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3565         uinfo->count = elem->channels;
3566         uinfo->value.integer.min = 0;
3567         uinfo->value.integer.max = 4095;
3568         uinfo->value.integer.step = 1;
3569         return 0;
3570 }
3571
3572 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
3573                                    struct snd_ctl_elem_value *ucontrol)
3574 {
3575         struct usb_mixer_elem_info *elem = kctl->private_data;
3576         u16 meter_levels[SCARLETT2_MAX_METERS];
3577         int i, err;
3578
3579         err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels,
3580                                              meter_levels);
3581         if (err < 0)
3582                 return err;
3583
3584         for (i = 0; i < elem->channels; i++)
3585                 ucontrol->value.integer.value[i] = meter_levels[i];
3586
3587         return 0;
3588 }
3589
3590 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
3591         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
3592         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3593         .name = "",
3594         .info = scarlett2_meter_ctl_info,
3595         .get  = scarlett2_meter_ctl_get
3596 };
3597
3598 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
3599 {
3600         struct scarlett2_data *private = mixer->private_data;
3601
3602         /* devices without a mixer also don't support reporting levels */
3603         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3604                 return 0;
3605
3606         return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
3607                                      0, private->num_mux_dsts,
3608                                      "Level Meter", NULL);
3609 }
3610
3611 /*** MSD Controls ***/
3612
3613 static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
3614                                  struct snd_ctl_elem_value *ucontrol)
3615 {
3616         struct usb_mixer_elem_info *elem = kctl->private_data;
3617         struct scarlett2_data *private = elem->head.mixer->private_data;
3618
3619         ucontrol->value.integer.value[0] = private->msd_switch;
3620         return 0;
3621 }
3622
3623 static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
3624                                  struct snd_ctl_elem_value *ucontrol)
3625 {
3626         struct usb_mixer_elem_info *elem = kctl->private_data;
3627         struct usb_mixer_interface *mixer = elem->head.mixer;
3628         struct scarlett2_data *private = mixer->private_data;
3629
3630         int oval, val, err = 0;
3631
3632         mutex_lock(&private->data_mutex);
3633
3634         oval = private->msd_switch;
3635         val = !!ucontrol->value.integer.value[0];
3636
3637         if (oval == val)
3638                 goto unlock;
3639
3640         private->msd_switch = val;
3641
3642         /* Send switch change to the device */
3643         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3644                                        0, val);
3645         if (err == 0)
3646                 err = 1;
3647
3648 unlock:
3649         mutex_unlock(&private->data_mutex);
3650         return err;
3651 }
3652
3653 static const struct snd_kcontrol_new scarlett2_msd_ctl = {
3654         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3655         .name = "",
3656         .info = snd_ctl_boolean_mono_info,
3657         .get  = scarlett2_msd_ctl_get,
3658         .put  = scarlett2_msd_ctl_put,
3659 };
3660
3661 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
3662 {
3663         struct scarlett2_data *private = mixer->private_data;
3664         const struct scarlett2_device_info *info = private->info;
3665
3666         if (!info->has_msd_mode)
3667                 return 0;
3668
3669         /* If MSD mode is off, hide the switch by default */
3670         if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
3671                 return 0;
3672
3673         /* Add MSD control */
3674         return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
3675                                      0, 1, "MSD Mode Switch", NULL);
3676 }
3677
3678 /*** Standalone Control ***/
3679
3680 static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,
3681                                         struct snd_ctl_elem_value *ucontrol)
3682 {
3683         struct usb_mixer_elem_info *elem = kctl->private_data;
3684         struct scarlett2_data *private = elem->head.mixer->private_data;
3685
3686         ucontrol->value.integer.value[0] = private->standalone_switch;
3687         return 0;
3688 }
3689
3690 static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,
3691                                         struct snd_ctl_elem_value *ucontrol)
3692 {
3693         struct usb_mixer_elem_info *elem = kctl->private_data;
3694         struct usb_mixer_interface *mixer = elem->head.mixer;
3695         struct scarlett2_data *private = mixer->private_data;
3696
3697         int oval, val, err = 0;
3698
3699         mutex_lock(&private->data_mutex);
3700
3701         oval = private->standalone_switch;
3702         val = !!ucontrol->value.integer.value[0];
3703
3704         if (oval == val)
3705                 goto unlock;
3706
3707         private->standalone_switch = val;
3708
3709         /* Send switch change to the device */
3710         err = scarlett2_usb_set_config(mixer,
3711                                        SCARLETT2_CONFIG_STANDALONE_SWITCH,
3712                                        0, val);
3713         if (err == 0)
3714                 err = 1;
3715
3716 unlock:
3717         mutex_unlock(&private->data_mutex);
3718         return err;
3719 }
3720
3721 static const struct snd_kcontrol_new scarlett2_standalone_ctl = {
3722         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3723         .name = "",
3724         .info = snd_ctl_boolean_mono_info,
3725         .get  = scarlett2_standalone_ctl_get,
3726         .put  = scarlett2_standalone_ctl_put,
3727 };
3728
3729 static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
3730 {
3731         struct scarlett2_data *private = mixer->private_data;
3732
3733         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3734                 return 0;
3735
3736         /* Add standalone control */
3737         return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
3738                                      0, 1, "Standalone Switch", NULL);
3739 }
3740
3741 /*** Cleanup/Suspend Callbacks ***/
3742
3743 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
3744 {
3745         struct scarlett2_data *private = mixer->private_data;
3746
3747         cancel_delayed_work_sync(&private->work);
3748         kfree(private);
3749         mixer->private_data = NULL;
3750 }
3751
3752 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
3753 {
3754         struct scarlett2_data *private = mixer->private_data;
3755
3756         if (cancel_delayed_work_sync(&private->work))
3757                 scarlett2_config_save(private->mixer);
3758 }
3759
3760 /*** Initialisation ***/
3761
3762 static void scarlett2_count_mux_io(struct scarlett2_data *private)
3763 {
3764         const struct scarlett2_device_info *info = private->info;
3765         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3766         int port_type, srcs = 0, dsts = 0;
3767
3768         for (port_type = 0;
3769              port_type < SCARLETT2_PORT_TYPE_COUNT;
3770              port_type++) {
3771                 srcs += port_count[port_type][SCARLETT2_PORT_IN];
3772                 dsts += port_count[port_type][SCARLETT2_PORT_OUT];
3773         }
3774
3775         private->num_mux_srcs = srcs;
3776         private->num_mux_dsts = dsts;
3777 }
3778
3779 /* Look through the interface descriptors for the Focusrite Control
3780  * interface (bInterfaceClass = 255 Vendor Specific Class) and set
3781  * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
3782  * in private
3783  */
3784 static int scarlett2_find_fc_interface(struct usb_device *dev,
3785                                        struct scarlett2_data *private)
3786 {
3787         struct usb_host_config *config = dev->actconfig;
3788         int i;
3789
3790         for (i = 0; i < config->desc.bNumInterfaces; i++) {
3791                 struct usb_interface *intf = config->interface[i];
3792                 struct usb_interface_descriptor *desc =
3793                         &intf->altsetting[0].desc;
3794                 struct usb_endpoint_descriptor *epd;
3795
3796                 if (desc->bInterfaceClass != 255)
3797                         continue;
3798
3799                 epd = get_endpoint(intf->altsetting, 0);
3800                 private->bInterfaceNumber = desc->bInterfaceNumber;
3801                 private->bEndpointAddress = epd->bEndpointAddress &
3802                         USB_ENDPOINT_NUMBER_MASK;
3803                 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
3804                 private->bInterval = epd->bInterval;
3805                 return 0;
3806         }
3807
3808         return -EINVAL;
3809 }
3810
3811 /* Initialise private data */
3812 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
3813                                   const struct scarlett2_device_info *info)
3814 {
3815         struct scarlett2_data *private =
3816                 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
3817
3818         if (!private)
3819                 return -ENOMEM;
3820
3821         mutex_init(&private->usb_mutex);
3822         mutex_init(&private->data_mutex);
3823         INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
3824
3825         mixer->private_data = private;
3826         mixer->private_free = scarlett2_private_free;
3827         mixer->private_suspend = scarlett2_private_suspend;
3828
3829         private->info = info;
3830         scarlett2_count_mux_io(private);
3831         private->scarlett2_seq = 0;
3832         private->mixer = mixer;
3833
3834         return scarlett2_find_fc_interface(mixer->chip->dev, private);
3835 }
3836
3837 /* Cargo cult proprietary initialisation sequence */
3838 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
3839 {
3840         struct usb_device *dev = mixer->chip->dev;
3841         struct scarlett2_data *private = mixer->private_data;
3842         u8 buf[24];
3843         int err;
3844
3845         if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
3846                 return -EINVAL;
3847
3848         /* step 0 */
3849         err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
3850                                SCARLETT2_USB_CMD_INIT, buf, sizeof(buf));
3851         if (err < 0)
3852                 return err;
3853
3854         /* step 1 */
3855         private->scarlett2_seq = 1;
3856         err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
3857         if (err < 0)
3858                 return err;
3859
3860         /* step 2 */
3861         private->scarlett2_seq = 1;
3862         return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84);
3863 }
3864
3865 /* Read configuration from the interface on start */
3866 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
3867 {
3868         struct scarlett2_data *private = mixer->private_data;
3869         const struct scarlett2_device_info *info = private->info;
3870         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3871         int num_line_out =
3872                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3873         int num_mixer_out =
3874                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3875         struct scarlett2_usb_volume_status volume_status;
3876         int err, i;
3877
3878         if (info->has_msd_mode) {
3879                 err = scarlett2_usb_get_config(
3880                         mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3881                         1, &private->msd_switch);
3882                 if (err < 0)
3883                         return err;
3884
3885                 /* no other controls are created if MSD mode is on */
3886                 if (private->msd_switch)
3887                         return 0;
3888         }
3889
3890         err = scarlett2_update_input_other(mixer);
3891         if (err < 0)
3892                 return err;
3893
3894         err = scarlett2_update_monitor_other(mixer);
3895         if (err < 0)
3896                 return err;
3897
3898         /* the rest of the configuration is for devices with a mixer */
3899         if (info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3900                 return 0;
3901
3902         err = scarlett2_usb_get_config(
3903                 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
3904                 1, &private->standalone_switch);
3905         if (err < 0)
3906                 return err;
3907
3908         err = scarlett2_update_sync(mixer);
3909         if (err < 0)
3910                 return err;
3911
3912         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
3913         if (err < 0)
3914                 return err;
3915
3916         if (info->line_out_hw_vol)
3917                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3918                         private->dim_mute[i] = !!volume_status.dim_mute[i];
3919
3920         private->master_vol = clamp(
3921                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
3922                 0, SCARLETT2_VOLUME_BIAS);
3923
3924         for (i = 0; i < num_line_out; i++) {
3925                 int volume, mute;
3926
3927                 private->vol_sw_hw_switch[i] =
3928                         info->line_out_hw_vol
3929                                 && volume_status.sw_hw_switch[i];
3930
3931                 volume = private->vol_sw_hw_switch[i]
3932                            ? volume_status.master_vol
3933                            : volume_status.sw_vol[i];
3934                 volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
3935                                0, SCARLETT2_VOLUME_BIAS);
3936                 private->vol[i] = volume;
3937
3938                 mute = private->vol_sw_hw_switch[i]
3939                          ? private->dim_mute[SCARLETT2_BUTTON_MUTE]
3940                          : volume_status.mute_switch[i];
3941                 private->mute_switch[i] = mute;
3942         }
3943
3944         for (i = 0; i < num_mixer_out; i++) {
3945                 err = scarlett2_usb_get_mix(mixer, i);
3946                 if (err < 0)
3947                         return err;
3948         }
3949
3950         return scarlett2_usb_get_mux(mixer);
3951 }
3952
3953 /* Notify on sync change */
3954 static void scarlett2_notify_sync(
3955         struct usb_mixer_interface *mixer)
3956 {
3957         struct scarlett2_data *private = mixer->private_data;
3958
3959         private->sync_updated = 1;
3960
3961         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3962                        &private->sync_ctl->id);
3963 }
3964
3965 /* Notify on monitor change */
3966 static void scarlett2_notify_monitor(
3967         struct usb_mixer_interface *mixer)
3968 {
3969         struct snd_card *card = mixer->chip->card;
3970         struct scarlett2_data *private = mixer->private_data;
3971         const struct scarlett2_device_info *info = private->info;
3972         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3973         int num_line_out =
3974                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3975         int i;
3976
3977         /* if line_out_hw_vol is 0, there are no controls to update */
3978         if (!info->line_out_hw_vol)
3979                 return;
3980
3981         private->vol_updated = 1;
3982
3983         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3984                        &private->master_vol_ctl->id);
3985
3986         for (i = 0; i < num_line_out; i++)
3987                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3988                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3989                                        &private->vol_ctls[i]->id);
3990 }
3991
3992 /* Notify on dim/mute change */
3993 static void scarlett2_notify_dim_mute(
3994         struct usb_mixer_interface *mixer)
3995 {
3996         struct snd_card *card = mixer->chip->card;
3997         struct scarlett2_data *private = mixer->private_data;
3998         const struct scarlett2_device_info *info = private->info;
3999         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
4000         int num_line_out =
4001                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
4002         int i;
4003
4004         private->vol_updated = 1;
4005
4006         if (!info->line_out_hw_vol)
4007                 return;
4008
4009         for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
4010                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4011                                &private->dim_mute_ctls[i]->id);
4012
4013         for (i = 0; i < num_line_out; i++)
4014                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
4015                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4016                                        &private->mute_ctls[i]->id);
4017 }
4018
4019 /* Notify on "input other" change (level/pad/air) */
4020 static void scarlett2_notify_input_other(
4021         struct usb_mixer_interface *mixer)
4022 {
4023         struct snd_card *card = mixer->chip->card;
4024         struct scarlett2_data *private = mixer->private_data;
4025         const struct scarlett2_device_info *info = private->info;
4026         int i;
4027
4028         private->input_other_updated = 1;
4029
4030         for (i = 0; i < info->level_input_count; i++)
4031                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4032                                &private->level_ctls[i]->id);
4033         for (i = 0; i < info->pad_input_count; i++)
4034                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4035                                &private->pad_ctls[i]->id);
4036         for (i = 0; i < info->air_input_count; i++)
4037                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4038                                &private->air_ctls[i]->id);
4039         for (i = 0; i < info->phantom_count; i++)
4040                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4041                                &private->phantom_ctls[i]->id);
4042 }
4043
4044 /* Notify on "monitor other" change (direct monitor, speaker
4045  * switching, talkback)
4046  */
4047 static void scarlett2_notify_monitor_other(
4048         struct usb_mixer_interface *mixer)
4049 {
4050         struct snd_card *card = mixer->chip->card;
4051         struct scarlett2_data *private = mixer->private_data;
4052         const struct scarlett2_device_info *info = private->info;
4053
4054         private->monitor_other_updated = 1;
4055
4056         if (info->direct_monitor) {
4057                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4058                                &private->direct_monitor_ctl->id);
4059                 return;
4060         }
4061
4062         if (info->has_speaker_switching)
4063                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4064                                &private->speaker_switching_ctl->id);
4065
4066         if (info->has_talkback)
4067                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4068                                &private->talkback_ctl->id);
4069
4070         /* if speaker switching was recently enabled or disabled,
4071          * invalidate the dim/mute and mux enum controls
4072          */
4073         if (private->speaker_switching_switched) {
4074                 int i;
4075
4076                 scarlett2_notify_dim_mute(mixer);
4077
4078                 private->speaker_switching_switched = 0;
4079                 private->mux_updated = 1;
4080
4081                 for (i = 0; i < private->num_mux_dsts; i++)
4082                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4083                                        &private->mux_ctls[i]->id);
4084         }
4085 }
4086
4087 /* Interrupt callback */
4088 static void scarlett2_notify(struct urb *urb)
4089 {
4090         struct usb_mixer_interface *mixer = urb->context;
4091         int len = urb->actual_length;
4092         int ustatus = urb->status;
4093         u32 data;
4094
4095         if (ustatus != 0 || len != 8)
4096                 goto requeue;
4097
4098         data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
4099         if (data & SCARLETT2_USB_NOTIFY_SYNC)
4100                 scarlett2_notify_sync(mixer);
4101         if (data & SCARLETT2_USB_NOTIFY_MONITOR)
4102                 scarlett2_notify_monitor(mixer);
4103         if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE)
4104                 scarlett2_notify_dim_mute(mixer);
4105         if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER)
4106                 scarlett2_notify_input_other(mixer);
4107         if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER)
4108                 scarlett2_notify_monitor_other(mixer);
4109
4110 requeue:
4111         if (ustatus != -ENOENT &&
4112             ustatus != -ECONNRESET &&
4113             ustatus != -ESHUTDOWN) {
4114                 urb->dev = mixer->chip->dev;
4115                 usb_submit_urb(urb, GFP_ATOMIC);
4116         }
4117 }
4118
4119 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
4120 {
4121         struct usb_device *dev = mixer->chip->dev;
4122         struct scarlett2_data *private = mixer->private_data;
4123         unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
4124         void *transfer_buffer;
4125
4126         if (mixer->urb) {
4127                 usb_audio_err(mixer->chip,
4128                               "%s: mixer urb already in use!\n", __func__);
4129                 return 0;
4130         }
4131
4132         if (usb_pipe_type_check(dev, pipe))
4133                 return -EINVAL;
4134
4135         mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
4136         if (!mixer->urb)
4137                 return -ENOMEM;
4138
4139         transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
4140         if (!transfer_buffer)
4141                 return -ENOMEM;
4142
4143         usb_fill_int_urb(mixer->urb, dev, pipe,
4144                          transfer_buffer, private->wMaxPacketSize,
4145                          scarlett2_notify, mixer, private->bInterval);
4146
4147         return usb_submit_urb(mixer->urb, GFP_KERNEL);
4148 }
4149
4150 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
4151 {
4152         const struct scarlett2_device_info **info = scarlett2_devices;
4153         int err;
4154
4155         /* Find device in scarlett2_devices */
4156         while (*info && (*info)->usb_id != mixer->chip->usb_id)
4157                 info++;
4158         if (!*info)
4159                 return -EINVAL;
4160
4161         /* Initialise private data */
4162         err = scarlett2_init_private(mixer, *info);
4163         if (err < 0)
4164                 return err;
4165
4166         /* Send proprietary USB initialisation sequence */
4167         err = scarlett2_usb_init(mixer);
4168         if (err < 0)
4169                 return err;
4170
4171         /* Read volume levels and controls from the interface */
4172         err = scarlett2_read_configs(mixer);
4173         if (err < 0)
4174                 return err;
4175
4176         /* Create the MSD control */
4177         err = scarlett2_add_msd_ctl(mixer);
4178         if (err < 0)
4179                 return err;
4180
4181         /* If MSD mode is enabled, don't create any other controls */
4182         if (((struct scarlett2_data *)mixer->private_data)->msd_switch)
4183                 return 0;
4184
4185         /* Create the analogue output controls */
4186         err = scarlett2_add_line_out_ctls(mixer);
4187         if (err < 0)
4188                 return err;
4189
4190         /* Create the analogue input controls */
4191         err = scarlett2_add_line_in_ctls(mixer);
4192         if (err < 0)
4193                 return err;
4194
4195         /* Create the input, output, and mixer mux input selections */
4196         err = scarlett2_add_mux_enums(mixer);
4197         if (err < 0)
4198                 return err;
4199
4200         /* Create the matrix mixer controls */
4201         err = scarlett2_add_mixer_ctls(mixer);
4202         if (err < 0)
4203                 return err;
4204
4205         /* Create the level meter controls */
4206         err = scarlett2_add_meter_ctl(mixer);
4207         if (err < 0)
4208                 return err;
4209
4210         /* Create the sync control */
4211         err = scarlett2_add_sync_ctl(mixer);
4212         if (err < 0)
4213                 return err;
4214
4215         /* Create the direct monitor control */
4216         err = scarlett2_add_direct_monitor_ctl(mixer);
4217         if (err < 0)
4218                 return err;
4219
4220         /* Create the speaker switching control */
4221         err = scarlett2_add_speaker_switch_ctl(mixer);
4222         if (err < 0)
4223                 return err;
4224
4225         /* Create the talkback controls */
4226         err = scarlett2_add_talkback_ctls(mixer);
4227         if (err < 0)
4228                 return err;
4229
4230         /* Create the standalone control */
4231         err = scarlett2_add_standalone_ctl(mixer);
4232         if (err < 0)
4233                 return err;
4234
4235         /* Set up the interrupt polling */
4236         err = scarlett2_init_notify(mixer);
4237         if (err < 0)
4238                 return err;
4239
4240         return 0;
4241 }
4242
4243 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
4244 {
4245         struct snd_usb_audio *chip = mixer->chip;
4246         int err;
4247
4248         /* only use UAC_VERSION_2 */
4249         if (!mixer->protocol)
4250                 return 0;
4251
4252         if (!(chip->setup & SCARLETT2_ENABLE)) {
4253                 usb_audio_info(chip,
4254                         "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; "
4255                         "use options snd_usb_audio vid=0x%04x pid=0x%04x "
4256                         "device_setup=1 to enable and report any issues "
4257                         "to g@b4.vu",
4258                         USB_ID_VENDOR(chip->usb_id),
4259                         USB_ID_PRODUCT(chip->usb_id));
4260                 return 0;
4261         }
4262
4263         usb_audio_info(chip,
4264                 "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x",
4265                 USB_ID_PRODUCT(chip->usb_id));
4266
4267         err = snd_scarlett_gen2_controls_create(mixer);
4268         if (err < 0)
4269                 usb_audio_err(mixer->chip,
4270                               "Error initialising Scarlett Mixer Driver: %d",
4271                               err);
4272
4273         return err;
4274 }