4198 lines
114 KiB
C
4198 lines
114 KiB
C
|
// SPDX-License-Identifier: GPL-2.0
|
||
|
|
/*
|
||
|
|
* Focusrite Scarlett Gen 2/3 and Clarett+ Driver for ALSA
|
||
|
|
*
|
||
|
|
* Supported models:
|
||
|
|
* - 6i6/18i8/18i20 Gen 2
|
||
|
|
* - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
|
||
|
|
* - Clarett+ 8Pre
|
||
|
|
*
|
||
|
|
* Copyright (c) 2018-2022 by Geoffrey D. Bennett <g at b4.vu>
|
||
|
|
* Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
|
||
|
|
* Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com>
|
||
|
|
*
|
||
|
|
* Based on the Scarlett (Gen 1) 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>
|
||
|
|
*/
|
||
|
|
|
||
|
|
/* The protocol was reverse engineered by looking at the communication
|
||
|
|
* between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
|
||
|
|
* (firmware 1083) using usbmon in July-August 2018.
|
||
|
|
*
|
||
|
|
* Scarlett 18i8 support added in April 2019.
|
||
|
|
*
|
||
|
|
* Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
|
||
|
|
* for providing usbmon output and testing).
|
||
|
|
*
|
||
|
|
* Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
|
||
|
|
* Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
|
||
|
|
* usbmon output and testing).
|
||
|
|
*
|
||
|
|
* Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
|
||
|
|
* Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon
|
||
|
|
* output, protocol traces and testing).
|
||
|
|
*
|
||
|
|
* Support for loading mixer volume and mux configuration from the
|
||
|
|
* interface during driver initialisation added in May 2021 (thanks to
|
||
|
|
* Vladimir Sadovnikov for figuring out how).
|
||
|
|
*
|
||
|
|
* Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
|
||
|
|
* Vorona for 2i2 protocol traces).
|
||
|
|
*
|
||
|
|
* Support for phantom power, direct monitoring, speaker switching,
|
||
|
|
* and talkback added in May-June 2021.
|
||
|
|
*
|
||
|
|
* Support for Clarett+ 8Pre added in Aug 2022 by Christian
|
||
|
|
* Colglazier.
|
||
|
|
*
|
||
|
|
* This ALSA mixer gives access to (model-dependent):
|
||
|
|
* - input, output, mixer-matrix muxes
|
||
|
|
* - mixer-matrix gain stages
|
||
|
|
* - gain/volume/mute controls
|
||
|
|
* - level meters
|
||
|
|
* - line/inst level, pad, and air controls
|
||
|
|
* - phantom power, direct monitor, speaker switching, and talkback
|
||
|
|
* controls
|
||
|
|
* - disable/enable MSD mode
|
||
|
|
* - disable/enable standalone mode
|
||
|
|
*
|
||
|
|
* <ditaa>
|
||
|
|
* /--------------\ 18chn 20chn /--------------\
|
||
|
|
* | Hardware in +--+------\ /-------------+--+ ALSA PCM out |
|
||
|
|
* \--------------/ | | | | \--------------/
|
||
|
|
* | | | /-----\ |
|
||
|
|
* | | | | | |
|
||
|
|
* | v v v | |
|
||
|
|
* | +---------------+ | |
|
||
|
|
* | \ Matrix Mux / | |
|
||
|
|
* | +-----+-----+ | |
|
||
|
|
* | | | |
|
||
|
|
* | |18chn | |
|
||
|
|
* | | | |
|
||
|
|
* | | 10chn| |
|
||
|
|
* | v | |
|
||
|
|
* | +------------+ | |
|
||
|
|
* | | Mixer | | |
|
||
|
|
* | | Matrix | | |
|
||
|
|
* | | | | |
|
||
|
|
* | | 18x10 Gain | | |
|
||
|
|
* | | stages | | |
|
||
|
|
* | +-----+------+ | |
|
||
|
|
* | | | |
|
||
|
|
* |18chn |10chn | |20chn
|
||
|
|
* | | | |
|
||
|
|
* | +----------/ |
|
||
|
|
* | | |
|
||
|
|
* v v v
|
||
|
|
* ===========================
|
||
|
|
* +---------------+ +--—------------+
|
||
|
|
* \ Output Mux / \ Capture Mux /
|
||
|
|
* +---+---+---+ +-----+-----+
|
||
|
|
* | | |
|
||
|
|
* 10chn| | |18chn
|
||
|
|
* | | |
|
||
|
|
* /--------------\ | | | /--------------\
|
||
|
|
* | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in |
|
||
|
|
* | Hardware out | | \--------------/
|
||
|
|
* \--------------/ |
|
||
|
|
* v
|
||
|
|
* +-------------+ Software gain per channel.
|
||
|
|
* | Master Gain |<-- 18i20 only: Switch per channel
|
||
|
|
* +------+------+ to select HW or SW gain control.
|
||
|
|
* |
|
||
|
|
* |10chn
|
||
|
|
* /--------------\ |
|
||
|
|
* | Analogue |<------/
|
||
|
|
* | Hardware out |
|
||
|
|
* \--------------/
|
||
|
|
* </ditaa>
|
||
|
|
*
|
||
|
|
* Gen 3 devices have a Mass Storage Device (MSD) mode where a small
|
||
|
|
* disk with registration and driver download information is presented
|
||
|
|
* to the host. To access the full functionality of the device without
|
||
|
|
* proprietary software, MSD mode can be disabled by:
|
||
|
|
* - holding down the 48V button for five seconds while powering on
|
||
|
|
* the device, or
|
||
|
|
* - using this driver and alsamixer to change the "MSD Mode" setting
|
||
|
|
* to Off and power-cycling the device
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <linux/slab.h>
|
||
|
|
#include <linux/usb.h>
|
||
|
|
#include <linux/moduleparam.h>
|
||
|
|
|
||
|
|
#include <sound/control.h>
|
||
|
|
#include <sound/tlv.h>
|
||
|
|
|
||
|
|
#include "usbaudio.h"
|
||
|
|
#include "mixer.h"
|
||
|
|
#include "helper.h"
|
||
|
|
|
||
|
|
#include "mixer_scarlett_gen2.h"
|
||
|
|
|
||
|
|
/* device_setup value to enable */
|
||
|
|
#define SCARLETT2_ENABLE 0x01
|
||
|
|
|
||
|
|
/* device_setup value to allow turning MSD mode back on */
|
||
|
|
#define SCARLETT2_MSD_ENABLE 0x02
|
||
|
|
|
||
|
|
/* some gui mixers can't handle negative ctl values */
|
||
|
|
#define SCARLETT2_VOLUME_BIAS 127
|
||
|
|
|
||
|
|
/* mixer range from -80dB to +6dB in 0.5dB steps */
|
||
|
|
#define SCARLETT2_MIXER_MIN_DB -80
|
||
|
|
#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
|
||
|
|
#define SCARLETT2_MIXER_MAX_DB 6
|
||
|
|
#define SCARLETT2_MIXER_MAX_VALUE \
|
||
|
|
((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
|
||
|
|
#define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1)
|
||
|
|
|
||
|
|
/* map from (dB + 80) * 2 to mixer value
|
||
|
|
* for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
|
||
|
|
*/
|
||
|
|
static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = {
|
||
|
|
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
|
||
|
|
2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
|
||
|
|
9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
|
||
|
|
23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
|
||
|
|
54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
|
||
|
|
122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
|
||
|
|
244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
|
||
|
|
487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
|
||
|
|
973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
|
||
|
|
1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
|
||
|
|
3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
|
||
|
|
5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
|
||
|
|
9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
|
||
|
|
16345
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Maximum number of analogue outputs */
|
||
|
|
#define SCARLETT2_ANALOGUE_MAX 10
|
||
|
|
|
||
|
|
/* Maximum number of level and pad switches */
|
||
|
|
#define SCARLETT2_LEVEL_SWITCH_MAX 2
|
||
|
|
#define SCARLETT2_PAD_SWITCH_MAX 8
|
||
|
|
#define SCARLETT2_AIR_SWITCH_MAX 8
|
||
|
|
#define SCARLETT2_PHANTOM_SWITCH_MAX 2
|
||
|
|
|
||
|
|
/* Maximum number of inputs to the mixer */
|
||
|
|
#define SCARLETT2_INPUT_MIX_MAX 25
|
||
|
|
|
||
|
|
/* Maximum number of outputs from the mixer */
|
||
|
|
#define SCARLETT2_OUTPUT_MIX_MAX 12
|
||
|
|
|
||
|
|
/* Maximum size of the data in the USB mux assignment message:
|
||
|
|
* 20 inputs, 20 outputs, 25 matrix inputs, 12 spare
|
||
|
|
*/
|
||
|
|
#define SCARLETT2_MUX_MAX 77
|
||
|
|
|
||
|
|
/* Maximum number of meters (sum of output port counts) */
|
||
|
|
#define SCARLETT2_MAX_METERS 65
|
||
|
|
|
||
|
|
/* There are three different sets of configuration parameters across
|
||
|
|
* the devices
|
||
|
|
*/
|
||
|
|
enum {
|
||
|
|
SCARLETT2_CONFIG_SET_NO_MIXER = 0,
|
||
|
|
SCARLETT2_CONFIG_SET_GEN_2 = 1,
|
||
|
|
SCARLETT2_CONFIG_SET_GEN_3 = 2,
|
||
|
|
SCARLETT2_CONFIG_SET_CLARETT = 3,
|
||
|
|
SCARLETT2_CONFIG_SET_COUNT = 4
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Hardware port types:
|
||
|
|
* - None (no input to mux)
|
||
|
|
* - Analogue I/O
|
||
|
|
* - S/PDIF I/O
|
||
|
|
* - ADAT I/O
|
||
|
|
* - Mixer I/O
|
||
|
|
* - PCM I/O
|
||
|
|
*/
|
||
|
|
enum {
|
||
|
|
SCARLETT2_PORT_TYPE_NONE = 0,
|
||
|
|
SCARLETT2_PORT_TYPE_ANALOGUE = 1,
|
||
|
|
SCARLETT2_PORT_TYPE_SPDIF = 2,
|
||
|
|
SCARLETT2_PORT_TYPE_ADAT = 3,
|
||
|
|
SCARLETT2_PORT_TYPE_MIX = 4,
|
||
|
|
SCARLETT2_PORT_TYPE_PCM = 5,
|
||
|
|
SCARLETT2_PORT_TYPE_COUNT = 6,
|
||
|
|
};
|
||
|
|
|
||
|
|
/* I/O count of each port type kept in struct scarlett2_ports */
|
||
|
|
enum {
|
||
|
|
SCARLETT2_PORT_IN = 0,
|
||
|
|
SCARLETT2_PORT_OUT = 1,
|
||
|
|
SCARLETT2_PORT_DIRNS = 2,
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Dim/Mute buttons on the 18i20 */
|
||
|
|
enum {
|
||
|
|
SCARLETT2_BUTTON_MUTE = 0,
|
||
|
|
SCARLETT2_BUTTON_DIM = 1,
|
||
|
|
SCARLETT2_DIM_MUTE_COUNT = 2,
|
||
|
|
};
|
||
|
|
|
||
|
|
static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = {
|
||
|
|
"Mute Playback Switch", "Dim Playback Switch"
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Description of each hardware port type:
|
||
|
|
* - id: hardware ID of this port type
|
||
|
|
* - src_descr: printf format string for mux input selections
|
||
|
|
* - src_num_offset: added to channel number for the fprintf
|
||
|
|
* - dst_descr: printf format string for mixer controls
|
||
|
|
*/
|
||
|
|
struct scarlett2_port {
|
||
|
|
u16 id;
|
||
|
|
const char * const src_descr;
|
||
|
|
int src_num_offset;
|
||
|
|
const char * const dst_descr;
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = {
|
||
|
|
.id = 0x000,
|
||
|
|
.src_descr = "Off"
|
||
|
|
},
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = {
|
||
|
|
.id = 0x080,
|
||
|
|
.src_descr = "Analogue %d",
|
||
|
|
.src_num_offset = 1,
|
||
|
|
.dst_descr = "Analogue Output %02d Playback"
|
||
|
|
},
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = {
|
||
|
|
.id = 0x180,
|
||
|
|
.src_descr = "S/PDIF %d",
|
||
|
|
.src_num_offset = 1,
|
||
|
|
.dst_descr = "S/PDIF Output %d Playback"
|
||
|
|
},
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = {
|
||
|
|
.id = 0x200,
|
||
|
|
.src_descr = "ADAT %d",
|
||
|
|
.src_num_offset = 1,
|
||
|
|
.dst_descr = "ADAT Output %d Playback"
|
||
|
|
},
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = {
|
||
|
|
.id = 0x300,
|
||
|
|
.src_descr = "Mix %c",
|
||
|
|
.src_num_offset = 'A',
|
||
|
|
.dst_descr = "Mixer Input %02d Capture"
|
||
|
|
},
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = {
|
||
|
|
.id = 0x600,
|
||
|
|
.src_descr = "PCM %d",
|
||
|
|
.src_num_offset = 1,
|
||
|
|
.dst_descr = "PCM %02d Capture"
|
||
|
|
},
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Number of mux tables: one for each band of sample rates
|
||
|
|
* (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz)
|
||
|
|
*/
|
||
|
|
#define SCARLETT2_MUX_TABLES 3
|
||
|
|
|
||
|
|
/* Maximum number of entries in a mux table */
|
||
|
|
#define SCARLETT2_MAX_MUX_ENTRIES 10
|
||
|
|
|
||
|
|
/* One entry within mux_assignment defines the port type and range of
|
||
|
|
* ports to add to the set_mux message. The end of the list is marked
|
||
|
|
* with count == 0.
|
||
|
|
*/
|
||
|
|
struct scarlett2_mux_entry {
|
||
|
|
u8 port_type;
|
||
|
|
u8 start;
|
||
|
|
u8 count;
|
||
|
|
};
|
||
|
|
|
||
|
|
struct scarlett2_device_info {
|
||
|
|
u32 usb_id; /* USB device identifier */
|
||
|
|
|
||
|
|
/* Gen 3 devices have an internal MSD mode switch that needs
|
||
|
|
* to be disabled in order to access the full functionality of
|
||
|
|
* the device.
|
||
|
|
*/
|
||
|
|
u8 has_msd_mode;
|
||
|
|
|
||
|
|
/* which set of configuration parameters the device uses */
|
||
|
|
u8 config_set;
|
||
|
|
|
||
|
|
/* line out hw volume is sw controlled */
|
||
|
|
u8 line_out_hw_vol;
|
||
|
|
|
||
|
|
/* support for main/alt speaker switching */
|
||
|
|
u8 has_speaker_switching;
|
||
|
|
|
||
|
|
/* support for talkback microphone */
|
||
|
|
u8 has_talkback;
|
||
|
|
|
||
|
|
/* the number of analogue inputs with a software switchable
|
||
|
|
* level control that can be set to line or instrument
|
||
|
|
*/
|
||
|
|
u8 level_input_count;
|
||
|
|
|
||
|
|
/* the first input with a level control (0-based) */
|
||
|
|
u8 level_input_first;
|
||
|
|
|
||
|
|
/* the number of analogue inputs with a software switchable
|
||
|
|
* 10dB pad control
|
||
|
|
*/
|
||
|
|
u8 pad_input_count;
|
||
|
|
|
||
|
|
/* the number of analogue inputs with a software switchable
|
||
|
|
* "air" control
|
||
|
|
*/
|
||
|
|
u8 air_input_count;
|
||
|
|
|
||
|
|
/* the number of phantom (48V) software switchable controls */
|
||
|
|
u8 phantom_count;
|
||
|
|
|
||
|
|
/* the number of inputs each phantom switch controls */
|
||
|
|
u8 inputs_per_phantom;
|
||
|
|
|
||
|
|
/* the number of direct monitor options
|
||
|
|
* (0 = none, 1 = mono only, 2 = mono/stereo)
|
||
|
|
*/
|
||
|
|
u8 direct_monitor;
|
||
|
|
|
||
|
|
/* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected
|
||
|
|
* internally to the analogue 7/8 outputs
|
||
|
|
*/
|
||
|
|
u8 line_out_remap_enable;
|
||
|
|
u8 line_out_remap[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
/* additional description for the line out volume controls */
|
||
|
|
const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
/* number of sources/destinations of each port type */
|
||
|
|
const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS];
|
||
|
|
|
||
|
|
/* layout/order of the entries in the set_mux message */
|
||
|
|
struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES]
|
||
|
|
[SCARLETT2_MAX_MUX_ENTRIES];
|
||
|
|
};
|
||
|
|
|
||
|
|
struct scarlett2_data {
|
||
|
|
struct usb_mixer_interface *mixer;
|
||
|
|
struct mutex usb_mutex; /* prevent sending concurrent USB requests */
|
||
|
|
struct mutex data_mutex; /* lock access to this data */
|
||
|
|
struct delayed_work work;
|
||
|
|
const struct scarlett2_device_info *info;
|
||
|
|
__u8 bInterfaceNumber;
|
||
|
|
__u8 bEndpointAddress;
|
||
|
|
__u16 wMaxPacketSize;
|
||
|
|
__u8 bInterval;
|
||
|
|
int num_mux_srcs;
|
||
|
|
int num_mux_dsts;
|
||
|
|
u16 scarlett2_seq;
|
||
|
|
u8 sync_updated;
|
||
|
|
u8 vol_updated;
|
||
|
|
u8 input_other_updated;
|
||
|
|
u8 monitor_other_updated;
|
||
|
|
u8 mux_updated;
|
||
|
|
u8 speaker_switching_switched;
|
||
|
|
u8 sync;
|
||
|
|
u8 master_vol;
|
||
|
|
u8 vol[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
|
||
|
|
u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
|
||
|
|
u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
|
||
|
|
u8 air_switch[SCARLETT2_AIR_SWITCH_MAX];
|
||
|
|
u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX];
|
||
|
|
u8 phantom_persistence;
|
||
|
|
u8 direct_monitor_switch;
|
||
|
|
u8 speaker_switching_switch;
|
||
|
|
u8 talkback_switch;
|
||
|
|
u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX];
|
||
|
|
u8 msd_switch;
|
||
|
|
u8 standalone_switch;
|
||
|
|
struct snd_kcontrol *sync_ctl;
|
||
|
|
struct snd_kcontrol *master_vol_ctl;
|
||
|
|
struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT];
|
||
|
|
struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX];
|
||
|
|
struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX];
|
||
|
|
struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX];
|
||
|
|
struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX];
|
||
|
|
struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX];
|
||
|
|
struct snd_kcontrol *direct_monitor_ctl;
|
||
|
|
struct snd_kcontrol *speaker_switching_ctl;
|
||
|
|
struct snd_kcontrol *talkback_ctl;
|
||
|
|
u8 mux[SCARLETT2_MUX_MAX];
|
||
|
|
u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Model-specific data ***/
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s6i6_gen2_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8203),
|
||
|
|
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_2,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 2,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 6, 6 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s18i8_gen2_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8204),
|
||
|
|
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_2,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 4,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor L",
|
||
|
|
"Monitor R",
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 8, 18 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 4 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s18i20_gen2_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8201),
|
||
|
|
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_2,
|
||
|
|
.line_out_hw_vol = 1,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor L",
|
||
|
|
"Monitor R",
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 6 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info solo_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8211),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_NO_MIXER,
|
||
|
|
.level_input_count = 1,
|
||
|
|
.level_input_first = 1,
|
||
|
|
.air_input_count = 1,
|
||
|
|
.phantom_count = 1,
|
||
|
|
.inputs_per_phantom = 1,
|
||
|
|
.direct_monitor = 1,
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s2i2_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8210),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_NO_MIXER,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.air_input_count = 2,
|
||
|
|
.phantom_count = 1,
|
||
|
|
.inputs_per_phantom = 2,
|
||
|
|
.direct_monitor = 2,
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s4i4_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8212),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_3,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 2,
|
||
|
|
.air_input_count = 2,
|
||
|
|
.phantom_count = 1,
|
||
|
|
.inputs_per_phantom = 2,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor L",
|
||
|
|
"Monitor R",
|
||
|
|
"Headphones L",
|
||
|
|
"Headphones R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 6, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 4, 6 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 6 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 16 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s8i6_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8213),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_3,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 2,
|
||
|
|
.air_input_count = 2,
|
||
|
|
.phantom_count = 1,
|
||
|
|
.inputs_per_phantom = 2,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 8, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 6, 10 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 18 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s18i8_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8214),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_3,
|
||
|
|
.line_out_hw_vol = 1,
|
||
|
|
.has_speaker_switching = 1,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 4,
|
||
|
|
.air_input_count = 4,
|
||
|
|
.phantom_count = 2,
|
||
|
|
.inputs_per_phantom = 2,
|
||
|
|
|
||
|
|
.line_out_remap_enable = 1,
|
||
|
|
.line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 },
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor L",
|
||
|
|
"Monitor R",
|
||
|
|
"Alt Monitor L",
|
||
|
|
"Alt Monitor R",
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 10, 20 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 8, 20 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 12, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 10, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 12, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 10, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 20 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info s18i20_gen3_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x8215),
|
||
|
|
|
||
|
|
.has_msd_mode = 1,
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_GEN_3,
|
||
|
|
.line_out_hw_vol = 1,
|
||
|
|
.has_speaker_switching = 1,
|
||
|
|
.has_talkback = 1,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.pad_input_count = 8,
|
||
|
|
.air_input_count = 8,
|
||
|
|
.phantom_count = 2,
|
||
|
|
.inputs_per_phantom = 4,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor 1 L",
|
||
|
|
"Monitor 1 R",
|
||
|
|
"Monitor 2 L",
|
||
|
|
"Monitor 2 R",
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 12, 25 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 20, 20 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 10, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 25 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 12 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 10, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 8, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 25 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 10 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 24 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info clarett_8pre_info = {
|
||
|
|
.usb_id = USB_ID(0x1235, 0x820c),
|
||
|
|
|
||
|
|
.config_set = SCARLETT2_CONFIG_SET_CLARETT,
|
||
|
|
.line_out_hw_vol = 1,
|
||
|
|
.level_input_count = 2,
|
||
|
|
.air_input_count = 8,
|
||
|
|
|
||
|
|
.line_out_descrs = {
|
||
|
|
"Monitor L",
|
||
|
|
"Monitor R",
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
NULL,
|
||
|
|
"Headphones 1 L",
|
||
|
|
"Headphones 1 R",
|
||
|
|
"Headphones 2 L",
|
||
|
|
"Headphones 2 R",
|
||
|
|
},
|
||
|
|
|
||
|
|
.port_count = {
|
||
|
|
[SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },
|
||
|
|
[SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },
|
||
|
|
[SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },
|
||
|
|
[SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },
|
||
|
|
[SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },
|
||
|
|
},
|
||
|
|
|
||
|
|
.mux_assignment = { {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 8 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 14 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ADAT, 0, 4 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_MIX, 0, 18 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 8 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
}, {
|
||
|
|
{ SCARLETT2_PORT_TYPE_PCM, 0, 12 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },
|
||
|
|
{ SCARLETT2_PORT_TYPE_NONE, 0, 22 },
|
||
|
|
{ 0, 0, 0 },
|
||
|
|
} },
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_device_info *scarlett2_devices[] = {
|
||
|
|
/* Supported Gen 2 devices */
|
||
|
|
&s6i6_gen2_info,
|
||
|
|
&s18i8_gen2_info,
|
||
|
|
&s18i20_gen2_info,
|
||
|
|
|
||
|
|
/* Supported Gen 3 devices */
|
||
|
|
&solo_gen3_info,
|
||
|
|
&s2i2_gen3_info,
|
||
|
|
&s4i4_gen3_info,
|
||
|
|
&s8i6_gen3_info,
|
||
|
|
&s18i8_gen3_info,
|
||
|
|
&s18i20_gen3_info,
|
||
|
|
|
||
|
|
/* Supported Clarett+ devices */
|
||
|
|
&clarett_8pre_info,
|
||
|
|
|
||
|
|
/* End of list */
|
||
|
|
NULL
|
||
|
|
};
|
||
|
|
|
||
|
|
/* get the starting port index number for a given port type/direction */
|
||
|
|
static int scarlett2_get_port_start_num(
|
||
|
|
const int port_count[][SCARLETT2_PORT_DIRNS],
|
||
|
|
int direction, int port_type)
|
||
|
|
{
|
||
|
|
int i, num = 0;
|
||
|
|
|
||
|
|
for (i = 0; i < port_type; i++)
|
||
|
|
num += port_count[i][direction];
|
||
|
|
|
||
|
|
return num;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** USB Interactions ***/
|
||
|
|
|
||
|
|
/* Notifications from the interface */
|
||
|
|
#define SCARLETT2_USB_NOTIFY_SYNC 0x00000008
|
||
|
|
#define SCARLETT2_USB_NOTIFY_DIM_MUTE 0x00200000
|
||
|
|
#define SCARLETT2_USB_NOTIFY_MONITOR 0x00400000
|
||
|
|
#define SCARLETT2_USB_NOTIFY_INPUT_OTHER 0x00800000
|
||
|
|
#define SCARLETT2_USB_NOTIFY_MONITOR_OTHER 0x01000000
|
||
|
|
|
||
|
|
/* Commands for sending/receiving requests/responses */
|
||
|
|
#define SCARLETT2_USB_CMD_INIT 0
|
||
|
|
#define SCARLETT2_USB_CMD_REQ 2
|
||
|
|
#define SCARLETT2_USB_CMD_RESP 3
|
||
|
|
|
||
|
|
#define SCARLETT2_USB_INIT_1 0x00000000
|
||
|
|
#define SCARLETT2_USB_INIT_2 0x00000002
|
||
|
|
#define SCARLETT2_USB_GET_METER 0x00001001
|
||
|
|
#define SCARLETT2_USB_GET_MIX 0x00002001
|
||
|
|
#define SCARLETT2_USB_SET_MIX 0x00002002
|
||
|
|
#define SCARLETT2_USB_GET_MUX 0x00003001
|
||
|
|
#define SCARLETT2_USB_SET_MUX 0x00003002
|
||
|
|
#define SCARLETT2_USB_GET_SYNC 0x00006004
|
||
|
|
#define SCARLETT2_USB_GET_DATA 0x00800000
|
||
|
|
#define SCARLETT2_USB_SET_DATA 0x00800001
|
||
|
|
#define SCARLETT2_USB_DATA_CMD 0x00800002
|
||
|
|
|
||
|
|
#define SCARLETT2_USB_CONFIG_SAVE 6
|
||
|
|
|
||
|
|
#define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
|
||
|
|
#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
|
||
|
|
|
||
|
|
/* volume status is read together (matches scarlett2_config_items[1]) */
|
||
|
|
struct scarlett2_usb_volume_status {
|
||
|
|
/* dim/mute buttons */
|
||
|
|
u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];
|
||
|
|
|
||
|
|
u8 pad1;
|
||
|
|
|
||
|
|
/* software volume setting */
|
||
|
|
s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
/* actual volume of output inc. dim (-18dB) */
|
||
|
|
s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
/* internal mute buttons */
|
||
|
|
u8 mute_switch[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
/* sw (0) or hw (1) controlled */
|
||
|
|
u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
|
||
|
|
|
||
|
|
u8 pad3[6];
|
||
|
|
|
||
|
|
/* front panel volume knob */
|
||
|
|
s16 master_vol;
|
||
|
|
} __packed;
|
||
|
|
|
||
|
|
/* Configuration parameters that can be read and written */
|
||
|
|
enum {
|
||
|
|
SCARLETT2_CONFIG_DIM_MUTE = 0,
|
||
|
|
SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
|
||
|
|
SCARLETT2_CONFIG_MUTE_SWITCH = 2,
|
||
|
|
SCARLETT2_CONFIG_SW_HW_SWITCH = 3,
|
||
|
|
SCARLETT2_CONFIG_LEVEL_SWITCH = 4,
|
||
|
|
SCARLETT2_CONFIG_PAD_SWITCH = 5,
|
||
|
|
SCARLETT2_CONFIG_MSD_SWITCH = 6,
|
||
|
|
SCARLETT2_CONFIG_AIR_SWITCH = 7,
|
||
|
|
SCARLETT2_CONFIG_STANDALONE_SWITCH = 8,
|
||
|
|
SCARLETT2_CONFIG_PHANTOM_SWITCH = 9,
|
||
|
|
SCARLETT2_CONFIG_PHANTOM_PERSISTENCE = 10,
|
||
|
|
SCARLETT2_CONFIG_DIRECT_MONITOR = 11,
|
||
|
|
SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH = 12,
|
||
|
|
SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE = 13,
|
||
|
|
SCARLETT2_CONFIG_TALKBACK_MAP = 14,
|
||
|
|
SCARLETT2_CONFIG_COUNT = 15
|
||
|
|
};
|
||
|
|
|
||
|
|
/* Location, size, and activation command number for the configuration
|
||
|
|
* parameters. Size is in bits and may be 1, 8, or 16.
|
||
|
|
*/
|
||
|
|
struct scarlett2_config {
|
||
|
|
u8 offset;
|
||
|
|
u8 size;
|
||
|
|
u8 activate;
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct scarlett2_config
|
||
|
|
scarlett2_config_items[SCARLETT2_CONFIG_SET_COUNT]
|
||
|
|
[SCARLETT2_CONFIG_COUNT] =
|
||
|
|
|
||
|
|
/* Devices without a mixer (Gen 3 Solo and 2i2) */
|
||
|
|
{ {
|
||
|
|
[SCARLETT2_CONFIG_MSD_SWITCH] = {
|
||
|
|
.offset = 0x04, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
|
||
|
|
.offset = 0x05, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
|
||
|
|
.offset = 0x06, .size = 8, .activate = 3 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_DIRECT_MONITOR] = {
|
||
|
|
.offset = 0x07, .size = 8, .activate = 4 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
|
||
|
|
.offset = 0x08, .size = 1, .activate = 7 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_AIR_SWITCH] = {
|
||
|
|
.offset = 0x09, .size = 1, .activate = 8 },
|
||
|
|
|
||
|
|
/* Gen 2 devices: 6i6, 18i8, 18i20 */
|
||
|
|
}, {
|
||
|
|
[SCARLETT2_CONFIG_DIM_MUTE] = {
|
||
|
|
.offset = 0x31, .size = 8, .activate = 2 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
|
||
|
|
.offset = 0x34, .size = 16, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MUTE_SWITCH] = {
|
||
|
|
.offset = 0x5c, .size = 8, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
|
||
|
|
.offset = 0x66, .size = 8, .activate = 3 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
|
||
|
|
.offset = 0x7c, .size = 8, .activate = 7 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PAD_SWITCH] = {
|
||
|
|
.offset = 0x84, .size = 8, .activate = 8 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
|
||
|
|
.offset = 0x8d, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
/* Gen 3 devices: 4i4, 8i6, 18i8, 18i20 */
|
||
|
|
}, {
|
||
|
|
[SCARLETT2_CONFIG_DIM_MUTE] = {
|
||
|
|
.offset = 0x31, .size = 8, .activate = 2 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
|
||
|
|
.offset = 0x34, .size = 16, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MUTE_SWITCH] = {
|
||
|
|
.offset = 0x5c, .size = 8, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
|
||
|
|
.offset = 0x66, .size = 8, .activate = 3 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
|
||
|
|
.offset = 0x7c, .size = 8, .activate = 7 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PAD_SWITCH] = {
|
||
|
|
.offset = 0x84, .size = 8, .activate = 8 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_AIR_SWITCH] = {
|
||
|
|
.offset = 0x8c, .size = 8, .activate = 8 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
|
||
|
|
.offset = 0x95, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PHANTOM_SWITCH] = {
|
||
|
|
.offset = 0x9c, .size = 1, .activate = 8 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MSD_SWITCH] = {
|
||
|
|
.offset = 0x9d, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {
|
||
|
|
.offset = 0x9e, .size = 8, .activate = 6 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = {
|
||
|
|
.offset = 0x9f, .size = 1, .activate = 10 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = {
|
||
|
|
.offset = 0xa0, .size = 1, .activate = 10 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_TALKBACK_MAP] = {
|
||
|
|
.offset = 0xb0, .size = 16, .activate = 10 },
|
||
|
|
|
||
|
|
/* Clarett+ 8Pre */
|
||
|
|
}, {
|
||
|
|
[SCARLETT2_CONFIG_DIM_MUTE] = {
|
||
|
|
.offset = 0x31, .size = 8, .activate = 2 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {
|
||
|
|
.offset = 0x34, .size = 16, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_MUTE_SWITCH] = {
|
||
|
|
.offset = 0x5c, .size = 8, .activate = 1 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_SW_HW_SWITCH] = {
|
||
|
|
.offset = 0x66, .size = 8, .activate = 3 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_LEVEL_SWITCH] = {
|
||
|
|
.offset = 0x7c, .size = 8, .activate = 7 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_AIR_SWITCH] = {
|
||
|
|
.offset = 0x95, .size = 8, .activate = 8 },
|
||
|
|
|
||
|
|
[SCARLETT2_CONFIG_STANDALONE_SWITCH] = {
|
||
|
|
.offset = 0x8d, .size = 8, .activate = 6 },
|
||
|
|
} };
|
||
|
|
|
||
|
|
/* proprietary request/response format */
|
||
|
|
struct scarlett2_usb_packet {
|
||
|
|
__le32 cmd;
|
||
|
|
__le16 size;
|
||
|
|
__le16 seq;
|
||
|
|
__le32 error;
|
||
|
|
__le32 pad;
|
||
|
|
u8 data[];
|
||
|
|
};
|
||
|
|
|
||
|
|
static void scarlett2_fill_request_header(struct scarlett2_data *private,
|
||
|
|
struct scarlett2_usb_packet *req,
|
||
|
|
u32 cmd, u16 req_size)
|
||
|
|
{
|
||
|
|
/* sequence must go up by 1 for each request */
|
||
|
|
u16 seq = private->scarlett2_seq++;
|
||
|
|
|
||
|
|
req->cmd = cpu_to_le32(cmd);
|
||
|
|
req->size = cpu_to_le16(req_size);
|
||
|
|
req->seq = cpu_to_le16(seq);
|
||
|
|
req->error = 0;
|
||
|
|
req->pad = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_usb_tx(struct usb_device *dev, int interface,
|
||
|
|
void *buf, u16 size)
|
||
|
|
{
|
||
|
|
return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
|
||
|
|
SCARLETT2_USB_CMD_REQ,
|
||
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
|
||
|
|
0, interface, buf, size);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_usb_rx(struct usb_device *dev, int interface,
|
||
|
|
u32 usb_req, void *buf, u16 size)
|
||
|
|
{
|
||
|
|
return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
|
||
|
|
usb_req,
|
||
|
|
USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
|
||
|
|
0, interface, buf, size);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a proprietary format request to the Scarlett interface */
|
||
|
|
static int scarlett2_usb(
|
||
|
|
struct usb_mixer_interface *mixer, u32 cmd,
|
||
|
|
void *req_data, u16 req_size, void *resp_data, u16 resp_size)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
struct usb_device *dev = mixer->chip->dev;
|
||
|
|
struct scarlett2_usb_packet *req, *resp = NULL;
|
||
|
|
size_t req_buf_size = struct_size(req, data, req_size);
|
||
|
|
size_t resp_buf_size = struct_size(resp, data, resp_size);
|
||
|
|
int err;
|
||
|
|
|
||
|
|
req = kmalloc(req_buf_size, GFP_KERNEL);
|
||
|
|
if (!req) {
|
||
|
|
err = -ENOMEM;
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
resp = kmalloc(resp_buf_size, GFP_KERNEL);
|
||
|
|
if (!resp) {
|
||
|
|
err = -ENOMEM;
|
||
|
|
goto error;
|
||
|
|
}
|
||
|
|
|
||
|
|
mutex_lock(&private->usb_mutex);
|
||
|
|
|
||
|
|
/* build request message and send it */
|
||
|
|
|
||
|
|
scarlett2_fill_request_header(private, req, cmd, req_size);
|
||
|
|
|
||
|
|
if (req_size)
|
||
|
|
memcpy(req->data, req_data, req_size);
|
||
|
|
|
||
|
|
err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
|
||
|
|
req, req_buf_size);
|
||
|
|
|
||
|
|
if (err != req_buf_size) {
|
||
|
|
usb_audio_err(
|
||
|
|
mixer->chip,
|
||
|
|
"Scarlett Gen 2/3 USB request result cmd %x was %d\n",
|
||
|
|
cmd, err);
|
||
|
|
err = -EINVAL;
|
||
|
|
goto unlock;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* send a second message to get the response */
|
||
|
|
|
||
|
|
err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
|
||
|
|
SCARLETT2_USB_CMD_RESP,
|
||
|
|
resp, resp_buf_size);
|
||
|
|
|
||
|
|
/* validate the response */
|
||
|
|
|
||
|
|
if (err != resp_buf_size) {
|
||
|
|
usb_audio_err(
|
||
|
|
mixer->chip,
|
||
|
|
"Scarlett Gen 2/3 USB response result cmd %x was %d "
|
||
|
|
"expected %zu\n",
|
||
|
|
cmd, err, resp_buf_size);
|
||
|
|
err = -EINVAL;
|
||
|
|
goto unlock;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* cmd/seq/size should match except when initialising
|
||
|
|
* seq sent = 1, response = 0
|
||
|
|
*/
|
||
|
|
if (resp->cmd != req->cmd ||
|
||
|
|
(resp->seq != req->seq &&
|
||
|
|
(le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
|
||
|
|
resp_size != le16_to_cpu(resp->size) ||
|
||
|
|
resp->error ||
|
||
|
|
resp->pad) {
|
||
|
|
usb_audio_err(
|
||
|
|
mixer->chip,
|
||
|
|
"Scarlett Gen 2/3 USB invalid response; "
|
||
|
|
"cmd tx/rx %d/%d seq %d/%d size %d/%d "
|
||
|
|
"error %d pad %d\n",
|
||
|
|
le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
|
||
|
|
le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
|
||
|
|
resp_size, le16_to_cpu(resp->size),
|
||
|
|
le32_to_cpu(resp->error),
|
||
|
|
le32_to_cpu(resp->pad));
|
||
|
|
err = -EINVAL;
|
||
|
|
goto unlock;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (resp_data && resp_size > 0)
|
||
|
|
memcpy(resp_data, resp->data, resp_size);
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->usb_mutex);
|
||
|
|
error:
|
||
|
|
kfree(req);
|
||
|
|
kfree(resp);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to get data; result placed in *buf */
|
||
|
|
static int scarlett2_usb_get(
|
||
|
|
struct usb_mixer_interface *mixer,
|
||
|
|
int offset, void *buf, int size)
|
||
|
|
{
|
||
|
|
struct {
|
||
|
|
__le32 offset;
|
||
|
|
__le32 size;
|
||
|
|
} __packed req;
|
||
|
|
|
||
|
|
req.offset = cpu_to_le32(offset);
|
||
|
|
req.size = cpu_to_le32(size);
|
||
|
|
return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
|
||
|
|
&req, sizeof(req), buf, size);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to get configuration parameters; result placed in *buf */
|
||
|
|
static int scarlett2_usb_get_config(
|
||
|
|
struct usb_mixer_interface *mixer,
|
||
|
|
int config_item_num, int count, void *buf)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const struct scarlett2_config *config_item =
|
||
|
|
&scarlett2_config_items[info->config_set][config_item_num];
|
||
|
|
int size, err, i;
|
||
|
|
u8 *buf_8;
|
||
|
|
u8 value;
|
||
|
|
|
||
|
|
/* For byte-sized parameters, retrieve directly into buf */
|
||
|
|
if (config_item->size >= 8) {
|
||
|
|
size = config_item->size / 8 * count;
|
||
|
|
err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
if (size == 2) {
|
||
|
|
u16 *buf_16 = buf;
|
||
|
|
|
||
|
|
for (i = 0; i < count; i++, buf_16++)
|
||
|
|
*buf_16 = le16_to_cpu(*(__le16 *)buf_16);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* For bit-sized parameters, retrieve into value */
|
||
|
|
err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* then unpack from value into buf[] */
|
||
|
|
buf_8 = buf;
|
||
|
|
for (i = 0; i < 8 && i < count; i++, value >>= 1)
|
||
|
|
*buf_8++ = value & 1;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
|
||
|
|
static void scarlett2_config_save(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
__le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
|
||
|
|
|
||
|
|
scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
|
||
|
|
&req, sizeof(u32),
|
||
|
|
NULL, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Delayed work to save config */
|
||
|
|
static void scarlett2_config_save_work(struct work_struct *work)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private =
|
||
|
|
container_of(work, struct scarlett2_data, work.work);
|
||
|
|
|
||
|
|
scarlett2_config_save(private->mixer);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to set a SCARLETT2_CONFIG_* parameter */
|
||
|
|
static int scarlett2_usb_set_config(
|
||
|
|
struct usb_mixer_interface *mixer,
|
||
|
|
int config_item_num, int index, int value)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const struct scarlett2_config *config_item =
|
||
|
|
&scarlett2_config_items[info->config_set][config_item_num];
|
||
|
|
struct {
|
||
|
|
__le32 offset;
|
||
|
|
__le32 bytes;
|
||
|
|
__le32 value;
|
||
|
|
} __packed req;
|
||
|
|
__le32 req2;
|
||
|
|
int offset, size;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
/* Cancel any pending NVRAM save */
|
||
|
|
cancel_delayed_work_sync(&private->work);
|
||
|
|
|
||
|
|
/* Convert config_item->size in bits to size in bytes and
|
||
|
|
* calculate offset
|
||
|
|
*/
|
||
|
|
if (config_item->size >= 8) {
|
||
|
|
size = config_item->size / 8;
|
||
|
|
offset = config_item->offset + index * size;
|
||
|
|
|
||
|
|
/* If updating a bit, retrieve the old value, set/clear the
|
||
|
|
* bit as needed, and update value
|
||
|
|
*/
|
||
|
|
} else {
|
||
|
|
u8 tmp;
|
||
|
|
|
||
|
|
size = 1;
|
||
|
|
offset = config_item->offset;
|
||
|
|
|
||
|
|
scarlett2_usb_get(mixer, offset, &tmp, 1);
|
||
|
|
if (value)
|
||
|
|
tmp |= (1 << index);
|
||
|
|
else
|
||
|
|
tmp &= ~(1 << index);
|
||
|
|
|
||
|
|
value = tmp;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send the configuration parameter data */
|
||
|
|
req.offset = cpu_to_le32(offset);
|
||
|
|
req.bytes = cpu_to_le32(size);
|
||
|
|
req.value = cpu_to_le32(value);
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
|
||
|
|
&req, sizeof(u32) * 2 + size,
|
||
|
|
NULL, 0);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Activate the change */
|
||
|
|
req2 = cpu_to_le32(config_item->activate);
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
|
||
|
|
&req2, sizeof(req2), NULL, 0);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Schedule the change to be written to NVRAM */
|
||
|
|
if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
|
||
|
|
schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to get sync status; result placed in *sync */
|
||
|
|
static int scarlett2_usb_get_sync_status(
|
||
|
|
struct usb_mixer_interface *mixer,
|
||
|
|
u8 *sync)
|
||
|
|
{
|
||
|
|
__le32 data;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
|
||
|
|
NULL, 0, &data, sizeof(data));
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
*sync = !!data;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to get volume status; result placed in *buf */
|
||
|
|
static int scarlett2_usb_get_volume_status(
|
||
|
|
struct usb_mixer_interface *mixer,
|
||
|
|
struct scarlett2_usb_volume_status *buf)
|
||
|
|
{
|
||
|
|
return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
|
||
|
|
buf, sizeof(*buf));
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to get the volumes for all inputs of one mix
|
||
|
|
* and put the values into private->mix[]
|
||
|
|
*/
|
||
|
|
static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
|
||
|
|
int mix_num)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
int num_mixer_in =
|
||
|
|
info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
|
||
|
|
int err, i, j, k;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
__le16 mix_num;
|
||
|
|
__le16 count;
|
||
|
|
} __packed req;
|
||
|
|
|
||
|
|
__le16 data[SCARLETT2_INPUT_MIX_MAX];
|
||
|
|
|
||
|
|
req.mix_num = cpu_to_le16(mix_num);
|
||
|
|
req.count = cpu_to_le16(num_mixer_in);
|
||
|
|
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
|
||
|
|
&req, sizeof(req),
|
||
|
|
data, num_mixer_in * sizeof(u16));
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) {
|
||
|
|
u16 mixer_value = le16_to_cpu(data[i]);
|
||
|
|
|
||
|
|
for (k = 0; k < SCARLETT2_MIXER_VALUE_COUNT; k++)
|
||
|
|
if (scarlett2_mixer_values[k] >= mixer_value)
|
||
|
|
break;
|
||
|
|
if (k == SCARLETT2_MIXER_VALUE_COUNT)
|
||
|
|
k = SCARLETT2_MIXER_MAX_VALUE;
|
||
|
|
private->mix[j] = k;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send a USB message to set the volumes for all inputs of one mix
|
||
|
|
* (values obtained from private->mix[])
|
||
|
|
*/
|
||
|
|
static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
|
||
|
|
int mix_num)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
__le16 mix_num;
|
||
|
|
__le16 data[SCARLETT2_INPUT_MIX_MAX];
|
||
|
|
} __packed req;
|
||
|
|
|
||
|
|
int i, j;
|
||
|
|
int num_mixer_in =
|
||
|
|
info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
|
||
|
|
|
||
|
|
req.mix_num = cpu_to_le16(mix_num);
|
||
|
|
|
||
|
|
for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
|
||
|
|
req.data[i] = cpu_to_le16(
|
||
|
|
scarlett2_mixer_values[private->mix[j]]
|
||
|
|
);
|
||
|
|
|
||
|
|
return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
|
||
|
|
&req, (num_mixer_in + 1) * sizeof(u16),
|
||
|
|
NULL, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Convert a port number index (per info->port_count) to a hardware ID */
|
||
|
|
static u32 scarlett2_mux_src_num_to_id(
|
||
|
|
const int port_count[][SCARLETT2_PORT_DIRNS], int num)
|
||
|
|
{
|
||
|
|
int port_type;
|
||
|
|
|
||
|
|
for (port_type = 0;
|
||
|
|
port_type < SCARLETT2_PORT_TYPE_COUNT;
|
||
|
|
port_type++) {
|
||
|
|
if (num < port_count[port_type][SCARLETT2_PORT_IN])
|
||
|
|
return scarlett2_ports[port_type].id | num;
|
||
|
|
num -= port_count[port_type][SCARLETT2_PORT_IN];
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Oops */
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Convert a hardware ID to a port number index */
|
||
|
|
static u32 scarlett2_mux_id_to_num(
|
||
|
|
const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)
|
||
|
|
{
|
||
|
|
int port_type;
|
||
|
|
int port_num = 0;
|
||
|
|
|
||
|
|
for (port_type = 0;
|
||
|
|
port_type < SCARLETT2_PORT_TYPE_COUNT;
|
||
|
|
port_type++) {
|
||
|
|
int base = scarlett2_ports[port_type].id;
|
||
|
|
int count = port_count[port_type][direction];
|
||
|
|
|
||
|
|
if (id >= base && id < base + count)
|
||
|
|
return port_num + id - base;
|
||
|
|
port_num += count;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Oops */
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Convert one mux entry from the interface and load into private->mux[] */
|
||
|
|
static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
|
||
|
|
u32 mux_entry)
|
||
|
|
{
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
|
||
|
|
int dst_idx, src_idx;
|
||
|
|
|
||
|
|
dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT,
|
||
|
|
mux_entry & 0xFFF);
|
||
|
|
if (dst_idx < 0)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (dst_idx >= private->num_mux_dsts) {
|
||
|
|
usb_audio_err(private->mixer->chip,
|
||
|
|
"BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",
|
||
|
|
mux_entry, dst_idx, private->num_mux_dsts);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN,
|
||
|
|
mux_entry >> 12);
|
||
|
|
if (src_idx < 0)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (src_idx >= private->num_mux_srcs) {
|
||
|
|
usb_audio_err(private->mixer->chip,
|
||
|
|
"BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",
|
||
|
|
mux_entry, src_idx, private->num_mux_srcs);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
private->mux[dst_idx] = src_idx;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send USB message to get mux inputs and then populate private->mux[] */
|
||
|
|
static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int count = private->num_mux_dsts;
|
||
|
|
int err, i;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
__le16 num;
|
||
|
|
__le16 count;
|
||
|
|
} __packed req;
|
||
|
|
|
||
|
|
__le32 data[SCARLETT2_MUX_MAX];
|
||
|
|
|
||
|
|
private->mux_updated = 0;
|
||
|
|
|
||
|
|
req.num = 0;
|
||
|
|
req.count = cpu_to_le16(count);
|
||
|
|
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
|
||
|
|
&req, sizeof(req),
|
||
|
|
data, count * sizeof(u32));
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
for (i = 0; i < count; i++)
|
||
|
|
scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send USB messages to set mux inputs */
|
||
|
|
static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int table;
|
||
|
|
|
||
|
|
struct {
|
||
|
|
__le16 pad;
|
||
|
|
__le16 num;
|
||
|
|
__le32 data[SCARLETT2_MUX_MAX];
|
||
|
|
} __packed req;
|
||
|
|
|
||
|
|
req.pad = 0;
|
||
|
|
|
||
|
|
/* set mux settings for each rate */
|
||
|
|
for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {
|
||
|
|
const struct scarlett2_mux_entry *entry;
|
||
|
|
|
||
|
|
/* i counts over the output array */
|
||
|
|
int i = 0, err;
|
||
|
|
|
||
|
|
req.num = cpu_to_le16(table);
|
||
|
|
|
||
|
|
/* loop through each entry */
|
||
|
|
for (entry = info->mux_assignment[table];
|
||
|
|
entry->count;
|
||
|
|
entry++) {
|
||
|
|
int j;
|
||
|
|
int port_type = entry->port_type;
|
||
|
|
int port_idx = entry->start;
|
||
|
|
int mux_idx = scarlett2_get_port_start_num(port_count,
|
||
|
|
SCARLETT2_PORT_OUT, port_type) + port_idx;
|
||
|
|
int dst_id = scarlett2_ports[port_type].id + port_idx;
|
||
|
|
|
||
|
|
/* Empty slots */
|
||
|
|
if (!dst_id) {
|
||
|
|
for (j = 0; j < entry->count; j++)
|
||
|
|
req.data[i++] = 0;
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Non-empty mux slots use the lower 12 bits
|
||
|
|
* for the destination and next 12 bits for
|
||
|
|
* the source
|
||
|
|
*/
|
||
|
|
for (j = 0; j < entry->count; j++) {
|
||
|
|
int src_id = scarlett2_mux_src_num_to_id(
|
||
|
|
port_count, private->mux[mux_idx++]);
|
||
|
|
req.data[i++] = cpu_to_le32(dst_id |
|
||
|
|
src_id << 12);
|
||
|
|
dst_id++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
|
||
|
|
&req, (i + 1) * sizeof(u32),
|
||
|
|
NULL, 0);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Send USB message to get meter levels */
|
||
|
|
static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
|
||
|
|
u16 num_meters, u16 *levels)
|
||
|
|
{
|
||
|
|
struct {
|
||
|
|
__le16 pad;
|
||
|
|
__le16 num_meters;
|
||
|
|
__le32 magic;
|
||
|
|
} __packed req;
|
||
|
|
u32 resp[SCARLETT2_MAX_METERS];
|
||
|
|
int i, err;
|
||
|
|
|
||
|
|
req.pad = 0;
|
||
|
|
req.num_meters = cpu_to_le16(num_meters);
|
||
|
|
req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
|
||
|
|
&req, sizeof(req), resp, num_meters * sizeof(u32));
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* copy, convert to u16 */
|
||
|
|
for (i = 0; i < num_meters; i++)
|
||
|
|
levels[i] = resp[i];
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Control Functions ***/
|
||
|
|
|
||
|
|
/* helper function to create a new control */
|
||
|
|
static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
|
||
|
|
const struct snd_kcontrol_new *ncontrol,
|
||
|
|
int index, int channels, const char *name,
|
||
|
|
struct snd_kcontrol **kctl_return)
|
||
|
|
{
|
||
|
|
struct snd_kcontrol *kctl;
|
||
|
|
struct usb_mixer_elem_info *elem;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
elem = kzalloc(sizeof(*elem), GFP_KERNEL);
|
||
|
|
if (!elem)
|
||
|
|
return -ENOMEM;
|
||
|
|
|
||
|
|
/* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
|
||
|
|
* ignores them for resume and other operations.
|
||
|
|
* Also, the head.id field is set to 0, as we don't use this field.
|
||
|
|
*/
|
||
|
|
elem->head.mixer = mixer;
|
||
|
|
elem->control = index;
|
||
|
|
elem->head.id = 0;
|
||
|
|
elem->channels = channels;
|
||
|
|
elem->val_type = USB_MIXER_BESPOKEN;
|
||
|
|
|
||
|
|
kctl = snd_ctl_new1(ncontrol, elem);
|
||
|
|
if (!kctl) {
|
||
|
|
kfree(elem);
|
||
|
|
return -ENOMEM;
|
||
|
|
}
|
||
|
|
kctl->private_free = snd_usb_mixer_elem_free;
|
||
|
|
|
||
|
|
strscpy(kctl->id.name, name, sizeof(kctl->id.name));
|
||
|
|
|
||
|
|
err = snd_usb_mixer_add_control(&elem->head, kctl);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
if (kctl_return)
|
||
|
|
*kctl_return = kctl;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Sync Control ***/
|
||
|
|
|
||
|
|
/* Update sync control after receiving notification that the status
|
||
|
|
* has changed
|
||
|
|
*/
|
||
|
|
static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
private->sync_updated = 0;
|
||
|
|
return scarlett2_usb_get_sync_status(mixer, &private->sync);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *texts[2] = {
|
||
|
|
"Unlocked", "Locked"
|
||
|
|
};
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 2, texts);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->sync_updated)
|
||
|
|
scarlett2_update_sync(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->sync;
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_sync_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_sync_ctl_info,
|
||
|
|
.get = scarlett2_sync_ctl_get
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
/* devices without a mixer also don't support reporting sync status */
|
||
|
|
if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
|
||
|
|
0, 1, "Sync Status", &private->sync_ctl);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Analogue Line Out Volume Controls ***/
|
||
|
|
|
||
|
|
/* Update hardware volume controls after receiving notification that
|
||
|
|
* they have changed
|
||
|
|
*/
|
||
|
|
static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
struct scarlett2_usb_volume_status volume_status;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int err, i;
|
||
|
|
int mute;
|
||
|
|
|
||
|
|
private->vol_updated = 0;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_volume_status(mixer, &volume_status);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
private->master_vol = clamp(
|
||
|
|
volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
|
||
|
|
0, SCARLETT2_VOLUME_BIAS);
|
||
|
|
|
||
|
|
if (info->line_out_hw_vol)
|
||
|
|
for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
|
||
|
|
private->dim_mute[i] = !!volume_status.dim_mute[i];
|
||
|
|
|
||
|
|
mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
|
||
|
|
|
||
|
|
for (i = 0; i < num_line_out; i++)
|
||
|
|
if (private->vol_sw_hw_switch[i]) {
|
||
|
|
private->vol[i] = private->master_vol;
|
||
|
|
private->mute_switch[i] = mute;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_volume_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 = SCARLETT2_VOLUME_BIAS;
|
||
|
|
uinfo->value.integer.step = 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->vol_updated)
|
||
|
|
scarlett2_update_volumes(mixer);
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->master_vol;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int line_out_remap(struct scarlett2_data *private, int index)
|
||
|
|
{
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
if (!info->line_out_remap_enable)
|
||
|
|
return index;
|
||
|
|
return info->line_out_remap[index];
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = line_out_remap(private, elem->control);
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->vol_updated)
|
||
|
|
scarlett2_update_volumes(mixer);
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->vol[index];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = line_out_remap(private, elem->control);
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->vol[index];
|
||
|
|
val = ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->vol[index] = val;
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
|
||
|
|
index, val - SCARLETT2_VOLUME_BIAS);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const DECLARE_TLV_DB_MINMAX(
|
||
|
|
db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
|
||
|
|
);
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ |
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_volume_ctl_info,
|
||
|
|
.get = scarlett2_master_volume_ctl_get,
|
||
|
|
.private_value = 0, /* max value */
|
||
|
|
.tlv = { .p = db_scale_scarlett2_gain }
|
||
|
|
};
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_volume_ctl_info,
|
||
|
|
.get = scarlett2_volume_ctl_get,
|
||
|
|
.put = scarlett2_volume_ctl_put,
|
||
|
|
.private_value = 0, /* max value */
|
||
|
|
.tlv = { .p = db_scale_scarlett2_gain }
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Mute Switch Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = line_out_remap(private, elem->control);
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->vol_updated)
|
||
|
|
scarlett2_update_volumes(mixer);
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->mute_switch[index];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = line_out_remap(private, elem->control);
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->mute_switch[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->mute_switch[index] = val;
|
||
|
|
|
||
|
|
/* Send mute change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_mute_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_mute_ctl_get,
|
||
|
|
.put = scarlett2_mute_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** HW/SW Volume Switch Controls ***/
|
||
|
|
|
||
|
|
static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
|
||
|
|
{
|
||
|
|
private->sw_hw_ctls[index]->vd[0].access &=
|
||
|
|
~SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
|
||
|
|
{
|
||
|
|
private->sw_hw_ctls[index]->vd[0].access |=
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *const values[2] = {
|
||
|
|
"SW", "HW"
|
||
|
|
};
|
||
|
|
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 2, values);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
int index = line_out_remap(private, elem->control);
|
||
|
|
|
||
|
|
ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
|
||
|
|
int index, int value)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
|
||
|
|
/* Set/Clear write bits */
|
||
|
|
if (value) {
|
||
|
|
private->vol_ctls[index]->vd[0].access |=
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
private->mute_ctls[index]->vd[0].access |=
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
} else {
|
||
|
|
private->vol_ctls[index]->vd[0].access &=
|
||
|
|
~SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
private->mute_ctls[index]->vd[0].access &=
|
||
|
|
~SNDRV_CTL_ELEM_ACCESS_WRITE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify of write bit and possible value change */
|
||
|
|
snd_ctl_notify(card,
|
||
|
|
SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
|
||
|
|
&private->vol_ctls[index]->id);
|
||
|
|
snd_ctl_notify(card,
|
||
|
|
SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,
|
||
|
|
&private->mute_ctls[index]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
|
||
|
|
int ctl_index, int val)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = line_out_remap(private, ctl_index);
|
||
|
|
int err;
|
||
|
|
|
||
|
|
private->vol_sw_hw_switch[index] = val;
|
||
|
|
|
||
|
|
/* Change access mode to RO (hardware controlled volume)
|
||
|
|
* or RW (software controlled volume)
|
||
|
|
*/
|
||
|
|
scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
|
||
|
|
|
||
|
|
/* Reset volume/mute to master volume/mute */
|
||
|
|
private->vol[index] = private->master_vol;
|
||
|
|
private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
|
||
|
|
|
||
|
|
/* Set SW volume to current HW volume */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
|
||
|
|
index, private->master_vol - SCARLETT2_VOLUME_BIAS);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Set SW mute to current HW mute */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
|
||
|
|
index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Send SW/HW switch change to the device */
|
||
|
|
return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
|
||
|
|
index, val);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int ctl_index = elem->control;
|
||
|
|
int index = line_out_remap(private, ctl_index);
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->vol_sw_hw_switch[index];
|
||
|
|
val = !!ucontrol->value.enumerated.item[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
err = scarlett2_sw_hw_change(mixer, ctl_index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_sw_hw_enum_ctl_info,
|
||
|
|
.get = scarlett2_sw_hw_enum_ctl_get,
|
||
|
|
.put = scarlett2_sw_hw_enum_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Line Level/Instrument Level Switch Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_update_input_other(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
private->input_other_updated = 0;
|
||
|
|
|
||
|
|
if (info->level_input_count) {
|
||
|
|
int err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
|
||
|
|
info->level_input_count + info->level_input_first,
|
||
|
|
private->level_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info->pad_input_count) {
|
||
|
|
int err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_PAD_SWITCH,
|
||
|
|
info->pad_input_count, private->pad_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info->air_input_count) {
|
||
|
|
int err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_AIR_SWITCH,
|
||
|
|
info->air_input_count, private->air_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info->phantom_count) {
|
||
|
|
int err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
|
||
|
|
info->phantom_count, private->phantom_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
|
||
|
|
1, &private->phantom_persistence);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *const values[2] = {
|
||
|
|
"Line", "Inst"
|
||
|
|
};
|
||
|
|
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 2, values);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
int index = elem->control + info->level_input_first;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->input_other_updated)
|
||
|
|
scarlett2_update_input_other(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->level_switch[index];
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
int index = elem->control + info->level_input_first;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->level_switch[index];
|
||
|
|
val = !!ucontrol->value.enumerated.item[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->level_switch[index] = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_level_enum_ctl_info,
|
||
|
|
.get = scarlett2_level_enum_ctl_get,
|
||
|
|
.put = scarlett2_level_enum_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Pad Switch Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->input_other_updated)
|
||
|
|
scarlett2_update_input_other(mixer);
|
||
|
|
ucontrol->value.integer.value[0] =
|
||
|
|
private->pad_switch[elem->control];
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->pad_switch[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->pad_switch[index] = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_pad_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_pad_ctl_get,
|
||
|
|
.put = scarlett2_pad_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Air Switch Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->input_other_updated)
|
||
|
|
scarlett2_update_input_other(mixer);
|
||
|
|
ucontrol->value.integer.value[0] = private->air_switch[elem->control];
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->air_switch[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->air_switch[index] = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_air_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_air_ctl_get,
|
||
|
|
.put = scarlett2_air_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Phantom Switch Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->input_other_updated)
|
||
|
|
scarlett2_update_input_other(mixer);
|
||
|
|
ucontrol->value.integer.value[0] =
|
||
|
|
private->phantom_switch[elem->control];
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->phantom_switch[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->phantom_switch[index] = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_phantom_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_phantom_ctl_get,
|
||
|
|
.put = scarlett2_phantom_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Phantom Persistence Control ***/
|
||
|
|
|
||
|
|
static int scarlett2_phantom_persistence_ctl_get(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->phantom_persistence;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_phantom_persistence_ctl_put(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->phantom_persistence;
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->phantom_persistence = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_phantom_persistence_ctl_get,
|
||
|
|
.put = scarlett2_phantom_persistence_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Direct Monitor Control ***/
|
||
|
|
|
||
|
|
static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
/* monitor_other_enable[0] enables speaker switching
|
||
|
|
* monitor_other_enable[1] enables talkback
|
||
|
|
*/
|
||
|
|
u8 monitor_other_enable[2];
|
||
|
|
|
||
|
|
/* monitor_other_switch[0] activates the alternate speakers
|
||
|
|
* monitor_other_switch[1] activates talkback
|
||
|
|
*/
|
||
|
|
u8 monitor_other_switch[2];
|
||
|
|
|
||
|
|
private->monitor_other_updated = 0;
|
||
|
|
|
||
|
|
if (info->direct_monitor)
|
||
|
|
return scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
|
||
|
|
1, &private->direct_monitor_switch);
|
||
|
|
|
||
|
|
/* if it doesn't do speaker switching then it also doesn't do
|
||
|
|
* talkback
|
||
|
|
*/
|
||
|
|
if (!info->has_speaker_switching)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
|
||
|
|
2, monitor_other_enable);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
|
||
|
|
2, monitor_other_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
if (!monitor_other_enable[0])
|
||
|
|
private->speaker_switching_switch = 0;
|
||
|
|
else
|
||
|
|
private->speaker_switching_switch = monitor_other_switch[0] + 1;
|
||
|
|
|
||
|
|
if (info->has_talkback) {
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] =
|
||
|
|
info->port_count;
|
||
|
|
int num_mixes =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
|
||
|
|
u16 bitmap;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
if (!monitor_other_enable[1])
|
||
|
|
private->talkback_switch = 0;
|
||
|
|
else
|
||
|
|
private->talkback_switch = monitor_other_switch[1] + 1;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_config(mixer,
|
||
|
|
SCARLETT2_CONFIG_TALKBACK_MAP,
|
||
|
|
1, &bitmap);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
for (i = 0; i < num_mixes; i++, bitmap >>= 1)
|
||
|
|
private->talkback_map[i] = bitmap & 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_direct_monitor_ctl_get(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->monitor_other_updated)
|
||
|
|
scarlett2_update_monitor_other(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_direct_monitor_ctl_put(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->direct_monitor_switch;
|
||
|
|
val = min(ucontrol->value.enumerated.item[0], 2U);
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->direct_monitor_switch = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_direct_monitor_stereo_enum_ctl_info(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *const values[3] = {
|
||
|
|
"Off", "Mono", "Stereo"
|
||
|
|
};
|
||
|
|
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 3, values);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Direct Monitor for Solo is mono-only and only needs a boolean control
|
||
|
|
* Direct Monitor for 2i2 is selectable between Off/Mono/Stereo
|
||
|
|
*/
|
||
|
|
static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {
|
||
|
|
{
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_direct_monitor_ctl_get,
|
||
|
|
.put = scarlett2_direct_monitor_ctl_put,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_direct_monitor_stereo_enum_ctl_info,
|
||
|
|
.get = scarlett2_direct_monitor_ctl_get,
|
||
|
|
.put = scarlett2_direct_monitor_ctl_put,
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const char *s;
|
||
|
|
|
||
|
|
if (!info->direct_monitor)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
s = info->direct_monitor == 1
|
||
|
|
? "Direct Monitor Playback Switch"
|
||
|
|
: "Direct Monitor Playback Enum";
|
||
|
|
|
||
|
|
return scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
|
||
|
|
0, 1, s, &private->direct_monitor_ctl);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Speaker Switching Control ***/
|
||
|
|
|
||
|
|
static int scarlett2_speaker_switch_enum_ctl_info(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *const values[3] = {
|
||
|
|
"Off", "Main", "Alt"
|
||
|
|
};
|
||
|
|
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 3, values);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_speaker_switch_enum_ctl_get(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->monitor_other_updated)
|
||
|
|
scarlett2_update_monitor_other(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* when speaker switching gets enabled, switch the main/alt speakers
|
||
|
|
* to HW volume and disable those controls
|
||
|
|
*/
|
||
|
|
static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int i, err;
|
||
|
|
|
||
|
|
for (i = 0; i < 4; i++) {
|
||
|
|
int index = line_out_remap(private, i);
|
||
|
|
|
||
|
|
/* switch the main/alt speakers to HW volume */
|
||
|
|
if (!private->vol_sw_hw_switch[index]) {
|
||
|
|
err = scarlett2_sw_hw_change(private->mixer, i, 1);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* disable the line out SW/HW switch */
|
||
|
|
scarlett2_sw_hw_ctl_ro(private, i);
|
||
|
|
snd_ctl_notify(card,
|
||
|
|
SNDRV_CTL_EVENT_MASK_VALUE |
|
||
|
|
SNDRV_CTL_EVENT_MASK_INFO,
|
||
|
|
&private->sw_hw_ctls[i]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* when the next monitor-other notify comes in, update the mux
|
||
|
|
* configuration
|
||
|
|
*/
|
||
|
|
private->speaker_switching_switched = 1;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* when speaker switching gets disabled, reenable the hw/sw controls
|
||
|
|
* and invalidate the routing
|
||
|
|
*/
|
||
|
|
static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
/* enable the line out SW/HW switch */
|
||
|
|
for (i = 0; i < 4; i++) {
|
||
|
|
scarlett2_sw_hw_ctl_rw(private, i);
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,
|
||
|
|
&private->sw_hw_ctls[i]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* when the next monitor-other notify comes in, update the mux
|
||
|
|
* configuration
|
||
|
|
*/
|
||
|
|
private->speaker_switching_switched = 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_speaker_switch_enum_ctl_put(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->speaker_switching_switch;
|
||
|
|
val = min(ucontrol->value.enumerated.item[0], 2U);
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->speaker_switching_switch = val;
|
||
|
|
|
||
|
|
/* enable/disable speaker switching */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
|
||
|
|
0, !!val);
|
||
|
|
if (err < 0)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
/* if speaker switching is enabled, select main or alt */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
|
||
|
|
0, val == 2);
|
||
|
|
if (err < 0)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
/* update controls if speaker switching gets enabled or disabled */
|
||
|
|
if (!oval && val)
|
||
|
|
err = scarlett2_speaker_switch_enable(mixer);
|
||
|
|
else if (oval && !val)
|
||
|
|
scarlett2_speaker_switch_disable(mixer);
|
||
|
|
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_speaker_switch_enum_ctl_info,
|
||
|
|
.get = scarlett2_speaker_switch_enum_ctl_get,
|
||
|
|
.put = scarlett2_speaker_switch_enum_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_speaker_switch_ctl(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
if (!info->has_speaker_switching)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
return scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_speaker_switch_enum_ctl,
|
||
|
|
0, 1, "Speaker Switching Playback Enum",
|
||
|
|
&private->speaker_switching_ctl);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Talkback and Talkback Map Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_talkback_enum_ctl_info(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
static const char *const values[3] = {
|
||
|
|
"Disabled", "Off", "On"
|
||
|
|
};
|
||
|
|
|
||
|
|
return snd_ctl_enum_info(uinfo, 1, 3, values);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_talkback_enum_ctl_get(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->monitor_other_updated)
|
||
|
|
scarlett2_update_monitor_other(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->talkback_switch;
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_talkback_enum_ctl_put(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->talkback_switch;
|
||
|
|
val = min(ucontrol->value.enumerated.item[0], 2U);
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->talkback_switch = val;
|
||
|
|
|
||
|
|
/* enable/disable talkback */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
|
||
|
|
1, !!val);
|
||
|
|
if (err < 0)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
/* if talkback is enabled, select main or alt */
|
||
|
|
err = scarlett2_usb_set_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
|
||
|
|
1, val == 2);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_talkback_enum_ctl_info,
|
||
|
|
.get = scarlett2_talkback_enum_ctl_get,
|
||
|
|
.put = scarlett2_talkback_enum_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_talkback_map_ctl_get(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
int index = elem->control;
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->talkback_map[index];
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_talkback_map_ctl_put(
|
||
|
|
struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] =
|
||
|
|
private->info->port_count;
|
||
|
|
int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0, i;
|
||
|
|
u16 bitmap = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->talkback_map[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->talkback_map[index] = val;
|
||
|
|
|
||
|
|
for (i = 0; i < num_mixes; i++)
|
||
|
|
bitmap |= private->talkback_map[i] << i;
|
||
|
|
|
||
|
|
/* Send updated bitmap to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
|
||
|
|
0, bitmap);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_talkback_map_ctl_get,
|
||
|
|
.put = scarlett2_talkback_map_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_talkback_ctls(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
|
||
|
|
int err, i;
|
||
|
|
char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
||
|
|
|
||
|
|
if (!info->has_talkback)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
err = scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_talkback_enum_ctl,
|
||
|
|
0, 1, "Talkback Playback Enum",
|
||
|
|
&private->talkback_ctl);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
for (i = 0; i < num_mixes; i++) {
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Talkback Mix %c Playback Switch", i + 'A');
|
||
|
|
err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
|
||
|
|
i, 1, s, NULL);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Dim/Mute Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->vol_updated)
|
||
|
|
scarlett2_update_volumes(mixer);
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0, i;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->dim_mute[index];
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->dim_mute[index] = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
|
||
|
|
index, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
if (index == SCARLETT2_BUTTON_MUTE)
|
||
|
|
for (i = 0; i < num_line_out; i++) {
|
||
|
|
int line_index = line_out_remap(private, i);
|
||
|
|
|
||
|
|
if (private->vol_sw_hw_switch[line_index]) {
|
||
|
|
private->mute_switch[line_index] = val;
|
||
|
|
snd_ctl_notify(mixer->chip->card,
|
||
|
|
SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->mute_ctls[i]->id);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_dim_mute_ctl_get,
|
||
|
|
.put = scarlett2_dim_mute_ctl_put
|
||
|
|
};
|
||
|
|
|
||
|
|
/*** Create the analogue output controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int err, i;
|
||
|
|
char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
||
|
|
|
||
|
|
/* Add R/O HW volume control */
|
||
|
|
if (info->line_out_hw_vol) {
|
||
|
|
snprintf(s, sizeof(s), "Master HW Playback Volume");
|
||
|
|
err = scarlett2_add_new_ctl(mixer,
|
||
|
|
&scarlett2_master_volume_ctl,
|
||
|
|
0, 1, s, &private->master_vol_ctl);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add volume controls */
|
||
|
|
for (i = 0; i < num_line_out; i++) {
|
||
|
|
int index = line_out_remap(private, i);
|
||
|
|
|
||
|
|
/* Fader */
|
||
|
|
if (info->line_out_descrs[i])
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Line %02d (%s) Playback Volume",
|
||
|
|
i + 1, info->line_out_descrs[i]);
|
||
|
|
else
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Line %02d Playback Volume",
|
||
|
|
i + 1);
|
||
|
|
err = scarlett2_add_new_ctl(mixer,
|
||
|
|
&scarlett2_line_out_volume_ctl,
|
||
|
|
i, 1, s, &private->vol_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Mute Switch */
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Line %02d Mute Playback Switch",
|
||
|
|
i + 1);
|
||
|
|
err = scarlett2_add_new_ctl(mixer,
|
||
|
|
&scarlett2_mute_ctl,
|
||
|
|
i, 1, s,
|
||
|
|
&private->mute_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Make the fader and mute controls read-only if the
|
||
|
|
* SW/HW switch is set to HW
|
||
|
|
*/
|
||
|
|
if (private->vol_sw_hw_switch[index])
|
||
|
|
scarlett2_vol_ctl_set_writable(mixer, i, 0);
|
||
|
|
|
||
|
|
/* SW/HW Switch */
|
||
|
|
if (info->line_out_hw_vol) {
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Line Out %02d Volume Control Playback Enum",
|
||
|
|
i + 1);
|
||
|
|
err = scarlett2_add_new_ctl(mixer,
|
||
|
|
&scarlett2_sw_hw_enum_ctl,
|
||
|
|
i, 1, s,
|
||
|
|
&private->sw_hw_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Make the switch read-only if the line is
|
||
|
|
* involved in speaker switching
|
||
|
|
*/
|
||
|
|
if (private->speaker_switching_switch && i < 4)
|
||
|
|
scarlett2_sw_hw_ctl_ro(private, i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add dim/mute controls */
|
||
|
|
if (info->line_out_hw_vol)
|
||
|
|
for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {
|
||
|
|
err = scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_dim_mute_ctl,
|
||
|
|
i, 1, scarlett2_dim_mute_names[i],
|
||
|
|
&private->dim_mute_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Create the analogue input controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
int err, i;
|
||
|
|
char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
||
|
|
const char *fmt = "Line In %d %s Capture %s";
|
||
|
|
const char *fmt2 = "Line In %d-%d %s Capture %s";
|
||
|
|
|
||
|
|
/* Add input level (line/inst) controls */
|
||
|
|
for (i = 0; i < info->level_input_count; i++) {
|
||
|
|
snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
|
||
|
|
"Level", "Enum");
|
||
|
|
err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
|
||
|
|
i, 1, s, &private->level_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add input pad controls */
|
||
|
|
for (i = 0; i < info->pad_input_count; i++) {
|
||
|
|
snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");
|
||
|
|
err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
|
||
|
|
i, 1, s, &private->pad_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add input air controls */
|
||
|
|
for (i = 0; i < info->air_input_count; i++) {
|
||
|
|
snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch");
|
||
|
|
err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl,
|
||
|
|
i, 1, s, &private->air_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Add input phantom controls */
|
||
|
|
if (info->inputs_per_phantom == 1) {
|
||
|
|
for (i = 0; i < info->phantom_count; i++) {
|
||
|
|
snprintf(s, sizeof(s), fmt, i + 1,
|
||
|
|
"Phantom Power", "Switch");
|
||
|
|
err = scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_phantom_ctl,
|
||
|
|
i, 1, s, &private->phantom_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
} else if (info->inputs_per_phantom > 1) {
|
||
|
|
for (i = 0; i < info->phantom_count; i++) {
|
||
|
|
int from = i * info->inputs_per_phantom + 1;
|
||
|
|
int to = (i + 1) * info->inputs_per_phantom;
|
||
|
|
|
||
|
|
snprintf(s, sizeof(s), fmt2, from, to,
|
||
|
|
"Phantom Power", "Switch");
|
||
|
|
err = scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_phantom_ctl,
|
||
|
|
i, 1, s, &private->phantom_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (info->phantom_count) {
|
||
|
|
err = scarlett2_add_new_ctl(
|
||
|
|
mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
|
||
|
|
"Phantom Power Persistence Capture Switch", NULL);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Mixer Volume Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_mixer_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 = SCARLETT2_MIXER_MAX_VALUE;
|
||
|
|
uinfo->value.integer.step = 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->mix[elem->control];
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int oval, val, num_mixer_in, mix_num, err = 0;
|
||
|
|
int index = elem->control;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->mix[index];
|
||
|
|
val = ucontrol->value.integer.value[0];
|
||
|
|
num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
|
||
|
|
mix_num = index / num_mixer_in;
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->mix[index] = val;
|
||
|
|
err = scarlett2_usb_set_mix(mixer, mix_num);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const DECLARE_TLV_DB_MINMAX(
|
||
|
|
db_scale_scarlett2_mixer,
|
||
|
|
SCARLETT2_MIXER_MIN_DB * 100,
|
||
|
|
SCARLETT2_MIXER_MAX_DB * 100
|
||
|
|
);
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
|
||
|
|
SNDRV_CTL_ELEM_ACCESS_TLV_READ,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_mixer_ctl_info,
|
||
|
|
.get = scarlett2_mixer_ctl_get,
|
||
|
|
.put = scarlett2_mixer_ctl_put,
|
||
|
|
.private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
|
||
|
|
.tlv = { .p = db_scale_scarlett2_mixer }
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int err, i, j;
|
||
|
|
int index;
|
||
|
|
char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
||
|
|
|
||
|
|
int num_inputs =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT];
|
||
|
|
int num_outputs =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
|
||
|
|
|
||
|
|
for (i = 0, index = 0; i < num_outputs; i++)
|
||
|
|
for (j = 0; j < num_inputs; j++, index++) {
|
||
|
|
snprintf(s, sizeof(s),
|
||
|
|
"Mix %c Input %02d Playback Volume",
|
||
|
|
'A' + i, j + 1);
|
||
|
|
err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
|
||
|
|
index, 1, s, NULL);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Mux Source Selection Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_info *uinfo)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
unsigned int item = uinfo->value.enumerated.item;
|
||
|
|
int items = private->num_mux_srcs;
|
||
|
|
int port_type;
|
||
|
|
|
||
|
|
uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
|
||
|
|
uinfo->count = elem->channels;
|
||
|
|
uinfo->value.enumerated.items = items;
|
||
|
|
|
||
|
|
if (item >= items)
|
||
|
|
item = uinfo->value.enumerated.item = items - 1;
|
||
|
|
|
||
|
|
for (port_type = 0;
|
||
|
|
port_type < SCARLETT2_PORT_TYPE_COUNT;
|
||
|
|
port_type++) {
|
||
|
|
if (item < port_count[port_type][SCARLETT2_PORT_IN]) {
|
||
|
|
const struct scarlett2_port *port =
|
||
|
|
&scarlett2_ports[port_type];
|
||
|
|
|
||
|
|
sprintf(uinfo->value.enumerated.name,
|
||
|
|
port->src_descr, item + port->src_num_offset);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
item -= port_count[port_type][SCARLETT2_PORT_IN];
|
||
|
|
}
|
||
|
|
|
||
|
|
return -EINVAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int line_out_count =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int index = elem->control;
|
||
|
|
|
||
|
|
if (index < line_out_count)
|
||
|
|
index = line_out_remap(private, index);
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
if (private->mux_updated)
|
||
|
|
scarlett2_usb_get_mux(mixer);
|
||
|
|
ucontrol->value.enumerated.item[0] = private->mux[index];
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int line_out_count =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int index = elem->control;
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
if (index < line_out_count)
|
||
|
|
index = line_out_remap(private, index);
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->mux[index];
|
||
|
|
val = min(ucontrol->value.enumerated.item[0],
|
||
|
|
private->num_mux_srcs - 1U);
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->mux[index] = val;
|
||
|
|
err = scarlett2_usb_set_mux(mixer);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_mux_src_enum_ctl_info,
|
||
|
|
.get = scarlett2_mux_src_enum_ctl_get,
|
||
|
|
.put = scarlett2_mux_src_enum_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int port_type, channel, i;
|
||
|
|
|
||
|
|
for (i = 0, port_type = 0;
|
||
|
|
port_type < SCARLETT2_PORT_TYPE_COUNT;
|
||
|
|
port_type++) {
|
||
|
|
for (channel = 0;
|
||
|
|
channel < port_count[port_type][SCARLETT2_PORT_OUT];
|
||
|
|
channel++, i++) {
|
||
|
|
int err;
|
||
|
|
char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
|
||
|
|
const char *const descr =
|
||
|
|
scarlett2_ports[port_type].dst_descr;
|
||
|
|
|
||
|
|
snprintf(s, sizeof(s) - 5, descr, channel + 1);
|
||
|
|
strcat(s, " Enum");
|
||
|
|
|
||
|
|
err = scarlett2_add_new_ctl(mixer,
|
||
|
|
&scarlett2_mux_src_enum_ctl,
|
||
|
|
i, 1, s,
|
||
|
|
&private->mux_ctls[i]);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Meter Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_meter_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 = 4095;
|
||
|
|
uinfo->value.integer.step = 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
u16 meter_levels[SCARLETT2_MAX_METERS];
|
||
|
|
int i, err;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels,
|
||
|
|
meter_levels);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
for (i = 0; i < elem->channels; i++)
|
||
|
|
ucontrol->value.integer.value[i] = meter_levels[i];
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_meter_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_PCM,
|
||
|
|
.access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
|
||
|
|
.name = "",
|
||
|
|
.info = scarlett2_meter_ctl_info,
|
||
|
|
.get = scarlett2_meter_ctl_get
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
/* devices without a mixer also don't support reporting levels */
|
||
|
|
if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
|
||
|
|
0, private->num_mux_dsts,
|
||
|
|
"Level Meter", NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** MSD Controls ***/
|
||
|
|
|
||
|
|
static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->msd_switch;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->msd_switch;
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->msd_switch = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
|
||
|
|
0, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_msd_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_msd_ctl_get,
|
||
|
|
.put = scarlett2_msd_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
if (!info->has_msd_mode)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* If MSD mode is off, hide the switch by default */
|
||
|
|
if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* Add MSD control */
|
||
|
|
return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
|
||
|
|
0, 1, "MSD Mode Switch", NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Standalone Control ***/
|
||
|
|
|
||
|
|
static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct scarlett2_data *private = elem->head.mixer->private_data;
|
||
|
|
|
||
|
|
ucontrol->value.integer.value[0] = private->standalone_switch;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,
|
||
|
|
struct snd_ctl_elem_value *ucontrol)
|
||
|
|
{
|
||
|
|
struct usb_mixer_elem_info *elem = kctl->private_data;
|
||
|
|
struct usb_mixer_interface *mixer = elem->head.mixer;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
int oval, val, err = 0;
|
||
|
|
|
||
|
|
mutex_lock(&private->data_mutex);
|
||
|
|
|
||
|
|
oval = private->standalone_switch;
|
||
|
|
val = !!ucontrol->value.integer.value[0];
|
||
|
|
|
||
|
|
if (oval == val)
|
||
|
|
goto unlock;
|
||
|
|
|
||
|
|
private->standalone_switch = val;
|
||
|
|
|
||
|
|
/* Send switch change to the device */
|
||
|
|
err = scarlett2_usb_set_config(mixer,
|
||
|
|
SCARLETT2_CONFIG_STANDALONE_SWITCH,
|
||
|
|
0, val);
|
||
|
|
if (err == 0)
|
||
|
|
err = 1;
|
||
|
|
|
||
|
|
unlock:
|
||
|
|
mutex_unlock(&private->data_mutex);
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
static const struct snd_kcontrol_new scarlett2_standalone_ctl = {
|
||
|
|
.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
|
||
|
|
.name = "",
|
||
|
|
.info = snd_ctl_boolean_mono_info,
|
||
|
|
.get = scarlett2_standalone_ctl_get,
|
||
|
|
.put = scarlett2_standalone_ctl_put,
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* Add standalone control */
|
||
|
|
return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
|
||
|
|
0, 1, "Standalone Switch", NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Cleanup/Suspend Callbacks ***/
|
||
|
|
|
||
|
|
static void scarlett2_private_free(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
cancel_delayed_work_sync(&private->work);
|
||
|
|
kfree(private);
|
||
|
|
mixer->private_data = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
if (cancel_delayed_work_sync(&private->work))
|
||
|
|
scarlett2_config_save(private->mixer);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*** Initialisation ***/
|
||
|
|
|
||
|
|
static void scarlett2_count_mux_io(struct scarlett2_data *private)
|
||
|
|
{
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int port_type, srcs = 0, dsts = 0;
|
||
|
|
|
||
|
|
for (port_type = 0;
|
||
|
|
port_type < SCARLETT2_PORT_TYPE_COUNT;
|
||
|
|
port_type++) {
|
||
|
|
srcs += port_count[port_type][SCARLETT2_PORT_IN];
|
||
|
|
dsts += port_count[port_type][SCARLETT2_PORT_OUT];
|
||
|
|
}
|
||
|
|
|
||
|
|
private->num_mux_srcs = srcs;
|
||
|
|
private->num_mux_dsts = dsts;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Look through the interface descriptors for the Focusrite Control
|
||
|
|
* interface (bInterfaceClass = 255 Vendor Specific Class) and set
|
||
|
|
* bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval
|
||
|
|
* in private
|
||
|
|
*/
|
||
|
|
static int scarlett2_find_fc_interface(struct usb_device *dev,
|
||
|
|
struct scarlett2_data *private)
|
||
|
|
{
|
||
|
|
struct usb_host_config *config = dev->actconfig;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
for (i = 0; i < config->desc.bNumInterfaces; i++) {
|
||
|
|
struct usb_interface *intf = config->interface[i];
|
||
|
|
struct usb_interface_descriptor *desc =
|
||
|
|
&intf->altsetting[0].desc;
|
||
|
|
struct usb_endpoint_descriptor *epd;
|
||
|
|
|
||
|
|
if (desc->bInterfaceClass != 255)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
epd = get_endpoint(intf->altsetting, 0);
|
||
|
|
private->bInterfaceNumber = desc->bInterfaceNumber;
|
||
|
|
private->bEndpointAddress = epd->bEndpointAddress &
|
||
|
|
USB_ENDPOINT_NUMBER_MASK;
|
||
|
|
private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
|
||
|
|
private->bInterval = epd->bInterval;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
return -EINVAL;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Initialise private data */
|
||
|
|
static int scarlett2_init_private(struct usb_mixer_interface *mixer,
|
||
|
|
const struct scarlett2_device_info *info)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private =
|
||
|
|
kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);
|
||
|
|
|
||
|
|
if (!private)
|
||
|
|
return -ENOMEM;
|
||
|
|
|
||
|
|
mutex_init(&private->usb_mutex);
|
||
|
|
mutex_init(&private->data_mutex);
|
||
|
|
INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
|
||
|
|
|
||
|
|
mixer->private_data = private;
|
||
|
|
mixer->private_free = scarlett2_private_free;
|
||
|
|
mixer->private_suspend = scarlett2_private_suspend;
|
||
|
|
|
||
|
|
private->info = info;
|
||
|
|
scarlett2_count_mux_io(private);
|
||
|
|
private->scarlett2_seq = 0;
|
||
|
|
private->mixer = mixer;
|
||
|
|
|
||
|
|
return scarlett2_find_fc_interface(mixer->chip->dev, private);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Cargo cult proprietary initialisation sequence */
|
||
|
|
static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct usb_device *dev = mixer->chip->dev;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
u8 buf[24];
|
||
|
|
int err;
|
||
|
|
|
||
|
|
if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
/* step 0 */
|
||
|
|
err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
|
||
|
|
SCARLETT2_USB_CMD_INIT, buf, sizeof(buf));
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* step 1 */
|
||
|
|
private->scarlett2_seq = 1;
|
||
|
|
err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* step 2 */
|
||
|
|
private->scarlett2_seq = 1;
|
||
|
|
return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Read configuration from the interface on start */
|
||
|
|
static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int num_mixer_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN];
|
||
|
|
struct scarlett2_usb_volume_status volume_status;
|
||
|
|
int err, i;
|
||
|
|
|
||
|
|
if (info->has_msd_mode) {
|
||
|
|
err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_MSD_SWITCH,
|
||
|
|
1, &private->msd_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* no other controls are created if MSD mode is on */
|
||
|
|
if (private->msd_switch)
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
err = scarlett2_update_input_other(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
err = scarlett2_update_monitor_other(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* the rest of the configuration is for devices with a mixer */
|
||
|
|
if (info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_config(
|
||
|
|
mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
|
||
|
|
1, &private->standalone_switch);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
err = scarlett2_update_sync(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
err = scarlett2_usb_get_volume_status(mixer, &volume_status);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
if (info->line_out_hw_vol)
|
||
|
|
for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
|
||
|
|
private->dim_mute[i] = !!volume_status.dim_mute[i];
|
||
|
|
|
||
|
|
private->master_vol = clamp(
|
||
|
|
volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
|
||
|
|
0, SCARLETT2_VOLUME_BIAS);
|
||
|
|
|
||
|
|
for (i = 0; i < num_line_out; i++) {
|
||
|
|
int volume, mute;
|
||
|
|
|
||
|
|
private->vol_sw_hw_switch[i] =
|
||
|
|
info->line_out_hw_vol
|
||
|
|
&& volume_status.sw_hw_switch[i];
|
||
|
|
|
||
|
|
volume = private->vol_sw_hw_switch[i]
|
||
|
|
? volume_status.master_vol
|
||
|
|
: volume_status.sw_vol[i];
|
||
|
|
volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
|
||
|
|
0, SCARLETT2_VOLUME_BIAS);
|
||
|
|
private->vol[i] = volume;
|
||
|
|
|
||
|
|
mute = private->vol_sw_hw_switch[i]
|
||
|
|
? private->dim_mute[SCARLETT2_BUTTON_MUTE]
|
||
|
|
: volume_status.mute_switch[i];
|
||
|
|
private->mute_switch[i] = mute;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i = 0; i < num_mixer_out; i++) {
|
||
|
|
err = scarlett2_usb_get_mix(mixer, i);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
}
|
||
|
|
|
||
|
|
return scarlett2_usb_get_mux(mixer);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify on sync change */
|
||
|
|
static void scarlett2_notify_sync(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
|
||
|
|
private->sync_updated = 1;
|
||
|
|
|
||
|
|
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->sync_ctl->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify on monitor change */
|
||
|
|
static void scarlett2_notify_monitor(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int i;
|
||
|
|
|
||
|
|
/* if line_out_hw_vol is 0, there are no controls to update */
|
||
|
|
if (!info->line_out_hw_vol)
|
||
|
|
return;
|
||
|
|
|
||
|
|
private->vol_updated = 1;
|
||
|
|
|
||
|
|
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->master_vol_ctl->id);
|
||
|
|
|
||
|
|
for (i = 0; i < num_line_out; i++)
|
||
|
|
if (private->vol_sw_hw_switch[line_out_remap(private, i)])
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->vol_ctls[i]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify on dim/mute change */
|
||
|
|
static void scarlett2_notify_dim_mute(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
|
||
|
|
int num_line_out =
|
||
|
|
port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];
|
||
|
|
int i;
|
||
|
|
|
||
|
|
private->vol_updated = 1;
|
||
|
|
|
||
|
|
if (!info->line_out_hw_vol)
|
||
|
|
return;
|
||
|
|
|
||
|
|
for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->dim_mute_ctls[i]->id);
|
||
|
|
|
||
|
|
for (i = 0; i < num_line_out; i++)
|
||
|
|
if (private->vol_sw_hw_switch[line_out_remap(private, i)])
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->mute_ctls[i]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify on "input other" change (level/pad/air) */
|
||
|
|
static void scarlett2_notify_input_other(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
private->input_other_updated = 1;
|
||
|
|
|
||
|
|
for (i = 0; i < info->level_input_count; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->level_ctls[i]->id);
|
||
|
|
for (i = 0; i < info->pad_input_count; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->pad_ctls[i]->id);
|
||
|
|
for (i = 0; i < info->air_input_count; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->air_ctls[i]->id);
|
||
|
|
for (i = 0; i < info->phantom_count; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->phantom_ctls[i]->id);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Notify on "monitor other" change (direct monitor, speaker
|
||
|
|
* switching, talkback)
|
||
|
|
*/
|
||
|
|
static void scarlett2_notify_monitor_other(
|
||
|
|
struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_card *card = mixer->chip->card;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
const struct scarlett2_device_info *info = private->info;
|
||
|
|
|
||
|
|
private->monitor_other_updated = 1;
|
||
|
|
|
||
|
|
if (info->direct_monitor) {
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->direct_monitor_ctl->id);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (info->has_speaker_switching)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->speaker_switching_ctl->id);
|
||
|
|
|
||
|
|
if (info->has_talkback)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->talkback_ctl->id);
|
||
|
|
|
||
|
|
/* if speaker switching was recently enabled or disabled,
|
||
|
|
* invalidate the dim/mute and mux enum controls
|
||
|
|
*/
|
||
|
|
if (private->speaker_switching_switched) {
|
||
|
|
int i;
|
||
|
|
|
||
|
|
scarlett2_notify_dim_mute(mixer);
|
||
|
|
|
||
|
|
private->speaker_switching_switched = 0;
|
||
|
|
private->mux_updated = 1;
|
||
|
|
|
||
|
|
for (i = 0; i < private->num_mux_dsts; i++)
|
||
|
|
snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,
|
||
|
|
&private->mux_ctls[i]->id);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Interrupt callback */
|
||
|
|
static void scarlett2_notify(struct urb *urb)
|
||
|
|
{
|
||
|
|
struct usb_mixer_interface *mixer = urb->context;
|
||
|
|
int len = urb->actual_length;
|
||
|
|
int ustatus = urb->status;
|
||
|
|
u32 data;
|
||
|
|
|
||
|
|
if (ustatus != 0 || len != 8)
|
||
|
|
goto requeue;
|
||
|
|
|
||
|
|
data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
|
||
|
|
if (data & SCARLETT2_USB_NOTIFY_SYNC)
|
||
|
|
scarlett2_notify_sync(mixer);
|
||
|
|
if (data & SCARLETT2_USB_NOTIFY_MONITOR)
|
||
|
|
scarlett2_notify_monitor(mixer);
|
||
|
|
if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE)
|
||
|
|
scarlett2_notify_dim_mute(mixer);
|
||
|
|
if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER)
|
||
|
|
scarlett2_notify_input_other(mixer);
|
||
|
|
if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER)
|
||
|
|
scarlett2_notify_monitor_other(mixer);
|
||
|
|
|
||
|
|
requeue:
|
||
|
|
if (ustatus != -ENOENT &&
|
||
|
|
ustatus != -ECONNRESET &&
|
||
|
|
ustatus != -ESHUTDOWN) {
|
||
|
|
urb->dev = mixer->chip->dev;
|
||
|
|
usb_submit_urb(urb, GFP_ATOMIC);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct usb_device *dev = mixer->chip->dev;
|
||
|
|
struct scarlett2_data *private = mixer->private_data;
|
||
|
|
unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
|
||
|
|
void *transfer_buffer;
|
||
|
|
|
||
|
|
if (mixer->urb) {
|
||
|
|
usb_audio_err(mixer->chip,
|
||
|
|
"%s: mixer urb already in use!\n", __func__);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (usb_pipe_type_check(dev, pipe))
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
|
||
|
|
if (!mixer->urb)
|
||
|
|
return -ENOMEM;
|
||
|
|
|
||
|
|
transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
|
||
|
|
if (!transfer_buffer)
|
||
|
|
return -ENOMEM;
|
||
|
|
|
||
|
|
usb_fill_int_urb(mixer->urb, dev, pipe,
|
||
|
|
transfer_buffer, private->wMaxPacketSize,
|
||
|
|
scarlett2_notify, mixer, private->bInterval);
|
||
|
|
|
||
|
|
return usb_submit_urb(mixer->urb, GFP_KERNEL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
const struct scarlett2_device_info **info = scarlett2_devices;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
/* Find device in scarlett2_devices */
|
||
|
|
while (*info && (*info)->usb_id != mixer->chip->usb_id)
|
||
|
|
info++;
|
||
|
|
if (!*info)
|
||
|
|
return -EINVAL;
|
||
|
|
|
||
|
|
/* Initialise private data */
|
||
|
|
err = scarlett2_init_private(mixer, *info);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Send proprietary USB initialisation sequence */
|
||
|
|
err = scarlett2_usb_init(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Read volume levels and controls from the interface */
|
||
|
|
err = scarlett2_read_configs(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the MSD control */
|
||
|
|
err = scarlett2_add_msd_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* If MSD mode is enabled, don't create any other controls */
|
||
|
|
if (((struct scarlett2_data *)mixer->private_data)->msd_switch)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* Create the analogue output controls */
|
||
|
|
err = scarlett2_add_line_out_ctls(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the analogue input controls */
|
||
|
|
err = scarlett2_add_line_in_ctls(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the input, output, and mixer mux input selections */
|
||
|
|
err = scarlett2_add_mux_enums(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the matrix mixer controls */
|
||
|
|
err = scarlett2_add_mixer_ctls(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the level meter controls */
|
||
|
|
err = scarlett2_add_meter_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the sync control */
|
||
|
|
err = scarlett2_add_sync_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the direct monitor control */
|
||
|
|
err = scarlett2_add_direct_monitor_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the speaker switching control */
|
||
|
|
err = scarlett2_add_speaker_switch_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the talkback controls */
|
||
|
|
err = scarlett2_add_talkback_ctls(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Create the standalone control */
|
||
|
|
err = scarlett2_add_standalone_ctl(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
/* Set up the interrupt polling */
|
||
|
|
err = scarlett2_init_notify(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
return err;
|
||
|
|
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
|
||
|
|
{
|
||
|
|
struct snd_usb_audio *chip = mixer->chip;
|
||
|
|
int err;
|
||
|
|
|
||
|
|
/* only use UAC_VERSION_2 */
|
||
|
|
if (!mixer->protocol)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
if (!(chip->setup & SCARLETT2_ENABLE)) {
|
||
|
|
usb_audio_info(chip,
|
||
|
|
"Focusrite Scarlett Gen 2/3 Mixer Driver disabled; "
|
||
|
|
"use options snd_usb_audio vid=0x%04x pid=0x%04x "
|
||
|
|
"device_setup=1 to enable and report any issues "
|
||
|
|
"to g@b4.vu",
|
||
|
|
USB_ID_VENDOR(chip->usb_id),
|
||
|
|
USB_ID_PRODUCT(chip->usb_id));
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
usb_audio_info(chip,
|
||
|
|
"Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x",
|
||
|
|
USB_ID_PRODUCT(chip->usb_id));
|
||
|
|
|
||
|
|
err = snd_scarlett_gen2_controls_create(mixer);
|
||
|
|
if (err < 0)
|
||
|
|
usb_audio_err(mixer->chip,
|
||
|
|
"Error initialising Scarlett Mixer Driver: %d",
|
||
|
|
err);
|
||
|
|
|
||
|
|
return err;
|
||
|
|
}
|