1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Focusrite Scarlett 2 Protocol Driver for ALSA
4	* (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and
5	* Clarett+ series products)
6	*
7	* Supported models:
8	* - 6i6/18i8/18i20 Gen 2
9	* - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
10	* - Solo/2i2/4i4 Gen 4
11	* - Clarett 2Pre/4Pre/8Pre USB
12	* - Clarett+ 2Pre/4Pre/8Pre
13	*
14	* Copyright (c) 2018-2023 by Geoffrey D. Bennett <g at b4.vu>
15	* Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
16	* Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com>
17	*
18	* Based on the Scarlett (Gen 1) Driver for ALSA:
19	*
20	* Copyright (c) 2013 by Tobias Hoffmann
21	* Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
22	* Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
23	* Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
24	*
25	* Many codes borrowed from audio.c by
26	* Alan Cox (alan at lxorguk.ukuu.org.uk)
27	* Thomas Sailer (sailer at ife.ee.ethz.ch)
28	*
29	* Code cleanup:
30	* David Henningsson <david.henningsson at canonical.com>
31	*/
32
33	/* The protocol was reverse engineered by looking at the communication
34	* between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
35	* (firmware 1083) using usbmon in July-August 2018.
36	*
37	* Scarlett 18i8 support added in April 2019.
38	*
39	* Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
40	* for providing usbmon output and testing).
41	*
42	* Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
43	* Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
44	* usbmon output and testing).
45	*
46	* Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
47	* Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon
48	* output, protocol traces and testing).
49	*
50	* Support for loading mixer volume and mux configuration from the
51	* interface during driver initialisation added in May 2021 (thanks to
52	* Vladimir Sadovnikov for figuring out how).
53	*
54	* Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
55	* Vorona for 2i2 protocol traces).
56	*
57	* Support for phantom power, direct monitoring, speaker switching,
58	* and talkback added in May-June 2021.
59	*
60	* Support for Clarett+ 8Pre added in Aug 2022 by Christian
61	* Colglazier.
62	*
63	* Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe
64	* Perrot for confirmation).
65	*
66	* Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to
67	* Gregory Rozzo for donating a 4Pre, and David Sherwood and Patrice
68	* Peterson for usbmon output).
69	*
70	* Support for Clarett 2Pre and 4Pre USB added in Oct 2023.
71	*
72	* Support for firmware updates added in Dec 2023.
73	*
74	* Support for Scarlett Solo/2i2/4i4 Gen 4 added in Dec 2023 (thanks
75	* to many LinuxMusicians people and to Focusrite for hardware
76	* donations).
77	*
78	* This ALSA mixer gives access to (model-dependent):
79	* - input, output, mixer-matrix muxes
80	* - mixer-matrix gain stages
81	* - gain/volume/mute controls
82	* - level meters
83	* - line/inst level, pad, and air controls
84	* - phantom power, direct monitor, speaker switching, and talkback
85	* controls
86	* - disable/enable MSD mode
87	* - disable/enable standalone mode
88	* - input gain, autogain, safe mode
89	* - direct monitor mixes
90	*
91	* <ditaa>
92	* /--------------\ 18chn 20chn /--------------\
93	* | Hardware in +--+------\ /-------------+--+ ALSA PCM out |
94	* \--------------/ | | | | \--------------/
95	* | | | /-----\ |
96	* | | | | | |
97	* | v v v | |
98	* | +---------------+ | |
99	* | \ Matrix Mux / | |
100	* | +-----+-----+ | |
101	* | | | |
102	* | |18chn | |
103	* | | | |
104	* | | 10chn| |
105	* | v | |
106	* | +------------+ | |
107	* | | Mixer | | |
108	* | | Matrix | | |
109	* | | | | |
110	* | | 18x10 Gain | | |
111	* | | stages | | |
112	* | +-----+------+ | |
113	* | | | |
114	* |18chn |10chn | |20chn
115	* | | | |
116	* | +----------/ |
117	* | | |
118	* v v v
119	* ===========================
120	* +---------------+ +--—------------+
121	* \ Output Mux / \ Capture Mux /
122	* +---+---+---+ +-----+-----+
123	* | | |
124	* 10chn| | |18chn
125	* | | |
126	* /--------------\ | | | /--------------\
127	* | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in |
128	* | Hardware out | | \--------------/
129	* \--------------/ |
130	* v
131	* +-------------+ Software gain per channel.
132	* | Master Gain |<-- 18i20 only: Switch per channel
133	* +------+------+ to select HW or SW gain control.
134	* |
135	* |10chn
136	* /--------------\ |
137	* | Analogue |<------/
138	* | Hardware out |
139	* \--------------/
140	* </ditaa>
141	*
142	* Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small
143	* disk with registration and driver download information is presented
144	* to the host. To access the full functionality of the device without
145	* proprietary software, MSD mode can be disabled by:
146	* - holding down the 48V button for five seconds while powering on
147	* the device, or
148	* - using this driver and alsamixer to change the "MSD Mode" setting
149	* to Off and power-cycling the device
150	*/
151
152	#include <linux/slab.h>
153	#include <linux/usb.h>
154	#include <linux/moduleparam.h>
155
156	#include <sound/control.h>
157	#include <sound/tlv.h>
158	#include <sound/hwdep.h>
159
160	#include <uapi/sound/scarlett2.h>
161
162	#include "usbaudio.h"
163	#include "mixer.h"
164	#include "helper.h"
165
166	#include "mixer_scarlett2.h"
167
168	/* device_setup value to allow turning MSD mode back on */
169	#define SCARLETT2_MSD_ENABLE 0x02
170
171	/* device_setup value to disable this mixer driver */
172	#define SCARLETT2_DISABLE 0x04
173
174	/* some gui mixers can't handle negative ctl values */
175	#define SCARLETT2_VOLUME_BIAS 127
176
177	/* maximum preamp input gain and value
178	* values are from 0 to 70, preamp gain is from 0 to 69 dB
179	*/
180	#define SCARLETT2_MAX_GAIN_VALUE 70
181	#define SCARLETT2_MAX_GAIN_DB 69
182
183	/* mixer range from -80dB to +6dB in 0.5dB steps */
184	#define SCARLETT2_MIXER_MIN_DB -80
185	#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
186	#define SCARLETT2_MIXER_MAX_DB 6
187	#define SCARLETT2_MIXER_MAX_VALUE \
188	((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
189	#define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1)
190
191	/* map from (dB + 80) * 2 to mixer value
192	* for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
193	*/
194	static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = {
195	0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
196	2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
197	9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
198	23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
199	54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
200	122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
201	244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
202	487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
203	973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
204	1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
205	3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
206	5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
207	9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
208	16345
209	};
210
211	/* Maximum number of analogue outputs */
212	#define SCARLETT2_ANALOGUE_MAX 10
213
214	/* Maximum number of various input controls */
215	#define SCARLETT2_LEVEL_SWITCH_MAX 2
216	#define SCARLETT2_PAD_SWITCH_MAX 8
217	#define SCARLETT2_AIR_SWITCH_MAX 8
218	#define SCARLETT2_PHANTOM_SWITCH_MAX 2
219	#define SCARLETT2_INPUT_GAIN_MAX 2
220
221	/* Maximum number of inputs to the mixer */
222	#define SCARLETT2_INPUT_MIX_MAX 25
223
224	/* Maximum number of outputs from the mixer */
225	#define SCARLETT2_OUTPUT_MIX_MAX 12
226
227	/* Maximum number of mixer gain controls */
228	#define SCARLETT2_MIX_MAX (SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX)
229
230	/* Maximum number of direct monitor mixer gain controls
231	* 1 (Solo) or 2 (2i2) direct monitor selections (Mono & Stereo)
232	* 2 Mix outputs (A/Left & B/Right)
233	* 4 Mix inputs
234	*/
235	#define SCARLETT2_MONITOR_MIX_MAX (2 * 2 * 4)
236
237	/* Maximum size of the data in the USB mux assignment message:
238	* 20 inputs, 20 outputs, 25 matrix inputs, 12 spare
239	*/
240	#define SCARLETT2_MUX_MAX 77
241
242	/* Maximum number of sources (sum of input port counts) */
243	#define SCARLETT2_MAX_SRCS 52
244
245	/* Maximum number of meters (sum of output port counts) */
246	#define SCARLETT2_MAX_METERS 65
247
248	/* Hardware port types:
249	* - None (no input to mux)
250	* - Analogue I/O
251	* - S/PDIF I/O
252	* - ADAT I/O
253	* - Mixer I/O
254	* - PCM I/O
255	*/
256	enum {
257	SCARLETT2_PORT_TYPE_NONE,
258	SCARLETT2_PORT_TYPE_ANALOGUE,
259	SCARLETT2_PORT_TYPE_SPDIF,
260	SCARLETT2_PORT_TYPE_ADAT,
261	SCARLETT2_PORT_TYPE_MIX,
262	SCARLETT2_PORT_TYPE_PCM,
263	SCARLETT2_PORT_TYPE_COUNT
264	};
265
266	/* I/O count of each port type kept in struct scarlett2_ports */
267	enum {
268	SCARLETT2_PORT_IN,
269	SCARLETT2_PORT_OUT,
270	SCARLETT2_PORT_DIRNS
271	};
272
273	/* Dim/Mute buttons on the 18i20 */
274	enum {
275	SCARLETT2_BUTTON_MUTE,
276	SCARLETT2_BUTTON_DIM,
277	SCARLETT2_DIM_MUTE_COUNT
278	};
279
280	/* Flash Write State */
281	enum {
282	SCARLETT2_FLASH_WRITE_STATE_IDLE,
283	SCARLETT2_FLASH_WRITE_STATE_SELECTED,
284	SCARLETT2_FLASH_WRITE_STATE_ERASING,
285	SCARLETT2_FLASH_WRITE_STATE_WRITE
286	};
287
288	static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = {
289	"Mute Playback Switch", "Dim Playback Switch"
290	};
291
292	/* The autogain_status is set based on the autogain_switch and
293	* raw_autogain_status values.
294	*
295	* If autogain_switch is set, autogain_status is set to 0 (Running).
296	* The other status values are from the raw_autogain_status value + 1.
297	*/
298	static const char *const scarlett2_autogain_status_texts[] = {
299	"Running",
300	"Success",
301	"SuccessDRover",
302	"WarnMinGainLimit",
303	"FailDRunder",
304	"FailMaxGainLimit",
305	"FailClipped",
306	"Cancelled",
307	"Invalid"
308	};
309
310	/* Power Status Values */
311	enum {
312	SCARLETT2_POWER_STATUS_EXT,
313	SCARLETT2_POWER_STATUS_BUS,
314	SCARLETT2_POWER_STATUS_FAIL,
315	SCARLETT2_POWER_STATUS_COUNT
316	};
317
318	/* Notification callback functions */
319	struct scarlett2_notification {
320	u32 mask;
321	void (*func)(struct usb_mixer_interface *mixer);
322	};
323
324	static void scarlett2_notify_sync(struct usb_mixer_interface *mixer);
325	static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer);
326	static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer);
327	static void scarlett2_notify_volume(struct usb_mixer_interface *mixer);
328	static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer);
329	static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer);
330	static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer);
331	static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer);
332	static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer);
333	static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer);
334	static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer);
335	static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer);
336	static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer);
337	static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer);
338	static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer);
339	static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer);
340	static void scarlett2_notify_pcm_input_switch(
341	struct usb_mixer_interface *mixer);
342
343	/* Arrays of notification callback functions */
344
345	static const struct scarlett2_notification scarlett2_notifications[] = {
346	{ 0x00000001, NULL }, /* ack, gets ignored */
347	{ 0x00000008, scarlett2_notify_sync },
348	{ 0x00200000, scarlett2_notify_dim_mute },
349	{ 0x00400000, scarlett2_notify_monitor },
350	{ 0x00800000, scarlett2_notify_input_other },
351	{ 0x01000000, scarlett2_notify_monitor_other },
352	{ 0, NULL }
353	};
354
355	static const struct scarlett2_notification scarlett3a_notifications[] = {
356	{ 0x00000001, NULL }, /* ack, gets ignored */
357	{ 0x00800000, scarlett2_notify_input_other },
358	{ 0x01000000, scarlett2_notify_direct_monitor },
359	{ 0, NULL }
360	};
361
362	static const struct scarlett2_notification scarlett4_solo_notifications[] = {
363	{ 0x00000001, NULL }, /* ack, gets ignored */
364	{ 0x00000008, scarlett2_notify_sync },
365	{ 0x00400000, scarlett2_notify_input_air },
366	{ 0x00800000, scarlett2_notify_direct_monitor },
367	{ 0x01000000, scarlett2_notify_input_level },
368	{ 0x02000000, scarlett2_notify_input_phantom },
369	{ 0x04000000, scarlett2_notify_pcm_input_switch },
370	{ 0, NULL }
371	};
372
373	static const struct scarlett2_notification scarlett4_2i2_notifications[] = {
374	{ 0x00000001, NULL }, /* ack, gets ignored */
375	{ 0x00000008, scarlett2_notify_sync },
376	{ 0x00200000, scarlett2_notify_input_safe },
377	{ 0x00400000, scarlett2_notify_autogain },
378	{ 0x00800000, scarlett2_notify_input_air },
379	{ 0x01000000, scarlett2_notify_direct_monitor },
380	{ 0x02000000, scarlett2_notify_input_select },
381	{ 0x04000000, scarlett2_notify_input_level },
382	{ 0x08000000, scarlett2_notify_input_phantom },
383	{ 0x10000000, NULL }, /* power status, ignored */
384	{ 0x40000000, scarlett2_notify_input_gain },
385	{ 0x80000000, NULL }, /* power status, ignored */
386	{ 0, NULL }
387	};
388
389	static const struct scarlett2_notification scarlett4_4i4_notifications[] = {
390	{ 0x00000001, NULL }, /* ack, gets ignored */
391	{ 0x00000008, scarlett2_notify_sync },
392	{ 0x00200000, scarlett2_notify_input_safe },
393	{ 0x00400000, scarlett2_notify_autogain },
394	{ 0x00800000, scarlett2_notify_input_air },
395	{ 0x01000000, scarlett2_notify_input_select },
396	{ 0x02000000, scarlett2_notify_input_level },
397	{ 0x04000000, scarlett2_notify_input_phantom },
398	{ 0x08000000, scarlett2_notify_power_status }, /* power external */
399	{ 0x20000000, scarlett2_notify_input_gain },
400	{ 0x40000000, scarlett2_notify_power_status }, /* power status */
401	{ 0x80000000, scarlett2_notify_volume },
402	{ 0, NULL }
403	};
404
405	/* Configuration parameters that can be read and written */
406	enum {
407	SCARLETT2_CONFIG_DIM_MUTE,
408	SCARLETT2_CONFIG_LINE_OUT_VOLUME,
409	SCARLETT2_CONFIG_MUTE_SWITCH,
410	SCARLETT2_CONFIG_SW_HW_SWITCH,
411	SCARLETT2_CONFIG_MASTER_VOLUME,
412	SCARLETT2_CONFIG_HEADPHONE_VOLUME,
413	SCARLETT2_CONFIG_LEVEL_SWITCH,
414	SCARLETT2_CONFIG_PAD_SWITCH,
415	SCARLETT2_CONFIG_MSD_SWITCH,
416	SCARLETT2_CONFIG_AIR_SWITCH,
417	SCARLETT2_CONFIG_STANDALONE_SWITCH,
418	SCARLETT2_CONFIG_PHANTOM_SWITCH,
419	SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
420	SCARLETT2_CONFIG_DIRECT_MONITOR,
421	SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
422	SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
423	SCARLETT2_CONFIG_TALKBACK_MAP,
424	SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
425	SCARLETT2_CONFIG_AUTOGAIN_STATUS,
426	SCARLETT2_CONFIG_INPUT_GAIN,
427	SCARLETT2_CONFIG_SAFE_SWITCH,
428	SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
429	SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
430	SCARLETT2_CONFIG_POWER_EXT,
431	SCARLETT2_CONFIG_POWER_LOW,
432	SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
433	SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
434	SCARLETT2_CONFIG_COUNT
435	};
436
437	/* Location, size, and activation command number for the configuration
438	* parameters. Size is in bits and may be 0, 1, 8, or 16.
439	*
440	* A size of 0 indicates that the parameter is a byte-sized Scarlett
441	* Gen 4 configuration which is written through the gen4_write_addr
442	* location (but still read through the given offset location).
443	*
444	* Some Gen 4 configuration parameters are written with 0x02 for a
445	* desired value of 0x01, and 0x03 for 0x00. These are indicated with
446	* mute set to 1. 0x02 and 0x03 are temporary values while the device
447	* makes the change and the channel and/or corresponding DSP channel
448	* output is muted.
449	*/
450	struct scarlett2_config {
451	u16 offset;
452	u8 size;
453	u8 activate;
454	u8 mute;
455	};
456
457	struct scarlett2_config_set {
458	const struct scarlett2_notification *notifications;
459	u16 gen4_write_addr;
460	const struct scarlett2_config items[SCARLETT2_CONFIG_COUNT];
461	};
462
463	/* Gen 2 devices without SW/HW volume switch: 6i6, 18i8 */
464
465	static const struct scarlett2_config_set scarlett2_config_set_gen2a = {
466	.notifications = scarlett2_notifications,
467	.items = {
468	[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
469	.offset = 0x34, .size = 16, .activate = 1 },
470
471	[SCARLETT2_CONFIG_MUTE_SWITCH] = {
472	.offset = 0x5c, .size = 8, .activate = 1 },
473
474	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
475	.offset = 0x7c, .size = 8, .activate = 7 },
476
477	[SCARLETT2_CONFIG_PAD_SWITCH] = {
478	.offset = 0x84, .size = 8, .activate = 8 },
479
480	[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
481	.offset = 0x8d, .size = 8, .activate = 6 },
482	}
483	};
484
485	/* Gen 2 devices with SW/HW volume switch: 18i20 */
486
487	static const struct scarlett2_config_set scarlett2_config_set_gen2b = {
488	.notifications = scarlett2_notifications,
489	.items = {
490	[SCARLETT2_CONFIG_DIM_MUTE] = {
491	.offset = 0x31, .size = 8, .activate = 2 },
492
493	[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
494	.offset = 0x34, .size = 16, .activate = 1 },
495
496	[SCARLETT2_CONFIG_MUTE_SWITCH] = {
497	.offset = 0x5c, .size = 8, .activate = 1 },
498
499	[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
500	.offset = 0x66, .size = 8, .activate = 3 },
501
502	[SCARLETT2_CONFIG_MASTER_VOLUME] = {
503	.offset = 0x76, .size = 16 },
504
505	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
506	.offset = 0x7c, .size = 8, .activate = 7 },
507
508	[SCARLETT2_CONFIG_PAD_SWITCH] = {
509	.offset = 0x84, .size = 8, .activate = 8 },
510
511	[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
512	.offset = 0x8d, .size = 8, .activate = 6 },
513	}
514	};
515
516	/* Gen 3 devices without a mixer (Solo and 2i2) */
517	static const struct scarlett2_config_set scarlett2_config_set_gen3a = {
518	.notifications = scarlett3a_notifications,
519	.items = {
520	[SCARLETT2_CONFIG_MSD_SWITCH] = {
521	.offset = 0x04, .size = 8, .activate = 6 },
522
523	[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
524	.offset = 0x05, .size = 8, .activate = 6 },
525
526	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
527	.offset = 0x06, .size = 8, .activate = 3 },
528
529	[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
530	.offset = 0x07, .size = 8, .activate = 4 },
531
532	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
533	.offset = 0x08, .size = 1, .activate = 7 },
534
535	[SCARLETT2_CONFIG_AIR_SWITCH] = {
536	.offset = 0x09, .size = 1, .activate = 8 },
537	}
538	};
539
540	/* Gen 3 devices without SW/HW volume switch: 4i4, 8i6 */
541	static const struct scarlett2_config_set scarlett2_config_set_gen3b = {
542	.notifications = scarlett2_notifications,
543	.items = {
544	[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
545	.offset = 0x34, .size = 16, .activate = 1 },
546
547	[SCARLETT2_CONFIG_MUTE_SWITCH] = {
548	.offset = 0x5c, .size = 8, .activate = 1 },
549
550	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
551	.offset = 0x7c, .size = 8, .activate = 7 },
552
553	[SCARLETT2_CONFIG_PAD_SWITCH] = {
554	.offset = 0x84, .size = 8, .activate = 8 },
555
556	[SCARLETT2_CONFIG_AIR_SWITCH] = {
557	.offset = 0x8c, .size = 8, .activate = 8 },
558
559	[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
560	.offset = 0x95, .size = 8, .activate = 6 },
561
562	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
563	.offset = 0x9c, .size = 1, .activate = 8 },
564
565	[SCARLETT2_CONFIG_MSD_SWITCH] = {
566	.offset = 0x9d, .size = 8, .activate = 6 },
567
568	[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
569	.offset = 0x9e, .size = 8, .activate = 6 },
570	}
571	};
572
573	/* Gen 3 devices with SW/HW volume switch: 18i8, 18i20 */
574	static const struct scarlett2_config_set scarlett2_config_set_gen3c = {
575	.notifications = scarlett2_notifications,
576	.items = {
577	[SCARLETT2_CONFIG_DIM_MUTE] = {
578	.offset = 0x31, .size = 8, .activate = 2 },
579
580	[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
581	.offset = 0x34, .size = 16, .activate = 1 },
582
583	[SCARLETT2_CONFIG_MUTE_SWITCH] = {
584	.offset = 0x5c, .size = 8, .activate = 1 },
585
586	[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
587	.offset = 0x66, .size = 8, .activate = 3 },
588
589	[SCARLETT2_CONFIG_MASTER_VOLUME] = {
590	.offset = 0x76, .size = 16 },
591
592	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
593	.offset = 0x7c, .size = 8, .activate = 7 },
594
595	[SCARLETT2_CONFIG_PAD_SWITCH] = {
596	.offset = 0x84, .size = 8, .activate = 8 },
597
598	[SCARLETT2_CONFIG_AIR_SWITCH] = {
599	.offset = 0x8c, .size = 8, .activate = 8 },
600
601	[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
602	.offset = 0x95, .size = 8, .activate = 6 },
603
604	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
605	.offset = 0x9c, .size = 1, .activate = 8 },
606
607	[SCARLETT2_CONFIG_MSD_SWITCH] = {
608	.offset = 0x9d, .size = 8, .activate = 6 },
609
610	[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
611	.offset = 0x9e, .size = 8, .activate = 6 },
612
613	[SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = {
614	.offset = 0x9f, .size = 1, .activate = 10 },
615
616	[SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = {
617	.offset = 0xa0, .size = 1, .activate = 10 },
618
619	[SCARLETT2_CONFIG_TALKBACK_MAP] = {
620	.offset = 0xb0, .size = 16, .activate = 10 },
621	}
622	};
623
624	/* Solo Gen 4 */
625	static const struct scarlett2_config_set scarlett2_config_set_gen4_solo = {
626	.notifications = scarlett4_solo_notifications,
627	.gen4_write_addr = 0xd8,
628	.items = {
629	[SCARLETT2_CONFIG_MSD_SWITCH] = {
630	.offset = 0x47, .size = 8, .activate = 4 },
631
632	[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
633	.offset = 0x108, .activate = 12 },
634
635	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
636	.offset = 0x46, .activate = 9, .mute = 1 },
637
638	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
639	.offset = 0x3d, .activate = 10, .mute = 1 },
640
641	[SCARLETT2_CONFIG_AIR_SWITCH] = {
642	.offset = 0x3e, .activate = 11 },
643
644	[SCARLETT2_CONFIG_PCM_INPUT_SWITCH] = {
645	.offset = 0x206, .activate = 25 },
646
647	[SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {
648	.offset = 0x232, .size = 16, .activate = 26 }
649	}
650	};
651
652	/* 2i2 Gen 4 */
653	static const struct scarlett2_config_set scarlett2_config_set_gen4_2i2 = {
654	.notifications = scarlett4_2i2_notifications,
655	.gen4_write_addr = 0xfc,
656	.items = {
657	[SCARLETT2_CONFIG_MSD_SWITCH] = {
658	.offset = 0x49, .size = 8, .activate = 4 }, // 0x41 ??
659
660	[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
661	.offset = 0x14a, .activate = 16 },
662
663	[SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {
664	.offset = 0x135, .activate = 10 },
665
666	[SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {
667	.offset = 0x137 },
668
669	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
670	.offset = 0x48, .activate = 11, .mute = 1 },
671
672	[SCARLETT2_CONFIG_INPUT_GAIN] = {
673	.offset = 0x4b, .activate = 12 },
674
675	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
676	.offset = 0x3c, .activate = 13, .mute = 1 },
677
678	[SCARLETT2_CONFIG_SAFE_SWITCH] = {
679	.offset = 0x147, .activate = 14 },
680
681	[SCARLETT2_CONFIG_AIR_SWITCH] = {
682	.offset = 0x3e, .activate = 15 },
683
684	[SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {
685	.offset = 0x14b, .activate = 17 },
686
687	[SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {
688	.offset = 0x14e, .activate = 18 },
689
690	[SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {
691	.offset = 0x2a0, .size = 16, .activate = 36 }
692	}
693	};
694
695	/* 4i4 Gen 4 */
696	static const struct scarlett2_config_set scarlett2_config_set_gen4_4i4 = {
697	.notifications = scarlett4_4i4_notifications,
698	.gen4_write_addr = 0x130,
699	.items = {
700	[SCARLETT2_CONFIG_MSD_SWITCH] = {
701	.offset = 0x5c, .size = 8, .activate = 4 },
702
703	[SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {
704	.offset = 0x13e, .activate = 10 },
705
706	[SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {
707	.offset = 0x140 },
708
709	[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
710	.offset = 0x5a, .activate = 11, .mute = 1 },
711
712	[SCARLETT2_CONFIG_INPUT_GAIN] = {
713	.offset = 0x5e, .activate = 12 },
714
715	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
716	.offset = 0x4e, .activate = 13, .mute = 1 },
717
718	[SCARLETT2_CONFIG_SAFE_SWITCH] = {
719	.offset = 0x150, .activate = 14 },
720
721	[SCARLETT2_CONFIG_AIR_SWITCH] = {
722	.offset = 0x50, .activate = 15 },
723
724	[SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {
725	.offset = 0x153, .activate = 16 },
726
727	[SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {
728	.offset = 0x156, .activate = 17 },
729
730	[SCARLETT2_CONFIG_MASTER_VOLUME] = {
731	.offset = 0x32, .size = 16 },
732
733	[SCARLETT2_CONFIG_HEADPHONE_VOLUME] = {
734	.offset = 0x3a, .size = 16 },
735
736	[SCARLETT2_CONFIG_POWER_EXT] = {
737	.offset = 0x168 },
738
739	[SCARLETT2_CONFIG_POWER_LOW] = {
740	.offset = 0x16d }
741	}
742	};
743
744	/* Clarett USB and Clarett+ devices: 2Pre, 4Pre, 8Pre */
745	static const struct scarlett2_config_set scarlett2_config_set_clarett = {
746	.notifications = scarlett2_notifications,
747	.items = {
748	[SCARLETT2_CONFIG_DIM_MUTE] = {
749	.offset = 0x31, .size = 8, .activate = 2 },
750
751	[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
752	.offset = 0x34, .size = 16, .activate = 1 },
753
754	[SCARLETT2_CONFIG_MUTE_SWITCH] = {
755	.offset = 0x5c, .size = 8, .activate = 1 },
756
757	[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
758	.offset = 0x66, .size = 8, .activate = 3 },
759
760	[SCARLETT2_CONFIG_MASTER_VOLUME] = {
761	.offset = 0x76, .size = 16 },
762
763	[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
764	.offset = 0x7c, .size = 8, .activate = 7 },
765
766	[SCARLETT2_CONFIG_AIR_SWITCH] = {
767	.offset = 0x95, .size = 8, .activate = 8 },
768
769	[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
770	.offset = 0x8d, .size = 8, .activate = 6 },
771	}
772	};
773
774	/* Description of each hardware port type:
775	* - id: hardware ID of this port type
776	* - src_descr: printf format string for mux input selections
777	* - src_num_offset: added to channel number for the fprintf
778	* - dst_descr: printf format string for mixer controls
779	*/
780	struct scarlett2_port {
781	u16 id;
782	const char * const src_descr;
783	int src_num_offset;
784	const char * const dst_descr;
785	const char * const dsp_src_descr;
786	const char * const dsp_dst_descr;
787	};
788
789	static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = {
790	[SCARLETT2_PORT_TYPE_NONE] = {
791	.id = 0x000,
792	.src_descr = "Off"
793	},
794	[SCARLETT2_PORT_TYPE_ANALOGUE] = {
795	.id = 0x080,
796	.src_descr = "Analogue %d",
797	.src_num_offset = 1,
798	.dst_descr = "Analogue Output %02d Playback"
799	},
800	[SCARLETT2_PORT_TYPE_SPDIF] = {
801	.id = 0x180,
802	.src_descr = "S/PDIF %d",
803	.src_num_offset = 1,
804	.dst_descr = "S/PDIF Output %d Playback"
805	},
806	[SCARLETT2_PORT_TYPE_ADAT] = {
807	.id = 0x200,
808	.src_descr = "ADAT %d",
809	.src_num_offset = 1,
810	.dst_descr = "ADAT Output %d Playback"
811	},
812	[SCARLETT2_PORT_TYPE_MIX] = {
813	.id = 0x300,
814	.src_descr = "Mix %c",
815	.src_num_offset = 'A',
816	.dst_descr = "Mixer Input %02d Capture",
817	.dsp_src_descr = "DSP %d",
818	.dsp_dst_descr = "DSP Input %d Capture"
819	},
820	[SCARLETT2_PORT_TYPE_PCM] = {
821	.id = 0x600,
822	.src_descr = "PCM %d",
823	.src_num_offset = 1,
824	.dst_descr = "PCM %02d Capture"
825	},
826	};
827
828	/* Number of mux tables: one for each band of sample rates
829	* (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz)
830	*/
831	#define SCARLETT2_MUX_TABLES 3
832
833	/* Maximum number of entries in a mux table */
834	#define SCARLETT2_MAX_MUX_ENTRIES 10
835
836	/* One entry within mux_assignment defines the port type and range of
837	* ports to add to the set_mux message. The end of the list is marked
838	* with count == 0.
839	*/
840	struct scarlett2_mux_entry {
841	u8 port_type;
842	u8 start;
843	u8 count;
844	};
845
846	/* Maximum number of entries in a mux table */
847	#define SCARLETT2_MAX_METER_ENTRIES 9
848
849	/* One entry within meter_assignment defines the range of mux outputs
850	* that consecutive meter entries are mapped to. The end of the list
851	* is marked with count == 0.
852	*/
853	struct scarlett2_meter_entry {
854	u8 start;
855	u8 count;
856	};
857
858	struct scarlett2_device_info {
859	/* which set of configuration parameters the device uses */
860	const struct scarlett2_config_set *config_set;
861
862	/* minimum firmware version required */
863	u16 min_firmware_version;
864
865	/* support for main/alt speaker switching */
866	u8 has_speaker_switching;
867
868	/* support for talkback microphone */
869	u8 has_talkback;
870
871	/* the number of analogue inputs with a software switchable
872	* level control that can be set to line or instrument
873	*/
874	u8 level_input_count;
875
876	/* the first input with a level control (0-based) */
877	u8 level_input_first;
878
879	/* the number of analogue inputs with a software switchable
880	* 10dB pad control
881	*/
882	u8 pad_input_count;
883
884	/* the number of analogue inputs with a software switchable
885	* "air" control
886	*/
887	u8 air_input_count;
888
889	/* the first input with an air control (0-based) */
890	u8 air_input_first;
891
892	/* number of additional air options
893	* 0 for air presence only (Gen 3)
894	* 1 for air presence+drive (Gen 4)
895	*/
896	u8 air_option;
897
898	/* the number of phantom (48V) software switchable controls */
899	u8 phantom_count;
900
901	/* the first input with phantom power control (0-based) */
902	u8 phantom_first;
903
904	/* the number of inputs each phantom switch controls */
905	u8 inputs_per_phantom;
906
907	/* the number of inputs with software-controllable gain */
908	u8 gain_input_count;
909
910	/* the number of direct monitor options
911	* (0 = none, 1 = mono only, 2 = mono/stereo)
912	*/
913	u8 direct_monitor;
914
915	/* the number of DSP channels */
916	u8 dsp_count;
917
918	/* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected
919	* internally to the analogue 7/8 outputs
920	*/
921	u8 line_out_remap_enable;
922	u8 line_out_remap[SCARLETT2_ANALOGUE_MAX];
923	u8 line_out_unmap[SCARLETT2_ANALOGUE_MAX];
924
925	/* additional description for the line out volume controls */
926	const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
927
928	/* number of sources/destinations of each port type */
929	const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS];
930
931	/* layout/order of the entries in the set_mux message */
932	struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES]
933	[SCARLETT2_MAX_MUX_ENTRIES];
934
935	/* map from meter level order returned by
936	* SCARLETT2_USB_GET_METER to index into mux[] entries (same
937	* as the order returned by scarlett2_meter_ctl_get())
938	*/
939	struct scarlett2_meter_entry meter_map[SCARLETT2_MAX_METER_ENTRIES];
940	};
941
942	struct scarlett2_data {
943	struct usb_mixer_interface *mixer;
944	struct mutex usb_mutex; /* prevent sending concurrent USB requests */
945	struct mutex data_mutex; /* lock access to this data */
946	u8 hwdep_in_use;
947	u8 selected_flash_segment_id;
948	u8 flash_write_state;
949	struct delayed_work work;
950	const struct scarlett2_device_info *info;
951	const struct scarlett2_config_set *config_set;
952	const char *series_name;
953	__u8 bInterfaceNumber;
954	__u8 bEndpointAddress;
955	__u16 wMaxPacketSize;
956	__u8 bInterval;
957	u8 num_mux_srcs;
958	u8 num_mux_dsts;
959	u8 num_mix_in;
960	u8 num_mix_out;
961	u8 num_line_out;
962	u8 num_monitor_mix_ctls;
963	u32 firmware_version;
964	u8 flash_segment_nums[SCARLETT2_SEGMENT_ID_COUNT];
965	u8 flash_segment_blocks[SCARLETT2_SEGMENT_ID_COUNT];
966	u16 scarlett2_seq;
967	u8 sync_updated;
968	u8 vol_updated;
969	u8 dim_mute_updated;
970	u8 input_level_updated;
971	u8 input_pad_updated;
972	u8 input_air_updated;
973	u8 input_phantom_updated;
974	u8 input_select_updated;
975	u8 input_gain_updated;
976	u8 autogain_updated;
977	u8 input_safe_updated;
978	u8 pcm_input_switch_updated;
979	u8 monitor_other_updated;
980	u8 direct_monitor_updated;
981	u8 mux_updated;
982	u8 mix_updated;
983	u8 speaker_switching_switched;
984	u8 power_status_updated;
985	u8 sync;
986	u8 master_vol;
987	u8 headphone_vol;
988	u8 vol[SCARLETT2_ANALOGUE_MAX];
989	u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
990	u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
991	u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
992	u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
993	u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
994	u8 air_switch[SCARLETT2_AIR_SWITCH_MAX];
995	u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX];
996	u8 phantom_persistence;
997	u8 input_select_switch;
998	u8 input_link_switch[SCARLETT2_INPUT_GAIN_MAX / 2];
999	u8 gain[SCARLETT2_INPUT_GAIN_MAX];
1000	u8 autogain_switch[SCARLETT2_INPUT_GAIN_MAX];
1001	u8 autogain_status[SCARLETT2_INPUT_GAIN_MAX];
1002	u8 safe_switch[SCARLETT2_INPUT_GAIN_MAX];
1003	u8 pcm_input_switch;
1004	u8 direct_monitor_switch;
1005	u8 speaker_switching_switch;
1006	u8 talkback_switch;
1007	u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX];
1008	u8 msd_switch;
1009	u8 standalone_switch;
1010	u8 power_status;
1011	u8 meter_level_map[SCARLETT2_MAX_METERS];
1012	struct snd_kcontrol *sync_ctl;
1013	struct snd_kcontrol *master_vol_ctl;
1014	struct snd_kcontrol *headphone_vol_ctl;
1015	struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
1016	struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX];
1017	struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX];
1018	struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT];
1019	struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX];
1020	struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX];
1021	struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX];
1022	struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX];
1023	struct snd_kcontrol *input_select_ctl;
1024	struct snd_kcontrol *input_link_ctls[SCARLETT2_INPUT_GAIN_MAX / 2];
1025	struct snd_kcontrol *input_gain_ctls[SCARLETT2_INPUT_GAIN_MAX];
1026	struct snd_kcontrol *autogain_ctls[SCARLETT2_INPUT_GAIN_MAX];
1027	struct snd_kcontrol *autogain_status_ctls[SCARLETT2_INPUT_GAIN_MAX];
1028	struct snd_kcontrol *safe_ctls[SCARLETT2_INPUT_GAIN_MAX];
1029	struct snd_kcontrol *pcm_input_switch_ctl;
1030	struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX];
1031	struct snd_kcontrol *mix_ctls[SCARLETT2_MIX_MAX];
1032	struct snd_kcontrol *direct_monitor_ctl;
1033	struct snd_kcontrol *speaker_switching_ctl;
1034	struct snd_kcontrol *talkback_ctl;
1035	struct snd_kcontrol *power_status_ctl;
1036	u8 mux[SCARLETT2_MUX_MAX];
1037	u8 mix[SCARLETT2_MIX_MAX];
1038	u8 monitor_mix[SCARLETT2_MONITOR_MIX_MAX];
1039	};
1040
1041	/*** Model-specific data ***/
1042
1043	static const struct scarlett2_device_info s6i6_gen2_info = {
1044	.config_set = &scarlett2_config_set_gen2a,
1045	.level_input_count = 2,
1046	.pad_input_count = 2,
1047
1048	.line_out_descrs = {
1049	"Headphones 1 L",
1050	"Headphones 1 R",
1051	"Headphones 2 L",
1052	"Headphones 2 R",
1053	},
1054
1055	.port_count = {
1056	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1057	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
1058	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1059	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1060	[SCARLETT2_PORT_TYPE_PCM] = { 6, 6 },
1061	},
1062
1063	.mux_assignment = { {
1064	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 6 },
1065	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1066	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1067	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1068	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1069	{ 0, 0, 0 },
1070	}, {
1071	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1072	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1073	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1074	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1075	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1076	{ 0, 0, 0 },
1077	}, {
1078	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1079	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1080	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1081	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1082	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1083	{ 0, 0, 0 },
1084	} },
1085
1086	.meter_map = {
1087	{ 24, 6 },
1088	{ 0, 24 },
1089	{ 0, 0 },
1090	}
1091	};
1092
1093	static const struct scarlett2_device_info s18i8_gen2_info = {
1094	.config_set = &scarlett2_config_set_gen2a,
1095	.level_input_count = 2,
1096	.pad_input_count = 4,
1097
1098	.line_out_descrs = {
1099	"Monitor L",
1100	"Monitor R",
1101	"Headphones 1 L",
1102	"Headphones 1 R",
1103	"Headphones 2 L",
1104	"Headphones 2 R",
1105	},
1106
1107	.port_count = {
1108	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1109	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 },
1110	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1111	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
1112	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1113	[SCARLETT2_PORT_TYPE_PCM] = { 8, 18 },
1114	},
1115
1116	.mux_assignment = { {
1117	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 18 },
1118	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1119	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1120	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1121	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1122	{ 0, 0, 0 },
1123	}, {
1124	{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
1125	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1126	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1127	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1128	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1129	{ 0, 0, 0 },
1130	}, {
1131	{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
1132	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1133	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1134	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1135	{ SCARLETT2_PORT_TYPE_NONE, 0, 4 },
1136	{ 0, 0, 0 },
1137	} },
1138
1139	.meter_map = {
1140	{ 26, 18 },
1141	{ 0, 26 },
1142	{ 0, 0 },
1143	}
1144	};
1145
1146	static const struct scarlett2_device_info s18i20_gen2_info = {
1147	.config_set = &scarlett2_config_set_gen2b,
1148
1149	.line_out_descrs = {
1150	"Monitor L",
1151	"Monitor R",
1152	NULL,
1153	NULL,
1154	NULL,
1155	NULL,
1156	"Headphones 1 L",
1157	"Headphones 1 R",
1158	"Headphones 2 L",
1159	"Headphones 2 R",
1160	},
1161
1162	.port_count = {
1163	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1164	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },
1165	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1166	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
1167	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1168	[SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },
1169	},
1170
1171	.mux_assignment = { {
1172	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 18 },
1173	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1174	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1175	{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
1176	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1177	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1178	{ 0, 0, 0 },
1179	}, {
1180	{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
1181	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1182	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1183	{ SCARLETT2_PORT_TYPE_ADAT, 0, 4 },
1184	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1185	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1186	{ 0, 0, 0 },
1187	}, {
1188	{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
1189	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1190	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1191	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1192	{ SCARLETT2_PORT_TYPE_NONE, 0, 6 },
1193	{ 0, 0, 0 },
1194	} },
1195
1196	.meter_map = {
1197	{ 38, 18 },
1198	{ 0, 38 },
1199	{ 0, 0 },
1200	}
1201	};
1202
1203	static const struct scarlett2_device_info solo_gen3_info = {
1204	.config_set = &scarlett2_config_set_gen3a,
1205	.level_input_count = 1,
1206	.level_input_first = 1,
1207	.air_input_count = 1,
1208	.phantom_count = 1,
1209	.inputs_per_phantom = 1,
1210	.direct_monitor = 1,
1211	};
1212
1213	static const struct scarlett2_device_info s2i2_gen3_info = {
1214	.config_set = &scarlett2_config_set_gen3a,
1215	.level_input_count = 2,
1216	.air_input_count = 2,
1217	.phantom_count = 1,
1218	.inputs_per_phantom = 2,
1219	.direct_monitor = 2,
1220	};
1221
1222	static const struct scarlett2_device_info s4i4_gen3_info = {
1223	.config_set = &scarlett2_config_set_gen3b,
1224	.level_input_count = 2,
1225	.pad_input_count = 2,
1226	.air_input_count = 2,
1227	.phantom_count = 1,
1228	.inputs_per_phantom = 2,
1229
1230	.line_out_descrs = {
1231	"Monitor L",
1232	"Monitor R",
1233	"Headphones L",
1234	"Headphones R",
1235	},
1236
1237	.port_count = {
1238	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1239	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
1240	[SCARLETT2_PORT_TYPE_MIX] = { 6, 8 },
1241	[SCARLETT2_PORT_TYPE_PCM] = { 4, 6 },
1242	},
1243
1244	.mux_assignment = { {
1245	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 6 },
1246	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1247	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1248	{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
1249	{ 0, 0, 0 },
1250	}, {
1251	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1252	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1253	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1254	{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
1255	{ 0, 0, 0 },
1256	}, {
1257	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1258	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1259	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1260	{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
1261	{ 0, 0, 0 },
1262	} },
1263
1264	.meter_map = {
1265	{ 12, 6 },
1266	{ 0, 12 },
1267	{ 0, 0 },
1268	}
1269	};
1270
1271	static const struct scarlett2_device_info s8i6_gen3_info = {
1272	.config_set = &scarlett2_config_set_gen3b,
1273	.level_input_count = 2,
1274	.pad_input_count = 2,
1275	.air_input_count = 2,
1276	.phantom_count = 1,
1277	.inputs_per_phantom = 2,
1278
1279	.line_out_descrs = {
1280	"Headphones 1 L",
1281	"Headphones 1 R",
1282	"Headphones 2 L",
1283	"Headphones 2 R",
1284	},
1285
1286	.port_count = {
1287	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1288	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 },
1289	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1290	[SCARLETT2_PORT_TYPE_MIX] = { 8, 8 },
1291	[SCARLETT2_PORT_TYPE_PCM] = { 6, 10 },
1292	},
1293
1294	.mux_assignment = { {
1295	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 8 },
1296	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1297	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1298	{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
1299	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1300	{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
1301	{ 0, 0, 0 },
1302	}, {
1303	{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
1304	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1305	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1306	{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
1307	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1308	{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
1309	{ 0, 0, 0 },
1310	}, {
1311	{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
1312	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1313	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1314	{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
1315	{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
1316	{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
1317	{ 0, 0, 0 },
1318	} },
1319
1320	.meter_map = {
1321	{ 14, 8 },
1322	{ 0, 6 },
1323	{ 22, 2 },
1324	{ 6, 8 },
1325	{ 0, 0 },
1326	}
1327	};
1328
1329	static const struct scarlett2_device_info s18i8_gen3_info = {
1330	.config_set = &scarlett2_config_set_gen3c,
1331	.has_speaker_switching = 1,
1332	.level_input_count = 2,
1333	.pad_input_count = 4,
1334	.air_input_count = 4,
1335	.phantom_count = 2,
1336	.inputs_per_phantom = 2,
1337
1338	.line_out_remap_enable = 1,
1339	.line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 },
1340	.line_out_unmap = { 0, 1, 4, 5, 6, 7, 2, 3 },
1341
1342	.line_out_descrs = {
1343	"Monitor L",
1344	"Monitor R",
1345	"Alt Monitor L",
1346	"Alt Monitor R",
1347	"Headphones 1 L",
1348	"Headphones 1 R",
1349	"Headphones 2 L",
1350	"Headphones 2 R",
1351	},
1352
1353	.port_count = {
1354	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1355	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 },
1356	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1357	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
1358	[SCARLETT2_PORT_TYPE_MIX] = { 10, 20 },
1359	[SCARLETT2_PORT_TYPE_PCM] = { 8, 20 },
1360	},
1361
1362	.mux_assignment = { {
1363	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 10 },
1364	{ SCARLETT2_PORT_TYPE_PCM, 12, 8 },
1365	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1366	{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
1367	{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
1368	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1369	{ SCARLETT2_PORT_TYPE_PCM, 10, 2 },
1370	{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
1371	{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
1372	{ 0, 0, 0 },
1373	}, {
1374	{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
1375	{ SCARLETT2_PORT_TYPE_PCM, 12, 4 },
1376	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1377	{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
1378	{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
1379	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1380	{ SCARLETT2_PORT_TYPE_PCM, 10, 2 },
1381	{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
1382	{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
1383	{ 0, 0, 0 },
1384	}, {
1385	{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
1386	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1387	{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
1388	{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
1389	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1390	{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
1391	{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
1392	{ 0, 0, 0 },
1393	} },
1394
1395	.meter_map = {
1396	{ 30, 10 },
1397	{ 42, 8 },
1398	{ 0, 2 },
1399	{ 6, 2 },
1400	{ 2, 4 },
1401	{ 8, 2 },
1402	{ 40, 2 },
1403	{ 10, 20 },
1404	{ 0, 0 }
1405	}
1406	};
1407
1408	static const struct scarlett2_device_info s18i20_gen3_info = {
1409	.config_set = &scarlett2_config_set_gen3c,
1410	.has_speaker_switching = 1,
1411	.has_talkback = 1,
1412	.level_input_count = 2,
1413	.pad_input_count = 8,
1414	.air_input_count = 8,
1415	.phantom_count = 2,
1416	.inputs_per_phantom = 4,
1417
1418	.line_out_descrs = {
1419	"Monitor 1 L",
1420	"Monitor 1 R",
1421	"Monitor 2 L",
1422	"Monitor 2 R",
1423	NULL,
1424	NULL,
1425	"Headphones 1 L",
1426	"Headphones 1 R",
1427	"Headphones 2 L",
1428	"Headphones 2 R",
1429	},
1430
1431	.port_count = {
1432	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1433	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 },
1434	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1435	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
1436	[SCARLETT2_PORT_TYPE_MIX] = { 12, 25 },
1437	[SCARLETT2_PORT_TYPE_PCM] = { 20, 20 },
1438	},
1439
1440	.mux_assignment = { {
1441	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 8 },
1442	{ SCARLETT2_PORT_TYPE_PCM, 10, 10 },
1443	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1444	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1445	{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
1446	{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
1447	{ SCARLETT2_PORT_TYPE_MIX, 0, 25 },
1448	{ SCARLETT2_PORT_TYPE_NONE, 0, 12 },
1449	{ 0, 0, 0 },
1450	}, {
1451	{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
1452	{ SCARLETT2_PORT_TYPE_PCM, 10, 8 },
1453	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1454	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1455	{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
1456	{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
1457	{ SCARLETT2_PORT_TYPE_MIX, 0, 25 },
1458	{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
1459	{ 0, 0, 0 },
1460	}, {
1461	{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
1462	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1463	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1464	{ SCARLETT2_PORT_TYPE_NONE, 0, 24 },
1465	{ 0, 0, 0 },
1466	} },
1467
1468	.meter_map = {
1469	{ 45, 8 },
1470	{ 55, 10 },
1471	{ 0, 20 },
1472	{ 53, 2 },
1473	{ 20, 25 },
1474	{ 0, 0 },
1475	}
1476	};
1477
1478	static const struct scarlett2_device_info solo_gen4_info = {
1479	.config_set = &scarlett2_config_set_gen4_solo,
1480	.min_firmware_version = 2115,
1481
1482	.level_input_count = 1,
1483	.air_input_count = 1,
1484	.air_input_first = 1,
1485	.air_option = 1,
1486	.phantom_count = 1,
1487	.phantom_first = 1,
1488	.inputs_per_phantom = 1,
1489	.direct_monitor = 1,
1490	.dsp_count = 2,
1491
1492	.port_count = {
1493	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1494	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 },
1495	[SCARLETT2_PORT_TYPE_MIX] = { 8, 6 },
1496	[SCARLETT2_PORT_TYPE_PCM] = { 2, 4 },
1497	},
1498
1499	.mux_assignment = { {
1500	{ .port_type: SCARLETT2_PORT_TYPE_MIX, .start: 4, .count: 2 },
1501	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1502	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1503	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1504	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1505	{ 0, 0, 0 },
1506	}, {
1507	{ SCARLETT2_PORT_TYPE_MIX, 4, 2 },
1508	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1509	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1510	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1511	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1512	{ 0, 0, 0 },
1513	}, {
1514	{ SCARLETT2_PORT_TYPE_MIX, 4, 2 },
1515	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1516	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1517	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1518	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1519	{ 0, 0, 0 },
1520	} },
1521
1522	.meter_map = {
1523	{ 6, 2 },
1524	{ 4, 2 },
1525	{ 8, 4 },
1526	{ 2, 2 },
1527	{ 0, 2 },
1528	{ 0, 0 }
1529	}
1530	};
1531
1532	static const struct scarlett2_device_info s2i2_gen4_info = {
1533	.config_set = &scarlett2_config_set_gen4_2i2,
1534	.min_firmware_version = 2115,
1535
1536	.level_input_count = 2,
1537	.air_input_count = 2,
1538	.air_option = 1,
1539	.phantom_count = 1,
1540	.inputs_per_phantom = 2,
1541	.gain_input_count = 2,
1542	.direct_monitor = 2,
1543	.dsp_count = 2,
1544
1545	.port_count = {
1546	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1547	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 },
1548	[SCARLETT2_PORT_TYPE_MIX] = { 6, 6 },
1549	[SCARLETT2_PORT_TYPE_PCM] = { 2, 4 },
1550	},
1551
1552	.mux_assignment = { {
1553	{ .port_type: SCARLETT2_PORT_TYPE_MIX, .start: 4, .count: 2 },
1554	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1555	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1556	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1557	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1558	{ 0, 0, 0 },
1559	}, {
1560	{ SCARLETT2_PORT_TYPE_MIX, 4, 2 },
1561	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1562	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1563	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1564	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1565	{ 0, 0, 0 },
1566	}, {
1567	{ SCARLETT2_PORT_TYPE_MIX, 4, 2 },
1568	{ SCARLETT2_PORT_TYPE_MIX, 2, 2 },
1569	{ SCARLETT2_PORT_TYPE_PCM, 0, 4 },
1570	{ SCARLETT2_PORT_TYPE_MIX, 0, 2 },
1571	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
1572	{ 0, 0, 0 },
1573	} },
1574
1575	.meter_map = {
1576	{ 6, 2 },
1577	{ 4, 2 },
1578	{ 8, 4 },
1579	{ 2, 2 },
1580	{ 0, 2 },
1581	{ 0, 0 }
1582	}
1583	};
1584
1585	static const struct scarlett2_device_info s4i4_gen4_info = {
1586	.config_set = &scarlett2_config_set_gen4_4i4,
1587	.min_firmware_version = 2089,
1588
1589	.level_input_count = 2,
1590	.air_input_count = 2,
1591	.air_option = 1,
1592	.phantom_count = 2,
1593	.inputs_per_phantom = 1,
1594	.gain_input_count = 2,
1595	.dsp_count = 2,
1596
1597	.port_count = {
1598	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1599	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 6 },
1600	[SCARLETT2_PORT_TYPE_MIX] = { 8, 12 },
1601	[SCARLETT2_PORT_TYPE_PCM] = { 6, 6 },
1602	},
1603
1604	.mux_assignment = { {
1605	{ .port_type: SCARLETT2_PORT_TYPE_MIX, .start: 10, .count: 2 },
1606	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1607	{ SCARLETT2_PORT_TYPE_MIX, 0, 10 },
1608	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1609	{ 0, 0, 0 },
1610	}, {
1611	{ SCARLETT2_PORT_TYPE_MIX, 10, 2 },
1612	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1613	{ SCARLETT2_PORT_TYPE_MIX, 0, 10 },
1614	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1615	{ 0, 0, 0 },
1616	}, {
1617	{ SCARLETT2_PORT_TYPE_MIX, 10, 2 },
1618	{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
1619	{ SCARLETT2_PORT_TYPE_MIX, 0, 10 },
1620	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1621	{ 0, 0, 0 },
1622	} },
1623
1624	.meter_map = {
1625	{ 16, 8 },
1626	{ 6, 10 },
1627	{ 0, 6 },
1628	{ 0, 0 }
1629	}
1630	};
1631
1632	static const struct scarlett2_device_info clarett_2pre_info = {
1633	.config_set = &scarlett2_config_set_clarett,
1634	.level_input_count = 2,
1635	.air_input_count = 2,
1636
1637	.line_out_descrs = {
1638	"Monitor L",
1639	"Monitor R",
1640	"Headphones L",
1641	"Headphones R",
1642	},
1643
1644	.port_count = {
1645	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1646	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 4 },
1647	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 0 },
1648	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
1649	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1650	[SCARLETT2_PORT_TYPE_PCM] = { 4, 12 },
1651	},
1652
1653	.mux_assignment = { {
1654	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 12 },
1655	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1656	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1657	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1658	{ 0, 0, 0 },
1659	}, {
1660	{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
1661	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1662	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1663	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1664	{ 0, 0, 0 },
1665	}, {
1666	{ SCARLETT2_PORT_TYPE_PCM, 0, 2 },
1667	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
1668	{ SCARLETT2_PORT_TYPE_NONE, 0, 26 },
1669	{ 0, 0, 0 },
1670	} },
1671
1672	.meter_map = {
1673	{ 22, 12 },
1674	{ 0, 22 },
1675	{ 0, 0 }
1676	}
1677	};
1678
1679	static const struct scarlett2_device_info clarett_4pre_info = {
1680	.config_set = &scarlett2_config_set_clarett,
1681	.level_input_count = 2,
1682	.air_input_count = 4,
1683
1684	.line_out_descrs = {
1685	"Monitor L",
1686	"Monitor R",
1687	"Headphones 1 L",
1688	"Headphones 1 R",
1689	"Headphones 2 L",
1690	"Headphones 2 R",
1691	},
1692
1693	.port_count = {
1694	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1695	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 },
1696	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1697	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
1698	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1699	[SCARLETT2_PORT_TYPE_PCM] = { 8, 18 },
1700	},
1701
1702	.mux_assignment = { {
1703	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 18 },
1704	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1705	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1706	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1707	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1708	{ 0, 0, 0 },
1709	}, {
1710	{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
1711	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1712	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1713	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1714	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1715	{ 0, 0, 0 },
1716	}, {
1717	{ SCARLETT2_PORT_TYPE_PCM, 0, 12 },
1718	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
1719	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1720	{ SCARLETT2_PORT_TYPE_NONE, 0, 24 },
1721	{ 0, 0, 0 },
1722	} },
1723
1724	.meter_map = {
1725	{ 26, 18 },
1726	{ 0, 26 },
1727	{ 0, 0 }
1728	}
1729	};
1730
1731	static const struct scarlett2_device_info clarett_8pre_info = {
1732	.config_set = &scarlett2_config_set_clarett,
1733	.level_input_count = 2,
1734	.air_input_count = 8,
1735
1736	.line_out_descrs = {
1737	"Monitor L",
1738	"Monitor R",
1739	NULL,
1740	NULL,
1741	NULL,
1742	NULL,
1743	"Headphones 1 L",
1744	"Headphones 1 R",
1745	"Headphones 2 L",
1746	"Headphones 2 R",
1747	},
1748
1749	.port_count = {
1750	[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
1751	[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },
1752	[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
1753	[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
1754	[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
1755	[SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },
1756	},
1757
1758	.mux_assignment = { {
1759	{ .port_type: SCARLETT2_PORT_TYPE_PCM, .start: 0, .count: 18 },
1760	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1761	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1762	{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
1763	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1764	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1765	{ 0, 0, 0 },
1766	}, {
1767	{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
1768	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1769	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1770	{ SCARLETT2_PORT_TYPE_ADAT, 0, 4 },
1771	{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
1772	{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
1773	{ 0, 0, 0 },
1774	}, {
1775	{ SCARLETT2_PORT_TYPE_PCM, 0, 12 },
1776	{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
1777	{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
1778	{ SCARLETT2_PORT_TYPE_NONE, 0, 22 },
1779	{ 0, 0, 0 },
1780	} },
1781
1782	.meter_map = {
1783	{ 38, 18 },
1784	{ 0, 38 },
1785	{ 0, 0 }
1786	}
1787	};
1788
1789	struct scarlett2_device_entry {
1790	const u32 usb_id; /* USB device identifier */
1791	const struct scarlett2_device_info *info;
1792	const char *series_name;
1793	};
1794
1795	static const struct scarlett2_device_entry scarlett2_devices[] = {
1796	/* Supported Gen 2 devices */
1797	{ USB_ID(0x1235, 0x8203), &s6i6_gen2_info, "Scarlett Gen 2" },
1798	{ USB_ID(0x1235, 0x8204), &s18i8_gen2_info, "Scarlett Gen 2" },
1799	{ USB_ID(0x1235, 0x8201), &s18i20_gen2_info, "Scarlett Gen 2" },
1800
1801	/* Supported Gen 3 devices */
1802	{ USB_ID(0x1235, 0x8211), &solo_gen3_info, "Scarlett Gen 3" },
1803	{ USB_ID(0x1235, 0x8210), &s2i2_gen3_info, "Scarlett Gen 3" },
1804	{ USB_ID(0x1235, 0x8212), &s4i4_gen3_info, "Scarlett Gen 3" },
1805	{ USB_ID(0x1235, 0x8213), &s8i6_gen3_info, "Scarlett Gen 3" },
1806	{ USB_ID(0x1235, 0x8214), &s18i8_gen3_info, "Scarlett Gen 3" },
1807	{ USB_ID(0x1235, 0x8215), &s18i20_gen3_info, "Scarlett Gen 3" },
1808
1809	/* Supported Gen 4 devices */
1810	{ USB_ID(0x1235, 0x8218), &solo_gen4_info, "Scarlett Gen 4" },
1811	{ USB_ID(0x1235, 0x8219), &s2i2_gen4_info, "Scarlett Gen 4" },
1812	{ USB_ID(0x1235, 0x821a), &s4i4_gen4_info, "Scarlett Gen 4" },
1813
1814	/* Supported Clarett USB/Clarett+ devices */
1815	{ USB_ID(0x1235, 0x8206), &clarett_2pre_info, "Clarett USB" },
1816	{ USB_ID(0x1235, 0x8207), &clarett_4pre_info, "Clarett USB" },
1817	{ USB_ID(0x1235, 0x8208), &clarett_8pre_info, "Clarett USB" },
1818	{ USB_ID(0x1235, 0x820a), &clarett_2pre_info, "Clarett+" },
1819	{ USB_ID(0x1235, 0x820b), &clarett_4pre_info, "Clarett+" },
1820	{ USB_ID(0x1235, 0x820c), &clarett_8pre_info, "Clarett+" },
1821
1822	/* End of list */
1823	{ 0, NULL },
1824	};
1825
1826	/* get the starting port index number for a given port type/direction */
1827	static int scarlett2_get_port_start_num(
1828	const int port_count[][SCARLETT2_PORT_DIRNS],
1829	int direction, int port_type)
1830	{
1831	int i, num = 0;
1832
1833	for (i = 0; i < port_type; i++)
1834	num += port_count[i][direction];
1835
1836	return num;
1837	}
1838
1839	/*** USB Interactions ***/
1840
1841	/* Commands for sending/receiving requests/responses */
1842	#define SCARLETT2_USB_CMD_INIT 0
1843	#define SCARLETT2_USB_CMD_REQ 2
1844	#define SCARLETT2_USB_CMD_RESP 3
1845
1846	#define SCARLETT2_USB_INIT_1 0x00000000
1847	#define SCARLETT2_USB_INIT_2 0x00000002
1848	#define SCARLETT2_USB_REBOOT 0x00000003
1849	#define SCARLETT2_USB_GET_METER 0x00001001
1850	#define SCARLETT2_USB_GET_MIX 0x00002001
1851	#define SCARLETT2_USB_SET_MIX 0x00002002
1852	#define SCARLETT2_USB_GET_MUX 0x00003001
1853	#define SCARLETT2_USB_SET_MUX 0x00003002
1854	#define SCARLETT2_USB_INFO_FLASH 0x00004000
1855	#define SCARLETT2_USB_INFO_SEGMENT 0x00004001
1856	#define SCARLETT2_USB_ERASE_SEGMENT 0x00004002
1857	#define SCARLETT2_USB_GET_ERASE 0x00004003
1858	#define SCARLETT2_USB_WRITE_SEGMENT 0x00004004
1859	#define SCARLETT2_USB_GET_SYNC 0x00006004
1860	#define SCARLETT2_USB_GET_DATA 0x00800000
1861	#define SCARLETT2_USB_SET_DATA 0x00800001
1862	#define SCARLETT2_USB_DATA_CMD 0x00800002
1863
1864	#define SCARLETT2_USB_CONFIG_SAVE 6
1865
1866	#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
1867
1868	#define SCARLETT2_FLASH_BLOCK_SIZE 4096
1869	#define SCARLETT2_FLASH_WRITE_MAX 1024
1870	#define SCARLETT2_SEGMENT_NUM_MIN 1
1871	#define SCARLETT2_SEGMENT_NUM_MAX 4
1872
1873	#define SCARLETT2_SEGMENT_SETTINGS_NAME "App_Settings"
1874	#define SCARLETT2_SEGMENT_FIRMWARE_NAME "App_Upgrade"
1875
1876	/* proprietary request/response format */
1877	struct scarlett2_usb_packet {
1878	__le32 cmd;
1879	__le16 size;
1880	__le16 seq;
1881	__le32 error;
1882	__le32 pad;
1883	u8 data[];
1884	};
1885
1886	static void scarlett2_fill_request_header(struct scarlett2_data *private,
1887	struct scarlett2_usb_packet *req,
1888	u32 cmd, u16 req_size)
1889	{
1890	/* sequence must go up by 1 for each request */
1891	u16 seq = private->scarlett2_seq++;
1892
1893	req->cmd = cpu_to_le32(cmd);
1894	req->size = cpu_to_le16(req_size);
1895	req->seq = cpu_to_le16(seq);
1896	req->error = 0;
1897	req->pad = 0;
1898	}
1899
1900	static int scarlett2_usb_tx(struct usb_device *dev, int interface,
1901	void *buf, u16 size)
1902	{
1903	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
1904	SCARLETT2_USB_CMD_REQ,
1905	USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
1906	value: 0, index: interface, data: buf, size);
1907	}
1908
1909	static int scarlett2_usb_rx(struct usb_device *dev, int interface,
1910	u32 usb_req, void *buf, u16 size)
1911	{
1912	return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
1913	request: usb_req,
1914	USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
1915	value: 0, index: interface, data: buf, size);
1916	}
1917
1918	/* Send a proprietary format request to the Scarlett interface */
1919	static int scarlett2_usb(
1920	struct usb_mixer_interface *mixer, u32 cmd,
1921	void *req_data, u16 req_size, void *resp_data, u16 resp_size)
1922	{
1923	struct scarlett2_data *private = mixer->private_data;
1924	struct usb_device *dev = mixer->chip->dev;
1925	struct scarlett2_usb_packet *req, *resp = NULL;
1926	size_t req_buf_size = struct_size(req, data, req_size);
1927	size_t resp_buf_size = struct_size(resp, data, resp_size);
1928	int err;
1929
1930	req = kmalloc(size: req_buf_size, GFP_KERNEL);
1931	if (!req) {
1932	err = -ENOMEM;
1933	goto error;
1934	}
1935
1936	resp = kmalloc(size: resp_buf_size, GFP_KERNEL);
1937	if (!resp) {
1938	err = -ENOMEM;
1939	goto error;
1940	}
1941
1942	mutex_lock(&private->usb_mutex);
1943
1944	/* build request message and send it */
1945
1946	scarlett2_fill_request_header(private, req, cmd, req_size);
1947
1948	if (req_size)
1949	memcpy(req->data, req_data, req_size);
1950
1951	err = scarlett2_usb_tx(dev, interface: private->bInterfaceNumber,
1952	buf: req, size: req_buf_size);
1953
1954	if (err != req_buf_size) {
1955	usb_audio_err(
1956	mixer->chip,
1957	"%s USB request result cmd %x was %d\n",
1958	private->series_name, cmd, err);
1959	err = -EINVAL;
1960	goto unlock;
1961	}
1962
1963	/* send a second message to get the response */
1964
1965	err = scarlett2_usb_rx(dev, interface: private->bInterfaceNumber,
1966	SCARLETT2_USB_CMD_RESP,
1967	buf: resp, size: resp_buf_size);
1968
1969	/* validate the response */
1970
1971	if (err != resp_buf_size) {
1972
1973	/* ESHUTDOWN and EPROTO are valid responses to a
1974	* reboot request
1975	*/
1976	if (cmd == SCARLETT2_USB_REBOOT &&
1977	(err == -ESHUTDOWN || err == -EPROTO)) {
1978	err = 0;
1979	goto unlock;
1980	}
1981
1982	usb_audio_err(
1983	mixer->chip,
1984	"%s USB response result cmd %x was %d expected %zu\n",
1985	private->series_name, cmd, err, resp_buf_size);
1986	err = -EINVAL;
1987	goto unlock;
1988	}
1989
1990	/* cmd/seq/size should match except when initialising
1991	* seq sent = 1, response = 0
1992	*/
1993	if (resp->cmd != req->cmd ||
1994	(resp->seq != req->seq &&
1995	(le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
1996	resp_size != le16_to_cpu(resp->size) ||
1997	resp->error ||
1998	resp->pad) {
1999	usb_audio_err(
2000	mixer->chip,
2001	"%s USB invalid response; "
2002	"cmd tx/rx %d/%d seq %d/%d size %d/%d "
2003	"error %d pad %d\n",
2004	private->series_name,
2005	le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
2006	le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
2007	resp_size, le16_to_cpu(resp->size),
2008	le32_to_cpu(resp->error),
2009	le32_to_cpu(resp->pad));
2010	err = -EINVAL;
2011	goto unlock;
2012	}
2013
2014	if (resp_data && resp_size > 0)
2015	memcpy(resp_data, resp->data, resp_size);
2016
2017	unlock:
2018	mutex_unlock(lock: &private->usb_mutex);
2019	error:
2020	kfree(objp: req);
2021	kfree(objp: resp);
2022	return err;
2023	}
2024
2025	/* Send a USB message to get data; result placed in *buf */
2026	static int scarlett2_usb_get(
2027	struct usb_mixer_interface *mixer,
2028	int offset, void *buf, int size)
2029	{
2030	struct {
2031	__le32 offset;
2032	__le32 size;
2033	} __packed req;
2034
2035	req.offset = cpu_to_le32(offset);
2036	req.size = cpu_to_le32(size);
2037	return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
2038	req_data: &req, req_size: sizeof(req), resp_data: buf, resp_size: size);
2039	}
2040
2041	/* Return true if the given configuration item is present in the
2042	* configuration set used by this device.
2043	*/
2044	static int scarlett2_has_config_item(
2045	struct scarlett2_data *private, int config_item_num)
2046	{
2047	return !!private->config_set->items[config_item_num].offset;
2048	}
2049
2050	/* Send a USB message to get configuration parameters; result placed in *buf */
2051	static int scarlett2_usb_get_config(
2052	struct usb_mixer_interface *mixer,
2053	int config_item_num, int count, void *buf)
2054	{
2055	struct scarlett2_data *private = mixer->private_data;
2056	const struct scarlett2_config *config_item =
2057	&private->config_set->items[config_item_num];
2058	int size, err, i;
2059	u8 *buf_8;
2060	u8 value;
2061
2062	/* Check that the configuration item is present in the
2063	* configuration set used by this device
2064	*/
2065	if (!config_item->offset)
2066	return -EFAULT;
2067
2068	/* Gen 4 style parameters are always 1 byte */
2069	size = config_item->size ? config_item->size : 8;
2070
2071	/* For byte-sized parameters, retrieve directly into buf */
2072	if (size >= 8) {
2073	size = size / 8 * count;
2074	err = scarlett2_usb_get(mixer, offset: config_item->offset, buf, size);
2075	if (err < 0)
2076	return err;
2077	if (size == 2) {
2078	u16 *buf_16 = buf;
2079
2080	for (i = 0; i < count; i++, buf_16++)
2081	*buf_16 = le16_to_cpu(*(__le16 *)buf_16);
2082	}
2083	return 0;
2084	}
2085
2086	/* For bit-sized parameters, retrieve into value */
2087	err = scarlett2_usb_get(mixer, offset: config_item->offset, buf: &value, size: 1);
2088	if (err < 0)
2089	return err;
2090
2091	/* then unpack from value into buf[] */
2092	buf_8 = buf;
2093	for (i = 0; i < 8 && i < count; i++, value >>= 1)
2094	*buf_8++ = value & 1;
2095
2096	return 0;
2097	}
2098
2099	/* Send a SCARLETT2_USB_SET_DATA command.
2100	* offset: location in the device's data space
2101	* size: size in bytes of the value (1, 2, 4)
2102	*/
2103	static int scarlett2_usb_set_data(
2104	struct usb_mixer_interface *mixer,
2105	int offset, int size, int value)
2106	{
2107	struct scarlett2_data *private = mixer->private_data;
2108	struct {
2109	__le32 offset;
2110	__le32 size;
2111	__le32 value;
2112	} __packed req;
2113
2114	req.offset = cpu_to_le32(offset);
2115	req.size = cpu_to_le32(size);
2116	req.value = cpu_to_le32(value);
2117	return scarlett2_usb(mixer: private->mixer, SCARLETT2_USB_SET_DATA,
2118	req_data: &req, req_size: sizeof(u32) * 2 + size, NULL, resp_size: 0);
2119	}
2120
2121	/* Send a SCARLETT2_USB_DATA_CMD command.
2122	* Configuration changes require activation with this after they have
2123	* been uploaded by a previous SCARLETT2_USB_SET_DATA.
2124	* The value for activate needed is determined by the configuration
2125	* item.
2126	*/
2127	static int scarlett2_usb_activate_config(
2128	struct usb_mixer_interface *mixer, int activate)
2129	{
2130	__le32 req;
2131
2132	req = cpu_to_le32(activate);
2133	return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
2134	req_data: &req, req_size: sizeof(req), NULL, resp_size: 0);
2135	}
2136
2137	/* Send USB messages to set a SCARLETT2_CONFIG_* parameter */
2138	static int scarlett2_usb_set_config(
2139	struct usb_mixer_interface *mixer,
2140	int config_item_num, int index, int value)
2141	{
2142	struct scarlett2_data *private = mixer->private_data;
2143	const struct scarlett2_config_set *config_set = private->config_set;
2144	const struct scarlett2_config *config_item =
2145	&config_set->items[config_item_num];
2146	int offset, size;
2147	int err;
2148
2149	/* Check that the configuration item is present in the
2150	* configuration set used by this device
2151	*/
2152	if (!config_item->offset)
2153	return -EFAULT;
2154
2155	/* Gen 4 style writes are selected with size = 0;
2156	* these are only byte-sized values written through a shared
2157	* location, different to the read address
2158	*/
2159	if (!config_item->size) {
2160	if (!config_set->gen4_write_addr)
2161	return -EFAULT;
2162
2163	/* Place index in gen4_write_addr + 1 */
2164	err = scarlett2_usb_set_data(
2165	mixer, offset: config_set->gen4_write_addr + 1, size: 1, value: index);
2166	if (err < 0)
2167	return err;
2168
2169	/* Place value in gen4_write_addr */
2170	err = scarlett2_usb_set_data(
2171	mixer, offset: config_set->gen4_write_addr, size: 1, value);
2172	if (err < 0)
2173	return err;
2174
2175	/* Request the interface do the write */
2176	return scarlett2_usb_activate_config(
2177	mixer, activate: config_item->activate);
2178	}
2179
2180	/* Not-Gen 4 style needs NVRAM save, supports
2181	* bit-modification, and writing is done to the same place
2182	* that the value can be read from
2183	*/
2184
2185	/* Cancel any pending NVRAM save */
2186	cancel_delayed_work_sync(dwork: &private->work);
2187
2188	/* Convert config_item->size in bits to size in bytes and
2189	* calculate offset
2190	*/
2191	if (config_item->size >= 8) {
2192	size = config_item->size / 8;
2193	offset = config_item->offset + index * size;
2194
2195	/* If updating a bit, retrieve the old value, set/clear the
2196	* bit as needed, and update value
2197	*/
2198	} else {
2199	u8 tmp;
2200
2201	size = 1;
2202	offset = config_item->offset;
2203
2204	err = scarlett2_usb_get(mixer, offset, buf: &tmp, size: 1);
2205	if (err < 0)
2206	return err;
2207
2208	if (value)
2209	tmp |= (1 << index);
2210	else
2211	tmp &= ~(1 << index);
2212
2213	value = tmp;
2214	}
2215
2216	/* Send the configuration parameter data */
2217	err = scarlett2_usb_set_data(mixer, offset, size, value);
2218	if (err < 0)
2219	return err;
2220
2221	/* Activate the change */
2222	err = scarlett2_usb_activate_config(mixer, activate: config_item->activate);
2223	if (err < 0)
2224	return err;
2225
2226	/* Gen 2 style writes to Gen 4 devices don't need saving */
2227	if (config_set->gen4_write_addr)
2228	return 0;
2229
2230	/* Schedule the change to be written to NVRAM */
2231	if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
2232	schedule_delayed_work(dwork: &private->work, delay: msecs_to_jiffies(m: 2000));
2233
2234	return 0;
2235	}
2236
2237	/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
2238	static void scarlett2_config_save(struct usb_mixer_interface *mixer)
2239	{
2240	int err;
2241
2242	err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE);
2243	if (err < 0)
2244	usb_audio_err(mixer->chip, "config save failed: %d\n", err);
2245	}
2246
2247	/* Delayed work to save config */
2248	static void scarlett2_config_save_work(struct work_struct *work)
2249	{
2250	struct scarlett2_data *private =
2251	container_of(work, struct scarlett2_data, work.work);
2252
2253	scarlett2_config_save(mixer: private->mixer);
2254	}
2255
2256	/* Send a USB message to get sync status; result placed in *sync */
2257	static int scarlett2_usb_get_sync_status(
2258	struct usb_mixer_interface *mixer,
2259	u8 *sync)
2260	{
2261	__le32 data;
2262	int err;
2263
2264	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
2265	NULL, req_size: 0, resp_data: &data, resp_size: sizeof(data));
2266	if (err < 0)
2267	return err;
2268
2269	*sync = !!data;
2270	return 0;
2271	}
2272
2273	/* Return true if the device has a mixer that we can control */
2274	static int scarlett2_has_mixer(struct scarlett2_data *private)
2275	{
2276	return !!private->info->mux_assignment[0][0].count;
2277	}
2278
2279	/* Map from mixer value to (db + 80) * 2
2280	* (reverse of scarlett2_mixer_values[])
2281	*/
2282	static int scarlett2_mixer_value_to_db(int value)
2283	{
2284	int i;
2285
2286	for (i = 0; i < SCARLETT2_MIXER_VALUE_COUNT; i++)
2287	if (scarlett2_mixer_values[i] >= value)
2288	return i;
2289	return SCARLETT2_MIXER_MAX_VALUE;
2290	}
2291
2292	/* Send a USB message to get the volumes for all inputs of one mix
2293	* and put the values into private->mix[]
2294	*/
2295	static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
2296	int mix_num)
2297	{
2298	struct scarlett2_data *private = mixer->private_data;
2299
2300	int num_mixer_in = private->num_mix_in;
2301	int err, i, j;
2302
2303	struct {
2304	__le16 mix_num;
2305	__le16 count;
2306	} __packed req;
2307
2308	__le16 data[SCARLETT2_INPUT_MIX_MAX];
2309
2310	req.mix_num = cpu_to_le16(mix_num);
2311	req.count = cpu_to_le16(num_mixer_in);
2312
2313	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
2314	req_data: &req, req_size: sizeof(req),
2315	resp_data: data, resp_size: num_mixer_in * sizeof(u16));
2316	if (err < 0)
2317	return err;
2318
2319	for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
2320	private->mix[j] = scarlett2_mixer_value_to_db(
2321	le16_to_cpu(data[i]));
2322
2323	return 0;
2324	}
2325
2326	/* Send a USB message to set the volumes for all inputs of one mix
2327	* (values obtained from private->mix[])
2328	*/
2329	static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
2330	int mix_num)
2331	{
2332	struct scarlett2_data *private = mixer->private_data;
2333
2334	struct {
2335	__le16 mix_num;
2336	__le16 data[SCARLETT2_INPUT_MIX_MAX];
2337	} __packed req;
2338
2339	int i, j;
2340	int num_mixer_in = private->num_mix_in;
2341
2342	req.mix_num = cpu_to_le16(mix_num);
2343
2344	for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
2345	req.data[i] = cpu_to_le16(
2346	scarlett2_mixer_values[private->mix[j]]
2347	);
2348
2349	return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
2350	req_data: &req, req_size: (num_mixer_in + 1) * sizeof(u16),
2351	NULL, resp_size: 0);
2352	}
2353
2354	/* Convert a port number index (per info->port_count) to a hardware ID */
2355	static u32 scarlett2_mux_src_num_to_id(
2356	const int port_count[][SCARLETT2_PORT_DIRNS], int num)
2357	{
2358	int port_type;
2359
2360	for (port_type = 0;
2361	port_type < SCARLETT2_PORT_TYPE_COUNT;
2362	port_type++) {
2363	if (num < port_count[port_type][SCARLETT2_PORT_IN])
2364	return scarlett2_ports[port_type].id | num;
2365	num -= port_count[port_type][SCARLETT2_PORT_IN];
2366	}
2367
2368	/* Oops */
2369	return 0;
2370	}
2371
2372	/* Convert a hardware ID to a port number index */
2373	static u32 scarlett2_mux_id_to_num(
2374	const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)
2375	{
2376	int port_type;
2377	int port_num = 0;
2378
2379	for (port_type = 0;
2380	port_type < SCARLETT2_PORT_TYPE_COUNT;
2381	port_type++) {
2382	int base = scarlett2_ports[port_type].id;
2383	int count = port_count[port_type][direction];
2384
2385	if (id >= base && id < base + count)
2386	return port_num + id - base;
2387	port_num += count;
2388	}
2389
2390	/* Oops */
2391	return -1;
2392	}
2393
2394	/* Convert one mux entry from the interface and load into private->mux[] */
2395	static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
2396	u32 mux_entry)
2397	{
2398	const struct scarlett2_device_info *info = private->info;
2399	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2400
2401	int dst_idx, src_idx;
2402
2403	dst_idx = scarlett2_mux_id_to_num(port_count, direction: SCARLETT2_PORT_OUT,
2404	id: mux_entry & 0xFFF);
2405	if (dst_idx < 0)
2406	return;
2407
2408	if (dst_idx >= private->num_mux_dsts) {
2409	usb_audio_err(private->mixer->chip,
2410	"BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",
2411	mux_entry, dst_idx, private->num_mux_dsts);
2412	return;
2413	}
2414
2415	src_idx = scarlett2_mux_id_to_num(port_count, direction: SCARLETT2_PORT_IN,
2416	id: mux_entry >> 12);
2417	if (src_idx < 0)
2418	return;
2419
2420	if (src_idx >= private->num_mux_srcs) {
2421	usb_audio_err(private->mixer->chip,
2422	"BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",
2423	mux_entry, src_idx, private->num_mux_srcs);
2424	return;
2425	}
2426
2427	private->mux[dst_idx] = src_idx;
2428	}
2429
2430	/* Update the meter level map
2431	*
2432	* The meter level data from the interface (SCARLETT2_USB_GET_METER
2433	* request) is returned in mux_assignment order, but to avoid exposing
2434	* that to userspace, scarlett2_meter_ctl_get() rearranges the data
2435	* into scarlett2_ports order using the meter_level_map[] array which
2436	* is set up by this function.
2437	*
2438	* In addition, the meter level data values returned from the
2439	* interface are invalid for destinations where:
2440	*
2441	* - the source is "Off"; therefore we set those values to zero (map
2442	* value of 255)
2443	*
2444	* - the source is assigned to a previous (with respect to the
2445	* mux_assignment order) destination; therefore we set those values
2446	* to the value previously reported for that source
2447	*/
2448	static void scarlett2_update_meter_level_map(struct scarlett2_data *private)
2449	{
2450	const struct scarlett2_device_info *info = private->info;
2451	const struct scarlett2_meter_entry *entry;
2452
2453	/* sources already assigned to a destination
2454	* value is 255 for None, otherwise the value of i
2455	* (index into array returned by
2456	* scarlett2_usb_get_meter_levels())
2457	*/
2458	u8 seen_src[SCARLETT2_MAX_SRCS] = { 1 };
2459	u8 seen_src_value[SCARLETT2_MAX_SRCS] = { 255 };
2460
2461	/* index in meter_map[] order */
2462	int i = 0;
2463
2464	/* go through the meter_map[] entries */
2465	for (entry = info->meter_map;
2466	entry->count;
2467	entry++) {
2468
2469	/* fill in each meter_level_map[] entry */
2470	int j, mux_idx;
2471
2472	for (j = 0, mux_idx = entry->start;
2473	j < entry->count;
2474	i++, j++, mux_idx++) {
2475
2476	/* convert mux_idx using line_out_unmap[] */
2477	int map_mux_idx = (
2478	info->line_out_remap_enable &&
2479	mux_idx < private->num_line_out
2480	) ? info->line_out_unmap[mux_idx]
2481	: mux_idx;
2482
2483	/* check which source is connected, and if
2484	* that source is already connected elsewhere,
2485	* use that existing connection's destination
2486	* for this meter entry instead
2487	*/
2488	int mux_src = private->mux[mux_idx];
2489
2490	if (!seen_src[mux_src]) {
2491	seen_src[mux_src] = 1;
2492	seen_src_value[mux_src] = i;
2493	}
2494	private->meter_level_map[map_mux_idx] =
2495	seen_src_value[mux_src];
2496	}
2497	}
2498	}
2499
2500	/* Send USB message to get mux inputs and then populate private->mux[] */
2501	static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
2502	{
2503	struct scarlett2_data *private = mixer->private_data;
2504	int count = private->num_mux_dsts;
2505	int err, i;
2506
2507	struct {
2508	__le16 num;
2509	__le16 count;
2510	} __packed req;
2511
2512	__le32 data[SCARLETT2_MUX_MAX];
2513
2514	private->mux_updated = 0;
2515
2516	req.num = 0;
2517	req.count = cpu_to_le16(count);
2518
2519	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
2520	req_data: &req, req_size: sizeof(req),
2521	resp_data: data, resp_size: count * sizeof(u32));
2522	if (err < 0)
2523	return err;
2524
2525	for (i = 0; i < count; i++)
2526	scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
2527
2528	scarlett2_update_meter_level_map(private);
2529
2530	return 0;
2531	}
2532
2533	/* Send USB messages to set mux inputs */
2534	static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
2535	{
2536	struct scarlett2_data *private = mixer->private_data;
2537	const struct scarlett2_device_info *info = private->info;
2538	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2539	int table;
2540
2541	struct {
2542	__le16 pad;
2543	__le16 num;
2544	__le32 data[SCARLETT2_MUX_MAX];
2545	} __packed req;
2546
2547	req.pad = 0;
2548
2549	/* set mux settings for each rate */
2550	for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {
2551	const struct scarlett2_mux_entry *entry;
2552
2553	/* i counts over the output array */
2554	int i = 0, err;
2555
2556	req.num = cpu_to_le16(table);
2557
2558	/* loop through each entry */
2559	for (entry = info->mux_assignment[table];
2560	entry->count;
2561	entry++) {
2562	int j;
2563	int port_type = entry->port_type;
2564	int port_idx = entry->start;
2565	int mux_idx = scarlett2_get_port_start_num(port_count,
2566	direction: SCARLETT2_PORT_OUT, port_type) + port_idx;
2567	int dst_id = scarlett2_ports[port_type].id + port_idx;
2568
2569	/* Empty slots */
2570	if (!dst_id) {
2571	for (j = 0; j < entry->count; j++)
2572	req.data[i++] = 0;
2573	continue;
2574	}
2575
2576	/* Non-empty mux slots use the lower 12 bits
2577	* for the destination and next 12 bits for
2578	* the source
2579	*/
2580	for (j = 0; j < entry->count; j++) {
2581	int src_id = scarlett2_mux_src_num_to_id(
2582	port_count, num: private->mux[mux_idx++]);
2583	req.data[i++] = cpu_to_le32(dst_id |
2584	src_id << 12);
2585	dst_id++;
2586	}
2587	}
2588
2589	err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
2590	req_data: &req, req_size: (i + 1) * sizeof(u32),
2591	NULL, resp_size: 0);
2592	if (err < 0)
2593	return err;
2594	}
2595
2596	scarlett2_update_meter_level_map(private);
2597
2598	return 0;
2599	}
2600
2601	/* Send USB message to get meter levels */
2602	static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
2603	u16 num_meters, u16 *levels)
2604	{
2605	struct {
2606	__le16 pad;
2607	__le16 num_meters;
2608	__le32 magic;
2609	} __packed req;
2610	__le32 resp[SCARLETT2_MAX_METERS];
2611	int i, err;
2612
2613	req.pad = 0;
2614	req.num_meters = cpu_to_le16(num_meters);
2615	req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
2616	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
2617	req_data: &req, req_size: sizeof(req), resp_data: resp, resp_size: num_meters * sizeof(u32));
2618	if (err < 0)
2619	return err;
2620
2621	/* copy, convert to u16 */
2622	for (i = 0; i < num_meters; i++)
2623	levels[i] = le32_to_cpu(resp[i]);
2624
2625	return 0;
2626	}
2627
2628	/* For config items with mute=1, xor bits 0 & 1 together to get the
2629	* current/next state. This won't have any effect on values which are
2630	* only ever 0/1.
2631	*/
2632	static uint8_t scarlett2_decode_muteable(uint8_t v)
2633	{
2634	return (v ^ (v >> 1)) & 1;
2635	}
2636
2637	/*** Control Functions ***/
2638
2639	/* helper function to create a new control */
2640	static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
2641	const struct snd_kcontrol_new *ncontrol,
2642	int index, int channels, const char *name,
2643	struct snd_kcontrol **kctl_return)
2644	{
2645	struct snd_kcontrol *kctl;
2646	struct usb_mixer_elem_info *elem;
2647	int err;
2648
2649	elem = kzalloc(size: sizeof(*elem), GFP_KERNEL);
2650	if (!elem)
2651	return -ENOMEM;
2652
2653	/* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
2654	* ignores them for resume and other operations.
2655	* Also, the head.id field is set to 0, as we don't use this field.
2656	*/
2657	elem->head.mixer = mixer;
2658	elem->control = index;
2659	elem->head.id = 0;
2660	elem->channels = channels;
2661	elem->val_type = USB_MIXER_BESPOKEN;
2662
2663	kctl = snd_ctl_new1(kcontrolnew: ncontrol, private_data: elem);
2664	if (!kctl) {
2665	kfree(objp: elem);
2666	return -ENOMEM;
2667	}
2668	kctl->private_free = snd_usb_mixer_elem_free;
2669
2670	strscpy(kctl->id.name, name, sizeof(kctl->id.name));
2671
2672	err = snd_usb_mixer_add_control(&elem->head, kctl);
2673	if (err < 0)
2674	return err;
2675
2676	if (kctl_return)
2677	*kctl_return = kctl;
2678
2679	return 0;
2680	}
2681
2682	/*** Firmware Version Control ***/
2683
2684	static int scarlett2_firmware_version_ctl_get(
2685	struct snd_kcontrol *kctl,
2686	struct snd_ctl_elem_value *ucontrol)
2687	{
2688	struct usb_mixer_elem_info *elem = kctl->private_data;
2689	struct scarlett2_data *private = elem->head.mixer->private_data;
2690
2691	ucontrol->value.integer.value[0] = private->firmware_version;
2692
2693	return 0;
2694	}
2695
2696	static int scarlett2_firmware_version_ctl_info(
2697	struct snd_kcontrol *kctl,
2698	struct snd_ctl_elem_info *uinfo)
2699	{
2700	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2701	uinfo->count = 1;
2702
2703	return 0;
2704	}
2705
2706	static const struct snd_kcontrol_new scarlett2_firmware_version_ctl = {
2707	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
2708	.access = SNDRV_CTL_ELEM_ACCESS_READ,
2709	.name = "",
2710	.info = scarlett2_firmware_version_ctl_info,
2711	.get = scarlett2_firmware_version_ctl_get
2712	};
2713
2714	static int scarlett2_add_firmware_version_ctl(
2715	struct usb_mixer_interface *mixer)
2716	{
2717	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_firmware_version_ctl,
2718	index: 0, channels: 0, name: "Firmware Version", NULL);
2719	}
2720
2721	/*** Minimum Firmware Version Control ***/
2722
2723	static int scarlett2_min_firmware_version_ctl_get(
2724	struct snd_kcontrol *kctl,
2725	struct snd_ctl_elem_value *ucontrol)
2726	{
2727	struct usb_mixer_elem_info *elem = kctl->private_data;
2728	struct scarlett2_data *private = elem->head.mixer->private_data;
2729
2730	ucontrol->value.integer.value[0] = private->info->min_firmware_version;
2731
2732	return 0;
2733	}
2734
2735	static int scarlett2_min_firmware_version_ctl_info(
2736	struct snd_kcontrol *kctl,
2737	struct snd_ctl_elem_info *uinfo)
2738	{
2739	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2740	uinfo->count = 1;
2741
2742	return 0;
2743	}
2744
2745	static const struct snd_kcontrol_new scarlett2_min_firmware_version_ctl = {
2746	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
2747	.access = SNDRV_CTL_ELEM_ACCESS_READ,
2748	.name = "",
2749	.info = scarlett2_min_firmware_version_ctl_info,
2750	.get = scarlett2_min_firmware_version_ctl_get
2751	};
2752
2753	static int scarlett2_add_min_firmware_version_ctl(
2754	struct usb_mixer_interface *mixer)
2755	{
2756	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_min_firmware_version_ctl,
2757	index: 0, channels: 0, name: "Minimum Firmware Version", NULL);
2758	}
2759
2760	/*** Sync Control ***/
2761
2762	/* Update sync control after receiving notification that the status
2763	* has changed
2764	*/
2765	static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
2766	{
2767	struct scarlett2_data *private = mixer->private_data;
2768
2769	private->sync_updated = 0;
2770	return scarlett2_usb_get_sync_status(mixer, sync: &private->sync);
2771	}
2772
2773	static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,
2774	struct snd_ctl_elem_info *uinfo)
2775	{
2776	static const char *texts[2] = {
2777	"Unlocked", "Locked"
2778	};
2779	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 2, names: texts);
2780	}
2781
2782	static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,
2783	struct snd_ctl_elem_value *ucontrol)
2784	{
2785	struct usb_mixer_elem_info *elem = kctl->private_data;
2786	struct usb_mixer_interface *mixer = elem->head.mixer;
2787	struct scarlett2_data *private = mixer->private_data;
2788	int err = 0;
2789
2790	mutex_lock(&private->data_mutex);
2791
2792	if (private->hwdep_in_use) {
2793	err = -EBUSY;
2794	goto unlock;
2795	}
2796
2797	if (private->sync_updated) {
2798	err = scarlett2_update_sync(mixer);
2799	if (err < 0)
2800	goto unlock;
2801	}
2802	ucontrol->value.enumerated.item[0] = private->sync;
2803
2804	unlock:
2805	mutex_unlock(lock: &private->data_mutex);
2806	return err;
2807	}
2808
2809	static const struct snd_kcontrol_new scarlett2_sync_ctl = {
2810	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2811	.access = SNDRV_CTL_ELEM_ACCESS_READ,
2812	.name = "",
2813	.info = scarlett2_sync_ctl_info,
2814	.get = scarlett2_sync_ctl_get
2815	};
2816
2817	static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
2818	{
2819	struct scarlett2_data *private = mixer->private_data;
2820
2821	/* devices without a mixer also don't support reporting sync status */
2822	if (!scarlett2_has_mixer(private))
2823	return 0;
2824
2825	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_sync_ctl,
2826	index: 0, channels: 1, name: "Sync Status", kctl_return: &private->sync_ctl);
2827	}
2828
2829	/*** Autogain Switch and Status Controls ***/
2830
2831	/* Forward declarations as phantom power and autogain can disable each other */
2832	static int scarlett2_check_input_phantom_updated(struct usb_mixer_interface *);
2833	static int scarlett2_phantom_is_switching(struct scarlett2_data *, int);
2834
2835	/* Set the access mode of a control to read-only (val = 0) or
2836	* read-write (val = 1).
2837	*/
2838	static void scarlett2_set_ctl_access(struct snd_kcontrol *kctl, int val)
2839	{
2840	if (val)
2841	kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
2842	else
2843	kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;
2844	}
2845
2846	/* Check if autogain is running on any input */
2847	static int scarlett2_autogain_is_running(struct scarlett2_data *private)
2848	{
2849	int i;
2850
2851	/* autogain_status[] is 0 if autogain is running */
2852	for (i = 0; i < private->info->gain_input_count; i++)
2853	if (!private->autogain_status[i])
2854	return 1;
2855
2856	return 0;
2857	}
2858
2859	static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)
2860	{
2861	struct scarlett2_data *private = mixer->private_data;
2862	const struct scarlett2_device_info *info = private->info;
2863	int err, i;
2864	u8 raw_autogain_status[SCARLETT2_INPUT_GAIN_MAX];
2865
2866	private->autogain_updated = 0;
2867
2868	if (!info->gain_input_count)
2869	return 0;
2870
2871	err = scarlett2_usb_get_config(
2872	mixer, config_item_num: SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
2873	count: info->gain_input_count, buf: private->autogain_switch);
2874	if (err < 0)
2875	return err;
2876	err = scarlett2_usb_get_config(
2877	mixer, config_item_num: SCARLETT2_CONFIG_AUTOGAIN_STATUS,
2878	count: info->gain_input_count, buf: raw_autogain_status);
2879	if (err < 0)
2880	return err;
2881
2882	/* Translate autogain_switch and raw_autogain_status into
2883	* autogain_status.
2884	*
2885	* When autogain_switch[] is set, the status is the first
2886	* element in scarlett2_autogain_status_texts[] (Running). The
2887	* subsequent elements correspond to the status value from the
2888	* device (raw_autogain_status[]) + 1. The last element is
2889	* "Invalid", in case the device reports a status outside the
2890	* range of scarlett2_autogain_status_texts[].
2891	*/
2892	for (i = 0; i < info->gain_input_count; i++)
2893	if (private->autogain_switch[i])
2894	private->autogain_status[i] = 0;
2895	else if (raw_autogain_status[i] <
2896	ARRAY_SIZE(scarlett2_autogain_status_texts) - 1)
2897	private->autogain_status[i] =
2898	raw_autogain_status[i] + 1;
2899	else
2900	private->autogain_status[i] =
2901	ARRAY_SIZE(scarlett2_autogain_status_texts) - 1;
2902
2903	return 0;
2904	}
2905
2906	/* Update access mode for controls affected by autogain */
2907	static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)
2908	{
2909	struct scarlett2_data *private = mixer->private_data;
2910	const struct scarlett2_device_info *info = private->info;
2911	int val = !scarlett2_autogain_is_running(private);
2912	int i;
2913
2914	scarlett2_set_ctl_access(kctl: private->input_select_ctl, val);
2915	for (i = 0; i < info->gain_input_count / 2; i++)
2916	scarlett2_set_ctl_access(kctl: private->input_link_ctls[i], val);
2917	for (i = 0; i < info->gain_input_count; i++) {
2918	scarlett2_set_ctl_access(kctl: private->input_gain_ctls[i], val);
2919	scarlett2_set_ctl_access(kctl: private->safe_ctls[i], val);
2920	}
2921	for (i = 0; i < info->level_input_count; i++)
2922	scarlett2_set_ctl_access(kctl: private->level_ctls[i], val);
2923	for (i = 0; i < info->air_input_count; i++)
2924	scarlett2_set_ctl_access(kctl: private->air_ctls[i], val);
2925	for (i = 0; i < info->phantom_count; i++)
2926	scarlett2_set_ctl_access(kctl: private->phantom_ctls[i], val);
2927	}
2928
2929	/* Notify of access mode change for all controls read-only while
2930	* autogain runs.
2931	*/
2932	static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer)
2933	{
2934	struct snd_card *card = mixer->chip->card;
2935	struct scarlett2_data *private = mixer->private_data;
2936	const struct scarlett2_device_info *info = private->info;
2937	int i;
2938
2939	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2940	id: &private->input_select_ctl->id);
2941	for (i = 0; i < info->gain_input_count / 2; i++)
2942	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2943	id: &private->input_link_ctls[i]->id);
2944	for (i = 0; i < info->gain_input_count; i++) {
2945	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2946	id: &private->input_gain_ctls[i]->id);
2947	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2948	id: &private->safe_ctls[i]->id);
2949	}
2950	for (i = 0; i < info->level_input_count; i++)
2951	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2952	id: &private->level_ctls[i]->id);
2953	for (i = 0; i < info->air_input_count; i++)
2954	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2955	id: &private->air_ctls[i]->id);
2956	for (i = 0; i < info->phantom_count; i++)
2957	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
2958	id: &private->phantom_ctls[i]->id);
2959	}
2960
2961	/* Call scarlett2_update_autogain() and
2962	* scarlett2_autogain_update_access() if autogain_updated is set.
2963	*/
2964	static int scarlett2_check_autogain_updated(
2965	struct usb_mixer_interface *mixer)
2966	{
2967	struct scarlett2_data *private = mixer->private_data;
2968	int err;
2969
2970	if (!private->autogain_updated)
2971	return 0;
2972
2973	err = scarlett2_update_autogain(mixer);
2974	if (err < 0)
2975	return err;
2976
2977	scarlett2_autogain_update_access(mixer);
2978
2979	return 0;
2980	}
2981
2982	/* If autogain_updated is set when a *_ctl_put() function for a
2983	* control that is meant to be read-only while autogain is running,
2984	* update the autogain status and access mode of affected controls.
2985	* Return -EPERM if autogain is running.
2986	*/
2987	static int scarlett2_check_put_during_autogain(
2988	struct usb_mixer_interface *mixer)
2989	{
2990	int err = scarlett2_check_autogain_updated(mixer);
2991
2992	if (err < 0)
2993	return err;
2994
2995	if (scarlett2_autogain_is_running(private: mixer->private_data))
2996	return -EPERM;
2997
2998	return 0;
2999	}
3000
3001	static int scarlett2_autogain_switch_ctl_info(
3002	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3003	{
3004	struct usb_mixer_elem_info *elem = kctl->private_data;
3005	struct usb_mixer_interface *mixer = elem->head.mixer;
3006	struct scarlett2_data *private = mixer->private_data;
3007	int err;
3008
3009	mutex_lock(&private->data_mutex);
3010
3011	err = scarlett2_check_input_phantom_updated(mixer);
3012	if (err < 0)
3013	goto unlock;
3014
3015	err = snd_ctl_boolean_mono_info(kcontrol: kctl, uinfo);
3016
3017	unlock:
3018	mutex_unlock(lock: &private->data_mutex);
3019	return err;
3020	}
3021
3022	static int scarlett2_autogain_switch_ctl_get(
3023	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3024	{
3025	struct usb_mixer_elem_info *elem = kctl->private_data;
3026	struct usb_mixer_interface *mixer = elem->head.mixer;
3027	struct scarlett2_data *private = mixer->private_data;
3028	int err;
3029
3030	mutex_lock(&private->data_mutex);
3031
3032	if (private->hwdep_in_use) {
3033	err = -EBUSY;
3034	goto unlock;
3035	}
3036
3037	err = scarlett2_check_autogain_updated(mixer);
3038	if (err < 0)
3039	goto unlock;
3040
3041	ucontrol->value.enumerated.item[0] =
3042	private->autogain_switch[elem->control];
3043
3044	unlock:
3045	mutex_unlock(lock: &private->data_mutex);
3046	return err;
3047	}
3048
3049	static int scarlett2_autogain_status_ctl_get(
3050	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3051	{
3052	struct usb_mixer_elem_info *elem = kctl->private_data;
3053	struct usb_mixer_interface *mixer = elem->head.mixer;
3054	struct scarlett2_data *private = mixer->private_data;
3055	int err;
3056
3057	mutex_lock(&private->data_mutex);
3058
3059	if (private->hwdep_in_use) {
3060	err = -EBUSY;
3061	goto unlock;
3062	}
3063
3064	err = scarlett2_check_autogain_updated(mixer);
3065	if (err < 0)
3066	goto unlock;
3067
3068	ucontrol->value.enumerated.item[0] =
3069	private->autogain_status[elem->control];
3070
3071	unlock:
3072	mutex_unlock(lock: &private->data_mutex);
3073	return err;
3074	}
3075
3076	static int scarlett2_autogain_switch_ctl_put(
3077	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3078	{
3079	struct usb_mixer_elem_info *elem = kctl->private_data;
3080	struct usb_mixer_interface *mixer = elem->head.mixer;
3081	struct scarlett2_data *private = mixer->private_data;
3082
3083	int index = elem->control;
3084	int oval, val, err;
3085
3086	mutex_lock(&private->data_mutex);
3087
3088	if (private->hwdep_in_use) {
3089	err = -EBUSY;
3090	goto unlock;
3091	}
3092
3093	err = scarlett2_check_input_phantom_updated(mixer);
3094	if (err < 0)
3095	goto unlock;
3096
3097	if (scarlett2_phantom_is_switching(private, index)) {
3098	err = -EPERM;
3099	goto unlock;
3100	}
3101
3102	oval = private->autogain_switch[index];
3103	val = !!ucontrol->value.integer.value[0];
3104
3105	if (oval == val)
3106	goto unlock;
3107
3108	private->autogain_switch[index] = val;
3109
3110	/* Send switch change to the device */
3111	err = scarlett2_usb_set_config(
3112	mixer, config_item_num: SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, value: val);
3113	if (err == 0)
3114	err = 1;
3115
3116	scarlett2_autogain_update_access(mixer);
3117	scarlett2_autogain_notify_access(mixer);
3118
3119	unlock:
3120	mutex_unlock(lock: &private->data_mutex);
3121	return err;
3122	}
3123
3124	static int scarlett2_autogain_status_ctl_info(
3125	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3126	{
3127	return snd_ctl_enum_info(
3128	info: uinfo, channels: 1,
3129	ARRAY_SIZE(scarlett2_autogain_status_texts),
3130	names: scarlett2_autogain_status_texts);
3131	}
3132
3133	static const struct snd_kcontrol_new scarlett2_autogain_switch_ctl = {
3134	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3135	.name = "",
3136	.info = scarlett2_autogain_switch_ctl_info,
3137	.get = scarlett2_autogain_switch_ctl_get,
3138	.put = scarlett2_autogain_switch_ctl_put
3139	};
3140
3141	static const struct snd_kcontrol_new scarlett2_autogain_status_ctl = {
3142	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3143	.access = SNDRV_CTL_ELEM_ACCESS_READ,
3144	.name = "",
3145	.info = scarlett2_autogain_status_ctl_info,
3146	.get = scarlett2_autogain_status_ctl_get,
3147	};
3148
3149	/*** Input Select Control ***/
3150
3151	static int scarlett2_update_input_select(struct usb_mixer_interface *mixer)
3152	{
3153	struct scarlett2_data *private = mixer->private_data;
3154	const struct scarlett2_device_info *info = private->info;
3155	int link_count = info->gain_input_count / 2;
3156	int err;
3157
3158	private->input_select_updated = 0;
3159
3160	if (!link_count)
3161	return 0;
3162
3163	err = scarlett2_usb_get_config(
3164	mixer, config_item_num: SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3165	count: 1, buf: &private->input_select_switch);
3166	if (err < 0)
3167	return err;
3168
3169	err = scarlett2_usb_get_config(
3170	mixer, config_item_num: SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
3171	count: link_count, buf: private->input_link_switch);
3172	if (err < 0)
3173	return err;
3174
3175	/* simplified because no model yet has link_count > 1 */
3176	if (private->input_link_switch[0])
3177	private->input_select_switch = 0;
3178
3179	return 0;
3180	}
3181
3182	static int scarlett2_input_select_ctl_get(
3183	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3184	{
3185	struct usb_mixer_elem_info *elem = kctl->private_data;
3186	struct usb_mixer_interface *mixer = elem->head.mixer;
3187	struct scarlett2_data *private = mixer->private_data;
3188	int err = 0;
3189
3190	mutex_lock(&private->data_mutex);
3191
3192	if (private->hwdep_in_use) {
3193	err = -EBUSY;
3194	goto unlock;
3195	}
3196
3197	if (private->input_select_updated) {
3198	err = scarlett2_update_input_select(mixer);
3199	if (err < 0)
3200	goto unlock;
3201	}
3202	ucontrol->value.enumerated.item[0] = private->input_select_switch;
3203
3204	unlock:
3205	mutex_unlock(lock: &private->data_mutex);
3206	return err;
3207	}
3208
3209	static int scarlett2_input_select_ctl_put(
3210	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3211	{
3212	struct usb_mixer_elem_info *elem = kctl->private_data;
3213	struct usb_mixer_interface *mixer = elem->head.mixer;
3214	struct scarlett2_data *private = mixer->private_data;
3215
3216	int oval, val, err;
3217	int max_val = private->input_link_switch[0] ? 0 : 1;
3218
3219	mutex_lock(&private->data_mutex);
3220
3221	if (private->hwdep_in_use) {
3222	err = -EBUSY;
3223	goto unlock;
3224	}
3225
3226	err = scarlett2_check_put_during_autogain(mixer);
3227	if (err < 0)
3228	goto unlock;
3229
3230	oval = private->input_select_switch;
3231	val = ucontrol->value.integer.value[0];
3232
3233	if (val < 0)
3234	val = 0;
3235	else if (val > max_val)
3236	val = max_val;
3237
3238	if (oval == val)
3239	goto unlock;
3240
3241	private->input_select_switch = val;
3242
3243	/* Send switch change to the device if inputs not linked */
3244	if (!private->input_link_switch[0])
3245	err = scarlett2_usb_set_config(
3246	mixer, config_item_num: SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3247	index: 1, value: val);
3248	if (err == 0)
3249	err = 1;
3250
3251	unlock:
3252	mutex_unlock(lock: &private->data_mutex);
3253	return err;
3254	}
3255
3256	static int scarlett2_input_select_ctl_info(
3257	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3258	{
3259	struct usb_mixer_elem_info *elem = kctl->private_data;
3260	struct usb_mixer_interface *mixer = elem->head.mixer;
3261	struct scarlett2_data *private = mixer->private_data;
3262
3263	int inputs = private->info->gain_input_count;
3264	int i, j;
3265	int err;
3266	char **values = kcalloc(n: inputs, size: sizeof(char *), GFP_KERNEL);
3267
3268	if (!values)
3269	return -ENOMEM;
3270
3271	mutex_lock(&private->data_mutex);
3272
3273	if (private->hwdep_in_use) {
3274	err = -EBUSY;
3275	goto unlock;
3276	}
3277
3278	err = scarlett2_check_autogain_updated(mixer);
3279	if (err < 0)
3280	goto unlock;
3281
3282	/* Loop through each input
3283	* Linked inputs have one value for the pair
3284	*/
3285	for (i = 0, j = 0; i < inputs; i++) {
3286	if (private->input_link_switch[i / 2]) {
3287	values[j++] = kasprintf(
3288	GFP_KERNEL, fmt: "Input %d-%d", i + 1, i + 2);
3289	i++;
3290	} else {
3291	values[j++] = kasprintf(
3292	GFP_KERNEL, fmt: "Input %d", i + 1);
3293	}
3294	}
3295
3296	err = snd_ctl_enum_info(info: uinfo, channels: 1, items: j,
3297	names: (const char * const *)values);
3298
3299	unlock:
3300	mutex_unlock(lock: &private->data_mutex);
3301
3302	for (i = 0; i < inputs; i++)
3303	kfree(objp: values[i]);
3304	kfree(objp: values);
3305
3306	return err;
3307	}
3308
3309	static const struct snd_kcontrol_new scarlett2_input_select_ctl = {
3310	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3311	.name = "",
3312	.info = scarlett2_input_select_ctl_info,
3313	.get = scarlett2_input_select_ctl_get,
3314	.put = scarlett2_input_select_ctl_put,
3315	};
3316
3317	/*** Input Link Switch Controls ***/
3318
3319	/* snd_ctl_boolean_mono_info() with autogain-updated check
3320	* (for controls that are read-only while autogain is running)
3321	*/
3322	static int scarlett2_autogain_disables_ctl_info(struct snd_kcontrol *kctl,
3323	struct snd_ctl_elem_info *uinfo)
3324	{
3325	struct usb_mixer_elem_info *elem = kctl->private_data;
3326	struct usb_mixer_interface *mixer = elem->head.mixer;
3327	struct scarlett2_data *private = mixer->private_data;
3328	int err;
3329
3330	mutex_lock(&private->data_mutex);
3331
3332	if (private->hwdep_in_use) {
3333	err = -EBUSY;
3334	goto unlock;
3335	}
3336
3337	err = scarlett2_check_autogain_updated(mixer);
3338	if (err < 0)
3339	goto unlock;
3340
3341	err = snd_ctl_boolean_mono_info(kcontrol: kctl, uinfo);
3342
3343	unlock:
3344	mutex_unlock(lock: &private->data_mutex);
3345	return err;
3346	}
3347
3348	static int scarlett2_input_link_ctl_get(
3349	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3350	{
3351	struct usb_mixer_elem_info *elem = kctl->private_data;
3352	struct usb_mixer_interface *mixer = elem->head.mixer;
3353	struct scarlett2_data *private = mixer->private_data;
3354	int err = 0;
3355
3356	mutex_lock(&private->data_mutex);
3357
3358	if (private->hwdep_in_use) {
3359	err = -EBUSY;
3360	goto unlock;
3361	}
3362
3363	if (private->input_select_updated) {
3364	err = scarlett2_update_input_select(mixer);
3365	if (err < 0)
3366	goto unlock;
3367	}
3368	ucontrol->value.enumerated.item[0] =
3369	private->input_link_switch[elem->control];
3370
3371	unlock:
3372	mutex_unlock(lock: &private->data_mutex);
3373	return err;
3374	}
3375
3376	static int scarlett2_input_link_ctl_put(
3377	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3378	{
3379	struct usb_mixer_elem_info *elem = kctl->private_data;
3380	struct usb_mixer_interface *mixer = elem->head.mixer;
3381	struct scarlett2_data *private = mixer->private_data;
3382
3383	int index = elem->control;
3384	int oval, val, err;
3385
3386	mutex_lock(&private->data_mutex);
3387
3388	if (private->hwdep_in_use) {
3389	err = -EBUSY;
3390	goto unlock;
3391	}
3392
3393	err = scarlett2_check_put_during_autogain(mixer);
3394	if (err < 0)
3395	goto unlock;
3396
3397	oval = private->input_link_switch[index];
3398	val = !!ucontrol->value.integer.value[0];
3399
3400	if (oval == val)
3401	goto unlock;
3402
3403	private->input_link_switch[index] = val;
3404
3405	/* Notify of change in input select options available */
3406	snd_ctl_notify(card: mixer->chip->card,
3407	SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
3408	id: &private->input_select_ctl->id);
3409	private->input_select_updated = 1;
3410
3411	/* Send switch change to the device
3412	* Link for channels 1-2 is at index 1
3413	* No device yet has more than 2 channels linked
3414	*/
3415	err = scarlett2_usb_set_config(
3416	mixer, config_item_num: SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index: index + 1, value: val);
3417	if (err == 0)
3418	err = 1;
3419
3420	unlock:
3421	mutex_unlock(lock: &private->data_mutex);
3422	return err;
3423	}
3424
3425	static const struct snd_kcontrol_new scarlett2_input_link_ctl = {
3426	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3427	.name = "",
3428	.info = scarlett2_autogain_disables_ctl_info,
3429	.get = scarlett2_input_link_ctl_get,
3430	.put = scarlett2_input_link_ctl_put
3431	};
3432
3433	/*** Input Gain Controls ***/
3434
3435	static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer)
3436	{
3437	struct scarlett2_data *private = mixer->private_data;
3438	const struct scarlett2_device_info *info = private->info;
3439
3440	private->input_gain_updated = 0;
3441
3442	if (!info->gain_input_count)
3443	return 0;
3444
3445	return scarlett2_usb_get_config(
3446	mixer, config_item_num: SCARLETT2_CONFIG_INPUT_GAIN,
3447	count: info->gain_input_count, buf: private->gain);
3448	}
3449
3450	static int scarlett2_input_gain_ctl_info(struct snd_kcontrol *kctl,
3451	struct snd_ctl_elem_info *uinfo)
3452	{
3453	struct usb_mixer_elem_info *elem = kctl->private_data;
3454	struct usb_mixer_interface *mixer = elem->head.mixer;
3455	struct scarlett2_data *private = mixer->private_data;
3456	int err;
3457
3458	mutex_lock(&private->data_mutex);
3459
3460	if (private->hwdep_in_use) {
3461	err = -EBUSY;
3462	goto unlock;
3463	}
3464
3465	err = scarlett2_check_autogain_updated(mixer);
3466	if (err < 0)
3467	goto unlock;
3468
3469	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3470	uinfo->count = elem->channels;
3471	uinfo->value.integer.min = 0;
3472	uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;
3473	uinfo->value.integer.step = 1;
3474
3475	unlock:
3476	mutex_unlock(lock: &private->data_mutex);
3477	return err;
3478	}
3479
3480	static int scarlett2_input_gain_ctl_get(struct snd_kcontrol *kctl,
3481	struct snd_ctl_elem_value *ucontrol)
3482	{
3483	struct usb_mixer_elem_info *elem = kctl->private_data;
3484	struct usb_mixer_interface *mixer = elem->head.mixer;
3485	struct scarlett2_data *private = mixer->private_data;
3486	int err = 0;
3487
3488	mutex_lock(&private->data_mutex);
3489
3490	if (private->hwdep_in_use) {
3491	err = -EBUSY;
3492	goto unlock;
3493	}
3494
3495	if (private->input_gain_updated) {
3496	err = scarlett2_update_input_gain(mixer);
3497	if (err < 0)
3498	goto unlock;
3499	}
3500	ucontrol->value.integer.value[0] =
3501	private->gain[elem->control];
3502
3503	unlock:
3504	mutex_unlock(lock: &private->data_mutex);
3505	return err;
3506	}
3507
3508	static int scarlett2_input_gain_ctl_put(struct snd_kcontrol *kctl,
3509	struct snd_ctl_elem_value *ucontrol)
3510	{
3511	struct usb_mixer_elem_info *elem = kctl->private_data;
3512	struct usb_mixer_interface *mixer = elem->head.mixer;
3513	struct scarlett2_data *private = mixer->private_data;
3514
3515	int index = elem->control;
3516	int oval, val, err;
3517
3518	mutex_lock(&private->data_mutex);
3519
3520	if (private->hwdep_in_use) {
3521	err = -EBUSY;
3522	goto unlock;
3523	}
3524
3525	err = scarlett2_check_put_during_autogain(mixer);
3526	if (err < 0)
3527	goto unlock;
3528
3529	oval = private->gain[index];
3530	val = ucontrol->value.integer.value[0];
3531
3532	if (oval == val)
3533	goto unlock;
3534
3535	private->gain[index] = val;
3536
3537	/* Send gain change to the device */
3538	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_INPUT_GAIN,
3539	index, value: val);
3540	if (err == 0)
3541	err = 1;
3542
3543	unlock:
3544	mutex_unlock(lock: &private->data_mutex);
3545	return err;
3546	}
3547
3548	static const DECLARE_TLV_DB_MINMAX(
3549	db_scale_scarlett2_gain, 0, SCARLETT2_MAX_GAIN_DB * 100
3550	);
3551
3552	static const struct snd_kcontrol_new scarlett2_input_gain_ctl = {
3553	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3554	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3555	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3556	.name = "",
3557	.info = scarlett2_input_gain_ctl_info,
3558	.get = scarlett2_input_gain_ctl_get,
3559	.put = scarlett2_input_gain_ctl_put,
3560	.private_value = 0, /* max value */
3561	.tlv = { .p = db_scale_scarlett2_gain }
3562	};
3563
3564	/*** Safe Controls ***/
3565
3566	static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer)
3567	{
3568	struct scarlett2_data *private = mixer->private_data;
3569	const struct scarlett2_device_info *info = private->info;
3570
3571	private->input_safe_updated = 0;
3572
3573	if (!info->gain_input_count)
3574	return 0;
3575
3576	return scarlett2_usb_get_config(
3577	mixer, config_item_num: SCARLETT2_CONFIG_SAFE_SWITCH,
3578	count: info->gain_input_count, buf: private->safe_switch);
3579	}
3580
3581	static int scarlett2_safe_ctl_get(struct snd_kcontrol *kctl,
3582	struct snd_ctl_elem_value *ucontrol)
3583	{
3584	struct usb_mixer_elem_info *elem = kctl->private_data;
3585	struct usb_mixer_interface *mixer = elem->head.mixer;
3586	struct scarlett2_data *private = mixer->private_data;
3587	int err = 0;
3588
3589	mutex_lock(&private->data_mutex);
3590
3591	if (private->hwdep_in_use) {
3592	err = -EBUSY;
3593	goto unlock;
3594	}
3595
3596	if (private->input_safe_updated) {
3597	err = scarlett2_update_input_safe(mixer);
3598	if (err < 0)
3599	goto unlock;
3600	}
3601	ucontrol->value.integer.value[0] =
3602	private->safe_switch[elem->control];
3603
3604	unlock:
3605	mutex_unlock(lock: &private->data_mutex);
3606	return err;
3607	}
3608
3609	static int scarlett2_safe_ctl_put(struct snd_kcontrol *kctl,
3610	struct snd_ctl_elem_value *ucontrol)
3611	{
3612	struct usb_mixer_elem_info *elem = kctl->private_data;
3613	struct usb_mixer_interface *mixer = elem->head.mixer;
3614	struct scarlett2_data *private = mixer->private_data;
3615
3616	int index = elem->control;
3617	int oval, val, err;
3618
3619	mutex_lock(&private->data_mutex);
3620
3621	if (private->hwdep_in_use) {
3622	err = -EBUSY;
3623	goto unlock;
3624	}
3625
3626	err = scarlett2_check_put_during_autogain(mixer);
3627	if (err < 0)
3628	goto unlock;
3629
3630	oval = private->safe_switch[index];
3631	val = !!ucontrol->value.integer.value[0];
3632
3633	if (oval == val)
3634	goto unlock;
3635
3636	private->safe_switch[index] = val;
3637
3638	/* Send switch change to the device */
3639	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_SAFE_SWITCH,
3640	index, value: val);
3641	if (err == 0)
3642	err = 1;
3643
3644	unlock:
3645	mutex_unlock(lock: &private->data_mutex);
3646	return err;
3647	}
3648
3649	static const struct snd_kcontrol_new scarlett2_safe_ctl = {
3650	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3651	.name = "",
3652	.info = scarlett2_autogain_disables_ctl_info,
3653	.get = scarlett2_safe_ctl_get,
3654	.put = scarlett2_safe_ctl_put,
3655	};
3656
3657	/*** PCM Input Control ***/
3658
3659	static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer)
3660	{
3661	struct scarlett2_data *private = mixer->private_data;
3662	int err;
3663
3664	private->pcm_input_switch_updated = 0;
3665
3666	err = scarlett2_usb_get_config(
3667	mixer, config_item_num: SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
3668	count: 1, buf: &private->pcm_input_switch);
3669	if (err < 0)
3670	return err;
3671
3672	return 0;
3673	}
3674
3675	static int scarlett2_pcm_input_switch_ctl_get(
3676	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3677	{
3678	struct usb_mixer_elem_info *elem = kctl->private_data;
3679	struct usb_mixer_interface *mixer = elem->head.mixer;
3680	struct scarlett2_data *private = elem->head.mixer->private_data;
3681	int err = 0;
3682
3683	mutex_lock(&private->data_mutex);
3684
3685	if (private->pcm_input_switch_updated) {
3686	err = scarlett2_update_pcm_input_switch(mixer);
3687	if (err < 0)
3688	goto unlock;
3689	}
3690	ucontrol->value.enumerated.item[0] = private->pcm_input_switch;
3691
3692	unlock:
3693	mutex_unlock(lock: &private->data_mutex);
3694	return err;
3695	}
3696
3697	static int scarlett2_pcm_input_switch_ctl_put(
3698	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
3699	{
3700	struct usb_mixer_elem_info *elem = kctl->private_data;
3701	struct usb_mixer_interface *mixer = elem->head.mixer;
3702	struct scarlett2_data *private = mixer->private_data;
3703
3704	int oval, val, err = 0;
3705
3706	mutex_lock(&private->data_mutex);
3707
3708	if (private->hwdep_in_use) {
3709	err = -EBUSY;
3710	goto unlock;
3711	}
3712
3713	oval = private->pcm_input_switch;
3714	val = !!ucontrol->value.integer.value[0];
3715
3716	if (oval == val)
3717	goto unlock;
3718
3719	private->pcm_input_switch = val;
3720
3721	/* Send switch change to the device */
3722	err = scarlett2_usb_set_config(
3723	mixer, config_item_num: SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
3724	index: 0, value: val);
3725	if (err == 0)
3726	err = 1;
3727
3728	unlock:
3729	mutex_unlock(lock: &private->data_mutex);
3730	return err;
3731	}
3732
3733	static int scarlett2_pcm_input_switch_ctl_info(
3734	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
3735	{
3736	static const char *const values[2] = {
3737	"Direct", "Mixer"
3738	};
3739
3740	return snd_ctl_enum_info(
3741	info: uinfo, channels: 1, items: 2, names: values);
3742	}
3743
3744	static const struct snd_kcontrol_new scarlett2_pcm_input_switch_ctl = {
3745	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3746	.name = "",
3747	.info = scarlett2_pcm_input_switch_ctl_info,
3748	.get = scarlett2_pcm_input_switch_ctl_get,
3749	.put = scarlett2_pcm_input_switch_ctl_put
3750	};
3751
3752	/*** Analogue Line Out Volume Controls ***/
3753
3754	/* Update hardware volume controls after receiving notification that
3755	* they have changed
3756	*/
3757	static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
3758	{
3759	struct scarlett2_data *private = mixer->private_data;
3760	s16 vol;
3761	int err, i;
3762
3763	private->vol_updated = 0;
3764
3765	if (scarlett2_has_config_item(private,
3766	config_item_num: SCARLETT2_CONFIG_MASTER_VOLUME)) {
3767	err = scarlett2_usb_get_config(
3768	mixer, config_item_num: SCARLETT2_CONFIG_MASTER_VOLUME,
3769	count: 1, buf: &vol);
3770	if (err < 0)
3771	return err;
3772
3773	private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
3774	0, SCARLETT2_VOLUME_BIAS);
3775
3776	if (scarlett2_has_config_item(private,
3777	config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH))
3778	for (i = 0; i < private->num_line_out; i++)
3779	if (private->vol_sw_hw_switch[i])
3780	private->vol[i] = private->master_vol;
3781	}
3782
3783	if (scarlett2_has_config_item(private,
3784	config_item_num: SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {
3785	err = scarlett2_usb_get_config(
3786	mixer, config_item_num: SCARLETT2_CONFIG_HEADPHONE_VOLUME,
3787	count: 1, buf: &vol);
3788	if (err < 0)
3789	return err;
3790
3791	private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
3792	0, SCARLETT2_VOLUME_BIAS);
3793	}
3794
3795	return 0;
3796	}
3797
3798	static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
3799	struct snd_ctl_elem_info *uinfo)
3800	{
3801	struct usb_mixer_elem_info *elem = kctl->private_data;
3802
3803	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3804	uinfo->count = elem->channels;
3805	uinfo->value.integer.min = 0;
3806	uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
3807	uinfo->value.integer.step = 1;
3808	return 0;
3809	}
3810
3811	static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
3812	struct snd_ctl_elem_value *ucontrol)
3813	{
3814	struct usb_mixer_elem_info *elem = kctl->private_data;
3815	struct usb_mixer_interface *mixer = elem->head.mixer;
3816	struct scarlett2_data *private = mixer->private_data;
3817	int err = 0;
3818
3819	mutex_lock(&private->data_mutex);
3820
3821	if (private->hwdep_in_use) {
3822	err = -EBUSY;
3823	goto unlock;
3824	}
3825
3826	if (private->vol_updated) {
3827	err = scarlett2_update_volumes(mixer);
3828	if (err < 0)
3829	goto unlock;
3830	}
3831	ucontrol->value.integer.value[0] = private->master_vol;
3832
3833	unlock:
3834	mutex_unlock(lock: &private->data_mutex);
3835	return err;
3836	}
3837
3838	static int scarlett2_headphone_volume_ctl_get(
3839	struct snd_kcontrol *kctl,
3840	struct snd_ctl_elem_value *ucontrol)
3841	{
3842	struct usb_mixer_elem_info *elem = kctl->private_data;
3843	struct usb_mixer_interface *mixer = elem->head.mixer;
3844	struct scarlett2_data *private = mixer->private_data;
3845	int err = 0;
3846
3847	mutex_lock(&private->data_mutex);
3848
3849	if (private->hwdep_in_use) {
3850	err = -EBUSY;
3851	goto unlock;
3852	}
3853
3854	if (private->vol_updated) {
3855	err = scarlett2_update_volumes(mixer);
3856	if (err < 0)
3857	goto unlock;
3858	}
3859	ucontrol->value.integer.value[0] = private->headphone_vol;
3860
3861	unlock:
3862	mutex_unlock(lock: &private->data_mutex);
3863	return err;
3864	}
3865
3866	static int line_out_remap(struct scarlett2_data *private, int index)
3867	{
3868	const struct scarlett2_device_info *info = private->info;
3869
3870	if (!info->line_out_remap_enable)
3871	return index;
3872
3873	if (index >= private->num_line_out)
3874	return index;
3875
3876	return info->line_out_remap[index];
3877	}
3878
3879	static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
3880	struct snd_ctl_elem_value *ucontrol)
3881	{
3882	struct usb_mixer_elem_info *elem = kctl->private_data;
3883	struct usb_mixer_interface *mixer = elem->head.mixer;
3884	struct scarlett2_data *private = mixer->private_data;
3885	int index = line_out_remap(private, index: elem->control);
3886	int err = 0;
3887
3888	mutex_lock(&private->data_mutex);
3889
3890	if (private->hwdep_in_use) {
3891	err = -EBUSY;
3892	goto unlock;
3893	}
3894
3895	if (private->vol_updated) {
3896	err = scarlett2_update_volumes(mixer);
3897	if (err < 0)
3898	goto unlock;
3899	}
3900	ucontrol->value.integer.value[0] = private->vol[index];
3901
3902	unlock:
3903	mutex_unlock(lock: &private->data_mutex);
3904	return err;
3905	}
3906
3907	static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
3908	struct snd_ctl_elem_value *ucontrol)
3909	{
3910	struct usb_mixer_elem_info *elem = kctl->private_data;
3911	struct usb_mixer_interface *mixer = elem->head.mixer;
3912	struct scarlett2_data *private = mixer->private_data;
3913	int index = line_out_remap(private, index: elem->control);
3914	int oval, val, err = 0;
3915
3916	mutex_lock(&private->data_mutex);
3917
3918	if (private->hwdep_in_use) {
3919	err = -EBUSY;
3920	goto unlock;
3921	}
3922
3923	oval = private->vol[index];
3924	val = ucontrol->value.integer.value[0];
3925
3926	if (oval == val)
3927	goto unlock;
3928
3929	private->vol[index] = val;
3930	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_LINE_OUT_VOLUME,
3931	index, value: val - SCARLETT2_VOLUME_BIAS);
3932	if (err == 0)
3933	err = 1;
3934
3935	unlock:
3936	mutex_unlock(lock: &private->data_mutex);
3937	return err;
3938	}
3939
3940	static const DECLARE_TLV_DB_MINMAX(
3941	db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
3942	);
3943
3944	static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
3945	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3946	.access = SNDRV_CTL_ELEM_ACCESS_READ |
3947	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3948	.name = "",
3949	.info = scarlett2_volume_ctl_info,
3950	.get = scarlett2_master_volume_ctl_get,
3951	.private_value = 0, /* max value */
3952	.tlv = { .p = db_scale_scarlett2_volume }
3953	};
3954
3955	static const struct snd_kcontrol_new scarlett2_headphone_volume_ctl = {
3956	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3957	.access = SNDRV_CTL_ELEM_ACCESS_READ |
3958	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3959	.name = "",
3960	.info = scarlett2_volume_ctl_info,
3961	.get = scarlett2_headphone_volume_ctl_get,
3962	.private_value = 0, /* max value */
3963	.tlv = { .p = db_scale_scarlett2_volume }
3964	};
3965
3966	static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
3967	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3968	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
3969	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
3970	.name = "",
3971	.info = scarlett2_volume_ctl_info,
3972	.get = scarlett2_volume_ctl_get,
3973	.put = scarlett2_volume_ctl_put,
3974	.private_value = 0, /* max value */
3975	.tlv = { .p = db_scale_scarlett2_volume }
3976	};
3977
3978	/*** Mute Switch Controls ***/
3979
3980	static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)
3981	{
3982	struct scarlett2_data *private = mixer->private_data;
3983	int err, i;
3984	u8 mute;
3985
3986	private->dim_mute_updated = 0;
3987
3988	if (!scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH))
3989	return 0;
3990
3991	err = scarlett2_usb_get_config(
3992	mixer, config_item_num: SCARLETT2_CONFIG_DIM_MUTE,
3993	count: SCARLETT2_DIM_MUTE_COUNT, buf: private->dim_mute);
3994	if (err < 0)
3995	return err;
3996
3997	for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
3998	private->dim_mute[i] = !!private->dim_mute[i];
3999
4000	mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4001
4002	for (i = 0; i < private->num_line_out; i++)
4003	if (private->vol_sw_hw_switch[i])
4004	private->mute_switch[i] = mute;
4005
4006	return 0;
4007	}
4008
4009	static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,
4010	struct snd_ctl_elem_value *ucontrol)
4011	{
4012	struct usb_mixer_elem_info *elem = kctl->private_data;
4013	struct usb_mixer_interface *mixer = elem->head.mixer;
4014	struct scarlett2_data *private = mixer->private_data;
4015	int index = line_out_remap(private, index: elem->control);
4016	int err = 0;
4017
4018	mutex_lock(&private->data_mutex);
4019
4020	if (private->hwdep_in_use) {
4021	err = -EBUSY;
4022	goto unlock;
4023	}
4024
4025	if (private->dim_mute_updated) {
4026	err = scarlett2_update_dim_mute(mixer);
4027	if (err < 0)
4028	goto unlock;
4029	}
4030	ucontrol->value.integer.value[0] = private->mute_switch[index];
4031
4032	unlock:
4033	mutex_unlock(lock: &private->data_mutex);
4034	return err;
4035	}
4036
4037	static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
4038	struct snd_ctl_elem_value *ucontrol)
4039	{
4040	struct usb_mixer_elem_info *elem = kctl->private_data;
4041	struct usb_mixer_interface *mixer = elem->head.mixer;
4042	struct scarlett2_data *private = mixer->private_data;
4043	int index = line_out_remap(private, index: elem->control);
4044	int oval, val, err = 0;
4045
4046	mutex_lock(&private->data_mutex);
4047
4048	if (private->hwdep_in_use) {
4049	err = -EBUSY;
4050	goto unlock;
4051	}
4052
4053	oval = private->mute_switch[index];
4054	val = !!ucontrol->value.integer.value[0];
4055
4056	if (oval == val)
4057	goto unlock;
4058
4059	private->mute_switch[index] = val;
4060
4061	/* Send mute change to the device */
4062	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_MUTE_SWITCH,
4063	index, value: val);
4064	if (err == 0)
4065	err = 1;
4066
4067	unlock:
4068	mutex_unlock(lock: &private->data_mutex);
4069	return err;
4070	}
4071
4072	static const struct snd_kcontrol_new scarlett2_mute_ctl = {
4073	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4074	.name = "",
4075	.info = snd_ctl_boolean_mono_info,
4076	.get = scarlett2_mute_ctl_get,
4077	.put = scarlett2_mute_ctl_put,
4078	};
4079
4080	/*** HW/SW Volume Switch Controls ***/
4081
4082	static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
4083	{
4084	private->sw_hw_ctls[index]->vd[0].access &=
4085	~SNDRV_CTL_ELEM_ACCESS_WRITE;
4086	}
4087
4088	static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
4089	{
4090	private->sw_hw_ctls[index]->vd[0].access |=
4091	SNDRV_CTL_ELEM_ACCESS_WRITE;
4092	}
4093
4094	static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
4095	struct snd_ctl_elem_info *uinfo)
4096	{
4097	static const char *const values[2] = {
4098	"SW", "HW"
4099	};
4100
4101	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 2, names: values);
4102	}
4103
4104	static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
4105	struct snd_ctl_elem_value *ucontrol)
4106	{
4107	struct usb_mixer_elem_info *elem = kctl->private_data;
4108	struct scarlett2_data *private = elem->head.mixer->private_data;
4109	int index = line_out_remap(private, index: elem->control);
4110
4111	ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
4112	return 0;
4113	}
4114
4115	static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
4116	int index, int value)
4117	{
4118	struct scarlett2_data *private = mixer->private_data;
4119	struct snd_card *card = mixer->chip->card;
4120
4121	/* Set/Clear write bits */
4122	if (value) {
4123	private->vol_ctls[index]->vd[0].access |=
4124	SNDRV_CTL_ELEM_ACCESS_WRITE;
4125	private->mute_ctls[index]->vd[0].access |=
4126	SNDRV_CTL_ELEM_ACCESS_WRITE;
4127	} else {
4128	private->vol_ctls[index]->vd[0].access &=
4129	~SNDRV_CTL_ELEM_ACCESS_WRITE;
4130	private->mute_ctls[index]->vd[0].access &=
4131	~SNDRV_CTL_ELEM_ACCESS_WRITE;
4132	}
4133
4134	/* Notify of write bit and possible value change */
4135	snd_ctl_notify(card,
4136	SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
4137	id: &private->vol_ctls[index]->id);
4138	snd_ctl_notify(card,
4139	SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
4140	id: &private->mute_ctls[index]->id);
4141	}
4142
4143	static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
4144	int ctl_index, int val)
4145	{
4146	struct scarlett2_data *private = mixer->private_data;
4147	int index = line_out_remap(private, index: ctl_index);
4148	int err;
4149
4150	private->vol_sw_hw_switch[index] = val;
4151
4152	/* Change access mode to RO (hardware controlled volume)
4153	* or RW (software controlled volume)
4154	*/
4155	scarlett2_vol_ctl_set_writable(mixer, index: ctl_index, value: !val);
4156
4157	/* Reset volume/mute to master volume/mute */
4158	private->vol[index] = private->master_vol;
4159	private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4160
4161	/* Set SW volume to current HW volume */
4162	err = scarlett2_usb_set_config(
4163	mixer, config_item_num: SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4164	index, value: private->master_vol - SCARLETT2_VOLUME_BIAS);
4165	if (err < 0)
4166	return err;
4167
4168	/* Set SW mute to current HW mute */
4169	err = scarlett2_usb_set_config(
4170	mixer, config_item_num: SCARLETT2_CONFIG_MUTE_SWITCH,
4171	index, value: private->dim_mute[SCARLETT2_BUTTON_MUTE]);
4172	if (err < 0)
4173	return err;
4174
4175	/* Send SW/HW switch change to the device */
4176	return scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH,
4177	index, value: val);
4178	}
4179
4180	static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
4181	struct snd_ctl_elem_value *ucontrol)
4182	{
4183	struct usb_mixer_elem_info *elem = kctl->private_data;
4184	struct usb_mixer_interface *mixer = elem->head.mixer;
4185	struct scarlett2_data *private = mixer->private_data;
4186	int ctl_index = elem->control;
4187	int index = line_out_remap(private, index: ctl_index);
4188	int oval, val, err = 0;
4189
4190	mutex_lock(&private->data_mutex);
4191
4192	if (private->hwdep_in_use) {
4193	err = -EBUSY;
4194	goto unlock;
4195	}
4196
4197	oval = private->vol_sw_hw_switch[index];
4198	val = !!ucontrol->value.enumerated.item[0];
4199
4200	if (oval == val)
4201	goto unlock;
4202
4203	err = scarlett2_sw_hw_change(mixer, ctl_index, val);
4204	if (err == 0)
4205	err = 1;
4206
4207	unlock:
4208	mutex_unlock(lock: &private->data_mutex);
4209	return err;
4210	}
4211
4212	static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
4213	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4214	.name = "",
4215	.info = scarlett2_sw_hw_enum_ctl_info,
4216	.get = scarlett2_sw_hw_enum_ctl_get,
4217	.put = scarlett2_sw_hw_enum_ctl_put,
4218	};
4219
4220	/*** Line Level/Instrument Level Switch Controls ***/
4221
4222	static int scarlett2_update_input_level(struct usb_mixer_interface *mixer)
4223	{
4224	struct scarlett2_data *private = mixer->private_data;
4225	const struct scarlett2_device_info *info = private->info;
4226
4227	private->input_level_updated = 0;
4228
4229	if (!info->level_input_count)
4230	return 0;
4231
4232	return scarlett2_usb_get_config(
4233	mixer, config_item_num: SCARLETT2_CONFIG_LEVEL_SWITCH,
4234	count: info->level_input_count + info->level_input_first,
4235	buf: private->level_switch);
4236	}
4237
4238	static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
4239	struct snd_ctl_elem_info *uinfo)
4240	{
4241	static const char *const values[2] = {
4242	"Line", "Inst"
4243	};
4244	struct usb_mixer_elem_info *elem = kctl->private_data;
4245	struct usb_mixer_interface *mixer = elem->head.mixer;
4246	struct scarlett2_data *private = mixer->private_data;
4247	int err;
4248
4249	mutex_lock(&private->data_mutex);
4250
4251	if (private->hwdep_in_use) {
4252	err = -EBUSY;
4253	goto unlock;
4254	}
4255
4256	err = scarlett2_check_autogain_updated(mixer);
4257	if (err < 0)
4258	goto unlock;
4259
4260	err = snd_ctl_enum_info(info: uinfo, channels: 1, items: 2, names: values);
4261
4262	unlock:
4263	mutex_unlock(lock: &private->data_mutex);
4264	return err;
4265	}
4266
4267	static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
4268	struct snd_ctl_elem_value *ucontrol)
4269	{
4270	struct usb_mixer_elem_info *elem = kctl->private_data;
4271	struct usb_mixer_interface *mixer = elem->head.mixer;
4272	struct scarlett2_data *private = mixer->private_data;
4273	const struct scarlett2_device_info *info = private->info;
4274
4275	int index = elem->control + info->level_input_first;
4276	int err = 0;
4277
4278	mutex_lock(&private->data_mutex);
4279
4280	if (private->hwdep_in_use) {
4281	err = -EBUSY;
4282	goto unlock;
4283	}
4284
4285	if (private->input_level_updated) {
4286	err = scarlett2_update_input_level(mixer);
4287	if (err < 0)
4288	goto unlock;
4289	}
4290	ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(
4291	v: private->level_switch[index]);
4292
4293	unlock:
4294	mutex_unlock(lock: &private->data_mutex);
4295	return err;
4296	}
4297
4298	static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
4299	struct snd_ctl_elem_value *ucontrol)
4300	{
4301	struct usb_mixer_elem_info *elem = kctl->private_data;
4302	struct usb_mixer_interface *mixer = elem->head.mixer;
4303	struct scarlett2_data *private = mixer->private_data;
4304	const struct scarlett2_device_info *info = private->info;
4305
4306	int index = elem->control + info->level_input_first;
4307	int oval, val, err;
4308
4309	mutex_lock(&private->data_mutex);
4310
4311	if (private->hwdep_in_use) {
4312	err = -EBUSY;
4313	goto unlock;
4314	}
4315
4316	err = scarlett2_check_put_during_autogain(mixer);
4317	if (err < 0)
4318	goto unlock;
4319
4320	oval = private->level_switch[index];
4321	val = !!ucontrol->value.enumerated.item[0];
4322
4323	if (oval == val)
4324	goto unlock;
4325
4326	private->level_switch[index] = val;
4327
4328	/* To set the Gen 4 muteable controls, bit 1 gets set instead */
4329	if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)
4330	val = (!val) | 0x02;
4331
4332	/* Send switch change to the device */
4333	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_LEVEL_SWITCH,
4334	index, value: val);
4335	if (err == 0)
4336	err = 1;
4337
4338	unlock:
4339	mutex_unlock(lock: &private->data_mutex);
4340	return err;
4341	}
4342
4343	static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
4344	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4345	.name = "",
4346	.info = scarlett2_level_enum_ctl_info,
4347	.get = scarlett2_level_enum_ctl_get,
4348	.put = scarlett2_level_enum_ctl_put,
4349	};
4350
4351	/*** Pad Switch Controls ***/
4352
4353	static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer)
4354	{
4355	struct scarlett2_data *private = mixer->private_data;
4356	const struct scarlett2_device_info *info = private->info;
4357
4358	private->input_pad_updated = 0;
4359
4360	if (!info->pad_input_count)
4361	return 0;
4362
4363	return scarlett2_usb_get_config(
4364	mixer, config_item_num: SCARLETT2_CONFIG_PAD_SWITCH,
4365	count: info->pad_input_count, buf: private->pad_switch);
4366	}
4367
4368	static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
4369	struct snd_ctl_elem_value *ucontrol)
4370	{
4371	struct usb_mixer_elem_info *elem = kctl->private_data;
4372	struct usb_mixer_interface *mixer = elem->head.mixer;
4373	struct scarlett2_data *private = mixer->private_data;
4374	int err = 0;
4375
4376	mutex_lock(&private->data_mutex);
4377
4378	if (private->hwdep_in_use) {
4379	err = -EBUSY;
4380	goto unlock;
4381	}
4382
4383	if (private->input_pad_updated) {
4384	err = scarlett2_update_input_pad(mixer);
4385	if (err < 0)
4386	goto unlock;
4387	}
4388	ucontrol->value.integer.value[0] =
4389	private->pad_switch[elem->control];
4390
4391	unlock:
4392	mutex_unlock(lock: &private->data_mutex);
4393	return err;
4394	}
4395
4396	static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
4397	struct snd_ctl_elem_value *ucontrol)
4398	{
4399	struct usb_mixer_elem_info *elem = kctl->private_data;
4400	struct usb_mixer_interface *mixer = elem->head.mixer;
4401	struct scarlett2_data *private = mixer->private_data;
4402
4403	int index = elem->control;
4404	int oval, val, err = 0;
4405
4406	mutex_lock(&private->data_mutex);
4407
4408	if (private->hwdep_in_use) {
4409	err = -EBUSY;
4410	goto unlock;
4411	}
4412
4413	oval = private->pad_switch[index];
4414	val = !!ucontrol->value.integer.value[0];
4415
4416	if (oval == val)
4417	goto unlock;
4418
4419	private->pad_switch[index] = val;
4420
4421	/* Send switch change to the device */
4422	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_PAD_SWITCH,
4423	index, value: val);
4424	if (err == 0)
4425	err = 1;
4426
4427	unlock:
4428	mutex_unlock(lock: &private->data_mutex);
4429	return err;
4430	}
4431
4432	static const struct snd_kcontrol_new scarlett2_pad_ctl = {
4433	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4434	.name = "",
4435	.info = snd_ctl_boolean_mono_info,
4436	.get = scarlett2_pad_ctl_get,
4437	.put = scarlett2_pad_ctl_put,
4438	};
4439
4440	/*** Air Switch Controls ***/
4441
4442	static int scarlett2_update_input_air(struct usb_mixer_interface *mixer)
4443	{
4444	struct scarlett2_data *private = mixer->private_data;
4445	const struct scarlett2_device_info *info = private->info;
4446
4447	private->input_air_updated = 0;
4448
4449	if (!info->air_input_count)
4450	return 0;
4451
4452	return scarlett2_usb_get_config(
4453	mixer, config_item_num: SCARLETT2_CONFIG_AIR_SWITCH,
4454	count: info->air_input_count, buf: private->air_switch);
4455	}
4456
4457	static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
4458	struct snd_ctl_elem_value *ucontrol)
4459	{
4460	struct usb_mixer_elem_info *elem = kctl->private_data;
4461	struct usb_mixer_interface *mixer = elem->head.mixer;
4462	struct scarlett2_data *private = mixer->private_data;
4463	int err = 0;
4464
4465	mutex_lock(&private->data_mutex);
4466
4467	if (private->hwdep_in_use) {
4468	err = -EBUSY;
4469	goto unlock;
4470	}
4471
4472	if (private->input_air_updated) {
4473	err = scarlett2_update_input_air(mixer);
4474	if (err < 0)
4475	goto unlock;
4476	}
4477	ucontrol->value.integer.value[0] = private->air_switch[elem->control];
4478
4479	unlock:
4480	mutex_unlock(lock: &private->data_mutex);
4481	return err;
4482	}
4483
4484	static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
4485	struct snd_ctl_elem_value *ucontrol)
4486	{
4487	struct usb_mixer_elem_info *elem = kctl->private_data;
4488	struct usb_mixer_interface *mixer = elem->head.mixer;
4489	struct scarlett2_data *private = mixer->private_data;
4490
4491	int index = elem->control;
4492	int oval, val, err;
4493
4494	mutex_lock(&private->data_mutex);
4495
4496	if (private->hwdep_in_use) {
4497	err = -EBUSY;
4498	goto unlock;
4499	}
4500
4501	err = scarlett2_check_put_during_autogain(mixer);
4502	if (err < 0)
4503	goto unlock;
4504
4505	oval = private->air_switch[index];
4506	val = ucontrol->value.integer.value[0];
4507
4508	if (oval == val)
4509	goto unlock;
4510
4511	private->air_switch[index] = val;
4512
4513	/* Send switch change to the device */
4514	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_AIR_SWITCH,
4515	index, value: val);
4516	if (err == 0)
4517	err = 1;
4518
4519	unlock:
4520	mutex_unlock(lock: &private->data_mutex);
4521	return err;
4522	}
4523
4524	static int scarlett2_air_with_drive_ctl_info(
4525	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
4526	{
4527	static const char *const values[3] = {
4528	"Off", "Presence", "Presence + Drive"
4529	};
4530	struct usb_mixer_elem_info *elem = kctl->private_data;
4531	struct usb_mixer_interface *mixer = elem->head.mixer;
4532	struct scarlett2_data *private = mixer->private_data;
4533	int err;
4534
4535	mutex_lock(&private->data_mutex);
4536
4537	if (private->hwdep_in_use) {
4538	err = -EBUSY;
4539	goto unlock;
4540	}
4541
4542	err = scarlett2_check_autogain_updated(mixer);
4543	if (err < 0)
4544	goto unlock;
4545
4546	err = snd_ctl_enum_info(info: uinfo, channels: 1, items: 3, names: values);
4547
4548	unlock:
4549	mutex_unlock(lock: &private->data_mutex);
4550	return err;
4551	}
4552
4553	static const struct snd_kcontrol_new scarlett2_air_ctl[2] = {
4554	{
4555	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4556	.name = "",
4557	.info = snd_ctl_boolean_mono_info,
4558	.get = scarlett2_air_ctl_get,
4559	.put = scarlett2_air_ctl_put,
4560	},
4561	{
4562	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4563	.name = "",
4564	.info = scarlett2_air_with_drive_ctl_info,
4565	.get = scarlett2_air_ctl_get,
4566	.put = scarlett2_air_ctl_put,
4567	}
4568	};
4569
4570	/*** Phantom Switch Controls ***/
4571
4572	static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer)
4573	{
4574	struct scarlett2_data *private = mixer->private_data;
4575	const struct scarlett2_device_info *info = private->info;
4576	int err;
4577
4578	private->input_phantom_updated = 0;
4579
4580	if (!info->phantom_count)
4581	return 0;
4582
4583	err = scarlett2_usb_get_config(
4584	mixer, config_item_num: SCARLETT2_CONFIG_PHANTOM_SWITCH,
4585	count: info->phantom_count, buf: private->phantom_switch);
4586	if (err < 0)
4587	return err;
4588
4589	if (scarlett2_has_config_item(private,
4590	config_item_num: SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {
4591	err = scarlett2_usb_get_config(
4592	mixer, config_item_num: SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
4593	count: 1, buf: &private->phantom_persistence);
4594	if (err < 0)
4595	return err;
4596	}
4597
4598	return 0;
4599	}
4600
4601	/* Check if phantom power on the given input is currently changing state */
4602	static int scarlett2_phantom_is_switching(
4603	struct scarlett2_data *private, int line_num)
4604	{
4605	const struct scarlett2_device_info *info = private->info;
4606	int index = line_num / info->inputs_per_phantom;
4607
4608	return !!(private->phantom_switch[index] & 0x02);
4609	}
4610
4611	/* Update autogain controls' access mode when phantom power changes state */
4612	static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)
4613	{
4614	struct scarlett2_data *private = mixer->private_data;
4615	const struct scarlett2_device_info *info = private->info;
4616	int i;
4617
4618	/* Disable autogain controls if phantom power is changing state */
4619	for (i = 0; i < info->gain_input_count; i++) {
4620	int val = !scarlett2_phantom_is_switching(private, line_num: i);
4621
4622	scarlett2_set_ctl_access(kctl: private->autogain_ctls[i], val);
4623	}
4624	}
4625
4626	/* Notify of access mode change for autogain which can't be enabled
4627	* while phantom power is changing.
4628	*/
4629	static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer)
4630	{
4631	struct snd_card *card = mixer->chip->card;
4632	struct scarlett2_data *private = mixer->private_data;
4633	const struct scarlett2_device_info *info = private->info;
4634	int i;
4635
4636	for (i = 0; i < info->gain_input_count; i++)
4637	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
4638	id: &private->autogain_ctls[i]->id);
4639	}
4640
4641	/* Call scarlett2_update_input_phantom() and
4642	* scarlett2_phantom_update_access() if input_phantom_updated is set.
4643	*/
4644	static int scarlett2_check_input_phantom_updated(
4645	struct usb_mixer_interface *mixer)
4646	{
4647	struct scarlett2_data *private = mixer->private_data;
4648	int err;
4649
4650	if (!private->input_phantom_updated)
4651	return 0;
4652
4653	err = scarlett2_update_input_phantom(mixer);
4654	if (err < 0)
4655	return err;
4656
4657	scarlett2_phantom_update_access(mixer);
4658
4659	return 0;
4660	}
4661
4662	static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
4663	struct snd_ctl_elem_value *ucontrol)
4664	{
4665	struct usb_mixer_elem_info *elem = kctl->private_data;
4666	struct usb_mixer_interface *mixer = elem->head.mixer;
4667	struct scarlett2_data *private = mixer->private_data;
4668	int err;
4669
4670	mutex_lock(&private->data_mutex);
4671
4672	if (private->hwdep_in_use) {
4673	err = -EBUSY;
4674	goto unlock;
4675	}
4676
4677	err = scarlett2_check_input_phantom_updated(mixer);
4678	if (err < 0)
4679	goto unlock;
4680
4681	ucontrol->value.integer.value[0] = scarlett2_decode_muteable(
4682	v: private->phantom_switch[elem->control]);
4683
4684	unlock:
4685	mutex_unlock(lock: &private->data_mutex);
4686	return err;
4687	}
4688
4689	static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
4690	struct snd_ctl_elem_value *ucontrol)
4691	{
4692	struct usb_mixer_elem_info *elem = kctl->private_data;
4693	struct usb_mixer_interface *mixer = elem->head.mixer;
4694	struct scarlett2_data *private = mixer->private_data;
4695	const struct scarlett2_device_info *info = private->info;
4696
4697	int index = elem->control;
4698	int oval, val, err;
4699
4700	mutex_lock(&private->data_mutex);
4701
4702	if (private->hwdep_in_use) {
4703	err = -EBUSY;
4704	goto unlock;
4705	}
4706
4707	err = scarlett2_check_put_during_autogain(mixer);
4708	if (err < 0)
4709	goto unlock;
4710
4711	oval = private->phantom_switch[index];
4712	val = !!ucontrol->value.integer.value[0];
4713
4714	if (oval == val)
4715	goto unlock;
4716
4717	private->phantom_switch[index] = val;
4718
4719	/* To set the Gen 4 muteable controls, bit 1 gets set */
4720	if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)
4721	val = (!val) | 0x02;
4722
4723	/* Send switch change to the device */
4724	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_PHANTOM_SWITCH,
4725	index: index + info->phantom_first, value: val);
4726	if (err == 0)
4727	err = 1;
4728
4729	scarlett2_phantom_update_access(mixer);
4730	scarlett2_phantom_notify_access(mixer);
4731
4732	unlock:
4733	mutex_unlock(lock: &private->data_mutex);
4734	return err;
4735	}
4736
4737	static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
4738	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4739	.name = "",
4740	.info = scarlett2_autogain_disables_ctl_info,
4741	.get = scarlett2_phantom_ctl_get,
4742	.put = scarlett2_phantom_ctl_put,
4743	};
4744
4745	/*** Phantom Persistence Control ***/
4746
4747	static int scarlett2_phantom_persistence_ctl_get(
4748	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4749	{
4750	struct usb_mixer_elem_info *elem = kctl->private_data;
4751	struct scarlett2_data *private = elem->head.mixer->private_data;
4752
4753	ucontrol->value.integer.value[0] = private->phantom_persistence;
4754	return 0;
4755	}
4756
4757	static int scarlett2_phantom_persistence_ctl_put(
4758	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4759	{
4760	struct usb_mixer_elem_info *elem = kctl->private_data;
4761	struct usb_mixer_interface *mixer = elem->head.mixer;
4762	struct scarlett2_data *private = mixer->private_data;
4763
4764	int index = elem->control;
4765	int oval, val, err = 0;
4766
4767	mutex_lock(&private->data_mutex);
4768
4769	if (private->hwdep_in_use) {
4770	err = -EBUSY;
4771	goto unlock;
4772	}
4773
4774	oval = private->phantom_persistence;
4775	val = !!ucontrol->value.integer.value[0];
4776
4777	if (oval == val)
4778	goto unlock;
4779
4780	private->phantom_persistence = val;
4781
4782	/* Send switch change to the device */
4783	err = scarlett2_usb_set_config(
4784	mixer, config_item_num: SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, value: val);
4785	if (err == 0)
4786	err = 1;
4787
4788	unlock:
4789	mutex_unlock(lock: &private->data_mutex);
4790	return err;
4791	}
4792
4793	static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
4794	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4795	.name = "",
4796	.info = snd_ctl_boolean_mono_info,
4797	.get = scarlett2_phantom_persistence_ctl_get,
4798	.put = scarlett2_phantom_persistence_ctl_put,
4799	};
4800
4801	/*** Speaker Switching Control ***/
4802
4803	static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
4804	{
4805	struct scarlett2_data *private = mixer->private_data;
4806	const struct scarlett2_device_info *info = private->info;
4807	int err;
4808
4809	/* monitor_other_enable[0] enables speaker switching
4810	* monitor_other_enable[1] enables talkback
4811	*/
4812	u8 monitor_other_enable[2];
4813
4814	/* monitor_other_switch[0] activates the alternate speakers
4815	* monitor_other_switch[1] activates talkback
4816	*/
4817	u8 monitor_other_switch[2];
4818
4819	private->monitor_other_updated = 0;
4820
4821	/* if it doesn't do speaker switching then it also doesn't do
4822	* talkback
4823	*/
4824	if (!info->has_speaker_switching)
4825	return 0;
4826
4827	err = scarlett2_usb_get_config(
4828	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
4829	count: 2, buf: monitor_other_enable);
4830	if (err < 0)
4831	return err;
4832
4833	err = scarlett2_usb_get_config(
4834	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
4835	count: 2, buf: monitor_other_switch);
4836	if (err < 0)
4837	return err;
4838
4839	if (!monitor_other_enable[0])
4840	private->speaker_switching_switch = 0;
4841	else
4842	private->speaker_switching_switch = monitor_other_switch[0] + 1;
4843
4844	if (info->has_talkback) {
4845	u16 bitmap;
4846	int i;
4847
4848	if (!monitor_other_enable[1])
4849	private->talkback_switch = 0;
4850	else
4851	private->talkback_switch = monitor_other_switch[1] + 1;
4852
4853	err = scarlett2_usb_get_config(mixer,
4854	config_item_num: SCARLETT2_CONFIG_TALKBACK_MAP,
4855	count: 1, buf: &bitmap);
4856	if (err < 0)
4857	return err;
4858	for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)
4859	private->talkback_map[i] = bitmap & 1;
4860	}
4861
4862	return 0;
4863	}
4864
4865	static int scarlett2_speaker_switch_enum_ctl_info(
4866	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
4867	{
4868	static const char *const values[3] = {
4869	"Off", "Main", "Alt"
4870	};
4871
4872	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 3, names: values);
4873	}
4874
4875	static int scarlett2_speaker_switch_enum_ctl_get(
4876	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4877	{
4878	struct usb_mixer_elem_info *elem = kctl->private_data;
4879	struct usb_mixer_interface *mixer = elem->head.mixer;
4880	struct scarlett2_data *private = mixer->private_data;
4881	int err = 0;
4882
4883	mutex_lock(&private->data_mutex);
4884
4885	if (private->hwdep_in_use) {
4886	err = -EBUSY;
4887	goto unlock;
4888	}
4889
4890	if (private->monitor_other_updated) {
4891	err = scarlett2_update_monitor_other(mixer);
4892	if (err < 0)
4893	goto unlock;
4894	}
4895	ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
4896
4897	unlock:
4898	mutex_unlock(lock: &private->data_mutex);
4899	return err;
4900	}
4901
4902	/* when speaker switching gets enabled, switch the main/alt speakers
4903	* to HW volume and disable those controls
4904	*/
4905	static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
4906	{
4907	struct snd_card *card = mixer->chip->card;
4908	struct scarlett2_data *private = mixer->private_data;
4909	int i, err;
4910
4911	for (i = 0; i < 4; i++) {
4912	int index = line_out_remap(private, index: i);
4913
4914	/* switch the main/alt speakers to HW volume */
4915	if (!private->vol_sw_hw_switch[index]) {
4916	err = scarlett2_sw_hw_change(mixer: private->mixer, ctl_index: i, val: 1);
4917	if (err < 0)
4918	return err;
4919	}
4920
4921	/* disable the line out SW/HW switch */
4922	scarlett2_sw_hw_ctl_ro(private, index: i);
4923	snd_ctl_notify(card,
4924	SNDRV_CTL_EVENT_MASK_VALUE |
4925	SNDRV_CTL_EVENT_MASK_INFO,
4926	id: &private->sw_hw_ctls[i]->id);
4927	}
4928
4929	/* when the next monitor-other notify comes in, update the mux
4930	* configuration
4931	*/
4932	private->speaker_switching_switched = 1;
4933
4934	return 0;
4935	}
4936
4937	/* when speaker switching gets disabled, reenable the hw/sw controls
4938	* and invalidate the routing
4939	*/
4940	static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
4941	{
4942	struct snd_card *card = mixer->chip->card;
4943	struct scarlett2_data *private = mixer->private_data;
4944	int i;
4945
4946	/* enable the line out SW/HW switch */
4947	for (i = 0; i < 4; i++) {
4948	scarlett2_sw_hw_ctl_rw(private, index: i);
4949	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
4950	id: &private->sw_hw_ctls[i]->id);
4951	}
4952
4953	/* when the next monitor-other notify comes in, update the mux
4954	* configuration
4955	*/
4956	private->speaker_switching_switched = 1;
4957	}
4958
4959	static int scarlett2_speaker_switch_enum_ctl_put(
4960	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
4961	{
4962	struct usb_mixer_elem_info *elem = kctl->private_data;
4963	struct usb_mixer_interface *mixer = elem->head.mixer;
4964	struct scarlett2_data *private = mixer->private_data;
4965
4966	int oval, val, err = 0;
4967
4968	mutex_lock(&private->data_mutex);
4969
4970	if (private->hwdep_in_use) {
4971	err = -EBUSY;
4972	goto unlock;
4973	}
4974
4975	oval = private->speaker_switching_switch;
4976	val = min(ucontrol->value.enumerated.item[0], 2U);
4977
4978	if (oval == val)
4979	goto unlock;
4980
4981	private->speaker_switching_switch = val;
4982
4983	/* enable/disable speaker switching */
4984	err = scarlett2_usb_set_config(
4985	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
4986	index: 0, value: !!val);
4987	if (err < 0)
4988	goto unlock;
4989
4990	/* if speaker switching is enabled, select main or alt */
4991	err = scarlett2_usb_set_config(
4992	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
4993	index: 0, value: val == 2);
4994	if (err < 0)
4995	goto unlock;
4996
4997	/* update controls if speaker switching gets enabled or disabled */
4998	if (!oval && val)
4999	err = scarlett2_speaker_switch_enable(mixer);
5000	else if (oval && !val)
5001	scarlett2_speaker_switch_disable(mixer);
5002
5003	if (err == 0)
5004	err = 1;
5005
5006	unlock:
5007	mutex_unlock(lock: &private->data_mutex);
5008	return err;
5009	}
5010
5011	static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
5012	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5013	.name = "",
5014	.info = scarlett2_speaker_switch_enum_ctl_info,
5015	.get = scarlett2_speaker_switch_enum_ctl_get,
5016	.put = scarlett2_speaker_switch_enum_ctl_put,
5017	};
5018
5019	static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer)
5020	{
5021	struct scarlett2_data *private = mixer->private_data;
5022	const struct scarlett2_device_info *info = private->info;
5023
5024	if (!info->has_speaker_switching)
5025	return 0;
5026
5027	return scarlett2_add_new_ctl(
5028	mixer, ncontrol: &scarlett2_speaker_switch_enum_ctl,
5029	index: 0, channels: 1, name: "Speaker Switching Playback Enum",
5030	kctl_return: &private->speaker_switching_ctl);
5031	}
5032
5033	/*** Talkback and Talkback Map Controls ***/
5034
5035	static int scarlett2_talkback_enum_ctl_info(
5036	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
5037	{
5038	static const char *const values[3] = {
5039	"Disabled", "Off", "On"
5040	};
5041
5042	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 3, names: values);
5043	}
5044
5045	static int scarlett2_talkback_enum_ctl_get(
5046	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5047	{
5048	struct usb_mixer_elem_info *elem = kctl->private_data;
5049	struct usb_mixer_interface *mixer = elem->head.mixer;
5050	struct scarlett2_data *private = mixer->private_data;
5051	int err = 0;
5052
5053	mutex_lock(&private->data_mutex);
5054
5055	if (private->hwdep_in_use) {
5056	err = -EBUSY;
5057	goto unlock;
5058	}
5059
5060	if (private->monitor_other_updated) {
5061	err = scarlett2_update_monitor_other(mixer);
5062	if (err < 0)
5063	goto unlock;
5064	}
5065	ucontrol->value.enumerated.item[0] = private->talkback_switch;
5066
5067	unlock:
5068	mutex_unlock(lock: &private->data_mutex);
5069	return err;
5070	}
5071
5072	static int scarlett2_talkback_enum_ctl_put(
5073	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5074	{
5075	struct usb_mixer_elem_info *elem = kctl->private_data;
5076	struct usb_mixer_interface *mixer = elem->head.mixer;
5077	struct scarlett2_data *private = mixer->private_data;
5078
5079	int oval, val, err = 0;
5080
5081	mutex_lock(&private->data_mutex);
5082
5083	if (private->hwdep_in_use) {
5084	err = -EBUSY;
5085	goto unlock;
5086	}
5087
5088	oval = private->talkback_switch;
5089	val = min(ucontrol->value.enumerated.item[0], 2U);
5090
5091	if (oval == val)
5092	goto unlock;
5093
5094	private->talkback_switch = val;
5095
5096	/* enable/disable talkback */
5097	err = scarlett2_usb_set_config(
5098	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
5099	index: 1, value: !!val);
5100	if (err < 0)
5101	goto unlock;
5102
5103	/* if talkback is enabled, select main or alt */
5104	err = scarlett2_usb_set_config(
5105	mixer, config_item_num: SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
5106	index: 1, value: val == 2);
5107	if (err == 0)
5108	err = 1;
5109
5110	unlock:
5111	mutex_unlock(lock: &private->data_mutex);
5112	return err;
5113	}
5114
5115	static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
5116	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5117	.name = "",
5118	.info = scarlett2_talkback_enum_ctl_info,
5119	.get = scarlett2_talkback_enum_ctl_get,
5120	.put = scarlett2_talkback_enum_ctl_put,
5121	};
5122
5123	static int scarlett2_talkback_map_ctl_get(
5124	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5125	{
5126	struct usb_mixer_elem_info *elem = kctl->private_data;
5127	struct usb_mixer_interface *mixer = elem->head.mixer;
5128	struct scarlett2_data *private = mixer->private_data;
5129	int index = elem->control;
5130
5131	ucontrol->value.integer.value[0] = private->talkback_map[index];
5132
5133	return 0;
5134	}
5135
5136	static int scarlett2_talkback_map_ctl_put(
5137	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5138	{
5139	struct usb_mixer_elem_info *elem = kctl->private_data;
5140	struct usb_mixer_interface *mixer = elem->head.mixer;
5141	struct scarlett2_data *private = mixer->private_data;
5142	int index = elem->control;
5143	int oval, val, err = 0, i;
5144	u16 bitmap = 0;
5145
5146	mutex_lock(&private->data_mutex);
5147
5148	if (private->hwdep_in_use) {
5149	err = -EBUSY;
5150	goto unlock;
5151	}
5152
5153	oval = private->talkback_map[index];
5154	val = !!ucontrol->value.integer.value[0];
5155
5156	if (oval == val)
5157	goto unlock;
5158
5159	private->talkback_map[index] = val;
5160
5161	for (i = 0; i < private->num_mix_out; i++)
5162	bitmap |= private->talkback_map[i] << i;
5163
5164	/* Send updated bitmap to the device */
5165	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_TALKBACK_MAP,
5166	index: 0, value: bitmap);
5167	if (err == 0)
5168	err = 1;
5169
5170	unlock:
5171	mutex_unlock(lock: &private->data_mutex);
5172	return err;
5173	}
5174
5175	static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
5176	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5177	.name = "",
5178	.info = snd_ctl_boolean_mono_info,
5179	.get = scarlett2_talkback_map_ctl_get,
5180	.put = scarlett2_talkback_map_ctl_put,
5181	};
5182
5183	static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer)
5184	{
5185	struct scarlett2_data *private = mixer->private_data;
5186	const struct scarlett2_device_info *info = private->info;
5187	int err, i;
5188	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
5189
5190	if (!info->has_talkback)
5191	return 0;
5192
5193	err = scarlett2_add_new_ctl(
5194	mixer, ncontrol: &scarlett2_talkback_enum_ctl,
5195	index: 0, channels: 1, name: "Talkback Playback Enum",
5196	kctl_return: &private->talkback_ctl);
5197	if (err < 0)
5198	return err;
5199
5200	for (i = 0; i < private->num_mix_out; i++) {
5201	snprintf(buf: s, size: sizeof(s),
5202	fmt: "Talkback Mix %c Playback Switch", i + 'A');
5203	err = scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_talkback_map_ctl,
5204	index: i, channels: 1, name: s, NULL);
5205	if (err < 0)
5206	return err;
5207	}
5208
5209	return 0;
5210	}
5211
5212	/*** Dim/Mute Controls ***/
5213
5214	static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
5215	struct snd_ctl_elem_value *ucontrol)
5216	{
5217	struct usb_mixer_elem_info *elem = kctl->private_data;
5218	struct usb_mixer_interface *mixer = elem->head.mixer;
5219	struct scarlett2_data *private = mixer->private_data;
5220	int err = 0;
5221
5222	mutex_lock(&private->data_mutex);
5223
5224	if (private->hwdep_in_use) {
5225	err = -EBUSY;
5226	goto unlock;
5227	}
5228
5229	if (private->dim_mute_updated) {
5230	err = scarlett2_update_dim_mute(mixer);
5231	if (err < 0)
5232	goto unlock;
5233	}
5234	ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
5235
5236	unlock:
5237	mutex_unlock(lock: &private->data_mutex);
5238	return err;
5239	}
5240
5241	static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
5242	struct snd_ctl_elem_value *ucontrol)
5243	{
5244	struct usb_mixer_elem_info *elem = kctl->private_data;
5245	struct usb_mixer_interface *mixer = elem->head.mixer;
5246	struct scarlett2_data *private = mixer->private_data;
5247	int index = elem->control;
5248	int oval, val, err = 0, i;
5249
5250	mutex_lock(&private->data_mutex);
5251
5252	if (private->hwdep_in_use) {
5253	err = -EBUSY;
5254	goto unlock;
5255	}
5256
5257	oval = private->dim_mute[index];
5258	val = !!ucontrol->value.integer.value[0];
5259
5260	if (oval == val)
5261	goto unlock;
5262
5263	private->dim_mute[index] = val;
5264
5265	/* Send switch change to the device */
5266	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_DIM_MUTE,
5267	index, value: val);
5268	if (err == 0)
5269	err = 1;
5270
5271	if (index == SCARLETT2_BUTTON_MUTE)
5272	for (i = 0; i < private->num_line_out; i++) {
5273	int line_index = line_out_remap(private, index: i);
5274
5275	if (private->vol_sw_hw_switch[line_index]) {
5276	private->mute_switch[line_index] = val;
5277	snd_ctl_notify(card: mixer->chip->card,
5278	SNDRV_CTL_EVENT_MASK_VALUE,
5279	id: &private->mute_ctls[i]->id);
5280	}
5281	}
5282
5283	unlock:
5284	mutex_unlock(lock: &private->data_mutex);
5285	return err;
5286	}
5287
5288	static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
5289	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5290	.name = "",
5291	.info = snd_ctl_boolean_mono_info,
5292	.get = scarlett2_dim_mute_ctl_get,
5293	.put = scarlett2_dim_mute_ctl_put
5294	};
5295
5296	/*** Create the analogue output controls ***/
5297
5298	static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
5299	{
5300	struct scarlett2_data *private = mixer->private_data;
5301	const struct scarlett2_device_info *info = private->info;
5302	int err, i;
5303	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
5304
5305	/* Add R/O HW volume control */
5306	if (scarlett2_has_config_item(private,
5307	config_item_num: SCARLETT2_CONFIG_MASTER_VOLUME)) {
5308	snprintf(buf: s, size: sizeof(s), fmt: "Master HW Playback Volume");
5309	err = scarlett2_add_new_ctl(mixer,
5310	ncontrol: &scarlett2_master_volume_ctl,
5311	index: 0, channels: 1, name: s, kctl_return: &private->master_vol_ctl);
5312	if (err < 0)
5313	return err;
5314	}
5315
5316	/* Add R/O headphone volume control */
5317	if (scarlett2_has_config_item(private,
5318	config_item_num: SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {
5319	snprintf(buf: s, size: sizeof(s), fmt: "Headphone Playback Volume");
5320	err = scarlett2_add_new_ctl(mixer,
5321	ncontrol: &scarlett2_headphone_volume_ctl,
5322	index: 0, channels: 1, name: s,
5323	kctl_return: &private->headphone_vol_ctl);
5324	if (err < 0)
5325	return err;
5326	}
5327
5328	/* Remaining controls are only applicable if the device
5329	* has per-channel line-out volume controls.
5330	*/
5331	if (!scarlett2_has_config_item(private,
5332	config_item_num: SCARLETT2_CONFIG_LINE_OUT_VOLUME))
5333	return 0;
5334
5335	/* Add volume controls */
5336	for (i = 0; i < private->num_line_out; i++) {
5337	int index = line_out_remap(private, index: i);
5338
5339	/* Fader */
5340	if (info->line_out_descrs[i])
5341	snprintf(buf: s, size: sizeof(s),
5342	fmt: "Line %02d (%s) Playback Volume",
5343	i + 1, info->line_out_descrs[i]);
5344	else
5345	snprintf(buf: s, size: sizeof(s),
5346	fmt: "Line %02d Playback Volume",
5347	i + 1);
5348	err = scarlett2_add_new_ctl(mixer,
5349	ncontrol: &scarlett2_line_out_volume_ctl,
5350	index: i, channels: 1, name: s, kctl_return: &private->vol_ctls[i]);
5351	if (err < 0)
5352	return err;
5353
5354	/* Mute Switch */
5355	snprintf(buf: s, size: sizeof(s),
5356	fmt: "Line %02d Mute Playback Switch",
5357	i + 1);
5358	err = scarlett2_add_new_ctl(mixer,
5359	ncontrol: &scarlett2_mute_ctl,
5360	index: i, channels: 1, name: s,
5361	kctl_return: &private->mute_ctls[i]);
5362	if (err < 0)
5363	return err;
5364
5365	/* SW/HW Switch */
5366	if (scarlett2_has_config_item(private,
5367	config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH)) {
5368
5369	/* Make the fader and mute controls read-only if the
5370	* SW/HW switch is set to HW
5371	*/
5372	if (private->vol_sw_hw_switch[index])
5373	scarlett2_vol_ctl_set_writable(mixer, index: i, value: 0);
5374
5375	scnprintf(buf: s, size: sizeof(s),
5376	fmt: "Line Out %02d Volume Control Playback Enum",
5377	i + 1);
5378	err = scarlett2_add_new_ctl(mixer,
5379	ncontrol: &scarlett2_sw_hw_enum_ctl,
5380	index: i, channels: 1, name: s,
5381	kctl_return: &private->sw_hw_ctls[i]);
5382	if (err < 0)
5383	return err;
5384
5385	/* Make the switch read-only if the line is
5386	* involved in speaker switching
5387	*/
5388	if (private->speaker_switching_switch && i < 4)
5389	scarlett2_sw_hw_ctl_ro(private, index: i);
5390	}
5391	}
5392
5393	/* Add dim/mute controls */
5394	if (scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_DIM_MUTE))
5395	for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
5396	err = scarlett2_add_new_ctl(
5397	mixer, ncontrol: &scarlett2_dim_mute_ctl,
5398	index: i, channels: 1, name: scarlett2_dim_mute_names[i],
5399	kctl_return: &private->dim_mute_ctls[i]);
5400	if (err < 0)
5401	return err;
5402	}
5403
5404	return 0;
5405	}
5406
5407	/*** Create the analogue input controls ***/
5408
5409	static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
5410	{
5411	struct scarlett2_data *private = mixer->private_data;
5412	const struct scarlett2_device_info *info = private->info;
5413	int err, i;
5414	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
5415	const char *fmt = "Line In %d %s Capture %s";
5416	const char *fmt2 = "Line In %d-%d %s Capture %s";
5417
5418	/* Add input level (line/inst) controls */
5419	for (i = 0; i < info->level_input_count; i++) {
5420	scnprintf(buf: s, size: sizeof(s), fmt, i + 1 + info->level_input_first,
5421	"Level", "Enum");
5422	err = scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_level_enum_ctl,
5423	index: i, channels: 1, name: s, kctl_return: &private->level_ctls[i]);
5424	if (err < 0)
5425	return err;
5426	}
5427
5428	/* Add input pad controls */
5429	for (i = 0; i < info->pad_input_count; i++) {
5430	scnprintf(buf: s, size: sizeof(s), fmt, i + 1, "Pad", "Switch");
5431	err = scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_pad_ctl,
5432	index: i, channels: 1, name: s, kctl_return: &private->pad_ctls[i]);
5433	if (err < 0)
5434	return err;
5435	}
5436
5437	/* Add input air controls */
5438	for (i = 0; i < info->air_input_count; i++) {
5439	scnprintf(buf: s, size: sizeof(s), fmt, i + 1 + info->air_input_first,
5440	"Air", info->air_option ? "Enum" : "Switch");
5441	err = scarlett2_add_new_ctl(
5442	mixer, ncontrol: &scarlett2_air_ctl[info->air_option],
5443	index: i, channels: 1, name: s, kctl_return: &private->air_ctls[i]);
5444	if (err < 0)
5445	return err;
5446	}
5447
5448	/* Add input phantom controls */
5449	if (info->inputs_per_phantom == 1) {
5450	for (i = 0; i < info->phantom_count; i++) {
5451	scnprintf(buf: s, size: sizeof(s), fmt,
5452	i + 1 + info->phantom_first,
5453	"Phantom Power", "Switch");
5454	err = scarlett2_add_new_ctl(
5455	mixer, ncontrol: &scarlett2_phantom_ctl,
5456	index: i, channels: 1, name: s, kctl_return: &private->phantom_ctls[i]);
5457	if (err < 0)
5458	return err;
5459	}
5460	} else if (info->inputs_per_phantom > 1) {
5461	for (i = 0; i < info->phantom_count; i++) {
5462	int from = i * info->inputs_per_phantom + 1;
5463	int to = (i + 1) * info->inputs_per_phantom;
5464
5465	scnprintf(buf: s, size: sizeof(s), fmt: fmt2, from, to,
5466	"Phantom Power", "Switch");
5467	err = scarlett2_add_new_ctl(
5468	mixer, ncontrol: &scarlett2_phantom_ctl,
5469	index: i, channels: 1, name: s, kctl_return: &private->phantom_ctls[i]);
5470	if (err < 0)
5471	return err;
5472	}
5473	}
5474	if (info->phantom_count &&
5475	scarlett2_has_config_item(private,
5476	config_item_num: SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {
5477	err = scarlett2_add_new_ctl(
5478	mixer, ncontrol: &scarlett2_phantom_persistence_ctl, index: 0, channels: 1,
5479	name: "Phantom Power Persistence Capture Switch", NULL);
5480	if (err < 0)
5481	return err;
5482	}
5483
5484	/* Add software-controllable input gain controls */
5485	if (info->gain_input_count) {
5486	err = scarlett2_add_new_ctl(
5487	mixer, ncontrol: &scarlett2_input_select_ctl, index: 0, channels: 1,
5488	name: "Input Select Capture Enum",
5489	kctl_return: &private->input_select_ctl);
5490	if (err < 0)
5491	return err;
5492
5493	for (i = 0; i < info->gain_input_count; i++) {
5494	if (i % 2) {
5495	scnprintf(buf: s, size: sizeof(s),
5496	fmt: "Line In %d-%d Link Capture Switch",
5497	i, i + 1);
5498	err = scarlett2_add_new_ctl(
5499	mixer, ncontrol: &scarlett2_input_link_ctl,
5500	index: i / 2, channels: 1, name: s,
5501	kctl_return: &private->input_link_ctls[i / 2]);
5502	if (err < 0)
5503	return err;
5504	}
5505
5506	scnprintf(buf: s, size: sizeof(s), fmt, i + 1,
5507	"Gain", "Volume");
5508	err = scarlett2_add_new_ctl(
5509	mixer, ncontrol: &scarlett2_input_gain_ctl,
5510	index: i, channels: 1, name: s, kctl_return: &private->input_gain_ctls[i]);
5511	if (err < 0)
5512	return err;
5513
5514	scnprintf(buf: s, size: sizeof(s), fmt, i + 1,
5515	"Autogain", "Switch");
5516	err = scarlett2_add_new_ctl(
5517	mixer, ncontrol: &scarlett2_autogain_switch_ctl,
5518	index: i, channels: 1, name: s, kctl_return: &private->autogain_ctls[i]);
5519	if (err < 0)
5520	return err;
5521
5522	scnprintf(buf: s, size: sizeof(s), fmt, i + 1,
5523	"Autogain Status", "Enum");
5524	err = scarlett2_add_new_ctl(
5525	mixer, ncontrol: &scarlett2_autogain_status_ctl,
5526	index: i, channels: 1, name: s, kctl_return: &private->autogain_status_ctls[i]);
5527
5528	scnprintf(buf: s, size: sizeof(s), fmt, i + 1,
5529	"Safe", "Switch");
5530	err = scarlett2_add_new_ctl(
5531	mixer, ncontrol: &scarlett2_safe_ctl,
5532	index: i, channels: 1, name: s, kctl_return: &private->safe_ctls[i]);
5533	if (err < 0)
5534	return err;
5535	}
5536	}
5537
5538	/* Add PCM Input Switch control */
5539	if (scarlett2_has_config_item(private,
5540	config_item_num: SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {
5541	err = scarlett2_add_new_ctl(
5542	mixer, ncontrol: &scarlett2_pcm_input_switch_ctl, index: 0, channels: 1,
5543	name: "PCM Input Capture Switch",
5544	kctl_return: &private->pcm_input_switch_ctl);
5545	if (err < 0)
5546	return err;
5547	}
5548
5549	return 0;
5550	}
5551
5552	/*** Mixer Volume Controls ***/
5553
5554	static int scarlett2_update_mix(struct usb_mixer_interface *mixer)
5555	{
5556	struct scarlett2_data *private = mixer->private_data;
5557	int i, err;
5558
5559	private->mix_updated = 0;
5560
5561	for (i = 0; i < private->num_mix_out; i++) {
5562	err = scarlett2_usb_get_mix(mixer, mix_num: i);
5563	if (err < 0)
5564	return err;
5565	}
5566
5567	return 1;
5568	}
5569
5570	static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
5571	struct snd_ctl_elem_info *uinfo)
5572	{
5573	struct usb_mixer_elem_info *elem = kctl->private_data;
5574
5575	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
5576	uinfo->count = elem->channels;
5577	uinfo->value.integer.min = 0;
5578	uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
5579	uinfo->value.integer.step = 1;
5580	return 0;
5581	}
5582
5583	static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
5584	struct snd_ctl_elem_value *ucontrol)
5585	{
5586	struct usb_mixer_elem_info *elem = kctl->private_data;
5587	struct usb_mixer_interface *mixer = elem->head.mixer;
5588	struct scarlett2_data *private = mixer->private_data;
5589	int err = 0;
5590
5591	mutex_lock(&private->data_mutex);
5592
5593	if (private->hwdep_in_use) {
5594	err = -EBUSY;
5595	goto unlock;
5596	}
5597
5598	if (private->mix_updated) {
5599	err = scarlett2_update_mix(mixer);
5600	if (err < 0)
5601	goto unlock;
5602	}
5603	ucontrol->value.integer.value[0] = private->mix[elem->control];
5604
5605	unlock:
5606	mutex_unlock(lock: &private->data_mutex);
5607	return err;
5608	}
5609
5610	static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
5611	struct snd_ctl_elem_value *ucontrol)
5612	{
5613	struct usb_mixer_elem_info *elem = kctl->private_data;
5614	struct usb_mixer_interface *mixer = elem->head.mixer;
5615	struct scarlett2_data *private = mixer->private_data;
5616	int oval, val, mix_num, err = 0;
5617	int index = elem->control;
5618
5619	mutex_lock(&private->data_mutex);
5620
5621	if (private->hwdep_in_use) {
5622	err = -EBUSY;
5623	goto unlock;
5624	}
5625
5626	oval = private->mix[index];
5627	val = clamp(ucontrol->value.integer.value[0],
5628	0L, (long)SCARLETT2_MIXER_MAX_VALUE);
5629	mix_num = index / private->num_mix_in;
5630
5631	if (oval == val)
5632	goto unlock;
5633
5634	private->mix[index] = val;
5635	err = scarlett2_usb_set_mix(mixer, mix_num);
5636	if (err == 0)
5637	err = 1;
5638
5639	unlock:
5640	mutex_unlock(lock: &private->data_mutex);
5641	return err;
5642	}
5643
5644	static const DECLARE_TLV_DB_MINMAX(
5645	db_scale_scarlett2_mixer,
5646	SCARLETT2_MIXER_MIN_DB * 100,
5647	SCARLETT2_MIXER_MAX_DB * 100
5648	);
5649
5650	static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
5651	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5652	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
5653	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
5654	.name = "",
5655	.info = scarlett2_mixer_ctl_info,
5656	.get = scarlett2_mixer_ctl_get,
5657	.put = scarlett2_mixer_ctl_put,
5658	.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
5659	.tlv = { .p = db_scale_scarlett2_mixer }
5660	};
5661
5662	static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
5663	{
5664	struct scarlett2_data *private = mixer->private_data;
5665	int err, i, j;
5666	int index;
5667	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
5668
5669	for (i = 0, index = 0; i < private->num_mix_out; i++)
5670	for (j = 0; j < private->num_mix_in; j++, index++) {
5671	snprintf(buf: s, size: sizeof(s),
5672	fmt: "Mix %c Input %02d Playback Volume",
5673	'A' + i, j + 1);
5674	err = scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_mixer_ctl,
5675	index, channels: 1, name: s,
5676	kctl_return: &private->mix_ctls[index]);
5677	if (err < 0)
5678	return err;
5679	}
5680
5681	return 0;
5682	}
5683
5684	/*** Direct Monitor Control ***/
5685
5686	static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)
5687	{
5688	struct scarlett2_data *private = mixer->private_data;
5689
5690	private->direct_monitor_updated = 0;
5691
5692	if (!private->info->direct_monitor)
5693	return 0;
5694
5695	return scarlett2_usb_get_config(
5696	mixer, config_item_num: SCARLETT2_CONFIG_DIRECT_MONITOR,
5697	count: 1, buf: &private->direct_monitor_switch);
5698	}
5699
5700	static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)
5701	{
5702	struct scarlett2_data *private = mixer->private_data;
5703	int err, i;
5704	u16 mix_values[SCARLETT2_MONITOR_MIX_MAX];
5705
5706	if (!private->num_monitor_mix_ctls)
5707	return 0;
5708
5709	err = scarlett2_usb_get_config(
5710	mixer, config_item_num: SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
5711	count: private->num_monitor_mix_ctls, buf: mix_values);
5712	if (err < 0)
5713	return err;
5714
5715	for (i = 0; i < private->num_monitor_mix_ctls; i++)
5716	private->monitor_mix[i] = scarlett2_mixer_value_to_db(
5717	value: mix_values[i]);
5718
5719	return 0;
5720	}
5721
5722	static int scarlett2_direct_monitor_ctl_get(
5723	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5724	{
5725	struct usb_mixer_elem_info *elem = kctl->private_data;
5726	struct usb_mixer_interface *mixer = elem->head.mixer;
5727	struct scarlett2_data *private = mixer->private_data;
5728	int err = 0;
5729
5730	mutex_lock(&private->data_mutex);
5731
5732	if (private->hwdep_in_use) {
5733	err = -EBUSY;
5734	goto unlock;
5735	}
5736
5737	if (private->direct_monitor_updated) {
5738	err = scarlett2_update_direct_monitor(mixer);
5739	if (err < 0)
5740	goto unlock;
5741	}
5742	ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
5743
5744	unlock:
5745	mutex_unlock(lock: &private->data_mutex);
5746	return err;
5747	}
5748
5749	static int scarlett2_direct_monitor_ctl_put(
5750	struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
5751	{
5752	struct usb_mixer_elem_info *elem = kctl->private_data;
5753	struct usb_mixer_interface *mixer = elem->head.mixer;
5754	struct scarlett2_data *private = mixer->private_data;
5755
5756	int index = elem->control;
5757	int oval, val, err = 0;
5758
5759	mutex_lock(&private->data_mutex);
5760
5761	if (private->hwdep_in_use) {
5762	err = -EBUSY;
5763	goto unlock;
5764	}
5765
5766	oval = private->direct_monitor_switch;
5767	val = min(ucontrol->value.enumerated.item[0], 2U);
5768
5769	if (oval == val)
5770	goto unlock;
5771
5772	private->direct_monitor_switch = val;
5773
5774	/* Send switch change to the device */
5775	err = scarlett2_usb_set_config(
5776	mixer, config_item_num: SCARLETT2_CONFIG_DIRECT_MONITOR, index, value: val);
5777	if (err == 0)
5778	err = 1;
5779
5780	unlock:
5781	mutex_unlock(lock: &private->data_mutex);
5782	return err;
5783	}
5784
5785	static int scarlett2_direct_monitor_stereo_enum_ctl_info(
5786	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
5787	{
5788	static const char *const values[3] = {
5789	"Off", "Mono", "Stereo"
5790	};
5791
5792	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 3, names: values);
5793	}
5794
5795	/* Direct Monitor for Solo is mono-only and only needs a boolean control
5796	* Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
5797	*/
5798	static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
5799	{
5800	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5801	.name = "",
5802	.info = snd_ctl_boolean_mono_info,
5803	.get = scarlett2_direct_monitor_ctl_get,
5804	.put = scarlett2_direct_monitor_ctl_put,
5805	},
5806	{
5807	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5808	.name = "",
5809	.info = scarlett2_direct_monitor_stereo_enum_ctl_info,
5810	.get = scarlett2_direct_monitor_ctl_get,
5811	.put = scarlett2_direct_monitor_ctl_put,
5812	}
5813	};
5814
5815	static int scarlett2_monitor_mix_ctl_get(struct snd_kcontrol *kctl,
5816	struct snd_ctl_elem_value *ucontrol)
5817	{
5818	struct usb_mixer_elem_info *elem = kctl->private_data;
5819	struct scarlett2_data *private = elem->head.mixer->private_data;
5820
5821	ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];
5822
5823	return 0;
5824	}
5825
5826	static int scarlett2_monitor_mix_ctl_put(struct snd_kcontrol *kctl,
5827	struct snd_ctl_elem_value *ucontrol)
5828	{
5829	struct usb_mixer_elem_info *elem = kctl->private_data;
5830	struct usb_mixer_interface *mixer = elem->head.mixer;
5831	struct scarlett2_data *private = mixer->private_data;
5832	int oval, val, err = 0;
5833	int index = elem->control;
5834
5835	mutex_lock(&private->data_mutex);
5836
5837	if (private->hwdep_in_use) {
5838	err = -EBUSY;
5839	goto unlock;
5840	}
5841
5842	oval = private->monitor_mix[index];
5843	val = clamp(ucontrol->value.integer.value[0],
5844	0L, (long)SCARLETT2_MIXER_MAX_VALUE);
5845
5846	if (oval == val)
5847	goto unlock;
5848
5849	private->monitor_mix[index] = val;
5850	err = scarlett2_usb_set_config(
5851	mixer, config_item_num: SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
5852	index, value: scarlett2_mixer_values[val]);
5853	if (err == 0)
5854	err = 1;
5855
5856	unlock:
5857	mutex_unlock(lock: &private->data_mutex);
5858	return err;
5859	}
5860
5861	static const struct snd_kcontrol_new scarlett2_monitor_mix_ctl = {
5862	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5863	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
5864	SNDRV_CTL_ELEM_ACCESS_TLV_READ,
5865	.name = "",
5866	.info = scarlett2_mixer_ctl_info,
5867	.get = scarlett2_monitor_mix_ctl_get,
5868	.put = scarlett2_monitor_mix_ctl_put,
5869	.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
5870	.tlv = { .p = db_scale_scarlett2_mixer }
5871	};
5872
5873	static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer)
5874	{
5875	struct scarlett2_data *private = mixer->private_data;
5876	const struct scarlett2_device_info *info = private->info;
5877	const char *s;
5878	int err, i, j, k, index;
5879
5880	if (!info->direct_monitor)
5881	return 0;
5882
5883	s = info->direct_monitor == 1
5884	? "Direct Monitor Playback Switch"
5885	: "Direct Monitor Playback Enum";
5886
5887	err = scarlett2_add_new_ctl(
5888	mixer, ncontrol: &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
5889	index: 0, channels: 1, name: s, kctl_return: &private->direct_monitor_ctl);
5890	if (err < 0)
5891	return err;
5892
5893	if (!private->num_monitor_mix_ctls)
5894	return 0;
5895
5896	/* 1 or 2 direct monitor selections (Mono & Stereo) */
5897	for (i = 0, index = 0; i < info->direct_monitor; i++) {
5898	const char * const format =
5899	"Monitor %sMix %c Input %02d Playback Volume";
5900	const char *mix_type;
5901
5902	if (info->direct_monitor == 1)
5903	mix_type = "";
5904	else if (i == 0)
5905	mix_type = "1 ";
5906	else
5907	mix_type = "2 ";
5908
5909	/* 2 Mix outputs, A/Left & B/Right */
5910	for (j = 0; j < 2; j++)
5911
5912	/* Mix inputs */
5913	for (k = 0; k < private->num_mix_in; k++, index++) {
5914	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
5915
5916	scnprintf(buf: name, size: sizeof(name), fmt: format,
5917	mix_type, 'A' + j, k + 1);
5918
5919	err = scarlett2_add_new_ctl(
5920	mixer, ncontrol: &scarlett2_monitor_mix_ctl,
5921	index, channels: 1, name, NULL);
5922	if (err < 0)
5923	return err;
5924	}
5925	}
5926
5927	return 0;
5928	}
5929
5930	/*** Mux Source Selection Controls ***/
5931
5932	static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
5933	struct snd_ctl_elem_info *uinfo)
5934	{
5935	struct usb_mixer_elem_info *elem = kctl->private_data;
5936	struct scarlett2_data *private = elem->head.mixer->private_data;
5937	const struct scarlett2_device_info *info = private->info;
5938	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
5939	unsigned int item = uinfo->value.enumerated.item;
5940	int items = private->num_mux_srcs;
5941	int port_type;
5942
5943	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
5944	uinfo->count = elem->channels;
5945	uinfo->value.enumerated.items = items;
5946
5947	if (item >= items)
5948	item = uinfo->value.enumerated.item = items - 1;
5949
5950	for (port_type = 0;
5951	port_type < SCARLETT2_PORT_TYPE_COUNT;
5952	port_type++) {
5953	if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
5954	const struct scarlett2_port *port =
5955	&scarlett2_ports[port_type];
5956
5957	if (port_type == SCARLETT2_PORT_TYPE_MIX &&
5958	item >= private->num_mix_out)
5959	sprintf(buf: uinfo->value.enumerated.name,
5960	fmt: port->dsp_src_descr,
5961	item - private->num_mix_out + 1);
5962	else
5963	sprintf(buf: uinfo->value.enumerated.name,
5964	fmt: port->src_descr,
5965	item + port->src_num_offset);
5966
5967	return 0;
5968	}
5969	item -= port_count[port_type][SCARLETT2_PORT_IN];
5970	}
5971
5972	return -EINVAL;
5973	}
5974
5975	static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
5976	struct snd_ctl_elem_value *ucontrol)
5977	{
5978	struct usb_mixer_elem_info *elem = kctl->private_data;
5979	struct usb_mixer_interface *mixer = elem->head.mixer;
5980	struct scarlett2_data *private = mixer->private_data;
5981	int index = line_out_remap(private, index: elem->control);
5982	int err = 0;
5983
5984	mutex_lock(&private->data_mutex);
5985
5986	if (private->hwdep_in_use) {
5987	err = -EBUSY;
5988	goto unlock;
5989	}
5990
5991	if (private->mux_updated) {
5992	err = scarlett2_usb_get_mux(mixer);
5993	if (err < 0)
5994	goto unlock;
5995	}
5996	ucontrol->value.enumerated.item[0] = private->mux[index];
5997
5998	unlock:
5999	mutex_unlock(lock: &private->data_mutex);
6000	return err;
6001	}
6002
6003	static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
6004	struct snd_ctl_elem_value *ucontrol)
6005	{
6006	struct usb_mixer_elem_info *elem = kctl->private_data;
6007	struct usb_mixer_interface *mixer = elem->head.mixer;
6008	struct scarlett2_data *private = mixer->private_data;
6009	int index = line_out_remap(private, index: elem->control);
6010	int oval, val, err = 0;
6011
6012	mutex_lock(&private->data_mutex);
6013
6014	if (private->hwdep_in_use) {
6015	err = -EBUSY;
6016	goto unlock;
6017	}
6018
6019	oval = private->mux[index];
6020	val = min(ucontrol->value.enumerated.item[0],
6021	private->num_mux_srcs - 1U);
6022
6023	if (oval == val)
6024	goto unlock;
6025
6026	private->mux[index] = val;
6027	err = scarlett2_usb_set_mux(mixer);
6028	if (err == 0)
6029	err = 1;
6030
6031	unlock:
6032	mutex_unlock(lock: &private->data_mutex);
6033	return err;
6034	}
6035
6036	static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
6037	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6038	.name = "",
6039	.info = scarlett2_mux_src_enum_ctl_info,
6040	.get = scarlett2_mux_src_enum_ctl_get,
6041	.put = scarlett2_mux_src_enum_ctl_put,
6042	};
6043
6044	static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
6045	{
6046	struct scarlett2_data *private = mixer->private_data;
6047	const struct scarlett2_device_info *info = private->info;
6048	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
6049	int port_type, channel, i;
6050
6051	for (i = 0, port_type = 0;
6052	port_type < SCARLETT2_PORT_TYPE_COUNT;
6053	port_type++) {
6054	for (channel = 0;
6055	channel < port_count[port_type][SCARLETT2_PORT_OUT];
6056	channel++, i++) {
6057	int err;
6058	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
6059	int channel_num = channel + 1;
6060	const struct scarlett2_port *port =
6061	&scarlett2_ports[port_type];
6062	const char *descr = port->dst_descr;
6063
6064	if (port_type == SCARLETT2_PORT_TYPE_MIX &&
6065	channel >= private->num_mix_in) {
6066	channel_num -= private->num_mix_in;
6067	descr = port->dsp_dst_descr;
6068	}
6069
6070	snprintf(buf: s, size: sizeof(s) - 5, fmt: descr, channel_num);
6071	strcat(p: s, q: " Enum");
6072
6073	err = scarlett2_add_new_ctl(mixer,
6074	ncontrol: &scarlett2_mux_src_enum_ctl,
6075	index: i, channels: 1, name: s,
6076	kctl_return: &private->mux_ctls[i]);
6077	if (err < 0)
6078	return err;
6079	}
6080	}
6081
6082	return 0;
6083	}
6084
6085	/*** Meter Controls ***/
6086
6087	static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
6088	struct snd_ctl_elem_info *uinfo)
6089	{
6090	struct usb_mixer_elem_info *elem = kctl->private_data;
6091
6092	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
6093	uinfo->count = elem->channels;
6094	uinfo->value.integer.min = 0;
6095	uinfo->value.integer.max = 4095;
6096	uinfo->value.integer.step = 1;
6097	return 0;
6098	}
6099
6100	static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
6101	struct snd_ctl_elem_value *ucontrol)
6102	{
6103	struct usb_mixer_elem_info *elem = kctl->private_data;
6104	struct usb_mixer_interface *mixer = elem->head.mixer;
6105	struct scarlett2_data *private = mixer->private_data;
6106	u8 *meter_level_map = private->meter_level_map;
6107	u16 meter_levels[SCARLETT2_MAX_METERS];
6108	int i, err;
6109
6110	mutex_lock(&private->data_mutex);
6111
6112	if (private->hwdep_in_use) {
6113	err = -EBUSY;
6114	goto unlock;
6115	}
6116
6117	err = scarlett2_usb_get_meter_levels(mixer, num_meters: elem->channels,
6118	levels: meter_levels);
6119	if (err < 0)
6120	goto unlock;
6121
6122	/* copy & translate from meter_levels[] using meter_level_map[] */
6123	for (i = 0; i < elem->channels; i++) {
6124	int idx = meter_level_map[i];
6125	int value;
6126
6127	if (idx == 255)
6128	value = 0;
6129	else
6130	value = meter_levels[idx];
6131
6132	ucontrol->value.integer.value[i] = value;
6133	}
6134
6135	unlock:
6136	mutex_unlock(lock: &private->data_mutex);
6137
6138	return err;
6139	}
6140
6141	static const struct snd_kcontrol_new scarlett2_meter_ctl = {
6142	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
6143	.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
6144	.name = "",
6145	.info = scarlett2_meter_ctl_info,
6146	.get = scarlett2_meter_ctl_get
6147	};
6148
6149	static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
6150	{
6151	struct scarlett2_data *private = mixer->private_data;
6152
6153	/* devices without a mixer also don't support reporting levels */
6154	if (!scarlett2_has_mixer(private))
6155	return 0;
6156
6157	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_meter_ctl,
6158	index: 0, channels: private->num_mux_dsts,
6159	name: "Level Meter", NULL);
6160	}
6161
6162	/*** MSD Controls ***/
6163
6164	static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
6165	struct snd_ctl_elem_value *ucontrol)
6166	{
6167	struct usb_mixer_elem_info *elem = kctl->private_data;
6168	struct scarlett2_data *private = elem->head.mixer->private_data;
6169
6170	ucontrol->value.integer.value[0] = private->msd_switch;
6171	return 0;
6172	}
6173
6174	static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
6175	struct snd_ctl_elem_value *ucontrol)
6176	{
6177	struct usb_mixer_elem_info *elem = kctl->private_data;
6178	struct usb_mixer_interface *mixer = elem->head.mixer;
6179	struct scarlett2_data *private = mixer->private_data;
6180
6181	int oval, val, err = 0;
6182
6183	mutex_lock(&private->data_mutex);
6184
6185	if (private->hwdep_in_use) {
6186	err = -EBUSY;
6187	goto unlock;
6188	}
6189
6190	oval = private->msd_switch;
6191	val = !!ucontrol->value.integer.value[0];
6192
6193	if (oval == val)
6194	goto unlock;
6195
6196	private->msd_switch = val;
6197
6198	/* Send switch change to the device */
6199	err = scarlett2_usb_set_config(mixer, config_item_num: SCARLETT2_CONFIG_MSD_SWITCH,
6200	index: 0, value: val);
6201	if (err == 0)
6202	err = 1;
6203
6204	unlock:
6205	mutex_unlock(lock: &private->data_mutex);
6206	return err;
6207	}
6208
6209	static const struct snd_kcontrol_new scarlett2_msd_ctl = {
6210	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6211	.name = "",
6212	.info = snd_ctl_boolean_mono_info,
6213	.get = scarlett2_msd_ctl_get,
6214	.put = scarlett2_msd_ctl_put,
6215	};
6216
6217	static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
6218	{
6219	struct scarlett2_data *private = mixer->private_data;
6220
6221	if (!scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_MSD_SWITCH))
6222	return 0;
6223
6224	/* If MSD mode is off, hide the switch by default */
6225	if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
6226	return 0;
6227
6228	/* Add MSD control */
6229	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_msd_ctl,
6230	index: 0, channels: 1, name: "MSD Mode Switch", NULL);
6231	}
6232
6233	/*** Standalone Control ***/
6234
6235	static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,
6236	struct snd_ctl_elem_value *ucontrol)
6237	{
6238	struct usb_mixer_elem_info *elem = kctl->private_data;
6239	struct scarlett2_data *private = elem->head.mixer->private_data;
6240
6241	ucontrol->value.integer.value[0] = private->standalone_switch;
6242	return 0;
6243	}
6244
6245	static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,
6246	struct snd_ctl_elem_value *ucontrol)
6247	{
6248	struct usb_mixer_elem_info *elem = kctl->private_data;
6249	struct usb_mixer_interface *mixer = elem->head.mixer;
6250	struct scarlett2_data *private = mixer->private_data;
6251
6252	int oval, val, err = 0;
6253
6254	mutex_lock(&private->data_mutex);
6255
6256	if (private->hwdep_in_use) {
6257	err = -EBUSY;
6258	goto unlock;
6259	}
6260
6261	oval = private->standalone_switch;
6262	val = !!ucontrol->value.integer.value[0];
6263
6264	if (oval == val)
6265	goto unlock;
6266
6267	private->standalone_switch = val;
6268
6269	/* Send switch change to the device */
6270	err = scarlett2_usb_set_config(mixer,
6271	config_item_num: SCARLETT2_CONFIG_STANDALONE_SWITCH,
6272	index: 0, value: val);
6273	if (err == 0)
6274	err = 1;
6275
6276	unlock:
6277	mutex_unlock(lock: &private->data_mutex);
6278	return err;
6279	}
6280
6281	static const struct snd_kcontrol_new scarlett2_standalone_ctl = {
6282	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6283	.name = "",
6284	.info = snd_ctl_boolean_mono_info,
6285	.get = scarlett2_standalone_ctl_get,
6286	.put = scarlett2_standalone_ctl_put,
6287	};
6288
6289	static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
6290	{
6291	struct scarlett2_data *private = mixer->private_data;
6292
6293	if (!scarlett2_has_config_item(private,
6294	config_item_num: SCARLETT2_CONFIG_STANDALONE_SWITCH))
6295	return 0;
6296
6297	/* Add standalone control */
6298	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_standalone_ctl,
6299	index: 0, channels: 1, name: "Standalone Switch", NULL);
6300	}
6301
6302	/*** Power Status ***/
6303
6304	static int scarlett2_update_power_status(struct usb_mixer_interface *mixer)
6305	{
6306	struct scarlett2_data *private = mixer->private_data;
6307	int err;
6308	u8 power_ext, power_low;
6309
6310	private->power_status_updated = 0;
6311
6312	err = scarlett2_usb_get_config(mixer, config_item_num: SCARLETT2_CONFIG_POWER_EXT,
6313	count: 1, buf: &power_ext);
6314	if (err < 0)
6315	return err;
6316
6317	err = scarlett2_usb_get_config(mixer, config_item_num: SCARLETT2_CONFIG_POWER_LOW,
6318	count: 1, buf: &power_low);
6319	if (err < 0)
6320	return err;
6321
6322	if (power_low)
6323	private->power_status = SCARLETT2_POWER_STATUS_FAIL;
6324	else if (power_ext)
6325	private->power_status = SCARLETT2_POWER_STATUS_EXT;
6326	else
6327	private->power_status = SCARLETT2_POWER_STATUS_BUS;
6328
6329	return 0;
6330	}
6331
6332	static int scarlett2_power_status_ctl_get(struct snd_kcontrol *kctl,
6333	struct snd_ctl_elem_value *ucontrol)
6334	{
6335	struct usb_mixer_elem_info *elem = kctl->private_data;
6336	struct usb_mixer_interface *mixer = elem->head.mixer;
6337	struct scarlett2_data *private = mixer->private_data;
6338	int err = 0;
6339
6340	mutex_lock(&private->data_mutex);
6341
6342	if (private->power_status_updated) {
6343	err = scarlett2_update_power_status(mixer);
6344	if (err < 0)
6345	goto unlock;
6346	}
6347	ucontrol->value.integer.value[0] = private->power_status;
6348
6349	unlock:
6350	mutex_unlock(lock: &private->data_mutex);
6351	return err;
6352	}
6353
6354	static int scarlett2_power_status_ctl_info(
6355	struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
6356	{
6357	static const char *const values[3] = {
6358	"External", "Bus", "Fail"
6359	};
6360
6361	return snd_ctl_enum_info(info: uinfo, channels: 1, items: 3, names: values);
6362	}
6363
6364	static const struct snd_kcontrol_new scarlett2_power_status_ctl = {
6365	.iface = SNDRV_CTL_ELEM_IFACE_CARD,
6366	.access = SNDRV_CTL_ELEM_ACCESS_READ,
6367	.name = "",
6368	.info = scarlett2_power_status_ctl_info,
6369	.get = scarlett2_power_status_ctl_get,
6370	};
6371
6372	static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer)
6373	{
6374	struct scarlett2_data *private = mixer->private_data;
6375
6376	if (!scarlett2_has_config_item(private,
6377	config_item_num: SCARLETT2_CONFIG_POWER_EXT))
6378	return 0;
6379
6380	/* Add power status control */
6381	return scarlett2_add_new_ctl(mixer, ncontrol: &scarlett2_power_status_ctl,
6382	index: 0, channels: 1, name: "Power Status Card Enum",
6383	kctl_return: &private->power_status_ctl);
6384	}
6385
6386	/*** Cleanup/Suspend Callbacks ***/
6387
6388	static void scarlett2_private_free(struct usb_mixer_interface *mixer)
6389	{
6390	struct scarlett2_data *private = mixer->private_data;
6391
6392	cancel_delayed_work_sync(dwork: &private->work);
6393	kfree(objp: private);
6394	mixer->private_data = NULL;
6395	}
6396
6397	static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
6398	{
6399	struct scarlett2_data *private = mixer->private_data;
6400
6401	if (cancel_delayed_work_sync(dwork: &private->work))
6402	scarlett2_config_save(mixer: private->mixer);
6403	}
6404
6405	/*** Initialisation ***/
6406
6407	static void scarlett2_count_io(struct scarlett2_data *private)
6408	{
6409	const struct scarlett2_device_info *info = private->info;
6410	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
6411	int port_type, srcs = 0, dsts = 0;
6412
6413	/* Count the number of mux sources and destinations */
6414	for (port_type = 0;
6415	port_type < SCARLETT2_PORT_TYPE_COUNT;
6416	port_type++) {
6417	srcs += port_count[port_type][SCARLETT2_PORT_IN];
6418	dsts += port_count[port_type][SCARLETT2_PORT_OUT];
6419	}
6420
6421	private->num_mux_srcs = srcs;
6422	private->num_mux_dsts = dsts;
6423
6424	/* Mixer inputs are mux outputs and vice versa.
6425	* Scarlett Gen 4 DSP I/O uses SCARLETT2_PORT_TYPE_MIX but
6426	* doesn't have mixer controls.
6427	*/
6428	private->num_mix_in =
6429	port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -
6430	info->dsp_count;
6431
6432	private->num_mix_out =
6433	port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -
6434	info->dsp_count;
6435
6436	/* Number of analogue line outputs */
6437	private->num_line_out =
6438	port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
6439
6440	/* Number of monitor mix controls */
6441	private->num_monitor_mix_ctls =
6442	info->direct_monitor * 2 * private->num_mix_in;
6443	}
6444
6445	/* Look through the interface descriptors for the Focusrite Control
6446	* interface (bInterfaceClass = 255 Vendor Specific Class) and set
6447	* bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
6448	* in private
6449	*/
6450	static int scarlett2_find_fc_interface(struct usb_device *dev,
6451	struct scarlett2_data *private)
6452	{
6453	struct usb_host_config *config = dev->actconfig;
6454	int i;
6455
6456	for (i = 0; i < config->desc.bNumInterfaces; i++) {
6457	struct usb_interface *intf = config->interface[i];
6458	struct usb_interface_descriptor *desc =
6459	&intf->altsetting[0].desc;
6460	struct usb_endpoint_descriptor *epd;
6461
6462	if (desc->bInterfaceClass != 255)
6463	continue;
6464
6465	epd = get_endpoint(intf->altsetting, 0);
6466	private->bInterfaceNumber = desc->bInterfaceNumber;
6467	private->bEndpointAddress = epd->bEndpointAddress &
6468	USB_ENDPOINT_NUMBER_MASK;
6469	private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
6470	private->bInterval = epd->bInterval;
6471	return 0;
6472	}
6473
6474	return -EINVAL;
6475	}
6476
6477	/* Initialise private data */
6478	static int scarlett2_init_private(struct usb_mixer_interface *mixer,
6479	const struct scarlett2_device_entry *entry)
6480	{
6481	struct scarlett2_data *private =
6482	kzalloc(size: sizeof(struct scarlett2_data), GFP_KERNEL);
6483
6484	if (!private)
6485	return -ENOMEM;
6486
6487	mutex_init(&private->usb_mutex);
6488	mutex_init(&private->data_mutex);
6489	INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
6490
6491	mixer->private_data = private;
6492	mixer->private_free = scarlett2_private_free;
6493	mixer->private_suspend = scarlett2_private_suspend;
6494
6495	private->info = entry->info;
6496	private->config_set = entry->info->config_set;
6497	private->series_name = entry->series_name;
6498	scarlett2_count_io(private);
6499	private->scarlett2_seq = 0;
6500	private->mixer = mixer;
6501
6502	return scarlett2_find_fc_interface(dev: mixer->chip->dev, private);
6503	}
6504
6505	/* Cargo cult proprietary initialisation sequence */
6506	static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
6507	{
6508	struct usb_device *dev = mixer->chip->dev;
6509	struct scarlett2_data *private = mixer->private_data;
6510	u8 step0_buf[24];
6511	u8 step2_buf[84];
6512	int err;
6513
6514	if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
6515	return -EINVAL;
6516
6517	/* step 0 */
6518	err = scarlett2_usb_rx(dev, interface: private->bInterfaceNumber,
6519	SCARLETT2_USB_CMD_INIT,
6520	buf: step0_buf, size: sizeof(step0_buf));
6521	if (err < 0)
6522	return err;
6523
6524	/* step 1 */
6525	private->scarlett2_seq = 1;
6526	err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, req_size: 0, NULL, resp_size: 0);
6527	if (err < 0)
6528	return err;
6529
6530	/* step 2 */
6531	private->scarlett2_seq = 1;
6532	err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,
6533	NULL, req_size: 0,
6534	resp_data: step2_buf, resp_size: sizeof(step2_buf));
6535	if (err < 0)
6536	return err;
6537
6538	/* extract 4-byte firmware version from step2_buf[8] */
6539	private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));
6540	usb_audio_info(mixer->chip,
6541	"Firmware version %d\n",
6542	private->firmware_version);
6543
6544	return 0;
6545	}
6546
6547	/* Get the flash segment numbers for the App_Settings and App_Upgrade
6548	* segments and put them in the private data
6549	*/
6550	static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer)
6551	{
6552	struct scarlett2_data *private = mixer->private_data;
6553	int err, count, i;
6554
6555	struct {
6556	__le32 size;
6557	__le32 count;
6558	u8 unknown[8];
6559	} __packed flash_info;
6560
6561	struct {
6562	__le32 size;
6563	__le32 flags;
6564	char name[16];
6565	} __packed segment_info;
6566
6567	err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH,
6568	NULL, req_size: 0,
6569	resp_data: &flash_info, resp_size: sizeof(flash_info));
6570	if (err < 0)
6571	return err;
6572
6573	count = le32_to_cpu(flash_info.count);
6574
6575	/* sanity check count */
6576	if (count < SCARLETT2_SEGMENT_NUM_MIN ||
6577	count > SCARLETT2_SEGMENT_NUM_MAX + 1) {
6578	usb_audio_err(mixer->chip,
6579	"invalid flash segment count: %d\n", count);
6580	return -EINVAL;
6581	}
6582
6583	for (i = 0; i < count; i++) {
6584	__le32 segment_num_req = cpu_to_le32(i);
6585	int flash_segment_id;
6586
6587	err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,
6588	req_data: &segment_num_req, req_size: sizeof(segment_num_req),
6589	resp_data: &segment_info, resp_size: sizeof(segment_info));
6590	if (err < 0) {
6591	usb_audio_err(mixer->chip,
6592	"failed to get flash segment info %d: %d\n",
6593	i, err);
6594	return err;
6595	}
6596
6597	if (!strncmp(segment_info.name,
6598	SCARLETT2_SEGMENT_SETTINGS_NAME, 16))
6599	flash_segment_id = SCARLETT2_SEGMENT_ID_SETTINGS;
6600	else if (!strncmp(segment_info.name,
6601	SCARLETT2_SEGMENT_FIRMWARE_NAME, 16))
6602	flash_segment_id = SCARLETT2_SEGMENT_ID_FIRMWARE;
6603	else
6604	continue;
6605
6606	private->flash_segment_nums[flash_segment_id] = i;
6607	private->flash_segment_blocks[flash_segment_id] =
6608	le32_to_cpu(segment_info.size) /
6609	SCARLETT2_FLASH_BLOCK_SIZE;
6610	}
6611
6612	/* segment 0 is App_Gold and we never want to touch that, so
6613	* use 0 as the "not-found" value
6614	*/
6615	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {
6616	usb_audio_err(mixer->chip,
6617	"failed to find flash segment %s\n",
6618	SCARLETT2_SEGMENT_SETTINGS_NAME);
6619	return -EINVAL;
6620	}
6621	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {
6622	usb_audio_err(mixer->chip,
6623	"failed to find flash segment %s\n",
6624	SCARLETT2_SEGMENT_FIRMWARE_NAME);
6625	return -EINVAL;
6626	}
6627
6628	return 0;
6629	}
6630
6631	/* Read configuration from the interface on start */
6632	static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
6633	{
6634	struct scarlett2_data *private = mixer->private_data;
6635	const struct scarlett2_device_info *info = private->info;
6636	int err, i;
6637
6638	if (scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_MSD_SWITCH)) {
6639	err = scarlett2_usb_get_config(
6640	mixer, config_item_num: SCARLETT2_CONFIG_MSD_SWITCH,
6641	count: 1, buf: &private->msd_switch);
6642	if (err < 0)
6643	return err;
6644	}
6645
6646	if (private->firmware_version < info->min_firmware_version) {
6647	usb_audio_err(mixer->chip,
6648	"Focusrite %s firmware version %d is too old; "
6649	"need %d",
6650	private->series_name,
6651	private->firmware_version,
6652	info->min_firmware_version);
6653	return 0;
6654	}
6655
6656	/* no other controls are created if MSD mode is on */
6657	if (private->msd_switch)
6658	return 0;
6659
6660	err = scarlett2_update_input_level(mixer);
6661	if (err < 0)
6662	return err;
6663
6664	err = scarlett2_update_input_pad(mixer);
6665	if (err < 0)
6666	return err;
6667
6668	err = scarlett2_update_input_air(mixer);
6669	if (err < 0)
6670	return err;
6671
6672	err = scarlett2_update_input_phantom(mixer);
6673	if (err < 0)
6674	return err;
6675
6676	err = scarlett2_update_direct_monitor(mixer);
6677	if (err < 0)
6678	return err;
6679
6680	/* the rest of the configuration is for devices with a mixer */
6681	if (!scarlett2_has_mixer(private))
6682	return 0;
6683
6684	err = scarlett2_update_monitor_mix(mixer);
6685	if (err < 0)
6686	return err;
6687
6688	err = scarlett2_update_monitor_other(mixer);
6689	if (err < 0)
6690	return err;
6691
6692	if (scarlett2_has_config_item(private,
6693	config_item_num: SCARLETT2_CONFIG_STANDALONE_SWITCH)) {
6694	err = scarlett2_usb_get_config(
6695	mixer, config_item_num: SCARLETT2_CONFIG_STANDALONE_SWITCH,
6696	count: 1, buf: &private->standalone_switch);
6697	if (err < 0)
6698	return err;
6699	}
6700
6701	if (scarlett2_has_config_item(private,
6702	config_item_num: SCARLETT2_CONFIG_POWER_EXT)) {
6703	err = scarlett2_update_power_status(mixer);
6704	if (err < 0)
6705	return err;
6706	}
6707
6708	err = scarlett2_update_sync(mixer);
6709	if (err < 0)
6710	return err;
6711
6712	if (scarlett2_has_config_item(private,
6713	config_item_num: SCARLETT2_CONFIG_LINE_OUT_VOLUME)) {
6714	s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
6715
6716	/* read SW line out volume */
6717	err = scarlett2_usb_get_config(
6718	mixer, config_item_num: SCARLETT2_CONFIG_LINE_OUT_VOLUME,
6719	count: private->num_line_out, buf: &sw_vol);
6720	if (err < 0)
6721	return err;
6722
6723	for (i = 0; i < private->num_line_out; i++)
6724	private->vol[i] = clamp(
6725	sw_vol[i] + SCARLETT2_VOLUME_BIAS,
6726	0, SCARLETT2_VOLUME_BIAS);
6727
6728	/* read SW mute */
6729	err = scarlett2_usb_get_config(
6730	mixer, config_item_num: SCARLETT2_CONFIG_MUTE_SWITCH,
6731	count: private->num_line_out, buf: &private->mute_switch);
6732	if (err < 0)
6733	return err;
6734
6735	for (i = 0; i < private->num_line_out; i++)
6736	private->mute_switch[i] =
6737	!!private->mute_switch[i];
6738
6739	/* read SW/HW switches */
6740	if (scarlett2_has_config_item(private,
6741	config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH)) {
6742	err = scarlett2_usb_get_config(
6743	mixer, config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH,
6744	count: private->num_line_out,
6745	buf: &private->vol_sw_hw_switch);
6746	if (err < 0)
6747	return err;
6748
6749	for (i = 0; i < private->num_line_out; i++)
6750	private->vol_sw_hw_switch[i] =
6751	!!private->vol_sw_hw_switch[i];
6752	}
6753	}
6754
6755	err = scarlett2_update_volumes(mixer);
6756	if (err < 0)
6757	return err;
6758
6759	err = scarlett2_update_dim_mute(mixer);
6760	if (err < 0)
6761	return err;
6762
6763	err = scarlett2_update_input_select(mixer);
6764	if (err < 0)
6765	return err;
6766
6767	err = scarlett2_update_input_gain(mixer);
6768	if (err < 0)
6769	return err;
6770
6771	err = scarlett2_update_autogain(mixer);
6772	if (err < 0)
6773	return err;
6774
6775	err = scarlett2_update_input_safe(mixer);
6776	if (err < 0)
6777	return err;
6778
6779	if (scarlett2_has_config_item(private,
6780	config_item_num: SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {
6781	err = scarlett2_update_pcm_input_switch(mixer);
6782	if (err < 0)
6783	return err;
6784	}
6785
6786	err = scarlett2_update_mix(mixer);
6787	if (err < 0)
6788	return err;
6789
6790	return scarlett2_usb_get_mux(mixer);
6791	}
6792
6793	/* Notify on sync change */
6794	static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)
6795	{
6796	struct scarlett2_data *private = mixer->private_data;
6797
6798	private->sync_updated = 1;
6799
6800	snd_ctl_notify(card: mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
6801	id: &private->sync_ctl->id);
6802	}
6803
6804	/* Notify on monitor change (Gen 2/3) */
6805	static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer)
6806	{
6807	struct snd_card *card = mixer->chip->card;
6808	struct scarlett2_data *private = mixer->private_data;
6809	int i;
6810
6811	if (!scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH))
6812	return;
6813
6814	private->vol_updated = 1;
6815
6816	snd_ctl_notify(card: mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
6817	id: &private->master_vol_ctl->id);
6818
6819	for (i = 0; i < private->num_line_out; i++)
6820	if (private->vol_sw_hw_switch[line_out_remap(private, index: i)])
6821	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6822	id: &private->vol_ctls[i]->id);
6823	}
6824
6825	/* Notify on volume change (Gen 4) */
6826	static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)
6827	{
6828	struct scarlett2_data *private = mixer->private_data;
6829
6830	private->vol_updated = 1;
6831
6832	snd_ctl_notify(card: mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
6833	id: &private->master_vol_ctl->id);
6834	snd_ctl_notify(card: mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
6835	id: &private->headphone_vol_ctl->id);
6836	}
6837
6838	/* Notify on dim/mute change */
6839	static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer)
6840	{
6841	struct snd_card *card = mixer->chip->card;
6842	struct scarlett2_data *private = mixer->private_data;
6843	int i;
6844
6845	if (!scarlett2_has_config_item(private, config_item_num: SCARLETT2_CONFIG_SW_HW_SWITCH))
6846	return;
6847
6848	private->dim_mute_updated = 1;
6849
6850	for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
6851	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6852	id: &private->dim_mute_ctls[i]->id);
6853
6854	for (i = 0; i < private->num_line_out; i++)
6855	if (private->vol_sw_hw_switch[line_out_remap(private, index: i)])
6856	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6857	id: &private->mute_ctls[i]->id);
6858	}
6859
6860	/* Notify on input level switch change */
6861	static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer)
6862	{
6863	struct snd_card *card = mixer->chip->card;
6864	struct scarlett2_data *private = mixer->private_data;
6865	const struct scarlett2_device_info *info = private->info;
6866	int i;
6867
6868	private->input_level_updated = 1;
6869
6870	for (i = 0; i < info->level_input_count; i++)
6871	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6872	id: &private->level_ctls[i]->id);
6873	}
6874
6875	/* Notify on input pad switch change */
6876	static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer)
6877	{
6878	struct snd_card *card = mixer->chip->card;
6879	struct scarlett2_data *private = mixer->private_data;
6880	const struct scarlett2_device_info *info = private->info;
6881	int i;
6882
6883	private->input_pad_updated = 1;
6884
6885	for (i = 0; i < info->pad_input_count; i++)
6886	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6887	id: &private->pad_ctls[i]->id);
6888	}
6889
6890	/* Notify on input air switch change */
6891	static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer)
6892	{
6893	struct snd_card *card = mixer->chip->card;
6894	struct scarlett2_data *private = mixer->private_data;
6895	const struct scarlett2_device_info *info = private->info;
6896	int i;
6897
6898	private->input_air_updated = 1;
6899
6900	for (i = 0; i < info->air_input_count; i++)
6901	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6902	id: &private->air_ctls[i]->id);
6903	}
6904
6905	/* Notify on input phantom switch change */
6906	static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer)
6907	{
6908	struct snd_card *card = mixer->chip->card;
6909	struct scarlett2_data *private = mixer->private_data;
6910	const struct scarlett2_device_info *info = private->info;
6911	int i;
6912
6913	private->input_phantom_updated = 1;
6914
6915	for (i = 0; i < info->phantom_count; i++)
6916	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6917	id: &private->phantom_ctls[i]->id);
6918
6919	scarlett2_phantom_notify_access(mixer);
6920	}
6921
6922	/* Notify on "input other" change (level/pad/air/phantom) */
6923	static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer)
6924	{
6925	scarlett2_notify_input_level(mixer);
6926	scarlett2_notify_input_pad(mixer);
6927	scarlett2_notify_input_air(mixer);
6928	scarlett2_notify_input_phantom(mixer);
6929	}
6930
6931	/* Notify on input select change */
6932	static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer)
6933	{
6934	struct snd_card *card = mixer->chip->card;
6935	struct scarlett2_data *private = mixer->private_data;
6936	const struct scarlett2_device_info *info = private->info;
6937	int i;
6938
6939	if (!info->gain_input_count)
6940	return;
6941
6942	private->input_select_updated = 1;
6943
6944	snd_ctl_notify(card,
6945	SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
6946	id: &private->input_select_ctl->id);
6947
6948	for (i = 0; i < info->gain_input_count / 2; i++)
6949	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6950	id: &private->input_link_ctls[i]->id);
6951	}
6952
6953	/* Notify on input gain change */
6954	static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer)
6955	{
6956	struct snd_card *card = mixer->chip->card;
6957	struct scarlett2_data *private = mixer->private_data;
6958	const struct scarlett2_device_info *info = private->info;
6959	int i;
6960
6961	if (!info->gain_input_count)
6962	return;
6963
6964	private->input_gain_updated = 1;
6965
6966	for (i = 0; i < info->gain_input_count; i++)
6967	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6968	id: &private->input_gain_ctls[i]->id);
6969	}
6970
6971	/* Notify on autogain change */
6972	static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer)
6973	{
6974	struct snd_card *card = mixer->chip->card;
6975	struct scarlett2_data *private = mixer->private_data;
6976	const struct scarlett2_device_info *info = private->info;
6977	int i;
6978
6979	if (!info->gain_input_count)
6980	return;
6981
6982	private->autogain_updated = 1;
6983
6984	for (i = 0; i < info->gain_input_count; i++) {
6985	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6986	id: &private->autogain_ctls[i]->id);
6987	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
6988	id: &private->autogain_status_ctls[i]->id);
6989	}
6990
6991	scarlett2_autogain_notify_access(mixer);
6992	}
6993
6994	/* Notify on input safe switch change */
6995	static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer)
6996	{
6997	struct snd_card *card = mixer->chip->card;
6998	struct scarlett2_data *private = mixer->private_data;
6999	const struct scarlett2_device_info *info = private->info;
7000	int i;
7001
7002	if (!info->gain_input_count)
7003	return;
7004
7005	private->input_safe_updated = 1;
7006
7007	for (i = 0; i < info->gain_input_count; i++)
7008	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7009	id: &private->safe_ctls[i]->id);
7010	}
7011
7012	/* Notify on "monitor other" change (speaker switching, talkback) */
7013	static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer)
7014	{
7015	struct snd_card *card = mixer->chip->card;
7016	struct scarlett2_data *private = mixer->private_data;
7017	const struct scarlett2_device_info *info = private->info;
7018
7019	private->monitor_other_updated = 1;
7020
7021	if (info->has_speaker_switching)
7022	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7023	id: &private->speaker_switching_ctl->id);
7024
7025	if (info->has_talkback)
7026	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7027	id: &private->talkback_ctl->id);
7028
7029	/* if speaker switching was recently enabled or disabled,
7030	* invalidate the dim/mute and mux enum controls
7031	*/
7032	if (private->speaker_switching_switched) {
7033	int i;
7034
7035	scarlett2_notify_dim_mute(mixer);
7036
7037	private->speaker_switching_switched = 0;
7038	private->mux_updated = 1;
7039
7040	for (i = 0; i < private->num_mux_dsts; i++)
7041	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7042	id: &private->mux_ctls[i]->id);
7043	}
7044	}
7045
7046	/* Notify on direct monitor switch change */
7047	static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer)
7048	{
7049	struct snd_card *card = mixer->chip->card;
7050	struct scarlett2_data *private = mixer->private_data;
7051	int count = private->num_mix_in * private->num_mix_out;
7052	int i;
7053
7054	private->direct_monitor_updated = 1;
7055
7056	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7057	id: &private->direct_monitor_ctl->id);
7058
7059	if (!scarlett2_has_mixer(private))
7060	return;
7061
7062	private->mix_updated = 1;
7063
7064	/* Notify of change to the mix controls */
7065	for (i = 0; i < count; i++)
7066	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7067	id: &private->mix_ctls[i]->id);
7068	}
7069
7070	/* Notify on power change */
7071	static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer)
7072	{
7073	struct snd_card *card = mixer->chip->card;
7074	struct scarlett2_data *private = mixer->private_data;
7075
7076	private->power_status_updated = 1;
7077
7078	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7079	id: &private->power_status_ctl->id);
7080	}
7081
7082	/* Notify on mux change */
7083	static void scarlett2_notify_mux(struct usb_mixer_interface *mixer)
7084	{
7085	struct snd_card *card = mixer->chip->card;
7086	struct scarlett2_data *private = mixer->private_data;
7087	int i;
7088
7089	private->mux_updated = 1;
7090
7091	for (i = 0; i < private->num_mux_dsts; i++)
7092	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7093	id: &private->mux_ctls[i]->id);
7094	}
7095
7096	/* Notify on PCM input switch change */
7097	static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer)
7098	{
7099	struct snd_card *card = mixer->chip->card;
7100	struct scarlett2_data *private = mixer->private_data;
7101
7102	private->pcm_input_switch_updated = 1;
7103
7104	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
7105	id: &private->pcm_input_switch_ctl->id);
7106
7107	scarlett2_notify_mux(mixer);
7108	}
7109
7110	/* Interrupt callback */
7111	static void scarlett2_notify(struct urb *urb)
7112	{
7113	struct usb_mixer_interface *mixer = urb->context;
7114	int len = urb->actual_length;
7115	int ustatus = urb->status;
7116	u32 data;
7117	struct scarlett2_data *private = mixer->private_data;
7118	const struct scarlett2_notification *notifications =
7119	private->config_set->notifications;
7120
7121	if (ustatus != 0 || len != 8)
7122	goto requeue;
7123
7124	data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
7125
7126	while (data && notifications->mask) {
7127	if (data & notifications->mask) {
7128	data &= ~notifications->mask;
7129	if (notifications->func)
7130	notifications->func(mixer);
7131	}
7132	notifications++;
7133	}
7134
7135	if (data)
7136	usb_audio_warn(mixer->chip,
7137	"%s: Unhandled notification: 0x%08x\n",
7138	__func__, data);
7139
7140	requeue:
7141	if (ustatus != -ENOENT &&
7142	ustatus != -ECONNRESET &&
7143	ustatus != -ESHUTDOWN) {
7144	urb->dev = mixer->chip->dev;
7145	usb_submit_urb(urb, GFP_ATOMIC);
7146	}
7147	}
7148
7149	static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
7150	{
7151	struct usb_device *dev = mixer->chip->dev;
7152	struct scarlett2_data *private = mixer->private_data;
7153	unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
7154	void *transfer_buffer;
7155
7156	if (mixer->urb) {
7157	usb_audio_err(mixer->chip,
7158	"%s: mixer urb already in use!\n", __func__);
7159	return 0;
7160	}
7161
7162	if (usb_pipe_type_check(dev, pipe))
7163	return -EINVAL;
7164
7165	mixer->urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL);
7166	if (!mixer->urb)
7167	return -ENOMEM;
7168
7169	transfer_buffer = kmalloc(size: private->wMaxPacketSize, GFP_KERNEL);
7170	if (!transfer_buffer)
7171	return -ENOMEM;
7172
7173	usb_fill_int_urb(urb: mixer->urb, dev, pipe,
7174	transfer_buffer, buffer_length: private->wMaxPacketSize,
7175	complete_fn: scarlett2_notify, context: mixer, interval: private->bInterval);
7176
7177	return usb_submit_urb(urb: mixer->urb, GFP_KERNEL);
7178	}
7179
7180	static const struct scarlett2_device_entry *get_scarlett2_device_entry(
7181	struct usb_mixer_interface *mixer)
7182	{
7183	const struct scarlett2_device_entry *entry = scarlett2_devices;
7184
7185	/* Find entry in scarlett2_devices */
7186	while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)
7187	entry++;
7188	if (!entry->usb_id)
7189	return NULL;
7190
7191	return entry;
7192	}
7193
7194	static int snd_scarlett2_controls_create(
7195	struct usb_mixer_interface *mixer,
7196	const struct scarlett2_device_entry *entry)
7197	{
7198	struct scarlett2_data *private;
7199	int err;
7200
7201	/* Initialise private data */
7202	err = scarlett2_init_private(mixer, entry);
7203	if (err < 0)
7204	return err;
7205
7206	private = mixer->private_data;
7207
7208	/* Send proprietary USB initialisation sequence */
7209	err = scarlett2_usb_init(mixer);
7210	if (err < 0)
7211	return err;
7212
7213	/* Get the upgrade & settings flash segment numbers */
7214	err = scarlett2_get_flash_segment_nums(mixer);
7215	if (err < 0)
7216	return err;
7217
7218	/* Add firmware version control */
7219	err = scarlett2_add_firmware_version_ctl(mixer);
7220	if (err < 0)
7221	return err;
7222
7223	/* Add minimum firmware version control */
7224	err = scarlett2_add_min_firmware_version_ctl(mixer);
7225	if (err < 0)
7226	return err;
7227
7228	/* Read volume levels and controls from the interface */
7229	err = scarlett2_read_configs(mixer);
7230	if (err < 0)
7231	return err;
7232
7233	/* Create the MSD control */
7234	err = scarlett2_add_msd_ctl(mixer);
7235	if (err < 0)
7236	return err;
7237
7238	/* If MSD mode is enabled, or if the firmware version is too
7239	* old, don't create any other controls
7240	*/
7241	if (private->msd_switch ||
7242	private->firmware_version < private->info->min_firmware_version)
7243	return 0;
7244
7245	/* Create the analogue output controls */
7246	err = scarlett2_add_line_out_ctls(mixer);
7247	if (err < 0)
7248	return err;
7249
7250	/* Create the analogue input controls */
7251	err = scarlett2_add_line_in_ctls(mixer);
7252	if (err < 0)
7253	return err;
7254
7255	/* Create the input, output, and mixer mux input selections */
7256	err = scarlett2_add_mux_enums(mixer);
7257	if (err < 0)
7258	return err;
7259
7260	/* Create the matrix mixer controls */
7261	err = scarlett2_add_mixer_ctls(mixer);
7262	if (err < 0)
7263	return err;
7264
7265	/* Create the level meter controls */
7266	err = scarlett2_add_meter_ctl(mixer);
7267	if (err < 0)
7268	return err;
7269
7270	/* Create the sync control */
7271	err = scarlett2_add_sync_ctl(mixer);
7272	if (err < 0)
7273	return err;
7274
7275	/* Create the direct monitor control(s) */
7276	err = scarlett2_add_direct_monitor_ctls(mixer);
7277	if (err < 0)
7278	return err;
7279
7280	/* Create the speaker switching control */
7281	err = scarlett2_add_speaker_switch_ctl(mixer);
7282	if (err < 0)
7283	return err;
7284
7285	/* Create the talkback controls */
7286	err = scarlett2_add_talkback_ctls(mixer);
7287	if (err < 0)
7288	return err;
7289
7290	/* Create the standalone control */
7291	err = scarlett2_add_standalone_ctl(mixer);
7292	if (err < 0)
7293	return err;
7294
7295	/* Create the power status control */
7296	err = scarlett2_add_power_status_ctl(mixer);
7297	if (err < 0)
7298	return err;
7299
7300	/* Set the access mode of controls disabled during
7301	* autogain/phantom power switching.
7302	*/
7303	if (private->info->gain_input_count) {
7304	scarlett2_autogain_update_access(mixer);
7305	scarlett2_phantom_update_access(mixer);
7306	}
7307
7308	/* Set up the interrupt polling */
7309	err = scarlett2_init_notify(mixer);
7310	if (err < 0)
7311	return err;
7312
7313	return 0;
7314	}
7315
7316	/*** hwdep interface ***/
7317
7318	/* Set private->hwdep_in_use; prevents access to the ALSA controls
7319	* while doing a config erase/firmware upgrade.
7320	*/
7321	static void scarlett2_lock(struct scarlett2_data *private)
7322	{
7323	mutex_lock(&private->data_mutex);
7324	private->hwdep_in_use = 1;
7325	mutex_unlock(lock: &private->data_mutex);
7326	}
7327
7328	/* Call SCARLETT2_USB_GET_ERASE to get the erase progress */
7329	static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)
7330	{
7331	struct scarlett2_data *private = mixer->private_data;
7332	int segment_id, segment_num, err;
7333	u8 erase_resp;
7334
7335	struct {
7336	__le32 segment_num;
7337	__le32 pad;
7338	} __packed erase_req;
7339
7340	segment_id = private->selected_flash_segment_id;
7341	segment_num = private->flash_segment_nums[segment_id];
7342
7343	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
7344	segment_num > SCARLETT2_SEGMENT_NUM_MAX)
7345	return -EFAULT;
7346
7347	/* Send the erase progress request */
7348	erase_req.segment_num = cpu_to_le32(segment_num);
7349	erase_req.pad = 0;
7350
7351	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
7352	req_data: &erase_req, req_size: sizeof(erase_req),
7353	resp_data: &erase_resp, resp_size: sizeof(erase_resp));
7354	if (err < 0)
7355	return err;
7356
7357	return erase_resp;
7358	}
7359
7360	/* Repeatedly call scarlett2_get_erase_progress() until it returns
7361	* 0xff (erase complete) or we've waited 10 seconds (it usually takes
7362	* <3 seconds).
7363	*/
7364	static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer)
7365	{
7366	int i, err;
7367
7368	for (i = 0; i < 100; i++) {
7369	err = scarlett2_get_erase_progress(mixer);
7370	if (err < 0)
7371	return err;
7372
7373	if (err == 0xff)
7374	return 0;
7375
7376	msleep(msecs: 100);
7377	}
7378
7379	return -ETIMEDOUT;
7380	}
7381
7382	/* Reboot the device; wait for the erase to complete if one is in
7383	* progress.
7384	*/
7385	static int scarlett2_reboot(struct usb_mixer_interface *mixer)
7386	{
7387	struct scarlett2_data *private = mixer->private_data;
7388
7389	if (private->flash_write_state ==
7390	SCARLETT2_FLASH_WRITE_STATE_ERASING) {
7391	int err = scarlett2_wait_for_erase(mixer);
7392
7393	if (err < 0)
7394	return err;
7395	}
7396
7397	return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, req_size: 0, NULL, resp_size: 0);
7398	}
7399
7400	/* Select a flash segment for erasing (and possibly writing to) */
7401	static int scarlett2_ioctl_select_flash_segment(
7402	struct usb_mixer_interface *mixer,
7403	unsigned long arg)
7404	{
7405	struct scarlett2_data *private = mixer->private_data;
7406	int segment_id, segment_num;
7407
7408	if (get_user(segment_id, (int __user *)arg))
7409	return -EFAULT;
7410
7411	/* Check the segment ID and segment number */
7412	if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT)
7413	return -EINVAL;
7414
7415	segment_num = private->flash_segment_nums[segment_id];
7416	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
7417	segment_num > SCARLETT2_SEGMENT_NUM_MAX) {
7418	usb_audio_err(mixer->chip,
7419	"%s: invalid segment number %d\n",
7420	__func__, segment_id);
7421	return -EFAULT;
7422	}
7423
7424	/* If erasing, wait for it to complete */
7425	if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {
7426	int err = scarlett2_wait_for_erase(mixer);
7427
7428	if (err < 0)
7429	return err;
7430	}
7431
7432	/* Save the selected segment ID and set the state to SELECTED */
7433	private->selected_flash_segment_id = segment_id;
7434	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;
7435
7436	return 0;
7437	}
7438
7439	/* Erase the previously-selected flash segment */
7440	static int scarlett2_ioctl_erase_flash_segment(
7441	struct usb_mixer_interface *mixer)
7442	{
7443	struct scarlett2_data *private = mixer->private_data;
7444	int segment_id, segment_num, err;
7445
7446	struct {
7447	__le32 segment_num;
7448	__le32 pad;
7449	} __packed erase_req;
7450
7451	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
7452	return -EINVAL;
7453
7454	segment_id = private->selected_flash_segment_id;
7455	segment_num = private->flash_segment_nums[segment_id];
7456
7457	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
7458	segment_num > SCARLETT2_SEGMENT_NUM_MAX)
7459	return -EFAULT;
7460
7461	/* Prevent access to ALSA controls that access the device from
7462	* here on
7463	*/
7464	scarlett2_lock(private);
7465
7466	/* Send the erase request */
7467	erase_req.segment_num = cpu_to_le32(segment_num);
7468	erase_req.pad = 0;
7469
7470	err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,
7471	req_data: &erase_req, req_size: sizeof(erase_req),
7472	NULL, resp_size: 0);
7473	if (err < 0)
7474	return err;
7475
7476	/* On success, change the state from SELECTED to ERASING */
7477	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;
7478
7479	return 0;
7480	}
7481
7482	/* Get the erase progress from the device */
7483	static int scarlett2_ioctl_get_erase_progress(
7484	struct usb_mixer_interface *mixer,
7485	unsigned long arg)
7486	{
7487	struct scarlett2_data *private = mixer->private_data;
7488	struct scarlett2_flash_segment_erase_progress progress;
7489	int segment_id, segment_num, err;
7490	u8 erase_resp;
7491
7492	struct {
7493	__le32 segment_num;
7494	__le32 pad;
7495	} __packed erase_req;
7496
7497	/* Check that we're erasing */
7498	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
7499	return -EINVAL;
7500
7501	segment_id = private->selected_flash_segment_id;
7502	segment_num = private->flash_segment_nums[segment_id];
7503
7504	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
7505	segment_num > SCARLETT2_SEGMENT_NUM_MAX)
7506	return -EFAULT;
7507
7508	/* Send the erase progress request */
7509	erase_req.segment_num = cpu_to_le32(segment_num);
7510	erase_req.pad = 0;
7511
7512	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
7513	req_data: &erase_req, req_size: sizeof(erase_req),
7514	resp_data: &erase_resp, resp_size: sizeof(erase_resp));
7515	if (err < 0)
7516	return err;
7517
7518	progress.progress = erase_resp;
7519	progress.num_blocks = private->flash_segment_blocks[segment_id];
7520
7521	if (copy_to_user(to: (void __user *)arg, from: &progress, n: sizeof(progress)))
7522	return -EFAULT;
7523
7524	/* If the erase is complete, change the state from ERASING to
7525	* WRITE.
7526	*/
7527	if (progress.progress == 0xff)
7528	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
7529
7530	return 0;
7531	}
7532
7533	static int scarlett2_hwdep_open(struct snd_hwdep *hw, struct file *file)
7534	{
7535	struct usb_mixer_interface *mixer = hw->private_data;
7536	struct scarlett2_data *private = mixer->private_data;
7537
7538	/* If erasing, wait for it to complete */
7539	if (private->flash_write_state ==
7540	SCARLETT2_FLASH_WRITE_STATE_ERASING) {
7541	int err = scarlett2_wait_for_erase(mixer);
7542
7543	if (err < 0)
7544	return err;
7545	}
7546
7547	/* Set the state to IDLE */
7548	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
7549
7550	return 0;
7551	}
7552
7553	static int scarlett2_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
7554	unsigned int cmd, unsigned long arg)
7555	{
7556	struct usb_mixer_interface *mixer = hw->private_data;
7557
7558	switch (cmd) {
7559
7560	case SCARLETT2_IOCTL_PVERSION:
7561	return put_user(SCARLETT2_HWDEP_VERSION,
7562	(int __user *)arg) ? -EFAULT : 0;
7563
7564	case SCARLETT2_IOCTL_REBOOT:
7565	return scarlett2_reboot(mixer);
7566
7567	case SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT:
7568	return scarlett2_ioctl_select_flash_segment(mixer, arg);
7569
7570	case SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT:
7571	return scarlett2_ioctl_erase_flash_segment(mixer);
7572
7573	case SCARLETT2_IOCTL_GET_ERASE_PROGRESS:
7574	return scarlett2_ioctl_get_erase_progress(mixer, arg);
7575
7576	default:
7577	return -ENOIOCTLCMD;
7578	}
7579	}
7580
7581	static long scarlett2_hwdep_write(struct snd_hwdep *hw,
7582	const char __user *buf,
7583	long count, loff_t *offset)
7584	{
7585	struct usb_mixer_interface *mixer = hw->private_data;
7586	struct scarlett2_data *private = mixer->private_data;
7587	int segment_id, segment_num, err, len;
7588	int flash_size;
7589
7590	/* SCARLETT2_USB_WRITE_SEGMENT request data */
7591	struct {
7592	__le32 segment_num;
7593	__le32 offset;
7594	__le32 pad;
7595	u8 data[];
7596	} __packed *req;
7597
7598	/* Calculate the maximum permitted in data[] */
7599	const size_t max_data_size = SCARLETT2_FLASH_WRITE_MAX -
7600	offsetof(typeof(*req), data);
7601
7602	/* If erasing, wait for it to complete */
7603	if (private->flash_write_state ==
7604	SCARLETT2_FLASH_WRITE_STATE_ERASING) {
7605	err = scarlett2_wait_for_erase(mixer);
7606	if (err < 0)
7607	return err;
7608	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
7609
7610	/* Check that an erase has been done & completed */
7611	} else if (private->flash_write_state !=
7612	SCARLETT2_FLASH_WRITE_STATE_WRITE) {
7613	return -EINVAL;
7614	}
7615
7616	/* Check that we're writing to the upgrade firmware */
7617	segment_id = private->selected_flash_segment_id;
7618	if (segment_id != SCARLETT2_SEGMENT_ID_FIRMWARE)
7619	return -EINVAL;
7620
7621	segment_num = private->flash_segment_nums[segment_id];
7622	if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||
7623	segment_num > SCARLETT2_SEGMENT_NUM_MAX)
7624	return -EFAULT;
7625
7626	/* Validate the offset and count */
7627	flash_size = private->flash_segment_blocks[segment_id] *
7628	SCARLETT2_FLASH_BLOCK_SIZE;
7629
7630	if (count < 0 || *offset < 0 || *offset + count >= flash_size)
7631	return -EINVAL;
7632
7633	if (!count)
7634	return 0;
7635
7636	/* Limit the *req size to SCARLETT2_FLASH_WRITE_MAX */
7637	if (count > max_data_size)
7638	count = max_data_size;
7639
7640	/* Create and send the request */
7641	len = struct_size(req, data, count);
7642	req = kzalloc(size: len, GFP_KERNEL);
7643	if (!req)
7644	return -ENOMEM;
7645
7646	req->segment_num = cpu_to_le32(segment_num);
7647	req->offset = cpu_to_le32(*offset);
7648	req->pad = 0;
7649
7650	if (copy_from_user(to: req->data, from: buf, n: count)) {
7651	err = -EFAULT;
7652	goto error;
7653	}
7654
7655	err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT,
7656	req_data: req, req_size: len, NULL, resp_size: 0);
7657	if (err < 0)
7658	goto error;
7659
7660	*offset += count;
7661	err = count;
7662
7663	error:
7664	kfree(objp: req);
7665	return err;
7666	}
7667
7668	static int scarlett2_hwdep_release(struct snd_hwdep *hw, struct file *file)
7669	{
7670	struct usb_mixer_interface *mixer = hw->private_data;
7671	struct scarlett2_data *private = mixer->private_data;
7672
7673	/* Return from the SELECTED or WRITE state to IDLE.
7674	* The ERASING state is left as-is, and checked on next open.
7675	*/
7676	if (private &&
7677	private->hwdep_in_use &&
7678	private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
7679	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
7680
7681	return 0;
7682	}
7683
7684	static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer)
7685	{
7686	struct snd_hwdep *hw;
7687	int err;
7688
7689	err = snd_hwdep_new(card: mixer->chip->card, id: "Focusrite Control", device: 0, rhwdep: &hw);
7690	if (err < 0)
7691	return err;
7692
7693	hw->private_data = mixer;
7694	hw->exclusive = 1;
7695	hw->ops.open = scarlett2_hwdep_open;
7696	hw->ops.ioctl = scarlett2_hwdep_ioctl;
7697	hw->ops.write = scarlett2_hwdep_write;
7698	hw->ops.release = scarlett2_hwdep_release;
7699
7700	return 0;
7701	}
7702
7703	int snd_scarlett2_init(struct usb_mixer_interface *mixer)
7704	{
7705	struct snd_usb_audio *chip = mixer->chip;
7706	const struct scarlett2_device_entry *entry;
7707	int err;
7708
7709	/* only use UAC_VERSION_2 */
7710	if (!mixer->protocol)
7711	return 0;
7712
7713	/* find entry in scarlett2_devices */
7714	entry = get_scarlett2_device_entry(mixer);
7715	if (!entry) {
7716	usb_audio_err(mixer->chip,
7717	"%s: missing device entry for %04x:%04x\n",
7718	__func__,
7719	USB_ID_VENDOR(chip->usb_id),
7720	USB_ID_PRODUCT(chip->usb_id));
7721	return 0;
7722	}
7723
7724	if (chip->setup & SCARLETT2_DISABLE) {
7725	usb_audio_info(chip,
7726	"Focusrite %s Mixer Driver disabled "
7727	"by modprobe options (snd_usb_audio "
7728	"vid=0x%04x pid=0x%04x device_setup=%d)\n",
7729	entry->series_name,
7730	USB_ID_VENDOR(chip->usb_id),
7731	USB_ID_PRODUCT(chip->usb_id),
7732	SCARLETT2_DISABLE);
7733	return 0;
7734	}
7735
7736	usb_audio_info(chip,
7737	"Focusrite %s Mixer Driver enabled (pid=0x%04x); "
7738	"report any issues to "
7739	"https://github.com/geoffreybennett/scarlett-gen2/issues",
7740	entry->series_name,
7741	USB_ID_PRODUCT(chip->usb_id));
7742
7743	err = snd_scarlett2_controls_create(mixer, entry);
7744	if (err < 0) {
7745	usb_audio_err(mixer->chip,
7746	"Error initialising %s Mixer Driver: %d",
7747	entry->series_name,
7748	err);
7749	return err;
7750	}
7751
7752	err = scarlett2_hwdep_init(mixer);
7753	if (err < 0)
7754	usb_audio_err(mixer->chip,
7755	"Error creating %s hwdep device: %d",
7756	entry->series_name,
7757	err);
7758
7759	return err;
7760	}
7761