[net-next-2.6.git] / sound / soc / txx9 / txx9aclc.c

/*
 * Generic TXx9 ACLC platform driver
 *
 * Copyright (C) 2009 Atsushi Nemoto
 *
 * Based on RBTX49xx patch from CELF patch archive.
 * (C) Copyright TOSHIBA CORPORATION 2004-2006
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include "txx9aclc.h"

static const struct snd_pcm_hardware txx9aclc_pcm_hardware = {
	/*
	 * REVISIT: SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
	 * needs more works for noncoherent MIPS.
	 */
	.info		  = SNDRV_PCM_INFO_INTERLEAVED |
			    SNDRV_PCM_INFO_BATCH |
			    SNDRV_PCM_INFO_PAUSE,
#ifdef __BIG_ENDIAN
	.formats	  = SNDRV_PCM_FMTBIT_S16_BE,
#else
	.formats	  = SNDRV_PCM_FMTBIT_S16_LE,
#endif
	.period_bytes_min = 1024,
	.period_bytes_max = 8 * 1024,
	.periods_min	  = 2,
	.periods_max	  = 4096,
	.buffer_bytes_max = 32 * 1024,
};

static int txx9aclc_pcm_hw_params(struct snd_pcm_substream *substream,
				  struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
	struct snd_soc_device *socdev = rtd->socdev;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct txx9aclc_dmadata *dmadata = runtime->private_data;
	int ret;

	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	if (ret < 0)
		return ret;

	dev_dbg(socdev->dev,
		"runtime->dma_area = %#lx dma_addr = %#lx dma_bytes = %zd "
		"runtime->min_align %ld\n",
		(unsigned long)runtime->dma_area,
		(unsigned long)runtime->dma_addr, runtime->dma_bytes,
		runtime->min_align);
	dev_dbg(socdev->dev,
		"periods %d period_bytes %d stream %d\n",
		params_periods(params), params_period_bytes(params),
		substream->stream);

	dmadata->substream = substream;
	dmadata->pos = 0;
	return 0;
}

static int txx9aclc_pcm_hw_free(struct snd_pcm_substream *substream)
{
	return snd_pcm_lib_free_pages(substream);
}

static int txx9aclc_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct txx9aclc_dmadata *dmadata = runtime->private_data;

	dmadata->dma_addr = runtime->dma_addr;
	dmadata->buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
	dmadata->period_bytes = snd_pcm_lib_period_bytes(substream);

	if (dmadata->buffer_bytes == dmadata->period_bytes) {
		dmadata->frag_bytes = dmadata->period_bytes >> 1;
		dmadata->frags = 2;
	} else {
		dmadata->frag_bytes = dmadata->period_bytes;
		dmadata->frags = dmadata->buffer_bytes / dmadata->period_bytes;
	}
	dmadata->frag_count = 0;
	dmadata->pos = 0;
	return 0;
}

static void txx9aclc_dma_complete(void *arg)
{
	struct txx9aclc_dmadata *dmadata = arg;
	unsigned long flags;

	/* dma completion handler cannot submit new operations */
	spin_lock_irqsave(&dmadata->dma_lock, flags);
	if (dmadata->frag_count >= 0) {
		dmadata->dmacount--;
		BUG_ON(dmadata->dmacount < 0);
		tasklet_schedule(&dmadata->tasklet);
	}
	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
}

static struct dma_async_tx_descriptor *
txx9aclc_dma_submit(struct txx9aclc_dmadata *dmadata, dma_addr_t buf_dma_addr)
{
	struct dma_chan *chan = dmadata->dma_chan;
	struct dma_async_tx_descriptor *desc;
	struct scatterlist sg;

	sg_init_table(&sg, 1);
	sg_set_page(&sg, pfn_to_page(PFN_DOWN(buf_dma_addr)),
		    dmadata->frag_bytes, buf_dma_addr & (PAGE_SIZE - 1));
	sg_dma_address(&sg) = buf_dma_addr;
	desc = chan->device->device_prep_slave_sg(chan, &sg, 1,
		dmadata->substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
		DMA_TO_DEVICE : DMA_FROM_DEVICE,
		DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
	if (!desc) {
		dev_err(&chan->dev->device, "cannot prepare slave dma\n");
		return NULL;
	}
	desc->callback = txx9aclc_dma_complete;
	desc->callback_param = dmadata;
	desc->tx_submit(desc);
	return desc;
}

#define NR_DMA_CHAIN		2

static void txx9aclc_dma_tasklet(unsigned long data)
{
	struct txx9aclc_dmadata *dmadata = (struct txx9aclc_dmadata *)data;
	struct dma_chan *chan = dmadata->dma_chan;
	struct dma_async_tx_descriptor *desc;
	struct snd_pcm_substream *substream = dmadata->substream;
	u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
		ACCTL_AUDODMA : ACCTL_AUDIDMA;
	int i;
	unsigned long flags;

	spin_lock_irqsave(&dmadata->dma_lock, flags);
	if (dmadata->frag_count < 0) {
		struct txx9aclc_soc_device *dev =
			container_of(dmadata, struct txx9aclc_soc_device,
				     dmadata[substream->stream]);
		struct txx9aclc_plat_drvdata *drvdata =
			txx9aclc_get_plat_drvdata(dev);
		void __iomem *base = drvdata->base;

		spin_unlock_irqrestore(&dmadata->dma_lock, flags);
		chan->device->device_terminate_all(chan);
		/* first time */
		for (i = 0; i < NR_DMA_CHAIN; i++) {
			desc = txx9aclc_dma_submit(dmadata,
				dmadata->dma_addr + i * dmadata->frag_bytes);
			if (!desc)
				return;
		}
		dmadata->dmacount = NR_DMA_CHAIN;
		chan->device->device_issue_pending(chan);
		spin_lock_irqsave(&dmadata->dma_lock, flags);
		__raw_writel(ctlbit, base + ACCTLEN);
		dmadata->frag_count = NR_DMA_CHAIN % dmadata->frags;
		spin_unlock_irqrestore(&dmadata->dma_lock, flags);
		return;
	}
	BUG_ON(dmadata->dmacount >= NR_DMA_CHAIN);
	while (dmadata->dmacount < NR_DMA_CHAIN) {
		dmadata->dmacount++;
		spin_unlock_irqrestore(&dmadata->dma_lock, flags);
		desc = txx9aclc_dma_submit(dmadata,
			dmadata->dma_addr +
			dmadata->frag_count * dmadata->frag_bytes);
		if (!desc)
			return;
		chan->device->device_issue_pending(chan);

		spin_lock_irqsave(&dmadata->dma_lock, flags);
		dmadata->frag_count++;
		dmadata->frag_count %= dmadata->frags;
		dmadata->pos += dmadata->frag_bytes;
		dmadata->pos %= dmadata->buffer_bytes;
		if ((dmadata->frag_count * dmadata->frag_bytes) %
		    dmadata->period_bytes == 0)
			snd_pcm_period_elapsed(substream);
	}
	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
}

static int txx9aclc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct txx9aclc_soc_device *dev =
		container_of(rtd->socdev, struct txx9aclc_soc_device, soc_dev);
	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
	void __iomem *base = drvdata->base;
	unsigned long flags;
	int ret = 0;
	u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
		ACCTL_AUDODMA : ACCTL_AUDIDMA;

	spin_lock_irqsave(&dmadata->dma_lock, flags);
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		dmadata->frag_count = -1;
		tasklet_schedule(&dmadata->tasklet);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		__raw_writel(ctlbit, base + ACCTLDIS);
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	case SNDRV_PCM_TRIGGER_RESUME:
		__raw_writel(ctlbit, base + ACCTLEN);
		break;
	default:
		ret = -EINVAL;
	}
	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
	return ret;
}

static snd_pcm_uframes_t
txx9aclc_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;

	return bytes_to_frames(substream->runtime, dmadata->pos);
}

static int txx9aclc_pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct txx9aclc_soc_device *dev =
		container_of(rtd->socdev, struct txx9aclc_soc_device, soc_dev);
	struct txx9aclc_dmadata *dmadata = &dev->dmadata[substream->stream];
	int ret;

	ret = snd_soc_set_runtime_hwparams(substream, &txx9aclc_pcm_hardware);
	if (ret)
		return ret;
	/* ensure that buffer size is a multiple of period size */
	ret = snd_pcm_hw_constraint_integer(substream->runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (ret < 0)
		return ret;
	substream->runtime->private_data = dmadata;
	return 0;
}

static int txx9aclc_pcm_close(struct snd_pcm_substream *substream)
{
	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
	struct dma_chan *chan = dmadata->dma_chan;

	dmadata->frag_count = -1;
	chan->device->device_terminate_all(chan);
	return 0;
}

static struct snd_pcm_ops txx9aclc_pcm_ops = {
	.open		= txx9aclc_pcm_open,
	.close		= txx9aclc_pcm_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= txx9aclc_pcm_hw_params,
	.hw_free	= txx9aclc_pcm_hw_free,
	.prepare	= txx9aclc_pcm_prepare,
	.trigger	= txx9aclc_pcm_trigger,
	.pointer	= txx9aclc_pcm_pointer,
};

static void txx9aclc_pcm_free_dma_buffers(struct snd_pcm *pcm)
{
	snd_pcm_lib_preallocate_free_for_all(pcm);
}

static int txx9aclc_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
			    struct snd_pcm *pcm)
{
	return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
		card->dev, 64 * 1024, 4 * 1024 * 1024);
}

static bool filter(struct dma_chan *chan, void *param)
{
	struct txx9aclc_dmadata *dmadata = param;
	char *devname;
	bool found = false;

	devname = kasprintf(GFP_KERNEL, "%s.%d", dmadata->dma_res->name,
		(int)dmadata->dma_res->start);
	if (strcmp(dev_name(chan->device->dev), devname) == 0) {
		chan->private = &dmadata->dma_slave;
		found = true;
	}
	kfree(devname);
	return found;
}

static int txx9aclc_dma_init(struct txx9aclc_soc_device *dev,
			     struct txx9aclc_dmadata *dmadata)
{
	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
	struct txx9dmac_slave *ds = &dmadata->dma_slave;
	dma_cap_mask_t mask;

	spin_lock_init(&dmadata->dma_lock);

	ds->reg_width = sizeof(u32);
	if (dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		ds->tx_reg = drvdata->physbase + ACAUDODAT;
		ds->rx_reg = 0;
	} else {
		ds->tx_reg = 0;
		ds->rx_reg = drvdata->physbase + ACAUDIDAT;
	}

	/* Try to grab a DMA channel */
	dma_cap_zero(mask);
	dma_cap_set(DMA_SLAVE, mask);
	dmadata->dma_chan = dma_request_channel(mask, filter, dmadata);
	if (!dmadata->dma_chan) {
		dev_err(dev->soc_dev.dev,
			"DMA channel for %s is not available\n",
			dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK ?
			"playback" : "capture");
		return -EBUSY;
	}
	tasklet_init(&dmadata->tasklet, txx9aclc_dma_tasklet,
		     (unsigned long)dmadata);
	return 0;
}

static int txx9aclc_pcm_probe(struct platform_device *pdev)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct txx9aclc_soc_device *dev =
		container_of(socdev, struct txx9aclc_soc_device, soc_dev);
	struct resource *r;
	int i;
	int ret;

	dev->dmadata[0].stream = SNDRV_PCM_STREAM_PLAYBACK;
	dev->dmadata[1].stream = SNDRV_PCM_STREAM_CAPTURE;
	for (i = 0; i < 2; i++) {
		r = platform_get_resource(dev->aclc_pdev, IORESOURCE_DMA, i);
		if (!r) {
			ret = -EBUSY;
			goto exit;
		}
		dev->dmadata[i].dma_res = r;
		ret = txx9aclc_dma_init(dev, &dev->dmadata[i]);
		if (ret)
			goto exit;
	}
	return 0;

exit:
	for (i = 0; i < 2; i++) {
		if (dev->dmadata[i].dma_chan)
			dma_release_channel(dev->dmadata[i].dma_chan);
		dev->dmadata[i].dma_chan = NULL;
	}
	return ret;
}

static int txx9aclc_pcm_remove(struct platform_device *pdev)
{
	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	struct txx9aclc_soc_device *dev =
		container_of(socdev, struct txx9aclc_soc_device, soc_dev);
	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
	void __iomem *base = drvdata->base;
	int i;

	/* disable all FIFO DMAs */
	__raw_writel(ACCTL_AUDODMA | ACCTL_AUDIDMA, base + ACCTLDIS);
	/* dummy R/W to clear pending DMAREQ if any */
	__raw_writel(__raw_readl(base + ACAUDIDAT), base + ACAUDODAT);

	for (i = 0; i < 2; i++) {
		struct txx9aclc_dmadata *dmadata = &dev->dmadata[i];
		struct dma_chan *chan = dmadata->dma_chan;
		if (chan) {
			dmadata->frag_count = -1;
			chan->device->device_terminate_all(chan);
			dma_release_channel(chan);
		}
		dev->dmadata[i].dma_chan = NULL;
	}
	return 0;
}

struct snd_soc_platform txx9aclc_soc_platform = {
	.name		= "txx9aclc-audio",
	.probe		= txx9aclc_pcm_probe,
	.remove		= txx9aclc_pcm_remove,
	.pcm_ops 	= &txx9aclc_pcm_ops,
	.pcm_new	= txx9aclc_pcm_new,
	.pcm_free	= txx9aclc_pcm_free_dma_buffers,
};
EXPORT_SYMBOL_GPL(txx9aclc_soc_platform);

static int __init txx9aclc_soc_platform_init(void)
{
	return snd_soc_register_platform(&txx9aclc_soc_platform);
}

static void __exit txx9aclc_soc_platform_exit(void)
{
	snd_soc_unregister_platform(&txx9aclc_soc_platform);
}

module_init(txx9aclc_soc_platform_init);
module_exit(txx9aclc_soc_platform_exit);

MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
MODULE_DESCRIPTION("TXx9 ACLC Audio DMA driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
e24805dd AN	1	/*
	2	* Generic TXx9 ACLC platform driver
	3	*
	4	* Copyright (C) 2009 Atsushi Nemoto
	5	*
	6	* Based on RBTX49xx patch from CELF patch archive.
	7	* (C) Copyright TOSHIBA CORPORATION 2004-2006
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License version 2 as
	11	* published by the Free Software Foundation.
	12	*/
	13
	14	#include <linux/module.h>
	15	#include <linux/init.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/scatterlist.h>
5a0e3ad6	18	#include <linux/slab.h>
e24805dd AN	19	#include <sound/core.h>
	20	#include <sound/pcm.h>
	21	#include <sound/pcm_params.h>
	22	#include <sound/soc.h>
	23	#include "txx9aclc.h"
	24
	25	static const struct snd_pcm_hardware txx9aclc_pcm_hardware = {
	26	/*
	27	* REVISIT: SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID
	28	* needs more works for noncoherent MIPS.
	29	*/
	30	.info = SNDRV_PCM_INFO_INTERLEAVED \|
	31	SNDRV_PCM_INFO_BATCH \|
	32	SNDRV_PCM_INFO_PAUSE,
	33	#ifdef __BIG_ENDIAN
	34	.formats = SNDRV_PCM_FMTBIT_S16_BE,
	35	#else
	36	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	37	#endif
	38	.period_bytes_min = 1024,
	39	.period_bytes_max = 8 * 1024,
	40	.periods_min = 2,
	41	.periods_max = 4096,
	42	.buffer_bytes_max = 32 * 1024,
	43	};
	44
	45	static int txx9aclc_pcm_hw_params(struct snd_pcm_substream *substream,
	46	struct snd_pcm_hw_params *params)
	47	{
	48	struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
	49	struct snd_soc_device *socdev = rtd->socdev;
	50	struct snd_pcm_runtime *runtime = substream->runtime;
	51	struct txx9aclc_dmadata *dmadata = runtime->private_data;
	52	int ret;
	53
	54	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	55	if (ret < 0)
	56	return ret;
	57
	58	dev_dbg(socdev->dev,
	59	"runtime->dma_area = %#lx dma_addr = %#lx dma_bytes = %zd "
	60	"runtime->min_align %ld\n",
	61	(unsigned long)runtime->dma_area,
	62	(unsigned long)runtime->dma_addr, runtime->dma_bytes,
	63	runtime->min_align);
	64	dev_dbg(socdev->dev,
	65	"periods %d period_bytes %d stream %d\n",
	66	params_periods(params), params_period_bytes(params),
	67	substream->stream);
	68
	69	dmadata->substream = substream;
	70	dmadata->pos = 0;
	71	return 0;
	72	}
	73
	74	static int txx9aclc_pcm_hw_free(struct snd_pcm_substream *substream)
	75	{
	76	return snd_pcm_lib_free_pages(substream);
	77	}
	78
	79	static int txx9aclc_pcm_prepare(struct snd_pcm_substream *substream)
	80	{
	81	struct snd_pcm_runtime *runtime = substream->runtime;
	82	struct txx9aclc_dmadata *dmadata = runtime->private_data;
83
84	dmadata->dma_addr = runtime->dma_addr;
85	dmadata->buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
86	dmadata->period_bytes = snd_pcm_lib_period_bytes(substream);
87
88	if (dmadata->buffer_bytes == dmadata->period_bytes) {
89	dmadata->frag_bytes = dmadata->period_bytes >> 1;
90	dmadata->frags = 2;
91	} else {
92	dmadata->frag_bytes = dmadata->period_bytes;
93	dmadata->frags = dmadata->buffer_bytes / dmadata->period_bytes;
94	}
95	dmadata->frag_count = 0;
96	dmadata->pos = 0;
97	return 0;
98	}
99
100	static void txx9aclc_dma_complete(void *arg)
101	{
102	struct txx9aclc_dmadata *dmadata = arg;
103	unsigned long flags;
104
105	/* dma completion handler cannot submit new operations */
106	spin_lock_irqsave(&dmadata->dma_lock, flags);
107	if (dmadata->frag_count >= 0) {
108	dmadata->dmacount--;
109	BUG_ON(dmadata->dmacount < 0);
110	tasklet_schedule(&dmadata->tasklet);
111	}
112	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
113	}
114
115	static struct dma_async_tx_descriptor *
116	txx9aclc_dma_submit(struct txx9aclc_dmadata *dmadata, dma_addr_t buf_dma_addr)
117	{
118	struct dma_chan *chan = dmadata->dma_chan;
119	struct dma_async_tx_descriptor *desc;
120	struct scatterlist sg;
121
122	sg_init_table(&sg, 1);
123	sg_set_page(&sg, pfn_to_page(PFN_DOWN(buf_dma_addr)),
124	dmadata->frag_bytes, buf_dma_addr & (PAGE_SIZE - 1));
125	sg_dma_address(&sg) = buf_dma_addr;
126	desc = chan->device->device_prep_slave_sg(chan, &sg, 1,
127	dmadata->substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
128	DMA_TO_DEVICE : DMA_FROM_DEVICE,
129	DMA_PREP_INTERRUPT \| DMA_CTRL_ACK);
130	if (!desc) {
131	dev_err(&chan->dev->device, "cannot prepare slave dma\n");
132	return NULL;
133	}
134	desc->callback = txx9aclc_dma_complete;
135	desc->callback_param = dmadata;
136	desc->tx_submit(desc);
137	return desc;
138	}
139
140	#define NR_DMA_CHAIN 2
141
142	static void txx9aclc_dma_tasklet(unsigned long data)
143	{
144	struct txx9aclc_dmadata dmadata = (struct txx9aclc_dmadata )data;
145	struct dma_chan *chan = dmadata->dma_chan;
146	struct dma_async_tx_descriptor *desc;
147	struct snd_pcm_substream *substream = dmadata->substream;
148	u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
149	ACCTL_AUDODMA : ACCTL_AUDIDMA;
150	int i;
151	unsigned long flags;
152
153	spin_lock_irqsave(&dmadata->dma_lock, flags);
154	if (dmadata->frag_count < 0) {
155	struct txx9aclc_soc_device *dev =
156	container_of(dmadata, struct txx9aclc_soc_device,
157	dmadata[substream->stream]);
158	struct txx9aclc_plat_drvdata *drvdata =
159	txx9aclc_get_plat_drvdata(dev);
160	void __iomem *base = drvdata->base;
161
162	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
163	chan->device->device_terminate_all(chan);
164	/* first time */
165	for (i = 0; i < NR_DMA_CHAIN; i++) {
166	desc = txx9aclc_dma_submit(dmadata,
167	dmadata->dma_addr + i * dmadata->frag_bytes);
168	if (!desc)
169	return;
170	}
171	dmadata->dmacount = NR_DMA_CHAIN;
172	chan->device->device_issue_pending(chan);
173	spin_lock_irqsave(&dmadata->dma_lock, flags);
174	__raw_writel(ctlbit, base + ACCTLEN);
175	dmadata->frag_count = NR_DMA_CHAIN % dmadata->frags;
176	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
177	return;
178	}
179	BUG_ON(dmadata->dmacount >= NR_DMA_CHAIN);
180	while (dmadata->dmacount < NR_DMA_CHAIN) {
181	dmadata->dmacount++;
182	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
183	desc = txx9aclc_dma_submit(dmadata,
184	dmadata->dma_addr +
185	dmadata->frag_count * dmadata->frag_bytes);
186	if (!desc)
187	return;
188	chan->device->device_issue_pending(chan);
189
190	spin_lock_irqsave(&dmadata->dma_lock, flags);
191	dmadata->frag_count++;
192	dmadata->frag_count %= dmadata->frags;
193	dmadata->pos += dmadata->frag_bytes;
194	dmadata->pos %= dmadata->buffer_bytes;
195	if ((dmadata->frag_count * dmadata->frag_bytes) %
196	dmadata->period_bytes == 0)
197	snd_pcm_period_elapsed(substream);
198	}
199	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
200	}
201
202	static int txx9aclc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
203	{
204	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
205	struct snd_soc_pcm_runtime *rtd = substream->private_data;
206	struct txx9aclc_soc_device *dev =
207	container_of(rtd->socdev, struct txx9aclc_soc_device, soc_dev);
208	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
209	void __iomem *base = drvdata->base;
210	unsigned long flags;
211	int ret = 0;
212	u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
213	ACCTL_AUDODMA : ACCTL_AUDIDMA;
214
215	spin_lock_irqsave(&dmadata->dma_lock, flags);
216	switch (cmd) {
217	case SNDRV_PCM_TRIGGER_START:
218	dmadata->frag_count = -1;
219	tasklet_schedule(&dmadata->tasklet);
220	break;
221	case SNDRV_PCM_TRIGGER_STOP:
222	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
223	case SNDRV_PCM_TRIGGER_SUSPEND:
224	__raw_writel(ctlbit, base + ACCTLDIS);
225	break;
226	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
227	case SNDRV_PCM_TRIGGER_RESUME:
228	__raw_writel(ctlbit, base + ACCTLEN);
229	break;
230	default:
231	ret = -EINVAL;
232	}
233	spin_unlock_irqrestore(&dmadata->dma_lock, flags);
234	return ret;
235	}
236
237	static snd_pcm_uframes_t
238	txx9aclc_pcm_pointer(struct snd_pcm_substream *substream)
239	{
240	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
241
242	return bytes_to_frames(substream->runtime, dmadata->pos);
243	}
244
245	static int txx9aclc_pcm_open(struct snd_pcm_substream *substream)
246	{
247	struct snd_soc_pcm_runtime *rtd = substream->private_data;
248	struct txx9aclc_soc_device *dev =
249	container_of(rtd->socdev, struct txx9aclc_soc_device, soc_dev);
250	struct txx9aclc_dmadata *dmadata = &dev->dmadata[substream->stream];
251	int ret;
252
253	ret = snd_soc_set_runtime_hwparams(substream, &txx9aclc_pcm_hardware);
254	if (ret)
255	return ret;
256	/* ensure that buffer size is a multiple of period size */
257	ret = snd_pcm_hw_constraint_integer(substream->runtime,
258	SNDRV_PCM_HW_PARAM_PERIODS);
259	if (ret < 0)
260	return ret;
261	substream->runtime->private_data = dmadata;
262	return 0;
263	}
264
265	static int txx9aclc_pcm_close(struct snd_pcm_substream *substream)
266	{
267	struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
268	struct dma_chan *chan = dmadata->dma_chan;
269
270	dmadata->frag_count = -1;
271	chan->device->device_terminate_all(chan);
272	return 0;
273	}
274
275	static struct snd_pcm_ops txx9aclc_pcm_ops = {
276	.open = txx9aclc_pcm_open,
277	.close = txx9aclc_pcm_close,
278	.ioctl = snd_pcm_lib_ioctl,
279	.hw_params = txx9aclc_pcm_hw_params,
280	.hw_free = txx9aclc_pcm_hw_free,
281	.prepare = txx9aclc_pcm_prepare,
282	.trigger = txx9aclc_pcm_trigger,
283	.pointer = txx9aclc_pcm_pointer,
284	};
285
286	static void txx9aclc_pcm_free_dma_buffers(struct snd_pcm *pcm)
287	{
288	snd_pcm_lib_preallocate_free_for_all(pcm);
289	}
290
291	static int txx9aclc_pcm_new(struct snd_card card, struct snd_soc_dai dai,
292	struct snd_pcm *pcm)
293	{
294	return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
295	card->dev, 64 * 1024, 4 * 1024 * 1024);
296	}
297
298	static bool filter(struct dma_chan chan, void param)
299	{
300	struct txx9aclc_dmadata *dmadata = param;
647613e9 AN	301	char *devname;
647613e9 AN	302	bool found = false;
e24805dd	303
647613e9	304	devname = kasprintf(GFP_KERNEL, "%s.%d", dmadata->dma_res->name,
e24805dd AN	305	(int)dmadata->dma_res->start);
	306	if (strcmp(dev_name(chan->device->dev), devname) == 0) {
	307	chan->private = &dmadata->dma_slave;
647613e9	308	found = true;
e24805dd	309	}
647613e9 AN	310	kfree(devname);
647613e9 AN	311	return found;
e24805dd AN	312	}
	313
	314	static int txx9aclc_dma_init(struct txx9aclc_soc_device *dev,
	315	struct txx9aclc_dmadata *dmadata)
	316	{
	317	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
	318	struct txx9dmac_slave *ds = &dmadata->dma_slave;
	319	dma_cap_mask_t mask;
	320
	321	spin_lock_init(&dmadata->dma_lock);
	322
	323	ds->reg_width = sizeof(u32);
	324	if (dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	325	ds->tx_reg = drvdata->physbase + ACAUDODAT;
	326	ds->rx_reg = 0;
	327	} else {
	328	ds->tx_reg = 0;
	329	ds->rx_reg = drvdata->physbase + ACAUDIDAT;
	330	}
	331
	332	/* Try to grab a DMA channel */
	333	dma_cap_zero(mask);
	334	dma_cap_set(DMA_SLAVE, mask);
	335	dmadata->dma_chan = dma_request_channel(mask, filter, dmadata);
	336	if (!dmadata->dma_chan) {
	337	dev_err(dev->soc_dev.dev,
	338	"DMA channel for %s is not available\n",
	339	dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK ?
	340	"playback" : "capture");
	341	return -EBUSY;
	342	}
	343	tasklet_init(&dmadata->tasklet, txx9aclc_dma_tasklet,
	344	(unsigned long)dmadata);
	345	return 0;
	346	}
	347
	348	static int txx9aclc_pcm_probe(struct platform_device *pdev)
	349	{
	350	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	351	struct txx9aclc_soc_device *dev =
	352	container_of(socdev, struct txx9aclc_soc_device, soc_dev);
	353	struct resource *r;
	354	int i;
	355	int ret;
	356
	357	dev->dmadata[0].stream = SNDRV_PCM_STREAM_PLAYBACK;
	358	dev->dmadata[1].stream = SNDRV_PCM_STREAM_CAPTURE;
	359	for (i = 0; i < 2; i++) {
	360	r = platform_get_resource(dev->aclc_pdev, IORESOURCE_DMA, i);
	361	if (!r) {
	362	ret = -EBUSY;
	363	goto exit;
	364	}
	365	dev->dmadata[i].dma_res = r;
	366	ret = txx9aclc_dma_init(dev, &dev->dmadata[i]);
	367	if (ret)
	368	goto exit;
	369	}
	370	return 0;
	371
	372	exit:
	373	for (i = 0; i < 2; i++) {
	374	if (dev->dmadata[i].dma_chan)
	375	dma_release_channel(dev->dmadata[i].dma_chan);
376	dev->dmadata[i].dma_chan = NULL;
377	}
378	return ret;
379	}
380
381	static int txx9aclc_pcm_remove(struct platform_device *pdev)
382	{
383	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
384	struct txx9aclc_soc_device *dev =
385	container_of(socdev, struct txx9aclc_soc_device, soc_dev);
386	struct txx9aclc_plat_drvdata *drvdata = txx9aclc_get_plat_drvdata(dev);
387	void __iomem *base = drvdata->base;
388	int i;
389
390	/* disable all FIFO DMAs */
391	__raw_writel(ACCTL_AUDODMA \| ACCTL_AUDIDMA, base + ACCTLDIS);
392	/* dummy R/W to clear pending DMAREQ if any */
393	__raw_writel(__raw_readl(base + ACAUDIDAT), base + ACAUDODAT);
394
395	for (i = 0; i < 2; i++) {
396	struct txx9aclc_dmadata *dmadata = &dev->dmadata[i];
397	struct dma_chan *chan = dmadata->dma_chan;
398	if (chan) {
399	dmadata->frag_count = -1;
400	chan->device->device_terminate_all(chan);
401	dma_release_channel(chan);
402	}
403	dev->dmadata[i].dma_chan = NULL;
404	}
405	return 0;
406	}
407
408	struct snd_soc_platform txx9aclc_soc_platform = {
409	.name = "txx9aclc-audio",
410	.probe = txx9aclc_pcm_probe,
411	.remove = txx9aclc_pcm_remove,
412	.pcm_ops = &txx9aclc_pcm_ops,
413	.pcm_new = txx9aclc_pcm_new,
414	.pcm_free = txx9aclc_pcm_free_dma_buffers,
415	};
416	EXPORT_SYMBOL_GPL(txx9aclc_soc_platform);
417
418	static int __init txx9aclc_soc_platform_init(void)
419	{
420	return snd_soc_register_platform(&txx9aclc_soc_platform);
421	}
422
423	static void __exit txx9aclc_soc_platform_exit(void)
424	{
425	snd_soc_unregister_platform(&txx9aclc_soc_platform);
426	}
427
428	module_init(txx9aclc_soc_platform_init);
429	module_exit(txx9aclc_soc_platform_exit);
430
431	MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
432	MODULE_DESCRIPTION("TXx9 ACLC Audio DMA driver");
433	MODULE_LICENSE("GPL");