[deliverable/linux.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 <linux/clk.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <linux/platform_data/asoc-kirkwood.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_DCO_LOCK;
	} 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);
	uint32_t ctl_play, ctl_rec;
	unsigned int i2s_reg;
	unsigned long i2s_value;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		i2s_reg = KIRKWOOD_I2S_PLAYCTL;
	} else {
		i2s_reg = KIRKWOOD_I2S_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;

	/*
	 * 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;
		ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C |
			   KIRKWOOD_PLAYCTL_I2S_EN;
		ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C |
			  KIRKWOOD_RECCTL_I2S_EN;
		break;
	/*
	 * doesn't work... S20_3LE != kirkwood 20bit format ?
	 *
	case SNDRV_PCM_FORMAT_S20_3LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
		ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 |
			   KIRKWOOD_PLAYCTL_I2S_EN;
		ctl_rec = KIRKWOOD_RECCTL_SIZE_20 |
			  KIRKWOOD_RECCTL_I2S_EN;
		break;
	*/
	case SNDRV_PCM_FORMAT_S24_LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
		ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 |
			   KIRKWOOD_PLAYCTL_I2S_EN;
		ctl_rec = KIRKWOOD_RECCTL_SIZE_24 |
			  KIRKWOOD_RECCTL_I2S_EN;
		break;
	case SNDRV_PCM_FORMAT_S32_LE:
		i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
		ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 |
			   KIRKWOOD_PLAYCTL_I2S_EN;
		ctl_rec = KIRKWOOD_RECCTL_SIZE_32 |
			  KIRKWOOD_RECCTL_I2S_EN;
		break;
	default:
		return -EINVAL;
	}

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		if (params_channels(params) == 1)
			ctl_play |= KIRKWOOD_PLAYCTL_MONO_BOTH;
		else
			ctl_play |= KIRKWOOD_PLAYCTL_MONO_OFF;

		priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK |
				    KIRKWOOD_PLAYCTL_I2S_EN |
				    KIRKWOOD_PLAYCTL_SPDIF_EN |
				    KIRKWOOD_PLAYCTL_SIZE_MASK);
		priv->ctl_play |= ctl_play;
	} else {
		priv->ctl_rec &= ~KIRKWOOD_RECCTL_SIZE_MASK;
		priv->ctl_rec |= ctl_rec;
	}

	writel(i2s_value, priv->io+i2s_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);
	uint32_t ctl, value;

	ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
	if (ctl & KIRKWOOD_PLAYCTL_PAUSE) {
		unsigned timeout = 5000;
		/*
		 * The Armada510 spec says that if we enter pause mode, the
		 * busy bit must be read back as clear _twice_.  Make sure
		 * we respect that otherwise we get DMA underruns.
		 */
		do {
			value = ctl;
			ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
			if (!((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
				break;
			udelay(1);
		} while (timeout--);

		if ((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
			dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
				   ctl);
	}

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		/* configure */
		ctl = priv->ctl_play;
		value = ctl & ~(KIRKWOOD_PLAYCTL_I2S_EN |
				KIRKWOOD_PLAYCTL_SPDIF_EN);
		writel(value, priv->io + KIRKWOOD_PLAYCTL);

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

		/* enable playback */
		writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
		/* stop audio, disable interrupts */
		ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE;
		writel(ctl, 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 */
		ctl &= ~(KIRKWOOD_PLAYCTL_I2S_EN | KIRKWOOD_PLAYCTL_SPDIF_EN);
		writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
		break;

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

	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE);
		writel(ctl, 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);
	uint32_t ctl, value;

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

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		/* configure */
		ctl = priv->ctl_rec;
		value = ctl & ~KIRKWOOD_RECCTL_I2S_EN;
		writel(value, priv->io + KIRKWOOD_RECCTL);

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

		/* enable record */
		writel(ctl, 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 const 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 = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		dev_err(&pdev->dev, "allocation failed\n");
		return -ENOMEM;
	}
	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");
		return -ENXIO;
	}

	priv->io = devm_request_and_ioremap(&pdev->dev, mem);
	if (!priv->io) {
		dev_err(&pdev->dev, "devm_request_and_ioremap failed\n");
		return -ENOMEM;
	}

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

	if (!data) {
		dev_err(&pdev->dev, "no platform data ?!\n");
		return -EINVAL;
	}

	priv->burst = data->burst;

	priv->clk = devm_clk_get(&pdev->dev, NULL);
	if (IS_ERR(priv->clk)) {
		dev_err(&pdev->dev, "no clock\n");
		return PTR_ERR(priv->clk);
	}

	err = clk_prepare_enable(priv->clk);
	if (err < 0)
		return err;

	priv->extclk = clk_get(&pdev->dev, "extclk");
	if (!IS_ERR(priv->extclk)) {
		if (priv->extclk == priv->clk) {
			clk_put(priv->extclk);
			priv->extclk = ERR_PTR(-EINVAL);
		} else {
			dev_info(&pdev->dev, "found external clock\n");
			clk_prepare_enable(priv->extclk);
			soc_dai = &kirkwood_i2s_dai_extclk;
		}
	}

	/* Some sensible defaults - this reflects the powerup values */
	priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
	priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;

	/* Select the burst size */
	if (data->burst == 32) {
		priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32;
		priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32;
	} else {
		priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128;
		priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128;
	}

	err = snd_soc_register_dai(&pdev->dev, &kirkwood_i2s_dai);
	if (!err)
		return 0;
	dev_err(&pdev->dev, "snd_soc_register_dai failed\n");

	clk_disable_unprepare(priv->clk);

	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);

	clk_disable_unprepare(priv->clk);

	return 0;
}

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

module_platform_driver(kirkwood_i2s_driver);

/* 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>
e919c716	20	#include <linux/clk.h>
f9b95980	21	#include <sound/pcm.h>
	22	#include <sound/pcm_params.h>
	23	#include <sound/soc.h>
c02cecb9	24	#include <linux/platform_data/asoc-kirkwood.h>
f9b95980	25	#include "kirkwood.h"
	26
	27	#define DRV_NAME "kirkwood-i2s"
	28
	29	#define KIRKWOOD_I2S_RATES \
	30	(SNDRV_PCM_RATE_44100 \| \
	31	SNDRV_PCM_RATE_48000 \| SNDRV_PCM_RATE_96000)
	32	#define KIRKWOOD_I2S_FORMATS \
	33	(SNDRV_PCM_FMTBIT_S16_LE \| \
	34	SNDRV_PCM_FMTBIT_S24_LE \| \
	35	SNDRV_PCM_FMTBIT_S32_LE)
	36
f9b95980	37	static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
	38	unsigned int fmt)
	39	{
f0fba2ad	40	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
f9b95980	41	unsigned long mask;
	42	unsigned long value;
	43
	44	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	45	case SND_SOC_DAIFMT_RIGHT_J:
	46	mask = KIRKWOOD_I2S_CTL_RJ;
	47	break;
	48	case SND_SOC_DAIFMT_LEFT_J:
	49	mask = KIRKWOOD_I2S_CTL_LJ;
	50	break;
	51	case SND_SOC_DAIFMT_I2S:
	52	mask = KIRKWOOD_I2S_CTL_I2S;
	53	break;
	54	default:
	55	return -EINVAL;
	56	}
	57
	58	/*
	59	* Set same format for playback and record
	60	* This avoids some troubles.
	61	*/
	62	value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
	63	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	64	value \|= mask;
	65	writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
	66
	67	value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
	68	value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
	69	value \|= mask;
	70	writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
	71
	72	return 0;
	73	}
	74
	75	static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
	76	{
	77	unsigned long value;
	78
	79	value = KIRKWOOD_DCO_CTL_OFFSET_0;
	80	switch (rate) {
	81	default:
	82	case 44100:
	83	value \|= KIRKWOOD_DCO_CTL_FREQ_11;
	84	break;
	85	case 48000:
	86	value \|= KIRKWOOD_DCO_CTL_FREQ_12;
	87	break;
	88	case 96000:
	89	value \|= KIRKWOOD_DCO_CTL_FREQ_24;
	90	break;
	91	}
	92	writel(value, io + KIRKWOOD_DCO_CTL);
	93
	94	/* wait for dco locked */
	95	do {
	96	cpu_relax();
	97	value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
2424d458	98	value &= KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK;
f9b95980	99	} while (value == 0);
	100	}
	101
f0fba2ad LG	102	static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
	103	struct snd_soc_dai *dai)
	104	{
	105	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
	106
	107	snd_soc_dai_set_dma_data(dai, substream, priv);
	108	return 0;
	109	}
	110
f9b95980	111	static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
	112	struct snd_pcm_hw_params *params,
	113	struct snd_soc_dai *dai)
	114	{
f0fba2ad	115	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
d8d11ba5 RK	116	uint32_t ctl_play, ctl_rec;
	117	unsigned int i2s_reg;
	118	unsigned long i2s_value;
f9b95980	119
	120	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	121	i2s_reg = KIRKWOOD_I2S_PLAYCTL;
f9b95980	122	} else {
f9b95980	123	i2s_reg = KIRKWOOD_I2S_RECCTL;
f9b95980	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
f9b95980	132	/*
	133	* Size settings in play/rec i2s control regs and play/rec control
	134	* regs must be the same.
	135	*/
	136	switch (params_format(params)) {
	137	case SNDRV_PCM_FORMAT_S16_LE:
	138	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_16;
d8d11ba5 RK	139	ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C \|
	140	KIRKWOOD_PLAYCTL_I2S_EN;
	141	ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C \|
	142	KIRKWOOD_RECCTL_I2S_EN;
f9b95980	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;
d8d11ba5 RK	149	ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 \|
	150	KIRKWOOD_PLAYCTL_I2S_EN;
	151	ctl_rec = KIRKWOOD_RECCTL_SIZE_20 \|
	152	KIRKWOOD_RECCTL_I2S_EN;
f9b95980	153	break;
	154	*/
	155	case SNDRV_PCM_FORMAT_S24_LE:
	156	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_24;
d8d11ba5 RK	157	ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 \|
	158	KIRKWOOD_PLAYCTL_I2S_EN;
	159	ctl_rec = KIRKWOOD_RECCTL_SIZE_24 \|
	160	KIRKWOOD_RECCTL_I2S_EN;
f9b95980	161	break;
	162	case SNDRV_PCM_FORMAT_S32_LE:
	163	i2s_value \|= KIRKWOOD_I2S_CTL_SIZE_32;
d8d11ba5 RK	164	ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 \|
	165	KIRKWOOD_PLAYCTL_I2S_EN;
	166	ctl_rec = KIRKWOOD_RECCTL_SIZE_32 \|
	167	KIRKWOOD_RECCTL_I2S_EN;
f9b95980	168	break;
	169	default:
	170	return -EINVAL;
	171	}
dfe4c936	172
dfe4c936	173	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
dfe4c936	174	if (params_channels(params) == 1)
d8d11ba5	175	ctl_play \|= KIRKWOOD_PLAYCTL_MONO_BOTH;
dfe4c936	176	else
d8d11ba5 RK	177	ctl_play \|= KIRKWOOD_PLAYCTL_MONO_OFF;
	178
	179	priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK \|
	180	KIRKWOOD_PLAYCTL_I2S_EN \|
	181	KIRKWOOD_PLAYCTL_SPDIF_EN \|
	182	KIRKWOOD_PLAYCTL_SIZE_MASK);
	183	priv->ctl_play \|= ctl_play;
	184	} else {
	185	priv->ctl_rec &= ~KIRKWOOD_RECCTL_SIZE_MASK;
	186	priv->ctl_rec \|= ctl_rec;
dfe4c936	187	}
dfe4c936	188
f9b95980	189	writel(i2s_value, priv->io+i2s_reg);
f9b95980	190
	191	return 0;
	192	}
	193
	194	static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
	195	int cmd, struct snd_soc_dai *dai)
	196	{
f0fba2ad	197	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
982b604b RK	198	uint32_t ctl, value;
	199
	200	ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
	201	if (ctl & KIRKWOOD_PLAYCTL_PAUSE) {
	202	unsigned timeout = 5000;
	203	/*
	204	* The Armada510 spec says that if we enter pause mode, the
	205	* busy bit must be read back as clear _twice_. Make sure
	206	* we respect that otherwise we get DMA underruns.
	207	*/
	208	do {
	209	value = ctl;
	210	ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
	211	if (!((ctl \| value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
	212	break;
	213	udelay(1);
	214	} while (timeout--);
	215
	216	if ((ctl \| value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
	217	dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
	218	ctl);
	219	}
f9b95980	220
	221	switch (cmd) {
	222	case SNDRV_PCM_TRIGGER_START:
d8d11ba5 RK	223	/* configure */
	224	ctl = priv->ctl_play;
	225	value = ctl & ~(KIRKWOOD_PLAYCTL_I2S_EN \|
	226	KIRKWOOD_PLAYCTL_SPDIF_EN);
	227	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	228
	229	/* enable interrupts */
f9b95980	230	value = readl(priv->io + KIRKWOOD_INT_MASK);
	231	value \|= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
	232	writel(value, priv->io + KIRKWOOD_INT_MASK);
	233
d8d11ba5	234	/* enable playback */
982b604b	235	writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
f9b95980	236	break;
	237
	238	case SNDRV_PCM_TRIGGER_STOP:
	239	/* stop audio, disable interrupts */
982b604b RK	240	ctl \|= KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE;
982b604b RK	241	writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
f9b95980	242
	243	value = readl(priv->io + KIRKWOOD_INT_MASK);
	244	value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
	245	writel(value, priv->io + KIRKWOOD_INT_MASK);
	246
	247	/* disable all playbacks */
982b604b RK	248	ctl &= ~(KIRKWOOD_PLAYCTL_I2S_EN \| KIRKWOOD_PLAYCTL_SPDIF_EN);
982b604b RK	249	writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
f9b95980	250	break;
	251
	252	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	253	case SNDRV_PCM_TRIGGER_SUSPEND:
982b604b RK	254	ctl \|= KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE;
982b604b RK	255	writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
f9b95980	256	break;
	257
	258	case SNDRV_PCM_TRIGGER_RESUME:
	259	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
982b604b RK	260	ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE \| KIRKWOOD_PLAYCTL_I2S_MUTE);
982b604b RK	261	writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
f9b95980	262	break;
	263
	264	default:
	265	return -EINVAL;
	266	}
	267
	268	return 0;
	269	}
	270
	271	static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
	272	int cmd, struct snd_soc_dai *dai)
	273	{
f0fba2ad	274	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
d8d11ba5	275	uint32_t ctl, value;
f9b95980	276
	277	value = readl(priv->io + KIRKWOOD_RECCTL);
	278
	279	switch (cmd) {
	280	case SNDRV_PCM_TRIGGER_START:
d8d11ba5 RK	281	/* configure */
	282	ctl = priv->ctl_rec;
	283	value = ctl & ~KIRKWOOD_RECCTL_I2S_EN;
	284	writel(value, priv->io + KIRKWOOD_RECCTL);
	285
	286	/* enable interrupts */
f9b95980	287	value = readl(priv->io + KIRKWOOD_INT_MASK);
	288	value \|= KIRKWOOD_INT_CAUSE_REC_BYTES;
	289	writel(value, priv->io + KIRKWOOD_INT_MASK);
	290
d8d11ba5 RK	291	/* enable record */
d8d11ba5 RK	292	writel(ctl, priv->io + KIRKWOOD_RECCTL);
f9b95980	293	break;
	294
	295	case SNDRV_PCM_TRIGGER_STOP:
	296	/* stop audio, disable interrupts */
	297	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	298	value \|= KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE;
f9b95980	299	writel(value, priv->io + KIRKWOOD_RECCTL);
	300
	301	value = readl(priv->io + KIRKWOOD_INT_MASK);
	302	value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
	303	writel(value, priv->io + KIRKWOOD_INT_MASK);
	304
	305	/* disable all records */
	306	value = readl(priv->io + KIRKWOOD_RECCTL);
	307	value &= ~(KIRKWOOD_RECCTL_I2S_EN \| KIRKWOOD_RECCTL_SPDIF_EN);
	308	writel(value, priv->io + KIRKWOOD_RECCTL);
	309	break;
	310
	311	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	312	case SNDRV_PCM_TRIGGER_SUSPEND:
	313	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	314	value \|= KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE;
f9b95980	315	writel(value, priv->io + KIRKWOOD_RECCTL);
	316	break;
	317
	318	case SNDRV_PCM_TRIGGER_RESUME:
	319	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	320	value = readl(priv->io + KIRKWOOD_RECCTL);
b424ec95	321	value &= ~(KIRKWOOD_RECCTL_PAUSE \| KIRKWOOD_RECCTL_MUTE);
f9b95980	322	writel(value, priv->io + KIRKWOOD_RECCTL);
	323	break;
	324
	325	default:
	326	return -EINVAL;
f9b95980	327	}
	328
	329	return 0;
	330	}
	331
	332	static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
	333	struct snd_soc_dai *dai)
	334	{
	335	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	336	return kirkwood_i2s_play_trigger(substream, cmd, dai);
	337	else
	338	return kirkwood_i2s_rec_trigger(substream, cmd, dai);
	339
	340	return 0;
	341	}
	342
f0fba2ad	343	static int kirkwood_i2s_probe(struct snd_soc_dai *dai)
f9b95980	344	{
f0fba2ad	345	struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
f9b95980	346	unsigned long value;
	347	unsigned int reg_data;
	348
	349	/* put system in a "safe" state : */
	350	/* disable audio interrupts */
	351	writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
	352	writel(0, priv->io + KIRKWOOD_INT_MASK);
	353
	354	reg_data = readl(priv->io + 0x1200);
	355	reg_data &= (~(0x333FF8));
	356	reg_data \|= 0x111D18;
	357	writel(reg_data, priv->io + 0x1200);
	358
	359	msleep(500);
	360
	361	reg_data = readl(priv->io + 0x1200);
	362	reg_data &= (~(0x333FF8));
	363	reg_data \|= 0x111D18;
	364	writel(reg_data, priv->io + 0x1200);
	365
	366	/* disable playback/record */
	367	value = readl(priv->io + KIRKWOOD_PLAYCTL);
	368	value &= ~(KIRKWOOD_PLAYCTL_I2S_EN\|KIRKWOOD_PLAYCTL_SPDIF_EN);
	369	writel(value, priv->io + KIRKWOOD_PLAYCTL);
	370
	371	value = readl(priv->io + KIRKWOOD_RECCTL);
	372	value &= ~(KIRKWOOD_RECCTL_I2S_EN \| KIRKWOOD_RECCTL_SPDIF_EN);
	373	writel(value, priv->io + KIRKWOOD_RECCTL);
	374
	375	return 0;
	376
	377	}
	378
f0fba2ad	379	static int kirkwood_i2s_remove(struct snd_soc_dai *dai)
f9b95980	380	{
f0fba2ad	381	return 0;
f9b95980	382	}
f9b95980	383
85e7652d	384	static const struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
f0fba2ad	385	.startup = kirkwood_i2s_startup,
f9b95980	386	.trigger = kirkwood_i2s_trigger,
	387	.hw_params = kirkwood_i2s_hw_params,
	388	.set_fmt = kirkwood_i2s_set_fmt,
	389	};
	390
	391
f0fba2ad	392	static struct snd_soc_dai_driver kirkwood_i2s_dai = {
f9b95980	393	.probe = kirkwood_i2s_probe,
	394	.remove = kirkwood_i2s_remove,
	395	.playback = {
	396	.channels_min = 1,
	397	.channels_max = 2,
	398	.rates = KIRKWOOD_I2S_RATES,
	399	.formats = KIRKWOOD_I2S_FORMATS,},
	400	.capture = {
	401	.channels_min = 1,
	402	.channels_max = 2,
	403	.rates = KIRKWOOD_I2S_RATES,
	404	.formats = KIRKWOOD_I2S_FORMATS,},
	405	.ops = &kirkwood_i2s_dai_ops,
	406	};
f9b95980	407
	408	static __devinit int kirkwood_i2s_dev_probe(struct platform_device *pdev)
	409	{
	410	struct resource *mem;
	411	struct kirkwood_asoc_platform_data *data =
	412	pdev->dev.platform_data;
f0fba2ad	413	struct kirkwood_dma_data *priv;
f9b95980	414	int err;
f9b95980	415
dbc517bf	416	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
f9b95980	417	if (!priv) {
f9b95980	418	dev_err(&pdev->dev, "allocation failed\n");
dbc517bf	419	return -ENOMEM;
f9b95980	420	}
f0fba2ad	421	dev_set_drvdata(&pdev->dev, priv);
f9b95980	422
	423	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	424	if (!mem) {
	425	dev_err(&pdev->dev, "platform_get_resource failed\n");
dbc517bf	426	return -ENXIO;
f9b95980	427	}
f9b95980	428
dbc517bf	429	priv->io = devm_request_and_ioremap(&pdev->dev, mem);
f9b95980	430	if (!priv->io) {
dbc517bf RK	431	dev_err(&pdev->dev, "devm_request_and_ioremap failed\n");
dbc517bf RK	432	return -ENOMEM;
f9b95980	433	}
	434
	435	priv->irq = platform_get_irq(pdev, 0);
	436	if (priv->irq <= 0) {
	437	dev_err(&pdev->dev, "platform_get_irq failed\n");
dbc517bf	438	return -ENXIO;
f9b95980	439	}
f9b95980	440
d4d9820b	441	if (!data) {
f9b95980	442	dev_err(&pdev->dev, "no platform data ?!\n");
dbc517bf	443	return -EINVAL;
f9b95980	444	}
f9b95980	445
f9b95980	446	priv->burst = data->burst;
f9b95980	447
dbc517bf	448	priv->clk = devm_clk_get(&pdev->dev, NULL);
e919c716 AL	449	if (IS_ERR(priv->clk)) {
e919c716 AL	450	dev_err(&pdev->dev, "no clock\n");
dbc517bf	451	return PTR_ERR(priv->clk);
e919c716	452	}
dbc517bf RK	453
	454	err = clk_prepare_enable(priv->clk);
	455	if (err < 0)
	456	return err;
e919c716	457
d8d11ba5 RK	458	priv->extclk = clk_get(&pdev->dev, "extclk");
	459	if (!IS_ERR(priv->extclk)) {
	460	if (priv->extclk == priv->clk) {
	461	clk_put(priv->extclk);
	462	priv->extclk = ERR_PTR(-EINVAL);
	463	} else {
	464	dev_info(&pdev->dev, "found external clock\n");
	465	clk_prepare_enable(priv->extclk);
	466	soc_dai = &kirkwood_i2s_dai_extclk;
	467	}
	468	}
	469
	470	/* Some sensible defaults - this reflects the powerup values */
	471	priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
	472	priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;
	473
	474	/* Select the burst size */
	475	if (data->burst == 32) {
	476	priv->ctl_play \|= KIRKWOOD_PLAYCTL_BURST_32;
	477	priv->ctl_rec \|= KIRKWOOD_RECCTL_BURST_32;
	478	} else {
	479	priv->ctl_play \|= KIRKWOOD_PLAYCTL_BURST_128;
	480	priv->ctl_rec \|= KIRKWOOD_RECCTL_BURST_128;
	481	}
	482
baffab28 SB	483	err = snd_soc_register_dai(&pdev->dev, &kirkwood_i2s_dai);
	484	if (!err)
	485	return 0;
	486	dev_err(&pdev->dev, "snd_soc_register_dai failed\n");
	487
	488	clk_disable_unprepare(priv->clk);
dbc517bf	489
f9b95980	490	return err;
	491	}
	492
	493	static __devexit int kirkwood_i2s_dev_remove(struct platform_device *pdev)
	494	{
f0fba2ad LG	495	struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);
	496
	497	snd_soc_unregister_dai(&pdev->dev);
e919c716 AL	498
e919c716 AL	499	clk_disable_unprepare(priv->clk);
f0fba2ad	500
f9b95980	501	return 0;
	502	}
	503
	504	static struct platform_driver kirkwood_i2s_driver = {
	505	.probe = kirkwood_i2s_dev_probe,
48860e40	506	.remove = __devexit_p(kirkwood_i2s_dev_remove),
f9b95980	507	.driver = {
	508	.name = DRV_NAME,
	509	.owner = THIS_MODULE,
	510	},
	511	};
	512
41b10225	513	module_platform_driver(kirkwood_i2s_driver);
f9b95980	514
f9b95980	515	/* Module information */
69737897	516	MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
f9b95980	517	MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
	518	MODULE_LICENSE("GPL");
	519	MODULE_ALIAS("platform:kirkwood-i2s");