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