Re: [alsa-devel] [PATCH 2/4] ASoC: add DAI and platform drivers

Liam Girdwood
2010-01-19T11:13:16Z

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%6fs, portB%6fs */
> + 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);