diff options
Diffstat (limited to 'sound/usb/mixer_scarlett_gen2.c')
| -rw-r--r-- | sound/usb/mixer_scarlett_gen2.c | 2075 |
1 files changed, 0 insertions, 2075 deletions
diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c deleted file mode 100644 index 74c00c905d24..000000000000 --- a/sound/usb/mixer_scarlett_gen2.c +++ /dev/null @@ -1,2075 +0,0 @@ -// 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; -} |