[mirror_ubuntu-artful-kernel.git] / sound / soc / s6000 / s6000-pcm.c

/*
 * ALSA PCM interface for the Stetch s6000 family
 *
 * Author:      Daniel Gloeckner, <dg@emlix.com>
 * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
 *
 * 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/slab.h>
#include <linux/dma-mapping.h>
#include <linux/interrupt.h>

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>

#include <asm/dma.h>
#include <variant/dmac.h>

#include "s6000-pcm.h"

#define S6_PCM_PREALLOCATE_SIZE (96 * 1024)
#define S6_PCM_PREALLOCATE_MAX  (2048 * 1024)

static struct snd_pcm_hardware s6000_pcm_hardware = {
	.info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
		 SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
		 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_JOINT_DUPLEX),
	.buffer_bytes_max = 0x7ffffff0,
	.period_bytes_min = 16,
	.period_bytes_max = 0xfffff0,
	.periods_min = 2,
	.periods_max = 1024, /* no limit */
	.fifo_size = 0,
};

struct s6000_runtime_data {
	spinlock_t lock;
	int period;		/* current DMA period */
};

static void s6000_pcm_enqueue_dma(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct s6000_runtime_data *prtd = runtime->private_data;
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	int channel;
	unsigned int period_size;
	unsigned int dma_offset;
	dma_addr_t dma_pos;
	dma_addr_t src, dst;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	period_size = snd_pcm_lib_period_bytes(substream);
	dma_offset = prtd->period * period_size;
	dma_pos = runtime->dma_addr + dma_offset;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		src = dma_pos;
		dst = par->sif_out;
		channel = par->dma_out;
	} else {
		src = par->sif_in;
		dst = dma_pos;
		channel = par->dma_in;
	}

	if (!s6dmac_channel_enabled(DMA_MASK_DMAC(channel),
				    DMA_INDEX_CHNL(channel)))
		return;

	if (s6dmac_fifo_full(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel))) {
		printk(KERN_ERR "s6000-pcm: fifo full\n");
		return;
	}

	if (WARN_ON(period_size & 15))
		return;
	s6dmac_put_fifo(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel),
			src, dst, period_size);

	prtd->period++;
	if (unlikely(prtd->period >= runtime->periods))
		prtd->period = 0;
}

static irqreturn_t s6000_pcm_irq(int irq, void *data)
{
	struct snd_pcm *pcm = data;
	struct snd_soc_pcm_runtime *runtime = pcm->private_data;
	struct s6000_runtime_data *prtd;
	unsigned int has_xrun;
	int i, ret = IRQ_NONE;

	for (i = 0; i < 2; ++i) {
		struct snd_pcm_substream *substream = pcm->streams[i].substream;
		struct s6000_pcm_dma_params *params =
					snd_soc_dai_get_dma_data(runtime->cpu_dai, substream);
		u32 channel;
		unsigned int pending;

		if (substream == SNDRV_PCM_STREAM_PLAYBACK)
			channel = params->dma_out;
		else
			channel = params->dma_in;

		has_xrun = params->check_xrun(runtime->cpu_dai);

		if (!channel)
			continue;

		if (unlikely(has_xrun & (1 << i)) &&
		    substream->runtime &&
		    snd_pcm_running(substream)) {
			dev_dbg(pcm->dev, "xrun\n");
			snd_pcm_stream_lock(substream);
			snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
			snd_pcm_stream_unlock(substream);
			ret = IRQ_HANDLED;
		}

		pending = s6dmac_int_sources(DMA_MASK_DMAC(channel),
					     DMA_INDEX_CHNL(channel));

		if (pending & 1) {
			ret = IRQ_HANDLED;
			if (likely(substream->runtime &&
				   snd_pcm_running(substream))) {
				snd_pcm_period_elapsed(substream);
				dev_dbg(pcm->dev, "period elapsed %x %x\n",
				       s6dmac_cur_src(DMA_MASK_DMAC(channel),
						   DMA_INDEX_CHNL(channel)),
				       s6dmac_cur_dst(DMA_MASK_DMAC(channel),
						   DMA_INDEX_CHNL(channel)));
				prtd = substream->runtime->private_data;
				spin_lock(&prtd->lock);
				s6000_pcm_enqueue_dma(substream);
				spin_unlock(&prtd->lock);
			}
		}

		if (unlikely(pending & ~7)) {
			if (pending & (1 << 3))
				printk(KERN_WARNING
				       "s6000-pcm: DMA %x Underflow\n",
				       channel);
			if (pending & (1 << 4))
				printk(KERN_WARNING
				       "s6000-pcm: DMA %x Overflow\n",
				       channel);
			if (pending & 0x1e0)
				printk(KERN_WARNING
				       "s6000-pcm: DMA %x Master Error "
				       "(mask %x)\n",
				       channel, pending >> 5);

		}
	}

	return ret;
}

static int s6000_pcm_start(struct snd_pcm_substream *substream)
{
	struct s6000_runtime_data *prtd = substream->runtime->private_data;
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	unsigned long flags;
	int srcinc;
	u32 dma;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	spin_lock_irqsave(&prtd->lock, flags);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		srcinc = 1;
		dma = par->dma_out;
	} else {
		srcinc = 0;
		dma = par->dma_in;
	}
	s6dmac_enable_chan(DMA_MASK_DMAC(dma), DMA_INDEX_CHNL(dma),
			   1 /* priority 1 (0 is max) */,
			   0 /* peripheral requests w/o xfer length mode */,
			   srcinc /* source address increment */,
			   srcinc^1 /* destination address increment */,
			   0 /* chunksize 0 (skip impossible on this dma) */,
			   0 /* source skip after chunk (impossible) */,
			   0 /* destination skip after chunk (impossible) */,
			   4 /* 16 byte burst size */,
			   -1 /* don't conserve bandwidth */,
			   0 /* low watermark irq descriptor threshold */,
			   0 /* disable hardware timestamps */,
			   1 /* enable channel */);

	s6000_pcm_enqueue_dma(substream);
	s6000_pcm_enqueue_dma(substream);

	spin_unlock_irqrestore(&prtd->lock, flags);

	return 0;
}

static int s6000_pcm_stop(struct snd_pcm_substream *substream)
{
	struct s6000_runtime_data *prtd = substream->runtime->private_data;
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	unsigned long flags;
	u32 channel;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		channel = par->dma_out;
	else
		channel = par->dma_in;

	s6dmac_set_terminal_count(DMA_MASK_DMAC(channel),
				  DMA_INDEX_CHNL(channel), 0);

	spin_lock_irqsave(&prtd->lock, flags);

	s6dmac_disable_chan(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel));

	spin_unlock_irqrestore(&prtd->lock, flags);

	return 0;
}

static int s6000_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	int ret;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	ret = par->trigger(substream, cmd, 0);
	if (ret < 0)
		return ret;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		ret = s6000_pcm_start(substream);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		ret = s6000_pcm_stop(substream);
		break;
	default:
		ret = -EINVAL;
	}
	if (ret < 0)
		return ret;

	return par->trigger(substream, cmd, 1);
}

static int s6000_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct s6000_runtime_data *prtd = substream->runtime->private_data;

	prtd->period = 0;

	return 0;
}

static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct s6000_runtime_data *prtd = runtime->private_data;
	unsigned long flags;
	unsigned int offset;
	dma_addr_t count;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	spin_lock_irqsave(&prtd->lock, flags);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		count = s6dmac_cur_src(DMA_MASK_DMAC(par->dma_out),
				       DMA_INDEX_CHNL(par->dma_out));
	else
		count = s6dmac_cur_dst(DMA_MASK_DMAC(par->dma_in),
				       DMA_INDEX_CHNL(par->dma_in));

	count -= runtime->dma_addr;

	spin_unlock_irqrestore(&prtd->lock, flags);

	offset = bytes_to_frames(runtime, count);
	if (unlikely(offset >= runtime->buffer_size))
		offset = 0;

	return offset;
}

static int s6000_pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct s6000_runtime_data *prtd;
	int ret;

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
	snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);

	ret = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 16);
	if (ret < 0)
		return ret;
	ret = snd_pcm_hw_constraint_step(runtime, 0,
					 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
	if (ret < 0)
		return ret;
	ret = snd_pcm_hw_constraint_integer(runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (ret < 0)
		return ret;

	if (par->same_rate) {
		int rate;
		spin_lock(&par->lock); /* needed? */
		rate = par->rate;
		spin_unlock(&par->lock);
		if (rate != -1) {
			ret = snd_pcm_hw_constraint_minmax(runtime,
							SNDRV_PCM_HW_PARAM_RATE,
							rate, rate);
			if (ret < 0)
				return ret;
		}
	}

	prtd = kzalloc(sizeof(struct s6000_runtime_data), GFP_KERNEL);
	if (prtd == NULL)
		return -ENOMEM;

	spin_lock_init(&prtd->lock);

	runtime->private_data = prtd;

	return 0;
}

static int s6000_pcm_close(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct s6000_runtime_data *prtd = runtime->private_data;

	kfree(prtd);

	return 0;
}

static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
				 struct snd_pcm_hw_params *hw_params)
{
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par;
	int ret;
	ret = snd_pcm_lib_malloc_pages(substream,
				       params_buffer_bytes(hw_params));
	if (ret < 0) {
		printk(KERN_WARNING "s6000-pcm: allocation of memory failed\n");
		return ret;
	}

	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	if (par->same_rate) {
		spin_lock(&par->lock);
		if (par->rate == -1 ||
		    !(par->in_use & ~(1 << substream->stream))) {
			par->rate = params_rate(hw_params);
			par->in_use |= 1 << substream->stream;
		} else if (params_rate(hw_params) != par->rate) {
			snd_pcm_lib_free_pages(substream);
			par->in_use &= ~(1 << substream->stream);
			ret = -EBUSY;
		}
		spin_unlock(&par->lock);
	}
	return ret;
}

static int s6000_pcm_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
	struct s6000_pcm_dma_params *par =
		snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);

	spin_lock(&par->lock);
	par->in_use &= ~(1 << substream->stream);
	if (!par->in_use)
		par->rate = -1;
	spin_unlock(&par->lock);

	return snd_pcm_lib_free_pages(substream);
}

static struct snd_pcm_ops s6000_pcm_ops = {
	.open = 	s6000_pcm_open,
	.close = 	s6000_pcm_close,
	.ioctl = 	snd_pcm_lib_ioctl,
	.hw_params = 	s6000_pcm_hw_params,
	.hw_free = 	s6000_pcm_hw_free,
	.trigger =	s6000_pcm_trigger,
	.prepare = 	s6000_pcm_prepare,
	.pointer = 	s6000_pcm_pointer,
};

static void s6000_pcm_free(struct snd_pcm *pcm)
{
	struct snd_soc_pcm_runtime *runtime = pcm->private_data;
	struct s6000_pcm_dma_params *params =
		snd_soc_dai_get_dma_data(runtime->cpu_dai,
			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);

	free_irq(params->irq, pcm);
	snd_pcm_lib_preallocate_free_for_all(pcm);
}

static int s6000_pcm_new(struct snd_soc_pcm_runtime *runtime)
{
	struct snd_card *card = runtime->card->snd_card;
	struct snd_pcm *pcm = runtime->pcm;
	struct s6000_pcm_dma_params *params;
	int res;

	params = snd_soc_dai_get_dma_data(runtime->cpu_dai,
			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);

	res = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
	if (res)
		return res;

	if (params->dma_in) {
		s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_in),
				    DMA_INDEX_CHNL(params->dma_in));
		s6dmac_int_sources(DMA_MASK_DMAC(params->dma_in),
				   DMA_INDEX_CHNL(params->dma_in));
	}

	if (params->dma_out) {
		s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_out),
				    DMA_INDEX_CHNL(params->dma_out));
		s6dmac_int_sources(DMA_MASK_DMAC(params->dma_out),
				   DMA_INDEX_CHNL(params->dma_out));
	}

	res = request_irq(params->irq, s6000_pcm_irq, IRQF_SHARED,
			  "s6000-audio", pcm);
	if (res) {
		printk(KERN_ERR "s6000-pcm couldn't get IRQ\n");
		return res;
	}

	res = snd_pcm_lib_preallocate_pages_for_all(pcm,
						    SNDRV_DMA_TYPE_DEV,
						    card->dev,
						    S6_PCM_PREALLOCATE_SIZE,
						    S6_PCM_PREALLOCATE_MAX);
	if (res)
		printk(KERN_WARNING "s6000-pcm: preallocation failed\n");

	spin_lock_init(&params->lock);
	params->in_use = 0;
	params->rate = -1;
	return 0;
}

static struct snd_soc_platform_driver s6000_soc_platform = {
	.ops =		&s6000_pcm_ops,
	.pcm_new = 	s6000_pcm_new,
	.pcm_free = 	s6000_pcm_free,
};

static int s6000_soc_platform_probe(struct platform_device *pdev)
{
	return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
}

static int s6000_soc_platform_remove(struct platform_device *pdev)
{
	snd_soc_unregister_platform(&pdev->dev);
	return 0;
}

static struct platform_driver s6000_pcm_driver = {
	.driver = {
			.name = "s6000-pcm-audio",
			.owner = THIS_MODULE,
	},

	.probe = s6000_soc_platform_probe,
	.remove = s6000_soc_platform_remove,
};

module_platform_driver(s6000_pcm_driver);

MODULE_AUTHOR("Daniel Gloeckner");
MODULE_DESCRIPTION("Stretch s6000 family PCM DMA module");
MODULE_LICENSE("GPL");
Commit	Line	Data
4b166da9 DG	1	/*
	2	* ALSA PCM interface for the Stetch s6000 family
	3	*
	4	* Author: Daniel Gloeckner, <dg@emlix.com>
	5	* Copyright: (C) 2009 emlix GmbH <info@emlix.com>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License version 2 as
	9	* published by the Free Software Foundation.
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/init.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/slab.h>
	16	#include <linux/dma-mapping.h>
	17	#include <linux/interrupt.h>
	18
	19	#include <sound/core.h>
	20	#include <sound/pcm.h>
	21	#include <sound/pcm_params.h>
	22	#include <sound/soc.h>
	23
	24	#include <asm/dma.h>
	25	#include <variant/dmac.h>
	26
	27	#include "s6000-pcm.h"
	28
	29	#define S6_PCM_PREALLOCATE_SIZE (96 * 1024)
	30	#define S6_PCM_PREALLOCATE_MAX (2048 * 1024)
	31
	32	static struct snd_pcm_hardware s6000_pcm_hardware = {
	33	.info = (SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	34	SNDRV_PCM_INFO_MMAP \| SNDRV_PCM_INFO_MMAP_VALID \|
	35	SNDRV_PCM_INFO_PAUSE \| SNDRV_PCM_INFO_JOINT_DUPLEX),
4b166da9 DG	36	.buffer_bytes_max = 0x7ffffff0,
	37	.period_bytes_min = 16,
	38	.period_bytes_max = 0xfffff0,
	39	.periods_min = 2,
	40	.periods_max = 1024, /* no limit */
	41	.fifo_size = 0,
	42	};
	43
	44	struct s6000_runtime_data {
	45	spinlock_t lock;
	46	int period; /* current DMA period */
	47	};
	48
	49	static void s6000_pcm_enqueue_dma(struct snd_pcm_substream *substream)
	50	{
	51	struct snd_pcm_runtime *runtime = substream->runtime;
	52	struct s6000_runtime_data *prtd = runtime->private_data;
	53	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	54	struct s6000_pcm_dma_params *par;
4b166da9 DG	55	int channel;
	56	unsigned int period_size;
	57	unsigned int dma_offset;
	58	dma_addr_t dma_pos;
	59	dma_addr_t src, dst;
	60
f0fba2ad	61	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	62
4b166da9 DG	63	period_size = snd_pcm_lib_period_bytes(substream);
	64	dma_offset = prtd->period * period_size;
	65	dma_pos = runtime->dma_addr + dma_offset;
	66
	67	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	68	src = dma_pos;
	69	dst = par->sif_out;
	70	channel = par->dma_out;
	71	} else {
	72	src = par->sif_in;
	73	dst = dma_pos;
	74	channel = par->dma_in;
	75	}
	76
	77	if (!s6dmac_channel_enabled(DMA_MASK_DMAC(channel),
	78	DMA_INDEX_CHNL(channel)))
	79	return;
	80
	81	if (s6dmac_fifo_full(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel))) {
	82	printk(KERN_ERR "s6000-pcm: fifo full\n");
	83	return;
	84	}
	85
4a318f1e TI	86	if (WARN_ON(period_size & 15))
4a318f1e TI	87	return;
4b166da9 DG	88	s6dmac_put_fifo(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel),
	89	src, dst, period_size);
	90
	91	prtd->period++;
	92	if (unlikely(prtd->period >= runtime->periods))
	93	prtd->period = 0;
	94	}
	95
	96	static irqreturn_t s6000_pcm_irq(int irq, void *data)
	97	{
	98	struct snd_pcm *pcm = data;
	99	struct snd_soc_pcm_runtime *runtime = pcm->private_data;
4b166da9 DG	100	struct s6000_runtime_data *prtd;
	101	unsigned int has_xrun;
	102	int i, ret = IRQ_NONE;
4b166da9	103
f0fba2ad	104	for (i = 0; i < 2; ++i) {
4b166da9	105	struct snd_pcm_substream *substream = pcm->streams[i].substream;
f0fba2ad LG	106	struct s6000_pcm_dma_params *params =
	107	snd_soc_dai_get_dma_data(runtime->cpu_dai, substream);
	108	u32 channel;
4b166da9 DG	109	unsigned int pending;
4b166da9 DG	110
f0fba2ad LG	111	if (substream == SNDRV_PCM_STREAM_PLAYBACK)
	112	channel = params->dma_out;
	113	else
	114	channel = params->dma_in;
	115
	116	has_xrun = params->check_xrun(runtime->cpu_dai);
	117
	118	if (!channel)
4b166da9 DG	119	continue;
	120
	121	if (unlikely(has_xrun & (1 << i)) &&
	122	substream->runtime &&
	123	snd_pcm_running(substream)) {
	124	dev_dbg(pcm->dev, "xrun\n");
61be2b9a	125	snd_pcm_stream_lock(substream);
4b166da9	126	snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
61be2b9a	127	snd_pcm_stream_unlock(substream);
4b166da9 DG	128	ret = IRQ_HANDLED;
	129	}
	130
f0fba2ad LG	131	pending = s6dmac_int_sources(DMA_MASK_DMAC(channel),
f0fba2ad LG	132	DMA_INDEX_CHNL(channel));
4b166da9 DG	133
	134	if (pending & 1) {
	135	ret = IRQ_HANDLED;
	136	if (likely(substream->runtime &&
	137	snd_pcm_running(substream))) {
	138	snd_pcm_period_elapsed(substream);
	139	dev_dbg(pcm->dev, "period elapsed %x %x\n",
f0fba2ad LG	140	s6dmac_cur_src(DMA_MASK_DMAC(channel),
	141	DMA_INDEX_CHNL(channel)),
	142	s6dmac_cur_dst(DMA_MASK_DMAC(channel),
	143	DMA_INDEX_CHNL(channel)));
4b166da9 DG	144	prtd = substream->runtime->private_data;
	145	spin_lock(&prtd->lock);
	146	s6000_pcm_enqueue_dma(substream);
	147	spin_unlock(&prtd->lock);
	148	}
	149	}
	150
	151	if (unlikely(pending & ~7)) {
	152	if (pending & (1 << 3))
	153	printk(KERN_WARNING
	154	"s6000-pcm: DMA %x Underflow\n",
f0fba2ad	155	channel);
4b166da9 DG	156	if (pending & (1 << 4))
	157	printk(KERN_WARNING
	158	"s6000-pcm: DMA %x Overflow\n",
f0fba2ad	159	channel);
4b166da9 DG	160	if (pending & 0x1e0)
	161	printk(KERN_WARNING
	162	"s6000-pcm: DMA %x Master Error "
	163	"(mask %x)\n",
f0fba2ad	164	channel, pending >> 5);
4b166da9 DG	165
	166	}
	167	}
	168
	169	return ret;
	170	}
	171
	172	static int s6000_pcm_start(struct snd_pcm_substream *substream)
	173	{
	174	struct s6000_runtime_data *prtd = substream->runtime->private_data;
	175	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	176	struct s6000_pcm_dma_params *par;
4b166da9 DG	177	unsigned long flags;
	178	int srcinc;
	179	u32 dma;
	180
f0fba2ad	181	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	182
4b166da9 DG	183	spin_lock_irqsave(&prtd->lock, flags);
	184
	185	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	186	srcinc = 1;
	187	dma = par->dma_out;
	188	} else {
	189	srcinc = 0;
	190	dma = par->dma_in;
	191	}
	192	s6dmac_enable_chan(DMA_MASK_DMAC(dma), DMA_INDEX_CHNL(dma),
	193	1 /* priority 1 (0 is max) */,
	194	0 /* peripheral requests w/o xfer length mode */,
	195	srcinc /* source address increment */,
	196	srcinc^1 /* destination address increment */,
	197	0 /* chunksize 0 (skip impossible on this dma) */,
	198	0 /* source skip after chunk (impossible) */,
	199	0 /* destination skip after chunk (impossible) */,
	200	4 /* 16 byte burst size */,
	201	-1 /* don't conserve bandwidth */,
af901ca1	202	0 /* low watermark irq descriptor threshold */,
4b166da9 DG	203	0 /* disable hardware timestamps */,
	204	1 /* enable channel */);
	205
	206	s6000_pcm_enqueue_dma(substream);
	207	s6000_pcm_enqueue_dma(substream);
	208
	209	spin_unlock_irqrestore(&prtd->lock, flags);
	210
	211	return 0;
	212	}
	213
	214	static int s6000_pcm_stop(struct snd_pcm_substream *substream)
	215	{
	216	struct s6000_runtime_data *prtd = substream->runtime->private_data;
	217	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	218	struct s6000_pcm_dma_params *par;
4b166da9 DG	219	unsigned long flags;
	220	u32 channel;
	221
f0fba2ad	222	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	223
4b166da9 DG	224	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	225	channel = par->dma_out;
	226	else
	227	channel = par->dma_in;
	228
	229	s6dmac_set_terminal_count(DMA_MASK_DMAC(channel),
	230	DMA_INDEX_CHNL(channel), 0);
	231
	232	spin_lock_irqsave(&prtd->lock, flags);
	233
	234	s6dmac_disable_chan(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel));
	235
	236	spin_unlock_irqrestore(&prtd->lock, flags);
	237
	238	return 0;
	239	}
	240
	241	static int s6000_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
	242	{
	243	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	244	struct s6000_pcm_dma_params *par;
4b166da9 DG	245	int ret;
4b166da9 DG	246
f0fba2ad	247	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	248
4b166da9 DG	249	ret = par->trigger(substream, cmd, 0);
	250	if (ret < 0)
	251	return ret;
	252
	253	switch (cmd) {
	254	case SNDRV_PCM_TRIGGER_START:
	255	case SNDRV_PCM_TRIGGER_RESUME:
	256	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	257	ret = s6000_pcm_start(substream);
	258	break;
	259	case SNDRV_PCM_TRIGGER_STOP:
	260	case SNDRV_PCM_TRIGGER_SUSPEND:
	261	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	262	ret = s6000_pcm_stop(substream);
	263	break;
	264	default:
	265	ret = -EINVAL;
	266	}
	267	if (ret < 0)
	268	return ret;
	269
	270	return par->trigger(substream, cmd, 1);
	271	}
	272
	273	static int s6000_pcm_prepare(struct snd_pcm_substream *substream)
	274	{
	275	struct s6000_runtime_data *prtd = substream->runtime->private_data;
	276
	277	prtd->period = 0;
	278
	279	return 0;
	280	}
	281
	282	static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
	283	{
	284	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	285	struct s6000_pcm_dma_params *par;
4b166da9 DG	286	struct snd_pcm_runtime *runtime = substream->runtime;
	287	struct s6000_runtime_data *prtd = runtime->private_data;
	288	unsigned long flags;
	289	unsigned int offset;
	290	dma_addr_t count;
	291
f0fba2ad	292	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	293
4b166da9 DG	294	spin_lock_irqsave(&prtd->lock, flags);
	295
	296	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	297	count = s6dmac_cur_src(DMA_MASK_DMAC(par->dma_out),
	298	DMA_INDEX_CHNL(par->dma_out));
	299	else
	300	count = s6dmac_cur_dst(DMA_MASK_DMAC(par->dma_in),
	301	DMA_INDEX_CHNL(par->dma_in));
	302
	303	count -= runtime->dma_addr;
	304
	305	spin_unlock_irqrestore(&prtd->lock, flags);
	306
	307	offset = bytes_to_frames(runtime, count);
	308	if (unlikely(offset >= runtime->buffer_size))
	309	offset = 0;
	310
	311	return offset;
	312	}
	313
	314	static int s6000_pcm_open(struct snd_pcm_substream *substream)
	315	{
	316	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	317	struct s6000_pcm_dma_params *par;
4b166da9 DG	318	struct snd_pcm_runtime *runtime = substream->runtime;
	319	struct s6000_runtime_data *prtd;
	320	int ret;
	321
f0fba2ad	322	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
4b166da9 DG	323	snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);
	324
	325	ret = snd_pcm_hw_constraint_step(runtime, 0,
	326	SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 16);
	327	if (ret < 0)
	328	return ret;
	329	ret = snd_pcm_hw_constraint_step(runtime, 0,
	330	SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
	331	if (ret < 0)
	332	return ret;
	333	ret = snd_pcm_hw_constraint_integer(runtime,
	334	SNDRV_PCM_HW_PARAM_PERIODS);
	335	if (ret < 0)
	336	return ret;
	337
	338	if (par->same_rate) {
	339	int rate;
	340	spin_lock(&par->lock); /* needed? */
	341	rate = par->rate;
	342	spin_unlock(&par->lock);
	343	if (rate != -1) {
	344	ret = snd_pcm_hw_constraint_minmax(runtime,
	345	SNDRV_PCM_HW_PARAM_RATE,
	346	rate, rate);
	347	if (ret < 0)
	348	return ret;
	349	}
	350	}
	351
	352	prtd = kzalloc(sizeof(struct s6000_runtime_data), GFP_KERNEL);
	353	if (prtd == NULL)
	354	return -ENOMEM;
	355
	356	spin_lock_init(&prtd->lock);
	357
	358	runtime->private_data = prtd;
	359
	360	return 0;
	361	}
	362
	363	static int s6000_pcm_close(struct snd_pcm_substream *substream)
	364	{
	365	struct snd_pcm_runtime *runtime = substream->runtime;
	366	struct s6000_runtime_data *prtd = runtime->private_data;
	367
	368	kfree(prtd);
	369
	370	return 0;
	371	}
	372
	373	static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
	374	struct snd_pcm_hw_params *hw_params)
	375	{
	376	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	377	struct s6000_pcm_dma_params *par;
4b166da9 DG	378	int ret;
	379	ret = snd_pcm_lib_malloc_pages(substream,
	380	params_buffer_bytes(hw_params));
	381	if (ret < 0) {
	382	printk(KERN_WARNING "s6000-pcm: allocation of memory failed\n");
	383	return ret;
	384	}
	385
f0fba2ad	386	par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
5f712b2b	387
4b166da9 DG	388	if (par->same_rate) {
	389	spin_lock(&par->lock);
	390	if (par->rate == -1 \|\|
	391	!(par->in_use & ~(1 << substream->stream))) {
	392	par->rate = params_rate(hw_params);
	393	par->in_use \|= 1 << substream->stream;
	394	} else if (params_rate(hw_params) != par->rate) {
	395	snd_pcm_lib_free_pages(substream);
	396	par->in_use &= ~(1 << substream->stream);
	397	ret = -EBUSY;
	398	}
	399	spin_unlock(&par->lock);
	400	}
	401	return ret;
	402	}
	403
	404	static int s6000_pcm_hw_free(struct snd_pcm_substream *substream)
	405	{
	406	struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
5f712b2b	407	struct s6000_pcm_dma_params *par =
f0fba2ad	408	snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
4b166da9 DG	409
	410	spin_lock(&par->lock);
	411	par->in_use &= ~(1 << substream->stream);
	412	if (!par->in_use)
	413	par->rate = -1;
	414	spin_unlock(&par->lock);
	415
	416	return snd_pcm_lib_free_pages(substream);
	417	}
	418
	419	static struct snd_pcm_ops s6000_pcm_ops = {
	420	.open = s6000_pcm_open,
	421	.close = s6000_pcm_close,
	422	.ioctl = snd_pcm_lib_ioctl,
	423	.hw_params = s6000_pcm_hw_params,
	424	.hw_free = s6000_pcm_hw_free,
	425	.trigger = s6000_pcm_trigger,
	426	.prepare = s6000_pcm_prepare,
	427	.pointer = s6000_pcm_pointer,
	428	};
	429
	430	static void s6000_pcm_free(struct snd_pcm *pcm)
	431	{
	432	struct snd_soc_pcm_runtime *runtime = pcm->private_data;
5f712b2b	433	struct s6000_pcm_dma_params *params =
6296914c JE	434	snd_soc_dai_get_dma_data(runtime->cpu_dai,
6296914c JE	435	pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
4b166da9 DG	436
	437	free_irq(params->irq, pcm);
	438	snd_pcm_lib_preallocate_free_for_all(pcm);
	439	}
	440
552d1ef6	441	static int s6000_pcm_new(struct snd_soc_pcm_runtime *runtime)
4b166da9	442	{
552d1ef6	443	struct snd_card *card = runtime->card->snd_card;
552d1ef6	444	struct snd_pcm *pcm = runtime->pcm;
5f712b2b	445	struct s6000_pcm_dma_params *params;
4b166da9 DG	446	int res;
4b166da9 DG	447
f0fba2ad	448	params = snd_soc_dai_get_dma_data(runtime->cpu_dai,
6296914c	449	pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
5f712b2b	450
c9bd5e69 RK	451	res = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
	452	if (res)
	453	return res;
4b166da9 DG	454
	455	if (params->dma_in) {
	456	s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_in),
	457	DMA_INDEX_CHNL(params->dma_in));
	458	s6dmac_int_sources(DMA_MASK_DMAC(params->dma_in),
	459	DMA_INDEX_CHNL(params->dma_in));
	460	}
	461
	462	if (params->dma_out) {
	463	s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_out),
	464	DMA_INDEX_CHNL(params->dma_out));
	465	s6dmac_int_sources(DMA_MASK_DMAC(params->dma_out),
	466	DMA_INDEX_CHNL(params->dma_out));
	467	}
	468
	469	res = request_irq(params->irq, s6000_pcm_irq, IRQF_SHARED,
9e4ea718	470	"s6000-audio", pcm);
4b166da9 DG	471	if (res) {
	472	printk(KERN_ERR "s6000-pcm couldn't get IRQ\n");
	473	return res;
	474	}
	475
	476	res = snd_pcm_lib_preallocate_pages_for_all(pcm,
	477	SNDRV_DMA_TYPE_DEV,
	478	card->dev,
	479	S6_PCM_PREALLOCATE_SIZE,
	480	S6_PCM_PREALLOCATE_MAX);
	481	if (res)
	482	printk(KERN_WARNING "s6000-pcm: preallocation failed\n");
	483
	484	spin_lock_init(&params->lock);
	485	params->in_use = 0;
	486	params->rate = -1;
	487	return 0;
	488	}
	489
f0fba2ad LG	490	static struct snd_soc_platform_driver s6000_soc_platform = {
f0fba2ad LG	491	.ops = &s6000_pcm_ops,
4b166da9 DG	492	.pcm_new = s6000_pcm_new,
	493	.pcm_free = s6000_pcm_free,
	494	};
4b166da9	495
9ac8a712	496	static int s6000_soc_platform_probe(struct platform_device *pdev)
f0fba2ad LG	497	{
	498	return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
	499	}
	500
9ac8a712	501	static int s6000_soc_platform_remove(struct platform_device *pdev)
f0fba2ad LG	502	{
	503	snd_soc_unregister_platform(&pdev->dev);
	504	return 0;
	505	}
	506
	507	static struct platform_driver s6000_pcm_driver = {
	508	.driver = {
	509	.name = "s6000-pcm-audio",
	510	.owner = THIS_MODULE,
	511	},
	512
	513	.probe = s6000_soc_platform_probe,
9ac8a712	514	.remove = s6000_soc_platform_remove,
f0fba2ad LG	515	};
f0fba2ad LG	516
880dd721	517	module_platform_driver(s6000_pcm_driver);
4b166da9 DG	518
	519	MODULE_AUTHOR("Daniel Gloeckner");
	520	MODULE_DESCRIPTION("Stretch s6000 family PCM DMA module");
	521	MODULE_LICENSE("GPL");