[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>

5 files changed, 361 insertions, 370 deletions

diff --git a/sound/soc/at91/Makefile b/sound/soc/at91/Makefile
index eb12ea2..b77b01a 100644
--- a/sound/soc/at91/Makefile
+++ b/sound/soc/at91/Makefile
@@ -1,6 +1,6 @@
 # AT91 Platform Support
-snd-soc-at91-objs := at91rm9200-pcm.o
-snd-soc-at91-i2s-objs := at91rm9200-i2s.o
+snd-soc-at91-objs := at91-pcm.o
+snd-soc-at91-i2s-objs := at91-i2s.o
 
 obj-$(CONFIG_SND_AT91_SOC) += snd-soc-at91.o
 obj-$(CONFIG_SND_AT91_SOC_I2S) += snd-soc-at91-i2s.o
diff --git a/sound/soc/at91/at91rm9200-i2s.c b/sound/soc/at91/at91-i2s.c
index e3e6345..b452e8e 100644
--- a/sound/soc/at91/at91rm9200-i2s.c
+++ b/sound/soc/at91/at91-i2s.c
@@ -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>
  *         Endrelia Technologies Inc.
@@ -28,34 +28,41 @@
 #include <sound/initval.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/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
-#define	DBG(x...)	printk(KERN_DEBUG "at91rm9200-i2s:" x)
+#define	DBG(x...)	printk(KERN_DEBUG "at91-i2s:" x)
 #else
 #define	DBG(x...)
 #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)
 
-#define AT91RM9200_I2S_DIR \
+#define AT91_I2S_DIR \
 	(SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE)
 
 /* 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 */
 	{
-		.fmt = AT91RM9200_I2S_DAIFMT,
+		.fmt = AT91_I2S_DAIFMT,
 		.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
 		.pcmrate = SNDRV_PCM_RATE_8000,
-		.pcmdir = AT91RM9200_I2S_DIR,
+		.pcmdir = AT91_I2S_DIR,
 		.flags = SND_SOC_DAI_BFS_DIV,
 		.fs = 1500,
 		.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 */
 	{
-		.fmt = AT91RM9200_I2S_DAIFMT,
+		.fmt = AT91_I2S_DAIFMT,
 		.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
 		.pcmrate = SNDRV_PCM_RATE_16000,
-		.pcmdir = AT91RM9200_I2S_DIR,
+		.pcmdir = AT91_I2S_DIR,
 		.flags = SND_SOC_DAI_BFS_DIV,
 		.fs = 750,
 		.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 */
 	{
-		.fmt = AT91RM9200_I2S_DAIFMT,
+		.fmt = AT91_I2S_DAIFMT,
 		.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
 		.pcmrate = SNDRV_PCM_RATE_32000,
-		.pcmdir = AT91RM9200_I2S_DIR,
+		.pcmdir = AT91_I2S_DIR,
 		.flags = SND_SOC_DAI_BFS_DIV,
 		.fs = 375,
 		.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 */
 	{
-		.fmt = AT91RM9200_I2S_DAIFMT,
+		.fmt = AT91_I2S_DAIFMT,
 		.pcmfmt = SNDRV_PCM_FMTBIT_S16_LE,
 		.pcmrate = SNDRV_PCM_RATE_48000,
-		.pcmdir = AT91RM9200_I2S_DIR,
+		.pcmdir = AT91_I2S_DIR,
 		.flags = SND_SOC_DAI_BFS_DIV,
 		.fs = 250,
 		.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] = {
-	{
-	.cr	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_CR),
-	.ier	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_IER),
-	.idr	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_SSC_IDR),
-	},
-	{
-	.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] = {
-	{
-	.xpr	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TPR),
-	.xcr	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TCR),
-	.xnpr	= (void __iomem *) (AT91_VA_BASE_SSC0 + AT91_PDC_TNPR),
-	.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 at91_pdc_regs pdc_tx_reg = {
+	.xpr		= AT91_PDC_TPR,
+	.xcr		= AT91_PDC_TCR,
+	.xnpr		= AT91_PDC_TNPR,
+	.xncr		= AT91_PDC_TNCR,
 };
 
-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),
-	},
+static struct at91_pdc_regs pdc_rx_reg = {
+	.xpr		= AT91_PDC_RPR,
+	.xcr		= AT91_PDC_RCR,
+	.xnpr		= AT91_PDC_RNPR,
+	.xncr		= AT91_PDC_RNCR,
 };
 
 /*
  * 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_disable	= AT91_SSC_TXDIS,
 	.ssc_endx	= AT91_SSC_ENDTX,
@@ -181,7 +136,7 @@ static struct at91rm9200_ssc_mask ssc_tx_mask = {
 	.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_disable	= AT91_SSC_RXDIS,
 	.ssc_endx	= AT91_SSC_ENDRX,
@@ -190,61 +145,61 @@ static struct at91rm9200_ssc_mask ssc_rx_mask = {
 	.pdc_disable	= AT91_PDC_RXTDIS,
 };
 
-/*
- * A MUTEX is used to protect an SSC initialzed flag which allows
- * the substream hw_params() call to initialize the SSC only if
- * there are no other substreams open.  If there are other
- * substreams open, the hw_param() call can only check that
- * it is using the same format and rate.
- */
-static DECLARE_MUTEX(ssc0_mutex);
-static DECLARE_MUTEX(ssc1_mutex);
-static DECLARE_MUTEX(ssc2_mutex);
 
 /*
  * DMA parameters.
  */
-static at91rm9200_pcm_dma_params_t ssc_dma_params[3][2] = {
+static struct at91_pcm_dma_params ssc_dma_params[NUM_SSC_DEVICES][2] = {
 	{{
 	.name		= "SSC0/I2S PCM Stereo out",
-	.ssc		= &ssc_reg[0],
-	.pdc		= &pdc_tx_reg[0],
+	.pdc		= &pdc_tx_reg,
 	.mask		= &ssc_tx_mask,
 	},
 	{
 	.name		= "SSC0/I2S PCM Stereo in",
-	.ssc		= &ssc_reg[0],
-	.pdc		= &pdc_rx_reg[0],
+	.pdc		= &pdc_rx_reg,
 	.mask		= &ssc_rx_mask,
 	}},
+#if NUM_SSC_DEVICES == 3
 	{{
 	.name		= "SSC1/I2S PCM Stereo out",
-	.ssc		= &ssc_reg[1],
-	.pdc		= &pdc_tx_reg[1],
+	.pdc		= &pdc_tx_reg,
 	.mask		= &ssc_tx_mask,
 	},
 	{
 	.name		= "SSC1/I2S PCM Stereo in",
-	.ssc		= &ssc_reg[1],
-	.pdc		= &pdc_rx_reg[1],
+	.pdc		= &pdc_rx_reg,
 	.mask		= &ssc_rx_mask,
 	}},
 	{{
 	.name		= "SSC2/I2S PCM Stereo out",
-	.ssc		= &ssc_reg[2],
-	.pdc		= &pdc_tx_reg[2],
+	.pdc		= &pdc_tx_reg,
 	.mask		= &ssc_tx_mask,
 	},
 	{
 	.name		= "SSC1/I2S PCM Stereo in",
-	.ssc		= &ssc_reg[2],
-	.pdc		= &pdc_rx_reg[2],
+	.pdc		= &pdc_rx_reg,
 	.mask		= &ssc_rx_mask,
 	}},
+#endif
 };
 
 
-struct at91rm9200_ssc_state {
+/*
+ * A MUTEX is used to protect an SSC initialzed flag which allows
+ * the substream hw_params() call to initialize the SSC only if
+ * there are no other substreams open.  If there are other
+ * substreams open, the hw_param() call can only check that
+ * it is using the same format and rate.
+ */
+static DECLARE_MUTEX(ssc0_mutex);
+#if NUM_SSC_DEVICES == 3
+static DECLARE_MUTEX(ssc1_mutex);
+static DECLARE_MUTEX(ssc2_mutex);
+#endif
+
+
+struct at91_ssc_state {
 	u32	ssc_cmr;
 	u32	ssc_rcmr;
 	u32	ssc_rfmr;
@@ -254,33 +209,30 @@ struct at91rm9200_ssc_state {
 	u32	ssc_imr;
 };
 
-static struct at91rm9200_ssc_info {
+
+static struct at91_ssc_info {
 	char		*name;
-	void __iomem    *ssc_base;
-	u32		pid;
+	struct at91_ssc_periph ssc;
 	spinlock_t 	lock;		/* lock for dir_mask */
 	int		dir_mask;	/* 0=unused, 1=playback, 2=capture */
 	struct semaphore *mutex;
 	int		initialized;
 	int		pcmfmt;
 	int		rate;
-	at91rm9200_pcm_dma_params_t *dma_params[2];
-	struct at91rm9200_ssc_state ssc_state;
+	struct at91_pcm_dma_params *dma_params[2];
+	struct at91_ssc_state ssc_state;
 
-} ssc_info[3] = {
+} ssc_info[NUM_SSC_DEVICES] = {
 	{
 	.name		= "ssc0",
-	.ssc_base	= (void __iomem *) AT91_VA_BASE_SSC0,
-	.pid		= AT91_ID_SSC0,
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.dir_mask	= 0,
 	.mutex		= &ssc0_mutex,
 	.initialized	= 0,
 	},
+#if NUM_SSC_DEVICES == 3
 	{
 	.name		= "ssc1",
-	.ssc_base	= (void __iomem *) AT91_VA_BASE_SSC1,
-	.pid		= AT91_ID_SSC1,
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.dir_mask	= 0,
 	.mutex		= &ssc1_mutex,
@@ -288,25 +240,24 @@ static struct at91rm9200_ssc_info {
 	},
 	{
 	.name		= "ssc2",
-	.ssc_base	= (void __iomem *) AT91_VA_BASE_SSC2,
-	.pid		= AT91_ID_SSC2,
 	.lock		= SPIN_LOCK_UNLOCKED,
 	.dir_mask	= 0,
 	.mutex		= &ssc2_mutex,
 	.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;
-	at91rm9200_pcm_dma_params_t *dma_params;
+	struct at91_ssc_info *ssc_p = dev_id;
+	struct at91_pcm_dma_params *dma_params;
 	u32 ssc_sr;
 	int i;
 
-	ssc_sr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR)
-			& at91_ssc_read(ssc_p->ssc_base + AT91_SSC_IMR);
+	ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR)
+			& at91_ssc_read(ssc_p->ssc.base + AT91_SSC_IMR);
 
 	/*
 	 * 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;
 }
 
-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 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;
 
 	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;
 
 	spin_lock_irq(&ssc_p->lock);
@@ -348,20 +299,22 @@ static int at91rm9200_i2s_startup(struct snd_pcm_substream *substream)
 	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 at91rm9200_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id];
-	at91rm9200_pcm_dma_params_t *dma_params = rtd->cpu_dai->dma_data;
+	struct at91_ssc_info *ssc_p = &ssc_info[rtd->cpu_dai->id];
+	struct at91_pcm_dma_params *dma_params = rtd->cpu_dai->dma_data;
 	int dir, dir_mask;
 
 	dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
 
 	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"),
-			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;
 		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;
 	if (!ssc_p->dir_mask) {
 		/* Shutdown the SSC clock. */
-		DBG("Stopping pid %d clock\n", ssc_p->pid);
-		at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->pid);
+		DBG("Stopping pid %d clock\n", ssc_p->ssc.pid);
+		at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->ssc.pid);
 
 		if (ssc_p->initialized)
-			free_irq(ssc_p->pid, ssc_p);
+			free_irq(ssc_p->ssc.pid, ssc_p);
 
 		/* 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. */
 		ssc_p->initialized = 0;
@@ -388,10 +341,10 @@ static void at91rm9200_i2s_shutdown(struct snd_pcm_substream *substream)
 }
 
 #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 at91rm9200_ssc_info *ssc_p;
+	struct at91_ssc_info *ssc_p;
 
 	if(!dai->active)
 		return 0;
@@ -399,27 +352,27 @@ static int at91rm9200_i2s_suspend(struct platform_device *pdev,
 	ssc_p = &ssc_info[dai->id];
 
 	/* Save the status register before disabling transmit and receive. */
-	ssc_p->state->ssc_sr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_SR);
-	at91_ssc_write(ssc_p->ssc_base +
+	ssc_p->state->ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR);
+	at91_ssc_write(ssc_p->ssc.base +
 		AT91_SSC_CR, AT91_SSC_TXDIS | AT91_SSC_RXDIS);
 
 	/* Save the current interrupt mask, then disable unmasked interrupts. */
-	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);
+	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);
 
-	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_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_tfmr = at91_ssc_read(ssc_p->ssc_base + AT91_SSC_RCMR);
+	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_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_tfmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
 
 	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 at91rm9200_ssc_info *ssc_p;
+	struct at91_ssc_info *ssc_p;
 	u32 cr_mask;
 
 	if(!dai->active)
@@ -427,15 +380,15 @@ static int at91rm9200_i2s_resume(struct platform_device *pdev,
 
 	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_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_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_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_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_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_TXENA) ? AT91_SSC_TXEN : 0));
 
@@ -443,11 +396,11 @@ static int at91rm9200_i2s_resume(struct platform_device *pdev,
 }
 
 #else
-#define at91rm9200_i2s_suspend	NULL
-#define at91rm9200_i2s_resume	NULL
+#define at91_i2s_suspend	NULL
+#define at91_i2s_resume	NULL
 #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,
 	unsigned int clk)
 {
@@ -457,17 +410,16 @@ static unsigned int at91rm9200_i2s_config_sysclk(
 	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_soc_pcm_runtime *rtd = substream->private_data;
 	int id = rtd->cpu_dai->id;
-	struct at91rm9200_ssc_info *ssc_p = &ssc_info[id];
-	at91rm9200_pcm_dma_params_t *dma_params;
+	struct at91_ssc_info *ssc_p = &ssc_info[id];
+	struct at91_pcm_dma_params *dma_params;
 	unsigned int pcmfmt, rate;
 	int dir, channels, bits;
 	struct clk *mck_clk;
-	unsigned long bclk;
 	u32 div, period, tfmr, rfmr, tcmr, rcmr;
 	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;
 
 	dma_params = &ssc_dma_params[id][dir];
+	dma_params->ssc_base = ssc_p->ssc.base;
 	dma_params->substream = substream;
 
 	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;
 			break;
 		default:
-			printk(KERN_WARNING "at91rm9200-i2s: unsupported format %x\n",
+			printk(KERN_WARNING "at91-i2s: unsupported format %x\n",
 				pcmfmt);
 			return -EINVAL;
 	}
@@ -509,46 +462,45 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
 	 */
 	if (ssc_p->initialized) {
 		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");
 			up(ssc_p->mutex);
 			return -EINVAL;
 		}
 	} else {
 		/* Enable PMC peripheral clock for this SSC */
-		DBG("Starting pid %d clock\n", ssc_p->pid);
-		at91_sys_write(AT91_PMC_PCER, 1<<ssc_p->pid);
+		DBG("Starting pid %d clock\n", ssc_p->ssc.pid);
+		at91_sys_write(AT91_PMC_PCER, 1<<ssc_p->ssc.pid);
 
 		/* Reset the SSC */
-		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_RCR, 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_TPR, 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_TNCR, 0);
+		at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR, AT91_SSC_SWRST);
 
-		mck_clk = clk_get(NULL, "mck");
+		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_RNPR, 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_TCR, 0);
+		at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TNPR, 0);
+		at91_ssc_write(ssc_p->ssc.base + AT91_PDC_TNCR, 0);
 
 		div = rtd->cpu_dai->dai_runtime.priv >> 16;
 		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),
 			SND_SOC_FSBD(6),
 			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,
 			period);
 
 		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.
@@ -563,7 +515,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
 		| (( 0				<<  5) & AT91_SSC_DATDEF)
 		| (((bits - 1)			<<  0) & AT91_SSC_DATALEN);
 		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 =
 		  (( 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);
 
 		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
@@ -590,7 +542,7 @@ static int at91rm9200_i2s_hw_params(struct snd_pcm_substream *substream,
 		| (( AT91_SSC_CKS_DIV		     ) & AT91_SSC_CKS);
 
 		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 =
 		  (( 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);
 
 		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) {
-			printk(KERN_WARNING "at91rm9200-i2s: request_irq failure\n");
+			printk(KERN_WARNING "at91-i2s: request_irq failure\n");
 			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;
-	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",
 	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;
 }
 
 
-struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
-	{	.name = "at91rm9200-ssc0/i2s",
+struct snd_soc_cpu_dai at91_i2s_dai[NUM_SSC_DEVICES] = {
+	{	.name = "at91_ssc0/i2s",
 		.id = 0,
 		.type = SND_SOC_DAI_I2S,
-		.suspend = at91rm9200_i2s_suspend,
-		.resume = at91rm9200_i2s_resume,
-		.config_sysclk = at91rm9200_i2s_config_sysclk,
+		.suspend = at91_i2s_suspend,
+		.resume = at91_i2s_resume,
+		.config_sysclk = at91_i2s_config_sysclk,
 		.playback = {
 			.channels_min = 1,
 			.channels_max = 2,},
@@ -655,20 +608,22 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
 			.channels_min = 1,
 			.channels_max = 2,},
 		.ops = {
-			.startup = at91rm9200_i2s_startup,
-			.shutdown = at91rm9200_i2s_shutdown,
-			.prepare = at91rm9200_i2s_prepare,
-			.hw_params = at91rm9200_i2s_hw_params,},
+			.startup = at91_i2s_startup,
+			.shutdown = at91_i2s_shutdown,
+			.prepare = at91_i2s_prepare,
+			.hw_params = at91_i2s_hw_params,},
 		.caps = {
-			.mode = &at91rm9200_i2s[0],
-			.num_modes = ARRAY_SIZE(at91rm9200_i2s),},
+			.mode = &at91_i2s[0],
+			.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,
 		.type = SND_SOC_DAI_I2S,
-		.suspend = at91rm9200_i2s_suspend,
-		.resume = at91rm9200_i2s_resume,
-		.config_sysclk = at91rm9200_i2s_config_sysclk,
+		.suspend = at91_i2s_suspend,
+		.resume = at91_i2s_resume,
+		.config_sysclk = at91_i2s_config_sysclk,
 		.playback = {
 			.channels_min = 1,
 			.channels_max = 2,},
@@ -676,20 +631,21 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
 			.channels_min = 1,
 			.channels_max = 2,},
 		.ops = {
-			.startup = at91rm9200_i2s_startup,
-			.shutdown = at91rm9200_i2s_shutdown,
-			.prepare = at91rm9200_i2s_prepare,
-			.hw_params = at91rm9200_i2s_hw_params,},
+			.startup = at91_i2s_startup,
+			.shutdown = at91_i2s_shutdown,
+			.prepare = at91_i2s_prepare,
+			.hw_params = at91_i2s_hw_params,},
 		.caps = {
-			.mode = &at91rm9200_i2s[0],
-			.num_modes = ARRAY_SIZE(at91rm9200_i2s),},
+			.mode = &at91_i2s[0],
+			.num_modes = ARRAY_SIZE(at91_i2s),},
+		.private_data = &ssc_info[1].ssc,
 	},
-	{	.name = "at91rm9200-ssc2/i2s",
+	{	.name = "at91_ssc2/i2s",
 		.id = 2,
 		.type = SND_SOC_DAI_I2S,
-		.suspend = at91rm9200_i2s_suspend,
-		.resume = at91rm9200_i2s_resume,
-		.config_sysclk = at91rm9200_i2s_config_sysclk,
+		.suspend = at91_i2s_suspend,
+		.resume = at91_i2s_resume,
+		.config_sysclk = at91_i2s_config_sysclk,
 		.playback = {
 			.channels_min = 1,
 			.channels_max = 2,},
@@ -697,19 +653,21 @@ struct snd_soc_cpu_dai at91rm9200_i2s_dai[] = {
 			.channels_min = 1,
 			.channels_max = 2,},
 		.ops = {
-			.startup = at91rm9200_i2s_startup,
-			.shutdown = at91rm9200_i2s_shutdown,
-			.prepare = at91rm9200_i2s_prepare,
-			.hw_params = at91rm9200_i2s_hw_params,},
+			.startup = at91_i2s_startup,
+			.shutdown = at91_i2s_shutdown,
+			.prepare = at91_i2s_prepare,
+			.hw_params = at91_i2s_hw_params,},
 		.caps = {
-			.mode = &at91rm9200_i2s[0],
-			.num_modes = ARRAY_SIZE(at91rm9200_i2s),},
+			.mode = &at91_i2s[0],
+			.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_AUTHOR("Frank Mandarino, fmandarino@endrelia.com, www.endrelia.com");
-MODULE_DESCRIPTION("AT91RM9200 I2S ASoC Interface");
+MODULE_DESCRIPTION("AT91 I2S ASoC Interface");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/at91/at91rm9200-pcm.c b/sound/soc/at91/at91-pcm.c
index 237bc5f..fd9d732 100644
--- a/sound/soc/at91/at91rm9200-pcm.c
+++ b/sound/soc/at91/at91-pcm.c
@@ -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>
  *		Endrelia Technologies Inc.
@@ -28,20 +28,19 @@
 #include <sound/pcm_params.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/at91_ssc.h>
+#include <asm/arch/at91_pdc.h>
 
-#include "at91rm9200-pcm.h"
+#include "at91-pcm.h"
 
 #if 0
-#define	DBG(x...)	printk(KERN_INFO "at91rm9200-pcm: " x)
+#define	DBG(x...)	printk(KERN_INFO "at91-pcm: " x)
 #else
 #define	DBG(x...)
 #endif
 
-static const snd_pcm_hardware_t at91rm9200_pcm_hardware = {
+static const struct snd_pcm_hardware at91_pcm_hardware = {
 	.info			= SNDRV_PCM_INFO_MMAP |
 				  SNDRV_PCM_INFO_MMAP_VALID |
 				  SNDRV_PCM_INFO_INTERLEAVED |
@@ -54,8 +53,8 @@ static const snd_pcm_hardware_t at91rm9200_pcm_hardware = {
 	.buffer_bytes_max	= 32 * 1024,
 };
 
-struct at91rm9200_runtime_data {
-	at91rm9200_pcm_dma_params_t *params;
+struct at91_runtime_data {
+	struct at91_pcm_dma_params *params;
 	dma_addr_t dma_buffer;			/* physical address of dma buffer */
 	dma_addr_t dma_buffer_end;		/* first address beyond DMA buffer */
 	size_t period_size;
@@ -66,11 +65,11 @@ struct at91rm9200_runtime_data {
 	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 at91rm9200_runtime_data *prtd = substream->runtime->private_data;
-	at91rm9200_pcm_dma_params_t *params = prtd->params;
+	struct at91_runtime_data *prtd = substream->runtime->private_data;
+	struct at91_pcm_dma_params *params = prtd->params;
 	static int count = 0;
 
 	count++;
@@ -78,24 +77,24 @@ static void at91rm9200_pcm_dma_irq(u32 ssc_sr,
 	if (ssc_sr & params->mask->ssc_endbuf) {
 
 		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
 				? "underrun" : "overrun",
 			params->name, ssc_sr, count);
 
 		/* 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;
 		if (prtd->period_ptr >= prtd->dma_buffer_end) {
 			prtd->period_ptr = prtd->dma_buffer;
 		}
 
-		at91_ssc_write(params->pdc->xpr, prtd->period_ptr);
-		at91_ssc_write(params->pdc->xcr,
+		at91_ssc_write(params->ssc_base + params->pdc->xpr, prtd->period_ptr);
+		at91_ssc_write(params->ssc_base + params->pdc->xcr,
 				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) {
@@ -105,19 +104,19 @@ static void at91rm9200_pcm_dma_irq(u32 ssc_sr,
 		if (prtd->period_ptr >= prtd->dma_buffer_end) {
 			prtd->period_ptr = prtd->dma_buffer;
 		}
-		at91_ssc_write(params->pdc->xnpr, prtd->period_ptr);
-		at91_ssc_write(params->pdc->xncr,
+		at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->period_ptr);
+		at91_ssc_write(params->ssc_base + params->pdc->xncr,
 				prtd->period_size / params->pdc_xfer_size);
 	}
 
 	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)
 {
-	snd_pcm_runtime_t *runtime = substream->runtime;
-	struct at91rm9200_runtime_data *prtd = runtime->private_data;
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct at91_runtime_data *prtd = runtime->private_data;
 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
 
 	/* 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);
 
 	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_end = runtime->dma_addr + runtime->dma_bytes;
@@ -138,76 +137,76 @@ static int at91rm9200_pcm_hw_params(struct snd_pcm_substream *substream,
 	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;
-	at91rm9200_pcm_dma_params_t *params = prtd->params;
+	struct at91_runtime_data *prtd = substream->runtime->private_data;
+	struct at91_pcm_dma_params *params = prtd->params;
 
 	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;
 	}
 
 	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;
-	at91rm9200_pcm_dma_params_t *params = prtd->params;
+	struct at91_runtime_data *prtd = substream->runtime->private_data;
+	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);
 
-	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;
 }
 
-static int at91rm9200_pcm_trigger(struct snd_pcm_substream *substream,
+static int at91_pcm_trigger(struct snd_pcm_substream *substream,
 	int cmd)
 {
-	struct at91rm9200_runtime_data *prtd = substream->runtime->private_data;
-	at91rm9200_pcm_dma_params_t *params = prtd->params;
+	struct at91_runtime_data *prtd = substream->runtime->private_data;
+	struct at91_pcm_dma_params *params = prtd->params;
 	int ret = 0;
 
 	switch (cmd) {
 	case SNDRV_PCM_TRIGGER_START:
 		prtd->period_ptr = prtd->dma_buffer;
 
-		at91_ssc_write(params->pdc->xpr, prtd->period_ptr);
-		at91_ssc_write(params->pdc->xcr,
+		at91_ssc_write(params->ssc_base + params->pdc->xpr, prtd->period_ptr);
+		at91_ssc_write(params->ssc_base + params->pdc->xcr,
 				prtd->period_size / params->pdc_xfer_size);
 
 		prtd->period_ptr += prtd->period_size;
-		at91_ssc_write(params->pdc->xnpr, prtd->period_ptr);
-		at91_ssc_write(params->pdc->xncr,
+		at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->period_ptr);
+		at91_ssc_write(params->ssc_base + params->pdc->xncr,
 				prtd->period_size / params->pdc_xfer_size);
 
 		DBG("trigger: period_ptr=%lx, xpr=%lx, xcr=%ld, xnpr=%lx, xncr=%ld\n",
 			(unsigned long) prtd->period_ptr,
-			at91_ssc_read(params->pdc->xpr),
-			at91_ssc_read(params->pdc->xcr),
-			at91_ssc_read(params->pdc->xnpr),
-			at91_ssc_read(params->pdc->xncr));
+			at91_ssc_read(params->ssc_base + params->pdc->xpr),
+			at91_ssc_read(params->ssc_base + params->pdc->xcr),
+			at91_ssc_read(params->ssc_base + params->pdc->xnpr),
+			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);
 
-		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),
-					at91_ssc_read(params->ssc->ier + 8));
+		DBG("sr=%lx imr=%lx\n", at91_ssc_read(params->ssc_base + AT91_SSC_SR),
+					at91_ssc_read(params->ssc_base + AT91_SSC_IER));
 		break;
 
 	case SNDRV_PCM_TRIGGER_STOP:
 	case SNDRV_PCM_TRIGGER_SUSPEND:
 	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;
 
 	case SNDRV_PCM_TRIGGER_RESUME:
 	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;
 
 	default:
@@ -217,16 +216,16 @@ static int at91rm9200_pcm_trigger(struct snd_pcm_substream *substream,
 	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_runtime *runtime = substream->runtime;
-	struct at91rm9200_runtime_data *prtd = runtime->private_data;
-	at91rm9200_pcm_dma_params_t *params = prtd->params;
+	struct at91_runtime_data *prtd = runtime->private_data;
+	struct at91_pcm_dma_params *params = prtd->params;
 	dma_addr_t ptr;
 	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);
 
 	if (x == runtime->buffer_size)
@@ -234,20 +233,20 @@ static snd_pcm_uframes_t at91rm9200_pcm_pointer(
 	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 at91rm9200_runtime_data *prtd;
+	struct at91_runtime_data *prtd;
 	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 */
 	ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 	if (ret < 0)
 		goto out;
 
-	prtd = kzalloc(sizeof(struct at91rm9200_runtime_data), GFP_KERNEL);
+	prtd = kzalloc(sizeof(struct at91_runtime_data), GFP_KERNEL);
 	if (prtd == NULL) {
 		ret = -ENOMEM;
 		goto out;
@@ -258,15 +257,15 @@ static int at91rm9200_pcm_open(struct snd_pcm_substream *substream)
 	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);
 	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 snd_pcm_runtime *runtime = substream->runtime;
@@ -277,24 +276,24 @@ static int at91rm9200_pcm_mmap(struct snd_pcm_substream *substream,
 				     runtime->dma_bytes);
 }
 
-struct snd_pcm_ops at91rm9200_pcm_ops = {
-	.open		= at91rm9200_pcm_open,
-	.close		= at91rm9200_pcm_close,
+struct snd_pcm_ops at91_pcm_ops = {
+	.open		= at91_pcm_open,
+	.close		= at91_pcm_close,
 	.ioctl		= snd_pcm_lib_ioctl,
-	.hw_params	= at91rm9200_pcm_hw_params,
-	.hw_free	= at91rm9200_pcm_hw_free,
-	.prepare	= at91rm9200_pcm_prepare,
-	.trigger	= at91rm9200_pcm_trigger,
-	.pointer	= at91rm9200_pcm_pointer,
-	.mmap		= at91rm9200_pcm_mmap,
+	.hw_params	= at91_pcm_hw_params,
+	.hw_free	= at91_pcm_hw_free,
+	.prepare	= at91_pcm_prepare,
+	.trigger	= at91_pcm_trigger,
+	.pointer	= at91_pcm_pointer,
+	.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)
 {
 	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
 	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.dev = pcm->card->dev;
@@ -314,27 +313,27 @@ static int at91rm9200_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
 	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)
 {
 	int ret = 0;
 
 	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)
 		card->dev->coherent_dma_mask = 0xffffffff;
 
 	if (dai->playback.channels_min) {
-		ret = at91rm9200_pcm_preallocate_dma_buffer(pcm,
+		ret = at91_pcm_preallocate_dma_buffer(pcm,
 			SNDRV_PCM_STREAM_PLAYBACK);
 		if (ret)
 			goto out;
 	}
 
 	if (dai->capture.channels_min) {
-		ret = at91rm9200_pcm_preallocate_dma_buffer(pcm,
+		ret = at91_pcm_preallocate_dma_buffer(pcm,
 			SNDRV_PCM_STREAM_CAPTURE);
 		if (ret)
 			goto out;
@@ -343,7 +342,7 @@ static int at91rm9200_pcm_new(struct snd_card *card,
 	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_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_pcm_runtime *runtime = dai->runtime;
-	struct at91rm9200_runtime_data *prtd;
-	at91rm9200_pcm_dma_params_t *params;
+	struct at91_runtime_data *prtd;
+	struct at91_pcm_dma_params *params;
 
 	if (!runtime)
 		return 0;
@@ -379,22 +378,22 @@ static int at91rm9200_pcm_suspend(struct platform_device *pdev,
 
 	/* 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_xcr_save  = at91_ssc_read(params->pdc->xcr);
-	prtd->pdc_xnpr_save = at91_ssc_read(params->pdc->xnpr);
-	prtd->pdc_xncr_save = at91_ssc_read(params->pdc->xncr);
+	prtd->pdc_xpr_save  = at91_ssc_read(params->ssc_base + params->pdc->xpr);
+	prtd->pdc_xcr_save  = at91_ssc_read(params->ssc_base + params->pdc->xcr);
+	prtd->pdc_xnpr_save = at91_ssc_read(params->ssc_base + params->pdc->xnpr);
+	prtd->pdc_xncr_save = at91_ssc_read(params->ssc_base + params->pdc->xncr);
 
 	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_pcm_runtime *runtime = dai->runtime;
-	struct at91rm9200_runtime_data *prtd;
-	at91rm9200_pcm_dma_params_t *params;
+	struct at91_runtime_data *prtd;
+	struct at91_pcm_dma_params *params;
 
 	if (!runtime)
 		return 0;
@@ -403,26 +402,26 @@ static int at91rm9200_pcm_resume(struct platform_device *pdev,
 	params = prtd->params;
 
 	/* restore the PDC registers and enable the PDC */
-	at91_ssc_write(params->pdc->xpr,  prtd->pdc_xpr_save);
-	at91_ssc_write(params->pdc->xcr,  prtd->pdc_xcr_save);
-	at91_ssc_write(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->xpr,  prtd->pdc_xpr_save);
+	at91_ssc_write(params->ssc_base + params->pdc->xcr,  prtd->pdc_xcr_save);
+	at91_ssc_write(params->ssc_base + params->pdc->xnpr, prtd->pdc_xnpr_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;
 }
 
-struct snd_soc_platform at91rm9200_soc_platform = {
-	.name		= "at91rm9200-audio",
-	.pcm_ops 	= &at91rm9200_pcm_ops,
-	.pcm_new	= at91rm9200_pcm_new,
-	.pcm_free	= at91rm9200_pcm_free_dma_buffers,
-	.suspend	= at91rm9200_pcm_suspend,
-	.resume		= at91rm9200_pcm_resume,
+struct snd_soc_platform at91_soc_platform = {
+	.name		= "at91-audio",
+	.pcm_ops 	= &at91_pcm_ops,
+	.pcm_new	= at91_pcm_new,
+	.pcm_free	= at91_pcm_free_dma_buffers,
+	.suspend	= at91_pcm_suspend,
+	.resume		= at91_pcm_resume,
 };
 
-EXPORT_SYMBOL_GPL(at91rm9200_soc_platform);
+EXPORT_SYMBOL_GPL(at91_soc_platform);
 
 MODULE_AUTHOR("Frank Mandarino <fmandarino@endrelia.com>");
-MODULE_DESCRIPTION("Atmel AT91RM9200 PCM module");
+MODULE_DESCRIPTION("Atmel AT91 PCM module");
 MODULE_LICENSE("GPL");
diff --git a/sound/soc/at91/at91rm9200-pcm.h b/sound/soc/at91/at91-pcm.h
index 65468f1..6c3b095 100644
--- a/sound/soc/at91/at91rm9200-pcm.h
+++ b/sound/soc/at91/at91-pcm.h
@@ -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>
  *		Endrelia Technologies Inc.
@@ -16,24 +16,26 @@
  * 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.
  */
-struct at91rm9200_ssc_regs {
-	void __iomem 	*cr;		/* SSC control */
-	void __iomem	*ier;		/* SSC interrupt enable */
-	void __iomem	*idr;		/* SSC interrupt disable */
+struct at91_pdc_regs {
+	unsigned int	xpr;		/* PDC recv/trans pointer */
+	unsigned int	xcr;		/* PDC recv/trans counter */
+	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 {
-	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 {
+struct at91_ssc_mask {
 	u32	ssc_enable;		/* SSC recv/trans enable */
 	u32	ssc_disable;		/* SSC recv/trans disable */
 	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
  * non-NULL.
  */
-typedef struct {
+struct at91_pcm_dma_params {
 	char *name;			/* stream identifier */
 	int pdc_xfer_size;		/* PDC counter increment in bytes */
-	struct at91rm9200_ssc_regs *ssc; /* SSC register addresses */
-	struct at91rm9200_pdc_regs *pdc; /* PDC receive/transmit registers */
-	struct at91rm9200_ssc_mask *mask;/* SSC & PDC status bits */
-	snd_pcm_substream_t *substream;
-	void (*dma_intr_handler)(u32, snd_pcm_substream_t *);
-} at91rm9200_pcm_dma_params_t;
+	void __iomem *ssc_base;		/* SSC base address */
+	struct at91_pdc_regs *pdc; /* PDC receive or transmit registers */
+	struct at91_ssc_mask *mask;/* SSC & PDC status bits */
+	struct snd_pcm_substream *substream;
+	void (*dma_intr_handler)(u32, struct snd_pcm_substream *);
+};
 
-extern struct snd_soc_cpu_dai at91rm9200_i2s_dai[3];
-extern struct snd_soc_platform at91rm9200_soc_platform;
+extern struct snd_soc_cpu_dai at91_i2s_dai[3];
+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_write(a,v)	__raw_writel((v),(a))
diff --git a/sound/soc/at91/eti_b1_wm8731.c b/sound/soc/at91/eti_b1_wm8731.c
index d955cac..089cdc9 100644
--- a/sound/soc/at91/eti_b1_wm8731.c
+++ b/sound/soc/at91/eti_b1_wm8731.c
@@ -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>
  *		Endrelia Technologies Inc.
@@ -37,12 +37,12 @@
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
 
-#include <asm/arch/at91rm9200.h>
-#include <asm/arch/gpio.h>
 #include <asm/arch/hardware.h>
+#include <asm/arch/at91_pio.h>
+#include <asm/arch/gpio.h>
 
 #include "../codecs/wm8731.h"
-#include "at91rm9200-pcm.h"
+#include "at91-pcm.h"
 
 #if 0
 #define	DBG(x...)	printk(KERN_INFO "eti_b1_wm8731:" x)
@@ -50,10 +50,18 @@
 #define	DBG(x...)
 #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 *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. */
 	clk_enable(pck1_clk);
@@ -62,7 +70,7 @@ static int eti_b1_startup(snd_pcm_substream_t *substream)
 	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. */
 	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 = {
 	.name = "WM8731",
 	.stream_name = "WM8731",
-	.cpu_dai = &at91rm9200_i2s_dai[1],
+	.cpu_dai = &at91_i2s_dai[1],
 	.codec_dai = &wm8731_dai,
 	.init = eti_b1_wm8731_init,
 	.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 = {
 	.machine = &snd_soc_machine_eti_b1,
-	.platform = &at91rm9200_soc_platform,
+	.platform = &at91_soc_platform,
 	.codec_dev = &soc_codec_dev_wm8731,
 	.codec_data = &eti_b1_wm8731_setup,
 };
@@ -168,22 +176,41 @@ static int __init eti_b1_init(void)
 {
 	int ret;
 	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);
-	if (!eti_b1_snd_device)
-		return -ENOMEM;
+	if (!eti_b1_snd_device) {
+		DBG("platform device allocation failed\n");
+		ret = -ENOMEM;
+		goto fail_io_unmap;
+	}
 
 	platform_set_drvdata(eti_b1_snd_device, &eti_b1_snd_devdata);
 	eti_b1_snd_devdata.dev = &eti_b1_snd_device->dev;
 
 	ret = platform_device_add(eti_b1_snd_device);
 	if (ret) {
+		DBG("platform device add failed\n");
 		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
-			| AT91_PB9_RD1 /* | AT91_PB10_RK1 | AT91_PB11_RF1 */;
+ 	ssc_pio_lines = AT91_PIO_TF1 | AT91_PIO_TK1 | AT91_PIO_TD1
+			| AT91_PIO_RD1 /* | AT91_PIO_RK1 | AT91_PIO_RF1 */;
 
 	/* Reset all PIO registers and assign lines to peripheral A */
  	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);
 
 	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)
 {
+	struct at91_ssc_periph *ssc = eti_b1_dai.cpu_dai->private_data;
+
 	clk_put(pck1_clk);
 	clk_put(pllb_clk);
 
 	platform_device_unregister(eti_b1_snd_device);
+
+	iounmap(ssc->base);
+	release_mem_region(AT91RM9200_BASE_SSC1, SZ_16K);
 }
 
 module_init(eti_b1_init);