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
130 ((cval)->head.mixer->ignore_ctl_error ? 0 : (err))
299 * retrieve a mixer value
302 static inline int mixer_ctrl_intf(struct usb_mixer_interface *mixer)
304 return get_iface_desc(mixer->hostif)->bInterfaceNumber;
310 struct snd_usb_audio *chip = cval->head.mixer->chip;
321 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
346 struct snd_usb_audio *chip = cval->head.mixer->chip;
368 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
411 return (cval->head.mixer->protocol == UAC_VERSION_1) ?
442 if (!cval->head.mixer->ignore_ctl_error)
443 usb_audio_dbg(cval->head.mixer->chip,
454 * set a mixer value
460 struct snd_usb_audio *chip = cval->head.mixer->chip;
467 if (cval->head.mixer->protocol == UAC_VERSION_1) {
492 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
528 usb_audio_dbg(cval->head.mixer->chip,
545 * TLV callback for mixer volume controls
573 * used for mixer unit parser
593 struct usb_mixer_interface *mixer = list->mixer;
596 while (snd_ctl_find_id(mixer->chip->card, &kctl->id))
598 err = snd_ctl_add(mixer->chip->card, kctl);
600 usb_audio_dbg(mixer->chip, "cannot add control (err = %d)\n",
606 list->next_id_elem = mixer->id_elems[list->id];
607 mixer->id_elems[list->id] = list;
755 switch (state->mixer->protocol) {
849 int protocol = state->mixer->protocol;
878 if (state->mixer->protocol != UAC_VERSION_3)
888 int protocol = state->mixer->protocol;
960 int protocol = state->mixer->protocol;
1079 * interface to ALSA control for feature/mixer units
1086 struct snd_usb_audio *chip = cval->head.mixer->chip;
1217 /* forcibly initialize the current mixer value; if GET_CUR fails, set to
1227 if (!cval->head.mixer->ignore_ctl_error)
1228 usb_audio_warn(cval->head.mixer->chip,
1230 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1263 usb_audio_err(cval->head.mixer->chip,
1265 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1273 } else if (cval->head.mixer->protocol == UAC_VERSION_1) {
1347 usb_audio_info(cval->head.mixer->chip,
1349 cval->head.id, mixer_ctrl_intf(cval->head.mixer),
1373 /* get a feature/mixer unit info */
1396 snd_ctl_notify(cval->head.mixer->chip->card,
1408 /* get the current value from feature/mixer unit */
1440 /* put the current value to feature/mixer unit */
1497 struct snd_usb_audio *chip = cval->head.mixer->chip;
1506 idx = mixer_ctrl_intf(cval->head.mixer) | (cval->head.id << 8);
1507 if (cval->head.mixer->protocol == UAC_VERSION_2) {
1603 * This symbol is exported in order to allow the mixer quirks to
1617 * A lot of headsets/headphones have a "Speaker" mixer. Make sure we
1655 static void __build_feature_ctl(struct usb_mixer_interface *mixer,
1682 snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
1691 if (mixer->protocol == UAC_VERSION_1)
1720 usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1729 len = snd_usb_copy_string_desc(mixer->chip, nameid,
1745 len = get_term_name(mixer->chip, iterm,
1749 len = get_term_name(mixer->chip, oterm,
1758 check_no_speaker_on_headset(kctl, mixer->chip->card);
1786 usb_audio_dbg(mixer->chip,
1804 snd_usb_mixer_fu_apply_quirk(mixer, cval, unitid, kctl);
1813 usb_audio_warn(mixer->chip,
1816 usb_audio_warn(mixer->chip,
1822 usb_audio_dbg(mixer->chip, "[%d] FU [%s] ch = %d, val = %d/%d/%d\n",
1836 __build_feature_ctl(state->mixer, state->map, ctl_mask, control,
1840 static void build_feature_ctl_badd(struct usb_mixer_interface *mixer,
1844 __build_feature_ctl(mixer, badd_map, ctl_mask, control,
1848 static void get_connector_control_name(struct usb_mixer_interface *mixer,
1852 int name_len = get_term_name(mixer->chip, term, name, name_size, 0);
1877 /* Build a mixer control for a UAC connector control (jack-detect) */
1878 static void build_connector_control(struct usb_mixer_interface *mixer,
1893 snd_usb_mixer_elem_init_std(&cval->head, mixer, term->id);
1908 if (mixer->protocol == UAC_VERSION_2)
1919 usb_audio_err(mixer->chip, "cannot malloc kcontrol\n");
1927 get_connector_control_name(mixer, term, is_input, kctl->id.name,
1941 if (state->mixer->protocol != UAC_VERSION_2)
1956 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, hdr->bClockID);
2000 if (state->mixer->protocol == UAC_VERSION_1) {
2004 } else if (state->mixer->protocol == UAC_VERSION_2) {
2045 if (state->mixer->protocol == UAC_VERSION_1) {
2147 * build a mixer unit control
2170 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2174 __u8 *c = uac_mixer_unit_bmControls(desc, state->mixer->protocol);
2212 if (state->mixer->protocol == UAC_VERSION_2) {
2217 } else if (state->mixer->protocol == UAC_VERSION_3) {
2231 build_connector_control(state->mixer, state->map, &iterm, true);
2237 * parse a mixer unit
2271 if (mixer_bitmap_overflow(desc, state->mixer->protocol,
2279 state->mixer->protocol);
2496 __u8 *controls = uac_processing_unit_bmControls(desc, state->mixer->protocol);
2498 if (state->mixer->protocol == UAC_VERSION_1) {
2514 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2519 if (state->mixer->protocol > UAC_VERSION_1 &&
2529 switch (state->mixer->protocol) {
2544 state->mixer->protocol);
2589 nameid = uac_extension_unit_iExtension(desc, state->mixer->protocol);
2591 nameid = uac_processing_unit_iProcessing(desc, state->mixer->protocol);
2619 switch (state->mixer->protocol) {
2758 snd_usb_mixer_elem_init_std(&cval->head, state->mixer, unitid);
2766 switch (state->mixer->protocol) {
2816 switch (state->mixer->protocol) {
2870 int protocol = state->mixer->protocol;
2927 static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
2930 snd_usb_mixer_disconnect(mixer);
2932 kfree(mixer->id_elems);
2933 if (mixer->urb) {
2934 kfree(mixer->urb->transfer_buffer);
2935 usb_free_urb(mixer->urb);
2937 usb_free_urb(mixer->rc_urb);
2938 kfree(mixer->rc_setup_packet);
2939 kfree(mixer);
2944 struct usb_mixer_interface *mixer = device->device_data;
2945 snd_usb_mixer_free(mixer);
3018 static bool uac3_badd_func_has_valid_channels(struct usb_mixer_interface *mixer,
3028 usb_audio_warn(mixer->chip, "BAAD %s: no channels?",
3037 usb_audio_warn(mixer->chip, "BAAD %s c_chmask mismatch",
3043 usb_audio_warn(mixer->chip, "BAAD %s p_chmask mismatch",
3051 * create mixer controls for UAC3 BADD profiles
3057 static int snd_usb_mixer_controls_badd(struct usb_mixer_interface *mixer,
3060 struct usb_device *dev = mixer->chip->dev;
3062 int badd_profile = mixer->chip->badd_profile;
3112 usb_audio_err(mixer->chip,
3136 usb_audio_dbg(mixer->chip,
3155 if (!uac3_badd_func_has_valid_channels(mixer, f, c_chmask, p_chmask))
3162 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3165 build_feature_ctl_badd(mixer, p_chmask, UAC_FU_VOLUME,
3172 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3175 build_feature_ctl_badd(mixer, c_chmask, UAC_FU_VOLUME,
3182 build_feature_ctl_badd(mixer, 0, UAC_FU_MUTE,
3185 build_feature_ctl_badd(mixer, 1, UAC_FU_VOLUME,
3197 build_connector_control(mixer, map->map, &iterm, true);
3203 build_connector_control(mixer, map->map, &oterm, false);
3210 * create mixer controls
3214 static int snd_usb_mixer_controls(struct usb_mixer_interface *mixer)
3222 state.chip = mixer->chip;
3223 state.mixer = mixer;
3224 state.buffer = mixer->hostif->extra;
3225 state.buflen = mixer->hostif->extralen;
3232 mixer->connector_map = map->connector_map;
3238 while ((p = snd_usb_find_csint_desc(mixer->hostif->extra,
3239 mixer->hostif->extralen,
3241 if (!snd_usb_validate_audio_desc(p, mixer->protocol))
3244 if (mixer->protocol == UAC_VERSION_1) {
3255 } else if (mixer->protocol == UAC_VERSION_2) {
3278 build_connector_control(state.mixer, state.map,
3304 build_connector_control(state.mixer, state.map,
3313 static int delegate_notify(struct usb_mixer_interface *mixer, int unitid,
3316 const struct usbmix_connector_map *map = mixer->connector_map;
3333 void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
3337 unitid = delegate_notify(mixer, unitid, NULL, NULL);
3339 for_each_mixer_elem(list, mixer, unitid) {
3347 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3379 struct usb_mixer_interface *mixer;
3383 list_for_each_entry(mixer, &chip->mixer_list, list) {
3386 chip->usb_id, mixer_ctrl_intf(mixer),
3387 mixer->ignore_ctl_error);
3390 for_each_mixer_elem(list, mixer, unitid) {
3404 static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
3414 usb_audio_dbg(mixer->chip,
3420 unitid = delegate_notify(mixer, unitid, &control, &channel);
3422 for_each_mixer_elem(list, mixer, unitid)
3428 for_each_mixer_elem(list, mixer, unitid) {
3448 snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
3461 usb_audio_dbg(mixer->chip,
3471 struct usb_mixer_interface *mixer = urb->context;
3478 if (mixer->protocol == UAC_VERSION_1) {
3494 snd_usb_mixer_rc_memory_change(mixer, status->bOriginator);
3496 snd_usb_mixer_notify_id(mixer, status->bOriginator);
3509 snd_usb_mixer_interrupt_v2(mixer, msg->bAttribute,
3519 urb->dev = mixer->chip->dev;
3525 static int snd_usb_mixer_status_create(struct usb_mixer_interface *mixer)
3533 if (get_iface_desc(mixer->hostif)->bNumEndpoints < 1)
3535 ep = get_endpoint(mixer->hostif, 0);
3544 mixer->urb = usb_alloc_urb(0, GFP_KERNEL);
3545 if (!mixer->urb) {
3549 usb_fill_int_urb(mixer->urb, mixer->chip->dev,
3550 usb_rcvintpipe(mixer->chip->dev, epnum),
3552 snd_usb_mixer_interrupt, mixer, ep->bInterval);
3553 usb_submit_urb(mixer->urb, GFP_KERNEL);
3562 struct usb_mixer_interface *mixer;
3567 mixer = kzalloc(sizeof(*mixer), GFP_KERNEL);
3568 if (!mixer)
3570 mixer->chip = chip;
3571 mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR);
3572 mixer->id_elems = kcalloc(MAX_ID_ELEMS, sizeof(*mixer->id_elems),
3574 if (!mixer->id_elems) {
3575 kfree(mixer);
3579 mixer->hostif = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0];
3580 switch (get_iface_desc(mixer->hostif)->bInterfaceProtocol) {
3583 mixer->protocol = UAC_VERSION_1;
3586 mixer->protocol = UAC_VERSION_2;
3589 mixer->protocol = UAC_VERSION_3;
3593 if (mixer->protocol == UAC_VERSION_3 &&
3595 err = snd_usb_mixer_controls_badd(mixer, ctrlif);
3599 err = snd_usb_mixer_controls(mixer);
3604 err = snd_usb_mixer_status_create(mixer);
3608 err = snd_usb_mixer_apply_create_quirk(mixer);
3612 err = snd_device_new(chip->card, SNDRV_DEV_CODEC, mixer, &dev_ops);
3620 list_add(&mixer->list, &chip->mixer_list);
3624 snd_usb_mixer_free(mixer);
3628 void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
3630 if (mixer->disconnected)
3632 if (mixer->urb)
3633 usb_kill_urb(mixer->urb);
3634 if (mixer->rc_urb)
3635 usb_kill_urb(mixer->rc_urb);
3636 if (mixer->private_free)
3637 mixer->private_free(mixer);
3638 mixer->disconnected = true;
3641 /* stop any bus activity of a mixer */
3642 static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
3644 usb_kill_urb(mixer->urb);
3645 usb_kill_urb(mixer->rc_urb);
3648 static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
3652 if (mixer->urb) {
3653 err = usb_submit_urb(mixer->urb, GFP_NOIO);
3661 int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
3663 snd_usb_mixer_inactivate(mixer);
3664 if (mixer->private_suspend)
3665 mixer->private_suspend(mixer);
3699 int snd_usb_mixer_resume(struct usb_mixer_interface *mixer)
3704 /* restore cached mixer values */
3706 for_each_mixer_elem(list, mixer, id) {
3715 snd_usb_mixer_resume_quirk(mixer);
3717 return snd_usb_mixer_activate(mixer);
3721 struct usb_mixer_interface *mixer,
3724 list->mixer = mixer;