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                 for (i = 0; i < num_mixes; i++, bitmap >>= 1)
2454                         private->talkback_map[i] = bitmap & 1;
2455         }
2456
2457         return 0;
2458 }
2459
2460 static int scarlett2_direct_monitor_ctl_get(
2461         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2462 {
2463         struct usb_mixer_elem_info *elem = kctl->private_data;
2464         struct usb_mixer_interface *mixer = elem->head.mixer;
2465         struct scarlett2_data *private = elem->head.mixer->private_data;
2466
2467         mutex_lock(&private->data_mutex);
2468         if (private->monitor_other_updated)
2469                 scarlett2_update_monitor_other(mixer);
2470         ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
2471         mutex_unlock(&private->data_mutex);
2472
2473         return 0;
2474 }
2475
2476 static int scarlett2_direct_monitor_ctl_put(
2477         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2478 {
2479         struct usb_mixer_elem_info *elem = kctl->private_data;
2480         struct usb_mixer_interface *mixer = elem->head.mixer;
2481         struct scarlett2_data *private = mixer->private_data;
2482
2483         int index = elem->control;
2484         int oval, val, err = 0;
2485
2486         mutex_lock(&private->data_mutex);
2487
2488         oval = private->direct_monitor_switch;
2489         val = min(ucontrol->value.enumerated.item[0], 2U);
2490
2491         if (oval == val)
2492                 goto unlock;
2493
2494         private->direct_monitor_switch = val;
2495
2496         /* Send switch change to the device */
2497         err = scarlett2_usb_set_config(
2498                 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
2499         if (err == 0)
2500                 err = 1;
2501
2502 unlock:
2503         mutex_unlock(&private->data_mutex);
2504         return err;
2505 }
2506
2507 static int scarlett2_direct_monitor_stereo_enum_ctl_info(
2508         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2509 {
2510         static const char *const values[3] = {
2511                 "Off", "Mono", "Stereo"
2512         };
2513
2514         return snd_ctl_enum_info(uinfo, 1, 3, values);
2515 }
2516
2517 /* Direct Monitor for Solo is mono-only and only needs a boolean control
2518  * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
2519  */
2520 static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
2521         {
2522                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2523                 .name = "",
2524                 .info = snd_ctl_boolean_mono_info,
2525                 .get  = scarlett2_direct_monitor_ctl_get,
2526                 .put  = scarlett2_direct_monitor_ctl_put,
2527         },
2528         {
2529                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2530                 .name = "",
2531                 .info = scarlett2_direct_monitor_stereo_enum_ctl_info,
2532                 .get  = scarlett2_direct_monitor_ctl_get,
2533                 .put  = scarlett2_direct_monitor_ctl_put,
2534         }
2535 };
2536
2537 static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer)
2538 {
2539         struct scarlett2_data *private = mixer->private_data;
2540         const struct scarlett2_device_info *info = private->info;
2541         const char *s;
2542
2543         if (!info->direct_monitor)
2544                 return 0;
2545
2546         s = info->direct_monitor == 1
2547               ? "Direct Monitor Playback Switch"
2548               : "Direct Monitor Playback Enum";
2549
2550         return scarlett2_add_new_ctl(
2551                 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
2552                 0, 1, s, &private->direct_monitor_ctl);
2553 }
2554
2555 /*** Speaker Switching Control ***/
2556
2557 static int scarlett2_speaker_switch_enum_ctl_info(
2558         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2559 {
2560         static const char *const values[3] = {
2561                 "Off", "Main", "Alt"
2562         };
2563
2564         return snd_ctl_enum_info(uinfo, 1, 3, values);
2565 }
2566
2567 static int scarlett2_speaker_switch_enum_ctl_get(
2568         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2569 {
2570         struct usb_mixer_elem_info *elem = kctl->private_data;
2571         struct usb_mixer_interface *mixer = elem->head.mixer;
2572         struct scarlett2_data *private = mixer->private_data;
2573
2574         mutex_lock(&private->data_mutex);
2575         if (private->monitor_other_updated)
2576                 scarlett2_update_monitor_other(mixer);
2577         ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
2578         mutex_unlock(&private->data_mutex);
2579
2580         return 0;
2581 }
2582
2583 /* when speaker switching gets enabled, switch the main/alt speakers
2584  * to HW volume and disable those controls
2585  */
2586 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
2587 {
2588         struct snd_card *card = mixer->chip->card;
2589         struct scarlett2_data *private = mixer->private_data;
2590         int i, err;
2591
2592         for (i = 0; i < 4; i++) {
2593                 int index = line_out_remap(private, i);
2594
2595                 /* switch the main/alt speakers to HW volume */
2596                 if (!private->vol_sw_hw_switch[index]) {
2597                         err = scarlett2_sw_hw_change(private->mixer, i, 1);
2598                         if (err < 0)
2599                                 return err;
2600                 }
2601
2602                 /* disable the line out SW/HW switch */
2603                 scarlett2_sw_hw_ctl_ro(private, i);
2604                 snd_ctl_notify(card,
2605                                SNDRV_CTL_EVENT_MASK_VALUE |
2606                                  SNDRV_CTL_EVENT_MASK_INFO,
2607                                &private->sw_hw_ctls[i]->id);
2608         }
2609
2610         /* when the next monitor-other notify comes in, update the mux
2611          * configuration
2612          */
2613         private->speaker_switching_switched = 1;
2614
2615         return 0;
2616 }
2617
2618 /* when speaker switching gets disabled, reenable the hw/sw controls
2619  * and invalidate the routing
2620  */
2621 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
2622 {
2623         struct snd_card *card = mixer->chip->card;
2624         struct scarlett2_data *private = mixer->private_data;
2625         int i;
2626
2627         /* enable the line out SW/HW switch */
2628         for (i = 0; i < 4; i++) {
2629                 scarlett2_sw_hw_ctl_rw(private, i);
2630                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2631                                &private->sw_hw_ctls[i]->id);
2632         }
2633
2634         /* when the next monitor-other notify comes in, update the mux
2635          * configuration
2636          */
2637         private->speaker_switching_switched = 1;
2638 }
2639
2640 static int scarlett2_speaker_switch_enum_ctl_put(
2641         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2642 {
2643         struct usb_mixer_elem_info *elem = kctl->private_data;
2644         struct usb_mixer_interface *mixer = elem->head.mixer;
2645         struct scarlett2_data *private = mixer->private_data;
2646
2647         int oval, val, err = 0;
2648
2649         mutex_lock(&private->data_mutex);
2650
2651         oval = private->speaker_switching_switch;
2652         val = min(ucontrol->value.enumerated.item[0], 2U);
2653
2654         if (oval == val)
2655                 goto unlock;
2656
2657         private->speaker_switching_switch = val;
2658
2659         /* enable/disable speaker switching */
2660         err = scarlett2_usb_set_config(
2661                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2662                 0, !!val);
2663         if (err < 0)
2664                 goto unlock;
2665
2666         /* if speaker switching is enabled, select main or alt */
2667         err = scarlett2_usb_set_config(
2668                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2669                 0, val == 2);
2670         if (err < 0)
2671                 goto unlock;
2672
2673         /* update controls if speaker switching gets enabled or disabled */
2674         if (!oval && val)
2675                 err = scarlett2_speaker_switch_enable(mixer);
2676         else if (oval && !val)
2677                 scarlett2_speaker_switch_disable(mixer);
2678
2679         if (err == 0)
2680                 err = 1;
2681
2682 unlock:
2683         mutex_unlock(&private->data_mutex);
2684         return err;
2685 }
2686
2687 static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
2688         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2689         .name = "",
2690         .info = scarlett2_speaker_switch_enum_ctl_info,
2691         .get  = scarlett2_speaker_switch_enum_ctl_get,
2692         .put  = scarlett2_speaker_switch_enum_ctl_put,
2693 };
2694
2695 static int scarlett2_add_speaker_switch_ctl(
2696         struct usb_mixer_interface *mixer)
2697 {
2698         struct scarlett2_data *private = mixer->private_data;
2699         const struct scarlett2_device_info *info = private->info;
2700
2701         if (!info->has_speaker_switching)
2702                 return 0;
2703
2704         return scarlett2_add_new_ctl(
2705                 mixer, &scarlett2_speaker_switch_enum_ctl,
2706                 0, 1, "Speaker Switching Playback Enum",
2707                 &private->speaker_switching_ctl);
2708 }
2709
2710 /*** Talkback and Talkback Map Controls ***/
2711
2712 static int scarlett2_talkback_enum_ctl_info(
2713         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2714 {
2715         static const char *const values[3] = {
2716                 "Disabled", "Off", "On"
2717         };
2718
2719         return snd_ctl_enum_info(uinfo, 1, 3, values);
2720 }
2721
2722 static int scarlett2_talkback_enum_ctl_get(
2723         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2724 {
2725         struct usb_mixer_elem_info *elem = kctl->private_data;
2726         struct usb_mixer_interface *mixer = elem->head.mixer;
2727         struct scarlett2_data *private = mixer->private_data;
2728
2729         mutex_lock(&private->data_mutex);
2730         if (private->monitor_other_updated)
2731                 scarlett2_update_monitor_other(mixer);
2732         ucontrol->value.enumerated.item[0] = private->talkback_switch;
2733         mutex_unlock(&private->data_mutex);
2734
2735         return 0;
2736 }
2737
2738 static int scarlett2_talkback_enum_ctl_put(
2739         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2740 {
2741         struct usb_mixer_elem_info *elem = kctl->private_data;
2742         struct usb_mixer_interface *mixer = elem->head.mixer;
2743         struct scarlett2_data *private = mixer->private_data;
2744
2745         int oval, val, err = 0;
2746
2747         mutex_lock(&private->data_mutex);
2748
2749         oval = private->talkback_switch;
2750         val = min(ucontrol->value.enumerated.item[0], 2U);
2751
2752         if (oval == val)
2753                 goto unlock;
2754
2755         private->talkback_switch = val;
2756
2757         /* enable/disable talkback */
2758         err = scarlett2_usb_set_config(
2759                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2760                 1, !!val);
2761         if (err < 0)
2762                 goto unlock;
2763
2764         /* if talkback is enabled, select main or alt */
2765         err = scarlett2_usb_set_config(
2766                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2767                 1, val == 2);
2768         if (err == 0)
2769                 err = 1;
2770
2771 unlock:
2772         mutex_unlock(&private->data_mutex);
2773         return err;
2774 }
2775
2776 static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
2777         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2778         .name = "",
2779         .info = scarlett2_talkback_enum_ctl_info,
2780         .get  = scarlett2_talkback_enum_ctl_get,
2781         .put  = scarlett2_talkback_enum_ctl_put,
2782 };
2783
2784 static int scarlett2_talkback_map_ctl_get(
2785         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2786 {
2787         struct usb_mixer_elem_info *elem = kctl->private_data;
2788         struct usb_mixer_interface *mixer = elem->head.mixer;
2789         struct scarlett2_data *private = mixer->private_data;
2790         int index = elem->control;
2791
2792         ucontrol->value.integer.value[0] = private->talkback_map[index];
2793
2794         return 0;
2795 }
2796
2797 static int scarlett2_talkback_map_ctl_put(
2798         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2799 {
2800         struct usb_mixer_elem_info *elem = kctl->private_data;
2801         struct usb_mixer_interface *mixer = elem->head.mixer;
2802         struct scarlett2_data *private = mixer->private_data;
2803         const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2804                 private->info->port_count;
2805         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2806
2807         int index = elem->control;
2808         int oval, val, err = 0, i;
2809         u16 bitmap = 0;
2810
2811         mutex_lock(&private->data_mutex);
2812
2813         oval = private->talkback_map[index];
2814         val = !!ucontrol->value.integer.value[0];
2815
2816         if (oval == val)
2817                 goto unlock;
2818
2819         private->talkback_map[index] = val;
2820
2821         for (i = 0; i < num_mixes; i++)
2822                 bitmap |= private->talkback_map[i] << i;
2823
2824         /* Send updated bitmap to the device */
2825         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
2826                                        0, bitmap);
2827         if (err == 0)
2828                 err = 1;
2829
2830 unlock:
2831         mutex_unlock(&private->data_mutex);
2832         return err;
2833 }
2834
2835 static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
2836         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2837         .name = "",
2838         .info = snd_ctl_boolean_mono_info,
2839         .get  = scarlett2_talkback_map_ctl_get,
2840         .put  = scarlett2_talkback_map_ctl_put,
2841 };
2842
2843 static int scarlett2_add_talkback_ctls(
2844         struct usb_mixer_interface *mixer)
2845 {
2846         struct scarlett2_data *private = mixer->private_data;
2847         const struct scarlett2_device_info *info = private->info;
2848         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2849         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2850         int err, i;
2851         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2852
2853         if (!info->has_talkback)
2854                 return 0;
2855
2856         err = scarlett2_add_new_ctl(
2857                 mixer, &scarlett2_talkback_enum_ctl,
2858                 0, 1, "Talkback Playback Enum",
2859                 &private->talkback_ctl);
2860         if (err < 0)
2861                 return err;
2862
2863         for (i = 0; i < num_mixes; i++) {
2864                 snprintf(s, sizeof(s),
2865                          "Talkback Mix %c Playback Switch", i + 'A');
2866                 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
2867                                             i, 1, s, NULL);
2868                 if (err < 0)
2869                         return err;
2870         }
2871
2872         return 0;
2873 }
2874
2875 /*** Dim/Mute Controls ***/
2876
2877 static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
2878                                       struct snd_ctl_elem_value *ucontrol)
2879 {
2880         struct usb_mixer_elem_info *elem = kctl->private_data;
2881         struct usb_mixer_interface *mixer = elem->head.mixer;
2882         struct scarlett2_data *private = mixer->private_data;
2883
2884         mutex_lock(&private->data_mutex);
2885         if (private->vol_updated)
2886                 scarlett2_update_volumes(mixer);
2887         mutex_unlock(&private->data_mutex);
2888
2889         ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
2890         return 0;
2891 }
2892
2893 static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
2894                                       struct snd_ctl_elem_value *ucontrol)
2895 {
2896         struct usb_mixer_elem_info *elem = kctl->private_data;
2897         struct usb_mixer_interface *mixer = elem->head.mixer;
2898         struct scarlett2_data *private = mixer->private_data;
2899         const struct scarlett2_device_info *info = private->info;
2900         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2901         int num_line_out =
2902                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
2903
2904         int index = elem->control;
2905         int oval, val, err = 0, i;
2906
2907         mutex_lock(&private->data_mutex);
2908
2909         oval = private->dim_mute[index];
2910         val = !!ucontrol->value.integer.value[0];
2911
2912         if (oval == val)
2913                 goto unlock;
2914
2915         private->dim_mute[index] = val;
2916
2917         /* Send switch change to the device */
2918         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
2919                                        index, val);
2920         if (err == 0)
2921                 err = 1;
2922
2923         if (index == SCARLETT2_BUTTON_MUTE)
2924                 for (i = 0; i < num_line_out; i++) {
2925                         int line_index = line_out_remap(private, i);
2926
2927                         if (private->vol_sw_hw_switch[line_index]) {
2928                                 private->mute_switch[line_index] = val;
2929                                 snd_ctl_notify(mixer->chip->card,
2930                                                SNDRV_CTL_EVENT_MASK_VALUE,
2931                                                &private->mute_ctls[i]->id);
2932                         }
2933                 }
2934
2935 unlock:
2936         mutex_unlock(&private->data_mutex);
2937         return err;
2938 }
2939
2940 static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
2941         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2942         .name = "",
2943         .info = snd_ctl_boolean_mono_info,
2944         .get  = scarlett2_dim_mute_ctl_get,
2945         .put  = scarlett2_dim_mute_ctl_put
2946 };
2947
2948 /*** Create the analogue output controls ***/
2949
2950 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
2951 {
2952         struct scarlett2_data *private = mixer->private_data;
2953         const struct scarlett2_device_info *info = private->info;
2954         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2955         int num_line_out =
2956                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
2957         int err, i;
2958         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2959
2960         /* Add R/O HW volume control */
2961         if (info->line_out_hw_vol) {
2962                 snprintf(s, sizeof(s), "Master HW Playback Volume");
2963                 err = scarlett2_add_new_ctl(mixer,
2964                                             &scarlett2_master_volume_ctl,
2965                                             0, 1, s, &private->master_vol_ctl);
2966                 if (err < 0)
2967                         return err;
2968         }
2969
2970         /* Add volume controls */
2971         for (i = 0; i < num_line_out; i++) {
2972                 int index = line_out_remap(private, i);
2973
2974                 /* Fader */
2975                 if (info->line_out_descrs[i])
2976                         snprintf(s, sizeof(s),
2977                                  "Line %02d (%s) Playback Volume",
2978                                  i + 1, info->line_out_descrs[i]);
2979                 else
2980                         snprintf(s, sizeof(s),
2981                                  "Line %02d Playback Volume",
2982                                  i + 1);
2983                 err = scarlett2_add_new_ctl(mixer,
2984                                             &scarlett2_line_out_volume_ctl,
2985                                             i, 1, s, &private->vol_ctls[i]);
2986                 if (err < 0)
2987                         return err;
2988
2989                 /* Mute Switch */
2990                 snprintf(s, sizeof(s),
2991                          "Line %02d Mute Playback Switch",
2992                          i + 1);
2993                 err = scarlett2_add_new_ctl(mixer,
2994                                             &scarlett2_mute_ctl,
2995                                             i, 1, s,
2996                                             &private->mute_ctls[i]);
2997                 if (err < 0)
2998                         return err;
2999
3000                 /* Make the fader and mute controls read-only if the
3001                  * SW/HW switch is set to HW
3002                  */
3003                 if (private->vol_sw_hw_switch[index])
3004                         scarlett2_vol_ctl_set_writable(mixer, i, 0);
3005
3006                 /* SW/HW Switch */
3007                 if (info->line_out_hw_vol) {
3008                         snprintf(s, sizeof(s),
3009                                  "Line Out %02d Volume Control Playback Enum",
3010                                  i + 1);
3011                         err = scarlett2_add_new_ctl(mixer,
3012                                                     &scarlett2_sw_hw_enum_ctl,
3013                                                     i, 1, s,
3014                                                     &private->sw_hw_ctls[i]);
3015                         if (err < 0)
3016                                 return err;
3017
3018                         /* Make the switch read-only if the line is
3019                          * involved in speaker switching
3020                          */
3021                         if (private->speaker_switching_switch && i < 4)
3022                                 scarlett2_sw_hw_ctl_ro(private, i);
3023                 }
3024         }
3025
3026         /* Add dim/mute controls */
3027         if (info->line_out_hw_vol)
3028                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
3029                         err = scarlett2_add_new_ctl(
3030                                 mixer, &scarlett2_dim_mute_ctl,
3031                                 i, 1, scarlett2_dim_mute_names[i],
3032                                 &private->dim_mute_ctls[i]);
3033                         if (err < 0)
3034                                 return err;
3035                 }
3036
3037         return 0;
3038 }
3039
3040 /*** Create the analogue input controls ***/
3041
3042 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
3043 {
3044         struct scarlett2_data *private = mixer->private_data;
3045         const struct scarlett2_device_info *info = private->info;
3046         int err, i;
3047         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3048         const char *fmt = "Line In %d %s Capture %s";
3049         const char *fmt2 = "Line In %d-%d %s Capture %s";
3050
3051         /* Add input level (line/inst) controls */
3052         for (i = 0; i < info->level_input_count; i++) {
3053                 snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
3054                          "Level", "Enum");
3055                 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
3056                                             i, 1, s, &private->level_ctls[i]);
3057                 if (err < 0)
3058                         return err;
3059         }
3060
3061         /* Add input pad controls */
3062         for (i = 0; i < info->pad_input_count; i++) {
3063                 snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
3064                 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
3065                                             i, 1, s, &private->pad_ctls[i]);
3066                 if (err < 0)
3067                         return err;
3068         }
3069
3070         /* Add input air controls */
3071         for (i = 0; i < info->air_input_count; i++) {
3072                 snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch");
3073                 err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl,
3074                                             i, 1, s, &private->air_ctls[i]);
3075                 if (err < 0)
3076                         return err;
3077         }
3078
3079         /* Add input phantom controls */
3080         if (info->inputs_per_phantom == 1) {
3081                 for (i = 0; i < info->phantom_count; i++) {
3082                         snprintf(s, sizeof(s), fmt, i + 1,
3083                                  "Phantom Power", "Switch");
3084                         err = scarlett2_add_new_ctl(
3085                                 mixer, &scarlett2_phantom_ctl,
3086                                 i, 1, s, &private->phantom_ctls[i]);
3087                         if (err < 0)
3088                                 return err;
3089                 }
3090         } else if (info->inputs_per_phantom > 1) {
3091                 for (i = 0; i < info->phantom_count; i++) {
3092                         int from = i * info->inputs_per_phantom + 1;
3093                         int to = (i + 1) * info->inputs_per_phantom;
3094
3095                         snprintf(s, sizeof(s), fmt2, from, to,
3096                                  "Phantom Power", "Switch");
3097                         err = scarlett2_add_new_ctl(
3098                                 mixer, &scarlett2_phantom_ctl,
3099                                 i, 1, s, &private->phantom_ctls[i]);
3100                         if (err < 0)
3101                                 return err;
3102                 }
3103         }
3104         if (info->phantom_count) {
3105                 err = scarlett2_add_new_ctl(
3106                         mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
3107                         "Phantom Power Persistence Capture Switch", NULL);
3108                 if (err < 0)
3109                         return err;
3110         }
3111
3112         return 0;
3113 }
3114
3115 /*** Mixer Volume Controls ***/
3116
3117 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
3118                                     struct snd_ctl_elem_info *uinfo)
3119 {
3120         struct usb_mixer_elem_info *elem = kctl->private_data;
3121
3122         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3123         uinfo->count = elem->channels;
3124         uinfo->value.integer.min = 0;
3125         uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
3126         uinfo->value.integer.step = 1;
3127         return 0;
3128 }
3129
3130 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
3131                                    struct snd_ctl_elem_value *ucontrol)
3132 {
3133         struct usb_mixer_elem_info *elem = kctl->private_data;
3134         struct scarlett2_data *private = elem->head.mixer->private_data;
3135
3136         ucontrol->value.integer.value[0] = private->mix[elem->control];
3137         return 0;
3138 }
3139
3140 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
3141                                    struct snd_ctl_elem_value *ucontrol)
3142 {
3143         struct usb_mixer_elem_info *elem = kctl->private_data;
3144         struct usb_mixer_interface *mixer = elem->head.mixer;
3145         struct scarlett2_data *private = mixer->private_data;
3146         const struct scarlett2_device_info *info = private->info;
3147         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3148         int oval, val, num_mixer_in, mix_num, err = 0;
3149         int index = elem->control;
3150
3151         mutex_lock(&private->data_mutex);
3152
3153         oval = private->mix[index];
3154         val = ucontrol->value.integer.value[0];
3155         num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3156         mix_num = index / num_mixer_in;
3157
3158         if (oval == val)
3159                 goto unlock;
3160
3161         private->mix[index] = val;
3162         err = scarlett2_usb_set_mix(mixer, mix_num);
3163         if (err == 0)
3164                 err = 1;
3165
3166 unlock:
3167         mutex_unlock(&private->data_mutex);
3168         return err;
3169 }
3170
3171 static const DECLARE_TLV_DB_MINMAX(
3172         db_scale_scarlett2_mixer,
3173         SCARLETT2_MIXER_MIN_DB * 100,
3174         SCARLETT2_MIXER_MAX_DB * 100
3175 );
3176
3177 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
3178         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3179         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3180                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3181         .name = "",
3182         .info = scarlett2_mixer_ctl_info,
3183         .get  = scarlett2_mixer_ctl_get,
3184         .put  = scarlett2_mixer_ctl_put,
3185         .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
3186         .tlv = { .p = db_scale_scarlett2_mixer }
3187 };
3188
3189 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
3190 {
3191         struct scarlett2_data *private = mixer->private_data;
3192         const struct scarlett2_device_info *info = private->info;
3193         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3194         int err, i, j;
3195         int index;
3196         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3197
3198         int num_inputs =
3199                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3200         int num_outputs =
3201                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3202
3203         for (i = 0, index = 0; i < num_outputs; i++)
3204                 for (j = 0; j < num_inputs; j++, index++) {
3205                         snprintf(s, sizeof(s),
3206                                  "Mix %c Input %02d Playback Volume",
3207                                  'A' + i, j + 1);
3208                         err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
3209                                                     index, 1, s, NULL);
3210                         if (err < 0)
3211                                 return err;
3212                 }
3213
3214         return 0;
3215 }
3216
3217 /*** Mux Source Selection Controls ***/
3218
3219 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
3220                                            struct snd_ctl_elem_info *uinfo)
3221 {
3222         struct usb_mixer_elem_info *elem = kctl->private_data;
3223         struct scarlett2_data *private = elem->head.mixer->private_data;
3224         const struct scarlett2_device_info *info = private->info;
3225         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3226         unsigned int item = uinfo->value.enumerated.item;
3227         int items = private->num_mux_srcs;
3228         int port_type;
3229
3230         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3231         uinfo->count = elem->channels;
3232         uinfo->value.enumerated.items = items;
3233
3234         if (item >= items)
3235                 item = uinfo->value.enumerated.item = items - 1;
3236
3237         for (port_type = 0;
3238              port_type < SCARLETT2_PORT_TYPE_COUNT;
3239              port_type++) {
3240                 if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
3241                         const struct scarlett2_port *port =
3242                                 &scarlett2_ports[port_type];
3243
3244                         sprintf(uinfo->value.enumerated.name,
3245                                 port->src_descr, item + port->src_num_offset);
3246                         return 0;
3247                 }
3248                 item -= port_count[port_type][SCARLETT2_PORT_IN];
3249         }
3250
3251         return -EINVAL;
3252 }
3253
3254 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
3255                                           struct snd_ctl_elem_value *ucontrol)
3256 {
3257         struct usb_mixer_elem_info *elem = kctl->private_data;
3258         struct usb_mixer_interface *mixer = elem->head.mixer;
3259         struct scarlett2_data *private = mixer->private_data;
3260         const struct scarlett2_device_info *info = private->info;
3261         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3262         int line_out_count =
3263                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3264         int index = elem->control;
3265
3266         if (index < line_out_count)
3267                 index = line_out_remap(private, index);
3268
3269         mutex_lock(&private->data_mutex);
3270         if (private->mux_updated)
3271                 scarlett2_usb_get_mux(mixer);
3272         ucontrol->value.enumerated.item[0] = private->mux[index];
3273         mutex_unlock(&private->data_mutex);
3274
3275         return 0;
3276 }
3277
3278 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
3279                                           struct snd_ctl_elem_value *ucontrol)
3280 {
3281         struct usb_mixer_elem_info *elem = kctl->private_data;
3282         struct usb_mixer_interface *mixer = elem->head.mixer;
3283         struct scarlett2_data *private = mixer->private_data;
3284         const struct scarlett2_device_info *info = private->info;
3285         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3286         int line_out_count =
3287                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3288         int index = elem->control;
3289         int oval, val, err = 0;
3290
3291         if (index < line_out_count)
3292                 index = line_out_remap(private, index);
3293
3294         mutex_lock(&private->data_mutex);
3295
3296         oval = private->mux[index];
3297         val = min(ucontrol->value.enumerated.item[0],
3298                   private->num_mux_srcs - 1U);
3299
3300         if (oval == val)
3301                 goto unlock;
3302
3303         private->mux[index] = val;
3304         err = scarlett2_usb_set_mux(mixer);
3305         if (err == 0)
3306                 err = 1;
3307
3308 unlock:
3309         mutex_unlock(&private->data_mutex);
3310         return err;
3311 }
3312
3313 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
3314         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3315         .name = "",
3316         .info = scarlett2_mux_src_enum_ctl_info,
3317         .get  = scarlett2_mux_src_enum_ctl_get,
3318         .put  = scarlett2_mux_src_enum_ctl_put,
3319 };
3320
3321 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
3322 {
3323         struct scarlett2_data *private = mixer->private_data;
3324         const struct scarlett2_device_info *info = private->info;
3325         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3326         int port_type, channel, i;
3327
3328         for (i = 0, port_type = 0;
3329              port_type < SCARLETT2_PORT_TYPE_COUNT;
3330              port_type++) {
3331                 for (channel = 0;
3332                      channel < port_count[port_type][SCARLETT2_PORT_OUT];
3333                      channel++, i++) {
3334                         int err;
3335                         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3336                         const char *const descr =
3337                                 scarlett2_ports[port_type].dst_descr;
3338
3339                         snprintf(s, sizeof(s) - 5, descr, channel + 1);
3340                         strcat(s, " Enum");
3341
3342                         err = scarlett2_add_new_ctl(mixer,
3343                                                     &scarlett2_mux_src_enum_ctl,
3344                                                     i, 1, s,
3345                                                     &private->mux_ctls[i]);
3346                         if (err < 0)
3347                                 return err;
3348                 }
3349         }
3350
3351         return 0;
3352 }
3353
3354 /*** Meter Controls ***/
3355
3356 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
3357                                     struct snd_ctl_elem_info *uinfo)
3358 {
3359         struct usb_mixer_elem_info *elem = kctl->private_data;
3360
3361         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3362         uinfo->count = elem->channels;
3363         uinfo->value.integer.min = 0;
3364         uinfo->value.integer.max = 4095;
3365         uinfo->value.integer.step = 1;
3366         return 0;
3367 }
3368
3369 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
3370                                    struct snd_ctl_elem_value *ucontrol)
3371 {
3372         struct usb_mixer_elem_info *elem = kctl->private_data;
3373         u16 meter_levels[SCARLETT2_MAX_METERS];
3374         int i, err;
3375
3376         err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels,
3377                                              meter_levels);
3378         if (err < 0)
3379                 return err;
3380
3381         for (i = 0; i < elem->channels; i++)
3382                 ucontrol->value.integer.value[i] = meter_levels[i];
3383
3384         return 0;
3385 }
3386
3387 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
3388         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
3389         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3390         .name = "",
3391         .info = scarlett2_meter_ctl_info,
3392         .get  = scarlett2_meter_ctl_get
3393 };
3394
3395 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
3396 {
3397         struct scarlett2_data *private = mixer->private_data;
3398
3399         /* devices without a mixer also don't support reporting levels */
3400         if (!private->info->has_mixer)
3401                 return 0;
3402
3403         return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
3404                                      0, private->num_mux_dsts,
3405                                      "Level Meter", NULL);
3406 }
3407
3408 /*** MSD Controls ***/
3409
3410 static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
3411                                  struct snd_ctl_elem_value *ucontrol)
3412 {
3413         struct usb_mixer_elem_info *elem = kctl->private_data;
3414         struct scarlett2_data *private = elem->head.mixer->private_data;
3415
3416         ucontrol->value.integer.value[0] = private->msd_switch;
3417         return 0;
3418 }
3419
3420 static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
3421                                  struct snd_ctl_elem_value *ucontrol)
3422 {
3423         struct usb_mixer_elem_info *elem = kctl->private_data;
3424         struct usb_mixer_interface *mixer = elem->head.mixer;
3425         struct scarlett2_data *private = mixer->private_data;
3426
3427         int oval, val, err = 0;
3428
3429         mutex_lock(&private->data_mutex);
3430
3431         oval = private->msd_switch;
3432         val = !!ucontrol->value.integer.value[0];
3433
3434         if (oval == val)
3435                 goto unlock;
3436
3437         private->msd_switch = val;
3438
3439         /* Send switch change to the device */
3440         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3441                                        0, val);
3442         if (err == 0)
3443                 err = 1;
3444
3445 unlock:
3446         mutex_unlock(&private->data_mutex);
3447         return err;
3448 }
3449
3450 static const struct snd_kcontrol_new scarlett2_msd_ctl = {
3451         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3452         .name = "",
3453         .info = snd_ctl_boolean_mono_info,
3454         .get  = scarlett2_msd_ctl_get,
3455         .put  = scarlett2_msd_ctl_put,
3456 };
3457
3458 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
3459 {
3460         struct scarlett2_data *private = mixer->private_data;
3461         const struct scarlett2_device_info *info = private->info;
3462
3463         if (!info->has_msd_mode)
3464                 return 0;
3465
3466         /* If MSD mode is off, hide the switch by default */
3467         if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
3468                 return 0;
3469
3470         /* Add MSD control */
3471         return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
3472                                      0, 1, "MSD Mode Switch", NULL);
3473 }
3474
3475 /*** Cleanup/Suspend Callbacks ***/
3476
3477 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
3478 {
3479         struct scarlett2_data *private = mixer->private_data;
3480
3481         cancel_delayed_work_sync(&private->work);
3482         kfree(private);
3483         mixer->private_data = NULL;
3484 }
3485
3486 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
3487 {
3488         struct scarlett2_data *private = mixer->private_data;
3489
3490         if (cancel_delayed_work_sync(&private->work))
3491                 scarlett2_config_save(private->mixer);
3492 }
3493
3494 /*** Initialisation ***/
3495
3496 static void scarlett2_count_mux_io(struct scarlett2_data *private)
3497 {
3498         const struct scarlett2_device_info *info = private->info;
3499         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3500         int port_type, srcs = 0, dsts = 0;
3501
3502         for (port_type = 0;
3503              port_type < SCARLETT2_PORT_TYPE_COUNT;
3504              port_type++) {
3505                 srcs += port_count[port_type][SCARLETT2_PORT_IN];
3506                 dsts += port_count[port_type][SCARLETT2_PORT_OUT];
3507         }
3508
3509         private->num_mux_srcs = srcs;
3510         private->num_mux_dsts = dsts;
3511 }
3512
3513 /* Look through the interface descriptors for the Focusrite Control
3514  * interface (bInterfaceClass = 255 Vendor Specific Class) and set
3515  * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
3516  * in private
3517  */
3518 static int scarlett2_find_fc_interface(struct usb_device *dev,
3519                                        struct scarlett2_data *private)
3520 {
3521         struct usb_host_config *config = dev->actconfig;
3522         int i;
3523
3524         for (i = 0; i < config->desc.bNumInterfaces; i++) {
3525                 struct usb_interface *intf = config->interface[i];
3526                 struct usb_interface_descriptor *desc =
3527                         &intf->altsetting[0].desc;
3528                 struct usb_endpoint_descriptor *epd;
3529
3530                 if (desc->bInterfaceClass != 255)
3531                         continue;
3532
3533                 epd = get_endpoint(intf->altsetting, 0);
3534                 private->bInterfaceNumber = desc->bInterfaceNumber;
3535                 private->bEndpointAddress = epd->bEndpointAddress &
3536                         USB_ENDPOINT_NUMBER_MASK;
3537                 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
3538                 private->bInterval = epd->bInterval;
3539                 return 0;
3540         }
3541
3542         return -EINVAL;
3543 }
3544
3545 /* Initialise private data */
3546 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
3547                                   const struct scarlett2_device_info *info)
3548 {
3549         struct scarlett2_data *private =
3550                 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
3551
3552         if (!private)
3553                 return -ENOMEM;
3554
3555         mutex_init(&private->usb_mutex);
3556         mutex_init(&private->data_mutex);
3557         INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
3558
3559         mixer->private_data = private;
3560         mixer->private_free = scarlett2_private_free;
3561         mixer->private_suspend = scarlett2_private_suspend;
3562
3563         private->info = info;
3564         scarlett2_count_mux_io(private);
3565         private->scarlett2_seq = 0;
3566         private->mixer = mixer;
3567
3568         return scarlett2_find_fc_interface(mixer->chip->dev, private);
3569 }
3570
3571 /* Cargo cult proprietary initialisation sequence */
3572 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
3573 {
3574         struct usb_device *dev = mixer->chip->dev;
3575         struct scarlett2_data *private = mixer->private_data;
3576         u8 buf[24];
3577         int err;
3578
3579         if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
3580                 return -EINVAL;
3581
3582         /* step 0 */
3583         err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
3584                                SCARLETT2_USB_CMD_INIT, buf, sizeof(buf));
3585         if (err < 0)
3586                 return err;
3587
3588         /* step 1 */
3589         private->scarlett2_seq = 1;
3590         err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
3591         if (err < 0)
3592                 return err;
3593
3594         /* step 2 */
3595         private->scarlett2_seq = 1;
3596         return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84);
3597 }
3598
3599 /* Read configuration from the interface on start */
3600 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
3601 {
3602         struct scarlett2_data *private = mixer->private_data;
3603         const struct scarlett2_device_info *info = private->info;
3604         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3605         int num_line_out =
3606                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3607         int num_mixer_out =
3608                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3609         struct scarlett2_usb_volume_status volume_status;
3610         int err, i;
3611
3612         if (info->has_msd_mode) {
3613                 err = scarlett2_usb_get_config(
3614                         mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3615                         1, &private->msd_switch);
3616                 if (err < 0)
3617                         return err;
3618
3619                 /* no other controls are created if MSD mode is on */
3620                 if (private->msd_switch)
3621                         return 0;
3622         }
3623
3624         err = scarlett2_update_input_other(mixer);
3625         if (err < 0)
3626                 return err;
3627
3628         err = scarlett2_update_monitor_other(mixer);
3629         if (err < 0)
3630                 return err;
3631
3632         /* the rest of the configuration is for devices with a mixer */
3633         if (!info->has_mixer)
3634                 return 0;
3635
3636         err = scarlett2_update_sync(mixer);
3637         if (err < 0)
3638                 return err;
3639
3640         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
3641         if (err < 0)
3642                 return err;
3643
3644         if (info->line_out_hw_vol)
3645                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3646                         private->dim_mute[i] = !!volume_status.dim_mute[i];
3647
3648         private->master_vol = clamp(
3649                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
3650                 0, SCARLETT2_VOLUME_BIAS);
3651
3652         for (i = 0; i < num_line_out; i++) {
3653                 int volume, mute;
3654
3655                 private->vol_sw_hw_switch[i] =
3656                         info->line_out_hw_vol
3657                                 && volume_status.sw_hw_switch[i];
3658
3659                 volume = private->vol_sw_hw_switch[i]
3660                            ? volume_status.master_vol
3661                            : volume_status.sw_vol[i];
3662                 volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
3663                                0, SCARLETT2_VOLUME_BIAS);
3664                 private->vol[i] = volume;
3665
3666                 mute = private->vol_sw_hw_switch[i]
3667                          ? private->dim_mute[SCARLETT2_BUTTON_MUTE]
3668                          : volume_status.mute_switch[i];
3669                 private->mute_switch[i] = mute;
3670         }
3671
3672         for (i = 0; i < num_mixer_out; i++) {
3673                 err = scarlett2_usb_get_mix(mixer, i);
3674                 if (err < 0)
3675                         return err;
3676         }
3677
3678         return scarlett2_usb_get_mux(mixer);
3679 }
3680
3681 /* Notify on sync change */
3682 static void scarlett2_notify_sync(
3683         struct usb_mixer_interface *mixer)
3684 {
3685         struct scarlett2_data *private = mixer->private_data;
3686
3687         private->sync_updated = 1;
3688
3689         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3690                        &private->sync_ctl->id);
3691 }
3692
3693 /* Notify on monitor change */
3694 static void scarlett2_notify_monitor(
3695         struct usb_mixer_interface *mixer)
3696 {
3697         struct snd_card *card = mixer->chip->card;
3698         struct scarlett2_data *private = mixer->private_data;
3699         const struct scarlett2_device_info *info = private->info;
3700         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3701         int num_line_out =
3702                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3703         int i;
3704
3705         /* if line_out_hw_vol is 0, there are no controls to update */
3706         if (!info->line_out_hw_vol)
3707                 return;
3708
3709         private->vol_updated = 1;
3710
3711         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3712                        &private->master_vol_ctl->id);
3713
3714         for (i = 0; i < num_line_out; i++)
3715                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3716                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3717                                        &private->vol_ctls[i]->id);
3718 }
3719
3720 /* Notify on dim/mute change */
3721 static void scarlett2_notify_dim_mute(
3722         struct usb_mixer_interface *mixer)
3723 {
3724         struct snd_card *card = mixer->chip->card;
3725         struct scarlett2_data *private = mixer->private_data;
3726         const struct scarlett2_device_info *info = private->info;
3727         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3728         int num_line_out =
3729                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3730         int i;
3731
3732         private->vol_updated = 1;
3733
3734         if (!info->line_out_hw_vol)
3735                 return;
3736
3737         for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3738                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3739                                &private->dim_mute_ctls[i]->id);
3740
3741         for (i = 0; i < num_line_out; i++)
3742                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3743                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3744                                        &private->mute_ctls[i]->id);
3745 }
3746
3747 /* Notify on "input other" change (level/pad/air) */
3748 static void scarlett2_notify_input_other(
3749         struct usb_mixer_interface *mixer)
3750 {
3751         struct snd_card *card = mixer->chip->card;
3752         struct scarlett2_data *private = mixer->private_data;
3753         const struct scarlett2_device_info *info = private->info;
3754         int i;
3755
3756         private->input_other_updated = 1;
3757
3758         for (i = 0; i < info->level_input_count; i++)
3759                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3760                                &private->level_ctls[i]->id);
3761         for (i = 0; i < info->pad_input_count; i++)
3762                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3763                                &private->pad_ctls[i]->id);
3764         for (i = 0; i < info->air_input_count; i++)
3765                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3766                                &private->air_ctls[i]->id);
3767         for (i = 0; i < info->phantom_count; i++)
3768                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3769                                &private->phantom_ctls[i]->id);
3770 }
3771
3772 /* Notify on "monitor other" change (direct monitor, speaker
3773  * switching, talkback)
3774  */
3775 static void scarlett2_notify_monitor_other(
3776         struct usb_mixer_interface *mixer)
3777 {
3778         struct snd_card *card = mixer->chip->card;
3779         struct scarlett2_data *private = mixer->private_data;
3780         const struct scarlett2_device_info *info = private->info;
3781
3782         private->monitor_other_updated = 1;
3783
3784         if (info->direct_monitor) {
3785                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3786                                &private->direct_monitor_ctl->id);
3787                 return;
3788         }
3789
3790         if (info->has_speaker_switching)
3791                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3792                                &private->speaker_switching_ctl->id);
3793
3794         if (info->has_talkback)
3795                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3796                                &private->talkback_ctl->id);
3797
3798         /* if speaker switching was recently enabled or disabled,
3799          * invalidate the dim/mute and mux enum controls
3800          */
3801         if (private->speaker_switching_switched) {
3802                 int i;
3803
3804                 scarlett2_notify_dim_mute(mixer);
3805
3806                 private->speaker_switching_switched = 0;
3807                 private->mux_updated = 1;
3808
3809                 for (i = 0; i < private->num_mux_dsts; i++)
3810                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3811                                        &private->mux_ctls[i]->id);
3812         }
3813 }
3814
3815 /* Interrupt callback */
3816 static void scarlett2_notify(struct urb *urb)
3817 {
3818         struct usb_mixer_interface *mixer = urb->context;
3819         int len = urb->actual_length;
3820         int ustatus = urb->status;
3821         u32 data;
3822
3823         if (ustatus != 0 || len != 8)
3824                 goto requeue;
3825
3826         data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
3827         if (data & SCARLETT2_USB_NOTIFY_SYNC)
3828                 scarlett2_notify_sync(mixer);
3829         if (data & SCARLETT2_USB_NOTIFY_MONITOR)
3830                 scarlett2_notify_monitor(mixer);
3831         if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE)
3832                 scarlett2_notify_dim_mute(mixer);
3833         if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER)
3834                 scarlett2_notify_input_other(mixer);
3835         if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER)
3836                 scarlett2_notify_monitor_other(mixer);
3837
3838 requeue:
3839         if (ustatus != -ENOENT &&
3840             ustatus != -ECONNRESET &&
3841             ustatus != -ESHUTDOWN) {
3842                 urb->dev = mixer->chip->dev;
3843                 usb_submit_urb(urb, GFP_ATOMIC);
3844         }
3845 }
3846
3847 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
3848 {
3849         struct usb_device *dev = mixer->chip->dev;
3850         struct scarlett2_data *private = mixer->private_data;
3851         unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
3852         void *transfer_buffer;
3853
3854         if (mixer->urb) {
3855                 usb_audio_err(mixer->chip,
3856                               "%s: mixer urb already in use!\n", __func__);
3857                 return 0;
3858         }
3859
3860         if (usb_pipe_type_check(dev, pipe))
3861                 return -EINVAL;
3862
3863         mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3864         if (!mixer->urb)
3865                 return -ENOMEM;
3866
3867         transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
3868         if (!transfer_buffer)
3869                 return -ENOMEM;
3870
3871         usb_fill_int_urb(mixer->urb, dev, pipe,
3872                          transfer_buffer, private->wMaxPacketSize,
3873                          scarlett2_notify, mixer, private->bInterval);
3874
3875         return usb_submit_urb(mixer->urb, GFP_KERNEL);
3876 }
3877
3878 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
3879 {
3880         const struct scarlett2_device_info **info = scarlett2_devices;
3881         int err;
3882
3883         /* Find device in scarlett2_devices */
3884         while (*info && (*info)->usb_id != mixer->chip->usb_id)
3885                 info++;
3886         if (!*info)
3887                 return -EINVAL;
3888
3889         /* Initialise private data */
3890         err = scarlett2_init_private(mixer, *info);
3891         if (err < 0)
3892                 return err;
3893
3894         /* Send proprietary USB initialisation sequence */
3895         err = scarlett2_usb_init(mixer);
3896         if (err < 0)
3897                 return err;
3898
3899         /* Read volume levels and controls from the interface */
3900         err = scarlett2_read_configs(mixer);
3901         if (err < 0)
3902                 return err;
3903
3904         /* Create the MSD control */
3905         err = scarlett2_add_msd_ctl(mixer);
3906         if (err < 0)
3907                 return err;
3908
3909         /* If MSD mode is enabled, don't create any other controls */
3910         if (((struct scarlett2_data *)mixer->private_data)->msd_switch)
3911                 return 0;
3912
3913         /* Create the analogue output controls */
3914         err = scarlett2_add_line_out_ctls(mixer);
3915         if (err < 0)
3916                 return err;
3917
3918         /* Create the analogue input controls */
3919         err = scarlett2_add_line_in_ctls(mixer);
3920         if (err < 0)
3921                 return err;
3922
3923         /* Create the input, output, and mixer mux input selections */
3924         err = scarlett2_add_mux_enums(mixer);
3925         if (err < 0)
3926                 return err;
3927
3928         /* Create the matrix mixer controls */
3929         err = scarlett2_add_mixer_ctls(mixer);
3930         if (err < 0)
3931                 return err;
3932
3933         /* Create the level meter controls */
3934         err = scarlett2_add_meter_ctl(mixer);
3935         if (err < 0)
3936                 return err;
3937
3938         /* Create the sync control */
3939         err = scarlett2_add_sync_ctl(mixer);
3940         if (err < 0)
3941                 return err;
3942
3943         /* Create the direct monitor control */
3944         err = scarlett2_add_direct_monitor_ctl(mixer);
3945         if (err < 0)
3946                 return err;
3947
3948         /* Create the speaker switching control */
3949         err = scarlett2_add_speaker_switch_ctl(mixer);
3950         if (err < 0)
3951                 return err;
3952
3953         /* Create the talkback controls */
3954         err = scarlett2_add_talkback_ctls(mixer);
3955         if (err < 0)
3956                 return err;
3957
3958         /* Set up the interrupt polling */
3959         err = scarlett2_init_notify(mixer);
3960         if (err < 0)
3961                 return err;
3962
3963         return 0;
3964 }
3965
3966 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
3967 {
3968         struct snd_usb_audio *chip = mixer->chip;
3969         int err;
3970
3971         /* only use UAC_VERSION_2 */
3972         if (!mixer->protocol)
3973                 return 0;
3974
3975         if (!(chip->setup & SCARLETT2_ENABLE)) {
3976                 usb_audio_info(chip,
3977                         "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; "
3978                         "use options snd_usb_audio vid=0x%04x pid=0x%04x "
3979                         "device_setup=1 to enable and report any issues "
3980                         "to g@b4.vu",
3981                         USB_ID_VENDOR(chip->usb_id),
3982                         USB_ID_PRODUCT(chip->usb_id));
3983                 return 0;
3984         }
3985
3986         usb_audio_info(chip,
3987                 "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x",
3988                 USB_ID_PRODUCT(chip->usb_id));
3989
3990         err = snd_scarlett_gen2_controls_create(mixer);
3991         if (err < 0)
3992                 usb_audio_err(mixer->chip,
3993                               "Error initialising Scarlett Mixer Driver: %d",
3994                               err);
3995
3996         return err;
3997 }