Lines Matching refs:private
1149 static void scarlett2_fill_request_header(struct scarlett2_data *private,
1154 u16 seq = private->scarlett2_seq++;
1186 struct scarlett2_data *private = mixer->private_data;
1205 mutex_lock(&private->usb_mutex);
1209 scarlett2_fill_request_header(private, req, cmd, req_size);
1214 err = scarlett2_usb_tx(dev, private->bInterfaceNumber,
1228 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
1271 mutex_unlock(&private->usb_mutex);
1299 struct scarlett2_data *private = mixer->private_data;
1300 const struct scarlett2_device_info *info = private->info;
1350 struct scarlett2_data *private =
1353 scarlett2_config_save(private->mixer);
1361 struct scarlett2_data *private = mixer->private_data;
1362 const struct scarlett2_device_info *info = private->info;
1375 cancel_delayed_work_sync(&private->work);
1424 schedule_delayed_work(&private->work, msecs_to_jiffies(2000));
1456 * and put the values into private->mix[]
1461 struct scarlett2_data *private = mixer->private_data;
1462 const struct scarlett2_device_info *info = private->info;
1492 private->mix[j] = k;
1499 * (values obtained from private->mix[])
1504 struct scarlett2_data *private = mixer->private_data;
1505 const struct scarlett2_device_info *info = private->info;
1520 scarlett2_mixer_values[private->mix[j]]
1568 /* Convert one mux entry from the interface and load into private->mux[] */
1569 static void scarlett2_usb_populate_mux(struct scarlett2_data *private,
1572 const struct scarlett2_device_info *info = private->info;
1582 if (dst_idx >= private->num_mux_dsts) {
1583 usb_audio_err(private->mixer->chip,
1585 mux_entry, dst_idx, private->num_mux_dsts);
1594 if (src_idx >= private->num_mux_srcs) {
1595 usb_audio_err(private->mixer->chip,
1597 mux_entry, src_idx, private->num_mux_srcs);
1601 private->mux[dst_idx] = src_idx;
1604 /* Send USB message to get mux inputs and then populate private->mux[] */
1607 struct scarlett2_data *private = mixer->private_data;
1608 int count = private->num_mux_dsts;
1618 private->mux_updated = 0;
1630 scarlett2_usb_populate_mux(private, le32_to_cpu(data[i]));
1638 struct scarlett2_data *private = mixer->private_data;
1639 const struct scarlett2_device_info *info = private->info;
1684 port_count, private->mux[mux_idx++]);
1780 struct scarlett2_data *private = mixer->private_data;
1782 private->sync_updated = 0;
1783 return scarlett2_usb_get_sync_status(mixer, &private->sync);
1800 struct scarlett2_data *private = mixer->private_data;
1803 mutex_lock(&private->data_mutex);
1805 if (private->sync_updated) {
1810 ucontrol->value.enumerated.item[0] = private->sync;
1813 mutex_unlock(&private->data_mutex);
1827 struct scarlett2_data *private = mixer->private_data;
1830 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
1834 0, 1, "Sync Status", &private->sync_ctl);
1844 struct scarlett2_data *private = mixer->private_data;
1845 const struct scarlett2_device_info *info = private->info;
1853 private->vol_updated = 0;
1859 private->master_vol = clamp(
1865 private->dim_mute[i] = !!volume_status.dim_mute[i];
1867 mute = private->dim_mute[SCARLETT2_BUTTON_MUTE];
1870 if (private->vol_sw_hw_switch[i]) {
1871 private->vol[i] = private->master_vol;
1872 private->mute_switch[i] = mute;
1896 struct scarlett2_data *private = mixer->private_data;
1899 mutex_lock(&private->data_mutex);
1901 if (private->vol_updated) {
1906 ucontrol->value.integer.value[0] = private->master_vol;
1909 mutex_unlock(&private->data_mutex);
1913 static int line_out_remap(struct scarlett2_data *private, int index)
1915 const struct scarlett2_device_info *info = private->info;
1934 struct scarlett2_data *private = mixer->private_data;
1935 int index = line_out_remap(private, elem->control);
1938 mutex_lock(&private->data_mutex);
1940 if (private->vol_updated) {
1945 ucontrol->value.integer.value[0] = private->vol[index];
1948 mutex_unlock(&private->data_mutex);
1957 struct scarlett2_data *private = mixer->private_data;
1958 int index = line_out_remap(private, elem->control);
1961 mutex_lock(&private->data_mutex);
1963 oval = private->vol[index];
1969 private->vol[index] = val;
1976 mutex_unlock(&private->data_mutex);
2014 struct scarlett2_data *private = mixer->private_data;
2015 int index = line_out_remap(private, elem->control);
2018 mutex_lock(&private->data_mutex);
2020 if (private->vol_updated) {
2025 ucontrol->value.integer.value[0] = private->mute_switch[index];
2028 mutex_unlock(&private->data_mutex);
2037 struct scarlett2_data *private = mixer->private_data;
2038 int index = line_out_remap(private, elem->control);
2041 mutex_lock(&private->data_mutex);
2043 oval = private->mute_switch[index];
2049 private->mute_switch[index] = val;
2058 mutex_unlock(&private->data_mutex);
2072 static void scarlett2_sw_hw_ctl_ro(struct scarlett2_data *private, int index)
2074 private->sw_hw_ctls[index]->vd[0].access &=
2078 static void scarlett2_sw_hw_ctl_rw(struct scarlett2_data *private, int index)
2080 private->sw_hw_ctls[index]->vd[0].access |=
2098 struct scarlett2_data *private = elem->head.mixer->private_data;
2099 int index = line_out_remap(private, elem->control);
2101 ucontrol->value.enumerated.item[0] = private->vol_sw_hw_switch[index];
2108 struct scarlett2_data *private = mixer->private_data;
2113 private->vol_ctls[index]->vd[0].access |=
2115 private->mute_ctls[index]->vd[0].access |=
2118 private->vol_ctls[index]->vd[0].access &=
2120 private->mute_ctls[index]->vd[0].access &=
2127 &private->vol_ctls[index]->id);
2130 &private->mute_ctls[index]->id);
2136 struct scarlett2_data *private = mixer->private_data;
2137 int index = line_out_remap(private, ctl_index);
2140 private->vol_sw_hw_switch[index] = val;
2148 private->vol[index] = private->master_vol;
2149 private->mute_switch[index] = private->dim_mute[SCARLETT2_BUTTON_MUTE];
2154 index, private->master_vol - SCARLETT2_VOLUME_BIAS);
2161 index, private->dim_mute[SCARLETT2_BUTTON_MUTE]);
2175 struct scarlett2_data *private = mixer->private_data;
2177 int index = line_out_remap(private, ctl_index);
2180 mutex_lock(&private->data_mutex);
2182 oval = private->vol_sw_hw_switch[index];
2193 mutex_unlock(&private->data_mutex);
2209 struct scarlett2_data *private = mixer->private_data;
2210 const struct scarlett2_device_info *info = private->info;
2212 private->input_other_updated = 0;
2218 private->level_switch);
2226 info->pad_input_count, private->pad_switch);
2234 info->air_input_count, private->air_switch);
2242 info->phantom_count, private->phantom_switch);
2248 1, &private->phantom_persistence);
2271 struct scarlett2_data *private = mixer->private_data;
2272 const struct scarlett2_device_info *info = private->info;
2277 mutex_lock(&private->data_mutex);
2279 if (private->input_other_updated) {
2284 ucontrol->value.enumerated.item[0] = private->level_switch[index];
2287 mutex_unlock(&private->data_mutex);
2296 struct scarlett2_data *private = mixer->private_data;
2297 const struct scarlett2_device_info *info = private->info;
2302 mutex_lock(&private->data_mutex);
2304 oval = private->level_switch[index];
2310 private->level_switch[index] = val;
2319 mutex_unlock(&private->data_mutex);
2338 struct scarlett2_data *private = mixer->private_data;
2341 mutex_lock(&private->data_mutex);
2343 if (private->input_other_updated) {
2349 private->pad_switch[elem->control];
2352 mutex_unlock(&private->data_mutex);
2361 struct scarlett2_data *private = mixer->private_data;
2366 mutex_lock(&private->data_mutex);
2368 oval = private->pad_switch[index];
2374 private->pad_switch[index] = val;
2383 mutex_unlock(&private->data_mutex);
2402 struct scarlett2_data *private = mixer->private_data;
2405 mutex_lock(&private->data_mutex);
2407 if (private->input_other_updated) {
2412 ucontrol->value.integer.value[0] = private->air_switch[elem->control];
2415 mutex_unlock(&private->data_mutex);
2424 struct scarlett2_data *private = mixer->private_data;
2429 mutex_lock(&private->data_mutex);
2431 oval = private->air_switch[index];
2437 private->air_switch[index] = val;
2446 mutex_unlock(&private->data_mutex);
2465 struct scarlett2_data *private = mixer->private_data;
2468 mutex_lock(&private->data_mutex);
2470 if (private->input_other_updated) {
2476 private->phantom_switch[elem->control];
2479 mutex_unlock(&private->data_mutex);
2488 struct scarlett2_data *private = mixer->private_data;
2493 mutex_lock(&private->data_mutex);
2495 oval = private->phantom_switch[index];
2501 private->phantom_switch[index] = val;
2510 mutex_unlock(&private->data_mutex);
2528 struct scarlett2_data *private = elem->head.mixer->private_data;
2530 ucontrol->value.integer.value[0] = private->phantom_persistence;
2539 struct scarlett2_data *private = mixer->private_data;
2544 mutex_lock(&private->data_mutex);
2546 oval = private->phantom_persistence;
2552 private->phantom_persistence = val;
2561 mutex_unlock(&private->data_mutex);
2577 struct scarlett2_data *private = mixer->private_data;
2578 const struct scarlett2_device_info *info = private->info;
2591 private->monitor_other_updated = 0;
2596 1, &private->direct_monitor_switch);
2617 private->speaker_switching_switch = 0;
2619 private->speaker_switching_switch = monitor_other_switch[0] + 1;
2630 private->talkback_switch = 0;
2632 private->talkback_switch = monitor_other_switch[1] + 1;
2640 private->talkback_map[i] = bitmap & 1;
2651 struct scarlett2_data *private = elem->head.mixer->private_data;
2654 mutex_lock(&private->data_mutex);
2656 if (private->monitor_other_updated) {
2661 ucontrol->value.enumerated.item[0] = private->direct_monitor_switch;
2664 mutex_unlock(&private->data_mutex);
2673 struct scarlett2_data *private = mixer->private_data;
2678 mutex_lock(&private->data_mutex);
2680 oval = private->direct_monitor_switch;
2686 private->direct_monitor_switch = val;
2695 mutex_unlock(&private->data_mutex);
2731 struct scarlett2_data *private = mixer->private_data;
2732 const struct scarlett2_device_info *info = private->info;
2744 0, 1, s, &private->direct_monitor_ctl);
2764 struct scarlett2_data *private = mixer->private_data;
2767 mutex_lock(&private->data_mutex);
2769 if (private->monitor_other_updated) {
2774 ucontrol->value.enumerated.item[0] = private->speaker_switching_switch;
2777 mutex_unlock(&private->data_mutex);
2787 struct scarlett2_data *private = mixer->private_data;
2791 int index = line_out_remap(private, i);
2794 if (!private->vol_sw_hw_switch[index]) {
2795 err = scarlett2_sw_hw_change(private->mixer, i, 1);
2801 scarlett2_sw_hw_ctl_ro(private, i);
2805 &private->sw_hw_ctls[i]->id);
2811 private->speaker_switching_switched = 1;
2822 struct scarlett2_data *private = mixer->private_data;
2827 scarlett2_sw_hw_ctl_rw(private, i);
2829 &private->sw_hw_ctls[i]->id);
2835 private->speaker_switching_switched = 1;
2843 struct scarlett2_data *private = mixer->private_data;
2847 mutex_lock(&private->data_mutex);
2849 oval = private->speaker_switching_switch;
2855 private->speaker_switching_switch = val;
2881 mutex_unlock(&private->data_mutex);
2896 struct scarlett2_data *private = mixer->private_data;
2897 const struct scarlett2_device_info *info = private->info;
2905 &private->speaker_switching_ctl);
2925 struct scarlett2_data *private = mixer->private_data;
2928 mutex_lock(&private->data_mutex);
2930 if (private->monitor_other_updated) {
2935 ucontrol->value.enumerated.item[0] = private->talkback_switch;
2938 mutex_unlock(&private->data_mutex);
2947 struct scarlett2_data *private = mixer->private_data;
2951 mutex_lock(&private->data_mutex);
2953 oval = private->talkback_switch;
2959 private->talkback_switch = val;
2976 mutex_unlock(&private->data_mutex);
2993 struct scarlett2_data *private = mixer->private_data;
2996 ucontrol->value.integer.value[0] = private->talkback_map[index];
3006 struct scarlett2_data *private = mixer->private_data;
3008 private->info->port_count;
3015 mutex_lock(&private->data_mutex);
3017 oval = private->talkback_map[index];
3023 private->talkback_map[index] = val;
3026 bitmap |= private->talkback_map[i] << i;
3035 mutex_unlock(&private->data_mutex);
3050 struct scarlett2_data *private = mixer->private_data;
3051 const struct scarlett2_device_info *info = private->info;
3063 &private->talkback_ctl);
3086 struct scarlett2_data *private = mixer->private_data;
3089 mutex_lock(&private->data_mutex);
3091 if (private->vol_updated) {
3096 ucontrol->value.integer.value[0] = private->dim_mute[elem->control];
3099 mutex_unlock(&private->data_mutex);
3108 struct scarlett2_data *private = mixer->private_data;
3109 const struct scarlett2_device_info *info = private->info;
3117 mutex_lock(&private->data_mutex);
3119 oval = private->dim_mute[index];
3125 private->dim_mute[index] = val;
3135 int line_index = line_out_remap(private, i);
3137 if (private->vol_sw_hw_switch[line_index]) {
3138 private->mute_switch[line_index] = val;
3141 &private->mute_ctls[i]->id);
3146 mutex_unlock(&private->data_mutex);
3162 struct scarlett2_data *private = mixer->private_data;
3163 const struct scarlett2_device_info *info = private->info;
3175 0, 1, s, &private->master_vol_ctl);
3182 int index = line_out_remap(private, i);
3195 i, 1, s, &private->vol_ctls[i]);
3206 &private->mute_ctls[i]);
3213 if (private->vol_sw_hw_switch[index])
3224 &private->sw_hw_ctls[i]);
3231 if (private->speaker_switching_switch && i < 4)
3232 scarlett2_sw_hw_ctl_ro(private, i);
3242 &private->dim_mute_ctls[i]);
3254 struct scarlett2_data *private = mixer->private_data;
3255 const struct scarlett2_device_info *info = private->info;
3266 i, 1, s, &private->level_ctls[i]);
3275 i, 1, s, &private->pad_ctls[i]);
3284 i, 1, s, &private->air_ctls[i]);
3296 i, 1, s, &private->phantom_ctls[i]);
3309 i, 1, s, &private->phantom_ctls[i]);
3344 struct scarlett2_data *private = elem->head.mixer->private_data;
3346 ucontrol->value.integer.value[0] = private->mix[elem->control];
3355 struct scarlett2_data *private = mixer->private_data;
3356 const struct scarlett2_device_info *info = private->info;
3361 mutex_lock(&private->data_mutex);
3363 oval = private->mix[index];
3372 private->mix[index] = val;
3378 mutex_unlock(&private->data_mutex);
3402 struct scarlett2_data *private = mixer->private_data;
3403 const struct scarlett2_device_info *info = private->info;
3434 struct scarlett2_data *private = elem->head.mixer->private_data;
3435 const struct scarlett2_device_info *info = private->info;
3438 int items = private->num_mux_srcs;
3470 struct scarlett2_data *private = mixer->private_data;
3471 int index = line_out_remap(private, elem->control);
3474 mutex_lock(&private->data_mutex);
3476 if (private->mux_updated) {
3481 ucontrol->value.enumerated.item[0] = private->mux[index];
3484 mutex_unlock(&private->data_mutex);
3493 struct scarlett2_data *private = mixer->private_data;
3494 int index = line_out_remap(private, elem->control);
3497 mutex_lock(&private->data_mutex);
3499 oval = private->mux[index];
3501 private->num_mux_srcs - 1U);
3506 private->mux[index] = val;
3512 mutex_unlock(&private->data_mutex);
3526 struct scarlett2_data *private = mixer->private_data;
3527 const struct scarlett2_device_info *info = private->info;
3548 &private->mux_ctls[i]);
3600 struct scarlett2_data *private = mixer->private_data;
3603 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3607 0, private->num_mux_dsts,
3617 struct scarlett2_data *private = elem->head.mixer->private_data;
3619 ucontrol->value.integer.value[0] = private->msd_switch;
3628 struct scarlett2_data *private = mixer->private_data;
3632 mutex_lock(&private->data_mutex);
3634 oval = private->msd_switch;
3640 private->msd_switch = val;
3649 mutex_unlock(&private->data_mutex);
3663 struct scarlett2_data *private = mixer->private_data;
3664 const struct scarlett2_device_info *info = private->info;
3670 if (!private->msd_switch && !(mixer->chip->setup & SCARLETT2_MSD_ENABLE))
3684 struct scarlett2_data *private = elem->head.mixer->private_data;
3686 ucontrol->value.integer.value[0] = private->standalone_switch;
3695 struct scarlett2_data *private = mixer->private_data;
3699 mutex_lock(&private->data_mutex);
3701 oval = private->standalone_switch;
3707 private->standalone_switch = val;
3717 mutex_unlock(&private->data_mutex);
3731 struct scarlett2_data *private = mixer->private_data;
3733 if (private->info->config_set == SCARLETT2_CONFIG_SET_NO_MIXER)
3745 struct scarlett2_data *private = mixer->private_data;
3747 cancel_delayed_work_sync(&private->work);
3748 kfree(private);
3754 struct scarlett2_data *private = mixer->private_data;
3756 if (cancel_delayed_work_sync(&private->work))
3757 scarlett2_config_save(private->mixer);
3762 static void scarlett2_count_mux_io(struct scarlett2_data *private)
3764 const struct scarlett2_device_info *info = private->info;
3775 private->num_mux_srcs = srcs;
3776 private->num_mux_dsts = dsts;
3782 * in private
3785 struct scarlett2_data *private)
3800 private->bInterfaceNumber = desc->bInterfaceNumber;
3801 private->bEndpointAddress = epd->bEndpointAddress &
3803 private->wMaxPacketSize = le16_to_cpu(epd->wMaxPacketSize);
3804 private->bInterval = epd->bInterval;
3811 /* Initialise private data */
3815 struct scarlett2_data *private =
3818 if (!private)
3821 mutex_init(&private->usb_mutex);
3822 mutex_init(&private->data_mutex);
3823 INIT_DELAYED_WORK(&private->work, scarlett2_config_save_work);
3825 mixer->private_data = private;
3829 private->info = info;
3830 scarlett2_count_mux_io(private);
3831 private->scarlett2_seq = 0;
3832 private->mixer = mixer;
3834 return scarlett2_find_fc_interface(mixer->chip->dev, private);
3841 struct scarlett2_data *private = mixer->private_data;
3849 err = scarlett2_usb_rx(dev, private->bInterfaceNumber,
3855 private->scarlett2_seq = 1;
3861 private->scarlett2_seq = 1;
3868 struct scarlett2_data *private = mixer->private_data;
3869 const struct scarlett2_device_info *info = private->info;
3881 1, &private->msd_switch);
3886 if (private->msd_switch)
3904 1, &private->standalone_switch);
3918 private->dim_mute[i] = !!volume_status.dim_mute[i];
3920 private->master_vol = clamp(
3927 private->vol_sw_hw_switch[i] =
3931 volume = private->vol_sw_hw_switch[i]
3936 private->vol[i] = volume;
3938 mute = private->vol_sw_hw_switch[i]
3939 ? private->dim_mute[SCARLETT2_BUTTON_MUTE]
3941 private->mute_switch[i] = mute;
3957 struct scarlett2_data *private = mixer->private_data;
3959 private->sync_updated = 1;
3962 &private->sync_ctl->id);
3970 struct scarlett2_data *private = mixer->private_data;
3971 const struct scarlett2_device_info *info = private->info;
3981 private->vol_updated = 1;
3984 &private->master_vol_ctl->id);
3987 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
3989 &private->vol_ctls[i]->id);
3997 struct scarlett2_data *private = mixer->private_data;
3998 const struct scarlett2_device_info *info = private->info;
4004 private->vol_updated = 1;
4011 &private->dim_mute_ctls[i]->id);
4014 if (private->vol_sw_hw_switch[line_out_remap(private, i)])
4016 &private->mute_ctls[i]->id);
4024 struct scarlett2_data *private = mixer->private_data;
4025 const struct scarlett2_device_info *info = private->info;
4028 private->input_other_updated = 1;
4032 &private->level_ctls[i]->id);
4035 &private->pad_ctls[i]->id);
4038 &private->air_ctls[i]->id);
4041 &private->phantom_ctls[i]->id);
4051 struct scarlett2_data *private = mixer->private_data;
4052 const struct scarlett2_device_info *info = private->info;
4054 private->monitor_other_updated = 1;
4058 &private->direct_monitor_ctl->id);
4064 &private->speaker_switching_ctl->id);
4068 &private->talkback_ctl->id);
4073 if (private->speaker_switching_switched) {
4078 private->speaker_switching_switched = 0;
4079 private->mux_updated = 1;
4081 for (i = 0; i < private->num_mux_dsts; i++)
4083 &private->mux_ctls[i]->id);
4122 struct scarlett2_data *private = mixer->private_data;
4123 unsigned int pipe = usb_rcvintpipe(dev, private->bEndpointAddress);
4139 transfer_buffer = kmalloc(private->wMaxPacketSize, GFP_KERNEL);
4144 transfer_buffer, private->wMaxPacketSize,
4145 scarlett2_notify, mixer, private->bInterval);
4161 /* Initialise private data */