Lines Matching +full:mixer +full:- +full:mode
1 // SPDX-License-Identifier: GPL-2.0
8 * - 6i6/18i8/18i20 Gen 2
9 * - Solo/2i2/4i4/8i6/18i8/18i20 Gen 3
10 * - Solo/2i2/4i4 Gen 4
11 * - Clarett 2Pre/4Pre/8Pre USB
12 * - Clarett+ 2Pre/4Pre/8Pre
13 * - Vocaster One/Two
15 * Copyright (c) 2018-2025 by Geoffrey D. Bennett <g at b4.vu>
16 * Copyright (c) 2020-2021 by Vladimir Sadovnikov <sadko4u@gmail.com>
36 * (firmware 1083) using usbmon in July-August 2018.
51 * Support for loading mixer volume and mux configuration from the
59 * and talkback added in May-June 2021.
82 * This ALSA mixer gives access to (model-dependent):
83 * - input, output, mixer-matrix muxes
84 * - mixer-matrix gain stages
85 * - gain/volume/mute controls
86 * - level meters
87 * - line/inst level, pad, and air controls
88 * - phantom power, direct monitor, speaker switching, and talkback
90 * - disable/enable MSD mode
91 * - disable/enable standalone mode
92 * - input mute, gain, autogain, safe mode
93 * - direct monitor mixes
94 * - compressor and EQ
95 * - Bluetooth volume
98 * /--------------\ 18chn 20chn /--------------\
99 * | Hardware in +--+------\ /-------------+--+ ALSA PCM out |
100 * \--------------/ | | | | \--------------/
101 * | | | /-----\ |
104 * | +---------------+ | |
106 * | +-----+-----+ | |
112 * | +------------+ | |
113 * | | Mixer | | |
118 * | +-----+------+ | |
122 * | +----------/ |
126 * +---------------+ +--—------------+
128 * +---+---+---+ +-----+-----+
132 * /--------------\ | | | /--------------\
133 * | S/PDIF, ADAT |<--/ |10chn \-->| ALSA PCM in |
134 * | Hardware out | | \--------------/
135 * \--------------/ |
137 * +-------------+ Software gain per channel.
138 * | Master Gain |<-- 18i20 only: Switch per channel
139 * +------+------+ to select HW or SW gain control.
142 * /--------------\ |
143 * | Analogue |<------/
145 * \--------------/
148 * Gen 3/4 devices have a Mass Storage Device (MSD) mode where a small
151 * proprietary software, MSD mode can be disabled by:
152 * - holding down the 48V button for five seconds while powering on
154 * - using this driver and alsamixer to change the "MSD Mode" setting
155 * to Off and power-cycling the device
169 #include "mixer.h"
175 /* device_setup value to allow turning MSD mode back on */
178 /* device_setup value to disable this mixer driver */
188 * (the corresponding value in dB is per-device)
195 /* mixer range from -80dB to +12dB in 0.5dB steps */
196 #define SCARLETT2_MIXER_MIN_DB -80
197 #define SCARLETT2_MIXER_BIAS (-SCARLETT2_MIXER_MIN_DB * 2)
200 ((SCARLETT2_MIXER_MAX_DB - SCARLETT2_MIXER_MIN_DB) * 2)
203 /* map from (dB + 80) * 2 to mixer value
204 * for dB in 0 .. 184: int(8192 * pow(10, ((dB - 160) / 2 / 20)))
236 /* Maximum number of inputs to the mixer */
239 /* Maximum number of outputs from the mixer */
242 /* Maximum number of mixer gain controls */
245 /* Maximum number of direct monitor mixer gain controls
265 * The compressor parameters are 32-bit fixed point values with 24
278 * - Enable: Off, On
279 * - Threshold: -40dB to 0dB
280 * - Ratio: 1:1 to 50:1 in 0.5:1 steps
281 * - Knee Width: 0dB to 10dB
282 * - Attack: 30ms to 127ms
283 * - Release: 30ms to 127ms
284 * - Makeup Gain: 0dB to 24dB
288 { "Threshold", SNDRV_CTL_ELEM_TYPE_INTEGER, -40, 0, 24 },
317 * - None (no input to mux)
318 * - Analogue I/O
319 * - S/PDIF I/O
320 * - ADAT I/O
321 * - Mixer I/O
322 * - PCM I/O
350 #define SCARLETT2_AG_TARGET_MIN (-30)
428 void (*func)(struct usb_mixer_interface *mixer);
431 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer);
432 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer);
433 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer);
434 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer);
435 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer);
436 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer);
437 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer);
438 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer);
439 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer);
440 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer);
441 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer);
442 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer);
443 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer);
444 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer);
445 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer);
446 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer);
447 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer);
448 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer);
449 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer);
451 struct usb_mixer_interface *mixer);
452 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer);
678 /* Gen 3 devices without a mixer (Solo and 2i2) */
1019 * - id: hardware ID of this port type
1020 * - src_descr: printf format string for mux input selections
1021 * - src_num_offset: added to channel number for the fprintf
1022 * - dst_descr: printf format string for mixer controls
1060 .dst_descr = "Mixer Input %02d Capture",
1123 /* the first input with a level control (0-based) */
1136 /* the first input with an air control (0-based) */
1148 /* number of pre-compressor filters */
1165 /* the first input with phantom power control (0-based) */
1171 /* the number of inputs with software-controllable gain */
1174 /* the number of inputs with safe mode */
1188 /* S/PDIF Source/Digital I/O mode control */
1221 struct usb_mixer_interface *mixer;
1345 /*** Model-specific data ***/
1650 .spdif_mode_control_name = "S/PDIF Mode Capture Enum",
1743 .spdif_mode_control_name = "Digital I/O Mode Capture Enum",
2323 /* Gen 4 device firmware provides access to a base64-encoded
2324 * zlib-compressed JSON description of the device's capabilities and
2326 * /proc/asound/cardX/device-map.json.zz.b64
2329 #define SCARLETT2_DEVMAP_FILENAME "device-map.json.zz.b64"
2346 u16 seq = private->scarlett2_seq++;
2348 req->cmd = cpu_to_le32(cmd);
2349 req->size = cpu_to_le16(req_size);
2350 req->seq = cpu_to_le16(seq);
2351 req->error = 0;
2352 req->pad = 0;
2375 struct usb_mixer_interface *mixer, u32 cmd,
2378 struct scarlett2_data *private = mixer->private_data;
2379 struct usb_device *dev = mixer->chip->dev;
2390 return -ENOMEM;
2394 return -ENOMEM;
2396 guard(mutex)(&private->usb_mutex);
2403 memcpy(req->data, req_data, req_size);
2406 err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
2410 if (err == -EPROTO && ++retries <= max_retries) {
2411 msleep(5 * (1 << (retries - 1)));
2415 mixer->chip,
2417 private->series_name, cmd, err);
2418 return -EINVAL;
2421 if (!wait_for_completion_timeout(&private->cmd_done,
2424 mixer->chip,
2426 private->series_name, cmd);
2428 return -ETIMEDOUT;
2433 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
2445 (err == -ESHUTDOWN || err == -EPROTO))
2449 mixer->chip,
2451 private->series_name, cmd, err, resp_buf_size);
2452 return -EINVAL;
2458 if (resp->cmd != req->cmd ||
2459 (resp->seq != req->seq &&
2460 (le16_to_cpu(req->seq) != 1 || resp->seq != 0)) ||
2461 resp_size != le16_to_cpu(resp->size) ||
2462 resp->error ||
2463 resp->pad) {
2465 mixer->chip,
2469 private->series_name,
2470 le32_to_cpu(req->cmd), le32_to_cpu(resp->cmd),
2471 le16_to_cpu(req->seq), le16_to_cpu(resp->seq),
2472 resp_size, le16_to_cpu(resp->size),
2473 le32_to_cpu(resp->error),
2474 le32_to_cpu(resp->pad));
2475 return -EINVAL;
2479 memcpy(resp_data, resp->data, resp_size);
2486 struct usb_mixer_interface *mixer,
2496 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
2506 return !!private->config_set->items[config_item_num].offset;
2511 struct usb_mixer_interface *mixer,
2514 struct scarlett2_data *private = mixer->private_data;
2516 &private->config_set->items[config_item_num];
2524 if (!config_item->offset)
2525 return -EFAULT;
2528 size = config_item->size ? config_item->size : 8;
2530 /* For byte-sized parameters, retrieve directly into buf */
2533 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
2550 /* For bit-sized parameters, retrieve into value */
2551 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
2568 struct usb_mixer_interface *mixer,
2571 struct scarlett2_data *private = mixer->private_data;
2581 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2591 struct usb_mixer_interface *mixer,
2594 struct scarlett2_data *private = mixer->private_data;
2606 return -ENOMEM;
2608 req->offset = cpu_to_le32(offset);
2609 req->size = cpu_to_le32(bytes);
2611 memcpy(req->data, buf, count);
2617 ((__le16 *)req->data)[i] = cpu_to_le16(buf_16[i]);
2623 ((__le32 *)req->data)[i] = cpu_to_le32(buf_32[i]);
2626 err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2640 struct usb_mixer_interface *mixer, int activate)
2645 return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
2651 struct usb_mixer_interface *mixer,
2654 struct scarlett2_data *private = mixer->private_data;
2655 const struct scarlett2_config_set *config_set = private->config_set;
2657 &config_set->items[config_item_num];
2664 if (!config_item->offset)
2665 return -EFAULT;
2668 if (config_item->pbuf) {
2669 if (!config_set->param_buf_addr)
2670 return -EFAULT;
2674 mixer, config_set->param_buf_addr + 1, 1, index);
2680 mixer, config_set->param_buf_addr, 1, value);
2686 mixer, config_item->activate);
2690 * save and support bit-modification
2694 cancel_delayed_work_sync(&private->work);
2696 /* Convert config_item->size in bits to size in bytes and
2699 if (config_item->size >= 8) {
2700 size = config_item->size / 8;
2701 offset = config_item->offset + index * size;
2710 offset = config_item->offset;
2712 err = scarlett2_usb_get(mixer, offset, &tmp, 1);
2725 err = scarlett2_usb_set_data(mixer, offset, size, value);
2730 err = scarlett2_usb_activate_config(mixer, config_item->activate);
2737 if (config_set->param_buf_addr)
2741 if (config_item->activate != SCARLETT2_USB_CONFIG_SAVE)
2742 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
2751 struct usb_mixer_interface *mixer,
2754 struct scarlett2_data *private = mixer->private_data;
2755 const struct scarlett2_config_set *config_set = private->config_set;
2757 &config_set->items[config_item_num];
2764 if (!config_item->offset)
2765 return -EFAULT;
2767 /* Convert config_item->size in bits to size in bytes and
2770 if (config_item->size >= 8) {
2771 size = config_item->size / 8;
2772 offset = config_item->offset + index * size;
2776 return -EFAULT;
2780 err = scarlett2_usb_set_data_buf(mixer, offset, size, count, buf);
2785 return scarlett2_usb_activate_config(mixer, config_item->activate);
2789 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
2793 err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE);
2795 usb_audio_err(mixer->chip, "config save failed: %d\n", err);
2804 scarlett2_config_save(private->mixer);
2809 struct usb_mixer_interface *mixer,
2815 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
2824 /* Return true if the device has a mixer that we can control */
2827 return !!private->info->mux_assignment[0][0].count;
2830 /* Map from mixer value to (db + 80) * 2
2844 * and put the values into private->mix[]
2846 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
2849 struct scarlett2_data *private = mixer->private_data;
2851 int num_mixer_in = private->num_mix_in;
2864 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
2871 private->mix[j] = scarlett2_mixer_value_to_db(
2878 * (values obtained from private->mix[])
2880 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
2883 struct scarlett2_data *private = mixer->private_data;
2891 int num_mixer_in = private->num_mix_in;
2897 scarlett2_mixer_values[private->mix[j]]
2900 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
2905 /* Convert a port number index (per info->port_count) to a hardware ID */
2916 num -= port_count[port_type][SCARLETT2_PORT_IN];
2937 return port_num + id - base;
2942 return -1;
2945 /* Convert one mux entry from the interface and load into private->mux[] */
2949 const struct scarlett2_device_info *info = private->info;
2950 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
2959 if (dst_idx >= private->num_mux_dsts) {
2960 usb_audio_err(private->mixer->chip,
2962 mux_entry, dst_idx, private->num_mux_dsts);
2971 if (src_idx >= private->num_mux_srcs) {
2972 usb_audio_err(private->mixer->chip,
2974 mux_entry, src_idx, private->num_mux_srcs);
2978 private->mux[dst_idx] = src_idx;
2992 * - the source is "Off"; therefore we set those values to zero (map
2995 * - the source is assigned to a previous (with respect to the
3001 const struct scarlett2_device_info *info = private->info;
3016 for (entry = info->meter_map;
3017 entry->count;
3023 for (j = 0, mux_idx = entry->start;
3024 j < entry->count;
3029 info->line_out_remap_enable &&
3030 mux_idx < private->num_line_out
3031 ) ? info->line_out_unmap[mux_idx]
3039 int mux_src = private->mux[mux_idx];
3045 private->meter_level_map[map_mux_idx] =
3051 /* Send USB message to get mux inputs and then populate private->mux[] */
3052 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
3054 struct scarlett2_data *private = mixer->private_data;
3055 int count = private->num_mux_dsts;
3065 private->mux_updated = 0;
3070 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
3085 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
3087 struct scarlett2_data *private = mixer->private_data;
3088 const struct scarlett2_device_info *info = private->info;
3089 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
3110 for (entry = info->mux_assignment[table];
3111 entry->count;
3114 int port_type = entry->port_type;
3115 int port_idx = entry->start;
3122 for (j = 0; j < entry->count; j++)
3127 /* Non-empty mux slots use the lower 12 bits
3131 for (j = 0; j < entry->count; j++) {
3133 port_count, private->mux[mux_idx++]);
3140 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
3153 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
3167 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
3191 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
3202 return -ENOMEM;
3204 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
3208 elem->head.mixer = mixer;
3209 elem->control = index;
3210 elem->head.id = 0;
3211 elem->channels = channels;
3212 elem->val_type = USB_MIXER_BESPOKEN;
3217 return -ENOMEM;
3219 kctl->private_free = snd_usb_mixer_elem_free;
3221 strscpy(kctl->id.name, name, sizeof(kctl->id.name));
3223 err = snd_usb_mixer_add_control(&elem->head, kctl);
3239 struct usb_mixer_elem_info *elem = kctl->private_data;
3240 struct scarlett2_data *private = elem->head.mixer->private_data;
3242 ucontrol->value.integer.value[0] = private->firmware_version;
3251 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3252 uinfo->count = 1;
3266 struct usb_mixer_interface *mixer)
3268 return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl,
3278 struct usb_mixer_elem_info *elem = kctl->private_data;
3279 struct scarlett2_data *private = elem->head.mixer->private_data;
3281 ucontrol->value.integer.value[0] = private->info->min_firmware_version;
3290 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3291 uinfo->count = 1;
3305 struct usb_mixer_interface *mixer)
3307 return scarlett2_add_new_ctl(mixer, &scarlett2_min_firmware_version_ctl,
3316 static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
3318 struct scarlett2_data *private = mixer->private_data;
3320 private->sync_updated = 0;
3321 return scarlett2_usb_get_sync_status(mixer, &private->sync);
3336 struct usb_mixer_elem_info *elem = kctl->private_data;
3337 struct usb_mixer_interface *mixer = elem->head.mixer;
3338 struct scarlett2_data *private = mixer->private_data;
3341 guard(mutex)(&private->data_mutex);
3343 if (private->hwdep_in_use)
3344 return -EBUSY;
3346 if (private->sync_updated) {
3347 err = scarlett2_update_sync(mixer);
3351 ucontrol->value.enumerated.item[0] = private->sync;
3363 static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
3365 struct scarlett2_data *private = mixer->private_data;
3367 /* devices without a mixer also don't support reporting sync status */
3371 return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
3372 0, 1, "Sync Status", &private->sync_ctl);
3381 /* Set the access mode of a control to read-only (val = 0) or
3382 * read-write (val = 1).
3387 kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_WRITE;
3389 kctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_WRITE;
3398 for (i = 0; i < private->info->gain_input_count; i++)
3399 if (!private->autogain_status[i])
3405 static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)
3407 struct scarlett2_data *private = mixer->private_data;
3408 const struct scarlett2_device_info *info = private->info;
3413 private->autogain_updated = 0;
3415 if (!info->gain_input_count)
3419 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
3420 info->gain_input_count, private->autogain_switch);
3424 mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS,
3425 info->gain_input_count, raw_autogain_status);
3439 for (i = 0; i < info->gain_input_count; i++)
3440 if (private->autogain_switch[i])
3441 private->autogain_status[i] = 0;
3443 private->num_autogain_status_texts - 1)
3444 private->autogain_status[i] =
3447 private->autogain_status[i] =
3448 private->num_autogain_status_texts - 1;
3455 mixer, scarlett2_ag_target_configs[i],
3463 private->ag_targets[i] = -ag_target_values[i];
3468 /* Update access mode for controls affected by autogain */
3469 static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)
3471 struct scarlett2_data *private = mixer->private_data;
3472 const struct scarlett2_device_info *info = private->info;
3478 scarlett2_set_ctl_access(private->input_select_ctl, val);
3481 for (i = 0; i < info->gain_input_count; i++)
3482 scarlett2_set_ctl_access(private->input_link_ctls[i],
3484 for (i = 0; i < info->gain_input_count; i++)
3485 scarlett2_set_ctl_access(private->input_gain_ctls[i], val);
3486 for (i = 0; i < info->safe_input_count; i++)
3487 scarlett2_set_ctl_access(private->safe_ctls[i], val);
3488 for (i = 0; i < info->level_input_count; i++)
3489 scarlett2_set_ctl_access(private->level_ctls[i], val);
3490 for (i = 0; i < info->air_input_count; i++)
3491 scarlett2_set_ctl_access(private->air_ctls[i], val);
3492 for (i = 0; i < info->mute_input_count; i++)
3493 scarlett2_set_ctl_access(private->input_mute_ctls[i], val);
3494 for (i = 0; i < info->phantom_count; i++)
3495 scarlett2_set_ctl_access(private->phantom_ctls[i], val);
3496 for (i = 0; i < info->dsp_input_count; i++)
3497 scarlett2_set_ctl_access(private->dsp_ctls[i], val);
3503 private->ag_target_ctls[i], val);
3506 /* Notify of access mode change for all controls read-only while
3509 static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer)
3511 struct snd_card *card = mixer->chip->card;
3512 struct scarlett2_data *private = mixer->private_data;
3513 const struct scarlett2_device_info *info = private->info;
3519 &private->input_select_ctl->id);
3522 for (i = 0; i < info->gain_input_count; i++)
3524 &private->input_link_ctls[i]->id);
3525 for (i = 0; i < info->gain_input_count; i++)
3527 &private->input_gain_ctls[i]->id);
3528 for (i = 0; i < info->safe_input_count; i++)
3530 &private->safe_ctls[i]->id);
3531 for (i = 0; i < info->level_input_count; i++)
3533 &private->level_ctls[i]->id);
3534 for (i = 0; i < info->air_input_count; i++)
3536 &private->air_ctls[i]->id);
3537 for (i = 0; i < info->dsp_input_count; i++)
3539 &private->dsp_ctls[i]->id);
3540 for (i = 0; i < info->mute_input_count; i++)
3542 &private->input_mute_ctls[i]->id);
3543 for (i = 0; i < info->phantom_count; i++)
3545 &private->phantom_ctls[i]->id);
3551 &private->ag_target_ctls[i]->id);
3558 struct usb_mixer_interface *mixer)
3560 struct scarlett2_data *private = mixer->private_data;
3563 if (!private->autogain_updated)
3566 err = scarlett2_update_autogain(mixer);
3570 scarlett2_autogain_update_access(mixer);
3576 * control that is meant to be read-only while autogain is running,
3577 * update the autogain status and access mode of affected controls.
3578 * Return -EPERM if autogain is running.
3581 struct usb_mixer_interface *mixer)
3583 int err = scarlett2_check_autogain_updated(mixer);
3588 if (scarlett2_autogain_is_running(mixer->private_data))
3589 return -EPERM;
3597 struct usb_mixer_elem_info *elem = kctl->private_data;
3598 struct usb_mixer_interface *mixer = elem->head.mixer;
3599 struct scarlett2_data *private = mixer->private_data;
3602 guard(mutex)(&private->data_mutex);
3604 err = scarlett2_check_input_phantom_updated(mixer);
3614 struct usb_mixer_elem_info *elem = kctl->private_data;
3615 struct usb_mixer_interface *mixer = elem->head.mixer;
3616 struct scarlett2_data *private = mixer->private_data;
3619 guard(mutex)(&private->data_mutex);
3621 if (private->hwdep_in_use)
3622 return -EBUSY;
3624 err = scarlett2_check_autogain_updated(mixer);
3628 ucontrol->value.enumerated.item[0] =
3629 private->autogain_switch[elem->control];
3636 struct usb_mixer_elem_info *elem = kctl->private_data;
3637 struct usb_mixer_interface *mixer = elem->head.mixer;
3638 struct scarlett2_data *private = mixer->private_data;
3641 guard(mutex)(&private->data_mutex);
3643 if (private->hwdep_in_use)
3644 return -EBUSY;
3646 err = scarlett2_check_autogain_updated(mixer);
3650 ucontrol->value.enumerated.item[0] =
3651 private->autogain_status[elem->control];
3658 struct usb_mixer_elem_info *elem = kctl->private_data;
3659 struct usb_mixer_interface *mixer = elem->head.mixer;
3660 struct scarlett2_data *private = mixer->private_data;
3661 int index = elem->control;
3664 guard(mutex)(&private->data_mutex);
3666 if (private->hwdep_in_use)
3667 return -EBUSY;
3669 err = scarlett2_check_input_phantom_updated(mixer);
3674 return -EPERM;
3676 oval = private->autogain_switch[index];
3677 val = !!ucontrol->value.integer.value[0];
3682 private->autogain_switch[index] = val;
3686 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val);
3688 scarlett2_autogain_update_access(mixer);
3689 scarlett2_autogain_notify_access(mixer);
3697 struct usb_mixer_elem_info *elem = kctl->private_data;
3698 struct scarlett2_data *private = elem->head.mixer->private_data;
3702 private->num_autogain_status_texts,
3703 private->config_set->autogain_status_texts);
3727 struct usb_mixer_elem_info *elem = kctl->private_data;
3728 struct usb_mixer_interface *mixer = elem->head.mixer;
3729 struct scarlett2_data *private = mixer->private_data;
3732 guard(mutex)(&private->data_mutex);
3734 if (private->hwdep_in_use)
3735 return -EBUSY;
3737 err = scarlett2_check_autogain_updated(mixer);
3741 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3742 uinfo->count = 1;
3743 uinfo->value.integer.min = SCARLETT2_AG_TARGET_MIN;
3744 uinfo->value.integer.max = 0;
3745 uinfo->value.integer.step = 1;
3753 struct usb_mixer_elem_info *elem = kctl->private_data;
3754 struct usb_mixer_interface *mixer = elem->head.mixer;
3755 struct scarlett2_data *private = mixer->private_data;
3758 guard(mutex)(&private->data_mutex);
3760 if (private->hwdep_in_use)
3761 return -EBUSY;
3763 if (private->autogain_updated) {
3764 err = scarlett2_update_autogain(mixer);
3769 ucontrol->value.integer.value[0] = private->ag_targets[elem->control];
3776 struct usb_mixer_elem_info *elem = kctl->private_data;
3777 struct usb_mixer_interface *mixer = elem->head.mixer;
3778 struct scarlett2_data *private = mixer->private_data;
3779 int index = elem->control;
3782 guard(mutex)(&private->data_mutex);
3784 if (private->hwdep_in_use)
3785 return -EBUSY;
3787 err = scarlett2_check_put_during_autogain(mixer);
3791 oval = private->ag_targets[index];
3792 val = clamp(ucontrol->value.integer.value[0],
3798 private->ag_targets[index] = val;
3802 mixer, scarlett2_ag_target_configs[index], 1, -val);
3824 static int scarlett2_update_input_select(struct usb_mixer_interface *mixer)
3826 struct scarlett2_data *private = mixer->private_data;
3827 const struct scarlett2_device_info *info = private->info;
3828 int link_count = info->gain_input_count;
3831 private->input_select_updated = 0;
3839 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3840 1, &private->input_select_switch);
3845 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
3846 link_count, private->input_link_switch);
3856 struct usb_mixer_elem_info *elem = kctl->private_data;
3857 struct usb_mixer_interface *mixer = elem->head.mixer;
3858 struct scarlett2_data *private = mixer->private_data;
3861 guard(mutex)(&private->data_mutex);
3863 if (private->hwdep_in_use)
3864 return -EBUSY;
3866 if (private->input_select_updated) {
3867 err = scarlett2_update_input_select(mixer);
3871 ucontrol->value.enumerated.item[0] = private->input_select_switch;
3878 struct usb_mixer_elem_info *elem = kctl->private_data;
3879 struct usb_mixer_interface *mixer = elem->head.mixer;
3880 struct scarlett2_data *private = mixer->private_data;
3881 const struct scarlett2_device_info *info = private->info;
3884 guard(mutex)(&private->data_mutex);
3886 if (private->hwdep_in_use)
3887 return -EBUSY;
3889 err = scarlett2_check_put_during_autogain(mixer);
3893 oval = private->input_select_switch;
3894 val = ucontrol->value.integer.value[0];
3898 else if (val >= info->gain_input_count)
3899 val = info->gain_input_count - 1;
3904 private->input_select_switch = val;
3908 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3917 struct usb_mixer_elem_info *elem = kctl->private_data;
3918 struct usb_mixer_interface *mixer = elem->head.mixer;
3919 struct scarlett2_data *private = mixer->private_data;
3920 int inputs = private->info->gain_input_count;
3926 return -ENOMEM;
3928 guard(mutex)(&private->data_mutex);
3930 if (private->hwdep_in_use)
3931 return -EBUSY;
3933 err = scarlett2_check_autogain_updated(mixer);
3941 err = -ENOMEM;
3966 /* snd_ctl_boolean_mono_info() with autogain-updated check
3967 * (for controls that are read-only while autogain is running)
3972 struct usb_mixer_elem_info *elem = kctl->private_data;
3973 struct usb_mixer_interface *mixer = elem->head.mixer;
3974 struct scarlett2_data *private = mixer->private_data;
3977 guard(mutex)(&private->data_mutex);
3979 if (private->hwdep_in_use)
3980 return -EBUSY;
3982 err = scarlett2_check_autogain_updated(mixer);
3992 struct usb_mixer_elem_info *elem = kctl->private_data;
3993 struct usb_mixer_interface *mixer = elem->head.mixer;
3994 struct scarlett2_data *private = mixer->private_data;
3997 guard(mutex)(&private->data_mutex);
3999 if (private->hwdep_in_use)
4000 return -EBUSY;
4002 if (private->input_select_updated) {
4003 err = scarlett2_update_input_select(mixer);
4007 ucontrol->value.enumerated.item[0] =
4008 private->input_link_switch[elem->control];
4015 struct usb_mixer_elem_info *elem = kctl->private_data;
4016 struct usb_mixer_interface *mixer = elem->head.mixer;
4017 struct scarlett2_data *private = mixer->private_data;
4018 int index = elem->control;
4021 guard(mutex)(&private->data_mutex);
4023 if (private->hwdep_in_use)
4024 return -EBUSY;
4026 err = scarlett2_check_put_during_autogain(mixer);
4030 oval = private->input_link_switch[index];
4031 val = !!ucontrol->value.integer.value[0];
4036 private->input_link_switch[index] = val;
4039 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index, val);
4054 static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer)
4056 struct scarlett2_data *private = mixer->private_data;
4057 const struct scarlett2_device_info *info = private->info;
4059 private->input_gain_updated = 0;
4061 if (!info->gain_input_count)
4065 mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4066 info->gain_input_count, private->gain);
4072 struct usb_mixer_elem_info *elem = kctl->private_data;
4073 struct usb_mixer_interface *mixer = elem->head.mixer;
4074 struct scarlett2_data *private = mixer->private_data;
4077 guard(mutex)(&private->data_mutex);
4079 if (private->hwdep_in_use)
4080 return -EBUSY;
4082 err = scarlett2_check_autogain_updated(mixer);
4086 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4087 uinfo->count = elem->channels;
4088 uinfo->value.integer.min = 0;
4089 uinfo->value.integer.max = SCARLETT2_MAX_GAIN_VALUE;
4090 uinfo->value.integer.step = 1;
4098 struct usb_mixer_elem_info *elem = kctl->private_data;
4099 struct usb_mixer_interface *mixer = elem->head.mixer;
4100 struct scarlett2_data *private = mixer->private_data;
4103 guard(mutex)(&private->data_mutex);
4105 if (private->hwdep_in_use)
4106 return -EBUSY;
4108 if (private->input_gain_updated) {
4109 err = scarlett2_update_input_gain(mixer);
4113 ucontrol->value.integer.value[0] =
4114 private->gain[elem->control];
4121 struct usb_mixer_elem_info *elem = kctl->private_data;
4122 struct usb_mixer_interface *mixer = elem->head.mixer;
4123 struct scarlett2_data *private = mixer->private_data;
4124 int index = elem->control;
4127 guard(mutex)(&private->data_mutex);
4129 if (private->hwdep_in_use)
4130 return -EBUSY;
4132 err = scarlett2_check_put_during_autogain(mixer);
4136 oval = private->gain[index];
4137 val = ucontrol->value.integer.value[0];
4142 private->gain[index] = val;
4145 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4164 static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer)
4166 struct scarlett2_data *private = mixer->private_data;
4167 const struct scarlett2_device_info *info = private->info;
4169 private->input_safe_updated = 0;
4171 if (!info->safe_input_count)
4175 mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4176 info->safe_input_count, private->safe_switch);
4182 struct usb_mixer_elem_info *elem = kctl->private_data;
4183 struct usb_mixer_interface *mixer = elem->head.mixer;
4184 struct scarlett2_data *private = mixer->private_data;
4187 guard(mutex)(&private->data_mutex);
4189 if (private->hwdep_in_use)
4190 return -EBUSY;
4192 if (private->input_safe_updated) {
4193 err = scarlett2_update_input_safe(mixer);
4197 ucontrol->value.integer.value[0] =
4198 private->safe_switch[elem->control];
4205 struct usb_mixer_elem_info *elem = kctl->private_data;
4206 struct usb_mixer_interface *mixer = elem->head.mixer;
4207 struct scarlett2_data *private = mixer->private_data;
4208 int index = elem->control;
4211 guard(mutex)(&private->data_mutex);
4213 if (private->hwdep_in_use)
4214 return -EBUSY;
4216 err = scarlett2_check_put_during_autogain(mixer);
4220 oval = private->safe_switch[index];
4221 val = !!ucontrol->value.integer.value[0];
4226 private->safe_switch[index] = val;
4229 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4245 static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer)
4247 struct scarlett2_data *private = mixer->private_data;
4250 private->pcm_input_switch_updated = 0;
4253 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4254 1, &private->pcm_input_switch);
4264 struct usb_mixer_elem_info *elem = kctl->private_data;
4265 struct usb_mixer_interface *mixer = elem->head.mixer;
4266 struct scarlett2_data *private = elem->head.mixer->private_data;
4269 guard(mutex)(&private->data_mutex);
4271 if (private->pcm_input_switch_updated) {
4272 err = scarlett2_update_pcm_input_switch(mixer);
4276 ucontrol->value.enumerated.item[0] = private->pcm_input_switch;
4283 struct usb_mixer_elem_info *elem = kctl->private_data;
4284 struct usb_mixer_interface *mixer = elem->head.mixer;
4285 struct scarlett2_data *private = mixer->private_data;
4288 guard(mutex)(&private->data_mutex);
4290 if (private->hwdep_in_use)
4291 return -EBUSY;
4293 oval = private->pcm_input_switch;
4294 val = !!ucontrol->value.integer.value[0];
4299 private->pcm_input_switch = val;
4303 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4313 "Direct", "Mixer"
4333 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
4335 struct scarlett2_data *private = mixer->private_data;
4339 private->vol_updated = 0;
4344 mixer, SCARLETT2_CONFIG_MASTER_VOLUME,
4349 private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4354 for (i = 0; i < private->num_line_out; i++)
4355 if (private->vol_sw_hw_switch[i])
4356 private->vol[i] = private->master_vol;
4362 mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME,
4367 private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS,
4377 struct usb_mixer_elem_info *elem = kctl->private_data;
4379 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
4380 uinfo->count = elem->channels;
4381 uinfo->value.integer.min = 0;
4382 uinfo->value.integer.max = SCARLETT2_VOLUME_BIAS;
4383 uinfo->value.integer.step = 1;
4390 struct usb_mixer_elem_info *elem = kctl->private_data;
4391 struct usb_mixer_interface *mixer = elem->head.mixer;
4392 struct scarlett2_data *private = mixer->private_data;
4395 guard(mutex)(&private->data_mutex);
4397 if (private->hwdep_in_use)
4398 return -EBUSY;
4400 if (private->vol_updated) {
4401 err = scarlett2_update_volumes(mixer);
4405 ucontrol->value.integer.value[0] = private->master_vol;
4413 struct usb_mixer_elem_info *elem = kctl->private_data;
4414 struct usb_mixer_interface *mixer = elem->head.mixer;
4415 struct scarlett2_data *private = mixer->private_data;
4418 guard(mutex)(&private->data_mutex);
4420 if (private->hwdep_in_use)
4421 return -EBUSY;
4423 if (private->vol_updated) {
4424 err = scarlett2_update_volumes(mixer);
4428 ucontrol->value.integer.value[0] = private->headphone_vol;
4434 const struct scarlett2_device_info *info = private->info;
4436 if (!info->line_out_remap_enable)
4439 if (index >= private->num_line_out)
4442 return info->line_out_remap[index];
4448 struct usb_mixer_elem_info *elem = kctl->private_data;
4449 struct usb_mixer_interface *mixer = elem->head.mixer;
4450 struct scarlett2_data *private = mixer->private_data;
4451 int index = line_out_remap(private, elem->control);
4454 guard(mutex)(&private->data_mutex);
4456 if (private->hwdep_in_use)
4457 return -EBUSY;
4459 if (private->vol_updated) {
4460 err = scarlett2_update_volumes(mixer);
4464 ucontrol->value.integer.value[0] = private->vol[index];
4471 struct usb_mixer_elem_info *elem = kctl->private_data;
4472 struct usb_mixer_interface *mixer = elem->head.mixer;
4473 struct scarlett2_data *private = mixer->private_data;
4474 int index = line_out_remap(private, elem->control);
4477 guard(mutex)(&private->data_mutex);
4479 if (private->hwdep_in_use)
4480 return -EBUSY;
4482 oval = private->vol[index];
4483 val = ucontrol->value.integer.value[0];
4488 private->vol[index] = val;
4489 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4490 index, val - SCARLETT2_VOLUME_BIAS);
4496 db_scale_scarlett2_volume, -SCARLETT2_VOLUME_BIAS * 100, 0
4535 static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)
4537 struct scarlett2_data *private = mixer->private_data;
4541 private->dim_mute_updated = 0;
4547 mixer, SCARLETT2_CONFIG_DIM_MUTE,
4548 SCARLETT2_DIM_MUTE_COUNT, private->dim_mute);
4553 private->dim_mute[i] = !!private->dim_mute[i];
4555 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4557 for (i = 0; i < private->num_line_out; i++)
4558 if (private->vol_sw_hw_switch[i])
4559 private->mute_switch[i] = mute;
4567 struct usb_mixer_elem_info *elem = kctl->private_data;
4568 struct usb_mixer_interface *mixer = elem->head.mixer;
4569 struct scarlett2_data *private = mixer->private_data;
4570 int index = line_out_remap(private, elem->control);
4573 guard(mutex)(&private->data_mutex);
4575 if (private->hwdep_in_use)
4576 return -EBUSY;
4578 if (private->dim_mute_updated) {
4579 err = scarlett2_update_dim_mute(mixer);
4583 ucontrol->value.integer.value[0] = private->mute_switch[index];
4590 struct usb_mixer_elem_info *elem = kctl->private_data;
4591 struct usb_mixer_interface *mixer = elem->head.mixer;
4592 struct scarlett2_data *private = mixer->private_data;
4593 int index = line_out_remap(private, elem->control);
4596 guard(mutex)(&private->data_mutex);
4598 if (private->hwdep_in_use)
4599 return -EBUSY;
4601 oval = private->mute_switch[index];
4602 val = !!ucontrol->value.integer.value[0];
4607 private->mute_switch[index] = val;
4610 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4628 private->sw_hw_ctls[index]->vd[0].access &=
4634 private->sw_hw_ctls[index]->vd[0].access |=
4651 struct usb_mixer_elem_info *elem = kctl->private_data;
4652 struct scarlett2_data *private = elem->head.mixer->private_data;
4653 int index = line_out_remap(private, elem->control);
4655 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
4659 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
4662 struct scarlett2_data *private = mixer->private_data;
4663 struct snd_card *card = mixer->chip->card;
4667 private->vol_ctls[index]->vd[0].access |=
4669 private->mute_ctls[index]->vd[0].access |=
4672 private->vol_ctls[index]->vd[0].access &=
4674 private->mute_ctls[index]->vd[0].access &=
4681 &private->vol_ctls[index]->id);
4684 &private->mute_ctls[index]->id);
4687 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
4690 struct scarlett2_data *private = mixer->private_data;
4694 private->vol_sw_hw_switch[index] = val;
4696 /* Change access mode to RO (hardware controlled volume)
4699 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
4702 private->vol[index] = private->master_vol;
4703 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
4707 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4708 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
4714 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4715 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
4720 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
4727 struct usb_mixer_elem_info *elem = kctl->private_data;
4728 struct usb_mixer_interface *mixer = elem->head.mixer;
4729 struct scarlett2_data *private = mixer->private_data;
4730 int ctl_index = elem->control;
4734 guard(mutex)(&private->data_mutex);
4736 if (private->hwdep_in_use)
4737 return -EBUSY;
4739 oval = private->vol_sw_hw_switch[index];
4740 val = !!ucontrol->value.enumerated.item[0];
4745 err = scarlett2_sw_hw_change(mixer, ctl_index, val);
4760 static int scarlett2_update_input_level(struct usb_mixer_interface *mixer)
4762 struct scarlett2_data *private = mixer->private_data;
4763 const struct scarlett2_device_info *info = private->info;
4765 private->input_level_updated = 0;
4767 if (!info->level_input_count)
4771 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
4772 info->level_input_count + info->level_input_first,
4773 private->level_switch);
4782 struct usb_mixer_elem_info *elem = kctl->private_data;
4783 struct usb_mixer_interface *mixer = elem->head.mixer;
4784 struct scarlett2_data *private = mixer->private_data;
4787 guard(mutex)(&private->data_mutex);
4789 if (private->hwdep_in_use)
4790 return -EBUSY;
4792 err = scarlett2_check_autogain_updated(mixer);
4802 struct usb_mixer_elem_info *elem = kctl->private_data;
4803 struct usb_mixer_interface *mixer = elem->head.mixer;
4804 struct scarlett2_data *private = mixer->private_data;
4805 const struct scarlett2_device_info *info = private->info;
4806 int index = elem->control + info->level_input_first;
4809 guard(mutex)(&private->data_mutex);
4811 if (private->hwdep_in_use)
4812 return -EBUSY;
4814 if (private->input_level_updated) {
4815 err = scarlett2_update_input_level(mixer);
4819 ucontrol->value.enumerated.item[0] = scarlett2_decode_muteable(
4820 private->level_switch[index]);
4827 struct usb_mixer_elem_info *elem = kctl->private_data;
4828 struct usb_mixer_interface *mixer = elem->head.mixer;
4829 struct scarlett2_data *private = mixer->private_data;
4830 const struct scarlett2_device_info *info = private->info;
4831 int index = elem->control + info->level_input_first;
4834 guard(mutex)(&private->data_mutex);
4836 if (private->hwdep_in_use)
4837 return -EBUSY;
4839 err = scarlett2_check_put_during_autogain(mixer);
4843 oval = private->level_switch[index];
4844 val = !!ucontrol->value.enumerated.item[0];
4849 private->level_switch[index] = val;
4852 if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute)
4856 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
4872 static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer)
4874 struct scarlett2_data *private = mixer->private_data;
4875 const struct scarlett2_device_info *info = private->info;
4877 private->input_pad_updated = 0;
4879 if (!info->pad_input_count)
4883 mixer, SCARLETT2_CONFIG_PAD_SWITCH,
4884 info->pad_input_count, private->pad_switch);
4890 struct usb_mixer_elem_info *elem = kctl->private_data;
4891 struct usb_mixer_interface *mixer = elem->head.mixer;
4892 struct scarlett2_data *private = mixer->private_data;
4895 guard(mutex)(&private->data_mutex);
4897 if (private->hwdep_in_use)
4898 return -EBUSY;
4900 if (private->input_pad_updated) {
4901 err = scarlett2_update_input_pad(mixer);
4905 ucontrol->value.integer.value[0] =
4906 private->pad_switch[elem->control];
4913 struct usb_mixer_elem_info *elem = kctl->private_data;
4914 struct usb_mixer_interface *mixer = elem->head.mixer;
4915 struct scarlett2_data *private = mixer->private_data;
4916 int index = elem->control;
4919 guard(mutex)(&private->data_mutex);
4921 if (private->hwdep_in_use)
4922 return -EBUSY;
4924 oval = private->pad_switch[index];
4925 val = !!ucontrol->value.integer.value[0];
4930 private->pad_switch[index] = val;
4933 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
4949 static int scarlett2_update_input_air(struct usb_mixer_interface *mixer)
4951 struct scarlett2_data *private = mixer->private_data;
4952 const struct scarlett2_device_info *info = private->info;
4954 private->input_air_updated = 0;
4956 if (!info->air_input_count)
4960 mixer, SCARLETT2_CONFIG_AIR_SWITCH,
4961 info->air_input_count, private->air_switch);
4967 struct usb_mixer_elem_info *elem = kctl->private_data;
4968 struct usb_mixer_interface *mixer = elem->head.mixer;
4969 struct scarlett2_data *private = mixer->private_data;
4972 guard(mutex)(&private->data_mutex);
4974 if (private->hwdep_in_use)
4975 return -EBUSY;
4977 if (private->input_air_updated) {
4978 err = scarlett2_update_input_air(mixer);
4982 ucontrol->value.integer.value[0] = private->air_switch[elem->control];
4989 struct usb_mixer_elem_info *elem = kctl->private_data;
4990 struct usb_mixer_interface *mixer = elem->head.mixer;
4991 struct scarlett2_data *private = mixer->private_data;
4992 int index = elem->control;
4995 guard(mutex)(&private->data_mutex);
4997 if (private->hwdep_in_use)
4998 return -EBUSY;
5000 err = scarlett2_check_put_during_autogain(mixer);
5004 oval = private->air_switch[index];
5005 val = ucontrol->value.integer.value[0];
5010 private->air_switch[index] = val;
5013 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5025 struct usb_mixer_elem_info *elem = kctl->private_data;
5026 struct usb_mixer_interface *mixer = elem->head.mixer;
5027 struct scarlett2_data *private = mixer->private_data;
5030 guard(mutex)(&private->data_mutex);
5032 if (private->hwdep_in_use)
5033 return -EBUSY;
5035 err = scarlett2_check_autogain_updated(mixer);
5061 static int scarlett2_update_input_dsp(struct usb_mixer_interface *mixer)
5063 struct scarlett2_data *private = mixer->private_data;
5064 const struct scarlett2_device_info *info = private->info;
5066 private->input_dsp_updated = 0;
5068 if (!info->dsp_input_count)
5072 mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5073 info->dsp_input_count, private->dsp_switch);
5079 struct usb_mixer_elem_info *elem = kctl->private_data;
5080 struct usb_mixer_interface *mixer = elem->head.mixer;
5081 struct scarlett2_data *private = mixer->private_data;
5084 guard(mutex)(&private->data_mutex);
5086 if (private->hwdep_in_use)
5087 return -EBUSY;
5089 if (private->input_dsp_updated) {
5090 err = scarlett2_update_input_dsp(mixer);
5094 ucontrol->value.integer.value[0] = private->dsp_switch[elem->control];
5101 struct usb_mixer_elem_info *elem = kctl->private_data;
5102 struct usb_mixer_interface *mixer = elem->head.mixer;
5103 struct scarlett2_data *private = mixer->private_data;
5104 int index = elem->control;
5107 guard(mutex)(&private->data_mutex);
5109 if (private->hwdep_in_use)
5110 return -EBUSY;
5112 err = scarlett2_check_put_during_autogain(mixer);
5116 oval = private->dsp_switch[index];
5117 val = ucontrol->value.integer.value[0];
5122 private->dsp_switch[index] = val;
5125 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5141 static int scarlett2_update_compressor_values(struct usb_mixer_interface *mixer)
5143 struct scarlett2_data *private = mixer->private_data;
5144 const struct scarlett2_device_info *info = private->info;
5147 if (!info->dsp_input_count)
5151 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS,
5152 SCARLETT2_COMPRESSOR_PARAM_COUNT * info->dsp_input_count,
5153 private->compressor_values);
5161 for (j = 0; j < info->dsp_input_count; j++) {
5163 int val = private->compressor_values[idx];
5165 val >>= param->scale_bits;
5166 val = clamp(val, param->min, param->max);
5167 private->compressor_values[idx] = val;
5177 struct usb_mixer_elem_info *elem = kctl->private_data;
5178 struct scarlett2_data *private = elem->head.mixer->private_data;
5180 ucontrol->value.integer.value[0] =
5181 private->compressor_values[elem->control];
5188 struct usb_mixer_elem_info *elem = kctl->private_data;
5189 struct usb_mixer_interface *mixer = elem->head.mixer;
5190 struct scarlett2_data *private = mixer->private_data;
5191 int index = elem->control;
5198 guard(mutex)(&private->data_mutex);
5200 if (private->hwdep_in_use)
5201 return -EBUSY;
5203 err = scarlett2_check_put_during_autogain(mixer);
5207 oval = private->compressor_values[index];
5208 val = ucontrol->value.integer.value[0];
5212 private->compressor_values[index] = val;
5214 scaled_val = val << param->scale_bits;
5223 mixer, private->config_set->param_buf_addr + 1, 1, channel);
5228 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS, index, scaled_val);
5236 struct usb_mixer_elem_info *elem = kctl->private_data;
5237 int control = elem->control % SCARLETT2_COMPRESSOR_PARAM_COUNT;
5239 uinfo->type = compressor_params[control].type;
5240 uinfo->count = 1;
5241 uinfo->value.integer.min = compressor_params[control].min;
5242 uinfo->value.integer.max = compressor_params[control].max;
5243 uinfo->value.integer.step = 1;
5255 /*** DSP Pre-Compressor and PEQ Filter Controls ***/
5260 struct usb_mixer_elem_info *elem = kctl->private_data;
5261 struct scarlett2_data *private = elem->head.mixer->private_data;
5263 ucontrol->value.integer.value[0] = private->precomp_flt_switch[elem->control];
5271 struct usb_mixer_elem_info *elem = kctl->private_data;
5272 struct scarlett2_data *private = elem->head.mixer->private_data;
5274 ucontrol->value.integer.value[0] =
5275 private->peq_flt_switch[elem->control];
5283 struct usb_mixer_elem_info *elem = kctl->private_data;
5284 struct usb_mixer_interface *mixer = elem->head.mixer;
5285 struct scarlett2_data *private = mixer->private_data;
5288 guard(mutex)(&private->data_mutex);
5290 if (private->hwdep_in_use)
5291 return -EBUSY;
5293 oval = private->precomp_flt_switch[elem->control];
5294 val = ucontrol->value.integer.value[0];
5299 private->precomp_flt_switch[elem->control] = val;
5303 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5304 elem->control, val);
5312 struct usb_mixer_elem_info *elem = kctl->private_data;
5313 struct usb_mixer_interface *mixer = elem->head.mixer;
5314 struct scarlett2_data *private = mixer->private_data;
5317 guard(mutex)(&private->data_mutex);
5319 if (private->hwdep_in_use)
5320 return -EBUSY;
5322 oval = private->peq_flt_switch[elem->control];
5323 val = ucontrol->value.integer.value[0];
5328 private->peq_flt_switch[elem->control] = val;
5332 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5333 elem->control, val);
5354 static int scarlett2_update_filter_values(struct usb_mixer_interface *mixer)
5356 struct scarlett2_data *private = mixer->private_data;
5357 const struct scarlett2_device_info *info = private->info;
5363 if (!info->dsp_input_count)
5368 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5369 info->dsp_input_count, private->precomp_flt_switch);
5374 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5375 info->dsp_input_count * info->peq_flt_count,
5376 private->peq_flt_switch);
5380 /* Get pre-compressor filter values directly */
5382 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5383 info->dsp_input_count *
5384 info->precomp_flt_count *
5386 private->precomp_flt_values);
5395 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5396 info->dsp_input_count *
5397 info->peq_flt_total_count *
5403 for (i = 0, dst_idx = 0; i < info->dsp_input_count; i++) {
5405 info->peq_flt_total_count *
5407 for (j = 0; j < info->peq_flt_count; j++)
5411 private->peq_flt_values[dst_idx] =
5421 struct usb_mixer_elem_info *elem = kctl->private_data;
5422 struct scarlett2_data *private = elem->head.mixer->private_data;
5425 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5428 ucontrol->value.integer.value[i] =
5429 private->precomp_flt_values[idx];
5437 struct usb_mixer_elem_info *elem = kctl->private_data;
5438 struct scarlett2_data *private = elem->head.mixer->private_data;
5441 for (i = 0, idx = elem->control * SCARLETT2_BIQUAD_COEFFS;
5444 ucontrol->value.integer.value[i] =
5445 private->peq_flt_values[idx];
5453 struct usb_mixer_elem_info *elem = kctl->private_data;
5454 struct usb_mixer_interface *mixer = elem->head.mixer;
5455 struct scarlett2_data *private = mixer->private_data;
5456 int index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5459 guard(mutex)(&private->data_mutex);
5461 if (private->hwdep_in_use)
5462 return -EBUSY;
5464 err = scarlett2_check_put_during_autogain(mixer);
5470 oval = private->precomp_flt_values[index + i];
5471 val = ucontrol->value.integer.value[i];
5481 private->precomp_flt_values[index + i] =
5482 ucontrol->value.integer.value[i];
5486 mixer, private->config_set->param_buf_addr, 1, index);
5491 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5493 &private->precomp_flt_values[index]);
5501 struct usb_mixer_elem_info *elem = kctl->private_data;
5502 struct usb_mixer_interface *mixer = elem->head.mixer;
5503 struct scarlett2_data *private = mixer->private_data;
5504 const struct scarlett2_device_info *info = private->info;
5505 int src_index = elem->control * SCARLETT2_BIQUAD_COEFFS;
5507 elem->control /
5508 info->peq_flt_count *
5509 info->peq_flt_total_count +
5510 elem->control % info->peq_flt_count
5514 guard(mutex)(&private->data_mutex);
5516 if (private->hwdep_in_use)
5517 return -EBUSY;
5519 err = scarlett2_check_put_during_autogain(mixer);
5525 oval = private->peq_flt_values[src_index + i];
5526 val = ucontrol->value.integer.value[i];
5536 private->peq_flt_values[src_index + i] =
5537 ucontrol->value.integer.value[i];
5541 mixer, private->config_set->param_buf_addr, 1, dst_index);
5546 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5548 &private->peq_flt_values[src_index]);
5556 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
5557 uinfo->count = SCARLETT2_BIQUAD_COEFFS;
5558 uinfo->value.integer.min = INT_MIN;
5559 uinfo->value.integer.max = INT_MAX;
5560 uinfo->value.integer.step = 1;
5582 static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer)
5584 struct scarlett2_data *private = mixer->private_data;
5585 const struct scarlett2_device_info *info = private->info;
5587 private->input_mute_updated = 0;
5589 if (!info->mute_input_count)
5593 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5594 info->mute_input_count, private->input_mute_switch);
5600 struct usb_mixer_elem_info *elem = kctl->private_data;
5601 struct usb_mixer_interface *mixer = elem->head.mixer;
5602 struct scarlett2_data *private = mixer->private_data;
5605 guard(mutex)(&private->data_mutex);
5607 if (private->hwdep_in_use)
5608 return -EBUSY;
5610 if (private->input_mute_updated) {
5611 err = scarlett2_update_input_mute(mixer);
5615 ucontrol->value.integer.value[0] =
5616 private->input_mute_switch[elem->control];
5623 struct usb_mixer_elem_info *elem = kctl->private_data;
5624 struct usb_mixer_interface *mixer = elem->head.mixer;
5625 struct scarlett2_data *private = mixer->private_data;
5626 int index = elem->control;
5629 guard(mutex)(&private->data_mutex);
5631 if (private->hwdep_in_use)
5632 return -EBUSY;
5634 err = scarlett2_check_put_during_autogain(mixer);
5638 oval = private->input_mute_switch[index];
5639 val = ucontrol->value.integer.value[0];
5644 private->input_mute_switch[index] = val;
5648 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5664 static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer)
5666 struct scarlett2_data *private = mixer->private_data;
5667 const struct scarlett2_device_info *info = private->info;
5670 private->input_phantom_updated = 0;
5672 if (!info->phantom_count)
5676 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5677 info->phantom_count, private->phantom_switch);
5684 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
5685 1, &private->phantom_persistence);
5697 const struct scarlett2_device_info *info = private->info;
5698 int index = line_num / info->inputs_per_phantom;
5700 return !!(private->phantom_switch[index] & 0x02);
5703 /* Update autogain controls' access mode when phantom power changes state */
5704 static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)
5706 struct scarlett2_data *private = mixer->private_data;
5707 const struct scarlett2_device_info *info = private->info;
5711 for (i = 0; i < info->gain_input_count; i++) {
5714 scarlett2_set_ctl_access(private->autogain_ctls[i], val);
5718 /* Notify of access mode change for autogain which can't be enabled
5721 static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer)
5723 struct snd_card *card = mixer->chip->card;
5724 struct scarlett2_data *private = mixer->private_data;
5725 const struct scarlett2_device_info *info = private->info;
5728 for (i = 0; i < info->gain_input_count; i++)
5730 &private->autogain_ctls[i]->id);
5737 struct usb_mixer_interface *mixer)
5739 struct scarlett2_data *private = mixer->private_data;
5742 if (!private->input_phantom_updated)
5745 err = scarlett2_update_input_phantom(mixer);
5749 scarlett2_phantom_update_access(mixer);
5757 struct usb_mixer_elem_info *elem = kctl->private_data;
5758 struct usb_mixer_interface *mixer = elem->head.mixer;
5759 struct scarlett2_data *private = mixer->private_data;
5762 guard(mutex)(&private->data_mutex);
5764 if (private->hwdep_in_use)
5765 return -EBUSY;
5767 err = scarlett2_check_input_phantom_updated(mixer);
5771 ucontrol->value.integer.value[0] = scarlett2_decode_muteable(
5772 private->phantom_switch[elem->control]);
5779 struct usb_mixer_elem_info *elem = kctl->private_data;
5780 struct usb_mixer_interface *mixer = elem->head.mixer;
5781 struct scarlett2_data *private = mixer->private_data;
5782 const struct scarlett2_device_info *info = private->info;
5783 int index = elem->control;
5786 guard(mutex)(&private->data_mutex);
5788 if (private->hwdep_in_use)
5789 return -EBUSY;
5791 err = scarlett2_check_put_during_autogain(mixer);
5795 oval = private->phantom_switch[index];
5796 val = !!ucontrol->value.integer.value[0];
5801 private->phantom_switch[index] = val;
5804 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute)
5808 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5809 index + info->phantom_first, val);
5810 scarlett2_phantom_update_access(mixer);
5811 scarlett2_phantom_notify_access(mixer);
5829 struct usb_mixer_elem_info *elem = kctl->private_data;
5830 struct scarlett2_data *private = elem->head.mixer->private_data;
5832 ucontrol->value.integer.value[0] = private->phantom_persistence;
5839 struct usb_mixer_elem_info *elem = kctl->private_data;
5840 struct usb_mixer_interface *mixer = elem->head.mixer;
5841 struct scarlett2_data *private = mixer->private_data;
5842 int index = elem->control;
5845 guard(mutex)(&private->data_mutex);
5847 if (private->hwdep_in_use)
5848 return -EBUSY;
5850 oval = private->phantom_persistence;
5851 val = !!ucontrol->value.integer.value[0];
5856 private->phantom_persistence = val;
5860 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
5875 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
5877 struct scarlett2_data *private = mixer->private_data;
5878 const struct scarlett2_device_info *info = private->info;
5891 private->monitor_other_updated = 0;
5896 if (!info->has_speaker_switching)
5900 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
5906 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
5912 private->speaker_switching_switch = 0;
5914 private->speaker_switching_switch = monitor_other_switch[0] + 1;
5916 if (info->has_talkback) {
5921 private->talkback_switch = 0;
5923 private->talkback_switch = monitor_other_switch[1] + 1;
5925 err = scarlett2_usb_get_config(mixer,
5930 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1)
5931 private->talkback_map[i] = bitmap & 1;
5950 struct usb_mixer_elem_info *elem = kctl->private_data;
5951 struct usb_mixer_interface *mixer = elem->head.mixer;
5952 struct scarlett2_data *private = mixer->private_data;
5955 guard(mutex)(&private->data_mutex);
5957 if (private->hwdep_in_use)
5958 return -EBUSY;
5960 if (private->monitor_other_updated) {
5961 err = scarlett2_update_monitor_other(mixer);
5965 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
5972 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
5974 struct snd_card *card = mixer->chip->card;
5975 struct scarlett2_data *private = mixer->private_data;
5982 if (!private->vol_sw_hw_switch[index]) {
5983 err = scarlett2_sw_hw_change(private->mixer, i, 1);
5993 &private->sw_hw_ctls[i]->id);
5996 /* when the next monitor-other notify comes in, update the mux
5999 private->speaker_switching_switched = 1;
6007 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
6009 struct snd_card *card = mixer->chip->card;
6010 struct scarlett2_data *private = mixer->private_data;
6017 &private->sw_hw_ctls[i]->id);
6020 /* when the next monitor-other notify comes in, update the mux
6023 private->speaker_switching_switched = 1;
6029 struct usb_mixer_elem_info *elem = kctl->private_data;
6030 struct usb_mixer_interface *mixer = elem->head.mixer;
6031 struct scarlett2_data *private = mixer->private_data;
6034 guard(mutex)(&private->data_mutex);
6036 if (private->hwdep_in_use)
6037 return -EBUSY;
6039 oval = private->speaker_switching_switch;
6040 val = min(ucontrol->value.enumerated.item[0], 2U);
6045 private->speaker_switching_switch = val;
6049 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6056 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6063 err = scarlett2_speaker_switch_enable(mixer);
6065 scarlett2_speaker_switch_disable(mixer);
6078 static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer)
6080 struct scarlett2_data *private = mixer->private_data;
6081 const struct scarlett2_device_info *info = private->info;
6083 if (!info->has_speaker_switching)
6087 mixer, &scarlett2_speaker_switch_enum_ctl,
6089 &private->speaker_switching_ctl);
6107 struct usb_mixer_elem_info *elem = kctl->private_data;
6108 struct usb_mixer_interface *mixer = elem->head.mixer;
6109 struct scarlett2_data *private = mixer->private_data;
6112 guard(mutex)(&private->data_mutex);
6114 if (private->hwdep_in_use)
6115 return -EBUSY;
6117 if (private->monitor_other_updated) {
6118 err = scarlett2_update_monitor_other(mixer);
6122 ucontrol->value.enumerated.item[0] = private->talkback_switch;
6129 struct usb_mixer_elem_info *elem = kctl->private_data;
6130 struct usb_mixer_interface *mixer = elem->head.mixer;
6131 struct scarlett2_data *private = mixer->private_data;
6134 guard(mutex)(&private->data_mutex);
6136 if (private->hwdep_in_use)
6137 return -EBUSY;
6139 oval = private->talkback_switch;
6140 val = min(ucontrol->value.enumerated.item[0], 2U);
6145 private->talkback_switch = val;
6149 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6156 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6173 struct usb_mixer_elem_info *elem = kctl->private_data;
6174 struct usb_mixer_interface *mixer = elem->head.mixer;
6175 struct scarlett2_data *private = mixer->private_data;
6176 int index = elem->control;
6178 ucontrol->value.integer.value[0] = private->talkback_map[index];
6186 struct usb_mixer_elem_info *elem = kctl->private_data;
6187 struct usb_mixer_interface *mixer = elem->head.mixer;
6188 struct scarlett2_data *private = mixer->private_data;
6189 int index = elem->control;
6193 guard(mutex)(&private->data_mutex);
6195 if (private->hwdep_in_use)
6196 return -EBUSY;
6198 oval = private->talkback_map[index];
6199 val = !!ucontrol->value.integer.value[0];
6204 private->talkback_map[index] = val;
6206 for (i = 0; i < private->num_mix_out; i++)
6207 bitmap |= private->talkback_map[i] << i;
6210 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
6224 static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer)
6226 struct scarlett2_data *private = mixer->private_data;
6227 const struct scarlett2_device_info *info = private->info;
6231 if (!info->has_talkback)
6235 mixer, &scarlett2_talkback_enum_ctl,
6237 &private->talkback_ctl);
6241 for (i = 0; i < private->num_mix_out; i++) {
6244 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
6258 struct usb_mixer_elem_info *elem = kctl->private_data;
6259 struct usb_mixer_interface *mixer = elem->head.mixer;
6260 struct scarlett2_data *private = mixer->private_data;
6263 guard(mutex)(&private->data_mutex);
6265 if (private->hwdep_in_use)
6266 return -EBUSY;
6268 if (private->dim_mute_updated) {
6269 err = scarlett2_update_dim_mute(mixer);
6273 ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
6280 struct usb_mixer_elem_info *elem = kctl->private_data;
6281 struct usb_mixer_interface *mixer = elem->head.mixer;
6282 struct scarlett2_data *private = mixer->private_data;
6283 int index = elem->control;
6286 guard(mutex)(&private->data_mutex);
6288 if (private->hwdep_in_use)
6289 return -EBUSY;
6291 oval = private->dim_mute[index];
6292 val = !!ucontrol->value.integer.value[0];
6297 private->dim_mute[index] = val;
6300 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
6303 for (i = 0; i < private->num_line_out; i++) {
6306 if (private->vol_sw_hw_switch[line_index]) {
6307 private->mute_switch[line_index] = val;
6308 snd_ctl_notify(mixer->chip->card,
6310 &private->mute_ctls[i]->id);
6330 struct usb_mixer_elem_info *elem = kctl->private_data;
6331 struct scarlett2_data *private = elem->head.mixer->private_data;
6333 ucontrol->value.integer.value[0] =
6334 !!(private->sp_hp_mute & (1 << elem->control));
6342 struct usb_mixer_elem_info *elem = kctl->private_data;
6343 struct usb_mixer_interface *mixer = elem->head.mixer;
6344 struct scarlett2_data *private = mixer->private_data;
6345 int index = elem->control;
6348 guard(mutex)(&private->data_mutex);
6350 if (private->hwdep_in_use)
6351 return -EBUSY;
6353 val = private->sp_hp_mute;
6355 if (ucontrol->value.integer.value[0])
6360 if (val == private->sp_hp_mute)
6363 private->sp_hp_mute = val;
6366 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SP_HP_MUTE,
6382 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
6384 struct scarlett2_data *private = mixer->private_data;
6385 const struct scarlett2_device_info *info = private->info;
6393 err = scarlett2_add_new_ctl(mixer,
6395 0, 1, s, &private->master_vol_ctl);
6404 err = scarlett2_add_new_ctl(mixer,
6407 &private->headphone_vol_ctl);
6413 if (private->info->sp_hp_mute_names)
6414 for (i = 0; private->info->sp_hp_mute_names[i]; i++) {
6416 mixer, &scarlett2_sp_hp_mute_ctl,
6417 i, 1, private->info->sp_hp_mute_names[i],
6424 * has per-channel line-out volume controls.
6431 for (i = 0; i < private->num_line_out; i++) {
6435 if (info->line_out_descrs[i])
6438 i + 1, info->line_out_descrs[i]);
6443 err = scarlett2_add_new_ctl(mixer,
6445 i, 1, s, &private->vol_ctls[i]);
6453 err = scarlett2_add_new_ctl(mixer,
6456 &private->mute_ctls[i]);
6464 /* Make the fader and mute controls read-only if the
6467 if (private->vol_sw_hw_switch[index])
6468 scarlett2_vol_ctl_set_writable(mixer, i, 0);
6473 err = scarlett2_add_new_ctl(mixer,
6476 &private->sw_hw_ctls[i]);
6480 /* Make the switch read-only if the line is
6483 if (private->speaker_switching_switch && i < 4)
6492 mixer, &scarlett2_dim_mute_ctl,
6494 &private->dim_mute_ctls[i]);
6504 static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i)
6506 struct scarlett2_data *private = mixer->private_data;
6507 const struct scarlett2_device_info *info = private->info;
6519 scnprintf(s, sizeof(s), compr_fmt, i + 1, param->name);
6521 mixer, &scarlett2_compressor_ctl,
6523 1, s, &private->compressor_ctls[idx]);
6529 scnprintf(s, sizeof(s), flt_switch_fmt, i + 1, "Pre-Comp");
6531 mixer, &scarlett2_precomp_flt_switch_ctl,
6532 i, 1, s, &private->precomp_flt_switch_ctls[i]);
6538 mixer, &scarlett2_peq_flt_switch_ctl,
6539 i, 1, s, &private->peq_flt_switch_ctls[i]);
6544 for (j = 0; j < info->precomp_flt_count; j++) {
6545 scnprintf(s, sizeof(s), flt_fmt, i + 1, "Pre-Comp", j + 1);
6547 mixer, &scarlett2_precomp_flt_ctl,
6548 i * info->precomp_flt_count + j,
6549 1, s, &private->precomp_flt_switch_ctls[j]);
6554 for (j = 0; j < info->peq_flt_count; j++) {
6557 mixer, &scarlett2_peq_flt_ctl,
6558 i * info->peq_flt_count + j,
6559 1, s, &private->peq_flt_switch_ctls[j]);
6567 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
6569 struct scarlett2_data *private = mixer->private_data;
6570 const struct scarlett2_device_info *info = private->info;
6574 const char *fmt2 = "Line In %d-%d %s Capture %s";
6577 for (i = 0; i < info->level_input_count; i++) {
6578 scnprintf(s, sizeof(s), fmt, i + 1 + info->level_input_first,
6580 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
6581 i, 1, s, &private->level_ctls[i]);
6587 for (i = 0; i < info->pad_input_count; i++) {
6589 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
6590 i, 1, s, &private->pad_ctls[i]);
6596 for (i = 0; i < info->air_input_count; i++) {
6597 scnprintf(s, sizeof(s), fmt, i + 1 + info->air_input_first,
6598 "Air", info->air_option ? "Enum" : "Switch");
6600 mixer, &scarlett2_air_ctl[info->air_option],
6601 i, 1, s, &private->air_ctls[i]);
6607 for (i = 0; i < info->dsp_input_count; i++) {
6609 err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl,
6610 i, 1, s, &private->dsp_ctls[i]);
6614 err = scarlett2_add_dsp_ctls(mixer, i);
6620 for (i = 0; i < info->mute_input_count; i++) {
6623 mixer, &scarlett2_input_mute_ctl,
6624 i, 1, s, &private->input_mute_ctls[i]);
6630 if (info->inputs_per_phantom == 1) {
6631 for (i = 0; i < info->phantom_count; i++) {
6633 i + 1 + info->phantom_first,
6636 mixer, &scarlett2_phantom_ctl,
6637 i, 1, s, &private->phantom_ctls[i]);
6641 } else if (info->inputs_per_phantom > 1) {
6642 for (i = 0; i < info->phantom_count; i++) {
6643 int from = i * info->inputs_per_phantom + 1;
6644 int to = (i + 1) * info->inputs_per_phantom;
6649 mixer, &scarlett2_phantom_ctl,
6650 i, 1, s, &private->phantom_ctls[i]);
6655 if (info->phantom_count &&
6659 mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
6669 mixer, &scarlett2_input_select_ctl, 0, 1,
6671 &private->input_select_ctl);
6678 for (i = 0; i < info->gain_input_count; i++) {
6682 mixer, &scarlett2_input_link_ctl,
6683 i, 1, s, &private->input_link_ctls[i]);
6689 /* Add software-controllable input gain controls */
6690 for (i = 0; i < info->gain_input_count; i++) {
6694 mixer, &scarlett2_input_gain_ctl,
6695 i, 1, s, &private->input_gain_ctls[i]);
6698 private->input_gain_ctls[i]->tlv.p =
6699 private->config_set->input_gain_tlv;
6704 mixer, &scarlett2_autogain_switch_ctl,
6705 i, 1, s, &private->autogain_ctls[i]);
6712 mixer, &scarlett2_autogain_status_ctl,
6713 i, 1, s, &private->autogain_status_ctls[i]);
6724 mixer, &scarlett2_ag_target_ctl,
6725 i, 1, s, &private->ag_target_ctls[i]);
6730 /* Add safe-mode input switch controls */
6731 for (i = 0; i < info->safe_input_count; i++) {
6735 mixer, &scarlett2_safe_ctl,
6736 i, 1, s, &private->safe_ctls[i]);
6745 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1,
6747 &private->pcm_input_switch_ctl);
6755 /*** Mixer Volume Controls ***/
6757 static int scarlett2_update_mix(struct usb_mixer_interface *mixer)
6759 struct scarlett2_data *private = mixer->private_data;
6762 private->mix_updated = 0;
6764 for (i = 0; i < private->num_mix_out; i++) {
6765 err = scarlett2_usb_get_mix(mixer, i);
6776 struct usb_mixer_elem_info *elem = kctl->private_data;
6778 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
6779 uinfo->count = elem->channels;
6780 uinfo->value.integer.min = 0;
6781 uinfo->value.integer.max = SCARLETT2_MIXER_MAX_VALUE;
6782 uinfo->value.integer.step = 1;
6789 struct usb_mixer_elem_info *elem = kctl->private_data;
6790 struct usb_mixer_interface *mixer = elem->head.mixer;
6791 struct scarlett2_data *private = mixer->private_data;
6794 guard(mutex)(&private->data_mutex);
6796 if (private->hwdep_in_use)
6797 return -EBUSY;
6799 if (private->mix_updated) {
6800 err = scarlett2_update_mix(mixer);
6804 ucontrol->value.integer.value[0] = private->mix[elem->control];
6811 struct usb_mixer_elem_info *elem = kctl->private_data;
6812 struct usb_mixer_interface *mixer = elem->head.mixer;
6813 struct scarlett2_data *private = mixer->private_data;
6815 int index = elem->control;
6817 guard(mutex)(&private->data_mutex);
6819 if (private->hwdep_in_use)
6820 return -EBUSY;
6822 oval = private->mix[index];
6823 val = clamp(ucontrol->value.integer.value[0],
6825 mix_num = index / private->num_mix_in;
6830 private->mix[index] = val;
6831 err = scarlett2_usb_set_mix(mixer, mix_num);
6854 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
6856 struct scarlett2_data *private = mixer->private_data;
6861 for (i = 0, index = 0; i < private->num_mix_out; i++)
6862 for (j = 0; j < private->num_mix_in; j++, index++) {
6866 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
6868 &private->mix_ctls[index]);
6878 static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)
6880 struct scarlett2_data *private = mixer->private_data;
6882 private->direct_monitor_updated = 0;
6884 if (!private->info->direct_monitor)
6888 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
6889 1, &private->direct_monitor_switch);
6892 static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)
6894 struct scarlett2_data *private = mixer->private_data;
6898 if (!private->num_monitor_mix_ctls)
6902 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
6903 private->num_monitor_mix_ctls, mix_values);
6907 for (i = 0; i < private->num_monitor_mix_ctls; i++)
6908 private->monitor_mix[i] = scarlett2_mixer_value_to_db(
6917 struct usb_mixer_elem_info *elem = kctl->private_data;
6918 struct usb_mixer_interface *mixer = elem->head.mixer;
6919 struct scarlett2_data *private = mixer->private_data;
6922 guard(mutex)(&private->data_mutex);
6924 if (private->hwdep_in_use)
6925 return -EBUSY;
6927 if (private->direct_monitor_updated) {
6928 err = scarlett2_update_direct_monitor(mixer);
6932 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
6939 struct usb_mixer_elem_info *elem = kctl->private_data;
6940 struct usb_mixer_interface *mixer = elem->head.mixer;
6941 struct scarlett2_data *private = mixer->private_data;
6942 int index = elem->control;
6945 guard(mutex)(&private->data_mutex);
6947 if (private->hwdep_in_use)
6948 return -EBUSY;
6950 oval = private->direct_monitor_switch;
6951 val = min(ucontrol->value.enumerated.item[0], 2U);
6956 private->direct_monitor_switch = val;
6960 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
6975 /* Direct Monitor for Solo is mono-only and only needs a boolean control
6998 struct usb_mixer_elem_info *elem = kctl->private_data;
6999 struct scarlett2_data *private = elem->head.mixer->private_data;
7001 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control];
7009 struct usb_mixer_elem_info *elem = kctl->private_data;
7010 struct usb_mixer_interface *mixer = elem->head.mixer;
7011 struct scarlett2_data *private = mixer->private_data;
7013 int index = elem->control;
7015 guard(mutex)(&private->data_mutex);
7017 if (private->hwdep_in_use)
7018 return -EBUSY;
7020 oval = private->monitor_mix[index];
7021 val = clamp(ucontrol->value.integer.value[0],
7027 private->monitor_mix[index] = val;
7029 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
7047 static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer)
7049 struct scarlett2_data *private = mixer->private_data;
7050 const struct scarlett2_device_info *info = private->info;
7054 if (!info->direct_monitor)
7057 s = info->direct_monitor == 1
7062 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
7063 0, 1, s, &private->direct_monitor_ctl);
7067 if (!private->num_monitor_mix_ctls)
7071 for (i = 0, index = 0; i < info->direct_monitor; i++) {
7076 if (info->direct_monitor == 1)
7087 for (k = 0; k < private->num_mix_in; k++, index++) {
7094 mixer, &scarlett2_monitor_mix_ctl,
7109 struct usb_mixer_elem_info *elem = kctl->private_data;
7110 struct scarlett2_data *private = elem->head.mixer->private_data;
7111 const struct scarlett2_device_info *info = private->info;
7112 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7113 unsigned int item = uinfo->value.enumerated.item;
7114 int items = private->num_mux_srcs;
7117 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
7118 uinfo->count = elem->channels;
7119 uinfo->value.enumerated.items = items;
7122 item = uinfo->value.enumerated.item = items - 1;
7132 item >= private->num_mix_out)
7133 scnprintf(uinfo->value.enumerated.name,
7134 sizeof(uinfo->value.enumerated.name),
7135 port->dsp_src_descr,
7136 item - private->num_mix_out + 1);
7138 scnprintf(uinfo->value.enumerated.name,
7139 sizeof(uinfo->value.enumerated.name),
7140 port->src_descr,
7141 item + port->src_num_offset);
7145 item -= port_count[port_type][SCARLETT2_PORT_IN];
7148 return -EINVAL;
7154 struct usb_mixer_elem_info *elem = kctl->private_data;
7155 struct usb_mixer_interface *mixer = elem->head.mixer;
7156 struct scarlett2_data *private = mixer->private_data;
7157 int index = line_out_remap(private, elem->control);
7160 guard(mutex)(&private->data_mutex);
7162 if (private->hwdep_in_use)
7163 return -EBUSY;
7165 if (private->mux_updated) {
7166 err = scarlett2_usb_get_mux(mixer);
7170 ucontrol->value.enumerated.item[0] = private->mux[index];
7177 struct usb_mixer_elem_info *elem = kctl->private_data;
7178 struct usb_mixer_interface *mixer = elem->head.mixer;
7179 struct scarlett2_data *private = mixer->private_data;
7180 int index = line_out_remap(private, elem->control);
7183 guard(mutex)(&private->data_mutex);
7185 if (private->hwdep_in_use)
7186 return -EBUSY;
7188 oval = private->mux[index];
7189 val = min(ucontrol->value.enumerated.item[0],
7190 private->num_mux_srcs - 1U);
7195 private->mux[index] = val;
7196 err = scarlett2_usb_set_mux(mixer);
7209 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
7211 struct scarlett2_data *private = mixer->private_data;
7212 const struct scarlett2_device_info *info = private->info;
7213 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
7227 const char *descr = port->dst_descr;
7230 channel >= private->num_mix_in) {
7231 channel_num -= private->num_mix_in;
7232 descr = port->dsp_dst_descr;
7235 snprintf(s, sizeof(s) - 5, descr, channel_num);
7238 err = scarlett2_add_new_ctl(mixer,
7241 &private->mux_ctls[i]);
7255 struct usb_mixer_elem_info *elem = kctl->private_data;
7257 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7258 uinfo->count = elem->channels;
7259 uinfo->value.integer.min = 0;
7260 uinfo->value.integer.max = 4095;
7261 uinfo->value.integer.step = 1;
7268 struct usb_mixer_elem_info *elem = kctl->private_data;
7269 struct usb_mixer_interface *mixer = elem->head.mixer;
7270 struct scarlett2_data *private = mixer->private_data;
7271 u8 *meter_level_map = private->meter_level_map;
7275 guard(mutex)(&private->data_mutex);
7277 if (private->hwdep_in_use)
7278 return -EBUSY;
7280 err = scarlett2_usb_get_meter_levels(mixer, elem->channels,
7286 for (i = 0; i < elem->channels; i++) {
7295 ucontrol->value.integer.value[i] = value;
7309 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
7311 struct scarlett2_data *private = mixer->private_data;
7313 /* devices without a mixer also don't support reporting levels */
7317 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
7318 0, private->num_mux_dsts,
7327 struct usb_mixer_elem_info *elem = kctl->private_data;
7328 struct scarlett2_data *private = elem->head.mixer->private_data;
7330 ucontrol->value.integer.value[0] = private->msd_switch;
7337 struct usb_mixer_elem_info *elem = kctl->private_data;
7338 struct usb_mixer_interface *mixer = elem->head.mixer;
7339 struct scarlett2_data *private = mixer->private_data;
7342 guard(mutex)(&private->data_mutex);
7344 if (private->hwdep_in_use)
7345 return -EBUSY;
7347 oval = private->msd_switch;
7348 val = !!ucontrol->value.integer.value[0];
7353 private->msd_switch = val;
7356 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
7370 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
7372 struct scarlett2_data *private = mixer->private_data;
7377 /* If MSD mode is off, hide the switch by default */
7378 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
7382 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
7383 0, 1, "MSD Mode Switch", NULL);
7391 struct usb_mixer_elem_info *elem = kctl->private_data;
7392 struct scarlett2_data *private = elem->head.mixer->private_data;
7394 ucontrol->value.integer.value[0] = private->standalone_switch;
7401 struct usb_mixer_elem_info *elem = kctl->private_data;
7402 struct usb_mixer_interface *mixer = elem->head.mixer;
7403 struct scarlett2_data *private = mixer->private_data;
7406 guard(mutex)(&private->data_mutex);
7408 if (private->hwdep_in_use)
7409 return -EBUSY;
7411 oval = private->standalone_switch;
7412 val = !!ucontrol->value.integer.value[0];
7417 private->standalone_switch = val;
7420 err = scarlett2_usb_set_config(mixer,
7435 static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
7437 struct scarlett2_data *private = mixer->private_data;
7444 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
7450 static int scarlett2_update_power_status(struct usb_mixer_interface *mixer)
7452 struct scarlett2_data *private = mixer->private_data;
7456 private->power_status_updated = 0;
7458 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT,
7463 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW,
7469 private->power_status = SCARLETT2_POWER_STATUS_FAIL;
7471 private->power_status = SCARLETT2_POWER_STATUS_EXT;
7473 private->power_status = SCARLETT2_POWER_STATUS_BUS;
7481 struct usb_mixer_elem_info *elem = kctl->private_data;
7482 struct usb_mixer_interface *mixer = elem->head.mixer;
7483 struct scarlett2_data *private = mixer->private_data;
7486 guard(mutex)(&private->data_mutex);
7488 if (private->power_status_updated) {
7489 err = scarlett2_update_power_status(mixer);
7493 ucontrol->value.integer.value[0] = private->power_status;
7515 static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer)
7517 struct scarlett2_data *private = mixer->private_data;
7524 return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl,
7526 &private->power_status_ctl);
7531 static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer)
7533 struct scarlett2_data *private = mixer->private_data;
7536 private->bluetooth_updated = 0;
7538 if (!private->info->has_bluetooth)
7541 err = scarlett2_usb_get_config(mixer,
7543 1, &private->bluetooth_volume);
7553 struct usb_mixer_elem_info *elem = kctl->private_data;
7554 struct usb_mixer_interface *mixer = elem->head.mixer;
7555 struct scarlett2_data *private = mixer->private_data;
7558 guard(mutex)(&private->data_mutex);
7560 if (private->hwdep_in_use)
7561 return -EBUSY;
7563 if (private->bluetooth_updated) {
7564 err = scarlett2_update_bluetooth_volume(mixer);
7568 ucontrol->value.integer.value[0] = private->bluetooth_volume;
7575 struct usb_mixer_elem_info *elem = kctl->private_data;
7576 struct usb_mixer_interface *mixer = elem->head.mixer;
7577 struct scarlett2_data *private = mixer->private_data;
7580 guard(mutex)(&private->data_mutex);
7582 if (private->hwdep_in_use)
7583 return -EBUSY;
7585 oval = private->bluetooth_volume;
7586 val = clamp(ucontrol->value.integer.value[0],
7592 private->bluetooth_volume = val;
7593 err = scarlett2_usb_set_config(mixer,
7603 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
7604 uinfo->count = 1;
7605 uinfo->value.integer.min = 0;
7606 uinfo->value.integer.max = SCARLETT2_MAX_BLUETOOTH_VOLUME;
7607 uinfo->value.integer.step = 1;
7620 struct usb_mixer_interface *mixer)
7622 struct scarlett2_data *private = mixer->private_data;
7624 if (!private->info->has_bluetooth)
7628 return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl,
7630 &private->bluetooth_volume_ctl);
7633 /*** S/PDIF Mode Controls ***/
7635 static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer)
7637 struct scarlett2_data *private = mixer->private_data;
7639 u8 mode;
7640 const u8 *mode_values = private->info->spdif_mode_values;
7642 if (!private->info->spdif_mode_control_name)
7645 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE,
7646 1, &mode);
7650 private->spdif_mode = 0;
7653 if (*mode_values == mode) {
7654 private->spdif_mode = i;
7664 struct usb_mixer_elem_info *elem = kctl->private_data;
7665 struct scarlett2_data *private = elem->head.mixer->private_data;
7666 const char * const *mode_texts = private->info->spdif_mode_texts;
7673 private->info->spdif_mode_texts);
7679 struct usb_mixer_elem_info *elem = kctl->private_data;
7680 struct scarlett2_data *private = elem->head.mixer->private_data;
7682 ucontrol->value.enumerated.item[0] = private->spdif_mode;
7689 struct usb_mixer_elem_info *elem = kctl->private_data;
7690 struct usb_mixer_interface *mixer = elem->head.mixer;
7691 struct scarlett2_data *private = mixer->private_data;
7695 guard(mutex)(&private->data_mutex);
7697 oval = private->spdif_mode;
7698 val = ucontrol->value.enumerated.item[0];
7701 return -EINVAL;
7704 if (private->info->spdif_mode_values[i] == 0xff)
7705 return -EINVAL;
7710 private->spdif_mode = val;
7713 mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0,
7714 private->info->spdif_mode_values[val]);
7727 static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer)
7729 struct scarlett2_data *private = mixer->private_data;
7731 if (!private->info->spdif_mode_control_name)
7734 return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl,
7736 private->info->spdif_mode_control_name,
7743 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)
7745 struct scarlett2_data *private = mixer->private_data;
7747 private->sync_updated = 1;
7749 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7750 &private->sync_ctl->id);
7754 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer)
7756 struct snd_card *card = mixer->chip->card;
7757 struct scarlett2_data *private = mixer->private_data;
7763 private->vol_updated = 1;
7765 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7766 &private->master_vol_ctl->id);
7768 for (i = 0; i < private->num_line_out; i++)
7769 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
7771 &private->vol_ctls[i]->id);
7775 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)
7777 struct scarlett2_data *private = mixer->private_data;
7779 private->vol_updated = 1;
7781 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7782 &private->master_vol_ctl->id);
7783 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7784 &private->headphone_vol_ctl->id);
7788 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer)
7790 struct snd_card *card = mixer->chip->card;
7791 struct scarlett2_data *private = mixer->private_data;
7797 private->dim_mute_updated = 1;
7801 &private->dim_mute_ctls[i]->id);
7803 for (i = 0; i < private->num_line_out; i++)
7804 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
7806 &private->mute_ctls[i]->id);
7810 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer)
7812 struct snd_card *card = mixer->chip->card;
7813 struct scarlett2_data *private = mixer->private_data;
7814 const struct scarlett2_device_info *info = private->info;
7817 private->input_level_updated = 1;
7819 for (i = 0; i < info->level_input_count; i++)
7821 &private->level_ctls[i]->id);
7825 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer)
7827 struct snd_card *card = mixer->chip->card;
7828 struct scarlett2_data *private = mixer->private_data;
7829 const struct scarlett2_device_info *info = private->info;
7832 private->input_pad_updated = 1;
7834 for (i = 0; i < info->pad_input_count; i++)
7836 &private->pad_ctls[i]->id);
7840 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer)
7842 struct snd_card *card = mixer->chip->card;
7843 struct scarlett2_data *private = mixer->private_data;
7844 const struct scarlett2_device_info *info = private->info;
7847 private->input_air_updated = 1;
7849 for (i = 0; i < info->air_input_count; i++)
7851 &private->air_ctls[i]->id);
7855 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer)
7857 struct snd_card *card = mixer->chip->card;
7858 struct scarlett2_data *private = mixer->private_data;
7859 const struct scarlett2_device_info *info = private->info;
7862 private->input_dsp_updated = 1;
7864 for (i = 0; i < info->dsp_input_count; i++)
7866 &private->dsp_ctls[i]->id);
7870 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer)
7872 struct snd_card *card = mixer->chip->card;
7873 struct scarlett2_data *private = mixer->private_data;
7874 const struct scarlett2_device_info *info = private->info;
7877 private->input_mute_updated = 1;
7879 for (i = 0; i < info->mute_input_count; i++)
7881 &private->input_mute_ctls[i]->id);
7885 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer)
7887 struct snd_card *card = mixer->chip->card;
7888 struct scarlett2_data *private = mixer->private_data;
7889 const struct scarlett2_device_info *info = private->info;
7892 private->input_phantom_updated = 1;
7894 for (i = 0; i < info->phantom_count; i++)
7896 &private->phantom_ctls[i]->id);
7898 scarlett2_phantom_notify_access(mixer);
7902 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer)
7904 scarlett2_notify_input_level(mixer);
7905 scarlett2_notify_input_pad(mixer);
7906 scarlett2_notify_input_air(mixer);
7907 scarlett2_notify_input_phantom(mixer);
7911 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer)
7913 struct snd_card *card = mixer->chip->card;
7914 struct scarlett2_data *private = mixer->private_data;
7915 const struct scarlett2_device_info *info = private->info;
7922 private->input_select_updated = 1;
7926 &private->input_select_ctl->id);
7928 for (i = 0; i < info->gain_input_count; i++)
7930 &private->input_link_ctls[i]->id);
7934 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer)
7936 struct snd_card *card = mixer->chip->card;
7937 struct scarlett2_data *private = mixer->private_data;
7938 const struct scarlett2_device_info *info = private->info;
7941 if (!info->gain_input_count)
7944 private->input_gain_updated = 1;
7946 for (i = 0; i < info->gain_input_count; i++)
7948 &private->input_gain_ctls[i]->id);
7952 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer)
7954 struct snd_card *card = mixer->chip->card;
7955 struct scarlett2_data *private = mixer->private_data;
7956 const struct scarlett2_device_info *info = private->info;
7959 if (!info->gain_input_count)
7962 private->autogain_updated = 1;
7964 for (i = 0; i < info->gain_input_count; i++) {
7966 &private->autogain_ctls[i]->id);
7968 &private->autogain_status_ctls[i]->id);
7975 &private->ag_target_ctls[i]->id);
7977 scarlett2_autogain_notify_access(mixer);
7981 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer)
7983 struct snd_card *card = mixer->chip->card;
7984 struct scarlett2_data *private = mixer->private_data;
7985 const struct scarlett2_device_info *info = private->info;
7988 if (!info->safe_input_count)
7991 private->input_safe_updated = 1;
7993 for (i = 0; i < info->safe_input_count; i++)
7995 &private->safe_ctls[i]->id);
7999 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer)
8001 struct snd_card *card = mixer->chip->card;
8002 struct scarlett2_data *private = mixer->private_data;
8003 const struct scarlett2_device_info *info = private->info;
8005 private->monitor_other_updated = 1;
8007 if (info->has_speaker_switching)
8009 &private->speaker_switching_ctl->id);
8011 if (info->has_talkback)
8013 &private->talkback_ctl->id);
8018 if (private->speaker_switching_switched) {
8021 scarlett2_notify_dim_mute(mixer);
8023 private->speaker_switching_switched = 0;
8024 private->mux_updated = 1;
8026 for (i = 0; i < private->num_mux_dsts; i++)
8028 &private->mux_ctls[i]->id);
8033 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer)
8035 struct snd_card *card = mixer->chip->card;
8036 struct scarlett2_data *private = mixer->private_data;
8037 int count = private->num_mix_in * private->num_mix_out;
8040 private->direct_monitor_updated = 1;
8043 &private->direct_monitor_ctl->id);
8048 private->mix_updated = 1;
8053 &private->mix_ctls[i]->id);
8057 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer)
8059 struct snd_card *card = mixer->chip->card;
8060 struct scarlett2_data *private = mixer->private_data;
8062 private->power_status_updated = 1;
8065 &private->power_status_ctl->id);
8069 static void scarlett2_notify_mux(struct usb_mixer_interface *mixer)
8071 struct snd_card *card = mixer->chip->card;
8072 struct scarlett2_data *private = mixer->private_data;
8075 private->mux_updated = 1;
8077 for (i = 0; i < private->num_mux_dsts; i++)
8079 &private->mux_ctls[i]->id);
8083 static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer)
8085 struct snd_card *card = mixer->chip->card;
8086 struct scarlett2_data *private = mixer->private_data;
8088 private->pcm_input_switch_updated = 1;
8091 &private->pcm_input_switch_ctl->id);
8093 scarlett2_notify_mux(mixer);
8097 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer)
8099 struct snd_card *card = mixer->chip->card;
8100 struct scarlett2_data *private = mixer->private_data;
8102 if (!private->info->has_bluetooth)
8105 private->bluetooth_updated = 1;
8108 &private->bluetooth_volume_ctl->id);
8114 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer)
8116 struct scarlett2_data *private = mixer->private_data;
8119 if (private->running)
8120 complete(&private->cmd_done);
8126 struct usb_mixer_interface *mixer = urb->context;
8127 int len = urb->actual_length;
8128 int ustatus = urb->status;
8130 struct scarlett2_data *private = mixer->private_data;
8132 private->config_set->notifications;
8137 data = le32_to_cpu(*(__le32 *)urb->transfer_buffer);
8142 if (private->running < 2)
8145 while (data && notifications->mask) {
8146 if (data & notifications->mask) {
8147 data &= ~notifications->mask;
8148 if (notifications->func)
8149 notifications->func(mixer);
8155 usb_audio_warn(mixer->chip,
8160 if (ustatus != -ENOENT &&
8161 ustatus != -ECONNRESET &&
8162 ustatus != -ESHUTDOWN) {
8163 urb->dev = mixer->chip->dev;
8166 complete(&private->cmd_done);
8172 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
8174 struct scarlett2_data *private = mixer->private_data;
8176 cancel_delayed_work_sync(&private->work);
8178 mixer->private_data = NULL;
8181 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
8183 struct scarlett2_data *private = mixer->private_data;
8185 if (cancel_delayed_work_sync(&private->work))
8186 scarlett2_config_save(private->mixer);
8193 const struct scarlett2_device_info *info = private->info;
8194 const struct scarlett2_config_set *config_set = info->config_set;
8195 const int (*port_count)[SCARLETT2_PORT_DIRNS] = info->port_count;
8206 private->num_mux_srcs = srcs;
8207 private->num_mux_dsts = dsts;
8209 /* Mixer inputs are mux outputs and vice versa.
8211 * doesn't have mixer controls.
8213 private->num_mix_in =
8214 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_OUT] -
8215 info->dsp_count;
8217 private->num_mix_out =
8218 port_count[SCARLETT2_PORT_TYPE_MIX][SCARLETT2_PORT_IN] -
8219 info->dsp_count;
8222 private->num_line_out =
8226 private->num_monitor_mix_ctls =
8227 info->direct_monitor * 2 * private->num_mix_in;
8230 if (config_set->autogain_status_texts) {
8231 const char * const *texts = config_set->autogain_status_texts;
8235 private->num_autogain_status_texts = i;
8247 struct usb_host_config *config = dev->actconfig;
8250 for (i = 0; i < config->desc.bNumInterfaces; i++) {
8251 struct usb_interface *intf = config->interface[i];
8253 &intf->altsetting[0].desc;
8256 if (desc->bInterfaceClass != 255)
8259 epd = get_endpoint(intf->altsetting, 0);
8260 private->bInterfaceNumber = desc->bInterfaceNumber;
8261 private->bEndpointAddress = usb_endpoint_num(epd);
8262 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
8263 private->bInterval = epd->bInterval;
8267 return -EINVAL;
8271 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
8278 return -ENOMEM;
8280 mutex_init(&private->usb_mutex);
8281 mutex_init(&private->data_mutex);
8282 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
8284 mixer->private_data = private;
8285 mixer->private_free = scarlett2_private_free;
8286 mixer->private_suspend = scarlett2_private_suspend;
8288 private->info = entry->info;
8289 private->config_set = entry->info->config_set;
8290 private->series_name = entry->series_name;
8292 private->scarlett2_seq = 0;
8293 private->mixer = mixer;
8295 return scarlett2_find_fc_interface(mixer->chip->dev, private);
8299 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
8301 struct usb_device *dev = mixer->chip->dev;
8302 struct scarlett2_data *private = mixer->private_data;
8303 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
8306 if (mixer->urb) {
8307 usb_audio_err(mixer->chip,
8308 "%s: mixer urb already in use!\n", __func__);
8313 return -EINVAL;
8315 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
8316 if (!mixer->urb)
8317 return -ENOMEM;
8319 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
8321 return -ENOMEM;
8323 usb_fill_int_urb(mixer->urb, dev, pipe,
8324 transfer_buffer, private->wMaxPacketSize,
8325 scarlett2_notify, mixer, private->bInterval);
8327 init_completion(&private->cmd_done);
8329 return usb_submit_urb(mixer->urb, GFP_KERNEL);
8333 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
8335 struct usb_device *dev = mixer->chip->dev;
8336 struct scarlett2_data *private = mixer->private_data;
8342 return -EINVAL;
8345 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
8357 err = scarlett2_init_notify(mixer);
8367 private->running = 1;
8370 private->scarlett2_seq = 1;
8371 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
8376 private->scarlett2_seq = 1;
8377 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,
8383 /* extract 4-byte firmware version from step2_buf[8] */
8384 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8));
8385 usb_audio_info(mixer->chip,
8387 private->firmware_version);
8395 static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer)
8397 struct scarlett2_data *private = mixer->private_data;
8412 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH,
8423 usb_audio_err(mixer->chip,
8425 return -EINVAL;
8432 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,
8436 usb_audio_err(mixer->chip,
8451 private->flash_segment_nums[flash_segment_id] = i;
8452 private->flash_segment_blocks[flash_segment_id] =
8458 * use 0 as the "not-found" value
8460 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) {
8461 usb_audio_err(mixer->chip,
8464 return -EINVAL;
8466 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) {
8467 usb_audio_err(mixer->chip,
8470 return -EINVAL;
8477 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
8479 struct scarlett2_data *private = mixer->private_data;
8480 const struct scarlett2_device_info *info = private->info;
8485 mixer, SCARLETT2_CONFIG_MSD_SWITCH,
8486 1, &private->msd_switch);
8491 if (private->firmware_version < info->min_firmware_version) {
8492 usb_audio_err(mixer->chip,
8495 private->series_name,
8496 private->firmware_version,
8497 info->min_firmware_version);
8501 /* no other controls are created if MSD mode is on */
8502 if (private->msd_switch)
8505 err = scarlett2_update_input_level(mixer);
8509 err = scarlett2_update_input_pad(mixer);
8513 err = scarlett2_update_input_air(mixer);
8517 err = scarlett2_update_input_dsp(mixer);
8521 err = scarlett2_update_compressor_values(mixer);
8525 err = scarlett2_update_filter_values(mixer);
8529 err = scarlett2_update_input_mute(mixer);
8533 err = scarlett2_update_input_phantom(mixer);
8537 err = scarlett2_update_direct_monitor(mixer);
8541 /* the rest of the configuration is for devices with a mixer */
8545 err = scarlett2_update_monitor_mix(mixer);
8549 err = scarlett2_update_monitor_other(mixer);
8556 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
8557 1, &private->standalone_switch);
8564 err = scarlett2_update_power_status(mixer);
8569 err = scarlett2_update_sync(mixer);
8579 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
8580 private->num_line_out, &sw_vol);
8584 for (i = 0; i < private->num_line_out; i++)
8585 private->vol[i] = clamp(
8591 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
8592 private->num_line_out, &private->mute_switch);
8596 for (i = 0; i < private->num_line_out; i++)
8597 private->mute_switch[i] =
8598 !!private->mute_switch[i];
8604 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
8605 private->num_line_out,
8606 &private->vol_sw_hw_switch);
8610 for (i = 0; i < private->num_line_out; i++)
8611 private->vol_sw_hw_switch[i] =
8612 !!private->vol_sw_hw_switch[i];
8616 err = scarlett2_update_volumes(mixer);
8620 err = scarlett2_update_dim_mute(mixer);
8624 err = scarlett2_update_input_select(mixer);
8628 err = scarlett2_update_input_gain(mixer);
8632 err = scarlett2_update_autogain(mixer);
8636 err = scarlett2_update_input_safe(mixer);
8642 err = scarlett2_update_pcm_input_switch(mixer);
8647 err = scarlett2_update_bluetooth_volume(mixer);
8651 err = scarlett2_update_spdif_mode(mixer);
8655 err = scarlett2_update_mix(mixer);
8659 return scarlett2_usb_get_mux(mixer);
8663 struct usb_mixer_interface *mixer)
8668 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)
8670 if (!entry->usb_id)
8677 struct usb_mixer_interface *mixer,
8684 err = scarlett2_init_private(mixer, entry);
8688 private = mixer->private_data;
8691 err = scarlett2_usb_init(mixer);
8696 err = scarlett2_get_flash_segment_nums(mixer);
8701 err = scarlett2_add_firmware_version_ctl(mixer);
8706 err = scarlett2_add_min_firmware_version_ctl(mixer);
8711 err = scarlett2_read_configs(mixer);
8716 err = scarlett2_add_msd_ctl(mixer);
8720 /* If MSD mode is enabled, or if the firmware version is too
8723 if (private->msd_switch ||
8724 private->firmware_version < private->info->min_firmware_version)
8728 err = scarlett2_add_line_out_ctls(mixer);
8733 err = scarlett2_add_line_in_ctls(mixer);
8737 /* Create the input, output, and mixer mux input selections */
8738 err = scarlett2_add_mux_enums(mixer);
8742 /* Create the matrix mixer controls */
8743 err = scarlett2_add_mixer_ctls(mixer);
8748 err = scarlett2_add_meter_ctl(mixer);
8753 err = scarlett2_add_sync_ctl(mixer);
8758 err = scarlett2_add_direct_monitor_ctls(mixer);
8763 err = scarlett2_add_speaker_switch_ctl(mixer);
8768 err = scarlett2_add_talkback_ctls(mixer);
8773 err = scarlett2_add_standalone_ctl(mixer);
8778 err = scarlett2_add_power_status_ctl(mixer);
8783 err = scarlett2_add_bluetooth_volume_ctl(mixer);
8787 /* Create the S/PDIF mode control */
8788 err = scarlett2_add_spdif_mode_ctl(mixer);
8792 /* Set the access mode of controls disabled during
8795 if (private->info->gain_input_count) {
8796 scarlett2_autogain_update_access(mixer);
8797 scarlett2_phantom_update_access(mixer);
8801 private->running = 2;
8808 /* Set private->hwdep_in_use; prevents access to the ALSA controls
8813 guard(mutex)(&private->data_mutex);
8814 private->hwdep_in_use = 1;
8818 static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)
8820 struct scarlett2_data *private = mixer->private_data;
8829 segment_id = private->selected_flash_segment_id;
8830 segment_num = private->flash_segment_nums[segment_id];
8834 return -EFAULT;
8840 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
8853 static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer)
8858 err = scarlett2_get_erase_progress(mixer);
8868 return -ETIMEDOUT;
8874 static int scarlett2_reboot(struct usb_mixer_interface *mixer)
8876 struct scarlett2_data *private = mixer->private_data;
8878 if (private->flash_write_state ==
8880 int err = scarlett2_wait_for_erase(mixer);
8886 return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0);
8891 struct usb_mixer_interface *mixer,
8894 struct scarlett2_data *private = mixer->private_data;
8898 return -EFAULT;
8902 return -EINVAL;
8904 segment_num = private->flash_segment_nums[segment_id];
8907 usb_audio_err(mixer->chip,
8910 return -EFAULT;
8914 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) {
8915 int err = scarlett2_wait_for_erase(mixer);
8922 private->selected_flash_segment_id = segment_id;
8923 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED;
8928 /* Erase the previously-selected flash segment */
8930 struct usb_mixer_interface *mixer)
8932 struct scarlett2_data *private = mixer->private_data;
8940 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
8941 return -EINVAL;
8943 segment_id = private->selected_flash_segment_id;
8944 segment_num = private->flash_segment_nums[segment_id];
8948 return -EFAULT;
8959 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,
8966 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING;
8973 struct usb_mixer_interface *mixer,
8976 struct scarlett2_data *private = mixer->private_data;
8987 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
8988 return -EINVAL;
8990 segment_id = private->selected_flash_segment_id;
8991 segment_num = private->flash_segment_nums[segment_id];
8995 return -EFAULT;
9001 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9008 progress.num_blocks = private->flash_segment_blocks[segment_id];
9011 return -EFAULT;
9017 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9024 struct usb_mixer_interface *mixer = hw->private_data;
9025 struct scarlett2_data *private = mixer->private_data;
9028 if (private->flash_write_state ==
9030 int err = scarlett2_wait_for_erase(mixer);
9037 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9045 struct usb_mixer_interface *mixer = hw->private_data;
9051 (int __user *)arg) ? -EFAULT : 0;
9054 return scarlett2_reboot(mixer);
9057 return scarlett2_ioctl_select_flash_segment(mixer, arg);
9060 return scarlett2_ioctl_erase_flash_segment(mixer);
9063 return scarlett2_ioctl_get_erase_progress(mixer, arg);
9066 return -ENOIOCTLCMD;
9074 struct usb_mixer_interface *mixer = hw->private_data;
9075 struct scarlett2_data *private = mixer->private_data;
9089 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED)
9090 return -EINVAL;
9093 segment_id = private->selected_flash_segment_id;
9095 return -EINVAL;
9097 segment_num = private->flash_segment_nums[segment_id];
9100 return -EFAULT;
9104 return -EINVAL;
9107 flash_size = private->flash_segment_blocks[segment_id] *
9118 count = flash_size - *offset;
9127 return -ENOMEM;
9129 err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT,
9136 return -EFAULT;
9146 struct usb_mixer_interface *mixer = hw->private_data;
9147 struct scarlett2_data *private = mixer->private_data;
9160 const size_t max_data_size = SCARLETT2_FLASH_RW_MAX -
9164 if (private->flash_write_state ==
9166 err = scarlett2_wait_for_erase(mixer);
9169 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE;
9172 } else if (private->flash_write_state !=
9174 return -EINVAL;
9178 segment_id = private->selected_flash_segment_id;
9180 return -EINVAL;
9182 segment_num = private->flash_segment_nums[segment_id];
9185 return -EFAULT;
9188 flash_size = private->flash_segment_blocks[segment_id] *
9192 return -ENOSPC;
9205 return -ENOMEM;
9207 req->segment_num = cpu_to_le32(segment_num);
9208 req->offset = cpu_to_le32(*offset);
9209 req->pad = 0;
9211 if (copy_from_user(req->data, buf, count))
9212 return -EFAULT;
9214 err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT,
9225 struct usb_mixer_interface *mixer = hw->private_data;
9226 struct scarlett2_data *private = mixer->private_data;
9229 * The ERASING state is left as-is, and checked on next open.
9232 private->hwdep_in_use &&
9233 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING)
9234 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE;
9239 static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer)
9244 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);
9248 hw->private_data = mixer;
9249 hw->exclusive = 1;
9250 hw->ops.open = scarlett2_hwdep_open;
9251 hw->ops.ioctl = scarlett2_hwdep_ioctl;
9252 hw->ops.read = scarlett2_hwdep_read;
9253 hw->ops.write = scarlett2_hwdep_write;
9254 hw->ops.release = scarlett2_hwdep_release;
9259 /*** device-map file ***/
9269 struct usb_mixer_interface *mixer = entry->private_data;
9274 if (pos >= entry->size)
9277 if (pos + count > entry->size)
9278 count = entry->size - pos;
9282 return -ENOMEM;
9297 size_t block_start = pos - offset;
9300 entry->size - block_start);
9303 size_t copy_size = min_t(size_t, count, read_size - offset);
9307 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_DEVMAP,
9313 return -EFAULT;
9318 count -= copy_size;
9328 static int scarlett2_devmap_init(struct usb_mixer_interface *mixer)
9330 struct snd_card *card = mixer->chip->card;
9331 struct scarlett2_data *private = mixer->private_data;
9332 const struct scarlett2_device_info *info = private->info;
9341 if (!info->has_devmap)
9344 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_DEVMAP,
9355 entry->content = SNDRV_INFO_CONTENT_DATA;
9356 entry->private_data = mixer;
9357 entry->c.ops = &scarlett2_devmap_ops;
9358 entry->size = config_len;
9359 entry->mode = S_IFREG | 0444;
9364 int snd_scarlett2_init(struct usb_mixer_interface *mixer)
9366 struct snd_usb_audio *chip = mixer->chip;
9371 if (!mixer->protocol)
9375 if (chip->setup & SCARLETT2_USE_FCP_DRIVER)
9376 return snd_fcp_init(mixer);
9379 entry = get_scarlett2_device_entry(mixer);
9381 usb_audio_err(mixer->chip,
9384 USB_ID_VENDOR(chip->usb_id),
9385 USB_ID_PRODUCT(chip->usb_id));
9389 if (chip->setup & SCARLETT2_DISABLE) {
9391 "Focusrite %s Mixer Driver disabled "
9394 entry->series_name,
9395 USB_ID_VENDOR(chip->usb_id),
9396 USB_ID_PRODUCT(chip->usb_id),
9402 "Focusrite %s Mixer Driver enabled (pid=0x%04x); "
9404 "https://github.com/geoffreybennett/scarlett-gen2/issues",
9405 entry->series_name,
9406 USB_ID_PRODUCT(chip->usb_id));
9408 err = snd_scarlett2_controls_create(mixer, entry);
9410 usb_audio_err(mixer->chip,
9411 "Error initialising %s Mixer Driver: %d",
9412 entry->series_name,
9417 err = scarlett2_hwdep_init(mixer);
9419 usb_audio_err(mixer->chip,
9421 entry->series_name,
9426 err = scarlett2_devmap_init(mixer);
9428 usb_audio_err(mixer->chip,
9430 entry->series_name,