Linux Audio

Check our new training course

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