imx-pcm-fiq.c 7.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * imx-pcm-fiq.c  --  ALSA Soc Audio Layer
 *
 * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
 *
 * This code is based on code copyrighted by Freescale,
 * Liam Girdwood, Javier Martin and probably others.
 *
 *  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/clk.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/platform_device.h>
22
#include <linux/slab.h>
23 24 25 26 27 28 29 30 31

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

#include <asm/fiq.h>

32
#include <mach/irqs.h>
33 34 35 36 37 38 39 40
#include <mach/ssi.h>

#include "imx-ssi.h"

struct imx_pcm_runtime_data {
	int period;
	int periods;
	unsigned long offset;
41
	unsigned long last_offset;
42
	unsigned long size;
43 44 45
	struct hrtimer hrt;
	int poll_time_ns;
	struct snd_pcm_substream *substream;
46
	atomic_t running;
47 48
};

49
static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
50
{
51 52 53
	struct imx_pcm_runtime_data *iprtd =
		container_of(hrt, struct imx_pcm_runtime_data, hrt);
	struct snd_pcm_substream *substream = iprtd->substream;
54 55
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct pt_regs regs;
56
	unsigned long delta;
57

58 59 60
	if (!atomic_read(&iprtd->running))
		return HRTIMER_NORESTART;

61 62 63 64 65 66 67
	get_fiq_regs(&regs);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		iprtd->offset = regs.ARM_r8 & 0xffff;
	else
		iprtd->offset = regs.ARM_r9 & 0xffff;

68 69 70 71 72 73 74 75 76
	/* How much data have we transferred since the last period report? */
	if (iprtd->offset >= iprtd->last_offset)
		delta = iprtd->offset - iprtd->last_offset;
	else
		delta = runtime->buffer_size + iprtd->offset
			- iprtd->last_offset;

	/* If we've transferred at least a period then report it and
	 * reset our poll time */
77
	if (delta >= iprtd->period) {
78 79 80 81
		snd_pcm_period_elapsed(substream);
		iprtd->last_offset = iprtd->offset;
	}

82
	hrtimer_forward_now(hrt, ns_to_ktime(iprtd->poll_time_ns));
83

84
	return HRTIMER_RESTART;
85 86 87 88 89 90 91 92 93 94 95 96 97 98
}

static struct fiq_handler fh = {
	.name		= DRV_NAME,
};

static int snd_imx_pcm_hw_params(struct snd_pcm_substream *substream,
				struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd = runtime->private_data;

	iprtd->size = params_buffer_bytes(params);
	iprtd->periods = params_periods(params);
99
	iprtd->period = params_period_bytes(params) ;
100
	iprtd->offset = 0;
101
	iprtd->last_offset = 0;
102 103
	iprtd->poll_time_ns = 1000000000 / params_rate(params) *
				params_period_size(params);
104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);

	return 0;
}

static int snd_imx_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd = runtime->private_data;
	struct pt_regs regs;

	get_fiq_regs(&regs);
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		regs.ARM_r8 = (iprtd->period * iprtd->periods - 1) << 16;
	else
		regs.ARM_r9 = (iprtd->period * iprtd->periods - 1) << 16;

	set_fiq_regs(&regs);

	return 0;
}

static int fiq_enable;
static int imx_pcm_fiq;

static int snd_imx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd = runtime->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
138
		atomic_set(&iprtd->running, 1);
139 140
		hrtimer_start(&iprtd->hrt, ns_to_ktime(iprtd->poll_time_ns),
		      HRTIMER_MODE_REL);
141 142 143 144 145 146 147 148
		if (++fiq_enable == 1)
			enable_fiq(imx_pcm_fiq);

		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
149 150
		atomic_set(&iprtd->running, 0);

151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
		if (--fiq_enable == 0)
			disable_fiq(imx_pcm_fiq);

		break;
	default:
		return -EINVAL;
	}

	return 0;
}

static snd_pcm_uframes_t snd_imx_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd = runtime->private_data;

	return bytes_to_frames(substream->runtime, iprtd->offset);
}

static struct snd_pcm_hardware snd_imx_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_RESUME,
	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	.rate_min = 8000,
	.channels_min = 2,
	.channels_max = 2,
	.buffer_bytes_max = IMX_SSI_DMABUF_SIZE,
	.period_bytes_min = 128,
	.period_bytes_max = 16 * 1024,
184
	.periods_min = 4,
185 186 187 188 189 190 191 192 193 194 195
	.periods_max = 255,
	.fifo_size = 0,
};

static int snd_imx_open(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd;
	int ret;

	iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
196 197
	if (iprtd == NULL)
		return -ENOMEM;
198 199
	runtime->private_data = iprtd;

200 201
	iprtd->substream = substream;

202
	atomic_set(&iprtd->running, 0);
203 204
	hrtimer_init(&iprtd->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	iprtd->hrt.function = snd_hrtimer_callback;
205 206 207

	ret = snd_pcm_hw_constraint_integer(substream->runtime,
			SNDRV_PCM_HW_PARAM_PERIODS);
208 209
	if (ret < 0) {
		kfree(iprtd);
210
		return ret;
211
	}
212 213 214 215 216 217 218 219 220 221

	snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
	return 0;
}

static int snd_imx_close(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct imx_pcm_runtime_data *iprtd = runtime->private_data;

222 223
	hrtimer_cancel(&iprtd->hrt);

224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
	kfree(iprtd);

	return 0;
}

static struct snd_pcm_ops imx_pcm_ops = {
	.open		= snd_imx_open,
	.close		= snd_imx_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= snd_imx_pcm_hw_params,
	.prepare	= snd_imx_pcm_prepare,
	.trigger	= snd_imx_pcm_trigger,
	.pointer	= snd_imx_pcm_pointer,
	.mmap		= snd_imx_pcm_mmap,
};

240 241
static int ssi_irq = 0;

242
static int imx_pcm_fiq_new(struct snd_soc_pcm_runtime *rtd)
243
{
244
	struct snd_pcm *pcm = rtd->pcm;
245
	struct snd_pcm_substream *substream;
246 247
	int ret;

248
	ret = imx_pcm_new(rtd);
249 250 251
	if (ret)
		return ret;

252 253
	substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
	if (substream) {
254 255 256 257 258
		struct snd_dma_buffer *buf = &substream->dma_buffer;

		imx_ssi_fiq_tx_buffer = (unsigned long)buf->area;
	}

259 260
	substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
	if (substream) {
261 262 263 264 265 266 267 268 269 270 271
		struct snd_dma_buffer *buf = &substream->dma_buffer;

		imx_ssi_fiq_rx_buffer = (unsigned long)buf->area;
	}

	set_fiq_handler(&imx_ssi_fiq_start,
		&imx_ssi_fiq_end - &imx_ssi_fiq_start);

	return 0;
}

272 273 274 275 276 277 278 279 280
static void imx_pcm_fiq_free(struct snd_pcm *pcm)
{
	mxc_set_irq_fiq(ssi_irq, 0);
	release_fiq(&fh);
	imx_pcm_free(pcm);
}

static struct snd_soc_platform_driver imx_soc_platform_fiq = {
	.ops		= &imx_pcm_ops,
281
	.pcm_new	= imx_pcm_fiq_new,
282
	.pcm_free	= imx_pcm_fiq_free,
283 284
};

285
static int __devinit imx_soc_platform_probe(struct platform_device *pdev)
286
{
287 288
	struct imx_ssi *ssi = platform_get_drvdata(pdev);
	int ret;
289 290 291 292

	ret = claim_fiq(&fh);
	if (ret) {
		dev_err(&pdev->dev, "failed to claim fiq: %d", ret);
293
		return ret;
294 295 296
	}

	mxc_set_irq_fiq(ssi->irq, 1);
297
	ssi_irq = ssi->irq;
298 299 300 301 302 303 304 305

	imx_pcm_fiq = ssi->irq;

	imx_ssi_fiq_base = (unsigned long)ssi->base;

	ssi->dma_params_tx.burstsize = 4;
	ssi->dma_params_rx.burstsize = 6;

306 307 308 309 310 311 312 313 314 315 316
	ret = snd_soc_register_platform(&pdev->dev, &imx_soc_platform_fiq);
	if (ret)
		goto failed_register;

	return 0;

failed_register:
	mxc_set_irq_fiq(ssi_irq, 0);
	release_fiq(&fh);

	return ret;
317 318
}

319
static int __devexit imx_soc_platform_remove(struct platform_device *pdev)
320
{
321 322
	snd_soc_unregister_platform(&pdev->dev);
	return 0;
323 324
}

325 326 327 328 329 330 331 332 333 334
static struct platform_driver imx_pcm_driver = {
	.driver = {
			.name = "imx-fiq-pcm-audio",
			.owner = THIS_MODULE,
	},

	.probe = imx_soc_platform_probe,
	.remove = __devexit_p(imx_soc_platform_remove),
};

335
module_platform_driver(imx_pcm_driver);
336 337

MODULE_LICENSE("GPL");