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", "Dim"
 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 scarlett2_data *private = elem->head.mixer->private_data;
1860         int index = line_out_remap(private, elem->control);
1861
1862         ucontrol->value.integer.value[0] = private->mute_switch[index];
1863         return 0;
1864 }
1865
1866 static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
1867                                         struct snd_ctl_elem_value *ucontrol)
1868 {
1869         struct usb_mixer_elem_info *elem = kctl->private_data;
1870         struct usb_mixer_interface *mixer = elem->head.mixer;
1871         struct scarlett2_data *private = mixer->private_data;
1872         int index = line_out_remap(private, elem->control);
1873         int oval, val, err = 0;
1874
1875         mutex_lock(&private->data_mutex);
1876
1877         oval = private->mute_switch[index];
1878         val = !!ucontrol->value.integer.value[0];
1879
1880         if (oval == val)
1881                 goto unlock;
1882
1883         private->mute_switch[index] = val;
1884
1885         /* Send mute change to the device */
1886         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
1887                                        index, val);
1888         if (err == 0)
1889                 err = 1;
1890
1891 unlock:
1892         mutex_unlock(&private->data_mutex);
1893         return err;
1894 }
1895
1896 static const struct snd_kcontrol_new scarlett2_mute_ctl = {
1897         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1898         .name = "",
1899         .info = snd_ctl_boolean_mono_info,
1900         .get  = scarlett2_mute_ctl_get,
1901         .put  = scarlett2_mute_ctl_put,
1902 };
1903
1904 /*** HW/SW Volume Switch Controls ***/
1905
1906 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
1907 {
1908         private->sw_hw_ctls[index]->vd[0].access &=
1909                 ~SNDRV_CTL_ELEM_ACCESS_WRITE;
1910 }
1911
1912 static void scarlett2_sw_hw_ctl_rw(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 int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
1919                                          struct snd_ctl_elem_info *uinfo)
1920 {
1921         static const char *const values[2] = {
1922                 "SW", "HW"
1923         };
1924
1925         return snd_ctl_enum_info(uinfo, 1, 2, values);
1926 }
1927
1928 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
1929                                         struct snd_ctl_elem_value *ucontrol)
1930 {
1931         struct usb_mixer_elem_info *elem = kctl->private_data;
1932         struct scarlett2_data *private = elem->head.mixer->private_data;
1933         int index = line_out_remap(private, elem->control);
1934
1935         ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
1936         return 0;
1937 }
1938
1939 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
1940                                            int index, int value)
1941 {
1942         struct scarlett2_data *private = mixer->private_data;
1943         struct snd_card *card = mixer->chip->card;
1944
1945         /* Set/Clear write bits */
1946         if (value) {
1947                 private->vol_ctls[index]->vd[0].access |=
1948                         SNDRV_CTL_ELEM_ACCESS_WRITE;
1949                 private->mute_ctls[index]->vd[0].access |=
1950                         SNDRV_CTL_ELEM_ACCESS_WRITE;
1951         } else {
1952                 private->vol_ctls[index]->vd[0].access &=
1953                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
1954                 private->mute_ctls[index]->vd[0].access &=
1955                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
1956         }
1957
1958         /* Notify of write bit change */
1959         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
1960                        &private->vol_ctls[index]->id);
1961         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
1962                        &private->mute_ctls[index]->id);
1963 }
1964
1965 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
1966                                   int ctl_index, int val)
1967 {
1968         struct scarlett2_data *private = mixer->private_data;
1969         int index = line_out_remap(private, ctl_index);
1970         int err;
1971
1972         private->vol_sw_hw_switch[index] = val;
1973
1974         /* Change access mode to RO (hardware controlled volume)
1975          * or RW (software controlled volume)
1976          */
1977         scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
1978
1979         /* Reset volume/mute to master volume/mute */
1980         private->vol[index] = private->master_vol;
1981         private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
1982
1983         /* Set SW volume to current HW volume */
1984         err = scarlett2_usb_set_config(
1985                 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1986                 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
1987         if (err < 0)
1988                 return err;
1989
1990         /* Set SW mute to current HW mute */
1991         err = scarlett2_usb_set_config(
1992                 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
1993                 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
1994         if (err < 0)
1995                 return err;
1996
1997         /* Send SW/HW switch change to the device */
1998         return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
1999                                         index, val);
2000 }
2001
2002 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
2003                                         struct snd_ctl_elem_value *ucontrol)
2004 {
2005         struct usb_mixer_elem_info *elem = kctl->private_data;
2006         struct usb_mixer_interface *mixer = elem->head.mixer;
2007         struct scarlett2_data *private = mixer->private_data;
2008         int ctl_index = elem->control;
2009         int index = line_out_remap(private, ctl_index);
2010         int oval, val, err = 0;
2011
2012         mutex_lock(&private->data_mutex);
2013
2014         oval = private->vol_sw_hw_switch[index];
2015         val = !!ucontrol->value.enumerated.item[0];
2016
2017         if (oval == val)
2018                 goto unlock;
2019
2020         err = scarlett2_sw_hw_change(mixer, ctl_index, val);
2021         if (err == 0)
2022                 err = 1;
2023
2024 unlock:
2025         mutex_unlock(&private->data_mutex);
2026         return err;
2027 }
2028
2029 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
2030         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2031         .name = "",
2032         .info = scarlett2_sw_hw_enum_ctl_info,
2033         .get  = scarlett2_sw_hw_enum_ctl_get,
2034         .put  = scarlett2_sw_hw_enum_ctl_put,
2035 };
2036
2037 /*** Line Level/Instrument Level Switch Controls ***/
2038
2039 static int scarlett2_update_input_other(struct usb_mixer_interface *mixer)
2040 {
2041         struct scarlett2_data *private = mixer->private_data;
2042         const struct scarlett2_device_info *info = private->info;
2043
2044         private->input_other_updated = 0;
2045
2046         if (info->level_input_count) {
2047                 int err = scarlett2_usb_get_config(
2048                         mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2049                         info->level_input_count + info->level_input_first,
2050                         private->level_switch);
2051                 if (err < 0)
2052                         return err;
2053         }
2054
2055         if (info->pad_input_count) {
2056                 int err = scarlett2_usb_get_config(
2057                         mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2058                         info->pad_input_count, private->pad_switch);
2059                 if (err < 0)
2060                         return err;
2061         }
2062
2063         if (info->air_input_count) {
2064                 int err = scarlett2_usb_get_config(
2065                         mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2066                         info->air_input_count, private->air_switch);
2067                 if (err < 0)
2068                         return err;
2069         }
2070
2071         if (info->phantom_count) {
2072                 int err = scarlett2_usb_get_config(
2073                         mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2074                         info->phantom_count, private->phantom_switch);
2075                 if (err < 0)
2076                         return err;
2077
2078                 err = scarlett2_usb_get_config(
2079                         mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
2080                         1, &private->phantom_persistence);
2081                 if (err < 0)
2082                         return err;
2083         }
2084
2085         return 0;
2086 }
2087
2088 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
2089                                          struct snd_ctl_elem_info *uinfo)
2090 {
2091         static const char *const values[2] = {
2092                 "Line", "Inst"
2093         };
2094
2095         return snd_ctl_enum_info(uinfo, 1, 2, values);
2096 }
2097
2098 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
2099                                         struct snd_ctl_elem_value *ucontrol)
2100 {
2101         struct usb_mixer_elem_info *elem = kctl->private_data;
2102         struct usb_mixer_interface *mixer = elem->head.mixer;
2103         struct scarlett2_data *private = mixer->private_data;
2104         const struct scarlett2_device_info *info = private->info;
2105
2106         int index = elem->control + info->level_input_first;
2107
2108         mutex_lock(&private->data_mutex);
2109         if (private->input_other_updated)
2110                 scarlett2_update_input_other(mixer);
2111         ucontrol->value.enumerated.item[0] = private->level_switch[index];
2112         mutex_unlock(&private->data_mutex);
2113
2114         return 0;
2115 }
2116
2117 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
2118                                         struct snd_ctl_elem_value *ucontrol)
2119 {
2120         struct usb_mixer_elem_info *elem = kctl->private_data;
2121         struct usb_mixer_interface *mixer = elem->head.mixer;
2122         struct scarlett2_data *private = mixer->private_data;
2123         const struct scarlett2_device_info *info = private->info;
2124
2125         int index = elem->control + info->level_input_first;
2126         int oval, val, err = 0;
2127
2128         mutex_lock(&private->data_mutex);
2129
2130         oval = private->level_switch[index];
2131         val = !!ucontrol->value.enumerated.item[0];
2132
2133         if (oval == val)
2134                 goto unlock;
2135
2136         private->level_switch[index] = val;
2137
2138         /* Send switch change to the device */
2139         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
2140                                        index, val);
2141         if (err == 0)
2142                 err = 1;
2143
2144 unlock:
2145         mutex_unlock(&private->data_mutex);
2146         return err;
2147 }
2148
2149 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
2150         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2151         .name = "",
2152         .info = scarlett2_level_enum_ctl_info,
2153         .get  = scarlett2_level_enum_ctl_get,
2154         .put  = scarlett2_level_enum_ctl_put,
2155 };
2156
2157 /*** Pad Switch Controls ***/
2158
2159 static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
2160                                  struct snd_ctl_elem_value *ucontrol)
2161 {
2162         struct usb_mixer_elem_info *elem = kctl->private_data;
2163         struct usb_mixer_interface *mixer = elem->head.mixer;
2164         struct scarlett2_data *private = mixer->private_data;
2165
2166         mutex_lock(&private->data_mutex);
2167         if (private->input_other_updated)
2168                 scarlett2_update_input_other(mixer);
2169         ucontrol->value.integer.value[0] =
2170                 private->pad_switch[elem->control];
2171         mutex_unlock(&private->data_mutex);
2172
2173         return 0;
2174 }
2175
2176 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
2177                                  struct snd_ctl_elem_value *ucontrol)
2178 {
2179         struct usb_mixer_elem_info *elem = kctl->private_data;
2180         struct usb_mixer_interface *mixer = elem->head.mixer;
2181         struct scarlett2_data *private = mixer->private_data;
2182
2183         int index = elem->control;
2184         int oval, val, err = 0;
2185
2186         mutex_lock(&private->data_mutex);
2187
2188         oval = private->pad_switch[index];
2189         val = !!ucontrol->value.integer.value[0];
2190
2191         if (oval == val)
2192                 goto unlock;
2193
2194         private->pad_switch[index] = val;
2195
2196         /* Send switch change to the device */
2197         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
2198                                        index, val);
2199         if (err == 0)
2200                 err = 1;
2201
2202 unlock:
2203         mutex_unlock(&private->data_mutex);
2204         return err;
2205 }
2206
2207 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
2208         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2209         .name = "",
2210         .info = snd_ctl_boolean_mono_info,
2211         .get  = scarlett2_pad_ctl_get,
2212         .put  = scarlett2_pad_ctl_put,
2213 };
2214
2215 /*** Air Switch Controls ***/
2216
2217 static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
2218                                  struct snd_ctl_elem_value *ucontrol)
2219 {
2220         struct usb_mixer_elem_info *elem = kctl->private_data;
2221         struct usb_mixer_interface *mixer = elem->head.mixer;
2222         struct scarlett2_data *private = mixer->private_data;
2223
2224         mutex_lock(&private->data_mutex);
2225         if (private->input_other_updated)
2226                 scarlett2_update_input_other(mixer);
2227         ucontrol->value.integer.value[0] = private->air_switch[elem->control];
2228         mutex_unlock(&private->data_mutex);
2229
2230         return 0;
2231 }
2232
2233 static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
2234                                  struct snd_ctl_elem_value *ucontrol)
2235 {
2236         struct usb_mixer_elem_info *elem = kctl->private_data;
2237         struct usb_mixer_interface *mixer = elem->head.mixer;
2238         struct scarlett2_data *private = mixer->private_data;
2239
2240         int index = elem->control;
2241         int oval, val, err = 0;
2242
2243         mutex_lock(&private->data_mutex);
2244
2245         oval = private->air_switch[index];
2246         val = !!ucontrol->value.integer.value[0];
2247
2248         if (oval == val)
2249                 goto unlock;
2250
2251         private->air_switch[index] = val;
2252
2253         /* Send switch change to the device */
2254         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
2255                                        index, val);
2256         if (err == 0)
2257                 err = 1;
2258
2259 unlock:
2260         mutex_unlock(&private->data_mutex);
2261         return err;
2262 }
2263
2264 static const struct snd_kcontrol_new scarlett2_air_ctl = {
2265         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2266         .name = "",
2267         .info = snd_ctl_boolean_mono_info,
2268         .get  = scarlett2_air_ctl_get,
2269         .put  = scarlett2_air_ctl_put,
2270 };
2271
2272 /*** Phantom Switch Controls ***/
2273
2274 static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
2275                                      struct snd_ctl_elem_value *ucontrol)
2276 {
2277         struct usb_mixer_elem_info *elem = kctl->private_data;
2278         struct usb_mixer_interface *mixer = elem->head.mixer;
2279         struct scarlett2_data *private = mixer->private_data;
2280
2281         mutex_lock(&private->data_mutex);
2282         if (private->input_other_updated)
2283                 scarlett2_update_input_other(mixer);
2284         ucontrol->value.integer.value[0] =
2285                 private->phantom_switch[elem->control];
2286         mutex_unlock(&private->data_mutex);
2287
2288         return 0;
2289 }
2290
2291 static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
2292                                      struct snd_ctl_elem_value *ucontrol)
2293 {
2294         struct usb_mixer_elem_info *elem = kctl->private_data;
2295         struct usb_mixer_interface *mixer = elem->head.mixer;
2296         struct scarlett2_data *private = mixer->private_data;
2297
2298         int index = elem->control;
2299         int oval, val, err = 0;
2300
2301         mutex_lock(&private->data_mutex);
2302
2303         oval = private->phantom_switch[index];
2304         val = !!ucontrol->value.integer.value[0];
2305
2306         if (oval == val)
2307                 goto unlock;
2308
2309         private->phantom_switch[index] = val;
2310
2311         /* Send switch change to the device */
2312         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
2313                                        index, val);
2314         if (err == 0)
2315                 err = 1;
2316
2317 unlock:
2318         mutex_unlock(&private->data_mutex);
2319         return err;
2320 }
2321
2322 static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
2323         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2324         .name = "",
2325         .info = snd_ctl_boolean_mono_info,
2326         .get  = scarlett2_phantom_ctl_get,
2327         .put  = scarlett2_phantom_ctl_put,
2328 };
2329
2330 /*** Phantom Persistence Control ***/
2331
2332 static int scarlett2_phantom_persistence_ctl_get(
2333         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2334 {
2335         struct usb_mixer_elem_info *elem = kctl->private_data;
2336         struct scarlett2_data *private = elem->head.mixer->private_data;
2337
2338         ucontrol->value.integer.value[0] = private->phantom_persistence;
2339         return 0;
2340 }
2341
2342 static int scarlett2_phantom_persistence_ctl_put(
2343         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2344 {
2345         struct usb_mixer_elem_info *elem = kctl->private_data;
2346         struct usb_mixer_interface *mixer = elem->head.mixer;
2347         struct scarlett2_data *private = mixer->private_data;
2348
2349         int index = elem->control;
2350         int oval, val, err = 0;
2351
2352         mutex_lock(&private->data_mutex);
2353
2354         oval = private->phantom_persistence;
2355         val = !!ucontrol->value.integer.value[0];
2356
2357         if (oval == val)
2358                 goto unlock;
2359
2360         private->phantom_persistence = val;
2361
2362         /* Send switch change to the device */
2363         err = scarlett2_usb_set_config(
2364                 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
2365         if (err == 0)
2366                 err = 1;
2367
2368 unlock:
2369         mutex_unlock(&private->data_mutex);
2370         return err;
2371 }
2372
2373 static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
2374         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2375         .name = "",
2376         .info = snd_ctl_boolean_mono_info,
2377         .get  = scarlett2_phantom_persistence_ctl_get,
2378         .put  = scarlett2_phantom_persistence_ctl_put,
2379 };
2380
2381 /*** Direct Monitor Control ***/
2382
2383 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
2384 {
2385         struct scarlett2_data *private = mixer->private_data;
2386         const struct scarlett2_device_info *info = private->info;
2387         int err;
2388
2389         /* monitor_other_enable[0] enables speaker switching
2390          * monitor_other_enable[1] enables talkback
2391          */
2392         u8 monitor_other_enable[2];
2393
2394         /* monitor_other_switch[0] activates the alternate speakers
2395          * monitor_other_switch[1] activates talkback
2396          */
2397         u8 monitor_other_switch[2];
2398
2399         private->monitor_other_updated = 0;
2400
2401         if (info->direct_monitor)
2402                 return scarlett2_usb_get_config(
2403                         mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
2404                         1, &private->direct_monitor_switch);
2405
2406         /* if it doesn't do speaker switching then it also doesn't do
2407          * talkback
2408          */
2409         if (!info->has_speaker_switching)
2410                 return 0;
2411
2412         err = scarlett2_usb_get_config(
2413                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2414                 2, monitor_other_enable);
2415         if (err < 0)
2416                 return err;
2417
2418         err = scarlett2_usb_get_config(
2419                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2420                 2, monitor_other_switch);
2421         if (err < 0)
2422                 return err;
2423
2424         if (!monitor_other_enable[0])
2425                 private->speaker_switching_switch = 0;
2426         else
2427                 private->speaker_switching_switch = monitor_other_switch[0] + 1;
2428
2429         if (info->has_talkback) {
2430                 const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2431                         info->port_count;
2432                 int num_mixes =
2433                         port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2434                 u16 bitmap;
2435                 int i;
2436
2437                 if (!monitor_other_enable[1])
2438                         private->talkback_switch = 0;
2439                 else
2440                         private->talkback_switch = monitor_other_switch[1] + 1;
2441
2442                 err = scarlett2_usb_get_config(mixer,
2443                                                SCARLETT2_CONFIG_TALKBACK_MAP,
2444                                                1, &bitmap);
2445                 for (i = 0; i < num_mixes; i++, bitmap >>= 1)
2446                         private->talkback_map[i] = bitmap & 1;
2447         }
2448
2449         return 0;
2450 }
2451
2452 static int scarlett2_direct_monitor_ctl_get(
2453         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2454 {
2455         struct usb_mixer_elem_info *elem = kctl->private_data;
2456         struct usb_mixer_interface *mixer = elem->head.mixer;
2457         struct scarlett2_data *private = elem->head.mixer->private_data;
2458
2459         mutex_lock(&private->data_mutex);
2460         if (private->monitor_other_updated)
2461                 scarlett2_update_monitor_other(mixer);
2462         ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
2463         mutex_unlock(&private->data_mutex);
2464
2465         return 0;
2466 }
2467
2468 static int scarlett2_direct_monitor_ctl_put(
2469         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2470 {
2471         struct usb_mixer_elem_info *elem = kctl->private_data;
2472         struct usb_mixer_interface *mixer = elem->head.mixer;
2473         struct scarlett2_data *private = mixer->private_data;
2474
2475         int index = elem->control;
2476         int oval, val, err = 0;
2477
2478         mutex_lock(&private->data_mutex);
2479
2480         oval = private->direct_monitor_switch;
2481         val = min(ucontrol->value.enumerated.item[0], 2U);
2482
2483         if (oval == val)
2484                 goto unlock;
2485
2486         private->direct_monitor_switch = val;
2487
2488         /* Send switch change to the device */
2489         err = scarlett2_usb_set_config(
2490                 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
2491         if (err == 0)
2492                 err = 1;
2493
2494 unlock:
2495         mutex_unlock(&private->data_mutex);
2496         return err;
2497 }
2498
2499 static int scarlett2_direct_monitor_stereo_enum_ctl_info(
2500         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2501 {
2502         static const char *const values[3] = {
2503                 "Off", "Mono", "Stereo"
2504         };
2505
2506         return snd_ctl_enum_info(uinfo, 1, 3, values);
2507 }
2508
2509 /* Direct Monitor for Solo is mono-only and only needs a boolean control
2510  * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
2511  */
2512 static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
2513         {
2514                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2515                 .name = "",
2516                 .info = snd_ctl_boolean_mono_info,
2517                 .get  = scarlett2_direct_monitor_ctl_get,
2518                 .put  = scarlett2_direct_monitor_ctl_put,
2519         },
2520         {
2521                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2522                 .name = "",
2523                 .info = scarlett2_direct_monitor_stereo_enum_ctl_info,
2524                 .get  = scarlett2_direct_monitor_ctl_get,
2525                 .put  = scarlett2_direct_monitor_ctl_put,
2526         }
2527 };
2528
2529 static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer)
2530 {
2531         struct scarlett2_data *private = mixer->private_data;
2532         const struct scarlett2_device_info *info = private->info;
2533
2534         if (!info->direct_monitor)
2535                 return 0;
2536
2537         return scarlett2_add_new_ctl(
2538                 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
2539                 0, 1, "Direct Monitor Playback Switch",
2540                 &private->direct_monitor_ctl);
2541 }
2542
2543 /*** Speaker Switching Control ***/
2544
2545 static int scarlett2_speaker_switch_enum_ctl_info(
2546         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2547 {
2548         static const char *const values[3] = {
2549                 "Off", "Main", "Alt"
2550         };
2551
2552         return snd_ctl_enum_info(uinfo, 1, 3, values);
2553 }
2554
2555 static int scarlett2_speaker_switch_enum_ctl_get(
2556         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2557 {
2558         struct usb_mixer_elem_info *elem = kctl->private_data;
2559         struct usb_mixer_interface *mixer = elem->head.mixer;
2560         struct scarlett2_data *private = mixer->private_data;
2561
2562         mutex_lock(&private->data_mutex);
2563         if (private->monitor_other_updated)
2564                 scarlett2_update_monitor_other(mixer);
2565         ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
2566         mutex_unlock(&private->data_mutex);
2567
2568         return 0;
2569 }
2570
2571 /* when speaker switching gets enabled, switch the main/alt speakers
2572  * to HW volume and disable those controls
2573  */
2574 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
2575 {
2576         struct snd_card *card = mixer->chip->card;
2577         struct scarlett2_data *private = mixer->private_data;
2578         int i, err;
2579
2580         for (i = 0; i < 4; i++) {
2581                 int index = line_out_remap(private, i);
2582
2583                 /* switch the main/alt speakers to HW volume */
2584                 if (!private->vol_sw_hw_switch[index]) {
2585                         err = scarlett2_sw_hw_change(private->mixer, i, 1);
2586                         if (err < 0)
2587                                 return err;
2588                 }
2589
2590                 /* disable the line out SW/HW switch */
2591                 scarlett2_sw_hw_ctl_ro(private, i);
2592                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2593                                &private->sw_hw_ctls[i]->id);
2594         }
2595
2596         /* when the next monitor-other notify comes in, update the mux
2597          * configuration
2598          */
2599         private->speaker_switching_switched = 1;
2600
2601         return 0;
2602 }
2603
2604 /* when speaker switching gets disabled, reenable the hw/sw controls
2605  * and invalidate the routing
2606  */
2607 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
2608 {
2609         struct snd_card *card = mixer->chip->card;
2610         struct scarlett2_data *private = mixer->private_data;
2611         int i;
2612
2613         /* enable the line out SW/HW switch */
2614         for (i = 0; i < 4; i++) {
2615                 scarlett2_sw_hw_ctl_rw(private, i);
2616                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2617                                &private->sw_hw_ctls[i]->id);
2618         }
2619
2620         /* when the next monitor-other notify comes in, update the mux
2621          * configuration
2622          */
2623         private->speaker_switching_switched = 1;
2624 }
2625
2626 static int scarlett2_speaker_switch_enum_ctl_put(
2627         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2628 {
2629         struct usb_mixer_elem_info *elem = kctl->private_data;
2630         struct usb_mixer_interface *mixer = elem->head.mixer;
2631         struct scarlett2_data *private = mixer->private_data;
2632
2633         int oval, val, err = 0;
2634
2635         mutex_lock(&private->data_mutex);
2636
2637         oval = private->speaker_switching_switch;
2638         val = min(ucontrol->value.enumerated.item[0], 2U);
2639
2640         if (oval == val)
2641                 goto unlock;
2642
2643         private->speaker_switching_switch = val;
2644
2645         /* enable/disable speaker switching */
2646         err = scarlett2_usb_set_config(
2647                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2648                 0, !!val);
2649         if (err < 0)
2650                 goto unlock;
2651
2652         /* if speaker switching is enabled, select main or alt */
2653         err = scarlett2_usb_set_config(
2654                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2655                 0, val == 2);
2656         if (err < 0)
2657                 goto unlock;
2658
2659         /* update controls if speaker switching gets enabled or disabled */
2660         if (!oval && val)
2661                 err = scarlett2_speaker_switch_enable(mixer);
2662         else if (oval && !val)
2663                 scarlett2_speaker_switch_disable(mixer);
2664
2665         if (err == 0)
2666                 err = 1;
2667
2668 unlock:
2669         mutex_unlock(&private->data_mutex);
2670         return err;
2671 }
2672
2673 static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
2674         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2675         .name = "",
2676         .info = scarlett2_speaker_switch_enum_ctl_info,
2677         .get  = scarlett2_speaker_switch_enum_ctl_get,
2678         .put  = scarlett2_speaker_switch_enum_ctl_put,
2679 };
2680
2681 static int scarlett2_add_speaker_switch_ctl(
2682         struct usb_mixer_interface *mixer)
2683 {
2684         struct scarlett2_data *private = mixer->private_data;
2685         const struct scarlett2_device_info *info = private->info;
2686
2687         if (!info->has_speaker_switching)
2688                 return 0;
2689
2690         return scarlett2_add_new_ctl(
2691                 mixer, &scarlett2_speaker_switch_enum_ctl,
2692                 0, 1, "Speaker Switching Playback Enum",
2693                 &private->speaker_switching_ctl);
2694 }
2695
2696 /*** Talkback and Talkback Map Controls ***/
2697
2698 static int scarlett2_talkback_enum_ctl_info(
2699         struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
2700 {
2701         static const char *const values[3] = {
2702                 "Disabled", "Off", "On"
2703         };
2704
2705         return snd_ctl_enum_info(uinfo, 1, 3, values);
2706 }
2707
2708 static int scarlett2_talkback_enum_ctl_get(
2709         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2710 {
2711         struct usb_mixer_elem_info *elem = kctl->private_data;
2712         struct usb_mixer_interface *mixer = elem->head.mixer;
2713         struct scarlett2_data *private = mixer->private_data;
2714
2715         mutex_lock(&private->data_mutex);
2716         if (private->monitor_other_updated)
2717                 scarlett2_update_monitor_other(mixer);
2718         ucontrol->value.enumerated.item[0] = private->talkback_switch;
2719         mutex_unlock(&private->data_mutex);
2720
2721         return 0;
2722 }
2723
2724 static int scarlett2_talkback_enum_ctl_put(
2725         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2726 {
2727         struct usb_mixer_elem_info *elem = kctl->private_data;
2728         struct usb_mixer_interface *mixer = elem->head.mixer;
2729         struct scarlett2_data *private = mixer->private_data;
2730
2731         int oval, val, err = 0;
2732
2733         mutex_lock(&private->data_mutex);
2734
2735         oval = private->talkback_switch;
2736         val = min(ucontrol->value.enumerated.item[0], 2U);
2737
2738         if (oval == val)
2739                 goto unlock;
2740
2741         private->talkback_switch = val;
2742
2743         /* enable/disable talkback */
2744         err = scarlett2_usb_set_config(
2745                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
2746                 1, !!val);
2747         if (err < 0)
2748                 goto unlock;
2749
2750         /* if talkback is enabled, select main or alt */
2751         err = scarlett2_usb_set_config(
2752                 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
2753                 1, val == 2);
2754         if (err == 0)
2755                 err = 1;
2756
2757 unlock:
2758         mutex_unlock(&private->data_mutex);
2759         return err;
2760 }
2761
2762 static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
2763         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2764         .name = "",
2765         .info = scarlett2_talkback_enum_ctl_info,
2766         .get  = scarlett2_talkback_enum_ctl_get,
2767         .put  = scarlett2_talkback_enum_ctl_put,
2768 };
2769
2770 static int scarlett2_talkback_map_ctl_get(
2771         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2772 {
2773         struct usb_mixer_elem_info *elem = kctl->private_data;
2774         struct usb_mixer_interface *mixer = elem->head.mixer;
2775         struct scarlett2_data *private = mixer->private_data;
2776         int index = elem->control;
2777
2778         ucontrol->value.integer.value[0] = private->talkback_map[index];
2779
2780         return 0;
2781 }
2782
2783 static int scarlett2_talkback_map_ctl_put(
2784         struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
2785 {
2786         struct usb_mixer_elem_info *elem = kctl->private_data;
2787         struct usb_mixer_interface *mixer = elem->head.mixer;
2788         struct scarlett2_data *private = mixer->private_data;
2789         const int (*port_count)[SCARLETT2_PORT_DIRNS] =
2790                 private->info->port_count;
2791         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2792
2793         int index = elem->control;
2794         int oval, val, err = 0, i;
2795         u16 bitmap = 0;
2796
2797         mutex_lock(&private->data_mutex);
2798
2799         oval = private->talkback_map[index];
2800         val = !!ucontrol->value.integer.value[0];
2801
2802         if (oval == val)
2803                 goto unlock;
2804
2805         private->talkback_map[index] = val;
2806
2807         for (i = 0; i < num_mixes; i++)
2808                 bitmap |= private->talkback_map[i] << i;
2809
2810         /* Send updated bitmap to the device */
2811         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
2812                                        0, bitmap);
2813         if (err == 0)
2814                 err = 1;
2815
2816 unlock:
2817         mutex_unlock(&private->data_mutex);
2818         return err;
2819 }
2820
2821 static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
2822         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2823         .name = "",
2824         .info = snd_ctl_boolean_mono_info,
2825         .get  = scarlett2_talkback_map_ctl_get,
2826         .put  = scarlett2_talkback_map_ctl_put,
2827 };
2828
2829 static int scarlett2_add_talkback_ctls(
2830         struct usb_mixer_interface *mixer)
2831 {
2832         struct scarlett2_data *private = mixer->private_data;
2833         const struct scarlett2_device_info *info = private->info;
2834         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2835         int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
2836         int err, i;
2837         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2838
2839         if (!info->has_talkback)
2840                 return 0;
2841
2842         err = scarlett2_add_new_ctl(
2843                 mixer, &scarlett2_talkback_enum_ctl,
2844                 0, 1, "Talkback Playback Enum",
2845                 &private->talkback_ctl);
2846         if (err < 0)
2847                 return err;
2848
2849         for (i = 0; i < num_mixes; i++) {
2850                 snprintf(s, sizeof(s),
2851                          "Talkback Mix %c Playback Switch", i + 'A');
2852                 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
2853                                             i, 1, s, NULL);
2854                 if (err < 0)
2855                         return err;
2856         }
2857
2858         return 0;
2859 }
2860
2861 /*** Dim/Mute Controls ***/
2862
2863 static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
2864                                       struct snd_ctl_elem_value *ucontrol)
2865 {
2866         struct usb_mixer_elem_info *elem = kctl->private_data;
2867         struct usb_mixer_interface *mixer = elem->head.mixer;
2868         struct scarlett2_data *private = mixer->private_data;
2869
2870         mutex_lock(&private->data_mutex);
2871         if (private->vol_updated)
2872                 scarlett2_update_volumes(mixer);
2873         mutex_unlock(&private->data_mutex);
2874
2875         ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
2876         return 0;
2877 }
2878
2879 static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
2880                                       struct snd_ctl_elem_value *ucontrol)
2881 {
2882         struct usb_mixer_elem_info *elem = kctl->private_data;
2883         struct usb_mixer_interface *mixer = elem->head.mixer;
2884         struct scarlett2_data *private = mixer->private_data;
2885         const struct scarlett2_device_info *info = private->info;
2886         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2887         int num_line_out =
2888                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
2889
2890         int index = elem->control;
2891         int oval, val, err = 0, i;
2892
2893         mutex_lock(&private->data_mutex);
2894
2895         oval = private->dim_mute[index];
2896         val = !!ucontrol->value.integer.value[0];
2897
2898         if (oval == val)
2899                 goto unlock;
2900
2901         private->dim_mute[index] = val;
2902
2903         /* Send switch change to the device */
2904         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
2905                                        index, val);
2906         if (err == 0)
2907                 err = 1;
2908
2909         if (index == SCARLETT2_BUTTON_MUTE)
2910                 for (i = 0; i < num_line_out; i++) {
2911                         int line_index = line_out_remap(private, i);
2912
2913                         if (private->vol_sw_hw_switch[line_index]) {
2914                                 private->mute_switch[line_index] = val;
2915                                 snd_ctl_notify(mixer->chip->card,
2916                                                SNDRV_CTL_EVENT_MASK_INFO,
2917                                                &private->mute_ctls[i]->id);
2918                         }
2919                 }
2920
2921 unlock:
2922         mutex_unlock(&private->data_mutex);
2923         return err;
2924 }
2925
2926 static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
2927         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2928         .name = "",
2929         .info = snd_ctl_boolean_mono_info,
2930         .get  = scarlett2_dim_mute_ctl_get,
2931         .put  = scarlett2_dim_mute_ctl_put
2932 };
2933
2934 /*** Create the analogue output controls ***/
2935
2936 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
2937 {
2938         struct scarlett2_data *private = mixer->private_data;
2939         const struct scarlett2_device_info *info = private->info;
2940         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2941         int num_line_out =
2942                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
2943         int err, i;
2944         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
2945
2946         /* Add R/O HW volume control */
2947         if (info->line_out_hw_vol) {
2948                 snprintf(s, sizeof(s), "Master HW Playback Volume");
2949                 err = scarlett2_add_new_ctl(mixer,
2950                                             &scarlett2_master_volume_ctl,
2951                                             0, 1, s, &private->master_vol_ctl);
2952                 if (err < 0)
2953                         return err;
2954         }
2955
2956         /* Add volume controls */
2957         for (i = 0; i < num_line_out; i++) {
2958                 int index = line_out_remap(private, i);
2959
2960                 /* Fader */
2961                 if (info->line_out_descrs[i])
2962                         snprintf(s, sizeof(s),
2963                                  "Line %02d (%s) Playback Volume",
2964                                  i + 1, info->line_out_descrs[i]);
2965                 else
2966                         snprintf(s, sizeof(s),
2967                                  "Line %02d Playback Volume",
2968                                  i + 1);
2969                 err = scarlett2_add_new_ctl(mixer,
2970                                             &scarlett2_line_out_volume_ctl,
2971                                             i, 1, s, &private->vol_ctls[i]);
2972                 if (err < 0)
2973                         return err;
2974
2975                 /* Mute Switch */
2976                 snprintf(s, sizeof(s),
2977                          "Line %02d Mute Playback Switch",
2978                          i + 1);
2979                 err = scarlett2_add_new_ctl(mixer,
2980                                             &scarlett2_mute_ctl,
2981                                             i, 1, s,
2982                                             &private->mute_ctls[i]);
2983                 if (err < 0)
2984                         return err;
2985
2986                 /* Make the fader and mute controls read-only if the
2987                  * SW/HW switch is set to HW
2988                  */
2989                 if (private->vol_sw_hw_switch[index])
2990                         scarlett2_vol_ctl_set_writable(mixer, i, 0);
2991
2992                 /* SW/HW Switch */
2993                 if (info->line_out_hw_vol) {
2994                         snprintf(s, sizeof(s),
2995                                  "Line Out %02d Volume Control Playback Enum",
2996                                  i + 1);
2997                         err = scarlett2_add_new_ctl(mixer,
2998                                                     &scarlett2_sw_hw_enum_ctl,
2999                                                     i, 1, s,
3000                                                     &private->sw_hw_ctls[i]);
3001                         if (err < 0)
3002                                 return err;
3003
3004                         /* Make the switch read-only if the line is
3005                          * involved in speaker switching
3006                          */
3007                         if (private->speaker_switching_switch && i < 4)
3008                                 scarlett2_sw_hw_ctl_ro(private, i);
3009                 }
3010         }
3011
3012         /* Add dim/mute controls */
3013         if (info->line_out_hw_vol)
3014                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
3015                         err = scarlett2_add_new_ctl(
3016                                 mixer, &scarlett2_dim_mute_ctl,
3017                                 i, 1, scarlett2_dim_mute_names[i],
3018                                 &private->dim_mute_ctls[i]);
3019                         if (err < 0)
3020                                 return err;
3021                 }
3022
3023         return 0;
3024 }
3025
3026 /*** Create the analogue input controls ***/
3027
3028 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
3029 {
3030         struct scarlett2_data *private = mixer->private_data;
3031         const struct scarlett2_device_info *info = private->info;
3032         int err, i;
3033         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3034         const char *fmt = "Line In %d %s Capture %s";
3035         const char *fmt2 = "Line In %d-%d %s Capture %s";
3036
3037         /* Add input level (line/inst) controls */
3038         for (i = 0; i < info->level_input_count; i++) {
3039                 snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
3040                          "Level", "Enum");
3041                 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
3042                                             i, 1, s, &private->level_ctls[i]);
3043                 if (err < 0)
3044                         return err;
3045         }
3046
3047         /* Add input pad controls */
3048         for (i = 0; i < info->pad_input_count; i++) {
3049                 snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
3050                 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
3051                                             i, 1, s, &private->pad_ctls[i]);
3052                 if (err < 0)
3053                         return err;
3054         }
3055
3056         /* Add input air controls */
3057         for (i = 0; i < info->air_input_count; i++) {
3058                 snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch");
3059                 err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl,
3060                                             i, 1, s, &private->air_ctls[i]);
3061                 if (err < 0)
3062                         return err;
3063         }
3064
3065         /* Add input phantom controls */
3066         if (info->inputs_per_phantom == 1) {
3067                 for (i = 0; i < info->phantom_count; i++) {
3068                         snprintf(s, sizeof(s), fmt, i + 1,
3069                                  "Phantom Power", "Switch");
3070                         err = scarlett2_add_new_ctl(
3071                                 mixer, &scarlett2_phantom_ctl,
3072                                 i, 1, s, &private->phantom_ctls[i]);
3073                         if (err < 0)
3074                                 return err;
3075                 }
3076         } else if (info->inputs_per_phantom > 1) {
3077                 for (i = 0; i < info->phantom_count; i++) {
3078                         int from = i * info->inputs_per_phantom + 1;
3079                         int to = (i + 1) * info->inputs_per_phantom;
3080
3081                         snprintf(s, sizeof(s), fmt2, from, to,
3082                                  "Phantom Power", "Switch");
3083                         err = scarlett2_add_new_ctl(
3084                                 mixer, &scarlett2_phantom_ctl,
3085                                 i, 1, s, &private->phantom_ctls[i]);
3086                         if (err < 0)
3087                                 return err;
3088                 }
3089         }
3090         if (info->phantom_count) {
3091                 err = scarlett2_add_new_ctl(
3092                         mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
3093                         "Phantom Power Persistence Capture Switch", NULL);
3094                 if (err < 0)
3095                         return err;
3096         }
3097
3098         return 0;
3099 }
3100
3101 /*** Mixer Volume Controls ***/
3102
3103 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
3104                                     struct snd_ctl_elem_info *uinfo)
3105 {
3106         struct usb_mixer_elem_info *elem = kctl->private_data;
3107
3108         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3109         uinfo->count = elem->channels;
3110         uinfo->value.integer.min = 0;
3111         uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
3112         uinfo->value.integer.step = 1;
3113         return 0;
3114 }
3115
3116 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
3117                                    struct snd_ctl_elem_value *ucontrol)
3118 {
3119         struct usb_mixer_elem_info *elem = kctl->private_data;
3120         struct scarlett2_data *private = elem->head.mixer->private_data;
3121
3122         ucontrol->value.integer.value[0] = private->mix[elem->control];
3123         return 0;
3124 }
3125
3126 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
3127                                    struct snd_ctl_elem_value *ucontrol)
3128 {
3129         struct usb_mixer_elem_info *elem = kctl->private_data;
3130         struct usb_mixer_interface *mixer = elem->head.mixer;
3131         struct scarlett2_data *private = mixer->private_data;
3132         const struct scarlett2_device_info *info = private->info;
3133         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3134         int oval, val, num_mixer_in, mix_num, err = 0;
3135         int index = elem->control;
3136
3137         mutex_lock(&private->data_mutex);
3138
3139         oval = private->mix[index];
3140         val = ucontrol->value.integer.value[0];
3141         num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3142         mix_num = index / num_mixer_in;
3143
3144         if (oval == val)
3145                 goto unlock;
3146
3147         private->mix[index] = val;
3148         err = scarlett2_usb_set_mix(mixer, mix_num);
3149         if (err == 0)
3150                 err = 1;
3151
3152 unlock:
3153         mutex_unlock(&private->data_mutex);
3154         return err;
3155 }
3156
3157 static const DECLARE_TLV_DB_MINMAX(
3158         db_scale_scarlett2_mixer,
3159         SCARLETT2_MIXER_MIN_DB * 100,
3160         SCARLETT2_MIXER_MAX_DB * 100
3161 );
3162
3163 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
3164         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3165         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3166                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3167         .name = "",
3168         .info = scarlett2_mixer_ctl_info,
3169         .get  = scarlett2_mixer_ctl_get,
3170         .put  = scarlett2_mixer_ctl_put,
3171         .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
3172         .tlv = { .p = db_scale_scarlett2_mixer }
3173 };
3174
3175 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
3176 {
3177         struct scarlett2_data *private = mixer->private_data;
3178         const struct scarlett2_device_info *info = private->info;
3179         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3180         int err, i, j;
3181         int index;
3182         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3183
3184         int num_inputs =
3185                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
3186         int num_outputs =
3187                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3188
3189         for (i = 0, index = 0; i < num_outputs; i++)
3190                 for (j = 0; j < num_inputs; j++, index++) {
3191                         snprintf(s, sizeof(s),
3192                                  "Mix %c Input %02d Playback Volume",
3193                                  'A' + i, j + 1);
3194                         err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
3195                                                     index, 1, s, NULL);
3196                         if (err < 0)
3197                                 return err;
3198                 }
3199
3200         return 0;
3201 }
3202
3203 /*** Mux Source Selection Controls ***/
3204
3205 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
3206                                            struct snd_ctl_elem_info *uinfo)
3207 {
3208         struct usb_mixer_elem_info *elem = kctl->private_data;
3209         struct scarlett2_data *private = elem->head.mixer->private_data;
3210         const struct scarlett2_device_info *info = private->info;
3211         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3212         unsigned int item = uinfo->value.enumerated.item;
3213         int items = private->num_mux_srcs;
3214         int port_type;
3215
3216         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3217         uinfo->count = elem->channels;
3218         uinfo->value.enumerated.items = items;
3219
3220         if (item >= items)
3221                 item = uinfo->value.enumerated.item = items - 1;
3222
3223         for (port_type = 0;
3224              port_type < SCARLETT2_PORT_TYPE_COUNT;
3225              port_type++) {
3226                 if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
3227                         const struct scarlett2_port *port =
3228                                 &scarlett2_ports[port_type];
3229
3230                         sprintf(uinfo->value.enumerated.name,
3231                                 port->src_descr, item + port->src_num_offset);
3232                         return 0;
3233                 }
3234                 item -= port_count[port_type][SCARLETT2_PORT_IN];
3235         }
3236
3237         return -EINVAL;
3238 }
3239
3240 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
3241                                           struct snd_ctl_elem_value *ucontrol)
3242 {
3243         struct usb_mixer_elem_info *elem = kctl->private_data;
3244         struct usb_mixer_interface *mixer = elem->head.mixer;
3245         struct scarlett2_data *private = mixer->private_data;
3246         const struct scarlett2_device_info *info = private->info;
3247         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3248         int line_out_count =
3249                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3250         int index = elem->control;
3251
3252         if (index < line_out_count)
3253                 index = line_out_remap(private, index);
3254
3255         mutex_lock(&private->data_mutex);
3256         if (private->mux_updated)
3257                 scarlett2_usb_get_mux(mixer);
3258         ucontrol->value.enumerated.item[0] = private->mux[index];
3259         mutex_unlock(&private->data_mutex);
3260
3261         return 0;
3262 }
3263
3264 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
3265                                           struct snd_ctl_elem_value *ucontrol)
3266 {
3267         struct usb_mixer_elem_info *elem = kctl->private_data;
3268         struct usb_mixer_interface *mixer = elem->head.mixer;
3269         struct scarlett2_data *private = mixer->private_data;
3270         const struct scarlett2_device_info *info = private->info;
3271         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3272         int line_out_count =
3273                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3274         int index = elem->control;
3275         int oval, val, err = 0;
3276
3277         if (index < line_out_count)
3278                 index = line_out_remap(private, index);
3279
3280         mutex_lock(&private->data_mutex);
3281
3282         oval = private->mux[index];
3283         val = min(ucontrol->value.enumerated.item[0],
3284                   private->num_mux_srcs - 1U);
3285
3286         if (oval == val)
3287                 goto unlock;
3288
3289         private->mux[index] = val;
3290         err = scarlett2_usb_set_mux(mixer);
3291         if (err == 0)
3292                 err = 1;
3293
3294 unlock:
3295         mutex_unlock(&private->data_mutex);
3296         return err;
3297 }
3298
3299 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
3300         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3301         .name = "",
3302         .info = scarlett2_mux_src_enum_ctl_info,
3303         .get  = scarlett2_mux_src_enum_ctl_get,
3304         .put  = scarlett2_mux_src_enum_ctl_put,
3305 };
3306
3307 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
3308 {
3309         struct scarlett2_data *private = mixer->private_data;
3310         const struct scarlett2_device_info *info = private->info;
3311         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3312         int port_type, channel, i;
3313
3314         for (i = 0, port_type = 0;
3315              port_type < SCARLETT2_PORT_TYPE_COUNT;
3316              port_type++) {
3317                 for (channel = 0;
3318                      channel < port_count[port_type][SCARLETT2_PORT_OUT];
3319                      channel++, i++) {
3320                         int err;
3321                         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
3322                         const char *const descr =
3323                                 scarlett2_ports[port_type].dst_descr;
3324
3325                         snprintf(s, sizeof(s) - 5, descr, channel + 1);
3326                         strcat(s, " Enum");
3327
3328                         err = scarlett2_add_new_ctl(mixer,
3329                                                     &scarlett2_mux_src_enum_ctl,
3330                                                     i, 1, s,
3331                                                     &private->mux_ctls[i]);
3332                         if (err < 0)
3333                                 return err;
3334                 }
3335         }
3336
3337         return 0;
3338 }
3339
3340 /*** Meter Controls ***/
3341
3342 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
3343                                     struct snd_ctl_elem_info *uinfo)
3344 {
3345         struct usb_mixer_elem_info *elem = kctl->private_data;
3346
3347         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3348         uinfo->count = elem->channels;
3349         uinfo->value.integer.min = 0;
3350         uinfo->value.integer.max = 4095;
3351         uinfo->value.integer.step = 1;
3352         return 0;
3353 }
3354
3355 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
3356                                    struct snd_ctl_elem_value *ucontrol)
3357 {
3358         struct usb_mixer_elem_info *elem = kctl->private_data;
3359         u16 meter_levels[SCARLETT2_MAX_METERS];
3360         int i, err;
3361
3362         err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels,
3363                                              meter_levels);
3364         if (err < 0)
3365                 return err;
3366
3367         for (i = 0; i < elem->channels; i++)
3368                 ucontrol->value.integer.value[i] = meter_levels[i];
3369
3370         return 0;
3371 }
3372
3373 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
3374         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
3375         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
3376         .name = "",
3377         .info = scarlett2_meter_ctl_info,
3378         .get  = scarlett2_meter_ctl_get
3379 };
3380
3381 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
3382 {
3383         struct scarlett2_data *private = mixer->private_data;
3384
3385         /* devices without a mixer also don't support reporting levels */
3386         if (!private->info->has_mixer)
3387                 return 0;
3388
3389         return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
3390                                      0, private->num_mux_dsts,
3391                                      "Level Meter", NULL);
3392 }
3393
3394 /*** MSD Controls ***/
3395
3396 static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
3397                                  struct snd_ctl_elem_value *ucontrol)
3398 {
3399         struct usb_mixer_elem_info *elem = kctl->private_data;
3400         struct scarlett2_data *private = elem->head.mixer->private_data;
3401
3402         ucontrol->value.integer.value[0] = private->msd_switch;
3403         return 0;
3404 }
3405
3406 static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
3407                                  struct snd_ctl_elem_value *ucontrol)
3408 {
3409         struct usb_mixer_elem_info *elem = kctl->private_data;
3410         struct usb_mixer_interface *mixer = elem->head.mixer;
3411         struct scarlett2_data *private = mixer->private_data;
3412
3413         int oval, val, err = 0;
3414
3415         mutex_lock(&private->data_mutex);
3416
3417         oval = private->msd_switch;
3418         val = !!ucontrol->value.integer.value[0];
3419
3420         if (oval == val)
3421                 goto unlock;
3422
3423         private->msd_switch = val;
3424
3425         /* Send switch change to the device */
3426         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3427                                        0, val);
3428         if (err == 0)
3429                 err = 1;
3430
3431 unlock:
3432         mutex_unlock(&private->data_mutex);
3433         return err;
3434 }
3435
3436 static const struct snd_kcontrol_new scarlett2_msd_ctl = {
3437         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3438         .name = "",
3439         .info = snd_ctl_boolean_mono_info,
3440         .get  = scarlett2_msd_ctl_get,
3441         .put  = scarlett2_msd_ctl_put,
3442 };
3443
3444 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
3445 {
3446         struct scarlett2_data *private = mixer->private_data;
3447         const struct scarlett2_device_info *info = private->info;
3448
3449         if (!info->has_msd_mode)
3450                 return 0;
3451
3452         /* If MSD mode is off, hide the switch by default */
3453         if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
3454                 return 0;
3455
3456         /* Add MSD control */
3457         return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
3458                                      0, 1, "MSD Mode", NULL);
3459 }
3460
3461 /*** Cleanup/Suspend Callbacks ***/
3462
3463 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
3464 {
3465         struct scarlett2_data *private = mixer->private_data;
3466
3467         cancel_delayed_work_sync(&private->work);
3468         kfree(private);
3469         mixer->private_data = NULL;
3470 }
3471
3472 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
3473 {
3474         struct scarlett2_data *private = mixer->private_data;
3475
3476         if (cancel_delayed_work_sync(&private->work))
3477                 scarlett2_config_save(private->mixer);
3478 }
3479
3480 /*** Initialisation ***/
3481
3482 static void scarlett2_count_mux_io(struct scarlett2_data *private)
3483 {
3484         const struct scarlett2_device_info *info = private->info;
3485         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3486         int port_type, srcs = 0, dsts = 0;
3487
3488         for (port_type = 0;
3489              port_type < SCARLETT2_PORT_TYPE_COUNT;
3490              port_type++) {
3491                 srcs += port_count[port_type][SCARLETT2_PORT_IN];
3492                 dsts += port_count[port_type][SCARLETT2_PORT_OUT];
3493         }
3494
3495         private->num_mux_srcs = srcs;
3496         private->num_mux_dsts = dsts;
3497 }
3498
3499 /* Look through the interface descriptors for the Focusrite Control
3500  * interface (bInterfaceClass = 255 Vendor Specific Class) and set
3501  * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
3502  * in private
3503  */
3504 static int scarlett2_find_fc_interface(struct usb_device *dev,
3505                                        struct scarlett2_data *private)
3506 {
3507         struct usb_host_config *config = dev->actconfig;
3508         int i;
3509
3510         for (i = 0; i < config->desc.bNumInterfaces; i++) {
3511                 struct usb_interface *intf = config->interface[i];
3512                 struct usb_interface_descriptor *desc =
3513                         &intf->altsetting[0].desc;
3514                 struct usb_endpoint_descriptor *epd;
3515
3516                 if (desc->bInterfaceClass != 255)
3517                         continue;
3518
3519                 epd = get_endpoint(intf->altsetting, 0);
3520                 private->bInterfaceNumber = desc->bInterfaceNumber;
3521                 private->bEndpointAddress = epd->bEndpointAddress &
3522                         USB_ENDPOINT_NUMBER_MASK;
3523                 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
3524                 private->bInterval = epd->bInterval;
3525                 return 0;
3526         }
3527
3528         return -EINVAL;
3529 }
3530
3531 /* Initialise private data */
3532 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
3533                                   const struct scarlett2_device_info *info)
3534 {
3535         struct scarlett2_data *private =
3536                 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
3537
3538         if (!private)
3539                 return -ENOMEM;
3540
3541         mutex_init(&private->usb_mutex);
3542         mutex_init(&private->data_mutex);
3543         INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
3544
3545         mixer->private_data = private;
3546         mixer->private_free = scarlett2_private_free;
3547         mixer->private_suspend = scarlett2_private_suspend;
3548
3549         private->info = info;
3550         scarlett2_count_mux_io(private);
3551         private->scarlett2_seq = 0;
3552         private->mixer = mixer;
3553
3554         return scarlett2_find_fc_interface(mixer->chip->dev, private);
3555 }
3556
3557 /* Cargo cult proprietary initialisation sequence */
3558 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
3559 {
3560         struct usb_device *dev = mixer->chip->dev;
3561         struct scarlett2_data *private = mixer->private_data;
3562         u8 buf[24];
3563         int err;
3564
3565         if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
3566                 return -EINVAL;
3567
3568         /* step 0 */
3569         err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
3570                                SCARLETT2_USB_CMD_INIT, buf, sizeof(buf));
3571         if (err < 0)
3572                 return err;
3573
3574         /* step 1 */
3575         private->scarlett2_seq = 1;
3576         err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
3577         if (err < 0)
3578                 return err;
3579
3580         /* step 2 */
3581         private->scarlett2_seq = 1;
3582         return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84);
3583 }
3584
3585 /* Read configuration from the interface on start */
3586 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
3587 {
3588         struct scarlett2_data *private = mixer->private_data;
3589         const struct scarlett2_device_info *info = private->info;
3590         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3591         int num_line_out =
3592                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3593         int num_mixer_out =
3594                 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
3595         struct scarlett2_usb_volume_status volume_status;
3596         int err, i;
3597
3598         if (info->has_msd_mode) {
3599                 err = scarlett2_usb_get_config(
3600                         mixer, SCARLETT2_CONFIG_MSD_SWITCH,
3601                         1, &private->msd_switch);
3602                 if (err < 0)
3603                         return err;
3604
3605                 /* no other controls are created if MSD mode is on */
3606                 if (private->msd_switch)
3607                         return 0;
3608         }
3609
3610         err = scarlett2_update_input_other(mixer);
3611         if (err < 0)
3612                 return err;
3613
3614         err = scarlett2_update_monitor_other(mixer);
3615         if (err < 0)
3616                 return err;
3617
3618         /* the rest of the configuration is for devices with a mixer */
3619         if (!info->has_mixer)
3620                 return 0;
3621
3622         err = scarlett2_update_sync(mixer);
3623         if (err < 0)
3624                 return err;
3625
3626         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
3627         if (err < 0)
3628                 return err;
3629
3630         if (info->line_out_hw_vol)
3631                 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3632                         private->dim_mute[i] = !!volume_status.dim_mute[i];
3633
3634         private->master_vol = clamp(
3635                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
3636                 0, SCARLETT2_VOLUME_BIAS);
3637
3638         for (i = 0; i < num_line_out; i++) {
3639                 int volume, mute;
3640
3641                 private->vol_sw_hw_switch[i] =
3642                         info->line_out_hw_vol
3643                                 && volume_status.sw_hw_switch[i];
3644
3645                 volume = private->vol_sw_hw_switch[i]
3646                            ? volume_status.master_vol
3647                            : volume_status.sw_vol[i];
3648                 volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
3649                                0, SCARLETT2_VOLUME_BIAS);
3650                 private->vol[i] = volume;
3651
3652                 mute = private->vol_sw_hw_switch[i]
3653                          ? private->dim_mute[SCARLETT2_BUTTON_MUTE]
3654                          : volume_status.mute_switch[i];
3655                 private->mute_switch[i] = mute;
3656         }
3657
3658         for (i = 0; i < num_mixer_out; i++) {
3659                 err = scarlett2_usb_get_mix(mixer, i);
3660                 if (err < 0)
3661                         return err;
3662         }
3663
3664         return scarlett2_usb_get_mux(mixer);
3665 }
3666
3667 /* Notify on sync change */
3668 static void scarlett2_notify_sync(
3669         struct usb_mixer_interface *mixer)
3670 {
3671         struct scarlett2_data *private = mixer->private_data;
3672
3673         private->sync_updated = 1;
3674
3675         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3676                        &private->sync_ctl->id);
3677 }
3678
3679 /* Notify on monitor change */
3680 static void scarlett2_notify_monitor(
3681         struct usb_mixer_interface *mixer)
3682 {
3683         struct snd_card *card = mixer->chip->card;
3684         struct scarlett2_data *private = mixer->private_data;
3685         const struct scarlett2_device_info *info = private->info;
3686         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3687         int num_line_out =
3688                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3689         int i;
3690
3691         /* if line_out_hw_vol is 0, there are no controls to update */
3692         if (!info->line_out_hw_vol)
3693                 return;
3694
3695         private->vol_updated = 1;
3696
3697         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3698                        &private->master_vol_ctl->id);
3699
3700         for (i = 0; i < num_line_out; i++)
3701                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3702                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3703                                        &private->vol_ctls[i]->id);
3704 }
3705
3706 /* Notify on dim/mute change */
3707 static void scarlett2_notify_dim_mute(
3708         struct usb_mixer_interface *mixer)
3709 {
3710         struct snd_card *card = mixer->chip->card;
3711         struct scarlett2_data *private = mixer->private_data;
3712         const struct scarlett2_device_info *info = private->info;
3713         const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3714         int num_line_out =
3715                 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
3716         int i;
3717
3718         private->vol_updated = 1;
3719
3720         if (!info->line_out_hw_vol)
3721                 return;
3722
3723         for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3724                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3725                                &private->dim_mute_ctls[i]->id);
3726
3727         for (i = 0; i < num_line_out; i++)
3728                 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3729                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3730                                        &private->mute_ctls[i]->id);
3731 }
3732
3733 /* Notify on "input other" change (level/pad/air) */
3734 static void scarlett2_notify_input_other(
3735         struct usb_mixer_interface *mixer)
3736 {
3737         struct snd_card *card = mixer->chip->card;
3738         struct scarlett2_data *private = mixer->private_data;
3739         const struct scarlett2_device_info *info = private->info;
3740         int i;
3741
3742         private->input_other_updated = 1;
3743
3744         for (i = 0; i < info->level_input_count; i++)
3745                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3746                                &private->level_ctls[i]->id);
3747         for (i = 0; i < info->pad_input_count; i++)
3748                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3749                                &private->pad_ctls[i]->id);
3750         for (i = 0; i < info->air_input_count; i++)
3751                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3752                                &private->air_ctls[i]->id);
3753         for (i = 0; i < info->phantom_count; i++)
3754                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3755                                &private->phantom_ctls[i]->id);
3756 }
3757
3758 /* Notify on "monitor other" change (direct monitor, speaker
3759  * switching, talkback)
3760  */
3761 static void scarlett2_notify_monitor_other(
3762         struct usb_mixer_interface *mixer)
3763 {
3764         struct snd_card *card = mixer->chip->card;
3765         struct scarlett2_data *private = mixer->private_data;
3766         const struct scarlett2_device_info *info = private->info;
3767
3768         private->monitor_other_updated = 1;
3769
3770         if (info->direct_monitor) {
3771                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3772                                &private->direct_monitor_ctl->id);
3773                 return;
3774         }
3775
3776         if (info->has_speaker_switching)
3777                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3778                                &private->speaker_switching_ctl->id);
3779
3780         if (info->has_talkback)
3781                 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3782                                &private->talkback_ctl->id);
3783
3784         /* if speaker switching was recently enabled or disabled,
3785          * invalidate the dim/mute and mux enum controls
3786          */
3787         if (private->speaker_switching_switched) {
3788                 int i;
3789
3790                 scarlett2_notify_dim_mute(mixer);
3791
3792                 private->speaker_switching_switched = 0;
3793                 private->mux_updated = 1;
3794
3795                 for (i = 0; i < private->num_mux_dsts; i++)
3796                         snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
3797                                        &private->mux_ctls[i]->id);
3798         }
3799 }
3800
3801 /* Interrupt callback */
3802 static void scarlett2_notify(struct urb *urb)
3803 {
3804         struct usb_mixer_interface *mixer = urb->context;
3805         int len = urb->actual_length;
3806         int ustatus = urb->status;
3807         u32 data;
3808
3809         if (ustatus != 0 || len != 8)
3810                 goto requeue;
3811
3812         data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
3813         if (data & SCARLETT2_USB_NOTIFY_SYNC)
3814                 scarlett2_notify_sync(mixer);
3815         if (data & SCARLETT2_USB_NOTIFY_MONITOR)
3816                 scarlett2_notify_monitor(mixer);
3817         if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE)
3818                 scarlett2_notify_dim_mute(mixer);
3819         if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER)
3820                 scarlett2_notify_input_other(mixer);
3821         if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER)
3822                 scarlett2_notify_monitor_other(mixer);
3823
3824 requeue:
3825         if (ustatus != -ENOENT &&
3826             ustatus != -ECONNRESET &&
3827             ustatus != -ESHUTDOWN) {
3828                 urb->dev = mixer->chip->dev;
3829                 usb_submit_urb(urb, GFP_ATOMIC);
3830         }
3831 }
3832
3833 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
3834 {
3835         struct usb_device *dev = mixer->chip->dev;
3836         struct scarlett2_data *private = mixer->private_data;
3837         unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
3838         void *transfer_buffer;
3839
3840         if (mixer->urb) {
3841                 usb_audio_err(mixer->chip,
3842                               "%s: mixer urb already in use!\n", __func__);
3843                 return 0;
3844         }
3845
3846         if (usb_pipe_type_check(dev, pipe))
3847                 return -EINVAL;
3848
3849         mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3850         if (!mixer->urb)
3851                 return -ENOMEM;
3852
3853         transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
3854         if (!transfer_buffer)
3855                 return -ENOMEM;
3856
3857         usb_fill_int_urb(mixer->urb, dev, pipe,
3858                          transfer_buffer, private->wMaxPacketSize,
3859                          scarlett2_notify, mixer, private->bInterval);
3860
3861         return usb_submit_urb(mixer->urb, GFP_KERNEL);
3862 }
3863
3864 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
3865 {
3866         const struct scarlett2_device_info **info = scarlett2_devices;
3867         int err;
3868
3869         /* Find device in scarlett2_devices */
3870         while (*info && (*info)->usb_id != mixer->chip->usb_id)
3871                 info++;
3872         if (!*info)
3873                 return -EINVAL;
3874
3875         /* Initialise private data */
3876         err = scarlett2_init_private(mixer, *info);
3877         if (err < 0)
3878                 return err;
3879
3880         /* Send proprietary USB initialisation sequence */
3881         err = scarlett2_usb_init(mixer);
3882         if (err < 0)
3883                 return err;
3884
3885         /* Read volume levels and controls from the interface */
3886         err = scarlett2_read_configs(mixer);
3887         if (err < 0)
3888                 return err;
3889
3890         /* Create the MSD control */
3891         err = scarlett2_add_msd_ctl(mixer);
3892         if (err < 0)
3893                 return err;
3894
3895         /* If MSD mode is enabled, don't create any other controls */
3896         if (((struct scarlett2_data *)mixer->private_data)->msd_switch)
3897                 return 0;
3898
3899         /* Create the analogue output controls */
3900         err = scarlett2_add_line_out_ctls(mixer);
3901         if (err < 0)
3902                 return err;
3903
3904         /* Create the analogue input controls */
3905         err = scarlett2_add_line_in_ctls(mixer);
3906         if (err < 0)
3907                 return err;
3908
3909         /* Create the input, output, and mixer mux input selections */
3910         err = scarlett2_add_mux_enums(mixer);
3911         if (err < 0)
3912                 return err;
3913
3914         /* Create the matrix mixer controls */
3915         err = scarlett2_add_mixer_ctls(mixer);
3916         if (err < 0)
3917                 return err;
3918
3919         /* Create the level meter controls */
3920         err = scarlett2_add_meter_ctl(mixer);
3921         if (err < 0)
3922                 return err;
3923
3924         /* Create the sync control */
3925         err = scarlett2_add_sync_ctl(mixer);
3926         if (err < 0)
3927                 return err;
3928
3929         /* Create the direct monitor control */
3930         err = scarlett2_add_direct_monitor_ctl(mixer);
3931         if (err < 0)
3932                 return err;
3933
3934         /* Create the speaker switching control */
3935         err = scarlett2_add_speaker_switch_ctl(mixer);
3936         if (err < 0)
3937                 return err;
3938
3939         /* Create the talkback controls */
3940         err = scarlett2_add_talkback_ctls(mixer);
3941         if (err < 0)
3942                 return err;
3943
3944         /* Set up the interrupt polling */
3945         err = scarlett2_init_notify(mixer);
3946         if (err < 0)
3947                 return err;
3948
3949         return 0;
3950 }
3951
3952 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
3953 {
3954         struct snd_usb_audio *chip = mixer->chip;
3955         int err;
3956
3957         /* only use UAC_VERSION_2 */
3958         if (!mixer->protocol)
3959                 return 0;
3960
3961         if (!(chip->setup & SCARLETT2_ENABLE)) {
3962                 usb_audio_info(chip,
3963                         "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; "
3964                         "use options snd_usb_audio vid=0x%04x pid=0x%04x "
3965                         "device_setup=1 to enable and report any issues "
3966                         "to g@b4.vu",
3967                         USB_ID_VENDOR(chip->usb_id),
3968                         USB_ID_PRODUCT(chip->usb_id));
3969                 return 0;
3970         }
3971
3972         usb_audio_info(chip,
3973                 "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x",
3974                 USB_ID_PRODUCT(chip->usb_id));
3975
3976         err = snd_scarlett_gen2_controls_create(mixer);
3977         if (err < 0)
3978                 usb_audio_err(mixer->chip,
3979                               "Error initialising Scarlett Mixer Driver: %d",
3980                               err);
3981
3982         return err;
3983 }