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