Re: [alsa-devel] [PATCH 2/4] ASoC: add DAI and platform drivers for SH SIU and support for the Migo-R board

On Tue, 2010-01-19 at 09:09 +0100, Guennadi Liakhovetski wrote:

Several SuperH platforms, including sh7722, sh7343, sh7354, sh7367 include a Sound Interface Unit (SIU). This patch adds drivers for this interface and support for the sh7722 Migo-R board.

Had a quick look wrt the ALSA parts. Comments below.

Signed-off-by: Guennadi Liakhovetski g.liakhovetski@gmx.de

As mentioned in the introduction mail, this driver requires firmware to be loaded from user-space using the standard hotplug functionality.

arch/sh/include/asm/siu.h | 26 ++ sound/soc/sh/Kconfig | 16 + sound/soc/sh/Makefile | 4 + sound/soc/sh/migor.c | 261 ++++++++++++++ sound/soc/sh/siu.h | 217 ++++++++++++ sound/soc/sh/siu_dai.c | 833 +++++++++++++++++++++++++++++++++++++++++++++ sound/soc/sh/siu_pcm.c | 716 ++++++++++++++++++++++++++++++++++++++ 7 files changed, 2073 insertions(+), 0 deletions(-) create mode 100644 arch/sh/include/asm/siu.h create mode 100644 sound/soc/sh/migor.c create mode 100644 sound/soc/sh/siu.h create mode 100644 sound/soc/sh/siu_dai.c create mode 100644 sound/soc/sh/siu_pcm.c

diff --git a/arch/sh/include/asm/siu.h b/arch/sh/include/asm/siu.h new file mode 100644 index 0000000..57565a3 --- /dev/null +++ b/arch/sh/include/asm/siu.h @@ -0,0 +1,26 @@ +/*

• • platform header for the SIU ASoC driver
• • Copyright (C) 2009-2010 Guennadi Liakhovetski g.liakhovetski@gmx.de
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License version 2 as
• • published by the Free Software Foundation.
• */

+#ifndef ASM_SIU_H +#define ASM_SIU_H

+#include <asm/dma-sh.h>

+struct device;

+struct siu_platform {

• struct device *dma_dev;
• enum sh_dmae_slave_chan_id dma_slave_tx_a;
• enum sh_dmae_slave_chan_id dma_slave_rx_a;
• enum sh_dmae_slave_chan_id dma_slave_tx_b;
• enum sh_dmae_slave_chan_id dma_slave_rx_b;

+};

+#endif /* ASM_SIU_H */ diff --git a/sound/soc/sh/Kconfig b/sound/soc/sh/Kconfig index 8072a6d..eec6fe5 100644 --- a/sound/soc/sh/Kconfig +++ b/sound/soc/sh/Kconfig @@ -26,6 +26,14 @@ config SND_SOC_SH4_FSI help This option enables FSI sound support

+config SND_SOC_SH4_SIU

• tristate "SH4 SIU support"
• depends on CPU_SUBTYPE_SH7722
• select DMADEVICES
• select SH_DMAE
• help

•  This option enables SIU sound support
  

## ## Boards ## @@ -55,4 +63,12 @@ config SND_FSI_DA7210 This option enables generic sound support for the FSI - DA7210 unit

+config SND_SIU_MIGOR

• tristate "SIU sound support on Migo-R"
• depends on SND_SOC_SH4_SIU && SH_MIGOR
• select SND_SOC_WM8978
• help

•  This option enables generic sound support for the
  

•  SH7722 Migo-R board
  

endmenu diff --git a/sound/soc/sh/Makefile b/sound/soc/sh/Makefile index 1d0ec0a..8a5a192 100644 --- a/sound/soc/sh/Makefile +++ b/sound/soc/sh/Makefile @@ -6,15 +6,19 @@ obj-$(CONFIG_SND_SOC_PCM_SH7760) += snd-soc-dma-sh7760.o snd-soc-hac-objs := hac.o snd-soc-ssi-objs := ssi.o snd-soc-fsi-objs := fsi.o +snd-soc-siu-objs := siu_pcm.o siu_dai.o obj-$(CONFIG_SND_SOC_SH4_HAC) += snd-soc-hac.o obj-$(CONFIG_SND_SOC_SH4_SSI) += snd-soc-ssi.o obj-$(CONFIG_SND_SOC_SH4_FSI) += snd-soc-fsi.o +obj-$(CONFIG_SND_SOC_SH4_SIU) += snd-soc-siu.o

## boards snd-soc-sh7760-ac97-objs := sh7760-ac97.o snd-soc-fsi-ak4642-objs := fsi-ak4642.o snd-soc-fsi-da7210-objs := fsi-da7210.o +snd-soc-migor-objs := migor.o

obj-$(CONFIG_SND_SH7760_AC97) += snd-soc-sh7760-ac97.o obj-$(CONFIG_SND_FSI_AK4642) += snd-soc-fsi-ak4642.o obj-$(CONFIG_SND_FSI_DA7210) += snd-soc-fsi-da7210.o +obj-$(CONFIG_SND_SIU_MIGOR) += snd-soc-migor.o diff --git a/sound/soc/sh/migor.c b/sound/soc/sh/migor.c new file mode 100644 index 0000000..507e59e --- /dev/null +++ b/sound/soc/sh/migor.c @@ -0,0 +1,261 @@ +/*

• • ALSA SoC driver for Migo-R
• • Copyright (C) 2009-2010 Guennadi Liakhovetski g.liakhovetski@gmx.de
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License version 2 as
• • published by the Free Software Foundation.
• */

+#include <linux/device.h> +#include <linux/firmware.h> +#include <linux/module.h>

+#include <asm/clock.h>

+#include <cpu/sh7722.h>

+#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h>

+#include "../codecs/wm8978.h" +#include "siu.h"

+/* Default 8000Hz sampling frequency */ +static unsigned long codec_freq = 49152350 / 12;

+static const int mclk_numerator[] = {1, 3, 2, 3, 4, 6, 8, 12}; +static const int mclk_denominator[] = {1, 2, 1, 1, 1, 1, 1, 1};

+/* External clock, sourced from the codec at the SIUMCKB pin */ +static unsigned long siumckb_recalc(struct clk *clk) +{

• return codec_freq;

+}

+static struct clk_ops siumckb_clk_ops = {

• .recalc = siumckb_recalc,

+};

+static struct clk siumckb_clk = {

• .name = "siumckb_clk",
• .id = -1,
• .ops = &siumckb_clk_ops,
• .rate = 0, /* initialised at run-time */

+};

+static int migor_hw_params(struct snd_pcm_substream *substream,

• 	   struct snd_pcm_hw_params *params)
  

+{

• struct snd_soc_pcm_runtime *rtd = substream->private_data;
• struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
• unsigned int mclk_div, opclk_div, f2;
• int ret, mclk_idx;
• unsigned int rate = params_rate(params);
• switch (rate) {
• case 48000:

• mclk_div = 0x40;
  

• opclk_div = 0;
  

• /* f2 = 98304000, was 98304050 */
  

What does the "was" value represent here ?

• break;
  

• case 44100:

• mclk_div = 0x40;
  

• opclk_div = 0;
  

• /* f2 = 90316800, was 90317500 */
  

• break;
  

• case 32000:

• mclk_div = 0x80;
  

• opclk_div = 0x010;
  

• /* f2 = 131072000, was 131072500 */
  

• break;
  

• case 24000:

• mclk_div = 0x80;
  

• opclk_div = 0x010;
  

• /* f2 = 98304000, was 98304700 */
  

• break;
  

• case 22050:

• mclk_div = 0x80;
  

• opclk_div = 0x010;
  

• /* f2 = 90316800, was 90317500 */
  

• break;
  

• case 16000:

• mclk_div = 0xa0;
  

• opclk_div = 0x020;
  

• /* f2 = 98304000, was 98304700 */
  

• break;
  

• case 11025:

• mclk_div = 0x80;
  

• opclk_div = 0x010;
  

• /* f2 = 45158400, was 45158752 */
  

• break;
  

• default:
• case 8000:

• mclk_div = 0xa0;
  

• opclk_div = 0x020;
  

• /* f2 = 49152000, was 49152350 */
  

• break;
  

• }
• mclk_idx = mclk_div >> 5;
• /*

• * Calculate f2, according to Figure 40 "PLL and Clock Select Circuit"
  

• * in WM8978 datasheet
  

• */
  

• f2 = rate * 256 * 4 * mclk_numerator[mclk_idx] /

• mclk_denominator[mclk_idx];
  

• ret = snd_soc_dai_set_clkdiv(codec_dai, WM8978_MCLKDIV,

• 		     mclk_div & 0xe0);
  

• if (ret < 0)

• return ret;
  

• ret = snd_soc_dai_set_clkdiv(codec_dai, WM8978_OPCLKDIV, opclk_div);
• if (ret < 0)

• return ret;
  

• ret = snd_soc_dai_set_clkdiv(codec_dai, WM8978_DACCLK, 8);
• if (ret < 0)

• return ret;
  

• ret = snd_soc_dai_set_pll(codec_dai, 0, 0, 13000000, f2);
• if (ret < 0)

• return ret;
  

• ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_NB_IF |

• 		  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
  

• if (ret < 0)

• return ret;
  

• ret = snd_soc_dai_set_fmt(rtd->dai->cpu_dai, SND_SOC_DAIFMT_NB_IF |

• 		  SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS);
  

• if (ret < 0)

• return ret;
  

• /* See Figure 40 */
• codec_freq = f2 / ((opclk_div >> 4) + 1) >> 2;
• /*

• * This propagates the parent frequency change to children and
  

• * recalculates the frequency table
  

• */
  

• clk_set_rate(&siumckb_clk, codec_freq);
• dev_dbg(codec_dai->dev, "%s: configure %luHz\n", __func__, codec_freq);
• snd_soc_dai_set_sysclk(rtd->dai->cpu_dai, CLKB_EXT, codec_freq / 2,

• 	       SND_SOC_CLOCK_IN);
  

• return ret;

+}

+static int migor_hw_free(struct snd_pcm_substream *substream) +{

• struct snd_soc_pcm_runtime *rtd = substream->private_data;
• struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
• /* disable the PLL */
• return snd_soc_dai_set_pll(codec_dai, 0, 0, 0, 0);

+}

+static int migor_startup(struct snd_pcm_substream *substream) +{

• struct snd_soc_pcm_runtime *rtd = substream->private_data;
• struct snd_soc_device *socdev = rtd->socdev;
• struct snd_soc_codec *codec = socdev->card->codec;
• int ret;
• /* Activate DAC output routes */
• ret = snd_soc_dapm_enable_pin(codec, "Left Speaker Out");
• if (ret < 0) {

• dev_warn(socdev->dev, "Left err %d\n", ret);
  

• return ret;
  

• }
• ret = snd_soc_dapm_enable_pin(codec, "Right Speaker Out");
• if (ret < 0) {

• dev_warn(socdev->dev, "Right err %d\n", ret);
  

• return ret;
  

• }
• snd_soc_dapm_sync(codec);
• return 0;

+}

+static struct snd_soc_ops migor_dai_ops = {

• .hw_params = migor_hw_params,
• .hw_free = migor_hw_free,
• .startup = migor_startup,

+};

+/* migor digital audio interface glue - connects codec <--> CPU */ +static struct snd_soc_dai_link migor_dai = {

• .name = "wm8978",
• .stream_name = "WM8978",
• .cpu_dai = &siu_i2s_dai,
• .codec_dai = &wm8978_dai,
• .ops = &migor_dai_ops,

+};

+/* migor audio machine driver */ +static struct snd_soc_card snd_soc_migor = {

• .name = "Migo-R",
• .platform = &siu_platform,
• .dai_link = &migor_dai,
• .num_links = 1,

+};

+/* migor audio subsystem */ +static struct snd_soc_device migor_snd_devdata = {

• .card = &snd_soc_migor,
• .codec_dev = &soc_codec_dev_wm8978,

+};

+static struct platform_device *migor_snd_device;

+static int __init migor_init(void) +{

• int ret;
• ret = clk_register(&siumckb_clk);
• if (ret < 0)

• return ret;
  

• /* Port number used on this machine: port B */
• migor_snd_device = platform_device_alloc("soc-audio", 1);
• if (!migor_snd_device) {

• ret = -ENOMEM;
  

• goto epdevalloc;
  

• }
• platform_set_drvdata(migor_snd_device, &migor_snd_devdata);
• migor_snd_devdata.dev = &migor_snd_device->dev;
• ret = platform_device_add(migor_snd_device);
• if (ret)

• goto epdevadd;
  

• return 0;

+epdevadd:

• platform_device_put(migor_snd_device);

+epdevalloc:

• clk_unregister(&siumckb_clk);
• return ret;

+}

+static void __exit migor_exit(void) +{

• clk_unregister(&siumckb_clk);
• platform_device_unregister(migor_snd_device);

+}

+module_init(migor_init); +module_exit(migor_exit);

+MODULE_AUTHOR("Guennadi Liakhovetski g.liakhovetski@gmx.de"); +MODULE_DESCRIPTION("ALSA SoC Migor"); +MODULE_LICENSE("GPL v2"); diff --git a/sound/soc/sh/siu.h b/sound/soc/sh/siu.h new file mode 100644 index 0000000..e7cba83 --- /dev/null +++ b/sound/soc/sh/siu.h @@ -0,0 +1,217 @@ +/*

• • siu.h - ALSA SoC driver for Renesas SH7343, SH7722 SIU peripheral.
• • Copyright (C) 2009-2010 Guennadi Liakhovetski g.liakhovetski@gmx.de
• • Copyright (C) 2006 Carlos Munoz carlos@kenati.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation; either version 2 of the License, or
• • (at your option) any later version.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
• */

+#ifndef SIU_H +#define SIU_H

+/* Common kernel and user-space firmware-building defines and types */

+#define YRAM0_SIZE (0x0040 / 4) /* 16 */ +#define YRAM1_SIZE (0x0080 / 4) /* 32 */ +#define YRAM2_SIZE (0x0040 / 4) /* 16 */ +#define YRAM3_SIZE (0x0080 / 4) /* 32 */ +#define YRAM4_SIZE (0x0080 / 4) /* 32 */ +#define YRAM_DEF_SIZE (YRAM0_SIZE + YRAM1_SIZE + YRAM2_SIZE + \

• 		 YRAM3_SIZE + YRAM4_SIZE)
  

+#define YRAM_FIR_SIZE (0x0400 / 4) /* 256 */ +#define YRAM_IIR_SIZE (0x0200 / 4) /* 128 */

+#define XRAM0_SIZE (0x0400 / 4) /* 256 */ +#define XRAM1_SIZE (0x0200 / 4) /* 128 */ +#define XRAM2_SIZE (0x0200 / 4) /* 128 */

+/* PRAM program array size */ +#define PRAM0_SIZE (0x0100 / 4) /* 64 */ +#define PRAM1_SIZE ((0x2000 - 0x0100) / 4) /* 1984 */

+#include <linux/types.h>

+struct siu_spb_param {

• __u32 ab1a; /* input FIFO address */
• __u32 ab0a; /* output FIFO address */
• __u32 dir; /* 0=the ather except CPUOUTPUT, 1=CPUINPUT */
• __u32 event; /* SPB program starting conditions */
• __u32 stfifo; /* STFIFO register setting value */
• __u32 trdat; /* TRDAT register setting value */

+};

+struct siu_firmware {

• __u32 yram_fir_coeff[YRAM_FIR_SIZE];
• __u32 pram0[PRAM0_SIZE];
• __u32 pram1[PRAM1_SIZE];
• __u32 yram0[YRAM0_SIZE];
• __u32 yram1[YRAM1_SIZE];
• __u32 yram2[YRAM2_SIZE];
• __u32 yram3[YRAM3_SIZE];
• __u32 yram4[YRAM4_SIZE];
• __u32 spbpar_num;
• struct siu_spb_param spbpar[32];

+};

+#ifdef __KERNEL__

+#include <linux/dmaengine.h> +#include <linux/interrupt.h> +#include <linux/io.h>

+#include <asm/dma-sh.h>

+#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/soc-dai.h>

+#define SIU_PORTA 0 /* port A */ +#define SIU_PORTB 1 /* port B */ +#define MAX_SIU_PORTS 2

+/* SIU clock configuration */ +enum {CLKA_PLL, CLKA_EXT, CLKB_PLL, CLKB_EXT};

+/* Board specifics */ +#if defined(CONFIG_CPU_SUBTYPE_SH7722) +# define MAX_VOLUME 0x1000 +#else +# define MAX_VOLUME 0x7fff +#endif

+struct siu_info {

• int port_id;
• u32 __iomem *pram;
• u32 __iomem *xram;
• u32 __iomem *yram;
• u32 __iomem *reg;
• struct siu_firmware fw;

+};

+#define PRAM_SIZE 0x2000 +#define XRAM_SIZE 0x800 +#define YRAM_SIZE 0x800

+#define XRAM_OFFSET 0x4000 +#define YRAM_OFFSET 0x6000 +#define REG_OFFSET 0xc000

+struct siu_stream {

• struct tasklet_struct tasklet;
• struct snd_pcm_substream *substream;
• snd_pcm_format_t format;
• size_t buf_bytes;
• size_t period_bytes;
• int cur_period; /* Period currently in dma */
• u32 volume;
• void *mono_buf; /* Mono buffer */
• size_t mono_size; /* and its size in bytes */
• snd_pcm_sframes_t xfer_cnt; /* Number of frames */
• u8 rw_flg; /* transfer status */
• /* DMA status */
• dma_addr_t mono_dma;
• struct dma_chan *chan; /* DMA channel */
• struct dma_async_tx_descriptor *tx_desc;
• dma_cookie_t cookie;
• struct sh_dmae_slave param;

+};

+struct siu_port {

• unsigned long play_cap; /* Used to track full duplex */
• struct snd_pcm *pcm;
• struct siu_stream playback;
• struct siu_stream capture;
• u32 stfifo; /* STFIFO value from firmware */
• u32 trdat; /* TRDAT value from firmware */

+};

+extern struct siu_port *siu_ports[MAX_SIU_PORTS];

+static inline struct siu_port *siu_port_info(struct snd_pcm_substream *substream) +{

• struct platform_device *pdev =

• to_platform_device(substream->pcm->card->dev);
  

• return siu_ports[pdev->id];

+}

+#define PLAYBACK_ENABLED 1 +#define CAPTURE_ENABLED 2

+#define VOLUME_CAPTURE 0 +#define VOLUME_PLAYBACK 1 +#define DFLT_VOLUME_LEVEL 0x08000800

+#define PERIOD_BYTES_MAX 8192 /* DMA transfer/period size */ +#define PERIOD_BYTES_MIN 256 /* DMA transfer/period size */ +#define PERIODS_MAX 64 /* Max periods in buffer */ +#define PERIODS_MIN 4 /* Min periods in buffer */ +#define BUFFER_BYTES_MAX (PERIOD_BYTES_MAX * PERIODS_MAX) +#define GET_MAX_PERIODS(buf_bytes, period_bytes) \

• 		((buf_bytes) / (period_bytes))
  

+#define PERIOD_OFFSET(buf_addr, period_num, period_bytes) \

• 		((buf_addr) + ((period_num) * (period_bytes)))
  

+#define RWF_STM_RD 0x01 /* Read in progress */ +#define RWF_STM_WT 0x02 /* Write in progress */

+/* Register access */ +static inline void siu_write32(u32 __iomem *addr, u32 val) +{

• __raw_writel(val, addr);

+}

+static inline u32 siu_read32(u32 __iomem *addr) +{

• return __raw_readl(addr);

+}

+/* SIU registers */ +#define IFCTL (0x000 / sizeof(u32)) +#define SRCTL (0x004 / sizeof(u32)) +#define SFORM (0x008 / sizeof(u32)) +#define CKCTL (0x00c / sizeof(u32)) +#define TRDAT (0x010 / sizeof(u32)) +#define STFIFO (0x014 / sizeof(u32)) +#define DPAK (0x01c / sizeof(u32)) +#define CKREV (0x020 / sizeof(u32)) +#define EVNTC (0x028 / sizeof(u32)) +#define SBCTL (0x040 / sizeof(u32)) +#define SBPSET (0x044 / sizeof(u32)) +#define SBFSTS (0x068 / sizeof(u32)) +#define SBDVCA (0x06c / sizeof(u32)) +#define SBDVCB (0x070 / sizeof(u32)) +#define SBACTIV (0x074 / sizeof(u32)) +#define DMAIA (0x090 / sizeof(u32)) +#define DMAIB (0x094 / sizeof(u32)) +#define DMAOA (0x098 / sizeof(u32)) +#define DMAOB (0x09c / sizeof(u32)) +#define DMAML (0x0a0 / sizeof(u32)) +#define SPSTS (0x0cc / sizeof(u32)) +#define SPCTL (0x0d0 / sizeof(u32)) +#define BRGASEL (0x100 / sizeof(u32)) +#define BRRA (0x104 / sizeof(u32)) +#define BRGBSEL (0x108 / sizeof(u32)) +#define BRRB (0x10c / sizeof(u32))

+extern struct snd_soc_platform siu_platform; +extern struct snd_soc_dai siu_i2s_dai;

+int siu_init_port(int port, struct siu_port **port_info, struct snd_card *card); +void siu_free_port(struct siu_port *port_info);

+#endif

+#endif /* SIU_H */ diff --git a/sound/soc/sh/siu_dai.c b/sound/soc/sh/siu_dai.c new file mode 100644 index 0000000..e5dbedb --- /dev/null +++ b/sound/soc/sh/siu_dai.c @@ -0,0 +1,833 @@ +/*

• • siu_dai.c - ALSA SoC driver for Renesas SH7343, SH7722 SIU peripheral.
• • Copyright (C) 2009-2010 Guennadi Liakhovetski g.liakhovetski@gmx.de
• • Copyright (C) 2006 Carlos Munoz carlos@kenati.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation; either version 2 of the License, or
• • (at your option) any later version.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
• */

+#include <linux/delay.h> +#include <linux/firmware.h> +#include <linux/pm_runtime.h>

+#include <asm/clock.h> +#include <asm/siu.h>

+#include <sound/control.h> +#include <sound/soc-dai.h>

+#include "siu.h"

+/*

• • SPDIF is only available on port A and on some SIU implementations it is only
• • available for input. Due to the lack of hardware to test it, SPDIF is left
• • disabled in this driver version
• */

+struct format_flag {

• u32 i2s;
• u32 pcm;
• u32 spdif;
• u32 mask;

+};

+struct port_flag {

• struct format_flag playback;
• struct format_flag capture;

+};

+static struct port_flag siu_flags[MAX_SIU_PORTS] = {

• [SIU_PORTA] = {

• .playback = {
  

• 	.i2s	= 0x50000000,
  

• 	.pcm	= 0x40000000,
  

• 	.spdif	= 0x80000000,	/* not on all SIU versions */
  

• 	.mask	= 0xd0000000,
  

• },
  

• .capture = {
  

• 	.i2s	= 0x05000000,
  

• 	.pcm	= 0x04000000,
  

• 	.spdif	= 0x08000000,
  

• 	.mask	= 0x0d000000,
  

• },
  

• },
• [SIU_PORTB] = {

• .playback = {
  

• 	.i2s	= 0x00500000,
  

• 	.pcm	= 0x00400000,
  

• 	.spdif	= 0,		/* impossible - turn off */
  

• 	.mask	= 0x00500000,
  

• },
  

• .capture = {
  

• 	.i2s	= 0x00050000,
  

• 	.pcm	= 0x00040000,
  

• 	.spdif	= 0,		/* impossible - turn off */
  

• 	.mask	= 0x00050000,
  

• },
  

• },

+};

+static void siu_dai_start(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• dev_dbg(port_info->pcm->card->dev, "%s\n", __func__);
• /* Turn on SIU clock */
• pm_runtime_get_sync(siu_i2s_dai.dev);
• /* Issue software reset to siu */
• siu_write32(base + SRCTL, 0);
• /* Wait for the reset to take effect */
• udelay(1);
• port_info->stfifo = 0;
• port_info->trdat = 0;
• /* portA, portB, SIU operate */
• siu_write32(base + SRCTL, 0x301);
• /* portA=256fs, portB=256fs */
• siu_write32(base + CKCTL, 0x40400000);
• /* portA's BRG does not divide SIUCKA */
• siu_write32(base + BRGASEL, 0);
• siu_write32(base + BRRA, 0);
• /* portB's BRG divides SIUCKB by half */
• siu_write32(base + BRGBSEL, 1);
• siu_write32(base + BRRB, 0);
• siu_write32(base + IFCTL, 0x44440000);
• /* portA: 32 bit/fs, master; portB: 32 bit/fs, master */
• siu_write32(base + SFORM, 0x0c0c0000);
• /*

• * Volume levels: looks like the DSP firmware implements volume controls
  

• * differently from what's described in the datasheet
  

• */
  

• siu_write32(base + SBDVCA, port_info->playback.volume);
• siu_write32(base + SBDVCB, port_info->capture.volume);

+}

+static void siu_dai_stop(void) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• /* SIU software reset */
• siu_write32(base + SRCTL, 0);
• /* Turn off SIU clock */
• pm_runtime_put_sync(siu_i2s_dai.dev);

+}

+static void siu_dai_spbAselect(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_firmware *fw = &info->fw;
• u32 *ydef = fw->yram0;
• u32 idx;
• /* path A use */
• if (!info->port_id)

• idx = 1;		/* portA */
  

• else

• idx = 2;		/* portB */
  

• ydef[0] = (fw->spbpar[idx].ab1a << 16) |

• (fw->spbpar[idx].ab0a << 8) |
  

• (fw->spbpar[idx].dir << 7) | 3;
  

• ydef[1] = fw->yram0[1]; /* 0x03000300 */
• ydef[2] = (16 / 2) << 24;
• ydef[3] = fw->yram0[3]; /* 0 */
• ydef[4] = fw->yram0[4]; /* 0 */
• ydef[7] = fw->spbpar[idx].event;
• port_info->stfifo |= fw->spbpar[idx].stfifo;
• port_info->trdat |= fw->spbpar[idx].trdat;

+}

+static void siu_dai_spbBselect(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_firmware *fw = &info->fw;
• u32 *ydef = fw->yram0;
• u32 idx;
• /* path B use */
• if (!info->port_id)

• idx = 7;		/* portA */
  

• else

• idx = 8;		/* portB */
  

• ydef[5] = (fw->spbpar[idx].ab1a << 16) |

• (fw->spbpar[idx].ab0a << 8) | 1;
  

• ydef[6] = fw->spbpar[idx].event;
• port_info->stfifo |= fw->spbpar[idx].stfifo;
• port_info->trdat |= fw->spbpar[idx].trdat;

+}

+static void siu_dai_open(struct siu_stream *siu_stream) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct snd_pcm_substream *substream = siu_stream->substream;
• struct snd_pcm_runtime *rt = substream->runtime;
• u32 srctl, ifctl;
• srctl = siu_read32(base + SRCTL);
• ifctl = siu_read32(base + IFCTL);
• switch (info->port_id) {
• case SIU_PORTA:

• /* portA operates */
  

• srctl |= 0x200;
  

• ifctl &= ~0xc2;
  

• /* Mono mode is not used, instead, stereo is simulated */
  

• if (rt->channels == 1)
  

• 	ifctl |= 0x80;
  

• break;
  

• case SIU_PORTB:

• /* portB operates */
  

• srctl |= 0x100;
  

• ifctl &= ~0x31;
  

• /* Mono mode is not used, instead, stereo is simulated */
  

• if (rt->channels == 1)
  

• 	ifctl |= 0x20;
  

• break;
  

• }
• siu_write32(base + SRCTL, srctl);
• /* Unmute and configure portA */
• siu_write32(base + IFCTL, ifctl);

+}

+/*

• • At the moment only fixed Left-upper, Left-lower, Right-upper, Right-lower
• • packing is supported
• */

+static void siu_dai_pcmdatapack(struct siu_stream *siu_stream) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• u32 dpak;
• dpak = siu_read32(base + DPAK);
• switch (info->port_id) {
• case SIU_PORTA:

• dpak &= ~0xc0000000;
  

• break;
  

• case SIU_PORTB:

• dpak &= ~0x00c00000;
  

• break;
  

• }
• siu_write32(base + DPAK, dpak);

+}

+static int siu_dai_spbstart(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_firmware *fw = &info->fw;
• u32 *ydef = fw->yram0;
• int cnt;
• u32 __iomem *add;
• u32 *ptr;
• /* Load SPB Program in PRAM */
• ptr = fw->pram0;
• add = info->pram;
• for (cnt = 0; cnt < PRAM0_SIZE; cnt++, add++, ptr++)

• siu_write32(add, *ptr);
  

• ptr = fw->pram1;
• add = info->pram + (0x0100 / sizeof(u32));
• for (cnt = 0; cnt < PRAM1_SIZE; cnt++, add++, ptr++)

• siu_write32(add, *ptr);
  

• /* XRAM initialization */
• add = info->xram;
• for (cnt = 0; cnt < XRAM0_SIZE + XRAM1_SIZE + XRAM2_SIZE; cnt++, add++)

• siu_write32(add, 0);
  

• /* YRAM variable area initialization */
• add = info->yram;
• for (cnt = 0; cnt < YRAM_DEF_SIZE; cnt++, add++)

• siu_write32(add, ydef[cnt]);
  

• /* YRAM FIR coefficient area initialization */
• add = info->yram + (0x0200 / sizeof(u32));
• for (cnt = 0; cnt < YRAM_FIR_SIZE; cnt++, add++)

• siu_write32(add, fw->yram_fir_coeff[cnt]);
  

• /* YRAM IIR coefficient area initialization */
• add = info->yram + (0x0600 / sizeof(u32));
• for (cnt = 0; cnt < YRAM_IIR_SIZE; cnt++, add++)

• siu_write32(add, 0);
  

• siu_write32(base + TRDAT, port_info->trdat);
• port_info->trdat = 0x0;
• /* SPB start condition: software */
• siu_write32(base + SBACTIV, 0);
• /* Start SPB */
• siu_write32(base + SBCTL, 0xc0000000);
• /* Wait for program to halt */
• cnt = 0x10000;
• while (--cnt && siu_read32(base + SBCTL) != 0x80000000)

• cpu_relax();
  

• if (!cnt)

• return -EBUSY;
  

• /* SPB program start address setting */
• siu_write32(base + SBPSET, 0x00400000);
• /* SPB hardware start(FIFOCTL source) */
• siu_write32(base + SBACTIV, 0xc0000000);
• return 0;

+}

+static void siu_dai_spbstop(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• siu_write32(base + SBACTIV, 0);
• /* SPB stop */
• siu_write32(base + SBCTL, 0);
• port_info->stfifo = 0;

+}

+/* API functions */

+/* Playback and capture hardware properties are identical */ +static struct snd_pcm_hardware siu_dai_pcm_hw = {

• .info = SNDRV_PCM_INFO_INTERLEAVED,
• .formats = SNDRV_PCM_FMTBIT_S16,
• .rates = SNDRV_PCM_RATE_8000_48000,
• .rate_min = 8000,
• .rate_max = 48000,
• .channels_min = 1,

Shouldn't this be 2 as it's stated in siu_dai_open() that mono is not used.

• .channels_max = 2,
• .buffer_bytes_max = BUFFER_BYTES_MAX,
• .period_bytes_min = PERIOD_BYTES_MIN,
• .period_bytes_max = PERIOD_BYTES_MAX,
• .periods_min = PERIODS_MIN,
• .periods_max = PERIODS_MAX,

+};

+static int siu_dai_info_volume(struct snd_kcontrol *kctrl,

• 	       struct snd_ctl_elem_info *uinfo)
  

+{

• struct siu_port *port_info = snd_kcontrol_chip(kctrl);
• dev_dbg(port_info->pcm->card->dev, "%s\n", __func__);
• uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
• uinfo->count = 2;
• uinfo->value.integer.min = 0;
• uinfo->value.integer.max = MAX_VOLUME;
• return 0;

+}

+static int siu_dai_get_volume(struct snd_kcontrol *kctrl,

• 	      struct snd_ctl_elem_value *ucontrol)
  

+{

• struct siu_port *port_info = snd_kcontrol_chip(kctrl);
• struct device *dev = port_info->pcm->card->dev;
• u32 vol;
• dev_dbg(dev, "%s\n", __func__);
• switch (kctrl->private_value) {
• case VOLUME_PLAYBACK:

• /* Playback is always on port 0 */
  

• vol = port_info->playback.volume;
  

• ucontrol->value.integer.value[0] = vol & 0xffff;
  

• ucontrol->value.integer.value[1] = vol >> 16 & 0xffff;
  

• break;
  

• case VOLUME_CAPTURE:

• /* Capture is always on port 1 */
  

• vol = port_info->capture.volume;
  

• ucontrol->value.integer.value[0] = vol & 0xffff;
  

• ucontrol->value.integer.value[1] = vol >> 16 & 0xffff;
  

• break;
  

• default:

• dev_err(dev, "%s() invalid private_value=%ld\n",
  

• 	__func__, kctrl->private_value);
  

• return -EINVAL;
  

• }
• return 0;

+}

+static int siu_dai_put_volume(struct snd_kcontrol *kctrl,

• 	      struct snd_ctl_elem_value *ucontrol)
  

+{

• struct siu_port *port_info = snd_kcontrol_chip(kctrl);
• struct device *dev = port_info->pcm->card->dev;
• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• u32 new_vol;
• u32 cur_vol;
• dev_dbg(dev, "%s\n", __func__);
• if (ucontrol->value.integer.value[0] < 0 ||

•    ucontrol->value.integer.value[0] > MAX_VOLUME ||
  

•    ucontrol->value.integer.value[1] < 0 ||
  

•    ucontrol->value.integer.value[1] > MAX_VOLUME)
  

• return -EINVAL;
  

• new_vol = ucontrol->value.integer.value[0] |

• ucontrol->value.integer.value[1] << 16;
  

• /* See comment above - DSP firmware implementation */
• switch (kctrl->private_value) {
• case VOLUME_PLAYBACK:

• /* Playback is always on port 0 */
  

• cur_vol = port_info->playback.volume;
  

• siu_write32(base + SBDVCA, new_vol);
  

• port_info->playback.volume = new_vol;
  

• break;
  

• case VOLUME_CAPTURE:

• /* Capture is always on port 1 */
  

• cur_vol = port_info->capture.volume;
  

• siu_write32(base + SBDVCB, new_vol);
  

• port_info->capture.volume = new_vol;
  

• break;
  

• default:

• dev_err(dev, "%s() invalid private_value=%ld\n",
  

• 	__func__, kctrl->private_value);
  

• return -EINVAL;
  

• }
• if (cur_vol != new_vol)

• return 1;
  

• return 0;

+}

+static struct snd_kcontrol_new playback_controls = {

• .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
• .name = "PCM Playback Volume",
• .index = 0,
• .info = siu_dai_info_volume,
• .get = siu_dai_get_volume,
• .put = siu_dai_put_volume,
• .private_value = VOLUME_PLAYBACK,

+};

+static struct snd_kcontrol_new capture_controls = {

• .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
• .name = "PCM Capture Volume",
• .index = 0,
• .info = siu_dai_info_volume,
• .get = siu_dai_get_volume,
• .put = siu_dai_put_volume,
• .private_value = VOLUME_CAPTURE,

+};

+int siu_init_port(int port, struct siu_port **port_info, struct snd_card *card) +{

• struct device *dev = card->dev;
• struct snd_kcontrol *kctrl;
• int ret;
• *port_info = kzalloc(sizeof(**port_info), GFP_KERNEL);
• if (!*port_info)

• return -ENOMEM;
  

• dev_dbg(dev, "%s: port #%d@%p\n", __func__, port, *port_info);
• (*port_info)->playback.volume = DFLT_VOLUME_LEVEL;
• (*port_info)->capture.volume = DFLT_VOLUME_LEVEL;
• /*

• * Add mixer support. The SPB is used to change the volume. Both
  

• * ports use the same SPB. Therefore, we only register one
  

• * control instance since it will be used by both channels.
  

• * In error case we continue without controls.
  

• */
  

• kctrl = snd_ctl_new1(&playback_controls, *port_info);
• ret = snd_ctl_add(card, kctrl);
• if (ret < 0)

• dev_err(dev,
  

• 	"failed to add playback controls %p port=%d err=%d\n",
  

• 	kctrl, port, ret);
  

• kctrl = snd_ctl_new1(&capture_controls, *port_info);
• ret = snd_ctl_add(card, kctrl);
• if (ret < 0)

• dev_err(dev,
  

• 	"failed to add capture controls %p port=%d err=%d\n",
  

• 	kctrl, port, ret);
  

• return 0;

+}

+void siu_free_port(struct siu_port *port_info) +{

• kfree(port_info);

+}

+static int siu_dai_startup(struct snd_pcm_substream *substream,

• 	   struct snd_soc_dai *dai)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct snd_pcm_runtime *rt = substream->runtime;
• struct siu_port *port_info = siu_port_info(substream);
• int ret;
• dev_dbg(substream->pcm->card->dev, "%s: port=%d@%p\n", __func__,

• info->port_id, port_info);
  

• snd_soc_set_runtime_hwparams(substream, &siu_dai_pcm_hw);
• ret = snd_pcm_hw_constraint_integer(rt, SNDRV_PCM_HW_PARAM_PERIODS);
• if (unlikely(ret < 0))

• return ret;
  

• siu_dai_start(port_info);
• return 0;

+}

+static void siu_dai_shutdown(struct snd_pcm_substream *substream,

• 	     struct snd_soc_dai *dai)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_port *port_info = siu_port_info(substream);
• dev_dbg(substream->pcm->card->dev, "%s: port=%d@%p\n", __func__,

• info->port_id, port_info);
  

• if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

• port_info->play_cap &= ~PLAYBACK_ENABLED;
  

• else

• port_info->play_cap &= ~CAPTURE_ENABLED;
  

• /* Stop the siu if the other stream is not using it */
• if (!port_info->play_cap) {

• /* during stmread or stmwrite ? */
  

• BUG_ON(port_info->playback.rw_flg || port_info->capture.rw_flg);
  

• siu_dai_spbstop(port_info);
  

• siu_dai_stop();
  

• }

+}

+/* PCM part of siu_dai_playback_prepare() / siu_dai_capture_prepare() */ +static int siu_dai_prepare(struct snd_pcm_substream *substream,

• 	   struct snd_soc_dai *dai)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct snd_pcm_runtime *rt = substream->runtime;
• struct siu_port *port_info = siu_port_info(substream);
• struct siu_stream *siu_stream;
• int self, ret;
• dev_dbg(substream->pcm->card->dev,

• "%s: port %d, active streams %lx, %d channels\n",
  

• __func__, info->port_id, port_info->play_cap, rt->channels);
  

• if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

• self = PLAYBACK_ENABLED;
  

• siu_stream = &port_info->playback;
  

• } else {

• self = CAPTURE_ENABLED;
  

• siu_stream = &port_info->capture;
  

• }
• /* Set up the siu if not already done */
• if (!port_info->play_cap) {

• siu_stream->rw_flg = 0;	/* stream-data transfer flag */
  

• siu_dai_spbAselect(port_info);
  

• siu_dai_spbBselect(port_info);
  

• siu_dai_open(siu_stream);
  

• siu_dai_pcmdatapack(siu_stream);
  

• ret = siu_dai_spbstart(port_info);
  

• if (ret < 0)
  

• 	goto fail;
  

• }
• port_info->play_cap |= self;

+fail:

• return ret;

+}

+/*

• • SIU can set bus format to I2S / PCM / SPDIF independently for playback and
• • capture, however, the current API sets the bus format globally for a DAI.
• */

+static int siu_dai_set_fmt(struct snd_soc_dai *dai,

• 	   unsigned int fmt)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• u32 ifctl;
• dev_dbg(dai->dev, "%s: fmt 0x%x on port %d\n",

• __func__, fmt, info->port_id);
  

• if (info->port_id < 0)

• return -ENODEV;
  

• /* Here select between I2S / PCM / SPDIF */
• switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
• case SND_SOC_DAIFMT_I2S:

• ifctl = siu_flags[info->port_id].playback.i2s |
  

• 	siu_flags[info->port_id].capture.i2s;
  

• break;
  

• case SND_SOC_DAIFMT_LEFT_J:

• ifctl = siu_flags[info->port_id].playback.pcm |
  

• 	siu_flags[info->port_id].capture.pcm;
  

• break;
  

• /* SPDIF disabled - see comment at the top */
• default:

• return -EINVAL;
  

• }
• ifctl |= ~(siu_flags[info->port_id].playback.mask |

•    siu_flags[info->port_id].capture.mask) &
  

• siu_read32(base + IFCTL);
  

• siu_write32(base + IFCTL, ifctl);
• return 0;

+}

+static int siu_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,

• 	      unsigned int freq, int dir)
  

+{

• struct clk *siu_clk, *parent_clk;
• char *siu_name, *parent_name;
• int ret;
• if (dir != SND_SOC_CLOCK_IN)

• return -EINVAL;
  

• dev_dbg(dai->dev, "%s: using clock %d\n", __func__, clk_id);
• switch (clk_id) {
• case CLKA_PLL:

• siu_name = "siua_clk";
  

• parent_name = "pll_clk";
  

• break;
  

• case CLKA_EXT:

• siu_name = "siua_clk";
  

• parent_name = "siumcka_clk";
  

• break;
  

• case CLKB_PLL:

• siu_name = "siub_clk";
  

• parent_name = "pll_clk";
  

• break;
  

• case CLKB_EXT:

• siu_name = "siub_clk";
  

• parent_name = "siumckb_clk";
  

• break;
  

• default:

• return -EINVAL;
  

• }
• siu_clk = clk_get(siu_i2s_dai.dev, siu_name);
• if (IS_ERR(siu_clk))

• return PTR_ERR(siu_clk);
  

• parent_clk = clk_get(siu_i2s_dai.dev, parent_name);
• if (!IS_ERR(parent_clk)) {

• ret = clk_set_parent(siu_clk, parent_clk);
  

• if (!ret)
  

• 	clk_set_rate(siu_clk, freq);
  

• }
• clk_put(parent_clk);
• clk_put(siu_clk);
• return 0;

+}

+static struct snd_soc_dai_ops siu_dai_ops = {

• .startup = siu_dai_startup,
• .shutdown = siu_dai_shutdown,
• .prepare = siu_dai_prepare,
• .set_sysclk = siu_dai_set_sysclk,
• .set_fmt = siu_dai_set_fmt,

+};

+struct snd_soc_dai siu_i2s_dai = {

• .name = "sh-siu",
• .id = 0,
• .playback = {

• .channels_min = 1,
  

Shouldn't this also be 2 due to mono not used statement in siu_dai_open()

• .channels_max = 2,
  

• .formats = SNDRV_PCM_FMTBIT_S16,
  

• .rates = SNDRV_PCM_RATE_8000_48000,
  

• },
• .capture = {

• .channels_min = 1,
  

• .channels_max = 2,
  

• .formats = SNDRV_PCM_FMTBIT_S16,
  

• .rates = SNDRV_PCM_RATE_8000_48000,
  

• },
  

• .ops = &siu_dai_ops,

+}; +EXPORT_SYMBOL_GPL(siu_i2s_dai);

+static int __devinit siu_probe(struct platform_device *pdev) +{

• const struct firmware *fw_entry;
• struct resource *res, *region;
• struct siu_info *info;
• int ret;
• info = kmalloc(sizeof(*info), GFP_KERNEL);
• if (!info)

• return -ENOMEM;
  

• ret = request_firmware(&fw_entry, "siu_spb.bin", &pdev->dev);
• if (ret)

• goto ereqfw;
  

• /*

• * Loaded firmware is "const" - read only, but we have to modify it in
  

• * snd_siu_sh7343_spbAselect() and snd_siu_sh7343_spbBselect()
  

• */
  

• memcpy(&info->fw, fw_entry->data, fw_entry->size);
• release_firmware(fw_entry);
• res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
• if (!res) {

• ret = -ENODEV;
  

• goto egetres;
  

• }
• region = request_mem_region(res->start, resource_size(res),

• 		    pdev->name);
  

• if (!region) {

• dev_err(&pdev->dev, "SIU region already claimed\n");
  

• ret = -EBUSY;
  

• goto ereqmemreg;
  

• }
• ret = -ENOMEM;
• info->pram = ioremap(res->start, PRAM_SIZE);
• if (!info->pram)

• goto emappram;
  

• info->xram = ioremap(res->start + XRAM_OFFSET, XRAM_SIZE);
• if (!info->xram)

• goto emapxram;
  

• info->yram = ioremap(res->start + YRAM_OFFSET, YRAM_SIZE);
• if (!info->yram)

• goto emapyram;
  

• info->reg = ioremap(res->start + REG_OFFSET, resource_size(res) -

• 	    REG_OFFSET);
  

• if (!info->reg)

• goto emapreg;
  

• siu_i2s_dai.dev = &pdev->dev;
• siu_i2s_dai.private_data = info;
• ret = snd_soc_register_dais(&siu_i2s_dai, 1);
• if (ret < 0)

• goto edaiinit;
  

• ret = snd_soc_register_platform(&siu_platform);
• if (ret < 0)

• goto esocregp;
  

• pm_runtime_enable(&pdev->dev);
• return ret;

+esocregp:

• snd_soc_unregister_dais(&siu_i2s_dai, 1);

+edaiinit:

• iounmap(info->reg);

+emapreg:

• iounmap(info->yram);

+emapyram:

• iounmap(info->xram);

+emapxram:

• iounmap(info->pram);

+emappram:

• release_mem_region(res->start, resource_size(res));

+ereqmemreg: +egetres: +ereqfw:

• kfree(info);
• return ret;

+}

+static int __devexit siu_remove(struct platform_device *pdev) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct resource *res;
• pm_runtime_disable(&pdev->dev);
• snd_soc_unregister_platform(&siu_platform);
• snd_soc_unregister_dais(&siu_i2s_dai, 1);
• iounmap(info->reg);
• iounmap(info->yram);
• iounmap(info->xram);
• iounmap(info->pram);
• res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
• if (res)

• release_mem_region(res->start, resource_size(res));
  

• kfree(info);
• return 0;

+}

+static struct platform_driver siu_driver = {

• .driver = {

• .name	= "sh_siu",
  

• },
• .probe = siu_probe,
• .remove = __devexit_p(siu_remove),

+};

+static int __init siu_init(void) +{

• return platform_driver_register(&siu_driver);

+}

+static void __exit siu_exit(void) +{

• platform_driver_unregister(&siu_driver);

+}

+module_init(siu_init) +module_exit(siu_exit)

+MODULE_AUTHOR("Carlos Munoz carlos@kenati.com"); +MODULE_DESCRIPTION("ALSA SoC SH7722 SIU driver"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/sh/siu_pcm.c b/sound/soc/sh/siu_pcm.c new file mode 100644 index 0000000..afe2e6e --- /dev/null +++ b/sound/soc/sh/siu_pcm.c @@ -0,0 +1,716 @@ +/*

• • siu_pcm.c - ALSA driver for Renesas SH7343, SH7722 SIU peripheral.
• • Copyright (C) 2009-2010 Guennadi Liakhovetski g.liakhovetski@gmx.de
• • Copyright (C) 2006 Carlos Munoz carlos@kenati.com
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation; either version 2 of the License, or
• • (at your option) any later version.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
• */

+#include <linux/delay.h> +#include <linux/dma-mapping.h> +#include <linux/dmaengine.h> +#include <linux/interrupt.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/slab.h>

+#include <sound/control.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> +#include <sound/soc-dai.h>

+#include <asm/dma-sh.h> +#include <asm/siu.h>

+#include "siu.h"

+struct siu_port *siu_ports[MAX_SIU_PORTS];

+static void copy_playback_period(struct siu_stream *siu_stream) +{

• struct snd_pcm_runtime *rt = siu_stream->substream->runtime;
• u16 *src;
• u32 *dst;
• int cp_cnt;
• int i;
• src = (u16 *)PERIOD_OFFSET(rt->dma_area,

• 		   siu_stream->cur_period,
  

• 		   siu_stream->period_bytes);
  

• dst = siu_stream->mono_buf;
• cp_cnt = siu_stream->xfer_cnt;
• for (i = 0; i < cp_cnt; i++)

• *dst++ = *src++;
  

+}

+static void copy_capture_period(struct siu_stream *siu_stream) +{

• struct snd_pcm_runtime *rt = siu_stream->substream->runtime;
• u16 *src;
• u16 *dst;
• int cp_cnt;
• int i;
• dst = (u16 *)PERIOD_OFFSET(rt->dma_area,

• 		   siu_stream->cur_period,
  

• 		   siu_stream->period_bytes);
  

• src = (u16 *)siu_stream->mono_buf;
• cp_cnt = siu_stream->xfer_cnt;
• for (i = 0; i < cp_cnt; i++) {

• *dst++ = *src;
  

• src += 2;
  

• }

+}

+/* transfersize is number of u32 dma transfers per period */ +static int siu_pcm_stmwrite_stop(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_stream *siu_stream = &port_info->playback;
• u32 stfifo;
• if (!siu_stream->rw_flg)

• return -EPERM;
  

• /* output FIFO disable */
• stfifo = siu_read32(base + STFIFO);
• siu_write32(base + STFIFO, stfifo & ~0x0c180c18);
• pr_debug("%s: STFIFO %x -> %x\n", __func__,

•  stfifo, stfifo & ~0x0c180c18);
  

• /* during stmwrite clear */
• siu_stream->rw_flg = 0;
• return 0;

+}

+static int siu_pcm_stmwrite_start(struct siu_port *port_info) +{

• struct siu_stream *siu_stream = &port_info->playback;
• if (siu_stream->rw_flg)

• return -EPERM;
  

• /* Current period in buffer */
• port_info->playback.cur_period = 0;
• /* during stmwrite flag set */
• siu_stream->rw_flg = RWF_STM_WT;
• /* DMA transfer start */
• tasklet_schedule(&siu_stream->tasklet);
• return 0;

+}

+static void siu_dma_tx_complete(void *arg) +{

• struct siu_stream *siu_stream = arg;
• struct snd_pcm_substream *substream = siu_stream->substream;
• if (!siu_stream->rw_flg)

• return;
  

• if (substream->runtime->channels == 1 &&

•    substream->stream == SNDRV_PCM_STREAM_CAPTURE)
  

• copy_capture_period(siu_stream);
  

• /* Update completed period count */
• if (++siu_stream->cur_period >=

•    GET_MAX_PERIODS(siu_stream->buf_bytes,
  

• 	    siu_stream->period_bytes))
  

• siu_stream->cur_period = 0;
  

• pr_debug("%s: done period #%d (%u/%u bytes), cookie %d\n",

• __func__, siu_stream->cur_period,
  

• siu_stream->cur_period * siu_stream->period_bytes,
  

• siu_stream->buf_bytes, siu_stream->cookie);
  

• tasklet_schedule(&siu_stream->tasklet);
• /* Notify alsa: a period is done */
• snd_pcm_period_elapsed(siu_stream->substream);

+}

+static int siu_pcm_wr_set(struct siu_port *port_info,

• 	  dma_addr_t buff, u32 size)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_stream *siu_stream = &port_info->playback;
• struct snd_pcm_substream *substream = siu_stream->substream;
• struct device *dev = substream->pcm->card->dev;
• struct dma_async_tx_descriptor *desc;
• dma_cookie_t cookie;
• struct scatterlist sg;
• u32 stfifo;
• sg_init_table(&sg, 1);
• sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),

•     size, offset_in_page(buff));
  

• sg_dma_address(&sg) = buff;
• desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,

• &sg, 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
  

• if (!desc) {

• dev_err(dev, "Failed to allocate a dma descriptor\n");
  

• return -ENOMEM;
  

• }
• desc->callback = siu_dma_tx_complete;
• desc->callback_param = siu_stream;
• cookie = desc->tx_submit(desc);
• if (cookie < 0) {

• dev_err(dev, "Failed to submit a dma transfer\n");
  

• return cookie;
  

• }
• siu_stream->tx_desc = desc;
• siu_stream->cookie = cookie;
• dma_async_issue_pending(siu_stream->chan);
• /* only output FIFO enable */
• stfifo = siu_read32(base + STFIFO);
• siu_write32(base + STFIFO, stfifo | (port_info->stfifo & 0x0c180c18));
• dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,

• stfifo, stfifo | (port_info->stfifo & 0x0c180c18));
  

• return 0;

+}

+static int siu_pcm_rd_set(struct siu_port *port_info,

• 	  dma_addr_t buff, size_t size)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_stream *siu_stream = &port_info->capture;
• struct snd_pcm_substream *substream = siu_stream->substream;
• struct device *dev = substream->pcm->card->dev;
• struct dma_async_tx_descriptor *desc;
• dma_cookie_t cookie;
• struct scatterlist sg;
• u32 stfifo;
• dev_dbg(dev, "%s: %u@%llx\n", __func__, size, (unsigned long long)buff);
• sg_init_table(&sg, 1);
• sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),

•     size, offset_in_page(buff));
  

• sg_dma_address(&sg) = buff;
• desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,

• &sg, 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
  

• if (!desc) {

• dev_err(dev, "Failed to allocate dma descriptor\n");
  

• return -ENOMEM;
  

• }
• desc->callback = siu_dma_tx_complete;
• desc->callback_param = siu_stream;
• cookie = desc->tx_submit(desc);
• if (cookie < 0) {

• dev_err(dev, "Failed to submit dma descriptor\n");
  

• return cookie;
  

• }
• siu_stream->tx_desc = desc;
• siu_stream->cookie = cookie;
• dma_async_issue_pending(siu_stream->chan);
• /* only input FIFO enable */
• stfifo = siu_read32(base + STFIFO);
• siu_write32(base + STFIFO, siu_read32(base + STFIFO) |

•     (port_info->stfifo & 0x13071307));
  

• dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,

• stfifo, stfifo | (port_info->stfifo & 0x13071307));
  

• return 0;

+}

+static void siu_io_tasklet(unsigned long data) +{

• struct siu_stream *siu_stream = (struct siu_stream *)data;
• struct snd_pcm_substream *substream = siu_stream->substream;
• struct device *dev = substream->pcm->card->dev;
• struct snd_pcm_runtime *rt = substream->runtime;
• struct siu_port *port_info = siu_port_info(substream);
• dev_dbg(dev, "%s: flags %x\n", __func__, siu_stream->rw_flg);
• if (!siu_stream->rw_flg) {

• dev_dbg(dev, "%s: stream inactive\n", __func__);
  

• return;
  

• }
• if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {

• dma_addr_t buff;
  

• size_t count;
  

• u8 *virt;
  

• if (rt->channels == 1) {
  

• 	buff = siu_stream->mono_dma;
  

• 	virt = siu_stream->mono_buf;
  

• 	count = siu_stream->mono_size;
  

• } else {
  

• 	buff = (dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
  

• 			siu_stream->cur_period,
  

• 			siu_stream->period_bytes);
  

• 	virt = PERIOD_OFFSET(rt->dma_area,
  

• 			siu_stream->cur_period,
  

• 			siu_stream->period_bytes);
  

• 	count = siu_stream->period_bytes;
  

• }
  

• /* DMA transfer start */
  

• siu_pcm_rd_set(port_info, buff, count);
  

• } else {

• /* For mono streams we need to use the mono buffer */
  

• if (rt->channels == 1) {
  

• 	copy_playback_period(siu_stream);
  

• 	siu_pcm_wr_set(port_info,
  

• 		siu_stream->mono_dma, siu_stream->mono_size);
  

• } else {
  

• 	siu_pcm_wr_set(port_info,
  

• 		(dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
  

• 			siu_stream->cur_period,
  

• 			siu_stream->period_bytes),
  

• 		siu_stream->period_bytes);
  

• }
  

• }

+}

+/* Capture */ +static int siu_pcm_stmread_start(struct siu_port *port_info) +{

• struct siu_stream *siu_stream = &port_info->capture;
• if (siu_stream->xfer_cnt > 0x1000000)

• return -EINVAL;
  

• if (siu_stream->rw_flg)

• return -EPERM;
  

• /* Current period in buffer */
• siu_stream->cur_period = 0;
• /* during stmread flag set */
• siu_stream->rw_flg = RWF_STM_RD;
• tasklet_schedule(&siu_stream->tasklet);
• return 0;

+}

+static int siu_pcm_stmread_stop(struct siu_port *port_info) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_stream *siu_stream = &port_info->capture;
• struct device *dev = siu_stream->substream->pcm->card->dev;
• u32 stfifo;
• if (!siu_stream->rw_flg)

• return -EPERM;
  

• /* input FIFO disable */
• stfifo = siu_read32(base + STFIFO);
• siu_write32(base + STFIFO, stfifo & ~0x13071307);
• dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,

• stfifo, stfifo & ~0x13071307);
  

• /* during stmread flag clear */
• siu_stream->rw_flg = 0;
• return 0;

+}

+static int siu_pcm_hw_params(struct snd_pcm_substream *ss,

• 	     struct snd_pcm_hw_params *hw_params)
  

+{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct device *dev = ss->pcm->card->dev;
• int ret;
• dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
• ret = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw_params));
• if (ret < 0)

• dev_err(dev, "snd_pcm_lib_malloc_pages() failed\n");
  

• return ret;

+}

+static void siu_pcm_mono_free(struct device *dev, struct siu_stream *stream) +{

• dma_free_coherent(dev, stream->mono_size,

• 	  stream->mono_buf, stream->mono_dma);
  

• stream->mono_buf = NULL;
• stream->mono_size = 0;

+}

+static int siu_pcm_hw_free(struct snd_pcm_substream *ss) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_port *port_info = siu_port_info(ss);
• struct device *dev = ss->pcm->card->dev;
• struct siu_stream *siu_stream;
• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)

• siu_stream = &port_info->playback;
  

• else

• siu_stream = &port_info->capture;
  

• dev_dbg(dev, "%s: port=%d, mono %p\n", __func__,

• info->port_id, siu_stream->mono_buf);
  

• if (siu_stream->mono_buf && ss->runtime->channels == 1)

• siu_pcm_mono_free(ss->pcm->card->dev, siu_stream);
  

• return snd_pcm_lib_free_pages(ss);

+}

+static bool filter(struct dma_chan *chan, void *slave) +{

• struct sh_dmae_slave *param = slave;
• pr_debug("%s: slave ID %d\n", __func__, param->slave_id);
• if (unlikely(param->dma_dev != chan->device->dev))

• return false;
  

• chan->private = param;
• return true;

+}

+static int siu_pcm_open(struct snd_pcm_substream *ss) +{

• /* Playback / Capture */
• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_port *port_info = siu_port_info(ss);
• struct siu_stream *siu_stream;
• u32 port = info->port_id;
• struct siu_platform *pdata = siu_i2s_dai.dev->platform_data;
• struct device *dev = ss->pcm->card->dev;
• dma_cap_mask_t mask;
• struct sh_dmae_slave *param;
• dma_cap_zero(mask);
• dma_cap_set(DMA_SLAVE, mask);
• dev_dbg(dev, "%s, port=%d@%p\n", __func__, port, port_info);
• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) {

• siu_stream = &port_info->playback;
  

• param = &siu_stream->param;
  

• param->slave_id = port ? SHDMA_SLAVE_SIUB_TX :
  

• 	SHDMA_SLAVE_SIUA_TX;
  

• } else {

• siu_stream = &port_info->capture;
  

• param = &siu_stream->param;
  

• param->slave_id = port ? SHDMA_SLAVE_SIUB_RX :
  

• 	SHDMA_SLAVE_SIUA_RX;
  

• }
• param->dma_dev = pdata->dma_dev;
• /* Get DMA channel */
• siu_stream->chan = dma_request_channel(mask, filter, param);
• if (!siu_stream->chan) {

• dev_err(dev, "DMA channel allocation failed!\n");
  

• return -EBUSY;
  

• }
• siu_stream->substream = ss;
• return 0;

+}

+static int siu_pcm_close(struct snd_pcm_substream *ss) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct device *dev = ss->pcm->card->dev;
• struct siu_port *port_info = siu_port_info(ss);
• struct siu_stream *siu_stream;
• dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)

• siu_stream = &port_info->playback;
  

• else

• siu_stream = &port_info->capture;
  

• dma_release_channel(siu_stream->chan);
• siu_stream->chan = NULL;
• siu_stream->substream = NULL;
• return 0;

+}

+static int siu_pcm_mono_alloc(struct device *dev, struct siu_stream *siu_stream) +{

• /*

• * The hardware only supports stereo (2 channels) streams. We must
  

• * convert mono streams (1 channel) to stereo streams. To do that we
  

• * just copy the mono data to one of the stereo channels and instruct
  

• * the siu to play the data on both channels. However, the idle
  

• * channel must also be present in the buffer, so we use an extra
  

• * buffer twice as big as one mono period. Also since this function
  

• * can be called multiple times, we must adjust the buffer size.
  

• */
  

Shouldn't this be done by userspace. i.e. alsa plugin or pulseaudio ?

• if (siu_stream->mono_buf && siu_stream->mono_size !=

•    siu_stream->period_bytes * 2) {
  

• dma_free_coherent(dev, siu_stream->mono_size,
  

• 		  siu_stream->mono_buf, siu_stream->mono_dma);
  

• siu_stream->mono_buf = NULL;
  

• siu_stream->mono_size = 0;
  

• }
• if (!siu_stream->mono_buf) {

• siu_stream->mono_buf = dma_alloc_coherent(dev,
  

• 				siu_stream->period_bytes * 2,
  

• 				&siu_stream->mono_dma,
  

• 				GFP_KERNEL);
  

• if (!siu_stream->mono_buf)
  

• 	return -ENOMEM;
  

• siu_stream->mono_size = siu_stream->period_bytes * 2;
  

• }
• dev_dbg(dev, "%s: mono buffer @ %p\n", __func__, siu_stream->mono_buf);
• return 0;

+}

+static int siu_pcm_prepare(struct snd_pcm_substream *ss) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct siu_port *port_info = siu_port_info(ss);
• struct device *dev = ss->pcm->card->dev;
• struct snd_pcm_runtime *rt = ss->runtime;
• struct siu_stream *siu_stream;
• snd_pcm_sframes_t xfer_cnt;
• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)

• siu_stream = &port_info->playback;
  

• else

• siu_stream = &port_info->capture;
  

• rt = siu_stream->substream->runtime;
• siu_stream->buf_bytes = snd_pcm_lib_buffer_bytes(ss);
• siu_stream->period_bytes = snd_pcm_lib_period_bytes(ss);
• dev_dbg(dev, "%s: port=%d, %d channels, period=%u bytes\n", __func__,

• info->port_id, rt->channels, siu_stream->period_bytes);
  

• /* We only support buffers that are multiples of the period */
• if (siu_stream->buf_bytes % siu_stream->period_bytes) {

• dev_err(dev, "%s() - buffer=%d not multiple of period=%d\n",
  

•        __func__, siu_stream->buf_bytes,
  

•        siu_stream->period_bytes);
  

• return -EINVAL;
  

• }
• xfer_cnt = bytes_to_frames(rt, siu_stream->period_bytes);
• if (!xfer_cnt || xfer_cnt > 0x1000000)

• return -EINVAL;
  

• if (rt->channels == 1) {

• int ret = siu_pcm_mono_alloc(ss->pcm->card->dev,
  

• 			     siu_stream);
  

• if (ret < 0)
  

• 	return ret;
  

• }
• siu_stream->format = rt->format;
• siu_stream->xfer_cnt = xfer_cnt;
• dev_dbg(dev, "port=%d buf=%lx buf_bytes=%d period_bytes=%d "

• "format=%d channels=%d xfer_cnt=%d\n", info->port_id,
  

• (unsigned long)rt->dma_addr, siu_stream->buf_bytes,
  

• siu_stream->period_bytes,
  

• siu_stream->format, rt->channels, (int)xfer_cnt);
  

• return 0;

+}

+static int siu_pcm_trigger(struct snd_pcm_substream *ss, int cmd) +{

• struct siu_info *info = siu_i2s_dai.private_data;
• struct device *dev = ss->pcm->card->dev;
• struct siu_port *port_info = siu_port_info(ss);
• int ret;
• dev_dbg(dev, "%s: port=%d@%p, cmd=%d\n", __func__,

• info->port_id, port_info, cmd);
  

• switch (cmd) {
• case SNDRV_PCM_TRIGGER_START:

• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
  

• 	ret = siu_pcm_stmwrite_start(port_info);
  

• else
  

• 	ret = siu_pcm_stmread_start(port_info);
  

• if (ret < 0)
  

• 	dev_warn(dev, "%s: start failed on port=%d\n",
  

• 		 __func__, info->port_id);
  

• break;
  

• case SNDRV_PCM_TRIGGER_STOP:

• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
  

• 	siu_pcm_stmwrite_stop(port_info);
  

• else
  

• 	siu_pcm_stmread_stop(port_info);
  

• ret = 0;
  

• break;
  

• default:

• dev_err(dev, "%s() unsupported cmd=%d\n", __func__, cmd);
  

• ret = -EINVAL;
  

• }
• return ret;

+}

+/*

• • So far only resolution of one period is supported, subject to extending the
• • dmangine API
• */

+static snd_pcm_uframes_t siu_pcm_pointer_dma(struct snd_pcm_substream *ss) +{

• struct device *dev = ss->pcm->card->dev;
• struct siu_info *info = siu_i2s_dai.private_data;
• u32 __iomem *base = info->reg;
• struct siu_port *port_info = siu_port_info(ss);
• struct snd_pcm_runtime *rt = ss->runtime;
• size_t ptr;
• struct siu_stream *siu_stream;
• if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)

• siu_stream = &port_info->playback;
  

• else

• siu_stream = &port_info->capture;
  

• /*

• * ptr is the offset into the buffer where the dma is currently at. We
  

• * check if the dma buffer has just wrapped.
  

• */
  

• ptr = PERIOD_OFFSET(rt->dma_addr,

• 	    siu_stream->cur_period,
  

• 	    siu_stream->period_bytes) - rt->dma_addr;
  

• dev_dbg(dev,

• "%s: port=%d, events %x, FSTS %x, xferred %u/%u, cookie %d\n",
  

• __func__, info->port_id, siu_read32(base + EVNTC),
  

• siu_read32(base + SBFSTS), ptr, siu_stream->buf_bytes,
  

• siu_stream->cookie);
  

• if (ptr >= siu_stream->buf_bytes)

• ptr = 0;
  

• return bytes_to_frames(ss->runtime, ptr);

+}

+static int siu_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,

•        struct snd_pcm *pcm)
  

+{

• /* card->dev == socdev->dev, see snd_soc_new_pcms() */
• struct siu_info *info = siu_i2s_dai.private_data;
• struct platform_device *pdev = to_platform_device(card->dev);
• int ret;
• int i;
• /* pdev->id selects between SIUA and SIUB */
• if (pdev->id < 0 || pdev->id >= MAX_SIU_PORTS)

• return -EINVAL;
  

• info->port_id = pdev->id;
• /*

• * While the siu has 2 ports, only one port can be on at a time (only 1
  

• * SPB). So far all the boards using the siu had only one of the ports
  

• * wired to a codec. To simplify things, we only register one port with
  

• * alsa. In case both ports are needed, it should be changed here
  

• */
  

• for (i = pdev->id; i < pdev->id + 1; i++) {

• struct siu_port **port_info = &siu_ports[i];
  

• ret = siu_init_port(i, port_info, card);
  

• if (ret < 0)
  

• 	return ret;
  

• ret = snd_pcm_lib_preallocate_pages_for_all(pcm,
  

• 			SNDRV_DMA_TYPE_DEV, NULL,
  

• 			BUFFER_BYTES_MAX, BUFFER_BYTES_MAX);
  

• if (ret < 0) {
  

• 	dev_err(card->dev,
  

• 	       "snd_pcm_lib_preallocate_pages_for_all() err=%d",
  

• 		ret);
  

• 	goto fail;
  

• }
  

• /* IO tasklets */
  

• tasklet_init(&(*port_info)->playback.tasklet, siu_io_tasklet,
  

• 	     (unsigned long)&(*port_info)->playback);
  

• tasklet_init(&(*port_info)->capture.tasklet, siu_io_tasklet,
  

• 	     (unsigned long)&(*port_info)->capture);
  

• }
• dev_info(card->dev, "SuperH SIU driver initialized.\n");
• return 0;

+fail:

• siu_free_port(siu_ports[pdev->id]);
• dev_err(card->dev, "SIU: failed to initialize.\n");
• return ret;

+}

+static void siu_pcm_free(struct snd_pcm *pcm) +{

• struct platform_device *pdev = to_platform_device(pcm->card->dev);
• struct siu_port *port_info = siu_ports[pdev->id];
• tasklet_kill(&port_info->capture.tasklet);
• tasklet_kill(&port_info->playback.tasklet);
• siu_free_port(port_info);
• snd_pcm_lib_preallocate_free_for_all(pcm);
• dev_dbg(pcm->card->dev, "%s\n", __func__);

+}

+static struct snd_pcm_ops siu_pcm_ops = {

• .open = siu_pcm_open,
• .close = siu_pcm_close,
• .ioctl = snd_pcm_lib_ioctl,
• .hw_params = siu_pcm_hw_params,
• .hw_free = siu_pcm_hw_free,
• .prepare = siu_pcm_prepare,
• .trigger = siu_pcm_trigger,
• .pointer = siu_pcm_pointer_dma,

+};

+struct snd_soc_platform siu_platform = {

• .name = "siu-audio",
• .pcm_ops = &siu_pcm_ops,
• .pcm_new = siu_pcm_new,
• .pcm_free = siu_pcm_free,

+}; +EXPORT_SYMBOL_GPL(siu_platform);