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