Lines Matching full:mixer
51 * Support for loading mixer volume and mux configuration from the
82 * This ALSA mixer gives access to (model-dependent):
83 * - input, output, mixer-matrix muxes
84 * - mixer-matrix gain stages
113 * | | Mixer | | |
169 #include "mixer.h"
178 /* device_setup value to disable this mixer driver */
195 /* mixer range from -80dB to +12dB in 0.5dB steps */
203 /* map from (dB + 80) * 2 to mixer value
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
321 * - Mixer I/O
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) */
1022 * - dst_descr: printf format string for mixer controls
1060 .dst_descr = "Mixer Input %02d Capture",
1221 struct usb_mixer_interface *mixer;
2375 struct usb_mixer_interface *mixer, u32 cmd,
2378 struct scarlett2_data *private = mixer->private_data;
2379 struct usb_device *dev = mixer->chip->dev;
2415 mixer->chip,
2424 mixer->chip,
2449 mixer->chip,
2465 mixer->chip,
2486 struct usb_mixer_interface *mixer,
2496 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
2511 struct usb_mixer_interface *mixer,
2514 struct scarlett2_data *private = mixer->private_data;
2533 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
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;
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;
2674 mixer, config_set->param_buf_addr + 1, 1, index);
2680 mixer, config_set->param_buf_addr, 1, value);
2686 mixer, config_item->activate);
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);
2751 struct usb_mixer_interface *mixer,
2754 struct scarlett2_data *private = mixer->private_data;
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 */
2830 /* Map from mixer value to (db + 80) * 2
2846 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
2849 struct scarlett2_data *private = mixer->private_data;
2864 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
2880 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
2883 struct scarlett2_data *private = mixer->private_data;
2900 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
2960 usb_audio_err(private->mixer->chip,
2972 usb_audio_err(private->mixer->chip,
3052 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
3054 struct scarlett2_data *private = mixer->private_data;
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;
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,
3204 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
3208 elem->head.mixer = mixer;
3240 struct scarlett2_data *private = elem->head.mixer->private_data;
3266 struct usb_mixer_interface *mixer)
3268 return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl,
3279 struct scarlett2_data *private = elem->head.mixer->private_data;
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;
3321 return scarlett2_usb_get_sync_status(mixer, &private->sync);
3337 struct usb_mixer_interface *mixer = elem->head.mixer;
3338 struct scarlett2_data *private = mixer->private_data;
3347 err = scarlett2_update_sync(mixer);
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,
3405 static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)
3407 struct scarlett2_data *private = mixer->private_data;
3419 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
3424 mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS,
3455 mixer, scarlett2_ag_target_configs[i],
3469 static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)
3471 struct scarlett2_data *private = mixer->private_data;
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;
3558 struct usb_mixer_interface *mixer)
3560 struct scarlett2_data *private = mixer->private_data;
3566 err = scarlett2_update_autogain(mixer);
3570 scarlett2_autogain_update_access(mixer);
3581 struct usb_mixer_interface *mixer)
3583 int err = scarlett2_check_autogain_updated(mixer);
3588 if (scarlett2_autogain_is_running(mixer->private_data))
3598 struct usb_mixer_interface *mixer = elem->head.mixer;
3599 struct scarlett2_data *private = mixer->private_data;
3604 err = scarlett2_check_input_phantom_updated(mixer);
3615 struct usb_mixer_interface *mixer = elem->head.mixer;
3616 struct scarlett2_data *private = mixer->private_data;
3624 err = scarlett2_check_autogain_updated(mixer);
3637 struct usb_mixer_interface *mixer = elem->head.mixer;
3638 struct scarlett2_data *private = mixer->private_data;
3646 err = scarlett2_check_autogain_updated(mixer);
3659 struct usb_mixer_interface *mixer = elem->head.mixer;
3660 struct scarlett2_data *private = mixer->private_data;
3669 err = scarlett2_check_input_phantom_updated(mixer);
3686 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val);
3688 scarlett2_autogain_update_access(mixer);
3689 scarlett2_autogain_notify_access(mixer);
3698 struct scarlett2_data *private = elem->head.mixer->private_data;
3728 struct usb_mixer_interface *mixer = elem->head.mixer;
3729 struct scarlett2_data *private = mixer->private_data;
3737 err = scarlett2_check_autogain_updated(mixer);
3754 struct usb_mixer_interface *mixer = elem->head.mixer;
3755 struct scarlett2_data *private = mixer->private_data;
3764 err = scarlett2_update_autogain(mixer);
3777 struct usb_mixer_interface *mixer = elem->head.mixer;
3778 struct scarlett2_data *private = mixer->private_data;
3787 err = scarlett2_check_put_during_autogain(mixer);
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;
3839 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3845 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH,
3857 struct usb_mixer_interface *mixer = elem->head.mixer;
3858 struct scarlett2_data *private = mixer->private_data;
3867 err = scarlett2_update_input_select(mixer);
3879 struct usb_mixer_interface *mixer = elem->head.mixer;
3880 struct scarlett2_data *private = mixer->private_data;
3889 err = scarlett2_check_put_during_autogain(mixer);
3908 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3918 struct usb_mixer_interface *mixer = elem->head.mixer;
3919 struct scarlett2_data *private = mixer->private_data;
3933 err = scarlett2_check_autogain_updated(mixer);
3973 struct usb_mixer_interface *mixer = elem->head.mixer;
3974 struct scarlett2_data *private = mixer->private_data;
3982 err = scarlett2_check_autogain_updated(mixer);
3993 struct usb_mixer_interface *mixer = elem->head.mixer;
3994 struct scarlett2_data *private = mixer->private_data;
4003 err = scarlett2_update_input_select(mixer);
4016 struct usb_mixer_interface *mixer = elem->head.mixer;
4017 struct scarlett2_data *private = mixer->private_data;
4026 err = scarlett2_check_put_during_autogain(mixer);
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;
4065 mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4073 struct usb_mixer_interface *mixer = elem->head.mixer;
4074 struct scarlett2_data *private = mixer->private_data;
4082 err = scarlett2_check_autogain_updated(mixer);
4099 struct usb_mixer_interface *mixer = elem->head.mixer;
4100 struct scarlett2_data *private = mixer->private_data;
4109 err = scarlett2_update_input_gain(mixer);
4122 struct usb_mixer_interface *mixer = elem->head.mixer;
4123 struct scarlett2_data *private = mixer->private_data;
4132 err = scarlett2_check_put_during_autogain(mixer);
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;
4175 mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4183 struct usb_mixer_interface *mixer = elem->head.mixer;
4184 struct scarlett2_data *private = mixer->private_data;
4193 err = scarlett2_update_input_safe(mixer);
4206 struct usb_mixer_interface *mixer = elem->head.mixer;
4207 struct scarlett2_data *private = mixer->private_data;
4216 err = scarlett2_check_put_during_autogain(mixer);
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;
4253 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4265 struct usb_mixer_interface *mixer = elem->head.mixer;
4266 struct scarlett2_data *private = elem->head.mixer->private_data;
4272 err = scarlett2_update_pcm_input_switch(mixer);
4284 struct usb_mixer_interface *mixer = elem->head.mixer;
4285 struct scarlett2_data *private = mixer->private_data;
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;
4344 mixer, SCARLETT2_CONFIG_MASTER_VOLUME,
4362 mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME,
4391 struct usb_mixer_interface *mixer = elem->head.mixer;
4392 struct scarlett2_data *private = mixer->private_data;
4401 err = scarlett2_update_volumes(mixer);
4414 struct usb_mixer_interface *mixer = elem->head.mixer;
4415 struct scarlett2_data *private = mixer->private_data;
4424 err = scarlett2_update_volumes(mixer);
4449 struct usb_mixer_interface *mixer = elem->head.mixer;
4450 struct scarlett2_data *private = mixer->private_data;
4460 err = scarlett2_update_volumes(mixer);
4472 struct usb_mixer_interface *mixer = elem->head.mixer;
4473 struct scarlett2_data *private = mixer->private_data;
4489 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4535 static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)
4537 struct scarlett2_data *private = mixer->private_data;
4547 mixer, SCARLETT2_CONFIG_DIM_MUTE,
4568 struct usb_mixer_interface *mixer = elem->head.mixer;
4569 struct scarlett2_data *private = mixer->private_data;
4579 err = scarlett2_update_dim_mute(mixer);
4591 struct usb_mixer_interface *mixer = elem->head.mixer;
4592 struct scarlett2_data *private = mixer->private_data;
4610 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4652 struct scarlett2_data *private = elem->head.mixer->private_data;
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;
4687 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
4690 struct scarlett2_data *private = mixer->private_data;
4699 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
4707 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4714 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4720 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
4728 struct usb_mixer_interface *mixer = elem->head.mixer;
4729 struct scarlett2_data *private = mixer->private_data;
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;
4771 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
4783 struct usb_mixer_interface *mixer = elem->head.mixer;
4784 struct scarlett2_data *private = mixer->private_data;
4792 err = scarlett2_check_autogain_updated(mixer);
4803 struct usb_mixer_interface *mixer = elem->head.mixer;
4804 struct scarlett2_data *private = mixer->private_data;
4815 err = scarlett2_update_input_level(mixer);
4828 struct usb_mixer_interface *mixer = elem->head.mixer;
4829 struct scarlett2_data *private = mixer->private_data;
4839 err = scarlett2_check_put_during_autogain(mixer);
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;
4883 mixer, SCARLETT2_CONFIG_PAD_SWITCH,
4891 struct usb_mixer_interface *mixer = elem->head.mixer;
4892 struct scarlett2_data *private = mixer->private_data;
4901 err = scarlett2_update_input_pad(mixer);
4914 struct usb_mixer_interface *mixer = elem->head.mixer;
4915 struct scarlett2_data *private = mixer->private_data;
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;
4960 mixer, SCARLETT2_CONFIG_AIR_SWITCH,
4968 struct usb_mixer_interface *mixer = elem->head.mixer;
4969 struct scarlett2_data *private = mixer->private_data;
4978 err = scarlett2_update_input_air(mixer);
4990 struct usb_mixer_interface *mixer = elem->head.mixer;
4991 struct scarlett2_data *private = mixer->private_data;
5000 err = scarlett2_check_put_during_autogain(mixer);
5013 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5026 struct usb_mixer_interface *mixer = elem->head.mixer;
5027 struct scarlett2_data *private = mixer->private_data;
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;
5072 mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5080 struct usb_mixer_interface *mixer = elem->head.mixer;
5081 struct scarlett2_data *private = mixer->private_data;
5090 err = scarlett2_update_input_dsp(mixer);
5102 struct usb_mixer_interface *mixer = elem->head.mixer;
5103 struct scarlett2_data *private = mixer->private_data;
5112 err = scarlett2_check_put_during_autogain(mixer);
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;
5151 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS,
5178 struct scarlett2_data *private = elem->head.mixer->private_data;
5189 struct usb_mixer_interface *mixer = elem->head.mixer;
5190 struct scarlett2_data *private = mixer->private_data;
5203 err = scarlett2_check_put_during_autogain(mixer);
5223 mixer, private->config_set->param_buf_addr + 1, 1, channel);
5228 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS, index, scaled_val);
5261 struct scarlett2_data *private = elem->head.mixer->private_data;
5272 struct scarlett2_data *private = elem->head.mixer->private_data;
5284 struct usb_mixer_interface *mixer = elem->head.mixer;
5285 struct scarlett2_data *private = mixer->private_data;
5303 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5313 struct usb_mixer_interface *mixer = elem->head.mixer;
5314 struct scarlett2_data *private = mixer->private_data;
5332 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5354 static int scarlett2_update_filter_values(struct usb_mixer_interface *mixer)
5356 struct scarlett2_data *private = mixer->private_data;
5368 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5374 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5382 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5395 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5422 struct scarlett2_data *private = elem->head.mixer->private_data;
5438 struct scarlett2_data *private = elem->head.mixer->private_data;
5454 struct usb_mixer_interface *mixer = elem->head.mixer;
5455 struct scarlett2_data *private = mixer->private_data;
5464 err = scarlett2_check_put_during_autogain(mixer);
5486 mixer, private->config_set->param_buf_addr, 1, index);
5491 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5502 struct usb_mixer_interface *mixer = elem->head.mixer;
5503 struct scarlett2_data *private = mixer->private_data;
5519 err = scarlett2_check_put_during_autogain(mixer);
5541 mixer, private->config_set->param_buf_addr, 1, dst_index);
5546 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5582 static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer)
5584 struct scarlett2_data *private = mixer->private_data;
5593 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5601 struct usb_mixer_interface *mixer = elem->head.mixer;
5602 struct scarlett2_data *private = mixer->private_data;
5611 err = scarlett2_update_input_mute(mixer);
5624 struct usb_mixer_interface *mixer = elem->head.mixer;
5625 struct scarlett2_data *private = mixer->private_data;
5634 err = scarlett2_check_put_during_autogain(mixer);
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;
5676 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5684 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
5704 static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)
5706 struct scarlett2_data *private = mixer->private_data;
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;
5737 struct usb_mixer_interface *mixer)
5739 struct scarlett2_data *private = mixer->private_data;
5745 err = scarlett2_update_input_phantom(mixer);
5749 scarlett2_phantom_update_access(mixer);
5758 struct usb_mixer_interface *mixer = elem->head.mixer;
5759 struct scarlett2_data *private = mixer->private_data;
5767 err = scarlett2_check_input_phantom_updated(mixer);
5780 struct usb_mixer_interface *mixer = elem->head.mixer;
5781 struct scarlett2_data *private = mixer->private_data;
5791 err = scarlett2_check_put_during_autogain(mixer);
5808 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5810 scarlett2_phantom_update_access(mixer);
5811 scarlett2_phantom_notify_access(mixer);
5830 struct scarlett2_data *private = elem->head.mixer->private_data;
5840 struct usb_mixer_interface *mixer = elem->head.mixer;
5841 struct scarlett2_data *private = mixer->private_data;
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;
5900 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
5906 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
5925 err = scarlett2_usb_get_config(mixer,
5951 struct usb_mixer_interface *mixer = elem->head.mixer;
5952 struct scarlett2_data *private = mixer->private_data;
5961 err = scarlett2_update_monitor_other(mixer);
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;
5983 err = scarlett2_sw_hw_change(private->mixer, i, 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;
6030 struct usb_mixer_interface *mixer = elem->head.mixer;
6031 struct scarlett2_data *private = mixer->private_data;
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;
6087 mixer, &scarlett2_speaker_switch_enum_ctl,
6108 struct usb_mixer_interface *mixer = elem->head.mixer;
6109 struct scarlett2_data *private = mixer->private_data;
6118 err = scarlett2_update_monitor_other(mixer);
6130 struct usb_mixer_interface *mixer = elem->head.mixer;
6131 struct scarlett2_data *private = mixer->private_data;
6149 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6156 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6174 struct usb_mixer_interface *mixer = elem->head.mixer;
6175 struct scarlett2_data *private = mixer->private_data;
6187 struct usb_mixer_interface *mixer = elem->head.mixer;
6188 struct scarlett2_data *private = mixer->private_data;
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;
6235 mixer, &scarlett2_talkback_enum_ctl,
6244 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
6259 struct usb_mixer_interface *mixer = elem->head.mixer;
6260 struct scarlett2_data *private = mixer->private_data;
6269 err = scarlett2_update_dim_mute(mixer);
6281 struct usb_mixer_interface *mixer = elem->head.mixer;
6282 struct scarlett2_data *private = mixer->private_data;
6300 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
6308 snd_ctl_notify(mixer->chip->card,
6331 struct scarlett2_data *private = elem->head.mixer->private_data;
6343 struct usb_mixer_interface *mixer = elem->head.mixer;
6344 struct scarlett2_data *private = mixer->private_data;
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;
6393 err = scarlett2_add_new_ctl(mixer,
6404 err = scarlett2_add_new_ctl(mixer,
6416 mixer, &scarlett2_sp_hp_mute_ctl,
6443 err = scarlett2_add_new_ctl(mixer,
6453 err = scarlett2_add_new_ctl(mixer,
6468 scarlett2_vol_ctl_set_writable(mixer, i, 0);
6473 err = scarlett2_add_new_ctl(mixer,
6492 mixer, &scarlett2_dim_mute_ctl,
6504 static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i)
6506 struct scarlett2_data *private = mixer->private_data;
6521 mixer, &scarlett2_compressor_ctl,
6531 mixer, &scarlett2_precomp_flt_switch_ctl,
6538 mixer, &scarlett2_peq_flt_switch_ctl,
6547 mixer, &scarlett2_precomp_flt_ctl,
6557 mixer, &scarlett2_peq_flt_ctl,
6567 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
6569 struct scarlett2_data *private = mixer->private_data;
6580 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
6589 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
6600 mixer, &scarlett2_air_ctl[info->air_option],
6609 err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl,
6614 err = scarlett2_add_dsp_ctls(mixer, i);
6623 mixer, &scarlett2_input_mute_ctl,
6636 mixer, &scarlett2_phantom_ctl,
6649 mixer, &scarlett2_phantom_ctl,
6659 mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
6669 mixer, &scarlett2_input_select_ctl, 0, 1,
6682 mixer, &scarlett2_input_link_ctl,
6694 mixer, &scarlett2_input_gain_ctl,
6704 mixer, &scarlett2_autogain_switch_ctl,
6712 mixer, &scarlett2_autogain_status_ctl,
6724 mixer, &scarlett2_ag_target_ctl,
6735 mixer, &scarlett2_safe_ctl,
6745 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1,
6755 /*** Mixer Volume Controls ***/
6757 static int scarlett2_update_mix(struct usb_mixer_interface *mixer)
6759 struct scarlett2_data *private = mixer->private_data;
6765 err = scarlett2_usb_get_mix(mixer, i);
6790 struct usb_mixer_interface *mixer = elem->head.mixer;
6791 struct scarlett2_data *private = mixer->private_data;
6800 err = scarlett2_update_mix(mixer);
6812 struct usb_mixer_interface *mixer = elem->head.mixer;
6813 struct scarlett2_data *private = mixer->private_data;
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;
6866 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
6878 static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)
6880 struct scarlett2_data *private = mixer->private_data;
6888 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
6892 static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)
6894 struct scarlett2_data *private = mixer->private_data;
6902 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
6918 struct usb_mixer_interface *mixer = elem->head.mixer;
6919 struct scarlett2_data *private = mixer->private_data;
6928 err = scarlett2_update_direct_monitor(mixer);
6940 struct usb_mixer_interface *mixer = elem->head.mixer;
6941 struct scarlett2_data *private = mixer->private_data;
6960 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
6999 struct scarlett2_data *private = elem->head.mixer->private_data;
7010 struct usb_mixer_interface *mixer = elem->head.mixer;
7011 struct scarlett2_data *private = mixer->private_data;
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;
7062 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
7094 mixer, &scarlett2_monitor_mix_ctl,
7110 struct scarlett2_data *private = elem->head.mixer->private_data;
7155 struct usb_mixer_interface *mixer = elem->head.mixer;
7156 struct scarlett2_data *private = mixer->private_data;
7166 err = scarlett2_usb_get_mux(mixer);
7178 struct usb_mixer_interface *mixer = elem->head.mixer;
7179 struct scarlett2_data *private = mixer->private_data;
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;
7238 err = scarlett2_add_new_ctl(mixer,
7269 struct usb_mixer_interface *mixer = elem->head.mixer;
7270 struct scarlett2_data *private = mixer->private_data;
7280 err = scarlett2_usb_get_meter_levels(mixer, elem->channels,
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,
7328 struct scarlett2_data *private = elem->head.mixer->private_data;
7338 struct usb_mixer_interface *mixer = elem->head.mixer;
7339 struct scarlett2_data *private = mixer->private_data;
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;
7378 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
7382 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
7392 struct scarlett2_data *private = elem->head.mixer->private_data;
7402 struct usb_mixer_interface *mixer = elem->head.mixer;
7403 struct scarlett2_data *private = mixer->private_data;
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;
7458 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT,
7463 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW,
7482 struct usb_mixer_interface *mixer = elem->head.mixer;
7483 struct scarlett2_data *private = mixer->private_data;
7489 err = scarlett2_update_power_status(mixer);
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,
7531 static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer)
7533 struct scarlett2_data *private = mixer->private_data;
7541 err = scarlett2_usb_get_config(mixer,
7554 struct usb_mixer_interface *mixer = elem->head.mixer;
7555 struct scarlett2_data *private = mixer->private_data;
7564 err = scarlett2_update_bluetooth_volume(mixer);
7576 struct usb_mixer_interface *mixer = elem->head.mixer;
7577 struct scarlett2_data *private = mixer->private_data;
7593 err = scarlett2_usb_set_config(mixer,
7620 struct usb_mixer_interface *mixer)
7622 struct scarlett2_data *private = mixer->private_data;
7628 return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl,
7635 static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer)
7637 struct scarlett2_data *private = mixer->private_data;
7645 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE,
7665 struct scarlett2_data *private = elem->head.mixer->private_data;
7680 struct scarlett2_data *private = elem->head.mixer->private_data;
7690 struct usb_mixer_interface *mixer = elem->head.mixer;
7691 struct scarlett2_data *private = mixer->private_data;
7713 mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0,
7727 static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer)
7729 struct scarlett2_data *private = mixer->private_data;
7734 return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl,
7743 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)
7745 struct scarlett2_data *private = mixer->private_data;
7749 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
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;
7765 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7775 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)
7777 struct scarlett2_data *private = mixer->private_data;
7781 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
7783 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
8021 scarlett2_notify_dim_mute(mixer);
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;
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;
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;
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;
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;
8114 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer)
8116 struct scarlett2_data *private = mixer->private_data;
8126 struct usb_mixer_interface *mixer = urb->context;
8130 struct scarlett2_data *private = mixer->private_data;
8149 notifications->func(mixer);
8155 usb_audio_warn(mixer->chip,
8163 urb->dev = mixer->chip->dev;
8172 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
8174 struct scarlett2_data *private = mixer->private_data;
8178 mixer->private_data = NULL;
8181 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
8183 struct scarlett2_data *private = mixer->private_data;
8186 scarlett2_config_save(private->mixer);
8209 /* Mixer inputs are mux outputs and vice versa.
8211 * doesn't have mixer controls.
8271 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
8284 mixer->private_data = private;
8285 mixer->private_free = scarlett2_private_free;
8286 mixer->private_suspend = scarlett2_private_suspend;
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;
8306 if (mixer->urb) {
8307 usb_audio_err(mixer->chip,
8308 "%s: mixer urb already in use!\n", __func__);
8315 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
8316 if (!mixer->urb)
8323 usb_fill_int_urb(mixer->urb, dev, pipe,
8325 scarlett2_notify, mixer, private->bInterval);
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;
8357 err = scarlett2_init_notify(mixer);
8371 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
8377 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,
8385 usb_audio_info(mixer->chip,
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,
8432 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,
8436 usb_audio_err(mixer->chip,
8461 usb_audio_err(mixer->chip,
8467 usb_audio_err(mixer->chip,
8477 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
8479 struct scarlett2_data *private = mixer->private_data;
8485 mixer, SCARLETT2_CONFIG_MSD_SWITCH,
8492 usb_audio_err(mixer->chip,
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,
8564 err = scarlett2_update_power_status(mixer);
8569 err = scarlett2_update_sync(mixer);
8579 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
8591 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
8604 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
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)
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);
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);
8788 err = scarlett2_add_spdif_mode_ctl(mixer);
8796 scarlett2_autogain_update_access(mixer);
8797 scarlett2_phantom_update_access(mixer);
8818 static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)
8820 struct scarlett2_data *private = mixer->private_data;
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);
8874 static int scarlett2_reboot(struct usb_mixer_interface *mixer)
8876 struct scarlett2_data *private = mixer->private_data;
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;
8907 usb_audio_err(mixer->chip,
8915 int err = scarlett2_wait_for_erase(mixer);
8930 struct usb_mixer_interface *mixer)
8932 struct scarlett2_data *private = mixer->private_data;
8959 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,
8973 struct usb_mixer_interface *mixer,
8976 struct scarlett2_data *private = mixer->private_data;
9001 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9024 struct usb_mixer_interface *mixer = hw->private_data;
9025 struct scarlett2_data *private = mixer->private_data;
9030 int err = scarlett2_wait_for_erase(mixer);
9045 struct usb_mixer_interface *mixer = hw->private_data;
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);
9074 struct usb_mixer_interface *mixer = hw->private_data;
9075 struct scarlett2_data *private = mixer->private_data;
9129 err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT,
9146 struct usb_mixer_interface *mixer = hw->private_data;
9147 struct scarlett2_data *private = mixer->private_data;
9166 err = scarlett2_wait_for_erase(mixer);
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;
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;
9269 struct usb_mixer_interface *mixer = entry->private_data;
9307 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_DEVMAP,
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;
9344 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_DEVMAP,
9356 entry->private_data = mixer;
9364 int snd_scarlett2_init(struct usb_mixer_interface *mixer)
9366 struct snd_usb_audio *chip = mixer->chip;
9371 if (!mixer->protocol)
9376 return snd_fcp_init(mixer);
9379 entry = get_scarlett2_device_entry(mixer);
9381 usb_audio_err(mixer->chip,
9391 "Focusrite %s Mixer Driver disabled "
9402 "Focusrite %s Mixer Driver enabled (pid=0x%04x); "
9408 err = snd_scarlett2_controls_create(mixer, entry);
9410 usb_audio_err(mixer->chip,
9411 "Error initialising %s Mixer Driver: %d",
9417 err = scarlett2_hwdep_init(mixer);
9419 usb_audio_err(mixer->chip,
9426 err = scarlett2_devmap_init(mixer);
9428 usb_audio_err(mixer->chip,