xref: /linux/sound/usb/mixer_scarlett2.c (revision 33e02dc69afbd8f1b85a51d74d72f139ba4ca623)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *   Focusrite Scarlett 2 Protocol Driver for ALSA
4  *   (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and
5  *   Clarett+ series products)
6  *
7  *   Supported models:
8  *   - 6i6/18i8/18i20 Gen 2
9  *   - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
10  *   - Solo/2i2/4i4 Gen 4
11  *   - Clarett 2Pre/4Pre/8Pre USB
12  *   - Clarett+ 2Pre/4Pre/8Pre
13  *
14  *   Copyright (c) 2018-2023 by Geoffrey D. Bennett <g at b4.vu>
15  *   Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
16  *   Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com>
17  *
18  *   Based on the Scarlett (Gen 1) Driver for ALSA:
19  *
20  *   Copyright (c) 2013 by Tobias Hoffmann
21  *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
22  *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
23  *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
24  *
25  *   Many codes borrowed from audio.c by
26  *     Alan Cox (alan at lxorguk.ukuu.org.uk)
27  *     Thomas Sailer (sailer at ife.ee.ethz.ch)
28  *
29  *   Code cleanup:
30  *   David Henningsson <david.henningsson at canonical.com>
31  */
32 
33 /* The protocol was reverse engineered by looking at the communication
34  * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
35  * (firmware 1083) using usbmon in July-August 2018.
36  *
37  * Scarlett 18i8 support added in April 2019.
38  *
39  * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
40  * for providing usbmon output and testing).
41  *
42  * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
43  * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
44  * usbmon output and testing).
45  *
46  * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
47  * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon
48  * output, protocol traces and testing).
49  *
50  * Support for loading mixer volume and mux configuration from the
51  * interface during driver initialisation added in May 2021 (thanks to
52  * Vladimir Sadovnikov for figuring out how).
53  *
54  * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
55  * Vorona for 2i2 protocol traces).
56  *
57  * Support for phantom power, direct monitoring, speaker switching,
58  * and talkback added in May-June 2021.
59  *
60  * Support for Clarett+ 8Pre added in Aug 2022 by Christian
61  * Colglazier.
62  *
63  * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe
64  * Perrot for confirmation).
65  *
66  * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to
67  * Gregory Rozzo for donating a 4Pre, and David Sherwood and Patrice
68  * Peterson for usbmon output).
69  *
70  * Support for Clarett 2Pre and 4Pre USB added in Oct 2023.
71  *
72  * Support for firmware updates added in Dec 2023.
73  *
74  * Support for Scarlett Solo/2i2/4i4 Gen 4 added in Dec 2023 (thanks
75  * to many LinuxMusicians people and to Focusrite for hardware
76  * donations).
77  *
78  * This ALSA mixer gives access to (model-dependent):
79  *  - input, output, mixer-matrix muxes
80  *  - mixer-matrix gain stages
81  *  - gain/volume/mute controls
82  *  - level meters
83  *  - line/inst level, pad, and air controls
84  *  - phantom power, direct monitor, speaker switching, and talkback
85  *    controls
86  *  - disable/enable MSD mode
87  *  - disable/enable standalone mode
88  *  - input mute, gain, autogain, safe mode
89  *  - direct monitor mixes
90  *  - compressor and EQ
91  *  - Bluetooth volume
92  *
93  * <ditaa>
94  *    /--------------\    18chn            20chn     /--------------\
95  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
96  *    \--------------/  |      |    |             |  \--------------/
97  *                      |      |    |    /-----\  |
98  *                      |      |    |    |     |  |
99  *                      |      v    v    v     |  |
100  *                      |   +---------------+  |  |
101  *                      |    \ Matrix  Mux /   |  |
102  *                      |     +-----+-----+    |  |
103  *                      |           |          |  |
104  *                      |           |18chn     |  |
105  *                      |           |          |  |
106  *                      |           |     10chn|  |
107  *                      |           v          |  |
108  *                      |     +------------+   |  |
109  *                      |     | Mixer      |   |  |
110  *                      |     |     Matrix |   |  |
111  *                      |     |            |   |  |
112  *                      |     | 18x10 Gain |   |  |
113  *                      |     |   stages   |   |  |
114  *                      |     +-----+------+   |  |
115  *                      |           |          |  |
116  *                      |18chn      |10chn     |  |20chn
117  *                      |           |          |  |
118  *                      |           +----------/  |
119  *                      |           |             |
120  *                      v           v             v
121  *                      ===========================
122  *               +---------------+       +--—------------+
123  *                \ Output  Mux /         \ Capture Mux /
124  *                 +---+---+---+           +-----+-----+
125  *                     |   |                     |
126  *                10chn|   |                     |18chn
127  *                     |   |                     |
128  *  /--------------\   |   |                     |   /--------------\
129  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
130  *  | Hardware out |       |                         \--------------/
131  *  \--------------/       |
132  *                         v
133  *                  +-------------+    Software gain per channel.
134  *                  | Master Gain |<-- 18i20 only: Switch per channel
135  *                  +------+------+    to select HW or SW gain control.
136  *                         |
137  *                         |10chn
138  *  /--------------\       |
139  *  | Analogue     |<------/
140  *  | Hardware out |
141  *  \--------------/
142  * </ditaa>
143  *
144  * Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small
145  * disk with registration and driver download information is presented
146  * to the host. To access the full functionality of the device without
147  * proprietary software, MSD mode can be disabled by:
148  * - holding down the 48V button for five seconds while powering on
149  *   the device, or
150  * - using this driver and alsamixer to change the "MSD Mode" setting
151  *   to Off and power-cycling the device
152  */
153 
154 #include <linux/slab.h>
155 #include <linux/usb.h>
156 #include <linux/moduleparam.h>
157 
158 #include <sound/control.h>
159 #include <sound/tlv.h>
160 #include <sound/hwdep.h>
161 
162 #include <uapi/sound/scarlett2.h>
163 
164 #include "usbaudio.h"
165 #include "mixer.h"
166 #include "helper.h"
167 
168 #include "mixer_scarlett2.h"
169 
170 /* device_setup value to allow turning MSD mode back on */
171 #define SCARLETT2_MSD_ENABLE 0x02
172 
173 /* device_setup value to disable this mixer driver */
174 #define SCARLETT2_DISABLE 0x04
175 
176 /* some gui mixers can't handle negative ctl values */
177 #define SCARLETT2_VOLUME_BIAS 127
178 
179 /* maximum preamp input gain value
180  * (the corresponding value in dB is per-device)
181  */
182 #define SCARLETT2_MAX_GAIN_VALUE 70
183 
184 /* maximum Bluetooth volume value */
185 #define SCARLETT2_MAX_BLUETOOTH_VOLUME 30
186 
187 /* mixer range from -80dB to +12dB in 0.5dB steps */
188 #define SCARLETT2_MIXER_MIN_DB -80
189 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
190 #define SCARLETT2_MIXER_MAX_DB 12
191 #define SCARLETT2_MIXER_MAX_VALUE \
192 	((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
193 #define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1)
194 
195 /* map from (dB + 80) * 2 to mixer value
196  * for dB in 0 .. 184: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
197  */
198 static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = {
199 	0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
200 	2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
201 	9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
202 	23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
203 	54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
204 	122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
205 	244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
206 	487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
207 	973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
208 	1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
209 	3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
210 	5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
211 	9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
212 	16345, 17313, 18339, 19426, 20577, 21796, 23088, 24456, 25905,
213 	27440, 29066, 30788, 32612
214 };
215 
216 /* Maximum number of analogue outputs */
217 #define SCARLETT2_ANALOGUE_MAX 10
218 
219 /* Maximum number of various input controls */
220 #define SCARLETT2_LEVEL_SWITCH_MAX 2
221 #define SCARLETT2_PAD_SWITCH_MAX 8
222 #define SCARLETT2_AIR_SWITCH_MAX 8
223 #define SCARLETT2_DSP_SWITCH_MAX 2
224 #define SCARLETT2_INPUT_MUTE_SWITCH_MAX 2
225 #define SCARLETT2_PHANTOM_SWITCH_MAX 2
226 #define SCARLETT2_INPUT_GAIN_MAX 2
227 
228 /* Maximum number of inputs to the mixer */
229 #define SCARLETT2_INPUT_MIX_MAX 25
230 
231 /* Maximum number of outputs from the mixer */
232 #define SCARLETT2_OUTPUT_MIX_MAX 12
233 
234 /* Maximum number of mixer gain controls */
235 #define SCARLETT2_MIX_MAX (SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX)
236 
237 /* Maximum number of direct monitor mixer gain controls
238  * 1 (Solo) or 2 (2i2) direct monitor selections (Mono & Stereo)
239  * 2 Mix outputs (A/Left & B/Right)
240  * 4 Mix inputs
241  */
242 #define SCARLETT2_MONITOR_MIX_MAX (2 * 2 * 4)
243 
244 /* Maximum size of the data in the USB mux assignment message:
245  * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare
246  */
247 #define SCARLETT2_MUX_MAX 77
248 
249 /* Maximum number of sources (sum of input port counts) */
250 #define SCARLETT2_MAX_SRCS 52
251 
252 /* Maximum number of meters (sum of output port counts) */
253 #define SCARLETT2_MAX_METERS 65
254 
255 /* Compressor parameter data
256  *
257  * The compressor parameters are 32-bit fixed point values with 24
258  * bits of fraction. Integer values are sufficient for the parameters
259  * except for ratio which we can set in 0.5:1 steps.
260  */
261 struct compressor_param {
262 	const char          *name;
263 	snd_ctl_elem_type_t  type;
264 	s32                  min;
265 	s32                  max;
266 	int                  scale_bits;
267 };
268 
269 /* The available compressor parameters on the Vocaster:
270  * - Enable: Off, On
271  * - Threshold: -40dB to 0dB
272  * - Ratio: 1:1 to 50:1 in 0.5:1 steps
273  * - Knee Width: 0dB to 10dB
274  * - Attack: 30ms to 127ms
275  * - Release: 30ms to 127ms
276  * - Makeup Gain: 0dB to 24dB
277  */
278 static const struct compressor_param compressor_params[] = {
279 	{ "Enable",      SNDRV_CTL_ELEM_TYPE_BOOLEAN,   0,   1,  0 },
280 	{ "Threshold",   SNDRV_CTL_ELEM_TYPE_INTEGER, -40,   0, 24 },
281 	{ "Ratio",       SNDRV_CTL_ELEM_TYPE_INTEGER,   2, 100, 23 },
282 	{ "Knee Width",  SNDRV_CTL_ELEM_TYPE_INTEGER,   0,  10, 24 },
283 	{ "Attack",      SNDRV_CTL_ELEM_TYPE_INTEGER,  30, 127, 24 },
284 	{ "Release",     SNDRV_CTL_ELEM_TYPE_INTEGER,  30, 127, 24 },
285 	{ "Makeup Gain", SNDRV_CTL_ELEM_TYPE_INTEGER,   0,  24, 24 },
286 };
287 
288 #define SCARLETT2_COMPRESSOR_PARAM_COUNT ARRAY_SIZE(compressor_params)
289 #define SCARLETT2_COMPRESSOR_CTLS_MAX \
290 	(SCARLETT2_COMPRESSOR_PARAM_COUNT * SCARLETT2_DSP_SWITCH_MAX)
291 
292 /* Maximum number of filter controls */
293 #define SCARLETT2_PRECOMP_FLT_CTLS_MAX (2 * SCARLETT2_DSP_SWITCH_MAX)
294 #define SCARLETT2_PEQ_FLT_CTLS_MAX (3 * SCARLETT2_DSP_SWITCH_MAX)
295 
296 /* Number of biquad filter coefficients */
297 #define SCARLETT2_BIQUAD_COEFFS 5
298 
299 /* Maximum number of filter coefficient values */
300 #define SCARLETT2_PRECOMP_FLT_VALUES_MAX \
301 	(SCARLETT2_PRECOMP_FLT_CTLS_MAX * SCARLETT2_BIQUAD_COEFFS)
302 #define SCARLETT2_PEQ_FLT_VALUES_MAX \
303 	(SCARLETT2_PEQ_FLT_CTLS_MAX * SCARLETT2_BIQUAD_COEFFS)
304 
305 /* Maximum number of PEQ filter slots */
306 #define SCARLETT2_PEQ_FLT_SLOTS_MAX 4
307 
308 /* Hardware port types:
309  * - None (no input to mux)
310  * - Analogue I/O
311  * - S/PDIF I/O
312  * - ADAT I/O
313  * - Mixer I/O
314  * - PCM I/O
315  */
316 enum {
317 	SCARLETT2_PORT_TYPE_NONE,
318 	SCARLETT2_PORT_TYPE_ANALOGUE,
319 	SCARLETT2_PORT_TYPE_SPDIF,
320 	SCARLETT2_PORT_TYPE_ADAT,
321 	SCARLETT2_PORT_TYPE_MIX,
322 	SCARLETT2_PORT_TYPE_PCM,
323 	SCARLETT2_PORT_TYPE_COUNT
324 };
325 
326 /* I/O count of each port type kept in struct scarlett2_ports */
327 enum {
328 	SCARLETT2_PORT_IN,
329 	SCARLETT2_PORT_OUT,
330 	SCARLETT2_PORT_DIRNS
331 };
332 
333 /* Dim/Mute buttons on the 18i20 */
334 enum {
335 	SCARLETT2_BUTTON_MUTE,
336 	SCARLETT2_BUTTON_DIM,
337 	SCARLETT2_DIM_MUTE_COUNT
338 };
339 
340 /* Autogain target values */
341 
342 #define SCARLETT2_AG_TARGET_MIN (-30)
343 
344 enum {
345 	SCARLETT2_AG_HOT_TARGET,
346 	SCARLETT2_AG_MEAN_TARGET,
347 	SCARLETT2_AG_PEAK_TARGET,
348 	SCARLETT2_AG_TARGET_COUNT
349 };
350 
351 /* Flash Write State */
352 enum {
353 	SCARLETT2_FLASH_WRITE_STATE_IDLE,
354 	SCARLETT2_FLASH_WRITE_STATE_SELECTED,
355 	SCARLETT2_FLASH_WRITE_STATE_ERASING,
356 	SCARLETT2_FLASH_WRITE_STATE_WRITE
357 };
358 
359 static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = {
360 	"Mute Playback Switch", "Dim Playback Switch"
361 };
362 
363 /* The autogain_status is set based on the autogain_switch and
364  * raw_autogain_status values.
365  *
366  * If autogain_switch is set, autogain_status is set to 0 (Running).
367  * The other status values are from the raw_autogain_status value + 1.
368  */
369 static const char *const scarlett2_autogain_status_gen4[] = {
370 	"Running",
371 	"Success",
372 	"SuccessDRover",
373 	"WarnMinGainLimit",
374 	"FailDRunder",
375 	"FailMaxGainLimit",
376 	"FailClipped",
377 	"Cancelled",
378 	"Invalid",
379 	NULL
380 };
381 
382 static const char *const scarlett2_autogain_status_vocaster[] = {
383 	"Running",
384 	"Success",
385 	"FailPG",
386 	"FailRange",
387 	"WarnMaxCap",
388 	"WarnMinCap",
389 	"Cancelled",
390 	"Invalid",
391 	NULL
392 };
393 
394 /* Power Status Values */
395 enum {
396 	SCARLETT2_POWER_STATUS_EXT,
397 	SCARLETT2_POWER_STATUS_BUS,
398 	SCARLETT2_POWER_STATUS_FAIL,
399 	SCARLETT2_POWER_STATUS_COUNT
400 };
401 
402 /* Notification callback functions */
403 struct scarlett2_notification {
404 	u32 mask;
405 	void (*func)(struct usb_mixer_interface *mixer);
406 };
407 
408 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer);
409 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer);
410 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer);
411 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer);
412 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer);
413 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer);
414 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer);
415 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer);
416 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer);
417 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer);
418 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer);
419 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer);
420 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer);
421 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer);
422 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer);
423 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer);
424 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer);
425 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer);
426 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer);
427 static void scarlett2_notify_pcm_input_switch(
428 					struct usb_mixer_interface *mixer);
429 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer);
430 
431 /* Arrays of notification callback functions */
432 
433 static const struct scarlett2_notification scarlett2_notifications[] = {
434 	{ 0x00000001, scarlett2_notify_ack },
435 	{ 0x00000008, scarlett2_notify_sync },
436 	{ 0x00200000, scarlett2_notify_dim_mute },
437 	{ 0x00400000, scarlett2_notify_monitor },
438 	{ 0x00800000, scarlett2_notify_input_other },
439 	{ 0x01000000, scarlett2_notify_monitor_other },
440 	{ 0, NULL }
441 };
442 
443 static const struct scarlett2_notification scarlett3a_notifications[] = {
444 	{ 0x00000001, scarlett2_notify_ack },
445 	{ 0x00800000, scarlett2_notify_input_other },
446 	{ 0x01000000, scarlett2_notify_direct_monitor },
447 	{ 0, NULL }
448 };
449 
450 static const struct scarlett2_notification vocaster_notifications[] = {
451 	{ 0x00000001, scarlett2_notify_ack },
452 	{ 0x00000008, scarlett2_notify_sync },
453 	{ 0x00200000, scarlett2_notify_input_mute },
454 	{ 0x00400000, scarlett2_notify_autogain },
455 	{ 0x04000000, scarlett2_notify_input_dsp },
456 	{ 0x08000000, scarlett2_notify_input_gain },
457 	{ 0x10000000, scarlett2_notify_input_phantom },
458 	{ 0x20000000, scarlett2_notify_bluetooth },
459 	{ 0, NULL }
460 };
461 
462 static const struct scarlett2_notification scarlett4_solo_notifications[] = {
463 	{ 0x00000001, scarlett2_notify_ack },
464 	{ 0x00000008, scarlett2_notify_sync },
465 	{ 0x00400000, scarlett2_notify_input_air },
466 	{ 0x00800000, scarlett2_notify_direct_monitor },
467 	{ 0x01000000, scarlett2_notify_input_level },
468 	{ 0x02000000, scarlett2_notify_input_phantom },
469 	{ 0x04000000, scarlett2_notify_pcm_input_switch },
470 	{ 0, NULL }
471 };
472 
473 static const struct scarlett2_notification scarlett4_2i2_notifications[] = {
474 	{ 0x00000001, scarlett2_notify_ack },
475 	{ 0x00000008, scarlett2_notify_sync },
476 	{ 0x00200000, scarlett2_notify_input_safe },
477 	{ 0x00400000, scarlett2_notify_autogain },
478 	{ 0x00800000, scarlett2_notify_input_air },
479 	{ 0x01000000, scarlett2_notify_direct_monitor },
480 	{ 0x02000000, scarlett2_notify_input_select },
481 	{ 0x04000000, scarlett2_notify_input_level },
482 	{ 0x08000000, scarlett2_notify_input_phantom },
483 	{ 0x10000000, NULL }, /* power status, ignored */
484 	{ 0x40000000, scarlett2_notify_input_gain },
485 	{ 0x80000000, NULL }, /* power status, ignored */
486 	{ 0, NULL }
487 };
488 
489 static const struct scarlett2_notification scarlett4_4i4_notifications[] = {
490 	{ 0x00000001, scarlett2_notify_ack },
491 	{ 0x00000008, scarlett2_notify_sync },
492 	{ 0x00200000, scarlett2_notify_input_safe },
493 	{ 0x00400000, scarlett2_notify_autogain },
494 	{ 0x00800000, scarlett2_notify_input_air },
495 	{ 0x01000000, scarlett2_notify_input_select },
496 	{ 0x02000000, scarlett2_notify_input_level },
497 	{ 0x04000000, scarlett2_notify_input_phantom },
498 	{ 0x08000000, scarlett2_notify_power_status }, /* power external */
499 	{ 0x20000000, scarlett2_notify_input_gain },
500 	{ 0x40000000, scarlett2_notify_power_status }, /* power status */
501 	{ 0x80000000, scarlett2_notify_volume },
502 	{ 0, NULL }
503 };
504 
505 /* Configuration parameters that can be read and written */
506 enum {
507 	SCARLETT2_CONFIG_DIM_MUTE,
508 	SCARLETT2_CONFIG_LINE_OUT_VOLUME,
509 	SCARLETT2_CONFIG_MUTE_SWITCH,
510 	SCARLETT2_CONFIG_SW_HW_SWITCH,
511 	SCARLETT2_CONFIG_MASTER_VOLUME,
512 	SCARLETT2_CONFIG_HEADPHONE_VOLUME,
513 	SCARLETT2_CONFIG_LEVEL_SWITCH,
514 	SCARLETT2_CONFIG_PAD_SWITCH,
515 	SCARLETT2_CONFIG_MSD_SWITCH,
516 	SCARLETT2_CONFIG_AIR_SWITCH,
517 	SCARLETT2_CONFIG_DSP_SWITCH,
518 	SCARLETT2_CONFIG_COMPRESSOR_PARAMS,
519 	SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
520 	SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
521 	SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
522 	SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
523 	SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
524 	SCARLETT2_CONFIG_STANDALONE_SWITCH,
525 	SCARLETT2_CONFIG_PHANTOM_SWITCH,
526 	SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
527 	SCARLETT2_CONFIG_DIRECT_MONITOR,
528 	SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
529 	SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
530 	SCARLETT2_CONFIG_TALKBACK_MAP,
531 	SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
532 	SCARLETT2_CONFIG_AUTOGAIN_STATUS,
533 	SCARLETT2_CONFIG_AG_HOT_TARGET,
534 	SCARLETT2_CONFIG_AG_MEAN_TARGET,
535 	SCARLETT2_CONFIG_AG_PEAK_TARGET,
536 	SCARLETT2_CONFIG_INPUT_GAIN,
537 	SCARLETT2_CONFIG_SAFE_SWITCH,
538 	SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
539 	SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
540 	SCARLETT2_CONFIG_POWER_EXT,
541 	SCARLETT2_CONFIG_POWER_LOW,
542 	SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
543 	SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
544 	SCARLETT2_CONFIG_BLUETOOTH_VOLUME,
545 	SCARLETT2_CONFIG_SPDIF_MODE,
546 	SCARLETT2_CONFIG_COUNT
547 };
548 
549 /* Autogain target configuration parameters and names */
550 
551 static const int scarlett2_ag_target_configs[] = {
552 	[SCARLETT2_AG_HOT_TARGET]  = SCARLETT2_CONFIG_AG_HOT_TARGET,
553 	[SCARLETT2_AG_MEAN_TARGET] = SCARLETT2_CONFIG_AG_MEAN_TARGET,
554 	[SCARLETT2_AG_PEAK_TARGET] = SCARLETT2_CONFIG_AG_PEAK_TARGET
555 };
556 
557 static const char *const scarlett2_ag_target_names[] = {
558 	"Hot", "Mean", "Peak"
559 };
560 
561 /* Location, size, and activation command number for the configuration
562  * parameters. Size is in bits and may be 1, 8, 16, or 32.
563  *
564  * Vocaster and 4th Gen devices have a parameter buffer to set certain
565  * configuration parameters. When pbuf is set, rather than writing to
566  * the given offset, the channel and value are written to the
567  * parameter buffer and the activate command is sent to the device.
568  *
569  * Some Gen 4 configuration parameters are written with 0x02 for a
570  * desired value of 0x01, and 0x03 for 0x00. These are indicated with
571  * mute set to 1. 0x02 and 0x03 are temporary values while the device
572  * makes the change and the channel and/or corresponding DSP channel
573  * output is muted.
574  */
575 struct scarlett2_config {
576 	u16 offset;
577 	u8 size;
578 	u8 activate;
579 	u8 pbuf;
580 	u8 mute;
581 };
582 
583 struct scarlett2_config_set {
584 	const struct scarlett2_notification *notifications;
585 	u16 param_buf_addr;
586 	const unsigned int *input_gain_tlv;
587 	const char *const *autogain_status_texts;
588 	const struct scarlett2_config items[SCARLETT2_CONFIG_COUNT];
589 };
590 
591 /* Input gain TLV dB ranges */
592 
593 static const DECLARE_TLV_DB_MINMAX(
594 	db_scale_vocaster_gain, 0, 70 * 100
595 );
596 
597 static const DECLARE_TLV_DB_MINMAX(
598 	db_scale_gen4_gain, 0, 69 * 100
599 );
600 
601 /* Gen 2 devices without SW/HW volume switch: 6i6, 18i8 */
602 
603 static const struct scarlett2_config_set scarlett2_config_set_gen2a = {
604 	.notifications = scarlett2_notifications,
605 	.items = {
606 		[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
607 			.offset = 0x34, .size = 16, .activate = 1 },
608 
609 		[SCARLETT2_CONFIG_MUTE_SWITCH] = {
610 			.offset = 0x5c, .size = 8, .activate = 1 },
611 
612 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
613 			.offset = 0x7c, .size = 8, .activate = 7 },
614 
615 		[SCARLETT2_CONFIG_PAD_SWITCH] = {
616 			.offset = 0x84, .size = 8, .activate = 8 },
617 
618 		[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
619 			.offset = 0x8d, .size = 8, .activate = 6 },
620 	}
621 };
622 
623 /* Gen 2 devices with SW/HW volume switch: 18i20 */
624 
625 static const struct scarlett2_config_set scarlett2_config_set_gen2b = {
626 	.notifications = scarlett2_notifications,
627 	.items = {
628 		[SCARLETT2_CONFIG_DIM_MUTE] = {
629 			.offset = 0x31, .size = 8, .activate = 2 },
630 
631 		[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
632 			.offset = 0x34, .size = 16, .activate = 1 },
633 
634 		[SCARLETT2_CONFIG_MUTE_SWITCH] = {
635 			.offset = 0x5c, .size = 8, .activate = 1 },
636 
637 		[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
638 			.offset = 0x66, .size = 8, .activate = 3 },
639 
640 		[SCARLETT2_CONFIG_MASTER_VOLUME] = {
641 			.offset = 0x76, .size = 16 },
642 
643 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
644 			.offset = 0x7c, .size = 8, .activate = 7 },
645 
646 		[SCARLETT2_CONFIG_PAD_SWITCH] = {
647 			.offset = 0x84, .size = 8, .activate = 8 },
648 
649 		[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
650 			.offset = 0x8d, .size = 8, .activate = 6 },
651 	}
652 };
653 
654 /* Gen 3 devices without a mixer (Solo and 2i2) */
655 static const struct scarlett2_config_set scarlett2_config_set_gen3a = {
656 	.notifications = scarlett3a_notifications,
657 	.items = {
658 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
659 			.offset = 0x04, .size = 8, .activate = 6 },
660 
661 		[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
662 			.offset = 0x05, .size = 8, .activate = 6 },
663 
664 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
665 			.offset = 0x06, .size = 8, .activate = 3 },
666 
667 		[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
668 			.offset = 0x07, .size = 8, .activate = 4 },
669 
670 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
671 			.offset = 0x08, .size = 1, .activate = 7 },
672 
673 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
674 			.offset = 0x09, .size = 1, .activate = 8 },
675 	}
676 };
677 
678 /* Gen 3 devices without SW/HW volume switch: 4i4, 8i6 */
679 static const struct scarlett2_config_set scarlett2_config_set_gen3b = {
680 	.notifications = scarlett2_notifications,
681 	.items = {
682 		[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
683 			.offset = 0x34, .size = 16, .activate = 1 },
684 
685 		[SCARLETT2_CONFIG_MUTE_SWITCH] = {
686 			.offset = 0x5c, .size = 8, .activate = 1 },
687 
688 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
689 			.offset = 0x7c, .size = 8, .activate = 7 },
690 
691 		[SCARLETT2_CONFIG_PAD_SWITCH] = {
692 			.offset = 0x84, .size = 8, .activate = 8 },
693 
694 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
695 			.offset = 0x8c, .size = 8, .activate = 8 },
696 
697 		[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
698 			.offset = 0x95, .size = 8, .activate = 6 },
699 
700 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
701 			.offset = 0x9c, .size = 1, .activate = 8 },
702 
703 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
704 			.offset = 0x9d, .size = 8, .activate = 6 },
705 
706 		[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
707 			.offset = 0x9e, .size = 8, .activate = 6 },
708 	}
709 };
710 
711 /* Gen 3 devices with SW/HW volume switch: 18i8, 18i20 */
712 static const struct scarlett2_config_set scarlett2_config_set_gen3c = {
713 	.notifications = scarlett2_notifications,
714 	.items = {
715 		[SCARLETT2_CONFIG_DIM_MUTE] = {
716 			.offset = 0x31, .size = 8, .activate = 2 },
717 
718 		[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
719 			.offset = 0x34, .size = 16, .activate = 1 },
720 
721 		[SCARLETT2_CONFIG_MUTE_SWITCH] = {
722 			.offset = 0x5c, .size = 8, .activate = 1 },
723 
724 		[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
725 			.offset = 0x66, .size = 8, .activate = 3 },
726 
727 		[SCARLETT2_CONFIG_MASTER_VOLUME] = {
728 			.offset = 0x76, .size = 16 },
729 
730 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
731 			.offset = 0x7c, .size = 8, .activate = 7 },
732 
733 		[SCARLETT2_CONFIG_PAD_SWITCH] = {
734 			.offset = 0x84, .size = 8, .activate = 8 },
735 
736 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
737 			.offset = 0x8c, .size = 8, .activate = 8 },
738 
739 		[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
740 			.offset = 0x95, .size = 8, .activate = 6 },
741 
742 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
743 			.offset = 0x9c, .size = 1, .activate = 8 },
744 
745 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
746 			.offset = 0x9d, .size = 8, .activate = 6 },
747 
748 		[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
749 			.offset = 0x9e, .size = 8, .activate = 6 },
750 
751 		[SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = {
752 			.offset = 0x9f, .size = 1, .activate = 10 },
753 
754 		[SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = {
755 			.offset = 0xa0, .size = 1, .activate = 10 },
756 
757 		[SCARLETT2_CONFIG_TALKBACK_MAP] = {
758 			.offset = 0xb0, .size = 16, .activate = 10 },
759 
760 		[SCARLETT2_CONFIG_SPDIF_MODE] = {
761 			.offset = 0x94, .size = 8, .activate = 6 },
762 	}
763 };
764 
765 /* Vocaster */
766 static const struct scarlett2_config_set scarlett2_config_set_vocaster = {
767 	.notifications = vocaster_notifications,
768 	.param_buf_addr = 0x1bc,
769 	.input_gain_tlv = db_scale_vocaster_gain,
770 	.autogain_status_texts = scarlett2_autogain_status_vocaster,
771 	.items = {
772 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
773 			.offset = 0x9d, .size = 8, .activate = 6 },
774 
775 		[SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {
776 			.offset = 0x1c0, .size = 8, .activate = 19, .pbuf = 1 },
777 
778 		[SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {
779 			.offset = 0x1c2, .size = 8, },
780 
781 		[SCARLETT2_CONFIG_AG_HOT_TARGET] = {
782 			.offset = 0xc1, .size = 8, .activate = 29, .pbuf = 1 },
783 
784 		[SCARLETT2_CONFIG_INPUT_GAIN] = {
785 			.offset = 0x9f, .size = 8, .activate = 21, .pbuf = 1 },
786 
787 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
788 			.offset = 0x9c, .size = 1, .activate = 20, .pbuf = 1 },
789 
790 		[SCARLETT2_CONFIG_DSP_SWITCH] = {
791 			.offset = 0x1c4, .size = 8, .activate = 22, .pbuf = 1 },
792 
793 		[SCARLETT2_CONFIG_COMPRESSOR_PARAMS] = {
794 			.offset = 0x1c8, .size = 32, .activate = 23 },
795 
796 		[SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH] = {
797 			.offset = 0x7c, .size = 32, .activate = 27 },
798 
799 		[SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS] = {
800 			.offset = 0x200, .size = 32, .activate = 27 },
801 
802 		[SCARLETT2_CONFIG_PEQ_FLT_SWITCH] = {
803 			.offset = 0x84, .size = 32, .activate = 27 },
804 
805 		[SCARLETT2_CONFIG_PEQ_FLT_PARAMS] = {
806 			.offset = 0x250, .size = 32, .activate = 27 },
807 
808 		[SCARLETT2_CONFIG_INPUT_MUTE_SWITCH] = {
809 			.offset = 0x1be, .size = 8, .activate = 17, .pbuf = 1 },
810 
811 		[SCARLETT2_CONFIG_BLUETOOTH_VOLUME] = {
812 			.offset = 0xbf, .size = 8, .activate = 28 },
813 	}
814 };
815 
816 /* Solo Gen 4 */
817 static const struct scarlett2_config_set scarlett2_config_set_gen4_solo = {
818 	.notifications = scarlett4_solo_notifications,
819 	.param_buf_addr = 0xd8,
820 	.items = {
821 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
822 			.offset = 0x47, .size = 8, .activate = 4 },
823 
824 		[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
825 			.offset = 0x108, .size = 8, .activate = 12, .pbuf = 1 },
826 
827 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
828 			.offset = 0x46, .size = 8, .activate = 9, .pbuf = 1,
829 			.mute = 1 },
830 
831 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
832 			.offset = 0x3d, .size = 8, .activate = 10, .pbuf = 1,
833 			.mute = 1 },
834 
835 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
836 			.offset = 0x3e, .size = 8, .activate = 11, .pbuf = 1 },
837 
838 		[SCARLETT2_CONFIG_PCM_INPUT_SWITCH] = {
839 			.offset = 0x206, .size = 8, .activate = 25, .pbuf = 1 },
840 
841 		[SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {
842 			.offset = 0x232, .size = 16, .activate = 26 }
843 	}
844 };
845 
846 /* 2i2 Gen 4 */
847 static const struct scarlett2_config_set scarlett2_config_set_gen4_2i2 = {
848 	.notifications = scarlett4_2i2_notifications,
849 	.param_buf_addr = 0xfc,
850 	.input_gain_tlv = db_scale_gen4_gain,
851 	.autogain_status_texts = scarlett2_autogain_status_gen4,
852 	.items = {
853 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
854 			.offset = 0x49, .size = 8, .activate = 4 },
855 
856 		[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
857 			.offset = 0x14a, .size = 8, .activate = 16, .pbuf = 1 },
858 
859 		[SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {
860 			.offset = 0x135, .size = 8, .activate = 10, .pbuf = 1 },
861 
862 		[SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {
863 			.offset = 0x137, .size = 8 },
864 
865 		[SCARLETT2_CONFIG_AG_MEAN_TARGET] = {
866 			.offset = 0x131, .size = 8, .activate = 29, .pbuf = 1 },
867 
868 		[SCARLETT2_CONFIG_AG_PEAK_TARGET] = {
869 			.offset = 0x132, .size = 8, .activate = 30, .pbuf = 1 },
870 
871 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
872 			.offset = 0x48, .size = 8, .activate = 11, .pbuf = 1,
873 			.mute = 1 },
874 
875 		[SCARLETT2_CONFIG_INPUT_GAIN] = {
876 			.offset = 0x4b, .size = 8, .activate = 12, .pbuf = 1 },
877 
878 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
879 			.offset = 0x3c, .size = 8, .activate = 13, .pbuf = 1,
880 			.mute = 1 },
881 
882 		[SCARLETT2_CONFIG_SAFE_SWITCH] = {
883 			.offset = 0x147, .size = 8, .activate = 14, .pbuf = 1 },
884 
885 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
886 			.offset = 0x3e, .size = 8, .activate = 15, .pbuf = 1 },
887 
888 		[SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {
889 			.offset = 0x14b, .size = 8, .activate = 17, .pbuf = 1 },
890 
891 		[SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {
892 			.offset = 0x14e, .size = 8, .activate = 18, .pbuf = 1 },
893 
894 		[SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {
895 			.offset = 0x2a0, .size = 16, .activate = 36 }
896 	}
897 };
898 
899 /* 4i4 Gen 4 */
900 static const struct scarlett2_config_set scarlett2_config_set_gen4_4i4 = {
901 	.notifications = scarlett4_4i4_notifications,
902 	.param_buf_addr = 0x130,
903 	.input_gain_tlv = db_scale_gen4_gain,
904 	.autogain_status_texts = scarlett2_autogain_status_gen4,
905 	.items = {
906 		[SCARLETT2_CONFIG_MSD_SWITCH] = {
907 			.offset = 0x5c, .size = 8, .activate = 4 },
908 
909 		[SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {
910 			.offset = 0x13e, .size = 8, .activate = 10, .pbuf = 1 },
911 
912 		[SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {
913 			.offset = 0x140, .size = 8 },
914 
915 		[SCARLETT2_CONFIG_AG_MEAN_TARGET] = {
916 			.offset = 0x13a, .size = 8, .activate = 23, .pbuf = 1 },
917 
918 		[SCARLETT2_CONFIG_AG_PEAK_TARGET] = {
919 			.offset = 0x13b, .size = 8, .activate = 24, .pbuf = 1 },
920 
921 		[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
922 			.offset = 0x5a, .size = 8, .activate = 11, .pbuf = 1,
923 			.mute = 1 },
924 
925 		[SCARLETT2_CONFIG_INPUT_GAIN] = {
926 			.offset = 0x5e, .size = 8, .activate = 12, .pbuf = 1 },
927 
928 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
929 			.offset = 0x4e, .size = 8, .activate = 13, .pbuf = 1,
930 			.mute = 1 },
931 
932 		[SCARLETT2_CONFIG_SAFE_SWITCH] = {
933 			.offset = 0x150, .size = 8, .activate = 14, .pbuf = 1 },
934 
935 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
936 			.offset = 0x50, .size = 8, .activate = 15, .pbuf = 1 },
937 
938 		[SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {
939 			.offset = 0x153, .size = 8, .activate = 16, .pbuf = 1 },
940 
941 		[SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {
942 			.offset = 0x156, .size = 8, .activate = 17, .pbuf = 1 },
943 
944 		[SCARLETT2_CONFIG_MASTER_VOLUME] = {
945 			.offset = 0x32, .size = 16 },
946 
947 		[SCARLETT2_CONFIG_HEADPHONE_VOLUME] = {
948 			.offset = 0x3a, .size = 16 },
949 
950 		[SCARLETT2_CONFIG_POWER_EXT] = {
951 			.offset = 0x168, .size = 8 },
952 
953 		[SCARLETT2_CONFIG_POWER_LOW] = {
954 			.offset = 0x16d, .size = 8 }
955 	}
956 };
957 
958 /* Clarett USB and Clarett+ devices: 2Pre, 4Pre, 8Pre */
959 static const struct scarlett2_config_set scarlett2_config_set_clarett = {
960 	.notifications = scarlett2_notifications,
961 	.items = {
962 		[SCARLETT2_CONFIG_DIM_MUTE] = {
963 			.offset = 0x31, .size = 8, .activate = 2 },
964 
965 		[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
966 			.offset = 0x34, .size = 16, .activate = 1 },
967 
968 		[SCARLETT2_CONFIG_MUTE_SWITCH] = {
969 			.offset = 0x5c, .size = 8, .activate = 1 },
970 
971 		[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
972 			.offset = 0x66, .size = 8, .activate = 3 },
973 
974 		[SCARLETT2_CONFIG_MASTER_VOLUME] = {
975 			.offset = 0x76, .size = 16 },
976 
977 		[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
978 			.offset = 0x7c, .size = 8, .activate = 7 },
979 
980 		[SCARLETT2_CONFIG_AIR_SWITCH] = {
981 			.offset = 0x95, .size = 8, .activate = 8 },
982 
983 		[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
984 			.offset = 0x8d, .size = 8, .activate = 6 },
985 
986 		[SCARLETT2_CONFIG_SPDIF_MODE] = {
987 			.offset = 0x9e, .size = 8, .activate = 4 },
988 	}
989 };
990 
991 /* Description of each hardware port type:
992  * - id: hardware ID of this port type
993  * - src_descr: printf format string for mux input selections
994  * - src_num_offset: added to channel number for the fprintf
995  * - dst_descr: printf format string for mixer controls
996  */
997 struct scarlett2_port {
998 	u16 id;
999 	const char * const src_descr;
1000 	int src_num_offset;
1001 	const char * const dst_descr;
1002 	const char * const dsp_src_descr;
1003 	const char * const dsp_dst_descr;
1004 };
1005 
1006 static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = {
1007 	[SCARLETT2_PORT_TYPE_NONE] = {
1008 		.id = 0x000,
1009 		.src_descr = "Off"
1010 	},
1011 	[SCARLETT2_PORT_TYPE_ANALOGUE] = {
1012 		.id = 0x080,
1013 		.src_descr = "Analogue %d",
1014 		.src_num_offset = 1,
1015 		.dst_descr = "Analogue Output %02d Playback"
1016 	},
1017 	[SCARLETT2_PORT_TYPE_SPDIF] = {
1018 		.id = 0x180,
1019 		.src_descr = "S/PDIF %d",
1020 		.src_num_offset = 1,
1021 		.dst_descr = "S/PDIF Output %d Playback"
1022 	},
1023 	[SCARLETT2_PORT_TYPE_ADAT] = {
1024 		.id = 0x200,
1025 		.src_descr = "ADAT %d",
1026 		.src_num_offset = 1,
1027 		.dst_descr = "ADAT Output %d Playback"
1028 	},
1029 	[SCARLETT2_PORT_TYPE_MIX] = {
1030 		.id = 0x300,
1031 		.src_descr = "Mix %c",
1032 		.src_num_offset = 'A',
1033 		.dst_descr = "Mixer Input %02d Capture",
1034 		.dsp_src_descr = "DSP %d",
1035 		.dsp_dst_descr = "DSP Input %d Capture"
1036 	},
1037 	[SCARLETT2_PORT_TYPE_PCM] = {
1038 		.id = 0x600,
1039 		.src_descr = "PCM %d",
1040 		.src_num_offset = 1,
1041 		.dst_descr = "PCM %02d Capture"
1042 	},
1043 };
1044 
1045 /* Number of mux tables: one for each band of sample rates
1046  * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz)
1047  */
1048 #define SCARLETT2_MUX_TABLES 3
1049 
1050 /* Maximum number of entries in a mux table */
1051 #define SCARLETT2_MAX_MUX_ENTRIES 10
1052 
1053 /* One entry within mux_assignment defines the port type and range of
1054  * ports to add to the set_mux message. The end of the list is marked
1055  * with count == 0.
1056  */
1057 struct scarlett2_mux_entry {
1058 	u8 port_type;
1059 	u8 start;
1060 	u8 count;
1061 };
1062 
1063 /* Maximum number of entries in a mux table */
1064 #define SCARLETT2_MAX_METER_ENTRIES 9
1065 
1066 /* One entry within meter_assignment defines the range of mux outputs
1067  * that consecutive meter entries are mapped to. The end of the list
1068  * is marked with count == 0.
1069  */
1070 struct scarlett2_meter_entry {
1071 	u8 start;
1072 	u8 count;
1073 };
1074 
1075 struct scarlett2_device_info {
1076 	/* which set of configuration parameters the device uses */
1077 	const struct scarlett2_config_set *config_set;
1078 
1079 	/* minimum firmware version required */
1080 	u16 min_firmware_version;
1081 
1082 	/* support for main/alt speaker switching */
1083 	u8 has_speaker_switching;
1084 
1085 	/* support for talkback microphone */
1086 	u8 has_talkback;
1087 
1088 	/* the number of analogue inputs with a software switchable
1089 	 * level control that can be set to line or instrument
1090 	 */
1091 	u8 level_input_count;
1092 
1093 	/* the first input with a level control (0-based) */
1094 	u8 level_input_first;
1095 
1096 	/* the number of analogue inputs with a software switchable
1097 	 * 10dB pad control
1098 	 */
1099 	u8 pad_input_count;
1100 
1101 	/* the number of analogue inputs with a software switchable
1102 	 * "air" control
1103 	 */
1104 	u8 air_input_count;
1105 
1106 	/* the first input with an air control (0-based) */
1107 	u8 air_input_first;
1108 
1109 	/* number of additional air options
1110 	 * 0 for air presence only (Gen 3)
1111 	 * 1 for air presence+drive (Gen 4)
1112 	 */
1113 	u8 air_option;
1114 
1115 	/* the number of analogue inputs with DSP control */
1116 	u8 dsp_input_count;
1117 
1118 	/* number of pre-compressor filters */
1119 	u8 precomp_flt_count;
1120 
1121 	/* number of parametric EQ filters */
1122 	u8 peq_flt_count;
1123 
1124 	/* number of PEQ filters plus unused slots */
1125 	u8 peq_flt_total_count;
1126 
1127 	/* the number of analogue inputs with a software switchable
1128 	 * mute control
1129 	 */
1130 	u8 mute_input_count;
1131 
1132 	/* the number of phantom (48V) software switchable controls */
1133 	u8 phantom_count;
1134 
1135 	/* the first input with phantom power control (0-based) */
1136 	u8 phantom_first;
1137 
1138 	/* the number of inputs each phantom switch controls */
1139 	u8 inputs_per_phantom;
1140 
1141 	/* the number of inputs with software-controllable gain */
1142 	u8 gain_input_count;
1143 
1144 	/* the number of inputs with safe mode */
1145 	u8 safe_input_count;
1146 
1147 	/* the number of direct monitor options
1148 	 * (0 = none, 1 = mono only, 2 = mono/stereo)
1149 	 */
1150 	u8 direct_monitor;
1151 
1152 	/* the number of DSP channels */
1153 	u8 dsp_count;
1154 
1155 	/* has a Bluetooth module with volume control */
1156 	u8 has_bluetooth;
1157 
1158 	/* S/PDIF Source/Digital I/O mode control */
1159 	const char * const spdif_mode_control_name;
1160 	const u8 *spdif_mode_values;
1161 	const char * const *spdif_mode_texts;
1162 
1163 	/* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected
1164 	 * internally to the analogue 7/8 outputs
1165 	 */
1166 	u8 line_out_remap_enable;
1167 	u8 line_out_remap[SCARLETT2_ANALOGUE_MAX];
1168 	u8 line_out_unmap[SCARLETT2_ANALOGUE_MAX];
1169 
1170 	/* additional description for the line out volume controls */
1171 	const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
1172 
1173 	/* number of sources/destinations of each port type */
1174 	const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS];
1175 
1176 	/* layout/order of the entries in the set_mux message */
1177 	struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES]
1178 						 [SCARLETT2_MAX_MUX_ENTRIES];
1179 
1180 	/* map from meter level order returned by
1181 	 * SCARLETT2_USB_GET_METER to index into mux[] entries (same
1182 	 * as the order returned by scarlett2_meter_ctl_get())
1183 	 */
1184 	struct scarlett2_meter_entry meter_map[SCARLETT2_MAX_METER_ENTRIES];
1185 };
1186 
1187 struct scarlett2_data {
1188 	struct usb_mixer_interface *mixer;
1189 	struct mutex usb_mutex; /* prevent sending concurrent USB requests */
1190 	struct completion cmd_done;
1191 	struct mutex data_mutex; /* lock access to this data */
1192 	u8 running;
1193 	u8 hwdep_in_use;
1194 	u8 selected_flash_segment_id;
1195 	u8 flash_write_state;
1196 	struct delayed_work work;
1197 	const struct scarlett2_device_info *info;
1198 	const struct scarlett2_config_set *config_set;
1199 	const char *series_name;
1200 	__u8 bInterfaceNumber;
1201 	__u8 bEndpointAddress;
1202 	__u16 wMaxPacketSize;
1203 	__u8 bInterval;
1204 	u8 num_mux_srcs;
1205 	u8 num_mux_dsts;
1206 	u8 num_mix_in;
1207 	u8 num_mix_out;
1208 	u8 num_line_out;
1209 	u8 num_monitor_mix_ctls;
1210 	u8 num_autogain_status_texts;
1211 	u32 firmware_version;
1212 	u8 flash_segment_nums[SCARLETT2_SEGMENT_ID_COUNT];
1213 	u8 flash_segment_blocks[SCARLETT2_SEGMENT_ID_COUNT];
1214 	u16 scarlett2_seq;
1215 	u8 sync_updated;
1216 	u8 vol_updated;
1217 	u8 dim_mute_updated;
1218 	u8 input_level_updated;
1219 	u8 input_pad_updated;
1220 	u8 input_air_updated;
1221 	u8 input_dsp_updated;
1222 	u8 input_mute_updated;
1223 	u8 input_phantom_updated;
1224 	u8 input_select_updated;
1225 	u8 input_gain_updated;
1226 	u8 autogain_updated;
1227 	u8 input_safe_updated;
1228 	u8 pcm_input_switch_updated;
1229 	u8 monitor_other_updated;
1230 	u8 direct_monitor_updated;
1231 	u8 mux_updated;
1232 	u8 mix_updated;
1233 	u8 speaker_switching_switched;
1234 	u8 power_status_updated;
1235 	u8 bluetooth_updated;
1236 	u8 sync;
1237 	u8 master_vol;
1238 	u8 headphone_vol;
1239 	u8 vol[SCARLETT2_ANALOGUE_MAX];
1240 	u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
1241 	u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
1242 	u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
1243 	u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
1244 	u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
1245 	u8 air_switch[SCARLETT2_AIR_SWITCH_MAX];
1246 	u8 dsp_switch[SCARLETT2_DSP_SWITCH_MAX];
1247 	s32 compressor_values[SCARLETT2_COMPRESSOR_CTLS_MAX];
1248 	s32 precomp_flt_values[SCARLETT2_PRECOMP_FLT_VALUES_MAX];
1249 	s32 peq_flt_values[SCARLETT2_PEQ_FLT_VALUES_MAX];
1250 	u8 precomp_flt_switch[SCARLETT2_DSP_SWITCH_MAX];
1251 	u8 peq_flt_switch[SCARLETT2_DSP_SWITCH_MAX];
1252 	u8 input_mute_switch[SCARLETT2_INPUT_MUTE_SWITCH_MAX];
1253 	u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX];
1254 	u8 phantom_persistence;
1255 	u8 input_select_switch;
1256 	u8 input_link_switch[SCARLETT2_INPUT_GAIN_MAX / 2];
1257 	u8 gain[SCARLETT2_INPUT_GAIN_MAX];
1258 	u8 autogain_switch[SCARLETT2_INPUT_GAIN_MAX];
1259 	u8 autogain_status[SCARLETT2_INPUT_GAIN_MAX];
1260 	s8 ag_targets[SCARLETT2_AG_TARGET_COUNT];
1261 	u8 safe_switch[SCARLETT2_INPUT_GAIN_MAX];
1262 	u8 pcm_input_switch;
1263 	u8 direct_monitor_switch;
1264 	u8 speaker_switching_switch;
1265 	u8 talkback_switch;
1266 	u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX];
1267 	u8 msd_switch;
1268 	u8 standalone_switch;
1269 	u8 power_status;
1270 	u8 bluetooth_volume;
1271 	u8 spdif_mode;
1272 	u8 meter_level_map[SCARLETT2_MAX_METERS];
1273 	struct snd_kcontrol *sync_ctl;
1274 	struct snd_kcontrol *master_vol_ctl;
1275 	struct snd_kcontrol *headphone_vol_ctl;
1276 	struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
1277 	struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX];
1278 	struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX];
1279 	struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT];
1280 	struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX];
1281 	struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX];
1282 	struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX];
1283 	struct snd_kcontrol *dsp_ctls[SCARLETT2_DSP_SWITCH_MAX];
1284 	struct snd_kcontrol *input_mute_ctls[SCARLETT2_INPUT_MUTE_SWITCH_MAX];
1285 	struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX];
1286 	struct snd_kcontrol *input_select_ctl;
1287 	struct snd_kcontrol *input_link_ctls[SCARLETT2_INPUT_GAIN_MAX / 2];
1288 	struct snd_kcontrol *input_gain_ctls[SCARLETT2_INPUT_GAIN_MAX];
1289 	struct snd_kcontrol *autogain_ctls[SCARLETT2_INPUT_GAIN_MAX];
1290 	struct snd_kcontrol *autogain_status_ctls[SCARLETT2_INPUT_GAIN_MAX];
1291 	struct snd_kcontrol *ag_target_ctls[SCARLETT2_AG_TARGET_COUNT];
1292 	struct snd_kcontrol *safe_ctls[SCARLETT2_INPUT_GAIN_MAX];
1293 	struct snd_kcontrol *pcm_input_switch_ctl;
1294 	struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX];
1295 	struct snd_kcontrol *mix_ctls[SCARLETT2_MIX_MAX];
1296 	struct snd_kcontrol *compressor_ctls[SCARLETT2_COMPRESSOR_CTLS_MAX];
1297 	struct snd_kcontrol *precomp_flt_ctls[SCARLETT2_PRECOMP_FLT_CTLS_MAX];
1298 	struct snd_kcontrol *peq_flt_ctls[SCARLETT2_PEQ_FLT_CTLS_MAX];
1299 	struct snd_kcontrol *precomp_flt_switch_ctls[SCARLETT2_DSP_SWITCH_MAX];
1300 	struct snd_kcontrol *peq_flt_switch_ctls[SCARLETT2_DSP_SWITCH_MAX];
1301 	struct snd_kcontrol *direct_monitor_ctl;
1302 	struct snd_kcontrol *speaker_switching_ctl;
1303 	struct snd_kcontrol *talkback_ctl;
1304 	struct snd_kcontrol *power_status_ctl;
1305 	struct snd_kcontrol *bluetooth_volume_ctl;
1306 	u8 mux[SCARLETT2_MUX_MAX];
1307 	u8 mix[SCARLETT2_MIX_MAX];
1308 	u8 monitor_mix[SCARLETT2_MONITOR_MIX_MAX];
1309 };
1310 
1311 /*** Model-specific data ***/
1312 
1313 static const struct scarlett2_device_info s6i6_gen2_info = {
1314 	.config_set = &scarlett2_config_set_gen2a,
1315 	.level_input_count = 2,
1316 	.pad_input_count = 2,
1317 
1318 	.line_out_descrs = {
1319 		"Headphones 1 L",
1320 		"Headphones 1 R",
1321 		"Headphones 2 L",
1322 		"Headphones 2 R",
1323 	},
1324 
1325 	.port_count = {
1326 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1327 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  4,  4 },
1328 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
1329 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
1330 		[SCARLETT2_PORT_TYPE_PCM]      = {  6,  6 },
1331 	},
1332 
1333 	.mux_assignment = { {
1334 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1335 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1336 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1337 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1338 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1339 		{ 0,                            0,  0 },
1340 	}, {
1341 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1342 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1343 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1344 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1345 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1346 		{ 0,                            0,  0 },
1347 	}, {
1348 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1349 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1350 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1351 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1352 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1353 		{ 0,                            0,  0 },
1354 	} },
1355 
1356 	.meter_map = {
1357 		{ 24,  6 },
1358 		{  0, 24 },
1359 		{  0,  0 },
1360 	}
1361 };
1362 
1363 static const struct scarlett2_device_info s18i8_gen2_info = {
1364 	.config_set = &scarlett2_config_set_gen2a,
1365 	.level_input_count = 2,
1366 	.pad_input_count = 4,
1367 
1368 	.line_out_descrs = {
1369 		"Monitor L",
1370 		"Monitor R",
1371 		"Headphones 1 L",
1372 		"Headphones 1 R",
1373 		"Headphones 2 L",
1374 		"Headphones 2 R",
1375 	},
1376 
1377 	.port_count = {
1378 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1379 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  8,  6 },
1380 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
1381 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
1382 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
1383 		[SCARLETT2_PORT_TYPE_PCM]      = {  8, 18 },
1384 	},
1385 
1386 	.mux_assignment = { {
1387 		{ SCARLETT2_PORT_TYPE_PCM,      0, 18 },
1388 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
1389 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1390 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1391 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1392 		{ 0,                            0,  0 },
1393 	}, {
1394 		{ SCARLETT2_PORT_TYPE_PCM,      0, 14 },
1395 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
1396 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1397 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1398 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1399 		{ 0,                            0,  0 },
1400 	}, {
1401 		{ SCARLETT2_PORT_TYPE_PCM,      0, 10 },
1402 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
1403 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1404 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1405 		{ SCARLETT2_PORT_TYPE_NONE,     0,  4 },
1406 		{ 0,                            0,  0 },
1407 	} },
1408 
1409 	.meter_map = {
1410 		{ 26, 18 },
1411 		{  0, 26 },
1412 		{  0,  0 },
1413 	}
1414 };
1415 
1416 static const struct scarlett2_device_info s18i20_gen2_info = {
1417 	.config_set = &scarlett2_config_set_gen2b,
1418 
1419 	.line_out_descrs = {
1420 		"Monitor L",
1421 		"Monitor R",
1422 		NULL,
1423 		NULL,
1424 		NULL,
1425 		NULL,
1426 		"Headphones 1 L",
1427 		"Headphones 1 R",
1428 		"Headphones 2 L",
1429 		"Headphones 2 R",
1430 	},
1431 
1432 	.port_count = {
1433 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1434 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  8, 10 },
1435 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
1436 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
1437 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
1438 		[SCARLETT2_PORT_TYPE_PCM]      = { 20, 18 },
1439 	},
1440 
1441 	.mux_assignment = { {
1442 		{ SCARLETT2_PORT_TYPE_PCM,      0, 18 },
1443 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1444 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1445 		{ SCARLETT2_PORT_TYPE_ADAT,     0,  8 },
1446 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1447 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1448 		{ 0,                            0,  0 },
1449 	}, {
1450 		{ SCARLETT2_PORT_TYPE_PCM,      0, 14 },
1451 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1452 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1453 		{ SCARLETT2_PORT_TYPE_ADAT,     0,  4 },
1454 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1455 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
1456 		{ 0,                            0,  0 },
1457 	}, {
1458 		{ SCARLETT2_PORT_TYPE_PCM,      0, 10 },
1459 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1460 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1461 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
1462 		{ SCARLETT2_PORT_TYPE_NONE,     0,  6 },
1463 		{ 0,                            0,  0 },
1464 	} },
1465 
1466 	.meter_map = {
1467 		{ 38, 18 },
1468 		{  0, 38 },
1469 		{  0,  0 },
1470 	}
1471 };
1472 
1473 static const struct scarlett2_device_info solo_gen3_info = {
1474 	.config_set = &scarlett2_config_set_gen3a,
1475 	.level_input_count = 1,
1476 	.level_input_first = 1,
1477 	.air_input_count = 1,
1478 	.phantom_count = 1,
1479 	.inputs_per_phantom = 1,
1480 	.direct_monitor = 1,
1481 };
1482 
1483 static const struct scarlett2_device_info s2i2_gen3_info = {
1484 	.config_set = &scarlett2_config_set_gen3a,
1485 	.level_input_count = 2,
1486 	.air_input_count = 2,
1487 	.phantom_count = 1,
1488 	.inputs_per_phantom = 2,
1489 	.direct_monitor = 2,
1490 };
1491 
1492 static const struct scarlett2_device_info s4i4_gen3_info = {
1493 	.config_set = &scarlett2_config_set_gen3b,
1494 	.level_input_count = 2,
1495 	.pad_input_count = 2,
1496 	.air_input_count = 2,
1497 	.phantom_count = 1,
1498 	.inputs_per_phantom = 2,
1499 
1500 	.line_out_descrs = {
1501 		"Monitor L",
1502 		"Monitor R",
1503 		"Headphones L",
1504 		"Headphones R",
1505 	},
1506 
1507 	.port_count = {
1508 		[SCARLETT2_PORT_TYPE_NONE]     = { 1, 0 },
1509 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
1510 		[SCARLETT2_PORT_TYPE_MIX]      = { 6, 8 },
1511 		[SCARLETT2_PORT_TYPE_PCM]      = { 4, 6 },
1512 	},
1513 
1514 	.mux_assignment = { {
1515 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1516 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1517 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1518 		{ SCARLETT2_PORT_TYPE_NONE,     0, 16 },
1519 		{ 0,                            0,  0 },
1520 	}, {
1521 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1522 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1523 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1524 		{ SCARLETT2_PORT_TYPE_NONE,     0, 16 },
1525 		{ 0,                            0,  0 },
1526 	}, {
1527 		{ SCARLETT2_PORT_TYPE_PCM,      0,  6 },
1528 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1529 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1530 		{ SCARLETT2_PORT_TYPE_NONE,     0, 16 },
1531 		{ 0,                            0,  0 },
1532 	} },
1533 
1534 	.meter_map = {
1535 		{ 12,  6 },
1536 		{  0, 12 },
1537 		{  0,  0 },
1538 	}
1539 };
1540 
1541 static const struct scarlett2_device_info s8i6_gen3_info = {
1542 	.config_set = &scarlett2_config_set_gen3b,
1543 	.level_input_count = 2,
1544 	.pad_input_count = 2,
1545 	.air_input_count = 2,
1546 	.phantom_count = 1,
1547 	.inputs_per_phantom = 2,
1548 
1549 	.line_out_descrs = {
1550 		"Headphones 1 L",
1551 		"Headphones 1 R",
1552 		"Headphones 2 L",
1553 		"Headphones 2 R",
1554 	},
1555 
1556 	.port_count = {
1557 		[SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
1558 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 6,  4 },
1559 		[SCARLETT2_PORT_TYPE_SPDIF]    = { 2,  2 },
1560 		[SCARLETT2_PORT_TYPE_MIX]      = { 8,  8 },
1561 		[SCARLETT2_PORT_TYPE_PCM]      = { 6, 10 },
1562 	},
1563 
1564 	.mux_assignment = { {
1565 		{ SCARLETT2_PORT_TYPE_PCM,      0,  8 },
1566 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1567 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1568 		{ SCARLETT2_PORT_TYPE_PCM,      8,  2 },
1569 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1570 		{ SCARLETT2_PORT_TYPE_NONE,     0, 18 },
1571 		{ 0,                            0,  0 },
1572 	}, {
1573 		{ SCARLETT2_PORT_TYPE_PCM,      0,  8 },
1574 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1575 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1576 		{ SCARLETT2_PORT_TYPE_PCM,      8,  2 },
1577 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1578 		{ SCARLETT2_PORT_TYPE_NONE,     0, 18 },
1579 		{ 0,                            0,  0 },
1580 	}, {
1581 		{ SCARLETT2_PORT_TYPE_PCM,      0,  8 },
1582 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
1583 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
1584 		{ SCARLETT2_PORT_TYPE_PCM,      8,  2 },
1585 		{ SCARLETT2_PORT_TYPE_MIX,      0,  8 },
1586 		{ SCARLETT2_PORT_TYPE_NONE,     0, 18 },
1587 		{ 0,                            0,  0 },
1588 	} },
1589 
1590 	.meter_map = {
1591 		{ 14, 8 },
1592 		{  0, 6 },
1593 		{ 22, 2 },
1594 		{  6, 8 },
1595 		{  0, 0 },
1596 	}
1597 };
1598 
1599 static const u8 scarlett2_spdif_s18i8_gen3_values[] = { 0, 2, 0xff };
1600 
1601 static const char * const scarlett2_spdif_s18i8_gen3_texts[] = {
1602 	"RCA",
1603 	"Optical",
1604 	NULL
1605 };
1606 
1607 static const struct scarlett2_device_info s18i8_gen3_info = {
1608 	.config_set = &scarlett2_config_set_gen3c,
1609 	.has_speaker_switching = 1,
1610 	.level_input_count = 2,
1611 	.pad_input_count = 4,
1612 	.air_input_count = 4,
1613 	.phantom_count = 2,
1614 	.inputs_per_phantom = 2,
1615 
1616 	.spdif_mode_control_name = "S/PDIF Mode Capture Enum",
1617 	.spdif_mode_values = scarlett2_spdif_s18i8_gen3_values,
1618 	.spdif_mode_texts = scarlett2_spdif_s18i8_gen3_texts,
1619 
1620 	.line_out_remap_enable = 1,
1621 	.line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 },
1622 	.line_out_unmap = { 0, 1, 4, 5, 6, 7, 2, 3 },
1623 
1624 	.line_out_descrs = {
1625 		"Monitor L",
1626 		"Monitor R",
1627 		"Alt Monitor L",
1628 		"Alt Monitor R",
1629 		"Headphones 1 L",
1630 		"Headphones 1 R",
1631 		"Headphones 2 L",
1632 		"Headphones 2 R",
1633 	},
1634 
1635 	.port_count = {
1636 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1637 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  8,  8 },
1638 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
1639 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
1640 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 20 },
1641 		[SCARLETT2_PORT_TYPE_PCM]      = {  8, 20 },
1642 	},
1643 
1644 	.mux_assignment = { {
1645 		{ SCARLETT2_PORT_TYPE_PCM,       0, 10 },
1646 		{ SCARLETT2_PORT_TYPE_PCM,      12,  8 },
1647 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1648 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
1649 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
1650 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1651 		{ SCARLETT2_PORT_TYPE_PCM,      10,  2 },
1652 		{ SCARLETT2_PORT_TYPE_MIX,       0, 20 },
1653 		{ SCARLETT2_PORT_TYPE_NONE,      0, 10 },
1654 		{ 0,                             0,  0 },
1655 	}, {
1656 		{ SCARLETT2_PORT_TYPE_PCM,       0, 10 },
1657 		{ SCARLETT2_PORT_TYPE_PCM,      12,  4 },
1658 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1659 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
1660 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
1661 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1662 		{ SCARLETT2_PORT_TYPE_PCM,      10,  2 },
1663 		{ SCARLETT2_PORT_TYPE_MIX,       0, 20 },
1664 		{ SCARLETT2_PORT_TYPE_NONE,      0, 10 },
1665 		{ 0,                             0,  0 },
1666 	}, {
1667 		{ SCARLETT2_PORT_TYPE_PCM,       0, 10 },
1668 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1669 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  6,  2 },
1670 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  2,  4 },
1671 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1672 		{ SCARLETT2_PORT_TYPE_MIX,       0, 20 },
1673 		{ SCARLETT2_PORT_TYPE_NONE,      0, 10 },
1674 		{ 0,                             0,  0 },
1675 	} },
1676 
1677 	.meter_map = {
1678 		{ 30, 10 },
1679 		{ 42,  8 },
1680 		{  0,  2 },
1681 		{  6,  2 },
1682 		{  2,  4 },
1683 		{  8,  2 },
1684 		{ 40,  2 },
1685 		{ 10, 20 },
1686 		{  0,  0 }
1687 	}
1688 };
1689 
1690 static const u8 scarlett2_spdif_s18i20_gen3_values[] = { 0, 6, 1, 0xff };
1691 
1692 static const char * const scarlett2_spdif_s18i20_gen3_texts[] = {
1693 	"S/PDIF RCA",
1694 	"S/PDIF Optical",
1695 	"Dual ADAT",
1696 	NULL
1697 };
1698 
1699 static const struct scarlett2_device_info s18i20_gen3_info = {
1700 	.config_set = &scarlett2_config_set_gen3c,
1701 	.has_speaker_switching = 1,
1702 	.has_talkback = 1,
1703 	.level_input_count = 2,
1704 	.pad_input_count = 8,
1705 	.air_input_count = 8,
1706 	.phantom_count = 2,
1707 	.inputs_per_phantom = 4,
1708 
1709 	.spdif_mode_control_name = "Digital I/O Mode Capture Enum",
1710 	.spdif_mode_values = scarlett2_spdif_s18i20_gen3_values,
1711 	.spdif_mode_texts = scarlett2_spdif_s18i20_gen3_texts,
1712 
1713 	.line_out_descrs = {
1714 		"Monitor 1 L",
1715 		"Monitor 1 R",
1716 		"Monitor 2 L",
1717 		"Monitor 2 R",
1718 		NULL,
1719 		NULL,
1720 		"Headphones 1 L",
1721 		"Headphones 1 R",
1722 		"Headphones 2 L",
1723 		"Headphones 2 R",
1724 	},
1725 
1726 	.port_count = {
1727 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1728 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  9, 10 },
1729 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
1730 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
1731 		[SCARLETT2_PORT_TYPE_MIX]      = { 12, 25 },
1732 		[SCARLETT2_PORT_TYPE_PCM]      = { 20, 20 },
1733 	},
1734 
1735 	.mux_assignment = { {
1736 		{ SCARLETT2_PORT_TYPE_PCM,       0,  8 },
1737 		{ SCARLETT2_PORT_TYPE_PCM,      10, 10 },
1738 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
1739 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1740 		{ SCARLETT2_PORT_TYPE_ADAT,      0,  8 },
1741 		{ SCARLETT2_PORT_TYPE_PCM,       8,  2 },
1742 		{ SCARLETT2_PORT_TYPE_MIX,       0, 25 },
1743 		{ SCARLETT2_PORT_TYPE_NONE,      0, 12 },
1744 		{ 0,                             0,  0 },
1745 	}, {
1746 		{ SCARLETT2_PORT_TYPE_PCM,       0,  8 },
1747 		{ SCARLETT2_PORT_TYPE_PCM,      10,  8 },
1748 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
1749 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1750 		{ SCARLETT2_PORT_TYPE_ADAT,      0,  8 },
1751 		{ SCARLETT2_PORT_TYPE_PCM,       8,  2 },
1752 		{ SCARLETT2_PORT_TYPE_MIX,       0, 25 },
1753 		{ SCARLETT2_PORT_TYPE_NONE,      0, 10 },
1754 		{ 0,                             0,  0 },
1755 	}, {
1756 		{ SCARLETT2_PORT_TYPE_PCM,       0, 10 },
1757 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0, 10 },
1758 		{ SCARLETT2_PORT_TYPE_SPDIF,     0,  2 },
1759 		{ SCARLETT2_PORT_TYPE_NONE,      0, 24 },
1760 		{ 0,                             0,  0 },
1761 	} },
1762 
1763 	.meter_map = {
1764 		{ 45,  8 },
1765 		{ 55, 10 },
1766 		{  0, 20 },
1767 		{ 53,  2 },
1768 		{ 20, 25 },
1769 		{  0,  0 },
1770 	}
1771 };
1772 
1773 static const struct scarlett2_device_info vocaster_one_info = {
1774 	.config_set = &scarlett2_config_set_vocaster,
1775 	.min_firmware_version = 1769,
1776 
1777 	.phantom_count = 1,
1778 	.inputs_per_phantom = 1,
1779 	.dsp_count = 1,
1780 	.dsp_input_count = 1,
1781 	.precomp_flt_count = 2,
1782 	.peq_flt_count = 3,
1783 	.peq_flt_total_count = 4,
1784 	.mute_input_count = 1,
1785 	.gain_input_count = 1,
1786 
1787 	.port_count = {
1788 		[SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
1789 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2,  4 },
1790 		[SCARLETT2_PORT_TYPE_MIX]      = { 9,  9 },
1791 		[SCARLETT2_PORT_TYPE_PCM]      = { 4, 10 },
1792 	},
1793 
1794 	.mux_assignment = { {
1795 		{ SCARLETT2_PORT_TYPE_MIX,      8, 1 },
1796 		{ SCARLETT2_PORT_TYPE_PCM,      5, 5 },
1797 		{ SCARLETT2_PORT_TYPE_MIX,      6, 2 },
1798 		{ SCARLETT2_PORT_TYPE_PCM,      0, 5 },
1799 		{ SCARLETT2_PORT_TYPE_MIX,      0, 6 },
1800 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1801 		{ 0, 0, 0 },
1802 	} },
1803 
1804 	.meter_map = {
1805 		{ 12, 1 },
1806 		{ 18, 5 },
1807 		{ 10, 2 },
1808 		{ 13, 5 },
1809 		{  4, 6 },
1810 		{  0, 4 },
1811 		{  0, 0 }
1812 	}
1813 };
1814 
1815 static const struct scarlett2_device_info vocaster_two_info = {
1816 	.config_set = &scarlett2_config_set_vocaster,
1817 	.min_firmware_version = 1769,
1818 
1819 	.phantom_count = 2,
1820 	.inputs_per_phantom = 1,
1821 	.dsp_count = 2,
1822 	.dsp_input_count = 2,
1823 	.precomp_flt_count = 2,
1824 	.peq_flt_count = 3,
1825 	.peq_flt_total_count = 4,
1826 	.mute_input_count = 2,
1827 	.gain_input_count = 2,
1828 	.has_bluetooth = 1,
1829 
1830 	.port_count = {
1831 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
1832 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  6,  6 },
1833 		[SCARLETT2_PORT_TYPE_MIX]      = { 12, 14 },
1834 		[SCARLETT2_PORT_TYPE_PCM]      = {  4, 14 },
1835 	},
1836 
1837 	.mux_assignment = { {
1838 		{ SCARLETT2_PORT_TYPE_MIX,      12,  2 },
1839 		{ SCARLETT2_PORT_TYPE_PCM,       6,  8 },
1840 		{ SCARLETT2_PORT_TYPE_MIX,      10,  2 },
1841 		{ SCARLETT2_PORT_TYPE_PCM,       0,  6 },
1842 		{ SCARLETT2_PORT_TYPE_MIX,       0, 10 },
1843 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  6 },
1844 		{ 0, 0, 0 },
1845 	} },
1846 
1847 	.meter_map = {
1848 		{ 18,  2 },
1849 		{ 26,  8 },
1850 		{ 16,  2 },
1851 		{ 20,  6 },
1852 		{  6, 10 },
1853 		{  0,  6 },
1854 		{  0,  0 }
1855 	}
1856 };
1857 
1858 static const struct scarlett2_device_info solo_gen4_info = {
1859 	.config_set = &scarlett2_config_set_gen4_solo,
1860 	.min_firmware_version = 2115,
1861 
1862 	.level_input_count = 1,
1863 	.air_input_count = 1,
1864 	.air_input_first = 1,
1865 	.air_option = 1,
1866 	.phantom_count = 1,
1867 	.phantom_first = 1,
1868 	.inputs_per_phantom = 1,
1869 	.direct_monitor = 1,
1870 	.dsp_count = 2,
1871 
1872 	.port_count = {
1873 		[SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
1874 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2,  2 },
1875 		[SCARLETT2_PORT_TYPE_MIX]      = { 8,  6 },
1876 		[SCARLETT2_PORT_TYPE_PCM]      = { 2,  4 },
1877 	},
1878 
1879 	.mux_assignment = { {
1880 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1881 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1882 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1883 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1884 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1885 		{ 0,                             0,  0 },
1886 	}, {
1887 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1888 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1889 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1890 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1891 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1892 		{ 0,                             0,  0 },
1893 	}, {
1894 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1895 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1896 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1897 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1898 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1899 		{ 0,                             0,  0 },
1900 	} },
1901 
1902 	.meter_map = {
1903 		{  6,  2 },
1904 		{  4,  2 },
1905 		{  8,  4 },
1906 		{  2,  2 },
1907 		{  0,  2 },
1908 		{  0,  0 }
1909 	}
1910 };
1911 
1912 static const struct scarlett2_device_info s2i2_gen4_info = {
1913 	.config_set = &scarlett2_config_set_gen4_2i2,
1914 	.min_firmware_version = 2115,
1915 
1916 	.level_input_count = 2,
1917 	.air_input_count = 2,
1918 	.air_option = 1,
1919 	.phantom_count = 1,
1920 	.inputs_per_phantom = 2,
1921 	.gain_input_count = 2,
1922 	.safe_input_count = 2,
1923 	.direct_monitor = 2,
1924 	.dsp_count = 2,
1925 
1926 	.port_count = {
1927 		[SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
1928 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2,  2 },
1929 		[SCARLETT2_PORT_TYPE_MIX]      = { 6,  6 },
1930 		[SCARLETT2_PORT_TYPE_PCM]      = { 2,  4 },
1931 	},
1932 
1933 	.mux_assignment = { {
1934 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1935 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1936 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1937 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1938 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1939 		{ 0,                             0,  0 },
1940 	}, {
1941 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1942 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1943 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1944 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1945 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1946 		{ 0,                             0,  0 },
1947 	}, {
1948 		{ SCARLETT2_PORT_TYPE_MIX,       4,  2 },
1949 		{ SCARLETT2_PORT_TYPE_MIX,       2,  2 },
1950 		{ SCARLETT2_PORT_TYPE_PCM,       0,  4 },
1951 		{ SCARLETT2_PORT_TYPE_MIX,       0,  2 },
1952 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  2 },
1953 		{ 0,                             0,  0 },
1954 	} },
1955 
1956 	.meter_map = {
1957 		{  6,  2 },
1958 		{  4,  2 },
1959 		{  8,  4 },
1960 		{  2,  2 },
1961 		{  0,  2 },
1962 		{  0,  0 }
1963 	}
1964 };
1965 
1966 static const struct scarlett2_device_info s4i4_gen4_info = {
1967 	.config_set = &scarlett2_config_set_gen4_4i4,
1968 	.min_firmware_version = 2089,
1969 
1970 	.level_input_count = 2,
1971 	.air_input_count = 2,
1972 	.air_option = 1,
1973 	.phantom_count = 2,
1974 	.inputs_per_phantom = 1,
1975 	.gain_input_count = 2,
1976 	.safe_input_count = 2,
1977 	.dsp_count = 2,
1978 
1979 	.port_count = {
1980 		[SCARLETT2_PORT_TYPE_NONE]     = { 1,  0 },
1981 		[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4,  6 },
1982 		[SCARLETT2_PORT_TYPE_MIX]      = { 8, 12 },
1983 		[SCARLETT2_PORT_TYPE_PCM]      = { 6,  6 },
1984 	},
1985 
1986 	.mux_assignment = { {
1987 		{ SCARLETT2_PORT_TYPE_MIX,      10,  2 },
1988 		{ SCARLETT2_PORT_TYPE_PCM,       0,  6 },
1989 		{ SCARLETT2_PORT_TYPE_MIX,       0, 10 },
1990 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  6 },
1991 		{ 0,                             0,  0 },
1992 	}, {
1993 		{ SCARLETT2_PORT_TYPE_MIX,      10,  2 },
1994 		{ SCARLETT2_PORT_TYPE_PCM,       0,  6 },
1995 		{ SCARLETT2_PORT_TYPE_MIX,       0, 10 },
1996 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  6 },
1997 		{ 0,                             0,  0 },
1998 	}, {
1999 		{ SCARLETT2_PORT_TYPE_MIX,      10,  2 },
2000 		{ SCARLETT2_PORT_TYPE_PCM,       0,  6 },
2001 		{ SCARLETT2_PORT_TYPE_MIX,       0, 10 },
2002 		{ SCARLETT2_PORT_TYPE_ANALOGUE,  0,  6 },
2003 		{ 0,                             0,  0 },
2004 	} },
2005 
2006 	.meter_map = {
2007 		{ 16,  8 },
2008 		{  6, 10 },
2009 		{  0,  6 },
2010 		{  0,  0 }
2011 	}
2012 };
2013 
2014 static const struct scarlett2_device_info clarett_2pre_info = {
2015 	.config_set = &scarlett2_config_set_clarett,
2016 	.level_input_count = 2,
2017 	.air_input_count = 2,
2018 
2019 	.line_out_descrs = {
2020 		"Monitor L",
2021 		"Monitor R",
2022 		"Headphones L",
2023 		"Headphones R",
2024 	},
2025 
2026 	.port_count = {
2027 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
2028 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  2,  4 },
2029 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  0 },
2030 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
2031 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
2032 		[SCARLETT2_PORT_TYPE_PCM]      = {  4, 12 },
2033 	},
2034 
2035 	.mux_assignment = { {
2036 		{ SCARLETT2_PORT_TYPE_PCM,      0, 12 },
2037 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
2038 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2039 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2040 		{ 0,                            0,  0 },
2041 	}, {
2042 		{ SCARLETT2_PORT_TYPE_PCM,      0,  8 },
2043 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
2044 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2045 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2046 		{ 0,                            0,  0 },
2047 	}, {
2048 		{ SCARLETT2_PORT_TYPE_PCM,      0,  2 },
2049 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  4 },
2050 		{ SCARLETT2_PORT_TYPE_NONE,     0, 26 },
2051 		{ 0,                            0,  0 },
2052 	} },
2053 
2054 	.meter_map = {
2055 		{ 22, 12 },
2056 		{  0, 22 },
2057 		{  0,  0 }
2058 	}
2059 };
2060 
2061 static const u8 scarlett2_spdif_clarett_values[] = { 0, 1, 2, 0xff };
2062 
2063 static const char * const scarlett2_spdif_clarett_texts[] = {
2064 	"None",
2065 	"Optical",
2066 	"RCA",
2067 	NULL
2068 };
2069 
2070 static const struct scarlett2_device_info clarett_4pre_info = {
2071 	.config_set = &scarlett2_config_set_clarett,
2072 	.level_input_count = 2,
2073 	.air_input_count = 4,
2074 
2075 	.spdif_mode_control_name = "S/PDIF Source Capture Enum",
2076 	.spdif_mode_values = scarlett2_spdif_clarett_values,
2077 	.spdif_mode_texts = scarlett2_spdif_clarett_texts,
2078 
2079 	.line_out_descrs = {
2080 		"Monitor L",
2081 		"Monitor R",
2082 		"Headphones 1 L",
2083 		"Headphones 1 R",
2084 		"Headphones 2 L",
2085 		"Headphones 2 R",
2086 	},
2087 
2088 	.port_count = {
2089 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
2090 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  8,  6 },
2091 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
2092 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  0 },
2093 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
2094 		[SCARLETT2_PORT_TYPE_PCM]      = {  8, 18 },
2095 	},
2096 
2097 	.mux_assignment = { {
2098 		{ SCARLETT2_PORT_TYPE_PCM,      0, 18 },
2099 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
2100 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2101 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2102 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2103 		{ 0,                            0,  0 },
2104 	}, {
2105 		{ SCARLETT2_PORT_TYPE_PCM,      0, 14 },
2106 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
2107 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2108 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2109 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2110 		{ 0,                            0,  0 },
2111 	}, {
2112 		{ SCARLETT2_PORT_TYPE_PCM,      0, 12 },
2113 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0,  6 },
2114 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2115 		{ SCARLETT2_PORT_TYPE_NONE,     0, 24 },
2116 		{ 0,                            0,  0 },
2117 	} },
2118 
2119 	.meter_map = {
2120 		{ 26, 18 },
2121 		{  0, 26 },
2122 		{  0,  0 }
2123 	}
2124 };
2125 
2126 static const struct scarlett2_device_info clarett_8pre_info = {
2127 	.config_set = &scarlett2_config_set_clarett,
2128 	.level_input_count = 2,
2129 	.air_input_count = 8,
2130 
2131 	.spdif_mode_control_name = "S/PDIF Source Capture Enum",
2132 	.spdif_mode_values = scarlett2_spdif_clarett_values,
2133 	.spdif_mode_texts = scarlett2_spdif_clarett_texts,
2134 
2135 	.line_out_descrs = {
2136 		"Monitor L",
2137 		"Monitor R",
2138 		NULL,
2139 		NULL,
2140 		NULL,
2141 		NULL,
2142 		"Headphones 1 L",
2143 		"Headphones 1 R",
2144 		"Headphones 2 L",
2145 		"Headphones 2 R",
2146 	},
2147 
2148 	.port_count = {
2149 		[SCARLETT2_PORT_TYPE_NONE]     = {  1,  0 },
2150 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {  8, 10 },
2151 		[SCARLETT2_PORT_TYPE_SPDIF]    = {  2,  2 },
2152 		[SCARLETT2_PORT_TYPE_ADAT]     = {  8,  8 },
2153 		[SCARLETT2_PORT_TYPE_MIX]      = { 10, 18 },
2154 		[SCARLETT2_PORT_TYPE_PCM]      = { 20, 18 },
2155 	},
2156 
2157 	.mux_assignment = { {
2158 		{ SCARLETT2_PORT_TYPE_PCM,      0, 18 },
2159 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
2160 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2161 		{ SCARLETT2_PORT_TYPE_ADAT,     0,  8 },
2162 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2163 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2164 		{ 0,                            0,  0 },
2165 	}, {
2166 		{ SCARLETT2_PORT_TYPE_PCM,      0, 14 },
2167 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
2168 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2169 		{ SCARLETT2_PORT_TYPE_ADAT,     0,  4 },
2170 		{ SCARLETT2_PORT_TYPE_MIX,      0, 18 },
2171 		{ SCARLETT2_PORT_TYPE_NONE,     0,  8 },
2172 		{ 0,                            0,  0 },
2173 	}, {
2174 		{ SCARLETT2_PORT_TYPE_PCM,      0, 12 },
2175 		{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
2176 		{ SCARLETT2_PORT_TYPE_SPDIF,    0,  2 },
2177 		{ SCARLETT2_PORT_TYPE_NONE,     0, 22 },
2178 		{ 0,                            0,  0 },
2179 	} },
2180 
2181 	.meter_map = {
2182 		{ 38, 18 },
2183 		{  0, 38 },
2184 		{  0,  0 }
2185 	}
2186 };
2187 
2188 struct scarlett2_device_entry {
2189 	const u32 usb_id; /* USB device identifier */
2190 	const struct scarlett2_device_info *info;
2191 	const char *series_name;
2192 };
2193 
2194 static const struct scarlett2_device_entry scarlett2_devices[] = {
2195 	/* Supported Gen 2 devices */
2196 	{ USB_ID(0x1235, 0x8203), &s6i6_gen2_info, "Scarlett Gen 2" },
2197 	{ USB_ID(0x1235, 0x8204), &s18i8_gen2_info, "Scarlett Gen 2" },
2198 	{ USB_ID(0x1235, 0x8201), &s18i20_gen2_info, "Scarlett Gen 2" },
2199 
2200 	/* Supported Gen 3 devices */
2201 	{ USB_ID(0x1235, 0x8211), &solo_gen3_info, "Scarlett Gen 3" },
2202 	{ USB_ID(0x1235, 0x8210), &s2i2_gen3_info, "Scarlett Gen 3" },
2203 	{ USB_ID(0x1235, 0x8212), &s4i4_gen3_info, "Scarlett Gen 3" },
2204 	{ USB_ID(0x1235, 0x8213), &s8i6_gen3_info, "Scarlett Gen 3" },
2205 	{ USB_ID(0x1235, 0x8214), &s18i8_gen3_info, "Scarlett Gen 3" },
2206 	{ USB_ID(0x1235, 0x8215), &s18i20_gen3_info, "Scarlett Gen 3" },
2207 
2208 	/* Supported Vocaster devices */
2209 	{ USB_ID(0x1235, 0x8216), &vocaster_one_info, "Vocaster" },
2210 	{ USB_ID(0x1235, 0x8217), &vocaster_two_info, "Vocaster" },
2211 
2212 	/* Supported Gen 4 devices */
2213 	{ USB_ID(0x1235, 0x8218), &solo_gen4_info, "Scarlett Gen 4" },
2214 	{ USB_ID(0x1235, 0x8219), &s2i2_gen4_info, "Scarlett Gen 4" },
2215 	{ USB_ID(0x1235, 0x821a), &s4i4_gen4_info, "Scarlett Gen 4" },
2216 
2217 	/* Supported Clarett USB/Clarett+ devices */
2218 	{ USB_ID(0x1235, 0x8206), &clarett_2pre_info, "Clarett USB" },
2219 	{ USB_ID(0x1235, 0x8207), &clarett_4pre_info, "Clarett USB" },
2220 	{ USB_ID(0x1235, 0x8208), &clarett_8pre_info, "Clarett USB" },
2221 	{ USB_ID(0x1235, 0x820a), &clarett_2pre_info, "Clarett+" },
2222 	{ USB_ID(0x1235, 0x820b), &clarett_4pre_info, "Clarett+" },
2223 	{ USB_ID(0x1235, 0x820c), &clarett_8pre_info, "Clarett+" },
2224 
2225 	/* End of list */
2226 	{ 0, NULL },
2227 };
2228 
2229 /* get the starting port index number for a given port type/direction */
scarlett2_get_port_start_num(const int port_count[][SCARLETT2_PORT_DIRNS],int direction,int port_type)2230 static int scarlett2_get_port_start_num(
2231 	const int port_count[][SCARLETT2_PORT_DIRNS],
2232 	int direction, int port_type)
2233 {
2234 	int i, num = 0;
2235 
2236 	for (i = 0; i < port_type; i++)
2237 		num += port_count[i][direction];
2238 
2239 	return num;
2240 }
2241 
2242 /*** USB Interactions ***/
2243 
2244 /* Commands for sending/receiving requests/responses */
2245 #define SCARLETT2_USB_CMD_INIT 0
2246 #define SCARLETT2_USB_CMD_REQ  2
2247 #define SCARLETT2_USB_CMD_RESP 3
2248 
2249 #define SCARLETT2_USB_INIT_1        0x00000000
2250 #define SCARLETT2_USB_INIT_2        0x00000002
2251 #define SCARLETT2_USB_REBOOT        0x00000003
2252 #define SCARLETT2_USB_GET_METER     0x00001001
2253 #define SCARLETT2_USB_GET_MIX       0x00002001
2254 #define SCARLETT2_USB_SET_MIX       0x00002002
2255 #define SCARLETT2_USB_GET_MUX       0x00003001
2256 #define SCARLETT2_USB_SET_MUX       0x00003002
2257 #define SCARLETT2_USB_INFO_FLASH    0x00004000
2258 #define SCARLETT2_USB_INFO_SEGMENT  0x00004001
2259 #define SCARLETT2_USB_ERASE_SEGMENT 0x00004002
2260 #define SCARLETT2_USB_GET_ERASE     0x00004003
2261 #define SCARLETT2_USB_WRITE_SEGMENT 0x00004004
2262 #define SCARLETT2_USB_READ_SEGMENT  0x00004005
2263 #define SCARLETT2_USB_GET_SYNC      0x00006004
2264 #define SCARLETT2_USB_GET_DATA      0x00800000
2265 #define SCARLETT2_USB_SET_DATA      0x00800001
2266 #define SCARLETT2_USB_DATA_CMD      0x00800002
2267 
2268 #define SCARLETT2_USB_CONFIG_SAVE 6
2269 
2270 #define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
2271 
2272 #define SCARLETT2_FLASH_BLOCK_SIZE 4096
2273 #define SCARLETT2_FLASH_RW_MAX 1024
2274 #define SCARLETT2_SEGMENT_NUM_MIN 1
2275 #define SCARLETT2_SEGMENT_NUM_MAX 4
2276 
2277 #define SCARLETT2_SEGMENT_SETTINGS_NAME "App_Settings"
2278 #define SCARLETT2_SEGMENT_FIRMWARE_NAME "App_Upgrade"
2279 
2280 /* proprietary request/response format */
2281 struct scarlett2_usb_packet {
2282 	__le32 cmd;
2283 	__le16 size;
2284 	__le16 seq;
2285 	__le32 error;
2286 	__le32 pad;
2287 	u8 data[];
2288 };
2289 
scarlett2_fill_request_header(struct scarlett2_data * private,struct scarlett2_usb_packet * req,u32 cmd,u16 req_size)2290 static void scarlett2_fill_request_header(struct scarlett2_data *private,
2291 					  struct scarlett2_usb_packet *req,
2292 					  u32 cmd, u16 req_size)
2293 {
2294 	/* sequence must go up by 1 for each request */
2295 	u16 seq = private->scarlett2_seq++;
2296 
2297 	req->cmd = cpu_to_le32(cmd);
2298 	req->size = cpu_to_le16(req_size);
2299 	req->seq = cpu_to_le16(seq);
2300 	req->error = 0;
2301 	req->pad = 0;
2302 }
2303 
scarlett2_usb_tx(struct usb_device * dev,int interface,void * buf,u16 size)2304 static int scarlett2_usb_tx(struct usb_device *dev, int interface,
2305 			    void *buf, u16 size)
2306 {
2307 	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
2308 			SCARLETT2_USB_CMD_REQ,
2309 			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
2310 			0, interface, buf, size);
2311 }
2312 
scarlett2_usb_rx(struct usb_device * dev,int interface,u32 usb_req,void * buf,u16 size)2313 static int scarlett2_usb_rx(struct usb_device *dev, int interface,
2314 			    u32 usb_req, void *buf, u16 size)
2315 {
2316 	return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
2317 			usb_req,
2318 			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
2319 			0, interface, buf, size);
2320 }
2321 
2322 /* Send a proprietary format request to the Scarlett interface */
scarlett2_usb(struct usb_mixer_interface * mixer,u32 cmd,void * req_data,u16 req_size,void * resp_data,u16 resp_size)2323 static int scarlett2_usb(
2324 	struct usb_mixer_interface *mixer, u32 cmd,
2325 	void *req_data, u16 req_size, void *resp_data, u16 resp_size)
2326 {
2327 	struct scarlett2_data *private = mixer->private_data;
2328 	struct usb_device *dev = mixer->chip->dev;
2329 	struct scarlett2_usb_packet *req, *resp = NULL;
2330 	size_t req_buf_size = struct_size(req, data, req_size);
2331 	size_t resp_buf_size = struct_size(resp, data, resp_size);
2332 	int err;
2333 
2334 	req = kmalloc(req_buf_size, GFP_KERNEL);
2335 	if (!req) {
2336 		err = -ENOMEM;
2337 		goto error;
2338 	}
2339 
2340 	resp = kmalloc(resp_buf_size, GFP_KERNEL);
2341 	if (!resp) {
2342 		err = -ENOMEM;
2343 		goto error;
2344 	}
2345 
2346 	mutex_lock(&private->usb_mutex);
2347 
2348 	/* build request message and send it */
2349 
2350 	scarlett2_fill_request_header(private, req, cmd, req_size);
2351 
2352 	if (req_size)
2353 		memcpy(req->data, req_data, req_size);
2354 
2355 	err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
2356 			       req, req_buf_size);
2357 
2358 	if (err != req_buf_size) {
2359 		usb_audio_err(
2360 			mixer->chip,
2361 			"%s USB request result cmd %x was %d\n",
2362 			private->series_name, cmd, err);
2363 		err = -EINVAL;
2364 		goto unlock;
2365 	}
2366 
2367 	if (!wait_for_completion_timeout(&private->cmd_done,
2368 					 msecs_to_jiffies(1000))) {
2369 		usb_audio_err(
2370 			mixer->chip,
2371 			"%s USB request timed out, cmd %x\n",
2372 			private->series_name, cmd);
2373 
2374 		err = -ETIMEDOUT;
2375 		goto unlock;
2376 	}
2377 
2378 	/* send a second message to get the response */
2379 
2380 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
2381 			       SCARLETT2_USB_CMD_RESP,
2382 			       resp, resp_buf_size);
2383 
2384 	/* validate the response */
2385 
2386 	if (err != resp_buf_size) {
2387 
2388 		/* ESHUTDOWN and EPROTO are valid responses to a
2389 		 * reboot request
2390 		 */
2391 		if (cmd == SCARLETT2_USB_REBOOT &&
2392 		    (err == -ESHUTDOWN || err == -EPROTO)) {
2393 			err = 0;
2394 			goto unlock;
2395 		}
2396 
2397 		usb_audio_err(
2398 			mixer->chip,
2399 			"%s USB response result cmd %x was %d expected %zu\n",
2400 			private->series_name, cmd, err, resp_buf_size);
2401 		err = -EINVAL;
2402 		goto unlock;
2403 	}
2404 
2405 	/* cmd/seq/size should match except when initialising
2406 	 * seq sent = 1, response = 0
2407 	 */
2408 	if (resp->cmd != req->cmd ||
2409 	    (resp->seq != req->seq &&
2410 		(le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
2411 	    resp_size != le16_to_cpu(resp->size) ||
2412 	    resp->error ||
2413 	    resp->pad) {
2414 		usb_audio_err(
2415 			mixer->chip,
2416 			"%s USB invalid response; "
2417 			   "cmd tx/rx %d/%d seq %d/%d size %d/%d "
2418 			   "error %d pad %d\n",
2419 			private->series_name,
2420 			le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
2421 			le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
2422 			resp_size, le16_to_cpu(resp->size),
2423 			le32_to_cpu(resp->error),
2424 			le32_to_cpu(resp->pad));
2425 		err = -EINVAL;
2426 		goto unlock;
2427 	}
2428 
2429 	if (resp_data && resp_size > 0)
2430 		memcpy(resp_data, resp->data, resp_size);
2431 
2432 unlock:
2433 	mutex_unlock(&private->usb_mutex);
2434 error:
2435 	kfree(req);
2436 	kfree(resp);
2437 	return err;
2438 }
2439 
2440 /* Send a USB message to get data; result placed in *buf */
scarlett2_usb_get(struct usb_mixer_interface * mixer,int offset,void * buf,int size)2441 static int scarlett2_usb_get(
2442 	struct usb_mixer_interface *mixer,
2443 	int offset, void *buf, int size)
2444 {
2445 	struct {
2446 		__le32 offset;
2447 		__le32 size;
2448 	} __packed req;
2449 
2450 	req.offset = cpu_to_le32(offset);
2451 	req.size = cpu_to_le32(size);
2452 	return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
2453 			     &req, sizeof(req), buf, size);
2454 }
2455 
2456 /* Return true if the given configuration item is present in the
2457  * configuration set used by this device.
2458  */
scarlett2_has_config_item(struct scarlett2_data * private,int config_item_num)2459 static int scarlett2_has_config_item(
2460 	struct scarlett2_data *private, int config_item_num)
2461 {
2462 	return !!private->config_set->items[config_item_num].offset;
2463 }
2464 
2465 /* Send a USB message to get configuration parameters; result placed in *buf */
scarlett2_usb_get_config(struct usb_mixer_interface * mixer,int config_item_num,int count,void * buf)2466 static int scarlett2_usb_get_config(
2467 	struct usb_mixer_interface *mixer,
2468 	int config_item_num, int count, void *buf)
2469 {
2470 	struct scarlett2_data *private = mixer->private_data;
2471 	const struct scarlett2_config *config_item =
2472 		&private->config_set->items[config_item_num];
2473 	int size, err, i;
2474 	u8 *buf_8;
2475 	u8 value;
2476 
2477 	/* Check that the configuration item is present in the
2478 	 * configuration set used by this device
2479 	 */
2480 	if (!config_item->offset)
2481 		return -EFAULT;
2482 
2483 	/* Writes to the parameter buffer are always 1 byte */
2484 	size = config_item->size ? config_item->size : 8;
2485 
2486 	/* For byte-sized parameters, retrieve directly into buf */
2487 	if (size >= 8) {
2488 		size = size / 8 * count;
2489 		err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
2490 		if (err < 0)
2491 			return err;
2492 		if (size == 2) {
2493 			u16 *buf_16 = buf;
2494 
2495 			for (i = 0; i < count; i++, buf_16++)
2496 				*buf_16 = le16_to_cpu(*(__le16 *)buf_16);
2497 		} else if (size == 4) {
2498 			u32 *buf_32 = buf;
2499 
2500 			for (i = 0; i < count; i++, buf_32++)
2501 				*buf_32 = le32_to_cpu(*(__le32 *)buf_32);
2502 		}
2503 		return 0;
2504 	}
2505 
2506 	/* For bit-sized parameters, retrieve into value */
2507 	err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
2508 	if (err < 0)
2509 		return err;
2510 
2511 	/* then unpack from value into buf[] */
2512 	buf_8 = buf;
2513 	for (i = 0; i < 8 && i < count; i++, value >>= 1)
2514 		*buf_8++ = value & 1;
2515 
2516 	return 0;
2517 }
2518 
2519 /* Send a SCARLETT2_USB_SET_DATA command.
2520  * offset: location in the device's data space
2521  * size: size in bytes of the value (1, 2, 4)
2522  */
scarlett2_usb_set_data(struct usb_mixer_interface * mixer,int offset,int size,int value)2523 static int scarlett2_usb_set_data(
2524 	struct usb_mixer_interface *mixer,
2525 	int offset, int size, int value)
2526 {
2527 	struct scarlett2_data *private = mixer->private_data;
2528 	struct {
2529 		__le32 offset;
2530 		__le32 size;
2531 		__le32 value;
2532 	} __packed req;
2533 
2534 	req.offset = cpu_to_le32(offset);
2535 	req.size = cpu_to_le32(size);
2536 	req.value = cpu_to_le32(value);
2537 	return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2538 			     &req, sizeof(u32) * 2 + size, NULL, 0);
2539 }
2540 
2541 /* Send a SCARLETT2_USB_SET_DATA command with multiple values.
2542  * offset: location in the device's data space
2543  * size: size in bytes of each value (1, 2, 4)
2544  * count: number of values
2545  */
scarlett2_usb_set_data_buf(struct usb_mixer_interface * mixer,int offset,int size,int count,void * buf)2546 static int scarlett2_usb_set_data_buf(
2547 	struct usb_mixer_interface *mixer,
2548 	int offset, int size, int count, void *buf)
2549 {
2550 	struct scarlett2_data *private = mixer->private_data;
2551 	int bytes = size * count;
2552 	struct {
2553 		__le32 offset;
2554 		__le32 size;
2555 		u8 data[];
2556 	} __packed *req;
2557 	int err;
2558 	int buf_size = struct_size(req, data, bytes);
2559 
2560 	req = kmalloc(buf_size, GFP_KERNEL);
2561 	if (!req)
2562 		return -ENOMEM;
2563 
2564 	req->offset = cpu_to_le32(offset);
2565 	req->size = cpu_to_le32(bytes);
2566 	if (size == 1) {
2567 		memcpy(req->data, buf, count);
2568 	} else if (size == 2) {
2569 		u16 *buf_16 = buf;
2570 		int i;
2571 
2572 		for (i = 0; i < count; i++)
2573 			((__le16 *)req->data)[i] = cpu_to_le16(buf_16[i]);
2574 	} else {
2575 		u32 *buf_32 = buf;
2576 		int i;
2577 
2578 		for (i = 0; i < count; i++)
2579 			((__le32 *)req->data)[i] = cpu_to_le32(buf_32[i]);
2580 	}
2581 
2582 	err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2583 			    req, buf_size, NULL, 0);
2584 
2585 	kfree(req);
2586 	return err;
2587 }
2588 
2589 /* Send a SCARLETT2_USB_DATA_CMD command.
2590  * Configuration changes require activation with this after they have
2591  * been uploaded by a previous SCARLETT2_USB_SET_DATA.
2592  * The value for activate needed is determined by the configuration
2593  * item.
2594  */
scarlett2_usb_activate_config(struct usb_mixer_interface * mixer,int activate)2595 static int scarlett2_usb_activate_config(
2596 	struct usb_mixer_interface *mixer, int activate)
2597 {
2598 	__le32 req;
2599 
2600 	req = cpu_to_le32(activate);
2601 	return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
2602 			     &req, sizeof(req), NULL, 0);
2603 }
2604 
2605 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter */
scarlett2_usb_set_config(struct usb_mixer_interface * mixer,int config_item_num,int index,int value)2606 static int scarlett2_usb_set_config(
2607 	struct usb_mixer_interface *mixer,
2608 	int config_item_num, int index, int value)
2609 {
2610 	struct scarlett2_data *private = mixer->private_data;
2611 	const struct scarlett2_config_set *config_set = private->config_set;
2612 	const struct scarlett2_config *config_item =
2613 		&config_set->items[config_item_num];
2614 	int offset, size;
2615 	int err;
2616 
2617 	/* Check that the configuration item is present in the
2618 	 * configuration set used by this device
2619 	 */
2620 	if (!config_item->offset)
2621 		return -EFAULT;
2622 
2623 	/* Write via the parameter buffer? */
2624 	if (config_item->pbuf) {
2625 		if (!config_set->param_buf_addr)
2626 			return -EFAULT;
2627 
2628 		/* Place index in param_buf_addr + 1 */
2629 		err = scarlett2_usb_set_data(
2630 			mixer, config_set->param_buf_addr + 1, 1, index);
2631 		if (err < 0)
2632 			return err;
2633 
2634 		/* Place value in param_buf_addr */
2635 		err = scarlett2_usb_set_data(
2636 			mixer, config_set->param_buf_addr, 1, value);
2637 		if (err < 0)
2638 			return err;
2639 
2640 		/* Activate the write through the parameter buffer */
2641 		return scarlett2_usb_activate_config(
2642 			mixer, config_item->activate);
2643 	}
2644 
2645 	/* Direct writes (not via the parameter buffer) need NVRAM
2646 	 * save and support bit-modification
2647 	 */
2648 
2649 	/* Cancel any pending NVRAM save */
2650 	cancel_delayed_work_sync(&private->work);
2651 
2652 	/* Convert config_item->size in bits to size in bytes and
2653 	 * calculate offset
2654 	 */
2655 	if (config_item->size >= 8) {
2656 		size = config_item->size / 8;
2657 		offset = config_item->offset + index * size;
2658 
2659 	/* If updating a bit, retrieve the old value, set/clear the
2660 	 * bit as needed, and update value
2661 	 */
2662 	} else {
2663 		u8 tmp;
2664 
2665 		size = 1;
2666 		offset = config_item->offset;
2667 
2668 		err = scarlett2_usb_get(mixer, offset, &tmp, 1);
2669 		if (err < 0)
2670 			return err;
2671 
2672 		if (value)
2673 			tmp |= (1 << index);
2674 		else
2675 			tmp &= ~(1 << index);
2676 
2677 		value = tmp;
2678 	}
2679 
2680 	/* Write the new value */
2681 	err = scarlett2_usb_set_data(mixer, offset, size, value);
2682 	if (err < 0)
2683 		return err;
2684 
2685 	/* Activate the change */
2686 	err = scarlett2_usb_activate_config(mixer, config_item->activate);
2687 	if (err < 0)
2688 		return err;
2689 
2690 	/* Interfaces with parameter buffer writes don't need a
2691 	 * separate save step
2692 	 */
2693 	if (config_set->param_buf_addr)
2694 		return 0;
2695 
2696 	/* Schedule the change to be written to NVRAM */
2697 	if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
2698 		schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
2699 
2700 	return 0;
2701 }
2702 
2703 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter with
2704  * multiple values
2705  */
scarlett2_usb_set_config_buf(struct usb_mixer_interface * mixer,int config_item_num,int index,int count,void * buf)2706 static int scarlett2_usb_set_config_buf(
2707 	struct usb_mixer_interface *mixer,
2708 	int config_item_num, int index, int count, void *buf)
2709 {
2710 	struct scarlett2_data *private = mixer->private_data;
2711 	const struct scarlett2_config_set *config_set = private->config_set;
2712 	const struct scarlett2_config *config_item =
2713 		&config_set->items[config_item_num];
2714 	int offset, size;
2715 	int err;
2716 
2717 	/* Check that the configuration item is present in the
2718 	 * configuration set used by this device
2719 	 */
2720 	if (!config_item->offset)
2721 		return -EFAULT;
2722 
2723 	/* Convert config_item->size in bits to size in bytes and
2724 	 * calculate offset
2725 	 */
2726 	if (config_item->size >= 8) {
2727 		size = config_item->size / 8;
2728 		offset = config_item->offset + index * size;
2729 
2730 	/* Bit updates not supported */
2731 	} else {
2732 		return -EFAULT;
2733 	}
2734 
2735 	/* Write the new values */
2736 	err = scarlett2_usb_set_data_buf(mixer, offset, size, count, buf);
2737 	if (err < 0)
2738 		return err;
2739 
2740 	/* Activate the change */
2741 	return scarlett2_usb_activate_config(mixer, config_item->activate);
2742 }
2743 
2744 /* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
scarlett2_config_save(struct usb_mixer_interface * mixer)2745 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
2746 {
2747 	int err;
2748 
2749 	err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE);
2750 	if (err < 0)
2751 		usb_audio_err(mixer->chip, "config save failed: %d\n", err);
2752 }
2753 
2754 /* Delayed work to save config */
scarlett2_config_save_work(struct work_struct * work)2755 static void scarlett2_config_save_work(struct work_struct *work)
2756 {
2757 	struct scarlett2_data *private =
2758 		container_of(work, struct scarlett2_data, work.work);
2759 
2760 	scarlett2_config_save(private->mixer);
2761 }
2762 
2763 /* Send a USB message to get sync status; result placed in *sync */
scarlett2_usb_get_sync_status(struct usb_mixer_interface * mixer,u8 * sync)2764 static int scarlett2_usb_get_sync_status(
2765 	struct usb_mixer_interface *mixer,
2766 	u8 *sync)
2767 {
2768 	__le32 data;
2769 	int err;
2770 
2771 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
2772 			    NULL, 0, &data, sizeof(data));
2773 	if (err < 0)
2774 		return err;
2775 
2776 	*sync = !!data;
2777 	return 0;
2778 }
2779 
2780 /* Return true if the device has a mixer that we can control */
scarlett2_has_mixer(struct scarlett2_data * private)2781 static int scarlett2_has_mixer(struct scarlett2_data *private)
2782 {
2783 	return !!private->info->mux_assignment[0][0].count;
2784 }
2785 
2786 /* Map from mixer value to (db + 80) * 2
2787  * (reverse of scarlett2_mixer_values[])
2788  */
scarlett2_mixer_value_to_db(int value)2789 static int scarlett2_mixer_value_to_db(int value)
2790 {
2791 	int i;
2792 
2793 	for (i = 0; i < SCARLETT2_MIXER_VALUE_COUNT; i++)
2794 		if (scarlett2_mixer_values[i] >= value)
2795 			return i;
2796 	return SCARLETT2_MIXER_MAX_VALUE;
2797 }
2798 
2799 /* Send a USB message to get the volumes for all inputs of one mix
2800  * and put the values into private->mix[]
2801  */
scarlett2_usb_get_mix(struct usb_mixer_interface * mixer,int mix_num)2802 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
2803 				 int mix_num)
2804 {
2805 	struct scarlett2_data *private = mixer->private_data;
2806 
2807 	int num_mixer_in = private->num_mix_in;
2808 	int err, i, j;
2809 
2810 	struct {
2811 		__le16 mix_num;
2812 		__le16 count;
2813 	} __packed req;
2814 
2815 	__le16 data[SCARLETT2_INPUT_MIX_MAX];
2816 
2817 	req.mix_num = cpu_to_le16(mix_num);
2818 	req.count = cpu_to_le16(num_mixer_in);
2819 
2820 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
2821 			    &req, sizeof(req),
2822 			    data, num_mixer_in * sizeof(u16));
2823 	if (err < 0)
2824 		return err;
2825 
2826 	for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
2827 		private->mix[j] = scarlett2_mixer_value_to_db(
2828 			le16_to_cpu(data[i]));
2829 
2830 	return 0;
2831 }
2832 
2833 /* Send a USB message to set the volumes for all inputs of one mix
2834  * (values obtained from private->mix[])
2835  */
scarlett2_usb_set_mix(struct usb_mixer_interface * mixer,int mix_num)2836 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
2837 				 int mix_num)
2838 {
2839 	struct scarlett2_data *private = mixer->private_data;
2840 
2841 	struct {
2842 		__le16 mix_num;
2843 		__le16 data[SCARLETT2_INPUT_MIX_MAX];
2844 	} __packed req;
2845 
2846 	int i, j;
2847 	int num_mixer_in = private->num_mix_in;
2848 
2849 	req.mix_num = cpu_to_le16(mix_num);
2850 
2851 	for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
2852 		req.data[i] = cpu_to_le16(
2853 			scarlett2_mixer_values[private->mix[j]]
2854 		);
2855 
2856 	return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
2857 			     &req, (num_mixer_in + 1) * sizeof(u16),
2858 			     NULL, 0);
2859 }
2860 
2861 /* Convert a port number index (per info->port_count) to a hardware ID */
scarlett2_mux_src_num_to_id(const int port_count[][SCARLETT2_PORT_DIRNS],int num)2862 static u32 scarlett2_mux_src_num_to_id(
2863 	const int port_count[][SCARLETT2_PORT_DIRNS], int num)
2864 {
2865 	int port_type;
2866 
2867 	for (port_type = 0;
2868 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
2869 	     port_type++) {
2870 		if (num < port_count[port_type][SCARLETT2_PORT_IN])
2871 			return scarlett2_ports[port_type].id | num;
2872 		num -= port_count[port_type][SCARLETT2_PORT_IN];
2873 	}
2874 
2875 	/* Oops */
2876 	return 0;
2877 }
2878 
2879 /* Convert a hardware ID to a port number index */
scarlett2_mux_id_to_num(const int port_count[][SCARLETT2_PORT_DIRNS],int direction,u32 id)2880 static u32 scarlett2_mux_id_to_num(
2881 	const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)
2882 {
2883 	int port_type;
2884 	int port_num = 0;
2885 
2886 	for (port_type = 0;
2887 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
2888 	     port_type++) {
2889 		int base = scarlett2_ports[port_type].id;
2890 		int count = port_count[port_type][direction];
2891 
2892 		if (id >= base && id < base + count)
2893 			return port_num + id - base;
2894 		port_num += count;
2895 	}
2896 
2897 	/* Oops */
2898 	return -1;
2899 }
2900 
2901 /* Convert one mux entry from the interface and load into private->mux[] */
scarlett2_usb_populate_mux(struct scarlett2_data * private,u32 mux_entry)2902 static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
2903 				       u32 mux_entry)
2904 {
2905 	const struct scarlett2_device_info *info = private->info;
2906 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2907 
2908 	int dst_idx, src_idx;
2909 
2910 	dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT,
2911 					  mux_entry & 0xFFF);
2912 	if (dst_idx < 0)
2913 		return;
2914 
2915 	if (dst_idx >= private->num_mux_dsts) {
2916 		usb_audio_err(private->mixer->chip,
2917 			"BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",
2918 			mux_entry, dst_idx, private->num_mux_dsts);
2919 		return;
2920 	}
2921 
2922 	src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN,
2923 					  mux_entry >> 12);
2924 	if (src_idx < 0)
2925 		return;
2926 
2927 	if (src_idx >= private->num_mux_srcs) {
2928 		usb_audio_err(private->mixer->chip,
2929 			"BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",
2930 			mux_entry, src_idx, private->num_mux_srcs);
2931 		return;
2932 	}
2933 
2934 	private->mux[dst_idx] = src_idx;
2935 }
2936 
2937 /* Update the meter level map
2938  *
2939  * The meter level data from the interface (SCARLETT2_USB_GET_METER
2940  * request) is returned in mux_assignment order, but to avoid exposing
2941  * that to userspace, scarlett2_meter_ctl_get() rearranges the data
2942  * into scarlett2_ports order using the meter_level_map[] array which
2943  * is set up by this function.
2944  *
2945  * In addition, the meter level data values returned from the
2946  * interface are invalid for destinations where:
2947  *
2948  * - the source is "Off"; therefore we set those values to zero (map
2949  *   value of 255)
2950  *
2951  * - the source is assigned to a previous (with respect to the
2952  *   mux_assignment order) destination; therefore we set those values
2953  *   to the value previously reported for that source
2954  */
scarlett2_update_meter_level_map(struct scarlett2_data * private)2955 static void scarlett2_update_meter_level_map(struct scarlett2_data *private)
2956 {
2957 	const struct scarlett2_device_info *info = private->info;
2958 	const struct scarlett2_meter_entry *entry;
2959 
2960 	/* sources already assigned to a destination
2961 	 * value is 255 for None, otherwise the value of i
2962 	 * (index into array returned by
2963 	 * scarlett2_usb_get_meter_levels())
2964 	 */
2965 	u8 seen_src[SCARLETT2_MAX_SRCS] = { 1 };
2966 	u8 seen_src_value[SCARLETT2_MAX_SRCS] = { 255 };
2967 
2968 	/* index in meter_map[] order */
2969 	int i = 0;
2970 
2971 	/* go through the meter_map[] entries */
2972 	for (entry = info->meter_map;
2973 	     entry->count;
2974 	     entry++) {
2975 
2976 		/* fill in each meter_level_map[] entry */
2977 		int j, mux_idx;
2978 
2979 		for (j = 0, mux_idx = entry->start;
2980 		     j < entry->count;
2981 		     i++, j++, mux_idx++) {
2982 
2983 			/* convert mux_idx using line_out_unmap[] */
2984 			int map_mux_idx = (
2985 			    info->line_out_remap_enable &&
2986 			    mux_idx < private->num_line_out
2987 			) ? info->line_out_unmap[mux_idx]
2988 			  : mux_idx;
2989 
2990 			/* check which source is connected, and if
2991 			 * that source is already connected elsewhere,
2992 			 * use that existing connection's destination
2993 			 * for this meter entry instead
2994 			 */
2995 			int mux_src = private->mux[mux_idx];
2996 
2997 			if (!seen_src[mux_src]) {
2998 				seen_src[mux_src] = 1;
2999 				seen_src_value[mux_src] = i;
3000 			}
3001 			private->meter_level_map[map_mux_idx] =
3002 				seen_src_value[mux_src];
3003 		}
3004 	}
3005 }
3006 
3007 /* Send USB message to get mux inputs and then populate private->mux[] */
scarlett2_usb_get_mux(struct usb_mixer_interface * mixer)3008 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
3009 {
3010 	struct scarlett2_data *private = mixer->private_data;
3011 	int count = private->num_mux_dsts;
3012 	int err, i;
3013 
3014 	struct {
3015 		__le16 num;
3016 		__le16 count;
3017 	} __packed req;
3018 
3019 	__le32 data[SCARLETT2_MUX_MAX];
3020 
3021 	private->mux_updated = 0;
3022 
3023 	req.num = 0;
3024 	req.count = cpu_to_le16(count);
3025 
3026 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
3027 			    &req, sizeof(req),
3028 			    data, count * sizeof(u32));
3029 	if (err < 0)
3030 		return err;
3031 
3032 	for (i = 0; i < count; i++)
3033 		scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
3034 
3035 	scarlett2_update_meter_level_map(private);
3036 
3037 	return 0;
3038 }
3039 
3040 /* Send USB messages to set mux inputs */
scarlett2_usb_set_mux(struct usb_mixer_interface * mixer)3041 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
3042 {
3043 	struct scarlett2_data *private = mixer->private_data;
3044 	const struct scarlett2_device_info *info = private->info;
3045 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3046 	int table;
3047 
3048 	struct {
3049 		__le16 pad;
3050 		__le16 num;
3051 		__le32 data[SCARLETT2_MUX_MAX];
3052 	} __packed req;
3053 
3054 	req.pad = 0;
3055 
3056 	/* set mux settings for each rate */
3057 	for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {
3058 		const struct scarlett2_mux_entry *entry;
3059 
3060 		/* i counts over the output array */
3061 		int i = 0, err;
3062 
3063 		req.num = cpu_to_le16(table);
3064 
3065 		/* loop through each entry */
3066 		for (entry = info->mux_assignment[table];
3067 		     entry->count;
3068 		     entry++) {
3069 			int j;
3070 			int port_type = entry->port_type;
3071 			int port_idx = entry->start;
3072 			int mux_idx = scarlett2_get_port_start_num(port_count,
3073 				SCARLETT2_PORT_OUT, port_type) + port_idx;
3074 			int dst_id = scarlett2_ports[port_type].id + port_idx;
3075 
3076 			/* Empty slots */
3077 			if (!dst_id) {
3078 				for (j = 0; j < entry->count; j++)
3079 					req.data[i++] = 0;
3080 				continue;
3081 			}
3082 
3083 			/* Non-empty mux slots use the lower 12 bits
3084 			 * for the destination and next 12 bits for
3085 			 * the source
3086 			 */
3087 			for (j = 0; j < entry->count; j++) {
3088 				int src_id = scarlett2_mux_src_num_to_id(
3089 					port_count, private->mux[mux_idx++]);
3090 				req.data[i++] = cpu_to_le32(dst_id |
3091 							    src_id << 12);
3092 				dst_id++;
3093 			}
3094 		}
3095 
3096 		err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
3097 				    &req, (i + 1) * sizeof(u32),
3098 				    NULL, 0);
3099 		if (err < 0)
3100 			return err;
3101 	}
3102 
3103 	scarlett2_update_meter_level_map(private);
3104 
3105 	return 0;
3106 }
3107 
3108 /* Send USB message to get meter levels */
scarlett2_usb_get_meter_levels(struct usb_mixer_interface * mixer,u16 num_meters,u16 * levels)3109 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
3110 					  u16 num_meters, u16 *levels)
3111 {
3112 	struct {
3113 		__le16 pad;
3114 		__le16 num_meters;
3115 		__le32 magic;
3116 	} __packed req;
3117 	__le32 resp[SCARLETT2_MAX_METERS];
3118 	int i, err;
3119 
3120 	req.pad = 0;
3121 	req.num_meters = cpu_to_le16(num_meters);
3122 	req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
3123 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
3124 			    &req, sizeof(req), resp, num_meters * sizeof(u32));
3125 	if (err < 0)
3126 		return err;
3127 
3128 	/* copy, convert to u16 */
3129 	for (i = 0; i < num_meters; i++)
3130 		levels[i] = le32_to_cpu(resp[i]);
3131 
3132 	return 0;
3133 }
3134 
3135 /* For config items with mute=1, xor bits 0 & 1 together to get the
3136  * current/next state. This won't have any effect on values which are
3137  * only ever 0/1.
3138  */
scarlett2_decode_muteable(uint8_t v)3139 static uint8_t scarlett2_decode_muteable(uint8_t v)
3140 {
3141 	return (v ^ (v >> 1)) & 1;
3142 }
3143 
3144 /*** Control Functions ***/
3145 
3146 /* helper function to create a new control */
scarlett2_add_new_ctl(struct usb_mixer_interface * mixer,const struct snd_kcontrol_new * ncontrol,int index,int channels,const char * name,struct snd_kcontrol ** kctl_return)3147 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
3148 				 const struct snd_kcontrol_new *ncontrol,
3149 				 int index, int channels, const char *name,
3150 				 struct snd_kcontrol **kctl_return)
3151 {
3152 	struct snd_kcontrol *kctl;
3153 	struct usb_mixer_elem_info *elem;
3154 	int err;
3155 
3156 	elem = kzalloc(sizeof(*elem), GFP_KERNEL);
3157 	if (!elem)
3158 		return -ENOMEM;
3159 
3160 	/* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
3161 	 * ignores them for resume and other operations.
3162 	 * Also, the head.id field is set to 0, as we don't use this field.
3163 	 */
3164 	elem->head.mixer = mixer;
3165 	elem->control = index;
3166 	elem->head.id = 0;
3167 	elem->channels = channels;
3168 	elem->val_type = USB_MIXER_BESPOKEN;
3169 
3170 	kctl = snd_ctl_new1(ncontrol, elem);
3171 	if (!kctl) {
3172 		kfree(elem);
3173 		return -ENOMEM;
3174 	}
3175 	kctl->private_free = snd_usb_mixer_elem_free;
3176 
3177 	strscpy(kctl->id.name, name, sizeof(kctl->id.name));
3178 
3179 	err = snd_usb_mixer_add_control(&elem->head, kctl);
3180 	if (err < 0)
3181 		return err;
3182 
3183 	if (kctl_return)
3184 		*kctl_return = kctl;
3185 
3186 	return 0;
3187 }
3188 
3189 /*** Firmware Version Control ***/
3190 
scarlett2_firmware_version_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3191 static int scarlett2_firmware_version_ctl_get(
3192 	struct snd_kcontrol *kctl,
3193 	struct snd_ctl_elem_value *ucontrol)
3194 {
3195 	struct usb_mixer_elem_info *elem = kctl->private_data;
3196 	struct scarlett2_data *private = elem->head.mixer->private_data;
3197 
3198 	ucontrol->value.integer.value[0] = private->firmware_version;
3199 
3200 	return 0;
3201 }
3202 
scarlett2_firmware_version_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3203 static int scarlett2_firmware_version_ctl_info(
3204 	struct snd_kcontrol *kctl,
3205 	struct snd_ctl_elem_info *uinfo)
3206 {
3207 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3208 	uinfo->count = 1;
3209 
3210 	return 0;
3211 }
3212 
3213 static const struct snd_kcontrol_new scarlett2_firmware_version_ctl = {
3214 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
3215 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
3216 	.name = "",
3217 	.info = scarlett2_firmware_version_ctl_info,
3218 	.get  = scarlett2_firmware_version_ctl_get
3219 };
3220 
scarlett2_add_firmware_version_ctl(struct usb_mixer_interface * mixer)3221 static int scarlett2_add_firmware_version_ctl(
3222 	struct usb_mixer_interface *mixer)
3223 {
3224 	return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl,
3225 				     0, 0, "Firmware Version", NULL);
3226 }
3227 
3228 /*** Minimum Firmware Version Control ***/
3229 
scarlett2_min_firmware_version_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3230 static int scarlett2_min_firmware_version_ctl_get(
3231 	struct snd_kcontrol *kctl,
3232 	struct snd_ctl_elem_value *ucontrol)
3233 {
3234 	struct usb_mixer_elem_info *elem = kctl->private_data;
3235 	struct scarlett2_data *private = elem->head.mixer->private_data;
3236 
3237 	ucontrol->value.integer.value[0] = private->info->min_firmware_version;
3238 
3239 	return 0;
3240 }
3241 
scarlett2_min_firmware_version_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3242 static int scarlett2_min_firmware_version_ctl_info(
3243 	struct snd_kcontrol *kctl,
3244 	struct snd_ctl_elem_info *uinfo)
3245 {
3246 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3247 	uinfo->count = 1;
3248 
3249 	return 0;
3250 }
3251 
3252 static const struct snd_kcontrol_new scarlett2_min_firmware_version_ctl = {
3253 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
3254 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
3255 	.name = "",
3256 	.info = scarlett2_min_firmware_version_ctl_info,
3257 	.get  = scarlett2_min_firmware_version_ctl_get
3258 };
3259 
scarlett2_add_min_firmware_version_ctl(struct usb_mixer_interface * mixer)3260 static int scarlett2_add_min_firmware_version_ctl(
3261 	struct usb_mixer_interface *mixer)
3262 {
3263 	return scarlett2_add_new_ctl(mixer, &scarlett2_min_firmware_version_ctl,
3264 				     0, 0, "Minimum Firmware Version", NULL);
3265 }
3266 
3267 /*** Sync Control ***/
3268 
3269 /* Update sync control after receiving notification that the status
3270  * has changed
3271  */
scarlett2_update_sync(struct usb_mixer_interface * mixer)3272 static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
3273 {
3274 	struct scarlett2_data *private = mixer->private_data;
3275 
3276 	private->sync_updated = 0;
3277 	return scarlett2_usb_get_sync_status(mixer, &private->sync);
3278 }
3279 
scarlett2_sync_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3280 static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,
3281 				   struct snd_ctl_elem_info *uinfo)
3282 {
3283 	static const char *texts[2] = {
3284 		"Unlocked", "Locked"
3285 	};
3286 	return snd_ctl_enum_info(uinfo, 1, 2, texts);
3287 }
3288 
scarlett2_sync_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3289 static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,
3290 				  struct snd_ctl_elem_value *ucontrol)
3291 {
3292 	struct usb_mixer_elem_info *elem = kctl->private_data;
3293 	struct usb_mixer_interface *mixer = elem->head.mixer;
3294 	struct scarlett2_data *private = mixer->private_data;
3295 	int err = 0;
3296 
3297 	mutex_lock(&private->data_mutex);
3298 
3299 	if (private->hwdep_in_use) {
3300 		err = -EBUSY;
3301 		goto unlock;
3302 	}
3303 
3304 	if (private->sync_updated) {
3305 		err = scarlett2_update_sync(mixer);
3306 		if (err < 0)
3307 			goto unlock;
3308 	}
3309 	ucontrol->value.enumerated.item[0] = private->sync;
3310 
3311 unlock:
3312 	mutex_unlock(&private->data_mutex);
3313 	return err;
3314 }
3315 
3316 static const struct snd_kcontrol_new scarlett2_sync_ctl = {
3317 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3318 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
3319 	.name = "",
3320 	.info = scarlett2_sync_ctl_info,
3321 	.get  = scarlett2_sync_ctl_get
3322 };
3323 
scarlett2_add_sync_ctl(struct usb_mixer_interface * mixer)3324 static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
3325 {
3326 	struct scarlett2_data *private = mixer->private_data;
3327 
3328 	/* devices without a mixer also don't support reporting sync status */
3329 	if (!scarlett2_has_mixer(private))
3330 		return 0;
3331 
3332 	return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
3333 				     0, 1, "Sync Status", &private->sync_ctl);
3334 }
3335 
3336 /*** Autogain Switch and Status Controls ***/
3337 
3338 /* Forward declarations as phantom power and autogain can disable each other */
3339 static int scarlett2_check_input_phantom_updated(struct usb_mixer_interface *);
3340 static int scarlett2_phantom_is_switching(struct scarlett2_data *, int);
3341 
3342 /* Set the access mode of a control to read-only (val = 0) or
3343  * read-write (val = 1).
3344  */
scarlett2_set_ctl_access(struct snd_kcontrol * kctl,int val)3345 static void scarlett2_set_ctl_access(struct snd_kcontrol *kctl, int val)
3346 {
3347 	if (val)
3348 		kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
3349 	else
3350 		kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;
3351 }
3352 
3353 /* Check if autogain is running on any input */
scarlett2_autogain_is_running(struct scarlett2_data * private)3354 static int scarlett2_autogain_is_running(struct scarlett2_data *private)
3355 {
3356 	int i;
3357 
3358 	/* autogain_status[] is 0 if autogain is running */
3359 	for (i = 0; i < private->info->gain_input_count; i++)
3360 		if (!private->autogain_status[i])
3361 			return 1;
3362 
3363 	return 0;
3364 }
3365 
scarlett2_update_autogain(struct usb_mixer_interface * mixer)3366 static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)
3367 {
3368 	struct scarlett2_data *private = mixer->private_data;
3369 	const struct scarlett2_device_info *info = private->info;
3370 	int err, i;
3371 	u8 raw_autogain_status[SCARLETT2_INPUT_GAIN_MAX];
3372 	s8 ag_target_values[SCARLETT2_AG_TARGET_COUNT];
3373 
3374 	private->autogain_updated = 0;
3375 
3376 	if (!info->gain_input_count)
3377 		return 0;
3378 
3379 	err = scarlett2_usb_get_config(
3380 		mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
3381 		info->gain_input_count, private->autogain_switch);
3382 	if (err < 0)
3383 		return err;
3384 	err = scarlett2_usb_get_config(
3385 		mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS,
3386 		info->gain_input_count, raw_autogain_status);
3387 	if (err < 0)
3388 		return err;
3389 
3390 	/* Translate autogain_switch and raw_autogain_status into
3391 	 * autogain_status.
3392 	 *
3393 	 * When autogain_switch[] is set, the status is the first
3394 	 * element in scarlett2_autogain_status_texts[] (Running). The
3395 	 * subsequent elements correspond to the status value from the
3396 	 * device (raw_autogain_status[]) + 1. The last element is
3397 	 * "Invalid", in case the device reports a status outside the
3398 	 * range of scarlett2_autogain_status_texts[].
3399 	 */
3400 	for (i = 0; i < info->gain_input_count; i++)
3401 		if (private->autogain_switch[i])
3402 			private->autogain_status[i] = 0;
3403 		else if (raw_autogain_status[i] <
3404 				private->num_autogain_status_texts - 1)
3405 			private->autogain_status[i] =
3406 				raw_autogain_status[i] + 1;
3407 		else
3408 			private->autogain_status[i] =
3409 				private->num_autogain_status_texts - 1;
3410 
3411 
3412 	for (int i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
3413 		if (scarlett2_has_config_item(private,
3414 					      scarlett2_ag_target_configs[i])) {
3415 			err = scarlett2_usb_get_config(
3416 				mixer, scarlett2_ag_target_configs[i],
3417 				1, &ag_target_values[i]);
3418 			if (err < 0)
3419 				return err;
3420 		}
3421 
3422 	/* convert from negative dBFS as used by the device */
3423 	for (int i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
3424 		private->ag_targets[i] = -ag_target_values[i];
3425 
3426 	return 0;
3427 }
3428 
3429 /* Update access mode for controls affected by autogain */
scarlett2_autogain_update_access(struct usb_mixer_interface * mixer)3430 static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)
3431 {
3432 	struct scarlett2_data *private = mixer->private_data;
3433 	const struct scarlett2_device_info *info = private->info;
3434 	int val = !scarlett2_autogain_is_running(private);
3435 	int i;
3436 
3437 	if (scarlett2_has_config_item(private,
3438 				      SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))
3439 		scarlett2_set_ctl_access(private->input_select_ctl, val);
3440 	if (scarlett2_has_config_item(private,
3441 				      SCARLETT2_CONFIG_INPUT_LINK_SWITCH))
3442 		for (i = 0; i < info->gain_input_count / 2; i++)
3443 			scarlett2_set_ctl_access(private->input_link_ctls[i],
3444 						 val);
3445 	for (i = 0; i < info->gain_input_count; i++)
3446 		scarlett2_set_ctl_access(private->input_gain_ctls[i], val);
3447 	for (i = 0; i < info->safe_input_count; i++)
3448 		scarlett2_set_ctl_access(private->safe_ctls[i], val);
3449 	for (i = 0; i < info->level_input_count; i++)
3450 		scarlett2_set_ctl_access(private->level_ctls[i], val);
3451 	for (i = 0; i < info->air_input_count; i++)
3452 		scarlett2_set_ctl_access(private->air_ctls[i], val);
3453 	for (i = 0; i < info->mute_input_count; i++)
3454 		scarlett2_set_ctl_access(private->input_mute_ctls[i], val);
3455 	for (i = 0; i < info->phantom_count; i++)
3456 		scarlett2_set_ctl_access(private->phantom_ctls[i], val);
3457 	for (i = 0; i < info->dsp_input_count; i++)
3458 		scarlett2_set_ctl_access(private->dsp_ctls[i], val);
3459 
3460 	for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
3461 		if (scarlett2_has_config_item(private,
3462 					      scarlett2_ag_target_configs[i]))
3463 			scarlett2_set_ctl_access(
3464 				private->ag_target_ctls[i], val);
3465 }
3466 
3467 /* Notify of access mode change for all controls read-only while
3468  * autogain runs.
3469  */
scarlett2_autogain_notify_access(struct usb_mixer_interface * mixer)3470 static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer)
3471 {
3472 	struct snd_card *card = mixer->chip->card;
3473 	struct scarlett2_data *private = mixer->private_data;
3474 	const struct scarlett2_device_info *info = private->info;
3475 	int i;
3476 
3477 	if (scarlett2_has_config_item(private,
3478 				      SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))
3479 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3480 			       &private->input_select_ctl->id);
3481 	if (scarlett2_has_config_item(private,
3482 				      SCARLETT2_CONFIG_INPUT_LINK_SWITCH))
3483 		for (i = 0; i < info->gain_input_count / 2; i++)
3484 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3485 				       &private->input_link_ctls[i]->id);
3486 	for (i = 0; i < info->gain_input_count; i++)
3487 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3488 			       &private->input_gain_ctls[i]->id);
3489 	for (i = 0; i < info->safe_input_count; i++)
3490 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3491 			       &private->safe_ctls[i]->id);
3492 	for (i = 0; i < info->level_input_count; i++)
3493 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3494 			       &private->level_ctls[i]->id);
3495 	for (i = 0; i < info->air_input_count; i++)
3496 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3497 			       &private->air_ctls[i]->id);
3498 	for (i = 0; i < info->dsp_input_count; i++)
3499 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3500 			       &private->dsp_ctls[i]->id);
3501 	for (i = 0; i < info->mute_input_count; i++)
3502 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3503 			       &private->input_mute_ctls[i]->id);
3504 	for (i = 0; i < info->phantom_count; i++)
3505 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3506 			       &private->phantom_ctls[i]->id);
3507 
3508 	for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
3509 		if (scarlett2_has_config_item(private,
3510 					      scarlett2_ag_target_configs[i]))
3511 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
3512 				       &private->ag_target_ctls[i]->id);
3513 }
3514 
3515 /* Call scarlett2_update_autogain() and
3516  * scarlett2_autogain_update_access() if autogain_updated is set.
3517  */
scarlett2_check_autogain_updated(struct usb_mixer_interface * mixer)3518 static int scarlett2_check_autogain_updated(
3519 	struct usb_mixer_interface *mixer)
3520 {
3521 	struct scarlett2_data *private = mixer->private_data;
3522 	int err;
3523 
3524 	if (!private->autogain_updated)
3525 		return 0;
3526 
3527 	err = scarlett2_update_autogain(mixer);
3528 	if (err < 0)
3529 		return err;
3530 
3531 	scarlett2_autogain_update_access(mixer);
3532 
3533 	return 0;
3534 }
3535 
3536 /* If autogain_updated is set when a *_ctl_put() function for a
3537  * control that is meant to be read-only while autogain is running,
3538  * update the autogain status and access mode of affected controls.
3539  * Return -EPERM if autogain is running.
3540  */
scarlett2_check_put_during_autogain(struct usb_mixer_interface * mixer)3541 static int scarlett2_check_put_during_autogain(
3542 	struct usb_mixer_interface *mixer)
3543 {
3544 	int err = scarlett2_check_autogain_updated(mixer);
3545 
3546 	if (err < 0)
3547 		return err;
3548 
3549 	if (scarlett2_autogain_is_running(mixer->private_data))
3550 		return -EPERM;
3551 
3552 	return 0;
3553 }
3554 
scarlett2_autogain_switch_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3555 static int scarlett2_autogain_switch_ctl_info(
3556 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3557 {
3558 	struct usb_mixer_elem_info *elem = kctl->private_data;
3559 	struct usb_mixer_interface *mixer = elem->head.mixer;
3560 	struct scarlett2_data *private = mixer->private_data;
3561 	int err;
3562 
3563 	mutex_lock(&private->data_mutex);
3564 
3565 	err = scarlett2_check_input_phantom_updated(mixer);
3566 	if (err < 0)
3567 		goto unlock;
3568 
3569 	err = snd_ctl_boolean_mono_info(kctl, uinfo);
3570 
3571 unlock:
3572 	mutex_unlock(&private->data_mutex);
3573 	return err;
3574 }
3575 
scarlett2_autogain_switch_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3576 static int scarlett2_autogain_switch_ctl_get(
3577 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3578 {
3579 	struct usb_mixer_elem_info *elem = kctl->private_data;
3580 	struct usb_mixer_interface *mixer = elem->head.mixer;
3581 	struct scarlett2_data *private = mixer->private_data;
3582 	int err;
3583 
3584 	mutex_lock(&private->data_mutex);
3585 
3586 	if (private->hwdep_in_use) {
3587 		err = -EBUSY;
3588 		goto unlock;
3589 	}
3590 
3591 	err = scarlett2_check_autogain_updated(mixer);
3592 	if (err < 0)
3593 		goto unlock;
3594 
3595 	ucontrol->value.enumerated.item[0] =
3596 		private->autogain_switch[elem->control];
3597 
3598 unlock:
3599 	mutex_unlock(&private->data_mutex);
3600 	return err;
3601 }
3602 
scarlett2_autogain_status_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3603 static int scarlett2_autogain_status_ctl_get(
3604 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3605 {
3606 	struct usb_mixer_elem_info *elem = kctl->private_data;
3607 	struct usb_mixer_interface *mixer = elem->head.mixer;
3608 	struct scarlett2_data *private = mixer->private_data;
3609 	int err;
3610 
3611 	mutex_lock(&private->data_mutex);
3612 
3613 	if (private->hwdep_in_use) {
3614 		err = -EBUSY;
3615 		goto unlock;
3616 	}
3617 
3618 	err = scarlett2_check_autogain_updated(mixer);
3619 	if (err < 0)
3620 		goto unlock;
3621 
3622 	ucontrol->value.enumerated.item[0] =
3623 		private->autogain_status[elem->control];
3624 
3625 unlock:
3626 	mutex_unlock(&private->data_mutex);
3627 	return err;
3628 }
3629 
scarlett2_autogain_switch_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3630 static int scarlett2_autogain_switch_ctl_put(
3631 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3632 {
3633 	struct usb_mixer_elem_info *elem = kctl->private_data;
3634 	struct usb_mixer_interface *mixer = elem->head.mixer;
3635 	struct scarlett2_data *private = mixer->private_data;
3636 
3637 	int index = elem->control;
3638 	int oval, val, err;
3639 
3640 	mutex_lock(&private->data_mutex);
3641 
3642 	if (private->hwdep_in_use) {
3643 		err = -EBUSY;
3644 		goto unlock;
3645 	}
3646 
3647 	err = scarlett2_check_input_phantom_updated(mixer);
3648 	if (err < 0)
3649 		goto unlock;
3650 
3651 	if (scarlett2_phantom_is_switching(private, index)) {
3652 		err = -EPERM;
3653 		goto unlock;
3654 	}
3655 
3656 	oval = private->autogain_switch[index];
3657 	val = !!ucontrol->value.integer.value[0];
3658 
3659 	if (oval == val)
3660 		goto unlock;
3661 
3662 	private->autogain_switch[index] = val;
3663 
3664 	/* Send switch change to the device */
3665 	err = scarlett2_usb_set_config(
3666 		mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val);
3667 	if (err == 0)
3668 		err = 1;
3669 
3670 	scarlett2_autogain_update_access(mixer);
3671 	scarlett2_autogain_notify_access(mixer);
3672 
3673 unlock:
3674 	mutex_unlock(&private->data_mutex);
3675 	return err;
3676 }
3677 
scarlett2_autogain_status_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3678 static int scarlett2_autogain_status_ctl_info(
3679 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3680 {
3681 	struct usb_mixer_elem_info *elem = kctl->private_data;
3682 	struct scarlett2_data *private = elem->head.mixer->private_data;
3683 
3684 	return snd_ctl_enum_info(
3685 		uinfo, 1,
3686 		private->num_autogain_status_texts,
3687 		private->config_set->autogain_status_texts);
3688 }
3689 
3690 static const struct snd_kcontrol_new scarlett2_autogain_switch_ctl = {
3691 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3692 	.name = "",
3693 	.info = scarlett2_autogain_switch_ctl_info,
3694 	.get  = scarlett2_autogain_switch_ctl_get,
3695 	.put  = scarlett2_autogain_switch_ctl_put
3696 };
3697 
3698 static const struct snd_kcontrol_new scarlett2_autogain_status_ctl = {
3699 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3700 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
3701 	.name = "",
3702 	.info = scarlett2_autogain_status_ctl_info,
3703 	.get  = scarlett2_autogain_status_ctl_get,
3704 };
3705 
3706 /*** Autogain Target Controls ***/
3707 
scarlett2_ag_target_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3708 static int scarlett2_ag_target_ctl_info(
3709 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3710 {
3711 	struct usb_mixer_elem_info *elem = kctl->private_data;
3712 	struct usb_mixer_interface *mixer = elem->head.mixer;
3713 	struct scarlett2_data *private = mixer->private_data;
3714 	int err;
3715 
3716 	mutex_lock(&private->data_mutex);
3717 
3718 	if (private->hwdep_in_use) {
3719 		err = -EBUSY;
3720 		goto unlock;
3721 	}
3722 
3723 	err = scarlett2_check_autogain_updated(mixer);
3724 	if (err < 0)
3725 		goto unlock;
3726 
3727 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3728 	uinfo->count = 1;
3729 	uinfo->value.integer.min = SCARLETT2_AG_TARGET_MIN;
3730 	uinfo->value.integer.max = 0;
3731 	uinfo->value.integer.step = 1;
3732 
3733 unlock:
3734 	mutex_unlock(&private->data_mutex);
3735 	return err;
3736 }
3737 
scarlett2_ag_target_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3738 static int scarlett2_ag_target_ctl_get(
3739 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3740 {
3741 	struct usb_mixer_elem_info *elem = kctl->private_data;
3742 	struct usb_mixer_interface *mixer = elem->head.mixer;
3743 	struct scarlett2_data *private = mixer->private_data;
3744 	int err = 0;
3745 
3746 	mutex_lock(&private->data_mutex);
3747 
3748 	if (private->hwdep_in_use) {
3749 		err = -EBUSY;
3750 		goto unlock;
3751 	}
3752 
3753 	if (private->autogain_updated) {
3754 		err = scarlett2_update_autogain(mixer);
3755 		if (err < 0)
3756 			goto unlock;
3757 	}
3758 
3759 	ucontrol->value.integer.value[0] = private->ag_targets[elem->control];
3760 
3761 unlock:
3762 	mutex_unlock(&private->data_mutex);
3763 	return err;
3764 }
3765 
scarlett2_ag_target_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3766 static int scarlett2_ag_target_ctl_put(
3767 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3768 {
3769 	struct usb_mixer_elem_info *elem = kctl->private_data;
3770 	struct usb_mixer_interface *mixer = elem->head.mixer;
3771 	struct scarlett2_data *private = mixer->private_data;
3772 
3773 	int index = elem->control;
3774 	int oval, val, err;
3775 
3776 	mutex_lock(&private->data_mutex);
3777 
3778 	if (private->hwdep_in_use) {
3779 		err = -EBUSY;
3780 		goto unlock;
3781 	}
3782 
3783 	err = scarlett2_check_put_during_autogain(mixer);
3784 	if (err < 0)
3785 		goto unlock;
3786 
3787 	oval = private->ag_targets[index];
3788 	val = clamp(ucontrol->value.integer.value[0],
3789 		    (long)SCARLETT2_AG_TARGET_MIN, 0L);
3790 
3791 	if (oval == val)
3792 		goto unlock;
3793 
3794 	private->ag_targets[index] = val;
3795 
3796 	/* Send new value to the device */
3797 	err = scarlett2_usb_set_config(
3798 		mixer, scarlett2_ag_target_configs[index], 1, -val);
3799 	if (err == 0)
3800 		err = 1;
3801 
3802 unlock:
3803 	mutex_unlock(&private->data_mutex);
3804 	return err;
3805 }
3806 
3807 static const DECLARE_TLV_DB_MINMAX(
3808 	db_scale_ag_target, SCARLETT2_AG_TARGET_MIN * 100, 0
3809 );
3810 
3811 static const struct snd_kcontrol_new scarlett2_ag_target_ctl = {
3812 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
3813 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3814 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3815 	.name = "",
3816 	.info = scarlett2_ag_target_ctl_info,
3817 	.get  = scarlett2_ag_target_ctl_get,
3818 	.put  = scarlett2_ag_target_ctl_put,
3819 	.tlv = { .p = db_scale_ag_target }
3820 };
3821 
3822 /*** Input Select Control ***/
3823 
scarlett2_update_input_select(struct usb_mixer_interface * mixer)3824 static int scarlett2_update_input_select(struct usb_mixer_interface *mixer)
3825 {
3826 	struct scarlett2_data *private = mixer->private_data;
3827 	const struct scarlett2_device_info *info = private->info;
3828 	int link_count = info->gain_input_count / 2;
3829 	int err;
3830 
3831 	private->input_select_updated = 0;
3832 
3833 	if (!scarlett2_has_config_item(private,
3834 				       SCARLETT2_CONFIG_INPUT_SELECT_SWITCH) ||
3835 	    !link_count)
3836 		return 0;
3837 
3838 	err = scarlett2_usb_get_config(
3839 		mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3840 		1, &private->input_select_switch);
3841 	if (err < 0)
3842 		return err;
3843 
3844 	err = scarlett2_usb_get_config(
3845 		mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
3846 		link_count, private->input_link_switch);
3847 	if (err < 0)
3848 		return err;
3849 
3850 	/* simplified because no model yet has link_count > 1 */
3851 	if (private->input_link_switch[0])
3852 		private->input_select_switch = 0;
3853 
3854 	return 0;
3855 }
3856 
scarlett2_input_select_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3857 static int scarlett2_input_select_ctl_get(
3858 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3859 {
3860 	struct usb_mixer_elem_info *elem = kctl->private_data;
3861 	struct usb_mixer_interface *mixer = elem->head.mixer;
3862 	struct scarlett2_data *private = mixer->private_data;
3863 	int err = 0;
3864 
3865 	mutex_lock(&private->data_mutex);
3866 
3867 	if (private->hwdep_in_use) {
3868 		err = -EBUSY;
3869 		goto unlock;
3870 	}
3871 
3872 	if (private->input_select_updated) {
3873 		err = scarlett2_update_input_select(mixer);
3874 		if (err < 0)
3875 			goto unlock;
3876 	}
3877 	ucontrol->value.enumerated.item[0] = private->input_select_switch;
3878 
3879 unlock:
3880 	mutex_unlock(&private->data_mutex);
3881 	return err;
3882 }
3883 
scarlett2_input_select_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)3884 static int scarlett2_input_select_ctl_put(
3885 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3886 {
3887 	struct usb_mixer_elem_info *elem = kctl->private_data;
3888 	struct usb_mixer_interface *mixer = elem->head.mixer;
3889 	struct scarlett2_data *private = mixer->private_data;
3890 
3891 	int oval, val, err;
3892 	int max_val = private->input_link_switch[0] ? 0 : 1;
3893 
3894 	mutex_lock(&private->data_mutex);
3895 
3896 	if (private->hwdep_in_use) {
3897 		err = -EBUSY;
3898 		goto unlock;
3899 	}
3900 
3901 	err = scarlett2_check_put_during_autogain(mixer);
3902 	if (err < 0)
3903 		goto unlock;
3904 
3905 	oval = private->input_select_switch;
3906 	val = ucontrol->value.integer.value[0];
3907 
3908 	if (val < 0)
3909 		val = 0;
3910 	else if (val > max_val)
3911 		val = max_val;
3912 
3913 	if (oval == val)
3914 		goto unlock;
3915 
3916 	private->input_select_switch = val;
3917 
3918 	/* Send switch change to the device if inputs not linked */
3919 	if (!private->input_link_switch[0])
3920 		err = scarlett2_usb_set_config(
3921 			mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3922 			1, val);
3923 	if (err == 0)
3924 		err = 1;
3925 
3926 unlock:
3927 	mutex_unlock(&private->data_mutex);
3928 	return err;
3929 }
3930 
scarlett2_input_select_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3931 static int scarlett2_input_select_ctl_info(
3932 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3933 {
3934 	struct usb_mixer_elem_info *elem = kctl->private_data;
3935 	struct usb_mixer_interface *mixer = elem->head.mixer;
3936 	struct scarlett2_data *private = mixer->private_data;
3937 
3938 	int inputs = private->info->gain_input_count;
3939 	int i, j;
3940 	int err;
3941 	char **values = kcalloc(inputs, sizeof(char *), GFP_KERNEL);
3942 
3943 	if (!values)
3944 		return -ENOMEM;
3945 
3946 	mutex_lock(&private->data_mutex);
3947 
3948 	if (private->hwdep_in_use) {
3949 		err = -EBUSY;
3950 		goto unlock;
3951 	}
3952 
3953 	err = scarlett2_check_autogain_updated(mixer);
3954 	if (err < 0)
3955 		goto unlock;
3956 
3957 	/* Loop through each input
3958 	 * Linked inputs have one value for the pair
3959 	 */
3960 	for (i = 0, j = 0; i < inputs; i++) {
3961 		if (private->input_link_switch[i / 2]) {
3962 			values[j++] = kasprintf(
3963 				GFP_KERNEL, "Input %d-%d", i + 1, i + 2);
3964 			i++;
3965 		} else {
3966 			values[j++] = kasprintf(
3967 				GFP_KERNEL, "Input %d", i + 1);
3968 		}
3969 	}
3970 
3971 	err = snd_ctl_enum_info(uinfo, 1, j,
3972 				(const char * const *)values);
3973 
3974 unlock:
3975 	mutex_unlock(&private->data_mutex);
3976 
3977 	for (i = 0; i < inputs; i++)
3978 		kfree(values[i]);
3979 	kfree(values);
3980 
3981 	return err;
3982 }
3983 
3984 static const struct snd_kcontrol_new scarlett2_input_select_ctl = {
3985 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3986 	.name = "",
3987 	.info = scarlett2_input_select_ctl_info,
3988 	.get  = scarlett2_input_select_ctl_get,
3989 	.put  = scarlett2_input_select_ctl_put,
3990 };
3991 
3992 /*** Input Link Switch Controls ***/
3993 
3994 /* snd_ctl_boolean_mono_info() with autogain-updated check
3995  * (for controls that are read-only while autogain is running)
3996  */
scarlett2_autogain_disables_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)3997 static int scarlett2_autogain_disables_ctl_info(struct snd_kcontrol *kctl,
3998 						struct snd_ctl_elem_info *uinfo)
3999 {
4000 	struct usb_mixer_elem_info *elem = kctl->private_data;
4001 	struct usb_mixer_interface *mixer = elem->head.mixer;
4002 	struct scarlett2_data *private = mixer->private_data;
4003 	int err;
4004 
4005 	mutex_lock(&private->data_mutex);
4006 
4007 	if (private->hwdep_in_use) {
4008 		err = -EBUSY;
4009 		goto unlock;
4010 	}
4011 
4012 	err = scarlett2_check_autogain_updated(mixer);
4013 	if (err < 0)
4014 		goto unlock;
4015 
4016 	err = snd_ctl_boolean_mono_info(kctl, uinfo);
4017 
4018 unlock:
4019 	mutex_unlock(&private->data_mutex);
4020 	return err;
4021 }
4022 
scarlett2_input_link_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4023 static int scarlett2_input_link_ctl_get(
4024 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4025 {
4026 	struct usb_mixer_elem_info *elem = kctl->private_data;
4027 	struct usb_mixer_interface *mixer = elem->head.mixer;
4028 	struct scarlett2_data *private = mixer->private_data;
4029 	int err = 0;
4030 
4031 	mutex_lock(&private->data_mutex);
4032 
4033 	if (private->hwdep_in_use) {
4034 		err = -EBUSY;
4035 		goto unlock;
4036 	}
4037 
4038 	if (private->input_select_updated) {
4039 		err = scarlett2_update_input_select(mixer);
4040 		if (err < 0)
4041 			goto unlock;
4042 	}
4043 	ucontrol->value.enumerated.item[0] =
4044 		private->input_link_switch[elem->control];
4045 
4046 unlock:
4047 	mutex_unlock(&private->data_mutex);
4048 	return err;
4049 }
4050 
scarlett2_input_link_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4051 static int scarlett2_input_link_ctl_put(
4052 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4053 {
4054 	struct usb_mixer_elem_info *elem = kctl->private_data;
4055 	struct usb_mixer_interface *mixer = elem->head.mixer;
4056 	struct scarlett2_data *private = mixer->private_data;
4057 
4058 	int index = elem->control;
4059 	int oval, val, err;
4060 
4061 	mutex_lock(&private->data_mutex);
4062 
4063 	if (private->hwdep_in_use) {
4064 		err = -EBUSY;
4065 		goto unlock;
4066 	}
4067 
4068 	err = scarlett2_check_put_during_autogain(mixer);
4069 	if (err < 0)
4070 		goto unlock;
4071 
4072 	oval = private->input_link_switch[index];
4073 	val = !!ucontrol->value.integer.value[0];
4074 
4075 	if (oval == val)
4076 		goto unlock;
4077 
4078 	private->input_link_switch[index] = val;
4079 
4080 	/* Notify of change in input select options available */
4081 	snd_ctl_notify(mixer->chip->card,
4082 		       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
4083 		       &private->input_select_ctl->id);
4084 	private->input_select_updated = 1;
4085 
4086 	/* Send switch change to the device
4087 	 * Link for channels 1-2 is at index 1
4088 	 * No device yet has more than 2 channels linked
4089 	 */
4090 	err = scarlett2_usb_set_config(
4091 		mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index + 1, val);
4092 	if (err == 0)
4093 		err = 1;
4094 
4095 unlock:
4096 	mutex_unlock(&private->data_mutex);
4097 	return err;
4098 }
4099 
4100 static const struct snd_kcontrol_new scarlett2_input_link_ctl = {
4101 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4102 	.name = "",
4103 	.info = scarlett2_autogain_disables_ctl_info,
4104 	.get  = scarlett2_input_link_ctl_get,
4105 	.put  = scarlett2_input_link_ctl_put
4106 };
4107 
4108 /*** Input Gain Controls ***/
4109 
scarlett2_update_input_gain(struct usb_mixer_interface * mixer)4110 static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer)
4111 {
4112 	struct scarlett2_data *private = mixer->private_data;
4113 	const struct scarlett2_device_info *info = private->info;
4114 
4115 	private->input_gain_updated = 0;
4116 
4117 	if (!info->gain_input_count)
4118 		return 0;
4119 
4120 	return scarlett2_usb_get_config(
4121 		mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4122 		info->gain_input_count, private->gain);
4123 }
4124 
scarlett2_input_gain_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)4125 static int scarlett2_input_gain_ctl_info(struct snd_kcontrol *kctl,
4126 					 struct snd_ctl_elem_info *uinfo)
4127 {
4128 	struct usb_mixer_elem_info *elem = kctl->private_data;
4129 	struct usb_mixer_interface *mixer = elem->head.mixer;
4130 	struct scarlett2_data *private = mixer->private_data;
4131 	int err;
4132 
4133 	mutex_lock(&private->data_mutex);
4134 
4135 	if (private->hwdep_in_use) {
4136 		err = -EBUSY;
4137 		goto unlock;
4138 	}
4139 
4140 	err = scarlett2_check_autogain_updated(mixer);
4141 	if (err < 0)
4142 		goto unlock;
4143 
4144 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4145 	uinfo->count = elem->channels;
4146 	uinfo->value.integer.min = 0;
4147 	uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;
4148 	uinfo->value.integer.step = 1;
4149 
4150 unlock:
4151 	mutex_unlock(&private->data_mutex);
4152 	return err;
4153 }
4154 
scarlett2_input_gain_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4155 static int scarlett2_input_gain_ctl_get(struct snd_kcontrol *kctl,
4156 					struct snd_ctl_elem_value *ucontrol)
4157 {
4158 	struct usb_mixer_elem_info *elem = kctl->private_data;
4159 	struct usb_mixer_interface *mixer = elem->head.mixer;
4160 	struct scarlett2_data *private = mixer->private_data;
4161 	int err = 0;
4162 
4163 	mutex_lock(&private->data_mutex);
4164 
4165 	if (private->hwdep_in_use) {
4166 		err = -EBUSY;
4167 		goto unlock;
4168 	}
4169 
4170 	if (private->input_gain_updated) {
4171 		err = scarlett2_update_input_gain(mixer);
4172 		if (err < 0)
4173 			goto unlock;
4174 	}
4175 	ucontrol->value.integer.value[0] =
4176 		private->gain[elem->control];
4177 
4178 unlock:
4179 	mutex_unlock(&private->data_mutex);
4180 	return err;
4181 }
4182 
scarlett2_input_gain_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4183 static int scarlett2_input_gain_ctl_put(struct snd_kcontrol *kctl,
4184 					struct snd_ctl_elem_value *ucontrol)
4185 {
4186 	struct usb_mixer_elem_info *elem = kctl->private_data;
4187 	struct usb_mixer_interface *mixer = elem->head.mixer;
4188 	struct scarlett2_data *private = mixer->private_data;
4189 
4190 	int index = elem->control;
4191 	int oval, val, err;
4192 
4193 	mutex_lock(&private->data_mutex);
4194 
4195 	if (private->hwdep_in_use) {
4196 		err = -EBUSY;
4197 		goto unlock;
4198 	}
4199 
4200 	err = scarlett2_check_put_during_autogain(mixer);
4201 	if (err < 0)
4202 		goto unlock;
4203 
4204 	oval = private->gain[index];
4205 	val = ucontrol->value.integer.value[0];
4206 
4207 	if (oval == val)
4208 		goto unlock;
4209 
4210 	private->gain[index] = val;
4211 
4212 	/* Send gain change to the device */
4213 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4214 				       index, val);
4215 	if (err == 0)
4216 		err = 1;
4217 
4218 unlock:
4219 	mutex_unlock(&private->data_mutex);
4220 	return err;
4221 }
4222 
4223 static const struct snd_kcontrol_new scarlett2_input_gain_ctl = {
4224 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4225 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
4226 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
4227 	.name = "",
4228 	.info = scarlett2_input_gain_ctl_info,
4229 	.get  = scarlett2_input_gain_ctl_get,
4230 	.put  = scarlett2_input_gain_ctl_put,
4231 	.private_value = 0, /* max value */
4232 };
4233 
4234 /*** Safe Controls ***/
4235 
scarlett2_update_input_safe(struct usb_mixer_interface * mixer)4236 static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer)
4237 {
4238 	struct scarlett2_data *private = mixer->private_data;
4239 	const struct scarlett2_device_info *info = private->info;
4240 
4241 	private->input_safe_updated = 0;
4242 
4243 	if (!info->safe_input_count)
4244 		return 0;
4245 
4246 	return scarlett2_usb_get_config(
4247 		mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4248 		info->safe_input_count, private->safe_switch);
4249 }
4250 
scarlett2_safe_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4251 static int scarlett2_safe_ctl_get(struct snd_kcontrol *kctl,
4252 				  struct snd_ctl_elem_value *ucontrol)
4253 {
4254 	struct usb_mixer_elem_info *elem = kctl->private_data;
4255 	struct usb_mixer_interface *mixer = elem->head.mixer;
4256 	struct scarlett2_data *private = mixer->private_data;
4257 	int err = 0;
4258 
4259 	mutex_lock(&private->data_mutex);
4260 
4261 	if (private->hwdep_in_use) {
4262 		err = -EBUSY;
4263 		goto unlock;
4264 	}
4265 
4266 	if (private->input_safe_updated) {
4267 		err = scarlett2_update_input_safe(mixer);
4268 		if (err < 0)
4269 			goto unlock;
4270 	}
4271 	ucontrol->value.integer.value[0] =
4272 		private->safe_switch[elem->control];
4273 
4274 unlock:
4275 	mutex_unlock(&private->data_mutex);
4276 	return err;
4277 }
4278 
scarlett2_safe_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4279 static int scarlett2_safe_ctl_put(struct snd_kcontrol *kctl,
4280 				  struct snd_ctl_elem_value *ucontrol)
4281 {
4282 	struct usb_mixer_elem_info *elem = kctl->private_data;
4283 	struct usb_mixer_interface *mixer = elem->head.mixer;
4284 	struct scarlett2_data *private = mixer->private_data;
4285 
4286 	int index = elem->control;
4287 	int oval, val, err;
4288 
4289 	mutex_lock(&private->data_mutex);
4290 
4291 	if (private->hwdep_in_use) {
4292 		err = -EBUSY;
4293 		goto unlock;
4294 	}
4295 
4296 	err = scarlett2_check_put_during_autogain(mixer);
4297 	if (err < 0)
4298 		goto unlock;
4299 
4300 	oval = private->safe_switch[index];
4301 	val = !!ucontrol->value.integer.value[0];
4302 
4303 	if (oval == val)
4304 		goto unlock;
4305 
4306 	private->safe_switch[index] = val;
4307 
4308 	/* Send switch change to the device */
4309 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4310 				       index, val);
4311 	if (err == 0)
4312 		err = 1;
4313 
4314 unlock:
4315 	mutex_unlock(&private->data_mutex);
4316 	return err;
4317 }
4318 
4319 static const struct snd_kcontrol_new scarlett2_safe_ctl = {
4320 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4321 	.name = "",
4322 	.info = scarlett2_autogain_disables_ctl_info,
4323 	.get  = scarlett2_safe_ctl_get,
4324 	.put  = scarlett2_safe_ctl_put,
4325 };
4326 
4327 /*** PCM Input Control ***/
4328 
scarlett2_update_pcm_input_switch(struct usb_mixer_interface * mixer)4329 static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer)
4330 {
4331 	struct scarlett2_data *private = mixer->private_data;
4332 	int err;
4333 
4334 	private->pcm_input_switch_updated = 0;
4335 
4336 	err = scarlett2_usb_get_config(
4337 		mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4338 		1, &private->pcm_input_switch);
4339 	if (err < 0)
4340 		return err;
4341 
4342 	return 0;
4343 }
4344 
scarlett2_pcm_input_switch_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4345 static int scarlett2_pcm_input_switch_ctl_get(
4346 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4347 {
4348 	struct usb_mixer_elem_info *elem = kctl->private_data;
4349 	struct usb_mixer_interface *mixer = elem->head.mixer;
4350 	struct scarlett2_data *private = elem->head.mixer->private_data;
4351 	int err = 0;
4352 
4353 	mutex_lock(&private->data_mutex);
4354 
4355 	if (private->pcm_input_switch_updated) {
4356 		err = scarlett2_update_pcm_input_switch(mixer);
4357 		if (err < 0)
4358 			goto unlock;
4359 	}
4360 	ucontrol->value.enumerated.item[0] = private->pcm_input_switch;
4361 
4362 unlock:
4363 	mutex_unlock(&private->data_mutex);
4364 	return err;
4365 }
4366 
scarlett2_pcm_input_switch_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4367 static int scarlett2_pcm_input_switch_ctl_put(
4368 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4369 {
4370 	struct usb_mixer_elem_info *elem = kctl->private_data;
4371 	struct usb_mixer_interface *mixer = elem->head.mixer;
4372 	struct scarlett2_data *private = mixer->private_data;
4373 
4374 	int oval, val, err = 0;
4375 
4376 	mutex_lock(&private->data_mutex);
4377 
4378 	if (private->hwdep_in_use) {
4379 		err = -EBUSY;
4380 		goto unlock;
4381 	}
4382 
4383 	oval = private->pcm_input_switch;
4384 	val = !!ucontrol->value.integer.value[0];
4385 
4386 	if (oval == val)
4387 		goto unlock;
4388 
4389 	private->pcm_input_switch = val;
4390 
4391 	/* Send switch change to the device */
4392 	err = scarlett2_usb_set_config(
4393 		mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4394 		0, val);
4395 	if (err == 0)
4396 		err = 1;
4397 
4398 unlock:
4399 	mutex_unlock(&private->data_mutex);
4400 	return err;
4401 }
4402 
scarlett2_pcm_input_switch_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)4403 static int scarlett2_pcm_input_switch_ctl_info(
4404 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
4405 {
4406 	static const char *const values[2] = {
4407 		"Direct", "Mixer"
4408 	};
4409 
4410 	return snd_ctl_enum_info(
4411 		uinfo, 1, 2, values);
4412 }
4413 
4414 static const struct snd_kcontrol_new scarlett2_pcm_input_switch_ctl = {
4415 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4416 	.name = "",
4417 	.info = scarlett2_pcm_input_switch_ctl_info,
4418 	.get  = scarlett2_pcm_input_switch_ctl_get,
4419 	.put  = scarlett2_pcm_input_switch_ctl_put
4420 };
4421 
4422 /*** Analogue Line Out Volume Controls ***/
4423 
4424 /* Update hardware volume controls after receiving notification that
4425  * they have changed
4426  */
scarlett2_update_volumes(struct usb_mixer_interface * mixer)4427 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
4428 {
4429 	struct scarlett2_data *private = mixer->private_data;
4430 	s16 vol;
4431 	int err, i;
4432 
4433 	private->vol_updated = 0;
4434 
4435 	if (scarlett2_has_config_item(private,
4436 				      SCARLETT2_CONFIG_MASTER_VOLUME)) {
4437 		err = scarlett2_usb_get_config(
4438 			mixer, SCARLETT2_CONFIG_MASTER_VOLUME,
4439 			1, &vol);
4440 		if (err < 0)
4441 			return err;
4442 
4443 		private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4444 					    0, SCARLETT2_VOLUME_BIAS);
4445 
4446 		if (scarlett2_has_config_item(private,
4447 					      SCARLETT2_CONFIG_SW_HW_SWITCH))
4448 			for (i = 0; i < private->num_line_out; i++)
4449 				if (private->vol_sw_hw_switch[i])
4450 					private->vol[i] = private->master_vol;
4451 	}
4452 
4453 	if (scarlett2_has_config_item(private,
4454 				      SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {
4455 		err = scarlett2_usb_get_config(
4456 			mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME,
4457 			1, &vol);
4458 		if (err < 0)
4459 			return err;
4460 
4461 		private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4462 					       0, SCARLETT2_VOLUME_BIAS);
4463 	}
4464 
4465 	return 0;
4466 }
4467 
scarlett2_volume_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)4468 static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
4469 				     struct snd_ctl_elem_info *uinfo)
4470 {
4471 	struct usb_mixer_elem_info *elem = kctl->private_data;
4472 
4473 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4474 	uinfo->count = elem->channels;
4475 	uinfo->value.integer.min = 0;
4476 	uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
4477 	uinfo->value.integer.step = 1;
4478 	return 0;
4479 }
4480 
scarlett2_master_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4481 static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
4482 					   struct snd_ctl_elem_value *ucontrol)
4483 {
4484 	struct usb_mixer_elem_info *elem = kctl->private_data;
4485 	struct usb_mixer_interface *mixer = elem->head.mixer;
4486 	struct scarlett2_data *private = mixer->private_data;
4487 	int err = 0;
4488 
4489 	mutex_lock(&private->data_mutex);
4490 
4491 	if (private->hwdep_in_use) {
4492 		err = -EBUSY;
4493 		goto unlock;
4494 	}
4495 
4496 	if (private->vol_updated) {
4497 		err = scarlett2_update_volumes(mixer);
4498 		if (err < 0)
4499 			goto unlock;
4500 	}
4501 	ucontrol->value.integer.value[0] = private->master_vol;
4502 
4503 unlock:
4504 	mutex_unlock(&private->data_mutex);
4505 	return err;
4506 }
4507 
scarlett2_headphone_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4508 static int scarlett2_headphone_volume_ctl_get(
4509 	struct snd_kcontrol *kctl,
4510 	struct snd_ctl_elem_value *ucontrol)
4511 {
4512 	struct usb_mixer_elem_info *elem = kctl->private_data;
4513 	struct usb_mixer_interface *mixer = elem->head.mixer;
4514 	struct scarlett2_data *private = mixer->private_data;
4515 	int err = 0;
4516 
4517 	mutex_lock(&private->data_mutex);
4518 
4519 	if (private->hwdep_in_use) {
4520 		err = -EBUSY;
4521 		goto unlock;
4522 	}
4523 
4524 	if (private->vol_updated) {
4525 		err = scarlett2_update_volumes(mixer);
4526 		if (err < 0)
4527 			goto unlock;
4528 	}
4529 	ucontrol->value.integer.value[0] = private->headphone_vol;
4530 
4531 unlock:
4532 	mutex_unlock(&private->data_mutex);
4533 	return err;
4534 }
4535 
line_out_remap(struct scarlett2_data * private,int index)4536 static int line_out_remap(struct scarlett2_data *private, int index)
4537 {
4538 	const struct scarlett2_device_info *info = private->info;
4539 
4540 	if (!info->line_out_remap_enable)
4541 		return index;
4542 
4543 	if (index >= private->num_line_out)
4544 		return index;
4545 
4546 	return info->line_out_remap[index];
4547 }
4548 
scarlett2_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4549 static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
4550 				    struct snd_ctl_elem_value *ucontrol)
4551 {
4552 	struct usb_mixer_elem_info *elem = kctl->private_data;
4553 	struct usb_mixer_interface *mixer = elem->head.mixer;
4554 	struct scarlett2_data *private = mixer->private_data;
4555 	int index = line_out_remap(private, elem->control);
4556 	int err = 0;
4557 
4558 	mutex_lock(&private->data_mutex);
4559 
4560 	if (private->hwdep_in_use) {
4561 		err = -EBUSY;
4562 		goto unlock;
4563 	}
4564 
4565 	if (private->vol_updated) {
4566 		err = scarlett2_update_volumes(mixer);
4567 		if (err < 0)
4568 			goto unlock;
4569 	}
4570 	ucontrol->value.integer.value[0] = private->vol[index];
4571 
4572 unlock:
4573 	mutex_unlock(&private->data_mutex);
4574 	return err;
4575 }
4576 
scarlett2_volume_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4577 static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
4578 				    struct snd_ctl_elem_value *ucontrol)
4579 {
4580 	struct usb_mixer_elem_info *elem = kctl->private_data;
4581 	struct usb_mixer_interface *mixer = elem->head.mixer;
4582 	struct scarlett2_data *private = mixer->private_data;
4583 	int index = line_out_remap(private, elem->control);
4584 	int oval, val, err = 0;
4585 
4586 	mutex_lock(&private->data_mutex);
4587 
4588 	if (private->hwdep_in_use) {
4589 		err = -EBUSY;
4590 		goto unlock;
4591 	}
4592 
4593 	oval = private->vol[index];
4594 	val = ucontrol->value.integer.value[0];
4595 
4596 	if (oval == val)
4597 		goto unlock;
4598 
4599 	private->vol[index] = val;
4600 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4601 				       index, val - SCARLETT2_VOLUME_BIAS);
4602 	if (err == 0)
4603 		err = 1;
4604 
4605 unlock:
4606 	mutex_unlock(&private->data_mutex);
4607 	return err;
4608 }
4609 
4610 static const DECLARE_TLV_DB_MINMAX(
4611 	db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
4612 );
4613 
4614 static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
4615 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4616 	.access = SNDRV_CTL_ELEM_ACCESS_READ |
4617 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
4618 	.name = "",
4619 	.info = scarlett2_volume_ctl_info,
4620 	.get  = scarlett2_master_volume_ctl_get,
4621 	.private_value = 0, /* max value */
4622 	.tlv = { .p = db_scale_scarlett2_volume }
4623 };
4624 
4625 static const struct snd_kcontrol_new scarlett2_headphone_volume_ctl = {
4626 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4627 	.access = SNDRV_CTL_ELEM_ACCESS_READ |
4628 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
4629 	.name = "",
4630 	.info = scarlett2_volume_ctl_info,
4631 	.get  = scarlett2_headphone_volume_ctl_get,
4632 	.private_value = 0, /* max value */
4633 	.tlv = { .p = db_scale_scarlett2_volume }
4634 };
4635 
4636 static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
4637 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4638 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
4639 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
4640 	.name = "",
4641 	.info = scarlett2_volume_ctl_info,
4642 	.get  = scarlett2_volume_ctl_get,
4643 	.put  = scarlett2_volume_ctl_put,
4644 	.private_value = 0, /* max value */
4645 	.tlv = { .p = db_scale_scarlett2_volume }
4646 };
4647 
4648 /*** Mute Switch Controls ***/
4649 
scarlett2_update_dim_mute(struct usb_mixer_interface * mixer)4650 static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)
4651 {
4652 	struct scarlett2_data *private = mixer->private_data;
4653 	int err, i;
4654 	u8 mute;
4655 
4656 	private->dim_mute_updated = 0;
4657 
4658 	if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))
4659 		return 0;
4660 
4661 	err = scarlett2_usb_get_config(
4662 		mixer, SCARLETT2_CONFIG_DIM_MUTE,
4663 		SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);
4664 	if (err < 0)
4665 		return err;
4666 
4667 	for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
4668 		private->dim_mute[i] = !!private->dim_mute[i];
4669 
4670 	mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4671 
4672 	for (i = 0; i < private->num_line_out; i++)
4673 		if (private->vol_sw_hw_switch[i])
4674 			private->mute_switch[i] = mute;
4675 
4676 	return 0;
4677 }
4678 
scarlett2_mute_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4679 static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,
4680 					struct snd_ctl_elem_value *ucontrol)
4681 {
4682 	struct usb_mixer_elem_info *elem = kctl->private_data;
4683 	struct usb_mixer_interface *mixer = elem->head.mixer;
4684 	struct scarlett2_data *private = mixer->private_data;
4685 	int index = line_out_remap(private, elem->control);
4686 	int err = 0;
4687 
4688 	mutex_lock(&private->data_mutex);
4689 
4690 	if (private->hwdep_in_use) {
4691 		err = -EBUSY;
4692 		goto unlock;
4693 	}
4694 
4695 	if (private->dim_mute_updated) {
4696 		err = scarlett2_update_dim_mute(mixer);
4697 		if (err < 0)
4698 			goto unlock;
4699 	}
4700 	ucontrol->value.integer.value[0] = private->mute_switch[index];
4701 
4702 unlock:
4703 	mutex_unlock(&private->data_mutex);
4704 	return err;
4705 }
4706 
scarlett2_mute_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4707 static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
4708 					struct snd_ctl_elem_value *ucontrol)
4709 {
4710 	struct usb_mixer_elem_info *elem = kctl->private_data;
4711 	struct usb_mixer_interface *mixer = elem->head.mixer;
4712 	struct scarlett2_data *private = mixer->private_data;
4713 	int index = line_out_remap(private, elem->control);
4714 	int oval, val, err = 0;
4715 
4716 	mutex_lock(&private->data_mutex);
4717 
4718 	if (private->hwdep_in_use) {
4719 		err = -EBUSY;
4720 		goto unlock;
4721 	}
4722 
4723 	oval = private->mute_switch[index];
4724 	val = !!ucontrol->value.integer.value[0];
4725 
4726 	if (oval == val)
4727 		goto unlock;
4728 
4729 	private->mute_switch[index] = val;
4730 
4731 	/* Send mute change to the device */
4732 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4733 				       index, val);
4734 	if (err == 0)
4735 		err = 1;
4736 
4737 unlock:
4738 	mutex_unlock(&private->data_mutex);
4739 	return err;
4740 }
4741 
4742 static const struct snd_kcontrol_new scarlett2_mute_ctl = {
4743 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4744 	.name = "",
4745 	.info = snd_ctl_boolean_mono_info,
4746 	.get  = scarlett2_mute_ctl_get,
4747 	.put  = scarlett2_mute_ctl_put,
4748 };
4749 
4750 /*** HW/SW Volume Switch Controls ***/
4751 
scarlett2_sw_hw_ctl_ro(struct scarlett2_data * private,int index)4752 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
4753 {
4754 	private->sw_hw_ctls[index]->vd[0].access &=
4755 		~SNDRV_CTL_ELEM_ACCESS_WRITE;
4756 }
4757 
scarlett2_sw_hw_ctl_rw(struct scarlett2_data * private,int index)4758 static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
4759 {
4760 	private->sw_hw_ctls[index]->vd[0].access |=
4761 		SNDRV_CTL_ELEM_ACCESS_WRITE;
4762 }
4763 
scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)4764 static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
4765 					 struct snd_ctl_elem_info *uinfo)
4766 {
4767 	static const char *const values[2] = {
4768 		"SW", "HW"
4769 	};
4770 
4771 	return snd_ctl_enum_info(uinfo, 1, 2, values);
4772 }
4773 
scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4774 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
4775 					struct snd_ctl_elem_value *ucontrol)
4776 {
4777 	struct usb_mixer_elem_info *elem = kctl->private_data;
4778 	struct scarlett2_data *private = elem->head.mixer->private_data;
4779 	int index = line_out_remap(private, elem->control);
4780 
4781 	ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
4782 	return 0;
4783 }
4784 
scarlett2_vol_ctl_set_writable(struct usb_mixer_interface * mixer,int index,int value)4785 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
4786 					   int index, int value)
4787 {
4788 	struct scarlett2_data *private = mixer->private_data;
4789 	struct snd_card *card = mixer->chip->card;
4790 
4791 	/* Set/Clear write bits */
4792 	if (value) {
4793 		private->vol_ctls[index]->vd[0].access |=
4794 			SNDRV_CTL_ELEM_ACCESS_WRITE;
4795 		private->mute_ctls[index]->vd[0].access |=
4796 			SNDRV_CTL_ELEM_ACCESS_WRITE;
4797 	} else {
4798 		private->vol_ctls[index]->vd[0].access &=
4799 			~SNDRV_CTL_ELEM_ACCESS_WRITE;
4800 		private->mute_ctls[index]->vd[0].access &=
4801 			~SNDRV_CTL_ELEM_ACCESS_WRITE;
4802 	}
4803 
4804 	/* Notify of write bit and possible value change */
4805 	snd_ctl_notify(card,
4806 		       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
4807 		       &private->vol_ctls[index]->id);
4808 	snd_ctl_notify(card,
4809 		       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
4810 		       &private->mute_ctls[index]->id);
4811 }
4812 
scarlett2_sw_hw_change(struct usb_mixer_interface * mixer,int ctl_index,int val)4813 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
4814 				  int ctl_index, int val)
4815 {
4816 	struct scarlett2_data *private = mixer->private_data;
4817 	int index = line_out_remap(private, ctl_index);
4818 	int err;
4819 
4820 	private->vol_sw_hw_switch[index] = val;
4821 
4822 	/* Change access mode to RO (hardware controlled volume)
4823 	 * or RW (software controlled volume)
4824 	 */
4825 	scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
4826 
4827 	/* Reset volume/mute to master volume/mute */
4828 	private->vol[index] = private->master_vol;
4829 	private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4830 
4831 	/* Set SW volume to current HW volume */
4832 	err = scarlett2_usb_set_config(
4833 		mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4834 		index, private->master_vol - SCARLETT2_VOLUME_BIAS);
4835 	if (err < 0)
4836 		return err;
4837 
4838 	/* Set SW mute to current HW mute */
4839 	err = scarlett2_usb_set_config(
4840 		mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4841 		index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
4842 	if (err < 0)
4843 		return err;
4844 
4845 	/* Send SW/HW switch change to the device */
4846 	return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
4847 					index, val);
4848 }
4849 
scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4850 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
4851 					struct snd_ctl_elem_value *ucontrol)
4852 {
4853 	struct usb_mixer_elem_info *elem = kctl->private_data;
4854 	struct usb_mixer_interface *mixer = elem->head.mixer;
4855 	struct scarlett2_data *private = mixer->private_data;
4856 	int ctl_index = elem->control;
4857 	int index = line_out_remap(private, ctl_index);
4858 	int oval, val, err = 0;
4859 
4860 	mutex_lock(&private->data_mutex);
4861 
4862 	if (private->hwdep_in_use) {
4863 		err = -EBUSY;
4864 		goto unlock;
4865 	}
4866 
4867 	oval = private->vol_sw_hw_switch[index];
4868 	val = !!ucontrol->value.enumerated.item[0];
4869 
4870 	if (oval == val)
4871 		goto unlock;
4872 
4873 	err = scarlett2_sw_hw_change(mixer, ctl_index, val);
4874 	if (err == 0)
4875 		err = 1;
4876 
4877 unlock:
4878 	mutex_unlock(&private->data_mutex);
4879 	return err;
4880 }
4881 
4882 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
4883 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4884 	.name = "",
4885 	.info = scarlett2_sw_hw_enum_ctl_info,
4886 	.get  = scarlett2_sw_hw_enum_ctl_get,
4887 	.put  = scarlett2_sw_hw_enum_ctl_put,
4888 };
4889 
4890 /*** Line Level/Instrument Level Switch Controls ***/
4891 
scarlett2_update_input_level(struct usb_mixer_interface * mixer)4892 static int scarlett2_update_input_level(struct usb_mixer_interface *mixer)
4893 {
4894 	struct scarlett2_data *private = mixer->private_data;
4895 	const struct scarlett2_device_info *info = private->info;
4896 
4897 	private->input_level_updated = 0;
4898 
4899 	if (!info->level_input_count)
4900 		return 0;
4901 
4902 	return scarlett2_usb_get_config(
4903 		mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
4904 		info->level_input_count + info->level_input_first,
4905 		private->level_switch);
4906 }
4907 
scarlett2_level_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)4908 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
4909 					 struct snd_ctl_elem_info *uinfo)
4910 {
4911 	static const char *const values[2] = {
4912 		"Line", "Inst"
4913 	};
4914 	struct usb_mixer_elem_info *elem = kctl->private_data;
4915 	struct usb_mixer_interface *mixer = elem->head.mixer;
4916 	struct scarlett2_data *private = mixer->private_data;
4917 	int err;
4918 
4919 	mutex_lock(&private->data_mutex);
4920 
4921 	if (private->hwdep_in_use) {
4922 		err = -EBUSY;
4923 		goto unlock;
4924 	}
4925 
4926 	err = scarlett2_check_autogain_updated(mixer);
4927 	if (err < 0)
4928 		goto unlock;
4929 
4930 	err = snd_ctl_enum_info(uinfo, 1, 2, values);
4931 
4932 unlock:
4933 	mutex_unlock(&private->data_mutex);
4934 	return err;
4935 }
4936 
scarlett2_level_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4937 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
4938 					struct snd_ctl_elem_value *ucontrol)
4939 {
4940 	struct usb_mixer_elem_info *elem = kctl->private_data;
4941 	struct usb_mixer_interface *mixer = elem->head.mixer;
4942 	struct scarlett2_data *private = mixer->private_data;
4943 	const struct scarlett2_device_info *info = private->info;
4944 
4945 	int index = elem->control + info->level_input_first;
4946 	int err = 0;
4947 
4948 	mutex_lock(&private->data_mutex);
4949 
4950 	if (private->hwdep_in_use) {
4951 		err = -EBUSY;
4952 		goto unlock;
4953 	}
4954 
4955 	if (private->input_level_updated) {
4956 		err = scarlett2_update_input_level(mixer);
4957 		if (err < 0)
4958 			goto unlock;
4959 	}
4960 	ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(
4961 		private->level_switch[index]);
4962 
4963 unlock:
4964 	mutex_unlock(&private->data_mutex);
4965 	return err;
4966 }
4967 
scarlett2_level_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)4968 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
4969 					struct snd_ctl_elem_value *ucontrol)
4970 {
4971 	struct usb_mixer_elem_info *elem = kctl->private_data;
4972 	struct usb_mixer_interface *mixer = elem->head.mixer;
4973 	struct scarlett2_data *private = mixer->private_data;
4974 	const struct scarlett2_device_info *info = private->info;
4975 
4976 	int index = elem->control + info->level_input_first;
4977 	int oval, val, err;
4978 
4979 	mutex_lock(&private->data_mutex);
4980 
4981 	if (private->hwdep_in_use) {
4982 		err = -EBUSY;
4983 		goto unlock;
4984 	}
4985 
4986 	err = scarlett2_check_put_during_autogain(mixer);
4987 	if (err < 0)
4988 		goto unlock;
4989 
4990 	oval = private->level_switch[index];
4991 	val = !!ucontrol->value.enumerated.item[0];
4992 
4993 	if (oval == val)
4994 		goto unlock;
4995 
4996 	private->level_switch[index] = val;
4997 
4998 	/* To set the Gen 4 muteable controls, bit 1 gets set instead */
4999 	if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)
5000 		val = (!val) | 0x02;
5001 
5002 	/* Send switch change to the device */
5003 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
5004 				       index, val);
5005 	if (err == 0)
5006 		err = 1;
5007 
5008 unlock:
5009 	mutex_unlock(&private->data_mutex);
5010 	return err;
5011 }
5012 
5013 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
5014 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5015 	.name = "",
5016 	.info = scarlett2_level_enum_ctl_info,
5017 	.get  = scarlett2_level_enum_ctl_get,
5018 	.put  = scarlett2_level_enum_ctl_put,
5019 };
5020 
5021 /*** Pad Switch Controls ***/
5022 
scarlett2_update_input_pad(struct usb_mixer_interface * mixer)5023 static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer)
5024 {
5025 	struct scarlett2_data *private = mixer->private_data;
5026 	const struct scarlett2_device_info *info = private->info;
5027 
5028 	private->input_pad_updated = 0;
5029 
5030 	if (!info->pad_input_count)
5031 		return 0;
5032 
5033 	return scarlett2_usb_get_config(
5034 		mixer, SCARLETT2_CONFIG_PAD_SWITCH,
5035 		info->pad_input_count, private->pad_switch);
5036 }
5037 
scarlett2_pad_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5038 static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
5039 				 struct snd_ctl_elem_value *ucontrol)
5040 {
5041 	struct usb_mixer_elem_info *elem = kctl->private_data;
5042 	struct usb_mixer_interface *mixer = elem->head.mixer;
5043 	struct scarlett2_data *private = mixer->private_data;
5044 	int err = 0;
5045 
5046 	mutex_lock(&private->data_mutex);
5047 
5048 	if (private->hwdep_in_use) {
5049 		err = -EBUSY;
5050 		goto unlock;
5051 	}
5052 
5053 	if (private->input_pad_updated) {
5054 		err = scarlett2_update_input_pad(mixer);
5055 		if (err < 0)
5056 			goto unlock;
5057 	}
5058 	ucontrol->value.integer.value[0] =
5059 		private->pad_switch[elem->control];
5060 
5061 unlock:
5062 	mutex_unlock(&private->data_mutex);
5063 	return err;
5064 }
5065 
scarlett2_pad_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5066 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
5067 				 struct snd_ctl_elem_value *ucontrol)
5068 {
5069 	struct usb_mixer_elem_info *elem = kctl->private_data;
5070 	struct usb_mixer_interface *mixer = elem->head.mixer;
5071 	struct scarlett2_data *private = mixer->private_data;
5072 
5073 	int index = elem->control;
5074 	int oval, val, err = 0;
5075 
5076 	mutex_lock(&private->data_mutex);
5077 
5078 	if (private->hwdep_in_use) {
5079 		err = -EBUSY;
5080 		goto unlock;
5081 	}
5082 
5083 	oval = private->pad_switch[index];
5084 	val = !!ucontrol->value.integer.value[0];
5085 
5086 	if (oval == val)
5087 		goto unlock;
5088 
5089 	private->pad_switch[index] = val;
5090 
5091 	/* Send switch change to the device */
5092 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
5093 				       index, val);
5094 	if (err == 0)
5095 		err = 1;
5096 
5097 unlock:
5098 	mutex_unlock(&private->data_mutex);
5099 	return err;
5100 }
5101 
5102 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
5103 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5104 	.name = "",
5105 	.info = snd_ctl_boolean_mono_info,
5106 	.get  = scarlett2_pad_ctl_get,
5107 	.put  = scarlett2_pad_ctl_put,
5108 };
5109 
5110 /*** Air Switch Controls ***/
5111 
scarlett2_update_input_air(struct usb_mixer_interface * mixer)5112 static int scarlett2_update_input_air(struct usb_mixer_interface *mixer)
5113 {
5114 	struct scarlett2_data *private = mixer->private_data;
5115 	const struct scarlett2_device_info *info = private->info;
5116 
5117 	private->input_air_updated = 0;
5118 
5119 	if (!info->air_input_count)
5120 		return 0;
5121 
5122 	return scarlett2_usb_get_config(
5123 		mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5124 		info->air_input_count, private->air_switch);
5125 }
5126 
scarlett2_air_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5127 static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
5128 				 struct snd_ctl_elem_value *ucontrol)
5129 {
5130 	struct usb_mixer_elem_info *elem = kctl->private_data;
5131 	struct usb_mixer_interface *mixer = elem->head.mixer;
5132 	struct scarlett2_data *private = mixer->private_data;
5133 	int err = 0;
5134 
5135 	mutex_lock(&private->data_mutex);
5136 
5137 	if (private->hwdep_in_use) {
5138 		err = -EBUSY;
5139 		goto unlock;
5140 	}
5141 
5142 	if (private->input_air_updated) {
5143 		err = scarlett2_update_input_air(mixer);
5144 		if (err < 0)
5145 			goto unlock;
5146 	}
5147 	ucontrol->value.integer.value[0] = private->air_switch[elem->control];
5148 
5149 unlock:
5150 	mutex_unlock(&private->data_mutex);
5151 	return err;
5152 }
5153 
scarlett2_air_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5154 static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
5155 				 struct snd_ctl_elem_value *ucontrol)
5156 {
5157 	struct usb_mixer_elem_info *elem = kctl->private_data;
5158 	struct usb_mixer_interface *mixer = elem->head.mixer;
5159 	struct scarlett2_data *private = mixer->private_data;
5160 
5161 	int index = elem->control;
5162 	int oval, val, err;
5163 
5164 	mutex_lock(&private->data_mutex);
5165 
5166 	if (private->hwdep_in_use) {
5167 		err = -EBUSY;
5168 		goto unlock;
5169 	}
5170 
5171 	err = scarlett2_check_put_during_autogain(mixer);
5172 	if (err < 0)
5173 		goto unlock;
5174 
5175 	oval = private->air_switch[index];
5176 	val = ucontrol->value.integer.value[0];
5177 
5178 	if (oval == val)
5179 		goto unlock;
5180 
5181 	private->air_switch[index] = val;
5182 
5183 	/* Send switch change to the device */
5184 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5185 				       index, val);
5186 	if (err == 0)
5187 		err = 1;
5188 
5189 unlock:
5190 	mutex_unlock(&private->data_mutex);
5191 	return err;
5192 }
5193 
scarlett2_air_with_drive_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)5194 static int scarlett2_air_with_drive_ctl_info(
5195 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
5196 {
5197 	static const char *const values[3] = {
5198 		"Off", "Presence", "Presence + Drive"
5199 	};
5200 	struct usb_mixer_elem_info *elem = kctl->private_data;
5201 	struct usb_mixer_interface *mixer = elem->head.mixer;
5202 	struct scarlett2_data *private = mixer->private_data;
5203 	int err;
5204 
5205 	mutex_lock(&private->data_mutex);
5206 
5207 	if (private->hwdep_in_use) {
5208 		err = -EBUSY;
5209 		goto unlock;
5210 	}
5211 
5212 	err = scarlett2_check_autogain_updated(mixer);
5213 	if (err < 0)
5214 		goto unlock;
5215 
5216 	err = snd_ctl_enum_info(uinfo, 1, 3, values);
5217 
5218 unlock:
5219 	mutex_unlock(&private->data_mutex);
5220 	return err;
5221 }
5222 
5223 static const struct snd_kcontrol_new scarlett2_air_ctl[2] = {
5224 	{
5225 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5226 		.name = "",
5227 		.info = snd_ctl_boolean_mono_info,
5228 		.get  = scarlett2_air_ctl_get,
5229 		.put  = scarlett2_air_ctl_put,
5230 	},
5231 	{
5232 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5233 		.name = "",
5234 		.info = scarlett2_air_with_drive_ctl_info,
5235 		.get  = scarlett2_air_ctl_get,
5236 		.put  = scarlett2_air_ctl_put,
5237 	}
5238 };
5239 
5240 /*** DSP Switch Control ***/
5241 
scarlett2_update_input_dsp(struct usb_mixer_interface * mixer)5242 static int scarlett2_update_input_dsp(struct usb_mixer_interface *mixer)
5243 {
5244 	struct scarlett2_data *private = mixer->private_data;
5245 	const struct scarlett2_device_info *info = private->info;
5246 
5247 	private->input_dsp_updated = 0;
5248 
5249 	if (!info->dsp_input_count)
5250 		return 0;
5251 
5252 	return scarlett2_usb_get_config(
5253 		mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5254 		info->dsp_input_count, private->dsp_switch);
5255 }
5256 
scarlett2_dsp_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5257 static int scarlett2_dsp_ctl_get(struct snd_kcontrol *kctl,
5258 				 struct snd_ctl_elem_value *ucontrol)
5259 {
5260 	struct usb_mixer_elem_info *elem = kctl->private_data;
5261 	struct usb_mixer_interface *mixer = elem->head.mixer;
5262 	struct scarlett2_data *private = mixer->private_data;
5263 	int err = 0;
5264 
5265 	mutex_lock(&private->data_mutex);
5266 
5267 	if (private->hwdep_in_use) {
5268 		err = -EBUSY;
5269 		goto unlock;
5270 	}
5271 
5272 	if (private->input_dsp_updated) {
5273 		err = scarlett2_update_input_dsp(mixer);
5274 		if (err < 0)
5275 			goto unlock;
5276 	}
5277 	ucontrol->value.integer.value[0] = private->dsp_switch[elem->control];
5278 
5279 unlock:
5280 	mutex_unlock(&private->data_mutex);
5281 	return err;
5282 }
5283 
scarlett2_dsp_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5284 static int scarlett2_dsp_ctl_put(struct snd_kcontrol *kctl,
5285 				 struct snd_ctl_elem_value *ucontrol)
5286 {
5287 	struct usb_mixer_elem_info *elem = kctl->private_data;
5288 	struct usb_mixer_interface *mixer = elem->head.mixer;
5289 	struct scarlett2_data *private = mixer->private_data;
5290 
5291 	int index = elem->control;
5292 	int oval, val, err;
5293 
5294 	mutex_lock(&private->data_mutex);
5295 
5296 	if (private->hwdep_in_use) {
5297 		err = -EBUSY;
5298 		goto unlock;
5299 	}
5300 
5301 	err = scarlett2_check_put_during_autogain(mixer);
5302 	if (err < 0)
5303 		goto unlock;
5304 
5305 	oval = private->dsp_switch[index];
5306 	val = ucontrol->value.integer.value[0];
5307 
5308 	if (oval == val)
5309 		goto unlock;
5310 
5311 	private->dsp_switch[index] = val;
5312 
5313 	/* Send switch change to the device */
5314 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5315 				       index, val);
5316 	if (err == 0)
5317 		err = 1;
5318 
5319 unlock:
5320 	mutex_unlock(&private->data_mutex);
5321 	return err;
5322 }
5323 
5324 static const struct snd_kcontrol_new scarlett2_dsp_ctl = {
5325 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5326 	.name = "",
5327 	.info = scarlett2_autogain_disables_ctl_info,
5328 	.get  = scarlett2_dsp_ctl_get,
5329 	.put  = scarlett2_dsp_ctl_put,
5330 };
5331 
5332 /*** DSP Compressor Parameter Controls ***/
5333 
scarlett2_update_compressor_values(struct usb_mixer_interface * mixer)5334 static int scarlett2_update_compressor_values(struct usb_mixer_interface *mixer)
5335 {
5336 	struct scarlett2_data *private = mixer->private_data;
5337 	const struct scarlett2_device_info *info = private->info;
5338 	int err, i, j;
5339 
5340 	if (!info->dsp_input_count)
5341 		return 0;
5342 
5343 	err = scarlett2_usb_get_config(
5344 		mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS,
5345 		SCARLETT2_COMPRESSOR_PARAM_COUNT * info->dsp_input_count,
5346 		private->compressor_values);
5347 
5348 	if (err < 0)
5349 		return err;
5350 
5351 	for (i = 0; i < SCARLETT2_COMPRESSOR_PARAM_COUNT; i++) {
5352 		const struct compressor_param *param = &compressor_params[i];
5353 
5354 		for (j = 0; j < info->dsp_input_count; j++) {
5355 			int idx = i + j * SCARLETT2_COMPRESSOR_PARAM_COUNT;
5356 			int val = private->compressor_values[idx];
5357 
5358 			val >>= param->scale_bits;
5359 			val = clamp(val, param->min, param->max);
5360 			private->compressor_values[idx] = val;
5361 		}
5362 	}
5363 
5364 	return 0;
5365 }
5366 
scarlett2_compressor_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5367 static int scarlett2_compressor_ctl_get(
5368 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5369 {
5370 	struct usb_mixer_elem_info *elem = kctl->private_data;
5371 	struct scarlett2_data *private = elem->head.mixer->private_data;
5372 
5373 	ucontrol->value.integer.value[0] =
5374 		private->compressor_values[elem->control];
5375 	return 0;
5376 }
5377 
scarlett2_compressor_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5378 static int scarlett2_compressor_ctl_put(
5379 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5380 {
5381 	struct usb_mixer_elem_info *elem = kctl->private_data;
5382 	struct usb_mixer_interface *mixer = elem->head.mixer;
5383 	struct scarlett2_data *private = mixer->private_data;
5384 
5385 	int index = elem->control;
5386 	int channel = index / SCARLETT2_COMPRESSOR_PARAM_COUNT;
5387 	int param_index = index % SCARLETT2_COMPRESSOR_PARAM_COUNT;
5388 	int oval, val, err;
5389 	s32 scaled_val;
5390 
5391 	mutex_lock(&private->data_mutex);
5392 
5393 	if (private->hwdep_in_use) {
5394 		err = -EBUSY;
5395 		goto unlock;
5396 	}
5397 
5398 	err = scarlett2_check_put_during_autogain(mixer);
5399 	if (err < 0)
5400 		goto unlock;
5401 
5402 	oval = private->compressor_values[index];
5403 	val = ucontrol->value.integer.value[0];
5404 	if (oval == val)
5405 		goto unlock;
5406 
5407 	private->compressor_values[index] = val;
5408 
5409 	const struct compressor_param *param = &compressor_params[param_index];
5410 
5411 	scaled_val = val << param->scale_bits;
5412 
5413 	/* Send change to the device */
5414 
5415 	/* The channel needs to be put in the parameter buffer index
5416 	 * field (param_buf_addr + 1); the value field isn't used in
5417 	 * this case.
5418 	 */
5419 	err = scarlett2_usb_set_data(
5420 		mixer, private->config_set->param_buf_addr + 1, 1, channel);
5421 	if (err < 0)
5422 		goto unlock;
5423 
5424 	err = scarlett2_usb_set_config(
5425 		mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS, index, scaled_val);
5426 	if (err < 0)
5427 		goto unlock;
5428 
5429 	if (err == 0)
5430 		err = 1;
5431 
5432 unlock:
5433 	mutex_unlock(&private->data_mutex);
5434 	return err;
5435 }
5436 
scarlett2_compressor_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)5437 static int scarlett2_compressor_ctl_info(
5438 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
5439 {
5440 	struct usb_mixer_elem_info *elem = kctl->private_data;
5441 	int control = elem->control % SCARLETT2_COMPRESSOR_PARAM_COUNT;
5442 
5443 	uinfo->type = compressor_params[control].type;
5444 	uinfo->count = 1;
5445 	uinfo->value.integer.min = compressor_params[control].min;
5446 	uinfo->value.integer.max = compressor_params[control].max;
5447 	uinfo->value.integer.step = 1;
5448 	return 0;
5449 }
5450 
5451 static const struct snd_kcontrol_new scarlett2_compressor_ctl = {
5452 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
5453 	.name = "",
5454 	.info = scarlett2_compressor_ctl_info,
5455 	.get  = scarlett2_compressor_ctl_get,
5456 	.put  = scarlett2_compressor_ctl_put,
5457 };
5458 
5459 /*** DSP Pre-Compressor and PEQ Filter Controls ***/
5460 
scarlett2_precomp_flt_switch_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5461 static int scarlett2_precomp_flt_switch_ctl_get(
5462 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5463 {
5464 	struct usb_mixer_elem_info *elem = kctl->private_data;
5465 	struct scarlett2_data *private = elem->head.mixer->private_data;
5466 
5467 	ucontrol->value.integer.value[0] = private->precomp_flt_switch[elem->control];
5468 
5469 	return 0;
5470 }
5471 
scarlett2_peq_flt_switch_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5472 static int scarlett2_peq_flt_switch_ctl_get(
5473 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5474 {
5475 	struct usb_mixer_elem_info *elem = kctl->private_data;
5476 	struct scarlett2_data *private = elem->head.mixer->private_data;
5477 
5478 	ucontrol->value.integer.value[0] =
5479 		private->peq_flt_switch[elem->control];
5480 
5481 	return 0;
5482 }
5483 
scarlett2_precomp_flt_switch_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5484 static int scarlett2_precomp_flt_switch_ctl_put(
5485 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5486 {
5487 	struct usb_mixer_elem_info *elem = kctl->private_data;
5488 	struct usb_mixer_interface *mixer = elem->head.mixer;
5489 	struct scarlett2_data *private = mixer->private_data;
5490 	int oval, val, err = 0;
5491 
5492 	mutex_lock(&private->data_mutex);
5493 
5494 	if (private->hwdep_in_use) {
5495 		err = -EBUSY;
5496 		goto unlock;
5497 	}
5498 
5499 	oval = private->precomp_flt_switch[elem->control];
5500 	val = ucontrol->value.integer.value[0];
5501 
5502 	if (oval == val)
5503 		goto unlock;
5504 
5505 	private->precomp_flt_switch[elem->control] = val;
5506 
5507 	/* Send change to the device */
5508 	err = scarlett2_usb_set_config(
5509 		mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5510 		elem->control, val);
5511 	if (err == 0)
5512 		err = 1;
5513 
5514 unlock:
5515 	mutex_unlock(&private->data_mutex);
5516 	return err;
5517 }
5518 
scarlett2_peq_flt_switch_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5519 static int scarlett2_peq_flt_switch_ctl_put(
5520 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5521 {
5522 	struct usb_mixer_elem_info *elem = kctl->private_data;
5523 	struct usb_mixer_interface *mixer = elem->head.mixer;
5524 	struct scarlett2_data *private = mixer->private_data;
5525 	int oval, val, err = 0;
5526 
5527 	mutex_lock(&private->data_mutex);
5528 
5529 	if (private->hwdep_in_use) {
5530 		err = -EBUSY;
5531 		goto unlock;
5532 	}
5533 
5534 	oval = private->peq_flt_switch[elem->control];
5535 	val = ucontrol->value.integer.value[0];
5536 
5537 	if (oval == val)
5538 		goto unlock;
5539 
5540 	private->peq_flt_switch[elem->control] = val;
5541 
5542 	/* Send change to the device */
5543 	err = scarlett2_usb_set_config(
5544 		mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5545 		elem->control, val);
5546 	if (err == 0)
5547 		err = 1;
5548 
5549 unlock:
5550 	mutex_unlock(&private->data_mutex);
5551 	return err;
5552 }
5553 
5554 static const struct snd_kcontrol_new scarlett2_precomp_flt_switch_ctl = {
5555 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
5556 	.name = "",
5557 	.info = snd_ctl_boolean_mono_info,
5558 	.get  = scarlett2_precomp_flt_switch_ctl_get,
5559 	.put  = scarlett2_precomp_flt_switch_ctl_put,
5560 };
5561 
5562 static const struct snd_kcontrol_new scarlett2_peq_flt_switch_ctl = {
5563 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
5564 	.name = "",
5565 	.info = snd_ctl_boolean_mono_info,
5566 	.get  = scarlett2_peq_flt_switch_ctl_get,
5567 	.put  = scarlett2_peq_flt_switch_ctl_put,
5568 };
5569 
scarlett2_update_filter_values(struct usb_mixer_interface * mixer)5570 static int scarlett2_update_filter_values(struct usb_mixer_interface *mixer)
5571 {
5572 	struct scarlett2_data *private = mixer->private_data;
5573 	const struct scarlett2_device_info *info = private->info;
5574 	int err, i, j, k, src_idx, dst_idx;
5575 	s32 peq_flt_values[SCARLETT2_DSP_SWITCH_MAX *
5576 			   SCARLETT2_PEQ_FLT_SLOTS_MAX *
5577 			   SCARLETT2_BIQUAD_COEFFS];
5578 
5579 	if (!info->dsp_input_count)
5580 		return 0;
5581 
5582 	/* Get filter switch values */
5583 	err = scarlett2_usb_get_config(
5584 		mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5585 		info->dsp_input_count, private->precomp_flt_switch);
5586 	if (err < 0)
5587 		return err;
5588 
5589 	err = scarlett2_usb_get_config(
5590 		mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5591 		info->dsp_input_count * info->peq_flt_count,
5592 		private->peq_flt_switch);
5593 	if (err < 0)
5594 		return err;
5595 
5596 	/* Get pre-compressor filter values directly */
5597 	err = scarlett2_usb_get_config(
5598 		mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5599 		info->dsp_input_count *
5600 			info->precomp_flt_count *
5601 			SCARLETT2_BIQUAD_COEFFS,
5602 		private->precomp_flt_values);
5603 
5604 	if (err < 0)
5605 		return err;
5606 
5607 	/* PEQ filter values need to be copied via buffer because of
5608 	 * padding after peq_flt_count up to peq_flt_total_count
5609 	 */
5610 	err = scarlett2_usb_get_config(
5611 		mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5612 		info->dsp_input_count *
5613 			info->peq_flt_total_count *
5614 			SCARLETT2_BIQUAD_COEFFS,
5615 		peq_flt_values);
5616 
5617 	for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) {
5618 		src_idx = i *
5619 			  info->peq_flt_total_count *
5620 			  SCARLETT2_BIQUAD_COEFFS;
5621 		for (j = 0; j < info->peq_flt_count; j++)
5622 			for (k = 0;
5623 			     k < SCARLETT2_BIQUAD_COEFFS;
5624 			     k++, src_idx++, dst_idx++)
5625 				private->peq_flt_values[dst_idx] =
5626 					peq_flt_values[src_idx];
5627 	}
5628 
5629 	return 0;
5630 }
5631 
scarlett2_precomp_flt_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5632 static int scarlett2_precomp_flt_ctl_get(
5633 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5634 {
5635 	struct usb_mixer_elem_info *elem = kctl->private_data;
5636 	struct scarlett2_data *private = elem->head.mixer->private_data;
5637 	int i, idx;
5638 
5639 	for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5640 	     i < SCARLETT2_BIQUAD_COEFFS;
5641 	     i++, idx++)
5642 		ucontrol->value.integer.value[i] =
5643 			private->precomp_flt_values[idx];
5644 
5645 	return 0;
5646 }
5647 
scarlett2_peq_flt_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5648 static int scarlett2_peq_flt_ctl_get(
5649 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5650 {
5651 	struct usb_mixer_elem_info *elem = kctl->private_data;
5652 	struct scarlett2_data *private = elem->head.mixer->private_data;
5653 	int i, idx;
5654 
5655 	for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5656 	     i < SCARLETT2_BIQUAD_COEFFS;
5657 	     i++, idx++)
5658 		ucontrol->value.integer.value[i] =
5659 			private->peq_flt_values[idx];
5660 
5661 	return 0;
5662 }
5663 
scarlett2_precomp_flt_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5664 static int scarlett2_precomp_flt_ctl_put(
5665 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5666 {
5667 	struct usb_mixer_elem_info *elem = kctl->private_data;
5668 	struct usb_mixer_interface *mixer = elem->head.mixer;
5669 	struct scarlett2_data *private = mixer->private_data;
5670 
5671 	int index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5672 	int i, oval, val, err;
5673 
5674 	mutex_lock(&private->data_mutex);
5675 
5676 	if (private->hwdep_in_use) {
5677 		err = -EBUSY;
5678 		goto unlock;
5679 	}
5680 
5681 	err = scarlett2_check_put_during_autogain(mixer);
5682 	if (err < 0)
5683 		goto unlock;
5684 
5685 	/* Check if any of the values have changed; if not, return */
5686 	for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) {
5687 		oval = private->precomp_flt_values[index + i];
5688 		val = ucontrol->value.integer.value[i];
5689 		if (oval != val)
5690 			break;
5691 	}
5692 
5693 	if (i == SCARLETT2_BIQUAD_COEFFS)
5694 		goto unlock;
5695 
5696 	/* Update the values */
5697 	for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++)
5698 		private->precomp_flt_values[index + i] =
5699 			ucontrol->value.integer.value[i];
5700 
5701 	/* Send change to the device */
5702 	err = scarlett2_usb_set_data(
5703 		mixer, private->config_set->param_buf_addr, 1, index);
5704 	if (err < 0)
5705 		goto unlock;
5706 
5707 	err = scarlett2_usb_set_config_buf(
5708 		mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5709 		index, SCARLETT2_BIQUAD_COEFFS,
5710 		&private->precomp_flt_values[index]);
5711 
5712 	if (err == 0)
5713 		err = 1;
5714 
5715 unlock:
5716 	mutex_unlock(&private->data_mutex);
5717 	return err;
5718 }
5719 
scarlett2_peq_flt_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5720 static int scarlett2_peq_flt_ctl_put(
5721 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5722 {
5723 	struct usb_mixer_elem_info *elem = kctl->private_data;
5724 	struct usb_mixer_interface *mixer = elem->head.mixer;
5725 	struct scarlett2_data *private = mixer->private_data;
5726 	const struct scarlett2_device_info *info = private->info;
5727 
5728 	int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5729 	int dst_index = (
5730 		elem->control /
5731 		info->peq_flt_count *
5732 		info->peq_flt_total_count +
5733 		elem->control % info->peq_flt_count
5734 	) * SCARLETT2_BIQUAD_COEFFS;
5735 	int i, oval, val, err;
5736 
5737 	mutex_lock(&private->data_mutex);
5738 
5739 	if (private->hwdep_in_use) {
5740 		err = -EBUSY;
5741 		goto unlock;
5742 	}
5743 
5744 	err = scarlett2_check_put_during_autogain(mixer);
5745 	if (err < 0)
5746 		goto unlock;
5747 
5748 	/* Check if any of the values have changed; if not, return */
5749 	for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) {
5750 		oval = private->peq_flt_values[src_index + i];
5751 		val = ucontrol->value.integer.value[i];
5752 		if (oval != val)
5753 			break;
5754 	}
5755 
5756 	if (i == SCARLETT2_BIQUAD_COEFFS)
5757 		goto unlock;
5758 
5759 	/* Update the values */
5760 	for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++)
5761 		private->peq_flt_values[src_index + i] =
5762 			ucontrol->value.integer.value[i];
5763 
5764 	/* Send change to the device */
5765 	err = scarlett2_usb_set_data(
5766 		mixer, private->config_set->param_buf_addr, 1, dst_index);
5767 	if (err < 0)
5768 		goto unlock;
5769 
5770 	err = scarlett2_usb_set_config_buf(
5771 		mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5772 		dst_index, SCARLETT2_BIQUAD_COEFFS,
5773 		&private->peq_flt_values[src_index]);
5774 
5775 	if (err == 0)
5776 		err = 1;
5777 
5778 unlock:
5779 	mutex_unlock(&private->data_mutex);
5780 	return err;
5781 }
5782 
scarlett2_flt_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)5783 static int scarlett2_flt_ctl_info(
5784 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
5785 {
5786 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
5787 	uinfo->count = SCARLETT2_BIQUAD_COEFFS;
5788 	uinfo->value.integer.min = INT_MIN;
5789 	uinfo->value.integer.max = INT_MAX;
5790 	uinfo->value.integer.step = 1;
5791 	return 0;
5792 }
5793 
5794 static const struct snd_kcontrol_new scarlett2_precomp_flt_ctl = {
5795 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
5796 	.name = "",
5797 	.info = scarlett2_flt_ctl_info,
5798 	.get  = scarlett2_precomp_flt_ctl_get,
5799 	.put  = scarlett2_precomp_flt_ctl_put,
5800 };
5801 
5802 static const struct snd_kcontrol_new scarlett2_peq_flt_ctl = {
5803 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
5804 	.name = "",
5805 	.info = scarlett2_flt_ctl_info,
5806 	.get  = scarlett2_peq_flt_ctl_get,
5807 	.put  = scarlett2_peq_flt_ctl_put,
5808 };
5809 
5810 /*** Input Mute Switch Controls ***/
5811 
scarlett2_update_input_mute(struct usb_mixer_interface * mixer)5812 static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer)
5813 {
5814 	struct scarlett2_data *private = mixer->private_data;
5815 	const struct scarlett2_device_info *info = private->info;
5816 
5817 	private->input_mute_updated = 0;
5818 
5819 	if (!info->mute_input_count)
5820 		return 0;
5821 
5822 	return scarlett2_usb_get_config(
5823 		mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5824 		info->mute_input_count, private->input_mute_switch);
5825 }
5826 
scarlett2_input_mute_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5827 static int scarlett2_input_mute_ctl_get(struct snd_kcontrol *kctl,
5828 					struct snd_ctl_elem_value *ucontrol)
5829 {
5830 	struct usb_mixer_elem_info *elem = kctl->private_data;
5831 	struct usb_mixer_interface *mixer = elem->head.mixer;
5832 	struct scarlett2_data *private = mixer->private_data;
5833 	int err = 0;
5834 
5835 	mutex_lock(&private->data_mutex);
5836 
5837 	if (private->hwdep_in_use) {
5838 		err = -EBUSY;
5839 		goto unlock;
5840 	}
5841 
5842 	if (private->input_mute_updated) {
5843 		err = scarlett2_update_input_mute(mixer);
5844 		if (err < 0)
5845 			goto unlock;
5846 	}
5847 	ucontrol->value.integer.value[0] =
5848 		private->input_mute_switch[elem->control];
5849 
5850 unlock:
5851 	mutex_unlock(&private->data_mutex);
5852 	return err;
5853 }
5854 
scarlett2_input_mute_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5855 static int scarlett2_input_mute_ctl_put(struct snd_kcontrol *kctl,
5856 					struct snd_ctl_elem_value *ucontrol)
5857 {
5858 	struct usb_mixer_elem_info *elem = kctl->private_data;
5859 	struct usb_mixer_interface *mixer = elem->head.mixer;
5860 	struct scarlett2_data *private = mixer->private_data;
5861 
5862 	int index = elem->control;
5863 	int oval, val, err;
5864 
5865 	mutex_lock(&private->data_mutex);
5866 
5867 	if (private->hwdep_in_use) {
5868 		err = -EBUSY;
5869 		goto unlock;
5870 	}
5871 
5872 	err = scarlett2_check_put_during_autogain(mixer);
5873 	if (err < 0)
5874 		goto unlock;
5875 
5876 	oval = private->input_mute_switch[index];
5877 	val = ucontrol->value.integer.value[0];
5878 
5879 	if (oval == val)
5880 		goto unlock;
5881 
5882 	private->input_mute_switch[index] = val;
5883 
5884 	/* Send switch change to the device */
5885 	err = scarlett2_usb_set_config(
5886 		mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5887 			index, val);
5888 	if (err == 0)
5889 		err = 1;
5890 
5891 unlock:
5892 	mutex_unlock(&private->data_mutex);
5893 	return err;
5894 }
5895 
5896 static const struct snd_kcontrol_new scarlett2_input_mute_ctl = {
5897 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5898 	.name = "",
5899 	.info = scarlett2_autogain_disables_ctl_info,
5900 	.get  = scarlett2_input_mute_ctl_get,
5901 	.put  = scarlett2_input_mute_ctl_put,
5902 };
5903 
5904 /*** Phantom Switch Controls ***/
5905 
scarlett2_update_input_phantom(struct usb_mixer_interface * mixer)5906 static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer)
5907 {
5908 	struct scarlett2_data *private = mixer->private_data;
5909 	const struct scarlett2_device_info *info = private->info;
5910 	int err;
5911 
5912 	private->input_phantom_updated = 0;
5913 
5914 	if (!info->phantom_count)
5915 		return 0;
5916 
5917 	err = scarlett2_usb_get_config(
5918 		mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5919 		info->phantom_count, private->phantom_switch);
5920 	if (err < 0)
5921 		return err;
5922 
5923 	if (scarlett2_has_config_item(private,
5924 				      SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {
5925 		err = scarlett2_usb_get_config(
5926 			mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
5927 			1, &private->phantom_persistence);
5928 		if (err < 0)
5929 			return err;
5930 	}
5931 
5932 	return 0;
5933 }
5934 
5935 /* Check if phantom power on the given input is currently changing state */
scarlett2_phantom_is_switching(struct scarlett2_data * private,int line_num)5936 static int scarlett2_phantom_is_switching(
5937 	struct scarlett2_data *private, int line_num)
5938 {
5939 	const struct scarlett2_device_info *info = private->info;
5940 	int index = line_num / info->inputs_per_phantom;
5941 
5942 	return !!(private->phantom_switch[index] & 0x02);
5943 }
5944 
5945 /* Update autogain controls' access mode when phantom power changes state */
scarlett2_phantom_update_access(struct usb_mixer_interface * mixer)5946 static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)
5947 {
5948 	struct scarlett2_data *private = mixer->private_data;
5949 	const struct scarlett2_device_info *info = private->info;
5950 	int i;
5951 
5952 	/* Disable autogain controls if phantom power is changing state */
5953 	for (i = 0; i < info->gain_input_count; i++) {
5954 		int val = !scarlett2_phantom_is_switching(private, i);
5955 
5956 		scarlett2_set_ctl_access(private->autogain_ctls[i], val);
5957 	}
5958 }
5959 
5960 /* Notify of access mode change for autogain which can't be enabled
5961  * while phantom power is changing.
5962  */
scarlett2_phantom_notify_access(struct usb_mixer_interface * mixer)5963 static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer)
5964 {
5965 	struct snd_card *card = mixer->chip->card;
5966 	struct scarlett2_data *private = mixer->private_data;
5967 	const struct scarlett2_device_info *info = private->info;
5968 	int i;
5969 
5970 	for (i = 0; i < info->gain_input_count; i++)
5971 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
5972 			       &private->autogain_ctls[i]->id);
5973 }
5974 
5975 /* Call scarlett2_update_input_phantom() and
5976  * scarlett2_phantom_update_access() if input_phantom_updated is set.
5977  */
scarlett2_check_input_phantom_updated(struct usb_mixer_interface * mixer)5978 static int scarlett2_check_input_phantom_updated(
5979 	struct usb_mixer_interface *mixer)
5980 {
5981 	struct scarlett2_data *private = mixer->private_data;
5982 	int err;
5983 
5984 	if (!private->input_phantom_updated)
5985 		return 0;
5986 
5987 	err = scarlett2_update_input_phantom(mixer);
5988 	if (err < 0)
5989 		return err;
5990 
5991 	scarlett2_phantom_update_access(mixer);
5992 
5993 	return 0;
5994 }
5995 
scarlett2_phantom_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)5996 static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
5997 				     struct snd_ctl_elem_value *ucontrol)
5998 {
5999 	struct usb_mixer_elem_info *elem = kctl->private_data;
6000 	struct usb_mixer_interface *mixer = elem->head.mixer;
6001 	struct scarlett2_data *private = mixer->private_data;
6002 	int err;
6003 
6004 	mutex_lock(&private->data_mutex);
6005 
6006 	if (private->hwdep_in_use) {
6007 		err = -EBUSY;
6008 		goto unlock;
6009 	}
6010 
6011 	err = scarlett2_check_input_phantom_updated(mixer);
6012 	if (err < 0)
6013 		goto unlock;
6014 
6015 	ucontrol->value.integer.value[0] = scarlett2_decode_muteable(
6016 		private->phantom_switch[elem->control]);
6017 
6018 unlock:
6019 	mutex_unlock(&private->data_mutex);
6020 	return err;
6021 }
6022 
scarlett2_phantom_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6023 static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
6024 				     struct snd_ctl_elem_value *ucontrol)
6025 {
6026 	struct usb_mixer_elem_info *elem = kctl->private_data;
6027 	struct usb_mixer_interface *mixer = elem->head.mixer;
6028 	struct scarlett2_data *private = mixer->private_data;
6029 	const struct scarlett2_device_info *info = private->info;
6030 
6031 	int index = elem->control;
6032 	int oval, val, err;
6033 
6034 	mutex_lock(&private->data_mutex);
6035 
6036 	if (private->hwdep_in_use) {
6037 		err = -EBUSY;
6038 		goto unlock;
6039 	}
6040 
6041 	err = scarlett2_check_put_during_autogain(mixer);
6042 	if (err < 0)
6043 		goto unlock;
6044 
6045 	oval = private->phantom_switch[index];
6046 	val = !!ucontrol->value.integer.value[0];
6047 
6048 	if (oval == val)
6049 		goto unlock;
6050 
6051 	private->phantom_switch[index] = val;
6052 
6053 	/* To set the Gen 4 muteable controls, bit 1 gets set */
6054 	if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)
6055 		val = (!val) | 0x02;
6056 
6057 	/* Send switch change to the device */
6058 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
6059 				       index + info->phantom_first, val);
6060 	if (err == 0)
6061 		err = 1;
6062 
6063 	scarlett2_phantom_update_access(mixer);
6064 	scarlett2_phantom_notify_access(mixer);
6065 
6066 unlock:
6067 	mutex_unlock(&private->data_mutex);
6068 	return err;
6069 }
6070 
6071 static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
6072 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6073 	.name = "",
6074 	.info = scarlett2_autogain_disables_ctl_info,
6075 	.get  = scarlett2_phantom_ctl_get,
6076 	.put  = scarlett2_phantom_ctl_put,
6077 };
6078 
6079 /*** Phantom Persistence Control ***/
6080 
scarlett2_phantom_persistence_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6081 static int scarlett2_phantom_persistence_ctl_get(
6082 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6083 {
6084 	struct usb_mixer_elem_info *elem = kctl->private_data;
6085 	struct scarlett2_data *private = elem->head.mixer->private_data;
6086 
6087 	ucontrol->value.integer.value[0] = private->phantom_persistence;
6088 	return 0;
6089 }
6090 
scarlett2_phantom_persistence_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6091 static int scarlett2_phantom_persistence_ctl_put(
6092 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6093 {
6094 	struct usb_mixer_elem_info *elem = kctl->private_data;
6095 	struct usb_mixer_interface *mixer = elem->head.mixer;
6096 	struct scarlett2_data *private = mixer->private_data;
6097 
6098 	int index = elem->control;
6099 	int oval, val, err = 0;
6100 
6101 	mutex_lock(&private->data_mutex);
6102 
6103 	if (private->hwdep_in_use) {
6104 		err = -EBUSY;
6105 		goto unlock;
6106 	}
6107 
6108 	oval = private->phantom_persistence;
6109 	val = !!ucontrol->value.integer.value[0];
6110 
6111 	if (oval == val)
6112 		goto unlock;
6113 
6114 	private->phantom_persistence = val;
6115 
6116 	/* Send switch change to the device */
6117 	err = scarlett2_usb_set_config(
6118 		mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
6119 	if (err == 0)
6120 		err = 1;
6121 
6122 unlock:
6123 	mutex_unlock(&private->data_mutex);
6124 	return err;
6125 }
6126 
6127 static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
6128 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6129 	.name = "",
6130 	.info = snd_ctl_boolean_mono_info,
6131 	.get  = scarlett2_phantom_persistence_ctl_get,
6132 	.put  = scarlett2_phantom_persistence_ctl_put,
6133 };
6134 
6135 /*** Speaker Switching Control ***/
6136 
scarlett2_update_monitor_other(struct usb_mixer_interface * mixer)6137 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
6138 {
6139 	struct scarlett2_data *private = mixer->private_data;
6140 	const struct scarlett2_device_info *info = private->info;
6141 	int err;
6142 
6143 	/* monitor_other_enable[0] enables speaker switching
6144 	 * monitor_other_enable[1] enables talkback
6145 	 */
6146 	u8 monitor_other_enable[2];
6147 
6148 	/* monitor_other_switch[0] activates the alternate speakers
6149 	 * monitor_other_switch[1] activates talkback
6150 	 */
6151 	u8 monitor_other_switch[2];
6152 
6153 	private->monitor_other_updated = 0;
6154 
6155 	/* if it doesn't do speaker switching then it also doesn't do
6156 	 * talkback
6157 	 */
6158 	if (!info->has_speaker_switching)
6159 		return 0;
6160 
6161 	err = scarlett2_usb_get_config(
6162 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6163 		2, monitor_other_enable);
6164 	if (err < 0)
6165 		return err;
6166 
6167 	err = scarlett2_usb_get_config(
6168 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6169 		2, monitor_other_switch);
6170 	if (err < 0)
6171 		return err;
6172 
6173 	if (!monitor_other_enable[0])
6174 		private->speaker_switching_switch = 0;
6175 	else
6176 		private->speaker_switching_switch = monitor_other_switch[0] + 1;
6177 
6178 	if (info->has_talkback) {
6179 		u16 bitmap;
6180 		int i;
6181 
6182 		if (!monitor_other_enable[1])
6183 			private->talkback_switch = 0;
6184 		else
6185 			private->talkback_switch = monitor_other_switch[1] + 1;
6186 
6187 		err = scarlett2_usb_get_config(mixer,
6188 					       SCARLETT2_CONFIG_TALKBACK_MAP,
6189 					       1, &bitmap);
6190 		if (err < 0)
6191 			return err;
6192 		for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)
6193 			private->talkback_map[i] = bitmap & 1;
6194 	}
6195 
6196 	return 0;
6197 }
6198 
scarlett2_speaker_switch_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)6199 static int scarlett2_speaker_switch_enum_ctl_info(
6200 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
6201 {
6202 	static const char *const values[3] = {
6203 		"Off", "Main", "Alt"
6204 	};
6205 
6206 	return snd_ctl_enum_info(uinfo, 1, 3, values);
6207 }
6208 
scarlett2_speaker_switch_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6209 static int scarlett2_speaker_switch_enum_ctl_get(
6210 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6211 {
6212 	struct usb_mixer_elem_info *elem = kctl->private_data;
6213 	struct usb_mixer_interface *mixer = elem->head.mixer;
6214 	struct scarlett2_data *private = mixer->private_data;
6215 	int err = 0;
6216 
6217 	mutex_lock(&private->data_mutex);
6218 
6219 	if (private->hwdep_in_use) {
6220 		err = -EBUSY;
6221 		goto unlock;
6222 	}
6223 
6224 	if (private->monitor_other_updated) {
6225 		err = scarlett2_update_monitor_other(mixer);
6226 		if (err < 0)
6227 			goto unlock;
6228 	}
6229 	ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
6230 
6231 unlock:
6232 	mutex_unlock(&private->data_mutex);
6233 	return err;
6234 }
6235 
6236 /* when speaker switching gets enabled, switch the main/alt speakers
6237  * to HW volume and disable those controls
6238  */
scarlett2_speaker_switch_enable(struct usb_mixer_interface * mixer)6239 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
6240 {
6241 	struct snd_card *card = mixer->chip->card;
6242 	struct scarlett2_data *private = mixer->private_data;
6243 	int i, err;
6244 
6245 	for (i = 0; i < 4; i++) {
6246 		int index = line_out_remap(private, i);
6247 
6248 		/* switch the main/alt speakers to HW volume */
6249 		if (!private->vol_sw_hw_switch[index]) {
6250 			err = scarlett2_sw_hw_change(private->mixer, i, 1);
6251 			if (err < 0)
6252 				return err;
6253 		}
6254 
6255 		/* disable the line out SW/HW switch */
6256 		scarlett2_sw_hw_ctl_ro(private, i);
6257 		snd_ctl_notify(card,
6258 			       SNDRV_CTL_EVENT_MASK_VALUE |
6259 				 SNDRV_CTL_EVENT_MASK_INFO,
6260 			       &private->sw_hw_ctls[i]->id);
6261 	}
6262 
6263 	/* when the next monitor-other notify comes in, update the mux
6264 	 * configuration
6265 	 */
6266 	private->speaker_switching_switched = 1;
6267 
6268 	return 0;
6269 }
6270 
6271 /* when speaker switching gets disabled, reenable the hw/sw controls
6272  * and invalidate the routing
6273  */
scarlett2_speaker_switch_disable(struct usb_mixer_interface * mixer)6274 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
6275 {
6276 	struct snd_card *card = mixer->chip->card;
6277 	struct scarlett2_data *private = mixer->private_data;
6278 	int i;
6279 
6280 	/* enable the line out SW/HW switch */
6281 	for (i = 0; i < 4; i++) {
6282 		scarlett2_sw_hw_ctl_rw(private, i);
6283 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
6284 			       &private->sw_hw_ctls[i]->id);
6285 	}
6286 
6287 	/* when the next monitor-other notify comes in, update the mux
6288 	 * configuration
6289 	 */
6290 	private->speaker_switching_switched = 1;
6291 }
6292 
scarlett2_speaker_switch_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6293 static int scarlett2_speaker_switch_enum_ctl_put(
6294 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6295 {
6296 	struct usb_mixer_elem_info *elem = kctl->private_data;
6297 	struct usb_mixer_interface *mixer = elem->head.mixer;
6298 	struct scarlett2_data *private = mixer->private_data;
6299 
6300 	int oval, val, err = 0;
6301 
6302 	mutex_lock(&private->data_mutex);
6303 
6304 	if (private->hwdep_in_use) {
6305 		err = -EBUSY;
6306 		goto unlock;
6307 	}
6308 
6309 	oval = private->speaker_switching_switch;
6310 	val = min(ucontrol->value.enumerated.item[0], 2U);
6311 
6312 	if (oval == val)
6313 		goto unlock;
6314 
6315 	private->speaker_switching_switch = val;
6316 
6317 	/* enable/disable speaker switching */
6318 	err = scarlett2_usb_set_config(
6319 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6320 		0, !!val);
6321 	if (err < 0)
6322 		goto unlock;
6323 
6324 	/* if speaker switching is enabled, select main or alt */
6325 	err = scarlett2_usb_set_config(
6326 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6327 		0, val == 2);
6328 	if (err < 0)
6329 		goto unlock;
6330 
6331 	/* update controls if speaker switching gets enabled or disabled */
6332 	if (!oval && val)
6333 		err = scarlett2_speaker_switch_enable(mixer);
6334 	else if (oval && !val)
6335 		scarlett2_speaker_switch_disable(mixer);
6336 
6337 	if (err == 0)
6338 		err = 1;
6339 
6340 unlock:
6341 	mutex_unlock(&private->data_mutex);
6342 	return err;
6343 }
6344 
6345 static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
6346 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6347 	.name = "",
6348 	.info = scarlett2_speaker_switch_enum_ctl_info,
6349 	.get  = scarlett2_speaker_switch_enum_ctl_get,
6350 	.put  = scarlett2_speaker_switch_enum_ctl_put,
6351 };
6352 
scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface * mixer)6353 static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer)
6354 {
6355 	struct scarlett2_data *private = mixer->private_data;
6356 	const struct scarlett2_device_info *info = private->info;
6357 
6358 	if (!info->has_speaker_switching)
6359 		return 0;
6360 
6361 	return scarlett2_add_new_ctl(
6362 		mixer, &scarlett2_speaker_switch_enum_ctl,
6363 		0, 1, "Speaker Switching Playback Enum",
6364 		&private->speaker_switching_ctl);
6365 }
6366 
6367 /*** Talkback and Talkback Map Controls ***/
6368 
scarlett2_talkback_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)6369 static int scarlett2_talkback_enum_ctl_info(
6370 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
6371 {
6372 	static const char *const values[3] = {
6373 		"Disabled", "Off", "On"
6374 	};
6375 
6376 	return snd_ctl_enum_info(uinfo, 1, 3, values);
6377 }
6378 
scarlett2_talkback_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6379 static int scarlett2_talkback_enum_ctl_get(
6380 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6381 {
6382 	struct usb_mixer_elem_info *elem = kctl->private_data;
6383 	struct usb_mixer_interface *mixer = elem->head.mixer;
6384 	struct scarlett2_data *private = mixer->private_data;
6385 	int err = 0;
6386 
6387 	mutex_lock(&private->data_mutex);
6388 
6389 	if (private->hwdep_in_use) {
6390 		err = -EBUSY;
6391 		goto unlock;
6392 	}
6393 
6394 	if (private->monitor_other_updated) {
6395 		err = scarlett2_update_monitor_other(mixer);
6396 		if (err < 0)
6397 			goto unlock;
6398 	}
6399 	ucontrol->value.enumerated.item[0] = private->talkback_switch;
6400 
6401 unlock:
6402 	mutex_unlock(&private->data_mutex);
6403 	return err;
6404 }
6405 
scarlett2_talkback_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6406 static int scarlett2_talkback_enum_ctl_put(
6407 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6408 {
6409 	struct usb_mixer_elem_info *elem = kctl->private_data;
6410 	struct usb_mixer_interface *mixer = elem->head.mixer;
6411 	struct scarlett2_data *private = mixer->private_data;
6412 
6413 	int oval, val, err = 0;
6414 
6415 	mutex_lock(&private->data_mutex);
6416 
6417 	if (private->hwdep_in_use) {
6418 		err = -EBUSY;
6419 		goto unlock;
6420 	}
6421 
6422 	oval = private->talkback_switch;
6423 	val = min(ucontrol->value.enumerated.item[0], 2U);
6424 
6425 	if (oval == val)
6426 		goto unlock;
6427 
6428 	private->talkback_switch = val;
6429 
6430 	/* enable/disable talkback */
6431 	err = scarlett2_usb_set_config(
6432 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6433 		1, !!val);
6434 	if (err < 0)
6435 		goto unlock;
6436 
6437 	/* if talkback is enabled, select main or alt */
6438 	err = scarlett2_usb_set_config(
6439 		mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6440 		1, val == 2);
6441 	if (err == 0)
6442 		err = 1;
6443 
6444 unlock:
6445 	mutex_unlock(&private->data_mutex);
6446 	return err;
6447 }
6448 
6449 static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
6450 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6451 	.name = "",
6452 	.info = scarlett2_talkback_enum_ctl_info,
6453 	.get  = scarlett2_talkback_enum_ctl_get,
6454 	.put  = scarlett2_talkback_enum_ctl_put,
6455 };
6456 
scarlett2_talkback_map_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6457 static int scarlett2_talkback_map_ctl_get(
6458 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6459 {
6460 	struct usb_mixer_elem_info *elem = kctl->private_data;
6461 	struct usb_mixer_interface *mixer = elem->head.mixer;
6462 	struct scarlett2_data *private = mixer->private_data;
6463 	int index = elem->control;
6464 
6465 	ucontrol->value.integer.value[0] = private->talkback_map[index];
6466 
6467 	return 0;
6468 }
6469 
scarlett2_talkback_map_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6470 static int scarlett2_talkback_map_ctl_put(
6471 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
6472 {
6473 	struct usb_mixer_elem_info *elem = kctl->private_data;
6474 	struct usb_mixer_interface *mixer = elem->head.mixer;
6475 	struct scarlett2_data *private = mixer->private_data;
6476 	int index = elem->control;
6477 	int oval, val, err = 0, i;
6478 	u16 bitmap = 0;
6479 
6480 	mutex_lock(&private->data_mutex);
6481 
6482 	if (private->hwdep_in_use) {
6483 		err = -EBUSY;
6484 		goto unlock;
6485 	}
6486 
6487 	oval = private->talkback_map[index];
6488 	val = !!ucontrol->value.integer.value[0];
6489 
6490 	if (oval == val)
6491 		goto unlock;
6492 
6493 	private->talkback_map[index] = val;
6494 
6495 	for (i = 0; i < private->num_mix_out; i++)
6496 		bitmap |= private->talkback_map[i] << i;
6497 
6498 	/* Send updated bitmap to the device */
6499 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
6500 				       0, bitmap);
6501 	if (err == 0)
6502 		err = 1;
6503 
6504 unlock:
6505 	mutex_unlock(&private->data_mutex);
6506 	return err;
6507 }
6508 
6509 static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
6510 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6511 	.name = "",
6512 	.info = snd_ctl_boolean_mono_info,
6513 	.get  = scarlett2_talkback_map_ctl_get,
6514 	.put  = scarlett2_talkback_map_ctl_put,
6515 };
6516 
scarlett2_add_talkback_ctls(struct usb_mixer_interface * mixer)6517 static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer)
6518 {
6519 	struct scarlett2_data *private = mixer->private_data;
6520 	const struct scarlett2_device_info *info = private->info;
6521 	int err, i;
6522 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
6523 
6524 	if (!info->has_talkback)
6525 		return 0;
6526 
6527 	err = scarlett2_add_new_ctl(
6528 		mixer, &scarlett2_talkback_enum_ctl,
6529 		0, 1, "Talkback Playback Enum",
6530 		&private->talkback_ctl);
6531 	if (err < 0)
6532 		return err;
6533 
6534 	for (i = 0; i < private->num_mix_out; i++) {
6535 		snprintf(s, sizeof(s),
6536 			 "Talkback Mix %c Playback Switch", i + 'A');
6537 		err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
6538 					    i, 1, s, NULL);
6539 		if (err < 0)
6540 			return err;
6541 	}
6542 
6543 	return 0;
6544 }
6545 
6546 /*** Dim/Mute Controls ***/
6547 
scarlett2_dim_mute_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6548 static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
6549 				      struct snd_ctl_elem_value *ucontrol)
6550 {
6551 	struct usb_mixer_elem_info *elem = kctl->private_data;
6552 	struct usb_mixer_interface *mixer = elem->head.mixer;
6553 	struct scarlett2_data *private = mixer->private_data;
6554 	int err = 0;
6555 
6556 	mutex_lock(&private->data_mutex);
6557 
6558 	if (private->hwdep_in_use) {
6559 		err = -EBUSY;
6560 		goto unlock;
6561 	}
6562 
6563 	if (private->dim_mute_updated) {
6564 		err = scarlett2_update_dim_mute(mixer);
6565 		if (err < 0)
6566 			goto unlock;
6567 	}
6568 	ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
6569 
6570 unlock:
6571 	mutex_unlock(&private->data_mutex);
6572 	return err;
6573 }
6574 
scarlett2_dim_mute_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)6575 static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
6576 				      struct snd_ctl_elem_value *ucontrol)
6577 {
6578 	struct usb_mixer_elem_info *elem = kctl->private_data;
6579 	struct usb_mixer_interface *mixer = elem->head.mixer;
6580 	struct scarlett2_data *private = mixer->private_data;
6581 	int index = elem->control;
6582 	int oval, val, err = 0, i;
6583 
6584 	mutex_lock(&private->data_mutex);
6585 
6586 	if (private->hwdep_in_use) {
6587 		err = -EBUSY;
6588 		goto unlock;
6589 	}
6590 
6591 	oval = private->dim_mute[index];
6592 	val = !!ucontrol->value.integer.value[0];
6593 
6594 	if (oval == val)
6595 		goto unlock;
6596 
6597 	private->dim_mute[index] = val;
6598 
6599 	/* Send switch change to the device */
6600 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
6601 				       index, val);
6602 	if (err == 0)
6603 		err = 1;
6604 
6605 	if (index == SCARLETT2_BUTTON_MUTE)
6606 		for (i = 0; i < private->num_line_out; i++) {
6607 			int line_index = line_out_remap(private, i);
6608 
6609 			if (private->vol_sw_hw_switch[line_index]) {
6610 				private->mute_switch[line_index] = val;
6611 				snd_ctl_notify(mixer->chip->card,
6612 					       SNDRV_CTL_EVENT_MASK_VALUE,
6613 					       &private->mute_ctls[i]->id);
6614 			}
6615 		}
6616 
6617 unlock:
6618 	mutex_unlock(&private->data_mutex);
6619 	return err;
6620 }
6621 
6622 static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
6623 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6624 	.name = "",
6625 	.info = snd_ctl_boolean_mono_info,
6626 	.get  = scarlett2_dim_mute_ctl_get,
6627 	.put  = scarlett2_dim_mute_ctl_put
6628 };
6629 
6630 /*** Create the analogue output controls ***/
6631 
scarlett2_add_line_out_ctls(struct usb_mixer_interface * mixer)6632 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
6633 {
6634 	struct scarlett2_data *private = mixer->private_data;
6635 	const struct scarlett2_device_info *info = private->info;
6636 	int err, i;
6637 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
6638 
6639 	/* Add R/O HW volume control */
6640 	if (scarlett2_has_config_item(private,
6641 				      SCARLETT2_CONFIG_MASTER_VOLUME)) {
6642 		snprintf(s, sizeof(s), "Master HW Playback Volume");
6643 		err = scarlett2_add_new_ctl(mixer,
6644 					    &scarlett2_master_volume_ctl,
6645 					    0, 1, s, &private->master_vol_ctl);
6646 		if (err < 0)
6647 			return err;
6648 	}
6649 
6650 	/* Add R/O headphone volume control */
6651 	if (scarlett2_has_config_item(private,
6652 				      SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {
6653 		snprintf(s, sizeof(s), "Headphone Playback Volume");
6654 		err = scarlett2_add_new_ctl(mixer,
6655 					    &scarlett2_headphone_volume_ctl,
6656 					    0, 1, s,
6657 					    &private->headphone_vol_ctl);
6658 		if (err < 0)
6659 			return err;
6660 	}
6661 
6662 	/* Remaining controls are only applicable if the device
6663 	 * has per-channel line-out volume controls.
6664 	 */
6665 	if (!scarlett2_has_config_item(private,
6666 				       SCARLETT2_CONFIG_LINE_OUT_VOLUME))
6667 		return 0;
6668 
6669 	/* Add volume controls */
6670 	for (i = 0; i < private->num_line_out; i++) {
6671 		int index = line_out_remap(private, i);
6672 
6673 		/* Fader */
6674 		if (info->line_out_descrs[i])
6675 			snprintf(s, sizeof(s),
6676 				 "Line %02d (%s) Playback Volume",
6677 				 i + 1, info->line_out_descrs[i]);
6678 		else
6679 			snprintf(s, sizeof(s),
6680 				 "Line %02d Playback Volume",
6681 				 i + 1);
6682 		err = scarlett2_add_new_ctl(mixer,
6683 					    &scarlett2_line_out_volume_ctl,
6684 					    i, 1, s, &private->vol_ctls[i]);
6685 		if (err < 0)
6686 			return err;
6687 
6688 		/* Mute Switch */
6689 		snprintf(s, sizeof(s),
6690 			 "Line %02d Mute Playback Switch",
6691 			 i + 1);
6692 		err = scarlett2_add_new_ctl(mixer,
6693 					    &scarlett2_mute_ctl,
6694 					    i, 1, s,
6695 					    &private->mute_ctls[i]);
6696 		if (err < 0)
6697 			return err;
6698 
6699 		/* SW/HW Switch */
6700 		if (scarlett2_has_config_item(private,
6701 					      SCARLETT2_CONFIG_SW_HW_SWITCH)) {
6702 
6703 			/* Make the fader and mute controls read-only if the
6704 			 * SW/HW switch is set to HW
6705 			 */
6706 			if (private->vol_sw_hw_switch[index])
6707 				scarlett2_vol_ctl_set_writable(mixer, i, 0);
6708 
6709 			scnprintf(s, sizeof(s),
6710 				  "Line Out %02d Volume Control Playback Enum",
6711 				  i + 1);
6712 			err = scarlett2_add_new_ctl(mixer,
6713 						    &scarlett2_sw_hw_enum_ctl,
6714 						    i, 1, s,
6715 						    &private->sw_hw_ctls[i]);
6716 			if (err < 0)
6717 				return err;
6718 
6719 			/* Make the switch read-only if the line is
6720 			 * involved in speaker switching
6721 			 */
6722 			if (private->speaker_switching_switch && i < 4)
6723 				scarlett2_sw_hw_ctl_ro(private, i);
6724 		}
6725 	}
6726 
6727 	/* Add dim/mute controls */
6728 	if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_DIM_MUTE))
6729 		for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
6730 			err = scarlett2_add_new_ctl(
6731 				mixer, &scarlett2_dim_mute_ctl,
6732 				i, 1, scarlett2_dim_mute_names[i],
6733 				&private->dim_mute_ctls[i]);
6734 			if (err < 0)
6735 				return err;
6736 		}
6737 
6738 	return 0;
6739 }
6740 
6741 /*** Create the analogue input controls ***/
6742 
scarlett2_add_dsp_ctls(struct usb_mixer_interface * mixer,int i)6743 static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i)
6744 {
6745 	struct scarlett2_data *private = mixer->private_data;
6746 	const struct scarlett2_device_info *info = private->info;
6747 	int j, err;
6748 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
6749 	const char *compr_fmt = "Line In %d Compressor %s";
6750 	const char *flt_switch_fmt = "Line In %d %s Filter Enable";
6751 	const char *flt_fmt = "Line In %d %s Coefficients %d";
6752 
6753 	/* Add compressor controls */
6754 	for (j = 0; j < SCARLETT2_COMPRESSOR_PARAM_COUNT; j++) {
6755 		const struct compressor_param *param = &compressor_params[j];
6756 		int idx = i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j;
6757 
6758 		scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name);
6759 		err = scarlett2_add_new_ctl(
6760 			mixer, &scarlett2_compressor_ctl,
6761 			i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j,
6762 			1, s, &private->compressor_ctls[idx]);
6763 		if (err < 0)
6764 			return err;
6765 	}
6766 
6767 	/* Add filter enable controls */
6768 	scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp");
6769 	err = scarlett2_add_new_ctl(
6770 		mixer, &scarlett2_precomp_flt_switch_ctl,
6771 		i, 1, s, &private->precomp_flt_switch_ctls[i]);
6772 	if (err < 0)
6773 		return err;
6774 
6775 	scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "PEQ");
6776 	err = scarlett2_add_new_ctl(
6777 		mixer, &scarlett2_peq_flt_switch_ctl,
6778 		i, 1, s, &private->peq_flt_switch_ctls[i]);
6779 	if (err < 0)
6780 		return err;
6781 
6782 	/* Add filter coefficient controls */
6783 	for (j = 0; j < info->precomp_flt_count; j++) {
6784 		scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1);
6785 		err = scarlett2_add_new_ctl(
6786 			mixer, &scarlett2_precomp_flt_ctl,
6787 			i * info->precomp_flt_count + j,
6788 			1, s, &private->precomp_flt_switch_ctls[j]);
6789 		if (err < 0)
6790 			return err;
6791 	}
6792 
6793 	for (j = 0; j < info->peq_flt_count; j++) {
6794 		scnprintf(s, sizeof(s), flt_fmt, i + 1, "PEQ", j + 1);
6795 		err = scarlett2_add_new_ctl(
6796 			mixer, &scarlett2_peq_flt_ctl,
6797 			i * info->peq_flt_count + j,
6798 			1, s, &private->peq_flt_switch_ctls[j]);
6799 		if (err < 0)
6800 			return err;
6801 	}
6802 
6803 	return 0;
6804 }
6805 
scarlett2_add_line_in_ctls(struct usb_mixer_interface * mixer)6806 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
6807 {
6808 	struct scarlett2_data *private = mixer->private_data;
6809 	const struct scarlett2_device_info *info = private->info;
6810 	int err, i;
6811 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
6812 	const char *fmt = "Line In %d %s Capture %s";
6813 	const char *fmt2 = "Line In %d-%d %s Capture %s";
6814 
6815 	/* Add input level (line/inst) controls */
6816 	for (i = 0; i < info->level_input_count; i++) {
6817 		scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
6818 			  "Level", "Enum");
6819 		err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
6820 					    i, 1, s, &private->level_ctls[i]);
6821 		if (err < 0)
6822 			return err;
6823 	}
6824 
6825 	/* Add input pad controls */
6826 	for (i = 0; i < info->pad_input_count; i++) {
6827 		scnprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
6828 		err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
6829 					    i, 1, s, &private->pad_ctls[i]);
6830 		if (err < 0)
6831 			return err;
6832 	}
6833 
6834 	/* Add input air controls */
6835 	for (i = 0; i < info->air_input_count; i++) {
6836 		scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,
6837 			  "Air", info->air_option ? "Enum" : "Switch");
6838 		err = scarlett2_add_new_ctl(
6839 			mixer, &scarlett2_air_ctl[info->air_option],
6840 			i, 1, s, &private->air_ctls[i]);
6841 		if (err < 0)
6842 			return err;
6843 	}
6844 
6845 	/* Add input DSP controls */
6846 	for (i = 0; i < info->dsp_input_count; i++) {
6847 		scnprintf(s, sizeof(s), fmt, i + 1, "DSP", "Switch");
6848 		err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl,
6849 					    i, 1, s, &private->dsp_ctls[i]);
6850 		if (err < 0)
6851 			return err;
6852 
6853 		err = scarlett2_add_dsp_ctls(mixer, i);
6854 		if (err < 0)
6855 			return err;
6856 	}
6857 
6858 	/* Add input mute controls */
6859 	for (i = 0; i < info->mute_input_count; i++) {
6860 		scnprintf(s, sizeof(s), fmt, i + 1, "Mute", "Switch");
6861 		err = scarlett2_add_new_ctl(
6862 			mixer, &scarlett2_input_mute_ctl,
6863 			i, 1, s, &private->input_mute_ctls[i]);
6864 		if (err < 0)
6865 			return err;
6866 	}
6867 
6868 	/* Add input phantom controls */
6869 	if (info->inputs_per_phantom == 1) {
6870 		for (i = 0; i < info->phantom_count; i++) {
6871 			scnprintf(s, sizeof(s), fmt,
6872 				  i + 1 + info->phantom_first,
6873 				  "Phantom Power", "Switch");
6874 			err = scarlett2_add_new_ctl(
6875 				mixer, &scarlett2_phantom_ctl,
6876 				i, 1, s, &private->phantom_ctls[i]);
6877 			if (err < 0)
6878 				return err;
6879 		}
6880 	} else if (info->inputs_per_phantom > 1) {
6881 		for (i = 0; i < info->phantom_count; i++) {
6882 			int from = i * info->inputs_per_phantom + 1;
6883 			int to = (i + 1) * info->inputs_per_phantom;
6884 
6885 			scnprintf(s, sizeof(s), fmt2, from, to,
6886 				  "Phantom Power", "Switch");
6887 			err = scarlett2_add_new_ctl(
6888 				mixer, &scarlett2_phantom_ctl,
6889 				i, 1, s, &private->phantom_ctls[i]);
6890 			if (err < 0)
6891 				return err;
6892 		}
6893 	}
6894 	if (info->phantom_count &&
6895 	    scarlett2_has_config_item(private,
6896 				      SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {
6897 		err = scarlett2_add_new_ctl(
6898 			mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
6899 			"Phantom Power Persistence Capture Switch", NULL);
6900 		if (err < 0)
6901 			return err;
6902 	}
6903 
6904 	/* Add input select/link controls */
6905 	if (scarlett2_has_config_item(private,
6906 				      SCARLETT2_CONFIG_INPUT_SELECT_SWITCH)) {
6907 		err = scarlett2_add_new_ctl(
6908 			mixer, &scarlett2_input_select_ctl, 0, 1,
6909 			"Input Select Capture Enum",
6910 			&private->input_select_ctl);
6911 		if (err < 0)
6912 			return err;
6913 	}
6914 
6915 	if (scarlett2_has_config_item(private,
6916 				      SCARLETT2_CONFIG_INPUT_LINK_SWITCH)) {
6917 		for (i = 0; i < info->gain_input_count / 2; i++) {
6918 			scnprintf(s, sizeof(s),
6919 				  "Line In %d-%d Link Capture Switch",
6920 				  (i * 2) + 1, (i * 2) + 2);
6921 			err = scarlett2_add_new_ctl(
6922 				mixer, &scarlett2_input_link_ctl,
6923 				i, 1, s, &private->input_link_ctls[i]);
6924 			if (err < 0)
6925 				return err;
6926 		}
6927 	}
6928 
6929 	/* Add software-controllable input gain controls */
6930 	for (i = 0; i < info->gain_input_count; i++) {
6931 		scnprintf(s, sizeof(s), fmt, i + 1,
6932 			  "Gain", "Volume");
6933 		err = scarlett2_add_new_ctl(
6934 			mixer, &scarlett2_input_gain_ctl,
6935 			i, 1, s, &private->input_gain_ctls[i]);
6936 		if (err < 0)
6937 			return err;
6938 		private->input_gain_ctls[i]->tlv.p =
6939 			private->config_set->input_gain_tlv;
6940 
6941 		scnprintf(s, sizeof(s), fmt, i + 1,
6942 			  "Autogain", "Switch");
6943 		err = scarlett2_add_new_ctl(
6944 			mixer, &scarlett2_autogain_switch_ctl,
6945 			i, 1, s, &private->autogain_ctls[i]);
6946 		if (err < 0)
6947 			return err;
6948 
6949 		scnprintf(s, sizeof(s), fmt, i + 1,
6950 			  "Autogain Status", "Enum");
6951 		err = scarlett2_add_new_ctl(
6952 			mixer, &scarlett2_autogain_status_ctl,
6953 			i, 1, s, &private->autogain_status_ctls[i]);
6954 	}
6955 
6956 	/* Add autogain target controls */
6957 	for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
6958 		if (scarlett2_has_config_item(private,
6959 					      scarlett2_ag_target_configs[i])) {
6960 
6961 			scnprintf(s, sizeof(s), "Autogain %s Target",
6962 				  scarlett2_ag_target_names[i]);
6963 			err = scarlett2_add_new_ctl(
6964 				mixer, &scarlett2_ag_target_ctl,
6965 				i, 1, s, &private->ag_target_ctls[i]);
6966 			if (err < 0)
6967 				return err;
6968 		}
6969 
6970 	/* Add safe-mode input switch controls */
6971 	for (i = 0; i < info->safe_input_count; i++) {
6972 		scnprintf(s, sizeof(s), fmt, i + 1,
6973 			  "Safe", "Switch");
6974 		err = scarlett2_add_new_ctl(
6975 			mixer, &scarlett2_safe_ctl,
6976 			i, 1, s, &private->safe_ctls[i]);
6977 		if (err < 0)
6978 			return err;
6979 	}
6980 
6981 	/* Add PCM Input Switch control */
6982 	if (scarlett2_has_config_item(private,
6983 				      SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {
6984 		err = scarlett2_add_new_ctl(
6985 			mixer, &scarlett2_pcm_input_switch_ctl, 0, 1,
6986 			"PCM Input Capture Switch",
6987 			&private->pcm_input_switch_ctl);
6988 		if (err < 0)
6989 			return err;
6990 	}
6991 
6992 	return 0;
6993 }
6994 
6995 /*** Mixer Volume Controls ***/
6996 
scarlett2_update_mix(struct usb_mixer_interface * mixer)6997 static int scarlett2_update_mix(struct usb_mixer_interface *mixer)
6998 {
6999 	struct scarlett2_data *private = mixer->private_data;
7000 	int i, err;
7001 
7002 	private->mix_updated = 0;
7003 
7004 	for (i = 0; i < private->num_mix_out; i++) {
7005 		err = scarlett2_usb_get_mix(mixer, i);
7006 		if (err < 0)
7007 			return err;
7008 	}
7009 
7010 	return 1;
7011 }
7012 
scarlett2_mixer_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7013 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
7014 				    struct snd_ctl_elem_info *uinfo)
7015 {
7016 	struct usb_mixer_elem_info *elem = kctl->private_data;
7017 
7018 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7019 	uinfo->count = elem->channels;
7020 	uinfo->value.integer.min = 0;
7021 	uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
7022 	uinfo->value.integer.step = 1;
7023 	return 0;
7024 }
7025 
scarlett2_mixer_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7026 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
7027 				   struct snd_ctl_elem_value *ucontrol)
7028 {
7029 	struct usb_mixer_elem_info *elem = kctl->private_data;
7030 	struct usb_mixer_interface *mixer = elem->head.mixer;
7031 	struct scarlett2_data *private = mixer->private_data;
7032 	int err = 0;
7033 
7034 	mutex_lock(&private->data_mutex);
7035 
7036 	if (private->hwdep_in_use) {
7037 		err = -EBUSY;
7038 		goto unlock;
7039 	}
7040 
7041 	if (private->mix_updated) {
7042 		err = scarlett2_update_mix(mixer);
7043 		if (err < 0)
7044 			goto unlock;
7045 	}
7046 	ucontrol->value.integer.value[0] = private->mix[elem->control];
7047 
7048 unlock:
7049 	mutex_unlock(&private->data_mutex);
7050 	return err;
7051 }
7052 
scarlett2_mixer_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7053 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
7054 				   struct snd_ctl_elem_value *ucontrol)
7055 {
7056 	struct usb_mixer_elem_info *elem = kctl->private_data;
7057 	struct usb_mixer_interface *mixer = elem->head.mixer;
7058 	struct scarlett2_data *private = mixer->private_data;
7059 	int oval, val, mix_num, err = 0;
7060 	int index = elem->control;
7061 
7062 	mutex_lock(&private->data_mutex);
7063 
7064 	if (private->hwdep_in_use) {
7065 		err = -EBUSY;
7066 		goto unlock;
7067 	}
7068 
7069 	oval = private->mix[index];
7070 	val = clamp(ucontrol->value.integer.value[0],
7071 		    0L, (long)SCARLETT2_MIXER_MAX_VALUE);
7072 	mix_num = index / private->num_mix_in;
7073 
7074 	if (oval == val)
7075 		goto unlock;
7076 
7077 	private->mix[index] = val;
7078 	err = scarlett2_usb_set_mix(mixer, mix_num);
7079 	if (err == 0)
7080 		err = 1;
7081 
7082 unlock:
7083 	mutex_unlock(&private->data_mutex);
7084 	return err;
7085 }
7086 
7087 static const DECLARE_TLV_DB_MINMAX(
7088 	db_scale_scarlett2_mixer,
7089 	SCARLETT2_MIXER_MIN_DB * 100,
7090 	SCARLETT2_MIXER_MAX_DB * 100
7091 );
7092 
7093 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
7094 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7095 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
7096 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
7097 	.name = "",
7098 	.info = scarlett2_mixer_ctl_info,
7099 	.get  = scarlett2_mixer_ctl_get,
7100 	.put  = scarlett2_mixer_ctl_put,
7101 	.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
7102 	.tlv = { .p = db_scale_scarlett2_mixer }
7103 };
7104 
scarlett2_add_mixer_ctls(struct usb_mixer_interface * mixer)7105 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
7106 {
7107 	struct scarlett2_data *private = mixer->private_data;
7108 	int err, i, j;
7109 	int index;
7110 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
7111 
7112 	for (i = 0, index = 0; i < private->num_mix_out; i++)
7113 		for (j = 0; j < private->num_mix_in; j++, index++) {
7114 			snprintf(s, sizeof(s),
7115 				 "Mix %c Input %02d Playback Volume",
7116 				 'A' + i, j + 1);
7117 			err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
7118 						    index, 1, s,
7119 						    &private->mix_ctls[index]);
7120 			if (err < 0)
7121 				return err;
7122 		}
7123 
7124 	return 0;
7125 }
7126 
7127 /*** Direct Monitor Control ***/
7128 
scarlett2_update_direct_monitor(struct usb_mixer_interface * mixer)7129 static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)
7130 {
7131 	struct scarlett2_data *private = mixer->private_data;
7132 
7133 	private->direct_monitor_updated = 0;
7134 
7135 	if (!private->info->direct_monitor)
7136 		return 0;
7137 
7138 	return scarlett2_usb_get_config(
7139 		mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
7140 		1, &private->direct_monitor_switch);
7141 }
7142 
scarlett2_update_monitor_mix(struct usb_mixer_interface * mixer)7143 static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)
7144 {
7145 	struct scarlett2_data *private = mixer->private_data;
7146 	int err, i;
7147 	u16 mix_values[SCARLETT2_MONITOR_MIX_MAX];
7148 
7149 	if (!private->num_monitor_mix_ctls)
7150 		return 0;
7151 
7152 	err = scarlett2_usb_get_config(
7153 		mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
7154 		private->num_monitor_mix_ctls, mix_values);
7155 	if (err < 0)
7156 		return err;
7157 
7158 	for (i = 0; i < private->num_monitor_mix_ctls; i++)
7159 		private->monitor_mix[i] = scarlett2_mixer_value_to_db(
7160 			mix_values[i]);
7161 
7162 	return 0;
7163 }
7164 
scarlett2_direct_monitor_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7165 static int scarlett2_direct_monitor_ctl_get(
7166 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
7167 {
7168 	struct usb_mixer_elem_info *elem = kctl->private_data;
7169 	struct usb_mixer_interface *mixer = elem->head.mixer;
7170 	struct scarlett2_data *private = mixer->private_data;
7171 	int err = 0;
7172 
7173 	mutex_lock(&private->data_mutex);
7174 
7175 	if (private->hwdep_in_use) {
7176 		err = -EBUSY;
7177 		goto unlock;
7178 	}
7179 
7180 	if (private->direct_monitor_updated) {
7181 		err = scarlett2_update_direct_monitor(mixer);
7182 		if (err < 0)
7183 			goto unlock;
7184 	}
7185 	ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
7186 
7187 unlock:
7188 	mutex_unlock(&private->data_mutex);
7189 	return err;
7190 }
7191 
scarlett2_direct_monitor_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7192 static int scarlett2_direct_monitor_ctl_put(
7193 	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
7194 {
7195 	struct usb_mixer_elem_info *elem = kctl->private_data;
7196 	struct usb_mixer_interface *mixer = elem->head.mixer;
7197 	struct scarlett2_data *private = mixer->private_data;
7198 
7199 	int index = elem->control;
7200 	int oval, val, err = 0;
7201 
7202 	mutex_lock(&private->data_mutex);
7203 
7204 	if (private->hwdep_in_use) {
7205 		err = -EBUSY;
7206 		goto unlock;
7207 	}
7208 
7209 	oval = private->direct_monitor_switch;
7210 	val = min(ucontrol->value.enumerated.item[0], 2U);
7211 
7212 	if (oval == val)
7213 		goto unlock;
7214 
7215 	private->direct_monitor_switch = val;
7216 
7217 	/* Send switch change to the device */
7218 	err = scarlett2_usb_set_config(
7219 		mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
7220 	if (err == 0)
7221 		err = 1;
7222 
7223 unlock:
7224 	mutex_unlock(&private->data_mutex);
7225 	return err;
7226 }
7227 
scarlett2_direct_monitor_stereo_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7228 static int scarlett2_direct_monitor_stereo_enum_ctl_info(
7229 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
7230 {
7231 	static const char *const values[3] = {
7232 		"Off", "Mono", "Stereo"
7233 	};
7234 
7235 	return snd_ctl_enum_info(uinfo, 1, 3, values);
7236 }
7237 
7238 /* Direct Monitor for Solo is mono-only and only needs a boolean control
7239  * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
7240  */
7241 static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
7242 	{
7243 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7244 		.name = "",
7245 		.info = snd_ctl_boolean_mono_info,
7246 		.get  = scarlett2_direct_monitor_ctl_get,
7247 		.put  = scarlett2_direct_monitor_ctl_put,
7248 	},
7249 	{
7250 		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7251 		.name = "",
7252 		.info = scarlett2_direct_monitor_stereo_enum_ctl_info,
7253 		.get  = scarlett2_direct_monitor_ctl_get,
7254 		.put  = scarlett2_direct_monitor_ctl_put,
7255 	}
7256 };
7257 
scarlett2_monitor_mix_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7258 static int scarlett2_monitor_mix_ctl_get(struct snd_kcontrol *kctl,
7259 					 struct snd_ctl_elem_value *ucontrol)
7260 {
7261 	struct usb_mixer_elem_info *elem = kctl->private_data;
7262 	struct scarlett2_data *private = elem->head.mixer->private_data;
7263 
7264 	ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];
7265 
7266 	return 0;
7267 }
7268 
scarlett2_monitor_mix_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7269 static int scarlett2_monitor_mix_ctl_put(struct snd_kcontrol *kctl,
7270 					 struct snd_ctl_elem_value *ucontrol)
7271 {
7272 	struct usb_mixer_elem_info *elem = kctl->private_data;
7273 	struct usb_mixer_interface *mixer = elem->head.mixer;
7274 	struct scarlett2_data *private = mixer->private_data;
7275 	int oval, val, err = 0;
7276 	int index = elem->control;
7277 
7278 	mutex_lock(&private->data_mutex);
7279 
7280 	if (private->hwdep_in_use) {
7281 		err = -EBUSY;
7282 		goto unlock;
7283 	}
7284 
7285 	oval = private->monitor_mix[index];
7286 	val = clamp(ucontrol->value.integer.value[0],
7287 		    0L, (long)SCARLETT2_MIXER_MAX_VALUE);
7288 
7289 	if (oval == val)
7290 		goto unlock;
7291 
7292 	private->monitor_mix[index] = val;
7293 	err = scarlett2_usb_set_config(
7294 		mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
7295 		index, scarlett2_mixer_values[val]);
7296 	if (err == 0)
7297 		err = 1;
7298 
7299 unlock:
7300 	mutex_unlock(&private->data_mutex);
7301 	return err;
7302 }
7303 
7304 static const struct snd_kcontrol_new scarlett2_monitor_mix_ctl = {
7305 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7306 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
7307 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
7308 	.name = "",
7309 	.info = scarlett2_mixer_ctl_info,
7310 	.get  = scarlett2_monitor_mix_ctl_get,
7311 	.put  = scarlett2_monitor_mix_ctl_put,
7312 	.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
7313 	.tlv = { .p = db_scale_scarlett2_mixer }
7314 };
7315 
scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface * mixer)7316 static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer)
7317 {
7318 	struct scarlett2_data *private = mixer->private_data;
7319 	const struct scarlett2_device_info *info = private->info;
7320 	const char *s;
7321 	int err, i, j, k, index;
7322 
7323 	if (!info->direct_monitor)
7324 		return 0;
7325 
7326 	s = info->direct_monitor == 1
7327 	      ? "Direct Monitor Playback Switch"
7328 	      : "Direct Monitor Playback Enum";
7329 
7330 	err = scarlett2_add_new_ctl(
7331 		mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
7332 		0, 1, s, &private->direct_monitor_ctl);
7333 	if (err < 0)
7334 		return err;
7335 
7336 	if (!private->num_monitor_mix_ctls)
7337 		return 0;
7338 
7339 	/* 1 or 2 direct monitor selections (Mono & Stereo) */
7340 	for (i = 0, index = 0; i < info->direct_monitor; i++) {
7341 		const char * const format =
7342 			"Monitor %sMix %c Input %02d Playback Volume";
7343 		const char *mix_type;
7344 
7345 		if (info->direct_monitor == 1)
7346 			mix_type = "";
7347 		else if (i == 0)
7348 			mix_type = "1 ";
7349 		else
7350 			mix_type = "2 ";
7351 
7352 		/* 2 Mix outputs, A/Left & B/Right */
7353 		for (j = 0; j < 2; j++)
7354 
7355 			/* Mix inputs */
7356 			for (k = 0; k < private->num_mix_in; k++, index++) {
7357 				char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
7358 
7359 				scnprintf(name, sizeof(name), format,
7360 					  mix_type, 'A' + j, k + 1);
7361 
7362 				err = scarlett2_add_new_ctl(
7363 					mixer, &scarlett2_monitor_mix_ctl,
7364 					index, 1, name, NULL);
7365 				if (err < 0)
7366 					return err;
7367 			}
7368 	}
7369 
7370 	return 0;
7371 }
7372 
7373 /*** Mux Source Selection Controls ***/
7374 
scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7375 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
7376 					   struct snd_ctl_elem_info *uinfo)
7377 {
7378 	struct usb_mixer_elem_info *elem = kctl->private_data;
7379 	struct scarlett2_data *private = elem->head.mixer->private_data;
7380 	const struct scarlett2_device_info *info = private->info;
7381 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7382 	unsigned int item = uinfo->value.enumerated.item;
7383 	int items = private->num_mux_srcs;
7384 	int port_type;
7385 
7386 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
7387 	uinfo->count = elem->channels;
7388 	uinfo->value.enumerated.items = items;
7389 
7390 	if (item >= items)
7391 		item = uinfo->value.enumerated.item = items - 1;
7392 
7393 	for (port_type = 0;
7394 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
7395 	     port_type++) {
7396 		if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
7397 			const struct scarlett2_port *port =
7398 				&scarlett2_ports[port_type];
7399 
7400 			if (port_type == SCARLETT2_PORT_TYPE_MIX &&
7401 			    item >= private->num_mix_out)
7402 				sprintf(uinfo->value.enumerated.name,
7403 					port->dsp_src_descr,
7404 					item - private->num_mix_out + 1);
7405 			else
7406 				sprintf(uinfo->value.enumerated.name,
7407 					port->src_descr,
7408 					item + port->src_num_offset);
7409 
7410 			return 0;
7411 		}
7412 		item -= port_count[port_type][SCARLETT2_PORT_IN];
7413 	}
7414 
7415 	return -EINVAL;
7416 }
7417 
scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7418 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
7419 					  struct snd_ctl_elem_value *ucontrol)
7420 {
7421 	struct usb_mixer_elem_info *elem = kctl->private_data;
7422 	struct usb_mixer_interface *mixer = elem->head.mixer;
7423 	struct scarlett2_data *private = mixer->private_data;
7424 	int index = line_out_remap(private, elem->control);
7425 	int err = 0;
7426 
7427 	mutex_lock(&private->data_mutex);
7428 
7429 	if (private->hwdep_in_use) {
7430 		err = -EBUSY;
7431 		goto unlock;
7432 	}
7433 
7434 	if (private->mux_updated) {
7435 		err = scarlett2_usb_get_mux(mixer);
7436 		if (err < 0)
7437 			goto unlock;
7438 	}
7439 	ucontrol->value.enumerated.item[0] = private->mux[index];
7440 
7441 unlock:
7442 	mutex_unlock(&private->data_mutex);
7443 	return err;
7444 }
7445 
scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7446 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
7447 					  struct snd_ctl_elem_value *ucontrol)
7448 {
7449 	struct usb_mixer_elem_info *elem = kctl->private_data;
7450 	struct usb_mixer_interface *mixer = elem->head.mixer;
7451 	struct scarlett2_data *private = mixer->private_data;
7452 	int index = line_out_remap(private, elem->control);
7453 	int oval, val, err = 0;
7454 
7455 	mutex_lock(&private->data_mutex);
7456 
7457 	if (private->hwdep_in_use) {
7458 		err = -EBUSY;
7459 		goto unlock;
7460 	}
7461 
7462 	oval = private->mux[index];
7463 	val = min(ucontrol->value.enumerated.item[0],
7464 		  private->num_mux_srcs - 1U);
7465 
7466 	if (oval == val)
7467 		goto unlock;
7468 
7469 	private->mux[index] = val;
7470 	err = scarlett2_usb_set_mux(mixer);
7471 	if (err == 0)
7472 		err = 1;
7473 
7474 unlock:
7475 	mutex_unlock(&private->data_mutex);
7476 	return err;
7477 }
7478 
7479 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
7480 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7481 	.name = "",
7482 	.info = scarlett2_mux_src_enum_ctl_info,
7483 	.get  = scarlett2_mux_src_enum_ctl_get,
7484 	.put  = scarlett2_mux_src_enum_ctl_put,
7485 };
7486 
scarlett2_add_mux_enums(struct usb_mixer_interface * mixer)7487 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
7488 {
7489 	struct scarlett2_data *private = mixer->private_data;
7490 	const struct scarlett2_device_info *info = private->info;
7491 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7492 	int port_type, channel, i;
7493 
7494 	for (i = 0, port_type = 0;
7495 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
7496 	     port_type++) {
7497 		for (channel = 0;
7498 		     channel < port_count[port_type][SCARLETT2_PORT_OUT];
7499 		     channel++, i++) {
7500 			int err;
7501 			char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
7502 			int channel_num = channel + 1;
7503 			const struct scarlett2_port *port =
7504 				&scarlett2_ports[port_type];
7505 			const char *descr = port->dst_descr;
7506 
7507 			if (port_type == SCARLETT2_PORT_TYPE_MIX &&
7508 			    channel >= private->num_mix_in) {
7509 				channel_num -= private->num_mix_in;
7510 				descr = port->dsp_dst_descr;
7511 			}
7512 
7513 			snprintf(s, sizeof(s) - 5, descr, channel_num);
7514 			strcat(s, " Enum");
7515 
7516 			err = scarlett2_add_new_ctl(mixer,
7517 						    &scarlett2_mux_src_enum_ctl,
7518 						    i, 1, s,
7519 						    &private->mux_ctls[i]);
7520 			if (err < 0)
7521 				return err;
7522 		}
7523 	}
7524 
7525 	return 0;
7526 }
7527 
7528 /*** Meter Controls ***/
7529 
scarlett2_meter_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7530 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
7531 				    struct snd_ctl_elem_info *uinfo)
7532 {
7533 	struct usb_mixer_elem_info *elem = kctl->private_data;
7534 
7535 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7536 	uinfo->count = elem->channels;
7537 	uinfo->value.integer.min = 0;
7538 	uinfo->value.integer.max = 4095;
7539 	uinfo->value.integer.step = 1;
7540 	return 0;
7541 }
7542 
scarlett2_meter_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7543 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
7544 				   struct snd_ctl_elem_value *ucontrol)
7545 {
7546 	struct usb_mixer_elem_info *elem = kctl->private_data;
7547 	struct usb_mixer_interface *mixer = elem->head.mixer;
7548 	struct scarlett2_data *private = mixer->private_data;
7549 	u8 *meter_level_map = private->meter_level_map;
7550 	u16 meter_levels[SCARLETT2_MAX_METERS];
7551 	int i, err;
7552 
7553 	mutex_lock(&private->data_mutex);
7554 
7555 	if (private->hwdep_in_use) {
7556 		err = -EBUSY;
7557 		goto unlock;
7558 	}
7559 
7560 	err = scarlett2_usb_get_meter_levels(mixer, elem->channels,
7561 					     meter_levels);
7562 	if (err < 0)
7563 		goto unlock;
7564 
7565 	/* copy & translate from meter_levels[] using meter_level_map[] */
7566 	for (i = 0; i < elem->channels; i++) {
7567 		int idx = meter_level_map[i];
7568 		int value;
7569 
7570 		if (idx == 255)
7571 			value = 0;
7572 		else
7573 			value = meter_levels[idx];
7574 
7575 		ucontrol->value.integer.value[i] = value;
7576 	}
7577 
7578 unlock:
7579 	mutex_unlock(&private->data_mutex);
7580 
7581 	return err;
7582 }
7583 
7584 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
7585 	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
7586 	.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
7587 	.name = "",
7588 	.info = scarlett2_meter_ctl_info,
7589 	.get  = scarlett2_meter_ctl_get
7590 };
7591 
scarlett2_add_meter_ctl(struct usb_mixer_interface * mixer)7592 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
7593 {
7594 	struct scarlett2_data *private = mixer->private_data;
7595 
7596 	/* devices without a mixer also don't support reporting levels */
7597 	if (!scarlett2_has_mixer(private))
7598 		return 0;
7599 
7600 	return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
7601 				     0, private->num_mux_dsts,
7602 				     "Level Meter", NULL);
7603 }
7604 
7605 /*** MSD Controls ***/
7606 
scarlett2_msd_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7607 static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
7608 				 struct snd_ctl_elem_value *ucontrol)
7609 {
7610 	struct usb_mixer_elem_info *elem = kctl->private_data;
7611 	struct scarlett2_data *private = elem->head.mixer->private_data;
7612 
7613 	ucontrol->value.integer.value[0] = private->msd_switch;
7614 	return 0;
7615 }
7616 
scarlett2_msd_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7617 static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
7618 				 struct snd_ctl_elem_value *ucontrol)
7619 {
7620 	struct usb_mixer_elem_info *elem = kctl->private_data;
7621 	struct usb_mixer_interface *mixer = elem->head.mixer;
7622 	struct scarlett2_data *private = mixer->private_data;
7623 
7624 	int oval, val, err = 0;
7625 
7626 	mutex_lock(&private->data_mutex);
7627 
7628 	if (private->hwdep_in_use) {
7629 		err = -EBUSY;
7630 		goto unlock;
7631 	}
7632 
7633 	oval = private->msd_switch;
7634 	val = !!ucontrol->value.integer.value[0];
7635 
7636 	if (oval == val)
7637 		goto unlock;
7638 
7639 	private->msd_switch = val;
7640 
7641 	/* Send switch change to the device */
7642 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
7643 				       0, val);
7644 	if (err == 0)
7645 		err = 1;
7646 
7647 unlock:
7648 	mutex_unlock(&private->data_mutex);
7649 	return err;
7650 }
7651 
7652 static const struct snd_kcontrol_new scarlett2_msd_ctl = {
7653 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7654 	.name = "",
7655 	.info = snd_ctl_boolean_mono_info,
7656 	.get  = scarlett2_msd_ctl_get,
7657 	.put  = scarlett2_msd_ctl_put,
7658 };
7659 
scarlett2_add_msd_ctl(struct usb_mixer_interface * mixer)7660 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
7661 {
7662 	struct scarlett2_data *private = mixer->private_data;
7663 
7664 	if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH))
7665 		return 0;
7666 
7667 	/* If MSD mode is off, hide the switch by default */
7668 	if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
7669 		return 0;
7670 
7671 	/* Add MSD control */
7672 	return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
7673 				     0, 1, "MSD Mode Switch", NULL);
7674 }
7675 
7676 /*** Standalone Control ***/
7677 
scarlett2_standalone_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7678 static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,
7679 					struct snd_ctl_elem_value *ucontrol)
7680 {
7681 	struct usb_mixer_elem_info *elem = kctl->private_data;
7682 	struct scarlett2_data *private = elem->head.mixer->private_data;
7683 
7684 	ucontrol->value.integer.value[0] = private->standalone_switch;
7685 	return 0;
7686 }
7687 
scarlett2_standalone_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7688 static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,
7689 					struct snd_ctl_elem_value *ucontrol)
7690 {
7691 	struct usb_mixer_elem_info *elem = kctl->private_data;
7692 	struct usb_mixer_interface *mixer = elem->head.mixer;
7693 	struct scarlett2_data *private = mixer->private_data;
7694 
7695 	int oval, val, err = 0;
7696 
7697 	mutex_lock(&private->data_mutex);
7698 
7699 	if (private->hwdep_in_use) {
7700 		err = -EBUSY;
7701 		goto unlock;
7702 	}
7703 
7704 	oval = private->standalone_switch;
7705 	val = !!ucontrol->value.integer.value[0];
7706 
7707 	if (oval == val)
7708 		goto unlock;
7709 
7710 	private->standalone_switch = val;
7711 
7712 	/* Send switch change to the device */
7713 	err = scarlett2_usb_set_config(mixer,
7714 				       SCARLETT2_CONFIG_STANDALONE_SWITCH,
7715 				       0, val);
7716 	if (err == 0)
7717 		err = 1;
7718 
7719 unlock:
7720 	mutex_unlock(&private->data_mutex);
7721 	return err;
7722 }
7723 
7724 static const struct snd_kcontrol_new scarlett2_standalone_ctl = {
7725 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7726 	.name = "",
7727 	.info = snd_ctl_boolean_mono_info,
7728 	.get  = scarlett2_standalone_ctl_get,
7729 	.put  = scarlett2_standalone_ctl_put,
7730 };
7731 
scarlett2_add_standalone_ctl(struct usb_mixer_interface * mixer)7732 static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
7733 {
7734 	struct scarlett2_data *private = mixer->private_data;
7735 
7736 	if (!scarlett2_has_config_item(private,
7737 				       SCARLETT2_CONFIG_STANDALONE_SWITCH))
7738 		return 0;
7739 
7740 	/* Add standalone control */
7741 	return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
7742 				     0, 1, "Standalone Switch", NULL);
7743 }
7744 
7745 /*** Power Status ***/
7746 
scarlett2_update_power_status(struct usb_mixer_interface * mixer)7747 static int scarlett2_update_power_status(struct usb_mixer_interface *mixer)
7748 {
7749 	struct scarlett2_data *private = mixer->private_data;
7750 	int err;
7751 	u8 power_ext, power_low;
7752 
7753 	private->power_status_updated = 0;
7754 
7755 	err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT,
7756 				       1, &power_ext);
7757 	if (err < 0)
7758 		return err;
7759 
7760 	err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW,
7761 				       1, &power_low);
7762 	if (err < 0)
7763 		return err;
7764 
7765 	if (power_low)
7766 		private->power_status = SCARLETT2_POWER_STATUS_FAIL;
7767 	else if (power_ext)
7768 		private->power_status = SCARLETT2_POWER_STATUS_EXT;
7769 	else
7770 		private->power_status = SCARLETT2_POWER_STATUS_BUS;
7771 
7772 	return 0;
7773 }
7774 
scarlett2_power_status_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7775 static int scarlett2_power_status_ctl_get(struct snd_kcontrol *kctl,
7776 					  struct snd_ctl_elem_value *ucontrol)
7777 {
7778 	struct usb_mixer_elem_info *elem = kctl->private_data;
7779 	struct usb_mixer_interface *mixer = elem->head.mixer;
7780 	struct scarlett2_data *private = mixer->private_data;
7781 	int err = 0;
7782 
7783 	mutex_lock(&private->data_mutex);
7784 
7785 	if (private->power_status_updated) {
7786 		err = scarlett2_update_power_status(mixer);
7787 		if (err < 0)
7788 			goto unlock;
7789 	}
7790 	ucontrol->value.integer.value[0] = private->power_status;
7791 
7792 unlock:
7793 	mutex_unlock(&private->data_mutex);
7794 	return err;
7795 }
7796 
scarlett2_power_status_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7797 static int scarlett2_power_status_ctl_info(
7798 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
7799 {
7800 	static const char *const values[3] = {
7801 		"External", "Bus", "Fail"
7802 	};
7803 
7804 	return snd_ctl_enum_info(uinfo, 1, 3, values);
7805 }
7806 
7807 static const struct snd_kcontrol_new scarlett2_power_status_ctl = {
7808 	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
7809 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
7810 	.name = "",
7811 	.info = scarlett2_power_status_ctl_info,
7812 	.get  = scarlett2_power_status_ctl_get,
7813 };
7814 
scarlett2_add_power_status_ctl(struct usb_mixer_interface * mixer)7815 static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer)
7816 {
7817 	struct scarlett2_data *private = mixer->private_data;
7818 
7819 	if (!scarlett2_has_config_item(private,
7820 				       SCARLETT2_CONFIG_POWER_EXT))
7821 		return 0;
7822 
7823 	/* Add power status control */
7824 	return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl,
7825 				     0, 1, "Power Status Card Enum",
7826 				     &private->power_status_ctl);
7827 }
7828 
7829 /*** Bluetooth Volume ***/
7830 
scarlett2_update_bluetooth_volume(struct usb_mixer_interface * mixer)7831 static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer)
7832 {
7833 	struct scarlett2_data *private = mixer->private_data;
7834 	int err;
7835 
7836 	private->bluetooth_updated = 0;
7837 
7838 	if (!private->info->has_bluetooth)
7839 		return 0;
7840 
7841 	err = scarlett2_usb_get_config(mixer,
7842 				       SCARLETT2_CONFIG_BLUETOOTH_VOLUME,
7843 				       1, &private->bluetooth_volume);
7844 	if (err < 0)
7845 		return err;
7846 
7847 	return 0;
7848 }
7849 
scarlett2_bluetooth_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7850 static int scarlett2_bluetooth_volume_ctl_get(struct snd_kcontrol *kctl,
7851 					     struct snd_ctl_elem_value *ucontrol)
7852 {
7853 	struct usb_mixer_elem_info *elem = kctl->private_data;
7854 	struct usb_mixer_interface *mixer = elem->head.mixer;
7855 	struct scarlett2_data *private = mixer->private_data;
7856 	int err = 0;
7857 
7858 	mutex_lock(&private->data_mutex);
7859 
7860 	if (private->hwdep_in_use) {
7861 		err = -EBUSY;
7862 		goto unlock;
7863 	}
7864 
7865 	if (private->bluetooth_updated) {
7866 		err = scarlett2_update_bluetooth_volume(mixer);
7867 		if (err < 0)
7868 			goto unlock;
7869 	}
7870 	ucontrol->value.integer.value[0] = private->bluetooth_volume;
7871 
7872 unlock:
7873 	mutex_unlock(&private->data_mutex);
7874 	return err;
7875 }
7876 
scarlett2_bluetooth_volume_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7877 static int scarlett2_bluetooth_volume_ctl_put(struct snd_kcontrol *kctl,
7878 					     struct snd_ctl_elem_value *ucontrol)
7879 {
7880 	struct usb_mixer_elem_info *elem = kctl->private_data;
7881 	struct usb_mixer_interface *mixer = elem->head.mixer;
7882 	struct scarlett2_data *private = mixer->private_data;
7883 	int oval, val, err = 0;
7884 
7885 	mutex_lock(&private->data_mutex);
7886 
7887 	if (private->hwdep_in_use) {
7888 		err = -EBUSY;
7889 		goto unlock;
7890 	}
7891 
7892 	oval = private->bluetooth_volume;
7893 	val = clamp(ucontrol->value.integer.value[0],
7894 		    0L, (long)SCARLETT2_MAX_BLUETOOTH_VOLUME);
7895 
7896 	if (oval == val)
7897 		goto unlock;
7898 
7899 	private->bluetooth_volume = val;
7900 	err = scarlett2_usb_set_config(mixer,
7901 				       SCARLETT2_CONFIG_BLUETOOTH_VOLUME,
7902 				       0, val);
7903 	if (err == 0)
7904 		err = 1;
7905 
7906 unlock:
7907 	mutex_unlock(&private->data_mutex);
7908 	return err;
7909 }
7910 
scarlett2_bluetooth_volume_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7911 static int scarlett2_bluetooth_volume_ctl_info(
7912 	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
7913 {
7914 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7915 	uinfo->count = 1;
7916 	uinfo->value.integer.min = 0;
7917 	uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME;
7918 	uinfo->value.integer.step = 1;
7919 	return 0;
7920 }
7921 
7922 static const struct snd_kcontrol_new scarlett2_bluetooth_volume_ctl = {
7923 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7924 	.name = "",
7925 	.info = scarlett2_bluetooth_volume_ctl_info,
7926 	.get  = scarlett2_bluetooth_volume_ctl_get,
7927 	.put  = scarlett2_bluetooth_volume_ctl_put,
7928 };
7929 
scarlett2_add_bluetooth_volume_ctl(struct usb_mixer_interface * mixer)7930 static int scarlett2_add_bluetooth_volume_ctl(
7931 	struct usb_mixer_interface *mixer)
7932 {
7933 	struct scarlett2_data *private = mixer->private_data;
7934 
7935 	if (!private->info->has_bluetooth)
7936 		return 0;
7937 
7938 	/* Add Bluetooth volume control */
7939 	return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl,
7940 				     0, 1, "Bluetooth Capture Volume",
7941 				     &private->bluetooth_volume_ctl);
7942 }
7943 
7944 /*** S/PDIF Mode Controls ***/
7945 
scarlett2_update_spdif_mode(struct usb_mixer_interface * mixer)7946 static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer)
7947 {
7948 	struct scarlett2_data *private = mixer->private_data;
7949 	int err, i;
7950 	u8 mode;
7951 	const u8 *mode_values = private->info->spdif_mode_values;
7952 
7953 	if (!private->info->spdif_mode_control_name)
7954 		return 0;
7955 
7956 	err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE,
7957 				       1, &mode);
7958 	if (err < 0)
7959 		return err;
7960 
7961 	private->spdif_mode = 0;
7962 
7963 	for (i = 0; *mode_values != 0xff; i++, mode_values++)
7964 		if (*mode_values == mode) {
7965 			private->spdif_mode = i;
7966 			break;
7967 		}
7968 
7969 	return 0;
7970 }
7971 
scarlett2_spdif_mode_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)7972 static int scarlett2_spdif_mode_ctl_info(struct snd_kcontrol *kctl,
7973 					   struct snd_ctl_elem_info *uinfo)
7974 {
7975 	struct usb_mixer_elem_info *elem = kctl->private_data;
7976 	struct scarlett2_data *private = elem->head.mixer->private_data;
7977 	const char * const *mode_texts = private->info->spdif_mode_texts;
7978 	int count = 0;
7979 
7980 	while (*mode_texts++)
7981 		count++;
7982 
7983 	return snd_ctl_enum_info(uinfo, 1, count,
7984 				 private->info->spdif_mode_texts);
7985 }
7986 
scarlett2_spdif_mode_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7987 static int scarlett2_spdif_mode_ctl_get(struct snd_kcontrol *kctl,
7988 					  struct snd_ctl_elem_value *ucontrol)
7989 {
7990 	struct usb_mixer_elem_info *elem = kctl->private_data;
7991 	struct scarlett2_data *private = elem->head.mixer->private_data;
7992 
7993 	ucontrol->value.enumerated.item[0] = private->spdif_mode;
7994 	return 0;
7995 }
7996 
scarlett2_spdif_mode_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)7997 static int scarlett2_spdif_mode_ctl_put(struct snd_kcontrol *kctl,
7998 					  struct snd_ctl_elem_value *ucontrol)
7999 {
8000 	struct usb_mixer_elem_info *elem = kctl->private_data;
8001 	struct usb_mixer_interface *mixer = elem->head.mixer;
8002 	struct scarlett2_data *private = mixer->private_data;
8003 	int oval, val, err = 0;
8004 	int i;
8005 
8006 	mutex_lock(&private->data_mutex);
8007 
8008 	oval = private->spdif_mode;
8009 	val = ucontrol->value.enumerated.item[0];
8010 
8011 	if (val < 0) {
8012 		err = -EINVAL;
8013 		goto unlock;
8014 	}
8015 
8016 	for (i = 0; i <= val; i++)
8017 		if (private->info->spdif_mode_values[i] == 0xff) {
8018 			err = -EINVAL;
8019 			goto unlock;
8020 		}
8021 
8022 	if (oval == val)
8023 		goto unlock;
8024 
8025 	private->spdif_mode = val;
8026 
8027 	err = scarlett2_usb_set_config(
8028 		mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0,
8029 		private->info->spdif_mode_values[val]);
8030 	if (!err)
8031 		err = 1;
8032 
8033 unlock:
8034 	mutex_unlock(&private->data_mutex);
8035 	return err;
8036 }
8037 
8038 static const struct snd_kcontrol_new scarlett2_spdif_mode_ctl = {
8039 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8040 	.name = "",
8041 	.info = scarlett2_spdif_mode_ctl_info,
8042 	.get  = scarlett2_spdif_mode_ctl_get,
8043 	.put  = scarlett2_spdif_mode_ctl_put,
8044 };
8045 
scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface * mixer)8046 static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer)
8047 {
8048 	struct scarlett2_data *private = mixer->private_data;
8049 
8050 	if (!private->info->spdif_mode_control_name)
8051 		return 0;
8052 
8053 	return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl,
8054 				     0, 1,
8055 				     private->info->spdif_mode_control_name,
8056 				     NULL);
8057 }
8058 
8059 /*** Notification Handlers ***/
8060 
8061 /* Notify on sync change */
scarlett2_notify_sync(struct usb_mixer_interface * mixer)8062 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)
8063 {
8064 	struct scarlett2_data *private = mixer->private_data;
8065 
8066 	private->sync_updated = 1;
8067 
8068 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8069 		       &private->sync_ctl->id);
8070 }
8071 
8072 /* Notify on monitor change (Gen 2/3) */
scarlett2_notify_monitor(struct usb_mixer_interface * mixer)8073 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer)
8074 {
8075 	struct snd_card *card = mixer->chip->card;
8076 	struct scarlett2_data *private = mixer->private_data;
8077 	int i;
8078 
8079 	if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))
8080 		return;
8081 
8082 	private->vol_updated = 1;
8083 
8084 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8085 		       &private->master_vol_ctl->id);
8086 
8087 	for (i = 0; i < private->num_line_out; i++)
8088 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])
8089 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8090 				       &private->vol_ctls[i]->id);
8091 }
8092 
8093 /* Notify on volume change (Gen 4) */
scarlett2_notify_volume(struct usb_mixer_interface * mixer)8094 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)
8095 {
8096 	struct scarlett2_data *private = mixer->private_data;
8097 
8098 	private->vol_updated = 1;
8099 
8100 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8101 		       &private->master_vol_ctl->id);
8102 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8103 		       &private->headphone_vol_ctl->id);
8104 }
8105 
8106 /* Notify on dim/mute change */
scarlett2_notify_dim_mute(struct usb_mixer_interface * mixer)8107 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer)
8108 {
8109 	struct snd_card *card = mixer->chip->card;
8110 	struct scarlett2_data *private = mixer->private_data;
8111 	int i;
8112 
8113 	if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))
8114 		return;
8115 
8116 	private->dim_mute_updated = 1;
8117 
8118 	for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
8119 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8120 			       &private->dim_mute_ctls[i]->id);
8121 
8122 	for (i = 0; i < private->num_line_out; i++)
8123 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])
8124 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8125 				       &private->mute_ctls[i]->id);
8126 }
8127 
8128 /* Notify on input level switch change */
scarlett2_notify_input_level(struct usb_mixer_interface * mixer)8129 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer)
8130 {
8131 	struct snd_card *card = mixer->chip->card;
8132 	struct scarlett2_data *private = mixer->private_data;
8133 	const struct scarlett2_device_info *info = private->info;
8134 	int i;
8135 
8136 	private->input_level_updated = 1;
8137 
8138 	for (i = 0; i < info->level_input_count; i++)
8139 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8140 			       &private->level_ctls[i]->id);
8141 }
8142 
8143 /* Notify on input pad switch change */
scarlett2_notify_input_pad(struct usb_mixer_interface * mixer)8144 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer)
8145 {
8146 	struct snd_card *card = mixer->chip->card;
8147 	struct scarlett2_data *private = mixer->private_data;
8148 	const struct scarlett2_device_info *info = private->info;
8149 	int i;
8150 
8151 	private->input_pad_updated = 1;
8152 
8153 	for (i = 0; i < info->pad_input_count; i++)
8154 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8155 			       &private->pad_ctls[i]->id);
8156 }
8157 
8158 /* Notify on input air switch change */
scarlett2_notify_input_air(struct usb_mixer_interface * mixer)8159 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer)
8160 {
8161 	struct snd_card *card = mixer->chip->card;
8162 	struct scarlett2_data *private = mixer->private_data;
8163 	const struct scarlett2_device_info *info = private->info;
8164 	int i;
8165 
8166 	private->input_air_updated = 1;
8167 
8168 	for (i = 0; i < info->air_input_count; i++)
8169 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8170 			       &private->air_ctls[i]->id);
8171 }
8172 
8173 /* Notify on input DSP switch change */
scarlett2_notify_input_dsp(struct usb_mixer_interface * mixer)8174 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer)
8175 {
8176 	struct snd_card *card = mixer->chip->card;
8177 	struct scarlett2_data *private = mixer->private_data;
8178 	const struct scarlett2_device_info *info = private->info;
8179 	int i;
8180 
8181 	private->input_dsp_updated = 1;
8182 
8183 	for (i = 0; i < info->dsp_input_count; i++)
8184 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8185 			       &private->dsp_ctls[i]->id);
8186 }
8187 
8188 /* Notify on input mute switch change */
scarlett2_notify_input_mute(struct usb_mixer_interface * mixer)8189 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer)
8190 {
8191 	struct snd_card *card = mixer->chip->card;
8192 	struct scarlett2_data *private = mixer->private_data;
8193 	const struct scarlett2_device_info *info = private->info;
8194 	int i;
8195 
8196 	private->input_mute_updated = 1;
8197 
8198 	for (i = 0; i < info->mute_input_count; i++)
8199 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8200 			       &private->input_mute_ctls[i]->id);
8201 }
8202 
8203 /* Notify on input phantom switch change */
scarlett2_notify_input_phantom(struct usb_mixer_interface * mixer)8204 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer)
8205 {
8206 	struct snd_card *card = mixer->chip->card;
8207 	struct scarlett2_data *private = mixer->private_data;
8208 	const struct scarlett2_device_info *info = private->info;
8209 	int i;
8210 
8211 	private->input_phantom_updated = 1;
8212 
8213 	for (i = 0; i < info->phantom_count; i++)
8214 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8215 			       &private->phantom_ctls[i]->id);
8216 
8217 	scarlett2_phantom_notify_access(mixer);
8218 }
8219 
8220 /* Notify on "input other" change (level/pad/air/phantom) */
scarlett2_notify_input_other(struct usb_mixer_interface * mixer)8221 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer)
8222 {
8223 	scarlett2_notify_input_level(mixer);
8224 	scarlett2_notify_input_pad(mixer);
8225 	scarlett2_notify_input_air(mixer);
8226 	scarlett2_notify_input_phantom(mixer);
8227 }
8228 
8229 /* Notify on input select change */
scarlett2_notify_input_select(struct usb_mixer_interface * mixer)8230 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer)
8231 {
8232 	struct snd_card *card = mixer->chip->card;
8233 	struct scarlett2_data *private = mixer->private_data;
8234 	const struct scarlett2_device_info *info = private->info;
8235 	int i;
8236 
8237 	if (!scarlett2_has_config_item(private,
8238 				       SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))
8239 		return;
8240 
8241 	private->input_select_updated = 1;
8242 
8243 	snd_ctl_notify(card,
8244 		       SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
8245 		       &private->input_select_ctl->id);
8246 
8247 	for (i = 0; i < info->gain_input_count / 2; i++)
8248 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8249 			       &private->input_link_ctls[i]->id);
8250 }
8251 
8252 /* Notify on input gain change */
scarlett2_notify_input_gain(struct usb_mixer_interface * mixer)8253 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer)
8254 {
8255 	struct snd_card *card = mixer->chip->card;
8256 	struct scarlett2_data *private = mixer->private_data;
8257 	const struct scarlett2_device_info *info = private->info;
8258 	int i;
8259 
8260 	if (!info->gain_input_count)
8261 		return;
8262 
8263 	private->input_gain_updated = 1;
8264 
8265 	for (i = 0; i < info->gain_input_count; i++)
8266 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8267 			       &private->input_gain_ctls[i]->id);
8268 }
8269 
8270 /* Notify on autogain change */
scarlett2_notify_autogain(struct usb_mixer_interface * mixer)8271 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer)
8272 {
8273 	struct snd_card *card = mixer->chip->card;
8274 	struct scarlett2_data *private = mixer->private_data;
8275 	const struct scarlett2_device_info *info = private->info;
8276 	int i;
8277 
8278 	if (!info->gain_input_count)
8279 		return;
8280 
8281 	private->autogain_updated = 1;
8282 
8283 	for (i = 0; i < info->gain_input_count; i++) {
8284 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8285 			       &private->autogain_ctls[i]->id);
8286 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8287 			       &private->autogain_status_ctls[i]->id);
8288 	}
8289 
8290 	for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)
8291 		if (scarlett2_has_config_item(private,
8292 					      scarlett2_ag_target_configs[i]))
8293 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
8294 				       &private->ag_target_ctls[i]->id);
8295 
8296 	scarlett2_autogain_notify_access(mixer);
8297 }
8298 
8299 /* Notify on input safe switch change */
scarlett2_notify_input_safe(struct usb_mixer_interface * mixer)8300 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer)
8301 {
8302 	struct snd_card *card = mixer->chip->card;
8303 	struct scarlett2_data *private = mixer->private_data;
8304 	const struct scarlett2_device_info *info = private->info;
8305 	int i;
8306 
8307 	if (!info->safe_input_count)
8308 		return;
8309 
8310 	private->input_safe_updated = 1;
8311 
8312 	for (i = 0; i < info->safe_input_count; i++)
8313 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8314 			       &private->safe_ctls[i]->id);
8315 }
8316 
8317 /* Notify on "monitor other" change (speaker switching, talkback) */
scarlett2_notify_monitor_other(struct usb_mixer_interface * mixer)8318 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer)
8319 {
8320 	struct snd_card *card = mixer->chip->card;
8321 	struct scarlett2_data *private = mixer->private_data;
8322 	const struct scarlett2_device_info *info = private->info;
8323 
8324 	private->monitor_other_updated = 1;
8325 
8326 	if (info->has_speaker_switching)
8327 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8328 			       &private->speaker_switching_ctl->id);
8329 
8330 	if (info->has_talkback)
8331 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8332 			       &private->talkback_ctl->id);
8333 
8334 	/* if speaker switching was recently enabled or disabled,
8335 	 * invalidate the dim/mute and mux enum controls
8336 	 */
8337 	if (private->speaker_switching_switched) {
8338 		int i;
8339 
8340 		scarlett2_notify_dim_mute(mixer);
8341 
8342 		private->speaker_switching_switched = 0;
8343 		private->mux_updated = 1;
8344 
8345 		for (i = 0; i < private->num_mux_dsts; i++)
8346 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8347 				       &private->mux_ctls[i]->id);
8348 	}
8349 }
8350 
8351 /* Notify on direct monitor switch change */
scarlett2_notify_direct_monitor(struct usb_mixer_interface * mixer)8352 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer)
8353 {
8354 	struct snd_card *card = mixer->chip->card;
8355 	struct scarlett2_data *private = mixer->private_data;
8356 	int count = private->num_mix_in * private->num_mix_out;
8357 	int i;
8358 
8359 	private->direct_monitor_updated = 1;
8360 
8361 	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8362 		       &private->direct_monitor_ctl->id);
8363 
8364 	if (!scarlett2_has_mixer(private))
8365 		return;
8366 
8367 	private->mix_updated = 1;
8368 
8369 	/* Notify of change to the mix controls */
8370 	for (i = 0; i < count; i++)
8371 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8372 			       &private->mix_ctls[i]->id);
8373 }
8374 
8375 /* Notify on power change */
scarlett2_notify_power_status(struct usb_mixer_interface * mixer)8376 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer)
8377 {
8378 	struct snd_card *card = mixer->chip->card;
8379 	struct scarlett2_data *private = mixer->private_data;
8380 
8381 	private->power_status_updated = 1;
8382 
8383 	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8384 		       &private->power_status_ctl->id);
8385 }
8386 
8387 /* Notify on mux change */
scarlett2_notify_mux(struct usb_mixer_interface * mixer)8388 static void scarlett2_notify_mux(struct usb_mixer_interface *mixer)
8389 {
8390 	struct snd_card *card = mixer->chip->card;
8391 	struct scarlett2_data *private = mixer->private_data;
8392 	int i;
8393 
8394 	private->mux_updated = 1;
8395 
8396 	for (i = 0; i < private->num_mux_dsts; i++)
8397 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8398 			       &private->mux_ctls[i]->id);
8399 }
8400 
8401 /* Notify on PCM input switch change */
scarlett2_notify_pcm_input_switch(struct usb_mixer_interface * mixer)8402 static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer)
8403 {
8404 	struct snd_card *card = mixer->chip->card;
8405 	struct scarlett2_data *private = mixer->private_data;
8406 
8407 	private->pcm_input_switch_updated = 1;
8408 
8409 	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8410 		       &private->pcm_input_switch_ctl->id);
8411 
8412 	scarlett2_notify_mux(mixer);
8413 }
8414 
8415 /* Notify on Bluetooth change */
scarlett2_notify_bluetooth(struct usb_mixer_interface * mixer)8416 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer)
8417 {
8418 	struct snd_card *card = mixer->chip->card;
8419 	struct scarlett2_data *private = mixer->private_data;
8420 
8421 	if (!private->info->has_bluetooth)
8422 		return;
8423 
8424 	private->bluetooth_updated = 1;
8425 
8426 	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
8427 		       &private->bluetooth_volume_ctl->id);
8428 }
8429 
8430 /* Handle acknowledgement that a command was received; let
8431  * scarlett2_usb() know that it can proceed
8432  */
scarlett2_notify_ack(struct usb_mixer_interface * mixer)8433 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer)
8434 {
8435 	struct scarlett2_data *private = mixer->private_data;
8436 
8437 	/* if running == 0, ignore ACKs */
8438 	if (private->running)
8439 		complete(&private->cmd_done);
8440 }
8441 
8442 /* Interrupt callback */
scarlett2_notify(struct urb * urb)8443 static void scarlett2_notify(struct urb *urb)
8444 {
8445 	struct usb_mixer_interface *mixer = urb->context;
8446 	int len = urb->actual_length;
8447 	int ustatus = urb->status;
8448 	u32 data;
8449 	struct scarlett2_data *private = mixer->private_data;
8450 	const struct scarlett2_notification *notifications =
8451 		private->config_set->notifications;
8452 
8453 	if (ustatus != 0 || len != 8)
8454 		goto requeue;
8455 
8456 	data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
8457 
8458 	/* Ignore notifications except ACK during initialisation.
8459 	 * ACK is 0x00000001 on every device.
8460 	 */
8461 	if (private->running < 2)
8462 		data &= 1;
8463 
8464 	while (data && notifications->mask) {
8465 		if (data & notifications->mask) {
8466 			data &= ~notifications->mask;
8467 			if (notifications->func)
8468 				notifications->func(mixer);
8469 		}
8470 		notifications++;
8471 	}
8472 
8473 	if (data)
8474 		usb_audio_warn(mixer->chip,
8475 			       "%s: Unhandled notification: 0x%08x\n",
8476 			       __func__, data);
8477 
8478 requeue:
8479 	if (ustatus != -ENOENT &&
8480 	    ustatus != -ECONNRESET &&
8481 	    ustatus != -ESHUTDOWN) {
8482 		urb->dev = mixer->chip->dev;
8483 		usb_submit_urb(urb, GFP_ATOMIC);
8484 	} else {
8485 		complete(&private->cmd_done);
8486 	}
8487 }
8488 
8489 /*** Cleanup/Suspend Callbacks ***/
8490 
scarlett2_private_free(struct usb_mixer_interface * mixer)8491 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
8492 {
8493 	struct scarlett2_data *private = mixer->private_data;
8494 
8495 	cancel_delayed_work_sync(&private->work);
8496 	kfree(private);
8497 	mixer->private_data = NULL;
8498 }
8499 
scarlett2_private_suspend(struct usb_mixer_interface * mixer)8500 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
8501 {
8502 	struct scarlett2_data *private = mixer->private_data;
8503 
8504 	if (cancel_delayed_work_sync(&private->work))
8505 		scarlett2_config_save(private->mixer);
8506 }
8507 
8508 /*** Initialisation ***/
8509 
scarlett2_count_io(struct scarlett2_data * private)8510 static void scarlett2_count_io(struct scarlett2_data *private)
8511 {
8512 	const struct scarlett2_device_info *info = private->info;
8513 	const struct scarlett2_config_set *config_set = info->config_set;
8514 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
8515 	int port_type, srcs = 0, dsts = 0, i;
8516 
8517 	/* Count the number of mux sources and destinations */
8518 	for (port_type = 0;
8519 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
8520 	     port_type++) {
8521 		srcs += port_count[port_type][SCARLETT2_PORT_IN];
8522 		dsts += port_count[port_type][SCARLETT2_PORT_OUT];
8523 	}
8524 
8525 	private->num_mux_srcs = srcs;
8526 	private->num_mux_dsts = dsts;
8527 
8528 	/* Mixer inputs are mux outputs and vice versa.
8529 	 * Scarlett Gen 4 DSP I/O uses SCARLETT2_PORT_TYPE_MIX but
8530 	 * doesn't have mixer controls.
8531 	 */
8532 	private->num_mix_in =
8533 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -
8534 			info->dsp_count;
8535 
8536 	private->num_mix_out =
8537 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -
8538 			info->dsp_count;
8539 
8540 	/* Number of analogue line outputs */
8541 	private->num_line_out =
8542 		port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
8543 
8544 	/* Number of monitor mix controls */
8545 	private->num_monitor_mix_ctls =
8546 		info->direct_monitor * 2 * private->num_mix_in;
8547 
8548 	/* Number of autogain status texts */
8549 	if (config_set->autogain_status_texts) {
8550 		const char * const *texts = config_set->autogain_status_texts;
8551 
8552 		for (i = 0; texts[i]; i++)
8553 			;
8554 		private->num_autogain_status_texts = i;
8555 	}
8556 }
8557 
8558 /* Look through the interface descriptors for the Focusrite Control
8559  * interface (bInterfaceClass = 255 Vendor Specific Class) and set
8560  * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
8561  * in private
8562  */
scarlett2_find_fc_interface(struct usb_device * dev,struct scarlett2_data * private)8563 static int scarlett2_find_fc_interface(struct usb_device *dev,
8564 				       struct scarlett2_data *private)
8565 {
8566 	struct usb_host_config *config = dev->actconfig;
8567 	int i;
8568 
8569 	for (i = 0; i < config->desc.bNumInterfaces; i++) {
8570 		struct usb_interface *intf = config->interface[i];
8571 		struct usb_interface_descriptor *desc =
8572 			&intf->altsetting[0].desc;
8573 		struct usb_endpoint_descriptor *epd;
8574 
8575 		if (desc->bInterfaceClass != 255)
8576 			continue;
8577 
8578 		epd = get_endpoint(intf->altsetting, 0);
8579 		private->bInterfaceNumber = desc->bInterfaceNumber;
8580 		private->bEndpointAddress = epd->bEndpointAddress &
8581 			USB_ENDPOINT_NUMBER_MASK;
8582 		private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
8583 		private->bInterval = epd->bInterval;
8584 		return 0;
8585 	}
8586 
8587 	return -EINVAL;
8588 }
8589 
8590 /* Initialise private data */
scarlett2_init_private(struct usb_mixer_interface * mixer,const struct scarlett2_device_entry * entry)8591 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
8592 				  const struct scarlett2_device_entry *entry)
8593 {
8594 	struct scarlett2_data *private =
8595 		kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
8596 
8597 	if (!private)
8598 		return -ENOMEM;
8599 
8600 	mutex_init(&private->usb_mutex);
8601 	mutex_init(&private->data_mutex);
8602 	INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
8603 
8604 	mixer->private_data = private;
8605 	mixer->private_free = scarlett2_private_free;
8606 	mixer->private_suspend = scarlett2_private_suspend;
8607 
8608 	private->info = entry->info;
8609 	private->config_set = entry->info->config_set;
8610 	private->series_name = entry->series_name;
8611 	scarlett2_count_io(private);
8612 	private->scarlett2_seq = 0;
8613 	private->mixer = mixer;
8614 
8615 	return scarlett2_find_fc_interface(mixer->chip->dev, private);
8616 }
8617 
8618 /* Submit a URB to receive notifications from the device */
scarlett2_init_notify(struct usb_mixer_interface * mixer)8619 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
8620 {
8621 	struct usb_device *dev = mixer->chip->dev;
8622 	struct scarlett2_data *private = mixer->private_data;
8623 	unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
8624 	void *transfer_buffer;
8625 
8626 	if (mixer->urb) {
8627 		usb_audio_err(mixer->chip,
8628 			      "%s: mixer urb already in use!\n", __func__);
8629 		return 0;
8630 	}
8631 
8632 	if (usb_pipe_type_check(dev, pipe))
8633 		return -EINVAL;
8634 
8635 	mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
8636 	if (!mixer->urb)
8637 		return -ENOMEM;
8638 
8639 	transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
8640 	if (!transfer_buffer)
8641 		return -ENOMEM;
8642 
8643 	usb_fill_int_urb(mixer->urb, dev, pipe,
8644 			 transfer_buffer, private->wMaxPacketSize,
8645 			 scarlett2_notify, mixer, private->bInterval);
8646 
8647 	init_completion(&private->cmd_done);
8648 
8649 	return usb_submit_urb(mixer->urb, GFP_KERNEL);
8650 }
8651 
8652 /* Cargo cult proprietary initialisation sequence */
scarlett2_usb_init(struct usb_mixer_interface * mixer)8653 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
8654 {
8655 	struct usb_device *dev = mixer->chip->dev;
8656 	struct scarlett2_data *private = mixer->private_data;
8657 	u8 step0_buf[24];
8658 	u8 step2_buf[84];
8659 	int err;
8660 
8661 	if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
8662 		return -EINVAL;
8663 
8664 	/* step 0 */
8665 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
8666 			       SCARLETT2_USB_CMD_INIT,
8667 			       step0_buf, sizeof(step0_buf));
8668 	if (err < 0)
8669 		return err;
8670 
8671 	/* Set up the interrupt polling for notifications.
8672 	 * When running is:
8673 	 * 0: all notifications are ignored
8674 	 * 1: only ACKs are handled
8675 	 * 2: all notifications are handled
8676 	 */
8677 	err = scarlett2_init_notify(mixer);
8678 	if (err < 0)
8679 		return err;
8680 
8681 	/* sleep for a moment in case of an outstanding ACK */
8682 	msleep(20);
8683 
8684 	/* start handling ACKs, but no other notifications until the
8685 	 * ALSA controls have been created
8686 	 */
8687 	private->running = 1;
8688 
8689 	/* step 1 */
8690 	private->scarlett2_seq = 1;
8691 	err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
8692 	if (err < 0)
8693 		return err;
8694 
8695 	/* step 2 */
8696 	private->scarlett2_seq = 1;
8697 	err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,
8698 			    NULL, 0,
8699 			    step2_buf, sizeof(step2_buf));
8700 	if (err < 0)
8701 		return err;
8702 
8703 	/* extract 4-byte firmware version from step2_buf[8] */
8704 	private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));
8705 	usb_audio_info(mixer->chip,
8706 		       "Firmware version %d\n",
8707 		       private->firmware_version);
8708 
8709 	return 0;
8710 }
8711 
8712 /* Get the flash segment numbers for the App_Settings and App_Upgrade
8713  * segments and put them in the private data
8714  */
scarlett2_get_flash_segment_nums(struct usb_mixer_interface * mixer)8715 static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer)
8716 {
8717 	struct scarlett2_data *private = mixer->private_data;
8718 	int err, count, i;
8719 
8720 	struct {
8721 		__le32 size;
8722 		__le32 count;
8723 		u8 unknown[8];
8724 	} __packed flash_info;
8725 
8726 	struct {
8727 		__le32 size;
8728 		__le32 flags;
8729 		char name[16];
8730 	} __packed segment_info;
8731 
8732 	err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH,
8733 			    NULL, 0,
8734 			    &flash_info, sizeof(flash_info));
8735 	if (err < 0)
8736 		return err;
8737 
8738 	count = le32_to_cpu(flash_info.count);
8739 
8740 	/* sanity check count */
8741 	if (count < SCARLETT2_SEGMENT_NUM_MIN ||
8742 	    count > SCARLETT2_SEGMENT_NUM_MAX + 1) {
8743 		usb_audio_err(mixer->chip,
8744 			      "invalid flash segment count: %d\n", count);
8745 		return -EINVAL;
8746 	}
8747 
8748 	for (i = 0; i < count; i++) {
8749 		__le32 segment_num_req = cpu_to_le32(i);
8750 		int flash_segment_id;
8751 
8752 		err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,
8753 				    &segment_num_req, sizeof(segment_num_req),
8754 				    &segment_info, sizeof(segment_info));
8755 		if (err < 0) {
8756 			usb_audio_err(mixer->chip,
8757 				"failed to get flash segment info %d: %d\n",
8758 				i, err);
8759 			return err;
8760 		}
8761 
8762 		if (!strncmp(segment_info.name,
8763 			     SCARLETT2_SEGMENT_SETTINGS_NAME, 16))
8764 			flash_segment_id = SCARLETT2_SEGMENT_ID_SETTINGS;
8765 		else if (!strncmp(segment_info.name,
8766 				  SCARLETT2_SEGMENT_FIRMWARE_NAME, 16))
8767 			flash_segment_id = SCARLETT2_SEGMENT_ID_FIRMWARE;
8768 		else
8769 			continue;
8770 
8771 		private->flash_segment_nums[flash_segment_id] = i;
8772 		private->flash_segment_blocks[flash_segment_id] =
8773 			le32_to_cpu(segment_info.size) /
8774 				SCARLETT2_FLASH_BLOCK_SIZE;
8775 	}
8776 
8777 	/* segment 0 is App_Gold and we never want to touch that, so
8778 	 * use 0 as the "not-found" value
8779 	 */
8780 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {
8781 		usb_audio_err(mixer->chip,
8782 			      "failed to find flash segment %s\n",
8783 			      SCARLETT2_SEGMENT_SETTINGS_NAME);
8784 		return -EINVAL;
8785 	}
8786 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {
8787 		usb_audio_err(mixer->chip,
8788 			      "failed to find flash segment %s\n",
8789 			      SCARLETT2_SEGMENT_FIRMWARE_NAME);
8790 		return -EINVAL;
8791 	}
8792 
8793 	return 0;
8794 }
8795 
8796 /* Read configuration from the interface on start */
scarlett2_read_configs(struct usb_mixer_interface * mixer)8797 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
8798 {
8799 	struct scarlett2_data *private = mixer->private_data;
8800 	const struct scarlett2_device_info *info = private->info;
8801 	int err, i;
8802 
8803 	if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) {
8804 		err = scarlett2_usb_get_config(
8805 			mixer, SCARLETT2_CONFIG_MSD_SWITCH,
8806 			1, &private->msd_switch);
8807 		if (err < 0)
8808 			return err;
8809 	}
8810 
8811 	if (private->firmware_version < info->min_firmware_version) {
8812 		usb_audio_err(mixer->chip,
8813 			      "Focusrite %s firmware version %d is too old; "
8814 			      "need %d",
8815 			      private->series_name,
8816 			      private->firmware_version,
8817 			      info->min_firmware_version);
8818 		return 0;
8819 	}
8820 
8821 	/* no other controls are created if MSD mode is on */
8822 	if (private->msd_switch)
8823 		return 0;
8824 
8825 	err = scarlett2_update_input_level(mixer);
8826 	if (err < 0)
8827 		return err;
8828 
8829 	err = scarlett2_update_input_pad(mixer);
8830 	if (err < 0)
8831 		return err;
8832 
8833 	err = scarlett2_update_input_air(mixer);
8834 	if (err < 0)
8835 		return err;
8836 
8837 	err = scarlett2_update_input_dsp(mixer);
8838 	if (err < 0)
8839 		return err;
8840 
8841 	err = scarlett2_update_compressor_values(mixer);
8842 	if (err < 0)
8843 		return err;
8844 
8845 	err = scarlett2_update_filter_values(mixer);
8846 	if (err < 0)
8847 		return err;
8848 
8849 	err = scarlett2_update_input_mute(mixer);
8850 	if (err < 0)
8851 		return err;
8852 
8853 	err = scarlett2_update_input_phantom(mixer);
8854 	if (err < 0)
8855 		return err;
8856 
8857 	err = scarlett2_update_direct_monitor(mixer);
8858 	if (err < 0)
8859 		return err;
8860 
8861 	/* the rest of the configuration is for devices with a mixer */
8862 	if (!scarlett2_has_mixer(private))
8863 		return 0;
8864 
8865 	err = scarlett2_update_monitor_mix(mixer);
8866 	if (err < 0)
8867 		return err;
8868 
8869 	err = scarlett2_update_monitor_other(mixer);
8870 	if (err < 0)
8871 		return err;
8872 
8873 	if (scarlett2_has_config_item(private,
8874 				      SCARLETT2_CONFIG_STANDALONE_SWITCH)) {
8875 		err = scarlett2_usb_get_config(
8876 			mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
8877 			1, &private->standalone_switch);
8878 		if (err < 0)
8879 			return err;
8880 	}
8881 
8882 	if (scarlett2_has_config_item(private,
8883 				      SCARLETT2_CONFIG_POWER_EXT)) {
8884 		err = scarlett2_update_power_status(mixer);
8885 		if (err < 0)
8886 			return err;
8887 	}
8888 
8889 	err = scarlett2_update_sync(mixer);
8890 	if (err < 0)
8891 		return err;
8892 
8893 	if (scarlett2_has_config_item(private,
8894 				      SCARLETT2_CONFIG_LINE_OUT_VOLUME)) {
8895 		s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
8896 
8897 		/* read SW line out volume */
8898 		err = scarlett2_usb_get_config(
8899 			mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
8900 			private->num_line_out, &sw_vol);
8901 		if (err < 0)
8902 			return err;
8903 
8904 		for (i = 0; i < private->num_line_out; i++)
8905 			private->vol[i] = clamp(
8906 				sw_vol[i] + SCARLETT2_VOLUME_BIAS,
8907 				0, SCARLETT2_VOLUME_BIAS);
8908 
8909 		/* read SW mute */
8910 		err = scarlett2_usb_get_config(
8911 			mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
8912 			private->num_line_out, &private->mute_switch);
8913 		if (err < 0)
8914 			return err;
8915 
8916 		for (i = 0; i < private->num_line_out; i++)
8917 			private->mute_switch[i] =
8918 				!!private->mute_switch[i];
8919 
8920 		/* read SW/HW switches */
8921 		if (scarlett2_has_config_item(private,
8922 					      SCARLETT2_CONFIG_SW_HW_SWITCH)) {
8923 			err = scarlett2_usb_get_config(
8924 				mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
8925 				private->num_line_out,
8926 				&private->vol_sw_hw_switch);
8927 			if (err < 0)
8928 				return err;
8929 
8930 			for (i = 0; i < private->num_line_out; i++)
8931 				private->vol_sw_hw_switch[i] =
8932 					!!private->vol_sw_hw_switch[i];
8933 		}
8934 	}
8935 
8936 	err = scarlett2_update_volumes(mixer);
8937 	if (err < 0)
8938 		return err;
8939 
8940 	err = scarlett2_update_dim_mute(mixer);
8941 	if (err < 0)
8942 		return err;
8943 
8944 	err = scarlett2_update_input_select(mixer);
8945 	if (err < 0)
8946 		return err;
8947 
8948 	err = scarlett2_update_input_gain(mixer);
8949 	if (err < 0)
8950 		return err;
8951 
8952 	err = scarlett2_update_autogain(mixer);
8953 	if (err < 0)
8954 		return err;
8955 
8956 	err = scarlett2_update_input_safe(mixer);
8957 	if (err < 0)
8958 		return err;
8959 
8960 	if (scarlett2_has_config_item(private,
8961 				      SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {
8962 		err = scarlett2_update_pcm_input_switch(mixer);
8963 		if (err < 0)
8964 			return err;
8965 	}
8966 
8967 	err = scarlett2_update_bluetooth_volume(mixer);
8968 	if (err < 0)
8969 		return err;
8970 
8971 	err = scarlett2_update_spdif_mode(mixer);
8972 	if (err < 0)
8973 		return err;
8974 
8975 	err = scarlett2_update_mix(mixer);
8976 	if (err < 0)
8977 		return err;
8978 
8979 	return scarlett2_usb_get_mux(mixer);
8980 }
8981 
get_scarlett2_device_entry(struct usb_mixer_interface * mixer)8982 static const struct scarlett2_device_entry *get_scarlett2_device_entry(
8983 	struct usb_mixer_interface *mixer)
8984 {
8985 	const struct scarlett2_device_entry *entry = scarlett2_devices;
8986 
8987 	/* Find entry in scarlett2_devices */
8988 	while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)
8989 		entry++;
8990 	if (!entry->usb_id)
8991 		return NULL;
8992 
8993 	return entry;
8994 }
8995 
snd_scarlett2_controls_create(struct usb_mixer_interface * mixer,const struct scarlett2_device_entry * entry)8996 static int snd_scarlett2_controls_create(
8997 	struct usb_mixer_interface *mixer,
8998 	const struct scarlett2_device_entry *entry)
8999 {
9000 	struct scarlett2_data *private;
9001 	int err;
9002 
9003 	/* Initialise private data */
9004 	err = scarlett2_init_private(mixer, entry);
9005 	if (err < 0)
9006 		return err;
9007 
9008 	private = mixer->private_data;
9009 
9010 	/* Send proprietary USB initialisation sequence */
9011 	err = scarlett2_usb_init(mixer);
9012 	if (err < 0)
9013 		return err;
9014 
9015 	/* Get the upgrade & settings flash segment numbers */
9016 	err = scarlett2_get_flash_segment_nums(mixer);
9017 	if (err < 0)
9018 		return err;
9019 
9020 	/* Add firmware version control */
9021 	err = scarlett2_add_firmware_version_ctl(mixer);
9022 	if (err < 0)
9023 		return err;
9024 
9025 	/* Add minimum firmware version control */
9026 	err = scarlett2_add_min_firmware_version_ctl(mixer);
9027 	if (err < 0)
9028 		return err;
9029 
9030 	/* Read volume levels and controls from the interface */
9031 	err = scarlett2_read_configs(mixer);
9032 	if (err < 0)
9033 		return err;
9034 
9035 	/* Create the MSD control */
9036 	err = scarlett2_add_msd_ctl(mixer);
9037 	if (err < 0)
9038 		return err;
9039 
9040 	/* If MSD mode is enabled, or if the firmware version is too
9041 	 * old, don't create any other controls
9042 	 */
9043 	if (private->msd_switch ||
9044 	    private->firmware_version < private->info->min_firmware_version)
9045 		return 0;
9046 
9047 	/* Create the analogue output controls */
9048 	err = scarlett2_add_line_out_ctls(mixer);
9049 	if (err < 0)
9050 		return err;
9051 
9052 	/* Create the analogue input controls */
9053 	err = scarlett2_add_line_in_ctls(mixer);
9054 	if (err < 0)
9055 		return err;
9056 
9057 	/* Create the input, output, and mixer mux input selections */
9058 	err = scarlett2_add_mux_enums(mixer);
9059 	if (err < 0)
9060 		return err;
9061 
9062 	/* Create the matrix mixer controls */
9063 	err = scarlett2_add_mixer_ctls(mixer);
9064 	if (err < 0)
9065 		return err;
9066 
9067 	/* Create the level meter controls */
9068 	err = scarlett2_add_meter_ctl(mixer);
9069 	if (err < 0)
9070 		return err;
9071 
9072 	/* Create the sync control */
9073 	err = scarlett2_add_sync_ctl(mixer);
9074 	if (err < 0)
9075 		return err;
9076 
9077 	/* Create the direct monitor control(s) */
9078 	err = scarlett2_add_direct_monitor_ctls(mixer);
9079 	if (err < 0)
9080 		return err;
9081 
9082 	/* Create the speaker switching control */
9083 	err = scarlett2_add_speaker_switch_ctl(mixer);
9084 	if (err < 0)
9085 		return err;
9086 
9087 	/* Create the talkback controls */
9088 	err = scarlett2_add_talkback_ctls(mixer);
9089 	if (err < 0)
9090 		return err;
9091 
9092 	/* Create the standalone control */
9093 	err = scarlett2_add_standalone_ctl(mixer);
9094 	if (err < 0)
9095 		return err;
9096 
9097 	/* Create the power status control */
9098 	err = scarlett2_add_power_status_ctl(mixer);
9099 	if (err < 0)
9100 		return err;
9101 
9102 	/* Create the Bluetooth volume control */
9103 	err = scarlett2_add_bluetooth_volume_ctl(mixer);
9104 	if (err < 0)
9105 		return err;
9106 
9107 	/* Create the S/PDIF mode control */
9108 	err = scarlett2_add_spdif_mode_ctl(mixer);
9109 	if (err < 0)
9110 		return err;
9111 
9112 	/* Set the access mode of controls disabled during
9113 	 * autogain/phantom power switching.
9114 	 */
9115 	if (private->info->gain_input_count) {
9116 		scarlett2_autogain_update_access(mixer);
9117 		scarlett2_phantom_update_access(mixer);
9118 	}
9119 
9120 	/* Start handling all notifications */
9121 	private->running = 2;
9122 
9123 	return 0;
9124 }
9125 
9126 /*** hwdep interface ***/
9127 
9128 /* Set private->hwdep_in_use; prevents access to the ALSA controls
9129  * while doing a config erase/firmware upgrade.
9130  */
scarlett2_lock(struct scarlett2_data * private)9131 static void scarlett2_lock(struct scarlett2_data *private)
9132 {
9133 	mutex_lock(&private->data_mutex);
9134 	private->hwdep_in_use = 1;
9135 	mutex_unlock(&private->data_mutex);
9136 }
9137 
9138 /* Call SCARLETT2_USB_GET_ERASE to get the erase progress */
scarlett2_get_erase_progress(struct usb_mixer_interface * mixer)9139 static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)
9140 {
9141 	struct scarlett2_data *private = mixer->private_data;
9142 	int segment_id, segment_num, err;
9143 	u8 erase_resp;
9144 
9145 	struct {
9146 		__le32 segment_num;
9147 		__le32 pad;
9148 	} __packed erase_req;
9149 
9150 	segment_id = private->selected_flash_segment_id;
9151 	segment_num = private->flash_segment_nums[segment_id];
9152 
9153 	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
9154 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX)
9155 		return -EFAULT;
9156 
9157 	/* Send the erase progress request */
9158 	erase_req.segment_num = cpu_to_le32(segment_num);
9159 	erase_req.pad = 0;
9160 
9161 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9162 			    &erase_req, sizeof(erase_req),
9163 			    &erase_resp, sizeof(erase_resp));
9164 	if (err < 0)
9165 		return err;
9166 
9167 	return erase_resp;
9168 }
9169 
9170 /* Repeatedly call scarlett2_get_erase_progress() until it returns
9171  * 0xff (erase complete) or we've waited 10 seconds (it usually takes
9172  * <3 seconds).
9173  */
scarlett2_wait_for_erase(struct usb_mixer_interface * mixer)9174 static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer)
9175 {
9176 	int i, err;
9177 
9178 	for (i = 0; i < 100; i++) {
9179 		err = scarlett2_get_erase_progress(mixer);
9180 		if (err < 0)
9181 			return err;
9182 
9183 		if (err == 0xff)
9184 			return 0;
9185 
9186 		msleep(100);
9187 	}
9188 
9189 	return -ETIMEDOUT;
9190 }
9191 
9192 /* Reboot the device; wait for the erase to complete if one is in
9193  * progress.
9194  */
scarlett2_reboot(struct usb_mixer_interface * mixer)9195 static int scarlett2_reboot(struct usb_mixer_interface *mixer)
9196 {
9197 	struct scarlett2_data *private = mixer->private_data;
9198 
9199 	if (private->flash_write_state ==
9200 	      SCARLETT2_FLASH_WRITE_STATE_ERASING) {
9201 		int err = scarlett2_wait_for_erase(mixer);
9202 
9203 		if (err < 0)
9204 			return err;
9205 	}
9206 
9207 	return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0);
9208 }
9209 
9210 /* Select a flash segment for reading/erasing/writing */
scarlett2_ioctl_select_flash_segment(struct usb_mixer_interface * mixer,unsigned long arg)9211 static int scarlett2_ioctl_select_flash_segment(
9212 	struct usb_mixer_interface *mixer,
9213 	unsigned long arg)
9214 {
9215 	struct scarlett2_data *private = mixer->private_data;
9216 	int segment_id, segment_num;
9217 
9218 	if (get_user(segment_id, (int __user *)arg))
9219 		return -EFAULT;
9220 
9221 	/* Check the segment ID and segment number */
9222 	if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT)
9223 		return -EINVAL;
9224 
9225 	segment_num = private->flash_segment_nums[segment_id];
9226 	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
9227 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX) {
9228 		usb_audio_err(mixer->chip,
9229 			      "%s: invalid segment number %d\n",
9230 			      __func__, segment_id);
9231 		return -EFAULT;
9232 	}
9233 
9234 	/* If erasing, wait for it to complete */
9235 	if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {
9236 		int err = scarlett2_wait_for_erase(mixer);
9237 
9238 		if (err < 0)
9239 			return err;
9240 	}
9241 
9242 	/* Save the selected segment ID and set the state to SELECTED */
9243 	private->selected_flash_segment_id = segment_id;
9244 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;
9245 
9246 	return 0;
9247 }
9248 
9249 /* Erase the previously-selected flash segment */
scarlett2_ioctl_erase_flash_segment(struct usb_mixer_interface * mixer)9250 static int scarlett2_ioctl_erase_flash_segment(
9251 	struct usb_mixer_interface *mixer)
9252 {
9253 	struct scarlett2_data *private = mixer->private_data;
9254 	int segment_id, segment_num, err;
9255 
9256 	struct {
9257 		__le32 segment_num;
9258 		__le32 pad;
9259 	} __packed erase_req;
9260 
9261 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
9262 		return -EINVAL;
9263 
9264 	segment_id = private->selected_flash_segment_id;
9265 	segment_num = private->flash_segment_nums[segment_id];
9266 
9267 	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
9268 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX)
9269 		return -EFAULT;
9270 
9271 	/* Prevent access to ALSA controls that access the device from
9272 	 * here on
9273 	 */
9274 	scarlett2_lock(private);
9275 
9276 	/* Send the erase request */
9277 	erase_req.segment_num = cpu_to_le32(segment_num);
9278 	erase_req.pad = 0;
9279 
9280 	err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,
9281 			    &erase_req, sizeof(erase_req),
9282 			    NULL, 0);
9283 	if (err < 0)
9284 		return err;
9285 
9286 	/* On success, change the state from SELECTED to ERASING */
9287 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;
9288 
9289 	return 0;
9290 }
9291 
9292 /* Get the erase progress from the device */
scarlett2_ioctl_get_erase_progress(struct usb_mixer_interface * mixer,unsigned long arg)9293 static int scarlett2_ioctl_get_erase_progress(
9294 	struct usb_mixer_interface *mixer,
9295 	unsigned long arg)
9296 {
9297 	struct scarlett2_data *private = mixer->private_data;
9298 	struct scarlett2_flash_segment_erase_progress progress;
9299 	int segment_id, segment_num, err;
9300 	u8 erase_resp;
9301 
9302 	struct {
9303 		__le32 segment_num;
9304 		__le32 pad;
9305 	} __packed erase_req;
9306 
9307 	/* Check that we're erasing */
9308 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
9309 		return -EINVAL;
9310 
9311 	segment_id = private->selected_flash_segment_id;
9312 	segment_num = private->flash_segment_nums[segment_id];
9313 
9314 	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
9315 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX)
9316 		return -EFAULT;
9317 
9318 	/* Send the erase progress request */
9319 	erase_req.segment_num = cpu_to_le32(segment_num);
9320 	erase_req.pad = 0;
9321 
9322 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9323 			    &erase_req, sizeof(erase_req),
9324 			    &erase_resp, sizeof(erase_resp));
9325 	if (err < 0)
9326 		return err;
9327 
9328 	progress.progress = erase_resp;
9329 	progress.num_blocks = private->flash_segment_blocks[segment_id];
9330 
9331 	if (copy_to_user((void __user *)arg, &progress, sizeof(progress)))
9332 		return -EFAULT;
9333 
9334 	/* If the erase is complete, change the state from ERASING to
9335 	 * WRITE.
9336 	 */
9337 	if (progress.progress == 0xff)
9338 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9339 
9340 	return 0;
9341 }
9342 
scarlett2_hwdep_open(struct snd_hwdep * hw,struct file * file)9343 static int scarlett2_hwdep_open(struct snd_hwdep *hw, struct file *file)
9344 {
9345 	struct usb_mixer_interface *mixer = hw->private_data;
9346 	struct scarlett2_data *private = mixer->private_data;
9347 
9348 	/* If erasing, wait for it to complete */
9349 	if (private->flash_write_state ==
9350 	      SCARLETT2_FLASH_WRITE_STATE_ERASING) {
9351 		int err = scarlett2_wait_for_erase(mixer);
9352 
9353 		if (err < 0)
9354 			return err;
9355 	}
9356 
9357 	/* Set the state to IDLE */
9358 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9359 
9360 	return 0;
9361 }
9362 
scarlett2_hwdep_ioctl(struct snd_hwdep * hw,struct file * file,unsigned int cmd,unsigned long arg)9363 static int scarlett2_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
9364 				 unsigned int cmd, unsigned long arg)
9365 {
9366 	struct usb_mixer_interface *mixer = hw->private_data;
9367 
9368 	switch (cmd) {
9369 
9370 	case SCARLETT2_IOCTL_PVERSION:
9371 		return put_user(SCARLETT2_HWDEP_VERSION,
9372 				(int __user *)arg) ? -EFAULT : 0;
9373 
9374 	case SCARLETT2_IOCTL_REBOOT:
9375 		return scarlett2_reboot(mixer);
9376 
9377 	case SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT:
9378 		return scarlett2_ioctl_select_flash_segment(mixer, arg);
9379 
9380 	case SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT:
9381 		return scarlett2_ioctl_erase_flash_segment(mixer);
9382 
9383 	case SCARLETT2_IOCTL_GET_ERASE_PROGRESS:
9384 		return scarlett2_ioctl_get_erase_progress(mixer, arg);
9385 
9386 	default:
9387 		return -ENOIOCTLCMD;
9388 	}
9389 }
9390 
scarlett2_hwdep_read(struct snd_hwdep * hw,char __user * buf,long count,loff_t * offset)9391 static long scarlett2_hwdep_read(struct snd_hwdep *hw,
9392 				 char __user *buf,
9393 				 long count, loff_t *offset)
9394 {
9395 	struct usb_mixer_interface *mixer = hw->private_data;
9396 	struct scarlett2_data *private = mixer->private_data;
9397 	int segment_id, segment_num, err;
9398 	int flash_size;
9399 
9400 	/* SCARLETT2_USB_READ_SEGMENT request data */
9401 	struct {
9402 		__le32 segment_num;
9403 		__le32 offset;
9404 		__le32 len;
9405 	} __packed req;
9406 
9407 	u8 *resp;
9408 
9409 	/* Flash segment must first be selected */
9410 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
9411 		return -EINVAL;
9412 
9413 	/* Get the selected flash segment number */
9414 	segment_id = private->selected_flash_segment_id;
9415 	if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT)
9416 		return -EINVAL;
9417 
9418 	segment_num = private->flash_segment_nums[segment_id];
9419 	if (segment_num < 0 ||
9420 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX)
9421 		return -EFAULT;
9422 
9423 	/* Validate the offset and count */
9424 	if (count < 0 || *offset < 0)
9425 		return -EINVAL;
9426 
9427 	/* Reached EOF? */
9428 	flash_size = private->flash_segment_blocks[segment_id] *
9429 		     SCARLETT2_FLASH_BLOCK_SIZE;
9430 	if (!count || *offset >= flash_size)
9431 		return 0;
9432 
9433 	/* Limit the numbers of bytes read to SCARLETT2_FLASH_RW_MAX */
9434 	if (count > SCARLETT2_FLASH_RW_MAX)
9435 		count = SCARLETT2_FLASH_RW_MAX;
9436 
9437 	/* Limit read to EOF */
9438 	if (*offset + count >= flash_size)
9439 		count = flash_size - *offset;
9440 
9441 	/* Create and send the request */
9442 	req.segment_num = cpu_to_le32(segment_num);
9443 	req.offset = cpu_to_le32(*offset);
9444 	req.len = cpu_to_le32(count);
9445 
9446 	resp = kzalloc(count, GFP_KERNEL);
9447 	if (!resp)
9448 		return -ENOMEM;
9449 
9450 	err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT,
9451 			    &req, sizeof(req), resp, count);
9452 	if (err < 0)
9453 		goto error;
9454 
9455 	/* Copy the response to userspace */
9456 	if (copy_to_user(buf, resp, count)) {
9457 		err = -EFAULT;
9458 		goto error;
9459 	}
9460 
9461 	*offset += count;
9462 	err = count;
9463 
9464 error:
9465 	kfree(resp);
9466 	return err;
9467 }
9468 
scarlett2_hwdep_write(struct snd_hwdep * hw,const char __user * buf,long count,loff_t * offset)9469 static long scarlett2_hwdep_write(struct snd_hwdep *hw,
9470 				  const char __user *buf,
9471 				  long count, loff_t *offset)
9472 {
9473 	struct usb_mixer_interface *mixer = hw->private_data;
9474 	struct scarlett2_data *private = mixer->private_data;
9475 	int segment_id, segment_num, err, len;
9476 	int flash_size;
9477 
9478 	/* SCARLETT2_USB_WRITE_SEGMENT request data */
9479 	struct {
9480 		__le32 segment_num;
9481 		__le32 offset;
9482 		__le32 pad;
9483 		u8 data[];
9484 	} __packed *req;
9485 
9486 	/* Calculate the maximum permitted in data[] */
9487 	const size_t max_data_size = SCARLETT2_FLASH_RW_MAX -
9488 				     offsetof(typeof(*req), data);
9489 
9490 	/* If erasing, wait for it to complete */
9491 	if (private->flash_write_state ==
9492 	      SCARLETT2_FLASH_WRITE_STATE_ERASING) {
9493 		err = scarlett2_wait_for_erase(mixer);
9494 		if (err < 0)
9495 			return err;
9496 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9497 
9498 	/* Check that an erase has been done & completed */
9499 	} else if (private->flash_write_state !=
9500 		     SCARLETT2_FLASH_WRITE_STATE_WRITE) {
9501 		return -EINVAL;
9502 	}
9503 
9504 	/* Check that we're writing to the upgrade firmware */
9505 	segment_id = private->selected_flash_segment_id;
9506 	if (segment_id != SCARLETT2_SEGMENT_ID_FIRMWARE)
9507 		return -EINVAL;
9508 
9509 	segment_num = private->flash_segment_nums[segment_id];
9510 	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
9511 	    segment_num > SCARLETT2_SEGMENT_NUM_MAX)
9512 		return -EFAULT;
9513 
9514 	/* Validate the offset and count */
9515 	flash_size = private->flash_segment_blocks[segment_id] *
9516 		     SCARLETT2_FLASH_BLOCK_SIZE;
9517 
9518 	if (count < 0 || *offset < 0 || *offset + count >= flash_size)
9519 		return -EINVAL;
9520 
9521 	if (!count)
9522 		return 0;
9523 
9524 	/* Limit the *req size to SCARLETT2_FLASH_RW_MAX */
9525 	if (count > max_data_size)
9526 		count = max_data_size;
9527 
9528 	/* Create and send the request */
9529 	len = struct_size(req, data, count);
9530 	req = kzalloc(len, GFP_KERNEL);
9531 	if (!req)
9532 		return -ENOMEM;
9533 
9534 	req->segment_num = cpu_to_le32(segment_num);
9535 	req->offset = cpu_to_le32(*offset);
9536 	req->pad = 0;
9537 
9538 	if (copy_from_user(req->data, buf, count)) {
9539 		err = -EFAULT;
9540 		goto error;
9541 	}
9542 
9543 	err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT,
9544 			    req, len, NULL, 0);
9545 	if (err < 0)
9546 		goto error;
9547 
9548 	*offset += count;
9549 	err = count;
9550 
9551 error:
9552 	kfree(req);
9553 	return err;
9554 }
9555 
scarlett2_hwdep_release(struct snd_hwdep * hw,struct file * file)9556 static int scarlett2_hwdep_release(struct snd_hwdep *hw, struct file *file)
9557 {
9558 	struct usb_mixer_interface *mixer = hw->private_data;
9559 	struct scarlett2_data *private = mixer->private_data;
9560 
9561 	/* Return from the SELECTED or WRITE state to IDLE.
9562 	 * The ERASING state is left as-is, and checked on next open.
9563 	 */
9564 	if (private &&
9565 	    private->hwdep_in_use &&
9566 	    private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
9567 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9568 
9569 	return 0;
9570 }
9571 
scarlett2_hwdep_init(struct usb_mixer_interface * mixer)9572 static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer)
9573 {
9574 	struct snd_hwdep *hw;
9575 	int err;
9576 
9577 	err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);
9578 	if (err < 0)
9579 		return err;
9580 
9581 	hw->private_data = mixer;
9582 	hw->exclusive = 1;
9583 	hw->ops.open = scarlett2_hwdep_open;
9584 	hw->ops.ioctl = scarlett2_hwdep_ioctl;
9585 	hw->ops.read = scarlett2_hwdep_read;
9586 	hw->ops.write = scarlett2_hwdep_write;
9587 	hw->ops.release = scarlett2_hwdep_release;
9588 
9589 	return 0;
9590 }
9591 
snd_scarlett2_init(struct usb_mixer_interface * mixer)9592 int snd_scarlett2_init(struct usb_mixer_interface *mixer)
9593 {
9594 	struct snd_usb_audio *chip = mixer->chip;
9595 	const struct scarlett2_device_entry *entry;
9596 	int err;
9597 
9598 	/* only use UAC_VERSION_2 */
9599 	if (!mixer->protocol)
9600 		return 0;
9601 
9602 	/* find entry in scarlett2_devices */
9603 	entry = get_scarlett2_device_entry(mixer);
9604 	if (!entry) {
9605 		usb_audio_err(mixer->chip,
9606 			      "%s: missing device entry for %04x:%04x\n",
9607 			      __func__,
9608 			      USB_ID_VENDOR(chip->usb_id),
9609 			      USB_ID_PRODUCT(chip->usb_id));
9610 		return 0;
9611 	}
9612 
9613 	if (chip->setup & SCARLETT2_DISABLE) {
9614 		usb_audio_info(chip,
9615 			"Focusrite %s Mixer Driver disabled "
9616 			"by modprobe options (snd_usb_audio "
9617 			"vid=0x%04x pid=0x%04x device_setup=%d)\n",
9618 			entry->series_name,
9619 			USB_ID_VENDOR(chip->usb_id),
9620 			USB_ID_PRODUCT(chip->usb_id),
9621 			SCARLETT2_DISABLE);
9622 		return 0;
9623 	}
9624 
9625 	usb_audio_info(chip,
9626 		"Focusrite %s Mixer Driver enabled (pid=0x%04x); "
9627 		"report any issues to "
9628 		"https://github.com/geoffreybennett/scarlett-gen2/issues",
9629 		entry->series_name,
9630 		USB_ID_PRODUCT(chip->usb_id));
9631 
9632 	err = snd_scarlett2_controls_create(mixer, entry);
9633 	if (err < 0) {
9634 		usb_audio_err(mixer->chip,
9635 			      "Error initialising %s Mixer Driver: %d",
9636 			      entry->series_name,
9637 			      err);
9638 		return err;
9639 	}
9640 
9641 	err = scarlett2_hwdep_init(mixer);
9642 	if (err < 0)
9643 		usb_audio_err(mixer->chip,
9644 			      "Error creating %s hwdep device: %d",
9645 			      entry->series_name,
9646 			      err);
9647 
9648 	return err;
9649 }
9650