1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Focusrite Scarlett 2 Protocol Driver for ALSA 4 * (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and 5 * Clarett+ series products) 6 * 7 * Supported models: 8 * - 6i6/18i8/18i20 Gen 2 9 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3 10 * - Solo/2i2/4i4 Gen 4 11 * - Clarett 2Pre/4Pre/8Pre USB 12 * - Clarett+ 2Pre/4Pre/8Pre 13 * 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 Hoffmann 21 * 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 by 26 * 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 communication 34 * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20 35 * (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 Wittmann 40 * for providing usbmon output and testing). 41 * 42 * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent 43 * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6 44 * usbmon output and testing). 45 * 46 * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to 47 * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon 48 * output, protocol traces and testing). 49 * 50 * Support for loading mixer volume and mux configuration from the 51 * interface during driver initialisation added in May 2021 (thanks to 52 * Vladimir Sadovnikov for figuring out how). 53 * 54 * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander 55 * 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 Christian 61 * Colglazier. 62 * 63 * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe 64 * Perrot for confirmation). 65 * 66 * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to 67 * Gregory Rozzo for donating a 4Pre, and David Sherwood and Patrice 68 * 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 (thanks 75 * to many LinuxMusicians people and to Focusrite for hardware 76 * donations). 77 * 78 * This ALSA mixer gives access to (model-dependent): 79 * - input, output, mixer-matrix muxes 80 * - mixer-matrix gain stages 81 * - gain/volume/mute controls 82 * - level meters 83 * - line/inst level, pad, and air controls 84 * - phantom power, direct monitor, speaker switching, and talkback 85 * controls 86 * - disable/enable MSD mode 87 * - disable/enable standalone mode 88 * - input mute, gain, autogain, safe mode 89 * - direct monitor mixes 90 * - compressor and EQ 91 * - Bluetooth volume 92 * 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 | |20chn 117 * | | | | 118 * | +----------/ | 119 * | | | 120 * v v v 121 * =========================== 122 * +---------------+ +--���------------+ 123 * \ Output Mux / \ Capture Mux / 124 * +---+---+---+ +-----+-----+ 125 * | | | 126 * 10chn| | |18chn 127 * | | | 128 * /--------------\ | | | /--------------\ 129 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in | 130 * | Hardware out | | \--------------/ 131 * \--------------/ | 132 * v 133 * +-------------+ Software gain per channel. 134 * | Master Gain |<-- 18i20 only: Switch per channel 135 * +------+------+ to select HW or SW gain control. 136 * | 137 * |10chn 138 * /--------------\ | 139 * | Analogue |<------/ 140 * | Hardware out | 141 * \--------------/ 142 * </ditaa> 143 * 144 * Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small 145 * disk with registration and driver download information is presented 146 * to the host. To access the full functionality of the device without 147 * proprietary software, MSD mode can be disabled by: 148 * - holding down the 48V button for five seconds while powering on 149 * the device, or 150 * - using this driver and alsamixer to change the "MSD Mode" setting 151 * to Off and power-cycling the device 152 */ 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 0x02 172 173/* device_setup value to disable this mixer driver */ 174#define SCARLETT2_DISABLE 0x04 175 176/* some gui mixers can't handle negative ctl values */ 177#define SCARLETT2_VOLUME_BIAS 127 178 179/* maximum preamp input gain value 180 * (the corresponding value in dB is per-device) 181 */ 182#define SCARLETT2_MAX_GAIN_VALUE 70 183 184/* maximum Bluetooth volume value */ 185#define SCARLETT2_MAX_BLUETOOTH_VOLUME 30 186 187/* mixer range from -80dB to +12dB in 0.5dB steps */ 188#define SCARLETT2_MIXER_MIN_DB -80 189#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2) 190#define SCARLETT2_MIXER_MAX_DB 12 191#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 value 196 * 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, 32612 214}; 215 216/* Maximum number of analogue outputs */ 217#define SCARLETT2_ANALOGUE_MAX 10 218 219/* Maximum number of various input controls */ 220#define SCARLETT2_LEVEL_SWITCH_MAX 2 221#define SCARLETT2_PAD_SWITCH_MAX 8 222#define SCARLETT2_AIR_SWITCH_MAX 8 223#define SCARLETT2_DSP_SWITCH_MAX 2 224#define SCARLETT2_INPUT_MUTE_SWITCH_MAX 2 225#define SCARLETT2_PHANTOM_SWITCH_MAX 2 226#define SCARLETT2_INPUT_GAIN_MAX 2 227 228/* Maximum number of inputs to the mixer */ 229#define SCARLETT2_INPUT_MIX_MAX 25 230 231/* Maximum number of outputs from the mixer */ 232#define SCARLETT2_OUTPUT_MIX_MAX 12 233 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 controls 238 * 1 (Solo) or 2 (2i2) direct monitor selections (Mono & Stereo) 239 * 2 Mix outputs (A/Left & B/Right) 240 * 4 Mix inputs 241 */ 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 spare 246 */ 247#define SCARLETT2_MUX_MAX 77 248 249/* Maximum number of sources (sum of input port counts) */ 250#define SCARLETT2_MAX_SRCS 52 251 252/* Maximum number of meters (sum of output port counts) */ 253#define SCARLETT2_MAX_METERS 65 254 255/* Compressor parameter data 256 * 257 * The compressor parameters are 32-bit fixed point values with 24 258 * bits of fraction. Integer values are sufficient for the parameters 259 * 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, On 271 * - Threshold: -40dB to 0dB 272 * - Ratio: 1:1 to 50:1 in 0.5:1 steps 273 * - Knee Width: 0dB to 10dB 274 * - Attack: 30ms to 127ms 275 * - Release: 30ms to 127ms 276 * - Makeup Gain: 0dB to 24dB 277 */ 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 5 298 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 4 307 308/* Hardware port types: 309 * - None (no input to mux) 310 * - Analogue I/O 311 * - S/PDIF I/O 312 * - ADAT I/O 313 * - Mixer I/O 314 * - PCM I/O 315 */ 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_COUNT 324}; 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_DIRNS 331}; 332 333/* Dim/Mute buttons on the 18i20 */ 334enum { 335 SCARLETT2_BUTTON_MUTE, 336 SCARLETT2_BUTTON_DIM, 337 SCARLETT2_DIM_MUTE_COUNT 338}; 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_COUNT 349}; 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_WRITE 357}; 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 and 364 * 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 NULL 380}; 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 NULL 392}; 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_COUNT 400}; 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_COUNT 547}; 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_TARGET 555}; 556 557static const char *const scarlett2_ag_target_names[] = { 558 "Hot", "Mean", "Peak" 559}; 560 561/* Location, size, and activation command number for the configuration 562 * 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 certain 565 * configuration parameters. When pbuf is set, rather than writing to 566 * the given offset, the channel and value are written to the 567 * parameter buffer and the activate command is sent to the device. 568 * 569 * Some Gen 4 configuration parameters are written with 0x02 for a 570 * desired value of 0x01, and 0x03 for 0x00. These are indicated with 571 * mute set to 1. 0x02 and 0x03 are temporary values while the device 572 * makes the change and the channel and/or corresponding DSP channel 573 * 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 * 100 595); 596 597static const DECLARE_TLV_DB_MINMAX( 598 db_scale_gen4_gain, 0, 69 * 100 599); 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 type 993 * - src_descr: printf format string for mux input selections 994 * - src_num_offset: added to channel number for the fprintf 995 * - dst_descr: printf format string for mixer controls 996 */ 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 rates 1046 * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz) 1047 */ 1048#define SCARLETT2_MUX_TABLES 3 1049 1050/* Maximum number of entries in a mux table */ 1051#define SCARLETT2_MAX_MUX_ENTRIES 10 1052 1053/* One entry within mux_assignment defines the port type and range of 1054 * ports to add to the set_mux message. The end of the list is marked 1055 * 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 9 1065 1066/* One entry within meter_assignment defines the range of mux outputs 1067 * that consecutive meter entries are mapped to. The end of the list 1068 * 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 switchable 1089 * level control that can be set to line or instrument 1090 */ 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 switchable 1097 * 10dB pad control 1098 */ 1099 u8 pad_input_count; 1100 1101 /* the number of analogue inputs with a software switchable 1102 * "air" control 1103 */ 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 options 1110 * 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 switchable 1128 * mute control 1129 */ 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 options 1148 * (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" connected 1164 * internally to the analogue 7/8 outputs 1165 */ 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 by 1181 * SCARLETT2_USB_GET_METER to index into mux[] entries (same 1182 * 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 NULL 1605}; 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 NULL 1697}; 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 NULL 2068}; 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 0 2246#define SCARLETT2_USB_CMD_REQ 2 2247#define SCARLETT2_USB_CMD_RESP 3 2248 2249#define SCARLETT2_USB_INIT_1 0x00000000 2250#define SCARLETT2_USB_INIT_2 0x00000002 2251#define SCARLETT2_USB_REBOOT 0x00000003 2252#define SCARLETT2_USB_GET_METER 0x00001001 2253#define SCARLETT2_USB_GET_MIX 0x00002001 2254#define SCARLETT2_USB_SET_MIX 0x00002002 2255#define SCARLETT2_USB_GET_MUX 0x00003001 2256#define SCARLETT2_USB_SET_MUX 0x00003002 2257#define SCARLETT2_USB_INFO_FLASH 0x00004000 2258#define SCARLETT2_USB_INFO_SEGMENT 0x00004001 2259#define SCARLETT2_USB_ERASE_SEGMENT 0x00004002 2260#define SCARLETT2_USB_GET_ERASE 0x00004003 2261#define SCARLETT2_USB_WRITE_SEGMENT 0x00004004 2262#define SCARLETT2_USB_READ_SEGMENT 0x00004005 2263#define SCARLETT2_USB_GET_SYNC 0x00006004 2264#define SCARLETT2_USB_GET_DATA 0x00800000 2265#define SCARLETT2_USB_SET_DATA 0x00800001 2266#define SCARLETT2_USB_DATA_CMD 0x00800002 2267 2268#define SCARLETT2_USB_CONFIG_SAVE 6 2269 2270#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1 2271 2272#define SCARLETT2_FLASH_BLOCK_SIZE 4096 2273#define SCARLETT2_FLASH_RW_MAX 1024 2274#define SCARLETT2_SEGMENT_NUM_MIN 1 2275#define SCARLETT2_SEGMENT_NUM_MAX 4 2276 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 a 2389 * reboot request 2390 */ 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 initialising 2406 * seq sent = 1, response = 0 2407 */ 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 the 2457 * 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 the 2478 * configuration set used by this device 2479 */ 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 space 2521 * 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 space 2543 * size: size in bytes of each value (1, 2, 4) 2544 * count: number of values 2545 */ 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 have 2591 * been uploaded by a previous SCARLETT2_USB_SET_DATA. 2592 * The value for activate needed is determined by the configuration 2593 * 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 the 2618 * configuration set used by this device 2619 */ 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 NVRAM 2646 * save and support bit-modification 2647 */ 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 and 2653 * calculate offset 2654 */ 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 the 2660 * bit as needed, and update value 2661 */ 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 else 2675 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 a 2691 * separate save step 2692 */ 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 with 2704 * multiple values 2705 */ 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 the 2718 * configuration set used by this device 2719 */ 2720 if (!config_item->offset) 2721 return -EFAULT; 2722 2723 /* Convert config_item->size in bits to size in bytes and 2724 * calculate offset 2725 */ 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) * 2 2787 * (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 mix 2800 * 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 mix 2834 * (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 map 2938 * 2939 * The meter level data from the interface (SCARLETT2_USB_GET_METER 2940 * request) is returned in mux_assignment order, but to avoid exposing 2941 * that to userspace, scarlett2_meter_ctl_get() rearranges the data 2942 * into scarlett2_ports order using the meter_level_map[] array which 2943 * is set up by this function. 2944 * 2945 * In addition, the meter level data values returned from the 2946 * interface are invalid for destinations where: 2947 * 2948 * - the source is "Off"; therefore we set those values to zero (map 2949 * value of 255) 2950 * 2951 * - the source is assigned to a previous (with respect to the 2952 * mux_assignment order) destination; therefore we set those values 2953 * to the value previously reported for that source 2954 */ 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 destination 2961 * value is 255 for None, otherwise the value of i 2962 * (index into array returned by 2963 * 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_out 2987 ) ? info->line_out_unmap[mux_idx] 2988 : mux_idx; 2989 2990 /* check which source is connected, and if 2991 * that source is already connected elsewhere, 2992 * use that existing connection's destination 2993 * for this meter entry instead 2994 */ 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 bits 3084 * for the destination and next 12 bits for 3085 * the source 3086 */ 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 the 3136 * current/next state. This won't have any effect on values which are 3137 * 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 code 3161 * 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_get 3219}; 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_get 3258}; 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 status 3270 * has changed 3271 */ 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_get 3322}; 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) or 3343 * 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 else 3350 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 into 3391 * autogain_status. 3392 * 3393 * When autogain_switch[] is set, the status is the first 3394 * element in scarlett2_autogain_status_texts[] (Running). The 3395 * subsequent elements correspond to the status value from the 3396 * device (raw_autogain_status[]) + 1. The last element is 3397 * "Invalid", in case the device reports a status outside the 3398 * 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 else 3408 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 while 3468 * 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() and 3516 * 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 a 3537 * 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_put 3696}; 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, 0 3809); 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 input 3958 * Linked inputs have one value for the pair 3959 */ 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 check 3995 * (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 device 4087 * Link for channels 1-2 is at index 1 4088 * No device yet has more than 2 channels linked 4089 */ 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_put 4106}; 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_put 4420}; 4421 4422/*** Analogue Line Out Volume Controls ***/ 4423 4424/* Update hardware volume controls after receiving notification that 4425 * they have changed 4426 */ 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, 0 4612); 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 index 5416 * field (param_buf_addr + 1); the value field isn't used in 5417 * 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 of 5608 * padding after peq_flt_count up to peq_flt_total_count 5609 */ 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 5617 for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) { 5618 src_idx = i * 5619 info->peq_flt_total_count * 5620 SCARLETT2_BIQUAD_COEFFS; 5621 for (j = 0; j < info->peq_flt_count; j++) 5622 for (k = 0; 5623 k < SCARLETT2_BIQUAD_COEFFS; 5624 k++, src_idx++, dst_idx++) 5625 private->peq_flt_values[dst_idx] = 5626 peq_flt_values[src_idx]; 5627 } 5628 5629 return 0; 5630} 5631 5632static int scarlett2_precomp_flt_ctl_get( 5633 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5634{ 5635 struct usb_mixer_elem_info *elem = kctl->private_data; 5636 struct scarlett2_data *private = elem->head.mixer->private_data; 5637 int i, idx; 5638 5639 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS; 5640 i < SCARLETT2_BIQUAD_COEFFS; 5641 i++, idx++) 5642 ucontrol->value.integer.value[i] = 5643 private->precomp_flt_values[idx]; 5644 5645 return 0; 5646} 5647 5648static int scarlett2_peq_flt_ctl_get( 5649 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5650{ 5651 struct usb_mixer_elem_info *elem = kctl->private_data; 5652 struct scarlett2_data *private = elem->head.mixer->private_data; 5653 int i, idx; 5654 5655 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS; 5656 i < SCARLETT2_BIQUAD_COEFFS; 5657 i++, idx++) 5658 ucontrol->value.integer.value[i] = 5659 private->peq_flt_values[idx]; 5660 5661 return 0; 5662} 5663 5664static int scarlett2_precomp_flt_ctl_put( 5665 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5666{ 5667 struct usb_mixer_elem_info *elem = kctl->private_data; 5668 struct usb_mixer_interface *mixer = elem->head.mixer; 5669 struct scarlett2_data *private = mixer->private_data; 5670 5671 int index = elem->control * SCARLETT2_BIQUAD_COEFFS; 5672 int i, oval, val, err; 5673 5674 mutex_lock(&private->data_mutex); 5675 5676 if (private->hwdep_in_use) { 5677 err = -EBUSY; 5678 goto unlock; 5679 } 5680 5681 err = scarlett2_check_put_during_autogain(mixer); 5682 if (err < 0) 5683 goto unlock; 5684 5685 /* Check if any of the values have changed; if not, return */ 5686 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) { 5687 oval = private->precomp_flt_values[index + i]; 5688 val = ucontrol->value.integer.value[i]; 5689 if (oval != val) 5690 break; 5691 } 5692 5693 if (i == SCARLETT2_BIQUAD_COEFFS) 5694 goto unlock; 5695 5696 /* Update the values */ 5697 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) 5698 private->precomp_flt_values[index + i] = 5699 ucontrol->value.integer.value[i]; 5700 5701 /* Send change to the device */ 5702 err = scarlett2_usb_set_data( 5703 mixer, private->config_set->param_buf_addr, 1, index); 5704 if (err < 0) 5705 goto unlock; 5706 5707 err = scarlett2_usb_set_config_buf( 5708 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS, 5709 index, SCARLETT2_BIQUAD_COEFFS, 5710 &private->precomp_flt_values[index]); 5711 5712 if (err == 0) 5713 err = 1; 5714 5715unlock: 5716 mutex_unlock(&private->data_mutex); 5717 return err; 5718} 5719 5720static int scarlett2_peq_flt_ctl_put( 5721 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5722{ 5723 struct usb_mixer_elem_info *elem = kctl->private_data; 5724 struct usb_mixer_interface *mixer = elem->head.mixer; 5725 struct scarlett2_data *private = mixer->private_data; 5726 const struct scarlett2_device_info *info = private->info; 5727 5728 int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS; 5729 int dst_index = ( 5730 elem->control / 5731 info->peq_flt_count * 5732 info->peq_flt_total_count + 5733 elem->control % info->peq_flt_count 5734 ) * SCARLETT2_BIQUAD_COEFFS; 5735 int i, oval, val, err; 5736 5737 mutex_lock(&private->data_mutex); 5738 5739 if (private->hwdep_in_use) { 5740 err = -EBUSY; 5741 goto unlock; 5742 } 5743 5744 err = scarlett2_check_put_during_autogain(mixer); 5745 if (err < 0) 5746 goto unlock; 5747 5748 /* Check if any of the values have changed; if not, return */ 5749 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) { 5750 oval = private->peq_flt_values[src_index + i]; 5751 val = ucontrol->value.integer.value[i]; 5752 if (oval != val) 5753 break; 5754 } 5755 5756 if (i == SCARLETT2_BIQUAD_COEFFS) 5757 goto unlock; 5758 5759 /* Update the values */ 5760 for (i = 0; i < SCARLETT2_BIQUAD_COEFFS; i++) 5761 private->peq_flt_values[src_index + i] = 5762 ucontrol->value.integer.value[i]; 5763 5764 /* Send change to the device */ 5765 err = scarlett2_usb_set_data( 5766 mixer, private->config_set->param_buf_addr, 1, dst_index); 5767 if (err < 0) 5768 goto unlock; 5769 5770 err = scarlett2_usb_set_config_buf( 5771 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS, 5772 dst_index, SCARLETT2_BIQUAD_COEFFS, 5773 &private->peq_flt_values[src_index]); 5774 5775 if (err == 0) 5776 err = 1; 5777 5778unlock: 5779 mutex_unlock(&private->data_mutex); 5780 return err; 5781} 5782 5783static int scarlett2_flt_ctl_info( 5784 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 5785{ 5786 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 5787 uinfo->count = SCARLETT2_BIQUAD_COEFFS; 5788 uinfo->value.integer.min = INT_MIN; 5789 uinfo->value.integer.max = INT_MAX; 5790 uinfo->value.integer.step = 1; 5791 return 0; 5792} 5793 5794static const struct snd_kcontrol_new scarlett2_precomp_flt_ctl = { 5795 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 5796 .name = "", 5797 .info = scarlett2_flt_ctl_info, 5798 .get = scarlett2_precomp_flt_ctl_get, 5799 .put = scarlett2_precomp_flt_ctl_put, 5800}; 5801 5802static const struct snd_kcontrol_new scarlett2_peq_flt_ctl = { 5803 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 5804 .name = "", 5805 .info = scarlett2_flt_ctl_info, 5806 .get = scarlett2_peq_flt_ctl_get, 5807 .put = scarlett2_peq_flt_ctl_put, 5808}; 5809 5810/*** Input Mute Switch Controls ***/ 5811 5812static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer) 5813{ 5814 struct scarlett2_data *private = mixer->private_data; 5815 const struct scarlett2_device_info *info = private->info; 5816 5817 private->input_mute_updated = 0; 5818 5819 if (!info->mute_input_count) 5820 return 0; 5821 5822 return scarlett2_usb_get_config( 5823 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH, 5824 info->mute_input_count, private->input_mute_switch); 5825} 5826 5827static int scarlett2_input_mute_ctl_get(struct snd_kcontrol *kctl, 5828 struct snd_ctl_elem_value *ucontrol) 5829{ 5830 struct usb_mixer_elem_info *elem = kctl->private_data; 5831 struct usb_mixer_interface *mixer = elem->head.mixer; 5832 struct scarlett2_data *private = mixer->private_data; 5833 int err = 0; 5834 5835 mutex_lock(&private->data_mutex); 5836 5837 if (private->hwdep_in_use) { 5838 err = -EBUSY; 5839 goto unlock; 5840 } 5841 5842 if (private->input_mute_updated) { 5843 err = scarlett2_update_input_mute(mixer); 5844 if (err < 0) 5845 goto unlock; 5846 } 5847 ucontrol->value.integer.value[0] = 5848 private->input_mute_switch[elem->control]; 5849 5850unlock: 5851 mutex_unlock(&private->data_mutex); 5852 return err; 5853} 5854 5855static int scarlett2_input_mute_ctl_put(struct snd_kcontrol *kctl, 5856 struct snd_ctl_elem_value *ucontrol) 5857{ 5858 struct usb_mixer_elem_info *elem = kctl->private_data; 5859 struct usb_mixer_interface *mixer = elem->head.mixer; 5860 struct scarlett2_data *private = mixer->private_data; 5861 5862 int index = elem->control; 5863 int oval, val, err; 5864 5865 mutex_lock(&private->data_mutex); 5866 5867 if (private->hwdep_in_use) { 5868 err = -EBUSY; 5869 goto unlock; 5870 } 5871 5872 err = scarlett2_check_put_during_autogain(mixer); 5873 if (err < 0) 5874 goto unlock; 5875 5876 oval = private->input_mute_switch[index]; 5877 val = ucontrol->value.integer.value[0]; 5878 5879 if (oval == val) 5880 goto unlock; 5881 5882 private->input_mute_switch[index] = val; 5883 5884 /* Send switch change to the device */ 5885 err = scarlett2_usb_set_config( 5886 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH, 5887 index, val); 5888 if (err == 0) 5889 err = 1; 5890 5891unlock: 5892 mutex_unlock(&private->data_mutex); 5893 return err; 5894} 5895 5896static const struct snd_kcontrol_new scarlett2_input_mute_ctl = { 5897 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5898 .name = "", 5899 .info = scarlett2_autogain_disables_ctl_info, 5900 .get = scarlett2_input_mute_ctl_get, 5901 .put = scarlett2_input_mute_ctl_put, 5902}; 5903 5904/*** Phantom Switch Controls ***/ 5905 5906static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer) 5907{ 5908 struct scarlett2_data *private = mixer->private_data; 5909 const struct scarlett2_device_info *info = private->info; 5910 int err; 5911 5912 private->input_phantom_updated = 0; 5913 5914 if (!info->phantom_count) 5915 return 0; 5916 5917 err = scarlett2_usb_get_config( 5918 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 5919 info->phantom_count, private->phantom_switch); 5920 if (err < 0) 5921 return err; 5922 5923 if (scarlett2_has_config_item(private, 5924 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) { 5925 err = scarlett2_usb_get_config( 5926 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, 5927 1, &private->phantom_persistence); 5928 if (err < 0) 5929 return err; 5930 } 5931 5932 return 0; 5933} 5934 5935/* Check if phantom power on the given input is currently changing state */ 5936static int scarlett2_phantom_is_switching( 5937 struct scarlett2_data *private, int line_num) 5938{ 5939 const struct scarlett2_device_info *info = private->info; 5940 int index = line_num / info->inputs_per_phantom; 5941 5942 return !!(private->phantom_switch[index] & 0x02); 5943} 5944 5945/* Update autogain controls' access mode when phantom power changes state */ 5946static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer) 5947{ 5948 struct scarlett2_data *private = mixer->private_data; 5949 const struct scarlett2_device_info *info = private->info; 5950 int i; 5951 5952 /* Disable autogain controls if phantom power is changing state */ 5953 for (i = 0; i < info->gain_input_count; i++) { 5954 int val = !scarlett2_phantom_is_switching(private, i); 5955 5956 scarlett2_set_ctl_access(private->autogain_ctls[i], val); 5957 } 5958} 5959 5960/* Notify of access mode change for autogain which can't be enabled 5961 * while phantom power is changing. 5962 */ 5963static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer) 5964{ 5965 struct snd_card *card = mixer->chip->card; 5966 struct scarlett2_data *private = mixer->private_data; 5967 const struct scarlett2_device_info *info = private->info; 5968 int i; 5969 5970 for (i = 0; i < info->gain_input_count; i++) 5971 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 5972 &private->autogain_ctls[i]->id); 5973} 5974 5975/* Call scarlett2_update_input_phantom() and 5976 * scarlett2_phantom_update_access() if input_phantom_updated is set. 5977 */ 5978static int scarlett2_check_input_phantom_updated( 5979 struct usb_mixer_interface *mixer) 5980{ 5981 struct scarlett2_data *private = mixer->private_data; 5982 int err; 5983 5984 if (!private->input_phantom_updated) 5985 return 0; 5986 5987 err = scarlett2_update_input_phantom(mixer); 5988 if (err < 0) 5989 return err; 5990 5991 scarlett2_phantom_update_access(mixer); 5992 5993 return 0; 5994} 5995 5996static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl, 5997 struct snd_ctl_elem_value *ucontrol) 5998{ 5999 struct usb_mixer_elem_info *elem = kctl->private_data; 6000 struct usb_mixer_interface *mixer = elem->head.mixer; 6001 struct scarlett2_data *private = mixer->private_data; 6002 int err; 6003 6004 mutex_lock(&private->data_mutex); 6005 6006 if (private->hwdep_in_use) { 6007 err = -EBUSY; 6008 goto unlock; 6009 } 6010 6011 err = scarlett2_check_input_phantom_updated(mixer); 6012 if (err < 0) 6013 goto unlock; 6014 6015 ucontrol->value.integer.value[0] = scarlett2_decode_muteable( 6016 private->phantom_switch[elem->control]); 6017 6018unlock: 6019 mutex_unlock(&private->data_mutex); 6020 return err; 6021} 6022 6023static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl, 6024 struct snd_ctl_elem_value *ucontrol) 6025{ 6026 struct usb_mixer_elem_info *elem = kctl->private_data; 6027 struct usb_mixer_interface *mixer = elem->head.mixer; 6028 struct scarlett2_data *private = mixer->private_data; 6029 const struct scarlett2_device_info *info = private->info; 6030 6031 int index = elem->control; 6032 int oval, val, err; 6033 6034 mutex_lock(&private->data_mutex); 6035 6036 if (private->hwdep_in_use) { 6037 err = -EBUSY; 6038 goto unlock; 6039 } 6040 6041 err = scarlett2_check_put_during_autogain(mixer); 6042 if (err < 0) 6043 goto unlock; 6044 6045 oval = private->phantom_switch[index]; 6046 val = !!ucontrol->value.integer.value[0]; 6047 6048 if (oval == val) 6049 goto unlock; 6050 6051 private->phantom_switch[index] = val; 6052 6053 /* To set the Gen 4 muteable controls, bit 1 gets set */ 6054 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute) 6055 val = (!val) | 0x02; 6056 6057 /* Send switch change to the device */ 6058 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 6059 index + info->phantom_first, val); 6060 if (err == 0) 6061 err = 1; 6062 6063 scarlett2_phantom_update_access(mixer); 6064 scarlett2_phantom_notify_access(mixer); 6065 6066unlock: 6067 mutex_unlock(&private->data_mutex); 6068 return err; 6069} 6070 6071static const struct snd_kcontrol_new scarlett2_phantom_ctl = { 6072 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6073 .name = "", 6074 .info = scarlett2_autogain_disables_ctl_info, 6075 .get = scarlett2_phantom_ctl_get, 6076 .put = scarlett2_phantom_ctl_put, 6077}; 6078 6079/*** Phantom Persistence Control ***/ 6080 6081static int scarlett2_phantom_persistence_ctl_get( 6082 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6083{ 6084 struct usb_mixer_elem_info *elem = kctl->private_data; 6085 struct scarlett2_data *private = elem->head.mixer->private_data; 6086 6087 ucontrol->value.integer.value[0] = private->phantom_persistence; 6088 return 0; 6089} 6090 6091static int scarlett2_phantom_persistence_ctl_put( 6092 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6093{ 6094 struct usb_mixer_elem_info *elem = kctl->private_data; 6095 struct usb_mixer_interface *mixer = elem->head.mixer; 6096 struct scarlett2_data *private = mixer->private_data; 6097 6098 int index = elem->control; 6099 int oval, val, err = 0; 6100 6101 mutex_lock(&private->data_mutex); 6102 6103 if (private->hwdep_in_use) { 6104 err = -EBUSY; 6105 goto unlock; 6106 } 6107 6108 oval = private->phantom_persistence; 6109 val = !!ucontrol->value.integer.value[0]; 6110 6111 if (oval == val) 6112 goto unlock; 6113 6114 private->phantom_persistence = val; 6115 6116 /* Send switch change to the device */ 6117 err = scarlett2_usb_set_config( 6118 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val); 6119 if (err == 0) 6120 err = 1; 6121 6122unlock: 6123 mutex_unlock(&private->data_mutex); 6124 return err; 6125} 6126 6127static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = { 6128 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6129 .name = "", 6130 .info = snd_ctl_boolean_mono_info, 6131 .get = scarlett2_phantom_persistence_ctl_get, 6132 .put = scarlett2_phantom_persistence_ctl_put, 6133}; 6134 6135/*** Speaker Switching Control ***/ 6136 6137static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer) 6138{ 6139 struct scarlett2_data *private = mixer->private_data; 6140 const struct scarlett2_device_info *info = private->info; 6141 int err; 6142 6143 /* monitor_other_enable[0] enables speaker switching 6144 * monitor_other_enable[1] enables talkback 6145 */ 6146 u8 monitor_other_enable[2]; 6147 6148 /* monitor_other_switch[0] activates the alternate speakers 6149 * monitor_other_switch[1] activates talkback 6150 */ 6151 u8 monitor_other_switch[2]; 6152 6153 private->monitor_other_updated = 0; 6154 6155 /* if it doesn't do speaker switching then it also doesn't do 6156 * talkback 6157 */ 6158 if (!info->has_speaker_switching) 6159 return 0; 6160 6161 err = scarlett2_usb_get_config( 6162 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 6163 2, monitor_other_enable); 6164 if (err < 0) 6165 return err; 6166 6167 err = scarlett2_usb_get_config( 6168 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 6169 2, monitor_other_switch); 6170 if (err < 0) 6171 return err; 6172 6173 if (!monitor_other_enable[0]) 6174 private->speaker_switching_switch = 0; 6175 else 6176 private->speaker_switching_switch = monitor_other_switch[0] + 1; 6177 6178 if (info->has_talkback) { 6179 u16 bitmap; 6180 int i; 6181 6182 if (!monitor_other_enable[1]) 6183 private->talkback_switch = 0; 6184 else 6185 private->talkback_switch = monitor_other_switch[1] + 1; 6186 6187 err = scarlett2_usb_get_config(mixer, 6188 SCARLETT2_CONFIG_TALKBACK_MAP, 6189 1, &bitmap); 6190 if (err < 0) 6191 return err; 6192 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1) 6193 private->talkback_map[i] = bitmap & 1; 6194 } 6195 6196 return 0; 6197} 6198 6199static int scarlett2_speaker_switch_enum_ctl_info( 6200 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 6201{ 6202 static const char *const values[3] = { 6203 "Off", "Main", "Alt" 6204 }; 6205 6206 return snd_ctl_enum_info(uinfo, 1, 3, values); 6207} 6208 6209static int scarlett2_speaker_switch_enum_ctl_get( 6210 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6211{ 6212 struct usb_mixer_elem_info *elem = kctl->private_data; 6213 struct usb_mixer_interface *mixer = elem->head.mixer; 6214 struct scarlett2_data *private = mixer->private_data; 6215 int err = 0; 6216 6217 mutex_lock(&private->data_mutex); 6218 6219 if (private->hwdep_in_use) { 6220 err = -EBUSY; 6221 goto unlock; 6222 } 6223 6224 if (private->monitor_other_updated) { 6225 err = scarlett2_update_monitor_other(mixer); 6226 if (err < 0) 6227 goto unlock; 6228 } 6229 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch; 6230 6231unlock: 6232 mutex_unlock(&private->data_mutex); 6233 return err; 6234} 6235 6236/* when speaker switching gets enabled, switch the main/alt speakers 6237 * to HW volume and disable those controls 6238 */ 6239static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer) 6240{ 6241 struct snd_card *card = mixer->chip->card; 6242 struct scarlett2_data *private = mixer->private_data; 6243 int i, err; 6244 6245 for (i = 0; i < 4; i++) { 6246 int index = line_out_remap(private, i); 6247 6248 /* switch the main/alt speakers to HW volume */ 6249 if (!private->vol_sw_hw_switch[index]) { 6250 err = scarlett2_sw_hw_change(private->mixer, i, 1); 6251 if (err < 0) 6252 return err; 6253 } 6254 6255 /* disable the line out SW/HW switch */ 6256 scarlett2_sw_hw_ctl_ro(private, i); 6257 snd_ctl_notify(card, 6258 SNDRV_CTL_EVENT_MASK_VALUE | 6259 SNDRV_CTL_EVENT_MASK_INFO, 6260 &private->sw_hw_ctls[i]->id); 6261 } 6262 6263 /* when the next monitor-other notify comes in, update the mux 6264 * configuration 6265 */ 6266 private->speaker_switching_switched = 1; 6267 6268 return 0; 6269} 6270 6271/* when speaker switching gets disabled, reenable the hw/sw controls 6272 * and invalidate the routing 6273 */ 6274static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer) 6275{ 6276 struct snd_card *card = mixer->chip->card; 6277 struct scarlett2_data *private = mixer->private_data; 6278 int i; 6279 6280 /* enable the line out SW/HW switch */ 6281 for (i = 0; i < 4; i++) { 6282 scarlett2_sw_hw_ctl_rw(private, i); 6283 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 6284 &private->sw_hw_ctls[i]->id); 6285 } 6286 6287 /* when the next monitor-other notify comes in, update the mux 6288 * configuration 6289 */ 6290 private->speaker_switching_switched = 1; 6291} 6292 6293static int scarlett2_speaker_switch_enum_ctl_put( 6294 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6295{ 6296 struct usb_mixer_elem_info *elem = kctl->private_data; 6297 struct usb_mixer_interface *mixer = elem->head.mixer; 6298 struct scarlett2_data *private = mixer->private_data; 6299 6300 int oval, val, err = 0; 6301 6302 mutex_lock(&private->data_mutex); 6303 6304 if (private->hwdep_in_use) { 6305 err = -EBUSY; 6306 goto unlock; 6307 } 6308 6309 oval = private->speaker_switching_switch; 6310 val = min(ucontrol->value.enumerated.item[0], 2U); 6311 6312 if (oval == val) 6313 goto unlock; 6314 6315 private->speaker_switching_switch = val; 6316 6317 /* enable/disable speaker switching */ 6318 err = scarlett2_usb_set_config( 6319 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 6320 0, !!val); 6321 if (err < 0) 6322 goto unlock; 6323 6324 /* if speaker switching is enabled, select main or alt */ 6325 err = scarlett2_usb_set_config( 6326 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 6327 0, val == 2); 6328 if (err < 0) 6329 goto unlock; 6330 6331 /* update controls if speaker switching gets enabled or disabled */ 6332 if (!oval && val) 6333 err = scarlett2_speaker_switch_enable(mixer); 6334 else if (oval && !val) 6335 scarlett2_speaker_switch_disable(mixer); 6336 6337 if (err == 0) 6338 err = 1; 6339 6340unlock: 6341 mutex_unlock(&private->data_mutex); 6342 return err; 6343} 6344 6345static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = { 6346 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6347 .name = "", 6348 .info = scarlett2_speaker_switch_enum_ctl_info, 6349 .get = scarlett2_speaker_switch_enum_ctl_get, 6350 .put = scarlett2_speaker_switch_enum_ctl_put, 6351}; 6352 6353static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer) 6354{ 6355 struct scarlett2_data *private = mixer->private_data; 6356 const struct scarlett2_device_info *info = private->info; 6357 6358 if (!info->has_speaker_switching) 6359 return 0; 6360 6361 return scarlett2_add_new_ctl( 6362 mixer, &scarlett2_speaker_switch_enum_ctl, 6363 0, 1, "Speaker Switching Playback Enum", 6364 &private->speaker_switching_ctl); 6365} 6366 6367/*** Talkback and Talkback Map Controls ***/ 6368 6369static int scarlett2_talkback_enum_ctl_info( 6370 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 6371{ 6372 static const char *const values[3] = { 6373 "Disabled", "Off", "On" 6374 }; 6375 6376 return snd_ctl_enum_info(uinfo, 1, 3, values); 6377} 6378 6379static int scarlett2_talkback_enum_ctl_get( 6380 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6381{ 6382 struct usb_mixer_elem_info *elem = kctl->private_data; 6383 struct usb_mixer_interface *mixer = elem->head.mixer; 6384 struct scarlett2_data *private = mixer->private_data; 6385 int err = 0; 6386 6387 mutex_lock(&private->data_mutex); 6388 6389 if (private->hwdep_in_use) { 6390 err = -EBUSY; 6391 goto unlock; 6392 } 6393 6394 if (private->monitor_other_updated) { 6395 err = scarlett2_update_monitor_other(mixer); 6396 if (err < 0) 6397 goto unlock; 6398 } 6399 ucontrol->value.enumerated.item[0] = private->talkback_switch; 6400 6401unlock: 6402 mutex_unlock(&private->data_mutex); 6403 return err; 6404} 6405 6406static int scarlett2_talkback_enum_ctl_put( 6407 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6408{ 6409 struct usb_mixer_elem_info *elem = kctl->private_data; 6410 struct usb_mixer_interface *mixer = elem->head.mixer; 6411 struct scarlett2_data *private = mixer->private_data; 6412 6413 int oval, val, err = 0; 6414 6415 mutex_lock(&private->data_mutex); 6416 6417 if (private->hwdep_in_use) { 6418 err = -EBUSY; 6419 goto unlock; 6420 } 6421 6422 oval = private->talkback_switch; 6423 val = min(ucontrol->value.enumerated.item[0], 2U); 6424 6425 if (oval == val) 6426 goto unlock; 6427 6428 private->talkback_switch = val; 6429 6430 /* enable/disable talkback */ 6431 err = scarlett2_usb_set_config( 6432 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 6433 1, !!val); 6434 if (err < 0) 6435 goto unlock; 6436 6437 /* if talkback is enabled, select main or alt */ 6438 err = scarlett2_usb_set_config( 6439 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 6440 1, val == 2); 6441 if (err == 0) 6442 err = 1; 6443 6444unlock: 6445 mutex_unlock(&private->data_mutex); 6446 return err; 6447} 6448 6449static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = { 6450 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6451 .name = "", 6452 .info = scarlett2_talkback_enum_ctl_info, 6453 .get = scarlett2_talkback_enum_ctl_get, 6454 .put = scarlett2_talkback_enum_ctl_put, 6455}; 6456 6457static int scarlett2_talkback_map_ctl_get( 6458 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6459{ 6460 struct usb_mixer_elem_info *elem = kctl->private_data; 6461 struct usb_mixer_interface *mixer = elem->head.mixer; 6462 struct scarlett2_data *private = mixer->private_data; 6463 int index = elem->control; 6464 6465 ucontrol->value.integer.value[0] = private->talkback_map[index]; 6466 6467 return 0; 6468} 6469 6470static int scarlett2_talkback_map_ctl_put( 6471 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 6472{ 6473 struct usb_mixer_elem_info *elem = kctl->private_data; 6474 struct usb_mixer_interface *mixer = elem->head.mixer; 6475 struct scarlett2_data *private = mixer->private_data; 6476 int index = elem->control; 6477 int oval, val, err = 0, i; 6478 u16 bitmap = 0; 6479 6480 mutex_lock(&private->data_mutex); 6481 6482 if (private->hwdep_in_use) { 6483 err = -EBUSY; 6484 goto unlock; 6485 } 6486 6487 oval = private->talkback_map[index]; 6488 val = !!ucontrol->value.integer.value[0]; 6489 6490 if (oval == val) 6491 goto unlock; 6492 6493 private->talkback_map[index] = val; 6494 6495 for (i = 0; i < private->num_mix_out; i++) 6496 bitmap |= private->talkback_map[i] << i; 6497 6498 /* Send updated bitmap to the device */ 6499 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP, 6500 0, bitmap); 6501 if (err == 0) 6502 err = 1; 6503 6504unlock: 6505 mutex_unlock(&private->data_mutex); 6506 return err; 6507} 6508 6509static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = { 6510 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6511 .name = "", 6512 .info = snd_ctl_boolean_mono_info, 6513 .get = scarlett2_talkback_map_ctl_get, 6514 .put = scarlett2_talkback_map_ctl_put, 6515}; 6516 6517static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer) 6518{ 6519 struct scarlett2_data *private = mixer->private_data; 6520 const struct scarlett2_device_info *info = private->info; 6521 int err, i; 6522 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 6523 6524 if (!info->has_talkback) 6525 return 0; 6526 6527 err = scarlett2_add_new_ctl( 6528 mixer, &scarlett2_talkback_enum_ctl, 6529 0, 1, "Talkback Playback Enum", 6530 &private->talkback_ctl); 6531 if (err < 0) 6532 return err; 6533 6534 for (i = 0; i < private->num_mix_out; i++) { 6535 snprintf(s, sizeof(s), 6536 "Talkback Mix %c Playback Switch", i + 'A'); 6537 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl, 6538 i, 1, s, NULL); 6539 if (err < 0) 6540 return err; 6541 } 6542 6543 return 0; 6544} 6545 6546/*** Dim/Mute Controls ***/ 6547 6548static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl, 6549 struct snd_ctl_elem_value *ucontrol) 6550{ 6551 struct usb_mixer_elem_info *elem = kctl->private_data; 6552 struct usb_mixer_interface *mixer = elem->head.mixer; 6553 struct scarlett2_data *private = mixer->private_data; 6554 int err = 0; 6555 6556 mutex_lock(&private->data_mutex); 6557 6558 if (private->hwdep_in_use) { 6559 err = -EBUSY; 6560 goto unlock; 6561 } 6562 6563 if (private->dim_mute_updated) { 6564 err = scarlett2_update_dim_mute(mixer); 6565 if (err < 0) 6566 goto unlock; 6567 } 6568 ucontrol->value.integer.value[0] = private->dim_mute[elem->control]; 6569 6570unlock: 6571 mutex_unlock(&private->data_mutex); 6572 return err; 6573} 6574 6575static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl, 6576 struct snd_ctl_elem_value *ucontrol) 6577{ 6578 struct usb_mixer_elem_info *elem = kctl->private_data; 6579 struct usb_mixer_interface *mixer = elem->head.mixer; 6580 struct scarlett2_data *private = mixer->private_data; 6581 int index = elem->control; 6582 int oval, val, err = 0, i; 6583 6584 mutex_lock(&private->data_mutex); 6585 6586 if (private->hwdep_in_use) { 6587 err = -EBUSY; 6588 goto unlock; 6589 } 6590 6591 oval = private->dim_mute[index]; 6592 val = !!ucontrol->value.integer.value[0]; 6593 6594 if (oval == val) 6595 goto unlock; 6596 6597 private->dim_mute[index] = val; 6598 6599 /* Send switch change to the device */ 6600 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE, 6601 index, val); 6602 if (err == 0) 6603 err = 1; 6604 6605 if (index == SCARLETT2_BUTTON_MUTE) 6606 for (i = 0; i < private->num_line_out; i++) { 6607 int line_index = line_out_remap(private, i); 6608 6609 if (private->vol_sw_hw_switch[line_index]) { 6610 private->mute_switch[line_index] = val; 6611 snd_ctl_notify(mixer->chip->card, 6612 SNDRV_CTL_EVENT_MASK_VALUE, 6613 &private->mute_ctls[i]->id); 6614 } 6615 } 6616 6617unlock: 6618 mutex_unlock(&private->data_mutex); 6619 return err; 6620} 6621 6622static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = { 6623 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6624 .name = "", 6625 .info = snd_ctl_boolean_mono_info, 6626 .get = scarlett2_dim_mute_ctl_get, 6627 .put = scarlett2_dim_mute_ctl_put 6628}; 6629 6630/*** Create the analogue output controls ***/ 6631 6632static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer) 6633{ 6634 struct scarlett2_data *private = mixer->private_data; 6635 const struct scarlett2_device_info *info = private->info; 6636 int err, i; 6637 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 6638 6639 /* Add R/O HW volume control */ 6640 if (scarlett2_has_config_item(private, 6641 SCARLETT2_CONFIG_MASTER_VOLUME)) { 6642 snprintf(s, sizeof(s), "Master HW Playback Volume"); 6643 err = scarlett2_add_new_ctl(mixer, 6644 &scarlett2_master_volume_ctl, 6645 0, 1, s, &private->master_vol_ctl); 6646 if (err < 0) 6647 return err; 6648 } 6649 6650 /* Add R/O headphone volume control */ 6651 if (scarlett2_has_config_item(private, 6652 SCARLETT2_CONFIG_HEADPHONE_VOLUME)) { 6653 snprintf(s, sizeof(s), "Headphone Playback Volume"); 6654 err = scarlett2_add_new_ctl(mixer, 6655 &scarlett2_headphone_volume_ctl, 6656 0, 1, s, 6657 &private->headphone_vol_ctl); 6658 if (err < 0) 6659 return err; 6660 } 6661 6662 /* Remaining controls are only applicable if the device 6663 * has per-channel line-out volume controls. 6664 */ 6665 if (!scarlett2_has_config_item(private, 6666 SCARLETT2_CONFIG_LINE_OUT_VOLUME)) 6667 return 0; 6668 6669 /* Add volume controls */ 6670 for (i = 0; i < private->num_line_out; i++) { 6671 int index = line_out_remap(private, i); 6672 6673 /* Fader */ 6674 if (info->line_out_descrs[i]) 6675 snprintf(s, sizeof(s), 6676 "Line %02d (%s) Playback Volume", 6677 i + 1, info->line_out_descrs[i]); 6678 else 6679 snprintf(s, sizeof(s), 6680 "Line %02d Playback Volume", 6681 i + 1); 6682 err = scarlett2_add_new_ctl(mixer, 6683 &scarlett2_line_out_volume_ctl, 6684 i, 1, s, &private->vol_ctls[i]); 6685 if (err < 0) 6686 return err; 6687 6688 /* Mute Switch */ 6689 snprintf(s, sizeof(s), 6690 "Line %02d Mute Playback Switch", 6691 i + 1); 6692 err = scarlett2_add_new_ctl(mixer, 6693 &scarlett2_mute_ctl, 6694 i, 1, s, 6695 &private->mute_ctls[i]); 6696 if (err < 0) 6697 return err; 6698 6699 /* SW/HW Switch */ 6700 if (scarlett2_has_config_item(private, 6701 SCARLETT2_CONFIG_SW_HW_SWITCH)) { 6702 6703 /* Make the fader and mute controls read-only if the 6704 * SW/HW switch is set to HW 6705 */ 6706 if (private->vol_sw_hw_switch[index]) 6707 scarlett2_vol_ctl_set_writable(mixer, i, 0); 6708 6709 scnprintf(s, sizeof(s), 6710 "Line Out %02d Volume Control Playback Enum", 6711 i + 1); 6712 err = scarlett2_add_new_ctl(mixer, 6713 &scarlett2_sw_hw_enum_ctl, 6714 i, 1, s, 6715 &private->sw_hw_ctls[i]); 6716 if (err < 0) 6717 return err; 6718 6719 /* Make the switch read-only if the line is 6720 * involved in speaker switching 6721 */ 6722 if (private->speaker_switching_switch && i < 4) 6723 scarlett2_sw_hw_ctl_ro(private, i); 6724 } 6725 } 6726 6727 /* Add dim/mute controls */ 6728 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_DIM_MUTE)) 6729 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) { 6730 err = scarlett2_add_new_ctl( 6731 mixer, &scarlett2_dim_mute_ctl, 6732 i, 1, scarlett2_dim_mute_names[i], 6733 &private->dim_mute_ctls[i]); 6734 if (err < 0) 6735 return err; 6736 } 6737 6738 return 0; 6739} 6740 6741/*** Create the analogue input controls ***/ 6742 6743static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i) 6744{ 6745 struct scarlett2_data *private = mixer->private_data; 6746 const struct scarlett2_device_info *info = private->info; 6747 int j, err; 6748 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 6749 const char *compr_fmt = "Line In %d Compressor %s"; 6750 const char *flt_switch_fmt = "Line In %d %s Filter Enable"; 6751 const char *flt_fmt = "Line In %d %s Coefficients %d"; 6752 6753 /* Add compressor controls */ 6754 for (j = 0; j < SCARLETT2_COMPRESSOR_PARAM_COUNT; j++) { 6755 const struct compressor_param *param = &compressor_params[j]; 6756 int idx = i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j; 6757 6758 scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name); 6759 err = scarlett2_add_new_ctl( 6760 mixer, &scarlett2_compressor_ctl, 6761 i * SCARLETT2_COMPRESSOR_PARAM_COUNT + j, 6762 1, s, &private->compressor_ctls[idx]); 6763 if (err < 0) 6764 return err; 6765 } 6766 6767 /* Add filter enable controls */ 6768 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp"); 6769 err = scarlett2_add_new_ctl( 6770 mixer, &scarlett2_precomp_flt_switch_ctl, 6771 i, 1, s, &private->precomp_flt_switch_ctls[i]); 6772 if (err < 0) 6773 return err; 6774 6775 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "PEQ"); 6776 err = scarlett2_add_new_ctl( 6777 mixer, &scarlett2_peq_flt_switch_ctl, 6778 i, 1, s, &private->peq_flt_switch_ctls[i]); 6779 if (err < 0) 6780 return err; 6781 6782 /* Add filter coefficient controls */ 6783 for (j = 0; j < info->precomp_flt_count; j++) { 6784 scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1); 6785 err = scarlett2_add_new_ctl( 6786 mixer, &scarlett2_precomp_flt_ctl, 6787 i * info->precomp_flt_count + j, 6788 1, s, &private->precomp_flt_switch_ctls[j]); 6789 if (err < 0) 6790 return err; 6791 } 6792 6793 for (j = 0; j < info->peq_flt_count; j++) { 6794 scnprintf(s, sizeof(s), flt_fmt, i + 1, "PEQ", j + 1); 6795 err = scarlett2_add_new_ctl( 6796 mixer, &scarlett2_peq_flt_ctl, 6797 i * info->peq_flt_count + j, 6798 1, s, &private->peq_flt_switch_ctls[j]); 6799 if (err < 0) 6800 return err; 6801 } 6802 6803 return 0; 6804} 6805 6806static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer) 6807{ 6808 struct scarlett2_data *private = mixer->private_data; 6809 const struct scarlett2_device_info *info = private->info; 6810 int err, i; 6811 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 6812 const char *fmt = "Line In %d %s Capture %s"; 6813 const char *fmt2 = "Line In %d-%d %s Capture %s"; 6814 6815 /* Add input level (line/inst) controls */ 6816 for (i = 0; i < info->level_input_count; i++) { 6817 scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first, 6818 "Level", "Enum"); 6819 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl, 6820 i, 1, s, &private->level_ctls[i]); 6821 if (err < 0) 6822 return err; 6823 } 6824 6825 /* Add input pad controls */ 6826 for (i = 0; i < info->pad_input_count; i++) { 6827 scnprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch"); 6828 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl, 6829 i, 1, s, &private->pad_ctls[i]); 6830 if (err < 0) 6831 return err; 6832 } 6833 6834 /* Add input air controls */ 6835 for (i = 0; i < info->air_input_count; i++) { 6836 scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first, 6837 "Air", info->air_option ? "Enum" : "Switch"); 6838 err = scarlett2_add_new_ctl( 6839 mixer, &scarlett2_air_ctl[info->air_option], 6840 i, 1, s, &private->air_ctls[i]); 6841 if (err < 0) 6842 return err; 6843 } 6844 6845 /* Add input DSP controls */ 6846 for (i = 0; i < info->dsp_input_count; i++) { 6847 scnprintf(s, sizeof(s), fmt, i + 1, "DSP", "Switch"); 6848 err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl, 6849 i, 1, s, &private->dsp_ctls[i]); 6850 if (err < 0) 6851 return err; 6852 6853 err = scarlett2_add_dsp_ctls(mixer, i); 6854 if (err < 0) 6855 return err; 6856 } 6857 6858 /* Add input mute controls */ 6859 for (i = 0; i < info->mute_input_count; i++) { 6860 scnprintf(s, sizeof(s), fmt, i + 1, "Mute", "Switch"); 6861 err = scarlett2_add_new_ctl( 6862 mixer, &scarlett2_input_mute_ctl, 6863 i, 1, s, &private->input_mute_ctls[i]); 6864 if (err < 0) 6865 return err; 6866 } 6867 6868 /* Add input phantom controls */ 6869 if (info->inputs_per_phantom == 1) { 6870 for (i = 0; i < info->phantom_count; i++) { 6871 scnprintf(s, sizeof(s), fmt, 6872 i + 1 + info->phantom_first, 6873 "Phantom Power", "Switch"); 6874 err = scarlett2_add_new_ctl( 6875 mixer, &scarlett2_phantom_ctl, 6876 i, 1, s, &private->phantom_ctls[i]); 6877 if (err < 0) 6878 return err; 6879 } 6880 } else if (info->inputs_per_phantom > 1) { 6881 for (i = 0; i < info->phantom_count; i++) { 6882 int from = i * info->inputs_per_phantom + 1; 6883 int to = (i + 1) * info->inputs_per_phantom; 6884 6885 scnprintf(s, sizeof(s), fmt2, from, to, 6886 "Phantom Power", "Switch"); 6887 err = scarlett2_add_new_ctl( 6888 mixer, &scarlett2_phantom_ctl, 6889 i, 1, s, &private->phantom_ctls[i]); 6890 if (err < 0) 6891 return err; 6892 } 6893 } 6894 if (info->phantom_count && 6895 scarlett2_has_config_item(private, 6896 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) { 6897 err = scarlett2_add_new_ctl( 6898 mixer, &scarlett2_phantom_persistence_ctl, 0, 1, 6899 "Phantom Power Persistence Capture Switch", NULL); 6900 if (err < 0) 6901 return err; 6902 } 6903 6904 /* Add input select/link controls */ 6905 if (scarlett2_has_config_item(private, 6906 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH)) { 6907 err = scarlett2_add_new_ctl( 6908 mixer, &scarlett2_input_select_ctl, 0, 1, 6909 "Input Select Capture Enum", 6910 &private->input_select_ctl); 6911 if (err < 0) 6912 return err; 6913 } 6914 6915 if (scarlett2_has_config_item(private, 6916 SCARLETT2_CONFIG_INPUT_LINK_SWITCH)) { 6917 for (i = 0; i < info->gain_input_count / 2; i++) { 6918 scnprintf(s, sizeof(s), 6919 "Line In %d-%d Link Capture Switch", 6920 (i * 2) + 1, (i * 2) + 2); 6921 err = scarlett2_add_new_ctl( 6922 mixer, &scarlett2_input_link_ctl, 6923 i, 1, s, &private->input_link_ctls[i]); 6924 if (err < 0) 6925 return err; 6926 } 6927 } 6928 6929 /* Add software-controllable input gain controls */ 6930 for (i = 0; i < info->gain_input_count; i++) { 6931 scnprintf(s, sizeof(s), fmt, i + 1, 6932 "Gain", "Volume"); 6933 err = scarlett2_add_new_ctl( 6934 mixer, &scarlett2_input_gain_ctl, 6935 i, 1, s, &private->input_gain_ctls[i]); 6936 if (err < 0) 6937 return err; 6938 private->input_gain_ctls[i]->tlv.p = 6939 private->config_set->input_gain_tlv; 6940 6941 scnprintf(s, sizeof(s), fmt, i + 1, 6942 "Autogain", "Switch"); 6943 err = scarlett2_add_new_ctl( 6944 mixer, &scarlett2_autogain_switch_ctl, 6945 i, 1, s, &private->autogain_ctls[i]); 6946 if (err < 0) 6947 return err; 6948 6949 scnprintf(s, sizeof(s), fmt, i + 1, 6950 "Autogain Status", "Enum"); 6951 err = scarlett2_add_new_ctl( 6952 mixer, &scarlett2_autogain_status_ctl, 6953 i, 1, s, &private->autogain_status_ctls[i]); 6954 } 6955 6956 /* Add autogain target controls */ 6957 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++) 6958 if (scarlett2_has_config_item(private, 6959 scarlett2_ag_target_configs[i])) { 6960 6961 scnprintf(s, sizeof(s), "Autogain %s Target", 6962 scarlett2_ag_target_names[i]); 6963 err = scarlett2_add_new_ctl( 6964 mixer, &scarlett2_ag_target_ctl, 6965 i, 1, s, &private->ag_target_ctls[i]); 6966 if (err < 0) 6967 return err; 6968 } 6969 6970 /* Add safe-mode input switch controls */ 6971 for (i = 0; i < info->safe_input_count; i++) { 6972 scnprintf(s, sizeof(s), fmt, i + 1, 6973 "Safe", "Switch"); 6974 err = scarlett2_add_new_ctl( 6975 mixer, &scarlett2_safe_ctl, 6976 i, 1, s, &private->safe_ctls[i]); 6977 if (err < 0) 6978 return err; 6979 } 6980 6981 /* Add PCM Input Switch control */ 6982 if (scarlett2_has_config_item(private, 6983 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) { 6984 err = scarlett2_add_new_ctl( 6985 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1, 6986 "PCM Input Capture Switch", 6987 &private->pcm_input_switch_ctl); 6988 if (err < 0) 6989 return err; 6990 } 6991 6992 return 0; 6993} 6994 6995/*** Mixer Volume Controls ***/ 6996 6997static int scarlett2_update_mix(struct usb_mixer_interface *mixer) 6998{ 6999 struct scarlett2_data *private = mixer->private_data; 7000 int i, err; 7001 7002 private->mix_updated = 0; 7003 7004 for (i = 0; i < private->num_mix_out; i++) { 7005 err = scarlett2_usb_get_mix(mixer, i); 7006 if (err < 0) 7007 return err; 7008 } 7009 7010 return 1; 7011} 7012 7013static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl, 7014 struct snd_ctl_elem_info *uinfo) 7015{ 7016 struct usb_mixer_elem_info *elem = kctl->private_data; 7017 7018 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 7019 uinfo->count = elem->channels; 7020 uinfo->value.integer.min = 0; 7021 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE; 7022 uinfo->value.integer.step = 1; 7023 return 0; 7024} 7025 7026static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl, 7027 struct snd_ctl_elem_value *ucontrol) 7028{ 7029 struct usb_mixer_elem_info *elem = kctl->private_data; 7030 struct usb_mixer_interface *mixer = elem->head.mixer; 7031 struct scarlett2_data *private = mixer->private_data; 7032 int err = 0; 7033 7034 mutex_lock(&private->data_mutex); 7035 7036 if (private->hwdep_in_use) { 7037 err = -EBUSY; 7038 goto unlock; 7039 } 7040 7041 if (private->mix_updated) { 7042 err = scarlett2_update_mix(mixer); 7043 if (err < 0) 7044 goto unlock; 7045 } 7046 ucontrol->value.integer.value[0] = private->mix[elem->control]; 7047 7048unlock: 7049 mutex_unlock(&private->data_mutex); 7050 return err; 7051} 7052 7053static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl, 7054 struct snd_ctl_elem_value *ucontrol) 7055{ 7056 struct usb_mixer_elem_info *elem = kctl->private_data; 7057 struct usb_mixer_interface *mixer = elem->head.mixer; 7058 struct scarlett2_data *private = mixer->private_data; 7059 int oval, val, mix_num, err = 0; 7060 int index = elem->control; 7061 7062 mutex_lock(&private->data_mutex); 7063 7064 if (private->hwdep_in_use) { 7065 err = -EBUSY; 7066 goto unlock; 7067 } 7068 7069 oval = private->mix[index]; 7070 val = clamp(ucontrol->value.integer.value[0], 7071 0L, (long)SCARLETT2_MIXER_MAX_VALUE); 7072 mix_num = index / private->num_mix_in; 7073 7074 if (oval == val) 7075 goto unlock; 7076 7077 private->mix[index] = val; 7078 err = scarlett2_usb_set_mix(mixer, mix_num); 7079 if (err == 0) 7080 err = 1; 7081 7082unlock: 7083 mutex_unlock(&private->data_mutex); 7084 return err; 7085} 7086 7087static const DECLARE_TLV_DB_MINMAX( 7088 db_scale_scarlett2_mixer, 7089 SCARLETT2_MIXER_MIN_DB * 100, 7090 SCARLETT2_MIXER_MAX_DB * 100 7091); 7092 7093static const struct snd_kcontrol_new scarlett2_mixer_ctl = { 7094 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7095 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 7096 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 7097 .name = "", 7098 .info = scarlett2_mixer_ctl_info, 7099 .get = scarlett2_mixer_ctl_get, 7100 .put = scarlett2_mixer_ctl_put, 7101 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ 7102 .tlv = { .p = db_scale_scarlett2_mixer } 7103}; 7104 7105static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer) 7106{ 7107 struct scarlett2_data *private = mixer->private_data; 7108 int err, i, j; 7109 int index; 7110 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 7111 7112 for (i = 0, index = 0; i < private->num_mix_out; i++) 7113 for (j = 0; j < private->num_mix_in; j++, index++) { 7114 snprintf(s, sizeof(s), 7115 "Mix %c Input %02d Playback Volume", 7116 'A' + i, j + 1); 7117 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl, 7118 index, 1, s, 7119 &private->mix_ctls[index]); 7120 if (err < 0) 7121 return err; 7122 } 7123 7124 return 0; 7125} 7126 7127/*** Direct Monitor Control ***/ 7128 7129static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer) 7130{ 7131 struct scarlett2_data *private = mixer->private_data; 7132 7133 private->direct_monitor_updated = 0; 7134 7135 if (!private->info->direct_monitor) 7136 return 0; 7137 7138 return scarlett2_usb_get_config( 7139 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, 7140 1, &private->direct_monitor_switch); 7141} 7142 7143static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer) 7144{ 7145 struct scarlett2_data *private = mixer->private_data; 7146 int err, i; 7147 u16 mix_values[SCARLETT2_MONITOR_MIX_MAX]; 7148 7149 if (!private->num_monitor_mix_ctls) 7150 return 0; 7151 7152 err = scarlett2_usb_get_config( 7153 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN, 7154 private->num_monitor_mix_ctls, mix_values); 7155 if (err < 0) 7156 return err; 7157 7158 for (i = 0; i < private->num_monitor_mix_ctls; i++) 7159 private->monitor_mix[i] = scarlett2_mixer_value_to_db( 7160 mix_values[i]); 7161 7162 return 0; 7163} 7164 7165static int scarlett2_direct_monitor_ctl_get( 7166 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 7167{ 7168 struct usb_mixer_elem_info *elem = kctl->private_data; 7169 struct usb_mixer_interface *mixer = elem->head.mixer; 7170 struct scarlett2_data *private = mixer->private_data; 7171 int err = 0; 7172 7173 mutex_lock(&private->data_mutex); 7174 7175 if (private->hwdep_in_use) { 7176 err = -EBUSY; 7177 goto unlock; 7178 } 7179 7180 if (private->direct_monitor_updated) { 7181 err = scarlett2_update_direct_monitor(mixer); 7182 if (err < 0) 7183 goto unlock; 7184 } 7185 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch; 7186 7187unlock: 7188 mutex_unlock(&private->data_mutex); 7189 return err; 7190} 7191 7192static int scarlett2_direct_monitor_ctl_put( 7193 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 7194{ 7195 struct usb_mixer_elem_info *elem = kctl->private_data; 7196 struct usb_mixer_interface *mixer = elem->head.mixer; 7197 struct scarlett2_data *private = mixer->private_data; 7198 7199 int index = elem->control; 7200 int oval, val, err = 0; 7201 7202 mutex_lock(&private->data_mutex); 7203 7204 if (private->hwdep_in_use) { 7205 err = -EBUSY; 7206 goto unlock; 7207 } 7208 7209 oval = private->direct_monitor_switch; 7210 val = min(ucontrol->value.enumerated.item[0], 2U); 7211 7212 if (oval == val) 7213 goto unlock; 7214 7215 private->direct_monitor_switch = val; 7216 7217 /* Send switch change to the device */ 7218 err = scarlett2_usb_set_config( 7219 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val); 7220 if (err == 0) 7221 err = 1; 7222 7223unlock: 7224 mutex_unlock(&private->data_mutex); 7225 return err; 7226} 7227 7228static int scarlett2_direct_monitor_stereo_enum_ctl_info( 7229 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 7230{ 7231 static const char *const values[3] = { 7232 "Off", "Mono", "Stereo" 7233 }; 7234 7235 return snd_ctl_enum_info(uinfo, 1, 3, values); 7236} 7237 7238/* Direct Monitor for Solo is mono-only and only needs a boolean control 7239 * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo 7240 */ 7241static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = { 7242 { 7243 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7244 .name = "", 7245 .info = snd_ctl_boolean_mono_info, 7246 .get = scarlett2_direct_monitor_ctl_get, 7247 .put = scarlett2_direct_monitor_ctl_put, 7248 }, 7249 { 7250 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7251 .name = "", 7252 .info = scarlett2_direct_monitor_stereo_enum_ctl_info, 7253 .get = scarlett2_direct_monitor_ctl_get, 7254 .put = scarlett2_direct_monitor_ctl_put, 7255 } 7256}; 7257 7258static int scarlett2_monitor_mix_ctl_get(struct snd_kcontrol *kctl, 7259 struct snd_ctl_elem_value *ucontrol) 7260{ 7261 struct usb_mixer_elem_info *elem = kctl->private_data; 7262 struct scarlett2_data *private = elem->head.mixer->private_data; 7263 7264 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control]; 7265 7266 return 0; 7267} 7268 7269static int scarlett2_monitor_mix_ctl_put(struct snd_kcontrol *kctl, 7270 struct snd_ctl_elem_value *ucontrol) 7271{ 7272 struct usb_mixer_elem_info *elem = kctl->private_data; 7273 struct usb_mixer_interface *mixer = elem->head.mixer; 7274 struct scarlett2_data *private = mixer->private_data; 7275 int oval, val, err = 0; 7276 int index = elem->control; 7277 7278 mutex_lock(&private->data_mutex); 7279 7280 if (private->hwdep_in_use) { 7281 err = -EBUSY; 7282 goto unlock; 7283 } 7284 7285 oval = private->monitor_mix[index]; 7286 val = clamp(ucontrol->value.integer.value[0], 7287 0L, (long)SCARLETT2_MIXER_MAX_VALUE); 7288 7289 if (oval == val) 7290 goto unlock; 7291 7292 private->monitor_mix[index] = val; 7293 err = scarlett2_usb_set_config( 7294 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN, 7295 index, scarlett2_mixer_values[val]); 7296 if (err == 0) 7297 err = 1; 7298 7299unlock: 7300 mutex_unlock(&private->data_mutex); 7301 return err; 7302} 7303 7304static const struct snd_kcontrol_new scarlett2_monitor_mix_ctl = { 7305 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7306 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 7307 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 7308 .name = "", 7309 .info = scarlett2_mixer_ctl_info, 7310 .get = scarlett2_monitor_mix_ctl_get, 7311 .put = scarlett2_monitor_mix_ctl_put, 7312 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ 7313 .tlv = { .p = db_scale_scarlett2_mixer } 7314}; 7315 7316static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer) 7317{ 7318 struct scarlett2_data *private = mixer->private_data; 7319 const struct scarlett2_device_info *info = private->info; 7320 const char *s; 7321 int err, i, j, k, index; 7322 7323 if (!info->direct_monitor) 7324 return 0; 7325 7326 s = info->direct_monitor == 1 7327 ? "Direct Monitor Playback Switch" 7328 : "Direct Monitor Playback Enum"; 7329 7330 err = scarlett2_add_new_ctl( 7331 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1], 7332 0, 1, s, &private->direct_monitor_ctl); 7333 if (err < 0) 7334 return err; 7335 7336 if (!private->num_monitor_mix_ctls) 7337 return 0; 7338 7339 /* 1 or 2 direct monitor selections (Mono & Stereo) */ 7340 for (i = 0, index = 0; i < info->direct_monitor; i++) { 7341 const char * const format = 7342 "Monitor %sMix %c Input %02d Playback Volume"; 7343 const char *mix_type; 7344 7345 if (info->direct_monitor == 1) 7346 mix_type = ""; 7347 else if (i == 0) 7348 mix_type = "1 "; 7349 else 7350 mix_type = "2 "; 7351 7352 /* 2 Mix outputs, A/Left & B/Right */ 7353 for (j = 0; j < 2; j++) 7354 7355 /* Mix inputs */ 7356 for (k = 0; k < private->num_mix_in; k++, index++) { 7357 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 7358 7359 scnprintf(name, sizeof(name), format, 7360 mix_type, 'A' + j, k + 1); 7361 7362 err = scarlett2_add_new_ctl( 7363 mixer, &scarlett2_monitor_mix_ctl, 7364 index, 1, name, NULL); 7365 if (err < 0) 7366 return err; 7367 } 7368 } 7369 7370 return 0; 7371} 7372 7373/*** Mux Source Selection Controls ***/ 7374 7375static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl, 7376 struct snd_ctl_elem_info *uinfo) 7377{ 7378 struct usb_mixer_elem_info *elem = kctl->private_data; 7379 struct scarlett2_data *private = elem->head.mixer->private_data; 7380 const struct scarlett2_device_info *info = private->info; 7381 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 7382 unsigned int item = uinfo->value.enumerated.item; 7383 int items = private->num_mux_srcs; 7384 int port_type; 7385 7386 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 7387 uinfo->count = elem->channels; 7388 uinfo->value.enumerated.items = items; 7389 7390 if (item >= items) 7391 item = uinfo->value.enumerated.item = items - 1; 7392 7393 for (port_type = 0; 7394 port_type < SCARLETT2_PORT_TYPE_COUNT; 7395 port_type++) { 7396 if (item < port_count[port_type][SCARLETT2_PORT_IN]) { 7397 const struct scarlett2_port *port = 7398 &scarlett2_ports[port_type]; 7399 7400 if (port_type == SCARLETT2_PORT_TYPE_MIX && 7401 item >= private->num_mix_out) 7402 sprintf(uinfo->value.enumerated.name, 7403 port->dsp_src_descr, 7404 item - private->num_mix_out + 1); 7405 else 7406 sprintf(uinfo->value.enumerated.name, 7407 port->src_descr, 7408 item + port->src_num_offset); 7409 7410 return 0; 7411 } 7412 item -= port_count[port_type][SCARLETT2_PORT_IN]; 7413 } 7414 7415 return -EINVAL; 7416} 7417 7418static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl, 7419 struct snd_ctl_elem_value *ucontrol) 7420{ 7421 struct usb_mixer_elem_info *elem = kctl->private_data; 7422 struct usb_mixer_interface *mixer = elem->head.mixer; 7423 struct scarlett2_data *private = mixer->private_data; 7424 int index = line_out_remap(private, elem->control); 7425 int err = 0; 7426 7427 mutex_lock(&private->data_mutex); 7428 7429 if (private->hwdep_in_use) { 7430 err = -EBUSY; 7431 goto unlock; 7432 } 7433 7434 if (private->mux_updated) { 7435 err = scarlett2_usb_get_mux(mixer); 7436 if (err < 0) 7437 goto unlock; 7438 } 7439 ucontrol->value.enumerated.item[0] = private->mux[index]; 7440 7441unlock: 7442 mutex_unlock(&private->data_mutex); 7443 return err; 7444} 7445 7446static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl, 7447 struct snd_ctl_elem_value *ucontrol) 7448{ 7449 struct usb_mixer_elem_info *elem = kctl->private_data; 7450 struct usb_mixer_interface *mixer = elem->head.mixer; 7451 struct scarlett2_data *private = mixer->private_data; 7452 int index = line_out_remap(private, elem->control); 7453 int oval, val, err = 0; 7454 7455 mutex_lock(&private->data_mutex); 7456 7457 if (private->hwdep_in_use) { 7458 err = -EBUSY; 7459 goto unlock; 7460 } 7461 7462 oval = private->mux[index]; 7463 val = min(ucontrol->value.enumerated.item[0], 7464 private->num_mux_srcs - 1U); 7465 7466 if (oval == val) 7467 goto unlock; 7468 7469 private->mux[index] = val; 7470 err = scarlett2_usb_set_mux(mixer); 7471 if (err == 0) 7472 err = 1; 7473 7474unlock: 7475 mutex_unlock(&private->data_mutex); 7476 return err; 7477} 7478 7479static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = { 7480 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7481 .name = "", 7482 .info = scarlett2_mux_src_enum_ctl_info, 7483 .get = scarlett2_mux_src_enum_ctl_get, 7484 .put = scarlett2_mux_src_enum_ctl_put, 7485}; 7486 7487static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer) 7488{ 7489 struct scarlett2_data *private = mixer->private_data; 7490 const struct scarlett2_device_info *info = private->info; 7491 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 7492 int port_type, channel, i; 7493 7494 for (i = 0, port_type = 0; 7495 port_type < SCARLETT2_PORT_TYPE_COUNT; 7496 port_type++) { 7497 for (channel = 0; 7498 channel < port_count[port_type][SCARLETT2_PORT_OUT]; 7499 channel++, i++) { 7500 int err; 7501 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 7502 int channel_num = channel + 1; 7503 const struct scarlett2_port *port = 7504 &scarlett2_ports[port_type]; 7505 const char *descr = port->dst_descr; 7506 7507 if (port_type == SCARLETT2_PORT_TYPE_MIX && 7508 channel >= private->num_mix_in) { 7509 channel_num -= private->num_mix_in; 7510 descr = port->dsp_dst_descr; 7511 } 7512 7513 snprintf(s, sizeof(s) - 5, descr, channel_num); 7514 strcat(s, " Enum"); 7515 7516 err = scarlett2_add_new_ctl(mixer, 7517 &scarlett2_mux_src_enum_ctl, 7518 i, 1, s, 7519 &private->mux_ctls[i]); 7520 if (err < 0) 7521 return err; 7522 } 7523 } 7524 7525 return 0; 7526} 7527 7528/*** Meter Controls ***/ 7529 7530static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl, 7531 struct snd_ctl_elem_info *uinfo) 7532{ 7533 struct usb_mixer_elem_info *elem = kctl->private_data; 7534 7535 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 7536 uinfo->count = elem->channels; 7537 uinfo->value.integer.min = 0; 7538 uinfo->value.integer.max = 4095; 7539 uinfo->value.integer.step = 1; 7540 return 0; 7541} 7542 7543static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl, 7544 struct snd_ctl_elem_value *ucontrol) 7545{ 7546 struct usb_mixer_elem_info *elem = kctl->private_data; 7547 struct usb_mixer_interface *mixer = elem->head.mixer; 7548 struct scarlett2_data *private = mixer->private_data; 7549 u8 *meter_level_map = private->meter_level_map; 7550 u16 meter_levels[SCARLETT2_MAX_METERS]; 7551 int i, err; 7552 7553 mutex_lock(&private->data_mutex); 7554 7555 if (private->hwdep_in_use) { 7556 err = -EBUSY; 7557 goto unlock; 7558 } 7559 7560 err = scarlett2_usb_get_meter_levels(mixer, elem->channels, 7561 meter_levels); 7562 if (err < 0) 7563 goto unlock; 7564 7565 /* copy & translate from meter_levels[] using meter_level_map[] */ 7566 for (i = 0; i < elem->channels; i++) { 7567 int idx = meter_level_map[i]; 7568 int value; 7569 7570 if (idx == 255) 7571 value = 0; 7572 else 7573 value = meter_levels[idx]; 7574 7575 ucontrol->value.integer.value[i] = value; 7576 } 7577 7578unlock: 7579 mutex_unlock(&private->data_mutex); 7580 7581 return err; 7582} 7583 7584static const struct snd_kcontrol_new scarlett2_meter_ctl = { 7585 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 7586 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 7587 .name = "", 7588 .info = scarlett2_meter_ctl_info, 7589 .get = scarlett2_meter_ctl_get 7590}; 7591 7592static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer) 7593{ 7594 struct scarlett2_data *private = mixer->private_data; 7595 7596 /* devices without a mixer also don't support reporting levels */ 7597 if (!scarlett2_has_mixer(private)) 7598 return 0; 7599 7600 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl, 7601 0, private->num_mux_dsts, 7602 "Level Meter", NULL); 7603} 7604 7605/*** MSD Controls ***/ 7606 7607static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl, 7608 struct snd_ctl_elem_value *ucontrol) 7609{ 7610 struct usb_mixer_elem_info *elem = kctl->private_data; 7611 struct scarlett2_data *private = elem->head.mixer->private_data; 7612 7613 ucontrol->value.integer.value[0] = private->msd_switch; 7614 return 0; 7615} 7616 7617static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl, 7618 struct snd_ctl_elem_value *ucontrol) 7619{ 7620 struct usb_mixer_elem_info *elem = kctl->private_data; 7621 struct usb_mixer_interface *mixer = elem->head.mixer; 7622 struct scarlett2_data *private = mixer->private_data; 7623 7624 int oval, val, err = 0; 7625 7626 mutex_lock(&private->data_mutex); 7627 7628 if (private->hwdep_in_use) { 7629 err = -EBUSY; 7630 goto unlock; 7631 } 7632 7633 oval = private->msd_switch; 7634 val = !!ucontrol->value.integer.value[0]; 7635 7636 if (oval == val) 7637 goto unlock; 7638 7639 private->msd_switch = val; 7640 7641 /* Send switch change to the device */ 7642 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH, 7643 0, val); 7644 if (err == 0) 7645 err = 1; 7646 7647unlock: 7648 mutex_unlock(&private->data_mutex); 7649 return err; 7650} 7651 7652static const struct snd_kcontrol_new scarlett2_msd_ctl = { 7653 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7654 .name = "", 7655 .info = snd_ctl_boolean_mono_info, 7656 .get = scarlett2_msd_ctl_get, 7657 .put = scarlett2_msd_ctl_put, 7658}; 7659 7660static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer) 7661{ 7662 struct scarlett2_data *private = mixer->private_data; 7663 7664 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) 7665 return 0; 7666 7667 /* If MSD mode is off, hide the switch by default */ 7668 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE)) 7669 return 0; 7670 7671 /* Add MSD control */ 7672 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl, 7673 0, 1, "MSD Mode Switch", NULL); 7674} 7675 7676/*** Standalone Control ***/ 7677 7678static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl, 7679 struct snd_ctl_elem_value *ucontrol) 7680{ 7681 struct usb_mixer_elem_info *elem = kctl->private_data; 7682 struct scarlett2_data *private = elem->head.mixer->private_data; 7683 7684 ucontrol->value.integer.value[0] = private->standalone_switch; 7685 return 0; 7686} 7687 7688static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl, 7689 struct snd_ctl_elem_value *ucontrol) 7690{ 7691 struct usb_mixer_elem_info *elem = kctl->private_data; 7692 struct usb_mixer_interface *mixer = elem->head.mixer; 7693 struct scarlett2_data *private = mixer->private_data; 7694 7695 int oval, val, err = 0; 7696 7697 mutex_lock(&private->data_mutex); 7698 7699 if (private->hwdep_in_use) { 7700 err = -EBUSY; 7701 goto unlock; 7702 } 7703 7704 oval = private->standalone_switch; 7705 val = !!ucontrol->value.integer.value[0]; 7706 7707 if (oval == val) 7708 goto unlock; 7709 7710 private->standalone_switch = val; 7711 7712 /* Send switch change to the device */ 7713 err = scarlett2_usb_set_config(mixer, 7714 SCARLETT2_CONFIG_STANDALONE_SWITCH, 7715 0, val); 7716 if (err == 0) 7717 err = 1; 7718 7719unlock: 7720 mutex_unlock(&private->data_mutex); 7721 return err; 7722} 7723 7724static const struct snd_kcontrol_new scarlett2_standalone_ctl = { 7725 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7726 .name = "", 7727 .info = snd_ctl_boolean_mono_info, 7728 .get = scarlett2_standalone_ctl_get, 7729 .put = scarlett2_standalone_ctl_put, 7730}; 7731 7732static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer) 7733{ 7734 struct scarlett2_data *private = mixer->private_data; 7735 7736 if (!scarlett2_has_config_item(private, 7737 SCARLETT2_CONFIG_STANDALONE_SWITCH)) 7738 return 0; 7739 7740 /* Add standalone control */ 7741 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl, 7742 0, 1, "Standalone Switch", NULL); 7743} 7744 7745/*** Power Status ***/ 7746 7747static int scarlett2_update_power_status(struct usb_mixer_interface *mixer) 7748{ 7749 struct scarlett2_data *private = mixer->private_data; 7750 int err; 7751 u8 power_ext, power_low; 7752 7753 private->power_status_updated = 0; 7754 7755 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT, 7756 1, &power_ext); 7757 if (err < 0) 7758 return err; 7759 7760 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW, 7761 1, &power_low); 7762 if (err < 0) 7763 return err; 7764 7765 if (power_low) 7766 private->power_status = SCARLETT2_POWER_STATUS_FAIL; 7767 else if (power_ext) 7768 private->power_status = SCARLETT2_POWER_STATUS_EXT; 7769 else 7770 private->power_status = SCARLETT2_POWER_STATUS_BUS; 7771 7772 return 0; 7773} 7774 7775static int scarlett2_power_status_ctl_get(struct snd_kcontrol *kctl, 7776 struct snd_ctl_elem_value *ucontrol) 7777{ 7778 struct usb_mixer_elem_info *elem = kctl->private_data; 7779 struct usb_mixer_interface *mixer = elem->head.mixer; 7780 struct scarlett2_data *private = mixer->private_data; 7781 int err = 0; 7782 7783 mutex_lock(&private->data_mutex); 7784 7785 if (private->power_status_updated) { 7786 err = scarlett2_update_power_status(mixer); 7787 if (err < 0) 7788 goto unlock; 7789 } 7790 ucontrol->value.integer.value[0] = private->power_status; 7791 7792unlock: 7793 mutex_unlock(&private->data_mutex); 7794 return err; 7795} 7796 7797static int scarlett2_power_status_ctl_info( 7798 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 7799{ 7800 static const char *const values[3] = { 7801 "External", "Bus", "Fail" 7802 }; 7803 7804 return snd_ctl_enum_info(uinfo, 1, 3, values); 7805} 7806 7807static const struct snd_kcontrol_new scarlett2_power_status_ctl = { 7808 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 7809 .access = SNDRV_CTL_ELEM_ACCESS_READ, 7810 .name = "", 7811 .info = scarlett2_power_status_ctl_info, 7812 .get = scarlett2_power_status_ctl_get, 7813}; 7814 7815static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer) 7816{ 7817 struct scarlett2_data *private = mixer->private_data; 7818 7819 if (!scarlett2_has_config_item(private, 7820 SCARLETT2_CONFIG_POWER_EXT)) 7821 return 0; 7822 7823 /* Add power status control */ 7824 return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl, 7825 0, 1, "Power Status Card Enum", 7826 &private->power_status_ctl); 7827} 7828 7829/*** Bluetooth Volume ***/ 7830 7831static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer) 7832{ 7833 struct scarlett2_data *private = mixer->private_data; 7834 int err; 7835 7836 private->bluetooth_updated = 0; 7837 7838 if (!private->info->has_bluetooth) 7839 return 0; 7840 7841 err = scarlett2_usb_get_config(mixer, 7842 SCARLETT2_CONFIG_BLUETOOTH_VOLUME, 7843 1, &private->bluetooth_volume); 7844 if (err < 0) 7845 return err; 7846 7847 return 0; 7848} 7849 7850static int scarlett2_bluetooth_volume_ctl_get(struct snd_kcontrol *kctl, 7851 struct snd_ctl_elem_value *ucontrol) 7852{ 7853 struct usb_mixer_elem_info *elem = kctl->private_data; 7854 struct usb_mixer_interface *mixer = elem->head.mixer; 7855 struct scarlett2_data *private = mixer->private_data; 7856 int err = 0; 7857 7858 mutex_lock(&private->data_mutex); 7859 7860 if (private->hwdep_in_use) { 7861 err = -EBUSY; 7862 goto unlock; 7863 } 7864 7865 if (private->bluetooth_updated) { 7866 err = scarlett2_update_bluetooth_volume(mixer); 7867 if (err < 0) 7868 goto unlock; 7869 } 7870 ucontrol->value.integer.value[0] = private->bluetooth_volume; 7871 7872unlock: 7873 mutex_unlock(&private->data_mutex); 7874 return err; 7875} 7876 7877static int scarlett2_bluetooth_volume_ctl_put(struct snd_kcontrol *kctl, 7878 struct snd_ctl_elem_value *ucontrol) 7879{ 7880 struct usb_mixer_elem_info *elem = kctl->private_data; 7881 struct usb_mixer_interface *mixer = elem->head.mixer; 7882 struct scarlett2_data *private = mixer->private_data; 7883 int oval, val, err = 0; 7884 7885 mutex_lock(&private->data_mutex); 7886 7887 if (private->hwdep_in_use) { 7888 err = -EBUSY; 7889 goto unlock; 7890 } 7891 7892 oval = private->bluetooth_volume; 7893 val = clamp(ucontrol->value.integer.value[0], 7894 0L, (long)SCARLETT2_MAX_BLUETOOTH_VOLUME); 7895 7896 if (oval == val) 7897 goto unlock; 7898 7899 private->bluetooth_volume = val; 7900 err = scarlett2_usb_set_config(mixer, 7901 SCARLETT2_CONFIG_BLUETOOTH_VOLUME, 7902 0, val); 7903 if (err == 0) 7904 err = 1; 7905 7906unlock: 7907 mutex_unlock(&private->data_mutex); 7908 return err; 7909} 7910 7911static int scarlett2_bluetooth_volume_ctl_info( 7912 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 7913{ 7914 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 7915 uinfo->count = 1; 7916 uinfo->value.integer.min = 0; 7917 uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME; 7918 uinfo->value.integer.step = 1; 7919 return 0; 7920} 7921 7922static const struct snd_kcontrol_new scarlett2_bluetooth_volume_ctl = { 7923 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 7924 .name = "", 7925 .info = scarlett2_bluetooth_volume_ctl_info, 7926 .get = scarlett2_bluetooth_volume_ctl_get, 7927 .put = scarlett2_bluetooth_volume_ctl_put, 7928}; 7929 7930static int scarlett2_add_bluetooth_volume_ctl( 7931 struct usb_mixer_interface *mixer) 7932{ 7933 struct scarlett2_data *private = mixer->private_data; 7934 7935 if (!private->info->has_bluetooth) 7936 return 0; 7937 7938 /* Add Bluetooth volume control */ 7939 return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl, 7940 0, 1, "Bluetooth Capture Volume", 7941 &private->bluetooth_volume_ctl); 7942} 7943 7944/*** S/PDIF Mode Controls ***/ 7945 7946static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer) 7947{ 7948 struct scarlett2_data *private = mixer->private_data; 7949 int err, i; 7950 u8 mode; 7951 const u8 *mode_values = private->info->spdif_mode_values; 7952 7953 if (!private->info->spdif_mode_control_name) 7954 return 0; 7955 7956 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE, 7957 1, &mode); 7958 if (err < 0) 7959 return err; 7960 7961 private->spdif_mode = 0; 7962 7963 for (i = 0; *mode_values != 0xff; i++, mode_values++) 7964 if (*mode_values == mode) { 7965 private->spdif_mode = i; 7966 break; 7967 } 7968 7969 return 0; 7970} 7971 7972static int scarlett2_spdif_mode_ctl_info(struct snd_kcontrol *kctl, 7973 struct snd_ctl_elem_info *uinfo) 7974{ 7975 struct usb_mixer_elem_info *elem = kctl->private_data; 7976 struct scarlett2_data *private = elem->head.mixer->private_data; 7977 const char * const *mode_texts = private->info->spdif_mode_texts; 7978 int count = 0; 7979 7980 while (*mode_texts++) 7981 count++; 7982 7983 return snd_ctl_enum_info(uinfo, 1, count, 7984 private->info->spdif_mode_texts); 7985} 7986 7987static int scarlett2_spdif_mode_ctl_get(struct snd_kcontrol *kctl, 7988 struct snd_ctl_elem_value *ucontrol) 7989{ 7990 struct usb_mixer_elem_info *elem = kctl->private_data; 7991 struct scarlett2_data *private = elem->head.mixer->private_data; 7992 7993 ucontrol->value.enumerated.item[0] = private->spdif_mode; 7994 return 0; 7995} 7996 7997static int scarlett2_spdif_mode_ctl_put(struct snd_kcontrol *kctl, 7998 struct snd_ctl_elem_value *ucontrol) 7999{ 8000 struct usb_mixer_elem_info *elem = kctl->private_data; 8001 struct usb_mixer_interface *mixer = elem->head.mixer; 8002 struct scarlett2_data *private = mixer->private_data; 8003 int oval, val, err = 0; 8004 int i; 8005 8006 mutex_lock(&private->data_mutex); 8007 8008 oval = private->spdif_mode; 8009 val = ucontrol->value.enumerated.item[0]; 8010 8011 if (val < 0) { 8012 err = -EINVAL; 8013 goto unlock; 8014 } 8015 8016 for (i = 0; i <= val; i++) 8017 if (private->info->spdif_mode_values[i] == 0xff) { 8018 err = -EINVAL; 8019 goto unlock; 8020 } 8021 8022 if (oval == val) 8023 goto unlock; 8024 8025 private->spdif_mode = val; 8026 8027 err = scarlett2_usb_set_config( 8028 mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0, 8029 private->info->spdif_mode_values[val]); 8030 if (!err) 8031 err = 1; 8032 8033unlock: 8034 mutex_unlock(&private->data_mutex); 8035 return err; 8036} 8037 8038static const struct snd_kcontrol_new scarlett2_spdif_mode_ctl = { 8039 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 8040 .name = "", 8041 .info = scarlett2_spdif_mode_ctl_info, 8042 .get = scarlett2_spdif_mode_ctl_get, 8043 .put = scarlett2_spdif_mode_ctl_put, 8044}; 8045 8046static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer) 8047{ 8048 struct scarlett2_data *private = mixer->private_data; 8049 8050 if (!private->info->spdif_mode_control_name) 8051 return 0; 8052 8053 return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl, 8054 0, 1, 8055 private->info->spdif_mode_control_name, 8056 NULL); 8057} 8058 8059/*** Notification Handlers ***/ 8060 8061/* Notify on sync change */ 8062static void scarlett2_notify_sync(struct usb_mixer_interface *mixer) 8063{ 8064 struct scarlett2_data *private = mixer->private_data; 8065 8066 private->sync_updated = 1; 8067 8068 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 8069 &private->sync_ctl->id); 8070} 8071 8072/* Notify on monitor change (Gen 2/3) */ 8073static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer) 8074{ 8075 struct snd_card *card = mixer->chip->card; 8076 struct scarlett2_data *private = mixer->private_data; 8077 int i; 8078 8079 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) 8080 return; 8081 8082 private->vol_updated = 1; 8083 8084 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 8085 &private->master_vol_ctl->id); 8086 8087 for (i = 0; i < private->num_line_out; i++) 8088 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 8089 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8090 &private->vol_ctls[i]->id); 8091} 8092 8093/* Notify on volume change (Gen 4) */ 8094static void scarlett2_notify_volume(struct usb_mixer_interface *mixer) 8095{ 8096 struct scarlett2_data *private = mixer->private_data; 8097 8098 private->vol_updated = 1; 8099 8100 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 8101 &private->master_vol_ctl->id); 8102 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 8103 &private->headphone_vol_ctl->id); 8104} 8105 8106/* Notify on dim/mute change */ 8107static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer) 8108{ 8109 struct snd_card *card = mixer->chip->card; 8110 struct scarlett2_data *private = mixer->private_data; 8111 int i; 8112 8113 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) 8114 return; 8115 8116 private->dim_mute_updated = 1; 8117 8118 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 8119 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8120 &private->dim_mute_ctls[i]->id); 8121 8122 for (i = 0; i < private->num_line_out; i++) 8123 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 8124 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8125 &private->mute_ctls[i]->id); 8126} 8127 8128/* Notify on input level switch change */ 8129static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer) 8130{ 8131 struct snd_card *card = mixer->chip->card; 8132 struct scarlett2_data *private = mixer->private_data; 8133 const struct scarlett2_device_info *info = private->info; 8134 int i; 8135 8136 private->input_level_updated = 1; 8137 8138 for (i = 0; i < info->level_input_count; i++) 8139 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8140 &private->level_ctls[i]->id); 8141} 8142 8143/* Notify on input pad switch change */ 8144static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer) 8145{ 8146 struct snd_card *card = mixer->chip->card; 8147 struct scarlett2_data *private = mixer->private_data; 8148 const struct scarlett2_device_info *info = private->info; 8149 int i; 8150 8151 private->input_pad_updated = 1; 8152 8153 for (i = 0; i < info->pad_input_count; i++) 8154 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8155 &private->pad_ctls[i]->id); 8156} 8157 8158/* Notify on input air switch change */ 8159static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer) 8160{ 8161 struct snd_card *card = mixer->chip->card; 8162 struct scarlett2_data *private = mixer->private_data; 8163 const struct scarlett2_device_info *info = private->info; 8164 int i; 8165 8166 private->input_air_updated = 1; 8167 8168 for (i = 0; i < info->air_input_count; i++) 8169 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8170 &private->air_ctls[i]->id); 8171} 8172 8173/* Notify on input DSP switch change */ 8174static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer) 8175{ 8176 struct snd_card *card = mixer->chip->card; 8177 struct scarlett2_data *private = mixer->private_data; 8178 const struct scarlett2_device_info *info = private->info; 8179 int i; 8180 8181 private->input_dsp_updated = 1; 8182 8183 for (i = 0; i < info->dsp_input_count; i++) 8184 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8185 &private->dsp_ctls[i]->id); 8186} 8187 8188/* Notify on input mute switch change */ 8189static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer) 8190{ 8191 struct snd_card *card = mixer->chip->card; 8192 struct scarlett2_data *private = mixer->private_data; 8193 const struct scarlett2_device_info *info = private->info; 8194 int i; 8195 8196 private->input_mute_updated = 1; 8197 8198 for (i = 0; i < info->mute_input_count; i++) 8199 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8200 &private->input_mute_ctls[i]->id); 8201} 8202 8203/* Notify on input phantom switch change */ 8204static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer) 8205{ 8206 struct snd_card *card = mixer->chip->card; 8207 struct scarlett2_data *private = mixer->private_data; 8208 const struct scarlett2_device_info *info = private->info; 8209 int i; 8210 8211 private->input_phantom_updated = 1; 8212 8213 for (i = 0; i < info->phantom_count; i++) 8214 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8215 &private->phantom_ctls[i]->id); 8216 8217 scarlett2_phantom_notify_access(mixer); 8218} 8219 8220/* Notify on "input other" change (level/pad/air/phantom) */ 8221static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer) 8222{ 8223 scarlett2_notify_input_level(mixer); 8224 scarlett2_notify_input_pad(mixer); 8225 scarlett2_notify_input_air(mixer); 8226 scarlett2_notify_input_phantom(mixer); 8227} 8228 8229/* Notify on input select change */ 8230static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer) 8231{ 8232 struct snd_card *card = mixer->chip->card; 8233 struct scarlett2_data *private = mixer->private_data; 8234 const struct scarlett2_device_info *info = private->info; 8235 int i; 8236 8237 if (!scarlett2_has_config_item(private, 8238 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH)) 8239 return; 8240 8241 private->input_select_updated = 1; 8242 8243 snd_ctl_notify(card, 8244 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 8245 &private->input_select_ctl->id); 8246 8247 for (i = 0; i < info->gain_input_count / 2; i++) 8248 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8249 &private->input_link_ctls[i]->id); 8250} 8251 8252/* Notify on input gain change */ 8253static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer) 8254{ 8255 struct snd_card *card = mixer->chip->card; 8256 struct scarlett2_data *private = mixer->private_data; 8257 const struct scarlett2_device_info *info = private->info; 8258 int i; 8259 8260 if (!info->gain_input_count) 8261 return; 8262 8263 private->input_gain_updated = 1; 8264 8265 for (i = 0; i < info->gain_input_count; i++) 8266 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8267 &private->input_gain_ctls[i]->id); 8268} 8269 8270/* Notify on autogain change */ 8271static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer) 8272{ 8273 struct snd_card *card = mixer->chip->card; 8274 struct scarlett2_data *private = mixer->private_data; 8275 const struct scarlett2_device_info *info = private->info; 8276 int i; 8277 8278 if (!info->gain_input_count) 8279 return; 8280 8281 private->autogain_updated = 1; 8282 8283 for (i = 0; i < info->gain_input_count; i++) { 8284 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8285 &private->autogain_ctls[i]->id); 8286 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8287 &private->autogain_status_ctls[i]->id); 8288 } 8289 8290 for (i = 0; i < SCARLETT2_AG_TARGET_COUNT; i++) 8291 if (scarlett2_has_config_item(private, 8292 scarlett2_ag_target_configs[i])) 8293 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 8294 &private->ag_target_ctls[i]->id); 8295 8296 scarlett2_autogain_notify_access(mixer); 8297} 8298 8299/* Notify on input safe switch change */ 8300static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer) 8301{ 8302 struct snd_card *card = mixer->chip->card; 8303 struct scarlett2_data *private = mixer->private_data; 8304 const struct scarlett2_device_info *info = private->info; 8305 int i; 8306 8307 if (!info->safe_input_count) 8308 return; 8309 8310 private->input_safe_updated = 1; 8311 8312 for (i = 0; i < info->safe_input_count; i++) 8313 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8314 &private->safe_ctls[i]->id); 8315} 8316 8317/* Notify on "monitor other" change (speaker switching, talkback) */ 8318static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer) 8319{ 8320 struct snd_card *card = mixer->chip->card; 8321 struct scarlett2_data *private = mixer->private_data; 8322 const struct scarlett2_device_info *info = private->info; 8323 8324 private->monitor_other_updated = 1; 8325 8326 if (info->has_speaker_switching) 8327 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8328 &private->speaker_switching_ctl->id); 8329 8330 if (info->has_talkback) 8331 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8332 &private->talkback_ctl->id); 8333 8334 /* if speaker switching was recently enabled or disabled, 8335 * invalidate the dim/mute and mux enum controls 8336 */ 8337 if (private->speaker_switching_switched) { 8338 int i; 8339 8340 scarlett2_notify_dim_mute(mixer); 8341 8342 private->speaker_switching_switched = 0; 8343 private->mux_updated = 1; 8344 8345 for (i = 0; i < private->num_mux_dsts; i++) 8346 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8347 &private->mux_ctls[i]->id); 8348 } 8349} 8350 8351/* Notify on direct monitor switch change */ 8352static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer) 8353{ 8354 struct snd_card *card = mixer->chip->card; 8355 struct scarlett2_data *private = mixer->private_data; 8356 int count = private->num_mix_in * private->num_mix_out; 8357 int i; 8358 8359 private->direct_monitor_updated = 1; 8360 8361 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8362 &private->direct_monitor_ctl->id); 8363 8364 if (!scarlett2_has_mixer(private)) 8365 return; 8366 8367 private->mix_updated = 1; 8368 8369 /* Notify of change to the mix controls */ 8370 for (i = 0; i < count; i++) 8371 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8372 &private->mix_ctls[i]->id); 8373} 8374 8375/* Notify on power change */ 8376static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer) 8377{ 8378 struct snd_card *card = mixer->chip->card; 8379 struct scarlett2_data *private = mixer->private_data; 8380 8381 private->power_status_updated = 1; 8382 8383 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8384 &private->power_status_ctl->id); 8385} 8386 8387/* Notify on mux change */ 8388static void scarlett2_notify_mux(struct usb_mixer_interface *mixer) 8389{ 8390 struct snd_card *card = mixer->chip->card; 8391 struct scarlett2_data *private = mixer->private_data; 8392 int i; 8393 8394 private->mux_updated = 1; 8395 8396 for (i = 0; i < private->num_mux_dsts; i++) 8397 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8398 &private->mux_ctls[i]->id); 8399} 8400 8401/* Notify on PCM input switch change */ 8402static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer) 8403{ 8404 struct snd_card *card = mixer->chip->card; 8405 struct scarlett2_data *private = mixer->private_data; 8406 8407 private->pcm_input_switch_updated = 1; 8408 8409 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8410 &private->pcm_input_switch_ctl->id); 8411 8412 scarlett2_notify_mux(mixer); 8413} 8414 8415/* Notify on Bluetooth change */ 8416static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer) 8417{ 8418 struct snd_card *card = mixer->chip->card; 8419 struct scarlett2_data *private = mixer->private_data; 8420 8421 if (!private->info->has_bluetooth) 8422 return; 8423 8424 private->bluetooth_updated = 1; 8425 8426 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 8427 &private->bluetooth_volume_ctl->id); 8428} 8429 8430/* Handle acknowledgement that a command was received; let 8431 * scarlett2_usb() know that it can proceed 8432 */ 8433static void scarlett2_notify_ack(struct usb_mixer_interface *mixer) 8434{ 8435 struct scarlett2_data *private = mixer->private_data; 8436 8437 /* if running == 0, ignore ACKs */ 8438 if (private->running) 8439 complete(&private->cmd_done); 8440} 8441 8442/* Interrupt callback */ 8443static void scarlett2_notify(struct urb *urb) 8444{ 8445 struct usb_mixer_interface *mixer = urb->context; 8446 int len = urb->actual_length; 8447 int ustatus = urb->status; 8448 u32 data; 8449 struct scarlett2_data *private = mixer->private_data; 8450 const struct scarlett2_notification *notifications = 8451 private->config_set->notifications; 8452 8453 if (ustatus != 0 || len != 8) 8454 goto requeue; 8455 8456 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer); 8457 8458 /* Ignore notifications except ACK during initialisation. 8459 * ACK is 0x00000001 on every device. 8460 */ 8461 if (private->running < 2) 8462 data &= 1; 8463 8464 while (data && notifications->mask) { 8465 if (data & notifications->mask) { 8466 data &= ~notifications->mask; 8467 if (notifications->func) 8468 notifications->func(mixer); 8469 } 8470 notifications++; 8471 } 8472 8473 if (data) 8474 usb_audio_warn(mixer->chip, 8475 "%s: Unhandled notification: 0x%08x\n", 8476 __func__, data); 8477 8478requeue: 8479 if (ustatus != -ENOENT && 8480 ustatus != -ECONNRESET && 8481 ustatus != -ESHUTDOWN) { 8482 urb->dev = mixer->chip->dev; 8483 usb_submit_urb(urb, GFP_ATOMIC); 8484 } else { 8485 complete(&private->cmd_done); 8486 } 8487} 8488 8489/*** Cleanup/Suspend Callbacks ***/ 8490 8491static void scarlett2_private_free(struct usb_mixer_interface *mixer) 8492{ 8493 struct scarlett2_data *private = mixer->private_data; 8494 8495 cancel_delayed_work_sync(&private->work); 8496 kfree(private); 8497 mixer->private_data = NULL; 8498} 8499 8500static void scarlett2_private_suspend(struct usb_mixer_interface *mixer) 8501{ 8502 struct scarlett2_data *private = mixer->private_data; 8503 8504 if (cancel_delayed_work_sync(&private->work)) 8505 scarlett2_config_save(private->mixer); 8506} 8507 8508/*** Initialisation ***/ 8509 8510static void scarlett2_count_io(struct scarlett2_data *private) 8511{ 8512 const struct scarlett2_device_info *info = private->info; 8513 const struct scarlett2_config_set *config_set = info->config_set; 8514 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 8515 int port_type, srcs = 0, dsts = 0, i; 8516 8517 /* Count the number of mux sources and destinations */ 8518 for (port_type = 0; 8519 port_type < SCARLETT2_PORT_TYPE_COUNT; 8520 port_type++) { 8521 srcs += port_count[port_type][SCARLETT2_PORT_IN]; 8522 dsts += port_count[port_type][SCARLETT2_PORT_OUT]; 8523 } 8524 8525 private->num_mux_srcs = srcs; 8526 private->num_mux_dsts = dsts; 8527 8528 /* Mixer inputs are mux outputs and vice versa. 8529 * Scarlett Gen 4 DSP I/O uses SCARLETT2_PORT_TYPE_MIX but 8530 * doesn't have mixer controls. 8531 */ 8532 private->num_mix_in = 8533 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] - 8534 info->dsp_count; 8535 8536 private->num_mix_out = 8537 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] - 8538 info->dsp_count; 8539 8540 /* Number of analogue line outputs */ 8541 private->num_line_out = 8542 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 8543 8544 /* Number of monitor mix controls */ 8545 private->num_monitor_mix_ctls = 8546 info->direct_monitor * 2 * private->num_mix_in; 8547 8548 /* Number of autogain status texts */ 8549 if (config_set->autogain_status_texts) { 8550 const char * const *texts = config_set->autogain_status_texts; 8551 8552 for (i = 0; texts[i]; i++) 8553 ; 8554 private->num_autogain_status_texts = i; 8555 } 8556} 8557 8558/* Look through the interface descriptors for the Focusrite Control 8559 * interface (bInterfaceClass = 255 Vendor Specific Class) and set 8560 * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval 8561 * in private 8562 */ 8563static int scarlett2_find_fc_interface(struct usb_device *dev, 8564 struct scarlett2_data *private) 8565{ 8566 struct usb_host_config *config = dev->actconfig; 8567 int i; 8568 8569 for (i = 0; i < config->desc.bNumInterfaces; i++) { 8570 struct usb_interface *intf = config->interface[i]; 8571 struct usb_interface_descriptor *desc = 8572 &intf->altsetting[0].desc; 8573 struct usb_endpoint_descriptor *epd; 8574 8575 if (desc->bInterfaceClass != 255) 8576 continue; 8577 8578 epd = get_endpoint(intf->altsetting, 0); 8579 private->bInterfaceNumber = desc->bInterfaceNumber; 8580 private->bEndpointAddress = epd->bEndpointAddress & 8581 USB_ENDPOINT_NUMBER_MASK; 8582 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize); 8583 private->bInterval = epd->bInterval; 8584 return 0; 8585 } 8586 8587 return -EINVAL; 8588} 8589 8590/* Initialise private data */ 8591static int scarlett2_init_private(struct usb_mixer_interface *mixer, 8592 const struct scarlett2_device_entry *entry) 8593{ 8594 struct scarlett2_data *private = 8595 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL); 8596 8597 if (!private) 8598 return -ENOMEM; 8599 8600 mutex_init(&private->usb_mutex); 8601 mutex_init(&private->data_mutex); 8602 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work); 8603 8604 mixer->private_data = private; 8605 mixer->private_free = scarlett2_private_free; 8606 mixer->private_suspend = scarlett2_private_suspend; 8607 8608 private->info = entry->info; 8609 private->config_set = entry->info->config_set; 8610 private->series_name = entry->series_name; 8611 scarlett2_count_io(private); 8612 private->scarlett2_seq = 0; 8613 private->mixer = mixer; 8614 8615 return scarlett2_find_fc_interface(mixer->chip->dev, private); 8616} 8617 8618/* Submit a URB to receive notifications from the device */ 8619static int scarlett2_init_notify(struct usb_mixer_interface *mixer) 8620{ 8621 struct usb_device *dev = mixer->chip->dev; 8622 struct scarlett2_data *private = mixer->private_data; 8623 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress); 8624 void *transfer_buffer; 8625 8626 if (mixer->urb) { 8627 usb_audio_err(mixer->chip, 8628 "%s: mixer urb already in use!\n", __func__); 8629 return 0; 8630 } 8631 8632 if (usb_pipe_type_check(dev, pipe)) 8633 return -EINVAL; 8634 8635 mixer->urb = usb_alloc_urb(0, GFP_KERNEL); 8636 if (!mixer->urb) 8637 return -ENOMEM; 8638 8639 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL); 8640 if (!transfer_buffer) 8641 return -ENOMEM; 8642 8643 usb_fill_int_urb(mixer->urb, dev, pipe, 8644 transfer_buffer, private->wMaxPacketSize, 8645 scarlett2_notify, mixer, private->bInterval); 8646 8647 init_completion(&private->cmd_done); 8648 8649 return usb_submit_urb(mixer->urb, GFP_KERNEL); 8650} 8651 8652/* Cargo cult proprietary initialisation sequence */ 8653static int scarlett2_usb_init(struct usb_mixer_interface *mixer) 8654{ 8655 struct usb_device *dev = mixer->chip->dev; 8656 struct scarlett2_data *private = mixer->private_data; 8657 u8 step0_buf[24]; 8658 u8 step2_buf[84]; 8659 int err; 8660 8661 if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0))) 8662 return -EINVAL; 8663 8664 /* step 0 */ 8665 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, 8666 SCARLETT2_USB_CMD_INIT, 8667 step0_buf, sizeof(step0_buf)); 8668 if (err < 0) 8669 return err; 8670 8671 /* Set up the interrupt polling for notifications. 8672 * When running is: 8673 * 0: all notifications are ignored 8674 * 1: only ACKs are handled 8675 * 2: all notifications are handled 8676 */ 8677 err = scarlett2_init_notify(mixer); 8678 if (err < 0) 8679 return err; 8680 8681 /* sleep for a moment in case of an outstanding ACK */ 8682 msleep(20); 8683 8684 /* start handling ACKs, but no other notifications until the 8685 * ALSA controls have been created 8686 */ 8687 private->running = 1; 8688 8689 /* step 1 */ 8690 private->scarlett2_seq = 1; 8691 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0); 8692 if (err < 0) 8693 return err; 8694 8695 /* step 2 */ 8696 private->scarlett2_seq = 1; 8697 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, 8698 NULL, 0, 8699 step2_buf, sizeof(step2_buf)); 8700 if (err < 0) 8701 return err; 8702 8703 /* extract 4-byte firmware version from step2_buf[8] */ 8704 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8)); 8705 usb_audio_info(mixer->chip, 8706 "Firmware version %d\n", 8707 private->firmware_version); 8708 8709 return 0; 8710} 8711 8712/* Get the flash segment numbers for the App_Settings and App_Upgrade 8713 * segments and put them in the private data 8714 */ 8715static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer) 8716{ 8717 struct scarlett2_data *private = mixer->private_data; 8718 int err, count, i; 8719 8720 struct { 8721 __le32 size; 8722 __le32 count; 8723 u8 unknown[8]; 8724 } __packed flash_info; 8725 8726 struct { 8727 __le32 size; 8728 __le32 flags; 8729 char name[16]; 8730 } __packed segment_info; 8731 8732 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH, 8733 NULL, 0, 8734 &flash_info, sizeof(flash_info)); 8735 if (err < 0) 8736 return err; 8737 8738 count = le32_to_cpu(flash_info.count); 8739 8740 /* sanity check count */ 8741 if (count < SCARLETT2_SEGMENT_NUM_MIN || 8742 count > SCARLETT2_SEGMENT_NUM_MAX + 1) { 8743 usb_audio_err(mixer->chip, 8744 "invalid flash segment count: %d\n", count); 8745 return -EINVAL; 8746 } 8747 8748 for (i = 0; i < count; i++) { 8749 __le32 segment_num_req = cpu_to_le32(i); 8750 int flash_segment_id; 8751 8752 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT, 8753 &segment_num_req, sizeof(segment_num_req), 8754 &segment_info, sizeof(segment_info)); 8755 if (err < 0) { 8756 usb_audio_err(mixer->chip, 8757 "failed to get flash segment info %d: %d\n", 8758 i, err); 8759 return err; 8760 } 8761 8762 if (!strncmp(segment_info.name, 8763 SCARLETT2_SEGMENT_SETTINGS_NAME, 16)) 8764 flash_segment_id = SCARLETT2_SEGMENT_ID_SETTINGS; 8765 else if (!strncmp(segment_info.name, 8766 SCARLETT2_SEGMENT_FIRMWARE_NAME, 16)) 8767 flash_segment_id = SCARLETT2_SEGMENT_ID_FIRMWARE; 8768 else 8769 continue; 8770 8771 private->flash_segment_nums[flash_segment_id] = i; 8772 private->flash_segment_blocks[flash_segment_id] = 8773 le32_to_cpu(segment_info.size) / 8774 SCARLETT2_FLASH_BLOCK_SIZE; 8775 } 8776 8777 /* segment 0 is App_Gold and we never want to touch that, so 8778 * use 0 as the "not-found" value 8779 */ 8780 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) { 8781 usb_audio_err(mixer->chip, 8782 "failed to find flash segment %s\n", 8783 SCARLETT2_SEGMENT_SETTINGS_NAME); 8784 return -EINVAL; 8785 } 8786 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) { 8787 usb_audio_err(mixer->chip, 8788 "failed to find flash segment %s\n", 8789 SCARLETT2_SEGMENT_FIRMWARE_NAME); 8790 return -EINVAL; 8791 } 8792 8793 return 0; 8794} 8795 8796/* Read configuration from the interface on start */ 8797static int scarlett2_read_configs(struct usb_mixer_interface *mixer) 8798{ 8799 struct scarlett2_data *private = mixer->private_data; 8800 const struct scarlett2_device_info *info = private->info; 8801 int err, i; 8802 8803 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) { 8804 err = scarlett2_usb_get_config( 8805 mixer, SCARLETT2_CONFIG_MSD_SWITCH, 8806 1, &private->msd_switch); 8807 if (err < 0) 8808 return err; 8809 } 8810 8811 if (private->firmware_version < info->min_firmware_version) { 8812 usb_audio_err(mixer->chip, 8813 "Focusrite %s firmware version %d is too old; " 8814 "need %d", 8815 private->series_name, 8816 private->firmware_version, 8817 info->min_firmware_version); 8818 return 0; 8819 } 8820 8821 /* no other controls are created if MSD mode is on */ 8822 if (private->msd_switch) 8823 return 0; 8824 8825 err = scarlett2_update_input_level(mixer); 8826 if (err < 0) 8827 return err; 8828 8829 err = scarlett2_update_input_pad(mixer); 8830 if (err < 0) 8831 return err; 8832 8833 err = scarlett2_update_input_air(mixer); 8834 if (err < 0) 8835 return err; 8836 8837 err = scarlett2_update_input_dsp(mixer); 8838 if (err < 0) 8839 return err; 8840 8841 err = scarlett2_update_compressor_values(mixer); 8842 if (err < 0) 8843 return err; 8844 8845 err = scarlett2_update_filter_values(mixer); 8846 if (err < 0) 8847 return err; 8848 8849 err = scarlett2_update_input_mute(mixer); 8850 if (err < 0) 8851 return err; 8852 8853 err = scarlett2_update_input_phantom(mixer); 8854 if (err < 0) 8855 return err; 8856 8857 err = scarlett2_update_direct_monitor(mixer); 8858 if (err < 0) 8859 return err; 8860 8861 /* the rest of the configuration is for devices with a mixer */ 8862 if (!scarlett2_has_mixer(private)) 8863 return 0; 8864 8865 err = scarlett2_update_monitor_mix(mixer); 8866 if (err < 0) 8867 return err; 8868 8869 err = scarlett2_update_monitor_other(mixer); 8870 if (err < 0) 8871 return err; 8872 8873 if (scarlett2_has_config_item(private, 8874 SCARLETT2_CONFIG_STANDALONE_SWITCH)) { 8875 err = scarlett2_usb_get_config( 8876 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH, 8877 1, &private->standalone_switch); 8878 if (err < 0) 8879 return err; 8880 } 8881 8882 if (scarlett2_has_config_item(private, 8883 SCARLETT2_CONFIG_POWER_EXT)) { 8884 err = scarlett2_update_power_status(mixer); 8885 if (err < 0) 8886 return err; 8887 } 8888 8889 err = scarlett2_update_sync(mixer); 8890 if (err < 0) 8891 return err; 8892 8893 if (scarlett2_has_config_item(private, 8894 SCARLETT2_CONFIG_LINE_OUT_VOLUME)) { 8895 s16 sw_vol[SCARLETT2_ANALOGUE_MAX]; 8896 8897 /* read SW line out volume */ 8898 err = scarlett2_usb_get_config( 8899 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 8900 private->num_line_out, &sw_vol); 8901 if (err < 0) 8902 return err; 8903 8904 for (i = 0; i < private->num_line_out; i++) 8905 private->vol[i] = clamp( 8906 sw_vol[i] + SCARLETT2_VOLUME_BIAS, 8907 0, SCARLETT2_VOLUME_BIAS); 8908 8909 /* read SW mute */ 8910 err = scarlett2_usb_get_config( 8911 mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 8912 private->num_line_out, &private->mute_switch); 8913 if (err < 0) 8914 return err; 8915 8916 for (i = 0; i < private->num_line_out; i++) 8917 private->mute_switch[i] = 8918 !!private->mute_switch[i]; 8919 8920 /* read SW/HW switches */ 8921 if (scarlett2_has_config_item(private, 8922 SCARLETT2_CONFIG_SW_HW_SWITCH)) { 8923 err = scarlett2_usb_get_config( 8924 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, 8925 private->num_line_out, 8926 &private->vol_sw_hw_switch); 8927 if (err < 0) 8928 return err; 8929 8930 for (i = 0; i < private->num_line_out; i++) 8931 private->vol_sw_hw_switch[i] = 8932 !!private->vol_sw_hw_switch[i]; 8933 } 8934 } 8935 8936 err = scarlett2_update_volumes(mixer); 8937 if (err < 0) 8938 return err; 8939 8940 err = scarlett2_update_dim_mute(mixer); 8941 if (err < 0) 8942 return err; 8943 8944 err = scarlett2_update_input_select(mixer); 8945 if (err < 0) 8946 return err; 8947 8948 err = scarlett2_update_input_gain(mixer); 8949 if (err < 0) 8950 return err; 8951 8952 err = scarlett2_update_autogain(mixer); 8953 if (err < 0) 8954 return err; 8955 8956 err = scarlett2_update_input_safe(mixer); 8957 if (err < 0) 8958 return err; 8959 8960 if (scarlett2_has_config_item(private, 8961 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) { 8962 err = scarlett2_update_pcm_input_switch(mixer); 8963 if (err < 0) 8964 return err; 8965 } 8966 8967 err = scarlett2_update_bluetooth_volume(mixer); 8968 if (err < 0) 8969 return err; 8970 8971 err = scarlett2_update_spdif_mode(mixer); 8972 if (err < 0) 8973 return err; 8974 8975 err = scarlett2_update_mix(mixer); 8976 if (err < 0) 8977 return err; 8978 8979 return scarlett2_usb_get_mux(mixer); 8980} 8981 8982static const struct scarlett2_device_entry *get_scarlett2_device_entry( 8983 struct usb_mixer_interface *mixer) 8984{ 8985 const struct scarlett2_device_entry *entry = scarlett2_devices; 8986 8987 /* Find entry in scarlett2_devices */ 8988 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id) 8989 entry++; 8990 if (!entry->usb_id) 8991 return NULL; 8992 8993 return entry; 8994} 8995 8996static int snd_scarlett2_controls_create( 8997 struct usb_mixer_interface *mixer, 8998 const struct scarlett2_device_entry *entry) 8999{ 9000 struct scarlett2_data *private; 9001 int err; 9002 9003 /* Initialise private data */ 9004 err = scarlett2_init_private(mixer, entry); 9005 if (err < 0) 9006 return err; 9007 9008 private = mixer->private_data; 9009 9010 /* Send proprietary USB initialisation sequence */ 9011 err = scarlett2_usb_init(mixer); 9012 if (err < 0) 9013 return err; 9014 9015 /* Get the upgrade & settings flash segment numbers */ 9016 err = scarlett2_get_flash_segment_nums(mixer); 9017 if (err < 0) 9018 return err; 9019 9020 /* Add firmware version control */ 9021 err = scarlett2_add_firmware_version_ctl(mixer); 9022 if (err < 0) 9023 return err; 9024 9025 /* Add minimum firmware version control */ 9026 err = scarlett2_add_min_firmware_version_ctl(mixer); 9027 if (err < 0) 9028 return err; 9029 9030 /* Read volume levels and controls from the interface */ 9031 err = scarlett2_read_configs(mixer); 9032 if (err < 0) 9033 return err; 9034 9035 /* Create the MSD control */ 9036 err = scarlett2_add_msd_ctl(mixer); 9037 if (err < 0) 9038 return err; 9039 9040 /* If MSD mode is enabled, or if the firmware version is too 9041 * old, don't create any other controls 9042 */ 9043 if (private->msd_switch || 9044 private->firmware_version < private->info->min_firmware_version) 9045 return 0; 9046 9047 /* Create the analogue output controls */ 9048 err = scarlett2_add_line_out_ctls(mixer); 9049 if (err < 0) 9050 return err; 9051 9052 /* Create the analogue input controls */ 9053 err = scarlett2_add_line_in_ctls(mixer); 9054 if (err < 0) 9055 return err; 9056 9057 /* Create the input, output, and mixer mux input selections */ 9058 err = scarlett2_add_mux_enums(mixer); 9059 if (err < 0) 9060 return err; 9061 9062 /* Create the matrix mixer controls */ 9063 err = scarlett2_add_mixer_ctls(mixer); 9064 if (err < 0) 9065 return err; 9066 9067 /* Create the level meter controls */ 9068 err = scarlett2_add_meter_ctl(mixer); 9069 if (err < 0) 9070 return err; 9071 9072 /* Create the sync control */ 9073 err = scarlett2_add_sync_ctl(mixer); 9074 if (err < 0) 9075 return err; 9076 9077 /* Create the direct monitor control(s) */ 9078 err = scarlett2_add_direct_monitor_ctls(mixer); 9079 if (err < 0) 9080 return err; 9081 9082 /* Create the speaker switching control */ 9083 err = scarlett2_add_speaker_switch_ctl(mixer); 9084 if (err < 0) 9085 return err; 9086 9087 /* Create the talkback controls */ 9088 err = scarlett2_add_talkback_ctls(mixer); 9089 if (err < 0) 9090 return err; 9091 9092 /* Create the standalone control */ 9093 err = scarlett2_add_standalone_ctl(mixer); 9094 if (err < 0) 9095 return err; 9096 9097 /* Create the power status control */ 9098 err = scarlett2_add_power_status_ctl(mixer); 9099 if (err < 0) 9100 return err; 9101 9102 /* Create the Bluetooth volume control */ 9103 err = scarlett2_add_bluetooth_volume_ctl(mixer); 9104 if (err < 0) 9105 return err; 9106 9107 /* Create the S/PDIF mode control */ 9108 err = scarlett2_add_spdif_mode_ctl(mixer); 9109 if (err < 0) 9110 return err; 9111 9112 /* Set the access mode of controls disabled during 9113 * autogain/phantom power switching. 9114 */ 9115 if (private->info->gain_input_count) { 9116 scarlett2_autogain_update_access(mixer); 9117 scarlett2_phantom_update_access(mixer); 9118 } 9119 9120 /* Start handling all notifications */ 9121 private->running = 2; 9122 9123 return 0; 9124} 9125 9126/*** hwdep interface ***/ 9127 9128/* Set private->hwdep_in_use; prevents access to the ALSA controls 9129 * while doing a config erase/firmware upgrade. 9130 */ 9131static void scarlett2_lock(struct scarlett2_data *private) 9132{ 9133 mutex_lock(&private->data_mutex); 9134 private->hwdep_in_use = 1; 9135 mutex_unlock(&private->data_mutex); 9136} 9137 9138/* Call SCARLETT2_USB_GET_ERASE to get the erase progress */ 9139static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer) 9140{ 9141 struct scarlett2_data *private = mixer->private_data; 9142 int segment_id, segment_num, err; 9143 u8 erase_resp; 9144 9145 struct { 9146 __le32 segment_num; 9147 __le32 pad; 9148 } __packed erase_req; 9149 9150 segment_id = private->selected_flash_segment_id; 9151 segment_num = private->flash_segment_nums[segment_id]; 9152 9153 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 9154 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 9155 return -EFAULT; 9156 9157 /* Send the erase progress request */ 9158 erase_req.segment_num = cpu_to_le32(segment_num); 9159 erase_req.pad = 0; 9160 9161 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE, 9162 &erase_req, sizeof(erase_req), 9163 &erase_resp, sizeof(erase_resp)); 9164 if (err < 0) 9165 return err; 9166 9167 return erase_resp; 9168} 9169 9170/* Repeatedly call scarlett2_get_erase_progress() until it returns 9171 * 0xff (erase complete) or we've waited 10 seconds (it usually takes 9172 * <3 seconds). 9173 */ 9174static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer) 9175{ 9176 int i, err; 9177 9178 for (i = 0; i < 100; i++) { 9179 err = scarlett2_get_erase_progress(mixer); 9180 if (err < 0) 9181 return err; 9182 9183 if (err == 0xff) 9184 return 0; 9185 9186 msleep(100); 9187 } 9188 9189 return -ETIMEDOUT; 9190} 9191 9192/* Reboot the device; wait for the erase to complete if one is in 9193 * progress. 9194 */ 9195static int scarlett2_reboot(struct usb_mixer_interface *mixer) 9196{ 9197 struct scarlett2_data *private = mixer->private_data; 9198 9199 if (private->flash_write_state == 9200 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 9201 int err = scarlett2_wait_for_erase(mixer); 9202 9203 if (err < 0) 9204 return err; 9205 } 9206 9207 return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0); 9208} 9209 9210/* Select a flash segment for reading/erasing/writing */ 9211static int scarlett2_ioctl_select_flash_segment( 9212 struct usb_mixer_interface *mixer, 9213 unsigned long arg) 9214{ 9215 struct scarlett2_data *private = mixer->private_data; 9216 int segment_id, segment_num; 9217 9218 if (get_user(segment_id, (int __user *)arg)) 9219 return -EFAULT; 9220 9221 /* Check the segment ID and segment number */ 9222 if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT) 9223 return -EINVAL; 9224 9225 segment_num = private->flash_segment_nums[segment_id]; 9226 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 9227 segment_num > SCARLETT2_SEGMENT_NUM_MAX) { 9228 usb_audio_err(mixer->chip, 9229 "%s: invalid segment number %d\n", 9230 __func__, segment_id); 9231 return -EFAULT; 9232 } 9233 9234 /* If erasing, wait for it to complete */ 9235 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) { 9236 int err = scarlett2_wait_for_erase(mixer); 9237 9238 if (err < 0) 9239 return err; 9240 } 9241 9242 /* Save the selected segment ID and set the state to SELECTED */ 9243 private->selected_flash_segment_id = segment_id; 9244 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED; 9245 9246 return 0; 9247} 9248 9249/* Erase the previously-selected flash segment */ 9250static int scarlett2_ioctl_erase_flash_segment( 9251 struct usb_mixer_interface *mixer) 9252{ 9253 struct scarlett2_data *private = mixer->private_data; 9254 int segment_id, segment_num, err; 9255 9256 struct { 9257 __le32 segment_num; 9258 __le32 pad; 9259 } __packed erase_req; 9260 9261 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED) 9262 return -EINVAL; 9263 9264 segment_id = private->selected_flash_segment_id; 9265 segment_num = private->flash_segment_nums[segment_id]; 9266 9267 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 9268 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 9269 return -EFAULT; 9270 9271 /* Prevent access to ALSA controls that access the device from 9272 * here on 9273 */ 9274 scarlett2_lock(private); 9275 9276 /* Send the erase request */ 9277 erase_req.segment_num = cpu_to_le32(segment_num); 9278 erase_req.pad = 0; 9279 9280 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT, 9281 &erase_req, sizeof(erase_req), 9282 NULL, 0); 9283 if (err < 0) 9284 return err; 9285 9286 /* On success, change the state from SELECTED to ERASING */ 9287 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING; 9288 9289 return 0; 9290} 9291 9292/* Get the erase progress from the device */ 9293static int scarlett2_ioctl_get_erase_progress( 9294 struct usb_mixer_interface *mixer, 9295 unsigned long arg) 9296{ 9297 struct scarlett2_data *private = mixer->private_data; 9298 struct scarlett2_flash_segment_erase_progress progress; 9299 int segment_id, segment_num, err; 9300 u8 erase_resp; 9301 9302 struct { 9303 __le32 segment_num; 9304 __le32 pad; 9305 } __packed erase_req; 9306 9307 /* Check that we're erasing */ 9308 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) 9309 return -EINVAL; 9310 9311 segment_id = private->selected_flash_segment_id; 9312 segment_num = private->flash_segment_nums[segment_id]; 9313 9314 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 9315 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 9316 return -EFAULT; 9317 9318 /* Send the erase progress request */ 9319 erase_req.segment_num = cpu_to_le32(segment_num); 9320 erase_req.pad = 0; 9321 9322 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE, 9323 &erase_req, sizeof(erase_req), 9324 &erase_resp, sizeof(erase_resp)); 9325 if (err < 0) 9326 return err; 9327 9328 progress.progress = erase_resp; 9329 progress.num_blocks = private->flash_segment_blocks[segment_id]; 9330 9331 if (copy_to_user((void __user *)arg, &progress, sizeof(progress))) 9332 return -EFAULT; 9333 9334 /* If the erase is complete, change the state from ERASING to 9335 * WRITE. 9336 */ 9337 if (progress.progress == 0xff) 9338 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; 9339 9340 return 0; 9341} 9342 9343static int scarlett2_hwdep_open(struct snd_hwdep *hw, struct file *file) 9344{ 9345 struct usb_mixer_interface *mixer = hw->private_data; 9346 struct scarlett2_data *private = mixer->private_data; 9347 9348 /* If erasing, wait for it to complete */ 9349 if (private->flash_write_state == 9350 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 9351 int err = scarlett2_wait_for_erase(mixer); 9352 9353 if (err < 0) 9354 return err; 9355 } 9356 9357 /* Set the state to IDLE */ 9358 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; 9359 9360 return 0; 9361} 9362 9363static int scarlett2_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, 9364 unsigned int cmd, unsigned long arg) 9365{ 9366 struct usb_mixer_interface *mixer = hw->private_data; 9367 9368 switch (cmd) { 9369 9370 case SCARLETT2_IOCTL_PVERSION: 9371 return put_user(SCARLETT2_HWDEP_VERSION, 9372 (int __user *)arg) ? -EFAULT : 0; 9373 9374 case SCARLETT2_IOCTL_REBOOT: 9375 return scarlett2_reboot(mixer); 9376 9377 case SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT: 9378 return scarlett2_ioctl_select_flash_segment(mixer, arg); 9379 9380 case SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT: 9381 return scarlett2_ioctl_erase_flash_segment(mixer); 9382 9383 case SCARLETT2_IOCTL_GET_ERASE_PROGRESS: 9384 return scarlett2_ioctl_get_erase_progress(mixer, arg); 9385 9386 default: 9387 return -ENOIOCTLCMD; 9388 } 9389} 9390 9391static long scarlett2_hwdep_read(struct snd_hwdep *hw, 9392 char __user *buf, 9393 long count, loff_t *offset) 9394{ 9395 struct usb_mixer_interface *mixer = hw->private_data; 9396 struct scarlett2_data *private = mixer->private_data; 9397 int segment_id, segment_num, err; 9398 int flash_size; 9399 9400 /* SCARLETT2_USB_READ_SEGMENT request data */ 9401 struct { 9402 __le32 segment_num; 9403 __le32 offset; 9404 __le32 len; 9405 } __packed req; 9406 9407 u8 *resp; 9408 9409 /* Flash segment must first be selected */ 9410 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED) 9411 return -EINVAL; 9412 9413 /* Get the selected flash segment number */ 9414 segment_id = private->selected_flash_segment_id; 9415 if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT) 9416 return -EINVAL; 9417 9418 segment_num = private->flash_segment_nums[segment_id]; 9419 if (segment_num < 0 || 9420 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 9421 return -EFAULT; 9422 9423 /* Validate the offset and count */ 9424 if (count < 0 || *offset < 0) 9425 return -EINVAL; 9426 9427 /* Reached EOF? */ 9428 flash_size = private->flash_segment_blocks[segment_id] * 9429 SCARLETT2_FLASH_BLOCK_SIZE; 9430 if (!count || *offset >= flash_size) 9431 return 0; 9432 9433 /* Limit the numbers of bytes read to SCARLETT2_FLASH_RW_MAX */ 9434 if (count > SCARLETT2_FLASH_RW_MAX) 9435 count = SCARLETT2_FLASH_RW_MAX; 9436 9437 /* Limit read to EOF */ 9438 if (*offset + count >= flash_size) 9439 count = flash_size - *offset; 9440 9441 /* Create and send the request */ 9442 req.segment_num = cpu_to_le32(segment_num); 9443 req.offset = cpu_to_le32(*offset); 9444 req.len = cpu_to_le32(count); 9445 9446 resp = kzalloc(count, GFP_KERNEL); 9447 if (!resp) 9448 return -ENOMEM; 9449 9450 err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT, 9451 &req, sizeof(req), resp, count); 9452 if (err < 0) 9453 goto error; 9454 9455 /* Copy the response to userspace */ 9456 if (copy_to_user(buf, resp, count)) { 9457 err = -EFAULT; 9458 goto error; 9459 } 9460 9461 *offset += count; 9462 err = count; 9463 9464error: 9465 kfree(resp); 9466 return err; 9467} 9468 9469static long scarlett2_hwdep_write(struct snd_hwdep *hw, 9470 const char __user *buf, 9471 long count, loff_t *offset) 9472{ 9473 struct usb_mixer_interface *mixer = hw->private_data; 9474 struct scarlett2_data *private = mixer->private_data; 9475 int segment_id, segment_num, err, len; 9476 int flash_size; 9477 9478 /* SCARLETT2_USB_WRITE_SEGMENT request data */ 9479 struct { 9480 __le32 segment_num; 9481 __le32 offset; 9482 __le32 pad; 9483 u8 data[]; 9484 } __packed *req; 9485 9486 /* Calculate the maximum permitted in data[] */ 9487 const size_t max_data_size = SCARLETT2_FLASH_RW_MAX - 9488 offsetof(typeof(*req), data); 9489 9490 /* If erasing, wait for it to complete */ 9491 if (private->flash_write_state == 9492 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 9493 err = scarlett2_wait_for_erase(mixer); 9494 if (err < 0) 9495 return err; 9496 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; 9497 9498 /* Check that an erase has been done & completed */ 9499 } else if (private->flash_write_state != 9500 SCARLETT2_FLASH_WRITE_STATE_WRITE) { 9501 return -EINVAL; 9502 } 9503 9504 /* Check that we're writing to the upgrade firmware */ 9505 segment_id = private->selected_flash_segment_id; 9506 if (segment_id != SCARLETT2_SEGMENT_ID_FIRMWARE) 9507 return -EINVAL; 9508 9509 segment_num = private->flash_segment_nums[segment_id]; 9510 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 9511 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 9512 return -EFAULT; 9513 9514 /* Validate the offset and count */ 9515 flash_size = private->flash_segment_blocks[segment_id] * 9516 SCARLETT2_FLASH_BLOCK_SIZE; 9517 9518 if (count < 0 || *offset < 0 || *offset + count >= flash_size) 9519 return -EINVAL; 9520 9521 if (!count) 9522 return 0; 9523 9524 /* Limit the *req size to SCARLETT2_FLASH_RW_MAX */ 9525 if (count > max_data_size) 9526 count = max_data_size; 9527 9528 /* Create and send the request */ 9529 len = struct_size(req, data, count); 9530 req = kzalloc(len, GFP_KERNEL); 9531 if (!req) 9532 return -ENOMEM; 9533 9534 req->segment_num = cpu_to_le32(segment_num); 9535 req->offset = cpu_to_le32(*offset); 9536 req->pad = 0; 9537 9538 if (copy_from_user(req->data, buf, count)) { 9539 err = -EFAULT; 9540 goto error; 9541 } 9542 9543 err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT, 9544 req, len, NULL, 0); 9545 if (err < 0) 9546 goto error; 9547 9548 *offset += count; 9549 err = count; 9550 9551error: 9552 kfree(req); 9553 return err; 9554} 9555 9556static int scarlett2_hwdep_release(struct snd_hwdep *hw, struct file *file) 9557{ 9558 struct usb_mixer_interface *mixer = hw->private_data; 9559 struct scarlett2_data *private = mixer->private_data; 9560 9561 /* Return from the SELECTED or WRITE state to IDLE. 9562 * The ERASING state is left as-is, and checked on next open. 9563 */ 9564 if (private && 9565 private->hwdep_in_use && 9566 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) 9567 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; 9568 9569 return 0; 9570} 9571 9572static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer) 9573{ 9574 struct snd_hwdep *hw; 9575 int err; 9576 9577 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw); 9578 if (err < 0) 9579 return err; 9580 9581 hw->private_data = mixer; 9582 hw->exclusive = 1; 9583 hw->ops.open = scarlett2_hwdep_open; 9584 hw->ops.ioctl = scarlett2_hwdep_ioctl; 9585 hw->ops.read = scarlett2_hwdep_read; 9586 hw->ops.write = scarlett2_hwdep_write; 9587 hw->ops.release = scarlett2_hwdep_release; 9588 9589 return 0; 9590} 9591 9592int snd_scarlett2_init(struct usb_mixer_interface *mixer) 9593{ 9594 struct snd_usb_audio *chip = mixer->chip; 9595 const struct scarlett2_device_entry *entry; 9596 int err; 9597 9598 /* only use UAC_VERSION_2 */ 9599 if (!mixer->protocol) 9600 return 0; 9601 9602 /* find entry in scarlett2_devices */ 9603 entry = get_scarlett2_device_entry(mixer); 9604 if (!entry) { 9605 usb_audio_err(mixer->chip, 9606 "%s: missing device entry for %04x:%04x\n", 9607 __func__, 9608 USB_ID_VENDOR(chip->usb_id), 9609 USB_ID_PRODUCT(chip->usb_id)); 9610 return 0; 9611 } 9612 9613 if (chip->setup & SCARLETT2_DISABLE) { 9614 usb_audio_info(chip, 9615 "Focusrite %s Mixer Driver disabled " 9616 "by modprobe options (snd_usb_audio " 9617 "vid=0x%04x pid=0x%04x device_setup=%d)\n", 9618 entry->series_name, 9619 USB_ID_VENDOR(chip->usb_id), 9620 USB_ID_PRODUCT(chip->usb_id), 9621 SCARLETT2_DISABLE); 9622 return 0; 9623 } 9624 9625 usb_audio_info(chip, 9626 "Focusrite %s Mixer Driver enabled (pid=0x%04x); " 9627 "report any issues to " 9628 "https://github.com/geoffreybennett/scarlett-gen2/issues", 9629 entry->series_name, 9630 USB_ID_PRODUCT(chip->usb_id)); 9631 9632 err = snd_scarlett2_controls_create(mixer, entry); 9633 if (err < 0) { 9634 usb_audio_err(mixer->chip, 9635 "Error initialising %s Mixer Driver: %d", 9636 entry->series_name, 9637 err); 9638 return err; 9639 } 9640 9641 err = scarlett2_hwdep_init(mixer); 9642 if (err < 0) 9643 usb_audio_err(mixer->chip, 9644 "Error creating %s hwdep device: %d", 9645 entry->series_name, 9646 err); 9647 9648 return err; 9649} 9650