1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Focusrite Scarlett Gen 2/3 and Clarett+ Driver for ALSA 4 * 5 * Supported models: 6 * - 6i6/18i8/18i20 Gen 2 7 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3 8 * - Clarett+ 8Pre 9 * 10 * Copyright (c) 2018-2022 by Geoffrey D. Bennett <g at b4.vu> 11 * Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com> 12 * Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com> 13 * 14 * Based on the Scarlett (Gen 1) Driver for ALSA: 15 * 16 * Copyright (c) 2013 by Tobias Hoffmann 17 * Copyright (c) 2013 by Robin Gareus <robin at gareus.org> 18 * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de> 19 * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com> 20 * 21 * Many codes borrowed from audio.c by 22 * Alan Cox (alan at lxorguk.ukuu.org.uk) 23 * Thomas Sailer (sailer at ife.ee.ethz.ch) 24 * 25 * Code cleanup: 26 * David Henningsson <david.henningsson at canonical.com> 27 */ 28 29/* The protocol was reverse engineered by looking at the communication 30 * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20 31 * (firmware 1083) using usbmon in July-August 2018. 32 * 33 * Scarlett 18i8 support added in April 2019. 34 * 35 * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann 36 * for providing usbmon output and testing). 37 * 38 * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent 39 * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6 40 * usbmon output and testing). 41 * 42 * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to 43 * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon 44 * output, protocol traces and testing). 45 * 46 * Support for loading mixer volume and mux configuration from the 47 * interface during driver initialisation added in May 2021 (thanks to 48 * Vladimir Sadovnikov for figuring out how). 49 * 50 * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander 51 * Vorona for 2i2 protocol traces). 52 * 53 * Support for phantom power, direct monitoring, speaker switching, 54 * and talkback added in May-June 2021. 55 * 56 * Support for Clarett+ 8Pre added in Aug 2022 by Christian 57 * Colglazier. 58 * 59 * This ALSA mixer gives access to (model-dependent): 60 * - input, output, mixer-matrix muxes 61 * - mixer-matrix gain stages 62 * - gain/volume/mute controls 63 * - level meters 64 * - line/inst level, pad, and air controls 65 * - phantom power, direct monitor, speaker switching, and talkback 66 * controls 67 * - disable/enable MSD mode 68 * - disable/enable standalone mode 69 * 70 * <ditaa> 71 * /--------------\ 18chn 20chn /--------------\ 72 * | Hardware in +--+------\ /-------------+--+ ALSA PCM out | 73 * \--------------/ | | | | \--------------/ 74 * | | | /-----\ | 75 * | | | | | | 76 * | v v v | | 77 * | +---------------+ | | 78 * | \ Matrix Mux / | | 79 * | +-----+-----+ | | 80 * | | | | 81 * | |18chn | | 82 * | | | | 83 * | | 10chn| | 84 * | v | | 85 * | +------------+ | | 86 * | | Mixer | | | 87 * | | Matrix | | | 88 * | | | | | 89 * | | 18x10 Gain | | | 90 * | | stages | | | 91 * | +-----+------+ | | 92 * | | | | 93 * |18chn |10chn | |20chn 94 * | | | | 95 * | +----------/ | 96 * | | | 97 * v v v 98 * =========================== 99 * +---------------+ +--—------------+ 100 * \ Output Mux / \ Capture Mux / 101 * +---+---+---+ +-----+-----+ 102 * | | | 103 * 10chn| | |18chn 104 * | | | 105 * /--------------\ | | | /--------------\ 106 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in | 107 * | Hardware out | | \--------------/ 108 * \--------------/ | 109 * v 110 * +-------------+ Software gain per channel. 111 * | Master Gain |<-- 18i20 only: Switch per channel 112 * +------+------+ to select HW or SW gain control. 113 * | 114 * |10chn 115 * /--------------\ | 116 * | Analogue |<------/ 117 * | Hardware out | 118 * \--------------/ 119 * </ditaa> 120 * 121 * Gen 3 devices have a Mass Storage Device (MSD) mode where a small 122 * disk with registration and driver download information is presented 123 * to the host. To access the full functionality of the device without 124 * proprietary software, MSD mode can be disabled by: 125 * - holding down the 48V button for five seconds while powering on 126 * the device, or 127 * - using this driver and alsamixer to change the "MSD Mode" setting 128 * to Off and power-cycling the device 129 */ 130 131#include <linux/slab.h> 132#include <linux/usb.h> 133#include <linux/moduleparam.h> 134 135#include <sound/control.h> 136#include <sound/tlv.h> 137 138#include "usbaudio.h" 139#include "mixer.h" 140#include "helper.h" 141 142#include "mixer_scarlett_gen2.h" 143 144/* device_setup value to enable */ 145#define SCARLETT2_ENABLE 0x01 146 147/* device_setup value to allow turning MSD mode back on */ 148#define SCARLETT2_MSD_ENABLE 0x02 149 150/* some gui mixers can't handle negative ctl values */ 151#define SCARLETT2_VOLUME_BIAS 127 152 153/* mixer range from -80dB to +6dB in 0.5dB steps */ 154#define SCARLETT2_MIXER_MIN_DB -80 155#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2) 156#define SCARLETT2_MIXER_MAX_DB 6 157#define SCARLETT2_MIXER_MAX_VALUE \ 158 ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2) 159#define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1) 160 161/* map from (dB + 80) * 2 to mixer value 162 * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20))) 163 */ 164static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = { 165 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 166 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8, 167 9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 168 23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51, 169 54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115, 170 122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230, 171 244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460, 172 487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919, 173 973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634, 174 1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906, 175 3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168, 176 5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191, 177 9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430, 178 16345 179}; 180 181/* Maximum number of analogue outputs */ 182#define SCARLETT2_ANALOGUE_MAX 10 183 184/* Maximum number of level and pad switches */ 185#define SCARLETT2_LEVEL_SWITCH_MAX 2 186#define SCARLETT2_PAD_SWITCH_MAX 8 187#define SCARLETT2_AIR_SWITCH_MAX 8 188#define SCARLETT2_PHANTOM_SWITCH_MAX 2 189 190/* Maximum number of inputs to the mixer */ 191#define SCARLETT2_INPUT_MIX_MAX 25 192 193/* Maximum number of outputs from the mixer */ 194#define SCARLETT2_OUTPUT_MIX_MAX 12 195 196/* Maximum size of the data in the USB mux assignment message: 197 * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare 198 */ 199#define SCARLETT2_MUX_MAX 77 200 201/* Maximum number of meters (sum of output port counts) */ 202#define SCARLETT2_MAX_METERS 65 203 204/* There are three different sets of configuration parameters across 205 * the devices 206 */ 207enum { 208 SCARLETT2_CONFIG_SET_NO_MIXER = 0, 209 SCARLETT2_CONFIG_SET_GEN_2 = 1, 210 SCARLETT2_CONFIG_SET_GEN_3 = 2, 211 SCARLETT2_CONFIG_SET_CLARETT = 3, 212 SCARLETT2_CONFIG_SET_COUNT = 4 213}; 214 215/* Hardware port types: 216 * - None (no input to mux) 217 * - Analogue I/O 218 * - S/PDIF I/O 219 * - ADAT I/O 220 * - Mixer I/O 221 * - PCM I/O 222 */ 223enum { 224 SCARLETT2_PORT_TYPE_NONE = 0, 225 SCARLETT2_PORT_TYPE_ANALOGUE = 1, 226 SCARLETT2_PORT_TYPE_SPDIF = 2, 227 SCARLETT2_PORT_TYPE_ADAT = 3, 228 SCARLETT2_PORT_TYPE_MIX = 4, 229 SCARLETT2_PORT_TYPE_PCM = 5, 230 SCARLETT2_PORT_TYPE_COUNT = 6, 231}; 232 233/* I/O count of each port type kept in struct scarlett2_ports */ 234enum { 235 SCARLETT2_PORT_IN = 0, 236 SCARLETT2_PORT_OUT = 1, 237 SCARLETT2_PORT_DIRNS = 2, 238}; 239 240/* Dim/Mute buttons on the 18i20 */ 241enum { 242 SCARLETT2_BUTTON_MUTE = 0, 243 SCARLETT2_BUTTON_DIM = 1, 244 SCARLETT2_DIM_MUTE_COUNT = 2, 245}; 246 247static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = { 248 "Mute Playback Switch", "Dim Playback Switch" 249}; 250 251/* Description of each hardware port type: 252 * - id: hardware ID of this port type 253 * - src_descr: printf format string for mux input selections 254 * - src_num_offset: added to channel number for the fprintf 255 * - dst_descr: printf format string for mixer controls 256 */ 257struct scarlett2_port { 258 u16 id; 259 const char * const src_descr; 260 int src_num_offset; 261 const char * const dst_descr; 262}; 263 264static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = { 265 [SCARLETT2_PORT_TYPE_NONE] = { 266 .id = 0x000, 267 .src_descr = "Off" 268 }, 269 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 270 .id = 0x080, 271 .src_descr = "Analogue %d", 272 .src_num_offset = 1, 273 .dst_descr = "Analogue Output %02d Playback" 274 }, 275 [SCARLETT2_PORT_TYPE_SPDIF] = { 276 .id = 0x180, 277 .src_descr = "S/PDIF %d", 278 .src_num_offset = 1, 279 .dst_descr = "S/PDIF Output %d Playback" 280 }, 281 [SCARLETT2_PORT_TYPE_ADAT] = { 282 .id = 0x200, 283 .src_descr = "ADAT %d", 284 .src_num_offset = 1, 285 .dst_descr = "ADAT Output %d Playback" 286 }, 287 [SCARLETT2_PORT_TYPE_MIX] = { 288 .id = 0x300, 289 .src_descr = "Mix %c", 290 .src_num_offset = 'A', 291 .dst_descr = "Mixer Input %02d Capture" 292 }, 293 [SCARLETT2_PORT_TYPE_PCM] = { 294 .id = 0x600, 295 .src_descr = "PCM %d", 296 .src_num_offset = 1, 297 .dst_descr = "PCM %02d Capture" 298 }, 299}; 300 301/* Number of mux tables: one for each band of sample rates 302 * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz) 303 */ 304#define SCARLETT2_MUX_TABLES 3 305 306/* Maximum number of entries in a mux table */ 307#define SCARLETT2_MAX_MUX_ENTRIES 10 308 309/* One entry within mux_assignment defines the port type and range of 310 * ports to add to the set_mux message. The end of the list is marked 311 * with count == 0. 312 */ 313struct scarlett2_mux_entry { 314 u8 port_type; 315 u8 start; 316 u8 count; 317}; 318 319struct scarlett2_device_info { 320 u32 usb_id; /* USB device identifier */ 321 322 /* Gen 3 devices have an internal MSD mode switch that needs 323 * to be disabled in order to access the full functionality of 324 * the device. 325 */ 326 u8 has_msd_mode; 327 328 /* which set of configuration parameters the device uses */ 329 u8 config_set; 330 331 /* line out hw volume is sw controlled */ 332 u8 line_out_hw_vol; 333 334 /* support for main/alt speaker switching */ 335 u8 has_speaker_switching; 336 337 /* support for talkback microphone */ 338 u8 has_talkback; 339 340 /* the number of analogue inputs with a software switchable 341 * level control that can be set to line or instrument 342 */ 343 u8 level_input_count; 344 345 /* the first input with a level control (0-based) */ 346 u8 level_input_first; 347 348 /* the number of analogue inputs with a software switchable 349 * 10dB pad control 350 */ 351 u8 pad_input_count; 352 353 /* the number of analogue inputs with a software switchable 354 * "air" control 355 */ 356 u8 air_input_count; 357 358 /* the number of phantom (48V) software switchable controls */ 359 u8 phantom_count; 360 361 /* the number of inputs each phantom switch controls */ 362 u8 inputs_per_phantom; 363 364 /* the number of direct monitor options 365 * (0 = none, 1 = mono only, 2 = mono/stereo) 366 */ 367 u8 direct_monitor; 368 369 /* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected 370 * internally to the analogue 7/8 outputs 371 */ 372 u8 line_out_remap_enable; 373 u8 line_out_remap[SCARLETT2_ANALOGUE_MAX]; 374 375 /* additional description for the line out volume controls */ 376 const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX]; 377 378 /* number of sources/destinations of each port type */ 379 const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS]; 380 381 /* layout/order of the entries in the set_mux message */ 382 struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES] 383 [SCARLETT2_MAX_MUX_ENTRIES]; 384}; 385 386struct scarlett2_data { 387 struct usb_mixer_interface *mixer; 388 struct mutex usb_mutex; /* prevent sending concurrent USB requests */ 389 struct mutex data_mutex; /* lock access to this data */ 390 struct delayed_work work; 391 const struct scarlett2_device_info *info; 392 __u8 bInterfaceNumber; 393 __u8 bEndpointAddress; 394 __u16 wMaxPacketSize; 395 __u8 bInterval; 396 int num_mux_srcs; 397 int num_mux_dsts; 398 u16 scarlett2_seq; 399 u8 sync_updated; 400 u8 vol_updated; 401 u8 input_other_updated; 402 u8 monitor_other_updated; 403 u8 mux_updated; 404 u8 speaker_switching_switched; 405 u8 sync; 406 u8 master_vol; 407 u8 vol[SCARLETT2_ANALOGUE_MAX]; 408 u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX]; 409 u8 mute_switch[SCARLETT2_ANALOGUE_MAX]; 410 u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX]; 411 u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX]; 412 u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT]; 413 u8 air_switch[SCARLETT2_AIR_SWITCH_MAX]; 414 u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX]; 415 u8 phantom_persistence; 416 u8 direct_monitor_switch; 417 u8 speaker_switching_switch; 418 u8 talkback_switch; 419 u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX]; 420 u8 msd_switch; 421 u8 standalone_switch; 422 struct snd_kcontrol *sync_ctl; 423 struct snd_kcontrol *master_vol_ctl; 424 struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX]; 425 struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX]; 426 struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX]; 427 struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT]; 428 struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX]; 429 struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX]; 430 struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX]; 431 struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX]; 432 struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX]; 433 struct snd_kcontrol *direct_monitor_ctl; 434 struct snd_kcontrol *speaker_switching_ctl; 435 struct snd_kcontrol *talkback_ctl; 436 u8 mux[SCARLETT2_MUX_MAX]; 437 u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX]; 438}; 439 440/*** Model-specific data ***/ 441 442static const struct scarlett2_device_info s6i6_gen2_info = { 443 .usb_id = USB_ID(0x1235, 0x8203), 444 445 .config_set = SCARLETT2_CONFIG_SET_GEN_2, 446 .level_input_count = 2, 447 .pad_input_count = 2, 448 449 .line_out_descrs = { 450 "Headphones 1 L", 451 "Headphones 1 R", 452 "Headphones 2 L", 453 "Headphones 2 R", 454 }, 455 456 .port_count = { 457 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 458 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, 459 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 460 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 461 [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 }, 462 }, 463 464 .mux_assignment = { { 465 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 466 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 467 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 468 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 469 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 470 { 0, 0, 0 }, 471 }, { 472 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 473 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 474 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 475 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 476 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 477 { 0, 0, 0 }, 478 }, { 479 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 480 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 481 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 482 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 483 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 484 { 0, 0, 0 }, 485 } }, 486}; 487 488static const struct scarlett2_device_info s18i8_gen2_info = { 489 .usb_id = USB_ID(0x1235, 0x8204), 490 491 .config_set = SCARLETT2_CONFIG_SET_GEN_2, 492 .level_input_count = 2, 493 .pad_input_count = 4, 494 495 .line_out_descrs = { 496 "Monitor L", 497 "Monitor R", 498 "Headphones 1 L", 499 "Headphones 1 R", 500 "Headphones 2 L", 501 "Headphones 2 R", 502 }, 503 504 .port_count = { 505 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 506 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 }, 507 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 508 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 509 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 510 [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 }, 511 }, 512 513 .mux_assignment = { { 514 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 515 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 516 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 517 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 518 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 519 { 0, 0, 0 }, 520 }, { 521 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 522 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 523 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 524 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 525 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 526 { 0, 0, 0 }, 527 }, { 528 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 529 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 530 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 531 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 532 { SCARLETT2_PORT_TYPE_NONE, 0, 4 }, 533 { 0, 0, 0 }, 534 } }, 535}; 536 537static const struct scarlett2_device_info s18i20_gen2_info = { 538 .usb_id = USB_ID(0x1235, 0x8201), 539 540 .config_set = SCARLETT2_CONFIG_SET_GEN_2, 541 .line_out_hw_vol = 1, 542 543 .line_out_descrs = { 544 "Monitor L", 545 "Monitor R", 546 NULL, 547 NULL, 548 NULL, 549 NULL, 550 "Headphones 1 L", 551 "Headphones 1 R", 552 "Headphones 2 L", 553 "Headphones 2 R", 554 }, 555 556 .port_count = { 557 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 558 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, 559 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 560 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 561 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 562 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, 563 }, 564 565 .mux_assignment = { { 566 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 567 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 568 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 569 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 570 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 571 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 572 { 0, 0, 0 }, 573 }, { 574 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 575 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 576 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 577 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, 578 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 579 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 580 { 0, 0, 0 }, 581 }, { 582 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 583 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 584 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 585 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 586 { SCARLETT2_PORT_TYPE_NONE, 0, 6 }, 587 { 0, 0, 0 }, 588 } }, 589}; 590 591static const struct scarlett2_device_info solo_gen3_info = { 592 .usb_id = USB_ID(0x1235, 0x8211), 593 594 .has_msd_mode = 1, 595 .config_set = SCARLETT2_CONFIG_SET_NO_MIXER, 596 .level_input_count = 1, 597 .level_input_first = 1, 598 .air_input_count = 1, 599 .phantom_count = 1, 600 .inputs_per_phantom = 1, 601 .direct_monitor = 1, 602}; 603 604static const struct scarlett2_device_info s2i2_gen3_info = { 605 .usb_id = USB_ID(0x1235, 0x8210), 606 607 .has_msd_mode = 1, 608 .config_set = SCARLETT2_CONFIG_SET_NO_MIXER, 609 .level_input_count = 2, 610 .air_input_count = 2, 611 .phantom_count = 1, 612 .inputs_per_phantom = 2, 613 .direct_monitor = 2, 614}; 615 616static const struct scarlett2_device_info s4i4_gen3_info = { 617 .usb_id = USB_ID(0x1235, 0x8212), 618 619 .has_msd_mode = 1, 620 .config_set = SCARLETT2_CONFIG_SET_GEN_3, 621 .level_input_count = 2, 622 .pad_input_count = 2, 623 .air_input_count = 2, 624 .phantom_count = 1, 625 .inputs_per_phantom = 2, 626 627 .line_out_descrs = { 628 "Monitor L", 629 "Monitor R", 630 "Headphones L", 631 "Headphones R", 632 }, 633 634 .port_count = { 635 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 636 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, 637 [SCARLETT2_PORT_TYPE_MIX] = { 6, 8 }, 638 [SCARLETT2_PORT_TYPE_PCM] = { 4, 6 }, 639 }, 640 641 .mux_assignment = { { 642 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 643 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 644 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 645 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 646 { 0, 0, 0 }, 647 }, { 648 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 649 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 650 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 651 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 652 { 0, 0, 0 }, 653 }, { 654 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 655 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 656 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 657 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 658 { 0, 0, 0 }, 659 } }, 660}; 661 662static const struct scarlett2_device_info s8i6_gen3_info = { 663 .usb_id = USB_ID(0x1235, 0x8213), 664 665 .has_msd_mode = 1, 666 .config_set = SCARLETT2_CONFIG_SET_GEN_3, 667 .level_input_count = 2, 668 .pad_input_count = 2, 669 .air_input_count = 2, 670 .phantom_count = 1, 671 .inputs_per_phantom = 2, 672 673 .line_out_descrs = { 674 "Headphones 1 L", 675 "Headphones 1 R", 676 "Headphones 2 L", 677 "Headphones 2 R", 678 }, 679 680 .port_count = { 681 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 682 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 }, 683 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 684 [SCARLETT2_PORT_TYPE_MIX] = { 8, 8 }, 685 [SCARLETT2_PORT_TYPE_PCM] = { 6, 10 }, 686 }, 687 688 .mux_assignment = { { 689 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 690 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 691 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 692 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 693 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 694 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 695 { 0, 0, 0 }, 696 }, { 697 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 698 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 699 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 700 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 701 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 702 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 703 { 0, 0, 0 }, 704 }, { 705 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 706 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 707 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 708 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 709 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 710 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 711 { 0, 0, 0 }, 712 } }, 713}; 714 715static const struct scarlett2_device_info s18i8_gen3_info = { 716 .usb_id = USB_ID(0x1235, 0x8214), 717 718 .has_msd_mode = 1, 719 .config_set = SCARLETT2_CONFIG_SET_GEN_3, 720 .line_out_hw_vol = 1, 721 .has_speaker_switching = 1, 722 .level_input_count = 2, 723 .pad_input_count = 4, 724 .air_input_count = 4, 725 .phantom_count = 2, 726 .inputs_per_phantom = 2, 727 728 .line_out_remap_enable = 1, 729 .line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 }, 730 731 .line_out_descrs = { 732 "Monitor L", 733 "Monitor R", 734 "Alt Monitor L", 735 "Alt Monitor R", 736 "Headphones 1 L", 737 "Headphones 1 R", 738 "Headphones 2 L", 739 "Headphones 2 R", 740 }, 741 742 .port_count = { 743 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 744 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 }, 745 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 746 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 747 [SCARLETT2_PORT_TYPE_MIX] = { 10, 20 }, 748 [SCARLETT2_PORT_TYPE_PCM] = { 8, 20 }, 749 }, 750 751 .mux_assignment = { { 752 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 753 { SCARLETT2_PORT_TYPE_PCM, 12, 8 }, 754 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 755 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 756 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 757 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 758 { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, 759 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 760 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 761 { 0, 0, 0 }, 762 }, { 763 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 764 { SCARLETT2_PORT_TYPE_PCM, 12, 4 }, 765 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 766 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 767 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 768 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 769 { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, 770 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 771 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 772 { 0, 0, 0 }, 773 }, { 774 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 775 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 776 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 777 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 778 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 779 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 780 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 781 { 0, 0, 0 }, 782 } }, 783}; 784 785static const struct scarlett2_device_info s18i20_gen3_info = { 786 .usb_id = USB_ID(0x1235, 0x8215), 787 788 .has_msd_mode = 1, 789 .config_set = SCARLETT2_CONFIG_SET_GEN_3, 790 .line_out_hw_vol = 1, 791 .has_speaker_switching = 1, 792 .has_talkback = 1, 793 .level_input_count = 2, 794 .pad_input_count = 8, 795 .air_input_count = 8, 796 .phantom_count = 2, 797 .inputs_per_phantom = 4, 798 799 .line_out_descrs = { 800 "Monitor 1 L", 801 "Monitor 1 R", 802 "Monitor 2 L", 803 "Monitor 2 R", 804 NULL, 805 NULL, 806 "Headphones 1 L", 807 "Headphones 1 R", 808 "Headphones 2 L", 809 "Headphones 2 R", 810 }, 811 812 .port_count = { 813 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 814 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 }, 815 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 816 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 817 [SCARLETT2_PORT_TYPE_MIX] = { 12, 25 }, 818 [SCARLETT2_PORT_TYPE_PCM] = { 20, 20 }, 819 }, 820 821 .mux_assignment = { { 822 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 823 { SCARLETT2_PORT_TYPE_PCM, 10, 10 }, 824 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 825 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 826 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 827 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 828 { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, 829 { SCARLETT2_PORT_TYPE_NONE, 0, 12 }, 830 { 0, 0, 0 }, 831 }, { 832 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 833 { SCARLETT2_PORT_TYPE_PCM, 10, 8 }, 834 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 835 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 836 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 837 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 838 { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, 839 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 840 { 0, 0, 0 }, 841 }, { 842 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 843 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 844 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 845 { SCARLETT2_PORT_TYPE_NONE, 0, 24 }, 846 { 0, 0, 0 }, 847 } }, 848}; 849 850static const struct scarlett2_device_info clarett_8pre_info = { 851 .usb_id = USB_ID(0x1235, 0x820c), 852 853 .config_set = SCARLETT2_CONFIG_SET_CLARETT, 854 .line_out_hw_vol = 1, 855 .level_input_count = 2, 856 .air_input_count = 8, 857 858 .line_out_descrs = { 859 "Monitor L", 860 "Monitor R", 861 NULL, 862 NULL, 863 NULL, 864 NULL, 865 "Headphones 1 L", 866 "Headphones 1 R", 867 "Headphones 2 L", 868 "Headphones 2 R", 869 }, 870 871 .port_count = { 872 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 873 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, 874 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 875 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 876 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 877 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, 878 }, 879 880 .mux_assignment = { { 881 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 882 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 883 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 884 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 885 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 886 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 887 { 0, 0, 0 }, 888 }, { 889 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 890 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 891 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 892 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, 893 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 894 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 895 { 0, 0, 0 }, 896 }, { 897 { SCARLETT2_PORT_TYPE_PCM, 0, 12 }, 898 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 899 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 900 { SCARLETT2_PORT_TYPE_NONE, 0, 22 }, 901 { 0, 0, 0 }, 902 } }, 903}; 904 905static const struct scarlett2_device_info *scarlett2_devices[] = { 906 /* Supported Gen 2 devices */ 907 &s6i6_gen2_info, 908 &s18i8_gen2_info, 909 &s18i20_gen2_info, 910 911 /* Supported Gen 3 devices */ 912 &solo_gen3_info, 913 &s2i2_gen3_info, 914 &s4i4_gen3_info, 915 &s8i6_gen3_info, 916 &s18i8_gen3_info, 917 &s18i20_gen3_info, 918 919 /* Supported Clarett+ devices */ 920 &clarett_8pre_info, 921 922 /* End of list */ 923 NULL 924}; 925 926/* get the starting port index number for a given port type/direction */ 927static int scarlett2_get_port_start_num( 928 const int port_count[][SCARLETT2_PORT_DIRNS], 929 int direction, int port_type) 930{ 931 int i, num = 0; 932 933 for (i = 0; i < port_type; i++) 934 num += port_count[i][direction]; 935 936 return num; 937} 938 939/*** USB Interactions ***/ 940 941/* Notifications from the interface */ 942#define SCARLETT2_USB_NOTIFY_SYNC 0x00000008 943#define SCARLETT2_USB_NOTIFY_DIM_MUTE 0x00200000 944#define SCARLETT2_USB_NOTIFY_MONITOR 0x00400000 945#define SCARLETT2_USB_NOTIFY_INPUT_OTHER 0x00800000 946#define SCARLETT2_USB_NOTIFY_MONITOR_OTHER 0x01000000 947 948/* Commands for sending/receiving requests/responses */ 949#define SCARLETT2_USB_CMD_INIT 0 950#define SCARLETT2_USB_CMD_REQ 2 951#define SCARLETT2_USB_CMD_RESP 3 952 953#define SCARLETT2_USB_INIT_1 0x00000000 954#define SCARLETT2_USB_INIT_2 0x00000002 955#define SCARLETT2_USB_GET_METER 0x00001001 956#define SCARLETT2_USB_GET_MIX 0x00002001 957#define SCARLETT2_USB_SET_MIX 0x00002002 958#define SCARLETT2_USB_GET_MUX 0x00003001 959#define SCARLETT2_USB_SET_MUX 0x00003002 960#define SCARLETT2_USB_GET_SYNC 0x00006004 961#define SCARLETT2_USB_GET_DATA 0x00800000 962#define SCARLETT2_USB_SET_DATA 0x00800001 963#define SCARLETT2_USB_DATA_CMD 0x00800002 964 965#define SCARLETT2_USB_CONFIG_SAVE 6 966 967#define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31 968#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1 969 970/* volume status is read together (matches scarlett2_config_items[1]) */ 971struct scarlett2_usb_volume_status { 972 /* dim/mute buttons */ 973 u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT]; 974 975 u8 pad1; 976 977 /* software volume setting */ 978 s16 sw_vol[SCARLETT2_ANALOGUE_MAX]; 979 980 /* actual volume of output inc. dim (-18dB) */ 981 s16 hw_vol[SCARLETT2_ANALOGUE_MAX]; 982 983 /* internal mute buttons */ 984 u8 mute_switch[SCARLETT2_ANALOGUE_MAX]; 985 986 /* sw (0) or hw (1) controlled */ 987 u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX]; 988 989 u8 pad3[6]; 990 991 /* front panel volume knob */ 992 s16 master_vol; 993} __packed; 994 995/* Configuration parameters that can be read and written */ 996enum { 997 SCARLETT2_CONFIG_DIM_MUTE = 0, 998 SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1, 999 SCARLETT2_CONFIG_MUTE_SWITCH = 2, 1000 SCARLETT2_CONFIG_SW_HW_SWITCH = 3, 1001 SCARLETT2_CONFIG_LEVEL_SWITCH = 4, 1002 SCARLETT2_CONFIG_PAD_SWITCH = 5, 1003 SCARLETT2_CONFIG_MSD_SWITCH = 6, 1004 SCARLETT2_CONFIG_AIR_SWITCH = 7, 1005 SCARLETT2_CONFIG_STANDALONE_SWITCH = 8, 1006 SCARLETT2_CONFIG_PHANTOM_SWITCH = 9, 1007 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE = 10, 1008 SCARLETT2_CONFIG_DIRECT_MONITOR = 11, 1009 SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH = 12, 1010 SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE = 13, 1011 SCARLETT2_CONFIG_TALKBACK_MAP = 14, 1012 SCARLETT2_CONFIG_COUNT = 15 1013}; 1014 1015/* Location, size, and activation command number for the configuration 1016 * parameters. Size is in bits and may be 1, 8, or 16. 1017 */ 1018struct scarlett2_config { 1019 u8 offset; 1020 u8 size; 1021 u8 activate; 1022}; 1023 1024static const struct scarlett2_config 1025 scarlett2_config_items[SCARLETT2_CONFIG_SET_COUNT] 1026 [SCARLETT2_CONFIG_COUNT] = 1027 1028/* Devices without a mixer (Gen 3 Solo and 2i2) */ 1029{ { 1030 [SCARLETT2_CONFIG_MSD_SWITCH] = { 1031 .offset = 0x04, .size = 8, .activate = 6 }, 1032 1033 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { 1034 .offset = 0x05, .size = 8, .activate = 6 }, 1035 1036 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 1037 .offset = 0x06, .size = 8, .activate = 3 }, 1038 1039 [SCARLETT2_CONFIG_DIRECT_MONITOR] = { 1040 .offset = 0x07, .size = 8, .activate = 4 }, 1041 1042 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 1043 .offset = 0x08, .size = 1, .activate = 7 }, 1044 1045 [SCARLETT2_CONFIG_AIR_SWITCH] = { 1046 .offset = 0x09, .size = 1, .activate = 8 }, 1047 1048/* Gen 2 devices: 6i6, 18i8, 18i20 */ 1049}, { 1050 [SCARLETT2_CONFIG_DIM_MUTE] = { 1051 .offset = 0x31, .size = 8, .activate = 2 }, 1052 1053 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 1054 .offset = 0x34, .size = 16, .activate = 1 }, 1055 1056 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 1057 .offset = 0x5c, .size = 8, .activate = 1 }, 1058 1059 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 1060 .offset = 0x66, .size = 8, .activate = 3 }, 1061 1062 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 1063 .offset = 0x7c, .size = 8, .activate = 7 }, 1064 1065 [SCARLETT2_CONFIG_PAD_SWITCH] = { 1066 .offset = 0x84, .size = 8, .activate = 8 }, 1067 1068 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 1069 .offset = 0x8d, .size = 8, .activate = 6 }, 1070 1071/* Gen 3 devices: 4i4, 8i6, 18i8, 18i20 */ 1072}, { 1073 [SCARLETT2_CONFIG_DIM_MUTE] = { 1074 .offset = 0x31, .size = 8, .activate = 2 }, 1075 1076 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 1077 .offset = 0x34, .size = 16, .activate = 1 }, 1078 1079 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 1080 .offset = 0x5c, .size = 8, .activate = 1 }, 1081 1082 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 1083 .offset = 0x66, .size = 8, .activate = 3 }, 1084 1085 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 1086 .offset = 0x7c, .size = 8, .activate = 7 }, 1087 1088 [SCARLETT2_CONFIG_PAD_SWITCH] = { 1089 .offset = 0x84, .size = 8, .activate = 8 }, 1090 1091 [SCARLETT2_CONFIG_AIR_SWITCH] = { 1092 .offset = 0x8c, .size = 8, .activate = 8 }, 1093 1094 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 1095 .offset = 0x95, .size = 8, .activate = 6 }, 1096 1097 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 1098 .offset = 0x9c, .size = 1, .activate = 8 }, 1099 1100 [SCARLETT2_CONFIG_MSD_SWITCH] = { 1101 .offset = 0x9d, .size = 8, .activate = 6 }, 1102 1103 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { 1104 .offset = 0x9e, .size = 8, .activate = 6 }, 1105 1106 [SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = { 1107 .offset = 0x9f, .size = 1, .activate = 10 }, 1108 1109 [SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = { 1110 .offset = 0xa0, .size = 1, .activate = 10 }, 1111 1112 [SCARLETT2_CONFIG_TALKBACK_MAP] = { 1113 .offset = 0xb0, .size = 16, .activate = 10 }, 1114 1115/* Clarett+ 8Pre */ 1116}, { 1117 [SCARLETT2_CONFIG_DIM_MUTE] = { 1118 .offset = 0x31, .size = 8, .activate = 2 }, 1119 1120 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 1121 .offset = 0x34, .size = 16, .activate = 1 }, 1122 1123 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 1124 .offset = 0x5c, .size = 8, .activate = 1 }, 1125 1126 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 1127 .offset = 0x66, .size = 8, .activate = 3 }, 1128 1129 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 1130 .offset = 0x7c, .size = 8, .activate = 7 }, 1131 1132 [SCARLETT2_CONFIG_AIR_SWITCH] = { 1133 .offset = 0x95, .size = 8, .activate = 8 }, 1134 1135 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 1136 .offset = 0x8d, .size = 8, .activate = 6 }, 1137} }; 1138 1139/* proprietary request/response format */ 1140struct scarlett2_usb_packet { 1141 __le32 cmd; 1142 __le16 size; 1143 __le16 seq; 1144 __le32 error; 1145 __le32 pad; 1146 u8 data[]; 1147}; 1148 1149static void scarlett2_fill_request_header(struct scarlett2_data *private, 1150 struct scarlett2_usb_packet *req, 1151 u32 cmd, u16 req_size) 1152{ 1153 /* sequence must go up by 1 for each request */ 1154 u16 seq = private->scarlett2_seq++; 1155 1156 req->cmd = cpu_to_le32(cmd); 1157 req->size = cpu_to_le16(req_size); 1158 req->seq = cpu_to_le16(seq); 1159 req->error = 0; 1160 req->pad = 0; 1161} 1162 1163static int scarlett2_usb_tx(struct usb_device *dev, int interface, 1164 void *buf, u16 size) 1165{ 1166 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1167 SCARLETT2_USB_CMD_REQ, 1168 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1169 0, interface, buf, size); 1170} 1171 1172static int scarlett2_usb_rx(struct usb_device *dev, int interface, 1173 u32 usb_req, void *buf, u16 size) 1174{ 1175 return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 1176 usb_req, 1177 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 1178 0, interface, buf, size); 1179} 1180 1181/* Send a proprietary format request to the Scarlett interface */ 1182static int scarlett2_usb( 1183 struct usb_mixer_interface *mixer, u32 cmd, 1184 void *req_data, u16 req_size, void *resp_data, u16 resp_size) 1185{ 1186 struct scarlett2_data *private = mixer->private_data; 1187 struct usb_device *dev = mixer->chip->dev; 1188 struct scarlett2_usb_packet *req, *resp = NULL; 1189 size_t req_buf_size = struct_size(req, data, req_size); 1190 size_t resp_buf_size = struct_size(resp, data, resp_size); 1191 int err; 1192 1193 req = kmalloc(req_buf_size, GFP_KERNEL); 1194 if (!req) { 1195 err = -ENOMEM; 1196 goto error; 1197 } 1198 1199 resp = kmalloc(resp_buf_size, GFP_KERNEL); 1200 if (!resp) { 1201 err = -ENOMEM; 1202 goto error; 1203 } 1204 1205 mutex_lock(&private->usb_mutex); 1206 1207 /* build request message and send it */ 1208 1209 scarlett2_fill_request_header(private, req, cmd, req_size); 1210 1211 if (req_size) 1212 memcpy(req->data, req_data, req_size); 1213 1214 err = scarlett2_usb_tx(dev, private->bInterfaceNumber, 1215 req, req_buf_size); 1216 1217 if (err != req_buf_size) { 1218 usb_audio_err( 1219 mixer->chip, 1220 "Scarlett Gen 2/3 USB request result cmd %x was %d\n", 1221 cmd, err); 1222 err = -EINVAL; 1223 goto unlock; 1224 } 1225 1226 /* send a second message to get the response */ 1227 1228 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, 1229 SCARLETT2_USB_CMD_RESP, 1230 resp, resp_buf_size); 1231 1232 /* validate the response */ 1233 1234 if (err != resp_buf_size) { 1235 usb_audio_err( 1236 mixer->chip, 1237 "Scarlett Gen 2/3 USB response result cmd %x was %d " 1238 "expected %zu\n", 1239 cmd, err, resp_buf_size); 1240 err = -EINVAL; 1241 goto unlock; 1242 } 1243 1244 /* cmd/seq/size should match except when initialising 1245 * seq sent = 1, response = 0 1246 */ 1247 if (resp->cmd != req->cmd || 1248 (resp->seq != req->seq && 1249 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) || 1250 resp_size != le16_to_cpu(resp->size) || 1251 resp->error || 1252 resp->pad) { 1253 usb_audio_err( 1254 mixer->chip, 1255 "Scarlett Gen 2/3 USB invalid response; " 1256 "cmd tx/rx %d/%d seq %d/%d size %d/%d " 1257 "error %d pad %d\n", 1258 le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd), 1259 le16_to_cpu(req->seq), le16_to_cpu(resp->seq), 1260 resp_size, le16_to_cpu(resp->size), 1261 le32_to_cpu(resp->error), 1262 le32_to_cpu(resp->pad)); 1263 err = -EINVAL; 1264 goto unlock; 1265 } 1266 1267 if (resp_data && resp_size > 0) 1268 memcpy(resp_data, resp->data, resp_size); 1269 1270unlock: 1271 mutex_unlock(&private->usb_mutex); 1272error: 1273 kfree(req); 1274 kfree(resp); 1275 return err; 1276} 1277 1278/* Send a USB message to get data; result placed in *buf */ 1279static int scarlett2_usb_get( 1280 struct usb_mixer_interface *mixer, 1281 int offset, void *buf, int size) 1282{ 1283 struct { 1284 __le32 offset; 1285 __le32 size; 1286 } __packed req; 1287 1288 req.offset = cpu_to_le32(offset); 1289 req.size = cpu_to_le32(size); 1290 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA, 1291 &req, sizeof(req), buf, size); 1292} 1293 1294/* Send a USB message to get configuration parameters; result placed in *buf */ 1295static int scarlett2_usb_get_config( 1296 struct usb_mixer_interface *mixer, 1297 int config_item_num, int count, void *buf) 1298{ 1299 struct scarlett2_data *private = mixer->private_data; 1300 const struct scarlett2_device_info *info = private->info; 1301 const struct scarlett2_config *config_item = 1302 &scarlett2_config_items[info->config_set][config_item_num]; 1303 int size, err, i; 1304 u8 *buf_8; 1305 u8 value; 1306 1307 /* For byte-sized parameters, retrieve directly into buf */ 1308 if (config_item->size >= 8) { 1309 size = config_item->size / 8 * count; 1310 err = scarlett2_usb_get(mixer, config_item->offset, buf, size); 1311 if (err < 0) 1312 return err; 1313 if (size == 2) { 1314 u16 *buf_16 = buf; 1315 1316 for (i = 0; i < count; i++, buf_16++) 1317 *buf_16 = le16_to_cpu(*(__le16 *)buf_16); 1318 } 1319 return 0; 1320 } 1321 1322 /* For bit-sized parameters, retrieve into value */ 1323 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1); 1324 if (err < 0) 1325 return err; 1326 1327 /* then unpack from value into buf[] */ 1328 buf_8 = buf; 1329 for (i = 0; i < 8 && i < count; i++, value >>= 1) 1330 *buf_8++ = value & 1; 1331 1332 return 0; 1333} 1334 1335/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */ 1336static void scarlett2_config_save(struct usb_mixer_interface *mixer) 1337{ 1338 __le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE); 1339 1340 int err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD, 1341 &req, sizeof(u32), 1342 NULL, 0); 1343 if (err < 0) 1344 usb_audio_err(mixer->chip, "config save failed: %d\n", err); 1345} 1346 1347/* Delayed work to save config */ 1348static void scarlett2_config_save_work(struct work_struct *work) 1349{ 1350 struct scarlett2_data *private = 1351 container_of(work, struct scarlett2_data, work.work); 1352 1353 scarlett2_config_save(private->mixer); 1354} 1355 1356/* Send a USB message to set a SCARLETT2_CONFIG_* parameter */ 1357static int scarlett2_usb_set_config( 1358 struct usb_mixer_interface *mixer, 1359 int config_item_num, int index, int value) 1360{ 1361 struct scarlett2_data *private = mixer->private_data; 1362 const struct scarlett2_device_info *info = private->info; 1363 const struct scarlett2_config *config_item = 1364 &scarlett2_config_items[info->config_set][config_item_num]; 1365 struct { 1366 __le32 offset; 1367 __le32 bytes; 1368 __le32 value; 1369 } __packed req; 1370 __le32 req2; 1371 int offset, size; 1372 int err; 1373 1374 /* Cancel any pending NVRAM save */ 1375 cancel_delayed_work_sync(&private->work); 1376 1377 /* Convert config_item->size in bits to size in bytes and 1378 * calculate offset 1379 */ 1380 if (config_item->size >= 8) { 1381 size = config_item->size / 8; 1382 offset = config_item->offset + index * size; 1383 1384 /* If updating a bit, retrieve the old value, set/clear the 1385 * bit as needed, and update value 1386 */ 1387 } else { 1388 u8 tmp; 1389 1390 size = 1; 1391 offset = config_item->offset; 1392 1393 err = scarlett2_usb_get(mixer, offset, &tmp, 1); 1394 if (err < 0) 1395 return err; 1396 1397 if (value) 1398 tmp |= (1 << index); 1399 else 1400 tmp &= ~(1 << index); 1401 1402 value = tmp; 1403 } 1404 1405 /* Send the configuration parameter data */ 1406 req.offset = cpu_to_le32(offset); 1407 req.bytes = cpu_to_le32(size); 1408 req.value = cpu_to_le32(value); 1409 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA, 1410 &req, sizeof(u32) * 2 + size, 1411 NULL, 0); 1412 if (err < 0) 1413 return err; 1414 1415 /* Activate the change */ 1416 req2 = cpu_to_le32(config_item->activate); 1417 err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD, 1418 &req2, sizeof(req2), NULL, 0); 1419 if (err < 0) 1420 return err; 1421 1422 /* Schedule the change to be written to NVRAM */ 1423 if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE) 1424 schedule_delayed_work(&private->work, msecs_to_jiffies(2000)); 1425 1426 return 0; 1427} 1428 1429/* Send a USB message to get sync status; result placed in *sync */ 1430static int scarlett2_usb_get_sync_status( 1431 struct usb_mixer_interface *mixer, 1432 u8 *sync) 1433{ 1434 __le32 data; 1435 int err; 1436 1437 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC, 1438 NULL, 0, &data, sizeof(data)); 1439 if (err < 0) 1440 return err; 1441 1442 *sync = !!data; 1443 return 0; 1444} 1445 1446/* Send a USB message to get volume status; result placed in *buf */ 1447static int scarlett2_usb_get_volume_status( 1448 struct usb_mixer_interface *mixer, 1449 struct scarlett2_usb_volume_status *buf) 1450{ 1451 return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET, 1452 buf, sizeof(*buf)); 1453} 1454 1455/* Send a USB message to get the volumes for all inputs of one mix 1456 * and put the values into private->mix[] 1457 */ 1458static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer, 1459 int mix_num) 1460{ 1461 struct scarlett2_data *private = mixer->private_data; 1462 const struct scarlett2_device_info *info = private->info; 1463 1464 int num_mixer_in = 1465 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; 1466 int err, i, j, k; 1467 1468 struct { 1469 __le16 mix_num; 1470 __le16 count; 1471 } __packed req; 1472 1473 __le16 data[SCARLETT2_INPUT_MIX_MAX]; 1474 1475 req.mix_num = cpu_to_le16(mix_num); 1476 req.count = cpu_to_le16(num_mixer_in); 1477 1478 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX, 1479 &req, sizeof(req), 1480 data, num_mixer_in * sizeof(u16)); 1481 if (err < 0) 1482 return err; 1483 1484 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) { 1485 u16 mixer_value = le16_to_cpu(data[i]); 1486 1487 for (k = 0; k < SCARLETT2_MIXER_VALUE_COUNT; k++) 1488 if (scarlett2_mixer_values[k] >= mixer_value) 1489 break; 1490 if (k == SCARLETT2_MIXER_VALUE_COUNT) 1491 k = SCARLETT2_MIXER_MAX_VALUE; 1492 private->mix[j] = k; 1493 } 1494 1495 return 0; 1496} 1497 1498/* Send a USB message to set the volumes for all inputs of one mix 1499 * (values obtained from private->mix[]) 1500 */ 1501static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer, 1502 int mix_num) 1503{ 1504 struct scarlett2_data *private = mixer->private_data; 1505 const struct scarlett2_device_info *info = private->info; 1506 1507 struct { 1508 __le16 mix_num; 1509 __le16 data[SCARLETT2_INPUT_MIX_MAX]; 1510 } __packed req; 1511 1512 int i, j; 1513 int num_mixer_in = 1514 info->port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; 1515 1516 req.mix_num = cpu_to_le16(mix_num); 1517 1518 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) 1519 req.data[i] = cpu_to_le16( 1520 scarlett2_mixer_values[private->mix[j]] 1521 ); 1522 1523 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX, 1524 &req, (num_mixer_in + 1) * sizeof(u16), 1525 NULL, 0); 1526} 1527 1528/* Convert a port number index (per info->port_count) to a hardware ID */ 1529static u32 scarlett2_mux_src_num_to_id( 1530 const int port_count[][SCARLETT2_PORT_DIRNS], int num) 1531{ 1532 int port_type; 1533 1534 for (port_type = 0; 1535 port_type < SCARLETT2_PORT_TYPE_COUNT; 1536 port_type++) { 1537 if (num < port_count[port_type][SCARLETT2_PORT_IN]) 1538 return scarlett2_ports[port_type].id | num; 1539 num -= port_count[port_type][SCARLETT2_PORT_IN]; 1540 } 1541 1542 /* Oops */ 1543 return 0; 1544} 1545 1546/* Convert a hardware ID to a port number index */ 1547static u32 scarlett2_mux_id_to_num( 1548 const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id) 1549{ 1550 int port_type; 1551 int port_num = 0; 1552 1553 for (port_type = 0; 1554 port_type < SCARLETT2_PORT_TYPE_COUNT; 1555 port_type++) { 1556 int base = scarlett2_ports[port_type].id; 1557 int count = port_count[port_type][direction]; 1558 1559 if (id >= base && id < base + count) 1560 return port_num + id - base; 1561 port_num += count; 1562 } 1563 1564 /* Oops */ 1565 return -1; 1566} 1567 1568/* Convert one mux entry from the interface and load into private->mux[] */ 1569static void scarlett2_usb_populate_mux(struct scarlett2_data *private, 1570 u32 mux_entry) 1571{ 1572 const struct scarlett2_device_info *info = private->info; 1573 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 1574 1575 int dst_idx, src_idx; 1576 1577 dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT, 1578 mux_entry & 0xFFF); 1579 if (dst_idx < 0) 1580 return; 1581 1582 if (dst_idx >= private->num_mux_dsts) { 1583 usb_audio_err(private->mixer->chip, 1584 "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d", 1585 mux_entry, dst_idx, private->num_mux_dsts); 1586 return; 1587 } 1588 1589 src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN, 1590 mux_entry >> 12); 1591 if (src_idx < 0) 1592 return; 1593 1594 if (src_idx >= private->num_mux_srcs) { 1595 usb_audio_err(private->mixer->chip, 1596 "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d", 1597 mux_entry, src_idx, private->num_mux_srcs); 1598 return; 1599 } 1600 1601 private->mux[dst_idx] = src_idx; 1602} 1603 1604/* Send USB message to get mux inputs and then populate private->mux[] */ 1605static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer) 1606{ 1607 struct scarlett2_data *private = mixer->private_data; 1608 int count = private->num_mux_dsts; 1609 int err, i; 1610 1611 struct { 1612 __le16 num; 1613 __le16 count; 1614 } __packed req; 1615 1616 __le32 data[SCARLETT2_MUX_MAX]; 1617 1618 private->mux_updated = 0; 1619 1620 req.num = 0; 1621 req.count = cpu_to_le16(count); 1622 1623 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX, 1624 &req, sizeof(req), 1625 data, count * sizeof(u32)); 1626 if (err < 0) 1627 return err; 1628 1629 for (i = 0; i < count; i++) 1630 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i])); 1631 1632 return 0; 1633} 1634 1635/* Send USB messages to set mux inputs */ 1636static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer) 1637{ 1638 struct scarlett2_data *private = mixer->private_data; 1639 const struct scarlett2_device_info *info = private->info; 1640 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 1641 int table; 1642 1643 struct { 1644 __le16 pad; 1645 __le16 num; 1646 __le32 data[SCARLETT2_MUX_MAX]; 1647 } __packed req; 1648 1649 req.pad = 0; 1650 1651 /* set mux settings for each rate */ 1652 for (table = 0; table < SCARLETT2_MUX_TABLES; table++) { 1653 const struct scarlett2_mux_entry *entry; 1654 1655 /* i counts over the output array */ 1656 int i = 0, err; 1657 1658 req.num = cpu_to_le16(table); 1659 1660 /* loop through each entry */ 1661 for (entry = info->mux_assignment[table]; 1662 entry->count; 1663 entry++) { 1664 int j; 1665 int port_type = entry->port_type; 1666 int port_idx = entry->start; 1667 int mux_idx = scarlett2_get_port_start_num(port_count, 1668 SCARLETT2_PORT_OUT, port_type) + port_idx; 1669 int dst_id = scarlett2_ports[port_type].id + port_idx; 1670 1671 /* Empty slots */ 1672 if (!dst_id) { 1673 for (j = 0; j < entry->count; j++) 1674 req.data[i++] = 0; 1675 continue; 1676 } 1677 1678 /* Non-empty mux slots use the lower 12 bits 1679 * for the destination and next 12 bits for 1680 * the source 1681 */ 1682 for (j = 0; j < entry->count; j++) { 1683 int src_id = scarlett2_mux_src_num_to_id( 1684 port_count, private->mux[mux_idx++]); 1685 req.data[i++] = cpu_to_le32(dst_id | 1686 src_id << 12); 1687 dst_id++; 1688 } 1689 } 1690 1691 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX, 1692 &req, (i + 1) * sizeof(u32), 1693 NULL, 0); 1694 if (err < 0) 1695 return err; 1696 } 1697 1698 return 0; 1699} 1700 1701/* Send USB message to get meter levels */ 1702static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer, 1703 u16 num_meters, u16 *levels) 1704{ 1705 struct { 1706 __le16 pad; 1707 __le16 num_meters; 1708 __le32 magic; 1709 } __packed req; 1710 u32 resp[SCARLETT2_MAX_METERS]; 1711 int i, err; 1712 1713 req.pad = 0; 1714 req.num_meters = cpu_to_le16(num_meters); 1715 req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC); 1716 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER, 1717 &req, sizeof(req), resp, num_meters * sizeof(u32)); 1718 if (err < 0) 1719 return err; 1720 1721 /* copy, convert to u16 */ 1722 for (i = 0; i < num_meters; i++) 1723 levels[i] = resp[i]; 1724 1725 return 0; 1726} 1727 1728/*** Control Functions ***/ 1729 1730/* helper function to create a new control */ 1731static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer, 1732 const struct snd_kcontrol_new *ncontrol, 1733 int index, int channels, const char *name, 1734 struct snd_kcontrol **kctl_return) 1735{ 1736 struct snd_kcontrol *kctl; 1737 struct usb_mixer_elem_info *elem; 1738 int err; 1739 1740 elem = kzalloc(sizeof(*elem), GFP_KERNEL); 1741 if (!elem) 1742 return -ENOMEM; 1743 1744 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code 1745 * ignores them for resume and other operations. 1746 * Also, the head.id field is set to 0, as we don't use this field. 1747 */ 1748 elem->head.mixer = mixer; 1749 elem->control = index; 1750 elem->head.id = 0; 1751 elem->channels = channels; 1752 elem->val_type = USB_MIXER_BESPOKEN; 1753 1754 kctl = snd_ctl_new1(ncontrol, elem); 1755 if (!kctl) { 1756 kfree(elem); 1757 return -ENOMEM; 1758 } 1759 kctl->private_free = snd_usb_mixer_elem_free; 1760 1761 strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 1762 1763 err = snd_usb_mixer_add_control(&elem->head, kctl); 1764 if (err < 0) 1765 return err; 1766 1767 if (kctl_return) 1768 *kctl_return = kctl; 1769 1770 return 0; 1771} 1772 1773/*** Sync Control ***/ 1774 1775/* Update sync control after receiving notification that the status 1776 * has changed 1777 */ 1778static int scarlett2_update_sync(struct usb_mixer_interface *mixer) 1779{ 1780 struct scarlett2_data *private = mixer->private_data; 1781 1782 private->sync_updated = 0; 1783 return scarlett2_usb_get_sync_status(mixer, &private->sync); 1784} 1785 1786static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl, 1787 struct snd_ctl_elem_info *uinfo) 1788{ 1789 static const char *texts[2] = { 1790 "Unlocked", "Locked" 1791 }; 1792 return snd_ctl_enum_info(uinfo, 1, 2, texts); 1793} 1794 1795static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl, 1796 struct snd_ctl_elem_value *ucontrol) 1797{ 1798 struct usb_mixer_elem_info *elem = kctl->private_data; 1799 struct usb_mixer_interface *mixer = elem->head.mixer; 1800 struct scarlett2_data *private = mixer->private_data; 1801 int err = 0; 1802 1803 mutex_lock(&private->data_mutex); 1804 1805 if (private->sync_updated) { 1806 err = scarlett2_update_sync(mixer); 1807 if (err < 0) 1808 goto unlock; 1809 } 1810 ucontrol->value.enumerated.item[0] = private->sync; 1811 1812unlock: 1813 mutex_unlock(&private->data_mutex); 1814 return err; 1815} 1816 1817static const struct snd_kcontrol_new scarlett2_sync_ctl = { 1818 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1819 .access = SNDRV_CTL_ELEM_ACCESS_READ, 1820 .name = "", 1821 .info = scarlett2_sync_ctl_info, 1822 .get = scarlett2_sync_ctl_get 1823}; 1824 1825static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer) 1826{ 1827 struct scarlett2_data *private = mixer->private_data; 1828 1829 /* devices without a mixer also don't support reporting sync status */ 1830 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) 1831 return 0; 1832 1833 return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl, 1834 0, 1, "Sync Status", &private->sync_ctl); 1835} 1836 1837/*** Analogue Line Out Volume Controls ***/ 1838 1839/* Update hardware volume controls after receiving notification that 1840 * they have changed 1841 */ 1842static int scarlett2_update_volumes(struct usb_mixer_interface *mixer) 1843{ 1844 struct scarlett2_data *private = mixer->private_data; 1845 const struct scarlett2_device_info *info = private->info; 1846 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 1847 struct scarlett2_usb_volume_status volume_status; 1848 int num_line_out = 1849 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 1850 int err, i; 1851 int mute; 1852 1853 private->vol_updated = 0; 1854 1855 err = scarlett2_usb_get_volume_status(mixer, &volume_status); 1856 if (err < 0) 1857 return err; 1858 1859 private->master_vol = clamp( 1860 volume_status.master_vol + SCARLETT2_VOLUME_BIAS, 1861 0, SCARLETT2_VOLUME_BIAS); 1862 1863 if (info->line_out_hw_vol) 1864 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 1865 private->dim_mute[i] = !!volume_status.dim_mute[i]; 1866 1867 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE]; 1868 1869 for (i = 0; i < num_line_out; i++) 1870 if (private->vol_sw_hw_switch[i]) { 1871 private->vol[i] = private->master_vol; 1872 private->mute_switch[i] = mute; 1873 } 1874 1875 return 0; 1876} 1877 1878static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl, 1879 struct snd_ctl_elem_info *uinfo) 1880{ 1881 struct usb_mixer_elem_info *elem = kctl->private_data; 1882 1883 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1884 uinfo->count = elem->channels; 1885 uinfo->value.integer.min = 0; 1886 uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS; 1887 uinfo->value.integer.step = 1; 1888 return 0; 1889} 1890 1891static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl, 1892 struct snd_ctl_elem_value *ucontrol) 1893{ 1894 struct usb_mixer_elem_info *elem = kctl->private_data; 1895 struct usb_mixer_interface *mixer = elem->head.mixer; 1896 struct scarlett2_data *private = mixer->private_data; 1897 int err = 0; 1898 1899 mutex_lock(&private->data_mutex); 1900 1901 if (private->vol_updated) { 1902 err = scarlett2_update_volumes(mixer); 1903 if (err < 0) 1904 goto unlock; 1905 } 1906 ucontrol->value.integer.value[0] = private->master_vol; 1907 1908unlock: 1909 mutex_unlock(&private->data_mutex); 1910 return err; 1911} 1912 1913static int line_out_remap(struct scarlett2_data *private, int index) 1914{ 1915 const struct scarlett2_device_info *info = private->info; 1916 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 1917 int line_out_count = 1918 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 1919 1920 if (!info->line_out_remap_enable) 1921 return index; 1922 1923 if (index >= line_out_count) 1924 return index; 1925 1926 return info->line_out_remap[index]; 1927} 1928 1929static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl, 1930 struct snd_ctl_elem_value *ucontrol) 1931{ 1932 struct usb_mixer_elem_info *elem = kctl->private_data; 1933 struct usb_mixer_interface *mixer = elem->head.mixer; 1934 struct scarlett2_data *private = mixer->private_data; 1935 int index = line_out_remap(private, elem->control); 1936 int err = 0; 1937 1938 mutex_lock(&private->data_mutex); 1939 1940 if (private->vol_updated) { 1941 err = scarlett2_update_volumes(mixer); 1942 if (err < 0) 1943 goto unlock; 1944 } 1945 ucontrol->value.integer.value[0] = private->vol[index]; 1946 1947unlock: 1948 mutex_unlock(&private->data_mutex); 1949 return err; 1950} 1951 1952static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl, 1953 struct snd_ctl_elem_value *ucontrol) 1954{ 1955 struct usb_mixer_elem_info *elem = kctl->private_data; 1956 struct usb_mixer_interface *mixer = elem->head.mixer; 1957 struct scarlett2_data *private = mixer->private_data; 1958 int index = line_out_remap(private, elem->control); 1959 int oval, val, err = 0; 1960 1961 mutex_lock(&private->data_mutex); 1962 1963 oval = private->vol[index]; 1964 val = ucontrol->value.integer.value[0]; 1965 1966 if (oval == val) 1967 goto unlock; 1968 1969 private->vol[index] = val; 1970 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 1971 index, val - SCARLETT2_VOLUME_BIAS); 1972 if (err == 0) 1973 err = 1; 1974 1975unlock: 1976 mutex_unlock(&private->data_mutex); 1977 return err; 1978} 1979 1980static const DECLARE_TLV_DB_MINMAX( 1981 db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0 1982); 1983 1984static const struct snd_kcontrol_new scarlett2_master_volume_ctl = { 1985 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1986 .access = SNDRV_CTL_ELEM_ACCESS_READ | 1987 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 1988 .name = "", 1989 .info = scarlett2_volume_ctl_info, 1990 .get = scarlett2_master_volume_ctl_get, 1991 .private_value = 0, /* max value */ 1992 .tlv = { .p = db_scale_scarlett2_gain } 1993}; 1994 1995static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = { 1996 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1997 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 1998 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 1999 .name = "", 2000 .info = scarlett2_volume_ctl_info, 2001 .get = scarlett2_volume_ctl_get, 2002 .put = scarlett2_volume_ctl_put, 2003 .private_value = 0, /* max value */ 2004 .tlv = { .p = db_scale_scarlett2_gain } 2005}; 2006 2007/*** Mute Switch Controls ***/ 2008 2009static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl, 2010 struct snd_ctl_elem_value *ucontrol) 2011{ 2012 struct usb_mixer_elem_info *elem = kctl->private_data; 2013 struct usb_mixer_interface *mixer = elem->head.mixer; 2014 struct scarlett2_data *private = mixer->private_data; 2015 int index = line_out_remap(private, elem->control); 2016 int err = 0; 2017 2018 mutex_lock(&private->data_mutex); 2019 2020 if (private->vol_updated) { 2021 err = scarlett2_update_volumes(mixer); 2022 if (err < 0) 2023 goto unlock; 2024 } 2025 ucontrol->value.integer.value[0] = private->mute_switch[index]; 2026 2027unlock: 2028 mutex_unlock(&private->data_mutex); 2029 return err; 2030} 2031 2032static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl, 2033 struct snd_ctl_elem_value *ucontrol) 2034{ 2035 struct usb_mixer_elem_info *elem = kctl->private_data; 2036 struct usb_mixer_interface *mixer = elem->head.mixer; 2037 struct scarlett2_data *private = mixer->private_data; 2038 int index = line_out_remap(private, elem->control); 2039 int oval, val, err = 0; 2040 2041 mutex_lock(&private->data_mutex); 2042 2043 oval = private->mute_switch[index]; 2044 val = !!ucontrol->value.integer.value[0]; 2045 2046 if (oval == val) 2047 goto unlock; 2048 2049 private->mute_switch[index] = val; 2050 2051 /* Send mute change to the device */ 2052 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 2053 index, val); 2054 if (err == 0) 2055 err = 1; 2056 2057unlock: 2058 mutex_unlock(&private->data_mutex); 2059 return err; 2060} 2061 2062static const struct snd_kcontrol_new scarlett2_mute_ctl = { 2063 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2064 .name = "", 2065 .info = snd_ctl_boolean_mono_info, 2066 .get = scarlett2_mute_ctl_get, 2067 .put = scarlett2_mute_ctl_put, 2068}; 2069 2070/*** HW/SW Volume Switch Controls ***/ 2071 2072static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index) 2073{ 2074 private->sw_hw_ctls[index]->vd[0].access &= 2075 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 2076} 2077 2078static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index) 2079{ 2080 private->sw_hw_ctls[index]->vd[0].access |= 2081 SNDRV_CTL_ELEM_ACCESS_WRITE; 2082} 2083 2084static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl, 2085 struct snd_ctl_elem_info *uinfo) 2086{ 2087 static const char *const values[2] = { 2088 "SW", "HW" 2089 }; 2090 2091 return snd_ctl_enum_info(uinfo, 1, 2, values); 2092} 2093 2094static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl, 2095 struct snd_ctl_elem_value *ucontrol) 2096{ 2097 struct usb_mixer_elem_info *elem = kctl->private_data; 2098 struct scarlett2_data *private = elem->head.mixer->private_data; 2099 int index = line_out_remap(private, elem->control); 2100 2101 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index]; 2102 return 0; 2103} 2104 2105static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer, 2106 int index, int value) 2107{ 2108 struct scarlett2_data *private = mixer->private_data; 2109 struct snd_card *card = mixer->chip->card; 2110 2111 /* Set/Clear write bits */ 2112 if (value) { 2113 private->vol_ctls[index]->vd[0].access |= 2114 SNDRV_CTL_ELEM_ACCESS_WRITE; 2115 private->mute_ctls[index]->vd[0].access |= 2116 SNDRV_CTL_ELEM_ACCESS_WRITE; 2117 } else { 2118 private->vol_ctls[index]->vd[0].access &= 2119 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 2120 private->mute_ctls[index]->vd[0].access &= 2121 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 2122 } 2123 2124 /* Notify of write bit and possible value change */ 2125 snd_ctl_notify(card, 2126 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 2127 &private->vol_ctls[index]->id); 2128 snd_ctl_notify(card, 2129 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 2130 &private->mute_ctls[index]->id); 2131} 2132 2133static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer, 2134 int ctl_index, int val) 2135{ 2136 struct scarlett2_data *private = mixer->private_data; 2137 int index = line_out_remap(private, ctl_index); 2138 int err; 2139 2140 private->vol_sw_hw_switch[index] = val; 2141 2142 /* Change access mode to RO (hardware controlled volume) 2143 * or RW (software controlled volume) 2144 */ 2145 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val); 2146 2147 /* Reset volume/mute to master volume/mute */ 2148 private->vol[index] = private->master_vol; 2149 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE]; 2150 2151 /* Set SW volume to current HW volume */ 2152 err = scarlett2_usb_set_config( 2153 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 2154 index, private->master_vol - SCARLETT2_VOLUME_BIAS); 2155 if (err < 0) 2156 return err; 2157 2158 /* Set SW mute to current HW mute */ 2159 err = scarlett2_usb_set_config( 2160 mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 2161 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]); 2162 if (err < 0) 2163 return err; 2164 2165 /* Send SW/HW switch change to the device */ 2166 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, 2167 index, val); 2168} 2169 2170static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl, 2171 struct snd_ctl_elem_value *ucontrol) 2172{ 2173 struct usb_mixer_elem_info *elem = kctl->private_data; 2174 struct usb_mixer_interface *mixer = elem->head.mixer; 2175 struct scarlett2_data *private = mixer->private_data; 2176 int ctl_index = elem->control; 2177 int index = line_out_remap(private, ctl_index); 2178 int oval, val, err = 0; 2179 2180 mutex_lock(&private->data_mutex); 2181 2182 oval = private->vol_sw_hw_switch[index]; 2183 val = !!ucontrol->value.enumerated.item[0]; 2184 2185 if (oval == val) 2186 goto unlock; 2187 2188 err = scarlett2_sw_hw_change(mixer, ctl_index, val); 2189 if (err == 0) 2190 err = 1; 2191 2192unlock: 2193 mutex_unlock(&private->data_mutex); 2194 return err; 2195} 2196 2197static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = { 2198 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2199 .name = "", 2200 .info = scarlett2_sw_hw_enum_ctl_info, 2201 .get = scarlett2_sw_hw_enum_ctl_get, 2202 .put = scarlett2_sw_hw_enum_ctl_put, 2203}; 2204 2205/*** Line Level/Instrument Level Switch Controls ***/ 2206 2207static int scarlett2_update_input_other(struct usb_mixer_interface *mixer) 2208{ 2209 struct scarlett2_data *private = mixer->private_data; 2210 const struct scarlett2_device_info *info = private->info; 2211 2212 private->input_other_updated = 0; 2213 2214 if (info->level_input_count) { 2215 int err = scarlett2_usb_get_config( 2216 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, 2217 info->level_input_count + info->level_input_first, 2218 private->level_switch); 2219 if (err < 0) 2220 return err; 2221 } 2222 2223 if (info->pad_input_count) { 2224 int err = scarlett2_usb_get_config( 2225 mixer, SCARLETT2_CONFIG_PAD_SWITCH, 2226 info->pad_input_count, private->pad_switch); 2227 if (err < 0) 2228 return err; 2229 } 2230 2231 if (info->air_input_count) { 2232 int err = scarlett2_usb_get_config( 2233 mixer, SCARLETT2_CONFIG_AIR_SWITCH, 2234 info->air_input_count, private->air_switch); 2235 if (err < 0) 2236 return err; 2237 } 2238 2239 if (info->phantom_count) { 2240 int err = scarlett2_usb_get_config( 2241 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 2242 info->phantom_count, private->phantom_switch); 2243 if (err < 0) 2244 return err; 2245 2246 err = scarlett2_usb_get_config( 2247 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, 2248 1, &private->phantom_persistence); 2249 if (err < 0) 2250 return err; 2251 } 2252 2253 return 0; 2254} 2255 2256static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl, 2257 struct snd_ctl_elem_info *uinfo) 2258{ 2259 static const char *const values[2] = { 2260 "Line", "Inst" 2261 }; 2262 2263 return snd_ctl_enum_info(uinfo, 1, 2, values); 2264} 2265 2266static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl, 2267 struct snd_ctl_elem_value *ucontrol) 2268{ 2269 struct usb_mixer_elem_info *elem = kctl->private_data; 2270 struct usb_mixer_interface *mixer = elem->head.mixer; 2271 struct scarlett2_data *private = mixer->private_data; 2272 const struct scarlett2_device_info *info = private->info; 2273 2274 int index = elem->control + info->level_input_first; 2275 int err = 0; 2276 2277 mutex_lock(&private->data_mutex); 2278 2279 if (private->input_other_updated) { 2280 err = scarlett2_update_input_other(mixer); 2281 if (err < 0) 2282 goto unlock; 2283 } 2284 ucontrol->value.enumerated.item[0] = private->level_switch[index]; 2285 2286unlock: 2287 mutex_unlock(&private->data_mutex); 2288 return err; 2289} 2290 2291static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl, 2292 struct snd_ctl_elem_value *ucontrol) 2293{ 2294 struct usb_mixer_elem_info *elem = kctl->private_data; 2295 struct usb_mixer_interface *mixer = elem->head.mixer; 2296 struct scarlett2_data *private = mixer->private_data; 2297 const struct scarlett2_device_info *info = private->info; 2298 2299 int index = elem->control + info->level_input_first; 2300 int oval, val, err = 0; 2301 2302 mutex_lock(&private->data_mutex); 2303 2304 oval = private->level_switch[index]; 2305 val = !!ucontrol->value.enumerated.item[0]; 2306 2307 if (oval == val) 2308 goto unlock; 2309 2310 private->level_switch[index] = val; 2311 2312 /* Send switch change to the device */ 2313 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, 2314 index, val); 2315 if (err == 0) 2316 err = 1; 2317 2318unlock: 2319 mutex_unlock(&private->data_mutex); 2320 return err; 2321} 2322 2323static const struct snd_kcontrol_new scarlett2_level_enum_ctl = { 2324 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2325 .name = "", 2326 .info = scarlett2_level_enum_ctl_info, 2327 .get = scarlett2_level_enum_ctl_get, 2328 .put = scarlett2_level_enum_ctl_put, 2329}; 2330 2331/*** Pad Switch Controls ***/ 2332 2333static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl, 2334 struct snd_ctl_elem_value *ucontrol) 2335{ 2336 struct usb_mixer_elem_info *elem = kctl->private_data; 2337 struct usb_mixer_interface *mixer = elem->head.mixer; 2338 struct scarlett2_data *private = mixer->private_data; 2339 int err = 0; 2340 2341 mutex_lock(&private->data_mutex); 2342 2343 if (private->input_other_updated) { 2344 err = scarlett2_update_input_other(mixer); 2345 if (err < 0) 2346 goto unlock; 2347 } 2348 ucontrol->value.integer.value[0] = 2349 private->pad_switch[elem->control]; 2350 2351unlock: 2352 mutex_unlock(&private->data_mutex); 2353 return err; 2354} 2355 2356static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl, 2357 struct snd_ctl_elem_value *ucontrol) 2358{ 2359 struct usb_mixer_elem_info *elem = kctl->private_data; 2360 struct usb_mixer_interface *mixer = elem->head.mixer; 2361 struct scarlett2_data *private = mixer->private_data; 2362 2363 int index = elem->control; 2364 int oval, val, err = 0; 2365 2366 mutex_lock(&private->data_mutex); 2367 2368 oval = private->pad_switch[index]; 2369 val = !!ucontrol->value.integer.value[0]; 2370 2371 if (oval == val) 2372 goto unlock; 2373 2374 private->pad_switch[index] = val; 2375 2376 /* Send switch change to the device */ 2377 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH, 2378 index, val); 2379 if (err == 0) 2380 err = 1; 2381 2382unlock: 2383 mutex_unlock(&private->data_mutex); 2384 return err; 2385} 2386 2387static const struct snd_kcontrol_new scarlett2_pad_ctl = { 2388 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2389 .name = "", 2390 .info = snd_ctl_boolean_mono_info, 2391 .get = scarlett2_pad_ctl_get, 2392 .put = scarlett2_pad_ctl_put, 2393}; 2394 2395/*** Air Switch Controls ***/ 2396 2397static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl, 2398 struct snd_ctl_elem_value *ucontrol) 2399{ 2400 struct usb_mixer_elem_info *elem = kctl->private_data; 2401 struct usb_mixer_interface *mixer = elem->head.mixer; 2402 struct scarlett2_data *private = mixer->private_data; 2403 int err = 0; 2404 2405 mutex_lock(&private->data_mutex); 2406 2407 if (private->input_other_updated) { 2408 err = scarlett2_update_input_other(mixer); 2409 if (err < 0) 2410 goto unlock; 2411 } 2412 ucontrol->value.integer.value[0] = private->air_switch[elem->control]; 2413 2414unlock: 2415 mutex_unlock(&private->data_mutex); 2416 return err; 2417} 2418 2419static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl, 2420 struct snd_ctl_elem_value *ucontrol) 2421{ 2422 struct usb_mixer_elem_info *elem = kctl->private_data; 2423 struct usb_mixer_interface *mixer = elem->head.mixer; 2424 struct scarlett2_data *private = mixer->private_data; 2425 2426 int index = elem->control; 2427 int oval, val, err = 0; 2428 2429 mutex_lock(&private->data_mutex); 2430 2431 oval = private->air_switch[index]; 2432 val = !!ucontrol->value.integer.value[0]; 2433 2434 if (oval == val) 2435 goto unlock; 2436 2437 private->air_switch[index] = val; 2438 2439 /* Send switch change to the device */ 2440 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH, 2441 index, val); 2442 if (err == 0) 2443 err = 1; 2444 2445unlock: 2446 mutex_unlock(&private->data_mutex); 2447 return err; 2448} 2449 2450static const struct snd_kcontrol_new scarlett2_air_ctl = { 2451 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2452 .name = "", 2453 .info = snd_ctl_boolean_mono_info, 2454 .get = scarlett2_air_ctl_get, 2455 .put = scarlett2_air_ctl_put, 2456}; 2457 2458/*** Phantom Switch Controls ***/ 2459 2460static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl, 2461 struct snd_ctl_elem_value *ucontrol) 2462{ 2463 struct usb_mixer_elem_info *elem = kctl->private_data; 2464 struct usb_mixer_interface *mixer = elem->head.mixer; 2465 struct scarlett2_data *private = mixer->private_data; 2466 int err = 0; 2467 2468 mutex_lock(&private->data_mutex); 2469 2470 if (private->input_other_updated) { 2471 err = scarlett2_update_input_other(mixer); 2472 if (err < 0) 2473 goto unlock; 2474 } 2475 ucontrol->value.integer.value[0] = 2476 private->phantom_switch[elem->control]; 2477 2478unlock: 2479 mutex_unlock(&private->data_mutex); 2480 return err; 2481} 2482 2483static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl, 2484 struct snd_ctl_elem_value *ucontrol) 2485{ 2486 struct usb_mixer_elem_info *elem = kctl->private_data; 2487 struct usb_mixer_interface *mixer = elem->head.mixer; 2488 struct scarlett2_data *private = mixer->private_data; 2489 2490 int index = elem->control; 2491 int oval, val, err = 0; 2492 2493 mutex_lock(&private->data_mutex); 2494 2495 oval = private->phantom_switch[index]; 2496 val = !!ucontrol->value.integer.value[0]; 2497 2498 if (oval == val) 2499 goto unlock; 2500 2501 private->phantom_switch[index] = val; 2502 2503 /* Send switch change to the device */ 2504 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 2505 index, val); 2506 if (err == 0) 2507 err = 1; 2508 2509unlock: 2510 mutex_unlock(&private->data_mutex); 2511 return err; 2512} 2513 2514static const struct snd_kcontrol_new scarlett2_phantom_ctl = { 2515 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2516 .name = "", 2517 .info = snd_ctl_boolean_mono_info, 2518 .get = scarlett2_phantom_ctl_get, 2519 .put = scarlett2_phantom_ctl_put, 2520}; 2521 2522/*** Phantom Persistence Control ***/ 2523 2524static int scarlett2_phantom_persistence_ctl_get( 2525 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2526{ 2527 struct usb_mixer_elem_info *elem = kctl->private_data; 2528 struct scarlett2_data *private = elem->head.mixer->private_data; 2529 2530 ucontrol->value.integer.value[0] = private->phantom_persistence; 2531 return 0; 2532} 2533 2534static int scarlett2_phantom_persistence_ctl_put( 2535 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2536{ 2537 struct usb_mixer_elem_info *elem = kctl->private_data; 2538 struct usb_mixer_interface *mixer = elem->head.mixer; 2539 struct scarlett2_data *private = mixer->private_data; 2540 2541 int index = elem->control; 2542 int oval, val, err = 0; 2543 2544 mutex_lock(&private->data_mutex); 2545 2546 oval = private->phantom_persistence; 2547 val = !!ucontrol->value.integer.value[0]; 2548 2549 if (oval == val) 2550 goto unlock; 2551 2552 private->phantom_persistence = val; 2553 2554 /* Send switch change to the device */ 2555 err = scarlett2_usb_set_config( 2556 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val); 2557 if (err == 0) 2558 err = 1; 2559 2560unlock: 2561 mutex_unlock(&private->data_mutex); 2562 return err; 2563} 2564 2565static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = { 2566 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2567 .name = "", 2568 .info = snd_ctl_boolean_mono_info, 2569 .get = scarlett2_phantom_persistence_ctl_get, 2570 .put = scarlett2_phantom_persistence_ctl_put, 2571}; 2572 2573/*** Direct Monitor Control ***/ 2574 2575static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer) 2576{ 2577 struct scarlett2_data *private = mixer->private_data; 2578 const struct scarlett2_device_info *info = private->info; 2579 int err; 2580 2581 /* monitor_other_enable[0] enables speaker switching 2582 * monitor_other_enable[1] enables talkback 2583 */ 2584 u8 monitor_other_enable[2]; 2585 2586 /* monitor_other_switch[0] activates the alternate speakers 2587 * monitor_other_switch[1] activates talkback 2588 */ 2589 u8 monitor_other_switch[2]; 2590 2591 private->monitor_other_updated = 0; 2592 2593 if (info->direct_monitor) 2594 return scarlett2_usb_get_config( 2595 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, 2596 1, &private->direct_monitor_switch); 2597 2598 /* if it doesn't do speaker switching then it also doesn't do 2599 * talkback 2600 */ 2601 if (!info->has_speaker_switching) 2602 return 0; 2603 2604 err = scarlett2_usb_get_config( 2605 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 2606 2, monitor_other_enable); 2607 if (err < 0) 2608 return err; 2609 2610 err = scarlett2_usb_get_config( 2611 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 2612 2, monitor_other_switch); 2613 if (err < 0) 2614 return err; 2615 2616 if (!monitor_other_enable[0]) 2617 private->speaker_switching_switch = 0; 2618 else 2619 private->speaker_switching_switch = monitor_other_switch[0] + 1; 2620 2621 if (info->has_talkback) { 2622 const int (*port_count)[SCARLETT2_PORT_DIRNS] = 2623 info->port_count; 2624 int num_mixes = 2625 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; 2626 u16 bitmap; 2627 int i; 2628 2629 if (!monitor_other_enable[1]) 2630 private->talkback_switch = 0; 2631 else 2632 private->talkback_switch = monitor_other_switch[1] + 1; 2633 2634 err = scarlett2_usb_get_config(mixer, 2635 SCARLETT2_CONFIG_TALKBACK_MAP, 2636 1, &bitmap); 2637 if (err < 0) 2638 return err; 2639 for (i = 0; i < num_mixes; i++, bitmap >>= 1) 2640 private->talkback_map[i] = bitmap & 1; 2641 } 2642 2643 return 0; 2644} 2645 2646static int scarlett2_direct_monitor_ctl_get( 2647 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2648{ 2649 struct usb_mixer_elem_info *elem = kctl->private_data; 2650 struct usb_mixer_interface *mixer = elem->head.mixer; 2651 struct scarlett2_data *private = elem->head.mixer->private_data; 2652 int err = 0; 2653 2654 mutex_lock(&private->data_mutex); 2655 2656 if (private->monitor_other_updated) { 2657 err = scarlett2_update_monitor_other(mixer); 2658 if (err < 0) 2659 goto unlock; 2660 } 2661 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch; 2662 2663unlock: 2664 mutex_unlock(&private->data_mutex); 2665 return err; 2666} 2667 2668static int scarlett2_direct_monitor_ctl_put( 2669 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2670{ 2671 struct usb_mixer_elem_info *elem = kctl->private_data; 2672 struct usb_mixer_interface *mixer = elem->head.mixer; 2673 struct scarlett2_data *private = mixer->private_data; 2674 2675 int index = elem->control; 2676 int oval, val, err = 0; 2677 2678 mutex_lock(&private->data_mutex); 2679 2680 oval = private->direct_monitor_switch; 2681 val = min(ucontrol->value.enumerated.item[0], 2U); 2682 2683 if (oval == val) 2684 goto unlock; 2685 2686 private->direct_monitor_switch = val; 2687 2688 /* Send switch change to the device */ 2689 err = scarlett2_usb_set_config( 2690 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val); 2691 if (err == 0) 2692 err = 1; 2693 2694unlock: 2695 mutex_unlock(&private->data_mutex); 2696 return err; 2697} 2698 2699static int scarlett2_direct_monitor_stereo_enum_ctl_info( 2700 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 2701{ 2702 static const char *const values[3] = { 2703 "Off", "Mono", "Stereo" 2704 }; 2705 2706 return snd_ctl_enum_info(uinfo, 1, 3, values); 2707} 2708 2709/* Direct Monitor for Solo is mono-only and only needs a boolean control 2710 * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo 2711 */ 2712static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = { 2713 { 2714 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2715 .name = "", 2716 .info = snd_ctl_boolean_mono_info, 2717 .get = scarlett2_direct_monitor_ctl_get, 2718 .put = scarlett2_direct_monitor_ctl_put, 2719 }, 2720 { 2721 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2722 .name = "", 2723 .info = scarlett2_direct_monitor_stereo_enum_ctl_info, 2724 .get = scarlett2_direct_monitor_ctl_get, 2725 .put = scarlett2_direct_monitor_ctl_put, 2726 } 2727}; 2728 2729static int scarlett2_add_direct_monitor_ctl(struct usb_mixer_interface *mixer) 2730{ 2731 struct scarlett2_data *private = mixer->private_data; 2732 const struct scarlett2_device_info *info = private->info; 2733 const char *s; 2734 2735 if (!info->direct_monitor) 2736 return 0; 2737 2738 s = info->direct_monitor == 1 2739 ? "Direct Monitor Playback Switch" 2740 : "Direct Monitor Playback Enum"; 2741 2742 return scarlett2_add_new_ctl( 2743 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1], 2744 0, 1, s, &private->direct_monitor_ctl); 2745} 2746 2747/*** Speaker Switching Control ***/ 2748 2749static int scarlett2_speaker_switch_enum_ctl_info( 2750 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 2751{ 2752 static const char *const values[3] = { 2753 "Off", "Main", "Alt" 2754 }; 2755 2756 return snd_ctl_enum_info(uinfo, 1, 3, values); 2757} 2758 2759static int scarlett2_speaker_switch_enum_ctl_get( 2760 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2761{ 2762 struct usb_mixer_elem_info *elem = kctl->private_data; 2763 struct usb_mixer_interface *mixer = elem->head.mixer; 2764 struct scarlett2_data *private = mixer->private_data; 2765 int err = 0; 2766 2767 mutex_lock(&private->data_mutex); 2768 2769 if (private->monitor_other_updated) { 2770 err = scarlett2_update_monitor_other(mixer); 2771 if (err < 0) 2772 goto unlock; 2773 } 2774 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch; 2775 2776unlock: 2777 mutex_unlock(&private->data_mutex); 2778 return err; 2779} 2780 2781/* when speaker switching gets enabled, switch the main/alt speakers 2782 * to HW volume and disable those controls 2783 */ 2784static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer) 2785{ 2786 struct snd_card *card = mixer->chip->card; 2787 struct scarlett2_data *private = mixer->private_data; 2788 int i, err; 2789 2790 for (i = 0; i < 4; i++) { 2791 int index = line_out_remap(private, i); 2792 2793 /* switch the main/alt speakers to HW volume */ 2794 if (!private->vol_sw_hw_switch[index]) { 2795 err = scarlett2_sw_hw_change(private->mixer, i, 1); 2796 if (err < 0) 2797 return err; 2798 } 2799 2800 /* disable the line out SW/HW switch */ 2801 scarlett2_sw_hw_ctl_ro(private, i); 2802 snd_ctl_notify(card, 2803 SNDRV_CTL_EVENT_MASK_VALUE | 2804 SNDRV_CTL_EVENT_MASK_INFO, 2805 &private->sw_hw_ctls[i]->id); 2806 } 2807 2808 /* when the next monitor-other notify comes in, update the mux 2809 * configuration 2810 */ 2811 private->speaker_switching_switched = 1; 2812 2813 return 0; 2814} 2815 2816/* when speaker switching gets disabled, reenable the hw/sw controls 2817 * and invalidate the routing 2818 */ 2819static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer) 2820{ 2821 struct snd_card *card = mixer->chip->card; 2822 struct scarlett2_data *private = mixer->private_data; 2823 int i; 2824 2825 /* enable the line out SW/HW switch */ 2826 for (i = 0; i < 4; i++) { 2827 scarlett2_sw_hw_ctl_rw(private, i); 2828 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2829 &private->sw_hw_ctls[i]->id); 2830 } 2831 2832 /* when the next monitor-other notify comes in, update the mux 2833 * configuration 2834 */ 2835 private->speaker_switching_switched = 1; 2836} 2837 2838static int scarlett2_speaker_switch_enum_ctl_put( 2839 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2840{ 2841 struct usb_mixer_elem_info *elem = kctl->private_data; 2842 struct usb_mixer_interface *mixer = elem->head.mixer; 2843 struct scarlett2_data *private = mixer->private_data; 2844 2845 int oval, val, err = 0; 2846 2847 mutex_lock(&private->data_mutex); 2848 2849 oval = private->speaker_switching_switch; 2850 val = min(ucontrol->value.enumerated.item[0], 2U); 2851 2852 if (oval == val) 2853 goto unlock; 2854 2855 private->speaker_switching_switch = val; 2856 2857 /* enable/disable speaker switching */ 2858 err = scarlett2_usb_set_config( 2859 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 2860 0, !!val); 2861 if (err < 0) 2862 goto unlock; 2863 2864 /* if speaker switching is enabled, select main or alt */ 2865 err = scarlett2_usb_set_config( 2866 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 2867 0, val == 2); 2868 if (err < 0) 2869 goto unlock; 2870 2871 /* update controls if speaker switching gets enabled or disabled */ 2872 if (!oval && val) 2873 err = scarlett2_speaker_switch_enable(mixer); 2874 else if (oval && !val) 2875 scarlett2_speaker_switch_disable(mixer); 2876 2877 if (err == 0) 2878 err = 1; 2879 2880unlock: 2881 mutex_unlock(&private->data_mutex); 2882 return err; 2883} 2884 2885static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = { 2886 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2887 .name = "", 2888 .info = scarlett2_speaker_switch_enum_ctl_info, 2889 .get = scarlett2_speaker_switch_enum_ctl_get, 2890 .put = scarlett2_speaker_switch_enum_ctl_put, 2891}; 2892 2893static int scarlett2_add_speaker_switch_ctl( 2894 struct usb_mixer_interface *mixer) 2895{ 2896 struct scarlett2_data *private = mixer->private_data; 2897 const struct scarlett2_device_info *info = private->info; 2898 2899 if (!info->has_speaker_switching) 2900 return 0; 2901 2902 return scarlett2_add_new_ctl( 2903 mixer, &scarlett2_speaker_switch_enum_ctl, 2904 0, 1, "Speaker Switching Playback Enum", 2905 &private->speaker_switching_ctl); 2906} 2907 2908/*** Talkback and Talkback Map Controls ***/ 2909 2910static int scarlett2_talkback_enum_ctl_info( 2911 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 2912{ 2913 static const char *const values[3] = { 2914 "Disabled", "Off", "On" 2915 }; 2916 2917 return snd_ctl_enum_info(uinfo, 1, 3, values); 2918} 2919 2920static int scarlett2_talkback_enum_ctl_get( 2921 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2922{ 2923 struct usb_mixer_elem_info *elem = kctl->private_data; 2924 struct usb_mixer_interface *mixer = elem->head.mixer; 2925 struct scarlett2_data *private = mixer->private_data; 2926 int err = 0; 2927 2928 mutex_lock(&private->data_mutex); 2929 2930 if (private->monitor_other_updated) { 2931 err = scarlett2_update_monitor_other(mixer); 2932 if (err < 0) 2933 goto unlock; 2934 } 2935 ucontrol->value.enumerated.item[0] = private->talkback_switch; 2936 2937unlock: 2938 mutex_unlock(&private->data_mutex); 2939 return err; 2940} 2941 2942static int scarlett2_talkback_enum_ctl_put( 2943 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2944{ 2945 struct usb_mixer_elem_info *elem = kctl->private_data; 2946 struct usb_mixer_interface *mixer = elem->head.mixer; 2947 struct scarlett2_data *private = mixer->private_data; 2948 2949 int oval, val, err = 0; 2950 2951 mutex_lock(&private->data_mutex); 2952 2953 oval = private->talkback_switch; 2954 val = min(ucontrol->value.enumerated.item[0], 2U); 2955 2956 if (oval == val) 2957 goto unlock; 2958 2959 private->talkback_switch = val; 2960 2961 /* enable/disable talkback */ 2962 err = scarlett2_usb_set_config( 2963 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 2964 1, !!val); 2965 if (err < 0) 2966 goto unlock; 2967 2968 /* if talkback is enabled, select main or alt */ 2969 err = scarlett2_usb_set_config( 2970 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 2971 1, val == 2); 2972 if (err == 0) 2973 err = 1; 2974 2975unlock: 2976 mutex_unlock(&private->data_mutex); 2977 return err; 2978} 2979 2980static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = { 2981 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2982 .name = "", 2983 .info = scarlett2_talkback_enum_ctl_info, 2984 .get = scarlett2_talkback_enum_ctl_get, 2985 .put = scarlett2_talkback_enum_ctl_put, 2986}; 2987 2988static int scarlett2_talkback_map_ctl_get( 2989 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 2990{ 2991 struct usb_mixer_elem_info *elem = kctl->private_data; 2992 struct usb_mixer_interface *mixer = elem->head.mixer; 2993 struct scarlett2_data *private = mixer->private_data; 2994 int index = elem->control; 2995 2996 ucontrol->value.integer.value[0] = private->talkback_map[index]; 2997 2998 return 0; 2999} 3000 3001static int scarlett2_talkback_map_ctl_put( 3002 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3003{ 3004 struct usb_mixer_elem_info *elem = kctl->private_data; 3005 struct usb_mixer_interface *mixer = elem->head.mixer; 3006 struct scarlett2_data *private = mixer->private_data; 3007 const int (*port_count)[SCARLETT2_PORT_DIRNS] = 3008 private->info->port_count; 3009 int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; 3010 3011 int index = elem->control; 3012 int oval, val, err = 0, i; 3013 u16 bitmap = 0; 3014 3015 mutex_lock(&private->data_mutex); 3016 3017 oval = private->talkback_map[index]; 3018 val = !!ucontrol->value.integer.value[0]; 3019 3020 if (oval == val) 3021 goto unlock; 3022 3023 private->talkback_map[index] = val; 3024 3025 for (i = 0; i < num_mixes; i++) 3026 bitmap |= private->talkback_map[i] << i; 3027 3028 /* Send updated bitmap to the device */ 3029 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP, 3030 0, bitmap); 3031 if (err == 0) 3032 err = 1; 3033 3034unlock: 3035 mutex_unlock(&private->data_mutex); 3036 return err; 3037} 3038 3039static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = { 3040 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3041 .name = "", 3042 .info = snd_ctl_boolean_mono_info, 3043 .get = scarlett2_talkback_map_ctl_get, 3044 .put = scarlett2_talkback_map_ctl_put, 3045}; 3046 3047static int scarlett2_add_talkback_ctls( 3048 struct usb_mixer_interface *mixer) 3049{ 3050 struct scarlett2_data *private = mixer->private_data; 3051 const struct scarlett2_device_info *info = private->info; 3052 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3053 int num_mixes = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; 3054 int err, i; 3055 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3056 3057 if (!info->has_talkback) 3058 return 0; 3059 3060 err = scarlett2_add_new_ctl( 3061 mixer, &scarlett2_talkback_enum_ctl, 3062 0, 1, "Talkback Playback Enum", 3063 &private->talkback_ctl); 3064 if (err < 0) 3065 return err; 3066 3067 for (i = 0; i < num_mixes; i++) { 3068 snprintf(s, sizeof(s), 3069 "Talkback Mix %c Playback Switch", i + 'A'); 3070 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl, 3071 i, 1, s, NULL); 3072 if (err < 0) 3073 return err; 3074 } 3075 3076 return 0; 3077} 3078 3079/*** Dim/Mute Controls ***/ 3080 3081static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl, 3082 struct snd_ctl_elem_value *ucontrol) 3083{ 3084 struct usb_mixer_elem_info *elem = kctl->private_data; 3085 struct usb_mixer_interface *mixer = elem->head.mixer; 3086 struct scarlett2_data *private = mixer->private_data; 3087 int err = 0; 3088 3089 mutex_lock(&private->data_mutex); 3090 3091 if (private->vol_updated) { 3092 err = scarlett2_update_volumes(mixer); 3093 if (err < 0) 3094 goto unlock; 3095 } 3096 ucontrol->value.integer.value[0] = private->dim_mute[elem->control]; 3097 3098unlock: 3099 mutex_unlock(&private->data_mutex); 3100 return err; 3101} 3102 3103static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl, 3104 struct snd_ctl_elem_value *ucontrol) 3105{ 3106 struct usb_mixer_elem_info *elem = kctl->private_data; 3107 struct usb_mixer_interface *mixer = elem->head.mixer; 3108 struct scarlett2_data *private = mixer->private_data; 3109 const struct scarlett2_device_info *info = private->info; 3110 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3111 int num_line_out = 3112 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 3113 3114 int index = elem->control; 3115 int oval, val, err = 0, i; 3116 3117 mutex_lock(&private->data_mutex); 3118 3119 oval = private->dim_mute[index]; 3120 val = !!ucontrol->value.integer.value[0]; 3121 3122 if (oval == val) 3123 goto unlock; 3124 3125 private->dim_mute[index] = val; 3126 3127 /* Send switch change to the device */ 3128 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE, 3129 index, val); 3130 if (err == 0) 3131 err = 1; 3132 3133 if (index == SCARLETT2_BUTTON_MUTE) 3134 for (i = 0; i < num_line_out; i++) { 3135 int line_index = line_out_remap(private, i); 3136 3137 if (private->vol_sw_hw_switch[line_index]) { 3138 private->mute_switch[line_index] = val; 3139 snd_ctl_notify(mixer->chip->card, 3140 SNDRV_CTL_EVENT_MASK_VALUE, 3141 &private->mute_ctls[i]->id); 3142 } 3143 } 3144 3145unlock: 3146 mutex_unlock(&private->data_mutex); 3147 return err; 3148} 3149 3150static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = { 3151 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3152 .name = "", 3153 .info = snd_ctl_boolean_mono_info, 3154 .get = scarlett2_dim_mute_ctl_get, 3155 .put = scarlett2_dim_mute_ctl_put 3156}; 3157 3158/*** Create the analogue output controls ***/ 3159 3160static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer) 3161{ 3162 struct scarlett2_data *private = mixer->private_data; 3163 const struct scarlett2_device_info *info = private->info; 3164 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3165 int num_line_out = 3166 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 3167 int err, i; 3168 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3169 3170 /* Add R/O HW volume control */ 3171 if (info->line_out_hw_vol) { 3172 snprintf(s, sizeof(s), "Master HW Playback Volume"); 3173 err = scarlett2_add_new_ctl(mixer, 3174 &scarlett2_master_volume_ctl, 3175 0, 1, s, &private->master_vol_ctl); 3176 if (err < 0) 3177 return err; 3178 } 3179 3180 /* Add volume controls */ 3181 for (i = 0; i < num_line_out; i++) { 3182 int index = line_out_remap(private, i); 3183 3184 /* Fader */ 3185 if (info->line_out_descrs[i]) 3186 snprintf(s, sizeof(s), 3187 "Line %02d (%s) Playback Volume", 3188 i + 1, info->line_out_descrs[i]); 3189 else 3190 snprintf(s, sizeof(s), 3191 "Line %02d Playback Volume", 3192 i + 1); 3193 err = scarlett2_add_new_ctl(mixer, 3194 &scarlett2_line_out_volume_ctl, 3195 i, 1, s, &private->vol_ctls[i]); 3196 if (err < 0) 3197 return err; 3198 3199 /* Mute Switch */ 3200 snprintf(s, sizeof(s), 3201 "Line %02d Mute Playback Switch", 3202 i + 1); 3203 err = scarlett2_add_new_ctl(mixer, 3204 &scarlett2_mute_ctl, 3205 i, 1, s, 3206 &private->mute_ctls[i]); 3207 if (err < 0) 3208 return err; 3209 3210 /* Make the fader and mute controls read-only if the 3211 * SW/HW switch is set to HW 3212 */ 3213 if (private->vol_sw_hw_switch[index]) 3214 scarlett2_vol_ctl_set_writable(mixer, i, 0); 3215 3216 /* SW/HW Switch */ 3217 if (info->line_out_hw_vol) { 3218 snprintf(s, sizeof(s), 3219 "Line Out %02d Volume Control Playback Enum", 3220 i + 1); 3221 err = scarlett2_add_new_ctl(mixer, 3222 &scarlett2_sw_hw_enum_ctl, 3223 i, 1, s, 3224 &private->sw_hw_ctls[i]); 3225 if (err < 0) 3226 return err; 3227 3228 /* Make the switch read-only if the line is 3229 * involved in speaker switching 3230 */ 3231 if (private->speaker_switching_switch && i < 4) 3232 scarlett2_sw_hw_ctl_ro(private, i); 3233 } 3234 } 3235 3236 /* Add dim/mute controls */ 3237 if (info->line_out_hw_vol) 3238 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) { 3239 err = scarlett2_add_new_ctl( 3240 mixer, &scarlett2_dim_mute_ctl, 3241 i, 1, scarlett2_dim_mute_names[i], 3242 &private->dim_mute_ctls[i]); 3243 if (err < 0) 3244 return err; 3245 } 3246 3247 return 0; 3248} 3249 3250/*** Create the analogue input controls ***/ 3251 3252static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer) 3253{ 3254 struct scarlett2_data *private = mixer->private_data; 3255 const struct scarlett2_device_info *info = private->info; 3256 int err, i; 3257 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3258 const char *fmt = "Line In %d %s Capture %s"; 3259 const char *fmt2 = "Line In %d-%d %s Capture %s"; 3260 3261 /* Add input level (line/inst) controls */ 3262 for (i = 0; i < info->level_input_count; i++) { 3263 snprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first, 3264 "Level", "Enum"); 3265 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl, 3266 i, 1, s, &private->level_ctls[i]); 3267 if (err < 0) 3268 return err; 3269 } 3270 3271 /* Add input pad controls */ 3272 for (i = 0; i < info->pad_input_count; i++) { 3273 snprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch"); 3274 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl, 3275 i, 1, s, &private->pad_ctls[i]); 3276 if (err < 0) 3277 return err; 3278 } 3279 3280 /* Add input air controls */ 3281 for (i = 0; i < info->air_input_count; i++) { 3282 snprintf(s, sizeof(s), fmt, i + 1, "Air", "Switch"); 3283 err = scarlett2_add_new_ctl(mixer, &scarlett2_air_ctl, 3284 i, 1, s, &private->air_ctls[i]); 3285 if (err < 0) 3286 return err; 3287 } 3288 3289 /* Add input phantom controls */ 3290 if (info->inputs_per_phantom == 1) { 3291 for (i = 0; i < info->phantom_count; i++) { 3292 scnprintf(s, sizeof(s), fmt, i + 1, 3293 "Phantom Power", "Switch"); 3294 err = scarlett2_add_new_ctl( 3295 mixer, &scarlett2_phantom_ctl, 3296 i, 1, s, &private->phantom_ctls[i]); 3297 if (err < 0) 3298 return err; 3299 } 3300 } else if (info->inputs_per_phantom > 1) { 3301 for (i = 0; i < info->phantom_count; i++) { 3302 int from = i * info->inputs_per_phantom + 1; 3303 int to = (i + 1) * info->inputs_per_phantom; 3304 3305 scnprintf(s, sizeof(s), fmt2, from, to, 3306 "Phantom Power", "Switch"); 3307 err = scarlett2_add_new_ctl( 3308 mixer, &scarlett2_phantom_ctl, 3309 i, 1, s, &private->phantom_ctls[i]); 3310 if (err < 0) 3311 return err; 3312 } 3313 } 3314 if (info->phantom_count) { 3315 err = scarlett2_add_new_ctl( 3316 mixer, &scarlett2_phantom_persistence_ctl, 0, 1, 3317 "Phantom Power Persistence Capture Switch", NULL); 3318 if (err < 0) 3319 return err; 3320 } 3321 3322 return 0; 3323} 3324 3325/*** Mixer Volume Controls ***/ 3326 3327static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl, 3328 struct snd_ctl_elem_info *uinfo) 3329{ 3330 struct usb_mixer_elem_info *elem = kctl->private_data; 3331 3332 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 3333 uinfo->count = elem->channels; 3334 uinfo->value.integer.min = 0; 3335 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE; 3336 uinfo->value.integer.step = 1; 3337 return 0; 3338} 3339 3340static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl, 3341 struct snd_ctl_elem_value *ucontrol) 3342{ 3343 struct usb_mixer_elem_info *elem = kctl->private_data; 3344 struct scarlett2_data *private = elem->head.mixer->private_data; 3345 3346 ucontrol->value.integer.value[0] = private->mix[elem->control]; 3347 return 0; 3348} 3349 3350static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl, 3351 struct snd_ctl_elem_value *ucontrol) 3352{ 3353 struct usb_mixer_elem_info *elem = kctl->private_data; 3354 struct usb_mixer_interface *mixer = elem->head.mixer; 3355 struct scarlett2_data *private = mixer->private_data; 3356 const struct scarlett2_device_info *info = private->info; 3357 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3358 int oval, val, num_mixer_in, mix_num, err = 0; 3359 int index = elem->control; 3360 3361 mutex_lock(&private->data_mutex); 3362 3363 oval = private->mix[index]; 3364 val = clamp(ucontrol->value.integer.value[0], 3365 0L, (long)SCARLETT2_MIXER_MAX_VALUE); 3366 num_mixer_in = port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; 3367 mix_num = index / num_mixer_in; 3368 3369 if (oval == val) 3370 goto unlock; 3371 3372 private->mix[index] = val; 3373 err = scarlett2_usb_set_mix(mixer, mix_num); 3374 if (err == 0) 3375 err = 1; 3376 3377unlock: 3378 mutex_unlock(&private->data_mutex); 3379 return err; 3380} 3381 3382static const DECLARE_TLV_DB_MINMAX( 3383 db_scale_scarlett2_mixer, 3384 SCARLETT2_MIXER_MIN_DB * 100, 3385 SCARLETT2_MIXER_MAX_DB * 100 3386); 3387 3388static const struct snd_kcontrol_new scarlett2_mixer_ctl = { 3389 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3390 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 3391 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 3392 .name = "", 3393 .info = scarlett2_mixer_ctl_info, 3394 .get = scarlett2_mixer_ctl_get, 3395 .put = scarlett2_mixer_ctl_put, 3396 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ 3397 .tlv = { .p = db_scale_scarlett2_mixer } 3398}; 3399 3400static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer) 3401{ 3402 struct scarlett2_data *private = mixer->private_data; 3403 const struct scarlett2_device_info *info = private->info; 3404 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3405 int err, i, j; 3406 int index; 3407 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3408 3409 int num_inputs = 3410 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT]; 3411 int num_outputs = 3412 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; 3413 3414 for (i = 0, index = 0; i < num_outputs; i++) 3415 for (j = 0; j < num_inputs; j++, index++) { 3416 snprintf(s, sizeof(s), 3417 "Mix %c Input %02d Playback Volume", 3418 'A' + i, j + 1); 3419 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl, 3420 index, 1, s, NULL); 3421 if (err < 0) 3422 return err; 3423 } 3424 3425 return 0; 3426} 3427 3428/*** Mux Source Selection Controls ***/ 3429 3430static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl, 3431 struct snd_ctl_elem_info *uinfo) 3432{ 3433 struct usb_mixer_elem_info *elem = kctl->private_data; 3434 struct scarlett2_data *private = elem->head.mixer->private_data; 3435 const struct scarlett2_device_info *info = private->info; 3436 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3437 unsigned int item = uinfo->value.enumerated.item; 3438 int items = private->num_mux_srcs; 3439 int port_type; 3440 3441 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 3442 uinfo->count = elem->channels; 3443 uinfo->value.enumerated.items = items; 3444 3445 if (item >= items) 3446 item = uinfo->value.enumerated.item = items - 1; 3447 3448 for (port_type = 0; 3449 port_type < SCARLETT2_PORT_TYPE_COUNT; 3450 port_type++) { 3451 if (item < port_count[port_type][SCARLETT2_PORT_IN]) { 3452 const struct scarlett2_port *port = 3453 &scarlett2_ports[port_type]; 3454 3455 sprintf(uinfo->value.enumerated.name, 3456 port->src_descr, item + port->src_num_offset); 3457 return 0; 3458 } 3459 item -= port_count[port_type][SCARLETT2_PORT_IN]; 3460 } 3461 3462 return -EINVAL; 3463} 3464 3465static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl, 3466 struct snd_ctl_elem_value *ucontrol) 3467{ 3468 struct usb_mixer_elem_info *elem = kctl->private_data; 3469 struct usb_mixer_interface *mixer = elem->head.mixer; 3470 struct scarlett2_data *private = mixer->private_data; 3471 int index = line_out_remap(private, elem->control); 3472 int err = 0; 3473 3474 mutex_lock(&private->data_mutex); 3475 3476 if (private->mux_updated) { 3477 err = scarlett2_usb_get_mux(mixer); 3478 if (err < 0) 3479 goto unlock; 3480 } 3481 ucontrol->value.enumerated.item[0] = private->mux[index]; 3482 3483unlock: 3484 mutex_unlock(&private->data_mutex); 3485 return err; 3486} 3487 3488static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl, 3489 struct snd_ctl_elem_value *ucontrol) 3490{ 3491 struct usb_mixer_elem_info *elem = kctl->private_data; 3492 struct usb_mixer_interface *mixer = elem->head.mixer; 3493 struct scarlett2_data *private = mixer->private_data; 3494 int index = line_out_remap(private, elem->control); 3495 int oval, val, err = 0; 3496 3497 mutex_lock(&private->data_mutex); 3498 3499 oval = private->mux[index]; 3500 val = min(ucontrol->value.enumerated.item[0], 3501 private->num_mux_srcs - 1U); 3502 3503 if (oval == val) 3504 goto unlock; 3505 3506 private->mux[index] = val; 3507 err = scarlett2_usb_set_mux(mixer); 3508 if (err == 0) 3509 err = 1; 3510 3511unlock: 3512 mutex_unlock(&private->data_mutex); 3513 return err; 3514} 3515 3516static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = { 3517 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3518 .name = "", 3519 .info = scarlett2_mux_src_enum_ctl_info, 3520 .get = scarlett2_mux_src_enum_ctl_get, 3521 .put = scarlett2_mux_src_enum_ctl_put, 3522}; 3523 3524static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer) 3525{ 3526 struct scarlett2_data *private = mixer->private_data; 3527 const struct scarlett2_device_info *info = private->info; 3528 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3529 int port_type, channel, i; 3530 3531 for (i = 0, port_type = 0; 3532 port_type < SCARLETT2_PORT_TYPE_COUNT; 3533 port_type++) { 3534 for (channel = 0; 3535 channel < port_count[port_type][SCARLETT2_PORT_OUT]; 3536 channel++, i++) { 3537 int err; 3538 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 3539 const char *const descr = 3540 scarlett2_ports[port_type].dst_descr; 3541 3542 snprintf(s, sizeof(s) - 5, descr, channel + 1); 3543 strcat(s, " Enum"); 3544 3545 err = scarlett2_add_new_ctl(mixer, 3546 &scarlett2_mux_src_enum_ctl, 3547 i, 1, s, 3548 &private->mux_ctls[i]); 3549 if (err < 0) 3550 return err; 3551 } 3552 } 3553 3554 return 0; 3555} 3556 3557/*** Meter Controls ***/ 3558 3559static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl, 3560 struct snd_ctl_elem_info *uinfo) 3561{ 3562 struct usb_mixer_elem_info *elem = kctl->private_data; 3563 3564 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 3565 uinfo->count = elem->channels; 3566 uinfo->value.integer.min = 0; 3567 uinfo->value.integer.max = 4095; 3568 uinfo->value.integer.step = 1; 3569 return 0; 3570} 3571 3572static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl, 3573 struct snd_ctl_elem_value *ucontrol) 3574{ 3575 struct usb_mixer_elem_info *elem = kctl->private_data; 3576 u16 meter_levels[SCARLETT2_MAX_METERS]; 3577 int i, err; 3578 3579 err = scarlett2_usb_get_meter_levels(elem->head.mixer, elem->channels, 3580 meter_levels); 3581 if (err < 0) 3582 return err; 3583 3584 for (i = 0; i < elem->channels; i++) 3585 ucontrol->value.integer.value[i] = meter_levels[i]; 3586 3587 return 0; 3588} 3589 3590static const struct snd_kcontrol_new scarlett2_meter_ctl = { 3591 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 3592 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 3593 .name = "", 3594 .info = scarlett2_meter_ctl_info, 3595 .get = scarlett2_meter_ctl_get 3596}; 3597 3598static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer) 3599{ 3600 struct scarlett2_data *private = mixer->private_data; 3601 3602 /* devices without a mixer also don't support reporting levels */ 3603 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) 3604 return 0; 3605 3606 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl, 3607 0, private->num_mux_dsts, 3608 "Level Meter", NULL); 3609} 3610 3611/*** MSD Controls ***/ 3612 3613static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl, 3614 struct snd_ctl_elem_value *ucontrol) 3615{ 3616 struct usb_mixer_elem_info *elem = kctl->private_data; 3617 struct scarlett2_data *private = elem->head.mixer->private_data; 3618 3619 ucontrol->value.integer.value[0] = private->msd_switch; 3620 return 0; 3621} 3622 3623static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl, 3624 struct snd_ctl_elem_value *ucontrol) 3625{ 3626 struct usb_mixer_elem_info *elem = kctl->private_data; 3627 struct usb_mixer_interface *mixer = elem->head.mixer; 3628 struct scarlett2_data *private = mixer->private_data; 3629 3630 int oval, val, err = 0; 3631 3632 mutex_lock(&private->data_mutex); 3633 3634 oval = private->msd_switch; 3635 val = !!ucontrol->value.integer.value[0]; 3636 3637 if (oval == val) 3638 goto unlock; 3639 3640 private->msd_switch = val; 3641 3642 /* Send switch change to the device */ 3643 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH, 3644 0, val); 3645 if (err == 0) 3646 err = 1; 3647 3648unlock: 3649 mutex_unlock(&private->data_mutex); 3650 return err; 3651} 3652 3653static const struct snd_kcontrol_new scarlett2_msd_ctl = { 3654 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3655 .name = "", 3656 .info = snd_ctl_boolean_mono_info, 3657 .get = scarlett2_msd_ctl_get, 3658 .put = scarlett2_msd_ctl_put, 3659}; 3660 3661static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer) 3662{ 3663 struct scarlett2_data *private = mixer->private_data; 3664 const struct scarlett2_device_info *info = private->info; 3665 3666 if (!info->has_msd_mode) 3667 return 0; 3668 3669 /* If MSD mode is off, hide the switch by default */ 3670 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE)) 3671 return 0; 3672 3673 /* Add MSD control */ 3674 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl, 3675 0, 1, "MSD Mode Switch", NULL); 3676} 3677 3678/*** Standalone Control ***/ 3679 3680static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl, 3681 struct snd_ctl_elem_value *ucontrol) 3682{ 3683 struct usb_mixer_elem_info *elem = kctl->private_data; 3684 struct scarlett2_data *private = elem->head.mixer->private_data; 3685 3686 ucontrol->value.integer.value[0] = private->standalone_switch; 3687 return 0; 3688} 3689 3690static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl, 3691 struct snd_ctl_elem_value *ucontrol) 3692{ 3693 struct usb_mixer_elem_info *elem = kctl->private_data; 3694 struct usb_mixer_interface *mixer = elem->head.mixer; 3695 struct scarlett2_data *private = mixer->private_data; 3696 3697 int oval, val, err = 0; 3698 3699 mutex_lock(&private->data_mutex); 3700 3701 oval = private->standalone_switch; 3702 val = !!ucontrol->value.integer.value[0]; 3703 3704 if (oval == val) 3705 goto unlock; 3706 3707 private->standalone_switch = val; 3708 3709 /* Send switch change to the device */ 3710 err = scarlett2_usb_set_config(mixer, 3711 SCARLETT2_CONFIG_STANDALONE_SWITCH, 3712 0, val); 3713 if (err == 0) 3714 err = 1; 3715 3716unlock: 3717 mutex_unlock(&private->data_mutex); 3718 return err; 3719} 3720 3721static const struct snd_kcontrol_new scarlett2_standalone_ctl = { 3722 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3723 .name = "", 3724 .info = snd_ctl_boolean_mono_info, 3725 .get = scarlett2_standalone_ctl_get, 3726 .put = scarlett2_standalone_ctl_put, 3727}; 3728 3729static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer) 3730{ 3731 struct scarlett2_data *private = mixer->private_data; 3732 3733 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) 3734 return 0; 3735 3736 /* Add standalone control */ 3737 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl, 3738 0, 1, "Standalone Switch", NULL); 3739} 3740 3741/*** Cleanup/Suspend Callbacks ***/ 3742 3743static void scarlett2_private_free(struct usb_mixer_interface *mixer) 3744{ 3745 struct scarlett2_data *private = mixer->private_data; 3746 3747 cancel_delayed_work_sync(&private->work); 3748 kfree(private); 3749 mixer->private_data = NULL; 3750} 3751 3752static void scarlett2_private_suspend(struct usb_mixer_interface *mixer) 3753{ 3754 struct scarlett2_data *private = mixer->private_data; 3755 3756 if (cancel_delayed_work_sync(&private->work)) 3757 scarlett2_config_save(private->mixer); 3758} 3759 3760/*** Initialisation ***/ 3761 3762static void scarlett2_count_mux_io(struct scarlett2_data *private) 3763{ 3764 const struct scarlett2_device_info *info = private->info; 3765 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3766 int port_type, srcs = 0, dsts = 0; 3767 3768 for (port_type = 0; 3769 port_type < SCARLETT2_PORT_TYPE_COUNT; 3770 port_type++) { 3771 srcs += port_count[port_type][SCARLETT2_PORT_IN]; 3772 dsts += port_count[port_type][SCARLETT2_PORT_OUT]; 3773 } 3774 3775 private->num_mux_srcs = srcs; 3776 private->num_mux_dsts = dsts; 3777} 3778 3779/* Look through the interface descriptors for the Focusrite Control 3780 * interface (bInterfaceClass = 255 Vendor Specific Class) and set 3781 * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval 3782 * in private 3783 */ 3784static int scarlett2_find_fc_interface(struct usb_device *dev, 3785 struct scarlett2_data *private) 3786{ 3787 struct usb_host_config *config = dev->actconfig; 3788 int i; 3789 3790 for (i = 0; i < config->desc.bNumInterfaces; i++) { 3791 struct usb_interface *intf = config->interface[i]; 3792 struct usb_interface_descriptor *desc = 3793 &intf->altsetting[0].desc; 3794 struct usb_endpoint_descriptor *epd; 3795 3796 if (desc->bInterfaceClass != 255) 3797 continue; 3798 3799 epd = get_endpoint(intf->altsetting, 0); 3800 private->bInterfaceNumber = desc->bInterfaceNumber; 3801 private->bEndpointAddress = epd->bEndpointAddress & 3802 USB_ENDPOINT_NUMBER_MASK; 3803 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize); 3804 private->bInterval = epd->bInterval; 3805 return 0; 3806 } 3807 3808 return -EINVAL; 3809} 3810 3811/* Initialise private data */ 3812static int scarlett2_init_private(struct usb_mixer_interface *mixer, 3813 const struct scarlett2_device_info *info) 3814{ 3815 struct scarlett2_data *private = 3816 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL); 3817 3818 if (!private) 3819 return -ENOMEM; 3820 3821 mutex_init(&private->usb_mutex); 3822 mutex_init(&private->data_mutex); 3823 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work); 3824 3825 mixer->private_data = private; 3826 mixer->private_free = scarlett2_private_free; 3827 mixer->private_suspend = scarlett2_private_suspend; 3828 3829 private->info = info; 3830 scarlett2_count_mux_io(private); 3831 private->scarlett2_seq = 0; 3832 private->mixer = mixer; 3833 3834 return scarlett2_find_fc_interface(mixer->chip->dev, private); 3835} 3836 3837/* Cargo cult proprietary initialisation sequence */ 3838static int scarlett2_usb_init(struct usb_mixer_interface *mixer) 3839{ 3840 struct usb_device *dev = mixer->chip->dev; 3841 struct scarlett2_data *private = mixer->private_data; 3842 u8 buf[24]; 3843 int err; 3844 3845 if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0))) 3846 return -EINVAL; 3847 3848 /* step 0 */ 3849 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, 3850 SCARLETT2_USB_CMD_INIT, buf, sizeof(buf)); 3851 if (err < 0) 3852 return err; 3853 3854 /* step 1 */ 3855 private->scarlett2_seq = 1; 3856 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0); 3857 if (err < 0) 3858 return err; 3859 3860 /* step 2 */ 3861 private->scarlett2_seq = 1; 3862 return scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, NULL, 0, NULL, 84); 3863} 3864 3865/* Read configuration from the interface on start */ 3866static int scarlett2_read_configs(struct usb_mixer_interface *mixer) 3867{ 3868 struct scarlett2_data *private = mixer->private_data; 3869 const struct scarlett2_device_info *info = private->info; 3870 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3871 int num_line_out = 3872 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 3873 int num_mixer_out = 3874 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN]; 3875 struct scarlett2_usb_volume_status volume_status; 3876 int err, i; 3877 3878 if (info->has_msd_mode) { 3879 err = scarlett2_usb_get_config( 3880 mixer, SCARLETT2_CONFIG_MSD_SWITCH, 3881 1, &private->msd_switch); 3882 if (err < 0) 3883 return err; 3884 3885 /* no other controls are created if MSD mode is on */ 3886 if (private->msd_switch) 3887 return 0; 3888 } 3889 3890 err = scarlett2_update_input_other(mixer); 3891 if (err < 0) 3892 return err; 3893 3894 err = scarlett2_update_monitor_other(mixer); 3895 if (err < 0) 3896 return err; 3897 3898 /* the rest of the configuration is for devices with a mixer */ 3899 if (info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER) 3900 return 0; 3901 3902 err = scarlett2_usb_get_config( 3903 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH, 3904 1, &private->standalone_switch); 3905 if (err < 0) 3906 return err; 3907 3908 err = scarlett2_update_sync(mixer); 3909 if (err < 0) 3910 return err; 3911 3912 err = scarlett2_usb_get_volume_status(mixer, &volume_status); 3913 if (err < 0) 3914 return err; 3915 3916 if (info->line_out_hw_vol) 3917 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 3918 private->dim_mute[i] = !!volume_status.dim_mute[i]; 3919 3920 private->master_vol = clamp( 3921 volume_status.master_vol + SCARLETT2_VOLUME_BIAS, 3922 0, SCARLETT2_VOLUME_BIAS); 3923 3924 for (i = 0; i < num_line_out; i++) { 3925 int volume, mute; 3926 3927 private->vol_sw_hw_switch[i] = 3928 info->line_out_hw_vol 3929 && volume_status.sw_hw_switch[i]; 3930 3931 volume = private->vol_sw_hw_switch[i] 3932 ? volume_status.master_vol 3933 : volume_status.sw_vol[i]; 3934 volume = clamp(volume + SCARLETT2_VOLUME_BIAS, 3935 0, SCARLETT2_VOLUME_BIAS); 3936 private->vol[i] = volume; 3937 3938 mute = private->vol_sw_hw_switch[i] 3939 ? private->dim_mute[SCARLETT2_BUTTON_MUTE] 3940 : volume_status.mute_switch[i]; 3941 private->mute_switch[i] = mute; 3942 } 3943 3944 for (i = 0; i < num_mixer_out; i++) { 3945 err = scarlett2_usb_get_mix(mixer, i); 3946 if (err < 0) 3947 return err; 3948 } 3949 3950 return scarlett2_usb_get_mux(mixer); 3951} 3952 3953/* Notify on sync change */ 3954static void scarlett2_notify_sync( 3955 struct usb_mixer_interface *mixer) 3956{ 3957 struct scarlett2_data *private = mixer->private_data; 3958 3959 private->sync_updated = 1; 3960 3961 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 3962 &private->sync_ctl->id); 3963} 3964 3965/* Notify on monitor change */ 3966static void scarlett2_notify_monitor( 3967 struct usb_mixer_interface *mixer) 3968{ 3969 struct snd_card *card = mixer->chip->card; 3970 struct scarlett2_data *private = mixer->private_data; 3971 const struct scarlett2_device_info *info = private->info; 3972 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 3973 int num_line_out = 3974 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 3975 int i; 3976 3977 /* if line_out_hw_vol is 0, there are no controls to update */ 3978 if (!info->line_out_hw_vol) 3979 return; 3980 3981 private->vol_updated = 1; 3982 3983 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 3984 &private->master_vol_ctl->id); 3985 3986 for (i = 0; i < num_line_out; i++) 3987 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 3988 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 3989 &private->vol_ctls[i]->id); 3990} 3991 3992/* Notify on dim/mute change */ 3993static void scarlett2_notify_dim_mute( 3994 struct usb_mixer_interface *mixer) 3995{ 3996 struct snd_card *card = mixer->chip->card; 3997 struct scarlett2_data *private = mixer->private_data; 3998 const struct scarlett2_device_info *info = private->info; 3999 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 4000 int num_line_out = 4001 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 4002 int i; 4003 4004 private->vol_updated = 1; 4005 4006 if (!info->line_out_hw_vol) 4007 return; 4008 4009 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 4010 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4011 &private->dim_mute_ctls[i]->id); 4012 4013 for (i = 0; i < num_line_out; i++) 4014 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 4015 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4016 &private->mute_ctls[i]->id); 4017} 4018 4019/* Notify on "input other" change (level/pad/air) */ 4020static void scarlett2_notify_input_other( 4021 struct usb_mixer_interface *mixer) 4022{ 4023 struct snd_card *card = mixer->chip->card; 4024 struct scarlett2_data *private = mixer->private_data; 4025 const struct scarlett2_device_info *info = private->info; 4026 int i; 4027 4028 private->input_other_updated = 1; 4029 4030 for (i = 0; i < info->level_input_count; i++) 4031 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4032 &private->level_ctls[i]->id); 4033 for (i = 0; i < info->pad_input_count; i++) 4034 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4035 &private->pad_ctls[i]->id); 4036 for (i = 0; i < info->air_input_count; i++) 4037 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4038 &private->air_ctls[i]->id); 4039 for (i = 0; i < info->phantom_count; i++) 4040 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4041 &private->phantom_ctls[i]->id); 4042} 4043 4044/* Notify on "monitor other" change (direct monitor, speaker 4045 * switching, talkback) 4046 */ 4047static void scarlett2_notify_monitor_other( 4048 struct usb_mixer_interface *mixer) 4049{ 4050 struct snd_card *card = mixer->chip->card; 4051 struct scarlett2_data *private = mixer->private_data; 4052 const struct scarlett2_device_info *info = private->info; 4053 4054 private->monitor_other_updated = 1; 4055 4056 if (info->direct_monitor) { 4057 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4058 &private->direct_monitor_ctl->id); 4059 return; 4060 } 4061 4062 if (info->has_speaker_switching) 4063 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4064 &private->speaker_switching_ctl->id); 4065 4066 if (info->has_talkback) 4067 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4068 &private->talkback_ctl->id); 4069 4070 /* if speaker switching was recently enabled or disabled, 4071 * invalidate the dim/mute and mux enum controls 4072 */ 4073 if (private->speaker_switching_switched) { 4074 int i; 4075 4076 scarlett2_notify_dim_mute(mixer); 4077 4078 private->speaker_switching_switched = 0; 4079 private->mux_updated = 1; 4080 4081 for (i = 0; i < private->num_mux_dsts; i++) 4082 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 4083 &private->mux_ctls[i]->id); 4084 } 4085} 4086 4087/* Interrupt callback */ 4088static void scarlett2_notify(struct urb *urb) 4089{ 4090 struct usb_mixer_interface *mixer = urb->context; 4091 int len = urb->actual_length; 4092 int ustatus = urb->status; 4093 u32 data; 4094 4095 if (ustatus != 0 || len != 8) 4096 goto requeue; 4097 4098 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer); 4099 if (data & SCARLETT2_USB_NOTIFY_SYNC) 4100 scarlett2_notify_sync(mixer); 4101 if (data & SCARLETT2_USB_NOTIFY_MONITOR) 4102 scarlett2_notify_monitor(mixer); 4103 if (data & SCARLETT2_USB_NOTIFY_DIM_MUTE) 4104 scarlett2_notify_dim_mute(mixer); 4105 if (data & SCARLETT2_USB_NOTIFY_INPUT_OTHER) 4106 scarlett2_notify_input_other(mixer); 4107 if (data & SCARLETT2_USB_NOTIFY_MONITOR_OTHER) 4108 scarlett2_notify_monitor_other(mixer); 4109 4110requeue: 4111 if (ustatus != -ENOENT && 4112 ustatus != -ECONNRESET && 4113 ustatus != -ESHUTDOWN) { 4114 urb->dev = mixer->chip->dev; 4115 usb_submit_urb(urb, GFP_ATOMIC); 4116 } 4117} 4118 4119static int scarlett2_init_notify(struct usb_mixer_interface *mixer) 4120{ 4121 struct usb_device *dev = mixer->chip->dev; 4122 struct scarlett2_data *private = mixer->private_data; 4123 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress); 4124 void *transfer_buffer; 4125 4126 if (mixer->urb) { 4127 usb_audio_err(mixer->chip, 4128 "%s: mixer urb already in use!\n", __func__); 4129 return 0; 4130 } 4131 4132 if (usb_pipe_type_check(dev, pipe)) 4133 return -EINVAL; 4134 4135 mixer->urb = usb_alloc_urb(0, GFP_KERNEL); 4136 if (!mixer->urb) 4137 return -ENOMEM; 4138 4139 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL); 4140 if (!transfer_buffer) 4141 return -ENOMEM; 4142 4143 usb_fill_int_urb(mixer->urb, dev, pipe, 4144 transfer_buffer, private->wMaxPacketSize, 4145 scarlett2_notify, mixer, private->bInterval); 4146 4147 return usb_submit_urb(mixer->urb, GFP_KERNEL); 4148} 4149 4150static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer) 4151{ 4152 const struct scarlett2_device_info **info = scarlett2_devices; 4153 int err; 4154 4155 /* Find device in scarlett2_devices */ 4156 while (*info && (*info)->usb_id != mixer->chip->usb_id) 4157 info++; 4158 if (!*info) 4159 return -EINVAL; 4160 4161 /* Initialise private data */ 4162 err = scarlett2_init_private(mixer, *info); 4163 if (err < 0) 4164 return err; 4165 4166 /* Send proprietary USB initialisation sequence */ 4167 err = scarlett2_usb_init(mixer); 4168 if (err < 0) 4169 return err; 4170 4171 /* Read volume levels and controls from the interface */ 4172 err = scarlett2_read_configs(mixer); 4173 if (err < 0) 4174 return err; 4175 4176 /* Create the MSD control */ 4177 err = scarlett2_add_msd_ctl(mixer); 4178 if (err < 0) 4179 return err; 4180 4181 /* If MSD mode is enabled, don't create any other controls */ 4182 if (((struct scarlett2_data *)mixer->private_data)->msd_switch) 4183 return 0; 4184 4185 /* Create the analogue output controls */ 4186 err = scarlett2_add_line_out_ctls(mixer); 4187 if (err < 0) 4188 return err; 4189 4190 /* Create the analogue input controls */ 4191 err = scarlett2_add_line_in_ctls(mixer); 4192 if (err < 0) 4193 return err; 4194 4195 /* Create the input, output, and mixer mux input selections */ 4196 err = scarlett2_add_mux_enums(mixer); 4197 if (err < 0) 4198 return err; 4199 4200 /* Create the matrix mixer controls */ 4201 err = scarlett2_add_mixer_ctls(mixer); 4202 if (err < 0) 4203 return err; 4204 4205 /* Create the level meter controls */ 4206 err = scarlett2_add_meter_ctl(mixer); 4207 if (err < 0) 4208 return err; 4209 4210 /* Create the sync control */ 4211 err = scarlett2_add_sync_ctl(mixer); 4212 if (err < 0) 4213 return err; 4214 4215 /* Create the direct monitor control */ 4216 err = scarlett2_add_direct_monitor_ctl(mixer); 4217 if (err < 0) 4218 return err; 4219 4220 /* Create the speaker switching control */ 4221 err = scarlett2_add_speaker_switch_ctl(mixer); 4222 if (err < 0) 4223 return err; 4224 4225 /* Create the talkback controls */ 4226 err = scarlett2_add_talkback_ctls(mixer); 4227 if (err < 0) 4228 return err; 4229 4230 /* Create the standalone control */ 4231 err = scarlett2_add_standalone_ctl(mixer); 4232 if (err < 0) 4233 return err; 4234 4235 /* Set up the interrupt polling */ 4236 err = scarlett2_init_notify(mixer); 4237 if (err < 0) 4238 return err; 4239 4240 return 0; 4241} 4242 4243int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer) 4244{ 4245 struct snd_usb_audio *chip = mixer->chip; 4246 int err; 4247 4248 /* only use UAC_VERSION_2 */ 4249 if (!mixer->protocol) 4250 return 0; 4251 4252 if (!(chip->setup & SCARLETT2_ENABLE)) { 4253 usb_audio_info(chip, 4254 "Focusrite Scarlett Gen 2/3 Mixer Driver disabled; " 4255 "use options snd_usb_audio vid=0x%04x pid=0x%04x " 4256 "device_setup=1 to enable and report any issues " 4257 "to g@b4.vu", 4258 USB_ID_VENDOR(chip->usb_id), 4259 USB_ID_PRODUCT(chip->usb_id)); 4260 return 0; 4261 } 4262 4263 usb_audio_info(chip, 4264 "Focusrite Scarlett Gen 2/3 Mixer Driver enabled pid=0x%04x", 4265 USB_ID_PRODUCT(chip->usb_id)); 4266 4267 err = snd_scarlett_gen2_controls_create(mixer); 4268 if (err < 0) 4269 usb_audio_err(mixer->chip, 4270 "Error initialising Scarlett Mixer Driver: %d", 4271 err); 4272 4273 return err; 4274} 4275