[deliverable/linux.git] / sound / soc / pxa / raumfeld.c

/*
 * raumfeld_audio.c  --  SoC audio for Raumfeld audio devices
 *
 * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
 *
 * based on code from:
 *
 *    Wolfson Microelectronics PLC.
 *    Openedhand Ltd.
 *    Liam Girdwood <lrg@slimlogic.co.uk>
 *    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.
 */

#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <sound/pcm.h>
#include <sound/soc.h>

#include <asm/mach-types.h>

#include "pxa-ssp.h"

#define GPIO_SPDIF_RESET	(38)
#define GPIO_MCLK_RESET		(111)
#define GPIO_CODEC_RESET	(120)

static struct i2c_client *max9486_client;
static struct i2c_board_info max9486_hwmon_info = {
	I2C_BOARD_INFO("max9485", 0x63),
};

#define MAX9485_MCLK_FREQ_112896 0x22
#define MAX9485_MCLK_FREQ_122880 0x23
#define MAX9485_MCLK_FREQ_225792 0x32
#define MAX9485_MCLK_FREQ_245760 0x33

static void set_max9485_clk(char clk)
{
	i2c_master_send(max9486_client, &clk, 1);
}

static void raumfeld_enable_audio(bool en)
{
	if (en) {
		gpio_set_value(GPIO_MCLK_RESET, 1);

		/* wait some time to let the clocks become stable */
		msleep(100);

		gpio_set_value(GPIO_SPDIF_RESET, 1);
		gpio_set_value(GPIO_CODEC_RESET, 1);
	} else {
		gpio_set_value(GPIO_MCLK_RESET, 0);
		gpio_set_value(GPIO_SPDIF_RESET, 0);
		gpio_set_value(GPIO_CODEC_RESET, 0);
	}
}

/* CS4270 */
static int raumfeld_cs4270_startup(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;

	/* set freq to 0 to enable all possible codec sample rates */
	return snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
}

static void raumfeld_cs4270_shutdown(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;

	/* set freq to 0 to enable all possible codec sample rates */
	snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
}

static int raumfeld_cs4270_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 = 0;

	switch (params_rate(params)) {
	case 44100:
		set_max9485_clk(MAX9485_MCLK_FREQ_112896);
		clk = 11289600;
		break;
	case 48000:
		set_max9485_clk(MAX9485_MCLK_FREQ_122880);
		clk = 12288000;
		break;
	case 88200:
		set_max9485_clk(MAX9485_MCLK_FREQ_225792);
		clk = 22579200;
		break;
	case 96000:
		set_max9485_clk(MAX9485_MCLK_FREQ_245760);
		clk = 24576000;
		break;
	default:
		return -EINVAL;
	}

	ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk, 0);
	if (ret < 0)
		return ret;

	/* setup the CPU DAI */
	ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
	if (ret < 0)
		return ret;

	return 0;
}

static struct snd_soc_ops raumfeld_cs4270_ops = {
	.startup = raumfeld_cs4270_startup,
	.shutdown = raumfeld_cs4270_shutdown,
	.hw_params = raumfeld_cs4270_hw_params,
};

static int raumfeld_analog_suspend(struct snd_soc_card *card)
{
	raumfeld_enable_audio(false);
	return 0;
}

static int raumfeld_analog_resume(struct snd_soc_card *card)
{
	raumfeld_enable_audio(true);
	return 0;
}

/* AK4104 */

static int raumfeld_ak4104_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 *cpu_dai = rtd->cpu_dai;
	int ret = 0, clk = 0;

	switch (params_rate(params)) {
	case 44100:
		set_max9485_clk(MAX9485_MCLK_FREQ_112896);
		clk = 11289600;
		break;
	case 48000:
		set_max9485_clk(MAX9485_MCLK_FREQ_122880);
		clk = 12288000;
		break;
	case 88200:
		set_max9485_clk(MAX9485_MCLK_FREQ_225792);
		clk = 22579200;
		break;
	case 96000:
		set_max9485_clk(MAX9485_MCLK_FREQ_245760);
		clk = 24576000;
		break;
	default:
		return -EINVAL;
	}

	/* setup the CPU DAI */
	ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
	if (ret < 0)
		return ret;

	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
	if (ret < 0)
		return ret;

	return 0;
}

static struct snd_soc_ops raumfeld_ak4104_ops = {
	.hw_params = raumfeld_ak4104_hw_params,
};

#define DAI_LINK_CS4270		\
{							\
	.name		= "CS4270",			\
	.stream_name	= "CS4270",			\
	.cpu_dai_name	= "pxa-ssp-dai.0",		\
	.platform_name	= "pxa-pcm-audio",		\
	.codec_dai_name	= "cs4270-hifi",		\
	.codec_name	= "cs4270.0-0048",	\
	.dai_fmt	= SND_SOC_DAIFMT_I2S |		\
			  SND_SOC_DAIFMT_NB_NF |        \
			  SND_SOC_DAIFMT_CBS_CFS,       \
	.ops		= &raumfeld_cs4270_ops,		\
}

#define DAI_LINK_AK4104		\
{							\
	.name		= "ak4104",			\
	.stream_name	= "Playback",			\
	.cpu_dai_name	= "pxa-ssp-dai.1",		\
	.codec_dai_name	= "ak4104-hifi",		\
	.platform_name	= "pxa-pcm-audio",		\
	.dai_fmt	= SND_SOC_DAIFMT_I2S |		\
			  SND_SOC_DAIFMT_NB_NF |	\
			  SND_SOC_DAIFMT_CBS_CFS,       \
	.ops		= &raumfeld_ak4104_ops,		\
	.codec_name	= "spi0.0",			\
}

static struct snd_soc_dai_link snd_soc_raumfeld_connector_dai[] =
{
	DAI_LINK_CS4270,
	DAI_LINK_AK4104,
};

static struct snd_soc_dai_link snd_soc_raumfeld_speaker_dai[] =
{
	DAI_LINK_CS4270,
};

static struct snd_soc_card snd_soc_raumfeld_connector = {
	.name		= "Raumfeld Connector",
	.owner		= THIS_MODULE,
	.dai_link	= snd_soc_raumfeld_connector_dai,
	.num_links	= ARRAY_SIZE(snd_soc_raumfeld_connector_dai),
	.suspend_post	= raumfeld_analog_suspend,
	.resume_pre	= raumfeld_analog_resume,
};

static struct snd_soc_card snd_soc_raumfeld_speaker = {
	.name		= "Raumfeld Speaker",
	.owner		= THIS_MODULE,
	.dai_link	= snd_soc_raumfeld_speaker_dai,
	.num_links	= ARRAY_SIZE(snd_soc_raumfeld_speaker_dai),
	.suspend_post	= raumfeld_analog_suspend,
	.resume_pre	= raumfeld_analog_resume,
};

static struct platform_device *raumfeld_audio_device;

static int __init raumfeld_audio_init(void)
{
	int ret;

	if (!machine_is_raumfeld_speaker() &&
	    !machine_is_raumfeld_connector())
		return 0;

	max9486_client = i2c_new_device(i2c_get_adapter(0),
					&max9486_hwmon_info);

	if (!max9486_client)
		return -ENOMEM;

	set_max9485_clk(MAX9485_MCLK_FREQ_122880);

	/* Register analog device */
	raumfeld_audio_device = platform_device_alloc("soc-audio", 0);
	if (!raumfeld_audio_device)
		return -ENOMEM;

	if (machine_is_raumfeld_speaker())
		platform_set_drvdata(raumfeld_audio_device,
				     &snd_soc_raumfeld_speaker);

	if (machine_is_raumfeld_connector())
		platform_set_drvdata(raumfeld_audio_device,
				     &snd_soc_raumfeld_connector);

	ret = platform_device_add(raumfeld_audio_device);
	if (ret < 0) {
		platform_device_put(raumfeld_audio_device);
		return ret;
	}

	raumfeld_enable_audio(true);
	return 0;
}

static void __exit raumfeld_audio_exit(void)
{
	raumfeld_enable_audio(false);

	platform_device_unregister(raumfeld_audio_device);

	i2c_unregister_device(max9486_client);

	gpio_free(GPIO_MCLK_RESET);
	gpio_free(GPIO_CODEC_RESET);
	gpio_free(GPIO_SPDIF_RESET);
}

module_init(raumfeld_audio_init);
module_exit(raumfeld_audio_exit);

/* Module information */
MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
MODULE_DESCRIPTION("Raumfeld audio SoC");
MODULE_LICENSE("GPL");
Commit	Line	Data
49af574b DM	1	/*
	2	* raumfeld_audio.c -- SoC audio for Raumfeld audio devices
	3	*
	4	* Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
	5	*
	6	* based on code from:
	7	*
	8	* Wolfson Microelectronics PLC.
	9	* Openedhand Ltd.
	10	* Liam Girdwood <lrg@slimlogic.co.uk>
	11	* Richard Purdie <richard@openedhand.com>
	12	*
	13	* This program is free software; you can redistribute it and/or modify it
	14	* under the terms of the GNU General Public License as published by the
	15	* Free Software Foundation; either version 2 of the License, or (at your
	16	* option) any later version.
	17	*/
	18
	19	#include <linux/module.h>
	20	#include <linux/i2c.h>
	21	#include <linux/delay.h>
	22	#include <linux/gpio.h>
	23	#include <sound/pcm.h>
	24	#include <sound/soc.h>
49af574b DM	25
	26	#include <asm/mach-types.h>
	27
49af574b DM	28	#include "pxa-ssp.h"
	29
	30	#define GPIO_SPDIF_RESET (38)
	31	#define GPIO_MCLK_RESET (111)
	32	#define GPIO_CODEC_RESET (120)
	33
	34	static struct i2c_client *max9486_client;
	35	static struct i2c_board_info max9486_hwmon_info = {
	36	I2C_BOARD_INFO("max9485", 0x63),
	37	};
	38
	39	#define MAX9485_MCLK_FREQ_112896 0x22
a4212968 DM	40	#define MAX9485_MCLK_FREQ_122880 0x23
	41	#define MAX9485_MCLK_FREQ_225792 0x32
	42	#define MAX9485_MCLK_FREQ_245760 0x33
49af574b DM	43
	44	static void set_max9485_clk(char clk)
	45	{
	46	i2c_master_send(max9486_client, &clk, 1);
	47	}
	48
	49	static void raumfeld_enable_audio(bool en)
	50	{
	51	if (en) {
	52	gpio_set_value(GPIO_MCLK_RESET, 1);
	53
	54	/* wait some time to let the clocks become stable */
	55	msleep(100);
	56
	57	gpio_set_value(GPIO_SPDIF_RESET, 1);
	58	gpio_set_value(GPIO_CODEC_RESET, 1);
	59	} else {
	60	gpio_set_value(GPIO_MCLK_RESET, 0);
	61	gpio_set_value(GPIO_SPDIF_RESET, 0);
	62	gpio_set_value(GPIO_CODEC_RESET, 0);
	63	}
	64	}
	65
	66	/* CS4270 */
	67	static int raumfeld_cs4270_startup(struct snd_pcm_substream *substream)
	68	{
	69	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad	70	struct snd_soc_dai *codec_dai = rtd->codec_dai;
49af574b	71
a4212968 DM	72	/* set freq to 0 to enable all possible codec sample rates */
	73	return snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
	74	}
49af574b	75
a4212968 DM	76	static void raumfeld_cs4270_shutdown(struct snd_pcm_substream *substream)
	77	{
	78	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad	79	struct snd_soc_dai *codec_dai = rtd->codec_dai;
a4212968 DM	80
	81	/* set freq to 0 to enable all possible codec sample rates */
	82	snd_soc_dai_set_sysclk(codec_dai, 0, 0, 0);
49af574b DM	83	}
	84
	85	static int raumfeld_cs4270_hw_params(struct snd_pcm_substream *substream,
	86	struct snd_pcm_hw_params *params)
	87	{
	88	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad LG	89	struct snd_soc_dai *codec_dai = rtd->codec_dai;
f0fba2ad LG	90	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
a8bd0ee5	91	unsigned int clk = 0;
49af574b DM	92	int ret = 0;
	93
	94	switch (params_rate(params)) {
a4212968 DM	95	case 44100:
	96	set_max9485_clk(MAX9485_MCLK_FREQ_112896);
	97	clk = 11289600;
	98	break;
49af574b	99	case 48000:
49af574b DM	100	set_max9485_clk(MAX9485_MCLK_FREQ_122880);
	101	clk = 12288000;
	102	break;
49af574b	103	case 88200:
a4212968 DM	104	set_max9485_clk(MAX9485_MCLK_FREQ_225792);
a4212968 DM	105	clk = 22579200;
49af574b	106	break;
a4212968 DM	107	case 96000:
	108	set_max9485_clk(MAX9485_MCLK_FREQ_245760);
	109	clk = 24576000;
	110	break;
	111	default:
	112	return -EINVAL;
49af574b DM	113	}
49af574b DM	114
49af574b DM	115	ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk, 0);
	116	if (ret < 0)
	117	return ret;
	118
	119	/* setup the CPU DAI */
a649d1fc	120	ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
49af574b DM	121	if (ret < 0)
	122	return ret;
	123
49af574b DM	124	ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
	125	if (ret < 0)
	126	return ret;
	127
a4212968	128	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
49af574b DM	129	if (ret < 0)
	130	return ret;
	131
	132	return 0;
	133	}
	134
	135	static struct snd_soc_ops raumfeld_cs4270_ops = {
	136	.startup = raumfeld_cs4270_startup,
a4212968	137	.shutdown = raumfeld_cs4270_shutdown,
49af574b DM	138	.hw_params = raumfeld_cs4270_hw_params,
	139	};
	140
477a6694	141	static int raumfeld_analog_suspend(struct snd_soc_card *card)
49af574b DM	142	{
	143	raumfeld_enable_audio(false);
	144	return 0;
	145	}
	146
477a6694	147	static int raumfeld_analog_resume(struct snd_soc_card *card)
49af574b DM	148	{
	149	raumfeld_enable_audio(true);
	150	return 0;
	151	}
	152
49af574b DM	153	/* AK4104 */
	154
	155	static int raumfeld_ak4104_hw_params(struct snd_pcm_substream *substream,
	156	struct snd_pcm_hw_params *params)
	157	{
	158	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad	159	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
a8bd0ee5	160	int ret = 0, clk = 0;
49af574b DM	161
49af574b DM	162	switch (params_rate(params)) {
a4212968 DM	163	case 44100:
	164	set_max9485_clk(MAX9485_MCLK_FREQ_112896);
	165	clk = 11289600;
	166	break;
49af574b	167	case 48000:
49af574b DM	168	set_max9485_clk(MAX9485_MCLK_FREQ_122880);
	169	clk = 12288000;
	170	break;
49af574b	171	case 88200:
a4212968 DM	172	set_max9485_clk(MAX9485_MCLK_FREQ_225792);
	173	clk = 22579200;
	174	break;
	175	case 96000:
	176	set_max9485_clk(MAX9485_MCLK_FREQ_245760);
	177	clk = 24576000;
49af574b	178	break;
a4212968 DM	179	default:
a4212968 DM	180	return -EINVAL;
49af574b DM	181	}
49af574b DM	182
49af574b	183	/* setup the CPU DAI */
a649d1fc	184	ret = snd_soc_dai_set_pll(cpu_dai, 0, 0, 0, clk);
49af574b DM	185	if (ret < 0)
	186	return ret;
	187
49af574b DM	188	ret = snd_soc_dai_set_clkdiv(cpu_dai, PXA_SSP_DIV_SCR, 4);
	189	if (ret < 0)
	190	return ret;
	191
a4212968	192	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA_SSP_CLK_EXT, clk, 1);
49af574b DM	193	if (ret < 0)
	194	return ret;
	195
	196	return 0;
	197	}
	198
	199	static struct snd_soc_ops raumfeld_ak4104_ops = {
	200	.hw_params = raumfeld_ak4104_hw_params,
	201	};
	202
477a6694 DM	203	#define DAI_LINK_CS4270 \
	204	{ \
	205	.name = "CS4270", \
	206	.stream_name = "CS4270", \
	207	.cpu_dai_name = "pxa-ssp-dai.0", \
	208	.platform_name = "pxa-pcm-audio", \
	209	.codec_dai_name = "cs4270-hifi", \
64902b29	210	.codec_name = "cs4270.0-0048", \
a8bd0ee5 LPC	211	.dai_fmt = SND_SOC_DAIFMT_I2S \| \
	212	SND_SOC_DAIFMT_NB_NF \| \
	213	SND_SOC_DAIFMT_CBS_CFS, \
477a6694 DM	214	.ops = &raumfeld_cs4270_ops, \
	215	}
	216
	217	#define DAI_LINK_AK4104 \
	218	{ \
	219	.name = "ak4104", \
	220	.stream_name = "Playback", \
	221	.cpu_dai_name = "pxa-ssp-dai.1", \
	222	.codec_dai_name = "ak4104-hifi", \
	223	.platform_name = "pxa-pcm-audio", \
a8bd0ee5 LPC	224	.dai_fmt = SND_SOC_DAIFMT_I2S \| \
	225	SND_SOC_DAIFMT_NB_NF \| \
	226	SND_SOC_DAIFMT_CBS_CFS, \
477a6694 DM	227	.ops = &raumfeld_ak4104_ops, \
	228	.codec_name = "spi0.0", \
	229	}
	230
	231	static struct snd_soc_dai_link snd_soc_raumfeld_connector_dai[] =
f0fba2ad	232	{
477a6694 DM	233	DAI_LINK_CS4270,
	234	DAI_LINK_AK4104,
	235	};
	236
	237	static struct snd_soc_dai_link snd_soc_raumfeld_speaker_dai[] =
f0fba2ad	238	{
477a6694 DM	239	DAI_LINK_CS4270,
	240	};
	241
	242	static struct snd_soc_card snd_soc_raumfeld_connector = {
	243	.name = "Raumfeld Connector",
561c6a17	244	.owner = THIS_MODULE,
477a6694 DM	245	.dai_link = snd_soc_raumfeld_connector_dai,
	246	.num_links = ARRAY_SIZE(snd_soc_raumfeld_connector_dai),
	247	.suspend_post = raumfeld_analog_suspend,
	248	.resume_pre = raumfeld_analog_resume,
	249	};
	250
	251	static struct snd_soc_card snd_soc_raumfeld_speaker = {
	252	.name = "Raumfeld Speaker",
561c6a17	253	.owner = THIS_MODULE,
477a6694 DM	254	.dai_link = snd_soc_raumfeld_speaker_dai,
	255	.num_links = ARRAY_SIZE(snd_soc_raumfeld_speaker_dai),
	256	.suspend_post = raumfeld_analog_suspend,
	257	.resume_pre = raumfeld_analog_resume,
49af574b DM	258	};
49af574b DM	259
f0fba2ad	260	static struct platform_device *raumfeld_audio_device;
49af574b DM	261
	262	static int __init raumfeld_audio_init(void)
	263	{
	264	int ret;
	265
	266	if (!machine_is_raumfeld_speaker() &&
	267	!machine_is_raumfeld_connector())
	268	return 0;
	269
	270	max9486_client = i2c_new_device(i2c_get_adapter(0),
	271	&max9486_hwmon_info);
	272
	273	if (!max9486_client)
	274	return -ENOMEM;
	275
	276	set_max9485_clk(MAX9485_MCLK_FREQ_122880);
	277
477a6694	278	/* Register analog device */
f0fba2ad LG	279	raumfeld_audio_device = platform_device_alloc("soc-audio", 0);
f0fba2ad LG	280	if (!raumfeld_audio_device)
49af574b DM	281	return -ENOMEM;
49af574b DM	282
49af574b	283	if (machine_is_raumfeld_speaker())
477a6694 DM	284	platform_set_drvdata(raumfeld_audio_device,
	285	&snd_soc_raumfeld_speaker);
	286
	287	if (machine_is_raumfeld_connector())
	288	platform_set_drvdata(raumfeld_audio_device,
	289	&snd_soc_raumfeld_connector);
	290
	291	ret = platform_device_add(raumfeld_audio_device);
4ed0d012 AL	292	if (ret < 0) {
4ed0d012 AL	293	platform_device_put(raumfeld_audio_device);
49af574b	294	return ret;
4ed0d012	295	}
49af574b	296
49af574b	297	raumfeld_enable_audio(true);
477a6694	298	return 0;
49af574b DM	299	}
	300
	301	static void __exit raumfeld_audio_exit(void)
	302	{
	303	raumfeld_enable_audio(false);
	304
f0fba2ad	305	platform_device_unregister(raumfeld_audio_device);
49af574b DM	306
	307	i2c_unregister_device(max9486_client);
	308
	309	gpio_free(GPIO_MCLK_RESET);
	310	gpio_free(GPIO_CODEC_RESET);
	311	gpio_free(GPIO_SPDIF_RESET);
	312	}
	313
	314	module_init(raumfeld_audio_init);
	315	module_exit(raumfeld_audio_exit);
	316
	317	/* Module information */
	318	MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
	319	MODULE_DESCRIPTION("Raumfeld audio SoC");
	320	MODULE_LICENSE("GPL");