[mirror_ubuntu-bionic-kernel.git] / sound / soc / kirkwood / kirkwood-i2s.c

/*
 * kirkwood-i2s.c
 *
 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
 *
 *  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/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/mbus.h>
#include <linux/delay.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <plat/audio.h>
#include "kirkwood.h"

#define DRV_NAME	"kirkwood-i2s"

#define KIRKWOOD_I2S_RATES \
	(SNDRV_PCM_RATE_44100 | \
	 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
#define KIRKWOOD_I2S_FORMATS \
	(SNDRV_PCM_FMTBIT_S16_LE | \
	 SNDRV_PCM_FMTBIT_S24_LE | \
	 SNDRV_PCM_FMTBIT_S32_LE)

static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
		unsigned int fmt)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
	unsigned long mask;
	unsigned long value;

	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_RIGHT_J:
		mask = KIRKWOOD_I2S_CTL_RJ;
		break;
	case SND_SOC_DAIFMT_LEFT_J:
		mask = KIRKWOOD_I2S_CTL_LJ;
		break;
	case SND_SOC_DAIFMT_I2S:
		mask = KIRKWOOD_I2S_CTL_I2S;
		break;
	default:
		return -EINVAL;
	}

	/*
	 * Set same format for playback and record
	 * This avoids some troubles.
	 */
	value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	value |= mask;
	writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);

	value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	value |= mask;
	writel(value, priv->io+KIRKWOOD_I2S_RECCTL);

	return 0;
}

static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
{
	unsigned long value;

	value = KIRKWOOD_DCO_CTL_OFFSET_0;
	switch (rate) {
	default:
	case 44100:
		value |= KIRKWOOD_DCO_CTL_FREQ_11;
		break;
	case 48000:
		value |= KIRKWOOD_DCO_CTL_FREQ_12;
		break;
	case 96000:
		value |= KIRKWOOD_DCO_CTL_FREQ_24;
		break;
	}
	writel(value, io + KIRKWOOD_DCO_CTL);

	/* wait for dco locked */
	do {
		cpu_relax();
		value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
		value &= KIRKWOOD_DCO_SPCR_STATUS;
	} while (value == 0);
}

static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
		struct snd_soc_dai *dai)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);

	snd_soc_dai_set_dma_data(dai, substream, priv);
	return 0;
}

static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
				 struct snd_pcm_hw_params *params,
				 struct snd_soc_dai *dai)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	unsigned int i2s_reg, reg;
	unsigned long i2s_value, value;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		i2s_reg = KIRKWOOD_I2S_PLAYCTL;
		reg = KIRKWOOD_PLAYCTL;
	} else {
		i2s_reg = KIRKWOOD_I2S_RECCTL;
		reg = KIRKWOOD_RECCTL;
	}

	/* set dco conf */
	kirkwood_set_dco(priv->io, params_rate(params));

	i2s_value = readl(priv->io+i2s_reg);
	i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;

	value = readl(priv->io+reg);
	value &= ~KIRKWOOD_PLAYCTL_SIZE_MASK;

	/*
	 * Size settings in play/rec i2s control regs and play/rec control
	 * regs must be the same.
	 */
	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
		value |= KIRKWOOD_PLAYCTL_SIZE_16_C;
		break;
	/*
	 * doesn't work... S20_3LE != kirkwood 20bit format ?
	 *
	case SNDRV_PCM_FORMAT_S20_3LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
		value |= KIRKWOOD_PLAYCTL_SIZE_20;
		break;
	*/
	case SNDRV_PCM_FORMAT_S24_LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
		value |= KIRKWOOD_PLAYCTL_SIZE_24;
		break;
	case SNDRV_PCM_FORMAT_S32_LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
		value |= KIRKWOOD_PLAYCTL_SIZE_32;
		break;
	default:
		return -EINVAL;
	}

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		value &= ~KIRKWOOD_PLAYCTL_MONO_MASK;
		if (params_channels(params) == 1)
			value |= KIRKWOOD_PLAYCTL_MONO_BOTH;
		else
			value |= KIRKWOOD_PLAYCTL_MONO_OFF;
	}

	writel(i2s_value, priv->io+i2s_reg);
	writel(value, priv->io+reg);

	return 0;
}

static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
				int cmd, struct snd_soc_dai *dai)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	unsigned long value;

	/*
	 * specs says KIRKWOOD_PLAYCTL must be read 2 times before
	 * changing it. So read 1 time here and 1 later.
	 */
	value = readl(priv->io + KIRKWOOD_PLAYCTL);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		/* stop audio, enable interrupts */
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value |= KIRKWOOD_PLAYCTL_PAUSE;
		writel(value, priv->io + KIRKWOOD_PLAYCTL);

		value = readl(priv->io + KIRKWOOD_INT_MASK);
		value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
		writel(value, priv->io + KIRKWOOD_INT_MASK);

		/* configure audio & enable i2s playback */
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value &= ~KIRKWOOD_PLAYCTL_BURST_MASK;
		value &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE
				| KIRKWOOD_PLAYCTL_SPDIF_EN);

		if (priv->burst == 32)
			value |= KIRKWOOD_PLAYCTL_BURST_32;
		else
			value |= KIRKWOOD_PLAYCTL_BURST_128;
		value |= KIRKWOOD_PLAYCTL_I2S_EN;
		writel(value, priv->io + KIRKWOOD_PLAYCTL);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
		/* stop audio, disable interrupts */
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE;
		writel(value, priv->io + KIRKWOOD_PLAYCTL);

		value = readl(priv->io + KIRKWOOD_INT_MASK);
		value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
		writel(value, priv->io + KIRKWOOD_INT_MASK);

		/* disable all playbacks */
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value &= ~(KIRKWOOD_PLAYCTL_I2S_EN | KIRKWOOD_PLAYCTL_SPDIF_EN);
		writel(value, priv->io + KIRKWOOD_PLAYCTL);
		break;

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE;
		writel(value, priv->io + KIRKWOOD_PLAYCTL);
		break;

	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		value = readl(priv->io + KIRKWOOD_PLAYCTL);
		value &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE);
		writel(value, priv->io + KIRKWOOD_PLAYCTL);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
				int cmd, struct snd_soc_dai *dai)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	unsigned long value;

	value = readl(priv->io + KIRKWOOD_RECCTL);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		/* stop audio, enable interrupts */
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value |= KIRKWOOD_RECCTL_PAUSE;
		writel(value, priv->io + KIRKWOOD_RECCTL);

		value = readl(priv->io + KIRKWOOD_INT_MASK);
		value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
		writel(value, priv->io + KIRKWOOD_INT_MASK);

		/* configure audio & enable i2s record */
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value &= ~KIRKWOOD_RECCTL_BURST_MASK;
		value &= ~KIRKWOOD_RECCTL_MONO;
		value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE
			| KIRKWOOD_RECCTL_SPDIF_EN);

		if (priv->burst == 32)
			value |= KIRKWOOD_RECCTL_BURST_32;
		else
			value |= KIRKWOOD_RECCTL_BURST_128;
		value |= KIRKWOOD_RECCTL_I2S_EN;

		writel(value, priv->io + KIRKWOOD_RECCTL);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
		/* stop audio, disable interrupts */
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
		writel(value, priv->io + KIRKWOOD_RECCTL);

		value = readl(priv->io + KIRKWOOD_INT_MASK);
		value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
		writel(value, priv->io + KIRKWOOD_INT_MASK);

		/* disable all records */
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
		writel(value, priv->io + KIRKWOOD_RECCTL);
		break;

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
		writel(value, priv->io + KIRKWOOD_RECCTL);
		break;

	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		value = readl(priv->io + KIRKWOOD_RECCTL);
		value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
		writel(value, priv->io + KIRKWOOD_RECCTL);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
			       struct snd_soc_dai *dai)
{
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		return kirkwood_i2s_play_trigger(substream, cmd, dai);
	else
		return kirkwood_i2s_rec_trigger(substream, cmd, dai);

	return 0;
}

static int kirkwood_i2s_probe(struct snd_soc_dai *dai)
{
	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	unsigned long value;
	unsigned int reg_data;

	/* put system in a "safe" state : */
	/* disable audio interrupts */
	writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
	writel(0, priv->io + KIRKWOOD_INT_MASK);

	reg_data = readl(priv->io + 0x1200);
	reg_data &= (~(0x333FF8));
	reg_data |= 0x111D18;
	writel(reg_data, priv->io + 0x1200);

	msleep(500);

	reg_data = readl(priv->io + 0x1200);
	reg_data &= (~(0x333FF8));
	reg_data |= 0x111D18;
	writel(reg_data, priv->io + 0x1200);

	/* disable playback/record */
	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	value &= ~(KIRKWOOD_PLAYCTL_I2S_EN|KIRKWOOD_PLAYCTL_SPDIF_EN);
	writel(value, priv->io + KIRKWOOD_PLAYCTL);

	value = readl(priv->io + KIRKWOOD_RECCTL);
	value &= ~(KIRKWOOD_RECCTL_I2S_EN | KIRKWOOD_RECCTL_SPDIF_EN);
	writel(value, priv->io + KIRKWOOD_RECCTL);

	return 0;

}

static int kirkwood_i2s_remove(struct snd_soc_dai *dai)
{
	return 0;
}

static struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
	.startup	= kirkwood_i2s_startup,
	.trigger	= kirkwood_i2s_trigger,
	.hw_params      = kirkwood_i2s_hw_params,
	.set_fmt        = kirkwood_i2s_set_fmt,
};


static struct snd_soc_dai_driver kirkwood_i2s_dai = {
	.probe = kirkwood_i2s_probe,
	.remove = kirkwood_i2s_remove,
	.playback = {
		.channels_min = 1,
		.channels_max = 2,
		.rates = KIRKWOOD_I2S_RATES,
		.formats = KIRKWOOD_I2S_FORMATS,},
	.capture = {
		.channels_min = 1,
		.channels_max = 2,
		.rates = KIRKWOOD_I2S_RATES,
		.formats = KIRKWOOD_I2S_FORMATS,},
	.ops = &kirkwood_i2s_dai_ops,
};

static __devinit int kirkwood_i2s_dev_probe(struct platform_device *pdev)
{
	struct resource *mem;
	struct kirkwood_asoc_platform_data *data =
		pdev->dev.platform_data;
	struct kirkwood_dma_data *priv;
	int err;

	priv = kzalloc(sizeof(struct kirkwood_dma_data), GFP_KERNEL);
	if (!priv) {
		dev_err(&pdev->dev, "allocation failed\n");
		err = -ENOMEM;
		goto error;
	}
	dev_set_drvdata(&pdev->dev, priv);

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!mem) {
		dev_err(&pdev->dev, "platform_get_resource failed\n");
		err = -ENXIO;
		goto err_alloc;
	}

	priv->mem = request_mem_region(mem->start, SZ_16K, DRV_NAME);
	if (!priv->mem) {
		dev_err(&pdev->dev, "request_mem_region failed\n");
		err = -EBUSY;
		goto error_alloc;
	}

	priv->io = ioremap(priv->mem->start, SZ_16K);
	if (!priv->io) {
		dev_err(&pdev->dev, "ioremap failed\n");
		err = -ENOMEM;
		goto err_iomem;
	}

	priv->irq = platform_get_irq(pdev, 0);
	if (priv->irq <= 0) {
		dev_err(&pdev->dev, "platform_get_irq failed\n");
		err = -ENXIO;
		goto err_ioremap;
	}

	if (!data || !data->dram) {
		dev_err(&pdev->dev, "no platform data ?!\n");
		err = -EINVAL;
		goto err_ioremap;
	}

	priv->dram = data->dram;
	priv->burst = data->burst;

	return snd_soc_register_dai(&pdev->dev, &kirkwood_i2s_dai);

err_ioremap:
	iounmap(priv->io);
err_iomem:
	release_mem_region(priv->mem->start, SZ_16K);
err_alloc:
	kfree(priv);
error:
	return err;
}

static __devexit int kirkwood_i2s_dev_remove(struct platform_device *pdev)
{
	struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);

	snd_soc_unregister_dai(&pdev->dev);
	iounmap(priv->io);
	release_mem_region(priv->mem->start, SZ_16K);
	kfree(priv);

	return 0;
}

static struct platform_driver kirkwood_i2s_driver = {
	.probe  = kirkwood_i2s_dev_probe,
	.remove = kirkwood_i2s_dev_remove,
	.driver = {
		.name = DRV_NAME,
		.owner = THIS_MODULE,
	},
};

static int __init kirkwood_i2s_init(void)
{
	return platform_driver_register(&kirkwood_i2s_driver);
}
module_init(kirkwood_i2s_init);

static void __exit kirkwood_i2s_exit(void)
{
	platform_driver_unregister(&kirkwood_i2s_driver);
}
module_exit(kirkwood_i2s_exit);

/* Module information */
MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:kirkwood-i2s");
Commit	Line	Data
f9b95980	1	/*
	2	* kirkwood-i2s.c
	3	*
	4	* (c) 2010 Arnaud Patard <apatard@mandriva.com>
69737897	5	* (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
f9b95980	6	*
	7	* This program is free software; you can redistribute it and/or modify it
	8	* under the terms of the GNU General Public License as published by the
	9	* Free Software Foundation; either version 2 of the License, or (at your
	10	* option) any later version.
	11	*/
	12
	13	#include <linux/init.h>
	14	#include <linux/module.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/io.h>
	17	#include <linux/slab.h>
	18	#include <linux/mbus.h>
	19	#include <linux/delay.h>
	20	#include <sound/pcm.h>
	21	#include <sound/pcm_params.h>
	22	#include <sound/soc.h>
	23	#include <plat/audio.h>
f9b95980	24	#include "kirkwood.h"
	25
	26	#define DRV_NAME "kirkwood-i2s"
	27
	28	#define KIRKWOOD_I2S_RATES \
	29	(SNDRV_PCM_RATE_44100 \| \
	30	SNDRV_PCM_RATE_48000 \| SNDRV_PCM_RATE_96000)
	31	#define KIRKWOOD_I2S_FORMATS \
	32	(SNDRV_PCM_FMTBIT_S16_LE \| \
	33	SNDRV_PCM_FMTBIT_S24_LE \| \
	34	SNDRV_PCM_FMTBIT_S32_LE)
	35
f9b95980	36	static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
	37	unsigned int fmt)
	38	{
f0fba2ad	39	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
f9b95980	40	unsigned long mask;
	41	unsigned long value;
	42
	43	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	44	case SND_SOC_DAIFMT_RIGHT_J:
	45	mask = KIRKWOOD_I2S_CTL_RJ;
	46	break;
	47	case SND_SOC_DAIFMT_LEFT_J:
	48	mask = KIRKWOOD_I2S_CTL_LJ;
	49	break;
	50	case SND_SOC_DAIFMT_I2S:
	51	mask = KIRKWOOD_I2S_CTL_I2S;
	52	break;
	53	default:
	54	return -EINVAL;
	55	}
	56
	57	/*
	58	* Set same format for playback and record
	59	* This avoids some troubles.
	60	*/
	61	value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
	62	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	63	value \|= mask;
	64	writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
	65
	66	value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
	67	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	68	value \|= mask;
	69	writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
	70
	71	return 0;
	72	}
	73
	74	static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
	75	{
	76	unsigned long value;
	77
	78	value = KIRKWOOD_DCO_CTL_OFFSET_0;
	79	switch (rate) {
	80	default:
	81	case 44100:
	82	value \|= KIRKWOOD_DCO_CTL_FREQ_11;
	83	break;
	84	case 48000:
	85	value \|= KIRKWOOD_DCO_CTL_FREQ_12;
	86	break;
	87	case 96000:
	88	value \|= KIRKWOOD_DCO_CTL_FREQ_24;
	89	break;
	90	}
	91	writel(value, io + KIRKWOOD_DCO_CTL);
	92
	93	/* wait for dco locked */
	94	do {
	95	cpu_relax();
	96	value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
	97	value &= KIRKWOOD_DCO_SPCR_STATUS;
	98	} while (value == 0);
	99	}
	100
f0fba2ad LG	101	static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
	102	struct snd_soc_dai *dai)
	103	{
	104	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	105
	106	snd_soc_dai_set_dma_data(dai, substream, priv);
	107	return 0;
	108	}
	109
f9b95980	110	static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
	111	struct snd_pcm_hw_params *params,
	112	struct snd_soc_dai *dai)
	113	{
f0fba2ad	114	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
f9b95980	115	unsigned int i2s_reg, reg;
	116	unsigned long i2s_value, value;
	117
	118	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	119	i2s_reg = KIRKWOOD_I2S_PLAYCTL;
	120	reg = KIRKWOOD_PLAYCTL;
	121	} else {
	122	i2s_reg = KIRKWOOD_I2S_RECCTL;
	123	reg = KIRKWOOD_RECCTL;
	124	}
	125
	126	/* set dco conf */
	127	kirkwood_set_dco(priv->io, params_rate(params));
	128
	129	i2s_value = readl(priv->io+i2s_reg);
	130	i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
	131
	132	value = readl(priv->io+reg);
	133	value &= ~KIRKWOOD_PLAYCTL_SIZE_MASK;
	134
	135	/*
	136	* Size settings in play/rec i2s control regs and play/rec control
	137	* regs must be the same.
	138	*/
	139	switch (params_format(params)) {
	140	case SNDRV_PCM_FORMAT_S16_LE:
	141	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_16;
	142	value \|= KIRKWOOD_PLAYCTL_SIZE_16_C;
	143	break;
	144	/*
	145	* doesn't work... S20_3LE != kirkwood 20bit format ?
	146	*
	147	case SNDRV_PCM_FORMAT_S20_3LE:
	148	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_20;
	149	value \|= KIRKWOOD_PLAYCTL_SIZE_20;
	150	break;
	151	*/
	152	case SNDRV_PCM_FORMAT_S24_LE:
	153	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_24;
	154	value \|= KIRKWOOD_PLAYCTL_SIZE_24;
	155	break;
	156	case SNDRV_PCM_FORMAT_S32_LE:
	157	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_32;
	158	value \|= KIRKWOOD_PLAYCTL_SIZE_32;
	159	break;
	160	default:
	161	return -EINVAL;
	162	}
dfe4c936 AP	163
	164	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	165	value &= ~KIRKWOOD_PLAYCTL_MONO_MASK;
	166	if (params_channels(params) == 1)
	167	value \|= KIRKWOOD_PLAYCTL_MONO_BOTH;
	168	else
	169	value \|= KIRKWOOD_PLAYCTL_MONO_OFF;
	170	}
	171
f9b95980	172	writel(i2s_value, priv->io+i2s_reg);
	173	writel(value, priv->io+reg);
	174
	175	return 0;
	176	}
	177
	178	static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
	179	int cmd, struct snd_soc_dai *dai)
	180	{
f0fba2ad	181	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
f9b95980	182	unsigned long value;
	183
	184	/*
	185	* specs says KIRKWOOD_PLAYCTL must be read 2 times before
	186	* changing it. So read 1 time here and 1 later.
	187	*/
	188	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	189
	190	switch (cmd) {
	191	case SNDRV_PCM_TRIGGER_START:
	192	/* stop audio, enable interrupts */
	193	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	194	value \|= KIRKWOOD_PLAYCTL_PAUSE;
	195	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	196
	197	value = readl(priv->io + KIRKWOOD_INT_MASK);
	198	value \|= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
	199	writel(value, priv->io + KIRKWOOD_INT_MASK);
	200
	201	/* configure audio & enable i2s playback */
	202	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	203	value &= ~KIRKWOOD_PLAYCTL_BURST_MASK;
b424ec95 AP	204	value &= ~(KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE
b424ec95 AP	205	\| KIRKWOOD_PLAYCTL_SPDIF_EN);
f9b95980	206
	207	if (priv->burst == 32)
	208	value \|= KIRKWOOD_PLAYCTL_BURST_32;
	209	else
	210	value \|= KIRKWOOD_PLAYCTL_BURST_128;
	211	value \|= KIRKWOOD_PLAYCTL_I2S_EN;
	212	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	213	break;
	214
	215	case SNDRV_PCM_TRIGGER_STOP:
	216	/* stop audio, disable interrupts */
	217	value = readl(priv->io + KIRKWOOD_PLAYCTL);
b424ec95	218	value \|= KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE;
f9b95980	219	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	220
	221	value = readl(priv->io + KIRKWOOD_INT_MASK);
	222	value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
	223	writel(value, priv->io + KIRKWOOD_INT_MASK);
	224
	225	/* disable all playbacks */
	226	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	227	value &= ~(KIRKWOOD_PLAYCTL_I2S_EN \| KIRKWOOD_PLAYCTL_SPDIF_EN);
	228	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	229	break;
	230
	231	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	232	case SNDRV_PCM_TRIGGER_SUSPEND:
	233	value = readl(priv->io + KIRKWOOD_PLAYCTL);
b424ec95	234	value \|= KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE;
f9b95980	235	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	236	break;
	237
	238	case SNDRV_PCM_TRIGGER_RESUME:
	239	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	240	value = readl(priv->io + KIRKWOOD_PLAYCTL);
b424ec95	241	value &= ~(KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE);
f9b95980	242	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	243	break;
	244
	245	default:
	246	return -EINVAL;
	247	}
	248
	249	return 0;
	250	}
	251
	252	static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
	253	int cmd, struct snd_soc_dai *dai)
	254	{
f0fba2ad	255	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
f9b95980	256	unsigned long value;
	257
	258	value = readl(priv->io + KIRKWOOD_RECCTL);
	259
	260	switch (cmd) {
	261	case SNDRV_PCM_TRIGGER_START:
	262	/* stop audio, enable interrupts */
	263	value = readl(priv->io + KIRKWOOD_RECCTL);
	264	value \|= KIRKWOOD_RECCTL_PAUSE;
	265	writel(value, priv->io + KIRKWOOD_RECCTL);
	266
	267	value = readl(priv->io + KIRKWOOD_INT_MASK);
	268	value \|= KIRKWOOD_INT_CAUSE_REC_BYTES;
	269	writel(value, priv->io + KIRKWOOD_INT_MASK);
	270
	271	/* configure audio & enable i2s record */
	272	value = readl(priv->io + KIRKWOOD_RECCTL);
	273	value &= ~KIRKWOOD_RECCTL_BURST_MASK;
	274	value &= ~KIRKWOOD_RECCTL_MONO;
b424ec95 AP	275	value &= ~(KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE
b424ec95 AP	276	\| KIRKWOOD_RECCTL_SPDIF_EN);
f9b95980	277
	278	if (priv->burst == 32)
	279	value \|= KIRKWOOD_RECCTL_BURST_32;
	280	else
	281	value \|= KIRKWOOD_RECCTL_BURST_128;
	282	value \|= KIRKWOOD_RECCTL_I2S_EN;
	283
	284	writel(value, priv->io + KIRKWOOD_RECCTL);
	285	break;
	286
	287	case SNDRV_PCM_TRIGGER_STOP:
	288	/* stop audio, disable interrupts */
	289	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	290	value \|= KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE;
f9b95980	291	writel(value, priv->io + KIRKWOOD_RECCTL);
	292
	293	value = readl(priv->io + KIRKWOOD_INT_MASK);
	294	value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
	295	writel(value, priv->io + KIRKWOOD_INT_MASK);
	296
	297	/* disable all records */
	298	value = readl(priv->io + KIRKWOOD_RECCTL);
	299	value &= ~(KIRKWOOD_RECCTL_I2S_EN \| KIRKWOOD_RECCTL_SPDIF_EN);
	300	writel(value, priv->io + KIRKWOOD_RECCTL);
	301	break;
	302
	303	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	304	case SNDRV_PCM_TRIGGER_SUSPEND:
	305	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	306	value \|= KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE;
f9b95980	307	writel(value, priv->io + KIRKWOOD_RECCTL);
	308	break;
	309
	310	case SNDRV_PCM_TRIGGER_RESUME:
	311	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	312	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	313	value &= ~(KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE);
f9b95980	314	writel(value, priv->io + KIRKWOOD_RECCTL);
	315	break;
	316
	317	default:
	318	return -EINVAL;
f9b95980	319	}
	320
	321	return 0;
	322	}
	323
	324	static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
	325	struct snd_soc_dai *dai)
	326	{
	327	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	328	return kirkwood_i2s_play_trigger(substream, cmd, dai);
	329	else
	330	return kirkwood_i2s_rec_trigger(substream, cmd, dai);
	331
	332	return 0;
	333	}
	334
f0fba2ad	335	static int kirkwood_i2s_probe(struct snd_soc_dai *dai)
f9b95980	336	{
f0fba2ad	337	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
f9b95980	338	unsigned long value;
	339	unsigned int reg_data;
	340
	341	/* put system in a "safe" state : */
	342	/* disable audio interrupts */
	343	writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
	344	writel(0, priv->io + KIRKWOOD_INT_MASK);
	345
	346	reg_data = readl(priv->io + 0x1200);
	347	reg_data &= (~(0x333FF8));
	348	reg_data \|= 0x111D18;
	349	writel(reg_data, priv->io + 0x1200);
	350
	351	msleep(500);
	352
	353	reg_data = readl(priv->io + 0x1200);
	354	reg_data &= (~(0x333FF8));
	355	reg_data \|= 0x111D18;
	356	writel(reg_data, priv->io + 0x1200);
	357
	358	/* disable playback/record */
	359	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	360	value &= ~(KIRKWOOD_PLAYCTL_I2S_EN\|KIRKWOOD_PLAYCTL_SPDIF_EN);
	361	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	362
	363	value = readl(priv->io + KIRKWOOD_RECCTL);
	364	value &= ~(KIRKWOOD_RECCTL_I2S_EN \| KIRKWOOD_RECCTL_SPDIF_EN);
	365	writel(value, priv->io + KIRKWOOD_RECCTL);
	366
	367	return 0;
	368
	369	}
	370
f0fba2ad	371	static int kirkwood_i2s_remove(struct snd_soc_dai *dai)
f9b95980	372	{
f0fba2ad	373	return 0;
f9b95980	374	}
	375
	376	static struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
f0fba2ad	377	.startup = kirkwood_i2s_startup,
f9b95980	378	.trigger = kirkwood_i2s_trigger,
	379	.hw_params = kirkwood_i2s_hw_params,
	380	.set_fmt = kirkwood_i2s_set_fmt,
	381	};
	382
	383
f0fba2ad	384	static struct snd_soc_dai_driver kirkwood_i2s_dai = {
f9b95980	385	.probe = kirkwood_i2s_probe,
	386	.remove = kirkwood_i2s_remove,
	387	.playback = {
	388	.channels_min = 1,
	389	.channels_max = 2,
	390	.rates = KIRKWOOD_I2S_RATES,
	391	.formats = KIRKWOOD_I2S_FORMATS,},
	392	.capture = {
	393	.channels_min = 1,
	394	.channels_max = 2,
	395	.rates = KIRKWOOD_I2S_RATES,
	396	.formats = KIRKWOOD_I2S_FORMATS,},
	397	.ops = &kirkwood_i2s_dai_ops,
	398	};
f9b95980	399
	400	static __devinit int kirkwood_i2s_dev_probe(struct platform_device *pdev)
	401	{
	402	struct resource *mem;
	403	struct kirkwood_asoc_platform_data *data =
	404	pdev->dev.platform_data;
f0fba2ad	405	struct kirkwood_dma_data *priv;
f9b95980	406	int err;
	407
	408	priv = kzalloc(sizeof(struct kirkwood_dma_data), GFP_KERNEL);
	409	if (!priv) {
	410	dev_err(&pdev->dev, "allocation failed\n");
	411	err = -ENOMEM;
	412	goto error;
	413	}
f0fba2ad	414	dev_set_drvdata(&pdev->dev, priv);
f9b95980	415
	416	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	417	if (!mem) {
	418	dev_err(&pdev->dev, "platform_get_resource failed\n");
	419	err = -ENXIO;
	420	goto err_alloc;
	421	}
	422
	423	priv->mem = request_mem_region(mem->start, SZ_16K, DRV_NAME);
	424	if (!priv->mem) {
	425	dev_err(&pdev->dev, "request_mem_region failed\n");
	426	err = -EBUSY;
96101bd0	427	goto error_alloc;
f9b95980	428	}
	429
	430	priv->io = ioremap(priv->mem->start, SZ_16K);
	431	if (!priv->io) {
	432	dev_err(&pdev->dev, "ioremap failed\n");
	433	err = -ENOMEM;
	434	goto err_iomem;
	435	}
	436
	437	priv->irq = platform_get_irq(pdev, 0);
	438	if (priv->irq <= 0) {
	439	dev_err(&pdev->dev, "platform_get_irq failed\n");
	440	err = -ENXIO;
	441	goto err_ioremap;
	442	}
	443
	444	if (!data \|\| !data->dram) {
	445	dev_err(&pdev->dev, "no platform data ?!\n");
	446	err = -EINVAL;
	447	goto err_ioremap;
	448	}
	449
	450	priv->dram = data->dram;
	451	priv->burst = data->burst;
	452
f0fba2ad	453	return snd_soc_register_dai(&pdev->dev, &kirkwood_i2s_dai);
f9b95980	454
	455	err_ioremap:
	456	iounmap(priv->io);
	457	err_iomem:
	458	release_mem_region(priv->mem->start, SZ_16K);
	459	err_alloc:
	460	kfree(priv);
	461	error:
	462	return err;
	463	}
	464
	465	static __devexit int kirkwood_i2s_dev_remove(struct platform_device *pdev)
	466	{
f0fba2ad LG	467	struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);
	468
	469	snd_soc_unregister_dai(&pdev->dev);
	470	iounmap(priv->io);
	471	release_mem_region(priv->mem->start, SZ_16K);
	472	kfree(priv);
	473
f9b95980	474	return 0;
	475	}
	476
	477	static struct platform_driver kirkwood_i2s_driver = {
	478	.probe = kirkwood_i2s_dev_probe,
	479	.remove = kirkwood_i2s_dev_remove,
	480	.driver = {
	481	.name = DRV_NAME,
	482	.owner = THIS_MODULE,
	483	},
	484	};
	485
	486	static int __init kirkwood_i2s_init(void)
	487	{
	488	return platform_driver_register(&kirkwood_i2s_driver);
	489	}
	490	module_init(kirkwood_i2s_init);
	491
	492	static void __exit kirkwood_i2s_exit(void)
	493	{
	494	platform_driver_unregister(&kirkwood_i2s_driver);
	495	}
	496	module_exit(kirkwood_i2s_exit);
	497
	498	/* Module information */
69737897	499	MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
f9b95980	500	MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
	501	MODULE_LICENSE("GPL");
	502	MODULE_ALIAS("platform:kirkwood-i2s");