[deliverable/linux.git] / sound / soc / samsung / smartq_wm8987.c

/* sound/soc/samsung/smartq_wm8987.c
 *
 * Copyright 2010 Maurus Cuelenaere <mcuelenaere@gmail.com>
 *
 * Based on smdk6410_wm8987.c
 *     Copyright 2007 Wolfson Microelectronics PLC. - linux@wolfsonmicro.com
 *     Graeme Gregory - graeme.gregory@wolfsonmicro.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.
 *
 */

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

#include <sound/soc.h>
#include <sound/jack.h>

#include <mach/gpio-samsung.h>
#include <asm/mach-types.h>

#include "i2s.h"
#include "../codecs/wm8750.h"

/*
 * WM8987 is register compatible with WM8750, so using that as base driver.
 */

static struct snd_soc_card snd_soc_smartq;

static int smartq_hifi_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	unsigned int clk = 0;
	int ret;

	switch (params_rate(params)) {
	case 8000:
	case 16000:
	case 32000:
	case 48000:
	case 96000:
		clk = 12288000;
		break;
	case 11025:
	case 22050:
	case 44100:
	case 88200:
		clk = 11289600;
		break;
	}

	/* set codec DAI configuration */
	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
					     SND_SOC_DAIFMT_NB_NF |
					     SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	/* set cpu DAI configuration */
	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
					   SND_SOC_DAIFMT_NB_NF |
					   SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	/* Use PCLK for I2S signal generation */
	ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_RCLKSRC_0,
					0, SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	/* Gate the RCLK output on PAD */
	ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_CDCLK,
					0, SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	/* set the codec system clock for DAC and ADC */
	ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
				     SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	return 0;
}

/*
 * SmartQ WM8987 HiFi DAI operations.
 */
static struct snd_soc_ops smartq_hifi_ops = {
	.hw_params = smartq_hifi_hw_params,
};

static struct snd_soc_jack smartq_jack;

static struct snd_soc_jack_pin smartq_jack_pins[] = {
	/* Disable speaker when headphone is plugged in */
	{
		.pin	= "Internal Speaker",
		.mask	= SND_JACK_HEADPHONE,
	},
};

static struct snd_soc_jack_gpio smartq_jack_gpios[] = {
	{
		.gpio		= S3C64XX_GPL(12),
		.name		= "headphone detect",
		.report		= SND_JACK_HEADPHONE,
		.debounce_time	= 200,
	},
};

static const struct snd_kcontrol_new wm8987_smartq_controls[] = {
	SOC_DAPM_PIN_SWITCH("Internal Speaker"),
	SOC_DAPM_PIN_SWITCH("Headphone Jack"),
	SOC_DAPM_PIN_SWITCH("Internal Mic"),
};

static int smartq_speaker_event(struct snd_soc_dapm_widget *w,
				struct snd_kcontrol *k,
				int event)
{
	gpio_set_value(S3C64XX_GPK(12), SND_SOC_DAPM_EVENT_OFF(event));

	return 0;
}

static const struct snd_soc_dapm_widget wm8987_dapm_widgets[] = {
	SND_SOC_DAPM_SPK("Internal Speaker", smartq_speaker_event),
	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	SND_SOC_DAPM_MIC("Internal Mic", NULL),
};

static const struct snd_soc_dapm_route audio_map[] = {
	{"Headphone Jack", NULL, "LOUT2"},
	{"Headphone Jack", NULL, "ROUT2"},

	{"Internal Speaker", NULL, "LOUT2"},
	{"Internal Speaker", NULL, "ROUT2"},

	{"Mic Bias", NULL, "Internal Mic"},
	{"LINPUT2", NULL, "Mic Bias"},
};

static int smartq_wm8987_init(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_codec *codec = rtd->codec;
	struct snd_soc_dapm_context *dapm = &codec->dapm;
	int err = 0;

	/* set endpoints to not connected */
	snd_soc_dapm_nc_pin(dapm, "LINPUT1");
	snd_soc_dapm_nc_pin(dapm, "RINPUT1");
	snd_soc_dapm_nc_pin(dapm, "OUT3");
	snd_soc_dapm_nc_pin(dapm, "ROUT1");

	/* set endpoints to default off mode */
	snd_soc_dapm_enable_pin(dapm, "Internal Speaker");
	snd_soc_dapm_enable_pin(dapm, "Internal Mic");
	snd_soc_dapm_disable_pin(dapm, "Headphone Jack");

	/* Headphone jack detection */
	err = snd_soc_jack_new(codec, "Headphone Jack",
			       SND_JACK_HEADPHONE, &smartq_jack);
	if (err)
		return err;

	err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins),
				    smartq_jack_pins);
	if (err)
		return err;

	err = snd_soc_jack_add_gpios(&smartq_jack,
				     ARRAY_SIZE(smartq_jack_gpios),
				     smartq_jack_gpios);

	return err;
}

static struct snd_soc_dai_link smartq_dai[] = {
	{
		.name		= "wm8987",
		.stream_name	= "SmartQ Hi-Fi",
		.cpu_dai_name	= "samsung-i2s.0",
		.codec_dai_name	= "wm8750-hifi",
		.platform_name	= "samsung-i2s.0",
		.codec_name	= "wm8750.0-0x1a",
		.init		= smartq_wm8987_init,
		.ops		= &smartq_hifi_ops,
	},
};

static struct snd_soc_card snd_soc_smartq = {
	.name = "SmartQ",
	.owner = THIS_MODULE,
	.dai_link = smartq_dai,
	.num_links = ARRAY_SIZE(smartq_dai),

	.dapm_widgets = wm8987_dapm_widgets,
	.num_dapm_widgets = ARRAY_SIZE(wm8987_dapm_widgets),
	.dapm_routes = audio_map,
	.num_dapm_routes = ARRAY_SIZE(audio_map),
	.controls = wm8987_smartq_controls,
	.num_controls = ARRAY_SIZE(wm8987_smartq_controls),
};

static struct platform_device *smartq_snd_device;

static int __init smartq_init(void)
{
	int ret;

	if (!machine_is_smartq7() && !machine_is_smartq5()) {
		pr_info("Only SmartQ is supported by this ASoC driver\n");
		return -ENODEV;
	}

	smartq_snd_device = platform_device_alloc("soc-audio", -1);
	if (!smartq_snd_device)
		return -ENOMEM;

	platform_set_drvdata(smartq_snd_device, &snd_soc_smartq);

	ret = platform_device_add(smartq_snd_device);
	if (ret) {
		platform_device_put(smartq_snd_device);
		return ret;
	}

	/* Initialise GPIOs used by amplifiers */
	ret = gpio_request(S3C64XX_GPK(12), "amplifiers shutdown");
	if (ret) {
		dev_err(&smartq_snd_device->dev, "Failed to register GPK12\n");
		goto err_unregister_device;
	}

	/* Disable amplifiers */
	ret = gpio_direction_output(S3C64XX_GPK(12), 1);
	if (ret) {
		dev_err(&smartq_snd_device->dev, "Failed to configure GPK12\n");
		goto err_free_gpio_amp_shut;
	}

	return 0;

err_free_gpio_amp_shut:
	gpio_free(S3C64XX_GPK(12));
err_unregister_device:
	platform_device_unregister(smartq_snd_device);

	return ret;
}

static void __exit smartq_exit(void)
{
	gpio_free(S3C64XX_GPK(12));
	snd_soc_jack_free_gpios(&smartq_jack, ARRAY_SIZE(smartq_jack_gpios),
				smartq_jack_gpios);

	platform_device_unregister(smartq_snd_device);
}

module_init(smartq_init);
module_exit(smartq_exit);

/* Module information */
MODULE_AUTHOR("Maurus Cuelenaere <mcuelenaere@gmail.com>");
MODULE_DESCRIPTION("ALSA SoC SmartQ WM8987");
MODULE_LICENSE("GPL");
Commit	Line	Data
5033f43c	1	/* sound/soc/samsung/smartq_wm8987.c
ce93a370 MC	2	*
	3	* Copyright 2010 Maurus Cuelenaere <mcuelenaere@gmail.com>
	4	*
	5	* Based on smdk6410_wm8987.c
	6	* Copyright 2007 Wolfson Microelectronics PLC. - linux@wolfsonmicro.com
	7	* Graeme Gregory - graeme.gregory@wolfsonmicro.com
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the
	11	* Free Software Foundation; either version 2 of the License, or (at your
	12	* option) any later version.
	13	*
	14	*/
	15
ce93a370	16	#include <linux/gpio.h>
da155d5b	17	#include <linux/module.h>
ce93a370	18
1c8f2c42	19	#include <sound/soc.h>
ce93a370 MC	20	#include <sound/jack.h>
ce93a370 MC	21
abffae64	22	#include <mach/gpio-samsung.h>
ce93a370 MC	23	#include <asm/mach-types.h>
ce93a370 MC	24
b9493d6c	25	#include "i2s.h"
ce93a370 MC	26	#include "../codecs/wm8750.h"
	27
	28	/*
	29	* WM8987 is register compatible with WM8750, so using that as base driver.
	30	*/
	31
	32	static struct snd_soc_card snd_soc_smartq;
	33
	34	static int smartq_hifi_hw_params(struct snd_pcm_substream *substream,
	35	struct snd_pcm_hw_params *params)
	36	{
	37	struct snd_soc_pcm_runtime *rtd = substream->private_data;
74bd21e9 AL	38	struct snd_soc_dai *codec_dai = rtd->codec_dai;
74bd21e9 AL	39	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
ce93a370 MC	40	unsigned int clk = 0;
	41	int ret;
	42
ce93a370 MC	43	switch (params_rate(params)) {
	44	case 8000:
	45	case 16000:
	46	case 32000:
	47	case 48000:
	48	case 96000:
	49	clk = 12288000;
	50	break;
	51	case 11025:
	52	case 22050:
	53	case 44100:
	54	case 88200:
	55	clk = 11289600;
	56	break;
	57	}
	58
	59	/* set codec DAI configuration */
	60	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S \|
	61	SND_SOC_DAIFMT_NB_NF \|
	62	SND_SOC_DAIFMT_CBS_CFS);
	63	if (ret < 0)
	64	return ret;
	65
	66	/* set cpu DAI configuration */
	67	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S \|
	68	SND_SOC_DAIFMT_NB_NF \|
	69	SND_SOC_DAIFMT_CBS_CFS);
	70	if (ret < 0)
	71	return ret;
	72
b9493d6c JB	73	/* Use PCLK for I2S signal generation */
	74	ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_RCLKSRC_0,
	75	0, SND_SOC_CLOCK_IN);
ce93a370 MC	76	if (ret < 0)
	77	return ret;
	78
b9493d6c JB	79	/* Gate the RCLK output on PAD */
	80	ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_CDCLK,
	81	0, SND_SOC_CLOCK_IN);
ce93a370 MC	82	if (ret < 0)
	83	return ret;
	84
b9493d6c JB	85	/* set the codec system clock for DAC and ADC */
	86	ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
	87	SND_SOC_CLOCK_IN);
ce93a370 MC	88	if (ret < 0)
	89	return ret;
	90
	91	return 0;
	92	}
	93
	94	/*
	95	* SmartQ WM8987 HiFi DAI operations.
	96	*/
	97	static struct snd_soc_ops smartq_hifi_ops = {
	98	.hw_params = smartq_hifi_hw_params,
	99	};
	100
	101	static struct snd_soc_jack smartq_jack;
	102
	103	static struct snd_soc_jack_pin smartq_jack_pins[] = {
	104	/* Disable speaker when headphone is plugged in */
	105	{
	106	.pin = "Internal Speaker",
	107	.mask = SND_JACK_HEADPHONE,
ce93a370 MC	108	},
	109	};
	110
	111	static struct snd_soc_jack_gpio smartq_jack_gpios[] = {
	112	{
	113	.gpio = S3C64XX_GPL(12),
	114	.name = "headphone detect",
	115	.report = SND_JACK_HEADPHONE,
	116	.debounce_time = 200,
	117	},
	118	};
	119
	120	static const struct snd_kcontrol_new wm8987_smartq_controls[] = {
	121	SOC_DAPM_PIN_SWITCH("Internal Speaker"),
	122	SOC_DAPM_PIN_SWITCH("Headphone Jack"),
	123	SOC_DAPM_PIN_SWITCH("Internal Mic"),
	124	};
	125
	126	static int smartq_speaker_event(struct snd_soc_dapm_widget *w,
	127	struct snd_kcontrol *k,
	128	int event)
	129	{
	130	gpio_set_value(S3C64XX_GPK(12), SND_SOC_DAPM_EVENT_OFF(event));
	131
	132	return 0;
	133	}
	134
	135	static const struct snd_soc_dapm_widget wm8987_dapm_widgets[] = {
	136	SND_SOC_DAPM_SPK("Internal Speaker", smartq_speaker_event),
	137	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	138	SND_SOC_DAPM_MIC("Internal Mic", NULL),
	139	};
	140
	141	static const struct snd_soc_dapm_route audio_map[] = {
	142	{"Headphone Jack", NULL, "LOUT2"},
	143	{"Headphone Jack", NULL, "ROUT2"},
	144
	145	{"Internal Speaker", NULL, "LOUT2"},
	146	{"Internal Speaker", NULL, "ROUT2"},
	147
	148	{"Mic Bias", NULL, "Internal Mic"},
	149	{"LINPUT2", NULL, "Mic Bias"},
	150	};
	151
74bd21e9	152	static int smartq_wm8987_init(struct snd_soc_pcm_runtime *rtd)
ce93a370	153	{
74bd21e9	154	struct snd_soc_codec *codec = rtd->codec;
ce6120cc	155	struct snd_soc_dapm_context *dapm = &codec->dapm;
ce93a370 MC	156	int err = 0;
ce93a370 MC	157
ce93a370	158	/* set endpoints to not connected */
ce6120cc LG	159	snd_soc_dapm_nc_pin(dapm, "LINPUT1");
	160	snd_soc_dapm_nc_pin(dapm, "RINPUT1");
	161	snd_soc_dapm_nc_pin(dapm, "OUT3");
	162	snd_soc_dapm_nc_pin(dapm, "ROUT1");
ce93a370 MC	163
ce93a370 MC	164	/* set endpoints to default off mode */
ce6120cc LG	165	snd_soc_dapm_enable_pin(dapm, "Internal Speaker");
	166	snd_soc_dapm_enable_pin(dapm, "Internal Mic");
	167	snd_soc_dapm_disable_pin(dapm, "Headphone Jack");
ce93a370	168
ce93a370	169	/* Headphone jack detection */
74bd21e9	170	err = snd_soc_jack_new(codec, "Headphone Jack",
ce93a370 MC	171	SND_JACK_HEADPHONE, &smartq_jack);
	172	if (err)
	173	return err;
	174
	175	err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins),
	176	smartq_jack_pins);
	177	if (err)
	178	return err;
	179
	180	err = snd_soc_jack_add_gpios(&smartq_jack,
	181	ARRAY_SIZE(smartq_jack_gpios),
	182	smartq_jack_gpios);
	183
	184	return err;
	185	}
	186
	187	static struct snd_soc_dai_link smartq_dai[] = {
	188	{
	189	.name = "wm8987",
	190	.stream_name = "SmartQ Hi-Fi",
b9493d6c	191	.cpu_dai_name = "samsung-i2s.0",
f0fba2ad	192	.codec_dai_name = "wm8750-hifi",
a08485d8	193	.platform_name = "samsung-i2s.0",
dc5de62b	194	.codec_name = "wm8750.0-0x1a",
ce93a370 MC	195	.init = smartq_wm8987_init,
	196	.ops = &smartq_hifi_ops,
	197	},
	198	};
	199
	200	static struct snd_soc_card snd_soc_smartq = {
	201	.name = "SmartQ",
095d79dc	202	.owner = THIS_MODULE,
ce93a370 MC	203	.dai_link = smartq_dai,
ce93a370 MC	204	.num_links = ARRAY_SIZE(smartq_dai),
257fe593 MB	205
	206	.dapm_widgets = wm8987_dapm_widgets,
	207	.num_dapm_widgets = ARRAY_SIZE(wm8987_dapm_widgets),
	208	.dapm_routes = audio_map,
	209	.num_dapm_routes = ARRAY_SIZE(audio_map),
	210	.controls = wm8987_smartq_controls,
	211	.num_controls = ARRAY_SIZE(wm8987_smartq_controls),
ce93a370 MC	212	};
ce93a370 MC	213
ce93a370 MC	214	static struct platform_device *smartq_snd_device;
	215
	216	static int __init smartq_init(void)
	217	{
	218	int ret;
	219
	220	if (!machine_is_smartq7() && !machine_is_smartq5()) {
	221	pr_info("Only SmartQ is supported by this ASoC driver\n");
	222	return -ENODEV;
	223	}
	224
	225	smartq_snd_device = platform_device_alloc("soc-audio", -1);
	226	if (!smartq_snd_device)
	227	return -ENOMEM;
	228
f0fba2ad	229	platform_set_drvdata(smartq_snd_device, &snd_soc_smartq);
ce93a370 MC	230
	231	ret = platform_device_add(smartq_snd_device);
	232	if (ret) {
	233	platform_device_put(smartq_snd_device);
	234	return ret;
	235	}
	236
	237	/* Initialise GPIOs used by amplifiers */
	238	ret = gpio_request(S3C64XX_GPK(12), "amplifiers shutdown");
	239	if (ret) {
	240	dev_err(&smartq_snd_device->dev, "Failed to register GPK12\n");
	241	goto err_unregister_device;
	242	}
	243
	244	/* Disable amplifiers */
	245	ret = gpio_direction_output(S3C64XX_GPK(12), 1);
	246	if (ret) {
	247	dev_err(&smartq_snd_device->dev, "Failed to configure GPK12\n");
	248	goto err_free_gpio_amp_shut;
	249	}
	250
	251	return 0;
	252
	253	err_free_gpio_amp_shut:
	254	gpio_free(S3C64XX_GPK(12));
	255	err_unregister_device:
	256	platform_device_unregister(smartq_snd_device);
	257
	258	return ret;
	259	}
	260
	261	static void __exit smartq_exit(void)
	262	{
3790f205	263	gpio_free(S3C64XX_GPK(12));
ce93a370 MC	264	snd_soc_jack_free_gpios(&smartq_jack, ARRAY_SIZE(smartq_jack_gpios),
	265	smartq_jack_gpios);
	266
	267	platform_device_unregister(smartq_snd_device);
	268	}
	269
	270	module_init(smartq_init);
	271	module_exit(smartq_exit);
	272
	273	/* Module information */
	274	MODULE_AUTHOR("Maurus Cuelenaere <mcuelenaere@gmail.com>");
	275	MODULE_DESCRIPTION("ALSA SoC SmartQ WM8987");
	276	MODULE_LICENSE("GPL");