?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: rtl8192u: remove redundant assignment to pointer crypt
[linux/fpc-iii.git] / sound / usb / mixer_scarlett.c
blob83715fd8dfd6478fa27e199acd6f4c0b5ad2c891
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Scarlett Driver for ALSA
4 *
5 * Copyright (c) 2013 by Tobias Hoffmann
6 * Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
7 * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
8 * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
9 *
10 * Many codes borrowed from audio.c by
11 * Alan Cox (alan at lxorguk.ukuu.org.uk)
12 * Thomas Sailer (sailer at ife.ee.ethz.ch)
13 *
14 * Code cleanup:
15 * David Henningsson <david.henningsson at canonical.com>
16 */
17
18 /*
19 * Rewritten and extended to support more models, e.g. Scarlett 18i8.
20 *
21 * Auto-detection via UAC2 is not feasible to properly discover the vast
22 * majority of features. It's related to both Linux/ALSA's UAC2 as well as
23 * Focusrite's implementation of it. Eventually quirks may be sufficient but
24 * right now it's a major headache to work arount these things.
25 *
26 * NB. Neither the OSX nor the win driver provided by Focusrite performs
27 * discovery, they seem to operate the same as this driver.
28 */
29
30 /* Mixer Interface for the Focusrite Scarlett 18i6 audio interface.
31 *
32 * The protocol was reverse engineered by looking at communication between
33 * Scarlett MixControl (v 1.2.128.0) and the Focusrite(R) Scarlett 18i6
34 * (firmware v305) using wireshark and usbmon in January 2013.
35 * Extended in July 2013.
36 *
37 * this mixer gives complete access to all features of the device:
38 * - change Impedance of inputs (Line-in, Mic / Instrument, Hi-Z)
39 * - select clock source
40 * - dynamic input to mixer-matrix assignment
41 * - 18 x 6 mixer-matrix gain stages
42 * - bus routing & volume control
43 * - automatic re-initialization on connect if device was power-cycled
44 *
45 * USB URB commands overview (bRequest = 0x01 = UAC2_CS_CUR)
46 * wIndex
47 * 0x01 Analog Input line/instrument impedance switch, wValue=0x0901 +
48 * channel, data=Line/Inst (2bytes)
49 * pad (-10dB) switch, wValue=0x0b01 + channel, data=Off/On (2bytes)
50 * ?? wValue=0x0803/04, ?? (2bytes)
51 * 0x0a Master Volume, wValue=0x0200+bus[0:all + only 1..4?] data(2bytes)
52 * Bus Mute/Unmute wValue=0x0100+bus[0:all + only 1..4?], data(2bytes)
53 * 0x28 Clock source, wValue=0x0100, data={1:int,2:spdif,3:adat} (1byte)
54 * 0x29 Set Sample-rate, wValue=0x0100, data=sample-rate(4bytes)
55 * 0x32 Mixer mux, wValue=0x0600 + mixer-channel, data=input-to-connect(2bytes)
56 * 0x33 Output mux, wValue=bus, data=input-to-connect(2bytes)
57 * 0x34 Capture mux, wValue=0...18, data=input-to-connect(2bytes)
58 * 0x3c Matrix Mixer gains, wValue=mixer-node data=gain(2bytes)
59 * ?? [sometimes](4bytes, e.g 0x000003be 0x000003bf ...03ff)
60 *
61 * USB reads: (i.e. actually issued by original software)
62 * 0x01 wValue=0x0901+channel (1byte!!), wValue=0x0b01+channed (1byte!!)
63 * 0x29 wValue=0x0100 sample-rate(4bytes)
64 * wValue=0x0200 ?? 1byte (only once)
65 * 0x2a wValue=0x0100 ?? 4bytes, sample-rate2 ??
66 *
67 * USB reads with bRequest = 0x03 = UAC2_CS_MEM
68 * 0x3c wValue=0x0002 1byte: sync status (locked=1)
69 * wValue=0x0000 18*2byte: peak meter (inputs)
70 * wValue=0x0001 8(?)*2byte: peak meter (mix)
71 * wValue=0x0003 6*2byte: peak meter (pcm/daw)
72 *
73 * USB write with bRequest = 0x03
74 * 0x3c Save settings to hardware: wValue=0x005a, data=0xa5
75 *
76 *
77 * <ditaa>
78 * /--------------\ 18chn 6chn /--------------\
79 * | Hardware in +--+-------\ /------+--+ ALSA PCM out |
80 * \--------------/ | | | | \--------------/
81 * | | | |
82 * | v v |
83 * | +---------------+ |
84 * | \ Matrix Mux / |
85 * | +-----+-----+ |
86 * | | |
87 * | | 18chn |
88 * | v |
89 * | +-----------+ |
90 * | | Mixer | |
91 * | | Matrix | |
92 * | | | |
93 * | | 18x6 Gain | |
94 * | | stages | |
95 * | +-----+-----+ |
96 * | | |
97 * | | |
98 * | 18chn | 6chn | 6chn
99 * v v v
100 * =========================
101 * +---------------+ +--—------------+
102 * \ Output Mux / \ Capture Mux /
103 * +-----+-----+ +-----+-----+
104 * | |
105 * | 6chn |
106 * v |
107 * +-------------+ |
108 * | Master Gain | |
109 * +------+------+ |
110 * | |
111 * | 6chn | 18chn
112 * | (3 stereo pairs) |
113 * /--------------\ | | /--------------\
114 * | Hardware out |<--/ \-->| ALSA PCM in |
115 * \--------------/ \--------------/
116 * </ditaa>
117 *
118 */
119
120 #include <linux/slab.h>
121 #include <linux/usb.h>
122 #include <linux/usb/audio-v2.h>
123
124 #include <sound/core.h>
125 #include <sound/control.h>
126 #include <sound/tlv.h>
127
128 #include "usbaudio.h"
129 #include "mixer.h"
130 #include "helper.h"
131 #include "power.h"
132
133 #include "mixer_scarlett.h"
134
135 /* some gui mixers can't handle negative ctl values */
136 #define SND_SCARLETT_LEVEL_BIAS 128
137 #define SND_SCARLETT_MATRIX_IN_MAX 18
138 #define SND_SCARLETT_CONTROLS_MAX 10
139 #define SND_SCARLETT_OFFSETS_MAX 5
140
141 enum {
142 SCARLETT_OUTPUTS,
143 SCARLETT_SWITCH_IMPEDANCE,
144 SCARLETT_SWITCH_PAD,
145 };
146
147 enum {
148 SCARLETT_OFFSET_PCM = 0,
149 SCARLETT_OFFSET_ANALOG = 1,
150 SCARLETT_OFFSET_SPDIF = 2,
151 SCARLETT_OFFSET_ADAT = 3,
152 SCARLETT_OFFSET_MIX = 4,
153 };
154
155 struct scarlett_mixer_elem_enum_info {
156 int start;
157 int len;
158 int offsets[SND_SCARLETT_OFFSETS_MAX];
159 char const * const *names;
160 };
161
162 struct scarlett_mixer_control {
163 unsigned char num;
164 unsigned char type;
165 const char *name;
166 };
167
168 struct scarlett_device_info {
169 int matrix_in;
170 int matrix_out;
171 int input_len;
172 int output_len;
173
174 struct scarlett_mixer_elem_enum_info opt_master;
175 struct scarlett_mixer_elem_enum_info opt_matrix;
176
177 /* initial values for matrix mux */
178 int matrix_mux_init[SND_SCARLETT_MATRIX_IN_MAX];
179
180 int num_controls; /* number of items in controls */
181 const struct scarlett_mixer_control controls[SND_SCARLETT_CONTROLS_MAX];
182 };
183
184 /********************** Enum Strings *************************/
185
186 static const struct scarlett_mixer_elem_enum_info opt_pad = {
187 .start = 0,
188 .len = 2,
189 .offsets = {},
190 .names = (char const * const []){
191 "0dB", "-10dB"
192 }
193 };
194
195 static const struct scarlett_mixer_elem_enum_info opt_impedance = {
196 .start = 0,
197 .len = 2,
198 .offsets = {},
199 .names = (char const * const []){
200 "Line", "Hi-Z"
201 }
202 };
203
204 static const struct scarlett_mixer_elem_enum_info opt_clock = {
205 .start = 1,
206 .len = 3,
207 .offsets = {},
208 .names = (char const * const []){
209 "Internal", "SPDIF", "ADAT"
210 }
211 };
212
213 static const struct scarlett_mixer_elem_enum_info opt_sync = {
214 .start = 0,
215 .len = 2,
216 .offsets = {},
217 .names = (char const * const []){
218 "No Lock", "Locked"
219 }
220 };
221
222 static int scarlett_ctl_switch_info(struct snd_kcontrol *kctl,
223 struct snd_ctl_elem_info *uinfo)
224 {
225 struct usb_mixer_elem_info *elem = kctl->private_data;
226
227 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
228 uinfo->count = elem->channels;
229 uinfo->value.integer.min = 0;
230 uinfo->value.integer.max = 1;
231 return 0;
232 }
233
234 static int scarlett_ctl_switch_get(struct snd_kcontrol *kctl,
235 struct snd_ctl_elem_value *ucontrol)
236 {
237 struct usb_mixer_elem_info *elem = kctl->private_data;
238 int i, err, val;
239
240 for (i = 0; i < elem->channels; i++) {
241 err = snd_usb_get_cur_mix_value(elem, i, i, &val);
242 if (err < 0)
243 return err;
244
245 val = !val; /* invert mute logic for mixer */
246 ucontrol->value.integer.value[i] = val;
247 }
248
249 return 0;
250 }
251
252 static int scarlett_ctl_switch_put(struct snd_kcontrol *kctl,
253 struct snd_ctl_elem_value *ucontrol)
254 {
255 struct usb_mixer_elem_info *elem = kctl->private_data;
256 int i, changed = 0;
257 int err, oval, val;
258
259 for (i = 0; i < elem->channels; i++) {
260 err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
261 if (err < 0)
262 return err;
263
264 val = ucontrol->value.integer.value[i];
265 val = !val;
266 if (oval != val) {
267 err = snd_usb_set_cur_mix_value(elem, i, i, val);
268 if (err < 0)
269 return err;
270
271 changed = 1;
272 }
273 }
274
275 return changed;
276 }
277
278 static int scarlett_ctl_resume(struct usb_mixer_elem_list *list)
279 {
280 struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
281 int i;
282
283 for (i = 0; i < elem->channels; i++)
284 if (elem->cached & (1 << i))
285 snd_usb_set_cur_mix_value(elem, i, i,
286 elem->cache_val[i]);
287 return 0;
288 }
289
290 static int scarlett_ctl_info(struct snd_kcontrol *kctl,
291 struct snd_ctl_elem_info *uinfo)
292 {
293 struct usb_mixer_elem_info *elem = kctl->private_data;
294
295 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
296 uinfo->count = elem->channels;
297 uinfo->value.integer.min = 0;
298 uinfo->value.integer.max = (int)kctl->private_value +
299 SND_SCARLETT_LEVEL_BIAS;
300 uinfo->value.integer.step = 1;
301 return 0;
302 }
303
304 static int scarlett_ctl_get(struct snd_kcontrol *kctl,
305 struct snd_ctl_elem_value *ucontrol)
306 {
307 struct usb_mixer_elem_info *elem = kctl->private_data;
308 int i, err, val;
309
310 for (i = 0; i < elem->channels; i++) {
311 err = snd_usb_get_cur_mix_value(elem, i, i, &val);
312 if (err < 0)
313 return err;
314
315 val = clamp(val / 256, -128, (int)kctl->private_value) +
316 SND_SCARLETT_LEVEL_BIAS;
317 ucontrol->value.integer.value[i] = val;
318 }
319
320 return 0;
321 }
322
323 static int scarlett_ctl_put(struct snd_kcontrol *kctl,
324 struct snd_ctl_elem_value *ucontrol)
325 {
326 struct usb_mixer_elem_info *elem = kctl->private_data;
327 int i, changed = 0;
328 int err, oval, val;
329
330 for (i = 0; i < elem->channels; i++) {
331 err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
332 if (err < 0)
333 return err;
334
335 val = ucontrol->value.integer.value[i] -
336 SND_SCARLETT_LEVEL_BIAS;
337 val = val * 256;
338 if (oval != val) {
339 err = snd_usb_set_cur_mix_value(elem, i, i, val);
340 if (err < 0)
341 return err;
342
343 changed = 1;
344 }
345 }
346
347 return changed;
348 }
349
350 static void scarlett_generate_name(int i, char *dst, int offsets[])
351 {
352 if (i > offsets[SCARLETT_OFFSET_MIX])
353 sprintf(dst, "Mix %c",
354 'A'+(i - offsets[SCARLETT_OFFSET_MIX] - 1));
355 else if (i > offsets[SCARLETT_OFFSET_ADAT])
356 sprintf(dst, "ADAT %d", i - offsets[SCARLETT_OFFSET_ADAT]);
357 else if (i > offsets[SCARLETT_OFFSET_SPDIF])
358 sprintf(dst, "SPDIF %d", i - offsets[SCARLETT_OFFSET_SPDIF]);
359 else if (i > offsets[SCARLETT_OFFSET_ANALOG])
360 sprintf(dst, "Analog %d", i - offsets[SCARLETT_OFFSET_ANALOG]);
361 else if (i > offsets[SCARLETT_OFFSET_PCM])
362 sprintf(dst, "PCM %d", i - offsets[SCARLETT_OFFSET_PCM]);
363 else
364 sprintf(dst, "Off");
365 }
366
367 static int scarlett_ctl_enum_dynamic_info(struct snd_kcontrol *kctl,
368 struct snd_ctl_elem_info *uinfo)
369 {
370 struct usb_mixer_elem_info *elem = kctl->private_data;
371 struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
372 unsigned int items = opt->len;
373
374 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
375 uinfo->count = elem->channels;
376 uinfo->value.enumerated.items = items;
377
378 if (uinfo->value.enumerated.item >= items)
379 uinfo->value.enumerated.item = items - 1;
380
381 /* generate name dynamically based on item number and offset info */
382 scarlett_generate_name(uinfo->value.enumerated.item,
383 uinfo->value.enumerated.name,
384 opt->offsets);
385
386 return 0;
387 }
388
389 static int scarlett_ctl_enum_info(struct snd_kcontrol *kctl,
390 struct snd_ctl_elem_info *uinfo)
391 {
392 struct usb_mixer_elem_info *elem = kctl->private_data;
393 struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
394
395 return snd_ctl_enum_info(uinfo, elem->channels, opt->len,
396 (const char * const *)opt->names);
397 }
398
399 static int scarlett_ctl_enum_get(struct snd_kcontrol *kctl,
400 struct snd_ctl_elem_value *ucontrol)
401 {
402 struct usb_mixer_elem_info *elem = kctl->private_data;
403 struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
404 int err, val;
405
406 err = snd_usb_get_cur_mix_value(elem, 0, 0, &val);
407 if (err < 0)
408 return err;
409
410 val = clamp(val - opt->start, 0, opt->len-1);
411
412 ucontrol->value.enumerated.item[0] = val;
413
414 return 0;
415 }
416
417 static int scarlett_ctl_enum_put(struct snd_kcontrol *kctl,
418 struct snd_ctl_elem_value *ucontrol)
419 {
420 struct usb_mixer_elem_info *elem = kctl->private_data;
421 struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
422 int err, oval, val;
423
424 err = snd_usb_get_cur_mix_value(elem, 0, 0, &oval);
425 if (err < 0)
426 return err;
427
428 val = ucontrol->value.integer.value[0];
429 val = val + opt->start;
430 if (val != oval) {
431 snd_usb_set_cur_mix_value(elem, 0, 0, val);
432 return 1;
433 }
434 return 0;
435 }
436
437 static int scarlett_ctl_enum_resume(struct usb_mixer_elem_list *list)
438 {
439 struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
440
441 if (elem->cached)
442 snd_usb_set_cur_mix_value(elem, 0, 0, *elem->cache_val);
443 return 0;
444 }
445
446 static int scarlett_ctl_meter_get(struct snd_kcontrol *kctl,
447 struct snd_ctl_elem_value *ucontrol)
448 {
449 struct usb_mixer_elem_info *elem = kctl->private_data;
450 struct snd_usb_audio *chip = elem->head.mixer->chip;
451 unsigned char buf[2 * MAX_CHANNELS] = {0, };
452 int wValue = (elem->control << 8) | elem->idx_off;
453 int idx = snd_usb_ctrl_intf(chip) | (elem->head.id << 8);
454 int err;
455
456 err = snd_usb_ctl_msg(chip->dev,
457 usb_rcvctrlpipe(chip->dev, 0),
458 UAC2_CS_MEM,
459 USB_RECIP_INTERFACE | USB_TYPE_CLASS |
460 USB_DIR_IN, wValue, idx, buf, elem->channels);
461 if (err < 0)
462 return err;
463
464 ucontrol->value.enumerated.item[0] = clamp((int)buf[0], 0, 1);
465 return 0;
466 }
467
468 static const struct snd_kcontrol_new usb_scarlett_ctl_switch = {
469 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
470 .name = "",
471 .info = scarlett_ctl_switch_info,
472 .get = scarlett_ctl_switch_get,
473 .put = scarlett_ctl_switch_put,
474 };
475
476 static const DECLARE_TLV_DB_SCALE(db_scale_scarlett_gain, -12800, 100, 0);
477
478 static const struct snd_kcontrol_new usb_scarlett_ctl = {
479 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
480 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
481 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
482 .name = "",
483 .info = scarlett_ctl_info,
484 .get = scarlett_ctl_get,
485 .put = scarlett_ctl_put,
486 .private_value = 6, /* max value */
487 .tlv = { .p = db_scale_scarlett_gain }
488 };
489
490 static const struct snd_kcontrol_new usb_scarlett_ctl_master = {
491 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
492 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
493 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
494 .name = "",
495 .info = scarlett_ctl_info,
496 .get = scarlett_ctl_get,
497 .put = scarlett_ctl_put,
498 .private_value = 6, /* max value */
499 .tlv = { .p = db_scale_scarlett_gain }
500 };
501
502 static const struct snd_kcontrol_new usb_scarlett_ctl_enum = {
503 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
504 .name = "",
505 .info = scarlett_ctl_enum_info,
506 .get = scarlett_ctl_enum_get,
507 .put = scarlett_ctl_enum_put,
508 };
509
510 static const struct snd_kcontrol_new usb_scarlett_ctl_dynamic_enum = {
511 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
512 .name = "",
513 .info = scarlett_ctl_enum_dynamic_info,
514 .get = scarlett_ctl_enum_get,
515 .put = scarlett_ctl_enum_put,
516 };
517
518 static const struct snd_kcontrol_new usb_scarlett_ctl_sync = {
519 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
520 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
521 .name = "",
522 .info = scarlett_ctl_enum_info,
523 .get = scarlett_ctl_meter_get,
524 };
525
526 static int add_new_ctl(struct usb_mixer_interface *mixer,
527 const struct snd_kcontrol_new *ncontrol,
528 usb_mixer_elem_resume_func_t resume,
529 int index, int offset, int num,
530 int val_type, int channels, const char *name,
531 const struct scarlett_mixer_elem_enum_info *opt,
532 struct usb_mixer_elem_info **elem_ret
533 )
534 {
535 struct snd_kcontrol *kctl;
536 struct usb_mixer_elem_info *elem;
537 int err;
538
539 elem = kzalloc(sizeof(*elem), GFP_KERNEL);
540 if (!elem)
541 return -ENOMEM;
542
543 elem->head.mixer = mixer;
544 elem->head.resume = resume;
545 elem->control = offset;
546 elem->idx_off = num;
547 elem->head.id = index;
548 elem->val_type = val_type;
549
550 elem->channels = channels;
551
552 /* add scarlett_mixer_elem_enum_info struct */
553 elem->private_data = (void *)opt;
554
555 kctl = snd_ctl_new1(ncontrol, elem);
556 if (!kctl) {
557 kfree(elem);
558 return -ENOMEM;
559 }
560 kctl->private_free = snd_usb_mixer_elem_free;
561
562 strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
563
564 err = snd_usb_mixer_add_control(&elem->head, kctl);
565 if (err < 0)
566 return err;
567
568 if (elem_ret)
569 *elem_ret = elem;
570
571 return 0;
572 }
573
574 static int add_output_ctls(struct usb_mixer_interface *mixer,
575 int index, const char *name,
576 const struct scarlett_device_info *info)
577 {
578 int err;
579 char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
580 struct usb_mixer_elem_info *elem;
581
582 /* Add mute switch */
583 snprintf(mx, sizeof(mx), "Master %d (%s) Playback Switch",
584 index + 1, name);
585 err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
586 scarlett_ctl_resume, 0x0a, 0x01,
587 2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
588 if (err < 0)
589 return err;
590
591 /* Add volume control and initialize to 0 */
592 snprintf(mx, sizeof(mx), "Master %d (%s) Playback Volume",
593 index + 1, name);
594 err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
595 scarlett_ctl_resume, 0x0a, 0x02,
596 2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
597 if (err < 0)
598 return err;
599
600 /* Add L channel source playback enumeration */
601 snprintf(mx, sizeof(mx), "Master %dL (%s) Source Playback Enum",
602 index + 1, name);
603 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
604 scarlett_ctl_enum_resume, 0x33, 0x00,
605 2*index, USB_MIXER_S16, 1, mx, &info->opt_master,
606 &elem);
607 if (err < 0)
608 return err;
609
610 /* Add R channel source playback enumeration */
611 snprintf(mx, sizeof(mx), "Master %dR (%s) Source Playback Enum",
612 index + 1, name);
613 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
614 scarlett_ctl_enum_resume, 0x33, 0x00,
615 2*index+1, USB_MIXER_S16, 1, mx, &info->opt_master,
616 &elem);
617 if (err < 0)
618 return err;
619
620 return 0;
621 }
622
623 /********************** device-specific config *************************/
624
625 /* untested... */
626 static struct scarlett_device_info s6i6_info = {
627 .matrix_in = 18,
628 .matrix_out = 8,
629 .input_len = 6,
630 .output_len = 6,
631
632 .opt_master = {
633 .start = -1,
634 .len = 27,
635 .offsets = {0, 12, 16, 18, 18},
636 .names = NULL
637 },
638
639 .opt_matrix = {
640 .start = -1,
641 .len = 19,
642 .offsets = {0, 12, 16, 18, 18},
643 .names = NULL
644 },
645
646 .num_controls = 9,
647 .controls = {
648 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
649 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
650 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
651 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
652 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
653 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
654 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
655 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
656 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
657 },
658
659 .matrix_mux_init = {
660 12, 13, 14, 15, /* Analog -> 1..4 */
661 16, 17, /* SPDIF -> 5,6 */
662 0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */
663 8, 9, 10, 11
664 }
665 };
666
667 /* untested... */
668 static struct scarlett_device_info s8i6_info = {
669 .matrix_in = 18,
670 .matrix_out = 6,
671 .input_len = 8,
672 .output_len = 6,
673
674 .opt_master = {
675 .start = -1,
676 .len = 25,
677 .offsets = {0, 12, 16, 18, 18},
678 .names = NULL
679 },
680
681 .opt_matrix = {
682 .start = -1,
683 .len = 19,
684 .offsets = {0, 12, 16, 18, 18},
685 .names = NULL
686 },
687
688 .num_controls = 7,
689 .controls = {
690 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
691 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
692 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
693 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
694 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
695 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
696 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
697 },
698
699 .matrix_mux_init = {
700 12, 13, 14, 15, /* Analog -> 1..4 */
701 16, 17, /* SPDIF -> 5,6 */
702 0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */
703 8, 9, 10, 11
704 }
705 };
706
707 static struct scarlett_device_info s18i6_info = {
708 .matrix_in = 18,
709 .matrix_out = 6,
710 .input_len = 18,
711 .output_len = 6,
712
713 .opt_master = {
714 .start = -1,
715 .len = 31,
716 .offsets = {0, 6, 14, 16, 24},
717 .names = NULL,
718 },
719
720 .opt_matrix = {
721 .start = -1,
722 .len = 25,
723 .offsets = {0, 6, 14, 16, 24},
724 .names = NULL,
725 },
726
727 .num_controls = 5,
728 .controls = {
729 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
730 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
731 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
732 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
733 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
734 },
735
736 .matrix_mux_init = {
737 6, 7, 8, 9, 10, 11, 12, 13, /* Analog -> 1..8 */
738 16, 17, 18, 19, 20, 21, /* ADAT[1..6] -> 9..14 */
739 14, 15, /* SPDIF -> 15,16 */
740 0, 1 /* PCM[1,2] -> 17,18 */
741 }
742 };
743
744 static struct scarlett_device_info s18i8_info = {
745 .matrix_in = 18,
746 .matrix_out = 8,
747 .input_len = 18,
748 .output_len = 8,
749
750 .opt_master = {
751 .start = -1,
752 .len = 35,
753 .offsets = {0, 8, 16, 18, 26},
754 .names = NULL
755 },
756
757 .opt_matrix = {
758 .start = -1,
759 .len = 27,
760 .offsets = {0, 8, 16, 18, 26},
761 .names = NULL
762 },
763
764 .num_controls = 10,
765 .controls = {
766 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
767 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone 1" },
768 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Headphone 2" },
769 { .num = 3, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
770 { .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
771 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
772 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
773 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
774 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
775 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
776 },
777
778 .matrix_mux_init = {
779 8, 9, 10, 11, 12, 13, 14, 15, /* Analog -> 1..8 */
780 18, 19, 20, 21, 22, 23, /* ADAT[1..6] -> 9..14 */
781 16, 17, /* SPDIF -> 15,16 */
782 0, 1 /* PCM[1,2] -> 17,18 */
783 }
784 };
785
786 static struct scarlett_device_info s18i20_info = {
787 .matrix_in = 18,
788 .matrix_out = 8,
789 .input_len = 18,
790 .output_len = 20,
791
792 .opt_master = {
793 .start = -1,
794 .len = 47,
795 .offsets = {0, 20, 28, 30, 38},
796 .names = NULL
797 },
798
799 .opt_matrix = {
800 .start = -1,
801 .len = 39,
802 .offsets = {0, 20, 28, 30, 38},
803 .names = NULL
804 },
805
806 .num_controls = 10,
807 .controls = {
808 { .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
809 { .num = 1, .type = SCARLETT_OUTPUTS, .name = "Line 3/4" },
810 { .num = 2, .type = SCARLETT_OUTPUTS, .name = "Line 5/6" },
811 { .num = 3, .type = SCARLETT_OUTPUTS, .name = "Line 7/8" },
812 { .num = 4, .type = SCARLETT_OUTPUTS, .name = "Line 9/10" },
813 { .num = 5, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
814 { .num = 6, .type = SCARLETT_OUTPUTS, .name = "ADAT 1/2" },
815 { .num = 7, .type = SCARLETT_OUTPUTS, .name = "ADAT 3/4" },
816 { .num = 8, .type = SCARLETT_OUTPUTS, .name = "ADAT 5/6" },
817 { .num = 9, .type = SCARLETT_OUTPUTS, .name = "ADAT 7/8" },
818 /*{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
819 { .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
820 { .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
821 { .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
822 { .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
823 { .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},*/
824 },
825
826 .matrix_mux_init = {
827 20, 21, 22, 23, 24, 25, 26, 27, /* Analog -> 1..8 */
828 30, 31, 32, 33, 34, 35, /* ADAT[1..6] -> 9..14 */
829 28, 29, /* SPDIF -> 15,16 */
830 0, 1 /* PCM[1,2] -> 17,18 */
831 }
832 };
833
834
835 static int scarlett_controls_create_generic(struct usb_mixer_interface *mixer,
836 struct scarlett_device_info *info)
837 {
838 int i, err;
839 char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
840 const struct scarlett_mixer_control *ctl;
841 struct usb_mixer_elem_info *elem;
842
843 /* create master switch and playback volume */
844 err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
845 scarlett_ctl_resume, 0x0a, 0x01, 0,
846 USB_MIXER_S16, 1, "Master Playback Switch", NULL,
847 &elem);
848 if (err < 0)
849 return err;
850
851 err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
852 scarlett_ctl_resume, 0x0a, 0x02, 0,
853 USB_MIXER_S16, 1, "Master Playback Volume", NULL,
854 &elem);
855 if (err < 0)
856 return err;
857
858 /* iterate through controls in info struct and create each one */
859 for (i = 0; i < info->num_controls; i++) {
860 ctl = &info->controls[i];
861
862 switch (ctl->type) {
863 case SCARLETT_OUTPUTS:
864 err = add_output_ctls(mixer, ctl->num, ctl->name, info);
865 if (err < 0)
866 return err;
867 break;
868 case SCARLETT_SWITCH_IMPEDANCE:
869 sprintf(mx, "Input %d Impedance Switch", ctl->num);
870 err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
871 scarlett_ctl_enum_resume, 0x01,
872 0x09, ctl->num, USB_MIXER_S16, 1, mx,
873 &opt_impedance, &elem);
874 if (err < 0)
875 return err;
876 break;
877 case SCARLETT_SWITCH_PAD:
878 sprintf(mx, "Input %d Pad Switch", ctl->num);
879 err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
880 scarlett_ctl_enum_resume, 0x01,
881 0x0b, ctl->num, USB_MIXER_S16, 1, mx,
882 &opt_pad, &elem);
883 if (err < 0)
884 return err;
885 break;
886 }
887 }
888
889 return 0;
890 }
891
892 /*
893 * Create and initialize a mixer for the Focusrite(R) Scarlett
894 */
895 int snd_scarlett_controls_create(struct usb_mixer_interface *mixer)
896 {
897 int err, i, o;
898 char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
899 struct scarlett_device_info *info;
900 struct usb_mixer_elem_info *elem;
901 static char sample_rate_buffer[4] = { '\x80', '\xbb', '\x00', '\x00' };
902
903 /* only use UAC_VERSION_2 */
904 if (!mixer->protocol)
905 return 0;
906
907 switch (mixer->chip->usb_id) {
908 case USB_ID(0x1235, 0x8012):
909 info = &s6i6_info;
910 break;
911 case USB_ID(0x1235, 0x8002):
912 info = &s8i6_info;
913 break;
914 case USB_ID(0x1235, 0x8004):
915 info = &s18i6_info;
916 break;
917 case USB_ID(0x1235, 0x8014):
918 info = &s18i8_info;
919 break;
920 case USB_ID(0x1235, 0x800c):
921 info = &s18i20_info;
922 break;
923 default: /* device not (yet) supported */
924 return -EINVAL;
925 }
926
927 /* generic function to create controls */
928 err = scarlett_controls_create_generic(mixer, info);
929 if (err < 0)
930 return err;
931
932 /* setup matrix controls */
933 for (i = 0; i < info->matrix_in; i++) {
934 snprintf(mx, sizeof(mx), "Matrix %02d Input Playback Route",
935 i+1);
936 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
937 scarlett_ctl_enum_resume, 0x32,
938 0x06, i, USB_MIXER_S16, 1, mx,
939 &info->opt_matrix, &elem);
940 if (err < 0)
941 return err;
942
943 for (o = 0; o < info->matrix_out; o++) {
944 sprintf(mx, "Matrix %02d Mix %c Playback Volume", i+1,
945 o+'A');
946 err = add_new_ctl(mixer, &usb_scarlett_ctl,
947 scarlett_ctl_resume, 0x3c, 0x00,
948 (i << 3) + (o & 0x07), USB_MIXER_S16,
949 1, mx, NULL, &elem);
950 if (err < 0)
951 return err;
952
953 }
954 }
955
956 for (i = 0; i < info->input_len; i++) {
957 snprintf(mx, sizeof(mx), "Input Source %02d Capture Route",
958 i+1);
959 err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
960 scarlett_ctl_enum_resume, 0x34,
961 0x00, i, USB_MIXER_S16, 1, mx,
962 &info->opt_master, &elem);
963 if (err < 0)
964 return err;
965 }
966
967 /* val_len == 1 needed here */
968 err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
969 scarlett_ctl_enum_resume, 0x28, 0x01, 0,
970 USB_MIXER_U8, 1, "Sample Clock Source",
971 &opt_clock, &elem);
972 if (err < 0)
973 return err;
974
975 /* val_len == 1 and UAC2_CS_MEM */
976 err = add_new_ctl(mixer, &usb_scarlett_ctl_sync, NULL, 0x3c, 0x00, 2,
977 USB_MIXER_U8, 1, "Sample Clock Sync Status",
978 &opt_sync, &elem);
979 if (err < 0)
980 return err;
981
982 /* initialize sampling rate to 48000 */
983 err = snd_usb_ctl_msg(mixer->chip->dev,
984 usb_sndctrlpipe(mixer->chip->dev, 0), UAC2_CS_CUR,
985 USB_RECIP_INTERFACE | USB_TYPE_CLASS |
986 USB_DIR_OUT, 0x0100, snd_usb_ctrl_intf(mixer->chip) |
987 (0x29 << 8), sample_rate_buffer, 4);
988 if (err < 0)
989 return err;
990
991 return err;
992 }
Linux with added FPC-III support