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