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
14  *   Copyright (c) 2018-2024 by Geoffrey D. Bennett <g at b4.vu>
15  *   Copyright (c) 2020-2021 by Vladimir Sadovnikov <[email protected]>
35  * (firmware 1083) using usbmon in July-August 2018.
39  * Scarlett 6i6 support added in June 2019 (thanks to Martin Wittmann
42  * Scarlett 4i4/8i6 Gen 3 support added in May 2020 (thanks to Laurent
43  * Debricon for donating a 4i4 and to Fredrik Unger for providing 8i6
46  * Scarlett 18i8/18i20 Gen 3 support added in June 2020 (thanks to
51  * interface during driver initialisation added in May 2021 (thanks to
54  * Support for Solo/2i2 Gen 3 added in May 2021 (thanks to Alexander
58  * and talkback added in May-June 2021.
63  * Support for Clarett 8Pre USB added in Sep 2023 (thanks to Philippe
66  * Support for Clarett+ 4Pre and 2Pre added in Sep 2023 (thanks to
75  * to many LinuxMusicians people and to Focusrite for hardware
78  * This ALSA mixer gives access to (model-dependent):
79  *  - input, output, mixer-matrix muxes
80  *  - mixer-matrix gain stages
81  *  - gain/volume/mute controls
82  *  - level meters
83  *  - line/inst level, pad, and air controls
84  *  - phantom power, direct monitor, speaker switching, and talkback
86  *  - disable/enable MSD mode
87  *  - disable/enable standalone mode
88  *  - input mute, gain, autogain, safe mode
89  *  - direct monitor mixes
90  *  - compressor and EQ
91  *  - Bluetooth volume
94  *    /--------------\    18chn            20chn     /--------------\
95  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
96  *    \--------------/  |      |    |             |  \--------------/
97  *                      |      |    |    /-----\  |
100  *                      |   +---------------+  |  |
102  *                      |     +-----+-----+    |  |
108  *                      |     +------------+   |  |
114  *                      |     +-----+------+   |  |
118  *                      |           +----------/  |
122  *               +---------------+       +--—------------+
124  *                 +---+---+---+           +-----+-----+
128  *  /--------------\   |   |                     |   /--------------\
129  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
130  *  | Hardware out |       |                         \--------------/
131  *  \--------------/       |
133  *                  +-------------+    Software gain per channel.
134  *                  | Master Gain |<-- 18i20 only: Switch per channel
135  *                  +------+------+    to select HW or SW gain control.
138  *  /--------------\       |
139  *  | Analogue     |<------/
141  *  \--------------/
146  * to the host. To access the full functionality of the device without
148  * - holding down the 48V button for five seconds while powering on
150  * - using this driver and alsamixer to change the "MSD Mode" setting
151  *   to Off and power-cycling the device
171 /* device_setup value to allow turning MSD mode back on */
174 /* device_setup value to disable this mixer driver */
177 /* device_setup value to use the FCP driver instead */
184  * (the corresponding value in dB is per-device)
191 /* mixer range from -80dB to +12dB in 0.5dB steps */
192 #define SCARLETT2_MIXER_MIN_DB -80
193 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
196 	((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
199 /* map from (dB + 80) * 2 to mixer value
200  * for dB in 0 .. 184: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
232 /* Maximum number of inputs to the mixer */
261  * The compressor parameters are 32-bit fixed point values with 24
274  * - Enable: Off, On
275  * - Threshold: -40dB to 0dB
276  * - Ratio: 1:1 to 50:1 in 0.5:1 steps
277  * - Knee Width: 0dB to 10dB
278  * - Attack: 30ms to 127ms
279  * - Release: 30ms to 127ms
280  * - Makeup Gain: 0dB to 24dB
284 	{ "Threshold",   SNDRV_CTL_ELEM_TYPE_INTEGER, -40,   0, 24 },
313  * - None (no input to mux)
314  * - Analogue I/O
315  * - S/PDIF I/O
316  * - ADAT I/O
317  * - Mixer I/O
318  * - PCM I/O
346 #define SCARLETT2_AG_TARGET_MIN (-30)
370  * If autogain_switch is set, autogain_status is set to 0 (Running).
568  * Vocaster and 4th Gen devices have a parameter buffer to set certain
569  * configuration parameters. When pbuf is set, rather than writing to
570  * the given offset, the channel and value are written to the
571  * parameter buffer and the activate command is sent to the device.
575  * mute set to 1. 0x02 and 0x03 are temporary values while the device
582 	u8 activate;  member
611 			.offset = 0x34, .size = 16, .activate = 1 },
614 			.offset = 0x5c, .size = 8, .activate = 1 },
617 			.offset = 0x7c, .size = 8, .activate = 7 },
620 			.offset = 0x84, .size = 8, .activate = 8 },
623 			.offset = 0x8d, .size = 8, .activate = 6 },
633 			.offset = 0x31, .size = 8, .activate = 2 },
636 			.offset = 0x34, .size = 16, .activate = 1 },
639 			.offset = 0x5c, .size = 8, .activate = 1 },
642 			.offset = 0x66, .size = 8, .activate = 3 },
648 			.offset = 0x7c, .size = 8, .activate = 7 },
651 			.offset = 0x84, .size = 8, .activate = 8 },
654 			.offset = 0x8d, .size = 8, .activate = 6 },
663 			.offset = 0x04, .size = 8, .activate = 6 },
666 			.offset = 0x05, .size = 8, .activate = 6 },
669 			.offset = 0x06, .size = 8, .activate = 3 },
672 			.offset = 0x07, .size = 8, .activate = 4 },
675 			.offset = 0x08, .size = 1, .activate = 7 },
678 			.offset = 0x09, .size = 1, .activate = 8 },
687 			.offset = 0x34, .size = 16, .activate = 1 },
690 			.offset = 0x5c, .size = 8, .activate = 1 },
693 			.offset = 0x7c, .size = 8, .activate = 7 },
696 			.offset = 0x84, .size = 8, .activate = 8 },
699 			.offset = 0x8c, .size = 8, .activate = 8 },
702 			.offset = 0x95, .size = 8, .activate = 6 },
705 			.offset = 0x9c, .size = 1, .activate = 8 },
708 			.offset = 0x9d, .size = 8, .activate = 6 },
711 			.offset = 0x9e, .size = 8, .activate = 6 },
720 			.offset = 0x31, .size = 8, .activate = 2 },
723 			.offset = 0x34, .size = 16, .activate = 1 },
726 			.offset = 0x5c, .size = 8, .activate = 1 },
729 			.offset = 0x66, .size = 8, .activate = 3 },
735 			.offset = 0x7c, .size = 8, .activate = 7 },
738 			.offset = 0x84, .size = 8, .activate = 8 },
741 			.offset = 0x8c, .size = 8, .activate = 8 },
744 			.offset = 0x95, .size = 8, .activate = 6 },
747 			.offset = 0x9c, .size = 1, .activate = 8 },
750 			.offset = 0x9d, .size = 8, .activate = 6 },
753 			.offset = 0x9e, .size = 8, .activate = 6 },
756 			.offset = 0x9f, .size = 1, .activate = 10 },
759 			.offset = 0xa0, .size = 1, .activate = 10 },
762 			.offset = 0xb0, .size = 16, .activate = 10 },
765 			.offset = 0x94, .size = 8, .activate = 6 },
777 			.offset = 0x9d, .size = 8, .activate = 6 },
780 			.offset = 0x1c0, .size = 8, .activate = 19, .pbuf = 1 },
786 			.offset = 0xc1, .size = 8, .activate = 29, .pbuf = 1 },
789 			.offset = 0x9f, .size = 8, .activate = 21, .pbuf = 1 },
792 			.offset = 0x9c, .size = 1, .activate = 20, .pbuf = 1 },
795 			.offset = 0x1c4, .size = 8, .activate = 22, .pbuf = 1 },
798 			.offset = 0x1c8, .size = 32, .activate = 23 },
801 			.offset = 0x7c, .size = 32, .activate = 27 },
804 			.offset = 0x200, .size = 32, .activate = 27 },
807 			.offset = 0x84, .size = 32, .activate = 27 },
810 			.offset = 0x250, .size = 32, .activate = 27 },
813 			.offset = 0x1be, .size = 8, .activate = 17, .pbuf = 1 },
816 			.offset = 0xbf, .size = 8, .activate = 28 },
826 			.offset = 0x47, .size = 8, .activate = 4 },
829 			.offset = 0x108, .size = 8, .activate = 12, .pbuf = 1 },
832 			.offset = 0x46, .size = 8, .activate = 9, .pbuf = 1,
836 			.offset = 0x3d, .size = 8, .activate = 10, .pbuf = 1,
840 			.offset = 0x3e, .size = 8, .activate = 11, .pbuf = 1 },
843 			.offset = 0x206, .size = 8, .activate = 25, .pbuf = 1 },
846 			.offset = 0x232, .size = 16, .activate = 26 }
858 			.offset = 0x49, .size = 8, .activate = 4 },
861 			.offset = 0x14a, .size = 8, .activate = 16, .pbuf = 1 },
864 			.offset = 0x135, .size = 8, .activate = 10, .pbuf = 1 },
870 			.offset = 0x131, .size = 8, .activate = 29, .pbuf = 1 },
873 			.offset = 0x132, .size = 8, .activate = 30, .pbuf = 1 },
876 			.offset = 0x48, .size = 8, .activate = 11, .pbuf = 1,
880 			.offset = 0x4b, .size = 8, .activate = 12, .pbuf = 1 },
883 			.offset = 0x3c, .size = 8, .activate = 13, .pbuf = 1,
887 			.offset = 0x147, .size = 8, .activate = 14, .pbuf = 1 },
890 			.offset = 0x3e, .size = 8, .activate = 15, .pbuf = 1 },
893 			.offset = 0x14b, .size = 8, .activate = 17, .pbuf = 1 },
896 			.offset = 0x14e, .size = 8, .activate = 18, .pbuf = 1 },
899 			.offset = 0x2a0, .size = 16, .activate = 36 }
911 			.offset = 0x5c, .size = 8, .activate = 4 },
914 			.offset = 0x13e, .size = 8, .activate = 10, .pbuf = 1 },
920 			.offset = 0x13a, .size = 8, .activate = 23, .pbuf = 1 },
923 			.offset = 0x13b, .size = 8, .activate = 24, .pbuf = 1 },
926 			.offset = 0x5a, .size = 8, .activate = 11, .pbuf = 1,
930 			.offset = 0x5e, .size = 8, .activate = 12, .pbuf = 1 },
933 			.offset = 0x4e, .size = 8, .activate = 13, .pbuf = 1,
937 			.offset = 0x150, .size = 8, .activate = 14, .pbuf = 1 },
940 			.offset = 0x50, .size = 8, .activate = 15, .pbuf = 1 },
943 			.offset = 0x153, .size = 8, .activate = 16, .pbuf = 1 },
946 			.offset = 0x156, .size = 8, .activate = 17, .pbuf = 1 },
967 			.offset = 0x31, .size = 8, .activate = 2 },
970 			.offset = 0x34, .size = 16, .activate = 1 },
973 			.offset = 0x5c, .size = 8, .activate = 1 },
976 			.offset = 0x66, .size = 8, .activate = 3 },
982 			.offset = 0x7c, .size = 8, .activate = 7 },
985 			.offset = 0x95, .size = 8, .activate = 8 },
988 			.offset = 0x8d, .size = 8, .activate = 6 },
991 			.offset = 0x9e, .size = 8, .activate = 4 },
996  * - id: hardware ID of this port type
997  * - src_descr: printf format string for mux input selections
998  * - src_num_offset: added to channel number for the fprintf
999  * - dst_descr: printf format string for mixer controls
1058  * ports to add to the set_mux message. The end of the list is marked
1071  * that consecutive meter entries are mapped to. The end of the list
1096 	 * level control that can be set to line or instrument
1100 	/* the first input with a level control (0-based) */
1113 	/* the first input with an air control (0-based) */
1125 	/* number of pre-compressor filters */
1142 	/* the first input with phantom power control (0-based) */
1148 	/* the number of inputs with software-controllable gain */
1171 	 * internally to the analogue 7/8 outputs
1188 	 * SCARLETT2_USB_GET_METER to index into mux[] entries (same
1198 	struct mutex data_mutex; /* lock access to this data */
1318 /*** Model-specific data ***/
2294 /* Gen 4 device firmware provides access to a base64-encoded
2295  * zlib-compressed JSON description of the device's capabilities and
2297  * /proc/asound/cardX/device-map.json.zz.b64
2300 #define SCARLETT2_DEVMAP_FILENAME "device-map.json.zz.b64"
2317 	u16 seq = private->scarlett2_seq++;  in scarlett2_fill_request_header()
2319 	req->cmd = cpu_to_le32(cmd);  in scarlett2_fill_request_header()
2320 	req->size = cpu_to_le16(req_size);  in scarlett2_fill_request_header()
2321 	req->seq = cpu_to_le16(seq);  in scarlett2_fill_request_header()
2322 	req->error = 0;  in scarlett2_fill_request_header()
2323 	req->pad = 0;  in scarlett2_fill_request_header()
2344 /* Send a proprietary format request to the Scarlett interface */
2349 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb()
2350 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_usb()
2358 		err = -ENOMEM;  in scarlett2_usb()
2364 		err = -ENOMEM;  in scarlett2_usb()
2368 	mutex_lock(&private->usb_mutex);  in scarlett2_usb()
2375 		memcpy(req->data, req_data, req_size);  in scarlett2_usb()
2377 	err = scarlett2_usb_tx(dev, private->bInterfaceNumber,  in scarlett2_usb()
2382 			mixer->chip,  in scarlett2_usb()
2384 			private->series_name, cmd, err);  in scarlett2_usb()
2385 		err = -EINVAL;  in scarlett2_usb()
2389 	if (!wait_for_completion_timeout(&private->cmd_done,  in scarlett2_usb()
2392 			mixer->chip,  in scarlett2_usb()
2394 			private->series_name, cmd);  in scarlett2_usb()
2396 		err = -ETIMEDOUT;  in scarlett2_usb()
2400 	/* send a second message to get the response */  in scarlett2_usb()
2402 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,  in scarlett2_usb()
2410 		/* ESHUTDOWN and EPROTO are valid responses to a  in scarlett2_usb()
2414 		    (err == -ESHUTDOWN || err == -EPROTO)) {  in scarlett2_usb()
2420 			mixer->chip,  in scarlett2_usb()
2422 			private->series_name, cmd, err, resp_buf_size);  in scarlett2_usb()
2423 		err = -EINVAL;  in scarlett2_usb()
2430 	if (resp->cmd != req->cmd ||  in scarlett2_usb()
2431 	    (resp->seq != req->seq &&  in scarlett2_usb()
2432 		(le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||  in scarlett2_usb()
2433 	    resp_size != le16_to_cpu(resp->size) ||  in scarlett2_usb()
2434 	    resp->error ||  in scarlett2_usb()
2435 	    resp->pad) {  in scarlett2_usb()
2437 			mixer->chip,  in scarlett2_usb()
2441 			private->series_name,  in scarlett2_usb()
2442 			le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),  in scarlett2_usb()
2443 			le16_to_cpu(req->seq), le16_to_cpu(resp->seq),  in scarlett2_usb()
2444 			resp_size, le16_to_cpu(resp->size),  in scarlett2_usb()
2445 			le32_to_cpu(resp->error),  in scarlett2_usb()
2446 			le32_to_cpu(resp->pad));  in scarlett2_usb()
2447 		err = -EINVAL;  in scarlett2_usb()
2452 		memcpy(resp_data, resp->data, resp_size);  in scarlett2_usb()
2455 	mutex_unlock(&private->usb_mutex);  in scarlett2_usb()
2462 /* Send a USB message to get data; result placed in *buf */
2484 	return !!private->config_set->items[config_item_num].offset;  in scarlett2_has_config_item()
2487 /* Send a USB message to get configuration parameters; result placed in *buf */
2492 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_config()
2494 		&private->config_set->items[config_item_num];  in scarlett2_usb_get_config()
2502 	if (!config_item->offset)  in scarlett2_usb_get_config()
2503 		return -EFAULT;  in scarlett2_usb_get_config()
2505 	/* Writes to the parameter buffer are always 1 byte */  in scarlett2_usb_get_config()
2506 	size = config_item->size ? config_item->size : 8;  in scarlett2_usb_get_config()
2508 	/* For byte-sized parameters, retrieve directly into buf */  in scarlett2_usb_get_config()
2511 		err = scarlett2_usb_get(mixer, config_item->offset, buf, size);  in scarlett2_usb_get_config()
2528 	/* For bit-sized parameters, retrieve into value */  in scarlett2_usb_get_config()
2529 	err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);  in scarlett2_usb_get_config()
2549 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_data()
2559 	return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,  in scarlett2_usb_set_data()
2572 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_data_buf()
2584 		return -ENOMEM;  in scarlett2_usb_set_data_buf()
2586 	req->offset = cpu_to_le32(offset);  in scarlett2_usb_set_data_buf()
2587 	req->size = cpu_to_le32(bytes);  in scarlett2_usb_set_data_buf()
2589 		memcpy(req->data, buf, count);  in scarlett2_usb_set_data_buf()
2595 			((__le16 *)req->data)[i] = cpu_to_le16(buf_16[i]);  in scarlett2_usb_set_data_buf()
2601 			((__le32 *)req->data)[i] = cpu_to_le32(buf_32[i]);  in scarlett2_usb_set_data_buf()
2604 	err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,  in scarlett2_usb_set_data_buf()
2614  * The value for activate needed is determined by the configuration
2618 	struct usb_mixer_interface *mixer, int activate)  in scarlett2_usb_activate_config()  argument
2622 	req = cpu_to_le32(activate);  in scarlett2_usb_activate_config()
2627 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter */
2632 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_config()
2633 	const struct scarlett2_config_set *config_set = private->config_set;  in scarlett2_usb_set_config()
2635 		&config_set->items[config_item_num];  in scarlett2_usb_set_config()
2642 	if (!config_item->offset)  in scarlett2_usb_set_config()
2643 		return -EFAULT;  in scarlett2_usb_set_config()
2646 	if (config_item->pbuf) {  in scarlett2_usb_set_config()
2647 		if (!config_set->param_buf_addr)  in scarlett2_usb_set_config()
2648 			return -EFAULT;  in scarlett2_usb_set_config()
2652 			mixer, config_set->param_buf_addr + 1, 1, index);  in scarlett2_usb_set_config()
2658 			mixer, config_set->param_buf_addr, 1, value);  in scarlett2_usb_set_config()
2662 		/* Activate the write through the parameter buffer */  in scarlett2_usb_set_config()
2664 			mixer, config_item->activate);  in scarlett2_usb_set_config()
2668 	 * save and support bit-modification  in scarlett2_usb_set_config()
2672 	cancel_delayed_work_sync(&private->work);  in scarlett2_usb_set_config()
2674 	/* Convert config_item->size in bits to size in bytes and  in scarlett2_usb_set_config()
2677 	if (config_item->size >= 8) {  in scarlett2_usb_set_config()
2678 		size = config_item->size / 8;  in scarlett2_usb_set_config()
2679 		offset = config_item->offset + index * size;  in scarlett2_usb_set_config()
2688 		offset = config_item->offset;  in scarlett2_usb_set_config()
2707 	/* Activate the change */  in scarlett2_usb_set_config()
2708 	err = scarlett2_usb_activate_config(mixer, config_item->activate);  in scarlett2_usb_set_config()
2715 	if (config_set->param_buf_addr)  in scarlett2_usb_set_config()
2718 	/* Schedule the change to be written to NVRAM */  in scarlett2_usb_set_config()
2719 	if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)  in scarlett2_usb_set_config()
2720 		schedule_delayed_work(&private->work, msecs_to_jiffies(2000));  in scarlett2_usb_set_config()
2725 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter with
2732 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_config_buf()
2733 	const struct scarlett2_config_set *config_set = private->config_set;  in scarlett2_usb_set_config_buf()
2735 		&config_set->items[config_item_num];  in scarlett2_usb_set_config_buf()
2742 	if (!config_item->offset)  in scarlett2_usb_set_config_buf()
2743 		return -EFAULT;  in scarlett2_usb_set_config_buf()
2745 	/* Convert config_item->size in bits to size in bytes and  in scarlett2_usb_set_config_buf()
2748 	if (config_item->size >= 8) {  in scarlett2_usb_set_config_buf()
2749 		size = config_item->size / 8;  in scarlett2_usb_set_config_buf()
2750 		offset = config_item->offset + index * size;  in scarlett2_usb_set_config_buf()
2754 		return -EFAULT;  in scarlett2_usb_set_config_buf()
2762 	/* Activate the change */  in scarlett2_usb_set_config_buf()
2763 	return scarlett2_usb_activate_config(mixer, config_item->activate);  in scarlett2_usb_set_config_buf()
2773 		usb_audio_err(mixer->chip, "config save failed: %d\n", err);  in scarlett2_config_save()
2776 /* Delayed work to save config */
2782 	scarlett2_config_save(private->mixer);  in scarlett2_config_save_work()
2785 /* Send a USB message to get sync status; result placed in *sync */
2805 	return !!private->info->mux_assignment[0][0].count;  in scarlett2_has_mixer()
2808 /* Map from mixer value to (db + 80) * 2
2821 /* Send a USB message to get the volumes for all inputs of one mix
2822  * and put the values into private->mix[]
2827 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_mix()
2829 	int num_mixer_in = private->num_mix_in;  in scarlett2_usb_get_mix()
2849 		private->mix[j] = scarlett2_mixer_value_to_db(  in scarlett2_usb_get_mix()
2855 /* Send a USB message to set the volumes for all inputs of one mix
2856  * (values obtained from private->mix[])
2861 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_mix()
2869 	int num_mixer_in = private->num_mix_in;  in scarlett2_usb_set_mix()
2875 			scarlett2_mixer_values[private->mix[j]]  in scarlett2_usb_set_mix()
2883 /* Convert a port number index (per info->port_count) to a hardware ID */
2894 		num -= port_count[port_type][SCARLETT2_PORT_IN];  in scarlett2_mux_src_num_to_id()
2901 /* Convert a hardware ID to a port number index */
2915 			return port_num + id - base;  in scarlett2_mux_id_to_num()
2920 	return -1;  in scarlett2_mux_id_to_num()
2923 /* Convert one mux entry from the interface and load into private->mux[] */
2927 	const struct scarlett2_device_info *info = private->info;  in scarlett2_usb_populate_mux()
2928 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_usb_populate_mux()
2937 	if (dst_idx >= private->num_mux_dsts) {  in scarlett2_usb_populate_mux()
2938 		usb_audio_err(private->mixer->chip,  in scarlett2_usb_populate_mux()
2940 			mux_entry, dst_idx, private->num_mux_dsts);  in scarlett2_usb_populate_mux()
2949 	if (src_idx >= private->num_mux_srcs) {  in scarlett2_usb_populate_mux()
2950 		usb_audio_err(private->mixer->chip,  in scarlett2_usb_populate_mux()
2952 			mux_entry, src_idx, private->num_mux_srcs);  in scarlett2_usb_populate_mux()
2956 	private->mux[dst_idx] = src_idx;  in scarlett2_usb_populate_mux()
2962  * request) is returned in mux_assignment order, but to avoid exposing
2963  * that to userspace, scarlett2_meter_ctl_get() rearranges the data
2970  * - the source is "Off"; therefore we set those values to zero (map
2973  * - the source is assigned to a previous (with respect to the
2975  *   to the value previously reported for that source
2979 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_meter_level_map()
2982 	/* sources already assigned to a destination  in scarlett2_update_meter_level_map()
2994 	for (entry = info->meter_map;  in scarlett2_update_meter_level_map()
2995 	     entry->count;  in scarlett2_update_meter_level_map()
3001 		for (j = 0, mux_idx = entry->start;  in scarlett2_update_meter_level_map()
3002 		     j < entry->count;  in scarlett2_update_meter_level_map()
3007 			    info->line_out_remap_enable &&  in scarlett2_update_meter_level_map()
3008 			    mux_idx < private->num_line_out  in scarlett2_update_meter_level_map()
3009 			) ? info->line_out_unmap[mux_idx]  in scarlett2_update_meter_level_map()
3017 			int mux_src = private->mux[mux_idx];  in scarlett2_update_meter_level_map()
3023 			private->meter_level_map[map_mux_idx] =  in scarlett2_update_meter_level_map()
3029 /* Send USB message to get mux inputs and then populate private->mux[] */
3032 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_mux()
3033 	int count = private->num_mux_dsts;  in scarlett2_usb_get_mux()
3043 	private->mux_updated = 0;  in scarlett2_usb_get_mux()
3062 /* Send USB messages to set mux inputs */
3065 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_mux()
3066 	const struct scarlett2_device_info *info = private->info;  in scarlett2_usb_set_mux()
3067 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_usb_set_mux()
3088 		for (entry = info->mux_assignment[table];  in scarlett2_usb_set_mux()
3089 		     entry->count;  in scarlett2_usb_set_mux()
3092 			int port_type = entry->port_type;  in scarlett2_usb_set_mux()
3093 			int port_idx = entry->start;  in scarlett2_usb_set_mux()
3100 				for (j = 0; j < entry->count; j++)  in scarlett2_usb_set_mux()
3105 			/* Non-empty mux slots use the lower 12 bits  in scarlett2_usb_set_mux()
3109 			for (j = 0; j < entry->count; j++) {  in scarlett2_usb_set_mux()
3111 					port_count, private->mux[mux_idx++]);  in scarlett2_usb_set_mux()
3130 /* Send USB message to get meter levels */
3150 	/* copy, convert to u16 */  in scarlett2_usb_get_meter_levels()
3157 /* For config items with mute=1, xor bits 0 & 1 together to get the
3168 /* helper function to create a new control */
3180 		return -ENOMEM;  in scarlett2_add_new_ctl()
3184 	 * Also, the head.id field is set to 0, as we don't use this field.  in scarlett2_add_new_ctl()
3186 	elem->head.mixer = mixer;  in scarlett2_add_new_ctl()
3187 	elem->control = index;  in scarlett2_add_new_ctl()
3188 	elem->head.id = 0;  in scarlett2_add_new_ctl()
3189 	elem->channels = channels;  in scarlett2_add_new_ctl()
3190 	elem->val_type = USB_MIXER_BESPOKEN;  in scarlett2_add_new_ctl()
3195 		return -ENOMEM;  in scarlett2_add_new_ctl()
3197 	kctl->private_free = snd_usb_mixer_elem_free;  in scarlett2_add_new_ctl()
3199 	strscpy(kctl->id.name, name, sizeof(kctl->id.name));  in scarlett2_add_new_ctl()
3201 	err = snd_usb_mixer_add_control(&elem->head, kctl);  in scarlett2_add_new_ctl()
3217 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_firmware_version_ctl_get()
3218 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_firmware_version_ctl_get()
3220 	ucontrol->value.integer.value[0] = private->firmware_version;  in scarlett2_firmware_version_ctl_get()
3229 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_firmware_version_ctl_info()
3230 	uinfo->count = 1;  in scarlett2_firmware_version_ctl_info()
3256 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_min_firmware_version_ctl_get()
3257 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_min_firmware_version_ctl_get()
3259 	ucontrol->value.integer.value[0] = private->info->min_firmware_version;  in scarlett2_min_firmware_version_ctl_get()
3268 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_min_firmware_version_ctl_info()
3269 	uinfo->count = 1;  in scarlett2_min_firmware_version_ctl_info()
3296 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_sync()
3298 	private->sync_updated = 0;  in scarlett2_update_sync()
3299 	return scarlett2_usb_get_sync_status(mixer, &private->sync);  in scarlett2_update_sync()
3314 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sync_ctl_get()
3315 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_sync_ctl_get()
3316 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sync_ctl_get()
3319 	mutex_lock(&private->data_mutex);  in scarlett2_sync_ctl_get()
3321 	if (private->hwdep_in_use) {  in scarlett2_sync_ctl_get()
3322 		err = -EBUSY;  in scarlett2_sync_ctl_get()
3326 	if (private->sync_updated) {  in scarlett2_sync_ctl_get()
3331 	ucontrol->value.enumerated.item[0] = private->sync;  in scarlett2_sync_ctl_get()
3334 	mutex_unlock(&private->data_mutex);  in scarlett2_sync_ctl_get()
3348 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_sync_ctl()
3355 				     0, 1, "Sync Status", &private->sync_ctl);  in scarlett2_add_sync_ctl()
3364 /* Set the access mode of a control to read-only (val = 0) or
3365  * read-write (val = 1).
3370 		kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;  in scarlett2_set_ctl_access()
3372 		kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;  in scarlett2_set_ctl_access()
3381 	for (i = 0; i < private->info->gain_input_count; i++)  in scarlett2_autogain_is_running()
3382 		if (!private->autogain_status[i])  in scarlett2_autogain_is_running()
3390 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_autogain()
3391 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_autogain()
3396 	private->autogain_updated = 0;  in scarlett2_update_autogain()
3398 	if (!info->gain_input_count)  in scarlett2_update_autogain()
3403 		info->gain_input_count, private->autogain_switch);  in scarlett2_update_autogain()
3408 		info->gain_input_count, raw_autogain_status);  in scarlett2_update_autogain()
3417 	 * subsequent elements correspond to the status value from the  in scarlett2_update_autogain()
3422 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_update_autogain()
3423 		if (private->autogain_switch[i])  in scarlett2_update_autogain()
3424 			private->autogain_status[i] = 0;  in scarlett2_update_autogain()
3426 				private->num_autogain_status_texts - 1)  in scarlett2_update_autogain()
3427 			private->autogain_status[i] =  in scarlett2_update_autogain()
3430 			private->autogain_status[i] =  in scarlett2_update_autogain()
3431 				private->num_autogain_status_texts - 1;  in scarlett2_update_autogain()
3446 		private->ag_targets[i] = -ag_target_values[i];  in scarlett2_update_autogain()
3454 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_update_access()
3455 	const struct scarlett2_device_info *info = private->info;  in scarlett2_autogain_update_access()
3461 		scarlett2_set_ctl_access(private->input_select_ctl, val);  in scarlett2_autogain_update_access()
3464 		for (i = 0; i < info->gain_input_count; i++)  in scarlett2_autogain_update_access()
3465 			scarlett2_set_ctl_access(private->input_link_ctls[i],  in scarlett2_autogain_update_access()
3467 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_autogain_update_access()
3468 		scarlett2_set_ctl_access(private->input_gain_ctls[i], val);  in scarlett2_autogain_update_access()
3469 	for (i = 0; i < info->safe_input_count; i++)  in scarlett2_autogain_update_access()
3470 		scarlett2_set_ctl_access(private->safe_ctls[i], val);  in scarlett2_autogain_update_access()
3471 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_autogain_update_access()
3472 		scarlett2_set_ctl_access(private->level_ctls[i], val);  in scarlett2_autogain_update_access()
3473 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_autogain_update_access()
3474 		scarlett2_set_ctl_access(private->air_ctls[i], val);  in scarlett2_autogain_update_access()
3475 	for (i = 0; i < info->mute_input_count; i++)  in scarlett2_autogain_update_access()
3476 		scarlett2_set_ctl_access(private->input_mute_ctls[i], val);  in scarlett2_autogain_update_access()
3477 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_autogain_update_access()
3478 		scarlett2_set_ctl_access(private->phantom_ctls[i], val);  in scarlett2_autogain_update_access()
3479 	for (i = 0; i < info->dsp_input_count; i++)  in scarlett2_autogain_update_access()
3480 		scarlett2_set_ctl_access(private->dsp_ctls[i], val);  in scarlett2_autogain_update_access()
3486 				private->ag_target_ctls[i], val);  in scarlett2_autogain_update_access()
3489 /* Notify of access mode change for all controls read-only while
3494 	struct snd_card *card = mixer->chip->card;  in scarlett2_autogain_notify_access()
3495 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_notify_access()
3496 	const struct scarlett2_device_info *info = private->info;  in scarlett2_autogain_notify_access()
3502 			       &private->input_select_ctl->id);  in scarlett2_autogain_notify_access()
3505 		for (i = 0; i < info->gain_input_count; i++)  in scarlett2_autogain_notify_access()
3507 				       &private->input_link_ctls[i]->id);  in scarlett2_autogain_notify_access()
3508 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_autogain_notify_access()
3510 			       &private->input_gain_ctls[i]->id);  in scarlett2_autogain_notify_access()
3511 	for (i = 0; i < info->safe_input_count; i++)  in scarlett2_autogain_notify_access()
3513 			       &private->safe_ctls[i]->id);  in scarlett2_autogain_notify_access()
3514 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_autogain_notify_access()
3516 			       &private->level_ctls[i]->id);  in scarlett2_autogain_notify_access()
3517 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_autogain_notify_access()
3519 			       &private->air_ctls[i]->id);  in scarlett2_autogain_notify_access()
3520 	for (i = 0; i < info->dsp_input_count; i++)  in scarlett2_autogain_notify_access()
3522 			       &private->dsp_ctls[i]->id);  in scarlett2_autogain_notify_access()
3523 	for (i = 0; i < info->mute_input_count; i++)  in scarlett2_autogain_notify_access()
3525 			       &private->input_mute_ctls[i]->id);  in scarlett2_autogain_notify_access()
3526 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_autogain_notify_access()
3528 			       &private->phantom_ctls[i]->id);  in scarlett2_autogain_notify_access()
3534 				       &private->ag_target_ctls[i]->id);  in scarlett2_autogain_notify_access()
3543 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_check_autogain_updated()
3546 	if (!private->autogain_updated)  in scarlett2_check_autogain_updated()
3559  * control that is meant to be read-only while autogain is running,
3561  * Return -EPERM if autogain is running.
3571 	if (scarlett2_autogain_is_running(mixer->private_data))  in scarlett2_check_put_during_autogain()
3572 		return -EPERM;  in scarlett2_check_put_during_autogain()
3580 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_info()
3581 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_info()
3582 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_info()
3585 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_info()
3594 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_info()
3601 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_get()
3602 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_get()
3603 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_get()
3606 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_get()
3608 	if (private->hwdep_in_use) {  in scarlett2_autogain_switch_ctl_get()
3609 		err = -EBUSY;  in scarlett2_autogain_switch_ctl_get()
3617 	ucontrol->value.enumerated.item[0] =  in scarlett2_autogain_switch_ctl_get()
3618 		private->autogain_switch[elem->control];  in scarlett2_autogain_switch_ctl_get()
3621 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_get()
3628 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_status_ctl_get()
3629 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_status_ctl_get()
3630 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_status_ctl_get()
3633 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_status_ctl_get()
3635 	if (private->hwdep_in_use) {  in scarlett2_autogain_status_ctl_get()
3636 		err = -EBUSY;  in scarlett2_autogain_status_ctl_get()
3644 	ucontrol->value.enumerated.item[0] =  in scarlett2_autogain_status_ctl_get()
3645 		private->autogain_status[elem->control];  in scarlett2_autogain_status_ctl_get()
3648 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_status_ctl_get()
3655 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_put()
3656 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_put()
3657 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_put()
3659 	int index = elem->control;  in scarlett2_autogain_switch_ctl_put()
3662 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_put()
3664 	if (private->hwdep_in_use) {  in scarlett2_autogain_switch_ctl_put()
3665 		err = -EBUSY;  in scarlett2_autogain_switch_ctl_put()
3674 		err = -EPERM;  in scarlett2_autogain_switch_ctl_put()
3678 	oval = private->autogain_switch[index];  in scarlett2_autogain_switch_ctl_put()
3679 	val = !!ucontrol->value.integer.value[0];  in scarlett2_autogain_switch_ctl_put()
3684 	private->autogain_switch[index] = val;  in scarlett2_autogain_switch_ctl_put()
3686 	/* Send switch change to the device */  in scarlett2_autogain_switch_ctl_put()
3696 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_put()
3703 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_status_ctl_info()
3704 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_autogain_status_ctl_info()
3708 		private->num_autogain_status_texts,  in scarlett2_autogain_status_ctl_info()
3709 		private->config_set->autogain_status_texts);  in scarlett2_autogain_status_ctl_info()
3733 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_ag_target_ctl_info()
3734 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_ag_target_ctl_info()
3735 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ag_target_ctl_info()
3738 	mutex_lock(&private->data_mutex);  in scarlett2_ag_target_ctl_info()
3740 	if (private->hwdep_in_use) {  in scarlett2_ag_target_ctl_info()
3741 		err = -EBUSY;  in scarlett2_ag_target_ctl_info()
3749 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_ag_target_ctl_info()
3750 	uinfo->count = 1;  in scarlett2_ag_target_ctl_info()
3751 	uinfo->value.integer.min = SCARLETT2_AG_TARGET_MIN;  in scarlett2_ag_target_ctl_info()
3752 	uinfo->value.integer.max = 0;  in scarlett2_ag_target_ctl_info()
3753 	uinfo->value.integer.step = 1;  in scarlett2_ag_target_ctl_info()
3756 	mutex_unlock(&private->data_mutex);  in scarlett2_ag_target_ctl_info()
3763 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_ag_target_ctl_get()
3764 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_ag_target_ctl_get()
3765 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ag_target_ctl_get()
3768 	mutex_lock(&private->data_mutex);  in scarlett2_ag_target_ctl_get()
3770 	if (private->hwdep_in_use) {  in scarlett2_ag_target_ctl_get()
3771 		err = -EBUSY;  in scarlett2_ag_target_ctl_get()
3775 	if (private->autogain_updated) {  in scarlett2_ag_target_ctl_get()
3781 	ucontrol->value.integer.value[0] = private->ag_targets[elem->control];  in scarlett2_ag_target_ctl_get()
3784 	mutex_unlock(&private->data_mutex);  in scarlett2_ag_target_ctl_get()
3791 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_ag_target_ctl_put()
3792 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_ag_target_ctl_put()
3793 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ag_target_ctl_put()
3795 	int index = elem->control;  in scarlett2_ag_target_ctl_put()
3798 	mutex_lock(&private->data_mutex);  in scarlett2_ag_target_ctl_put()
3800 	if (private->hwdep_in_use) {  in scarlett2_ag_target_ctl_put()
3801 		err = -EBUSY;  in scarlett2_ag_target_ctl_put()
3809 	oval = private->ag_targets[index];  in scarlett2_ag_target_ctl_put()
3810 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_ag_target_ctl_put()
3816 	private->ag_targets[index] = val;  in scarlett2_ag_target_ctl_put()
3818 	/* Send new value to the device */  in scarlett2_ag_target_ctl_put()
3820 		mixer, scarlett2_ag_target_configs[index], 1, -val);  in scarlett2_ag_target_ctl_put()
3825 	mutex_unlock(&private->data_mutex);  in scarlett2_ag_target_ctl_put()
3848 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_select()
3849 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_select()
3850 	int link_count = info->gain_input_count;  in scarlett2_update_input_select()
3853 	private->input_select_updated = 0;  in scarlett2_update_input_select()
3862 		1, &private->input_select_switch);  in scarlett2_update_input_select()
3868 		link_count, private->input_link_switch);  in scarlett2_update_input_select()
3878 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_get()
3879 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_get()
3880 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_get()
3883 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_get()
3885 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_get()
3886 		err = -EBUSY;  in scarlett2_input_select_ctl_get()
3890 	if (private->input_select_updated) {  in scarlett2_input_select_ctl_get()
3895 	ucontrol->value.enumerated.item[0] = private->input_select_switch;  in scarlett2_input_select_ctl_get()
3898 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_get()
3905 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_put()
3906 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_put()
3907 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_put()
3908 	const struct scarlett2_device_info *info = private->info;  in scarlett2_input_select_ctl_put()
3912 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_put()
3914 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_put()
3915 		err = -EBUSY;  in scarlett2_input_select_ctl_put()
3923 	oval = private->input_select_switch;  in scarlett2_input_select_ctl_put()
3924 	val = ucontrol->value.integer.value[0];  in scarlett2_input_select_ctl_put()
3928 	else if (val >= info->gain_input_count)  in scarlett2_input_select_ctl_put()
3929 		val = info->gain_input_count - 1;  in scarlett2_input_select_ctl_put()
3934 	private->input_select_switch = val;  in scarlett2_input_select_ctl_put()
3936 	/* Send new value to the device */  in scarlett2_input_select_ctl_put()
3944 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_put()
3951 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_info()
3952 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_info()
3953 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_info()
3955 	int inputs = private->info->gain_input_count;  in scarlett2_input_select_ctl_info()
3960 		return -ENOMEM;  in scarlett2_input_select_ctl_info()
3962 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_info()
3964 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_info()
3965 		err = -EBUSY;  in scarlett2_input_select_ctl_info()
3981 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_info()
4000 /* snd_ctl_boolean_mono_info() with autogain-updated check
4001  * (for controls that are read-only while autogain is running)
4006 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_disables_ctl_info()
4007 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_disables_ctl_info()
4008 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_disables_ctl_info()
4011 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_disables_ctl_info()
4013 	if (private->hwdep_in_use) {  in scarlett2_autogain_disables_ctl_info()
4014 		err = -EBUSY;  in scarlett2_autogain_disables_ctl_info()
4025 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_disables_ctl_info()
4032 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_link_ctl_get()
4033 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_link_ctl_get()
4034 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_link_ctl_get()
4037 	mutex_lock(&private->data_mutex);  in scarlett2_input_link_ctl_get()
4039 	if (private->hwdep_in_use) {  in scarlett2_input_link_ctl_get()
4040 		err = -EBUSY;  in scarlett2_input_link_ctl_get()
4044 	if (private->input_select_updated) {  in scarlett2_input_link_ctl_get()
4049 	ucontrol->value.enumerated.item[0] =  in scarlett2_input_link_ctl_get()
4050 		private->input_link_switch[elem->control];  in scarlett2_input_link_ctl_get()
4053 	mutex_unlock(&private->data_mutex);  in scarlett2_input_link_ctl_get()
4060 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_link_ctl_put()
4061 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_link_ctl_put()
4062 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_link_ctl_put()
4064 	int index = elem->control;  in scarlett2_input_link_ctl_put()
4067 	mutex_lock(&private->data_mutex);  in scarlett2_input_link_ctl_put()
4069 	if (private->hwdep_in_use) {  in scarlett2_input_link_ctl_put()
4070 		err = -EBUSY;  in scarlett2_input_link_ctl_put()
4078 	oval = private->input_link_switch[index];  in scarlett2_input_link_ctl_put()
4079 	val = !!ucontrol->value.integer.value[0];  in scarlett2_input_link_ctl_put()
4084 	private->input_link_switch[index] = val;  in scarlett2_input_link_ctl_put()
4092 	mutex_unlock(&private->data_mutex);  in scarlett2_input_link_ctl_put()
4108 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_gain()
4109 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_gain()
4111 	private->input_gain_updated = 0;  in scarlett2_update_input_gain()
4113 	if (!info->gain_input_count)  in scarlett2_update_input_gain()
4118 		info->gain_input_count, private->gain);  in scarlett2_update_input_gain()
4124 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_info()
4125 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_info()
4126 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_info()
4129 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_info()
4131 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_info()
4132 		err = -EBUSY;  in scarlett2_input_gain_ctl_info()
4140 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_input_gain_ctl_info()
4141 	uinfo->count = elem->channels;  in scarlett2_input_gain_ctl_info()
4142 	uinfo->value.integer.min = 0;  in scarlett2_input_gain_ctl_info()
4143 	uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;  in scarlett2_input_gain_ctl_info()
4144 	uinfo->value.integer.step = 1;  in scarlett2_input_gain_ctl_info()
4147 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_info()
4154 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_get()
4155 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_get()
4156 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_get()
4159 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_get()
4161 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_get()
4162 		err = -EBUSY;  in scarlett2_input_gain_ctl_get()
4166 	if (private->input_gain_updated) {  in scarlett2_input_gain_ctl_get()
4171 	ucontrol->value.integer.value[0] =  in scarlett2_input_gain_ctl_get()
4172 		private->gain[elem->control];  in scarlett2_input_gain_ctl_get()
4175 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_get()
4182 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_put()
4183 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_put()
4184 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_put()
4186 	int index = elem->control;  in scarlett2_input_gain_ctl_put()
4189 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_put()
4191 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_put()
4192 		err = -EBUSY;  in scarlett2_input_gain_ctl_put()
4200 	oval = private->gain[index];  in scarlett2_input_gain_ctl_put()
4201 	val = ucontrol->value.integer.value[0];  in scarlett2_input_gain_ctl_put()
4206 	private->gain[index] = val;  in scarlett2_input_gain_ctl_put()
4208 	/* Send gain change to the device */  in scarlett2_input_gain_ctl_put()
4215 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_put()
4234 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_safe()
4235 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_safe()
4237 	private->input_safe_updated = 0;  in scarlett2_update_input_safe()
4239 	if (!info->safe_input_count)  in scarlett2_update_input_safe()
4244 		info->safe_input_count, private->safe_switch);  in scarlett2_update_input_safe()
4250 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_safe_ctl_get()
4251 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_safe_ctl_get()
4252 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_safe_ctl_get()
4255 	mutex_lock(&private->data_mutex);  in scarlett2_safe_ctl_get()
4257 	if (private->hwdep_in_use) {  in scarlett2_safe_ctl_get()
4258 		err = -EBUSY;  in scarlett2_safe_ctl_get()
4262 	if (private->input_safe_updated) {  in scarlett2_safe_ctl_get()
4267 	ucontrol->value.integer.value[0] =  in scarlett2_safe_ctl_get()
4268 		private->safe_switch[elem->control];  in scarlett2_safe_ctl_get()
4271 	mutex_unlock(&private->data_mutex);  in scarlett2_safe_ctl_get()
4278 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_safe_ctl_put()
4279 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_safe_ctl_put()
4280 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_safe_ctl_put()
4282 	int index = elem->control;  in scarlett2_safe_ctl_put()
4285 	mutex_lock(&private->data_mutex);  in scarlett2_safe_ctl_put()
4287 	if (private->hwdep_in_use) {  in scarlett2_safe_ctl_put()
4288 		err = -EBUSY;  in scarlett2_safe_ctl_put()
4296 	oval = private->safe_switch[index];  in scarlett2_safe_ctl_put()
4297 	val = !!ucontrol->value.integer.value[0];  in scarlett2_safe_ctl_put()
4302 	private->safe_switch[index] = val;  in scarlett2_safe_ctl_put()
4304 	/* Send switch change to the device */  in scarlett2_safe_ctl_put()
4311 	mutex_unlock(&private->data_mutex);  in scarlett2_safe_ctl_put()
4327 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_pcm_input_switch()
4330 	private->pcm_input_switch_updated = 0;  in scarlett2_update_pcm_input_switch()
4334 		1, &private->pcm_input_switch);  in scarlett2_update_pcm_input_switch()
4344 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pcm_input_switch_ctl_get()
4345 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pcm_input_switch_ctl_get()
4346 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_pcm_input_switch_ctl_get()
4349 	mutex_lock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_get()
4351 	if (private->pcm_input_switch_updated) {  in scarlett2_pcm_input_switch_ctl_get()
4356 	ucontrol->value.enumerated.item[0] = private->pcm_input_switch;  in scarlett2_pcm_input_switch_ctl_get()
4359 	mutex_unlock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_get()
4366 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pcm_input_switch_ctl_put()
4367 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pcm_input_switch_ctl_put()
4368 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pcm_input_switch_ctl_put()
4372 	mutex_lock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_put()
4374 	if (private->hwdep_in_use) {  in scarlett2_pcm_input_switch_ctl_put()
4375 		err = -EBUSY;  in scarlett2_pcm_input_switch_ctl_put()
4379 	oval = private->pcm_input_switch;  in scarlett2_pcm_input_switch_ctl_put()
4380 	val = !!ucontrol->value.integer.value[0];  in scarlett2_pcm_input_switch_ctl_put()
4385 	private->pcm_input_switch = val;  in scarlett2_pcm_input_switch_ctl_put()
4387 	/* Send switch change to the device */  in scarlett2_pcm_input_switch_ctl_put()
4395 	mutex_unlock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_put()
4425 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_volumes()
4429 	private->vol_updated = 0;  in scarlett2_update_volumes()
4439 		private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,  in scarlett2_update_volumes()
4444 			for (i = 0; i < private->num_line_out; i++)  in scarlett2_update_volumes()
4445 				if (private->vol_sw_hw_switch[i])  in scarlett2_update_volumes()
4446 					private->vol[i] = private->master_vol;  in scarlett2_update_volumes()
4457 		private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,  in scarlett2_update_volumes()
4467 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_info()
4469 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_volume_ctl_info()
4470 	uinfo->count = elem->channels;  in scarlett2_volume_ctl_info()
4471 	uinfo->value.integer.min = 0;  in scarlett2_volume_ctl_info()
4472 	uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;  in scarlett2_volume_ctl_info()
4473 	uinfo->value.integer.step = 1;  in scarlett2_volume_ctl_info()
4480 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_master_volume_ctl_get()
4481 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_master_volume_ctl_get()
4482 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_master_volume_ctl_get()
4485 	mutex_lock(&private->data_mutex);  in scarlett2_master_volume_ctl_get()
4487 	if (private->hwdep_in_use) {  in scarlett2_master_volume_ctl_get()
4488 		err = -EBUSY;  in scarlett2_master_volume_ctl_get()
4492 	if (private->vol_updated) {  in scarlett2_master_volume_ctl_get()
4497 	ucontrol->value.integer.value[0] = private->master_vol;  in scarlett2_master_volume_ctl_get()
4500 	mutex_unlock(&private->data_mutex);  in scarlett2_master_volume_ctl_get()
4508 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_headphone_volume_ctl_get()
4509 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_headphone_volume_ctl_get()
4510 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_headphone_volume_ctl_get()
4513 	mutex_lock(&private->data_mutex);  in scarlett2_headphone_volume_ctl_get()
4515 	if (private->hwdep_in_use) {  in scarlett2_headphone_volume_ctl_get()
4516 		err = -EBUSY;  in scarlett2_headphone_volume_ctl_get()
4520 	if (private->vol_updated) {  in scarlett2_headphone_volume_ctl_get()
4525 	ucontrol->value.integer.value[0] = private->headphone_vol;  in scarlett2_headphone_volume_ctl_get()
4528 	mutex_unlock(&private->data_mutex);  in scarlett2_headphone_volume_ctl_get()
4534 	const struct scarlett2_device_info *info = private->info;  in line_out_remap()
4536 	if (!info->line_out_remap_enable)  in line_out_remap()
4539 	if (index >= private->num_line_out)  in line_out_remap()
4542 	return info->line_out_remap[index];  in line_out_remap()
4548 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_get()
4549 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_volume_ctl_get()
4550 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_volume_ctl_get()
4551 	int index = line_out_remap(private, elem->control);  in scarlett2_volume_ctl_get()
4554 	mutex_lock(&private->data_mutex);  in scarlett2_volume_ctl_get()
4556 	if (private->hwdep_in_use) {  in scarlett2_volume_ctl_get()
4557 		err = -EBUSY;  in scarlett2_volume_ctl_get()
4561 	if (private->vol_updated) {  in scarlett2_volume_ctl_get()
4566 	ucontrol->value.integer.value[0] = private->vol[index];  in scarlett2_volume_ctl_get()
4569 	mutex_unlock(&private->data_mutex);  in scarlett2_volume_ctl_get()
4576 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_put()
4577 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_volume_ctl_put()
4578 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_volume_ctl_put()
4579 	int index = line_out_remap(private, elem->control);  in scarlett2_volume_ctl_put()
4582 	mutex_lock(&private->data_mutex);  in scarlett2_volume_ctl_put()
4584 	if (private->hwdep_in_use) {  in scarlett2_volume_ctl_put()
4585 		err = -EBUSY;  in scarlett2_volume_ctl_put()
4589 	oval = private->vol[index];  in scarlett2_volume_ctl_put()
4590 	val = ucontrol->value.integer.value[0];  in scarlett2_volume_ctl_put()
4595 	private->vol[index] = val;  in scarlett2_volume_ctl_put()
4597 				       index, val - SCARLETT2_VOLUME_BIAS);  in scarlett2_volume_ctl_put()
4602 	mutex_unlock(&private->data_mutex);  in scarlett2_volume_ctl_put()
4607 	db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
4648 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_dim_mute()
4652 	private->dim_mute_updated = 0;  in scarlett2_update_dim_mute()
4659 		SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);  in scarlett2_update_dim_mute()
4664 		private->dim_mute[i] = !!private->dim_mute[i];  in scarlett2_update_dim_mute()
4666 	mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];  in scarlett2_update_dim_mute()
4668 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_update_dim_mute()
4669 		if (private->vol_sw_hw_switch[i])  in scarlett2_update_dim_mute()
4670 			private->mute_switch[i] = mute;  in scarlett2_update_dim_mute()
4678 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mute_ctl_get()
4679 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mute_ctl_get()
4680 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mute_ctl_get()
4681 	int index = line_out_remap(private, elem->control);  in scarlett2_mute_ctl_get()
4684 	mutex_lock(&private->data_mutex);  in scarlett2_mute_ctl_get()
4686 	if (private->hwdep_in_use) {  in scarlett2_mute_ctl_get()
4687 		err = -EBUSY;  in scarlett2_mute_ctl_get()
4691 	if (private->dim_mute_updated) {  in scarlett2_mute_ctl_get()
4696 	ucontrol->value.integer.value[0] = private->mute_switch[index];  in scarlett2_mute_ctl_get()
4699 	mutex_unlock(&private->data_mutex);  in scarlett2_mute_ctl_get()
4706 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mute_ctl_put()
4707 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mute_ctl_put()
4708 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mute_ctl_put()
4709 	int index = line_out_remap(private, elem->control);  in scarlett2_mute_ctl_put()
4712 	mutex_lock(&private->data_mutex);  in scarlett2_mute_ctl_put()
4714 	if (private->hwdep_in_use) {  in scarlett2_mute_ctl_put()
4715 		err = -EBUSY;  in scarlett2_mute_ctl_put()
4719 	oval = private->mute_switch[index];  in scarlett2_mute_ctl_put()
4720 	val = !!ucontrol->value.integer.value[0];  in scarlett2_mute_ctl_put()
4725 	private->mute_switch[index] = val;  in scarlett2_mute_ctl_put()
4727 	/* Send mute change to the device */  in scarlett2_mute_ctl_put()
4734 	mutex_unlock(&private->data_mutex);  in scarlett2_mute_ctl_put()
4750 	private->sw_hw_ctls[index]->vd[0].access &=  in scarlett2_sw_hw_ctl_ro()
4756 	private->sw_hw_ctls[index]->vd[0].access |=  in scarlett2_sw_hw_ctl_rw()
4773 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sw_hw_enum_ctl_get()
4774 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_sw_hw_enum_ctl_get()
4775 	int index = line_out_remap(private, elem->control);  in scarlett2_sw_hw_enum_ctl_get()
4777 	ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];  in scarlett2_sw_hw_enum_ctl_get()
4784 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_vol_ctl_set_writable()
4785 	struct snd_card *card = mixer->chip->card;  in scarlett2_vol_ctl_set_writable()
4789 		private->vol_ctls[index]->vd[0].access |=  in scarlett2_vol_ctl_set_writable()
4791 		private->mute_ctls[index]->vd[0].access |=  in scarlett2_vol_ctl_set_writable()
4794 		private->vol_ctls[index]->vd[0].access &=  in scarlett2_vol_ctl_set_writable()
4796 		private->mute_ctls[index]->vd[0].access &=  in scarlett2_vol_ctl_set_writable()
4803 		       &private->vol_ctls[index]->id);  in scarlett2_vol_ctl_set_writable()
4806 		       &private->mute_ctls[index]->id);  in scarlett2_vol_ctl_set_writable()
4812 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sw_hw_change()
4816 	private->vol_sw_hw_switch[index] = val;  in scarlett2_sw_hw_change()
4818 	/* Change access mode to RO (hardware controlled volume)  in scarlett2_sw_hw_change()
4823 	/* Reset volume/mute to master volume/mute */  in scarlett2_sw_hw_change()
4824 	private->vol[index] = private->master_vol;  in scarlett2_sw_hw_change()
4825 	private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];  in scarlett2_sw_hw_change()
4827 	/* Set SW volume to current HW volume */  in scarlett2_sw_hw_change()
4830 		index, private->master_vol - SCARLETT2_VOLUME_BIAS);  in scarlett2_sw_hw_change()
4834 	/* Set SW mute to current HW mute */  in scarlett2_sw_hw_change()
4837 		index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);  in scarlett2_sw_hw_change()
4841 	/* Send SW/HW switch change to the device */  in scarlett2_sw_hw_change()
4849 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sw_hw_enum_ctl_put()
4850 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_sw_hw_enum_ctl_put()
4851 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sw_hw_enum_ctl_put()
4852 	int ctl_index = elem->control;  in scarlett2_sw_hw_enum_ctl_put()
4856 	mutex_lock(&private->data_mutex);  in scarlett2_sw_hw_enum_ctl_put()
4858 	if (private->hwdep_in_use) {  in scarlett2_sw_hw_enum_ctl_put()
4859 		err = -EBUSY;  in scarlett2_sw_hw_enum_ctl_put()
4863 	oval = private->vol_sw_hw_switch[index];  in scarlett2_sw_hw_enum_ctl_put()
4864 	val = !!ucontrol->value.enumerated.item[0];  in scarlett2_sw_hw_enum_ctl_put()
4874 	mutex_unlock(&private->data_mutex);  in scarlett2_sw_hw_enum_ctl_put()
4890 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_level()
4891 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_level()
4893 	private->input_level_updated = 0;  in scarlett2_update_input_level()
4895 	if (!info->level_input_count)  in scarlett2_update_input_level()
4900 		info->level_input_count + info->level_input_first,  in scarlett2_update_input_level()
4901 		private->level_switch);  in scarlett2_update_input_level()
4910 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_info()
4911 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_info()
4912 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_info()
4915 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_info()
4917 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_info()
4918 		err = -EBUSY;  in scarlett2_level_enum_ctl_info()
4929 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_info()
4936 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_get()
4937 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_get()
4938 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_get()
4939 	const struct scarlett2_device_info *info = private->info;  in scarlett2_level_enum_ctl_get()
4941 	int index = elem->control + info->level_input_first;  in scarlett2_level_enum_ctl_get()
4944 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_get()
4946 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_get()
4947 		err = -EBUSY;  in scarlett2_level_enum_ctl_get()
4951 	if (private->input_level_updated) {  in scarlett2_level_enum_ctl_get()
4956 	ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(  in scarlett2_level_enum_ctl_get()
4957 		private->level_switch[index]);  in scarlett2_level_enum_ctl_get()
4960 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_get()
4967 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_put()
4968 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_put()
4969 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_put()
4970 	const struct scarlett2_device_info *info = private->info;  in scarlett2_level_enum_ctl_put()
4972 	int index = elem->control + info->level_input_first;  in scarlett2_level_enum_ctl_put()
4975 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_put()
4977 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_put()
4978 		err = -EBUSY;  in scarlett2_level_enum_ctl_put()
4986 	oval = private->level_switch[index];  in scarlett2_level_enum_ctl_put()
4987 	val = !!ucontrol->value.enumerated.item[0];  in scarlett2_level_enum_ctl_put()
4992 	private->level_switch[index] = val;  in scarlett2_level_enum_ctl_put()
4994 	/* To set the Gen 4 muteable controls, bit 1 gets set instead */  in scarlett2_level_enum_ctl_put()
4995 	if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)  in scarlett2_level_enum_ctl_put()
4998 	/* Send switch change to the device */  in scarlett2_level_enum_ctl_put()
5005 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_put()
5021 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_pad()
5022 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_pad()
5024 	private->input_pad_updated = 0;  in scarlett2_update_input_pad()
5026 	if (!info->pad_input_count)  in scarlett2_update_input_pad()
5031 		info->pad_input_count, private->pad_switch);  in scarlett2_update_input_pad()
5037 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pad_ctl_get()
5038 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pad_ctl_get()
5039 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pad_ctl_get()
5042 	mutex_lock(&private->data_mutex);  in scarlett2_pad_ctl_get()
5044 	if (private->hwdep_in_use) {  in scarlett2_pad_ctl_get()
5045 		err = -EBUSY;  in scarlett2_pad_ctl_get()
5049 	if (private->input_pad_updated) {  in scarlett2_pad_ctl_get()
5054 	ucontrol->value.integer.value[0] =  in scarlett2_pad_ctl_get()
5055 		private->pad_switch[elem->control];  in scarlett2_pad_ctl_get()
5058 	mutex_unlock(&private->data_mutex);  in scarlett2_pad_ctl_get()
5065 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pad_ctl_put()
5066 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pad_ctl_put()
5067 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pad_ctl_put()
5069 	int index = elem->control;  in scarlett2_pad_ctl_put()
5072 	mutex_lock(&private->data_mutex);  in scarlett2_pad_ctl_put()
5074 	if (private->hwdep_in_use) {  in scarlett2_pad_ctl_put()
5075 		err = -EBUSY;  in scarlett2_pad_ctl_put()
5079 	oval = private->pad_switch[index];  in scarlett2_pad_ctl_put()
5080 	val = !!ucontrol->value.integer.value[0];  in scarlett2_pad_ctl_put()
5085 	private->pad_switch[index] = val;  in scarlett2_pad_ctl_put()
5087 	/* Send switch change to the device */  in scarlett2_pad_ctl_put()
5094 	mutex_unlock(&private->data_mutex);  in scarlett2_pad_ctl_put()
5110 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_air()
5111 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_air()
5113 	private->input_air_updated = 0;  in scarlett2_update_input_air()
5115 	if (!info->air_input_count)  in scarlett2_update_input_air()
5120 		info->air_input_count, private->air_switch);  in scarlett2_update_input_air()
5126 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_ctl_get()
5127 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_ctl_get()
5128 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_ctl_get()
5131 	mutex_lock(&private->data_mutex);  in scarlett2_air_ctl_get()
5133 	if (private->hwdep_in_use) {  in scarlett2_air_ctl_get()
5134 		err = -EBUSY;  in scarlett2_air_ctl_get()
5138 	if (private->input_air_updated) {  in scarlett2_air_ctl_get()
5143 	ucontrol->value.integer.value[0] = private->air_switch[elem->control];  in scarlett2_air_ctl_get()
5146 	mutex_unlock(&private->data_mutex);  in scarlett2_air_ctl_get()
5153 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_ctl_put()
5154 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_ctl_put()
5155 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_ctl_put()
5157 	int index = elem->control;  in scarlett2_air_ctl_put()
5160 	mutex_lock(&private->data_mutex);  in scarlett2_air_ctl_put()
5162 	if (private->hwdep_in_use) {  in scarlett2_air_ctl_put()
5163 		err = -EBUSY;  in scarlett2_air_ctl_put()
5171 	oval = private->air_switch[index];  in scarlett2_air_ctl_put()
5172 	val = ucontrol->value.integer.value[0];  in scarlett2_air_ctl_put()
5177 	private->air_switch[index] = val;  in scarlett2_air_ctl_put()
5179 	/* Send switch change to the device */  in scarlett2_air_ctl_put()
5186 	mutex_unlock(&private->data_mutex);  in scarlett2_air_ctl_put()
5196 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_with_drive_ctl_info()
5197 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_with_drive_ctl_info()
5198 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_with_drive_ctl_info()
5201 	mutex_lock(&private->data_mutex);  in scarlett2_air_with_drive_ctl_info()
5203 	if (private->hwdep_in_use) {  in scarlett2_air_with_drive_ctl_info()
5204 		err = -EBUSY;  in scarlett2_air_with_drive_ctl_info()
5215 	mutex_unlock(&private->data_mutex);  in scarlett2_air_with_drive_ctl_info()
5240 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_dsp()
5241 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_dsp()
5243 	private->input_dsp_updated = 0;  in scarlett2_update_input_dsp()
5245 	if (!info->dsp_input_count)  in scarlett2_update_input_dsp()
5250 		info->dsp_input_count, private->dsp_switch);  in scarlett2_update_input_dsp()
5256 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dsp_ctl_get()
5257 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dsp_ctl_get()
5258 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dsp_ctl_get()
5261 	mutex_lock(&private->data_mutex);  in scarlett2_dsp_ctl_get()
5263 	if (private->hwdep_in_use) {  in scarlett2_dsp_ctl_get()
5264 		err = -EBUSY;  in scarlett2_dsp_ctl_get()
5268 	if (private->input_dsp_updated) {  in scarlett2_dsp_ctl_get()
5273 	ucontrol->value.integer.value[0] = private->dsp_switch[elem->control];  in scarlett2_dsp_ctl_get()
5276 	mutex_unlock(&private->data_mutex);  in scarlett2_dsp_ctl_get()
5283 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dsp_ctl_put()
5284 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dsp_ctl_put()
5285 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dsp_ctl_put()
5287 	int index = elem->control;  in scarlett2_dsp_ctl_put()
5290 	mutex_lock(&private->data_mutex);  in scarlett2_dsp_ctl_put()
5292 	if (private->hwdep_in_use) {  in scarlett2_dsp_ctl_put()
5293 		err = -EBUSY;  in scarlett2_dsp_ctl_put()
5301 	oval = private->dsp_switch[index];  in scarlett2_dsp_ctl_put()
5302 	val = ucontrol->value.integer.value[0];  in scarlett2_dsp_ctl_put()
5307 	private->dsp_switch[index] = val;  in scarlett2_dsp_ctl_put()
5309 	/* Send switch change to the device */  in scarlett2_dsp_ctl_put()
5316 	mutex_unlock(&private->data_mutex);  in scarlett2_dsp_ctl_put()
5332 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_compressor_values()
5333 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_compressor_values()
5336 	if (!info->dsp_input_count)  in scarlett2_update_compressor_values()
5341 		SCARLETT2_COMPRESSOR_PARAM_COUNT * info->dsp_input_count,  in scarlett2_update_compressor_values()
5342 		private->compressor_values);  in scarlett2_update_compressor_values()
5350 		for (j = 0; j < info->dsp_input_count; j++) {  in scarlett2_update_compressor_values()
5352 			int val = private->compressor_values[idx];  in scarlett2_update_compressor_values()
5354 			val >>= param->scale_bits;  in scarlett2_update_compressor_values()
5355 			val = clamp(val, param->min, param->max);  in scarlett2_update_compressor_values()
5356 			private->compressor_values[idx] = val;  in scarlett2_update_compressor_values()
5366 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_compressor_ctl_get()
5367 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_compressor_ctl_get()
5369 	ucontrol->value.integer.value[0] =  in scarlett2_compressor_ctl_get()
5370 		private->compressor_values[elem->control];  in scarlett2_compressor_ctl_get()
5377 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_compressor_ctl_put()
5378 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_compressor_ctl_put()
5379 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_compressor_ctl_put()
5381 	int index = elem->control;  in scarlett2_compressor_ctl_put()
5389 	mutex_lock(&private->data_mutex);  in scarlett2_compressor_ctl_put()
5391 	if (private->hwdep_in_use) {  in scarlett2_compressor_ctl_put()
5392 		err = -EBUSY;  in scarlett2_compressor_ctl_put()
5400 	oval = private->compressor_values[index];  in scarlett2_compressor_ctl_put()
5401 	val = ucontrol->value.integer.value[0];  in scarlett2_compressor_ctl_put()
5405 	private->compressor_values[index] = val;  in scarlett2_compressor_ctl_put()
5407 	scaled_val = val << param->scale_bits;  in scarlett2_compressor_ctl_put()
5409 	/* Send change to the device */  in scarlett2_compressor_ctl_put()
5411 	/* The channel needs to be put in the parameter buffer index  in scarlett2_compressor_ctl_put()
5416 		mixer, private->config_set->param_buf_addr + 1, 1, channel);  in scarlett2_compressor_ctl_put()
5429 	mutex_unlock(&private->data_mutex);  in scarlett2_compressor_ctl_put()
5436 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_compressor_ctl_info()
5437 	int control = elem->control % SCARLETT2_COMPRESSOR_PARAM_COUNT;  in scarlett2_compressor_ctl_info()
5439 	uinfo->type = compressor_params[control].type;  in scarlett2_compressor_ctl_info()
5440 	uinfo->count = 1;  in scarlett2_compressor_ctl_info()
5441 	uinfo->value.integer.min = compressor_params[control].min;  in scarlett2_compressor_ctl_info()
5442 	uinfo->value.integer.max = compressor_params[control].max;  in scarlett2_compressor_ctl_info()
5443 	uinfo->value.integer.step = 1;  in scarlett2_compressor_ctl_info()
5455 /*** DSP Pre-Compressor and PEQ Filter Controls ***/
5460 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_precomp_flt_switch_ctl_get()
5461 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_precomp_flt_switch_ctl_get()
5463 	ucontrol->value.integer.value[0] = private->precomp_flt_switch[elem->control];  in scarlett2_precomp_flt_switch_ctl_get()
5471 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_peq_flt_switch_ctl_get()
5472 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_peq_flt_switch_ctl_get()
5474 	ucontrol->value.integer.value[0] =  in scarlett2_peq_flt_switch_ctl_get()
5475 		private->peq_flt_switch[elem->control];  in scarlett2_peq_flt_switch_ctl_get()
5483 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_precomp_flt_switch_ctl_put()
5484 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_precomp_flt_switch_ctl_put()
5485 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_precomp_flt_switch_ctl_put()
5488 	mutex_lock(&private->data_mutex);  in scarlett2_precomp_flt_switch_ctl_put()
5490 	if (private->hwdep_in_use) {  in scarlett2_precomp_flt_switch_ctl_put()
5491 		err = -EBUSY;  in scarlett2_precomp_flt_switch_ctl_put()
5495 	oval = private->precomp_flt_switch[elem->control];  in scarlett2_precomp_flt_switch_ctl_put()
5496 	val = ucontrol->value.integer.value[0];  in scarlett2_precomp_flt_switch_ctl_put()
5501 	private->precomp_flt_switch[elem->control] = val;  in scarlett2_precomp_flt_switch_ctl_put()
5503 	/* Send change to the device */  in scarlett2_precomp_flt_switch_ctl_put()
5506 		elem->control, val);  in scarlett2_precomp_flt_switch_ctl_put()
5511 	mutex_unlock(&private->data_mutex);  in scarlett2_precomp_flt_switch_ctl_put()
5518 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_peq_flt_switch_ctl_put()
5519 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_peq_flt_switch_ctl_put()
5520 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_peq_flt_switch_ctl_put()
5523 	mutex_lock(&private->data_mutex);  in scarlett2_peq_flt_switch_ctl_put()
5525 	if (private->hwdep_in_use) {  in scarlett2_peq_flt_switch_ctl_put()
5526 		err = -EBUSY;  in scarlett2_peq_flt_switch_ctl_put()
5530 	oval = private->peq_flt_switch[elem->control];  in scarlett2_peq_flt_switch_ctl_put()
5531 	val = ucontrol->value.integer.value[0];  in scarlett2_peq_flt_switch_ctl_put()
5536 	private->peq_flt_switch[elem->control] = val;  in scarlett2_peq_flt_switch_ctl_put()
5538 	/* Send change to the device */  in scarlett2_peq_flt_switch_ctl_put()
5541 		elem->control, val);  in scarlett2_peq_flt_switch_ctl_put()
5546 	mutex_unlock(&private->data_mutex);  in scarlett2_peq_flt_switch_ctl_put()
5568 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_filter_values()
5569 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_filter_values()
5575 	if (!info->dsp_input_count)  in scarlett2_update_filter_values()
5581 		info->dsp_input_count, private->precomp_flt_switch);  in scarlett2_update_filter_values()
5587 		info->dsp_input_count * info->peq_flt_count,  in scarlett2_update_filter_values()
5588 		private->peq_flt_switch);  in scarlett2_update_filter_values()
5592 	/* Get pre-compressor filter values directly */  in scarlett2_update_filter_values()
5595 		info->dsp_input_count *  in scarlett2_update_filter_values()
5596 			info->precomp_flt_count *  in scarlett2_update_filter_values()
5598 		private->precomp_flt_values);  in scarlett2_update_filter_values()
5603 	/* PEQ filter values need to be copied via buffer because of  in scarlett2_update_filter_values()
5604 	 * padding after peq_flt_count up to peq_flt_total_count  in scarlett2_update_filter_values()
5608 		info->dsp_input_count *  in scarlett2_update_filter_values()
5609 			info->peq_flt_total_count *  in scarlett2_update_filter_values()
5615 	for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) {  in scarlett2_update_filter_values()
5617 			  info->peq_flt_total_count *  in scarlett2_update_filter_values()
5619 		for (j = 0; j < info->peq_flt_count; j++)  in scarlett2_update_filter_values()
5623 				private->peq_flt_values[dst_idx] =  in scarlett2_update_filter_values()
5633 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_precomp_flt_ctl_get()
5634 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_precomp_flt_ctl_get()
5637 	for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;  in scarlett2_precomp_flt_ctl_get()
5640 		ucontrol->value.integer.value[i] =  in scarlett2_precomp_flt_ctl_get()
5641 			private->precomp_flt_values[idx];  in scarlett2_precomp_flt_ctl_get()
5649 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_peq_flt_ctl_get()
5650 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_peq_flt_ctl_get()
5653 	for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;  in scarlett2_peq_flt_ctl_get()
5656 		ucontrol->value.integer.value[i] =  in scarlett2_peq_flt_ctl_get()
5657 			private->peq_flt_values[idx];  in scarlett2_peq_flt_ctl_get()
5665 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_precomp_flt_ctl_put()
5666 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_precomp_flt_ctl_put()
5667 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_precomp_flt_ctl_put()
5669 	int index = elem->control * SCARLETT2_BIQUAD_COEFFS;  in scarlett2_precomp_flt_ctl_put()
5672 	mutex_lock(&private->data_mutex);  in scarlett2_precomp_flt_ctl_put()
5674 	if (private->hwdep_in_use) {  in scarlett2_precomp_flt_ctl_put()
5675 		err = -EBUSY;  in scarlett2_precomp_flt_ctl_put()
5685 		oval = private->precomp_flt_values[index + i];  in scarlett2_precomp_flt_ctl_put()
5686 		val = ucontrol->value.integer.value[i];  in scarlett2_precomp_flt_ctl_put()
5696 		private->precomp_flt_values[index + i] =  in scarlett2_precomp_flt_ctl_put()
5697 			ucontrol->value.integer.value[i];  in scarlett2_precomp_flt_ctl_put()
5699 	/* Send change to the device */  in scarlett2_precomp_flt_ctl_put()
5701 		mixer, private->config_set->param_buf_addr, 1, index);  in scarlett2_precomp_flt_ctl_put()
5708 		&private->precomp_flt_values[index]);  in scarlett2_precomp_flt_ctl_put()
5714 	mutex_unlock(&private->data_mutex);  in scarlett2_precomp_flt_ctl_put()
5721 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_peq_flt_ctl_put()
5722 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_peq_flt_ctl_put()
5723 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_peq_flt_ctl_put()
5724 	const struct scarlett2_device_info *info = private->info;  in scarlett2_peq_flt_ctl_put()
5726 	int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS;  in scarlett2_peq_flt_ctl_put()
5728 		elem->control /  in scarlett2_peq_flt_ctl_put()
5729 		info->peq_flt_count *  in scarlett2_peq_flt_ctl_put()
5730 		info->peq_flt_total_count +  in scarlett2_peq_flt_ctl_put()
5731 		elem->control % info->peq_flt_count  in scarlett2_peq_flt_ctl_put()
5735 	mutex_lock(&private->data_mutex);  in scarlett2_peq_flt_ctl_put()
5737 	if (private->hwdep_in_use) {  in scarlett2_peq_flt_ctl_put()
5738 		err = -EBUSY;  in scarlett2_peq_flt_ctl_put()
5748 		oval = private->peq_flt_values[src_index + i];  in scarlett2_peq_flt_ctl_put()
5749 		val = ucontrol->value.integer.value[i];  in scarlett2_peq_flt_ctl_put()
5759 		private->peq_flt_values[src_index + i] =  in scarlett2_peq_flt_ctl_put()
5760 			ucontrol->value.integer.value[i];  in scarlett2_peq_flt_ctl_put()
5762 	/* Send change to the device */  in scarlett2_peq_flt_ctl_put()
5764 		mixer, private->config_set->param_buf_addr, 1, dst_index);  in scarlett2_peq_flt_ctl_put()
5771 		&private->peq_flt_values[src_index]);  in scarlett2_peq_flt_ctl_put()
5777 	mutex_unlock(&private->data_mutex);  in scarlett2_peq_flt_ctl_put()
5784 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_flt_ctl_info()
5785 	uinfo->count = SCARLETT2_BIQUAD_COEFFS;  in scarlett2_flt_ctl_info()
5786 	uinfo->value.integer.min = INT_MIN;  in scarlett2_flt_ctl_info()
5787 	uinfo->value.integer.max = INT_MAX;  in scarlett2_flt_ctl_info()
5788 	uinfo->value.integer.step = 1;  in scarlett2_flt_ctl_info()
5812 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_mute()
5813 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_mute()
5815 	private->input_mute_updated = 0;  in scarlett2_update_input_mute()
5817 	if (!info->mute_input_count)  in scarlett2_update_input_mute()
5822 		info->mute_input_count, private->input_mute_switch);  in scarlett2_update_input_mute()
5828 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_mute_ctl_get()
5829 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_mute_ctl_get()
5830 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_mute_ctl_get()
5833 	mutex_lock(&private->data_mutex);  in scarlett2_input_mute_ctl_get()
5835 	if (private->hwdep_in_use) {  in scarlett2_input_mute_ctl_get()
5836 		err = -EBUSY;  in scarlett2_input_mute_ctl_get()
5840 	if (private->input_mute_updated) {  in scarlett2_input_mute_ctl_get()
5845 	ucontrol->value.integer.value[0] =  in scarlett2_input_mute_ctl_get()
5846 		private->input_mute_switch[elem->control];  in scarlett2_input_mute_ctl_get()
5849 	mutex_unlock(&private->data_mutex);  in scarlett2_input_mute_ctl_get()
5856 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_mute_ctl_put()
5857 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_mute_ctl_put()
5858 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_mute_ctl_put()
5860 	int index = elem->control;  in scarlett2_input_mute_ctl_put()
5863 	mutex_lock(&private->data_mutex);  in scarlett2_input_mute_ctl_put()
5865 	if (private->hwdep_in_use) {  in scarlett2_input_mute_ctl_put()
5866 		err = -EBUSY;  in scarlett2_input_mute_ctl_put()
5874 	oval = private->input_mute_switch[index];  in scarlett2_input_mute_ctl_put()
5875 	val = ucontrol->value.integer.value[0];  in scarlett2_input_mute_ctl_put()
5880 	private->input_mute_switch[index] = val;  in scarlett2_input_mute_ctl_put()
5882 	/* Send switch change to the device */  in scarlett2_input_mute_ctl_put()
5890 	mutex_unlock(&private->data_mutex);  in scarlett2_input_mute_ctl_put()
5906 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_phantom()
5907 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_phantom()
5910 	private->input_phantom_updated = 0;  in scarlett2_update_input_phantom()
5912 	if (!info->phantom_count)  in scarlett2_update_input_phantom()
5917 		info->phantom_count, private->phantom_switch);  in scarlett2_update_input_phantom()
5925 			1, &private->phantom_persistence);  in scarlett2_update_input_phantom()
5937 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_is_switching()
5938 	int index = line_num / info->inputs_per_phantom;  in scarlett2_phantom_is_switching()
5940 	return !!(private->phantom_switch[index] & 0x02);  in scarlett2_phantom_is_switching()
5946 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_update_access()
5947 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_update_access()
5951 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_phantom_update_access()
5954 		scarlett2_set_ctl_access(private->autogain_ctls[i], val);  in scarlett2_phantom_update_access()
5963 	struct snd_card *card = mixer->chip->card;  in scarlett2_phantom_notify_access()
5964 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_notify_access()
5965 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_notify_access()
5968 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_phantom_notify_access()
5970 			       &private->autogain_ctls[i]->id);  in scarlett2_phantom_notify_access()
5979 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_check_input_phantom_updated()
5982 	if (!private->input_phantom_updated)  in scarlett2_check_input_phantom_updated()
5997 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_ctl_get()
5998 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_ctl_get()
5999 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_ctl_get()
6002 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_ctl_get()
6004 	if (private->hwdep_in_use) {  in scarlett2_phantom_ctl_get()
6005 		err = -EBUSY;  in scarlett2_phantom_ctl_get()
6013 	ucontrol->value.integer.value[0] = scarlett2_decode_muteable(  in scarlett2_phantom_ctl_get()
6014 		private->phantom_switch[elem->control]);  in scarlett2_phantom_ctl_get()
6017 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_ctl_get()
6024 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_ctl_put()
6025 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_ctl_put()
6026 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_ctl_put()
6027 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_ctl_put()
6029 	int index = elem->control;  in scarlett2_phantom_ctl_put()
6032 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_ctl_put()
6034 	if (private->hwdep_in_use) {  in scarlett2_phantom_ctl_put()
6035 		err = -EBUSY;  in scarlett2_phantom_ctl_put()
6043 	oval = private->phantom_switch[index];  in scarlett2_phantom_ctl_put()
6044 	val = !!ucontrol->value.integer.value[0];  in scarlett2_phantom_ctl_put()
6049 	private->phantom_switch[index] = val;  in scarlett2_phantom_ctl_put()
6051 	/* To set the Gen 4 muteable controls, bit 1 gets set */  in scarlett2_phantom_ctl_put()
6052 	if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)  in scarlett2_phantom_ctl_put()
6055 	/* Send switch change to the device */  in scarlett2_phantom_ctl_put()
6057 				       index + info->phantom_first, val);  in scarlett2_phantom_ctl_put()
6065 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_ctl_put()
6082 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_persistence_ctl_get()
6083 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_phantom_persistence_ctl_get()
6085 	ucontrol->value.integer.value[0] = private->phantom_persistence;  in scarlett2_phantom_persistence_ctl_get()
6092 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_persistence_ctl_put()
6093 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_persistence_ctl_put()
6094 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_persistence_ctl_put()
6096 	int index = elem->control;  in scarlett2_phantom_persistence_ctl_put()
6099 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_persistence_ctl_put()
6101 	if (private->hwdep_in_use) {  in scarlett2_phantom_persistence_ctl_put()
6102 		err = -EBUSY;  in scarlett2_phantom_persistence_ctl_put()
6106 	oval = private->phantom_persistence;  in scarlett2_phantom_persistence_ctl_put()
6107 	val = !!ucontrol->value.integer.value[0];  in scarlett2_phantom_persistence_ctl_put()
6112 	private->phantom_persistence = val;  in scarlett2_phantom_persistence_ctl_put()
6114 	/* Send switch change to the device */  in scarlett2_phantom_persistence_ctl_put()
6121 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_persistence_ctl_put()
6137 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_monitor_other()
6138 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_monitor_other()
6151 	private->monitor_other_updated = 0;  in scarlett2_update_monitor_other()
6156 	if (!info->has_speaker_switching)  in scarlett2_update_monitor_other()
6172 		private->speaker_switching_switch = 0;  in scarlett2_update_monitor_other()
6174 		private->speaker_switching_switch = monitor_other_switch[0] + 1;  in scarlett2_update_monitor_other()
6176 	if (info->has_talkback) {  in scarlett2_update_monitor_other()
6181 			private->talkback_switch = 0;  in scarlett2_update_monitor_other()
6183 			private->talkback_switch = monitor_other_switch[1] + 1;  in scarlett2_update_monitor_other()
6190 		for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)  in scarlett2_update_monitor_other()
6191 			private->talkback_map[i] = bitmap & 1;  in scarlett2_update_monitor_other()
6210 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_speaker_switch_enum_ctl_get()
6211 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_speaker_switch_enum_ctl_get()
6212 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enum_ctl_get()
6215 	mutex_lock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_get()
6217 	if (private->hwdep_in_use) {  in scarlett2_speaker_switch_enum_ctl_get()
6218 		err = -EBUSY;  in scarlett2_speaker_switch_enum_ctl_get()
6222 	if (private->monitor_other_updated) {  in scarlett2_speaker_switch_enum_ctl_get()
6227 	ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;  in scarlett2_speaker_switch_enum_ctl_get()
6230 	mutex_unlock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_get()
6235  * to HW volume and disable those controls
6239 	struct snd_card *card = mixer->chip->card;  in scarlett2_speaker_switch_enable()
6240 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enable()
6246 		/* switch the main/alt speakers to HW volume */  in scarlett2_speaker_switch_enable()
6247 		if (!private->vol_sw_hw_switch[index]) {  in scarlett2_speaker_switch_enable()
6248 			err = scarlett2_sw_hw_change(private->mixer, i, 1);  in scarlett2_speaker_switch_enable()
6258 			       &private->sw_hw_ctls[i]->id);  in scarlett2_speaker_switch_enable()
6261 	/* when the next monitor-other notify comes in, update the mux  in scarlett2_speaker_switch_enable()
6264 	private->speaker_switching_switched = 1;  in scarlett2_speaker_switch_enable()
6274 	struct snd_card *card = mixer->chip->card;  in scarlett2_speaker_switch_disable()
6275 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_disable()
6282 			       &private->sw_hw_ctls[i]->id);  in scarlett2_speaker_switch_disable()
6285 	/* when the next monitor-other notify comes in, update the mux  in scarlett2_speaker_switch_disable()
6288 	private->speaker_switching_switched = 1;  in scarlett2_speaker_switch_disable()
6294 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_speaker_switch_enum_ctl_put()
6295 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_speaker_switch_enum_ctl_put()
6296 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enum_ctl_put()
6300 	mutex_lock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_put()
6302 	if (private->hwdep_in_use) {  in scarlett2_speaker_switch_enum_ctl_put()
6303 		err = -EBUSY;  in scarlett2_speaker_switch_enum_ctl_put()
6307 	oval = private->speaker_switching_switch;  in scarlett2_speaker_switch_enum_ctl_put()
6308 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_speaker_switch_enum_ctl_put()
6313 	private->speaker_switching_switch = val;  in scarlett2_speaker_switch_enum_ctl_put()
6339 	mutex_unlock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_put()
6353 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_speaker_switch_ctl()
6354 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_speaker_switch_ctl()
6356 	if (!info->has_speaker_switching)  in scarlett2_add_speaker_switch_ctl()
6362 		&private->speaker_switching_ctl);  in scarlett2_add_speaker_switch_ctl()
6380 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_enum_ctl_get()
6381 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_enum_ctl_get()
6382 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_enum_ctl_get()
6385 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_get()
6387 	if (private->hwdep_in_use) {  in scarlett2_talkback_enum_ctl_get()
6388 		err = -EBUSY;  in scarlett2_talkback_enum_ctl_get()
6392 	if (private->monitor_other_updated) {  in scarlett2_talkback_enum_ctl_get()
6397 	ucontrol->value.enumerated.item[0] = private->talkback_switch;  in scarlett2_talkback_enum_ctl_get()
6400 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_get()
6407 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_enum_ctl_put()
6408 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_enum_ctl_put()
6409 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_enum_ctl_put()
6413 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_put()
6415 	if (private->hwdep_in_use) {  in scarlett2_talkback_enum_ctl_put()
6416 		err = -EBUSY;  in scarlett2_talkback_enum_ctl_put()
6420 	oval = private->talkback_switch;  in scarlett2_talkback_enum_ctl_put()
6421 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_talkback_enum_ctl_put()
6426 	private->talkback_switch = val;  in scarlett2_talkback_enum_ctl_put()
6443 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_put()
6458 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_map_ctl_get()
6459 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_map_ctl_get()
6460 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_map_ctl_get()
6461 	int index = elem->control;  in scarlett2_talkback_map_ctl_get()
6463 	ucontrol->value.integer.value[0] = private->talkback_map[index];  in scarlett2_talkback_map_ctl_get()
6471 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_map_ctl_put()
6472 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_map_ctl_put()
6473 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_map_ctl_put()
6474 	int index = elem->control;  in scarlett2_talkback_map_ctl_put()
6478 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_map_ctl_put()
6480 	if (private->hwdep_in_use) {  in scarlett2_talkback_map_ctl_put()
6481 		err = -EBUSY;  in scarlett2_talkback_map_ctl_put()
6485 	oval = private->talkback_map[index];  in scarlett2_talkback_map_ctl_put()
6486 	val = !!ucontrol->value.integer.value[0];  in scarlett2_talkback_map_ctl_put()
6491 	private->talkback_map[index] = val;  in scarlett2_talkback_map_ctl_put()
6493 	for (i = 0; i < private->num_mix_out; i++)  in scarlett2_talkback_map_ctl_put()
6494 		bitmap |= private->talkback_map[i] << i;  in scarlett2_talkback_map_ctl_put()
6496 	/* Send updated bitmap to the device */  in scarlett2_talkback_map_ctl_put()
6503 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_map_ctl_put()
6517 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_talkback_ctls()
6518 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_talkback_ctls()
6522 	if (!info->has_talkback)  in scarlett2_add_talkback_ctls()
6528 		&private->talkback_ctl);  in scarlett2_add_talkback_ctls()
6532 	for (i = 0; i < private->num_mix_out; i++) {  in scarlett2_add_talkback_ctls()
6549 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dim_mute_ctl_get()
6550 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dim_mute_ctl_get()
6551 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dim_mute_ctl_get()
6554 	mutex_lock(&private->data_mutex);  in scarlett2_dim_mute_ctl_get()
6556 	if (private->hwdep_in_use) {  in scarlett2_dim_mute_ctl_get()
6557 		err = -EBUSY;  in scarlett2_dim_mute_ctl_get()
6561 	if (private->dim_mute_updated) {  in scarlett2_dim_mute_ctl_get()
6566 	ucontrol->value.integer.value[0] = private->dim_mute[elem->control];  in scarlett2_dim_mute_ctl_get()
6569 	mutex_unlock(&private->data_mutex);  in scarlett2_dim_mute_ctl_get()
6576 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dim_mute_ctl_put()
6577 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dim_mute_ctl_put()
6578 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dim_mute_ctl_put()
6579 	int index = elem->control;  in scarlett2_dim_mute_ctl_put()
6582 	mutex_lock(&private->data_mutex);  in scarlett2_dim_mute_ctl_put()
6584 	if (private->hwdep_in_use) {  in scarlett2_dim_mute_ctl_put()
6585 		err = -EBUSY;  in scarlett2_dim_mute_ctl_put()
6589 	oval = private->dim_mute[index];  in scarlett2_dim_mute_ctl_put()
6590 	val = !!ucontrol->value.integer.value[0];  in scarlett2_dim_mute_ctl_put()
6595 	private->dim_mute[index] = val;  in scarlett2_dim_mute_ctl_put()
6597 	/* Send switch change to the device */  in scarlett2_dim_mute_ctl_put()
6604 		for (i = 0; i < private->num_line_out; i++) {  in scarlett2_dim_mute_ctl_put()
6607 			if (private->vol_sw_hw_switch[line_index]) {  in scarlett2_dim_mute_ctl_put()
6608 				private->mute_switch[line_index] = val;  in scarlett2_dim_mute_ctl_put()
6609 				snd_ctl_notify(mixer->chip->card,  in scarlett2_dim_mute_ctl_put()
6611 					       &private->mute_ctls[i]->id);  in scarlett2_dim_mute_ctl_put()
6616 	mutex_unlock(&private->data_mutex);  in scarlett2_dim_mute_ctl_put()
6632 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_line_out_ctls()
6633 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_line_out_ctls()
6643 					    0, 1, s, &private->master_vol_ctl);  in scarlett2_add_line_out_ctls()
6655 					    &private->headphone_vol_ctl);  in scarlett2_add_line_out_ctls()
6661 	 * has per-channel line-out volume controls.  in scarlett2_add_line_out_ctls()
6668 	for (i = 0; i < private->num_line_out; i++) {  in scarlett2_add_line_out_ctls()
6672 		if (info->line_out_descrs[i])  in scarlett2_add_line_out_ctls()
6675 				 i + 1, info->line_out_descrs[i]);  in scarlett2_add_line_out_ctls()
6682 					    i, 1, s, &private->vol_ctls[i]);  in scarlett2_add_line_out_ctls()
6693 					    &private->mute_ctls[i]);  in scarlett2_add_line_out_ctls()
6701 			/* Make the fader and mute controls read-only if the  in scarlett2_add_line_out_ctls()
6702 			 * SW/HW switch is set to HW  in scarlett2_add_line_out_ctls()
6704 			if (private->vol_sw_hw_switch[index])  in scarlett2_add_line_out_ctls()
6713 						    &private->sw_hw_ctls[i]);  in scarlett2_add_line_out_ctls()
6717 			/* Make the switch read-only if the line is  in scarlett2_add_line_out_ctls()
6720 			if (private->speaker_switching_switch && i < 4)  in scarlett2_add_line_out_ctls()
6731 				&private->dim_mute_ctls[i]);  in scarlett2_add_line_out_ctls()
6743 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_dsp_ctls()
6744 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_dsp_ctls()
6756 		scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name);  in scarlett2_add_dsp_ctls()
6760 			1, s, &private->compressor_ctls[idx]);  in scarlett2_add_dsp_ctls()
6766 	scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp");  in scarlett2_add_dsp_ctls()
6769 		i, 1, s, &private->precomp_flt_switch_ctls[i]);  in scarlett2_add_dsp_ctls()
6776 		i, 1, s, &private->peq_flt_switch_ctls[i]);  in scarlett2_add_dsp_ctls()
6781 	for (j = 0; j < info->precomp_flt_count; j++) {  in scarlett2_add_dsp_ctls()
6782 		scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1);  in scarlett2_add_dsp_ctls()
6785 			i * info->precomp_flt_count + j,  in scarlett2_add_dsp_ctls()
6786 			1, s, &private->precomp_flt_switch_ctls[j]);  in scarlett2_add_dsp_ctls()
6791 	for (j = 0; j < info->peq_flt_count; j++) {  in scarlett2_add_dsp_ctls()
6795 			i * info->peq_flt_count + j,  in scarlett2_add_dsp_ctls()
6796 			1, s, &private->peq_flt_switch_ctls[j]);  in scarlett2_add_dsp_ctls()
6806 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_line_in_ctls()
6807 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_line_in_ctls()
6811 	const char *fmt2 = "Line In %d-%d %s Capture %s";  in scarlett2_add_line_in_ctls()
6814 	for (i = 0; i < info->level_input_count; i++) {  in scarlett2_add_line_in_ctls()
6815 		scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,  in scarlett2_add_line_in_ctls()
6818 					    i, 1, s, &private->level_ctls[i]);  in scarlett2_add_line_in_ctls()
6824 	for (i = 0; i < info->pad_input_count; i++) {  in scarlett2_add_line_in_ctls()
6827 					    i, 1, s, &private->pad_ctls[i]);  in scarlett2_add_line_in_ctls()
6833 	for (i = 0; i < info->air_input_count; i++) {  in scarlett2_add_line_in_ctls()
6834 		scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,  in scarlett2_add_line_in_ctls()
6835 			  "Air", info->air_option ? "Enum" : "Switch");  in scarlett2_add_line_in_ctls()
6837 			mixer, &scarlett2_air_ctl[info->air_option],  in scarlett2_add_line_in_ctls()
6838 			i, 1, s, &private->air_ctls[i]);  in scarlett2_add_line_in_ctls()
6844 	for (i = 0; i < info->dsp_input_count; i++) {  in scarlett2_add_line_in_ctls()
6847 					    i, 1, s, &private->dsp_ctls[i]);  in scarlett2_add_line_in_ctls()
6857 	for (i = 0; i < info->mute_input_count; i++) {  in scarlett2_add_line_in_ctls()
6861 			i, 1, s, &private->input_mute_ctls[i]);  in scarlett2_add_line_in_ctls()
6867 	if (info->inputs_per_phantom == 1) {  in scarlett2_add_line_in_ctls()
6868 		for (i = 0; i < info->phantom_count; i++) {  in scarlett2_add_line_in_ctls()
6870 				  i + 1 + info->phantom_first,  in scarlett2_add_line_in_ctls()
6874 				i, 1, s, &private->phantom_ctls[i]);  in scarlett2_add_line_in_ctls()
6878 	} else if (info->inputs_per_phantom > 1) {  in scarlett2_add_line_in_ctls()
6879 		for (i = 0; i < info->phantom_count; i++) {  in scarlett2_add_line_in_ctls()
6880 			int from = i * info->inputs_per_phantom + 1;  in scarlett2_add_line_in_ctls()
6881 			int to = (i + 1) * info->inputs_per_phantom;  in scarlett2_add_line_in_ctls()  local
6883 			scnprintf(s, sizeof(s), fmt2, from, to,  in scarlett2_add_line_in_ctls()
6887 				i, 1, s, &private->phantom_ctls[i]);  in scarlett2_add_line_in_ctls()
6892 	if (info->phantom_count &&  in scarlett2_add_line_in_ctls()
6908 			&private->input_select_ctl);  in scarlett2_add_line_in_ctls()
6915 		for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_add_line_in_ctls()
6920 				i, 1, s, &private->input_link_ctls[i]);  in scarlett2_add_line_in_ctls()
6926 	/* Add software-controllable input gain controls */  in scarlett2_add_line_in_ctls()
6927 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_add_line_in_ctls()
6932 			i, 1, s, &private->input_gain_ctls[i]);  in scarlett2_add_line_in_ctls()
6935 		private->input_gain_ctls[i]->tlv.p =  in scarlett2_add_line_in_ctls()
6936 			private->config_set->input_gain_tlv;  in scarlett2_add_line_in_ctls()
6942 			i, 1, s, &private->autogain_ctls[i]);  in scarlett2_add_line_in_ctls()
6950 			i, 1, s, &private->autogain_status_ctls[i]);  in scarlett2_add_line_in_ctls()
6962 				i, 1, s, &private->ag_target_ctls[i]);  in scarlett2_add_line_in_ctls()
6967 	/* Add safe-mode input switch controls */  in scarlett2_add_line_in_ctls()
6968 	for (i = 0; i < info->safe_input_count; i++) {  in scarlett2_add_line_in_ctls()
6973 			i, 1, s, &private->safe_ctls[i]);  in scarlett2_add_line_in_ctls()
6984 			&private->pcm_input_switch_ctl);  in scarlett2_add_line_in_ctls()
6996 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_mix()
6999 	private->mix_updated = 0;  in scarlett2_update_mix()
7001 	for (i = 0; i < private->num_mix_out; i++) {  in scarlett2_update_mix()
7013 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_info()
7015 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_mixer_ctl_info()
7016 	uinfo->count = elem->channels;  in scarlett2_mixer_ctl_info()
7017 	uinfo->value.integer.min = 0;  in scarlett2_mixer_ctl_info()
7018 	uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;  in scarlett2_mixer_ctl_info()
7019 	uinfo->value.integer.step = 1;  in scarlett2_mixer_ctl_info()
7026 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_get()
7027 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mixer_ctl_get()
7028 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mixer_ctl_get()
7031 	mutex_lock(&private->data_mutex);  in scarlett2_mixer_ctl_get()
7033 	if (private->hwdep_in_use) {  in scarlett2_mixer_ctl_get()
7034 		err = -EBUSY;  in scarlett2_mixer_ctl_get()
7038 	if (private->mix_updated) {  in scarlett2_mixer_ctl_get()
7043 	ucontrol->value.integer.value[0] = private->mix[elem->control];  in scarlett2_mixer_ctl_get()
7046 	mutex_unlock(&private->data_mutex);  in scarlett2_mixer_ctl_get()
7053 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_put()
7054 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mixer_ctl_put()
7055 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mixer_ctl_put()
7057 	int index = elem->control;  in scarlett2_mixer_ctl_put()
7059 	mutex_lock(&private->data_mutex);  in scarlett2_mixer_ctl_put()
7061 	if (private->hwdep_in_use) {  in scarlett2_mixer_ctl_put()
7062 		err = -EBUSY;  in scarlett2_mixer_ctl_put()
7066 	oval = private->mix[index];  in scarlett2_mixer_ctl_put()
7067 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_mixer_ctl_put()
7069 	mix_num = index / private->num_mix_in;  in scarlett2_mixer_ctl_put()
7074 	private->mix[index] = val;  in scarlett2_mixer_ctl_put()
7080 	mutex_unlock(&private->data_mutex);  in scarlett2_mixer_ctl_put()
7104 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_mixer_ctls()
7109 	for (i = 0, index = 0; i < private->num_mix_out; i++)  in scarlett2_add_mixer_ctls()
7110 		for (j = 0; j < private->num_mix_in; j++, index++) {  in scarlett2_add_mixer_ctls()
7116 						    &private->mix_ctls[index]);  in scarlett2_add_mixer_ctls()
7128 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_direct_monitor()
7130 	private->direct_monitor_updated = 0;  in scarlett2_update_direct_monitor()
7132 	if (!private->info->direct_monitor)  in scarlett2_update_direct_monitor()
7137 		1, &private->direct_monitor_switch);  in scarlett2_update_direct_monitor()
7142 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_monitor_mix()
7146 	if (!private->num_monitor_mix_ctls)  in scarlett2_update_monitor_mix()
7151 		private->num_monitor_mix_ctls, mix_values);  in scarlett2_update_monitor_mix()
7155 	for (i = 0; i < private->num_monitor_mix_ctls; i++)  in scarlett2_update_monitor_mix()
7156 		private->monitor_mix[i] = scarlett2_mixer_value_to_db(  in scarlett2_update_monitor_mix()
7165 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_direct_monitor_ctl_get()
7166 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_direct_monitor_ctl_get()
7167 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_direct_monitor_ctl_get()
7170 	mutex_lock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_get()
7172 	if (private->hwdep_in_use) {  in scarlett2_direct_monitor_ctl_get()
7173 		err = -EBUSY;  in scarlett2_direct_monitor_ctl_get()
7177 	if (private->direct_monitor_updated) {  in scarlett2_direct_monitor_ctl_get()
7182 	ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;  in scarlett2_direct_monitor_ctl_get()
7185 	mutex_unlock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_get()
7192 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_direct_monitor_ctl_put()
7193 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_direct_monitor_ctl_put()
7194 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_direct_monitor_ctl_put()
7196 	int index = elem->control;  in scarlett2_direct_monitor_ctl_put()
7199 	mutex_lock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_put()
7201 	if (private->hwdep_in_use) {  in scarlett2_direct_monitor_ctl_put()
7202 		err = -EBUSY;  in scarlett2_direct_monitor_ctl_put()
7206 	oval = private->direct_monitor_switch;  in scarlett2_direct_monitor_ctl_put()
7207 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_direct_monitor_ctl_put()
7212 	private->direct_monitor_switch = val;  in scarlett2_direct_monitor_ctl_put()
7214 	/* Send switch change to the device */  in scarlett2_direct_monitor_ctl_put()
7221 	mutex_unlock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_put()
7235 /* Direct Monitor for Solo is mono-only and only needs a boolean control
7258 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_monitor_mix_ctl_get()
7259 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_monitor_mix_ctl_get()
7261 	ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];  in scarlett2_monitor_mix_ctl_get()
7269 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_monitor_mix_ctl_put()
7270 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_monitor_mix_ctl_put()
7271 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_monitor_mix_ctl_put()
7273 	int index = elem->control;  in scarlett2_monitor_mix_ctl_put()
7275 	mutex_lock(&private->data_mutex);  in scarlett2_monitor_mix_ctl_put()
7277 	if (private->hwdep_in_use) {  in scarlett2_monitor_mix_ctl_put()
7278 		err = -EBUSY;  in scarlett2_monitor_mix_ctl_put()
7282 	oval = private->monitor_mix[index];  in scarlett2_monitor_mix_ctl_put()
7283 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_monitor_mix_ctl_put()
7289 	private->monitor_mix[index] = val;  in scarlett2_monitor_mix_ctl_put()
7297 	mutex_unlock(&private->data_mutex);  in scarlett2_monitor_mix_ctl_put()
7315 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_direct_monitor_ctls()
7316 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_direct_monitor_ctls()
7320 	if (!info->direct_monitor)  in scarlett2_add_direct_monitor_ctls()
7323 	s = info->direct_monitor == 1  in scarlett2_add_direct_monitor_ctls()
7328 		mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],  in scarlett2_add_direct_monitor_ctls()
7329 		0, 1, s, &private->direct_monitor_ctl);  in scarlett2_add_direct_monitor_ctls()
7333 	if (!private->num_monitor_mix_ctls)  in scarlett2_add_direct_monitor_ctls()
7337 	for (i = 0, index = 0; i < info->direct_monitor; i++) {  in scarlett2_add_direct_monitor_ctls()
7342 		if (info->direct_monitor == 1)  in scarlett2_add_direct_monitor_ctls()
7353 			for (k = 0; k < private->num_mix_in; k++, index++) {  in scarlett2_add_direct_monitor_ctls()
7375 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_info()
7376 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_mux_src_enum_ctl_info()
7377 	const struct scarlett2_device_info *info = private->info;  in scarlett2_mux_src_enum_ctl_info()
7378 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_mux_src_enum_ctl_info()
7379 	unsigned int item = uinfo->value.enumerated.item;  in scarlett2_mux_src_enum_ctl_info()
7380 	int items = private->num_mux_srcs;  in scarlett2_mux_src_enum_ctl_info()
7383 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;  in scarlett2_mux_src_enum_ctl_info()
7384 	uinfo->count = elem->channels;  in scarlett2_mux_src_enum_ctl_info()
7385 	uinfo->value.enumerated.items = items;  in scarlett2_mux_src_enum_ctl_info()
7388 		item = uinfo->value.enumerated.item = items - 1;  in scarlett2_mux_src_enum_ctl_info()
7398 			    item >= private->num_mix_out)  in scarlett2_mux_src_enum_ctl_info()
7399 				sprintf(uinfo->value.enumerated.name,  in scarlett2_mux_src_enum_ctl_info()
7400 					port->dsp_src_descr,  in scarlett2_mux_src_enum_ctl_info()
7401 					item - private->num_mix_out + 1);  in scarlett2_mux_src_enum_ctl_info()
7403 				sprintf(uinfo->value.enumerated.name,  in scarlett2_mux_src_enum_ctl_info()
7404 					port->src_descr,  in scarlett2_mux_src_enum_ctl_info()
7405 					item + port->src_num_offset);  in scarlett2_mux_src_enum_ctl_info()
7409 		item -= port_count[port_type][SCARLETT2_PORT_IN];  in scarlett2_mux_src_enum_ctl_info()
7412 	return -EINVAL;  in scarlett2_mux_src_enum_ctl_info()
7418 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_get()
7419 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mux_src_enum_ctl_get()
7420 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mux_src_enum_ctl_get()
7421 	int index = line_out_remap(private, elem->control);  in scarlett2_mux_src_enum_ctl_get()
7424 	mutex_lock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_get()
7426 	if (private->hwdep_in_use) {  in scarlett2_mux_src_enum_ctl_get()
7427 		err = -EBUSY;  in scarlett2_mux_src_enum_ctl_get()
7431 	if (private->mux_updated) {  in scarlett2_mux_src_enum_ctl_get()
7436 	ucontrol->value.enumerated.item[0] = private->mux[index];  in scarlett2_mux_src_enum_ctl_get()
7439 	mutex_unlock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_get()
7446 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_put()
7447 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mux_src_enum_ctl_put()
7448 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mux_src_enum_ctl_put()
7449 	int index = line_out_remap(private, elem->control);  in scarlett2_mux_src_enum_ctl_put()
7452 	mutex_lock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_put()
7454 	if (private->hwdep_in_use) {  in scarlett2_mux_src_enum_ctl_put()
7455 		err = -EBUSY;  in scarlett2_mux_src_enum_ctl_put()
7459 	oval = private->mux[index];  in scarlett2_mux_src_enum_ctl_put()
7460 	val = min(ucontrol->value.enumerated.item[0],  in scarlett2_mux_src_enum_ctl_put()
7461 		  private->num_mux_srcs - 1U);  in scarlett2_mux_src_enum_ctl_put()
7466 	private->mux[index] = val;  in scarlett2_mux_src_enum_ctl_put()
7472 	mutex_unlock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_put()
7486 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_mux_enums()
7487 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_mux_enums()
7488 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_add_mux_enums()
7502 			const char *descr = port->dst_descr;  in scarlett2_add_mux_enums()
7505 			    channel >= private->num_mix_in) {  in scarlett2_add_mux_enums()
7506 				channel_num -= private->num_mix_in;  in scarlett2_add_mux_enums()
7507 				descr = port->dsp_dst_descr;  in scarlett2_add_mux_enums()
7510 			snprintf(s, sizeof(s) - 5, descr, channel_num);  in scarlett2_add_mux_enums()
7516 						    &private->mux_ctls[i]);  in scarlett2_add_mux_enums()
7530 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_meter_ctl_info()
7532 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_meter_ctl_info()
7533 	uinfo->count = elem->channels;  in scarlett2_meter_ctl_info()
7534 	uinfo->value.integer.min = 0;  in scarlett2_meter_ctl_info()
7535 	uinfo->value.integer.max = 4095;  in scarlett2_meter_ctl_info()
7536 	uinfo->value.integer.step = 1;  in scarlett2_meter_ctl_info()
7543 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_meter_ctl_get()
7544 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_meter_ctl_get()
7545 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_meter_ctl_get()
7546 	u8 *meter_level_map = private->meter_level_map;  in scarlett2_meter_ctl_get()
7550 	mutex_lock(&private->data_mutex);  in scarlett2_meter_ctl_get()
7552 	if (private->hwdep_in_use) {  in scarlett2_meter_ctl_get()
7553 		err = -EBUSY;  in scarlett2_meter_ctl_get()
7557 	err = scarlett2_usb_get_meter_levels(mixer, elem->channels,  in scarlett2_meter_ctl_get()
7563 	for (i = 0; i < elem->channels; i++) {  in scarlett2_meter_ctl_get()
7572 		ucontrol->value.integer.value[i] = value;  in scarlett2_meter_ctl_get()
7576 	mutex_unlock(&private->data_mutex);  in scarlett2_meter_ctl_get()
7591 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_meter_ctl()
7598 				     0, private->num_mux_dsts,  in scarlett2_add_meter_ctl()
7607 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_msd_ctl_get()
7608 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_msd_ctl_get()
7610 	ucontrol->value.integer.value[0] = private->msd_switch;  in scarlett2_msd_ctl_get()
7617 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_msd_ctl_put()
7618 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_msd_ctl_put()
7619 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_msd_ctl_put()
7623 	mutex_lock(&private->data_mutex);  in scarlett2_msd_ctl_put()
7625 	if (private->hwdep_in_use) {  in scarlett2_msd_ctl_put()
7626 		err = -EBUSY;  in scarlett2_msd_ctl_put()
7630 	oval = private->msd_switch;  in scarlett2_msd_ctl_put()
7631 	val = !!ucontrol->value.integer.value[0];  in scarlett2_msd_ctl_put()
7636 	private->msd_switch = val;  in scarlett2_msd_ctl_put()
7638 	/* Send switch change to the device */  in scarlett2_msd_ctl_put()
7645 	mutex_unlock(&private->data_mutex);  in scarlett2_msd_ctl_put()
7659 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_msd_ctl()
7665 	if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))  in scarlett2_add_msd_ctl()
7678 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_standalone_ctl_get()
7679 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_standalone_ctl_get()
7681 	ucontrol->value.integer.value[0] = private->standalone_switch;  in scarlett2_standalone_ctl_get()
7688 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_standalone_ctl_put()
7689 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_standalone_ctl_put()
7690 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_standalone_ctl_put()
7694 	mutex_lock(&private->data_mutex);  in scarlett2_standalone_ctl_put()
7696 	if (private->hwdep_in_use) {  in scarlett2_standalone_ctl_put()
7697 		err = -EBUSY;  in scarlett2_standalone_ctl_put()
7701 	oval = private->standalone_switch;  in scarlett2_standalone_ctl_put()
7702 	val = !!ucontrol->value.integer.value[0];  in scarlett2_standalone_ctl_put()
7707 	private->standalone_switch = val;  in scarlett2_standalone_ctl_put()
7709 	/* Send switch change to the device */  in scarlett2_standalone_ctl_put()
7717 	mutex_unlock(&private->data_mutex);  in scarlett2_standalone_ctl_put()
7731 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_standalone_ctl()
7746 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_power_status()
7750 	private->power_status_updated = 0;  in scarlett2_update_power_status()
7763 		private->power_status = SCARLETT2_POWER_STATUS_FAIL;  in scarlett2_update_power_status()
7765 		private->power_status = SCARLETT2_POWER_STATUS_EXT;  in scarlett2_update_power_status()
7767 		private->power_status = SCARLETT2_POWER_STATUS_BUS;  in scarlett2_update_power_status()
7775 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_power_status_ctl_get()
7776 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_power_status_ctl_get()
7777 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_power_status_ctl_get()
7780 	mutex_lock(&private->data_mutex);  in scarlett2_power_status_ctl_get()
7782 	if (private->power_status_updated) {  in scarlett2_power_status_ctl_get()
7787 	ucontrol->value.integer.value[0] = private->power_status;  in scarlett2_power_status_ctl_get()
7790 	mutex_unlock(&private->data_mutex);  in scarlett2_power_status_ctl_get()
7814 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_power_status_ctl()
7823 				     &private->power_status_ctl);  in scarlett2_add_power_status_ctl()
7830 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_bluetooth_volume()
7833 	private->bluetooth_updated = 0;  in scarlett2_update_bluetooth_volume()
7835 	if (!private->info->has_bluetooth)  in scarlett2_update_bluetooth_volume()
7840 				       1, &private->bluetooth_volume);  in scarlett2_update_bluetooth_volume()
7850 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_bluetooth_volume_ctl_get()
7851 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_bluetooth_volume_ctl_get()
7852 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_bluetooth_volume_ctl_get()
7855 	mutex_lock(&private->data_mutex);  in scarlett2_bluetooth_volume_ctl_get()
7857 	if (private->hwdep_in_use) {  in scarlett2_bluetooth_volume_ctl_get()
7858 		err = -EBUSY;  in scarlett2_bluetooth_volume_ctl_get()
7862 	if (private->bluetooth_updated) {  in scarlett2_bluetooth_volume_ctl_get()
7867 	ucontrol->value.integer.value[0] = private->bluetooth_volume;  in scarlett2_bluetooth_volume_ctl_get()
7870 	mutex_unlock(&private->data_mutex);  in scarlett2_bluetooth_volume_ctl_get()
7877 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_bluetooth_volume_ctl_put()
7878 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_bluetooth_volume_ctl_put()
7879 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_bluetooth_volume_ctl_put()
7882 	mutex_lock(&private->data_mutex);  in scarlett2_bluetooth_volume_ctl_put()
7884 	if (private->hwdep_in_use) {  in scarlett2_bluetooth_volume_ctl_put()
7885 		err = -EBUSY;  in scarlett2_bluetooth_volume_ctl_put()
7889 	oval = private->bluetooth_volume;  in scarlett2_bluetooth_volume_ctl_put()
7890 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_bluetooth_volume_ctl_put()
7896 	private->bluetooth_volume = val;  in scarlett2_bluetooth_volume_ctl_put()
7904 	mutex_unlock(&private->data_mutex);  in scarlett2_bluetooth_volume_ctl_put()
7911 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_bluetooth_volume_ctl_info()
7912 	uinfo->count = 1;  in scarlett2_bluetooth_volume_ctl_info()
7913 	uinfo->value.integer.min = 0;  in scarlett2_bluetooth_volume_ctl_info()
7914 	uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME;  in scarlett2_bluetooth_volume_ctl_info()
7915 	uinfo->value.integer.step = 1;  in scarlett2_bluetooth_volume_ctl_info()
7930 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_bluetooth_volume_ctl()
7932 	if (!private->info->has_bluetooth)  in scarlett2_add_bluetooth_volume_ctl()
7938 				     &private->bluetooth_volume_ctl);  in scarlett2_add_bluetooth_volume_ctl()
7945 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_spdif_mode()
7948 	const u8 *mode_values = private->info->spdif_mode_values;  in scarlett2_update_spdif_mode()
7950 	if (!private->info->spdif_mode_control_name)  in scarlett2_update_spdif_mode()
7958 	private->spdif_mode = 0;  in scarlett2_update_spdif_mode()
7962 			private->spdif_mode = i;  in scarlett2_update_spdif_mode()
7972 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_spdif_mode_ctl_info()
7973 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_spdif_mode_ctl_info()
7974 	const char * const *mode_texts = private->info->spdif_mode_texts;  in scarlett2_spdif_mode_ctl_info()
7981 				 private->info->spdif_mode_texts);  in scarlett2_spdif_mode_ctl_info()
7987 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_spdif_mode_ctl_get()
7988 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_spdif_mode_ctl_get()
7990 	ucontrol->value.enumerated.item[0] = private->spdif_mode;  in scarlett2_spdif_mode_ctl_get()
7997 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_spdif_mode_ctl_put()
7998 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_spdif_mode_ctl_put()
7999 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_spdif_mode_ctl_put()
8003 	mutex_lock(&private->data_mutex);  in scarlett2_spdif_mode_ctl_put()
8005 	oval = private->spdif_mode;  in scarlett2_spdif_mode_ctl_put()
8006 	val = ucontrol->value.enumerated.item[0];  in scarlett2_spdif_mode_ctl_put()
8009 		err = -EINVAL;  in scarlett2_spdif_mode_ctl_put()
8014 		if (private->info->spdif_mode_values[i] == 0xff) {  in scarlett2_spdif_mode_ctl_put()
8015 			err = -EINVAL;  in scarlett2_spdif_mode_ctl_put()
8022 	private->spdif_mode = val;  in scarlett2_spdif_mode_ctl_put()
8026 		private->info->spdif_mode_values[val]);  in scarlett2_spdif_mode_ctl_put()
8031 	mutex_unlock(&private->data_mutex);  in scarlett2_spdif_mode_ctl_put()
8045 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_spdif_mode_ctl()
8047 	if (!private->info->spdif_mode_control_name)  in scarlett2_add_spdif_mode_ctl()
8052 				     private->info->spdif_mode_control_name,  in scarlett2_add_spdif_mode_ctl()
8061 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_sync()
8063 	private->sync_updated = 1;  in scarlett2_notify_sync()
8065 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_sync()
8066 		       &private->sync_ctl->id);  in scarlett2_notify_sync()
8072 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_monitor()
8073 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_monitor()
8079 	private->vol_updated = 1;  in scarlett2_notify_monitor()
8081 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_monitor()
8082 		       &private->master_vol_ctl->id);  in scarlett2_notify_monitor()
8084 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_notify_monitor()
8085 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])  in scarlett2_notify_monitor()
8087 				       &private->vol_ctls[i]->id);  in scarlett2_notify_monitor()
8093 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_volume()
8095 	private->vol_updated = 1;  in scarlett2_notify_volume()
8097 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_volume()
8098 		       &private->master_vol_ctl->id);  in scarlett2_notify_volume()
8099 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_volume()
8100 		       &private->headphone_vol_ctl->id);  in scarlett2_notify_volume()
8106 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_dim_mute()
8107 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_dim_mute()
8113 	private->dim_mute_updated = 1;  in scarlett2_notify_dim_mute()
8117 			       &private->dim_mute_ctls[i]->id);  in scarlett2_notify_dim_mute()
8119 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_notify_dim_mute()
8120 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])  in scarlett2_notify_dim_mute()
8122 				       &private->mute_ctls[i]->id);  in scarlett2_notify_dim_mute()
8128 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_level()
8129 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_level()
8130 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_level()
8133 	private->input_level_updated = 1;  in scarlett2_notify_input_level()
8135 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_notify_input_level()
8137 			       &private->level_ctls[i]->id);  in scarlett2_notify_input_level()
8143 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_pad()
8144 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_pad()
8145 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_pad()
8148 	private->input_pad_updated = 1;  in scarlett2_notify_input_pad()
8150 	for (i = 0; i < info->pad_input_count; i++)  in scarlett2_notify_input_pad()
8152 			       &private->pad_ctls[i]->id);  in scarlett2_notify_input_pad()
8158 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_air()
8159 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_air()
8160 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_air()
8163 	private->input_air_updated = 1;  in scarlett2_notify_input_air()
8165 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_notify_input_air()
8167 			       &private->air_ctls[i]->id);  in scarlett2_notify_input_air()
8173 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_dsp()
8174 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_dsp()
8175 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_dsp()
8178 	private->input_dsp_updated = 1;  in scarlett2_notify_input_dsp()
8180 	for (i = 0; i < info->dsp_input_count; i++)  in scarlett2_notify_input_dsp()
8182 			       &private->dsp_ctls[i]->id);  in scarlett2_notify_input_dsp()
8188 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_mute()
8189 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_mute()
8190 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_mute()
8193 	private->input_mute_updated = 1;  in scarlett2_notify_input_mute()
8195 	for (i = 0; i < info->mute_input_count; i++)  in scarlett2_notify_input_mute()
8197 			       &private->input_mute_ctls[i]->id);  in scarlett2_notify_input_mute()
8203 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_phantom()
8204 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_phantom()
8205 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_phantom()
8208 	private->input_phantom_updated = 1;  in scarlett2_notify_input_phantom()
8210 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_notify_input_phantom()
8212 			       &private->phantom_ctls[i]->id);  in scarlett2_notify_input_phantom()
8229 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_select()
8230 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_select()
8231 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_select()
8238 	private->input_select_updated = 1;  in scarlett2_notify_input_select()
8242 		       &private->input_select_ctl->id);  in scarlett2_notify_input_select()
8244 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_notify_input_select()
8246 			       &private->input_link_ctls[i]->id);  in scarlett2_notify_input_select()
8252 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_gain()
8253 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_gain()
8254 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_gain()
8257 	if (!info->gain_input_count)  in scarlett2_notify_input_gain()
8260 	private->input_gain_updated = 1;  in scarlett2_notify_input_gain()
8262 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_notify_input_gain()
8264 			       &private->input_gain_ctls[i]->id);  in scarlett2_notify_input_gain()
8270 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_autogain()
8271 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_autogain()
8272 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_autogain()
8275 	if (!info->gain_input_count)  in scarlett2_notify_autogain()
8278 	private->autogain_updated = 1;  in scarlett2_notify_autogain()
8280 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_notify_autogain()
8282 			       &private->autogain_ctls[i]->id);  in scarlett2_notify_autogain()
8284 			       &private->autogain_status_ctls[i]->id);  in scarlett2_notify_autogain()
8291 				       &private->ag_target_ctls[i]->id);  in scarlett2_notify_autogain()
8299 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_safe()
8300 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_safe()
8301 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_safe()
8304 	if (!info->safe_input_count)  in scarlett2_notify_input_safe()
8307 	private->input_safe_updated = 1;  in scarlett2_notify_input_safe()
8309 	for (i = 0; i < info->safe_input_count; i++)  in scarlett2_notify_input_safe()
8311 			       &private->safe_ctls[i]->id);  in scarlett2_notify_input_safe()
8317 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_monitor_other()
8318 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_monitor_other()
8319 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_monitor_other()
8321 	private->monitor_other_updated = 1;  in scarlett2_notify_monitor_other()
8323 	if (info->has_speaker_switching)  in scarlett2_notify_monitor_other()
8325 			       &private->speaker_switching_ctl->id);  in scarlett2_notify_monitor_other()
8327 	if (info->has_talkback)  in scarlett2_notify_monitor_other()
8329 			       &private->talkback_ctl->id);  in scarlett2_notify_monitor_other()
8334 	if (private->speaker_switching_switched) {  in scarlett2_notify_monitor_other()
8339 		private->speaker_switching_switched = 0;  in scarlett2_notify_monitor_other()
8340 		private->mux_updated = 1;  in scarlett2_notify_monitor_other()
8342 		for (i = 0; i < private->num_mux_dsts; i++)  in scarlett2_notify_monitor_other()
8344 				       &private->mux_ctls[i]->id);  in scarlett2_notify_monitor_other()
8351 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_direct_monitor()
8352 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_direct_monitor()
8353 	int count = private->num_mix_in * private->num_mix_out;  in scarlett2_notify_direct_monitor()
8356 	private->direct_monitor_updated = 1;  in scarlett2_notify_direct_monitor()
8359 		       &private->direct_monitor_ctl->id);  in scarlett2_notify_direct_monitor()
8364 	private->mix_updated = 1;  in scarlett2_notify_direct_monitor()
8366 	/* Notify of change to the mix controls */  in scarlett2_notify_direct_monitor()
8369 			       &private->mix_ctls[i]->id);  in scarlett2_notify_direct_monitor()
8375 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_power_status()
8376 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_power_status()
8378 	private->power_status_updated = 1;  in scarlett2_notify_power_status()
8381 		       &private->power_status_ctl->id);  in scarlett2_notify_power_status()
8387 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_mux()
8388 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_mux()
8391 	private->mux_updated = 1;  in scarlett2_notify_mux()
8393 	for (i = 0; i < private->num_mux_dsts; i++)  in scarlett2_notify_mux()
8395 			       &private->mux_ctls[i]->id);  in scarlett2_notify_mux()
8401 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_pcm_input_switch()
8402 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_pcm_input_switch()
8404 	private->pcm_input_switch_updated = 1;  in scarlett2_notify_pcm_input_switch()
8407 		       &private->pcm_input_switch_ctl->id);  in scarlett2_notify_pcm_input_switch()
8415 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_bluetooth()
8416 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_bluetooth()
8418 	if (!private->info->has_bluetooth)  in scarlett2_notify_bluetooth()
8421 	private->bluetooth_updated = 1;  in scarlett2_notify_bluetooth()
8424 		       &private->bluetooth_volume_ctl->id);  in scarlett2_notify_bluetooth()
8432 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_ack()
8435 	if (private->running)  in scarlett2_notify_ack()
8436 		complete(&private->cmd_done);  in scarlett2_notify_ack()
8442 	struct usb_mixer_interface *mixer = urb->context;  in scarlett2_notify()
8443 	int len = urb->actual_length;  in scarlett2_notify()
8444 	int ustatus = urb->status;  in scarlett2_notify()
8446 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify()
8448 		private->config_set->notifications;  in scarlett2_notify()
8453 	data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);  in scarlett2_notify()
8458 	if (private->running < 2)  in scarlett2_notify()
8461 	while (data && notifications->mask) {  in scarlett2_notify()
8462 		if (data & notifications->mask) {  in scarlett2_notify()
8463 			data &= ~notifications->mask;  in scarlett2_notify()
8464 			if (notifications->func)  in scarlett2_notify()
8465 				notifications->func(mixer);  in scarlett2_notify()
8471 		usb_audio_warn(mixer->chip,  in scarlett2_notify()
8476 	if (ustatus != -ENOENT &&  in scarlett2_notify()
8477 	    ustatus != -ECONNRESET &&  in scarlett2_notify()
8478 	    ustatus != -ESHUTDOWN) {  in scarlett2_notify()
8479 		urb->dev = mixer->chip->dev;  in scarlett2_notify()
8482 		complete(&private->cmd_done);  in scarlett2_notify()
8490 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_private_free()
8492 	cancel_delayed_work_sync(&private->work);  in scarlett2_private_free()
8494 	mixer->private_data = NULL;  in scarlett2_private_free()
8499 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_private_suspend()
8501 	if (cancel_delayed_work_sync(&private->work))  in scarlett2_private_suspend()
8502 		scarlett2_config_save(private->mixer);  in scarlett2_private_suspend()
8509 	const struct scarlett2_device_info *info = private->info;  in scarlett2_count_io()
8510 	const struct scarlett2_config_set *config_set = info->config_set;  in scarlett2_count_io()
8511 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_count_io()
8522 	private->num_mux_srcs = srcs;  in scarlett2_count_io()
8523 	private->num_mux_dsts = dsts;  in scarlett2_count_io()
8529 	private->num_mix_in =  in scarlett2_count_io()
8530 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -  in scarlett2_count_io()
8531 			info->dsp_count;  in scarlett2_count_io()
8533 	private->num_mix_out =  in scarlett2_count_io()
8534 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -  in scarlett2_count_io()
8535 			info->dsp_count;  in scarlett2_count_io()
8538 	private->num_line_out =  in scarlett2_count_io()
8542 	private->num_monitor_mix_ctls =  in scarlett2_count_io()
8543 		info->direct_monitor * 2 * private->num_mix_in;  in scarlett2_count_io()
8546 	if (config_set->autogain_status_texts) {  in scarlett2_count_io()
8547 		const char * const *texts = config_set->autogain_status_texts;  in scarlett2_count_io()
8551 		private->num_autogain_status_texts = i;  in scarlett2_count_io()
8563 	struct usb_host_config *config = dev->actconfig;  in scarlett2_find_fc_interface()
8566 	for (i = 0; i < config->desc.bNumInterfaces; i++) {  in scarlett2_find_fc_interface()
8567 		struct usb_interface *intf = config->interface[i];  in scarlett2_find_fc_interface()
8569 			&intf->altsetting[0].desc;  in scarlett2_find_fc_interface()
8572 		if (desc->bInterfaceClass != 255)  in scarlett2_find_fc_interface()
8575 		epd = get_endpoint(intf->altsetting, 0);  in scarlett2_find_fc_interface()
8576 		private->bInterfaceNumber = desc->bInterfaceNumber;  in scarlett2_find_fc_interface()
8577 		private->bEndpointAddress = epd->bEndpointAddress &  in scarlett2_find_fc_interface()
8579 		private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);  in scarlett2_find_fc_interface()
8580 		private->bInterval = epd->bInterval;  in scarlett2_find_fc_interface()
8584 	return -EINVAL;  in scarlett2_find_fc_interface()
8595 		return -ENOMEM;  in scarlett2_init_private()
8597 	mutex_init(&private->usb_mutex);  in scarlett2_init_private()
8598 	mutex_init(&private->data_mutex);  in scarlett2_init_private()
8599 	INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);  in scarlett2_init_private()
8601 	mixer->private_data = private;  in scarlett2_init_private()
8602 	mixer->private_free = scarlett2_private_free;  in scarlett2_init_private()
8603 	mixer->private_suspend = scarlett2_private_suspend;  in scarlett2_init_private()
8605 	private->info = entry->info;  in scarlett2_init_private()
8606 	private->config_set = entry->info->config_set;  in scarlett2_init_private()
8607 	private->series_name = entry->series_name;  in scarlett2_init_private()
8609 	private->scarlett2_seq = 0;  in scarlett2_init_private()
8610 	private->mixer = mixer;  in scarlett2_init_private()
8612 	return scarlett2_find_fc_interface(mixer->chip->dev, private);  in scarlett2_init_private()
8615 /* Submit a URB to receive notifications from the device */
8618 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_init_notify()
8619 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_init_notify()
8620 	unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);  in scarlett2_init_notify()
8623 	if (mixer->urb) {  in scarlett2_init_notify()
8624 		usb_audio_err(mixer->chip,  in scarlett2_init_notify()
8630 		return -EINVAL;  in scarlett2_init_notify()
8632 	mixer->urb = usb_alloc_urb(0, GFP_KERNEL);  in scarlett2_init_notify()
8633 	if (!mixer->urb)  in scarlett2_init_notify()
8634 		return -ENOMEM;  in scarlett2_init_notify()
8636 	transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);  in scarlett2_init_notify()
8638 		return -ENOMEM;  in scarlett2_init_notify()
8640 	usb_fill_int_urb(mixer->urb, dev, pipe,  in scarlett2_init_notify()
8641 			 transfer_buffer, private->wMaxPacketSize,  in scarlett2_init_notify()
8642 			 scarlett2_notify, mixer, private->bInterval);  in scarlett2_init_notify()
8644 	init_completion(&private->cmd_done);  in scarlett2_init_notify()
8646 	return usb_submit_urb(mixer->urb, GFP_KERNEL);  in scarlett2_init_notify()
8652 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_usb_init()
8653 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_init()
8659 		return -EINVAL;  in scarlett2_usb_init()
8662 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,  in scarlett2_usb_init()
8684 	private->running = 1;  in scarlett2_usb_init()
8687 	private->scarlett2_seq = 1;  in scarlett2_usb_init()
8693 	private->scarlett2_seq = 1;  in scarlett2_usb_init()
8700 	/* extract 4-byte firmware version from step2_buf[8] */  in scarlett2_usb_init()
8701 	private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));  in scarlett2_usb_init()
8702 	usb_audio_info(mixer->chip,  in scarlett2_usb_init()
8704 		       private->firmware_version);  in scarlett2_usb_init()
8714 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_get_flash_segment_nums()
8740 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
8742 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
8753 			usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
8754 				"failed to get flash segment info %d: %d\n",  in scarlett2_get_flash_segment_nums()
8768 		private->flash_segment_nums[flash_segment_id] = i;  in scarlett2_get_flash_segment_nums()
8769 		private->flash_segment_blocks[flash_segment_id] =  in scarlett2_get_flash_segment_nums()
8774 	/* segment 0 is App_Gold and we never want to touch that, so  in scarlett2_get_flash_segment_nums()
8775 	 * use 0 as the "not-found" value  in scarlett2_get_flash_segment_nums()
8777 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {  in scarlett2_get_flash_segment_nums()
8778 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
8779 			      "failed to find flash segment %s\n",  in scarlett2_get_flash_segment_nums()
8781 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
8783 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {  in scarlett2_get_flash_segment_nums()
8784 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
8785 			      "failed to find flash segment %s\n",  in scarlett2_get_flash_segment_nums()
8787 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
8796 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_read_configs()
8797 	const struct scarlett2_device_info *info = private->info;  in scarlett2_read_configs()
8803 			1, &private->msd_switch);  in scarlett2_read_configs()
8808 	if (private->firmware_version < info->min_firmware_version) {  in scarlett2_read_configs()
8809 		usb_audio_err(mixer->chip,  in scarlett2_read_configs()
8812 			      private->series_name,  in scarlett2_read_configs()
8813 			      private->firmware_version,  in scarlett2_read_configs()
8814 			      info->min_firmware_version);  in scarlett2_read_configs()
8819 	if (private->msd_switch)  in scarlett2_read_configs()
8874 			1, &private->standalone_switch);  in scarlett2_read_configs()
8897 			private->num_line_out, &sw_vol);  in scarlett2_read_configs()
8901 		for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
8902 			private->vol[i] = clamp(  in scarlett2_read_configs()
8909 			private->num_line_out, &private->mute_switch);  in scarlett2_read_configs()
8913 		for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
8914 			private->mute_switch[i] =  in scarlett2_read_configs()
8915 				!!private->mute_switch[i];  in scarlett2_read_configs()
8922 				private->num_line_out,  in scarlett2_read_configs()
8923 				&private->vol_sw_hw_switch);  in scarlett2_read_configs()
8927 			for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
8928 				private->vol_sw_hw_switch[i] =  in scarlett2_read_configs()
8929 					!!private->vol_sw_hw_switch[i];  in scarlett2_read_configs()
8985 	while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)  in get_scarlett2_device_entry()
8987 	if (!entry->usb_id)  in get_scarlett2_device_entry()
9005 	private = mixer->private_data;  in snd_scarlett2_controls_create()
9040 	if (private->msd_switch ||  in snd_scarlett2_controls_create()
9041 	    private->firmware_version < private->info->min_firmware_version)  in snd_scarlett2_controls_create()
9112 	if (private->info->gain_input_count) {  in snd_scarlett2_controls_create()
9118 	private->running = 2;  in snd_scarlett2_controls_create()
9125 /* Set private->hwdep_in_use; prevents access to the ALSA controls
9130 	mutex_lock(&private->data_mutex);  in scarlett2_lock()
9131 	private->hwdep_in_use = 1;  in scarlett2_lock()
9132 	mutex_unlock(&private->data_mutex);  in scarlett2_lock()
9135 /* Call SCARLETT2_USB_GET_ERASE to get the erase progress */
9138 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_get_erase_progress()
9147 	segment_id = private->selected_flash_segment_id;  in scarlett2_get_erase_progress()
9148 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_get_erase_progress()
9152 		return -EFAULT;  in scarlett2_get_erase_progress()
9186 	return -ETIMEDOUT;  in scarlett2_wait_for_erase()
9189 /* Reboot the device; wait for the erase to complete if one is in
9194 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_reboot()
9196 	if (private->flash_write_state ==  in scarlett2_reboot()
9212 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_select_flash_segment()
9216 		return -EFAULT;  in scarlett2_ioctl_select_flash_segment()
9220 		return -EINVAL;  in scarlett2_ioctl_select_flash_segment()
9222 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_select_flash_segment()
9225 		usb_audio_err(mixer->chip,  in scarlett2_ioctl_select_flash_segment()
9228 		return -EFAULT;  in scarlett2_ioctl_select_flash_segment()
9231 	/* If erasing, wait for it to complete */  in scarlett2_ioctl_select_flash_segment()
9232 	if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {  in scarlett2_ioctl_select_flash_segment()
9239 	/* Save the selected segment ID and set the state to SELECTED */  in scarlett2_ioctl_select_flash_segment()
9240 	private->selected_flash_segment_id = segment_id;  in scarlett2_ioctl_select_flash_segment()
9241 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;  in scarlett2_ioctl_select_flash_segment()
9246 /* Erase the previously-selected flash segment */
9250 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_erase_flash_segment()
9258 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)  in scarlett2_ioctl_erase_flash_segment()
9259 		return -EINVAL;  in scarlett2_ioctl_erase_flash_segment()
9261 	segment_id = private->selected_flash_segment_id;  in scarlett2_ioctl_erase_flash_segment()
9262 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_erase_flash_segment()
9266 		return -EFAULT;  in scarlett2_ioctl_erase_flash_segment()
9268 	/* Prevent access to ALSA controls that access the device from  in scarlett2_ioctl_erase_flash_segment()
9283 	/* On success, change the state from SELECTED to ERASING */  in scarlett2_ioctl_erase_flash_segment()
9284 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;  in scarlett2_ioctl_erase_flash_segment()
9294 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_get_erase_progress()
9305 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)  in scarlett2_ioctl_get_erase_progress()
9306 		return -EINVAL;  in scarlett2_ioctl_get_erase_progress()
9308 	segment_id = private->selected_flash_segment_id;  in scarlett2_ioctl_get_erase_progress()
9309 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_get_erase_progress()
9313 		return -EFAULT;  in scarlett2_ioctl_get_erase_progress()
9326 	progress.num_blocks = private->flash_segment_blocks[segment_id];  in scarlett2_ioctl_get_erase_progress()
9329 		return -EFAULT;  in scarlett2_ioctl_get_erase_progress()
9331 	/* If the erase is complete, change the state from ERASING to  in scarlett2_ioctl_get_erase_progress()
9335 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;  in scarlett2_ioctl_get_erase_progress()
9342 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_open()
9343 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_open()
9345 	/* If erasing, wait for it to complete */  in scarlett2_hwdep_open()
9346 	if (private->flash_write_state ==  in scarlett2_hwdep_open()
9354 	/* Set the state to IDLE */  in scarlett2_hwdep_open()
9355 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;  in scarlett2_hwdep_open()
9363 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_ioctl()
9369 				(int __user *)arg) ? -EFAULT : 0;  in scarlett2_hwdep_ioctl()
9384 		return -ENOIOCTLCMD;  in scarlett2_hwdep_ioctl()
9392 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_read()
9393 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_read()
9407 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)  in scarlett2_hwdep_read()
9408 		return -EINVAL;  in scarlett2_hwdep_read()
9411 	segment_id = private->selected_flash_segment_id;  in scarlett2_hwdep_read()
9413 		return -EINVAL;  in scarlett2_hwdep_read()
9415 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_hwdep_read()
9418 		return -EFAULT;  in scarlett2_hwdep_read()
9422 		return -EINVAL;  in scarlett2_hwdep_read()
9425 	flash_size = private->flash_segment_blocks[segment_id] *  in scarlett2_hwdep_read()
9430 	/* Limit the numbers of bytes read to SCARLETT2_FLASH_RW_MAX */  in scarlett2_hwdep_read()
9434 	/* Limit read to EOF */  in scarlett2_hwdep_read()
9436 		count = flash_size - *offset;  in scarlett2_hwdep_read()
9445 		return -ENOMEM;  in scarlett2_hwdep_read()
9452 	/* Copy the response to userspace */  in scarlett2_hwdep_read()
9454 		err = -EFAULT;  in scarlett2_hwdep_read()
9470 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_write()
9471 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_write()
9484 	const size_t max_data_size = SCARLETT2_FLASH_RW_MAX -  in scarlett2_hwdep_write()
9487 	/* If erasing, wait for it to complete */  in scarlett2_hwdep_write()
9488 	if (private->flash_write_state ==  in scarlett2_hwdep_write()
9493 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;  in scarlett2_hwdep_write()
9496 	} else if (private->flash_write_state !=  in scarlett2_hwdep_write()
9498 		return -EINVAL;  in scarlett2_hwdep_write()
9501 	/* Check that we're writing to the upgrade firmware */  in scarlett2_hwdep_write()
9502 	segment_id = private->selected_flash_segment_id;  in scarlett2_hwdep_write()
9504 		return -EINVAL;  in scarlett2_hwdep_write()
9506 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_hwdep_write()
9509 		return -EFAULT;  in scarlett2_hwdep_write()
9512 	flash_size = private->flash_segment_blocks[segment_id] *  in scarlett2_hwdep_write()
9516 		return -ENOSPC;  in scarlett2_hwdep_write()
9521 	/* Limit the *req size to SCARLETT2_FLASH_RW_MAX */  in scarlett2_hwdep_write()
9529 		return -ENOMEM;  in scarlett2_hwdep_write()
9531 	req->segment_num = cpu_to_le32(segment_num);  in scarlett2_hwdep_write()
9532 	req->offset = cpu_to_le32(*offset);  in scarlett2_hwdep_write()
9533 	req->pad = 0;  in scarlett2_hwdep_write()
9535 	if (copy_from_user(req->data, buf, count)) {  in scarlett2_hwdep_write()
9536 		err = -EFAULT;  in scarlett2_hwdep_write()
9555 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_release()
9556 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_release()
9558 	/* Return from the SELECTED or WRITE state to IDLE.  in scarlett2_hwdep_release()
9559 	 * The ERASING state is left as-is, and checked on next open.  in scarlett2_hwdep_release()
9562 	    private->hwdep_in_use &&  in scarlett2_hwdep_release()
9563 	    private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)  in scarlett2_hwdep_release()
9564 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;  in scarlett2_hwdep_release()
9574 	err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);  in scarlett2_hwdep_init()
9578 	hw->private_data = mixer;  in scarlett2_hwdep_init()
9579 	hw->exclusive = 1;  in scarlett2_hwdep_init()
9580 	hw->ops.open = scarlett2_hwdep_open;  in scarlett2_hwdep_init()
9581 	hw->ops.ioctl = scarlett2_hwdep_ioctl;  in scarlett2_hwdep_init()
9582 	hw->ops.read = scarlett2_hwdep_read;  in scarlett2_hwdep_init()
9583 	hw->ops.write = scarlett2_hwdep_write;  in scarlett2_hwdep_init()
9584 	hw->ops.release = scarlett2_hwdep_release;  in scarlett2_hwdep_init()
9589 /*** device-map file ***/
9599 	struct usb_mixer_interface *mixer = entry->private_data;  in scarlett2_devmap_read()
9604 	if (pos >= entry->size)  in scarlett2_devmap_read()
9607 	if (pos + count > entry->size)  in scarlett2_devmap_read()
9608 		count = entry->size - pos;  in scarlett2_devmap_read()
9612 		return -ENOMEM;  in scarlett2_devmap_read()
9616 		 * so we need to read a whole block and copy the requested  in scarlett2_devmap_read()
9617 		 * chunk to userspace.  in scarlett2_devmap_read()
9627 		size_t block_start = pos - offset;  in scarlett2_devmap_read()
9630 					 entry->size - block_start);  in scarlett2_devmap_read()
9632 		/* size of the chunk to copy to userspace */  in scarlett2_devmap_read()
9633 		size_t copy_size = min_t(size_t, count, read_size - offset);  in scarlett2_devmap_read()
9646 			return -EFAULT;  in scarlett2_devmap_read()
9652 		count -= copy_size;  in scarlett2_devmap_read()
9665 	struct snd_card *card = mixer->chip->card;  in scarlett2_devmap_init()
9666 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_devmap_init()
9667 	const struct scarlett2_device_info *info = private->info;  in scarlett2_devmap_init()
9676 	if (!info->has_devmap)  in scarlett2_devmap_init()
9690 	entry->content = SNDRV_INFO_CONTENT_DATA;  in scarlett2_devmap_init()
9691 	entry->private_data = mixer;  in scarlett2_devmap_init()
9692 	entry->c.ops = &scarlett2_devmap_ops;  in scarlett2_devmap_init()
9693 	entry->size = config_len;  in scarlett2_devmap_init()
9694 	entry->mode = S_IFREG | 0444;  in scarlett2_devmap_init()
9701 	struct snd_usb_audio *chip = mixer->chip;  in snd_scarlett2_init()
9706 	if (!mixer->protocol)  in snd_scarlett2_init()
9709 	/* check if the user wants to use the FCP driver instead */  in snd_scarlett2_init()
9710 	if (chip->setup & SCARLETT2_USE_FCP_DRIVER)  in snd_scarlett2_init()
9716 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
9719 			      USB_ID_VENDOR(chip->usb_id),  in snd_scarlett2_init()
9720 			      USB_ID_PRODUCT(chip->usb_id));  in snd_scarlett2_init()
9724 	if (chip->setup & SCARLETT2_DISABLE) {  in snd_scarlett2_init()
9729 			entry->series_name,  in snd_scarlett2_init()
9730 			USB_ID_VENDOR(chip->usb_id),  in snd_scarlett2_init()
9731 			USB_ID_PRODUCT(chip->usb_id),  in snd_scarlett2_init()
9738 		"report any issues to "  in snd_scarlett2_init()
9739 		"https://github.com/geoffreybennett/scarlett-gen2/issues",  in snd_scarlett2_init()
9740 		entry->series_name,  in snd_scarlett2_init()
9741 		USB_ID_PRODUCT(chip->usb_id));  in snd_scarlett2_init()
9745 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
9747 			      entry->series_name,  in snd_scarlett2_init()
9754 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
9756 			      entry->series_name,  in snd_scarlett2_init()
9763 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
9765 			      entry->series_name,  in snd_scarlett2_init()