Release 4.7 sound/soc/fsl/imx-pcm-fiq.c

Directory: sound/soc/fsl
/*
 * 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>
#include <linux/slab.h>

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

#include <asm/fiq.h>

#include <linux/platform_data/asoc-imx-ssi.h>

#include "imx-ssi.h"
#include "imx-pcm.h"


struct imx_pcm_runtime_data {
	
unsigned int period;
	
int periods;
	
unsigned long offset;
	
struct hrtimer hrt;
	
int poll_time_ns;
	
struct snd_pcm_substream *substream;
	
atomic_t playing;
	
atomic_t capturing;
};



static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
{
	struct imx_pcm_runtime_data *iprtd =
		container_of(hrt, struct imx_pcm_runtime_data, hrt);
	struct snd_pcm_substream *substream = iprtd->substream;
	struct pt_regs regs;

	if (!atomic_read(&iprtd->playing) && !atomic_read(&iprtd->capturing))
		return HRTIMER_NORESTART;

	get_fiq_regs(&regs);

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

	snd_pcm_period_elapsed(substream);

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

	return HRTIMER_RESTART;
}

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 95 80.51% 3 60.00%
mark brown mark brown 13 11.02% 1 20.00%
oskar schirmer oskar schirmer 10 8.47% 1 20.00%
Total 118 100.00% 5 100.00%


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->periods = params_periods(params);
	iprtd->period = params_period_bytes(params);
	iprtd->offset = 0;
	iprtd->poll_time_ns = 1000000000 / params_rate(params) *
				params_period_size(params);
	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 87 100.00% 2 100.00%
Total 87 100.00% 2 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 93 100.00% 1 100.00%
Total 93 100.00% 1 100.00%


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:
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
			atomic_set(&iprtd->playing, 1);
		else
			atomic_set(&iprtd->capturing, 1);
		hrtimer_start(&iprtd->hrt, ns_to_ktime(iprtd->poll_time_ns),
		      HRTIMER_MODE_REL);
		enable_fiq(imx_pcm_fiq);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
			atomic_set(&iprtd->playing, 0);
		else
			atomic_set(&iprtd->capturing, 0);
		if (!atomic_read(&iprtd->playing) &&
				!atomic_read(&iprtd->capturing))
			disable_fiq(imx_pcm_fiq);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 112 65.50% 3 60.00%
oskar schirmer oskar schirmer 57 33.33% 1 20.00%
mark brown mark brown 2 1.17% 1 20.00%
Total 171 100.00% 5 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 41 100.00% 1 100.00%
Total 41 100.00% 1 100.00%


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,
	.buffer_bytes_max = IMX_SSI_DMABUF_SIZE,
	.period_bytes_min = 128,
	.period_bytes_max = 16 * 1024,
	.periods_min = 4,
	.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);
	if (iprtd == NULL)
		return -ENOMEM;
	runtime->private_data = iprtd;

	iprtd->substream = substream;

	atomic_set(&iprtd->playing, 0);
	atomic_set(&iprtd->capturing, 0);
	hrtimer_init(&iprtd->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
	iprtd->hrt.function = snd_hrtimer_callback;

	ret = snd_pcm_hw_constraint_integer(substream->runtime,
			SNDRV_PCM_HW_PARAM_PERIODS);
	if (ret < 0) {
		kfree(iprtd);
		return ret;
	}

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

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 113 80.14% 3 60.00%
vasiliy kulikov vasiliy kulikov 17 12.06% 1 20.00%
oskar schirmer oskar schirmer 11 7.80% 1 20.00%
Total 141 100.00% 5 100.00%



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;

	hrtimer_cancel(&iprtd->hrt);

	kfree(iprtd);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 45 100.00% 2 100.00%
Total 45 100.00% 2 100.00%



static int snd_imx_pcm_mmap(struct snd_pcm_substream *substream,
		struct vm_area_struct *vma)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	int ret;

	ret = dma_mmap_wc(substream->pcm->card->dev, vma, runtime->dma_area,
			  runtime->dma_addr, runtime->dma_bytes);

	pr_debug("%s: ret: %d %p %pad 0x%08zx\n", __func__, ret,
			runtime->dma_area,
			&runtime->dma_addr,
			runtime->dma_bytes);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 77 96.25% 1 25.00%
luis r. rodriguez luis r. rodriguez 1 1.25% 1 25.00%
heinrich schuchardt heinrich schuchardt 1 1.25% 1 25.00%
arnd bergmann arnd bergmann 1 1.25% 1 25.00%
Total 80 100.00% 4 100.00%


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,
};



static int imx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
{
	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	struct snd_dma_buffer *buf = &substream->dma_buffer;
	size_t size = IMX_SSI_DMABUF_SIZE;

	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	buf->dev.dev = pcm->card->dev;
	buf->private_data = NULL;
	buf->area = dma_alloc_wc(pcm->card->dev, size, &buf->addr, GFP_KERNEL);
	if (!buf->area)
		return -ENOMEM;
	buf->bytes = size;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 110 99.10% 1 50.00%
luis r. rodriguez luis r. rodriguez 1 0.90% 1 50.00%
Total 111 100.00% 2 100.00%



static int imx_pcm_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_card *card = rtd->card->snd_card;
	struct snd_pcm *pcm = rtd->pcm;
	int ret;

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

	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
		ret = imx_pcm_preallocate_dma_buffer(pcm,
			SNDRV_PCM_STREAM_PLAYBACK);
		if (ret)
			return ret;
	}

	if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
		ret = imx_pcm_preallocate_dma_buffer(pcm,
			SNDRV_PCM_STREAM_CAPTURE);
		if (ret)
			return ret;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 97 83.62% 1 33.33%
russell king russell king 12 10.34% 1 33.33%
fabio estevam fabio estevam 7 6.03% 1 33.33%
Total 116 100.00% 3 100.00%


static int ssi_irq = 0;



static int imx_pcm_fiq_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_pcm *pcm = rtd->pcm;
	struct snd_pcm_substream *substream;
	int ret;

	ret = imx_pcm_new(rtd);
	if (ret)
		return ret;

	substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
	if (substream) {
		struct snd_dma_buffer *buf = &substream->dma_buffer;

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

	substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
	if (substream) {
		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;
}

Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 100 76.34% 1 33.33%
wolfram sang wolfram sang 19 14.50% 1 33.33%
liam girdwood liam girdwood 12 9.16% 1 33.33%
Total 131 100.00% 3 100.00%



static void imx_pcm_free(struct snd_pcm *pcm)
{
	struct snd_pcm_substream *substream;
	struct snd_dma_buffer *buf;
	int stream;

	for (stream = 0; stream < 2; stream++) {
		substream = pcm->streams[stream].substream;
		if (!substream)
			continue;

		buf = &substream->dma_buffer;
		if (!buf->area)
			continue;

		dma_free_wc(pcm->card->dev, buf->bytes, buf->area, buf->addr);
		buf->area = NULL;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 97 98.98% 1 50.00%
luis r. rodriguez luis r. rodriguez 1 1.02% 1 50.00%
Total 98 100.00% 2 100.00%



static void imx_pcm_fiq_free(struct snd_pcm *pcm)
{
	mxc_set_irq_fiq(ssi_irq, 0);
	release_fiq(&fh);
	imx_pcm_free(pcm);
}

Contributors
Person Tokens Prop Commits CommitProp
liam girdwood liam girdwood 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


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



int imx_pcm_fiq_init(struct platform_device *pdev,
		struct imx_pcm_fiq_params *params)
{
	int ret;

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

	mxc_set_irq_fiq(params->irq, 1);
	ssi_irq = params->irq;

	imx_pcm_fiq = params->irq;

	imx_ssi_fiq_base = (unsigned long)params->base;

	params->dma_params_tx->maxburst = 4;
	params->dma_params_rx->maxburst = 6;

	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;
}
Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 75 55.56% 1 20.00%
liam girdwood liam girdwood 44 32.59% 1 20.00%
markus pargmann markus pargmann 13 9.63% 1 20.00%
lars-peter clausen lars-peter clausen 2 1.48% 1 20.00%
shawn guo shawn guo 1 0.74% 1 20.00%
Total 135 100.00% 5 100.00%


EXPORT_SYMBOL_GPL(imx_pcm_fiq_init);



void imx_pcm_fiq_exit(struct platform_device *pdev)
{
	snd_soc_unregister_platform(&pdev->dev);
}
Contributors
Person Tokens Prop Commits CommitProp
shawn guo shawn guo 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(imx_pcm_fiq_exit);

MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
sascha hauer sascha hauer 980 58.61% 4 16.67%
shawn guo shawn guo 410 24.52% 3 12.50%
liam girdwood liam girdwood 94 5.62% 2 8.33%
oskar schirmer oskar schirmer 82 4.90% 1 4.17%
mark brown mark brown 20 1.20% 2 8.33%
wolfram sang wolfram sang 19 1.14% 1 4.17%
markus pargmann markus pargmann 19 1.14% 1 4.17%
vasiliy kulikov vasiliy kulikov 17 1.02% 1 4.17%
russell king russell king 12 0.72% 1 4.17%
fabio estevam fabio estevam 8 0.48% 2 8.33%
luis r. rodriguez luis r. rodriguez 3 0.18% 1 4.17%
tejun heo tejun heo 3 0.18% 1 4.17%
lars-peter clausen lars-peter clausen 2 0.12% 1 4.17%
arnd bergmann arnd bergmann 2 0.12% 2 8.33%
heinrich schuchardt heinrich schuchardt 1 0.06% 1 4.17%
Total 1672 100.00% 24 100.00%
  Directory: sound/soc/fsl

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
sascha hauer	sascha hauer	95	80.51%	3	60.00%
mark brown	mark brown	13	11.02%	1	20.00%
oskar schirmer	oskar schirmer	10	8.47%	1	20.00%
	Total	118	100.00%	5	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 sound/soc/fsl/imx-pcm-fiq.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
