sound/usb/mixer_scarlett_gen2.c

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