sound/usb/mixer_scarlett_gen2.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *   Focusrite Scarlett 6i6/18i8/18i20 Gen 2 Driver for ALSA
   4  *
   5  *   Copyright (c) 2018-2019 by Geoffrey D. Bennett <g at b4.vu>
   6  *
   7  *   Based on the Scarlett (Gen 1) Driver for ALSA:
   8  *
   9  *   Copyright (c) 2013 by Tobias Hoffmann
  10  *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
  11  *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
  12  *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
  13  *
  14  *   Many codes borrowed from audio.c by
  15  *     Alan Cox (alan at lxorguk.ukuu.org.uk)
  16  *     Thomas Sailer (sailer at ife.ee.ethz.ch)
  17  *
  18  *   Code cleanup:
  19  *   David Henningsson <david.henningsson at canonical.com>
  20  */
  21
  22 /* Mixer Interface for the Focusrite Scarlett 6i6/18i8/18i20 Gen 2 audio
  23  * interface. Based on the Gen 1 driver and rewritten.
  24  */
  25
  26 /* The protocol was reverse engineered by looking at the communication
  27  * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
  28  * (firmware 1083) using usbmon in July-August 2018.
  29  *
  30  * Scarlett 18i8 support added in April 2019.
  31  *
  32  * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
  33  * for providing usbmon output and testing).
  34  *
  35  * This ALSA mixer gives access to:
  36  *  - input, output, mixer-matrix muxes
  37  *  - 18x10 mixer-matrix gain stages
  38  *  - gain/volume controls
  39  *  - level meters
  40  *  - line/inst level and pad controls
  41  *
  42  * <ditaa>
  43  *    /--------------\    18chn            20chn     /--------------\
  44  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
  45  *    \--------------/  |      |    |             |  \--------------/
  46  *                      |      |    |    /-----\  |
  47  *                      |      |    |    |     |  |
  48  *                      |      v    v    v     |  |
  49  *                      |   +---------------+  |  |
  50  *                      |    \ Matrix  Mux /   |  |
  51  *                      |     +-----+-----+    |  |
  52  *                      |           |          |  |
  53  *                      |           |18chn     |  |
  54  *                      |           |          |  |
  55  *                      |           |     10chn|  |
  56  *                      |           v          |  |
  57  *                      |     +------------+   |  |
  58  *                      |     | Mixer      |   |  |
  59  *                      |     |     Matrix |   |  |
  60  *                      |     |            |   |  |
  61  *                      |     | 18x10 Gain |   |  |
  62  *                      |     |   stages   |   |  |
  63  *                      |     +-----+------+   |  |
  64  *                      |           |          |  |
  65  *                      |18chn      |10chn     |  |20chn
  66  *                      |           |          |  |
  67  *                      |           +----------/  |
  68  *                      |           |             |
  69  *                      v           v             v
  70  *                      ===========================
  71  *               +---------------+       +--—------------+
  72  *                \ Output  Mux /         \ Capture Mux /
  73  *                 +---+---+---+           +-----+-----+
  74  *                     |   |                     |
  75  *                10chn|   |                     |18chn
  76  *                     |   |                     |
  77  *  /--------------\   |   |                     |   /--------------\
  78  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
  79  *  | Hardware out |       |                         \--------------/
  80  *  \--------------/       |
  81  *                         v
  82  *                  +-------------+    Software gain per channel.
  83  *                  | Master Gain |<-- 18i20 only: Switch per channel
  84  *                  +------+------+    to select HW or SW gain control.
  85  *                         |
  86  *                         |10chn
  87  *  /--------------\       |
  88  *  | Analogue     |<------/
  89  *  | Hardware out |
  90  *  \--------------/
  91  * </ditaa>
  92  *
  93  */
  94
  95 #include <linux/slab.h>
  96 #include <linux/usb.h>
  97 #include <linux/moduleparam.h>
  98
  99 #include <sound/control.h>
 100 #include <sound/tlv.h>
 101
 102 #include "usbaudio.h"
 103 #include "mixer.h"
 104 #include "helper.h"
 105
 106 #include "mixer_scarlett_gen2.h"
 107
 108 /* device_setup value to enable */
 109 #define SCARLETT2_ENABLE 0x01
 110
 111 /* some gui mixers can't handle negative ctl values */
 112 #define SCARLETT2_VOLUME_BIAS 127
 113
 114 /* mixer range from -80dB to +6dB in 0.5dB steps */
 115 #define SCARLETT2_MIXER_MIN_DB -80
 116 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
 117 #define SCARLETT2_MIXER_MAX_DB 6
 118 #define SCARLETT2_MIXER_MAX_VALUE \
 119         ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
 120
 121 /* map from (dB + 80) * 2 to mixer value
 122  * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
 123  */
 124 static const u16 scarlett2_mixer_values[173] = {
 125         0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
 126         2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
 127         9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
 128         23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
 129         54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
 130         122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
 131         244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
 132         487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
 133         973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
 134         1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
 135         3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
 136         5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
 137         9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
 138         16345
 139 };
 140
 141 /* Maximum number of analogue outputs */
 142 #define SCARLETT2_ANALOGUE_MAX 10
 143
 144 /* Maximum number of level and pad switches */
 145 #define SCARLETT2_LEVEL_SWITCH_MAX 2
 146 #define SCARLETT2_PAD_SWITCH_MAX 4
 147
 148 /* Maximum number of inputs to the mixer */
 149 #define SCARLETT2_INPUT_MIX_MAX 18
 150
 151 /* Maximum number of outputs from the mixer */
 152 #define SCARLETT2_OUTPUT_MIX_MAX 10
 153
 154 /* Maximum size of the data in the USB mux assignment message:
 155  * 18 inputs, 20 outputs, 18 matrix inputs, 8 spare
 156  */
 157 #define SCARLETT2_MUX_MAX 64
 158
 159 /* Number of meters:
 160  * 18 inputs, 20 outputs, 18 matrix inputs
 161  */
 162 #define SCARLETT2_NUM_METERS 56
 163
 164 /* Hardware port types:
 165  * - None (no input to mux)
 166  * - Analogue I/O
 167  * - S/PDIF I/O
 168  * - ADAT I/O
 169  * - Mixer I/O
 170  * - PCM I/O
 171  */
 172 enum {
 173         SCARLETT2_PORT_TYPE_NONE = 0,
 174         SCARLETT2_PORT_TYPE_ANALOGUE = 1,
 175         SCARLETT2_PORT_TYPE_SPDIF = 2,
 176         SCARLETT2_PORT_TYPE_ADAT = 3,
 177         SCARLETT2_PORT_TYPE_MIX = 4,
 178         SCARLETT2_PORT_TYPE_PCM = 5,
 179         SCARLETT2_PORT_TYPE_COUNT = 6,
 180 };
 181
 182 /* Count of total I/O and number available at each sample rate */
 183 enum {
 184         SCARLETT2_PORT_IN = 0,
 185         SCARLETT2_PORT_OUT = 1,
 186         SCARLETT2_PORT_OUT_44 = 2,
 187         SCARLETT2_PORT_OUT_88 = 3,
 188         SCARLETT2_PORT_OUT_176 = 4,
 189         SCARLETT2_PORT_DIRECTIONS = 5,
 190 };
 191
 192 /* Hardware buttons on the 18i20 */
 193 #define SCARLETT2_BUTTON_MAX 2
 194
 195 static const char *const scarlett2_button_names[SCARLETT2_BUTTON_MAX] = {
 196         "Mute", "Dim"
 197 };
 198
 199 /* Description of each hardware port type:
 200  * - id: hardware ID for this port type
 201  * - num: number of sources/destinations of this port type
 202  * - src_descr: printf format string for mux input selections
 203  * - src_num_offset: added to channel number for the fprintf
 204  * - dst_descr: printf format string for mixer controls
 205  */
 206 struct scarlett2_ports {
 207         u16 id;
 208         int num[SCARLETT2_PORT_DIRECTIONS];
 209         const char * const src_descr;
 210         int src_num_offset;
 211         const char * const dst_descr;
 212 };
 213
 214 struct scarlett2_device_info {
 215         u8 line_out_hw_vol; /* line out hw volume is sw controlled */
 216         u8 button_count; /* number of buttons */
 217         u8 level_input_count; /* inputs with level selectable */
 218         u8 pad_input_count; /* inputs with pad selectable */
 219         const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
 220         struct scarlett2_ports ports[SCARLETT2_PORT_TYPE_COUNT];
 221 };
 222
 223 struct scarlett2_mixer_data {
 224         struct usb_mixer_interface *mixer;
 225         struct mutex usb_mutex; /* prevent sending concurrent USB requests */
 226         struct mutex data_mutex; /* lock access to this data */
 227         struct delayed_work work;
 228         const struct scarlett2_device_info *info;
 229         int num_mux_srcs;
 230         u16 scarlett2_seq;
 231         u8 vol_updated;
 232         u8 master_vol;
 233         u8 vol[SCARLETT2_ANALOGUE_MAX];
 234         u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
 235         u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
 236         u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
 237         u8 buttons[SCARLETT2_BUTTON_MAX];
 238         struct snd_kcontrol *master_vol_ctl;
 239         struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
 240         struct snd_kcontrol *button_ctls[SCARLETT2_BUTTON_MAX];
 241         u8 mux[SCARLETT2_MUX_MAX];
 242         u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
 243 };
 244
 245 /*** Model-specific data ***/
 246
 247 static const struct scarlett2_device_info s6i6_gen2_info = {
 248         /* The first two analogue inputs can be switched between line
 249          * and instrument levels.
 250          */
 251         .level_input_count = 2,
 252
 253         /* The first two analogue inputs have an optional pad. */
 254         .pad_input_count = 2,
 255
 256         .line_out_descrs = {
 257                 "Headphones 1 L",
 258                 "Headphones 1 R",
 259                 "Headphones 2 L",
 260                 "Headphones 2 R",
 261         },
 262
 263         .ports = {
 264                 [SCARLETT2_PORT_TYPE_NONE] = {
 265                         .id = 0x000,
 266                         .num = { 1, 0, 8, 8, 8 },
 267                         .src_descr = "Off",
 268                         .src_num_offset = 0,
 269                 },
 270                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {
 271                         .id = 0x080,
 272                         .num = { 4, 4, 4, 4, 4 },
 273                         .src_descr = "Analogue %d",
 274                         .src_num_offset = 1,
 275                         .dst_descr = "Analogue Output %02d Playback"
 276                 },
 277                 [SCARLETT2_PORT_TYPE_SPDIF] = {
 278                         .id = 0x180,
 279                         .num = { 2, 2, 2, 2, 2 },
 280                         .src_descr = "S/PDIF %d",
 281                         .src_num_offset = 1,
 282                         .dst_descr = "S/PDIF Output %d Playback"
 283                 },
 284                 [SCARLETT2_PORT_TYPE_MIX] = {
 285                         .id = 0x300,
 286                         .num = { 10, 18, 18, 18, 18 },
 287                         .src_descr = "Mix %c",
 288                         .src_num_offset = 65,
 289                         .dst_descr = "Mixer Input %02d Capture"
 290                 },
 291                 [SCARLETT2_PORT_TYPE_PCM] = {
 292                         .id = 0x600,
 293                         .num = { 6, 6, 6, 6, 6 },
 294                         .src_descr = "PCM %d",
 295                         .src_num_offset = 1,
 296                         .dst_descr = "PCM %02d Capture"
 297                 },
 298         },
 299 };
 300
 301 static const struct scarlett2_device_info s18i8_gen2_info = {
 302         /* The first two analogue inputs can be switched between line
 303          * and instrument levels.
 304          */
 305         .level_input_count = 2,
 306
 307         /* The first four analogue inputs have an optional pad. */
 308         .pad_input_count = 4,
 309
 310         .line_out_descrs = {
 311                 "Monitor L",
 312                 "Monitor R",
 313                 "Headphones 1 L",
 314                 "Headphones 1 R",
 315                 "Headphones 2 L",
 316                 "Headphones 2 R",
 317         },
 318
 319         .ports = {
 320                 [SCARLETT2_PORT_TYPE_NONE] = {
 321                         .id = 0x000,
 322                         .num = { 1, 0, 8, 8, 4 },
 323                         .src_descr = "Off",
 324                         .src_num_offset = 0,
 325                 },
 326                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {
 327                         .id = 0x080,
 328                         .num = { 8, 6, 6, 6, 6 },
 329                         .src_descr = "Analogue %d",
 330                         .src_num_offset = 1,
 331                         .dst_descr = "Analogue Output %02d Playback"
 332                 },
 333                 [SCARLETT2_PORT_TYPE_SPDIF] = {
 334                         .id = 0x180,
 335                         /* S/PDIF outputs aren't available at 192kHz
 336                          * but are included in the USB mux I/O
 337                          * assignment message anyway
 338                          */
 339                         .num = { 2, 2, 2, 2, 2 },
 340                         .src_descr = "S/PDIF %d",
 341                         .src_num_offset = 1,
 342                         .dst_descr = "S/PDIF Output %d Playback"
 343                 },
 344                 [SCARLETT2_PORT_TYPE_ADAT] = {
 345                         .id = 0x200,
 346                         .num = { 8, 0, 0, 0, 0 },
 347                         .src_descr = "ADAT %d",
 348                         .src_num_offset = 1,
 349                 },
 350                 [SCARLETT2_PORT_TYPE_MIX] = {
 351                         .id = 0x300,
 352                         .num = { 10, 18, 18, 18, 18 },
 353                         .src_descr = "Mix %c",
 354                         .src_num_offset = 65,
 355                         .dst_descr = "Mixer Input %02d Capture"
 356                 },
 357                 [SCARLETT2_PORT_TYPE_PCM] = {
 358                         .id = 0x600,
 359                         .num = { 8, 18, 18, 14, 10 },
 360                         .src_descr = "PCM %d",
 361                         .src_num_offset = 1,
 362                         .dst_descr = "PCM %02d Capture"
 363                 },
 364         },
 365 };
 366
 367 static const struct scarlett2_device_info s18i20_gen2_info = {
 368         /* The analogue line outputs on the 18i20 can be switched
 369          * between software and hardware volume control
 370          */
 371         .line_out_hw_vol = 1,
 372
 373         /* Mute and dim buttons */
 374         .button_count = 2,
 375
 376         .line_out_descrs = {
 377                 "Monitor L",
 378                 "Monitor R",
 379                 NULL,
 380                 NULL,
 381                 NULL,
 382                 NULL,
 383                 "Headphones 1 L",
 384                 "Headphones 1 R",
 385                 "Headphones 2 L",
 386                 "Headphones 2 R",
 387         },
 388
 389         .ports = {
 390                 [SCARLETT2_PORT_TYPE_NONE] = {
 391                         .id = 0x000,
 392                         .num = { 1, 0, 8, 8, 6 },
 393                         .src_descr = "Off",
 394                         .src_num_offset = 0,
 395                 },
 396                 [SCARLETT2_PORT_TYPE_ANALOGUE] = {
 397                         .id = 0x080,
 398                         .num = { 8, 10, 10, 10, 10 },
 399                         .src_descr = "Analogue %d",
 400                         .src_num_offset = 1,
 401                         .dst_descr = "Analogue Output %02d Playback"
 402                 },
 403                 [SCARLETT2_PORT_TYPE_SPDIF] = {
 404                         /* S/PDIF outputs aren't available at 192kHz
 405                          * but are included in the USB mux I/O
 406                          * assignment message anyway
 407                          */
 408                         .id = 0x180,
 409                         .num = { 2, 2, 2, 2, 2 },
 410                         .src_descr = "S/PDIF %d",
 411                         .src_num_offset = 1,
 412                         .dst_descr = "S/PDIF Output %d Playback"
 413                 },
 414                 [SCARLETT2_PORT_TYPE_ADAT] = {
 415                         .id = 0x200,
 416                         .num = { 8, 8, 8, 4, 0 },
 417                         .src_descr = "ADAT %d",
 418                         .src_num_offset = 1,
 419                         .dst_descr = "ADAT Output %d Playback"
 420                 },
 421                 [SCARLETT2_PORT_TYPE_MIX] = {
 422                         .id = 0x300,
 423                         .num = { 10, 18, 18, 18, 18 },
 424                         .src_descr = "Mix %c",
 425                         .src_num_offset = 65,
 426                         .dst_descr = "Mixer Input %02d Capture"
 427                 },
 428                 [SCARLETT2_PORT_TYPE_PCM] = {
 429                         .id = 0x600,
 430                         .num = { 20, 18, 18, 14, 10 },
 431                         .src_descr = "PCM %d",
 432                         .src_num_offset = 1,
 433                         .dst_descr = "PCM %02d Capture"
 434                 },
 435         },
 436 };
 437
 438 /* get the starting port index number for a given port type/direction */
 439 static int scarlett2_get_port_start_num(const struct scarlett2_ports *ports,
 440                                         int direction, int port_type)
 441 {
 442         int i, num = 0;
 443
 444         for (i = 0; i < port_type; i++)
 445                 num += ports[i].num[direction];
 446
 447         return num;
 448 }
 449
 450 /*** USB Interactions ***/
 451
 452 /* Vendor-Specific Interface, Endpoint, MaxPacketSize, Interval */
 453 #define SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE 5
 454 #define SCARLETT2_USB_INTERRUPT_ENDPOINT 4
 455 #define SCARLETT2_USB_INTERRUPT_MAX_DATA 64
 456 #define SCARLETT2_USB_INTERRUPT_INTERVAL 3
 457
 458 /* Interrupt flags for volume and mute/dim button changes */
 459 #define SCARLETT2_USB_INTERRUPT_VOL_CHANGE 0x400000
 460 #define SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE 0x200000
 461
 462 /* Commands for sending/receiving requests/responses */
 463 #define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ 2
 464 #define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP 3
 465
 466 #define SCARLETT2_USB_INIT_SEQ 0x00000000
 467 #define SCARLETT2_USB_GET_METER_LEVELS 0x00001001
 468 #define SCARLETT2_USB_SET_MIX 0x00002002
 469 #define SCARLETT2_USB_SET_MUX 0x00003002
 470 #define SCARLETT2_USB_GET_DATA 0x00800000
 471 #define SCARLETT2_USB_SET_DATA 0x00800001
 472 #define SCARLETT2_USB_DATA_CMD 0x00800002
 473 #define SCARLETT2_USB_CONFIG_SAVE 6
 474
 475 #define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
 476 #define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
 477
 478 /* volume status is read together (matches scarlett2_config_items[]) */
 479 struct scarlett2_usb_volume_status {
 480         /* mute & dim buttons */
 481         u8 buttons[SCARLETT2_BUTTON_MAX];
 482
 483         u8 pad1;
 484
 485         /* software volume setting */
 486         s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
 487
 488         /* actual volume of output inc. dim (-18dB) */
 489         s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
 490
 491         u8 pad2[SCARLETT2_ANALOGUE_MAX];
 492
 493         /* sw (0) or hw (1) controlled */
 494         u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
 495
 496         u8 pad3[6];
 497
 498         /* front panel volume knob */
 499         s16 master_vol;
 500 } __packed;
 501
 502 /* Configuration parameters that can be read and written */
 503 enum {
 504         SCARLETT2_CONFIG_BUTTONS = 0,
 505         SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
 506         SCARLETT2_CONFIG_SW_HW_SWITCH = 2,
 507         SCARLETT2_CONFIG_LEVEL_SWITCH = 3,
 508         SCARLETT2_CONFIG_PAD_SWITCH = 4,
 509         SCARLETT2_CONFIG_COUNT = 5
 510 };
 511
 512 /* Location, size, and activation command number for the configuration
 513  * parameters
 514  */
 515 struct scarlett2_config {
 516         u8 offset;
 517         u8 size;
 518         u8 activate;
 519 };
 520
 521 static const struct scarlett2_config
 522                 scarlett2_config_items[SCARLETT2_CONFIG_COUNT] = {
 523         /* Mute/Dim Buttons */
 524         {
 525                 .offset = 0x31,
 526                 .size = 1,
 527                 .activate = 2
 528         },
 529
 530         /* Line Out Volume */
 531         {
 532                 .offset = 0x34,
 533                 .size = 2,
 534                 .activate = 1
 535         },
 536
 537         /* SW/HW Volume Switch */
 538         {
 539                 .offset = 0x66,
 540                 .size = 1,
 541                 .activate = 3
 542         },
 543
 544         /* Level Switch */
 545         {
 546                 .offset = 0x7c,
 547                 .size = 1,
 548                 .activate = 7
 549         },
 550
 551         /* Pad Switch */
 552         {
 553                 .offset = 0x84,
 554                 .size = 1,
 555                 .activate = 8
 556         }
 557 };
 558
 559 /* proprietary request/response format */
 560 struct scarlett2_usb_packet {
 561         __le32 cmd;
 562         __le16 size;
 563         __le16 seq;
 564         __le32 error;
 565         __le32 pad;
 566         u8 data[];
 567 };
 568
 569 #define SCARLETT2_USB_PACKET_LEN (sizeof(struct scarlett2_usb_packet))
 570
 571 static void scarlett2_fill_request_header(struct scarlett2_mixer_data *private,
 572                                           struct scarlett2_usb_packet *req,
 573                                           u32 cmd, u16 req_size)
 574 {
 575         /* sequence must go up by 1 for each request */
 576         u16 seq = private->scarlett2_seq++;
 577
 578         req->cmd = cpu_to_le32(cmd);
 579         req->size = cpu_to_le16(req_size);
 580         req->seq = cpu_to_le16(seq);
 581         req->error = 0;
 582         req->pad = 0;
 583 }
 584
 585 /* Send a proprietary format request to the Scarlett interface */
 586 static int scarlett2_usb(
 587         struct usb_mixer_interface *mixer, u32 cmd,
 588         void *req_data, u16 req_size, void *resp_data, u16 resp_size)
 589 {
 590         struct scarlett2_mixer_data *private = mixer->private_data;
 591         u16 req_buf_size = sizeof(struct scarlett2_usb_packet) + req_size;
 592         u16 resp_buf_size = sizeof(struct scarlett2_usb_packet) + resp_size;
 593         struct scarlett2_usb_packet *req = NULL, *resp = NULL;
 594         int err = 0;
 595
 596         req = kmalloc(req_buf_size, GFP_KERNEL);
 597         if (!req) {
 598                 err = -ENOMEM;
 599                 goto error;
 600         }
 601
 602         resp = kmalloc(resp_buf_size, GFP_KERNEL);
 603         if (!resp) {
 604                 err = -ENOMEM;
 605                 goto error;
 606         }
 607
 608         mutex_lock(&private->usb_mutex);
 609
 610         /* build request message and send it */
 611
 612         scarlett2_fill_request_header(private, req, cmd, req_size);
 613
 614         if (req_size)
 615                 memcpy(req->data, req_data, req_size);
 616
 617         err = snd_usb_ctl_msg(mixer->chip->dev,
 618                         usb_sndctrlpipe(mixer->chip->dev, 0),
 619                         SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ,
 620                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
 621                         0,
 622                         SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
 623                         req,
 624                         req_buf_size);
 625
 626         if (err != req_buf_size) {
 627                 usb_audio_err(
 628                         mixer->chip,
 629                         "Scarlett Gen 2 USB request result cmd %x was %d\n",
 630                         cmd, err);
 631                 err = -EINVAL;
 632                 goto unlock;
 633         }
 634
 635         /* send a second message to get the response */
 636
 637         err = snd_usb_ctl_msg(mixer->chip->dev,
 638                         usb_rcvctrlpipe(mixer->chip->dev, 0),
 639                         SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP,
 640                         USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
 641                         0,
 642                         SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
 643                         resp,
 644                         resp_buf_size);
 645
 646         /* validate the response */
 647
 648         if (err != resp_buf_size) {
 649                 usb_audio_err(
 650                         mixer->chip,
 651                         "Scarlett Gen 2 USB response result cmd %x was %d\n",
 652                         cmd, err);
 653                 err = -EINVAL;
 654                 goto unlock;
 655         }
 656
 657         if (resp->cmd != req->cmd ||
 658             resp->seq != req->seq ||
 659             resp_size != le16_to_cpu(resp->size) ||
 660             resp->error ||
 661             resp->pad) {
 662                 usb_audio_err(
 663                         mixer->chip,
 664                         "Scarlett Gen 2 USB invalid response; "
 665                            "cmd tx/rx %d/%d seq %d/%d size %d/%d "
 666                            "error %d pad %d\n",
 667                         le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
 668                         le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
 669                         resp_size, le16_to_cpu(resp->size),
 670                         le32_to_cpu(resp->error),
 671                         le32_to_cpu(resp->pad));
 672                 err = -EINVAL;
 673                 goto unlock;
 674         }
 675
 676         if (resp_size > 0)
 677                 memcpy(resp_data, resp->data, resp_size);
 678
 679 unlock:
 680         mutex_unlock(&private->usb_mutex);
 681 error:
 682         kfree(req);
 683         kfree(resp);
 684         return err;
 685 }
 686
 687 /* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
 688 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
 689 {
 690         __le32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
 691
 692         scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
 693                       &req, sizeof(u32),
 694                       NULL, 0);
 695 }
 696
 697 /* Delayed work to save config */
 698 static void scarlett2_config_save_work(struct work_struct *work)
 699 {
 700         struct scarlett2_mixer_data *private =
 701                 container_of(work, struct scarlett2_mixer_data, work.work);
 702
 703         scarlett2_config_save(private->mixer);
 704 }
 705
 706 /* Send a USB message to set a configuration parameter (volume level,
 707  * sw/hw volume switch, line/inst level switch, or pad switch)
 708  */
 709 static int scarlett2_usb_set_config(
 710         struct usb_mixer_interface *mixer,
 711         int config_item_num, int index, int value)
 712 {
 713         const struct scarlett2_config config_item =
 714                scarlett2_config_items[config_item_num];
 715         struct {
 716                 __le32 offset;
 717                 __le32 bytes;
 718                 __le32 value;
 719         } __packed req;
 720         __le32 req2;
 721         int err;
 722         struct scarlett2_mixer_data *private = mixer->private_data;
 723
 724         /* Cancel any pending NVRAM save */
 725         cancel_delayed_work_sync(&private->work);
 726
 727         /* Send the configuration parameter data */
 728         req.offset = cpu_to_le32(config_item.offset + index * config_item.size);
 729         req.bytes = cpu_to_le32(config_item.size);
 730         req.value = cpu_to_le32(value);
 731         err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
 732                             &req, sizeof(u32) * 2 + config_item.size,
 733                             NULL, 0);
 734         if (err < 0)
 735                 return err;
 736
 737         /* Activate the change */
 738         req2 = cpu_to_le32(config_item.activate);
 739         err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
 740                             &req2, sizeof(req2), NULL, 0);
 741         if (err < 0)
 742                 return err;
 743
 744         /* Schedule the change to be written to NVRAM */
 745         schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
 746
 747         return 0;
 748 }
 749
 750 /* Send a USB message to get data; result placed in *buf */
 751 static int scarlett2_usb_get(
 752         struct usb_mixer_interface *mixer,
 753         int offset, void *buf, int size)
 754 {
 755         struct {
 756                 __le32 offset;
 757                 __le32 size;
 758         } __packed req;
 759
 760         req.offset = cpu_to_le32(offset);
 761         req.size = cpu_to_le32(size);
 762         return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
 763                              &req, sizeof(req), buf, size);
 764 }
 765
 766 /* Send a USB message to get configuration parameters; result placed in *buf */
 767 static int scarlett2_usb_get_config(
 768         struct usb_mixer_interface *mixer,
 769         int config_item_num, int count, void *buf)
 770 {
 771         const struct scarlett2_config config_item =
 772                scarlett2_config_items[config_item_num];
 773         int size = config_item.size * count;
 774
 775         return scarlett2_usb_get(mixer, config_item.offset, buf, size);
 776 }
 777
 778 /* Send a USB message to get volume status; result placed in *buf */
 779 static int scarlett2_usb_get_volume_status(
 780         struct usb_mixer_interface *mixer,
 781         struct scarlett2_usb_volume_status *buf)
 782 {
 783         return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
 784                                  buf, sizeof(*buf));
 785 }
 786
 787 /* Send a USB message to set the volumes for all inputs of one mix
 788  * (values obtained from private->mix[])
 789  */
 790 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
 791                                      int mix_num)
 792 {
 793         struct scarlett2_mixer_data *private = mixer->private_data;
 794         const struct scarlett2_device_info *info = private->info;
 795
 796         struct {
 797                 __le16 mix_num;
 798                 __le16 data[SCARLETT2_INPUT_MIX_MAX];
 799         } __packed req;
 800
 801         int i, j;
 802         int num_mixer_in =
 803                 info->ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
 804
 805         req.mix_num = cpu_to_le16(mix_num);
 806
 807         for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
 808                 req.data[i] = cpu_to_le16(
 809                         scarlett2_mixer_values[private->mix[j]]
 810                 );
 811
 812         return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
 813                              &req, (num_mixer_in + 1) * sizeof(u16),
 814                              NULL, 0);
 815 }
 816
 817 /* Convert a port number index (per info->ports) to a hardware ID */
 818 static u32 scarlett2_mux_src_num_to_id(const struct scarlett2_ports *ports,
 819                                        int num)
 820 {
 821         int port_type;
 822
 823         for (port_type = 0;
 824              port_type < SCARLETT2_PORT_TYPE_COUNT;
 825              port_type++) {
 826                 if (num < ports[port_type].num[SCARLETT2_PORT_IN])
 827                         return ports[port_type].id | num;
 828                 num -= ports[port_type].num[SCARLETT2_PORT_IN];
 829         }
 830
 831         /* Oops */
 832         return 0;
 833 }
 834
 835 /* Send USB messages to set mux inputs */
 836 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
 837 {
 838         struct scarlett2_mixer_data *private = mixer->private_data;
 839         const struct scarlett2_device_info *info = private->info;
 840         const struct scarlett2_ports *ports = info->ports;
 841         int rate, port_dir_rate;
 842
 843         static const int assignment_order[SCARLETT2_PORT_TYPE_COUNT] = {
 844                 SCARLETT2_PORT_TYPE_PCM,
 845                 SCARLETT2_PORT_TYPE_ANALOGUE,
 846                 SCARLETT2_PORT_TYPE_SPDIF,
 847                 SCARLETT2_PORT_TYPE_ADAT,
 848                 SCARLETT2_PORT_TYPE_MIX,
 849                 SCARLETT2_PORT_TYPE_NONE,
 850         };
 851
 852         struct {
 853                 __le16 pad;
 854                 __le16 num;
 855                 __le32 data[SCARLETT2_MUX_MAX];
 856         } __packed req;
 857
 858         req.pad = 0;
 859
 860         /* mux settings for each rate */
 861         for (rate = 0, port_dir_rate = SCARLETT2_PORT_OUT_44;
 862              port_dir_rate <= SCARLETT2_PORT_OUT_176;
 863              rate++, port_dir_rate++) {
 864                 int order_num, i, err;
 865
 866                 req.num = cpu_to_le16(rate);
 867
 868                 for (order_num = 0, i = 0;
 869                      order_num < SCARLETT2_PORT_TYPE_COUNT;
 870                      order_num++) {
 871                         int port_type = assignment_order[order_num];
 872                         int j = scarlett2_get_port_start_num(ports,
 873                                                              SCARLETT2_PORT_OUT,
 874                                                              port_type);
 875                         int port_id = ports[port_type].id;
 876                         int channel;
 877
 878                         for (channel = 0;
 879                              channel < ports[port_type].num[port_dir_rate];
 880                              channel++, i++, j++)
 881                                 /* lower 12 bits for the destination and
 882                                  * next 12 bits for the source
 883                                  */
 884                                 req.data[i] = !port_id
 885                                         ? 0
 886                                         : cpu_to_le32(
 887                                                 port_id |
 888                                                 channel |
 889                                                 scarlett2_mux_src_num_to_id(
 890                                                         ports, private->mux[j]
 891                                                 ) << 12
 892                                           );
 893
 894                         /* skip private->mux[j] entries not output */
 895                         j += ports[port_type].num[SCARLETT2_PORT_OUT] -
 896                              ports[port_type].num[port_dir_rate];
 897                 }
 898
 899                 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
 900                                     &req, (i + 1) * sizeof(u32),
 901                                     NULL, 0);
 902                 if (err < 0)
 903                         return err;
 904         }
 905
 906         return 0;
 907 }
 908
 909 /* Send USB message to get meter levels */
 910 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
 911                                           u16 *levels)
 912 {
 913         struct {
 914                 __le16 pad;
 915                 __le16 num_meters;
 916                 __le32 magic;
 917         } __packed req;
 918         u32 resp[SCARLETT2_NUM_METERS];
 919         int i, err;
 920
 921         req.pad = 0;
 922         req.num_meters = cpu_to_le16(SCARLETT2_NUM_METERS);
 923         req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
 924         err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER_LEVELS,
 925                             &req, sizeof(req), resp, sizeof(resp));
 926         if (err < 0)
 927                 return err;
 928
 929         /* copy, convert to u16 */
 930         for (i = 0; i < SCARLETT2_NUM_METERS; i++)
 931                 levels[i] = resp[i];
 932
 933         return 0;
 934 }
 935
 936 /*** Control Functions ***/
 937
 938 /* helper function to create a new control */
 939 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
 940                                  const struct snd_kcontrol_new *ncontrol,
 941                                  int index, int channels, const char *name,
 942                                  struct snd_kcontrol **kctl_return)
 943 {
 944         struct snd_kcontrol *kctl;
 945         struct usb_mixer_elem_info *elem;
 946         int err;
 947
 948         elem = kzalloc(sizeof(*elem), GFP_KERNEL);
 949         if (!elem)
 950                 return -ENOMEM;
 951
 952         /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
 953          * ignores them for resume and other operations.
 954          * Also, the head.id field is set to 0, as we don't use this field.
 955          */
 956         elem->head.mixer = mixer;
 957         elem->control = index;
 958         elem->head.id = 0;
 959         elem->channels = channels;
 960         elem->val_type = USB_MIXER_BESPOKEN;
 961
 962         kctl = snd_ctl_new1(ncontrol, elem);
 963         if (!kctl) {
 964                 kfree(elem);
 965                 return -ENOMEM;
 966         }
 967         kctl->private_free = snd_usb_mixer_elem_free;
 968
 969         strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
 970
 971         err = snd_usb_mixer_add_control(&elem->head, kctl);
 972         if (err < 0)
 973                 return err;
 974
 975         if (kctl_return)
 976                 *kctl_return = kctl;
 977
 978         return 0;
 979 }
 980
 981 /*** Analogue Line Out Volume Controls ***/
 982
 983 /* Update hardware volume controls after receiving notification that
 984  * they have changed
 985  */
 986 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
 987 {
 988         struct scarlett2_mixer_data *private = mixer->private_data;
 989         const struct scarlett2_ports *ports = private->info->ports;
 990         struct scarlett2_usb_volume_status volume_status;
 991         int num_line_out =
 992                 ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
 993         int err, i;
 994
 995         private->vol_updated = 0;
 996
 997         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
 998         if (err < 0)
 999                 return err;
1000
1001         private->master_vol = clamp(
1002                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1003                 0, SCARLETT2_VOLUME_BIAS);
1004
1005         for (i = 0; i < num_line_out; i++) {
1006                 if (private->vol_sw_hw_switch[i])
1007                         private->vol[i] = private->master_vol;
1008         }
1009
1010         for (i = 0; i < private->info->button_count; i++)
1011                 private->buttons[i] = !!volume_status.buttons[i];
1012
1013         return 0;
1014 }
1015
1016 static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
1017                                      struct snd_ctl_elem_info *uinfo)
1018 {
1019         struct usb_mixer_elem_info *elem = kctl->private_data;
1020
1021         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1022         uinfo->count = elem->channels;
1023         uinfo->value.integer.min = 0;
1024         uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
1025         uinfo->value.integer.step = 1;
1026         return 0;
1027 }
1028
1029 static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
1030                                            struct snd_ctl_elem_value *ucontrol)
1031 {
1032         struct usb_mixer_elem_info *elem = kctl->private_data;
1033         struct usb_mixer_interface *mixer = elem->head.mixer;
1034         struct scarlett2_mixer_data *private = mixer->private_data;
1035
1036         mutex_lock(&private->data_mutex);
1037         if (private->vol_updated)
1038                 scarlett2_update_volumes(mixer);
1039         mutex_unlock(&private->data_mutex);
1040
1041         ucontrol->value.integer.value[0] = private->master_vol;
1042         return 0;
1043 }
1044
1045 static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
1046                                     struct snd_ctl_elem_value *ucontrol)
1047 {
1048         struct usb_mixer_elem_info *elem = kctl->private_data;
1049         struct usb_mixer_interface *mixer = elem->head.mixer;
1050         struct scarlett2_mixer_data *private = mixer->private_data;
1051         int index = elem->control;
1052
1053         mutex_lock(&private->data_mutex);
1054         if (private->vol_updated)
1055                 scarlett2_update_volumes(mixer);
1056         mutex_unlock(&private->data_mutex);
1057
1058         ucontrol->value.integer.value[0] = private->vol[index];
1059         return 0;
1060 }
1061
1062 static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
1063                                     struct snd_ctl_elem_value *ucontrol)
1064 {
1065         struct usb_mixer_elem_info *elem = kctl->private_data;
1066         struct usb_mixer_interface *mixer = elem->head.mixer;
1067         struct scarlett2_mixer_data *private = mixer->private_data;
1068         int index = elem->control;
1069         int oval, val, err = 0;
1070
1071         mutex_lock(&private->data_mutex);
1072
1073         oval = private->vol[index];
1074         val = ucontrol->value.integer.value[0];
1075
1076         if (oval == val)
1077                 goto unlock;
1078
1079         private->vol[index] = val;
1080         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1081                                        index, val - SCARLETT2_VOLUME_BIAS);
1082         if (err == 0)
1083                 err = 1;
1084
1085 unlock:
1086         mutex_unlock(&private->data_mutex);
1087         return err;
1088 }
1089
1090 static const DECLARE_TLV_DB_MINMAX(
1091         db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
1092 );
1093
1094 static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
1095         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1096         .access = SNDRV_CTL_ELEM_ACCESS_READ |
1097                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1098         .name = "",
1099         .info = scarlett2_volume_ctl_info,
1100         .get  = scarlett2_master_volume_ctl_get,
1101         .private_value = 0, /* max value */
1102         .tlv = { .p = db_scale_scarlett2_gain }
1103 };
1104
1105 static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
1106         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1107         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1108                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1109         .name = "",
1110         .info = scarlett2_volume_ctl_info,
1111         .get  = scarlett2_volume_ctl_get,
1112         .put  = scarlett2_volume_ctl_put,
1113         .private_value = 0, /* max value */
1114         .tlv = { .p = db_scale_scarlett2_gain }
1115 };
1116
1117 /*** HW/SW Volume Switch Controls ***/
1118
1119 static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
1120                                          struct snd_ctl_elem_info *uinfo)
1121 {
1122         static const char *const values[2] = {
1123                 "SW", "HW"
1124         };
1125
1126         return snd_ctl_enum_info(uinfo, 1, 2, values);
1127 }
1128
1129 static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
1130                                         struct snd_ctl_elem_value *ucontrol)
1131 {
1132         struct usb_mixer_elem_info *elem = kctl->private_data;
1133         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1134
1135         ucontrol->value.enumerated.item[0] =
1136                 private->vol_sw_hw_switch[elem->control];
1137         return 0;
1138 }
1139
1140 static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
1141                                         struct snd_ctl_elem_value *ucontrol)
1142 {
1143         struct usb_mixer_elem_info *elem = kctl->private_data;
1144         struct usb_mixer_interface *mixer = elem->head.mixer;
1145         struct scarlett2_mixer_data *private = mixer->private_data;
1146
1147         int index = elem->control;
1148         int oval, val, err = 0;
1149
1150         mutex_lock(&private->data_mutex);
1151
1152         oval = private->vol_sw_hw_switch[index];
1153         val = !!ucontrol->value.integer.value[0];
1154
1155         if (oval == val)
1156                 goto unlock;
1157
1158         private->vol_sw_hw_switch[index] = val;
1159
1160         /* Change access mode to RO (hardware controlled volume)
1161          * or RW (software controlled volume)
1162          */
1163         if (val)
1164                 private->vol_ctls[index]->vd[0].access &=
1165                         ~SNDRV_CTL_ELEM_ACCESS_WRITE;
1166         else
1167                 private->vol_ctls[index]->vd[0].access |=
1168                         SNDRV_CTL_ELEM_ACCESS_WRITE;
1169
1170         /* Reset volume to master volume */
1171         private->vol[index] = private->master_vol;
1172
1173         /* Set SW volume to current HW volume */
1174         err = scarlett2_usb_set_config(
1175                 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
1176                 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
1177         if (err < 0)
1178                 goto unlock;
1179
1180         /* Notify of RO/RW change */
1181         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_INFO,
1182                        &private->vol_ctls[index]->id);
1183
1184         /* Send SW/HW switch change to the device */
1185         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
1186                                        index, val);
1187         if (err == 0)
1188                 err = 1;
1189
1190 unlock:
1191         mutex_unlock(&private->data_mutex);
1192         return err;
1193 }
1194
1195 static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
1196         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1197         .name = "",
1198         .info = scarlett2_sw_hw_enum_ctl_info,
1199         .get  = scarlett2_sw_hw_enum_ctl_get,
1200         .put  = scarlett2_sw_hw_enum_ctl_put,
1201 };
1202
1203 /*** Line Level/Instrument Level Switch Controls ***/
1204
1205 static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
1206                                          struct snd_ctl_elem_info *uinfo)
1207 {
1208         static const char *const values[2] = {
1209                 "Line", "Inst"
1210         };
1211
1212         return snd_ctl_enum_info(uinfo, 1, 2, values);
1213 }
1214
1215 static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
1216                                         struct snd_ctl_elem_value *ucontrol)
1217 {
1218         struct usb_mixer_elem_info *elem = kctl->private_data;
1219         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1220
1221         ucontrol->value.enumerated.item[0] =
1222                 private->level_switch[elem->control];
1223         return 0;
1224 }
1225
1226 static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
1227                                         struct snd_ctl_elem_value *ucontrol)
1228 {
1229         struct usb_mixer_elem_info *elem = kctl->private_data;
1230         struct usb_mixer_interface *mixer = elem->head.mixer;
1231         struct scarlett2_mixer_data *private = mixer->private_data;
1232
1233         int index = elem->control;
1234         int oval, val, err = 0;
1235
1236         mutex_lock(&private->data_mutex);
1237
1238         oval = private->level_switch[index];
1239         val = !!ucontrol->value.integer.value[0];
1240
1241         if (oval == val)
1242                 goto unlock;
1243
1244         private->level_switch[index] = val;
1245
1246         /* Send switch change to the device */
1247         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
1248                                        index, val);
1249         if (err == 0)
1250                 err = 1;
1251
1252 unlock:
1253         mutex_unlock(&private->data_mutex);
1254         return err;
1255 }
1256
1257 static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
1258         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1259         .name = "",
1260         .info = scarlett2_level_enum_ctl_info,
1261         .get  = scarlett2_level_enum_ctl_get,
1262         .put  = scarlett2_level_enum_ctl_put,
1263 };
1264
1265 /*** Pad Switch Controls ***/
1266
1267 static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
1268                                  struct snd_ctl_elem_value *ucontrol)
1269 {
1270         struct usb_mixer_elem_info *elem = kctl->private_data;
1271         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1272
1273         ucontrol->value.enumerated.item[0] =
1274                 private->pad_switch[elem->control];
1275         return 0;
1276 }
1277
1278 static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
1279                                  struct snd_ctl_elem_value *ucontrol)
1280 {
1281         struct usb_mixer_elem_info *elem = kctl->private_data;
1282         struct usb_mixer_interface *mixer = elem->head.mixer;
1283         struct scarlett2_mixer_data *private = mixer->private_data;
1284
1285         int index = elem->control;
1286         int oval, val, err = 0;
1287
1288         mutex_lock(&private->data_mutex);
1289
1290         oval = private->pad_switch[index];
1291         val = !!ucontrol->value.integer.value[0];
1292
1293         if (oval == val)
1294                 goto unlock;
1295
1296         private->pad_switch[index] = val;
1297
1298         /* Send switch change to the device */
1299         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
1300                                        index, val);
1301         if (err == 0)
1302                 err = 1;
1303
1304 unlock:
1305         mutex_unlock(&private->data_mutex);
1306         return err;
1307 }
1308
1309 static const struct snd_kcontrol_new scarlett2_pad_ctl = {
1310         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1311         .name = "",
1312         .info = snd_ctl_boolean_mono_info,
1313         .get  = scarlett2_pad_ctl_get,
1314         .put  = scarlett2_pad_ctl_put,
1315 };
1316
1317 /*** Mute/Dim Controls ***/
1318
1319 static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl,
1320                                     struct snd_ctl_elem_value *ucontrol)
1321 {
1322         struct usb_mixer_elem_info *elem = kctl->private_data;
1323         struct usb_mixer_interface *mixer = elem->head.mixer;
1324         struct scarlett2_mixer_data *private = mixer->private_data;
1325
1326         mutex_lock(&private->data_mutex);
1327         if (private->vol_updated)
1328                 scarlett2_update_volumes(mixer);
1329         mutex_unlock(&private->data_mutex);
1330
1331         ucontrol->value.enumerated.item[0] = private->buttons[elem->control];
1332         return 0;
1333 }
1334
1335 static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl,
1336                                     struct snd_ctl_elem_value *ucontrol)
1337 {
1338         struct usb_mixer_elem_info *elem = kctl->private_data;
1339         struct usb_mixer_interface *mixer = elem->head.mixer;
1340         struct scarlett2_mixer_data *private = mixer->private_data;
1341
1342         int index = elem->control;
1343         int oval, val, err = 0;
1344
1345         mutex_lock(&private->data_mutex);
1346
1347         oval = private->buttons[index];
1348         val = !!ucontrol->value.integer.value[0];
1349
1350         if (oval == val)
1351                 goto unlock;
1352
1353         private->buttons[index] = val;
1354
1355         /* Send switch change to the device */
1356         err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS,
1357                                        index, val);
1358         if (err == 0)
1359                 err = 1;
1360
1361 unlock:
1362         mutex_unlock(&private->data_mutex);
1363         return err;
1364 }
1365
1366 static const struct snd_kcontrol_new scarlett2_button_ctl = {
1367         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1368         .name = "",
1369         .info = snd_ctl_boolean_mono_info,
1370         .get  = scarlett2_button_ctl_get,
1371         .put  = scarlett2_button_ctl_put
1372 };
1373
1374 /*** Create the analogue output controls ***/
1375
1376 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
1377 {
1378         struct scarlett2_mixer_data *private = mixer->private_data;
1379         const struct scarlett2_device_info *info = private->info;
1380         const struct scarlett2_ports *ports = info->ports;
1381         int num_line_out =
1382                 ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1383         int err, i;
1384         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1385
1386         /* Add R/O HW volume control */
1387         if (info->line_out_hw_vol) {
1388                 snprintf(s, sizeof(s), "Master HW Playback Volume");
1389                 err = scarlett2_add_new_ctl(mixer,
1390                                             &scarlett2_master_volume_ctl,
1391                                             0, 1, s, &private->master_vol_ctl);
1392                 if (err < 0)
1393                         return err;
1394         }
1395
1396         /* Add volume controls */
1397         for (i = 0; i < num_line_out; i++) {
1398
1399                 /* Fader */
1400                 if (info->line_out_descrs[i])
1401                         snprintf(s, sizeof(s),
1402                                  "Line %02d (%s) Playback Volume",
1403                                  i + 1, info->line_out_descrs[i]);
1404                 else
1405                         snprintf(s, sizeof(s),
1406                                  "Line %02d Playback Volume",
1407                                  i + 1);
1408                 err = scarlett2_add_new_ctl(mixer,
1409                                             &scarlett2_line_out_volume_ctl,
1410                                             i, 1, s, &private->vol_ctls[i]);
1411                 if (err < 0)
1412                         return err;
1413
1414                 /* Make the fader read-only if the SW/HW switch is set to HW */
1415                 if (private->vol_sw_hw_switch[i])
1416                         private->vol_ctls[i]->vd[0].access &=
1417                                 ~SNDRV_CTL_ELEM_ACCESS_WRITE;
1418
1419                 /* SW/HW Switch */
1420                 if (info->line_out_hw_vol) {
1421                         snprintf(s, sizeof(s),
1422                                  "Line Out %02d Volume Control Playback Enum",
1423                                  i + 1);
1424                         err = scarlett2_add_new_ctl(mixer,
1425                                                     &scarlett2_sw_hw_enum_ctl,
1426                                                     i, 1, s, NULL);
1427                         if (err < 0)
1428                                 return err;
1429                 }
1430         }
1431
1432         /* Add HW button controls */
1433         for (i = 0; i < private->info->button_count; i++) {
1434                 err = scarlett2_add_new_ctl(mixer, &scarlett2_button_ctl,
1435                                             i, 1, scarlett2_button_names[i],
1436                                             &private->button_ctls[i]);
1437                 if (err < 0)
1438                         return err;
1439         }
1440
1441         return 0;
1442 }
1443
1444 /*** Create the analogue input controls ***/
1445
1446 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
1447 {
1448         struct scarlett2_mixer_data *private = mixer->private_data;
1449         const struct scarlett2_device_info *info = private->info;
1450         int err, i;
1451         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1452
1453         /* Add input level (line/inst) controls */
1454         for (i = 0; i < info->level_input_count; i++) {
1455                 snprintf(s, sizeof(s), "Line In %d Level Capture Enum", i + 1);
1456                 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
1457                                             i, 1, s, NULL);
1458                 if (err < 0)
1459                         return err;
1460         }
1461
1462         /* Add input pad controls */
1463         for (i = 0; i < info->pad_input_count; i++) {
1464                 snprintf(s, sizeof(s), "Line In %d Pad Capture Switch", i + 1);
1465                 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
1466                                             i, 1, s, NULL);
1467                 if (err < 0)
1468                         return err;
1469         }
1470
1471         return 0;
1472 }
1473
1474 /*** Mixer Volume Controls ***/
1475
1476 static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
1477                                     struct snd_ctl_elem_info *uinfo)
1478 {
1479         struct usb_mixer_elem_info *elem = kctl->private_data;
1480
1481         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1482         uinfo->count = elem->channels;
1483         uinfo->value.integer.min = 0;
1484         uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
1485         uinfo->value.integer.step = 1;
1486         return 0;
1487 }
1488
1489 static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
1490                                    struct snd_ctl_elem_value *ucontrol)
1491 {
1492         struct usb_mixer_elem_info *elem = kctl->private_data;
1493         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1494
1495         ucontrol->value.integer.value[0] = private->mix[elem->control];
1496         return 0;
1497 }
1498
1499 static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
1500                                    struct snd_ctl_elem_value *ucontrol)
1501 {
1502         struct usb_mixer_elem_info *elem = kctl->private_data;
1503         struct usb_mixer_interface *mixer = elem->head.mixer;
1504         struct scarlett2_mixer_data *private = mixer->private_data;
1505         const struct scarlett2_device_info *info = private->info;
1506         const struct scarlett2_ports *ports = info->ports;
1507         int oval, val, num_mixer_in, mix_num, err = 0;
1508
1509         mutex_lock(&private->data_mutex);
1510
1511         oval = private->mix[elem->control];
1512         val = ucontrol->value.integer.value[0];
1513         num_mixer_in = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
1514         mix_num = elem->control / num_mixer_in;
1515
1516         if (oval == val)
1517                 goto unlock;
1518
1519         private->mix[elem->control] = val;
1520         err = scarlett2_usb_set_mix(mixer, mix_num);
1521         if (err == 0)
1522                 err = 1;
1523
1524 unlock:
1525         mutex_unlock(&private->data_mutex);
1526         return err;
1527 }
1528
1529 static const DECLARE_TLV_DB_MINMAX(
1530         db_scale_scarlett2_mixer,
1531         SCARLETT2_MIXER_MIN_DB * 100,
1532         SCARLETT2_MIXER_MAX_DB * 100
1533 );
1534
1535 static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
1536         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1537         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1538                   SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1539         .name = "",
1540         .info = scarlett2_mixer_ctl_info,
1541         .get  = scarlett2_mixer_ctl_get,
1542         .put  = scarlett2_mixer_ctl_put,
1543         .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
1544         .tlv = { .p = db_scale_scarlett2_mixer }
1545 };
1546
1547 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
1548 {
1549         struct scarlett2_mixer_data *private = mixer->private_data;
1550         const struct scarlett2_ports *ports = private->info->ports;
1551         int err, i, j;
1552         int index;
1553         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1554
1555         int num_inputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
1556         int num_outputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_IN];
1557
1558         for (i = 0, index = 0; i < num_outputs; i++) {
1559                 for (j = 0; j < num_inputs; j++, index++) {
1560                         snprintf(s, sizeof(s),
1561                                  "Mix %c Input %02d Playback Volume",
1562                                  'A' + i, j + 1);
1563                         err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
1564                                                     index, 1, s, NULL);
1565                         if (err < 0)
1566                                 return err;
1567                 }
1568         }
1569
1570         return 0;
1571 }
1572
1573 /*** Mux Source Selection Controls ***/
1574
1575 static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
1576                                            struct snd_ctl_elem_info *uinfo)
1577 {
1578         struct usb_mixer_elem_info *elem = kctl->private_data;
1579         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1580         const struct scarlett2_ports *ports = private->info->ports;
1581         unsigned int item = uinfo->value.enumerated.item;
1582         int items = private->num_mux_srcs;
1583         int port_type;
1584
1585         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1586         uinfo->count = elem->channels;
1587         uinfo->value.enumerated.items = items;
1588
1589         if (item >= items)
1590                 item = uinfo->value.enumerated.item = items - 1;
1591
1592         for (port_type = 0;
1593              port_type < SCARLETT2_PORT_TYPE_COUNT;
1594              port_type++) {
1595                 if (item < ports[port_type].num[SCARLETT2_PORT_IN]) {
1596                         sprintf(uinfo->value.enumerated.name,
1597                                 ports[port_type].src_descr,
1598                                 item + ports[port_type].src_num_offset);
1599                         return 0;
1600                 }
1601                 item -= ports[port_type].num[SCARLETT2_PORT_IN];
1602         }
1603
1604         return -EINVAL;
1605 }
1606
1607 static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
1608                                           struct snd_ctl_elem_value *ucontrol)
1609 {
1610         struct usb_mixer_elem_info *elem = kctl->private_data;
1611         struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
1612
1613         ucontrol->value.enumerated.item[0] = private->mux[elem->control];
1614         return 0;
1615 }
1616
1617 static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
1618                                           struct snd_ctl_elem_value *ucontrol)
1619 {
1620         struct usb_mixer_elem_info *elem = kctl->private_data;
1621         struct usb_mixer_interface *mixer = elem->head.mixer;
1622         struct scarlett2_mixer_data *private = mixer->private_data;
1623         int index = elem->control;
1624         int oval, val, err = 0;
1625
1626         mutex_lock(&private->data_mutex);
1627
1628         oval = private->mux[index];
1629         val = clamp(ucontrol->value.integer.value[0],
1630                     0L, private->num_mux_srcs - 1L);
1631
1632         if (oval == val)
1633                 goto unlock;
1634
1635         private->mux[index] = val;
1636         err = scarlett2_usb_set_mux(mixer);
1637         if (err == 0)
1638                 err = 1;
1639
1640 unlock:
1641         mutex_unlock(&private->data_mutex);
1642         return err;
1643 }
1644
1645 static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
1646         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1647         .name = "",
1648         .info = scarlett2_mux_src_enum_ctl_info,
1649         .get  = scarlett2_mux_src_enum_ctl_get,
1650         .put  = scarlett2_mux_src_enum_ctl_put,
1651 };
1652
1653 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
1654 {
1655         struct scarlett2_mixer_data *private = mixer->private_data;
1656         const struct scarlett2_ports *ports = private->info->ports;
1657         int port_type, channel, i;
1658
1659         for (i = 0, port_type = 0;
1660              port_type < SCARLETT2_PORT_TYPE_COUNT;
1661              port_type++) {
1662                 for (channel = 0;
1663                      channel < ports[port_type].num[SCARLETT2_PORT_OUT];
1664                      channel++, i++) {
1665                         int err;
1666                         char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
1667                         const char *const descr = ports[port_type].dst_descr;
1668
1669                         snprintf(s, sizeof(s) - 5, descr, channel + 1);
1670                         strcat(s, " Enum");
1671
1672                         err = scarlett2_add_new_ctl(mixer,
1673                                                     &scarlett2_mux_src_enum_ctl,
1674                                                     i, 1, s, NULL);
1675                         if (err < 0)
1676                                 return err;
1677                 }
1678         }
1679
1680         return 0;
1681 }
1682
1683 /*** Meter Controls ***/
1684
1685 static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
1686                                     struct snd_ctl_elem_info *uinfo)
1687 {
1688         struct usb_mixer_elem_info *elem = kctl->private_data;
1689
1690         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1691         uinfo->count = elem->channels;
1692         uinfo->value.integer.min = 0;
1693         uinfo->value.integer.max = 4095;
1694         uinfo->value.integer.step = 1;
1695         return 0;
1696 }
1697
1698 static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
1699                                    struct snd_ctl_elem_value *ucontrol)
1700 {
1701         struct usb_mixer_elem_info *elem = kctl->private_data;
1702         u16 meter_levels[SCARLETT2_NUM_METERS];
1703         int i, err;
1704
1705         err = scarlett2_usb_get_meter_levels(elem->head.mixer, meter_levels);
1706         if (err < 0)
1707                 return err;
1708
1709         for (i = 0; i < elem->channels; i++)
1710                 ucontrol->value.integer.value[i] = meter_levels[i];
1711
1712         return 0;
1713 }
1714
1715 static const struct snd_kcontrol_new scarlett2_meter_ctl = {
1716         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
1717         .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
1718         .name = "",
1719         .info = scarlett2_meter_ctl_info,
1720         .get  = scarlett2_meter_ctl_get
1721 };
1722
1723 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
1724 {
1725         return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
1726                                      0, SCARLETT2_NUM_METERS,
1727                                      "Level Meter", NULL);
1728 }
1729
1730 /*** Cleanup/Suspend Callbacks ***/
1731
1732 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
1733 {
1734         struct scarlett2_mixer_data *private = mixer->private_data;
1735
1736         cancel_delayed_work_sync(&private->work);
1737         kfree(private);
1738         mixer->private_data = NULL;
1739 }
1740
1741 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
1742 {
1743         struct scarlett2_mixer_data *private = mixer->private_data;
1744
1745         if (cancel_delayed_work_sync(&private->work))
1746                 scarlett2_config_save(private->mixer);
1747 }
1748
1749 /*** Initialisation ***/
1750
1751 static int scarlett2_count_mux_srcs(const struct scarlett2_ports *ports)
1752 {
1753         int port_type, count = 0;
1754
1755         for (port_type = 0;
1756              port_type < SCARLETT2_PORT_TYPE_COUNT;
1757              port_type++)
1758                 count += ports[port_type].num[SCARLETT2_PORT_IN];
1759
1760         return count;
1761 }
1762
1763 /* Default routing connects PCM outputs and inputs to Analogue,
1764  * S/PDIF, then ADAT
1765  */
1766 static void scarlett2_init_routing(u8 *mux,
1767                                    const struct scarlett2_ports *ports)
1768 {
1769         int i, input_num, input_count, port_type;
1770         int output_num, output_count, port_type_connect_num;
1771
1772         static const int connect_order[] = {
1773                 SCARLETT2_PORT_TYPE_ANALOGUE,
1774                 SCARLETT2_PORT_TYPE_SPDIF,
1775                 SCARLETT2_PORT_TYPE_ADAT,
1776                 -1
1777         };
1778
1779         /* Assign PCM inputs (routing outputs) */
1780         output_num = scarlett2_get_port_start_num(ports,
1781                                                   SCARLETT2_PORT_OUT,
1782                                                   SCARLETT2_PORT_TYPE_PCM);
1783         output_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_OUT];
1784
1785         for (port_type = connect_order[port_type_connect_num = 0];
1786              port_type >= 0;
1787              port_type = connect_order[++port_type_connect_num]) {
1788                 input_num = scarlett2_get_port_start_num(
1789                         ports, SCARLETT2_PORT_IN, port_type);
1790                 input_count = ports[port_type].num[SCARLETT2_PORT_IN];
1791                 for (i = 0;
1792                      i < input_count && output_count;
1793                      i++, output_count--)
1794                         mux[output_num++] = input_num++;
1795         }
1796
1797         /* Assign PCM outputs (routing inputs) */
1798         input_num = scarlett2_get_port_start_num(ports,
1799                                                  SCARLETT2_PORT_IN,
1800                                                  SCARLETT2_PORT_TYPE_PCM);
1801         input_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_IN];
1802
1803         for (port_type = connect_order[port_type_connect_num = 0];
1804              port_type >= 0;
1805              port_type = connect_order[++port_type_connect_num]) {
1806                 output_num = scarlett2_get_port_start_num(
1807                         ports, SCARLETT2_PORT_OUT, port_type);
1808                 output_count = ports[port_type].num[SCARLETT2_PORT_OUT];
1809                 for (i = 0;
1810                      i < output_count && input_count;
1811                      i++, input_count--)
1812                         mux[output_num++] = input_num++;
1813         }
1814 }
1815
1816 /* Initialise private data, routing, sequence number */
1817 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
1818                                   const struct scarlett2_device_info *info)
1819 {
1820         struct scarlett2_mixer_data *private =
1821                 kzalloc(sizeof(struct scarlett2_mixer_data), GFP_KERNEL);
1822
1823         if (!private)
1824                 return -ENOMEM;
1825
1826         mutex_init(&private->usb_mutex);
1827         mutex_init(&private->data_mutex);
1828         INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
1829         private->info = info;
1830         private->num_mux_srcs = scarlett2_count_mux_srcs(info->ports);
1831         private->scarlett2_seq = 0;
1832         private->mixer = mixer;
1833         mixer->private_data = private;
1834         mixer->private_free = scarlett2_private_free;
1835         mixer->private_suspend = scarlett2_private_suspend;
1836
1837         /* Setup default routing */
1838         scarlett2_init_routing(private->mux, info->ports);
1839
1840         /* Initialise the sequence number used for the proprietary commands */
1841         return scarlett2_usb(mixer, SCARLETT2_USB_INIT_SEQ, NULL, 0, NULL, 0);
1842 }
1843
1844 /* Read line-in config and line-out volume settings on start */
1845 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
1846 {
1847         struct scarlett2_mixer_data *private = mixer->private_data;
1848         const struct scarlett2_device_info *info = private->info;
1849         const struct scarlett2_ports *ports = info->ports;
1850         int num_line_out =
1851                 ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1852         u8 level_switches[SCARLETT2_LEVEL_SWITCH_MAX];
1853         u8 pad_switches[SCARLETT2_PAD_SWITCH_MAX];
1854         struct scarlett2_usb_volume_status volume_status;
1855         int err, i;
1856
1857         if (info->level_input_count) {
1858                 err = scarlett2_usb_get_config(
1859                         mixer,
1860                         SCARLETT2_CONFIG_LEVEL_SWITCH,
1861                         info->level_input_count,
1862                         level_switches);
1863                 if (err < 0)
1864                         return err;
1865                 for (i = 0; i < info->level_input_count; i++)
1866                         private->level_switch[i] = level_switches[i];
1867         }
1868
1869         if (info->pad_input_count) {
1870                 err = scarlett2_usb_get_config(
1871                         mixer,
1872                         SCARLETT2_CONFIG_PAD_SWITCH,
1873                         info->pad_input_count,
1874                         pad_switches);
1875                 if (err < 0)
1876                         return err;
1877                 for (i = 0; i < info->pad_input_count; i++)
1878                         private->pad_switch[i] = pad_switches[i];
1879         }
1880
1881         err = scarlett2_usb_get_volume_status(mixer, &volume_status);
1882         if (err < 0)
1883                 return err;
1884
1885         private->master_vol = clamp(
1886                 volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
1887                 0, SCARLETT2_VOLUME_BIAS);
1888
1889         for (i = 0; i < num_line_out; i++) {
1890                 int volume;
1891
1892                 private->vol_sw_hw_switch[i] =
1893                         info->line_out_hw_vol
1894                                 && volume_status.sw_hw_switch[i];
1895
1896                 volume = private->vol_sw_hw_switch[i]
1897                            ? volume_status.master_vol
1898                            : volume_status.sw_vol[i];
1899                 volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
1900                                0, SCARLETT2_VOLUME_BIAS);
1901                 private->vol[i] = volume;
1902         }
1903
1904         for (i = 0; i < info->button_count; i++)
1905                 private->buttons[i] = !!volume_status.buttons[i];
1906
1907         return 0;
1908 }
1909
1910 /* Notify on volume change */
1911 static void scarlett2_mixer_interrupt_vol_change(
1912         struct usb_mixer_interface *mixer)
1913 {
1914         struct scarlett2_mixer_data *private = mixer->private_data;
1915         const struct scarlett2_ports *ports = private->info->ports;
1916         int num_line_out =
1917                 ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
1918         int i;
1919
1920         private->vol_updated = 1;
1921
1922         snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1923                        &private->master_vol_ctl->id);
1924
1925         for (i = 0; i < num_line_out; i++) {
1926                 if (!private->vol_sw_hw_switch[i])
1927                         continue;
1928                 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1929                                &private->vol_ctls[i]->id);
1930         }
1931 }
1932
1933 /* Notify on button change */
1934 static void scarlett2_mixer_interrupt_button_change(
1935         struct usb_mixer_interface *mixer)
1936 {
1937         struct scarlett2_mixer_data *private = mixer->private_data;
1938         int i;
1939
1940         private->vol_updated = 1;
1941
1942         for (i = 0; i < private->info->button_count; i++)
1943                 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
1944                                &private->button_ctls[i]->id);
1945 }
1946
1947 /* Interrupt callback */
1948 static void scarlett2_mixer_interrupt(struct urb *urb)
1949 {
1950         struct usb_mixer_interface *mixer = urb->context;
1951         int len = urb->actual_length;
1952         int ustatus = urb->status;
1953         u32 data;
1954
1955         if (ustatus != 0)
1956                 goto requeue;
1957
1958         if (len == 8) {
1959                 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
1960                 if (data & SCARLETT2_USB_INTERRUPT_VOL_CHANGE)
1961                         scarlett2_mixer_interrupt_vol_change(mixer);
1962                 if (data & SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE)
1963                         scarlett2_mixer_interrupt_button_change(mixer);
1964         } else {
1965                 usb_audio_err(mixer->chip,
1966                               "scarlett mixer interrupt length %d\n", len);
1967         }
1968
1969 requeue:
1970         if (ustatus != -ENOENT &&
1971             ustatus != -ECONNRESET &&
1972             ustatus != -ESHUTDOWN) {
1973                 urb->dev = mixer->chip->dev;
1974                 usb_submit_urb(urb, GFP_ATOMIC);
1975         }
1976 }
1977
1978 static int scarlett2_mixer_status_create(struct usb_mixer_interface *mixer)
1979 {
1980         struct usb_device *dev = mixer->chip->dev;
1981         unsigned int pipe = usb_rcvintpipe(dev,
1982                                            SCARLETT2_USB_INTERRUPT_ENDPOINT);
1983         void *transfer_buffer;
1984
1985         if (mixer->urb) {
1986                 usb_audio_err(mixer->chip,
1987                               "%s: mixer urb already in use!\n", __func__);
1988                 return 0;
1989         }
1990
1991         if (usb_pipe_type_check(dev, pipe))
1992                 return -EINVAL;
1993
1994         mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
1995         if (!mixer->urb)
1996                 return -ENOMEM;
1997
1998         transfer_buffer = kmalloc(SCARLETT2_USB_INTERRUPT_MAX_DATA, GFP_KERNEL);
1999         if (!transfer_buffer)
2000                 return -ENOMEM;
2001
2002         usb_fill_int_urb(mixer->urb, dev, pipe,
2003                          transfer_buffer, SCARLETT2_USB_INTERRUPT_MAX_DATA,
2004                          scarlett2_mixer_interrupt, mixer,
2005                          SCARLETT2_USB_INTERRUPT_INTERVAL);
2006
2007         return usb_submit_urb(mixer->urb, GFP_KERNEL);
2008 }
2009
2010 static int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer,
2011                                              const struct scarlett2_device_info *info)
2012 {
2013         int err;
2014
2015         /* Initialise private data, routing, sequence number */
2016         err = scarlett2_init_private(mixer, info);
2017         if (err < 0)
2018                 return err;
2019
2020         /* Read volume levels and controls from the interface */
2021         err = scarlett2_read_configs(mixer);
2022         if (err < 0)
2023                 return err;
2024
2025         /* Create the analogue output controls */
2026         err = scarlett2_add_line_out_ctls(mixer);
2027         if (err < 0)
2028                 return err;
2029
2030         /* Create the analogue input controls */
2031         err = scarlett2_add_line_in_ctls(mixer);
2032         if (err < 0)
2033                 return err;
2034
2035         /* Create the input, output, and mixer mux input selections */
2036         err = scarlett2_add_mux_enums(mixer);
2037         if (err < 0)
2038                 return err;
2039
2040         /* Create the matrix mixer controls */
2041         err = scarlett2_add_mixer_ctls(mixer);
2042         if (err < 0)
2043                 return err;
2044
2045         /* Create the level meter controls */
2046         err = scarlett2_add_meter_ctl(mixer);
2047         if (err < 0)
2048                 return err;
2049
2050         /* Set up the interrupt polling if there are hardware buttons */
2051         if (info->button_count) {
2052                 err = scarlett2_mixer_status_create(mixer);
2053                 if (err < 0)
2054                         return err;
2055         }
2056
2057         return 0;
2058 }
2059
2060 int snd_scarlett_gen2_init(struct usb_mixer_interface *mixer)
2061 {
2062         struct snd_usb_audio *chip = mixer->chip;
2063         const struct scarlett2_device_info *info;
2064         int err;
2065
2066         /* only use UAC_VERSION_2 */
2067         if (!mixer->protocol)
2068                 return 0;
2069
2070         switch (chip->usb_id) {
2071         case USB_ID(0x1235, 0x8203):
2072                 info = &s6i6_gen2_info;
2073                 break;
2074         case USB_ID(0x1235, 0x8204):
2075                 info = &s18i8_gen2_info;
2076                 break;
2077         case USB_ID(0x1235, 0x8201):
2078                 info = &s18i20_gen2_info;
2079                 break;
2080         default: /* device not (yet) supported */
2081                 return -EINVAL;
2082         }
2083
2084         if (!(chip->setup & SCARLETT2_ENABLE)) {
2085                 usb_audio_info(chip,
2086                         "Focusrite Scarlett Gen 2 Mixer Driver disabled; "
2087                         "use options snd_usb_audio vid=0x%04x pid=0x%04x "
2088                         "device_setup=1 to enable and report any issues "
2089                         "to g@b4.vu",
2090                         USB_ID_VENDOR(chip->usb_id),
2091                         USB_ID_PRODUCT(chip->usb_id));
2092                 return 0;
2093         }
2094
2095         usb_audio_info(chip,
2096                 "Focusrite Scarlett Gen 2 Mixer Driver enabled pid=0x%04x",
2097                 USB_ID_PRODUCT(chip->usb_id));
2098
2099         err = snd_scarlett_gen2_controls_create(mixer, info);
2100         if (err < 0)
2101                 usb_audio_err(mixer->chip,
2102                               "Error initialising Scarlett Mixer Driver: %d",
2103                               err);
2104
2105         return err;
2106 }