~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/usb/mixer_scarlett.c

Version: ~ [ linux-5.9-rc5 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 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 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 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 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 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 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 }
1005 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp