Lines Matching refs:mixer
15 * TODOs, for both the mixer and the streaming interfaces:
48 #include "mixer.h"
67 struct usb_mixer_interface *mixer;
94 * manual mapping of mixer names
95 * if the mixer topology is too complicated and the parsed names are
127 ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
292 * retrieve a mixer value
295 static inline int mixer_ctrl_intf(struct usb_mixer_interface *mixer)
297 return get_iface_desc(mixer->hostif)->bInterfaceNumber;
303 struct snd_usb_audio *chip = cval->head.mixer->chip;
314 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
339 struct snd_usb_audio *chip = cval->head.mixer->chip;
362 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
406 return (cval->head.mixer->protocol == UAC_VERSION_1) ?
437 if (!cval->head.mixer->ignore_ctl_error)
438 usb_audio_dbg(cval->head.mixer->chip,
449 * set a mixer value
455 struct snd_usb_audio *chip = cval->head.mixer->chip;
462 if (cval->head.mixer->protocol == UAC_VERSION_1) {
487 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
523 usb_audio_dbg(cval->head.mixer->chip,
540 * TLV callback for mixer volume controls
568 * used for mixer unit parser
588 struct usb_mixer_interface *mixer = list->mixer;
591 while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
593 err = snd_ctl_add(mixer->chip->card, kctl);
595 usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n",
601 list->next_id_elem = mixer->id_elems[list->id];
602 mixer->id_elems[list->id] = list;
750 switch (state->mixer->protocol) {
844 int protocol = state->mixer->protocol;
873 if (state->mixer->protocol != UAC_VERSION_3)
883 int protocol = state->mixer->protocol;
955 int protocol = state->mixer->protocol;
1074 * interface to ALSA control for feature/mixer units
1081 struct snd_usb_audio *chip = cval->head.mixer->chip;
1225 usb_audio_err(cval->head.mixer->chip,
1227 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1309 usb_audio_info(cval->head.mixer->chip,
1311 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1322 /* get a feature/mixer unit info */
1345 snd_ctl_notify(cval->head.mixer->chip->card,
1357 /* get the current value from feature/mixer unit */
1389 /* put the current value to feature/mixer unit */
1448 struct snd_usb_audio *chip = cval->head.mixer->chip;
1457 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
1458 if (cval->head.mixer->protocol == UAC_VERSION_2) {
1532 * This symbol is exported in order to allow the mixer quirks to
1546 * A lot of headsets/headphones have a "Speaker" mixer. Make sure we
1584 static void __build_feature_ctl(struct usb_mixer_interface *mixer,
1611 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1620 if (mixer->protocol == UAC_VERSION_1)
1649 usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1658 len = snd_usb_copy_string_desc(mixer->chip, nameid,
1674 len = get_term_name(mixer->chip, iterm,
1678 len = get_term_name(mixer->chip, oterm,
1687 check_no_speaker_on_headset(kctl, mixer->chip->card);
1715 usb_audio_dbg(mixer->chip,
1733 snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
1742 usb_audio_warn(mixer->chip,
1745 usb_audio_warn(mixer->chip,
1751 usb_audio_dbg(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1765 __build_feature_ctl(state->mixer, state->map, ctl_mask, control,
1769 static void build_feature_ctl_badd(struct usb_mixer_interface *mixer,
1773 __build_feature_ctl(mixer, badd_map, ctl_mask, control,
1777 static void get_connector_control_name(struct usb_mixer_interface *mixer,
1781 int name_len = get_term_name(mixer->chip, term, name, name_size, 0);
1797 /* Build a mixer control for a UAC connector control (jack-detect) */
1798 static void build_connector_control(struct usb_mixer_interface *mixer,
1813 snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
1824 if (mixer->protocol == UAC_VERSION_2)
1835 usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1843 get_connector_control_name(mixer, term, is_input, kctl->id.name,
1858 if (state->mixer->protocol != UAC_VERSION_2)
1873 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
1918 if (state->mixer->protocol == UAC_VERSION_1) {
1922 } else if (state->mixer->protocol == UAC_VERSION_2) {
1963 if (state->mixer->protocol == UAC_VERSION_1) {
2065 * build a mixer unit control
2088 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2092 __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
2130 if (state->mixer->protocol == UAC_VERSION_2) {
2135 } else if (state->mixer->protocol == UAC_VERSION_3) {
2149 build_connector_control(state->mixer, state->map, &iterm, true);
2155 * parse a mixer unit
2189 if (mixer_bitmap_overflow(desc, state->mixer->protocol,
2197 state->mixer->protocol);
2414 __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
2416 if (state->mixer->protocol == UAC_VERSION_1) {
2432 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2437 if (state->mixer->protocol > UAC_VERSION_1 &&
2447 switch (state->mixer->protocol) {
2462 state->mixer->protocol);
2507 nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol);
2509 nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
2537 switch (state->mixer->protocol) {
2676 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2684 switch (state->mixer->protocol) {
2735 switch (state->mixer->protocol) {
2789 int protocol = state->mixer->protocol;
2846 static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2849 snd_usb_mixer_disconnect(mixer);
2851 kfree(mixer->id_elems);
2852 if (mixer->urb) {
2853 kfree(mixer->urb->transfer_buffer);
2854 usb_free_urb(mixer->urb);
2856 usb_free_urb(mixer->rc_urb);
2857 kfree(mixer->rc_setup_packet);
2858 kfree(mixer);
2863 struct usb_mixer_interface *mixer = device->device_data;
2864 snd_usb_mixer_free(mixer);
2937 static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer,
2947 usb_audio_warn(mixer->chip, "BAAD %s: no channels?",
2956 usb_audio_warn(mixer->chip, "BAAD %s c_chmask mismatch",
2962 usb_audio_warn(mixer->chip, "BAAD %s p_chmask mismatch",
2970 * create mixer controls for UAC3 BADD profiles
2976 static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer,
2979 struct usb_device *dev = mixer->chip->dev;
2981 int badd_profile = mixer->chip->badd_profile;
3031 usb_audio_err(mixer->chip,
3055 usb_audio_dbg(mixer->chip,
3074 if (!uac3_badd_func_has_valid_channels(mixer, f, c_chmask, p_chmask))
3081 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3084 build_feature_ctl_badd(mixer, p_chmask, UAC_FU_VOLUME,
3091 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3094 build_feature_ctl_badd(mixer, c_chmask, UAC_FU_VOLUME,
3101 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3104 build_feature_ctl_badd(mixer, 1, UAC_FU_VOLUME,
3116 build_connector_control(mixer, map->map, &iterm, true);
3122 build_connector_control(mixer, map->map, &oterm, false);
3129 * create mixer controls
3133 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
3141 state.chip = mixer->chip;
3142 state.mixer = mixer;
3143 state.buffer = mixer->hostif->extra;
3144 state.buflen = mixer->hostif->extralen;
3151 mixer->connector_map = map->connector_map;
3152 mixer->ignore_ctl_error |= map->ignore_ctl_error;
3158 while ((p = snd_usb_find_csint_desc(mixer->hostif->extra,
3159 mixer->hostif->extralen,
3161 if (!snd_usb_validate_audio_desc(p, mixer->protocol))
3164 if (mixer->protocol == UAC_VERSION_1) {
3175 } else if (mixer->protocol == UAC_VERSION_2) {
3198 build_connector_control(state.mixer, state.map,
3224 build_connector_control(state.mixer, state.map,
3233 static int delegate_notify(struct usb_mixer_interface *mixer, int unitid,
3236 const struct usbmix_connector_map *map = mixer->connector_map;
3253 void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
3257 unitid = delegate_notify(mixer, unitid, NULL, NULL);
3259 for_each_mixer_elem(list, mixer, unitid) {
3267 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3299 struct usb_mixer_interface *mixer;
3303 list_for_each_entry(mixer, &chip->mixer_list, list) {
3306 chip->usb_id, mixer_ctrl_intf(mixer),
3307 mixer->ignore_ctl_error);
3310 for_each_mixer_elem(list, mixer, unitid) {
3324 static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
3334 usb_audio_dbg(mixer->chip,
3340 unitid = delegate_notify(mixer, unitid, &control, &channel);
3342 for_each_mixer_elem(list, mixer, unitid)
3348 for_each_mixer_elem(list, mixer, unitid) {
3368 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3381 usb_audio_dbg(mixer->chip,
3391 struct usb_mixer_interface *mixer = urb->context;
3398 if (mixer->protocol == UAC_VERSION_1) {
3414 snd_usb_mixer_rc_memory_change(mixer, status->bOriginator);
3416 snd_usb_mixer_notify_id(mixer, status->bOriginator);
3429 snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute,
3439 urb->dev = mixer->chip->dev;
3445 static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
3453 if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1)
3455 ep = get_endpoint(mixer->hostif, 0);
3464 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3465 if (!mixer->urb) {
3469 usb_fill_int_urb(mixer->urb, mixer->chip->dev,
3470 usb_rcvintpipe(mixer->chip->dev, epnum),
3472 snd_usb_mixer_interrupt, mixer, ep->bInterval);
3473 usb_submit_urb(mixer->urb, GFP_KERNEL);
3480 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
3482 ucontrol->value.integer.value[0] = mixer->chip->keep_iface;
3489 struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
3492 if (mixer->chip->keep_iface == keep_iface)
3494 mixer->chip->keep_iface = keep_iface;
3506 static int create_keep_iface_ctl(struct usb_mixer_interface *mixer)
3508 struct snd_kcontrol *kctl = snd_ctl_new1(&keep_iface_ctl, mixer);
3511 if (snd_ctl_find_id(mixer->chip->card, &kctl->id)) {
3516 return snd_ctl_add(mixer->chip->card, kctl);
3525 struct usb_mixer_interface *mixer;
3530 mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
3531 if (!mixer)
3533 mixer->chip = chip;
3534 mixer->ignore_ctl_error = ignore_error;
3535 mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
3537 if (!mixer->id_elems) {
3538 kfree(mixer);
3542 mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
3543 switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) {
3546 mixer->protocol = UAC_VERSION_1;
3549 mixer->protocol = UAC_VERSION_2;
3552 mixer->protocol = UAC_VERSION_3;
3556 if (mixer->protocol == UAC_VERSION_3 &&
3558 err = snd_usb_mixer_controls_badd(mixer, ctrlif);
3562 err = snd_usb_mixer_controls(mixer);
3567 err = snd_usb_mixer_status_create(mixer);
3571 err = create_keep_iface_ctl(mixer);
3575 err = snd_usb_mixer_apply_create_quirk(mixer);
3579 err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops);
3587 list_add(&mixer->list, &chip->mixer_list);
3591 snd_usb_mixer_free(mixer);
3595 void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
3597 if (mixer->disconnected)
3599 if (mixer->urb)
3600 usb_kill_urb(mixer->urb);
3601 if (mixer->rc_urb)
3602 usb_kill_urb(mixer->rc_urb);
3603 if (mixer->private_free)
3604 mixer->private_free(mixer);
3605 mixer->disconnected = true;
3609 /* stop any bus activity of a mixer */
3610 static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
3612 usb_kill_urb(mixer->urb);
3613 usb_kill_urb(mixer->rc_urb);
3616 static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
3620 if (mixer->urb) {
3621 err = usb_submit_urb(mixer->urb, GFP_NOIO);
3629 int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
3631 snd_usb_mixer_inactivate(mixer);
3632 if (mixer->private_suspend)
3633 mixer->private_suspend(mixer);
3670 int snd_usb_mixer_resume(struct usb_mixer_interface *mixer, bool reset_resume)
3676 /* restore cached mixer values */
3678 for_each_mixer_elem(list, mixer, id) {
3688 snd_usb_mixer_resume_quirk(mixer);
3690 return snd_usb_mixer_activate(mixer);
3695 struct usb_mixer_interface *mixer,
3698 list->mixer = mixer;