sound/usb/mixer_quirks.c

5  *   Quirks and vendor-specific extensions for mixer interfaces
33 #include "mixer.h"
55 static int snd_create_std_mono_ctl_offset(struct usb_mixer_interface *mixer,
71 	snd_usb_mixer_elem_init_std(&cval->head, mixer, unitid);
104 	/* Add control to mixer */
108 static int snd_create_std_mono_ctl(struct usb_mixer_interface *mixer,
116 	return snd_create_std_mono_ctl_offset(mixer, unitid, control, cmask,
123 static int snd_create_std_mono_table(struct usb_mixer_interface *mixer,
129 		err = snd_create_std_mono_ctl(mixer, t->unitid, t->control,
139 static int add_single_ctl_with_resume(struct usb_mixer_interface *mixer,
153 	list->mixer = mixer;
195 	struct usb_mixer_interface *mixer = urb->context;
196 	const struct rc_config *rc = mixer->rc_cfg;
202 	code = mixer->rc_buffer[rc->offset];
204 		code |= mixer->rc_buffer[rc->offset + 1] << 8;
206 	/* the Mute button actually changes the mixer control */
208 		snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
209 	mixer->rc_code = code;
211 	wake_up(&mixer->rc_waitq);
217 	struct usb_mixer_interface *mixer = hw->private_data;
223 	err = wait_event_interruptible(mixer->rc_waitq,
224 				       (rc_code = xchg(&mixer->rc_code, 0)) != 0);
237 	struct usb_mixer_interface *mixer = hw->private_data;
239 	poll_wait(file, &mixer->rc_waitq, wait);
240 	return mixer->rc_code ? EPOLLIN | EPOLLRDNORM : 0;
243 static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
249 		if (rc_configs[i].usb_id == mixer->chip->usb_id)
253 	mixer->rc_cfg = &rc_configs[i];
255 	len = mixer->rc_cfg->packet_length;
257 	init_waitqueue_head(&mixer->rc_waitq);
258 	err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
262 		 "%s remote control", mixer->chip->card->shortname);
264 	hwdep->private_data = mixer;
269 	mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
270 	if (!mixer->rc_urb)
272 	mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
273 	if (!mixer->rc_setup_packet) {
274 		usb_free_urb(mixer->rc_urb);
275 		mixer->rc_urb = NULL;
278 	mixer->rc_setup_packet->bRequestType =
280 	mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
281 	mixer->rc_setup_packet->wValue = cpu_to_le16(0);
282 	mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
283 	mixer->rc_setup_packet->wLength = cpu_to_le16(len);
284 	usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
285 			     usb_rcvctrlpipe(mixer->chip->dev, 0),
286 			     (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
287 			     snd_usb_soundblaster_remote_complete, mixer);
299 static int snd_audigy2nx_led_update(struct usb_mixer_interface *mixer,
302 	struct snd_usb_audio *chip = mixer->chip;
333 	struct usb_mixer_interface *mixer = list->mixer;
344 	err = snd_audigy2nx_led_update(mixer, value, index);
352 	return snd_audigy2nx_led_update(list->mixer, priv_value >> 8,
370 static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
378 		if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
381 		if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
384 			(mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
385 			 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
386 			 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
387 			 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
393 		err = add_single_ctl_with_resume(mixer, 0,
421 	struct usb_mixer_interface *mixer = entry->private_data;
425 	snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
426 	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
428 	else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
429 		 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
436 		err = snd_usb_lock_shutdown(mixer->chip);
439 		err = snd_usb_ctl_msg(mixer->chip->dev,
440 				      usb_rcvctrlpipe(mixer->chip->dev, 0),
444 		snd_usb_unlock_shutdown(mixer->chip);
468 static int snd_emu0204_ch_switch_update(struct usb_mixer_interface *mixer,
471 	struct snd_usb_audio *chip = mixer->chip;
493 	struct usb_mixer_interface *mixer = list->mixer;
504 	err = snd_emu0204_ch_switch_update(mixer, value);
510 	return snd_emu0204_ch_switch_update(list->mixer,
523 static int snd_emu0204_controls_create(struct usb_mixer_interface *mixer)
525 	return add_single_ctl_with_resume(mixer, 0,
539 static int snd_xonar_u1_switch_update(struct usb_mixer_interface *mixer,
542 	struct snd_usb_audio *chip = mixer->chip;
572 	err = snd_xonar_u1_switch_update(list->mixer, new_status);
578 	return snd_xonar_u1_switch_update(list->mixer,
591 static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
593 	return add_single_ctl_with_resume(mixer, 0,
681 	struct snd_usb_audio *chip = list->mixer->chip;
700 static int snd_mbox1_clk_switch_update(struct usb_mixer_interface *mixer, int is_spdif_sync)
702 	struct snd_usb_audio *chip = mixer->chip;
732 	struct usb_mixer_interface *mixer = list->mixer;
742 	err = snd_mbox1_clk_switch_update(mixer, new_val);
759 	return snd_mbox1_clk_switch_update(list->mixer, list->kctl->private_value);
771 static int snd_mbox1_src_switch_update(struct usb_mixer_interface *mixer, int is_spdif_input)
773 	struct snd_usb_audio *chip = mixer->chip;
802 	struct usb_mixer_interface *mixer = list->mixer;
812 	err = snd_mbox1_src_switch_update(mixer, new_val);
829 	return snd_mbox1_src_switch_update(list->mixer, list->kctl->private_value);
854 static int snd_mbox1_controls_create(struct usb_mixer_interface *mixer)
857 	err = add_single_ctl_with_resume(mixer, 0,
863 	return add_single_ctl_with_resume(mixer, 1,
872 static int snd_ni_control_init_val(struct usb_mixer_interface *mixer,
875 	struct usb_device *dev = mixer->chip->dev;
903 	struct snd_usb_audio *chip = list->mixer->chip;
989 static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
1008 		err = add_single_ctl_with_resume(mixer, 0,
1013 		snd_ni_control_init_val(mixer, list->kctl);
1032 static int snd_ftu_eff_switch_init(struct usb_mixer_interface *mixer,
1035 	struct usb_device *dev = mixer->chip->dev;
1046 			      snd_usb_ctrl_intf(mixer->chip) | ((pval & 0xff) << 8),
1064 	struct snd_usb_audio *chip = list->mixer->chip;
1104 static int snd_ftu_create_effect_switch(struct usb_mixer_interface *mixer,
1119 	err = add_single_ctl_with_resume(mixer, bUnitID,
1125 	snd_ftu_eff_switch_init(mixer, list->kctl);
1130 static int snd_ftu_create_volume_ctls(struct usb_mixer_interface *mixer)
1146 			err = snd_create_std_mono_ctl(mixer, id, control,
1157 			err = snd_create_std_mono_ctl(mixer, id, control,
1168 /* This control needs a volume quirk, see mixer.c */
1169 static int snd_ftu_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1177 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1181 /* This control needs a volume quirk, see mixer.c */
1182 static int snd_ftu_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1190 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1194 /* This control needs a volume quirk, see mixer.c */
1195 static int snd_ftu_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1203 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1207 static int snd_ftu_create_effect_return_ctls(struct usb_mixer_interface *mixer)
1221 		err = snd_create_std_mono_ctl(mixer, id, control,
1231 static int snd_ftu_create_effect_send_ctls(struct usb_mixer_interface *mixer)
1245 		err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1255 		err = snd_create_std_mono_ctl(mixer, id, control, cmask,
1264 static int snd_ftu_create_mixer(struct usb_mixer_interface *mixer)
1268 	err = snd_ftu_create_volume_ctls(mixer);
1272 	err = snd_ftu_create_effect_switch(mixer, 1, 6);
1276 	err = snd_ftu_create_effect_volume_ctl(mixer);
1280 	err = snd_ftu_create_effect_duration_ctl(mixer);
1284 	err = snd_ftu_create_effect_feedback_ctl(mixer);
1288 	err = snd_ftu_create_effect_return_ctls(mixer);
1292 	err = snd_ftu_create_effect_send_ctls(mixer);
1302 	struct usb_mixer_interface *mixer;
1306 	list_for_each_entry(mixer, &chip->mixer_list, list) {
1307 		if (mixer->id_elems[unitid]) {
1308 			cval = mixer_elem_list_to_info(mixer->id_elems[unitid]);
1312 			snd_usb_mixer_notify_id(mixer, unitid);
1319 /* C400/C600 volume controls, this control needs a volume quirk, see mixer.c */
1320 static int snd_c400_create_vol_ctls(struct usb_mixer_interface *mixer)
1332 	switch (mixer->chip->usb_id) {
1357 			err = snd_create_std_mono_ctl_offset(mixer, id, control,
1368 /* This control needs a volume quirk, see mixer.c */
1369 static int snd_c400_create_effect_volume_ctl(struct usb_mixer_interface *mixer)
1377 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1381 /* This control needs a volume quirk, see mixer.c */
1382 static int snd_c400_create_effect_duration_ctl(struct usb_mixer_interface *mixer)
1390 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1394 /* This control needs a volume quirk, see mixer.c */
1395 static int snd_c400_create_effect_feedback_ctl(struct usb_mixer_interface *mixer)
1403 	return snd_create_std_mono_ctl(mixer, id, control, cmask, val_type,
1407 static int snd_c400_create_effect_vol_ctls(struct usb_mixer_interface *mixer)
1419 	switch (mixer->chip->usb_id) {
1442 		err = snd_create_std_mono_ctl(mixer, id, control,
1452 static int snd_c400_create_effect_ret_vol_ctls(struct usb_mixer_interface *mixer)
1464 	switch (mixer->chip->usb_id) {
1484 		err = snd_create_std_mono_ctl_offset(mixer, id, control,
1494 static int snd_c400_create_mixer(struct usb_mixer_interface *mixer)
1498 	err = snd_c400_create_vol_ctls(mixer);
1502 	err = snd_c400_create_effect_vol_ctls(mixer);
1506 	err = snd_c400_create_effect_ret_vol_ctls(mixer);
1510 	err = snd_ftu_create_effect_switch(mixer, 2, 0x43);
1514 	err = snd_c400_create_effect_volume_ctl(mixer);
1518 	err = snd_c400_create_effect_duration_ctl(mixer);
1522 	err = snd_c400_create_effect_feedback_ctl(mixer);
1530  * The mixer units for Ebox-44 are corrupt, and even where they
1532  * stereo. So we provide a good mixer here.
1638 	struct snd_usb_audio *chip = list->mixer->chip;
1690 	struct snd_usb_audio *chip = list->mixer->chip;
1777 	struct snd_usb_audio *chip = list->mixer->chip;
1840 static int snd_microii_controls_create(struct usb_mixer_interface *mixer)
1850 		err = add_single_ctl_with_resume(mixer, 0,
1870 static int snd_soundblaster_e1_switch_update(struct usb_mixer_interface *mixer,
1873 	struct snd_usb_audio *chip = mixer->chip;
1901 	err = snd_soundblaster_e1_switch_update(list->mixer, value);
1907 	return snd_soundblaster_e1_switch_update(list->mixer,
1930 static int snd_soundblaster_e1_switch_create(struct usb_mixer_interface *mixer)
1932 	return add_single_ctl_with_resume(mixer, 0,
2002 	struct snd_usb_audio *chip = cval->head.mixer->chip;
2054 	snd_ctl_notify(list->mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
2059 static int realtek_add_jack(struct usb_mixer_interface *mixer,
2068 	snd_usb_mixer_elem_init_std(&cval->head, mixer,
2086 static int dell_dock_mixer_create(struct usb_mixer_interface *mixer)
2089 	struct usb_device *dev = mixer->chip->dev;
2092 	realtek_hda_set(mixer->chip,
2105 	err = realtek_add_jack(mixer, "Line Out Jack", REALTEK_LINE1);
2108 	err = realtek_add_jack(mixer, "Headphone Jack", REALTEK_HP_OUT);
2111 	err = realtek_add_jack(mixer, "Headset Mic Jack",
2129 static int dell_dock_mixer_init(struct usb_mixer_interface *mixer)
2132 	dell_dock_init_vol(mixer->chip, 1, 16);
2133 	dell_dock_init_vol(mixer->chip, 2, 16);
2134 	dell_dock_init_vol(mixer->chip, 1, 19);
2135 	dell_dock_init_vol(mixer->chip, 2, 19);
2219 	struct snd_usb_audio *chip = list->mixer->chip;
2337 	struct snd_usb_audio *chip = list->mixer->chip;
2497 static int snd_rme_controls_create(struct usb_mixer_interface *mixer)
2502 		err = add_single_ctl_with_resume(mixer, 0,
2554 static int snd_bbfpro_ctl_update(struct usb_mixer_interface *mixer, u8 reg,
2559 	struct snd_usb_audio *chip = mixer->chip;
2654 	struct usb_mixer_interface *mixer = list->mixer;
2681 	err = snd_bbfpro_ctl_update(mixer, reg, idx, val);
2695 	return snd_bbfpro_ctl_update(list->mixer, reg, idx, value);
2698 static int snd_bbfpro_vol_update(struct usb_mixer_interface *mixer, u16 index,
2701 	struct snd_usb_audio *chip = mixer->chip;
2753 	struct usb_mixer_interface *mixer = list->mixer;
2770 	err = snd_bbfpro_vol_update(mixer, idx, new_val);
2780 	return snd_bbfpro_vol_update(list->mixer, idx, val);
2802 static int snd_bbfpro_ctl_add(struct usb_mixer_interface *mixer, u8 reg,
2812 	return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_ctl_resume,
2816 static int snd_bbfpro_vol_add(struct usb_mixer_interface *mixer, u16 index,
2824 	return add_single_ctl_with_resume(mixer, 0, snd_bbfpro_vol_resume,
2828 static int snd_bbfpro_controls_create(struct usb_mixer_interface *mixer)
2848 			err = snd_bbfpro_vol_add(mixer, (26 * o + i), name);
2856 			err = snd_bbfpro_vol_add(mixer, (26 * o + 12 + i),
2864 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2870 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2876 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2882 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG1,
2889 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2895 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2901 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2907 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2913 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
2919 	err = snd_bbfpro_ctl_add(mixer, SND_BBFPRO_CTL_REG2,
3268 static int snd_djm_controls_update(struct usb_mixer_interface *mixer,
3277 	err = snd_usb_lock_shutdown(mixer->chip);
3282 		mixer->chip->dev, usb_sndctrlpipe(mixer->chip->dev, 0),
3289 	snd_usb_unlock_shutdown(mixer->chip);
3303 	struct usb_mixer_interface *mixer = list->mixer;
3314 	return snd_djm_controls_update(mixer, device, group, value);
3324 	return snd_djm_controls_update(list->mixer, device, group, value);
3327 static int snd_djm_controls_create(struct usb_mixer_interface *mixer,
3351 		err = snd_djm_controls_update(mixer, device_idx, i, value);
3354 		err = add_single_ctl_with_resume(mixer, 0, snd_djm_controls_resume,
3362 int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
3366 	err = snd_usb_soundblaster_remote_init(mixer);
3370 	switch (mixer->chip->usb_id) {
3373 		err = snd_us16x08_controls_create(mixer);
3380 		err = snd_audigy2nx_controls_create(mixer);
3383 		snd_card_ro_proc_new(mixer->chip->card, "audigy2nx",
3384 				     mixer, snd_audigy2nx_proc_read);
3389 		err = snd_emu0204_controls_create(mixer);
3394 		err = snd_c400_create_mixer(mixer);
3399 		err = snd_ftu_create_mixer(mixer);
3405 		err = snd_xonar_u1_controls_create(mixer);
3409 		err = snd_microii_controls_create(mixer);
3413 		err = snd_mbox1_controls_create(mixer);
3417 		err = snd_nativeinstruments_create_mixer(mixer,
3423 		err = snd_nativeinstruments_create_mixer(mixer,
3430 		err = snd_create_std_mono_table(mixer, ebox44_table);
3438 		err = snd_scarlett_controls_create(mixer);
3461 		err = snd_scarlett2_init(mixer);
3465 		err = snd_soundblaster_e1_switch_create(mixer);
3468 		err = dell_dock_mixer_create(mixer);
3471 		err = dell_dock_mixer_init(mixer);
3477 		err = snd_rme_controls_create(mixer);
3481 		err = snd_sc1810_init_mixer(mixer);
3484 		err = snd_bbfpro_controls_create(mixer);
3487 		err = snd_djm_controls_create(mixer, SND_DJM_250MK2_IDX);
3490 		err = snd_djm_controls_create(mixer, SND_DJM_450_IDX);
3493 		err = snd_djm_controls_create(mixer, SND_DJM_750_IDX);
3496 		err = snd_djm_controls_create(mixer, SND_DJM_750MK2_IDX);
3499 		err = snd_djm_controls_create(mixer, SND_DJM_850_IDX);
3502 		err = snd_djm_controls_create(mixer, SND_DJM_900NXS2_IDX);
3509 void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
3511 	switch (mixer->chip->usb_id) {
3513 		dell_dock_mixer_init(mixer);
3518 void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
3521 	if (!mixer->rc_cfg)
3526 		mixer->rc_urb->dev = mixer->chip->dev;
3527 		usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
3536 		if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
3537 		    mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
3538 			snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
3541 		usb_audio_dbg(mixer->chip, "memory change in unknown unit %d\n", unitid);
3546 static void snd_dragonfly_quirk_db_scale(struct usb_mixer_interface *mixer,
3566 		usb_audio_info(mixer->chip, "applying DragonFly dB scale quirk (0-50 variant)\n");
3575 		usb_audio_info(mixer->chip, "ignoring too narrow dB range on a DragonFly device");
3580 void snd_usb_mixer_fu_apply_quirk(struct usb_mixer_interface *mixer,
3584 	switch (mixer->chip->usb_id) {
3587 			snd_dragonfly_quirk_db_scale(mixer, cval, kctl);