[deliverable/linux.git] / sound / usb / mixer_quirks.c

/*
 *   USB Audio Driver for ALSA
 *
 *   Quirks and vendor-specific extensions for mixer interfaces
 *
 *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
 *
 *   Many codes borrowed from audio.c by
 *	    Alan Cox (alan@lxorguk.ukuu.org.uk)
 *	    Thomas Sailer (sailer@ife.ee.ethz.ch)
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/usb/audio.h>

#include <sound/core.h>
#include <sound/control.h>
#include <sound/hwdep.h>
#include <sound/info.h>

#include "usbaudio.h"
#include "mixer.h"
#include "mixer_quirks.h"
#include "helper.h"

extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;

/*
 * Sound Blaster remote control configuration
 *
 * format of remote control data:
 * Extigy:       xx 00
 * Audigy 2 NX:  06 80 xx 00 00 00
 * Live! 24-bit: 06 80 xx yy 22 83
 */
static const struct rc_config {
	u32 usb_id;
	u8  offset;
	u8  length;
	u8  packet_length;
	u8  min_packet_length; /* minimum accepted length of the URB result */
	u8  mute_mixer_id;
	u32 mute_code;
} rc_configs[] = {
	{ USB_ID(0x041e, 0x3000), 0, 1, 2, 1,  18, 0x0013 }, /* Extigy       */
	{ USB_ID(0x041e, 0x3020), 2, 1, 6, 6,  18, 0x0013 }, /* Audigy 2 NX  */
	{ USB_ID(0x041e, 0x3040), 2, 2, 6, 6,  2,  0x6e91 }, /* Live! 24-bit */
	{ USB_ID(0x041e, 0x3042), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 */
	{ USB_ID(0x041e, 0x30df), 0, 1, 1, 1,  1,  0x000d }, /* Usb X-Fi S51 Pro */
	{ USB_ID(0x041e, 0x3048), 2, 2, 6, 6,  2,  0x6e91 }, /* Toshiba SB0500 */
};

static void snd_usb_soundblaster_remote_complete(struct urb *urb)
{
	struct usb_mixer_interface *mixer = urb->context;
	const struct rc_config *rc = mixer->rc_cfg;
	u32 code;

	if (urb->status < 0 || urb->actual_length < rc->min_packet_length)
		return;

	code = mixer->rc_buffer[rc->offset];
	if (rc->length == 2)
		code |= mixer->rc_buffer[rc->offset + 1] << 8;

	/* the Mute button actually changes the mixer control */
	if (code == rc->mute_code)
		snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
	mixer->rc_code = code;
	wmb();
	wake_up(&mixer->rc_waitq);
}

static long snd_usb_sbrc_hwdep_read(struct snd_hwdep *hw, char __user *buf,
				     long count, loff_t *offset)
{
	struct usb_mixer_interface *mixer = hw->private_data;
	int err;
	u32 rc_code;

	if (count != 1 && count != 4)
		return -EINVAL;
	err = wait_event_interruptible(mixer->rc_waitq,
				       (rc_code = xchg(&mixer->rc_code, 0)) != 0);
	if (err == 0) {
		if (count == 1)
			err = put_user(rc_code, buf);
		else
			err = put_user(rc_code, (u32 __user *)buf);
	}
	return err < 0 ? err : count;
}

static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep *hw, struct file *file,
					    poll_table *wait)
{
	struct usb_mixer_interface *mixer = hw->private_data;

	poll_wait(file, &mixer->rc_waitq, wait);
	return mixer->rc_code ? POLLIN | POLLRDNORM : 0;
}

static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
{
	struct snd_hwdep *hwdep;
	int err, len, i;

	for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
		if (rc_configs[i].usb_id == mixer->chip->usb_id)
			break;
	if (i >= ARRAY_SIZE(rc_configs))
		return 0;
	mixer->rc_cfg = &rc_configs[i];

	len = mixer->rc_cfg->packet_length;

	init_waitqueue_head(&mixer->rc_waitq);
	err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
	if (err < 0)
		return err;
	snprintf(hwdep->name, sizeof(hwdep->name),
		 "%s remote control", mixer->chip->card->shortname);
	hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
	hwdep->private_data = mixer;
	hwdep->ops.read = snd_usb_sbrc_hwdep_read;
	hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
	hwdep->exclusive = 1;

	mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
	if (!mixer->rc_urb)
		return -ENOMEM;
	mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
	if (!mixer->rc_setup_packet) {
		usb_free_urb(mixer->rc_urb);
		mixer->rc_urb = NULL;
		return -ENOMEM;
	}
	mixer->rc_setup_packet->bRequestType =
		USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
	mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
	mixer->rc_setup_packet->wValue = cpu_to_le16(0);
	mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
	mixer->rc_setup_packet->wLength = cpu_to_le16(len);
	usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
			     usb_rcvctrlpipe(mixer->chip->dev, 0),
			     (u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
			     snd_usb_soundblaster_remote_complete, mixer);
	return 0;
}

#define snd_audigy2nx_led_info		snd_ctl_boolean_mono_info

static int snd_audigy2nx_led_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	int index = kcontrol->private_value;

	ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
	return 0;
}

static int snd_audigy2nx_led_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	int index = kcontrol->private_value;
	int value = ucontrol->value.integer.value[0];
	int err, changed;

	if (value > 1)
		return -EINVAL;
	changed = value != mixer->audigy2nx_leds[index];
	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
		err = snd_usb_ctl_msg(mixer->chip->dev,
			      usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
			      !value, 0, NULL, 0);
	/* USB X-Fi S51 Pro */
	if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df))
		err = snd_usb_ctl_msg(mixer->chip->dev,
			      usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
			      !value, 0, NULL, 0);
	else
		err = snd_usb_ctl_msg(mixer->chip->dev,
			      usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
			      value, index + 2, NULL, 0);
	if (err < 0)
		return err;
	mixer->audigy2nx_leds[index] = value;
	return changed;
}

static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "CMSS LED Switch",
		.info = snd_audigy2nx_led_info,
		.get = snd_audigy2nx_led_get,
		.put = snd_audigy2nx_led_put,
		.private_value = 0,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Power LED Switch",
		.info = snd_audigy2nx_led_info,
		.get = snd_audigy2nx_led_get,
		.put = snd_audigy2nx_led_put,
		.private_value = 1,
	},
	{
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.name = "Dolby Digital LED Switch",
		.info = snd_audigy2nx_led_info,
		.get = snd_audigy2nx_led_get,
		.put = snd_audigy2nx_led_put,
		.private_value = 2,
	},
};

static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
{
	int i, err;

	for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
		/* USB X-Fi S51 doesn't have a CMSS LED */
		if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
			continue;
		/* USB X-Fi S51 Pro doesn't have one either */
		if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
			continue;
		if (i > 1 && /* Live24ext has 2 LEDs only */
			(mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
			 mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
			 mixer->chip->usb_id == USB_ID(0x041e, 0x30df) ||
			 mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
			break; 
		err = snd_ctl_add(mixer->chip->card,
				  snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
		if (err < 0)
			return err;
	}
	mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
	return 0;
}

static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
				    struct snd_info_buffer *buffer)
{
	static const struct sb_jack {
		int unitid;
		const char *name;
	}  jacks_audigy2nx[] = {
		{4,  "dig in "},
		{7,  "line in"},
		{19, "spk out"},
		{20, "hph out"},
		{-1, NULL}
	}, jacks_live24ext[] = {
		{4,  "line in"}, /* &1=Line, &2=Mic*/
		{3,  "hph out"}, /* headphones */
		{0,  "RC     "}, /* last command, 6 bytes see rc_config above */
		{-1, NULL}
	};
	const struct sb_jack *jacks;
	struct usb_mixer_interface *mixer = entry->private_data;
	int i, err;
	u8 buf[3];

	snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
		jacks = jacks_audigy2nx;
	else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
		 mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
		jacks = jacks_live24ext;
	else
		return;

	for (i = 0; jacks[i].name; ++i) {
		snd_iprintf(buffer, "%s: ", jacks[i].name);
		err = snd_usb_ctl_msg(mixer->chip->dev,
				      usb_rcvctrlpipe(mixer->chip->dev, 0),
				      UAC_GET_MEM, USB_DIR_IN | USB_TYPE_CLASS |
				      USB_RECIP_INTERFACE, 0,
				      jacks[i].unitid << 8, buf, 3);
		if (err == 3 && (buf[0] == 3 || buf[0] == 6))
			snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
		else
			snd_iprintf(buffer, "?\n");
	}
}

static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);

	ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
	return 0;
}

static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
				   struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	u8 old_status, new_status;
	int err, changed;

	old_status = mixer->xonar_u1_status;
	if (ucontrol->value.integer.value[0])
		new_status = old_status | 0x02;
	else
		new_status = old_status & ~0x02;
	changed = new_status != old_status;
	err = snd_usb_ctl_msg(mixer->chip->dev,
			      usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
			      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
			      50, 0, &new_status, 1);
	if (err < 0)
		return err;
	mixer->xonar_u1_status = new_status;
	return changed;
}

static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Digital Playback Switch",
	.info = snd_ctl_boolean_mono_info,
	.get = snd_xonar_u1_switch_get,
	.put = snd_xonar_u1_switch_put,
};

static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
{
	int err;

	err = snd_ctl_add(mixer->chip->card,
			  snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
	if (err < 0)
		return err;
	mixer->xonar_u1_status = 0x05;
	return 0;
}

/* Native Instruments device quirks */

#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 | (wIndex))

static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
					     struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	struct usb_device *dev = mixer->chip->dev;
	u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
	u16 wIndex = kcontrol->private_value & 0xffff;
	u8 tmp;

	int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
				  USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
				  0, cpu_to_le16(wIndex),
				  &tmp, sizeof(tmp), 1000);

	if (ret < 0) {
		snd_printk(KERN_ERR
			   "unable to issue vendor read request (ret = %d)", ret);
		return ret;
	}

	ucontrol->value.integer.value[0] = tmp;

	return 0;
}

static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
					     struct snd_ctl_elem_value *ucontrol)
{
	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	struct usb_device *dev = mixer->chip->dev;
	u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
	u16 wIndex = kcontrol->private_value & 0xffff;
	u16 wValue = ucontrol->value.integer.value[0];

	int ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
				  USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
				  cpu_to_le16(wValue), cpu_to_le16(wIndex),
				  NULL, 0, 1000);

	if (ret < 0) {
		snd_printk(KERN_ERR
			   "unable to issue vendor write request (ret = %d)", ret);
		return ret;
	}

	return 0;
}

static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
	{
		.name = "Direct Thru Channel A",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x03),
	},
	{
		.name = "Direct Thru Channel B",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x05),
	},
	{
		.name = "Phono Input Channel A",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x03),
	},
	{
		.name = "Phono Input Channel B",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x05),
	},
};

static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
	{
		.name = "Direct Thru Channel A",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x03),
	},
	{
		.name = "Direct Thru Channel B",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x05),
	},
	{
		.name = "Direct Thru Channel C",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x07),
	},
	{
		.name = "Direct Thru Channel D",
		.private_value = _MAKE_NI_CONTROL(0x01, 0x09),
	},
	{
		.name = "Phono Input Channel A",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x03),
	},
	{
		.name = "Phono Input Channel B",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x05),
	},
	{
		.name = "Phono Input Channel C",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x07),
	},
	{
		.name = "Phono Input Channel D",
		.private_value = _MAKE_NI_CONTROL(0x02, 0x09),
	},
};

static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
					      const struct snd_kcontrol_new *kc,
					      unsigned int count)
{
	int i, err = 0;
	struct snd_kcontrol_new template = {
		.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
		.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
		.get = snd_nativeinstruments_control_get,
		.put = snd_nativeinstruments_control_put,
		.info = snd_ctl_boolean_mono_info,
	};

	for (i = 0; i < count; i++) {
		struct snd_kcontrol *c;

		template.name = kc[i].name;
		template.private_value = kc[i].private_value;

		c = snd_ctl_new1(&template, mixer);
		err = snd_ctl_add(mixer->chip->card, c);

		if (err < 0)
			break;
	}

	return err;
}

/* M-Audio FastTrack Ultra quirks */

/* private_free callback */
static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
{
	kfree(kctl->private_data);
	kctl->private_data = NULL;
}

static int snd_maudio_ftu_create_ctl(struct usb_mixer_interface *mixer,
				     int in, int out, const char *name)
{
	struct usb_mixer_elem_info *cval;
	struct snd_kcontrol *kctl;

	cval = kzalloc(sizeof(*cval), GFP_KERNEL);
	if (!cval)
		return -ENOMEM;

	cval->id = 5;
	cval->mixer = mixer;
	cval->val_type = USB_MIXER_S16;
	cval->channels = 1;
	cval->control = out + 1;
	cval->cmask = 1 << in;

	kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
	if (!kctl) {
		kfree(cval);
		return -ENOMEM;
	}

	snprintf(kctl->id.name, sizeof(kctl->id.name), name);
	kctl->private_free = usb_mixer_elem_free;
	return snd_usb_mixer_add_control(mixer, kctl);
}

static int snd_maudio_ftu_create_mixer(struct usb_mixer_interface *mixer)
{
	char name[64];
	int in, out, err;

	for (out = 0; out < 8; out++) {
		for (in = 0; in < 8; in++) {
			snprintf(name, sizeof(name),
				 "AIn%d - Out%d Capture Volume", in  + 1, out + 1);
			err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
			if (err < 0)
				return err;
		}

		for (in = 8; in < 16; in++) {
			snprintf(name, sizeof(name),
				 "DIn%d - Out%d Playback Volume", in - 7, out + 1);
			err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
			if (err < 0)
				return err;
		}
	}

	return 0;
}

void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
			       unsigned char samplerate_id)
{
	struct usb_mixer_interface *mixer;
	struct usb_mixer_elem_info *cval;
	int unitid = 12; /* SamleRate ExtensionUnit ID */

	list_for_each_entry(mixer, &chip->mixer_list, list) {
		cval = mixer->id_elems[unitid];
		if (cval) {
			snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
						    cval->control << 8,
						    samplerate_id);
			snd_usb_mixer_notify_id(mixer, unitid);
		}
		break;
	}
}

int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
{
	int err = 0;
	struct snd_info_entry *entry;

	if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
		return err;

	switch (mixer->chip->usb_id) {
	case USB_ID(0x041e, 0x3020):
	case USB_ID(0x041e, 0x3040):
	case USB_ID(0x041e, 0x3042):
	case USB_ID(0x041e, 0x30df):
	case USB_ID(0x041e, 0x3048):
		err = snd_audigy2nx_controls_create(mixer);
		if (err < 0)
			break;
		if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
			snd_info_set_text_ops(entry, mixer,
					      snd_audigy2nx_proc_read);
		break;

	case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
	case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
		err = snd_maudio_ftu_create_mixer(mixer);
		break;

	case USB_ID(0x0b05, 0x1739):
	case USB_ID(0x0b05, 0x1743):
		err = snd_xonar_u1_controls_create(mixer);
		break;

	case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
		err = snd_nativeinstruments_create_mixer(mixer,
				snd_nativeinstruments_ta6_mixers,
				ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
		break;

	case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
		err = snd_nativeinstruments_create_mixer(mixer,
				snd_nativeinstruments_ta10_mixers,
				ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
		break;
	}

	return err;
}

void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
				    int unitid)
{
	if (!mixer->rc_cfg)
		return;
	/* unit ids specific to Extigy/Audigy 2 NX: */
	switch (unitid) {
	case 0: /* remote control */
		mixer->rc_urb->dev = mixer->chip->dev;
		usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
		break;
	case 4: /* digital in jack */
	case 7: /* line in jacks */
	case 19: /* speaker out jacks */
	case 20: /* headphones out jack */
		break;
	/* live24ext: 4 = line-in jack */
	case 3:	/* hp-out jack (may actuate Mute) */
		if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
		    mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
			snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
		break;
	default:
		snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
		break;
	}
}
Commit	Line	Data
7b1eda22 DM	1	/*
	2	* USB Audio Driver for ALSA
	3	*
	4	* Quirks and vendor-specific extensions for mixer interfaces
	5	*
	6	* Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
	7	*
	8	* Many codes borrowed from audio.c by
	9	* Alan Cox (alan@lxorguk.ukuu.org.uk)
	10	* Thomas Sailer (sailer@ife.ee.ethz.ch)
	11	*
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* This program is distributed in the hope that it will be useful,
	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	21	* GNU General Public License for more details.
	22	*
	23	* You should have received a copy of the GNU General Public License
	24	* along with this program; if not, write to the Free Software
	25	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	26	*/
	27
	28	#include <linux/init.h>
36db0456	29	#include <linux/slab.h>
7b1eda22 DM	30	#include <linux/usb.h>
	31	#include <linux/usb/audio.h>
	32
	33	#include <sound/core.h>
	34	#include <sound/control.h>
	35	#include <sound/hwdep.h>
	36	#include <sound/info.h>
	37
	38	#include "usbaudio.h"
f0b5e634	39	#include "mixer.h"
7b1eda22 DM	40	#include "mixer_quirks.h"
	41	#include "helper.h"
	42
d5a0bf6c DM	43	extern struct snd_kcontrol_new *snd_usb_feature_unit_ctl;
d5a0bf6c DM	44
7b1eda22 DM	45	/*
	46	* Sound Blaster remote control configuration
	47	*
	48	* format of remote control data:
	49	* Extigy: xx 00
	50	* Audigy 2 NX: 06 80 xx 00 00 00
	51	* Live! 24-bit: 06 80 xx yy 22 83
	52	*/
	53	static const struct rc_config {
	54	u32 usb_id;
	55	u8 offset;
	56	u8 length;
	57	u8 packet_length;
	58	u8 min_packet_length; /* minimum accepted length of the URB result */
	59	u8 mute_mixer_id;
	60	u32 mute_code;
	61	} rc_configs[] = {
	62	{ USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
	63	{ USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
	64	{ USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
ca8dc34e	65	{ USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
7cdd8d73	66	{ USB_ID(0x041e, 0x30df), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 Pro */
7b1eda22 DM	67	{ USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
	68	};
	69
	70	static void snd_usb_soundblaster_remote_complete(struct urb *urb)
	71	{
	72	struct usb_mixer_interface *mixer = urb->context;
	73	const struct rc_config *rc = mixer->rc_cfg;
	74	u32 code;
	75
	76	if (urb->status < 0 \|\| urb->actual_length < rc->min_packet_length)
	77	return;
	78
	79	code = mixer->rc_buffer[rc->offset];
	80	if (rc->length == 2)
	81	code \|= mixer->rc_buffer[rc->offset + 1] << 8;
	82
	83	/* the Mute button actually changes the mixer control */
	84	if (code == rc->mute_code)
	85	snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
	86	mixer->rc_code = code;
	87	wmb();
	88	wake_up(&mixer->rc_waitq);
	89	}
	90
	91	static long snd_usb_sbrc_hwdep_read(struct snd_hwdep hw, char __user buf,
	92	long count, loff_t *offset)
	93	{
	94	struct usb_mixer_interface *mixer = hw->private_data;
	95	int err;
	96	u32 rc_code;
	97
	98	if (count != 1 && count != 4)
	99	return -EINVAL;
	100	err = wait_event_interruptible(mixer->rc_waitq,
	101	(rc_code = xchg(&mixer->rc_code, 0)) != 0);
	102	if (err == 0) {
	103	if (count == 1)
	104	err = put_user(rc_code, buf);
	105	else
	106	err = put_user(rc_code, (u32 __user *)buf);
	107	}
	108	return err < 0 ? err : count;
	109	}
	110
	111	static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep hw, struct file file,
	112	poll_table *wait)
	113	{
	114	struct usb_mixer_interface *mixer = hw->private_data;
	115
	116	poll_wait(file, &mixer->rc_waitq, wait);
	117	return mixer->rc_code ? POLLIN \| POLLRDNORM : 0;
	118	}
	119
	120	static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
	121	{
	122	struct snd_hwdep *hwdep;
	123	int err, len, i;
	124
	125	for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
	126	if (rc_configs[i].usb_id == mixer->chip->usb_id)
	127	break;
	128	if (i >= ARRAY_SIZE(rc_configs))
	129	return 0;
	130	mixer->rc_cfg = &rc_configs[i];
131
132	len = mixer->rc_cfg->packet_length;
133
134	init_waitqueue_head(&mixer->rc_waitq);
135	err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
136	if (err < 0)
137	return err;
138	snprintf(hwdep->name, sizeof(hwdep->name),
139	"%s remote control", mixer->chip->card->shortname);
140	hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
141	hwdep->private_data = mixer;
142	hwdep->ops.read = snd_usb_sbrc_hwdep_read;
143	hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
144	hwdep->exclusive = 1;
145
146	mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
147	if (!mixer->rc_urb)
148	return -ENOMEM;
149	mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
150	if (!mixer->rc_setup_packet) {
151	usb_free_urb(mixer->rc_urb);
152	mixer->rc_urb = NULL;
153	return -ENOMEM;
154	}
155	mixer->rc_setup_packet->bRequestType =
156	USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE;
157	mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
158	mixer->rc_setup_packet->wValue = cpu_to_le16(0);
159	mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
160	mixer->rc_setup_packet->wLength = cpu_to_le16(len);
161	usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
162	usb_rcvctrlpipe(mixer->chip->dev, 0),
163	(u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
164	snd_usb_soundblaster_remote_complete, mixer);
165	return 0;
166	}
167
168	#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
169
170	static int snd_audigy2nx_led_get(struct snd_kcontrol kcontrol, struct snd_ctl_elem_value ucontrol)
171	{
172	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
173	int index = kcontrol->private_value;
174
175	ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
176	return 0;
177	}
178
179	static int snd_audigy2nx_led_put(struct snd_kcontrol kcontrol, struct snd_ctl_elem_value ucontrol)
180	{
181	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
182	int index = kcontrol->private_value;
183	int value = ucontrol->value.integer.value[0];
184	int err, changed;
185
186	if (value > 1)
187	return -EINVAL;
188	changed = value != mixer->audigy2nx_leds[index];
ca8dc34e MJ	189	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
	190	err = snd_usb_ctl_msg(mixer->chip->dev,
	191	usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
	192	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
17d900c4	193	!value, 0, NULL, 0);
7cdd8d73 MB	194	/* USB X-Fi S51 Pro */
	195	if (mixer->chip->usb_id == USB_ID(0x041e, 0x30df))
	196	err = snd_usb_ctl_msg(mixer->chip->dev,
	197	usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
	198	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
17d900c4	199	!value, 0, NULL, 0);
ca8dc34e MJ	200	else
ca8dc34e MJ	201	err = snd_usb_ctl_msg(mixer->chip->dev,
7b1eda22 DM	202	usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
7b1eda22 DM	203	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
17d900c4	204	value, index + 2, NULL, 0);
7b1eda22 DM	205	if (err < 0)
	206	return err;
	207	mixer->audigy2nx_leds[index] = value;
	208	return changed;
	209	}
	210
	211	static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
	212	{
	213	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	214	.name = "CMSS LED Switch",
	215	.info = snd_audigy2nx_led_info,
	216	.get = snd_audigy2nx_led_get,
	217	.put = snd_audigy2nx_led_put,
	218	.private_value = 0,
	219	},
	220	{
	221	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	222	.name = "Power LED Switch",
	223	.info = snd_audigy2nx_led_info,
	224	.get = snd_audigy2nx_led_get,
	225	.put = snd_audigy2nx_led_put,
	226	.private_value = 1,
	227	},
	228	{
	229	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	230	.name = "Dolby Digital LED Switch",
	231	.info = snd_audigy2nx_led_info,
	232	.get = snd_audigy2nx_led_get,
	233	.put = snd_audigy2nx_led_put,
	234	.private_value = 2,
	235	},
	236	};
	237
	238	static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
	239	{
	240	int i, err;
	241
	242	for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
ca8dc34e MJ	243	/* USB X-Fi S51 doesn't have a CMSS LED */
	244	if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
	245	continue;
7cdd8d73 MB	246	/* USB X-Fi S51 Pro doesn't have one either */
	247	if ((mixer->chip->usb_id == USB_ID(0x041e, 0x30df)) && i == 0)
	248	continue;
7b1eda22 DM	249	if (i > 1 && /* Live24ext has 2 LEDs only */
7b1eda22 DM	250	(mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
ca8dc34e	251	mixer->chip->usb_id == USB_ID(0x041e, 0x3042) \|\|
7cdd8d73	252	mixer->chip->usb_id == USB_ID(0x041e, 0x30df) \|\|
7b1eda22 DM	253	mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
	254	break;
	255	err = snd_ctl_add(mixer->chip->card,
	256	snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
	257	if (err < 0)
	258	return err;
	259	}
	260	mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
	261	return 0;
	262	}
	263
	264	static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
	265	struct snd_info_buffer *buffer)
	266	{
	267	static const struct sb_jack {
	268	int unitid;
	269	const char *name;
	270	} jacks_audigy2nx[] = {
	271	{4, "dig in "},
	272	{7, "line in"},
	273	{19, "spk out"},
	274	{20, "hph out"},
	275	{-1, NULL}
	276	}, jacks_live24ext[] = {
	277	{4, "line in"}, /* &1=Line, &2=Mic*/
	278	{3, "hph out"}, /* headphones */
	279	{0, "RC "}, /* last command, 6 bytes see rc_config above */
	280	{-1, NULL}
	281	};
	282	const struct sb_jack *jacks;
	283	struct usb_mixer_interface *mixer = entry->private_data;
	284	int i, err;
	285	u8 buf[3];
	286
	287	snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
	288	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
	289	jacks = jacks_audigy2nx;
	290	else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
	291	mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
	292	jacks = jacks_live24ext;
	293	else
	294	return;
	295
	296	for (i = 0; jacks[i].name; ++i) {
	297	snd_iprintf(buffer, "%s: ", jacks[i].name);
	298	err = snd_usb_ctl_msg(mixer->chip->dev,
	299	usb_rcvctrlpipe(mixer->chip->dev, 0),
	300	UAC_GET_MEM, USB_DIR_IN \| USB_TYPE_CLASS \|
	301	USB_RECIP_INTERFACE, 0,
17d900c4	302	jacks[i].unitid << 8, buf, 3);
7b1eda22 DM	303	if (err == 3 && (buf[0] == 3 \|\| buf[0] == 6))
	304	snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
	305	else
	306	snd_iprintf(buffer, "?\n");
	307	}
	308	}
	309
	310	static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
	311	struct snd_ctl_elem_value *ucontrol)
	312	{
	313	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	314
	315	ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
	316	return 0;
	317	}
	318
	319	static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
	320	struct snd_ctl_elem_value *ucontrol)
	321	{
	322	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	323	u8 old_status, new_status;
	324	int err, changed;
	325
	326	old_status = mixer->xonar_u1_status;
	327	if (ucontrol->value.integer.value[0])
	328	new_status = old_status \| 0x02;
	329	else
	330	new_status = old_status & ~0x02;
	331	changed = new_status != old_status;
	332	err = snd_usb_ctl_msg(mixer->chip->dev,
	333	usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
	334	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
17d900c4	335	50, 0, &new_status, 1);
7b1eda22 DM	336	if (err < 0)
	337	return err;
	338	mixer->xonar_u1_status = new_status;
	339	return changed;
	340	}
	341
	342	static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
	343	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	344	.name = "Digital Playback Switch",
	345	.info = snd_ctl_boolean_mono_info,
	346	.get = snd_xonar_u1_switch_get,
	347	.put = snd_xonar_u1_switch_put,
	348	};
	349
	350	static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
	351	{
	352	int err;
	353
	354	err = snd_ctl_add(mixer->chip->card,
	355	snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
	356	if (err < 0)
	357	return err;
	358	mixer->xonar_u1_status = 0x05;
	359	return 0;
	360	}
	361
54a8c500 DM	362	/* Native Instruments device quirks */
	363
	364	#define _MAKE_NI_CONTROL(bRequest,wIndex) ((bRequest) << 16 \| (wIndex))
	365
	366	static int snd_nativeinstruments_control_get(struct snd_kcontrol *kcontrol,
	367	struct snd_ctl_elem_value *ucontrol)
	368	{
	369	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	370	struct usb_device *dev = mixer->chip->dev;
	371	u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
	372	u16 wIndex = kcontrol->private_value & 0xffff;
	373	u8 tmp;
	374
	375	int ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), bRequest,
	376	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_IN,
	377	0, cpu_to_le16(wIndex),
	378	&tmp, sizeof(tmp), 1000);
	379
	380	if (ret < 0) {
	381	snd_printk(KERN_ERR
	382	"unable to issue vendor read request (ret = %d)", ret);
	383	return ret;
	384	}
	385
	386	ucontrol->value.integer.value[0] = tmp;
	387
	388	return 0;
	389	}
	390
	391	static int snd_nativeinstruments_control_put(struct snd_kcontrol *kcontrol,
	392	struct snd_ctl_elem_value *ucontrol)
	393	{
	394	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	395	struct usb_device *dev = mixer->chip->dev;
	396	u8 bRequest = (kcontrol->private_value >> 16) & 0xff;
	397	u16 wIndex = kcontrol->private_value & 0xffff;
	398	u16 wValue = ucontrol->value.integer.value[0];
	399
	400	int ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), bRequest,
	401	USB_TYPE_VENDOR \| USB_RECIP_DEVICE \| USB_DIR_OUT,
	402	cpu_to_le16(wValue), cpu_to_le16(wIndex),
	403	NULL, 0, 1000);
	404
	405	if (ret < 0) {
	406	snd_printk(KERN_ERR
	407	"unable to issue vendor write request (ret = %d)", ret);
	408	return ret;
	409	}
	410
	411	return 0;
	412	}
	413
	414	static struct snd_kcontrol_new snd_nativeinstruments_ta6_mixers[] = {
	415	{
	416	.name = "Direct Thru Channel A",
	417	.private_value = _MAKE_NI_CONTROL(0x01, 0x03),
	418	},
	419	{
	420	.name = "Direct Thru Channel B",
	421	.private_value = _MAKE_NI_CONTROL(0x01, 0x05),
	422	},
	423	{
	424	.name = "Phono Input Channel A",
	425	.private_value = _MAKE_NI_CONTROL(0x02, 0x03),
426	},
427	{
428	.name = "Phono Input Channel B",
429	.private_value = _MAKE_NI_CONTROL(0x02, 0x05),
430	},
431	};
432
433	static struct snd_kcontrol_new snd_nativeinstruments_ta10_mixers[] = {
434	{
435	.name = "Direct Thru Channel A",
436	.private_value = _MAKE_NI_CONTROL(0x01, 0x03),
437	},
438	{
439	.name = "Direct Thru Channel B",
440	.private_value = _MAKE_NI_CONTROL(0x01, 0x05),
441	},
442	{
443	.name = "Direct Thru Channel C",
444	.private_value = _MAKE_NI_CONTROL(0x01, 0x07),
445	},
446	{
447	.name = "Direct Thru Channel D",
448	.private_value = _MAKE_NI_CONTROL(0x01, 0x09),
449	},
450	{
451	.name = "Phono Input Channel A",
452	.private_value = _MAKE_NI_CONTROL(0x02, 0x03),
453	},
454	{
455	.name = "Phono Input Channel B",
456	.private_value = _MAKE_NI_CONTROL(0x02, 0x05),
457	},
458	{
459	.name = "Phono Input Channel C",
460	.private_value = _MAKE_NI_CONTROL(0x02, 0x07),
461	},
462	{
463	.name = "Phono Input Channel D",
464	.private_value = _MAKE_NI_CONTROL(0x02, 0x09),
465	},
466	};
467
468	static int snd_nativeinstruments_create_mixer(struct usb_mixer_interface *mixer,
469	const struct snd_kcontrol_new *kc,
470	unsigned int count)
471	{
472	int i, err = 0;
473	struct snd_kcontrol_new template = {
474	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
475	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
476	.get = snd_nativeinstruments_control_get,
477	.put = snd_nativeinstruments_control_put,
478	.info = snd_ctl_boolean_mono_info,
479	};
480
481	for (i = 0; i < count; i++) {
482	struct snd_kcontrol *c;
483
484	template.name = kc[i].name;
485	template.private_value = kc[i].private_value;
486
487	c = snd_ctl_new1(&template, mixer);
488	err = snd_ctl_add(mixer->chip->card, c);
489
490	if (err < 0)
491	break;
492	}
493
494	return err;
495	}
496
d5a0bf6c DM	497	/* M-Audio FastTrack Ultra quirks */
	498
	499	/* private_free callback */
	500	static void usb_mixer_elem_free(struct snd_kcontrol *kctl)
	501	{
	502	kfree(kctl->private_data);
	503	kctl->private_data = NULL;
	504	}
	505
	506	static int snd_maudio_ftu_create_ctl(struct usb_mixer_interface *mixer,
	507	int in, int out, const char *name)
	508	{
	509	struct usb_mixer_elem_info *cval;
	510	struct snd_kcontrol *kctl;
	511
	512	cval = kzalloc(sizeof(*cval), GFP_KERNEL);
	513	if (!cval)
	514	return -ENOMEM;
	515
	516	cval->id = 5;
	517	cval->mixer = mixer;
	518	cval->val_type = USB_MIXER_S16;
	519	cval->channels = 1;
	520	cval->control = out + 1;
	521	cval->cmask = 1 << in;
	522
	523	kctl = snd_ctl_new1(snd_usb_feature_unit_ctl, cval);
	524	if (!kctl) {
	525	kfree(cval);
	526	return -ENOMEM;
	527	}
	528
	529	snprintf(kctl->id.name, sizeof(kctl->id.name), name);
	530	kctl->private_free = usb_mixer_elem_free;
	531	return snd_usb_mixer_add_control(mixer, kctl);
	532	}
	533
	534	static int snd_maudio_ftu_create_mixer(struct usb_mixer_interface *mixer)
	535	{
	536	char name[64];
	537	int in, out, err;
	538
	539	for (out = 0; out < 8; out++) {
	540	for (in = 0; in < 8; in++) {
	541	snprintf(name, sizeof(name),
	542	"AIn%d - Out%d Capture Volume", in + 1, out + 1);
	543	err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
	544	if (err < 0)
	545	return err;
	546	}
	547
	548	for (in = 8; in < 16; in++) {
	549	snprintf(name, sizeof(name),
	550	"DIn%d - Out%d Playback Volume", in - 7, out + 1);
	551	err = snd_maudio_ftu_create_ctl(mixer, in, out, name);
	552	if (err < 0)
	553	return err;
	554	}
	555	}
	556
	557	return 0;
	558	}
	559
7b1eda22 DM	560	void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
	561	unsigned char samplerate_id)
	562	{
	563	struct usb_mixer_interface *mixer;
	564	struct usb_mixer_elem_info *cval;
	565	int unitid = 12; /* SamleRate ExtensionUnit ID */
	566
	567	list_for_each_entry(mixer, &chip->mixer_list, list) {
	568	cval = mixer->id_elems[unitid];
	569	if (cval) {
	570	snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
	571	cval->control << 8,
	572	samplerate_id);
	573	snd_usb_mixer_notify_id(mixer, unitid);
	574	}
	575	break;
	576	}
	577	}
	578
	579	int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
	580	{
3347b26c	581	int err = 0;
7b1eda22 DM	582	struct snd_info_entry *entry;
	583
	584	if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
	585	return err;
	586
3347b26c DM	587	switch (mixer->chip->usb_id) {
	588	case USB_ID(0x041e, 0x3020):
	589	case USB_ID(0x041e, 0x3040):
	590	case USB_ID(0x041e, 0x3042):
7cdd8d73	591	case USB_ID(0x041e, 0x30df):
3347b26c DM	592	case USB_ID(0x041e, 0x3048):
	593	err = snd_audigy2nx_controls_create(mixer);
	594	if (err < 0)
	595	break;
7b1eda22 DM	596	if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
	597	snd_info_set_text_ops(entry, mixer,
	598	snd_audigy2nx_proc_read);
3347b26c	599	break;
7b1eda22	600
d5a0bf6c DM	601	case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra */
	602	case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */
	603	err = snd_maudio_ftu_create_mixer(mixer);
	604	break;
	605
3347b26c DM	606	case USB_ID(0x0b05, 0x1739):
3347b26c DM	607	case USB_ID(0x0b05, 0x1743):
7b1eda22	608	err = snd_xonar_u1_controls_create(mixer);
3347b26c	609	break;
7b1eda22	610
3347b26c	611	case USB_ID(0x17cc, 0x1011): /* Traktor Audio 6 */
54a8c500 DM	612	err = snd_nativeinstruments_create_mixer(mixer,
	613	snd_nativeinstruments_ta6_mixers,
	614	ARRAY_SIZE(snd_nativeinstruments_ta6_mixers));
3347b26c	615	break;
54a8c500	616
3347b26c	617	case USB_ID(0x17cc, 0x1021): /* Traktor Audio 10 */
54a8c500 DM	618	err = snd_nativeinstruments_create_mixer(mixer,
	619	snd_nativeinstruments_ta10_mixers,
	620	ARRAY_SIZE(snd_nativeinstruments_ta10_mixers));
3347b26c	621	break;
54a8c500 DM	622	}
54a8c500 DM	623
3347b26c	624	return err;
7b1eda22 DM	625	}
	626
	627	void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
	628	int unitid)
	629	{
	630	if (!mixer->rc_cfg)
	631	return;
	632	/* unit ids specific to Extigy/Audigy 2 NX: */
	633	switch (unitid) {
	634	case 0: /* remote control */
	635	mixer->rc_urb->dev = mixer->chip->dev;
	636	usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
	637	break;
	638	case 4: /* digital in jack */
	639	case 7: /* line in jacks */
	640	case 19: /* speaker out jacks */
	641	case 20: /* headphones out jack */
	642	break;
	643	/* live24ext: 4 = line-in jack */
	644	case 3: /* hp-out jack (may actuate Mute) */
	645	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
	646	mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
	647	snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
	648	break;
	649	default:
	650	snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
	651	break;
	652	}
	653	}
	654