[net-next-2.6.git] / sound / soc / pxa / tosa.c

/*
 * tosa.c  --  SoC audio for Tosa
 *
 * Copyright 2005 Wolfson Microelectronics PLC.
 * Copyright 2005 Openedhand Ltd.
 *
 * Authors: Liam Girdwood <liam.girdwood@wolfsonmicro.com>
 *          Richard Purdie <richard@openedhand.com>
 *
 *  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.
 *
 * GPIO's
 *  1 - Jack Insertion
 *  5 - Hookswitch (headset answer/hang up switch)
 *
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/device.h>
#include <linux/gpio.h>

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>

#include <asm/mach-types.h>
#include <mach/tosa.h>
#include <mach/pxa-regs.h>
#include <mach/hardware.h>
#include <mach/audio.h>

#include "../codecs/wm9712.h"
#include "pxa2xx-pcm.h"
#include "pxa2xx-ac97.h"

static struct snd_soc_machine tosa;

#define TOSA_HP        0
#define TOSA_MIC_INT   1
#define TOSA_HEADSET   2
#define TOSA_HP_OFF    3
#define TOSA_SPK_ON    0
#define TOSA_SPK_OFF   1

static int tosa_jack_func;
static int tosa_spk_func;

static void tosa_ext_control(struct snd_soc_codec *codec)
{
	/* set up jack connection */
	switch (tosa_jack_func) {
	case TOSA_HP:
		snd_soc_dapm_disable_pin(codec, "Mic (Internal)");
		snd_soc_dapm_enable_pin(codec, "Headphone Jack");
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		break;
	case TOSA_MIC_INT:
		snd_soc_dapm_enable_pin(codec, "Mic (Internal)");
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		break;
	case TOSA_HEADSET:
		snd_soc_dapm_disable_pin(codec, "Mic (Internal)");
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_enable_pin(codec, "Headset Jack");
		break;
	}

	if (tosa_spk_func == TOSA_SPK_ON)
		snd_soc_dapm_enable_pin(codec, "Speaker");
	else
		snd_soc_dapm_disable_pin(codec, "Speaker");

	snd_soc_dapm_sync(codec);
}

static int tosa_startup(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_codec *codec = rtd->socdev->codec;

	/* check the jack status at stream startup */
	tosa_ext_control(codec);
	return 0;
}

static struct snd_soc_ops tosa_ops = {
	.startup = tosa_startup,
};

static int tosa_get_jack(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = tosa_jack_func;
	return 0;
}

static int tosa_set_jack(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);

	if (tosa_jack_func == ucontrol->value.integer.value[0])
		return 0;

	tosa_jack_func = ucontrol->value.integer.value[0];
	tosa_ext_control(codec);
	return 1;
}

static int tosa_get_spk(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = tosa_spk_func;
	return 0;
}

static int tosa_set_spk(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);

	if (tosa_spk_func == ucontrol->value.integer.value[0])
		return 0;

	tosa_spk_func = ucontrol->value.integer.value[0];
	tosa_ext_control(codec);
	return 1;
}

/* tosa dapm event handlers */
static int tosa_hp_event(struct snd_soc_dapm_widget *w,
	struct snd_kcontrol *k, int event)
{
	gpio_set_value(TOSA_GPIO_L_MUTE, SND_SOC_DAPM_EVENT_ON(event) ? 1 :0);
	return 0;
}

/* tosa machine dapm widgets */
static const struct snd_soc_dapm_widget tosa_dapm_widgets[] = {
SND_SOC_DAPM_HP("Headphone Jack", tosa_hp_event),
SND_SOC_DAPM_HP("Headset Jack", NULL),
SND_SOC_DAPM_MIC("Mic (Internal)", NULL),
SND_SOC_DAPM_SPK("Speaker", NULL),
};

/* tosa audio map */
static const struct snd_soc_dapm_route audio_map[] = {

	/* headphone connected to HPOUTL, HPOUTR */
	{"Headphone Jack", NULL, "HPOUTL"},
	{"Headphone Jack", NULL, "HPOUTR"},

	/* ext speaker connected to LOUT2, ROUT2 */
	{"Speaker", NULL, "LOUT2"},
	{"Speaker", NULL, "ROUT2"},

	/* internal mic is connected to mic1, mic2 differential - with bias */
	{"MIC1", NULL, "Mic Bias"},
	{"MIC2", NULL, "Mic Bias"},
	{"Mic Bias", NULL, "Mic (Internal)"},

	/* headset is connected to HPOUTR, and LINEINR with bias */
	{"Headset Jack", NULL, "HPOUTR"},
	{"LINEINR", NULL, "Mic Bias"},
	{"Mic Bias", NULL, "Headset Jack"},
};

static const char *jack_function[] = {"Headphone", "Mic", "Line", "Headset",
	"Off"};
static const char *spk_function[] = {"On", "Off"};
static const struct soc_enum tosa_enum[] = {
	SOC_ENUM_SINGLE_EXT(5, jack_function),
	SOC_ENUM_SINGLE_EXT(2, spk_function),
};

static const struct snd_kcontrol_new tosa_controls[] = {
	SOC_ENUM_EXT("Jack Function", tosa_enum[0], tosa_get_jack,
		tosa_set_jack),
	SOC_ENUM_EXT("Speaker Function", tosa_enum[1], tosa_get_spk,
		tosa_set_spk),
};

static int tosa_ac97_init(struct snd_soc_codec *codec)
{
	int i, err;

	snd_soc_dapm_disable_pin(codec, "OUT3");
	snd_soc_dapm_disable_pin(codec, "MONOOUT");

	/* add tosa specific controls */
	for (i = 0; i < ARRAY_SIZE(tosa_controls); i++) {
		err = snd_ctl_add(codec->card,
				snd_soc_cnew(&tosa_controls[i],codec, NULL));
		if (err < 0)
			return err;
	}

	/* add tosa specific widgets */
	snd_soc_dapm_new_controls(codec, tosa_dapm_widgets,
				  ARRAY_SIZE(tosa_dapm_widgets));

	/* set up tosa specific audio path audio_map */
	snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));

	snd_soc_dapm_sync(codec);
	return 0;
}

static struct snd_soc_dai_link tosa_dai[] = {
{
	.name = "AC97",
	.stream_name = "AC97 HiFi",
	.cpu_dai = &pxa_ac97_dai[PXA2XX_DAI_AC97_HIFI],
	.codec_dai = &wm9712_dai[WM9712_DAI_AC97_HIFI],
	.init = tosa_ac97_init,
	.ops = &tosa_ops,
},
{
	.name = "AC97 Aux",
	.stream_name = "AC97 Aux",
	.cpu_dai = &pxa_ac97_dai[PXA2XX_DAI_AC97_AUX],
	.codec_dai = &wm9712_dai[WM9712_DAI_AC97_AUX],
	.ops = &tosa_ops,
},
};

static struct snd_soc_machine tosa = {
	.name = "Tosa",
	.dai_link = tosa_dai,
	.num_links = ARRAY_SIZE(tosa_dai),
};

static struct snd_soc_device tosa_snd_devdata = {
	.machine = &tosa,
	.platform = &pxa2xx_soc_platform,
	.codec_dev = &soc_codec_dev_wm9712,
};

static struct platform_device *tosa_snd_device;

static int __init tosa_init(void)
{
	int ret;

	if (!machine_is_tosa())
		return -ENODEV;

	ret = gpio_request(TOSA_GPIO_L_MUTE, "Headphone Jack");
	if (ret)
		return ret;
	gpio_direction_output(TOSA_GPIO_L_MUTE, 0);

	tosa_snd_device = platform_device_alloc("soc-audio", -1);
	if (!tosa_snd_device) {
		ret = -ENOMEM;
		goto err_alloc;
	}

	platform_set_drvdata(tosa_snd_device, &tosa_snd_devdata);
	tosa_snd_devdata.dev = &tosa_snd_device->dev;
	ret = platform_device_add(tosa_snd_device);

	if (!ret)
		return 0;

	platform_device_put(tosa_snd_device);

err_alloc:
	gpio_free(TOSA_GPIO_L_MUTE);

	return ret;
}

static void __exit tosa_exit(void)
{
	platform_device_unregister(tosa_snd_device);
	gpio_free(TOSA_GPIO_L_MUTE);
}

module_init(tosa_init);
module_exit(tosa_exit);

/* Module information */
MODULE_AUTHOR("Richard Purdie");
MODULE_DESCRIPTION("ALSA SoC Tosa");
MODULE_LICENSE("GPL");
Commit	Line	Data
1b49cb98 LG	1	/*
	2	* tosa.c -- SoC audio for Tosa
	3	*
	4	* Copyright 2005 Wolfson Microelectronics PLC.
	5	* Copyright 2005 Openedhand Ltd.
	6	*
	7	* Authors: Liam Girdwood <liam.girdwood@wolfsonmicro.com>
	8	* Richard Purdie <richard@openedhand.com>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the
	12	* Free Software Foundation; either version 2 of the License, or (at your
	13	* option) any later version.
	14	*
1b49cb98 LG	15	* GPIO's
	16	* 1 - Jack Insertion
	17	* 5 - Hookswitch (headset answer/hang up switch)
	18	*
	19	*/
	20
	21	#include <linux/module.h>
	22	#include <linux/moduleparam.h>
	23	#include <linux/device.h>
4440cbd6	24	#include <linux/gpio.h>
1b49cb98	25
1b49cb98 LG	26	#include <sound/core.h>
	27	#include <sound/pcm.h>
	28	#include <sound/soc.h>
	29	#include <sound/soc-dapm.h>
	30
	31	#include <asm/mach-types.h>
a09e64fb RK	32	#include <mach/tosa.h>
	33	#include <mach/pxa-regs.h>
	34	#include <mach/hardware.h>
	35	#include <mach/audio.h>
1b49cb98 LG	36
	37	#include "../codecs/wm9712.h"
	38	#include "pxa2xx-pcm.h"
cb4c048b	39	#include "pxa2xx-ac97.h"
1b49cb98 LG	40
	41	static struct snd_soc_machine tosa;
	42
	43	#define TOSA_HP 0
	44	#define TOSA_MIC_INT 1
	45	#define TOSA_HEADSET 2
	46	#define TOSA_HP_OFF 3
	47	#define TOSA_SPK_ON 0
	48	#define TOSA_SPK_OFF 1
	49
	50	static int tosa_jack_func;
	51	static int tosa_spk_func;
	52
	53	static void tosa_ext_control(struct snd_soc_codec *codec)
	54	{
1b49cb98 LG	55	/* set up jack connection */
	56	switch (tosa_jack_func) {
	57	case TOSA_HP:
a5302181 LG	58	snd_soc_dapm_disable_pin(codec, "Mic (Internal)");
	59	snd_soc_dapm_enable_pin(codec, "Headphone Jack");
	60	snd_soc_dapm_disable_pin(codec, "Headset Jack");
1b49cb98 LG	61	break;
1b49cb98 LG	62	case TOSA_MIC_INT:
a5302181 LG	63	snd_soc_dapm_enable_pin(codec, "Mic (Internal)");
	64	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	65	snd_soc_dapm_disable_pin(codec, "Headset Jack");
1b49cb98 LG	66	break;
1b49cb98 LG	67	case TOSA_HEADSET:
a5302181 LG	68	snd_soc_dapm_disable_pin(codec, "Mic (Internal)");
	69	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	70	snd_soc_dapm_enable_pin(codec, "Headset Jack");
1b49cb98 LG	71	break;
	72	}
	73
	74	if (tosa_spk_func == TOSA_SPK_ON)
a5302181 LG	75	snd_soc_dapm_enable_pin(codec, "Speaker");
	76	else
	77	snd_soc_dapm_disable_pin(codec, "Speaker");
1b49cb98	78
a5302181	79	snd_soc_dapm_sync(codec);
1b49cb98 LG	80	}
	81
	82	static int tosa_startup(struct snd_pcm_substream *substream)
	83	{
	84	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	85	struct snd_soc_codec *codec = rtd->socdev->codec;
	86
	87	/* check the jack status at stream startup */
	88	tosa_ext_control(codec);
	89	return 0;
	90	}
	91
	92	static struct snd_soc_ops tosa_ops = {
	93	.startup = tosa_startup,
	94	};
	95
	96	static int tosa_get_jack(struct snd_kcontrol *kcontrol,
	97	struct snd_ctl_elem_value *ucontrol)
	98	{
	99	ucontrol->value.integer.value[0] = tosa_jack_func;
	100	return 0;
	101	}
	102
	103	static int tosa_set_jack(struct snd_kcontrol *kcontrol,
	104	struct snd_ctl_elem_value *ucontrol)
	105	{
	106	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
	107
	108	if (tosa_jack_func == ucontrol->value.integer.value[0])
	109	return 0;
	110
	111	tosa_jack_func = ucontrol->value.integer.value[0];
	112	tosa_ext_control(codec);
	113	return 1;
	114	}
	115
	116	static int tosa_get_spk(struct snd_kcontrol *kcontrol,
	117	struct snd_ctl_elem_value *ucontrol)
	118	{
	119	ucontrol->value.integer.value[0] = tosa_spk_func;
	120	return 0;
	121	}
	122
	123	static int tosa_set_spk(struct snd_kcontrol *kcontrol,
	124	struct snd_ctl_elem_value *ucontrol)
	125	{
	126	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
	127
	128	if (tosa_spk_func == ucontrol->value.integer.value[0])
	129	return 0;
	130
	131	tosa_spk_func = ucontrol->value.integer.value[0];
	132	tosa_ext_control(codec);
	133	return 1;
	134	}
	135
	136	/* tosa dapm event handlers */
338c7ed0 JN	137	static int tosa_hp_event(struct snd_soc_dapm_widget *w,
338c7ed0 JN	138	struct snd_kcontrol *k, int event)
1b49cb98	139	{
4440cbd6	140	gpio_set_value(TOSA_GPIO_L_MUTE, SND_SOC_DAPM_EVENT_ON(event) ? 1 :0);
1b49cb98 LG	141	return 0;
	142	}
	143
	144	/* tosa machine dapm widgets */
	145	static const struct snd_soc_dapm_widget tosa_dapm_widgets[] = {
	146	SND_SOC_DAPM_HP("Headphone Jack", tosa_hp_event),
	147	SND_SOC_DAPM_HP("Headset Jack", NULL),
	148	SND_SOC_DAPM_MIC("Mic (Internal)", NULL),
	149	SND_SOC_DAPM_SPK("Speaker", NULL),
	150	};
	151
	152	/* tosa audio map */
76d39d0a	153	static const struct snd_soc_dapm_route audio_map[] = {
1b49cb98 LG	154
	155	/* headphone connected to HPOUTL, HPOUTR */
	156	{"Headphone Jack", NULL, "HPOUTL"},
	157	{"Headphone Jack", NULL, "HPOUTR"},
	158
	159	/* ext speaker connected to LOUT2, ROUT2 */
	160	{"Speaker", NULL, "LOUT2"},
	161	{"Speaker", NULL, "ROUT2"},
	162
	163	/* internal mic is connected to mic1, mic2 differential - with bias */
	164	{"MIC1", NULL, "Mic Bias"},
	165	{"MIC2", NULL, "Mic Bias"},
	166	{"Mic Bias", NULL, "Mic (Internal)"},
	167
	168	/* headset is connected to HPOUTR, and LINEINR with bias */
	169	{"Headset Jack", NULL, "HPOUTR"},
	170	{"LINEINR", NULL, "Mic Bias"},
	171	{"Mic Bias", NULL, "Headset Jack"},
1b49cb98 LG	172	};
	173
	174	static const char *jack_function[] = {"Headphone", "Mic", "Line", "Headset",
	175	"Off"};
	176	static const char *spk_function[] = {"On", "Off"};
	177	static const struct soc_enum tosa_enum[] = {
	178	SOC_ENUM_SINGLE_EXT(5, jack_function),
	179	SOC_ENUM_SINGLE_EXT(2, spk_function),
	180	};
	181
	182	static const struct snd_kcontrol_new tosa_controls[] = {
	183	SOC_ENUM_EXT("Jack Function", tosa_enum[0], tosa_get_jack,
	184	tosa_set_jack),
	185	SOC_ENUM_EXT("Speaker Function", tosa_enum[1], tosa_get_spk,
	186	tosa_set_spk),
	187	};
	188
	189	static int tosa_ac97_init(struct snd_soc_codec *codec)
	190	{
	191	int i, err;
	192
a5302181 LG	193	snd_soc_dapm_disable_pin(codec, "OUT3");
a5302181 LG	194	snd_soc_dapm_disable_pin(codec, "MONOOUT");
1b49cb98 LG	195
	196	/* add tosa specific controls */
	197	for (i = 0; i < ARRAY_SIZE(tosa_controls); i++) {
	198	err = snd_ctl_add(codec->card,
	199	snd_soc_cnew(&tosa_controls[i],codec, NULL));
	200	if (err < 0)
	201	return err;
	202	}
	203
	204	/* add tosa specific widgets */
76d39d0a	205	snd_soc_dapm_new_controls(codec, tosa_dapm_widgets,
25191c45	206	ARRAY_SIZE(tosa_dapm_widgets));
1b49cb98 LG	207
1b49cb98 LG	208	/* set up tosa specific audio path audio_map */
25191c45	209	snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
1b49cb98	210
a5302181	211	snd_soc_dapm_sync(codec);
1b49cb98 LG	212	return 0;
	213	}
	214
	215	static struct snd_soc_dai_link tosa_dai[] = {
	216	{
	217	.name = "AC97",
	218	.stream_name = "AC97 HiFi",
	219	.cpu_dai = &pxa_ac97_dai[PXA2XX_DAI_AC97_HIFI],
	220	.codec_dai = &wm9712_dai[WM9712_DAI_AC97_HIFI],
	221	.init = tosa_ac97_init,
cb4c048b	222	.ops = &tosa_ops,
1b49cb98 LG	223	},
	224	{
	225	.name = "AC97 Aux",
	226	.stream_name = "AC97 Aux",
	227	.cpu_dai = &pxa_ac97_dai[PXA2XX_DAI_AC97_AUX],
	228	.codec_dai = &wm9712_dai[WM9712_DAI_AC97_AUX],
cb4c048b	229	.ops = &tosa_ops,
1b49cb98 LG	230	},
	231	};
	232
	233	static struct snd_soc_machine tosa = {
	234	.name = "Tosa",
	235	.dai_link = tosa_dai,
	236	.num_links = ARRAY_SIZE(tosa_dai),
1b49cb98 LG	237	};
	238
	239	static struct snd_soc_device tosa_snd_devdata = {
	240	.machine = &tosa,
	241	.platform = &pxa2xx_soc_platform,
	242	.codec_dev = &soc_codec_dev_wm9712,
	243	};
	244
	245	static struct platform_device *tosa_snd_device;
	246
	247	static int __init tosa_init(void)
	248	{
	249	int ret;
	250
	251	if (!machine_is_tosa())
	252	return -ENODEV;
	253
4440cbd6 DES	254	ret = gpio_request(TOSA_GPIO_L_MUTE, "Headphone Jack");
	255	if (ret)
	256	return ret;
	257	gpio_direction_output(TOSA_GPIO_L_MUTE, 0);
	258
1b49cb98	259	tosa_snd_device = platform_device_alloc("soc-audio", -1);
4440cbd6 DES	260	if (!tosa_snd_device) {
	261	ret = -ENOMEM;
	262	goto err_alloc;
	263	}
1b49cb98 LG	264
	265	platform_set_drvdata(tosa_snd_device, &tosa_snd_devdata);
	266	tosa_snd_devdata.dev = &tosa_snd_device->dev;
	267	ret = platform_device_add(tosa_snd_device);
	268
4440cbd6 DES	269	if (!ret)
	270	return 0;
	271
	272	platform_device_put(tosa_snd_device);
	273
	274	err_alloc:
	275	gpio_free(TOSA_GPIO_L_MUTE);
1b49cb98 LG	276
	277	return ret;
	278	}
	279
	280	static void __exit tosa_exit(void)
	281	{
	282	platform_device_unregister(tosa_snd_device);
4440cbd6	283	gpio_free(TOSA_GPIO_L_MUTE);
1b49cb98 LG	284	}
	285
	286	module_init(tosa_init);
	287	module_exit(tosa_exit);
	288
	289	/* Module information */
	290	MODULE_AUTHOR("Richard Purdie");
	291	MODULE_DESCRIPTION("ALSA SoC Tosa");
	292	MODULE_LICENSE("GPL");