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