9652 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Focusrite Scarlett 2 Protocol Driver for ALSA4 * (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and5 * Clarett+ series products)6 *7 * Supported models:8 * - 6i6/18i8/18i20 Gen 29 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 310 * - Solo/2i2/4i4 Gen 411 * - Clarett 2Pre/4Pre/8Pre USB12 * - Clarett+ 2Pre/4Pre/8Pre13 *14 * Copyright (c) 2018-2023 by Geoffrey D. Bennett <g at b4.vu>15 * Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>16 * Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com>17 *18 * Based on the Scarlett (Gen 1) Driver for ALSA:19 *20 * Copyright (c) 2013 by Tobias Hoffmann21 * Copyright (c) 2013 by Robin Gareus <robin at gareus.org>22 * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>23 * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>24 *25 * Many codes borrowed from audio.c by26 * Alan Cox (alan at lxorguk.ukuu.org.uk)27 * Thomas Sailer (sailer at ife.ee.ethz.ch)28 *29 * Code cleanup:30 * David Henningsson <david.henningsson at canonical.com>31 */32 33/* The protocol was reverse engineered by looking at the communication34 * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i2035 * (firmware 1083) using usbmon in July-August 2018.36 *37 * Scarlett 18i8 support added in April 2019.38 *39 * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann40 * for providing usbmon output and testing).41 *42 * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent43 * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i644 * usbmon output and testing).45 *46 * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to47 * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon48 * output, protocol traces and testing).49 *50 * Support for loading mixer volume and mux configuration from the51 * interface during driver initialisation added in May 2021 (thanks to52 * Vladimir Sadovnikov for figuring out how).53 *54 * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander55 * Vorona for 2i2 protocol traces).56 *57 * Support for phantom power, direct monitoring, speaker switching,58 * and talkback added in May-June 2021.59 *60 * Support for Clarett+ 8Pre added in Aug 2022 by Christian61 * Colglazier.62 *63 * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe64 * Perrot for confirmation).65 *66 * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to67 * Gregory Rozzo for donating a 4Pre, and David Sherwood and Patrice68 * Peterson for usbmon output).69 *70 * Support for Clarett 2Pre and 4Pre USB added in Oct 2023.71 *72 * Support for firmware updates added in Dec 2023.73 *74 * Support for Scarlett Solo/2i2/4i4 Gen 4 added in Dec 2023 (thanks75 * to many LinuxMusicians people and to Focusrite for hardware76 * donations).77 *78 * This ALSA mixer gives access to (model-dependent):79 * - input, output, mixer-matrix muxes80 * - mixer-matrix gain stages81 * - gain/volume/mute controls82 * - level meters83 * - line/inst level, pad, and air controls84 * - phantom power, direct monitor, speaker switching, and talkback85 * controls86 * - disable/enable MSD mode87 * - disable/enable standalone mode88 * - input mute, gain, autogain, safe mode89 * - direct monitor mixes90 * - compressor and EQ91 * - Bluetooth volume92 *93 * <ditaa>94 * /--------------\ 18chn 20chn /--------------\95 * | Hardware in +--+------\ /-------------+--+ ALSA PCM out |96 * \--------------/ | | | | \--------------/97 * | | | /-----\ |98 * | | | | | |99 * | v v v | |100 * | +---------------+ | |101 * | \ Matrix Mux / | |102 * | +-----+-----+ | |103 * | | | |104 * | |18chn | |105 * | | | |106 * | | 10chn| |107 * | v | |108 * | +------------+ | |109 * | | Mixer | | |110 * | | Matrix | | |111 * | | | | |112 * | | 18x10 Gain | | |113 * | | stages | | |114 * | +-----+------+ | |115 * | | | |116 * |18chn |10chn | |20chn117 * | | | |118 * | +----------/ |119 * | | |120 * v v v121 * ===========================122 * +---------------+ +--—------------+123 * \ Output Mux / \ Capture Mux /124 * +---+---+---+ +-----+-----+125 * | | |126 * 10chn| | |18chn127 * | | |128 * /--------------\ | | | /--------------\129 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in |130 * | Hardware out | | \--------------/131 * \--------------/ |132 * v133 * +-------------+ Software gain per channel.134 * | Master Gain |<-- 18i20 only: Switch per channel135 * +------+------+ to select HW or SW gain control.136 * |137 * |10chn138 * /--------------\ |139 * | Analogue |<------/140 * | Hardware out |141 * \--------------/142 * </ditaa>143 *144 * Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small145 * disk with registration and driver download information is presented146 * to the host. To access the full functionality of the device without147 * proprietary software, MSD mode can be disabled by:148 * - holding down the 48V button for five seconds while powering on149 * the device, or150 * - using this driver and alsamixer to change the "MSD Mode" setting151 * to Off and power-cycling the device152 */153 154#include <linux/slab.h>155#include <linux/usb.h>156#include <linux/moduleparam.h>157 158#include <sound/control.h>159#include <sound/tlv.h>160#include <sound/hwdep.h>161 162#include <uapi/sound/scarlett2.h>163 164#include "usbaudio.h"165#include "mixer.h"166#include "helper.h"167 168#include "mixer_scarlett2.h"169 170/* device_setup value to allow turning MSD mode back on */171#define SCARLETT2_MSD_ENABLE 0x02172 173/* device_setup value to disable this mixer driver */174#define SCARLETT2_DISABLE 0x04175 176/* some gui mixers can't handle negative ctl values */177#define SCARLETT2_VOLUME_BIAS 127178 179/* maximum preamp input gain value180 * (the corresponding value in dB is per-device)181 */182#define SCARLETT2_MAX_GAIN_VALUE 70183 184/* maximum Bluetooth volume value */185#define SCARLETT2_MAX_BLUETOOTH_VOLUME 30186 187/* mixer range from -80dB to +12dB in 0.5dB steps */188#define SCARLETT2_MIXER_MIN_DB -80189#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)190#define SCARLETT2_MIXER_MAX_DB 12191#define SCARLETT2_MIXER_MAX_VALUE \192 ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)193#define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1)194 195/* map from (dB + 80) * 2 to mixer value196 * for dB in 0 .. 184: int(8192 * pow(10, ((dB - 160) / 2 / 20)))197 */198static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = {199 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,200 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,201 9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,202 23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,203 54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,204 122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,205 244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,206 487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,207 973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,208 1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,209 3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,210 5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,211 9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,212 16345, 17313, 18339, 19426, 20577, 21796, 23088, 24456, 25905,213 27440, 29066, 30788, 32612214};215 216/* Maximum number of analogue outputs */217#define SCARLETT2_ANALOGUE_MAX 10218 219/* Maximum number of various input controls */220#define SCARLETT2_LEVEL_SWITCH_MAX 2221#define SCARLETT2_PAD_SWITCH_MAX 8222#define SCARLETT2_AIR_SWITCH_MAX 8223#define SCARLETT2_DSP_SWITCH_MAX 2224#define SCARLETT2_INPUT_MUTE_SWITCH_MAX 2225#define SCARLETT2_PHANTOM_SWITCH_MAX 2226#define SCARLETT2_INPUT_GAIN_MAX 2227 228/* Maximum number of inputs to the mixer */229#define SCARLETT2_INPUT_MIX_MAX 25230 231/* Maximum number of outputs from the mixer */232#define SCARLETT2_OUTPUT_MIX_MAX 12233 234/* Maximum number of mixer gain controls */235#define SCARLETT2_MIX_MAX (SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX)236 237/* Maximum number of direct monitor mixer gain controls238 * 1 (Solo) or 2 (2i2) direct monitor selections (Mono & Stereo)239 * 2 Mix outputs (A/Left & B/Right)240 * 4 Mix inputs241 */242#define SCARLETT2_MONITOR_MIX_MAX (2 * 2 * 4)243 244/* Maximum size of the data in the USB mux assignment message:245 * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare246 */247#define SCARLETT2_MUX_MAX 77248 249/* Maximum number of sources (sum of input port counts) */250#define SCARLETT2_MAX_SRCS 52251 252/* Maximum number of meters (sum of output port counts) */253#define SCARLETT2_MAX_METERS 65254 255/* Compressor parameter data256 *257 * The compressor parameters are 32-bit fixed point values with 24258 * bits of fraction. Integer values are sufficient for the parameters259 * except for ratio which we can set in 0.5:1 steps.260 */261struct compressor_param {262 const char *name;263 snd_ctl_elem_type_t type;264 s32 min;265 s32 max;266 int scale_bits;267};268 269/* The available compressor parameters on the Vocaster:270 * - Enable: Off, On271 * - Threshold: -40dB to 0dB272 * - Ratio: 1:1 to 50:1 in 0.5:1 steps273 * - Knee Width: 0dB to 10dB274 * - Attack: 30ms to 127ms275 * - Release: 30ms to 127ms276 * - Makeup Gain: 0dB to 24dB277 */278static const struct compressor_param compressor_params[] = {279 { "Enable", SNDRV_CTL_ELEM_TYPE_BOOLEAN, 0, 1, 0 },280 { "Threshold", SNDRV_CTL_ELEM_TYPE_INTEGER, -40, 0, 24 },281 { "Ratio", SNDRV_CTL_ELEM_TYPE_INTEGER, 2, 100, 23 },282 { "Knee Width", SNDRV_CTL_ELEM_TYPE_INTEGER, 0, 10, 24 },283 { "Attack", SNDRV_CTL_ELEM_TYPE_INTEGER, 30, 127, 24 },284 { "Release", SNDRV_CTL_ELEM_TYPE_INTEGER, 30, 127, 24 },285 { "Makeup Gain", SNDRV_CTL_ELEM_TYPE_INTEGER, 0, 24, 24 },286};287 288#define SCARLETT2_COMPRESSOR_PARAM_COUNT ARRAY_SIZE(compressor_params)289#define SCARLETT2_COMPRESSOR_CTLS_MAX \290 (SCARLETT2_COMPRESSOR_PARAM_COUNT * SCARLETT2_DSP_SWITCH_MAX)291 292/* Maximum number of filter controls */293#define SCARLETT2_PRECOMP_FLT_CTLS_MAX (2 * SCARLETT2_DSP_SWITCH_MAX)294#define SCARLETT2_PEQ_FLT_CTLS_MAX (3 * SCARLETT2_DSP_SWITCH_MAX)295 296/* Number of biquad filter coefficients */297#define SCARLETT2_BIQUAD_COEFFS 5298 299/* Maximum number of filter coefficient values */300#define SCARLETT2_PRECOMP_FLT_VALUES_MAX \301 (SCARLETT2_PRECOMP_FLT_CTLS_MAX * SCARLETT2_BIQUAD_COEFFS)302#define SCARLETT2_PEQ_FLT_VALUES_MAX \303 (SCARLETT2_PEQ_FLT_CTLS_MAX * SCARLETT2_BIQUAD_COEFFS)304 305/* Maximum number of PEQ filter slots */306#define SCARLETT2_PEQ_FLT_SLOTS_MAX 4307 308/* Hardware port types:309 * - None (no input to mux)310 * - Analogue I/O311 * - S/PDIF I/O312 * - ADAT I/O313 * - Mixer I/O314 * - PCM I/O315 */316enum {317 SCARLETT2_PORT_TYPE_NONE,318 SCARLETT2_PORT_TYPE_ANALOGUE,319 SCARLETT2_PORT_TYPE_SPDIF,320 SCARLETT2_PORT_TYPE_ADAT,321 SCARLETT2_PORT_TYPE_MIX,322 SCARLETT2_PORT_TYPE_PCM,323 SCARLETT2_PORT_TYPE_COUNT324};325 326/* I/O count of each port type kept in struct scarlett2_ports */327enum {328 SCARLETT2_PORT_IN,329 SCARLETT2_PORT_OUT,330 SCARLETT2_PORT_DIRNS331};332 333/* Dim/Mute buttons on the 18i20 */334enum {335 SCARLETT2_BUTTON_MUTE,336 SCARLETT2_BUTTON_DIM,337 SCARLETT2_DIM_MUTE_COUNT338};339 340/* Autogain target values */341 342#define SCARLETT2_AG_TARGET_MIN (-30)343 344enum {345 SCARLETT2_AG_HOT_TARGET,346 SCARLETT2_AG_MEAN_TARGET,347 SCARLETT2_AG_PEAK_TARGET,348 SCARLETT2_AG_TARGET_COUNT349};350 351/* Flash Write State */352enum {353 SCARLETT2_FLASH_WRITE_STATE_IDLE,354 SCARLETT2_FLASH_WRITE_STATE_SELECTED,355 SCARLETT2_FLASH_WRITE_STATE_ERASING,356 SCARLETT2_FLASH_WRITE_STATE_WRITE357};358 359static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = {360 "Mute Playback Switch", "Dim Playback Switch"361};362 363/* The autogain_status is set based on the autogain_switch and364 * raw_autogain_status values.365 *366 * If autogain_switch is set, autogain_status is set to 0 (Running).367 * The other status values are from the raw_autogain_status value + 1.368 */369static const char *const scarlett2_autogain_status_gen4[] = {370 "Running",371 "Success",372 "SuccessDRover",373 "WarnMinGainLimit",374 "FailDRunder",375 "FailMaxGainLimit",376 "FailClipped",377 "Cancelled",378 "Invalid",379 NULL380};381 382static const char *const scarlett2_autogain_status_vocaster[] = {383 "Running",384 "Success",385 "FailPG",386 "FailRange",387 "WarnMaxCap",388 "WarnMinCap",389 "Cancelled",390 "Invalid",391 NULL392};393 394/* Power Status Values */395enum {396 SCARLETT2_POWER_STATUS_EXT,397 SCARLETT2_POWER_STATUS_BUS,398 SCARLETT2_POWER_STATUS_FAIL,399 SCARLETT2_POWER_STATUS_COUNT400};401 402/* Notification callback functions */403struct scarlett2_notification {404 u32 mask;405 void (*func)(struct usb_mixer_interface *mixer);406};407 408static void scarlett2_notify_ack(struct usb_mixer_interface *mixer);409static void scarlett2_notify_sync(struct usb_mixer_interface *mixer);410static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer);411static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer);412static void scarlett2_notify_volume(struct usb_mixer_interface *mixer);413static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer);414static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer);415static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer);416static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer);417static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer);418static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer);419static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer);420static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer);421static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer);422static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer);423static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer);424static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer);425static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer);426static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer);427static void scarlett2_notify_pcm_input_switch(428 struct usb_mixer_interface *mixer);429static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer);430 431/* Arrays of notification callback functions */432 433static const struct scarlett2_notification scarlett2_notifications[] = {434 { 0x00000001, scarlett2_notify_ack },435 { 0x00000008, scarlett2_notify_sync },436 { 0x00200000, scarlett2_notify_dim_mute },437 { 0x00400000, scarlett2_notify_monitor },438 { 0x00800000, scarlett2_notify_input_other },439 { 0x01000000, scarlett2_notify_monitor_other },440 { 0, NULL }441};442 443static const struct scarlett2_notification scarlett3a_notifications[] = {444 { 0x00000001, scarlett2_notify_ack },445 { 0x00800000, scarlett2_notify_input_other },446 { 0x01000000, scarlett2_notify_direct_monitor },447 { 0, NULL }448};449 450static const struct scarlett2_notification vocaster_notifications[] = {451 { 0x00000001, scarlett2_notify_ack },452 { 0x00000008, scarlett2_notify_sync },453 { 0x00200000, scarlett2_notify_input_mute },454 { 0x00400000, scarlett2_notify_autogain },455 { 0x04000000, scarlett2_notify_input_dsp },456 { 0x08000000, scarlett2_notify_input_gain },457 { 0x10000000, scarlett2_notify_input_phantom },458 { 0x20000000, scarlett2_notify_bluetooth },459 { 0, NULL }460};461 462static const struct scarlett2_notification scarlett4_solo_notifications[] = {463 { 0x00000001, scarlett2_notify_ack },464 { 0x00000008, scarlett2_notify_sync },465 { 0x00400000, scarlett2_notify_input_air },466 { 0x00800000, scarlett2_notify_direct_monitor },467 { 0x01000000, scarlett2_notify_input_level },468 { 0x02000000, scarlett2_notify_input_phantom },469 { 0x04000000, scarlett2_notify_pcm_input_switch },470 { 0, NULL }471};472 473static const struct scarlett2_notification scarlett4_2i2_notifications[] = {474 { 0x00000001, scarlett2_notify_ack },475 { 0x00000008, scarlett2_notify_sync },476 { 0x00200000, scarlett2_notify_input_safe },477 { 0x00400000, scarlett2_notify_autogain },478 { 0x00800000, scarlett2_notify_input_air },479 { 0x01000000, scarlett2_notify_direct_monitor },480 { 0x02000000, scarlett2_notify_input_select },481 { 0x04000000, scarlett2_notify_input_level },482 { 0x08000000, scarlett2_notify_input_phantom },483 { 0x10000000, NULL }, /* power status, ignored */484 { 0x40000000, scarlett2_notify_input_gain },485 { 0x80000000, NULL }, /* power status, ignored */486 { 0, NULL }487};488 489static const struct scarlett2_notification scarlett4_4i4_notifications[] = {490 { 0x00000001, scarlett2_notify_ack },491 { 0x00000008, scarlett2_notify_sync },492 { 0x00200000, scarlett2_notify_input_safe },493 { 0x00400000, scarlett2_notify_autogain },494 { 0x00800000, scarlett2_notify_input_air },495 { 0x01000000, scarlett2_notify_input_select },496 { 0x02000000, scarlett2_notify_input_level },497 { 0x04000000, scarlett2_notify_input_phantom },498 { 0x08000000, scarlett2_notify_power_status }, /* power external */499 { 0x20000000, scarlett2_notify_input_gain },500 { 0x40000000, scarlett2_notify_power_status }, /* power status */501 { 0x80000000, scarlett2_notify_volume },502 { 0, NULL }503};504 505/* Configuration parameters that can be read and written */506enum {507 SCARLETT2_CONFIG_DIM_MUTE,508 SCARLETT2_CONFIG_LINE_OUT_VOLUME,509 SCARLETT2_CONFIG_MUTE_SWITCH,510 SCARLETT2_CONFIG_SW_HW_SWITCH,511 SCARLETT2_CONFIG_MASTER_VOLUME,512 SCARLETT2_CONFIG_HEADPHONE_VOLUME,513 SCARLETT2_CONFIG_LEVEL_SWITCH,514 SCARLETT2_CONFIG_PAD_SWITCH,515 SCARLETT2_CONFIG_MSD_SWITCH,516 SCARLETT2_CONFIG_AIR_SWITCH,517 SCARLETT2_CONFIG_DSP_SWITCH,518 SCARLETT2_CONFIG_COMPRESSOR_PARAMS,519 SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,520 SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,521 SCARLETT2_CONFIG_PEQ_FLT_SWITCH,522 SCARLETT2_CONFIG_PEQ_FLT_PARAMS,523 SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,524 SCARLETT2_CONFIG_STANDALONE_SWITCH,525 SCARLETT2_CONFIG_PHANTOM_SWITCH,526 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,527 SCARLETT2_CONFIG_DIRECT_MONITOR,528 SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,529 SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,530 SCARLETT2_CONFIG_TALKBACK_MAP,531 SCARLETT2_CONFIG_AUTOGAIN_SWITCH,532 SCARLETT2_CONFIG_AUTOGAIN_STATUS,533 SCARLETT2_CONFIG_AG_HOT_TARGET,534 SCARLETT2_CONFIG_AG_MEAN_TARGET,535 SCARLETT2_CONFIG_AG_PEAK_TARGET,536 SCARLETT2_CONFIG_INPUT_GAIN,537 SCARLETT2_CONFIG_SAFE_SWITCH,538 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,539 SCARLETT2_CONFIG_INPUT_LINK_SWITCH,540 SCARLETT2_CONFIG_POWER_EXT,541 SCARLETT2_CONFIG_POWER_LOW,542 SCARLETT2_CONFIG_PCM_INPUT_SWITCH,543 SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,544 SCARLETT2_CONFIG_BLUETOOTH_VOLUME,545 SCARLETT2_CONFIG_SPDIF_MODE,546 SCARLETT2_CONFIG_COUNT547};548 549/* Autogain target configuration parameters and names */550 551static const int scarlett2_ag_target_configs[] = {552 [SCARLETT2_AG_HOT_TARGET] = SCARLETT2_CONFIG_AG_HOT_TARGET,553 [SCARLETT2_AG_MEAN_TARGET] = SCARLETT2_CONFIG_AG_MEAN_TARGET,554 [SCARLETT2_AG_PEAK_TARGET] = SCARLETT2_CONFIG_AG_PEAK_TARGET555};556 557static const char *const scarlett2_ag_target_names[] = {558 "Hot", "Mean", "Peak"559};560 561/* Location, size, and activation command number for the configuration562 * parameters. Size is in bits and may be 1, 8, 16, or 32.563 *564 * Vocaster and 4th Gen devices have a parameter buffer to set certain565 * configuration parameters. When pbuf is set, rather than writing to566 * the given offset, the channel and value are written to the567 * parameter buffer and the activate command is sent to the device.568 *569 * Some Gen 4 configuration parameters are written with 0x02 for a570 * desired value of 0x01, and 0x03 for 0x00. These are indicated with571 * mute set to 1. 0x02 and 0x03 are temporary values while the device572 * makes the change and the channel and/or corresponding DSP channel573 * output is muted.574 */575struct scarlett2_config {576 u16 offset;577 u8 size;578 u8 activate;579 u8 pbuf;580 u8 mute;581};582 583struct scarlett2_config_set {584 const struct scarlett2_notification *notifications;585 u16 param_buf_addr;586 const unsigned int *input_gain_tlv;587 const char *const *autogain_status_texts;588 const struct scarlett2_config items[SCARLETT2_CONFIG_COUNT];589};590 591/* Input gain TLV dB ranges */592 593static const DECLARE_TLV_DB_MINMAX(594 db_scale_vocaster_gain, 0, 70 * 100595);596 597static const DECLARE_TLV_DB_MINMAX(598 db_scale_gen4_gain, 0, 69 * 100599);600 601/* Gen 2 devices without SW/HW volume switch: 6i6, 18i8 */602 603static const struct scarlett2_config_set scarlett2_config_set_gen2a = {604 .notifications = scarlett2_notifications,605 .items = {606 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {607 .offset = 0x34, .size = 16, .activate = 1 },608 609 [SCARLETT2_CONFIG_MUTE_SWITCH] = {610 .offset = 0x5c, .size = 8, .activate = 1 },611 612 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {613 .offset = 0x7c, .size = 8, .activate = 7 },614 615 [SCARLETT2_CONFIG_PAD_SWITCH] = {616 .offset = 0x84, .size = 8, .activate = 8 },617 618 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {619 .offset = 0x8d, .size = 8, .activate = 6 },620 }621};622 623/* Gen 2 devices with SW/HW volume switch: 18i20 */624 625static const struct scarlett2_config_set scarlett2_config_set_gen2b = {626 .notifications = scarlett2_notifications,627 .items = {628 [SCARLETT2_CONFIG_DIM_MUTE] = {629 .offset = 0x31, .size = 8, .activate = 2 },630 631 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {632 .offset = 0x34, .size = 16, .activate = 1 },633 634 [SCARLETT2_CONFIG_MUTE_SWITCH] = {635 .offset = 0x5c, .size = 8, .activate = 1 },636 637 [SCARLETT2_CONFIG_SW_HW_SWITCH] = {638 .offset = 0x66, .size = 8, .activate = 3 },639 640 [SCARLETT2_CONFIG_MASTER_VOLUME] = {641 .offset = 0x76, .size = 16 },642 643 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {644 .offset = 0x7c, .size = 8, .activate = 7 },645 646 [SCARLETT2_CONFIG_PAD_SWITCH] = {647 .offset = 0x84, .size = 8, .activate = 8 },648 649 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {650 .offset = 0x8d, .size = 8, .activate = 6 },651 }652};653 654/* Gen 3 devices without a mixer (Solo and 2i2) */655static const struct scarlett2_config_set scarlett2_config_set_gen3a = {656 .notifications = scarlett3a_notifications,657 .items = {658 [SCARLETT2_CONFIG_MSD_SWITCH] = {659 .offset = 0x04, .size = 8, .activate = 6 },660 661 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {662 .offset = 0x05, .size = 8, .activate = 6 },663 664 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {665 .offset = 0x06, .size = 8, .activate = 3 },666 667 [SCARLETT2_CONFIG_DIRECT_MONITOR] = {668 .offset = 0x07, .size = 8, .activate = 4 },669 670 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {671 .offset = 0x08, .size = 1, .activate = 7 },672 673 [SCARLETT2_CONFIG_AIR_SWITCH] = {674 .offset = 0x09, .size = 1, .activate = 8 },675 }676};677 678/* Gen 3 devices without SW/HW volume switch: 4i4, 8i6 */679static const struct scarlett2_config_set scarlett2_config_set_gen3b = {680 .notifications = scarlett2_notifications,681 .items = {682 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {683 .offset = 0x34, .size = 16, .activate = 1 },684 685 [SCARLETT2_CONFIG_MUTE_SWITCH] = {686 .offset = 0x5c, .size = 8, .activate = 1 },687 688 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {689 .offset = 0x7c, .size = 8, .activate = 7 },690 691 [SCARLETT2_CONFIG_PAD_SWITCH] = {692 .offset = 0x84, .size = 8, .activate = 8 },693 694 [SCARLETT2_CONFIG_AIR_SWITCH] = {695 .offset = 0x8c, .size = 8, .activate = 8 },696 697 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {698 .offset = 0x95, .size = 8, .activate = 6 },699 700 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {701 .offset = 0x9c, .size = 1, .activate = 8 },702 703 [SCARLETT2_CONFIG_MSD_SWITCH] = {704 .offset = 0x9d, .size = 8, .activate = 6 },705 706 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {707 .offset = 0x9e, .size = 8, .activate = 6 },708 }709};710 711/* Gen 3 devices with SW/HW volume switch: 18i8, 18i20 */712static const struct scarlett2_config_set scarlett2_config_set_gen3c = {713 .notifications = scarlett2_notifications,714 .items = {715 [SCARLETT2_CONFIG_DIM_MUTE] = {716 .offset = 0x31, .size = 8, .activate = 2 },717 718 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {719 .offset = 0x34, .size = 16, .activate = 1 },720 721 [SCARLETT2_CONFIG_MUTE_SWITCH] = {722 .offset = 0x5c, .size = 8, .activate = 1 },723 724 [SCARLETT2_CONFIG_SW_HW_SWITCH] = {725 .offset = 0x66, .size = 8, .activate = 3 },726 727 [SCARLETT2_CONFIG_MASTER_VOLUME] = {728 .offset = 0x76, .size = 16 },729 730 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {731 .offset = 0x7c, .size = 8, .activate = 7 },732 733 [SCARLETT2_CONFIG_PAD_SWITCH] = {734 .offset = 0x84, .size = 8, .activate = 8 },735 736 [SCARLETT2_CONFIG_AIR_SWITCH] = {737 .offset = 0x8c, .size = 8, .activate = 8 },738 739 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {740 .offset = 0x95, .size = 8, .activate = 6 },741 742 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {743 .offset = 0x9c, .size = 1, .activate = 8 },744 745 [SCARLETT2_CONFIG_MSD_SWITCH] = {746 .offset = 0x9d, .size = 8, .activate = 6 },747 748 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = {749 .offset = 0x9e, .size = 8, .activate = 6 },750 751 [SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = {752 .offset = 0x9f, .size = 1, .activate = 10 },753 754 [SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = {755 .offset = 0xa0, .size = 1, .activate = 10 },756 757 [SCARLETT2_CONFIG_TALKBACK_MAP] = {758 .offset = 0xb0, .size = 16, .activate = 10 },759 760 [SCARLETT2_CONFIG_SPDIF_MODE] = {761 .offset = 0x94, .size = 8, .activate = 6 },762 }763};764 765/* Vocaster */766static const struct scarlett2_config_set scarlett2_config_set_vocaster = {767 .notifications = vocaster_notifications,768 .param_buf_addr = 0x1bc,769 .input_gain_tlv = db_scale_vocaster_gain,770 .autogain_status_texts = scarlett2_autogain_status_vocaster,771 .items = {772 [SCARLETT2_CONFIG_MSD_SWITCH] = {773 .offset = 0x9d, .size = 8, .activate = 6 },774 775 [SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {776 .offset = 0x1c0, .size = 8, .activate = 19, .pbuf = 1 },777 778 [SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {779 .offset = 0x1c2, .size = 8, },780 781 [SCARLETT2_CONFIG_AG_HOT_TARGET] = {782 .offset = 0xc1, .size = 8, .activate = 29, .pbuf = 1 },783 784 [SCARLETT2_CONFIG_INPUT_GAIN] = {785 .offset = 0x9f, .size = 8, .activate = 21, .pbuf = 1 },786 787 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {788 .offset = 0x9c, .size = 1, .activate = 20, .pbuf = 1 },789 790 [SCARLETT2_CONFIG_DSP_SWITCH] = {791 .offset = 0x1c4, .size = 8, .activate = 22, .pbuf = 1 },792 793 [SCARLETT2_CONFIG_COMPRESSOR_PARAMS] = {794 .offset = 0x1c8, .size = 32, .activate = 23 },795 796 [SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH] = {797 .offset = 0x7c, .size = 32, .activate = 27 },798 799 [SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS] = {800 .offset = 0x200, .size = 32, .activate = 27 },801 802 [SCARLETT2_CONFIG_PEQ_FLT_SWITCH] = {803 .offset = 0x84, .size = 32, .activate = 27 },804 805 [SCARLETT2_CONFIG_PEQ_FLT_PARAMS] = {806 .offset = 0x250, .size = 32, .activate = 27 },807 808 [SCARLETT2_CONFIG_INPUT_MUTE_SWITCH] = {809 .offset = 0x1be, .size = 8, .activate = 17, .pbuf = 1 },810 811 [SCARLETT2_CONFIG_BLUETOOTH_VOLUME] = {812 .offset = 0xbf, .size = 8, .activate = 28 },813 }814};815 816/* Solo Gen 4 */817static const struct scarlett2_config_set scarlett2_config_set_gen4_solo = {818 .notifications = scarlett4_solo_notifications,819 .param_buf_addr = 0xd8,820 .items = {821 [SCARLETT2_CONFIG_MSD_SWITCH] = {822 .offset = 0x47, .size = 8, .activate = 4 },823 824 [SCARLETT2_CONFIG_DIRECT_MONITOR] = {825 .offset = 0x108, .size = 8, .activate = 12, .pbuf = 1 },826 827 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {828 .offset = 0x46, .size = 8, .activate = 9, .pbuf = 1,829 .mute = 1 },830 831 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {832 .offset = 0x3d, .size = 8, .activate = 10, .pbuf = 1,833 .mute = 1 },834 835 [SCARLETT2_CONFIG_AIR_SWITCH] = {836 .offset = 0x3e, .size = 8, .activate = 11, .pbuf = 1 },837 838 [SCARLETT2_CONFIG_PCM_INPUT_SWITCH] = {839 .offset = 0x206, .size = 8, .activate = 25, .pbuf = 1 },840 841 [SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {842 .offset = 0x232, .size = 16, .activate = 26 }843 }844};845 846/* 2i2 Gen 4 */847static const struct scarlett2_config_set scarlett2_config_set_gen4_2i2 = {848 .notifications = scarlett4_2i2_notifications,849 .param_buf_addr = 0xfc,850 .input_gain_tlv = db_scale_gen4_gain,851 .autogain_status_texts = scarlett2_autogain_status_gen4,852 .items = {853 [SCARLETT2_CONFIG_MSD_SWITCH] = {854 .offset = 0x49, .size = 8, .activate = 4 },855 856 [SCARLETT2_CONFIG_DIRECT_MONITOR] = {857 .offset = 0x14a, .size = 8, .activate = 16, .pbuf = 1 },858 859 [SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {860 .offset = 0x135, .size = 8, .activate = 10, .pbuf = 1 },861 862 [SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {863 .offset = 0x137, .size = 8 },864 865 [SCARLETT2_CONFIG_AG_MEAN_TARGET] = {866 .offset = 0x131, .size = 8, .activate = 29, .pbuf = 1 },867 868 [SCARLETT2_CONFIG_AG_PEAK_TARGET] = {869 .offset = 0x132, .size = 8, .activate = 30, .pbuf = 1 },870 871 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {872 .offset = 0x48, .size = 8, .activate = 11, .pbuf = 1,873 .mute = 1 },874 875 [SCARLETT2_CONFIG_INPUT_GAIN] = {876 .offset = 0x4b, .size = 8, .activate = 12, .pbuf = 1 },877 878 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {879 .offset = 0x3c, .size = 8, .activate = 13, .pbuf = 1,880 .mute = 1 },881 882 [SCARLETT2_CONFIG_SAFE_SWITCH] = {883 .offset = 0x147, .size = 8, .activate = 14, .pbuf = 1 },884 885 [SCARLETT2_CONFIG_AIR_SWITCH] = {886 .offset = 0x3e, .size = 8, .activate = 15, .pbuf = 1 },887 888 [SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {889 .offset = 0x14b, .size = 8, .activate = 17, .pbuf = 1 },890 891 [SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {892 .offset = 0x14e, .size = 8, .activate = 18, .pbuf = 1 },893 894 [SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = {895 .offset = 0x2a0, .size = 16, .activate = 36 }896 }897};898 899/* 4i4 Gen 4 */900static const struct scarlett2_config_set scarlett2_config_set_gen4_4i4 = {901 .notifications = scarlett4_4i4_notifications,902 .param_buf_addr = 0x130,903 .input_gain_tlv = db_scale_gen4_gain,904 .autogain_status_texts = scarlett2_autogain_status_gen4,905 .items = {906 [SCARLETT2_CONFIG_MSD_SWITCH] = {907 .offset = 0x5c, .size = 8, .activate = 4 },908 909 [SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = {910 .offset = 0x13e, .size = 8, .activate = 10, .pbuf = 1 },911 912 [SCARLETT2_CONFIG_AUTOGAIN_STATUS] = {913 .offset = 0x140, .size = 8 },914 915 [SCARLETT2_CONFIG_AG_MEAN_TARGET] = {916 .offset = 0x13a, .size = 8, .activate = 23, .pbuf = 1 },917 918 [SCARLETT2_CONFIG_AG_PEAK_TARGET] = {919 .offset = 0x13b, .size = 8, .activate = 24, .pbuf = 1 },920 921 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = {922 .offset = 0x5a, .size = 8, .activate = 11, .pbuf = 1,923 .mute = 1 },924 925 [SCARLETT2_CONFIG_INPUT_GAIN] = {926 .offset = 0x5e, .size = 8, .activate = 12, .pbuf = 1 },927 928 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {929 .offset = 0x4e, .size = 8, .activate = 13, .pbuf = 1,930 .mute = 1 },931 932 [SCARLETT2_CONFIG_SAFE_SWITCH] = {933 .offset = 0x150, .size = 8, .activate = 14, .pbuf = 1 },934 935 [SCARLETT2_CONFIG_AIR_SWITCH] = {936 .offset = 0x50, .size = 8, .activate = 15, .pbuf = 1 },937 938 [SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = {939 .offset = 0x153, .size = 8, .activate = 16, .pbuf = 1 },940 941 [SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = {942 .offset = 0x156, .size = 8, .activate = 17, .pbuf = 1 },943 944 [SCARLETT2_CONFIG_MASTER_VOLUME] = {945 .offset = 0x32, .size = 16 },946 947 [SCARLETT2_CONFIG_HEADPHONE_VOLUME] = {948 .offset = 0x3a, .size = 16 },949 950 [SCARLETT2_CONFIG_POWER_EXT] = {951 .offset = 0x168, .size = 8 },952 953 [SCARLETT2_CONFIG_POWER_LOW] = {954 .offset = 0x16d, .size = 8 }955 }956};957 958/* Clarett USB and Clarett+ devices: 2Pre, 4Pre, 8Pre */959static const struct scarlett2_config_set scarlett2_config_set_clarett = {960 .notifications = scarlett2_notifications,961 .items = {962 [SCARLETT2_CONFIG_DIM_MUTE] = {963 .offset = 0x31, .size = 8, .activate = 2 },964 965 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = {966 .offset = 0x34, .size = 16, .activate = 1 },967 968 [SCARLETT2_CONFIG_MUTE_SWITCH] = {969 .offset = 0x5c, .size = 8, .activate = 1 },970 971 [SCARLETT2_CONFIG_SW_HW_SWITCH] = {972 .offset = 0x66, .size = 8, .activate = 3 },973 974 [SCARLETT2_CONFIG_MASTER_VOLUME] = {975 .offset = 0x76, .size = 16 },976 977 [SCARLETT2_CONFIG_LEVEL_SWITCH] = {978 .offset = 0x7c, .size = 8, .activate = 7 },979 980 [SCARLETT2_CONFIG_AIR_SWITCH] = {981 .offset = 0x95, .size = 8, .activate = 8 },982 983 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = {984 .offset = 0x8d, .size = 8, .activate = 6 },985 986 [SCARLETT2_CONFIG_SPDIF_MODE] = {987 .offset = 0x9e, .size = 8, .activate = 4 },988 }989};990 991/* Description of each hardware port type:992 * - id: hardware ID of this port type993 * - src_descr: printf format string for mux input selections994 * - src_num_offset: added to channel number for the fprintf995 * - dst_descr: printf format string for mixer controls996 */997struct scarlett2_port {998 u16 id;999 const char * const src_descr;1000 int src_num_offset;1001 const char * const dst_descr;1002 const char * const dsp_src_descr;1003 const char * const dsp_dst_descr;1004};1005 1006static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = {1007 [SCARLETT2_PORT_TYPE_NONE] = {1008 .id = 0x000,1009 .src_descr = "Off"1010 },1011 [SCARLETT2_PORT_TYPE_ANALOGUE] = {1012 .id = 0x080,1013 .src_descr = "Analogue %d",1014 .src_num_offset = 1,1015 .dst_descr = "Analogue Output %02d Playback"1016 },1017 [SCARLETT2_PORT_TYPE_SPDIF] = {1018 .id = 0x180,1019 .src_descr = "S/PDIF %d",1020 .src_num_offset = 1,1021 .dst_descr = "S/PDIF Output %d Playback"1022 },1023 [SCARLETT2_PORT_TYPE_ADAT] = {1024 .id = 0x200,1025 .src_descr = "ADAT %d",1026 .src_num_offset = 1,1027 .dst_descr = "ADAT Output %d Playback"1028 },1029 [SCARLETT2_PORT_TYPE_MIX] = {1030 .id = 0x300,1031 .src_descr = "Mix %c",1032 .src_num_offset = 'A',1033 .dst_descr = "Mixer Input %02d Capture",1034 .dsp_src_descr = "DSP %d",1035 .dsp_dst_descr = "DSP Input %d Capture"1036 },1037 [SCARLETT2_PORT_TYPE_PCM] = {1038 .id = 0x600,1039 .src_descr = "PCM %d",1040 .src_num_offset = 1,1041 .dst_descr = "PCM %02d Capture"1042 },1043};1044 1045/* Number of mux tables: one for each band of sample rates1046 * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz)1047 */1048#define SCARLETT2_MUX_TABLES 31049 1050/* Maximum number of entries in a mux table */1051#define SCARLETT2_MAX_MUX_ENTRIES 101052 1053/* One entry within mux_assignment defines the port type and range of1054 * ports to add to the set_mux message. The end of the list is marked1055 * with count == 0.1056 */1057struct scarlett2_mux_entry {1058 u8 port_type;1059 u8 start;1060 u8 count;1061};1062 1063/* Maximum number of entries in a mux table */1064#define SCARLETT2_MAX_METER_ENTRIES 91065 1066/* One entry within meter_assignment defines the range of mux outputs1067 * that consecutive meter entries are mapped to. The end of the list1068 * is marked with count == 0.1069 */1070struct scarlett2_meter_entry {1071 u8 start;1072 u8 count;1073};1074 1075struct scarlett2_device_info {1076 /* which set of configuration parameters the device uses */1077 const struct scarlett2_config_set *config_set;1078 1079 /* minimum firmware version required */1080 u16 min_firmware_version;1081 1082 /* support for main/alt speaker switching */1083 u8 has_speaker_switching;1084 1085 /* support for talkback microphone */1086 u8 has_talkback;1087 1088 /* the number of analogue inputs with a software switchable1089 * level control that can be set to line or instrument1090 */1091 u8 level_input_count;1092 1093 /* the first input with a level control (0-based) */1094 u8 level_input_first;1095 1096 /* the number of analogue inputs with a software switchable1097 * 10dB pad control1098 */1099 u8 pad_input_count;1100 1101 /* the number of analogue inputs with a software switchable1102 * "air" control1103 */1104 u8 air_input_count;1105 1106 /* the first input with an air control (0-based) */1107 u8 air_input_first;1108 1109 /* number of additional air options1110 * 0 for air presence only (Gen 3)1111 * 1 for air presence+drive (Gen 4)1112 */1113 u8 air_option;1114 1115 /* the number of analogue inputs with DSP control */1116 u8 dsp_input_count;1117 1118 /* number of pre-compressor filters */1119 u8 precomp_flt_count;1120 1121 /* number of parametric EQ filters */1122 u8 peq_flt_count;1123 1124 /* number of PEQ filters plus unused slots */1125 u8 peq_flt_total_count;1126 1127 /* the number of analogue inputs with a software switchable1128 * mute control1129 */1130 u8 mute_input_count;1131 1132 /* the number of phantom (48V) software switchable controls */1133 u8 phantom_count;1134 1135 /* the first input with phantom power control (0-based) */1136 u8 phantom_first;1137 1138 /* the number of inputs each phantom switch controls */1139 u8 inputs_per_phantom;1140 1141 /* the number of inputs with software-controllable gain */1142 u8 gain_input_count;1143 1144 /* the number of inputs with safe mode */1145 u8 safe_input_count;1146 1147 /* the number of direct monitor options1148 * (0 = none, 1 = mono only, 2 = mono/stereo)1149 */1150 u8 direct_monitor;1151 1152 /* the number of DSP channels */1153 u8 dsp_count;1154 1155 /* has a Bluetooth module with volume control */1156 u8 has_bluetooth;1157 1158 /* S/PDIF Source/Digital I/O mode control */1159 const char * const spdif_mode_control_name;1160 const u8 *spdif_mode_values;1161 const char * const *spdif_mode_texts;1162 1163 /* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected1164 * internally to the analogue 7/8 outputs1165 */1166 u8 line_out_remap_enable;1167 u8 line_out_remap[SCARLETT2_ANALOGUE_MAX];1168 u8 line_out_unmap[SCARLETT2_ANALOGUE_MAX];1169 1170 /* additional description for the line out volume controls */1171 const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];1172 1173 /* number of sources/destinations of each port type */1174 const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS];1175 1176 /* layout/order of the entries in the set_mux message */1177 struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES]1178 [SCARLETT2_MAX_MUX_ENTRIES];1179 1180 /* map from meter level order returned by1181 * SCARLETT2_USB_GET_METER to index into mux[] entries (same1182 * as the order returned by scarlett2_meter_ctl_get())1183 */1184 struct scarlett2_meter_entry meter_map[SCARLETT2_MAX_METER_ENTRIES];1185};1186 1187struct scarlett2_data {1188 struct usb_mixer_interface *mixer;1189 struct mutex usb_mutex; /* prevent sending concurrent USB requests */1190 struct completion cmd_done;1191 struct mutex data_mutex; /* lock access to this data */1192 u8 running;1193 u8 hwdep_in_use;1194 u8 selected_flash_segment_id;1195 u8 flash_write_state;1196 struct delayed_work work;1197 const struct scarlett2_device_info *info;1198 const struct scarlett2_config_set *config_set;1199 const char *series_name;1200 __u8 bInterfaceNumber;1201 __u8 bEndpointAddress;1202 __u16 wMaxPacketSize;1203 __u8 bInterval;1204 u8 num_mux_srcs;1205 u8 num_mux_dsts;1206 u8 num_mix_in;1207 u8 num_mix_out;1208 u8 num_line_out;1209 u8 num_monitor_mix_ctls;1210 u8 num_autogain_status_texts;1211 u32 firmware_version;1212 u8 flash_segment_nums[SCARLETT2_SEGMENT_ID_COUNT];1213 u8 flash_segment_blocks[SCARLETT2_SEGMENT_ID_COUNT];1214 u16 scarlett2_seq;1215 u8 sync_updated;1216 u8 vol_updated;1217 u8 dim_mute_updated;1218 u8 input_level_updated;1219 u8 input_pad_updated;1220 u8 input_air_updated;1221 u8 input_dsp_updated;1222 u8 input_mute_updated;1223 u8 input_phantom_updated;1224 u8 input_select_updated;1225 u8 input_gain_updated;1226 u8 autogain_updated;1227 u8 input_safe_updated;1228 u8 pcm_input_switch_updated;1229 u8 monitor_other_updated;1230 u8 direct_monitor_updated;1231 u8 mux_updated;1232 u8 mix_updated;1233 u8 speaker_switching_switched;1234 u8 power_status_updated;1235 u8 bluetooth_updated;1236 u8 sync;1237 u8 master_vol;1238 u8 headphone_vol;1239 u8 vol[SCARLETT2_ANALOGUE_MAX];1240 u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];1241 u8 mute_switch[SCARLETT2_ANALOGUE_MAX];1242 u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];1243 u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];1244 u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT];1245 u8 air_switch[SCARLETT2_AIR_SWITCH_MAX];1246 u8 dsp_switch[SCARLETT2_DSP_SWITCH_MAX];1247 s32 compressor_values[SCARLETT2_COMPRESSOR_CTLS_MAX];1248 s32 precomp_flt_values[SCARLETT2_PRECOMP_FLT_VALUES_MAX];1249 s32 peq_flt_values[SCARLETT2_PEQ_FLT_VALUES_MAX];1250 u8 precomp_flt_switch[SCARLETT2_DSP_SWITCH_MAX];1251 u8 peq_flt_switch[SCARLETT2_DSP_SWITCH_MAX];1252 u8 input_mute_switch[SCARLETT2_INPUT_MUTE_SWITCH_MAX];1253 u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX];1254 u8 phantom_persistence;1255 u8 input_select_switch;1256 u8 input_link_switch[SCARLETT2_INPUT_GAIN_MAX / 2];1257 u8 gain[SCARLETT2_INPUT_GAIN_MAX];1258 u8 autogain_switch[SCARLETT2_INPUT_GAIN_MAX];1259 u8 autogain_status[SCARLETT2_INPUT_GAIN_MAX];1260 s8 ag_targets[SCARLETT2_AG_TARGET_COUNT];1261 u8 safe_switch[SCARLETT2_INPUT_GAIN_MAX];1262 u8 pcm_input_switch;1263 u8 direct_monitor_switch;1264 u8 speaker_switching_switch;1265 u8 talkback_switch;1266 u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX];1267 u8 msd_switch;1268 u8 standalone_switch;1269 u8 power_status;1270 u8 bluetooth_volume;1271 u8 spdif_mode;1272 u8 meter_level_map[SCARLETT2_MAX_METERS];1273 struct snd_kcontrol *sync_ctl;1274 struct snd_kcontrol *master_vol_ctl;1275 struct snd_kcontrol *headphone_vol_ctl;1276 struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];1277 struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX];1278 struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX];1279 struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT];1280 struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX];1281 struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX];1282 struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX];1283 struct snd_kcontrol *dsp_ctls[SCARLETT2_DSP_SWITCH_MAX];1284 struct snd_kcontrol *input_mute_ctls[SCARLETT2_INPUT_MUTE_SWITCH_MAX];1285 struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX];1286 struct snd_kcontrol *input_select_ctl;1287 struct snd_kcontrol *input_link_ctls[SCARLETT2_INPUT_GAIN_MAX / 2];1288 struct snd_kcontrol *input_gain_ctls[SCARLETT2_INPUT_GAIN_MAX];1289 struct snd_kcontrol *autogain_ctls[SCARLETT2_INPUT_GAIN_MAX];1290 struct snd_kcontrol *autogain_status_ctls[SCARLETT2_INPUT_GAIN_MAX];1291 struct snd_kcontrol *ag_target_ctls[SCARLETT2_AG_TARGET_COUNT];1292 struct snd_kcontrol *safe_ctls[SCARLETT2_INPUT_GAIN_MAX];1293 struct snd_kcontrol *pcm_input_switch_ctl;1294 struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX];1295 struct snd_kcontrol *mix_ctls[SCARLETT2_MIX_MAX];1296 struct snd_kcontrol *compressor_ctls[SCARLETT2_COMPRESSOR_CTLS_MAX];1297 struct snd_kcontrol *precomp_flt_ctls[SCARLETT2_PRECOMP_FLT_CTLS_MAX];1298 struct snd_kcontrol *peq_flt_ctls[SCARLETT2_PEQ_FLT_CTLS_MAX];1299 struct snd_kcontrol *precomp_flt_switch_ctls[SCARLETT2_DSP_SWITCH_MAX];1300 struct snd_kcontrol *peq_flt_switch_ctls[SCARLETT2_DSP_SWITCH_MAX];1301 struct snd_kcontrol *direct_monitor_ctl;1302 struct snd_kcontrol *speaker_switching_ctl;1303 struct snd_kcontrol *talkback_ctl;1304 struct snd_kcontrol *power_status_ctl;1305 struct snd_kcontrol *bluetooth_volume_ctl;1306 u8 mux[SCARLETT2_MUX_MAX];1307 u8 mix[SCARLETT2_MIX_MAX];1308 u8 monitor_mix[SCARLETT2_MONITOR_MIX_MAX];1309};1310 1311/*** Model-specific data ***/1312 1313static const struct scarlett2_device_info s6i6_gen2_info = {1314 .config_set = &scarlett2_config_set_gen2a,1315 .level_input_count = 2,1316 .pad_input_count = 2,1317 1318 .line_out_descrs = {1319 "Headphones 1 L",1320 "Headphones 1 R",1321 "Headphones 2 L",1322 "Headphones 2 R",1323 },1324 1325 .port_count = {1326 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1327 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },1328 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1329 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },1330 [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 },1331 },1332 1333 .mux_assignment = { {1334 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1335 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1336 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1337 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1338 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1339 { 0, 0, 0 },1340 }, {1341 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1342 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1343 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1344 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1345 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1346 { 0, 0, 0 },1347 }, {1348 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1349 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1350 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1351 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1352 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1353 { 0, 0, 0 },1354 } },1355 1356 .meter_map = {1357 { 24, 6 },1358 { 0, 24 },1359 { 0, 0 },1360 }1361};1362 1363static const struct scarlett2_device_info s18i8_gen2_info = {1364 .config_set = &scarlett2_config_set_gen2a,1365 .level_input_count = 2,1366 .pad_input_count = 4,1367 1368 .line_out_descrs = {1369 "Monitor L",1370 "Monitor R",1371 "Headphones 1 L",1372 "Headphones 1 R",1373 "Headphones 2 L",1374 "Headphones 2 R",1375 },1376 1377 .port_count = {1378 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1379 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 },1380 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1381 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },1382 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },1383 [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 },1384 },1385 1386 .mux_assignment = { {1387 { SCARLETT2_PORT_TYPE_PCM, 0, 18 },1388 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1389 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1390 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1391 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1392 { 0, 0, 0 },1393 }, {1394 { SCARLETT2_PORT_TYPE_PCM, 0, 14 },1395 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1396 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1397 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1398 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1399 { 0, 0, 0 },1400 }, {1401 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1402 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1403 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1404 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1405 { SCARLETT2_PORT_TYPE_NONE, 0, 4 },1406 { 0, 0, 0 },1407 } },1408 1409 .meter_map = {1410 { 26, 18 },1411 { 0, 26 },1412 { 0, 0 },1413 }1414};1415 1416static const struct scarlett2_device_info s18i20_gen2_info = {1417 .config_set = &scarlett2_config_set_gen2b,1418 1419 .line_out_descrs = {1420 "Monitor L",1421 "Monitor R",1422 NULL,1423 NULL,1424 NULL,1425 NULL,1426 "Headphones 1 L",1427 "Headphones 1 R",1428 "Headphones 2 L",1429 "Headphones 2 R",1430 },1431 1432 .port_count = {1433 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1434 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },1435 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1436 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },1437 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },1438 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },1439 },1440 1441 .mux_assignment = { {1442 { SCARLETT2_PORT_TYPE_PCM, 0, 18 },1443 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1444 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1445 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 },1446 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1447 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1448 { 0, 0, 0 },1449 }, {1450 { SCARLETT2_PORT_TYPE_PCM, 0, 14 },1451 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1452 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1453 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 },1454 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1455 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },1456 { 0, 0, 0 },1457 }, {1458 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1459 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1460 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1461 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },1462 { SCARLETT2_PORT_TYPE_NONE, 0, 6 },1463 { 0, 0, 0 },1464 } },1465 1466 .meter_map = {1467 { 38, 18 },1468 { 0, 38 },1469 { 0, 0 },1470 }1471};1472 1473static const struct scarlett2_device_info solo_gen3_info = {1474 .config_set = &scarlett2_config_set_gen3a,1475 .level_input_count = 1,1476 .level_input_first = 1,1477 .air_input_count = 1,1478 .phantom_count = 1,1479 .inputs_per_phantom = 1,1480 .direct_monitor = 1,1481};1482 1483static const struct scarlett2_device_info s2i2_gen3_info = {1484 .config_set = &scarlett2_config_set_gen3a,1485 .level_input_count = 2,1486 .air_input_count = 2,1487 .phantom_count = 1,1488 .inputs_per_phantom = 2,1489 .direct_monitor = 2,1490};1491 1492static const struct scarlett2_device_info s4i4_gen3_info = {1493 .config_set = &scarlett2_config_set_gen3b,1494 .level_input_count = 2,1495 .pad_input_count = 2,1496 .air_input_count = 2,1497 .phantom_count = 1,1498 .inputs_per_phantom = 2,1499 1500 .line_out_descrs = {1501 "Monitor L",1502 "Monitor R",1503 "Headphones L",1504 "Headphones R",1505 },1506 1507 .port_count = {1508 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1509 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 },1510 [SCARLETT2_PORT_TYPE_MIX] = { 6, 8 },1511 [SCARLETT2_PORT_TYPE_PCM] = { 4, 6 },1512 },1513 1514 .mux_assignment = { {1515 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1516 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1517 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1518 { SCARLETT2_PORT_TYPE_NONE, 0, 16 },1519 { 0, 0, 0 },1520 }, {1521 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1522 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1523 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1524 { SCARLETT2_PORT_TYPE_NONE, 0, 16 },1525 { 0, 0, 0 },1526 }, {1527 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1528 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1529 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1530 { SCARLETT2_PORT_TYPE_NONE, 0, 16 },1531 { 0, 0, 0 },1532 } },1533 1534 .meter_map = {1535 { 12, 6 },1536 { 0, 12 },1537 { 0, 0 },1538 }1539};1540 1541static const struct scarlett2_device_info s8i6_gen3_info = {1542 .config_set = &scarlett2_config_set_gen3b,1543 .level_input_count = 2,1544 .pad_input_count = 2,1545 .air_input_count = 2,1546 .phantom_count = 1,1547 .inputs_per_phantom = 2,1548 1549 .line_out_descrs = {1550 "Headphones 1 L",1551 "Headphones 1 R",1552 "Headphones 2 L",1553 "Headphones 2 R",1554 },1555 1556 .port_count = {1557 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1558 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 },1559 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1560 [SCARLETT2_PORT_TYPE_MIX] = { 8, 8 },1561 [SCARLETT2_PORT_TYPE_PCM] = { 6, 10 },1562 },1563 1564 .mux_assignment = { {1565 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },1566 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1567 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1568 { SCARLETT2_PORT_TYPE_PCM, 8, 2 },1569 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1570 { SCARLETT2_PORT_TYPE_NONE, 0, 18 },1571 { 0, 0, 0 },1572 }, {1573 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },1574 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1575 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1576 { SCARLETT2_PORT_TYPE_PCM, 8, 2 },1577 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1578 { SCARLETT2_PORT_TYPE_NONE, 0, 18 },1579 { 0, 0, 0 },1580 }, {1581 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },1582 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1583 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1584 { SCARLETT2_PORT_TYPE_PCM, 8, 2 },1585 { SCARLETT2_PORT_TYPE_MIX, 0, 8 },1586 { SCARLETT2_PORT_TYPE_NONE, 0, 18 },1587 { 0, 0, 0 },1588 } },1589 1590 .meter_map = {1591 { 14, 8 },1592 { 0, 6 },1593 { 22, 2 },1594 { 6, 8 },1595 { 0, 0 },1596 }1597};1598 1599static const u8 scarlett2_spdif_s18i8_gen3_values[] = { 0, 2, 0xff };1600 1601static const char * const scarlett2_spdif_s18i8_gen3_texts[] = {1602 "RCA",1603 "Optical",1604 NULL1605};1606 1607static const struct scarlett2_device_info s18i8_gen3_info = {1608 .config_set = &scarlett2_config_set_gen3c,1609 .has_speaker_switching = 1,1610 .level_input_count = 2,1611 .pad_input_count = 4,1612 .air_input_count = 4,1613 .phantom_count = 2,1614 .inputs_per_phantom = 2,1615 1616 .spdif_mode_control_name = "S/PDIF Mode Capture Enum",1617 .spdif_mode_values = scarlett2_spdif_s18i8_gen3_values,1618 .spdif_mode_texts = scarlett2_spdif_s18i8_gen3_texts,1619 1620 .line_out_remap_enable = 1,1621 .line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 },1622 .line_out_unmap = { 0, 1, 4, 5, 6, 7, 2, 3 },1623 1624 .line_out_descrs = {1625 "Monitor L",1626 "Monitor R",1627 "Alt Monitor L",1628 "Alt Monitor R",1629 "Headphones 1 L",1630 "Headphones 1 R",1631 "Headphones 2 L",1632 "Headphones 2 R",1633 },1634 1635 .port_count = {1636 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1637 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 },1638 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1639 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },1640 [SCARLETT2_PORT_TYPE_MIX] = { 10, 20 },1641 [SCARLETT2_PORT_TYPE_PCM] = { 8, 20 },1642 },1643 1644 .mux_assignment = { {1645 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1646 { SCARLETT2_PORT_TYPE_PCM, 12, 8 },1647 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1648 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },1649 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },1650 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1651 { SCARLETT2_PORT_TYPE_PCM, 10, 2 },1652 { SCARLETT2_PORT_TYPE_MIX, 0, 20 },1653 { SCARLETT2_PORT_TYPE_NONE, 0, 10 },1654 { 0, 0, 0 },1655 }, {1656 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1657 { SCARLETT2_PORT_TYPE_PCM, 12, 4 },1658 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1659 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },1660 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },1661 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1662 { SCARLETT2_PORT_TYPE_PCM, 10, 2 },1663 { SCARLETT2_PORT_TYPE_MIX, 0, 20 },1664 { SCARLETT2_PORT_TYPE_NONE, 0, 10 },1665 { 0, 0, 0 },1666 }, {1667 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1668 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1669 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 },1670 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 },1671 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1672 { SCARLETT2_PORT_TYPE_MIX, 0, 20 },1673 { SCARLETT2_PORT_TYPE_NONE, 0, 10 },1674 { 0, 0, 0 },1675 } },1676 1677 .meter_map = {1678 { 30, 10 },1679 { 42, 8 },1680 { 0, 2 },1681 { 6, 2 },1682 { 2, 4 },1683 { 8, 2 },1684 { 40, 2 },1685 { 10, 20 },1686 { 0, 0 }1687 }1688};1689 1690static const u8 scarlett2_spdif_s18i20_gen3_values[] = { 0, 6, 1, 0xff };1691 1692static const char * const scarlett2_spdif_s18i20_gen3_texts[] = {1693 "S/PDIF RCA",1694 "S/PDIF Optical",1695 "Dual ADAT",1696 NULL1697};1698 1699static const struct scarlett2_device_info s18i20_gen3_info = {1700 .config_set = &scarlett2_config_set_gen3c,1701 .has_speaker_switching = 1,1702 .has_talkback = 1,1703 .level_input_count = 2,1704 .pad_input_count = 8,1705 .air_input_count = 8,1706 .phantom_count = 2,1707 .inputs_per_phantom = 4,1708 1709 .spdif_mode_control_name = "Digital I/O Mode Capture Enum",1710 .spdif_mode_values = scarlett2_spdif_s18i20_gen3_values,1711 .spdif_mode_texts = scarlett2_spdif_s18i20_gen3_texts,1712 1713 .line_out_descrs = {1714 "Monitor 1 L",1715 "Monitor 1 R",1716 "Monitor 2 L",1717 "Monitor 2 R",1718 NULL,1719 NULL,1720 "Headphones 1 L",1721 "Headphones 1 R",1722 "Headphones 2 L",1723 "Headphones 2 R",1724 },1725 1726 .port_count = {1727 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1728 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 },1729 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },1730 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },1731 [SCARLETT2_PORT_TYPE_MIX] = { 12, 25 },1732 [SCARLETT2_PORT_TYPE_PCM] = { 20, 20 },1733 },1734 1735 .mux_assignment = { {1736 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },1737 { SCARLETT2_PORT_TYPE_PCM, 10, 10 },1738 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1739 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1740 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 },1741 { SCARLETT2_PORT_TYPE_PCM, 8, 2 },1742 { SCARLETT2_PORT_TYPE_MIX, 0, 25 },1743 { SCARLETT2_PORT_TYPE_NONE, 0, 12 },1744 { 0, 0, 0 },1745 }, {1746 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },1747 { SCARLETT2_PORT_TYPE_PCM, 10, 8 },1748 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1749 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1750 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 },1751 { SCARLETT2_PORT_TYPE_PCM, 8, 2 },1752 { SCARLETT2_PORT_TYPE_MIX, 0, 25 },1753 { SCARLETT2_PORT_TYPE_NONE, 0, 10 },1754 { 0, 0, 0 },1755 }, {1756 { SCARLETT2_PORT_TYPE_PCM, 0, 10 },1757 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },1758 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },1759 { SCARLETT2_PORT_TYPE_NONE, 0, 24 },1760 { 0, 0, 0 },1761 } },1762 1763 .meter_map = {1764 { 45, 8 },1765 { 55, 10 },1766 { 0, 20 },1767 { 53, 2 },1768 { 20, 25 },1769 { 0, 0 },1770 }1771};1772 1773static const struct scarlett2_device_info vocaster_one_info = {1774 .config_set = &scarlett2_config_set_vocaster,1775 .min_firmware_version = 1769,1776 1777 .phantom_count = 1,1778 .inputs_per_phantom = 1,1779 .dsp_count = 1,1780 .dsp_input_count = 1,1781 .precomp_flt_count = 2,1782 .peq_flt_count = 3,1783 .peq_flt_total_count = 4,1784 .mute_input_count = 1,1785 .gain_input_count = 1,1786 1787 .port_count = {1788 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1789 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 4 },1790 [SCARLETT2_PORT_TYPE_MIX] = { 9, 9 },1791 [SCARLETT2_PORT_TYPE_PCM] = { 4, 10 },1792 },1793 1794 .mux_assignment = { {1795 { SCARLETT2_PORT_TYPE_MIX, 8, 1 },1796 { SCARLETT2_PORT_TYPE_PCM, 5, 5 },1797 { SCARLETT2_PORT_TYPE_MIX, 6, 2 },1798 { SCARLETT2_PORT_TYPE_PCM, 0, 5 },1799 { SCARLETT2_PORT_TYPE_MIX, 0, 6 },1800 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },1801 { 0, 0, 0 },1802 } },1803 1804 .meter_map = {1805 { 12, 1 },1806 { 18, 5 },1807 { 10, 2 },1808 { 13, 5 },1809 { 4, 6 },1810 { 0, 4 },1811 { 0, 0 }1812 }1813};1814 1815static const struct scarlett2_device_info vocaster_two_info = {1816 .config_set = &scarlett2_config_set_vocaster,1817 .min_firmware_version = 1769,1818 1819 .phantom_count = 2,1820 .inputs_per_phantom = 1,1821 .dsp_count = 2,1822 .dsp_input_count = 2,1823 .precomp_flt_count = 2,1824 .peq_flt_count = 3,1825 .peq_flt_total_count = 4,1826 .mute_input_count = 2,1827 .gain_input_count = 2,1828 .has_bluetooth = 1,1829 1830 .port_count = {1831 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1832 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 6 },1833 [SCARLETT2_PORT_TYPE_MIX] = { 12, 14 },1834 [SCARLETT2_PORT_TYPE_PCM] = { 4, 14 },1835 },1836 1837 .mux_assignment = { {1838 { SCARLETT2_PORT_TYPE_MIX, 12, 2 },1839 { SCARLETT2_PORT_TYPE_PCM, 6, 8 },1840 { SCARLETT2_PORT_TYPE_MIX, 10, 2 },1841 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1842 { SCARLETT2_PORT_TYPE_MIX, 0, 10 },1843 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1844 { 0, 0, 0 },1845 } },1846 1847 .meter_map = {1848 { 18, 2 },1849 { 26, 8 },1850 { 16, 2 },1851 { 20, 6 },1852 { 6, 10 },1853 { 0, 6 },1854 { 0, 0 }1855 }1856};1857 1858static const struct scarlett2_device_info solo_gen4_info = {1859 .config_set = &scarlett2_config_set_gen4_solo,1860 .min_firmware_version = 2115,1861 1862 .level_input_count = 1,1863 .air_input_count = 1,1864 .air_input_first = 1,1865 .air_option = 1,1866 .phantom_count = 1,1867 .phantom_first = 1,1868 .inputs_per_phantom = 1,1869 .direct_monitor = 1,1870 .dsp_count = 2,1871 1872 .port_count = {1873 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1874 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 },1875 [SCARLETT2_PORT_TYPE_MIX] = { 8, 6 },1876 [SCARLETT2_PORT_TYPE_PCM] = { 2, 4 },1877 },1878 1879 .mux_assignment = { {1880 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1881 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1882 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1883 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1884 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1885 { 0, 0, 0 },1886 }, {1887 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1888 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1889 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1890 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1891 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1892 { 0, 0, 0 },1893 }, {1894 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1895 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1896 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1897 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1898 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1899 { 0, 0, 0 },1900 } },1901 1902 .meter_map = {1903 { 6, 2 },1904 { 4, 2 },1905 { 8, 4 },1906 { 2, 2 },1907 { 0, 2 },1908 { 0, 0 }1909 }1910};1911 1912static const struct scarlett2_device_info s2i2_gen4_info = {1913 .config_set = &scarlett2_config_set_gen4_2i2,1914 .min_firmware_version = 2115,1915 1916 .level_input_count = 2,1917 .air_input_count = 2,1918 .air_option = 1,1919 .phantom_count = 1,1920 .inputs_per_phantom = 2,1921 .gain_input_count = 2,1922 .safe_input_count = 2,1923 .direct_monitor = 2,1924 .dsp_count = 2,1925 1926 .port_count = {1927 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1928 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 },1929 [SCARLETT2_PORT_TYPE_MIX] = { 6, 6 },1930 [SCARLETT2_PORT_TYPE_PCM] = { 2, 4 },1931 },1932 1933 .mux_assignment = { {1934 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1935 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1936 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1937 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1938 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1939 { 0, 0, 0 },1940 }, {1941 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1942 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1943 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1944 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1945 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1946 { 0, 0, 0 },1947 }, {1948 { SCARLETT2_PORT_TYPE_MIX, 4, 2 },1949 { SCARLETT2_PORT_TYPE_MIX, 2, 2 },1950 { SCARLETT2_PORT_TYPE_PCM, 0, 4 },1951 { SCARLETT2_PORT_TYPE_MIX, 0, 2 },1952 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 },1953 { 0, 0, 0 },1954 } },1955 1956 .meter_map = {1957 { 6, 2 },1958 { 4, 2 },1959 { 8, 4 },1960 { 2, 2 },1961 { 0, 2 },1962 { 0, 0 }1963 }1964};1965 1966static const struct scarlett2_device_info s4i4_gen4_info = {1967 .config_set = &scarlett2_config_set_gen4_4i4,1968 .min_firmware_version = 2089,1969 1970 .level_input_count = 2,1971 .air_input_count = 2,1972 .air_option = 1,1973 .phantom_count = 2,1974 .inputs_per_phantom = 1,1975 .gain_input_count = 2,1976 .safe_input_count = 2,1977 .dsp_count = 2,1978 1979 .port_count = {1980 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },1981 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 6 },1982 [SCARLETT2_PORT_TYPE_MIX] = { 8, 12 },1983 [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 },1984 },1985 1986 .mux_assignment = { {1987 { SCARLETT2_PORT_TYPE_MIX, 10, 2 },1988 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1989 { SCARLETT2_PORT_TYPE_MIX, 0, 10 },1990 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1991 { 0, 0, 0 },1992 }, {1993 { SCARLETT2_PORT_TYPE_MIX, 10, 2 },1994 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },1995 { SCARLETT2_PORT_TYPE_MIX, 0, 10 },1996 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },1997 { 0, 0, 0 },1998 }, {1999 { SCARLETT2_PORT_TYPE_MIX, 10, 2 },2000 { SCARLETT2_PORT_TYPE_PCM, 0, 6 },2001 { SCARLETT2_PORT_TYPE_MIX, 0, 10 },2002 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },2003 { 0, 0, 0 },2004 } },2005 2006 .meter_map = {2007 { 16, 8 },2008 { 6, 10 },2009 { 0, 6 },2010 { 0, 0 }2011 }2012};2013 2014static const struct scarlett2_device_info clarett_2pre_info = {2015 .config_set = &scarlett2_config_set_clarett,2016 .level_input_count = 2,2017 .air_input_count = 2,2018 2019 .line_out_descrs = {2020 "Monitor L",2021 "Monitor R",2022 "Headphones L",2023 "Headphones R",2024 },2025 2026 .port_count = {2027 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },2028 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 4 },2029 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 0 },2030 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },2031 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },2032 [SCARLETT2_PORT_TYPE_PCM] = { 4, 12 },2033 },2034 2035 .mux_assignment = { {2036 { SCARLETT2_PORT_TYPE_PCM, 0, 12 },2037 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },2038 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2039 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2040 { 0, 0, 0 },2041 }, {2042 { SCARLETT2_PORT_TYPE_PCM, 0, 8 },2043 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },2044 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2045 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2046 { 0, 0, 0 },2047 }, {2048 { SCARLETT2_PORT_TYPE_PCM, 0, 2 },2049 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 },2050 { SCARLETT2_PORT_TYPE_NONE, 0, 26 },2051 { 0, 0, 0 },2052 } },2053 2054 .meter_map = {2055 { 22, 12 },2056 { 0, 22 },2057 { 0, 0 }2058 }2059};2060 2061static const u8 scarlett2_spdif_clarett_values[] = { 0, 1, 2, 0xff };2062 2063static const char * const scarlett2_spdif_clarett_texts[] = {2064 "None",2065 "Optical",2066 "RCA",2067 NULL2068};2069 2070static const struct scarlett2_device_info clarett_4pre_info = {2071 .config_set = &scarlett2_config_set_clarett,2072 .level_input_count = 2,2073 .air_input_count = 4,2074 2075 .spdif_mode_control_name = "S/PDIF Source Capture Enum",2076 .spdif_mode_values = scarlett2_spdif_clarett_values,2077 .spdif_mode_texts = scarlett2_spdif_clarett_texts,2078 2079 .line_out_descrs = {2080 "Monitor L",2081 "Monitor R",2082 "Headphones 1 L",2083 "Headphones 1 R",2084 "Headphones 2 L",2085 "Headphones 2 R",2086 },2087 2088 .port_count = {2089 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },2090 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 },2091 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },2092 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 },2093 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },2094 [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 },2095 },2096 2097 .mux_assignment = { {2098 { SCARLETT2_PORT_TYPE_PCM, 0, 18 },2099 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },2100 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2101 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2102 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2103 { 0, 0, 0 },2104 }, {2105 { SCARLETT2_PORT_TYPE_PCM, 0, 14 },2106 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },2107 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2108 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2109 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2110 { 0, 0, 0 },2111 }, {2112 { SCARLETT2_PORT_TYPE_PCM, 0, 12 },2113 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 },2114 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2115 { SCARLETT2_PORT_TYPE_NONE, 0, 24 },2116 { 0, 0, 0 },2117 } },2118 2119 .meter_map = {2120 { 26, 18 },2121 { 0, 26 },2122 { 0, 0 }2123 }2124};2125 2126static const struct scarlett2_device_info clarett_8pre_info = {2127 .config_set = &scarlett2_config_set_clarett,2128 .level_input_count = 2,2129 .air_input_count = 8,2130 2131 .spdif_mode_control_name = "S/PDIF Source Capture Enum",2132 .spdif_mode_values = scarlett2_spdif_clarett_values,2133 .spdif_mode_texts = scarlett2_spdif_clarett_texts,2134 2135 .line_out_descrs = {2136 "Monitor L",2137 "Monitor R",2138 NULL,2139 NULL,2140 NULL,2141 NULL,2142 "Headphones 1 L",2143 "Headphones 1 R",2144 "Headphones 2 L",2145 "Headphones 2 R",2146 },2147 2148 .port_count = {2149 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 },2150 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 },2151 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 },2152 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 },2153 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 },2154 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 },2155 },2156 2157 .mux_assignment = { {2158 { SCARLETT2_PORT_TYPE_PCM, 0, 18 },2159 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },2160 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2161 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 },2162 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2163 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2164 { 0, 0, 0 },2165 }, {2166 { SCARLETT2_PORT_TYPE_PCM, 0, 14 },2167 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },2168 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2169 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 },2170 { SCARLETT2_PORT_TYPE_MIX, 0, 18 },2171 { SCARLETT2_PORT_TYPE_NONE, 0, 8 },2172 { 0, 0, 0 },2173 }, {2174 { SCARLETT2_PORT_TYPE_PCM, 0, 12 },2175 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 },2176 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 },2177 { SCARLETT2_PORT_TYPE_NONE, 0, 22 },2178 { 0, 0, 0 },2179 } },2180 2181 .meter_map = {2182 { 38, 18 },2183 { 0, 38 },2184 { 0, 0 }2185 }2186};2187 2188struct scarlett2_device_entry {2189 const u32 usb_id; /* USB device identifier */2190 const struct scarlett2_device_info *info;2191 const char *series_name;2192};2193 2194static const struct scarlett2_device_entry scarlett2_devices[] = {2195 /* Supported Gen 2 devices */2196 { USB_ID(0x1235, 0x8203), &s6i6_gen2_info, "Scarlett Gen 2" },2197 { USB_ID(0x1235, 0x8204), &s18i8_gen2_info, "Scarlett Gen 2" },2198 { USB_ID(0x1235, 0x8201), &s18i20_gen2_info, "Scarlett Gen 2" },2199 2200 /* Supported Gen 3 devices */2201 { USB_ID(0x1235, 0x8211), &solo_gen3_info, "Scarlett Gen 3" },2202 { USB_ID(0x1235, 0x8210), &s2i2_gen3_info, "Scarlett Gen 3" },2203 { USB_ID(0x1235, 0x8212), &s4i4_gen3_info, "Scarlett Gen 3" },2204 { USB_ID(0x1235, 0x8213), &s8i6_gen3_info, "Scarlett Gen 3" },2205 { USB_ID(0x1235, 0x8214), &s18i8_gen3_info, "Scarlett Gen 3" },2206 { USB_ID(0x1235, 0x8215), &s18i20_gen3_info, "Scarlett Gen 3" },2207 2208 /* Supported Vocaster devices */2209 { USB_ID(0x1235, 0x8216), &vocaster_one_info, "Vocaster" },2210 { USB_ID(0x1235, 0x8217), &vocaster_two_info, "Vocaster" },2211 2212 /* Supported Gen 4 devices */2213 { USB_ID(0x1235, 0x8218), &solo_gen4_info, "Scarlett Gen 4" },2214 { USB_ID(0x1235, 0x8219), &s2i2_gen4_info, "Scarlett Gen 4" },2215 { USB_ID(0x1235, 0x821a), &s4i4_gen4_info, "Scarlett Gen 4" },2216 2217 /* Supported Clarett USB/Clarett+ devices */2218 { USB_ID(0x1235, 0x8206), &clarett_2pre_info, "Clarett USB" },2219 { USB_ID(0x1235, 0x8207), &clarett_4pre_info, "Clarett USB" },2220 { USB_ID(0x1235, 0x8208), &clarett_8pre_info, "Clarett USB" },2221 { USB_ID(0x1235, 0x820a), &clarett_2pre_info, "Clarett+" },2222 { USB_ID(0x1235, 0x820b), &clarett_4pre_info, "Clarett+" },2223 { USB_ID(0x1235, 0x820c), &clarett_8pre_info, "Clarett+" },2224 2225 /* End of list */2226 { 0, NULL },2227};2228 2229/* get the starting port index number for a given port type/direction */2230static int scarlett2_get_port_start_num(2231 const int port_count[][SCARLETT2_PORT_DIRNS],2232 int direction, int port_type)2233{2234 int i, num = 0;2235 2236 for (i = 0; i < port_type; i++)2237 num += port_count[i][direction];2238 2239 return num;2240}2241 2242/*** USB Interactions ***/2243 2244/* Commands for sending/receiving requests/responses */2245#define SCARLETT2_USB_CMD_INIT 02246#define SCARLETT2_USB_CMD_REQ 22247#define SCARLETT2_USB_CMD_RESP 32248 2249#define SCARLETT2_USB_INIT_1 0x000000002250#define SCARLETT2_USB_INIT_2 0x000000022251#define SCARLETT2_USB_REBOOT 0x000000032252#define SCARLETT2_USB_GET_METER 0x000010012253#define SCARLETT2_USB_GET_MIX 0x000020012254#define SCARLETT2_USB_SET_MIX 0x000020022255#define SCARLETT2_USB_GET_MUX 0x000030012256#define SCARLETT2_USB_SET_MUX 0x000030022257#define SCARLETT2_USB_INFO_FLASH 0x000040002258#define SCARLETT2_USB_INFO_SEGMENT 0x000040012259#define SCARLETT2_USB_ERASE_SEGMENT 0x000040022260#define SCARLETT2_USB_GET_ERASE 0x000040032261#define SCARLETT2_USB_WRITE_SEGMENT 0x000040042262#define SCARLETT2_USB_READ_SEGMENT 0x000040052263#define SCARLETT2_USB_GET_SYNC 0x000060042264#define SCARLETT2_USB_GET_DATA 0x008000002265#define SCARLETT2_USB_SET_DATA 0x008000012266#define SCARLETT2_USB_DATA_CMD 0x008000022267 2268#define SCARLETT2_USB_CONFIG_SAVE 62269 2270#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 12271 2272#define SCARLETT2_FLASH_BLOCK_SIZE 40962273#define SCARLETT2_FLASH_RW_MAX 10242274#define SCARLETT2_SEGMENT_NUM_MIN 12275#define SCARLETT2_SEGMENT_NUM_MAX 42276 2277#define SCARLETT2_SEGMENT_SETTINGS_NAME "App_Settings"2278#define SCARLETT2_SEGMENT_FIRMWARE_NAME "App_Upgrade"2279 2280/* proprietary request/response format */2281struct scarlett2_usb_packet {2282 __le32 cmd;2283 __le16 size;2284 __le16 seq;2285 __le32 error;2286 __le32 pad;2287 u8 data[];2288};2289 2290static void scarlett2_fill_request_header(struct scarlett2_data *private,2291 struct scarlett2_usb_packet *req,2292 u32 cmd, u16 req_size)2293{2294 /* sequence must go up by 1 for each request */2295 u16 seq = private->scarlett2_seq++;2296 2297 req->cmd = cpu_to_le32(cmd);2298 req->size = cpu_to_le16(req_size);2299 req->seq = cpu_to_le16(seq);2300 req->error = 0;2301 req->pad = 0;2302}2303 2304static int scarlett2_usb_tx(struct usb_device *dev, int interface,2305 void *buf, u16 size)2306{2307 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),2308 SCARLETT2_USB_CMD_REQ,2309 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,2310 0, interface, buf, size);2311}2312 2313static int scarlett2_usb_rx(struct usb_device *dev, int interface,2314 u32 usb_req, void *buf, u16 size)2315{2316 return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),2317 usb_req,2318 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,2319 0, interface, buf, size);2320}2321 2322/* Send a proprietary format request to the Scarlett interface */2323static int scarlett2_usb(2324 struct usb_mixer_interface *mixer, u32 cmd,2325 void *req_data, u16 req_size, void *resp_data, u16 resp_size)2326{2327 struct scarlett2_data *private = mixer->private_data;2328 struct usb_device *dev = mixer->chip->dev;2329 struct scarlett2_usb_packet *req, *resp = NULL;2330 size_t req_buf_size = struct_size(req, data, req_size);2331 size_t resp_buf_size = struct_size(resp, data, resp_size);2332 int err;2333 2334 req = kmalloc(req_buf_size, GFP_KERNEL);2335 if (!req) {2336 err = -ENOMEM;2337 goto error;2338 }2339 2340 resp = kmalloc(resp_buf_size, GFP_KERNEL);2341 if (!resp) {2342 err = -ENOMEM;2343 goto error;2344 }2345 2346 mutex_lock(&private->usb_mutex);2347 2348 /* build request message and send it */2349 2350 scarlett2_fill_request_header(private, req, cmd, req_size);2351 2352 if (req_size)2353 memcpy(req->data, req_data, req_size);2354 2355 err = scarlett2_usb_tx(dev, private->bInterfaceNumber,2356 req, req_buf_size);2357 2358 if (err != req_buf_size) {2359 usb_audio_err(2360 mixer->chip,2361 "%s USB request result cmd %x was %d\n",2362 private->series_name, cmd, err);2363 err = -EINVAL;2364 goto unlock;2365 }2366 2367 if (!wait_for_completion_timeout(&private->cmd_done,2368 msecs_to_jiffies(1000))) {2369 usb_audio_err(2370 mixer->chip,2371 "%s USB request timed out, cmd %x\n",2372 private->series_name, cmd);2373 2374 err = -ETIMEDOUT;2375 goto unlock;2376 }2377 2378 /* send a second message to get the response */2379 2380 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,2381 SCARLETT2_USB_CMD_RESP,2382 resp, resp_buf_size);2383 2384 /* validate the response */2385 2386 if (err != resp_buf_size) {2387 2388 /* ESHUTDOWN and EPROTO are valid responses to a2389 * reboot request2390 */2391 if (cmd == SCARLETT2_USB_REBOOT &&2392 (err == -ESHUTDOWN || err == -EPROTO)) {2393 err = 0;2394 goto unlock;2395 }2396 2397 usb_audio_err(2398 mixer->chip,2399 "%s USB response result cmd %x was %d expected %zu\n",2400 private->series_name, cmd, err, resp_buf_size);2401 err = -EINVAL;2402 goto unlock;2403 }2404 2405 /* cmd/seq/size should match except when initialising2406 * seq sent = 1, response = 02407 */2408 if (resp->cmd != req->cmd ||2409 (resp->seq != req->seq &&2410 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||2411 resp_size != le16_to_cpu(resp->size) ||2412 resp->error ||2413 resp->pad) {2414 usb_audio_err(2415 mixer->chip,2416 "%s USB invalid response; "2417 "cmd tx/rx %d/%d seq %d/%d size %d/%d "2418 "error %d pad %d\n",2419 private->series_name,2420 le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),2421 le16_to_cpu(req->seq), le16_to_cpu(resp->seq),2422 resp_size, le16_to_cpu(resp->size),2423 le32_to_cpu(resp->error),2424 le32_to_cpu(resp->pad));2425 err = -EINVAL;2426 goto unlock;2427 }2428 2429 if (resp_data && resp_size > 0)2430 memcpy(resp_data, resp->data, resp_size);2431 2432unlock:2433 mutex_unlock(&private->usb_mutex);2434error:2435 kfree(req);2436 kfree(resp);2437 return err;2438}2439 2440/* Send a USB message to get data; result placed in *buf */2441static int scarlett2_usb_get(2442 struct usb_mixer_interface *mixer,2443 int offset, void *buf, int size)2444{2445 struct {2446 __le32 offset;2447 __le32 size;2448 } __packed req;2449 2450 req.offset = cpu_to_le32(offset);2451 req.size = cpu_to_le32(size);2452 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,2453 &req, sizeof(req), buf, size);2454}2455 2456/* Return true if the given configuration item is present in the2457 * configuration set used by this device.2458 */2459static int scarlett2_has_config_item(2460 struct scarlett2_data *private, int config_item_num)2461{2462 return !!private->config_set->items[config_item_num].offset;2463}2464 2465/* Send a USB message to get configuration parameters; result placed in *buf */2466static int scarlett2_usb_get_config(2467 struct usb_mixer_interface *mixer,2468 int config_item_num, int count, void *buf)2469{2470 struct scarlett2_data *private = mixer->private_data;2471 const struct scarlett2_config *config_item =2472 &private->config_set->items[config_item_num];2473 int size, err, i;2474 u8 *buf_8;2475 u8 value;2476 2477 /* Check that the configuration item is present in the2478 * configuration set used by this device2479 */2480 if (!config_item->offset)2481 return -EFAULT;2482 2483 /* Writes to the parameter buffer are always 1 byte */2484 size = config_item->size ? config_item->size : 8;2485 2486 /* For byte-sized parameters, retrieve directly into buf */2487 if (size >= 8) {2488 size = size / 8 * count;2489 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);2490 if (err < 0)2491 return err;2492 if (size == 2) {2493 u16 *buf_16 = buf;2494 2495 for (i = 0; i < count; i++, buf_16++)2496 *buf_16 = le16_to_cpu(*(__le16 *)buf_16);2497 } else if (size == 4) {2498 u32 *buf_32 = buf;2499 2500 for (i = 0; i < count; i++, buf_32++)2501 *buf_32 = le32_to_cpu(*(__le32 *)buf_32);2502 }2503 return 0;2504 }2505 2506 /* For bit-sized parameters, retrieve into value */2507 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);2508 if (err < 0)2509 return err;2510 2511 /* then unpack from value into buf[] */2512 buf_8 = buf;2513 for (i = 0; i < 8 && i < count; i++, value >>= 1)2514 *buf_8++ = value & 1;2515 2516 return 0;2517}2518 2519/* Send a SCARLETT2_USB_SET_DATA command.2520 * offset: location in the device's data space2521 * size: size in bytes of the value (1, 2, 4)2522 */2523static int scarlett2_usb_set_data(2524 struct usb_mixer_interface *mixer,2525 int offset, int size, int value)2526{2527 struct scarlett2_data *private = mixer->private_data;2528 struct {2529 __le32 offset;2530 __le32 size;2531 __le32 value;2532 } __packed req;2533 2534 req.offset = cpu_to_le32(offset);2535 req.size = cpu_to_le32(size);2536 req.value = cpu_to_le32(value);2537 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,2538 &req, sizeof(u32) * 2 + size, NULL, 0);2539}2540 2541/* Send a SCARLETT2_USB_SET_DATA command with multiple values.2542 * offset: location in the device's data space2543 * size: size in bytes of each value (1, 2, 4)2544 * count: number of values2545 */2546static int scarlett2_usb_set_data_buf(2547 struct usb_mixer_interface *mixer,2548 int offset, int size, int count, void *buf)2549{2550 struct scarlett2_data *private = mixer->private_data;2551 int bytes = size * count;2552 struct {2553 __le32 offset;2554 __le32 size;2555 u8 data[];2556 } __packed *req;2557 int err;2558 int buf_size = struct_size(req, data, bytes);2559 2560 req = kmalloc(buf_size, GFP_KERNEL);2561 if (!req)2562 return -ENOMEM;2563 2564 req->offset = cpu_to_le32(offset);2565 req->size = cpu_to_le32(bytes);2566 if (size == 1) {2567 memcpy(req->data, buf, count);2568 } else if (size == 2) {2569 u16 *buf_16 = buf;2570 int i;2571 2572 for (i = 0; i < count; i++)2573 ((__le16 *)req->data)[i] = cpu_to_le16(buf_16[i]);2574 } else {2575 u32 *buf_32 = buf;2576 int i;2577 2578 for (i = 0; i < count; i++)2579 ((__le32 *)req->data)[i] = cpu_to_le32(buf_32[i]);2580 }2581 2582 err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,2583 req, buf_size, NULL, 0);2584 2585 kfree(req);2586 return err;2587}2588 2589/* Send a SCARLETT2_USB_DATA_CMD command.2590 * Configuration changes require activation with this after they have2591 * been uploaded by a previous SCARLETT2_USB_SET_DATA.2592 * The value for activate needed is determined by the configuration2593 * item.2594 */2595static int scarlett2_usb_activate_config(2596 struct usb_mixer_interface *mixer, int activate)2597{2598 __le32 req;2599 2600 req = cpu_to_le32(activate);2601 return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,2602 &req, sizeof(req), NULL, 0);2603}2604 2605/* Send USB messages to set a SCARLETT2_CONFIG_* parameter */2606static int scarlett2_usb_set_config(2607 struct usb_mixer_interface *mixer,2608 int config_item_num, int index, int value)2609{2610 struct scarlett2_data *private = mixer->private_data;2611 const struct scarlett2_config_set *config_set = private->config_set;2612 const struct scarlett2_config *config_item =2613 &config_set->items[config_item_num];2614 int offset, size;2615 int err;2616 2617 /* Check that the configuration item is present in the2618 * configuration set used by this device2619 */2620 if (!config_item->offset)2621 return -EFAULT;2622 2623 /* Write via the parameter buffer? */2624 if (config_item->pbuf) {2625 if (!config_set->param_buf_addr)2626 return -EFAULT;2627 2628 /* Place index in param_buf_addr + 1 */2629 err = scarlett2_usb_set_data(2630 mixer, config_set->param_buf_addr + 1, 1, index);2631 if (err < 0)2632 return err;2633 2634 /* Place value in param_buf_addr */2635 err = scarlett2_usb_set_data(2636 mixer, config_set->param_buf_addr, 1, value);2637 if (err < 0)2638 return err;2639 2640 /* Activate the write through the parameter buffer */2641 return scarlett2_usb_activate_config(2642 mixer, config_item->activate);2643 }2644 2645 /* Direct writes (not via the parameter buffer) need NVRAM2646 * save and support bit-modification2647 */2648 2649 /* Cancel any pending NVRAM save */2650 cancel_delayed_work_sync(&private->work);2651 2652 /* Convert config_item->size in bits to size in bytes and2653 * calculate offset2654 */2655 if (config_item->size >= 8) {2656 size = config_item->size / 8;2657 offset = config_item->offset + index * size;2658 2659 /* If updating a bit, retrieve the old value, set/clear the2660 * bit as needed, and update value2661 */2662 } else {2663 u8 tmp;2664 2665 size = 1;2666 offset = config_item->offset;2667 2668 err = scarlett2_usb_get(mixer, offset, &tmp, 1);2669 if (err < 0)2670 return err;2671 2672 if (value)2673 tmp |= (1 << index);2674 else2675 tmp &= ~(1 << index);2676 2677 value = tmp;2678 }2679 2680 /* Write the new value */2681 err = scarlett2_usb_set_data(mixer, offset, size, value);2682 if (err < 0)2683 return err;2684 2685 /* Activate the change */2686 err = scarlett2_usb_activate_config(mixer, config_item->activate);2687 if (err < 0)2688 return err;2689 2690 /* Interfaces with parameter buffer writes don't need a2691 * separate save step2692 */2693 if (config_set->param_buf_addr)2694 return 0;2695 2696 /* Schedule the change to be written to NVRAM */2697 if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)2698 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));2699 2700 return 0;2701}2702 2703/* Send USB messages to set a SCARLETT2_CONFIG_* parameter with2704 * multiple values2705 */2706static int scarlett2_usb_set_config_buf(2707 struct usb_mixer_interface *mixer,2708 int config_item_num, int index, int count, void *buf)2709{2710 struct scarlett2_data *private = mixer->private_data;2711 const struct scarlett2_config_set *config_set = private->config_set;2712 const struct scarlett2_config *config_item =2713 &config_set->items[config_item_num];2714 int offset, size;2715 int err;2716 2717 /* Check that the configuration item is present in the2718 * configuration set used by this device2719 */2720 if (!config_item->offset)2721 return -EFAULT;2722 2723 /* Convert config_item->size in bits to size in bytes and2724 * calculate offset2725 */2726 if (config_item->size >= 8) {2727 size = config_item->size / 8;2728 offset = config_item->offset + index * size;2729 2730 /* Bit updates not supported */2731 } else {2732 return -EFAULT;2733 }2734 2735 /* Write the new values */2736 err = scarlett2_usb_set_data_buf(mixer, offset, size, count, buf);2737 if (err < 0)2738 return err;2739 2740 /* Activate the change */2741 return scarlett2_usb_activate_config(mixer, config_item->activate);2742}2743 2744/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */2745static void scarlett2_config_save(struct usb_mixer_interface *mixer)2746{2747 int err;2748 2749 err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE);2750 if (err < 0)2751 usb_audio_err(mixer->chip, "config save failed: %d\n", err);2752}2753 2754/* Delayed work to save config */2755static void scarlett2_config_save_work(struct work_struct *work)2756{2757 struct scarlett2_data *private =2758 container_of(work, struct scarlett2_data, work.work);2759 2760 scarlett2_config_save(private->mixer);2761}2762 2763/* Send a USB message to get sync status; result placed in *sync */2764static int scarlett2_usb_get_sync_status(2765 struct usb_mixer_interface *mixer,2766 u8 *sync)2767{2768 __le32 data;2769 int err;2770 2771 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,2772 NULL, 0, &data, sizeof(data));2773 if (err < 0)2774 return err;2775 2776 *sync = !!data;2777 return 0;2778}2779 2780/* Return true if the device has a mixer that we can control */2781static int scarlett2_has_mixer(struct scarlett2_data *private)2782{2783 return !!private->info->mux_assignment[0][0].count;2784}2785 2786/* Map from mixer value to (db + 80) * 22787 * (reverse of scarlett2_mixer_values[])2788 */2789static int scarlett2_mixer_value_to_db(int value)2790{2791 int i;2792 2793 for (i = 0; i < SCARLETT2_MIXER_VALUE_COUNT; i++)2794 if (scarlett2_mixer_values[i] >= value)2795 return i;2796 return SCARLETT2_MIXER_MAX_VALUE;2797}2798 2799/* Send a USB message to get the volumes for all inputs of one mix2800 * and put the values into private->mix[]2801 */2802static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,2803 int mix_num)2804{2805 struct scarlett2_data *private = mixer->private_data;2806 2807 int num_mixer_in = private->num_mix_in;2808 int err, i, j;2809 2810 struct {2811 __le16 mix_num;2812 __le16 count;2813 } __packed req;2814 2815 __le16 data[SCARLETT2_INPUT_MIX_MAX];2816 2817 req.mix_num = cpu_to_le16(mix_num);2818 req.count = cpu_to_le16(num_mixer_in);2819 2820 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,2821 &req, sizeof(req),2822 data, num_mixer_in * sizeof(u16));2823 if (err < 0)2824 return err;2825 2826 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)2827 private->mix[j] = scarlett2_mixer_value_to_db(2828 le16_to_cpu(data[i]));2829 2830 return 0;2831}2832 2833/* Send a USB message to set the volumes for all inputs of one mix2834 * (values obtained from private->mix[])2835 */2836static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,2837 int mix_num)2838{2839 struct scarlett2_data *private = mixer->private_data;2840 2841 struct {2842 __le16 mix_num;2843 __le16 data[SCARLETT2_INPUT_MIX_MAX];2844 } __packed req;2845 2846 int i, j;2847 int num_mixer_in = private->num_mix_in;2848 2849 req.mix_num = cpu_to_le16(mix_num);2850 2851 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)2852 req.data[i] = cpu_to_le16(2853 scarlett2_mixer_values[private->mix[j]]2854 );2855 2856 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,2857 &req, (num_mixer_in + 1) * sizeof(u16),2858 NULL, 0);2859}2860 2861/* Convert a port number index (per info->port_count) to a hardware ID */2862static u32 scarlett2_mux_src_num_to_id(2863 const int port_count[][SCARLETT2_PORT_DIRNS], int num)2864{2865 int port_type;2866 2867 for (port_type = 0;2868 port_type < SCARLETT2_PORT_TYPE_COUNT;2869 port_type++) {2870 if (num < port_count[port_type][SCARLETT2_PORT_IN])2871 return scarlett2_ports[port_type].id | num;2872 num -= port_count[port_type][SCARLETT2_PORT_IN];2873 }2874 2875 /* Oops */2876 return 0;2877}2878 2879/* Convert a hardware ID to a port number index */2880static u32 scarlett2_mux_id_to_num(2881 const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id)2882{2883 int port_type;2884 int port_num = 0;2885 2886 for (port_type = 0;2887 port_type < SCARLETT2_PORT_TYPE_COUNT;2888 port_type++) {2889 int base = scarlett2_ports[port_type].id;2890 int count = port_count[port_type][direction];2891 2892 if (id >= base && id < base + count)2893 return port_num + id - base;2894 port_num += count;2895 }2896 2897 /* Oops */2898 return -1;2899}2900 2901/* Convert one mux entry from the interface and load into private->mux[] */2902static void scarlett2_usb_populate_mux(struct scarlett2_data *private,2903 u32 mux_entry)2904{2905 const struct scarlett2_device_info *info = private->info;2906 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;2907 2908 int dst_idx, src_idx;2909 2910 dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT,2911 mux_entry & 0xFFF);2912 if (dst_idx < 0)2913 return;2914 2915 if (dst_idx >= private->num_mux_dsts) {2916 usb_audio_err(private->mixer->chip,2917 "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d",2918 mux_entry, dst_idx, private->num_mux_dsts);2919 return;2920 }2921 2922 src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN,2923 mux_entry >> 12);2924 if (src_idx < 0)2925 return;2926 2927 if (src_idx >= private->num_mux_srcs) {2928 usb_audio_err(private->mixer->chip,2929 "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d",2930 mux_entry, src_idx, private->num_mux_srcs);2931 return;2932 }2933 2934 private->mux[dst_idx] = src_idx;2935}2936 2937/* Update the meter level map2938 *2939 * The meter level data from the interface (SCARLETT2_USB_GET_METER2940 * request) is returned in mux_assignment order, but to avoid exposing2941 * that to userspace, scarlett2_meter_ctl_get() rearranges the data2942 * into scarlett2_ports order using the meter_level_map[] array which2943 * is set up by this function.2944 *2945 * In addition, the meter level data values returned from the2946 * interface are invalid for destinations where:2947 *2948 * - the source is "Off"; therefore we set those values to zero (map2949 * value of 255)2950 *2951 * - the source is assigned to a previous (with respect to the2952 * mux_assignment order) destination; therefore we set those values2953 * to the value previously reported for that source2954 */2955static void scarlett2_update_meter_level_map(struct scarlett2_data *private)2956{2957 const struct scarlett2_device_info *info = private->info;2958 const struct scarlett2_meter_entry *entry;2959 2960 /* sources already assigned to a destination2961 * value is 255 for None, otherwise the value of i2962 * (index into array returned by2963 * scarlett2_usb_get_meter_levels())2964 */2965 u8 seen_src[SCARLETT2_MAX_SRCS] = { 1 };2966 u8 seen_src_value[SCARLETT2_MAX_SRCS] = { 255 };2967 2968 /* index in meter_map[] order */2969 int i = 0;2970 2971 /* go through the meter_map[] entries */2972 for (entry = info->meter_map;2973 entry->count;2974 entry++) {2975 2976 /* fill in each meter_level_map[] entry */2977 int j, mux_idx;2978 2979 for (j = 0, mux_idx = entry->start;2980 j < entry->count;2981 i++, j++, mux_idx++) {2982 2983 /* convert mux_idx using line_out_unmap[] */2984 int map_mux_idx = (2985 info->line_out_remap_enable &&2986 mux_idx < private->num_line_out2987 ) ? info->line_out_unmap[mux_idx]2988 : mux_idx;2989 2990 /* check which source is connected, and if2991 * that source is already connected elsewhere,2992 * use that existing connection's destination2993 * for this meter entry instead2994 */2995 int mux_src = private->mux[mux_idx];2996 2997 if (!seen_src[mux_src]) {2998 seen_src[mux_src] = 1;2999 seen_src_value[mux_src] = i;3000 }3001 private->meter_level_map[map_mux_idx] =3002 seen_src_value[mux_src];3003 }3004 }3005}3006 3007/* Send USB message to get mux inputs and then populate private->mux[] */3008static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)3009{3010 struct scarlett2_data *private = mixer->private_data;3011 int count = private->num_mux_dsts;3012 int err, i;3013 3014 struct {3015 __le16 num;3016 __le16 count;3017 } __packed req;3018 3019 __le32 data[SCARLETT2_MUX_MAX];3020 3021 private->mux_updated = 0;3022 3023 req.num = 0;3024 req.count = cpu_to_le16(count);3025 3026 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,3027 &req, sizeof(req),3028 data, count * sizeof(u32));3029 if (err < 0)3030 return err;3031 3032 for (i = 0; i < count; i++)3033 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));3034 3035 scarlett2_update_meter_level_map(private);3036 3037 return 0;3038}3039 3040/* Send USB messages to set mux inputs */3041static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)3042{3043 struct scarlett2_data *private = mixer->private_data;3044 const struct scarlett2_device_info *info = private->info;3045 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;3046 int table;3047 3048 struct {3049 __le16 pad;3050 __le16 num;3051 __le32 data[SCARLETT2_MUX_MAX];3052 } __packed req;3053 3054 req.pad = 0;3055 3056 /* set mux settings for each rate */3057 for (table = 0; table < SCARLETT2_MUX_TABLES; table++) {3058 const struct scarlett2_mux_entry *entry;3059 3060 /* i counts over the output array */3061 int i = 0, err;3062 3063 req.num = cpu_to_le16(table);3064 3065 /* loop through each entry */3066 for (entry = info->mux_assignment[table];3067 entry->count;3068 entry++) {3069 int j;3070 int port_type = entry->port_type;3071 int port_idx = entry->start;3072 int mux_idx = scarlett2_get_port_start_num(port_count,3073 SCARLETT2_PORT_OUT, port_type) + port_idx;3074 int dst_id = scarlett2_ports[port_type].id + port_idx;3075 3076 /* Empty slots */3077 if (!dst_id) {3078 for (j = 0; j < entry->count; j++)3079 req.data[i++] = 0;3080 continue;3081 }3082 3083 /* Non-empty mux slots use the lower 12 bits3084 * for the destination and next 12 bits for3085 * the source3086 */3087 for (j = 0; j < entry->count; j++) {3088 int src_id = scarlett2_mux_src_num_to_id(3089 port_count, private->mux[mux_idx++]);3090 req.data[i++] = cpu_to_le32(dst_id |3091 src_id << 12);3092 dst_id++;3093 }3094 }3095 3096 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,3097 &req, (i + 1) * sizeof(u32),3098 NULL, 0);3099 if (err < 0)3100 return err;3101 }3102 3103 scarlett2_update_meter_level_map(private);3104 3105 return 0;3106}3107 3108/* Send USB message to get meter levels */3109static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,3110 u16 num_meters, u16 *levels)3111{3112 struct {3113 __le16 pad;3114 __le16 num_meters;3115 __le32 magic;3116 } __packed req;3117 __le32 resp[SCARLETT2_MAX_METERS];3118 int i, err;3119 3120 req.pad = 0;3121 req.num_meters = cpu_to_le16(num_meters);3122 req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);3123 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,3124 &req, sizeof(req), resp, num_meters * sizeof(u32));3125 if (err < 0)3126 return err;3127 3128 /* copy, convert to u16 */3129 for (i = 0; i < num_meters; i++)3130 levels[i] = le32_to_cpu(resp[i]);3131 3132 return 0;3133}3134 3135/* For config items with mute=1, xor bits 0 & 1 together to get the3136 * current/next state. This won't have any effect on values which are3137 * only ever 0/1.3138 */3139static uint8_t scarlett2_decode_muteable(uint8_t v)3140{3141 return (v ^ (v >> 1)) & 1;3142}3143 3144/*** Control Functions ***/3145 3146/* helper function to create a new control */3147static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,3148 const struct snd_kcontrol_new *ncontrol,3149 int index, int channels, const char *name,3150 struct snd_kcontrol **kctl_return)3151{3152 struct snd_kcontrol *kctl;3153 struct usb_mixer_elem_info *elem;3154 int err;3155 3156 elem = kzalloc(sizeof(*elem), GFP_KERNEL);3157 if (!elem)3158 return -ENOMEM;3159 3160 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code3161 * ignores them for resume and other operations.3162 * Also, the head.id field is set to 0, as we don't use this field.3163 */3164 elem->head.mixer = mixer;3165 elem->control = index;3166 elem->head.id = 0;3167 elem->channels = channels;3168 elem->val_type = USB_MIXER_BESPOKEN;3169 3170 kctl = snd_ctl_new1(ncontrol, elem);3171 if (!kctl) {3172 kfree(elem);3173 return -ENOMEM;3174 }3175 kctl->private_free = snd_usb_mixer_elem_free;3176 3177 strscpy(kctl->id.name, name, sizeof(kctl->id.name));3178 3179 err = snd_usb_mixer_add_control(&elem->head, kctl);3180 if (err < 0)3181 return err;3182 3183 if (kctl_return)3184 *kctl_return = kctl;3185 3186 return 0;3187}3188 3189/*** Firmware Version Control ***/3190 3191static int scarlett2_firmware_version_ctl_get(3192 struct snd_kcontrol *kctl,3193 struct snd_ctl_elem_value *ucontrol)3194{3195 struct usb_mixer_elem_info *elem = kctl->private_data;3196 struct scarlett2_data *private = elem->head.mixer->private_data;3197 3198 ucontrol->value.integer.value[0] = private->firmware_version;3199 3200 return 0;3201}3202 3203static int scarlett2_firmware_version_ctl_info(3204 struct snd_kcontrol *kctl,3205 struct snd_ctl_elem_info *uinfo)3206{3207 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;3208 uinfo->count = 1;3209 3210 return 0;3211}3212 3213static const struct snd_kcontrol_new scarlett2_firmware_version_ctl = {3214 .iface = SNDRV_CTL_ELEM_IFACE_CARD,3215 .access = SNDRV_CTL_ELEM_ACCESS_READ,3216 .name = "",3217 .info = scarlett2_firmware_version_ctl_info,3218 .get = scarlett2_firmware_version_ctl_get3219};3220 3221static int scarlett2_add_firmware_version_ctl(3222 struct usb_mixer_interface *mixer)3223{3224 return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl,3225 0, 0, "Firmware Version", NULL);3226}3227 3228/*** Minimum Firmware Version Control ***/3229 3230static int scarlett2_min_firmware_version_ctl_get(3231 struct snd_kcontrol *kctl,3232 struct snd_ctl_elem_value *ucontrol)3233{3234 struct usb_mixer_elem_info *elem = kctl->private_data;3235 struct scarlett2_data *private = elem->head.mixer->private_data;3236 3237 ucontrol->value.integer.value[0] = private->info->min_firmware_version;3238 3239 return 0;3240}3241 3242static int scarlett2_min_firmware_version_ctl_info(3243 struct snd_kcontrol *kctl,3244 struct snd_ctl_elem_info *uinfo)3245{3246 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;3247 uinfo->count = 1;3248 3249 return 0;3250}3251 3252static const struct snd_kcontrol_new scarlett2_min_firmware_version_ctl = {3253 .iface = SNDRV_CTL_ELEM_IFACE_CARD,3254 .access = SNDRV_CTL_ELEM_ACCESS_READ,3255 .name = "",3256 .info = scarlett2_min_firmware_version_ctl_info,3257 .get = scarlett2_min_firmware_version_ctl_get3258};3259 3260static int scarlett2_add_min_firmware_version_ctl(3261 struct usb_mixer_interface *mixer)3262{3263 return scarlett2_add_new_ctl(mixer, &scarlett2_min_firmware_version_ctl,3264 0, 0, "Minimum Firmware Version", NULL);3265}3266 3267/*** Sync Control ***/3268 3269/* Update sync control after receiving notification that the status3270 * has changed3271 */3272static int scarlett2_update_sync(struct usb_mixer_interface *mixer)3273{3274 struct scarlett2_data *private = mixer->private_data;3275 3276 private->sync_updated = 0;3277 return scarlett2_usb_get_sync_status(mixer, &private->sync);3278}3279 3280static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl,3281 struct snd_ctl_elem_info *uinfo)3282{3283 static const char *texts[2] = {3284 "Unlocked", "Locked"3285 };3286 return snd_ctl_enum_info(uinfo, 1, 2, texts);3287}3288 3289static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl,3290 struct snd_ctl_elem_value *ucontrol)3291{3292 struct usb_mixer_elem_info *elem = kctl->private_data;3293 struct usb_mixer_interface *mixer = elem->head.mixer;3294 struct scarlett2_data *private = mixer->private_data;3295 int err = 0;3296 3297 mutex_lock(&private->data_mutex);3298 3299 if (private->hwdep_in_use) {3300 err = -EBUSY;3301 goto unlock;3302 }3303 3304 if (private->sync_updated) {3305 err = scarlett2_update_sync(mixer);3306 if (err < 0)3307 goto unlock;3308 }3309 ucontrol->value.enumerated.item[0] = private->sync;3310 3311unlock:3312 mutex_unlock(&private->data_mutex);3313 return err;3314}3315 3316static const struct snd_kcontrol_new scarlett2_sync_ctl = {3317 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,3318 .access = SNDRV_CTL_ELEM_ACCESS_READ,3319 .name = "",3320 .info = scarlett2_sync_ctl_info,3321 .get = scarlett2_sync_ctl_get3322};3323 3324static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)3325{3326 struct scarlett2_data *private = mixer->private_data;3327 3328 /* devices without a mixer also don't support reporting sync status */3329 if (!scarlett2_has_mixer(private))3330 return 0;3331 3332 return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,3333 0, 1, "Sync Status", &private->sync_ctl);3334}3335 3336/*** Autogain Switch and Status Controls ***/3337 3338/* Forward declarations as phantom power and autogain can disable each other */3339static int scarlett2_check_input_phantom_updated(struct usb_mixer_interface *);3340static int scarlett2_phantom_is_switching(struct scarlett2_data *, int);3341 3342/* Set the access mode of a control to read-only (val = 0) or3343 * read-write (val = 1).3344 */3345static void scarlett2_set_ctl_access(struct snd_kcontrol *kctl, int val)3346{3347 if (val)3348 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;3349 else3350 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;3351}3352 3353/* Check if autogain is running on any input */3354static int scarlett2_autogain_is_running(struct scarlett2_data *private)3355{3356 int i;3357 3358 /* autogain_status[] is 0 if autogain is running */3359 for (i = 0; i < private->info->gain_input_count; i++)3360 if (!private->autogain_status[i])3361 return 1;3362 3363 return 0;3364}3365 3366static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)3367{3368 struct scarlett2_data *private = mixer->private_data;3369 const struct scarlett2_device_info *info = private->info;3370 int err, i;3371 u8 raw_autogain_status[SCARLETT2_INPUT_GAIN_MAX];3372 s8 ag_target_values[SCARLETT2_AG_TARGET_COUNT];3373 3374 private->autogain_updated = 0;3375 3376 if (!info->gain_input_count)3377 return 0;3378 3379 err = scarlett2_usb_get_config(3380 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH,3381 info->gain_input_count, private->autogain_switch);3382 if (err < 0)3383 return err;3384 err = scarlett2_usb_get_config(3385 mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS,3386 info->gain_input_count, raw_autogain_status);3387 if (err < 0)3388 return err;3389 3390 /* Translate autogain_switch and raw_autogain_status into3391 * autogain_status.3392 *3393 * When autogain_switch[] is set, the status is the first3394 * element in scarlett2_autogain_status_texts[] (Running). The3395 * subsequent elements correspond to the status value from the3396 * device (raw_autogain_status[]) + 1. The last element is3397 * "Invalid", in case the device reports a status outside the3398 * range of scarlett2_autogain_status_texts[].3399 */3400 for (i = 0; i < info->gain_input_count; i++)3401 if (private->autogain_switch[i])3402 private->autogain_status[i] = 0;3403 else if (raw_autogain_status[i] <3404 private->num_autogain_status_texts - 1)3405 private->autogain_status[i] =3406 raw_autogain_status[i] + 1;3407 else3408 private->autogain_status[i] =3409 private->num_autogain_status_texts - 1;3410 3411 3412 for (int i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)3413 if (scarlett2_has_config_item(private,3414 scarlett2_ag_target_configs[i])) {3415 err = scarlett2_usb_get_config(3416 mixer, scarlett2_ag_target_configs[i],3417 1, &ag_target_values[i]);3418 if (err < 0)3419 return err;3420 }3421 3422 /* convert from negative dBFS as used by the device */3423 for (int i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)3424 private->ag_targets[i] = -ag_target_values[i];3425 3426 return 0;3427}3428 3429/* Update access mode for controls affected by autogain */3430static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)3431{3432 struct scarlett2_data *private = mixer->private_data;3433 const struct scarlett2_device_info *info = private->info;3434 int val = !scarlett2_autogain_is_running(private);3435 int i;3436 3437 if (scarlett2_has_config_item(private,3438 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))3439 scarlett2_set_ctl_access(private->input_select_ctl, val);3440 if (scarlett2_has_config_item(private,3441 SCARLETT2_CONFIG_INPUT_LINK_SWITCH))3442 for (i = 0; i < info->gain_input_count / 2; i++)3443 scarlett2_set_ctl_access(private->input_link_ctls[i],3444 val);3445 for (i = 0; i < info->gain_input_count; i++)3446 scarlett2_set_ctl_access(private->input_gain_ctls[i], val);3447 for (i = 0; i < info->safe_input_count; i++)3448 scarlett2_set_ctl_access(private->safe_ctls[i], val);3449 for (i = 0; i < info->level_input_count; i++)3450 scarlett2_set_ctl_access(private->level_ctls[i], val);3451 for (i = 0; i < info->air_input_count; i++)3452 scarlett2_set_ctl_access(private->air_ctls[i], val);3453 for (i = 0; i < info->mute_input_count; i++)3454 scarlett2_set_ctl_access(private->input_mute_ctls[i], val);3455 for (i = 0; i < info->phantom_count; i++)3456 scarlett2_set_ctl_access(private->phantom_ctls[i], val);3457 for (i = 0; i < info->dsp_input_count; i++)3458 scarlett2_set_ctl_access(private->dsp_ctls[i], val);3459 3460 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)3461 if (scarlett2_has_config_item(private,3462 scarlett2_ag_target_configs[i]))3463 scarlett2_set_ctl_access(3464 private->ag_target_ctls[i], val);3465}3466 3467/* Notify of access mode change for all controls read-only while3468 * autogain runs.3469 */3470static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer)3471{3472 struct snd_card *card = mixer->chip->card;3473 struct scarlett2_data *private = mixer->private_data;3474 const struct scarlett2_device_info *info = private->info;3475 int i;3476 3477 if (scarlett2_has_config_item(private,3478 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))3479 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3480 &private->input_select_ctl->id);3481 if (scarlett2_has_config_item(private,3482 SCARLETT2_CONFIG_INPUT_LINK_SWITCH))3483 for (i = 0; i < info->gain_input_count / 2; i++)3484 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3485 &private->input_link_ctls[i]->id);3486 for (i = 0; i < info->gain_input_count; i++)3487 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3488 &private->input_gain_ctls[i]->id);3489 for (i = 0; i < info->safe_input_count; i++)3490 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3491 &private->safe_ctls[i]->id);3492 for (i = 0; i < info->level_input_count; i++)3493 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3494 &private->level_ctls[i]->id);3495 for (i = 0; i < info->air_input_count; i++)3496 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3497 &private->air_ctls[i]->id);3498 for (i = 0; i < info->dsp_input_count; i++)3499 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3500 &private->dsp_ctls[i]->id);3501 for (i = 0; i < info->mute_input_count; i++)3502 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3503 &private->input_mute_ctls[i]->id);3504 for (i = 0; i < info->phantom_count; i++)3505 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3506 &private->phantom_ctls[i]->id);3507 3508 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)3509 if (scarlett2_has_config_item(private,3510 scarlett2_ag_target_configs[i]))3511 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,3512 &private->ag_target_ctls[i]->id);3513}3514 3515/* Call scarlett2_update_autogain() and3516 * scarlett2_autogain_update_access() if autogain_updated is set.3517 */3518static int scarlett2_check_autogain_updated(3519 struct usb_mixer_interface *mixer)3520{3521 struct scarlett2_data *private = mixer->private_data;3522 int err;3523 3524 if (!private->autogain_updated)3525 return 0;3526 3527 err = scarlett2_update_autogain(mixer);3528 if (err < 0)3529 return err;3530 3531 scarlett2_autogain_update_access(mixer);3532 3533 return 0;3534}3535 3536/* If autogain_updated is set when a *_ctl_put() function for a3537 * control that is meant to be read-only while autogain is running,3538 * update the autogain status and access mode of affected controls.3539 * Return -EPERM if autogain is running.3540 */3541static int scarlett2_check_put_during_autogain(3542 struct usb_mixer_interface *mixer)3543{3544 int err = scarlett2_check_autogain_updated(mixer);3545 3546 if (err < 0)3547 return err;3548 3549 if (scarlett2_autogain_is_running(mixer->private_data))3550 return -EPERM;3551 3552 return 0;3553}3554 3555static int scarlett2_autogain_switch_ctl_info(3556 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)3557{3558 struct usb_mixer_elem_info *elem = kctl->private_data;3559 struct usb_mixer_interface *mixer = elem->head.mixer;3560 struct scarlett2_data *private = mixer->private_data;3561 int err;3562 3563 mutex_lock(&private->data_mutex);3564 3565 err = scarlett2_check_input_phantom_updated(mixer);3566 if (err < 0)3567 goto unlock;3568 3569 err = snd_ctl_boolean_mono_info(kctl, uinfo);3570 3571unlock:3572 mutex_unlock(&private->data_mutex);3573 return err;3574}3575 3576static int scarlett2_autogain_switch_ctl_get(3577 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3578{3579 struct usb_mixer_elem_info *elem = kctl->private_data;3580 struct usb_mixer_interface *mixer = elem->head.mixer;3581 struct scarlett2_data *private = mixer->private_data;3582 int err;3583 3584 mutex_lock(&private->data_mutex);3585 3586 if (private->hwdep_in_use) {3587 err = -EBUSY;3588 goto unlock;3589 }3590 3591 err = scarlett2_check_autogain_updated(mixer);3592 if (err < 0)3593 goto unlock;3594 3595 ucontrol->value.enumerated.item[0] =3596 private->autogain_switch[elem->control];3597 3598unlock:3599 mutex_unlock(&private->data_mutex);3600 return err;3601}3602 3603static int scarlett2_autogain_status_ctl_get(3604 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3605{3606 struct usb_mixer_elem_info *elem = kctl->private_data;3607 struct usb_mixer_interface *mixer = elem->head.mixer;3608 struct scarlett2_data *private = mixer->private_data;3609 int err;3610 3611 mutex_lock(&private->data_mutex);3612 3613 if (private->hwdep_in_use) {3614 err = -EBUSY;3615 goto unlock;3616 }3617 3618 err = scarlett2_check_autogain_updated(mixer);3619 if (err < 0)3620 goto unlock;3621 3622 ucontrol->value.enumerated.item[0] =3623 private->autogain_status[elem->control];3624 3625unlock:3626 mutex_unlock(&private->data_mutex);3627 return err;3628}3629 3630static int scarlett2_autogain_switch_ctl_put(3631 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3632{3633 struct usb_mixer_elem_info *elem = kctl->private_data;3634 struct usb_mixer_interface *mixer = elem->head.mixer;3635 struct scarlett2_data *private = mixer->private_data;3636 3637 int index = elem->control;3638 int oval, val, err;3639 3640 mutex_lock(&private->data_mutex);3641 3642 if (private->hwdep_in_use) {3643 err = -EBUSY;3644 goto unlock;3645 }3646 3647 err = scarlett2_check_input_phantom_updated(mixer);3648 if (err < 0)3649 goto unlock;3650 3651 if (scarlett2_phantom_is_switching(private, index)) {3652 err = -EPERM;3653 goto unlock;3654 }3655 3656 oval = private->autogain_switch[index];3657 val = !!ucontrol->value.integer.value[0];3658 3659 if (oval == val)3660 goto unlock;3661 3662 private->autogain_switch[index] = val;3663 3664 /* Send switch change to the device */3665 err = scarlett2_usb_set_config(3666 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val);3667 if (err == 0)3668 err = 1;3669 3670 scarlett2_autogain_update_access(mixer);3671 scarlett2_autogain_notify_access(mixer);3672 3673unlock:3674 mutex_unlock(&private->data_mutex);3675 return err;3676}3677 3678static int scarlett2_autogain_status_ctl_info(3679 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)3680{3681 struct usb_mixer_elem_info *elem = kctl->private_data;3682 struct scarlett2_data *private = elem->head.mixer->private_data;3683 3684 return snd_ctl_enum_info(3685 uinfo, 1,3686 private->num_autogain_status_texts,3687 private->config_set->autogain_status_texts);3688}3689 3690static const struct snd_kcontrol_new scarlett2_autogain_switch_ctl = {3691 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,3692 .name = "",3693 .info = scarlett2_autogain_switch_ctl_info,3694 .get = scarlett2_autogain_switch_ctl_get,3695 .put = scarlett2_autogain_switch_ctl_put3696};3697 3698static const struct snd_kcontrol_new scarlett2_autogain_status_ctl = {3699 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,3700 .access = SNDRV_CTL_ELEM_ACCESS_READ,3701 .name = "",3702 .info = scarlett2_autogain_status_ctl_info,3703 .get = scarlett2_autogain_status_ctl_get,3704};3705 3706/*** Autogain Target Controls ***/3707 3708static int scarlett2_ag_target_ctl_info(3709 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)3710{3711 struct usb_mixer_elem_info *elem = kctl->private_data;3712 struct usb_mixer_interface *mixer = elem->head.mixer;3713 struct scarlett2_data *private = mixer->private_data;3714 int err;3715 3716 mutex_lock(&private->data_mutex);3717 3718 if (private->hwdep_in_use) {3719 err = -EBUSY;3720 goto unlock;3721 }3722 3723 err = scarlett2_check_autogain_updated(mixer);3724 if (err < 0)3725 goto unlock;3726 3727 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;3728 uinfo->count = 1;3729 uinfo->value.integer.min = SCARLETT2_AG_TARGET_MIN;3730 uinfo->value.integer.max = 0;3731 uinfo->value.integer.step = 1;3732 3733unlock:3734 mutex_unlock(&private->data_mutex);3735 return err;3736}3737 3738static int scarlett2_ag_target_ctl_get(3739 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3740{3741 struct usb_mixer_elem_info *elem = kctl->private_data;3742 struct usb_mixer_interface *mixer = elem->head.mixer;3743 struct scarlett2_data *private = mixer->private_data;3744 int err = 0;3745 3746 mutex_lock(&private->data_mutex);3747 3748 if (private->hwdep_in_use) {3749 err = -EBUSY;3750 goto unlock;3751 }3752 3753 if (private->autogain_updated) {3754 err = scarlett2_update_autogain(mixer);3755 if (err < 0)3756 goto unlock;3757 }3758 3759 ucontrol->value.integer.value[0] = private->ag_targets[elem->control];3760 3761unlock:3762 mutex_unlock(&private->data_mutex);3763 return err;3764}3765 3766static int scarlett2_ag_target_ctl_put(3767 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3768{3769 struct usb_mixer_elem_info *elem = kctl->private_data;3770 struct usb_mixer_interface *mixer = elem->head.mixer;3771 struct scarlett2_data *private = mixer->private_data;3772 3773 int index = elem->control;3774 int oval, val, err;3775 3776 mutex_lock(&private->data_mutex);3777 3778 if (private->hwdep_in_use) {3779 err = -EBUSY;3780 goto unlock;3781 }3782 3783 err = scarlett2_check_put_during_autogain(mixer);3784 if (err < 0)3785 goto unlock;3786 3787 oval = private->ag_targets[index];3788 val = clamp(ucontrol->value.integer.value[0],3789 (long)SCARLETT2_AG_TARGET_MIN, 0L);3790 3791 if (oval == val)3792 goto unlock;3793 3794 private->ag_targets[index] = val;3795 3796 /* Send new value to the device */3797 err = scarlett2_usb_set_config(3798 mixer, scarlett2_ag_target_configs[index], 1, -val);3799 if (err == 0)3800 err = 1;3801 3802unlock:3803 mutex_unlock(&private->data_mutex);3804 return err;3805}3806 3807static const DECLARE_TLV_DB_MINMAX(3808 db_scale_ag_target, SCARLETT2_AG_TARGET_MIN * 100, 03809);3810 3811static const struct snd_kcontrol_new scarlett2_ag_target_ctl = {3812 .iface = SNDRV_CTL_ELEM_IFACE_CARD,3813 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |3814 SNDRV_CTL_ELEM_ACCESS_TLV_READ,3815 .name = "",3816 .info = scarlett2_ag_target_ctl_info,3817 .get = scarlett2_ag_target_ctl_get,3818 .put = scarlett2_ag_target_ctl_put,3819 .tlv = { .p = db_scale_ag_target }3820};3821 3822/*** Input Select Control ***/3823 3824static int scarlett2_update_input_select(struct usb_mixer_interface *mixer)3825{3826 struct scarlett2_data *private = mixer->private_data;3827 const struct scarlett2_device_info *info = private->info;3828 int link_count = info->gain_input_count / 2;3829 int err;3830 3831 private->input_select_updated = 0;3832 3833 if (!scarlett2_has_config_item(private,3834 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH) ||3835 !link_count)3836 return 0;3837 3838 err = scarlett2_usb_get_config(3839 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,3840 1, &private->input_select_switch);3841 if (err < 0)3842 return err;3843 3844 err = scarlett2_usb_get_config(3845 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH,3846 link_count, private->input_link_switch);3847 if (err < 0)3848 return err;3849 3850 /* simplified because no model yet has link_count > 1 */3851 if (private->input_link_switch[0])3852 private->input_select_switch = 0;3853 3854 return 0;3855}3856 3857static int scarlett2_input_select_ctl_get(3858 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3859{3860 struct usb_mixer_elem_info *elem = kctl->private_data;3861 struct usb_mixer_interface *mixer = elem->head.mixer;3862 struct scarlett2_data *private = mixer->private_data;3863 int err = 0;3864 3865 mutex_lock(&private->data_mutex);3866 3867 if (private->hwdep_in_use) {3868 err = -EBUSY;3869 goto unlock;3870 }3871 3872 if (private->input_select_updated) {3873 err = scarlett2_update_input_select(mixer);3874 if (err < 0)3875 goto unlock;3876 }3877 ucontrol->value.enumerated.item[0] = private->input_select_switch;3878 3879unlock:3880 mutex_unlock(&private->data_mutex);3881 return err;3882}3883 3884static int scarlett2_input_select_ctl_put(3885 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)3886{3887 struct usb_mixer_elem_info *elem = kctl->private_data;3888 struct usb_mixer_interface *mixer = elem->head.mixer;3889 struct scarlett2_data *private = mixer->private_data;3890 3891 int oval, val, err;3892 int max_val = private->input_link_switch[0] ? 0 : 1;3893 3894 mutex_lock(&private->data_mutex);3895 3896 if (private->hwdep_in_use) {3897 err = -EBUSY;3898 goto unlock;3899 }3900 3901 err = scarlett2_check_put_during_autogain(mixer);3902 if (err < 0)3903 goto unlock;3904 3905 oval = private->input_select_switch;3906 val = ucontrol->value.integer.value[0];3907 3908 if (val < 0)3909 val = 0;3910 else if (val > max_val)3911 val = max_val;3912 3913 if (oval == val)3914 goto unlock;3915 3916 private->input_select_switch = val;3917 3918 /* Send switch change to the device if inputs not linked */3919 if (!private->input_link_switch[0])3920 err = scarlett2_usb_set_config(3921 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,3922 1, val);3923 if (err == 0)3924 err = 1;3925 3926unlock:3927 mutex_unlock(&private->data_mutex);3928 return err;3929}3930 3931static int scarlett2_input_select_ctl_info(3932 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)3933{3934 struct usb_mixer_elem_info *elem = kctl->private_data;3935 struct usb_mixer_interface *mixer = elem->head.mixer;3936 struct scarlett2_data *private = mixer->private_data;3937 3938 int inputs = private->info->gain_input_count;3939 int i, j;3940 int err;3941 char **values = kcalloc(inputs, sizeof(char *), GFP_KERNEL);3942 3943 if (!values)3944 return -ENOMEM;3945 3946 mutex_lock(&private->data_mutex);3947 3948 if (private->hwdep_in_use) {3949 err = -EBUSY;3950 goto unlock;3951 }3952 3953 err = scarlett2_check_autogain_updated(mixer);3954 if (err < 0)3955 goto unlock;3956 3957 /* Loop through each input3958 * Linked inputs have one value for the pair3959 */3960 for (i = 0, j = 0; i < inputs; i++) {3961 if (private->input_link_switch[i / 2]) {3962 values[j++] = kasprintf(3963 GFP_KERNEL, "Input %d-%d", i + 1, i + 2);3964 i++;3965 } else {3966 values[j++] = kasprintf(3967 GFP_KERNEL, "Input %d", i + 1);3968 }3969 }3970 3971 err = snd_ctl_enum_info(uinfo, 1, j,3972 (const char * const *)values);3973 3974unlock:3975 mutex_unlock(&private->data_mutex);3976 3977 for (i = 0; i < inputs; i++)3978 kfree(values[i]);3979 kfree(values);3980 3981 return err;3982}3983 3984static const struct snd_kcontrol_new scarlett2_input_select_ctl = {3985 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,3986 .name = "",3987 .info = scarlett2_input_select_ctl_info,3988 .get = scarlett2_input_select_ctl_get,3989 .put = scarlett2_input_select_ctl_put,3990};3991 3992/*** Input Link Switch Controls ***/3993 3994/* snd_ctl_boolean_mono_info() with autogain-updated check3995 * (for controls that are read-only while autogain is running)3996 */3997static int scarlett2_autogain_disables_ctl_info(struct snd_kcontrol *kctl,3998 struct snd_ctl_elem_info *uinfo)3999{4000 struct usb_mixer_elem_info *elem = kctl->private_data;4001 struct usb_mixer_interface *mixer = elem->head.mixer;4002 struct scarlett2_data *private = mixer->private_data;4003 int err;4004 4005 mutex_lock(&private->data_mutex);4006 4007 if (private->hwdep_in_use) {4008 err = -EBUSY;4009 goto unlock;4010 }4011 4012 err = scarlett2_check_autogain_updated(mixer);4013 if (err < 0)4014 goto unlock;4015 4016 err = snd_ctl_boolean_mono_info(kctl, uinfo);4017 4018unlock:4019 mutex_unlock(&private->data_mutex);4020 return err;4021}4022 4023static int scarlett2_input_link_ctl_get(4024 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)4025{4026 struct usb_mixer_elem_info *elem = kctl->private_data;4027 struct usb_mixer_interface *mixer = elem->head.mixer;4028 struct scarlett2_data *private = mixer->private_data;4029 int err = 0;4030 4031 mutex_lock(&private->data_mutex);4032 4033 if (private->hwdep_in_use) {4034 err = -EBUSY;4035 goto unlock;4036 }4037 4038 if (private->input_select_updated) {4039 err = scarlett2_update_input_select(mixer);4040 if (err < 0)4041 goto unlock;4042 }4043 ucontrol->value.enumerated.item[0] =4044 private->input_link_switch[elem->control];4045 4046unlock:4047 mutex_unlock(&private->data_mutex);4048 return err;4049}4050 4051static int scarlett2_input_link_ctl_put(4052 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)4053{4054 struct usb_mixer_elem_info *elem = kctl->private_data;4055 struct usb_mixer_interface *mixer = elem->head.mixer;4056 struct scarlett2_data *private = mixer->private_data;4057 4058 int index = elem->control;4059 int oval, val, err;4060 4061 mutex_lock(&private->data_mutex);4062 4063 if (private->hwdep_in_use) {4064 err = -EBUSY;4065 goto unlock;4066 }4067 4068 err = scarlett2_check_put_during_autogain(mixer);4069 if (err < 0)4070 goto unlock;4071 4072 oval = private->input_link_switch[index];4073 val = !!ucontrol->value.integer.value[0];4074 4075 if (oval == val)4076 goto unlock;4077 4078 private->input_link_switch[index] = val;4079 4080 /* Notify of change in input select options available */4081 snd_ctl_notify(mixer->chip->card,4082 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,4083 &private->input_select_ctl->id);4084 private->input_select_updated = 1;4085 4086 /* Send switch change to the device4087 * Link for channels 1-2 is at index 14088 * No device yet has more than 2 channels linked4089 */4090 err = scarlett2_usb_set_config(4091 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index + 1, val);4092 if (err == 0)4093 err = 1;4094 4095unlock:4096 mutex_unlock(&private->data_mutex);4097 return err;4098}4099 4100static const struct snd_kcontrol_new scarlett2_input_link_ctl = {4101 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4102 .name = "",4103 .info = scarlett2_autogain_disables_ctl_info,4104 .get = scarlett2_input_link_ctl_get,4105 .put = scarlett2_input_link_ctl_put4106};4107 4108/*** Input Gain Controls ***/4109 4110static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer)4111{4112 struct scarlett2_data *private = mixer->private_data;4113 const struct scarlett2_device_info *info = private->info;4114 4115 private->input_gain_updated = 0;4116 4117 if (!info->gain_input_count)4118 return 0;4119 4120 return scarlett2_usb_get_config(4121 mixer, SCARLETT2_CONFIG_INPUT_GAIN,4122 info->gain_input_count, private->gain);4123}4124 4125static int scarlett2_input_gain_ctl_info(struct snd_kcontrol *kctl,4126 struct snd_ctl_elem_info *uinfo)4127{4128 struct usb_mixer_elem_info *elem = kctl->private_data;4129 struct usb_mixer_interface *mixer = elem->head.mixer;4130 struct scarlett2_data *private = mixer->private_data;4131 int err;4132 4133 mutex_lock(&private->data_mutex);4134 4135 if (private->hwdep_in_use) {4136 err = -EBUSY;4137 goto unlock;4138 }4139 4140 err = scarlett2_check_autogain_updated(mixer);4141 if (err < 0)4142 goto unlock;4143 4144 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;4145 uinfo->count = elem->channels;4146 uinfo->value.integer.min = 0;4147 uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;4148 uinfo->value.integer.step = 1;4149 4150unlock:4151 mutex_unlock(&private->data_mutex);4152 return err;4153}4154 4155static int scarlett2_input_gain_ctl_get(struct snd_kcontrol *kctl,4156 struct snd_ctl_elem_value *ucontrol)4157{4158 struct usb_mixer_elem_info *elem = kctl->private_data;4159 struct usb_mixer_interface *mixer = elem->head.mixer;4160 struct scarlett2_data *private = mixer->private_data;4161 int err = 0;4162 4163 mutex_lock(&private->data_mutex);4164 4165 if (private->hwdep_in_use) {4166 err = -EBUSY;4167 goto unlock;4168 }4169 4170 if (private->input_gain_updated) {4171 err = scarlett2_update_input_gain(mixer);4172 if (err < 0)4173 goto unlock;4174 }4175 ucontrol->value.integer.value[0] =4176 private->gain[elem->control];4177 4178unlock:4179 mutex_unlock(&private->data_mutex);4180 return err;4181}4182 4183static int scarlett2_input_gain_ctl_put(struct snd_kcontrol *kctl,4184 struct snd_ctl_elem_value *ucontrol)4185{4186 struct usb_mixer_elem_info *elem = kctl->private_data;4187 struct usb_mixer_interface *mixer = elem->head.mixer;4188 struct scarlett2_data *private = mixer->private_data;4189 4190 int index = elem->control;4191 int oval, val, err;4192 4193 mutex_lock(&private->data_mutex);4194 4195 if (private->hwdep_in_use) {4196 err = -EBUSY;4197 goto unlock;4198 }4199 4200 err = scarlett2_check_put_during_autogain(mixer);4201 if (err < 0)4202 goto unlock;4203 4204 oval = private->gain[index];4205 val = ucontrol->value.integer.value[0];4206 4207 if (oval == val)4208 goto unlock;4209 4210 private->gain[index] = val;4211 4212 /* Send gain change to the device */4213 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_INPUT_GAIN,4214 index, val);4215 if (err == 0)4216 err = 1;4217 4218unlock:4219 mutex_unlock(&private->data_mutex);4220 return err;4221}4222 4223static const struct snd_kcontrol_new scarlett2_input_gain_ctl = {4224 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4225 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |4226 SNDRV_CTL_ELEM_ACCESS_TLV_READ,4227 .name = "",4228 .info = scarlett2_input_gain_ctl_info,4229 .get = scarlett2_input_gain_ctl_get,4230 .put = scarlett2_input_gain_ctl_put,4231 .private_value = 0, /* max value */4232};4233 4234/*** Safe Controls ***/4235 4236static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer)4237{4238 struct scarlett2_data *private = mixer->private_data;4239 const struct scarlett2_device_info *info = private->info;4240 4241 private->input_safe_updated = 0;4242 4243 if (!info->safe_input_count)4244 return 0;4245 4246 return scarlett2_usb_get_config(4247 mixer, SCARLETT2_CONFIG_SAFE_SWITCH,4248 info->safe_input_count, private->safe_switch);4249}4250 4251static int scarlett2_safe_ctl_get(struct snd_kcontrol *kctl,4252 struct snd_ctl_elem_value *ucontrol)4253{4254 struct usb_mixer_elem_info *elem = kctl->private_data;4255 struct usb_mixer_interface *mixer = elem->head.mixer;4256 struct scarlett2_data *private = mixer->private_data;4257 int err = 0;4258 4259 mutex_lock(&private->data_mutex);4260 4261 if (private->hwdep_in_use) {4262 err = -EBUSY;4263 goto unlock;4264 }4265 4266 if (private->input_safe_updated) {4267 err = scarlett2_update_input_safe(mixer);4268 if (err < 0)4269 goto unlock;4270 }4271 ucontrol->value.integer.value[0] =4272 private->safe_switch[elem->control];4273 4274unlock:4275 mutex_unlock(&private->data_mutex);4276 return err;4277}4278 4279static int scarlett2_safe_ctl_put(struct snd_kcontrol *kctl,4280 struct snd_ctl_elem_value *ucontrol)4281{4282 struct usb_mixer_elem_info *elem = kctl->private_data;4283 struct usb_mixer_interface *mixer = elem->head.mixer;4284 struct scarlett2_data *private = mixer->private_data;4285 4286 int index = elem->control;4287 int oval, val, err;4288 4289 mutex_lock(&private->data_mutex);4290 4291 if (private->hwdep_in_use) {4292 err = -EBUSY;4293 goto unlock;4294 }4295 4296 err = scarlett2_check_put_during_autogain(mixer);4297 if (err < 0)4298 goto unlock;4299 4300 oval = private->safe_switch[index];4301 val = !!ucontrol->value.integer.value[0];4302 4303 if (oval == val)4304 goto unlock;4305 4306 private->safe_switch[index] = val;4307 4308 /* Send switch change to the device */4309 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SAFE_SWITCH,4310 index, val);4311 if (err == 0)4312 err = 1;4313 4314unlock:4315 mutex_unlock(&private->data_mutex);4316 return err;4317}4318 4319static const struct snd_kcontrol_new scarlett2_safe_ctl = {4320 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4321 .name = "",4322 .info = scarlett2_autogain_disables_ctl_info,4323 .get = scarlett2_safe_ctl_get,4324 .put = scarlett2_safe_ctl_put,4325};4326 4327/*** PCM Input Control ***/4328 4329static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer)4330{4331 struct scarlett2_data *private = mixer->private_data;4332 int err;4333 4334 private->pcm_input_switch_updated = 0;4335 4336 err = scarlett2_usb_get_config(4337 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,4338 1, &private->pcm_input_switch);4339 if (err < 0)4340 return err;4341 4342 return 0;4343}4344 4345static int scarlett2_pcm_input_switch_ctl_get(4346 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)4347{4348 struct usb_mixer_elem_info *elem = kctl->private_data;4349 struct usb_mixer_interface *mixer = elem->head.mixer;4350 struct scarlett2_data *private = elem->head.mixer->private_data;4351 int err = 0;4352 4353 mutex_lock(&private->data_mutex);4354 4355 if (private->pcm_input_switch_updated) {4356 err = scarlett2_update_pcm_input_switch(mixer);4357 if (err < 0)4358 goto unlock;4359 }4360 ucontrol->value.enumerated.item[0] = private->pcm_input_switch;4361 4362unlock:4363 mutex_unlock(&private->data_mutex);4364 return err;4365}4366 4367static int scarlett2_pcm_input_switch_ctl_put(4368 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)4369{4370 struct usb_mixer_elem_info *elem = kctl->private_data;4371 struct usb_mixer_interface *mixer = elem->head.mixer;4372 struct scarlett2_data *private = mixer->private_data;4373 4374 int oval, val, err = 0;4375 4376 mutex_lock(&private->data_mutex);4377 4378 if (private->hwdep_in_use) {4379 err = -EBUSY;4380 goto unlock;4381 }4382 4383 oval = private->pcm_input_switch;4384 val = !!ucontrol->value.integer.value[0];4385 4386 if (oval == val)4387 goto unlock;4388 4389 private->pcm_input_switch = val;4390 4391 /* Send switch change to the device */4392 err = scarlett2_usb_set_config(4393 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,4394 0, val);4395 if (err == 0)4396 err = 1;4397 4398unlock:4399 mutex_unlock(&private->data_mutex);4400 return err;4401}4402 4403static int scarlett2_pcm_input_switch_ctl_info(4404 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)4405{4406 static const char *const values[2] = {4407 "Direct", "Mixer"4408 };4409 4410 return snd_ctl_enum_info(4411 uinfo, 1, 2, values);4412}4413 4414static const struct snd_kcontrol_new scarlett2_pcm_input_switch_ctl = {4415 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4416 .name = "",4417 .info = scarlett2_pcm_input_switch_ctl_info,4418 .get = scarlett2_pcm_input_switch_ctl_get,4419 .put = scarlett2_pcm_input_switch_ctl_put4420};4421 4422/*** Analogue Line Out Volume Controls ***/4423 4424/* Update hardware volume controls after receiving notification that4425 * they have changed4426 */4427static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)4428{4429 struct scarlett2_data *private = mixer->private_data;4430 s16 vol;4431 int err, i;4432 4433 private->vol_updated = 0;4434 4435 if (scarlett2_has_config_item(private,4436 SCARLETT2_CONFIG_MASTER_VOLUME)) {4437 err = scarlett2_usb_get_config(4438 mixer, SCARLETT2_CONFIG_MASTER_VOLUME,4439 1, &vol);4440 if (err < 0)4441 return err;4442 4443 private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,4444 0, SCARLETT2_VOLUME_BIAS);4445 4446 if (scarlett2_has_config_item(private,4447 SCARLETT2_CONFIG_SW_HW_SWITCH))4448 for (i = 0; i < private->num_line_out; i++)4449 if (private->vol_sw_hw_switch[i])4450 private->vol[i] = private->master_vol;4451 }4452 4453 if (scarlett2_has_config_item(private,4454 SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {4455 err = scarlett2_usb_get_config(4456 mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME,4457 1, &vol);4458 if (err < 0)4459 return err;4460 4461 private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,4462 0, SCARLETT2_VOLUME_BIAS);4463 }4464 4465 return 0;4466}4467 4468static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,4469 struct snd_ctl_elem_info *uinfo)4470{4471 struct usb_mixer_elem_info *elem = kctl->private_data;4472 4473 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;4474 uinfo->count = elem->channels;4475 uinfo->value.integer.min = 0;4476 uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;4477 uinfo->value.integer.step = 1;4478 return 0;4479}4480 4481static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,4482 struct snd_ctl_elem_value *ucontrol)4483{4484 struct usb_mixer_elem_info *elem = kctl->private_data;4485 struct usb_mixer_interface *mixer = elem->head.mixer;4486 struct scarlett2_data *private = mixer->private_data;4487 int err = 0;4488 4489 mutex_lock(&private->data_mutex);4490 4491 if (private->hwdep_in_use) {4492 err = -EBUSY;4493 goto unlock;4494 }4495 4496 if (private->vol_updated) {4497 err = scarlett2_update_volumes(mixer);4498 if (err < 0)4499 goto unlock;4500 }4501 ucontrol->value.integer.value[0] = private->master_vol;4502 4503unlock:4504 mutex_unlock(&private->data_mutex);4505 return err;4506}4507 4508static int scarlett2_headphone_volume_ctl_get(4509 struct snd_kcontrol *kctl,4510 struct snd_ctl_elem_value *ucontrol)4511{4512 struct usb_mixer_elem_info *elem = kctl->private_data;4513 struct usb_mixer_interface *mixer = elem->head.mixer;4514 struct scarlett2_data *private = mixer->private_data;4515 int err = 0;4516 4517 mutex_lock(&private->data_mutex);4518 4519 if (private->hwdep_in_use) {4520 err = -EBUSY;4521 goto unlock;4522 }4523 4524 if (private->vol_updated) {4525 err = scarlett2_update_volumes(mixer);4526 if (err < 0)4527 goto unlock;4528 }4529 ucontrol->value.integer.value[0] = private->headphone_vol;4530 4531unlock:4532 mutex_unlock(&private->data_mutex);4533 return err;4534}4535 4536static int line_out_remap(struct scarlett2_data *private, int index)4537{4538 const struct scarlett2_device_info *info = private->info;4539 4540 if (!info->line_out_remap_enable)4541 return index;4542 4543 if (index >= private->num_line_out)4544 return index;4545 4546 return info->line_out_remap[index];4547}4548 4549static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,4550 struct snd_ctl_elem_value *ucontrol)4551{4552 struct usb_mixer_elem_info *elem = kctl->private_data;4553 struct usb_mixer_interface *mixer = elem->head.mixer;4554 struct scarlett2_data *private = mixer->private_data;4555 int index = line_out_remap(private, elem->control);4556 int err = 0;4557 4558 mutex_lock(&private->data_mutex);4559 4560 if (private->hwdep_in_use) {4561 err = -EBUSY;4562 goto unlock;4563 }4564 4565 if (private->vol_updated) {4566 err = scarlett2_update_volumes(mixer);4567 if (err < 0)4568 goto unlock;4569 }4570 ucontrol->value.integer.value[0] = private->vol[index];4571 4572unlock:4573 mutex_unlock(&private->data_mutex);4574 return err;4575}4576 4577static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,4578 struct snd_ctl_elem_value *ucontrol)4579{4580 struct usb_mixer_elem_info *elem = kctl->private_data;4581 struct usb_mixer_interface *mixer = elem->head.mixer;4582 struct scarlett2_data *private = mixer->private_data;4583 int index = line_out_remap(private, elem->control);4584 int oval, val, err = 0;4585 4586 mutex_lock(&private->data_mutex);4587 4588 if (private->hwdep_in_use) {4589 err = -EBUSY;4590 goto unlock;4591 }4592 4593 oval = private->vol[index];4594 val = ucontrol->value.integer.value[0];4595 4596 if (oval == val)4597 goto unlock;4598 4599 private->vol[index] = val;4600 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,4601 index, val - SCARLETT2_VOLUME_BIAS);4602 if (err == 0)4603 err = 1;4604 4605unlock:4606 mutex_unlock(&private->data_mutex);4607 return err;4608}4609 4610static const DECLARE_TLV_DB_MINMAX(4611 db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 04612);4613 4614static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {4615 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4616 .access = SNDRV_CTL_ELEM_ACCESS_READ |4617 SNDRV_CTL_ELEM_ACCESS_TLV_READ,4618 .name = "",4619 .info = scarlett2_volume_ctl_info,4620 .get = scarlett2_master_volume_ctl_get,4621 .private_value = 0, /* max value */4622 .tlv = { .p = db_scale_scarlett2_volume }4623};4624 4625static const struct snd_kcontrol_new scarlett2_headphone_volume_ctl = {4626 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4627 .access = SNDRV_CTL_ELEM_ACCESS_READ |4628 SNDRV_CTL_ELEM_ACCESS_TLV_READ,4629 .name = "",4630 .info = scarlett2_volume_ctl_info,4631 .get = scarlett2_headphone_volume_ctl_get,4632 .private_value = 0, /* max value */4633 .tlv = { .p = db_scale_scarlett2_volume }4634};4635 4636static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {4637 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4638 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |4639 SNDRV_CTL_ELEM_ACCESS_TLV_READ,4640 .name = "",4641 .info = scarlett2_volume_ctl_info,4642 .get = scarlett2_volume_ctl_get,4643 .put = scarlett2_volume_ctl_put,4644 .private_value = 0, /* max value */4645 .tlv = { .p = db_scale_scarlett2_volume }4646};4647 4648/*** Mute Switch Controls ***/4649 4650static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)4651{4652 struct scarlett2_data *private = mixer->private_data;4653 int err, i;4654 u8 mute;4655 4656 private->dim_mute_updated = 0;4657 4658 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))4659 return 0;4660 4661 err = scarlett2_usb_get_config(4662 mixer, SCARLETT2_CONFIG_DIM_MUTE,4663 SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);4664 if (err < 0)4665 return err;4666 4667 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)4668 private->dim_mute[i] = !!private->dim_mute[i];4669 4670 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];4671 4672 for (i = 0; i < private->num_line_out; i++)4673 if (private->vol_sw_hw_switch[i])4674 private->mute_switch[i] = mute;4675 4676 return 0;4677}4678 4679static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl,4680 struct snd_ctl_elem_value *ucontrol)4681{4682 struct usb_mixer_elem_info *elem = kctl->private_data;4683 struct usb_mixer_interface *mixer = elem->head.mixer;4684 struct scarlett2_data *private = mixer->private_data;4685 int index = line_out_remap(private, elem->control);4686 int err = 0;4687 4688 mutex_lock(&private->data_mutex);4689 4690 if (private->hwdep_in_use) {4691 err = -EBUSY;4692 goto unlock;4693 }4694 4695 if (private->dim_mute_updated) {4696 err = scarlett2_update_dim_mute(mixer);4697 if (err < 0)4698 goto unlock;4699 }4700 ucontrol->value.integer.value[0] = private->mute_switch[index];4701 4702unlock:4703 mutex_unlock(&private->data_mutex);4704 return err;4705}4706 4707static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl,4708 struct snd_ctl_elem_value *ucontrol)4709{4710 struct usb_mixer_elem_info *elem = kctl->private_data;4711 struct usb_mixer_interface *mixer = elem->head.mixer;4712 struct scarlett2_data *private = mixer->private_data;4713 int index = line_out_remap(private, elem->control);4714 int oval, val, err = 0;4715 4716 mutex_lock(&private->data_mutex);4717 4718 if (private->hwdep_in_use) {4719 err = -EBUSY;4720 goto unlock;4721 }4722 4723 oval = private->mute_switch[index];4724 val = !!ucontrol->value.integer.value[0];4725 4726 if (oval == val)4727 goto unlock;4728 4729 private->mute_switch[index] = val;4730 4731 /* Send mute change to the device */4732 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,4733 index, val);4734 if (err == 0)4735 err = 1;4736 4737unlock:4738 mutex_unlock(&private->data_mutex);4739 return err;4740}4741 4742static const struct snd_kcontrol_new scarlett2_mute_ctl = {4743 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4744 .name = "",4745 .info = snd_ctl_boolean_mono_info,4746 .get = scarlett2_mute_ctl_get,4747 .put = scarlett2_mute_ctl_put,4748};4749 4750/*** HW/SW Volume Switch Controls ***/4751 4752static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)4753{4754 private->sw_hw_ctls[index]->vd[0].access &=4755 ~SNDRV_CTL_ELEM_ACCESS_WRITE;4756}4757 4758static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)4759{4760 private->sw_hw_ctls[index]->vd[0].access |=4761 SNDRV_CTL_ELEM_ACCESS_WRITE;4762}4763 4764static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,4765 struct snd_ctl_elem_info *uinfo)4766{4767 static const char *const values[2] = {4768 "SW", "HW"4769 };4770 4771 return snd_ctl_enum_info(uinfo, 1, 2, values);4772}4773 4774static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,4775 struct snd_ctl_elem_value *ucontrol)4776{4777 struct usb_mixer_elem_info *elem = kctl->private_data;4778 struct scarlett2_data *private = elem->head.mixer->private_data;4779 int index = line_out_remap(private, elem->control);4780 4781 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];4782 return 0;4783}4784 4785static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,4786 int index, int value)4787{4788 struct scarlett2_data *private = mixer->private_data;4789 struct snd_card *card = mixer->chip->card;4790 4791 /* Set/Clear write bits */4792 if (value) {4793 private->vol_ctls[index]->vd[0].access |=4794 SNDRV_CTL_ELEM_ACCESS_WRITE;4795 private->mute_ctls[index]->vd[0].access |=4796 SNDRV_CTL_ELEM_ACCESS_WRITE;4797 } else {4798 private->vol_ctls[index]->vd[0].access &=4799 ~SNDRV_CTL_ELEM_ACCESS_WRITE;4800 private->mute_ctls[index]->vd[0].access &=4801 ~SNDRV_CTL_ELEM_ACCESS_WRITE;4802 }4803 4804 /* Notify of write bit and possible value change */4805 snd_ctl_notify(card,4806 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,4807 &private->vol_ctls[index]->id);4808 snd_ctl_notify(card,4809 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,4810 &private->mute_ctls[index]->id);4811}4812 4813static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,4814 int ctl_index, int val)4815{4816 struct scarlett2_data *private = mixer->private_data;4817 int index = line_out_remap(private, ctl_index);4818 int err;4819 4820 private->vol_sw_hw_switch[index] = val;4821 4822 /* Change access mode to RO (hardware controlled volume)4823 * or RW (software controlled volume)4824 */4825 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);4826 4827 /* Reset volume/mute to master volume/mute */4828 private->vol[index] = private->master_vol;4829 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];4830 4831 /* Set SW volume to current HW volume */4832 err = scarlett2_usb_set_config(4833 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,4834 index, private->master_vol - SCARLETT2_VOLUME_BIAS);4835 if (err < 0)4836 return err;4837 4838 /* Set SW mute to current HW mute */4839 err = scarlett2_usb_set_config(4840 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,4841 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);4842 if (err < 0)4843 return err;4844 4845 /* Send SW/HW switch change to the device */4846 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,4847 index, val);4848}4849 4850static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,4851 struct snd_ctl_elem_value *ucontrol)4852{4853 struct usb_mixer_elem_info *elem = kctl->private_data;4854 struct usb_mixer_interface *mixer = elem->head.mixer;4855 struct scarlett2_data *private = mixer->private_data;4856 int ctl_index = elem->control;4857 int index = line_out_remap(private, ctl_index);4858 int oval, val, err = 0;4859 4860 mutex_lock(&private->data_mutex);4861 4862 if (private->hwdep_in_use) {4863 err = -EBUSY;4864 goto unlock;4865 }4866 4867 oval = private->vol_sw_hw_switch[index];4868 val = !!ucontrol->value.enumerated.item[0];4869 4870 if (oval == val)4871 goto unlock;4872 4873 err = scarlett2_sw_hw_change(mixer, ctl_index, val);4874 if (err == 0)4875 err = 1;4876 4877unlock:4878 mutex_unlock(&private->data_mutex);4879 return err;4880}4881 4882static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {4883 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,4884 .name = "",4885 .info = scarlett2_sw_hw_enum_ctl_info,4886 .get = scarlett2_sw_hw_enum_ctl_get,4887 .put = scarlett2_sw_hw_enum_ctl_put,4888};4889 4890/*** Line Level/Instrument Level Switch Controls ***/4891 4892static int scarlett2_update_input_level(struct usb_mixer_interface *mixer)4893{4894 struct scarlett2_data *private = mixer->private_data;4895 const struct scarlett2_device_info *info = private->info;4896 4897 private->input_level_updated = 0;4898 4899 if (!info->level_input_count)4900 return 0;4901 4902 return scarlett2_usb_get_config(4903 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,4904 info->level_input_count + info->level_input_first,4905 private->level_switch);4906}4907 4908static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,4909 struct snd_ctl_elem_info *uinfo)4910{4911 static const char *const values[2] = {4912 "Line", "Inst"4913 };4914 struct usb_mixer_elem_info *elem = kctl->private_data;4915 struct usb_mixer_interface *mixer = elem->head.mixer;4916 struct scarlett2_data *private = mixer->private_data;4917 int err;4918 4919 mutex_lock(&private->data_mutex);4920 4921 if (private->hwdep_in_use) {4922 err = -EBUSY;4923 goto unlock;4924 }4925 4926 err = scarlett2_check_autogain_updated(mixer);4927 if (err < 0)4928 goto unlock;4929 4930 err = snd_ctl_enum_info(uinfo, 1, 2, values);4931 4932unlock:4933 mutex_unlock(&private->data_mutex);4934 return err;4935}4936 4937static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,4938 struct snd_ctl_elem_value *ucontrol)4939{4940 struct usb_mixer_elem_info *elem = kctl->private_data;4941 struct usb_mixer_interface *mixer = elem->head.mixer;4942 struct scarlett2_data *private = mixer->private_data;4943 const struct scarlett2_device_info *info = private->info;4944 4945 int index = elem->control + info->level_input_first;4946 int err = 0;4947 4948 mutex_lock(&private->data_mutex);4949 4950 if (private->hwdep_in_use) {4951 err = -EBUSY;4952 goto unlock;4953 }4954 4955 if (private->input_level_updated) {4956 err = scarlett2_update_input_level(mixer);4957 if (err < 0)4958 goto unlock;4959 }4960 ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(4961 private->level_switch[index]);4962 4963unlock:4964 mutex_unlock(&private->data_mutex);4965 return err;4966}4967 4968static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,4969 struct snd_ctl_elem_value *ucontrol)4970{4971 struct usb_mixer_elem_info *elem = kctl->private_data;4972 struct usb_mixer_interface *mixer = elem->head.mixer;4973 struct scarlett2_data *private = mixer->private_data;4974 const struct scarlett2_device_info *info = private->info;4975 4976 int index = elem->control + info->level_input_first;4977 int oval, val, err;4978 4979 mutex_lock(&private->data_mutex);4980 4981 if (private->hwdep_in_use) {4982 err = -EBUSY;4983 goto unlock;4984 }4985 4986 err = scarlett2_check_put_during_autogain(mixer);4987 if (err < 0)4988 goto unlock;4989 4990 oval = private->level_switch[index];4991 val = !!ucontrol->value.enumerated.item[0];4992 4993 if (oval == val)4994 goto unlock;4995 4996 private->level_switch[index] = val;4997 4998 /* To set the Gen 4 muteable controls, bit 1 gets set instead */4999 if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)5000 val = (!val) | 0x02;5001 5002 /* Send switch change to the device */5003 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,5004 index, val);5005 if (err == 0)5006 err = 1;5007 5008unlock:5009 mutex_unlock(&private->data_mutex);5010 return err;5011}5012 5013static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {5014 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5015 .name = "",5016 .info = scarlett2_level_enum_ctl_info,5017 .get = scarlett2_level_enum_ctl_get,5018 .put = scarlett2_level_enum_ctl_put,5019};5020 5021/*** Pad Switch Controls ***/5022 5023static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer)5024{5025 struct scarlett2_data *private = mixer->private_data;5026 const struct scarlett2_device_info *info = private->info;5027 5028 private->input_pad_updated = 0;5029 5030 if (!info->pad_input_count)5031 return 0;5032 5033 return scarlett2_usb_get_config(5034 mixer, SCARLETT2_CONFIG_PAD_SWITCH,5035 info->pad_input_count, private->pad_switch);5036}5037 5038static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,5039 struct snd_ctl_elem_value *ucontrol)5040{5041 struct usb_mixer_elem_info *elem = kctl->private_data;5042 struct usb_mixer_interface *mixer = elem->head.mixer;5043 struct scarlett2_data *private = mixer->private_data;5044 int err = 0;5045 5046 mutex_lock(&private->data_mutex);5047 5048 if (private->hwdep_in_use) {5049 err = -EBUSY;5050 goto unlock;5051 }5052 5053 if (private->input_pad_updated) {5054 err = scarlett2_update_input_pad(mixer);5055 if (err < 0)5056 goto unlock;5057 }5058 ucontrol->value.integer.value[0] =5059 private->pad_switch[elem->control];5060 5061unlock:5062 mutex_unlock(&private->data_mutex);5063 return err;5064}5065 5066static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,5067 struct snd_ctl_elem_value *ucontrol)5068{5069 struct usb_mixer_elem_info *elem = kctl->private_data;5070 struct usb_mixer_interface *mixer = elem->head.mixer;5071 struct scarlett2_data *private = mixer->private_data;5072 5073 int index = elem->control;5074 int oval, val, err = 0;5075 5076 mutex_lock(&private->data_mutex);5077 5078 if (private->hwdep_in_use) {5079 err = -EBUSY;5080 goto unlock;5081 }5082 5083 oval = private->pad_switch[index];5084 val = !!ucontrol->value.integer.value[0];5085 5086 if (oval == val)5087 goto unlock;5088 5089 private->pad_switch[index] = val;5090 5091 /* Send switch change to the device */5092 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,5093 index, val);5094 if (err == 0)5095 err = 1;5096 5097unlock:5098 mutex_unlock(&private->data_mutex);5099 return err;5100}5101 5102static const struct snd_kcontrol_new scarlett2_pad_ctl = {5103 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5104 .name = "",5105 .info = snd_ctl_boolean_mono_info,5106 .get = scarlett2_pad_ctl_get,5107 .put = scarlett2_pad_ctl_put,5108};5109 5110/*** Air Switch Controls ***/5111 5112static int scarlett2_update_input_air(struct usb_mixer_interface *mixer)5113{5114 struct scarlett2_data *private = mixer->private_data;5115 const struct scarlett2_device_info *info = private->info;5116 5117 private->input_air_updated = 0;5118 5119 if (!info->air_input_count)5120 return 0;5121 5122 return scarlett2_usb_get_config(5123 mixer, SCARLETT2_CONFIG_AIR_SWITCH,5124 info->air_input_count, private->air_switch);5125}5126 5127static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl,5128 struct snd_ctl_elem_value *ucontrol)5129{5130 struct usb_mixer_elem_info *elem = kctl->private_data;5131 struct usb_mixer_interface *mixer = elem->head.mixer;5132 struct scarlett2_data *private = mixer->private_data;5133 int err = 0;5134 5135 mutex_lock(&private->data_mutex);5136 5137 if (private->hwdep_in_use) {5138 err = -EBUSY;5139 goto unlock;5140 }5141 5142 if (private->input_air_updated) {5143 err = scarlett2_update_input_air(mixer);5144 if (err < 0)5145 goto unlock;5146 }5147 ucontrol->value.integer.value[0] = private->air_switch[elem->control];5148 5149unlock:5150 mutex_unlock(&private->data_mutex);5151 return err;5152}5153 5154static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl,5155 struct snd_ctl_elem_value *ucontrol)5156{5157 struct usb_mixer_elem_info *elem = kctl->private_data;5158 struct usb_mixer_interface *mixer = elem->head.mixer;5159 struct scarlett2_data *private = mixer->private_data;5160 5161 int index = elem->control;5162 int oval, val, err;5163 5164 mutex_lock(&private->data_mutex);5165 5166 if (private->hwdep_in_use) {5167 err = -EBUSY;5168 goto unlock;5169 }5170 5171 err = scarlett2_check_put_during_autogain(mixer);5172 if (err < 0)5173 goto unlock;5174 5175 oval = private->air_switch[index];5176 val = ucontrol->value.integer.value[0];5177 5178 if (oval == val)5179 goto unlock;5180 5181 private->air_switch[index] = val;5182 5183 /* Send switch change to the device */5184 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,5185 index, val);5186 if (err == 0)5187 err = 1;5188 5189unlock:5190 mutex_unlock(&private->data_mutex);5191 return err;5192}5193 5194static int scarlett2_air_with_drive_ctl_info(5195 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)5196{5197 static const char *const values[3] = {5198 "Off", "Presence", "Presence + Drive"5199 };5200 struct usb_mixer_elem_info *elem = kctl->private_data;5201 struct usb_mixer_interface *mixer = elem->head.mixer;5202 struct scarlett2_data *private = mixer->private_data;5203 int err;5204 5205 mutex_lock(&private->data_mutex);5206 5207 if (private->hwdep_in_use) {5208 err = -EBUSY;5209 goto unlock;5210 }5211 5212 err = scarlett2_check_autogain_updated(mixer);5213 if (err < 0)5214 goto unlock;5215 5216 err = snd_ctl_enum_info(uinfo, 1, 3, values);5217 5218unlock:5219 mutex_unlock(&private->data_mutex);5220 return err;5221}5222 5223static const struct snd_kcontrol_new scarlett2_air_ctl[2] = {5224 {5225 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5226 .name = "",5227 .info = snd_ctl_boolean_mono_info,5228 .get = scarlett2_air_ctl_get,5229 .put = scarlett2_air_ctl_put,5230 },5231 {5232 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5233 .name = "",5234 .info = scarlett2_air_with_drive_ctl_info,5235 .get = scarlett2_air_ctl_get,5236 .put = scarlett2_air_ctl_put,5237 }5238};5239 5240/*** DSP Switch Control ***/5241 5242static int scarlett2_update_input_dsp(struct usb_mixer_interface *mixer)5243{5244 struct scarlett2_data *private = mixer->private_data;5245 const struct scarlett2_device_info *info = private->info;5246 5247 private->input_dsp_updated = 0;5248 5249 if (!info->dsp_input_count)5250 return 0;5251 5252 return scarlett2_usb_get_config(5253 mixer, SCARLETT2_CONFIG_DSP_SWITCH,5254 info->dsp_input_count, private->dsp_switch);5255}5256 5257static int scarlett2_dsp_ctl_get(struct snd_kcontrol *kctl,5258 struct snd_ctl_elem_value *ucontrol)5259{5260 struct usb_mixer_elem_info *elem = kctl->private_data;5261 struct usb_mixer_interface *mixer = elem->head.mixer;5262 struct scarlett2_data *private = mixer->private_data;5263 int err = 0;5264 5265 mutex_lock(&private->data_mutex);5266 5267 if (private->hwdep_in_use) {5268 err = -EBUSY;5269 goto unlock;5270 }5271 5272 if (private->input_dsp_updated) {5273 err = scarlett2_update_input_dsp(mixer);5274 if (err < 0)5275 goto unlock;5276 }5277 ucontrol->value.integer.value[0] = private->dsp_switch[elem->control];5278 5279unlock:5280 mutex_unlock(&private->data_mutex);5281 return err;5282}5283 5284static int scarlett2_dsp_ctl_put(struct snd_kcontrol *kctl,5285 struct snd_ctl_elem_value *ucontrol)5286{5287 struct usb_mixer_elem_info *elem = kctl->private_data;5288 struct usb_mixer_interface *mixer = elem->head.mixer;5289 struct scarlett2_data *private = mixer->private_data;5290 5291 int index = elem->control;5292 int oval, val, err;5293 5294 mutex_lock(&private->data_mutex);5295 5296 if (private->hwdep_in_use) {5297 err = -EBUSY;5298 goto unlock;5299 }5300 5301 err = scarlett2_check_put_during_autogain(mixer);5302 if (err < 0)5303 goto unlock;5304 5305 oval = private->dsp_switch[index];5306 val = ucontrol->value.integer.value[0];5307 5308 if (oval == val)5309 goto unlock;5310 5311 private->dsp_switch[index] = val;5312 5313 /* Send switch change to the device */5314 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DSP_SWITCH,5315 index, val);5316 if (err == 0)5317 err = 1;5318 5319unlock:5320 mutex_unlock(&private->data_mutex);5321 return err;5322}5323 5324static const struct snd_kcontrol_new scarlett2_dsp_ctl = {5325 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5326 .name = "",5327 .info = scarlett2_autogain_disables_ctl_info,5328 .get = scarlett2_dsp_ctl_get,5329 .put = scarlett2_dsp_ctl_put,5330};5331 5332/*** DSP Compressor Parameter Controls ***/5333 5334static int scarlett2_update_compressor_values(struct usb_mixer_interface *mixer)5335{5336 struct scarlett2_data *private = mixer->private_data;5337 const struct scarlett2_device_info *info = private->info;5338 int err, i, j;5339 5340 if (!info->dsp_input_count)5341 return 0;5342 5343 err = scarlett2_usb_get_config(5344 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS,5345 SCARLETT2_COMPRESSOR_PARAM_COUNT * info->dsp_input_count,5346 private->compressor_values);5347 5348 if (err < 0)5349 return err;5350 5351 for (i = 0; i < SCARLETT2_COMPRESSOR_PARAM_COUNT; i++) {5352 const struct compressor_param *param = &compressor_params[i];5353 5354 for (j = 0; j < info->dsp_input_count; j++) {5355 int idx = i + j * SCARLETT2_COMPRESSOR_PARAM_COUNT;5356 int val = private->compressor_values[idx];5357 5358 val >>= param->scale_bits;5359 val = clamp(val, param->min, param->max);5360 private->compressor_values[idx] = val;5361 }5362 }5363 5364 return 0;5365}5366 5367static int scarlett2_compressor_ctl_get(5368 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5369{5370 struct usb_mixer_elem_info *elem = kctl->private_data;5371 struct scarlett2_data *private = elem->head.mixer->private_data;5372 5373 ucontrol->value.integer.value[0] =5374 private->compressor_values[elem->control];5375 return 0;5376}5377 5378static int scarlett2_compressor_ctl_put(5379 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5380{5381 struct usb_mixer_elem_info *elem = kctl->private_data;5382 struct usb_mixer_interface *mixer = elem->head.mixer;5383 struct scarlett2_data *private = mixer->private_data;5384 5385 int index = elem->control;5386 int channel = index / SCARLETT2_COMPRESSOR_PARAM_COUNT;5387 int param_index = index % SCARLETT2_COMPRESSOR_PARAM_COUNT;5388 int oval, val, err;5389 s32 scaled_val;5390 5391 mutex_lock(&private->data_mutex);5392 5393 if (private->hwdep_in_use) {5394 err = -EBUSY;5395 goto unlock;5396 }5397 5398 err = scarlett2_check_put_during_autogain(mixer);5399 if (err < 0)5400 goto unlock;5401 5402 oval = private->compressor_values[index];5403 val = ucontrol->value.integer.value[0];5404 if (oval == val)5405 goto unlock;5406 5407 private->compressor_values[index] = val;5408 5409 const struct compressor_param *param = &compressor_params[param_index];5410 5411 scaled_val = val << param->scale_bits;5412 5413 /* Send change to the device */5414 5415 /* The channel needs to be put in the parameter buffer index5416 * field (param_buf_addr + 1); the value field isn't used in5417 * this case.5418 */5419 err = scarlett2_usb_set_data(5420 mixer, private->config_set->param_buf_addr + 1, 1, channel);5421 if (err < 0)5422 goto unlock;5423 5424 err = scarlett2_usb_set_config(5425 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS, index, scaled_val);5426 if (err < 0)5427 goto unlock;5428 5429 if (err == 0)5430 err = 1;5431 5432unlock:5433 mutex_unlock(&private->data_mutex);5434 return err;5435}5436 5437static int scarlett2_compressor_ctl_info(5438 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)5439{5440 struct usb_mixer_elem_info *elem = kctl->private_data;5441 int control = elem->control % SCARLETT2_COMPRESSOR_PARAM_COUNT;5442 5443 uinfo->type = compressor_params[control].type;5444 uinfo->count = 1;5445 uinfo->value.integer.min = compressor_params[control].min;5446 uinfo->value.integer.max = compressor_params[control].max;5447 uinfo->value.integer.step = 1;5448 return 0;5449}5450 5451static const struct snd_kcontrol_new scarlett2_compressor_ctl = {5452 .iface = SNDRV_CTL_ELEM_IFACE_CARD,5453 .name = "",5454 .info = scarlett2_compressor_ctl_info,5455 .get = scarlett2_compressor_ctl_get,5456 .put = scarlett2_compressor_ctl_put,5457};5458 5459/*** DSP Pre-Compressor and PEQ Filter Controls ***/5460 5461static int scarlett2_precomp_flt_switch_ctl_get(5462 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5463{5464 struct usb_mixer_elem_info *elem = kctl->private_data;5465 struct scarlett2_data *private = elem->head.mixer->private_data;5466 5467 ucontrol->value.integer.value[0] = private->precomp_flt_switch[elem->control];5468 5469 return 0;5470}5471 5472static int scarlett2_peq_flt_switch_ctl_get(5473 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5474{5475 struct usb_mixer_elem_info *elem = kctl->private_data;5476 struct scarlett2_data *private = elem->head.mixer->private_data;5477 5478 ucontrol->value.integer.value[0] =5479 private->peq_flt_switch[elem->control];5480 5481 return 0;5482}5483 5484static int scarlett2_precomp_flt_switch_ctl_put(5485 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5486{5487 struct usb_mixer_elem_info *elem = kctl->private_data;5488 struct usb_mixer_interface *mixer = elem->head.mixer;5489 struct scarlett2_data *private = mixer->private_data;5490 int oval, val, err = 0;5491 5492 mutex_lock(&private->data_mutex);5493 5494 if (private->hwdep_in_use) {5495 err = -EBUSY;5496 goto unlock;5497 }5498 5499 oval = private->precomp_flt_switch[elem->control];5500 val = ucontrol->value.integer.value[0];5501 5502 if (oval == val)5503 goto unlock;5504 5505 private->precomp_flt_switch[elem->control] = val;5506 5507 /* Send change to the device */5508 err = scarlett2_usb_set_config(5509 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,5510 elem->control, val);5511 if (err == 0)5512 err = 1;5513 5514unlock:5515 mutex_unlock(&private->data_mutex);5516 return err;5517}5518 5519static int scarlett2_peq_flt_switch_ctl_put(5520 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5521{5522 struct usb_mixer_elem_info *elem = kctl->private_data;5523 struct usb_mixer_interface *mixer = elem->head.mixer;5524 struct scarlett2_data *private = mixer->private_data;5525 int oval, val, err = 0;5526 5527 mutex_lock(&private->data_mutex);5528 5529 if (private->hwdep_in_use) {5530 err = -EBUSY;5531 goto unlock;5532 }5533 5534 oval = private->peq_flt_switch[elem->control];5535 val = ucontrol->value.integer.value[0];5536 5537 if (oval == val)5538 goto unlock;5539 5540 private->peq_flt_switch[elem->control] = val;5541 5542 /* Send change to the device */5543 err = scarlett2_usb_set_config(5544 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,5545 elem->control, val);5546 if (err == 0)5547 err = 1;5548 5549unlock:5550 mutex_unlock(&private->data_mutex);5551 return err;5552}5553 5554static const struct snd_kcontrol_new scarlett2_precomp_flt_switch_ctl = {5555 .iface = SNDRV_CTL_ELEM_IFACE_CARD,5556 .name = "",5557 .info = snd_ctl_boolean_mono_info,5558 .get = scarlett2_precomp_flt_switch_ctl_get,5559 .put = scarlett2_precomp_flt_switch_ctl_put,5560};5561 5562static const struct snd_kcontrol_new scarlett2_peq_flt_switch_ctl = {5563 .iface = SNDRV_CTL_ELEM_IFACE_CARD,5564 .name = "",5565 .info = snd_ctl_boolean_mono_info,5566 .get = scarlett2_peq_flt_switch_ctl_get,5567 .put = scarlett2_peq_flt_switch_ctl_put,5568};5569 5570static int scarlett2_update_filter_values(struct usb_mixer_interface *mixer)5571{5572 struct scarlett2_data *private = mixer->private_data;5573 const struct scarlett2_device_info *info = private->info;5574 int err, i, j, k, src_idx, dst_idx;5575 s32 peq_flt_values[SCARLETT2_DSP_SWITCH_MAX *5576 SCARLETT2_PEQ_FLT_SLOTS_MAX *5577 SCARLETT2_BIQUAD_COEFFS];5578 5579 if (!info->dsp_input_count)5580 return 0;5581 5582 /* Get filter switch values */5583 err = scarlett2_usb_get_config(5584 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,5585 info->dsp_input_count, private->precomp_flt_switch);5586 if (err < 0)5587 return err;5588 5589 err = scarlett2_usb_get_config(5590 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,5591 info->dsp_input_count * info->peq_flt_count,5592 private->peq_flt_switch);5593 if (err < 0)5594 return err;5595 5596 /* Get pre-compressor filter values directly */5597 err = scarlett2_usb_get_config(5598 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,5599 info->dsp_input_count *5600 info->precomp_flt_count *5601 SCARLETT2_BIQUAD_COEFFS,5602 private->precomp_flt_values);5603 5604 if (err < 0)5605 return err;5606 5607 /* PEQ filter values need to be copied via buffer because of5608 * padding after peq_flt_count up to peq_flt_total_count5609 */5610 err = scarlett2_usb_get_config(5611 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,5612 info->dsp_input_count *5613 info->peq_flt_total_count *5614 SCARLETT2_BIQUAD_COEFFS,5615 peq_flt_values);5616 if (err < 0)5617 return err;5618 5619 for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) {5620 src_idx = i *5621 info->peq_flt_total_count *5622 SCARLETT2_BIQUAD_COEFFS;5623 for (j = 0; j < info->peq_flt_count; j++)5624 for (k = 0;5625 k < SCARLETT2_BIQUAD_COEFFS;5626 k++, src_idx++, dst_idx++)5627 private->peq_flt_values[dst_idx] =5628 peq_flt_values[src_idx];5629 }5630 5631 return 0;5632}5633 5634static int scarlett2_precomp_flt_ctl_get(5635 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5636{5637 struct usb_mixer_elem_info *elem = kctl->private_data;5638 struct scarlett2_data *private = elem->head.mixer->private_data;5639 int i, idx;5640 5641 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;5642 i < SCARLETT2_BIQUAD_COEFFS;5643 i++, idx++)5644 ucontrol->value.integer.value[i] =5645 private->precomp_flt_values[idx];5646 5647 return 0;5648}5649 5650static int scarlett2_peq_flt_ctl_get(5651 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5652{5653 struct usb_mixer_elem_info *elem = kctl->private_data;5654 struct scarlett2_data *private = elem->head.mixer->private_data;5655 int i, idx;5656 5657 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;5658 i < SCARLETT2_BIQUAD_COEFFS;5659 i++, idx++)5660 ucontrol->value.integer.value[i] =5661 private->peq_flt_values[idx];5662 5663 return 0;5664}5665 5666static int scarlett2_precomp_flt_ctl_put(5667 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5668{5669 struct usb_mixer_elem_info *elem = kctl->private_data;5670 struct usb_mixer_interface *mixer = elem->head.mixer;5671 struct scarlett2_data *private = mixer->private_data;5672 5673 int index = elem->control * SCARLETT2_BIQUAD_COEFFS;5674 int i, oval, val, err;5675 5676 mutex_lock(&private->data_mutex);5677 5678 if (private->hwdep_in_use) {5679 err = -EBUSY;5680 goto unlock;5681 }5682 5683 err = scarlett2_check_put_during_autogain(mixer);5684 if (err < 0)5685 goto unlock;5686 5687 /* Check if any of the values have changed; if not, return */5688 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) {5689 oval = private->precomp_flt_values[index + i];5690 val = ucontrol->value.integer.value[i];5691 if (oval != val)5692 break;5693 }5694 5695 if (i == SCARLETT2_BIQUAD_COEFFS)5696 goto unlock;5697 5698 /* Update the values */5699 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++)5700 private->precomp_flt_values[index + i] =5701 ucontrol->value.integer.value[i];5702 5703 /* Send change to the device */5704 err = scarlett2_usb_set_data(5705 mixer, private->config_set->param_buf_addr, 1, index);5706 if (err < 0)5707 goto unlock;5708 5709 err = scarlett2_usb_set_config_buf(5710 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,5711 index, SCARLETT2_BIQUAD_COEFFS,5712 &private->precomp_flt_values[index]);5713 5714 if (err == 0)5715 err = 1;5716 5717unlock:5718 mutex_unlock(&private->data_mutex);5719 return err;5720}5721 5722static int scarlett2_peq_flt_ctl_put(5723 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)5724{5725 struct usb_mixer_elem_info *elem = kctl->private_data;5726 struct usb_mixer_interface *mixer = elem->head.mixer;5727 struct scarlett2_data *private = mixer->private_data;5728 const struct scarlett2_device_info *info = private->info;5729 5730 int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS;5731 int dst_index = (5732 elem->control /5733 info->peq_flt_count *5734 info->peq_flt_total_count +5735 elem->control % info->peq_flt_count5736 ) * SCARLETT2_BIQUAD_COEFFS;5737 int i, oval, val, err;5738 5739 mutex_lock(&private->data_mutex);5740 5741 if (private->hwdep_in_use) {5742 err = -EBUSY;5743 goto unlock;5744 }5745 5746 err = scarlett2_check_put_during_autogain(mixer);5747 if (err < 0)5748 goto unlock;5749 5750 /* Check if any of the values have changed; if not, return */5751 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) {5752 oval = private->peq_flt_values[src_index + i];5753 val = ucontrol->value.integer.value[i];5754 if (oval != val)5755 break;5756 }5757 5758 if (i == SCARLETT2_BIQUAD_COEFFS)5759 goto unlock;5760 5761 /* Update the values */5762 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++)5763 private->peq_flt_values[src_index + i] =5764 ucontrol->value.integer.value[i];5765 5766 /* Send change to the device */5767 err = scarlett2_usb_set_data(5768 mixer, private->config_set->param_buf_addr, 1, dst_index);5769 if (err < 0)5770 goto unlock;5771 5772 err = scarlett2_usb_set_config_buf(5773 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,5774 dst_index, SCARLETT2_BIQUAD_COEFFS,5775 &private->peq_flt_values[src_index]);5776 5777 if (err == 0)5778 err = 1;5779 5780unlock:5781 mutex_unlock(&private->data_mutex);5782 return err;5783}5784 5785static int scarlett2_flt_ctl_info(5786 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)5787{5788 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;5789 uinfo->count = SCARLETT2_BIQUAD_COEFFS;5790 uinfo->value.integer.min = INT_MIN;5791 uinfo->value.integer.max = INT_MAX;5792 uinfo->value.integer.step = 1;5793 return 0;5794}5795 5796static const struct snd_kcontrol_new scarlett2_precomp_flt_ctl = {5797 .iface = SNDRV_CTL_ELEM_IFACE_CARD,5798 .name = "",5799 .info = scarlett2_flt_ctl_info,5800 .get = scarlett2_precomp_flt_ctl_get,5801 .put = scarlett2_precomp_flt_ctl_put,5802};5803 5804static const struct snd_kcontrol_new scarlett2_peq_flt_ctl = {5805 .iface = SNDRV_CTL_ELEM_IFACE_CARD,5806 .name = "",5807 .info = scarlett2_flt_ctl_info,5808 .get = scarlett2_peq_flt_ctl_get,5809 .put = scarlett2_peq_flt_ctl_put,5810};5811 5812/*** Input Mute Switch Controls ***/5813 5814static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer)5815{5816 struct scarlett2_data *private = mixer->private_data;5817 const struct scarlett2_device_info *info = private->info;5818 5819 private->input_mute_updated = 0;5820 5821 if (!info->mute_input_count)5822 return 0;5823 5824 return scarlett2_usb_get_config(5825 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,5826 info->mute_input_count, private->input_mute_switch);5827}5828 5829static int scarlett2_input_mute_ctl_get(struct snd_kcontrol *kctl,5830 struct snd_ctl_elem_value *ucontrol)5831{5832 struct usb_mixer_elem_info *elem = kctl->private_data;5833 struct usb_mixer_interface *mixer = elem->head.mixer;5834 struct scarlett2_data *private = mixer->private_data;5835 int err = 0;5836 5837 mutex_lock(&private->data_mutex);5838 5839 if (private->hwdep_in_use) {5840 err = -EBUSY;5841 goto unlock;5842 }5843 5844 if (private->input_mute_updated) {5845 err = scarlett2_update_input_mute(mixer);5846 if (err < 0)5847 goto unlock;5848 }5849 ucontrol->value.integer.value[0] =5850 private->input_mute_switch[elem->control];5851 5852unlock:5853 mutex_unlock(&private->data_mutex);5854 return err;5855}5856 5857static int scarlett2_input_mute_ctl_put(struct snd_kcontrol *kctl,5858 struct snd_ctl_elem_value *ucontrol)5859{5860 struct usb_mixer_elem_info *elem = kctl->private_data;5861 struct usb_mixer_interface *mixer = elem->head.mixer;5862 struct scarlett2_data *private = mixer->private_data;5863 5864 int index = elem->control;5865 int oval, val, err;5866 5867 mutex_lock(&private->data_mutex);5868 5869 if (private->hwdep_in_use) {5870 err = -EBUSY;5871 goto unlock;5872 }5873 5874 err = scarlett2_check_put_during_autogain(mixer);5875 if (err < 0)5876 goto unlock;5877 5878 oval = private->input_mute_switch[index];5879 val = ucontrol->value.integer.value[0];5880 5881 if (oval == val)5882 goto unlock;5883 5884 private->input_mute_switch[index] = val;5885 5886 /* Send switch change to the device */5887 err = scarlett2_usb_set_config(5888 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,5889 index, val);5890 if (err == 0)5891 err = 1;5892 5893unlock:5894 mutex_unlock(&private->data_mutex);5895 return err;5896}5897 5898static const struct snd_kcontrol_new scarlett2_input_mute_ctl = {5899 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,5900 .name = "",5901 .info = scarlett2_autogain_disables_ctl_info,5902 .get = scarlett2_input_mute_ctl_get,5903 .put = scarlett2_input_mute_ctl_put,5904};5905 5906/*** Phantom Switch Controls ***/5907 5908static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer)5909{5910 struct scarlett2_data *private = mixer->private_data;5911 const struct scarlett2_device_info *info = private->info;5912 int err;5913 5914 private->input_phantom_updated = 0;5915 5916 if (!info->phantom_count)5917 return 0;5918 5919 err = scarlett2_usb_get_config(5920 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,5921 info->phantom_count, private->phantom_switch);5922 if (err < 0)5923 return err;5924 5925 if (scarlett2_has_config_item(private,5926 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {5927 err = scarlett2_usb_get_config(5928 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,5929 1, &private->phantom_persistence);5930 if (err < 0)5931 return err;5932 }5933 5934 return 0;5935}5936 5937/* Check if phantom power on the given input is currently changing state */5938static int scarlett2_phantom_is_switching(5939 struct scarlett2_data *private, int line_num)5940{5941 const struct scarlett2_device_info *info = private->info;5942 int index = line_num / info->inputs_per_phantom;5943 5944 return !!(private->phantom_switch[index] & 0x02);5945}5946 5947/* Update autogain controls' access mode when phantom power changes state */5948static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)5949{5950 struct scarlett2_data *private = mixer->private_data;5951 const struct scarlett2_device_info *info = private->info;5952 int i;5953 5954 /* Disable autogain controls if phantom power is changing state */5955 for (i = 0; i < info->gain_input_count; i++) {5956 int val = !scarlett2_phantom_is_switching(private, i);5957 5958 scarlett2_set_ctl_access(private->autogain_ctls[i], val);5959 }5960}5961 5962/* Notify of access mode change for autogain which can't be enabled5963 * while phantom power is changing.5964 */5965static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer)5966{5967 struct snd_card *card = mixer->chip->card;5968 struct scarlett2_data *private = mixer->private_data;5969 const struct scarlett2_device_info *info = private->info;5970 int i;5971 5972 for (i = 0; i < info->gain_input_count; i++)5973 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,5974 &private->autogain_ctls[i]->id);5975}5976 5977/* Call scarlett2_update_input_phantom() and5978 * scarlett2_phantom_update_access() if input_phantom_updated is set.5979 */5980static int scarlett2_check_input_phantom_updated(5981 struct usb_mixer_interface *mixer)5982{5983 struct scarlett2_data *private = mixer->private_data;5984 int err;5985 5986 if (!private->input_phantom_updated)5987 return 0;5988 5989 err = scarlett2_update_input_phantom(mixer);5990 if (err < 0)5991 return err;5992 5993 scarlett2_phantom_update_access(mixer);5994 5995 return 0;5996}5997 5998static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl,5999 struct snd_ctl_elem_value *ucontrol)6000{6001 struct usb_mixer_elem_info *elem = kctl->private_data;6002 struct usb_mixer_interface *mixer = elem->head.mixer;6003 struct scarlett2_data *private = mixer->private_data;6004 int err;6005 6006 mutex_lock(&private->data_mutex);6007 6008 if (private->hwdep_in_use) {6009 err = -EBUSY;6010 goto unlock;6011 }6012 6013 err = scarlett2_check_input_phantom_updated(mixer);6014 if (err < 0)6015 goto unlock;6016 6017 ucontrol->value.integer.value[0] = scarlett2_decode_muteable(6018 private->phantom_switch[elem->control]);6019 6020unlock:6021 mutex_unlock(&private->data_mutex);6022 return err;6023}6024 6025static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl,6026 struct snd_ctl_elem_value *ucontrol)6027{6028 struct usb_mixer_elem_info *elem = kctl->private_data;6029 struct usb_mixer_interface *mixer = elem->head.mixer;6030 struct scarlett2_data *private = mixer->private_data;6031 const struct scarlett2_device_info *info = private->info;6032 6033 int index = elem->control;6034 int oval, val, err;6035 6036 mutex_lock(&private->data_mutex);6037 6038 if (private->hwdep_in_use) {6039 err = -EBUSY;6040 goto unlock;6041 }6042 6043 err = scarlett2_check_put_during_autogain(mixer);6044 if (err < 0)6045 goto unlock;6046 6047 oval = private->phantom_switch[index];6048 val = !!ucontrol->value.integer.value[0];6049 6050 if (oval == val)6051 goto unlock;6052 6053 private->phantom_switch[index] = val;6054 6055 /* To set the Gen 4 muteable controls, bit 1 gets set */6056 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)6057 val = (!val) | 0x02;6058 6059 /* Send switch change to the device */6060 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,6061 index + info->phantom_first, val);6062 if (err == 0)6063 err = 1;6064 6065 scarlett2_phantom_update_access(mixer);6066 scarlett2_phantom_notify_access(mixer);6067 6068unlock:6069 mutex_unlock(&private->data_mutex);6070 return err;6071}6072 6073static const struct snd_kcontrol_new scarlett2_phantom_ctl = {6074 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6075 .name = "",6076 .info = scarlett2_autogain_disables_ctl_info,6077 .get = scarlett2_phantom_ctl_get,6078 .put = scarlett2_phantom_ctl_put,6079};6080 6081/*** Phantom Persistence Control ***/6082 6083static int scarlett2_phantom_persistence_ctl_get(6084 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6085{6086 struct usb_mixer_elem_info *elem = kctl->private_data;6087 struct scarlett2_data *private = elem->head.mixer->private_data;6088 6089 ucontrol->value.integer.value[0] = private->phantom_persistence;6090 return 0;6091}6092 6093static int scarlett2_phantom_persistence_ctl_put(6094 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6095{6096 struct usb_mixer_elem_info *elem = kctl->private_data;6097 struct usb_mixer_interface *mixer = elem->head.mixer;6098 struct scarlett2_data *private = mixer->private_data;6099 6100 int index = elem->control;6101 int oval, val, err = 0;6102 6103 mutex_lock(&private->data_mutex);6104 6105 if (private->hwdep_in_use) {6106 err = -EBUSY;6107 goto unlock;6108 }6109 6110 oval = private->phantom_persistence;6111 val = !!ucontrol->value.integer.value[0];6112 6113 if (oval == val)6114 goto unlock;6115 6116 private->phantom_persistence = val;6117 6118 /* Send switch change to the device */6119 err = scarlett2_usb_set_config(6120 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);6121 if (err == 0)6122 err = 1;6123 6124unlock:6125 mutex_unlock(&private->data_mutex);6126 return err;6127}6128 6129static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = {6130 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6131 .name = "",6132 .info = snd_ctl_boolean_mono_info,6133 .get = scarlett2_phantom_persistence_ctl_get,6134 .put = scarlett2_phantom_persistence_ctl_put,6135};6136 6137/*** Speaker Switching Control ***/6138 6139static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)6140{6141 struct scarlett2_data *private = mixer->private_data;6142 const struct scarlett2_device_info *info = private->info;6143 int err;6144 6145 /* monitor_other_enable[0] enables speaker switching6146 * monitor_other_enable[1] enables talkback6147 */6148 u8 monitor_other_enable[2];6149 6150 /* monitor_other_switch[0] activates the alternate speakers6151 * monitor_other_switch[1] activates talkback6152 */6153 u8 monitor_other_switch[2];6154 6155 private->monitor_other_updated = 0;6156 6157 /* if it doesn't do speaker switching then it also doesn't do6158 * talkback6159 */6160 if (!info->has_speaker_switching)6161 return 0;6162 6163 err = scarlett2_usb_get_config(6164 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,6165 2, monitor_other_enable);6166 if (err < 0)6167 return err;6168 6169 err = scarlett2_usb_get_config(6170 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,6171 2, monitor_other_switch);6172 if (err < 0)6173 return err;6174 6175 if (!monitor_other_enable[0])6176 private->speaker_switching_switch = 0;6177 else6178 private->speaker_switching_switch = monitor_other_switch[0] + 1;6179 6180 if (info->has_talkback) {6181 u16 bitmap;6182 int i;6183 6184 if (!monitor_other_enable[1])6185 private->talkback_switch = 0;6186 else6187 private->talkback_switch = monitor_other_switch[1] + 1;6188 6189 err = scarlett2_usb_get_config(mixer,6190 SCARLETT2_CONFIG_TALKBACK_MAP,6191 1, &bitmap);6192 if (err < 0)6193 return err;6194 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)6195 private->talkback_map[i] = bitmap & 1;6196 }6197 6198 return 0;6199}6200 6201static int scarlett2_speaker_switch_enum_ctl_info(6202 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)6203{6204 static const char *const values[3] = {6205 "Off", "Main", "Alt"6206 };6207 6208 return snd_ctl_enum_info(uinfo, 1, 3, values);6209}6210 6211static int scarlett2_speaker_switch_enum_ctl_get(6212 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6213{6214 struct usb_mixer_elem_info *elem = kctl->private_data;6215 struct usb_mixer_interface *mixer = elem->head.mixer;6216 struct scarlett2_data *private = mixer->private_data;6217 int err = 0;6218 6219 mutex_lock(&private->data_mutex);6220 6221 if (private->hwdep_in_use) {6222 err = -EBUSY;6223 goto unlock;6224 }6225 6226 if (private->monitor_other_updated) {6227 err = scarlett2_update_monitor_other(mixer);6228 if (err < 0)6229 goto unlock;6230 }6231 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;6232 6233unlock:6234 mutex_unlock(&private->data_mutex);6235 return err;6236}6237 6238/* when speaker switching gets enabled, switch the main/alt speakers6239 * to HW volume and disable those controls6240 */6241static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)6242{6243 struct snd_card *card = mixer->chip->card;6244 struct scarlett2_data *private = mixer->private_data;6245 int i, err;6246 6247 for (i = 0; i < 4; i++) {6248 int index = line_out_remap(private, i);6249 6250 /* switch the main/alt speakers to HW volume */6251 if (!private->vol_sw_hw_switch[index]) {6252 err = scarlett2_sw_hw_change(private->mixer, i, 1);6253 if (err < 0)6254 return err;6255 }6256 6257 /* disable the line out SW/HW switch */6258 scarlett2_sw_hw_ctl_ro(private, i);6259 snd_ctl_notify(card,6260 SNDRV_CTL_EVENT_MASK_VALUE |6261 SNDRV_CTL_EVENT_MASK_INFO,6262 &private->sw_hw_ctls[i]->id);6263 }6264 6265 /* when the next monitor-other notify comes in, update the mux6266 * configuration6267 */6268 private->speaker_switching_switched = 1;6269 6270 return 0;6271}6272 6273/* when speaker switching gets disabled, reenable the hw/sw controls6274 * and invalidate the routing6275 */6276static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)6277{6278 struct snd_card *card = mixer->chip->card;6279 struct scarlett2_data *private = mixer->private_data;6280 int i;6281 6282 /* enable the line out SW/HW switch */6283 for (i = 0; i < 4; i++) {6284 scarlett2_sw_hw_ctl_rw(private, i);6285 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,6286 &private->sw_hw_ctls[i]->id);6287 }6288 6289 /* when the next monitor-other notify comes in, update the mux6290 * configuration6291 */6292 private->speaker_switching_switched = 1;6293}6294 6295static int scarlett2_speaker_switch_enum_ctl_put(6296 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6297{6298 struct usb_mixer_elem_info *elem = kctl->private_data;6299 struct usb_mixer_interface *mixer = elem->head.mixer;6300 struct scarlett2_data *private = mixer->private_data;6301 6302 int oval, val, err = 0;6303 6304 mutex_lock(&private->data_mutex);6305 6306 if (private->hwdep_in_use) {6307 err = -EBUSY;6308 goto unlock;6309 }6310 6311 oval = private->speaker_switching_switch;6312 val = min(ucontrol->value.enumerated.item[0], 2U);6313 6314 if (oval == val)6315 goto unlock;6316 6317 private->speaker_switching_switch = val;6318 6319 /* enable/disable speaker switching */6320 err = scarlett2_usb_set_config(6321 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,6322 0, !!val);6323 if (err < 0)6324 goto unlock;6325 6326 /* if speaker switching is enabled, select main or alt */6327 err = scarlett2_usb_set_config(6328 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,6329 0, val == 2);6330 if (err < 0)6331 goto unlock;6332 6333 /* update controls if speaker switching gets enabled or disabled */6334 if (!oval && val)6335 err = scarlett2_speaker_switch_enable(mixer);6336 else if (oval && !val)6337 scarlett2_speaker_switch_disable(mixer);6338 6339 if (err == 0)6340 err = 1;6341 6342unlock:6343 mutex_unlock(&private->data_mutex);6344 return err;6345}6346 6347static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = {6348 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6349 .name = "",6350 .info = scarlett2_speaker_switch_enum_ctl_info,6351 .get = scarlett2_speaker_switch_enum_ctl_get,6352 .put = scarlett2_speaker_switch_enum_ctl_put,6353};6354 6355static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer)6356{6357 struct scarlett2_data *private = mixer->private_data;6358 const struct scarlett2_device_info *info = private->info;6359 6360 if (!info->has_speaker_switching)6361 return 0;6362 6363 return scarlett2_add_new_ctl(6364 mixer, &scarlett2_speaker_switch_enum_ctl,6365 0, 1, "Speaker Switching Playback Enum",6366 &private->speaker_switching_ctl);6367}6368 6369/*** Talkback and Talkback Map Controls ***/6370 6371static int scarlett2_talkback_enum_ctl_info(6372 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)6373{6374 static const char *const values[3] = {6375 "Disabled", "Off", "On"6376 };6377 6378 return snd_ctl_enum_info(uinfo, 1, 3, values);6379}6380 6381static int scarlett2_talkback_enum_ctl_get(6382 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6383{6384 struct usb_mixer_elem_info *elem = kctl->private_data;6385 struct usb_mixer_interface *mixer = elem->head.mixer;6386 struct scarlett2_data *private = mixer->private_data;6387 int err = 0;6388 6389 mutex_lock(&private->data_mutex);6390 6391 if (private->hwdep_in_use) {6392 err = -EBUSY;6393 goto unlock;6394 }6395 6396 if (private->monitor_other_updated) {6397 err = scarlett2_update_monitor_other(mixer);6398 if (err < 0)6399 goto unlock;6400 }6401 ucontrol->value.enumerated.item[0] = private->talkback_switch;6402 6403unlock:6404 mutex_unlock(&private->data_mutex);6405 return err;6406}6407 6408static int scarlett2_talkback_enum_ctl_put(6409 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6410{6411 struct usb_mixer_elem_info *elem = kctl->private_data;6412 struct usb_mixer_interface *mixer = elem->head.mixer;6413 struct scarlett2_data *private = mixer->private_data;6414 6415 int oval, val, err = 0;6416 6417 mutex_lock(&private->data_mutex);6418 6419 if (private->hwdep_in_use) {6420 err = -EBUSY;6421 goto unlock;6422 }6423 6424 oval = private->talkback_switch;6425 val = min(ucontrol->value.enumerated.item[0], 2U);6426 6427 if (oval == val)6428 goto unlock;6429 6430 private->talkback_switch = val;6431 6432 /* enable/disable talkback */6433 err = scarlett2_usb_set_config(6434 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,6435 1, !!val);6436 if (err < 0)6437 goto unlock;6438 6439 /* if talkback is enabled, select main or alt */6440 err = scarlett2_usb_set_config(6441 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,6442 1, val == 2);6443 if (err == 0)6444 err = 1;6445 6446unlock:6447 mutex_unlock(&private->data_mutex);6448 return err;6449}6450 6451static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = {6452 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6453 .name = "",6454 .info = scarlett2_talkback_enum_ctl_info,6455 .get = scarlett2_talkback_enum_ctl_get,6456 .put = scarlett2_talkback_enum_ctl_put,6457};6458 6459static int scarlett2_talkback_map_ctl_get(6460 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6461{6462 struct usb_mixer_elem_info *elem = kctl->private_data;6463 struct usb_mixer_interface *mixer = elem->head.mixer;6464 struct scarlett2_data *private = mixer->private_data;6465 int index = elem->control;6466 6467 ucontrol->value.integer.value[0] = private->talkback_map[index];6468 6469 return 0;6470}6471 6472static int scarlett2_talkback_map_ctl_put(6473 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)6474{6475 struct usb_mixer_elem_info *elem = kctl->private_data;6476 struct usb_mixer_interface *mixer = elem->head.mixer;6477 struct scarlett2_data *private = mixer->private_data;6478 int index = elem->control;6479 int oval, val, err = 0, i;6480 u16 bitmap = 0;6481 6482 mutex_lock(&private->data_mutex);6483 6484 if (private->hwdep_in_use) {6485 err = -EBUSY;6486 goto unlock;6487 }6488 6489 oval = private->talkback_map[index];6490 val = !!ucontrol->value.integer.value[0];6491 6492 if (oval == val)6493 goto unlock;6494 6495 private->talkback_map[index] = val;6496 6497 for (i = 0; i < private->num_mix_out; i++)6498 bitmap |= private->talkback_map[i] << i;6499 6500 /* Send updated bitmap to the device */6501 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,6502 0, bitmap);6503 if (err == 0)6504 err = 1;6505 6506unlock:6507 mutex_unlock(&private->data_mutex);6508 return err;6509}6510 6511static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = {6512 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6513 .name = "",6514 .info = snd_ctl_boolean_mono_info,6515 .get = scarlett2_talkback_map_ctl_get,6516 .put = scarlett2_talkback_map_ctl_put,6517};6518 6519static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer)6520{6521 struct scarlett2_data *private = mixer->private_data;6522 const struct scarlett2_device_info *info = private->info;6523 int err, i;6524 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];6525 6526 if (!info->has_talkback)6527 return 0;6528 6529 err = scarlett2_add_new_ctl(6530 mixer, &scarlett2_talkback_enum_ctl,6531 0, 1, "Talkback Playback Enum",6532 &private->talkback_ctl);6533 if (err < 0)6534 return err;6535 6536 for (i = 0; i < private->num_mix_out; i++) {6537 snprintf(s, sizeof(s),6538 "Talkback Mix %c Playback Switch", i + 'A');6539 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,6540 i, 1, s, NULL);6541 if (err < 0)6542 return err;6543 }6544 6545 return 0;6546}6547 6548/*** Dim/Mute Controls ***/6549 6550static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl,6551 struct snd_ctl_elem_value *ucontrol)6552{6553 struct usb_mixer_elem_info *elem = kctl->private_data;6554 struct usb_mixer_interface *mixer = elem->head.mixer;6555 struct scarlett2_data *private = mixer->private_data;6556 int err = 0;6557 6558 mutex_lock(&private->data_mutex);6559 6560 if (private->hwdep_in_use) {6561 err = -EBUSY;6562 goto unlock;6563 }6564 6565 if (private->dim_mute_updated) {6566 err = scarlett2_update_dim_mute(mixer);6567 if (err < 0)6568 goto unlock;6569 }6570 ucontrol->value.integer.value[0] = private->dim_mute[elem->control];6571 6572unlock:6573 mutex_unlock(&private->data_mutex);6574 return err;6575}6576 6577static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl,6578 struct snd_ctl_elem_value *ucontrol)6579{6580 struct usb_mixer_elem_info *elem = kctl->private_data;6581 struct usb_mixer_interface *mixer = elem->head.mixer;6582 struct scarlett2_data *private = mixer->private_data;6583 int index = elem->control;6584 int oval, val, err = 0, i;6585 6586 mutex_lock(&private->data_mutex);6587 6588 if (private->hwdep_in_use) {6589 err = -EBUSY;6590 goto unlock;6591 }6592 6593 oval = private->dim_mute[index];6594 val = !!ucontrol->value.integer.value[0];6595 6596 if (oval == val)6597 goto unlock;6598 6599 private->dim_mute[index] = val;6600 6601 /* Send switch change to the device */6602 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,6603 index, val);6604 if (err == 0)6605 err = 1;6606 6607 if (index == SCARLETT2_BUTTON_MUTE)6608 for (i = 0; i < private->num_line_out; i++) {6609 int line_index = line_out_remap(private, i);6610 6611 if (private->vol_sw_hw_switch[line_index]) {6612 private->mute_switch[line_index] = val;6613 snd_ctl_notify(mixer->chip->card,6614 SNDRV_CTL_EVENT_MASK_VALUE,6615 &private->mute_ctls[i]->id);6616 }6617 }6618 6619unlock:6620 mutex_unlock(&private->data_mutex);6621 return err;6622}6623 6624static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = {6625 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,6626 .name = "",6627 .info = snd_ctl_boolean_mono_info,6628 .get = scarlett2_dim_mute_ctl_get,6629 .put = scarlett2_dim_mute_ctl_put6630};6631 6632/*** Create the analogue output controls ***/6633 6634static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)6635{6636 struct scarlett2_data *private = mixer->private_data;6637 const struct scarlett2_device_info *info = private->info;6638 int err, i;6639 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];6640 6641 /* Add R/O HW volume control */6642 if (scarlett2_has_config_item(private,6643 SCARLETT2_CONFIG_MASTER_VOLUME)) {6644 snprintf(s, sizeof(s), "Master HW Playback Volume");6645 err = scarlett2_add_new_ctl(mixer,6646 &scarlett2_master_volume_ctl,6647 0, 1, s, &private->master_vol_ctl);6648 if (err < 0)6649 return err;6650 }6651 6652 /* Add R/O headphone volume control */6653 if (scarlett2_has_config_item(private,6654 SCARLETT2_CONFIG_HEADPHONE_VOLUME)) {6655 snprintf(s, sizeof(s), "Headphone Playback Volume");6656 err = scarlett2_add_new_ctl(mixer,6657 &scarlett2_headphone_volume_ctl,6658 0, 1, s,6659 &private->headphone_vol_ctl);6660 if (err < 0)6661 return err;6662 }6663 6664 /* Remaining controls are only applicable if the device6665 * has per-channel line-out volume controls.6666 */6667 if (!scarlett2_has_config_item(private,6668 SCARLETT2_CONFIG_LINE_OUT_VOLUME))6669 return 0;6670 6671 /* Add volume controls */6672 for (i = 0; i < private->num_line_out; i++) {6673 int index = line_out_remap(private, i);6674 6675 /* Fader */6676 if (info->line_out_descrs[i])6677 snprintf(s, sizeof(s),6678 "Line %02d (%s) Playback Volume",6679 i + 1, info->line_out_descrs[i]);6680 else6681 snprintf(s, sizeof(s),6682 "Line %02d Playback Volume",6683 i + 1);6684 err = scarlett2_add_new_ctl(mixer,6685 &scarlett2_line_out_volume_ctl,6686 i, 1, s, &private->vol_ctls[i]);6687 if (err < 0)6688 return err;6689 6690 /* Mute Switch */6691 snprintf(s, sizeof(s),6692 "Line %02d Mute Playback Switch",6693 i + 1);6694 err = scarlett2_add_new_ctl(mixer,6695 &scarlett2_mute_ctl,6696 i, 1, s,6697 &private->mute_ctls[i]);6698 if (err < 0)6699 return err;6700 6701 /* SW/HW Switch */6702 if (scarlett2_has_config_item(private,6703 SCARLETT2_CONFIG_SW_HW_SWITCH)) {6704 6705 /* Make the fader and mute controls read-only if the6706 * SW/HW switch is set to HW6707 */6708 if (private->vol_sw_hw_switch[index])6709 scarlett2_vol_ctl_set_writable(mixer, i, 0);6710 6711 scnprintf(s, sizeof(s),6712 "Line Out %02d Volume Control Playback Enum",6713 i + 1);6714 err = scarlett2_add_new_ctl(mixer,6715 &scarlett2_sw_hw_enum_ctl,6716 i, 1, s,6717 &private->sw_hw_ctls[i]);6718 if (err < 0)6719 return err;6720 6721 /* Make the switch read-only if the line is6722 * involved in speaker switching6723 */6724 if (private->speaker_switching_switch && i < 4)6725 scarlett2_sw_hw_ctl_ro(private, i);6726 }6727 }6728 6729 /* Add dim/mute controls */6730 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_DIM_MUTE))6731 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) {6732 err = scarlett2_add_new_ctl(6733 mixer, &scarlett2_dim_mute_ctl,6734 i, 1, scarlett2_dim_mute_names[i],6735 &private->dim_mute_ctls[i]);6736 if (err < 0)6737 return err;6738 }6739 6740 return 0;6741}6742 6743/*** Create the analogue input controls ***/6744 6745static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i)6746{6747 struct scarlett2_data *private = mixer->private_data;6748 const struct scarlett2_device_info *info = private->info;6749 int j, err;6750 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];6751 const char *compr_fmt = "Line In %d Compressor %s";6752 const char *flt_switch_fmt = "Line In %d %s Filter Enable";6753 const char *flt_fmt = "Line In %d %s Coefficients %d";6754 6755 /* Add compressor controls */6756 for (j = 0; j < SCARLETT2_COMPRESSOR_PARAM_COUNT; j++) {6757 const struct compressor_param *param = &compressor_params[j];6758 int idx = i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j;6759 6760 scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name);6761 err = scarlett2_add_new_ctl(6762 mixer, &scarlett2_compressor_ctl,6763 i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j,6764 1, s, &private->compressor_ctls[idx]);6765 if (err < 0)6766 return err;6767 }6768 6769 /* Add filter enable controls */6770 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp");6771 err = scarlett2_add_new_ctl(6772 mixer, &scarlett2_precomp_flt_switch_ctl,6773 i, 1, s, &private->precomp_flt_switch_ctls[i]);6774 if (err < 0)6775 return err;6776 6777 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "PEQ");6778 err = scarlett2_add_new_ctl(6779 mixer, &scarlett2_peq_flt_switch_ctl,6780 i, 1, s, &private->peq_flt_switch_ctls[i]);6781 if (err < 0)6782 return err;6783 6784 /* Add filter coefficient controls */6785 for (j = 0; j < info->precomp_flt_count; j++) {6786 scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1);6787 err = scarlett2_add_new_ctl(6788 mixer, &scarlett2_precomp_flt_ctl,6789 i * info->precomp_flt_count + j,6790 1, s, &private->precomp_flt_switch_ctls[j]);6791 if (err < 0)6792 return err;6793 }6794 6795 for (j = 0; j < info->peq_flt_count; j++) {6796 scnprintf(s, sizeof(s), flt_fmt, i + 1, "PEQ", j + 1);6797 err = scarlett2_add_new_ctl(6798 mixer, &scarlett2_peq_flt_ctl,6799 i * info->peq_flt_count + j,6800 1, s, &private->peq_flt_switch_ctls[j]);6801 if (err < 0)6802 return err;6803 }6804 6805 return 0;6806}6807 6808static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)6809{6810 struct scarlett2_data *private = mixer->private_data;6811 const struct scarlett2_device_info *info = private->info;6812 int err, i;6813 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];6814 const char *fmt = "Line In %d %s Capture %s";6815 const char *fmt2 = "Line In %d-%d %s Capture %s";6816 6817 /* Add input level (line/inst) controls */6818 for (i = 0; i < info->level_input_count; i++) {6819 scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,6820 "Level", "Enum");6821 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,6822 i, 1, s, &private->level_ctls[i]);6823 if (err < 0)6824 return err;6825 }6826 6827 /* Add input pad controls */6828 for (i = 0; i < info->pad_input_count; i++) {6829 scnprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch");6830 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,6831 i, 1, s, &private->pad_ctls[i]);6832 if (err < 0)6833 return err;6834 }6835 6836 /* Add input air controls */6837 for (i = 0; i < info->air_input_count; i++) {6838 scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,6839 "Air", info->air_option ? "Enum" : "Switch");6840 err = scarlett2_add_new_ctl(6841 mixer, &scarlett2_air_ctl[info->air_option],6842 i, 1, s, &private->air_ctls[i]);6843 if (err < 0)6844 return err;6845 }6846 6847 /* Add input DSP controls */6848 for (i = 0; i < info->dsp_input_count; i++) {6849 scnprintf(s, sizeof(s), fmt, i + 1, "DSP", "Switch");6850 err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl,6851 i, 1, s, &private->dsp_ctls[i]);6852 if (err < 0)6853 return err;6854 6855 err = scarlett2_add_dsp_ctls(mixer, i);6856 if (err < 0)6857 return err;6858 }6859 6860 /* Add input mute controls */6861 for (i = 0; i < info->mute_input_count; i++) {6862 scnprintf(s, sizeof(s), fmt, i + 1, "Mute", "Switch");6863 err = scarlett2_add_new_ctl(6864 mixer, &scarlett2_input_mute_ctl,6865 i, 1, s, &private->input_mute_ctls[i]);6866 if (err < 0)6867 return err;6868 }6869 6870 /* Add input phantom controls */6871 if (info->inputs_per_phantom == 1) {6872 for (i = 0; i < info->phantom_count; i++) {6873 scnprintf(s, sizeof(s), fmt,6874 i + 1 + info->phantom_first,6875 "Phantom Power", "Switch");6876 err = scarlett2_add_new_ctl(6877 mixer, &scarlett2_phantom_ctl,6878 i, 1, s, &private->phantom_ctls[i]);6879 if (err < 0)6880 return err;6881 }6882 } else if (info->inputs_per_phantom > 1) {6883 for (i = 0; i < info->phantom_count; i++) {6884 int from = i * info->inputs_per_phantom + 1;6885 int to = (i + 1) * info->inputs_per_phantom;6886 6887 scnprintf(s, sizeof(s), fmt2, from, to,6888 "Phantom Power", "Switch");6889 err = scarlett2_add_new_ctl(6890 mixer, &scarlett2_phantom_ctl,6891 i, 1, s, &private->phantom_ctls[i]);6892 if (err < 0)6893 return err;6894 }6895 }6896 if (info->phantom_count &&6897 scarlett2_has_config_item(private,6898 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) {6899 err = scarlett2_add_new_ctl(6900 mixer, &scarlett2_phantom_persistence_ctl, 0, 1,6901 "Phantom Power Persistence Capture Switch", NULL);6902 if (err < 0)6903 return err;6904 }6905 6906 /* Add input select/link controls */6907 if (scarlett2_has_config_item(private,6908 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH)) {6909 err = scarlett2_add_new_ctl(6910 mixer, &scarlett2_input_select_ctl, 0, 1,6911 "Input Select Capture Enum",6912 &private->input_select_ctl);6913 if (err < 0)6914 return err;6915 }6916 6917 if (scarlett2_has_config_item(private,6918 SCARLETT2_CONFIG_INPUT_LINK_SWITCH)) {6919 for (i = 0; i < info->gain_input_count / 2; i++) {6920 scnprintf(s, sizeof(s),6921 "Line In %d-%d Link Capture Switch",6922 (i * 2) + 1, (i * 2) + 2);6923 err = scarlett2_add_new_ctl(6924 mixer, &scarlett2_input_link_ctl,6925 i, 1, s, &private->input_link_ctls[i]);6926 if (err < 0)6927 return err;6928 }6929 }6930 6931 /* Add software-controllable input gain controls */6932 for (i = 0; i < info->gain_input_count; i++) {6933 scnprintf(s, sizeof(s), fmt, i + 1,6934 "Gain", "Volume");6935 err = scarlett2_add_new_ctl(6936 mixer, &scarlett2_input_gain_ctl,6937 i, 1, s, &private->input_gain_ctls[i]);6938 if (err < 0)6939 return err;6940 private->input_gain_ctls[i]->tlv.p =6941 private->config_set->input_gain_tlv;6942 6943 scnprintf(s, sizeof(s), fmt, i + 1,6944 "Autogain", "Switch");6945 err = scarlett2_add_new_ctl(6946 mixer, &scarlett2_autogain_switch_ctl,6947 i, 1, s, &private->autogain_ctls[i]);6948 if (err < 0)6949 return err;6950 6951 scnprintf(s, sizeof(s), fmt, i + 1,6952 "Autogain Status", "Enum");6953 err = scarlett2_add_new_ctl(6954 mixer, &scarlett2_autogain_status_ctl,6955 i, 1, s, &private->autogain_status_ctls[i]);6956 }6957 6958 /* Add autogain target controls */6959 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)6960 if (scarlett2_has_config_item(private,6961 scarlett2_ag_target_configs[i])) {6962 6963 scnprintf(s, sizeof(s), "Autogain %s Target",6964 scarlett2_ag_target_names[i]);6965 err = scarlett2_add_new_ctl(6966 mixer, &scarlett2_ag_target_ctl,6967 i, 1, s, &private->ag_target_ctls[i]);6968 if (err < 0)6969 return err;6970 }6971 6972 /* Add safe-mode input switch controls */6973 for (i = 0; i < info->safe_input_count; i++) {6974 scnprintf(s, sizeof(s), fmt, i + 1,6975 "Safe", "Switch");6976 err = scarlett2_add_new_ctl(6977 mixer, &scarlett2_safe_ctl,6978 i, 1, s, &private->safe_ctls[i]);6979 if (err < 0)6980 return err;6981 }6982 6983 /* Add PCM Input Switch control */6984 if (scarlett2_has_config_item(private,6985 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {6986 err = scarlett2_add_new_ctl(6987 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1,6988 "PCM Input Capture Switch",6989 &private->pcm_input_switch_ctl);6990 if (err < 0)6991 return err;6992 }6993 6994 return 0;6995}6996 6997/*** Mixer Volume Controls ***/6998 6999static int scarlett2_update_mix(struct usb_mixer_interface *mixer)7000{7001 struct scarlett2_data *private = mixer->private_data;7002 int i, err;7003 7004 private->mix_updated = 0;7005 7006 for (i = 0; i < private->num_mix_out; i++) {7007 err = scarlett2_usb_get_mix(mixer, i);7008 if (err < 0)7009 return err;7010 }7011 7012 return 1;7013}7014 7015static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,7016 struct snd_ctl_elem_info *uinfo)7017{7018 struct usb_mixer_elem_info *elem = kctl->private_data;7019 7020 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;7021 uinfo->count = elem->channels;7022 uinfo->value.integer.min = 0;7023 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;7024 uinfo->value.integer.step = 1;7025 return 0;7026}7027 7028static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,7029 struct snd_ctl_elem_value *ucontrol)7030{7031 struct usb_mixer_elem_info *elem = kctl->private_data;7032 struct usb_mixer_interface *mixer = elem->head.mixer;7033 struct scarlett2_data *private = mixer->private_data;7034 int err = 0;7035 7036 mutex_lock(&private->data_mutex);7037 7038 if (private->hwdep_in_use) {7039 err = -EBUSY;7040 goto unlock;7041 }7042 7043 if (private->mix_updated) {7044 err = scarlett2_update_mix(mixer);7045 if (err < 0)7046 goto unlock;7047 }7048 ucontrol->value.integer.value[0] = private->mix[elem->control];7049 7050unlock:7051 mutex_unlock(&private->data_mutex);7052 return err;7053}7054 7055static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,7056 struct snd_ctl_elem_value *ucontrol)7057{7058 struct usb_mixer_elem_info *elem = kctl->private_data;7059 struct usb_mixer_interface *mixer = elem->head.mixer;7060 struct scarlett2_data *private = mixer->private_data;7061 int oval, val, mix_num, err = 0;7062 int index = elem->control;7063 7064 mutex_lock(&private->data_mutex);7065 7066 if (private->hwdep_in_use) {7067 err = -EBUSY;7068 goto unlock;7069 }7070 7071 oval = private->mix[index];7072 val = clamp(ucontrol->value.integer.value[0],7073 0L, (long)SCARLETT2_MIXER_MAX_VALUE);7074 mix_num = index / private->num_mix_in;7075 7076 if (oval == val)7077 goto unlock;7078 7079 private->mix[index] = val;7080 err = scarlett2_usb_set_mix(mixer, mix_num);7081 if (err == 0)7082 err = 1;7083 7084unlock:7085 mutex_unlock(&private->data_mutex);7086 return err;7087}7088 7089static const DECLARE_TLV_DB_MINMAX(7090 db_scale_scarlett2_mixer,7091 SCARLETT2_MIXER_MIN_DB * 100,7092 SCARLETT2_MIXER_MAX_DB * 1007093);7094 7095static const struct snd_kcontrol_new scarlett2_mixer_ctl = {7096 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7097 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |7098 SNDRV_CTL_ELEM_ACCESS_TLV_READ,7099 .name = "",7100 .info = scarlett2_mixer_ctl_info,7101 .get = scarlett2_mixer_ctl_get,7102 .put = scarlett2_mixer_ctl_put,7103 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */7104 .tlv = { .p = db_scale_scarlett2_mixer }7105};7106 7107static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)7108{7109 struct scarlett2_data *private = mixer->private_data;7110 int err, i, j;7111 int index;7112 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];7113 7114 for (i = 0, index = 0; i < private->num_mix_out; i++)7115 for (j = 0; j < private->num_mix_in; j++, index++) {7116 snprintf(s, sizeof(s),7117 "Mix %c Input %02d Playback Volume",7118 'A' + i, j + 1);7119 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,7120 index, 1, s,7121 &private->mix_ctls[index]);7122 if (err < 0)7123 return err;7124 }7125 7126 return 0;7127}7128 7129/*** Direct Monitor Control ***/7130 7131static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)7132{7133 struct scarlett2_data *private = mixer->private_data;7134 7135 private->direct_monitor_updated = 0;7136 7137 if (!private->info->direct_monitor)7138 return 0;7139 7140 return scarlett2_usb_get_config(7141 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,7142 1, &private->direct_monitor_switch);7143}7144 7145static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)7146{7147 struct scarlett2_data *private = mixer->private_data;7148 int err, i;7149 u16 mix_values[SCARLETT2_MONITOR_MIX_MAX];7150 7151 if (!private->num_monitor_mix_ctls)7152 return 0;7153 7154 err = scarlett2_usb_get_config(7155 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,7156 private->num_monitor_mix_ctls, mix_values);7157 if (err < 0)7158 return err;7159 7160 for (i = 0; i < private->num_monitor_mix_ctls; i++)7161 private->monitor_mix[i] = scarlett2_mixer_value_to_db(7162 mix_values[i]);7163 7164 return 0;7165}7166 7167static int scarlett2_direct_monitor_ctl_get(7168 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)7169{7170 struct usb_mixer_elem_info *elem = kctl->private_data;7171 struct usb_mixer_interface *mixer = elem->head.mixer;7172 struct scarlett2_data *private = mixer->private_data;7173 int err = 0;7174 7175 mutex_lock(&private->data_mutex);7176 7177 if (private->hwdep_in_use) {7178 err = -EBUSY;7179 goto unlock;7180 }7181 7182 if (private->direct_monitor_updated) {7183 err = scarlett2_update_direct_monitor(mixer);7184 if (err < 0)7185 goto unlock;7186 }7187 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;7188 7189unlock:7190 mutex_unlock(&private->data_mutex);7191 return err;7192}7193 7194static int scarlett2_direct_monitor_ctl_put(7195 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol)7196{7197 struct usb_mixer_elem_info *elem = kctl->private_data;7198 struct usb_mixer_interface *mixer = elem->head.mixer;7199 struct scarlett2_data *private = mixer->private_data;7200 7201 int index = elem->control;7202 int oval, val, err = 0;7203 7204 mutex_lock(&private->data_mutex);7205 7206 if (private->hwdep_in_use) {7207 err = -EBUSY;7208 goto unlock;7209 }7210 7211 oval = private->direct_monitor_switch;7212 val = min(ucontrol->value.enumerated.item[0], 2U);7213 7214 if (oval == val)7215 goto unlock;7216 7217 private->direct_monitor_switch = val;7218 7219 /* Send switch change to the device */7220 err = scarlett2_usb_set_config(7221 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);7222 if (err == 0)7223 err = 1;7224 7225unlock:7226 mutex_unlock(&private->data_mutex);7227 return err;7228}7229 7230static int scarlett2_direct_monitor_stereo_enum_ctl_info(7231 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)7232{7233 static const char *const values[3] = {7234 "Off", "Mono", "Stereo"7235 };7236 7237 return snd_ctl_enum_info(uinfo, 1, 3, values);7238}7239 7240/* Direct Monitor for Solo is mono-only and only needs a boolean control7241 * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo7242 */7243static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = {7244 {7245 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7246 .name = "",7247 .info = snd_ctl_boolean_mono_info,7248 .get = scarlett2_direct_monitor_ctl_get,7249 .put = scarlett2_direct_monitor_ctl_put,7250 },7251 {7252 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7253 .name = "",7254 .info = scarlett2_direct_monitor_stereo_enum_ctl_info,7255 .get = scarlett2_direct_monitor_ctl_get,7256 .put = scarlett2_direct_monitor_ctl_put,7257 }7258};7259 7260static int scarlett2_monitor_mix_ctl_get(struct snd_kcontrol *kctl,7261 struct snd_ctl_elem_value *ucontrol)7262{7263 struct usb_mixer_elem_info *elem = kctl->private_data;7264 struct scarlett2_data *private = elem->head.mixer->private_data;7265 7266 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];7267 7268 return 0;7269}7270 7271static int scarlett2_monitor_mix_ctl_put(struct snd_kcontrol *kctl,7272 struct snd_ctl_elem_value *ucontrol)7273{7274 struct usb_mixer_elem_info *elem = kctl->private_data;7275 struct usb_mixer_interface *mixer = elem->head.mixer;7276 struct scarlett2_data *private = mixer->private_data;7277 int oval, val, err = 0;7278 int index = elem->control;7279 7280 mutex_lock(&private->data_mutex);7281 7282 if (private->hwdep_in_use) {7283 err = -EBUSY;7284 goto unlock;7285 }7286 7287 oval = private->monitor_mix[index];7288 val = clamp(ucontrol->value.integer.value[0],7289 0L, (long)SCARLETT2_MIXER_MAX_VALUE);7290 7291 if (oval == val)7292 goto unlock;7293 7294 private->monitor_mix[index] = val;7295 err = scarlett2_usb_set_config(7296 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,7297 index, scarlett2_mixer_values[val]);7298 if (err == 0)7299 err = 1;7300 7301unlock:7302 mutex_unlock(&private->data_mutex);7303 return err;7304}7305 7306static const struct snd_kcontrol_new scarlett2_monitor_mix_ctl = {7307 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7308 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |7309 SNDRV_CTL_ELEM_ACCESS_TLV_READ,7310 .name = "",7311 .info = scarlett2_mixer_ctl_info,7312 .get = scarlett2_monitor_mix_ctl_get,7313 .put = scarlett2_monitor_mix_ctl_put,7314 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */7315 .tlv = { .p = db_scale_scarlett2_mixer }7316};7317 7318static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer)7319{7320 struct scarlett2_data *private = mixer->private_data;7321 const struct scarlett2_device_info *info = private->info;7322 const char *s;7323 int err, i, j, k, index;7324 7325 if (!info->direct_monitor)7326 return 0;7327 7328 s = info->direct_monitor == 17329 ? "Direct Monitor Playback Switch"7330 : "Direct Monitor Playback Enum";7331 7332 err = scarlett2_add_new_ctl(7333 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],7334 0, 1, s, &private->direct_monitor_ctl);7335 if (err < 0)7336 return err;7337 7338 if (!private->num_monitor_mix_ctls)7339 return 0;7340 7341 /* 1 or 2 direct monitor selections (Mono & Stereo) */7342 for (i = 0, index = 0; i < info->direct_monitor; i++) {7343 const char * const format =7344 "Monitor %sMix %c Input %02d Playback Volume";7345 const char *mix_type;7346 7347 if (info->direct_monitor == 1)7348 mix_type = "";7349 else if (i == 0)7350 mix_type = "1 ";7351 else7352 mix_type = "2 ";7353 7354 /* 2 Mix outputs, A/Left & B/Right */7355 for (j = 0; j < 2; j++)7356 7357 /* Mix inputs */7358 for (k = 0; k < private->num_mix_in; k++, index++) {7359 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];7360 7361 scnprintf(name, sizeof(name), format,7362 mix_type, 'A' + j, k + 1);7363 7364 err = scarlett2_add_new_ctl(7365 mixer, &scarlett2_monitor_mix_ctl,7366 index, 1, name, NULL);7367 if (err < 0)7368 return err;7369 }7370 }7371 7372 return 0;7373}7374 7375/*** Mux Source Selection Controls ***/7376 7377static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,7378 struct snd_ctl_elem_info *uinfo)7379{7380 struct usb_mixer_elem_info *elem = kctl->private_data;7381 struct scarlett2_data *private = elem->head.mixer->private_data;7382 const struct scarlett2_device_info *info = private->info;7383 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;7384 unsigned int item = uinfo->value.enumerated.item;7385 int items = private->num_mux_srcs;7386 int port_type;7387 7388 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;7389 uinfo->count = elem->channels;7390 uinfo->value.enumerated.items = items;7391 7392 if (item >= items)7393 item = uinfo->value.enumerated.item = items - 1;7394 7395 for (port_type = 0;7396 port_type < SCARLETT2_PORT_TYPE_COUNT;7397 port_type++) {7398 if (item < port_count[port_type][SCARLETT2_PORT_IN]) {7399 const struct scarlett2_port *port =7400 &scarlett2_ports[port_type];7401 7402 if (port_type == SCARLETT2_PORT_TYPE_MIX &&7403 item >= private->num_mix_out)7404 sprintf(uinfo->value.enumerated.name,7405 port->dsp_src_descr,7406 item - private->num_mix_out + 1);7407 else7408 sprintf(uinfo->value.enumerated.name,7409 port->src_descr,7410 item + port->src_num_offset);7411 7412 return 0;7413 }7414 item -= port_count[port_type][SCARLETT2_PORT_IN];7415 }7416 7417 return -EINVAL;7418}7419 7420static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,7421 struct snd_ctl_elem_value *ucontrol)7422{7423 struct usb_mixer_elem_info *elem = kctl->private_data;7424 struct usb_mixer_interface *mixer = elem->head.mixer;7425 struct scarlett2_data *private = mixer->private_data;7426 int index = line_out_remap(private, elem->control);7427 int err = 0;7428 7429 mutex_lock(&private->data_mutex);7430 7431 if (private->hwdep_in_use) {7432 err = -EBUSY;7433 goto unlock;7434 }7435 7436 if (private->mux_updated) {7437 err = scarlett2_usb_get_mux(mixer);7438 if (err < 0)7439 goto unlock;7440 }7441 ucontrol->value.enumerated.item[0] = private->mux[index];7442 7443unlock:7444 mutex_unlock(&private->data_mutex);7445 return err;7446}7447 7448static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,7449 struct snd_ctl_elem_value *ucontrol)7450{7451 struct usb_mixer_elem_info *elem = kctl->private_data;7452 struct usb_mixer_interface *mixer = elem->head.mixer;7453 struct scarlett2_data *private = mixer->private_data;7454 int index = line_out_remap(private, elem->control);7455 int oval, val, err = 0;7456 7457 mutex_lock(&private->data_mutex);7458 7459 if (private->hwdep_in_use) {7460 err = -EBUSY;7461 goto unlock;7462 }7463 7464 oval = private->mux[index];7465 val = min(ucontrol->value.enumerated.item[0],7466 private->num_mux_srcs - 1U);7467 7468 if (oval == val)7469 goto unlock;7470 7471 private->mux[index] = val;7472 err = scarlett2_usb_set_mux(mixer);7473 if (err == 0)7474 err = 1;7475 7476unlock:7477 mutex_unlock(&private->data_mutex);7478 return err;7479}7480 7481static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {7482 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7483 .name = "",7484 .info = scarlett2_mux_src_enum_ctl_info,7485 .get = scarlett2_mux_src_enum_ctl_get,7486 .put = scarlett2_mux_src_enum_ctl_put,7487};7488 7489static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)7490{7491 struct scarlett2_data *private = mixer->private_data;7492 const struct scarlett2_device_info *info = private->info;7493 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;7494 int port_type, channel, i;7495 7496 for (i = 0, port_type = 0;7497 port_type < SCARLETT2_PORT_TYPE_COUNT;7498 port_type++) {7499 for (channel = 0;7500 channel < port_count[port_type][SCARLETT2_PORT_OUT];7501 channel++, i++) {7502 int err;7503 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];7504 int channel_num = channel + 1;7505 const struct scarlett2_port *port =7506 &scarlett2_ports[port_type];7507 const char *descr = port->dst_descr;7508 7509 if (port_type == SCARLETT2_PORT_TYPE_MIX &&7510 channel >= private->num_mix_in) {7511 channel_num -= private->num_mix_in;7512 descr = port->dsp_dst_descr;7513 }7514 7515 snprintf(s, sizeof(s) - 5, descr, channel_num);7516 strcat(s, " Enum");7517 7518 err = scarlett2_add_new_ctl(mixer,7519 &scarlett2_mux_src_enum_ctl,7520 i, 1, s,7521 &private->mux_ctls[i]);7522 if (err < 0)7523 return err;7524 }7525 }7526 7527 return 0;7528}7529 7530/*** Meter Controls ***/7531 7532static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,7533 struct snd_ctl_elem_info *uinfo)7534{7535 struct usb_mixer_elem_info *elem = kctl->private_data;7536 7537 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;7538 uinfo->count = elem->channels;7539 uinfo->value.integer.min = 0;7540 uinfo->value.integer.max = 4095;7541 uinfo->value.integer.step = 1;7542 return 0;7543}7544 7545static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,7546 struct snd_ctl_elem_value *ucontrol)7547{7548 struct usb_mixer_elem_info *elem = kctl->private_data;7549 struct usb_mixer_interface *mixer = elem->head.mixer;7550 struct scarlett2_data *private = mixer->private_data;7551 u8 *meter_level_map = private->meter_level_map;7552 u16 meter_levels[SCARLETT2_MAX_METERS];7553 int i, err;7554 7555 mutex_lock(&private->data_mutex);7556 7557 if (private->hwdep_in_use) {7558 err = -EBUSY;7559 goto unlock;7560 }7561 7562 err = scarlett2_usb_get_meter_levels(mixer, elem->channels,7563 meter_levels);7564 if (err < 0)7565 goto unlock;7566 7567 /* copy & translate from meter_levels[] using meter_level_map[] */7568 for (i = 0; i < elem->channels; i++) {7569 int idx = meter_level_map[i];7570 int value;7571 7572 if (idx == 255)7573 value = 0;7574 else7575 value = meter_levels[idx];7576 7577 ucontrol->value.integer.value[i] = value;7578 }7579 7580unlock:7581 mutex_unlock(&private->data_mutex);7582 7583 return err;7584}7585 7586static const struct snd_kcontrol_new scarlett2_meter_ctl = {7587 .iface = SNDRV_CTL_ELEM_IFACE_PCM,7588 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,7589 .name = "",7590 .info = scarlett2_meter_ctl_info,7591 .get = scarlett2_meter_ctl_get7592};7593 7594static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)7595{7596 struct scarlett2_data *private = mixer->private_data;7597 7598 /* devices without a mixer also don't support reporting levels */7599 if (!scarlett2_has_mixer(private))7600 return 0;7601 7602 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,7603 0, private->num_mux_dsts,7604 "Level Meter", NULL);7605}7606 7607/*** MSD Controls ***/7608 7609static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl,7610 struct snd_ctl_elem_value *ucontrol)7611{7612 struct usb_mixer_elem_info *elem = kctl->private_data;7613 struct scarlett2_data *private = elem->head.mixer->private_data;7614 7615 ucontrol->value.integer.value[0] = private->msd_switch;7616 return 0;7617}7618 7619static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl,7620 struct snd_ctl_elem_value *ucontrol)7621{7622 struct usb_mixer_elem_info *elem = kctl->private_data;7623 struct usb_mixer_interface *mixer = elem->head.mixer;7624 struct scarlett2_data *private = mixer->private_data;7625 7626 int oval, val, err = 0;7627 7628 mutex_lock(&private->data_mutex);7629 7630 if (private->hwdep_in_use) {7631 err = -EBUSY;7632 goto unlock;7633 }7634 7635 oval = private->msd_switch;7636 val = !!ucontrol->value.integer.value[0];7637 7638 if (oval == val)7639 goto unlock;7640 7641 private->msd_switch = val;7642 7643 /* Send switch change to the device */7644 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,7645 0, val);7646 if (err == 0)7647 err = 1;7648 7649unlock:7650 mutex_unlock(&private->data_mutex);7651 return err;7652}7653 7654static const struct snd_kcontrol_new scarlett2_msd_ctl = {7655 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7656 .name = "",7657 .info = snd_ctl_boolean_mono_info,7658 .get = scarlett2_msd_ctl_get,7659 .put = scarlett2_msd_ctl_put,7660};7661 7662static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)7663{7664 struct scarlett2_data *private = mixer->private_data;7665 7666 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH))7667 return 0;7668 7669 /* If MSD mode is off, hide the switch by default */7670 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))7671 return 0;7672 7673 /* Add MSD control */7674 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,7675 0, 1, "MSD Mode Switch", NULL);7676}7677 7678/*** Standalone Control ***/7679 7680static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl,7681 struct snd_ctl_elem_value *ucontrol)7682{7683 struct usb_mixer_elem_info *elem = kctl->private_data;7684 struct scarlett2_data *private = elem->head.mixer->private_data;7685 7686 ucontrol->value.integer.value[0] = private->standalone_switch;7687 return 0;7688}7689 7690static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl,7691 struct snd_ctl_elem_value *ucontrol)7692{7693 struct usb_mixer_elem_info *elem = kctl->private_data;7694 struct usb_mixer_interface *mixer = elem->head.mixer;7695 struct scarlett2_data *private = mixer->private_data;7696 7697 int oval, val, err = 0;7698 7699 mutex_lock(&private->data_mutex);7700 7701 if (private->hwdep_in_use) {7702 err = -EBUSY;7703 goto unlock;7704 }7705 7706 oval = private->standalone_switch;7707 val = !!ucontrol->value.integer.value[0];7708 7709 if (oval == val)7710 goto unlock;7711 7712 private->standalone_switch = val;7713 7714 /* Send switch change to the device */7715 err = scarlett2_usb_set_config(mixer,7716 SCARLETT2_CONFIG_STANDALONE_SWITCH,7717 0, val);7718 if (err == 0)7719 err = 1;7720 7721unlock:7722 mutex_unlock(&private->data_mutex);7723 return err;7724}7725 7726static const struct snd_kcontrol_new scarlett2_standalone_ctl = {7727 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7728 .name = "",7729 .info = snd_ctl_boolean_mono_info,7730 .get = scarlett2_standalone_ctl_get,7731 .put = scarlett2_standalone_ctl_put,7732};7733 7734static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)7735{7736 struct scarlett2_data *private = mixer->private_data;7737 7738 if (!scarlett2_has_config_item(private,7739 SCARLETT2_CONFIG_STANDALONE_SWITCH))7740 return 0;7741 7742 /* Add standalone control */7743 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,7744 0, 1, "Standalone Switch", NULL);7745}7746 7747/*** Power Status ***/7748 7749static int scarlett2_update_power_status(struct usb_mixer_interface *mixer)7750{7751 struct scarlett2_data *private = mixer->private_data;7752 int err;7753 u8 power_ext, power_low;7754 7755 private->power_status_updated = 0;7756 7757 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT,7758 1, &power_ext);7759 if (err < 0)7760 return err;7761 7762 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW,7763 1, &power_low);7764 if (err < 0)7765 return err;7766 7767 if (power_low)7768 private->power_status = SCARLETT2_POWER_STATUS_FAIL;7769 else if (power_ext)7770 private->power_status = SCARLETT2_POWER_STATUS_EXT;7771 else7772 private->power_status = SCARLETT2_POWER_STATUS_BUS;7773 7774 return 0;7775}7776 7777static int scarlett2_power_status_ctl_get(struct snd_kcontrol *kctl,7778 struct snd_ctl_elem_value *ucontrol)7779{7780 struct usb_mixer_elem_info *elem = kctl->private_data;7781 struct usb_mixer_interface *mixer = elem->head.mixer;7782 struct scarlett2_data *private = mixer->private_data;7783 int err = 0;7784 7785 mutex_lock(&private->data_mutex);7786 7787 if (private->power_status_updated) {7788 err = scarlett2_update_power_status(mixer);7789 if (err < 0)7790 goto unlock;7791 }7792 ucontrol->value.integer.value[0] = private->power_status;7793 7794unlock:7795 mutex_unlock(&private->data_mutex);7796 return err;7797}7798 7799static int scarlett2_power_status_ctl_info(7800 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)7801{7802 static const char *const values[3] = {7803 "External", "Bus", "Fail"7804 };7805 7806 return snd_ctl_enum_info(uinfo, 1, 3, values);7807}7808 7809static const struct snd_kcontrol_new scarlett2_power_status_ctl = {7810 .iface = SNDRV_CTL_ELEM_IFACE_CARD,7811 .access = SNDRV_CTL_ELEM_ACCESS_READ,7812 .name = "",7813 .info = scarlett2_power_status_ctl_info,7814 .get = scarlett2_power_status_ctl_get,7815};7816 7817static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer)7818{7819 struct scarlett2_data *private = mixer->private_data;7820 7821 if (!scarlett2_has_config_item(private,7822 SCARLETT2_CONFIG_POWER_EXT))7823 return 0;7824 7825 /* Add power status control */7826 return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl,7827 0, 1, "Power Status Card Enum",7828 &private->power_status_ctl);7829}7830 7831/*** Bluetooth Volume ***/7832 7833static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer)7834{7835 struct scarlett2_data *private = mixer->private_data;7836 int err;7837 7838 private->bluetooth_updated = 0;7839 7840 if (!private->info->has_bluetooth)7841 return 0;7842 7843 err = scarlett2_usb_get_config(mixer,7844 SCARLETT2_CONFIG_BLUETOOTH_VOLUME,7845 1, &private->bluetooth_volume);7846 if (err < 0)7847 return err;7848 7849 return 0;7850}7851 7852static int scarlett2_bluetooth_volume_ctl_get(struct snd_kcontrol *kctl,7853 struct snd_ctl_elem_value *ucontrol)7854{7855 struct usb_mixer_elem_info *elem = kctl->private_data;7856 struct usb_mixer_interface *mixer = elem->head.mixer;7857 struct scarlett2_data *private = mixer->private_data;7858 int err = 0;7859 7860 mutex_lock(&private->data_mutex);7861 7862 if (private->hwdep_in_use) {7863 err = -EBUSY;7864 goto unlock;7865 }7866 7867 if (private->bluetooth_updated) {7868 err = scarlett2_update_bluetooth_volume(mixer);7869 if (err < 0)7870 goto unlock;7871 }7872 ucontrol->value.integer.value[0] = private->bluetooth_volume;7873 7874unlock:7875 mutex_unlock(&private->data_mutex);7876 return err;7877}7878 7879static int scarlett2_bluetooth_volume_ctl_put(struct snd_kcontrol *kctl,7880 struct snd_ctl_elem_value *ucontrol)7881{7882 struct usb_mixer_elem_info *elem = kctl->private_data;7883 struct usb_mixer_interface *mixer = elem->head.mixer;7884 struct scarlett2_data *private = mixer->private_data;7885 int oval, val, err = 0;7886 7887 mutex_lock(&private->data_mutex);7888 7889 if (private->hwdep_in_use) {7890 err = -EBUSY;7891 goto unlock;7892 }7893 7894 oval = private->bluetooth_volume;7895 val = clamp(ucontrol->value.integer.value[0],7896 0L, (long)SCARLETT2_MAX_BLUETOOTH_VOLUME);7897 7898 if (oval == val)7899 goto unlock;7900 7901 private->bluetooth_volume = val;7902 err = scarlett2_usb_set_config(mixer,7903 SCARLETT2_CONFIG_BLUETOOTH_VOLUME,7904 0, val);7905 if (err == 0)7906 err = 1;7907 7908unlock:7909 mutex_unlock(&private->data_mutex);7910 return err;7911}7912 7913static int scarlett2_bluetooth_volume_ctl_info(7914 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo)7915{7916 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;7917 uinfo->count = 1;7918 uinfo->value.integer.min = 0;7919 uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME;7920 uinfo->value.integer.step = 1;7921 return 0;7922}7923 7924static const struct snd_kcontrol_new scarlett2_bluetooth_volume_ctl = {7925 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,7926 .name = "",7927 .info = scarlett2_bluetooth_volume_ctl_info,7928 .get = scarlett2_bluetooth_volume_ctl_get,7929 .put = scarlett2_bluetooth_volume_ctl_put,7930};7931 7932static int scarlett2_add_bluetooth_volume_ctl(7933 struct usb_mixer_interface *mixer)7934{7935 struct scarlett2_data *private = mixer->private_data;7936 7937 if (!private->info->has_bluetooth)7938 return 0;7939 7940 /* Add Bluetooth volume control */7941 return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl,7942 0, 1, "Bluetooth Capture Volume",7943 &private->bluetooth_volume_ctl);7944}7945 7946/*** S/PDIF Mode Controls ***/7947 7948static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer)7949{7950 struct scarlett2_data *private = mixer->private_data;7951 int err, i;7952 u8 mode;7953 const u8 *mode_values = private->info->spdif_mode_values;7954 7955 if (!private->info->spdif_mode_control_name)7956 return 0;7957 7958 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE,7959 1, &mode);7960 if (err < 0)7961 return err;7962 7963 private->spdif_mode = 0;7964 7965 for (i = 0; *mode_values != 0xff; i++, mode_values++)7966 if (*mode_values == mode) {7967 private->spdif_mode = i;7968 break;7969 }7970 7971 return 0;7972}7973 7974static int scarlett2_spdif_mode_ctl_info(struct snd_kcontrol *kctl,7975 struct snd_ctl_elem_info *uinfo)7976{7977 struct usb_mixer_elem_info *elem = kctl->private_data;7978 struct scarlett2_data *private = elem->head.mixer->private_data;7979 const char * const *mode_texts = private->info->spdif_mode_texts;7980 int count = 0;7981 7982 while (*mode_texts++)7983 count++;7984 7985 return snd_ctl_enum_info(uinfo, 1, count,7986 private->info->spdif_mode_texts);7987}7988 7989static int scarlett2_spdif_mode_ctl_get(struct snd_kcontrol *kctl,7990 struct snd_ctl_elem_value *ucontrol)7991{7992 struct usb_mixer_elem_info *elem = kctl->private_data;7993 struct scarlett2_data *private = elem->head.mixer->private_data;7994 7995 ucontrol->value.enumerated.item[0] = private->spdif_mode;7996 return 0;7997}7998 7999static int scarlett2_spdif_mode_ctl_put(struct snd_kcontrol *kctl,8000 struct snd_ctl_elem_value *ucontrol)8001{8002 struct usb_mixer_elem_info *elem = kctl->private_data;8003 struct usb_mixer_interface *mixer = elem->head.mixer;8004 struct scarlett2_data *private = mixer->private_data;8005 int oval, val, err = 0;8006 int i;8007 8008 mutex_lock(&private->data_mutex);8009 8010 oval = private->spdif_mode;8011 val = ucontrol->value.enumerated.item[0];8012 8013 if (val < 0) {8014 err = -EINVAL;8015 goto unlock;8016 }8017 8018 for (i = 0; i <= val; i++)8019 if (private->info->spdif_mode_values[i] == 0xff) {8020 err = -EINVAL;8021 goto unlock;8022 }8023 8024 if (oval == val)8025 goto unlock;8026 8027 private->spdif_mode = val;8028 8029 err = scarlett2_usb_set_config(8030 mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0,8031 private->info->spdif_mode_values[val]);8032 if (!err)8033 err = 1;8034 8035unlock:8036 mutex_unlock(&private->data_mutex);8037 return err;8038}8039 8040static const struct snd_kcontrol_new scarlett2_spdif_mode_ctl = {8041 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,8042 .name = "",8043 .info = scarlett2_spdif_mode_ctl_info,8044 .get = scarlett2_spdif_mode_ctl_get,8045 .put = scarlett2_spdif_mode_ctl_put,8046};8047 8048static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer)8049{8050 struct scarlett2_data *private = mixer->private_data;8051 8052 if (!private->info->spdif_mode_control_name)8053 return 0;8054 8055 return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl,8056 0, 1,8057 private->info->spdif_mode_control_name,8058 NULL);8059}8060 8061/*** Notification Handlers ***/8062 8063/* Notify on sync change */8064static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)8065{8066 struct scarlett2_data *private = mixer->private_data;8067 8068 private->sync_updated = 1;8069 8070 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,8071 &private->sync_ctl->id);8072}8073 8074/* Notify on monitor change (Gen 2/3) */8075static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer)8076{8077 struct snd_card *card = mixer->chip->card;8078 struct scarlett2_data *private = mixer->private_data;8079 int i;8080 8081 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))8082 return;8083 8084 private->vol_updated = 1;8085 8086 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,8087 &private->master_vol_ctl->id);8088 8089 for (i = 0; i < private->num_line_out; i++)8090 if (private->vol_sw_hw_switch[line_out_remap(private, i)])8091 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8092 &private->vol_ctls[i]->id);8093}8094 8095/* Notify on volume change (Gen 4) */8096static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)8097{8098 struct scarlett2_data *private = mixer->private_data;8099 8100 private->vol_updated = 1;8101 8102 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,8103 &private->master_vol_ctl->id);8104 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,8105 &private->headphone_vol_ctl->id);8106}8107 8108/* Notify on dim/mute change */8109static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer)8110{8111 struct snd_card *card = mixer->chip->card;8112 struct scarlett2_data *private = mixer->private_data;8113 int i;8114 8115 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH))8116 return;8117 8118 private->dim_mute_updated = 1;8119 8120 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++)8121 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8122 &private->dim_mute_ctls[i]->id);8123 8124 for (i = 0; i < private->num_line_out; i++)8125 if (private->vol_sw_hw_switch[line_out_remap(private, i)])8126 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8127 &private->mute_ctls[i]->id);8128}8129 8130/* Notify on input level switch change */8131static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer)8132{8133 struct snd_card *card = mixer->chip->card;8134 struct scarlett2_data *private = mixer->private_data;8135 const struct scarlett2_device_info *info = private->info;8136 int i;8137 8138 private->input_level_updated = 1;8139 8140 for (i = 0; i < info->level_input_count; i++)8141 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8142 &private->level_ctls[i]->id);8143}8144 8145/* Notify on input pad switch change */8146static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer)8147{8148 struct snd_card *card = mixer->chip->card;8149 struct scarlett2_data *private = mixer->private_data;8150 const struct scarlett2_device_info *info = private->info;8151 int i;8152 8153 private->input_pad_updated = 1;8154 8155 for (i = 0; i < info->pad_input_count; i++)8156 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8157 &private->pad_ctls[i]->id);8158}8159 8160/* Notify on input air switch change */8161static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer)8162{8163 struct snd_card *card = mixer->chip->card;8164 struct scarlett2_data *private = mixer->private_data;8165 const struct scarlett2_device_info *info = private->info;8166 int i;8167 8168 private->input_air_updated = 1;8169 8170 for (i = 0; i < info->air_input_count; i++)8171 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8172 &private->air_ctls[i]->id);8173}8174 8175/* Notify on input DSP switch change */8176static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer)8177{8178 struct snd_card *card = mixer->chip->card;8179 struct scarlett2_data *private = mixer->private_data;8180 const struct scarlett2_device_info *info = private->info;8181 int i;8182 8183 private->input_dsp_updated = 1;8184 8185 for (i = 0; i < info->dsp_input_count; i++)8186 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8187 &private->dsp_ctls[i]->id);8188}8189 8190/* Notify on input mute switch change */8191static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer)8192{8193 struct snd_card *card = mixer->chip->card;8194 struct scarlett2_data *private = mixer->private_data;8195 const struct scarlett2_device_info *info = private->info;8196 int i;8197 8198 private->input_mute_updated = 1;8199 8200 for (i = 0; i < info->mute_input_count; i++)8201 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8202 &private->input_mute_ctls[i]->id);8203}8204 8205/* Notify on input phantom switch change */8206static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer)8207{8208 struct snd_card *card = mixer->chip->card;8209 struct scarlett2_data *private = mixer->private_data;8210 const struct scarlett2_device_info *info = private->info;8211 int i;8212 8213 private->input_phantom_updated = 1;8214 8215 for (i = 0; i < info->phantom_count; i++)8216 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8217 &private->phantom_ctls[i]->id);8218 8219 scarlett2_phantom_notify_access(mixer);8220}8221 8222/* Notify on "input other" change (level/pad/air/phantom) */8223static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer)8224{8225 scarlett2_notify_input_level(mixer);8226 scarlett2_notify_input_pad(mixer);8227 scarlett2_notify_input_air(mixer);8228 scarlett2_notify_input_phantom(mixer);8229}8230 8231/* Notify on input select change */8232static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer)8233{8234 struct snd_card *card = mixer->chip->card;8235 struct scarlett2_data *private = mixer->private_data;8236 const struct scarlett2_device_info *info = private->info;8237 int i;8238 8239 if (!scarlett2_has_config_item(private,8240 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH))8241 return;8242 8243 private->input_select_updated = 1;8244 8245 snd_ctl_notify(card,8246 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO,8247 &private->input_select_ctl->id);8248 8249 for (i = 0; i < info->gain_input_count / 2; i++)8250 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8251 &private->input_link_ctls[i]->id);8252}8253 8254/* Notify on input gain change */8255static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer)8256{8257 struct snd_card *card = mixer->chip->card;8258 struct scarlett2_data *private = mixer->private_data;8259 const struct scarlett2_device_info *info = private->info;8260 int i;8261 8262 if (!info->gain_input_count)8263 return;8264 8265 private->input_gain_updated = 1;8266 8267 for (i = 0; i < info->gain_input_count; i++)8268 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8269 &private->input_gain_ctls[i]->id);8270}8271 8272/* Notify on autogain change */8273static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer)8274{8275 struct snd_card *card = mixer->chip->card;8276 struct scarlett2_data *private = mixer->private_data;8277 const struct scarlett2_device_info *info = private->info;8278 int i;8279 8280 if (!info->gain_input_count)8281 return;8282 8283 private->autogain_updated = 1;8284 8285 for (i = 0; i < info->gain_input_count; i++) {8286 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8287 &private->autogain_ctls[i]->id);8288 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8289 &private->autogain_status_ctls[i]->id);8290 }8291 8292 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++)8293 if (scarlett2_has_config_item(private,8294 scarlett2_ag_target_configs[i]))8295 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO,8296 &private->ag_target_ctls[i]->id);8297 8298 scarlett2_autogain_notify_access(mixer);8299}8300 8301/* Notify on input safe switch change */8302static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer)8303{8304 struct snd_card *card = mixer->chip->card;8305 struct scarlett2_data *private = mixer->private_data;8306 const struct scarlett2_device_info *info = private->info;8307 int i;8308 8309 if (!info->safe_input_count)8310 return;8311 8312 private->input_safe_updated = 1;8313 8314 for (i = 0; i < info->safe_input_count; i++)8315 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8316 &private->safe_ctls[i]->id);8317}8318 8319/* Notify on "monitor other" change (speaker switching, talkback) */8320static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer)8321{8322 struct snd_card *card = mixer->chip->card;8323 struct scarlett2_data *private = mixer->private_data;8324 const struct scarlett2_device_info *info = private->info;8325 8326 private->monitor_other_updated = 1;8327 8328 if (info->has_speaker_switching)8329 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8330 &private->speaker_switching_ctl->id);8331 8332 if (info->has_talkback)8333 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8334 &private->talkback_ctl->id);8335 8336 /* if speaker switching was recently enabled or disabled,8337 * invalidate the dim/mute and mux enum controls8338 */8339 if (private->speaker_switching_switched) {8340 int i;8341 8342 scarlett2_notify_dim_mute(mixer);8343 8344 private->speaker_switching_switched = 0;8345 private->mux_updated = 1;8346 8347 for (i = 0; i < private->num_mux_dsts; i++)8348 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8349 &private->mux_ctls[i]->id);8350 }8351}8352 8353/* Notify on direct monitor switch change */8354static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer)8355{8356 struct snd_card *card = mixer->chip->card;8357 struct scarlett2_data *private = mixer->private_data;8358 int count = private->num_mix_in * private->num_mix_out;8359 int i;8360 8361 private->direct_monitor_updated = 1;8362 8363 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8364 &private->direct_monitor_ctl->id);8365 8366 if (!scarlett2_has_mixer(private))8367 return;8368 8369 private->mix_updated = 1;8370 8371 /* Notify of change to the mix controls */8372 for (i = 0; i < count; i++)8373 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8374 &private->mix_ctls[i]->id);8375}8376 8377/* Notify on power change */8378static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer)8379{8380 struct snd_card *card = mixer->chip->card;8381 struct scarlett2_data *private = mixer->private_data;8382 8383 private->power_status_updated = 1;8384 8385 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8386 &private->power_status_ctl->id);8387}8388 8389/* Notify on mux change */8390static void scarlett2_notify_mux(struct usb_mixer_interface *mixer)8391{8392 struct snd_card *card = mixer->chip->card;8393 struct scarlett2_data *private = mixer->private_data;8394 int i;8395 8396 private->mux_updated = 1;8397 8398 for (i = 0; i < private->num_mux_dsts; i++)8399 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8400 &private->mux_ctls[i]->id);8401}8402 8403/* Notify on PCM input switch change */8404static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer)8405{8406 struct snd_card *card = mixer->chip->card;8407 struct scarlett2_data *private = mixer->private_data;8408 8409 private->pcm_input_switch_updated = 1;8410 8411 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8412 &private->pcm_input_switch_ctl->id);8413 8414 scarlett2_notify_mux(mixer);8415}8416 8417/* Notify on Bluetooth change */8418static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer)8419{8420 struct snd_card *card = mixer->chip->card;8421 struct scarlett2_data *private = mixer->private_data;8422 8423 if (!private->info->has_bluetooth)8424 return;8425 8426 private->bluetooth_updated = 1;8427 8428 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE,8429 &private->bluetooth_volume_ctl->id);8430}8431 8432/* Handle acknowledgement that a command was received; let8433 * scarlett2_usb() know that it can proceed8434 */8435static void scarlett2_notify_ack(struct usb_mixer_interface *mixer)8436{8437 struct scarlett2_data *private = mixer->private_data;8438 8439 /* if running == 0, ignore ACKs */8440 if (private->running)8441 complete(&private->cmd_done);8442}8443 8444/* Interrupt callback */8445static void scarlett2_notify(struct urb *urb)8446{8447 struct usb_mixer_interface *mixer = urb->context;8448 int len = urb->actual_length;8449 int ustatus = urb->status;8450 u32 data;8451 struct scarlett2_data *private = mixer->private_data;8452 const struct scarlett2_notification *notifications =8453 private->config_set->notifications;8454 8455 if (ustatus != 0 || len != 8)8456 goto requeue;8457 8458 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);8459 8460 /* Ignore notifications except ACK during initialisation.8461 * ACK is 0x00000001 on every device.8462 */8463 if (private->running < 2)8464 data &= 1;8465 8466 while (data && notifications->mask) {8467 if (data & notifications->mask) {8468 data &= ~notifications->mask;8469 if (notifications->func)8470 notifications->func(mixer);8471 }8472 notifications++;8473 }8474 8475 if (data)8476 usb_audio_warn(mixer->chip,8477 "%s: Unhandled notification: 0x%08x\n",8478 __func__, data);8479 8480requeue:8481 if (ustatus != -ENOENT &&8482 ustatus != -ECONNRESET &&8483 ustatus != -ESHUTDOWN) {8484 urb->dev = mixer->chip->dev;8485 usb_submit_urb(urb, GFP_ATOMIC);8486 } else {8487 complete(&private->cmd_done);8488 }8489}8490 8491/*** Cleanup/Suspend Callbacks ***/8492 8493static void scarlett2_private_free(struct usb_mixer_interface *mixer)8494{8495 struct scarlett2_data *private = mixer->private_data;8496 8497 cancel_delayed_work_sync(&private->work);8498 kfree(private);8499 mixer->private_data = NULL;8500}8501 8502static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)8503{8504 struct scarlett2_data *private = mixer->private_data;8505 8506 if (cancel_delayed_work_sync(&private->work))8507 scarlett2_config_save(private->mixer);8508}8509 8510/*** Initialisation ***/8511 8512static void scarlett2_count_io(struct scarlett2_data *private)8513{8514 const struct scarlett2_device_info *info = private->info;8515 const struct scarlett2_config_set *config_set = info->config_set;8516 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;8517 int port_type, srcs = 0, dsts = 0, i;8518 8519 /* Count the number of mux sources and destinations */8520 for (port_type = 0;8521 port_type < SCARLETT2_PORT_TYPE_COUNT;8522 port_type++) {8523 srcs += port_count[port_type][SCARLETT2_PORT_IN];8524 dsts += port_count[port_type][SCARLETT2_PORT_OUT];8525 }8526 8527 private->num_mux_srcs = srcs;8528 private->num_mux_dsts = dsts;8529 8530 /* Mixer inputs are mux outputs and vice versa.8531 * Scarlett Gen 4 DSP I/O uses SCARLETT2_PORT_TYPE_MIX but8532 * doesn't have mixer controls.8533 */8534 private->num_mix_in =8535 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -8536 info->dsp_count;8537 8538 private->num_mix_out =8539 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -8540 info->dsp_count;8541 8542 /* Number of analogue line outputs */8543 private->num_line_out =8544 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT];8545 8546 /* Number of monitor mix controls */8547 private->num_monitor_mix_ctls =8548 info->direct_monitor * 2 * private->num_mix_in;8549 8550 /* Number of autogain status texts */8551 if (config_set->autogain_status_texts) {8552 const char * const *texts = config_set->autogain_status_texts;8553 8554 for (i = 0; texts[i]; i++)8555 ;8556 private->num_autogain_status_texts = i;8557 }8558}8559 8560/* Look through the interface descriptors for the Focusrite Control8561 * interface (bInterfaceClass = 255 Vendor Specific Class) and set8562 * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval8563 * in private8564 */8565static int scarlett2_find_fc_interface(struct usb_device *dev,8566 struct scarlett2_data *private)8567{8568 struct usb_host_config *config = dev->actconfig;8569 int i;8570 8571 for (i = 0; i < config->desc.bNumInterfaces; i++) {8572 struct usb_interface *intf = config->interface[i];8573 struct usb_interface_descriptor *desc =8574 &intf->altsetting[0].desc;8575 struct usb_endpoint_descriptor *epd;8576 8577 if (desc->bInterfaceClass != 255)8578 continue;8579 8580 epd = get_endpoint(intf->altsetting, 0);8581 private->bInterfaceNumber = desc->bInterfaceNumber;8582 private->bEndpointAddress = epd->bEndpointAddress &8583 USB_ENDPOINT_NUMBER_MASK;8584 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);8585 private->bInterval = epd->bInterval;8586 return 0;8587 }8588 8589 return -EINVAL;8590}8591 8592/* Initialise private data */8593static int scarlett2_init_private(struct usb_mixer_interface *mixer,8594 const struct scarlett2_device_entry *entry)8595{8596 struct scarlett2_data *private =8597 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL);8598 8599 if (!private)8600 return -ENOMEM;8601 8602 mutex_init(&private->usb_mutex);8603 mutex_init(&private->data_mutex);8604 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);8605 8606 mixer->private_data = private;8607 mixer->private_free = scarlett2_private_free;8608 mixer->private_suspend = scarlett2_private_suspend;8609 8610 private->info = entry->info;8611 private->config_set = entry->info->config_set;8612 private->series_name = entry->series_name;8613 scarlett2_count_io(private);8614 private->scarlett2_seq = 0;8615 private->mixer = mixer;8616 8617 return scarlett2_find_fc_interface(mixer->chip->dev, private);8618}8619 8620/* Submit a URB to receive notifications from the device */8621static int scarlett2_init_notify(struct usb_mixer_interface *mixer)8622{8623 struct usb_device *dev = mixer->chip->dev;8624 struct scarlett2_data *private = mixer->private_data;8625 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);8626 void *transfer_buffer;8627 8628 if (mixer->urb) {8629 usb_audio_err(mixer->chip,8630 "%s: mixer urb already in use!\n", __func__);8631 return 0;8632 }8633 8634 if (usb_pipe_type_check(dev, pipe))8635 return -EINVAL;8636 8637 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);8638 if (!mixer->urb)8639 return -ENOMEM;8640 8641 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);8642 if (!transfer_buffer)8643 return -ENOMEM;8644 8645 usb_fill_int_urb(mixer->urb, dev, pipe,8646 transfer_buffer, private->wMaxPacketSize,8647 scarlett2_notify, mixer, private->bInterval);8648 8649 init_completion(&private->cmd_done);8650 8651 return usb_submit_urb(mixer->urb, GFP_KERNEL);8652}8653 8654/* Cargo cult proprietary initialisation sequence */8655static int scarlett2_usb_init(struct usb_mixer_interface *mixer)8656{8657 struct usb_device *dev = mixer->chip->dev;8658 struct scarlett2_data *private = mixer->private_data;8659 u8 step0_buf[24];8660 u8 step2_buf[84];8661 int err;8662 8663 if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0)))8664 return -EINVAL;8665 8666 /* step 0 */8667 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,8668 SCARLETT2_USB_CMD_INIT,8669 step0_buf, sizeof(step0_buf));8670 if (err < 0)8671 return err;8672 8673 /* Set up the interrupt polling for notifications.8674 * When running is:8675 * 0: all notifications are ignored8676 * 1: only ACKs are handled8677 * 2: all notifications are handled8678 */8679 err = scarlett2_init_notify(mixer);8680 if (err < 0)8681 return err;8682 8683 /* sleep for a moment in case of an outstanding ACK */8684 msleep(20);8685 8686 /* start handling ACKs, but no other notifications until the8687 * ALSA controls have been created8688 */8689 private->running = 1;8690 8691 /* step 1 */8692 private->scarlett2_seq = 1;8693 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);8694 if (err < 0)8695 return err;8696 8697 /* step 2 */8698 private->scarlett2_seq = 1;8699 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,8700 NULL, 0,8701 step2_buf, sizeof(step2_buf));8702 if (err < 0)8703 return err;8704 8705 /* extract 4-byte firmware version from step2_buf[8] */8706 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));8707 usb_audio_info(mixer->chip,8708 "Firmware version %d\n",8709 private->firmware_version);8710 8711 return 0;8712}8713 8714/* Get the flash segment numbers for the App_Settings and App_Upgrade8715 * segments and put them in the private data8716 */8717static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer)8718{8719 struct scarlett2_data *private = mixer->private_data;8720 int err, count, i;8721 8722 struct {8723 __le32 size;8724 __le32 count;8725 u8 unknown[8];8726 } __packed flash_info;8727 8728 struct {8729 __le32 size;8730 __le32 flags;8731 char name[16];8732 } __packed segment_info;8733 8734 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH,8735 NULL, 0,8736 &flash_info, sizeof(flash_info));8737 if (err < 0)8738 return err;8739 8740 count = le32_to_cpu(flash_info.count);8741 8742 /* sanity check count */8743 if (count < SCARLETT2_SEGMENT_NUM_MIN ||8744 count > SCARLETT2_SEGMENT_NUM_MAX + 1) {8745 usb_audio_err(mixer->chip,8746 "invalid flash segment count: %d\n", count);8747 return -EINVAL;8748 }8749 8750 for (i = 0; i < count; i++) {8751 __le32 segment_num_req = cpu_to_le32(i);8752 int flash_segment_id;8753 8754 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,8755 &segment_num_req, sizeof(segment_num_req),8756 &segment_info, sizeof(segment_info));8757 if (err < 0) {8758 usb_audio_err(mixer->chip,8759 "failed to get flash segment info %d: %d\n",8760 i, err);8761 return err;8762 }8763 8764 if (!strncmp(segment_info.name,8765 SCARLETT2_SEGMENT_SETTINGS_NAME, 16))8766 flash_segment_id = SCARLETT2_SEGMENT_ID_SETTINGS;8767 else if (!strncmp(segment_info.name,8768 SCARLETT2_SEGMENT_FIRMWARE_NAME, 16))8769 flash_segment_id = SCARLETT2_SEGMENT_ID_FIRMWARE;8770 else8771 continue;8772 8773 private->flash_segment_nums[flash_segment_id] = i;8774 private->flash_segment_blocks[flash_segment_id] =8775 le32_to_cpu(segment_info.size) /8776 SCARLETT2_FLASH_BLOCK_SIZE;8777 }8778 8779 /* segment 0 is App_Gold and we never want to touch that, so8780 * use 0 as the "not-found" value8781 */8782 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {8783 usb_audio_err(mixer->chip,8784 "failed to find flash segment %s\n",8785 SCARLETT2_SEGMENT_SETTINGS_NAME);8786 return -EINVAL;8787 }8788 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {8789 usb_audio_err(mixer->chip,8790 "failed to find flash segment %s\n",8791 SCARLETT2_SEGMENT_FIRMWARE_NAME);8792 return -EINVAL;8793 }8794 8795 return 0;8796}8797 8798/* Read configuration from the interface on start */8799static int scarlett2_read_configs(struct usb_mixer_interface *mixer)8800{8801 struct scarlett2_data *private = mixer->private_data;8802 const struct scarlett2_device_info *info = private->info;8803 int err, i;8804 8805 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) {8806 err = scarlett2_usb_get_config(8807 mixer, SCARLETT2_CONFIG_MSD_SWITCH,8808 1, &private->msd_switch);8809 if (err < 0)8810 return err;8811 }8812 8813 if (private->firmware_version < info->min_firmware_version) {8814 usb_audio_err(mixer->chip,8815 "Focusrite %s firmware version %d is too old; "8816 "need %d",8817 private->series_name,8818 private->firmware_version,8819 info->min_firmware_version);8820 return 0;8821 }8822 8823 /* no other controls are created if MSD mode is on */8824 if (private->msd_switch)8825 return 0;8826 8827 err = scarlett2_update_input_level(mixer);8828 if (err < 0)8829 return err;8830 8831 err = scarlett2_update_input_pad(mixer);8832 if (err < 0)8833 return err;8834 8835 err = scarlett2_update_input_air(mixer);8836 if (err < 0)8837 return err;8838 8839 err = scarlett2_update_input_dsp(mixer);8840 if (err < 0)8841 return err;8842 8843 err = scarlett2_update_compressor_values(mixer);8844 if (err < 0)8845 return err;8846 8847 err = scarlett2_update_filter_values(mixer);8848 if (err < 0)8849 return err;8850 8851 err = scarlett2_update_input_mute(mixer);8852 if (err < 0)8853 return err;8854 8855 err = scarlett2_update_input_phantom(mixer);8856 if (err < 0)8857 return err;8858 8859 err = scarlett2_update_direct_monitor(mixer);8860 if (err < 0)8861 return err;8862 8863 /* the rest of the configuration is for devices with a mixer */8864 if (!scarlett2_has_mixer(private))8865 return 0;8866 8867 err = scarlett2_update_monitor_mix(mixer);8868 if (err < 0)8869 return err;8870 8871 err = scarlett2_update_monitor_other(mixer);8872 if (err < 0)8873 return err;8874 8875 if (scarlett2_has_config_item(private,8876 SCARLETT2_CONFIG_STANDALONE_SWITCH)) {8877 err = scarlett2_usb_get_config(8878 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,8879 1, &private->standalone_switch);8880 if (err < 0)8881 return err;8882 }8883 8884 if (scarlett2_has_config_item(private,8885 SCARLETT2_CONFIG_POWER_EXT)) {8886 err = scarlett2_update_power_status(mixer);8887 if (err < 0)8888 return err;8889 }8890 8891 err = scarlett2_update_sync(mixer);8892 if (err < 0)8893 return err;8894 8895 if (scarlett2_has_config_item(private,8896 SCARLETT2_CONFIG_LINE_OUT_VOLUME)) {8897 s16 sw_vol[SCARLETT2_ANALOGUE_MAX];8898 8899 /* read SW line out volume */8900 err = scarlett2_usb_get_config(8901 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,8902 private->num_line_out, &sw_vol);8903 if (err < 0)8904 return err;8905 8906 for (i = 0; i < private->num_line_out; i++)8907 private->vol[i] = clamp(8908 sw_vol[i] + SCARLETT2_VOLUME_BIAS,8909 0, SCARLETT2_VOLUME_BIAS);8910 8911 /* read SW mute */8912 err = scarlett2_usb_get_config(8913 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,8914 private->num_line_out, &private->mute_switch);8915 if (err < 0)8916 return err;8917 8918 for (i = 0; i < private->num_line_out; i++)8919 private->mute_switch[i] =8920 !!private->mute_switch[i];8921 8922 /* read SW/HW switches */8923 if (scarlett2_has_config_item(private,8924 SCARLETT2_CONFIG_SW_HW_SWITCH)) {8925 err = scarlett2_usb_get_config(8926 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,8927 private->num_line_out,8928 &private->vol_sw_hw_switch);8929 if (err < 0)8930 return err;8931 8932 for (i = 0; i < private->num_line_out; i++)8933 private->vol_sw_hw_switch[i] =8934 !!private->vol_sw_hw_switch[i];8935 }8936 }8937 8938 err = scarlett2_update_volumes(mixer);8939 if (err < 0)8940 return err;8941 8942 err = scarlett2_update_dim_mute(mixer);8943 if (err < 0)8944 return err;8945 8946 err = scarlett2_update_input_select(mixer);8947 if (err < 0)8948 return err;8949 8950 err = scarlett2_update_input_gain(mixer);8951 if (err < 0)8952 return err;8953 8954 err = scarlett2_update_autogain(mixer);8955 if (err < 0)8956 return err;8957 8958 err = scarlett2_update_input_safe(mixer);8959 if (err < 0)8960 return err;8961 8962 if (scarlett2_has_config_item(private,8963 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) {8964 err = scarlett2_update_pcm_input_switch(mixer);8965 if (err < 0)8966 return err;8967 }8968 8969 err = scarlett2_update_bluetooth_volume(mixer);8970 if (err < 0)8971 return err;8972 8973 err = scarlett2_update_spdif_mode(mixer);8974 if (err < 0)8975 return err;8976 8977 err = scarlett2_update_mix(mixer);8978 if (err < 0)8979 return err;8980 8981 return scarlett2_usb_get_mux(mixer);8982}8983 8984static const struct scarlett2_device_entry *get_scarlett2_device_entry(8985 struct usb_mixer_interface *mixer)8986{8987 const struct scarlett2_device_entry *entry = scarlett2_devices;8988 8989 /* Find entry in scarlett2_devices */8990 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)8991 entry++;8992 if (!entry->usb_id)8993 return NULL;8994 8995 return entry;8996}8997 8998static int snd_scarlett2_controls_create(8999 struct usb_mixer_interface *mixer,9000 const struct scarlett2_device_entry *entry)9001{9002 struct scarlett2_data *private;9003 int err;9004 9005 /* Initialise private data */9006 err = scarlett2_init_private(mixer, entry);9007 if (err < 0)9008 return err;9009 9010 private = mixer->private_data;9011 9012 /* Send proprietary USB initialisation sequence */9013 err = scarlett2_usb_init(mixer);9014 if (err < 0)9015 return err;9016 9017 /* Get the upgrade & settings flash segment numbers */9018 err = scarlett2_get_flash_segment_nums(mixer);9019 if (err < 0)9020 return err;9021 9022 /* Add firmware version control */9023 err = scarlett2_add_firmware_version_ctl(mixer);9024 if (err < 0)9025 return err;9026 9027 /* Add minimum firmware version control */9028 err = scarlett2_add_min_firmware_version_ctl(mixer);9029 if (err < 0)9030 return err;9031 9032 /* Read volume levels and controls from the interface */9033 err = scarlett2_read_configs(mixer);9034 if (err < 0)9035 return err;9036 9037 /* Create the MSD control */9038 err = scarlett2_add_msd_ctl(mixer);9039 if (err < 0)9040 return err;9041 9042 /* If MSD mode is enabled, or if the firmware version is too9043 * old, don't create any other controls9044 */9045 if (private->msd_switch ||9046 private->firmware_version < private->info->min_firmware_version)9047 return 0;9048 9049 /* Create the analogue output controls */9050 err = scarlett2_add_line_out_ctls(mixer);9051 if (err < 0)9052 return err;9053 9054 /* Create the analogue input controls */9055 err = scarlett2_add_line_in_ctls(mixer);9056 if (err < 0)9057 return err;9058 9059 /* Create the input, output, and mixer mux input selections */9060 err = scarlett2_add_mux_enums(mixer);9061 if (err < 0)9062 return err;9063 9064 /* Create the matrix mixer controls */9065 err = scarlett2_add_mixer_ctls(mixer);9066 if (err < 0)9067 return err;9068 9069 /* Create the level meter controls */9070 err = scarlett2_add_meter_ctl(mixer);9071 if (err < 0)9072 return err;9073 9074 /* Create the sync control */9075 err = scarlett2_add_sync_ctl(mixer);9076 if (err < 0)9077 return err;9078 9079 /* Create the direct monitor control(s) */9080 err = scarlett2_add_direct_monitor_ctls(mixer);9081 if (err < 0)9082 return err;9083 9084 /* Create the speaker switching control */9085 err = scarlett2_add_speaker_switch_ctl(mixer);9086 if (err < 0)9087 return err;9088 9089 /* Create the talkback controls */9090 err = scarlett2_add_talkback_ctls(mixer);9091 if (err < 0)9092 return err;9093 9094 /* Create the standalone control */9095 err = scarlett2_add_standalone_ctl(mixer);9096 if (err < 0)9097 return err;9098 9099 /* Create the power status control */9100 err = scarlett2_add_power_status_ctl(mixer);9101 if (err < 0)9102 return err;9103 9104 /* Create the Bluetooth volume control */9105 err = scarlett2_add_bluetooth_volume_ctl(mixer);9106 if (err < 0)9107 return err;9108 9109 /* Create the S/PDIF mode control */9110 err = scarlett2_add_spdif_mode_ctl(mixer);9111 if (err < 0)9112 return err;9113 9114 /* Set the access mode of controls disabled during9115 * autogain/phantom power switching.9116 */9117 if (private->info->gain_input_count) {9118 scarlett2_autogain_update_access(mixer);9119 scarlett2_phantom_update_access(mixer);9120 }9121 9122 /* Start handling all notifications */9123 private->running = 2;9124 9125 return 0;9126}9127 9128/*** hwdep interface ***/9129 9130/* Set private->hwdep_in_use; prevents access to the ALSA controls9131 * while doing a config erase/firmware upgrade.9132 */9133static void scarlett2_lock(struct scarlett2_data *private)9134{9135 mutex_lock(&private->data_mutex);9136 private->hwdep_in_use = 1;9137 mutex_unlock(&private->data_mutex);9138}9139 9140/* Call SCARLETT2_USB_GET_ERASE to get the erase progress */9141static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)9142{9143 struct scarlett2_data *private = mixer->private_data;9144 int segment_id, segment_num, err;9145 u8 erase_resp;9146 9147 struct {9148 __le32 segment_num;9149 __le32 pad;9150 } __packed erase_req;9151 9152 segment_id = private->selected_flash_segment_id;9153 segment_num = private->flash_segment_nums[segment_id];9154 9155 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||9156 segment_num > SCARLETT2_SEGMENT_NUM_MAX)9157 return -EFAULT;9158 9159 /* Send the erase progress request */9160 erase_req.segment_num = cpu_to_le32(segment_num);9161 erase_req.pad = 0;9162 9163 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,9164 &erase_req, sizeof(erase_req),9165 &erase_resp, sizeof(erase_resp));9166 if (err < 0)9167 return err;9168 9169 return erase_resp;9170}9171 9172/* Repeatedly call scarlett2_get_erase_progress() until it returns9173 * 0xff (erase complete) or we've waited 10 seconds (it usually takes9174 * <3 seconds).9175 */9176static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer)9177{9178 int i, err;9179 9180 for (i = 0; i < 100; i++) {9181 err = scarlett2_get_erase_progress(mixer);9182 if (err < 0)9183 return err;9184 9185 if (err == 0xff)9186 return 0;9187 9188 msleep(100);9189 }9190 9191 return -ETIMEDOUT;9192}9193 9194/* Reboot the device; wait for the erase to complete if one is in9195 * progress.9196 */9197static int scarlett2_reboot(struct usb_mixer_interface *mixer)9198{9199 struct scarlett2_data *private = mixer->private_data;9200 9201 if (private->flash_write_state ==9202 SCARLETT2_FLASH_WRITE_STATE_ERASING) {9203 int err = scarlett2_wait_for_erase(mixer);9204 9205 if (err < 0)9206 return err;9207 }9208 9209 return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0);9210}9211 9212/* Select a flash segment for reading/erasing/writing */9213static int scarlett2_ioctl_select_flash_segment(9214 struct usb_mixer_interface *mixer,9215 unsigned long arg)9216{9217 struct scarlett2_data *private = mixer->private_data;9218 int segment_id, segment_num;9219 9220 if (get_user(segment_id, (int __user *)arg))9221 return -EFAULT;9222 9223 /* Check the segment ID and segment number */9224 if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT)9225 return -EINVAL;9226 9227 segment_num = private->flash_segment_nums[segment_id];9228 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||9229 segment_num > SCARLETT2_SEGMENT_NUM_MAX) {9230 usb_audio_err(mixer->chip,9231 "%s: invalid segment number %d\n",9232 __func__, segment_id);9233 return -EFAULT;9234 }9235 9236 /* If erasing, wait for it to complete */9237 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {9238 int err = scarlett2_wait_for_erase(mixer);9239 9240 if (err < 0)9241 return err;9242 }9243 9244 /* Save the selected segment ID and set the state to SELECTED */9245 private->selected_flash_segment_id = segment_id;9246 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;9247 9248 return 0;9249}9250 9251/* Erase the previously-selected flash segment */9252static int scarlett2_ioctl_erase_flash_segment(9253 struct usb_mixer_interface *mixer)9254{9255 struct scarlett2_data *private = mixer->private_data;9256 int segment_id, segment_num, err;9257 9258 struct {9259 __le32 segment_num;9260 __le32 pad;9261 } __packed erase_req;9262 9263 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)9264 return -EINVAL;9265 9266 segment_id = private->selected_flash_segment_id;9267 segment_num = private->flash_segment_nums[segment_id];9268 9269 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||9270 segment_num > SCARLETT2_SEGMENT_NUM_MAX)9271 return -EFAULT;9272 9273 /* Prevent access to ALSA controls that access the device from9274 * here on9275 */9276 scarlett2_lock(private);9277 9278 /* Send the erase request */9279 erase_req.segment_num = cpu_to_le32(segment_num);9280 erase_req.pad = 0;9281 9282 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,9283 &erase_req, sizeof(erase_req),9284 NULL, 0);9285 if (err < 0)9286 return err;9287 9288 /* On success, change the state from SELECTED to ERASING */9289 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;9290 9291 return 0;9292}9293 9294/* Get the erase progress from the device */9295static int scarlett2_ioctl_get_erase_progress(9296 struct usb_mixer_interface *mixer,9297 unsigned long arg)9298{9299 struct scarlett2_data *private = mixer->private_data;9300 struct scarlett2_flash_segment_erase_progress progress;9301 int segment_id, segment_num, err;9302 u8 erase_resp;9303 9304 struct {9305 __le32 segment_num;9306 __le32 pad;9307 } __packed erase_req;9308 9309 /* Check that we're erasing */9310 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)9311 return -EINVAL;9312 9313 segment_id = private->selected_flash_segment_id;9314 segment_num = private->flash_segment_nums[segment_id];9315 9316 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||9317 segment_num > SCARLETT2_SEGMENT_NUM_MAX)9318 return -EFAULT;9319 9320 /* Send the erase progress request */9321 erase_req.segment_num = cpu_to_le32(segment_num);9322 erase_req.pad = 0;9323 9324 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,9325 &erase_req, sizeof(erase_req),9326 &erase_resp, sizeof(erase_resp));9327 if (err < 0)9328 return err;9329 9330 progress.progress = erase_resp;9331 progress.num_blocks = private->flash_segment_blocks[segment_id];9332 9333 if (copy_to_user((void __user *)arg, &progress, sizeof(progress)))9334 return -EFAULT;9335 9336 /* If the erase is complete, change the state from ERASING to9337 * WRITE.9338 */9339 if (progress.progress == 0xff)9340 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;9341 9342 return 0;9343}9344 9345static int scarlett2_hwdep_open(struct snd_hwdep *hw, struct file *file)9346{9347 struct usb_mixer_interface *mixer = hw->private_data;9348 struct scarlett2_data *private = mixer->private_data;9349 9350 /* If erasing, wait for it to complete */9351 if (private->flash_write_state ==9352 SCARLETT2_FLASH_WRITE_STATE_ERASING) {9353 int err = scarlett2_wait_for_erase(mixer);9354 9355 if (err < 0)9356 return err;9357 }9358 9359 /* Set the state to IDLE */9360 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;9361 9362 return 0;9363}9364 9365static int scarlett2_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,9366 unsigned int cmd, unsigned long arg)9367{9368 struct usb_mixer_interface *mixer = hw->private_data;9369 9370 switch (cmd) {9371 9372 case SCARLETT2_IOCTL_PVERSION:9373 return put_user(SCARLETT2_HWDEP_VERSION,9374 (int __user *)arg) ? -EFAULT : 0;9375 9376 case SCARLETT2_IOCTL_REBOOT:9377 return scarlett2_reboot(mixer);9378 9379 case SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT:9380 return scarlett2_ioctl_select_flash_segment(mixer, arg);9381 9382 case SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT:9383 return scarlett2_ioctl_erase_flash_segment(mixer);9384 9385 case SCARLETT2_IOCTL_GET_ERASE_PROGRESS:9386 return scarlett2_ioctl_get_erase_progress(mixer, arg);9387 9388 default:9389 return -ENOIOCTLCMD;9390 }9391}9392 9393static long scarlett2_hwdep_read(struct snd_hwdep *hw,9394 char __user *buf,9395 long count, loff_t *offset)9396{9397 struct usb_mixer_interface *mixer = hw->private_data;9398 struct scarlett2_data *private = mixer->private_data;9399 int segment_id, segment_num, err;9400 int flash_size;9401 9402 /* SCARLETT2_USB_READ_SEGMENT request data */9403 struct {9404 __le32 segment_num;9405 __le32 offset;9406 __le32 len;9407 } __packed req;9408 9409 u8 *resp;9410 9411 /* Flash segment must first be selected */9412 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)9413 return -EINVAL;9414 9415 /* Get the selected flash segment number */9416 segment_id = private->selected_flash_segment_id;9417 if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT)9418 return -EINVAL;9419 9420 segment_num = private->flash_segment_nums[segment_id];9421 if (segment_num < 0 ||9422 segment_num > SCARLETT2_SEGMENT_NUM_MAX)9423 return -EFAULT;9424 9425 /* Validate the offset and count */9426 if (count < 0 || *offset < 0)9427 return -EINVAL;9428 9429 /* Reached EOF? */9430 flash_size = private->flash_segment_blocks[segment_id] *9431 SCARLETT2_FLASH_BLOCK_SIZE;9432 if (!count || *offset >= flash_size)9433 return 0;9434 9435 /* Limit the numbers of bytes read to SCARLETT2_FLASH_RW_MAX */9436 if (count > SCARLETT2_FLASH_RW_MAX)9437 count = SCARLETT2_FLASH_RW_MAX;9438 9439 /* Limit read to EOF */9440 if (*offset + count >= flash_size)9441 count = flash_size - *offset;9442 9443 /* Create and send the request */9444 req.segment_num = cpu_to_le32(segment_num);9445 req.offset = cpu_to_le32(*offset);9446 req.len = cpu_to_le32(count);9447 9448 resp = kzalloc(count, GFP_KERNEL);9449 if (!resp)9450 return -ENOMEM;9451 9452 err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT,9453 &req, sizeof(req), resp, count);9454 if (err < 0)9455 goto error;9456 9457 /* Copy the response to userspace */9458 if (copy_to_user(buf, resp, count)) {9459 err = -EFAULT;9460 goto error;9461 }9462 9463 *offset += count;9464 err = count;9465 9466error:9467 kfree(resp);9468 return err;9469}9470 9471static long scarlett2_hwdep_write(struct snd_hwdep *hw,9472 const char __user *buf,9473 long count, loff_t *offset)9474{9475 struct usb_mixer_interface *mixer = hw->private_data;9476 struct scarlett2_data *private = mixer->private_data;9477 int segment_id, segment_num, err, len;9478 int flash_size;9479 9480 /* SCARLETT2_USB_WRITE_SEGMENT request data */9481 struct {9482 __le32 segment_num;9483 __le32 offset;9484 __le32 pad;9485 u8 data[];9486 } __packed *req;9487 9488 /* Calculate the maximum permitted in data[] */9489 const size_t max_data_size = SCARLETT2_FLASH_RW_MAX -9490 offsetof(typeof(*req), data);9491 9492 /* If erasing, wait for it to complete */9493 if (private->flash_write_state ==9494 SCARLETT2_FLASH_WRITE_STATE_ERASING) {9495 err = scarlett2_wait_for_erase(mixer);9496 if (err < 0)9497 return err;9498 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;9499 9500 /* Check that an erase has been done & completed */9501 } else if (private->flash_write_state !=9502 SCARLETT2_FLASH_WRITE_STATE_WRITE) {9503 return -EINVAL;9504 }9505 9506 /* Check that we're writing to the upgrade firmware */9507 segment_id = private->selected_flash_segment_id;9508 if (segment_id != SCARLETT2_SEGMENT_ID_FIRMWARE)9509 return -EINVAL;9510 9511 segment_num = private->flash_segment_nums[segment_id];9512 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN ||9513 segment_num > SCARLETT2_SEGMENT_NUM_MAX)9514 return -EFAULT;9515 9516 /* Validate the offset and count */9517 flash_size = private->flash_segment_blocks[segment_id] *9518 SCARLETT2_FLASH_BLOCK_SIZE;9519 9520 if (count < 0 || *offset < 0 || *offset + count >= flash_size)9521 return -EINVAL;9522 9523 if (!count)9524 return 0;9525 9526 /* Limit the *req size to SCARLETT2_FLASH_RW_MAX */9527 if (count > max_data_size)9528 count = max_data_size;9529 9530 /* Create and send the request */9531 len = struct_size(req, data, count);9532 req = kzalloc(len, GFP_KERNEL);9533 if (!req)9534 return -ENOMEM;9535 9536 req->segment_num = cpu_to_le32(segment_num);9537 req->offset = cpu_to_le32(*offset);9538 req->pad = 0;9539 9540 if (copy_from_user(req->data, buf, count)) {9541 err = -EFAULT;9542 goto error;9543 }9544 9545 err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT,9546 req, len, NULL, 0);9547 if (err < 0)9548 goto error;9549 9550 *offset += count;9551 err = count;9552 9553error:9554 kfree(req);9555 return err;9556}9557 9558static int scarlett2_hwdep_release(struct snd_hwdep *hw, struct file *file)9559{9560 struct usb_mixer_interface *mixer = hw->private_data;9561 struct scarlett2_data *private = mixer->private_data;9562 9563 /* Return from the SELECTED or WRITE state to IDLE.9564 * The ERASING state is left as-is, and checked on next open.9565 */9566 if (private &&9567 private->hwdep_in_use &&9568 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)9569 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;9570 9571 return 0;9572}9573 9574static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer)9575{9576 struct snd_hwdep *hw;9577 int err;9578 9579 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);9580 if (err < 0)9581 return err;9582 9583 hw->private_data = mixer;9584 hw->exclusive = 1;9585 hw->ops.open = scarlett2_hwdep_open;9586 hw->ops.ioctl = scarlett2_hwdep_ioctl;9587 hw->ops.read = scarlett2_hwdep_read;9588 hw->ops.write = scarlett2_hwdep_write;9589 hw->ops.release = scarlett2_hwdep_release;9590 9591 return 0;9592}9593 9594int snd_scarlett2_init(struct usb_mixer_interface *mixer)9595{9596 struct snd_usb_audio *chip = mixer->chip;9597 const struct scarlett2_device_entry *entry;9598 int err;9599 9600 /* only use UAC_VERSION_2 */9601 if (!mixer->protocol)9602 return 0;9603 9604 /* find entry in scarlett2_devices */9605 entry = get_scarlett2_device_entry(mixer);9606 if (!entry) {9607 usb_audio_err(mixer->chip,9608 "%s: missing device entry for %04x:%04x\n",9609 __func__,9610 USB_ID_VENDOR(chip->usb_id),9611 USB_ID_PRODUCT(chip->usb_id));9612 return 0;9613 }9614 9615 if (chip->setup & SCARLETT2_DISABLE) {9616 usb_audio_info(chip,9617 "Focusrite %s Mixer Driver disabled "9618 "by modprobe options (snd_usb_audio "9619 "vid=0x%04x pid=0x%04x device_setup=%d)\n",9620 entry->series_name,9621 USB_ID_VENDOR(chip->usb_id),9622 USB_ID_PRODUCT(chip->usb_id),9623 SCARLETT2_DISABLE);9624 return 0;9625 }9626 9627 usb_audio_info(chip,9628 "Focusrite %s Mixer Driver enabled (pid=0x%04x); "9629 "report any issues to "9630 "https://github.com/geoffreybennett/scarlett-gen2/issues",9631 entry->series_name,9632 USB_ID_PRODUCT(chip->usb_id));9633 9634 err = snd_scarlett2_controls_create(mixer, entry);9635 if (err < 0) {9636 usb_audio_err(mixer->chip,9637 "Error initialising %s Mixer Driver: %d",9638 entry->series_name,9639 err);9640 return err;9641 }9642 9643 err = scarlett2_hwdep_init(mixer);9644 if (err < 0)9645 usb_audio_err(mixer->chip,9646 "Error creating %s hwdep device: %d",9647 entry->series_name,9648 err);9649 9650 return err;9651}9652