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-2023 by Geoffrey D. Bennett <g at b4.vu>
15  *   Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
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 gain, autogain, safe mode
89  *  - direct monitor mixes
92  *    /--------------\    18chn            20chn     /--------------\
93  *    | Hardware  in +--+------\    /-------------+--+ ALSA PCM out |
94  *    \--------------/  |      |    |             |  \--------------/
95  *                      |      |    |    /-----\  |
98  *                      |   +---------------+  |  |
100  *                      |     +-----+-----+    |  |
106  *                      |     +------------+   |  |
112  *                      |     +-----+------+   |  |
116  *                      |           +----------/  |
120  *               +---------------+       +--—------------+
122  *                 +---+---+---+           +-----+-----+
126  *  /--------------\   |   |                     |   /--------------\
127  *  | S/PDIF, ADAT |<--/   |10chn                \-->| ALSA PCM in  |
128  *  | Hardware out |       |                         \--------------/
129  *  \--------------/       |
131  *                  +-------------+    Software gain per channel.
132  *                  | Master Gain |<-- 18i20 only: Switch per channel
133  *                  +------+------+    to select HW or SW gain control.
136  *  /--------------\       |
137  *  | Analogue     |<------/
139  *  \--------------/
144  * to the host. To access the full functionality of the device without
146  * - holding down the 48V button for five seconds while powering on
148  * - using this driver and alsamixer to change the "MSD Mode" setting
149  *   to Off and power-cycling the device
168 /* device_setup value to allow turning MSD mode back on */
171 /* device_setup value to disable this mixer driver */
178 /* mixer range from -80dB to +6dB in 0.5dB steps */
179 #define SCARLETT2_MIXER_MIN_DB -80
180 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
183 	((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
186 /* map from (dB + 80) * 2 to mixer value
187  * for dB in 0 .. 172: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
216 /* Maximum number of inputs to the mixer */
244  * - None (no input to mux)
245  * - Analogue I/O
246  * - S/PDIF I/O
247  * - ADAT I/O
248  * - Mixer I/O
249  * - PCM I/O
427  * A size of 0 indicates that the parameter is a byte-sized Scarlett
433  * mute set to 1. 0x02 and 0x03 are temporary values while the device
440 	u8 activate;  member
456 			.offset = 0x34, .size = 16, .activate = 1 },
459 			.offset = 0x5c, .size = 8, .activate = 1 },
462 			.offset = 0x7c, .size = 8, .activate = 7 },
465 			.offset = 0x84, .size = 8, .activate = 8 },
468 			.offset = 0x8d, .size = 8, .activate = 6 },
478 			.offset = 0x31, .size = 8, .activate = 2 },
481 			.offset = 0x34, .size = 16, .activate = 1 },
484 			.offset = 0x5c, .size = 8, .activate = 1 },
487 			.offset = 0x66, .size = 8, .activate = 3 },
493 			.offset = 0x7c, .size = 8, .activate = 7 },
496 			.offset = 0x84, .size = 8, .activate = 8 },
499 			.offset = 0x8d, .size = 8, .activate = 6 },
508 			.offset = 0x04, .size = 8, .activate = 6 },
511 			.offset = 0x05, .size = 8, .activate = 6 },
514 			.offset = 0x06, .size = 8, .activate = 3 },
517 			.offset = 0x07, .size = 8, .activate = 4 },
520 			.offset = 0x08, .size = 1, .activate = 7 },
523 			.offset = 0x09, .size = 1, .activate = 8 },
532 			.offset = 0x34, .size = 16, .activate = 1 },
535 			.offset = 0x5c, .size = 8, .activate = 1 },
538 			.offset = 0x7c, .size = 8, .activate = 7 },
541 			.offset = 0x84, .size = 8, .activate = 8 },
544 			.offset = 0x8c, .size = 8, .activate = 8 },
547 			.offset = 0x95, .size = 8, .activate = 6 },
550 			.offset = 0x9c, .size = 1, .activate = 8 },
553 			.offset = 0x9d, .size = 8, .activate = 6 },
556 			.offset = 0x9e, .size = 8, .activate = 6 },
565 			.offset = 0x31, .size = 8, .activate = 2 },
568 			.offset = 0x34, .size = 16, .activate = 1 },
571 			.offset = 0x5c, .size = 8, .activate = 1 },
574 			.offset = 0x66, .size = 8, .activate = 3 },
580 			.offset = 0x7c, .size = 8, .activate = 7 },
583 			.offset = 0x84, .size = 8, .activate = 8 },
586 			.offset = 0x8c, .size = 8, .activate = 8 },
589 			.offset = 0x95, .size = 8, .activate = 6 },
592 			.offset = 0x9c, .size = 1, .activate = 8 },
595 			.offset = 0x9d, .size = 8, .activate = 6 },
598 			.offset = 0x9e, .size = 8, .activate = 6 },
601 			.offset = 0x9f, .size = 1, .activate = 10 },
604 			.offset = 0xa0, .size = 1, .activate = 10 },
607 			.offset = 0xb0, .size = 16, .activate = 10 },
617 			.offset = 0x47, .size = 8, .activate = 4 },
620 			.offset = 0x108, .activate = 12 },
623 			.offset = 0x46, .activate = 9, .mute = 1 },
626 			.offset = 0x3d, .activate = 10, .mute = 1 },
629 			.offset = 0x3e, .activate = 11 },
632 			.offset = 0x206, .activate = 25 },
635 			.offset = 0x232, .size = 16, .activate = 26 }
645 			.offset = 0x49, .size = 8, .activate = 4 }, // 0x41 ??
648 			.offset = 0x14a, .activate = 16 },
651 			.offset = 0x135, .activate = 10 },
657 			.offset = 0x48, .activate = 11, .mute = 1 },
660 			.offset = 0x4b, .activate = 12 },
663 			.offset = 0x3c, .activate = 13, .mute = 1 },
666 			.offset = 0x147, .activate = 14 },
669 			.offset = 0x3e, .activate = 15 },
672 			.offset = 0x14b, .activate = 17 },
675 			.offset = 0x14e, .activate = 18 },
678 			.offset = 0x2a0, .size = 16, .activate = 36 }
688 			.offset = 0x5c, .size = 8, .activate = 4 },
691 			.offset = 0x13e, .activate = 10 },
697 			.offset = 0x5a, .activate = 11, .mute = 1 },
700 			.offset = 0x5e, .activate = 12 },
703 			.offset = 0x4e, .activate = 13, .mute = 1 },
706 			.offset = 0x150, .activate = 14 },
709 			.offset = 0x50, .activate = 15 },
712 			.offset = 0x153, .activate = 16 },
715 			.offset = 0x156, .activate = 17 },
736 			.offset = 0x31, .size = 8, .activate = 2 },
739 			.offset = 0x34, .size = 16, .activate = 1 },
742 			.offset = 0x5c, .size = 8, .activate = 1 },
745 			.offset = 0x66, .size = 8, .activate = 3 },
751 			.offset = 0x7c, .size = 8, .activate = 7 },
754 			.offset = 0x95, .size = 8, .activate = 8 },
757 			.offset = 0x8d, .size = 8, .activate = 6 },
762  * - id: hardware ID of this port type
763  * - src_descr: printf format string for mux input selections
764  * - src_num_offset: added to channel number for the fprintf
765  * - dst_descr: printf format string for mixer controls
824  * ports to add to the set_mux message. The end of the list is marked
837  * that consecutive meter entries are mapped to. The end of the list
859 	 * level control that can be set to line or instrument
863 	/* the first input with a level control (0-based) */
876 	/* the first input with an air control (0-based) */
888 	/* the first input with phantom power control (0-based) */
894 	/* the number of inputs with software-controllable gain */
906 	 * internally to the analogue 7/8 outputs
923 	 * SCARLETT2_USB_GET_METER to index into mux[] entries (same
932 	struct mutex data_mutex; /* lock access to this data */
1028 /*** Model-specific data ***/
1878 	u16 seq = private->scarlett2_seq++;  in scarlett2_fill_request_header()
1880 	req->cmd = cpu_to_le32(cmd);  in scarlett2_fill_request_header()
1881 	req->size = cpu_to_le16(req_size);  in scarlett2_fill_request_header()
1882 	req->seq = cpu_to_le16(seq);  in scarlett2_fill_request_header()
1883 	req->error = 0;  in scarlett2_fill_request_header()
1884 	req->pad = 0;  in scarlett2_fill_request_header()
1905 /* Send a proprietary format request to the Scarlett interface */
1910 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb()
1911 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_usb()
1919 		err = -ENOMEM;  in scarlett2_usb()
1925 		err = -ENOMEM;  in scarlett2_usb()
1929 	mutex_lock(&private->usb_mutex);  in scarlett2_usb()
1936 		memcpy(req->data, req_data, req_size);  in scarlett2_usb()
1938 	err = scarlett2_usb_tx(dev, private->bInterfaceNumber,  in scarlett2_usb()
1943 			mixer->chip,  in scarlett2_usb()
1945 			private->series_name, cmd, err);  in scarlett2_usb()
1946 		err = -EINVAL;  in scarlett2_usb()
1950 	/* send a second message to get the response */  in scarlett2_usb()
1952 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,  in scarlett2_usb()
1960 		/* ESHUTDOWN and EPROTO are valid responses to a  in scarlett2_usb()
1964 		    (err == -ESHUTDOWN || err == -EPROTO)) {  in scarlett2_usb()
1970 			mixer->chip,  in scarlett2_usb()
1972 			private->series_name, cmd, err, resp_buf_size);  in scarlett2_usb()
1973 		err = -EINVAL;  in scarlett2_usb()
1980 	if (resp->cmd != req->cmd ||  in scarlett2_usb()
1981 	    (resp->seq != req->seq &&  in scarlett2_usb()
1982 		(le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||  in scarlett2_usb()
1983 	    resp_size != le16_to_cpu(resp->size) ||  in scarlett2_usb()
1984 	    resp->error ||  in scarlett2_usb()
1985 	    resp->pad) {  in scarlett2_usb()
1987 			mixer->chip,  in scarlett2_usb()
1991 			private->series_name,  in scarlett2_usb()
1992 			le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),  in scarlett2_usb()
1993 			le16_to_cpu(req->seq), le16_to_cpu(resp->seq),  in scarlett2_usb()
1994 			resp_size, le16_to_cpu(resp->size),  in scarlett2_usb()
1995 			le32_to_cpu(resp->error),  in scarlett2_usb()
1996 			le32_to_cpu(resp->pad));  in scarlett2_usb()
1997 		err = -EINVAL;  in scarlett2_usb()
2002 		memcpy(resp_data, resp->data, resp_size);  in scarlett2_usb()
2005 	mutex_unlock(&private->usb_mutex);  in scarlett2_usb()
2012 /* Send a USB message to get data; result placed in *buf */
2034 	return !!private->config_set->items[config_item_num].offset;  in scarlett2_has_config_item()
2037 /* Send a USB message to get configuration parameters; result placed in *buf */
2042 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_config()
2044 		&private->config_set->items[config_item_num];  in scarlett2_usb_get_config()
2052 	if (!config_item->offset)  in scarlett2_usb_get_config()
2053 		return -EFAULT;  in scarlett2_usb_get_config()
2056 	size = config_item->size ? config_item->size : 8;  in scarlett2_usb_get_config()
2058 	/* For byte-sized parameters, retrieve directly into buf */  in scarlett2_usb_get_config()
2061 		err = scarlett2_usb_get(mixer, config_item->offset, buf, size);  in scarlett2_usb_get_config()
2073 	/* For bit-sized parameters, retrieve into value */  in scarlett2_usb_get_config()
2074 	err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);  in scarlett2_usb_get_config()
2094 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_data()
2104 	return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,  in scarlett2_usb_set_data()
2111  * The value for activate needed is determined by the configuration
2115 	struct usb_mixer_interface *mixer, int activate)  in scarlett2_usb_activate_config()  argument
2119 	req = cpu_to_le32(activate);  in scarlett2_usb_activate_config()
2124 /* Send USB messages to set a SCARLETT2_CONFIG_* parameter */
2129 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_config()
2130 	const struct scarlett2_config_set *config_set = private->config_set;  in scarlett2_usb_set_config()
2132 		&config_set->items[config_item_num];  in scarlett2_usb_set_config()
2139 	if (!config_item->offset)  in scarlett2_usb_set_config()
2140 		return -EFAULT;  in scarlett2_usb_set_config()
2143 	 * these are only byte-sized values written through a shared  in scarlett2_usb_set_config()
2144 	 * location, different to the read address  in scarlett2_usb_set_config()
2146 	if (!config_item->size) {  in scarlett2_usb_set_config()
2147 		if (!config_set->gen4_write_addr)  in scarlett2_usb_set_config()
2148 			return -EFAULT;  in scarlett2_usb_set_config()
2152 			mixer, config_set->gen4_write_addr + 1, 1, index);  in scarlett2_usb_set_config()
2158 			mixer, config_set->gen4_write_addr, 1, value);  in scarlett2_usb_set_config()
2164 			mixer, config_item->activate);  in scarlett2_usb_set_config()
2167 	/* Not-Gen 4 style needs NVRAM save, supports  in scarlett2_usb_set_config()
2168 	 * bit-modification, and writing is done to the same place  in scarlett2_usb_set_config()
2173 	cancel_delayed_work_sync(&private->work);  in scarlett2_usb_set_config()
2175 	/* Convert config_item->size in bits to size in bytes and  in scarlett2_usb_set_config()
2178 	if (config_item->size >= 8) {  in scarlett2_usb_set_config()
2179 		size = config_item->size / 8;  in scarlett2_usb_set_config()
2180 		offset = config_item->offset + index * size;  in scarlett2_usb_set_config()
2189 		offset = config_item->offset;  in scarlett2_usb_set_config()
2208 	/* Activate the change */  in scarlett2_usb_set_config()
2209 	err = scarlett2_usb_activate_config(mixer, config_item->activate);  in scarlett2_usb_set_config()
2213 	/* Gen 2 style writes to Gen 4 devices don't need saving */  in scarlett2_usb_set_config()
2214 	if (config_set->gen4_write_addr)  in scarlett2_usb_set_config()
2217 	/* Schedule the change to be written to NVRAM */  in scarlett2_usb_set_config()
2218 	if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)  in scarlett2_usb_set_config()
2219 		schedule_delayed_work(&private->work, msecs_to_jiffies(2000));  in scarlett2_usb_set_config()
2231 		usb_audio_err(mixer->chip, "config save failed: %d\n", err);  in scarlett2_config_save()
2234 /* Delayed work to save config */
2240 	scarlett2_config_save(private->mixer);  in scarlett2_config_save_work()
2243 /* Send a USB message to get sync status; result placed in *sync */
2263 	return !!private->info->mux_assignment[0][0].count;  in scarlett2_has_mixer()
2266 /* Map from mixer value to (db + 80) * 2
2279 /* Send a USB message to get the volumes for all inputs of one mix
2280  * and put the values into private->mix[]
2285 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_mix()
2287 	int num_mixer_in = private->num_mix_in;  in scarlett2_usb_get_mix()
2307 		private->mix[j] = scarlett2_mixer_value_to_db(  in scarlett2_usb_get_mix()
2313 /* Send a USB message to set the volumes for all inputs of one mix
2314  * (values obtained from private->mix[])
2319 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_mix()
2327 	int num_mixer_in = private->num_mix_in;  in scarlett2_usb_set_mix()
2333 			scarlett2_mixer_values[private->mix[j]]  in scarlett2_usb_set_mix()
2341 /* Convert a port number index (per info->port_count) to a hardware ID */
2352 		num -= port_count[port_type][SCARLETT2_PORT_IN];  in scarlett2_mux_src_num_to_id()
2359 /* Convert a hardware ID to a port number index */
2373 			return port_num + id - base;  in scarlett2_mux_id_to_num()
2378 	return -1;  in scarlett2_mux_id_to_num()
2381 /* Convert one mux entry from the interface and load into private->mux[] */
2385 	const struct scarlett2_device_info *info = private->info;  in scarlett2_usb_populate_mux()
2386 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_usb_populate_mux()
2395 	if (dst_idx >= private->num_mux_dsts) {  in scarlett2_usb_populate_mux()
2396 		usb_audio_err(private->mixer->chip,  in scarlett2_usb_populate_mux()
2398 			mux_entry, dst_idx, private->num_mux_dsts);  in scarlett2_usb_populate_mux()
2407 	if (src_idx >= private->num_mux_srcs) {  in scarlett2_usb_populate_mux()
2408 		usb_audio_err(private->mixer->chip,  in scarlett2_usb_populate_mux()
2410 			mux_entry, src_idx, private->num_mux_srcs);  in scarlett2_usb_populate_mux()
2414 	private->mux[dst_idx] = src_idx;  in scarlett2_usb_populate_mux()
2420  * request) is returned in mux_assignment order, but to avoid exposing
2421  * that to userspace, scarlett2_meter_ctl_get() rearranges the data
2428  * - the source is "Off"; therefore we set those values to zero (map
2431  * - the source is assigned to a previous (with respect to the
2433  *   to the value previously reported for that source
2437 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_meter_level_map()
2440 	/* sources already assigned to a destination  in scarlett2_update_meter_level_map()
2452 	for (entry = info->meter_map;  in scarlett2_update_meter_level_map()
2453 	     entry->count;  in scarlett2_update_meter_level_map()
2459 		for (j = 0, mux_idx = entry->start;  in scarlett2_update_meter_level_map()
2460 		     j < entry->count;  in scarlett2_update_meter_level_map()
2465 			    info->line_out_remap_enable &&  in scarlett2_update_meter_level_map()
2466 			    mux_idx < private->num_line_out  in scarlett2_update_meter_level_map()
2467 			) ? info->line_out_unmap[mux_idx]  in scarlett2_update_meter_level_map()
2475 			int mux_src = private->mux[mux_idx];  in scarlett2_update_meter_level_map()
2481 			private->meter_level_map[map_mux_idx] =  in scarlett2_update_meter_level_map()
2487 /* Send USB message to get mux inputs and then populate private->mux[] */
2490 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_get_mux()
2491 	int count = private->num_mux_dsts;  in scarlett2_usb_get_mux()
2501 	private->mux_updated = 0;  in scarlett2_usb_get_mux()
2520 /* Send USB messages to set mux inputs */
2523 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_set_mux()
2524 	const struct scarlett2_device_info *info = private->info;  in scarlett2_usb_set_mux()
2525 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_usb_set_mux()
2546 		for (entry = info->mux_assignment[table];  in scarlett2_usb_set_mux()
2547 		     entry->count;  in scarlett2_usb_set_mux()
2550 			int port_type = entry->port_type;  in scarlett2_usb_set_mux()
2551 			int port_idx = entry->start;  in scarlett2_usb_set_mux()
2558 				for (j = 0; j < entry->count; j++)  in scarlett2_usb_set_mux()
2563 			/* Non-empty mux slots use the lower 12 bits  in scarlett2_usb_set_mux()
2567 			for (j = 0; j < entry->count; j++) {  in scarlett2_usb_set_mux()
2569 					port_count, private->mux[mux_idx++]);  in scarlett2_usb_set_mux()
2588 /* Send USB message to get meter levels */
2608 	/* copy, convert to u16 */  in scarlett2_usb_get_meter_levels()
2615 /* For config items with mute=1, xor bits 0 & 1 together to get the
2626 /* helper function to create a new control */
2638 		return -ENOMEM;  in scarlett2_add_new_ctl()
2642 	 * Also, the head.id field is set to 0, as we don't use this field.  in scarlett2_add_new_ctl()
2644 	elem->head.mixer = mixer;  in scarlett2_add_new_ctl()
2645 	elem->control = index;  in scarlett2_add_new_ctl()
2646 	elem->head.id = 0;  in scarlett2_add_new_ctl()
2647 	elem->channels = channels;  in scarlett2_add_new_ctl()
2648 	elem->val_type = USB_MIXER_BESPOKEN;  in scarlett2_add_new_ctl()
2653 		return -ENOMEM;  in scarlett2_add_new_ctl()
2655 	kctl->private_free = snd_usb_mixer_elem_free;  in scarlett2_add_new_ctl()
2657 	strscpy(kctl->id.name, name, sizeof(kctl->id.name));  in scarlett2_add_new_ctl()
2659 	err = snd_usb_mixer_add_control(&elem->head, kctl);  in scarlett2_add_new_ctl()
2675 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_firmware_version_ctl_get()
2676 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_firmware_version_ctl_get()
2678 	ucontrol->value.integer.value[0] = private->firmware_version;  in scarlett2_firmware_version_ctl_get()
2687 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_firmware_version_ctl_info()
2688 	uinfo->count = 1;  in scarlett2_firmware_version_ctl_info()
2714 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_min_firmware_version_ctl_get()
2715 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_min_firmware_version_ctl_get()
2717 	ucontrol->value.integer.value[0] = private->info->min_firmware_version;  in scarlett2_min_firmware_version_ctl_get()
2726 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_min_firmware_version_ctl_info()
2727 	uinfo->count = 1;  in scarlett2_min_firmware_version_ctl_info()
2754 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_sync()
2756 	private->sync_updated = 0;  in scarlett2_update_sync()
2757 	return scarlett2_usb_get_sync_status(mixer, &private->sync);  in scarlett2_update_sync()
2772 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sync_ctl_get()
2773 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_sync_ctl_get()
2774 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sync_ctl_get()
2777 	mutex_lock(&private->data_mutex);  in scarlett2_sync_ctl_get()
2779 	if (private->hwdep_in_use) {  in scarlett2_sync_ctl_get()
2780 		err = -EBUSY;  in scarlett2_sync_ctl_get()
2784 	if (private->sync_updated) {  in scarlett2_sync_ctl_get()
2789 	ucontrol->value.enumerated.item[0] = private->sync;  in scarlett2_sync_ctl_get()
2792 	mutex_unlock(&private->data_mutex);  in scarlett2_sync_ctl_get()
2806 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_sync_ctl()
2813 				     0, 1, "Sync Status", &private->sync_ctl);  in scarlett2_add_sync_ctl()
2822 /* Set the access mode of a control to read-only (val = 0) or
2823  * read-write (val = 1).
2828 		kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;  in scarlett2_set_ctl_access()
2830 		kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;  in scarlett2_set_ctl_access()
2838 	for (i = 0; i < private->info->gain_input_count; i++)  in scarlett2_autogain_is_running()
2839 		if (private->autogain_status[i] ==  in scarlett2_autogain_is_running()
2848 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_autogain()
2849 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_autogain()
2853 	private->autogain_updated = 0;  in scarlett2_update_autogain()
2855 	if (!info->gain_input_count)  in scarlett2_update_autogain()
2860 		info->gain_input_count, private->autogain_switch);  in scarlett2_update_autogain()
2865 		info->gain_input_count, raw_autogain_status);  in scarlett2_update_autogain()
2872 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_update_autogain()
2873 		if (private->autogain_switch[i])  in scarlett2_update_autogain()
2874 			private->autogain_status[i] =  in scarlett2_update_autogain()
2877 			private->autogain_status[i] =  in scarlett2_update_autogain()
2881 			private->autogain_status[i] =  in scarlett2_update_autogain()
2884 			private->autogain_status[i] =  in scarlett2_update_autogain()
2887 			private->autogain_status[i] =  in scarlett2_update_autogain()
2896 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_update_access()
2897 	const struct scarlett2_device_info *info = private->info;  in scarlett2_autogain_update_access()
2901 	scarlett2_set_ctl_access(private->input_select_ctl, val);  in scarlett2_autogain_update_access()
2902 	for (i = 0; i < info->gain_input_count / 2; i++)  in scarlett2_autogain_update_access()
2903 		scarlett2_set_ctl_access(private->input_link_ctls[i], val);  in scarlett2_autogain_update_access()
2904 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_autogain_update_access()
2905 		scarlett2_set_ctl_access(private->input_gain_ctls[i], val);  in scarlett2_autogain_update_access()
2906 		scarlett2_set_ctl_access(private->safe_ctls[i], val);  in scarlett2_autogain_update_access()
2908 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_autogain_update_access()
2909 		scarlett2_set_ctl_access(private->level_ctls[i], val);  in scarlett2_autogain_update_access()
2910 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_autogain_update_access()
2911 		scarlett2_set_ctl_access(private->air_ctls[i], val);  in scarlett2_autogain_update_access()
2912 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_autogain_update_access()
2913 		scarlett2_set_ctl_access(private->phantom_ctls[i], val);  in scarlett2_autogain_update_access()
2916 /* Notify of access mode change for all controls read-only while
2921 	struct snd_card *card = mixer->chip->card;  in scarlett2_autogain_notify_access()
2922 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_notify_access()
2923 	const struct scarlett2_device_info *info = private->info;  in scarlett2_autogain_notify_access()
2927 		       &private->input_select_ctl->id);  in scarlett2_autogain_notify_access()
2928 	for (i = 0; i < info->gain_input_count / 2; i++)  in scarlett2_autogain_notify_access()
2930 			       &private->input_link_ctls[i]->id);  in scarlett2_autogain_notify_access()
2931 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_autogain_notify_access()
2933 			       &private->input_gain_ctls[i]->id);  in scarlett2_autogain_notify_access()
2935 			       &private->safe_ctls[i]->id);  in scarlett2_autogain_notify_access()
2937 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_autogain_notify_access()
2939 			       &private->level_ctls[i]->id);  in scarlett2_autogain_notify_access()
2940 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_autogain_notify_access()
2942 			       &private->air_ctls[i]->id);  in scarlett2_autogain_notify_access()
2943 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_autogain_notify_access()
2945 			       &private->phantom_ctls[i]->id);  in scarlett2_autogain_notify_access()
2954 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_check_autogain_updated()
2957 	if (!private->autogain_updated)  in scarlett2_check_autogain_updated()
2970  * control that is meant to be read-only while autogain is running,
2972  * Return -EPERM if autogain is running.
2982 	if (scarlett2_autogain_is_running(mixer->private_data))  in scarlett2_check_put_during_autogain()
2983 		return -EPERM;  in scarlett2_check_put_during_autogain()
2991 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_info()
2992 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_info()
2993 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_info()
2996 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_info()
3005 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_info()
3012 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_get()
3013 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_get()
3014 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_get()
3017 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_get()
3019 	if (private->hwdep_in_use) {  in scarlett2_autogain_switch_ctl_get()
3020 		err = -EBUSY;  in scarlett2_autogain_switch_ctl_get()
3028 	ucontrol->value.enumerated.item[0] =  in scarlett2_autogain_switch_ctl_get()
3029 		private->autogain_switch[elem->control];  in scarlett2_autogain_switch_ctl_get()
3032 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_get()
3039 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_status_ctl_get()
3040 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_status_ctl_get()
3041 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_status_ctl_get()
3044 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_status_ctl_get()
3046 	if (private->hwdep_in_use) {  in scarlett2_autogain_status_ctl_get()
3047 		err = -EBUSY;  in scarlett2_autogain_status_ctl_get()
3055 	ucontrol->value.enumerated.item[0] =  in scarlett2_autogain_status_ctl_get()
3056 		private->autogain_status[elem->control];  in scarlett2_autogain_status_ctl_get()
3059 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_status_ctl_get()
3066 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_switch_ctl_put()
3067 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_switch_ctl_put()
3068 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_switch_ctl_put()
3070 	int index = elem->control;  in scarlett2_autogain_switch_ctl_put()
3073 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_put()
3075 	if (private->hwdep_in_use) {  in scarlett2_autogain_switch_ctl_put()
3076 		err = -EBUSY;  in scarlett2_autogain_switch_ctl_put()
3085 		err = -EPERM;  in scarlett2_autogain_switch_ctl_put()
3089 	oval = private->autogain_switch[index];  in scarlett2_autogain_switch_ctl_put()
3090 	val = !!ucontrol->value.integer.value[0];  in scarlett2_autogain_switch_ctl_put()
3095 	private->autogain_switch[index] = val;  in scarlett2_autogain_switch_ctl_put()
3097 	/* Send switch change to the device */  in scarlett2_autogain_switch_ctl_put()
3107 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_switch_ctl_put()
3142 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_select()
3143 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_select()
3144 	int link_count = info->gain_input_count / 2;  in scarlett2_update_input_select()
3147 	private->input_select_updated = 0;  in scarlett2_update_input_select()
3154 		1, &private->input_select_switch);  in scarlett2_update_input_select()
3160 		link_count, private->input_link_switch);  in scarlett2_update_input_select()
3165 	if (private->input_link_switch[0])  in scarlett2_update_input_select()
3166 		private->input_select_switch = 0;  in scarlett2_update_input_select()
3174 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_get()
3175 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_get()
3176 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_get()
3179 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_get()
3181 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_get()
3182 		err = -EBUSY;  in scarlett2_input_select_ctl_get()
3186 	if (private->input_select_updated) {  in scarlett2_input_select_ctl_get()
3191 	ucontrol->value.enumerated.item[0] = private->input_select_switch;  in scarlett2_input_select_ctl_get()
3194 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_get()
3201 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_put()
3202 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_put()
3203 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_put()
3206 	int max_val = private->input_link_switch[0] ? 0 : 1;  in scarlett2_input_select_ctl_put()
3208 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_put()
3210 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_put()
3211 		err = -EBUSY;  in scarlett2_input_select_ctl_put()
3219 	oval = private->input_select_switch;  in scarlett2_input_select_ctl_put()
3220 	val = ucontrol->value.integer.value[0];  in scarlett2_input_select_ctl_put()
3230 	private->input_select_switch = val;  in scarlett2_input_select_ctl_put()
3232 	/* Send switch change to the device if inputs not linked */  in scarlett2_input_select_ctl_put()
3233 	if (!private->input_link_switch[0])  in scarlett2_input_select_ctl_put()
3241 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_put()
3248 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_select_ctl_info()
3249 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_select_ctl_info()
3250 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_select_ctl_info()
3252 	int inputs = private->info->gain_input_count;  in scarlett2_input_select_ctl_info()
3258 		return -ENOMEM;  in scarlett2_input_select_ctl_info()
3260 	mutex_lock(&private->data_mutex);  in scarlett2_input_select_ctl_info()
3262 	if (private->hwdep_in_use) {  in scarlett2_input_select_ctl_info()
3263 		err = -EBUSY;  in scarlett2_input_select_ctl_info()
3275 		if (private->input_link_switch[i / 2]) {  in scarlett2_input_select_ctl_info()
3277 				GFP_KERNEL, "Input %d-%d", i + 1, i + 2);  in scarlett2_input_select_ctl_info()
3289 	mutex_unlock(&private->data_mutex);  in scarlett2_input_select_ctl_info()
3308 /* snd_ctl_boolean_mono_info() with autogain-updated check
3309  * (for controls that are read-only while autogain is running)
3314 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_autogain_disables_ctl_info()
3315 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_autogain_disables_ctl_info()
3316 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_autogain_disables_ctl_info()
3319 	mutex_lock(&private->data_mutex);  in scarlett2_autogain_disables_ctl_info()
3321 	if (private->hwdep_in_use) {  in scarlett2_autogain_disables_ctl_info()
3322 		err = -EBUSY;  in scarlett2_autogain_disables_ctl_info()
3333 	mutex_unlock(&private->data_mutex);  in scarlett2_autogain_disables_ctl_info()
3340 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_link_ctl_get()
3341 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_link_ctl_get()
3342 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_link_ctl_get()
3345 	mutex_lock(&private->data_mutex);  in scarlett2_input_link_ctl_get()
3347 	if (private->hwdep_in_use) {  in scarlett2_input_link_ctl_get()
3348 		err = -EBUSY;  in scarlett2_input_link_ctl_get()
3352 	if (private->input_select_updated) {  in scarlett2_input_link_ctl_get()
3357 	ucontrol->value.enumerated.item[0] =  in scarlett2_input_link_ctl_get()
3358 		private->input_link_switch[elem->control];  in scarlett2_input_link_ctl_get()
3361 	mutex_unlock(&private->data_mutex);  in scarlett2_input_link_ctl_get()
3368 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_link_ctl_put()
3369 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_link_ctl_put()
3370 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_link_ctl_put()
3372 	int index = elem->control;  in scarlett2_input_link_ctl_put()
3375 	mutex_lock(&private->data_mutex);  in scarlett2_input_link_ctl_put()
3377 	if (private->hwdep_in_use) {  in scarlett2_input_link_ctl_put()
3378 		err = -EBUSY;  in scarlett2_input_link_ctl_put()
3386 	oval = private->input_link_switch[index];  in scarlett2_input_link_ctl_put()
3387 	val = !!ucontrol->value.integer.value[0];  in scarlett2_input_link_ctl_put()
3392 	private->input_link_switch[index] = val;  in scarlett2_input_link_ctl_put()
3395 	snd_ctl_notify(mixer->chip->card,  in scarlett2_input_link_ctl_put()
3397 		       &private->input_select_ctl->id);  in scarlett2_input_link_ctl_put()
3398 	private->input_select_updated = 1;  in scarlett2_input_link_ctl_put()
3400 	/* Send switch change to the device  in scarlett2_input_link_ctl_put()
3401 	 * Link for channels 1-2 is at index 1  in scarlett2_input_link_ctl_put()
3410 	mutex_unlock(&private->data_mutex);  in scarlett2_input_link_ctl_put()
3426 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_gain()
3427 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_gain()
3429 	private->input_gain_updated = 0;  in scarlett2_update_input_gain()
3431 	if (!info->gain_input_count)  in scarlett2_update_input_gain()
3436 		info->gain_input_count, private->gain);  in scarlett2_update_input_gain()
3442 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_info()
3443 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_info()
3444 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_info()
3447 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_info()
3449 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_info()
3450 		err = -EBUSY;  in scarlett2_input_gain_ctl_info()
3458 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_input_gain_ctl_info()
3459 	uinfo->count = elem->channels;  in scarlett2_input_gain_ctl_info()
3460 	uinfo->value.integer.min = 0;  in scarlett2_input_gain_ctl_info()
3461 	uinfo->value.integer.max = SCARLETT2_GAIN_BIAS;  in scarlett2_input_gain_ctl_info()
3462 	uinfo->value.integer.step = 1;  in scarlett2_input_gain_ctl_info()
3465 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_info()
3472 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_get()
3473 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_get()
3474 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_get()
3477 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_get()
3479 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_get()
3480 		err = -EBUSY;  in scarlett2_input_gain_ctl_get()
3484 	if (private->input_gain_updated) {  in scarlett2_input_gain_ctl_get()
3489 	ucontrol->value.integer.value[0] =  in scarlett2_input_gain_ctl_get()
3490 		private->gain[elem->control];  in scarlett2_input_gain_ctl_get()
3493 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_get()
3500 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_input_gain_ctl_put()
3501 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_input_gain_ctl_put()
3502 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_input_gain_ctl_put()
3504 	int index = elem->control;  in scarlett2_input_gain_ctl_put()
3507 	mutex_lock(&private->data_mutex);  in scarlett2_input_gain_ctl_put()
3509 	if (private->hwdep_in_use) {  in scarlett2_input_gain_ctl_put()
3510 		err = -EBUSY;  in scarlett2_input_gain_ctl_put()
3518 	oval = private->gain[index];  in scarlett2_input_gain_ctl_put()
3519 	val = ucontrol->value.integer.value[0];  in scarlett2_input_gain_ctl_put()
3524 	private->gain[index] = val;  in scarlett2_input_gain_ctl_put()
3526 	/* Send gain change to the device */  in scarlett2_input_gain_ctl_put()
3533 	mutex_unlock(&private->data_mutex);  in scarlett2_input_gain_ctl_put()
3538 	db_scale_scarlett2_gain, -SCARLETT2_GAIN_BIAS * 100, 0
3557 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_safe()
3558 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_safe()
3560 	private->input_safe_updated = 0;  in scarlett2_update_input_safe()
3562 	if (!info->gain_input_count)  in scarlett2_update_input_safe()
3567 		info->gain_input_count, private->safe_switch);  in scarlett2_update_input_safe()
3573 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_safe_ctl_get()
3574 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_safe_ctl_get()
3575 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_safe_ctl_get()
3578 	mutex_lock(&private->data_mutex);  in scarlett2_safe_ctl_get()
3580 	if (private->hwdep_in_use) {  in scarlett2_safe_ctl_get()
3581 		err = -EBUSY;  in scarlett2_safe_ctl_get()
3585 	if (private->input_safe_updated) {  in scarlett2_safe_ctl_get()
3590 	ucontrol->value.integer.value[0] =  in scarlett2_safe_ctl_get()
3591 		private->safe_switch[elem->control];  in scarlett2_safe_ctl_get()
3594 	mutex_unlock(&private->data_mutex);  in scarlett2_safe_ctl_get()
3601 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_safe_ctl_put()
3602 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_safe_ctl_put()
3603 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_safe_ctl_put()
3605 	int index = elem->control;  in scarlett2_safe_ctl_put()
3608 	mutex_lock(&private->data_mutex);  in scarlett2_safe_ctl_put()
3610 	if (private->hwdep_in_use) {  in scarlett2_safe_ctl_put()
3611 		err = -EBUSY;  in scarlett2_safe_ctl_put()
3619 	oval = private->safe_switch[index];  in scarlett2_safe_ctl_put()
3620 	val = !!ucontrol->value.integer.value[0];  in scarlett2_safe_ctl_put()
3625 	private->safe_switch[index] = val;  in scarlett2_safe_ctl_put()
3627 	/* Send switch change to the device */  in scarlett2_safe_ctl_put()
3634 	mutex_unlock(&private->data_mutex);  in scarlett2_safe_ctl_put()
3650 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_pcm_input_switch()
3653 	private->pcm_input_switch_updated = 0;  in scarlett2_update_pcm_input_switch()
3657 		1, &private->pcm_input_switch);  in scarlett2_update_pcm_input_switch()
3667 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pcm_input_switch_ctl_get()
3668 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pcm_input_switch_ctl_get()
3669 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_pcm_input_switch_ctl_get()
3672 	mutex_lock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_get()
3674 	if (private->pcm_input_switch_updated) {  in scarlett2_pcm_input_switch_ctl_get()
3679 	ucontrol->value.enumerated.item[0] = private->pcm_input_switch;  in scarlett2_pcm_input_switch_ctl_get()
3682 	mutex_unlock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_get()
3689 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pcm_input_switch_ctl_put()
3690 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pcm_input_switch_ctl_put()
3691 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pcm_input_switch_ctl_put()
3695 	mutex_lock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_put()
3697 	if (private->hwdep_in_use) {  in scarlett2_pcm_input_switch_ctl_put()
3698 		err = -EBUSY;  in scarlett2_pcm_input_switch_ctl_put()
3702 	oval = private->pcm_input_switch;  in scarlett2_pcm_input_switch_ctl_put()
3703 	val = !!ucontrol->value.integer.value[0];  in scarlett2_pcm_input_switch_ctl_put()
3708 	private->pcm_input_switch = val;  in scarlett2_pcm_input_switch_ctl_put()
3710 	/* Send switch change to the device */  in scarlett2_pcm_input_switch_ctl_put()
3718 	mutex_unlock(&private->data_mutex);  in scarlett2_pcm_input_switch_ctl_put()
3748 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_volumes()
3752 	private->vol_updated = 0;  in scarlett2_update_volumes()
3762 		private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,  in scarlett2_update_volumes()
3767 			for (i = 0; i < private->num_line_out; i++)  in scarlett2_update_volumes()
3768 				if (private->vol_sw_hw_switch[i])  in scarlett2_update_volumes()
3769 					private->vol[i] = private->master_vol;  in scarlett2_update_volumes()
3780 		private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,  in scarlett2_update_volumes()
3790 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_info()
3792 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_volume_ctl_info()
3793 	uinfo->count = elem->channels;  in scarlett2_volume_ctl_info()
3794 	uinfo->value.integer.min = 0;  in scarlett2_volume_ctl_info()
3795 	uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;  in scarlett2_volume_ctl_info()
3796 	uinfo->value.integer.step = 1;  in scarlett2_volume_ctl_info()
3803 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_master_volume_ctl_get()
3804 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_master_volume_ctl_get()
3805 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_master_volume_ctl_get()
3808 	mutex_lock(&private->data_mutex);  in scarlett2_master_volume_ctl_get()
3810 	if (private->hwdep_in_use) {  in scarlett2_master_volume_ctl_get()
3811 		err = -EBUSY;  in scarlett2_master_volume_ctl_get()
3815 	if (private->vol_updated) {  in scarlett2_master_volume_ctl_get()
3820 	ucontrol->value.integer.value[0] = private->master_vol;  in scarlett2_master_volume_ctl_get()
3823 	mutex_unlock(&private->data_mutex);  in scarlett2_master_volume_ctl_get()
3831 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_headphone_volume_ctl_get()
3832 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_headphone_volume_ctl_get()
3833 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_headphone_volume_ctl_get()
3836 	mutex_lock(&private->data_mutex);  in scarlett2_headphone_volume_ctl_get()
3838 	if (private->hwdep_in_use) {  in scarlett2_headphone_volume_ctl_get()
3839 		err = -EBUSY;  in scarlett2_headphone_volume_ctl_get()
3843 	if (private->vol_updated) {  in scarlett2_headphone_volume_ctl_get()
3848 	ucontrol->value.integer.value[0] = private->headphone_vol;  in scarlett2_headphone_volume_ctl_get()
3851 	mutex_unlock(&private->data_mutex);  in scarlett2_headphone_volume_ctl_get()
3857 	const struct scarlett2_device_info *info = private->info;  in line_out_remap()
3859 	if (!info->line_out_remap_enable)  in line_out_remap()
3862 	if (index >= private->num_line_out)  in line_out_remap()
3865 	return info->line_out_remap[index];  in line_out_remap()
3871 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_get()
3872 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_volume_ctl_get()
3873 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_volume_ctl_get()
3874 	int index = line_out_remap(private, elem->control);  in scarlett2_volume_ctl_get()
3877 	mutex_lock(&private->data_mutex);  in scarlett2_volume_ctl_get()
3879 	if (private->hwdep_in_use) {  in scarlett2_volume_ctl_get()
3880 		err = -EBUSY;  in scarlett2_volume_ctl_get()
3884 	if (private->vol_updated) {  in scarlett2_volume_ctl_get()
3889 	ucontrol->value.integer.value[0] = private->vol[index];  in scarlett2_volume_ctl_get()
3892 	mutex_unlock(&private->data_mutex);  in scarlett2_volume_ctl_get()
3899 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_volume_ctl_put()
3900 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_volume_ctl_put()
3901 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_volume_ctl_put()
3902 	int index = line_out_remap(private, elem->control);  in scarlett2_volume_ctl_put()
3905 	mutex_lock(&private->data_mutex);  in scarlett2_volume_ctl_put()
3907 	if (private->hwdep_in_use) {  in scarlett2_volume_ctl_put()
3908 		err = -EBUSY;  in scarlett2_volume_ctl_put()
3912 	oval = private->vol[index];  in scarlett2_volume_ctl_put()
3913 	val = ucontrol->value.integer.value[0];  in scarlett2_volume_ctl_put()
3918 	private->vol[index] = val;  in scarlett2_volume_ctl_put()
3920 				       index, val - SCARLETT2_VOLUME_BIAS);  in scarlett2_volume_ctl_put()
3925 	mutex_unlock(&private->data_mutex);  in scarlett2_volume_ctl_put()
3930 	db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
3971 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_dim_mute()
3975 	private->dim_mute_updated = 0;  in scarlett2_update_dim_mute()
3982 		SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);  in scarlett2_update_dim_mute()
3987 		private->dim_mute[i] = !!private->dim_mute[i];  in scarlett2_update_dim_mute()
3989 	mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];  in scarlett2_update_dim_mute()
3991 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_update_dim_mute()
3992 		if (private->vol_sw_hw_switch[i])  in scarlett2_update_dim_mute()
3993 			private->mute_switch[i] = mute;  in scarlett2_update_dim_mute()
4001 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mute_ctl_get()
4002 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mute_ctl_get()
4003 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mute_ctl_get()
4004 	int index = line_out_remap(private, elem->control);  in scarlett2_mute_ctl_get()
4007 	mutex_lock(&private->data_mutex);  in scarlett2_mute_ctl_get()
4009 	if (private->hwdep_in_use) {  in scarlett2_mute_ctl_get()
4010 		err = -EBUSY;  in scarlett2_mute_ctl_get()
4014 	if (private->dim_mute_updated) {  in scarlett2_mute_ctl_get()
4019 	ucontrol->value.integer.value[0] = private->mute_switch[index];  in scarlett2_mute_ctl_get()
4022 	mutex_unlock(&private->data_mutex);  in scarlett2_mute_ctl_get()
4029 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mute_ctl_put()
4030 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mute_ctl_put()
4031 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mute_ctl_put()
4032 	int index = line_out_remap(private, elem->control);  in scarlett2_mute_ctl_put()
4035 	mutex_lock(&private->data_mutex);  in scarlett2_mute_ctl_put()
4037 	if (private->hwdep_in_use) {  in scarlett2_mute_ctl_put()
4038 		err = -EBUSY;  in scarlett2_mute_ctl_put()
4042 	oval = private->mute_switch[index];  in scarlett2_mute_ctl_put()
4043 	val = !!ucontrol->value.integer.value[0];  in scarlett2_mute_ctl_put()
4048 	private->mute_switch[index] = val;  in scarlett2_mute_ctl_put()
4050 	/* Send mute change to the device */  in scarlett2_mute_ctl_put()
4057 	mutex_unlock(&private->data_mutex);  in scarlett2_mute_ctl_put()
4073 	private->sw_hw_ctls[index]->vd[0].access &=  in scarlett2_sw_hw_ctl_ro()
4079 	private->sw_hw_ctls[index]->vd[0].access |=  in scarlett2_sw_hw_ctl_rw()
4096 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sw_hw_enum_ctl_get()
4097 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_sw_hw_enum_ctl_get()
4098 	int index = line_out_remap(private, elem->control);  in scarlett2_sw_hw_enum_ctl_get()
4100 	ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];  in scarlett2_sw_hw_enum_ctl_get()
4107 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_vol_ctl_set_writable()
4108 	struct snd_card *card = mixer->chip->card;  in scarlett2_vol_ctl_set_writable()
4112 		private->vol_ctls[index]->vd[0].access |=  in scarlett2_vol_ctl_set_writable()
4114 		private->mute_ctls[index]->vd[0].access |=  in scarlett2_vol_ctl_set_writable()
4117 		private->vol_ctls[index]->vd[0].access &=  in scarlett2_vol_ctl_set_writable()
4119 		private->mute_ctls[index]->vd[0].access &=  in scarlett2_vol_ctl_set_writable()
4126 		       &private->vol_ctls[index]->id);  in scarlett2_vol_ctl_set_writable()
4129 		       &private->mute_ctls[index]->id);  in scarlett2_vol_ctl_set_writable()
4135 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sw_hw_change()
4139 	private->vol_sw_hw_switch[index] = val;  in scarlett2_sw_hw_change()
4141 	/* Change access mode to RO (hardware controlled volume)  in scarlett2_sw_hw_change()
4146 	/* Reset volume/mute to master volume/mute */  in scarlett2_sw_hw_change()
4147 	private->vol[index] = private->master_vol;  in scarlett2_sw_hw_change()
4148 	private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];  in scarlett2_sw_hw_change()
4150 	/* Set SW volume to current HW volume */  in scarlett2_sw_hw_change()
4153 		index, private->master_vol - SCARLETT2_VOLUME_BIAS);  in scarlett2_sw_hw_change()
4157 	/* Set SW mute to current HW mute */  in scarlett2_sw_hw_change()
4160 		index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);  in scarlett2_sw_hw_change()
4164 	/* Send SW/HW switch change to the device */  in scarlett2_sw_hw_change()
4172 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_sw_hw_enum_ctl_put()
4173 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_sw_hw_enum_ctl_put()
4174 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_sw_hw_enum_ctl_put()
4175 	int ctl_index = elem->control;  in scarlett2_sw_hw_enum_ctl_put()
4179 	mutex_lock(&private->data_mutex);  in scarlett2_sw_hw_enum_ctl_put()
4181 	if (private->hwdep_in_use) {  in scarlett2_sw_hw_enum_ctl_put()
4182 		err = -EBUSY;  in scarlett2_sw_hw_enum_ctl_put()
4186 	oval = private->vol_sw_hw_switch[index];  in scarlett2_sw_hw_enum_ctl_put()
4187 	val = !!ucontrol->value.enumerated.item[0];  in scarlett2_sw_hw_enum_ctl_put()
4197 	mutex_unlock(&private->data_mutex);  in scarlett2_sw_hw_enum_ctl_put()
4213 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_level()
4214 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_level()
4216 	private->input_level_updated = 0;  in scarlett2_update_input_level()
4218 	if (!info->level_input_count)  in scarlett2_update_input_level()
4223 		info->level_input_count + info->level_input_first,  in scarlett2_update_input_level()
4224 		private->level_switch);  in scarlett2_update_input_level()
4233 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_info()
4234 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_info()
4235 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_info()
4238 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_info()
4240 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_info()
4241 		err = -EBUSY;  in scarlett2_level_enum_ctl_info()
4252 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_info()
4259 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_get()
4260 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_get()
4261 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_get()
4262 	const struct scarlett2_device_info *info = private->info;  in scarlett2_level_enum_ctl_get()
4264 	int index = elem->control + info->level_input_first;  in scarlett2_level_enum_ctl_get()
4267 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_get()
4269 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_get()
4270 		err = -EBUSY;  in scarlett2_level_enum_ctl_get()
4274 	if (private->input_level_updated) {  in scarlett2_level_enum_ctl_get()
4279 	ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(  in scarlett2_level_enum_ctl_get()
4280 		private->level_switch[index]);  in scarlett2_level_enum_ctl_get()
4283 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_get()
4290 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_level_enum_ctl_put()
4291 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_level_enum_ctl_put()
4292 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_level_enum_ctl_put()
4293 	const struct scarlett2_device_info *info = private->info;  in scarlett2_level_enum_ctl_put()
4295 	int index = elem->control + info->level_input_first;  in scarlett2_level_enum_ctl_put()
4298 	mutex_lock(&private->data_mutex);  in scarlett2_level_enum_ctl_put()
4300 	if (private->hwdep_in_use) {  in scarlett2_level_enum_ctl_put()
4301 		err = -EBUSY;  in scarlett2_level_enum_ctl_put()
4309 	oval = private->level_switch[index];  in scarlett2_level_enum_ctl_put()
4310 	val = !!ucontrol->value.enumerated.item[0];  in scarlett2_level_enum_ctl_put()
4315 	private->level_switch[index] = val;  in scarlett2_level_enum_ctl_put()
4317 	/* To set the Gen 4 muteable controls, bit 1 gets set instead */  in scarlett2_level_enum_ctl_put()
4318 	if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)  in scarlett2_level_enum_ctl_put()
4321 	/* Send switch change to the device */  in scarlett2_level_enum_ctl_put()
4328 	mutex_unlock(&private->data_mutex);  in scarlett2_level_enum_ctl_put()
4344 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_pad()
4345 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_pad()
4347 	private->input_pad_updated = 0;  in scarlett2_update_input_pad()
4349 	if (!info->pad_input_count)  in scarlett2_update_input_pad()
4354 		info->pad_input_count, private->pad_switch);  in scarlett2_update_input_pad()
4360 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pad_ctl_get()
4361 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pad_ctl_get()
4362 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pad_ctl_get()
4365 	mutex_lock(&private->data_mutex);  in scarlett2_pad_ctl_get()
4367 	if (private->hwdep_in_use) {  in scarlett2_pad_ctl_get()
4368 		err = -EBUSY;  in scarlett2_pad_ctl_get()
4372 	if (private->input_pad_updated) {  in scarlett2_pad_ctl_get()
4377 	ucontrol->value.integer.value[0] =  in scarlett2_pad_ctl_get()
4378 		private->pad_switch[elem->control];  in scarlett2_pad_ctl_get()
4381 	mutex_unlock(&private->data_mutex);  in scarlett2_pad_ctl_get()
4388 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_pad_ctl_put()
4389 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_pad_ctl_put()
4390 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_pad_ctl_put()
4392 	int index = elem->control;  in scarlett2_pad_ctl_put()
4395 	mutex_lock(&private->data_mutex);  in scarlett2_pad_ctl_put()
4397 	if (private->hwdep_in_use) {  in scarlett2_pad_ctl_put()
4398 		err = -EBUSY;  in scarlett2_pad_ctl_put()
4402 	oval = private->pad_switch[index];  in scarlett2_pad_ctl_put()
4403 	val = !!ucontrol->value.integer.value[0];  in scarlett2_pad_ctl_put()
4408 	private->pad_switch[index] = val;  in scarlett2_pad_ctl_put()
4410 	/* Send switch change to the device */  in scarlett2_pad_ctl_put()
4417 	mutex_unlock(&private->data_mutex);  in scarlett2_pad_ctl_put()
4433 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_air()
4434 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_air()
4436 	private->input_air_updated = 0;  in scarlett2_update_input_air()
4438 	if (!info->air_input_count)  in scarlett2_update_input_air()
4443 		info->air_input_count, private->air_switch);  in scarlett2_update_input_air()
4449 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_ctl_get()
4450 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_ctl_get()
4451 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_ctl_get()
4454 	mutex_lock(&private->data_mutex);  in scarlett2_air_ctl_get()
4456 	if (private->hwdep_in_use) {  in scarlett2_air_ctl_get()
4457 		err = -EBUSY;  in scarlett2_air_ctl_get()
4461 	if (private->input_air_updated) {  in scarlett2_air_ctl_get()
4466 	ucontrol->value.integer.value[0] = private->air_switch[elem->control];  in scarlett2_air_ctl_get()
4469 	mutex_unlock(&private->data_mutex);  in scarlett2_air_ctl_get()
4476 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_ctl_put()
4477 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_ctl_put()
4478 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_ctl_put()
4480 	int index = elem->control;  in scarlett2_air_ctl_put()
4483 	mutex_lock(&private->data_mutex);  in scarlett2_air_ctl_put()
4485 	if (private->hwdep_in_use) {  in scarlett2_air_ctl_put()
4486 		err = -EBUSY;  in scarlett2_air_ctl_put()
4494 	oval = private->air_switch[index];  in scarlett2_air_ctl_put()
4495 	val = ucontrol->value.integer.value[0];  in scarlett2_air_ctl_put()
4500 	private->air_switch[index] = val;  in scarlett2_air_ctl_put()
4502 	/* Send switch change to the device */  in scarlett2_air_ctl_put()
4509 	mutex_unlock(&private->data_mutex);  in scarlett2_air_ctl_put()
4519 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_air_with_drive_ctl_info()
4520 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_air_with_drive_ctl_info()
4521 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_air_with_drive_ctl_info()
4524 	mutex_lock(&private->data_mutex);  in scarlett2_air_with_drive_ctl_info()
4526 	if (private->hwdep_in_use) {  in scarlett2_air_with_drive_ctl_info()
4527 		err = -EBUSY;  in scarlett2_air_with_drive_ctl_info()
4538 	mutex_unlock(&private->data_mutex);  in scarlett2_air_with_drive_ctl_info()
4563 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_input_phantom()
4564 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_input_phantom()
4567 	private->input_phantom_updated = 0;  in scarlett2_update_input_phantom()
4569 	if (!info->phantom_count)  in scarlett2_update_input_phantom()
4574 		info->phantom_count, private->phantom_switch);  in scarlett2_update_input_phantom()
4582 			1, &private->phantom_persistence);  in scarlett2_update_input_phantom()
4594 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_is_switching()
4595 	int index = line_num / info->inputs_per_phantom;  in scarlett2_phantom_is_switching()
4597 	return !!(private->phantom_switch[index] & 0x02);  in scarlett2_phantom_is_switching()
4603 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_update_access()
4604 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_update_access()
4608 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_phantom_update_access()
4611 		scarlett2_set_ctl_access(private->autogain_ctls[i], val);  in scarlett2_phantom_update_access()
4620 	struct snd_card *card = mixer->chip->card;  in scarlett2_phantom_notify_access()
4621 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_notify_access()
4622 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_notify_access()
4625 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_phantom_notify_access()
4627 			       &private->autogain_ctls[i]->id);  in scarlett2_phantom_notify_access()
4636 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_check_input_phantom_updated()
4639 	if (!private->input_phantom_updated)  in scarlett2_check_input_phantom_updated()
4654 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_ctl_get()
4655 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_ctl_get()
4656 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_ctl_get()
4659 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_ctl_get()
4661 	if (private->hwdep_in_use) {  in scarlett2_phantom_ctl_get()
4662 		err = -EBUSY;  in scarlett2_phantom_ctl_get()
4670 	ucontrol->value.integer.value[0] = scarlett2_decode_muteable(  in scarlett2_phantom_ctl_get()
4671 		private->phantom_switch[elem->control]);  in scarlett2_phantom_ctl_get()
4674 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_ctl_get()
4681 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_ctl_put()
4682 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_ctl_put()
4683 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_ctl_put()
4684 	const struct scarlett2_device_info *info = private->info;  in scarlett2_phantom_ctl_put()
4686 	int index = elem->control;  in scarlett2_phantom_ctl_put()
4689 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_ctl_put()
4691 	if (private->hwdep_in_use) {  in scarlett2_phantom_ctl_put()
4692 		err = -EBUSY;  in scarlett2_phantom_ctl_put()
4700 	oval = private->phantom_switch[index];  in scarlett2_phantom_ctl_put()
4701 	val = !!ucontrol->value.integer.value[0];  in scarlett2_phantom_ctl_put()
4706 	private->phantom_switch[index] = val;  in scarlett2_phantom_ctl_put()
4708 	/* To set the Gen 4 muteable controls, bit 1 gets set */  in scarlett2_phantom_ctl_put()
4709 	if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)  in scarlett2_phantom_ctl_put()
4712 	/* Send switch change to the device */  in scarlett2_phantom_ctl_put()
4714 				       index + info->phantom_first, val);  in scarlett2_phantom_ctl_put()
4722 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_ctl_put()
4739 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_persistence_ctl_get()
4740 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_phantom_persistence_ctl_get()
4742 	ucontrol->value.integer.value[0] = private->phantom_persistence;  in scarlett2_phantom_persistence_ctl_get()
4749 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_phantom_persistence_ctl_put()
4750 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_phantom_persistence_ctl_put()
4751 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_phantom_persistence_ctl_put()
4753 	int index = elem->control;  in scarlett2_phantom_persistence_ctl_put()
4756 	mutex_lock(&private->data_mutex);  in scarlett2_phantom_persistence_ctl_put()
4758 	if (private->hwdep_in_use) {  in scarlett2_phantom_persistence_ctl_put()
4759 		err = -EBUSY;  in scarlett2_phantom_persistence_ctl_put()
4763 	oval = private->phantom_persistence;  in scarlett2_phantom_persistence_ctl_put()
4764 	val = !!ucontrol->value.integer.value[0];  in scarlett2_phantom_persistence_ctl_put()
4769 	private->phantom_persistence = val;  in scarlett2_phantom_persistence_ctl_put()
4771 	/* Send switch change to the device */  in scarlett2_phantom_persistence_ctl_put()
4778 	mutex_unlock(&private->data_mutex);  in scarlett2_phantom_persistence_ctl_put()
4794 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_monitor_other()
4795 	const struct scarlett2_device_info *info = private->info;  in scarlett2_update_monitor_other()
4808 	private->monitor_other_updated = 0;  in scarlett2_update_monitor_other()
4813 	if (!info->has_speaker_switching)  in scarlett2_update_monitor_other()
4829 		private->speaker_switching_switch = 0;  in scarlett2_update_monitor_other()
4831 		private->speaker_switching_switch = monitor_other_switch[0] + 1;  in scarlett2_update_monitor_other()
4833 	if (info->has_talkback) {  in scarlett2_update_monitor_other()
4838 			private->talkback_switch = 0;  in scarlett2_update_monitor_other()
4840 			private->talkback_switch = monitor_other_switch[1] + 1;  in scarlett2_update_monitor_other()
4847 		for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)  in scarlett2_update_monitor_other()
4848 			private->talkback_map[i] = bitmap & 1;  in scarlett2_update_monitor_other()
4867 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_speaker_switch_enum_ctl_get()
4868 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_speaker_switch_enum_ctl_get()
4869 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enum_ctl_get()
4872 	mutex_lock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_get()
4874 	if (private->hwdep_in_use) {  in scarlett2_speaker_switch_enum_ctl_get()
4875 		err = -EBUSY;  in scarlett2_speaker_switch_enum_ctl_get()
4879 	if (private->monitor_other_updated) {  in scarlett2_speaker_switch_enum_ctl_get()
4884 	ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;  in scarlett2_speaker_switch_enum_ctl_get()
4887 	mutex_unlock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_get()
4892  * to HW volume and disable those controls
4896 	struct snd_card *card = mixer->chip->card;  in scarlett2_speaker_switch_enable()
4897 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enable()
4903 		/* switch the main/alt speakers to HW volume */  in scarlett2_speaker_switch_enable()
4904 		if (!private->vol_sw_hw_switch[index]) {  in scarlett2_speaker_switch_enable()
4905 			err = scarlett2_sw_hw_change(private->mixer, i, 1);  in scarlett2_speaker_switch_enable()
4915 			       &private->sw_hw_ctls[i]->id);  in scarlett2_speaker_switch_enable()
4918 	/* when the next monitor-other notify comes in, update the mux  in scarlett2_speaker_switch_enable()
4921 	private->speaker_switching_switched = 1;  in scarlett2_speaker_switch_enable()
4931 	struct snd_card *card = mixer->chip->card;  in scarlett2_speaker_switch_disable()
4932 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_disable()
4939 			       &private->sw_hw_ctls[i]->id);  in scarlett2_speaker_switch_disable()
4942 	/* when the next monitor-other notify comes in, update the mux  in scarlett2_speaker_switch_disable()
4945 	private->speaker_switching_switched = 1;  in scarlett2_speaker_switch_disable()
4951 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_speaker_switch_enum_ctl_put()
4952 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_speaker_switch_enum_ctl_put()
4953 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_speaker_switch_enum_ctl_put()
4957 	mutex_lock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_put()
4959 	if (private->hwdep_in_use) {  in scarlett2_speaker_switch_enum_ctl_put()
4960 		err = -EBUSY;  in scarlett2_speaker_switch_enum_ctl_put()
4964 	oval = private->speaker_switching_switch;  in scarlett2_speaker_switch_enum_ctl_put()
4965 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_speaker_switch_enum_ctl_put()
4970 	private->speaker_switching_switch = val;  in scarlett2_speaker_switch_enum_ctl_put()
4996 	mutex_unlock(&private->data_mutex);  in scarlett2_speaker_switch_enum_ctl_put()
5010 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_speaker_switch_ctl()
5011 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_speaker_switch_ctl()
5013 	if (!info->has_speaker_switching)  in scarlett2_add_speaker_switch_ctl()
5019 		&private->speaker_switching_ctl);  in scarlett2_add_speaker_switch_ctl()
5037 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_enum_ctl_get()
5038 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_enum_ctl_get()
5039 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_enum_ctl_get()
5042 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_get()
5044 	if (private->hwdep_in_use) {  in scarlett2_talkback_enum_ctl_get()
5045 		err = -EBUSY;  in scarlett2_talkback_enum_ctl_get()
5049 	if (private->monitor_other_updated) {  in scarlett2_talkback_enum_ctl_get()
5054 	ucontrol->value.enumerated.item[0] = private->talkback_switch;  in scarlett2_talkback_enum_ctl_get()
5057 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_get()
5064 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_enum_ctl_put()
5065 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_enum_ctl_put()
5066 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_enum_ctl_put()
5070 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_put()
5072 	if (private->hwdep_in_use) {  in scarlett2_talkback_enum_ctl_put()
5073 		err = -EBUSY;  in scarlett2_talkback_enum_ctl_put()
5077 	oval = private->talkback_switch;  in scarlett2_talkback_enum_ctl_put()
5078 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_talkback_enum_ctl_put()
5083 	private->talkback_switch = val;  in scarlett2_talkback_enum_ctl_put()
5100 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_enum_ctl_put()
5115 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_map_ctl_get()
5116 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_map_ctl_get()
5117 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_map_ctl_get()
5118 	int index = elem->control;  in scarlett2_talkback_map_ctl_get()
5120 	ucontrol->value.integer.value[0] = private->talkback_map[index];  in scarlett2_talkback_map_ctl_get()
5128 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_talkback_map_ctl_put()
5129 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_talkback_map_ctl_put()
5130 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_talkback_map_ctl_put()
5131 	int index = elem->control;  in scarlett2_talkback_map_ctl_put()
5135 	mutex_lock(&private->data_mutex);  in scarlett2_talkback_map_ctl_put()
5137 	if (private->hwdep_in_use) {  in scarlett2_talkback_map_ctl_put()
5138 		err = -EBUSY;  in scarlett2_talkback_map_ctl_put()
5142 	oval = private->talkback_map[index];  in scarlett2_talkback_map_ctl_put()
5143 	val = !!ucontrol->value.integer.value[0];  in scarlett2_talkback_map_ctl_put()
5148 	private->talkback_map[index] = val;  in scarlett2_talkback_map_ctl_put()
5150 	for (i = 0; i < private->num_mix_out; i++)  in scarlett2_talkback_map_ctl_put()
5151 		bitmap |= private->talkback_map[i] << i;  in scarlett2_talkback_map_ctl_put()
5153 	/* Send updated bitmap to the device */  in scarlett2_talkback_map_ctl_put()
5160 	mutex_unlock(&private->data_mutex);  in scarlett2_talkback_map_ctl_put()
5174 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_talkback_ctls()
5175 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_talkback_ctls()
5179 	if (!info->has_talkback)  in scarlett2_add_talkback_ctls()
5185 		&private->talkback_ctl);  in scarlett2_add_talkback_ctls()
5189 	for (i = 0; i < private->num_mix_out; i++) {  in scarlett2_add_talkback_ctls()
5206 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dim_mute_ctl_get()
5207 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dim_mute_ctl_get()
5208 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dim_mute_ctl_get()
5211 	mutex_lock(&private->data_mutex);  in scarlett2_dim_mute_ctl_get()
5213 	if (private->hwdep_in_use) {  in scarlett2_dim_mute_ctl_get()
5214 		err = -EBUSY;  in scarlett2_dim_mute_ctl_get()
5218 	if (private->dim_mute_updated) {  in scarlett2_dim_mute_ctl_get()
5223 	ucontrol->value.integer.value[0] = private->dim_mute[elem->control];  in scarlett2_dim_mute_ctl_get()
5226 	mutex_unlock(&private->data_mutex);  in scarlett2_dim_mute_ctl_get()
5233 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_dim_mute_ctl_put()
5234 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_dim_mute_ctl_put()
5235 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_dim_mute_ctl_put()
5236 	int index = elem->control;  in scarlett2_dim_mute_ctl_put()
5239 	mutex_lock(&private->data_mutex);  in scarlett2_dim_mute_ctl_put()
5241 	if (private->hwdep_in_use) {  in scarlett2_dim_mute_ctl_put()
5242 		err = -EBUSY;  in scarlett2_dim_mute_ctl_put()
5246 	oval = private->dim_mute[index];  in scarlett2_dim_mute_ctl_put()
5247 	val = !!ucontrol->value.integer.value[0];  in scarlett2_dim_mute_ctl_put()
5252 	private->dim_mute[index] = val;  in scarlett2_dim_mute_ctl_put()
5254 	/* Send switch change to the device */  in scarlett2_dim_mute_ctl_put()
5261 		for (i = 0; i < private->num_line_out; i++) {  in scarlett2_dim_mute_ctl_put()
5264 			if (private->vol_sw_hw_switch[line_index]) {  in scarlett2_dim_mute_ctl_put()
5265 				private->mute_switch[line_index] = val;  in scarlett2_dim_mute_ctl_put()
5266 				snd_ctl_notify(mixer->chip->card,  in scarlett2_dim_mute_ctl_put()
5268 					       &private->mute_ctls[i]->id);  in scarlett2_dim_mute_ctl_put()
5273 	mutex_unlock(&private->data_mutex);  in scarlett2_dim_mute_ctl_put()
5289 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_line_out_ctls()
5290 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_line_out_ctls()
5300 					    0, 1, s, &private->master_vol_ctl);  in scarlett2_add_line_out_ctls()
5312 					    &private->headphone_vol_ctl);  in scarlett2_add_line_out_ctls()
5318 	 * has per-channel line-out volume controls.  in scarlett2_add_line_out_ctls()
5325 	for (i = 0; i < private->num_line_out; i++) {  in scarlett2_add_line_out_ctls()
5329 		if (info->line_out_descrs[i])  in scarlett2_add_line_out_ctls()
5332 				 i + 1, info->line_out_descrs[i]);  in scarlett2_add_line_out_ctls()
5339 					    i, 1, s, &private->vol_ctls[i]);  in scarlett2_add_line_out_ctls()
5350 					    &private->mute_ctls[i]);  in scarlett2_add_line_out_ctls()
5358 			/* Make the fader and mute controls read-only if the  in scarlett2_add_line_out_ctls()
5359 			 * SW/HW switch is set to HW  in scarlett2_add_line_out_ctls()
5361 			if (private->vol_sw_hw_switch[index])  in scarlett2_add_line_out_ctls()
5370 						    &private->sw_hw_ctls[i]);  in scarlett2_add_line_out_ctls()
5374 			/* Make the switch read-only if the line is  in scarlett2_add_line_out_ctls()
5377 			if (private->speaker_switching_switch && i < 4)  in scarlett2_add_line_out_ctls()
5388 				&private->dim_mute_ctls[i]);  in scarlett2_add_line_out_ctls()
5400 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_line_in_ctls()
5401 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_line_in_ctls()
5405 	const char *fmt2 = "Line In %d-%d %s Capture %s";  in scarlett2_add_line_in_ctls()
5408 	for (i = 0; i < info->level_input_count; i++) {  in scarlett2_add_line_in_ctls()
5409 		scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,  in scarlett2_add_line_in_ctls()
5412 					    i, 1, s, &private->level_ctls[i]);  in scarlett2_add_line_in_ctls()
5418 	for (i = 0; i < info->pad_input_count; i++) {  in scarlett2_add_line_in_ctls()
5421 					    i, 1, s, &private->pad_ctls[i]);  in scarlett2_add_line_in_ctls()
5427 	for (i = 0; i < info->air_input_count; i++) {  in scarlett2_add_line_in_ctls()
5428 		scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,  in scarlett2_add_line_in_ctls()
5429 			  "Air", info->air_option ? "Enum" : "Switch");  in scarlett2_add_line_in_ctls()
5431 			mixer, &scarlett2_air_ctl[info->air_option],  in scarlett2_add_line_in_ctls()
5432 			i, 1, s, &private->air_ctls[i]);  in scarlett2_add_line_in_ctls()
5438 	if (info->inputs_per_phantom == 1) {  in scarlett2_add_line_in_ctls()
5439 		for (i = 0; i < info->phantom_count; i++) {  in scarlett2_add_line_in_ctls()
5441 				  i + 1 + info->phantom_first,  in scarlett2_add_line_in_ctls()
5445 				i, 1, s, &private->phantom_ctls[i]);  in scarlett2_add_line_in_ctls()
5449 	} else if (info->inputs_per_phantom > 1) {  in scarlett2_add_line_in_ctls()
5450 		for (i = 0; i < info->phantom_count; i++) {  in scarlett2_add_line_in_ctls()
5451 			int from = i * info->inputs_per_phantom + 1;  in scarlett2_add_line_in_ctls()
5452 			int to = (i + 1) * info->inputs_per_phantom;  in scarlett2_add_line_in_ctls()  local
5454 			scnprintf(s, sizeof(s), fmt2, from, to,  in scarlett2_add_line_in_ctls()
5458 				i, 1, s, &private->phantom_ctls[i]);  in scarlett2_add_line_in_ctls()
5463 	if (info->phantom_count &&  in scarlett2_add_line_in_ctls()
5473 	/* Add software-controllable input gain controls */  in scarlett2_add_line_in_ctls()
5474 	if (info->gain_input_count) {  in scarlett2_add_line_in_ctls()
5478 			&private->input_select_ctl);  in scarlett2_add_line_in_ctls()
5482 		for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_add_line_in_ctls()
5485 					  "Line In %d-%d Link Capture Switch",  in scarlett2_add_line_in_ctls()
5490 					&private->input_link_ctls[i / 2]);  in scarlett2_add_line_in_ctls()
5499 				i, 1, s, &private->input_gain_ctls[i]);  in scarlett2_add_line_in_ctls()
5507 				i, 1, s, &private->autogain_ctls[i]);  in scarlett2_add_line_in_ctls()
5515 				i, 1, s, &private->autogain_status_ctls[i]);  in scarlett2_add_line_in_ctls()
5521 				i, 1, s, &private->safe_ctls[i]);  in scarlett2_add_line_in_ctls()
5533 			&private->pcm_input_switch_ctl);  in scarlett2_add_line_in_ctls()
5545 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_mix()
5548 	private->mix_updated = 0;  in scarlett2_update_mix()
5550 	for (i = 0; i < private->num_mix_out; i++) {  in scarlett2_update_mix()
5562 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_info()
5564 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_mixer_ctl_info()
5565 	uinfo->count = elem->channels;  in scarlett2_mixer_ctl_info()
5566 	uinfo->value.integer.min = 0;  in scarlett2_mixer_ctl_info()
5567 	uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;  in scarlett2_mixer_ctl_info()
5568 	uinfo->value.integer.step = 1;  in scarlett2_mixer_ctl_info()
5575 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_get()
5576 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mixer_ctl_get()
5577 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mixer_ctl_get()
5580 	mutex_lock(&private->data_mutex);  in scarlett2_mixer_ctl_get()
5582 	if (private->hwdep_in_use) {  in scarlett2_mixer_ctl_get()
5583 		err = -EBUSY;  in scarlett2_mixer_ctl_get()
5587 	if (private->mix_updated) {  in scarlett2_mixer_ctl_get()
5592 	ucontrol->value.integer.value[0] = private->mix[elem->control];  in scarlett2_mixer_ctl_get()
5595 	mutex_unlock(&private->data_mutex);  in scarlett2_mixer_ctl_get()
5602 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mixer_ctl_put()
5603 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mixer_ctl_put()
5604 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mixer_ctl_put()
5606 	int index = elem->control;  in scarlett2_mixer_ctl_put()
5608 	mutex_lock(&private->data_mutex);  in scarlett2_mixer_ctl_put()
5610 	if (private->hwdep_in_use) {  in scarlett2_mixer_ctl_put()
5611 		err = -EBUSY;  in scarlett2_mixer_ctl_put()
5615 	oval = private->mix[index];  in scarlett2_mixer_ctl_put()
5616 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_mixer_ctl_put()
5618 	mix_num = index / private->num_mix_in;  in scarlett2_mixer_ctl_put()
5623 	private->mix[index] = val;  in scarlett2_mixer_ctl_put()
5629 	mutex_unlock(&private->data_mutex);  in scarlett2_mixer_ctl_put()
5653 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_mixer_ctls()
5658 	for (i = 0, index = 0; i < private->num_mix_out; i++)  in scarlett2_add_mixer_ctls()
5659 		for (j = 0; j < private->num_mix_in; j++, index++) {  in scarlett2_add_mixer_ctls()
5665 						    &private->mix_ctls[index]);  in scarlett2_add_mixer_ctls()
5677 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_direct_monitor()
5679 	private->direct_monitor_updated = 0;  in scarlett2_update_direct_monitor()
5681 	if (!private->info->direct_monitor)  in scarlett2_update_direct_monitor()
5686 		1, &private->direct_monitor_switch);  in scarlett2_update_direct_monitor()
5691 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_monitor_mix()
5695 	if (!private->num_monitor_mix_ctls)  in scarlett2_update_monitor_mix()
5700 		private->num_monitor_mix_ctls, mix_values);  in scarlett2_update_monitor_mix()
5704 	for (i = 0; i < private->num_monitor_mix_ctls; i++)  in scarlett2_update_monitor_mix()
5705 		private->monitor_mix[i] = scarlett2_mixer_value_to_db(  in scarlett2_update_monitor_mix()
5714 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_direct_monitor_ctl_get()
5715 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_direct_monitor_ctl_get()
5716 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_direct_monitor_ctl_get()
5719 	mutex_lock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_get()
5721 	if (private->hwdep_in_use) {  in scarlett2_direct_monitor_ctl_get()
5722 		err = -EBUSY;  in scarlett2_direct_monitor_ctl_get()
5726 	if (private->direct_monitor_updated) {  in scarlett2_direct_monitor_ctl_get()
5731 	ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;  in scarlett2_direct_monitor_ctl_get()
5734 	mutex_unlock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_get()
5741 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_direct_monitor_ctl_put()
5742 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_direct_monitor_ctl_put()
5743 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_direct_monitor_ctl_put()
5745 	int index = elem->control;  in scarlett2_direct_monitor_ctl_put()
5748 	mutex_lock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_put()
5750 	if (private->hwdep_in_use) {  in scarlett2_direct_monitor_ctl_put()
5751 		err = -EBUSY;  in scarlett2_direct_monitor_ctl_put()
5755 	oval = private->direct_monitor_switch;  in scarlett2_direct_monitor_ctl_put()
5756 	val = min(ucontrol->value.enumerated.item[0], 2U);  in scarlett2_direct_monitor_ctl_put()
5761 	private->direct_monitor_switch = val;  in scarlett2_direct_monitor_ctl_put()
5763 	/* Send switch change to the device */  in scarlett2_direct_monitor_ctl_put()
5770 	mutex_unlock(&private->data_mutex);  in scarlett2_direct_monitor_ctl_put()
5784 /* Direct Monitor for Solo is mono-only and only needs a boolean control
5807 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_monitor_mix_ctl_get()
5808 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_monitor_mix_ctl_get()
5810 	ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];  in scarlett2_monitor_mix_ctl_get()
5818 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_monitor_mix_ctl_put()
5819 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_monitor_mix_ctl_put()
5820 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_monitor_mix_ctl_put()
5822 	int index = elem->control;  in scarlett2_monitor_mix_ctl_put()
5824 	mutex_lock(&private->data_mutex);  in scarlett2_monitor_mix_ctl_put()
5826 	if (private->hwdep_in_use) {  in scarlett2_monitor_mix_ctl_put()
5827 		err = -EBUSY;  in scarlett2_monitor_mix_ctl_put()
5831 	oval = private->monitor_mix[index];  in scarlett2_monitor_mix_ctl_put()
5832 	val = clamp(ucontrol->value.integer.value[0],  in scarlett2_monitor_mix_ctl_put()
5838 	private->monitor_mix[index] = val;  in scarlett2_monitor_mix_ctl_put()
5846 	mutex_unlock(&private->data_mutex);  in scarlett2_monitor_mix_ctl_put()
5864 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_direct_monitor_ctls()
5865 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_direct_monitor_ctls()
5869 	if (!info->direct_monitor)  in scarlett2_add_direct_monitor_ctls()
5872 	s = info->direct_monitor == 1  in scarlett2_add_direct_monitor_ctls()
5877 		mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],  in scarlett2_add_direct_monitor_ctls()
5878 		0, 1, s, &private->direct_monitor_ctl);  in scarlett2_add_direct_monitor_ctls()
5882 	if (!private->num_monitor_mix_ctls)  in scarlett2_add_direct_monitor_ctls()
5886 	for (i = 0, index = 0; i < info->direct_monitor; i++) {  in scarlett2_add_direct_monitor_ctls()
5891 		if (info->direct_monitor == 1)  in scarlett2_add_direct_monitor_ctls()
5902 			for (k = 0; k < private->num_mix_in; k++, index++) {  in scarlett2_add_direct_monitor_ctls()
5924 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_info()
5925 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_mux_src_enum_ctl_info()
5926 	const struct scarlett2_device_info *info = private->info;  in scarlett2_mux_src_enum_ctl_info()
5927 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_mux_src_enum_ctl_info()
5928 	unsigned int item = uinfo->value.enumerated.item;  in scarlett2_mux_src_enum_ctl_info()
5929 	int items = private->num_mux_srcs;  in scarlett2_mux_src_enum_ctl_info()
5932 	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;  in scarlett2_mux_src_enum_ctl_info()
5933 	uinfo->count = elem->channels;  in scarlett2_mux_src_enum_ctl_info()
5934 	uinfo->value.enumerated.items = items;  in scarlett2_mux_src_enum_ctl_info()
5937 		item = uinfo->value.enumerated.item = items - 1;  in scarlett2_mux_src_enum_ctl_info()
5947 			    item >= private->num_mix_out)  in scarlett2_mux_src_enum_ctl_info()
5948 				sprintf(uinfo->value.enumerated.name,  in scarlett2_mux_src_enum_ctl_info()
5949 					port->dsp_src_descr,  in scarlett2_mux_src_enum_ctl_info()
5950 					item - private->num_mix_out + 1);  in scarlett2_mux_src_enum_ctl_info()
5952 				sprintf(uinfo->value.enumerated.name,  in scarlett2_mux_src_enum_ctl_info()
5953 					port->src_descr,  in scarlett2_mux_src_enum_ctl_info()
5954 					item + port->src_num_offset);  in scarlett2_mux_src_enum_ctl_info()
5958 		item -= port_count[port_type][SCARLETT2_PORT_IN];  in scarlett2_mux_src_enum_ctl_info()
5961 	return -EINVAL;  in scarlett2_mux_src_enum_ctl_info()
5967 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_get()
5968 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mux_src_enum_ctl_get()
5969 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mux_src_enum_ctl_get()
5970 	int index = line_out_remap(private, elem->control);  in scarlett2_mux_src_enum_ctl_get()
5973 	mutex_lock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_get()
5975 	if (private->hwdep_in_use) {  in scarlett2_mux_src_enum_ctl_get()
5976 		err = -EBUSY;  in scarlett2_mux_src_enum_ctl_get()
5980 	if (private->mux_updated) {  in scarlett2_mux_src_enum_ctl_get()
5985 	ucontrol->value.enumerated.item[0] = private->mux[index];  in scarlett2_mux_src_enum_ctl_get()
5988 	mutex_unlock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_get()
5995 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_mux_src_enum_ctl_put()
5996 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_mux_src_enum_ctl_put()
5997 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_mux_src_enum_ctl_put()
5998 	int index = line_out_remap(private, elem->control);  in scarlett2_mux_src_enum_ctl_put()
6001 	mutex_lock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_put()
6003 	if (private->hwdep_in_use) {  in scarlett2_mux_src_enum_ctl_put()
6004 		err = -EBUSY;  in scarlett2_mux_src_enum_ctl_put()
6008 	oval = private->mux[index];  in scarlett2_mux_src_enum_ctl_put()
6009 	val = min(ucontrol->value.enumerated.item[0],  in scarlett2_mux_src_enum_ctl_put()
6010 		  private->num_mux_srcs - 1U);  in scarlett2_mux_src_enum_ctl_put()
6015 	private->mux[index] = val;  in scarlett2_mux_src_enum_ctl_put()
6021 	mutex_unlock(&private->data_mutex);  in scarlett2_mux_src_enum_ctl_put()
6035 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_mux_enums()
6036 	const struct scarlett2_device_info *info = private->info;  in scarlett2_add_mux_enums()
6037 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_add_mux_enums()
6051 			const char *descr = port->dst_descr;  in scarlett2_add_mux_enums()
6054 			    channel >= private->num_mix_in) {  in scarlett2_add_mux_enums()
6055 				channel_num -= private->num_mix_in;  in scarlett2_add_mux_enums()
6056 				descr = port->dsp_dst_descr;  in scarlett2_add_mux_enums()
6059 			snprintf(s, sizeof(s) - 5, descr, channel_num);  in scarlett2_add_mux_enums()
6065 						    &private->mux_ctls[i]);  in scarlett2_add_mux_enums()
6079 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_meter_ctl_info()
6081 	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;  in scarlett2_meter_ctl_info()
6082 	uinfo->count = elem->channels;  in scarlett2_meter_ctl_info()
6083 	uinfo->value.integer.min = 0;  in scarlett2_meter_ctl_info()
6084 	uinfo->value.integer.max = 4095;  in scarlett2_meter_ctl_info()
6085 	uinfo->value.integer.step = 1;  in scarlett2_meter_ctl_info()
6092 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_meter_ctl_get()
6093 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_meter_ctl_get()
6094 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_meter_ctl_get()
6095 	u8 *meter_level_map = private->meter_level_map;  in scarlett2_meter_ctl_get()
6099 	mutex_lock(&private->data_mutex);  in scarlett2_meter_ctl_get()
6101 	if (private->hwdep_in_use) {  in scarlett2_meter_ctl_get()
6102 		err = -EBUSY;  in scarlett2_meter_ctl_get()
6106 	err = scarlett2_usb_get_meter_levels(mixer, elem->channels,  in scarlett2_meter_ctl_get()
6112 	for (i = 0; i < elem->channels; i++) {  in scarlett2_meter_ctl_get()
6121 		ucontrol->value.integer.value[i] = value;  in scarlett2_meter_ctl_get()
6125 	mutex_unlock(&private->data_mutex);  in scarlett2_meter_ctl_get()
6140 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_meter_ctl()
6147 				     0, private->num_mux_dsts,  in scarlett2_add_meter_ctl()
6156 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_msd_ctl_get()
6157 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_msd_ctl_get()
6159 	ucontrol->value.integer.value[0] = private->msd_switch;  in scarlett2_msd_ctl_get()
6166 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_msd_ctl_put()
6167 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_msd_ctl_put()
6168 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_msd_ctl_put()
6172 	mutex_lock(&private->data_mutex);  in scarlett2_msd_ctl_put()
6174 	if (private->hwdep_in_use) {  in scarlett2_msd_ctl_put()
6175 		err = -EBUSY;  in scarlett2_msd_ctl_put()
6179 	oval = private->msd_switch;  in scarlett2_msd_ctl_put()
6180 	val = !!ucontrol->value.integer.value[0];  in scarlett2_msd_ctl_put()
6185 	private->msd_switch = val;  in scarlett2_msd_ctl_put()
6187 	/* Send switch change to the device */  in scarlett2_msd_ctl_put()
6194 	mutex_unlock(&private->data_mutex);  in scarlett2_msd_ctl_put()
6208 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_msd_ctl()
6214 	if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))  in scarlett2_add_msd_ctl()
6227 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_standalone_ctl_get()
6228 	struct scarlett2_data *private = elem->head.mixer->private_data;  in scarlett2_standalone_ctl_get()
6230 	ucontrol->value.integer.value[0] = private->standalone_switch;  in scarlett2_standalone_ctl_get()
6237 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_standalone_ctl_put()
6238 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_standalone_ctl_put()
6239 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_standalone_ctl_put()
6243 	mutex_lock(&private->data_mutex);  in scarlett2_standalone_ctl_put()
6245 	if (private->hwdep_in_use) {  in scarlett2_standalone_ctl_put()
6246 		err = -EBUSY;  in scarlett2_standalone_ctl_put()
6250 	oval = private->standalone_switch;  in scarlett2_standalone_ctl_put()
6251 	val = !!ucontrol->value.integer.value[0];  in scarlett2_standalone_ctl_put()
6256 	private->standalone_switch = val;  in scarlett2_standalone_ctl_put()
6258 	/* Send switch change to the device */  in scarlett2_standalone_ctl_put()
6266 	mutex_unlock(&private->data_mutex);  in scarlett2_standalone_ctl_put()
6280 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_standalone_ctl()
6295 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_update_power_status()
6300 	private->power_status_updated = 0;  in scarlett2_update_power_status()
6313 		private->power_status = SCARLETT2_POWER_STATUS_FAIL;  in scarlett2_update_power_status()
6315 		private->power_status = SCARLETT2_POWER_STATUS_EXT;  in scarlett2_update_power_status()
6317 		private->power_status = SCARLETT2_POWER_STATUS_BUS;  in scarlett2_update_power_status()
6325 	struct usb_mixer_elem_info *elem = kctl->private_data;  in scarlett2_power_status_ctl_get()
6326 	struct usb_mixer_interface *mixer = elem->head.mixer;  in scarlett2_power_status_ctl_get()
6327 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_power_status_ctl_get()
6330 	mutex_lock(&private->data_mutex);  in scarlett2_power_status_ctl_get()
6332 	if (private->power_status_updated) {  in scarlett2_power_status_ctl_get()
6337 	ucontrol->value.integer.value[0] = private->power_status;  in scarlett2_power_status_ctl_get()
6340 	mutex_unlock(&private->data_mutex);  in scarlett2_power_status_ctl_get()
6364 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_add_power_status_ctl()
6373 				     &private->power_status_ctl);  in scarlett2_add_power_status_ctl()
6380 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_private_free()
6382 	cancel_delayed_work_sync(&private->work);  in scarlett2_private_free()
6384 	mixer->private_data = NULL;  in scarlett2_private_free()
6389 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_private_suspend()
6391 	if (cancel_delayed_work_sync(&private->work))  in scarlett2_private_suspend()
6392 		scarlett2_config_save(private->mixer);  in scarlett2_private_suspend()
6399 	const struct scarlett2_device_info *info = private->info;  in scarlett2_count_io()
6400 	const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;  in scarlett2_count_io()
6411 	private->num_mux_srcs = srcs;  in scarlett2_count_io()
6412 	private->num_mux_dsts = dsts;  in scarlett2_count_io()
6418 	private->num_mix_in =  in scarlett2_count_io()
6419 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -  in scarlett2_count_io()
6420 			info->dsp_count;  in scarlett2_count_io()
6422 	private->num_mix_out =  in scarlett2_count_io()
6423 		port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -  in scarlett2_count_io()
6424 			info->dsp_count;  in scarlett2_count_io()
6427 	private->num_line_out =  in scarlett2_count_io()
6431 	private->num_monitor_mix_ctls =  in scarlett2_count_io()
6432 		info->direct_monitor * 2 * private->num_mix_in;  in scarlett2_count_io()
6443 	struct usb_host_config *config = dev->actconfig;  in scarlett2_find_fc_interface()
6446 	for (i = 0; i < config->desc.bNumInterfaces; i++) {  in scarlett2_find_fc_interface()
6447 		struct usb_interface *intf = config->interface[i];  in scarlett2_find_fc_interface()
6449 			&intf->altsetting[0].desc;  in scarlett2_find_fc_interface()
6452 		if (desc->bInterfaceClass != 255)  in scarlett2_find_fc_interface()
6455 		epd = get_endpoint(intf->altsetting, 0);  in scarlett2_find_fc_interface()
6456 		private->bInterfaceNumber = desc->bInterfaceNumber;  in scarlett2_find_fc_interface()
6457 		private->bEndpointAddress = epd->bEndpointAddress &  in scarlett2_find_fc_interface()
6459 		private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);  in scarlett2_find_fc_interface()
6460 		private->bInterval = epd->bInterval;  in scarlett2_find_fc_interface()
6464 	return -EINVAL;  in scarlett2_find_fc_interface()
6475 		return -ENOMEM;  in scarlett2_init_private()
6477 	mutex_init(&private->usb_mutex);  in scarlett2_init_private()
6478 	mutex_init(&private->data_mutex);  in scarlett2_init_private()
6479 	INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);  in scarlett2_init_private()
6481 	mixer->private_data = private;  in scarlett2_init_private()
6482 	mixer->private_free = scarlett2_private_free;  in scarlett2_init_private()
6483 	mixer->private_suspend = scarlett2_private_suspend;  in scarlett2_init_private()
6485 	private->info = entry->info;  in scarlett2_init_private()
6486 	private->config_set = entry->info->config_set;  in scarlett2_init_private()
6487 	private->series_name = entry->series_name;  in scarlett2_init_private()
6489 	private->scarlett2_seq = 0;  in scarlett2_init_private()
6490 	private->mixer = mixer;  in scarlett2_init_private()
6492 	return scarlett2_find_fc_interface(mixer->chip->dev, private);  in scarlett2_init_private()
6498 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_usb_init()
6499 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_usb_init()
6505 		return -EINVAL;  in scarlett2_usb_init()
6508 	err = scarlett2_usb_rx(dev, private->bInterfaceNumber,  in scarlett2_usb_init()
6515 	private->scarlett2_seq = 1;  in scarlett2_usb_init()
6521 	private->scarlett2_seq = 1;  in scarlett2_usb_init()
6528 	/* extract 4-byte firmware version from step2_buf[8] */  in scarlett2_usb_init()
6529 	private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));  in scarlett2_usb_init()
6530 	usb_audio_info(mixer->chip,  in scarlett2_usb_init()
6532 		       private->firmware_version);  in scarlett2_usb_init()
6542 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_get_flash_segment_nums()
6568 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
6570 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
6581 			usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
6582 				"failed to get flash segment info %d: %d\n",  in scarlett2_get_flash_segment_nums()
6596 		private->flash_segment_nums[flash_segment_id] = i;  in scarlett2_get_flash_segment_nums()
6597 		private->flash_segment_blocks[flash_segment_id] =  in scarlett2_get_flash_segment_nums()
6602 	/* segment 0 is App_Gold and we never want to touch that, so  in scarlett2_get_flash_segment_nums()
6603 	 * use 0 as the "not-found" value  in scarlett2_get_flash_segment_nums()
6605 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {  in scarlett2_get_flash_segment_nums()
6606 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
6607 			      "failed to find flash segment %s\n",  in scarlett2_get_flash_segment_nums()
6609 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
6611 	if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {  in scarlett2_get_flash_segment_nums()
6612 		usb_audio_err(mixer->chip,  in scarlett2_get_flash_segment_nums()
6613 			      "failed to find flash segment %s\n",  in scarlett2_get_flash_segment_nums()
6615 		return -EINVAL;  in scarlett2_get_flash_segment_nums()
6624 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_read_configs()
6625 	const struct scarlett2_device_info *info = private->info;  in scarlett2_read_configs()
6631 			1, &private->msd_switch);  in scarlett2_read_configs()
6636 	if (private->firmware_version < info->min_firmware_version) {  in scarlett2_read_configs()
6637 		usb_audio_err(mixer->chip,  in scarlett2_read_configs()
6640 			      private->series_name,  in scarlett2_read_configs()
6641 			      private->firmware_version,  in scarlett2_read_configs()
6642 			      info->min_firmware_version);  in scarlett2_read_configs()
6647 	if (private->msd_switch)  in scarlett2_read_configs()
6686 			1, &private->standalone_switch);  in scarlett2_read_configs()
6709 			private->num_line_out, &sw_vol);  in scarlett2_read_configs()
6713 		for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
6714 			private->vol[i] = clamp(  in scarlett2_read_configs()
6721 			private->num_line_out, &private->mute_switch);  in scarlett2_read_configs()
6725 		for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
6726 			private->mute_switch[i] =  in scarlett2_read_configs()
6727 				!!private->mute_switch[i];  in scarlett2_read_configs()
6734 				private->num_line_out,  in scarlett2_read_configs()
6735 				&private->vol_sw_hw_switch);  in scarlett2_read_configs()
6739 			for (i = 0; i < private->num_line_out; i++)  in scarlett2_read_configs()
6740 				private->vol_sw_hw_switch[i] =  in scarlett2_read_configs()
6741 					!!private->vol_sw_hw_switch[i];  in scarlett2_read_configs()
6786 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_sync()
6788 	private->sync_updated = 1;  in scarlett2_notify_sync()
6790 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_sync()
6791 		       &private->sync_ctl->id);  in scarlett2_notify_sync()
6797 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_monitor()
6798 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_monitor()
6804 	private->vol_updated = 1;  in scarlett2_notify_monitor()
6806 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_monitor()
6807 		       &private->master_vol_ctl->id);  in scarlett2_notify_monitor()
6809 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_notify_monitor()
6810 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])  in scarlett2_notify_monitor()
6812 				       &private->vol_ctls[i]->id);  in scarlett2_notify_monitor()
6818 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_volume()
6820 	private->vol_updated = 1;  in scarlett2_notify_volume()
6822 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_volume()
6823 		       &private->master_vol_ctl->id);  in scarlett2_notify_volume()
6824 	snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,  in scarlett2_notify_volume()
6825 		       &private->headphone_vol_ctl->id);  in scarlett2_notify_volume()
6831 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_dim_mute()
6832 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_dim_mute()
6838 	private->dim_mute_updated = 1;  in scarlett2_notify_dim_mute()
6842 			       &private->dim_mute_ctls[i]->id);  in scarlett2_notify_dim_mute()
6844 	for (i = 0; i < private->num_line_out; i++)  in scarlett2_notify_dim_mute()
6845 		if (private->vol_sw_hw_switch[line_out_remap(private, i)])  in scarlett2_notify_dim_mute()
6847 				       &private->mute_ctls[i]->id);  in scarlett2_notify_dim_mute()
6853 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_level()
6854 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_level()
6855 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_level()
6858 	private->input_level_updated = 1;  in scarlett2_notify_input_level()
6860 	for (i = 0; i < info->level_input_count; i++)  in scarlett2_notify_input_level()
6862 			       &private->level_ctls[i]->id);  in scarlett2_notify_input_level()
6868 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_pad()
6869 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_pad()
6870 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_pad()
6873 	private->input_pad_updated = 1;  in scarlett2_notify_input_pad()
6875 	for (i = 0; i < info->pad_input_count; i++)  in scarlett2_notify_input_pad()
6877 			       &private->pad_ctls[i]->id);  in scarlett2_notify_input_pad()
6883 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_air()
6884 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_air()
6885 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_air()
6888 	private->input_air_updated = 1;  in scarlett2_notify_input_air()
6890 	for (i = 0; i < info->air_input_count; i++)  in scarlett2_notify_input_air()
6892 			       &private->air_ctls[i]->id);  in scarlett2_notify_input_air()
6898 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_phantom()
6899 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_phantom()
6900 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_phantom()
6903 	private->input_phantom_updated = 1;  in scarlett2_notify_input_phantom()
6905 	for (i = 0; i < info->phantom_count; i++)  in scarlett2_notify_input_phantom()
6907 			       &private->phantom_ctls[i]->id);  in scarlett2_notify_input_phantom()
6924 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_select()
6925 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_select()
6926 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_select()
6929 	if (!info->gain_input_count)  in scarlett2_notify_input_select()
6932 	private->input_select_updated = 1;  in scarlett2_notify_input_select()
6936 		       &private->input_select_ctl->id);  in scarlett2_notify_input_select()
6938 	for (i = 0; i < info->gain_input_count / 2; i++)  in scarlett2_notify_input_select()
6940 			       &private->input_link_ctls[i]->id);  in scarlett2_notify_input_select()
6946 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_gain()
6947 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_gain()
6948 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_gain()
6951 	if (!info->gain_input_count)  in scarlett2_notify_input_gain()
6954 	private->input_gain_updated = 1;  in scarlett2_notify_input_gain()
6956 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_notify_input_gain()
6958 			       &private->input_gain_ctls[i]->id);  in scarlett2_notify_input_gain()
6964 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_autogain()
6965 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_autogain()
6966 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_autogain()
6969 	if (!info->gain_input_count)  in scarlett2_notify_autogain()
6972 	private->autogain_updated = 1;  in scarlett2_notify_autogain()
6974 	for (i = 0; i < info->gain_input_count; i++) {  in scarlett2_notify_autogain()
6976 			       &private->autogain_ctls[i]->id);  in scarlett2_notify_autogain()
6978 			       &private->autogain_status_ctls[i]->id);  in scarlett2_notify_autogain()
6987 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_input_safe()
6988 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_input_safe()
6989 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_input_safe()
6992 	if (!info->gain_input_count)  in scarlett2_notify_input_safe()
6995 	private->input_safe_updated = 1;  in scarlett2_notify_input_safe()
6997 	for (i = 0; i < info->gain_input_count; i++)  in scarlett2_notify_input_safe()
6999 			       &private->safe_ctls[i]->id);  in scarlett2_notify_input_safe()
7005 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_monitor_other()
7006 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_monitor_other()
7007 	const struct scarlett2_device_info *info = private->info;  in scarlett2_notify_monitor_other()
7009 	private->monitor_other_updated = 1;  in scarlett2_notify_monitor_other()
7011 	if (info->has_speaker_switching)  in scarlett2_notify_monitor_other()
7013 			       &private->speaker_switching_ctl->id);  in scarlett2_notify_monitor_other()
7015 	if (info->has_talkback)  in scarlett2_notify_monitor_other()
7017 			       &private->talkback_ctl->id);  in scarlett2_notify_monitor_other()
7022 	if (private->speaker_switching_switched) {  in scarlett2_notify_monitor_other()
7027 		private->speaker_switching_switched = 0;  in scarlett2_notify_monitor_other()
7028 		private->mux_updated = 1;  in scarlett2_notify_monitor_other()
7030 		for (i = 0; i < private->num_mux_dsts; i++)  in scarlett2_notify_monitor_other()
7032 				       &private->mux_ctls[i]->id);  in scarlett2_notify_monitor_other()
7039 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_direct_monitor()
7040 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_direct_monitor()
7041 	int count = private->num_mix_in * private->num_mix_out;  in scarlett2_notify_direct_monitor()
7044 	private->direct_monitor_updated = 1;  in scarlett2_notify_direct_monitor()
7047 		       &private->direct_monitor_ctl->id);  in scarlett2_notify_direct_monitor()
7052 	private->mix_updated = 1;  in scarlett2_notify_direct_monitor()
7054 	/* Notify of change to the mix controls */  in scarlett2_notify_direct_monitor()
7057 			       &private->mix_ctls[i]->id);  in scarlett2_notify_direct_monitor()
7063 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_power_status()
7064 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_power_status()
7066 	private->power_status_updated = 1;  in scarlett2_notify_power_status()
7069 		       &private->power_status_ctl->id);  in scarlett2_notify_power_status()
7075 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_mux()
7076 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_mux()
7079 	private->mux_updated = 1;  in scarlett2_notify_mux()
7081 	for (i = 0; i < private->num_mux_dsts; i++)  in scarlett2_notify_mux()
7083 			       &private->mux_ctls[i]->id);  in scarlett2_notify_mux()
7089 	struct snd_card *card = mixer->chip->card;  in scarlett2_notify_pcm_input_switch()
7090 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify_pcm_input_switch()
7092 	private->pcm_input_switch_updated = 1;  in scarlett2_notify_pcm_input_switch()
7095 		       &private->pcm_input_switch_ctl->id);  in scarlett2_notify_pcm_input_switch()
7103 	struct usb_mixer_interface *mixer = urb->context;  in scarlett2_notify()
7104 	int len = urb->actual_length;  in scarlett2_notify()
7105 	int ustatus = urb->status;  in scarlett2_notify()
7107 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_notify()
7109 		private->config_set->notifications;  in scarlett2_notify()
7114 	data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);  in scarlett2_notify()
7116 	while (data && notifications->mask) {  in scarlett2_notify()
7117 		if (data & notifications->mask) {  in scarlett2_notify()
7118 			data &= ~notifications->mask;  in scarlett2_notify()
7119 			if (notifications->func)  in scarlett2_notify()
7120 				notifications->func(mixer);  in scarlett2_notify()
7126 		usb_audio_warn(mixer->chip,  in scarlett2_notify()
7131 	if (ustatus != -ENOENT &&  in scarlett2_notify()
7132 	    ustatus != -ECONNRESET &&  in scarlett2_notify()
7133 	    ustatus != -ESHUTDOWN) {  in scarlett2_notify()
7134 		urb->dev = mixer->chip->dev;  in scarlett2_notify()
7141 	struct usb_device *dev = mixer->chip->dev;  in scarlett2_init_notify()
7142 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_init_notify()
7143 	unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);  in scarlett2_init_notify()
7146 	if (mixer->urb) {  in scarlett2_init_notify()
7147 		usb_audio_err(mixer->chip,  in scarlett2_init_notify()
7153 		return -EINVAL;  in scarlett2_init_notify()
7155 	mixer->urb = usb_alloc_urb(0, GFP_KERNEL);  in scarlett2_init_notify()
7156 	if (!mixer->urb)  in scarlett2_init_notify()
7157 		return -ENOMEM;  in scarlett2_init_notify()
7159 	transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);  in scarlett2_init_notify()
7161 		return -ENOMEM;  in scarlett2_init_notify()
7163 	usb_fill_int_urb(mixer->urb, dev, pipe,  in scarlett2_init_notify()
7164 			 transfer_buffer, private->wMaxPacketSize,  in scarlett2_init_notify()
7165 			 scarlett2_notify, mixer, private->bInterval);  in scarlett2_init_notify()
7167 	return usb_submit_urb(mixer->urb, GFP_KERNEL);  in scarlett2_init_notify()
7176 	while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)  in get_scarlett2_device_entry()
7178 	if (!entry->usb_id)  in get_scarlett2_device_entry()
7196 	private = mixer->private_data;  in snd_scarlett2_controls_create()
7231 	if (private->msd_switch ||  in snd_scarlett2_controls_create()
7232 	    private->firmware_version < private->info->min_firmware_version)  in snd_scarlett2_controls_create()
7293 	if (private->info->gain_input_count) {  in snd_scarlett2_controls_create()
7308 /* Set private->hwdep_in_use; prevents access to the ALSA controls
7313 	mutex_lock(&private->data_mutex);  in scarlett2_lock()
7314 	private->hwdep_in_use = 1;  in scarlett2_lock()
7315 	mutex_unlock(&private->data_mutex);  in scarlett2_lock()
7318 /* Call SCARLETT2_USB_GET_ERASE to get the erase progress */
7321 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_get_erase_progress()
7330 	segment_id = private->selected_flash_segment_id;  in scarlett2_get_erase_progress()
7331 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_get_erase_progress()
7335 		return -EFAULT;  in scarlett2_get_erase_progress()
7369 	return -ETIMEDOUT;  in scarlett2_wait_for_erase()
7372 /* Reboot the device; wait for the erase to complete if one is in
7377 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_reboot()
7379 	if (private->flash_write_state ==  in scarlett2_reboot()
7390 /* Select a flash segment for erasing (and possibly writing to) */
7395 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_select_flash_segment()
7399 		return -EFAULT;  in scarlett2_ioctl_select_flash_segment()
7403 		return -EINVAL;  in scarlett2_ioctl_select_flash_segment()
7405 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_select_flash_segment()
7408 		usb_audio_err(mixer->chip,  in scarlett2_ioctl_select_flash_segment()
7411 		return -EFAULT;  in scarlett2_ioctl_select_flash_segment()
7414 	/* If erasing, wait for it to complete */  in scarlett2_ioctl_select_flash_segment()
7415 	if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {  in scarlett2_ioctl_select_flash_segment()
7422 	/* Save the selected segment ID and set the state to SELECTED */  in scarlett2_ioctl_select_flash_segment()
7423 	private->selected_flash_segment_id = segment_id;  in scarlett2_ioctl_select_flash_segment()
7424 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;  in scarlett2_ioctl_select_flash_segment()
7429 /* Erase the previously-selected flash segment */
7433 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_erase_flash_segment()
7441 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)  in scarlett2_ioctl_erase_flash_segment()
7442 		return -EINVAL;  in scarlett2_ioctl_erase_flash_segment()
7444 	segment_id = private->selected_flash_segment_id;  in scarlett2_ioctl_erase_flash_segment()
7445 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_erase_flash_segment()
7449 		return -EFAULT;  in scarlett2_ioctl_erase_flash_segment()
7451 	/* Prevent access to ALSA controls that access the device from  in scarlett2_ioctl_erase_flash_segment()
7466 	/* On success, change the state from SELECTED to ERASING */  in scarlett2_ioctl_erase_flash_segment()
7467 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;  in scarlett2_ioctl_erase_flash_segment()
7477 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_ioctl_get_erase_progress()
7488 	if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)  in scarlett2_ioctl_get_erase_progress()
7489 		return -EINVAL;  in scarlett2_ioctl_get_erase_progress()
7491 	segment_id = private->selected_flash_segment_id;  in scarlett2_ioctl_get_erase_progress()
7492 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_ioctl_get_erase_progress()
7496 		return -EFAULT;  in scarlett2_ioctl_get_erase_progress()
7509 	progress.num_blocks = private->flash_segment_blocks[segment_id];  in scarlett2_ioctl_get_erase_progress()
7512 		return -EFAULT;  in scarlett2_ioctl_get_erase_progress()
7514 	/* If the erase is complete, change the state from ERASING to  in scarlett2_ioctl_get_erase_progress()
7518 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;  in scarlett2_ioctl_get_erase_progress()
7525 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_open()
7526 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_open()
7528 	/* If erasing, wait for it to complete */  in scarlett2_hwdep_open()
7529 	if (private->flash_write_state ==  in scarlett2_hwdep_open()
7537 	/* Set the state to IDLE */  in scarlett2_hwdep_open()
7538 	private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;  in scarlett2_hwdep_open()
7546 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_ioctl()
7552 				(int __user *)arg) ? -EFAULT : 0;  in scarlett2_hwdep_ioctl()
7567 		return -ENOIOCTLCMD;  in scarlett2_hwdep_ioctl()
7575 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_write()
7576 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_write()
7589 	const size_t max_data_size = SCARLETT2_FLASH_WRITE_MAX -  in scarlett2_hwdep_write()
7592 	/* If erasing, wait for it to complete */  in scarlett2_hwdep_write()
7593 	if (private->flash_write_state ==  in scarlett2_hwdep_write()
7598 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;  in scarlett2_hwdep_write()
7601 	} else if (private->flash_write_state !=  in scarlett2_hwdep_write()
7603 		return -EINVAL;  in scarlett2_hwdep_write()
7606 	/* Check that we're writing to the upgrade firmware */  in scarlett2_hwdep_write()
7607 	segment_id = private->selected_flash_segment_id;  in scarlett2_hwdep_write()
7609 		return -EINVAL;  in scarlett2_hwdep_write()
7611 	segment_num = private->flash_segment_nums[segment_id];  in scarlett2_hwdep_write()
7614 		return -EFAULT;  in scarlett2_hwdep_write()
7617 	flash_size = private->flash_segment_blocks[segment_id] *  in scarlett2_hwdep_write()
7621 		return -EINVAL;  in scarlett2_hwdep_write()
7626 	/* Limit the *req size to SCARLETT2_FLASH_WRITE_MAX */  in scarlett2_hwdep_write()
7634 		return -ENOMEM;  in scarlett2_hwdep_write()
7636 	req->segment_num = cpu_to_le32(segment_num);  in scarlett2_hwdep_write()
7637 	req->offset = cpu_to_le32(*offset);  in scarlett2_hwdep_write()
7638 	req->pad = 0;  in scarlett2_hwdep_write()
7640 	if (copy_from_user(req->data, buf, count)) {  in scarlett2_hwdep_write()
7641 		err = -EFAULT;  in scarlett2_hwdep_write()
7660 	struct usb_mixer_interface *mixer = hw->private_data;  in scarlett2_hwdep_release()
7661 	struct scarlett2_data *private = mixer->private_data;  in scarlett2_hwdep_release()
7663 	/* Return from the SELECTED or WRITE state to IDLE.  in scarlett2_hwdep_release()
7664 	 * The ERASING state is left as-is, and checked on next open.  in scarlett2_hwdep_release()
7667 	    private->hwdep_in_use &&  in scarlett2_hwdep_release()
7668 	    private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)  in scarlett2_hwdep_release()
7669 		private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;  in scarlett2_hwdep_release()
7679 	err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);  in scarlett2_hwdep_init()
7683 	hw->private_data = mixer;  in scarlett2_hwdep_init()
7684 	hw->exclusive = 1;  in scarlett2_hwdep_init()
7685 	hw->ops.open = scarlett2_hwdep_open;  in scarlett2_hwdep_init()
7686 	hw->ops.ioctl = scarlett2_hwdep_ioctl;  in scarlett2_hwdep_init()
7687 	hw->ops.write = scarlett2_hwdep_write;  in scarlett2_hwdep_init()
7688 	hw->ops.release = scarlett2_hwdep_release;  in scarlett2_hwdep_init()
7695 	struct snd_usb_audio *chip = mixer->chip;  in snd_scarlett2_init()
7700 	if (!mixer->protocol)  in snd_scarlett2_init()
7706 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
7709 			      USB_ID_VENDOR(chip->usb_id),  in snd_scarlett2_init()
7710 			      USB_ID_PRODUCT(chip->usb_id));  in snd_scarlett2_init()
7714 	if (chip->setup & SCARLETT2_DISABLE) {  in snd_scarlett2_init()
7719 			entry->series_name,  in snd_scarlett2_init()
7720 			USB_ID_VENDOR(chip->usb_id),  in snd_scarlett2_init()
7721 			USB_ID_PRODUCT(chip->usb_id),  in snd_scarlett2_init()
7728 		"report any issues to "  in snd_scarlett2_init()
7729 		"https://github.com/geoffreybennett/scarlett-gen2/issues",  in snd_scarlett2_init()
7730 		entry->series_name,  in snd_scarlett2_init()
7731 		USB_ID_PRODUCT(chip->usb_id));  in snd_scarlett2_init()
7735 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
7737 			      entry->series_name,  in snd_scarlett2_init()
7744 		usb_audio_err(mixer->chip,  in snd_scarlett2_init()
7746 			      entry->series_name,  in snd_scarlett2_init()