1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Focusrite Scarlett 2 Protocol Driver for ALSA 4 * (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and 5 * Clarett+ series products) 6 * 7 * Supported models: 8 * - 6i6/18i8/18i20 Gen 2 9 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3 10 * - Solo/2i2/4i4 Gen 4 11 * - Clarett 2Pre/4Pre/8Pre USB 12 * - Clarett+ 2Pre/4Pre/8Pre 13 * 14 * Copyright (c) 2018-2023 by Geoffrey D. Bennett <g at b4.vu> 15 * Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com> 16 * Copyright (c) 2022 by Christian Colglazier <christian@cacolglazier.com> 17 * 18 * Based on the Scarlett (Gen 1) Driver for ALSA: 19 * 20 * Copyright (c) 2013 by Tobias Hoffmann 21 * Copyright (c) 2013 by Robin Gareus <robin at gareus.org> 22 * Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de> 23 * Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com> 24 * 25 * Many codes borrowed from audio.c by 26 * Alan Cox (alan at lxorguk.ukuu.org.uk) 27 * Thomas Sailer (sailer at ife.ee.ethz.ch) 28 * 29 * Code cleanup: 30 * David Henningsson <david.henningsson at canonical.com> 31 */ 32 33/* The protocol was reverse engineered by looking at the communication 34 * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20 35 * (firmware 1083) using usbmon in July-August 2018. 36 * 37 * Scarlett 18i8 support added in April 2019. 38 * 39 * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann 40 * for providing usbmon output and testing). 41 * 42 * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent 43 * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6 44 * usbmon output and testing). 45 * 46 * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to 47 * Darren Jaeckel, Alex Sedlack, and Clovis Lunel for providing usbmon 48 * output, protocol traces and testing). 49 * 50 * Support for loading mixer volume and mux configuration from the 51 * interface during driver initialisation added in May 2021 (thanks to 52 * Vladimir Sadovnikov for figuring out how). 53 * 54 * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander 55 * Vorona for 2i2 protocol traces). 56 * 57 * Support for phantom power, direct monitoring, speaker switching, 58 * and talkback added in May-June 2021. 59 * 60 * Support for Clarett+ 8Pre added in Aug 2022 by Christian 61 * Colglazier. 62 * 63 * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe 64 * Perrot for confirmation). 65 * 66 * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to 67 * Gregory Rozzo for donating a 4Pre, and David Sherwood and Patrice 68 * Peterson for usbmon output). 69 * 70 * Support for Clarett 2Pre and 4Pre USB added in Oct 2023. 71 * 72 * Support for firmware updates added in Dec 2023. 73 * 74 * Support for Scarlett Solo/2i2/4i4 Gen 4 added in Dec 2023 (thanks 75 * to many LinuxMusicians people and to Focusrite for hardware 76 * donations). 77 * 78 * This ALSA mixer gives access to (model-dependent): 79 * - input, output, mixer-matrix muxes 80 * - mixer-matrix gain stages 81 * - gain/volume/mute controls 82 * - level meters 83 * - line/inst level, pad, and air controls 84 * - phantom power, direct monitor, speaker switching, and talkback 85 * controls 86 * - disable/enable MSD mode 87 * - disable/enable standalone mode 88 * - input gain, autogain, safe mode 89 * - direct monitor mixes 90 * 91 * <ditaa> 92 * /--------------\ 18chn 20chn /--------------\ 93 * | Hardware in +--+------\ /-------------+--+ ALSA PCM out | 94 * \--------------/ | | | | \--------------/ 95 * | | | /-----\ | 96 * | | | | | | 97 * | v v v | | 98 * | +---------------+ | | 99 * | \ Matrix Mux / | | 100 * | +-----+-----+ | | 101 * | | | | 102 * | |18chn | | 103 * | | | | 104 * | | 10chn| | 105 * | v | | 106 * | +------------+ | | 107 * | | Mixer | | | 108 * | | Matrix | | | 109 * | | | | | 110 * | | 18x10 Gain | | | 111 * | | stages | | | 112 * | +-----+------+ | | 113 * | | | | 114 * |18chn |10chn | |20chn 115 * | | | | 116 * | +----------/ | 117 * | | | 118 * v v v 119 * =========================== 120 * +---------------+ +--���------------+ 121 * \ Output Mux / \ Capture Mux / 122 * +---+---+---+ +-----+-----+ 123 * | | | 124 * 10chn| | |18chn 125 * | | | 126 * /--------------\ | | | /--------------\ 127 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in | 128 * | Hardware out | | \--------------/ 129 * \--------------/ | 130 * v 131 * +-------------+ Software gain per channel. 132 * | Master Gain |<-- 18i20 only: Switch per channel 133 * +------+------+ to select HW or SW gain control. 134 * | 135 * |10chn 136 * /--------------\ | 137 * | Analogue |<------/ 138 * | Hardware out | 139 * \--------------/ 140 * </ditaa> 141 * 142 * Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small 143 * disk with registration and driver download information is presented 144 * to the host. To access the full functionality of the device without 145 * proprietary software, MSD mode can be disabled by: 146 * - holding down the 48V button for five seconds while powering on 147 * the device, or 148 * - using this driver and alsamixer to change the "MSD Mode" setting 149 * to Off and power-cycling the device 150 */ 151 152#include <linux/slab.h> 153#include <linux/usb.h> 154#include <linux/moduleparam.h> 155 156#include <sound/control.h> 157#include <sound/tlv.h> 158#include <sound/hwdep.h> 159 160#include <uapi/sound/scarlett2.h> 161 162#include "usbaudio.h" 163#include "mixer.h" 164#include "helper.h" 165 166#include "mixer_scarlett2.h" 167 168/* device_setup value to allow turning MSD mode back on */ 169#define SCARLETT2_MSD_ENABLE 0x02 170 171/* device_setup value to disable this mixer driver */ 172#define SCARLETT2_DISABLE 0x04 173 174/* some gui mixers can't handle negative ctl values */ 175#define SCARLETT2_VOLUME_BIAS 127 176 177/* maximum preamp input gain and value 178 * values are from 0 to 70, preamp gain is from 0 to 69 dB 179 */ 180#define SCARLETT2_MAX_GAIN_VALUE 70 181#define SCARLETT2_MAX_GAIN_DB 69 182 183/* mixer range from -80dB to +6dB in 0.5dB steps */ 184#define SCARLETT2_MIXER_MIN_DB -80 185#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2) 186#define SCARLETT2_MIXER_MAX_DB 6 187#define SCARLETT2_MIXER_MAX_VALUE \ 188 ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2) 189#define SCARLETT2_MIXER_VALUE_COUNT (SCARLETT2_MIXER_MAX_VALUE + 1) 190 191/* map from (dB + 80) * 2 to mixer value 192 * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20))) 193 */ 194static const u16 scarlett2_mixer_values[SCARLETT2_MIXER_VALUE_COUNT] = { 195 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 196 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8, 197 9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 198 23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51, 199 54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115, 200 122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230, 201 244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460, 202 487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919, 203 973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634, 204 1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906, 205 3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168, 206 5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191, 207 9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430, 208 16345 209}; 210 211/* Maximum number of analogue outputs */ 212#define SCARLETT2_ANALOGUE_MAX 10 213 214/* Maximum number of various input controls */ 215#define SCARLETT2_LEVEL_SWITCH_MAX 2 216#define SCARLETT2_PAD_SWITCH_MAX 8 217#define SCARLETT2_AIR_SWITCH_MAX 8 218#define SCARLETT2_PHANTOM_SWITCH_MAX 2 219#define SCARLETT2_INPUT_GAIN_MAX 2 220 221/* Maximum number of inputs to the mixer */ 222#define SCARLETT2_INPUT_MIX_MAX 25 223 224/* Maximum number of outputs from the mixer */ 225#define SCARLETT2_OUTPUT_MIX_MAX 12 226 227/* Maximum number of mixer gain controls */ 228#define SCARLETT2_MIX_MAX (SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX) 229 230/* Maximum number of direct monitor mixer gain controls 231 * 1 (Solo) or 2 (2i2) direct monitor selections (Mono & Stereo) 232 * 2 Mix outputs (A/Left & B/Right) 233 * 4 Mix inputs 234 */ 235#define SCARLETT2_MONITOR_MIX_MAX (2 * 2 * 4) 236 237/* Maximum size of the data in the USB mux assignment message: 238 * 20 inputs, 20 outputs, 25 matrix inputs, 12 spare 239 */ 240#define SCARLETT2_MUX_MAX 77 241 242/* Maximum number of sources (sum of input port counts) */ 243#define SCARLETT2_MAX_SRCS 52 244 245/* Maximum number of meters (sum of output port counts) */ 246#define SCARLETT2_MAX_METERS 65 247 248/* Hardware port types: 249 * - None (no input to mux) 250 * - Analogue I/O 251 * - S/PDIF I/O 252 * - ADAT I/O 253 * - Mixer I/O 254 * - PCM I/O 255 */ 256enum { 257 SCARLETT2_PORT_TYPE_NONE, 258 SCARLETT2_PORT_TYPE_ANALOGUE, 259 SCARLETT2_PORT_TYPE_SPDIF, 260 SCARLETT2_PORT_TYPE_ADAT, 261 SCARLETT2_PORT_TYPE_MIX, 262 SCARLETT2_PORT_TYPE_PCM, 263 SCARLETT2_PORT_TYPE_COUNT 264}; 265 266/* I/O count of each port type kept in struct scarlett2_ports */ 267enum { 268 SCARLETT2_PORT_IN, 269 SCARLETT2_PORT_OUT, 270 SCARLETT2_PORT_DIRNS 271}; 272 273/* Dim/Mute buttons on the 18i20 */ 274enum { 275 SCARLETT2_BUTTON_MUTE, 276 SCARLETT2_BUTTON_DIM, 277 SCARLETT2_DIM_MUTE_COUNT 278}; 279 280/* Flash Write State */ 281enum { 282 SCARLETT2_FLASH_WRITE_STATE_IDLE, 283 SCARLETT2_FLASH_WRITE_STATE_SELECTED, 284 SCARLETT2_FLASH_WRITE_STATE_ERASING, 285 SCARLETT2_FLASH_WRITE_STATE_WRITE 286}; 287 288static const char *const scarlett2_dim_mute_names[SCARLETT2_DIM_MUTE_COUNT] = { 289 "Mute Playback Switch", "Dim Playback Switch" 290}; 291 292/* The autogain_status is set based on the autogain_switch and 293 * raw_autogain_status values. 294 * 295 * If autogain_switch is set, autogain_status is set to 0 (Running). 296 * The other status values are from the raw_autogain_status value + 1. 297 */ 298static const char *const scarlett2_autogain_status_texts[] = { 299 "Running", 300 "Success", 301 "SuccessDRover", 302 "WarnMinGainLimit", 303 "FailDRunder", 304 "FailMaxGainLimit", 305 "FailClipped", 306 "Cancelled", 307 "Invalid" 308}; 309 310/* Power Status Values */ 311enum { 312 SCARLETT2_POWER_STATUS_EXT, 313 SCARLETT2_POWER_STATUS_BUS, 314 SCARLETT2_POWER_STATUS_FAIL, 315 SCARLETT2_POWER_STATUS_COUNT 316}; 317 318/* Notification callback functions */ 319struct scarlett2_notification { 320 u32 mask; 321 void (*func)(struct usb_mixer_interface *mixer); 322}; 323 324static void scarlett2_notify_sync(struct usb_mixer_interface *mixer); 325static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer); 326static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer); 327static void scarlett2_notify_volume(struct usb_mixer_interface *mixer); 328static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer); 329static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer); 330static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer); 331static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer); 332static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer); 333static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer); 334static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer); 335static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer); 336static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer); 337static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer); 338static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer); 339static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer); 340static void scarlett2_notify_pcm_input_switch( 341 struct usb_mixer_interface *mixer); 342 343/* Arrays of notification callback functions */ 344 345static const struct scarlett2_notification scarlett2_notifications[] = { 346 { 0x00000001, NULL }, /* ack, gets ignored */ 347 { 0x00000008, scarlett2_notify_sync }, 348 { 0x00200000, scarlett2_notify_dim_mute }, 349 { 0x00400000, scarlett2_notify_monitor }, 350 { 0x00800000, scarlett2_notify_input_other }, 351 { 0x01000000, scarlett2_notify_monitor_other }, 352 { 0, NULL } 353}; 354 355static const struct scarlett2_notification scarlett3a_notifications[] = { 356 { 0x00000001, NULL }, /* ack, gets ignored */ 357 { 0x00800000, scarlett2_notify_input_other }, 358 { 0x01000000, scarlett2_notify_direct_monitor }, 359 { 0, NULL } 360}; 361 362static const struct scarlett2_notification scarlett4_solo_notifications[] = { 363 { 0x00000001, NULL }, /* ack, gets ignored */ 364 { 0x00000008, scarlett2_notify_sync }, 365 { 0x00400000, scarlett2_notify_input_air }, 366 { 0x00800000, scarlett2_notify_direct_monitor }, 367 { 0x01000000, scarlett2_notify_input_level }, 368 { 0x02000000, scarlett2_notify_input_phantom }, 369 { 0x04000000, scarlett2_notify_pcm_input_switch }, 370 { 0, NULL } 371}; 372 373static const struct scarlett2_notification scarlett4_2i2_notifications[] = { 374 { 0x00000001, NULL }, /* ack, gets ignored */ 375 { 0x00000008, scarlett2_notify_sync }, 376 { 0x00200000, scarlett2_notify_input_safe }, 377 { 0x00400000, scarlett2_notify_autogain }, 378 { 0x00800000, scarlett2_notify_input_air }, 379 { 0x01000000, scarlett2_notify_direct_monitor }, 380 { 0x02000000, scarlett2_notify_input_select }, 381 { 0x04000000, scarlett2_notify_input_level }, 382 { 0x08000000, scarlett2_notify_input_phantom }, 383 { 0x10000000, NULL }, /* power status, ignored */ 384 { 0x40000000, scarlett2_notify_input_gain }, 385 { 0x80000000, NULL }, /* power status, ignored */ 386 { 0, NULL } 387}; 388 389static const struct scarlett2_notification scarlett4_4i4_notifications[] = { 390 { 0x00000001, NULL }, /* ack, gets ignored */ 391 { 0x00000008, scarlett2_notify_sync }, 392 { 0x00200000, scarlett2_notify_input_safe }, 393 { 0x00400000, scarlett2_notify_autogain }, 394 { 0x00800000, scarlett2_notify_input_air }, 395 { 0x01000000, scarlett2_notify_input_select }, 396 { 0x02000000, scarlett2_notify_input_level }, 397 { 0x04000000, scarlett2_notify_input_phantom }, 398 { 0x08000000, scarlett2_notify_power_status }, /* power external */ 399 { 0x20000000, scarlett2_notify_input_gain }, 400 { 0x40000000, scarlett2_notify_power_status }, /* power status */ 401 { 0x80000000, scarlett2_notify_volume }, 402 { 0, NULL } 403}; 404 405/* Configuration parameters that can be read and written */ 406enum { 407 SCARLETT2_CONFIG_DIM_MUTE, 408 SCARLETT2_CONFIG_LINE_OUT_VOLUME, 409 SCARLETT2_CONFIG_MUTE_SWITCH, 410 SCARLETT2_CONFIG_SW_HW_SWITCH, 411 SCARLETT2_CONFIG_MASTER_VOLUME, 412 SCARLETT2_CONFIG_HEADPHONE_VOLUME, 413 SCARLETT2_CONFIG_LEVEL_SWITCH, 414 SCARLETT2_CONFIG_PAD_SWITCH, 415 SCARLETT2_CONFIG_MSD_SWITCH, 416 SCARLETT2_CONFIG_AIR_SWITCH, 417 SCARLETT2_CONFIG_STANDALONE_SWITCH, 418 SCARLETT2_CONFIG_PHANTOM_SWITCH, 419 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, 420 SCARLETT2_CONFIG_DIRECT_MONITOR, 421 SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 422 SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 423 SCARLETT2_CONFIG_TALKBACK_MAP, 424 SCARLETT2_CONFIG_AUTOGAIN_SWITCH, 425 SCARLETT2_CONFIG_AUTOGAIN_STATUS, 426 SCARLETT2_CONFIG_INPUT_GAIN, 427 SCARLETT2_CONFIG_SAFE_SWITCH, 428 SCARLETT2_CONFIG_INPUT_SELECT_SWITCH, 429 SCARLETT2_CONFIG_INPUT_LINK_SWITCH, 430 SCARLETT2_CONFIG_POWER_EXT, 431 SCARLETT2_CONFIG_POWER_LOW, 432 SCARLETT2_CONFIG_PCM_INPUT_SWITCH, 433 SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN, 434 SCARLETT2_CONFIG_COUNT 435}; 436 437/* Location, size, and activation command number for the configuration 438 * parameters. Size is in bits and may be 0, 1, 8, or 16. 439 * 440 * A size of 0 indicates that the parameter is a byte-sized Scarlett 441 * Gen 4 configuration which is written through the gen4_write_addr 442 * location (but still read through the given offset location). 443 * 444 * Some Gen 4 configuration parameters are written with 0x02 for a 445 * desired value of 0x01, and 0x03 for 0x00. These are indicated with 446 * mute set to 1. 0x02 and 0x03 are temporary values while the device 447 * makes the change and the channel and/or corresponding DSP channel 448 * output is muted. 449 */ 450struct scarlett2_config { 451 u16 offset; 452 u8 size; 453 u8 activate; 454 u8 mute; 455}; 456 457struct scarlett2_config_set { 458 const struct scarlett2_notification *notifications; 459 u16 gen4_write_addr; 460 const struct scarlett2_config items[SCARLETT2_CONFIG_COUNT]; 461}; 462 463/* Gen 2 devices without SW/HW volume switch: 6i6, 18i8 */ 464 465static const struct scarlett2_config_set scarlett2_config_set_gen2a = { 466 .notifications = scarlett2_notifications, 467 .items = { 468 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 469 .offset = 0x34, .size = 16, .activate = 1 }, 470 471 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 472 .offset = 0x5c, .size = 8, .activate = 1 }, 473 474 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 475 .offset = 0x7c, .size = 8, .activate = 7 }, 476 477 [SCARLETT2_CONFIG_PAD_SWITCH] = { 478 .offset = 0x84, .size = 8, .activate = 8 }, 479 480 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 481 .offset = 0x8d, .size = 8, .activate = 6 }, 482 } 483}; 484 485/* Gen 2 devices with SW/HW volume switch: 18i20 */ 486 487static const struct scarlett2_config_set scarlett2_config_set_gen2b = { 488 .notifications = scarlett2_notifications, 489 .items = { 490 [SCARLETT2_CONFIG_DIM_MUTE] = { 491 .offset = 0x31, .size = 8, .activate = 2 }, 492 493 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 494 .offset = 0x34, .size = 16, .activate = 1 }, 495 496 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 497 .offset = 0x5c, .size = 8, .activate = 1 }, 498 499 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 500 .offset = 0x66, .size = 8, .activate = 3 }, 501 502 [SCARLETT2_CONFIG_MASTER_VOLUME] = { 503 .offset = 0x76, .size = 16 }, 504 505 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 506 .offset = 0x7c, .size = 8, .activate = 7 }, 507 508 [SCARLETT2_CONFIG_PAD_SWITCH] = { 509 .offset = 0x84, .size = 8, .activate = 8 }, 510 511 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 512 .offset = 0x8d, .size = 8, .activate = 6 }, 513 } 514}; 515 516/* Gen 3 devices without a mixer (Solo and 2i2) */ 517static const struct scarlett2_config_set scarlett2_config_set_gen3a = { 518 .notifications = scarlett3a_notifications, 519 .items = { 520 [SCARLETT2_CONFIG_MSD_SWITCH] = { 521 .offset = 0x04, .size = 8, .activate = 6 }, 522 523 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { 524 .offset = 0x05, .size = 8, .activate = 6 }, 525 526 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 527 .offset = 0x06, .size = 8, .activate = 3 }, 528 529 [SCARLETT2_CONFIG_DIRECT_MONITOR] = { 530 .offset = 0x07, .size = 8, .activate = 4 }, 531 532 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 533 .offset = 0x08, .size = 1, .activate = 7 }, 534 535 [SCARLETT2_CONFIG_AIR_SWITCH] = { 536 .offset = 0x09, .size = 1, .activate = 8 }, 537 } 538}; 539 540/* Gen 3 devices without SW/HW volume switch: 4i4, 8i6 */ 541static const struct scarlett2_config_set scarlett2_config_set_gen3b = { 542 .notifications = scarlett2_notifications, 543 .items = { 544 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 545 .offset = 0x34, .size = 16, .activate = 1 }, 546 547 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 548 .offset = 0x5c, .size = 8, .activate = 1 }, 549 550 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 551 .offset = 0x7c, .size = 8, .activate = 7 }, 552 553 [SCARLETT2_CONFIG_PAD_SWITCH] = { 554 .offset = 0x84, .size = 8, .activate = 8 }, 555 556 [SCARLETT2_CONFIG_AIR_SWITCH] = { 557 .offset = 0x8c, .size = 8, .activate = 8 }, 558 559 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 560 .offset = 0x95, .size = 8, .activate = 6 }, 561 562 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 563 .offset = 0x9c, .size = 1, .activate = 8 }, 564 565 [SCARLETT2_CONFIG_MSD_SWITCH] = { 566 .offset = 0x9d, .size = 8, .activate = 6 }, 567 568 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { 569 .offset = 0x9e, .size = 8, .activate = 6 }, 570 } 571}; 572 573/* Gen 3 devices with SW/HW volume switch: 18i8, 18i20 */ 574static const struct scarlett2_config_set scarlett2_config_set_gen3c = { 575 .notifications = scarlett2_notifications, 576 .items = { 577 [SCARLETT2_CONFIG_DIM_MUTE] = { 578 .offset = 0x31, .size = 8, .activate = 2 }, 579 580 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 581 .offset = 0x34, .size = 16, .activate = 1 }, 582 583 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 584 .offset = 0x5c, .size = 8, .activate = 1 }, 585 586 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 587 .offset = 0x66, .size = 8, .activate = 3 }, 588 589 [SCARLETT2_CONFIG_MASTER_VOLUME] = { 590 .offset = 0x76, .size = 16 }, 591 592 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 593 .offset = 0x7c, .size = 8, .activate = 7 }, 594 595 [SCARLETT2_CONFIG_PAD_SWITCH] = { 596 .offset = 0x84, .size = 8, .activate = 8 }, 597 598 [SCARLETT2_CONFIG_AIR_SWITCH] = { 599 .offset = 0x8c, .size = 8, .activate = 8 }, 600 601 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 602 .offset = 0x95, .size = 8, .activate = 6 }, 603 604 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 605 .offset = 0x9c, .size = 1, .activate = 8 }, 606 607 [SCARLETT2_CONFIG_MSD_SWITCH] = { 608 .offset = 0x9d, .size = 8, .activate = 6 }, 609 610 [SCARLETT2_CONFIG_PHANTOM_PERSISTENCE] = { 611 .offset = 0x9e, .size = 8, .activate = 6 }, 612 613 [SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH] = { 614 .offset = 0x9f, .size = 1, .activate = 10 }, 615 616 [SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE] = { 617 .offset = 0xa0, .size = 1, .activate = 10 }, 618 619 [SCARLETT2_CONFIG_TALKBACK_MAP] = { 620 .offset = 0xb0, .size = 16, .activate = 10 }, 621 } 622}; 623 624/* Solo Gen 4 */ 625static const struct scarlett2_config_set scarlett2_config_set_gen4_solo = { 626 .notifications = scarlett4_solo_notifications, 627 .gen4_write_addr = 0xd8, 628 .items = { 629 [SCARLETT2_CONFIG_MSD_SWITCH] = { 630 .offset = 0x47, .size = 8, .activate = 4 }, 631 632 [SCARLETT2_CONFIG_DIRECT_MONITOR] = { 633 .offset = 0x108, .activate = 12 }, 634 635 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 636 .offset = 0x46, .activate = 9, .mute = 1 }, 637 638 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 639 .offset = 0x3d, .activate = 10, .mute = 1 }, 640 641 [SCARLETT2_CONFIG_AIR_SWITCH] = { 642 .offset = 0x3e, .activate = 11 }, 643 644 [SCARLETT2_CONFIG_PCM_INPUT_SWITCH] = { 645 .offset = 0x206, .activate = 25 }, 646 647 [SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = { 648 .offset = 0x232, .size = 16, .activate = 26 } 649 } 650}; 651 652/* 2i2 Gen 4 */ 653static const struct scarlett2_config_set scarlett2_config_set_gen4_2i2 = { 654 .notifications = scarlett4_2i2_notifications, 655 .gen4_write_addr = 0xfc, 656 .items = { 657 [SCARLETT2_CONFIG_MSD_SWITCH] = { 658 .offset = 0x49, .size = 8, .activate = 4 }, // 0x41 ?? 659 660 [SCARLETT2_CONFIG_DIRECT_MONITOR] = { 661 .offset = 0x14a, .activate = 16 }, 662 663 [SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = { 664 .offset = 0x135, .activate = 10 }, 665 666 [SCARLETT2_CONFIG_AUTOGAIN_STATUS] = { 667 .offset = 0x137 }, 668 669 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 670 .offset = 0x48, .activate = 11, .mute = 1 }, 671 672 [SCARLETT2_CONFIG_INPUT_GAIN] = { 673 .offset = 0x4b, .activate = 12 }, 674 675 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 676 .offset = 0x3c, .activate = 13, .mute = 1 }, 677 678 [SCARLETT2_CONFIG_SAFE_SWITCH] = { 679 .offset = 0x147, .activate = 14 }, 680 681 [SCARLETT2_CONFIG_AIR_SWITCH] = { 682 .offset = 0x3e, .activate = 15 }, 683 684 [SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = { 685 .offset = 0x14b, .activate = 17 }, 686 687 [SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = { 688 .offset = 0x14e, .activate = 18 }, 689 690 [SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN] = { 691 .offset = 0x2a0, .size = 16, .activate = 36 } 692 } 693}; 694 695/* 4i4 Gen 4 */ 696static const struct scarlett2_config_set scarlett2_config_set_gen4_4i4 = { 697 .notifications = scarlett4_4i4_notifications, 698 .gen4_write_addr = 0x130, 699 .items = { 700 [SCARLETT2_CONFIG_MSD_SWITCH] = { 701 .offset = 0x5c, .size = 8, .activate = 4 }, 702 703 [SCARLETT2_CONFIG_AUTOGAIN_SWITCH] = { 704 .offset = 0x13e, .activate = 10 }, 705 706 [SCARLETT2_CONFIG_AUTOGAIN_STATUS] = { 707 .offset = 0x140 }, 708 709 [SCARLETT2_CONFIG_PHANTOM_SWITCH] = { 710 .offset = 0x5a, .activate = 11, .mute = 1 }, 711 712 [SCARLETT2_CONFIG_INPUT_GAIN] = { 713 .offset = 0x5e, .activate = 12 }, 714 715 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 716 .offset = 0x4e, .activate = 13, .mute = 1 }, 717 718 [SCARLETT2_CONFIG_SAFE_SWITCH] = { 719 .offset = 0x150, .activate = 14 }, 720 721 [SCARLETT2_CONFIG_AIR_SWITCH] = { 722 .offset = 0x50, .activate = 15 }, 723 724 [SCARLETT2_CONFIG_INPUT_SELECT_SWITCH] = { 725 .offset = 0x153, .activate = 16 }, 726 727 [SCARLETT2_CONFIG_INPUT_LINK_SWITCH] = { 728 .offset = 0x156, .activate = 17 }, 729 730 [SCARLETT2_CONFIG_MASTER_VOLUME] = { 731 .offset = 0x32, .size = 16 }, 732 733 [SCARLETT2_CONFIG_HEADPHONE_VOLUME] = { 734 .offset = 0x3a, .size = 16 }, 735 736 [SCARLETT2_CONFIG_POWER_EXT] = { 737 .offset = 0x168 }, 738 739 [SCARLETT2_CONFIG_POWER_LOW] = { 740 .offset = 0x16d } 741 } 742}; 743 744/* Clarett USB and Clarett+ devices: 2Pre, 4Pre, 8Pre */ 745static const struct scarlett2_config_set scarlett2_config_set_clarett = { 746 .notifications = scarlett2_notifications, 747 .items = { 748 [SCARLETT2_CONFIG_DIM_MUTE] = { 749 .offset = 0x31, .size = 8, .activate = 2 }, 750 751 [SCARLETT2_CONFIG_LINE_OUT_VOLUME] = { 752 .offset = 0x34, .size = 16, .activate = 1 }, 753 754 [SCARLETT2_CONFIG_MUTE_SWITCH] = { 755 .offset = 0x5c, .size = 8, .activate = 1 }, 756 757 [SCARLETT2_CONFIG_SW_HW_SWITCH] = { 758 .offset = 0x66, .size = 8, .activate = 3 }, 759 760 [SCARLETT2_CONFIG_MASTER_VOLUME] = { 761 .offset = 0x76, .size = 16 }, 762 763 [SCARLETT2_CONFIG_LEVEL_SWITCH] = { 764 .offset = 0x7c, .size = 8, .activate = 7 }, 765 766 [SCARLETT2_CONFIG_AIR_SWITCH] = { 767 .offset = 0x95, .size = 8, .activate = 8 }, 768 769 [SCARLETT2_CONFIG_STANDALONE_SWITCH] = { 770 .offset = 0x8d, .size = 8, .activate = 6 }, 771 } 772}; 773 774/* Description of each hardware port type: 775 * - id: hardware ID of this port type 776 * - src_descr: printf format string for mux input selections 777 * - src_num_offset: added to channel number for the fprintf 778 * - dst_descr: printf format string for mixer controls 779 */ 780struct scarlett2_port { 781 u16 id; 782 const char * const src_descr; 783 int src_num_offset; 784 const char * const dst_descr; 785 const char * const dsp_src_descr; 786 const char * const dsp_dst_descr; 787}; 788 789static const struct scarlett2_port scarlett2_ports[SCARLETT2_PORT_TYPE_COUNT] = { 790 [SCARLETT2_PORT_TYPE_NONE] = { 791 .id = 0x000, 792 .src_descr = "Off" 793 }, 794 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 795 .id = 0x080, 796 .src_descr = "Analogue %d", 797 .src_num_offset = 1, 798 .dst_descr = "Analogue Output %02d Playback" 799 }, 800 [SCARLETT2_PORT_TYPE_SPDIF] = { 801 .id = 0x180, 802 .src_descr = "S/PDIF %d", 803 .src_num_offset = 1, 804 .dst_descr = "S/PDIF Output %d Playback" 805 }, 806 [SCARLETT2_PORT_TYPE_ADAT] = { 807 .id = 0x200, 808 .src_descr = "ADAT %d", 809 .src_num_offset = 1, 810 .dst_descr = "ADAT Output %d Playback" 811 }, 812 [SCARLETT2_PORT_TYPE_MIX] = { 813 .id = 0x300, 814 .src_descr = "Mix %c", 815 .src_num_offset = 'A', 816 .dst_descr = "Mixer Input %02d Capture", 817 .dsp_src_descr = "DSP %d", 818 .dsp_dst_descr = "DSP Input %d Capture" 819 }, 820 [SCARLETT2_PORT_TYPE_PCM] = { 821 .id = 0x600, 822 .src_descr = "PCM %d", 823 .src_num_offset = 1, 824 .dst_descr = "PCM %02d Capture" 825 }, 826}; 827 828/* Number of mux tables: one for each band of sample rates 829 * (44.1/48kHz, 88.2/96kHz, and 176.4/176kHz) 830 */ 831#define SCARLETT2_MUX_TABLES 3 832 833/* Maximum number of entries in a mux table */ 834#define SCARLETT2_MAX_MUX_ENTRIES 10 835 836/* One entry within mux_assignment defines the port type and range of 837 * ports to add to the set_mux message. The end of the list is marked 838 * with count == 0. 839 */ 840struct scarlett2_mux_entry { 841 u8 port_type; 842 u8 start; 843 u8 count; 844}; 845 846/* Maximum number of entries in a mux table */ 847#define SCARLETT2_MAX_METER_ENTRIES 9 848 849/* One entry within meter_assignment defines the range of mux outputs 850 * that consecutive meter entries are mapped to. The end of the list 851 * is marked with count == 0. 852 */ 853struct scarlett2_meter_entry { 854 u8 start; 855 u8 count; 856}; 857 858struct scarlett2_device_info { 859 /* which set of configuration parameters the device uses */ 860 const struct scarlett2_config_set *config_set; 861 862 /* minimum firmware version required */ 863 u16 min_firmware_version; 864 865 /* support for main/alt speaker switching */ 866 u8 has_speaker_switching; 867 868 /* support for talkback microphone */ 869 u8 has_talkback; 870 871 /* the number of analogue inputs with a software switchable 872 * level control that can be set to line or instrument 873 */ 874 u8 level_input_count; 875 876 /* the first input with a level control (0-based) */ 877 u8 level_input_first; 878 879 /* the number of analogue inputs with a software switchable 880 * 10dB pad control 881 */ 882 u8 pad_input_count; 883 884 /* the number of analogue inputs with a software switchable 885 * "air" control 886 */ 887 u8 air_input_count; 888 889 /* the first input with an air control (0-based) */ 890 u8 air_input_first; 891 892 /* number of additional air options 893 * 0 for air presence only (Gen 3) 894 * 1 for air presence+drive (Gen 4) 895 */ 896 u8 air_option; 897 898 /* the number of phantom (48V) software switchable controls */ 899 u8 phantom_count; 900 901 /* the first input with phantom power control (0-based) */ 902 u8 phantom_first; 903 904 /* the number of inputs each phantom switch controls */ 905 u8 inputs_per_phantom; 906 907 /* the number of inputs with software-controllable gain */ 908 u8 gain_input_count; 909 910 /* the number of direct monitor options 911 * (0 = none, 1 = mono only, 2 = mono/stereo) 912 */ 913 u8 direct_monitor; 914 915 /* the number of DSP channels */ 916 u8 dsp_count; 917 918 /* remap analogue outputs; 18i8 Gen 3 has "line 3/4" connected 919 * internally to the analogue 7/8 outputs 920 */ 921 u8 line_out_remap_enable; 922 u8 line_out_remap[SCARLETT2_ANALOGUE_MAX]; 923 u8 line_out_unmap[SCARLETT2_ANALOGUE_MAX]; 924 925 /* additional description for the line out volume controls */ 926 const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX]; 927 928 /* number of sources/destinations of each port type */ 929 const int port_count[SCARLETT2_PORT_TYPE_COUNT][SCARLETT2_PORT_DIRNS]; 930 931 /* layout/order of the entries in the set_mux message */ 932 struct scarlett2_mux_entry mux_assignment[SCARLETT2_MUX_TABLES] 933 [SCARLETT2_MAX_MUX_ENTRIES]; 934 935 /* map from meter level order returned by 936 * SCARLETT2_USB_GET_METER to index into mux[] entries (same 937 * as the order returned by scarlett2_meter_ctl_get()) 938 */ 939 struct scarlett2_meter_entry meter_map[SCARLETT2_MAX_METER_ENTRIES]; 940}; 941 942struct scarlett2_data { 943 struct usb_mixer_interface *mixer; 944 struct mutex usb_mutex; /* prevent sending concurrent USB requests */ 945 struct mutex data_mutex; /* lock access to this data */ 946 u8 hwdep_in_use; 947 u8 selected_flash_segment_id; 948 u8 flash_write_state; 949 struct delayed_work work; 950 const struct scarlett2_device_info *info; 951 const struct scarlett2_config_set *config_set; 952 const char *series_name; 953 __u8 bInterfaceNumber; 954 __u8 bEndpointAddress; 955 __u16 wMaxPacketSize; 956 __u8 bInterval; 957 u8 num_mux_srcs; 958 u8 num_mux_dsts; 959 u8 num_mix_in; 960 u8 num_mix_out; 961 u8 num_line_out; 962 u8 num_monitor_mix_ctls; 963 u32 firmware_version; 964 u8 flash_segment_nums[SCARLETT2_SEGMENT_ID_COUNT]; 965 u8 flash_segment_blocks[SCARLETT2_SEGMENT_ID_COUNT]; 966 u16 scarlett2_seq; 967 u8 sync_updated; 968 u8 vol_updated; 969 u8 dim_mute_updated; 970 u8 input_level_updated; 971 u8 input_pad_updated; 972 u8 input_air_updated; 973 u8 input_phantom_updated; 974 u8 input_select_updated; 975 u8 input_gain_updated; 976 u8 autogain_updated; 977 u8 input_safe_updated; 978 u8 pcm_input_switch_updated; 979 u8 monitor_other_updated; 980 u8 direct_monitor_updated; 981 u8 mux_updated; 982 u8 mix_updated; 983 u8 speaker_switching_switched; 984 u8 power_status_updated; 985 u8 sync; 986 u8 master_vol; 987 u8 headphone_vol; 988 u8 vol[SCARLETT2_ANALOGUE_MAX]; 989 u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX]; 990 u8 mute_switch[SCARLETT2_ANALOGUE_MAX]; 991 u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX]; 992 u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX]; 993 u8 dim_mute[SCARLETT2_DIM_MUTE_COUNT]; 994 u8 air_switch[SCARLETT2_AIR_SWITCH_MAX]; 995 u8 phantom_switch[SCARLETT2_PHANTOM_SWITCH_MAX]; 996 u8 phantom_persistence; 997 u8 input_select_switch; 998 u8 input_link_switch[SCARLETT2_INPUT_GAIN_MAX / 2]; 999 u8 gain[SCARLETT2_INPUT_GAIN_MAX]; 1000 u8 autogain_switch[SCARLETT2_INPUT_GAIN_MAX]; 1001 u8 autogain_status[SCARLETT2_INPUT_GAIN_MAX]; 1002 u8 safe_switch[SCARLETT2_INPUT_GAIN_MAX]; 1003 u8 pcm_input_switch; 1004 u8 direct_monitor_switch; 1005 u8 speaker_switching_switch; 1006 u8 talkback_switch; 1007 u8 talkback_map[SCARLETT2_OUTPUT_MIX_MAX]; 1008 u8 msd_switch; 1009 u8 standalone_switch; 1010 u8 power_status; 1011 u8 meter_level_map[SCARLETT2_MAX_METERS]; 1012 struct snd_kcontrol *sync_ctl; 1013 struct snd_kcontrol *master_vol_ctl; 1014 struct snd_kcontrol *headphone_vol_ctl; 1015 struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX]; 1016 struct snd_kcontrol *sw_hw_ctls[SCARLETT2_ANALOGUE_MAX]; 1017 struct snd_kcontrol *mute_ctls[SCARLETT2_ANALOGUE_MAX]; 1018 struct snd_kcontrol *dim_mute_ctls[SCARLETT2_DIM_MUTE_COUNT]; 1019 struct snd_kcontrol *level_ctls[SCARLETT2_LEVEL_SWITCH_MAX]; 1020 struct snd_kcontrol *pad_ctls[SCARLETT2_PAD_SWITCH_MAX]; 1021 struct snd_kcontrol *air_ctls[SCARLETT2_AIR_SWITCH_MAX]; 1022 struct snd_kcontrol *phantom_ctls[SCARLETT2_PHANTOM_SWITCH_MAX]; 1023 struct snd_kcontrol *input_select_ctl; 1024 struct snd_kcontrol *input_link_ctls[SCARLETT2_INPUT_GAIN_MAX / 2]; 1025 struct snd_kcontrol *input_gain_ctls[SCARLETT2_INPUT_GAIN_MAX]; 1026 struct snd_kcontrol *autogain_ctls[SCARLETT2_INPUT_GAIN_MAX]; 1027 struct snd_kcontrol *autogain_status_ctls[SCARLETT2_INPUT_GAIN_MAX]; 1028 struct snd_kcontrol *safe_ctls[SCARLETT2_INPUT_GAIN_MAX]; 1029 struct snd_kcontrol *pcm_input_switch_ctl; 1030 struct snd_kcontrol *mux_ctls[SCARLETT2_MUX_MAX]; 1031 struct snd_kcontrol *mix_ctls[SCARLETT2_MIX_MAX]; 1032 struct snd_kcontrol *direct_monitor_ctl; 1033 struct snd_kcontrol *speaker_switching_ctl; 1034 struct snd_kcontrol *talkback_ctl; 1035 struct snd_kcontrol *power_status_ctl; 1036 u8 mux[SCARLETT2_MUX_MAX]; 1037 u8 mix[SCARLETT2_MIX_MAX]; 1038 u8 monitor_mix[SCARLETT2_MONITOR_MIX_MAX]; 1039}; 1040 1041/*** Model-specific data ***/ 1042 1043static const struct scarlett2_device_info s6i6_gen2_info = { 1044 .config_set = &scarlett2_config_set_gen2a, 1045 .level_input_count = 2, 1046 .pad_input_count = 2, 1047 1048 .line_out_descrs = { 1049 "Headphones 1 L", 1050 "Headphones 1 R", 1051 "Headphones 2 L", 1052 "Headphones 2 R", 1053 }, 1054 1055 .port_count = { 1056 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1057 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, 1058 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1059 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1060 [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 }, 1061 }, 1062 1063 .mux_assignment = { { 1064 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1065 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1066 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1067 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1068 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1069 { 0, 0, 0 }, 1070 }, { 1071 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1072 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1073 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1074 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1075 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1076 { 0, 0, 0 }, 1077 }, { 1078 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1079 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1080 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1081 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1082 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1083 { 0, 0, 0 }, 1084 } }, 1085 1086 .meter_map = { 1087 { 24, 6 }, 1088 { 0, 24 }, 1089 { 0, 0 }, 1090 } 1091}; 1092 1093static const struct scarlett2_device_info s18i8_gen2_info = { 1094 .config_set = &scarlett2_config_set_gen2a, 1095 .level_input_count = 2, 1096 .pad_input_count = 4, 1097 1098 .line_out_descrs = { 1099 "Monitor L", 1100 "Monitor R", 1101 "Headphones 1 L", 1102 "Headphones 1 R", 1103 "Headphones 2 L", 1104 "Headphones 2 R", 1105 }, 1106 1107 .port_count = { 1108 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1109 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 }, 1110 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1111 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 1112 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1113 [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 }, 1114 }, 1115 1116 .mux_assignment = { { 1117 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 1118 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1119 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1120 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1121 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1122 { 0, 0, 0 }, 1123 }, { 1124 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 1125 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1126 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1127 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1128 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1129 { 0, 0, 0 }, 1130 }, { 1131 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1132 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1133 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1134 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1135 { SCARLETT2_PORT_TYPE_NONE, 0, 4 }, 1136 { 0, 0, 0 }, 1137 } }, 1138 1139 .meter_map = { 1140 { 26, 18 }, 1141 { 0, 26 }, 1142 { 0, 0 }, 1143 } 1144}; 1145 1146static const struct scarlett2_device_info s18i20_gen2_info = { 1147 .config_set = &scarlett2_config_set_gen2b, 1148 1149 .line_out_descrs = { 1150 "Monitor L", 1151 "Monitor R", 1152 NULL, 1153 NULL, 1154 NULL, 1155 NULL, 1156 "Headphones 1 L", 1157 "Headphones 1 R", 1158 "Headphones 2 L", 1159 "Headphones 2 R", 1160 }, 1161 1162 .port_count = { 1163 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1164 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, 1165 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1166 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 1167 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1168 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, 1169 }, 1170 1171 .mux_assignment = { { 1172 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 1173 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1174 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1175 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 1176 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1177 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1178 { 0, 0, 0 }, 1179 }, { 1180 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 1181 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1182 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1183 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, 1184 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1185 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1186 { 0, 0, 0 }, 1187 }, { 1188 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1189 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1190 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1191 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1192 { SCARLETT2_PORT_TYPE_NONE, 0, 6 }, 1193 { 0, 0, 0 }, 1194 } }, 1195 1196 .meter_map = { 1197 { 38, 18 }, 1198 { 0, 38 }, 1199 { 0, 0 }, 1200 } 1201}; 1202 1203static const struct scarlett2_device_info solo_gen3_info = { 1204 .config_set = &scarlett2_config_set_gen3a, 1205 .level_input_count = 1, 1206 .level_input_first = 1, 1207 .air_input_count = 1, 1208 .phantom_count = 1, 1209 .inputs_per_phantom = 1, 1210 .direct_monitor = 1, 1211}; 1212 1213static const struct scarlett2_device_info s2i2_gen3_info = { 1214 .config_set = &scarlett2_config_set_gen3a, 1215 .level_input_count = 2, 1216 .air_input_count = 2, 1217 .phantom_count = 1, 1218 .inputs_per_phantom = 2, 1219 .direct_monitor = 2, 1220}; 1221 1222static const struct scarlett2_device_info s4i4_gen3_info = { 1223 .config_set = &scarlett2_config_set_gen3b, 1224 .level_input_count = 2, 1225 .pad_input_count = 2, 1226 .air_input_count = 2, 1227 .phantom_count = 1, 1228 .inputs_per_phantom = 2, 1229 1230 .line_out_descrs = { 1231 "Monitor L", 1232 "Monitor R", 1233 "Headphones L", 1234 "Headphones R", 1235 }, 1236 1237 .port_count = { 1238 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1239 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 4 }, 1240 [SCARLETT2_PORT_TYPE_MIX] = { 6, 8 }, 1241 [SCARLETT2_PORT_TYPE_PCM] = { 4, 6 }, 1242 }, 1243 1244 .mux_assignment = { { 1245 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1246 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1247 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1248 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 1249 { 0, 0, 0 }, 1250 }, { 1251 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1252 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1253 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1254 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 1255 { 0, 0, 0 }, 1256 }, { 1257 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1258 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1259 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1260 { SCARLETT2_PORT_TYPE_NONE, 0, 16 }, 1261 { 0, 0, 0 }, 1262 } }, 1263 1264 .meter_map = { 1265 { 12, 6 }, 1266 { 0, 12 }, 1267 { 0, 0 }, 1268 } 1269}; 1270 1271static const struct scarlett2_device_info s8i6_gen3_info = { 1272 .config_set = &scarlett2_config_set_gen3b, 1273 .level_input_count = 2, 1274 .pad_input_count = 2, 1275 .air_input_count = 2, 1276 .phantom_count = 1, 1277 .inputs_per_phantom = 2, 1278 1279 .line_out_descrs = { 1280 "Headphones 1 L", 1281 "Headphones 1 R", 1282 "Headphones 2 L", 1283 "Headphones 2 R", 1284 }, 1285 1286 .port_count = { 1287 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1288 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 6, 4 }, 1289 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1290 [SCARLETT2_PORT_TYPE_MIX] = { 8, 8 }, 1291 [SCARLETT2_PORT_TYPE_PCM] = { 6, 10 }, 1292 }, 1293 1294 .mux_assignment = { { 1295 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1296 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1297 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1298 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 1299 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1300 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 1301 { 0, 0, 0 }, 1302 }, { 1303 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1304 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1305 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1306 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 1307 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1308 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 1309 { 0, 0, 0 }, 1310 }, { 1311 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1312 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1313 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1314 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 1315 { SCARLETT2_PORT_TYPE_MIX, 0, 8 }, 1316 { SCARLETT2_PORT_TYPE_NONE, 0, 18 }, 1317 { 0, 0, 0 }, 1318 } }, 1319 1320 .meter_map = { 1321 { 14, 8 }, 1322 { 0, 6 }, 1323 { 22, 2 }, 1324 { 6, 8 }, 1325 { 0, 0 }, 1326 } 1327}; 1328 1329static const struct scarlett2_device_info s18i8_gen3_info = { 1330 .config_set = &scarlett2_config_set_gen3c, 1331 .has_speaker_switching = 1, 1332 .level_input_count = 2, 1333 .pad_input_count = 4, 1334 .air_input_count = 4, 1335 .phantom_count = 2, 1336 .inputs_per_phantom = 2, 1337 1338 .line_out_remap_enable = 1, 1339 .line_out_remap = { 0, 1, 6, 7, 2, 3, 4, 5 }, 1340 .line_out_unmap = { 0, 1, 4, 5, 6, 7, 2, 3 }, 1341 1342 .line_out_descrs = { 1343 "Monitor L", 1344 "Monitor R", 1345 "Alt Monitor L", 1346 "Alt Monitor R", 1347 "Headphones 1 L", 1348 "Headphones 1 R", 1349 "Headphones 2 L", 1350 "Headphones 2 R", 1351 }, 1352 1353 .port_count = { 1354 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1355 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 8 }, 1356 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1357 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 1358 [SCARLETT2_PORT_TYPE_MIX] = { 10, 20 }, 1359 [SCARLETT2_PORT_TYPE_PCM] = { 8, 20 }, 1360 }, 1361 1362 .mux_assignment = { { 1363 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1364 { SCARLETT2_PORT_TYPE_PCM, 12, 8 }, 1365 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1366 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 1367 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 1368 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1369 { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, 1370 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 1371 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 1372 { 0, 0, 0 }, 1373 }, { 1374 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1375 { SCARLETT2_PORT_TYPE_PCM, 12, 4 }, 1376 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1377 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 1378 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 1379 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1380 { SCARLETT2_PORT_TYPE_PCM, 10, 2 }, 1381 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 1382 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 1383 { 0, 0, 0 }, 1384 }, { 1385 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1386 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1387 { SCARLETT2_PORT_TYPE_ANALOGUE, 6, 2 }, 1388 { SCARLETT2_PORT_TYPE_ANALOGUE, 2, 4 }, 1389 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1390 { SCARLETT2_PORT_TYPE_MIX, 0, 20 }, 1391 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 1392 { 0, 0, 0 }, 1393 } }, 1394 1395 .meter_map = { 1396 { 30, 10 }, 1397 { 42, 8 }, 1398 { 0, 2 }, 1399 { 6, 2 }, 1400 { 2, 4 }, 1401 { 8, 2 }, 1402 { 40, 2 }, 1403 { 10, 20 }, 1404 { 0, 0 } 1405 } 1406}; 1407 1408static const struct scarlett2_device_info s18i20_gen3_info = { 1409 .config_set = &scarlett2_config_set_gen3c, 1410 .has_speaker_switching = 1, 1411 .has_talkback = 1, 1412 .level_input_count = 2, 1413 .pad_input_count = 8, 1414 .air_input_count = 8, 1415 .phantom_count = 2, 1416 .inputs_per_phantom = 4, 1417 1418 .line_out_descrs = { 1419 "Monitor 1 L", 1420 "Monitor 1 R", 1421 "Monitor 2 L", 1422 "Monitor 2 R", 1423 NULL, 1424 NULL, 1425 "Headphones 1 L", 1426 "Headphones 1 R", 1427 "Headphones 2 L", 1428 "Headphones 2 R", 1429 }, 1430 1431 .port_count = { 1432 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1433 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 9, 10 }, 1434 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1435 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 1436 [SCARLETT2_PORT_TYPE_MIX] = { 12, 25 }, 1437 [SCARLETT2_PORT_TYPE_PCM] = { 20, 20 }, 1438 }, 1439 1440 .mux_assignment = { { 1441 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1442 { SCARLETT2_PORT_TYPE_PCM, 10, 10 }, 1443 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1444 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1445 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 1446 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 1447 { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, 1448 { SCARLETT2_PORT_TYPE_NONE, 0, 12 }, 1449 { 0, 0, 0 }, 1450 }, { 1451 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1452 { SCARLETT2_PORT_TYPE_PCM, 10, 8 }, 1453 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1454 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1455 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 1456 { SCARLETT2_PORT_TYPE_PCM, 8, 2 }, 1457 { SCARLETT2_PORT_TYPE_MIX, 0, 25 }, 1458 { SCARLETT2_PORT_TYPE_NONE, 0, 10 }, 1459 { 0, 0, 0 }, 1460 }, { 1461 { SCARLETT2_PORT_TYPE_PCM, 0, 10 }, 1462 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1463 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1464 { SCARLETT2_PORT_TYPE_NONE, 0, 24 }, 1465 { 0, 0, 0 }, 1466 } }, 1467 1468 .meter_map = { 1469 { 45, 8 }, 1470 { 55, 10 }, 1471 { 0, 20 }, 1472 { 53, 2 }, 1473 { 20, 25 }, 1474 { 0, 0 }, 1475 } 1476}; 1477 1478static const struct scarlett2_device_info solo_gen4_info = { 1479 .config_set = &scarlett2_config_set_gen4_solo, 1480 .min_firmware_version = 2115, 1481 1482 .level_input_count = 1, 1483 .air_input_count = 1, 1484 .air_input_first = 1, 1485 .air_option = 1, 1486 .phantom_count = 1, 1487 .phantom_first = 1, 1488 .inputs_per_phantom = 1, 1489 .direct_monitor = 1, 1490 .dsp_count = 2, 1491 1492 .port_count = { 1493 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1494 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 }, 1495 [SCARLETT2_PORT_TYPE_MIX] = { 8, 6 }, 1496 [SCARLETT2_PORT_TYPE_PCM] = { 2, 4 }, 1497 }, 1498 1499 .mux_assignment = { { 1500 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1501 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1502 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1503 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1504 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1505 { 0, 0, 0 }, 1506 }, { 1507 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1508 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1509 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1510 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1511 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1512 { 0, 0, 0 }, 1513 }, { 1514 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1515 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1516 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1517 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1518 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1519 { 0, 0, 0 }, 1520 } }, 1521 1522 .meter_map = { 1523 { 6, 2 }, 1524 { 4, 2 }, 1525 { 8, 4 }, 1526 { 2, 2 }, 1527 { 0, 2 }, 1528 { 0, 0 } 1529 } 1530}; 1531 1532static const struct scarlett2_device_info s2i2_gen4_info = { 1533 .config_set = &scarlett2_config_set_gen4_2i2, 1534 .min_firmware_version = 2115, 1535 1536 .level_input_count = 2, 1537 .air_input_count = 2, 1538 .air_option = 1, 1539 .phantom_count = 1, 1540 .inputs_per_phantom = 2, 1541 .gain_input_count = 2, 1542 .direct_monitor = 2, 1543 .dsp_count = 2, 1544 1545 .port_count = { 1546 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1547 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 2 }, 1548 [SCARLETT2_PORT_TYPE_MIX] = { 6, 6 }, 1549 [SCARLETT2_PORT_TYPE_PCM] = { 2, 4 }, 1550 }, 1551 1552 .mux_assignment = { { 1553 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1554 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1555 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1556 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1557 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1558 { 0, 0, 0 }, 1559 }, { 1560 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1561 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1562 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1563 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1564 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1565 { 0, 0, 0 }, 1566 }, { 1567 { SCARLETT2_PORT_TYPE_MIX, 4, 2 }, 1568 { SCARLETT2_PORT_TYPE_MIX, 2, 2 }, 1569 { SCARLETT2_PORT_TYPE_PCM, 0, 4 }, 1570 { SCARLETT2_PORT_TYPE_MIX, 0, 2 }, 1571 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 2 }, 1572 { 0, 0, 0 }, 1573 } }, 1574 1575 .meter_map = { 1576 { 6, 2 }, 1577 { 4, 2 }, 1578 { 8, 4 }, 1579 { 2, 2 }, 1580 { 0, 2 }, 1581 { 0, 0 } 1582 } 1583}; 1584 1585static const struct scarlett2_device_info s4i4_gen4_info = { 1586 .config_set = &scarlett2_config_set_gen4_4i4, 1587 .min_firmware_version = 2089, 1588 1589 .level_input_count = 2, 1590 .air_input_count = 2, 1591 .air_option = 1, 1592 .phantom_count = 2, 1593 .inputs_per_phantom = 1, 1594 .gain_input_count = 2, 1595 .dsp_count = 2, 1596 1597 .port_count = { 1598 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1599 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 4, 6 }, 1600 [SCARLETT2_PORT_TYPE_MIX] = { 8, 12 }, 1601 [SCARLETT2_PORT_TYPE_PCM] = { 6, 6 }, 1602 }, 1603 1604 .mux_assignment = { { 1605 { SCARLETT2_PORT_TYPE_MIX, 10, 2 }, 1606 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1607 { SCARLETT2_PORT_TYPE_MIX, 0, 10 }, 1608 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1609 { 0, 0, 0 }, 1610 }, { 1611 { SCARLETT2_PORT_TYPE_MIX, 10, 2 }, 1612 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1613 { SCARLETT2_PORT_TYPE_MIX, 0, 10 }, 1614 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1615 { 0, 0, 0 }, 1616 }, { 1617 { SCARLETT2_PORT_TYPE_MIX, 10, 2 }, 1618 { SCARLETT2_PORT_TYPE_PCM, 0, 6 }, 1619 { SCARLETT2_PORT_TYPE_MIX, 0, 10 }, 1620 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1621 { 0, 0, 0 }, 1622 } }, 1623 1624 .meter_map = { 1625 { 16, 8 }, 1626 { 6, 10 }, 1627 { 0, 6 }, 1628 { 0, 0 } 1629 } 1630}; 1631 1632static const struct scarlett2_device_info clarett_2pre_info = { 1633 .config_set = &scarlett2_config_set_clarett, 1634 .level_input_count = 2, 1635 .air_input_count = 2, 1636 1637 .line_out_descrs = { 1638 "Monitor L", 1639 "Monitor R", 1640 "Headphones L", 1641 "Headphones R", 1642 }, 1643 1644 .port_count = { 1645 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1646 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 2, 4 }, 1647 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 0 }, 1648 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 1649 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1650 [SCARLETT2_PORT_TYPE_PCM] = { 4, 12 }, 1651 }, 1652 1653 .mux_assignment = { { 1654 { SCARLETT2_PORT_TYPE_PCM, 0, 12 }, 1655 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1656 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1657 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1658 { 0, 0, 0 }, 1659 }, { 1660 { SCARLETT2_PORT_TYPE_PCM, 0, 8 }, 1661 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1662 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1663 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1664 { 0, 0, 0 }, 1665 }, { 1666 { SCARLETT2_PORT_TYPE_PCM, 0, 2 }, 1667 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 4 }, 1668 { SCARLETT2_PORT_TYPE_NONE, 0, 26 }, 1669 { 0, 0, 0 }, 1670 } }, 1671 1672 .meter_map = { 1673 { 22, 12 }, 1674 { 0, 22 }, 1675 { 0, 0 } 1676 } 1677}; 1678 1679static const struct scarlett2_device_info clarett_4pre_info = { 1680 .config_set = &scarlett2_config_set_clarett, 1681 .level_input_count = 2, 1682 .air_input_count = 4, 1683 1684 .line_out_descrs = { 1685 "Monitor L", 1686 "Monitor R", 1687 "Headphones 1 L", 1688 "Headphones 1 R", 1689 "Headphones 2 L", 1690 "Headphones 2 R", 1691 }, 1692 1693 .port_count = { 1694 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1695 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 6 }, 1696 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1697 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 0 }, 1698 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1699 [SCARLETT2_PORT_TYPE_PCM] = { 8, 18 }, 1700 }, 1701 1702 .mux_assignment = { { 1703 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 1704 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1705 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1706 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1707 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1708 { 0, 0, 0 }, 1709 }, { 1710 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 1711 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1712 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1713 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1714 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1715 { 0, 0, 0 }, 1716 }, { 1717 { SCARLETT2_PORT_TYPE_PCM, 0, 12 }, 1718 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 6 }, 1719 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1720 { SCARLETT2_PORT_TYPE_NONE, 0, 24 }, 1721 { 0, 0, 0 }, 1722 } }, 1723 1724 .meter_map = { 1725 { 26, 18 }, 1726 { 0, 26 }, 1727 { 0, 0 } 1728 } 1729}; 1730 1731static const struct scarlett2_device_info clarett_8pre_info = { 1732 .config_set = &scarlett2_config_set_clarett, 1733 .level_input_count = 2, 1734 .air_input_count = 8, 1735 1736 .line_out_descrs = { 1737 "Monitor L", 1738 "Monitor R", 1739 NULL, 1740 NULL, 1741 NULL, 1742 NULL, 1743 "Headphones 1 L", 1744 "Headphones 1 R", 1745 "Headphones 2 L", 1746 "Headphones 2 R", 1747 }, 1748 1749 .port_count = { 1750 [SCARLETT2_PORT_TYPE_NONE] = { 1, 0 }, 1751 [SCARLETT2_PORT_TYPE_ANALOGUE] = { 8, 10 }, 1752 [SCARLETT2_PORT_TYPE_SPDIF] = { 2, 2 }, 1753 [SCARLETT2_PORT_TYPE_ADAT] = { 8, 8 }, 1754 [SCARLETT2_PORT_TYPE_MIX] = { 10, 18 }, 1755 [SCARLETT2_PORT_TYPE_PCM] = { 20, 18 }, 1756 }, 1757 1758 .mux_assignment = { { 1759 { SCARLETT2_PORT_TYPE_PCM, 0, 18 }, 1760 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1761 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1762 { SCARLETT2_PORT_TYPE_ADAT, 0, 8 }, 1763 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1764 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1765 { 0, 0, 0 }, 1766 }, { 1767 { SCARLETT2_PORT_TYPE_PCM, 0, 14 }, 1768 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1769 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1770 { SCARLETT2_PORT_TYPE_ADAT, 0, 4 }, 1771 { SCARLETT2_PORT_TYPE_MIX, 0, 18 }, 1772 { SCARLETT2_PORT_TYPE_NONE, 0, 8 }, 1773 { 0, 0, 0 }, 1774 }, { 1775 { SCARLETT2_PORT_TYPE_PCM, 0, 12 }, 1776 { SCARLETT2_PORT_TYPE_ANALOGUE, 0, 10 }, 1777 { SCARLETT2_PORT_TYPE_SPDIF, 0, 2 }, 1778 { SCARLETT2_PORT_TYPE_NONE, 0, 22 }, 1779 { 0, 0, 0 }, 1780 } }, 1781 1782 .meter_map = { 1783 { 38, 18 }, 1784 { 0, 38 }, 1785 { 0, 0 } 1786 } 1787}; 1788 1789struct scarlett2_device_entry { 1790 const u32 usb_id; /* USB device identifier */ 1791 const struct scarlett2_device_info *info; 1792 const char *series_name; 1793}; 1794 1795static const struct scarlett2_device_entry scarlett2_devices[] = { 1796 /* Supported Gen 2 devices */ 1797 { USB_ID(0x1235, 0x8203), &s6i6_gen2_info, "Scarlett Gen 2" }, 1798 { USB_ID(0x1235, 0x8204), &s18i8_gen2_info, "Scarlett Gen 2" }, 1799 { USB_ID(0x1235, 0x8201), &s18i20_gen2_info, "Scarlett Gen 2" }, 1800 1801 /* Supported Gen 3 devices */ 1802 { USB_ID(0x1235, 0x8211), &solo_gen3_info, "Scarlett Gen 3" }, 1803 { USB_ID(0x1235, 0x8210), &s2i2_gen3_info, "Scarlett Gen 3" }, 1804 { USB_ID(0x1235, 0x8212), &s4i4_gen3_info, "Scarlett Gen 3" }, 1805 { USB_ID(0x1235, 0x8213), &s8i6_gen3_info, "Scarlett Gen 3" }, 1806 { USB_ID(0x1235, 0x8214), &s18i8_gen3_info, "Scarlett Gen 3" }, 1807 { USB_ID(0x1235, 0x8215), &s18i20_gen3_info, "Scarlett Gen 3" }, 1808 1809 /* Supported Gen 4 devices */ 1810 { USB_ID(0x1235, 0x8218), &solo_gen4_info, "Scarlett Gen 4" }, 1811 { USB_ID(0x1235, 0x8219), &s2i2_gen4_info, "Scarlett Gen 4" }, 1812 { USB_ID(0x1235, 0x821a), &s4i4_gen4_info, "Scarlett Gen 4" }, 1813 1814 /* Supported Clarett USB/Clarett+ devices */ 1815 { USB_ID(0x1235, 0x8206), &clarett_2pre_info, "Clarett USB" }, 1816 { USB_ID(0x1235, 0x8207), &clarett_4pre_info, "Clarett USB" }, 1817 { USB_ID(0x1235, 0x8208), &clarett_8pre_info, "Clarett USB" }, 1818 { USB_ID(0x1235, 0x820a), &clarett_2pre_info, "Clarett+" }, 1819 { USB_ID(0x1235, 0x820b), &clarett_4pre_info, "Clarett+" }, 1820 { USB_ID(0x1235, 0x820c), &clarett_8pre_info, "Clarett+" }, 1821 1822 /* End of list */ 1823 { 0, NULL }, 1824}; 1825 1826/* get the starting port index number for a given port type/direction */ 1827static int scarlett2_get_port_start_num( 1828 const int port_count[][SCARLETT2_PORT_DIRNS], 1829 int direction, int port_type) 1830{ 1831 int i, num = 0; 1832 1833 for (i = 0; i < port_type; i++) 1834 num += port_count[i][direction]; 1835 1836 return num; 1837} 1838 1839/*** USB Interactions ***/ 1840 1841/* Commands for sending/receiving requests/responses */ 1842#define SCARLETT2_USB_CMD_INIT 0 1843#define SCARLETT2_USB_CMD_REQ 2 1844#define SCARLETT2_USB_CMD_RESP 3 1845 1846#define SCARLETT2_USB_INIT_1 0x00000000 1847#define SCARLETT2_USB_INIT_2 0x00000002 1848#define SCARLETT2_USB_REBOOT 0x00000003 1849#define SCARLETT2_USB_GET_METER 0x00001001 1850#define SCARLETT2_USB_GET_MIX 0x00002001 1851#define SCARLETT2_USB_SET_MIX 0x00002002 1852#define SCARLETT2_USB_GET_MUX 0x00003001 1853#define SCARLETT2_USB_SET_MUX 0x00003002 1854#define SCARLETT2_USB_INFO_FLASH 0x00004000 1855#define SCARLETT2_USB_INFO_SEGMENT 0x00004001 1856#define SCARLETT2_USB_ERASE_SEGMENT 0x00004002 1857#define SCARLETT2_USB_GET_ERASE 0x00004003 1858#define SCARLETT2_USB_WRITE_SEGMENT 0x00004004 1859#define SCARLETT2_USB_GET_SYNC 0x00006004 1860#define SCARLETT2_USB_GET_DATA 0x00800000 1861#define SCARLETT2_USB_SET_DATA 0x00800001 1862#define SCARLETT2_USB_DATA_CMD 0x00800002 1863 1864#define SCARLETT2_USB_CONFIG_SAVE 6 1865 1866#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1 1867 1868#define SCARLETT2_FLASH_BLOCK_SIZE 4096 1869#define SCARLETT2_FLASH_WRITE_MAX 1024 1870#define SCARLETT2_SEGMENT_NUM_MIN 1 1871#define SCARLETT2_SEGMENT_NUM_MAX 4 1872 1873#define SCARLETT2_SEGMENT_SETTINGS_NAME "App_Settings" 1874#define SCARLETT2_SEGMENT_FIRMWARE_NAME "App_Upgrade" 1875 1876/* proprietary request/response format */ 1877struct scarlett2_usb_packet { 1878 __le32 cmd; 1879 __le16 size; 1880 __le16 seq; 1881 __le32 error; 1882 __le32 pad; 1883 u8 data[]; 1884}; 1885 1886static void scarlett2_fill_request_header(struct scarlett2_data *private, 1887 struct scarlett2_usb_packet *req, 1888 u32 cmd, u16 req_size) 1889{ 1890 /* sequence must go up by 1 for each request */ 1891 u16 seq = private->scarlett2_seq++; 1892 1893 req->cmd = cpu_to_le32(cmd); 1894 req->size = cpu_to_le16(req_size); 1895 req->seq = cpu_to_le16(seq); 1896 req->error = 0; 1897 req->pad = 0; 1898} 1899 1900static int scarlett2_usb_tx(struct usb_device *dev, int interface, 1901 void *buf, u16 size) 1902{ 1903 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 1904 SCARLETT2_USB_CMD_REQ, 1905 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, 1906 0, interface, buf, size); 1907} 1908 1909static int scarlett2_usb_rx(struct usb_device *dev, int interface, 1910 u32 usb_req, void *buf, u16 size) 1911{ 1912 return snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 1913 usb_req, 1914 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 1915 0, interface, buf, size); 1916} 1917 1918/* Send a proprietary format request to the Scarlett interface */ 1919static int scarlett2_usb( 1920 struct usb_mixer_interface *mixer, u32 cmd, 1921 void *req_data, u16 req_size, void *resp_data, u16 resp_size) 1922{ 1923 struct scarlett2_data *private = mixer->private_data; 1924 struct usb_device *dev = mixer->chip->dev; 1925 struct scarlett2_usb_packet *req, *resp = NULL; 1926 size_t req_buf_size = struct_size(req, data, req_size); 1927 size_t resp_buf_size = struct_size(resp, data, resp_size); 1928 int err; 1929 1930 req = kmalloc(req_buf_size, GFP_KERNEL); 1931 if (!req) { 1932 err = -ENOMEM; 1933 goto error; 1934 } 1935 1936 resp = kmalloc(resp_buf_size, GFP_KERNEL); 1937 if (!resp) { 1938 err = -ENOMEM; 1939 goto error; 1940 } 1941 1942 mutex_lock(&private->usb_mutex); 1943 1944 /* build request message and send it */ 1945 1946 scarlett2_fill_request_header(private, req, cmd, req_size); 1947 1948 if (req_size) 1949 memcpy(req->data, req_data, req_size); 1950 1951 err = scarlett2_usb_tx(dev, private->bInterfaceNumber, 1952 req, req_buf_size); 1953 1954 if (err != req_buf_size) { 1955 usb_audio_err( 1956 mixer->chip, 1957 "%s USB request result cmd %x was %d\n", 1958 private->series_name, cmd, err); 1959 err = -EINVAL; 1960 goto unlock; 1961 } 1962 1963 /* send a second message to get the response */ 1964 1965 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, 1966 SCARLETT2_USB_CMD_RESP, 1967 resp, resp_buf_size); 1968 1969 /* validate the response */ 1970 1971 if (err != resp_buf_size) { 1972 1973 /* ESHUTDOWN and EPROTO are valid responses to a 1974 * reboot request 1975 */ 1976 if (cmd == SCARLETT2_USB_REBOOT && 1977 (err == -ESHUTDOWN || err == -EPROTO)) { 1978 err = 0; 1979 goto unlock; 1980 } 1981 1982 usb_audio_err( 1983 mixer->chip, 1984 "%s USB response result cmd %x was %d expected %zu\n", 1985 private->series_name, cmd, err, resp_buf_size); 1986 err = -EINVAL; 1987 goto unlock; 1988 } 1989 1990 /* cmd/seq/size should match except when initialising 1991 * seq sent = 1, response = 0 1992 */ 1993 if (resp->cmd != req->cmd || 1994 (resp->seq != req->seq && 1995 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) || 1996 resp_size != le16_to_cpu(resp->size) || 1997 resp->error || 1998 resp->pad) { 1999 usb_audio_err( 2000 mixer->chip, 2001 "%s USB invalid response; " 2002 "cmd tx/rx %d/%d seq %d/%d size %d/%d " 2003 "error %d pad %d\n", 2004 private->series_name, 2005 le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd), 2006 le16_to_cpu(req->seq), le16_to_cpu(resp->seq), 2007 resp_size, le16_to_cpu(resp->size), 2008 le32_to_cpu(resp->error), 2009 le32_to_cpu(resp->pad)); 2010 err = -EINVAL; 2011 goto unlock; 2012 } 2013 2014 if (resp_data && resp_size > 0) 2015 memcpy(resp_data, resp->data, resp_size); 2016 2017unlock: 2018 mutex_unlock(&private->usb_mutex); 2019error: 2020 kfree(req); 2021 kfree(resp); 2022 return err; 2023} 2024 2025/* Send a USB message to get data; result placed in *buf */ 2026static int scarlett2_usb_get( 2027 struct usb_mixer_interface *mixer, 2028 int offset, void *buf, int size) 2029{ 2030 struct { 2031 __le32 offset; 2032 __le32 size; 2033 } __packed req; 2034 2035 req.offset = cpu_to_le32(offset); 2036 req.size = cpu_to_le32(size); 2037 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA, 2038 &req, sizeof(req), buf, size); 2039} 2040 2041/* Return true if the given configuration item is present in the 2042 * configuration set used by this device. 2043 */ 2044static int scarlett2_has_config_item( 2045 struct scarlett2_data *private, int config_item_num) 2046{ 2047 return !!private->config_set->items[config_item_num].offset; 2048} 2049 2050/* Send a USB message to get configuration parameters; result placed in *buf */ 2051static int scarlett2_usb_get_config( 2052 struct usb_mixer_interface *mixer, 2053 int config_item_num, int count, void *buf) 2054{ 2055 struct scarlett2_data *private = mixer->private_data; 2056 const struct scarlett2_config *config_item = 2057 &private->config_set->items[config_item_num]; 2058 int size, err, i; 2059 u8 *buf_8; 2060 u8 value; 2061 2062 /* Check that the configuration item is present in the 2063 * configuration set used by this device 2064 */ 2065 if (!config_item->offset) 2066 return -EFAULT; 2067 2068 /* Gen 4 style parameters are always 1 byte */ 2069 size = config_item->size ? config_item->size : 8; 2070 2071 /* For byte-sized parameters, retrieve directly into buf */ 2072 if (size >= 8) { 2073 size = size / 8 * count; 2074 err = scarlett2_usb_get(mixer, config_item->offset, buf, size); 2075 if (err < 0) 2076 return err; 2077 if (size == 2) { 2078 u16 *buf_16 = buf; 2079 2080 for (i = 0; i < count; i++, buf_16++) 2081 *buf_16 = le16_to_cpu(*(__le16 *)buf_16); 2082 } 2083 return 0; 2084 } 2085 2086 /* For bit-sized parameters, retrieve into value */ 2087 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1); 2088 if (err < 0) 2089 return err; 2090 2091 /* then unpack from value into buf[] */ 2092 buf_8 = buf; 2093 for (i = 0; i < 8 && i < count; i++, value >>= 1) 2094 *buf_8++ = value & 1; 2095 2096 return 0; 2097} 2098 2099/* Send a SCARLETT2_USB_SET_DATA command. 2100 * offset: location in the device's data space 2101 * size: size in bytes of the value (1, 2, 4) 2102 */ 2103static int scarlett2_usb_set_data( 2104 struct usb_mixer_interface *mixer, 2105 int offset, int size, int value) 2106{ 2107 struct scarlett2_data *private = mixer->private_data; 2108 struct { 2109 __le32 offset; 2110 __le32 size; 2111 __le32 value; 2112 } __packed req; 2113 2114 req.offset = cpu_to_le32(offset); 2115 req.size = cpu_to_le32(size); 2116 req.value = cpu_to_le32(value); 2117 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA, 2118 &req, sizeof(u32) * 2 + size, NULL, 0); 2119} 2120 2121/* Send a SCARLETT2_USB_DATA_CMD command. 2122 * Configuration changes require activation with this after they have 2123 * been uploaded by a previous SCARLETT2_USB_SET_DATA. 2124 * The value for activate needed is determined by the configuration 2125 * item. 2126 */ 2127static int scarlett2_usb_activate_config( 2128 struct usb_mixer_interface *mixer, int activate) 2129{ 2130 __le32 req; 2131 2132 req = cpu_to_le32(activate); 2133 return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD, 2134 &req, sizeof(req), NULL, 0); 2135} 2136 2137/* Send USB messages to set a SCARLETT2_CONFIG_* parameter */ 2138static int scarlett2_usb_set_config( 2139 struct usb_mixer_interface *mixer, 2140 int config_item_num, int index, int value) 2141{ 2142 struct scarlett2_data *private = mixer->private_data; 2143 const struct scarlett2_config_set *config_set = private->config_set; 2144 const struct scarlett2_config *config_item = 2145 &config_set->items[config_item_num]; 2146 int offset, size; 2147 int err; 2148 2149 /* Check that the configuration item is present in the 2150 * configuration set used by this device 2151 */ 2152 if (!config_item->offset) 2153 return -EFAULT; 2154 2155 /* Gen 4 style writes are selected with size = 0; 2156 * these are only byte-sized values written through a shared 2157 * location, different to the read address 2158 */ 2159 if (!config_item->size) { 2160 if (!config_set->gen4_write_addr) 2161 return -EFAULT; 2162 2163 /* Place index in gen4_write_addr + 1 */ 2164 err = scarlett2_usb_set_data( 2165 mixer, config_set->gen4_write_addr + 1, 1, index); 2166 if (err < 0) 2167 return err; 2168 2169 /* Place value in gen4_write_addr */ 2170 err = scarlett2_usb_set_data( 2171 mixer, config_set->gen4_write_addr, 1, value); 2172 if (err < 0) 2173 return err; 2174 2175 /* Request the interface do the write */ 2176 return scarlett2_usb_activate_config( 2177 mixer, config_item->activate); 2178 } 2179 2180 /* Not-Gen 4 style needs NVRAM save, supports 2181 * bit-modification, and writing is done to the same place 2182 * that the value can be read from 2183 */ 2184 2185 /* Cancel any pending NVRAM save */ 2186 cancel_delayed_work_sync(&private->work); 2187 2188 /* Convert config_item->size in bits to size in bytes and 2189 * calculate offset 2190 */ 2191 if (config_item->size >= 8) { 2192 size = config_item->size / 8; 2193 offset = config_item->offset + index * size; 2194 2195 /* If updating a bit, retrieve the old value, set/clear the 2196 * bit as needed, and update value 2197 */ 2198 } else { 2199 u8 tmp; 2200 2201 size = 1; 2202 offset = config_item->offset; 2203 2204 err = scarlett2_usb_get(mixer, offset, &tmp, 1); 2205 if (err < 0) 2206 return err; 2207 2208 if (value) 2209 tmp |= (1 << index); 2210 else 2211 tmp &= ~(1 << index); 2212 2213 value = tmp; 2214 } 2215 2216 /* Send the configuration parameter data */ 2217 err = scarlett2_usb_set_data(mixer, offset, size, value); 2218 if (err < 0) 2219 return err; 2220 2221 /* Activate the change */ 2222 err = scarlett2_usb_activate_config(mixer, config_item->activate); 2223 if (err < 0) 2224 return err; 2225 2226 /* Gen 2 style writes to Gen 4 devices don't need saving */ 2227 if (config_set->gen4_write_addr) 2228 return 0; 2229 2230 /* Schedule the change to be written to NVRAM */ 2231 if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE) 2232 schedule_delayed_work(&private->work, msecs_to_jiffies(2000)); 2233 2234 return 0; 2235} 2236 2237/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */ 2238static void scarlett2_config_save(struct usb_mixer_interface *mixer) 2239{ 2240 int err; 2241 2242 err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE); 2243 if (err < 0) 2244 usb_audio_err(mixer->chip, "config save failed: %d\n", err); 2245} 2246 2247/* Delayed work to save config */ 2248static void scarlett2_config_save_work(struct work_struct *work) 2249{ 2250 struct scarlett2_data *private = 2251 container_of(work, struct scarlett2_data, work.work); 2252 2253 scarlett2_config_save(private->mixer); 2254} 2255 2256/* Send a USB message to get sync status; result placed in *sync */ 2257static int scarlett2_usb_get_sync_status( 2258 struct usb_mixer_interface *mixer, 2259 u8 *sync) 2260{ 2261 __le32 data; 2262 int err; 2263 2264 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC, 2265 NULL, 0, &data, sizeof(data)); 2266 if (err < 0) 2267 return err; 2268 2269 *sync = !!data; 2270 return 0; 2271} 2272 2273/* Return true if the device has a mixer that we can control */ 2274static int scarlett2_has_mixer(struct scarlett2_data *private) 2275{ 2276 return !!private->info->mux_assignment[0][0].count; 2277} 2278 2279/* Map from mixer value to (db + 80) * 2 2280 * (reverse of scarlett2_mixer_values[]) 2281 */ 2282static int scarlett2_mixer_value_to_db(int value) 2283{ 2284 int i; 2285 2286 for (i = 0; i < SCARLETT2_MIXER_VALUE_COUNT; i++) 2287 if (scarlett2_mixer_values[i] >= value) 2288 return i; 2289 return SCARLETT2_MIXER_MAX_VALUE; 2290} 2291 2292/* Send a USB message to get the volumes for all inputs of one mix 2293 * and put the values into private->mix[] 2294 */ 2295static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer, 2296 int mix_num) 2297{ 2298 struct scarlett2_data *private = mixer->private_data; 2299 2300 int num_mixer_in = private->num_mix_in; 2301 int err, i, j; 2302 2303 struct { 2304 __le16 mix_num; 2305 __le16 count; 2306 } __packed req; 2307 2308 __le16 data[SCARLETT2_INPUT_MIX_MAX]; 2309 2310 req.mix_num = cpu_to_le16(mix_num); 2311 req.count = cpu_to_le16(num_mixer_in); 2312 2313 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX, 2314 &req, sizeof(req), 2315 data, num_mixer_in * sizeof(u16)); 2316 if (err < 0) 2317 return err; 2318 2319 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) 2320 private->mix[j] = scarlett2_mixer_value_to_db( 2321 le16_to_cpu(data[i])); 2322 2323 return 0; 2324} 2325 2326/* Send a USB message to set the volumes for all inputs of one mix 2327 * (values obtained from private->mix[]) 2328 */ 2329static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer, 2330 int mix_num) 2331{ 2332 struct scarlett2_data *private = mixer->private_data; 2333 2334 struct { 2335 __le16 mix_num; 2336 __le16 data[SCARLETT2_INPUT_MIX_MAX]; 2337 } __packed req; 2338 2339 int i, j; 2340 int num_mixer_in = private->num_mix_in; 2341 2342 req.mix_num = cpu_to_le16(mix_num); 2343 2344 for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++) 2345 req.data[i] = cpu_to_le16( 2346 scarlett2_mixer_values[private->mix[j]] 2347 ); 2348 2349 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX, 2350 &req, (num_mixer_in + 1) * sizeof(u16), 2351 NULL, 0); 2352} 2353 2354/* Convert a port number index (per info->port_count) to a hardware ID */ 2355static u32 scarlett2_mux_src_num_to_id( 2356 const int port_count[][SCARLETT2_PORT_DIRNS], int num) 2357{ 2358 int port_type; 2359 2360 for (port_type = 0; 2361 port_type < SCARLETT2_PORT_TYPE_COUNT; 2362 port_type++) { 2363 if (num < port_count[port_type][SCARLETT2_PORT_IN]) 2364 return scarlett2_ports[port_type].id | num; 2365 num -= port_count[port_type][SCARLETT2_PORT_IN]; 2366 } 2367 2368 /* Oops */ 2369 return 0; 2370} 2371 2372/* Convert a hardware ID to a port number index */ 2373static u32 scarlett2_mux_id_to_num( 2374 const int port_count[][SCARLETT2_PORT_DIRNS], int direction, u32 id) 2375{ 2376 int port_type; 2377 int port_num = 0; 2378 2379 for (port_type = 0; 2380 port_type < SCARLETT2_PORT_TYPE_COUNT; 2381 port_type++) { 2382 int base = scarlett2_ports[port_type].id; 2383 int count = port_count[port_type][direction]; 2384 2385 if (id >= base && id < base + count) 2386 return port_num + id - base; 2387 port_num += count; 2388 } 2389 2390 /* Oops */ 2391 return -1; 2392} 2393 2394/* Convert one mux entry from the interface and load into private->mux[] */ 2395static void scarlett2_usb_populate_mux(struct scarlett2_data *private, 2396 u32 mux_entry) 2397{ 2398 const struct scarlett2_device_info *info = private->info; 2399 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 2400 2401 int dst_idx, src_idx; 2402 2403 dst_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_OUT, 2404 mux_entry & 0xFFF); 2405 if (dst_idx < 0) 2406 return; 2407 2408 if (dst_idx >= private->num_mux_dsts) { 2409 usb_audio_err(private->mixer->chip, 2410 "BUG: scarlett2_mux_id_to_num(%06x, OUT): %d >= %d", 2411 mux_entry, dst_idx, private->num_mux_dsts); 2412 return; 2413 } 2414 2415 src_idx = scarlett2_mux_id_to_num(port_count, SCARLETT2_PORT_IN, 2416 mux_entry >> 12); 2417 if (src_idx < 0) 2418 return; 2419 2420 if (src_idx >= private->num_mux_srcs) { 2421 usb_audio_err(private->mixer->chip, 2422 "BUG: scarlett2_mux_id_to_num(%06x, IN): %d >= %d", 2423 mux_entry, src_idx, private->num_mux_srcs); 2424 return; 2425 } 2426 2427 private->mux[dst_idx] = src_idx; 2428} 2429 2430/* Update the meter level map 2431 * 2432 * The meter level data from the interface (SCARLETT2_USB_GET_METER 2433 * request) is returned in mux_assignment order, but to avoid exposing 2434 * that to userspace, scarlett2_meter_ctl_get() rearranges the data 2435 * into scarlett2_ports order using the meter_level_map[] array which 2436 * is set up by this function. 2437 * 2438 * In addition, the meter level data values returned from the 2439 * interface are invalid for destinations where: 2440 * 2441 * - the source is "Off"; therefore we set those values to zero (map 2442 * value of 255) 2443 * 2444 * - the source is assigned to a previous (with respect to the 2445 * mux_assignment order) destination; therefore we set those values 2446 * to the value previously reported for that source 2447 */ 2448static void scarlett2_update_meter_level_map(struct scarlett2_data *private) 2449{ 2450 const struct scarlett2_device_info *info = private->info; 2451 const struct scarlett2_meter_entry *entry; 2452 2453 /* sources already assigned to a destination 2454 * value is 255 for None, otherwise the value of i 2455 * (index into array returned by 2456 * scarlett2_usb_get_meter_levels()) 2457 */ 2458 u8 seen_src[SCARLETT2_MAX_SRCS] = { 1 }; 2459 u8 seen_src_value[SCARLETT2_MAX_SRCS] = { 255 }; 2460 2461 /* index in meter_map[] order */ 2462 int i = 0; 2463 2464 /* go through the meter_map[] entries */ 2465 for (entry = info->meter_map; 2466 entry->count; 2467 entry++) { 2468 2469 /* fill in each meter_level_map[] entry */ 2470 int j, mux_idx; 2471 2472 for (j = 0, mux_idx = entry->start; 2473 j < entry->count; 2474 i++, j++, mux_idx++) { 2475 2476 /* convert mux_idx using line_out_unmap[] */ 2477 int map_mux_idx = ( 2478 info->line_out_remap_enable && 2479 mux_idx < private->num_line_out 2480 ) ? info->line_out_unmap[mux_idx] 2481 : mux_idx; 2482 2483 /* check which source is connected, and if 2484 * that source is already connected elsewhere, 2485 * use that existing connection's destination 2486 * for this meter entry instead 2487 */ 2488 int mux_src = private->mux[mux_idx]; 2489 2490 if (!seen_src[mux_src]) { 2491 seen_src[mux_src] = 1; 2492 seen_src_value[mux_src] = i; 2493 } 2494 private->meter_level_map[map_mux_idx] = 2495 seen_src_value[mux_src]; 2496 } 2497 } 2498} 2499 2500/* Send USB message to get mux inputs and then populate private->mux[] */ 2501static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer) 2502{ 2503 struct scarlett2_data *private = mixer->private_data; 2504 int count = private->num_mux_dsts; 2505 int err, i; 2506 2507 struct { 2508 __le16 num; 2509 __le16 count; 2510 } __packed req; 2511 2512 __le32 data[SCARLETT2_MUX_MAX]; 2513 2514 private->mux_updated = 0; 2515 2516 req.num = 0; 2517 req.count = cpu_to_le16(count); 2518 2519 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX, 2520 &req, sizeof(req), 2521 data, count * sizeof(u32)); 2522 if (err < 0) 2523 return err; 2524 2525 for (i = 0; i < count; i++) 2526 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i])); 2527 2528 scarlett2_update_meter_level_map(private); 2529 2530 return 0; 2531} 2532 2533/* Send USB messages to set mux inputs */ 2534static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer) 2535{ 2536 struct scarlett2_data *private = mixer->private_data; 2537 const struct scarlett2_device_info *info = private->info; 2538 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 2539 int table; 2540 2541 struct { 2542 __le16 pad; 2543 __le16 num; 2544 __le32 data[SCARLETT2_MUX_MAX]; 2545 } __packed req; 2546 2547 req.pad = 0; 2548 2549 /* set mux settings for each rate */ 2550 for (table = 0; table < SCARLETT2_MUX_TABLES; table++) { 2551 const struct scarlett2_mux_entry *entry; 2552 2553 /* i counts over the output array */ 2554 int i = 0, err; 2555 2556 req.num = cpu_to_le16(table); 2557 2558 /* loop through each entry */ 2559 for (entry = info->mux_assignment[table]; 2560 entry->count; 2561 entry++) { 2562 int j; 2563 int port_type = entry->port_type; 2564 int port_idx = entry->start; 2565 int mux_idx = scarlett2_get_port_start_num(port_count, 2566 SCARLETT2_PORT_OUT, port_type) + port_idx; 2567 int dst_id = scarlett2_ports[port_type].id + port_idx; 2568 2569 /* Empty slots */ 2570 if (!dst_id) { 2571 for (j = 0; j < entry->count; j++) 2572 req.data[i++] = 0; 2573 continue; 2574 } 2575 2576 /* Non-empty mux slots use the lower 12 bits 2577 * for the destination and next 12 bits for 2578 * the source 2579 */ 2580 for (j = 0; j < entry->count; j++) { 2581 int src_id = scarlett2_mux_src_num_to_id( 2582 port_count, private->mux[mux_idx++]); 2583 req.data[i++] = cpu_to_le32(dst_id | 2584 src_id << 12); 2585 dst_id++; 2586 } 2587 } 2588 2589 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX, 2590 &req, (i + 1) * sizeof(u32), 2591 NULL, 0); 2592 if (err < 0) 2593 return err; 2594 } 2595 2596 scarlett2_update_meter_level_map(private); 2597 2598 return 0; 2599} 2600 2601/* Send USB message to get meter levels */ 2602static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer, 2603 u16 num_meters, u16 *levels) 2604{ 2605 struct { 2606 __le16 pad; 2607 __le16 num_meters; 2608 __le32 magic; 2609 } __packed req; 2610 __le32 resp[SCARLETT2_MAX_METERS]; 2611 int i, err; 2612 2613 req.pad = 0; 2614 req.num_meters = cpu_to_le16(num_meters); 2615 req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC); 2616 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER, 2617 &req, sizeof(req), resp, num_meters * sizeof(u32)); 2618 if (err < 0) 2619 return err; 2620 2621 /* copy, convert to u16 */ 2622 for (i = 0; i < num_meters; i++) 2623 levels[i] = le32_to_cpu(resp[i]); 2624 2625 return 0; 2626} 2627 2628/* For config items with mute=1, xor bits 0 & 1 together to get the 2629 * current/next state. This won't have any effect on values which are 2630 * only ever 0/1. 2631 */ 2632static uint8_t scarlett2_decode_muteable(uint8_t v) 2633{ 2634 return (v ^ (v >> 1)) & 1; 2635} 2636 2637/*** Control Functions ***/ 2638 2639/* helper function to create a new control */ 2640static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer, 2641 const struct snd_kcontrol_new *ncontrol, 2642 int index, int channels, const char *name, 2643 struct snd_kcontrol **kctl_return) 2644{ 2645 struct snd_kcontrol *kctl; 2646 struct usb_mixer_elem_info *elem; 2647 int err; 2648 2649 elem = kzalloc(sizeof(*elem), GFP_KERNEL); 2650 if (!elem) 2651 return -ENOMEM; 2652 2653 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code 2654 * ignores them for resume and other operations. 2655 * Also, the head.id field is set to 0, as we don't use this field. 2656 */ 2657 elem->head.mixer = mixer; 2658 elem->control = index; 2659 elem->head.id = 0; 2660 elem->channels = channels; 2661 elem->val_type = USB_MIXER_BESPOKEN; 2662 2663 kctl = snd_ctl_new1(ncontrol, elem); 2664 if (!kctl) { 2665 kfree(elem); 2666 return -ENOMEM; 2667 } 2668 kctl->private_free = snd_usb_mixer_elem_free; 2669 2670 strscpy(kctl->id.name, name, sizeof(kctl->id.name)); 2671 2672 err = snd_usb_mixer_add_control(&elem->head, kctl); 2673 if (err < 0) 2674 return err; 2675 2676 if (kctl_return) 2677 *kctl_return = kctl; 2678 2679 return 0; 2680} 2681 2682/*** Firmware Version Control ***/ 2683 2684static int scarlett2_firmware_version_ctl_get( 2685 struct snd_kcontrol *kctl, 2686 struct snd_ctl_elem_value *ucontrol) 2687{ 2688 struct usb_mixer_elem_info *elem = kctl->private_data; 2689 struct scarlett2_data *private = elem->head.mixer->private_data; 2690 2691 ucontrol->value.integer.value[0] = private->firmware_version; 2692 2693 return 0; 2694} 2695 2696static int scarlett2_firmware_version_ctl_info( 2697 struct snd_kcontrol *kctl, 2698 struct snd_ctl_elem_info *uinfo) 2699{ 2700 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2701 uinfo->count = 1; 2702 2703 return 0; 2704} 2705 2706static const struct snd_kcontrol_new scarlett2_firmware_version_ctl = { 2707 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 2708 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2709 .name = "", 2710 .info = scarlett2_firmware_version_ctl_info, 2711 .get = scarlett2_firmware_version_ctl_get 2712}; 2713 2714static int scarlett2_add_firmware_version_ctl( 2715 struct usb_mixer_interface *mixer) 2716{ 2717 return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl, 2718 0, 0, "Firmware Version", NULL); 2719} 2720 2721/*** Minimum Firmware Version Control ***/ 2722 2723static int scarlett2_min_firmware_version_ctl_get( 2724 struct snd_kcontrol *kctl, 2725 struct snd_ctl_elem_value *ucontrol) 2726{ 2727 struct usb_mixer_elem_info *elem = kctl->private_data; 2728 struct scarlett2_data *private = elem->head.mixer->private_data; 2729 2730 ucontrol->value.integer.value[0] = private->info->min_firmware_version; 2731 2732 return 0; 2733} 2734 2735static int scarlett2_min_firmware_version_ctl_info( 2736 struct snd_kcontrol *kctl, 2737 struct snd_ctl_elem_info *uinfo) 2738{ 2739 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2740 uinfo->count = 1; 2741 2742 return 0; 2743} 2744 2745static const struct snd_kcontrol_new scarlett2_min_firmware_version_ctl = { 2746 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 2747 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2748 .name = "", 2749 .info = scarlett2_min_firmware_version_ctl_info, 2750 .get = scarlett2_min_firmware_version_ctl_get 2751}; 2752 2753static int scarlett2_add_min_firmware_version_ctl( 2754 struct usb_mixer_interface *mixer) 2755{ 2756 return scarlett2_add_new_ctl(mixer, &scarlett2_min_firmware_version_ctl, 2757 0, 0, "Minimum Firmware Version", NULL); 2758} 2759 2760/*** Sync Control ***/ 2761 2762/* Update sync control after receiving notification that the status 2763 * has changed 2764 */ 2765static int scarlett2_update_sync(struct usb_mixer_interface *mixer) 2766{ 2767 struct scarlett2_data *private = mixer->private_data; 2768 2769 private->sync_updated = 0; 2770 return scarlett2_usb_get_sync_status(mixer, &private->sync); 2771} 2772 2773static int scarlett2_sync_ctl_info(struct snd_kcontrol *kctl, 2774 struct snd_ctl_elem_info *uinfo) 2775{ 2776 static const char *texts[2] = { 2777 "Unlocked", "Locked" 2778 }; 2779 return snd_ctl_enum_info(uinfo, 1, 2, texts); 2780} 2781 2782static int scarlett2_sync_ctl_get(struct snd_kcontrol *kctl, 2783 struct snd_ctl_elem_value *ucontrol) 2784{ 2785 struct usb_mixer_elem_info *elem = kctl->private_data; 2786 struct usb_mixer_interface *mixer = elem->head.mixer; 2787 struct scarlett2_data *private = mixer->private_data; 2788 int err = 0; 2789 2790 mutex_lock(&private->data_mutex); 2791 2792 if (private->hwdep_in_use) { 2793 err = -EBUSY; 2794 goto unlock; 2795 } 2796 2797 if (private->sync_updated) { 2798 err = scarlett2_update_sync(mixer); 2799 if (err < 0) 2800 goto unlock; 2801 } 2802 ucontrol->value.enumerated.item[0] = private->sync; 2803 2804unlock: 2805 mutex_unlock(&private->data_mutex); 2806 return err; 2807} 2808 2809static const struct snd_kcontrol_new scarlett2_sync_ctl = { 2810 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2811 .access = SNDRV_CTL_ELEM_ACCESS_READ, 2812 .name = "", 2813 .info = scarlett2_sync_ctl_info, 2814 .get = scarlett2_sync_ctl_get 2815}; 2816 2817static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer) 2818{ 2819 struct scarlett2_data *private = mixer->private_data; 2820 2821 /* devices without a mixer also don't support reporting sync status */ 2822 if (!scarlett2_has_mixer(private)) 2823 return 0; 2824 2825 return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl, 2826 0, 1, "Sync Status", &private->sync_ctl); 2827} 2828 2829/*** Autogain Switch and Status Controls ***/ 2830 2831/* Forward declarations as phantom power and autogain can disable each other */ 2832static int scarlett2_check_input_phantom_updated(struct usb_mixer_interface *); 2833static int scarlett2_phantom_is_switching(struct scarlett2_data *, int); 2834 2835/* Set the access mode of a control to read-only (val = 0) or 2836 * read-write (val = 1). 2837 */ 2838static void scarlett2_set_ctl_access(struct snd_kcontrol *kctl, int val) 2839{ 2840 if (val) 2841 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE; 2842 else 2843 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE; 2844} 2845 2846/* Check if autogain is running on any input */ 2847static int scarlett2_autogain_is_running(struct scarlett2_data *private) 2848{ 2849 int i; 2850 2851 /* autogain_status[] is 0 if autogain is running */ 2852 for (i = 0; i < private->info->gain_input_count; i++) 2853 if (!private->autogain_status[i]) 2854 return 1; 2855 2856 return 0; 2857} 2858 2859static int scarlett2_update_autogain(struct usb_mixer_interface *mixer) 2860{ 2861 struct scarlett2_data *private = mixer->private_data; 2862 const struct scarlett2_device_info *info = private->info; 2863 int err, i; 2864 u8 raw_autogain_status[SCARLETT2_INPUT_GAIN_MAX]; 2865 2866 private->autogain_updated = 0; 2867 2868 if (!info->gain_input_count) 2869 return 0; 2870 2871 err = scarlett2_usb_get_config( 2872 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, 2873 info->gain_input_count, private->autogain_switch); 2874 if (err < 0) 2875 return err; 2876 err = scarlett2_usb_get_config( 2877 mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS, 2878 info->gain_input_count, raw_autogain_status); 2879 if (err < 0) 2880 return err; 2881 2882 /* Translate autogain_switch and raw_autogain_status into 2883 * autogain_status. 2884 * 2885 * When autogain_switch[] is set, the status is the first 2886 * element in scarlett2_autogain_status_texts[] (Running). The 2887 * subsequent elements correspond to the status value from the 2888 * device (raw_autogain_status[]) + 1. The last element is 2889 * "Invalid", in case the device reports a status outside the 2890 * range of scarlett2_autogain_status_texts[]. 2891 */ 2892 for (i = 0; i < info->gain_input_count; i++) 2893 if (private->autogain_switch[i]) 2894 private->autogain_status[i] = 0; 2895 else if (raw_autogain_status[i] < 2896 ARRAY_SIZE(scarlett2_autogain_status_texts) - 1) 2897 private->autogain_status[i] = 2898 raw_autogain_status[i] + 1; 2899 else 2900 private->autogain_status[i] = 2901 ARRAY_SIZE(scarlett2_autogain_status_texts) - 1; 2902 2903 return 0; 2904} 2905 2906/* Update access mode for controls affected by autogain */ 2907static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer) 2908{ 2909 struct scarlett2_data *private = mixer->private_data; 2910 const struct scarlett2_device_info *info = private->info; 2911 int val = !scarlett2_autogain_is_running(private); 2912 int i; 2913 2914 scarlett2_set_ctl_access(private->input_select_ctl, val); 2915 for (i = 0; i < info->gain_input_count / 2; i++) 2916 scarlett2_set_ctl_access(private->input_link_ctls[i], val); 2917 for (i = 0; i < info->gain_input_count; i++) { 2918 scarlett2_set_ctl_access(private->input_gain_ctls[i], val); 2919 scarlett2_set_ctl_access(private->safe_ctls[i], val); 2920 } 2921 for (i = 0; i < info->level_input_count; i++) 2922 scarlett2_set_ctl_access(private->level_ctls[i], val); 2923 for (i = 0; i < info->air_input_count; i++) 2924 scarlett2_set_ctl_access(private->air_ctls[i], val); 2925 for (i = 0; i < info->phantom_count; i++) 2926 scarlett2_set_ctl_access(private->phantom_ctls[i], val); 2927} 2928 2929/* Notify of access mode change for all controls read-only while 2930 * autogain runs. 2931 */ 2932static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer) 2933{ 2934 struct snd_card *card = mixer->chip->card; 2935 struct scarlett2_data *private = mixer->private_data; 2936 const struct scarlett2_device_info *info = private->info; 2937 int i; 2938 2939 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2940 &private->input_select_ctl->id); 2941 for (i = 0; i < info->gain_input_count / 2; i++) 2942 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2943 &private->input_link_ctls[i]->id); 2944 for (i = 0; i < info->gain_input_count; i++) { 2945 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2946 &private->input_gain_ctls[i]->id); 2947 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2948 &private->safe_ctls[i]->id); 2949 } 2950 for (i = 0; i < info->level_input_count; i++) 2951 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2952 &private->level_ctls[i]->id); 2953 for (i = 0; i < info->air_input_count; i++) 2954 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2955 &private->air_ctls[i]->id); 2956 for (i = 0; i < info->phantom_count; i++) 2957 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 2958 &private->phantom_ctls[i]->id); 2959} 2960 2961/* Call scarlett2_update_autogain() and 2962 * scarlett2_autogain_update_access() if autogain_updated is set. 2963 */ 2964static int scarlett2_check_autogain_updated( 2965 struct usb_mixer_interface *mixer) 2966{ 2967 struct scarlett2_data *private = mixer->private_data; 2968 int err; 2969 2970 if (!private->autogain_updated) 2971 return 0; 2972 2973 err = scarlett2_update_autogain(mixer); 2974 if (err < 0) 2975 return err; 2976 2977 scarlett2_autogain_update_access(mixer); 2978 2979 return 0; 2980} 2981 2982/* If autogain_updated is set when a *_ctl_put() function for a 2983 * control that is meant to be read-only while autogain is running, 2984 * update the autogain status and access mode of affected controls. 2985 * Return -EPERM if autogain is running. 2986 */ 2987static int scarlett2_check_put_during_autogain( 2988 struct usb_mixer_interface *mixer) 2989{ 2990 int err = scarlett2_check_autogain_updated(mixer); 2991 2992 if (err < 0) 2993 return err; 2994 2995 if (scarlett2_autogain_is_running(mixer->private_data)) 2996 return -EPERM; 2997 2998 return 0; 2999} 3000 3001static int scarlett2_autogain_switch_ctl_info( 3002 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 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 int err; 3008 3009 mutex_lock(&private->data_mutex); 3010 3011 err = scarlett2_check_input_phantom_updated(mixer); 3012 if (err < 0) 3013 goto unlock; 3014 3015 err = snd_ctl_boolean_mono_info(kctl, uinfo); 3016 3017unlock: 3018 mutex_unlock(&private->data_mutex); 3019 return err; 3020} 3021 3022static int scarlett2_autogain_switch_ctl_get( 3023 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3024{ 3025 struct usb_mixer_elem_info *elem = kctl->private_data; 3026 struct usb_mixer_interface *mixer = elem->head.mixer; 3027 struct scarlett2_data *private = mixer->private_data; 3028 int err; 3029 3030 mutex_lock(&private->data_mutex); 3031 3032 if (private->hwdep_in_use) { 3033 err = -EBUSY; 3034 goto unlock; 3035 } 3036 3037 err = scarlett2_check_autogain_updated(mixer); 3038 if (err < 0) 3039 goto unlock; 3040 3041 ucontrol->value.enumerated.item[0] = 3042 private->autogain_switch[elem->control]; 3043 3044unlock: 3045 mutex_unlock(&private->data_mutex); 3046 return err; 3047} 3048 3049static int scarlett2_autogain_status_ctl_get( 3050 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3051{ 3052 struct usb_mixer_elem_info *elem = kctl->private_data; 3053 struct usb_mixer_interface *mixer = elem->head.mixer; 3054 struct scarlett2_data *private = mixer->private_data; 3055 int err; 3056 3057 mutex_lock(&private->data_mutex); 3058 3059 if (private->hwdep_in_use) { 3060 err = -EBUSY; 3061 goto unlock; 3062 } 3063 3064 err = scarlett2_check_autogain_updated(mixer); 3065 if (err < 0) 3066 goto unlock; 3067 3068 ucontrol->value.enumerated.item[0] = 3069 private->autogain_status[elem->control]; 3070 3071unlock: 3072 mutex_unlock(&private->data_mutex); 3073 return err; 3074} 3075 3076static int scarlett2_autogain_switch_ctl_put( 3077 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3078{ 3079 struct usb_mixer_elem_info *elem = kctl->private_data; 3080 struct usb_mixer_interface *mixer = elem->head.mixer; 3081 struct scarlett2_data *private = mixer->private_data; 3082 3083 int index = elem->control; 3084 int oval, val, err; 3085 3086 mutex_lock(&private->data_mutex); 3087 3088 if (private->hwdep_in_use) { 3089 err = -EBUSY; 3090 goto unlock; 3091 } 3092 3093 err = scarlett2_check_input_phantom_updated(mixer); 3094 if (err < 0) 3095 goto unlock; 3096 3097 if (scarlett2_phantom_is_switching(private, index)) { 3098 err = -EPERM; 3099 goto unlock; 3100 } 3101 3102 oval = private->autogain_switch[index]; 3103 val = !!ucontrol->value.integer.value[0]; 3104 3105 if (oval == val) 3106 goto unlock; 3107 3108 private->autogain_switch[index] = val; 3109 3110 /* Send switch change to the device */ 3111 err = scarlett2_usb_set_config( 3112 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val); 3113 if (err == 0) 3114 err = 1; 3115 3116 scarlett2_autogain_update_access(mixer); 3117 scarlett2_autogain_notify_access(mixer); 3118 3119unlock: 3120 mutex_unlock(&private->data_mutex); 3121 return err; 3122} 3123 3124static int scarlett2_autogain_status_ctl_info( 3125 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 3126{ 3127 return snd_ctl_enum_info( 3128 uinfo, 1, 3129 ARRAY_SIZE(scarlett2_autogain_status_texts), 3130 scarlett2_autogain_status_texts); 3131} 3132 3133static const struct snd_kcontrol_new scarlett2_autogain_switch_ctl = { 3134 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3135 .name = "", 3136 .info = scarlett2_autogain_switch_ctl_info, 3137 .get = scarlett2_autogain_switch_ctl_get, 3138 .put = scarlett2_autogain_switch_ctl_put 3139}; 3140 3141static const struct snd_kcontrol_new scarlett2_autogain_status_ctl = { 3142 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3143 .access = SNDRV_CTL_ELEM_ACCESS_READ, 3144 .name = "", 3145 .info = scarlett2_autogain_status_ctl_info, 3146 .get = scarlett2_autogain_status_ctl_get, 3147}; 3148 3149/*** Input Select Control ***/ 3150 3151static int scarlett2_update_input_select(struct usb_mixer_interface *mixer) 3152{ 3153 struct scarlett2_data *private = mixer->private_data; 3154 const struct scarlett2_device_info *info = private->info; 3155 int link_count = info->gain_input_count / 2; 3156 int err; 3157 3158 private->input_select_updated = 0; 3159 3160 if (!link_count) 3161 return 0; 3162 3163 err = scarlett2_usb_get_config( 3164 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH, 3165 1, &private->input_select_switch); 3166 if (err < 0) 3167 return err; 3168 3169 err = scarlett2_usb_get_config( 3170 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, 3171 link_count, private->input_link_switch); 3172 if (err < 0) 3173 return err; 3174 3175 /* simplified because no model yet has link_count > 1 */ 3176 if (private->input_link_switch[0]) 3177 private->input_select_switch = 0; 3178 3179 return 0; 3180} 3181 3182static int scarlett2_input_select_ctl_get( 3183 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3184{ 3185 struct usb_mixer_elem_info *elem = kctl->private_data; 3186 struct usb_mixer_interface *mixer = elem->head.mixer; 3187 struct scarlett2_data *private = mixer->private_data; 3188 int err = 0; 3189 3190 mutex_lock(&private->data_mutex); 3191 3192 if (private->hwdep_in_use) { 3193 err = -EBUSY; 3194 goto unlock; 3195 } 3196 3197 if (private->input_select_updated) { 3198 err = scarlett2_update_input_select(mixer); 3199 if (err < 0) 3200 goto unlock; 3201 } 3202 ucontrol->value.enumerated.item[0] = private->input_select_switch; 3203 3204unlock: 3205 mutex_unlock(&private->data_mutex); 3206 return err; 3207} 3208 3209static int scarlett2_input_select_ctl_put( 3210 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3211{ 3212 struct usb_mixer_elem_info *elem = kctl->private_data; 3213 struct usb_mixer_interface *mixer = elem->head.mixer; 3214 struct scarlett2_data *private = mixer->private_data; 3215 3216 int oval, val, err; 3217 int max_val = private->input_link_switch[0] ? 0 : 1; 3218 3219 mutex_lock(&private->data_mutex); 3220 3221 if (private->hwdep_in_use) { 3222 err = -EBUSY; 3223 goto unlock; 3224 } 3225 3226 err = scarlett2_check_put_during_autogain(mixer); 3227 if (err < 0) 3228 goto unlock; 3229 3230 oval = private->input_select_switch; 3231 val = ucontrol->value.integer.value[0]; 3232 3233 if (val < 0) 3234 val = 0; 3235 else if (val > max_val) 3236 val = max_val; 3237 3238 if (oval == val) 3239 goto unlock; 3240 3241 private->input_select_switch = val; 3242 3243 /* Send switch change to the device if inputs not linked */ 3244 if (!private->input_link_switch[0]) 3245 err = scarlett2_usb_set_config( 3246 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH, 3247 1, val); 3248 if (err == 0) 3249 err = 1; 3250 3251unlock: 3252 mutex_unlock(&private->data_mutex); 3253 return err; 3254} 3255 3256static int scarlett2_input_select_ctl_info( 3257 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 3258{ 3259 struct usb_mixer_elem_info *elem = kctl->private_data; 3260 struct usb_mixer_interface *mixer = elem->head.mixer; 3261 struct scarlett2_data *private = mixer->private_data; 3262 3263 int inputs = private->info->gain_input_count; 3264 int i, j; 3265 int err; 3266 char **values = kcalloc(inputs, sizeof(char *), GFP_KERNEL); 3267 3268 if (!values) 3269 return -ENOMEM; 3270 3271 mutex_lock(&private->data_mutex); 3272 3273 if (private->hwdep_in_use) { 3274 err = -EBUSY; 3275 goto unlock; 3276 } 3277 3278 err = scarlett2_check_autogain_updated(mixer); 3279 if (err < 0) 3280 goto unlock; 3281 3282 /* Loop through each input 3283 * Linked inputs have one value for the pair 3284 */ 3285 for (i = 0, j = 0; i < inputs; i++) { 3286 if (private->input_link_switch[i / 2]) { 3287 values[j++] = kasprintf( 3288 GFP_KERNEL, "Input %d-%d", i + 1, i + 2); 3289 i++; 3290 } else { 3291 values[j++] = kasprintf( 3292 GFP_KERNEL, "Input %d", i + 1); 3293 } 3294 } 3295 3296 err = snd_ctl_enum_info(uinfo, 1, j, 3297 (const char * const *)values); 3298 3299unlock: 3300 mutex_unlock(&private->data_mutex); 3301 3302 for (i = 0; i < inputs; i++) 3303 kfree(values[i]); 3304 kfree(values); 3305 3306 return err; 3307} 3308 3309static const struct snd_kcontrol_new scarlett2_input_select_ctl = { 3310 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3311 .name = "", 3312 .info = scarlett2_input_select_ctl_info, 3313 .get = scarlett2_input_select_ctl_get, 3314 .put = scarlett2_input_select_ctl_put, 3315}; 3316 3317/*** Input Link Switch Controls ***/ 3318 3319/* snd_ctl_boolean_mono_info() with autogain-updated check 3320 * (for controls that are read-only while autogain is running) 3321 */ 3322static int scarlett2_autogain_disables_ctl_info(struct snd_kcontrol *kctl, 3323 struct snd_ctl_elem_info *uinfo) 3324{ 3325 struct usb_mixer_elem_info *elem = kctl->private_data; 3326 struct usb_mixer_interface *mixer = elem->head.mixer; 3327 struct scarlett2_data *private = mixer->private_data; 3328 int err; 3329 3330 mutex_lock(&private->data_mutex); 3331 3332 if (private->hwdep_in_use) { 3333 err = -EBUSY; 3334 goto unlock; 3335 } 3336 3337 err = scarlett2_check_autogain_updated(mixer); 3338 if (err < 0) 3339 goto unlock; 3340 3341 err = snd_ctl_boolean_mono_info(kctl, uinfo); 3342 3343unlock: 3344 mutex_unlock(&private->data_mutex); 3345 return err; 3346} 3347 3348static int scarlett2_input_link_ctl_get( 3349 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3350{ 3351 struct usb_mixer_elem_info *elem = kctl->private_data; 3352 struct usb_mixer_interface *mixer = elem->head.mixer; 3353 struct scarlett2_data *private = mixer->private_data; 3354 int err = 0; 3355 3356 mutex_lock(&private->data_mutex); 3357 3358 if (private->hwdep_in_use) { 3359 err = -EBUSY; 3360 goto unlock; 3361 } 3362 3363 if (private->input_select_updated) { 3364 err = scarlett2_update_input_select(mixer); 3365 if (err < 0) 3366 goto unlock; 3367 } 3368 ucontrol->value.enumerated.item[0] = 3369 private->input_link_switch[elem->control]; 3370 3371unlock: 3372 mutex_unlock(&private->data_mutex); 3373 return err; 3374} 3375 3376static int scarlett2_input_link_ctl_put( 3377 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3378{ 3379 struct usb_mixer_elem_info *elem = kctl->private_data; 3380 struct usb_mixer_interface *mixer = elem->head.mixer; 3381 struct scarlett2_data *private = mixer->private_data; 3382 3383 int index = elem->control; 3384 int oval, val, err; 3385 3386 mutex_lock(&private->data_mutex); 3387 3388 if (private->hwdep_in_use) { 3389 err = -EBUSY; 3390 goto unlock; 3391 } 3392 3393 err = scarlett2_check_put_during_autogain(mixer); 3394 if (err < 0) 3395 goto unlock; 3396 3397 oval = private->input_link_switch[index]; 3398 val = !!ucontrol->value.integer.value[0]; 3399 3400 if (oval == val) 3401 goto unlock; 3402 3403 private->input_link_switch[index] = val; 3404 3405 /* Notify of change in input select options available */ 3406 snd_ctl_notify(mixer->chip->card, 3407 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 3408 &private->input_select_ctl->id); 3409 private->input_select_updated = 1; 3410 3411 /* Send switch change to the device 3412 * Link for channels 1-2 is at index 1 3413 * No device yet has more than 2 channels linked 3414 */ 3415 err = scarlett2_usb_set_config( 3416 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index + 1, val); 3417 if (err == 0) 3418 err = 1; 3419 3420unlock: 3421 mutex_unlock(&private->data_mutex); 3422 return err; 3423} 3424 3425static const struct snd_kcontrol_new scarlett2_input_link_ctl = { 3426 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3427 .name = "", 3428 .info = scarlett2_autogain_disables_ctl_info, 3429 .get = scarlett2_input_link_ctl_get, 3430 .put = scarlett2_input_link_ctl_put 3431}; 3432 3433/*** Input Gain Controls ***/ 3434 3435static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer) 3436{ 3437 struct scarlett2_data *private = mixer->private_data; 3438 const struct scarlett2_device_info *info = private->info; 3439 3440 private->input_gain_updated = 0; 3441 3442 if (!info->gain_input_count) 3443 return 0; 3444 3445 return scarlett2_usb_get_config( 3446 mixer, SCARLETT2_CONFIG_INPUT_GAIN, 3447 info->gain_input_count, private->gain); 3448} 3449 3450static int scarlett2_input_gain_ctl_info(struct snd_kcontrol *kctl, 3451 struct snd_ctl_elem_info *uinfo) 3452{ 3453 struct usb_mixer_elem_info *elem = kctl->private_data; 3454 struct usb_mixer_interface *mixer = elem->head.mixer; 3455 struct scarlett2_data *private = mixer->private_data; 3456 int err; 3457 3458 mutex_lock(&private->data_mutex); 3459 3460 if (private->hwdep_in_use) { 3461 err = -EBUSY; 3462 goto unlock; 3463 } 3464 3465 err = scarlett2_check_autogain_updated(mixer); 3466 if (err < 0) 3467 goto unlock; 3468 3469 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 3470 uinfo->count = elem->channels; 3471 uinfo->value.integer.min = 0; 3472 uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE; 3473 uinfo->value.integer.step = 1; 3474 3475unlock: 3476 mutex_unlock(&private->data_mutex); 3477 return err; 3478} 3479 3480static int scarlett2_input_gain_ctl_get(struct snd_kcontrol *kctl, 3481 struct snd_ctl_elem_value *ucontrol) 3482{ 3483 struct usb_mixer_elem_info *elem = kctl->private_data; 3484 struct usb_mixer_interface *mixer = elem->head.mixer; 3485 struct scarlett2_data *private = mixer->private_data; 3486 int err = 0; 3487 3488 mutex_lock(&private->data_mutex); 3489 3490 if (private->hwdep_in_use) { 3491 err = -EBUSY; 3492 goto unlock; 3493 } 3494 3495 if (private->input_gain_updated) { 3496 err = scarlett2_update_input_gain(mixer); 3497 if (err < 0) 3498 goto unlock; 3499 } 3500 ucontrol->value.integer.value[0] = 3501 private->gain[elem->control]; 3502 3503unlock: 3504 mutex_unlock(&private->data_mutex); 3505 return err; 3506} 3507 3508static int scarlett2_input_gain_ctl_put(struct snd_kcontrol *kctl, 3509 struct snd_ctl_elem_value *ucontrol) 3510{ 3511 struct usb_mixer_elem_info *elem = kctl->private_data; 3512 struct usb_mixer_interface *mixer = elem->head.mixer; 3513 struct scarlett2_data *private = mixer->private_data; 3514 3515 int index = elem->control; 3516 int oval, val, err; 3517 3518 mutex_lock(&private->data_mutex); 3519 3520 if (private->hwdep_in_use) { 3521 err = -EBUSY; 3522 goto unlock; 3523 } 3524 3525 err = scarlett2_check_put_during_autogain(mixer); 3526 if (err < 0) 3527 goto unlock; 3528 3529 oval = private->gain[index]; 3530 val = ucontrol->value.integer.value[0]; 3531 3532 if (oval == val) 3533 goto unlock; 3534 3535 private->gain[index] = val; 3536 3537 /* Send gain change to the device */ 3538 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_INPUT_GAIN, 3539 index, val); 3540 if (err == 0) 3541 err = 1; 3542 3543unlock: 3544 mutex_unlock(&private->data_mutex); 3545 return err; 3546} 3547 3548static const DECLARE_TLV_DB_MINMAX( 3549 db_scale_scarlett2_gain, 0, SCARLETT2_MAX_GAIN_DB * 100 3550); 3551 3552static const struct snd_kcontrol_new scarlett2_input_gain_ctl = { 3553 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3554 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 3555 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 3556 .name = "", 3557 .info = scarlett2_input_gain_ctl_info, 3558 .get = scarlett2_input_gain_ctl_get, 3559 .put = scarlett2_input_gain_ctl_put, 3560 .private_value = 0, /* max value */ 3561 .tlv = { .p = db_scale_scarlett2_gain } 3562}; 3563 3564/*** Safe Controls ***/ 3565 3566static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer) 3567{ 3568 struct scarlett2_data *private = mixer->private_data; 3569 const struct scarlett2_device_info *info = private->info; 3570 3571 private->input_safe_updated = 0; 3572 3573 if (!info->gain_input_count) 3574 return 0; 3575 3576 return scarlett2_usb_get_config( 3577 mixer, SCARLETT2_CONFIG_SAFE_SWITCH, 3578 info->gain_input_count, private->safe_switch); 3579} 3580 3581static int scarlett2_safe_ctl_get(struct snd_kcontrol *kctl, 3582 struct snd_ctl_elem_value *ucontrol) 3583{ 3584 struct usb_mixer_elem_info *elem = kctl->private_data; 3585 struct usb_mixer_interface *mixer = elem->head.mixer; 3586 struct scarlett2_data *private = mixer->private_data; 3587 int err = 0; 3588 3589 mutex_lock(&private->data_mutex); 3590 3591 if (private->hwdep_in_use) { 3592 err = -EBUSY; 3593 goto unlock; 3594 } 3595 3596 if (private->input_safe_updated) { 3597 err = scarlett2_update_input_safe(mixer); 3598 if (err < 0) 3599 goto unlock; 3600 } 3601 ucontrol->value.integer.value[0] = 3602 private->safe_switch[elem->control]; 3603 3604unlock: 3605 mutex_unlock(&private->data_mutex); 3606 return err; 3607} 3608 3609static int scarlett2_safe_ctl_put(struct snd_kcontrol *kctl, 3610 struct snd_ctl_elem_value *ucontrol) 3611{ 3612 struct usb_mixer_elem_info *elem = kctl->private_data; 3613 struct usb_mixer_interface *mixer = elem->head.mixer; 3614 struct scarlett2_data *private = mixer->private_data; 3615 3616 int index = elem->control; 3617 int oval, val, err; 3618 3619 mutex_lock(&private->data_mutex); 3620 3621 if (private->hwdep_in_use) { 3622 err = -EBUSY; 3623 goto unlock; 3624 } 3625 3626 err = scarlett2_check_put_during_autogain(mixer); 3627 if (err < 0) 3628 goto unlock; 3629 3630 oval = private->safe_switch[index]; 3631 val = !!ucontrol->value.integer.value[0]; 3632 3633 if (oval == val) 3634 goto unlock; 3635 3636 private->safe_switch[index] = val; 3637 3638 /* Send switch change to the device */ 3639 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SAFE_SWITCH, 3640 index, val); 3641 if (err == 0) 3642 err = 1; 3643 3644unlock: 3645 mutex_unlock(&private->data_mutex); 3646 return err; 3647} 3648 3649static const struct snd_kcontrol_new scarlett2_safe_ctl = { 3650 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3651 .name = "", 3652 .info = scarlett2_autogain_disables_ctl_info, 3653 .get = scarlett2_safe_ctl_get, 3654 .put = scarlett2_safe_ctl_put, 3655}; 3656 3657/*** PCM Input Control ***/ 3658 3659static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer) 3660{ 3661 struct scarlett2_data *private = mixer->private_data; 3662 int err; 3663 3664 private->pcm_input_switch_updated = 0; 3665 3666 err = scarlett2_usb_get_config( 3667 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH, 3668 1, &private->pcm_input_switch); 3669 if (err < 0) 3670 return err; 3671 3672 return 0; 3673} 3674 3675static int scarlett2_pcm_input_switch_ctl_get( 3676 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3677{ 3678 struct usb_mixer_elem_info *elem = kctl->private_data; 3679 struct usb_mixer_interface *mixer = elem->head.mixer; 3680 struct scarlett2_data *private = elem->head.mixer->private_data; 3681 int err = 0; 3682 3683 mutex_lock(&private->data_mutex); 3684 3685 if (private->pcm_input_switch_updated) { 3686 err = scarlett2_update_pcm_input_switch(mixer); 3687 if (err < 0) 3688 goto unlock; 3689 } 3690 ucontrol->value.enumerated.item[0] = private->pcm_input_switch; 3691 3692unlock: 3693 mutex_unlock(&private->data_mutex); 3694 return err; 3695} 3696 3697static int scarlett2_pcm_input_switch_ctl_put( 3698 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 3699{ 3700 struct usb_mixer_elem_info *elem = kctl->private_data; 3701 struct usb_mixer_interface *mixer = elem->head.mixer; 3702 struct scarlett2_data *private = mixer->private_data; 3703 3704 int oval, val, err = 0; 3705 3706 mutex_lock(&private->data_mutex); 3707 3708 if (private->hwdep_in_use) { 3709 err = -EBUSY; 3710 goto unlock; 3711 } 3712 3713 oval = private->pcm_input_switch; 3714 val = !!ucontrol->value.integer.value[0]; 3715 3716 if (oval == val) 3717 goto unlock; 3718 3719 private->pcm_input_switch = val; 3720 3721 /* Send switch change to the device */ 3722 err = scarlett2_usb_set_config( 3723 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH, 3724 0, val); 3725 if (err == 0) 3726 err = 1; 3727 3728unlock: 3729 mutex_unlock(&private->data_mutex); 3730 return err; 3731} 3732 3733static int scarlett2_pcm_input_switch_ctl_info( 3734 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 3735{ 3736 static const char *const values[2] = { 3737 "Direct", "Mixer" 3738 }; 3739 3740 return snd_ctl_enum_info( 3741 uinfo, 1, 2, values); 3742} 3743 3744static const struct snd_kcontrol_new scarlett2_pcm_input_switch_ctl = { 3745 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3746 .name = "", 3747 .info = scarlett2_pcm_input_switch_ctl_info, 3748 .get = scarlett2_pcm_input_switch_ctl_get, 3749 .put = scarlett2_pcm_input_switch_ctl_put 3750}; 3751 3752/*** Analogue Line Out Volume Controls ***/ 3753 3754/* Update hardware volume controls after receiving notification that 3755 * they have changed 3756 */ 3757static int scarlett2_update_volumes(struct usb_mixer_interface *mixer) 3758{ 3759 struct scarlett2_data *private = mixer->private_data; 3760 s16 vol; 3761 int err, i; 3762 3763 private->vol_updated = 0; 3764 3765 if (scarlett2_has_config_item(private, 3766 SCARLETT2_CONFIG_MASTER_VOLUME)) { 3767 err = scarlett2_usb_get_config( 3768 mixer, SCARLETT2_CONFIG_MASTER_VOLUME, 3769 1, &vol); 3770 if (err < 0) 3771 return err; 3772 3773 private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS, 3774 0, SCARLETT2_VOLUME_BIAS); 3775 3776 if (scarlett2_has_config_item(private, 3777 SCARLETT2_CONFIG_SW_HW_SWITCH)) 3778 for (i = 0; i < private->num_line_out; i++) 3779 if (private->vol_sw_hw_switch[i]) 3780 private->vol[i] = private->master_vol; 3781 } 3782 3783 if (scarlett2_has_config_item(private, 3784 SCARLETT2_CONFIG_HEADPHONE_VOLUME)) { 3785 err = scarlett2_usb_get_config( 3786 mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME, 3787 1, &vol); 3788 if (err < 0) 3789 return err; 3790 3791 private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS, 3792 0, SCARLETT2_VOLUME_BIAS); 3793 } 3794 3795 return 0; 3796} 3797 3798static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl, 3799 struct snd_ctl_elem_info *uinfo) 3800{ 3801 struct usb_mixer_elem_info *elem = kctl->private_data; 3802 3803 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 3804 uinfo->count = elem->channels; 3805 uinfo->value.integer.min = 0; 3806 uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS; 3807 uinfo->value.integer.step = 1; 3808 return 0; 3809} 3810 3811static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl, 3812 struct snd_ctl_elem_value *ucontrol) 3813{ 3814 struct usb_mixer_elem_info *elem = kctl->private_data; 3815 struct usb_mixer_interface *mixer = elem->head.mixer; 3816 struct scarlett2_data *private = mixer->private_data; 3817 int err = 0; 3818 3819 mutex_lock(&private->data_mutex); 3820 3821 if (private->hwdep_in_use) { 3822 err = -EBUSY; 3823 goto unlock; 3824 } 3825 3826 if (private->vol_updated) { 3827 err = scarlett2_update_volumes(mixer); 3828 if (err < 0) 3829 goto unlock; 3830 } 3831 ucontrol->value.integer.value[0] = private->master_vol; 3832 3833unlock: 3834 mutex_unlock(&private->data_mutex); 3835 return err; 3836} 3837 3838static int scarlett2_headphone_volume_ctl_get( 3839 struct snd_kcontrol *kctl, 3840 struct snd_ctl_elem_value *ucontrol) 3841{ 3842 struct usb_mixer_elem_info *elem = kctl->private_data; 3843 struct usb_mixer_interface *mixer = elem->head.mixer; 3844 struct scarlett2_data *private = mixer->private_data; 3845 int err = 0; 3846 3847 mutex_lock(&private->data_mutex); 3848 3849 if (private->hwdep_in_use) { 3850 err = -EBUSY; 3851 goto unlock; 3852 } 3853 3854 if (private->vol_updated) { 3855 err = scarlett2_update_volumes(mixer); 3856 if (err < 0) 3857 goto unlock; 3858 } 3859 ucontrol->value.integer.value[0] = private->headphone_vol; 3860 3861unlock: 3862 mutex_unlock(&private->data_mutex); 3863 return err; 3864} 3865 3866static int line_out_remap(struct scarlett2_data *private, int index) 3867{ 3868 const struct scarlett2_device_info *info = private->info; 3869 3870 if (!info->line_out_remap_enable) 3871 return index; 3872 3873 if (index >= private->num_line_out) 3874 return index; 3875 3876 return info->line_out_remap[index]; 3877} 3878 3879static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl, 3880 struct snd_ctl_elem_value *ucontrol) 3881{ 3882 struct usb_mixer_elem_info *elem = kctl->private_data; 3883 struct usb_mixer_interface *mixer = elem->head.mixer; 3884 struct scarlett2_data *private = mixer->private_data; 3885 int index = line_out_remap(private, elem->control); 3886 int err = 0; 3887 3888 mutex_lock(&private->data_mutex); 3889 3890 if (private->hwdep_in_use) { 3891 err = -EBUSY; 3892 goto unlock; 3893 } 3894 3895 if (private->vol_updated) { 3896 err = scarlett2_update_volumes(mixer); 3897 if (err < 0) 3898 goto unlock; 3899 } 3900 ucontrol->value.integer.value[0] = private->vol[index]; 3901 3902unlock: 3903 mutex_unlock(&private->data_mutex); 3904 return err; 3905} 3906 3907static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl, 3908 struct snd_ctl_elem_value *ucontrol) 3909{ 3910 struct usb_mixer_elem_info *elem = kctl->private_data; 3911 struct usb_mixer_interface *mixer = elem->head.mixer; 3912 struct scarlett2_data *private = mixer->private_data; 3913 int index = line_out_remap(private, elem->control); 3914 int oval, val, err = 0; 3915 3916 mutex_lock(&private->data_mutex); 3917 3918 if (private->hwdep_in_use) { 3919 err = -EBUSY; 3920 goto unlock; 3921 } 3922 3923 oval = private->vol[index]; 3924 val = ucontrol->value.integer.value[0]; 3925 3926 if (oval == val) 3927 goto unlock; 3928 3929 private->vol[index] = val; 3930 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 3931 index, val - SCARLETT2_VOLUME_BIAS); 3932 if (err == 0) 3933 err = 1; 3934 3935unlock: 3936 mutex_unlock(&private->data_mutex); 3937 return err; 3938} 3939 3940static const DECLARE_TLV_DB_MINMAX( 3941 db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0 3942); 3943 3944static const struct snd_kcontrol_new scarlett2_master_volume_ctl = { 3945 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3946 .access = SNDRV_CTL_ELEM_ACCESS_READ | 3947 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 3948 .name = "", 3949 .info = scarlett2_volume_ctl_info, 3950 .get = scarlett2_master_volume_ctl_get, 3951 .private_value = 0, /* max value */ 3952 .tlv = { .p = db_scale_scarlett2_volume } 3953}; 3954 3955static const struct snd_kcontrol_new scarlett2_headphone_volume_ctl = { 3956 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3957 .access = SNDRV_CTL_ELEM_ACCESS_READ | 3958 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 3959 .name = "", 3960 .info = scarlett2_volume_ctl_info, 3961 .get = scarlett2_headphone_volume_ctl_get, 3962 .private_value = 0, /* max value */ 3963 .tlv = { .p = db_scale_scarlett2_volume } 3964}; 3965 3966static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = { 3967 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3968 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 3969 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 3970 .name = "", 3971 .info = scarlett2_volume_ctl_info, 3972 .get = scarlett2_volume_ctl_get, 3973 .put = scarlett2_volume_ctl_put, 3974 .private_value = 0, /* max value */ 3975 .tlv = { .p = db_scale_scarlett2_volume } 3976}; 3977 3978/*** Mute Switch Controls ***/ 3979 3980static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer) 3981{ 3982 struct scarlett2_data *private = mixer->private_data; 3983 int err, i; 3984 u8 mute; 3985 3986 private->dim_mute_updated = 0; 3987 3988 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) 3989 return 0; 3990 3991 err = scarlett2_usb_get_config( 3992 mixer, SCARLETT2_CONFIG_DIM_MUTE, 3993 SCARLETT2_DIM_MUTE_COUNT, private->dim_mute); 3994 if (err < 0) 3995 return err; 3996 3997 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 3998 private->dim_mute[i] = !!private->dim_mute[i]; 3999 4000 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE]; 4001 4002 for (i = 0; i < private->num_line_out; i++) 4003 if (private->vol_sw_hw_switch[i]) 4004 private->mute_switch[i] = mute; 4005 4006 return 0; 4007} 4008 4009static int scarlett2_mute_ctl_get(struct snd_kcontrol *kctl, 4010 struct snd_ctl_elem_value *ucontrol) 4011{ 4012 struct usb_mixer_elem_info *elem = kctl->private_data; 4013 struct usb_mixer_interface *mixer = elem->head.mixer; 4014 struct scarlett2_data *private = mixer->private_data; 4015 int index = line_out_remap(private, elem->control); 4016 int err = 0; 4017 4018 mutex_lock(&private->data_mutex); 4019 4020 if (private->hwdep_in_use) { 4021 err = -EBUSY; 4022 goto unlock; 4023 } 4024 4025 if (private->dim_mute_updated) { 4026 err = scarlett2_update_dim_mute(mixer); 4027 if (err < 0) 4028 goto unlock; 4029 } 4030 ucontrol->value.integer.value[0] = private->mute_switch[index]; 4031 4032unlock: 4033 mutex_unlock(&private->data_mutex); 4034 return err; 4035} 4036 4037static int scarlett2_mute_ctl_put(struct snd_kcontrol *kctl, 4038 struct snd_ctl_elem_value *ucontrol) 4039{ 4040 struct usb_mixer_elem_info *elem = kctl->private_data; 4041 struct usb_mixer_interface *mixer = elem->head.mixer; 4042 struct scarlett2_data *private = mixer->private_data; 4043 int index = line_out_remap(private, elem->control); 4044 int oval, val, err = 0; 4045 4046 mutex_lock(&private->data_mutex); 4047 4048 if (private->hwdep_in_use) { 4049 err = -EBUSY; 4050 goto unlock; 4051 } 4052 4053 oval = private->mute_switch[index]; 4054 val = !!ucontrol->value.integer.value[0]; 4055 4056 if (oval == val) 4057 goto unlock; 4058 4059 private->mute_switch[index] = val; 4060 4061 /* Send mute change to the device */ 4062 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 4063 index, val); 4064 if (err == 0) 4065 err = 1; 4066 4067unlock: 4068 mutex_unlock(&private->data_mutex); 4069 return err; 4070} 4071 4072static const struct snd_kcontrol_new scarlett2_mute_ctl = { 4073 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4074 .name = "", 4075 .info = snd_ctl_boolean_mono_info, 4076 .get = scarlett2_mute_ctl_get, 4077 .put = scarlett2_mute_ctl_put, 4078}; 4079 4080/*** HW/SW Volume Switch Controls ***/ 4081 4082static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index) 4083{ 4084 private->sw_hw_ctls[index]->vd[0].access &= 4085 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 4086} 4087 4088static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index) 4089{ 4090 private->sw_hw_ctls[index]->vd[0].access |= 4091 SNDRV_CTL_ELEM_ACCESS_WRITE; 4092} 4093 4094static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl, 4095 struct snd_ctl_elem_info *uinfo) 4096{ 4097 static const char *const values[2] = { 4098 "SW", "HW" 4099 }; 4100 4101 return snd_ctl_enum_info(uinfo, 1, 2, values); 4102} 4103 4104static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl, 4105 struct snd_ctl_elem_value *ucontrol) 4106{ 4107 struct usb_mixer_elem_info *elem = kctl->private_data; 4108 struct scarlett2_data *private = elem->head.mixer->private_data; 4109 int index = line_out_remap(private, elem->control); 4110 4111 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index]; 4112 return 0; 4113} 4114 4115static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer, 4116 int index, int value) 4117{ 4118 struct scarlett2_data *private = mixer->private_data; 4119 struct snd_card *card = mixer->chip->card; 4120 4121 /* Set/Clear write bits */ 4122 if (value) { 4123 private->vol_ctls[index]->vd[0].access |= 4124 SNDRV_CTL_ELEM_ACCESS_WRITE; 4125 private->mute_ctls[index]->vd[0].access |= 4126 SNDRV_CTL_ELEM_ACCESS_WRITE; 4127 } else { 4128 private->vol_ctls[index]->vd[0].access &= 4129 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 4130 private->mute_ctls[index]->vd[0].access &= 4131 ~SNDRV_CTL_ELEM_ACCESS_WRITE; 4132 } 4133 4134 /* Notify of write bit and possible value change */ 4135 snd_ctl_notify(card, 4136 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 4137 &private->vol_ctls[index]->id); 4138 snd_ctl_notify(card, 4139 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 4140 &private->mute_ctls[index]->id); 4141} 4142 4143static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer, 4144 int ctl_index, int val) 4145{ 4146 struct scarlett2_data *private = mixer->private_data; 4147 int index = line_out_remap(private, ctl_index); 4148 int err; 4149 4150 private->vol_sw_hw_switch[index] = val; 4151 4152 /* Change access mode to RO (hardware controlled volume) 4153 * or RW (software controlled volume) 4154 */ 4155 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val); 4156 4157 /* Reset volume/mute to master volume/mute */ 4158 private->vol[index] = private->master_vol; 4159 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE]; 4160 4161 /* Set SW volume to current HW volume */ 4162 err = scarlett2_usb_set_config( 4163 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 4164 index, private->master_vol - SCARLETT2_VOLUME_BIAS); 4165 if (err < 0) 4166 return err; 4167 4168 /* Set SW mute to current HW mute */ 4169 err = scarlett2_usb_set_config( 4170 mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 4171 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]); 4172 if (err < 0) 4173 return err; 4174 4175 /* Send SW/HW switch change to the device */ 4176 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, 4177 index, val); 4178} 4179 4180static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl, 4181 struct snd_ctl_elem_value *ucontrol) 4182{ 4183 struct usb_mixer_elem_info *elem = kctl->private_data; 4184 struct usb_mixer_interface *mixer = elem->head.mixer; 4185 struct scarlett2_data *private = mixer->private_data; 4186 int ctl_index = elem->control; 4187 int index = line_out_remap(private, ctl_index); 4188 int oval, val, err = 0; 4189 4190 mutex_lock(&private->data_mutex); 4191 4192 if (private->hwdep_in_use) { 4193 err = -EBUSY; 4194 goto unlock; 4195 } 4196 4197 oval = private->vol_sw_hw_switch[index]; 4198 val = !!ucontrol->value.enumerated.item[0]; 4199 4200 if (oval == val) 4201 goto unlock; 4202 4203 err = scarlett2_sw_hw_change(mixer, ctl_index, val); 4204 if (err == 0) 4205 err = 1; 4206 4207unlock: 4208 mutex_unlock(&private->data_mutex); 4209 return err; 4210} 4211 4212static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = { 4213 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4214 .name = "", 4215 .info = scarlett2_sw_hw_enum_ctl_info, 4216 .get = scarlett2_sw_hw_enum_ctl_get, 4217 .put = scarlett2_sw_hw_enum_ctl_put, 4218}; 4219 4220/*** Line Level/Instrument Level Switch Controls ***/ 4221 4222static int scarlett2_update_input_level(struct usb_mixer_interface *mixer) 4223{ 4224 struct scarlett2_data *private = mixer->private_data; 4225 const struct scarlett2_device_info *info = private->info; 4226 4227 private->input_level_updated = 0; 4228 4229 if (!info->level_input_count) 4230 return 0; 4231 4232 return scarlett2_usb_get_config( 4233 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, 4234 info->level_input_count + info->level_input_first, 4235 private->level_switch); 4236} 4237 4238static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl, 4239 struct snd_ctl_elem_info *uinfo) 4240{ 4241 static const char *const values[2] = { 4242 "Line", "Inst" 4243 }; 4244 struct usb_mixer_elem_info *elem = kctl->private_data; 4245 struct usb_mixer_interface *mixer = elem->head.mixer; 4246 struct scarlett2_data *private = mixer->private_data; 4247 int err; 4248 4249 mutex_lock(&private->data_mutex); 4250 4251 if (private->hwdep_in_use) { 4252 err = -EBUSY; 4253 goto unlock; 4254 } 4255 4256 err = scarlett2_check_autogain_updated(mixer); 4257 if (err < 0) 4258 goto unlock; 4259 4260 err = snd_ctl_enum_info(uinfo, 1, 2, values); 4261 4262unlock: 4263 mutex_unlock(&private->data_mutex); 4264 return err; 4265} 4266 4267static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl, 4268 struct snd_ctl_elem_value *ucontrol) 4269{ 4270 struct usb_mixer_elem_info *elem = kctl->private_data; 4271 struct usb_mixer_interface *mixer = elem->head.mixer; 4272 struct scarlett2_data *private = mixer->private_data; 4273 const struct scarlett2_device_info *info = private->info; 4274 4275 int index = elem->control + info->level_input_first; 4276 int err = 0; 4277 4278 mutex_lock(&private->data_mutex); 4279 4280 if (private->hwdep_in_use) { 4281 err = -EBUSY; 4282 goto unlock; 4283 } 4284 4285 if (private->input_level_updated) { 4286 err = scarlett2_update_input_level(mixer); 4287 if (err < 0) 4288 goto unlock; 4289 } 4290 ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable( 4291 private->level_switch[index]); 4292 4293unlock: 4294 mutex_unlock(&private->data_mutex); 4295 return err; 4296} 4297 4298static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl, 4299 struct snd_ctl_elem_value *ucontrol) 4300{ 4301 struct usb_mixer_elem_info *elem = kctl->private_data; 4302 struct usb_mixer_interface *mixer = elem->head.mixer; 4303 struct scarlett2_data *private = mixer->private_data; 4304 const struct scarlett2_device_info *info = private->info; 4305 4306 int index = elem->control + info->level_input_first; 4307 int oval, val, err; 4308 4309 mutex_lock(&private->data_mutex); 4310 4311 if (private->hwdep_in_use) { 4312 err = -EBUSY; 4313 goto unlock; 4314 } 4315 4316 err = scarlett2_check_put_during_autogain(mixer); 4317 if (err < 0) 4318 goto unlock; 4319 4320 oval = private->level_switch[index]; 4321 val = !!ucontrol->value.enumerated.item[0]; 4322 4323 if (oval == val) 4324 goto unlock; 4325 4326 private->level_switch[index] = val; 4327 4328 /* To set the Gen 4 muteable controls, bit 1 gets set instead */ 4329 if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute) 4330 val = (!val) | 0x02; 4331 4332 /* Send switch change to the device */ 4333 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH, 4334 index, val); 4335 if (err == 0) 4336 err = 1; 4337 4338unlock: 4339 mutex_unlock(&private->data_mutex); 4340 return err; 4341} 4342 4343static const struct snd_kcontrol_new scarlett2_level_enum_ctl = { 4344 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4345 .name = "", 4346 .info = scarlett2_level_enum_ctl_info, 4347 .get = scarlett2_level_enum_ctl_get, 4348 .put = scarlett2_level_enum_ctl_put, 4349}; 4350 4351/*** Pad Switch Controls ***/ 4352 4353static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer) 4354{ 4355 struct scarlett2_data *private = mixer->private_data; 4356 const struct scarlett2_device_info *info = private->info; 4357 4358 private->input_pad_updated = 0; 4359 4360 if (!info->pad_input_count) 4361 return 0; 4362 4363 return scarlett2_usb_get_config( 4364 mixer, SCARLETT2_CONFIG_PAD_SWITCH, 4365 info->pad_input_count, private->pad_switch); 4366} 4367 4368static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl, 4369 struct snd_ctl_elem_value *ucontrol) 4370{ 4371 struct usb_mixer_elem_info *elem = kctl->private_data; 4372 struct usb_mixer_interface *mixer = elem->head.mixer; 4373 struct scarlett2_data *private = mixer->private_data; 4374 int err = 0; 4375 4376 mutex_lock(&private->data_mutex); 4377 4378 if (private->hwdep_in_use) { 4379 err = -EBUSY; 4380 goto unlock; 4381 } 4382 4383 if (private->input_pad_updated) { 4384 err = scarlett2_update_input_pad(mixer); 4385 if (err < 0) 4386 goto unlock; 4387 } 4388 ucontrol->value.integer.value[0] = 4389 private->pad_switch[elem->control]; 4390 4391unlock: 4392 mutex_unlock(&private->data_mutex); 4393 return err; 4394} 4395 4396static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl, 4397 struct snd_ctl_elem_value *ucontrol) 4398{ 4399 struct usb_mixer_elem_info *elem = kctl->private_data; 4400 struct usb_mixer_interface *mixer = elem->head.mixer; 4401 struct scarlett2_data *private = mixer->private_data; 4402 4403 int index = elem->control; 4404 int oval, val, err = 0; 4405 4406 mutex_lock(&private->data_mutex); 4407 4408 if (private->hwdep_in_use) { 4409 err = -EBUSY; 4410 goto unlock; 4411 } 4412 4413 oval = private->pad_switch[index]; 4414 val = !!ucontrol->value.integer.value[0]; 4415 4416 if (oval == val) 4417 goto unlock; 4418 4419 private->pad_switch[index] = val; 4420 4421 /* Send switch change to the device */ 4422 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH, 4423 index, val); 4424 if (err == 0) 4425 err = 1; 4426 4427unlock: 4428 mutex_unlock(&private->data_mutex); 4429 return err; 4430} 4431 4432static const struct snd_kcontrol_new scarlett2_pad_ctl = { 4433 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4434 .name = "", 4435 .info = snd_ctl_boolean_mono_info, 4436 .get = scarlett2_pad_ctl_get, 4437 .put = scarlett2_pad_ctl_put, 4438}; 4439 4440/*** Air Switch Controls ***/ 4441 4442static int scarlett2_update_input_air(struct usb_mixer_interface *mixer) 4443{ 4444 struct scarlett2_data *private = mixer->private_data; 4445 const struct scarlett2_device_info *info = private->info; 4446 4447 private->input_air_updated = 0; 4448 4449 if (!info->air_input_count) 4450 return 0; 4451 4452 return scarlett2_usb_get_config( 4453 mixer, SCARLETT2_CONFIG_AIR_SWITCH, 4454 info->air_input_count, private->air_switch); 4455} 4456 4457static int scarlett2_air_ctl_get(struct snd_kcontrol *kctl, 4458 struct snd_ctl_elem_value *ucontrol) 4459{ 4460 struct usb_mixer_elem_info *elem = kctl->private_data; 4461 struct usb_mixer_interface *mixer = elem->head.mixer; 4462 struct scarlett2_data *private = mixer->private_data; 4463 int err = 0; 4464 4465 mutex_lock(&private->data_mutex); 4466 4467 if (private->hwdep_in_use) { 4468 err = -EBUSY; 4469 goto unlock; 4470 } 4471 4472 if (private->input_air_updated) { 4473 err = scarlett2_update_input_air(mixer); 4474 if (err < 0) 4475 goto unlock; 4476 } 4477 ucontrol->value.integer.value[0] = private->air_switch[elem->control]; 4478 4479unlock: 4480 mutex_unlock(&private->data_mutex); 4481 return err; 4482} 4483 4484static int scarlett2_air_ctl_put(struct snd_kcontrol *kctl, 4485 struct snd_ctl_elem_value *ucontrol) 4486{ 4487 struct usb_mixer_elem_info *elem = kctl->private_data; 4488 struct usb_mixer_interface *mixer = elem->head.mixer; 4489 struct scarlett2_data *private = mixer->private_data; 4490 4491 int index = elem->control; 4492 int oval, val, err; 4493 4494 mutex_lock(&private->data_mutex); 4495 4496 if (private->hwdep_in_use) { 4497 err = -EBUSY; 4498 goto unlock; 4499 } 4500 4501 err = scarlett2_check_put_during_autogain(mixer); 4502 if (err < 0) 4503 goto unlock; 4504 4505 oval = private->air_switch[index]; 4506 val = ucontrol->value.integer.value[0]; 4507 4508 if (oval == val) 4509 goto unlock; 4510 4511 private->air_switch[index] = val; 4512 4513 /* Send switch change to the device */ 4514 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH, 4515 index, val); 4516 if (err == 0) 4517 err = 1; 4518 4519unlock: 4520 mutex_unlock(&private->data_mutex); 4521 return err; 4522} 4523 4524static int scarlett2_air_with_drive_ctl_info( 4525 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 4526{ 4527 static const char *const values[3] = { 4528 "Off", "Presence", "Presence + Drive" 4529 }; 4530 struct usb_mixer_elem_info *elem = kctl->private_data; 4531 struct usb_mixer_interface *mixer = elem->head.mixer; 4532 struct scarlett2_data *private = mixer->private_data; 4533 int err; 4534 4535 mutex_lock(&private->data_mutex); 4536 4537 if (private->hwdep_in_use) { 4538 err = -EBUSY; 4539 goto unlock; 4540 } 4541 4542 err = scarlett2_check_autogain_updated(mixer); 4543 if (err < 0) 4544 goto unlock; 4545 4546 err = snd_ctl_enum_info(uinfo, 1, 3, values); 4547 4548unlock: 4549 mutex_unlock(&private->data_mutex); 4550 return err; 4551} 4552 4553static const struct snd_kcontrol_new scarlett2_air_ctl[2] = { 4554 { 4555 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4556 .name = "", 4557 .info = snd_ctl_boolean_mono_info, 4558 .get = scarlett2_air_ctl_get, 4559 .put = scarlett2_air_ctl_put, 4560 }, 4561 { 4562 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4563 .name = "", 4564 .info = scarlett2_air_with_drive_ctl_info, 4565 .get = scarlett2_air_ctl_get, 4566 .put = scarlett2_air_ctl_put, 4567 } 4568}; 4569 4570/*** Phantom Switch Controls ***/ 4571 4572static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer) 4573{ 4574 struct scarlett2_data *private = mixer->private_data; 4575 const struct scarlett2_device_info *info = private->info; 4576 int err; 4577 4578 private->input_phantom_updated = 0; 4579 4580 if (!info->phantom_count) 4581 return 0; 4582 4583 err = scarlett2_usb_get_config( 4584 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 4585 info->phantom_count, private->phantom_switch); 4586 if (err < 0) 4587 return err; 4588 4589 if (scarlett2_has_config_item(private, 4590 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) { 4591 err = scarlett2_usb_get_config( 4592 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, 4593 1, &private->phantom_persistence); 4594 if (err < 0) 4595 return err; 4596 } 4597 4598 return 0; 4599} 4600 4601/* Check if phantom power on the given input is currently changing state */ 4602static int scarlett2_phantom_is_switching( 4603 struct scarlett2_data *private, int line_num) 4604{ 4605 const struct scarlett2_device_info *info = private->info; 4606 int index = line_num / info->inputs_per_phantom; 4607 4608 return !!(private->phantom_switch[index] & 0x02); 4609} 4610 4611/* Update autogain controls' access mode when phantom power changes state */ 4612static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer) 4613{ 4614 struct scarlett2_data *private = mixer->private_data; 4615 const struct scarlett2_device_info *info = private->info; 4616 int i; 4617 4618 /* Disable autogain controls if phantom power is changing state */ 4619 for (i = 0; i < info->gain_input_count; i++) { 4620 int val = !scarlett2_phantom_is_switching(private, i); 4621 4622 scarlett2_set_ctl_access(private->autogain_ctls[i], val); 4623 } 4624} 4625 4626/* Notify of access mode change for autogain which can't be enabled 4627 * while phantom power is changing. 4628 */ 4629static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer) 4630{ 4631 struct snd_card *card = mixer->chip->card; 4632 struct scarlett2_data *private = mixer->private_data; 4633 const struct scarlett2_device_info *info = private->info; 4634 int i; 4635 4636 for (i = 0; i < info->gain_input_count; i++) 4637 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 4638 &private->autogain_ctls[i]->id); 4639} 4640 4641/* Call scarlett2_update_input_phantom() and 4642 * scarlett2_phantom_update_access() if input_phantom_updated is set. 4643 */ 4644static int scarlett2_check_input_phantom_updated( 4645 struct usb_mixer_interface *mixer) 4646{ 4647 struct scarlett2_data *private = mixer->private_data; 4648 int err; 4649 4650 if (!private->input_phantom_updated) 4651 return 0; 4652 4653 err = scarlett2_update_input_phantom(mixer); 4654 if (err < 0) 4655 return err; 4656 4657 scarlett2_phantom_update_access(mixer); 4658 4659 return 0; 4660} 4661 4662static int scarlett2_phantom_ctl_get(struct snd_kcontrol *kctl, 4663 struct snd_ctl_elem_value *ucontrol) 4664{ 4665 struct usb_mixer_elem_info *elem = kctl->private_data; 4666 struct usb_mixer_interface *mixer = elem->head.mixer; 4667 struct scarlett2_data *private = mixer->private_data; 4668 int err; 4669 4670 mutex_lock(&private->data_mutex); 4671 4672 if (private->hwdep_in_use) { 4673 err = -EBUSY; 4674 goto unlock; 4675 } 4676 4677 err = scarlett2_check_input_phantom_updated(mixer); 4678 if (err < 0) 4679 goto unlock; 4680 4681 ucontrol->value.integer.value[0] = scarlett2_decode_muteable( 4682 private->phantom_switch[elem->control]); 4683 4684unlock: 4685 mutex_unlock(&private->data_mutex); 4686 return err; 4687} 4688 4689static int scarlett2_phantom_ctl_put(struct snd_kcontrol *kctl, 4690 struct snd_ctl_elem_value *ucontrol) 4691{ 4692 struct usb_mixer_elem_info *elem = kctl->private_data; 4693 struct usb_mixer_interface *mixer = elem->head.mixer; 4694 struct scarlett2_data *private = mixer->private_data; 4695 const struct scarlett2_device_info *info = private->info; 4696 4697 int index = elem->control; 4698 int oval, val, err; 4699 4700 mutex_lock(&private->data_mutex); 4701 4702 if (private->hwdep_in_use) { 4703 err = -EBUSY; 4704 goto unlock; 4705 } 4706 4707 err = scarlett2_check_put_during_autogain(mixer); 4708 if (err < 0) 4709 goto unlock; 4710 4711 oval = private->phantom_switch[index]; 4712 val = !!ucontrol->value.integer.value[0]; 4713 4714 if (oval == val) 4715 goto unlock; 4716 4717 private->phantom_switch[index] = val; 4718 4719 /* To set the Gen 4 muteable controls, bit 1 gets set */ 4720 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute) 4721 val = (!val) | 0x02; 4722 4723 /* Send switch change to the device */ 4724 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH, 4725 index + info->phantom_first, val); 4726 if (err == 0) 4727 err = 1; 4728 4729 scarlett2_phantom_update_access(mixer); 4730 scarlett2_phantom_notify_access(mixer); 4731 4732unlock: 4733 mutex_unlock(&private->data_mutex); 4734 return err; 4735} 4736 4737static const struct snd_kcontrol_new scarlett2_phantom_ctl = { 4738 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4739 .name = "", 4740 .info = scarlett2_autogain_disables_ctl_info, 4741 .get = scarlett2_phantom_ctl_get, 4742 .put = scarlett2_phantom_ctl_put, 4743}; 4744 4745/*** Phantom Persistence Control ***/ 4746 4747static int scarlett2_phantom_persistence_ctl_get( 4748 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 4749{ 4750 struct usb_mixer_elem_info *elem = kctl->private_data; 4751 struct scarlett2_data *private = elem->head.mixer->private_data; 4752 4753 ucontrol->value.integer.value[0] = private->phantom_persistence; 4754 return 0; 4755} 4756 4757static int scarlett2_phantom_persistence_ctl_put( 4758 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 4759{ 4760 struct usb_mixer_elem_info *elem = kctl->private_data; 4761 struct usb_mixer_interface *mixer = elem->head.mixer; 4762 struct scarlett2_data *private = mixer->private_data; 4763 4764 int index = elem->control; 4765 int oval, val, err = 0; 4766 4767 mutex_lock(&private->data_mutex); 4768 4769 if (private->hwdep_in_use) { 4770 err = -EBUSY; 4771 goto unlock; 4772 } 4773 4774 oval = private->phantom_persistence; 4775 val = !!ucontrol->value.integer.value[0]; 4776 4777 if (oval == val) 4778 goto unlock; 4779 4780 private->phantom_persistence = val; 4781 4782 /* Send switch change to the device */ 4783 err = scarlett2_usb_set_config( 4784 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val); 4785 if (err == 0) 4786 err = 1; 4787 4788unlock: 4789 mutex_unlock(&private->data_mutex); 4790 return err; 4791} 4792 4793static const struct snd_kcontrol_new scarlett2_phantom_persistence_ctl = { 4794 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4795 .name = "", 4796 .info = snd_ctl_boolean_mono_info, 4797 .get = scarlett2_phantom_persistence_ctl_get, 4798 .put = scarlett2_phantom_persistence_ctl_put, 4799}; 4800 4801/*** Speaker Switching Control ***/ 4802 4803static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer) 4804{ 4805 struct scarlett2_data *private = mixer->private_data; 4806 const struct scarlett2_device_info *info = private->info; 4807 int err; 4808 4809 /* monitor_other_enable[0] enables speaker switching 4810 * monitor_other_enable[1] enables talkback 4811 */ 4812 u8 monitor_other_enable[2]; 4813 4814 /* monitor_other_switch[0] activates the alternate speakers 4815 * monitor_other_switch[1] activates talkback 4816 */ 4817 u8 monitor_other_switch[2]; 4818 4819 private->monitor_other_updated = 0; 4820 4821 /* if it doesn't do speaker switching then it also doesn't do 4822 * talkback 4823 */ 4824 if (!info->has_speaker_switching) 4825 return 0; 4826 4827 err = scarlett2_usb_get_config( 4828 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 4829 2, monitor_other_enable); 4830 if (err < 0) 4831 return err; 4832 4833 err = scarlett2_usb_get_config( 4834 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 4835 2, monitor_other_switch); 4836 if (err < 0) 4837 return err; 4838 4839 if (!monitor_other_enable[0]) 4840 private->speaker_switching_switch = 0; 4841 else 4842 private->speaker_switching_switch = monitor_other_switch[0] + 1; 4843 4844 if (info->has_talkback) { 4845 u16 bitmap; 4846 int i; 4847 4848 if (!monitor_other_enable[1]) 4849 private->talkback_switch = 0; 4850 else 4851 private->talkback_switch = monitor_other_switch[1] + 1; 4852 4853 err = scarlett2_usb_get_config(mixer, 4854 SCARLETT2_CONFIG_TALKBACK_MAP, 4855 1, &bitmap); 4856 if (err < 0) 4857 return err; 4858 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1) 4859 private->talkback_map[i] = bitmap & 1; 4860 } 4861 4862 return 0; 4863} 4864 4865static int scarlett2_speaker_switch_enum_ctl_info( 4866 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 4867{ 4868 static const char *const values[3] = { 4869 "Off", "Main", "Alt" 4870 }; 4871 4872 return snd_ctl_enum_info(uinfo, 1, 3, values); 4873} 4874 4875static int scarlett2_speaker_switch_enum_ctl_get( 4876 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 4877{ 4878 struct usb_mixer_elem_info *elem = kctl->private_data; 4879 struct usb_mixer_interface *mixer = elem->head.mixer; 4880 struct scarlett2_data *private = mixer->private_data; 4881 int err = 0; 4882 4883 mutex_lock(&private->data_mutex); 4884 4885 if (private->hwdep_in_use) { 4886 err = -EBUSY; 4887 goto unlock; 4888 } 4889 4890 if (private->monitor_other_updated) { 4891 err = scarlett2_update_monitor_other(mixer); 4892 if (err < 0) 4893 goto unlock; 4894 } 4895 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch; 4896 4897unlock: 4898 mutex_unlock(&private->data_mutex); 4899 return err; 4900} 4901 4902/* when speaker switching gets enabled, switch the main/alt speakers 4903 * to HW volume and disable those controls 4904 */ 4905static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer) 4906{ 4907 struct snd_card *card = mixer->chip->card; 4908 struct scarlett2_data *private = mixer->private_data; 4909 int i, err; 4910 4911 for (i = 0; i < 4; i++) { 4912 int index = line_out_remap(private, i); 4913 4914 /* switch the main/alt speakers to HW volume */ 4915 if (!private->vol_sw_hw_switch[index]) { 4916 err = scarlett2_sw_hw_change(private->mixer, i, 1); 4917 if (err < 0) 4918 return err; 4919 } 4920 4921 /* disable the line out SW/HW switch */ 4922 scarlett2_sw_hw_ctl_ro(private, i); 4923 snd_ctl_notify(card, 4924 SNDRV_CTL_EVENT_MASK_VALUE | 4925 SNDRV_CTL_EVENT_MASK_INFO, 4926 &private->sw_hw_ctls[i]->id); 4927 } 4928 4929 /* when the next monitor-other notify comes in, update the mux 4930 * configuration 4931 */ 4932 private->speaker_switching_switched = 1; 4933 4934 return 0; 4935} 4936 4937/* when speaker switching gets disabled, reenable the hw/sw controls 4938 * and invalidate the routing 4939 */ 4940static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer) 4941{ 4942 struct snd_card *card = mixer->chip->card; 4943 struct scarlett2_data *private = mixer->private_data; 4944 int i; 4945 4946 /* enable the line out SW/HW switch */ 4947 for (i = 0; i < 4; i++) { 4948 scarlett2_sw_hw_ctl_rw(private, i); 4949 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_INFO, 4950 &private->sw_hw_ctls[i]->id); 4951 } 4952 4953 /* when the next monitor-other notify comes in, update the mux 4954 * configuration 4955 */ 4956 private->speaker_switching_switched = 1; 4957} 4958 4959static int scarlett2_speaker_switch_enum_ctl_put( 4960 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 4961{ 4962 struct usb_mixer_elem_info *elem = kctl->private_data; 4963 struct usb_mixer_interface *mixer = elem->head.mixer; 4964 struct scarlett2_data *private = mixer->private_data; 4965 4966 int oval, val, err = 0; 4967 4968 mutex_lock(&private->data_mutex); 4969 4970 if (private->hwdep_in_use) { 4971 err = -EBUSY; 4972 goto unlock; 4973 } 4974 4975 oval = private->speaker_switching_switch; 4976 val = min(ucontrol->value.enumerated.item[0], 2U); 4977 4978 if (oval == val) 4979 goto unlock; 4980 4981 private->speaker_switching_switch = val; 4982 4983 /* enable/disable speaker switching */ 4984 err = scarlett2_usb_set_config( 4985 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 4986 0, !!val); 4987 if (err < 0) 4988 goto unlock; 4989 4990 /* if speaker switching is enabled, select main or alt */ 4991 err = scarlett2_usb_set_config( 4992 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 4993 0, val == 2); 4994 if (err < 0) 4995 goto unlock; 4996 4997 /* update controls if speaker switching gets enabled or disabled */ 4998 if (!oval && val) 4999 err = scarlett2_speaker_switch_enable(mixer); 5000 else if (oval && !val) 5001 scarlett2_speaker_switch_disable(mixer); 5002 5003 if (err == 0) 5004 err = 1; 5005 5006unlock: 5007 mutex_unlock(&private->data_mutex); 5008 return err; 5009} 5010 5011static const struct snd_kcontrol_new scarlett2_speaker_switch_enum_ctl = { 5012 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5013 .name = "", 5014 .info = scarlett2_speaker_switch_enum_ctl_info, 5015 .get = scarlett2_speaker_switch_enum_ctl_get, 5016 .put = scarlett2_speaker_switch_enum_ctl_put, 5017}; 5018 5019static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer) 5020{ 5021 struct scarlett2_data *private = mixer->private_data; 5022 const struct scarlett2_device_info *info = private->info; 5023 5024 if (!info->has_speaker_switching) 5025 return 0; 5026 5027 return scarlett2_add_new_ctl( 5028 mixer, &scarlett2_speaker_switch_enum_ctl, 5029 0, 1, "Speaker Switching Playback Enum", 5030 &private->speaker_switching_ctl); 5031} 5032 5033/*** Talkback and Talkback Map Controls ***/ 5034 5035static int scarlett2_talkback_enum_ctl_info( 5036 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 5037{ 5038 static const char *const values[3] = { 5039 "Disabled", "Off", "On" 5040 }; 5041 5042 return snd_ctl_enum_info(uinfo, 1, 3, values); 5043} 5044 5045static int scarlett2_talkback_enum_ctl_get( 5046 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5047{ 5048 struct usb_mixer_elem_info *elem = kctl->private_data; 5049 struct usb_mixer_interface *mixer = elem->head.mixer; 5050 struct scarlett2_data *private = mixer->private_data; 5051 int err = 0; 5052 5053 mutex_lock(&private->data_mutex); 5054 5055 if (private->hwdep_in_use) { 5056 err = -EBUSY; 5057 goto unlock; 5058 } 5059 5060 if (private->monitor_other_updated) { 5061 err = scarlett2_update_monitor_other(mixer); 5062 if (err < 0) 5063 goto unlock; 5064 } 5065 ucontrol->value.enumerated.item[0] = private->talkback_switch; 5066 5067unlock: 5068 mutex_unlock(&private->data_mutex); 5069 return err; 5070} 5071 5072static int scarlett2_talkback_enum_ctl_put( 5073 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5074{ 5075 struct usb_mixer_elem_info *elem = kctl->private_data; 5076 struct usb_mixer_interface *mixer = elem->head.mixer; 5077 struct scarlett2_data *private = mixer->private_data; 5078 5079 int oval, val, err = 0; 5080 5081 mutex_lock(&private->data_mutex); 5082 5083 if (private->hwdep_in_use) { 5084 err = -EBUSY; 5085 goto unlock; 5086 } 5087 5088 oval = private->talkback_switch; 5089 val = min(ucontrol->value.enumerated.item[0], 2U); 5090 5091 if (oval == val) 5092 goto unlock; 5093 5094 private->talkback_switch = val; 5095 5096 /* enable/disable talkback */ 5097 err = scarlett2_usb_set_config( 5098 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE, 5099 1, !!val); 5100 if (err < 0) 5101 goto unlock; 5102 5103 /* if talkback is enabled, select main or alt */ 5104 err = scarlett2_usb_set_config( 5105 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH, 5106 1, val == 2); 5107 if (err == 0) 5108 err = 1; 5109 5110unlock: 5111 mutex_unlock(&private->data_mutex); 5112 return err; 5113} 5114 5115static const struct snd_kcontrol_new scarlett2_talkback_enum_ctl = { 5116 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5117 .name = "", 5118 .info = scarlett2_talkback_enum_ctl_info, 5119 .get = scarlett2_talkback_enum_ctl_get, 5120 .put = scarlett2_talkback_enum_ctl_put, 5121}; 5122 5123static int scarlett2_talkback_map_ctl_get( 5124 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5125{ 5126 struct usb_mixer_elem_info *elem = kctl->private_data; 5127 struct usb_mixer_interface *mixer = elem->head.mixer; 5128 struct scarlett2_data *private = mixer->private_data; 5129 int index = elem->control; 5130 5131 ucontrol->value.integer.value[0] = private->talkback_map[index]; 5132 5133 return 0; 5134} 5135 5136static int scarlett2_talkback_map_ctl_put( 5137 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5138{ 5139 struct usb_mixer_elem_info *elem = kctl->private_data; 5140 struct usb_mixer_interface *mixer = elem->head.mixer; 5141 struct scarlett2_data *private = mixer->private_data; 5142 int index = elem->control; 5143 int oval, val, err = 0, i; 5144 u16 bitmap = 0; 5145 5146 mutex_lock(&private->data_mutex); 5147 5148 if (private->hwdep_in_use) { 5149 err = -EBUSY; 5150 goto unlock; 5151 } 5152 5153 oval = private->talkback_map[index]; 5154 val = !!ucontrol->value.integer.value[0]; 5155 5156 if (oval == val) 5157 goto unlock; 5158 5159 private->talkback_map[index] = val; 5160 5161 for (i = 0; i < private->num_mix_out; i++) 5162 bitmap |= private->talkback_map[i] << i; 5163 5164 /* Send updated bitmap to the device */ 5165 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP, 5166 0, bitmap); 5167 if (err == 0) 5168 err = 1; 5169 5170unlock: 5171 mutex_unlock(&private->data_mutex); 5172 return err; 5173} 5174 5175static const struct snd_kcontrol_new scarlett2_talkback_map_ctl = { 5176 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5177 .name = "", 5178 .info = snd_ctl_boolean_mono_info, 5179 .get = scarlett2_talkback_map_ctl_get, 5180 .put = scarlett2_talkback_map_ctl_put, 5181}; 5182 5183static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer) 5184{ 5185 struct scarlett2_data *private = mixer->private_data; 5186 const struct scarlett2_device_info *info = private->info; 5187 int err, i; 5188 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 5189 5190 if (!info->has_talkback) 5191 return 0; 5192 5193 err = scarlett2_add_new_ctl( 5194 mixer, &scarlett2_talkback_enum_ctl, 5195 0, 1, "Talkback Playback Enum", 5196 &private->talkback_ctl); 5197 if (err < 0) 5198 return err; 5199 5200 for (i = 0; i < private->num_mix_out; i++) { 5201 snprintf(s, sizeof(s), 5202 "Talkback Mix %c Playback Switch", i + 'A'); 5203 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl, 5204 i, 1, s, NULL); 5205 if (err < 0) 5206 return err; 5207 } 5208 5209 return 0; 5210} 5211 5212/*** Dim/Mute Controls ***/ 5213 5214static int scarlett2_dim_mute_ctl_get(struct snd_kcontrol *kctl, 5215 struct snd_ctl_elem_value *ucontrol) 5216{ 5217 struct usb_mixer_elem_info *elem = kctl->private_data; 5218 struct usb_mixer_interface *mixer = elem->head.mixer; 5219 struct scarlett2_data *private = mixer->private_data; 5220 int err = 0; 5221 5222 mutex_lock(&private->data_mutex); 5223 5224 if (private->hwdep_in_use) { 5225 err = -EBUSY; 5226 goto unlock; 5227 } 5228 5229 if (private->dim_mute_updated) { 5230 err = scarlett2_update_dim_mute(mixer); 5231 if (err < 0) 5232 goto unlock; 5233 } 5234 ucontrol->value.integer.value[0] = private->dim_mute[elem->control]; 5235 5236unlock: 5237 mutex_unlock(&private->data_mutex); 5238 return err; 5239} 5240 5241static int scarlett2_dim_mute_ctl_put(struct snd_kcontrol *kctl, 5242 struct snd_ctl_elem_value *ucontrol) 5243{ 5244 struct usb_mixer_elem_info *elem = kctl->private_data; 5245 struct usb_mixer_interface *mixer = elem->head.mixer; 5246 struct scarlett2_data *private = mixer->private_data; 5247 int index = elem->control; 5248 int oval, val, err = 0, i; 5249 5250 mutex_lock(&private->data_mutex); 5251 5252 if (private->hwdep_in_use) { 5253 err = -EBUSY; 5254 goto unlock; 5255 } 5256 5257 oval = private->dim_mute[index]; 5258 val = !!ucontrol->value.integer.value[0]; 5259 5260 if (oval == val) 5261 goto unlock; 5262 5263 private->dim_mute[index] = val; 5264 5265 /* Send switch change to the device */ 5266 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE, 5267 index, val); 5268 if (err == 0) 5269 err = 1; 5270 5271 if (index == SCARLETT2_BUTTON_MUTE) 5272 for (i = 0; i < private->num_line_out; i++) { 5273 int line_index = line_out_remap(private, i); 5274 5275 if (private->vol_sw_hw_switch[line_index]) { 5276 private->mute_switch[line_index] = val; 5277 snd_ctl_notify(mixer->chip->card, 5278 SNDRV_CTL_EVENT_MASK_VALUE, 5279 &private->mute_ctls[i]->id); 5280 } 5281 } 5282 5283unlock: 5284 mutex_unlock(&private->data_mutex); 5285 return err; 5286} 5287 5288static const struct snd_kcontrol_new scarlett2_dim_mute_ctl = { 5289 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5290 .name = "", 5291 .info = snd_ctl_boolean_mono_info, 5292 .get = scarlett2_dim_mute_ctl_get, 5293 .put = scarlett2_dim_mute_ctl_put 5294}; 5295 5296/*** Create the analogue output controls ***/ 5297 5298static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer) 5299{ 5300 struct scarlett2_data *private = mixer->private_data; 5301 const struct scarlett2_device_info *info = private->info; 5302 int err, i; 5303 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 5304 5305 /* Add R/O HW volume control */ 5306 if (scarlett2_has_config_item(private, 5307 SCARLETT2_CONFIG_MASTER_VOLUME)) { 5308 snprintf(s, sizeof(s), "Master HW Playback Volume"); 5309 err = scarlett2_add_new_ctl(mixer, 5310 &scarlett2_master_volume_ctl, 5311 0, 1, s, &private->master_vol_ctl); 5312 if (err < 0) 5313 return err; 5314 } 5315 5316 /* Add R/O headphone volume control */ 5317 if (scarlett2_has_config_item(private, 5318 SCARLETT2_CONFIG_HEADPHONE_VOLUME)) { 5319 snprintf(s, sizeof(s), "Headphone Playback Volume"); 5320 err = scarlett2_add_new_ctl(mixer, 5321 &scarlett2_headphone_volume_ctl, 5322 0, 1, s, 5323 &private->headphone_vol_ctl); 5324 if (err < 0) 5325 return err; 5326 } 5327 5328 /* Remaining controls are only applicable if the device 5329 * has per-channel line-out volume controls. 5330 */ 5331 if (!scarlett2_has_config_item(private, 5332 SCARLETT2_CONFIG_LINE_OUT_VOLUME)) 5333 return 0; 5334 5335 /* Add volume controls */ 5336 for (i = 0; i < private->num_line_out; i++) { 5337 int index = line_out_remap(private, i); 5338 5339 /* Fader */ 5340 if (info->line_out_descrs[i]) 5341 snprintf(s, sizeof(s), 5342 "Line %02d (%s) Playback Volume", 5343 i + 1, info->line_out_descrs[i]); 5344 else 5345 snprintf(s, sizeof(s), 5346 "Line %02d Playback Volume", 5347 i + 1); 5348 err = scarlett2_add_new_ctl(mixer, 5349 &scarlett2_line_out_volume_ctl, 5350 i, 1, s, &private->vol_ctls[i]); 5351 if (err < 0) 5352 return err; 5353 5354 /* Mute Switch */ 5355 snprintf(s, sizeof(s), 5356 "Line %02d Mute Playback Switch", 5357 i + 1); 5358 err = scarlett2_add_new_ctl(mixer, 5359 &scarlett2_mute_ctl, 5360 i, 1, s, 5361 &private->mute_ctls[i]); 5362 if (err < 0) 5363 return err; 5364 5365 /* SW/HW Switch */ 5366 if (scarlett2_has_config_item(private, 5367 SCARLETT2_CONFIG_SW_HW_SWITCH)) { 5368 5369 /* Make the fader and mute controls read-only if the 5370 * SW/HW switch is set to HW 5371 */ 5372 if (private->vol_sw_hw_switch[index]) 5373 scarlett2_vol_ctl_set_writable(mixer, i, 0); 5374 5375 scnprintf(s, sizeof(s), 5376 "Line Out %02d Volume Control Playback Enum", 5377 i + 1); 5378 err = scarlett2_add_new_ctl(mixer, 5379 &scarlett2_sw_hw_enum_ctl, 5380 i, 1, s, 5381 &private->sw_hw_ctls[i]); 5382 if (err < 0) 5383 return err; 5384 5385 /* Make the switch read-only if the line is 5386 * involved in speaker switching 5387 */ 5388 if (private->speaker_switching_switch && i < 4) 5389 scarlett2_sw_hw_ctl_ro(private, i); 5390 } 5391 } 5392 5393 /* Add dim/mute controls */ 5394 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_DIM_MUTE)) 5395 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) { 5396 err = scarlett2_add_new_ctl( 5397 mixer, &scarlett2_dim_mute_ctl, 5398 i, 1, scarlett2_dim_mute_names[i], 5399 &private->dim_mute_ctls[i]); 5400 if (err < 0) 5401 return err; 5402 } 5403 5404 return 0; 5405} 5406 5407/*** Create the analogue input controls ***/ 5408 5409static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer) 5410{ 5411 struct scarlett2_data *private = mixer->private_data; 5412 const struct scarlett2_device_info *info = private->info; 5413 int err, i; 5414 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 5415 const char *fmt = "Line In %d %s Capture %s"; 5416 const char *fmt2 = "Line In %d-%d %s Capture %s"; 5417 5418 /* Add input level (line/inst) controls */ 5419 for (i = 0; i < info->level_input_count; i++) { 5420 scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first, 5421 "Level", "Enum"); 5422 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl, 5423 i, 1, s, &private->level_ctls[i]); 5424 if (err < 0) 5425 return err; 5426 } 5427 5428 /* Add input pad controls */ 5429 for (i = 0; i < info->pad_input_count; i++) { 5430 scnprintf(s, sizeof(s), fmt, i + 1, "Pad", "Switch"); 5431 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl, 5432 i, 1, s, &private->pad_ctls[i]); 5433 if (err < 0) 5434 return err; 5435 } 5436 5437 /* Add input air controls */ 5438 for (i = 0; i < info->air_input_count; i++) { 5439 scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first, 5440 "Air", info->air_option ? "Enum" : "Switch"); 5441 err = scarlett2_add_new_ctl( 5442 mixer, &scarlett2_air_ctl[info->air_option], 5443 i, 1, s, &private->air_ctls[i]); 5444 if (err < 0) 5445 return err; 5446 } 5447 5448 /* Add input phantom controls */ 5449 if (info->inputs_per_phantom == 1) { 5450 for (i = 0; i < info->phantom_count; i++) { 5451 scnprintf(s, sizeof(s), fmt, 5452 i + 1 + info->phantom_first, 5453 "Phantom Power", "Switch"); 5454 err = scarlett2_add_new_ctl( 5455 mixer, &scarlett2_phantom_ctl, 5456 i, 1, s, &private->phantom_ctls[i]); 5457 if (err < 0) 5458 return err; 5459 } 5460 } else if (info->inputs_per_phantom > 1) { 5461 for (i = 0; i < info->phantom_count; i++) { 5462 int from = i * info->inputs_per_phantom + 1; 5463 int to = (i + 1) * info->inputs_per_phantom; 5464 5465 scnprintf(s, sizeof(s), fmt2, from, to, 5466 "Phantom Power", "Switch"); 5467 err = scarlett2_add_new_ctl( 5468 mixer, &scarlett2_phantom_ctl, 5469 i, 1, s, &private->phantom_ctls[i]); 5470 if (err < 0) 5471 return err; 5472 } 5473 } 5474 if (info->phantom_count && 5475 scarlett2_has_config_item(private, 5476 SCARLETT2_CONFIG_PHANTOM_PERSISTENCE)) { 5477 err = scarlett2_add_new_ctl( 5478 mixer, &scarlett2_phantom_persistence_ctl, 0, 1, 5479 "Phantom Power Persistence Capture Switch", NULL); 5480 if (err < 0) 5481 return err; 5482 } 5483 5484 /* Add software-controllable input gain controls */ 5485 if (info->gain_input_count) { 5486 err = scarlett2_add_new_ctl( 5487 mixer, &scarlett2_input_select_ctl, 0, 1, 5488 "Input Select Capture Enum", 5489 &private->input_select_ctl); 5490 if (err < 0) 5491 return err; 5492 5493 for (i = 0; i < info->gain_input_count; i++) { 5494 if (i % 2) { 5495 scnprintf(s, sizeof(s), 5496 "Line In %d-%d Link Capture Switch", 5497 i, i + 1); 5498 err = scarlett2_add_new_ctl( 5499 mixer, &scarlett2_input_link_ctl, 5500 i / 2, 1, s, 5501 &private->input_link_ctls[i / 2]); 5502 if (err < 0) 5503 return err; 5504 } 5505 5506 scnprintf(s, sizeof(s), fmt, i + 1, 5507 "Gain", "Volume"); 5508 err = scarlett2_add_new_ctl( 5509 mixer, &scarlett2_input_gain_ctl, 5510 i, 1, s, &private->input_gain_ctls[i]); 5511 if (err < 0) 5512 return err; 5513 5514 scnprintf(s, sizeof(s), fmt, i + 1, 5515 "Autogain", "Switch"); 5516 err = scarlett2_add_new_ctl( 5517 mixer, &scarlett2_autogain_switch_ctl, 5518 i, 1, s, &private->autogain_ctls[i]); 5519 if (err < 0) 5520 return err; 5521 5522 scnprintf(s, sizeof(s), fmt, i + 1, 5523 "Autogain Status", "Enum"); 5524 err = scarlett2_add_new_ctl( 5525 mixer, &scarlett2_autogain_status_ctl, 5526 i, 1, s, &private->autogain_status_ctls[i]); 5527 5528 scnprintf(s, sizeof(s), fmt, i + 1, 5529 "Safe", "Switch"); 5530 err = scarlett2_add_new_ctl( 5531 mixer, &scarlett2_safe_ctl, 5532 i, 1, s, &private->safe_ctls[i]); 5533 if (err < 0) 5534 return err; 5535 } 5536 } 5537 5538 /* Add PCM Input Switch control */ 5539 if (scarlett2_has_config_item(private, 5540 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) { 5541 err = scarlett2_add_new_ctl( 5542 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1, 5543 "PCM Input Capture Switch", 5544 &private->pcm_input_switch_ctl); 5545 if (err < 0) 5546 return err; 5547 } 5548 5549 return 0; 5550} 5551 5552/*** Mixer Volume Controls ***/ 5553 5554static int scarlett2_update_mix(struct usb_mixer_interface *mixer) 5555{ 5556 struct scarlett2_data *private = mixer->private_data; 5557 int i, err; 5558 5559 private->mix_updated = 0; 5560 5561 for (i = 0; i < private->num_mix_out; i++) { 5562 err = scarlett2_usb_get_mix(mixer, i); 5563 if (err < 0) 5564 return err; 5565 } 5566 5567 return 1; 5568} 5569 5570static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl, 5571 struct snd_ctl_elem_info *uinfo) 5572{ 5573 struct usb_mixer_elem_info *elem = kctl->private_data; 5574 5575 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 5576 uinfo->count = elem->channels; 5577 uinfo->value.integer.min = 0; 5578 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE; 5579 uinfo->value.integer.step = 1; 5580 return 0; 5581} 5582 5583static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl, 5584 struct snd_ctl_elem_value *ucontrol) 5585{ 5586 struct usb_mixer_elem_info *elem = kctl->private_data; 5587 struct usb_mixer_interface *mixer = elem->head.mixer; 5588 struct scarlett2_data *private = mixer->private_data; 5589 int err = 0; 5590 5591 mutex_lock(&private->data_mutex); 5592 5593 if (private->hwdep_in_use) { 5594 err = -EBUSY; 5595 goto unlock; 5596 } 5597 5598 if (private->mix_updated) { 5599 err = scarlett2_update_mix(mixer); 5600 if (err < 0) 5601 goto unlock; 5602 } 5603 ucontrol->value.integer.value[0] = private->mix[elem->control]; 5604 5605unlock: 5606 mutex_unlock(&private->data_mutex); 5607 return err; 5608} 5609 5610static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl, 5611 struct snd_ctl_elem_value *ucontrol) 5612{ 5613 struct usb_mixer_elem_info *elem = kctl->private_data; 5614 struct usb_mixer_interface *mixer = elem->head.mixer; 5615 struct scarlett2_data *private = mixer->private_data; 5616 int oval, val, mix_num, err = 0; 5617 int index = elem->control; 5618 5619 mutex_lock(&private->data_mutex); 5620 5621 if (private->hwdep_in_use) { 5622 err = -EBUSY; 5623 goto unlock; 5624 } 5625 5626 oval = private->mix[index]; 5627 val = clamp(ucontrol->value.integer.value[0], 5628 0L, (long)SCARLETT2_MIXER_MAX_VALUE); 5629 mix_num = index / private->num_mix_in; 5630 5631 if (oval == val) 5632 goto unlock; 5633 5634 private->mix[index] = val; 5635 err = scarlett2_usb_set_mix(mixer, mix_num); 5636 if (err == 0) 5637 err = 1; 5638 5639unlock: 5640 mutex_unlock(&private->data_mutex); 5641 return err; 5642} 5643 5644static const DECLARE_TLV_DB_MINMAX( 5645 db_scale_scarlett2_mixer, 5646 SCARLETT2_MIXER_MIN_DB * 100, 5647 SCARLETT2_MIXER_MAX_DB * 100 5648); 5649 5650static const struct snd_kcontrol_new scarlett2_mixer_ctl = { 5651 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5652 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 5653 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 5654 .name = "", 5655 .info = scarlett2_mixer_ctl_info, 5656 .get = scarlett2_mixer_ctl_get, 5657 .put = scarlett2_mixer_ctl_put, 5658 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ 5659 .tlv = { .p = db_scale_scarlett2_mixer } 5660}; 5661 5662static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer) 5663{ 5664 struct scarlett2_data *private = mixer->private_data; 5665 int err, i, j; 5666 int index; 5667 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 5668 5669 for (i = 0, index = 0; i < private->num_mix_out; i++) 5670 for (j = 0; j < private->num_mix_in; j++, index++) { 5671 snprintf(s, sizeof(s), 5672 "Mix %c Input %02d Playback Volume", 5673 'A' + i, j + 1); 5674 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl, 5675 index, 1, s, 5676 &private->mix_ctls[index]); 5677 if (err < 0) 5678 return err; 5679 } 5680 5681 return 0; 5682} 5683 5684/*** Direct Monitor Control ***/ 5685 5686static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer) 5687{ 5688 struct scarlett2_data *private = mixer->private_data; 5689 5690 private->direct_monitor_updated = 0; 5691 5692 if (!private->info->direct_monitor) 5693 return 0; 5694 5695 return scarlett2_usb_get_config( 5696 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, 5697 1, &private->direct_monitor_switch); 5698} 5699 5700static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer) 5701{ 5702 struct scarlett2_data *private = mixer->private_data; 5703 int err, i; 5704 u16 mix_values[SCARLETT2_MONITOR_MIX_MAX]; 5705 5706 if (!private->num_monitor_mix_ctls) 5707 return 0; 5708 5709 err = scarlett2_usb_get_config( 5710 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN, 5711 private->num_monitor_mix_ctls, mix_values); 5712 if (err < 0) 5713 return err; 5714 5715 for (i = 0; i < private->num_monitor_mix_ctls; i++) 5716 private->monitor_mix[i] = scarlett2_mixer_value_to_db( 5717 mix_values[i]); 5718 5719 return 0; 5720} 5721 5722static int scarlett2_direct_monitor_ctl_get( 5723 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5724{ 5725 struct usb_mixer_elem_info *elem = kctl->private_data; 5726 struct usb_mixer_interface *mixer = elem->head.mixer; 5727 struct scarlett2_data *private = mixer->private_data; 5728 int err = 0; 5729 5730 mutex_lock(&private->data_mutex); 5731 5732 if (private->hwdep_in_use) { 5733 err = -EBUSY; 5734 goto unlock; 5735 } 5736 5737 if (private->direct_monitor_updated) { 5738 err = scarlett2_update_direct_monitor(mixer); 5739 if (err < 0) 5740 goto unlock; 5741 } 5742 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch; 5743 5744unlock: 5745 mutex_unlock(&private->data_mutex); 5746 return err; 5747} 5748 5749static int scarlett2_direct_monitor_ctl_put( 5750 struct snd_kcontrol *kctl, struct snd_ctl_elem_value *ucontrol) 5751{ 5752 struct usb_mixer_elem_info *elem = kctl->private_data; 5753 struct usb_mixer_interface *mixer = elem->head.mixer; 5754 struct scarlett2_data *private = mixer->private_data; 5755 5756 int index = elem->control; 5757 int oval, val, err = 0; 5758 5759 mutex_lock(&private->data_mutex); 5760 5761 if (private->hwdep_in_use) { 5762 err = -EBUSY; 5763 goto unlock; 5764 } 5765 5766 oval = private->direct_monitor_switch; 5767 val = min(ucontrol->value.enumerated.item[0], 2U); 5768 5769 if (oval == val) 5770 goto unlock; 5771 5772 private->direct_monitor_switch = val; 5773 5774 /* Send switch change to the device */ 5775 err = scarlett2_usb_set_config( 5776 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val); 5777 if (err == 0) 5778 err = 1; 5779 5780unlock: 5781 mutex_unlock(&private->data_mutex); 5782 return err; 5783} 5784 5785static int scarlett2_direct_monitor_stereo_enum_ctl_info( 5786 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 5787{ 5788 static const char *const values[3] = { 5789 "Off", "Mono", "Stereo" 5790 }; 5791 5792 return snd_ctl_enum_info(uinfo, 1, 3, values); 5793} 5794 5795/* Direct Monitor for Solo is mono-only and only needs a boolean control 5796 * Direct Monitor for 2i2 is selectable between Off/Mono/Stereo 5797 */ 5798static const struct snd_kcontrol_new scarlett2_direct_monitor_ctl[2] = { 5799 { 5800 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5801 .name = "", 5802 .info = snd_ctl_boolean_mono_info, 5803 .get = scarlett2_direct_monitor_ctl_get, 5804 .put = scarlett2_direct_monitor_ctl_put, 5805 }, 5806 { 5807 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5808 .name = "", 5809 .info = scarlett2_direct_monitor_stereo_enum_ctl_info, 5810 .get = scarlett2_direct_monitor_ctl_get, 5811 .put = scarlett2_direct_monitor_ctl_put, 5812 } 5813}; 5814 5815static int scarlett2_monitor_mix_ctl_get(struct snd_kcontrol *kctl, 5816 struct snd_ctl_elem_value *ucontrol) 5817{ 5818 struct usb_mixer_elem_info *elem = kctl->private_data; 5819 struct scarlett2_data *private = elem->head.mixer->private_data; 5820 5821 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control]; 5822 5823 return 0; 5824} 5825 5826static int scarlett2_monitor_mix_ctl_put(struct snd_kcontrol *kctl, 5827 struct snd_ctl_elem_value *ucontrol) 5828{ 5829 struct usb_mixer_elem_info *elem = kctl->private_data; 5830 struct usb_mixer_interface *mixer = elem->head.mixer; 5831 struct scarlett2_data *private = mixer->private_data; 5832 int oval, val, err = 0; 5833 int index = elem->control; 5834 5835 mutex_lock(&private->data_mutex); 5836 5837 if (private->hwdep_in_use) { 5838 err = -EBUSY; 5839 goto unlock; 5840 } 5841 5842 oval = private->monitor_mix[index]; 5843 val = clamp(ucontrol->value.integer.value[0], 5844 0L, (long)SCARLETT2_MIXER_MAX_VALUE); 5845 5846 if (oval == val) 5847 goto unlock; 5848 5849 private->monitor_mix[index] = val; 5850 err = scarlett2_usb_set_config( 5851 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN, 5852 index, scarlett2_mixer_values[val]); 5853 if (err == 0) 5854 err = 1; 5855 5856unlock: 5857 mutex_unlock(&private->data_mutex); 5858 return err; 5859} 5860 5861static const struct snd_kcontrol_new scarlett2_monitor_mix_ctl = { 5862 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5863 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 5864 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 5865 .name = "", 5866 .info = scarlett2_mixer_ctl_info, 5867 .get = scarlett2_monitor_mix_ctl_get, 5868 .put = scarlett2_monitor_mix_ctl_put, 5869 .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */ 5870 .tlv = { .p = db_scale_scarlett2_mixer } 5871}; 5872 5873static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer) 5874{ 5875 struct scarlett2_data *private = mixer->private_data; 5876 const struct scarlett2_device_info *info = private->info; 5877 const char *s; 5878 int err, i, j, k, index; 5879 5880 if (!info->direct_monitor) 5881 return 0; 5882 5883 s = info->direct_monitor == 1 5884 ? "Direct Monitor Playback Switch" 5885 : "Direct Monitor Playback Enum"; 5886 5887 err = scarlett2_add_new_ctl( 5888 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1], 5889 0, 1, s, &private->direct_monitor_ctl); 5890 if (err < 0) 5891 return err; 5892 5893 if (!private->num_monitor_mix_ctls) 5894 return 0; 5895 5896 /* 1 or 2 direct monitor selections (Mono & Stereo) */ 5897 for (i = 0, index = 0; i < info->direct_monitor; i++) { 5898 const char * const format = 5899 "Monitor %sMix %c Input %02d Playback Volume"; 5900 const char *mix_type; 5901 5902 if (info->direct_monitor == 1) 5903 mix_type = ""; 5904 else if (i == 0) 5905 mix_type = "1 "; 5906 else 5907 mix_type = "2 "; 5908 5909 /* 2 Mix outputs, A/Left & B/Right */ 5910 for (j = 0; j < 2; j++) 5911 5912 /* Mix inputs */ 5913 for (k = 0; k < private->num_mix_in; k++, index++) { 5914 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 5915 5916 scnprintf(name, sizeof(name), format, 5917 mix_type, 'A' + j, k + 1); 5918 5919 err = scarlett2_add_new_ctl( 5920 mixer, &scarlett2_monitor_mix_ctl, 5921 index, 1, name, NULL); 5922 if (err < 0) 5923 return err; 5924 } 5925 } 5926 5927 return 0; 5928} 5929 5930/*** Mux Source Selection Controls ***/ 5931 5932static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl, 5933 struct snd_ctl_elem_info *uinfo) 5934{ 5935 struct usb_mixer_elem_info *elem = kctl->private_data; 5936 struct scarlett2_data *private = elem->head.mixer->private_data; 5937 const struct scarlett2_device_info *info = private->info; 5938 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 5939 unsigned int item = uinfo->value.enumerated.item; 5940 int items = private->num_mux_srcs; 5941 int port_type; 5942 5943 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 5944 uinfo->count = elem->channels; 5945 uinfo->value.enumerated.items = items; 5946 5947 if (item >= items) 5948 item = uinfo->value.enumerated.item = items - 1; 5949 5950 for (port_type = 0; 5951 port_type < SCARLETT2_PORT_TYPE_COUNT; 5952 port_type++) { 5953 if (item < port_count[port_type][SCARLETT2_PORT_IN]) { 5954 const struct scarlett2_port *port = 5955 &scarlett2_ports[port_type]; 5956 5957 if (port_type == SCARLETT2_PORT_TYPE_MIX && 5958 item >= private->num_mix_out) 5959 sprintf(uinfo->value.enumerated.name, 5960 port->dsp_src_descr, 5961 item - private->num_mix_out + 1); 5962 else 5963 sprintf(uinfo->value.enumerated.name, 5964 port->src_descr, 5965 item + port->src_num_offset); 5966 5967 return 0; 5968 } 5969 item -= port_count[port_type][SCARLETT2_PORT_IN]; 5970 } 5971 5972 return -EINVAL; 5973} 5974 5975static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl, 5976 struct snd_ctl_elem_value *ucontrol) 5977{ 5978 struct usb_mixer_elem_info *elem = kctl->private_data; 5979 struct usb_mixer_interface *mixer = elem->head.mixer; 5980 struct scarlett2_data *private = mixer->private_data; 5981 int index = line_out_remap(private, elem->control); 5982 int err = 0; 5983 5984 mutex_lock(&private->data_mutex); 5985 5986 if (private->hwdep_in_use) { 5987 err = -EBUSY; 5988 goto unlock; 5989 } 5990 5991 if (private->mux_updated) { 5992 err = scarlett2_usb_get_mux(mixer); 5993 if (err < 0) 5994 goto unlock; 5995 } 5996 ucontrol->value.enumerated.item[0] = private->mux[index]; 5997 5998unlock: 5999 mutex_unlock(&private->data_mutex); 6000 return err; 6001} 6002 6003static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl, 6004 struct snd_ctl_elem_value *ucontrol) 6005{ 6006 struct usb_mixer_elem_info *elem = kctl->private_data; 6007 struct usb_mixer_interface *mixer = elem->head.mixer; 6008 struct scarlett2_data *private = mixer->private_data; 6009 int index = line_out_remap(private, elem->control); 6010 int oval, val, err = 0; 6011 6012 mutex_lock(&private->data_mutex); 6013 6014 if (private->hwdep_in_use) { 6015 err = -EBUSY; 6016 goto unlock; 6017 } 6018 6019 oval = private->mux[index]; 6020 val = min(ucontrol->value.enumerated.item[0], 6021 private->num_mux_srcs - 1U); 6022 6023 if (oval == val) 6024 goto unlock; 6025 6026 private->mux[index] = val; 6027 err = scarlett2_usb_set_mux(mixer); 6028 if (err == 0) 6029 err = 1; 6030 6031unlock: 6032 mutex_unlock(&private->data_mutex); 6033 return err; 6034} 6035 6036static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = { 6037 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6038 .name = "", 6039 .info = scarlett2_mux_src_enum_ctl_info, 6040 .get = scarlett2_mux_src_enum_ctl_get, 6041 .put = scarlett2_mux_src_enum_ctl_put, 6042}; 6043 6044static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer) 6045{ 6046 struct scarlett2_data *private = mixer->private_data; 6047 const struct scarlett2_device_info *info = private->info; 6048 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 6049 int port_type, channel, i; 6050 6051 for (i = 0, port_type = 0; 6052 port_type < SCARLETT2_PORT_TYPE_COUNT; 6053 port_type++) { 6054 for (channel = 0; 6055 channel < port_count[port_type][SCARLETT2_PORT_OUT]; 6056 channel++, i++) { 6057 int err; 6058 char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; 6059 int channel_num = channel + 1; 6060 const struct scarlett2_port *port = 6061 &scarlett2_ports[port_type]; 6062 const char *descr = port->dst_descr; 6063 6064 if (port_type == SCARLETT2_PORT_TYPE_MIX && 6065 channel >= private->num_mix_in) { 6066 channel_num -= private->num_mix_in; 6067 descr = port->dsp_dst_descr; 6068 } 6069 6070 snprintf(s, sizeof(s) - 5, descr, channel_num); 6071 strcat(s, " Enum"); 6072 6073 err = scarlett2_add_new_ctl(mixer, 6074 &scarlett2_mux_src_enum_ctl, 6075 i, 1, s, 6076 &private->mux_ctls[i]); 6077 if (err < 0) 6078 return err; 6079 } 6080 } 6081 6082 return 0; 6083} 6084 6085/*** Meter Controls ***/ 6086 6087static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl, 6088 struct snd_ctl_elem_info *uinfo) 6089{ 6090 struct usb_mixer_elem_info *elem = kctl->private_data; 6091 6092 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 6093 uinfo->count = elem->channels; 6094 uinfo->value.integer.min = 0; 6095 uinfo->value.integer.max = 4095; 6096 uinfo->value.integer.step = 1; 6097 return 0; 6098} 6099 6100static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl, 6101 struct snd_ctl_elem_value *ucontrol) 6102{ 6103 struct usb_mixer_elem_info *elem = kctl->private_data; 6104 struct usb_mixer_interface *mixer = elem->head.mixer; 6105 struct scarlett2_data *private = mixer->private_data; 6106 u8 *meter_level_map = private->meter_level_map; 6107 u16 meter_levels[SCARLETT2_MAX_METERS]; 6108 int i, err; 6109 6110 mutex_lock(&private->data_mutex); 6111 6112 if (private->hwdep_in_use) { 6113 err = -EBUSY; 6114 goto unlock; 6115 } 6116 6117 err = scarlett2_usb_get_meter_levels(mixer, elem->channels, 6118 meter_levels); 6119 if (err < 0) 6120 goto unlock; 6121 6122 /* copy & translate from meter_levels[] using meter_level_map[] */ 6123 for (i = 0; i < elem->channels; i++) { 6124 int idx = meter_level_map[i]; 6125 int value; 6126 6127 if (idx == 255) 6128 value = 0; 6129 else 6130 value = meter_levels[idx]; 6131 6132 ucontrol->value.integer.value[i] = value; 6133 } 6134 6135unlock: 6136 mutex_unlock(&private->data_mutex); 6137 6138 return err; 6139} 6140 6141static const struct snd_kcontrol_new scarlett2_meter_ctl = { 6142 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 6143 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 6144 .name = "", 6145 .info = scarlett2_meter_ctl_info, 6146 .get = scarlett2_meter_ctl_get 6147}; 6148 6149static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer) 6150{ 6151 struct scarlett2_data *private = mixer->private_data; 6152 6153 /* devices without a mixer also don't support reporting levels */ 6154 if (!scarlett2_has_mixer(private)) 6155 return 0; 6156 6157 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl, 6158 0, private->num_mux_dsts, 6159 "Level Meter", NULL); 6160} 6161 6162/*** MSD Controls ***/ 6163 6164static int scarlett2_msd_ctl_get(struct snd_kcontrol *kctl, 6165 struct snd_ctl_elem_value *ucontrol) 6166{ 6167 struct usb_mixer_elem_info *elem = kctl->private_data; 6168 struct scarlett2_data *private = elem->head.mixer->private_data; 6169 6170 ucontrol->value.integer.value[0] = private->msd_switch; 6171 return 0; 6172} 6173 6174static int scarlett2_msd_ctl_put(struct snd_kcontrol *kctl, 6175 struct snd_ctl_elem_value *ucontrol) 6176{ 6177 struct usb_mixer_elem_info *elem = kctl->private_data; 6178 struct usb_mixer_interface *mixer = elem->head.mixer; 6179 struct scarlett2_data *private = mixer->private_data; 6180 6181 int oval, val, err = 0; 6182 6183 mutex_lock(&private->data_mutex); 6184 6185 if (private->hwdep_in_use) { 6186 err = -EBUSY; 6187 goto unlock; 6188 } 6189 6190 oval = private->msd_switch; 6191 val = !!ucontrol->value.integer.value[0]; 6192 6193 if (oval == val) 6194 goto unlock; 6195 6196 private->msd_switch = val; 6197 6198 /* Send switch change to the device */ 6199 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH, 6200 0, val); 6201 if (err == 0) 6202 err = 1; 6203 6204unlock: 6205 mutex_unlock(&private->data_mutex); 6206 return err; 6207} 6208 6209static const struct snd_kcontrol_new scarlett2_msd_ctl = { 6210 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6211 .name = "", 6212 .info = snd_ctl_boolean_mono_info, 6213 .get = scarlett2_msd_ctl_get, 6214 .put = scarlett2_msd_ctl_put, 6215}; 6216 6217static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer) 6218{ 6219 struct scarlett2_data *private = mixer->private_data; 6220 6221 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) 6222 return 0; 6223 6224 /* If MSD mode is off, hide the switch by default */ 6225 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE)) 6226 return 0; 6227 6228 /* Add MSD control */ 6229 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl, 6230 0, 1, "MSD Mode Switch", NULL); 6231} 6232 6233/*** Standalone Control ***/ 6234 6235static int scarlett2_standalone_ctl_get(struct snd_kcontrol *kctl, 6236 struct snd_ctl_elem_value *ucontrol) 6237{ 6238 struct usb_mixer_elem_info *elem = kctl->private_data; 6239 struct scarlett2_data *private = elem->head.mixer->private_data; 6240 6241 ucontrol->value.integer.value[0] = private->standalone_switch; 6242 return 0; 6243} 6244 6245static int scarlett2_standalone_ctl_put(struct snd_kcontrol *kctl, 6246 struct snd_ctl_elem_value *ucontrol) 6247{ 6248 struct usb_mixer_elem_info *elem = kctl->private_data; 6249 struct usb_mixer_interface *mixer = elem->head.mixer; 6250 struct scarlett2_data *private = mixer->private_data; 6251 6252 int oval, val, err = 0; 6253 6254 mutex_lock(&private->data_mutex); 6255 6256 if (private->hwdep_in_use) { 6257 err = -EBUSY; 6258 goto unlock; 6259 } 6260 6261 oval = private->standalone_switch; 6262 val = !!ucontrol->value.integer.value[0]; 6263 6264 if (oval == val) 6265 goto unlock; 6266 6267 private->standalone_switch = val; 6268 6269 /* Send switch change to the device */ 6270 err = scarlett2_usb_set_config(mixer, 6271 SCARLETT2_CONFIG_STANDALONE_SWITCH, 6272 0, val); 6273 if (err == 0) 6274 err = 1; 6275 6276unlock: 6277 mutex_unlock(&private->data_mutex); 6278 return err; 6279} 6280 6281static const struct snd_kcontrol_new scarlett2_standalone_ctl = { 6282 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 6283 .name = "", 6284 .info = snd_ctl_boolean_mono_info, 6285 .get = scarlett2_standalone_ctl_get, 6286 .put = scarlett2_standalone_ctl_put, 6287}; 6288 6289static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer) 6290{ 6291 struct scarlett2_data *private = mixer->private_data; 6292 6293 if (!scarlett2_has_config_item(private, 6294 SCARLETT2_CONFIG_STANDALONE_SWITCH)) 6295 return 0; 6296 6297 /* Add standalone control */ 6298 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl, 6299 0, 1, "Standalone Switch", NULL); 6300} 6301 6302/*** Power Status ***/ 6303 6304static int scarlett2_update_power_status(struct usb_mixer_interface *mixer) 6305{ 6306 struct scarlett2_data *private = mixer->private_data; 6307 int err; 6308 u8 power_ext, power_low; 6309 6310 private->power_status_updated = 0; 6311 6312 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT, 6313 1, &power_ext); 6314 if (err < 0) 6315 return err; 6316 6317 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW, 6318 1, &power_low); 6319 if (err < 0) 6320 return err; 6321 6322 if (power_low) 6323 private->power_status = SCARLETT2_POWER_STATUS_FAIL; 6324 else if (power_ext) 6325 private->power_status = SCARLETT2_POWER_STATUS_EXT; 6326 else 6327 private->power_status = SCARLETT2_POWER_STATUS_BUS; 6328 6329 return 0; 6330} 6331 6332static int scarlett2_power_status_ctl_get(struct snd_kcontrol *kctl, 6333 struct snd_ctl_elem_value *ucontrol) 6334{ 6335 struct usb_mixer_elem_info *elem = kctl->private_data; 6336 struct usb_mixer_interface *mixer = elem->head.mixer; 6337 struct scarlett2_data *private = mixer->private_data; 6338 int err = 0; 6339 6340 mutex_lock(&private->data_mutex); 6341 6342 if (private->power_status_updated) { 6343 err = scarlett2_update_power_status(mixer); 6344 if (err < 0) 6345 goto unlock; 6346 } 6347 ucontrol->value.integer.value[0] = private->power_status; 6348 6349unlock: 6350 mutex_unlock(&private->data_mutex); 6351 return err; 6352} 6353 6354static int scarlett2_power_status_ctl_info( 6355 struct snd_kcontrol *kctl, struct snd_ctl_elem_info *uinfo) 6356{ 6357 static const char *const values[3] = { 6358 "External", "Bus", "Fail" 6359 }; 6360 6361 return snd_ctl_enum_info(uinfo, 1, 3, values); 6362} 6363 6364static const struct snd_kcontrol_new scarlett2_power_status_ctl = { 6365 .iface = SNDRV_CTL_ELEM_IFACE_CARD, 6366 .access = SNDRV_CTL_ELEM_ACCESS_READ, 6367 .name = "", 6368 .info = scarlett2_power_status_ctl_info, 6369 .get = scarlett2_power_status_ctl_get, 6370}; 6371 6372static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer) 6373{ 6374 struct scarlett2_data *private = mixer->private_data; 6375 6376 if (!scarlett2_has_config_item(private, 6377 SCARLETT2_CONFIG_POWER_EXT)) 6378 return 0; 6379 6380 /* Add power status control */ 6381 return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl, 6382 0, 1, "Power Status Card Enum", 6383 &private->power_status_ctl); 6384} 6385 6386/*** Cleanup/Suspend Callbacks ***/ 6387 6388static void scarlett2_private_free(struct usb_mixer_interface *mixer) 6389{ 6390 struct scarlett2_data *private = mixer->private_data; 6391 6392 cancel_delayed_work_sync(&private->work); 6393 kfree(private); 6394 mixer->private_data = NULL; 6395} 6396 6397static void scarlett2_private_suspend(struct usb_mixer_interface *mixer) 6398{ 6399 struct scarlett2_data *private = mixer->private_data; 6400 6401 if (cancel_delayed_work_sync(&private->work)) 6402 scarlett2_config_save(private->mixer); 6403} 6404 6405/*** Initialisation ***/ 6406 6407static void scarlett2_count_io(struct scarlett2_data *private) 6408{ 6409 const struct scarlett2_device_info *info = private->info; 6410 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count; 6411 int port_type, srcs = 0, dsts = 0; 6412 6413 /* Count the number of mux sources and destinations */ 6414 for (port_type = 0; 6415 port_type < SCARLETT2_PORT_TYPE_COUNT; 6416 port_type++) { 6417 srcs += port_count[port_type][SCARLETT2_PORT_IN]; 6418 dsts += port_count[port_type][SCARLETT2_PORT_OUT]; 6419 } 6420 6421 private->num_mux_srcs = srcs; 6422 private->num_mux_dsts = dsts; 6423 6424 /* Mixer inputs are mux outputs and vice versa. 6425 * Scarlett Gen 4 DSP I/O uses SCARLETT2_PORT_TYPE_MIX but 6426 * doesn't have mixer controls. 6427 */ 6428 private->num_mix_in = 6429 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] - 6430 info->dsp_count; 6431 6432 private->num_mix_out = 6433 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] - 6434 info->dsp_count; 6435 6436 /* Number of analogue line outputs */ 6437 private->num_line_out = 6438 port_count[SCARLETT2_PORT_TYPE_ANALOGUE][SCARLETT2_PORT_OUT]; 6439 6440 /* Number of monitor mix controls */ 6441 private->num_monitor_mix_ctls = 6442 info->direct_monitor * 2 * private->num_mix_in; 6443} 6444 6445/* Look through the interface descriptors for the Focusrite Control 6446 * interface (bInterfaceClass = 255 Vendor Specific Class) and set 6447 * bInterfaceNumber, bEndpointAddress, wMaxPacketSize, and bInterval 6448 * in private 6449 */ 6450static int scarlett2_find_fc_interface(struct usb_device *dev, 6451 struct scarlett2_data *private) 6452{ 6453 struct usb_host_config *config = dev->actconfig; 6454 int i; 6455 6456 for (i = 0; i < config->desc.bNumInterfaces; i++) { 6457 struct usb_interface *intf = config->interface[i]; 6458 struct usb_interface_descriptor *desc = 6459 &intf->altsetting[0].desc; 6460 struct usb_endpoint_descriptor *epd; 6461 6462 if (desc->bInterfaceClass != 255) 6463 continue; 6464 6465 epd = get_endpoint(intf->altsetting, 0); 6466 private->bInterfaceNumber = desc->bInterfaceNumber; 6467 private->bEndpointAddress = epd->bEndpointAddress & 6468 USB_ENDPOINT_NUMBER_MASK; 6469 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize); 6470 private->bInterval = epd->bInterval; 6471 return 0; 6472 } 6473 6474 return -EINVAL; 6475} 6476 6477/* Initialise private data */ 6478static int scarlett2_init_private(struct usb_mixer_interface *mixer, 6479 const struct scarlett2_device_entry *entry) 6480{ 6481 struct scarlett2_data *private = 6482 kzalloc(sizeof(struct scarlett2_data), GFP_KERNEL); 6483 6484 if (!private) 6485 return -ENOMEM; 6486 6487 mutex_init(&private->usb_mutex); 6488 mutex_init(&private->data_mutex); 6489 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work); 6490 6491 mixer->private_data = private; 6492 mixer->private_free = scarlett2_private_free; 6493 mixer->private_suspend = scarlett2_private_suspend; 6494 6495 private->info = entry->info; 6496 private->config_set = entry->info->config_set; 6497 private->series_name = entry->series_name; 6498 scarlett2_count_io(private); 6499 private->scarlett2_seq = 0; 6500 private->mixer = mixer; 6501 6502 return scarlett2_find_fc_interface(mixer->chip->dev, private); 6503} 6504 6505/* Cargo cult proprietary initialisation sequence */ 6506static int scarlett2_usb_init(struct usb_mixer_interface *mixer) 6507{ 6508 struct usb_device *dev = mixer->chip->dev; 6509 struct scarlett2_data *private = mixer->private_data; 6510 u8 step0_buf[24]; 6511 u8 step2_buf[84]; 6512 int err; 6513 6514 if (usb_pipe_type_check(dev, usb_sndctrlpipe(dev, 0))) 6515 return -EINVAL; 6516 6517 /* step 0 */ 6518 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, 6519 SCARLETT2_USB_CMD_INIT, 6520 step0_buf, sizeof(step0_buf)); 6521 if (err < 0) 6522 return err; 6523 6524 /* step 1 */ 6525 private->scarlett2_seq = 1; 6526 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0); 6527 if (err < 0) 6528 return err; 6529 6530 /* step 2 */ 6531 private->scarlett2_seq = 1; 6532 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2, 6533 NULL, 0, 6534 step2_buf, sizeof(step2_buf)); 6535 if (err < 0) 6536 return err; 6537 6538 /* extract 4-byte firmware version from step2_buf[8] */ 6539 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8)); 6540 usb_audio_info(mixer->chip, 6541 "Firmware version %d\n", 6542 private->firmware_version); 6543 6544 return 0; 6545} 6546 6547/* Get the flash segment numbers for the App_Settings and App_Upgrade 6548 * segments and put them in the private data 6549 */ 6550static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer) 6551{ 6552 struct scarlett2_data *private = mixer->private_data; 6553 int err, count, i; 6554 6555 struct { 6556 __le32 size; 6557 __le32 count; 6558 u8 unknown[8]; 6559 } __packed flash_info; 6560 6561 struct { 6562 __le32 size; 6563 __le32 flags; 6564 char name[16]; 6565 } __packed segment_info; 6566 6567 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH, 6568 NULL, 0, 6569 &flash_info, sizeof(flash_info)); 6570 if (err < 0) 6571 return err; 6572 6573 count = le32_to_cpu(flash_info.count); 6574 6575 /* sanity check count */ 6576 if (count < SCARLETT2_SEGMENT_NUM_MIN || 6577 count > SCARLETT2_SEGMENT_NUM_MAX + 1) { 6578 usb_audio_err(mixer->chip, 6579 "invalid flash segment count: %d\n", count); 6580 return -EINVAL; 6581 } 6582 6583 for (i = 0; i < count; i++) { 6584 __le32 segment_num_req = cpu_to_le32(i); 6585 int flash_segment_id; 6586 6587 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT, 6588 &segment_num_req, sizeof(segment_num_req), 6589 &segment_info, sizeof(segment_info)); 6590 if (err < 0) { 6591 usb_audio_err(mixer->chip, 6592 "failed to get flash segment info %d: %d\n", 6593 i, err); 6594 return err; 6595 } 6596 6597 if (!strncmp(segment_info.name, 6598 SCARLETT2_SEGMENT_SETTINGS_NAME, 16)) 6599 flash_segment_id = SCARLETT2_SEGMENT_ID_SETTINGS; 6600 else if (!strncmp(segment_info.name, 6601 SCARLETT2_SEGMENT_FIRMWARE_NAME, 16)) 6602 flash_segment_id = SCARLETT2_SEGMENT_ID_FIRMWARE; 6603 else 6604 continue; 6605 6606 private->flash_segment_nums[flash_segment_id] = i; 6607 private->flash_segment_blocks[flash_segment_id] = 6608 le32_to_cpu(segment_info.size) / 6609 SCARLETT2_FLASH_BLOCK_SIZE; 6610 } 6611 6612 /* segment 0 is App_Gold and we never want to touch that, so 6613 * use 0 as the "not-found" value 6614 */ 6615 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) { 6616 usb_audio_err(mixer->chip, 6617 "failed to find flash segment %s\n", 6618 SCARLETT2_SEGMENT_SETTINGS_NAME); 6619 return -EINVAL; 6620 } 6621 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) { 6622 usb_audio_err(mixer->chip, 6623 "failed to find flash segment %s\n", 6624 SCARLETT2_SEGMENT_FIRMWARE_NAME); 6625 return -EINVAL; 6626 } 6627 6628 return 0; 6629} 6630 6631/* Read configuration from the interface on start */ 6632static int scarlett2_read_configs(struct usb_mixer_interface *mixer) 6633{ 6634 struct scarlett2_data *private = mixer->private_data; 6635 const struct scarlett2_device_info *info = private->info; 6636 int err, i; 6637 6638 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) { 6639 err = scarlett2_usb_get_config( 6640 mixer, SCARLETT2_CONFIG_MSD_SWITCH, 6641 1, &private->msd_switch); 6642 if (err < 0) 6643 return err; 6644 } 6645 6646 if (private->firmware_version < info->min_firmware_version) { 6647 usb_audio_err(mixer->chip, 6648 "Focusrite %s firmware version %d is too old; " 6649 "need %d", 6650 private->series_name, 6651 private->firmware_version, 6652 info->min_firmware_version); 6653 return 0; 6654 } 6655 6656 /* no other controls are created if MSD mode is on */ 6657 if (private->msd_switch) 6658 return 0; 6659 6660 err = scarlett2_update_input_level(mixer); 6661 if (err < 0) 6662 return err; 6663 6664 err = scarlett2_update_input_pad(mixer); 6665 if (err < 0) 6666 return err; 6667 6668 err = scarlett2_update_input_air(mixer); 6669 if (err < 0) 6670 return err; 6671 6672 err = scarlett2_update_input_phantom(mixer); 6673 if (err < 0) 6674 return err; 6675 6676 err = scarlett2_update_direct_monitor(mixer); 6677 if (err < 0) 6678 return err; 6679 6680 /* the rest of the configuration is for devices with a mixer */ 6681 if (!scarlett2_has_mixer(private)) 6682 return 0; 6683 6684 err = scarlett2_update_monitor_mix(mixer); 6685 if (err < 0) 6686 return err; 6687 6688 err = scarlett2_update_monitor_other(mixer); 6689 if (err < 0) 6690 return err; 6691 6692 if (scarlett2_has_config_item(private, 6693 SCARLETT2_CONFIG_STANDALONE_SWITCH)) { 6694 err = scarlett2_usb_get_config( 6695 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH, 6696 1, &private->standalone_switch); 6697 if (err < 0) 6698 return err; 6699 } 6700 6701 if (scarlett2_has_config_item(private, 6702 SCARLETT2_CONFIG_POWER_EXT)) { 6703 err = scarlett2_update_power_status(mixer); 6704 if (err < 0) 6705 return err; 6706 } 6707 6708 err = scarlett2_update_sync(mixer); 6709 if (err < 0) 6710 return err; 6711 6712 if (scarlett2_has_config_item(private, 6713 SCARLETT2_CONFIG_LINE_OUT_VOLUME)) { 6714 s16 sw_vol[SCARLETT2_ANALOGUE_MAX]; 6715 6716 /* read SW line out volume */ 6717 err = scarlett2_usb_get_config( 6718 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME, 6719 private->num_line_out, &sw_vol); 6720 if (err < 0) 6721 return err; 6722 6723 for (i = 0; i < private->num_line_out; i++) 6724 private->vol[i] = clamp( 6725 sw_vol[i] + SCARLETT2_VOLUME_BIAS, 6726 0, SCARLETT2_VOLUME_BIAS); 6727 6728 /* read SW mute */ 6729 err = scarlett2_usb_get_config( 6730 mixer, SCARLETT2_CONFIG_MUTE_SWITCH, 6731 private->num_line_out, &private->mute_switch); 6732 if (err < 0) 6733 return err; 6734 6735 for (i = 0; i < private->num_line_out; i++) 6736 private->mute_switch[i] = 6737 !!private->mute_switch[i]; 6738 6739 /* read SW/HW switches */ 6740 if (scarlett2_has_config_item(private, 6741 SCARLETT2_CONFIG_SW_HW_SWITCH)) { 6742 err = scarlett2_usb_get_config( 6743 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH, 6744 private->num_line_out, 6745 &private->vol_sw_hw_switch); 6746 if (err < 0) 6747 return err; 6748 6749 for (i = 0; i < private->num_line_out; i++) 6750 private->vol_sw_hw_switch[i] = 6751 !!private->vol_sw_hw_switch[i]; 6752 } 6753 } 6754 6755 err = scarlett2_update_volumes(mixer); 6756 if (err < 0) 6757 return err; 6758 6759 err = scarlett2_update_dim_mute(mixer); 6760 if (err < 0) 6761 return err; 6762 6763 err = scarlett2_update_input_select(mixer); 6764 if (err < 0) 6765 return err; 6766 6767 err = scarlett2_update_input_gain(mixer); 6768 if (err < 0) 6769 return err; 6770 6771 err = scarlett2_update_autogain(mixer); 6772 if (err < 0) 6773 return err; 6774 6775 err = scarlett2_update_input_safe(mixer); 6776 if (err < 0) 6777 return err; 6778 6779 if (scarlett2_has_config_item(private, 6780 SCARLETT2_CONFIG_PCM_INPUT_SWITCH)) { 6781 err = scarlett2_update_pcm_input_switch(mixer); 6782 if (err < 0) 6783 return err; 6784 } 6785 6786 err = scarlett2_update_mix(mixer); 6787 if (err < 0) 6788 return err; 6789 6790 return scarlett2_usb_get_mux(mixer); 6791} 6792 6793/* Notify on sync change */ 6794static void scarlett2_notify_sync(struct usb_mixer_interface *mixer) 6795{ 6796 struct scarlett2_data *private = mixer->private_data; 6797 6798 private->sync_updated = 1; 6799 6800 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 6801 &private->sync_ctl->id); 6802} 6803 6804/* Notify on monitor change (Gen 2/3) */ 6805static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer) 6806{ 6807 struct snd_card *card = mixer->chip->card; 6808 struct scarlett2_data *private = mixer->private_data; 6809 int i; 6810 6811 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) 6812 return; 6813 6814 private->vol_updated = 1; 6815 6816 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 6817 &private->master_vol_ctl->id); 6818 6819 for (i = 0; i < private->num_line_out; i++) 6820 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 6821 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6822 &private->vol_ctls[i]->id); 6823} 6824 6825/* Notify on volume change (Gen 4) */ 6826static void scarlett2_notify_volume(struct usb_mixer_interface *mixer) 6827{ 6828 struct scarlett2_data *private = mixer->private_data; 6829 6830 private->vol_updated = 1; 6831 6832 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 6833 &private->master_vol_ctl->id); 6834 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE, 6835 &private->headphone_vol_ctl->id); 6836} 6837 6838/* Notify on dim/mute change */ 6839static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer) 6840{ 6841 struct snd_card *card = mixer->chip->card; 6842 struct scarlett2_data *private = mixer->private_data; 6843 int i; 6844 6845 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) 6846 return; 6847 6848 private->dim_mute_updated = 1; 6849 6850 for (i = 0; i < SCARLETT2_DIM_MUTE_COUNT; i++) 6851 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6852 &private->dim_mute_ctls[i]->id); 6853 6854 for (i = 0; i < private->num_line_out; i++) 6855 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) 6856 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6857 &private->mute_ctls[i]->id); 6858} 6859 6860/* Notify on input level switch change */ 6861static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer) 6862{ 6863 struct snd_card *card = mixer->chip->card; 6864 struct scarlett2_data *private = mixer->private_data; 6865 const struct scarlett2_device_info *info = private->info; 6866 int i; 6867 6868 private->input_level_updated = 1; 6869 6870 for (i = 0; i < info->level_input_count; i++) 6871 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6872 &private->level_ctls[i]->id); 6873} 6874 6875/* Notify on input pad switch change */ 6876static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer) 6877{ 6878 struct snd_card *card = mixer->chip->card; 6879 struct scarlett2_data *private = mixer->private_data; 6880 const struct scarlett2_device_info *info = private->info; 6881 int i; 6882 6883 private->input_pad_updated = 1; 6884 6885 for (i = 0; i < info->pad_input_count; i++) 6886 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6887 &private->pad_ctls[i]->id); 6888} 6889 6890/* Notify on input air switch change */ 6891static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer) 6892{ 6893 struct snd_card *card = mixer->chip->card; 6894 struct scarlett2_data *private = mixer->private_data; 6895 const struct scarlett2_device_info *info = private->info; 6896 int i; 6897 6898 private->input_air_updated = 1; 6899 6900 for (i = 0; i < info->air_input_count; i++) 6901 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6902 &private->air_ctls[i]->id); 6903} 6904 6905/* Notify on input phantom switch change */ 6906static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer) 6907{ 6908 struct snd_card *card = mixer->chip->card; 6909 struct scarlett2_data *private = mixer->private_data; 6910 const struct scarlett2_device_info *info = private->info; 6911 int i; 6912 6913 private->input_phantom_updated = 1; 6914 6915 for (i = 0; i < info->phantom_count; i++) 6916 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6917 &private->phantom_ctls[i]->id); 6918 6919 scarlett2_phantom_notify_access(mixer); 6920} 6921 6922/* Notify on "input other" change (level/pad/air/phantom) */ 6923static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer) 6924{ 6925 scarlett2_notify_input_level(mixer); 6926 scarlett2_notify_input_pad(mixer); 6927 scarlett2_notify_input_air(mixer); 6928 scarlett2_notify_input_phantom(mixer); 6929} 6930 6931/* Notify on input select change */ 6932static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer) 6933{ 6934 struct snd_card *card = mixer->chip->card; 6935 struct scarlett2_data *private = mixer->private_data; 6936 const struct scarlett2_device_info *info = private->info; 6937 int i; 6938 6939 if (!info->gain_input_count) 6940 return; 6941 6942 private->input_select_updated = 1; 6943 6944 snd_ctl_notify(card, 6945 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 6946 &private->input_select_ctl->id); 6947 6948 for (i = 0; i < info->gain_input_count / 2; i++) 6949 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6950 &private->input_link_ctls[i]->id); 6951} 6952 6953/* Notify on input gain change */ 6954static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer) 6955{ 6956 struct snd_card *card = mixer->chip->card; 6957 struct scarlett2_data *private = mixer->private_data; 6958 const struct scarlett2_device_info *info = private->info; 6959 int i; 6960 6961 if (!info->gain_input_count) 6962 return; 6963 6964 private->input_gain_updated = 1; 6965 6966 for (i = 0; i < info->gain_input_count; i++) 6967 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6968 &private->input_gain_ctls[i]->id); 6969} 6970 6971/* Notify on autogain change */ 6972static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer) 6973{ 6974 struct snd_card *card = mixer->chip->card; 6975 struct scarlett2_data *private = mixer->private_data; 6976 const struct scarlett2_device_info *info = private->info; 6977 int i; 6978 6979 if (!info->gain_input_count) 6980 return; 6981 6982 private->autogain_updated = 1; 6983 6984 for (i = 0; i < info->gain_input_count; i++) { 6985 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6986 &private->autogain_ctls[i]->id); 6987 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 6988 &private->autogain_status_ctls[i]->id); 6989 } 6990 6991 scarlett2_autogain_notify_access(mixer); 6992} 6993 6994/* Notify on input safe switch change */ 6995static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer) 6996{ 6997 struct snd_card *card = mixer->chip->card; 6998 struct scarlett2_data *private = mixer->private_data; 6999 const struct scarlett2_device_info *info = private->info; 7000 int i; 7001 7002 if (!info->gain_input_count) 7003 return; 7004 7005 private->input_safe_updated = 1; 7006 7007 for (i = 0; i < info->gain_input_count; i++) 7008 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7009 &private->safe_ctls[i]->id); 7010} 7011 7012/* Notify on "monitor other" change (speaker switching, talkback) */ 7013static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer) 7014{ 7015 struct snd_card *card = mixer->chip->card; 7016 struct scarlett2_data *private = mixer->private_data; 7017 const struct scarlett2_device_info *info = private->info; 7018 7019 private->monitor_other_updated = 1; 7020 7021 if (info->has_speaker_switching) 7022 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7023 &private->speaker_switching_ctl->id); 7024 7025 if (info->has_talkback) 7026 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7027 &private->talkback_ctl->id); 7028 7029 /* if speaker switching was recently enabled or disabled, 7030 * invalidate the dim/mute and mux enum controls 7031 */ 7032 if (private->speaker_switching_switched) { 7033 int i; 7034 7035 scarlett2_notify_dim_mute(mixer); 7036 7037 private->speaker_switching_switched = 0; 7038 private->mux_updated = 1; 7039 7040 for (i = 0; i < private->num_mux_dsts; i++) 7041 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7042 &private->mux_ctls[i]->id); 7043 } 7044} 7045 7046/* Notify on direct monitor switch change */ 7047static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer) 7048{ 7049 struct snd_card *card = mixer->chip->card; 7050 struct scarlett2_data *private = mixer->private_data; 7051 int count = private->num_mix_in * private->num_mix_out; 7052 int i; 7053 7054 private->direct_monitor_updated = 1; 7055 7056 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7057 &private->direct_monitor_ctl->id); 7058 7059 if (!scarlett2_has_mixer(private)) 7060 return; 7061 7062 private->mix_updated = 1; 7063 7064 /* Notify of change to the mix controls */ 7065 for (i = 0; i < count; i++) 7066 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7067 &private->mix_ctls[i]->id); 7068} 7069 7070/* Notify on power change */ 7071static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer) 7072{ 7073 struct snd_card *card = mixer->chip->card; 7074 struct scarlett2_data *private = mixer->private_data; 7075 7076 private->power_status_updated = 1; 7077 7078 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7079 &private->power_status_ctl->id); 7080} 7081 7082/* Notify on mux change */ 7083static void scarlett2_notify_mux(struct usb_mixer_interface *mixer) 7084{ 7085 struct snd_card *card = mixer->chip->card; 7086 struct scarlett2_data *private = mixer->private_data; 7087 int i; 7088 7089 private->mux_updated = 1; 7090 7091 for (i = 0; i < private->num_mux_dsts; i++) 7092 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7093 &private->mux_ctls[i]->id); 7094} 7095 7096/* Notify on PCM input switch change */ 7097static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer) 7098{ 7099 struct snd_card *card = mixer->chip->card; 7100 struct scarlett2_data *private = mixer->private_data; 7101 7102 private->pcm_input_switch_updated = 1; 7103 7104 snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, 7105 &private->pcm_input_switch_ctl->id); 7106 7107 scarlett2_notify_mux(mixer); 7108} 7109 7110/* Interrupt callback */ 7111static void scarlett2_notify(struct urb *urb) 7112{ 7113 struct usb_mixer_interface *mixer = urb->context; 7114 int len = urb->actual_length; 7115 int ustatus = urb->status; 7116 u32 data; 7117 struct scarlett2_data *private = mixer->private_data; 7118 const struct scarlett2_notification *notifications = 7119 private->config_set->notifications; 7120 7121 if (ustatus != 0 || len != 8) 7122 goto requeue; 7123 7124 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer); 7125 7126 while (data && notifications->mask) { 7127 if (data & notifications->mask) { 7128 data &= ~notifications->mask; 7129 if (notifications->func) 7130 notifications->func(mixer); 7131 } 7132 notifications++; 7133 } 7134 7135 if (data) 7136 usb_audio_warn(mixer->chip, 7137 "%s: Unhandled notification: 0x%08x\n", 7138 __func__, data); 7139 7140requeue: 7141 if (ustatus != -ENOENT && 7142 ustatus != -ECONNRESET && 7143 ustatus != -ESHUTDOWN) { 7144 urb->dev = mixer->chip->dev; 7145 usb_submit_urb(urb, GFP_ATOMIC); 7146 } 7147} 7148 7149static int scarlett2_init_notify(struct usb_mixer_interface *mixer) 7150{ 7151 struct usb_device *dev = mixer->chip->dev; 7152 struct scarlett2_data *private = mixer->private_data; 7153 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress); 7154 void *transfer_buffer; 7155 7156 if (mixer->urb) { 7157 usb_audio_err(mixer->chip, 7158 "%s: mixer urb already in use!\n", __func__); 7159 return 0; 7160 } 7161 7162 if (usb_pipe_type_check(dev, pipe)) 7163 return -EINVAL; 7164 7165 mixer->urb = usb_alloc_urb(0, GFP_KERNEL); 7166 if (!mixer->urb) 7167 return -ENOMEM; 7168 7169 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL); 7170 if (!transfer_buffer) 7171 return -ENOMEM; 7172 7173 usb_fill_int_urb(mixer->urb, dev, pipe, 7174 transfer_buffer, private->wMaxPacketSize, 7175 scarlett2_notify, mixer, private->bInterval); 7176 7177 return usb_submit_urb(mixer->urb, GFP_KERNEL); 7178} 7179 7180static const struct scarlett2_device_entry *get_scarlett2_device_entry( 7181 struct usb_mixer_interface *mixer) 7182{ 7183 const struct scarlett2_device_entry *entry = scarlett2_devices; 7184 7185 /* Find entry in scarlett2_devices */ 7186 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id) 7187 entry++; 7188 if (!entry->usb_id) 7189 return NULL; 7190 7191 return entry; 7192} 7193 7194static int snd_scarlett2_controls_create( 7195 struct usb_mixer_interface *mixer, 7196 const struct scarlett2_device_entry *entry) 7197{ 7198 struct scarlett2_data *private; 7199 int err; 7200 7201 /* Initialise private data */ 7202 err = scarlett2_init_private(mixer, entry); 7203 if (err < 0) 7204 return err; 7205 7206 private = mixer->private_data; 7207 7208 /* Send proprietary USB initialisation sequence */ 7209 err = scarlett2_usb_init(mixer); 7210 if (err < 0) 7211 return err; 7212 7213 /* Get the upgrade & settings flash segment numbers */ 7214 err = scarlett2_get_flash_segment_nums(mixer); 7215 if (err < 0) 7216 return err; 7217 7218 /* Add firmware version control */ 7219 err = scarlett2_add_firmware_version_ctl(mixer); 7220 if (err < 0) 7221 return err; 7222 7223 /* Add minimum firmware version control */ 7224 err = scarlett2_add_min_firmware_version_ctl(mixer); 7225 if (err < 0) 7226 return err; 7227 7228 /* Read volume levels and controls from the interface */ 7229 err = scarlett2_read_configs(mixer); 7230 if (err < 0) 7231 return err; 7232 7233 /* Create the MSD control */ 7234 err = scarlett2_add_msd_ctl(mixer); 7235 if (err < 0) 7236 return err; 7237 7238 /* If MSD mode is enabled, or if the firmware version is too 7239 * old, don't create any other controls 7240 */ 7241 if (private->msd_switch || 7242 private->firmware_version < private->info->min_firmware_version) 7243 return 0; 7244 7245 /* Create the analogue output controls */ 7246 err = scarlett2_add_line_out_ctls(mixer); 7247 if (err < 0) 7248 return err; 7249 7250 /* Create the analogue input controls */ 7251 err = scarlett2_add_line_in_ctls(mixer); 7252 if (err < 0) 7253 return err; 7254 7255 /* Create the input, output, and mixer mux input selections */ 7256 err = scarlett2_add_mux_enums(mixer); 7257 if (err < 0) 7258 return err; 7259 7260 /* Create the matrix mixer controls */ 7261 err = scarlett2_add_mixer_ctls(mixer); 7262 if (err < 0) 7263 return err; 7264 7265 /* Create the level meter controls */ 7266 err = scarlett2_add_meter_ctl(mixer); 7267 if (err < 0) 7268 return err; 7269 7270 /* Create the sync control */ 7271 err = scarlett2_add_sync_ctl(mixer); 7272 if (err < 0) 7273 return err; 7274 7275 /* Create the direct monitor control(s) */ 7276 err = scarlett2_add_direct_monitor_ctls(mixer); 7277 if (err < 0) 7278 return err; 7279 7280 /* Create the speaker switching control */ 7281 err = scarlett2_add_speaker_switch_ctl(mixer); 7282 if (err < 0) 7283 return err; 7284 7285 /* Create the talkback controls */ 7286 err = scarlett2_add_talkback_ctls(mixer); 7287 if (err < 0) 7288 return err; 7289 7290 /* Create the standalone control */ 7291 err = scarlett2_add_standalone_ctl(mixer); 7292 if (err < 0) 7293 return err; 7294 7295 /* Create the power status control */ 7296 err = scarlett2_add_power_status_ctl(mixer); 7297 if (err < 0) 7298 return err; 7299 7300 /* Set the access mode of controls disabled during 7301 * autogain/phantom power switching. 7302 */ 7303 if (private->info->gain_input_count) { 7304 scarlett2_autogain_update_access(mixer); 7305 scarlett2_phantom_update_access(mixer); 7306 } 7307 7308 /* Set up the interrupt polling */ 7309 err = scarlett2_init_notify(mixer); 7310 if (err < 0) 7311 return err; 7312 7313 return 0; 7314} 7315 7316/*** hwdep interface ***/ 7317 7318/* Set private->hwdep_in_use; prevents access to the ALSA controls 7319 * while doing a config erase/firmware upgrade. 7320 */ 7321static void scarlett2_lock(struct scarlett2_data *private) 7322{ 7323 mutex_lock(&private->data_mutex); 7324 private->hwdep_in_use = 1; 7325 mutex_unlock(&private->data_mutex); 7326} 7327 7328/* Call SCARLETT2_USB_GET_ERASE to get the erase progress */ 7329static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer) 7330{ 7331 struct scarlett2_data *private = mixer->private_data; 7332 int segment_id, segment_num, err; 7333 u8 erase_resp; 7334 7335 struct { 7336 __le32 segment_num; 7337 __le32 pad; 7338 } __packed erase_req; 7339 7340 segment_id = private->selected_flash_segment_id; 7341 segment_num = private->flash_segment_nums[segment_id]; 7342 7343 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 7344 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 7345 return -EFAULT; 7346 7347 /* Send the erase progress request */ 7348 erase_req.segment_num = cpu_to_le32(segment_num); 7349 erase_req.pad = 0; 7350 7351 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE, 7352 &erase_req, sizeof(erase_req), 7353 &erase_resp, sizeof(erase_resp)); 7354 if (err < 0) 7355 return err; 7356 7357 return erase_resp; 7358} 7359 7360/* Repeatedly call scarlett2_get_erase_progress() until it returns 7361 * 0xff (erase complete) or we've waited 10 seconds (it usually takes 7362 * <3 seconds). 7363 */ 7364static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer) 7365{ 7366 int i, err; 7367 7368 for (i = 0; i < 100; i++) { 7369 err = scarlett2_get_erase_progress(mixer); 7370 if (err < 0) 7371 return err; 7372 7373 if (err == 0xff) 7374 return 0; 7375 7376 msleep(100); 7377 } 7378 7379 return -ETIMEDOUT; 7380} 7381 7382/* Reboot the device; wait for the erase to complete if one is in 7383 * progress. 7384 */ 7385static int scarlett2_reboot(struct usb_mixer_interface *mixer) 7386{ 7387 struct scarlett2_data *private = mixer->private_data; 7388 7389 if (private->flash_write_state == 7390 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 7391 int err = scarlett2_wait_for_erase(mixer); 7392 7393 if (err < 0) 7394 return err; 7395 } 7396 7397 return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0); 7398} 7399 7400/* Select a flash segment for erasing (and possibly writing to) */ 7401static int scarlett2_ioctl_select_flash_segment( 7402 struct usb_mixer_interface *mixer, 7403 unsigned long arg) 7404{ 7405 struct scarlett2_data *private = mixer->private_data; 7406 int segment_id, segment_num; 7407 7408 if (get_user(segment_id, (int __user *)arg)) 7409 return -EFAULT; 7410 7411 /* Check the segment ID and segment number */ 7412 if (segment_id < 0 || segment_id >= SCARLETT2_SEGMENT_ID_COUNT) 7413 return -EINVAL; 7414 7415 segment_num = private->flash_segment_nums[segment_id]; 7416 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 7417 segment_num > SCARLETT2_SEGMENT_NUM_MAX) { 7418 usb_audio_err(mixer->chip, 7419 "%s: invalid segment number %d\n", 7420 __func__, segment_id); 7421 return -EFAULT; 7422 } 7423 7424 /* If erasing, wait for it to complete */ 7425 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) { 7426 int err = scarlett2_wait_for_erase(mixer); 7427 7428 if (err < 0) 7429 return err; 7430 } 7431 7432 /* Save the selected segment ID and set the state to SELECTED */ 7433 private->selected_flash_segment_id = segment_id; 7434 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED; 7435 7436 return 0; 7437} 7438 7439/* Erase the previously-selected flash segment */ 7440static int scarlett2_ioctl_erase_flash_segment( 7441 struct usb_mixer_interface *mixer) 7442{ 7443 struct scarlett2_data *private = mixer->private_data; 7444 int segment_id, segment_num, err; 7445 7446 struct { 7447 __le32 segment_num; 7448 __le32 pad; 7449 } __packed erase_req; 7450 7451 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED) 7452 return -EINVAL; 7453 7454 segment_id = private->selected_flash_segment_id; 7455 segment_num = private->flash_segment_nums[segment_id]; 7456 7457 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 7458 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 7459 return -EFAULT; 7460 7461 /* Prevent access to ALSA controls that access the device from 7462 * here on 7463 */ 7464 scarlett2_lock(private); 7465 7466 /* Send the erase request */ 7467 erase_req.segment_num = cpu_to_le32(segment_num); 7468 erase_req.pad = 0; 7469 7470 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT, 7471 &erase_req, sizeof(erase_req), 7472 NULL, 0); 7473 if (err < 0) 7474 return err; 7475 7476 /* On success, change the state from SELECTED to ERASING */ 7477 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING; 7478 7479 return 0; 7480} 7481 7482/* Get the erase progress from the device */ 7483static int scarlett2_ioctl_get_erase_progress( 7484 struct usb_mixer_interface *mixer, 7485 unsigned long arg) 7486{ 7487 struct scarlett2_data *private = mixer->private_data; 7488 struct scarlett2_flash_segment_erase_progress progress; 7489 int segment_id, segment_num, err; 7490 u8 erase_resp; 7491 7492 struct { 7493 __le32 segment_num; 7494 __le32 pad; 7495 } __packed erase_req; 7496 7497 /* Check that we're erasing */ 7498 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) 7499 return -EINVAL; 7500 7501 segment_id = private->selected_flash_segment_id; 7502 segment_num = private->flash_segment_nums[segment_id]; 7503 7504 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 7505 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 7506 return -EFAULT; 7507 7508 /* Send the erase progress request */ 7509 erase_req.segment_num = cpu_to_le32(segment_num); 7510 erase_req.pad = 0; 7511 7512 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE, 7513 &erase_req, sizeof(erase_req), 7514 &erase_resp, sizeof(erase_resp)); 7515 if (err < 0) 7516 return err; 7517 7518 progress.progress = erase_resp; 7519 progress.num_blocks = private->flash_segment_blocks[segment_id]; 7520 7521 if (copy_to_user((void __user *)arg, &progress, sizeof(progress))) 7522 return -EFAULT; 7523 7524 /* If the erase is complete, change the state from ERASING to 7525 * WRITE. 7526 */ 7527 if (progress.progress == 0xff) 7528 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; 7529 7530 return 0; 7531} 7532 7533static int scarlett2_hwdep_open(struct snd_hwdep *hw, struct file *file) 7534{ 7535 struct usb_mixer_interface *mixer = hw->private_data; 7536 struct scarlett2_data *private = mixer->private_data; 7537 7538 /* If erasing, wait for it to complete */ 7539 if (private->flash_write_state == 7540 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 7541 int err = scarlett2_wait_for_erase(mixer); 7542 7543 if (err < 0) 7544 return err; 7545 } 7546 7547 /* Set the state to IDLE */ 7548 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; 7549 7550 return 0; 7551} 7552 7553static int scarlett2_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, 7554 unsigned int cmd, unsigned long arg) 7555{ 7556 struct usb_mixer_interface *mixer = hw->private_data; 7557 7558 switch (cmd) { 7559 7560 case SCARLETT2_IOCTL_PVERSION: 7561 return put_user(SCARLETT2_HWDEP_VERSION, 7562 (int __user *)arg) ? -EFAULT : 0; 7563 7564 case SCARLETT2_IOCTL_REBOOT: 7565 return scarlett2_reboot(mixer); 7566 7567 case SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT: 7568 return scarlett2_ioctl_select_flash_segment(mixer, arg); 7569 7570 case SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT: 7571 return scarlett2_ioctl_erase_flash_segment(mixer); 7572 7573 case SCARLETT2_IOCTL_GET_ERASE_PROGRESS: 7574 return scarlett2_ioctl_get_erase_progress(mixer, arg); 7575 7576 default: 7577 return -ENOIOCTLCMD; 7578 } 7579} 7580 7581static long scarlett2_hwdep_write(struct snd_hwdep *hw, 7582 const char __user *buf, 7583 long count, loff_t *offset) 7584{ 7585 struct usb_mixer_interface *mixer = hw->private_data; 7586 struct scarlett2_data *private = mixer->private_data; 7587 int segment_id, segment_num, err, len; 7588 int flash_size; 7589 7590 /* SCARLETT2_USB_WRITE_SEGMENT request data */ 7591 struct { 7592 __le32 segment_num; 7593 __le32 offset; 7594 __le32 pad; 7595 u8 data[]; 7596 } __packed *req; 7597 7598 /* Calculate the maximum permitted in data[] */ 7599 const size_t max_data_size = SCARLETT2_FLASH_WRITE_MAX - 7600 offsetof(typeof(*req), data); 7601 7602 /* If erasing, wait for it to complete */ 7603 if (private->flash_write_state == 7604 SCARLETT2_FLASH_WRITE_STATE_ERASING) { 7605 err = scarlett2_wait_for_erase(mixer); 7606 if (err < 0) 7607 return err; 7608 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; 7609 7610 /* Check that an erase has been done & completed */ 7611 } else if (private->flash_write_state != 7612 SCARLETT2_FLASH_WRITE_STATE_WRITE) { 7613 return -EINVAL; 7614 } 7615 7616 /* Check that we're writing to the upgrade firmware */ 7617 segment_id = private->selected_flash_segment_id; 7618 if (segment_id != SCARLETT2_SEGMENT_ID_FIRMWARE) 7619 return -EINVAL; 7620 7621 segment_num = private->flash_segment_nums[segment_id]; 7622 if (segment_num < SCARLETT2_SEGMENT_NUM_MIN || 7623 segment_num > SCARLETT2_SEGMENT_NUM_MAX) 7624 return -EFAULT; 7625 7626 /* Validate the offset and count */ 7627 flash_size = private->flash_segment_blocks[segment_id] * 7628 SCARLETT2_FLASH_BLOCK_SIZE; 7629 7630 if (count < 0 || *offset < 0 || *offset + count >= flash_size) 7631 return -EINVAL; 7632 7633 if (!count) 7634 return 0; 7635 7636 /* Limit the *req size to SCARLETT2_FLASH_WRITE_MAX */ 7637 if (count > max_data_size) 7638 count = max_data_size; 7639 7640 /* Create and send the request */ 7641 len = struct_size(req, data, count); 7642 req = kzalloc(len, GFP_KERNEL); 7643 if (!req) 7644 return -ENOMEM; 7645 7646 req->segment_num = cpu_to_le32(segment_num); 7647 req->offset = cpu_to_le32(*offset); 7648 req->pad = 0; 7649 7650 if (copy_from_user(req->data, buf, count)) { 7651 err = -EFAULT; 7652 goto error; 7653 } 7654 7655 err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT, 7656 req, len, NULL, 0); 7657 if (err < 0) 7658 goto error; 7659 7660 *offset += count; 7661 err = count; 7662 7663error: 7664 kfree(req); 7665 return err; 7666} 7667 7668static int scarlett2_hwdep_release(struct snd_hwdep *hw, struct file *file) 7669{ 7670 struct usb_mixer_interface *mixer = hw->private_data; 7671 struct scarlett2_data *private = mixer->private_data; 7672 7673 /* Return from the SELECTED or WRITE state to IDLE. 7674 * The ERASING state is left as-is, and checked on next open. 7675 */ 7676 if (private && 7677 private->hwdep_in_use && 7678 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) 7679 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; 7680 7681 return 0; 7682} 7683 7684static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer) 7685{ 7686 struct snd_hwdep *hw; 7687 int err; 7688 7689 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw); 7690 if (err < 0) 7691 return err; 7692 7693 hw->private_data = mixer; 7694 hw->exclusive = 1; 7695 hw->ops.open = scarlett2_hwdep_open; 7696 hw->ops.ioctl = scarlett2_hwdep_ioctl; 7697 hw->ops.write = scarlett2_hwdep_write; 7698 hw->ops.release = scarlett2_hwdep_release; 7699 7700 return 0; 7701} 7702 7703int snd_scarlett2_init(struct usb_mixer_interface *mixer) 7704{ 7705 struct snd_usb_audio *chip = mixer->chip; 7706 const struct scarlett2_device_entry *entry; 7707 int err; 7708 7709 /* only use UAC_VERSION_2 */ 7710 if (!mixer->protocol) 7711 return 0; 7712 7713 /* find entry in scarlett2_devices */ 7714 entry = get_scarlett2_device_entry(mixer); 7715 if (!entry) { 7716 usb_audio_err(mixer->chip, 7717 "%s: missing device entry for %04x:%04x\n", 7718 __func__, 7719 USB_ID_VENDOR(chip->usb_id), 7720 USB_ID_PRODUCT(chip->usb_id)); 7721 return 0; 7722 } 7723 7724 if (chip->setup & SCARLETT2_DISABLE) { 7725 usb_audio_info(chip, 7726 "Focusrite %s Mixer Driver disabled " 7727 "by modprobe options (snd_usb_audio " 7728 "vid=0x%04x pid=0x%04x device_setup=%d)\n", 7729 entry->series_name, 7730 USB_ID_VENDOR(chip->usb_id), 7731 USB_ID_PRODUCT(chip->usb_id), 7732 SCARLETT2_DISABLE); 7733 return 0; 7734 } 7735 7736 usb_audio_info(chip, 7737 "Focusrite %s Mixer Driver enabled (pid=0x%04x); " 7738 "report any issues to " 7739 "https://github.com/geoffreybennett/scarlett-gen2/issues", 7740 entry->series_name, 7741 USB_ID_PRODUCT(chip->usb_id)); 7742 7743 err = snd_scarlett2_controls_create(mixer, entry); 7744 if (err < 0) { 7745 usb_audio_err(mixer->chip, 7746 "Error initialising %s Mixer Driver: %d", 7747 entry->series_name, 7748 err); 7749 return err; 7750 } 7751 7752 err = scarlett2_hwdep_init(mixer); 7753 if (err < 0) 7754 usb_audio_err(mixer->chip, 7755 "Error creating %s hwdep device: %d", 7756 entry->series_name, 7757 err); 7758 7759 return err; 7760} 7761