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