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