Lines Matching full:private
1873 static void scarlett2_fill_request_header(struct scarlett2_data *private, in scarlett2_fill_request_header() argument
1878 u16 seq = private->scarlett2_seq++; in scarlett2_fill_request_header()
1910 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb() local
1929 mutex_lock(&private->usb_mutex); in scarlett2_usb()
1933 scarlett2_fill_request_header(private, req, cmd, req_size); in scarlett2_usb()
1938 err = scarlett2_usb_tx(dev, private->bInterfaceNumber, in scarlett2_usb()
1945 private->series_name, cmd, err); in scarlett2_usb()
1952 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, in scarlett2_usb()
1972 private->series_name, cmd, err, resp_buf_size); in scarlett2_usb()
1991 private->series_name, in scarlett2_usb()
2005 mutex_unlock(&private->usb_mutex); in scarlett2_usb()
2032 struct scarlett2_data *private, int config_item_num) in scarlett2_has_config_item() argument
2034 return !!private->config_set->items[config_item_num].offset; in scarlett2_has_config_item()
2042 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_get_config() local
2044 &private->config_set->items[config_item_num]; in scarlett2_usb_get_config()
2094 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_set_data() local
2104 return scarlett2_usb(private->mixer, SCARLETT2_USB_SET_DATA, in scarlett2_usb_set_data()
2129 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_set_config() local
2130 const struct scarlett2_config_set *config_set = private->config_set; in scarlett2_usb_set_config()
2173 cancel_delayed_work_sync(&private->work); in scarlett2_usb_set_config()
2219 schedule_delayed_work(&private->work, msecs_to_jiffies(2000)); in scarlett2_usb_set_config()
2237 struct scarlett2_data *private = in scarlett2_config_save_work() local
2240 scarlett2_config_save(private->mixer); in scarlett2_config_save_work()
2261 static int scarlett2_has_mixer(struct scarlett2_data *private) in scarlett2_has_mixer() argument
2263 return !!private->info->mux_assignment[0][0].count; in scarlett2_has_mixer()
2280 * and put the values into private->mix[]
2285 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_get_mix() local
2287 int num_mixer_in = private->num_mix_in; in scarlett2_usb_get_mix()
2307 private->mix[j] = scarlett2_mixer_value_to_db( in scarlett2_usb_get_mix()
2314 * (values obtained from private->mix[])
2319 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_set_mix() local
2327 int num_mixer_in = private->num_mix_in; in scarlett2_usb_set_mix()
2333 scarlett2_mixer_values[private->mix[j]] in scarlett2_usb_set_mix()
2381 /* Convert one mux entry from the interface and load into private->mux[] */
2382 static void scarlett2_usb_populate_mux(struct scarlett2_data *private, in scarlett2_usb_populate_mux() argument
2385 const struct scarlett2_device_info *info = private->info; in scarlett2_usb_populate_mux()
2395 if (dst_idx >= private->num_mux_dsts) { in scarlett2_usb_populate_mux()
2396 usb_audio_err(private->mixer->chip, in scarlett2_usb_populate_mux()
2398 mux_entry, dst_idx, private->num_mux_dsts); in scarlett2_usb_populate_mux()
2407 if (src_idx >= private->num_mux_srcs) { in scarlett2_usb_populate_mux()
2408 usb_audio_err(private->mixer->chip, in scarlett2_usb_populate_mux()
2410 mux_entry, src_idx, private->num_mux_srcs); in scarlett2_usb_populate_mux()
2414 private->mux[dst_idx] = src_idx; in scarlett2_usb_populate_mux()
2435 static void scarlett2_update_meter_level_map(struct scarlett2_data *private) in scarlett2_update_meter_level_map() argument
2437 const struct scarlett2_device_info *info = private->info; in scarlett2_update_meter_level_map()
2466 mux_idx < private->num_line_out in scarlett2_update_meter_level_map()
2475 int mux_src = private->mux[mux_idx]; in scarlett2_update_meter_level_map()
2481 private->meter_level_map[map_mux_idx] = in scarlett2_update_meter_level_map()
2487 /* Send USB message to get mux inputs and then populate private->mux[] */
2490 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_get_mux() local
2491 int count = private->num_mux_dsts; in scarlett2_usb_get_mux()
2501 private->mux_updated = 0; in scarlett2_usb_get_mux()
2513 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i])); in scarlett2_usb_get_mux()
2515 scarlett2_update_meter_level_map(private); in scarlett2_usb_get_mux()
2523 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_set_mux() local
2524 const struct scarlett2_device_info *info = private->info; in scarlett2_usb_set_mux()
2569 port_count, private->mux[mux_idx++]); in scarlett2_usb_set_mux()
2583 scarlett2_update_meter_level_map(private); in scarlett2_usb_set_mux()
2676 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_firmware_version_ctl_get() local
2678 ucontrol->value.integer.value[0] = private->firmware_version; in scarlett2_firmware_version_ctl_get()
2715 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_min_firmware_version_ctl_get() local
2717 ucontrol->value.integer.value[0] = private->info->min_firmware_version; in scarlett2_min_firmware_version_ctl_get()
2754 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_sync() local
2756 private->sync_updated = 0; in scarlett2_update_sync()
2757 return scarlett2_usb_get_sync_status(mixer, &private->sync); in scarlett2_update_sync()
2774 struct scarlett2_data *private = mixer->private_data; in scarlett2_sync_ctl_get() local
2777 mutex_lock(&private->data_mutex); in scarlett2_sync_ctl_get()
2779 if (private->hwdep_in_use) { in scarlett2_sync_ctl_get()
2784 if (private->sync_updated) { in scarlett2_sync_ctl_get()
2789 ucontrol->value.enumerated.item[0] = private->sync; in scarlett2_sync_ctl_get()
2792 mutex_unlock(&private->data_mutex); in scarlett2_sync_ctl_get()
2806 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_sync_ctl() local
2809 if (!scarlett2_has_mixer(private)) in scarlett2_add_sync_ctl()
2813 0, 1, "Sync Status", &private->sync_ctl); in scarlett2_add_sync_ctl()
2834 static int scarlett2_autogain_is_running(struct scarlett2_data *private) in scarlett2_autogain_is_running() argument
2838 for (i = 0; i < private->info->gain_input_count; i++) in scarlett2_autogain_is_running()
2839 if (private->autogain_status[i] == in scarlett2_autogain_is_running()
2848 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_autogain() local
2849 const struct scarlett2_device_info *info = private->info; in scarlett2_update_autogain()
2853 private->autogain_updated = 0; in scarlett2_update_autogain()
2860 info->gain_input_count, private->autogain_switch); in scarlett2_update_autogain()
2873 if (private->autogain_switch[i]) in scarlett2_update_autogain()
2874 private->autogain_status[i] = in scarlett2_update_autogain()
2877 private->autogain_status[i] = in scarlett2_update_autogain()
2881 private->autogain_status[i] = in scarlett2_update_autogain()
2884 private->autogain_status[i] = in scarlett2_update_autogain()
2887 private->autogain_status[i] = in scarlett2_update_autogain()
2896 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_update_access() local
2897 const struct scarlett2_device_info *info = private->info; in scarlett2_autogain_update_access()
2898 int val = !scarlett2_autogain_is_running(private); in scarlett2_autogain_update_access()
2901 scarlett2_set_ctl_access(private->input_select_ctl, val); in scarlett2_autogain_update_access()
2903 scarlett2_set_ctl_access(private->input_link_ctls[i], val); in scarlett2_autogain_update_access()
2905 scarlett2_set_ctl_access(private->input_gain_ctls[i], val); in scarlett2_autogain_update_access()
2906 scarlett2_set_ctl_access(private->safe_ctls[i], val); in scarlett2_autogain_update_access()
2909 scarlett2_set_ctl_access(private->level_ctls[i], val); in scarlett2_autogain_update_access()
2911 scarlett2_set_ctl_access(private->air_ctls[i], val); in scarlett2_autogain_update_access()
2913 scarlett2_set_ctl_access(private->phantom_ctls[i], val); in scarlett2_autogain_update_access()
2922 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_notify_access() local
2923 const struct scarlett2_device_info *info = private->info; in scarlett2_autogain_notify_access()
2927 &private->input_select_ctl->id); in scarlett2_autogain_notify_access()
2930 &private->input_link_ctls[i]->id); in scarlett2_autogain_notify_access()
2933 &private->input_gain_ctls[i]->id); in scarlett2_autogain_notify_access()
2935 &private->safe_ctls[i]->id); in scarlett2_autogain_notify_access()
2939 &private->level_ctls[i]->id); in scarlett2_autogain_notify_access()
2942 &private->air_ctls[i]->id); in scarlett2_autogain_notify_access()
2945 &private->phantom_ctls[i]->id); in scarlett2_autogain_notify_access()
2954 struct scarlett2_data *private = mixer->private_data; in scarlett2_check_autogain_updated() local
2957 if (!private->autogain_updated) in scarlett2_check_autogain_updated()
2993 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_switch_ctl_info() local
2996 mutex_lock(&private->data_mutex); in scarlett2_autogain_switch_ctl_info()
3005 mutex_unlock(&private->data_mutex); in scarlett2_autogain_switch_ctl_info()
3014 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_switch_ctl_get() local
3017 mutex_lock(&private->data_mutex); in scarlett2_autogain_switch_ctl_get()
3019 if (private->hwdep_in_use) { in scarlett2_autogain_switch_ctl_get()
3029 private->autogain_switch[elem->control]; in scarlett2_autogain_switch_ctl_get()
3032 mutex_unlock(&private->data_mutex); in scarlett2_autogain_switch_ctl_get()
3041 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_status_ctl_get() local
3044 mutex_lock(&private->data_mutex); in scarlett2_autogain_status_ctl_get()
3046 if (private->hwdep_in_use) { in scarlett2_autogain_status_ctl_get()
3056 private->autogain_status[elem->control]; in scarlett2_autogain_status_ctl_get()
3059 mutex_unlock(&private->data_mutex); in scarlett2_autogain_status_ctl_get()
3068 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_switch_ctl_put() local
3073 mutex_lock(&private->data_mutex); in scarlett2_autogain_switch_ctl_put()
3075 if (private->hwdep_in_use) { in scarlett2_autogain_switch_ctl_put()
3084 if (scarlett2_phantom_is_switching(private, index)) { in scarlett2_autogain_switch_ctl_put()
3089 oval = private->autogain_switch[index]; in scarlett2_autogain_switch_ctl_put()
3095 private->autogain_switch[index] = val; in scarlett2_autogain_switch_ctl_put()
3107 mutex_unlock(&private->data_mutex); in scarlett2_autogain_switch_ctl_put()
3142 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_select() local
3143 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_select()
3147 private->input_select_updated = 0; in scarlett2_update_input_select()
3154 1, &private->input_select_switch); in scarlett2_update_input_select()
3160 link_count, private->input_link_switch); in scarlett2_update_input_select()
3165 if (private->input_link_switch[0]) in scarlett2_update_input_select()
3166 private->input_select_switch = 0; in scarlett2_update_input_select()
3176 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_select_ctl_get() local
3179 mutex_lock(&private->data_mutex); in scarlett2_input_select_ctl_get()
3181 if (private->hwdep_in_use) { in scarlett2_input_select_ctl_get()
3186 if (private->input_select_updated) { in scarlett2_input_select_ctl_get()
3191 ucontrol->value.enumerated.item[0] = private->input_select_switch; in scarlett2_input_select_ctl_get()
3194 mutex_unlock(&private->data_mutex); in scarlett2_input_select_ctl_get()
3203 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_select_ctl_put() local
3206 int max_val = private->input_link_switch[0] ? 0 : 1; in scarlett2_input_select_ctl_put()
3208 mutex_lock(&private->data_mutex); in scarlett2_input_select_ctl_put()
3210 if (private->hwdep_in_use) { in scarlett2_input_select_ctl_put()
3219 oval = private->input_select_switch; in scarlett2_input_select_ctl_put()
3230 private->input_select_switch = val; in scarlett2_input_select_ctl_put()
3233 if (!private->input_link_switch[0]) in scarlett2_input_select_ctl_put()
3241 mutex_unlock(&private->data_mutex); in scarlett2_input_select_ctl_put()
3250 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_select_ctl_info() local
3252 int inputs = private->info->gain_input_count; in scarlett2_input_select_ctl_info()
3260 mutex_lock(&private->data_mutex); in scarlett2_input_select_ctl_info()
3262 if (private->hwdep_in_use) { in scarlett2_input_select_ctl_info()
3275 if (private->input_link_switch[i / 2]) { in scarlett2_input_select_ctl_info()
3289 mutex_unlock(&private->data_mutex); in scarlett2_input_select_ctl_info()
3316 struct scarlett2_data *private = mixer->private_data; in scarlett2_autogain_disables_ctl_info() local
3319 mutex_lock(&private->data_mutex); in scarlett2_autogain_disables_ctl_info()
3321 if (private->hwdep_in_use) { in scarlett2_autogain_disables_ctl_info()
3333 mutex_unlock(&private->data_mutex); in scarlett2_autogain_disables_ctl_info()
3342 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_link_ctl_get() local
3345 mutex_lock(&private->data_mutex); in scarlett2_input_link_ctl_get()
3347 if (private->hwdep_in_use) { in scarlett2_input_link_ctl_get()
3352 if (private->input_select_updated) { in scarlett2_input_link_ctl_get()
3358 private->input_link_switch[elem->control]; in scarlett2_input_link_ctl_get()
3361 mutex_unlock(&private->data_mutex); in scarlett2_input_link_ctl_get()
3370 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_link_ctl_put() local
3375 mutex_lock(&private->data_mutex); in scarlett2_input_link_ctl_put()
3377 if (private->hwdep_in_use) { in scarlett2_input_link_ctl_put()
3386 oval = private->input_link_switch[index]; in scarlett2_input_link_ctl_put()
3392 private->input_link_switch[index] = val; in scarlett2_input_link_ctl_put()
3397 &private->input_select_ctl->id); in scarlett2_input_link_ctl_put()
3398 private->input_select_updated = 1; in scarlett2_input_link_ctl_put()
3410 mutex_unlock(&private->data_mutex); in scarlett2_input_link_ctl_put()
3426 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_gain() local
3427 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_gain()
3429 private->input_gain_updated = 0; in scarlett2_update_input_gain()
3436 info->gain_input_count, private->gain); in scarlett2_update_input_gain()
3444 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_gain_ctl_info() local
3447 mutex_lock(&private->data_mutex); in scarlett2_input_gain_ctl_info()
3449 if (private->hwdep_in_use) { in scarlett2_input_gain_ctl_info()
3465 mutex_unlock(&private->data_mutex); in scarlett2_input_gain_ctl_info()
3474 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_gain_ctl_get() local
3477 mutex_lock(&private->data_mutex); in scarlett2_input_gain_ctl_get()
3479 if (private->hwdep_in_use) { in scarlett2_input_gain_ctl_get()
3484 if (private->input_gain_updated) { in scarlett2_input_gain_ctl_get()
3490 private->gain[elem->control]; in scarlett2_input_gain_ctl_get()
3493 mutex_unlock(&private->data_mutex); in scarlett2_input_gain_ctl_get()
3502 struct scarlett2_data *private = mixer->private_data; in scarlett2_input_gain_ctl_put() local
3507 mutex_lock(&private->data_mutex); in scarlett2_input_gain_ctl_put()
3509 if (private->hwdep_in_use) { in scarlett2_input_gain_ctl_put()
3518 oval = private->gain[index]; in scarlett2_input_gain_ctl_put()
3524 private->gain[index] = val; in scarlett2_input_gain_ctl_put()
3533 mutex_unlock(&private->data_mutex); in scarlett2_input_gain_ctl_put()
3557 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_safe() local
3558 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_safe()
3560 private->input_safe_updated = 0; in scarlett2_update_input_safe()
3567 info->gain_input_count, private->safe_switch); in scarlett2_update_input_safe()
3575 struct scarlett2_data *private = mixer->private_data; in scarlett2_safe_ctl_get() local
3578 mutex_lock(&private->data_mutex); in scarlett2_safe_ctl_get()
3580 if (private->hwdep_in_use) { in scarlett2_safe_ctl_get()
3585 if (private->input_safe_updated) { in scarlett2_safe_ctl_get()
3591 private->safe_switch[elem->control]; in scarlett2_safe_ctl_get()
3594 mutex_unlock(&private->data_mutex); in scarlett2_safe_ctl_get()
3603 struct scarlett2_data *private = mixer->private_data; in scarlett2_safe_ctl_put() local
3608 mutex_lock(&private->data_mutex); in scarlett2_safe_ctl_put()
3610 if (private->hwdep_in_use) { in scarlett2_safe_ctl_put()
3619 oval = private->safe_switch[index]; in scarlett2_safe_ctl_put()
3625 private->safe_switch[index] = val; in scarlett2_safe_ctl_put()
3634 mutex_unlock(&private->data_mutex); in scarlett2_safe_ctl_put()
3650 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_pcm_input_switch() local
3653 private->pcm_input_switch_updated = 0; in scarlett2_update_pcm_input_switch()
3657 1, &private->pcm_input_switch); in scarlett2_update_pcm_input_switch()
3669 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_pcm_input_switch_ctl_get() local
3672 mutex_lock(&private->data_mutex); in scarlett2_pcm_input_switch_ctl_get()
3674 if (private->pcm_input_switch_updated) { in scarlett2_pcm_input_switch_ctl_get()
3679 ucontrol->value.enumerated.item[0] = private->pcm_input_switch; in scarlett2_pcm_input_switch_ctl_get()
3682 mutex_unlock(&private->data_mutex); in scarlett2_pcm_input_switch_ctl_get()
3691 struct scarlett2_data *private = mixer->private_data; in scarlett2_pcm_input_switch_ctl_put() local
3695 mutex_lock(&private->data_mutex); in scarlett2_pcm_input_switch_ctl_put()
3697 if (private->hwdep_in_use) { in scarlett2_pcm_input_switch_ctl_put()
3702 oval = private->pcm_input_switch; in scarlett2_pcm_input_switch_ctl_put()
3708 private->pcm_input_switch = val; in scarlett2_pcm_input_switch_ctl_put()
3718 mutex_unlock(&private->data_mutex); in scarlett2_pcm_input_switch_ctl_put()
3748 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_volumes() local
3752 private->vol_updated = 0; in scarlett2_update_volumes()
3754 if (scarlett2_has_config_item(private, in scarlett2_update_volumes()
3762 private->master_vol = clamp(vol + SCARLETT2_VOLUME_BIAS, in scarlett2_update_volumes()
3765 if (scarlett2_has_config_item(private, in scarlett2_update_volumes()
3767 for (i = 0; i < private->num_line_out; i++) in scarlett2_update_volumes()
3768 if (private->vol_sw_hw_switch[i]) in scarlett2_update_volumes()
3769 private->vol[i] = private->master_vol; in scarlett2_update_volumes()
3772 if (scarlett2_has_config_item(private, in scarlett2_update_volumes()
3780 private->headphone_vol = clamp(vol + SCARLETT2_VOLUME_BIAS, in scarlett2_update_volumes()
3805 struct scarlett2_data *private = mixer->private_data; in scarlett2_master_volume_ctl_get() local
3808 mutex_lock(&private->data_mutex); in scarlett2_master_volume_ctl_get()
3810 if (private->hwdep_in_use) { in scarlett2_master_volume_ctl_get()
3815 if (private->vol_updated) { in scarlett2_master_volume_ctl_get()
3820 ucontrol->value.integer.value[0] = private->master_vol; in scarlett2_master_volume_ctl_get()
3823 mutex_unlock(&private->data_mutex); in scarlett2_master_volume_ctl_get()
3833 struct scarlett2_data *private = mixer->private_data; in scarlett2_headphone_volume_ctl_get() local
3836 mutex_lock(&private->data_mutex); in scarlett2_headphone_volume_ctl_get()
3838 if (private->hwdep_in_use) { in scarlett2_headphone_volume_ctl_get()
3843 if (private->vol_updated) { in scarlett2_headphone_volume_ctl_get()
3848 ucontrol->value.integer.value[0] = private->headphone_vol; in scarlett2_headphone_volume_ctl_get()
3851 mutex_unlock(&private->data_mutex); in scarlett2_headphone_volume_ctl_get()
3855 static int line_out_remap(struct scarlett2_data *private, int index) in line_out_remap() argument
3857 const struct scarlett2_device_info *info = private->info; in line_out_remap()
3862 if (index >= private->num_line_out) in line_out_remap()
3873 struct scarlett2_data *private = mixer->private_data; in scarlett2_volume_ctl_get() local
3874 int index = line_out_remap(private, elem->control); in scarlett2_volume_ctl_get()
3877 mutex_lock(&private->data_mutex); in scarlett2_volume_ctl_get()
3879 if (private->hwdep_in_use) { in scarlett2_volume_ctl_get()
3884 if (private->vol_updated) { in scarlett2_volume_ctl_get()
3889 ucontrol->value.integer.value[0] = private->vol[index]; in scarlett2_volume_ctl_get()
3892 mutex_unlock(&private->data_mutex); in scarlett2_volume_ctl_get()
3901 struct scarlett2_data *private = mixer->private_data; in scarlett2_volume_ctl_put() local
3902 int index = line_out_remap(private, elem->control); in scarlett2_volume_ctl_put()
3905 mutex_lock(&private->data_mutex); in scarlett2_volume_ctl_put()
3907 if (private->hwdep_in_use) { in scarlett2_volume_ctl_put()
3912 oval = private->vol[index]; in scarlett2_volume_ctl_put()
3918 private->vol[index] = val; in scarlett2_volume_ctl_put()
3925 mutex_unlock(&private->data_mutex); in scarlett2_volume_ctl_put()
3971 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_dim_mute() local
3975 private->dim_mute_updated = 0; in scarlett2_update_dim_mute()
3977 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) in scarlett2_update_dim_mute()
3982 SCARLETT2_DIM_MUTE_COUNT, private->dim_mute); in scarlett2_update_dim_mute()
3987 private->dim_mute[i] = !!private->dim_mute[i]; in scarlett2_update_dim_mute()
3989 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE]; in scarlett2_update_dim_mute()
3991 for (i = 0; i < private->num_line_out; i++) in scarlett2_update_dim_mute()
3992 if (private->vol_sw_hw_switch[i]) in scarlett2_update_dim_mute()
3993 private->mute_switch[i] = mute; in scarlett2_update_dim_mute()
4003 struct scarlett2_data *private = mixer->private_data; in scarlett2_mute_ctl_get() local
4004 int index = line_out_remap(private, elem->control); in scarlett2_mute_ctl_get()
4007 mutex_lock(&private->data_mutex); in scarlett2_mute_ctl_get()
4009 if (private->hwdep_in_use) { in scarlett2_mute_ctl_get()
4014 if (private->dim_mute_updated) { in scarlett2_mute_ctl_get()
4019 ucontrol->value.integer.value[0] = private->mute_switch[index]; in scarlett2_mute_ctl_get()
4022 mutex_unlock(&private->data_mutex); in scarlett2_mute_ctl_get()
4031 struct scarlett2_data *private = mixer->private_data; in scarlett2_mute_ctl_put() local
4032 int index = line_out_remap(private, elem->control); in scarlett2_mute_ctl_put()
4035 mutex_lock(&private->data_mutex); in scarlett2_mute_ctl_put()
4037 if (private->hwdep_in_use) { in scarlett2_mute_ctl_put()
4042 oval = private->mute_switch[index]; in scarlett2_mute_ctl_put()
4048 private->mute_switch[index] = val; in scarlett2_mute_ctl_put()
4057 mutex_unlock(&private->data_mutex); in scarlett2_mute_ctl_put()
4071 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index) in scarlett2_sw_hw_ctl_ro() argument
4073 private->sw_hw_ctls[index]->vd[0].access &= in scarlett2_sw_hw_ctl_ro()
4077 static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index) in scarlett2_sw_hw_ctl_rw() argument
4079 private->sw_hw_ctls[index]->vd[0].access |= in scarlett2_sw_hw_ctl_rw()
4097 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_sw_hw_enum_ctl_get() local
4098 int index = line_out_remap(private, elem->control); in scarlett2_sw_hw_enum_ctl_get()
4100 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index]; in scarlett2_sw_hw_enum_ctl_get()
4107 struct scarlett2_data *private = mixer->private_data; in scarlett2_vol_ctl_set_writable() local
4112 private->vol_ctls[index]->vd[0].access |= in scarlett2_vol_ctl_set_writable()
4114 private->mute_ctls[index]->vd[0].access |= in scarlett2_vol_ctl_set_writable()
4117 private->vol_ctls[index]->vd[0].access &= in scarlett2_vol_ctl_set_writable()
4119 private->mute_ctls[index]->vd[0].access &= in scarlett2_vol_ctl_set_writable()
4126 &private->vol_ctls[index]->id); in scarlett2_vol_ctl_set_writable()
4129 &private->mute_ctls[index]->id); in scarlett2_vol_ctl_set_writable()
4135 struct scarlett2_data *private = mixer->private_data; in scarlett2_sw_hw_change() local
4136 int index = line_out_remap(private, ctl_index); in scarlett2_sw_hw_change()
4139 private->vol_sw_hw_switch[index] = val; in scarlett2_sw_hw_change()
4147 private->vol[index] = private->master_vol; in scarlett2_sw_hw_change()
4148 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE]; in scarlett2_sw_hw_change()
4153 index, private->master_vol - SCARLETT2_VOLUME_BIAS); in scarlett2_sw_hw_change()
4160 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]); in scarlett2_sw_hw_change()
4174 struct scarlett2_data *private = mixer->private_data; in scarlett2_sw_hw_enum_ctl_put() local
4176 int index = line_out_remap(private, ctl_index); in scarlett2_sw_hw_enum_ctl_put()
4179 mutex_lock(&private->data_mutex); in scarlett2_sw_hw_enum_ctl_put()
4181 if (private->hwdep_in_use) { in scarlett2_sw_hw_enum_ctl_put()
4186 oval = private->vol_sw_hw_switch[index]; in scarlett2_sw_hw_enum_ctl_put()
4197 mutex_unlock(&private->data_mutex); in scarlett2_sw_hw_enum_ctl_put()
4213 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_level() local
4214 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_level()
4216 private->input_level_updated = 0; in scarlett2_update_input_level()
4224 private->level_switch); in scarlett2_update_input_level()
4235 struct scarlett2_data *private = mixer->private_data; in scarlett2_level_enum_ctl_info() local
4238 mutex_lock(&private->data_mutex); in scarlett2_level_enum_ctl_info()
4240 if (private->hwdep_in_use) { in scarlett2_level_enum_ctl_info()
4252 mutex_unlock(&private->data_mutex); in scarlett2_level_enum_ctl_info()
4261 struct scarlett2_data *private = mixer->private_data; in scarlett2_level_enum_ctl_get() local
4262 const struct scarlett2_device_info *info = private->info; in scarlett2_level_enum_ctl_get()
4267 mutex_lock(&private->data_mutex); in scarlett2_level_enum_ctl_get()
4269 if (private->hwdep_in_use) { in scarlett2_level_enum_ctl_get()
4274 if (private->input_level_updated) { in scarlett2_level_enum_ctl_get()
4280 private->level_switch[index]); in scarlett2_level_enum_ctl_get()
4283 mutex_unlock(&private->data_mutex); in scarlett2_level_enum_ctl_get()
4292 struct scarlett2_data *private = mixer->private_data; in scarlett2_level_enum_ctl_put() local
4293 const struct scarlett2_device_info *info = private->info; in scarlett2_level_enum_ctl_put()
4298 mutex_lock(&private->data_mutex); in scarlett2_level_enum_ctl_put()
4300 if (private->hwdep_in_use) { in scarlett2_level_enum_ctl_put()
4309 oval = private->level_switch[index]; in scarlett2_level_enum_ctl_put()
4315 private->level_switch[index] = val; in scarlett2_level_enum_ctl_put()
4318 if (private->config_set->items[SCARLETT2_CONFIG_LEVEL_SWITCH].mute) in scarlett2_level_enum_ctl_put()
4328 mutex_unlock(&private->data_mutex); in scarlett2_level_enum_ctl_put()
4344 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_pad() local
4345 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_pad()
4347 private->input_pad_updated = 0; in scarlett2_update_input_pad()
4354 info->pad_input_count, private->pad_switch); in scarlett2_update_input_pad()
4362 struct scarlett2_data *private = mixer->private_data; in scarlett2_pad_ctl_get() local
4365 mutex_lock(&private->data_mutex); in scarlett2_pad_ctl_get()
4367 if (private->hwdep_in_use) { in scarlett2_pad_ctl_get()
4372 if (private->input_pad_updated) { in scarlett2_pad_ctl_get()
4378 private->pad_switch[elem->control]; in scarlett2_pad_ctl_get()
4381 mutex_unlock(&private->data_mutex); in scarlett2_pad_ctl_get()
4390 struct scarlett2_data *private = mixer->private_data; in scarlett2_pad_ctl_put() local
4395 mutex_lock(&private->data_mutex); in scarlett2_pad_ctl_put()
4397 if (private->hwdep_in_use) { in scarlett2_pad_ctl_put()
4402 oval = private->pad_switch[index]; in scarlett2_pad_ctl_put()
4408 private->pad_switch[index] = val; in scarlett2_pad_ctl_put()
4417 mutex_unlock(&private->data_mutex); in scarlett2_pad_ctl_put()
4433 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_air() local
4434 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_air()
4436 private->input_air_updated = 0; in scarlett2_update_input_air()
4443 info->air_input_count, private->air_switch); in scarlett2_update_input_air()
4451 struct scarlett2_data *private = mixer->private_data; in scarlett2_air_ctl_get() local
4454 mutex_lock(&private->data_mutex); in scarlett2_air_ctl_get()
4456 if (private->hwdep_in_use) { in scarlett2_air_ctl_get()
4461 if (private->input_air_updated) { in scarlett2_air_ctl_get()
4466 ucontrol->value.integer.value[0] = private->air_switch[elem->control]; in scarlett2_air_ctl_get()
4469 mutex_unlock(&private->data_mutex); in scarlett2_air_ctl_get()
4478 struct scarlett2_data *private = mixer->private_data; in scarlett2_air_ctl_put() local
4483 mutex_lock(&private->data_mutex); in scarlett2_air_ctl_put()
4485 if (private->hwdep_in_use) { in scarlett2_air_ctl_put()
4494 oval = private->air_switch[index]; in scarlett2_air_ctl_put()
4500 private->air_switch[index] = val; in scarlett2_air_ctl_put()
4509 mutex_unlock(&private->data_mutex); in scarlett2_air_ctl_put()
4521 struct scarlett2_data *private = mixer->private_data; in scarlett2_air_with_drive_ctl_info() local
4524 mutex_lock(&private->data_mutex); in scarlett2_air_with_drive_ctl_info()
4526 if (private->hwdep_in_use) { in scarlett2_air_with_drive_ctl_info()
4538 mutex_unlock(&private->data_mutex); in scarlett2_air_with_drive_ctl_info()
4563 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_input_phantom() local
4564 const struct scarlett2_device_info *info = private->info; in scarlett2_update_input_phantom()
4567 private->input_phantom_updated = 0; in scarlett2_update_input_phantom()
4574 info->phantom_count, private->phantom_switch); in scarlett2_update_input_phantom()
4578 if (scarlett2_has_config_item(private, in scarlett2_update_input_phantom()
4582 1, &private->phantom_persistence); in scarlett2_update_input_phantom()
4592 struct scarlett2_data *private, int line_num) in scarlett2_phantom_is_switching() argument
4594 const struct scarlett2_device_info *info = private->info; in scarlett2_phantom_is_switching()
4597 return !!(private->phantom_switch[index] & 0x02); in scarlett2_phantom_is_switching()
4603 struct scarlett2_data *private = mixer->private_data; in scarlett2_phantom_update_access() local
4604 const struct scarlett2_device_info *info = private->info; in scarlett2_phantom_update_access()
4609 int val = !scarlett2_phantom_is_switching(private, i); in scarlett2_phantom_update_access()
4611 scarlett2_set_ctl_access(private->autogain_ctls[i], val); in scarlett2_phantom_update_access()
4621 struct scarlett2_data *private = mixer->private_data; in scarlett2_phantom_notify_access() local
4622 const struct scarlett2_device_info *info = private->info; in scarlett2_phantom_notify_access()
4627 &private->autogain_ctls[i]->id); in scarlett2_phantom_notify_access()
4636 struct scarlett2_data *private = mixer->private_data; in scarlett2_check_input_phantom_updated() local
4639 if (!private->input_phantom_updated) in scarlett2_check_input_phantom_updated()
4656 struct scarlett2_data *private = mixer->private_data; in scarlett2_phantom_ctl_get() local
4659 mutex_lock(&private->data_mutex); in scarlett2_phantom_ctl_get()
4661 if (private->hwdep_in_use) { in scarlett2_phantom_ctl_get()
4671 private->phantom_switch[elem->control]); in scarlett2_phantom_ctl_get()
4674 mutex_unlock(&private->data_mutex); in scarlett2_phantom_ctl_get()
4683 struct scarlett2_data *private = mixer->private_data; in scarlett2_phantom_ctl_put() local
4684 const struct scarlett2_device_info *info = private->info; in scarlett2_phantom_ctl_put()
4689 mutex_lock(&private->data_mutex); in scarlett2_phantom_ctl_put()
4691 if (private->hwdep_in_use) { in scarlett2_phantom_ctl_put()
4700 oval = private->phantom_switch[index]; in scarlett2_phantom_ctl_put()
4706 private->phantom_switch[index] = val; in scarlett2_phantom_ctl_put()
4709 if (private->config_set->items[SCARLETT2_CONFIG_PHANTOM_SWITCH].mute) in scarlett2_phantom_ctl_put()
4722 mutex_unlock(&private->data_mutex); in scarlett2_phantom_ctl_put()
4740 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_phantom_persistence_ctl_get() local
4742 ucontrol->value.integer.value[0] = private->phantom_persistence; in scarlett2_phantom_persistence_ctl_get()
4751 struct scarlett2_data *private = mixer->private_data; in scarlett2_phantom_persistence_ctl_put() local
4756 mutex_lock(&private->data_mutex); in scarlett2_phantom_persistence_ctl_put()
4758 if (private->hwdep_in_use) { in scarlett2_phantom_persistence_ctl_put()
4763 oval = private->phantom_persistence; in scarlett2_phantom_persistence_ctl_put()
4769 private->phantom_persistence = val; in scarlett2_phantom_persistence_ctl_put()
4778 mutex_unlock(&private->data_mutex); in scarlett2_phantom_persistence_ctl_put()
4794 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_monitor_other() local
4795 const struct scarlett2_device_info *info = private->info; in scarlett2_update_monitor_other()
4808 private->monitor_other_updated = 0; in scarlett2_update_monitor_other()
4829 private->speaker_switching_switch = 0; in scarlett2_update_monitor_other()
4831 private->speaker_switching_switch = monitor_other_switch[0] + 1; in scarlett2_update_monitor_other()
4838 private->talkback_switch = 0; in scarlett2_update_monitor_other()
4840 private->talkback_switch = monitor_other_switch[1] + 1; in scarlett2_update_monitor_other()
4847 for (i = 0; i < private->num_mix_out; i++, bitmap >>= 1) in scarlett2_update_monitor_other()
4848 private->talkback_map[i] = bitmap & 1; in scarlett2_update_monitor_other()
4869 struct scarlett2_data *private = mixer->private_data; in scarlett2_speaker_switch_enum_ctl_get() local
4872 mutex_lock(&private->data_mutex); in scarlett2_speaker_switch_enum_ctl_get()
4874 if (private->hwdep_in_use) { in scarlett2_speaker_switch_enum_ctl_get()
4879 if (private->monitor_other_updated) { in scarlett2_speaker_switch_enum_ctl_get()
4884 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch; in scarlett2_speaker_switch_enum_ctl_get()
4887 mutex_unlock(&private->data_mutex); in scarlett2_speaker_switch_enum_ctl_get()
4897 struct scarlett2_data *private = mixer->private_data; in scarlett2_speaker_switch_enable() local
4901 int index = line_out_remap(private, i); in scarlett2_speaker_switch_enable()
4904 if (!private->vol_sw_hw_switch[index]) { in scarlett2_speaker_switch_enable()
4905 err = scarlett2_sw_hw_change(private->mixer, i, 1); in scarlett2_speaker_switch_enable()
4911 scarlett2_sw_hw_ctl_ro(private, i); in scarlett2_speaker_switch_enable()
4915 &private->sw_hw_ctls[i]->id); in scarlett2_speaker_switch_enable()
4921 private->speaker_switching_switched = 1; in scarlett2_speaker_switch_enable()
4932 struct scarlett2_data *private = mixer->private_data; in scarlett2_speaker_switch_disable() local
4937 scarlett2_sw_hw_ctl_rw(private, i); in scarlett2_speaker_switch_disable()
4939 &private->sw_hw_ctls[i]->id); in scarlett2_speaker_switch_disable()
4945 private->speaker_switching_switched = 1; in scarlett2_speaker_switch_disable()
4953 struct scarlett2_data *private = mixer->private_data; in scarlett2_speaker_switch_enum_ctl_put() local
4957 mutex_lock(&private->data_mutex); in scarlett2_speaker_switch_enum_ctl_put()
4959 if (private->hwdep_in_use) { in scarlett2_speaker_switch_enum_ctl_put()
4964 oval = private->speaker_switching_switch; in scarlett2_speaker_switch_enum_ctl_put()
4970 private->speaker_switching_switch = val; in scarlett2_speaker_switch_enum_ctl_put()
4996 mutex_unlock(&private->data_mutex); in scarlett2_speaker_switch_enum_ctl_put()
5010 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_speaker_switch_ctl() local
5011 const struct scarlett2_device_info *info = private->info; in scarlett2_add_speaker_switch_ctl()
5019 &private->speaker_switching_ctl); in scarlett2_add_speaker_switch_ctl()
5039 struct scarlett2_data *private = mixer->private_data; in scarlett2_talkback_enum_ctl_get() local
5042 mutex_lock(&private->data_mutex); in scarlett2_talkback_enum_ctl_get()
5044 if (private->hwdep_in_use) { in scarlett2_talkback_enum_ctl_get()
5049 if (private->monitor_other_updated) { in scarlett2_talkback_enum_ctl_get()
5054 ucontrol->value.enumerated.item[0] = private->talkback_switch; in scarlett2_talkback_enum_ctl_get()
5057 mutex_unlock(&private->data_mutex); in scarlett2_talkback_enum_ctl_get()
5066 struct scarlett2_data *private = mixer->private_data; in scarlett2_talkback_enum_ctl_put() local
5070 mutex_lock(&private->data_mutex); in scarlett2_talkback_enum_ctl_put()
5072 if (private->hwdep_in_use) { in scarlett2_talkback_enum_ctl_put()
5077 oval = private->talkback_switch; in scarlett2_talkback_enum_ctl_put()
5083 private->talkback_switch = val; in scarlett2_talkback_enum_ctl_put()
5100 mutex_unlock(&private->data_mutex); in scarlett2_talkback_enum_ctl_put()
5117 struct scarlett2_data *private = mixer->private_data; in scarlett2_talkback_map_ctl_get() local
5120 ucontrol->value.integer.value[0] = private->talkback_map[index]; in scarlett2_talkback_map_ctl_get()
5130 struct scarlett2_data *private = mixer->private_data; in scarlett2_talkback_map_ctl_put() local
5135 mutex_lock(&private->data_mutex); in scarlett2_talkback_map_ctl_put()
5137 if (private->hwdep_in_use) { in scarlett2_talkback_map_ctl_put()
5142 oval = private->talkback_map[index]; in scarlett2_talkback_map_ctl_put()
5148 private->talkback_map[index] = val; in scarlett2_talkback_map_ctl_put()
5150 for (i = 0; i < private->num_mix_out; i++) in scarlett2_talkback_map_ctl_put()
5151 bitmap |= private->talkback_map[i] << i; in scarlett2_talkback_map_ctl_put()
5160 mutex_unlock(&private->data_mutex); in scarlett2_talkback_map_ctl_put()
5174 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_talkback_ctls() local
5175 const struct scarlett2_device_info *info = private->info; in scarlett2_add_talkback_ctls()
5185 &private->talkback_ctl); in scarlett2_add_talkback_ctls()
5189 for (i = 0; i < private->num_mix_out; i++) { in scarlett2_add_talkback_ctls()
5208 struct scarlett2_data *private = mixer->private_data; in scarlett2_dim_mute_ctl_get() local
5211 mutex_lock(&private->data_mutex); in scarlett2_dim_mute_ctl_get()
5213 if (private->hwdep_in_use) { in scarlett2_dim_mute_ctl_get()
5218 if (private->dim_mute_updated) { in scarlett2_dim_mute_ctl_get()
5223 ucontrol->value.integer.value[0] = private->dim_mute[elem->control]; in scarlett2_dim_mute_ctl_get()
5226 mutex_unlock(&private->data_mutex); in scarlett2_dim_mute_ctl_get()
5235 struct scarlett2_data *private = mixer->private_data; in scarlett2_dim_mute_ctl_put() local
5239 mutex_lock(&private->data_mutex); in scarlett2_dim_mute_ctl_put()
5241 if (private->hwdep_in_use) { in scarlett2_dim_mute_ctl_put()
5246 oval = private->dim_mute[index]; in scarlett2_dim_mute_ctl_put()
5252 private->dim_mute[index] = val; in scarlett2_dim_mute_ctl_put()
5261 for (i = 0; i < private->num_line_out; i++) { in scarlett2_dim_mute_ctl_put()
5262 int line_index = line_out_remap(private, i); in scarlett2_dim_mute_ctl_put()
5264 if (private->vol_sw_hw_switch[line_index]) { in scarlett2_dim_mute_ctl_put()
5265 private->mute_switch[line_index] = val; in scarlett2_dim_mute_ctl_put()
5268 &private->mute_ctls[i]->id); in scarlett2_dim_mute_ctl_put()
5273 mutex_unlock(&private->data_mutex); in scarlett2_dim_mute_ctl_put()
5289 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_line_out_ctls() local
5290 const struct scarlett2_device_info *info = private->info; in scarlett2_add_line_out_ctls()
5295 if (scarlett2_has_config_item(private, in scarlett2_add_line_out_ctls()
5300 0, 1, s, &private->master_vol_ctl); in scarlett2_add_line_out_ctls()
5306 if (scarlett2_has_config_item(private, in scarlett2_add_line_out_ctls()
5312 &private->headphone_vol_ctl); in scarlett2_add_line_out_ctls()
5320 if (!scarlett2_has_config_item(private, in scarlett2_add_line_out_ctls()
5325 for (i = 0; i < private->num_line_out; i++) { in scarlett2_add_line_out_ctls()
5326 int index = line_out_remap(private, i); in scarlett2_add_line_out_ctls()
5339 i, 1, s, &private->vol_ctls[i]); in scarlett2_add_line_out_ctls()
5350 &private->mute_ctls[i]); in scarlett2_add_line_out_ctls()
5355 if (scarlett2_has_config_item(private, in scarlett2_add_line_out_ctls()
5361 if (private->vol_sw_hw_switch[index]) in scarlett2_add_line_out_ctls()
5370 &private->sw_hw_ctls[i]); in scarlett2_add_line_out_ctls()
5377 if (private->speaker_switching_switch && i < 4) in scarlett2_add_line_out_ctls()
5378 scarlett2_sw_hw_ctl_ro(private, i); in scarlett2_add_line_out_ctls()
5383 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_DIM_MUTE)) in scarlett2_add_line_out_ctls()
5388 &private->dim_mute_ctls[i]); in scarlett2_add_line_out_ctls()
5400 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_line_in_ctls() local
5401 const struct scarlett2_device_info *info = private->info; in scarlett2_add_line_in_ctls()
5412 i, 1, s, &private->level_ctls[i]); in scarlett2_add_line_in_ctls()
5421 i, 1, s, &private->pad_ctls[i]); in scarlett2_add_line_in_ctls()
5432 i, 1, s, &private->air_ctls[i]); in scarlett2_add_line_in_ctls()
5445 i, 1, s, &private->phantom_ctls[i]); in scarlett2_add_line_in_ctls()
5458 i, 1, s, &private->phantom_ctls[i]); in scarlett2_add_line_in_ctls()
5464 scarlett2_has_config_item(private, in scarlett2_add_line_in_ctls()
5478 &private->input_select_ctl); in scarlett2_add_line_in_ctls()
5490 &private->input_link_ctls[i / 2]); in scarlett2_add_line_in_ctls()
5499 i, 1, s, &private->input_gain_ctls[i]); in scarlett2_add_line_in_ctls()
5507 i, 1, s, &private->autogain_ctls[i]); in scarlett2_add_line_in_ctls()
5515 i, 1, s, &private->autogain_status_ctls[i]); in scarlett2_add_line_in_ctls()
5521 i, 1, s, &private->safe_ctls[i]); in scarlett2_add_line_in_ctls()
5528 if (scarlett2_has_config_item(private, in scarlett2_add_line_in_ctls()
5533 &private->pcm_input_switch_ctl); in scarlett2_add_line_in_ctls()
5545 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_mix() local
5548 private->mix_updated = 0; in scarlett2_update_mix()
5550 for (i = 0; i < private->num_mix_out; i++) { in scarlett2_update_mix()
5577 struct scarlett2_data *private = mixer->private_data; in scarlett2_mixer_ctl_get() local
5580 mutex_lock(&private->data_mutex); in scarlett2_mixer_ctl_get()
5582 if (private->hwdep_in_use) { in scarlett2_mixer_ctl_get()
5587 if (private->mix_updated) { in scarlett2_mixer_ctl_get()
5592 ucontrol->value.integer.value[0] = private->mix[elem->control]; in scarlett2_mixer_ctl_get()
5595 mutex_unlock(&private->data_mutex); in scarlett2_mixer_ctl_get()
5604 struct scarlett2_data *private = mixer->private_data; in scarlett2_mixer_ctl_put() local
5608 mutex_lock(&private->data_mutex); in scarlett2_mixer_ctl_put()
5610 if (private->hwdep_in_use) { in scarlett2_mixer_ctl_put()
5615 oval = private->mix[index]; in scarlett2_mixer_ctl_put()
5618 mix_num = index / private->num_mix_in; in scarlett2_mixer_ctl_put()
5623 private->mix[index] = val; in scarlett2_mixer_ctl_put()
5629 mutex_unlock(&private->data_mutex); in scarlett2_mixer_ctl_put()
5653 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_mixer_ctls() local
5658 for (i = 0, index = 0; i < private->num_mix_out; i++) in scarlett2_add_mixer_ctls()
5659 for (j = 0; j < private->num_mix_in; j++, index++) { in scarlett2_add_mixer_ctls()
5665 &private->mix_ctls[index]); in scarlett2_add_mixer_ctls()
5677 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_direct_monitor() local
5679 private->direct_monitor_updated = 0; in scarlett2_update_direct_monitor()
5681 if (!private->info->direct_monitor) in scarlett2_update_direct_monitor()
5686 1, &private->direct_monitor_switch); in scarlett2_update_direct_monitor()
5691 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_monitor_mix() local
5695 if (!private->num_monitor_mix_ctls) in scarlett2_update_monitor_mix()
5700 private->num_monitor_mix_ctls, mix_values); in scarlett2_update_monitor_mix()
5704 for (i = 0; i < private->num_monitor_mix_ctls; i++) in scarlett2_update_monitor_mix()
5705 private->monitor_mix[i] = scarlett2_mixer_value_to_db( in scarlett2_update_monitor_mix()
5716 struct scarlett2_data *private = mixer->private_data; in scarlett2_direct_monitor_ctl_get() local
5719 mutex_lock(&private->data_mutex); in scarlett2_direct_monitor_ctl_get()
5721 if (private->hwdep_in_use) { in scarlett2_direct_monitor_ctl_get()
5726 if (private->direct_monitor_updated) { in scarlett2_direct_monitor_ctl_get()
5731 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch; in scarlett2_direct_monitor_ctl_get()
5734 mutex_unlock(&private->data_mutex); in scarlett2_direct_monitor_ctl_get()
5743 struct scarlett2_data *private = mixer->private_data; in scarlett2_direct_monitor_ctl_put() local
5748 mutex_lock(&private->data_mutex); in scarlett2_direct_monitor_ctl_put()
5750 if (private->hwdep_in_use) { in scarlett2_direct_monitor_ctl_put()
5755 oval = private->direct_monitor_switch; in scarlett2_direct_monitor_ctl_put()
5761 private->direct_monitor_switch = val; in scarlett2_direct_monitor_ctl_put()
5770 mutex_unlock(&private->data_mutex); in scarlett2_direct_monitor_ctl_put()
5808 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_monitor_mix_ctl_get() local
5810 ucontrol->value.integer.value[0] = private->monitor_mix[elem->control]; in scarlett2_monitor_mix_ctl_get()
5820 struct scarlett2_data *private = mixer->private_data; in scarlett2_monitor_mix_ctl_put() local
5824 mutex_lock(&private->data_mutex); in scarlett2_monitor_mix_ctl_put()
5826 if (private->hwdep_in_use) { in scarlett2_monitor_mix_ctl_put()
5831 oval = private->monitor_mix[index]; in scarlett2_monitor_mix_ctl_put()
5838 private->monitor_mix[index] = val; in scarlett2_monitor_mix_ctl_put()
5846 mutex_unlock(&private->data_mutex); in scarlett2_monitor_mix_ctl_put()
5864 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_direct_monitor_ctls() local
5865 const struct scarlett2_device_info *info = private->info; in scarlett2_add_direct_monitor_ctls()
5878 0, 1, s, &private->direct_monitor_ctl); in scarlett2_add_direct_monitor_ctls()
5882 if (!private->num_monitor_mix_ctls) in scarlett2_add_direct_monitor_ctls()
5902 for (k = 0; k < private->num_mix_in; k++, index++) { in scarlett2_add_direct_monitor_ctls()
5925 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_mux_src_enum_ctl_info() local
5926 const struct scarlett2_device_info *info = private->info; in scarlett2_mux_src_enum_ctl_info()
5929 int items = private->num_mux_srcs; in scarlett2_mux_src_enum_ctl_info()
5947 item >= private->num_mix_out) in scarlett2_mux_src_enum_ctl_info()
5950 item - private->num_mix_out + 1); in scarlett2_mux_src_enum_ctl_info()
5969 struct scarlett2_data *private = mixer->private_data; in scarlett2_mux_src_enum_ctl_get() local
5970 int index = line_out_remap(private, elem->control); in scarlett2_mux_src_enum_ctl_get()
5973 mutex_lock(&private->data_mutex); in scarlett2_mux_src_enum_ctl_get()
5975 if (private->hwdep_in_use) { in scarlett2_mux_src_enum_ctl_get()
5980 if (private->mux_updated) { in scarlett2_mux_src_enum_ctl_get()
5985 ucontrol->value.enumerated.item[0] = private->mux[index]; in scarlett2_mux_src_enum_ctl_get()
5988 mutex_unlock(&private->data_mutex); in scarlett2_mux_src_enum_ctl_get()
5997 struct scarlett2_data *private = mixer->private_data; in scarlett2_mux_src_enum_ctl_put() local
5998 int index = line_out_remap(private, elem->control); in scarlett2_mux_src_enum_ctl_put()
6001 mutex_lock(&private->data_mutex); in scarlett2_mux_src_enum_ctl_put()
6003 if (private->hwdep_in_use) { in scarlett2_mux_src_enum_ctl_put()
6008 oval = private->mux[index]; in scarlett2_mux_src_enum_ctl_put()
6010 private->num_mux_srcs - 1U); in scarlett2_mux_src_enum_ctl_put()
6015 private->mux[index] = val; in scarlett2_mux_src_enum_ctl_put()
6021 mutex_unlock(&private->data_mutex); in scarlett2_mux_src_enum_ctl_put()
6035 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_mux_enums() local
6036 const struct scarlett2_device_info *info = private->info; in scarlett2_add_mux_enums()
6054 channel >= private->num_mix_in) { in scarlett2_add_mux_enums()
6055 channel_num -= private->num_mix_in; in scarlett2_add_mux_enums()
6065 &private->mux_ctls[i]); in scarlett2_add_mux_enums()
6094 struct scarlett2_data *private = mixer->private_data; in scarlett2_meter_ctl_get() local
6095 u8 *meter_level_map = private->meter_level_map; in scarlett2_meter_ctl_get()
6099 mutex_lock(&private->data_mutex); in scarlett2_meter_ctl_get()
6101 if (private->hwdep_in_use) { in scarlett2_meter_ctl_get()
6125 mutex_unlock(&private->data_mutex); in scarlett2_meter_ctl_get()
6140 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_meter_ctl() local
6143 if (!scarlett2_has_mixer(private)) in scarlett2_add_meter_ctl()
6147 0, private->num_mux_dsts, in scarlett2_add_meter_ctl()
6157 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_msd_ctl_get() local
6159 ucontrol->value.integer.value[0] = private->msd_switch; in scarlett2_msd_ctl_get()
6168 struct scarlett2_data *private = mixer->private_data; in scarlett2_msd_ctl_put() local
6172 mutex_lock(&private->data_mutex); in scarlett2_msd_ctl_put()
6174 if (private->hwdep_in_use) { in scarlett2_msd_ctl_put()
6179 oval = private->msd_switch; in scarlett2_msd_ctl_put()
6185 private->msd_switch = val; in scarlett2_msd_ctl_put()
6194 mutex_unlock(&private->data_mutex); in scarlett2_msd_ctl_put()
6208 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_msd_ctl() local
6210 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) in scarlett2_add_msd_ctl()
6214 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE)) in scarlett2_add_msd_ctl()
6228 struct scarlett2_data *private = elem->head.mixer->private_data; in scarlett2_standalone_ctl_get() local
6230 ucontrol->value.integer.value[0] = private->standalone_switch; in scarlett2_standalone_ctl_get()
6239 struct scarlett2_data *private = mixer->private_data; in scarlett2_standalone_ctl_put() local
6243 mutex_lock(&private->data_mutex); in scarlett2_standalone_ctl_put()
6245 if (private->hwdep_in_use) { in scarlett2_standalone_ctl_put()
6250 oval = private->standalone_switch; in scarlett2_standalone_ctl_put()
6256 private->standalone_switch = val; in scarlett2_standalone_ctl_put()
6266 mutex_unlock(&private->data_mutex); in scarlett2_standalone_ctl_put()
6280 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_standalone_ctl() local
6282 if (!scarlett2_has_config_item(private, in scarlett2_add_standalone_ctl()
6295 struct scarlett2_data *private = mixer->private_data; in scarlett2_update_power_status() local
6300 private->power_status_updated = 0; in scarlett2_update_power_status()
6313 private->power_status = SCARLETT2_POWER_STATUS_FAIL; in scarlett2_update_power_status()
6315 private->power_status = SCARLETT2_POWER_STATUS_EXT; in scarlett2_update_power_status()
6317 private->power_status = SCARLETT2_POWER_STATUS_BUS; in scarlett2_update_power_status()
6327 struct scarlett2_data *private = mixer->private_data; in scarlett2_power_status_ctl_get() local
6330 mutex_lock(&private->data_mutex); in scarlett2_power_status_ctl_get()
6332 if (private->power_status_updated) { in scarlett2_power_status_ctl_get()
6337 ucontrol->value.integer.value[0] = private->power_status; in scarlett2_power_status_ctl_get()
6340 mutex_unlock(&private->data_mutex); in scarlett2_power_status_ctl_get()
6364 struct scarlett2_data *private = mixer->private_data; in scarlett2_add_power_status_ctl() local
6366 if (!scarlett2_has_config_item(private, in scarlett2_add_power_status_ctl()
6373 &private->power_status_ctl); in scarlett2_add_power_status_ctl()
6380 struct scarlett2_data *private = mixer->private_data; in scarlett2_private_free() local
6382 cancel_delayed_work_sync(&private->work); in scarlett2_private_free()
6383 kfree(private); in scarlett2_private_free()
6389 struct scarlett2_data *private = mixer->private_data; in scarlett2_private_suspend() local
6391 if (cancel_delayed_work_sync(&private->work)) in scarlett2_private_suspend()
6392 scarlett2_config_save(private->mixer); in scarlett2_private_suspend()
6397 static void scarlett2_count_io(struct scarlett2_data *private) in scarlett2_count_io() argument
6399 const struct scarlett2_device_info *info = private->info; in scarlett2_count_io()
6411 private->num_mux_srcs = srcs; in scarlett2_count_io()
6412 private->num_mux_dsts = dsts; in scarlett2_count_io()
6418 private->num_mix_in = in scarlett2_count_io()
6422 private->num_mix_out = in scarlett2_count_io()
6427 private->num_line_out = in scarlett2_count_io()
6431 private->num_monitor_mix_ctls = in scarlett2_count_io()
6432 info->direct_monitor * 2 * private->num_mix_in; in scarlett2_count_io()
6438 * in private
6441 struct scarlett2_data *private) in scarlett2_find_fc_interface() argument
6456 private->bInterfaceNumber = desc->bInterfaceNumber; in scarlett2_find_fc_interface()
6457 private->bEndpointAddress = epd->bEndpointAddress & in scarlett2_find_fc_interface()
6459 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize); in scarlett2_find_fc_interface()
6460 private->bInterval = epd->bInterval; in scarlett2_find_fc_interface()
6467 /* Initialise private data */
6471 struct scarlett2_data *private = in scarlett2_init_private() local
6474 if (!private) in scarlett2_init_private()
6477 mutex_init(&private->usb_mutex); in scarlett2_init_private()
6478 mutex_init(&private->data_mutex); in scarlett2_init_private()
6479 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work); in scarlett2_init_private()
6481 mixer->private_data = private; in scarlett2_init_private()
6485 private->info = entry->info; in scarlett2_init_private()
6486 private->config_set = entry->info->config_set; in scarlett2_init_private()
6487 private->series_name = entry->series_name; in scarlett2_init_private()
6488 scarlett2_count_io(private); in scarlett2_init_private()
6489 private->scarlett2_seq = 0; in scarlett2_init_private()
6490 private->mixer = mixer; in scarlett2_init_private()
6492 return scarlett2_find_fc_interface(mixer->chip->dev, private); in scarlett2_init_private()
6499 struct scarlett2_data *private = mixer->private_data; in scarlett2_usb_init() local
6508 err = scarlett2_usb_rx(dev, private->bInterfaceNumber, in scarlett2_usb_init()
6515 private->scarlett2_seq = 1; in scarlett2_usb_init()
6521 private->scarlett2_seq = 1; in scarlett2_usb_init()
6529 private->firmware_version = le32_to_cpu(*(__le32 *)(step2_buf + 8)); in scarlett2_usb_init()
6532 private->firmware_version); in scarlett2_usb_init()
6538 * segments and put them in the private data
6542 struct scarlett2_data *private = mixer->private_data; in scarlett2_get_flash_segment_nums() local
6596 private->flash_segment_nums[flash_segment_id] = i; in scarlett2_get_flash_segment_nums()
6597 private->flash_segment_blocks[flash_segment_id] = in scarlett2_get_flash_segment_nums()
6605 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_SETTINGS]) { in scarlett2_get_flash_segment_nums()
6611 if (!private->flash_segment_nums[SCARLETT2_SEGMENT_ID_FIRMWARE]) { in scarlett2_get_flash_segment_nums()
6624 struct scarlett2_data *private = mixer->private_data; in scarlett2_read_configs() local
6625 const struct scarlett2_device_info *info = private->info; in scarlett2_read_configs()
6628 if (scarlett2_has_config_item(private, SCARLETT2_CONFIG_MSD_SWITCH)) { in scarlett2_read_configs()
6631 1, &private->msd_switch); in scarlett2_read_configs()
6636 if (private->firmware_version < info->min_firmware_version) { in scarlett2_read_configs()
6640 private->series_name, in scarlett2_read_configs()
6641 private->firmware_version, in scarlett2_read_configs()
6647 if (private->msd_switch) in scarlett2_read_configs()
6671 if (!scarlett2_has_mixer(private)) in scarlett2_read_configs()
6682 if (scarlett2_has_config_item(private, in scarlett2_read_configs()
6686 1, &private->standalone_switch); in scarlett2_read_configs()
6691 if (scarlett2_has_config_item(private, in scarlett2_read_configs()
6702 if (scarlett2_has_config_item(private, in scarlett2_read_configs()
6709 private->num_line_out, &sw_vol); in scarlett2_read_configs()
6713 for (i = 0; i < private->num_line_out; i++) in scarlett2_read_configs()
6714 private->vol[i] = clamp( in scarlett2_read_configs()
6721 private->num_line_out, &private->mute_switch); in scarlett2_read_configs()
6725 for (i = 0; i < private->num_line_out; i++) in scarlett2_read_configs()
6726 private->mute_switch[i] = in scarlett2_read_configs()
6727 !!private->mute_switch[i]; in scarlett2_read_configs()
6730 if (scarlett2_has_config_item(private, in scarlett2_read_configs()
6734 private->num_line_out, in scarlett2_read_configs()
6735 &private->vol_sw_hw_switch); in scarlett2_read_configs()
6739 for (i = 0; i < private->num_line_out; i++) in scarlett2_read_configs()
6740 private->vol_sw_hw_switch[i] = in scarlett2_read_configs()
6741 !!private->vol_sw_hw_switch[i]; in scarlett2_read_configs()
6769 if (scarlett2_has_config_item(private, in scarlett2_read_configs()
6786 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_sync() local
6788 private->sync_updated = 1; in scarlett2_notify_sync()
6791 &private->sync_ctl->id); in scarlett2_notify_sync()
6798 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_monitor() local
6801 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) in scarlett2_notify_monitor()
6804 private->vol_updated = 1; in scarlett2_notify_monitor()
6807 &private->master_vol_ctl->id); in scarlett2_notify_monitor()
6809 for (i = 0; i < private->num_line_out; i++) in scarlett2_notify_monitor()
6810 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) in scarlett2_notify_monitor()
6812 &private->vol_ctls[i]->id); in scarlett2_notify_monitor()
6818 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_volume() local
6820 private->vol_updated = 1; in scarlett2_notify_volume()
6823 &private->master_vol_ctl->id); in scarlett2_notify_volume()
6825 &private->headphone_vol_ctl->id); in scarlett2_notify_volume()
6832 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_dim_mute() local
6835 if (!scarlett2_has_config_item(private, SCARLETT2_CONFIG_SW_HW_SWITCH)) in scarlett2_notify_dim_mute()
6838 private->dim_mute_updated = 1; in scarlett2_notify_dim_mute()
6842 &private->dim_mute_ctls[i]->id); in scarlett2_notify_dim_mute()
6844 for (i = 0; i < private->num_line_out; i++) in scarlett2_notify_dim_mute()
6845 if (private->vol_sw_hw_switch[line_out_remap(private, i)]) in scarlett2_notify_dim_mute()
6847 &private->mute_ctls[i]->id); in scarlett2_notify_dim_mute()
6854 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_level() local
6855 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_level()
6858 private->input_level_updated = 1; in scarlett2_notify_input_level()
6862 &private->level_ctls[i]->id); in scarlett2_notify_input_level()
6869 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_pad() local
6870 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_pad()
6873 private->input_pad_updated = 1; in scarlett2_notify_input_pad()
6877 &private->pad_ctls[i]->id); in scarlett2_notify_input_pad()
6884 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_air() local
6885 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_air()
6888 private->input_air_updated = 1; in scarlett2_notify_input_air()
6892 &private->air_ctls[i]->id); in scarlett2_notify_input_air()
6899 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_phantom() local
6900 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_phantom()
6903 private->input_phantom_updated = 1; in scarlett2_notify_input_phantom()
6907 &private->phantom_ctls[i]->id); in scarlett2_notify_input_phantom()
6925 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_select() local
6926 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_select()
6932 private->input_select_updated = 1; in scarlett2_notify_input_select()
6936 &private->input_select_ctl->id); in scarlett2_notify_input_select()
6940 &private->input_link_ctls[i]->id); in scarlett2_notify_input_select()
6947 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_gain() local
6948 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_gain()
6954 private->input_gain_updated = 1; in scarlett2_notify_input_gain()
6958 &private->input_gain_ctls[i]->id); in scarlett2_notify_input_gain()
6965 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_autogain() local
6966 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_autogain()
6972 private->autogain_updated = 1; in scarlett2_notify_autogain()
6976 &private->autogain_ctls[i]->id); in scarlett2_notify_autogain()
6978 &private->autogain_status_ctls[i]->id); in scarlett2_notify_autogain()
6988 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_input_safe() local
6989 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_input_safe()
6995 private->input_safe_updated = 1; in scarlett2_notify_input_safe()
6999 &private->safe_ctls[i]->id); in scarlett2_notify_input_safe()
7006 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_monitor_other() local
7007 const struct scarlett2_device_info *info = private->info; in scarlett2_notify_monitor_other()
7009 private->monitor_other_updated = 1; in scarlett2_notify_monitor_other()
7013 &private->speaker_switching_ctl->id); in scarlett2_notify_monitor_other()
7017 &private->talkback_ctl->id); in scarlett2_notify_monitor_other()
7022 if (private->speaker_switching_switched) { in scarlett2_notify_monitor_other()
7027 private->speaker_switching_switched = 0; in scarlett2_notify_monitor_other()
7028 private->mux_updated = 1; in scarlett2_notify_monitor_other()
7030 for (i = 0; i < private->num_mux_dsts; i++) in scarlett2_notify_monitor_other()
7032 &private->mux_ctls[i]->id); in scarlett2_notify_monitor_other()
7040 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_direct_monitor() local
7041 int count = private->num_mix_in * private->num_mix_out; in scarlett2_notify_direct_monitor()
7044 private->direct_monitor_updated = 1; in scarlett2_notify_direct_monitor()
7047 &private->direct_monitor_ctl->id); in scarlett2_notify_direct_monitor()
7049 if (!scarlett2_has_mixer(private)) in scarlett2_notify_direct_monitor()
7052 private->mix_updated = 1; in scarlett2_notify_direct_monitor()
7057 &private->mix_ctls[i]->id); in scarlett2_notify_direct_monitor()
7064 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_power_status() local
7066 private->power_status_updated = 1; in scarlett2_notify_power_status()
7069 &private->power_status_ctl->id); in scarlett2_notify_power_status()
7076 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_mux() local
7079 private->mux_updated = 1; in scarlett2_notify_mux()
7081 for (i = 0; i < private->num_mux_dsts; i++) in scarlett2_notify_mux()
7083 &private->mux_ctls[i]->id); in scarlett2_notify_mux()
7090 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify_pcm_input_switch() local
7092 private->pcm_input_switch_updated = 1; in scarlett2_notify_pcm_input_switch()
7095 &private->pcm_input_switch_ctl->id); in scarlett2_notify_pcm_input_switch()
7107 struct scarlett2_data *private = mixer->private_data; in scarlett2_notify() local
7109 private->config_set->notifications; in scarlett2_notify()
7142 struct scarlett2_data *private = mixer->private_data; in scarlett2_init_notify() local
7143 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress); in scarlett2_init_notify()
7159 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL); in scarlett2_init_notify()
7164 transfer_buffer, private->wMaxPacketSize, in scarlett2_init_notify()
7165 scarlett2_notify, mixer, private->bInterval); in scarlett2_init_notify()
7188 struct scarlett2_data *private; in snd_scarlett2_controls_create() local
7191 /* Initialise private data */ in snd_scarlett2_controls_create()
7196 private = mixer->private_data; in snd_scarlett2_controls_create()
7231 if (private->msd_switch || in snd_scarlett2_controls_create()
7232 private->firmware_version < private->info->min_firmware_version) in snd_scarlett2_controls_create()
7293 if (private->info->gain_input_count) { in snd_scarlett2_controls_create()
7308 /* Set private->hwdep_in_use; prevents access to the ALSA controls
7311 static void scarlett2_lock(struct scarlett2_data *private) in scarlett2_lock() argument
7313 mutex_lock(&private->data_mutex); in scarlett2_lock()
7314 private->hwdep_in_use = 1; in scarlett2_lock()
7315 mutex_unlock(&private->data_mutex); in scarlett2_lock()
7321 struct scarlett2_data *private = mixer->private_data; in scarlett2_get_erase_progress() local
7330 segment_id = private->selected_flash_segment_id; in scarlett2_get_erase_progress()
7331 segment_num = private->flash_segment_nums[segment_id]; in scarlett2_get_erase_progress()
7377 struct scarlett2_data *private = mixer->private_data; in scarlett2_reboot() local
7379 if (private->flash_write_state == in scarlett2_reboot()
7395 struct scarlett2_data *private = mixer->private_data; in scarlett2_ioctl_select_flash_segment() local
7405 segment_num = private->flash_segment_nums[segment_id]; in scarlett2_ioctl_select_flash_segment()
7415 if (private->flash_write_state == SCARLETT2_FLASH_WRITE_STATE_ERASING) { in scarlett2_ioctl_select_flash_segment()
7423 private->selected_flash_segment_id = segment_id; in scarlett2_ioctl_select_flash_segment()
7424 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_SELECTED; in scarlett2_ioctl_select_flash_segment()
7433 struct scarlett2_data *private = mixer->private_data; in scarlett2_ioctl_erase_flash_segment() local
7441 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_SELECTED) in scarlett2_ioctl_erase_flash_segment()
7444 segment_id = private->selected_flash_segment_id; in scarlett2_ioctl_erase_flash_segment()
7445 segment_num = private->flash_segment_nums[segment_id]; in scarlett2_ioctl_erase_flash_segment()
7454 scarlett2_lock(private); in scarlett2_ioctl_erase_flash_segment()
7467 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_ERASING; in scarlett2_ioctl_erase_flash_segment()
7477 struct scarlett2_data *private = mixer->private_data; in scarlett2_ioctl_get_erase_progress() local
7488 if (private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) in scarlett2_ioctl_get_erase_progress()
7491 segment_id = private->selected_flash_segment_id; in scarlett2_ioctl_get_erase_progress()
7492 segment_num = private->flash_segment_nums[segment_id]; in scarlett2_ioctl_get_erase_progress()
7509 progress.num_blocks = private->flash_segment_blocks[segment_id]; in scarlett2_ioctl_get_erase_progress()
7518 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; in scarlett2_ioctl_get_erase_progress()
7526 struct scarlett2_data *private = mixer->private_data; in scarlett2_hwdep_open() local
7529 if (private->flash_write_state == in scarlett2_hwdep_open()
7538 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; in scarlett2_hwdep_open()
7576 struct scarlett2_data *private = mixer->private_data; in scarlett2_hwdep_write() local
7593 if (private->flash_write_state == in scarlett2_hwdep_write()
7598 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_WRITE; in scarlett2_hwdep_write()
7601 } else if (private->flash_write_state != in scarlett2_hwdep_write()
7607 segment_id = private->selected_flash_segment_id; in scarlett2_hwdep_write()
7611 segment_num = private->flash_segment_nums[segment_id]; in scarlett2_hwdep_write()
7617 flash_size = private->flash_segment_blocks[segment_id] * in scarlett2_hwdep_write()
7661 struct scarlett2_data *private = mixer->private_data; in scarlett2_hwdep_release() local
7666 if (private && in scarlett2_hwdep_release()
7667 private->hwdep_in_use && in scarlett2_hwdep_release()
7668 private->flash_write_state != SCARLETT2_FLASH_WRITE_STATE_ERASING) in scarlett2_hwdep_release()
7669 private->flash_write_state = SCARLETT2_FLASH_WRITE_STATE_IDLE; in scarlett2_hwdep_release()