[net-next-2.6.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"

/*
 * 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, 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, 100);
	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, 100);
	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;
		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, 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, 100);
		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, 100);
	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;
}

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;
	struct snd_info_entry *entry;

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

	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) ||
	    mixer->chip->usb_id == USB_ID(0x041e, 0x3040) ||
	    mixer->chip->usb_id == USB_ID(0x041e, 0x3042) ||
	    mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
		if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
			return err;
		if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
			snd_info_set_text_ops(entry, mixer,
					      snd_audigy2nx_proc_read);
	}

	if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) ||
	    mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
		err = snd_xonar_u1_controls_create(mixer);
		if (err < 0)
			return err;
	}

	return 0;
}

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
	43	/*
	44	* Sound Blaster remote control configuration
	45	*
	46	* format of remote control data:
	47	* Extigy: xx 00
	48	* Audigy 2 NX: 06 80 xx 00 00 00
	49	* Live! 24-bit: 06 80 xx yy 22 83
	50	*/
	51	static const struct rc_config {
	52	u32 usb_id;
	53	u8 offset;
	54	u8 length;
	55	u8 packet_length;
	56	u8 min_packet_length; /* minimum accepted length of the URB result */
	57	u8 mute_mixer_id;
	58	u32 mute_code;
	59	} rc_configs[] = {
	60	{ USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */
	61	{ USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */
	62	{ USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */
ca8dc34e	63	{ USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi S51 */
7b1eda22 DM	64	{ USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */
	65	};
	66
	67	static void snd_usb_soundblaster_remote_complete(struct urb *urb)
	68	{
	69	struct usb_mixer_interface *mixer = urb->context;
	70	const struct rc_config *rc = mixer->rc_cfg;
	71	u32 code;
	72
	73	if (urb->status < 0 \|\| urb->actual_length < rc->min_packet_length)
	74	return;
	75
	76	code = mixer->rc_buffer[rc->offset];
	77	if (rc->length == 2)
	78	code \|= mixer->rc_buffer[rc->offset + 1] << 8;
	79
	80	/* the Mute button actually changes the mixer control */
	81	if (code == rc->mute_code)
	82	snd_usb_mixer_notify_id(mixer, rc->mute_mixer_id);
	83	mixer->rc_code = code;
	84	wmb();
	85	wake_up(&mixer->rc_waitq);
	86	}
	87
	88	static long snd_usb_sbrc_hwdep_read(struct snd_hwdep hw, char __user buf,
	89	long count, loff_t *offset)
	90	{
	91	struct usb_mixer_interface *mixer = hw->private_data;
	92	int err;
	93	u32 rc_code;
	94
	95	if (count != 1 && count != 4)
	96	return -EINVAL;
	97	err = wait_event_interruptible(mixer->rc_waitq,
	98	(rc_code = xchg(&mixer->rc_code, 0)) != 0);
	99	if (err == 0) {
	100	if (count == 1)
	101	err = put_user(rc_code, buf);
	102	else
	103	err = put_user(rc_code, (u32 __user *)buf);
	104	}
	105	return err < 0 ? err : count;
	106	}
	107
	108	static unsigned int snd_usb_sbrc_hwdep_poll(struct snd_hwdep hw, struct file file,
	109	poll_table *wait)
	110	{
	111	struct usb_mixer_interface *mixer = hw->private_data;
	112
	113	poll_wait(file, &mixer->rc_waitq, wait);
	114	return mixer->rc_code ? POLLIN \| POLLRDNORM : 0;
	115	}
	116
	117	static int snd_usb_soundblaster_remote_init(struct usb_mixer_interface *mixer)
	118	{
	119	struct snd_hwdep *hwdep;
	120	int err, len, i;
	121
	122	for (i = 0; i < ARRAY_SIZE(rc_configs); ++i)
	123	if (rc_configs[i].usb_id == mixer->chip->usb_id)
	124	break;
	125	if (i >= ARRAY_SIZE(rc_configs))
	126	return 0;
	127	mixer->rc_cfg = &rc_configs[i];
128
129	len = mixer->rc_cfg->packet_length;
130
131	init_waitqueue_head(&mixer->rc_waitq);
132	err = snd_hwdep_new(mixer->chip->card, "SB remote control", 0, &hwdep);
133	if (err < 0)
134	return err;
135	snprintf(hwdep->name, sizeof(hwdep->name),
136	"%s remote control", mixer->chip->card->shortname);
137	hwdep->iface = SNDRV_HWDEP_IFACE_SB_RC;
138	hwdep->private_data = mixer;
139	hwdep->ops.read = snd_usb_sbrc_hwdep_read;
140	hwdep->ops.poll = snd_usb_sbrc_hwdep_poll;
141	hwdep->exclusive = 1;
142
143	mixer->rc_urb = usb_alloc_urb(0, GFP_KERNEL);
144	if (!mixer->rc_urb)
145	return -ENOMEM;
146	mixer->rc_setup_packet = kmalloc(sizeof(*mixer->rc_setup_packet), GFP_KERNEL);
147	if (!mixer->rc_setup_packet) {
148	usb_free_urb(mixer->rc_urb);
149	mixer->rc_urb = NULL;
150	return -ENOMEM;
151	}
152	mixer->rc_setup_packet->bRequestType =
153	USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_INTERFACE;
154	mixer->rc_setup_packet->bRequest = UAC_GET_MEM;
155	mixer->rc_setup_packet->wValue = cpu_to_le16(0);
156	mixer->rc_setup_packet->wIndex = cpu_to_le16(0);
157	mixer->rc_setup_packet->wLength = cpu_to_le16(len);
158	usb_fill_control_urb(mixer->rc_urb, mixer->chip->dev,
159	usb_rcvctrlpipe(mixer->chip->dev, 0),
160	(u8*)mixer->rc_setup_packet, mixer->rc_buffer, len,
161	snd_usb_soundblaster_remote_complete, mixer);
162	return 0;
163	}
164
165	#define snd_audigy2nx_led_info snd_ctl_boolean_mono_info
166
167	static int snd_audigy2nx_led_get(struct snd_kcontrol kcontrol, struct snd_ctl_elem_value ucontrol)
168	{
169	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
170	int index = kcontrol->private_value;
171
172	ucontrol->value.integer.value[0] = mixer->audigy2nx_leds[index];
173	return 0;
174	}
175
176	static int snd_audigy2nx_led_put(struct snd_kcontrol kcontrol, struct snd_ctl_elem_value ucontrol)
177	{
178	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
179	int index = kcontrol->private_value;
180	int value = ucontrol->value.integer.value[0];
181	int err, changed;
182
183	if (value > 1)
184	return -EINVAL;
185	changed = value != mixer->audigy2nx_leds[index];
ca8dc34e MJ	186	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3042))
	187	err = snd_usb_ctl_msg(mixer->chip->dev,
	188	usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
	189	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
	190	!value, 0, NULL, 0, 100);
	191	else
	192	err = snd_usb_ctl_msg(mixer->chip->dev,
7b1eda22 DM	193	usb_sndctrlpipe(mixer->chip->dev, 0), 0x24,
	194	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
	195	value, index + 2, NULL, 0, 100);
	196	if (err < 0)
	197	return err;
	198	mixer->audigy2nx_leds[index] = value;
	199	return changed;
	200	}
	201
	202	static struct snd_kcontrol_new snd_audigy2nx_controls[] = {
	203	{
	204	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	205	.name = "CMSS LED Switch",
	206	.info = snd_audigy2nx_led_info,
	207	.get = snd_audigy2nx_led_get,
	208	.put = snd_audigy2nx_led_put,
	209	.private_value = 0,
	210	},
	211	{
	212	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	213	.name = "Power LED Switch",
	214	.info = snd_audigy2nx_led_info,
	215	.get = snd_audigy2nx_led_get,
	216	.put = snd_audigy2nx_led_put,
	217	.private_value = 1,
	218	},
	219	{
	220	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	221	.name = "Dolby Digital LED Switch",
	222	.info = snd_audigy2nx_led_info,
	223	.get = snd_audigy2nx_led_get,
	224	.put = snd_audigy2nx_led_put,
	225	.private_value = 2,
	226	},
	227	};
	228
	229	static int snd_audigy2nx_controls_create(struct usb_mixer_interface *mixer)
	230	{
	231	int i, err;
	232
	233	for (i = 0; i < ARRAY_SIZE(snd_audigy2nx_controls); ++i) {
ca8dc34e MJ	234	/* USB X-Fi S51 doesn't have a CMSS LED */
	235	if ((mixer->chip->usb_id == USB_ID(0x041e, 0x3042)) && i == 0)
	236	continue;
7b1eda22 DM	237	if (i > 1 && /* Live24ext has 2 LEDs only */
7b1eda22 DM	238	(mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
ca8dc34e	239	mixer->chip->usb_id == USB_ID(0x041e, 0x3042) \|\|
7b1eda22 DM	240	mixer->chip->usb_id == USB_ID(0x041e, 0x3048)))
	241	break;
	242	err = snd_ctl_add(mixer->chip->card,
	243	snd_ctl_new1(&snd_audigy2nx_controls[i], mixer));
	244	if (err < 0)
	245	return err;
	246	}
	247	mixer->audigy2nx_leds[1] = 1; /* Power LED is on by default */
	248	return 0;
	249	}
	250
	251	static void snd_audigy2nx_proc_read(struct snd_info_entry *entry,
	252	struct snd_info_buffer *buffer)
	253	{
	254	static const struct sb_jack {
	255	int unitid;
	256	const char *name;
	257	} jacks_audigy2nx[] = {
	258	{4, "dig in "},
	259	{7, "line in"},
	260	{19, "spk out"},
	261	{20, "hph out"},
	262	{-1, NULL}
	263	}, jacks_live24ext[] = {
	264	{4, "line in"}, /* &1=Line, &2=Mic*/
	265	{3, "hph out"}, /* headphones */
	266	{0, "RC "}, /* last command, 6 bytes see rc_config above */
	267	{-1, NULL}
	268	};
	269	const struct sb_jack *jacks;
	270	struct usb_mixer_interface *mixer = entry->private_data;
	271	int i, err;
	272	u8 buf[3];
	273
	274	snd_iprintf(buffer, "%s jacks\n\n", mixer->chip->card->shortname);
	275	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020))
	276	jacks = jacks_audigy2nx;
	277	else if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
	278	mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
	279	jacks = jacks_live24ext;
	280	else
	281	return;
	282
	283	for (i = 0; jacks[i].name; ++i) {
	284	snd_iprintf(buffer, "%s: ", jacks[i].name);
	285	err = snd_usb_ctl_msg(mixer->chip->dev,
	286	usb_rcvctrlpipe(mixer->chip->dev, 0),
	287	UAC_GET_MEM, USB_DIR_IN \| USB_TYPE_CLASS \|
	288	USB_RECIP_INTERFACE, 0,
	289	jacks[i].unitid << 8, buf, 3, 100);
	290	if (err == 3 && (buf[0] == 3 \|\| buf[0] == 6))
	291	snd_iprintf(buffer, "%02x %02x\n", buf[1], buf[2]);
	292	else
	293	snd_iprintf(buffer, "?\n");
	294	}
	295	}
	296
	297	static int snd_xonar_u1_switch_get(struct snd_kcontrol *kcontrol,
	298	struct snd_ctl_elem_value *ucontrol)
	299	{
	300	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
	301
	302	ucontrol->value.integer.value[0] = !!(mixer->xonar_u1_status & 0x02);
	303	return 0;
304	}
305
306	static int snd_xonar_u1_switch_put(struct snd_kcontrol *kcontrol,
307	struct snd_ctl_elem_value *ucontrol)
308	{
309	struct usb_mixer_interface *mixer = snd_kcontrol_chip(kcontrol);
310	u8 old_status, new_status;
311	int err, changed;
312
313	old_status = mixer->xonar_u1_status;
314	if (ucontrol->value.integer.value[0])
315	new_status = old_status \| 0x02;
316	else
317	new_status = old_status & ~0x02;
318	changed = new_status != old_status;
319	err = snd_usb_ctl_msg(mixer->chip->dev,
320	usb_sndctrlpipe(mixer->chip->dev, 0), 0x08,
321	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_OTHER,
322	50, 0, &new_status, 1, 100);
323	if (err < 0)
324	return err;
325	mixer->xonar_u1_status = new_status;
326	return changed;
327	}
328
329	static struct snd_kcontrol_new snd_xonar_u1_output_switch = {
330	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
331	.name = "Digital Playback Switch",
332	.info = snd_ctl_boolean_mono_info,
333	.get = snd_xonar_u1_switch_get,
334	.put = snd_xonar_u1_switch_put,
335	};
336
337	static int snd_xonar_u1_controls_create(struct usb_mixer_interface *mixer)
338	{
339	int err;
340
341	err = snd_ctl_add(mixer->chip->card,
342	snd_ctl_new1(&snd_xonar_u1_output_switch, mixer));
343	if (err < 0)
344	return err;
345	mixer->xonar_u1_status = 0x05;
346	return 0;
347	}
348
349	void snd_emuusb_set_samplerate(struct snd_usb_audio *chip,
350	unsigned char samplerate_id)
351	{
352	struct usb_mixer_interface *mixer;
353	struct usb_mixer_elem_info *cval;
354	int unitid = 12; /* SamleRate ExtensionUnit ID */
355
356	list_for_each_entry(mixer, &chip->mixer_list, list) {
357	cval = mixer->id_elems[unitid];
358	if (cval) {
359	snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR,
360	cval->control << 8,
361	samplerate_id);
362	snd_usb_mixer_notify_id(mixer, unitid);
363	}
364	break;
365	}
366	}
367
368	int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
369	{
370	int err;
371	struct snd_info_entry *entry;
372
373	if ((err = snd_usb_soundblaster_remote_init(mixer)) < 0)
374	return err;
375
376	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3020) \|\|
377	mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
ca8dc34e	378	mixer->chip->usb_id == USB_ID(0x041e, 0x3042) \|\|
7b1eda22 DM	379	mixer->chip->usb_id == USB_ID(0x041e, 0x3048)) {
	380	if ((err = snd_audigy2nx_controls_create(mixer)) < 0)
	381	return err;
	382	if (!snd_card_proc_new(mixer->chip->card, "audigy2nx", &entry))
	383	snd_info_set_text_ops(entry, mixer,
	384	snd_audigy2nx_proc_read);
	385	}
	386
	387	if (mixer->chip->usb_id == USB_ID(0x0b05, 0x1739) \|\|
	388	mixer->chip->usb_id == USB_ID(0x0b05, 0x1743)) {
	389	err = snd_xonar_u1_controls_create(mixer);
	390	if (err < 0)
	391	return err;
	392	}
	393
	394	return 0;
	395	}
	396
	397	void snd_usb_mixer_rc_memory_change(struct usb_mixer_interface *mixer,
	398	int unitid)
	399	{
	400	if (!mixer->rc_cfg)
	401	return;
	402	/* unit ids specific to Extigy/Audigy 2 NX: */
	403	switch (unitid) {
	404	case 0: /* remote control */
	405	mixer->rc_urb->dev = mixer->chip->dev;
	406	usb_submit_urb(mixer->rc_urb, GFP_ATOMIC);
	407	break;
	408	case 4: /* digital in jack */
	409	case 7: /* line in jacks */
	410	case 19: /* speaker out jacks */
	411	case 20: /* headphones out jack */
	412	break;
	413	/* live24ext: 4 = line-in jack */
	414	case 3: /* hp-out jack (may actuate Mute) */
	415	if (mixer->chip->usb_id == USB_ID(0x041e, 0x3040) \|\|
	416	mixer->chip->usb_id == USB_ID(0x041e, 0x3048))
	417	snd_usb_mixer_notify_id(mixer, mixer->rc_cfg->mute_mixer_id);
	418	break;
	419	default:
	420	snd_printd(KERN_DEBUG "memory change in unknown unit %d\n", unitid);
	421	break;
	422	}
	423	}
	424