// 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 = { [SCARLETT2_PORT_TYPE_NONE] = { .id = 0x000, .num = { 1, 0, 8, 8, 8 }, .src_descr = "Off", .src_num_offset = 0, }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { .id = 0x080, .num = { 4, 4, 4, 4, 4 }, .src_descr = "Analogue %d", .src_num_offset = 1, .dst_descr = "Analogue Output %02d Playback" }, [SCARLETT2_PORT_TYPE_SPDIF] = { .id = 0x180, .num = { 2, 2, 2, 2, 2 }, .src_descr = "S/PDIF %d", .src_num_offset = 1, .dst_descr = "S/PDIF Output %d Playback" }, [SCARLETT2_PORT_TYPE_MIX] = { .id = 0x300, .num = { 10, 18, 18, 18, 18 }, .src_descr = "Mix %c", .src_num_offset = 65, .dst_descr = "Mixer Input %02d Capture" }, [SCARLETT2_PORT_TYPE_PCM] = { .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 = { [SCARLETT2_PORT_TYPE_NONE] = { .id = 0x000, .num = { 1, 0, 8, 8, 4 }, .src_descr = "Off", .src_num_offset = 0, }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { .id = 0x080, .num = { 8, 6, 6, 6, 6 }, .src_descr = "Analogue %d", .src_num_offset = 1, .dst_descr = "Analogue Output %02d Playback" }, [SCARLETT2_PORT_TYPE_SPDIF] = { .id = 0x180, /* S/PDIF outputs aren't available at 192KHz * but are included in the USB mux I/O * assignment message anyway */ .num = { 2, 2, 2, 2, 2 }, .src_descr = "S/PDIF %d", .src_num_offset = 1, .dst_descr = "S/PDIF Output %d Playback" }, [SCARLETT2_PORT_TYPE_ADAT] = { .id = 0x200, .num = { 8, 0, 0, 0, 0 }, .src_descr = "ADAT %d", .src_num_offset = 1, }, [SCARLETT2_PORT_TYPE_MIX] = { .id = 0x300, .num = { 10, 18, 18, 18, 18 }, .src_descr = "Mix %c", .src_num_offset = 65, .dst_descr = "Mixer Input %02d Capture" }, [SCARLETT2_PORT_TYPE_PCM] = { .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 = { [SCARLETT2_PORT_TYPE_NONE] = { .id = 0x000, .num = { 1, 0, 8, 8, 6 }, .src_descr = "Off", .src_num_offset = 0, }, [SCARLETT2_PORT_TYPE_ANALOGUE] = { .id = 0x080, .num = { 8, 10, 10, 10, 10 }, .src_descr = "Analogue %d", .src_num_offset = 1, .dst_descr = "Analogue Output %02d Playback" }, [SCARLETT2_PORT_TYPE_SPDIF] = { /* 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" }, [SCARLETT2_PORT_TYPE_ADAT] = { .id = 0x200, .num = { 8, 8, 8, 4, 0 }, .src_descr = "ADAT %d", .src_num_offset = 1, .dst_descr = "ADAT Output %d Playback" }, [SCARLETT2_PORT_TYPE_MIX] = { .id = 0x300, .num = { 10, 18, 18, 18, 18 }, .src_descr = "Mix %c", .src_num_offset = 65, .dst_descr = "Mixer Input %02d Capture" }, [SCARLETT2_PORT_TYPE_PCM] = { .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 { __le32 cmd; __le16 size; __le16 seq; __le32 error; __le32 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", le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd), le16_to_cpu(req->seq), le16_to_cpu(resp->seq), resp_size, le16_to_cpu(resp->size), le32_to_cpu(resp->error), le32_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) { __le32 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 { __le32 offset; __le32 bytes; __le32 value; } __packed req; __le32 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 { __le32 offset; __le32 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 { __le16 mix_num; __le16 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 { __le16 pad; __le16 num; __le32 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 { __le16 pad; __le16 num_meters; __le32 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; }