mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Thomas Gleixner](/assets/img/avatar_default.png)
Based on 3 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details this program is free software you can redistribute it and or modify it under the terms of the gnu general public license as published by the free software foundation either version 2 of the license or at your option any later version [author] [graeme] [gregory] [gg]@[slimlogic] [co] [uk] [author] [kishon] [vijay] [abraham] [i] [kishon]@[ti] [com] [based] [on] [twl6030]_[usb] [c] [author] [hema] [hk] [hemahk]@[ti] [com] this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1105 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.202006027@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
992 lines
28 KiB
C
992 lines
28 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* Scarlett Driver for ALSA
|
|
*
|
|
* Copyright (c) 2013 by Tobias Hoffmann
|
|
* Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
|
|
* Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
|
|
* Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
|
|
*
|
|
* Many codes borrowed from audio.c by
|
|
* Alan Cox (alan at lxorguk.ukuu.org.uk)
|
|
* Thomas Sailer (sailer at ife.ee.ethz.ch)
|
|
*
|
|
* Code cleanup:
|
|
* David Henningsson <david.henningsson at canonical.com>
|
|
*/
|
|
|
|
/*
|
|
* Rewritten and extended to support more models, e.g. Scarlett 18i8.
|
|
*
|
|
* Auto-detection via UAC2 is not feasible to properly discover the vast
|
|
* majority of features. It's related to both Linux/ALSA's UAC2 as well as
|
|
* Focusrite's implementation of it. Eventually quirks may be sufficient but
|
|
* right now it's a major headache to work arount these things.
|
|
*
|
|
* NB. Neither the OSX nor the win driver provided by Focusrite performs
|
|
* discovery, they seem to operate the same as this driver.
|
|
*/
|
|
|
|
/* Mixer Interface for the Focusrite Scarlett 18i6 audio interface.
|
|
*
|
|
* The protocol was reverse engineered by looking at communication between
|
|
* Scarlett MixControl (v 1.2.128.0) and the Focusrite(R) Scarlett 18i6
|
|
* (firmware v305) using wireshark and usbmon in January 2013.
|
|
* Extended in July 2013.
|
|
*
|
|
* this mixer gives complete access to all features of the device:
|
|
* - change Impedance of inputs (Line-in, Mic / Instrument, Hi-Z)
|
|
* - select clock source
|
|
* - dynamic input to mixer-matrix assignment
|
|
* - 18 x 6 mixer-matrix gain stages
|
|
* - bus routing & volume control
|
|
* - automatic re-initialization on connect if device was power-cycled
|
|
*
|
|
* USB URB commands overview (bRequest = 0x01 = UAC2_CS_CUR)
|
|
* wIndex
|
|
* 0x01 Analog Input line/instrument impedance switch, wValue=0x0901 +
|
|
* channel, data=Line/Inst (2bytes)
|
|
* pad (-10dB) switch, wValue=0x0b01 + channel, data=Off/On (2bytes)
|
|
* ?? wValue=0x0803/04, ?? (2bytes)
|
|
* 0x0a Master Volume, wValue=0x0200+bus[0:all + only 1..4?] data(2bytes)
|
|
* Bus Mute/Unmute wValue=0x0100+bus[0:all + only 1..4?], data(2bytes)
|
|
* 0x28 Clock source, wValue=0x0100, data={1:int,2:spdif,3:adat} (1byte)
|
|
* 0x29 Set Sample-rate, wValue=0x0100, data=sample-rate(4bytes)
|
|
* 0x32 Mixer mux, wValue=0x0600 + mixer-channel, data=input-to-connect(2bytes)
|
|
* 0x33 Output mux, wValue=bus, data=input-to-connect(2bytes)
|
|
* 0x34 Capture mux, wValue=0...18, data=input-to-connect(2bytes)
|
|
* 0x3c Matrix Mixer gains, wValue=mixer-node data=gain(2bytes)
|
|
* ?? [sometimes](4bytes, e.g 0x000003be 0x000003bf ...03ff)
|
|
*
|
|
* USB reads: (i.e. actually issued by original software)
|
|
* 0x01 wValue=0x0901+channel (1byte!!), wValue=0x0b01+channed (1byte!!)
|
|
* 0x29 wValue=0x0100 sample-rate(4bytes)
|
|
* wValue=0x0200 ?? 1byte (only once)
|
|
* 0x2a wValue=0x0100 ?? 4bytes, sample-rate2 ??
|
|
*
|
|
* USB reads with bRequest = 0x03 = UAC2_CS_MEM
|
|
* 0x3c wValue=0x0002 1byte: sync status (locked=1)
|
|
* wValue=0x0000 18*2byte: peak meter (inputs)
|
|
* wValue=0x0001 8(?)*2byte: peak meter (mix)
|
|
* wValue=0x0003 6*2byte: peak meter (pcm/daw)
|
|
*
|
|
* USB write with bRequest = 0x03
|
|
* 0x3c Save settings to hardware: wValue=0x005a, data=0xa5
|
|
*
|
|
*
|
|
* <ditaa>
|
|
* /--------------\ 18chn 6chn /--------------\
|
|
* | Hardware in +--+-------\ /------+--+ ALSA PCM out |
|
|
* \--------------/ | | | | \--------------/
|
|
* | | | |
|
|
* | v v |
|
|
* | +---------------+ |
|
|
* | \ Matrix Mux / |
|
|
* | +-----+-----+ |
|
|
* | | |
|
|
* | | 18chn |
|
|
* | v |
|
|
* | +-----------+ |
|
|
* | | Mixer | |
|
|
* | | Matrix | |
|
|
* | | | |
|
|
* | | 18x6 Gain | |
|
|
* | | stages | |
|
|
* | +-----+-----+ |
|
|
* | | |
|
|
* | | |
|
|
* | 18chn | 6chn | 6chn
|
|
* v v v
|
|
* =========================
|
|
* +---------------+ +--—------------+
|
|
* \ Output Mux / \ Capture Mux /
|
|
* +-----+-----+ +-----+-----+
|
|
* | |
|
|
* | 6chn |
|
|
* v |
|
|
* +-------------+ |
|
|
* | Master Gain | |
|
|
* +------+------+ |
|
|
* | |
|
|
* | 6chn | 18chn
|
|
* | (3 stereo pairs) |
|
|
* /--------------\ | | /--------------\
|
|
* | Hardware out |<--/ \-->| ALSA PCM in |
|
|
* \--------------/ \--------------/
|
|
* </ditaa>
|
|
*
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include <linux/usb.h>
|
|
#include <linux/usb/audio-v2.h>
|
|
|
|
#include <sound/core.h>
|
|
#include <sound/control.h>
|
|
#include <sound/tlv.h>
|
|
|
|
#include "usbaudio.h"
|
|
#include "mixer.h"
|
|
#include "helper.h"
|
|
#include "power.h"
|
|
|
|
#include "mixer_scarlett.h"
|
|
|
|
/* some gui mixers can't handle negative ctl values */
|
|
#define SND_SCARLETT_LEVEL_BIAS 128
|
|
#define SND_SCARLETT_MATRIX_IN_MAX 18
|
|
#define SND_SCARLETT_CONTROLS_MAX 10
|
|
#define SND_SCARLETT_OFFSETS_MAX 5
|
|
|
|
enum {
|
|
SCARLETT_OUTPUTS,
|
|
SCARLETT_SWITCH_IMPEDANCE,
|
|
SCARLETT_SWITCH_PAD,
|
|
};
|
|
|
|
enum {
|
|
SCARLETT_OFFSET_PCM = 0,
|
|
SCARLETT_OFFSET_ANALOG = 1,
|
|
SCARLETT_OFFSET_SPDIF = 2,
|
|
SCARLETT_OFFSET_ADAT = 3,
|
|
SCARLETT_OFFSET_MIX = 4,
|
|
};
|
|
|
|
struct scarlett_mixer_elem_enum_info {
|
|
int start;
|
|
int len;
|
|
int offsets[SND_SCARLETT_OFFSETS_MAX];
|
|
char const * const *names;
|
|
};
|
|
|
|
struct scarlett_mixer_control {
|
|
unsigned char num;
|
|
unsigned char type;
|
|
const char *name;
|
|
};
|
|
|
|
struct scarlett_device_info {
|
|
int matrix_in;
|
|
int matrix_out;
|
|
int input_len;
|
|
int output_len;
|
|
|
|
struct scarlett_mixer_elem_enum_info opt_master;
|
|
struct scarlett_mixer_elem_enum_info opt_matrix;
|
|
|
|
/* initial values for matrix mux */
|
|
int matrix_mux_init[SND_SCARLETT_MATRIX_IN_MAX];
|
|
|
|
int num_controls; /* number of items in controls */
|
|
const struct scarlett_mixer_control controls[SND_SCARLETT_CONTROLS_MAX];
|
|
};
|
|
|
|
/********************** Enum Strings *************************/
|
|
|
|
static const struct scarlett_mixer_elem_enum_info opt_pad = {
|
|
.start = 0,
|
|
.len = 2,
|
|
.offsets = {},
|
|
.names = (char const * const []){
|
|
"0dB", "-10dB"
|
|
}
|
|
};
|
|
|
|
static const struct scarlett_mixer_elem_enum_info opt_impedance = {
|
|
.start = 0,
|
|
.len = 2,
|
|
.offsets = {},
|
|
.names = (char const * const []){
|
|
"Line", "Hi-Z"
|
|
}
|
|
};
|
|
|
|
static const struct scarlett_mixer_elem_enum_info opt_clock = {
|
|
.start = 1,
|
|
.len = 3,
|
|
.offsets = {},
|
|
.names = (char const * const []){
|
|
"Internal", "SPDIF", "ADAT"
|
|
}
|
|
};
|
|
|
|
static const struct scarlett_mixer_elem_enum_info opt_sync = {
|
|
.start = 0,
|
|
.len = 2,
|
|
.offsets = {},
|
|
.names = (char const * const []){
|
|
"No Lock", "Locked"
|
|
}
|
|
};
|
|
|
|
static int scarlett_ctl_switch_info(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
|
|
uinfo->count = elem->channels;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_switch_get(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
int i, err, val;
|
|
|
|
for (i = 0; i < elem->channels; i++) {
|
|
err = snd_usb_get_cur_mix_value(elem, i, i, &val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = !val; /* invert mute logic for mixer */
|
|
ucontrol->value.integer.value[i] = val;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_switch_put(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
int i, changed = 0;
|
|
int err, oval, val;
|
|
|
|
for (i = 0; i < elem->channels; i++) {
|
|
err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = ucontrol->value.integer.value[i];
|
|
val = !val;
|
|
if (oval != val) {
|
|
err = snd_usb_set_cur_mix_value(elem, i, i, val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
changed = 1;
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
static int scarlett_ctl_resume(struct usb_mixer_elem_list *list)
|
|
{
|
|
struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
|
|
int i;
|
|
|
|
for (i = 0; i < elem->channels; i++)
|
|
if (elem->cached & (1 << i))
|
|
snd_usb_set_cur_mix_value(elem, i, i,
|
|
elem->cache_val[i]);
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_info(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
|
|
uinfo->count = elem->channels;
|
|
uinfo->value.integer.min = 0;
|
|
uinfo->value.integer.max = (int)kctl->private_value +
|
|
SND_SCARLETT_LEVEL_BIAS;
|
|
uinfo->value.integer.step = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_get(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
int i, err, val;
|
|
|
|
for (i = 0; i < elem->channels; i++) {
|
|
err = snd_usb_get_cur_mix_value(elem, i, i, &val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = clamp(val / 256, -128, (int)kctl->private_value) +
|
|
SND_SCARLETT_LEVEL_BIAS;
|
|
ucontrol->value.integer.value[i] = val;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_put(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
int i, changed = 0;
|
|
int err, oval, val;
|
|
|
|
for (i = 0; i < elem->channels; i++) {
|
|
err = snd_usb_get_cur_mix_value(elem, i, i, &oval);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = ucontrol->value.integer.value[i] -
|
|
SND_SCARLETT_LEVEL_BIAS;
|
|
val = val * 256;
|
|
if (oval != val) {
|
|
err = snd_usb_set_cur_mix_value(elem, i, i, val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
changed = 1;
|
|
}
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
static void scarlett_generate_name(int i, char *dst, int offsets[])
|
|
{
|
|
if (i > offsets[SCARLETT_OFFSET_MIX])
|
|
sprintf(dst, "Mix %c",
|
|
'A'+(i - offsets[SCARLETT_OFFSET_MIX] - 1));
|
|
else if (i > offsets[SCARLETT_OFFSET_ADAT])
|
|
sprintf(dst, "ADAT %d", i - offsets[SCARLETT_OFFSET_ADAT]);
|
|
else if (i > offsets[SCARLETT_OFFSET_SPDIF])
|
|
sprintf(dst, "SPDIF %d", i - offsets[SCARLETT_OFFSET_SPDIF]);
|
|
else if (i > offsets[SCARLETT_OFFSET_ANALOG])
|
|
sprintf(dst, "Analog %d", i - offsets[SCARLETT_OFFSET_ANALOG]);
|
|
else if (i > offsets[SCARLETT_OFFSET_PCM])
|
|
sprintf(dst, "PCM %d", i - offsets[SCARLETT_OFFSET_PCM]);
|
|
else
|
|
sprintf(dst, "Off");
|
|
}
|
|
|
|
static int scarlett_ctl_enum_dynamic_info(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
|
|
unsigned int items = opt->len;
|
|
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
|
uinfo->count = elem->channels;
|
|
uinfo->value.enumerated.items = items;
|
|
|
|
if (uinfo->value.enumerated.item >= items)
|
|
uinfo->value.enumerated.item = items - 1;
|
|
|
|
/* generate name dynamically based on item number and offset info */
|
|
scarlett_generate_name(uinfo->value.enumerated.item,
|
|
uinfo->value.enumerated.name,
|
|
opt->offsets);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_enum_info(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_info *uinfo)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
|
|
|
|
return snd_ctl_enum_info(uinfo, elem->channels, opt->len,
|
|
(const char * const *)opt->names);
|
|
}
|
|
|
|
static int scarlett_ctl_enum_get(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
|
|
int err, val;
|
|
|
|
err = snd_usb_get_cur_mix_value(elem, 0, 0, &val);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = clamp(val - opt->start, 0, opt->len-1);
|
|
|
|
ucontrol->value.enumerated.item[0] = val;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_enum_put(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
struct scarlett_mixer_elem_enum_info *opt = elem->private_data;
|
|
int err, oval, val;
|
|
|
|
err = snd_usb_get_cur_mix_value(elem, 0, 0, &oval);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
val = ucontrol->value.integer.value[0];
|
|
val = val + opt->start;
|
|
if (val != oval) {
|
|
snd_usb_set_cur_mix_value(elem, 0, 0, val);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_enum_resume(struct usb_mixer_elem_list *list)
|
|
{
|
|
struct usb_mixer_elem_info *elem = mixer_elem_list_to_info(list);
|
|
|
|
if (elem->cached)
|
|
snd_usb_set_cur_mix_value(elem, 0, 0, *elem->cache_val);
|
|
return 0;
|
|
}
|
|
|
|
static int scarlett_ctl_meter_get(struct snd_kcontrol *kctl,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
|
struct snd_usb_audio *chip = elem->head.mixer->chip;
|
|
unsigned char buf[2 * MAX_CHANNELS] = {0, };
|
|
int wValue = (elem->control << 8) | elem->idx_off;
|
|
int idx = snd_usb_ctrl_intf(chip) | (elem->head.id << 8);
|
|
int err;
|
|
|
|
err = snd_usb_ctl_msg(chip->dev,
|
|
usb_rcvctrlpipe(chip->dev, 0),
|
|
UAC2_CS_MEM,
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS |
|
|
USB_DIR_IN, wValue, idx, buf, elem->channels);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
ucontrol->value.enumerated.item[0] = clamp((int)buf[0], 0, 1);
|
|
return 0;
|
|
}
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl_switch = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "",
|
|
.info = scarlett_ctl_switch_info,
|
|
.get = scarlett_ctl_switch_get,
|
|
.put = scarlett_ctl_switch_put,
|
|
};
|
|
|
|
static const DECLARE_TLV_DB_SCALE(db_scale_scarlett_gain, -12800, 100, 0);
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ,
|
|
.name = "",
|
|
.info = scarlett_ctl_info,
|
|
.get = scarlett_ctl_get,
|
|
.put = scarlett_ctl_put,
|
|
.private_value = 6, /* max value */
|
|
.tlv = { .p = db_scale_scarlett_gain }
|
|
};
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl_master = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ,
|
|
.name = "",
|
|
.info = scarlett_ctl_info,
|
|
.get = scarlett_ctl_get,
|
|
.put = scarlett_ctl_put,
|
|
.private_value = 6, /* max value */
|
|
.tlv = { .p = db_scale_scarlett_gain }
|
|
};
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl_enum = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "",
|
|
.info = scarlett_ctl_enum_info,
|
|
.get = scarlett_ctl_enum_get,
|
|
.put = scarlett_ctl_enum_put,
|
|
};
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl_dynamic_enum = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.name = "",
|
|
.info = scarlett_ctl_enum_dynamic_info,
|
|
.get = scarlett_ctl_enum_get,
|
|
.put = scarlett_ctl_enum_put,
|
|
};
|
|
|
|
static const struct snd_kcontrol_new usb_scarlett_ctl_sync = {
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
|
|
.name = "",
|
|
.info = scarlett_ctl_enum_info,
|
|
.get = scarlett_ctl_meter_get,
|
|
};
|
|
|
|
static int add_new_ctl(struct usb_mixer_interface *mixer,
|
|
const struct snd_kcontrol_new *ncontrol,
|
|
usb_mixer_elem_resume_func_t resume,
|
|
int index, int offset, int num,
|
|
int val_type, int channels, const char *name,
|
|
const struct scarlett_mixer_elem_enum_info *opt,
|
|
struct usb_mixer_elem_info **elem_ret
|
|
)
|
|
{
|
|
struct snd_kcontrol *kctl;
|
|
struct usb_mixer_elem_info *elem;
|
|
int err;
|
|
|
|
elem = kzalloc(sizeof(*elem), GFP_KERNEL);
|
|
if (!elem)
|
|
return -ENOMEM;
|
|
|
|
elem->head.mixer = mixer;
|
|
elem->head.resume = resume;
|
|
elem->control = offset;
|
|
elem->idx_off = num;
|
|
elem->head.id = index;
|
|
elem->val_type = val_type;
|
|
|
|
elem->channels = channels;
|
|
|
|
/* add scarlett_mixer_elem_enum_info struct */
|
|
elem->private_data = (void *)opt;
|
|
|
|
kctl = snd_ctl_new1(ncontrol, elem);
|
|
if (!kctl) {
|
|
kfree(elem);
|
|
return -ENOMEM;
|
|
}
|
|
kctl->private_free = snd_usb_mixer_elem_free;
|
|
|
|
strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
|
|
|
|
err = snd_usb_mixer_add_control(&elem->head, kctl);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
if (elem_ret)
|
|
*elem_ret = elem;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int add_output_ctls(struct usb_mixer_interface *mixer,
|
|
int index, const char *name,
|
|
const struct scarlett_device_info *info)
|
|
{
|
|
int err;
|
|
char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
|
struct usb_mixer_elem_info *elem;
|
|
|
|
/* Add mute switch */
|
|
snprintf(mx, sizeof(mx), "Master %d (%s) Playback Switch",
|
|
index + 1, name);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
|
|
scarlett_ctl_resume, 0x0a, 0x01,
|
|
2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add volume control and initialize to 0 */
|
|
snprintf(mx, sizeof(mx), "Master %d (%s) Playback Volume",
|
|
index + 1, name);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
|
|
scarlett_ctl_resume, 0x0a, 0x02,
|
|
2*index+1, USB_MIXER_S16, 2, mx, NULL, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add L channel source playback enumeration */
|
|
snprintf(mx, sizeof(mx), "Master %dL (%s) Source Playback Enum",
|
|
index + 1, name);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
|
|
scarlett_ctl_enum_resume, 0x33, 0x00,
|
|
2*index, USB_MIXER_S16, 1, mx, &info->opt_master,
|
|
&elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* Add R channel source playback enumeration */
|
|
snprintf(mx, sizeof(mx), "Master %dR (%s) Source Playback Enum",
|
|
index + 1, name);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
|
|
scarlett_ctl_enum_resume, 0x33, 0x00,
|
|
2*index+1, USB_MIXER_S16, 1, mx, &info->opt_master,
|
|
&elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/********************** device-specific config *************************/
|
|
|
|
/* untested... */
|
|
static struct scarlett_device_info s6i6_info = {
|
|
.matrix_in = 18,
|
|
.matrix_out = 8,
|
|
.input_len = 6,
|
|
.output_len = 6,
|
|
|
|
.opt_master = {
|
|
.start = -1,
|
|
.len = 27,
|
|
.offsets = {0, 12, 16, 18, 18},
|
|
.names = NULL
|
|
},
|
|
|
|
.opt_matrix = {
|
|
.start = -1,
|
|
.len = 19,
|
|
.offsets = {0, 12, 16, 18, 18},
|
|
.names = NULL
|
|
},
|
|
|
|
.num_controls = 9,
|
|
.controls = {
|
|
{ .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
|
|
{ .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
|
|
{ .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
|
|
{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
},
|
|
|
|
.matrix_mux_init = {
|
|
12, 13, 14, 15, /* Analog -> 1..4 */
|
|
16, 17, /* SPDIF -> 5,6 */
|
|
0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */
|
|
8, 9, 10, 11
|
|
}
|
|
};
|
|
|
|
/* untested... */
|
|
static struct scarlett_device_info s8i6_info = {
|
|
.matrix_in = 18,
|
|
.matrix_out = 6,
|
|
.input_len = 8,
|
|
.output_len = 6,
|
|
|
|
.opt_master = {
|
|
.start = -1,
|
|
.len = 25,
|
|
.offsets = {0, 12, 16, 18, 18},
|
|
.names = NULL
|
|
},
|
|
|
|
.opt_matrix = {
|
|
.start = -1,
|
|
.len = 19,
|
|
.offsets = {0, 12, 16, 18, 18},
|
|
.names = NULL
|
|
},
|
|
|
|
.num_controls = 7,
|
|
.controls = {
|
|
{ .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
|
|
{ .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
|
|
{ .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
|
|
{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
},
|
|
|
|
.matrix_mux_init = {
|
|
12, 13, 14, 15, /* Analog -> 1..4 */
|
|
16, 17, /* SPDIF -> 5,6 */
|
|
0, 1, 2, 3, 4, 5, 6, 7, /* PCM[1..12] -> 7..18 */
|
|
8, 9, 10, 11
|
|
}
|
|
};
|
|
|
|
static struct scarlett_device_info s18i6_info = {
|
|
.matrix_in = 18,
|
|
.matrix_out = 6,
|
|
.input_len = 18,
|
|
.output_len = 6,
|
|
|
|
.opt_master = {
|
|
.start = -1,
|
|
.len = 31,
|
|
.offsets = {0, 6, 14, 16, 24},
|
|
.names = NULL,
|
|
},
|
|
|
|
.opt_matrix = {
|
|
.start = -1,
|
|
.len = 25,
|
|
.offsets = {0, 6, 14, 16, 24},
|
|
.names = NULL,
|
|
},
|
|
|
|
.num_controls = 5,
|
|
.controls = {
|
|
{ .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
|
|
{ .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone" },
|
|
{ .num = 2, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
|
|
{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
},
|
|
|
|
.matrix_mux_init = {
|
|
6, 7, 8, 9, 10, 11, 12, 13, /* Analog -> 1..8 */
|
|
16, 17, 18, 19, 20, 21, /* ADAT[1..6] -> 9..14 */
|
|
14, 15, /* SPDIF -> 15,16 */
|
|
0, 1 /* PCM[1,2] -> 17,18 */
|
|
}
|
|
};
|
|
|
|
static struct scarlett_device_info s18i8_info = {
|
|
.matrix_in = 18,
|
|
.matrix_out = 8,
|
|
.input_len = 18,
|
|
.output_len = 8,
|
|
|
|
.opt_master = {
|
|
.start = -1,
|
|
.len = 35,
|
|
.offsets = {0, 8, 16, 18, 26},
|
|
.names = NULL
|
|
},
|
|
|
|
.opt_matrix = {
|
|
.start = -1,
|
|
.len = 27,
|
|
.offsets = {0, 8, 16, 18, 26},
|
|
.names = NULL
|
|
},
|
|
|
|
.num_controls = 10,
|
|
.controls = {
|
|
{ .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
|
|
{ .num = 1, .type = SCARLETT_OUTPUTS, .name = "Headphone 1" },
|
|
{ .num = 2, .type = SCARLETT_OUTPUTS, .name = "Headphone 2" },
|
|
{ .num = 3, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
|
|
{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
},
|
|
|
|
.matrix_mux_init = {
|
|
8, 9, 10, 11, 12, 13, 14, 15, /* Analog -> 1..8 */
|
|
18, 19, 20, 21, 22, 23, /* ADAT[1..6] -> 9..14 */
|
|
16, 17, /* SPDIF -> 15,16 */
|
|
0, 1 /* PCM[1,2] -> 17,18 */
|
|
}
|
|
};
|
|
|
|
static struct scarlett_device_info s18i20_info = {
|
|
.matrix_in = 18,
|
|
.matrix_out = 8,
|
|
.input_len = 18,
|
|
.output_len = 20,
|
|
|
|
.opt_master = {
|
|
.start = -1,
|
|
.len = 47,
|
|
.offsets = {0, 20, 28, 30, 38},
|
|
.names = NULL
|
|
},
|
|
|
|
.opt_matrix = {
|
|
.start = -1,
|
|
.len = 39,
|
|
.offsets = {0, 20, 28, 30, 38},
|
|
.names = NULL
|
|
},
|
|
|
|
.num_controls = 10,
|
|
.controls = {
|
|
{ .num = 0, .type = SCARLETT_OUTPUTS, .name = "Monitor" },
|
|
{ .num = 1, .type = SCARLETT_OUTPUTS, .name = "Line 3/4" },
|
|
{ .num = 2, .type = SCARLETT_OUTPUTS, .name = "Line 5/6" },
|
|
{ .num = 3, .type = SCARLETT_OUTPUTS, .name = "Line 7/8" },
|
|
{ .num = 4, .type = SCARLETT_OUTPUTS, .name = "Line 9/10" },
|
|
{ .num = 5, .type = SCARLETT_OUTPUTS, .name = "SPDIF" },
|
|
{ .num = 6, .type = SCARLETT_OUTPUTS, .name = "ADAT 1/2" },
|
|
{ .num = 7, .type = SCARLETT_OUTPUTS, .name = "ADAT 3/4" },
|
|
{ .num = 8, .type = SCARLETT_OUTPUTS, .name = "ADAT 5/6" },
|
|
{ .num = 9, .type = SCARLETT_OUTPUTS, .name = "ADAT 7/8" },
|
|
/*{ .num = 1, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 1, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_IMPEDANCE, .name = NULL},
|
|
{ .num = 2, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 3, .type = SCARLETT_SWITCH_PAD, .name = NULL},
|
|
{ .num = 4, .type = SCARLETT_SWITCH_PAD, .name = NULL},*/
|
|
},
|
|
|
|
.matrix_mux_init = {
|
|
20, 21, 22, 23, 24, 25, 26, 27, /* Analog -> 1..8 */
|
|
30, 31, 32, 33, 34, 35, /* ADAT[1..6] -> 9..14 */
|
|
28, 29, /* SPDIF -> 15,16 */
|
|
0, 1 /* PCM[1,2] -> 17,18 */
|
|
}
|
|
};
|
|
|
|
|
|
static int scarlett_controls_create_generic(struct usb_mixer_interface *mixer,
|
|
struct scarlett_device_info *info)
|
|
{
|
|
int i, err;
|
|
char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
|
const struct scarlett_mixer_control *ctl;
|
|
struct usb_mixer_elem_info *elem;
|
|
|
|
/* create master switch and playback volume */
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_switch,
|
|
scarlett_ctl_resume, 0x0a, 0x01, 0,
|
|
USB_MIXER_S16, 1, "Master Playback Switch", NULL,
|
|
&elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_master,
|
|
scarlett_ctl_resume, 0x0a, 0x02, 0,
|
|
USB_MIXER_S16, 1, "Master Playback Volume", NULL,
|
|
&elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* iterate through controls in info struct and create each one */
|
|
for (i = 0; i < info->num_controls; i++) {
|
|
ctl = &info->controls[i];
|
|
|
|
switch (ctl->type) {
|
|
case SCARLETT_OUTPUTS:
|
|
err = add_output_ctls(mixer, ctl->num, ctl->name, info);
|
|
if (err < 0)
|
|
return err;
|
|
break;
|
|
case SCARLETT_SWITCH_IMPEDANCE:
|
|
sprintf(mx, "Input %d Impedance Switch", ctl->num);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
|
|
scarlett_ctl_enum_resume, 0x01,
|
|
0x09, ctl->num, USB_MIXER_S16, 1, mx,
|
|
&opt_impedance, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
break;
|
|
case SCARLETT_SWITCH_PAD:
|
|
sprintf(mx, "Input %d Pad Switch", ctl->num);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
|
|
scarlett_ctl_enum_resume, 0x01,
|
|
0x0b, ctl->num, USB_MIXER_S16, 1, mx,
|
|
&opt_pad, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Create and initialize a mixer for the Focusrite(R) Scarlett
|
|
*/
|
|
int snd_scarlett_controls_create(struct usb_mixer_interface *mixer)
|
|
{
|
|
int err, i, o;
|
|
char mx[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
|
struct scarlett_device_info *info;
|
|
struct usb_mixer_elem_info *elem;
|
|
static char sample_rate_buffer[4] = { '\x80', '\xbb', '\x00', '\x00' };
|
|
|
|
/* only use UAC_VERSION_2 */
|
|
if (!mixer->protocol)
|
|
return 0;
|
|
|
|
switch (mixer->chip->usb_id) {
|
|
case USB_ID(0x1235, 0x8012):
|
|
info = &s6i6_info;
|
|
break;
|
|
case USB_ID(0x1235, 0x8002):
|
|
info = &s8i6_info;
|
|
break;
|
|
case USB_ID(0x1235, 0x8004):
|
|
info = &s18i6_info;
|
|
break;
|
|
case USB_ID(0x1235, 0x8014):
|
|
info = &s18i8_info;
|
|
break;
|
|
case USB_ID(0x1235, 0x800c):
|
|
info = &s18i20_info;
|
|
break;
|
|
default: /* device not (yet) supported */
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* generic function to create controls */
|
|
err = scarlett_controls_create_generic(mixer, info);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* setup matrix controls */
|
|
for (i = 0; i < info->matrix_in; i++) {
|
|
snprintf(mx, sizeof(mx), "Matrix %02d Input Playback Route",
|
|
i+1);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
|
|
scarlett_ctl_enum_resume, 0x32,
|
|
0x06, i, USB_MIXER_S16, 1, mx,
|
|
&info->opt_matrix, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
for (o = 0; o < info->matrix_out; o++) {
|
|
sprintf(mx, "Matrix %02d Mix %c Playback Volume", i+1,
|
|
o+'A');
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl,
|
|
scarlett_ctl_resume, 0x3c, 0x00,
|
|
(i << 3) + (o & 0x07), USB_MIXER_S16,
|
|
1, mx, NULL, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < info->input_len; i++) {
|
|
snprintf(mx, sizeof(mx), "Input Source %02d Capture Route",
|
|
i+1);
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_dynamic_enum,
|
|
scarlett_ctl_enum_resume, 0x34,
|
|
0x00, i, USB_MIXER_S16, 1, mx,
|
|
&info->opt_master, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
}
|
|
|
|
/* val_len == 1 needed here */
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_enum,
|
|
scarlett_ctl_enum_resume, 0x28, 0x01, 0,
|
|
USB_MIXER_U8, 1, "Sample Clock Source",
|
|
&opt_clock, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* val_len == 1 and UAC2_CS_MEM */
|
|
err = add_new_ctl(mixer, &usb_scarlett_ctl_sync, NULL, 0x3c, 0x00, 2,
|
|
USB_MIXER_U8, 1, "Sample Clock Sync Status",
|
|
&opt_sync, &elem);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
/* initialize sampling rate to 48000 */
|
|
err = snd_usb_ctl_msg(mixer->chip->dev,
|
|
usb_sndctrlpipe(mixer->chip->dev, 0), UAC2_CS_CUR,
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS |
|
|
USB_DIR_OUT, 0x0100, snd_usb_ctrl_intf(mixer->chip) |
|
|
(0x29 << 8), sample_rate_buffer, 4);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
return err;
|
|
}
|