Lines Matching +full:activate +full:- +full:to +full:- +full:activate
1 // SPDX-License-Identifier: GPL-2.0
8 * - 6i6/18i8/18i20 Gen 2
9 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
10 * - Solo/2i2/4i4 Gen 4
11 * - Clarett 2Pre/4Pre/8Pre USB
12 * - Clarett+ 2Pre/4Pre/8Pre
13 * - Vocaster One/Two
15 * Copyright (c) 2018-2025 by Geoffrey D. Bennett <g at b4.vu>
16 * Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
36 * (firmware 1083) using usbmon in July-August 2018.
40 * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
43 * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
44 * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
47 * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
52 * interface during driver initialisation added in May 2021 (thanks to
55 * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
59 * and talkback added in May-June 2021.
64 * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe
67 * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to
76 * to many LinuxMusicians people and to Focusrite for hardware
79 * Support for Vocaster One and Two added in Mar 2024 (thanks to many
80 * LinuxMusicians people and to Focusrite for hardware donations).
82 * This ALSA mixer gives access to (model-dependent):
83 * - input, output, mixer-matrix muxes
84 * - mixer-matrix gain stages
85 * - gain/volume/mute controls
86 * - level meters
87 * - line/inst level, pad, and air controls
88 * - phantom power, direct monitor, speaker switching, and talkback
90 * - disable/enable MSD mode
91 * - disable/enable standalone mode
92 * - input mute, gain, autogain, safe mode
93 * - direct monitor mixes
94 * - compressor and EQ
95 * - Bluetooth volume
98 * /--------------\ 18chn 20chn /--------------\
99 * | Hardware in +--+------\ /-------------+--+ ALSA PCM out |
100 * \--------------/ | | | | \--------------/
101 * | | | /-----\ |
104 * | +---------------+ | |
106 * | +-----+-----+ | |
112 * | +------------+ | |
118 * | +-----+------+ | |
122 * | +----------/ |
126 * +---------------+ +--—------------+
128 * +---+---+---+ +-----+-----+
132 * /--------------\ | | | /--------------\
133 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in |
134 * | Hardware out | | \--------------/
135 * \--------------/ |
137 * +-------------+ Software gain per channel.
138 * | Master Gain |<-- 18i20 only: Switch per channel
139 * +------+------+ to select HW or SW gain control.
142 * /--------------\ |
143 * | Analogue |<------/
145 * \--------------/
150 * to the host. To access the full functionality of the device without
152 * - holding down the 48V button for five seconds while powering on
154 * - using this driver and alsamixer to change the "MSD Mode" setting
155 * to Off and power-cycling the device
175 /* device_setup value to allow turning MSD mode back on */
178 /* device_setup value to disable this mixer driver */
181 /* device_setup value to use the FCP driver instead */
188 * (the corresponding value in dB is per-device)
195 /* mixer range from -80dB to +12dB in 0.5dB steps */
196 #define SCARLETT2_MIXER_MIN_DB -80
197 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
200 ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
203 /* map from (dB + 80) * 2 to mixer value
204 * for dB in 0 .. 184: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
236 /* Maximum number of inputs to the mixer */
265 * The compressor parameters are 32-bit fixed point values with 24
278 * - Enable: Off, On
279 * - Threshold: -40dB to 0dB
280 * - Ratio: 1:1 to 50:1 in 0.5:1 steps
281 * - Knee Width: 0dB to 10dB
282 * - Attack: 30ms to 127ms
283 * - Release: 30ms to 127ms
284 * - Makeup Gain: 0dB to 24dB
288 { "Threshold", SNDRV_CTL_ELEM_TYPE_INTEGER, -40, 0, 24 },
317 * - None (no input to mux)
318 * - Analogue I/O
319 * - S/PDIF I/O
320 * - ADAT I/O
321 * - Mixer I/O
322 * - PCM I/O
350 #define SCARLETT2_AG_TARGET_MIN (-30)
389 * If autogain_switch is set, autogain_status is set to 0 (Running).
588 * Vocaster and 4th Gen devices have a parameter buffer to set certain
589 * configuration parameters. When pbuf is set, rather than writing to
590 * the given offset, the channel and value are written to the
591 * parameter buffer and the activate command is sent to the device.
595 * mute set to 1. 0x02 and 0x03 are temporary values while the device
602 u8 activate;
631 .offset = 0x34, .size = 16, .activate = 1 },
634 .offset = 0x5c, .size = 8, .activate = 1 },
637 .offset = 0x7c, .size = 8, .activate = 7 },
640 .offset = 0x84, .size = 8, .activate = 8 },
643 .offset = 0x8d, .size = 8, .activate = 6 },
653 .offset = 0x31, .size = 8, .activate = 2 },
656 .offset = 0x34, .size = 16, .activate = 1 },
659 .offset = 0x5c, .size = 8, .activate = 1 },
662 .offset = 0x66, .size = 8, .activate = 3 },
668 .offset = 0x7c, .size = 8, .activate = 7 },
671 .offset = 0x84, .size = 8, .activate = 8 },
674 .offset = 0x8d, .size = 8, .activate = 6 },
683 .offset = 0x04, .size = 8, .activate = 6 },
686 .offset = 0x05, .size = 8, .activate = 6 },
689 .offset = 0x06, .size = 8, .activate = 3 },
692 .offset = 0x07, .size = 8, .activate = 4 },
695 .offset = 0x08, .size = 1, .activate = 7 },
698 .offset = 0x09, .size = 1, .activate = 8 },
707 .offset = 0x34, .size = 16, .activate = 1 },
710 .offset = 0x5c, .size = 8, .activate = 1 },
713 .offset = 0x7c, .size = 8, .activate = 7 },
716 .offset = 0x84, .size = 8, .activate = 8 },
719 .offset = 0x8c, .size = 8, .activate = 8 },
722 .offset = 0x95, .size = 8, .activate = 6 },
725 .offset = 0x9c, .size = 1, .activate = 8 },
728 .offset = 0x9d, .size = 8, .activate = 6 },
731 .offset = 0x9e, .size = 8, .activate = 6 },
740 .offset = 0x31, .size = 8, .activate = 2 },
743 .offset = 0x34, .size = 16, .activate = 1 },
746 .offset = 0x5c, .size = 8, .activate = 1 },
749 .offset = 0x66, .size = 8, .activate = 3 },
755 .offset = 0x7c, .size = 8, .activate = 7 },
758 .offset = 0x84, .size = 8, .activate = 8 },
761 .offset = 0x8c, .size = 8, .activate = 8 },
764 .offset = 0x95, .size = 8, .activate = 6 },
767 .offset = 0x9c, .size = 1, .activate = 8 },
770 .offset = 0x9d, .size = 8, .activate = 6 },
773 .offset = 0x9e, .size = 8, .activate = 6 },
776 .offset = 0x9f, .size = 1, .activate = 10 },
779 .offset = 0xa0, .size = 1, .activate = 10 },
782 .offset = 0xb0, .size = 16, .activate = 10 },
785 .offset = 0x94, .size = 8, .activate = 6 },
797 .offset = 0x9d, .size = 8, .activate = 6 },
800 .offset = 0x1c0, .size = 8, .activate = 19, .pbuf = 1 },
806 .offset = 0xc1, .size = 8, .activate = 29, .pbuf = 1 },
809 .offset = 0x9f, .size = 8, .activate = 21, .pbuf = 1 },
812 .offset = 0x9c, .size = 1, .activate = 20, .pbuf = 1 },
815 .offset = 0x1c4, .size = 8, .activate = 22, .pbuf = 1 },
818 .offset = 0x1c8, .size = 32, .activate = 23 },
821 .offset = 0x7c, .size = 32, .activate = 27 },
824 .offset = 0x200, .size = 32, .activate = 27 },
827 .offset = 0x84, .size = 32, .activate = 27 },
830 .offset = 0x250, .size = 32, .activate = 27 },
833 .offset = 0x1be, .size = 8, .activate = 17, .pbuf = 1 },
836 .offset = 0xbf, .size = 8, .activate = 28 },
839 .offset = 0xab, .size = 8, .activate = 10 },
849 .offset = 0x47, .size = 8, .activate = 4 },
852 .offset = 0x108, .size = 8, .activate = 12, .pbuf = 1 },
855 .offset = 0x46, .size = 8, .activate = 9, .pbuf = 1,
859 .offset = 0x3d, .size = 8, .activate = 10, .pbuf = 1,
863 .offset = 0x3e, .size = 8, .activate = 11, .pbuf = 1 },
866 .offset = 0x206, .size = 8, .activate = 25, .pbuf = 1 },
869 .offset = 0x232, .size = 16, .activate = 26 }
881 .offset = 0x49, .size = 8, .activate = 4 },
884 .offset = 0x14a, .size = 8, .activate = 16, .pbuf = 1 },
887 .offset = 0x135, .size = 8, .activate = 10, .pbuf = 1 },
893 .offset = 0x131, .size = 8, .activate = 29, .pbuf = 1 },
896 .offset = 0x132, .size = 8, .activate = 30, .pbuf = 1 },
899 .offset = 0x48, .size = 8, .activate = 11, .pbuf = 1,
903 .offset = 0x4b, .size = 8, .activate = 12, .pbuf = 1 },
906 .offset = 0x3c, .size = 8, .activate = 13, .pbuf = 1,
910 .offset = 0x147, .size = 8, .activate = 14, .pbuf = 1 },
913 .offset = 0x3e, .size = 8, .activate = 15, .pbuf = 1 },
916 .offset = 0x14b, .size = 8, .activate = 17, .pbuf = 1 },
919 .offset = 0x14e, .size = 8, .activate = 18, .pbuf = 1 },
922 .offset = 0x2a0, .size = 16, .activate = 36 }
934 .offset = 0x5c, .size = 8, .activate = 4 },
937 .offset = 0x13e, .size = 8, .activate = 10, .pbuf = 1 },
943 .offset = 0x13a, .size = 8, .activate = 23, .pbuf = 1 },
946 .offset = 0x13b, .size = 8, .activate = 24, .pbuf = 1 },
949 .offset = 0x5a, .size = 8, .activate = 11, .pbuf = 1,
953 .offset = 0x5e, .size = 8, .activate = 12, .pbuf = 1 },
956 .offset = 0x4e, .size = 8, .activate = 13, .pbuf = 1,
960 .offset = 0x150, .size = 8, .activate = 14, .pbuf = 1 },
963 .offset = 0x50, .size = 8, .activate = 15, .pbuf = 1 },
966 .offset = 0x153, .size = 8, .activate = 16, .pbuf = 1 },
969 .offset = 0x156, .size = 8, .activate = 17, .pbuf = 1 },
990 .offset = 0x31, .size = 8, .activate = 2 },
993 .offset = 0x34, .size = 16, .activate = 1 },
996 .offset = 0x5c, .size = 8, .activate = 1 },
999 .offset = 0x66, .size = 8, .activate = 3 },
1005 .offset = 0x7c, .size = 8, .activate = 7 },
1008 .offset = 0x95, .size = 8, .activate = 8 },
1011 .offset = 0x8d, .size = 8, .activate = 6 },
1014 .offset = 0x9e, .size = 8, .activate = 4 },
1019 * - id: hardware ID of this port type
1020 * - src_descr: printf format string for mux input selections
1021 * - src_num_offset: added to channel number for the fprintf
1022 * - dst_descr: printf format string for mixer controls
1081 * ports to add to the set_mux message. The end of the list is marked
1094 * that consecutive meter entries are mapped to. The end of the list
1119 * level control that can be set to line or instrument
1123 /* the first input with a level control (0-based) */
1136 /* the first input with an air control (0-based) */
1148 /* number of pre-compressor filters */
1165 /* the first input with phantom power control (0-based) */
1171 /* the number of inputs with software-controllable gain */
1194 * internally to the analogue 7/8 outputs
1214 * SCARLETT2_USB_GET_METER to index into mux[] entries (same
1224 struct mutex data_mutex; /* lock access to this data */
1345 /*** Model-specific data ***/
2323 /* Gen 4 device firmware provides access to a base64-encoded
2324 * zlib-compressed JSON description of the device's capabilities and
2326 * /proc/asound/cardX/device-map.json.zz.b64
2329 #define SCARLETT2_DEVMAP_FILENAME "device-map.json.zz.b64"
2346 u16 seq = private->scarlett2_seq++;
2348 req->cmd = cpu_to_le32(cmd);
2349 req->size = cpu_to_le16(req_size);
2350 req->seq = cpu_to_le16(seq);
2351 req->error = 0;
2352 req->pad = 0;
2373 /* Send a proprietary format request to the Scarlett interface */
2378 struct scarlett2_data *private = mixer->private_data;
2379 struct usb_device *dev = mixer->chip->dev;
2390 return -ENOMEM;
2394 return -ENOMEM;
2396 guard(mutex)(&private->usb_mutex);
2403 memcpy(req->data, req_data, req_size);
2406 err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
2410 if (err == -EPROTO && ++retries <= max_retries) {
2411 msleep(5 * (1 << (retries - 1)));
2415 mixer->chip,
2417 private->series_name, cmd, err);
2418 return -EINVAL;
2421 if (!wait_for_completion_timeout(&private->cmd_done,
2424 mixer->chip,
2426 private->series_name, cmd);
2428 return -ETIMEDOUT;
2431 /* send a second message to get the response */
2433 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
2441 /* ESHUTDOWN and EPROTO are valid responses to a
2445 (err == -ESHUTDOWN || err == -EPROTO))
2449 mixer->chip,
2451 private->series_name, cmd, err, resp_buf_size);
2452 return -EINVAL;
2458 if (resp->cmd != req->cmd ||
2459 (resp->seq != req->seq &&
2460 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
2461 resp_size != le16_to_cpu(resp->size) ||
2462 resp->error ||
2463 resp->pad) {
2465 mixer->chip,
2469 private->series_name,
2470 le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
2471 le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
2472 resp_size, le16_to_cpu(resp->size),
2473 le32_to_cpu(resp->error),
2474 le32_to_cpu(resp->pad));
2475 return -EINVAL;
2479 memcpy(resp_data, resp->data, resp_size);
2484 /* Send a USB message to get data; result placed in *buf */
2506 return !!private->config_set->items[config_item_num].offset;
2509 /* Send a USB message to get configuration parameters; result placed in *buf */
2514 struct scarlett2_data *private = mixer->private_data;
2516 &private->config_set->items[config_item_num];
2524 if (!config_item->offset)
2525 return -EFAULT;
2527 /* Writes to the parameter buffer are always 1 byte */
2528 size = config_item->size ? config_item->size : 8;
2530 /* For byte-sized parameters, retrieve directly into buf */
2533 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
2550 /* For bit-sized parameters, retrieve into value */
2551 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
2571 struct scarlett2_data *private = mixer->private_data;
2581 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2594 struct scarlett2_data *private = mixer->private_data;
2606 return -ENOMEM;
2608 req->offset = cpu_to_le32(offset);
2609 req->size = cpu_to_le32(bytes);
2611 memcpy(req->data, buf, count);
2617 ((__le16 *)req->data)[i] = cpu_to_le16(buf_16[i]);
2623 ((__le32 *)req->data)[i] = cpu_to_le32(buf_32[i]);
2626 err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2636 * The value for activate needed is determined by the configuration
2640 struct usb_mixer_interface *mixer, int activate)
2644 req = cpu_to_le32(activate);
2649 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter */
2654 struct scarlett2_data *private = mixer->private_data;
2655 const struct scarlett2_config_set *config_set = private->config_set;
2657 &config_set->items[config_item_num];
2664 if (!config_item->offset)
2665 return -EFAULT;
2668 if (config_item->pbuf) {
2669 if (!config_set->param_buf_addr)
2670 return -EFAULT;
2674 mixer, config_set->param_buf_addr + 1, 1, index);
2680 mixer, config_set->param_buf_addr, 1, value);
2684 /* Activate the write through the parameter buffer */
2686 mixer, config_item->activate);
2690 * save and support bit-modification
2694 cancel_delayed_work_sync(&private->work);
2696 /* Convert config_item->size in bits to size in bytes and
2699 if (config_item->size >= 8) {
2700 size = config_item->size / 8;
2701 offset = config_item->offset + index * size;
2710 offset = config_item->offset;
2729 /* Activate the change */
2730 err = scarlett2_usb_activate_config(mixer, config_item->activate);
2737 if (config_set->param_buf_addr)
2740 /* Schedule the change to be written to NVRAM */
2741 if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
2742 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
2747 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter with
2754 struct scarlett2_data *private = mixer->private_data;
2755 const struct scarlett2_config_set *config_set = private->config_set;
2757 &config_set->items[config_item_num];
2764 if (!config_item->offset)
2765 return -EFAULT;
2767 /* Convert config_item->size in bits to size in bytes and
2770 if (config_item->size >= 8) {
2771 size = config_item->size / 8;
2772 offset = config_item->offset + index * size;
2776 return -EFAULT;
2784 /* Activate the change */
2785 return scarlett2_usb_activate_config(mixer, config_item->activate);
2795 usb_audio_err(mixer->chip, "config save failed: %d\n", err);
2798 /* Delayed work to save config */
2804 scarlett2_config_save(private->mixer);
2807 /* Send a USB message to get sync status; result placed in *sync */
2827 return !!private->info->mux_assignment[0][0].count;
2830 /* Map from mixer value to (db + 80) * 2
2843 /* Send a USB message to get the volumes for all inputs of one mix
2844 * and put the values into private->mix[]
2849 struct scarlett2_data *private = mixer->private_data;
2851 int num_mixer_in = private->num_mix_in;
2871 private->mix[j] = scarlett2_mixer_value_to_db(
2877 /* Send a USB message to set the volumes for all inputs of one mix
2878 * (values obtained from private->mix[])
2883 struct scarlett2_data *private = mixer->private_data;
2891 int num_mixer_in = private->num_mix_in;
2897 scarlett2_mixer_values[private->mix[j]]
2905 /* Convert a port number index (per info->port_count) to a hardware ID */
2916 num -= port_count[port_type][SCARLETT2_PORT_IN];
2923 /* Convert a hardware ID to a port number index */
2937 return port_num + id - base;
2942 return -1;
2945 /* Convert one mux entry from the interface and load into private->mux[] */
2949 const struct scarlett2_device_info *info = private->info;
2950 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2959 if (dst_idx >= private->num_mux_dsts) {
2960 usb_audio_err(private->mixer->chip,
2962 mux_entry, dst_idx, private->num_mux_dsts);
2971 if (src_idx >= private->num_mux_srcs) {
2972 usb_audio_err(private->mixer->chip,
2974 mux_entry, src_idx, private->num_mux_srcs);
2978 private->mux[dst_idx] = src_idx;
2984 * request) is returned in mux_assignment order, but to avoid exposing
2985 * that to userspace, scarlett2_meter_ctl_get() rearranges the data
2992 * - the source is "Off"; therefore we set those values to zero (map
2995 * - the source is assigned to a previous (with respect to the
2997 * to the value previously reported for that source
3001 const struct scarlett2_device_info *info = private->info;
3004 /* sources already assigned to a destination
3016 for (entry = info->meter_map;
3017 entry->count;
3023 for (j = 0, mux_idx = entry->start;
3024 j < entry->count;
3029 info->line_out_remap_enable &&
3030 mux_idx < private->num_line_out
3031 ) ? info->line_out_unmap[mux_idx]
3039 int mux_src = private->mux[mux_idx];
3045 private->meter_level_map[map_mux_idx] =
3051 /* Send USB message to get mux inputs and then populate private->mux[] */
3054 struct scarlett2_data *private = mixer->private_data;
3055 int count = private->num_mux_dsts;
3065 private->mux_updated = 0;
3084 /* Send USB messages to set mux inputs */
3087 struct scarlett2_data *private = mixer->private_data;
3088 const struct scarlett2_device_info *info = private->info;
3089 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3110 for (entry = info->mux_assignment[table];
3111 entry->count;
3114 int port_type = entry->port_type;
3115 int port_idx = entry->start;
3122 for (j = 0; j < entry->count; j++)
3127 /* Non-empty mux slots use the lower 12 bits
3131 for (j = 0; j < entry->count; j++) {
3133 port_count, private->mux[mux_idx++]);
3152 /* Send USB message to get meter levels */
3172 /* copy, convert to u16 */
3179 /* For config items with mute=1, xor bits 0 & 1 together to get the
3190 /* helper function to create a new control */
3202 return -ENOMEM;
3206 * Also, the head.id field is set to 0, as we don't use this field.
3208 elem->head.mixer = mixer;
3209 elem->control = index;
3210 elem->head.id = 0;
3211 elem->channels = channels;
3212 elem->val_type = USB_MIXER_BESPOKEN;
3217 return -ENOMEM;
3219 kctl->private_free = snd_usb_mixer_elem_free;
3221 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
3223 err = snd_usb_mixer_add_control(&elem->head, kctl);
3239 struct usb_mixer_elem_info *elem = kctl->private_data;
3240 struct scarlett2_data *private = elem->head.mixer->private_data;
3242 ucontrol->value.integer.value[0] = private->firmware_version;
3251 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3252 uinfo->count = 1;
3278 struct usb_mixer_elem_info *elem = kctl->private_data;
3279 struct scarlett2_data *private = elem->head.mixer->private_data;
3281 ucontrol->value.integer.value[0] = private->info->min_firmware_version;
3290 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3291 uinfo->count = 1;
3318 struct scarlett2_data *private = mixer->private_data;
3320 private->sync_updated = 0;
3321 return scarlett2_usb_get_sync_status(mixer, &private->sync);
3336 struct usb_mixer_elem_info *elem = kctl->private_data;
3337 struct usb_mixer_interface *mixer = elem->head.mixer;
3338 struct scarlett2_data *private = mixer->private_data;
3341 guard(mutex)(&private->data_mutex);
3343 if (private->hwdep_in_use)
3344 return -EBUSY;
3346 if (private->sync_updated) {
3351 ucontrol->value.enumerated.item[0] = private->sync;
3365 struct scarlett2_data *private = mixer->private_data;
3372 0, 1, "Sync Status", &private->sync_ctl);
3381 /* Set the access mode of a control to read-only (val = 0) or
3382 * read-write (val = 1).
3387 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
3389 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;
3398 for (i = 0; i < private->info->gain_input_count; i++)
3399 if (!private->autogain_status[i])
3407 struct scarlett2_data *private = mixer->private_data;
3408 const struct scarlett2_device_info *info = private->info;
3413 private->autogain_updated = 0;
3415 if (!info->gain_input_count)
3420 info->gain_input_count, private->autogain_switch);
3425 info->gain_input_count, raw_autogain_status);
3434 * subsequent elements correspond to the status value from the
3439 for (i = 0; i < info->gain_input_count; i++)
3440 if (private->autogain_switch[i])
3441 private->autogain_status[i] = 0;
3443 private->num_autogain_status_texts - 1)
3444 private->autogain_status[i] =
3447 private->autogain_status[i] =
3448 private->num_autogain_status_texts - 1;
3463 private->ag_targets[i] = -ag_target_values[i];
3471 struct scarlett2_data *private = mixer->private_data;
3472 const struct scarlett2_device_info *info = private->info;
3478 scarlett2_set_ctl_access(private->input_select_ctl, val);
3481 for (i = 0; i < info->gain_input_count; i++)
3482 scarlett2_set_ctl_access(private->input_link_ctls[i],
3484 for (i = 0; i < info->gain_input_count; i++)
3485 scarlett2_set_ctl_access(private->input_gain_ctls[i], val);
3486 for (i = 0; i < info->safe_input_count; i++)
3487 scarlett2_set_ctl_access(private->safe_ctls[i], val);
3488 for (i = 0; i < info->level_input_count; i++)
3489 scarlett2_set_ctl_access(private->level_ctls[i], val);
3490 for (i = 0; i < info->air_input_count; i++)
3491 scarlett2_set_ctl_access(private->air_ctls[i], val);
3492 for (i = 0; i < info->mute_input_count; i++)
3493 scarlett2_set_ctl_access(private->input_mute_ctls[i], val);
3494 for (i = 0; i < info->phantom_count; i++)
3495 scarlett2_set_ctl_access(private->phantom_ctls[i], val);
3496 for (i = 0; i < info->dsp_input_count; i++)
3497 scarlett2_set_ctl_access(private->dsp_ctls[i], val);
3503 private->ag_target_ctls[i], val);
3506 /* Notify of access mode change for all controls read-only while
3511 struct snd_card *card = mixer->chip->card;
3512 struct scarlett2_data *private = mixer->private_data;
3513 const struct scarlett2_device_info *info = private->info;
3519 &private->input_select_ctl->id);
3522 for (i = 0; i < info->gain_input_count; i++)
3524 &private->input_link_ctls[i]->id);
3525 for (i = 0; i < info->gain_input_count; i++)
3527 &private->input_gain_ctls[i]->id);
3528 for (i = 0; i < info->safe_input_count; i++)
3530 &private->safe_ctls[i]->id);
3531 for (i = 0; i < info->level_input_count; i++)
3533 &private->level_ctls[i]->id);
3534 for (i = 0; i < info->air_input_count; i++)
3536 &private->air_ctls[i]->id);
3537 for (i = 0; i < info->dsp_input_count; i++)
3539 &private->dsp_ctls[i]->id);
3540 for (i = 0; i < info->mute_input_count; i++)
3542 &private->input_mute_ctls[i]->id);
3543 for (i = 0; i < info->phantom_count; i++)
3545 &private->phantom_ctls[i]->id);
3551 &private->ag_target_ctls[i]->id);
3560 struct scarlett2_data *private = mixer->private_data;
3563 if (!private->autogain_updated)
3576 * control that is meant to be read-only while autogain is running,
3578 * Return -EPERM if autogain is running.
3588 if (scarlett2_autogain_is_running(mixer->private_data))
3589 return -EPERM;
3597 struct usb_mixer_elem_info *elem = kctl->private_data;
3598 struct usb_mixer_interface *mixer = elem->head.mixer;
3599 struct scarlett2_data *private = mixer->private_data;
3602 guard(mutex)(&private->data_mutex);
3614 struct usb_mixer_elem_info *elem = kctl->private_data;
3615 struct usb_mixer_interface *mixer = elem->head.mixer;
3616 struct scarlett2_data *private = mixer->private_data;
3619 guard(mutex)(&private->data_mutex);
3621 if (private->hwdep_in_use)
3622 return -EBUSY;
3628 ucontrol->value.enumerated.item[0] =
3629 private->autogain_switch[elem->control];
3636 struct usb_mixer_elem_info *elem = kctl->private_data;
3637 struct usb_mixer_interface *mixer = elem->head.mixer;
3638 struct scarlett2_data *private = mixer->private_data;
3641 guard(mutex)(&private->data_mutex);
3643 if (private->hwdep_in_use)
3644 return -EBUSY;
3650 ucontrol->value.enumerated.item[0] =
3651 private->autogain_status[elem->control];
3658 struct usb_mixer_elem_info *elem = kctl->private_data;
3659 struct usb_mixer_interface *mixer = elem->head.mixer;
3660 struct scarlett2_data *private = mixer->private_data;
3661 int index = elem->control;
3664 guard(mutex)(&private->data_mutex);
3666 if (private->hwdep_in_use)
3667 return -EBUSY;
3674 return -EPERM;
3676 oval = private->autogain_switch[index];
3677 val = !!ucontrol->value.integer.value[0];
3682 private->autogain_switch[index] = val;
3684 /* Send switch change to the device */
3697 struct usb_mixer_elem_info *elem = kctl->private_data;
3698 struct scarlett2_data *private = elem->head.mixer->private_data;
3702 private->num_autogain_status_texts,
3703 private->config_set->autogain_status_texts);
3727 struct usb_mixer_elem_info *elem = kctl->private_data;
3728 struct usb_mixer_interface *mixer = elem->head.mixer;
3729 struct scarlett2_data *private = mixer->private_data;
3732 guard(mutex)(&private->data_mutex);
3734 if (private->hwdep_in_use)
3735 return -EBUSY;
3741 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3742 uinfo->count = 1;
3743 uinfo->value.integer.min = SCARLETT2_AG_TARGET_MIN;
3744 uinfo->value.integer.max = 0;
3745 uinfo->value.integer.step = 1;
3753 struct usb_mixer_elem_info *elem = kctl->private_data;
3754 struct usb_mixer_interface *mixer = elem->head.mixer;
3755 struct scarlett2_data *private = mixer->private_data;
3758 guard(mutex)(&private->data_mutex);
3760 if (private->hwdep_in_use)
3761 return -EBUSY;
3763 if (private->autogain_updated) {
3769 ucontrol->value.integer.value[0] = private->ag_targets[elem->control];
3776 struct usb_mixer_elem_info *elem = kctl->private_data;
3777 struct usb_mixer_interface *mixer = elem->head.mixer;
3778 struct scarlett2_data *private = mixer->private_data;
3779 int index = elem->control;
3782 guard(mutex)(&private->data_mutex);
3784 if (private->hwdep_in_use)
3785 return -EBUSY;
3791 oval = private->ag_targets[index];
3792 val = clamp(ucontrol->value.integer.value[0],
3798 private->ag_targets[index] = val;
3800 /* Send new value to the device */
3802 mixer, scarlett2_ag_target_configs[index], 1, -val);
3826 struct scarlett2_data *private = mixer->private_data;
3827 const struct scarlett2_device_info *info = private->info;
3828 int link_count = info->gain_input_count;
3831 private->input_select_updated = 0;
3840 1, &private->input_select_switch);
3846 link_count, private->input_link_switch);
3856 struct usb_mixer_elem_info *elem = kctl->private_data;
3857 struct usb_mixer_interface *mixer = elem->head.mixer;
3858 struct scarlett2_data *private = mixer->private_data;
3861 guard(mutex)(&private->data_mutex);
3863 if (private->hwdep_in_use)
3864 return -EBUSY;
3866 if (private->input_select_updated) {
3871 ucontrol->value.enumerated.item[0] = private->input_select_switch;
3878 struct usb_mixer_elem_info *elem = kctl->private_data;
3879 struct usb_mixer_interface *mixer = elem->head.mixer;
3880 struct scarlett2_data *private = mixer->private_data;
3881 const struct scarlett2_device_info *info = private->info;
3884 guard(mutex)(&private->data_mutex);
3886 if (private->hwdep_in_use)
3887 return -EBUSY;
3893 oval = private->input_select_switch;
3894 val = ucontrol->value.integer.value[0];
3898 else if (val >= info->gain_input_count)
3899 val = info->gain_input_count - 1;
3904 private->input_select_switch = val;
3906 /* Send new value to the device */
3917 struct usb_mixer_elem_info *elem = kctl->private_data;
3918 struct usb_mixer_interface *mixer = elem->head.mixer;
3919 struct scarlett2_data *private = mixer->private_data;
3920 int inputs = private->info->gain_input_count;
3926 return -ENOMEM;
3928 guard(mutex)(&private->data_mutex);
3930 if (private->hwdep_in_use)
3931 return -EBUSY;
3941 err = -ENOMEM;
3966 /* snd_ctl_boolean_mono_info() with autogain-updated check
3967 * (for controls that are read-only while autogain is running)
3972 struct usb_mixer_elem_info *elem = kctl->private_data;
3973 struct usb_mixer_interface *mixer = elem->head.mixer;
3974 struct scarlett2_data *private = mixer->private_data;
3977 guard(mutex)(&private->data_mutex);
3979 if (private->hwdep_in_use)
3980 return -EBUSY;
3992 struct usb_mixer_elem_info *elem = kctl->private_data;
3993 struct usb_mixer_interface *mixer = elem->head.mixer;
3994 struct scarlett2_data *private = mixer->private_data;
3997 guard(mutex)(&private->data_mutex);
3999 if (private->hwdep_in_use)
4000 return -EBUSY;
4002 if (private->input_select_updated) {
4007 ucontrol->value.enumerated.item[0] =
4008 private->input_link_switch[elem->control];
4015 struct usb_mixer_elem_info *elem = kctl->private_data;
4016 struct usb_mixer_interface *mixer = elem->head.mixer;
4017 struct scarlett2_data *private = mixer->private_data;
4018 int index = elem->control;
4021 guard(mutex)(&private->data_mutex);
4023 if (private->hwdep_in_use)
4024 return -EBUSY;
4030 oval = private->input_link_switch[index];
4031 val = !!ucontrol->value.integer.value[0];
4036 private->input_link_switch[index] = val;
4056 struct scarlett2_data *private = mixer->private_data;
4057 const struct scarlett2_device_info *info = private->info;
4059 private->input_gain_updated = 0;
4061 if (!info->gain_input_count)
4066 info->gain_input_count, private->gain);
4072 struct usb_mixer_elem_info *elem = kctl->private_data;
4073 struct usb_mixer_interface *mixer = elem->head.mixer;
4074 struct scarlett2_data *private = mixer->private_data;
4077 guard(mutex)(&private->data_mutex);
4079 if (private->hwdep_in_use)
4080 return -EBUSY;
4086 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4087 uinfo->count = elem->channels;
4088 uinfo->value.integer.min = 0;
4089 uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;
4090 uinfo->value.integer.step = 1;
4098 struct usb_mixer_elem_info *elem = kctl->private_data;
4099 struct usb_mixer_interface *mixer = elem->head.mixer;
4100 struct scarlett2_data *private = mixer->private_data;
4103 guard(mutex)(&private->data_mutex);
4105 if (private->hwdep_in_use)
4106 return -EBUSY;
4108 if (private->input_gain_updated) {
4113 ucontrol->value.integer.value[0] =
4114 private->gain[elem->control];
4121 struct usb_mixer_elem_info *elem = kctl->private_data;
4122 struct usb_mixer_interface *mixer = elem->head.mixer;
4123 struct scarlett2_data *private = mixer->private_data;
4124 int index = elem->control;
4127 guard(mutex)(&private->data_mutex);
4129 if (private->hwdep_in_use)
4130 return -EBUSY;
4136 oval = private->gain[index];
4137 val = ucontrol->value.integer.value[0];
4142 private->gain[index] = val;
4144 /* Send gain change to the device */
4166 struct scarlett2_data *private = mixer->private_data;
4167 const struct scarlett2_device_info *info = private->info;
4169 private->input_safe_updated = 0;
4171 if (!info->safe_input_count)
4176 info->safe_input_count, private->safe_switch);
4182 struct usb_mixer_elem_info *elem = kctl->private_data;
4183 struct usb_mixer_interface *mixer = elem->head.mixer;
4184 struct scarlett2_data *private = mixer->private_data;
4187 guard(mutex)(&private->data_mutex);
4189 if (private->hwdep_in_use)
4190 return -EBUSY;
4192 if (private->input_safe_updated) {
4197 ucontrol->value.integer.value[0] =
4198 private->safe_switch[elem->control];
4205 struct usb_mixer_elem_info *elem = kctl->private_data;
4206 struct usb_mixer_interface *mixer = elem->head.mixer;
4207 struct scarlett2_data *private = mixer->private_data;
4208 int index = elem->control;
4211 guard(mutex)(&private->data_mutex);
4213 if (private->hwdep_in_use)
4214 return -EBUSY;
4220 oval = private->safe_switch[index];
4221 val = !!ucontrol->value.integer.value[0];
4226 private->safe_switch[index] = val;
4228 /* Send switch change to the device */
4247 struct scarlett2_data *private = mixer->private_data;
4250 private->pcm_input_switch_updated = 0;
4254 1, &private->pcm_input_switch);
4264 struct usb_mixer_elem_info *elem = kctl->private_data;
4265 struct usb_mixer_interface *mixer = elem->head.mixer;
4266 struct scarlett2_data *private = elem->head.mixer->private_data;
4269 guard(mutex)(&private->data_mutex);
4271 if (private->pcm_input_switch_updated) {
4276 ucontrol->value.enumerated.item[0] = private->pcm_input_switch;
4283 struct usb_mixer_elem_info *elem = kctl->private_data;
4284 struct usb_mixer_interface *mixer = elem->head.mixer;
4285 struct scarlett2_data *private = mixer->private_data;
4288 guard(mutex)(&private->data_mutex);
4290 if (private->hwdep_in_use)
4291 return -EBUSY;
4293 oval = private->pcm_input_switch;
4294 val = !!ucontrol->value.integer.value[0];
4299 private->pcm_input_switch = val;
4301 /* Send switch change to the device */
4335 struct scarlett2_data *private = mixer->private_data;
4339 private->vol_updated = 0;
4349 private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4354 for (i = 0; i < private->num_line_out; i++)
4355 if (private->vol_sw_hw_switch[i])
4356 private->vol[i] = private->master_vol;
4367 private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4377 struct usb_mixer_elem_info *elem = kctl->private_data;
4379 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4380 uinfo->count = elem->channels;
4381 uinfo->value.integer.min = 0;
4382 uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
4383 uinfo->value.integer.step = 1;
4390 struct usb_mixer_elem_info *elem = kctl->private_data;
4391 struct usb_mixer_interface *mixer = elem->head.mixer;
4392 struct scarlett2_data *private = mixer->private_data;
4395 guard(mutex)(&private->data_mutex);
4397 if (private->hwdep_in_use)
4398 return -EBUSY;
4400 if (private->vol_updated) {
4405 ucontrol->value.integer.value[0] = private->master_vol;
4413 struct usb_mixer_elem_info *elem = kctl->private_data;
4414 struct usb_mixer_interface *mixer = elem->head.mixer;
4415 struct scarlett2_data *private = mixer->private_data;
4418 guard(mutex)(&private->data_mutex);
4420 if (private->hwdep_in_use)
4421 return -EBUSY;
4423 if (private->vol_updated) {
4428 ucontrol->value.integer.value[0] = private->headphone_vol;
4434 const struct scarlett2_device_info *info = private->info;
4436 if (!info->line_out_remap_enable)
4439 if (index >= private->num_line_out)
4442 return info->line_out_remap[index];
4448 struct usb_mixer_elem_info *elem = kctl->private_data;
4449 struct usb_mixer_interface *mixer = elem->head.mixer;
4450 struct scarlett2_data *private = mixer->private_data;
4451 int index = line_out_remap(private, elem->control);
4454 guard(mutex)(&private->data_mutex);
4456 if (private->hwdep_in_use)
4457 return -EBUSY;
4459 if (private->vol_updated) {
4464 ucontrol->value.integer.value[0] = private->vol[index];
4471 struct usb_mixer_elem_info *elem = kctl->private_data;
4472 struct usb_mixer_interface *mixer = elem->head.mixer;
4473 struct scarlett2_data *private = mixer->private_data;
4474 int index = line_out_remap(private, elem->control);
4477 guard(mutex)(&private->data_mutex);
4479 if (private->hwdep_in_use)
4480 return -EBUSY;
4482 oval = private->vol[index];
4483 val = ucontrol->value.integer.value[0];
4488 private->vol[index] = val;
4490 index, val - SCARLETT2_VOLUME_BIAS);
4496 db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
4537 struct scarlett2_data *private = mixer->private_data;
4541 private->dim_mute_updated = 0;
4548 SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);
4553 private->dim_mute[i] = !!private->dim_mute[i];
4555 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4557 for (i = 0; i < private->num_line_out; i++)
4558 if (private->vol_sw_hw_switch[i])
4559 private->mute_switch[i] = mute;
4567 struct usb_mixer_elem_info *elem = kctl->private_data;
4568 struct usb_mixer_interface *mixer = elem->head.mixer;
4569 struct scarlett2_data *private = mixer->private_data;
4570 int index = line_out_remap(private, elem->control);
4573 guard(mutex)(&private->data_mutex);
4575 if (private->hwdep_in_use)
4576 return -EBUSY;
4578 if (private->dim_mute_updated) {
4583 ucontrol->value.integer.value[0] = private->mute_switch[index];
4590 struct usb_mixer_elem_info *elem = kctl->private_data;
4591 struct usb_mixer_interface *mixer = elem->head.mixer;
4592 struct scarlett2_data *private = mixer->private_data;
4593 int index = line_out_remap(private, elem->control);
4596 guard(mutex)(&private->data_mutex);
4598 if (private->hwdep_in_use)
4599 return -EBUSY;
4601 oval = private->mute_switch[index];
4602 val = !!ucontrol->value.integer.value[0];
4607 private->mute_switch[index] = val;
4609 /* Send mute change to the device */
4628 private->sw_hw_ctls[index]->vd[0].access &=
4634 private->sw_hw_ctls[index]->vd[0].access |=
4651 struct usb_mixer_elem_info *elem = kctl->private_data;
4652 struct scarlett2_data *private = elem->head.mixer->private_data;
4653 int index = line_out_remap(private, elem->control);
4655 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
4662 struct scarlett2_data *private = mixer->private_data;
4663 struct snd_card *card = mixer->chip->card;
4667 private->vol_ctls[index]->vd[0].access |=
4669 private->mute_ctls[index]->vd[0].access |=
4672 private->vol_ctls[index]->vd[0].access &=
4674 private->mute_ctls[index]->vd[0].access &=
4681 &private->vol_ctls[index]->id);
4684 &private->mute_ctls[index]->id);
4690 struct scarlett2_data *private = mixer->private_data;
4694 private->vol_sw_hw_switch[index] = val;
4696 /* Change access mode to RO (hardware controlled volume)
4701 /* Reset volume/mute to master volume/mute */
4702 private->vol[index] = private->master_vol;
4703 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4705 /* Set SW volume to current HW volume */
4708 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
4712 /* Set SW mute to current HW mute */
4715 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
4719 /* Send SW/HW switch change to the device */
4727 struct usb_mixer_elem_info *elem = kctl->private_data;
4728 struct usb_mixer_interface *mixer = elem->head.mixer;
4729 struct scarlett2_data *private = mixer->private_data;
4730 int ctl_index = elem->control;
4734 guard(mutex)(&private->data_mutex);
4736 if (private->hwdep_in_use)
4737 return -EBUSY;
4739 oval = private->vol_sw_hw_switch[index];
4740 val = !!ucontrol->value.enumerated.item[0];
4762 struct scarlett2_data *private = mixer->private_data;
4763 const struct scarlett2_device_info *info = private->info;
4765 private->input_level_updated = 0;
4767 if (!info->level_input_count)
4772 info->level_input_count + info->level_input_first,
4773 private->level_switch);
4782 struct usb_mixer_elem_info *elem = kctl->private_data;
4783 struct usb_mixer_interface *mixer = elem->head.mixer;
4784 struct scarlett2_data *private = mixer->private_data;
4787 guard(mutex)(&private->data_mutex);
4789 if (private->hwdep_in_use)
4790 return -EBUSY;
4802 struct usb_mixer_elem_info *elem = kctl->private_data;
4803 struct usb_mixer_interface *mixer = elem->head.mixer;
4804 struct scarlett2_data *private = mixer->private_data;
4805 const struct scarlett2_device_info *info = private->info;
4806 int index = elem->control + info->level_input_first;
4809 guard(mutex)(&private->data_mutex);
4811 if (private->hwdep_in_use)
4812 return -EBUSY;
4814 if (private->input_level_updated) {
4819 ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(
4820 private->level_switch[index]);
4827 struct usb_mixer_elem_info *elem = kctl->private_data;
4828 struct usb_mixer_interface *mixer = elem->head.mixer;
4829 struct scarlett2_data *private = mixer->private_data;
4830 const struct scarlett2_device_info *info = private->info;
4831 int index = elem->control + info->level_input_first;
4834 guard(mutex)(&private->data_mutex);
4836 if (private->hwdep_in_use)
4837 return -EBUSY;
4843 oval = private->level_switch[index];
4844 val = !!ucontrol->value.enumerated.item[0];
4849 private->level_switch[index] = val;
4851 /* To set the Gen 4 muteable controls, bit 1 gets set instead */
4852 if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)
4855 /* Send switch change to the device */
4874 struct scarlett2_data *private = mixer->private_data;
4875 const struct scarlett2_device_info *info = private->info;
4877 private->input_pad_updated = 0;
4879 if (!info->pad_input_count)
4884 info->pad_input_count, private->pad_switch);
4890 struct usb_mixer_elem_info *elem = kctl->private_data;
4891 struct usb_mixer_interface *mixer = elem->head.mixer;
4892 struct scarlett2_data *private = mixer->private_data;
4895 guard(mutex)(&private->data_mutex);
4897 if (private->hwdep_in_use)
4898 return -EBUSY;
4900 if (private->input_pad_updated) {
4905 ucontrol->value.integer.value[0] =
4906 private->pad_switch[elem->control];
4913 struct usb_mixer_elem_info *elem = kctl->private_data;
4914 struct usb_mixer_interface *mixer = elem->head.mixer;
4915 struct scarlett2_data *private = mixer->private_data;
4916 int index = elem->control;
4919 guard(mutex)(&private->data_mutex);
4921 if (private->hwdep_in_use)
4922 return -EBUSY;
4924 oval = private->pad_switch[index];
4925 val = !!ucontrol->value.integer.value[0];
4930 private->pad_switch[index] = val;
4932 /* Send switch change to the device */
4951 struct scarlett2_data *private = mixer->private_data;
4952 const struct scarlett2_device_info *info = private->info;
4954 private->input_air_updated = 0;
4956 if (!info->air_input_count)
4961 info->air_input_count, private->air_switch);
4967 struct usb_mixer_elem_info *elem = kctl->private_data;
4968 struct usb_mixer_interface *mixer = elem->head.mixer;
4969 struct scarlett2_data *private = mixer->private_data;
4972 guard(mutex)(&private->data_mutex);
4974 if (private->hwdep_in_use)
4975 return -EBUSY;
4977 if (private->input_air_updated) {
4982 ucontrol->value.integer.value[0] = private->air_switch[elem->control];
4989 struct usb_mixer_elem_info *elem = kctl->private_data;
4990 struct usb_mixer_interface *mixer = elem->head.mixer;
4991 struct scarlett2_data *private = mixer->private_data;
4992 int index = elem->control;
4995 guard(mutex)(&private->data_mutex);
4997 if (private->hwdep_in_use)
4998 return -EBUSY;
5004 oval = private->air_switch[index];
5005 val = ucontrol->value.integer.value[0];
5010 private->air_switch[index] = val;
5012 /* Send switch change to the device */
5025 struct usb_mixer_elem_info *elem = kctl->private_data;
5026 struct usb_mixer_interface *mixer = elem->head.mixer;
5027 struct scarlett2_data *private = mixer->private_data;
5030 guard(mutex)(&private->data_mutex);
5032 if (private->hwdep_in_use)
5033 return -EBUSY;
5063 struct scarlett2_data *private = mixer->private_data;
5064 const struct scarlett2_device_info *info = private->info;
5066 private->input_dsp_updated = 0;
5068 if (!info->dsp_input_count)
5073 info->dsp_input_count, private->dsp_switch);
5079 struct usb_mixer_elem_info *elem = kctl->private_data;
5080 struct usb_mixer_interface *mixer = elem->head.mixer;
5081 struct scarlett2_data *private = mixer->private_data;
5084 guard(mutex)(&private->data_mutex);
5086 if (private->hwdep_in_use)
5087 return -EBUSY;
5089 if (private->input_dsp_updated) {
5094 ucontrol->value.integer.value[0] = private->dsp_switch[elem->control];
5101 struct usb_mixer_elem_info *elem = kctl->private_data;
5102 struct usb_mixer_interface *mixer = elem->head.mixer;
5103 struct scarlett2_data *private = mixer->private_data;
5104 int index = elem->control;
5107 guard(mutex)(&private->data_mutex);
5109 if (private->hwdep_in_use)
5110 return -EBUSY;
5116 oval = private->dsp_switch[index];
5117 val = ucontrol->value.integer.value[0];
5122 private->dsp_switch[index] = val;
5124 /* Send switch change to the device */
5143 struct scarlett2_data *private = mixer->private_data;
5144 const struct scarlett2_device_info *info = private->info;
5147 if (!info->dsp_input_count)
5152 SCARLETT2_COMPRESSOR_PARAM_COUNT * info->dsp_input_count,
5153 private->compressor_values);
5161 for (j = 0; j < info->dsp_input_count; j++) {
5163 int val = private->compressor_values[idx];
5165 val >>= param->scale_bits;
5166 val = clamp(val, param->min, param->max);
5167 private->compressor_values[idx] = val;
5177 struct usb_mixer_elem_info *elem = kctl->private_data;
5178 struct scarlett2_data *private = elem->head.mixer->private_data;
5180 ucontrol->value.integer.value[0] =
5181 private->compressor_values[elem->control];
5188 struct usb_mixer_elem_info *elem = kctl->private_data;
5189 struct usb_mixer_interface *mixer = elem->head.mixer;
5190 struct scarlett2_data *private = mixer->private_data;
5191 int index = elem->control;
5198 guard(mutex)(&private->data_mutex);
5200 if (private->hwdep_in_use)
5201 return -EBUSY;
5207 oval = private->compressor_values[index];
5208 val = ucontrol->value.integer.value[0];
5212 private->compressor_values[index] = val;
5214 scaled_val = val << param->scale_bits;
5216 /* Send change to the device */
5218 /* The channel needs to be put in the parameter buffer index
5223 mixer, private->config_set->param_buf_addr + 1, 1, channel);
5236 struct usb_mixer_elem_info *elem = kctl->private_data;
5237 int control = elem->control % SCARLETT2_COMPRESSOR_PARAM_COUNT;
5239 uinfo->type = compressor_params[control].type;
5240 uinfo->count = 1;
5241 uinfo->value.integer.min = compressor_params[control].min;
5242 uinfo->value.integer.max = compressor_params[control].max;
5243 uinfo->value.integer.step = 1;
5255 /*** DSP Pre-Compressor and PEQ Filter Controls ***/
5260 struct usb_mixer_elem_info *elem = kctl->private_data;
5261 struct scarlett2_data *private = elem->head.mixer->private_data;
5263 ucontrol->value.integer.value[0] = private->precomp_flt_switch[elem->control];
5271 struct usb_mixer_elem_info *elem = kctl->private_data;
5272 struct scarlett2_data *private = elem->head.mixer->private_data;
5274 ucontrol->value.integer.value[0] =
5275 private->peq_flt_switch[elem->control];
5283 struct usb_mixer_elem_info *elem = kctl->private_data;
5284 struct usb_mixer_interface *mixer = elem->head.mixer;
5285 struct scarlett2_data *private = mixer->private_data;
5288 guard(mutex)(&private->data_mutex);
5290 if (private->hwdep_in_use)
5291 return -EBUSY;
5293 oval = private->precomp_flt_switch[elem->control];
5294 val = ucontrol->value.integer.value[0];
5299 private->precomp_flt_switch[elem->control] = val;
5301 /* Send change to the device */
5304 elem->control, val);
5312 struct usb_mixer_elem_info *elem = kctl->private_data;
5313 struct usb_mixer_interface *mixer = elem->head.mixer;
5314 struct scarlett2_data *private = mixer->private_data;
5317 guard(mutex)(&private->data_mutex);
5319 if (private->hwdep_in_use)
5320 return -EBUSY;
5322 oval = private->peq_flt_switch[elem->control];
5323 val = ucontrol->value.integer.value[0];
5328 private->peq_flt_switch[elem->control] = val;
5330 /* Send change to the device */
5333 elem->control, val);
5356 struct scarlett2_data *private = mixer->private_data;
5357 const struct scarlett2_device_info *info = private->info;
5363 if (!info->dsp_input_count)
5369 info->dsp_input_count, private->precomp_flt_switch);
5375 info->dsp_input_count * info->peq_flt_count,
5376 private->peq_flt_switch);
5380 /* Get pre-compressor filter values directly */
5383 info->dsp_input_count *
5384 info->precomp_flt_count *
5386 private->precomp_flt_values);
5391 /* PEQ filter values need to be copied via buffer because of
5392 * padding after peq_flt_count up to peq_flt_total_count
5396 info->dsp_input_count *
5397 info->peq_flt_total_count *
5403 for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) {
5405 info->peq_flt_total_count *
5407 for (j = 0; j < info->peq_flt_count; j++)
5411 private->peq_flt_values[dst_idx] =
5421 struct usb_mixer_elem_info *elem = kctl->private_data;
5422 struct scarlett2_data *private = elem->head.mixer->private_data;
5425 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5428 ucontrol->value.integer.value[i] =
5429 private->precomp_flt_values[idx];
5437 struct usb_mixer_elem_info *elem = kctl->private_data;
5438 struct scarlett2_data *private = elem->head.mixer->private_data;
5441 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5444 ucontrol->value.integer.value[i] =
5445 private->peq_flt_values[idx];
5453 struct usb_mixer_elem_info *elem = kctl->private_data;
5454 struct usb_mixer_interface *mixer = elem->head.mixer;
5455 struct scarlett2_data *private = mixer->private_data;
5456 int index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5459 guard(mutex)(&private->data_mutex);
5461 if (private->hwdep_in_use)
5462 return -EBUSY;
5470 oval = private->precomp_flt_values[index + i];
5471 val = ucontrol->value.integer.value[i];
5481 private->precomp_flt_values[index + i] =
5482 ucontrol->value.integer.value[i];
5484 /* Send change to the device */
5486 mixer, private->config_set->param_buf_addr, 1, index);
5493 &private->precomp_flt_values[index]);
5501 struct usb_mixer_elem_info *elem = kctl->private_data;
5502 struct usb_mixer_interface *mixer = elem->head.mixer;
5503 struct scarlett2_data *private = mixer->private_data;
5504 const struct scarlett2_device_info *info = private->info;
5505 int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5507 elem->control /
5508 info->peq_flt_count *
5509 info->peq_flt_total_count +
5510 elem->control % info->peq_flt_count
5514 guard(mutex)(&private->data_mutex);
5516 if (private->hwdep_in_use)
5517 return -EBUSY;
5525 oval = private->peq_flt_values[src_index + i];
5526 val = ucontrol->value.integer.value[i];
5536 private->peq_flt_values[src_index + i] =
5537 ucontrol->value.integer.value[i];
5539 /* Send change to the device */
5541 mixer, private->config_set->param_buf_addr, 1, dst_index);
5548 &private->peq_flt_values[src_index]);
5556 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
5557 uinfo->count = SCARLETT2_BIQUAD_COEFFS;
5558 uinfo->value.integer.min = INT_MIN;
5559 uinfo->value.integer.max = INT_MAX;
5560 uinfo->value.integer.step = 1;
5584 struct scarlett2_data *private = mixer->private_data;
5585 const struct scarlett2_device_info *info = private->info;
5587 private->input_mute_updated = 0;
5589 if (!info->mute_input_count)
5594 info->mute_input_count, private->input_mute_switch);
5600 struct usb_mixer_elem_info *elem = kctl->private_data;
5601 struct usb_mixer_interface *mixer = elem->head.mixer;
5602 struct scarlett2_data *private = mixer->private_data;
5605 guard(mutex)(&private->data_mutex);
5607 if (private->hwdep_in_use)
5608 return -EBUSY;
5610 if (private->input_mute_updated) {
5615 ucontrol->value.integer.value[0] =
5616 private->input_mute_switch[elem->control];
5623 struct usb_mixer_elem_info *elem = kctl->private_data;
5624 struct usb_mixer_interface *mixer = elem->head.mixer;
5625 struct scarlett2_data *private = mixer->private_data;
5626 int index = elem->control;
5629 guard(mutex)(&private->data_mutex);
5631 if (private->hwdep_in_use)
5632 return -EBUSY;
5638 oval = private->input_mute_switch[index];
5639 val = ucontrol->value.integer.value[0];
5644 private->input_mute_switch[index] = val;
5646 /* Send switch change to the device */
5666 struct scarlett2_data *private = mixer->private_data;
5667 const struct scarlett2_device_info *info = private->info;
5670 private->input_phantom_updated = 0;
5672 if (!info->phantom_count)
5677 info->phantom_count, private->phantom_switch);
5685 1, &private->phantom_persistence);
5697 const struct scarlett2_device_info *info = private->info;
5698 int index = line_num / info->inputs_per_phantom;
5700 return !!(private->phantom_switch[index] & 0x02);
5706 struct scarlett2_data *private = mixer->private_data;
5707 const struct scarlett2_device_info *info = private->info;
5711 for (i = 0; i < info->gain_input_count; i++) {
5714 scarlett2_set_ctl_access(private->autogain_ctls[i], val);
5723 struct snd_card *card = mixer->chip->card;
5724 struct scarlett2_data *private = mixer->private_data;
5725 const struct scarlett2_device_info *info = private->info;
5728 for (i = 0; i < info->gain_input_count; i++)
5730 &private->autogain_ctls[i]->id);
5739 struct scarlett2_data *private = mixer->private_data;
5742 if (!private->input_phantom_updated)
5757 struct usb_mixer_elem_info *elem = kctl->private_data;
5758 struct usb_mixer_interface *mixer = elem->head.mixer;
5759 struct scarlett2_data *private = mixer->private_data;
5762 guard(mutex)(&private->data_mutex);
5764 if (private->hwdep_in_use)
5765 return -EBUSY;
5771 ucontrol->value.integer.value[0] = scarlett2_decode_muteable(
5772 private->phantom_switch[elem->control]);
5779 struct usb_mixer_elem_info *elem = kctl->private_data;
5780 struct usb_mixer_interface *mixer = elem->head.mixer;
5781 struct scarlett2_data *private = mixer->private_data;
5782 const struct scarlett2_device_info *info = private->info;
5783 int index = elem->control;
5786 guard(mutex)(&private->data_mutex);
5788 if (private->hwdep_in_use)
5789 return -EBUSY;
5795 oval = private->phantom_switch[index];
5796 val = !!ucontrol->value.integer.value[0];
5801 private->phantom_switch[index] = val;
5803 /* To set the Gen 4 muteable controls, bit 1 gets set */
5804 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)
5807 /* Send switch change to the device */
5809 index + info->phantom_first, val);
5829 struct usb_mixer_elem_info *elem = kctl->private_data;
5830 struct scarlett2_data *private = elem->head.mixer->private_data;
5832 ucontrol->value.integer.value[0] = private->phantom_persistence;
5839 struct usb_mixer_elem_info *elem = kctl->private_data;
5840 struct usb_mixer_interface *mixer = elem->head.mixer;
5841 struct scarlett2_data *private = mixer->private_data;
5842 int index = elem->control;
5845 guard(mutex)(&private->data_mutex);
5847 if (private->hwdep_in_use)
5848 return -EBUSY;
5850 oval = private->phantom_persistence;
5851 val = !!ucontrol->value.integer.value[0];
5856 private->phantom_persistence = val;
5858 /* Send switch change to the device */
5877 struct scarlett2_data *private = mixer->private_data;
5878 const struct scarlett2_device_info *info = private->info;
5891 private->monitor_other_updated = 0;
5896 if (!info->has_speaker_switching)
5912 private->speaker_switching_switch = 0;
5914 private->speaker_switching_switch = monitor_other_switch[0] + 1;
5916 if (info->has_talkback) {
5921 private->talkback_switch = 0;
5923 private->talkback_switch = monitor_other_switch[1] + 1;
5930 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)
5931 private->talkback_map[i] = bitmap & 1;
5950 struct usb_mixer_elem_info *elem = kctl->private_data;
5951 struct usb_mixer_interface *mixer = elem->head.mixer;
5952 struct scarlett2_data *private = mixer->private_data;
5955 guard(mutex)(&private->data_mutex);
5957 if (private->hwdep_in_use)
5958 return -EBUSY;
5960 if (private->monitor_other_updated) {
5965 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
5970 * to HW volume and disable those controls
5974 struct snd_card *card = mixer->chip->card;
5975 struct scarlett2_data *private = mixer->private_data;
5981 /* switch the main/alt speakers to HW volume */
5982 if (!private->vol_sw_hw_switch[index]) {
5983 err = scarlett2_sw_hw_change(private->mixer, i, 1);
5993 &private->sw_hw_ctls[i]->id);
5996 /* when the next monitor-other notify comes in, update the mux
5999 private->speaker_switching_switched = 1;
6009 struct snd_card *card = mixer->chip->card;
6010 struct scarlett2_data *private = mixer->private_data;
6017 &private->sw_hw_ctls[i]->id);
6020 /* when the next monitor-other notify comes in, update the mux
6023 private->speaker_switching_switched = 1;
6029 struct usb_mixer_elem_info *elem = kctl->private_data;
6030 struct usb_mixer_interface *mixer = elem->head.mixer;
6031 struct scarlett2_data *private = mixer->private_data;
6034 guard(mutex)(&private->data_mutex);
6036 if (private->hwdep_in_use)
6037 return -EBUSY;
6039 oval = private->speaker_switching_switch;
6040 val = min(ucontrol->value.enumerated.item[0], 2U);
6045 private->speaker_switching_switch = val;
6080 struct scarlett2_data *private = mixer->private_data;
6081 const struct scarlett2_device_info *info = private->info;
6083 if (!info->has_speaker_switching)
6089 &private->speaker_switching_ctl);
6107 struct usb_mixer_elem_info *elem = kctl->private_data;
6108 struct usb_mixer_interface *mixer = elem->head.mixer;
6109 struct scarlett2_data *private = mixer->private_data;
6112 guard(mutex)(&private->data_mutex);
6114 if (private->hwdep_in_use)
6115 return -EBUSY;
6117 if (private->monitor_other_updated) {
6122 ucontrol->value.enumerated.item[0] = private->talkback_switch;
6129 struct usb_mixer_elem_info *elem = kctl->private_data;
6130 struct usb_mixer_interface *mixer = elem->head.mixer;
6131 struct scarlett2_data *private = mixer->private_data;
6134 guard(mutex)(&private->data_mutex);
6136 if (private->hwdep_in_use)
6137 return -EBUSY;
6139 oval = private->talkback_switch;
6140 val = min(ucontrol->value.enumerated.item[0], 2U);
6145 private->talkback_switch = val;
6173 struct usb_mixer_elem_info *elem = kctl->private_data;
6174 struct usb_mixer_interface *mixer = elem->head.mixer;
6175 struct scarlett2_data *private = mixer->private_data;
6176 int index = elem->control;
6178 ucontrol->value.integer.value[0] = private->talkback_map[index];
6186 struct usb_mixer_elem_info *elem = kctl->private_data;
6187 struct usb_mixer_interface *mixer = elem->head.mixer;
6188 struct scarlett2_data *private = mixer->private_data;
6189 int index = elem->control;
6193 guard(mutex)(&private->data_mutex);
6195 if (private->hwdep_in_use)
6196 return -EBUSY;
6198 oval = private->talkback_map[index];
6199 val = !!ucontrol->value.integer.value[0];
6204 private->talkback_map[index] = val;
6206 for (i = 0; i < private->num_mix_out; i++)
6207 bitmap |= private->talkback_map[i] << i;
6209 /* Send updated bitmap to the device */
6226 struct scarlett2_data *private = mixer->private_data;
6227 const struct scarlett2_device_info *info = private->info;
6231 if (!info->has_talkback)
6237 &private->talkback_ctl);
6241 for (i = 0; i < private->num_mix_out; i++) {
6258 struct usb_mixer_elem_info *elem = kctl->private_data;
6259 struct usb_mixer_interface *mixer = elem->head.mixer;
6260 struct scarlett2_data *private = mixer->private_data;
6263 guard(mutex)(&private->data_mutex);
6265 if (private->hwdep_in_use)
6266 return -EBUSY;
6268 if (private->dim_mute_updated) {
6273 ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
6280 struct usb_mixer_elem_info *elem = kctl->private_data;
6281 struct usb_mixer_interface *mixer = elem->head.mixer;
6282 struct scarlett2_data *private = mixer->private_data;
6283 int index = elem->control;
6286 guard(mutex)(&private->data_mutex);
6288 if (private->hwdep_in_use)
6289 return -EBUSY;
6291 oval = private->dim_mute[index];
6292 val = !!ucontrol->value.integer.value[0];
6297 private->dim_mute[index] = val;
6299 /* Send switch change to the device */
6303 for (i = 0; i < private->num_line_out; i++) {
6306 if (private->vol_sw_hw_switch[line_index]) {
6307 private->mute_switch[line_index] = val;
6308 snd_ctl_notify(mixer->chip->card,
6310 &private->mute_ctls[i]->id);
6330 struct usb_mixer_elem_info *elem = kctl->private_data;
6331 struct scarlett2_data *private = elem->head.mixer->private_data;
6333 ucontrol->value.integer.value[0] =
6334 !!(private->sp_hp_mute & (1 << elem->control));
6342 struct usb_mixer_elem_info *elem = kctl->private_data;
6343 struct usb_mixer_interface *mixer = elem->head.mixer;
6344 struct scarlett2_data *private = mixer->private_data;
6345 int index = elem->control;
6348 guard(mutex)(&private->data_mutex);
6350 if (private->hwdep_in_use)
6351 return -EBUSY;
6353 val = private->sp_hp_mute;
6355 if (ucontrol->value.integer.value[0])
6360 if (val == private->sp_hp_mute)
6363 private->sp_hp_mute = val;
6365 /* Send change to the device */
6384 struct scarlett2_data *private = mixer->private_data;
6385 const struct scarlett2_device_info *info = private->info;
6395 0, 1, s, &private->master_vol_ctl);
6407 &private->headphone_vol_ctl);
6413 if (private->info->sp_hp_mute_names)
6414 for (i = 0; private->info->sp_hp_mute_names[i]; i++) {
6417 i, 1, private->info->sp_hp_mute_names[i],
6424 * has per-channel line-out volume controls.
6431 for (i = 0; i < private->num_line_out; i++) {
6435 if (info->line_out_descrs[i])
6438 i + 1, info->line_out_descrs[i]);
6445 i, 1, s, &private->vol_ctls[i]);
6456 &private->mute_ctls[i]);
6464 /* Make the fader and mute controls read-only if the
6465 * SW/HW switch is set to HW
6467 if (private->vol_sw_hw_switch[index])
6476 &private->sw_hw_ctls[i]);
6480 /* Make the switch read-only if the line is
6483 if (private->speaker_switching_switch && i < 4)
6494 &private->dim_mute_ctls[i]);
6506 struct scarlett2_data *private = mixer->private_data;
6507 const struct scarlett2_device_info *info = private->info;
6519 scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name);
6523 1, s, &private->compressor_ctls[idx]);
6529 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp");
6532 i, 1, s, &private->precomp_flt_switch_ctls[i]);
6539 i, 1, s, &private->peq_flt_switch_ctls[i]);
6544 for (j = 0; j < info->precomp_flt_count; j++) {
6545 scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1);
6548 i * info->precomp_flt_count + j,
6549 1, s, &private->precomp_flt_switch_ctls[j]);
6554 for (j = 0; j < info->peq_flt_count; j++) {
6558 i * info->peq_flt_count + j,
6559 1, s, &private->peq_flt_switch_ctls[j]);
6569 struct scarlett2_data *private = mixer->private_data;
6570 const struct scarlett2_device_info *info = private->info;
6574 const char *fmt2 = "Line In %d-%d %s Capture %s";
6577 for (i = 0; i < info->level_input_count; i++) {
6578 scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
6581 i, 1, s, &private->level_ctls[i]);
6587 for (i = 0; i < info->pad_input_count; i++) {
6590 i, 1, s, &private->pad_ctls[i]);
6596 for (i = 0; i < info->air_input_count; i++) {
6597 scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,
6598 "Air", info->air_option ? "Enum" : "Switch");
6600 mixer, &scarlett2_air_ctl[info->air_option],
6601 i, 1, s, &private->air_ctls[i]);
6607 for (i = 0; i < info->dsp_input_count; i++) {
6610 i, 1, s, &private->dsp_ctls[i]);
6620 for (i = 0; i < info->mute_input_count; i++) {
6624 i, 1, s, &private->input_mute_ctls[i]);
6630 if (info->inputs_per_phantom == 1) {
6631 for (i = 0; i < info->phantom_count; i++) {
6633 i + 1 + info->phantom_first,
6637 i, 1, s, &private->phantom_ctls[i]);
6641 } else if (info->inputs_per_phantom > 1) {
6642 for (i = 0; i < info->phantom_count; i++) {
6643 int from = i * info->inputs_per_phantom + 1;
6644 int to = (i + 1) * info->inputs_per_phantom;
6646 scnprintf(s, sizeof(s), fmt2, from, to,
6650 i, 1, s, &private->phantom_ctls[i]);
6655 if (info->phantom_count &&
6671 &private->input_select_ctl);
6678 for (i = 0; i < info->gain_input_count; i++) {
6683 i, 1, s, &private->input_link_ctls[i]);
6689 /* Add software-controllable input gain controls */
6690 for (i = 0; i < info->gain_input_count; i++) {
6695 i, 1, s, &private->input_gain_ctls[i]);
6698 private->input_gain_ctls[i]->tlv.p =
6699 private->config_set->input_gain_tlv;
6705 i, 1, s, &private->autogain_ctls[i]);
6713 i, 1, s, &private->autogain_status_ctls[i]);
6725 i, 1, s, &private->ag_target_ctls[i]);
6730 /* Add safe-mode input switch controls */
6731 for (i = 0; i < info->safe_input_count; i++) {
6736 i, 1, s, &private->safe_ctls[i]);
6747 &private->pcm_input_switch_ctl);
6759 struct scarlett2_data *private = mixer->private_data;
6762 private->mix_updated = 0;
6764 for (i = 0; i < private->num_mix_out; i++) {
6776 struct usb_mixer_elem_info *elem = kctl->private_data;
6778 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
6779 uinfo->count = elem->channels;
6780 uinfo->value.integer.min = 0;
6781 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
6782 uinfo->value.integer.step = 1;
6789 struct usb_mixer_elem_info *elem = kctl->private_data;
6790 struct usb_mixer_interface *mixer = elem->head.mixer;
6791 struct scarlett2_data *private = mixer->private_data;
6794 guard(mutex)(&private->data_mutex);
6796 if (private->hwdep_in_use)
6797 return -EBUSY;
6799 if (private->mix_updated) {
6804 ucontrol->value.integer.value[0] = private->mix[elem->control];
6811 struct usb_mixer_elem_info *elem = kctl->private_data;
6812 struct usb_mixer_interface *mixer = elem->head.mixer;
6813 struct scarlett2_data *private = mixer->private_data;
6815 int index = elem->control;
6817 guard(mutex)(&private->data_mutex);
6819 if (private->hwdep_in_use)
6820 return -EBUSY;
6822 oval = private->mix[index];
6823 val = clamp(ucontrol->value.integer.value[0],
6825 mix_num = index / private->num_mix_in;
6830 private->mix[index] = val;
6856 struct scarlett2_data *private = mixer->private_data;
6861 for (i = 0, index = 0; i < private->num_mix_out; i++)
6862 for (j = 0; j < private->num_mix_in; j++, index++) {
6868 &private->mix_ctls[index]);
6880 struct scarlett2_data *private = mixer->private_data;
6882 private->direct_monitor_updated = 0;
6884 if (!private->info->direct_monitor)
6889 1, &private->direct_monitor_switch);
6894 struct scarlett2_data *private = mixer->private_data;
6898 if (!private->num_monitor_mix_ctls)
6903 private->num_monitor_mix_ctls, mix_values);
6907 for (i = 0; i < private->num_monitor_mix_ctls; i++)
6908 private->monitor_mix[i] = scarlett2_mixer_value_to_db(
6917 struct usb_mixer_elem_info *elem = kctl->private_data;
6918 struct usb_mixer_interface *mixer = elem->head.mixer;
6919 struct scarlett2_data *private = mixer->private_data;
6922 guard(mutex)(&private->data_mutex);
6924 if (private->hwdep_in_use)
6925 return -EBUSY;
6927 if (private->direct_monitor_updated) {
6932 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
6939 struct usb_mixer_elem_info *elem = kctl->private_data;
6940 struct usb_mixer_interface *mixer = elem->head.mixer;
6941 struct scarlett2_data *private = mixer->private_data;
6942 int index = elem->control;
6945 guard(mutex)(&private->data_mutex);
6947 if (private->hwdep_in_use)
6948 return -EBUSY;
6950 oval = private->direct_monitor_switch;
6951 val = min(ucontrol->value.enumerated.item[0], 2U);
6956 private->direct_monitor_switch = val;
6958 /* Send switch change to the device */
6975 /* Direct Monitor for Solo is mono-only and only needs a boolean control
6998 struct usb_mixer_elem_info *elem = kctl->private_data;
6999 struct scarlett2_data *private = elem->head.mixer->private_data;
7001 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];
7009 struct usb_mixer_elem_info *elem = kctl->private_data;
7010 struct usb_mixer_interface *mixer = elem->head.mixer;
7011 struct scarlett2_data *private = mixer->private_data;
7013 int index = elem->control;
7015 guard(mutex)(&private->data_mutex);
7017 if (private->hwdep_in_use)
7018 return -EBUSY;
7020 oval = private->monitor_mix[index];
7021 val = clamp(ucontrol->value.integer.value[0],
7027 private->monitor_mix[index] = val;
7049 struct scarlett2_data *private = mixer->private_data;
7050 const struct scarlett2_device_info *info = private->info;
7054 if (!info->direct_monitor)
7057 s = info->direct_monitor == 1
7062 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
7063 0, 1, s, &private->direct_monitor_ctl);
7067 if (!private->num_monitor_mix_ctls)
7071 for (i = 0, index = 0; i < info->direct_monitor; i++) {
7076 if (info->direct_monitor == 1)
7087 for (k = 0; k < private->num_mix_in; k++, index++) {
7109 struct usb_mixer_elem_info *elem = kctl->private_data;
7110 struct scarlett2_data *private = elem->head.mixer->private_data;
7111 const struct scarlett2_device_info *info = private->info;
7112 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7113 unsigned int item = uinfo->value.enumerated.item;
7114 int items = private->num_mux_srcs;
7117 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
7118 uinfo->count = elem->channels;
7119 uinfo->value.enumerated.items = items;
7122 item = uinfo->value.enumerated.item = items - 1;
7132 item >= private->num_mix_out)
7133 scnprintf(uinfo->value.enumerated.name,
7134 sizeof(uinfo->value.enumerated.name),
7135 port->dsp_src_descr,
7136 item - private->num_mix_out + 1);
7138 scnprintf(uinfo->value.enumerated.name,
7139 sizeof(uinfo->value.enumerated.name),
7140 port->src_descr,
7141 item + port->src_num_offset);
7145 item -= port_count[port_type][SCARLETT2_PORT_IN];
7148 return -EINVAL;
7154 struct usb_mixer_elem_info *elem = kctl->private_data;
7155 struct usb_mixer_interface *mixer = elem->head.mixer;
7156 struct scarlett2_data *private = mixer->private_data;
7157 int index = line_out_remap(private, elem->control);
7160 guard(mutex)(&private->data_mutex);
7162 if (private->hwdep_in_use)
7163 return -EBUSY;
7165 if (private->mux_updated) {
7170 ucontrol->value.enumerated.item[0] = private->mux[index];
7177 struct usb_mixer_elem_info *elem = kctl->private_data;
7178 struct usb_mixer_interface *mixer = elem->head.mixer;
7179 struct scarlett2_data *private = mixer->private_data;
7180 int index = line_out_remap(private, elem->control);
7183 guard(mutex)(&private->data_mutex);
7185 if (private->hwdep_in_use)
7186 return -EBUSY;
7188 oval = private->mux[index];
7189 val = min(ucontrol->value.enumerated.item[0],
7190 private->num_mux_srcs - 1U);
7195 private->mux[index] = val;
7211 struct scarlett2_data *private = mixer->private_data;
7212 const struct scarlett2_device_info *info = private->info;
7213 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7227 const char *descr = port->dst_descr;
7230 channel >= private->num_mix_in) {
7231 channel_num -= private->num_mix_in;
7232 descr = port->dsp_dst_descr;
7235 snprintf(s, sizeof(s) - 5, descr, channel_num);
7241 &private->mux_ctls[i]);
7255 struct usb_mixer_elem_info *elem = kctl->private_data;
7257 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7258 uinfo->count = elem->channels;
7259 uinfo->value.integer.min = 0;
7260 uinfo->value.integer.max = 4095;
7261 uinfo->value.integer.step = 1;
7268 struct usb_mixer_elem_info *elem = kctl->private_data;
7269 struct usb_mixer_interface *mixer = elem->head.mixer;
7270 struct scarlett2_data *private = mixer->private_data;
7271 u8 *meter_level_map = private->meter_level_map;
7275 guard(mutex)(&private->data_mutex);
7277 if (private->hwdep_in_use)
7278 return -EBUSY;
7280 err = scarlett2_usb_get_meter_levels(mixer, elem->channels,
7286 for (i = 0; i < elem->channels; i++) {
7295 ucontrol->value.integer.value[i] = value;
7311 struct scarlett2_data *private = mixer->private_data;
7318 0, private->num_mux_dsts,
7327 struct usb_mixer_elem_info *elem = kctl->private_data;
7328 struct scarlett2_data *private = elem->head.mixer->private_data;
7330 ucontrol->value.integer.value[0] = private->msd_switch;
7337 struct usb_mixer_elem_info *elem = kctl->private_data;
7338 struct usb_mixer_interface *mixer = elem->head.mixer;
7339 struct scarlett2_data *private = mixer->private_data;
7342 guard(mutex)(&private->data_mutex);
7344 if (private->hwdep_in_use)
7345 return -EBUSY;
7347 oval = private->msd_switch;
7348 val = !!ucontrol->value.integer.value[0];
7353 private->msd_switch = val;
7355 /* Send switch change to the device */
7372 struct scarlett2_data *private = mixer->private_data;
7378 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
7391 struct usb_mixer_elem_info *elem = kctl->private_data;
7392 struct scarlett2_data *private = elem->head.mixer->private_data;
7394 ucontrol->value.integer.value[0] = private->standalone_switch;
7401 struct usb_mixer_elem_info *elem = kctl->private_data;
7402 struct usb_mixer_interface *mixer = elem->head.mixer;
7403 struct scarlett2_data *private = mixer->private_data;
7406 guard(mutex)(&private->data_mutex);
7408 if (private->hwdep_in_use)
7409 return -EBUSY;
7411 oval = private->standalone_switch;
7412 val = !!ucontrol->value.integer.value[0];
7417 private->standalone_switch = val;
7419 /* Send switch change to the device */
7437 struct scarlett2_data *private = mixer->private_data;
7452 struct scarlett2_data *private = mixer->private_data;
7456 private->power_status_updated = 0;
7469 private->power_status = SCARLETT2_POWER_STATUS_FAIL;
7471 private->power_status = SCARLETT2_POWER_STATUS_EXT;
7473 private->power_status = SCARLETT2_POWER_STATUS_BUS;
7481 struct usb_mixer_elem_info *elem = kctl->private_data;
7482 struct usb_mixer_interface *mixer = elem->head.mixer;
7483 struct scarlett2_data *private = mixer->private_data;
7486 guard(mutex)(&private->data_mutex);
7488 if (private->power_status_updated) {
7493 ucontrol->value.integer.value[0] = private->power_status;
7517 struct scarlett2_data *private = mixer->private_data;
7526 &private->power_status_ctl);
7533 struct scarlett2_data *private = mixer->private_data;
7536 private->bluetooth_updated = 0;
7538 if (!private->info->has_bluetooth)
7543 1, &private->bluetooth_volume);
7553 struct usb_mixer_elem_info *elem = kctl->private_data;
7554 struct usb_mixer_interface *mixer = elem->head.mixer;
7555 struct scarlett2_data *private = mixer->private_data;
7558 guard(mutex)(&private->data_mutex);
7560 if (private->hwdep_in_use)
7561 return -EBUSY;
7563 if (private->bluetooth_updated) {
7568 ucontrol->value.integer.value[0] = private->bluetooth_volume;
7575 struct usb_mixer_elem_info *elem = kctl->private_data;
7576 struct usb_mixer_interface *mixer = elem->head.mixer;
7577 struct scarlett2_data *private = mixer->private_data;
7580 guard(mutex)(&private->data_mutex);
7582 if (private->hwdep_in_use)
7583 return -EBUSY;
7585 oval = private->bluetooth_volume;
7586 val = clamp(ucontrol->value.integer.value[0],
7592 private->bluetooth_volume = val;
7603 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7604 uinfo->count = 1;
7605 uinfo->value.integer.min = 0;
7606 uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME;
7607 uinfo->value.integer.step = 1;
7622 struct scarlett2_data *private = mixer->private_data;
7624 if (!private->info->has_bluetooth)
7630 &private->bluetooth_volume_ctl);
7637 struct scarlett2_data *private = mixer->private_data;
7640 const u8 *mode_values = private->info->spdif_mode_values;
7642 if (!private->info->spdif_mode_control_name)
7650 private->spdif_mode = 0;
7654 private->spdif_mode = i;
7664 struct usb_mixer_elem_info *elem = kctl->private_data;
7665 struct scarlett2_data *private = elem->head.mixer->private_data;
7666 const char * const *mode_texts = private->info->spdif_mode_texts;
7673 private->info->spdif_mode_texts);
7679 struct usb_mixer_elem_info *elem = kctl->private_data;
7680 struct scarlett2_data *private = elem->head.mixer->private_data;
7682 ucontrol->value.enumerated.item[0] = private->spdif_mode;
7689 struct usb_mixer_elem_info *elem = kctl->private_data;
7690 struct usb_mixer_interface *mixer = elem->head.mixer;
7691 struct scarlett2_data *private = mixer->private_data;
7695 guard(mutex)(&private->data_mutex);
7697 oval = private->spdif_mode;
7698 val = ucontrol->value.enumerated.item[0];
7701 return -EINVAL;
7704 if (private->info->spdif_mode_values[i] == 0xff)
7705 return -EINVAL;
7710 private->spdif_mode = val;
7714 private->info->spdif_mode_values[val]);
7729 struct scarlett2_data *private = mixer->private_data;
7731 if (!private->info->spdif_mode_control_name)
7736 private->info->spdif_mode_control_name,
7745 struct scarlett2_data *private = mixer->private_data;
7747 private->sync_updated = 1;
7749 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7750 &private->sync_ctl->id);
7756 struct snd_card *card = mixer->chip->card;
7757 struct scarlett2_data *private = mixer->private_data;
7763 private->vol_updated = 1;
7765 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7766 &private->master_vol_ctl->id);
7768 for (i = 0; i < private->num_line_out; i++)
7769 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
7771 &private->vol_ctls[i]->id);
7777 struct scarlett2_data *private = mixer->private_data;
7779 private->vol_updated = 1;
7781 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7782 &private->master_vol_ctl->id);
7783 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7784 &private->headphone_vol_ctl->id);
7790 struct snd_card *card = mixer->chip->card;
7791 struct scarlett2_data *private = mixer->private_data;
7797 private->dim_mute_updated = 1;
7801 &private->dim_mute_ctls[i]->id);
7803 for (i = 0; i < private->num_line_out; i++)
7804 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
7806 &private->mute_ctls[i]->id);
7812 struct snd_card *card = mixer->chip->card;
7813 struct scarlett2_data *private = mixer->private_data;
7814 const struct scarlett2_device_info *info = private->info;
7817 private->input_level_updated = 1;
7819 for (i = 0; i < info->level_input_count; i++)
7821 &private->level_ctls[i]->id);
7827 struct snd_card *card = mixer->chip->card;
7828 struct scarlett2_data *private = mixer->private_data;
7829 const struct scarlett2_device_info *info = private->info;
7832 private->input_pad_updated = 1;
7834 for (i = 0; i < info->pad_input_count; i++)
7836 &private->pad_ctls[i]->id);
7842 struct snd_card *card = mixer->chip->card;
7843 struct scarlett2_data *private = mixer->private_data;
7844 const struct scarlett2_device_info *info = private->info;
7847 private->input_air_updated = 1;
7849 for (i = 0; i < info->air_input_count; i++)
7851 &private->air_ctls[i]->id);
7857 struct snd_card *card = mixer->chip->card;
7858 struct scarlett2_data *private = mixer->private_data;
7859 const struct scarlett2_device_info *info = private->info;
7862 private->input_dsp_updated = 1;
7864 for (i = 0; i < info->dsp_input_count; i++)
7866 &private->dsp_ctls[i]->id);
7872 struct snd_card *card = mixer->chip->card;
7873 struct scarlett2_data *private = mixer->private_data;
7874 const struct scarlett2_device_info *info = private->info;
7877 private->input_mute_updated = 1;
7879 for (i = 0; i < info->mute_input_count; i++)
7881 &private->input_mute_ctls[i]->id);
7887 struct snd_card *card = mixer->chip->card;
7888 struct scarlett2_data *private = mixer->private_data;
7889 const struct scarlett2_device_info *info = private->info;
7892 private->input_phantom_updated = 1;
7894 for (i = 0; i < info->phantom_count; i++)
7896 &private->phantom_ctls[i]->id);
7913 struct snd_card *card = mixer->chip->card;
7914 struct scarlett2_data *private = mixer->private_data;
7915 const struct scarlett2_device_info *info = private->info;
7922 private->input_select_updated = 1;
7926 &private->input_select_ctl->id);
7928 for (i = 0; i < info->gain_input_count; i++)
7930 &private->input_link_ctls[i]->id);
7936 struct snd_card *card = mixer->chip->card;
7937 struct scarlett2_data *private = mixer->private_data;
7938 const struct scarlett2_device_info *info = private->info;
7941 if (!info->gain_input_count)
7944 private->input_gain_updated = 1;
7946 for (i = 0; i < info->gain_input_count; i++)
7948 &private->input_gain_ctls[i]->id);
7954 struct snd_card *card = mixer->chip->card;
7955 struct scarlett2_data *private = mixer->private_data;
7956 const struct scarlett2_device_info *info = private->info;
7959 if (!info->gain_input_count)
7962 private->autogain_updated = 1;
7964 for (i = 0; i < info->gain_input_count; i++) {
7966 &private->autogain_ctls[i]->id);
7968 &private->autogain_status_ctls[i]->id);
7975 &private->ag_target_ctls[i]->id);
7983 struct snd_card *card = mixer->chip->card;
7984 struct scarlett2_data *private = mixer->private_data;
7985 const struct scarlett2_device_info *info = private->info;
7988 if (!info->safe_input_count)
7991 private->input_safe_updated = 1;
7993 for (i = 0; i < info->safe_input_count; i++)
7995 &private->safe_ctls[i]->id);
8001 struct snd_card *card = mixer->chip->card;
8002 struct scarlett2_data *private = mixer->private_data;
8003 const struct scarlett2_device_info *info = private->info;
8005 private->monitor_other_updated = 1;
8007 if (info->has_speaker_switching)
8009 &private->speaker_switching_ctl->id);
8011 if (info->has_talkback)
8013 &private->talkback_ctl->id);
8018 if (private->speaker_switching_switched) {
8023 private->speaker_switching_switched = 0;
8024 private->mux_updated = 1;
8026 for (i = 0; i < private->num_mux_dsts; i++)
8028 &private->mux_ctls[i]->id);
8035 struct snd_card *card = mixer->chip->card;
8036 struct scarlett2_data *private = mixer->private_data;
8037 int count = private->num_mix_in * private->num_mix_out;
8040 private->direct_monitor_updated = 1;
8043 &private->direct_monitor_ctl->id);
8048 private->mix_updated = 1;
8050 /* Notify of change to the mix controls */
8053 &private->mix_ctls[i]->id);
8059 struct snd_card *card = mixer->chip->card;
8060 struct scarlett2_data *private = mixer->private_data;
8062 private->power_status_updated = 1;
8065 &private->power_status_ctl->id);
8071 struct snd_card *card = mixer->chip->card;
8072 struct scarlett2_data *private = mixer->private_data;
8075 private->mux_updated = 1;
8077 for (i = 0; i < private->num_mux_dsts; i++)
8079 &private->mux_ctls[i]->id);
8085 struct snd_card *card = mixer->chip->card;
8086 struct scarlett2_data *private = mixer->private_data;
8088 private->pcm_input_switch_updated = 1;
8091 &private->pcm_input_switch_ctl->id);
8099 struct snd_card *card = mixer->chip->card;
8100 struct scarlett2_data *private = mixer->private_data;
8102 if (!private->info->has_bluetooth)
8105 private->bluetooth_updated = 1;
8108 &private->bluetooth_volume_ctl->id);
8116 struct scarlett2_data *private = mixer->private_data;
8119 if (private->running)
8120 complete(&private->cmd_done);
8126 struct usb_mixer_interface *mixer = urb->context;
8127 int len = urb->actual_length;
8128 int ustatus = urb->status;
8130 struct scarlett2_data *private = mixer->private_data;
8132 private->config_set->notifications;
8137 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
8142 if (private->running < 2)
8145 while (data && notifications->mask) {
8146 if (data & notifications->mask) {
8147 data &= ~notifications->mask;
8148 if (notifications->func)
8149 notifications->func(mixer);
8155 usb_audio_warn(mixer->chip,
8160 if (ustatus != -ENOENT &&
8161 ustatus != -ECONNRESET &&
8162 ustatus != -ESHUTDOWN) {
8163 urb->dev = mixer->chip->dev;
8166 complete(&private->cmd_done);
8174 struct scarlett2_data *private = mixer->private_data;
8176 cancel_delayed_work_sync(&private->work);
8178 mixer->private_data = NULL;
8183 struct scarlett2_data *private = mixer->private_data;
8185 if (cancel_delayed_work_sync(&private->work))
8186 scarlett2_config_save(private->mixer);
8193 const struct scarlett2_device_info *info = private->info;
8194 const struct scarlett2_config_set *config_set = info->config_set;
8195 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
8206 private->num_mux_srcs = srcs;
8207 private->num_mux_dsts = dsts;
8213 private->num_mix_in =
8214 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -
8215 info->dsp_count;
8217 private->num_mix_out =
8218 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -
8219 info->dsp_count;
8222 private->num_line_out =
8226 private->num_monitor_mix_ctls =
8227 info->direct_monitor * 2 * private->num_mix_in;
8230 if (config_set->autogain_status_texts) {
8231 const char * const *texts = config_set->autogain_status_texts;
8235 private->num_autogain_status_texts = i;
8247 struct usb_host_config *config = dev->actconfig;
8250 for (i = 0; i < config->desc.bNumInterfaces; i++) {
8251 struct usb_interface *intf = config->interface[i];
8253 &intf->altsetting[0].desc;
8256 if (desc->bInterfaceClass != 255)
8259 epd = get_endpoint(intf->altsetting, 0);
8260 private->bInterfaceNumber = desc->bInterfaceNumber;
8261 private->bEndpointAddress = usb_endpoint_num(epd);
8262 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
8263 private->bInterval = epd->bInterval;
8267 return -EINVAL;
8278 return -ENOMEM;
8280 mutex_init(&private->usb_mutex);
8281 mutex_init(&private->data_mutex);
8282 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
8284 mixer->private_data = private;
8285 mixer->private_free = scarlett2_private_free;
8286 mixer->private_suspend = scarlett2_private_suspend;
8288 private->info = entry->info;
8289 private->config_set = entry->info->config_set;
8290 private->series_name = entry->series_name;
8292 private->scarlett2_seq = 0;
8293 private->mixer = mixer;
8295 return scarlett2_find_fc_interface(mixer->chip->dev, private);
8298 /* Submit a URB to receive notifications from the device */
8301 struct usb_device *dev = mixer->chip->dev;
8302 struct scarlett2_data *private = mixer->private_data;
8303 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
8306 if (mixer->urb) {
8307 usb_audio_err(mixer->chip,
8313 return -EINVAL;
8315 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
8316 if (!mixer->urb)
8317 return -ENOMEM;
8319 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
8321 return -ENOMEM;
8323 usb_fill_int_urb(mixer->urb, dev, pipe,
8324 transfer_buffer, private->wMaxPacketSize,
8325 scarlett2_notify, mixer, private->bInterval);
8327 init_completion(&private->cmd_done);
8329 return usb_submit_urb(mixer->urb, GFP_KERNEL);
8335 struct usb_device *dev = mixer->chip->dev;
8336 struct scarlett2_data *private = mixer->private_data;
8342 return -EINVAL;
8345 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
8367 private->running = 1;
8370 private->scarlett2_seq = 1;
8376 private->scarlett2_seq = 1;
8383 /* extract 4-byte firmware version from step2_buf[8] */
8384 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));
8385 usb_audio_info(mixer->chip,
8387 private->firmware_version);
8397 struct scarlett2_data *private = mixer->private_data;
8423 usb_audio_err(mixer->chip,
8425 return -EINVAL;
8436 usb_audio_err(mixer->chip,
8437 "failed to get flash segment info %d: %d\n",
8451 private->flash_segment_nums[flash_segment_id] = i;
8452 private->flash_segment_blocks[flash_segment_id] =
8457 /* segment 0 is App_Gold and we never want to touch that, so
8458 * use 0 as the "not-found" value
8460 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {
8461 usb_audio_err(mixer->chip,
8462 "failed to find flash segment %s\n",
8464 return -EINVAL;
8466 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {
8467 usb_audio_err(mixer->chip,
8468 "failed to find flash segment %s\n",
8470 return -EINVAL;
8479 struct scarlett2_data *private = mixer->private_data;
8480 const struct scarlett2_device_info *info = private->info;
8486 1, &private->msd_switch);
8491 if (private->firmware_version < info->min_firmware_version) {
8492 usb_audio_err(mixer->chip,
8495 private->series_name,
8496 private->firmware_version,
8497 info->min_firmware_version);
8502 if (private->msd_switch)
8557 1, &private->standalone_switch);
8580 private->num_line_out, &sw_vol);
8584 for (i = 0; i < private->num_line_out; i++)
8585 private->vol[i] = clamp(
8592 private->num_line_out, &private->mute_switch);
8596 for (i = 0; i < private->num_line_out; i++)
8597 private->mute_switch[i] =
8598 !!private->mute_switch[i];
8605 private->num_line_out,
8606 &private->vol_sw_hw_switch);
8610 for (i = 0; i < private->num_line_out; i++)
8611 private->vol_sw_hw_switch[i] =
8612 !!private->vol_sw_hw_switch[i];
8668 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)
8670 if (!entry->usb_id)
8688 private = mixer->private_data;
8723 if (private->msd_switch ||
8724 private->firmware_version < private->info->min_firmware_version)
8795 if (private->info->gain_input_count) {
8801 private->running = 2;
8808 /* Set private->hwdep_in_use; prevents access to the ALSA controls
8813 guard(mutex)(&private->data_mutex);
8814 private->hwdep_in_use = 1;
8817 /* Call SCARLETT2_USB_GET_ERASE to get the erase progress */
8820 struct scarlett2_data *private = mixer->private_data;
8829 segment_id = private->selected_flash_segment_id;
8830 segment_num = private->flash_segment_nums[segment_id];
8834 return -EFAULT;
8868 return -ETIMEDOUT;
8871 /* Reboot the device; wait for the erase to complete if one is in
8876 struct scarlett2_data *private = mixer->private_data;
8878 if (private->flash_write_state ==
8894 struct scarlett2_data *private = mixer->private_data;
8898 return -EFAULT;
8902 return -EINVAL;
8904 segment_num = private->flash_segment_nums[segment_id];
8907 usb_audio_err(mixer->chip,
8910 return -EFAULT;
8913 /* If erasing, wait for it to complete */
8914 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {
8921 /* Save the selected segment ID and set the state to SELECTED */
8922 private->selected_flash_segment_id = segment_id;
8923 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;
8928 /* Erase the previously-selected flash segment */
8932 struct scarlett2_data *private = mixer->private_data;
8940 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
8941 return -EINVAL;
8943 segment_id = private->selected_flash_segment_id;
8944 segment_num = private->flash_segment_nums[segment_id];
8948 return -EFAULT;
8950 /* Prevent access to ALSA controls that access the device from
8965 /* On success, change the state from SELECTED to ERASING */
8966 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;
8976 struct scarlett2_data *private = mixer->private_data;
8987 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
8988 return -EINVAL;
8990 segment_id = private->selected_flash_segment_id;
8991 segment_num = private->flash_segment_nums[segment_id];
8995 return -EFAULT;
9008 progress.num_blocks = private->flash_segment_blocks[segment_id];
9011 return -EFAULT;
9013 /* If the erase is complete, change the state from ERASING to
9017 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9024 struct usb_mixer_interface *mixer = hw->private_data;
9025 struct scarlett2_data *private = mixer->private_data;
9027 /* If erasing, wait for it to complete */
9028 if (private->flash_write_state ==
9036 /* Set the state to IDLE */
9037 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9045 struct usb_mixer_interface *mixer = hw->private_data;
9051 (int __user *)arg) ? -EFAULT : 0;
9066 return -ENOIOCTLCMD;
9074 struct usb_mixer_interface *mixer = hw->private_data;
9075 struct scarlett2_data *private = mixer->private_data;
9089 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
9090 return -EINVAL;
9093 segment_id = private->selected_flash_segment_id;
9095 return -EINVAL;
9097 segment_num = private->flash_segment_nums[segment_id];
9100 return -EFAULT;
9104 return -EINVAL;
9107 flash_size = private->flash_segment_blocks[segment_id] *
9112 /* Limit the numbers of bytes read to SCARLETT2_FLASH_RW_MAX */
9116 /* Limit read to EOF */
9118 count = flash_size - *offset;
9127 return -ENOMEM;
9134 /* Copy the response to userspace */
9136 return -EFAULT;
9146 struct usb_mixer_interface *mixer = hw->private_data;
9147 struct scarlett2_data *private = mixer->private_data;
9160 const size_t max_data_size = SCARLETT2_FLASH_RW_MAX -
9163 /* If erasing, wait for it to complete */
9164 if (private->flash_write_state ==
9169 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9172 } else if (private->flash_write_state !=
9174 return -EINVAL;
9177 /* Check that we're writing to the upgrade firmware */
9178 segment_id = private->selected_flash_segment_id;
9180 return -EINVAL;
9182 segment_num = private->flash_segment_nums[segment_id];
9185 return -EFAULT;
9188 flash_size = private->flash_segment_blocks[segment_id] *
9192 return -ENOSPC;
9197 /* Limit the *req size to SCARLETT2_FLASH_RW_MAX */
9205 return -ENOMEM;
9207 req->segment_num = cpu_to_le32(segment_num);
9208 req->offset = cpu_to_le32(*offset);
9209 req->pad = 0;
9211 if (copy_from_user(req->data, buf, count))
9212 return -EFAULT;
9225 struct usb_mixer_interface *mixer = hw->private_data;
9226 struct scarlett2_data *private = mixer->private_data;
9228 /* Return from the SELECTED or WRITE state to IDLE.
9229 * The ERASING state is left as-is, and checked on next open.
9232 private->hwdep_in_use &&
9233 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
9234 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9244 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);
9248 hw->private_data = mixer;
9249 hw->exclusive = 1;
9250 hw->ops.open = scarlett2_hwdep_open;
9251 hw->ops.ioctl = scarlett2_hwdep_ioctl;
9252 hw->ops.read = scarlett2_hwdep_read;
9253 hw->ops.write = scarlett2_hwdep_write;
9254 hw->ops.release = scarlett2_hwdep_release;
9259 /*** device-map file ***/
9269 struct usb_mixer_interface *mixer = entry->private_data;
9274 if (pos >= entry->size)
9277 if (pos + count > entry->size)
9278 count = entry->size - pos;
9282 return -ENOMEM;
9286 * so we need to read a whole block and copy the requested
9287 * chunk to userspace.
9297 size_t block_start = pos - offset;
9300 entry->size - block_start);
9302 /* size of the chunk to copy to userspace */
9303 size_t copy_size = min_t(size_t, count, read_size - offset);
9313 return -EFAULT;
9318 count -= copy_size;
9330 struct snd_card *card = mixer->chip->card;
9331 struct scarlett2_data *private = mixer->private_data;
9332 const struct scarlett2_device_info *info = private->info;
9341 if (!info->has_devmap)
9355 entry->content = SNDRV_INFO_CONTENT_DATA;
9356 entry->private_data = mixer;
9357 entry->c.ops = &scarlett2_devmap_ops;
9358 entry->size = config_len;
9359 entry->mode = S_IFREG | 0444;
9366 struct snd_usb_audio *chip = mixer->chip;
9371 if (!mixer->protocol)
9374 /* check if the user wants to use the FCP driver instead */
9375 if (chip->setup & SCARLETT2_USE_FCP_DRIVER)
9381 usb_audio_err(mixer->chip,
9384 USB_ID_VENDOR(chip->usb_id),
9385 USB_ID_PRODUCT(chip->usb_id));
9389 if (chip->setup & SCARLETT2_DISABLE) {
9394 entry->series_name,
9395 USB_ID_VENDOR(chip->usb_id),
9396 USB_ID_PRODUCT(chip->usb_id),
9403 "report any issues to "
9404 "https://github.com/geoffreybennett/scarlett-gen2/issues",
9405 entry->series_name,
9406 USB_ID_PRODUCT(chip->usb_id));
9410 usb_audio_err(mixer->chip,
9412 entry->series_name,
9419 usb_audio_err(mixer->chip,
9421 entry->series_name,
9428 usb_audio_err(mixer->chip,
9430 entry->series_name,