OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[ALSA] Update AT91 ASoC driver for 2.6.19 kernel. 

Changes were required to support latest AT91 header files.
Also updated to remove AT91RM9200-specific code in the ASoC
platform drivers to support the AT91SAM9260 and AT91SAM9261
chips, but no testing was performed on these chips.

Signed-off-by: Frank Mandarino <fmandarino@endrelia.com>
Signed-off-by: Liam Girdwood <lg@opensource.wolfsonmicro.com>
Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>
This commit is contained in:
Frank Mandarino 2006-11-24 15:49:39 +01:00 committed by Jaroslav Kysela
parent a9e996604f
commit 9f0ac6e1a8
5 changed files with 380 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sound/soc/at91/Makefile
View File

@ -1,6 +1,6 @@
# AT91 Platform Support # AT91 Platform Support
snd-soc-at91-objs := at91rm9200-pcm.o snd-soc-at91-objs := at91-pcm.o
snd-soc-at91-i2s-objs := at91rm9200-i2s.o snd-soc-at91-i2s-objs := at91-i2s.o
obj-$(CONFIG_SND_AT91_SOC) += snd-soc-at91.o obj-$(CONFIG_SND_AT91_SOC) += snd-soc-at91.o
obj-$(CONFIG_SND_AT91_SOC_I2S) += snd-soc-at91-i2s.o obj-$(CONFIG_SND_AT91_SOC_I2S) += snd-soc-at91-i2s.o

444
sound/soc/at91/at91rm9200-i2s.c → sound/soc/at91/at91-i2s.c
View File

@ -1,5 +1,5 @@
/* /*
* at91rm9200-i2s.c -- ALSA Soc Audio Layer Platform driver and DMA engine * at91-i2s.c -- ALSA SoC I2S Audio Layer Platform driver
* *
* Author: Frank Mandarino <fmandarino@endrelia.com> * Author: Frank Mandarino <fmandarino@endrelia.com>
* Endrelia Technologies Inc. * Endrelia Technologies Inc.
@ -28,34 +28,41 @@
#include <sound/initval.h> #include <sound/initval.h>
#include <sound/soc.h> #include <sound/soc.h>
#include <asm/arch/at91rm9200.h>
#include <asm/arch/at91rm9200_ssc.h>
#include <asm/arch/at91rm9200_pdc.h>
#include <asm/arch/hardware.h> #include <asm/arch/hardware.h>
#include <asm/arch/at91_pmc.h>
#include <asm/arch/at91_ssc.h>
#include <asm/arch/at91_pdc.h>
#include "at91rm9200-pcm.h" #include "at91-pcm.h"
#if 0 #if 0
#define DBG(x...) printk(KERN_DEBUG "at91rm9200-i2s:" x) #define DBG(x...) printk(KERN_DEBUG "at91-i2s:" x)
#else #else
#define DBG(x...) #define DBG(x...)
#endif #endif
#define AT91RM9200_I2S_DAIFMT \ #if defined(CONFIG_ARCH_AT91SAM9260)
#define NUM_SSC_DEVICES 1
#else
#define NUM_SSC_DEVICES 3
#endif
#define AT91_I2S_DAIFMT \
(SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_NB_NF) (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS | SND_SOC_DAIFMT_NB_NF)
#define AT91RM9200_I2S_DIR \ #define AT91_I2S_DIR \
(SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE) (SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE)
/* priv is (SSC_CMR.DIV << 16 | SSC_TCMR.PERIOD ) */ /* priv is (SSC_CMR.DIV << 16 | SSC_TCMR.PERIOD ) */
static struct snd_soc_dai_mode at91rm9200_i2s[] = { static struct snd_soc_dai_mode at91_i2s[] = {
/* 8k: BCLK = (MCLK/10) = (60MHz/50) = 1.2MHz */ /* 8k: BCLK = (MCLK/10) = (60MHz/50) = 1.2MHz */
{ {
.fmt = AT91RM9200_I2S_DAIFMT, .fmt = AT91_I2S_DAIFMT,
.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE, .pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
.pcmrate = SNDRV_PCM_RATE_8000, .pcmrate = SNDRV_PCM_RATE_8000,
.pcmdir = AT91RM9200_I2S_DIR, .pcmdir = AT91_I2S_DIR,
.flags = SND_SOC_DAI_BFS_DIV, .flags = SND_SOC_DAI_BFS_DIV,
.fs = 1500, .fs = 1500,
.bfs = SND_SOC_FSBD(10), .bfs = SND_SOC_FSBD(10),
@ -64,10 +71,10 @@ static struct snd_soc_dai_mode at91rm9200_i2s[] = {
/* 16k: BCLK = (MCLK/3) ~= (60MHz/14) = 4.285714MHz */ /* 16k: BCLK = (MCLK/3) ~= (60MHz/14) = 4.285714MHz */
{ {
.fmt = AT91RM9200_I2S_DAIFMT, .fmt = AT91_I2S_DAIFMT,
.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE, .pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
.pcmrate = SNDRV_PCM_RATE_16000, .pcmrate = SNDRV_PCM_RATE_16000,
.pcmdir = AT91RM9200_I2S_DIR, .pcmdir = AT91_I2S_DIR,
.flags = SND_SOC_DAI_BFS_DIV, .flags = SND_SOC_DAI_BFS_DIV,
.fs = 750, .fs = 750,
.bfs = SND_SOC_FSBD(3), .bfs = SND_SOC_FSBD(3),
@ -76,10 +83,10 @@ static struct snd_soc_dai_mode at91rm9200_i2s[] = {
/* 32k: BCLK = (MCLK/3) ~= (60MHz/14) = 4.285714MHz */ /* 32k: BCLK = (MCLK/3) ~= (60MHz/14) = 4.285714MHz */
{ {
.fmt = AT91RM9200_I2S_DAIFMT, .fmt = AT91_I2S_DAIFMT,
.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE, .pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
.pcmrate = SNDRV_PCM_RATE_32000, .pcmrate = SNDRV_PCM_RATE_32000,
.pcmdir = AT91RM9200_I2S_DIR, .pcmdir = AT91_I2S_DIR,
.flags = SND_SOC_DAI_BFS_DIV, .flags = SND_SOC_DAI_BFS_DIV,
.fs = 375, .fs = 375,
.bfs = SND_SOC_FSBD(3), .bfs = SND_SOC_FSBD(3),
@ -88,10 +95,10 @@ static struct snd_soc_dai_mode at91rm9200_i2s[] = {
/* 48k: BCLK = (MCLK/5) ~= (60MHz/26) = 2.3076923MHz */ /* 48k: BCLK = (MCLK/5) ~= (60MHz/26) = 2.3076923MHz */
{ {
.fmt = AT91RM9200_I2S_DAIFMT, .fmt = AT91_I2S_DAIFMT,
.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE, .pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
.pcmrate = SNDRV_PCM_RATE_48000, .pcmrate = SNDRV_PCM_RATE_48000,
.pcmdir = AT91RM9200_I2S_DIR, .pcmdir = AT91_I2S_DIR,
.flags = SND_SOC_DAI_BFS_DIV, .flags = SND_SOC_DAI_BFS_DIV,
.fs = 250, .fs = 250,
.bfs SND_SOC_FSBD(5), .bfs SND_SOC_FSBD(5),
@ -101,78 +108,26 @@ static struct snd_soc_dai_mode at91rm9200_i2s[] = {
/* /*
* SSC registers required by the PCM DMA engine. * SSC PDC registers required by the PCM DMA engine.
*/ */
static struct at91rm9200_ssc_regs ssc_reg[3] = { static struct at91_pdc_regs pdc_tx_reg = {
{ .xpr = AT91_PDC_TPR,
.cr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_CR), .xcr = AT91_PDC_TCR,
.ier = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_IER), .xnpr = AT91_PDC_TNPR,
.idr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_IDR), .xncr = AT91_PDC_TNCR,
},
{
.cr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_SSC_CR),
.ier = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_SSC_IER),
.idr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_SSC_IDR),
},
{
.cr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_SSC_CR),
.ier = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_SSC_IER),
.idr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_SSC_IDR),
},
}; };
static struct at91rm9200_pdc_regs pdc_tx_reg[3] = { static struct at91_pdc_regs pdc_rx_reg = {
{ .xpr = AT91_PDC_RPR,
.xpr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TPR), .xcr = AT91_PDC_RCR,
.xcr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TCR), .xnpr = AT91_PDC_RNPR,
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TNPR), .xncr = AT91_PDC_RNCR,
.xncr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_PTCR),
},
{
.xpr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_TPR),
.xcr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_TCR),
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_TNPR),
.xncr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_TNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_PTCR),
},
{
.xpr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_TPR),
.xcr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_TCR),
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_TNPR),
.xncr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_TNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_PTCR),
},
};
static struct at91rm9200_pdc_regs pdc_rx_reg[3] = {
{
.xpr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_RPR),
.xcr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_RCR),
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_RNPR),
.xncr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_RNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_PTCR),
},
{
.xpr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_RPR),
.xcr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_RCR),
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_RNPR),
.xncr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_RNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC1 + AT91_PDC_PTCR),
},
{
.xpr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_RPR),
.xcr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_RCR),
.xnpr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_RNPR),
.xncr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_RNCR),
.ptcr = (void __iomem *) (AT91_VA_BASE_SSC2 + AT91_PDC_PTCR),
},
}; };
/* /*
* SSC & PDC status bits for transmit and receive. * SSC & PDC status bits for transmit and receive.
*/ */
static struct at91rm9200_ssc_mask ssc_tx_mask = { static struct at91_ssc_mask ssc_tx_mask = {
.ssc_enable = AT91_SSC_TXEN, .ssc_enable = AT91_SSC_TXEN,
.ssc_disable = AT91_SSC_TXDIS, .ssc_disable = AT91_SSC_TXDIS,
.ssc_endx = AT91_SSC_ENDTX, .ssc_endx = AT91_SSC_ENDTX,
@ -181,7 +136,7 @@ static struct at91rm9200_ssc_mask ssc_tx_mask = {
.pdc_disable = AT91_PDC_TXTDIS, .pdc_disable = AT91_PDC_TXTDIS,
}; };
static struct at91rm9200_ssc_mask ssc_rx_mask = { static struct at91_ssc_mask ssc_rx_mask = {
.ssc_enable = AT91_SSC_RXEN, .ssc_enable = AT91_SSC_RXEN,
.ssc_disable = AT91_SSC_RXDIS, .ssc_disable = AT91_SSC_RXDIS,
.ssc_endx = AT91_SSC_ENDRX, .ssc_endx = AT91_SSC_ENDRX,
@ -190,6 +145,46 @@ static struct at91rm9200_ssc_mask ssc_rx_mask = {
.pdc_disable = AT91_PDC_RXTDIS, .pdc_disable = AT91_PDC_RXTDIS,
}; };
/*
* DMA parameters.
*/
static struct at91_pcm_dma_params ssc_dma_params[NUM_SSC_DEVICES][2] = {
{{
.name = "SSC0/I2S PCM Stereo out",
.pdc = &pdc_tx_reg,
.mask = &ssc_tx_mask,
},
{
.name = "SSC0/I2S PCM Stereo in",
.pdc = &pdc_rx_reg,
.mask = &ssc_rx_mask,
}},
#if NUM_SSC_DEVICES == 3
{{
.name = "SSC1/I2S PCM Stereo out",
.pdc = &pdc_tx_reg,
.mask = &ssc_tx_mask,
},
{
.name = "SSC1/I2S PCM Stereo in",
.pdc = &pdc_rx_reg,
.mask = &ssc_rx_mask,
}},
{{
.name = "SSC2/I2S PCM Stereo out",
.pdc = &pdc_tx_reg,
.mask = &ssc_tx_mask,
},
{
.name = "SSC1/I2S PCM Stereo in",
.pdc = &pdc_rx_reg,
.mask = &ssc_rx_mask,
}},
#endif
};
/* /*
* A MUTEX is used to protect an SSC initialzed flag which allows * A MUTEX is used to protect an SSC initialzed flag which allows
* the substream hw_params() call to initialize the SSC only if * the substream hw_params() call to initialize the SSC only if
@ -198,53 +193,13 @@ static struct at91rm9200_ssc_mask ssc_rx_mask = {
* it is using the same format and rate. * it is using the same format and rate.
*/ */
static DECLARE_MUTEX(ssc0_mutex); static DECLARE_MUTEX(ssc0_mutex);
#if NUM_SSC_DEVICES == 3
static DECLARE_MUTEX(ssc1_mutex); static DECLARE_MUTEX(ssc1_mutex);
static DECLARE_MUTEX(ssc2_mutex); static DECLARE_MUTEX(ssc2_mutex);
#endif
/*
* DMA parameters.
*/
static at91rm9200_pcm_dma_params_t ssc_dma_params[3][2] = {
{{
.name = "SSC0/I2S PCM Stereo out",
.ssc = &ssc_reg[0],
.pdc = &pdc_tx_reg[0],
.mask = &ssc_tx_mask,
},
{
.name = "SSC0/I2S PCM Stereo in",
.ssc = &ssc_reg[0],
.pdc = &pdc_rx_reg[0],
.mask = &ssc_rx_mask,
}},
{{
.name = "SSC1/I2S PCM Stereo out",
.ssc = &ssc_reg[1],
.pdc = &pdc_tx_reg[1],
.mask = &ssc_tx_mask,
},
{
.name = "SSC1/I2S PCM Stereo in",
.ssc = &ssc_reg[1],
.pdc = &pdc_rx_reg[1],
.mask = &ssc_rx_mask,
}},
{{
.name = "SSC2/I2S PCM Stereo out",
.ssc = &ssc_reg[2],
.pdc = &pdc_tx_reg[2],
.mask = &ssc_tx_mask,
},
{
.name = "SSC1/I2S PCM Stereo in",
.ssc = &ssc_reg[2],
.pdc = &pdc_rx_reg[2],
.mask = &ssc_rx_mask,
}},
};
struct at91rm9200_ssc_state { struct at91_ssc_state {
u32 ssc_cmr; u32 ssc_cmr;
u32 ssc_rcmr; u32 ssc_rcmr;
u32 ssc_rfmr; u32 ssc_rfmr;
@ -254,33 +209,30 @@ struct at91rm9200_ssc_state {
u32 ssc_imr; u32 ssc_imr;
}; };
static struct at91rm9200_ssc_info {
static struct at91_ssc_info {
char *name; char *name;
void __iomem *ssc_base; struct at91_ssc_periph ssc;
u32 pid;
spinlock_t lock; /* lock for dir_mask */ spinlock_t lock; /* lock for dir_mask */
int dir_mask; /* 0=unused, 1=playback, 2=capture */ int dir_mask; /* 0=unused, 1=playback, 2=capture */
struct semaphore *mutex; struct semaphore *mutex;
int initialized; int initialized;
int pcmfmt; int pcmfmt;
int rate; int rate;
at91rm9200_pcm_dma_params_t *dma_params[2]; struct at91_pcm_dma_params *dma_params[2];
struct at91rm9200_ssc_state ssc_state; struct at91_ssc_state ssc_state;
} ssc_info[3] = { } ssc_info[NUM_SSC_DEVICES] = {
{ {
.name = "ssc0", .name = "ssc0",
.ssc_base = (void __iomem *) AT91_VA_BASE_SSC0,
.pid = AT91_ID_SSC0,
.lock = SPIN_LOCK_UNLOCKED, .lock = SPIN_LOCK_UNLOCKED,
.dir_mask = 0, .dir_mask = 0,
.mutex = &ssc0_mutex, .mutex = &ssc0_mutex,
.initialized = 0, .initialized = 0,
}, },
#if NUM_SSC_DEVICES == 3
{ {
.name = "ssc1", .name = "ssc1",
.ssc_base = (void __iomem *) AT91_VA_BASE_SSC1,
.pid = AT91_ID_SSC1,
.lock = SPIN_LOCK_UNLOCKED, .lock = SPIN_LOCK_UNLOCKED,
.dir_mask = 0, .dir_mask = 0,
.mutex = &ssc1_mutex, .mutex = &ssc1_mutex,
@ -288,25 +240,24 @@ static struct at91rm9200_ssc_info {
}, },
{ {
.name = "ssc2", .name = "ssc2",
.ssc_base = (void __iomem *) AT91_VA_BASE_SSC2,
.pid = AT91_ID_SSC2,
.lock = SPIN_LOCK_UNLOCKED, .lock = SPIN_LOCK_UNLOCKED,
.dir_mask = 0, .dir_mask = 0,
.mutex = &ssc2_mutex, .mutex = &ssc2_mutex,
.initialized = 0, .initialized = 0,
}, },
#endif
}; };
static irqreturn_t at91rm9200_i2s_interrupt(int irq, void *dev_id) static irqreturn_t at91_i2s_interrupt(int irq, void *dev_id)
{ {
struct at91rm9200_ssc_info *ssc_p = dev_id; struct at91_ssc_info *ssc_p = dev_id;
at91rm9200_pcm_dma_params_t *dma_params; struct at91_pcm_dma_params *dma_params;
u32 ssc_sr; u32 ssc_sr;
int i; int i;
ssc_sr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR) ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR)
& at91_ssc_read(ssc_p->ssc_base + AT91_SSC_IMR); & at91_ssc_read(ssc_p->ssc.base + AT91_SSC_IMR);
/* /*
* Loop through the substreams attached to this SSC. If * Loop through the substreams attached to this SSC. If
@ -327,14 +278,14 @@ static irqreturn_t at91rm9200_i2s_interrupt(int irq, void *dev_id)
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static int at91rm9200_i2s_startup(struct snd_pcm_substream *substream) static int at91_i2s_startup(struct snd_pcm_substream *substream)
{ {
struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct at91rm9200_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id]; struct at91_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id];
int dir_mask; int dir_mask;
DBG("i2s_startup: SSC_SR=0x%08lx\n", DBG("i2s_startup: SSC_SR=0x%08lx\n",
at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR)); at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR));
dir_mask = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0x1 : 0x2; dir_mask = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0x1 : 0x2;
spin_lock_irq(&ssc_p->lock); spin_lock_irq(&ssc_p->lock);
@ -348,20 +299,22 @@ static int at91rm9200_i2s_startup(struct snd_pcm_substream *substream)
return 0; return 0;
} }
static void at91rm9200_i2s_shutdown(struct snd_pcm_substream *substream) static void at91_i2s_shutdown(struct snd_pcm_substream *substream)
{ {
struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data;
struct at91rm9200_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id]; struct at91_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id];
at91rm9200_pcm_dma_params_t *dma_params = rtd->cpu_dai->dma_data; struct at91_pcm_dma_params *dma_params = rtd->cpu_dai->dma_data;
int dir, dir_mask; int dir, dir_mask;
dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1; dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
if (dma_params != NULL) { if (dma_params != NULL) {
at91_ssc_write(dma_params->ssc->cr, dma_params->mask->ssc_disable); at91_ssc_write(dma_params->ssc_base + AT91_SSC_CR,
dma_params->mask->ssc_disable);
DBG("%s disabled SSC_SR=0x%08lx\n", (dir ? "receive" : "transmit"), DBG("%s disabled SSC_SR=0x%08lx\n", (dir ? "receive" : "transmit"),
at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR)); at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR));
dma_params->ssc_base = NULL;
dma_params->substream = NULL; dma_params->substream = NULL;
ssc_p->dma_params[dir] = NULL; ssc_p->dma_params[dir] = NULL;
} }
@ -372,14 +325,14 @@ static void at91rm9200_i2s_shutdown(struct snd_pcm_substream *substream)
ssc_p->dir_mask &= ~dir_mask; ssc_p->dir_mask &= ~dir_mask;
if (!ssc_p->dir_mask) { if (!ssc_p->dir_mask) {
/* Shutdown the SSC clock. */ /* Shutdown the SSC clock. */
DBG("Stopping pid %d clock\n", ssc_p->pid); DBG("Stopping pid %d clock\n", ssc_p->ssc.pid);
at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->pid); at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->ssc.pid);
if (ssc_p->initialized) if (ssc_p->initialized)
free_irq(ssc_p->pid, ssc_p); free_irq(ssc_p->ssc.pid, ssc_p);
/* Reset the SSC */ /* Reset the SSC */
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_CR, AT91_SSC_SWRST); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR, AT91_SSC_SWRST);
/* Force a re-init on the next hw_params() call. */ /* Force a re-init on the next hw_params() call. */
ssc_p->initialized = 0; ssc_p->initialized = 0;
@ -388,10 +341,10 @@ static void at91rm9200_i2s_shutdown(struct snd_pcm_substream *substream)
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM
static int at91rm9200_i2s_suspend(struct platform_device *pdev, static int at91_i2s_suspend(struct platform_device *pdev,
struct snd_soc_cpu_dai *dai) struct snd_soc_cpu_dai *dai)
{ {
struct at91rm9200_ssc_info *ssc_p; struct at91_ssc_info *ssc_p;
if(!dai->active) if(!dai->active)
return 0; return 0;
@ -399,27 +352,27 @@ static int at91rm9200_i2s_suspend(struct platform_device *pdev,
ssc_p = &ssc_info[dai->id]; ssc_p = &ssc_info[dai->id];
/* Save the status register before disabling transmit and receive. */ /* Save the status register before disabling transmit and receive. */
ssc_p->state->ssc_sr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR); ssc_p->state->ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR);
at91_ssc_write(ssc_p->ssc_base + at91_ssc_write(ssc_p->ssc.base +
AT91_SSC_CR, AT91_SSC_TXDIS | AT91_SSC_RXDIS); AT91_SSC_CR, AT91_SSC_TXDIS | AT91_SSC_RXDIS);
/* Save the current interrupt mask, then disable unmasked interrupts. */ /* Save the current interrupt mask, then disable unmasked interrupts. */
ssc_p->state->ssc_imr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_IMR); ssc_p->state->ssc_imr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_IMR);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_IDR, ssc_p->state->ssc_imr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_IDR, ssc_p->state->ssc_imr);
ssc_p->state->ssc_cmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_CMR); ssc_p->state->ssc_cmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_CMR);
ssc_p->state->ssc_rcmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_RCMR); ssc_p->state->ssc_rcmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
ssc_p->state->ssc_rfmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_RCMR); ssc_p->state->ssc_rfmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
ssc_p->state->ssc_tcmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_RCMR); ssc_p->state->ssc_tcmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
ssc_p->state->ssc_tfmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_RCMR); ssc_p->state->ssc_tfmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
return 0; return 0;
} }
static int at91rm9200_i2s_resume(struct platform_device *pdev, static int at91_i2s_resume(struct platform_device *pdev,
struct snd_soc_cpu_dai *dai) struct snd_soc_cpu_dai *dai)
{ {
struct at91rm9200_ssc_info *ssc_p; struct at91_ssc_info *ssc_p;
u32 cr_mask; u32 cr_mask;
if(!dai->active) if(!dai->active)
@ -427,15 +380,15 @@ static int at91rm9200_i2s_resume(struct platform_device *pdev,
ssc_p = &ssc_info[dai->id]; ssc_p = &ssc_info[dai->id];
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RCMR, ssc_p->state->ssc_tfmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, ssc_p->state->ssc_tfmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RCMR, ssc_p->state->ssc_tcmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, ssc_p->state->ssc_tcmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RCMR, ssc_p->state->ssc_rfmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, ssc_p->state->ssc_rfmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RCMR, ssc_p->state->ssc_rcmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, ssc_p->state->ssc_rcmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_CMR, ssc_p->state->ssc_cmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CMR, ssc_p->state->ssc_cmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_IER, ssc_p->state->ssc_imr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_IER, ssc_p->state->ssc_imr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_CR, at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR,
((ssc_p->state->ssc_sr & AT91_SSC_RXENA) ? AT91_SSC_RXEN : 0) | ((ssc_p->state->ssc_sr & AT91_SSC_RXENA) ? AT91_SSC_RXEN : 0) |
((ssc_p->state->ssc_sr & AT91_SSC_TXENA) ? AT91_SSC_TXEN : 0)); ((ssc_p->state->ssc_sr & AT91_SSC_TXENA) ? AT91_SSC_TXEN : 0));
@ -443,11 +396,11 @@ static int at91rm9200_i2s_resume(struct platform_device *pdev,
} }
#else #else
#define at91rm9200_i2s_suspend NULL #define at91_i2s_suspend NULL
#define at91rm9200_i2s_resume NULL #define at91_i2s_resume NULL
#endif #endif
static unsigned int at91rm9200_i2s_config_sysclk( static unsigned int at91_i2s_config_sysclk(
struct snd_soc_cpu_dai *iface, struct snd_soc_clock_info *info, struct snd_soc_cpu_dai *iface, struct snd_soc_clock_info *info,
unsigned int clk) unsigned int clk)
{ {
@ -457,17 +410,16 @@ static unsigned int at91rm9200_i2s_config_sysclk(
return 12000000; return 12000000;
} }
static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream, static int at91_i2s_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params) struct snd_pcm_hw_params *params)
{ {
struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data;
int id = rtd->cpu_dai->id; int id = rtd->cpu_dai->id;
struct at91rm9200_ssc_info *ssc_p = &ssc_info[id]; struct at91_ssc_info *ssc_p = &ssc_info[id];
at91rm9200_pcm_dma_params_t *dma_params; struct at91_pcm_dma_params *dma_params;
unsigned int pcmfmt, rate; unsigned int pcmfmt, rate;
int dir, channels, bits; int dir, channels, bits;
struct clk *mck_clk; struct clk *mck_clk;
unsigned long bclk;
u32 div, period, tfmr, rfmr, tcmr, rcmr; u32 div, period, tfmr, rfmr, tcmr, rcmr;
int ret; int ret;
@ -479,6 +431,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1; dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
dma_params = &ssc_dma_params[id][dir]; dma_params = &ssc_dma_params[id][dir];
dma_params->ssc_base = ssc_p->ssc.base;
dma_params->substream = substream; dma_params->substream = substream;
ssc_p->dma_params[dir] = dma_params; ssc_p->dma_params[dir] = dma_params;
@ -495,7 +448,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
dma_params->pdc_xfer_size = 2; dma_params->pdc_xfer_size = 2;
break; break;
default: default:
printk(KERN_WARNING "at91rm9200-i2s: unsupported format %x\n", printk(KERN_WARNING "at91-i2s: unsupported format %x\n",
pcmfmt); pcmfmt);
return -EINVAL; return -EINVAL;
} }
@ -509,46 +462,45 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
*/ */
if (ssc_p->initialized) { if (ssc_p->initialized) {
if (pcmfmt != ssc_p->pcmfmt || rate != ssc_p->rate) { if (pcmfmt != ssc_p->pcmfmt || rate != ssc_p->rate) {
printk(KERN_WARNING "at91rm9200-i2s: " printk(KERN_WARNING "at91-i2s: "
"incompatible substream in other direction\n"); "incompatible substream in other direction\n");
up(ssc_p->mutex); up(ssc_p->mutex);
return -EINVAL; return -EINVAL;
} }
} else { } else {
/* Enable PMC peripheral clock for this SSC */ /* Enable PMC peripheral clock for this SSC */
DBG("Starting pid %d clock\n", ssc_p->pid); DBG("Starting pid %d clock\n", ssc_p->ssc.pid);
at91_sys_write(AT91_PMC_PCER, 1<<ssc_p->pid); at91_sys_write(AT91_PMC_PCER, 1<<ssc_p->ssc.pid);
/* Reset the SSC */ /* Reset the SSC */
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_CR, AT91_SSC_SWRST); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR, AT91_SSC_SWRST);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_RPR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_RPR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_RCR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_RCR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_RNPR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_RNPR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_RNCR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_RNCR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_TPR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TPR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_TCR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TCR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_TNPR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TNPR, 0);
at91_ssc_write(ssc_p->ssc_base + AT91_PDC_TNCR, 0); at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TNCR, 0);
mck_clk = clk_get(NULL, "mck");
div = rtd->cpu_dai->dai_runtime.priv >> 16; div = rtd->cpu_dai->dai_runtime.priv >> 16;
period = rtd->cpu_dai->dai_runtime.priv & 0xffff; period = rtd->cpu_dai->dai_runtime.priv & 0xffff;
bclk = 60000000 / (2 * div);
DBG("mck %ld fsbd %d bfs %d bfs_real %d bclk %ld div %d period %d\n", mck_clk = clk_get(NULL, "mck");
DBG("mck %lu fsbd %u bfs %llu bfs_real %u bclk %lu div %u period %u\n",
clk_get_rate(mck_clk), clk_get_rate(mck_clk),
SND_SOC_FSBD(6), SND_SOC_FSBD(6),
rtd->cpu_dai->dai_runtime.bfs, rtd->cpu_dai->dai_runtime.bfs,
SND_SOC_FSBD_REAL(rtd->cpu_dai->dai_runtime.bfs), SND_SOC_FSBD_REAL(rtd->cpu_dai->dai_runtime.bfs),
bclk, clk_get_rate(mck_clk) / (2 * div),
div, div,
period); period);
clk_put(mck_clk); clk_put(mck_clk);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_CMR, div); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CMR, div);
/* /*
* Setup the TFMR and RFMR for the proper data format. * Setup the TFMR and RFMR for the proper data format.
@ -563,7 +515,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
| (( 0 << 5) & AT91_SSC_DATDEF) | (( 0 << 5) & AT91_SSC_DATDEF)
| (((bits - 1) << 0) & AT91_SSC_DATALEN); | (((bits - 1) << 0) & AT91_SSC_DATALEN);
DBG("SSC_TFMR=0x%08x\n", tfmr); DBG("SSC_TFMR=0x%08x\n", tfmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_TFMR, tfmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TFMR, tfmr);
rfmr = rfmr =
(( AT91_SSC_FSEDGE_POSITIVE ) & AT91_SSC_FSEDGE) (( AT91_SSC_FSEDGE_POSITIVE ) & AT91_SSC_FSEDGE)
@ -575,7 +527,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
| (((bits - 1) << 0) & AT91_SSC_DATALEN); | (((bits - 1) << 0) & AT91_SSC_DATALEN);
DBG("SSC_RFMR=0x%08x\n", rfmr); DBG("SSC_RFMR=0x%08x\n", rfmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RFMR, rfmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RFMR, rfmr);
/* /*
* Setup the TCMR and RCMR to generate the proper BCLK * Setup the TCMR and RCMR to generate the proper BCLK
@ -590,7 +542,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
| (( AT91_SSC_CKS_DIV ) & AT91_SSC_CKS); | (( AT91_SSC_CKS_DIV ) & AT91_SSC_CKS);
DBG("SSC_TCMR=0x%08x\n", tcmr); DBG("SSC_TCMR=0x%08x\n", tcmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_TCMR, tcmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TCMR, tcmr);
rcmr = rcmr =
(( 0 << 24) & AT91_SSC_PERIOD) (( 0 << 24) & AT91_SSC_PERIOD)
@ -601,11 +553,11 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
| (( AT91_SSC_CKS_CLOCK ) & AT91_SSC_CKS); | (( AT91_SSC_CKS_CLOCK ) & AT91_SSC_CKS);
DBG("SSC_RCMR=0x%08x\n", rcmr); DBG("SSC_RCMR=0x%08x\n", rcmr);
at91_ssc_write(ssc_p->ssc_base + AT91_SSC_RCMR, rcmr); at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, rcmr);
if ((ret = request_irq(ssc_p->pid, at91rm9200_i2s_interrupt, if ((ret = request_irq(ssc_p->ssc.pid, at91_i2s_interrupt,
0, ssc_p->name, ssc_p)) < 0) { 0, ssc_p->name, ssc_p)) < 0) {
printk(KERN_WARNING "at91rm9200-i2s: request_irq failure\n"); printk(KERN_WARNING "at91-i2s: request_irq failure\n");
return ret; return ret;
} }
@ -627,27 +579,28 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
} }
static int at91rm9200_i2s_prepare(struct snd_pcm_substream *substream) static int at91_i2s_prepare(struct snd_pcm_substream *substream)
{ {
struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data;
at91rm9200_pcm_dma_params_t *dma_params = rtd->cpu_dai->dma_data; struct at91_pcm_dma_params *dma_params = rtd->cpu_dai->dma_data;
at91_ssc_write(dma_params->ssc->cr, dma_params->mask->ssc_enable); at91_ssc_write(dma_params->ssc_base + AT91_SSC_CR,
dma_params->mask->ssc_enable);
DBG("%s enabled SSC_SR=0x%08lx\n", DBG("%s enabled SSC_SR=0x%08lx\n",
substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? "transmit" : "receive", substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? "transmit" : "receive",
at91_ssc_read(ssc_info[rtd->cpu_dai->id].ssc_base + AT91_SSC_SR)); at91_ssc_read(ssc_info[rtd->cpu_dai->id].ssc.base + AT91_SSC_SR));
return 0; return 0;
} }
struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = { struct snd_soc_cpu_dai at91_i2s_dai[NUM_SSC_DEVICES] = {
{ .name = "at91rm9200-ssc0/i2s", { .name = "at91_ssc0/i2s",
.id = 0, .id = 0,
.type = SND_SOC_DAI_I2S, .type = SND_SOC_DAI_I2S,
.suspend = at91rm9200_i2s_suspend, .suspend = at91_i2s_suspend,
.resume = at91rm9200_i2s_resume, .resume = at91_i2s_resume,
.config_sysclk = at91rm9200_i2s_config_sysclk, .config_sysclk = at91_i2s_config_sysclk,
.playback = { .playback = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
@ -655,20 +608,22 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
.ops = { .ops = {
.startup = at91rm9200_i2s_startup, .startup = at91_i2s_startup,
.shutdown = at91rm9200_i2s_shutdown, .shutdown = at91_i2s_shutdown,
.prepare = at91rm9200_i2s_prepare, .prepare = at91_i2s_prepare,
.hw_params = at91rm9200_i2s_hw_params,}, .hw_params = at91_i2s_hw_params,},
.caps = { .caps = {
.mode = &at91rm9200_i2s[0], .mode = &at91_i2s[0],
.num_modes = ARRAY_SIZE(at91rm9200_i2s),}, .num_modes = ARRAY_SIZE(at91_i2s),},
.private_data = &ssc_info[0].ssc,
}, },
{ .name = "at91rm9200-ssc1/i2s", #if NUM_SSC_DEVICES == 3
{ .name = "at91_ssc1/i2s",
.id = 1, .id = 1,
.type = SND_SOC_DAI_I2S, .type = SND_SOC_DAI_I2S,
.suspend = at91rm9200_i2s_suspend, .suspend = at91_i2s_suspend,
.resume = at91rm9200_i2s_resume, .resume = at91_i2s_resume,
.config_sysclk = at91rm9200_i2s_config_sysclk, .config_sysclk = at91_i2s_config_sysclk,
.playback = { .playback = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
@ -676,20 +631,21 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
.ops = { .ops = {
.startup = at91rm9200_i2s_startup, .startup = at91_i2s_startup,
.shutdown = at91rm9200_i2s_shutdown, .shutdown = at91_i2s_shutdown,
.prepare = at91rm9200_i2s_prepare, .prepare = at91_i2s_prepare,
.hw_params = at91rm9200_i2s_hw_params,}, .hw_params = at91_i2s_hw_params,},
.caps = { .caps = {
.mode = &at91rm9200_i2s[0], .mode = &at91_i2s[0],
.num_modes = ARRAY_SIZE(at91rm9200_i2s),}, .num_modes = ARRAY_SIZE(at91_i2s),},
.private_data = &ssc_info[1].ssc,
}, },
{ .name = "at91rm9200-ssc2/i2s", { .name = "at91_ssc2/i2s",
.id = 2, .id = 2,
.type = SND_SOC_DAI_I2S, .type = SND_SOC_DAI_I2S,
.suspend = at91rm9200_i2s_suspend, .suspend = at91_i2s_suspend,
.resume = at91rm9200_i2s_resume, .resume = at91_i2s_resume,
.config_sysclk = at91rm9200_i2s_config_sysclk, .config_sysclk = at91_i2s_config_sysclk,
.playback = { .playback = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
@ -697,19 +653,21 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
.channels_min = 1, .channels_min = 1,
.channels_max = 2,}, .channels_max = 2,},
.ops = { .ops = {
.startup = at91rm9200_i2s_startup, .startup = at91_i2s_startup,
.shutdown = at91rm9200_i2s_shutdown, .shutdown = at91_i2s_shutdown,
.prepare = at91rm9200_i2s_prepare, .prepare = at91_i2s_prepare,
.hw_params = at91rm9200_i2s_hw_params,}, .hw_params = at91_i2s_hw_params,},
.caps = { .caps = {
.mode = &at91rm9200_i2s[0], .mode = &at91_i2s[0],
.num_modes = ARRAY_SIZE(at91rm9200_i2s),}, .num_modes = ARRAY_SIZE(at91_i2s),},
.private_data = &ssc_info[2].ssc,
}, },
#endif
}; };
EXPORT_SYMBOL_GPL(at91rm9200_i2s_dai); EXPORT_SYMBOL_GPL(at91_i2s_dai);
/* Module information */ /* Module information */
MODULE_AUTHOR("Frank Mandarino, fmandarino@endrelia.com, www.endrelia.com"); MODULE_AUTHOR("Frank Mandarino, fmandarino@endrelia.com, www.endrelia.com");
MODULE_DESCRIPTION("AT91RM9200 I2S ASoC Interface"); MODULE_DESCRIPTION("AT91 I2S ASoC Interface");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

203
sound/soc/at91/at91rm9200-pcm.c → sound/soc/at91/at91-pcm.c
View File

@ -1,5 +1,5 @@
/* /*
* at91rm9200-pcm.c -- ALSA PCM interface for the Atmel AT91RM9200 chip. * at91-pcm.c -- ALSA PCM interface for the Atmel AT91 SoC
* *
* Author: Frank Mandarino <fmandarino@endrelia.com> * Author: Frank Mandarino <fmandarino@endrelia.com>
* Endrelia Technologies Inc. * Endrelia Technologies Inc.
@ -28,20 +28,19 @@
#include <sound/pcm_params.h> #include <sound/pcm_params.h>
#include <sound/soc.h> #include <sound/soc.h>
#include <asm/arch/at91rm9200.h>
#include <asm/arch/at91rm9200_ssc.h>
#include <asm/arch/at91rm9200_pdc.h>
#include <asm/arch/hardware.h> #include <asm/arch/hardware.h>
#include <asm/arch/at91_ssc.h>
#include <asm/arch/at91_pdc.h>
#include "at91rm9200-pcm.h" #include "at91-pcm.h"
#if 0 #if 0
#define DBG(x...) printk(KERN_INFO "at91rm9200-pcm: " x) #define DBG(x...) printk(KERN_INFO "at91-pcm: " x)
#else #else
#define DBG(x...) #define DBG(x...)
#endif #endif
static const snd_pcm_hardware_t at91rm9200_pcm_hardware = { static const struct snd_pcm_hardware at91_pcm_hardware = {
.info = SNDRV_PCM_INFO_MMAP | .info = SNDRV_PCM_INFO_MMAP |
SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_MMAP_VALID |
SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_INTERLEAVED |
@ -54,8 +53,8 @@ static const snd_pcm_hardware_t at91rm9200_pcm_hardware = {
.buffer_bytes_max = 32 * 1024, .buffer_bytes_max = 32 * 1024,
}; };
struct at91rm9200_runtime_data { struct at91_runtime_data {
at91rm9200_pcm_dma_params_t *params; struct at91_pcm_dma_params *params;
dma_addr_t dma_buffer; /* physical address of dma buffer */ dma_addr_t dma_buffer; /* physical address of dma buffer */
dma_addr_t dma_buffer_end; /* first address beyond DMA buffer */ dma_addr_t dma_buffer_end; /* first address beyond DMA buffer */
size_t period_size; size_t period_size;
@ -66,11 +65,11 @@ struct at91rm9200_runtime_data {
u32 pdc_xncr_save; u32 pdc_xncr_save;
}; };
static void at91rm9200_pcm_dma_irq(u32 ssc_sr, static void at91_pcm_dma_irq(u32 ssc_sr,
struct snd_pcm_substream *substream) struct snd_pcm_substream *substream)
{ {
struct at91rm9200_runtime_data *prtd = substream->runtime->private_data; struct at91_runtime_data *prtd = substream->runtime->private_data;
at91rm9200_pcm_dma_params_t *params = prtd->params; struct at91_pcm_dma_params *params = prtd->params;
static int count = 0; static int count = 0;
count++; count++;
@ -78,24 +77,24 @@ static void at91rm9200_pcm_dma_irq(u32 ssc_sr,
if (ssc_sr & params->mask->ssc_endbuf) { if (ssc_sr & params->mask->ssc_endbuf) {
printk(KERN_WARNING printk(KERN_WARNING
"at91rm9200-pcm: buffer %s on %s (SSC_SR=%#x, count=%d)\n", "at91-pcm: buffer %s on %s (SSC_SR=%#x, count=%d)\n",
substream->stream == SNDRV_PCM_STREAM_PLAYBACK substream->stream == SNDRV_PCM_STREAM_PLAYBACK
? "underrun" : "overrun", ? "underrun" : "overrun",
params->name, ssc_sr, count); params->name, ssc_sr, count);
/* re-start the PDC */ /* re-start the PDC */
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_disable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_disable);
prtd->period_ptr += prtd->period_size; prtd->period_ptr += prtd->period_size;
if (prtd->period_ptr >= prtd->dma_buffer_end) { if (prtd->period_ptr >= prtd->dma_buffer_end) {
prtd->period_ptr = prtd->dma_buffer; prtd->period_ptr = prtd->dma_buffer;
} }
at91_ssc_write(params->pdc->xpr, prtd->period_ptr); at91_ssc_write(params->ssc_base + params->pdc->xpr, prtd->period_ptr);
at91_ssc_write(params->pdc->xcr, at91_ssc_write(params->ssc_base + params->pdc->xcr,
prtd->period_size / params->pdc_xfer_size); prtd->period_size / params->pdc_xfer_size);
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_enable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_enable);
} }
if (ssc_sr & params->mask->ssc_endx) { if (ssc_sr & params->mask->ssc_endx) {
@ -105,19 +104,19 @@ static void at91rm9200_pcm_dma_irq(u32 ssc_sr,
if (prtd->period_ptr >= prtd->dma_buffer_end) { if (prtd->period_ptr >= prtd->dma_buffer_end) {
prtd->period_ptr = prtd->dma_buffer; prtd->period_ptr = prtd->dma_buffer;
} }
at91_ssc_write(params->pdc->xnpr, prtd->period_ptr); at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->period_ptr);
at91_ssc_write(params->pdc->xncr, at91_ssc_write(params->ssc_base + params->pdc->xncr,
prtd->period_size / params->pdc_xfer_size); prtd->period_size / params->pdc_xfer_size);
} }
snd_pcm_period_elapsed(substream); snd_pcm_period_elapsed(substream);
} }
static int at91rm9200_pcm_hw_params(struct snd_pcm_substream *substream, static int at91_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params) struct snd_pcm_hw_params *params)
{ {
snd_pcm_runtime_t *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct at91rm9200_runtime_data *prtd = runtime->private_data; struct at91_runtime_data *prtd = runtime->private_data;
struct snd_soc_pcm_runtime *rtd = substream->private_data; struct snd_soc_pcm_runtime *rtd = substream->private_data;
/* this may get called several times by oss emulation /* this may get called several times by oss emulation
@ -127,7 +126,7 @@ static int at91rm9200_pcm_hw_params(struct snd_pcm_substream *substream,
runtime->dma_bytes = params_buffer_bytes(params); runtime->dma_bytes = params_buffer_bytes(params);
prtd->params = rtd->cpu_dai->dma_data; prtd->params = rtd->cpu_dai->dma_data;
prtd->params->dma_intr_handler = at91rm9200_pcm_dma_irq; prtd->params->dma_intr_handler = at91_pcm_dma_irq;
prtd->dma_buffer = runtime->dma_addr; prtd->dma_buffer = runtime->dma_addr;
prtd->dma_buffer_end = runtime->dma_addr + runtime->dma_bytes; prtd->dma_buffer_end = runtime->dma_addr + runtime->dma_bytes;
@ -138,76 +137,76 @@ static int at91rm9200_pcm_hw_params(struct snd_pcm_substream *substream,
return 0; return 0;
} }
static int at91rm9200_pcm_hw_free(struct snd_pcm_substream *substream) static int at91_pcm_hw_free(struct snd_pcm_substream *substream)
{ {
struct at91rm9200_runtime_data *prtd = substream->runtime->private_data; struct at91_runtime_data *prtd = substream->runtime->private_data;
at91rm9200_pcm_dma_params_t *params = prtd->params; struct at91_pcm_dma_params *params = prtd->params;
if (params != NULL) { if (params != NULL) {
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_disable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_disable);
prtd->params->dma_intr_handler = NULL; prtd->params->dma_intr_handler = NULL;
} }
return 0; return 0;
} }
static int at91rm9200_pcm_prepare(struct snd_pcm_substream *substream) static int at91_pcm_prepare(struct snd_pcm_substream *substream)
{ {
struct at91rm9200_runtime_data *prtd = substream->runtime->private_data; struct at91_runtime_data *prtd = substream->runtime->private_data;
at91rm9200_pcm_dma_params_t *params = prtd->params; struct at91_pcm_dma_params *params = prtd->params;
at91_ssc_write(params->ssc->idr, at91_ssc_write(params->ssc_base + AT91_SSC_IDR,
params->mask->ssc_endx | params->mask->ssc_endbuf); params->mask->ssc_endx | params->mask->ssc_endbuf);
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_disable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_disable);
return 0; return 0;
} }
static int at91rm9200_pcm_trigger(struct snd_pcm_substream *substream, static int at91_pcm_trigger(struct snd_pcm_substream *substream,
int cmd) int cmd)
{ {
struct at91rm9200_runtime_data *prtd = substream->runtime->private_data; struct at91_runtime_data *prtd = substream->runtime->private_data;
at91rm9200_pcm_dma_params_t *params = prtd->params; struct at91_pcm_dma_params *params = prtd->params;
int ret = 0; int ret = 0;
switch (cmd) { switch (cmd) {
case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_START:
prtd->period_ptr = prtd->dma_buffer; prtd->period_ptr = prtd->dma_buffer;
at91_ssc_write(params->pdc->xpr, prtd->period_ptr); at91_ssc_write(params->ssc_base + params->pdc->xpr, prtd->period_ptr);
at91_ssc_write(params->pdc->xcr, at91_ssc_write(params->ssc_base + params->pdc->xcr,
prtd->period_size / params->pdc_xfer_size); prtd->period_size / params->pdc_xfer_size);
prtd->period_ptr += prtd->period_size; prtd->period_ptr += prtd->period_size;
at91_ssc_write(params->pdc->xnpr, prtd->period_ptr); at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->period_ptr);
at91_ssc_write(params->pdc->xncr, at91_ssc_write(params->ssc_base + params->pdc->xncr,
prtd->period_size / params->pdc_xfer_size); prtd->period_size / params->pdc_xfer_size);
DBG("trigger: period_ptr=%lx, xpr=%lx, xcr=%ld, xnpr=%lx, xncr=%ld\n", DBG("trigger: period_ptr=%lx, xpr=%lx, xcr=%ld, xnpr=%lx, xncr=%ld\n",
(unsigned long) prtd->period_ptr, (unsigned long) prtd->period_ptr,
at91_ssc_read(params->pdc->xpr), at91_ssc_read(params->ssc_base + params->pdc->xpr),
at91_ssc_read(params->pdc->xcr), at91_ssc_read(params->ssc_base + params->pdc->xcr),
at91_ssc_read(params->pdc->xnpr), at91_ssc_read(params->ssc_base + params->pdc->xnpr),
at91_ssc_read(params->pdc->xncr)); at91_ssc_read(params->ssc_base + params->pdc->xncr));
at91_ssc_write(params->ssc->ier, at91_ssc_write(params->ssc_base + AT91_SSC_IER,
params->mask->ssc_endx | params->mask->ssc_endbuf); params->mask->ssc_endx | params->mask->ssc_endbuf);
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_enable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_enable);
DBG("sr=%lx imr=%lx\n", at91_ssc_read(params->ssc->ier - 4), DBG("sr=%lx imr=%lx\n", at91_ssc_read(params->ssc_base + AT91_SSC_SR),
at91_ssc_read(params->ssc->ier + 8)); at91_ssc_read(params->ssc_base + AT91_SSC_IER));
break; break;
case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND: case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH: case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_disable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_disable);
break; break;
case SNDRV_PCM_TRIGGER_RESUME: case SNDRV_PCM_TRIGGER_RESUME:
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_enable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_enable);
break; break;
default: default:
@ -217,16 +216,16 @@ static int at91rm9200_pcm_trigger(struct snd_pcm_substream *substream,
return ret; return ret;
} }
static snd_pcm_uframes_t at91rm9200_pcm_pointer( static snd_pcm_uframes_t at91_pcm_pointer(
struct snd_pcm_substream *substream) struct snd_pcm_substream *substream)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct at91rm9200_runtime_data *prtd = runtime->private_data; struct at91_runtime_data *prtd = runtime->private_data;
at91rm9200_pcm_dma_params_t *params = prtd->params; struct at91_pcm_dma_params *params = prtd->params;
dma_addr_t ptr; dma_addr_t ptr;
snd_pcm_uframes_t x; snd_pcm_uframes_t x;
ptr = (dma_addr_t) at91_ssc_read(params->pdc->xpr); ptr = (dma_addr_t) at91_ssc_read(params->ssc_base + params->pdc->xpr);
x = bytes_to_frames(runtime, ptr - prtd->dma_buffer); x = bytes_to_frames(runtime, ptr - prtd->dma_buffer);
if (x == runtime->buffer_size) if (x == runtime->buffer_size)
@ -234,20 +233,20 @@ static snd_pcm_uframes_t at91rm9200_pcm_pointer(
return x; return x;
} }
static int at91rm9200_pcm_open(struct snd_pcm_substream *substream) static int at91_pcm_open(struct snd_pcm_substream *substream)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
struct at91rm9200_runtime_data *prtd; struct at91_runtime_data *prtd;
int ret = 0; int ret = 0;
snd_soc_set_runtime_hwparams(substream, &at91rm9200_pcm_hardware); snd_soc_set_runtime_hwparams(substream, &at91_pcm_hardware);
/* ensure that buffer size is a multiple of period size */ /* ensure that buffer size is a multiple of period size */
ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
if (ret < 0) if (ret < 0)
goto out; goto out;
prtd = kzalloc(sizeof(struct at91rm9200_runtime_data), GFP_KERNEL); prtd = kzalloc(sizeof(struct at91_runtime_data), GFP_KERNEL);
if (prtd == NULL) { if (prtd == NULL) {
ret = -ENOMEM; ret = -ENOMEM;
goto out; goto out;
@ -258,15 +257,15 @@ static int at91rm9200_pcm_open(struct snd_pcm_substream *substream)
return ret; return ret;
} }
static int at91rm9200_pcm_close(struct snd_pcm_substream *substream) static int at91_pcm_close(struct snd_pcm_substream *substream)
{ {
struct at91rm9200_runtime_data *prtd = substream->runtime->private_data; struct at91_runtime_data *prtd = substream->runtime->private_data;
kfree(prtd); kfree(prtd);
return 0; return 0;
} }
static int at91rm9200_pcm_mmap(struct snd_pcm_substream *substream, static int at91_pcm_mmap(struct snd_pcm_substream *substream,
struct vm_area_struct *vma) struct vm_area_struct *vma)
{ {
struct snd_pcm_runtime *runtime = substream->runtime; struct snd_pcm_runtime *runtime = substream->runtime;
@ -277,24 +276,24 @@ static int at91rm9200_pcm_mmap(struct snd_pcm_substream *substream,
runtime->dma_bytes); runtime->dma_bytes);
} }
struct snd_pcm_ops at91rm9200_pcm_ops = { struct snd_pcm_ops at91_pcm_ops = {
.open = at91rm9200_pcm_open, .open = at91_pcm_open,
.close = at91rm9200_pcm_close, .close = at91_pcm_close,
.ioctl = snd_pcm_lib_ioctl, .ioctl = snd_pcm_lib_ioctl,
.hw_params = at91rm9200_pcm_hw_params, .hw_params = at91_pcm_hw_params,
.hw_free = at91rm9200_pcm_hw_free, .hw_free = at91_pcm_hw_free,
.prepare = at91rm9200_pcm_prepare, .prepare = at91_pcm_prepare,
.trigger = at91rm9200_pcm_trigger, .trigger = at91_pcm_trigger,
.pointer = at91rm9200_pcm_pointer, .pointer = at91_pcm_pointer,
.mmap = at91rm9200_pcm_mmap, .mmap = at91_pcm_mmap,
}; };
static int at91rm9200_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, static int at91_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
int stream) int stream)
{ {
struct snd_pcm_substream *substream = pcm->streams[stream].substream; struct snd_pcm_substream *substream = pcm->streams[stream].substream;
struct snd_dma_buffer *buf = &substream->dma_buffer; struct snd_dma_buffer *buf = &substream->dma_buffer;
size_t size = at91rm9200_pcm_hardware.buffer_bytes_max; size_t size = at91_pcm_hardware.buffer_bytes_max;
buf->dev.type = SNDRV_DMA_TYPE_DEV; buf->dev.type = SNDRV_DMA_TYPE_DEV;
buf->dev.dev = pcm->card->dev; buf->dev.dev = pcm->card->dev;
@ -314,27 +313,27 @@ static int at91rm9200_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
return 0; return 0;
} }
static u64 at91rm9200_pcm_dmamask = 0xffffffff; static u64 at91_pcm_dmamask = 0xffffffff;
static int at91rm9200_pcm_new(struct snd_card *card, static int at91_pcm_new(struct snd_card *card,
struct snd_soc_codec_dai *dai, struct snd_pcm *pcm) struct snd_soc_codec_dai *dai, struct snd_pcm *pcm)
{ {
int ret = 0; int ret = 0;
if (!card->dev->dma_mask) if (!card->dev->dma_mask)
card->dev->dma_mask = &at91rm9200_pcm_dmamask; card->dev->dma_mask = &at91_pcm_dmamask;
if (!card->dev->coherent_dma_mask) if (!card->dev->coherent_dma_mask)
card->dev->coherent_dma_mask = 0xffffffff; card->dev->coherent_dma_mask = 0xffffffff;
if (dai->playback.channels_min) { if (dai->playback.channels_min) {
ret = at91rm9200_pcm_preallocate_dma_buffer(pcm, ret = at91_pcm_preallocate_dma_buffer(pcm,
SNDRV_PCM_STREAM_PLAYBACK); SNDRV_PCM_STREAM_PLAYBACK);
if (ret) if (ret)
goto out; goto out;
} }
if (dai->capture.channels_min) { if (dai->capture.channels_min) {
ret = at91rm9200_pcm_preallocate_dma_buffer(pcm, ret = at91_pcm_preallocate_dma_buffer(pcm,
SNDRV_PCM_STREAM_CAPTURE); SNDRV_PCM_STREAM_CAPTURE);
if (ret) if (ret)
goto out; goto out;
@ -343,7 +342,7 @@ static int at91rm9200_pcm_new(struct snd_card *card,
return ret; return ret;
} }
static void at91rm9200_pcm_free_dma_buffers(struct snd_pcm *pcm) static void at91_pcm_free_dma_buffers(struct snd_pcm *pcm)
{ {
struct snd_pcm_substream *substream; struct snd_pcm_substream *substream;
struct snd_dma_buffer *buf; struct snd_dma_buffer *buf;
@ -364,12 +363,12 @@ static void at91rm9200_pcm_free_dma_buffers(struct snd_pcm *pcm)
} }
} }
static int at91rm9200_pcm_suspend(struct platform_device *pdev, static int at91_pcm_suspend(struct platform_device *pdev,
struct snd_soc_cpu_dai *dai) struct snd_soc_cpu_dai *dai)
{ {
struct snd_pcm_runtime *runtime = dai->runtime; struct snd_pcm_runtime *runtime = dai->runtime;
struct at91rm9200_runtime_data *prtd; struct at91_runtime_data *prtd;
at91rm9200_pcm_dma_params_t *params; struct at91_pcm_dma_params *params;
if (!runtime) if (!runtime)
return 0; return 0;
@ -379,22 +378,22 @@ static int at91rm9200_pcm_suspend(struct platform_device *pdev,
/* disable the PDC and save the PDC registers */ /* disable the PDC and save the PDC registers */
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_disable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_disable);
prtd->pdc_xpr_save = at91_ssc_read(params->pdc->xpr); prtd->pdc_xpr_save = at91_ssc_read(params->ssc_base + params->pdc->xpr);
prtd->pdc_xcr_save = at91_ssc_read(params->pdc->xcr); prtd->pdc_xcr_save = at91_ssc_read(params->ssc_base + params->pdc->xcr);
prtd->pdc_xnpr_save = at91_ssc_read(params->pdc->xnpr); prtd->pdc_xnpr_save = at91_ssc_read(params->ssc_base + params->pdc->xnpr);
prtd->pdc_xncr_save = at91_ssc_read(params->pdc->xncr); prtd->pdc_xncr_save = at91_ssc_read(params->ssc_base + params->pdc->xncr);
return 0; return 0;
} }
static int at91rm9200_pcm_resume(struct platform_device *pdev, static int at91_pcm_resume(struct platform_device *pdev,
struct snd_soc_cpu_dai *dai) struct snd_soc_cpu_dai *dai)
{ {
struct snd_pcm_runtime *runtime = dai->runtime; struct snd_pcm_runtime *runtime = dai->runtime;
struct at91rm9200_runtime_data *prtd; struct at91_runtime_data *prtd;
at91rm9200_pcm_dma_params_t *params; struct at91_pcm_dma_params *params;
if (!runtime) if (!runtime)
return 0; return 0;
@ -403,26 +402,26 @@ static int at91rm9200_pcm_resume(struct platform_device *pdev,
params = prtd->params; params = prtd->params;
/* restore the PDC registers and enable the PDC */ /* restore the PDC registers and enable the PDC */
at91_ssc_write(params->pdc->xpr, prtd->pdc_xpr_save); at91_ssc_write(params->ssc_base + params->pdc->xpr, prtd->pdc_xpr_save);
at91_ssc_write(params->pdc->xcr, prtd->pdc_xcr_save); at91_ssc_write(params->ssc_base + params->pdc->xcr, prtd->pdc_xcr_save);
at91_ssc_write(params->pdc->xnpr, prtd->pdc_xnpr_save); at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->pdc_xnpr_save);
at91_ssc_write(params->pdc->xncr, prtd->pdc_xncr_save); at91_ssc_write(params->ssc_base + params->pdc->xncr, prtd->pdc_xncr_save);
at91_ssc_write(params->pdc->ptcr, params->mask->pdc_enable); at91_ssc_write(params->ssc_base + AT91_PDC_PTCR, params->mask->pdc_enable);
return 0; return 0;
} }
struct snd_soc_platform at91rm9200_soc_platform = { struct snd_soc_platform at91_soc_platform = {
.name = "at91rm9200-audio", .name = "at91-audio",
.pcm_ops = &at91rm9200_pcm_ops, .pcm_ops = &at91_pcm_ops,
.pcm_new = at91rm9200_pcm_new, .pcm_new = at91_pcm_new,
.pcm_free = at91rm9200_pcm_free_dma_buffers, .pcm_free = at91_pcm_free_dma_buffers,
.suspend = at91rm9200_pcm_suspend, .suspend = at91_pcm_suspend,
.resume = at91rm9200_pcm_resume, .resume = at91_pcm_resume,
}; };
EXPORT_SYMBOL_GPL(at91rm9200_soc_platform); EXPORT_SYMBOL_GPL(at91_soc_platform);
MODULE_AUTHOR("Frank Mandarino <fmandarino@endrelia.com>"); MODULE_AUTHOR("Frank Mandarino <fmandarino@endrelia.com>");
MODULE_DESCRIPTION("Atmel AT91RM9200 PCM module"); MODULE_DESCRIPTION("Atmel AT91 PCM module");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

54
sound/soc/at91/at91rm9200-pcm.h → sound/soc/at91/at91-pcm.h
View File

@ -1,5 +1,5 @@
/* /*
* at91rm9200-pcm.h - ALSA PCM interface for the Atmel AT91RM9200 chip * at91-pcm.h - ALSA PCM interface for the Atmel AT91 SoC
* *
* Author: Frank Mandarino <fmandarino@endrelia.com> * Author: Frank Mandarino <fmandarino@endrelia.com>
* Endrelia Technologies Inc. * Endrelia Technologies Inc.
@ -16,24 +16,26 @@
* published by the Free Software Foundation. * published by the Free Software Foundation.
*/ */
#include <asm/arch/hardware.h>
struct at91_ssc_periph {
void __iomem *base;
u32 pid;
};
/* /*
* Registers and status bits that are required by the PCM driver. * Registers and status bits that are required by the PCM driver.
*/ */
struct at91rm9200_ssc_regs { struct at91_pdc_regs {
void __iomem *cr; /* SSC control */ unsigned int xpr; /* PDC recv/trans pointer */
void __iomem *ier; /* SSC interrupt enable */ unsigned int xcr; /* PDC recv/trans counter */
void __iomem *idr; /* SSC interrupt disable */ unsigned int xnpr; /* PDC next recv/trans pointer */
unsigned int xncr; /* PDC next recv/trans counter */
unsigned int ptcr; /* PDC transfer control */
}; };
struct at91rm9200_pdc_regs { struct at91_ssc_mask {
void __iomem *xpr; /* PDC recv/trans pointer */
void __iomem *xcr; /* PDC recv/trans counter */
void __iomem *xnpr; /* PDC next recv/trans pointer */
void __iomem *xncr; /* PDC next recv/trans counter */
void __iomem *ptcr; /* PDC transfer control */
};
struct at91rm9200_ssc_mask {
u32 ssc_enable; /* SSC recv/trans enable */ u32 ssc_enable; /* SSC recv/trans enable */
u32 ssc_disable; /* SSC recv/trans disable */ u32 ssc_disable; /* SSC recv/trans disable */
u32 ssc_endx; /* SSC ENDTX or ENDRX */ u32 ssc_endx; /* SSC ENDTX or ENDRX */
@ -51,25 +53,19 @@ struct at91rm9200_ssc_mask {
* driver and called by the interface SSC interrupt handler if it is * driver and called by the interface SSC interrupt handler if it is
* non-NULL. * non-NULL.
*/ */
typedef struct { struct at91_pcm_dma_params {
char *name; /* stream identifier */ char *name; /* stream identifier */
int pdc_xfer_size; /* PDC counter increment in bytes */ int pdc_xfer_size; /* PDC counter increment in bytes */
struct at91rm9200_ssc_regs *ssc; /* SSC register addresses */ void __iomem *ssc_base; /* SSC base address */
struct at91rm9200_pdc_regs *pdc; /* PDC receive/transmit registers */ struct at91_pdc_regs *pdc; /* PDC receive or transmit registers */
struct at91rm9200_ssc_mask *mask;/* SSC & PDC status bits */ struct at91_ssc_mask *mask;/* SSC & PDC status bits */
snd_pcm_substream_t *substream; struct snd_pcm_substream *substream;
void (*dma_intr_handler)(u32, snd_pcm_substream_t *); void (*dma_intr_handler)(u32, struct snd_pcm_substream *);
} at91rm9200_pcm_dma_params_t; };
extern struct snd_soc_cpu_dai at91rm9200_i2s_dai[3]; extern struct snd_soc_cpu_dai at91_i2s_dai[3];
extern struct snd_soc_platform at91rm9200_soc_platform; extern struct snd_soc_platform at91_soc_platform;
/*
* SSC I/O helpers.
* E.g., at91_ssc_write(AT91_SSC(1) + AT91_SSC_CR, AT91_SSC_RXEN);
*/
#define AT91_SSC(x) (((x)==0) ? AT91_VA_BASE_SSC0 :\
((x)==1) ? AT91_VA_BASE_SSC1 : ((x)==2) ? AT91_VA_BASE_SSC2 : NULL)
#define at91_ssc_read(a) ((unsigned long) __raw_readl(a)) #define at91_ssc_read(a) ((unsigned long) __raw_readl(a))
#define at91_ssc_write(a,v) __raw_writel((v),(a)) #define at91_ssc_write(a,v) __raw_writel((v),(a))

64
sound/soc/at91/eti_b1_wm8731.c
View File

@ -1,5 +1,5 @@
/* /*
* eti_b1_wm8731 -- SoC audio for Endrelia ETI_B1. * eti_b1_wm8731 -- SoC audio for AT91RM9200-based Endrelia ETI_B1 board.
* *
* Author: Frank Mandarino <fmandarino@endrelia.com> * Author: Frank Mandarino <fmandarino@endrelia.com>
* Endrelia Technologies Inc. * Endrelia Technologies Inc.
@ -37,12 +37,12 @@
#include <sound/soc.h> #include <sound/soc.h>
#include <sound/soc-dapm.h> #include <sound/soc-dapm.h>
#include <asm/arch/at91rm9200.h>
#include <asm/arch/gpio.h>
#include <asm/arch/hardware.h> #include <asm/arch/hardware.h>
#include <asm/arch/at91_pio.h>
#include <asm/arch/gpio.h>
#include "../codecs/wm8731.h" #include "../codecs/wm8731.h"
#include "at91rm9200-pcm.h" #include "at91-pcm.h"
#if 0 #if 0
#define DBG(x...) printk(KERN_INFO "eti_b1_wm8731:" x) #define DBG(x...) printk(KERN_INFO "eti_b1_wm8731:" x)
@ -50,10 +50,18 @@
#define DBG(x...) #define DBG(x...)
#endif #endif
#define AT91_PIO_TF1 (1 << (AT91_PIN_PB6 - PIN_BASE) % 32)
#define AT91_PIO_TK1 (1 << (AT91_PIN_PB7 - PIN_BASE) % 32)
#define AT91_PIO_TD1 (1 << (AT91_PIN_PB8 - PIN_BASE) % 32)
#define AT91_PIO_RD1 (1 << (AT91_PIN_PB9 - PIN_BASE) % 32)
#define AT91_PIO_RK1 (1 << (AT91_PIN_PB10 - PIN_BASE) % 32)
#define AT91_PIO_RF1 (1 << (AT91_PIN_PB11 - PIN_BASE) % 32)
static struct clk *pck1_clk; static struct clk *pck1_clk;
static struct clk *pllb_clk; static struct clk *pllb_clk;
static int eti_b1_startup(snd_pcm_substream_t *substream) static int eti_b1_startup(struct snd_pcm_substream *substream)
{ {
/* Start PCK1 clock. */ /* Start PCK1 clock. */
clk_enable(pck1_clk); clk_enable(pck1_clk);
@ -62,7 +70,7 @@ static int eti_b1_startup(snd_pcm_substream_t *substream)
return 0; return 0;
} }
static void eti_b1_shutdown(snd_pcm_substream_t *substream) static void eti_b1_shutdown(struct snd_pcm_substream *substream)
{ {
/* Stop PCK1 clock. */ /* Stop PCK1 clock. */
clk_disable(pck1_clk); clk_disable(pck1_clk);
@ -138,7 +146,7 @@ unsigned int eti_b1_config_sysclk(struct snd_soc_pcm_runtime *rtd,
static struct snd_soc_dai_link eti_b1_dai = { static struct snd_soc_dai_link eti_b1_dai = {
.name = "WM8731", .name = "WM8731",
.stream_name = "WM8731", .stream_name = "WM8731",
.cpu_dai = &at91rm9200_i2s_dai[1], .cpu_dai = &at91_i2s_dai[1],
.codec_dai = &wm8731_dai, .codec_dai = &wm8731_dai,
.init = eti_b1_wm8731_init, .init = eti_b1_wm8731_init,
.config_sysclk = eti_b1_config_sysclk, .config_sysclk = eti_b1_config_sysclk,
@ -157,7 +165,7 @@ static struct wm8731_setup_data eti_b1_wm8731_setup = {
static struct snd_soc_device eti_b1_snd_devdata = { static struct snd_soc_device eti_b1_snd_devdata = {
.machine = &snd_soc_machine_eti_b1, .machine = &snd_soc_machine_eti_b1,
.platform = &at91rm9200_soc_platform, .platform = &at91_soc_platform,
.codec_dev = &soc_codec_dev_wm8731, .codec_dev = &soc_codec_dev_wm8731,
.codec_data = &eti_b1_wm8731_setup, .codec_data = &eti_b1_wm8731_setup,
}; };
@ -168,22 +176,41 @@ static int __init eti_b1_init(void)
{ {
int ret; int ret;
u32 ssc_pio_lines; u32 ssc_pio_lines;
struct at91_ssc_periph *ssc = eti_b1_dai.cpu_dai->private_data;
if (!request_mem_region(AT91RM9200_BASE_SSC1, SZ_16K, "soc-audio")) {
DBG("SSC1 memory region is busy\n");
return -EBUSY;
}
ssc->base = ioremap(AT91RM9200_BASE_SSC1, SZ_16K);
if (!ssc->base) {
DBG("SSC1 memory ioremap failed\n");
ret = -ENOMEM;
goto fail_release_mem;
}
ssc->pid = AT91RM9200_ID_SSC1;
eti_b1_snd_device = platform_device_alloc("soc-audio", -1); eti_b1_snd_device = platform_device_alloc("soc-audio", -1);
if (!eti_b1_snd_device) if (!eti_b1_snd_device) {
return -ENOMEM; DBG("platform device allocation failed\n");
ret = -ENOMEM;
goto fail_io_unmap;
}
platform_set_drvdata(eti_b1_snd_device, &eti_b1_snd_devdata); platform_set_drvdata(eti_b1_snd_device, &eti_b1_snd_devdata);
eti_b1_snd_devdata.dev = &eti_b1_snd_device->dev; eti_b1_snd_devdata.dev = &eti_b1_snd_device->dev;
ret = platform_device_add(eti_b1_snd_device); ret = platform_device_add(eti_b1_snd_device);
if (ret) { if (ret) {
DBG("platform device add failed\n");
platform_device_put(eti_b1_snd_device); platform_device_put(eti_b1_snd_device);
return ret; goto fail_io_unmap;
} }
ssc_pio_lines = AT91_PB6_TF1 | AT91_PB7_TK1 | AT91_PB8_TD1 ssc_pio_lines = AT91_PIO_TF1 | AT91_PIO_TK1 | AT91_PIO_TD1
| AT91_PB9_RD1 /* | AT91_PB10_RK1 | AT91_PB11_RF1 */; | AT91_PIO_RD1 /* | AT91_PIO_RK1 | AT91_PIO_RF1 */;
/* Reset all PIO registers and assign lines to peripheral A */ /* Reset all PIO registers and assign lines to peripheral A */
at91_sys_write(AT91_PIOB + PIO_PDR, ssc_pio_lines); at91_sys_write(AT91_PIOB + PIO_PDR, ssc_pio_lines);
@ -211,14 +238,25 @@ static int __init eti_b1_init(void)
at91_set_B_periph(AT91_PIN_PA24, 0); at91_set_B_periph(AT91_PIN_PA24, 0);
return ret; return ret;
fail_io_unmap:
iounmap(ssc->base);
fail_release_mem:
release_mem_region(AT91RM9200_BASE_SSC1, SZ_16K);
return ret;
} }
static void __exit eti_b1_exit(void) static void __exit eti_b1_exit(void)
{ {
struct at91_ssc_periph *ssc = eti_b1_dai.cpu_dai->private_data;
clk_put(pck1_clk); clk_put(pck1_clk);
clk_put(pllb_clk); clk_put(pllb_clk);
platform_device_unregister(eti_b1_snd_device); platform_device_unregister(eti_b1_snd_device);
iounmap(ssc->base);
release_mem_region(AT91RM9200_BASE_SSC1, SZ_16K);
} }
module_init(eti_b1_init); module_init(eti_b1_init);