[GitHub/mt8127/android_kernel_alcatel_ttab.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),
	.formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE),
	.rates = (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_5512 | \
		  SNDRV_PCM_RATE_8000_192000),
	.rate_min = 0,
	.rate_max = 1562500,
	.channels_min = 2,
	.channels_max = 8,
	.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;
	}

	BUG_ON(period_size & 15);
	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_stop(substream, SNDRV_PCM_STATE_XRUN);
			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 u64 s6000_pcm_dmamask = DMA_BIT_MASK(32);

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

	if (!card->dev->dma_mask)
		card->dev->dma_mask = &s6000_pcm_dmamask;
	if (!card->dev->coherent_dma_mask)
		card->dev->coherent_dma_mask = DMA_BIT_MASK(32);

	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 __devinit s6000_soc_platform_probe(struct platform_device *pdev)
{
	return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
}

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