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