| Message ID | 1443105005-4083-1-git-send-email-codekipper@gmail.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Thu, Sep 24, 2015 at 04:30:05PM +0200, codekipper@gmail.com wrote: > From: Marcus Cooper <codekipper@gmail.com> > > The sun4i, sun6i and sun7i SoC families have an SPDIF > block which is capable of playback and capture. I'm not seeing patches 1 or 2 - what's the story here, are there dependencies? Please use subject lines matching the style for the subsystem and also don't fill your subject lines with noisy tags beyond "[PATCH n/x]", when I look at this in my mail client what I see is: -> 432 C 09/24 codekipper@gmai ( 27K) [linux-sunxi][alsa-devel][PATCH 3/3] AS > sound/soc/sunxi/Kconfig | 10 + > sound/soc/sunxi/Makefile | 4 + > sound/soc/sunxi/sunxi-machine-spdif.c | 110 +++++ > sound/soc/sunxi/sunxi-spdif.c | 801 ++++++++++++++++++++++++++++++++++ The machine driver and controller driver should be submitted as separate patches for ease of review. Is there a strong reason for not using simple-card? > +void sunxi_snd_txctrl(struct snd_pcm_substream *substream, > + struct sunxi_spdif_dev *host, int on) > +{ > + u32 tmp; There's no meaningful sharing between the enable and disable paths and only one place either is called, it's better to just inline this into the callers. > + if (!cpu_dai->active) { > + ret = clk_prepare_enable(host->clk); > + if (ret) > + return ret; > + } Can you move the clock enables to runtime PM and let the core do runtime PM for you? > +static int sunxi_spdif_set_clkdiv(struct snd_soc_dai *cpu_dai, > + unsigned int rate, int div) > +{ > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); > + int sample_freq, original_sample_freq; Why are you implementing a set_clkdiv() operation - is the driver not capable of working out its internal clocking automaticallly? > +static int sunxi_spdif_hw_params(struct snd_pcm_substream *substream, > + struct snd_pcm_hw_params *params, > + struct snd_soc_dai *cpu_dai) > +{ > + ret = snd_soc_dai_set_fmt(cpu_dai, fmt); > + if (ret < 0) > + return ret; This looks very broken - what is this doing and why? > +static struct snd_soc_dai_driver sunxi_spdif_dai = { > + .playback = { > + .channels_min = 2, > + .channels_max = 2, > + .rates = SUNXI_RATES, There was code in the driver to handle mono signals but this says only stereo is supported? > + if (clk_prepare_enable(host->apb_clk)) { > + dev_err(&pdev->dev, "try to enable apb_spdif_clk failed\n"); > + return -EINVAL; > + } Don't ignore the error code you got from the API, print it and pass it back.
On 24 September 2015 at 19:29, Mark Brown <broonie@kernel.org> wrote: > On Thu, Sep 24, 2015 at 04:30:05PM +0200, codekipper@gmail.com wrote: >> From: Marcus Cooper <codekipper@gmail.com> >> >> The sun4i, sun6i and sun7i SoC families have an SPDIF >> block which is capable of playback and capture. > > I'm not seeing patches 1 or 2 - what's the story here, are there > dependencies? Please use subject lines matching the style for the > subsystem and also don't fill your subject lines with noisy tags beyond > "[PATCH n/x]", when I look at this in my mail client what I see is: For some reason git-send-email wouldn't send the last patch last night so I pushed it today using another machine. I was thinking last night that the tagging was a bit extreme. I won't do it again. > > -> 432 C 09/24 codekipper@gmai ( 27K) [linux-sunxi][alsa-devel][PATCH 3/3] AS > >> sound/soc/sunxi/Kconfig | 10 + >> sound/soc/sunxi/Makefile | 4 + >> sound/soc/sunxi/sunxi-machine-spdif.c | 110 +++++ >> sound/soc/sunxi/sunxi-spdif.c | 801 ++++++++++++++++++++++++++++++++++ > > The machine driver and controller driver should be submitted as separate > patches for ease of review. Is there a strong reason for not using > simple-card? Yeah..I'm looking for some spiritual guidance here...I'll separate this out and look at alternate methods. > >> +void sunxi_snd_txctrl(struct snd_pcm_substream *substream, >> + struct sunxi_spdif_dev *host, int on) >> +{ >> + u32 tmp; > > There's no meaningful sharing between the enable and disable paths and > only one place either is called, it's better to just inline this into > the callers. > >> + if (!cpu_dai->active) { >> + ret = clk_prepare_enable(host->clk); >> + if (ret) >> + return ret; >> + } > > Can you move the clock enables to runtime PM and let the core do runtime > PM for you? > >> +static int sunxi_spdif_set_clkdiv(struct snd_soc_dai *cpu_dai, >> + unsigned int rate, int div) >> +{ >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); >> + int sample_freq, original_sample_freq; > > Why are you implementing a set_clkdiv() operation - is the driver not > capable of working out its internal clocking automaticallly? > >> +static int sunxi_spdif_hw_params(struct snd_pcm_substream *substream, >> + struct snd_pcm_hw_params *params, >> + struct snd_soc_dai *cpu_dai) >> +{ > >> + ret = snd_soc_dai_set_fmt(cpu_dai, fmt); >> + if (ret < 0) >> + return ret; > > This looks very broken - what is this doing and why? > >> +static struct snd_soc_dai_driver sunxi_spdif_dai = { >> + .playback = { >> + .channels_min = 2, >> + .channels_max = 2, >> + .rates = SUNXI_RATES, > > There was code in the driver to handle mono signals but this says only > stereo is supported? > >> + if (clk_prepare_enable(host->apb_clk)) { >> + dev_err(&pdev->dev, "try to enable apb_spdif_clk failed\n"); >> + return -EINVAL; >> + } > > Don't ignore the error code you got from the API, print it and pass it > back. All points noted and I'll work to clear them...thanks for you time in reviewing this. CK
On Thu, Sep 24, 2015 at 04:30:05PM +0200, codekipper@gmail.com wrote: > From: Marcus Cooper <codekipper@gmail.com> > > The sun4i, sun6i and sun7i SoC families have an SPDIF > block which is capable of playback and capture. > > This patch enables the playback of this block for > the sun4i and sun7i families. > > Signed-off-by: Marcus Cooper <codekipper@gmail.com> > --- > sound/soc/sunxi/Kconfig | 10 + > sound/soc/sunxi/Makefile | 4 + > sound/soc/sunxi/sunxi-machine-spdif.c | 110 +++++ > sound/soc/sunxi/sunxi-spdif.c | 801 ++++++++++++++++++++++++++++++++++ > 4 files changed, 925 insertions(+) > create mode 100644 sound/soc/sunxi/sunxi-machine-spdif.c > create mode 100644 sound/soc/sunxi/sunxi-spdif.c > > diff --git a/sound/soc/sunxi/Kconfig b/sound/soc/sunxi/Kconfig > index 84c72ec..053db02 100644 > --- a/sound/soc/sunxi/Kconfig > +++ b/sound/soc/sunxi/Kconfig > @@ -8,4 +8,14 @@ config SND_SUN4I_CODEC > Select Y or M to add support for the Codec embedded in the Allwinner > A10 and affiliated SoCs. > > +config SND_SOC_SUNXI_DAI_SPDIF > + tristate > + select SND_SOC_GENERIC_DMAENGINE_PCM > + select REGMAP_MMIO > + > +config SND_SOC_SUNXI_MACHINE_SPDIF > + tristate "APB on-chip sun4i/sun5i/sun7i SPDIF" > + select SND_SOC_SUNXI_DAI_SPDIF > + help > + Say Y if you want to add support for SoC S/PDIF audio as simple audio card. > endmenu > diff --git a/sound/soc/sunxi/Makefile b/sound/soc/sunxi/Makefile > index ea8a08c..7849a75 100644 > --- a/sound/soc/sunxi/Makefile > +++ b/sound/soc/sunxi/Makefile > @@ -1,2 +1,6 @@ > obj-$(CONFIG_SND_SUN4I_CODEC) += sun4i-codec.o > > +snd-soc-sunxi-dai-spdif-objs := sunxi-spdif.o > +obj-$(CONFIG_SND_SOC_SUNXI_DAI_SPDIF) += snd-soc-sunxi-dai-spdif.o > +snd-soc-sunxi-machine-spdif-objs := sunxi-machine-spdif.o > +obj-$(CONFIG_SND_SOC_SUNXI_MACHINE_SPDIF) += snd-soc-sunxi-machine-spdif.o > diff --git a/sound/soc/sunxi/sunxi-machine-spdif.c b/sound/soc/sunxi/sunxi-machine-spdif.c > new file mode 100644 > index 0000000..f8f6bd8 > --- /dev/null > +++ b/sound/soc/sunxi/sunxi-machine-spdif.c > @@ -0,0 +1,110 @@ > +/* > + * Copyright (C) 2015 Andrea Venturi <be17068@iperbole.bo.it> > + * From code by (C) 2013 Freescale Semiconductor, Inc. > + * (sound/soc/fsl/imx-spdif.c) > + * > + * 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. > + */ > + > +#include <linux/module.h> > +#include <linux/of_platform.h> > +#include <sound/soc.h> > + > +struct sunxi_machine_spdif_data { > + struct snd_soc_dai_link dai; > + struct snd_soc_card card; > +}; > + > +static int sunxi_machine_spdif_audio_probe(struct platform_device *pdev) > +{ > + struct device_node *spdif_np, *np = pdev->dev.of_node; > + struct sunxi_machine_spdif_data *data; > + int ret = 0; > + > + dev_dbg(&pdev->dev, "%s: Looking for spdif-controller\n", __func__); > + spdif_np = of_parse_phandle(np, "spdif-controller", 0); > + if (!spdif_np) { > + dev_err(&pdev->dev, "failed to find spdif-controller\n"); > + ret = -EINVAL; > + goto end; > + } > + > + data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); > + if (!data) { > + ret = -ENOMEM; > + goto end; > + } > + > + data->dai.name = "S/PDIF PCM"; > + data->dai.stream_name = "S/PDIF PCM"; > + data->dai.codec_dai_name = "snd-soc-dummy-dai"; > + data->dai.codec_name = "snd-soc-dummy"; > + data->dai.cpu_of_node = spdif_np; > + data->dai.platform_of_node = spdif_np; > + data->dai.playback_only = true; > + data->dai.capture_only = true; > + > + if (of_property_read_bool(np, "spdif-out")) > + data->dai.capture_only = false; > + > + if (of_property_read_bool(np, "spdif-in")) > + data->dai.playback_only = false; > + > + if (data->dai.playback_only && data->dai.capture_only) { > + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); > + goto end; > + } > + > + data->card.dev = &pdev->dev; > + data->card.dai_link = &data->dai; > + data->card.num_links = 1; > + data->card.owner = THIS_MODULE; > + > + ret = snd_soc_of_parse_card_name(&data->card, "model"); > + if (ret) > + goto end; > + > + ret = devm_snd_soc_register_card(&pdev->dev, &data->card); > + if (ret) { > + dev_err(&pdev->dev, "snd_soc_register_card failed: %d\n", ret); > + goto end; > + } > + > + platform_set_drvdata(pdev, data); > + > +end: > + of_node_put(spdif_np); > + > + return ret; > +} > + > +#ifdef CONFIG_OF > +static const struct of_device_id sunxi_machine_spdif_dt_ids[] = { > + { .compatible = "allwinner,sunxi-audio-spdif", }, > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(of, sunxi_machine_spdif_dt_ids); > +#endif > + > +static struct platform_driver sunxi_machine_spdif_driver = { > + .driver = { > + .name = "sunxi-machine-spdif", > + .of_match_table = sunxi_machine_spdif_dt_ids, > + }, > + .probe = sunxi_machine_spdif_audio_probe, > +}; > + > +module_platform_driver(sunxi_machine_spdif_driver); > + > +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); > +MODULE_AUTHOR("Andrea Venturi, <be17068@iperbole.bo.it>"); > +MODULE_DESCRIPTION("Allwinner sunxi S/PDIF machine driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/sound/soc/sunxi/sunxi-spdif.c b/sound/soc/sunxi/sunxi-spdif.c > new file mode 100644 > index 0000000..cae9261 > --- /dev/null > +++ b/sound/soc/sunxi/sunxi-spdif.c > @@ -0,0 +1,801 @@ > +/* > + * ALSA SoC SPDIF Audio Layer > + * > + * Copyright 2015 Andrea Venturi <be17068@iperbole.bo.it> > + * Copyright 2015 Marcus Cooper <codekipper@gmail.com> > + * > + * Based on the Allwinner SDK driver, released under the GPL. > + * > + * 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. > + */ > + > +/* > + * this is SPDIF sunxi simple audio card DAI driver that uses the codec > + * "dummy driver" as per sound/soc/fsl/imx-spdif.c > + */ > +#include <linux/clk.h> > +#include <linux/delay.h> > +#include <linux/device.h> > +#include <linux/kernel.h> > +#include <linux/init.h> > +#include <linux/regmap.h> > +#include <linux/of_address.h> > +#include <linux/of_device.h> > +#include <linux/ioport.h> > +#include <linux/module.h> > +#include <linux/platform_device.h> > +#include <sound/dmaengine_pcm.h> > +#include <sound/pcm_params.h> > +#include <sound/soc.h> > + > +#define SUNXI_SPDIF_CTL (0x00) > + #define SUNXI_SPDIF_CTL_MCLKDIV(v) ((v) << 4) /* v even */ > + #define SUNXI_SPDIF_CTL_MCLKOUTEN BIT(2) > + #define SUNXI_SPDIF_CTL_GEN BIT(1) > + #define SUNXI_SPDIF_CTL_RESET BIT(0) > + > +#define SUNXI_SPDIF_TXCFG (0x04) > + #define SUNXI_SPDIF_TXCFG_SINGLEMOD BIT(31) > + #define SUNXI_SPDIF_TXCFG_ASS BIT(17) > + #define SUNXI_SPDIF_TXCFG_NONAUDIO BIT(16) > + #define SUNXI_SPDIF_TXCFG_TXRATIO(v) ((v) << 4) > + #define SUNXI_SPDIF_TXCFG_TXRATIO_MASK GENMASK(8, 4) > + #define SUNXI_SPDIF_TXCFG_FMTRVD GENMASK(3, 2) > + #define SUNXI_SPDIF_TXCFG_FMT16BIT (0 << 2) > + #define SUNXI_SPDIF_TXCFG_FMT20BIT (1 << 2) > + #define SUNXI_SPDIF_TXCFG_FMT24BIT (2 << 2) > + #define SUNXI_SPDIF_TXCFG_CHSTMODE BIT(1) > + #define SUNXI_SPDIF_TXCFG_TXEN BIT(0) > + > +#define SUNXI_SPDIF_RXCFG (0x08) > + #define SUNXI_SPDIF_RXCFG_LOCKFLAG BIT(4) > + #define SUNXI_SPDIF_RXCFG_CHSTSRC BIT(3) > + #define SUNXI_SPDIF_RXCFG_CHSTCP BIT(1) > + #define SUNXI_SPDIF_RXCFG_RXEN BIT(0) > + > +#define SUNXI_SPDIF_TXFIFO (0x0C) > + > +#define SUNXI_SPDIF_RXFIFO (0x10) > + > +#define SUNXI_SPDIF_FCTL (0x14) > + #define SUNXI_SPDIF_FCTL_FIFOSRC BIT(31) > + #define SUNXI_SPDIF_FCTL_FTX BIT(17) > + #define SUNXI_SPDIF_FCTL_FRX BIT(16) > + #define SUNXI_SPDIF_FCTL_TXTL(v) ((v) << 8) > + #define SUNXI_SPDIF_FCTL_TXTL_MASK GENMASK(12, 8) > + #define SUNXI_SPDIF_FCTL_RXTL(v) ((v) << 3) > + #define SUNXI_SPDIF_FCTL_RXTL_MASK GENMASK(7, 3) > + #define SUNXI_SPDIF_FCTL_TXIM BIT(2) > + #define SUNXI_SPDIF_FCTL_RXOM(v) ((v) << 0) > + #define SUNXI_SPDIF_FCTL_RXOM_MASK GENMASK(1, 0) > + > +#define SUNXI_SPDIF_FSTA (0x18) > + #define SUNXI_SPDIF_FSTA_TXE BIT(14) > + #define SUNXI_SPDIF_FSTA_TXECNTSHT (8) > + #define SUNXI_SPDIF_FSTA_RXA BIT(6) > + #define SUNXI_SPDIF_FSTA_RXACNTSHT (0) > + > +#define SUNXI_SPDIF_INT (0x1C) > + #define SUNXI_SPDIF_INT_RXLOCKEN BIT(18) > + #define SUNXI_SPDIF_INT_RXUNLOCKEN BIT(17) > + #define SUNXI_SPDIF_INT_RXPARERREN BIT(16) > + #define SUNXI_SPDIF_INT_TXDRQEN BIT(7) > + #define SUNXI_SPDIF_INT_TXUIEN BIT(6) > + #define SUNXI_SPDIF_INT_TXOIEN BIT(5) > + #define SUNXI_SPDIF_INT_TXEIEN BIT(4) > + #define SUNXI_SPDIF_INT_RXDRQEN BIT(2) > + #define SUNXI_SPDIF_INT_RXOIEN BIT(1) > + #define SUNXI_SPDIF_INT_RXAIEN BIT(0) > + > +#define SUNXI_SPDIF_ISTA (0x20) > + #define SUNXI_SPDIF_ISTA_RXLOCKSTA BIT(18) > + #define SUNXI_SPDIF_ISTA_RXUNLOCKSTA BIT(17) > + #define SUNXI_SPDIF_ISTA_RXPARERRSTA BIT(16) > + #define SUNXI_SPDIF_ISTA_TXUSTA BIT(6) > + #define SUNXI_SPDIF_ISTA_TXOSTA BIT(5) > + #define SUNXI_SPDIF_ISTA_TXESTA BIT(4) > + #define SUNXI_SPDIF_ISTA_RXOSTA BIT(1) > + #define SUNXI_SPDIF_ISTA_RXASTA BIT(0) > + > +#define SUNXI_SPDIF_TXCNT (0x24) > + > +#define SUNXI_SPDIF_RXCNT (0x28) > + > +#define SUNXI_SPDIF_TXCHSTA0 (0x2C) > + #define SUNXI_SPDIF_TXCHSTA0_CLK(v) ((v) << 28) > + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ(v) ((v) << 24) > + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK GENMASK(27, 24) > + #define SUNXI_SPDIF_TXCHSTA0_CHNUM(v) ((v) << 20) > + #define SUNXI_SPDIF_TXCHSTA0_CHNUM_MASK GENMASK(23, 20) > + #define SUNXI_SPDIF_TXCHSTA0_SRCNUM(v) ((v) << 16) > + #define SUNXI_SPDIF_TXCHSTA0_CATACOD(v) ((v) << 8) > + #define SUNXI_SPDIF_TXCHSTA0_MODE(v) ((v) << 6) > + #define SUNXI_SPDIF_TXCHSTA0_EMPHASIS(v) ((v) << 3) > + #define SUNXI_SPDIF_TXCHSTA0_CP BIT(2) > + #define SUNXI_SPDIF_TXCHSTA0_AUDIO BIT(1) > + #define SUNXI_SPDIF_TXCHSTA0_PRO BIT(0) > + > +#define SUNXI_SPDIF_TXCHSTA1 (0x30) > + #define SUNXI_SPDIF_TXCHSTA1_CGMSA(v) ((v) << 8) > + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(v) ((v) << 4) > + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK GENMASK(7, 4) > + #define SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(v) ((v) << 1) > + #define SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN BIT(0) > + > +#define SUNXI_SPDIF_RXCHSTA0 (0x34) > + #define SUNXI_SPDIF_RXCHSTA0_CLK(v) ((v) << 28) > + #define SUNXI_SPDIF_RXCHSTA0_SAMFREQ(v) ((v) << 24) > + #define SUNXI_SPDIF_RXCHSTA0_CHNUM(v) ((v) << 20) > + #define SUNXI_SPDIF_RXCHSTA0_SRCNUM(v) ((v) << 16) > + #define SUNXI_SPDIF_RXCHSTA0_CATACOD(v) ((v) << 8) > + #define SUNXI_SPDIF_RXCHSTA0_MODE(v) ((v) << 6) > + #define SUNXI_SPDIF_RXCHSTA0_EMPHASIS(v) ((v) << 3) > + #define SUNXI_SPDIF_RXCHSTA0_CP BIT(2) > + #define SUNXI_SPDIF_RXCHSTA0_AUDIO BIT(1) > + #define SUNXI_SPDIF_RXCHSTA0_PRO BIT(0) > + > +#define SUNXI_SPDIF_RXCHSTA1 (0x38) > + #define SUNXI_SPDIF_RXCHSTA1_CGMSA(v) ((v) << 8) > + #define SUNXI_SPDIF_RXCHSTA1_ORISAMFREQ(v) ((v) << 4) > + #define SUNXI_SPDIF_RXCHSTA1_SAMWORDLEN(v) ((v) << 1) > + #define SUNXI_SPDIF_RXCHSTA1_MAXWORDLEN BIT(0) > + > +/* Defines for Sampling Frequency */ > +enum sunxi_spdif_sampling_freq { > + SUNXI_SPDIF_SAMFREQ_44_1KHZ = 0x0, > + SUNXI_SPDIF_SAMFREQ_NOT_INDICATED = 0x1, > + SUNXI_SPDIF_SAMFREQ_48KHZ = 0x2, > + SUNXI_SPDIF_SAMFREQ_32KHZ = 0x3, > + SUNXI_SPDIF_SAMFREQ_22_05KHZ = 0x4, > + SUNXI_SPDIF_SAMFREQ_24KHZ = 0x6, > + SUNXI_SPDIF_SAMFREQ_88_2KHZ = 0x8, > + SUNXI_SPDIF_SAMFREQ_768KHZ = 0x9, > + SUNXI_SPDIF_SAMFREQ_96KHZ = 0xa, > + SUNXI_SPDIF_SAMFREQ_176_4KHZ = 0xc, > + SUNXI_SPDIF_SAMFREQ_192KHZ = 0xe, > +}; > + > +/* > + * Original sampling frequency can be represented by inverting the value of the > + * sampling frequency. > + */ > +#define ORIGINAL(v) ((~v) & 0xf) > + > +struct sunxi_spdif_dev { > + struct platform_device *pdev; > + struct clk *clk; > + struct clk *apb_clk; > + struct clk *audio_clk; > + struct snd_soc_dai_driver cpu_dai_drv; > + bool running; > + struct regmap *regmap; > + struct snd_dmaengine_dai_dma_data dma_params_tx; > + struct snd_dmaengine_dai_dma_data dma_params_rx; > + bool playback_supported; > + bool capture_supported; > +}; > + > +static void sunxi_spdif_configure(struct sunxi_spdif_dev *host) > +{ > + u32 reg_val; > + > + /* soft reset SPDIF */ > + regmap_write(host->regmap, SUNXI_SPDIF_CTL, SUNXI_SPDIF_CTL_RESET); > + > + /* MCLK OUTPUT enable */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, > + SUNXI_SPDIF_CTL_MCLKOUTEN, SUNXI_SPDIF_CTL_MCLKOUTEN); > + > + /* flush TX FIFO */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_FCTL, SUNXI_SPDIF_FCTL_FTX, > + SUNXI_SPDIF_FCTL_FTX); The new line should be aligned on an open parenthesis. > + > + /* clear interrupt status */ > + regmap_read(host->regmap, SUNXI_SPDIF_ISTA, ®_val); > + regmap_write(host->regmap, SUNXI_SPDIF_ISTA, reg_val); > + > + /* clear TX counter */ > + regmap_write(host->regmap, SUNXI_SPDIF_TXCNT, 0); > + > +} > + > +void sunxi_snd_txctrl(struct snd_pcm_substream *substream, > + struct sunxi_spdif_dev *host, int on) > +{ > + u32 tmp; > + > + regmap_read(host->regmap, SUNXI_SPDIF_TXCNT, &tmp); > + if (substream->runtime->channels == 1) > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, > + SUNXI_SPDIF_TXCFG_SINGLEMOD, > + SUNXI_SPDIF_TXCFG_SINGLEMOD); > + > + if (on) { > + /* SPDIF TX ENABLE */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, > + SUNXI_SPDIF_TXCFG_TXEN, > + SUNXI_SPDIF_TXCFG_TXEN); > + > + /* DRQ ENABLE */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, > + SUNXI_SPDIF_INT_TXDRQEN, > + SUNXI_SPDIF_INT_TXDRQEN); > + > + /* Global enable */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, > + SUNXI_SPDIF_CTL_GEN, > + SUNXI_SPDIF_CTL_GEN); > + } else { > + /* SPDIF TX DISABLE */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, > + SUNXI_SPDIF_TXCFG_TXEN, 0); > + > + /* DRQ DISABLE */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, > + SUNXI_SPDIF_INT_TXDRQEN, 0); > + > + /* Global disable */ > + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, > + SUNXI_SPDIF_CTL_GEN, 0); > + } > +} > + > +static int sunxi_spdif_startup(struct snd_pcm_substream *substream, > + struct snd_soc_dai *cpu_dai) > +{ > + struct snd_soc_pcm_runtime *rtd = substream->private_data; > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); > + int ret; > + > + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) > + return -EINVAL; > + > + /* Reset module and interrupts only for first initialization */ > + if (!cpu_dai->active) { > + ret = clk_prepare_enable(host->clk); Can't you just use runtime_pm to deal with that? > + if (ret) > + return ret; > + } > + > + host->running = true; > + sunxi_spdif_configure(host); > + > + return 0; > +} > + > +static void sunxi_spdif_shutdown(struct snd_pcm_substream *substream, > + struct snd_soc_dai *dai) > +{ > + struct snd_soc_pcm_runtime *rtd = substream->private_data; > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); > + > + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) > + return; > + > + clk_disable_unprepare(host->clk); > + host->running = false; > +} > + > +static int sunxi_spdif_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt) > +{ > + u32 reg_val; > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); > + > + reg_val = 0; > + reg_val &= ~SUNXI_SPDIF_TXCFG_SINGLEMOD; > + reg_val |= SUNXI_SPDIF_TXCFG_ASS; > + reg_val |= fmt; /* set non audio and bit depth */ > + reg_val |= SUNXI_SPDIF_TXCFG_CHSTMODE; > + regmap_write(host->regmap, SUNXI_SPDIF_TXCFG, reg_val); You can probably used regmap_update_bits for that. > + reg_val = 0; > + reg_val &= ~SUNXI_SPDIF_FCTL_FIFOSRC; > + reg_val |= SUNXI_SPDIF_FCTL_TXTL_MASK; > + reg_val |= SUNXI_SPDIF_FCTL_RXTL_MASK; > + reg_val |= SUNXI_SPDIF_FCTL_TXIM; > + reg_val |= SUNXI_SPDIF_FCTL_RXOM_MASK; > + regmap_write(host->regmap, SUNXI_SPDIF_FCTL, reg_val); > + reg_val = 0; > + reg_val |= (SUNXI_SPDIF_TXCHSTA0_CHNUM(2)); > + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA0, reg_val); > + > + reg_val = 0; > + reg_val |= (SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(1)); > + if ((fmt & SUNXI_SPDIF_TXCFG_FMT24BIT) == SUNXI_SPDIF_TXCFG_FMT24BIT) > + reg_val |= SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN; > + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA1, reg_val); > + return 0; > +} > + > +static int sunxi_spdif_set_sysclk(struct snd_soc_dai *cpu_dai, unsigned int freq) > +{ > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); > + struct platform_device *pdev = host->pdev; > + > + if (clk_set_rate(host->audio_clk, freq)) > + dev_err(&pdev->dev, > + "Setting pll2 clock rate for %d Hz failed!\n", freq); > + if (clk_set_rate(host->clk, freq)) > + dev_err(&pdev->dev, > + "Setting SPDIF clock rate for %d Hz failed!\n", freq); > + return 0; > +} > + > +static int sunxi_spdif_set_clkdiv(struct snd_soc_dai *cpu_dai, > + unsigned int rate, int div) > +{ > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); > + int sample_freq, original_sample_freq; > + > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, > + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, 0); > + > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, > + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, 0); Why do you need to clear the registers before writing them again? > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, > + SUNXI_SPDIF_TXCFG_TXRATIO_MASK, > + SUNXI_SPDIF_TXCFG_TXRATIO(div - 1)); > + > + if (rate == 24576000) { > + switch (div) { > + /* 24KHZ */ > + case 8: > + sample_freq = SUNXI_SPDIF_SAMFREQ_24KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_24KHZ); What is this original sample frequency? > + break; > + > + /* 32KHZ */ > + case 6: > + sample_freq = SUNXI_SPDIF_SAMFREQ_32KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_32KHZ); > + break; > + > + /* 48KHZ */ > + case 4: > + sample_freq = SUNXI_SPDIF_SAMFREQ_48KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_48KHZ); > + break; > + > + /* 96KHZ */ > + case 2: > + sample_freq = SUNXI_SPDIF_SAMFREQ_96KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_96KHZ); > + break; > + > + /* 192KHZ */ > + case 1: > + sample_freq = SUNXI_SPDIF_SAMFREQ_192KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_192KHZ); > + break; > + > + default: > + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; > + original_sample_freq = 0; > + break; > + } > + } else { > + /* 22.5792MHz */ > + switch (div) { > + /* 22.05KHZ */ > + case 8: > + sample_freq = SUNXI_SPDIF_SAMFREQ_22_05KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_22_05KHZ); > + break; > + > + /* 44.1KHZ */ > + case 4: > + sample_freq = SUNXI_SPDIF_SAMFREQ_44_1KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_44_1KHZ); > + break; > + > + /* 88.2KHZ */ > + case 2: > + sample_freq = SUNXI_SPDIF_SAMFREQ_88_2KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_88_2KHZ); > + break; > + > + /* 176.4KHZ */ > + case 1: > + sample_freq = SUNXI_SPDIF_SAMFREQ_176_4KHZ; > + original_sample_freq > + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_176_4KHZ); > + break; > + You can probably turn this into a funcion that computes it, instead of having to duplicated and almost identical switch statements. > + default: > + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; > + original_sample_freq = 0; > + break; > + } > + } Shouldn't you return an error in such a case? > + > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, > + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, > + SUNXI_SPDIF_TXCHSTA0_SAMFREQ(sample_freq)); > + > + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, > + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, > + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(original_sample_freq)); > + > + return 0; > +} > + > +static int sunxi_spdif_hw_params(struct snd_pcm_substream *substream, > + struct snd_pcm_hw_params *params, > + struct snd_soc_dai *cpu_dai) > +{ > + int ret = 0; > + int fmt; > + unsigned long rate = params_rate(params); > + u32 mclk_div = 0; > + unsigned int mclk = 0; > + > + /* Add the PCM and raw data select interface */ > + switch (params_channels(params)) { > + case 1: /* PCM mode */ > + case 2: > + fmt = 0; > + break; > + case 4: /* raw data mode */ > + fmt = SUNXI_SPDIF_TXCFG_NONAUDIO; > + break; > + default: > + return -EINVAL; > + } > + > + switch (params_format(params)) { > + case SNDRV_PCM_FORMAT_S16_LE: > + fmt |= SUNXI_SPDIF_TXCFG_FMT16BIT; > + break; > + case SNDRV_PCM_FORMAT_S20_3LE: > + fmt |= SUNXI_SPDIF_TXCFG_FMT20BIT; > + break; > + case SNDRV_PCM_FORMAT_S24_LE: > + fmt |= SUNXI_SPDIF_TXCFG_FMT24BIT; > + break; > + default: > + return -EINVAL; > + } > + > + ret = snd_soc_dai_set_fmt(cpu_dai, fmt); > + if (ret < 0) > + return ret; > + > + switch (rate) { > + case 22050: > + case 44100: > + case 88200: > + case 176400: > + mclk = 22579200; > + break; > + case 24000: > + case 32000: > + case 48000: > + case 96000: > + case 192000: > + mclk = 24576000; > + break; > + default: > + return -EINVAL; > + } > + > + ret = sunxi_spdif_set_sysclk(cpu_dai, mclk); > + if (ret < 0) > + return ret; > + > + switch (rate) { > + case 22050: > + case 24000: > + mclk_div = 8; > + break; > + case 32000: > + mclk_div = 6; > + break; > + case 44100: > + case 48000: > + mclk_div = 4; > + break; > + case 88200: > + case 96000: > + mclk_div = 2; > + break; > + case 176400: > + case 192000: > + mclk_div = 1; > + break; > + default: > + return -EINVAL; > + } > + > + ret = sunxi_spdif_set_clkdiv(cpu_dai, mclk, mclk_div); > + if (ret < 0) > + return ret; > + > + return 0; > +} > + > +static int sunxi_spdif_trigger(struct snd_pcm_substream *substream, int cmd, > + struct snd_soc_dai *dai) > +{ > + int ret = 0; > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); > + > + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) > + return -EINVAL; > + > + switch (cmd) { > + case SNDRV_PCM_TRIGGER_START: > + case SNDRV_PCM_TRIGGER_RESUME: > + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: > + sunxi_snd_txctrl(substream, host, 1); > + break; > + > + case SNDRV_PCM_TRIGGER_STOP: > + case SNDRV_PCM_TRIGGER_SUSPEND: > + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: > + sunxi_snd_txctrl(substream, host, 0); > + break; > + > + default: > + ret = -EINVAL; > + break; > + } > + return ret; > +} > + > +static int sunxi_spdif_soc_dai_probe(struct snd_soc_dai *dai) > +{ > + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); > + > + snd_soc_dai_init_dma_data(dai, &host->dma_params_tx, > + &host->dma_params_rx); > + return 0; > +} > + > +static const struct snd_soc_dai_ops sunxi_spdif_dai_ops = { > + .startup = sunxi_spdif_startup, > + .shutdown = sunxi_spdif_shutdown, > + .trigger = sunxi_spdif_trigger, > + .hw_params = sunxi_spdif_hw_params, > + .set_fmt = sunxi_spdif_set_fmt, > +}; > + > +static const struct regmap_config sunxi_spdif_regmap_config = { > + .reg_bits = 32, > + .reg_stride = 4, > + .val_bits = 32, > + .max_register = SUNXI_SPDIF_RXCHSTA1, > +}; > + > +#define SUNXI_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \ > + SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ > + SNDRV_PCM_RATE_192000) > +#define SUNXI_FORMATS (SNDRV_PCM_FORMAT_S16_LE | SNDRV_PCM_FORMAT_S20_3LE | \ > + SNDRV_PCM_FORMAT_S24_LE) > + > +static struct snd_soc_dai_driver sunxi_spdif_dai = { > + .playback = { > + .channels_min = 2, > + .channels_max = 2, > + .rates = SUNXI_RATES, > + .formats = SUNXI_FORMATS, > + }, > + .probe = sunxi_spdif_soc_dai_probe, > + .ops = &sunxi_spdif_dai_ops, > + .name = "spdif", > +}; > + > +static const struct snd_soc_dapm_widget dit_widgets[] = { > + SND_SOC_DAPM_OUTPUT("spdif-out"), > +}; > + > +static const struct snd_soc_dapm_route dit_routes[] = { > + { "spdif-out", NULL, "Playback" }, > +}; > + > +#ifdef CONFIG_OF You don't support !dt probing. You should probably only depend on CONFIG_OF in Kconfig. > +static const struct of_device_id sunxi_spdif_of_match[] = { > + { .compatible = "allwinner,sun4i-a10-spdif", }, I'd prefer to have the driver named sun4i-spdif (in the driver name, prefixes, Kconfig options, etc.) so that if there's a new spdif IP introduced, you don't end up with something weird. > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(of, sunxi_spdif_of_match); > +#endif > + > +static const struct snd_soc_component_driver sunxi_spdif_component = { > + .name = "sunxi-spdif", > +}; > + > +static int sunxi_spdif_probe(struct platform_device *pdev) > +{ > + struct device_node *np = pdev->dev.of_node; > + struct sunxi_spdif_dev *host; > + struct resource *res; > + int ret; > + const struct of_device_id *of_id; > + void __iomem *base; > + > + dev_dbg(&pdev->dev, "Entered %s\n", __func__); > + > + if (!np) > + return -ENODEV; > + > + of_id = of_match_device(sunxi_spdif_of_match, &pdev->dev); > + if (!of_id) { > + dev_err(&pdev->dev, "No matched devices found.\n"); > + return -EINVAL; > + } Are you using that of_id anywhere? > + > + host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); > + if (!host) > + return -ENOMEM; > + > + host->pdev = pdev; > + > + /* Initialize this copy of the CPU DAI driver structure */ > + memcpy(&host->cpu_dai_drv, &sunxi_spdif_dai, sizeof(sunxi_spdif_dai)); > + host->cpu_dai_drv.name = dev_name(&pdev->dev); > + > + /* Get the addresses */ > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + base = devm_ioremap_resource(&pdev->dev, res); > + if (IS_ERR(base)) > + return PTR_ERR(base); > + > + host->regmap = devm_regmap_init_mmio(&pdev->dev, base, > + &sunxi_spdif_regmap_config); > + > + /* Clocks */ > + host->apb_clk = devm_clk_get(&pdev->dev, "apb"); > + if (IS_ERR(host->apb_clk)) { > + dev_err(&pdev->dev, "failed to get a apb clock.\n"); > + return PTR_ERR(host->apb_clk); > + } > + > + if (clk_prepare_enable(host->apb_clk)) { > + dev_err(&pdev->dev, "try to enable apb_spdif_clk failed\n"); > + return -EINVAL; > + } > + > + host->audio_clk = devm_clk_get(&pdev->dev, "audio"); > + if (IS_ERR(host->audio_clk)) { > + dev_err(&pdev->dev, "failed to get an audio clock.\n"); > + return PTR_ERR(host->audio_clk); > + } > + > + host->clk = devm_clk_get(&pdev->dev, "spdif"); > + if (IS_ERR(host->clk)) { > + dev_err(&pdev->dev, "failed to get a spdif clock.\n"); > + return PTR_ERR(host->clk); > + } > + > + ret = clk_set_rate(host->audio_clk, 24576000); > + if (ret) { > + dev_err(&pdev->dev, "set spdif base clock failed!\n"); > + return ret; > + } Why do you need to have to poke at PLL2 directly? the spdif clock is its direct child. If you have to set a rate, do it directly on this clock. And you don't have to assign a rate at probe time either since you will like change it when the playback will start > + if (clk_prepare_enable(host->audio_clk)) { > + dev_err(&pdev->dev, "try to enable audio clk failed\n"); > + ret = -EINVAL; > + goto exit_clkdisable_apb_clk; > + } > + > + host->playback_supported = false; > + host->capture_supported = false; > + > + if (of_property_read_bool(np, "spdif-out")) > + host->playback_supported = true; > + > + if (!host->playback_supported) { > + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); > + goto exit_clkdisable_clk; > + } > + > + host->dma_params_tx.addr = res->start + SUNXI_SPDIF_TXFIFO; > + host->dma_params_tx.maxburst = 4; > + host->dma_params_tx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; > + host->dma_params_rx.addr = res->start + SUNXI_SPDIF_RXFIFO; > + host->dma_params_rx.maxburst = 4; > + host->dma_params_rx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; > + > + /* Register with ASoC */ > + dev_set_drvdata(&pdev->dev, host); That's not what it does. And you can use platform_set_drvdata here > + > + ret = devm_snd_soc_register_component(&pdev->dev, > + &sunxi_spdif_component, &sunxi_spdif_dai, 1); > + if (ret) > + goto exit_clkdisable_clk; > + > + ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); > + if (ret) > + goto exit_clkdisable_clk; > + return 0; > + > +exit_clkdisable_clk: > + clk_disable_unprepare(host->clk); > +exit_clkdisable_apb_clk: > + clk_disable_unprepare(host->apb_clk); > + return ret; > +} > + > +static int sunxi_spdif_remove(struct platform_device *pdev) > +{ > + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); > + > + snd_soc_unregister_platform(&pdev->dev); > + snd_soc_unregister_component(&pdev->dev); > + > + if (!IS_ERR(host->clk)) { > + clk_disable_unprepare(host->clk); > + clk_disable_unprepare(host->apb_clk); > + } > + > + return 0; > +} > + > +#ifdef CONFIG_PM > +static int sunxi_spdif_suspend(struct device *dev) > +{ > + struct platform_device *pdev = to_platform_device(dev); > + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); > + > + if (host->running) > + clk_disable(host->clk); > + > + return 0; > +} > + > +static int sunxi_spdif_resume(struct device *dev) > +{ > + struct platform_device *pdev = to_platform_device(dev); > + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); > + > + if (host->running) { > + clk_enable(host->clk); > + sunxi_spdif_configure(host); > + } > + return 0; > +} > + > +static SIMPLE_DEV_PM_OPS(spdif_dev_pm_ops, sunxi_spdif_suspend, > + sunxi_spdif_resume); > + > +#define SPDIF_DEV_PM_OPS (&spdif_dev_pm_ops) How did you test this? > +#else > +#define SPDIF_DEV_PM_OPS NULL > + > +#endif > + > +static struct platform_driver sunxi_spdif_driver = { > + .driver = { > + .name = "sunxi-spdif", > + .owner = THIS_MODULE, That's not needed anymore. > + .pm = SPDIF_DEV_PM_OPS, > + .of_match_table = of_match_ptr(sunxi_spdif_of_match), > + }, > + .probe = sunxi_spdif_probe, > + .remove = sunxi_spdif_remove, > +}; > + > +module_platform_driver(sunxi_spdif_driver); > + > +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); > +MODULE_AUTHOR("Andrea Venturi <be17068@iperbole.bo.it>"); > +MODULE_DESCRIPTION("Allwinner Sunxi SPDIF SoC Interface"); > +MODULE_LICENSE("GPL"); > +MODULE_ALIAS("platform:sunxi-spdif"); > -- > 1.9.1 Thanks! Maxime
On 28 September 2015 at 10:25, Maxime Ripard <maxime.ripard@free-electrons.com> wrote: > On Thu, Sep 24, 2015 at 04:30:05PM +0200, codekipper@gmail.com wrote: >> From: Marcus Cooper <codekipper@gmail.com> >> >> The sun4i, sun6i and sun7i SoC families have an SPDIF >> block which is capable of playback and capture. >> >> This patch enables the playback of this block for >> the sun4i and sun7i families. >> >> Signed-off-by: Marcus Cooper <codekipper@gmail.com> >> --- >> sound/soc/sunxi/Kconfig | 10 + >> sound/soc/sunxi/Makefile | 4 + >> sound/soc/sunxi/sunxi-machine-spdif.c | 110 +++++ >> sound/soc/sunxi/sunxi-spdif.c | 801 ++++++++++++++++++++++++++++++++++ >> 4 files changed, 925 insertions(+) >> create mode 100644 sound/soc/sunxi/sunxi-machine-spdif.c >> create mode 100644 sound/soc/sunxi/sunxi-spdif.c >> >> diff --git a/sound/soc/sunxi/Kconfig b/sound/soc/sunxi/Kconfig >> index 84c72ec..053db02 100644 >> --- a/sound/soc/sunxi/Kconfig >> +++ b/sound/soc/sunxi/Kconfig >> @@ -8,4 +8,14 @@ config SND_SUN4I_CODEC >> Select Y or M to add support for the Codec embedded in the Allwinner >> A10 and affiliated SoCs. >> >> +config SND_SOC_SUNXI_DAI_SPDIF >> + tristate >> + select SND_SOC_GENERIC_DMAENGINE_PCM >> + select REGMAP_MMIO >> + >> +config SND_SOC_SUNXI_MACHINE_SPDIF >> + tristate "APB on-chip sun4i/sun5i/sun7i SPDIF" >> + select SND_SOC_SUNXI_DAI_SPDIF >> + help >> + Say Y if you want to add support for SoC S/PDIF audio as simple audio card. >> endmenu >> diff --git a/sound/soc/sunxi/Makefile b/sound/soc/sunxi/Makefile >> index ea8a08c..7849a75 100644 >> --- a/sound/soc/sunxi/Makefile >> +++ b/sound/soc/sunxi/Makefile >> @@ -1,2 +1,6 @@ >> obj-$(CONFIG_SND_SUN4I_CODEC) += sun4i-codec.o >> >> +snd-soc-sunxi-dai-spdif-objs := sunxi-spdif.o >> +obj-$(CONFIG_SND_SOC_SUNXI_DAI_SPDIF) += snd-soc-sunxi-dai-spdif.o >> +snd-soc-sunxi-machine-spdif-objs := sunxi-machine-spdif.o >> +obj-$(CONFIG_SND_SOC_SUNXI_MACHINE_SPDIF) += snd-soc-sunxi-machine-spdif.o >> diff --git a/sound/soc/sunxi/sunxi-machine-spdif.c b/sound/soc/sunxi/sunxi-machine-spdif.c >> new file mode 100644 >> index 0000000..f8f6bd8 >> --- /dev/null >> +++ b/sound/soc/sunxi/sunxi-machine-spdif.c >> @@ -0,0 +1,110 @@ >> +/* >> + * Copyright (C) 2015 Andrea Venturi <be17068@iperbole.bo.it> >> + * From code by (C) 2013 Freescale Semiconductor, Inc. >> + * (sound/soc/fsl/imx-spdif.c) >> + * >> + * 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. >> + */ >> + >> +#include <linux/module.h> >> +#include <linux/of_platform.h> >> +#include <sound/soc.h> >> + >> +struct sunxi_machine_spdif_data { >> + struct snd_soc_dai_link dai; >> + struct snd_soc_card card; >> +}; >> + >> +static int sunxi_machine_spdif_audio_probe(struct platform_device *pdev) >> +{ >> + struct device_node *spdif_np, *np = pdev->dev.of_node; >> + struct sunxi_machine_spdif_data *data; >> + int ret = 0; >> + >> + dev_dbg(&pdev->dev, "%s: Looking for spdif-controller\n", __func__); >> + spdif_np = of_parse_phandle(np, "spdif-controller", 0); >> + if (!spdif_np) { >> + dev_err(&pdev->dev, "failed to find spdif-controller\n"); >> + ret = -EINVAL; >> + goto end; >> + } >> + >> + data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); >> + if (!data) { >> + ret = -ENOMEM; >> + goto end; >> + } >> + >> + data->dai.name = "S/PDIF PCM"; >> + data->dai.stream_name = "S/PDIF PCM"; >> + data->dai.codec_dai_name = "snd-soc-dummy-dai"; >> + data->dai.codec_name = "snd-soc-dummy"; >> + data->dai.cpu_of_node = spdif_np; >> + data->dai.platform_of_node = spdif_np; >> + data->dai.playback_only = true; >> + data->dai.capture_only = true; >> + >> + if (of_property_read_bool(np, "spdif-out")) >> + data->dai.capture_only = false; >> + >> + if (of_property_read_bool(np, "spdif-in")) >> + data->dai.playback_only = false; >> + >> + if (data->dai.playback_only && data->dai.capture_only) { >> + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); >> + goto end; >> + } >> + >> + data->card.dev = &pdev->dev; >> + data->card.dai_link = &data->dai; >> + data->card.num_links = 1; >> + data->card.owner = THIS_MODULE; >> + >> + ret = snd_soc_of_parse_card_name(&data->card, "model"); >> + if (ret) >> + goto end; >> + >> + ret = devm_snd_soc_register_card(&pdev->dev, &data->card); >> + if (ret) { >> + dev_err(&pdev->dev, "snd_soc_register_card failed: %d\n", ret); >> + goto end; >> + } >> + >> + platform_set_drvdata(pdev, data); >> + >> +end: >> + of_node_put(spdif_np); >> + >> + return ret; >> +} >> + >> +#ifdef CONFIG_OF >> +static const struct of_device_id sunxi_machine_spdif_dt_ids[] = { >> + { .compatible = "allwinner,sunxi-audio-spdif", }, >> + { /* sentinel */ } >> +}; >> +MODULE_DEVICE_TABLE(of, sunxi_machine_spdif_dt_ids); >> +#endif >> + >> +static struct platform_driver sunxi_machine_spdif_driver = { >> + .driver = { >> + .name = "sunxi-machine-spdif", >> + .of_match_table = sunxi_machine_spdif_dt_ids, >> + }, >> + .probe = sunxi_machine_spdif_audio_probe, >> +}; >> + >> +module_platform_driver(sunxi_machine_spdif_driver); >> + >> +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); >> +MODULE_AUTHOR("Andrea Venturi, <be17068@iperbole.bo.it>"); >> +MODULE_DESCRIPTION("Allwinner sunxi S/PDIF machine driver"); >> +MODULE_LICENSE("GPL v2"); >> diff --git a/sound/soc/sunxi/sunxi-spdif.c b/sound/soc/sunxi/sunxi-spdif.c >> new file mode 100644 >> index 0000000..cae9261 >> --- /dev/null >> +++ b/sound/soc/sunxi/sunxi-spdif.c >> @@ -0,0 +1,801 @@ >> +/* >> + * ALSA SoC SPDIF Audio Layer >> + * >> + * Copyright 2015 Andrea Venturi <be17068@iperbole.bo.it> >> + * Copyright 2015 Marcus Cooper <codekipper@gmail.com> >> + * >> + * Based on the Allwinner SDK driver, released under the GPL. >> + * >> + * 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. >> + */ >> + >> +/* >> + * this is SPDIF sunxi simple audio card DAI driver that uses the codec >> + * "dummy driver" as per sound/soc/fsl/imx-spdif.c >> + */ >> +#include <linux/clk.h> >> +#include <linux/delay.h> >> +#include <linux/device.h> >> +#include <linux/kernel.h> >> +#include <linux/init.h> >> +#include <linux/regmap.h> >> +#include <linux/of_address.h> >> +#include <linux/of_device.h> >> +#include <linux/ioport.h> >> +#include <linux/module.h> >> +#include <linux/platform_device.h> >> +#include <sound/dmaengine_pcm.h> >> +#include <sound/pcm_params.h> >> +#include <sound/soc.h> >> + >> +#define SUNXI_SPDIF_CTL (0x00) >> + #define SUNXI_SPDIF_CTL_MCLKDIV(v) ((v) << 4) /* v even */ >> + #define SUNXI_SPDIF_CTL_MCLKOUTEN BIT(2) >> + #define SUNXI_SPDIF_CTL_GEN BIT(1) >> + #define SUNXI_SPDIF_CTL_RESET BIT(0) >> + >> +#define SUNXI_SPDIF_TXCFG (0x04) >> + #define SUNXI_SPDIF_TXCFG_SINGLEMOD BIT(31) >> + #define SUNXI_SPDIF_TXCFG_ASS BIT(17) >> + #define SUNXI_SPDIF_TXCFG_NONAUDIO BIT(16) >> + #define SUNXI_SPDIF_TXCFG_TXRATIO(v) ((v) << 4) >> + #define SUNXI_SPDIF_TXCFG_TXRATIO_MASK GENMASK(8, 4) >> + #define SUNXI_SPDIF_TXCFG_FMTRVD GENMASK(3, 2) >> + #define SUNXI_SPDIF_TXCFG_FMT16BIT (0 << 2) >> + #define SUNXI_SPDIF_TXCFG_FMT20BIT (1 << 2) >> + #define SUNXI_SPDIF_TXCFG_FMT24BIT (2 << 2) >> + #define SUNXI_SPDIF_TXCFG_CHSTMODE BIT(1) >> + #define SUNXI_SPDIF_TXCFG_TXEN BIT(0) >> + >> +#define SUNXI_SPDIF_RXCFG (0x08) >> + #define SUNXI_SPDIF_RXCFG_LOCKFLAG BIT(4) >> + #define SUNXI_SPDIF_RXCFG_CHSTSRC BIT(3) >> + #define SUNXI_SPDIF_RXCFG_CHSTCP BIT(1) >> + #define SUNXI_SPDIF_RXCFG_RXEN BIT(0) >> + >> +#define SUNXI_SPDIF_TXFIFO (0x0C) >> + >> +#define SUNXI_SPDIF_RXFIFO (0x10) >> + >> +#define SUNXI_SPDIF_FCTL (0x14) >> + #define SUNXI_SPDIF_FCTL_FIFOSRC BIT(31) >> + #define SUNXI_SPDIF_FCTL_FTX BIT(17) >> + #define SUNXI_SPDIF_FCTL_FRX BIT(16) >> + #define SUNXI_SPDIF_FCTL_TXTL(v) ((v) << 8) >> + #define SUNXI_SPDIF_FCTL_TXTL_MASK GENMASK(12, 8) >> + #define SUNXI_SPDIF_FCTL_RXTL(v) ((v) << 3) >> + #define SUNXI_SPDIF_FCTL_RXTL_MASK GENMASK(7, 3) >> + #define SUNXI_SPDIF_FCTL_TXIM BIT(2) >> + #define SUNXI_SPDIF_FCTL_RXOM(v) ((v) << 0) >> + #define SUNXI_SPDIF_FCTL_RXOM_MASK GENMASK(1, 0) >> + >> +#define SUNXI_SPDIF_FSTA (0x18) >> + #define SUNXI_SPDIF_FSTA_TXE BIT(14) >> + #define SUNXI_SPDIF_FSTA_TXECNTSHT (8) >> + #define SUNXI_SPDIF_FSTA_RXA BIT(6) >> + #define SUNXI_SPDIF_FSTA_RXACNTSHT (0) >> + >> +#define SUNXI_SPDIF_INT (0x1C) >> + #define SUNXI_SPDIF_INT_RXLOCKEN BIT(18) >> + #define SUNXI_SPDIF_INT_RXUNLOCKEN BIT(17) >> + #define SUNXI_SPDIF_INT_RXPARERREN BIT(16) >> + #define SUNXI_SPDIF_INT_TXDRQEN BIT(7) >> + #define SUNXI_SPDIF_INT_TXUIEN BIT(6) >> + #define SUNXI_SPDIF_INT_TXOIEN BIT(5) >> + #define SUNXI_SPDIF_INT_TXEIEN BIT(4) >> + #define SUNXI_SPDIF_INT_RXDRQEN BIT(2) >> + #define SUNXI_SPDIF_INT_RXOIEN BIT(1) >> + #define SUNXI_SPDIF_INT_RXAIEN BIT(0) >> + >> +#define SUNXI_SPDIF_ISTA (0x20) >> + #define SUNXI_SPDIF_ISTA_RXLOCKSTA BIT(18) >> + #define SUNXI_SPDIF_ISTA_RXUNLOCKSTA BIT(17) >> + #define SUNXI_SPDIF_ISTA_RXPARERRSTA BIT(16) >> + #define SUNXI_SPDIF_ISTA_TXUSTA BIT(6) >> + #define SUNXI_SPDIF_ISTA_TXOSTA BIT(5) >> + #define SUNXI_SPDIF_ISTA_TXESTA BIT(4) >> + #define SUNXI_SPDIF_ISTA_RXOSTA BIT(1) >> + #define SUNXI_SPDIF_ISTA_RXASTA BIT(0) >> + >> +#define SUNXI_SPDIF_TXCNT (0x24) >> + >> +#define SUNXI_SPDIF_RXCNT (0x28) >> + >> +#define SUNXI_SPDIF_TXCHSTA0 (0x2C) >> + #define SUNXI_SPDIF_TXCHSTA0_CLK(v) ((v) << 28) >> + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ(v) ((v) << 24) >> + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK GENMASK(27, 24) >> + #define SUNXI_SPDIF_TXCHSTA0_CHNUM(v) ((v) << 20) >> + #define SUNXI_SPDIF_TXCHSTA0_CHNUM_MASK GENMASK(23, 20) >> + #define SUNXI_SPDIF_TXCHSTA0_SRCNUM(v) ((v) << 16) >> + #define SUNXI_SPDIF_TXCHSTA0_CATACOD(v) ((v) << 8) >> + #define SUNXI_SPDIF_TXCHSTA0_MODE(v) ((v) << 6) >> + #define SUNXI_SPDIF_TXCHSTA0_EMPHASIS(v) ((v) << 3) >> + #define SUNXI_SPDIF_TXCHSTA0_CP BIT(2) >> + #define SUNXI_SPDIF_TXCHSTA0_AUDIO BIT(1) >> + #define SUNXI_SPDIF_TXCHSTA0_PRO BIT(0) >> + >> +#define SUNXI_SPDIF_TXCHSTA1 (0x30) >> + #define SUNXI_SPDIF_TXCHSTA1_CGMSA(v) ((v) << 8) >> + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(v) ((v) << 4) >> + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK GENMASK(7, 4) >> + #define SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(v) ((v) << 1) >> + #define SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN BIT(0) >> + >> +#define SUNXI_SPDIF_RXCHSTA0 (0x34) >> + #define SUNXI_SPDIF_RXCHSTA0_CLK(v) ((v) << 28) >> + #define SUNXI_SPDIF_RXCHSTA0_SAMFREQ(v) ((v) << 24) >> + #define SUNXI_SPDIF_RXCHSTA0_CHNUM(v) ((v) << 20) >> + #define SUNXI_SPDIF_RXCHSTA0_SRCNUM(v) ((v) << 16) >> + #define SUNXI_SPDIF_RXCHSTA0_CATACOD(v) ((v) << 8) >> + #define SUNXI_SPDIF_RXCHSTA0_MODE(v) ((v) << 6) >> + #define SUNXI_SPDIF_RXCHSTA0_EMPHASIS(v) ((v) << 3) >> + #define SUNXI_SPDIF_RXCHSTA0_CP BIT(2) >> + #define SUNXI_SPDIF_RXCHSTA0_AUDIO BIT(1) >> + #define SUNXI_SPDIF_RXCHSTA0_PRO BIT(0) >> + >> +#define SUNXI_SPDIF_RXCHSTA1 (0x38) >> + #define SUNXI_SPDIF_RXCHSTA1_CGMSA(v) ((v) << 8) >> + #define SUNXI_SPDIF_RXCHSTA1_ORISAMFREQ(v) ((v) << 4) >> + #define SUNXI_SPDIF_RXCHSTA1_SAMWORDLEN(v) ((v) << 1) >> + #define SUNXI_SPDIF_RXCHSTA1_MAXWORDLEN BIT(0) >> + >> +/* Defines for Sampling Frequency */ >> +enum sunxi_spdif_sampling_freq { >> + SUNXI_SPDIF_SAMFREQ_44_1KHZ = 0x0, >> + SUNXI_SPDIF_SAMFREQ_NOT_INDICATED = 0x1, >> + SUNXI_SPDIF_SAMFREQ_48KHZ = 0x2, >> + SUNXI_SPDIF_SAMFREQ_32KHZ = 0x3, >> + SUNXI_SPDIF_SAMFREQ_22_05KHZ = 0x4, >> + SUNXI_SPDIF_SAMFREQ_24KHZ = 0x6, >> + SUNXI_SPDIF_SAMFREQ_88_2KHZ = 0x8, >> + SUNXI_SPDIF_SAMFREQ_768KHZ = 0x9, >> + SUNXI_SPDIF_SAMFREQ_96KHZ = 0xa, >> + SUNXI_SPDIF_SAMFREQ_176_4KHZ = 0xc, >> + SUNXI_SPDIF_SAMFREQ_192KHZ = 0xe, >> +}; >> + >> +/* >> + * Original sampling frequency can be represented by inverting the value of the >> + * sampling frequency. >> + */ >> +#define ORIGINAL(v) ((~v) & 0xf) >> + >> +struct sunxi_spdif_dev { >> + struct platform_device *pdev; >> + struct clk *clk; >> + struct clk *apb_clk; >> + struct clk *audio_clk; >> + struct snd_soc_dai_driver cpu_dai_drv; >> + bool running; >> + struct regmap *regmap; >> + struct snd_dmaengine_dai_dma_data dma_params_tx; >> + struct snd_dmaengine_dai_dma_data dma_params_rx; >> + bool playback_supported; >> + bool capture_supported; >> +}; >> + >> +static void sunxi_spdif_configure(struct sunxi_spdif_dev *host) >> +{ >> + u32 reg_val; >> + >> + /* soft reset SPDIF */ >> + regmap_write(host->regmap, SUNXI_SPDIF_CTL, SUNXI_SPDIF_CTL_RESET); >> + >> + /* MCLK OUTPUT enable */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, >> + SUNXI_SPDIF_CTL_MCLKOUTEN, SUNXI_SPDIF_CTL_MCLKOUTEN); >> + >> + /* flush TX FIFO */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_FCTL, SUNXI_SPDIF_FCTL_FTX, >> + SUNXI_SPDIF_FCTL_FTX); > > The new line should be aligned on an open parenthesis. DONE > >> + >> + /* clear interrupt status */ >> + regmap_read(host->regmap, SUNXI_SPDIF_ISTA, ®_val); >> + regmap_write(host->regmap, SUNXI_SPDIF_ISTA, reg_val); >> + >> + /* clear TX counter */ >> + regmap_write(host->regmap, SUNXI_SPDIF_TXCNT, 0); >> + >> +} >> + >> +void sunxi_snd_txctrl(struct snd_pcm_substream *substream, >> + struct sunxi_spdif_dev *host, int on) >> +{ >> + u32 tmp; >> + >> + regmap_read(host->regmap, SUNXI_SPDIF_TXCNT, &tmp); >> + if (substream->runtime->channels == 1) >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, >> + SUNXI_SPDIF_TXCFG_SINGLEMOD, >> + SUNXI_SPDIF_TXCFG_SINGLEMOD); >> + >> + if (on) { >> + /* SPDIF TX ENABLE */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, >> + SUNXI_SPDIF_TXCFG_TXEN, >> + SUNXI_SPDIF_TXCFG_TXEN); >> + >> + /* DRQ ENABLE */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, >> + SUNXI_SPDIF_INT_TXDRQEN, >> + SUNXI_SPDIF_INT_TXDRQEN); >> + >> + /* Global enable */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, >> + SUNXI_SPDIF_CTL_GEN, >> + SUNXI_SPDIF_CTL_GEN); >> + } else { >> + /* SPDIF TX DISABLE */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, >> + SUNXI_SPDIF_TXCFG_TXEN, 0); >> + >> + /* DRQ DISABLE */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, >> + SUNXI_SPDIF_INT_TXDRQEN, 0); >> + >> + /* Global disable */ >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, >> + SUNXI_SPDIF_CTL_GEN, 0); >> + } >> +} >> + >> +static int sunxi_spdif_startup(struct snd_pcm_substream *substream, >> + struct snd_soc_dai *cpu_dai) >> +{ >> + struct snd_soc_pcm_runtime *rtd = substream->private_data; >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); >> + int ret; >> + >> + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) >> + return -EINVAL; >> + >> + /* Reset module and interrupts only for first initialization */ >> + if (!cpu_dai->active) { >> + ret = clk_prepare_enable(host->clk); > > Can't you just use runtime_pm to deal with that? LOOKING INTO THIS. > >> + if (ret) >> + return ret; >> + } >> + >> + host->running = true; >> + sunxi_spdif_configure(host); >> + >> + return 0; >> +} >> + >> +static void sunxi_spdif_shutdown(struct snd_pcm_substream *substream, >> + struct snd_soc_dai *dai) >> +{ >> + struct snd_soc_pcm_runtime *rtd = substream->private_data; >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); >> + >> + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) >> + return; >> + >> + clk_disable_unprepare(host->clk); >> + host->running = false; >> +} >> + >> +static int sunxi_spdif_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt) >> +{ >> + u32 reg_val; >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); >> + >> + reg_val = 0; >> + reg_val &= ~SUNXI_SPDIF_TXCFG_SINGLEMOD; >> + reg_val |= SUNXI_SPDIF_TXCFG_ASS; >> + reg_val |= fmt; /* set non audio and bit depth */ >> + reg_val |= SUNXI_SPDIF_TXCFG_CHSTMODE; >> + regmap_write(host->regmap, SUNXI_SPDIF_TXCFG, reg_val); > > You can probably used regmap_update_bits for that. I've moved all this to the hw_params now so there is just the one reg write. > >> + reg_val = 0; >> + reg_val &= ~SUNXI_SPDIF_FCTL_FIFOSRC; >> + reg_val |= SUNXI_SPDIF_FCTL_TXTL_MASK; >> + reg_val |= SUNXI_SPDIF_FCTL_RXTL_MASK; >> + reg_val |= SUNXI_SPDIF_FCTL_TXIM; >> + reg_val |= SUNXI_SPDIF_FCTL_RXOM_MASK; >> + regmap_write(host->regmap, SUNXI_SPDIF_FCTL, reg_val); >> + reg_val = 0; >> + reg_val |= (SUNXI_SPDIF_TXCHSTA0_CHNUM(2)); >> + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA0, reg_val); >> + >> + reg_val = 0; >> + reg_val |= (SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(1)); >> + if ((fmt & SUNXI_SPDIF_TXCFG_FMT24BIT) == SUNXI_SPDIF_TXCFG_FMT24BIT) >> + reg_val |= SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN; >> + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA1, reg_val); >> + return 0; >> +} >> + >> +static int sunxi_spdif_set_sysclk(struct snd_soc_dai *cpu_dai, unsigned int freq) >> +{ >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); >> + struct platform_device *pdev = host->pdev; >> + >> + if (clk_set_rate(host->audio_clk, freq)) >> + dev_err(&pdev->dev, >> + "Setting pll2 clock rate for %d Hz failed!\n", freq); >> + if (clk_set_rate(host->clk, freq)) >> + dev_err(&pdev->dev, >> + "Setting SPDIF clock rate for %d Hz failed!\n", freq); >> + return 0; >> +} >> + >> +static int sunxi_spdif_set_clkdiv(struct snd_soc_dai *cpu_dai, >> + unsigned int rate, int div) >> +{ >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); >> + int sample_freq, original_sample_freq; >> + >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, >> + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, 0); >> + >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, >> + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, 0); > > Why do you need to clear the registers before writing them again? This is copied from the code from the SDK and as the data sheet lacks a lot of detail then I took the code as face value. Mark's comments prompted me to look into this and low and behold removal of all this sampling frequency code doesn't break playback....so it's all gone now. > >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, >> + SUNXI_SPDIF_TXCFG_TXRATIO_MASK, >> + SUNXI_SPDIF_TXCFG_TXRATIO(div - 1)); >> + >> + if (rate == 24576000) { >> + switch (div) { >> + /* 24KHZ */ >> + case 8: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_24KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_24KHZ); > > What is this original sample frequency? > >> + break; >> + >> + /* 32KHZ */ >> + case 6: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_32KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_32KHZ); >> + break; >> + >> + /* 48KHZ */ >> + case 4: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_48KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_48KHZ); >> + break; >> + >> + /* 96KHZ */ >> + case 2: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_96KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_96KHZ); >> + break; >> + >> + /* 192KHZ */ >> + case 1: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_192KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_192KHZ); >> + break; >> + >> + default: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; >> + original_sample_freq = 0; >> + break; >> + } >> + } else { >> + /* 22.5792MHz */ >> + switch (div) { >> + /* 22.05KHZ */ >> + case 8: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_22_05KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_22_05KHZ); >> + break; >> + >> + /* 44.1KHZ */ >> + case 4: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_44_1KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_44_1KHZ); >> + break; >> + >> + /* 88.2KHZ */ >> + case 2: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_88_2KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_88_2KHZ); >> + break; >> + >> + /* 176.4KHZ */ >> + case 1: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_176_4KHZ; >> + original_sample_freq >> + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_176_4KHZ); >> + break; >> + > > You can probably turn this into a funcion that computes it, instead of > having to duplicated and almost identical switch statements. > >> + default: >> + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; >> + original_sample_freq = 0; >> + break; >> + } >> + } > > Shouldn't you return an error in such a case? > >> + >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, >> + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, >> + SUNXI_SPDIF_TXCHSTA0_SAMFREQ(sample_freq)); >> + >> + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, >> + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, >> + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(original_sample_freq)); >> + >> + return 0; >> +} >> + >> +static int sunxi_spdif_hw_params(struct snd_pcm_substream *substream, >> + struct snd_pcm_hw_params *params, >> + struct snd_soc_dai *cpu_dai) >> +{ >> + int ret = 0; >> + int fmt; >> + unsigned long rate = params_rate(params); >> + u32 mclk_div = 0; >> + unsigned int mclk = 0; >> + >> + /* Add the PCM and raw data select interface */ >> + switch (params_channels(params)) { >> + case 1: /* PCM mode */ >> + case 2: >> + fmt = 0; >> + break; >> + case 4: /* raw data mode */ >> + fmt = SUNXI_SPDIF_TXCFG_NONAUDIO; >> + break; >> + default: >> + return -EINVAL; >> + } >> + >> + switch (params_format(params)) { >> + case SNDRV_PCM_FORMAT_S16_LE: >> + fmt |= SUNXI_SPDIF_TXCFG_FMT16BIT; >> + break; >> + case SNDRV_PCM_FORMAT_S20_3LE: >> + fmt |= SUNXI_SPDIF_TXCFG_FMT20BIT; >> + break; >> + case SNDRV_PCM_FORMAT_S24_LE: >> + fmt |= SUNXI_SPDIF_TXCFG_FMT24BIT; >> + break; >> + default: >> + return -EINVAL; >> + } >> + >> + ret = snd_soc_dai_set_fmt(cpu_dai, fmt); >> + if (ret < 0) >> + return ret; >> + >> + switch (rate) { >> + case 22050: >> + case 44100: >> + case 88200: >> + case 176400: >> + mclk = 22579200; >> + break; >> + case 24000: >> + case 32000: >> + case 48000: >> + case 96000: >> + case 192000: >> + mclk = 24576000; >> + break; >> + default: >> + return -EINVAL; >> + } >> + >> + ret = sunxi_spdif_set_sysclk(cpu_dai, mclk); >> + if (ret < 0) >> + return ret; >> + >> + switch (rate) { >> + case 22050: >> + case 24000: >> + mclk_div = 8; >> + break; >> + case 32000: >> + mclk_div = 6; >> + break; >> + case 44100: >> + case 48000: >> + mclk_div = 4; >> + break; >> + case 88200: >> + case 96000: >> + mclk_div = 2; >> + break; >> + case 176400: >> + case 192000: >> + mclk_div = 1; >> + break; >> + default: >> + return -EINVAL; >> + } >> + >> + ret = sunxi_spdif_set_clkdiv(cpu_dai, mclk, mclk_div); >> + if (ret < 0) >> + return ret; >> + >> + return 0; >> +} >> + >> +static int sunxi_spdif_trigger(struct snd_pcm_substream *substream, int cmd, >> + struct snd_soc_dai *dai) >> +{ >> + int ret = 0; >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); >> + >> + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) >> + return -EINVAL; >> + >> + switch (cmd) { >> + case SNDRV_PCM_TRIGGER_START: >> + case SNDRV_PCM_TRIGGER_RESUME: >> + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: >> + sunxi_snd_txctrl(substream, host, 1); >> + break; >> + >> + case SNDRV_PCM_TRIGGER_STOP: >> + case SNDRV_PCM_TRIGGER_SUSPEND: >> + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: >> + sunxi_snd_txctrl(substream, host, 0); >> + break; >> + >> + default: >> + ret = -EINVAL; >> + break; >> + } >> + return ret; >> +} >> + >> +static int sunxi_spdif_soc_dai_probe(struct snd_soc_dai *dai) >> +{ >> + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); >> + >> + snd_soc_dai_init_dma_data(dai, &host->dma_params_tx, >> + &host->dma_params_rx); >> + return 0; >> +} >> + >> +static const struct snd_soc_dai_ops sunxi_spdif_dai_ops = { >> + .startup = sunxi_spdif_startup, >> + .shutdown = sunxi_spdif_shutdown, >> + .trigger = sunxi_spdif_trigger, >> + .hw_params = sunxi_spdif_hw_params, >> + .set_fmt = sunxi_spdif_set_fmt, >> +}; >> + >> +static const struct regmap_config sunxi_spdif_regmap_config = { >> + .reg_bits = 32, >> + .reg_stride = 4, >> + .val_bits = 32, >> + .max_register = SUNXI_SPDIF_RXCHSTA1, >> +}; >> + >> +#define SUNXI_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \ >> + SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ >> + SNDRV_PCM_RATE_192000) >> +#define SUNXI_FORMATS (SNDRV_PCM_FORMAT_S16_LE | SNDRV_PCM_FORMAT_S20_3LE | \ >> + SNDRV_PCM_FORMAT_S24_LE) >> + >> +static struct snd_soc_dai_driver sunxi_spdif_dai = { >> + .playback = { >> + .channels_min = 2, >> + .channels_max = 2, >> + .rates = SUNXI_RATES, >> + .formats = SUNXI_FORMATS, >> + }, >> + .probe = sunxi_spdif_soc_dai_probe, >> + .ops = &sunxi_spdif_dai_ops, >> + .name = "spdif", >> +}; >> + >> +static const struct snd_soc_dapm_widget dit_widgets[] = { >> + SND_SOC_DAPM_OUTPUT("spdif-out"), >> +}; >> + >> +static const struct snd_soc_dapm_route dit_routes[] = { >> + { "spdif-out", NULL, "Playback" }, >> +}; >> + >> +#ifdef CONFIG_OF > > You don't support !dt probing. You should probably only depend on > CONFIG_OF in Kconfig. > >> +static const struct of_device_id sunxi_spdif_of_match[] = { >> + { .compatible = "allwinner,sun4i-a10-spdif", }, > > I'd prefer to have the driver named sun4i-spdif (in the driver name, > prefixes, Kconfig options, etc.) so that if there's a new spdif IP > introduced, you don't end up with something weird. Yeah...I was expecting this.....once I've confirmed operation after today's refactoring I will start search and replace!. > >> + { /* sentinel */ } >> +}; >> +MODULE_DEVICE_TABLE(of, sunxi_spdif_of_match); >> +#endif >> + >> +static const struct snd_soc_component_driver sunxi_spdif_component = { >> + .name = "sunxi-spdif", >> +}; >> + >> +static int sunxi_spdif_probe(struct platform_device *pdev) >> +{ >> + struct device_node *np = pdev->dev.of_node; >> + struct sunxi_spdif_dev *host; >> + struct resource *res; >> + int ret; >> + const struct of_device_id *of_id; >> + void __iomem *base; >> + >> + dev_dbg(&pdev->dev, "Entered %s\n", __func__); >> + >> + if (!np) >> + return -ENODEV; >> + >> + of_id = of_match_device(sunxi_spdif_of_match, &pdev->dev); >> + if (!of_id) { >> + dev_err(&pdev->dev, "No matched devices found.\n"); >> + return -EINVAL; >> + } > > Are you using that of_id anywhere? > Nope...it can go. >> + >> + host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); >> + if (!host) >> + return -ENOMEM; >> + >> + host->pdev = pdev; >> + >> + /* Initialize this copy of the CPU DAI driver structure */ >> + memcpy(&host->cpu_dai_drv, &sunxi_spdif_dai, sizeof(sunxi_spdif_dai)); >> + host->cpu_dai_drv.name = dev_name(&pdev->dev); >> + >> + /* Get the addresses */ >> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); >> + base = devm_ioremap_resource(&pdev->dev, res); >> + if (IS_ERR(base)) >> + return PTR_ERR(base); >> + >> + host->regmap = devm_regmap_init_mmio(&pdev->dev, base, >> + &sunxi_spdif_regmap_config); >> + >> + /* Clocks */ >> + host->apb_clk = devm_clk_get(&pdev->dev, "apb"); >> + if (IS_ERR(host->apb_clk)) { >> + dev_err(&pdev->dev, "failed to get a apb clock.\n"); >> + return PTR_ERR(host->apb_clk); >> + } >> + >> + if (clk_prepare_enable(host->apb_clk)) { >> + dev_err(&pdev->dev, "try to enable apb_spdif_clk failed\n"); >> + return -EINVAL; >> + } >> + >> + host->audio_clk = devm_clk_get(&pdev->dev, "audio"); >> + if (IS_ERR(host->audio_clk)) { >> + dev_err(&pdev->dev, "failed to get an audio clock.\n"); >> + return PTR_ERR(host->audio_clk); >> + } >> + >> + host->clk = devm_clk_get(&pdev->dev, "spdif"); >> + if (IS_ERR(host->clk)) { >> + dev_err(&pdev->dev, "failed to get a spdif clock.\n"); >> + return PTR_ERR(host->clk); >> + } >> + >> + ret = clk_set_rate(host->audio_clk, 24576000); >> + if (ret) { >> + dev_err(&pdev->dev, "set spdif base clock failed!\n"); >> + return ret; >> + } > > Why do you need to have to poke at PLL2 directly? the spdif clock is > its direct child. If you have to set a rate, do it directly on this > clock. And you don't have to assign a rate at probe time either since > you will like change it when the playback will start > OK...let me check this. >> + if (clk_prepare_enable(host->audio_clk)) { >> + dev_err(&pdev->dev, "try to enable audio clk failed\n"); >> + ret = -EINVAL; >> + goto exit_clkdisable_apb_clk; >> + } >> + >> + host->playback_supported = false; >> + host->capture_supported = false; >> + >> + if (of_property_read_bool(np, "spdif-out")) >> + host->playback_supported = true; >> + >> + if (!host->playback_supported) { >> + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); >> + goto exit_clkdisable_clk; >> + } >> + >> + host->dma_params_tx.addr = res->start + SUNXI_SPDIF_TXFIFO; >> + host->dma_params_tx.maxburst = 4; >> + host->dma_params_tx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; >> + host->dma_params_rx.addr = res->start + SUNXI_SPDIF_RXFIFO; >> + host->dma_params_rx.maxburst = 4; >> + host->dma_params_rx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; >> + >> + /* Register with ASoC */ >> + dev_set_drvdata(&pdev->dev, host); > > That's not what it does. And you can use platform_set_drvdata here OK...I will also check this. > >> + >> + ret = devm_snd_soc_register_component(&pdev->dev, >> + &sunxi_spdif_component, &sunxi_spdif_dai, 1); >> + if (ret) >> + goto exit_clkdisable_clk; >> + >> + ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); >> + if (ret) >> + goto exit_clkdisable_clk; >> + return 0; >> + >> +exit_clkdisable_clk: >> + clk_disable_unprepare(host->clk); >> +exit_clkdisable_apb_clk: >> + clk_disable_unprepare(host->apb_clk); >> + return ret; >> +} >> + >> +static int sunxi_spdif_remove(struct platform_device *pdev) >> +{ >> + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); >> + >> + snd_soc_unregister_platform(&pdev->dev); >> + snd_soc_unregister_component(&pdev->dev); >> + >> + if (!IS_ERR(host->clk)) { >> + clk_disable_unprepare(host->clk); >> + clk_disable_unprepare(host->apb_clk); >> + } >> + >> + return 0; >> +} >> + >> +#ifdef CONFIG_PM >> +static int sunxi_spdif_suspend(struct device *dev) >> +{ >> + struct platform_device *pdev = to_platform_device(dev); >> + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); >> + >> + if (host->running) >> + clk_disable(host->clk); >> + >> + return 0; >> +} >> + >> +static int sunxi_spdif_resume(struct device *dev) >> +{ >> + struct platform_device *pdev = to_platform_device(dev); >> + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); >> + >> + if (host->running) { >> + clk_enable(host->clk); >> + sunxi_spdif_configure(host); >> + } >> + return 0; >> +} >> + >> +static SIMPLE_DEV_PM_OPS(spdif_dev_pm_ops, sunxi_spdif_suspend, >> + sunxi_spdif_resume); >> + >> +#define SPDIF_DEV_PM_OPS (&spdif_dev_pm_ops) > > How did you test this? Errrrrr......uummmmmm.......let me think about this one. > >> +#else >> +#define SPDIF_DEV_PM_OPS NULL >> + >> +#endif >> + >> +static struct platform_driver sunxi_spdif_driver = { >> + .driver = { >> + .name = "sunxi-spdif", >> + .owner = THIS_MODULE, > > That's not needed anymore. > >> + .pm = SPDIF_DEV_PM_OPS, >> + .of_match_table = of_match_ptr(sunxi_spdif_of_match), >> + }, >> + .probe = sunxi_spdif_probe, >> + .remove = sunxi_spdif_remove, >> +}; >> + >> +module_platform_driver(sunxi_spdif_driver); >> + >> +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); >> +MODULE_AUTHOR("Andrea Venturi <be17068@iperbole.bo.it>"); >> +MODULE_DESCRIPTION("Allwinner Sunxi SPDIF SoC Interface"); >> +MODULE_LICENSE("GPL"); >> +MODULE_ALIAS("platform:sunxi-spdif"); >> -- >> 1.9.1 > > Thanks! > Maxime Thanks...they'll be nothing left of this driver soon, CK > > -- > Maxime Ripard, Free Electrons > Embedded Linux, Kernel and Android engineering > http://free-electrons.com
On Mon, Sep 28, 2015 at 10:25:33AM +0200, Maxime Ripard wrote: > On Thu, Sep 24, 2015 at 04:30:05PM +0200, codekipper@gmail.com wrote: > > From: Marcus Cooper <codekipper@gmail.com> > > > > The sun4i, sun6i and sun7i SoC families have an SPDIF > > block which is capable of playback and capture. Please delete unneeded context from replies, it makes it much easier to find new content.
diff --git a/sound/soc/sunxi/Kconfig b/sound/soc/sunxi/Kconfig index 84c72ec..053db02 100644 --- a/sound/soc/sunxi/Kconfig +++ b/sound/soc/sunxi/Kconfig @@ -8,4 +8,14 @@ config SND_SUN4I_CODEC Select Y or M to add support for the Codec embedded in the Allwinner A10 and affiliated SoCs. +config SND_SOC_SUNXI_DAI_SPDIF + tristate + select SND_SOC_GENERIC_DMAENGINE_PCM + select REGMAP_MMIO + +config SND_SOC_SUNXI_MACHINE_SPDIF + tristate "APB on-chip sun4i/sun5i/sun7i SPDIF" + select SND_SOC_SUNXI_DAI_SPDIF + help + Say Y if you want to add support for SoC S/PDIF audio as simple audio card. endmenu diff --git a/sound/soc/sunxi/Makefile b/sound/soc/sunxi/Makefile index ea8a08c..7849a75 100644 --- a/sound/soc/sunxi/Makefile +++ b/sound/soc/sunxi/Makefile @@ -1,2 +1,6 @@ obj-$(CONFIG_SND_SUN4I_CODEC) += sun4i-codec.o +snd-soc-sunxi-dai-spdif-objs := sunxi-spdif.o +obj-$(CONFIG_SND_SOC_SUNXI_DAI_SPDIF) += snd-soc-sunxi-dai-spdif.o +snd-soc-sunxi-machine-spdif-objs := sunxi-machine-spdif.o +obj-$(CONFIG_SND_SOC_SUNXI_MACHINE_SPDIF) += snd-soc-sunxi-machine-spdif.o diff --git a/sound/soc/sunxi/sunxi-machine-spdif.c b/sound/soc/sunxi/sunxi-machine-spdif.c new file mode 100644 index 0000000..f8f6bd8 --- /dev/null +++ b/sound/soc/sunxi/sunxi-machine-spdif.c @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2015 Andrea Venturi <be17068@iperbole.bo.it> + * From code by (C) 2013 Freescale Semiconductor, Inc. + * (sound/soc/fsl/imx-spdif.c) + * + * 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. + */ + +#include <linux/module.h> +#include <linux/of_platform.h> +#include <sound/soc.h> + +struct sunxi_machine_spdif_data { + struct snd_soc_dai_link dai; + struct snd_soc_card card; +}; + +static int sunxi_machine_spdif_audio_probe(struct platform_device *pdev) +{ + struct device_node *spdif_np, *np = pdev->dev.of_node; + struct sunxi_machine_spdif_data *data; + int ret = 0; + + dev_dbg(&pdev->dev, "%s: Looking for spdif-controller\n", __func__); + spdif_np = of_parse_phandle(np, "spdif-controller", 0); + if (!spdif_np) { + dev_err(&pdev->dev, "failed to find spdif-controller\n"); + ret = -EINVAL; + goto end; + } + + data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); + if (!data) { + ret = -ENOMEM; + goto end; + } + + data->dai.name = "S/PDIF PCM"; + data->dai.stream_name = "S/PDIF PCM"; + data->dai.codec_dai_name = "snd-soc-dummy-dai"; + data->dai.codec_name = "snd-soc-dummy"; + data->dai.cpu_of_node = spdif_np; + data->dai.platform_of_node = spdif_np; + data->dai.playback_only = true; + data->dai.capture_only = true; + + if (of_property_read_bool(np, "spdif-out")) + data->dai.capture_only = false; + + if (of_property_read_bool(np, "spdif-in")) + data->dai.playback_only = false; + + if (data->dai.playback_only && data->dai.capture_only) { + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); + goto end; + } + + data->card.dev = &pdev->dev; + data->card.dai_link = &data->dai; + data->card.num_links = 1; + data->card.owner = THIS_MODULE; + + ret = snd_soc_of_parse_card_name(&data->card, "model"); + if (ret) + goto end; + + ret = devm_snd_soc_register_card(&pdev->dev, &data->card); + if (ret) { + dev_err(&pdev->dev, "snd_soc_register_card failed: %d\n", ret); + goto end; + } + + platform_set_drvdata(pdev, data); + +end: + of_node_put(spdif_np); + + return ret; +} + +#ifdef CONFIG_OF +static const struct of_device_id sunxi_machine_spdif_dt_ids[] = { + { .compatible = "allwinner,sunxi-audio-spdif", }, + { /* sentinel */ } +}; +MODULE_DEVICE_TABLE(of, sunxi_machine_spdif_dt_ids); +#endif + +static struct platform_driver sunxi_machine_spdif_driver = { + .driver = { + .name = "sunxi-machine-spdif", + .of_match_table = sunxi_machine_spdif_dt_ids, + }, + .probe = sunxi_machine_spdif_audio_probe, +}; + +module_platform_driver(sunxi_machine_spdif_driver); + +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); +MODULE_AUTHOR("Andrea Venturi, <be17068@iperbole.bo.it>"); +MODULE_DESCRIPTION("Allwinner sunxi S/PDIF machine driver"); +MODULE_LICENSE("GPL v2"); diff --git a/sound/soc/sunxi/sunxi-spdif.c b/sound/soc/sunxi/sunxi-spdif.c new file mode 100644 index 0000000..cae9261 --- /dev/null +++ b/sound/soc/sunxi/sunxi-spdif.c @@ -0,0 +1,801 @@ +/* + * ALSA SoC SPDIF Audio Layer + * + * Copyright 2015 Andrea Venturi <be17068@iperbole.bo.it> + * Copyright 2015 Marcus Cooper <codekipper@gmail.com> + * + * Based on the Allwinner SDK driver, released under the GPL. + * + * 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. + */ + +/* + * this is SPDIF sunxi simple audio card DAI driver that uses the codec + * "dummy driver" as per sound/soc/fsl/imx-spdif.c + */ +#include <linux/clk.h> +#include <linux/delay.h> +#include <linux/device.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/regmap.h> +#include <linux/of_address.h> +#include <linux/of_device.h> +#include <linux/ioport.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <sound/dmaengine_pcm.h> +#include <sound/pcm_params.h> +#include <sound/soc.h> + +#define SUNXI_SPDIF_CTL (0x00) + #define SUNXI_SPDIF_CTL_MCLKDIV(v) ((v) << 4) /* v even */ + #define SUNXI_SPDIF_CTL_MCLKOUTEN BIT(2) + #define SUNXI_SPDIF_CTL_GEN BIT(1) + #define SUNXI_SPDIF_CTL_RESET BIT(0) + +#define SUNXI_SPDIF_TXCFG (0x04) + #define SUNXI_SPDIF_TXCFG_SINGLEMOD BIT(31) + #define SUNXI_SPDIF_TXCFG_ASS BIT(17) + #define SUNXI_SPDIF_TXCFG_NONAUDIO BIT(16) + #define SUNXI_SPDIF_TXCFG_TXRATIO(v) ((v) << 4) + #define SUNXI_SPDIF_TXCFG_TXRATIO_MASK GENMASK(8, 4) + #define SUNXI_SPDIF_TXCFG_FMTRVD GENMASK(3, 2) + #define SUNXI_SPDIF_TXCFG_FMT16BIT (0 << 2) + #define SUNXI_SPDIF_TXCFG_FMT20BIT (1 << 2) + #define SUNXI_SPDIF_TXCFG_FMT24BIT (2 << 2) + #define SUNXI_SPDIF_TXCFG_CHSTMODE BIT(1) + #define SUNXI_SPDIF_TXCFG_TXEN BIT(0) + +#define SUNXI_SPDIF_RXCFG (0x08) + #define SUNXI_SPDIF_RXCFG_LOCKFLAG BIT(4) + #define SUNXI_SPDIF_RXCFG_CHSTSRC BIT(3) + #define SUNXI_SPDIF_RXCFG_CHSTCP BIT(1) + #define SUNXI_SPDIF_RXCFG_RXEN BIT(0) + +#define SUNXI_SPDIF_TXFIFO (0x0C) + +#define SUNXI_SPDIF_RXFIFO (0x10) + +#define SUNXI_SPDIF_FCTL (0x14) + #define SUNXI_SPDIF_FCTL_FIFOSRC BIT(31) + #define SUNXI_SPDIF_FCTL_FTX BIT(17) + #define SUNXI_SPDIF_FCTL_FRX BIT(16) + #define SUNXI_SPDIF_FCTL_TXTL(v) ((v) << 8) + #define SUNXI_SPDIF_FCTL_TXTL_MASK GENMASK(12, 8) + #define SUNXI_SPDIF_FCTL_RXTL(v) ((v) << 3) + #define SUNXI_SPDIF_FCTL_RXTL_MASK GENMASK(7, 3) + #define SUNXI_SPDIF_FCTL_TXIM BIT(2) + #define SUNXI_SPDIF_FCTL_RXOM(v) ((v) << 0) + #define SUNXI_SPDIF_FCTL_RXOM_MASK GENMASK(1, 0) + +#define SUNXI_SPDIF_FSTA (0x18) + #define SUNXI_SPDIF_FSTA_TXE BIT(14) + #define SUNXI_SPDIF_FSTA_TXECNTSHT (8) + #define SUNXI_SPDIF_FSTA_RXA BIT(6) + #define SUNXI_SPDIF_FSTA_RXACNTSHT (0) + +#define SUNXI_SPDIF_INT (0x1C) + #define SUNXI_SPDIF_INT_RXLOCKEN BIT(18) + #define SUNXI_SPDIF_INT_RXUNLOCKEN BIT(17) + #define SUNXI_SPDIF_INT_RXPARERREN BIT(16) + #define SUNXI_SPDIF_INT_TXDRQEN BIT(7) + #define SUNXI_SPDIF_INT_TXUIEN BIT(6) + #define SUNXI_SPDIF_INT_TXOIEN BIT(5) + #define SUNXI_SPDIF_INT_TXEIEN BIT(4) + #define SUNXI_SPDIF_INT_RXDRQEN BIT(2) + #define SUNXI_SPDIF_INT_RXOIEN BIT(1) + #define SUNXI_SPDIF_INT_RXAIEN BIT(0) + +#define SUNXI_SPDIF_ISTA (0x20) + #define SUNXI_SPDIF_ISTA_RXLOCKSTA BIT(18) + #define SUNXI_SPDIF_ISTA_RXUNLOCKSTA BIT(17) + #define SUNXI_SPDIF_ISTA_RXPARERRSTA BIT(16) + #define SUNXI_SPDIF_ISTA_TXUSTA BIT(6) + #define SUNXI_SPDIF_ISTA_TXOSTA BIT(5) + #define SUNXI_SPDIF_ISTA_TXESTA BIT(4) + #define SUNXI_SPDIF_ISTA_RXOSTA BIT(1) + #define SUNXI_SPDIF_ISTA_RXASTA BIT(0) + +#define SUNXI_SPDIF_TXCNT (0x24) + +#define SUNXI_SPDIF_RXCNT (0x28) + +#define SUNXI_SPDIF_TXCHSTA0 (0x2C) + #define SUNXI_SPDIF_TXCHSTA0_CLK(v) ((v) << 28) + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ(v) ((v) << 24) + #define SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK GENMASK(27, 24) + #define SUNXI_SPDIF_TXCHSTA0_CHNUM(v) ((v) << 20) + #define SUNXI_SPDIF_TXCHSTA0_CHNUM_MASK GENMASK(23, 20) + #define SUNXI_SPDIF_TXCHSTA0_SRCNUM(v) ((v) << 16) + #define SUNXI_SPDIF_TXCHSTA0_CATACOD(v) ((v) << 8) + #define SUNXI_SPDIF_TXCHSTA0_MODE(v) ((v) << 6) + #define SUNXI_SPDIF_TXCHSTA0_EMPHASIS(v) ((v) << 3) + #define SUNXI_SPDIF_TXCHSTA0_CP BIT(2) + #define SUNXI_SPDIF_TXCHSTA0_AUDIO BIT(1) + #define SUNXI_SPDIF_TXCHSTA0_PRO BIT(0) + +#define SUNXI_SPDIF_TXCHSTA1 (0x30) + #define SUNXI_SPDIF_TXCHSTA1_CGMSA(v) ((v) << 8) + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(v) ((v) << 4) + #define SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK GENMASK(7, 4) + #define SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(v) ((v) << 1) + #define SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN BIT(0) + +#define SUNXI_SPDIF_RXCHSTA0 (0x34) + #define SUNXI_SPDIF_RXCHSTA0_CLK(v) ((v) << 28) + #define SUNXI_SPDIF_RXCHSTA0_SAMFREQ(v) ((v) << 24) + #define SUNXI_SPDIF_RXCHSTA0_CHNUM(v) ((v) << 20) + #define SUNXI_SPDIF_RXCHSTA0_SRCNUM(v) ((v) << 16) + #define SUNXI_SPDIF_RXCHSTA0_CATACOD(v) ((v) << 8) + #define SUNXI_SPDIF_RXCHSTA0_MODE(v) ((v) << 6) + #define SUNXI_SPDIF_RXCHSTA0_EMPHASIS(v) ((v) << 3) + #define SUNXI_SPDIF_RXCHSTA0_CP BIT(2) + #define SUNXI_SPDIF_RXCHSTA0_AUDIO BIT(1) + #define SUNXI_SPDIF_RXCHSTA0_PRO BIT(0) + +#define SUNXI_SPDIF_RXCHSTA1 (0x38) + #define SUNXI_SPDIF_RXCHSTA1_CGMSA(v) ((v) << 8) + #define SUNXI_SPDIF_RXCHSTA1_ORISAMFREQ(v) ((v) << 4) + #define SUNXI_SPDIF_RXCHSTA1_SAMWORDLEN(v) ((v) << 1) + #define SUNXI_SPDIF_RXCHSTA1_MAXWORDLEN BIT(0) + +/* Defines for Sampling Frequency */ +enum sunxi_spdif_sampling_freq { + SUNXI_SPDIF_SAMFREQ_44_1KHZ = 0x0, + SUNXI_SPDIF_SAMFREQ_NOT_INDICATED = 0x1, + SUNXI_SPDIF_SAMFREQ_48KHZ = 0x2, + SUNXI_SPDIF_SAMFREQ_32KHZ = 0x3, + SUNXI_SPDIF_SAMFREQ_22_05KHZ = 0x4, + SUNXI_SPDIF_SAMFREQ_24KHZ = 0x6, + SUNXI_SPDIF_SAMFREQ_88_2KHZ = 0x8, + SUNXI_SPDIF_SAMFREQ_768KHZ = 0x9, + SUNXI_SPDIF_SAMFREQ_96KHZ = 0xa, + SUNXI_SPDIF_SAMFREQ_176_4KHZ = 0xc, + SUNXI_SPDIF_SAMFREQ_192KHZ = 0xe, +}; + +/* + * Original sampling frequency can be represented by inverting the value of the + * sampling frequency. + */ +#define ORIGINAL(v) ((~v) & 0xf) + +struct sunxi_spdif_dev { + struct platform_device *pdev; + struct clk *clk; + struct clk *apb_clk; + struct clk *audio_clk; + struct snd_soc_dai_driver cpu_dai_drv; + bool running; + struct regmap *regmap; + struct snd_dmaengine_dai_dma_data dma_params_tx; + struct snd_dmaengine_dai_dma_data dma_params_rx; + bool playback_supported; + bool capture_supported; +}; + +static void sunxi_spdif_configure(struct sunxi_spdif_dev *host) +{ + u32 reg_val; + + /* soft reset SPDIF */ + regmap_write(host->regmap, SUNXI_SPDIF_CTL, SUNXI_SPDIF_CTL_RESET); + + /* MCLK OUTPUT enable */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, + SUNXI_SPDIF_CTL_MCLKOUTEN, SUNXI_SPDIF_CTL_MCLKOUTEN); + + /* flush TX FIFO */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_FCTL, SUNXI_SPDIF_FCTL_FTX, + SUNXI_SPDIF_FCTL_FTX); + + /* clear interrupt status */ + regmap_read(host->regmap, SUNXI_SPDIF_ISTA, ®_val); + regmap_write(host->regmap, SUNXI_SPDIF_ISTA, reg_val); + + /* clear TX counter */ + regmap_write(host->regmap, SUNXI_SPDIF_TXCNT, 0); + +} + +void sunxi_snd_txctrl(struct snd_pcm_substream *substream, + struct sunxi_spdif_dev *host, int on) +{ + u32 tmp; + + regmap_read(host->regmap, SUNXI_SPDIF_TXCNT, &tmp); + if (substream->runtime->channels == 1) + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, + SUNXI_SPDIF_TXCFG_SINGLEMOD, + SUNXI_SPDIF_TXCFG_SINGLEMOD); + + if (on) { + /* SPDIF TX ENABLE */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, + SUNXI_SPDIF_TXCFG_TXEN, + SUNXI_SPDIF_TXCFG_TXEN); + + /* DRQ ENABLE */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, + SUNXI_SPDIF_INT_TXDRQEN, + SUNXI_SPDIF_INT_TXDRQEN); + + /* Global enable */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, + SUNXI_SPDIF_CTL_GEN, + SUNXI_SPDIF_CTL_GEN); + } else { + /* SPDIF TX DISABLE */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, + SUNXI_SPDIF_TXCFG_TXEN, 0); + + /* DRQ DISABLE */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_INT, + SUNXI_SPDIF_INT_TXDRQEN, 0); + + /* Global disable */ + regmap_update_bits(host->regmap, SUNXI_SPDIF_CTL, + SUNXI_SPDIF_CTL_GEN, 0); + } +} + +static int sunxi_spdif_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *cpu_dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); + int ret; + + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) + return -EINVAL; + + /* Reset module and interrupts only for first initialization */ + if (!cpu_dai->active) { + ret = clk_prepare_enable(host->clk); + if (ret) + return ret; + } + + host->running = true; + sunxi_spdif_configure(host); + + return 0; +} + +static void sunxi_spdif_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(rtd->cpu_dai); + + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) + return; + + clk_disable_unprepare(host->clk); + host->running = false; +} + +static int sunxi_spdif_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt) +{ + u32 reg_val; + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); + + reg_val = 0; + reg_val &= ~SUNXI_SPDIF_TXCFG_SINGLEMOD; + reg_val |= SUNXI_SPDIF_TXCFG_ASS; + reg_val |= fmt; /* set non audio and bit depth */ + reg_val |= SUNXI_SPDIF_TXCFG_CHSTMODE; + regmap_write(host->regmap, SUNXI_SPDIF_TXCFG, reg_val); + reg_val = 0; + reg_val &= ~SUNXI_SPDIF_FCTL_FIFOSRC; + reg_val |= SUNXI_SPDIF_FCTL_TXTL_MASK; + reg_val |= SUNXI_SPDIF_FCTL_RXTL_MASK; + reg_val |= SUNXI_SPDIF_FCTL_TXIM; + reg_val |= SUNXI_SPDIF_FCTL_RXOM_MASK; + regmap_write(host->regmap, SUNXI_SPDIF_FCTL, reg_val); + reg_val = 0; + reg_val |= (SUNXI_SPDIF_TXCHSTA0_CHNUM(2)); + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA0, reg_val); + + reg_val = 0; + reg_val |= (SUNXI_SPDIF_TXCHSTA1_SAMWORDLEN(1)); + if ((fmt & SUNXI_SPDIF_TXCFG_FMT24BIT) == SUNXI_SPDIF_TXCFG_FMT24BIT) + reg_val |= SUNXI_SPDIF_TXCHSTA1_MAXWORDLEN; + regmap_write(host->regmap, SUNXI_SPDIF_TXCHSTA1, reg_val); + return 0; +} + +static int sunxi_spdif_set_sysclk(struct snd_soc_dai *cpu_dai, unsigned int freq) +{ + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); + struct platform_device *pdev = host->pdev; + + if (clk_set_rate(host->audio_clk, freq)) + dev_err(&pdev->dev, + "Setting pll2 clock rate for %d Hz failed!\n", freq); + if (clk_set_rate(host->clk, freq)) + dev_err(&pdev->dev, + "Setting SPDIF clock rate for %d Hz failed!\n", freq); + return 0; +} + +static int sunxi_spdif_set_clkdiv(struct snd_soc_dai *cpu_dai, + unsigned int rate, int div) +{ + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(cpu_dai); + int sample_freq, original_sample_freq; + + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, 0); + + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, 0); + + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCFG, + SUNXI_SPDIF_TXCFG_TXRATIO_MASK, + SUNXI_SPDIF_TXCFG_TXRATIO(div - 1)); + + if (rate == 24576000) { + switch (div) { + /* 24KHZ */ + case 8: + sample_freq = SUNXI_SPDIF_SAMFREQ_24KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_24KHZ); + break; + + /* 32KHZ */ + case 6: + sample_freq = SUNXI_SPDIF_SAMFREQ_32KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_32KHZ); + break; + + /* 48KHZ */ + case 4: + sample_freq = SUNXI_SPDIF_SAMFREQ_48KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_48KHZ); + break; + + /* 96KHZ */ + case 2: + sample_freq = SUNXI_SPDIF_SAMFREQ_96KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_96KHZ); + break; + + /* 192KHZ */ + case 1: + sample_freq = SUNXI_SPDIF_SAMFREQ_192KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_192KHZ); + break; + + default: + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; + original_sample_freq = 0; + break; + } + } else { + /* 22.5792MHz */ + switch (div) { + /* 22.05KHZ */ + case 8: + sample_freq = SUNXI_SPDIF_SAMFREQ_22_05KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_22_05KHZ); + break; + + /* 44.1KHZ */ + case 4: + sample_freq = SUNXI_SPDIF_SAMFREQ_44_1KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_44_1KHZ); + break; + + /* 88.2KHZ */ + case 2: + sample_freq = SUNXI_SPDIF_SAMFREQ_88_2KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_88_2KHZ); + break; + + /* 176.4KHZ */ + case 1: + sample_freq = SUNXI_SPDIF_SAMFREQ_176_4KHZ; + original_sample_freq + = ORIGINAL(SUNXI_SPDIF_SAMFREQ_176_4KHZ); + break; + + default: + sample_freq = SUNXI_SPDIF_SAMFREQ_NOT_INDICATED; + original_sample_freq = 0; + break; + } + } + + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA0, + SUNXI_SPDIF_TXCHSTA0_SAMFREQ_MASK, + SUNXI_SPDIF_TXCHSTA0_SAMFREQ(sample_freq)); + + regmap_update_bits(host->regmap, SUNXI_SPDIF_TXCHSTA1, + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ_MASK, + SUNXI_SPDIF_TXCHSTA1_ORISAMFREQ(original_sample_freq)); + + return 0; +} + +static int sunxi_spdif_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *cpu_dai) +{ + int ret = 0; + int fmt; + unsigned long rate = params_rate(params); + u32 mclk_div = 0; + unsigned int mclk = 0; + + /* Add the PCM and raw data select interface */ + switch (params_channels(params)) { + case 1: /* PCM mode */ + case 2: + fmt = 0; + break; + case 4: /* raw data mode */ + fmt = SUNXI_SPDIF_TXCFG_NONAUDIO; + break; + default: + return -EINVAL; + } + + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + fmt |= SUNXI_SPDIF_TXCFG_FMT16BIT; + break; + case SNDRV_PCM_FORMAT_S20_3LE: + fmt |= SUNXI_SPDIF_TXCFG_FMT20BIT; + break; + case SNDRV_PCM_FORMAT_S24_LE: + fmt |= SUNXI_SPDIF_TXCFG_FMT24BIT; + break; + default: + return -EINVAL; + } + + ret = snd_soc_dai_set_fmt(cpu_dai, fmt); + if (ret < 0) + return ret; + + switch (rate) { + case 22050: + case 44100: + case 88200: + case 176400: + mclk = 22579200; + break; + case 24000: + case 32000: + case 48000: + case 96000: + case 192000: + mclk = 24576000; + break; + default: + return -EINVAL; + } + + ret = sunxi_spdif_set_sysclk(cpu_dai, mclk); + if (ret < 0) + return ret; + + switch (rate) { + case 22050: + case 24000: + mclk_div = 8; + break; + case 32000: + mclk_div = 6; + break; + case 44100: + case 48000: + mclk_div = 4; + break; + case 88200: + case 96000: + mclk_div = 2; + break; + case 176400: + case 192000: + mclk_div = 1; + break; + default: + return -EINVAL; + } + + ret = sunxi_spdif_set_clkdiv(cpu_dai, mclk, mclk_div); + if (ret < 0) + return ret; + + return 0; +} + +static int sunxi_spdif_trigger(struct snd_pcm_substream *substream, int cmd, + struct snd_soc_dai *dai) +{ + int ret = 0; + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); + + if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) + return -EINVAL; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + sunxi_snd_txctrl(substream, host, 1); + break; + + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + sunxi_snd_txctrl(substream, host, 0); + break; + + default: + ret = -EINVAL; + break; + } + return ret; +} + +static int sunxi_spdif_soc_dai_probe(struct snd_soc_dai *dai) +{ + struct sunxi_spdif_dev *host = snd_soc_dai_get_drvdata(dai); + + snd_soc_dai_init_dma_data(dai, &host->dma_params_tx, + &host->dma_params_rx); + return 0; +} + +static const struct snd_soc_dai_ops sunxi_spdif_dai_ops = { + .startup = sunxi_spdif_startup, + .shutdown = sunxi_spdif_shutdown, + .trigger = sunxi_spdif_trigger, + .hw_params = sunxi_spdif_hw_params, + .set_fmt = sunxi_spdif_set_fmt, +}; + +static const struct regmap_config sunxi_spdif_regmap_config = { + .reg_bits = 32, + .reg_stride = 4, + .val_bits = 32, + .max_register = SUNXI_SPDIF_RXCHSTA1, +}; + +#define SUNXI_RATES (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \ + SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ + SNDRV_PCM_RATE_192000) +#define SUNXI_FORMATS (SNDRV_PCM_FORMAT_S16_LE | SNDRV_PCM_FORMAT_S20_3LE | \ + SNDRV_PCM_FORMAT_S24_LE) + +static struct snd_soc_dai_driver sunxi_spdif_dai = { + .playback = { + .channels_min = 2, + .channels_max = 2, + .rates = SUNXI_RATES, + .formats = SUNXI_FORMATS, + }, + .probe = sunxi_spdif_soc_dai_probe, + .ops = &sunxi_spdif_dai_ops, + .name = "spdif", +}; + +static const struct snd_soc_dapm_widget dit_widgets[] = { + SND_SOC_DAPM_OUTPUT("spdif-out"), +}; + +static const struct snd_soc_dapm_route dit_routes[] = { + { "spdif-out", NULL, "Playback" }, +}; + +#ifdef CONFIG_OF +static const struct of_device_id sunxi_spdif_of_match[] = { + { .compatible = "allwinner,sun4i-a10-spdif", }, + { /* sentinel */ } +}; +MODULE_DEVICE_TABLE(of, sunxi_spdif_of_match); +#endif + +static const struct snd_soc_component_driver sunxi_spdif_component = { + .name = "sunxi-spdif", +}; + +static int sunxi_spdif_probe(struct platform_device *pdev) +{ + struct device_node *np = pdev->dev.of_node; + struct sunxi_spdif_dev *host; + struct resource *res; + int ret; + const struct of_device_id *of_id; + void __iomem *base; + + dev_dbg(&pdev->dev, "Entered %s\n", __func__); + + if (!np) + return -ENODEV; + + of_id = of_match_device(sunxi_spdif_of_match, &pdev->dev); + if (!of_id) { + dev_err(&pdev->dev, "No matched devices found.\n"); + return -EINVAL; + } + + host = devm_kzalloc(&pdev->dev, sizeof(*host), GFP_KERNEL); + if (!host) + return -ENOMEM; + + host->pdev = pdev; + + /* Initialize this copy of the CPU DAI driver structure */ + memcpy(&host->cpu_dai_drv, &sunxi_spdif_dai, sizeof(sunxi_spdif_dai)); + host->cpu_dai_drv.name = dev_name(&pdev->dev); + + /* Get the addresses */ + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(base)) + return PTR_ERR(base); + + host->regmap = devm_regmap_init_mmio(&pdev->dev, base, + &sunxi_spdif_regmap_config); + + /* Clocks */ + host->apb_clk = devm_clk_get(&pdev->dev, "apb"); + if (IS_ERR(host->apb_clk)) { + dev_err(&pdev->dev, "failed to get a apb clock.\n"); + return PTR_ERR(host->apb_clk); + } + + if (clk_prepare_enable(host->apb_clk)) { + dev_err(&pdev->dev, "try to enable apb_spdif_clk failed\n"); + return -EINVAL; + } + + host->audio_clk = devm_clk_get(&pdev->dev, "audio"); + if (IS_ERR(host->audio_clk)) { + dev_err(&pdev->dev, "failed to get an audio clock.\n"); + return PTR_ERR(host->audio_clk); + } + + host->clk = devm_clk_get(&pdev->dev, "spdif"); + if (IS_ERR(host->clk)) { + dev_err(&pdev->dev, "failed to get a spdif clock.\n"); + return PTR_ERR(host->clk); + } + + ret = clk_set_rate(host->audio_clk, 24576000); + if (ret) { + dev_err(&pdev->dev, "set spdif base clock failed!\n"); + return ret; + } + + if (clk_prepare_enable(host->audio_clk)) { + dev_err(&pdev->dev, "try to enable audio clk failed\n"); + ret = -EINVAL; + goto exit_clkdisable_apb_clk; + } + + host->playback_supported = false; + host->capture_supported = false; + + if (of_property_read_bool(np, "spdif-out")) + host->playback_supported = true; + + if (!host->playback_supported) { + dev_err(&pdev->dev, "no enabled S/PDIF DAI link\n"); + goto exit_clkdisable_clk; + } + + host->dma_params_tx.addr = res->start + SUNXI_SPDIF_TXFIFO; + host->dma_params_tx.maxburst = 4; + host->dma_params_tx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; + host->dma_params_rx.addr = res->start + SUNXI_SPDIF_RXFIFO; + host->dma_params_rx.maxburst = 4; + host->dma_params_rx.addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES; + + /* Register with ASoC */ + dev_set_drvdata(&pdev->dev, host); + + ret = devm_snd_soc_register_component(&pdev->dev, + &sunxi_spdif_component, &sunxi_spdif_dai, 1); + if (ret) + goto exit_clkdisable_clk; + + ret = devm_snd_dmaengine_pcm_register(&pdev->dev, NULL, 0); + if (ret) + goto exit_clkdisable_clk; + return 0; + +exit_clkdisable_clk: + clk_disable_unprepare(host->clk); +exit_clkdisable_apb_clk: + clk_disable_unprepare(host->apb_clk); + return ret; +} + +static int sunxi_spdif_remove(struct platform_device *pdev) +{ + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); + + snd_soc_unregister_platform(&pdev->dev); + snd_soc_unregister_component(&pdev->dev); + + if (!IS_ERR(host->clk)) { + clk_disable_unprepare(host->clk); + clk_disable_unprepare(host->apb_clk); + } + + return 0; +} + +#ifdef CONFIG_PM +static int sunxi_spdif_suspend(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); + + if (host->running) + clk_disable(host->clk); + + return 0; +} + +static int sunxi_spdif_resume(struct device *dev) +{ + struct platform_device *pdev = to_platform_device(dev); + struct sunxi_spdif_dev *host = dev_get_drvdata(&pdev->dev); + + if (host->running) { + clk_enable(host->clk); + sunxi_spdif_configure(host); + } + return 0; +} + +static SIMPLE_DEV_PM_OPS(spdif_dev_pm_ops, sunxi_spdif_suspend, + sunxi_spdif_resume); + +#define SPDIF_DEV_PM_OPS (&spdif_dev_pm_ops) +#else +#define SPDIF_DEV_PM_OPS NULL + +#endif + +static struct platform_driver sunxi_spdif_driver = { + .driver = { + .name = "sunxi-spdif", + .owner = THIS_MODULE, + .pm = SPDIF_DEV_PM_OPS, + .of_match_table = of_match_ptr(sunxi_spdif_of_match), + }, + .probe = sunxi_spdif_probe, + .remove = sunxi_spdif_remove, +}; + +module_platform_driver(sunxi_spdif_driver); + +MODULE_AUTHOR("Marcus Cooper <codekipper@gmail.com>"); +MODULE_AUTHOR("Andrea Venturi <be17068@iperbole.bo.it>"); +MODULE_DESCRIPTION("Allwinner Sunxi SPDIF SoC Interface"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:sunxi-spdif");