• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *   Focusrite Scarlett 6i6/18i8/18i20 Gen 2 Driver for ALSA
4  *
5  *   Copyright (c) 2018-2019 by Geoffrey D. Bennett <g at b4.vu>
6  *
7  *   Based on the Scarlett (Gen 1) Driver for ALSA:
8  *
9  *   Copyright (c) 2013 by Tobias Hoffmann
10  *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
11  *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
12  *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
13  *
14  *   Many codes borrowed from audio.c by
15  *     Alan Cox (alan at lxorguk.ukuu.org.uk)
16  *     Thomas Sailer (sailer at ife.ee.ethz.ch)
17  *
18  *   Code cleanup:
19  *   David Henningsson <david.henningsson at canonical.com>
20  */
21 
22 /* Mixer Interface for the Focusrite Scarlett 6i6/18i8/18i20 Gen 2 audio
23  * interface. Based on the Gen 1 driver and rewritten.
24  */
25 
26 /* The protocol was reverse engineered by looking at the communication
27  * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
28  * (firmware 1083) using usbmon in July-August 2018.
29  *
30  * Scarlett 18i8 support added in April 2019.
31  *
32  * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
33  * for providing usbmon output and testing).
34  *
35  * This ALSA mixer gives access to:
36  *  - input, output, mixer-matrix muxes
37  *  - 18x10 mixer-matrix gain stages
38  *  - gain/volume controls
39  *  - level meters
40  *  - line/inst level and pad controls
41  *
42  * <ditaa>
43  *    /--------------\    18chn            20chn     /--------------\
44  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
45  *    \--------------/  |      |    |             |  \--------------/
46  *                      |      |    |    /-----\  |
47  *                      |      |    |    |     |  |
48  *                      |      v    v    v     |  |
49  *                      |   +---------------+  |  |
50  *                      |    \ Matrix  Mux /   |  |
51  *                      |     +-----+-----+    |  |
52  *                      |           |          |  |
53  *                      |           |18chn     |  |
54  *                      |           |          |  |
55  *                      |           |     10chn|  |
56  *                      |           v          |  |
57  *                      |     +------------+   |  |
58  *                      |     | Mixer      |   |  |
59  *                      |     |     Matrix |   |  |
60  *                      |     |            |   |  |
61  *                      |     | 18x10 Gain |   |  |
62  *                      |     |   stages   |   |  |
63  *                      |     +-----+------+   |  |
64  *                      |           |          |  |
65  *                      |18chn      |10chn     |  |20chn
66  *                      |           |          |  |
67  *                      |           +----------/  |
68  *                      |           |             |
69  *                      v           v             v
70  *                      ===========================
71  *               +---------------+       +--—------------+
72  *                \ Output  Mux /         \ Capture Mux /
73  *                 +---+---+---+           +-----+-----+
74  *                     |   |                     |
75  *                10chn|   |                     |18chn
76  *                     |   |                     |
77  *  /--------------\   |   |                     |   /--------------\
78  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
79  *  | Hardware out |       |                         \--------------/
80  *  \--------------/       |
81  *                         v
82  *                  +-------------+    Software gain per channel.
83  *                  | Master Gain |<-- 18i20 only: Switch per channel
84  *                  +------+------+    to select HW or SW gain control.
85  *                         |
86  *                         |10chn
87  *  /--------------\       |
88  *  | Analogue     |<------/
89  *  | Hardware out |
90  *  \--------------/
91  * </ditaa>
92  *
93  */
94 
95 #include <linux/slab.h>
96 #include <linux/usb.h>
97 #include <linux/moduleparam.h>
98 
99 #include <sound/control.h>
100 #include <sound/tlv.h>
101 
102 #include "usbaudio.h"
103 #include "mixer.h"
104 #include "helper.h"
105 
106 #include "mixer_scarlett_gen2.h"
107 
108 /* device_setup value to enable */
109 #define SCARLETT2_ENABLE 0x01
110 
111 /* some gui mixers can't handle negative ctl values */
112 #define SCARLETT2_VOLUME_BIAS 127
113 
114 /* mixer range from -80dB to +6dB in 0.5dB steps */
115 #define SCARLETT2_MIXER_MIN_DB -80
116 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
117 #define SCARLETT2_MIXER_MAX_DB 6
118 #define SCARLETT2_MIXER_MAX_VALUE \
119 	((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
120 
121 /* map from (dB + 80) * 2 to mixer value
122  * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
123  */
124 static const u16 scarlett2_mixer_values[173] = {
125 	0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
126 	2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
127 	9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
128 	23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
129 	54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
130 	122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
131 	244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
132 	487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
133 	973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
134 	1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
135 	3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
136 	5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
137 	9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
138 	16345
139 };
140 
141 /* Maximum number of analogue outputs */
142 #define SCARLETT2_ANALOGUE_MAX 10
143 
144 /* Maximum number of level and pad switches */
145 #define SCARLETT2_LEVEL_SWITCH_MAX 2
146 #define SCARLETT2_PAD_SWITCH_MAX 4
147 
148 /* Maximum number of inputs to the mixer */
149 #define SCARLETT2_INPUT_MIX_MAX 18
150 
151 /* Maximum number of outputs from the mixer */
152 #define SCARLETT2_OUTPUT_MIX_MAX 10
153 
154 /* Maximum size of the data in the USB mux assignment message:
155  * 18 inputs, 20 outputs, 18 matrix inputs, 8 spare
156  */
157 #define SCARLETT2_MUX_MAX 64
158 
159 /* Number of meters:
160  * 18 inputs, 20 outputs, 18 matrix inputs
161  */
162 #define SCARLETT2_NUM_METERS 56
163 
164 /* Hardware port types:
165  * - None (no input to mux)
166  * - Analogue I/O
167  * - S/PDIF I/O
168  * - ADAT I/O
169  * - Mixer I/O
170  * - PCM I/O
171  */
172 enum {
173 	SCARLETT2_PORT_TYPE_NONE = 0,
174 	SCARLETT2_PORT_TYPE_ANALOGUE = 1,
175 	SCARLETT2_PORT_TYPE_SPDIF = 2,
176 	SCARLETT2_PORT_TYPE_ADAT = 3,
177 	SCARLETT2_PORT_TYPE_MIX = 4,
178 	SCARLETT2_PORT_TYPE_PCM = 5,
179 	SCARLETT2_PORT_TYPE_COUNT = 6,
180 };
181 
182 /* Count of total I/O and number available at each sample rate */
183 enum {
184 	SCARLETT2_PORT_IN = 0,
185 	SCARLETT2_PORT_OUT = 1,
186 	SCARLETT2_PORT_OUT_44 = 2,
187 	SCARLETT2_PORT_OUT_88 = 3,
188 	SCARLETT2_PORT_OUT_176 = 4,
189 	SCARLETT2_PORT_DIRECTIONS = 5,
190 };
191 
192 /* Hardware buttons on the 18i20 */
193 #define SCARLETT2_BUTTON_MAX 2
194 
195 static const char *const scarlett2_button_names[SCARLETT2_BUTTON_MAX] = {
196 	"Mute", "Dim"
197 };
198 
199 /* Description of each hardware port type:
200  * - id: hardware ID for this port type
201  * - num: number of sources/destinations of this port type
202  * - src_descr: printf format string for mux input selections
203  * - src_num_offset: added to channel number for the fprintf
204  * - dst_descr: printf format string for mixer controls
205  */
206 struct scarlett2_ports {
207 	u16 id;
208 	int num[SCARLETT2_PORT_DIRECTIONS];
209 	const char * const src_descr;
210 	int src_num_offset;
211 	const char * const dst_descr;
212 };
213 
214 struct scarlett2_device_info {
215 	u8 line_out_hw_vol; /* line out hw volume is sw controlled */
216 	u8 button_count; /* number of buttons */
217 	u8 level_input_count; /* inputs with level selectable */
218 	u8 pad_input_count; /* inputs with pad selectable */
219 	const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
220 	struct scarlett2_ports ports[SCARLETT2_PORT_TYPE_COUNT];
221 };
222 
223 struct scarlett2_mixer_data {
224 	struct usb_mixer_interface *mixer;
225 	struct mutex usb_mutex; /* prevent sending concurrent USB requests */
226 	struct mutex data_mutex; /* lock access to this data */
227 	struct delayed_work work;
228 	const struct scarlett2_device_info *info;
229 	int num_mux_srcs;
230 	u16 scarlett2_seq;
231 	u8 vol_updated;
232 	u8 master_vol;
233 	u8 vol[SCARLETT2_ANALOGUE_MAX];
234 	u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
235 	u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
236 	u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
237 	u8 buttons[SCARLETT2_BUTTON_MAX];
238 	struct snd_kcontrol *master_vol_ctl;
239 	struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
240 	struct snd_kcontrol *button_ctls[SCARLETT2_BUTTON_MAX];
241 	u8 mux[SCARLETT2_MUX_MAX];
242 	u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
243 };
244 
245 /*** Model-specific data ***/
246 
247 static const struct scarlett2_device_info s6i6_gen2_info = {
248 	/* The first two analogue inputs can be switched between line
249 	 * and instrument levels.
250 	 */
251 	.level_input_count = 2,
252 
253 	/* The first two analogue inputs have an optional pad. */
254 	.pad_input_count = 2,
255 
256 	.line_out_descrs = {
257 		"Headphones 1 L",
258 		"Headphones 1 R",
259 		"Headphones 2 L",
260 		"Headphones 2 R",
261 	},
262 
263 	.ports = {
264 		[SCARLETT2_PORT_TYPE_NONE] = {
265 			.id = 0x000,
266 			.num = { 1, 0, 8, 8, 8 },
267 			.src_descr = "Off",
268 			.src_num_offset = 0,
269 		},
270 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {
271 			.id = 0x080,
272 			.num = { 4, 4, 4, 4, 4 },
273 			.src_descr = "Analogue %d",
274 			.src_num_offset = 1,
275 			.dst_descr = "Analogue Output %02d Playback"
276 		},
277 		[SCARLETT2_PORT_TYPE_SPDIF] = {
278 			.id = 0x180,
279 			.num = { 2, 2, 2, 2, 2 },
280 			.src_descr = "S/PDIF %d",
281 			.src_num_offset = 1,
282 			.dst_descr = "S/PDIF Output %d Playback"
283 		},
284 		[SCARLETT2_PORT_TYPE_MIX] = {
285 			.id = 0x300,
286 			.num = { 10, 18, 18, 18, 18 },
287 			.src_descr = "Mix %c",
288 			.src_num_offset = 65,
289 			.dst_descr = "Mixer Input %02d Capture"
290 		},
291 		[SCARLETT2_PORT_TYPE_PCM] = {
292 			.id = 0x600,
293 			.num = { 6, 6, 6, 6, 6 },
294 			.src_descr = "PCM %d",
295 			.src_num_offset = 1,
296 			.dst_descr = "PCM %02d Capture"
297 		},
298 	},
299 };
300 
301 static const struct scarlett2_device_info s18i8_gen2_info = {
302 	/* The first two analogue inputs can be switched between line
303 	 * and instrument levels.
304 	 */
305 	.level_input_count = 2,
306 
307 	/* The first four analogue inputs have an optional pad. */
308 	.pad_input_count = 4,
309 
310 	.line_out_descrs = {
311 		"Monitor L",
312 		"Monitor R",
313 		"Headphones 1 L",
314 		"Headphones 1 R",
315 		"Headphones 2 L",
316 		"Headphones 2 R",
317 	},
318 
319 	.ports = {
320 		[SCARLETT2_PORT_TYPE_NONE] = {
321 			.id = 0x000,
322 			.num = { 1, 0, 8, 8, 4 },
323 			.src_descr = "Off",
324 			.src_num_offset = 0,
325 		},
326 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {
327 			.id = 0x080,
328 			.num = { 8, 6, 6, 6, 6 },
329 			.src_descr = "Analogue %d",
330 			.src_num_offset = 1,
331 			.dst_descr = "Analogue Output %02d Playback"
332 		},
333 		[SCARLETT2_PORT_TYPE_SPDIF] = {
334 			.id = 0x180,
335 			/* S/PDIF outputs aren't available at 192kHz
336 			 * but are included in the USB mux I/O
337 			 * assignment message anyway
338 			 */
339 			.num = { 2, 2, 2, 2, 2 },
340 			.src_descr = "S/PDIF %d",
341 			.src_num_offset = 1,
342 			.dst_descr = "S/PDIF Output %d Playback"
343 		},
344 		[SCARLETT2_PORT_TYPE_ADAT] = {
345 			.id = 0x200,
346 			.num = { 8, 0, 0, 0, 0 },
347 			.src_descr = "ADAT %d",
348 			.src_num_offset = 1,
349 		},
350 		[SCARLETT2_PORT_TYPE_MIX] = {
351 			.id = 0x300,
352 			.num = { 10, 18, 18, 18, 18 },
353 			.src_descr = "Mix %c",
354 			.src_num_offset = 65,
355 			.dst_descr = "Mixer Input %02d Capture"
356 		},
357 		[SCARLETT2_PORT_TYPE_PCM] = {
358 			.id = 0x600,
359 			.num = { 8, 18, 18, 14, 10 },
360 			.src_descr = "PCM %d",
361 			.src_num_offset = 1,
362 			.dst_descr = "PCM %02d Capture"
363 		},
364 	},
365 };
366 
367 static const struct scarlett2_device_info s18i20_gen2_info = {
368 	/* The analogue line outputs on the 18i20 can be switched
369 	 * between software and hardware volume control
370 	 */
371 	.line_out_hw_vol = 1,
372 
373 	/* Mute and dim buttons */
374 	.button_count = 2,
375 
376 	.line_out_descrs = {
377 		"Monitor L",
378 		"Monitor R",
379 		NULL,
380 		NULL,
381 		NULL,
382 		NULL,
383 		"Headphones 1 L",
384 		"Headphones 1 R",
385 		"Headphones 2 L",
386 		"Headphones 2 R",
387 	},
388 
389 	.ports = {
390 		[SCARLETT2_PORT_TYPE_NONE] = {
391 			.id = 0x000,
392 			.num = { 1, 0, 8, 8, 6 },
393 			.src_descr = "Off",
394 			.src_num_offset = 0,
395 		},
396 		[SCARLETT2_PORT_TYPE_ANALOGUE] = {
397 			.id = 0x080,
398 			.num = { 8, 10, 10, 10, 10 },
399 			.src_descr = "Analogue %d",
400 			.src_num_offset = 1,
401 			.dst_descr = "Analogue Output %02d Playback"
402 		},
403 		[SCARLETT2_PORT_TYPE_SPDIF] = {
404 			/* S/PDIF outputs aren't available at 192kHz
405 			 * but are included in the USB mux I/O
406 			 * assignment message anyway
407 			 */
408 			.id = 0x180,
409 			.num = { 2, 2, 2, 2, 2 },
410 			.src_descr = "S/PDIF %d",
411 			.src_num_offset = 1,
412 			.dst_descr = "S/PDIF Output %d Playback"
413 		},
414 		[SCARLETT2_PORT_TYPE_ADAT] = {
415 			.id = 0x200,
416 			.num = { 8, 8, 8, 4, 0 },
417 			.src_descr = "ADAT %d",
418 			.src_num_offset = 1,
419 			.dst_descr = "ADAT Output %d Playback"
420 		},
421 		[SCARLETT2_PORT_TYPE_MIX] = {
422 			.id = 0x300,
423 			.num = { 10, 18, 18, 18, 18 },
424 			.src_descr = "Mix %c",
425 			.src_num_offset = 65,
426 			.dst_descr = "Mixer Input %02d Capture"
427 		},
428 		[SCARLETT2_PORT_TYPE_PCM] = {
429 			.id = 0x600,
430 			.num = { 20, 18, 18, 14, 10 },
431 			.src_descr = "PCM %d",
432 			.src_num_offset = 1,
433 			.dst_descr = "PCM %02d Capture"
434 		},
435 	},
436 };
437 
438 /* get the starting port index number for a given port type/direction */
scarlett2_get_port_start_num(const struct scarlett2_ports * ports,int direction,int port_type)439 static int scarlett2_get_port_start_num(const struct scarlett2_ports *ports,
440 					int direction, int port_type)
441 {
442 	int i, num = 0;
443 
444 	for (i = 0; i < port_type; i++)
445 		num += ports[i].num[direction];
446 
447 	return num;
448 }
449 
450 /*** USB Interactions ***/
451 
452 /* Vendor-Specific Interface, Endpoint, MaxPacketSize, Interval */
453 #define SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE 5
454 #define SCARLETT2_USB_INTERRUPT_ENDPOINT 4
455 #define SCARLETT2_USB_INTERRUPT_MAX_DATA 64
456 #define SCARLETT2_USB_INTERRUPT_INTERVAL 3
457 
458 /* Interrupt flags for volume and mute/dim button changes */
459 #define SCARLETT2_USB_INTERRUPT_VOL_CHANGE 0x400000
460 #define SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE 0x200000
461 
462 /* Commands for sending/receiving requests/responses */
463 #define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ 2
464 #define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP 3
465 
466 #define SCARLETT2_USB_INIT_SEQ 0x00000000
467 #define SCARLETT2_USB_GET_METER_LEVELS 0x00001001
468 #define SCARLETT2_USB_SET_MIX 0x00002002
469 #define SCARLETT2_USB_SET_MUX 0x00003002
470 #define SCARLETT2_USB_GET_DATA 0x00800000
471 #define SCARLETT2_USB_SET_DATA 0x00800001
472 #define SCARLETT2_USB_DATA_CMD 0x00800002
473 #define SCARLETT2_USB_CONFIG_SAVE 6
474 
475 #define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
476 #define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
477 
478 /* volume status is read together (matches scarlett2_config_items[]) */
479 struct scarlett2_usb_volume_status {
480 	/* mute & dim buttons */
481 	u8 buttons[SCARLETT2_BUTTON_MAX];
482 
483 	u8 pad1;
484 
485 	/* software volume setting */
486 	s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
487 
488 	/* actual volume of output inc. dim (-18dB) */
489 	s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
490 
491 	u8 pad2[SCARLETT2_ANALOGUE_MAX];
492 
493 	/* sw (0) or hw (1) controlled */
494 	u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
495 
496 	u8 pad3[6];
497 
498 	/* front panel volume knob */
499 	s16 master_vol;
500 } __packed;
501 
502 /* Configuration parameters that can be read and written */
503 enum {
504 	SCARLETT2_CONFIG_BUTTONS = 0,
505 	SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
506 	SCARLETT2_CONFIG_SW_HW_SWITCH = 2,
507 	SCARLETT2_CONFIG_LEVEL_SWITCH = 3,
508 	SCARLETT2_CONFIG_PAD_SWITCH = 4,
509 	SCARLETT2_CONFIG_COUNT = 5
510 };
511 
512 /* Location, size, and activation command number for the configuration
513  * parameters
514  */
515 struct scarlett2_config {
516 	u8 offset;
517 	u8 size;
518 	u8 activate;
519 };
520 
521 static const struct scarlett2_config
522 		scarlett2_config_items[SCARLETT2_CONFIG_COUNT] = {
523 	/* Mute/Dim Buttons */
524 	{
525 		.offset = 0x31,
526 		.size = 1,
527 		.activate = 2
528 	},
529 
530 	/* Line Out Volume */
531 	{
532 		.offset = 0x34,
533 		.size = 2,
534 		.activate = 1
535 	},
536 
537 	/* SW/HW Volume Switch */
538 	{
539 		.offset = 0x66,
540 		.size = 1,
541 		.activate = 3
542 	},
543 
544 	/* Level Switch */
545 	{
546 		.offset = 0x7c,
547 		.size = 1,
548 		.activate = 7
549 	},
550 
551 	/* Pad Switch */
552 	{
553 		.offset = 0x84,
554 		.size = 1,
555 		.activate = 8
556 	}
557 };
558 
559 /* proprietary request/response format */
560 struct scarlett2_usb_packet {
561 	__le32 cmd;
562 	__le16 size;
563 	__le16 seq;
564 	__le32 error;
565 	__le32 pad;
566 	u8 data[];
567 };
568 
569 #define SCARLETT2_USB_PACKET_LEN (sizeof(struct scarlett2_usb_packet))
570 
scarlett2_fill_request_header(struct scarlett2_mixer_data * private,struct scarlett2_usb_packet * req,u32 cmd,u16 req_size)571 static void scarlett2_fill_request_header(struct scarlett2_mixer_data *private,
572 					  struct scarlett2_usb_packet *req,
573 					  u32 cmd, u16 req_size)
574 {
575 	/* sequence must go up by 1 for each request */
576 	u16 seq = private->scarlett2_seq++;
577 
578 	req->cmd = cpu_to_le32(cmd);
579 	req->size = cpu_to_le16(req_size);
580 	req->seq = cpu_to_le16(seq);
581 	req->error = 0;
582 	req->pad = 0;
583 }
584 
585 /* 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)586 static int scarlett2_usb(
587 	struct usb_mixer_interface *mixer, u32 cmd,
588 	void *req_data, u16 req_size, void *resp_data, u16 resp_size)
589 {
590 	struct scarlett2_mixer_data *private = mixer->private_data;
591 	u16 req_buf_size = sizeof(struct scarlett2_usb_packet) + req_size;
592 	u16 resp_buf_size = sizeof(struct scarlett2_usb_packet) + resp_size;
593 	struct scarlett2_usb_packet *req = NULL, *resp = NULL;
594 	int err = 0;
595 
596 	req = kmalloc(req_buf_size, GFP_KERNEL);
597 	if (!req) {
598 		err = -ENOMEM;
599 		goto error;
600 	}
601 
602 	resp = kmalloc(resp_buf_size, GFP_KERNEL);
603 	if (!resp) {
604 		err = -ENOMEM;
605 		goto error;
606 	}
607 
608 	mutex_lock(&private->usb_mutex);
609 
610 	/* build request message and send it */
611 
612 	scarlett2_fill_request_header(private, req, cmd, req_size);
613 
614 	if (req_size)
615 		memcpy(req->data, req_data, req_size);
616 
617 	err = snd_usb_ctl_msg(mixer->chip->dev,
618 			usb_sndctrlpipe(mixer->chip->dev, 0),
619 			SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ,
620 			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
621 			0,
622 			SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
623 			req,
624 			req_buf_size);
625 
626 	if (err != req_buf_size) {
627 		usb_audio_err(
628 			mixer->chip,
629 			"Scarlett Gen 2 USB request result cmd %x was %d\n",
630 			cmd, err);
631 		err = -EINVAL;
632 		goto unlock;
633 	}
634 
635 	/* send a second message to get the response */
636 
637 	err = snd_usb_ctl_msg(mixer->chip->dev,
638 			usb_rcvctrlpipe(mixer->chip->dev, 0),
639 			SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP,
640 			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
641 			0,
642 			SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
643 			resp,
644 			resp_buf_size);
645 
646 	/* validate the response */
647 
648 	if (err != resp_buf_size) {
649 		usb_audio_err(
650 			mixer->chip,
651 			"Scarlett Gen 2 USB response result cmd %x was %d\n",
652 			cmd, err);
653 		err = -EINVAL;
654 		goto unlock;
655 	}
656 
657 	if (resp->cmd != req->cmd ||
658 	    resp->seq != req->seq ||
659 	    resp_size != le16_to_cpu(resp->size) ||
660 	    resp->error ||
661 	    resp->pad) {
662 		usb_audio_err(
663 			mixer->chip,
664 			"Scarlett Gen 2 USB invalid response; "
665 			   "cmd tx/rx %d/%d seq %d/%d size %d/%d "
666 			   "error %d pad %d\n",
667 			le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
668 			le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
669 			resp_size, le16_to_cpu(resp->size),
670 			le32_to_cpu(resp->error),
671 			le32_to_cpu(resp->pad));
672 		err = -EINVAL;
673 		goto unlock;
674 	}
675 
676 	if (resp_size > 0)
677 		memcpy(resp_data, resp->data, resp_size);
678 
679 unlock:
680 	mutex_unlock(&private->usb_mutex);
681 error:
682 	kfree(req);
683 	kfree(resp);
684 	return err;
685 }
686 
687 /* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
scarlett2_config_save(struct usb_mixer_interface * mixer)688 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
689 {
690 	__le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
691 
692 	scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
693 		      &req, sizeof(u32),
694 		      NULL, 0);
695 }
696 
697 /* Delayed work to save config */
scarlett2_config_save_work(struct work_struct * work)698 static void scarlett2_config_save_work(struct work_struct *work)
699 {
700 	struct scarlett2_mixer_data *private =
701 		container_of(work, struct scarlett2_mixer_data, work.work);
702 
703 	scarlett2_config_save(private->mixer);
704 }
705 
706 /* Send a USB message to set a configuration parameter (volume level,
707  * sw/hw volume switch, line/inst level switch, or pad switch)
708  */
scarlett2_usb_set_config(struct usb_mixer_interface * mixer,int config_item_num,int index,int value)709 static int scarlett2_usb_set_config(
710 	struct usb_mixer_interface *mixer,
711 	int config_item_num, int index, int value)
712 {
713 	const struct scarlett2_config config_item =
714 	       scarlett2_config_items[config_item_num];
715 	struct {
716 		__le32 offset;
717 		__le32 bytes;
718 		__le32 value;
719 	} __packed req;
720 	__le32 req2;
721 	int err;
722 	struct scarlett2_mixer_data *private = mixer->private_data;
723 
724 	/* Cancel any pending NVRAM save */
725 	cancel_delayed_work_sync(&private->work);
726 
727 	/* Send the configuration parameter data */
728 	req.offset = cpu_to_le32(config_item.offset + index * config_item.size);
729 	req.bytes = cpu_to_le32(config_item.size);
730 	req.value = cpu_to_le32(value);
731 	err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
732 			    &req, sizeof(u32) * 2 + config_item.size,
733 			    NULL, 0);
734 	if (err < 0)
735 		return err;
736 
737 	/* Activate the change */
738 	req2 = cpu_to_le32(config_item.activate);
739 	err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
740 			    &req2, sizeof(req2), NULL, 0);
741 	if (err < 0)
742 		return err;
743 
744 	/* Schedule the change to be written to NVRAM */
745 	schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
746 
747 	return 0;
748 }
749 
750 /* 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)751 static int scarlett2_usb_get(
752 	struct usb_mixer_interface *mixer,
753 	int offset, void *buf, int size)
754 {
755 	struct {
756 		__le32 offset;
757 		__le32 size;
758 	} __packed req;
759 
760 	req.offset = cpu_to_le32(offset);
761 	req.size = cpu_to_le32(size);
762 	return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
763 			     &req, sizeof(req), buf, size);
764 }
765 
766 /* 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)767 static int scarlett2_usb_get_config(
768 	struct usb_mixer_interface *mixer,
769 	int config_item_num, int count, void *buf)
770 {
771 	const struct scarlett2_config config_item =
772 	       scarlett2_config_items[config_item_num];
773 	int size = config_item.size * count;
774 
775 	return scarlett2_usb_get(mixer, config_item.offset, buf, size);
776 }
777 
778 /* Send a USB message to get volume status; result placed in *buf */
scarlett2_usb_get_volume_status(struct usb_mixer_interface * mixer,struct scarlett2_usb_volume_status * buf)779 static int scarlett2_usb_get_volume_status(
780 	struct usb_mixer_interface *mixer,
781 	struct scarlett2_usb_volume_status *buf)
782 {
783 	return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
784 				 buf, sizeof(*buf));
785 }
786 
787 /* Send a USB message to set the volumes for all inputs of one mix
788  * (values obtained from private->mix[])
789  */
scarlett2_usb_set_mix(struct usb_mixer_interface * mixer,int mix_num)790 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
791 				     int mix_num)
792 {
793 	struct scarlett2_mixer_data *private = mixer->private_data;
794 	const struct scarlett2_device_info *info = private->info;
795 
796 	struct {
797 		__le16 mix_num;
798 		__le16 data[SCARLETT2_INPUT_MIX_MAX];
799 	} __packed req;
800 
801 	int i, j;
802 	int num_mixer_in =
803 		info->ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
804 
805 	req.mix_num = cpu_to_le16(mix_num);
806 
807 	for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
808 		req.data[i] = cpu_to_le16(
809 			scarlett2_mixer_values[private->mix[j]]
810 		);
811 
812 	return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
813 			     &req, (num_mixer_in + 1) * sizeof(u16),
814 			     NULL, 0);
815 }
816 
817 /* Convert a port number index (per info->ports) to a hardware ID */
scarlett2_mux_src_num_to_id(const struct scarlett2_ports * ports,int num)818 static u32 scarlett2_mux_src_num_to_id(const struct scarlett2_ports *ports,
819 				       int num)
820 {
821 	int port_type;
822 
823 	for (port_type = 0;
824 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
825 	     port_type++) {
826 		if (num < ports[port_type].num[SCARLETT2_PORT_IN])
827 			return ports[port_type].id | num;
828 		num -= ports[port_type].num[SCARLETT2_PORT_IN];
829 	}
830 
831 	/* Oops */
832 	return 0;
833 }
834 
835 /* Send USB messages to set mux inputs */
scarlett2_usb_set_mux(struct usb_mixer_interface * mixer)836 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
837 {
838 	struct scarlett2_mixer_data *private = mixer->private_data;
839 	const struct scarlett2_device_info *info = private->info;
840 	const struct scarlett2_ports *ports = info->ports;
841 	int rate, port_dir_rate;
842 
843 	static const int assignment_order[SCARLETT2_PORT_TYPE_COUNT] = {
844 		SCARLETT2_PORT_TYPE_PCM,
845 		SCARLETT2_PORT_TYPE_ANALOGUE,
846 		SCARLETT2_PORT_TYPE_SPDIF,
847 		SCARLETT2_PORT_TYPE_ADAT,
848 		SCARLETT2_PORT_TYPE_MIX,
849 		SCARLETT2_PORT_TYPE_NONE,
850 	};
851 
852 	struct {
853 		__le16 pad;
854 		__le16 num;
855 		__le32 data[SCARLETT2_MUX_MAX];
856 	} __packed req;
857 
858 	req.pad = 0;
859 
860 	/* mux settings for each rate */
861 	for (rate = 0, port_dir_rate = SCARLETT2_PORT_OUT_44;
862 	     port_dir_rate <= SCARLETT2_PORT_OUT_176;
863 	     rate++, port_dir_rate++) {
864 		int order_num, i, err;
865 
866 		req.num = cpu_to_le16(rate);
867 
868 		for (order_num = 0, i = 0;
869 		     order_num < SCARLETT2_PORT_TYPE_COUNT;
870 		     order_num++) {
871 			int port_type = assignment_order[order_num];
872 			int j = scarlett2_get_port_start_num(ports,
873 							     SCARLETT2_PORT_OUT,
874 							     port_type);
875 			int port_id = ports[port_type].id;
876 			int channel;
877 
878 			for (channel = 0;
879 			     channel < ports[port_type].num[port_dir_rate];
880 			     channel++, i++, j++)
881 				/* lower 12 bits for the destination and
882 				 * next 12 bits for the source
883 				 */
884 				req.data[i] = !port_id
885 					? 0
886 					: cpu_to_le32(
887 						port_id |
888 						channel |
889 						scarlett2_mux_src_num_to_id(
890 							ports, private->mux[j]
891 						) << 12
892 					  );
893 
894 			/* skip private->mux[j] entries not output */
895 			j += ports[port_type].num[SCARLETT2_PORT_OUT] -
896 			     ports[port_type].num[port_dir_rate];
897 		}
898 
899 		err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
900 				    &req, (i + 1) * sizeof(u32),
901 				    NULL, 0);
902 		if (err < 0)
903 			return err;
904 	}
905 
906 	return 0;
907 }
908 
909 /* Send USB message to get meter levels */
scarlett2_usb_get_meter_levels(struct usb_mixer_interface * mixer,u16 * levels)910 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
911 					  u16 *levels)
912 {
913 	struct {
914 		__le16 pad;
915 		__le16 num_meters;
916 		__le32 magic;
917 	} __packed req;
918 	u32 resp[SCARLETT2_NUM_METERS];
919 	int i, err;
920 
921 	req.pad = 0;
922 	req.num_meters = cpu_to_le16(SCARLETT2_NUM_METERS);
923 	req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
924 	err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER_LEVELS,
925 			    &req, sizeof(req), resp, sizeof(resp));
926 	if (err < 0)
927 		return err;
928 
929 	/* copy, convert to u16 */
930 	for (i = 0; i < SCARLETT2_NUM_METERS; i++)
931 		levels[i] = resp[i];
932 
933 	return 0;
934 }
935 
936 /*** Control Functions ***/
937 
938 /* 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)939 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
940 				 const struct snd_kcontrol_new *ncontrol,
941 				 int index, int channels, const char *name,
942 				 struct snd_kcontrol **kctl_return)
943 {
944 	struct snd_kcontrol *kctl;
945 	struct usb_mixer_elem_info *elem;
946 	int err;
947 
948 	elem = kzalloc(sizeof(*elem), GFP_KERNEL);
949 	if (!elem)
950 		return -ENOMEM;
951 
952 	/* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
953 	 * ignores them for resume and other operations.
954 	 * Also, the head.id field is set to 0, as we don't use this field.
955 	 */
956 	elem->head.mixer = mixer;
957 	elem->control = index;
958 	elem->head.id = 0;
959 	elem->channels = channels;
960 	elem->val_type = USB_MIXER_BESPOKEN;
961 
962 	kctl = snd_ctl_new1(ncontrol, elem);
963 	if (!kctl) {
964 		kfree(elem);
965 		return -ENOMEM;
966 	}
967 	kctl->private_free = snd_usb_mixer_elem_free;
968 
969 	strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
970 
971 	err = snd_usb_mixer_add_control(&elem->head, kctl);
972 	if (err < 0)
973 		return err;
974 
975 	if (kctl_return)
976 		*kctl_return = kctl;
977 
978 	return 0;
979 }
980 
981 /*** Analogue Line Out Volume Controls ***/
982 
983 /* Update hardware volume controls after receiving notification that
984  * they have changed
985  */
scarlett2_update_volumes(struct usb_mixer_interface * mixer)986 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
987 {
988 	struct scarlett2_mixer_data *private = mixer->private_data;
989 	const struct scarlett2_ports *ports = private->info->ports;
990 	struct scarlett2_usb_volume_status volume_status;
991 	int num_line_out =
992 		ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
993 	int err, i;
994 
995 	private->vol_updated = 0;
996 
997 	err = scarlett2_usb_get_volume_status(mixer, &volume_status);
998 	if (err < 0)
999 		return err;
1000 
1001 	private->master_vol = clamp(
1002 		volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1003 		0, SCARLETT2_VOLUME_BIAS);
1004 
1005 	for (i = 0; i < num_line_out; i++) {
1006 		if (private->vol_sw_hw_switch[i])
1007 			private->vol[i] = private->master_vol;
1008 	}
1009 
1010 	for (i = 0; i < private->info->button_count; i++)
1011 		private->buttons[i] = !!volume_status.buttons[i];
1012 
1013 	return 0;
1014 }
1015 
scarlett2_volume_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1016 static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
1017 				     struct snd_ctl_elem_info *uinfo)
1018 {
1019 	struct usb_mixer_elem_info *elem = kctl->private_data;
1020 
1021 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1022 	uinfo->count = elem->channels;
1023 	uinfo->value.integer.min = 0;
1024 	uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
1025 	uinfo->value.integer.step = 1;
1026 	return 0;
1027 }
1028 
scarlett2_master_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1029 static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
1030 					   struct snd_ctl_elem_value *ucontrol)
1031 {
1032 	struct usb_mixer_elem_info *elem = kctl->private_data;
1033 	struct usb_mixer_interface *mixer = elem->head.mixer;
1034 	struct scarlett2_mixer_data *private = mixer->private_data;
1035 
1036 	mutex_lock(&private->data_mutex);
1037 	if (private->vol_updated)
1038 		scarlett2_update_volumes(mixer);
1039 	mutex_unlock(&private->data_mutex);
1040 
1041 	ucontrol->value.integer.value[0] = private->master_vol;
1042 	return 0;
1043 }
1044 
scarlett2_volume_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1045 static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
1046 				    struct snd_ctl_elem_value *ucontrol)
1047 {
1048 	struct usb_mixer_elem_info *elem = kctl->private_data;
1049 	struct usb_mixer_interface *mixer = elem->head.mixer;
1050 	struct scarlett2_mixer_data *private = mixer->private_data;
1051 	int index = elem->control;
1052 
1053 	mutex_lock(&private->data_mutex);
1054 	if (private->vol_updated)
1055 		scarlett2_update_volumes(mixer);
1056 	mutex_unlock(&private->data_mutex);
1057 
1058 	ucontrol->value.integer.value[0] = private->vol[index];
1059 	return 0;
1060 }
1061 
scarlett2_volume_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1062 static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
1063 				    struct snd_ctl_elem_value *ucontrol)
1064 {
1065 	struct usb_mixer_elem_info *elem = kctl->private_data;
1066 	struct usb_mixer_interface *mixer = elem->head.mixer;
1067 	struct scarlett2_mixer_data *private = mixer->private_data;
1068 	int index = elem->control;
1069 	int oval, val, err = 0;
1070 
1071 	mutex_lock(&private->data_mutex);
1072 
1073 	oval = private->vol[index];
1074 	val = ucontrol->value.integer.value[0];
1075 
1076 	if (oval == val)
1077 		goto unlock;
1078 
1079 	private->vol[index] = val;
1080 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1081 				       index, val - SCARLETT2_VOLUME_BIAS);
1082 	if (err == 0)
1083 		err = 1;
1084 
1085 unlock:
1086 	mutex_unlock(&private->data_mutex);
1087 	return err;
1088 }
1089 
1090 static const DECLARE_TLV_DB_MINMAX(
1091 	db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
1092 );
1093 
1094 static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
1095 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1096 	.access = SNDRV_CTL_ELEM_ACCESS_READ |
1097 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1098 	.name = "",
1099 	.info = scarlett2_volume_ctl_info,
1100 	.get  = scarlett2_master_volume_ctl_get,
1101 	.private_value = 0, /* max value */
1102 	.tlv = { .p = db_scale_scarlett2_gain }
1103 };
1104 
1105 static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
1106 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1107 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1108 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1109 	.name = "",
1110 	.info = scarlett2_volume_ctl_info,
1111 	.get  = scarlett2_volume_ctl_get,
1112 	.put  = scarlett2_volume_ctl_put,
1113 	.private_value = 0, /* max value */
1114 	.tlv = { .p = db_scale_scarlett2_gain }
1115 };
1116 
1117 /*** HW/SW Volume Switch Controls ***/
1118 
scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1119 static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
1120 					 struct snd_ctl_elem_info *uinfo)
1121 {
1122 	static const char *const values[2] = {
1123 		"SW", "HW"
1124 	};
1125 
1126 	return snd_ctl_enum_info(uinfo, 1, 2, values);
1127 }
1128 
scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1129 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
1130 					struct snd_ctl_elem_value *ucontrol)
1131 {
1132 	struct usb_mixer_elem_info *elem = kctl->private_data;
1133 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1134 
1135 	ucontrol->value.enumerated.item[0] =
1136 		private->vol_sw_hw_switch[elem->control];
1137 	return 0;
1138 }
1139 
scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1140 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
1141 					struct snd_ctl_elem_value *ucontrol)
1142 {
1143 	struct usb_mixer_elem_info *elem = kctl->private_data;
1144 	struct usb_mixer_interface *mixer = elem->head.mixer;
1145 	struct scarlett2_mixer_data *private = mixer->private_data;
1146 
1147 	int index = elem->control;
1148 	int oval, val, err = 0;
1149 
1150 	mutex_lock(&private->data_mutex);
1151 
1152 	oval = private->vol_sw_hw_switch[index];
1153 	val = !!ucontrol->value.integer.value[0];
1154 
1155 	if (oval == val)
1156 		goto unlock;
1157 
1158 	private->vol_sw_hw_switch[index] = val;
1159 
1160 	/* Change access mode to RO (hardware controlled volume)
1161 	 * or RW (software controlled volume)
1162 	 */
1163 	if (val)
1164 		private->vol_ctls[index]->vd[0].access &=
1165 			~SNDRV_CTL_ELEM_ACCESS_WRITE;
1166 	else
1167 		private->vol_ctls[index]->vd[0].access |=
1168 			SNDRV_CTL_ELEM_ACCESS_WRITE;
1169 
1170 	/* Reset volume to master volume */
1171 	private->vol[index] = private->master_vol;
1172 
1173 	/* Set SW volume to current HW volume */
1174 	err = scarlett2_usb_set_config(
1175 		mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1176 		index, private->master_vol - SCARLETT2_VOLUME_BIAS);
1177 	if (err < 0)
1178 		goto unlock;
1179 
1180 	/* Notify of RO/RW change */
1181 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_INFO,
1182 		       &private->vol_ctls[index]->id);
1183 
1184 	/* Send SW/HW switch change to the device */
1185 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
1186 				       index, val);
1187 	if (err == 0)
1188 		err = 1;
1189 
1190 unlock:
1191 	mutex_unlock(&private->data_mutex);
1192 	return err;
1193 }
1194 
1195 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
1196 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1197 	.name = "",
1198 	.info = scarlett2_sw_hw_enum_ctl_info,
1199 	.get  = scarlett2_sw_hw_enum_ctl_get,
1200 	.put  = scarlett2_sw_hw_enum_ctl_put,
1201 };
1202 
1203 /*** Line Level/Instrument Level Switch Controls ***/
1204 
scarlett2_level_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1205 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
1206 					 struct snd_ctl_elem_info *uinfo)
1207 {
1208 	static const char *const values[2] = {
1209 		"Line", "Inst"
1210 	};
1211 
1212 	return snd_ctl_enum_info(uinfo, 1, 2, values);
1213 }
1214 
scarlett2_level_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1215 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
1216 					struct snd_ctl_elem_value *ucontrol)
1217 {
1218 	struct usb_mixer_elem_info *elem = kctl->private_data;
1219 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1220 
1221 	ucontrol->value.enumerated.item[0] =
1222 		private->level_switch[elem->control];
1223 	return 0;
1224 }
1225 
scarlett2_level_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1226 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
1227 					struct snd_ctl_elem_value *ucontrol)
1228 {
1229 	struct usb_mixer_elem_info *elem = kctl->private_data;
1230 	struct usb_mixer_interface *mixer = elem->head.mixer;
1231 	struct scarlett2_mixer_data *private = mixer->private_data;
1232 
1233 	int index = elem->control;
1234 	int oval, val, err = 0;
1235 
1236 	mutex_lock(&private->data_mutex);
1237 
1238 	oval = private->level_switch[index];
1239 	val = !!ucontrol->value.integer.value[0];
1240 
1241 	if (oval == val)
1242 		goto unlock;
1243 
1244 	private->level_switch[index] = val;
1245 
1246 	/* Send switch change to the device */
1247 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
1248 				       index, val);
1249 	if (err == 0)
1250 		err = 1;
1251 
1252 unlock:
1253 	mutex_unlock(&private->data_mutex);
1254 	return err;
1255 }
1256 
1257 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
1258 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1259 	.name = "",
1260 	.info = scarlett2_level_enum_ctl_info,
1261 	.get  = scarlett2_level_enum_ctl_get,
1262 	.put  = scarlett2_level_enum_ctl_put,
1263 };
1264 
1265 /*** Pad Switch Controls ***/
1266 
scarlett2_pad_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1267 static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
1268 				 struct snd_ctl_elem_value *ucontrol)
1269 {
1270 	struct usb_mixer_elem_info *elem = kctl->private_data;
1271 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1272 
1273 	ucontrol->value.enumerated.item[0] =
1274 		private->pad_switch[elem->control];
1275 	return 0;
1276 }
1277 
scarlett2_pad_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1278 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
1279 				 struct snd_ctl_elem_value *ucontrol)
1280 {
1281 	struct usb_mixer_elem_info *elem = kctl->private_data;
1282 	struct usb_mixer_interface *mixer = elem->head.mixer;
1283 	struct scarlett2_mixer_data *private = mixer->private_data;
1284 
1285 	int index = elem->control;
1286 	int oval, val, err = 0;
1287 
1288 	mutex_lock(&private->data_mutex);
1289 
1290 	oval = private->pad_switch[index];
1291 	val = !!ucontrol->value.integer.value[0];
1292 
1293 	if (oval == val)
1294 		goto unlock;
1295 
1296 	private->pad_switch[index] = val;
1297 
1298 	/* Send switch change to the device */
1299 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
1300 				       index, val);
1301 	if (err == 0)
1302 		err = 1;
1303 
1304 unlock:
1305 	mutex_unlock(&private->data_mutex);
1306 	return err;
1307 }
1308 
1309 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
1310 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1311 	.name = "",
1312 	.info = snd_ctl_boolean_mono_info,
1313 	.get  = scarlett2_pad_ctl_get,
1314 	.put  = scarlett2_pad_ctl_put,
1315 };
1316 
1317 /*** Mute/Dim Controls ***/
1318 
scarlett2_button_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1319 static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl,
1320 				    struct snd_ctl_elem_value *ucontrol)
1321 {
1322 	struct usb_mixer_elem_info *elem = kctl->private_data;
1323 	struct usb_mixer_interface *mixer = elem->head.mixer;
1324 	struct scarlett2_mixer_data *private = mixer->private_data;
1325 
1326 	mutex_lock(&private->data_mutex);
1327 	if (private->vol_updated)
1328 		scarlett2_update_volumes(mixer);
1329 	mutex_unlock(&private->data_mutex);
1330 
1331 	ucontrol->value.enumerated.item[0] = private->buttons[elem->control];
1332 	return 0;
1333 }
1334 
scarlett2_button_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1335 static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl,
1336 				    struct snd_ctl_elem_value *ucontrol)
1337 {
1338 	struct usb_mixer_elem_info *elem = kctl->private_data;
1339 	struct usb_mixer_interface *mixer = elem->head.mixer;
1340 	struct scarlett2_mixer_data *private = mixer->private_data;
1341 
1342 	int index = elem->control;
1343 	int oval, val, err = 0;
1344 
1345 	mutex_lock(&private->data_mutex);
1346 
1347 	oval = private->buttons[index];
1348 	val = !!ucontrol->value.integer.value[0];
1349 
1350 	if (oval == val)
1351 		goto unlock;
1352 
1353 	private->buttons[index] = val;
1354 
1355 	/* Send switch change to the device */
1356 	err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS,
1357 				       index, val);
1358 	if (err == 0)
1359 		err = 1;
1360 
1361 unlock:
1362 	mutex_unlock(&private->data_mutex);
1363 	return err;
1364 }
1365 
1366 static const struct snd_kcontrol_new scarlett2_button_ctl = {
1367 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1368 	.name = "",
1369 	.info = snd_ctl_boolean_mono_info,
1370 	.get  = scarlett2_button_ctl_get,
1371 	.put  = scarlett2_button_ctl_put
1372 };
1373 
1374 /*** Create the analogue output controls ***/
1375 
scarlett2_add_line_out_ctls(struct usb_mixer_interface * mixer)1376 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
1377 {
1378 	struct scarlett2_mixer_data *private = mixer->private_data;
1379 	const struct scarlett2_device_info *info = private->info;
1380 	const struct scarlett2_ports *ports = info->ports;
1381 	int num_line_out =
1382 		ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1383 	int err, i;
1384 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1385 
1386 	/* Add R/O HW volume control */
1387 	if (info->line_out_hw_vol) {
1388 		snprintf(s, sizeof(s), "Master HW Playback Volume");
1389 		err = scarlett2_add_new_ctl(mixer,
1390 					    &scarlett2_master_volume_ctl,
1391 					    0, 1, s, &private->master_vol_ctl);
1392 		if (err < 0)
1393 			return err;
1394 	}
1395 
1396 	/* Add volume controls */
1397 	for (i = 0; i < num_line_out; i++) {
1398 
1399 		/* Fader */
1400 		if (info->line_out_descrs[i])
1401 			snprintf(s, sizeof(s),
1402 				 "Line %02d (%s) Playback Volume",
1403 				 i + 1, info->line_out_descrs[i]);
1404 		else
1405 			snprintf(s, sizeof(s),
1406 				 "Line %02d Playback Volume",
1407 				 i + 1);
1408 		err = scarlett2_add_new_ctl(mixer,
1409 					    &scarlett2_line_out_volume_ctl,
1410 					    i, 1, s, &private->vol_ctls[i]);
1411 		if (err < 0)
1412 			return err;
1413 
1414 		/* Make the fader read-only if the SW/HW switch is set to HW */
1415 		if (private->vol_sw_hw_switch[i])
1416 			private->vol_ctls[i]->vd[0].access &=
1417 				~SNDRV_CTL_ELEM_ACCESS_WRITE;
1418 
1419 		/* SW/HW Switch */
1420 		if (info->line_out_hw_vol) {
1421 			snprintf(s, sizeof(s),
1422 				 "Line Out %02d Volume Control Playback Enum",
1423 				 i + 1);
1424 			err = scarlett2_add_new_ctl(mixer,
1425 						    &scarlett2_sw_hw_enum_ctl,
1426 						    i, 1, s, NULL);
1427 			if (err < 0)
1428 				return err;
1429 		}
1430 	}
1431 
1432 	/* Add HW button controls */
1433 	for (i = 0; i < private->info->button_count; i++) {
1434 		err = scarlett2_add_new_ctl(mixer, &scarlett2_button_ctl,
1435 					    i, 1, scarlett2_button_names[i],
1436 					    &private->button_ctls[i]);
1437 		if (err < 0)
1438 			return err;
1439 	}
1440 
1441 	return 0;
1442 }
1443 
1444 /*** Create the analogue input controls ***/
1445 
scarlett2_add_line_in_ctls(struct usb_mixer_interface * mixer)1446 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
1447 {
1448 	struct scarlett2_mixer_data *private = mixer->private_data;
1449 	const struct scarlett2_device_info *info = private->info;
1450 	int err, i;
1451 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1452 
1453 	/* Add input level (line/inst) controls */
1454 	for (i = 0; i < info->level_input_count; i++) {
1455 		snprintf(s, sizeof(s), "Line In %d Level Capture Enum", i + 1);
1456 		err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
1457 					    i, 1, s, NULL);
1458 		if (err < 0)
1459 			return err;
1460 	}
1461 
1462 	/* Add input pad controls */
1463 	for (i = 0; i < info->pad_input_count; i++) {
1464 		snprintf(s, sizeof(s), "Line In %d Pad Capture Switch", i + 1);
1465 		err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
1466 					    i, 1, s, NULL);
1467 		if (err < 0)
1468 			return err;
1469 	}
1470 
1471 	return 0;
1472 }
1473 
1474 /*** Mixer Volume Controls ***/
1475 
scarlett2_mixer_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1476 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
1477 				    struct snd_ctl_elem_info *uinfo)
1478 {
1479 	struct usb_mixer_elem_info *elem = kctl->private_data;
1480 
1481 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1482 	uinfo->count = elem->channels;
1483 	uinfo->value.integer.min = 0;
1484 	uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
1485 	uinfo->value.integer.step = 1;
1486 	return 0;
1487 }
1488 
scarlett2_mixer_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1489 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
1490 				   struct snd_ctl_elem_value *ucontrol)
1491 {
1492 	struct usb_mixer_elem_info *elem = kctl->private_data;
1493 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1494 
1495 	ucontrol->value.integer.value[0] = private->mix[elem->control];
1496 	return 0;
1497 }
1498 
scarlett2_mixer_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1499 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
1500 				   struct snd_ctl_elem_value *ucontrol)
1501 {
1502 	struct usb_mixer_elem_info *elem = kctl->private_data;
1503 	struct usb_mixer_interface *mixer = elem->head.mixer;
1504 	struct scarlett2_mixer_data *private = mixer->private_data;
1505 	const struct scarlett2_device_info *info = private->info;
1506 	const struct scarlett2_ports *ports = info->ports;
1507 	int oval, val, num_mixer_in, mix_num, err = 0;
1508 
1509 	mutex_lock(&private->data_mutex);
1510 
1511 	oval = private->mix[elem->control];
1512 	val = ucontrol->value.integer.value[0];
1513 	num_mixer_in = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
1514 	mix_num = elem->control / num_mixer_in;
1515 
1516 	if (oval == val)
1517 		goto unlock;
1518 
1519 	private->mix[elem->control] = val;
1520 	err = scarlett2_usb_set_mix(mixer, mix_num);
1521 	if (err == 0)
1522 		err = 1;
1523 
1524 unlock:
1525 	mutex_unlock(&private->data_mutex);
1526 	return err;
1527 }
1528 
1529 static const DECLARE_TLV_DB_MINMAX(
1530 	db_scale_scarlett2_mixer,
1531 	SCARLETT2_MIXER_MIN_DB * 100,
1532 	SCARLETT2_MIXER_MAX_DB * 100
1533 );
1534 
1535 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
1536 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1537 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1538 		  SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1539 	.name = "",
1540 	.info = scarlett2_mixer_ctl_info,
1541 	.get  = scarlett2_mixer_ctl_get,
1542 	.put  = scarlett2_mixer_ctl_put,
1543 	.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
1544 	.tlv = { .p = db_scale_scarlett2_mixer }
1545 };
1546 
scarlett2_add_mixer_ctls(struct usb_mixer_interface * mixer)1547 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
1548 {
1549 	struct scarlett2_mixer_data *private = mixer->private_data;
1550 	const struct scarlett2_ports *ports = private->info->ports;
1551 	int err, i, j;
1552 	int index;
1553 	char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1554 
1555 	int num_inputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
1556 	int num_outputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_IN];
1557 
1558 	for (i = 0, index = 0; i < num_outputs; i++) {
1559 		for (j = 0; j < num_inputs; j++, index++) {
1560 			snprintf(s, sizeof(s),
1561 				 "Mix %c Input %02d Playback Volume",
1562 				 'A' + i, j + 1);
1563 			err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
1564 						    index, 1, s, NULL);
1565 			if (err < 0)
1566 				return err;
1567 		}
1568 	}
1569 
1570 	return 0;
1571 }
1572 
1573 /*** Mux Source Selection Controls ***/
1574 
scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1575 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
1576 					   struct snd_ctl_elem_info *uinfo)
1577 {
1578 	struct usb_mixer_elem_info *elem = kctl->private_data;
1579 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1580 	const struct scarlett2_ports *ports = private->info->ports;
1581 	unsigned int item = uinfo->value.enumerated.item;
1582 	int items = private->num_mux_srcs;
1583 	int port_type;
1584 
1585 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1586 	uinfo->count = elem->channels;
1587 	uinfo->value.enumerated.items = items;
1588 
1589 	if (item >= items)
1590 		item = uinfo->value.enumerated.item = items - 1;
1591 
1592 	for (port_type = 0;
1593 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
1594 	     port_type++) {
1595 		if (item < ports[port_type].num[SCARLETT2_PORT_IN]) {
1596 			sprintf(uinfo->value.enumerated.name,
1597 				ports[port_type].src_descr,
1598 				item + ports[port_type].src_num_offset);
1599 			return 0;
1600 		}
1601 		item -= ports[port_type].num[SCARLETT2_PORT_IN];
1602 	}
1603 
1604 	return -EINVAL;
1605 }
1606 
scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1607 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
1608 					  struct snd_ctl_elem_value *ucontrol)
1609 {
1610 	struct usb_mixer_elem_info *elem = kctl->private_data;
1611 	struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1612 
1613 	ucontrol->value.enumerated.item[0] = private->mux[elem->control];
1614 	return 0;
1615 }
1616 
scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1617 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
1618 					  struct snd_ctl_elem_value *ucontrol)
1619 {
1620 	struct usb_mixer_elem_info *elem = kctl->private_data;
1621 	struct usb_mixer_interface *mixer = elem->head.mixer;
1622 	struct scarlett2_mixer_data *private = mixer->private_data;
1623 	int index = elem->control;
1624 	int oval, val, err = 0;
1625 
1626 	mutex_lock(&private->data_mutex);
1627 
1628 	oval = private->mux[index];
1629 	val = clamp(ucontrol->value.integer.value[0],
1630 		    0L, private->num_mux_srcs - 1L);
1631 
1632 	if (oval == val)
1633 		goto unlock;
1634 
1635 	private->mux[index] = val;
1636 	err = scarlett2_usb_set_mux(mixer);
1637 	if (err == 0)
1638 		err = 1;
1639 
1640 unlock:
1641 	mutex_unlock(&private->data_mutex);
1642 	return err;
1643 }
1644 
1645 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
1646 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1647 	.name = "",
1648 	.info = scarlett2_mux_src_enum_ctl_info,
1649 	.get  = scarlett2_mux_src_enum_ctl_get,
1650 	.put  = scarlett2_mux_src_enum_ctl_put,
1651 };
1652 
scarlett2_add_mux_enums(struct usb_mixer_interface * mixer)1653 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
1654 {
1655 	struct scarlett2_mixer_data *private = mixer->private_data;
1656 	const struct scarlett2_ports *ports = private->info->ports;
1657 	int port_type, channel, i;
1658 
1659 	for (i = 0, port_type = 0;
1660 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
1661 	     port_type++) {
1662 		for (channel = 0;
1663 		     channel < ports[port_type].num[SCARLETT2_PORT_OUT];
1664 		     channel++, i++) {
1665 			int err;
1666 			char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1667 			const char *const descr = ports[port_type].dst_descr;
1668 
1669 			snprintf(s, sizeof(s) - 5, descr, channel + 1);
1670 			strcat(s, " Enum");
1671 
1672 			err = scarlett2_add_new_ctl(mixer,
1673 						    &scarlett2_mux_src_enum_ctl,
1674 						    i, 1, s, NULL);
1675 			if (err < 0)
1676 				return err;
1677 		}
1678 	}
1679 
1680 	return 0;
1681 }
1682 
1683 /*** Meter Controls ***/
1684 
scarlett2_meter_ctl_info(struct snd_kcontrol * kctl,struct snd_ctl_elem_info * uinfo)1685 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
1686 				    struct snd_ctl_elem_info *uinfo)
1687 {
1688 	struct usb_mixer_elem_info *elem = kctl->private_data;
1689 
1690 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1691 	uinfo->count = elem->channels;
1692 	uinfo->value.integer.min = 0;
1693 	uinfo->value.integer.max = 4095;
1694 	uinfo->value.integer.step = 1;
1695 	return 0;
1696 }
1697 
scarlett2_meter_ctl_get(struct snd_kcontrol * kctl,struct snd_ctl_elem_value * ucontrol)1698 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
1699 				   struct snd_ctl_elem_value *ucontrol)
1700 {
1701 	struct usb_mixer_elem_info *elem = kctl->private_data;
1702 	u16 meter_levels[SCARLETT2_NUM_METERS];
1703 	int i, err;
1704 
1705 	err = scarlett2_usb_get_meter_levels(elem->head.mixer, meter_levels);
1706 	if (err < 0)
1707 		return err;
1708 
1709 	for (i = 0; i < elem->channels; i++)
1710 		ucontrol->value.integer.value[i] = meter_levels[i];
1711 
1712 	return 0;
1713 }
1714 
1715 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
1716 	.iface = SNDRV_CTL_ELEM_IFACE_PCM,
1717 	.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1718 	.name = "",
1719 	.info = scarlett2_meter_ctl_info,
1720 	.get  = scarlett2_meter_ctl_get
1721 };
1722 
scarlett2_add_meter_ctl(struct usb_mixer_interface * mixer)1723 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
1724 {
1725 	return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
1726 				     0, SCARLETT2_NUM_METERS,
1727 				     "Level Meter", NULL);
1728 }
1729 
1730 /*** Cleanup/Suspend Callbacks ***/
1731 
scarlett2_private_free(struct usb_mixer_interface * mixer)1732 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
1733 {
1734 	struct scarlett2_mixer_data *private = mixer->private_data;
1735 
1736 	cancel_delayed_work_sync(&private->work);
1737 	kfree(private);
1738 	mixer->private_data = NULL;
1739 }
1740 
scarlett2_private_suspend(struct usb_mixer_interface * mixer)1741 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
1742 {
1743 	struct scarlett2_mixer_data *private = mixer->private_data;
1744 
1745 	if (cancel_delayed_work_sync(&private->work))
1746 		scarlett2_config_save(private->mixer);
1747 }
1748 
1749 /*** Initialisation ***/
1750 
scarlett2_count_mux_srcs(const struct scarlett2_ports * ports)1751 static int scarlett2_count_mux_srcs(const struct scarlett2_ports *ports)
1752 {
1753 	int port_type, count = 0;
1754 
1755 	for (port_type = 0;
1756 	     port_type < SCARLETT2_PORT_TYPE_COUNT;
1757 	     port_type++)
1758 		count += ports[port_type].num[SCARLETT2_PORT_IN];
1759 
1760 	return count;
1761 }
1762 
1763 /* Default routing connects PCM outputs and inputs to Analogue,
1764  * S/PDIF, then ADAT
1765  */
scarlett2_init_routing(u8 * mux,const struct scarlett2_ports * ports)1766 static void scarlett2_init_routing(u8 *mux,
1767 				   const struct scarlett2_ports *ports)
1768 {
1769 	int i, input_num, input_count, port_type;
1770 	int output_num, output_count, port_type_connect_num;
1771 
1772 	static const int connect_order[] = {
1773 		SCARLETT2_PORT_TYPE_ANALOGUE,
1774 		SCARLETT2_PORT_TYPE_SPDIF,
1775 		SCARLETT2_PORT_TYPE_ADAT,
1776 		-1
1777 	};
1778 
1779 	/* Assign PCM inputs (routing outputs) */
1780 	output_num = scarlett2_get_port_start_num(ports,
1781 						  SCARLETT2_PORT_OUT,
1782 						  SCARLETT2_PORT_TYPE_PCM);
1783 	output_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_OUT];
1784 
1785 	for (port_type = connect_order[port_type_connect_num = 0];
1786 	     port_type >= 0;
1787 	     port_type = connect_order[++port_type_connect_num]) {
1788 		input_num = scarlett2_get_port_start_num(
1789 			ports, SCARLETT2_PORT_IN, port_type);
1790 		input_count = ports[port_type].num[SCARLETT2_PORT_IN];
1791 		for (i = 0;
1792 		     i < input_count && output_count;
1793 		     i++, output_count--)
1794 			mux[output_num++] = input_num++;
1795 	}
1796 
1797 	/* Assign PCM outputs (routing inputs) */
1798 	input_num = scarlett2_get_port_start_num(ports,
1799 						 SCARLETT2_PORT_IN,
1800 						 SCARLETT2_PORT_TYPE_PCM);
1801 	input_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_IN];
1802 
1803 	for (port_type = connect_order[port_type_connect_num = 0];
1804 	     port_type >= 0;
1805 	     port_type = connect_order[++port_type_connect_num]) {
1806 		output_num = scarlett2_get_port_start_num(
1807 			ports, SCARLETT2_PORT_OUT, port_type);
1808 		output_count = ports[port_type].num[SCARLETT2_PORT_OUT];
1809 		for (i = 0;
1810 		     i < output_count && input_count;
1811 		     i++, input_count--)
1812 			mux[output_num++] = input_num++;
1813 	}
1814 }
1815 
1816 /* Initialise private data, routing, sequence number */
scarlett2_init_private(struct usb_mixer_interface * mixer,const struct scarlett2_device_info * info)1817 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
1818 				  const struct scarlett2_device_info *info)
1819 {
1820 	struct scarlett2_mixer_data *private =
1821 		kzalloc(sizeof(struct scarlett2_mixer_data), GFP_KERNEL);
1822 
1823 	if (!private)
1824 		return -ENOMEM;
1825 
1826 	mutex_init(&private->usb_mutex);
1827 	mutex_init(&private->data_mutex);
1828 	INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
1829 	private->info = info;
1830 	private->num_mux_srcs = scarlett2_count_mux_srcs(info->ports);
1831 	private->scarlett2_seq = 0;
1832 	private->mixer = mixer;
1833 	mixer->private_data = private;
1834 	mixer->private_free = scarlett2_private_free;
1835 	mixer->private_suspend = scarlett2_private_suspend;
1836 
1837 	/* Setup default routing */
1838 	scarlett2_init_routing(private->mux, info->ports);
1839 
1840 	/* Initialise the sequence number used for the proprietary commands */
1841 	return scarlett2_usb(mixer, SCARLETT2_USB_INIT_SEQ, NULL, 0, NULL, 0);
1842 }
1843 
1844 /* Read line-in config and line-out volume settings on start */
scarlett2_read_configs(struct usb_mixer_interface * mixer)1845 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
1846 {
1847 	struct scarlett2_mixer_data *private = mixer->private_data;
1848 	const struct scarlett2_device_info *info = private->info;
1849 	const struct scarlett2_ports *ports = info->ports;
1850 	int num_line_out =
1851 		ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1852 	u8 level_switches[SCARLETT2_LEVEL_SWITCH_MAX];
1853 	u8 pad_switches[SCARLETT2_PAD_SWITCH_MAX];
1854 	struct scarlett2_usb_volume_status volume_status;
1855 	int err, i;
1856 
1857 	if (info->level_input_count) {
1858 		err = scarlett2_usb_get_config(
1859 			mixer,
1860 			SCARLETT2_CONFIG_LEVEL_SWITCH,
1861 			info->level_input_count,
1862 			level_switches);
1863 		if (err < 0)
1864 			return err;
1865 		for (i = 0; i < info->level_input_count; i++)
1866 			private->level_switch[i] = level_switches[i];
1867 	}
1868 
1869 	if (info->pad_input_count) {
1870 		err = scarlett2_usb_get_config(
1871 			mixer,
1872 			SCARLETT2_CONFIG_PAD_SWITCH,
1873 			info->pad_input_count,
1874 			pad_switches);
1875 		if (err < 0)
1876 			return err;
1877 		for (i = 0; i < info->pad_input_count; i++)
1878 			private->pad_switch[i] = pad_switches[i];
1879 	}
1880 
1881 	err = scarlett2_usb_get_volume_status(mixer, &volume_status);
1882 	if (err < 0)
1883 		return err;
1884 
1885 	private->master_vol = clamp(
1886 		volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1887 		0, SCARLETT2_VOLUME_BIAS);
1888 
1889 	for (i = 0; i < num_line_out; i++) {
1890 		int volume;
1891 
1892 		private->vol_sw_hw_switch[i] =
1893 			info->line_out_hw_vol
1894 				&& volume_status.sw_hw_switch[i];
1895 
1896 		volume = private->vol_sw_hw_switch[i]
1897 			   ? volume_status.master_vol
1898 			   : volume_status.sw_vol[i];
1899 		volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
1900 			       0, SCARLETT2_VOLUME_BIAS);
1901 		private->vol[i] = volume;
1902 	}
1903 
1904 	for (i = 0; i < info->button_count; i++)
1905 		private->buttons[i] = !!volume_status.buttons[i];
1906 
1907 	return 0;
1908 }
1909 
1910 /* Notify on volume change */
scarlett2_mixer_interrupt_vol_change(struct usb_mixer_interface * mixer)1911 static void scarlett2_mixer_interrupt_vol_change(
1912 	struct usb_mixer_interface *mixer)
1913 {
1914 	struct scarlett2_mixer_data *private = mixer->private_data;
1915 	const struct scarlett2_ports *ports = private->info->ports;
1916 	int num_line_out =
1917 		ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1918 	int i;
1919 
1920 	private->vol_updated = 1;
1921 
1922 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1923 		       &private->master_vol_ctl->id);
1924 
1925 	for (i = 0; i < num_line_out; i++) {
1926 		if (!private->vol_sw_hw_switch[i])
1927 			continue;
1928 		snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1929 			       &private->vol_ctls[i]->id);
1930 	}
1931 }
1932 
1933 /* Notify on button change */
scarlett2_mixer_interrupt_button_change(struct usb_mixer_interface * mixer)1934 static void scarlett2_mixer_interrupt_button_change(
1935 	struct usb_mixer_interface *mixer)
1936 {
1937 	struct scarlett2_mixer_data *private = mixer->private_data;
1938 	int i;
1939 
1940 	private->vol_updated = 1;
1941 
1942 	for (i = 0; i < private->info->button_count; i++)
1943 		snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1944 			       &private->button_ctls[i]->id);
1945 }
1946 
1947 /* Interrupt callback */
scarlett2_mixer_interrupt(struct urb * urb)1948 static void scarlett2_mixer_interrupt(struct urb *urb)
1949 {
1950 	struct usb_mixer_interface *mixer = urb->context;
1951 	int len = urb->actual_length;
1952 	int ustatus = urb->status;
1953 	u32 data;
1954 
1955 	if (ustatus != 0)
1956 		goto requeue;
1957 
1958 	if (len == 8) {
1959 		data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
1960 		if (data & SCARLETT2_USB_INTERRUPT_VOL_CHANGE)
1961 			scarlett2_mixer_interrupt_vol_change(mixer);
1962 		if (data & SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE)
1963 			scarlett2_mixer_interrupt_button_change(mixer);
1964 	} else {
1965 		usb_audio_err(mixer->chip,
1966 			      "scarlett mixer interrupt length %d\n", len);
1967 	}
1968 
1969 requeue:
1970 	if (ustatus != -ENOENT &&
1971 	    ustatus != -ECONNRESET &&
1972 	    ustatus != -ESHUTDOWN) {
1973 		urb->dev = mixer->chip->dev;
1974 		usb_submit_urb(urb, GFP_ATOMIC);
1975 	}
1976 }
1977 
scarlett2_mixer_status_create(struct usb_mixer_interface * mixer)1978 static int scarlett2_mixer_status_create(struct usb_mixer_interface *mixer)
1979 {
1980 	struct usb_device *dev = mixer->chip->dev;
1981 	unsigned int pipe = usb_rcvintpipe(dev,
1982 					   SCARLETT2_USB_INTERRUPT_ENDPOINT);
1983 	void *transfer_buffer;
1984 
1985 	if (mixer->urb) {
1986 		usb_audio_err(mixer->chip,
1987 			      "%s: mixer urb already in use!\n", __func__);
1988 		return 0;
1989 	}
1990 
1991 	if (usb_pipe_type_check(dev, pipe))
1992 		return -EINVAL;
1993 
1994 	mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
1995 	if (!mixer->urb)
1996 		return -ENOMEM;
1997 
1998 	transfer_buffer = kmalloc(SCARLETT2_USB_INTERRUPT_MAX_DATA, GFP_KERNEL);
1999 	if (!transfer_buffer)
2000 		return -ENOMEM;
2001 
2002 	usb_fill_int_urb(mixer->urb, dev, pipe,
2003 			 transfer_buffer, SCARLETT2_USB_INTERRUPT_MAX_DATA,
2004 			 scarlett2_mixer_interrupt, mixer,
2005 			 SCARLETT2_USB_INTERRUPT_INTERVAL);
2006 
2007 	return usb_submit_urb(mixer->urb, GFP_KERNEL);
2008 }
2009 
snd_scarlett_gen2_controls_create(struct usb_mixer_interface * mixer,const struct scarlett2_device_info * info)2010 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer,
2011 					     const struct scarlett2_device_info *info)
2012 {
2013 	int err;
2014 
2015 	/* Initialise private data, routing, sequence number */
2016 	err = scarlett2_init_private(mixer, info);
2017 	if (err < 0)
2018 		return err;
2019 
2020 	/* Read volume levels and controls from the interface */
2021 	err = scarlett2_read_configs(mixer);
2022 	if (err < 0)
2023 		return err;
2024 
2025 	/* Create the analogue output controls */
2026 	err = scarlett2_add_line_out_ctls(mixer);
2027 	if (err < 0)
2028 		return err;
2029 
2030 	/* Create the analogue input controls */
2031 	err = scarlett2_add_line_in_ctls(mixer);
2032 	if (err < 0)
2033 		return err;
2034 
2035 	/* Create the input, output, and mixer mux input selections */
2036 	err = scarlett2_add_mux_enums(mixer);
2037 	if (err < 0)
2038 		return err;
2039 
2040 	/* Create the matrix mixer controls */
2041 	err = scarlett2_add_mixer_ctls(mixer);
2042 	if (err < 0)
2043 		return err;
2044 
2045 	/* Create the level meter controls */
2046 	err = scarlett2_add_meter_ctl(mixer);
2047 	if (err < 0)
2048 		return err;
2049 
2050 	/* Set up the interrupt polling if there are hardware buttons */
2051 	if (info->button_count) {
2052 		err = scarlett2_mixer_status_create(mixer);
2053 		if (err < 0)
2054 			return err;
2055 	}
2056 
2057 	return 0;
2058 }
2059 
snd_scarlett_gen2_init(struct usb_mixer_interface * mixer)2060 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
2061 {
2062 	struct snd_usb_audio *chip = mixer->chip;
2063 	const struct scarlett2_device_info *info;
2064 	int err;
2065 
2066 	/* only use UAC_VERSION_2 */
2067 	if (!mixer->protocol)
2068 		return 0;
2069 
2070 	switch (chip->usb_id) {
2071 	case USB_ID(0x1235, 0x8203):
2072 		info = &s6i6_gen2_info;
2073 		break;
2074 	case USB_ID(0x1235, 0x8204):
2075 		info = &s18i8_gen2_info;
2076 		break;
2077 	case USB_ID(0x1235, 0x8201):
2078 		info = &s18i20_gen2_info;
2079 		break;
2080 	default: /* device not (yet) supported */
2081 		return -EINVAL;
2082 	}
2083 
2084 	if (!(chip->setup & SCARLETT2_ENABLE)) {
2085 		usb_audio_info(chip,
2086 			"Focusrite Scarlett Gen 2 Mixer Driver disabled; "
2087 			"use options snd_usb_audio vid=0x%04x pid=0x%04x "
2088 			"device_setup=1 to enable and report any issues "
2089 			"to g@b4.vu",
2090 			USB_ID_VENDOR(chip->usb_id),
2091 			USB_ID_PRODUCT(chip->usb_id));
2092 		return 0;
2093 	}
2094 
2095 	usb_audio_info(chip,
2096 		"Focusrite Scarlett Gen 2 Mixer Driver enabled pid=0x%04x",
2097 		USB_ID_PRODUCT(chip->usb_id));
2098 
2099 	err = snd_scarlett_gen2_controls_create(mixer, info);
2100 	if (err < 0)
2101 		usb_audio_err(mixer->chip,
2102 			      "Error initialising Scarlett Mixer Driver: %d",
2103 			      err);
2104 
2105 	return err;
2106 }
2107