sound/usb/mixer_scarlett2.c

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