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