[linux-2.6-block.git] / sound / i2c / other / pt2258.c

/*
 *   ALSA Driver for the PT2258 volume controller.
 *
 *	Copyright (c) 2006  Jochen Voss <voss@seehuhn.de>
 *
 *   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 <sound/core.h>
#include <sound/control.h>
#include <sound/tlv.h>
#include <sound/i2c.h>
#include <sound/pt2258.h>
#include <linux/module.h>

MODULE_AUTHOR("Jochen Voss <voss@seehuhn.de>");
MODULE_DESCRIPTION("PT2258 volume controller (Princeton Technology Corp.)");
MODULE_LICENSE("GPL");

#define PT2258_CMD_RESET 0xc0
#define PT2258_CMD_UNMUTE 0xf8
#define PT2258_CMD_MUTE 0xf9

static const unsigned char pt2258_channel_code[12] = {
	0x80, 0x90,		/* channel 1: -10dB, -1dB */
	0x40, 0x50,		/* channel 2: -10dB, -1dB */
	0x00, 0x10,		/* channel 3: -10dB, -1dB */
	0x20, 0x30,		/* channel 4: -10dB, -1dB */
	0x60, 0x70,		/* channel 5: -10dB, -1dB */
	0xa0, 0xb0		/* channel 6: -10dB, -1dB */
};

int snd_pt2258_reset(struct snd_pt2258 *pt)
{
	unsigned char bytes[2];
	int i;

	/* reset chip */
	bytes[0] = PT2258_CMD_RESET;
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	/* mute all channels */
	pt->mute = 1;
	bytes[0] = PT2258_CMD_MUTE;
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	/* set all channels to 0dB */
	for (i = 0; i < 6; ++i)
		pt->volume[i] = 0;
	bytes[0] = 0xd0;
	bytes[1] = 0xe0;
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	return 0;

      __error:
	snd_i2c_unlock(pt->i2c_bus);
	snd_printk(KERN_ERR "PT2258 reset failed\n");
	return -EIO;
}

static int pt2258_stereo_volume_info(struct snd_kcontrol *kcontrol,
				     struct snd_ctl_elem_info *uinfo)
{
	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	uinfo->count = 2;
	uinfo->value.integer.min = 0;
	uinfo->value.integer.max = 79;
	return 0;
}

static int pt2258_stereo_volume_get(struct snd_kcontrol *kcontrol,
				    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pt2258 *pt = kcontrol->private_data;
	int base = kcontrol->private_value;

	/* chip does not support register reads */
	ucontrol->value.integer.value[0] = 79 - pt->volume[base];
	ucontrol->value.integer.value[1] = 79 - pt->volume[base + 1];
	return 0;
}

static int pt2258_stereo_volume_put(struct snd_kcontrol *kcontrol,
				    struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pt2258 *pt = kcontrol->private_data;
	int base = kcontrol->private_value;
	unsigned char bytes[2];
	int val0, val1;

	val0 = 79 - ucontrol->value.integer.value[0];
	val1 = 79 - ucontrol->value.integer.value[1];
	if (val0 < 0 || val0 > 79 || val1 < 0 || val1 > 79)
		return -EINVAL;
	if (val0 == pt->volume[base] && val1 == pt->volume[base + 1])
		return 0;

	pt->volume[base] = val0;
	bytes[0] = pt2258_channel_code[2 * base] | (val0 / 10);
	bytes[1] = pt2258_channel_code[2 * base + 1] | (val0 % 10);
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	pt->volume[base + 1] = val1;
	bytes[0] = pt2258_channel_code[2 * base + 2] | (val1 / 10);
	bytes[1] = pt2258_channel_code[2 * base + 3] | (val1 % 10);
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	return 1;

      __error:
	snd_i2c_unlock(pt->i2c_bus);
	snd_printk(KERN_ERR "PT2258 access failed\n");
	return -EIO;
}

#define pt2258_switch_info	snd_ctl_boolean_mono_info

static int pt2258_switch_get(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pt2258 *pt = kcontrol->private_data;

	ucontrol->value.integer.value[0] = !pt->mute;
	return 0;
}

static int pt2258_switch_put(struct snd_kcontrol *kcontrol,
			     struct snd_ctl_elem_value *ucontrol)
{
	struct snd_pt2258 *pt = kcontrol->private_data;
	unsigned char bytes[2];
	int val;

	val = !ucontrol->value.integer.value[0];
	if (pt->mute == val)
		return 0;

	pt->mute = val;
	bytes[0] = val ? PT2258_CMD_MUTE : PT2258_CMD_UNMUTE;
	snd_i2c_lock(pt->i2c_bus);
	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
		goto __error;
	snd_i2c_unlock(pt->i2c_bus);

	return 1;

      __error:
	snd_i2c_unlock(pt->i2c_bus);
	snd_printk(KERN_ERR "PT2258 access failed 2\n");
	return -EIO;
}

static const DECLARE_TLV_DB_SCALE(pt2258_db_scale, -7900, 100, 0);

int snd_pt2258_build_controls(struct snd_pt2258 *pt)
{
	struct snd_kcontrol_new knew;
	char *names[3] = {
		"Mic Loopback Playback Volume",
		"Line Loopback Playback Volume",
		"CD Loopback Playback Volume"
	};
	int i, err;

	for (i = 0; i < 3; ++i) {
		memset(&knew, 0, sizeof(knew));
		knew.name = names[i];
		knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
		knew.count = 1;
		knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
		    SNDRV_CTL_ELEM_ACCESS_TLV_READ;
		knew.private_value = 2 * i;
		knew.info = pt2258_stereo_volume_info;
		knew.get = pt2258_stereo_volume_get;
		knew.put = pt2258_stereo_volume_put;
		knew.tlv.p = pt2258_db_scale;

		err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
		if (err < 0)
			return err;
	}

	memset(&knew, 0, sizeof(knew));
	knew.name = "Loopback Switch";
	knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
	knew.info = pt2258_switch_info;
	knew.get = pt2258_switch_get;
	knew.put = pt2258_switch_put;
	knew.access = 0;
	err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
	if (err < 0)
		return err;

	return 0;
}

EXPORT_SYMBOL(snd_pt2258_reset);
EXPORT_SYMBOL(snd_pt2258_build_controls);
Commit	Line	Data
feaa6a74 JV	1	/*
	2	* ALSA Driver for the PT2258 volume controller.
	3	*
	4	* Copyright (c) 2006 Jochen Voss <voss@seehuhn.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21
feaa6a74 JV	22	#include <sound/core.h>
	23	#include <sound/control.h>
	24	#include <sound/tlv.h>
	25	#include <sound/i2c.h>
	26	#include <sound/pt2258.h>
da155d5b	27	#include <linux/module.h>
feaa6a74 JV	28
	29	MODULE_AUTHOR("Jochen Voss <voss@seehuhn.de>");
	30	MODULE_DESCRIPTION("PT2258 volume controller (Princeton Technology Corp.)");
	31	MODULE_LICENSE("GPL");
	32
	33	#define PT2258_CMD_RESET 0xc0
	34	#define PT2258_CMD_UNMUTE 0xf8
	35	#define PT2258_CMD_MUTE 0xf9
	36
	37	static const unsigned char pt2258_channel_code[12] = {
	38	0x80, 0x90, /* channel 1: -10dB, -1dB */
	39	0x40, 0x50, /* channel 2: -10dB, -1dB */
	40	0x00, 0x10, /* channel 3: -10dB, -1dB */
	41	0x20, 0x30, /* channel 4: -10dB, -1dB */
	42	0x60, 0x70, /* channel 5: -10dB, -1dB */
	43	0xa0, 0xb0 /* channel 6: -10dB, -1dB */
	44	};
	45
	46	int snd_pt2258_reset(struct snd_pt2258 *pt)
	47	{
	48	unsigned char bytes[2];
	49	int i;
	50
	51	/* reset chip */
	52	bytes[0] = PT2258_CMD_RESET;
	53	snd_i2c_lock(pt->i2c_bus);
	54	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
	55	goto __error;
	56	snd_i2c_unlock(pt->i2c_bus);
	57
	58	/* mute all channels */
	59	pt->mute = 1;
	60	bytes[0] = PT2258_CMD_MUTE;
	61	snd_i2c_lock(pt->i2c_bus);
	62	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
	63	goto __error;
	64	snd_i2c_unlock(pt->i2c_bus);
	65
	66	/* set all channels to 0dB */
	67	for (i = 0; i < 6; ++i)
	68	pt->volume[i] = 0;
	69	bytes[0] = 0xd0;
	70	bytes[1] = 0xe0;
	71	snd_i2c_lock(pt->i2c_bus);
	72	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
	73	goto __error;
	74	snd_i2c_unlock(pt->i2c_bus);
	75
	76	return 0;
	77
	78	__error:
	79	snd_i2c_unlock(pt->i2c_bus);
	80	snd_printk(KERN_ERR "PT2258 reset failed\n");
	81	return -EIO;
	82	}
	83
	84	static int pt2258_stereo_volume_info(struct snd_kcontrol *kcontrol,
	85	struct snd_ctl_elem_info *uinfo)
	86	{
	87	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
	88	uinfo->count = 2;
	89	uinfo->value.integer.min = 0;
	90	uinfo->value.integer.max = 79;
	91	return 0;
92	}
93
94	static int pt2258_stereo_volume_get(struct snd_kcontrol *kcontrol,
95	struct snd_ctl_elem_value *ucontrol)
96	{
97	struct snd_pt2258 *pt = kcontrol->private_data;
98	int base = kcontrol->private_value;
99
100	/* chip does not support register reads */
101	ucontrol->value.integer.value[0] = 79 - pt->volume[base];
102	ucontrol->value.integer.value[1] = 79 - pt->volume[base + 1];
103	return 0;
104	}
105
106	static int pt2258_stereo_volume_put(struct snd_kcontrol *kcontrol,
107	struct snd_ctl_elem_value *ucontrol)
108	{
109	struct snd_pt2258 *pt = kcontrol->private_data;
110	int base = kcontrol->private_value;
111	unsigned char bytes[2];
112	int val0, val1;
113
114	val0 = 79 - ucontrol->value.integer.value[0];
115	val1 = 79 - ucontrol->value.integer.value[1];
3b892467 TI	116	if (val0 < 0 \|\| val0 > 79 \|\| val1 < 0 \|\| val1 > 79)
3b892467 TI	117	return -EINVAL;
feaa6a74 JV	118	if (val0 == pt->volume[base] && val1 == pt->volume[base + 1])
	119	return 0;
	120
	121	pt->volume[base] = val0;
	122	bytes[0] = pt2258_channel_code[2 * base] \| (val0 / 10);
	123	bytes[1] = pt2258_channel_code[2 * base + 1] \| (val0 % 10);
	124	snd_i2c_lock(pt->i2c_bus);
	125	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
	126	goto __error;
	127	snd_i2c_unlock(pt->i2c_bus);
	128
	129	pt->volume[base + 1] = val1;
	130	bytes[0] = pt2258_channel_code[2 * base + 2] \| (val1 / 10);
	131	bytes[1] = pt2258_channel_code[2 * base + 3] \| (val1 % 10);
	132	snd_i2c_lock(pt->i2c_bus);
	133	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
	134	goto __error;
	135	snd_i2c_unlock(pt->i2c_bus);
	136
	137	return 1;
	138
	139	__error:
	140	snd_i2c_unlock(pt->i2c_bus);
	141	snd_printk(KERN_ERR "PT2258 access failed\n");
	142	return -EIO;
	143	}
	144
a5ce8890	145	#define pt2258_switch_info snd_ctl_boolean_mono_info
feaa6a74 JV	146
	147	static int pt2258_switch_get(struct snd_kcontrol *kcontrol,
	148	struct snd_ctl_elem_value *ucontrol)
	149	{
	150	struct snd_pt2258 *pt = kcontrol->private_data;
	151
	152	ucontrol->value.integer.value[0] = !pt->mute;
	153	return 0;
	154	}
	155
	156	static int pt2258_switch_put(struct snd_kcontrol *kcontrol,
	157	struct snd_ctl_elem_value *ucontrol)
	158	{
	159	struct snd_pt2258 *pt = kcontrol->private_data;
	160	unsigned char bytes[2];
	161	int val;
	162
	163	val = !ucontrol->value.integer.value[0];
	164	if (pt->mute == val)
	165	return 0;
	166
	167	pt->mute = val;
	168	bytes[0] = val ? PT2258_CMD_MUTE : PT2258_CMD_UNMUTE;
	169	snd_i2c_lock(pt->i2c_bus);
	170	if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
	171	goto __error;
	172	snd_i2c_unlock(pt->i2c_bus);
	173
	174	return 1;
	175
	176	__error:
	177	snd_i2c_unlock(pt->i2c_bus);
	178	snd_printk(KERN_ERR "PT2258 access failed 2\n");
	179	return -EIO;
	180	}
	181
0cb29ea0	182	static const DECLARE_TLV_DB_SCALE(pt2258_db_scale, -7900, 100, 0);
feaa6a74 JV	183
	184	int snd_pt2258_build_controls(struct snd_pt2258 *pt)
	185	{
	186	struct snd_kcontrol_new knew;
	187	char *names[3] = {
	188	"Mic Loopback Playback Volume",
	189	"Line Loopback Playback Volume",
	190	"CD Loopback Playback Volume"
	191	};
	192	int i, err;
	193
	194	for (i = 0; i < 3; ++i) {
	195	memset(&knew, 0, sizeof(knew));
	196	knew.name = names[i];
	197	knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
	198	knew.count = 1;
	199	knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE \|
	200	SNDRV_CTL_ELEM_ACCESS_TLV_READ;
	201	knew.private_value = 2 * i;
	202	knew.info = pt2258_stereo_volume_info;
	203	knew.get = pt2258_stereo_volume_get;
	204	knew.put = pt2258_stereo_volume_put;
	205	knew.tlv.p = pt2258_db_scale;
	206
	207	err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
	208	if (err < 0)
	209	return err;
	210	}
	211
	212	memset(&knew, 0, sizeof(knew));
	213	knew.name = "Loopback Switch";
	214	knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
	215	knew.info = pt2258_switch_info;
	216	knew.get = pt2258_switch_get;
	217	knew.put = pt2258_switch_put;
	218	knew.access = 0;
	219	err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
	220	if (err < 0)
	221	return err;
	222
	223	return 0;
	224	}
	225
	226	EXPORT_SYMBOL(snd_pt2258_reset);
	227	EXPORT_SYMBOL(snd_pt2258_build_controls);