ALSA: usb-audio: Scarlett Gen 2 mixer interface
authorGeoffrey D. Bennett <g@b4.vu>
Sun, 28 Jul 2019 15:12:45 +0000 (00:42 +0930)
committerTakashi Iwai <tiwai@suse.de>
Sun, 28 Jul 2019 15:47:48 +0000 (17:47 +0200)
Add mixer quirk for the Focusrite Scarlett 6i6, 18i8, and 18i20 Gen 2
audio interfaces. Although the interfaces are USB compliant,
additional input/output level controls and hardware routing/mixing
functionality are available using proprietary USB requests.

Signed-off-by: Geoffrey D. Bennett <g@b4.vu>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
sound/usb/Makefile
sound/usb/mixer.c
sound/usb/mixer.h
sound/usb/mixer_quirks.c
sound/usb/mixer_scarlett_gen2.c [new file with mode: 0644]
sound/usb/mixer_scarlett_gen2.h [new file with mode: 0644]

index e1ce257ab705a786a0fbf6079e8e62fc9632c2ab..f4b7384caa9dded2679ba9836ea579331f4878e6 100644 (file)
@@ -11,6 +11,7 @@ snd-usb-audio-objs :=         card.o \
                        mixer.o \
                        mixer_quirks.o \
                        mixer_scarlett.o \
+                       mixer_scarlett_gen2.o \
                        mixer_us16x08.o \
                        pcm.o \
                        power.o \
index 7498b5191b68e4cf0368599998160ec0eb17f29d..7b51ab4c35b085c348fa59c8fbda94ff06c62464 100644 (file)
@@ -3509,6 +3509,8 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
                usb_kill_urb(mixer->urb);
        if (mixer->rc_urb)
                usb_kill_urb(mixer->rc_urb);
+       if (mixer->private_free)
+               mixer->private_free(mixer);
        mixer->disconnected = true;
 }
 
@@ -3536,6 +3538,8 @@ static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
 int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
 {
        snd_usb_mixer_inactivate(mixer);
+       if (mixer->private_suspend)
+               mixer->private_suspend(mixer);
        return 0;
 }
 
index 394cd91075071c2853d9cf39737bf178587af8b7..37e1b234c802f59fec54a6a2b067b50e45511975 100644 (file)
@@ -28,6 +28,10 @@ struct usb_mixer_interface {
        struct media_mixer_ctl *media_mixer_ctl;
 
        bool disconnected;
+
+       void *private_data;
+       void (*private_free)(struct usb_mixer_interface *mixer);
+       void (*private_suspend)(struct usb_mixer_interface *mixer);
 };
 
 #define MAX_CHANNELS   16      /* max logical channels */
index 199fa157a411e4731fa56e477f0953b2c8fd68ea..70805c15b0b52fa3db1ae7894c28822e659eee40 100644 (file)
@@ -32,6 +32,7 @@
 #include "mixer.h"
 #include "mixer_quirks.h"
 #include "mixer_scarlett.h"
+#include "mixer_scarlett_gen2.h"
 #include "mixer_us16x08.h"
 #include "helper.h"
 
@@ -2258,6 +2259,12 @@ int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
                err = snd_scarlett_controls_create(mixer);
                break;
 
+       case USB_ID(0x1235, 0x8203): /* Focusrite Scarlett 6i6 2nd Gen */
+       case USB_ID(0x1235, 0x8204): /* Focusrite Scarlett 18i8 2nd Gen */
+       case USB_ID(0x1235, 0x8201): /* Focusrite Scarlett 18i20 2nd Gen */
+               err = snd_scarlett_gen2_controls_create(mixer);
+               break;
+
        case USB_ID(0x041e, 0x323b): /* Creative Sound Blaster E1 */
                err = snd_soundblaster_e1_switch_create(mixer);
                break;
diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c
new file mode 100644 (file)
index 0000000..7d460b1
--- /dev/null
@@ -0,0 +1,2075 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ *   Focusrite Scarlett 6i6/18i8/18i20 Gen 2 Driver for ALSA
+ *
+ *   Copyright (c) 2018-2019 by Geoffrey D. Bennett <g at b4.vu>
+ *
+ *   Based on the Scarlett (Gen 1) Driver for ALSA:
+ *
+ *   Copyright (c) 2013 by Tobias Hoffmann
+ *   Copyright (c) 2013 by Robin Gareus <robin at gareus.org>
+ *   Copyright (c) 2002 by Takashi Iwai <tiwai at suse.de>
+ *   Copyright (c) 2014 by Chris J Arges <chris.j.arges at canonical.com>
+ *
+ *   Many codes borrowed from audio.c by
+ *     Alan Cox (alan at lxorguk.ukuu.org.uk)
+ *     Thomas Sailer (sailer at ife.ee.ethz.ch)
+ *
+ *   Code cleanup:
+ *   David Henningsson <david.henningsson at canonical.com>
+ */
+
+/* Mixer Interface for the Focusrite Scarlett 6i6/18i8/18i20 Gen 2 audio
+ * interface. Based on the Gen 1 driver and rewritten.
+ */
+
+/* The protocol was reverse engineered by looking at the communication
+ * between Focusrite Control 2.3.4 and the Focusrite(R) Scarlett 18i20
+ * (firmware 1083) using usbmon in July-August 2018.
+ *
+ * Scarlett 18i8 support added in April 2019.
+ *
+ * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
+ * for providing usbmon output and testing).
+ *
+ * This ALSA mixer gives access to:
+ *  - input, output, mixer-matrix muxes
+ *  - 18x10 mixer-matrix gain stages
+ *  - gain/volume controls
+ *  - level meters
+ *  - line/inst level and pad controls
+ *
+ * <ditaa>
+ *    /--------------\    18chn            20chn     /--------------\
+ *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
+ *    \--------------/  |      |    |             |  \--------------/
+ *                      |      |    |    /-----\  |
+ *                      |      |    |    |     |  |
+ *                      |      v    v    v     |  |
+ *                      |   +---------------+  |  |
+ *                      |    \ Matrix  Mux /   |  |
+ *                      |     +-----+-----+    |  |
+ *                      |           |          |  |
+ *                      |           |18chn     |  |
+ *                      |           |          |  |
+ *                      |           |     10chn|  |
+ *                      |           v          |  |
+ *                      |     +------------+   |  |
+ *                      |     | Mixer      |   |  |
+ *                      |     |     Matrix |   |  |
+ *                      |     |            |   |  |
+ *                      |     | 18x10 Gain |   |  |
+ *                      |     |   stages   |   |  |
+ *                      |     +-----+------+   |  |
+ *                      |           |          |  |
+ *                      |18chn      |10chn     |  |20chn
+ *                      |           |          |  |
+ *                      |           +----------/  |
+ *                      |           |             |
+ *                      v           v             v
+ *                      ===========================
+ *               +---------------+       +--—------------+
+ *                \ Output  Mux /         \ Capture Mux /
+ *                 +---+---+---+           +-----+-----+
+ *                     |   |                     |
+ *                10chn|   |                     |18chn
+ *                     |   |                     |
+ *  /--------------\   |   |                     |   /--------------\
+ *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
+ *  | Hardware out |       |                         \--------------/
+ *  \--------------/       |
+ *                         v
+ *                  +-------------+    Software gain per channel.
+ *                  | Master Gain |<-- 18i20 only: Switch per channel
+ *                  +------+------+    to select HW or SW gain control.
+ *                         |
+ *                         |10chn
+ *  /--------------\       |
+ *  | Analogue     |<------/
+ *  | Hardware out |
+ *  \--------------/
+ * </ditaa>
+ *
+ */
+
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/moduleparam.h>
+
+#include <sound/control.h>
+#include <sound/tlv.h>
+
+#include "usbaudio.h"
+#include "mixer.h"
+#include "helper.h"
+
+#include "mixer_scarlett_gen2.h"
+
+/* device_setup value to enable */
+#define SCARLETT2_ENABLE 0x01
+
+/* some gui mixers can't handle negative ctl values */
+#define SCARLETT2_VOLUME_BIAS 127
+
+/* mixer range from -80dB to +6dB in 0.5dB steps */
+#define SCARLETT2_MIXER_MIN_DB -80
+#define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
+#define SCARLETT2_MIXER_MAX_DB 6
+#define SCARLETT2_MIXER_MAX_VALUE \
+       ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
+
+/* map from (dB + 80) * 2 to mixer value
+ * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
+ */
+static const u16 scarlett2_mixer_values[173] = {
+       0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+       2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 8, 8,
+       9, 9, 10, 10, 11, 12, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
+       23, 24, 25, 27, 29, 30, 32, 34, 36, 38, 41, 43, 46, 48, 51,
+       54, 57, 61, 65, 68, 73, 77, 81, 86, 91, 97, 103, 109, 115,
+       122, 129, 137, 145, 154, 163, 173, 183, 194, 205, 217, 230,
+       244, 259, 274, 290, 307, 326, 345, 365, 387, 410, 434, 460,
+       487, 516, 547, 579, 614, 650, 689, 730, 773, 819, 867, 919,
+       973, 1031, 1092, 1157, 1225, 1298, 1375, 1456, 1543, 1634,
+       1731, 1833, 1942, 2057, 2179, 2308, 2445, 2590, 2744, 2906,
+       3078, 3261, 3454, 3659, 3876, 4105, 4349, 4606, 4879, 5168,
+       5475, 5799, 6143, 6507, 6892, 7301, 7733, 8192, 8677, 9191,
+       9736, 10313, 10924, 11571, 12257, 12983, 13752, 14567, 15430,
+       16345
+};
+
+/* Maximum number of analogue outputs */
+#define SCARLETT2_ANALOGUE_MAX 10
+
+/* Maximum number of level and pad switches */
+#define SCARLETT2_LEVEL_SWITCH_MAX 2
+#define SCARLETT2_PAD_SWITCH_MAX 4
+
+/* Maximum number of inputs to the mixer */
+#define SCARLETT2_INPUT_MIX_MAX 18
+
+/* Maximum number of outputs from the mixer */
+#define SCARLETT2_OUTPUT_MIX_MAX 10
+
+/* Maximum size of the data in the USB mux assignment message:
+ * 18 inputs, 20 outputs, 18 matrix inputs, 8 spare
+ */
+#define SCARLETT2_MUX_MAX 64
+
+/* Number of meters:
+ * 18 inputs, 20 outputs, 18 matrix inputs
+ */
+#define SCARLETT2_NUM_METERS 56
+
+/* Hardware port types:
+ * - None (no input to mux)
+ * - Analogue I/O
+ * - S/PDIF I/O
+ * - ADAT I/O
+ * - Mixer I/O
+ * - PCM I/O
+ */
+enum {
+       SCARLETT2_PORT_TYPE_NONE = 0,
+       SCARLETT2_PORT_TYPE_ANALOGUE = 1,
+       SCARLETT2_PORT_TYPE_SPDIF = 2,
+       SCARLETT2_PORT_TYPE_ADAT = 3,
+       SCARLETT2_PORT_TYPE_MIX = 4,
+       SCARLETT2_PORT_TYPE_PCM = 5,
+       SCARLETT2_PORT_TYPE_COUNT = 6,
+};
+
+/* Count of total I/O and number available at each sample rate */
+enum {
+       SCARLETT2_PORT_IN = 0,
+       SCARLETT2_PORT_OUT = 1,
+       SCARLETT2_PORT_OUT_44 = 2,
+       SCARLETT2_PORT_OUT_88 = 3,
+       SCARLETT2_PORT_OUT_176 = 4,
+       SCARLETT2_PORT_DIRECTIONS = 5,
+};
+
+/* Hardware buttons on the 18i20 */
+#define SCARLETT2_BUTTON_MAX 2
+
+static const char *const scarlett2_button_names[SCARLETT2_BUTTON_MAX] = {
+       "Mute", "Dim"
+};
+
+/* Description of each hardware port type:
+ * - id: hardware ID for this port type
+ * - num: number of sources/destinations of this port type
+ * - src_descr: printf format string for mux input selections
+ * - src_num_offset: added to channel number for the fprintf
+ * - dst_descr: printf format string for mixer controls
+ */
+struct scarlett2_ports {
+       u16 id;
+       int num[SCARLETT2_PORT_DIRECTIONS];
+       const char * const src_descr;
+       int src_num_offset;
+       const char * const dst_descr;
+};
+
+struct scarlett2_device_info {
+       u8 line_out_hw_vol; /* line out hw volume is sw controlled */
+       u8 button_count; /* number of buttons */
+       u8 level_input_count; /* inputs with level selectable */
+       u8 pad_input_count; /* inputs with pad selectable */
+       const char * const line_out_descrs[SCARLETT2_ANALOGUE_MAX];
+       struct scarlett2_ports ports[SCARLETT2_PORT_TYPE_COUNT];
+};
+
+struct scarlett2_mixer_data {
+       struct usb_mixer_interface *mixer;
+       struct mutex usb_mutex; /* prevent sending concurrent USB requests */
+       struct mutex data_mutex; /* lock access to this data */
+       struct delayed_work work;
+       const struct scarlett2_device_info *info;
+       int num_mux_srcs;
+       u16 scarlett2_seq;
+       u8 vol_updated;
+       u8 master_vol;
+       u8 vol[SCARLETT2_ANALOGUE_MAX];
+       u8 vol_sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
+       u8 level_switch[SCARLETT2_LEVEL_SWITCH_MAX];
+       u8 pad_switch[SCARLETT2_PAD_SWITCH_MAX];
+       u8 buttons[SCARLETT2_BUTTON_MAX];
+       struct snd_kcontrol *master_vol_ctl;
+       struct snd_kcontrol *vol_ctls[SCARLETT2_ANALOGUE_MAX];
+       struct snd_kcontrol *button_ctls[SCARLETT2_BUTTON_MAX];
+       u8 mux[SCARLETT2_MUX_MAX];
+       u8 mix[SCARLETT2_INPUT_MIX_MAX * SCARLETT2_OUTPUT_MIX_MAX];
+};
+
+/*** Model-specific data ***/
+
+static const struct scarlett2_device_info s6i6_gen2_info = {
+       /* The first two analogue inputs can be switched between line
+        * and instrument levels.
+        */
+       .level_input_count = 2,
+
+       /* The first two analogue inputs have an optional pad. */
+       .pad_input_count = 2,
+
+       .line_out_descrs = {
+               "Monitor L",
+               "Monitor R",
+               "Headphones L",
+               "Headphones R",
+       },
+
+       .ports = {
+               {
+                       .id = 0x000,
+                       .num = { 1, 0, 8, 8, 8 },
+                       .src_descr = "Off",
+                       .src_num_offset = 0,
+               },
+               {
+                       .id = 0x080,
+                       .num = { 4, 4, 4, 4, 4 },
+                       .src_descr = "Analogue %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "Analogue Output %02d Playback"
+               },
+               {
+                       .id = 0x180,
+                       .num = { 2, 2, 2, 2, 2 },
+                       .src_descr = "S/PDIF %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "S/PDIF Output %d Playback"
+               },
+               {
+                       .id = 0x300,
+                       .num = { 10, 18, 18, 18, 18 },
+                       .src_descr = "Mix %c",
+                       .src_num_offset = 65,
+                       .dst_descr = "Mixer Input %02d Capture"
+               },
+               {
+                       .id = 0x600,
+                       .num = { 6, 6, 6, 6, 6 },
+                       .src_descr = "PCM %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "PCM %02d Capture"
+               },
+       },
+};
+
+static const struct scarlett2_device_info s18i8_gen2_info = {
+       /* The first two analogue inputs can be switched between line
+        * and instrument levels.
+        */
+       .level_input_count = 2,
+
+       /* The first four analogue inputs have an optional pad. */
+       .pad_input_count = 4,
+
+       .line_out_descrs = {
+               "Monitor L",
+               "Monitor R",
+               "Headphones 1 L",
+               "Headphones 1 R",
+               "Headphones 2 L",
+               "Headphones 2 R",
+       },
+
+       .ports = {
+               {
+                       .id = 0x000,
+                       .num = { 1, 0, 8, 8, 4 },
+                       .src_descr = "Off",
+                       .src_num_offset = 0,
+               },
+               {
+                       .id = 0x080,
+                       .num = { 8, 6, 6, 6, 6 },
+                       .src_descr = "Analogue %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "Analogue Output %02d Playback"
+               },
+               {
+                       /* S/PDIF outputs aren't available at 192KHz
+                        * but are included in the USB mux I/O
+                        * assignment message anyway
+                        */
+                       .id = 0x180,
+                       .num = { 2, 2, 2, 2, 2 },
+                       .src_descr = "S/PDIF %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "S/PDIF Output %d Playback"
+               },
+               {
+                       .id = 0x200,
+                       .num = { 8, 0, 0, 0, 0 },
+                       .src_descr = "ADAT %d",
+                       .src_num_offset = 1,
+               },
+               {
+                       .id = 0x300,
+                       .num = { 10, 18, 18, 18, 18 },
+                       .src_descr = "Mix %c",
+                       .src_num_offset = 65,
+                       .dst_descr = "Mixer Input %02d Capture"
+               },
+               {
+                       .id = 0x600,
+                       .num = { 20, 18, 18, 14, 10 },
+                       .src_descr = "PCM %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "PCM %02d Capture"
+               },
+       },
+};
+
+static const struct scarlett2_device_info s18i20_gen2_info = {
+       /* The analogue line outputs on the 18i20 can be switched
+        * between software and hardware volume control
+        */
+       .line_out_hw_vol = 1,
+
+       /* Mute and dim buttons */
+       .button_count = 2,
+
+       .line_out_descrs = {
+               "Monitor L",
+               "Monitor R",
+               NULL,
+               NULL,
+               NULL,
+               NULL,
+               "Headphones 1 L",
+               "Headphones 1 R",
+               "Headphones 2 L",
+               "Headphones 2 R",
+       },
+
+       .ports = {
+               {
+                       .id = 0x000,
+                       .num = { 1, 0, 8, 8, 6 },
+                       .src_descr = "Off",
+                       .src_num_offset = 0,
+               },
+               {
+                       .id = 0x080,
+                       .num = { 8, 10, 10, 10, 10 },
+                       .src_descr = "Analogue %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "Analogue Output %02d Playback"
+               },
+               {
+                       /* S/PDIF outputs aren't available at 192KHz
+                        * but are included in the USB mux I/O
+                        * assignment message anyway
+                        */
+                       .id = 0x180,
+                       .num = { 2, 2, 2, 2, 2 },
+                       .src_descr = "S/PDIF %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "S/PDIF Output %d Playback"
+               },
+               {
+                       .id = 0x200,
+                       .num = { 8, 8, 8, 4, 0 },
+                       .src_descr = "ADAT %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "ADAT Output %d Playback"
+               },
+               {
+                       .id = 0x300,
+                       .num = { 10, 18, 18, 18, 18 },
+                       .src_descr = "Mix %c",
+                       .src_num_offset = 65,
+                       .dst_descr = "Mixer Input %02d Capture"
+               },
+               {
+                       .id = 0x600,
+                       .num = { 20, 18, 18, 14, 10 },
+                       .src_descr = "PCM %d",
+                       .src_num_offset = 1,
+                       .dst_descr = "PCM %02d Capture"
+               },
+       },
+};
+
+/* get the starting port index number for a given port type/direction */
+static int scarlett2_get_port_start_num(const struct scarlett2_ports *ports,
+                                       int direction, int port_type)
+{
+       int i, num = 0;
+
+       for (i = 0; i < port_type; i++)
+               num += ports[i].num[direction];
+
+       return num;
+}
+
+/*** USB Interactions ***/
+
+/* Vendor-Specific Interface, Endpoint, MaxPacketSize, Interval */
+#define SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE 5
+#define SCARLETT2_USB_INTERRUPT_ENDPOINT 4
+#define SCARLETT2_USB_INTERRUPT_MAX_DATA 64
+#define SCARLETT2_USB_INTERRUPT_INTERVAL 3
+
+/* Interrupt flags for volume and mute/dim button changes */
+#define SCARLETT2_USB_INTERRUPT_VOL_CHANGE 0x400000
+#define SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE 0x200000
+
+/* Commands for sending/receiving requests/responses */
+#define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ 2
+#define SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP 3
+
+#define SCARLETT2_USB_INIT_SEQ 0x00000000
+#define SCARLETT2_USB_GET_METER_LEVELS 0x00001001
+#define SCARLETT2_USB_SET_MIX 0x00002002
+#define SCARLETT2_USB_SET_MUX 0x00003002
+#define SCARLETT2_USB_GET_DATA 0x00800000
+#define SCARLETT2_USB_SET_DATA 0x00800001
+#define SCARLETT2_USB_DATA_CMD 0x00800002
+#define SCARLETT2_USB_CONFIG_SAVE 6
+
+#define SCARLETT2_USB_VOLUME_STATUS_OFFSET 0x31
+#define SCARLETT2_USB_METER_LEVELS_GET_MAGIC 1
+
+/* volume status is read together (matches scarlett2_config_items[]) */
+struct scarlett2_usb_volume_status {
+       /* mute & dim buttons */
+       u8 buttons[SCARLETT2_BUTTON_MAX];
+
+       u8 pad1;
+
+       /* software volume setting */
+       s16 sw_vol[SCARLETT2_ANALOGUE_MAX];
+
+       /* actual volume of output inc. dim (-18dB) */
+       s16 hw_vol[SCARLETT2_ANALOGUE_MAX];
+
+       u8 pad2[SCARLETT2_ANALOGUE_MAX];
+
+       /* sw (0) or hw (1) controlled */
+       u8 sw_hw_switch[SCARLETT2_ANALOGUE_MAX];
+
+       u8 pad3[6];
+
+       /* front panel volume knob */
+       s16 master_vol;
+} __packed;
+
+/* Configuration parameters that can be read and written */
+enum {
+       SCARLETT2_CONFIG_BUTTONS = 0,
+       SCARLETT2_CONFIG_LINE_OUT_VOLUME = 1,
+       SCARLETT2_CONFIG_SW_HW_SWITCH = 2,
+       SCARLETT2_CONFIG_LEVEL_SWITCH = 3,
+       SCARLETT2_CONFIG_PAD_SWITCH = 4,
+       SCARLETT2_CONFIG_COUNT = 5
+};
+
+/* Location, size, and activation command number for the configuration
+ * parameters
+ */
+struct scarlett2_config {
+       u8 offset;
+       u8 size;
+       u8 activate;
+};
+
+static const struct scarlett2_config
+               scarlett2_config_items[SCARLETT2_CONFIG_COUNT] = {
+       /* Mute/Dim Buttons */
+       {
+               .offset = 0x31,
+               .size = 1,
+               .activate = 2
+       },
+
+       /* Line Out Volume */
+       {
+               .offset = 0x34,
+               .size = 2,
+               .activate = 1
+       },
+
+       /* SW/HW Volume Switch */
+       {
+               .offset = 0x66,
+               .size = 1,
+               .activate = 3
+       },
+
+       /* Level Switch */
+       {
+               .offset = 0x7c,
+               .size = 1,
+               .activate = 7
+       },
+
+       /* Pad Switch */
+       {
+               .offset = 0x84,
+               .size = 1,
+               .activate = 8
+       }
+};
+
+/* proprietary request/response format */
+struct scarlett2_usb_packet {
+       u32 cmd;
+       u16 size;
+       u16 seq;
+       u32 error;
+       u32 pad;
+       u8 data[];
+};
+
+#define SCARLETT2_USB_PACKET_LEN (sizeof(struct scarlett2_usb_packet))
+
+static void scarlett2_fill_request_header(struct scarlett2_mixer_data *private,
+                                         struct scarlett2_usb_packet *req,
+                                         u32 cmd, u16 req_size)
+{
+       /* sequence must go up by 1 for each request */
+       u16 seq = private->scarlett2_seq++;
+
+       req->cmd = cpu_to_le32(cmd);
+       req->size = cpu_to_le16(req_size);
+       req->seq = cpu_to_le16(seq);
+       req->error = 0;
+       req->pad = 0;
+}
+
+/* Send a proprietary format request to the Scarlett interface */
+static int scarlett2_usb(
+       struct usb_mixer_interface *mixer, u32 cmd,
+       void *req_data, u16 req_size, void *resp_data, u16 resp_size)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       u16 req_buf_size = sizeof(struct scarlett2_usb_packet) + req_size;
+       u16 resp_buf_size = sizeof(struct scarlett2_usb_packet) + resp_size;
+       struct scarlett2_usb_packet *req = NULL, *resp = NULL;
+       int err = 0;
+
+       req = kmalloc(req_buf_size, GFP_KERNEL);
+       if (!req) {
+               err = -ENOMEM;
+               goto error;
+       }
+
+       resp = kmalloc(resp_buf_size, GFP_KERNEL);
+       if (!resp) {
+               err = -ENOMEM;
+               goto error;
+       }
+
+       mutex_lock(&private->usb_mutex);
+
+       /* build request message and send it */
+
+       scarlett2_fill_request_header(private, req, cmd, req_size);
+
+       if (req_size)
+               memcpy(req->data, req_data, req_size);
+
+       err = snd_usb_ctl_msg(mixer->chip->dev,
+                       usb_sndctrlpipe(mixer->chip->dev, 0),
+                       SCARLETT2_USB_VENDOR_SPECIFIC_CMD_REQ,
+                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
+                       0,
+                       SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
+                       req,
+                       req_buf_size);
+
+       if (err != req_buf_size) {
+               usb_audio_err(
+                       mixer->chip,
+                       "Scarlett Gen 2 USB request result cmd %x was %d\n",
+                       cmd, err);
+               err = -EINVAL;
+               goto unlock;
+       }
+
+       /* send a second message to get the response */
+
+       err = snd_usb_ctl_msg(mixer->chip->dev,
+                       usb_sndctrlpipe(mixer->chip->dev, 0),
+                       SCARLETT2_USB_VENDOR_SPECIFIC_CMD_RESP,
+                       USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN,
+                       0,
+                       SCARLETT2_USB_VENDOR_SPECIFIC_INTERFACE,
+                       resp,
+                       resp_buf_size);
+
+       /* validate the response */
+
+       if (err != resp_buf_size) {
+               usb_audio_err(
+                       mixer->chip,
+                       "Scarlett Gen 2 USB response result cmd %x was %d\n",
+                       cmd, err);
+               err = -EINVAL;
+               goto unlock;
+       }
+
+       if (resp->cmd != req->cmd ||
+           resp->seq != req->seq ||
+           resp_size != le16_to_cpu(resp->size) ||
+           resp->error ||
+           resp->pad) {
+               usb_audio_err(
+                       mixer->chip,
+                       "Scarlett Gen 2 USB invalid response; "
+                          "cmd tx/rx %d/%d seq %d/%d size %d/%d "
+                          "error %d pad %d\n",
+                       le16_to_cpu(req->cmd), le16_to_cpu(resp->cmd),
+                       le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
+                       resp_size, le16_to_cpu(resp->size),
+                       le16_to_cpu(resp->error),
+                       le16_to_cpu(resp->pad));
+               err = -EINVAL;
+               goto unlock;
+       }
+
+       if (resp_size > 0)
+               memcpy(resp_data, resp->data, resp_size);
+
+unlock:
+       mutex_unlock(&private->usb_mutex);
+error:
+       kfree(req);
+       kfree(resp);
+       return err;
+}
+
+/* Send SCARLETT2_USB_DATA_CMD SCARLETT2_USB_CONFIG_SAVE */
+static void scarlett2_config_save(struct usb_mixer_interface *mixer)
+{
+       u32 req = cpu_to_le32(SCARLETT2_USB_CONFIG_SAVE);
+
+       scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
+                     &req, sizeof(u32),
+                     NULL, 0);
+}
+
+/* Delayed work to save config */
+static void scarlett2_config_save_work(struct work_struct *work)
+{
+       struct scarlett2_mixer_data *private =
+               container_of(work, struct scarlett2_mixer_data, work.work);
+
+       scarlett2_config_save(private->mixer);
+}
+
+/* Send a USB message to set a configuration parameter (volume level,
+ * sw/hw volume switch, line/inst level switch, or pad switch)
+ */
+static int scarlett2_usb_set_config(
+       struct usb_mixer_interface *mixer,
+       int config_item_num, int index, int value)
+{
+       const struct scarlett2_config config_item =
+              scarlett2_config_items[config_item_num];
+       struct {
+               u32 offset;
+               u32 bytes;
+               s32 value;
+       } __packed req;
+       u32 req2;
+       int err;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       /* Cancel any pending NVRAM save */
+       cancel_delayed_work_sync(&private->work);
+
+       /* Send the configuration parameter data */
+       req.offset = cpu_to_le32(config_item.offset + index * config_item.size);
+       req.bytes = cpu_to_le32(config_item.size);
+       req.value = cpu_to_le32(value);
+       err = scarlett2_usb(mixer, SCARLETT2_USB_SET_DATA,
+                           &req, sizeof(u32) * 2 + config_item.size,
+                           NULL, 0);
+       if (err < 0)
+               return err;
+
+       /* Activate the change */
+       req2 = cpu_to_le32(config_item.activate);
+       err = scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
+                           &req2, sizeof(req2), NULL, 0);
+       if (err < 0)
+               return err;
+
+       /* Schedule the change to be written to NVRAM */
+       schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
+
+       return 0;
+}
+
+/* Send a USB message to get data; result placed in *buf */
+static int scarlett2_usb_get(
+       struct usb_mixer_interface *mixer,
+       int offset, void *buf, int size)
+{
+       struct {
+               u32 offset;
+               u32 size;
+       } __packed req;
+
+       req.offset = cpu_to_le32(offset);
+       req.size = cpu_to_le32(size);
+       return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
+                            &req, sizeof(req), buf, size);
+}
+
+/* Send a USB message to get configuration parameters; result placed in *buf */
+static int scarlett2_usb_get_config(
+       struct usb_mixer_interface *mixer,
+       int config_item_num, int count, void *buf)
+{
+       const struct scarlett2_config config_item =
+              scarlett2_config_items[config_item_num];
+       int size = config_item.size * count;
+
+       return scarlett2_usb_get(mixer, config_item.offset, buf, size);
+}
+
+/* Send a USB message to get volume status; result placed in *buf */
+static int scarlett2_usb_get_volume_status(
+       struct usb_mixer_interface *mixer,
+       struct scarlett2_usb_volume_status *buf)
+{
+       return scarlett2_usb_get(mixer, SCARLETT2_USB_VOLUME_STATUS_OFFSET,
+                                buf, sizeof(*buf));
+}
+
+/* Send a USB message to set the volumes for all inputs of one mix
+ * (values obtained from private->mix[])
+ */
+static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
+                                    int mix_num)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+
+       struct {
+               u16 mix_num;
+               u16 data[SCARLETT2_INPUT_MIX_MAX];
+       } __packed req;
+
+       int i, j;
+       int num_mixer_in =
+               info->ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+
+       req.mix_num = cpu_to_le16(mix_num);
+
+       for (i = 0, j = mix_num * num_mixer_in; i < num_mixer_in; i++, j++)
+               req.data[i] = cpu_to_le16(
+                       scarlett2_mixer_values[private->mix[j]]
+               );
+
+       return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
+                            &req, (num_mixer_in + 1) * sizeof(u16),
+                            NULL, 0);
+}
+
+/* Convert a port number index (per info->ports) to a hardware ID */
+static u32 scarlett2_mux_src_num_to_id(const struct scarlett2_ports *ports,
+                                      int num)
+{
+       int port_type;
+
+       for (port_type = 0;
+            port_type < SCARLETT2_PORT_TYPE_COUNT;
+            port_type++) {
+               if (num < ports[port_type].num[SCARLETT2_PORT_IN])
+                       return ports[port_type].id | num;
+               num -= ports[port_type].num[SCARLETT2_PORT_IN];
+       }
+
+       /* Oops */
+       return 0;
+}
+
+/* Send USB messages to set mux inputs */
+static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+       const struct scarlett2_ports *ports = info->ports;
+       int rate, port_dir_rate;
+
+       static const int assignment_order[SCARLETT2_PORT_TYPE_COUNT] = {
+               SCARLETT2_PORT_TYPE_PCM,
+               SCARLETT2_PORT_TYPE_ANALOGUE,
+               SCARLETT2_PORT_TYPE_SPDIF,
+               SCARLETT2_PORT_TYPE_ADAT,
+               SCARLETT2_PORT_TYPE_MIX,
+               SCARLETT2_PORT_TYPE_NONE,
+       };
+
+       struct {
+               u16 pad;
+               u16 num;
+               u32 data[SCARLETT2_MUX_MAX];
+       } __packed req;
+
+       req.pad = 0;
+
+       /* mux settings for each rate */
+       for (rate = 0, port_dir_rate = SCARLETT2_PORT_OUT_44;
+            port_dir_rate <= SCARLETT2_PORT_OUT_176;
+            rate++, port_dir_rate++) {
+               int order_num, i, err;
+
+               req.num = cpu_to_le16(rate);
+
+               for (order_num = 0, i = 0;
+                    order_num < SCARLETT2_PORT_TYPE_COUNT;
+                    order_num++) {
+                       int port_type = assignment_order[order_num];
+                       int j = scarlett2_get_port_start_num(ports,
+                                                            SCARLETT2_PORT_OUT,
+                                                            port_type);
+                       int port_id = ports[port_type].id;
+                       int channel;
+
+                       for (channel = 0;
+                            channel < ports[port_type].num[port_dir_rate];
+                            channel++, i++, j++)
+                               /* lower 12 bits for the destination and
+                                * next 12 bits for the source
+                                */
+                               req.data[i] = !port_id
+                                       ? 0
+                                       : cpu_to_le32(
+                                               port_id |
+                                               channel |
+                                               scarlett2_mux_src_num_to_id(
+                                                       ports, private->mux[j]
+                                               ) << 12
+                                         );
+
+                       /* skip private->mux[j] entries not output */
+                       j += ports[port_type].num[SCARLETT2_PORT_OUT] -
+                            ports[port_type].num[port_dir_rate];
+               }
+
+               err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
+                                   &req, (i + 1) * sizeof(u32),
+                                   NULL, 0);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+/* Send USB message to get meter levels */
+static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
+                                         u16 *levels)
+{
+       struct {
+               u16 pad;
+               u16 num_meters;
+               u32 magic;
+       } __packed req;
+       u32 resp[SCARLETT2_NUM_METERS];
+       int i, err;
+
+       req.pad = 0;
+       req.num_meters = cpu_to_le16(SCARLETT2_NUM_METERS);
+       req.magic = cpu_to_le32(SCARLETT2_USB_METER_LEVELS_GET_MAGIC);
+       err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER_LEVELS,
+                           &req, sizeof(req), resp, sizeof(resp));
+       if (err < 0)
+               return err;
+
+       /* copy, convert to u16 */
+       for (i = 0; i < SCARLETT2_NUM_METERS; i++)
+               levels[i] = resp[i];
+
+       return 0;
+}
+
+/*** Control Functions ***/
+
+/* helper function to create a new control */
+static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
+                                const struct snd_kcontrol_new *ncontrol,
+                                int index, int channels, const char *name,
+                                struct snd_kcontrol **kctl_return)
+{
+       struct snd_kcontrol *kctl;
+       struct usb_mixer_elem_info *elem;
+       int err;
+
+       elem = kzalloc(sizeof(*elem), GFP_KERNEL);
+       if (!elem)
+               return -ENOMEM;
+
+       elem->head.mixer = mixer;
+       elem->control = index;
+       elem->head.id = index;
+       elem->channels = channels;
+
+       kctl = snd_ctl_new1(ncontrol, elem);
+       if (!kctl) {
+               kfree(elem);
+               return -ENOMEM;
+       }
+       kctl->private_free = snd_usb_mixer_elem_free;
+
+       strlcpy(kctl->id.name, name, sizeof(kctl->id.name));
+
+       err = snd_usb_mixer_add_control(&elem->head, kctl);
+       if (err < 0)
+               return err;
+
+       if (kctl_return)
+               *kctl_return = kctl;
+
+       return 0;
+}
+
+/*** Analogue Line Out Volume Controls ***/
+
+/* Update hardware volume controls after receiving notification that
+ * they have changed
+ */
+static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_ports *ports = private->info->ports;
+       struct scarlett2_usb_volume_status volume_status;
+       int num_line_out =
+               ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+       int err, i;
+
+       private->vol_updated = 0;
+
+       err = scarlett2_usb_get_volume_status(mixer, &volume_status);
+       if (err < 0)
+               return err;
+
+       private->master_vol = clamp(
+               volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
+               0, SCARLETT2_VOLUME_BIAS);
+
+       for (i = 0; i < num_line_out; i++) {
+               if (private->vol_sw_hw_switch[i])
+                       private->vol[i] = private->master_vol;
+       }
+
+       for (i = 0; i < private->info->button_count; i++)
+               private->buttons[i] = !!volume_status.buttons[i];
+
+       return 0;
+}
+
+static int scarlett2_volume_ctl_info(struct snd_kcontrol *kctl,
+                                    struct snd_ctl_elem_info *uinfo)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = elem->channels;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
+       uinfo->value.integer.step = 1;
+       return 0;
+}
+
+static int scarlett2_master_volume_ctl_get(struct snd_kcontrol *kctl,
+                                          struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       if (private->vol_updated) {
+               mutex_lock(&private->data_mutex);
+               scarlett2_update_volumes(mixer);
+               mutex_unlock(&private->data_mutex);
+       }
+
+       ucontrol->value.integer.value[0] = private->master_vol;
+       return 0;
+}
+
+static int scarlett2_volume_ctl_get(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       int index = elem->control;
+
+       if (private->vol_updated) {
+               mutex_lock(&private->data_mutex);
+               scarlett2_update_volumes(mixer);
+               mutex_unlock(&private->data_mutex);
+       }
+
+       ucontrol->value.integer.value[0] = private->vol[index];
+       return 0;
+}
+
+static int scarlett2_volume_ctl_put(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->vol[index];
+       val = ucontrol->value.integer.value[0];
+
+       if (oval == val)
+               goto unlock;
+
+       private->vol[index] = val;
+       err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
+                                      index, val - SCARLETT2_VOLUME_BIAS);
+       if (err == 0)
+               err = 1;
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const DECLARE_TLV_DB_MINMAX(
+       db_scale_scarlett2_gain, -SCARLETT2_VOLUME_BIAS * 100, 0
+);
+
+static const struct snd_kcontrol_new scarlett2_master_volume_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .access = SNDRV_CTL_ELEM_ACCESS_READ |
+                 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+       .name = "",
+       .info = scarlett2_volume_ctl_info,
+       .get  = scarlett2_master_volume_ctl_get,
+       .private_value = 0, /* max value */
+       .tlv = { .p = db_scale_scarlett2_gain }
+};
+
+static const struct snd_kcontrol_new scarlett2_line_out_volume_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+       .name = "",
+       .info = scarlett2_volume_ctl_info,
+       .get  = scarlett2_volume_ctl_get,
+       .put  = scarlett2_volume_ctl_put,
+       .private_value = 0, /* max value */
+       .tlv = { .p = db_scale_scarlett2_gain }
+};
+
+/*** HW/SW Volume Switch Controls ***/
+
+static int scarlett2_sw_hw_enum_ctl_info(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_info *uinfo)
+{
+       static const char *const values[2] = {
+               "SW", "HW"
+       };
+
+       return snd_ctl_enum_info(uinfo, 1, 2, values);
+}
+
+static int scarlett2_sw_hw_enum_ctl_get(struct snd_kcontrol *kctl,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+       ucontrol->value.enumerated.item[0] =
+               private->vol_sw_hw_switch[elem->control];
+       return 0;
+}
+
+static int scarlett2_sw_hw_enum_ctl_put(struct snd_kcontrol *kctl,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->vol_sw_hw_switch[index];
+       val = !!ucontrol->value.integer.value[0];
+
+       if (oval == val)
+               goto unlock;
+
+       private->vol_sw_hw_switch[index] = val;
+
+       /* Change access mode to RO (hardware controlled volume)
+        * or RW (software controlled volume)
+        */
+       if (val)
+               private->vol_ctls[index]->vd[0].access &=
+                       ~SNDRV_CTL_ELEM_ACCESS_WRITE;
+       else
+               private->vol_ctls[index]->vd[0].access |=
+                       SNDRV_CTL_ELEM_ACCESS_WRITE;
+
+       /* Reset volume to master volume */
+       private->vol[index] = private->master_vol;
+
+       /* Set SW volume to current HW volume */
+       err = scarlett2_usb_set_config(
+               mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
+               index, private->master_vol - SCARLETT2_VOLUME_BIAS);
+       if (err < 0)
+               goto unlock;
+
+       /* Notify of RO/RW change */
+       snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_INFO,
+                      &private->vol_ctls[index]->id);
+
+       /* Send SW/HW switch change to the device */
+       err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
+                                      index, val);
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_sw_hw_enum_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .name = "",
+       .info = scarlett2_sw_hw_enum_ctl_info,
+       .get  = scarlett2_sw_hw_enum_ctl_get,
+       .put  = scarlett2_sw_hw_enum_ctl_put,
+};
+
+/*** Line Level/Instrument Level Switch Controls ***/
+
+static int scarlett2_level_enum_ctl_info(struct snd_kcontrol *kctl,
+                                        struct snd_ctl_elem_info *uinfo)
+{
+       static const char *const values[2] = {
+               "Line", "Inst"
+       };
+
+       return snd_ctl_enum_info(uinfo, 1, 2, values);
+}
+
+static int scarlett2_level_enum_ctl_get(struct snd_kcontrol *kctl,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+       ucontrol->value.enumerated.item[0] =
+               private->level_switch[elem->control];
+       return 0;
+}
+
+static int scarlett2_level_enum_ctl_put(struct snd_kcontrol *kctl,
+                                       struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->level_switch[index];
+       val = !!ucontrol->value.integer.value[0];
+
+       if (oval == val)
+               goto unlock;
+
+       private->level_switch[index] = val;
+
+       /* Send switch change to the device */
+       err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
+                                      index, val);
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_level_enum_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .name = "",
+       .info = scarlett2_level_enum_ctl_info,
+       .get  = scarlett2_level_enum_ctl_get,
+       .put  = scarlett2_level_enum_ctl_put,
+};
+
+/*** Pad Switch Controls ***/
+
+static int scarlett2_pad_ctl_get(struct snd_kcontrol *kctl,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+       ucontrol->value.enumerated.item[0] =
+               private->pad_switch[elem->control];
+       return 0;
+}
+
+static int scarlett2_pad_ctl_put(struct snd_kcontrol *kctl,
+                                struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->pad_switch[index];
+       val = !!ucontrol->value.integer.value[0];
+
+       if (oval == val)
+               goto unlock;
+
+       private->pad_switch[index] = val;
+
+       /* Send switch change to the device */
+       err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
+                                      index, val);
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_pad_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .name = "",
+       .info = snd_ctl_boolean_mono_info,
+       .get  = scarlett2_pad_ctl_get,
+       .put  = scarlett2_pad_ctl_put,
+};
+
+/*** Mute/Dim Controls ***/
+
+static int scarlett2_button_ctl_get(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       if (private->vol_updated) {
+               mutex_lock(&private->data_mutex);
+               scarlett2_update_volumes(mixer);
+               mutex_unlock(&private->data_mutex);
+       }
+
+       ucontrol->value.enumerated.item[0] = private->buttons[elem->control];
+       return 0;
+}
+
+static int scarlett2_button_ctl_put(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->buttons[index];
+       val = !!ucontrol->value.integer.value[0];
+
+       if (oval == val)
+               goto unlock;
+
+       private->buttons[index] = val;
+
+       /* Send switch change to the device */
+       err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_BUTTONS,
+                                      index, val);
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_button_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .name = "",
+       .info = snd_ctl_boolean_mono_info,
+       .get  = scarlett2_button_ctl_get,
+       .put  = scarlett2_button_ctl_put
+};
+
+/*** Create the analogue output controls ***/
+
+static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+       const struct scarlett2_ports *ports = info->ports;
+       int num_line_out =
+               ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+       int err, i;
+       char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+       /* Add R/O HW volume control */
+       if (info->line_out_hw_vol) {
+               snprintf(s, sizeof(s), "Master HW Playback Volume");
+               err = scarlett2_add_new_ctl(mixer,
+                                           &scarlett2_master_volume_ctl,
+                                           0, 1, s, &private->master_vol_ctl);
+               if (err < 0)
+                       return err;
+       }
+
+       /* Add volume controls */
+       for (i = 0; i < num_line_out; i++) {
+
+               /* Fader */
+               if (info->line_out_descrs[i])
+                       snprintf(s, sizeof(s),
+                                "Line %02d (%s) Playback Volume",
+                                i + 1, info->line_out_descrs[i]);
+               else
+                       snprintf(s, sizeof(s),
+                                "Line %02d Playback Volume",
+                                i + 1);
+               err = scarlett2_add_new_ctl(mixer,
+                                           &scarlett2_line_out_volume_ctl,
+                                           i, 1, s, &private->vol_ctls[i]);
+               if (err < 0)
+                       return err;
+
+               /* Make the fader read-only if the SW/HW switch is set to HW */
+               if (private->vol_sw_hw_switch[i])
+                       private->vol_ctls[i]->vd[0].access &=
+                               ~SNDRV_CTL_ELEM_ACCESS_WRITE;
+
+               /* SW/HW Switch */
+               if (info->line_out_hw_vol) {
+                       snprintf(s, sizeof(s),
+                                "Line Out %02d Volume Control Playback Enum",
+                                i + 1);
+                       err = scarlett2_add_new_ctl(mixer,
+                                                   &scarlett2_sw_hw_enum_ctl,
+                                                   i, 1, s, NULL);
+                       if (err < 0)
+                               return err;
+               }
+       }
+
+       /* Add HW button controls */
+       for (i = 0; i < private->info->button_count; i++) {
+               err = scarlett2_add_new_ctl(mixer, &scarlett2_button_ctl,
+                                           i, 1, scarlett2_button_names[i],
+                                           &private->button_ctls[i]);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+/*** Create the analogue input controls ***/
+
+static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+       int err, i;
+       char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+       /* Add input level (line/inst) controls */
+       for (i = 0; i < info->level_input_count; i++) {
+               snprintf(s, sizeof(s), "Line In %d Level Capture Enum", i + 1);
+               err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
+                                           i, 1, s, NULL);
+               if (err < 0)
+                       return err;
+       }
+
+       /* Add input pad controls */
+       for (i = 0; i < info->pad_input_count; i++) {
+               snprintf(s, sizeof(s), "Line In %d Pad Capture Switch", i + 1);
+               err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
+                                           i, 1, s, NULL);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
+
+/*** Mixer Volume Controls ***/
+
+static int scarlett2_mixer_ctl_info(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_info *uinfo)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = elem->channels;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
+       uinfo->value.integer.step = 1;
+       return 0;
+}
+
+static int scarlett2_mixer_ctl_get(struct snd_kcontrol *kctl,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+       ucontrol->value.integer.value[0] = private->mix[elem->control];
+       return 0;
+}
+
+static int scarlett2_mixer_ctl_put(struct snd_kcontrol *kctl,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+       const struct scarlett2_ports *ports = info->ports;
+       int oval, val, num_mixer_in, mix_num, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->mix[elem->control];
+       val = ucontrol->value.integer.value[0];
+       num_mixer_in = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+       mix_num = elem->control / num_mixer_in;
+
+       if (oval == val)
+               goto unlock;
+
+       private->mix[elem->control] = val;
+       err = scarlett2_usb_set_mix(mixer, mix_num);
+       if (err == 0)
+               err = 1;
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const DECLARE_TLV_DB_MINMAX(
+       db_scale_scarlett2_mixer,
+       SCARLETT2_MIXER_MIN_DB * 100,
+       SCARLETT2_MIXER_MAX_DB * 100
+);
+
+static const struct snd_kcontrol_new scarlett2_mixer_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                 SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+       .name = "",
+       .info = scarlett2_mixer_ctl_info,
+       .get  = scarlett2_mixer_ctl_get,
+       .put  = scarlett2_mixer_ctl_put,
+       .private_value = SCARLETT2_MIXER_MAX_DB, /* max value */
+       .tlv = { .p = db_scale_scarlett2_mixer }
+};
+
+static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_ports *ports = private->info->ports;
+       int err, i, j;
+       int index;
+       char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+
+       int num_inputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_OUT];
+       int num_outputs = ports[SCARLETT2_PORT_TYPE_MIX].num[SCARLETT2_PORT_IN];
+
+       for (i = 0, index = 0; i < num_outputs; i++) {
+               for (j = 0; j < num_inputs; j++, index++) {
+                       snprintf(s, sizeof(s),
+                                "Mix %c Input %02d Playback Volume",
+                                'A' + i, j + 1);
+                       err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
+                                                   index, 1, s, NULL);
+                       if (err < 0)
+                               return err;
+               }
+       }
+
+       return 0;
+}
+
+/*** Mux Source Selection Controls ***/
+
+static int scarlett2_mux_src_enum_ctl_info(struct snd_kcontrol *kctl,
+                                          struct snd_ctl_elem_info *uinfo)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+       const struct scarlett2_ports *ports = private->info->ports;
+       unsigned int item = uinfo->value.enumerated.item;
+       int items = private->num_mux_srcs;
+       int port_type;
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
+       uinfo->count = elem->channels;
+       uinfo->value.enumerated.items = items;
+
+       if (item >= items)
+               item = uinfo->value.enumerated.item = items - 1;
+
+       for (port_type = 0;
+            port_type < SCARLETT2_PORT_TYPE_COUNT;
+            port_type++) {
+               if (item < ports[port_type].num[SCARLETT2_PORT_IN]) {
+                       sprintf(uinfo->value.enumerated.name,
+                               ports[port_type].src_descr,
+                               item + ports[port_type].src_num_offset);
+                       return 0;
+               }
+               item -= ports[port_type].num[SCARLETT2_PORT_IN];
+       }
+
+       return -EINVAL;
+}
+
+static int scarlett2_mux_src_enum_ctl_get(struct snd_kcontrol *kctl,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct scarlett2_mixer_data *private = elem->head.mixer->private_data;
+
+       ucontrol->value.enumerated.item[0] = private->mux[elem->control];
+       return 0;
+}
+
+static int scarlett2_mux_src_enum_ctl_put(struct snd_kcontrol *kctl,
+                                         struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       struct usb_mixer_interface *mixer = elem->head.mixer;
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       int index = elem->control;
+       int oval, val, err = 0;
+
+       mutex_lock(&private->data_mutex);
+
+       oval = private->mux[index];
+       val = clamp(ucontrol->value.integer.value[0],
+                   0L, private->num_mux_srcs - 1L);
+
+       if (oval == val)
+               goto unlock;
+
+       private->mux[index] = val;
+       err = scarlett2_usb_set_mux(mixer);
+       if (err == 0)
+               err = 1;
+
+unlock:
+       mutex_unlock(&private->data_mutex);
+       return err;
+}
+
+static const struct snd_kcontrol_new scarlett2_mux_src_enum_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+       .name = "",
+       .info = scarlett2_mux_src_enum_ctl_info,
+       .get  = scarlett2_mux_src_enum_ctl_get,
+       .put  = scarlett2_mux_src_enum_ctl_put,
+};
+
+static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_ports *ports = private->info->ports;
+       int port_type, channel, i;
+
+       for (i = 0, port_type = 0;
+            port_type < SCARLETT2_PORT_TYPE_COUNT;
+            port_type++) {
+               for (channel = 0;
+                    channel < ports[port_type].num[SCARLETT2_PORT_OUT];
+                    channel++, i++) {
+                       int err;
+                       char s[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
+                       const char *const descr = ports[port_type].dst_descr;
+
+                       snprintf(s, sizeof(s) - 5, descr, channel + 1);
+                       strcat(s, " Enum");
+
+                       err = scarlett2_add_new_ctl(mixer,
+                                                   &scarlett2_mux_src_enum_ctl,
+                                                   i, 1, s, NULL);
+                       if (err < 0)
+                               return err;
+               }
+       }
+
+       return 0;
+}
+
+/*** Meter Controls ***/
+
+static int scarlett2_meter_ctl_info(struct snd_kcontrol *kctl,
+                                   struct snd_ctl_elem_info *uinfo)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+
+       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
+       uinfo->count = elem->channels;
+       uinfo->value.integer.min = 0;
+       uinfo->value.integer.max = 4095;
+       uinfo->value.integer.step = 1;
+       return 0;
+}
+
+static int scarlett2_meter_ctl_get(struct snd_kcontrol *kctl,
+                                  struct snd_ctl_elem_value *ucontrol)
+{
+       struct usb_mixer_elem_info *elem = kctl->private_data;
+       u16 meter_levels[SCARLETT2_NUM_METERS];
+       int i, err;
+
+       err = scarlett2_usb_get_meter_levels(elem->head.mixer, meter_levels);
+       if (err < 0)
+               return err;
+
+       for (i = 0; i < elem->channels; i++)
+               ucontrol->value.integer.value[i] = meter_levels[i];
+
+       return 0;
+}
+
+static const struct snd_kcontrol_new scarlett2_meter_ctl = {
+       .iface = SNDRV_CTL_ELEM_IFACE_PCM,
+       .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
+       .name = "",
+       .info = scarlett2_meter_ctl_info,
+       .get  = scarlett2_meter_ctl_get
+};
+
+static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
+{
+       return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
+                                    0, SCARLETT2_NUM_METERS,
+                                    "Level Meter", NULL);
+}
+
+/*** Cleanup/Suspend Callbacks ***/
+
+static void scarlett2_private_free(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       cancel_delayed_work_sync(&private->work);
+       kfree(private);
+       mixer->private_data = NULL;
+}
+
+static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+
+       if (cancel_delayed_work_sync(&private->work))
+               scarlett2_config_save(private->mixer);
+}
+
+/*** Initialisation ***/
+
+static int scarlett2_count_mux_srcs(const struct scarlett2_ports *ports)
+{
+       int port_type, count = 0;
+
+       for (port_type = 0;
+            port_type < SCARLETT2_PORT_TYPE_COUNT;
+            port_type++)
+               count += ports[port_type].num[SCARLETT2_PORT_IN];
+
+       return count;
+}
+
+/* Default routing connects PCM outputs and inputs to Analogue,
+ * S/PDIF, then ADAT
+ */
+static void scarlett2_init_routing(u8 *mux,
+                                  const struct scarlett2_ports *ports)
+{
+       int i, input_num, input_count, port_type;
+       int output_num, output_count, port_type_connect_num;
+
+       static const int connect_order[] = {
+               SCARLETT2_PORT_TYPE_ANALOGUE,
+               SCARLETT2_PORT_TYPE_SPDIF,
+               SCARLETT2_PORT_TYPE_ADAT,
+               -1
+       };
+
+       /* Assign PCM inputs (routing outputs) */
+       output_num = scarlett2_get_port_start_num(ports,
+                                                 SCARLETT2_PORT_OUT,
+                                                 SCARLETT2_PORT_TYPE_PCM);
+       output_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_OUT];
+
+       for (port_type = connect_order[port_type_connect_num = 0];
+            port_type >= 0;
+            port_type = connect_order[++port_type_connect_num]) {
+               input_num = scarlett2_get_port_start_num(
+                       ports, SCARLETT2_PORT_IN, port_type);
+               input_count = ports[port_type].num[SCARLETT2_PORT_IN];
+               for (i = 0;
+                    i < input_count && output_count;
+                    i++, output_count--)
+                       mux[output_num++] = input_num++;
+       }
+
+       /* Assign PCM outputs (routing inputs) */
+       input_num = scarlett2_get_port_start_num(ports,
+                                                SCARLETT2_PORT_IN,
+                                                SCARLETT2_PORT_TYPE_PCM);
+       input_count = ports[SCARLETT2_PORT_TYPE_PCM].num[SCARLETT2_PORT_IN];
+
+       for (port_type = connect_order[port_type_connect_num = 0];
+            port_type >= 0;
+            port_type = connect_order[++port_type_connect_num]) {
+               output_num = scarlett2_get_port_start_num(
+                       ports, SCARLETT2_PORT_OUT, port_type);
+               output_count = ports[port_type].num[SCARLETT2_PORT_OUT];
+               for (i = 0;
+                    i < output_count && input_count;
+                    i++, input_count--)
+                       mux[output_num++] = input_num++;
+       }
+}
+
+/* Initialise private data, routing, sequence number */
+static int scarlett2_init_private(struct usb_mixer_interface *mixer,
+                                 const struct scarlett2_device_info *info)
+{
+       struct scarlett2_mixer_data *private =
+               kzalloc(sizeof(struct scarlett2_mixer_data), GFP_KERNEL);
+
+       if (!private)
+               return -ENOMEM;
+
+       mutex_init(&private->usb_mutex);
+       mutex_init(&private->data_mutex);
+       INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
+       private->info = info;
+       private->num_mux_srcs = scarlett2_count_mux_srcs(info->ports);
+       private->scarlett2_seq = 0;
+       private->mixer = mixer;
+       mixer->private_data = private;
+       mixer->private_free = scarlett2_private_free;
+       mixer->private_suspend = scarlett2_private_suspend;
+
+       /* Setup default routing */
+       scarlett2_init_routing(private->mux, info->ports);
+
+       /* Initialise the sequence number used for the proprietary commands */
+       return scarlett2_usb(mixer, SCARLETT2_USB_INIT_SEQ, NULL, 0, NULL, 0);
+}
+
+/* Read line-in config and line-out volume settings on start */
+static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_device_info *info = private->info;
+       const struct scarlett2_ports *ports = info->ports;
+       int num_line_out =
+               ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+       u8 level_switches[SCARLETT2_LEVEL_SWITCH_MAX];
+       u8 pad_switches[SCARLETT2_PAD_SWITCH_MAX];
+       struct scarlett2_usb_volume_status volume_status;
+       int err, i;
+
+       if (info->level_input_count) {
+               err = scarlett2_usb_get_config(
+                       mixer,
+                       SCARLETT2_CONFIG_LEVEL_SWITCH,
+                       info->level_input_count,
+                       level_switches);
+               if (err < 0)
+                       return err;
+               for (i = 0; i < info->level_input_count; i++)
+                       private->level_switch[i] = level_switches[i];
+       }
+
+       if (info->pad_input_count) {
+               err = scarlett2_usb_get_config(
+                       mixer,
+                       SCARLETT2_CONFIG_PAD_SWITCH,
+                       info->pad_input_count,
+                       pad_switches);
+               if (err < 0)
+                       return err;
+               for (i = 0; i < info->pad_input_count; i++)
+                       private->pad_switch[i] = pad_switches[i];
+       }
+
+       err = scarlett2_usb_get_volume_status(mixer, &volume_status);
+       if (err < 0)
+               return err;
+
+       private->master_vol = clamp(
+               volume_status.master_vol + SCARLETT2_VOLUME_BIAS,
+               0, SCARLETT2_VOLUME_BIAS);
+
+       for (i = 0; i < num_line_out; i++) {
+               int volume;
+
+               private->vol_sw_hw_switch[i] =
+                       info->line_out_hw_vol
+                               && volume_status.sw_hw_switch[i];
+
+               volume = private->vol_sw_hw_switch[i]
+                          ? volume_status.master_vol
+                          : volume_status.sw_vol[i];
+               volume = clamp(volume + SCARLETT2_VOLUME_BIAS,
+                              0, SCARLETT2_VOLUME_BIAS);
+               private->vol[i] = volume;
+       }
+
+       for (i = 0; i < info->button_count; i++)
+               private->buttons[i] = !!volume_status.buttons[i];
+
+       return 0;
+}
+
+/* Notify on volume change */
+static void scarlett2_mixer_interrupt_vol_change(
+       struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       const struct scarlett2_ports *ports = private->info->ports;
+       int num_line_out =
+               ports[SCARLETT2_PORT_TYPE_ANALOGUE].num[SCARLETT2_PORT_OUT];
+       int i;
+
+       private->vol_updated = 1;
+
+       snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                      &private->master_vol_ctl->id);
+
+       for (i = 0; i < num_line_out; i++) {
+               if (!private->vol_sw_hw_switch[i])
+                       continue;
+               snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                              &private->vol_ctls[i]->id);
+       }
+}
+
+/* Notify on button change */
+static void scarlett2_mixer_interrupt_button_change(
+       struct usb_mixer_interface *mixer)
+{
+       struct scarlett2_mixer_data *private = mixer->private_data;
+       int i;
+
+       private->vol_updated = 1;
+
+       for (i = 0; i < private->info->button_count; i++)
+               snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
+                              &private->button_ctls[i]->id);
+}
+
+/* Interrupt callback */
+static void scarlett2_mixer_interrupt(struct urb *urb)
+{
+       struct usb_mixer_interface *mixer = urb->context;
+       int len = urb->actual_length;
+       int ustatus = urb->status;
+       u32 data;
+
+       if (ustatus != 0)
+               goto requeue;
+
+       if (len == 8) {
+               data = le32_to_cpu(*(u32 *)urb->transfer_buffer);
+               if (data & SCARLETT2_USB_INTERRUPT_VOL_CHANGE)
+                       scarlett2_mixer_interrupt_vol_change(mixer);
+               if (data & SCARLETT2_USB_INTERRUPT_BUTTON_CHANGE)
+                       scarlett2_mixer_interrupt_button_change(mixer);
+       } else {
+               usb_audio_err(mixer->chip,
+                             "scarlett mixer interrupt length %d\n", len);
+       }
+
+requeue:
+       if (ustatus != -ENOENT &&
+           ustatus != -ECONNRESET &&
+           ustatus != -ESHUTDOWN) {
+               urb->dev = mixer->chip->dev;
+               usb_submit_urb(urb, GFP_ATOMIC);
+       }
+}
+
+static int scarlett2_mixer_status_create(struct usb_mixer_interface *mixer)
+{
+       struct usb_device *dev = mixer->chip->dev;
+       unsigned int pipe = usb_rcvintpipe(dev,
+                                          SCARLETT2_USB_INTERRUPT_ENDPOINT);
+       void *transfer_buffer;
+
+       if (mixer->urb) {
+               usb_audio_err(mixer->chip,
+                             "%s: mixer urb already in use!\n", __func__);
+               return 0;
+       }
+
+       if (snd_usb_pipe_sanity_check(dev, pipe))
+               return -EINVAL;
+
+       mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
+       if (!mixer->urb)
+               return -ENOMEM;
+
+       transfer_buffer = kmalloc(SCARLETT2_USB_INTERRUPT_MAX_DATA, GFP_KERNEL);
+       if (!transfer_buffer)
+               return -ENOMEM;
+
+       usb_fill_int_urb(mixer->urb, dev, pipe,
+                        transfer_buffer, SCARLETT2_USB_INTERRUPT_MAX_DATA,
+                        scarlett2_mixer_interrupt, mixer,
+                        SCARLETT2_USB_INTERRUPT_INTERVAL);
+
+       return usb_submit_urb(mixer->urb, GFP_KERNEL);
+}
+
+/* Entry point */
+int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer)
+{
+       const struct scarlett2_device_info *info;
+       int err;
+
+       /* only use UAC_VERSION_2 */
+       if (!mixer->protocol)
+               return 0;
+
+       switch (mixer->chip->usb_id) {
+       case USB_ID(0x1235, 0x8203):
+               info = &s6i6_gen2_info;
+               break;
+       case USB_ID(0x1235, 0x8204):
+               info = &s18i8_gen2_info;
+               break;
+       case USB_ID(0x1235, 0x8201):
+               info = &s18i20_gen2_info;
+               break;
+       default: /* device not (yet) supported */
+               return -EINVAL;
+       }
+
+       if (!(mixer->chip->setup & SCARLETT2_ENABLE)) {
+               usb_audio_err(mixer->chip,
+                       "Focusrite Scarlett Gen 2 Mixer Driver disabled; "
+                       "use options snd_usb_audio device_setup=1 "
+                       "to enable and report any issues to g@b4.vu");
+               return 0;
+       }
+
+       /* Initialise private data, routing, sequence number */
+       err = scarlett2_init_private(mixer, info);
+       if (err < 0)
+               return err;
+
+       /* Read volume levels and controls from the interface */
+       err = scarlett2_read_configs(mixer);
+       if (err < 0)
+               return err;
+
+       /* Create the analogue output controls */
+       err = scarlett2_add_line_out_ctls(mixer);
+       if (err < 0)
+               return err;
+
+       /* Create the analogue input controls */
+       err = scarlett2_add_line_in_ctls(mixer);
+       if (err < 0)
+               return err;
+
+       /* Create the input, output, and mixer mux input selections */
+       err = scarlett2_add_mux_enums(mixer);
+       if (err < 0)
+               return err;
+
+       /* Create the matrix mixer controls */
+       err = scarlett2_add_mixer_ctls(mixer);
+       if (err < 0)
+               return err;
+
+       /* Create the level meter controls */
+       err = scarlett2_add_meter_ctl(mixer);
+       if (err < 0)
+               return err;
+
+       /* Set up the interrupt polling if there are hardware buttons */
+       if (info->button_count) {
+               err = scarlett2_mixer_status_create(mixer);
+               if (err < 0)
+                       return err;
+       }
+
+       return 0;
+}
diff --git a/sound/usb/mixer_scarlett_gen2.h b/sound/usb/mixer_scarlett_gen2.h
new file mode 100644 (file)
index 0000000..52e1dad
--- /dev/null
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __USB_MIXER_SCARLETT_GEN2_H
+#define __USB_MIXER_SCARLETT_GEN2_H
+
+int snd_scarlett_gen2_controls_create(struct usb_mixer_interface *mixer);
+
+#endif /* __USB_MIXER_SCARLETT_GEN2_H */