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         scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
1341                       &req, sizeof(u32),
1342                       NULL, 0);
1343 }
1344
1345 /* Delayed work to save config */
1346 static void scarlett2_config_save_work(struct work_struct *work)
1347 {
1348         struct scarlett2_data *private =
1349                 container_of(work, struct scarlett2_data, work.work);
1350
1351         scarlett2_config_save(private->mixer);
1352 }
1353
1354 /* Send a USB message to set a SCARLETT2_CONFIG_* parameter */
1355 static int scarlett2_usb_set_config(
1356         struct usb_mixer_interface *mixer,
1357         int config_item_num, int index, int value)
1358 {
1359         struct scarlett2_data *private = mixer->private_data;
1360         const struct scarlett2_device_info *info = private->info;
1361         const struct scarlett2_config *config_item =
1362                &scarlett2_config_items[info->config_set][config_item_num];
1363         struct {
1364                 __le32 offset;
1365                 __le32 bytes;
1366                 __le32 value;
1367         } __packed req;
1368         __le32 req2;
1369         int offset, size;
1370         int err;
1371
1372         /* Cancel any pending NVRAM save */
1373         cancel_delayed_work_sync(&private->work);
1374
1375         /* Convert config_item->size in bits to size in bytes and
1376          * calculate offset
1377          */
1378         if (config_item->size >= 8) {
1379                 size = config_item->size / 8;
1380                 offset = config_item->offset + index * size;
1381
1382         /* If updating a bit, retrieve the old value, set/clear the
1383          * bit as needed, and update value
1384          */
1385         } else {
1386                 u8 tmp;
1387
1388                 size = 1;
1389                 offset = config_item->offset;
1390
1391                 scarlett2_usb_get(mixer, offset, &tmp, 1);
1392                 if (value)
1393                         tmp |= (1 << index);
1394                 else
1395                         tmp &= ~(1 << index);
1396
1397                 value = tmp;
1398         }
1399
1400         /* Send the configuration parameter data */
1401         req.offset = cpu_to_le32(offset);
1402         req.bytes = cpu_to_le32(size);
1403         req.value = cpu_to_le32(value);
1404         err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
1405                             &req, sizeof(u32) * 2 + size,
1406                             NULL, 0);
1407         if (err < 0)
1408                 return err;
1409
1410         /* Activate the change */
1411         req2 = cpu_to_le32(config_item->activate);
1412         err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
1413                             &req2, sizeof(req2), NULL, 0);
1414         if (err < 0)
1415                 return err;
1416
1417         /* Schedule the change to be written to NVRAM */
1418         if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
1419                 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
1420
1421         return 0;
1422 }
1423
1424 /* Send a USB message to get sync status; result placed in *sync */
1425 static int scarlett2_usb_get_sync_status(
1426         struct usb_mixer_interface *mixer,
1427         u8 *sync)
1428 {
1429         __le32 data;
1430         int err;
1431
1432         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
1433                             NULL, 0, &data, sizeof(data));
1434         if (err < 0)
1435                 return err;
1436
1437         *sync = !!data;
1438         return 0;
1439 }
1440
1441 /* Send a USB message to get volume status; result placed in *buf */
1442 static int scarlett2_usb_get_volume_status(
1443         struct usb_mixer_interface *mixer,
1444         struct scarlett2_usb_volume_status *buf)
1445 {
1446         return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
1447                                  buf, sizeof(*buf));
1448 }
1449
1450 /* Send a USB message to get the volumes for all inputs of one mix
1451  * and put the values into private->mix[]
1452  */
1453 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
1454                                  int mix_num)
1455 {
1456         struct scarlett2_data *private = mixer->private_data;
1457         const struct scarlett2_device_info *info = private->info;
1458
1459         int num_mixer_in =
1460                 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
1461         int err, i, j, k;
1462
1463         struct {
1464                 __le16 mix_num;
1465                 __le16 count;
1466         } __packed req;
1467
1468         __le16 data[SCARLETT2_INPUT_MIX_MAX];
1469
1470         req.mix_num = cpu_to_le16(mix_num);
1471         req.count = cpu_to_le16(num_mixer_in);
1472
1473         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
1474                             &req, sizeof(req),
1475                             data, num_mixer_in * sizeof(u16));
1476         if (err < 0)
1477                 return err;
1478
1479         for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) {
1480                 u16 mixer_value = le16_to_cpu(data[i]);
1481
1482                 for (k = 0; k < SCARLETT2_MIXER_VALUE_COUNT; k++)
1483                         if (scarlett2_mixer_values[k] >= mixer_value)
1484                                 break;
1485                 if (k == SCARLETT2_MIXER_VALUE_COUNT)
1486                         k = SCARLETT2_MIXER_MAX_VALUE;
1487                 private->mix[j] = k;
1488         }
1489
1490         return 0;
1491 }
1492
1493 /* Send a USB message to set the volumes for all inputs of one mix
1494  * (values obtained from private->mix[])
1495  */
1496 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
1497                                  int mix_num)
1498 {
1499         struct scarlett2_data *private = mixer->private_data;
1500         const struct scarlett2_device_info *info = private->info;
1501
1502         struct {
1503                 __le16 mix_num;
1504                 __le16 data[SCARLETT2_INPUT_MIX_MAX];
1505         } __packed req;
1506
1507         int i, j;
1508         int num_mixer_in =
1509                 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
1510
1511         req.mix_num = cpu_to_le16(mix_num);
1512
1513         for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
1514                 req.data[i] = cpu_to_le16(
1515                         scarlett2_mixer_values[private->mix[j]]
1516                 );
1517
1518         return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
1519                              &req, (num_mixer_in + 1) * sizeof(u16),
1520                              NULL, 0);
1521 }
1522
1523 /* Convert a port number index (per info->port_count) to a hardware ID */
1524 static u32 scarlett2_mux_src_num_to_id(
1525         const int port_count[][SCARLETT2_PORT_DIRNS], int num)
1526 {
1527         int port_type;
1528
1529         for (port_type = 0;
1530              port_type < SCARLETT2_PORT_TYPE_COUNT;
1531              port_type++) {
1532                 if (num < port_count[port_type][SCARLETT2_PORT_IN])
1533                         return scarlett2_ports[port_type].id | num;
1534                 num -= port_count[port_type][SCARLETT2_PORT_IN];
1535         }
1536
1537         /* Oops */
1538         return 0;
1539 }
1540
1541 /* Convert a hardware ID to a port number index */
1542 static u32 scarlett2_mux_id_to_num(
1543         const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)
1544 {
1545         int port_type;
1546         int port_num = 0;
1547
1548         for (port_type = 0;
1549              port_type < SCARLETT2_PORT_TYPE_COUNT;
1550              port_type++) {
1551                 int base = scarlett2_ports[port_type].id;
1552                 int count = port_count[port_type][direction];
1553
1554                 if (id >= base && id < base + count)
1555                         return port_num + id - base;
1556                 port_num += count;
1557         }
1558
1559         /* Oops */
1560         return -1;
1561 }
1562
1563 /* Convert one mux entry from the interface and load into private->mux[] */
1564 static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
1565                                        u32 mux_entry)
1566 {
1567         const struct scarlett2_device_info *info = private->info;
1568         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1569
1570         int dst_idx, src_idx;
1571
1572         dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT,
1573                                           mux_entry & 0xFFF);
1574         if (dst_idx < 0)
1575                 return;
1576
1577         if (dst_idx >= private->num_mux_dsts) {
1578                 usb_audio_err(private->mixer->chip,
1579                         "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",
1580                         mux_entry, dst_idx, private->num_mux_dsts);
1581                 return;
1582         }
1583
1584         src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN,
1585                                           mux_entry >> 12);
1586         if (src_idx < 0)
1587                 return;
1588
1589         if (src_idx >= private->num_mux_srcs) {
1590                 usb_audio_err(private->mixer->chip,
1591                         "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",
1592                         mux_entry, src_idx, private->num_mux_srcs);
1593                 return;
1594         }
1595
1596         private->mux[dst_idx] = src_idx;
1597 }
1598
1599 /* Send USB message to get mux inputs and then populate private->mux[] */
1600 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
1601 {
1602         struct scarlett2_data *private = mixer->private_data;
1603         int count = private->num_mux_dsts;
1604         int err, i;
1605
1606         struct {
1607                 __le16 num;
1608                 __le16 count;
1609         } __packed req;
1610
1611         __le32 data[SCARLETT2_MUX_MAX];
1612
1613         private->mux_updated = 0;
1614
1615         req.num = 0;
1616         req.count = cpu_to_le16(count);
1617
1618         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
1619                             &req, sizeof(req),
1620                             data, count * sizeof(u32));
1621         if (err < 0)
1622                 return err;
1623
1624         for (i = 0; i < count; i++)
1625                 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
1626
1627         return 0;
1628 }
1629
1630 /* Send USB messages to set mux inputs */
1631 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
1632 {
1633         struct scarlett2_data *private = mixer->private_data;
1634         const struct scarlett2_device_info *info = private->info;
1635         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1636         int table;
1637
1638         struct {
1639                 __le16 pad;
1640                 __le16 num;
1641                 __le32 data[SCARLETT2_MUX_MAX];
1642         } __packed req;
1643
1644         req.pad = 0;
1645
1646         /* set mux settings for each rate */
1647         for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {
1648                 const struct scarlett2_mux_entry *entry;
1649
1650                 /* i counts over the output array */
1651                 int i = 0, err;
1652
1653                 req.num = cpu_to_le16(table);
1654
1655                 /* loop through each entry */
1656                 for (entry = info->mux_assignment[table];
1657                      entry->count;
1658                      entry++) {
1659                         int j;
1660                         int port_type = entry->port_type;
1661                         int port_idx = entry->start;
1662                         int mux_idx = scarlett2_get_port_start_num(port_count,
1663                                 SCARLETT2_PORT_OUT, port_type) + port_idx;
1664                         int dst_id = scarlett2_ports[port_type].id + port_idx;
1665
1666                         /* Empty slots */
1667                         if (!dst_id) {
1668                                 for (j = 0; j < entry->count; j++)
1669                                         req.data[i++] = 0;
1670                                 continue;
1671                         }
1672
1673                         /* Non-empty mux slots use the lower 12 bits
1674                          * for the destination and next 12 bits for
1675                          * the source
1676                          */
1677                         for (j = 0; j < entry->count; j++) {
1678                                 int src_id = scarlett2_mux_src_num_to_id(
1679                                         port_count, private->mux[mux_idx++]);
1680                                 req.data[i++] = cpu_to_le32(dst_id |
1681                                                             src_id << 12);
1682                                 dst_id++;
1683                         }
1684                 }
1685
1686                 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
1687                                     &req, (i + 1) * sizeof(u32),
1688                                     NULL, 0);
1689                 if (err < 0)
1690                         return err;
1691         }
1692
1693         return 0;
1694 }
1695
1696 /* Send USB message to get meter levels */
1697 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
1698                                           u16 num_meters, u16 *levels)
1699 {
1700         struct {
1701                 __le16 pad;
1702                 __le16 num_meters;
1703                 __le32 magic;
1704         } __packed req;
1705         u32 resp[SCARLETT2_MAX_METERS];
1706         int i, err;
1707
1708         req.pad = 0;
1709         req.num_meters = cpu_to_le16(num_meters);
1710         req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
1711         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
1712                             &req, sizeof(req), resp, num_meters * sizeof(u32));
1713         if (err < 0)
1714                 return err;
1715
1716         /* copy, convert to u16 */
1717         for (i = 0; i < num_meters; i++)
1718                 levels[i] = resp[i];
1719
1720         return 0;
1721 }
1722
1723 /*** Control Functions ***/
1724
1725 /* helper function to create a new control */
1726 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
1727                                  const struct snd_kcontrol_new *ncontrol,
1728                                  int index, int channels, const char *name,
1729                                  struct snd_kcontrol **kctl_return)
1730 {
1731         struct snd_kcontrol *kctl;
1732         struct usb_mixer_elem_info *elem;
1733         int err;
1734
1735         elem = kzalloc(sizeof(*elem), GFP_KERNEL);
1736         if (!elem)
1737                 return -ENOMEM;
1738
1739         /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
1740          * ignores them for resume and other operations.
1741          * Also, the head.id field is set to 0, as we don't use this field.
1742          */
1743         elem->head.mixer = mixer;
1744         elem->control = index;
1745         elem->head.id = 0;
1746         elem->channels = channels;
1747         elem->val_type = USB_MIXER_BESPOKEN;
1748
1749         kctl = snd_ctl_new1(ncontrol, elem);
1750         if (!kctl) {
1751                 kfree(elem);
1752                 return -ENOMEM;
1753         }
1754         kctl->private_free = snd_usb_mixer_elem_free;
1755
1756         strscpy(kctl->id.name, name, sizeof(kctl->id.name));
1757
1758         err = snd_usb_mixer_add_control(&elem->head, kctl);
1759         if (err < 0)
1760                 return err;
1761
1762         if (kctl_return)
1763                 *kctl_return = kctl;
1764
1765         return 0;
1766 }
1767
1768 /*** Sync Control ***/
1769
1770 /* Update sync control after receiving notification that the status
1771  * has changed
1772  */
1773 static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
1774 {
1775         struct scarlett2_data *private = mixer->private_data;
1776
1777         private->sync_updated = 0;
1778         return scarlett2_usb_get_sync_status(mixer, &private->sync);
1779 }
1780
1781 static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,
1782                                    struct snd_ctl_elem_info *uinfo)
1783 {
1784         static const char *texts[2] = {
1785                 "Unlocked", "Locked"
1786         };
1787         return snd_ctl_enum_info(uinfo, 1, 2, texts);
1788 }
1789
1790 static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,
1791                                   struct snd_ctl_elem_value *ucontrol)
1792 {
1793         struct usb_mixer_elem_info *elem = kctl->private_data;
1794         struct usb_mixer_interface *mixer = elem->head.mixer;
1795         struct scarlett2_data *private = mixer->private_data;
1796
1797         mutex_lock(&private->data_mutex);
1798         if (private->sync_updated)
1799                 scarlett2_update_sync(mixer);
1800         ucontrol->value.enumerated.item[0] = private->sync;
1801         mutex_unlock(&private->data_mutex);
1802
1803         return 0;
1804 }
1805
1806 static const struct snd_kcontrol_new scarlett2_sync_ctl = {
1807         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1808         .access = SNDRV_CTL_ELEM_ACCESS_READ,
1809         .name = "",
1810         .info = scarlett2_sync_ctl_info,
1811         .get  = scarlett2_sync_ctl_get
1812 };
1813
1814 static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
1815 {
1816         struct scarlett2_data *private = mixer->private_data;
1817
1818         /* devices without a mixer also don't support reporting sync status */
1819         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
1820                 return 0;
1821
1822         return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
1823                                      0, 1, "Sync Status", &private->sync_ctl);
1824 }
1825
1826 /*** Analogue Line Out Volume Controls ***/
1827
1828 /* Update hardware volume controls after receiving notification that
1829  * they have changed
1830  */
1831 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
1832 {
1833         struct scarlett2_data *private = mixer->private_data;
1834         const struct scarlett2_device_info *info = private->info;
1835         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
1836         struct scarlett2_usb_volume_status volume_status;
1837         int num_line_out =
1838                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
1839         int err, i;
1840         int mute;
1841
1842         private->vol_updated = 0;
1843
1844         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
1845         if (err < 0)
1846                 return err;
1847
1848         private->master_vol = clamp(
1849                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1850                 0, SCARLETT2_VOLUME_BIAS);
1851
1852         if (info->line_out_hw_vol)
1853                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
1854                         private->dim_mute[i] = !!volume_status.dim_mute[i];
1855
1856         mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
1857
1858         for (i = 0; i < num_line_out; i++)
1859                 if (private->vol_sw_hw_switch[i]) {
1860                         private->vol[i] = private->master_vol;
1861                         private->mute_switch[i] = mute;
1862                 }
1863
1864         return 0;
1865 }
1866
1867 static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
1868                                      struct snd_ctl_elem_info *uinfo)
1869 {
1870         struct usb_mixer_elem_info *elem = kctl->private_data;
1871
1872         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1873         uinfo->count = elem->channels;
1874         uinfo->value.integer.min = 0;
1875         uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
1876         uinfo->value.integer.step = 1;
1877         return 0;
1878 }
1879
1880 static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
1881                                            struct snd_ctl_elem_value *ucontrol)
1882 {
1883         struct usb_mixer_elem_info *elem = kctl->private_data;
1884         struct usb_mixer_interface *mixer = elem->head.mixer;
1885         struct scarlett2_data *private = mixer->private_data;
1886
1887         mutex_lock(&private->data_mutex);
1888         if (private->vol_updated)
1889                 scarlett2_update_volumes(mixer);
1890         mutex_unlock(&private->data_mutex);
1891
1892         ucontrol->value.integer.value[0] = private->master_vol;
1893         return 0;
1894 }
1895
1896 static int line_out_remap(struct scarlett2_data *private, int index)
1897 {
1898         const struct scarlett2_device_info *info = private->info;
1899
1900         if (!info->line_out_remap_enable)
1901                 return index;
1902         return info->line_out_remap[index];
1903 }
1904
1905 static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
1906                                     struct snd_ctl_elem_value *ucontrol)
1907 {
1908         struct usb_mixer_elem_info *elem = kctl->private_data;
1909         struct usb_mixer_interface *mixer = elem->head.mixer;
1910         struct scarlett2_data *private = mixer->private_data;
1911         int index = line_out_remap(private, elem->control);
1912
1913         mutex_lock(&private->data_mutex);
1914         if (private->vol_updated)
1915                 scarlett2_update_volumes(mixer);
1916         mutex_unlock(&private->data_mutex);
1917
1918         ucontrol->value.integer.value[0] = private->vol[index];
1919         return 0;
1920 }
1921
1922 static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
1923                                     struct snd_ctl_elem_value *ucontrol)
1924 {
1925         struct usb_mixer_elem_info *elem = kctl->private_data;
1926         struct usb_mixer_interface *mixer = elem->head.mixer;
1927         struct scarlett2_data *private = mixer->private_data;
1928         int index = line_out_remap(private, elem->control);
1929         int oval, val, err = 0;
1930
1931         mutex_lock(&private->data_mutex);
1932
1933         oval = private->vol[index];
1934         val = ucontrol->value.integer.value[0];
1935
1936         if (oval == val)
1937                 goto unlock;
1938
1939         private->vol[index] = val;
1940         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1941                                        index, val - SCARLETT2_VOLUME_BIAS);
1942         if (err == 0)
1943                 err = 1;
1944
1945 unlock:
1946         mutex_unlock(&private->data_mutex);
1947         return err;
1948 }
1949
1950 static const DECLARE_TLV_DB_MINMAX(
1951         db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
1952 );
1953
1954 static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
1955         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1956         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1957                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1958         .name = "",
1959         .info = scarlett2_volume_ctl_info,
1960         .get  = scarlett2_master_volume_ctl_get,
1961         .private_value = 0, /* max value */
1962         .tlv = { .p = db_scale_scarlett2_gain }
1963 };
1964
1965 static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
1966         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1967         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1968                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1969         .name = "",
1970         .info = scarlett2_volume_ctl_info,
1971         .get  = scarlett2_volume_ctl_get,
1972         .put  = scarlett2_volume_ctl_put,
1973         .private_value = 0, /* max value */
1974         .tlv = { .p = db_scale_scarlett2_gain }
1975 };
1976
1977 /*** Mute Switch Controls ***/
1978
1979 static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,
1980                                         struct snd_ctl_elem_value *ucontrol)
1981 {
1982         struct usb_mixer_elem_info *elem = kctl->private_data;
1983         struct usb_mixer_interface *mixer = elem->head.mixer;
1984         struct scarlett2_data *private = mixer->private_data;
1985         int index = line_out_remap(private, elem->control);
1986
1987         mutex_lock(&private->data_mutex);
1988         if (private->vol_updated)
1989                 scarlett2_update_volumes(mixer);
1990         mutex_unlock(&private->data_mutex);
1991
1992         ucontrol->value.integer.value[0] = private->mute_switch[index];
1993         return 0;
1994 }
1995
1996 static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
1997                                         struct snd_ctl_elem_value *ucontrol)
1998 {
1999         struct usb_mixer_elem_info *elem = kctl->private_data;
2000         struct usb_mixer_interface *mixer = elem->head.mixer;
2001         struct scarlett2_data *private = mixer->private_data;
2002         int index = line_out_remap(private, elem->control);
2003         int oval, val, err = 0;
2004
2005         mutex_lock(&private->data_mutex);
2006
2007         oval = private->mute_switch[index];
2008         val = !!ucontrol->value.integer.value[0];
2009
2010         if (oval == val)
2011                 goto unlock;
2012
2013         private->mute_switch[index] = val;
2014
2015         /* Send mute change to the device */
2016         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
2017                                        index, val);
2018         if (err == 0)
2019                 err = 1;
2020
2021 unlock:
2022         mutex_unlock(&private->data_mutex);
2023         return err;
2024 }
2025
2026 static const struct snd_kcontrol_new scarlett2_mute_ctl = {
2027         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2028         .name = "",
2029         .info = snd_ctl_boolean_mono_info,
2030         .get  = scarlett2_mute_ctl_get,
2031         .put  = scarlett2_mute_ctl_put,
2032 };
2033
2034 /*** HW/SW Volume Switch Controls ***/
2035
2036 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
2037 {
2038         private->sw_hw_ctls[index]->vd[0].access &=
2039                 ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2040 }
2041
2042 static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
2043 {
2044         private->sw_hw_ctls[index]->vd[0].access |=
2045                 SNDRV_CTL_ELEM_ACCESS_WRITE;
2046 }
2047
2048 static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
2049                                          struct snd_ctl_elem_info *uinfo)
2050 {
2051         static const char *const values[2] = {
2052                 "SW", "HW"
2053         };
2054
2055         return snd_ctl_enum_info(uinfo, 1, 2, values);
2056 }
2057
2058 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
2059                                         struct snd_ctl_elem_value *ucontrol)
2060 {
2061         struct usb_mixer_elem_info *elem = kctl->private_data;
2062         struct scarlett2_data *private = elem->head.mixer->private_data;
2063         int index = line_out_remap(private, elem->control);
2064
2065         ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
2066         return 0;
2067 }
2068
2069 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
2070                                            int index, int value)
2071 {
2072         struct scarlett2_data *private = mixer->private_data;
2073         struct snd_card *card = mixer->chip->card;
2074
2075         /* Set/Clear write bits */
2076         if (value) {
2077                 private->vol_ctls[index]->vd[0].access |=
2078                         SNDRV_CTL_ELEM_ACCESS_WRITE;
2079                 private->mute_ctls[index]->vd[0].access |=
2080                         SNDRV_CTL_ELEM_ACCESS_WRITE;
2081         } else {
2082                 private->vol_ctls[index]->vd[0].access &=
2083                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2084                 private->mute_ctls[index]->vd[0].access &=
2085                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2086         }
2087
2088         /* Notify of write bit and possible value change */
2089         snd_ctl_notify(card,
2090                        SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
2091                        &private->vol_ctls[index]->id);
2092         snd_ctl_notify(card,
2093                        SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
2094                        &private->mute_ctls[index]->id);
2095 }
2096
2097 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
2098                                   int ctl_index, int val)
2099 {
2100         struct scarlett2_data *private = mixer->private_data;
2101         int index = line_out_remap(private, ctl_index);
2102         int err;
2103
2104         private->vol_sw_hw_switch[index] = val;
2105
2106         /* Change access mode to RO (hardware controlled volume)
2107          * or RW (software controlled volume)
2108          */
2109         scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
2110
2111         /* Reset volume/mute to master volume/mute */
2112         private->vol[index] = private->master_vol;
2113         private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
2114
2115         /* Set SW volume to current HW volume */
2116         err = scarlett2_usb_set_config(
2117                 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
2118                 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
2119         if (err < 0)
2120                 return err;
2121
2122         /* Set SW mute to current HW mute */
2123         err = scarlett2_usb_set_config(
2124                 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
2125                 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
2126         if (err < 0)
2127                 return err;
2128
2129         /* Send SW/HW switch change to the device */
2130         return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
2131                                         index, val);
2132 }
2133
2134 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
2135                                         struct snd_ctl_elem_value *ucontrol)
2136 {
2137         struct usb_mixer_elem_info *elem = kctl->private_data;
2138         struct usb_mixer_interface *mixer = elem->head.mixer;
2139         struct scarlett2_data *private = mixer->private_data;
2140         int ctl_index = elem->control;
2141         int index = line_out_remap(private, ctl_index);
2142         int oval, val, err = 0;
2143
2144         mutex_lock(&private->data_mutex);
2145
2146         oval = private->vol_sw_hw_switch[index];
2147         val = !!ucontrol->value.enumerated.item[0];
2148
2149         if (oval == val)
2150                 goto unlock;
2151
2152         err = scarlett2_sw_hw_change(mixer, ctl_index, val);
2153         if (err == 0)
2154                 err = 1;
2155
2156 unlock:
2157         mutex_unlock(&private->data_mutex);
2158         return err;
2159 }
2160
2161 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
2162         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2163         .name = "",
2164         .info = scarlett2_sw_hw_enum_ctl_info,
2165         .get  = scarlett2_sw_hw_enum_ctl_get,
2166         .put  = scarlett2_sw_hw_enum_ctl_put,
2167 };
2168
2169 /*** Line Level/Instrument Level Switch Controls ***/
2170
2171 static int scarlett2_update_input_other(struct usb_mixer_interface *mixer)
2172 {
2173         struct scarlett2_data *private = mixer->private_data;
2174         const struct scarlett2_device_info *info = private->info;
2175
2176         private->input_other_updated = 0;
2177
2178         if (info->level_input_count) {
2179                 int err = scarlett2_usb_get_config(
2180                         mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2181                         info->level_input_count + info->level_input_first,
2182                         private->level_switch);
2183                 if (err < 0)
2184                         return err;
2185         }
2186
2187         if (info->pad_input_count) {
2188                 int err = scarlett2_usb_get_config(
2189                         mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2190                         info->pad_input_count, private->pad_switch);
2191                 if (err < 0)
2192                         return err;
2193         }
2194
2195         if (info->air_input_count) {
2196                 int err = scarlett2_usb_get_config(
2197                         mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2198                         info->air_input_count, private->air_switch);
2199                 if (err < 0)
2200                         return err;
2201         }
2202
2203         if (info->phantom_count) {
2204                 int err = scarlett2_usb_get_config(
2205                         mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2206                         info->phantom_count, private->phantom_switch);
2207                 if (err < 0)
2208                         return err;
2209
2210                 err = scarlett2_usb_get_config(
2211                         mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
2212                         1, &private->phantom_persistence);
2213                 if (err < 0)
2214                         return err;
2215         }
2216
2217         return 0;
2218 }
2219
2220 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
2221                                          struct snd_ctl_elem_info *uinfo)
2222 {
2223         static const char *const values[2] = {
2224                 "Line", "Inst"
2225         };
2226
2227         return snd_ctl_enum_info(uinfo, 1, 2, values);
2228 }
2229
2230 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
2231                                         struct snd_ctl_elem_value *ucontrol)
2232 {
2233         struct usb_mixer_elem_info *elem = kctl->private_data;
2234         struct usb_mixer_interface *mixer = elem->head.mixer;
2235         struct scarlett2_data *private = mixer->private_data;
2236         const struct scarlett2_device_info *info = private->info;
2237
2238         int index = elem->control + info->level_input_first;
2239
2240         mutex_lock(&private->data_mutex);
2241         if (private->input_other_updated)
2242                 scarlett2_update_input_other(mixer);
2243         ucontrol->value.enumerated.item[0] = private->level_switch[index];
2244         mutex_unlock(&private->data_mutex);
2245
2246         return 0;
2247 }
2248
2249 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
2250                                         struct snd_ctl_elem_value *ucontrol)
2251 {
2252         struct usb_mixer_elem_info *elem = kctl->private_data;
2253         struct usb_mixer_interface *mixer = elem->head.mixer;
2254         struct scarlett2_data *private = mixer->private_data;
2255         const struct scarlett2_device_info *info = private->info;
2256
2257         int index = elem->control + info->level_input_first;
2258         int oval, val, err = 0;
2259
2260         mutex_lock(&private->data_mutex);
2261
2262         oval = private->level_switch[index];
2263         val = !!ucontrol->value.enumerated.item[0];
2264
2265         if (oval == val)
2266                 goto unlock;
2267
2268         private->level_switch[index] = val;
2269
2270         /* Send switch change to the device */
2271         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2272                                        index, val);
2273         if (err == 0)
2274                 err = 1;
2275
2276 unlock:
2277         mutex_unlock(&private->data_mutex);
2278         return err;
2279 }
2280
2281 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
2282         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2283         .name = "",
2284         .info = scarlett2_level_enum_ctl_info,
2285         .get  = scarlett2_level_enum_ctl_get,
2286         .put  = scarlett2_level_enum_ctl_put,
2287 };
2288
2289 /*** Pad Switch Controls ***/
2290
2291 static int scarlett2_pad_ctl_get(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
2298         mutex_lock(&private->data_mutex);
2299         if (private->input_other_updated)
2300                 scarlett2_update_input_other(mixer);
2301         ucontrol->value.integer.value[0] =
2302                 private->pad_switch[elem->control];
2303         mutex_unlock(&private->data_mutex);
2304
2305         return 0;
2306 }
2307
2308 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
2309                                  struct snd_ctl_elem_value *ucontrol)
2310 {
2311         struct usb_mixer_elem_info *elem = kctl->private_data;
2312         struct usb_mixer_interface *mixer = elem->head.mixer;
2313         struct scarlett2_data *private = mixer->private_data;
2314
2315         int index = elem->control;
2316         int oval, val, err = 0;
2317
2318         mutex_lock(&private->data_mutex);
2319
2320         oval = private->pad_switch[index];
2321         val = !!ucontrol->value.integer.value[0];
2322
2323         if (oval == val)
2324                 goto unlock;
2325
2326         private->pad_switch[index] = val;
2327
2328         /* Send switch change to the device */
2329         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2330                                        index, val);
2331         if (err == 0)
2332                 err = 1;
2333
2334 unlock:
2335         mutex_unlock(&private->data_mutex);
2336         return err;
2337 }
2338
2339 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
2340         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2341         .name = "",
2342         .info = snd_ctl_boolean_mono_info,
2343         .get  = scarlett2_pad_ctl_get,
2344         .put  = scarlett2_pad_ctl_put,
2345 };
2346
2347 /*** Air Switch Controls ***/
2348
2349 static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
2350                                  struct snd_ctl_elem_value *ucontrol)
2351 {
2352         struct usb_mixer_elem_info *elem = kctl->private_data;
2353         struct usb_mixer_interface *mixer = elem->head.mixer;
2354         struct scarlett2_data *private = mixer->private_data;
2355
2356         mutex_lock(&private->data_mutex);
2357         if (private->input_other_updated)
2358                 scarlett2_update_input_other(mixer);
2359         ucontrol->value.integer.value[0] = private->air_switch[elem->control];
2360         mutex_unlock(&private->data_mutex);
2361
2362         return 0;
2363 }
2364
2365 static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
2366                                  struct snd_ctl_elem_value *ucontrol)
2367 {
2368         struct usb_mixer_elem_info *elem = kctl->private_data;
2369         struct usb_mixer_interface *mixer = elem->head.mixer;
2370         struct scarlett2_data *private = mixer->private_data;
2371
2372         int index = elem->control;
2373         int oval, val, err = 0;
2374
2375         mutex_lock(&private->data_mutex);
2376
2377         oval = private->air_switch[index];
2378         val = !!ucontrol->value.integer.value[0];
2379
2380         if (oval == val)
2381                 goto unlock;
2382
2383         private->air_switch[index] = val;
2384
2385         /* Send switch change to the device */
2386         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2387                                        index, val);
2388         if (err == 0)
2389                 err = 1;
2390
2391 unlock:
2392         mutex_unlock(&private->data_mutex);
2393         return err;
2394 }
2395
2396 static const struct snd_kcontrol_new scarlett2_air_ctl = {
2397         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2398         .name = "",
2399         .info = snd_ctl_boolean_mono_info,
2400         .get  = scarlett2_air_ctl_get,
2401         .put  = scarlett2_air_ctl_put,
2402 };
2403
2404 /*** Phantom Switch Controls ***/
2405
2406 static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
2407                                      struct snd_ctl_elem_value *ucontrol)
2408 {
2409         struct usb_mixer_elem_info *elem = kctl->private_data;
2410         struct usb_mixer_interface *mixer = elem->head.mixer;
2411         struct scarlett2_data *private = mixer->private_data;
2412
2413         mutex_lock(&private->data_mutex);
2414         if (private->input_other_updated)
2415                 scarlett2_update_input_other(mixer);
2416         ucontrol->value.integer.value[0] =
2417                 private->phantom_switch[elem->control];
2418         mutex_unlock(&private->data_mutex);
2419
2420         return 0;
2421 }
2422
2423 static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
2424                                      struct snd_ctl_elem_value *ucontrol)
2425 {
2426         struct usb_mixer_elem_info *elem = kctl->private_data;
2427         struct usb_mixer_interface *mixer = elem->head.mixer;
2428         struct scarlett2_data *private = mixer->private_data;
2429
2430         int index = elem->control;
2431         int oval, val, err = 0;
2432
2433         mutex_lock(&private->data_mutex);
2434
2435         oval = private->phantom_switch[index];
2436         val = !!ucontrol->value.integer.value[0];
2437
2438         if (oval == val)
2439                 goto unlock;
2440
2441         private->phantom_switch[index] = val;
2442
2443         /* Send switch change to the device */
2444         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2445                                        index, val);
2446         if (err == 0)
2447                 err = 1;
2448
2449 unlock:
2450         mutex_unlock(&private->data_mutex);
2451         return err;
2452 }
2453
2454 static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
2455         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2456         .name = "",
2457         .info = snd_ctl_boolean_mono_info,
2458         .get  = scarlett2_phantom_ctl_get,
2459         .put  = scarlett2_phantom_ctl_put,
2460 };
2461
2462 /*** Phantom Persistence Control ***/
2463
2464 static int scarlett2_phantom_persistence_ctl_get(
2465         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2466 {
2467         struct usb_mixer_elem_info *elem = kctl->private_data;
2468         struct scarlett2_data *private = elem->head.mixer->private_data;
2469
2470         ucontrol->value.integer.value[0] = private->phantom_persistence;
2471         return 0;
2472 }
2473
2474 static int scarlett2_phantom_persistence_ctl_put(
2475         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2476 {
2477         struct usb_mixer_elem_info *elem = kctl->private_data;
2478         struct usb_mixer_interface *mixer = elem->head.mixer;
2479         struct scarlett2_data *private = mixer->private_data;
2480
2481         int index = elem->control;
2482         int oval, val, err = 0;
2483
2484         mutex_lock(&private->data_mutex);
2485
2486         oval = private->phantom_persistence;
2487         val = !!ucontrol->value.integer.value[0];
2488
2489         if (oval == val)
2490                 goto unlock;
2491
2492         private->phantom_persistence = val;
2493
2494         /* Send switch change to the device */
2495         err = scarlett2_usb_set_config(
2496                 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
2497         if (err == 0)
2498                 err = 1;
2499
2500 unlock:
2501         mutex_unlock(&private->data_mutex);
2502         return err;
2503 }
2504
2505 static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
2506         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2507         .name = "",
2508         .info = snd_ctl_boolean_mono_info,
2509         .get  = scarlett2_phantom_persistence_ctl_get,
2510         .put  = scarlett2_phantom_persistence_ctl_put,
2511 };
2512
2513 /*** Direct Monitor Control ***/
2514
2515 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
2516 {
2517         struct scarlett2_data *private = mixer->private_data;
2518         const struct scarlett2_device_info *info = private->info;
2519         int err;
2520
2521         /* monitor_other_enable[0] enables speaker switching
2522          * monitor_other_enable[1] enables talkback
2523          */
2524         u8 monitor_other_enable[2];
2525
2526         /* monitor_other_switch[0] activates the alternate speakers
2527          * monitor_other_switch[1] activates talkback
2528          */
2529         u8 monitor_other_switch[2];
2530
2531         private->monitor_other_updated = 0;
2532
2533         if (info->direct_monitor)
2534                 return scarlett2_usb_get_config(
2535                         mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
2536                         1, &private->direct_monitor_switch);
2537
2538         /* if it doesn't do speaker switching then it also doesn't do
2539          * talkback
2540          */
2541         if (!info->has_speaker_switching)
2542                 return 0;
2543
2544         err = scarlett2_usb_get_config(
2545                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2546                 2, monitor_other_enable);
2547         if (err < 0)
2548                 return err;
2549
2550         err = scarlett2_usb_get_config(
2551                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2552                 2, monitor_other_switch);
2553         if (err < 0)
2554                 return err;
2555
2556         if (!monitor_other_enable[0])
2557                 private->speaker_switching_switch = 0;
2558         else
2559                 private->speaker_switching_switch = monitor_other_switch[0] + 1;
2560
2561         if (info->has_talkback) {
2562                 const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2563                         info->port_count;
2564                 int num_mixes =
2565                         port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2566                 u16 bitmap;
2567                 int i;
2568
2569                 if (!monitor_other_enable[1])
2570                         private->talkback_switch = 0;
2571                 else
2572                         private->talkback_switch = monitor_other_switch[1] + 1;
2573
2574                 err = scarlett2_usb_get_config(mixer,
2575                                                SCARLETT2_CONFIG_TALKBACK_MAP,
2576                                                1, &bitmap);
2577                 if (err < 0)
2578                         return err;
2579                 for (i = 0; i < num_mixes; i++, bitmap >>= 1)
2580                         private->talkback_map[i] = bitmap & 1;
2581         }
2582
2583         return 0;
2584 }
2585
2586 static int scarlett2_direct_monitor_ctl_get(
2587         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2588 {
2589         struct usb_mixer_elem_info *elem = kctl->private_data;
2590         struct usb_mixer_interface *mixer = elem->head.mixer;
2591         struct scarlett2_data *private = elem->head.mixer->private_data;
2592
2593         mutex_lock(&private->data_mutex);
2594         if (private->monitor_other_updated)
2595                 scarlett2_update_monitor_other(mixer);
2596         ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
2597         mutex_unlock(&private->data_mutex);
2598
2599         return 0;
2600 }
2601
2602 static int scarlett2_direct_monitor_ctl_put(
2603         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2604 {
2605         struct usb_mixer_elem_info *elem = kctl->private_data;
2606         struct usb_mixer_interface *mixer = elem->head.mixer;
2607         struct scarlett2_data *private = mixer->private_data;
2608
2609         int index = elem->control;
2610         int oval, val, err = 0;
2611
2612         mutex_lock(&private->data_mutex);
2613
2614         oval = private->direct_monitor_switch;
2615         val = min(ucontrol->value.enumerated.item[0], 2U);
2616
2617         if (oval == val)
2618                 goto unlock;
2619
2620         private->direct_monitor_switch = val;
2621
2622         /* Send switch change to the device */
2623         err = scarlett2_usb_set_config(
2624                 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
2625         if (err == 0)
2626                 err = 1;
2627
2628 unlock:
2629         mutex_unlock(&private->data_mutex);
2630         return err;
2631 }
2632
2633 static int scarlett2_direct_monitor_stereo_enum_ctl_info(
2634         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2635 {
2636         static const char *const values[3] = {
2637                 "Off", "Mono", "Stereo"
2638         };
2639
2640         return snd_ctl_enum_info(uinfo, 1, 3, values);
2641 }
2642
2643 /* Direct Monitor for Solo is mono-only and only needs a boolean control
2644  * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
2645  */
2646 static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
2647         {
2648                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2649                 .name = "",
2650                 .info = snd_ctl_boolean_mono_info,
2651                 .get  = scarlett2_direct_monitor_ctl_get,
2652                 .put  = scarlett2_direct_monitor_ctl_put,
2653         },
2654         {
2655                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2656                 .name = "",
2657                 .info = scarlett2_direct_monitor_stereo_enum_ctl_info,
2658                 .get  = scarlett2_direct_monitor_ctl_get,
2659                 .put  = scarlett2_direct_monitor_ctl_put,
2660         }
2661 };
2662
2663 static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer)
2664 {
2665         struct scarlett2_data *private = mixer->private_data;
2666         const struct scarlett2_device_info *info = private->info;
2667         const char *s;
2668
2669         if (!info->direct_monitor)
2670                 return 0;
2671
2672         s = info->direct_monitor == 1
2673               ? "Direct Monitor Playback Switch"
2674               : "Direct Monitor Playback Enum";
2675
2676         return scarlett2_add_new_ctl(
2677                 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
2678                 0, 1, s, &private->direct_monitor_ctl);
2679 }
2680
2681 /*** Speaker Switching Control ***/
2682
2683 static int scarlett2_speaker_switch_enum_ctl_info(
2684         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2685 {
2686         static const char *const values[3] = {
2687                 "Off", "Main", "Alt"
2688         };
2689
2690         return snd_ctl_enum_info(uinfo, 1, 3, values);
2691 }
2692
2693 static int scarlett2_speaker_switch_enum_ctl_get(
2694         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2695 {
2696         struct usb_mixer_elem_info *elem = kctl->private_data;
2697         struct usb_mixer_interface *mixer = elem->head.mixer;
2698         struct scarlett2_data *private = mixer->private_data;
2699
2700         mutex_lock(&private->data_mutex);
2701         if (private->monitor_other_updated)
2702                 scarlett2_update_monitor_other(mixer);
2703         ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
2704         mutex_unlock(&private->data_mutex);
2705
2706         return 0;
2707 }
2708
2709 /* when speaker switching gets enabled, switch the main/alt speakers
2710  * to HW volume and disable those controls
2711  */
2712 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
2713 {
2714         struct snd_card *card = mixer->chip->card;
2715         struct scarlett2_data *private = mixer->private_data;
2716         int i, err;
2717
2718         for (i = 0; i < 4; i++) {
2719                 int index = line_out_remap(private, i);
2720
2721                 /* switch the main/alt speakers to HW volume */
2722                 if (!private->vol_sw_hw_switch[index]) {
2723                         err = scarlett2_sw_hw_change(private->mixer, i, 1);
2724                         if (err < 0)
2725                                 return err;
2726                 }
2727
2728                 /* disable the line out SW/HW switch */
2729                 scarlett2_sw_hw_ctl_ro(private, i);
2730                 snd_ctl_notify(card,
2731                                SNDRV_CTL_EVENT_MASK_VALUE |
2732                                  SNDRV_CTL_EVENT_MASK_INFO,
2733                                &private->sw_hw_ctls[i]->id);
2734         }
2735
2736         /* when the next monitor-other notify comes in, update the mux
2737          * configuration
2738          */
2739         private->speaker_switching_switched = 1;
2740
2741         return 0;
2742 }
2743
2744 /* when speaker switching gets disabled, reenable the hw/sw controls
2745  * and invalidate the routing
2746  */
2747 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
2748 {
2749         struct snd_card *card = mixer->chip->card;
2750         struct scarlett2_data *private = mixer->private_data;
2751         int i;
2752
2753         /* enable the line out SW/HW switch */
2754         for (i = 0; i < 4; i++) {
2755                 scarlett2_sw_hw_ctl_rw(private, i);
2756                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2757                                &private->sw_hw_ctls[i]->id);
2758         }
2759
2760         /* when the next monitor-other notify comes in, update the mux
2761          * configuration
2762          */
2763         private->speaker_switching_switched = 1;
2764 }
2765
2766 static int scarlett2_speaker_switch_enum_ctl_put(
2767         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2768 {
2769         struct usb_mixer_elem_info *elem = kctl->private_data;
2770         struct usb_mixer_interface *mixer = elem->head.mixer;
2771         struct scarlett2_data *private = mixer->private_data;
2772
2773         int oval, val, err = 0;
2774
2775         mutex_lock(&private->data_mutex);
2776
2777         oval = private->speaker_switching_switch;
2778         val = min(ucontrol->value.enumerated.item[0], 2U);
2779
2780         if (oval == val)
2781                 goto unlock;
2782
2783         private->speaker_switching_switch = val;
2784
2785         /* enable/disable speaker switching */
2786         err = scarlett2_usb_set_config(
2787                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2788                 0, !!val);
2789         if (err < 0)
2790                 goto unlock;
2791
2792         /* if speaker switching is enabled, select main or alt */
2793         err = scarlett2_usb_set_config(
2794                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2795                 0, val == 2);
2796         if (err < 0)
2797                 goto unlock;
2798
2799         /* update controls if speaker switching gets enabled or disabled */
2800         if (!oval && val)
2801                 err = scarlett2_speaker_switch_enable(mixer);
2802         else if (oval && !val)
2803                 scarlett2_speaker_switch_disable(mixer);
2804
2805         if (err == 0)
2806                 err = 1;
2807
2808 unlock:
2809         mutex_unlock(&private->data_mutex);
2810         return err;
2811 }
2812
2813 static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
2814         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2815         .name = "",
2816         .info = scarlett2_speaker_switch_enum_ctl_info,
2817         .get  = scarlett2_speaker_switch_enum_ctl_get,
2818         .put  = scarlett2_speaker_switch_enum_ctl_put,
2819 };
2820
2821 static int scarlett2_add_speaker_switch_ctl(
2822         struct usb_mixer_interface *mixer)
2823 {
2824         struct scarlett2_data *private = mixer->private_data;
2825         const struct scarlett2_device_info *info = private->info;
2826
2827         if (!info->has_speaker_switching)
2828                 return 0;
2829
2830         return scarlett2_add_new_ctl(
2831                 mixer, &scarlett2_speaker_switch_enum_ctl,
2832                 0, 1, "Speaker Switching Playback Enum",
2833                 &private->speaker_switching_ctl);
2834 }
2835
2836 /*** Talkback and Talkback Map Controls ***/
2837
2838 static int scarlett2_talkback_enum_ctl_info(
2839         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2840 {
2841         static const char *const values[3] = {
2842                 "Disabled", "Off", "On"
2843         };
2844
2845         return snd_ctl_enum_info(uinfo, 1, 3, values);
2846 }
2847
2848 static int scarlett2_talkback_enum_ctl_get(
2849         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2850 {
2851         struct usb_mixer_elem_info *elem = kctl->private_data;
2852         struct usb_mixer_interface *mixer = elem->head.mixer;
2853         struct scarlett2_data *private = mixer->private_data;
2854
2855         mutex_lock(&private->data_mutex);
2856         if (private->monitor_other_updated)
2857                 scarlett2_update_monitor_other(mixer);
2858         ucontrol->value.enumerated.item[0] = private->talkback_switch;
2859         mutex_unlock(&private->data_mutex);
2860
2861         return 0;
2862 }
2863
2864 static int scarlett2_talkback_enum_ctl_put(
2865         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2866 {
2867         struct usb_mixer_elem_info *elem = kctl->private_data;
2868         struct usb_mixer_interface *mixer = elem->head.mixer;
2869         struct scarlett2_data *private = mixer->private_data;
2870
2871         int oval, val, err = 0;
2872
2873         mutex_lock(&private->data_mutex);
2874
2875         oval = private->talkback_switch;
2876         val = min(ucontrol->value.enumerated.item[0], 2U);
2877
2878         if (oval == val)
2879                 goto unlock;
2880
2881         private->talkback_switch = val;
2882
2883         /* enable/disable talkback */
2884         err = scarlett2_usb_set_config(
2885                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2886                 1, !!val);
2887         if (err < 0)
2888                 goto unlock;
2889
2890         /* if talkback is enabled, select main or alt */
2891         err = scarlett2_usb_set_config(
2892                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2893                 1, val == 2);
2894         if (err == 0)
2895                 err = 1;
2896
2897 unlock:
2898         mutex_unlock(&private->data_mutex);
2899         return err;
2900 }
2901
2902 static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
2903         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2904         .name = "",
2905         .info = scarlett2_talkback_enum_ctl_info,
2906         .get  = scarlett2_talkback_enum_ctl_get,
2907         .put  = scarlett2_talkback_enum_ctl_put,
2908 };
2909
2910 static int scarlett2_talkback_map_ctl_get(
2911         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2912 {
2913         struct usb_mixer_elem_info *elem = kctl->private_data;
2914         struct usb_mixer_interface *mixer = elem->head.mixer;
2915         struct scarlett2_data *private = mixer->private_data;
2916         int index = elem->control;
2917
2918         ucontrol->value.integer.value[0] = private->talkback_map[index];
2919
2920         return 0;
2921 }
2922
2923 static int scarlett2_talkback_map_ctl_put(
2924         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2925 {
2926         struct usb_mixer_elem_info *elem = kctl->private_data;
2927         struct usb_mixer_interface *mixer = elem->head.mixer;
2928         struct scarlett2_data *private = mixer->private_data;
2929         const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2930                 private->info->port_count;
2931         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2932
2933         int index = elem->control;
2934         int oval, val, err = 0, i;
2935         u16 bitmap = 0;
2936
2937         mutex_lock(&private->data_mutex);
2938
2939         oval = private->talkback_map[index];
2940         val = !!ucontrol->value.integer.value[0];
2941
2942         if (oval == val)
2943                 goto unlock;
2944
2945         private->talkback_map[index] = val;
2946
2947         for (i = 0; i < num_mixes; i++)
2948                 bitmap |= private->talkback_map[i] << i;
2949
2950         /* Send updated bitmap to the device */
2951         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
2952                                        0, bitmap);
2953         if (err == 0)
2954                 err = 1;
2955
2956 unlock:
2957         mutex_unlock(&private->data_mutex);
2958         return err;
2959 }
2960
2961 static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
2962         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2963         .name = "",
2964         .info = snd_ctl_boolean_mono_info,
2965         .get  = scarlett2_talkback_map_ctl_get,
2966         .put  = scarlett2_talkback_map_ctl_put,
2967 };
2968
2969 static int scarlett2_add_talkback_ctls(
2970         struct usb_mixer_interface *mixer)
2971 {
2972         struct scarlett2_data *private = mixer->private_data;
2973         const struct scarlett2_device_info *info = private->info;
2974         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2975         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2976         int err, i;
2977         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2978
2979         if (!info->has_talkback)
2980                 return 0;
2981
2982         err = scarlett2_add_new_ctl(
2983                 mixer, &scarlett2_talkback_enum_ctl,
2984                 0, 1, "Talkback Playback Enum",
2985                 &private->talkback_ctl);
2986         if (err < 0)
2987                 return err;
2988
2989         for (i = 0; i < num_mixes; i++) {
2990                 snprintf(s, sizeof(s),
2991                          "Talkback Mix %c Playback Switch", i + 'A');
2992                 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
2993                                             i, 1, s, NULL);
2994                 if (err < 0)
2995                         return err;
2996         }
2997
2998         return 0;
2999 }
3000
3001 /*** Dim/Mute Controls ***/
3002
3003 static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
3004                                       struct snd_ctl_elem_value *ucontrol)
3005 {
3006         struct usb_mixer_elem_info *elem = kctl->private_data;
3007         struct usb_mixer_interface *mixer = elem->head.mixer;
3008         struct scarlett2_data *private = mixer->private_data;
3009
3010         mutex_lock(&private->data_mutex);
3011         if (private->vol_updated)
3012                 scarlett2_update_volumes(mixer);
3013         mutex_unlock(&private->data_mutex);
3014
3015         ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
3016         return 0;
3017 }
3018
3019 static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
3020                                       struct snd_ctl_elem_value *ucontrol)
3021 {
3022         struct usb_mixer_elem_info *elem = kctl->private_data;
3023         struct usb_mixer_interface *mixer = elem->head.mixer;
3024         struct scarlett2_data *private = mixer->private_data;
3025         const struct scarlett2_device_info *info = private->info;
3026         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3027         int num_line_out =
3028                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3029
3030         int index = elem->control;
3031         int oval, val, err = 0, i;
3032
3033         mutex_lock(&private->data_mutex);
3034
3035         oval = private->dim_mute[index];
3036         val = !!ucontrol->value.integer.value[0];
3037
3038         if (oval == val)
3039                 goto unlock;
3040
3041         private->dim_mute[index] = val;
3042
3043         /* Send switch change to the device */
3044         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
3045                                        index, val);
3046         if (err == 0)
3047                 err = 1;
3048
3049         if (index == SCARLETT2_BUTTON_MUTE)
3050                 for (i = 0; i < num_line_out; i++) {
3051                         int line_index = line_out_remap(private, i);
3052
3053                         if (private->vol_sw_hw_switch[line_index]) {
3054                                 private->mute_switch[line_index] = val;
3055                                 snd_ctl_notify(mixer->chip->card,
3056                                                SNDRV_CTL_EVENT_MASK_VALUE,
3057                                                &private->mute_ctls[i]->id);
3058                         }
3059                 }
3060
3061 unlock:
3062         mutex_unlock(&private->data_mutex);
3063         return err;
3064 }
3065
3066 static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
3067         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3068         .name = "",
3069         .info = snd_ctl_boolean_mono_info,
3070         .get  = scarlett2_dim_mute_ctl_get,
3071         .put  = scarlett2_dim_mute_ctl_put
3072 };
3073
3074 /*** Create the analogue output controls ***/
3075
3076 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
3077 {
3078         struct scarlett2_data *private = mixer->private_data;
3079         const struct scarlett2_device_info *info = private->info;
3080         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3081         int num_line_out =
3082                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3083         int err, i;
3084         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3085
3086         /* Add R/O HW volume control */
3087         if (info->line_out_hw_vol) {
3088                 snprintf(s, sizeof(s), "Master HW Playback Volume");
3089                 err = scarlett2_add_new_ctl(mixer,
3090                                             &scarlett2_master_volume_ctl,
3091                                             0, 1, s, &private->master_vol_ctl);
3092                 if (err < 0)
3093                         return err;
3094         }
3095
3096         /* Add volume controls */
3097         for (i = 0; i < num_line_out; i++) {
3098                 int index = line_out_remap(private, i);
3099
3100                 /* Fader */
3101                 if (info->line_out_descrs[i])
3102                         snprintf(s, sizeof(s),
3103                                  "Line %02d (%s) Playback Volume",
3104                                  i + 1, info->line_out_descrs[i]);
3105                 else
3106                         snprintf(s, sizeof(s),
3107                                  "Line %02d Playback Volume",
3108                                  i + 1);
3109                 err = scarlett2_add_new_ctl(mixer,
3110                                             &scarlett2_line_out_volume_ctl,
3111                                             i, 1, s, &private->vol_ctls[i]);
3112                 if (err < 0)
3113                         return err;
3114
3115                 /* Mute Switch */
3116                 snprintf(s, sizeof(s),
3117                          "Line %02d Mute Playback Switch",
3118                          i + 1);
3119                 err = scarlett2_add_new_ctl(mixer,
3120                                             &scarlett2_mute_ctl,
3121                                             i, 1, s,
3122                                             &private->mute_ctls[i]);
3123                 if (err < 0)
3124                         return err;
3125
3126                 /* Make the fader and mute controls read-only if the
3127                  * SW/HW switch is set to HW
3128                  */
3129                 if (private->vol_sw_hw_switch[index])
3130                         scarlett2_vol_ctl_set_writable(mixer, i, 0);
3131
3132                 /* SW/HW Switch */
3133                 if (info->line_out_hw_vol) {
3134                         snprintf(s, sizeof(s),
3135                                  "Line Out %02d Volume Control Playback Enum",
3136                                  i + 1);
3137                         err = scarlett2_add_new_ctl(mixer,
3138                                                     &scarlett2_sw_hw_enum_ctl,
3139                                                     i, 1, s,
3140                                                     &private->sw_hw_ctls[i]);
3141                         if (err < 0)
3142                                 return err;
3143
3144                         /* Make the switch read-only if the line is
3145                          * involved in speaker switching
3146                          */
3147                         if (private->speaker_switching_switch && i < 4)
3148                                 scarlett2_sw_hw_ctl_ro(private, i);
3149                 }
3150         }
3151
3152         /* Add dim/mute controls */
3153         if (info->line_out_hw_vol)
3154                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
3155                         err = scarlett2_add_new_ctl(
3156                                 mixer, &scarlett2_dim_mute_ctl,
3157                                 i, 1, scarlett2_dim_mute_names[i],
3158                                 &private->dim_mute_ctls[i]);
3159                         if (err < 0)
3160                                 return err;
3161                 }
3162
3163         return 0;
3164 }
3165
3166 /*** Create the analogue input controls ***/
3167
3168 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
3169 {
3170         struct scarlett2_data *private = mixer->private_data;
3171         const struct scarlett2_device_info *info = private->info;
3172         int err, i;
3173         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3174         const char *fmt = "Line In %d %s Capture %s";
3175         const char *fmt2 = "Line In %d-%d %s Capture %s";
3176
3177         /* Add input level (line/inst) controls */
3178         for (i = 0; i < info->level_input_count; i++) {
3179                 snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
3180                          "Level", "Enum");
3181                 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
3182                                             i, 1, s, &private->level_ctls[i]);
3183                 if (err < 0)
3184                         return err;
3185         }
3186
3187         /* Add input pad controls */
3188         for (i = 0; i < info->pad_input_count; i++) {
3189                 snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
3190                 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
3191                                             i, 1, s, &private->pad_ctls[i]);
3192                 if (err < 0)
3193                         return err;
3194         }
3195
3196         /* Add input air controls */
3197         for (i = 0; i < info->air_input_count; i++) {
3198                 snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch");
3199                 err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl,
3200                                             i, 1, s, &private->air_ctls[i]);
3201                 if (err < 0)
3202                         return err;
3203         }
3204
3205         /* Add input phantom controls */
3206         if (info->inputs_per_phantom == 1) {
3207                 for (i = 0; i < info->phantom_count; i++) {
3208                         snprintf(s, sizeof(s), fmt, i + 1,
3209                                  "Phantom Power", "Switch");
3210                         err = scarlett2_add_new_ctl(
3211                                 mixer, &scarlett2_phantom_ctl,
3212                                 i, 1, s, &private->phantom_ctls[i]);
3213                         if (err < 0)
3214                                 return err;
3215                 }
3216         } else if (info->inputs_per_phantom > 1) {
3217                 for (i = 0; i < info->phantom_count; i++) {
3218                         int from = i * info->inputs_per_phantom + 1;
3219                         int to = (i + 1) * info->inputs_per_phantom;
3220
3221                         snprintf(s, sizeof(s), fmt2, from, to,
3222                                  "Phantom Power", "Switch");
3223                         err = scarlett2_add_new_ctl(
3224                                 mixer, &scarlett2_phantom_ctl,
3225                                 i, 1, s, &private->phantom_ctls[i]);
3226                         if (err < 0)
3227                                 return err;
3228                 }
3229         }
3230         if (info->phantom_count) {
3231                 err = scarlett2_add_new_ctl(
3232                         mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
3233                         "Phantom Power Persistence Capture Switch", NULL);
3234                 if (err < 0)
3235                         return err;
3236         }
3237
3238         return 0;
3239 }
3240
3241 /*** Mixer Volume Controls ***/
3242
3243 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
3244                                     struct snd_ctl_elem_info *uinfo)
3245 {
3246         struct usb_mixer_elem_info *elem = kctl->private_data;
3247
3248         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3249         uinfo->count = elem->channels;
3250         uinfo->value.integer.min = 0;
3251         uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
3252         uinfo->value.integer.step = 1;
3253         return 0;
3254 }
3255
3256 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
3257                                    struct snd_ctl_elem_value *ucontrol)
3258 {
3259         struct usb_mixer_elem_info *elem = kctl->private_data;
3260         struct scarlett2_data *private = elem->head.mixer->private_data;
3261
3262         ucontrol->value.integer.value[0] = private->mix[elem->control];
3263         return 0;
3264 }
3265
3266 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
3267                                    struct snd_ctl_elem_value *ucontrol)
3268 {
3269         struct usb_mixer_elem_info *elem = kctl->private_data;
3270         struct usb_mixer_interface *mixer = elem->head.mixer;
3271         struct scarlett2_data *private = mixer->private_data;
3272         const struct scarlett2_device_info *info = private->info;
3273         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3274         int oval, val, num_mixer_in, mix_num, err = 0;
3275         int index = elem->control;
3276
3277         mutex_lock(&private->data_mutex);
3278
3279         oval = private->mix[index];
3280         val = ucontrol->value.integer.value[0];
3281         num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3282         mix_num = index / num_mixer_in;
3283
3284         if (oval == val)
3285                 goto unlock;
3286
3287         private->mix[index] = val;
3288         err = scarlett2_usb_set_mix(mixer, mix_num);
3289         if (err == 0)
3290                 err = 1;
3291
3292 unlock:
3293         mutex_unlock(&private->data_mutex);
3294         return err;
3295 }
3296
3297 static const DECLARE_TLV_DB_MINMAX(
3298         db_scale_scarlett2_mixer,
3299         SCARLETT2_MIXER_MIN_DB * 100,
3300         SCARLETT2_MIXER_MAX_DB * 100
3301 );
3302
3303 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
3304         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3305         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3306                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3307         .name = "",
3308         .info = scarlett2_mixer_ctl_info,
3309         .get  = scarlett2_mixer_ctl_get,
3310         .put  = scarlett2_mixer_ctl_put,
3311         .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
3312         .tlv = { .p = db_scale_scarlett2_mixer }
3313 };
3314
3315 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
3316 {
3317         struct scarlett2_data *private = mixer->private_data;
3318         const struct scarlett2_device_info *info = private->info;
3319         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3320         int err, i, j;
3321         int index;
3322         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3323
3324         int num_inputs =
3325                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3326         int num_outputs =
3327                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3328
3329         for (i = 0, index = 0; i < num_outputs; i++)
3330                 for (j = 0; j < num_inputs; j++, index++) {
3331                         snprintf(s, sizeof(s),
3332                                  "Mix %c Input %02d Playback Volume",
3333                                  'A' + i, j + 1);
3334                         err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
3335                                                     index, 1, s, NULL);
3336                         if (err < 0)
3337                                 return err;
3338                 }
3339
3340         return 0;
3341 }
3342
3343 /*** Mux Source Selection Controls ***/
3344
3345 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
3346                                            struct snd_ctl_elem_info *uinfo)
3347 {
3348         struct usb_mixer_elem_info *elem = kctl->private_data;
3349         struct scarlett2_data *private = elem->head.mixer->private_data;
3350         const struct scarlett2_device_info *info = private->info;
3351         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3352         unsigned int item = uinfo->value.enumerated.item;
3353         int items = private->num_mux_srcs;
3354         int port_type;
3355
3356         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3357         uinfo->count = elem->channels;
3358         uinfo->value.enumerated.items = items;
3359
3360         if (item >= items)
3361                 item = uinfo->value.enumerated.item = items - 1;
3362
3363         for (port_type = 0;
3364              port_type < SCARLETT2_PORT_TYPE_COUNT;
3365              port_type++) {
3366                 if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
3367                         const struct scarlett2_port *port =
3368                                 &scarlett2_ports[port_type];
3369
3370                         sprintf(uinfo->value.enumerated.name,
3371                                 port->src_descr, item + port->src_num_offset);
3372                         return 0;
3373                 }
3374                 item -= port_count[port_type][SCARLETT2_PORT_IN];
3375         }
3376
3377         return -EINVAL;
3378 }
3379
3380 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
3381                                           struct snd_ctl_elem_value *ucontrol)
3382 {
3383         struct usb_mixer_elem_info *elem = kctl->private_data;
3384         struct usb_mixer_interface *mixer = elem->head.mixer;
3385         struct scarlett2_data *private = mixer->private_data;
3386         const struct scarlett2_device_info *info = private->info;
3387         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3388         int line_out_count =
3389                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3390         int index = elem->control;
3391
3392         if (index < line_out_count)
3393                 index = line_out_remap(private, index);
3394
3395         mutex_lock(&private->data_mutex);
3396         if (private->mux_updated)
3397                 scarlett2_usb_get_mux(mixer);
3398         ucontrol->value.enumerated.item[0] = private->mux[index];
3399         mutex_unlock(&private->data_mutex);
3400
3401         return 0;
3402 }
3403
3404 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
3405                                           struct snd_ctl_elem_value *ucontrol)
3406 {
3407         struct usb_mixer_elem_info *elem = kctl->private_data;
3408         struct usb_mixer_interface *mixer = elem->head.mixer;
3409         struct scarlett2_data *private = mixer->private_data;
3410         const struct scarlett2_device_info *info = private->info;
3411         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3412         int line_out_count =
3413                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3414         int index = elem->control;
3415         int oval, val, err = 0;
3416
3417         if (index < line_out_count)
3418                 index = line_out_remap(private, index);
3419
3420         mutex_lock(&private->data_mutex);
3421
3422         oval = private->mux[index];
3423         val = min(ucontrol->value.enumerated.item[0],
3424                   private->num_mux_srcs - 1U);
3425
3426         if (oval == val)
3427                 goto unlock;
3428
3429         private->mux[index] = val;
3430         err = scarlett2_usb_set_mux(mixer);
3431         if (err == 0)
3432                 err = 1;
3433
3434 unlock:
3435         mutex_unlock(&private->data_mutex);
3436         return err;
3437 }
3438
3439 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
3440         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3441         .name = "",
3442         .info = scarlett2_mux_src_enum_ctl_info,
3443         .get  = scarlett2_mux_src_enum_ctl_get,
3444         .put  = scarlett2_mux_src_enum_ctl_put,
3445 };
3446
3447 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
3448 {
3449         struct scarlett2_data *private = mixer->private_data;
3450         const struct scarlett2_device_info *info = private->info;
3451         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3452         int port_type, channel, i;
3453
3454         for (i = 0, port_type = 0;
3455              port_type < SCARLETT2_PORT_TYPE_COUNT;
3456              port_type++) {
3457                 for (channel = 0;
3458                      channel < port_count[port_type][SCARLETT2_PORT_OUT];
3459                      channel++, i++) {
3460                         int err;
3461                         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3462                         const char *const descr =
3463                                 scarlett2_ports[port_type].dst_descr;
3464
3465                         snprintf(s, sizeof(s) - 5, descr, channel + 1);
3466                         strcat(s, " Enum");
3467
3468                         err = scarlett2_add_new_ctl(mixer,
3469                                                     &scarlett2_mux_src_enum_ctl,
3470                                                     i, 1, s,
3471                                                     &private->mux_ctls[i]);
3472                         if (err < 0)
3473                                 return err;
3474                 }
3475         }
3476
3477         return 0;
3478 }
3479
3480 /*** Meter Controls ***/
3481
3482 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
3483                                     struct snd_ctl_elem_info *uinfo)
3484 {
3485         struct usb_mixer_elem_info *elem = kctl->private_data;
3486
3487         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3488         uinfo->count = elem->channels;
3489         uinfo->value.integer.min = 0;
3490         uinfo->value.integer.max = 4095;
3491         uinfo->value.integer.step = 1;
3492         return 0;
3493 }
3494
3495 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
3496                                    struct snd_ctl_elem_value *ucontrol)
3497 {
3498         struct usb_mixer_elem_info *elem = kctl->private_data;
3499         u16 meter_levels[SCARLETT2_MAX_METERS];
3500         int i, err;
3501
3502         err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels,
3503                                              meter_levels);
3504         if (err < 0)
3505                 return err;
3506
3507         for (i = 0; i < elem->channels; i++)
3508                 ucontrol->value.integer.value[i] = meter_levels[i];
3509
3510         return 0;
3511 }
3512
3513 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
3514         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
3515         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3516         .name = "",
3517         .info = scarlett2_meter_ctl_info,
3518         .get  = scarlett2_meter_ctl_get
3519 };
3520
3521 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
3522 {
3523         struct scarlett2_data *private = mixer->private_data;
3524
3525         /* devices without a mixer also don't support reporting levels */
3526         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3527                 return 0;
3528
3529         return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
3530                                      0, private->num_mux_dsts,
3531                                      "Level Meter", NULL);
3532 }
3533
3534 /*** MSD Controls ***/
3535
3536 static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
3537                                  struct snd_ctl_elem_value *ucontrol)
3538 {
3539         struct usb_mixer_elem_info *elem = kctl->private_data;
3540         struct scarlett2_data *private = elem->head.mixer->private_data;
3541
3542         ucontrol->value.integer.value[0] = private->msd_switch;
3543         return 0;
3544 }
3545
3546 static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
3547                                  struct snd_ctl_elem_value *ucontrol)
3548 {
3549         struct usb_mixer_elem_info *elem = kctl->private_data;
3550         struct usb_mixer_interface *mixer = elem->head.mixer;
3551         struct scarlett2_data *private = mixer->private_data;
3552
3553         int oval, val, err = 0;
3554
3555         mutex_lock(&private->data_mutex);
3556
3557         oval = private->msd_switch;
3558         val = !!ucontrol->value.integer.value[0];
3559
3560         if (oval == val)
3561                 goto unlock;
3562
3563         private->msd_switch = val;
3564
3565         /* Send switch change to the device */
3566         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3567                                        0, val);
3568         if (err == 0)
3569                 err = 1;
3570
3571 unlock:
3572         mutex_unlock(&private->data_mutex);
3573         return err;
3574 }
3575
3576 static const struct snd_kcontrol_new scarlett2_msd_ctl = {
3577         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3578         .name = "",
3579         .info = snd_ctl_boolean_mono_info,
3580         .get  = scarlett2_msd_ctl_get,
3581         .put  = scarlett2_msd_ctl_put,
3582 };
3583
3584 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
3585 {
3586         struct scarlett2_data *private = mixer->private_data;
3587         const struct scarlett2_device_info *info = private->info;
3588
3589         if (!info->has_msd_mode)
3590                 return 0;
3591
3592         /* If MSD mode is off, hide the switch by default */
3593         if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
3594                 return 0;
3595
3596         /* Add MSD control */
3597         return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
3598                                      0, 1, "MSD Mode Switch", NULL);
3599 }
3600
3601 /*** Standalone Control ***/
3602
3603 static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,
3604                                         struct snd_ctl_elem_value *ucontrol)
3605 {
3606         struct usb_mixer_elem_info *elem = kctl->private_data;
3607         struct scarlett2_data *private = elem->head.mixer->private_data;
3608
3609         ucontrol->value.integer.value[0] = private->standalone_switch;
3610         return 0;
3611 }
3612
3613 static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,
3614                                         struct snd_ctl_elem_value *ucontrol)
3615 {
3616         struct usb_mixer_elem_info *elem = kctl->private_data;
3617         struct usb_mixer_interface *mixer = elem->head.mixer;
3618         struct scarlett2_data *private = mixer->private_data;
3619
3620         int oval, val, err = 0;
3621
3622         mutex_lock(&private->data_mutex);
3623
3624         oval = private->standalone_switch;
3625         val = !!ucontrol->value.integer.value[0];
3626
3627         if (oval == val)
3628                 goto unlock;
3629
3630         private->standalone_switch = val;
3631
3632         /* Send switch change to the device */
3633         err = scarlett2_usb_set_config(mixer,
3634                                        SCARLETT2_CONFIG_STANDALONE_SWITCH,
3635                                        0, val);
3636         if (err == 0)
3637                 err = 1;
3638
3639 unlock:
3640         mutex_unlock(&private->data_mutex);
3641         return err;
3642 }
3643
3644 static const struct snd_kcontrol_new scarlett2_standalone_ctl = {
3645         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3646         .name = "",
3647         .info = snd_ctl_boolean_mono_info,
3648         .get  = scarlett2_standalone_ctl_get,
3649         .put  = scarlett2_standalone_ctl_put,
3650 };
3651
3652 static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
3653 {
3654         struct scarlett2_data *private = mixer->private_data;
3655
3656         if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3657                 return 0;
3658
3659         /* Add standalone control */
3660         return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
3661                                      0, 1, "Standalone Switch", NULL);
3662 }
3663
3664 /*** Cleanup/Suspend Callbacks ***/
3665
3666 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
3667 {
3668         struct scarlett2_data *private = mixer->private_data;
3669
3670         cancel_delayed_work_sync(&private->work);
3671         kfree(private);
3672         mixer->private_data = NULL;
3673 }
3674
3675 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
3676 {
3677         struct scarlett2_data *private = mixer->private_data;
3678
3679         if (cancel_delayed_work_sync(&private->work))
3680                 scarlett2_config_save(private->mixer);
3681 }
3682
3683 /*** Initialisation ***/
3684
3685 static void scarlett2_count_mux_io(struct scarlett2_data *private)
3686 {
3687         const struct scarlett2_device_info *info = private->info;
3688         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3689         int port_type, srcs = 0, dsts = 0;
3690
3691         for (port_type = 0;
3692              port_type < SCARLETT2_PORT_TYPE_COUNT;
3693              port_type++) {
3694                 srcs += port_count[port_type][SCARLETT2_PORT_IN];
3695                 dsts += port_count[port_type][SCARLETT2_PORT_OUT];
3696         }
3697
3698         private->num_mux_srcs = srcs;
3699         private->num_mux_dsts = dsts;
3700 }
3701
3702 /* Look through the interface descriptors for the Focusrite Control
3703  * interface (bInterfaceClass = 255 Vendor Specific Class) and set
3704  * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
3705  * in private
3706  */
3707 static int scarlett2_find_fc_interface(struct usb_device *dev,
3708                                        struct scarlett2_data *private)
3709 {
3710         struct usb_host_config *config = dev->actconfig;
3711         int i;
3712
3713         for (i = 0; i < config->desc.bNumInterfaces; i++) {
3714                 struct usb_interface *intf = config->interface[i];
3715                 struct usb_interface_descriptor *desc =
3716                         &intf->altsetting[0].desc;
3717                 struct usb_endpoint_descriptor *epd;
3718
3719                 if (desc->bInterfaceClass != 255)
3720                         continue;
3721
3722                 epd = get_endpoint(intf->altsetting, 0);
3723                 private->bInterfaceNumber = desc->bInterfaceNumber;
3724                 private->bEndpointAddress = epd->bEndpointAddress &
3725                         USB_ENDPOINT_NUMBER_MASK;
3726                 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
3727                 private->bInterval = epd->bInterval;
3728                 return 0;
3729         }
3730
3731         return -EINVAL;
3732 }
3733
3734 /* Initialise private data */
3735 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
3736                                   const struct scarlett2_device_info *info)
3737 {
3738         struct scarlett2_data *private =
3739                 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
3740
3741         if (!private)
3742                 return -ENOMEM;
3743
3744         mutex_init(&private->usb_mutex);
3745         mutex_init(&private->data_mutex);
3746         INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
3747
3748         mixer->private_data = private;
3749         mixer->private_free = scarlett2_private_free;
3750         mixer->private_suspend = scarlett2_private_suspend;
3751
3752         private->info = info;
3753         scarlett2_count_mux_io(private);
3754         private->scarlett2_seq = 0;
3755         private->mixer = mixer;
3756
3757         return scarlett2_find_fc_interface(mixer->chip->dev, private);
3758 }
3759
3760 /* Cargo cult proprietary initialisation sequence */
3761 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
3762 {
3763         struct usb_device *dev = mixer->chip->dev;
3764         struct scarlett2_data *private = mixer->private_data;
3765         u8 buf[24];
3766         int err;
3767
3768         if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
3769                 return -EINVAL;
3770
3771         /* step 0 */
3772         err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
3773                                SCARLETT2_USB_CMD_INIT, buf, sizeof(buf));
3774         if (err < 0)
3775                 return err;
3776
3777         /* step 1 */
3778         private->scarlett2_seq = 1;
3779         err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
3780         if (err < 0)
3781                 return err;
3782
3783         /* step 2 */
3784         private->scarlett2_seq = 1;
3785         return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84);
3786 }
3787
3788 /* Read configuration from the interface on start */
3789 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
3790 {
3791         struct scarlett2_data *private = mixer->private_data;
3792         const struct scarlett2_device_info *info = private->info;
3793         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3794         int num_line_out =
3795                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3796         int num_mixer_out =
3797                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3798         struct scarlett2_usb_volume_status volume_status;
3799         int err, i;
3800
3801         if (info->has_msd_mode) {
3802                 err = scarlett2_usb_get_config(
3803                         mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3804                         1, &private->msd_switch);
3805                 if (err < 0)
3806                         return err;
3807
3808                 /* no other controls are created if MSD mode is on */
3809                 if (private->msd_switch)
3810                         return 0;
3811         }
3812
3813         err = scarlett2_update_input_other(mixer);
3814         if (err < 0)
3815                 return err;
3816
3817         err = scarlett2_update_monitor_other(mixer);
3818         if (err < 0)
3819                 return err;
3820
3821         /* the rest of the configuration is for devices with a mixer */
3822         if (info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3823                 return 0;
3824
3825         err = scarlett2_usb_get_config(
3826                 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
3827                 1, &private->standalone_switch);
3828         if (err < 0)
3829                 return err;
3830
3831         err = scarlett2_update_sync(mixer);
3832         if (err < 0)
3833                 return err;
3834
3835         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
3836         if (err < 0)
3837                 return err;
3838
3839         if (info->line_out_hw_vol)
3840                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3841                         private->dim_mute[i] = !!volume_status.dim_mute[i];
3842
3843         private->master_vol = clamp(
3844                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
3845                 0, SCARLETT2_VOLUME_BIAS);
3846
3847         for (i = 0; i < num_line_out; i++) {
3848                 int volume, mute;
3849
3850                 private->vol_sw_hw_switch[i] =
3851                         info->line_out_hw_vol
3852                                 && volume_status.sw_hw_switch[i];
3853
3854                 volume = private->vol_sw_hw_switch[i]
3855                            ? volume_status.master_vol
3856                            : volume_status.sw_vol[i];
3857                 volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
3858                                0, SCARLETT2_VOLUME_BIAS);
3859                 private->vol[i] = volume;
3860
3861                 mute = private->vol_sw_hw_switch[i]
3862                          ? private->dim_mute[SCARLETT2_BUTTON_MUTE]
3863                          : volume_status.mute_switch[i];
3864                 private->mute_switch[i] = mute;
3865         }
3866
3867         for (i = 0; i < num_mixer_out; i++) {
3868                 err = scarlett2_usb_get_mix(mixer, i);
3869                 if (err < 0)
3870                         return err;
3871         }
3872
3873         return scarlett2_usb_get_mux(mixer);
3874 }
3875
3876 /* Notify on sync change */
3877 static void scarlett2_notify_sync(
3878         struct usb_mixer_interface *mixer)
3879 {
3880         struct scarlett2_data *private = mixer->private_data;
3881
3882         private->sync_updated = 1;
3883
3884         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3885                        &private->sync_ctl->id);
3886 }
3887
3888 /* Notify on monitor change */
3889 static void scarlett2_notify_monitor(
3890         struct usb_mixer_interface *mixer)
3891 {
3892         struct snd_card *card = mixer->chip->card;
3893         struct scarlett2_data *private = mixer->private_data;
3894         const struct scarlett2_device_info *info = private->info;
3895         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3896         int num_line_out =
3897                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3898         int i;
3899
3900         /* if line_out_hw_vol is 0, there are no controls to update */
3901         if (!info->line_out_hw_vol)
3902                 return;
3903
3904         private->vol_updated = 1;
3905
3906         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3907                        &private->master_vol_ctl->id);
3908
3909         for (i = 0; i < num_line_out; i++)
3910                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3911                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3912                                        &private->vol_ctls[i]->id);
3913 }
3914
3915 /* Notify on dim/mute change */
3916 static void scarlett2_notify_dim_mute(
3917         struct usb_mixer_interface *mixer)
3918 {
3919         struct snd_card *card = mixer->chip->card;
3920         struct scarlett2_data *private = mixer->private_data;
3921         const struct scarlett2_device_info *info = private->info;
3922         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3923         int num_line_out =
3924                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3925         int i;
3926
3927         private->vol_updated = 1;
3928
3929         if (!info->line_out_hw_vol)
3930                 return;
3931
3932         for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3933                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3934                                &private->dim_mute_ctls[i]->id);
3935
3936         for (i = 0; i < num_line_out; i++)
3937                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3938                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3939                                        &private->mute_ctls[i]->id);
3940 }
3941
3942 /* Notify on "input other" change (level/pad/air) */
3943 static void scarlett2_notify_input_other(
3944         struct usb_mixer_interface *mixer)
3945 {
3946         struct snd_card *card = mixer->chip->card;
3947         struct scarlett2_data *private = mixer->private_data;
3948         const struct scarlett2_device_info *info = private->info;
3949         int i;
3950
3951         private->input_other_updated = 1;
3952
3953         for (i = 0; i < info->level_input_count; i++)
3954                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3955                                &private->level_ctls[i]->id);
3956         for (i = 0; i < info->pad_input_count; i++)
3957                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3958                                &private->pad_ctls[i]->id);
3959         for (i = 0; i < info->air_input_count; i++)
3960                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3961                                &private->air_ctls[i]->id);
3962         for (i = 0; i < info->phantom_count; i++)
3963                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3964                                &private->phantom_ctls[i]->id);
3965 }
3966
3967 /* Notify on "monitor other" change (direct monitor, speaker
3968  * switching, talkback)
3969  */
3970 static void scarlett2_notify_monitor_other(
3971         struct usb_mixer_interface *mixer)
3972 {
3973         struct snd_card *card = mixer->chip->card;
3974         struct scarlett2_data *private = mixer->private_data;
3975         const struct scarlett2_device_info *info = private->info;
3976
3977         private->monitor_other_updated = 1;
3978
3979         if (info->direct_monitor) {
3980                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3981                                &private->direct_monitor_ctl->id);
3982                 return;
3983         }
3984
3985         if (info->has_speaker_switching)
3986                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3987                                &private->speaker_switching_ctl->id);
3988
3989         if (info->has_talkback)
3990                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3991                                &private->talkback_ctl->id);
3992
3993         /* if speaker switching was recently enabled or disabled,
3994          * invalidate the dim/mute and mux enum controls
3995          */
3996         if (private->speaker_switching_switched) {
3997                 int i;
3998
3999                 scarlett2_notify_dim_mute(mixer);
4000
4001                 private->speaker_switching_switched = 0;
4002                 private->mux_updated = 1;
4003
4004                 for (i = 0; i < private->num_mux_dsts; i++)
4005                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
4006                                        &private->mux_ctls[i]->id);
4007         }
4008 }
4009
4010 /* Interrupt callback */
4011 static void scarlett2_notify(struct urb *urb)
4012 {
4013         struct usb_mixer_interface *mixer = urb->context;
4014         int len = urb->actual_length;
4015         int ustatus = urb->status;
4016         u32 data;
4017
4018         if (ustatus != 0 || len != 8)
4019                 goto requeue;
4020
4021         data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
4022         if (data & SCARLETT2_USB_NOTIFY_SYNC)
4023                 scarlett2_notify_sync(mixer);
4024         if (data & SCARLETT2_USB_NOTIFY_MONITOR)
4025                 scarlett2_notify_monitor(mixer);
4026         if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE)
4027                 scarlett2_notify_dim_mute(mixer);
4028         if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER)
4029                 scarlett2_notify_input_other(mixer);
4030         if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER)
4031                 scarlett2_notify_monitor_other(mixer);
4032
4033 requeue:
4034         if (ustatus != -ENOENT &&
4035             ustatus != -ECONNRESET &&
4036             ustatus != -ESHUTDOWN) {
4037                 urb->dev = mixer->chip->dev;
4038                 usb_submit_urb(urb, GFP_ATOMIC);
4039         }
4040 }
4041
4042 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
4043 {
4044         struct usb_device *dev = mixer->chip->dev;
4045         struct scarlett2_data *private = mixer->private_data;
4046         unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
4047         void *transfer_buffer;
4048
4049         if (mixer->urb) {
4050                 usb_audio_err(mixer->chip,
4051                               "%s: mixer urb already in use!\n", __func__);
4052                 return 0;
4053         }
4054
4055         if (usb_pipe_type_check(dev, pipe))
4056                 return -EINVAL;
4057
4058         mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
4059         if (!mixer->urb)
4060                 return -ENOMEM;
4061
4062         transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
4063         if (!transfer_buffer)
4064                 return -ENOMEM;
4065
4066         usb_fill_int_urb(mixer->urb, dev, pipe,
4067                          transfer_buffer, private->wMaxPacketSize,
4068                          scarlett2_notify, mixer, private->bInterval);
4069
4070         return usb_submit_urb(mixer->urb, GFP_KERNEL);
4071 }
4072
4073 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
4074 {
4075         const struct scarlett2_device_info **info = scarlett2_devices;
4076         int err;
4077
4078         /* Find device in scarlett2_devices */
4079         while (*info && (*info)->usb_id != mixer->chip->usb_id)
4080                 info++;
4081         if (!*info)
4082                 return -EINVAL;
4083
4084         /* Initialise private data */
4085         err = scarlett2_init_private(mixer, *info);
4086         if (err < 0)
4087                 return err;
4088
4089         /* Send proprietary USB initialisation sequence */
4090         err = scarlett2_usb_init(mixer);
4091         if (err < 0)
4092                 return err;
4093
4094         /* Read volume levels and controls from the interface */
4095         err = scarlett2_read_configs(mixer);
4096         if (err < 0)
4097                 return err;
4098
4099         /* Create the MSD control */
4100         err = scarlett2_add_msd_ctl(mixer);
4101         if (err < 0)
4102                 return err;
4103
4104         /* If MSD mode is enabled, don't create any other controls */
4105         if (((struct scarlett2_data *)mixer->private_data)->msd_switch)
4106                 return 0;
4107
4108         /* Create the analogue output controls */
4109         err = scarlett2_add_line_out_ctls(mixer);
4110         if (err < 0)
4111                 return err;
4112
4113         /* Create the analogue input controls */
4114         err = scarlett2_add_line_in_ctls(mixer);
4115         if (err < 0)
4116                 return err;
4117
4118         /* Create the input, output, and mixer mux input selections */
4119         err = scarlett2_add_mux_enums(mixer);
4120         if (err < 0)
4121                 return err;
4122
4123         /* Create the matrix mixer controls */
4124         err = scarlett2_add_mixer_ctls(mixer);
4125         if (err < 0)
4126                 return err;
4127
4128         /* Create the level meter controls */
4129         err = scarlett2_add_meter_ctl(mixer);
4130         if (err < 0)
4131                 return err;
4132
4133         /* Create the sync control */
4134         err = scarlett2_add_sync_ctl(mixer);
4135         if (err < 0)
4136                 return err;
4137
4138         /* Create the direct monitor control */
4139         err = scarlett2_add_direct_monitor_ctl(mixer);
4140         if (err < 0)
4141                 return err;
4142
4143         /* Create the speaker switching control */
4144         err = scarlett2_add_speaker_switch_ctl(mixer);
4145         if (err < 0)
4146                 return err;
4147
4148         /* Create the talkback controls */
4149         err = scarlett2_add_talkback_ctls(mixer);
4150         if (err < 0)
4151                 return err;
4152
4153         /* Create the standalone control */
4154         err = scarlett2_add_standalone_ctl(mixer);
4155         if (err < 0)
4156                 return err;
4157
4158         /* Set up the interrupt polling */
4159         err = scarlett2_init_notify(mixer);
4160         if (err < 0)
4161                 return err;
4162
4163         return 0;
4164 }
4165
4166 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
4167 {
4168         struct snd_usb_audio *chip = mixer->chip;
4169         int err;
4170
4171         /* only use UAC_VERSION_2 */
4172         if (!mixer->protocol)
4173                 return 0;
4174
4175         if (!(chip->setup & SCARLETT2_ENABLE)) {
4176                 usb_audio_info(chip,
4177                         "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; "
4178                         "use options snd_usb_audio vid=0x%04x pid=0x%04x "
4179                         "device_setup=1 to enable and report any issues "
4180                         "to g@b4.vu",
4181                         USB_ID_VENDOR(chip->usb_id),
4182                         USB_ID_PRODUCT(chip->usb_id));
4183                 return 0;
4184         }
4185
4186         usb_audio_info(chip,
4187                 "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x",
4188                 USB_ID_PRODUCT(chip->usb_id));
4189
4190         err = snd_scarlett_gen2_controls_create(mixer);
4191         if (err < 0)
4192                 usb_audio_err(mixer->chip,
4193                               "Error initialising Scarlett Mixer Driver: %d",
4194                               err);
4195
4196         return err;
4197 }