Lines Matching refs:mixer
50 * Support for loading mixer volume and mux configuration from the
78 * This ALSA mixer gives access to (model-dependent):
79 * - input, output, mixer-matrix muxes
80 * - mixer-matrix gain stages
165 #include "mixer.h"
173 /* device_setup value to disable this mixer driver */
187 /* mixer range from -80dB to +12dB in 0.5dB steps */
195 /* map from (dB + 80) * 2 to mixer value
228 /* Maximum number of inputs to the mixer */
231 /* Maximum number of outputs from the mixer */
234 /* Maximum number of mixer gain controls */
237 /* Maximum number of direct monitor mixer gain controls
405 void (*func)(struct usb_mixer_interface *mixer);
408 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer);
409 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer);
410 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer);
411 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer);
412 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer);
413 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer);
414 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer);
415 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer);
416 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer);
417 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer);
418 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer);
419 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer);
420 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer);
421 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer);
422 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer);
423 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer);
424 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer);
425 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer);
426 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer);
428 struct usb_mixer_interface *mixer);
429 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer);
654 /* Gen 3 devices without a mixer (Solo and 2i2) */
995 * - dst_descr: printf format string for mixer controls
1188 struct usb_mixer_interface *mixer;
2324 struct usb_mixer_interface *mixer, u32 cmd,
2327 struct scarlett2_data *private = mixer->private_data;
2328 struct usb_device *dev = mixer->chip->dev;
2360 mixer->chip,
2370 mixer->chip,
2398 mixer->chip,
2415 mixer->chip,
2442 struct usb_mixer_interface *mixer,
2452 return scarlett2_usb(mixer, SCARLETT2_USB_GET_DATA,
2467 struct usb_mixer_interface *mixer,
2470 struct scarlett2_data *private = mixer->private_data;
2489 err = scarlett2_usb_get(mixer, config_item->offset, buf, size);
2507 err = scarlett2_usb_get(mixer, config_item->offset, &value, 1);
2524 struct usb_mixer_interface *mixer,
2527 struct scarlett2_data *private = mixer->private_data;
2537 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2547 struct usb_mixer_interface *mixer,
2550 struct scarlett2_data *private = mixer->private_data;
2582 err = scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA,
2596 struct usb_mixer_interface *mixer, int activate)
2601 return scarlett2_usb(mixer, SCARLETT2_USB_DATA_CMD,
2607 struct usb_mixer_interface *mixer,
2610 struct scarlett2_data *private = mixer->private_data;
2630 mixer, config_set->param_buf_addr + 1, 1, index);
2636 mixer, config_set->param_buf_addr, 1, value);
2642 mixer, config_item->activate);
2668 err = scarlett2_usb_get(mixer, offset, &tmp, 1);
2681 err = scarlett2_usb_set_data(mixer, offset, size, value);
2686 err = scarlett2_usb_activate_config(mixer, config_item->activate);
2707 struct usb_mixer_interface *mixer,
2710 struct scarlett2_data *private = mixer->private_data;
2736 err = scarlett2_usb_set_data_buf(mixer, offset, size, count, buf);
2741 return scarlett2_usb_activate_config(mixer, config_item->activate);
2745 static void scarlett2_config_save(struct usb_mixer_interface *mixer)
2749 err = scarlett2_usb_activate_config(mixer, SCARLETT2_USB_CONFIG_SAVE);
2751 usb_audio_err(mixer->chip, "config save failed: %d\n", err);
2760 scarlett2_config_save(private->mixer);
2765 struct usb_mixer_interface *mixer,
2771 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_SYNC,
2780 /* Return true if the device has a mixer that we can control */
2786 /* Map from mixer value to (db + 80) * 2
2802 static int scarlett2_usb_get_mix(struct usb_mixer_interface *mixer,
2805 struct scarlett2_data *private = mixer->private_data;
2820 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MIX,
2836 static int scarlett2_usb_set_mix(struct usb_mixer_interface *mixer,
2839 struct scarlett2_data *private = mixer->private_data;
2856 return scarlett2_usb(mixer, SCARLETT2_USB_SET_MIX,
2916 usb_audio_err(private->mixer->chip,
2928 usb_audio_err(private->mixer->chip,
3008 static int scarlett2_usb_get_mux(struct usb_mixer_interface *mixer)
3010 struct scarlett2_data *private = mixer->private_data;
3026 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_MUX,
3041 static int scarlett2_usb_set_mux(struct usb_mixer_interface *mixer)
3043 struct scarlett2_data *private = mixer->private_data;
3096 err = scarlett2_usb(mixer, SCARLETT2_USB_SET_MUX,
3109 static int scarlett2_usb_get_meter_levels(struct usb_mixer_interface *mixer,
3123 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_METER,
3147 static int scarlett2_add_new_ctl(struct usb_mixer_interface *mixer,
3160 /* We set USB_MIXER_BESPOKEN type, so that the core USB mixer code
3164 elem->head.mixer = mixer;
3196 struct scarlett2_data *private = elem->head.mixer->private_data;
3222 struct usb_mixer_interface *mixer)
3224 return scarlett2_add_new_ctl(mixer, &scarlett2_firmware_version_ctl,
3235 struct scarlett2_data *private = elem->head.mixer->private_data;
3261 struct usb_mixer_interface *mixer)
3263 return scarlett2_add_new_ctl(mixer, &scarlett2_min_firmware_version_ctl,
3272 static int scarlett2_update_sync(struct usb_mixer_interface *mixer)
3274 struct scarlett2_data *private = mixer->private_data;
3277 return scarlett2_usb_get_sync_status(mixer, &private->sync);
3293 struct usb_mixer_interface *mixer = elem->head.mixer;
3294 struct scarlett2_data *private = mixer->private_data;
3305 err = scarlett2_update_sync(mixer);
3324 static int scarlett2_add_sync_ctl(struct usb_mixer_interface *mixer)
3326 struct scarlett2_data *private = mixer->private_data;
3328 /* devices without a mixer also don't support reporting sync status */
3332 return scarlett2_add_new_ctl(mixer, &scarlett2_sync_ctl,
3366 static int scarlett2_update_autogain(struct usb_mixer_interface *mixer)
3368 struct scarlett2_data *private = mixer->private_data;
3380 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH,
3385 mixer, SCARLETT2_CONFIG_AUTOGAIN_STATUS,
3416 mixer, scarlett2_ag_target_configs[i],
3430 static void scarlett2_autogain_update_access(struct usb_mixer_interface *mixer)
3432 struct scarlett2_data *private = mixer->private_data;
3470 static void scarlett2_autogain_notify_access(struct usb_mixer_interface *mixer)
3472 struct snd_card *card = mixer->chip->card;
3473 struct scarlett2_data *private = mixer->private_data;
3519 struct usb_mixer_interface *mixer)
3521 struct scarlett2_data *private = mixer->private_data;
3527 err = scarlett2_update_autogain(mixer);
3531 scarlett2_autogain_update_access(mixer);
3542 struct usb_mixer_interface *mixer)
3544 int err = scarlett2_check_autogain_updated(mixer);
3549 if (scarlett2_autogain_is_running(mixer->private_data))
3559 struct usb_mixer_interface *mixer = elem->head.mixer;
3560 struct scarlett2_data *private = mixer->private_data;
3565 err = scarlett2_check_input_phantom_updated(mixer);
3580 struct usb_mixer_interface *mixer = elem->head.mixer;
3581 struct scarlett2_data *private = mixer->private_data;
3591 err = scarlett2_check_autogain_updated(mixer);
3607 struct usb_mixer_interface *mixer = elem->head.mixer;
3608 struct scarlett2_data *private = mixer->private_data;
3618 err = scarlett2_check_autogain_updated(mixer);
3634 struct usb_mixer_interface *mixer = elem->head.mixer;
3635 struct scarlett2_data *private = mixer->private_data;
3647 err = scarlett2_check_input_phantom_updated(mixer);
3666 mixer, SCARLETT2_CONFIG_AUTOGAIN_SWITCH, index, val);
3670 scarlett2_autogain_update_access(mixer);
3671 scarlett2_autogain_notify_access(mixer);
3682 struct scarlett2_data *private = elem->head.mixer->private_data;
3712 struct usb_mixer_interface *mixer = elem->head.mixer;
3713 struct scarlett2_data *private = mixer->private_data;
3723 err = scarlett2_check_autogain_updated(mixer);
3742 struct usb_mixer_interface *mixer = elem->head.mixer;
3743 struct scarlett2_data *private = mixer->private_data;
3754 err = scarlett2_update_autogain(mixer);
3770 struct usb_mixer_interface *mixer = elem->head.mixer;
3771 struct scarlett2_data *private = mixer->private_data;
3783 err = scarlett2_check_put_during_autogain(mixer);
3798 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,
3861 struct usb_mixer_interface *mixer = elem->head.mixer;
3862 struct scarlett2_data *private = mixer->private_data;
3873 err = scarlett2_update_input_select(mixer);
3888 struct usb_mixer_interface *mixer = elem->head.mixer;
3889 struct scarlett2_data *private = mixer->private_data;
3901 err = scarlett2_check_put_during_autogain(mixer);
3921 mixer, SCARLETT2_CONFIG_INPUT_SELECT_SWITCH,
3935 struct usb_mixer_interface *mixer = elem->head.mixer;
3936 struct scarlett2_data *private = mixer->private_data;
3953 err = scarlett2_check_autogain_updated(mixer);
4001 struct usb_mixer_interface *mixer = elem->head.mixer;
4002 struct scarlett2_data *private = mixer->private_data;
4012 err = scarlett2_check_autogain_updated(mixer);
4027 struct usb_mixer_interface *mixer = elem->head.mixer;
4028 struct scarlett2_data *private = mixer->private_data;
4039 err = scarlett2_update_input_select(mixer);
4055 struct usb_mixer_interface *mixer = elem->head.mixer;
4056 struct scarlett2_data *private = mixer->private_data;
4068 err = scarlett2_check_put_during_autogain(mixer);
4081 snd_ctl_notify(mixer->chip->card,
4091 mixer, SCARLETT2_CONFIG_INPUT_LINK_SWITCH, index + 1, val);
4110 static int scarlett2_update_input_gain(struct usb_mixer_interface *mixer)
4112 struct scarlett2_data *private = mixer->private_data;
4121 mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4129 struct usb_mixer_interface *mixer = elem->head.mixer;
4130 struct scarlett2_data *private = mixer->private_data;
4140 err = scarlett2_check_autogain_updated(mixer);
4159 struct usb_mixer_interface *mixer = elem->head.mixer;
4160 struct scarlett2_data *private = mixer->private_data;
4171 err = scarlett2_update_input_gain(mixer);
4187 struct usb_mixer_interface *mixer = elem->head.mixer;
4188 struct scarlett2_data *private = mixer->private_data;
4200 err = scarlett2_check_put_during_autogain(mixer);
4213 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_INPUT_GAIN,
4236 static int scarlett2_update_input_safe(struct usb_mixer_interface *mixer)
4238 struct scarlett2_data *private = mixer->private_data;
4247 mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4255 struct usb_mixer_interface *mixer = elem->head.mixer;
4256 struct scarlett2_data *private = mixer->private_data;
4267 err = scarlett2_update_input_safe(mixer);
4283 struct usb_mixer_interface *mixer = elem->head.mixer;
4284 struct scarlett2_data *private = mixer->private_data;
4296 err = scarlett2_check_put_during_autogain(mixer);
4309 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SAFE_SWITCH,
4329 static int scarlett2_update_pcm_input_switch(struct usb_mixer_interface *mixer)
4331 struct scarlett2_data *private = mixer->private_data;
4337 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4349 struct usb_mixer_interface *mixer = elem->head.mixer;
4350 struct scarlett2_data *private = elem->head.mixer->private_data;
4356 err = scarlett2_update_pcm_input_switch(mixer);
4371 struct usb_mixer_interface *mixer = elem->head.mixer;
4372 struct scarlett2_data *private = mixer->private_data;
4393 mixer, SCARLETT2_CONFIG_PCM_INPUT_SWITCH,
4427 static int scarlett2_update_volumes(struct usb_mixer_interface *mixer)
4429 struct scarlett2_data *private = mixer->private_data;
4438 mixer, SCARLETT2_CONFIG_MASTER_VOLUME,
4456 mixer, SCARLETT2_CONFIG_HEADPHONE_VOLUME,
4485 struct usb_mixer_interface *mixer = elem->head.mixer;
4486 struct scarlett2_data *private = mixer->private_data;
4497 err = scarlett2_update_volumes(mixer);
4513 struct usb_mixer_interface *mixer = elem->head.mixer;
4514 struct scarlett2_data *private = mixer->private_data;
4525 err = scarlett2_update_volumes(mixer);
4553 struct usb_mixer_interface *mixer = elem->head.mixer;
4554 struct scarlett2_data *private = mixer->private_data;
4566 err = scarlett2_update_volumes(mixer);
4581 struct usb_mixer_interface *mixer = elem->head.mixer;
4582 struct scarlett2_data *private = mixer->private_data;
4600 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4650 static int scarlett2_update_dim_mute(struct usb_mixer_interface *mixer)
4652 struct scarlett2_data *private = mixer->private_data;
4662 mixer, SCARLETT2_CONFIG_DIM_MUTE,
4683 struct usb_mixer_interface *mixer = elem->head.mixer;
4684 struct scarlett2_data *private = mixer->private_data;
4696 err = scarlett2_update_dim_mute(mixer);
4711 struct usb_mixer_interface *mixer = elem->head.mixer;
4712 struct scarlett2_data *private = mixer->private_data;
4732 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4778 struct scarlett2_data *private = elem->head.mixer->private_data;
4785 static void scarlett2_vol_ctl_set_writable(struct usb_mixer_interface *mixer,
4788 struct scarlett2_data *private = mixer->private_data;
4789 struct snd_card *card = mixer->chip->card;
4813 static int scarlett2_sw_hw_change(struct usb_mixer_interface *mixer,
4816 struct scarlett2_data *private = mixer->private_data;
4825 scarlett2_vol_ctl_set_writable(mixer, ctl_index, !val);
4833 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
4840 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
4846 return scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
4854 struct usb_mixer_interface *mixer = elem->head.mixer;
4855 struct scarlett2_data *private = mixer->private_data;
4873 err = scarlett2_sw_hw_change(mixer, ctl_index, val);
4892 static int scarlett2_update_input_level(struct usb_mixer_interface *mixer)
4894 struct scarlett2_data *private = mixer->private_data;
4903 mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
4915 struct usb_mixer_interface *mixer = elem->head.mixer;
4916 struct scarlett2_data *private = mixer->private_data;
4926 err = scarlett2_check_autogain_updated(mixer);
4941 struct usb_mixer_interface *mixer = elem->head.mixer;
4942 struct scarlett2_data *private = mixer->private_data;
4956 err = scarlett2_update_input_level(mixer);
4972 struct usb_mixer_interface *mixer = elem->head.mixer;
4973 struct scarlett2_data *private = mixer->private_data;
4986 err = scarlett2_check_put_during_autogain(mixer);
5003 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_LEVEL_SWITCH,
5023 static int scarlett2_update_input_pad(struct usb_mixer_interface *mixer)
5025 struct scarlett2_data *private = mixer->private_data;
5034 mixer, SCARLETT2_CONFIG_PAD_SWITCH,
5042 struct usb_mixer_interface *mixer = elem->head.mixer;
5043 struct scarlett2_data *private = mixer->private_data;
5054 err = scarlett2_update_input_pad(mixer);
5070 struct usb_mixer_interface *mixer = elem->head.mixer;
5071 struct scarlett2_data *private = mixer->private_data;
5092 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PAD_SWITCH,
5112 static int scarlett2_update_input_air(struct usb_mixer_interface *mixer)
5114 struct scarlett2_data *private = mixer->private_data;
5123 mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5131 struct usb_mixer_interface *mixer = elem->head.mixer;
5132 struct scarlett2_data *private = mixer->private_data;
5143 err = scarlett2_update_input_air(mixer);
5158 struct usb_mixer_interface *mixer = elem->head.mixer;
5159 struct scarlett2_data *private = mixer->private_data;
5171 err = scarlett2_check_put_during_autogain(mixer);
5184 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_AIR_SWITCH,
5201 struct usb_mixer_interface *mixer = elem->head.mixer;
5202 struct scarlett2_data *private = mixer->private_data;
5212 err = scarlett2_check_autogain_updated(mixer);
5242 static int scarlett2_update_input_dsp(struct usb_mixer_interface *mixer)
5244 struct scarlett2_data *private = mixer->private_data;
5253 mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5261 struct usb_mixer_interface *mixer = elem->head.mixer;
5262 struct scarlett2_data *private = mixer->private_data;
5273 err = scarlett2_update_input_dsp(mixer);
5288 struct usb_mixer_interface *mixer = elem->head.mixer;
5289 struct scarlett2_data *private = mixer->private_data;
5301 err = scarlett2_check_put_during_autogain(mixer);
5314 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DSP_SWITCH,
5334 static int scarlett2_update_compressor_values(struct usb_mixer_interface *mixer)
5336 struct scarlett2_data *private = mixer->private_data;
5344 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS,
5371 struct scarlett2_data *private = elem->head.mixer->private_data;
5382 struct usb_mixer_interface *mixer = elem->head.mixer;
5383 struct scarlett2_data *private = mixer->private_data;
5398 err = scarlett2_check_put_during_autogain(mixer);
5420 mixer, private->config_set->param_buf_addr + 1, 1, channel);
5425 mixer, SCARLETT2_CONFIG_COMPRESSOR_PARAMS, index, scaled_val);
5465 struct scarlett2_data *private = elem->head.mixer->private_data;
5476 struct scarlett2_data *private = elem->head.mixer->private_data;
5488 struct usb_mixer_interface *mixer = elem->head.mixer;
5489 struct scarlett2_data *private = mixer->private_data;
5509 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5523 struct usb_mixer_interface *mixer = elem->head.mixer;
5524 struct scarlett2_data *private = mixer->private_data;
5544 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5570 static int scarlett2_update_filter_values(struct usb_mixer_interface *mixer)
5572 struct scarlett2_data *private = mixer->private_data;
5584 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_SWITCH,
5590 mixer, SCARLETT2_CONFIG_PEQ_FLT_SWITCH,
5598 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5611 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5636 struct scarlett2_data *private = elem->head.mixer->private_data;
5652 struct scarlett2_data *private = elem->head.mixer->private_data;
5668 struct usb_mixer_interface *mixer = elem->head.mixer;
5669 struct scarlett2_data *private = mixer->private_data;
5681 err = scarlett2_check_put_during_autogain(mixer);
5703 mixer, private->config_set->param_buf_addr, 1, index);
5708 mixer, SCARLETT2_CONFIG_PRECOMP_FLT_PARAMS,
5724 struct usb_mixer_interface *mixer = elem->head.mixer;
5725 struct scarlett2_data *private = mixer->private_data;
5744 err = scarlett2_check_put_during_autogain(mixer);
5766 mixer, private->config_set->param_buf_addr, 1, dst_index);
5771 mixer, SCARLETT2_CONFIG_PEQ_FLT_PARAMS,
5812 static int scarlett2_update_input_mute(struct usb_mixer_interface *mixer)
5814 struct scarlett2_data *private = mixer->private_data;
5823 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5831 struct usb_mixer_interface *mixer = elem->head.mixer;
5832 struct scarlett2_data *private = mixer->private_data;
5843 err = scarlett2_update_input_mute(mixer);
5859 struct usb_mixer_interface *mixer = elem->head.mixer;
5860 struct scarlett2_data *private = mixer->private_data;
5872 err = scarlett2_check_put_during_autogain(mixer);
5886 mixer, SCARLETT2_CONFIG_INPUT_MUTE_SWITCH,
5906 static int scarlett2_update_input_phantom(struct usb_mixer_interface *mixer)
5908 struct scarlett2_data *private = mixer->private_data;
5918 mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
5926 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE,
5946 static void scarlett2_phantom_update_access(struct usb_mixer_interface *mixer)
5948 struct scarlett2_data *private = mixer->private_data;
5963 static void scarlett2_phantom_notify_access(struct usb_mixer_interface *mixer)
5965 struct snd_card *card = mixer->chip->card;
5966 struct scarlett2_data *private = mixer->private_data;
5979 struct usb_mixer_interface *mixer)
5981 struct scarlett2_data *private = mixer->private_data;
5987 err = scarlett2_update_input_phantom(mixer);
5991 scarlett2_phantom_update_access(mixer);
6000 struct usb_mixer_interface *mixer = elem->head.mixer;
6001 struct scarlett2_data *private = mixer->private_data;
6011 err = scarlett2_check_input_phantom_updated(mixer);
6027 struct usb_mixer_interface *mixer = elem->head.mixer;
6028 struct scarlett2_data *private = mixer->private_data;
6041 err = scarlett2_check_put_during_autogain(mixer);
6058 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_PHANTOM_SWITCH,
6063 scarlett2_phantom_update_access(mixer);
6064 scarlett2_phantom_notify_access(mixer);
6085 struct scarlett2_data *private = elem->head.mixer->private_data;
6095 struct usb_mixer_interface *mixer = elem->head.mixer;
6096 struct scarlett2_data *private = mixer->private_data;
6118 mixer, SCARLETT2_CONFIG_PHANTOM_PERSISTENCE, index, val);
6137 static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer)
6139 struct scarlett2_data *private = mixer->private_data;
6162 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6168 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6187 err = scarlett2_usb_get_config(mixer,
6213 struct usb_mixer_interface *mixer = elem->head.mixer;
6214 struct scarlett2_data *private = mixer->private_data;
6225 err = scarlett2_update_monitor_other(mixer);
6239 static int scarlett2_speaker_switch_enable(struct usb_mixer_interface *mixer)
6241 struct snd_card *card = mixer->chip->card;
6242 struct scarlett2_data *private = mixer->private_data;
6250 err = scarlett2_sw_hw_change(private->mixer, i, 1);
6274 static void scarlett2_speaker_switch_disable(struct usb_mixer_interface *mixer)
6276 struct snd_card *card = mixer->chip->card;
6277 struct scarlett2_data *private = mixer->private_data;
6297 struct usb_mixer_interface *mixer = elem->head.mixer;
6298 struct scarlett2_data *private = mixer->private_data;
6319 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6326 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6333 err = scarlett2_speaker_switch_enable(mixer);
6335 scarlett2_speaker_switch_disable(mixer);
6353 static int scarlett2_add_speaker_switch_ctl(struct usb_mixer_interface *mixer)
6355 struct scarlett2_data *private = mixer->private_data;
6362 mixer, &scarlett2_speaker_switch_enum_ctl,
6383 struct usb_mixer_interface *mixer = elem->head.mixer;
6384 struct scarlett2_data *private = mixer->private_data;
6395 err = scarlett2_update_monitor_other(mixer);
6410 struct usb_mixer_interface *mixer = elem->head.mixer;
6411 struct scarlett2_data *private = mixer->private_data;
6432 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_ENABLE,
6439 mixer, SCARLETT2_CONFIG_MONITOR_OTHER_SWITCH,
6461 struct usb_mixer_interface *mixer = elem->head.mixer;
6462 struct scarlett2_data *private = mixer->private_data;
6474 struct usb_mixer_interface *mixer = elem->head.mixer;
6475 struct scarlett2_data *private = mixer->private_data;
6499 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_TALKBACK_MAP,
6517 static int scarlett2_add_talkback_ctls(struct usb_mixer_interface *mixer)
6519 struct scarlett2_data *private = mixer->private_data;
6528 mixer, &scarlett2_talkback_enum_ctl,
6537 err = scarlett2_add_new_ctl(mixer, &scarlett2_talkback_map_ctl,
6552 struct usb_mixer_interface *mixer = elem->head.mixer;
6553 struct scarlett2_data *private = mixer->private_data;
6564 err = scarlett2_update_dim_mute(mixer);
6579 struct usb_mixer_interface *mixer = elem->head.mixer;
6580 struct scarlett2_data *private = mixer->private_data;
6600 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_DIM_MUTE,
6611 snd_ctl_notify(mixer->chip->card,
6632 static int scarlett2_add_line_out_ctls(struct usb_mixer_interface *mixer)
6634 struct scarlett2_data *private = mixer->private_data;
6643 err = scarlett2_add_new_ctl(mixer,
6654 err = scarlett2_add_new_ctl(mixer,
6682 err = scarlett2_add_new_ctl(mixer,
6692 err = scarlett2_add_new_ctl(mixer,
6707 scarlett2_vol_ctl_set_writable(mixer, i, 0);
6712 err = scarlett2_add_new_ctl(mixer,
6731 mixer, &scarlett2_dim_mute_ctl,
6743 static int scarlett2_add_dsp_ctls(struct usb_mixer_interface *mixer, int i)
6745 struct scarlett2_data *private = mixer->private_data;
6760 mixer, &scarlett2_compressor_ctl,
6770 mixer, &scarlett2_precomp_flt_switch_ctl,
6777 mixer, &scarlett2_peq_flt_switch_ctl,
6786 mixer, &scarlett2_precomp_flt_ctl,
6796 mixer, &scarlett2_peq_flt_ctl,
6806 static int scarlett2_add_line_in_ctls(struct usb_mixer_interface *mixer)
6808 struct scarlett2_data *private = mixer->private_data;
6819 err = scarlett2_add_new_ctl(mixer, &scarlett2_level_enum_ctl,
6828 err = scarlett2_add_new_ctl(mixer, &scarlett2_pad_ctl,
6839 mixer, &scarlett2_air_ctl[info->air_option],
6848 err = scarlett2_add_new_ctl(mixer, &scarlett2_dsp_ctl,
6853 err = scarlett2_add_dsp_ctls(mixer, i);
6862 mixer, &scarlett2_input_mute_ctl,
6875 mixer, &scarlett2_phantom_ctl,
6888 mixer, &scarlett2_phantom_ctl,
6898 mixer, &scarlett2_phantom_persistence_ctl, 0, 1,
6908 mixer, &scarlett2_input_select_ctl, 0, 1,
6922 mixer, &scarlett2_input_link_ctl,
6934 mixer, &scarlett2_input_gain_ctl,
6944 mixer, &scarlett2_autogain_switch_ctl,
6952 mixer, &scarlett2_autogain_status_ctl,
6964 mixer, &scarlett2_ag_target_ctl,
6975 mixer, &scarlett2_safe_ctl,
6985 mixer, &scarlett2_pcm_input_switch_ctl, 0, 1,
6997 static int scarlett2_update_mix(struct usb_mixer_interface *mixer)
6999 struct scarlett2_data *private = mixer->private_data;
7005 err = scarlett2_usb_get_mix(mixer, i);
7030 struct usb_mixer_interface *mixer = elem->head.mixer;
7031 struct scarlett2_data *private = mixer->private_data;
7042 err = scarlett2_update_mix(mixer);
7057 struct usb_mixer_interface *mixer = elem->head.mixer;
7058 struct scarlett2_data *private = mixer->private_data;
7078 err = scarlett2_usb_set_mix(mixer, mix_num);
7105 static int scarlett2_add_mixer_ctls(struct usb_mixer_interface *mixer)
7107 struct scarlett2_data *private = mixer->private_data;
7117 err = scarlett2_add_new_ctl(mixer, &scarlett2_mixer_ctl,
7129 static int scarlett2_update_direct_monitor(struct usb_mixer_interface *mixer)
7131 struct scarlett2_data *private = mixer->private_data;
7139 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR,
7143 static int scarlett2_update_monitor_mix(struct usb_mixer_interface *mixer)
7145 struct scarlett2_data *private = mixer->private_data;
7153 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
7169 struct usb_mixer_interface *mixer = elem->head.mixer;
7170 struct scarlett2_data *private = mixer->private_data;
7181 err = scarlett2_update_direct_monitor(mixer);
7196 struct usb_mixer_interface *mixer = elem->head.mixer;
7197 struct scarlett2_data *private = mixer->private_data;
7219 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR, index, val);
7262 struct scarlett2_data *private = elem->head.mixer->private_data;
7273 struct usb_mixer_interface *mixer = elem->head.mixer;
7274 struct scarlett2_data *private = mixer->private_data;
7294 mixer, SCARLETT2_CONFIG_DIRECT_MONITOR_GAIN,
7316 static int scarlett2_add_direct_monitor_ctls(struct usb_mixer_interface *mixer)
7318 struct scarlett2_data *private = mixer->private_data;
7331 mixer, &scarlett2_direct_monitor_ctl[info->direct_monitor - 1],
7363 mixer, &scarlett2_monitor_mix_ctl,
7379 struct scarlett2_data *private = elem->head.mixer->private_data;
7422 struct usb_mixer_interface *mixer = elem->head.mixer;
7423 struct scarlett2_data *private = mixer->private_data;
7435 err = scarlett2_usb_get_mux(mixer);
7450 struct usb_mixer_interface *mixer = elem->head.mixer;
7451 struct scarlett2_data *private = mixer->private_data;
7470 err = scarlett2_usb_set_mux(mixer);
7487 static int scarlett2_add_mux_enums(struct usb_mixer_interface *mixer)
7489 struct scarlett2_data *private = mixer->private_data;
7516 err = scarlett2_add_new_ctl(mixer,
7547 struct usb_mixer_interface *mixer = elem->head.mixer;
7548 struct scarlett2_data *private = mixer->private_data;
7560 err = scarlett2_usb_get_meter_levels(mixer, elem->channels,
7592 static int scarlett2_add_meter_ctl(struct usb_mixer_interface *mixer)
7594 struct scarlett2_data *private = mixer->private_data;
7596 /* devices without a mixer also don't support reporting levels */
7600 return scarlett2_add_new_ctl(mixer, &scarlett2_meter_ctl,
7611 struct scarlett2_data *private = elem->head.mixer->private_data;
7621 struct usb_mixer_interface *mixer = elem->head.mixer;
7622 struct scarlett2_data *private = mixer->private_data;
7642 err = scarlett2_usb_set_config(mixer, SCARLETT2_CONFIG_MSD_SWITCH,
7660 static int scarlett2_add_msd_ctl(struct usb_mixer_interface *mixer)
7662 struct scarlett2_data *private = mixer->private_data;
7668 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
7672 return scarlett2_add_new_ctl(mixer, &scarlett2_msd_ctl,
7682 struct scarlett2_data *private = elem->head.mixer->private_data;
7692 struct usb_mixer_interface *mixer = elem->head.mixer;
7693 struct scarlett2_data *private = mixer->private_data;
7713 err = scarlett2_usb_set_config(mixer,
7732 static int scarlett2_add_standalone_ctl(struct usb_mixer_interface *mixer)
7734 struct scarlett2_data *private = mixer->private_data;
7741 return scarlett2_add_new_ctl(mixer, &scarlett2_standalone_ctl,
7747 static int scarlett2_update_power_status(struct usb_mixer_interface *mixer)
7749 struct scarlett2_data *private = mixer->private_data;
7755 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_EXT,
7760 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_POWER_LOW,
7779 struct usb_mixer_interface *mixer = elem->head.mixer;
7780 struct scarlett2_data *private = mixer->private_data;
7786 err = scarlett2_update_power_status(mixer);
7815 static int scarlett2_add_power_status_ctl(struct usb_mixer_interface *mixer)
7817 struct scarlett2_data *private = mixer->private_data;
7824 return scarlett2_add_new_ctl(mixer, &scarlett2_power_status_ctl,
7831 static int scarlett2_update_bluetooth_volume(struct usb_mixer_interface *mixer)
7833 struct scarlett2_data *private = mixer->private_data;
7841 err = scarlett2_usb_get_config(mixer,
7854 struct usb_mixer_interface *mixer = elem->head.mixer;
7855 struct scarlett2_data *private = mixer->private_data;
7866 err = scarlett2_update_bluetooth_volume(mixer);
7881 struct usb_mixer_interface *mixer = elem->head.mixer;
7882 struct scarlett2_data *private = mixer->private_data;
7900 err = scarlett2_usb_set_config(mixer,
7931 struct usb_mixer_interface *mixer)
7933 struct scarlett2_data *private = mixer->private_data;
7939 return scarlett2_add_new_ctl(mixer, &scarlett2_bluetooth_volume_ctl,
7946 static int scarlett2_update_spdif_mode(struct usb_mixer_interface *mixer)
7948 struct scarlett2_data *private = mixer->private_data;
7956 err = scarlett2_usb_get_config(mixer, SCARLETT2_CONFIG_SPDIF_MODE,
7976 struct scarlett2_data *private = elem->head.mixer->private_data;
7991 struct scarlett2_data *private = elem->head.mixer->private_data;
8001 struct usb_mixer_interface *mixer = elem->head.mixer;
8002 struct scarlett2_data *private = mixer->private_data;
8028 mixer, SCARLETT2_CONFIG_SPDIF_MODE, 0,
8046 static int scarlett2_add_spdif_mode_ctl(struct usb_mixer_interface *mixer)
8048 struct scarlett2_data *private = mixer->private_data;
8053 return scarlett2_add_new_ctl(mixer, &scarlett2_spdif_mode_ctl,
8062 static void scarlett2_notify_sync(struct usb_mixer_interface *mixer)
8064 struct scarlett2_data *private = mixer->private_data;
8068 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8073 static void scarlett2_notify_monitor(struct usb_mixer_interface *mixer)
8075 struct snd_card *card = mixer->chip->card;
8076 struct scarlett2_data *private = mixer->private_data;
8084 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8094 static void scarlett2_notify_volume(struct usb_mixer_interface *mixer)
8096 struct scarlett2_data *private = mixer->private_data;
8100 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8102 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
8107 static void scarlett2_notify_dim_mute(struct usb_mixer_interface *mixer)
8109 struct snd_card *card = mixer->chip->card;
8110 struct scarlett2_data *private = mixer->private_data;
8129 static void scarlett2_notify_input_level(struct usb_mixer_interface *mixer)
8131 struct snd_card *card = mixer->chip->card;
8132 struct scarlett2_data *private = mixer->private_data;
8144 static void scarlett2_notify_input_pad(struct usb_mixer_interface *mixer)
8146 struct snd_card *card = mixer->chip->card;
8147 struct scarlett2_data *private = mixer->private_data;
8159 static void scarlett2_notify_input_air(struct usb_mixer_interface *mixer)
8161 struct snd_card *card = mixer->chip->card;
8162 struct scarlett2_data *private = mixer->private_data;
8174 static void scarlett2_notify_input_dsp(struct usb_mixer_interface *mixer)
8176 struct snd_card *card = mixer->chip->card;
8177 struct scarlett2_data *private = mixer->private_data;
8189 static void scarlett2_notify_input_mute(struct usb_mixer_interface *mixer)
8191 struct snd_card *card = mixer->chip->card;
8192 struct scarlett2_data *private = mixer->private_data;
8204 static void scarlett2_notify_input_phantom(struct usb_mixer_interface *mixer)
8206 struct snd_card *card = mixer->chip->card;
8207 struct scarlett2_data *private = mixer->private_data;
8217 scarlett2_phantom_notify_access(mixer);
8221 static void scarlett2_notify_input_other(struct usb_mixer_interface *mixer)
8223 scarlett2_notify_input_level(mixer);
8224 scarlett2_notify_input_pad(mixer);
8225 scarlett2_notify_input_air(mixer);
8226 scarlett2_notify_input_phantom(mixer);
8230 static void scarlett2_notify_input_select(struct usb_mixer_interface *mixer)
8232 struct snd_card *card = mixer->chip->card;
8233 struct scarlett2_data *private = mixer->private_data;
8253 static void scarlett2_notify_input_gain(struct usb_mixer_interface *mixer)
8255 struct snd_card *card = mixer->chip->card;
8256 struct scarlett2_data *private = mixer->private_data;
8271 static void scarlett2_notify_autogain(struct usb_mixer_interface *mixer)
8273 struct snd_card *card = mixer->chip->card;
8274 struct scarlett2_data *private = mixer->private_data;
8296 scarlett2_autogain_notify_access(mixer);
8300 static void scarlett2_notify_input_safe(struct usb_mixer_interface *mixer)
8302 struct snd_card *card = mixer->chip->card;
8303 struct scarlett2_data *private = mixer->private_data;
8318 static void scarlett2_notify_monitor_other(struct usb_mixer_interface *mixer)
8320 struct snd_card *card = mixer->chip->card;
8321 struct scarlett2_data *private = mixer->private_data;
8340 scarlett2_notify_dim_mute(mixer);
8352 static void scarlett2_notify_direct_monitor(struct usb_mixer_interface *mixer)
8354 struct snd_card *card = mixer->chip->card;
8355 struct scarlett2_data *private = mixer->private_data;
8376 static void scarlett2_notify_power_status(struct usb_mixer_interface *mixer)
8378 struct snd_card *card = mixer->chip->card;
8379 struct scarlett2_data *private = mixer->private_data;
8388 static void scarlett2_notify_mux(struct usb_mixer_interface *mixer)
8390 struct snd_card *card = mixer->chip->card;
8391 struct scarlett2_data *private = mixer->private_data;
8402 static void scarlett2_notify_pcm_input_switch(struct usb_mixer_interface *mixer)
8404 struct snd_card *card = mixer->chip->card;
8405 struct scarlett2_data *private = mixer->private_data;
8412 scarlett2_notify_mux(mixer);
8416 static void scarlett2_notify_bluetooth(struct usb_mixer_interface *mixer)
8418 struct snd_card *card = mixer->chip->card;
8419 struct scarlett2_data *private = mixer->private_data;
8433 static void scarlett2_notify_ack(struct usb_mixer_interface *mixer)
8435 struct scarlett2_data *private = mixer->private_data;
8445 struct usb_mixer_interface *mixer = urb->context;
8449 struct scarlett2_data *private = mixer->private_data;
8468 notifications->func(mixer);
8474 usb_audio_warn(mixer->chip,
8482 urb->dev = mixer->chip->dev;
8491 static void scarlett2_private_free(struct usb_mixer_interface *mixer)
8493 struct scarlett2_data *private = mixer->private_data;
8497 mixer->private_data = NULL;
8500 static void scarlett2_private_suspend(struct usb_mixer_interface *mixer)
8502 struct scarlett2_data *private = mixer->private_data;
8505 scarlett2_config_save(private->mixer);
8530 * doesn't have mixer controls.
8591 static int scarlett2_init_private(struct usb_mixer_interface *mixer,
8604 mixer->private_data = private;
8605 mixer->private_free = scarlett2_private_free;
8606 mixer->private_suspend = scarlett2_private_suspend;
8613 private->mixer = mixer;
8615 return scarlett2_find_fc_interface(mixer->chip->dev, private);
8619 static int scarlett2_init_notify(struct usb_mixer_interface *mixer)
8621 struct usb_device *dev = mixer->chip->dev;
8622 struct scarlett2_data *private = mixer->private_data;
8626 if (mixer->urb) {
8627 usb_audio_err(mixer->chip,
8628 "%s: mixer urb already in use!\n", __func__);
8635 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
8636 if (!mixer->urb)
8643 usb_fill_int_urb(mixer->urb, dev, pipe,
8645 scarlett2_notify, mixer, private->bInterval);
8649 return usb_submit_urb(mixer->urb, GFP_KERNEL);
8653 static int scarlett2_usb_init(struct usb_mixer_interface *mixer)
8655 struct usb_device *dev = mixer->chip->dev;
8656 struct scarlett2_data *private = mixer->private_data;
8677 err = scarlett2_init_notify(mixer);
8691 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_1, NULL, 0, NULL, 0);
8697 err = scarlett2_usb(mixer, SCARLETT2_USB_INIT_2,
8705 usb_audio_info(mixer->chip,
8715 static int scarlett2_get_flash_segment_nums(struct usb_mixer_interface *mixer)
8717 struct scarlett2_data *private = mixer->private_data;
8732 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_FLASH,
8743 usb_audio_err(mixer->chip,
8752 err = scarlett2_usb(mixer, SCARLETT2_USB_INFO_SEGMENT,
8756 usb_audio_err(mixer->chip,
8781 usb_audio_err(mixer->chip,
8787 usb_audio_err(mixer->chip,
8797 static int scarlett2_read_configs(struct usb_mixer_interface *mixer)
8799 struct scarlett2_data *private = mixer->private_data;
8805 mixer, SCARLETT2_CONFIG_MSD_SWITCH,
8812 usb_audio_err(mixer->chip,
8825 err = scarlett2_update_input_level(mixer);
8829 err = scarlett2_update_input_pad(mixer);
8833 err = scarlett2_update_input_air(mixer);
8837 err = scarlett2_update_input_dsp(mixer);
8841 err = scarlett2_update_compressor_values(mixer);
8845 err = scarlett2_update_filter_values(mixer);
8849 err = scarlett2_update_input_mute(mixer);
8853 err = scarlett2_update_input_phantom(mixer);
8857 err = scarlett2_update_direct_monitor(mixer);
8861 /* the rest of the configuration is for devices with a mixer */
8865 err = scarlett2_update_monitor_mix(mixer);
8869 err = scarlett2_update_monitor_other(mixer);
8876 mixer, SCARLETT2_CONFIG_STANDALONE_SWITCH,
8884 err = scarlett2_update_power_status(mixer);
8889 err = scarlett2_update_sync(mixer);
8899 mixer, SCARLETT2_CONFIG_LINE_OUT_VOLUME,
8911 mixer, SCARLETT2_CONFIG_MUTE_SWITCH,
8924 mixer, SCARLETT2_CONFIG_SW_HW_SWITCH,
8936 err = scarlett2_update_volumes(mixer);
8940 err = scarlett2_update_dim_mute(mixer);
8944 err = scarlett2_update_input_select(mixer);
8948 err = scarlett2_update_input_gain(mixer);
8952 err = scarlett2_update_autogain(mixer);
8956 err = scarlett2_update_input_safe(mixer);
8962 err = scarlett2_update_pcm_input_switch(mixer);
8967 err = scarlett2_update_bluetooth_volume(mixer);
8971 err = scarlett2_update_spdif_mode(mixer);
8975 err = scarlett2_update_mix(mixer);
8979 return scarlett2_usb_get_mux(mixer);
8983 struct usb_mixer_interface *mixer)
8988 while (entry->usb_id && entry->usb_id != mixer->chip->usb_id)
8997 struct usb_mixer_interface *mixer,
9004 err = scarlett2_init_private(mixer, entry);
9008 private = mixer->private_data;
9011 err = scarlett2_usb_init(mixer);
9016 err = scarlett2_get_flash_segment_nums(mixer);
9021 err = scarlett2_add_firmware_version_ctl(mixer);
9026 err = scarlett2_add_min_firmware_version_ctl(mixer);
9031 err = scarlett2_read_configs(mixer);
9036 err = scarlett2_add_msd_ctl(mixer);
9048 err = scarlett2_add_line_out_ctls(mixer);
9053 err = scarlett2_add_line_in_ctls(mixer);
9057 /* Create the input, output, and mixer mux input selections */
9058 err = scarlett2_add_mux_enums(mixer);
9062 /* Create the matrix mixer controls */
9063 err = scarlett2_add_mixer_ctls(mixer);
9068 err = scarlett2_add_meter_ctl(mixer);
9073 err = scarlett2_add_sync_ctl(mixer);
9078 err = scarlett2_add_direct_monitor_ctls(mixer);
9083 err = scarlett2_add_speaker_switch_ctl(mixer);
9088 err = scarlett2_add_talkback_ctls(mixer);
9093 err = scarlett2_add_standalone_ctl(mixer);
9098 err = scarlett2_add_power_status_ctl(mixer);
9103 err = scarlett2_add_bluetooth_volume_ctl(mixer);
9108 err = scarlett2_add_spdif_mode_ctl(mixer);
9116 scarlett2_autogain_update_access(mixer);
9117 scarlett2_phantom_update_access(mixer);
9139 static int scarlett2_get_erase_progress(struct usb_mixer_interface *mixer)
9141 struct scarlett2_data *private = mixer->private_data;
9161 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9174 static int scarlett2_wait_for_erase(struct usb_mixer_interface *mixer)
9179 err = scarlett2_get_erase_progress(mixer);
9195 static int scarlett2_reboot(struct usb_mixer_interface *mixer)
9197 struct scarlett2_data *private = mixer->private_data;
9201 int err = scarlett2_wait_for_erase(mixer);
9207 return scarlett2_usb(mixer, SCARLETT2_USB_REBOOT, NULL, 0, NULL, 0);
9212 struct usb_mixer_interface *mixer,
9215 struct scarlett2_data *private = mixer->private_data;
9228 usb_audio_err(mixer->chip,
9236 int err = scarlett2_wait_for_erase(mixer);
9251 struct usb_mixer_interface *mixer)
9253 struct scarlett2_data *private = mixer->private_data;
9280 err = scarlett2_usb(mixer, SCARLETT2_USB_ERASE_SEGMENT,
9294 struct usb_mixer_interface *mixer,
9297 struct scarlett2_data *private = mixer->private_data;
9322 err = scarlett2_usb(mixer, SCARLETT2_USB_GET_ERASE,
9345 struct usb_mixer_interface *mixer = hw->private_data;
9346 struct scarlett2_data *private = mixer->private_data;
9351 int err = scarlett2_wait_for_erase(mixer);
9366 struct usb_mixer_interface *mixer = hw->private_data;
9375 return scarlett2_reboot(mixer);
9378 return scarlett2_ioctl_select_flash_segment(mixer, arg);
9381 return scarlett2_ioctl_erase_flash_segment(mixer);
9384 return scarlett2_ioctl_get_erase_progress(mixer, arg);
9395 struct usb_mixer_interface *mixer = hw->private_data;
9396 struct scarlett2_data *private = mixer->private_data;
9450 err = scarlett2_usb(mixer, SCARLETT2_USB_READ_SEGMENT,
9473 struct usb_mixer_interface *mixer = hw->private_data;
9474 struct scarlett2_data *private = mixer->private_data;
9493 err = scarlett2_wait_for_erase(mixer);
9543 err = scarlett2_usb(mixer, SCARLETT2_USB_WRITE_SEGMENT,
9558 struct usb_mixer_interface *mixer = hw->private_data;
9559 struct scarlett2_data *private = mixer->private_data;
9572 static int scarlett2_hwdep_init(struct usb_mixer_interface *mixer)
9577 err = snd_hwdep_new(mixer->chip->card, "Focusrite Control", 0, &hw);
9581 hw->private_data = mixer;
9592 int snd_scarlett2_init(struct usb_mixer_interface *mixer)
9594 struct snd_usb_audio *chip = mixer->chip;
9599 if (!mixer->protocol)
9603 entry = get_scarlett2_device_entry(mixer);
9605 usb_audio_err(mixer->chip,
9632 err = snd_scarlett2_controls_create(mixer, entry);
9634 usb_audio_err(mixer->chip,
9641 err = scarlett2_hwdep_init(mixer);
9643 usb_audio_err(mixer->chip,