[alsa-devel] [PATCH 4/4] qcom: ipq4019: Add ASoC driver modules

From: Jaiganesh Narayanan njaigane@codeaurora.org

This patch adds the alsa based audio driver for IPQ4019 ASoC.

Signed-off-by: Jaiganesh Narayanan njaigane@codeaurora.org --- sound/soc/qcom/Kconfig | 47 ++ sound/soc/qcom/Makefile | 1 + sound/soc/qcom/ipq4019/Makefile | 16 + sound/soc/qcom/ipq4019/ipq4019-adss.c | 407 ++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-adss.h | 432 +++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-codec.c | 475 +++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-codec.h | 91 ++++ sound/soc/qcom/ipq4019/ipq4019-cpu-dai.c | 687 ++++++++++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-mbox.c | 825 +++++++++++++++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-mbox.h | 146 +++++ sound/soc/qcom/ipq4019/ipq4019-pcm-i2s.c | 609 +++++++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-pcm-spdif.c | 664 +++++++++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-pcm-tdm.c | 609 +++++++++++++++++++++ sound/soc/qcom/ipq4019/ipq4019-pcm.h | 37 ++ sound/soc/qcom/ipq4019/ipq4019-stereo.c | 313 +++++++++++ sound/soc/qcom/ipq4019/ipq4019.c | 121 +++++ 16 files changed, 5480 insertions(+) create mode 100644 sound/soc/qcom/ipq4019/Makefile create mode 100644 sound/soc/qcom/ipq4019/ipq4019-adss.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-adss.h create mode 100644 sound/soc/qcom/ipq4019/ipq4019-codec.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-codec.h create mode 100644 sound/soc/qcom/ipq4019/ipq4019-cpu-dai.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-mbox.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-mbox.h create mode 100644 sound/soc/qcom/ipq4019/ipq4019-pcm-i2s.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-pcm-spdif.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-pcm-tdm.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019-pcm.h create mode 100644 sound/soc/qcom/ipq4019/ipq4019-stereo.c create mode 100644 sound/soc/qcom/ipq4019/ipq4019.c

diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig index 8ec9a07..de1f5b1 100644 --- a/sound/soc/qcom/Kconfig +++ b/sound/soc/qcom/Kconfig @@ -43,3 +43,50 @@ config SND_SOC_APQ8016_SBC Support for Qualcomm Technologies LPASS audio block in APQ8016 SOC-based systems. Say Y if you want to use audio devices on MI2S. + +config SND_SOC_IPQ4019 + tristate "Soc Audio support for IPQ4019 platforms" + depends on SND_SOC_QCOM + select SND_SOC_IPQ4019_ADSS + select SND_SOC_IPQ4019_CPU_DAI + select SND_SOC_IPQ4019_STEREO + select SND_SOC_IPQ4019_MBOX + select SND_SOC_IPQ4019_PCM_I2S + select SND_SOC_IPQ4019_CODEC + select SND_SOC_IPQ4019_PCM_TDM + select SND_SOC_IPQ4019_PCM_SPDIF + help + Say Y or M to if you want to add support for SoC audio on + Qualcomm Atheros IPQ4019 based board. + +config SND_SOC_IPQ4019_ADSS + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_CPU_DAI + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_STEREO + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_MBOX + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_PCM_I2S + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_CODEC + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_PCM_TDM + tristate + depends on SND_SOC_IPQ4019 + +config SND_SOC_IPQ4019_PCM_SPDIF + tristate + depends on SND_SOC_IPQ4019 diff --git a/sound/soc/qcom/Makefile b/sound/soc/qcom/Makefile index 79e5c50..f326b6a 100644 --- a/sound/soc/qcom/Makefile +++ b/sound/soc/qcom/Makefile @@ -15,3 +15,4 @@ snd-soc-apq8016-sbc-objs := apq8016_sbc.o

obj-$(CONFIG_SND_SOC_STORM) += snd-soc-storm.o obj-$(CONFIG_SND_SOC_APQ8016_SBC) += snd-soc-apq8016-sbc.o +obj-$(CONFIG_SND_SOC_IPQ4019) += ipq4019/ diff --git a/sound/soc/qcom/ipq4019/Makefile b/sound/soc/qcom/ipq4019/Makefile new file mode 100644 index 0000000..ee46f51 --- /dev/null +++ b/sound/soc/qcom/ipq4019/Makefile @@ -0,0 +1,16 @@ +# QCA IPQ4019 Sound Card Support +snd-soc-ipq4019-objs := ipq4019.o +snd-soc-ipq4019-cpu-dai-objs := ipq4019-cpu-dai.o +snd-soc-ipq4019-pcm-i2s-objs := ipq4019-pcm-i2s.o +snd-soc-ipq4019-pcm-tdm-objs := ipq4019-pcm-tdm.o +snd-soc-ipq4019-pcm-spdif-objs := ipq4019-pcm-spdif.o + +obj-$(CONFIG_SND_SOC_IPQ4019) += ipq4019.o +obj-$(CONFIG_SND_SOC_IPQ4019_ADSS) += ipq4019-adss.o +obj-$(CONFIG_SND_SOC_IPQ4019_CPU_DAI) += snd-soc-ipq4019-cpu-dai.o +obj-$(CONFIG_SND_SOC_IPQ4019_STEREO) += ipq4019-stereo.o +obj-$(CONFIG_SND_SOC_IPQ4019_MBOX) += ipq4019-mbox.o +obj-$(CONFIG_SND_SOC_IPQ4019_PCM_I2S) += snd-soc-ipq4019-pcm-i2s.o +obj-$(CONFIG_SND_SOC_IPQ4019_CODEC) += ipq4019-codec.o +obj-$(CONFIG_SND_SOC_IPQ4019_PCM_SPDIF) += snd-soc-ipq4019-pcm-spdif.o +obj-$(CONFIG_SND_SOC_IPQ4019_PCM_TDM) += snd-soc-ipq4019-pcm-tdm.o diff --git a/sound/soc/qcom/ipq4019/ipq4019-adss.c b/sound/soc/qcom/ipq4019/ipq4019-adss.c new file mode 100644 index 0000000..a3d21a193 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-adss.c @@ -0,0 +1,407 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/platform_device.h> +#include <linux/bitops.h> +#include <sound/pcm.h> +#include <linux/io.h> +#include <linux/delay.h> +#include <linux/reset.h> +#include <linux/spinlock.h> + +#include "ipq4019-adss.h" + +static void __iomem *adss_audio_local_base; +void __iomem *adss_audio_spdifin_base; +static struct reset_control *audio_blk_rst; +static spinlock_t i2s_ctrl_lock; +static spinlock_t tdm_ctrl_lock; +static spinlock_t glb_mode_lock; + +/* Channel Number Per Frame for Transmitter/Receiver + * Real value = val + 1 + */ +void ipq4019_glb_tdm_ctrl_ch_num(uint32_t val, uint32_t dir) +{ + uint32_t cfg; + unsigned long flags; + + spin_lock_irqsave(&tdm_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + + if (dir == PLAYBACK) { + cfg &= ~(GLB_TDM_CTRL_TX_CHAN_NUM_MASK); + cfg |= GLB_TDM_CTRL_TX_CHAN_NUM(val); + } else if (dir == CAPTURE) { + cfg &= ~(GLB_TDM_CTRL_RX_CHAN_NUM_MASK); + cfg |= GLB_TDM_CTRL_RX_CHAN_NUM(val); + } + writel(cfg, adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + spin_unlock_irqrestore(&tdm_ctrl_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_tdm_ctrl_ch_num); + +/* FSYNC Hi Duration for Transmitter/Receiver */ +void ipq4019_glb_tdm_ctrl_sync_num(uint32_t val, uint32_t dir) +{ + uint32_t cfg; + unsigned long flags; + + spin_lock_irqsave(&tdm_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + + if (dir == PLAYBACK) { + cfg &= ~(GLB_TDM_CTRL_TX_SYNC_NUM_MASK); + cfg |= GLB_TDM_CTRL_TX_SYNC_NUM(val); + } else if (dir == CAPTURE) { + cfg &= ~(GLB_TDM_CTRL_RX_SYNC_NUM_MASK); + cfg |= GLB_TDM_CTRL_RX_SYNC_NUM(val); + } + writel(cfg, adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + spin_unlock_irqrestore(&tdm_ctrl_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_tdm_ctrl_sync_num); + +/* Serial Data Delay for transmitter/receiver */ +void ipq4019_glb_tdm_ctrl_delay(uint32_t delay, uint32_t dir) +{ + uint32_t cfg; + unsigned long flags; + + spin_lock_irqsave(&tdm_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + + if (dir == PLAYBACK) { + cfg &= ~(GLB_TDM_CTRL_TX_DELAY); + if (delay) + cfg |= GLB_TDM_CTRL_TX_DELAY; + } else if (dir == CAPTURE) { + cfg &= ~(GLB_TDM_CTRL_RX_DELAY); + if (delay) + cfg |= GLB_TDM_CTRL_RX_DELAY; + } + writel(cfg, adss_audio_local_base + ADSS_GLB_TDM_CTRL_REG); + spin_unlock_irqrestore(&tdm_ctrl_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_tdm_ctrl_delay); + +/* I2S Interface Enable */ +static void ipq4019_glb_i2s_interface_en(int enable) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&i2s_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_CHIP_CTRL_I2S_REG); + cfg &= ~GLB_CHIP_CTRL_I2S_INTERFACE_EN; + if (enable) + cfg |= GLB_CHIP_CTRL_I2S_INTERFACE_EN; + writel(cfg, adss_audio_local_base + ADSS_GLB_CHIP_CTRL_I2S_REG); + spin_unlock_irqrestore(&i2s_ctrl_lock, flags); + /* + * As per the audio controller susbsytem after writing to + * the register wait 5ms for the i2s settle down. + */ + mdelay(5); +} +EXPORT_SYMBOL(ipq4019_glb_i2s_interface_en); + +/* Enable Stereo0/Stereo1/Stereo2 channel */ +void ipq4019_glb_stereo_ch_en(int enable, int stereo_ch) +{ + uint32_t cfg; + unsigned long flags; + + spin_lock_irqsave(&i2s_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_CHIP_CTRL_I2S_REG); + if (stereo_ch == STEREO0) { + cfg &= ~(GLB_CHIP_CTRL_I2S_STEREO0_GLB_EN); + cfg |= GLB_CHIP_CTRL_I2S_STEREO0_GLB_EN; + } else if (stereo_ch == STEREO1) { + cfg &= ~(GLB_CHIP_CTRL_I2S_STEREO1_GLB_EN); + cfg |= GLB_CHIP_CTRL_I2S_STEREO1_GLB_EN; + } else if (stereo_ch == STEREO2) { + cfg &= ~(GLB_CHIP_CTRL_I2S_STEREO2_GLB_EN); + cfg |= GLB_CHIP_CTRL_I2S_STEREO2_GLB_EN; + } + writel(cfg, adss_audio_local_base + ADSS_GLB_CHIP_CTRL_I2S_REG); + spin_unlock_irqrestore(&i2s_ctrl_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_stereo_ch_en); + +/* + * I2S Module Reset + */ +static void ipq4019_glb_i2s_reset(void) +{ + writel(GLB_I2S_RESET_VAL, adss_audio_local_base + ADSS_GLB_I2S_RST_REG); + mdelay(5); + writel(0x0, adss_audio_local_base + ADSS_GLB_I2S_RST_REG); +} + +/* + * Enable I2S/TDM and Playback/Capture Audio Mode + */ +void ipq4019_glb_audio_mode(int mode, int dir) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + if (mode == I2S && dir == PLAYBACK) { + cfg &= ~GLB_AUDIO_MODE_XMIT_MASK; + cfg |= GLB_AUDIO_MODE_XMIT_I2S; + } else if (mode == I2S && dir == CAPTURE) { + cfg &= ~GLB_AUDIO_MODE_RECV_MASK; + cfg |= GLB_AUDIO_MODE_RECV_I2S; + } else if (mode == TDM && dir == PLAYBACK) { + cfg &= ~GLB_AUDIO_MODE_XMIT_MASK; + cfg |= GLB_AUDIO_MODE_XMIT_TDM; + } else if (mode == TDM && dir == CAPTURE) { + cfg &= ~GLB_AUDIO_MODE_RECV_MASK; + cfg |= GLB_AUDIO_MODE_RECV_TDM; + } + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_audio_mode); + +/* + * I2S0 TX Data Port Enable + * + * Todo : + * Check if bits 6:4 configures only + * I2S0 or other channels as well + */ +void ipq4019_glb_tx_data_port_en(u32 enable) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~GLB_AUDIO_MODE_I2S0_TXD_OE; + if (enable) + cfg |= GLB_AUDIO_MODE_I2S0_TXD_OE; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_tx_data_port_en); + +/* + * I2S3 RX Data Port Enable + */ +void ipq4019_glb_rx_data_port_en(u32 enable) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~GLB_AUDIO_MODE_I2S3_RXD_OE; + if (enable) + cfg |= GLB_AUDIO_MODE_I2S3_RXD_OE; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_rx_data_port_en); + +/* + * Cross 1K Boundary + */ +void ipq4019_glb_audio_mode_B1K(void) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~GLB_AUDIO_MODE_B1K; + cfg |= GLB_AUDIO_MODE_B1K; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_audio_mode_B1K); + +/* + * Frame Sync Port Enable for I2S0 TX + */ +void ipq4019_glb_tx_framesync_port_en(u32 enable) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~GLB_AUDIO_MODE_I2S0_FS_OE; + if (enable) + cfg |= GLB_AUDIO_MODE_I2S0_FS_OE; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_tx_framesync_port_en); + +/* + * Frame Sync Port Enable for I2S3 RX + */ +void ipq4019_glb_rx_framesync_port_en(u32 enable) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&glb_mode_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~GLB_AUDIO_MODE_I2S3_FS_OE; + if (enable) + cfg |= GLB_AUDIO_MODE_I2S3_FS_OE; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + spin_unlock_irqrestore(&glb_mode_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_rx_framesync_port_en); + +void ipq4019_glb_clk_enable_oe(u32 dir) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&i2s_ctrl_lock, flags); + cfg = readl(adss_audio_local_base + ADSS_GLB_CLK_I2S_CTRL_REG); + + if (dir == PLAYBACK) { + cfg |= (GLB_CLK_I2S_CTRL_TX_BCLK_OE | + GLB_CLK_I2S_CTRL_TX_MCLK_OE); + } else { + cfg |= (GLB_CLK_I2S_CTRL_RX_BCLK_OE | + GLB_CLK_I2S_CTRL_RX_MCLK_OE); + } + writel(cfg, adss_audio_local_base + ADSS_GLB_CLK_I2S_CTRL_REG); + spin_unlock_irqrestore(&i2s_ctrl_lock, flags); +} +EXPORT_SYMBOL(ipq4019_glb_clk_enable_oe); + +void ipq4019_spdifin_ctrl_spdif_en(uint32_t enable) +{ + uint32_t reg_val; + + reg_val = readl(adss_audio_spdifin_base + ADSS_SPDIFIN_SPDIF_CTRL_REG); + + if (enable) + reg_val |= SPDIF_CTRL_SPDIF_ENABLE; + else + reg_val &= ~SPDIF_CTRL_SPDIF_ENABLE; + + writel(reg_val, adss_audio_spdifin_base + ADSS_SPDIFIN_SPDIF_CTRL_REG); + +} +EXPORT_SYMBOL(ipq4019_spdifin_ctrl_spdif_en); + +void ipq4019_spdifin_cfg(void) +{ + uint32_t reg_val; + + reg_val = readl(adss_audio_spdifin_base + ADSS_SPDIFIN_SPDIF_CTRL_REG); + reg_val &= ~(SPDIF_CTRL_CHANNEL_MODE + | SPDIF_CTRL_VALIDITYCHECK + | SPDIF_CTRL_PARITYCHECK); + reg_val |= (SPDIF_CTRL_USE_FIFO_IF + | SPDIF_CTRL_SFR_ENABLE + | SPDIF_CTRL_FIFO_ENABLE); + writel(reg_val, adss_audio_spdifin_base + ADSS_SPDIFIN_SPDIF_CTRL_REG); +} +EXPORT_SYMBOL(ipq4019_spdifin_cfg); + +void ipq4019_glb_spdif_out_en(uint32_t enable) +{ + int32_t cfg; + + cfg = readl(adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); + cfg &= ~(GLB_AUDIO_MODE_SPDIF_OUT_OE); + if (enable) + cfg |= GLB_AUDIO_MODE_SPDIF_OUT_OE; + writel(cfg, adss_audio_local_base + ADSS_GLB_AUDIO_MODE_REG); +} +EXPORT_SYMBOL(ipq4019_glb_spdif_out_en); + +static const struct of_device_id ipq4019_audio_adss_id_table[] = { + { .compatible = "qca,ipq4019-audio-adss" }, + {}, +}; +MODULE_DEVICE_TABLE(of, ipq4019_audio_adss_id_table); + +static int ipq4019_audio_adss_probe(struct platform_device *pdev) +{ + struct resource *res; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + adss_audio_local_base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(adss_audio_local_base)) + return PTR_ERR(adss_audio_local_base); + + res = platform_get_resource(pdev, IORESOURCE_MEM, 1); + adss_audio_spdifin_base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(adss_audio_spdifin_base)) + return PTR_ERR(adss_audio_spdifin_base); + + audio_blk_rst = devm_reset_control_get(&pdev->dev, "blk_rst"); + if (IS_ERR(audio_blk_rst)) + return PTR_ERR(audio_blk_rst); + + spin_lock_init(&i2s_ctrl_lock); + spin_lock_init(&glb_mode_lock); + spin_lock_init(&tdm_ctrl_lock); + + /* + * Reset order is critical here. + * First audio block should be out of reset, + * followed by I2S block. + * Since the audio block is brought out of + * reset by hardware by default, it is not + * required to be done in software explicitly. + */ + ipq4019_glb_i2s_reset(); + + ipq4019_glb_i2s_interface_en(ENABLE); + + ipq4019_glb_audio_mode_B1K(); + + return 0; +} + +static int ipq4019_audio_adss_remove(struct platform_device *pdev) +{ + ipq4019_glb_i2s_interface_en(DISABLE); + return 0; +} + +static struct platform_driver ipq4019_audio_adss_driver = { + .probe = ipq4019_audio_adss_probe, + .remove = ipq4019_audio_adss_remove, + .driver = { + .name = "ipq4019-adss", + .of_match_table = ipq4019_audio_adss_id_table, + }, +}; + +module_platform_driver(ipq4019_audio_adss_driver); + +MODULE_ALIAS("platform:ipq4019-adss"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 Audio subsytem driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-adss.h b/sound/soc/qcom/ipq4019/ipq4019-adss.h new file mode 100644 index 0000000..87f3e0f --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-adss.h @@ -0,0 +1,432 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef IPQ4019_ADSS_H +#define IPQ4019_ADSS_H + +/* ADSS AUDIO Registers */ + +#define ADSS_BASE 0x7700000 +#define ADSS_RANGE 0x20000 + +/* ADSS_AUDIO_LOCAL_REG Registers */ + +#define ADSS_GLB_PCM_MBOX_CTRL_REG 0x0C + +#define ADSS_GLB_CHIP_CTRL_I2S_REG 0x10 +#define GLB_CHIP_CTRL_I2S_INTERFACE_EN BIT(0) +#define GLB_CHIP_CTRL_I2S_STEREO0_GLB_EN BIT(1) +#define GLB_CHIP_CTRL_I2S_STEREO1_GLB_EN BIT(2) +#define GLB_CHIP_CTRL_I2S_STEREO2_GLB_EN BIT(3) + +#define ADSS_GLB_I2S_RST_REG 0x14 +#define GLB_I2S_RST_CTRL_MBOX0 BIT(0) +#define GLB_I2S_RST_CTRL_I2S0 BIT(1) +#define GLB_I2S_RST_CTRL_MBOX3 BIT(2) +#define GLB_I2S_RESET_VAL 0xF + +#define ADSS_GLB_CLK_I2S_CTRL_REG 0x18 +#define GLB_CLK_I2S_CTRL_TX_BCLK_OE BIT(28) +#define GLB_CLK_I2S_CTRL_RX_BCLK_OE BIT(27) +#define GLB_CLK_I2S_CTRL_RX_MCLK_OE BIT(16) +#define GLB_CLK_I2S_CTRL_TX_MCLK_OE BIT(17) + +#define ADSS_GLB_TDM_CTRL_REG 0x1C +#define GLB_TDM_CTRL_TX_CHAN_NUM(x) (x << 0) +#define GLB_TDM_CTRL_TX_CHAN_NUM_MASK 0xF +#define GLB_TDM_CTRL_TX_SYNC_NUM(x) (x << 4) +#define GLB_TDM_CTRL_TX_SYNC_NUM_MASK (0x1F << 4) +#define GLB_TDM_CTRL_RX_CHAN_NUM(x) (x << 16) +#define GLB_TDM_CTRL_RX_CHAN_NUM_MASK (0xF << 16) +#define GLB_TDM_CTRL_RX_SYNC_NUM(x) (x << 20) +#define GLB_TDM_CTRL_RX_SYNC_NUM_MASK (0x1F << 20) +#define GLB_TDM_CTRL_TX_DELAY BIT(25) +#define GLB_TDM_CTRL_RX_DELAY BIT(26) + +#define ADSS_GLB_AUDIO_MODE_REG 0x30 +#define GLB_AUDIO_MODE_RECV_MASK BIT(2) +#define GLB_AUDIO_MODE_XMIT_MASK BIT(0) +#define GLB_AUDIO_MODE_RECV_I2S (0 << 2) +#define GLB_AUDIO_MODE_RECV_TDM BIT(2) +#define GLB_AUDIO_MODE_XMIT_I2S (0 << 0) +#define GLB_AUDIO_MODE_XMIT_TDM BIT(0) +#define GLB_AUDIO_MODE_I2S0_TXD_OE (7 << 4) +#define GLB_AUDIO_MODE_I2S0_FS_OE BIT(7) +#define GLB_AUDIO_MODE_I2S3_FS_OE BIT(8) +#define GLB_AUDIO_MODE_I2S3_RXD_OE BIT(9) +#define GLB_AUDIO_MODE_SPDIF_OUT_OE BIT(10) +#define GLB_AUDIO_MODE_B1K BIT(28) + +#define ADSS_MBOX_STEREO_AUDIO_BASE (ADSS_BASE + 0x8000) + +/* ADSS_MBOX_STEREO_AUDIO_BASE + 0x0 */ +#define ADSS_MBOX0_AUDIO_BASE 0x0 +#define ADSS_MBOX1_AUDIO_BASE 0x2000 +#define ADSS_MBOX2_AUDIO_BASE 0x4000 +#define ADSS_MBOX3_AUDIO_BASE 0x6000 + +#define ADSS_MBOXn_MBOX_FIFO0_REG 0x0 +#define MBOX_FIFO_RESET_TX_INIT BIT(0) +#define MBOX_FIFO_RESET_RX_INIT BIT(2) + +#define ADSS_MBOXn_MBOX_FIFO_STATUS0_REG 0x08 + +#define ADSS_MBOXn_MBOX_DMA_POLICY_REG 0x10 +#define MBOX_DMA_POLICY_SW_RESET BIT(31) +#define MBOX_DMA_POLICY_TX_INT_TYPE BIT(17) +#define MBOX_DMA_POLICY_RX_INT_TYPE BIT(16) +#define MBOX_DMA_POLICY_RXD_16BIT_SWAP BIT(10) +#define MBOX_DMA_POLICY_RXD_END_SWAP BIT(8) +#define ADSS_MBOX_DMA_POLICY_SRAM_AC(x) ((((x) >> 28) & 0xf) << 12) +#define ADSS_MBOX_DMA_POLICY_TX_FIFO_THRESHOLD(x) ((((x) & 0xf) << 4)) + +#define ADSS_MBOXn_MBOXn_DMA_RX_DESCRIPTOR_BASE_REG 0x18 + +#define ADSS_MBOXn_MBOXn_DMA_RX_CONTROL_REG 0x1C +#define ADSS_MBOXn_DMA_RX_CONTROL_STOP BIT(0) +#define ADSS_MBOXn_DMA_RX_CONTROL_START BIT(1) +#define ADSS_MBOXn_DMA_RX_CONTROL_RESUME BIT(2) + +#define ADSS_MBOXn_MBOXn_DMA_TX_DESCRIPTOR_BASE_REG 0x20 + +#define ADSS_MBOXn_MBOXn_DMA_TX_CONTROL_REG 0x24 +#define ADSS_MBOXn_DMA_TX_CONTROL_STOP BIT(0) +#define ADSS_MBOXn_DMA_TX_CONTROL_START BIT(1) +#define ADSS_MBOXn_DMA_TX_CONTROL_RESUME BIT(2) + +#define ADSS_MBOXn_MBOX_FRAME_REG 0x38 +#define ADSS_MBOXn_FIFO_TIMEOUT_REG 0x40 + +#define ADSS_MBOXn_MBOX_INT_STATUS_REG 0x44 +#define MBOX_INT_STATUS_TX_DMA_COMPLETE BIT(6) +#define MBOX_INT_STATUS_RX_DMA_COMPLETE BIT(10) + +#define ADSS_MBOXn_MBOX_INT_ENABLE_REG 0x4C +#define MBOX_INT_ENABLE_RX_DMA_COMPLETE BIT(10) +#define MBOX_INT_STATUS_RX_UNDERFLOW BIT(4) +#define MBOX_INT_STATUS_RX_FIFO_UNDERFLOW BIT(12) +#define MBOX_INT_ENABLE_TX_DMA_COMPLETE BIT(6) +#define MBOX_INT_STATUS_TX_OVERFLOW BIT(5) +#define MBOX_INT_STATUS_TX_FIFO_OVERFLOW BIT(13) + +#define ADSS_MBOXn_MBOX_FIFO_RESET_REG 0x58 +#define MBOX_FIFO_RESET_TX_INIT BIT(0) +#define MBOX_FIFO_RESET_RX_INIT BIT(2) + +#define ADSS_MBOXn_MBOX_DEBUG_CHAIN0_REG 0x60 +#define ADSS_MBOXn_MBOX_DEBUG_CHAIN1_REG 0x64 +#define ADSS_MBOXn_MBOX_DEBUG_CHAIN0_SIGNALS_REG 0x68 +#define ADSS_MBOXn_MBOX_DEBUG_CHAIN1_SIGNALS_REG 0x6C + +/* ADSS_STEREO0_AUDIO_STEREO_REG Registers */ + +#define ADSS_STEREO0_AUDIO_BASE 0x9000 +#define ADSS_STEREO1_AUDIO_BASE 0xB000 +#define ADSS_STEREO2_AUDIO_BASE 0xD000 +#define ADSS_STEREO3_AUDIO_BASE 0xF000 + +#define STEREO0_OFFSET 0x0 +#define STEREO1_OFFSET 0x2000 +#define STEREO2_OFFSET 0x4000 +#define STEREO3_OFFSET 0x6000 + +#define ADSS_STEREOn_STEREO0_CONFIG_REG 0x0 +#define STEREOn_CONFIG_MIC_SWAP BIT(24) +#define STEREOn_CONFIG_SPDIF_ENABLE BIT(23) +#define STEREOn_CONFIG_ENABLE BIT(21) +#define STEREOn_CONFIG_MIC_RESET BIT(20) +#define STEREOn_CONFIG_RESET BIT(19) +#define STEREOn_CONFIG_I2S_DELAY (0 << 18) +#define STEREOn_CONFIG_PCM_SWAP BIT(17) +#define STEREOn_CONFIG_MIC_WORD_SIZE_32 BIT(16) +#define STEREOn_CONFIG_MIC_WORD_SIZE_16 (0 << 16) +#define STEREOn_CONFIG_STEREO_MODE (0 << 14) +#define STEREOn_CONFIG_MONO_MODE BIT(14) +#define STEREOn_CONFIG_STEREO_MONO_MASK (3 << 14) +#define STEREOn_CONFIG_DATA_WORD_SIZE(x) ((x) << 12) +#define STEREOn_CONFIG_DATA_WORD_SIZE_MASK (3 << 12) +#define STEREOn_CONFIG_I2S_WORD_SIZE_32 BIT(11) +#define STEREOn_CONFIG_I2S_WORD_SIZE_16 (0 << 11) +#define STEREOn_CONFIG_MCK_SEL BIT(10) +#define STEREOn_CONFIG_SAMPLE_CNT_CLEAR_TYPE BIT(9) +#define STEREOn_CONFIG_MASTER BIT(8) + +#define MAX_STEREO_ENTRIES 4 +#define TDM_SYNC_NUM 2 +#define TDM_DELAY 0 +#define MCLK_MULTI 4 + +/* ADSS_AUDIO_PCM_REG Registers */ + +#define ADSS_AUDIO_PCM_REG_BASE ADSS_BASE + 0x4000 + +#define AADSS_PCM_BITMAP_REG 0x0 + +#define AADSS_PCM_CTRL_REG 0x04 +#define PCM_CTRL_TX2RX_LP_EN(x) (x << 31) +#define PCM_CTRL_RX2TX_LP_EN(x) (x << 30) +#define PCM_CTRL_CPU_MODE(x) (x << 29) +#define PCM_CTRL_PCM_GCLK_EN(x) (x << 28) +#define PCM_CTRL_FRAME_SYNC_LEN(x) (x << 26) +#define PCM_CTRL_PCM_CLK_MODE(x) (x << 25) +#define PCM_CTRL_PCM_SLOT_MODE(x) (x << 24) +#define PCM_CTRL_PCM_DCLK_MODE(x) (x << 4) +#define PCM_CTRL_PCM_TX_PHASE(x) (x << 2) +#define PCM_CTRL_PCM_RX_PHASE(x) (x << 0) + +#define AADSS_PCM_OFFSET_REG 0x08 +#define AADSS_PCM_START_REG 0x0C +#define AADSS_PCM_INT_STATUS_REG 0x10 +#define AADSS_PCM_INT_ENABLE_REG 0x14 +#define AADSS_PCM_RX_DATA_8BIT_REG 0x18 +#define AADSS_PCM_TX_DATA_8BIT_REG 0x1C +#define AADSS_PCM_DIVIDER_REG 0x20 +#define AADSS_PCM_TH_REG 0x24 +#define AADSS_PCM_FIFO_CNT_REG 0x28 +#define AADSS_PCM_FIFO_ERR_SLOT_REG 0x2C +#define AADSS_PCM_RX_DATA_16BIT_REG 0x30 +#define AADSS_PCM_TX_DATA_16BIT_REG 0x34 + +/* I2S Parameters */ +#define IPQ4019_I2S_NO_OF_PERIODS (130) +#define IPQ4019_I2S_PERIOD_BYTES_MIN ALIGN(4032, L1_CACHE_BYTES) +#define IPQ4019_I2S_BUFF_SIZE (IPQ4019_I2S_PERIOD_BYTES_MIN * \ + IPQ4019_I2S_NO_OF_PERIODS) +#define IPQ4019_I2S_CAPTURE_BUFF_SIZE (IPQ4019_I2S_PERIOD_BYTES_MIN * \ + IPQ4019_I2S_NO_OF_PERIODS) + +/* TDM Parameters */ +#define IPQ4019_TDM_NO_OF_PERIODS (260) +#define IPQ4019_TDM_PERIOD_BYTES_MIN ALIGN(4032, L1_CACHE_BYTES) +#define IPQ4019_TDM_BUFF_SIZE (IPQ4019_TDM_PERIOD_BYTES_MIN * \ + IPQ4019_TDM_NO_OF_PERIODS) +#define IPQ4019_TDM_CAPTURE_BUFF_SIZE (IPQ4019_TDM_PERIOD_BYTES_MIN * \ + IPQ4019_TDM_NO_OF_PERIODS) + +/* SPDIF area */ + + +/* ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG Registers */ + +#define ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE ADSS_BASE + 0x6000 + +#define AADSS_MBOXSPDIFIN_MBOX_FIFO0_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x0) + +#define AADSS_MBOXSPDIFIN_MBOX_FIFO_STATUS0_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x08) + +#define AADSS_MBOXSPDIFIN_MBOX_DMA_POLICY_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x10) + +#define AADSS_MBOXSPDIFIN_MBOX0_DMA_RX_DESCRIPTOR_BASE_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x18) + +#define AADSS_MBOXSPDIFIN_MBOX0_DMA_RX_CONTROL_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x1C) + +#define AADSS_MBOXSPDIFIN_MBOX0_DMA_TX_DESCRIPTOR_BASE_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x20) + +#define AADSS_MBOXSPDIFIN_MBOX0_DMA_TX_CONTROL_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x24) + +#define AADSS_MBOXSPDIFIN_MBOX_FRAME_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x38) + +#define AADSS_MBOXSPDIFIN_FIFO_TIMEOUT_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x40) + +#define AADSS_MBOXSPDIFIN_MBOX_INT_STATUS_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x44) + +#define AADSS_MBOXSPDIFIN_MBOX_INT_ENABLE_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x4C) + +#define AADSS_MBOXSPDIFIN_MBOX_FIFO_RESET_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x58) + +#define AADSS_MBOXSPDIFIN_MBOX_DEBUG_CHAIN0_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x60) + +#define AADSS_MBOXSPDIFIN_MBOX_DEBUG_CHAIN1_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x64) + +#define AADSS_MBOXSPDIFIN_MBOX_DEBUG_CHAIN0_SIGNALS_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x68) + +#define AADSS_MBOXSPDIFIN_MBOX_DEBUG_CHAIN1_SIGNALS_REG \ + ((ADSS_MBOXSPDIFIN_AUDIO_MBOX_REG_BASE) + 0x6C) + +/* ADSS_SPDIFIN_AUDIO_SPDIF_BASE Registers */ + +#define ADSS_SPDIFIN_SPDIF_CTRL_REG (0x00) +#define SPDIF_CTRL_INTREQ_MASK BIT(31) +#define SPDIF_CTRL_BEGIN_MASK BIT(30) +#define SPDIF_CTRL_LOCK_MASK BIT(29) +#define SPDIF_CTRL_SYNCERR_MASK BIT(28) +#define SPDIF_CTRL_AFULL_MASK BIT(27) +#define SPDIF_CTRL_FULL_MASK BIT(26) +#define SPDIF_CTRL_AEMPTY_MASK BIT(25) +#define SPDIF_CTRL_EMPTY_MASK BIT(24) +#define SPDIF_CTRL_OVRERR_MASK BIT(23) +#define SPDIF_CTRL_UNDERR_MASK BIT(22) +#define SPDIF_CTRL_PARITY_MASK BIT(21) +#define SPDIF_CTRL_USE_FIFO_IF BIT(19) +#define SPDIF_CTRL_SETPREAMBB BIT(18) +#define SPDIF_CTRL_DUPLICATE BIT(17) +#define SPDIF_CTRL_CHANNEL_MODE BIT(16) +#define SPDIF_CTRL_VALIDITYCHECK BIT(15) +#define SPDIF_CTRL_PARITYGEN BIT(14) +#define SPDIF_CTRL_PARITYCHECK BIT(13) +#define SPDIF_CTRL_TR_MODE BIT(12) +#define SPDIF_CTRL_CLK_ENABLE BIT(11) +#define SPDIF_CTRL_FIFO_ENABLE BIT(10) +#define SPDIF_CTRL_SPDIF_ENABLE BIT(9) +#define SPDIF_CTRL_SFR_ENABLE BIT(8) +#define SPDIF_CTRL_TSAMPLERATE BIT(7) + +#define ADSS_SPDIFIN_STEREO0_VOLUME (0x04) +#define ADSS_SPDIFIN_FIFO_CTRL_REG (0x08) +#define ADSS_SPDIFIN_START_REG_REG (0x0C) +#define ADSS_SPDIFIN_SELFIFO_REG (0x10) + + +#define ADSS_AUDIO_SPDIF_MISC_REG 0x150 +#define AUDIO_SPDIF_MISC_AUTO_SCALE_DIV_MASK (0xF << 1) +#define AUDIO_SPDIF_MISC_AUTO_SCALE_DIV(x) (x << 1) + +#define ADSS_AUDIO_SPDIF_CBCR_REG 0x154 + +#define ADSS_AUDIO_SPDIFDIV2_MISC_REG 0x158 +#define AUDIO_SPDIFDIV2_MISC_AUTO_SCALE_DIV_MASK (0xF << 1) +#define AUDIO_SPDIFDIV2_MISC_AUTO_SCALE_DIV(x) (x << 1) + +#define ADSS_AUDIO_SPDIFDIV2_CBCR_REG 0x15C +#define ADSS_AUDIO_SPDIFINFAST_CMD_RCGR_REG 0x1E0 +#define AUDIO_SPDIFINFAST_CMD_RCGR_ROOT_EN (1 << 1) +#define AUDIO_SPDIFINFAST_CMD_RCGR_UPDATE (1 << 0) + +#define ADSS_AUDIO_SPDIFINFAST_CFG_RCGR_REG 0x1E4 +#define AUDIO_SPDIFINFAST_CFG_RCGR_SRC_SEL(x) (x << 8) +#define AUDIO_SPDIFINFAST_CFG_RCGR_SRC_DIV(x) (x << 0) + +#define ADSS_AUDIO_SPDIFINFAST_CBCR_REG 0x1EC +#define AUDIO_SPDIFINFAST 49152000 + +#define SNDRV_PCM_FMTBIT_S24_3 SNDRV_PCM_FMTBIT_S24_3LE + +/* Enumerations */ + +enum intf { + I2S, + TDM, + SPDIF, + I2S1, + I2S2, + MAX_INTF +}; + +enum dir { + PLAYBACK, + CAPTURE +}; + +enum cfg { + DISABLE, + ENABLE +}; + +/* Supported Channels */ +enum channels { + CH_STEREO = 2, + CH_3_1 = 4, + CH_5_1 = 6, + CH_7_1 = 8 +}; + +enum ipq4019_samp_freq { + FREQ_8000 = 8000, + FREQ_11025 = 11025, + FREQ_16000 = 16000, + FREQ_22050 = 22050, + FREQ_32000 = 32000, + FREQ_44100 = 44100, + FREQ_48000 = 48000, + FREQ_64000 = 64000, + FREQ_88200 = 88200, + FREQ_96000 = 96000, + FREQ_176400 = 176400, + FREQ_192000 = 192000, +}; + +#define RATE_16000_96000 \ + (SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\ + SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\ + SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |\ + SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000) + +enum stereo_ch { + STEREO0, + STEREO1, + STEREO2, + STEREO3 +}; + +enum bit_width { + __BIT_8 = 8, + __BIT_16 = 16, + __BIT_24 = 24, + __BIT_32 = 32, + __BIT_INVAL = -1 +}; + +/* ADSS APIs */ +extern void ipq4019_glb_audio_mode(int mode, int dir); +extern void ipq4019_glb_tx_data_port_en(uint32_t enable); +extern void ipq4019_glb_rx_data_port_en(uint32_t enable); +extern void ipq4019_glb_tx_framesync_port_en(uint32_t enable); +extern void ipq4019_glb_rx_framesync_port_en(uint32_t enable); +extern void ipq4019_glb_clk_enable_oe(uint32_t dir); +/* Stereo APIs */ +extern void ipq4019_stereo_config_reset(uint32_t reset, uint32_t stereo_offset); +extern void ipq4019_stereo_config_mic_reset(uint32_t reset, + uint32_t stereo_offset); +extern void ipq4019_stereo_config_enable(uint32_t enable, + uint32_t stereo_offset); +extern int ipq4019_cfg_bit_width(uint32_t bit_width, uint32_t stereo_offset); +extern void ipq4019_config_stereo_mode(uint32_t mode, uint32_t stereo_offset); +extern void ipq4019_config_master(uint32_t enable, uint32_t stereo_offset); +extern void ipq4019_config_mclk_sel(uint32_t stereo_offset, uint32_t val); +extern void ipq4019_config_sample_cnt_clear_type(uint32_t stereo_offset); + +/* APIs in DAI driver */ +extern int ipq4019_get_mbox_id(struct snd_pcm_substream *substream, int intf); +extern int ipq4019_get_stereo_id(struct snd_pcm_substream *substream, int intf); +extern u32 ipq4019_get_act_bit_width(u32 bit_width); +extern void ipq4019_stereo_spdif_enable(uint32_t enable, uint32_t stereo_id); +extern void ipq4019_stereo_spdif_pcmswap(uint32_t enable, uint32_t stereo_id); +extern void ipq4019_spdifin_ctrl_spdif_en(uint32_t enable); +extern void ipq4019_glb_spdif_out_en(uint32_t enable); +extern void ipq4019_spdifin_cfg(void); +extern void ipq4019_glb_tdm_ctrl_ch_num(uint32_t val, uint32_t dir); +extern void ipq4019_glb_tdm_ctrl_sync_num(uint32_t val, uint32_t dir); +extern void ipq4019_glb_tdm_ctrl_delay(uint32_t delay, uint32_t dir); + +void ipq4019_glb_audio_mode_B1K(void); + +#endif diff --git a/sound/soc/qcom/ipq4019/ipq4019-codec.c b/sound/soc/qcom/ipq4019/ipq4019-codec.c new file mode 100644 index 0000000..61421d9 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-codec.c @@ -0,0 +1,475 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/module.h> +#include <linux/init.h> +#include <sound/soc.h> +#include <sound/pcm.h> +#include <sound/soc.h> +#include <sound/soc-dai.h> +#include <sound/control.h> +#include <linux/platform_device.h> +#include <linux/spi/spi.h> +#include <linux/i2c.h> +#include <linux/gpio.h> +#include <linux/delay.h> +#include <sound/initval.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> + +#include "ipq4019-adss.h" +#include "ipq4019-codec.h" + +struct audio_hw_params audio_params; + +static const u8 akd4613_reg[AK4613_MAX_REG] = { + 0x0F, 0x07, 0x3F, 0x20, 0x20, 0x55, 0x05, 0x07, + 0x0F, 0x07, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +uint8_t ipq4019_compare_hw_params(struct audio_hw_params *curr_params) +{ + if ((curr_params->bit_width == audio_params.bit_width) && + (curr_params->freq == audio_params.freq) && + (curr_params->channels == audio_params.channels)) + return 0; + else + return -EINVAL; +} + +/* DFS : Sampling Speed + * + * DFS1 DFS0 Sampling Speed Mode (fs) + * 0 0 Normal Speed Mode 32kHz~48kHz (default) + * 0 1 Double Speed Mode 64kHz~96kHz + * 1 0 Quad Speed Mode 128kHz~192kHz + * 1 1 N/A - + */ + +static int ipq4019_codec_i2c_set_dfs(struct snd_soc_codec *codec, int mode) +{ + uint32_t reg; + + if (mode > QUAD_SPEED) { + pr_err("%s: %d: Invalid DFS mode", __func__, __LINE__); + return -EINVAL; + } + + reg = snd_soc_read(codec, AKD4613_04_CTRL2); + + reg &= ~(AKD4613_DFS_MASK); + reg |= AKD4613_DFS(mode); + + snd_soc_write(codec, AKD4613_04_CTRL2, reg); + + return 0; +} + +/* CKS : Master Clock Input Frequency Select + * + * CKS1 CKS0 Normal Speed Double Speed Quad Speed + * 0 0 256fs 256fs 128fs + * 0 1 384fs 256fs 128fs + * 1 0 512fs 256fs 128fs (default) + * 1 1 512fs 256fs 128fs + */ + +static int ipq4019_codec_i2c_set_cks(struct snd_soc_codec *codec, + int config, int mode) +{ + uint32_t cks_val; + uint32_t reg; + + if (mode == NORMAL_SPEED) { + if (config == FS_256) + cks_val = 0; + else if (config == FS_384) + cks_val = 1; + else if (config == FS_512) + cks_val = 2; + else + cks_val = -EINVAL; + } else if (mode == DOUBLE_SPEED) { + if (config == FS_256) + cks_val = 2; + else + cks_val = -EINVAL; + } else if (mode == QUAD_SPEED) { + if (config == FS_128) + cks_val = 2; + else + cks_val = -EINVAL; + } else { + pr_err("%s: %d: Invalid DFS mode", __func__, __LINE__); + return -EINVAL; + } + + if (cks_val < 0) { + pr_err("%s: %d: Invalid CKS config", __func__, __LINE__); + return cks_val; + } + + reg = snd_soc_read(codec, AKD4613_04_CTRL2); + + reg &= ~(AKD4613_CKS_MASK); + reg |= AKD4613_CKS(cks_val); + + snd_soc_write(codec, AKD4613_04_CTRL2, reg); + + return 0; +} + +static int ipq4019_codec_i2c_set_tdm_mode(struct snd_soc_codec *codec, + int tdm_mode) +{ + uint32_t reg; + + if (tdm_mode >= TDM_MAX) { + pr_err("%s: %d: Invalid DFS mode", __func__, __LINE__); + return -EINVAL; + } + + reg = snd_soc_read(codec, AKD4613_03_CTRL1); + + reg &= ~(AKD4613_TDM_MODE_MASK); + reg |= AKD4613_TDM_MODE(tdm_mode); + + snd_soc_write(codec, AKD4613_03_CTRL1, reg); + + return 0; +} + +static int ipq4019_codec_i2c_set_dif(struct snd_soc_codec *codec, + int dif_val) +{ + uint32_t reg; + + reg = snd_soc_read(codec, AKD4613_03_CTRL1); + + reg &= ~(AKD4613_DIF_MASK); + reg |= AKD4613_DIF(dif_val); + + snd_soc_write(codec, AKD4613_03_CTRL1, reg); + + return 0; +} + +static void ipq4019_codec_i2c_write_defaults(struct snd_soc_codec *codec) +{ + int i; + + for (i = 0; i < AK4613_MAX_REG; i++) + snd_soc_write(codec, i, akd4613_reg[i]); + udelay(10); +} + +static int ipq4019_codec_audio_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec; + + codec = dai->codec; + + /* I2S and TDM cannot co-exist. CPU DAI startup would + * have already checked this case, by this time. + */ + if (!dai->active) + ipq4019_codec_i2c_write_defaults(codec); + + return 0; +} + +static int ipq4019_codec_audio_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec; + int samp_rate = params_rate(params); + u32 bit_width = params_format(params); + int channels = params_channels(params); + int bit_act; + int dfs, cks, tdm_mode, dif; + uint32_t intf = dai->driver->id; + struct audio_hw_params curr_params; + + bit_act = ipq4019_get_act_bit_width(bit_width); + if (bit_act == __BIT_INVAL) + return -EINVAL; + + curr_params.freq = samp_rate; + curr_params.channels = channels; + curr_params.bit_width = bit_act; + + codec = dai->codec; + + /* + * Since CLKS in the codec are shared by I2S TX and RX channels, + * Rx and Tx when used simulatneoulsy will have to use the same channel, + * sampling frequency and bit widths. So compare the settings and then + * update the codec settings. + */ + + if (dai->active > 1) { + if (ipq4019_compare_hw_params(&curr_params)) { + /* Playback and capture settings do not match */ + pr_err("\nPlayback and capture settings do not match\n"); + return -EINVAL; + } + /* Settings match, codec settings are already done*/ + return 0; + } + + audio_params.freq = samp_rate; + audio_params.channels = channels; + audio_params.bit_width = bit_act; + + if (intf == I2S) { + /* default values */ + dfs = NORMAL_SPEED; + cks = FS_512; + tdm_mode = STEREO; + dif = DIF_I2S_MODE; + + } else if (intf == TDM) { + /* Codec settings for 8 channels */ + dfs = DOUBLE_SPEED; + cks = FS_256; + tdm_mode = TDM_256; + dif = DIF_LR_MODE3; + } else { + pr_err("\n%s Invalid interface\n", __func__); + return -EINVAL; + } + + ipq4019_codec_i2c_set_dfs(codec, dfs); + ipq4019_codec_i2c_set_cks(codec, cks, dfs); + ipq4019_codec_i2c_set_tdm_mode(codec, tdm_mode); + ipq4019_codec_i2c_set_dif(codec, dif); + udelay(10); + + return 0; +} + +static int ipq4019_codec_audio_prepare(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + dev_dbg(dai->dev, "%s:%d\n", __func__, __LINE__); + return 0; +} + +static void ipq4019_codec_audio_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + dev_dbg(dai->dev, "%s:%d\n", __func__, __LINE__); +} + +static struct snd_soc_dai_ops ipq4019_codec_audio_ops = { + .startup = ipq4019_codec_audio_startup, + .hw_params = ipq4019_codec_audio_hw_params, + .prepare = ipq4019_codec_audio_prepare, + .shutdown = ipq4019_codec_audio_shutdown, +}; + +static struct snd_soc_dai_driver ipq4019_codec_dais[] = { + { + .name = "qca-i2s-codec-dai", + .playback = { + .stream_name = "qca-i2s-playback", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + .capture = { + .stream_name = "qca-i2s-capture", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + .ops = &ipq4019_codec_audio_ops, + .id = I2S, + }, + { + .name = "qca-tdm-codec-dai", + .playback = { + .stream_name = "qca-tdm-playback", + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + .capture = { + .stream_name = "qca-tdm-capture", + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + .ops = &ipq4019_codec_audio_ops, + .id = TDM, + }, + { + .name = "qca-i2s1-codec-dai", + .playback = { + .stream_name = "qca-i2s1-playback", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + }, + { + .name = "qca-i2s2-codec-dai", + .playback = { + .stream_name = "qca-i2s2-playback", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + }, + }, + { + .name = "qca-spdif-codec-dai", + .playback = { + .stream_name = "qca-spdif-playback", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + }, + .capture = { + .stream_name = "qca-spdif-capture", + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + }, + }, +}; + +static int ipq4019_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + return -ENOTSUPP; +} + +static const struct snd_kcontrol_new vol_ctrl = { + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "playback volume", + .access = (SNDRV_CTL_ELEM_ACCESS_TLV_READ | + SNDRV_CTL_ELEM_ACCESS_READWRITE), + .info = ipq4019_info, +}; + +unsigned int ipq4019_codec_i2c_read(struct snd_soc_codec *codec, + unsigned int reg) +{ + int ret; + + ret = i2c_smbus_read_byte_data(codec->control_data, (u8)(reg & 0xFF)); + if (ret < 0) + pr_err("\ti2c read error %s(%d)\n", __func__, ret); + + return ret; +} + +static const struct snd_soc_codec_driver ipq4019_codec = { + .num_controls = 0, + .reg_cache_size = ARRAY_SIZE(akd4613_reg), + .reg_word_size = sizeof(u8), + .reg_cache_default = akd4613_reg, +}; + +static const struct of_device_id ipq4019_codec_id_table[] = { + { .compatible = "qca,ipq4019-codec" }, + { /* Sentinel */ } +}; +MODULE_DEVICE_TABLE(of, ipq4019_codec_id_table); + +static int ipq4019_codec_i2c_probe(struct i2c_client *i2c, + const struct i2c_device_id *id) +{ + int ret; + + ret = snd_soc_register_codec(&i2c->dev, + &ipq4019_codec, ipq4019_codec_dais, + ARRAY_SIZE(ipq4019_codec_dais)); + if (ret < 0) + pr_err("\nsnd_soc_register_codec failed (%d)\n", ret); + + return ret; +} + +static int ipq4019_codec_i2c_remove(struct i2c_client *client) +{ + snd_soc_unregister_codec(&client->dev); + return 0; +} + +static const struct of_device_id ipq4019_codec_of_match[] = { + { .compatible = "qca,ipq4019-codec" }, + {}, +}; + +static const struct i2c_device_id ipq4019_codec_i2c_id[] = { + { "qca_codec", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, ipq4019_codec_i2c_id); + +static struct i2c_driver ipq4019_codec_i2c_driver = { + .driver = { + .name = "qca_codec", + .owner = THIS_MODULE, + .of_match_table = ipq4019_codec_of_match, + }, + .probe = ipq4019_codec_i2c_probe, + .remove = ipq4019_codec_i2c_remove, + .id_table = ipq4019_codec_i2c_id, +}; + +static int ipq4019_codec_init(void) +{ + int ret; + + ret = i2c_add_driver(&ipq4019_codec_i2c_driver); + if (ret < 0) + pr_err("%s: %d: Failed to add I2C driver", __func__, __LINE__); + + return ret; +} +module_init(ipq4019_codec_init); + +static void ipq4019_codec_exit(void) +{ + i2c_del_driver(&ipq4019_codec_i2c_driver); +} +module_exit(ipq4019_codec_exit); + +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 Codec Driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-codec.h b/sound/soc/qcom/ipq4019/ipq4019-codec.h new file mode 100644 index 0000000..bf91c0f --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-codec.h @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#define AKD4613_00_PM1 0x00 +#define AKD4613_01_PM2 0x01 +#define AKD4613_02_PM3 0x02 +#define AKD4613_03_CTRL1 0x03 +#define AKD4613_04_CTRL2 0x04 +#define AKD4613_05_DE_EMP1 0x05 +#define AKD4613_06_DE_EMP2 0x06 +#define AKD4613_07_OVRFLW_DT 0x07 +#define AKD4613_08_ZERO_DT 0x08 +#define AKD4613_09_IP_CTRL 0x09 +#define AKD4613_0A_OP_CTRL 0x0A +#define AKD4613_0B_LOUT1_CTRL 0x0B +#define AKD4613_0C_ROUT1_CTRL 0x0C +#define AKD4613_0D_LOUT2_CTRL 0x0D +#define AKD4613_0E_ROUT2_CTRL 0x0E +#define AKD4613_0F_LOUT3_CTRL 0x0F +#define AKD4613_10_ROUT3_CTRL 0x10 +#define AKD4613_11_LOUT4_CTRL 0x11 +#define AKD4613_12_ROUT4_CTRL 0x12 +#define AKD4613_13_LOUT5_CTRL 0x13 +#define AKD4613_14_ROUT5_CTRL 0x14 +#define AKD4613_15_LOUT6_CTRL 0x15 +#define AKD4613_16_ROUT6_CTRL 0x16 + +#define AK4613_MAX_REG (AKD4613_16_ROUT6_CTRL + 1) + +/* AKD4613_03_CTRL1 */ +#define AKD4613_DIF_MASK (7 << 3) +#define AKD4613_DIF(x) (x << 3) +#define AKD4613_DIF_I2S_MODE (4 << 3) +#define AKD4613_TDM_MODE_MASK (3 << 6) +#define AKD4613_TDM_MODE(x) (x << 6) + +/* AKD4613_04_CTRL2 */ +#define AKD4613_CKS_MASK (0x3 << 4) +#define AKD4613_CKS(x) (x << 4) +#define AKD4613_DFS_MASK (0x3 << 2) +#define AKD4613_DFS(x) (x << 2) + +struct audio_hw_params { + uint8_t channels; + uint32_t freq; + uint8_t bit_width; +}; + +enum dfs { + NORMAL_SPEED, + DOUBLE_SPEED, + QUAD_SPEED, + NA +}; + +enum cks { + FS_128, + FS_256, + FS_384, + FS_512 +}; + +enum tdm_mode { + STEREO, + TDM_512, + TDM_256, + TDM_128, + TDM_MAX +}; + +enum dif { + DIF_LR_MODE0, + DIF_LR_MODE1, + DIF_LR_MODE2, + DIF_LR_MODE3, + DIF_I2S_MODE +}; diff --git a/sound/soc/qcom/ipq4019/ipq4019-cpu-dai.c b/sound/soc/qcom/ipq4019/ipq4019-cpu-dai.c new file mode 100644 index 0000000..8f33e91 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-cpu-dai.c @@ -0,0 +1,687 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/platform_device.h> +#include <linux/clk.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/soc.h> +#include <sound/pcm_params.h> +#include <linux/io.h> +#include <linux/delay.h> +#include <linux/of_device.h> +#include <linux/clk-provider.h> +#include <linux/clk.h> + +#include "ipq4019-mbox.h" +#include "ipq4019-adss.h" + +struct dai_priv_st { + int stereo_tx; + int stereo_rx; + int mbox_tx; + int mbox_rx; + int tx_enabled; + int rx_enabled; + struct platform_device *pdev; +}; +static struct dai_priv_st dai_priv[MAX_INTF]; + +static struct clk *audio_tx_bclk; +static struct clk *audio_tx_mclk; +static struct clk *audio_rx_bclk; +static struct clk *audio_rx_mclk; +static struct clk *audio_spdif_src; +static struct clk *audio_spdif_div2; +static struct clk *audio_spdifinfast_src; + +/* Get Stereo channel ID based on I2S intf and direction */ +int ipq4019_get_stereo_id(struct snd_pcm_substream *substream, int intf) +{ + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + return dai_priv[intf].stereo_tx; + case SNDRV_PCM_STREAM_CAPTURE: + return dai_priv[intf].stereo_rx; + } + return -EINVAL; +} +EXPORT_SYMBOL(ipq4019_get_stereo_id); + +/* Get MBOX channel ID based on I2S/TDM/SPDIF intf and direction */ +int ipq4019_get_mbox_id(struct snd_pcm_substream *substream, int intf) +{ + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + return dai_priv[intf].mbox_tx; + case SNDRV_PCM_STREAM_CAPTURE: + return dai_priv[intf].mbox_rx; + } + return -EINVAL; +} +EXPORT_SYMBOL(ipq4019_get_mbox_id); + +u32 ipq4019_get_act_bit_width(u32 bit_width) +{ + switch (bit_width) { + case SNDRV_PCM_FORMAT_S8: + case SNDRV_PCM_FORMAT_U8: + return __BIT_8; + case SNDRV_PCM_FORMAT_S16_LE: + case SNDRV_PCM_FORMAT_S16_BE: + case SNDRV_PCM_FORMAT_U16_LE: + case SNDRV_PCM_FORMAT_U16_BE: + return __BIT_16; + case SNDRV_PCM_FORMAT_S24_3LE: + case SNDRV_PCM_FORMAT_S24_3BE: + case SNDRV_PCM_FORMAT_U24_3LE: + case SNDRV_PCM_FORMAT_U24_3BE: + return __BIT_32; + case SNDRV_PCM_FORMAT_S24_LE: + case SNDRV_PCM_FORMAT_S24_BE: + case SNDRV_PCM_FORMAT_U24_LE: + case SNDRV_PCM_FORMAT_U24_BE: + return __BIT_24; + case SNDRV_PCM_FORMAT_S32_LE: + case SNDRV_PCM_FORMAT_S32_BE: + case SNDRV_PCM_FORMAT_U32_LE: + case SNDRV_PCM_FORMAT_U32_BE: + return __BIT_32; + } + return __BIT_INVAL; +} +EXPORT_SYMBOL(ipq4019_get_act_bit_width); + +static int ipq4019_audio_clk_get(struct clk **clk, struct device *dev, + const char *id) +{ + *clk = devm_clk_get(dev, id); + if (IS_ERR(*clk)) { + dev_err(dev, "%s: Error in %s\n", __func__, id); + return PTR_ERR(*clk); + } + + return 0; +} + +static int ipq4019_audio_clk_set(struct clk *clk, struct device *dev, + u32 val) +{ + int ret; + + ret = clk_set_rate(clk, val); + if (ret != 0) { + dev_err_ratelimited(dev, "Error in setting %s\n", + __clk_get_name(clk)); + return ret; + } + + ret = clk_prepare_enable(clk); + if (ret != 0) { + dev_err_ratelimited(dev, "Error in enable %s\n", + __clk_get_name(clk)); + return ret; + } + + return 0; +} + +static void ipq4019_audio_clk_disable(struct clk **clk, struct device *dev) +{ + if (__clk_is_enabled(*clk)) + clk_disable_unprepare(*clk); +} + +static int ipq4019_audio_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + u32 intf = dai->driver->id; + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + /* Check if the direction is enabled */ + if (dai_priv[intf].tx_enabled != ENABLE) + return -EFAULT; + + ipq4019_glb_tx_data_port_en(ENABLE); + ipq4019_glb_tx_framesync_port_en(ENABLE); + break; + case SNDRV_PCM_STREAM_CAPTURE: + /* Check if the direction is enabled */ + if (dai_priv[intf].rx_enabled != ENABLE) + return -EFAULT; + + ipq4019_glb_rx_data_port_en(ENABLE); + ipq4019_glb_rx_framesync_port_en(ENABLE); + break; + default: + return -EINVAL; + } + + if (intf == I2S || intf == I2S1 || intf == I2S2) { + /* Select I2S mode */ + ipq4019_glb_audio_mode(I2S, substream->stream); + } else if (intf == TDM) { + /* Select TDM mode */ + ipq4019_glb_audio_mode(TDM, substream->stream); + + /* Set TDM Ctrl register */ + ipq4019_glb_tdm_ctrl_sync_num(TDM_SYNC_NUM, substream->stream); + ipq4019_glb_tdm_ctrl_delay(TDM_DELAY, substream->stream); + } + + return 0; +} + +static int ipq4019_audio_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + u32 bit_width, channels, rate; + u32 intf = dai->driver->id; + u32 stereo_id = ipq4019_get_stereo_id(substream, intf); + u32 mbox_id = ipq4019_get_mbox_id(substream, intf); + u32 bit_act; + int ret; + u32 mclk, bclk; + struct device *dev = &(dai_priv[intf].pdev->dev); + + bit_width = params_format(params); + channels = params_channels(params); + rate = params_rate(params); + + bit_act = ipq4019_get_act_bit_width(bit_width); + + if (intf == TDM) { + /* Set TDM number of channels */ + ipq4019_glb_tdm_ctrl_ch_num((channels-1), substream->stream); + mclk = bclk = rate * bit_act * channels; + } else { + bclk = rate * bit_act * channels; + mclk = bclk * MCLK_MULTI; + } + + ipq4019_glb_clk_enable_oe(substream->stream); + + ipq4019_config_master(ENABLE, stereo_id); + + ret = ipq4019_cfg_bit_width(bit_width, stereo_id); + if (ret) { + pr_err("BitWidth %d not supported ret: %d\n", bit_width, ret); + return ret; + } + + ipq4019_stereo_config_enable(DISABLE, stereo_id); + + ipq4019_stereo_config_reset(ENABLE, stereo_id); + ipq4019_stereo_config_mic_reset(ENABLE, stereo_id); + + mdelay(5); + + ret = ipq4019_mbox_fifo_reset(mbox_id); + if (ret) { + pr_err("%s: ret: %d Error in dma fifo reset\n", + __func__, ret); + return ret; + } + + ipq4019_stereo_config_reset(DISABLE, stereo_id); + ipq4019_stereo_config_mic_reset(DISABLE, stereo_id); + ipq4019_stereo_config_enable(ENABLE, stereo_id); + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + ret = ipq4019_audio_clk_set(audio_tx_mclk, dev, mclk); + if (ret) + return ret; + + ret = ipq4019_audio_clk_set(audio_tx_bclk, dev, bclk); + if (ret) + return ret; + break; + + case SNDRV_PCM_STREAM_CAPTURE: + ret = ipq4019_audio_clk_set(audio_rx_mclk, dev, mclk); + if (ret) + return ret; + + ret = ipq4019_audio_clk_set(audio_rx_bclk, dev, bclk); + if (ret) + return ret; + break; + } + + return 0; +} + +static void ipq4019_audio_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + u32 intf = dai->driver->id; + struct device *dev = &(dai_priv[intf].pdev->dev); + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + ipq4019_glb_tx_data_port_en(DISABLE); + ipq4019_glb_tx_framesync_port_en(DISABLE); + + /* Disable the clocks */ + ipq4019_audio_clk_disable(&audio_tx_bclk, dev); + ipq4019_audio_clk_disable(&audio_tx_mclk, dev); + break; + case SNDRV_PCM_STREAM_CAPTURE: + ipq4019_glb_rx_data_port_en(DISABLE); + ipq4019_glb_rx_framesync_port_en(DISABLE); + + /* Disable the clocks */ + ipq4019_audio_clk_disable(&audio_rx_bclk, dev); + ipq4019_audio_clk_disable(&audio_rx_mclk, dev); + break; + } + + /* Disable the I2S Stereo block */ + ipq4019_stereo_config_enable(DISABLE, + ipq4019_get_stereo_id(substream, intf)); +} + +static struct snd_soc_dai_ops ipq4019_audio_ops = { + .startup = ipq4019_audio_startup, + .hw_params = ipq4019_audio_hw_params, + .shutdown = ipq4019_audio_shutdown, +}; + +static int ipq4019_spdif_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + uint32_t bit_width, channels, rate, bit_act; + int ret; + uint32_t stereo_id = ipq4019_get_stereo_id(substream, SPDIF); + uint32_t mclk, bclk; + struct device *dev = &(dai_priv[SPDIF].pdev->dev); + uint32_t spdif_bclk; + uint32_t spdif_mclk; + + bit_width = params_format(params); + channels = params_channels(params); + rate = params_rate(params); + bit_act = ipq4019_get_act_bit_width(bit_width); + + bclk = rate * bit_act * channels; + mclk = bclk * MCLK_MULTI; + + /* SPDIF subframe is always 32 bit and 2 channels */ + spdif_bclk = rate * 32 * 2; + spdif_mclk = spdif_bclk * 2; + + if (substream->stream == PLAYBACK) { + /* Set the clocks */ + ret = ipq4019_audio_clk_set(audio_tx_mclk, dev, mclk); + if (ret) + return ret; + + ret = ipq4019_audio_clk_set(audio_tx_bclk, dev, bclk); + if (ret) + return ret; + + ret = ipq4019_audio_clk_set(audio_spdif_src, dev, + spdif_mclk); + if (ret) + return ret; + + ret = ipq4019_audio_clk_set(audio_spdif_div2, dev, + spdif_bclk); + if (ret) + return ret; + + ipq4019_glb_clk_enable_oe(substream->stream); + + /* Set MASTER mode */ + ipq4019_config_master(ENABLE, stereo_id); + + /* Configure bit width */ + ret = ipq4019_cfg_bit_width(bit_width, stereo_id); + if (ret) { + pr_err("%s: BitWidth %d not supported\n", + __func__, bit_width); + return ret; + } + + } else if (substream->stream == CAPTURE) { + /* Set the clocks */ + ret = ipq4019_audio_clk_set(audio_spdifinfast_src, dev, + AUDIO_SPDIFINFAST); + if (ret) + return ret; + } + + return 0; +} + +static int ipq4019_spdif_prepare(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + dev_dbg(dai->dev, "%s:%d\n", __func__, __LINE__); + return 0; +} + +static int ipq4019_spdif_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + int ret = 0; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + /* Check if the direction is enabled */ + if (dai_priv[SPDIF].tx_enabled != ENABLE) + goto error; + + ipq4019_glb_tx_data_port_en(ENABLE); + ipq4019_glb_tx_framesync_port_en(ENABLE); + ipq4019_glb_spdif_out_en(ENABLE); + /* Select I2S/TDM */ + ipq4019_glb_audio_mode(I2S, substream->stream); + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + /* Check if the direction is enabled */ + if (dai_priv[SPDIF].rx_enabled != ENABLE) + goto error; + ipq4019_spdifin_ctrl_spdif_en(DISABLE); + + ipq4019_glb_rx_data_port_en(ENABLE); + ipq4019_glb_rx_framesync_port_en(ENABLE); + ipq4019_glb_audio_mode(I2S, substream->stream); + ipq4019_spdifin_cfg(); + } + + return ret; +error: + pr_err("%s: Direction not enabled\n", __func__); + return -EFAULT; +} + +static void ipq4019_spdif_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct device *dev = &(dai_priv[SPDIF].pdev->dev); + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + ipq4019_glb_tx_data_port_en(DISABLE); + ipq4019_glb_tx_framesync_port_en(DISABLE); + + /* Disable the clocks */ + ipq4019_audio_clk_disable(&audio_tx_bclk, dev); + ipq4019_audio_clk_disable(&audio_tx_mclk, dev); + ipq4019_audio_clk_disable(&audio_spdif_src, dev); + ipq4019_audio_clk_disable(&audio_spdif_div2, dev); + + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + ipq4019_glb_rx_data_port_en(DISABLE); + ipq4019_glb_rx_framesync_port_en(DISABLE); + + /* Disable the clocks */ + ipq4019_audio_clk_disable(&audio_spdifinfast_src, dev); + } +} + +static int ipq4019_spdif_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) +{ + dev_dbg(dai->dev, "%s:%d\n", __func__, __LINE__); + return 0; +} + +static struct snd_soc_dai_ops ipq4019_spdif_ops = { + .startup = ipq4019_spdif_startup, + .prepare = ipq4019_spdif_prepare, + .hw_params = ipq4019_spdif_hw_params, + .shutdown = ipq4019_spdif_shutdown, + .set_fmt = ipq4019_spdif_set_fmt, +}; + +static struct snd_soc_dai_driver ipq4019_cpu_dais[] = { + { + .playback = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .capture = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .ops = &ipq4019_audio_ops, + .id = I2S, + .name = "qca-i2s-dai" + }, + { + .playback = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .capture = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .ops = &ipq4019_audio_ops, + .id = TDM, + .name = "qca-tdm-dai" + }, + { + .playback = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = 2, + .channels_max = 2, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .ops = &ipq4019_audio_ops, + .id = I2S1, + .name = "qca-i2s1-dai" + }, + { + .playback = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .channels_min = 2, + .channels_max = 2, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .ops = &ipq4019_audio_ops, + .id = I2S2, + .name = "qca-i2s2-dai" + }, + { + .playback = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .capture = { + .rates = RATE_16000_96000, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + }, + .ops = &ipq4019_spdif_ops, + .id = SPDIF, + .name = "qca-spdif-dai" + }, +}; + +static const struct snd_soc_component_driver ipq4019_i2s_component = { + .name = "qca-cpu-dai", +}; + +static const struct of_device_id ipq4019_cpu_dai_id_table[] = { + { .compatible = "qca,ipq4019-i2s", .data = (void *)I2S }, + { .compatible = "qca,ipq4019-tdm", .data = (void *)TDM}, + { .compatible = "qca,ipq4019-spdif", .data = (void *)SPDIF}, + { .compatible = "qca,ipq4019-i2s1", .data = (void *)I2S1}, + { .compatible = "qca,ipq4019-i2s2", .data = (void *)I2S2}, + {}, +}; +MODULE_DEVICE_TABLE(of, ipq4019_cpu_dai_id_table); + +static int ipq4019_dai_probe(struct platform_device *pdev) +{ + const struct of_device_id *match; + struct device_node *np = pdev->dev.of_node; + int ret; + int intf; + + match = of_match_device(ipq4019_cpu_dai_id_table, &pdev->dev); + if (!match) + return -ENODEV; + + intf = (u32)match->data; + + /* TX is enabled only when both DMA and Stereo TX channel + * is specified in the DTSi + */ + if (!(of_property_read_u32(np, "dma-tx-channel", + &dai_priv[intf].mbox_tx) + || of_property_read_u32(np, "stereo-tx-port", + &dai_priv[intf].stereo_tx))) { + dai_priv[intf].tx_enabled = ENABLE; + } + + /* RX is enabled only when both DMA and Stereo RX channel + * is specified in the DTSi. + */ + if (!(of_property_read_u32(np, "dma-rx-channel", + &dai_priv[intf].mbox_rx))) { + if (intf == SPDIF) { + dai_priv[intf].rx_enabled = ENABLE; + dai_priv[intf].stereo_rx = MAX_STEREO_ENTRIES; + } else if (!(of_property_read_u32(np, "stereo-rx-port", + &dai_priv[intf].stereo_rx))) { + dai_priv[intf].rx_enabled = ENABLE; + } + } + + /* Either TX or Rx should have been enabled for a DMA/Stereo Channel */ + if (!(dai_priv[intf].tx_enabled || dai_priv[intf].rx_enabled)) { + dev_err(&pdev->dev, "%s: error reading node properties\n", + np->name); + return -EFAULT; + } + + /* Get Clks */ + audio_tx_mclk = devm_clk_get(&pdev->dev, "audio_tx_mclk"); + + if (IS_ERR(audio_tx_mclk)) { + dev_err(&pdev->dev, "Could not get tx_mclk\n"); + return PTR_ERR(audio_tx_mclk); + } + + audio_tx_bclk = devm_clk_get(&pdev->dev, "audio_tx_bclk"); + + if (IS_ERR(audio_tx_bclk)) { + dev_err(&pdev->dev, "Could not get tx_bclk\n"); + return PTR_ERR(audio_tx_bclk); + } + + if (intf == SPDIF) { + ret = ipq4019_audio_clk_get(&audio_spdif_src, &pdev->dev, + "audio_spdif_src"); + if (ret) + return ret; + + ret = ipq4019_audio_clk_get(&audio_spdif_div2, &pdev->dev, + "audio_spdif_div2"); + if (ret) + return ret; + + ret = ipq4019_audio_clk_get(&audio_spdifinfast_src, &pdev->dev, + "audio_spdifinfast_src"); + if (ret) + return ret; + } else { + audio_rx_mclk = devm_clk_get(&pdev->dev, "audio_rx_mclk"); + if (IS_ERR(audio_rx_mclk)) { + dev_err(&pdev->dev, "Could not get rx_mclk\n"); + return PTR_ERR(audio_rx_mclk); + } + + audio_rx_bclk = devm_clk_get(&pdev->dev, "audio_rx_bclk"); + if (IS_ERR(audio_rx_bclk)) { + dev_err(&pdev->dev, "Could not get rx_bclk\n"); + return PTR_ERR(audio_rx_bclk); + } + } + + dai_priv[intf].pdev = pdev; + ret = snd_soc_register_component(&pdev->dev, &ipq4019_i2s_component, + ipq4019_cpu_dais, ARRAY_SIZE(ipq4019_cpu_dais)); + if (ret) + dev_err(&pdev->dev, + "ret: %d error registering soc dais\n", ret); + + return ret; +} + +static int ipq4019_dai_remove(struct platform_device *pdev) +{ + snd_soc_unregister_component(&pdev->dev); + return 0; +} + +static struct platform_driver ipq4019_dai_driver = { + .probe = ipq4019_dai_probe, + .remove = ipq4019_dai_remove, + .driver = { + .name = "qca-cpu-dai", + .of_match_table = ipq4019_cpu_dai_id_table, + }, +}; + +module_platform_driver(ipq4019_dai_driver); + +MODULE_ALIAS("platform:qca-cpu-dai"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 CPU DAI DRIVER"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-mbox.c b/sound/soc/qcom/ipq4019/ipq4019-mbox.c new file mode 100644 index 0000000..2a3bee9 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-mbox.c @@ -0,0 +1,825 @@ +/* + * Copyright (c) 2015-2016 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include <linux/dma-mapping.h> +#include <linux/types.h> +#include <linux/module.h> +#include <linux/mm.h> +#include <linux/delay.h> +#include <sound/soc.h> + +#include "ipq4019-mbox.h" + +/* When the mailbox operation is started, the mailbox would get one descriptor + * for the current data transfer and prefetch one more descriptor. When less + * than 3 descriptors are configured, then it is possible that before the CPU + * handles the interrupt, the mailbox could check the pre fetched descriptor + * and stop the DMA transfer. + * To handle this, the design is use multiple descriptors, but they would + * point to the same buffer address. This way more number of descriptors + * would satisfy the mbox requirement, and reusing the buffer address would + * satisfy the upper layer's buffer requirement + * + * The value of 5 of repetition times was derived from trial and error testing + * for minimum number of repetitions that would result in MBOX operations + * without stopping. + */ +#define MBOX_MIN_DESC_NUM 3 +#define MBOX_DESC_REPEAT_NUM 5 + +enum { + CHN_DISABLED = 0x00, + CHN_ENABLED = 0x01, /* from dtsi */ + CHN_STARTED = 0x02, /* dma inited */ + CHN_STATUS_DISABLE = 0xFF, +}; + +static struct ipq4019_mbox_rt_priv *mbox_rtime[ADSS_MBOX_NR_CHANNELS]; + +struct ipq4019_mbox_desc + *ipq4019_mbox_get_last_played(unsigned int channel_id) +{ + struct ipq4019_mbox_desc *desc, *prev; + unsigned int ndescs, i; + uint32_t index; + uint32_t dir; + + index = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[index]) + return NULL; + + ndescs = mbox_rtime[index]->dir_priv[dir].ndescs; + /* Point to the last desc */ + prev = &mbox_rtime[index]->dir_priv[dir].dma_virt_head[ndescs - 1]; + + /* Point to the first desc */ + desc = &mbox_rtime[index]->dir_priv[dir].dma_virt_head[0]; + + for (i = 0; i < ndescs; i++) { + if (desc->OWN == 1 && prev->OWN == 0) + return desc; + prev = desc; + desc += 1; + } + + /* If we didn't find the last played buffer, return NULL */ + return NULL; +} +EXPORT_SYMBOL(ipq4019_mbox_get_last_played); + +uint32_t ipq4019_mbox_get_elapsed_size(uint32_t channel_id) +{ + struct ipq4019_mbox_desc *desc; + unsigned int i, size_played = 0; + uint32_t index; + uint32_t dir; + + index = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[index]) + return size_played; + + desc = mbox_rtime[index]->dir_priv[dir].dma_virt_head; + + for (i = 0; i < mbox_rtime[index]->dir_priv[dir].ndescs; i++) { + if (desc->OWN == 0) { + desc->OWN = 1; + desc->ei = 1; + size_played += desc->size; + } + desc += 1; + } + + return size_played; +} +EXPORT_SYMBOL(ipq4019_mbox_get_elapsed_size); + +static struct ipq4019_mbox_desc *get_next( + struct ipq4019_mbox_rt_dir_priv *rtdir, + struct ipq4019_mbox_desc *desc) +{ + struct ipq4019_mbox_desc *end; + + end = rtdir->dma_virt_head + rtdir->ndescs; + + desc++; + + if (desc >= end) + desc = rtdir->dma_virt_head; + + return desc; +} + +void ipq4019_mbox_desc_own(u32 channel_id, int desc_no, int own) +{ + struct ipq4019_mbox_desc *desc; + struct ipq4019_mbox_rt_dir_priv *rtdir; + u32 chan; + u32 dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + rtdir = &mbox_rtime[chan]->dir_priv[dir]; + + desc = rtdir->dma_virt_head; + desc += desc_no; + + rtdir->write = desc_no; + + desc->OWN = own; + desc->ei = 1; +} +EXPORT_SYMBOL(ipq4019_mbox_desc_own); + +u32 ipq4019_mbox_get_played_offset(u32 channel_id) +{ + struct ipq4019_mbox_desc *desc, *write; + struct ipq4019_mbox_rt_dir_priv *rtdir; + unsigned int i, size_played = 0; + u32 chan; + u32 dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + rtdir = &mbox_rtime[chan]->dir_priv[dir]; + + desc = rtdir->dma_virt_head; + write = &rtdir->dma_virt_head[rtdir->write]; + + desc += rtdir->read; + + for (i = 0; i < rtdir->ndescs; i++) { + if (desc->OWN == 0) { + size_played = desc->size; + rtdir->read = (rtdir->read + 1) % rtdir->ndescs; + } else { + break; + } + + if (desc != write) + break; + + desc = get_next(rtdir, desc); + } + + return size_played * rtdir->read; +} +EXPORT_SYMBOL(ipq4019_mbox_get_played_offset); + +uint32_t ipq4019_mbox_get_played_offset_set_own(u32 channel_id) +{ + struct ipq4019_mbox_desc *desc, *last_played, *prev; + struct ipq4019_mbox_rt_dir_priv *rtdir; + unsigned int i, desc_own, size_played = 0; + u32 chan, dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + rtdir = &mbox_rtime[chan]->dir_priv[dir]; + last_played = NULL; + + /* Point to the last desc */ + prev = &rtdir->dma_virt_head[rtdir->ndescs - 1]; + desc_own = prev->OWN; + + /* point to first desc */ + desc = &rtdir->dma_virt_head[0]; + + for (i = 0; i < rtdir->ndescs; i++) { + if (prev->OWN == 0) { + if (i == (rtdir->ndescs - 1)) { + if (desc_own == 1) + last_played = desc; + } else if (desc->OWN == 1) { + last_played = desc; + } + prev->OWN = 1; + prev->ei = 1; + } + prev = desc; + desc += 1; + } + if (last_played) { + desc = &rtdir->dma_virt_head[0]; + size_played = last_played->BufPtr - desc->BufPtr; + } else { + pr_debug("%s last played buf not found\n", __func__); + rtdir->last_played_is_null++; + } + + return size_played; +} +EXPORT_SYMBOL(ipq4019_mbox_get_played_offset_set_own); + +int ipq4019_mbox_fifo_reset(int channel_id) +{ + void __iomem *mbox_reg; + u32 chan, dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + + switch (dir) { + case PLAYBACK: + writel(MBOX_FIFO_RESET_TX_INIT, + mbox_reg + ADSS_MBOXn_MBOX_FIFO_RESET_REG); + break; + case CAPTURE: + writel(MBOX_FIFO_RESET_RX_INIT, + mbox_reg + ADSS_MBOXn_MBOX_FIFO_RESET_REG); + break; + } + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_fifo_reset); + +int ipq4019_mbox_dma_start(int channel_id) +{ + void __iomem *mbox_reg; + u32 chan, dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + mbox_rtime[index]->mbox_started = 1; + + switch (dir) { + case PLAYBACK: + writel(ADSS_MBOXn_DMA_RX_CONTROL_START, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_RX_CONTROL_REG); + break; + + case CAPTURE: + writel(ADSS_MBOXn_DMA_TX_CONTROL_START, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_TX_CONTROL_REG); + break; + } + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_start); + +int ipq4019_mbox_dma_resume(int channel_id) +{ + void __iomem *mbox_reg; + u32 chan, dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + if (!mbox_rtime[index]->mbox_started) + return 0; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + + switch (dir) { + case PLAYBACK: + writel(ADSS_MBOXn_DMA_RX_CONTROL_RESUME, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_RX_CONTROL_REG); + break; + + case CAPTURE: + writel(ADSS_MBOXn_DMA_TX_CONTROL_RESUME, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_TX_CONTROL_REG); + break; + } + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_resume); + +int ipq4019_mbox_dma_stop(int channel_id, u32 delay_in_ms) +{ + void __iomem *mbox_reg; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + u32 chan, dir; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + mbox_rtime[index]->mbox_started = 0; + + switch (dir) { + case PLAYBACK: + writel(ADSS_MBOXn_DMA_RX_CONTROL_STOP, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_RX_CONTROL_REG); + break; + + case CAPTURE: + writel(ADSS_MBOXn_DMA_TX_CONTROL_STOP, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_TX_CONTROL_REG); + break; + } + + /* + * Per the documentation: + * ______________________________________________________ + * Programming a one to this bit causes the DMA engine to + * stop transferring any more data from this descriptor + * chain. If a transfer is already in progress DMA enters + * a stop state after completing the current descriptor + * ______________________________________________________ + */ + mdelay(delay_in_ms); + + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + mbox_cb->read = 0; + mbox_cb->write = 0; + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_stop); + +static bool ipq4019_is_other_chn_active(u32 chan, u32 dir) +{ + if (dir == PLAYBACK) + return (test_bit(CHN_STARTED, + &mbox_rtime[chan]->dir_priv[CAPTURE].status)); + else + return (test_bit(CHN_STARTED, + &mbox_rtime[chan]->dir_priv[PLAYBACK].status)); +} + +int ipq4019_mbox_dma_reset_swap(int channel_id) +{ + unsigned int val; + void __iomem *mbox_reg; + u32 chan; + + chan = ipq4019_convert_id_to_channel(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + + val = readl(mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + val &= ~(MBOX_DMA_POLICY_RXD_END_SWAP | MBOX_DMA_POLICY_RXD_16BIT_SWAP); + + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_reset_swap); + +int ipq4019_mbox_dma_swap(int channel_id, snd_pcm_format_t format) +{ + unsigned int val; + void __iomem *mbox_reg; + u32 chan; + + chan = ipq4019_convert_id_to_channel(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + + val = readl(mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + switch (format) { + case SNDRV_PCM_FORMAT_S16_LE: + case SNDRV_PCM_FORMAT_S16_BE: + val |= MBOX_DMA_POLICY_RXD_16BIT_SWAP; + break; + case SNDRV_PCM_FORMAT_S24_3LE: + case SNDRV_PCM_FORMAT_S24_3BE: + val |= MBOX_DMA_POLICY_RXD_END_SWAP; + break; + default: + /* Nothing to do */ + break; + } + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_swap); + +static void ipq4019_mbox_intr_en(void __iomem *mbox_reg, unsigned int mask) +{ + unsigned int val; + + val = readl(mbox_reg + ADSS_MBOXn_MBOX_INT_ENABLE_REG); + val |= mask; + writel(val, mbox_reg + ADSS_MBOXn_MBOX_INT_ENABLE_REG); +} + +static void ipq4019_mbox_intr_disable(void __iomem *mbox_reg, unsigned int mask) +{ + unsigned int val; + + val = readl(mbox_reg + ADSS_MBOXn_MBOX_INT_ENABLE_REG); + val &= ~mask; + writel(val, mbox_reg + ADSS_MBOXn_MBOX_INT_ENABLE_REG); +} + +int ipq4019_mbox_dma_prepare(int channel_id) +{ + struct ipq4019_mbox_desc *desc; + unsigned int val; + void __iomem *mbox_reg; + dma_addr_t phys_addr; + u32 chan, dir; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_reg = mbox_rtime[chan]->mbox_reg_base; + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + + /* do not reset DMA registers if the other direction is active */ + if (!ipq4019_is_other_chn_active(chan, dir)) { + + val = readl(mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + val |= MBOX_DMA_POLICY_SW_RESET; + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + val &= ~MBOX_DMA_POLICY_SW_RESET; + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + } + + desc = mbox_cb->dma_virt_head; + phys_addr = mbox_cb->dma_phys_head; + val = readl(mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + + if (dir == PLAYBACK) { + /* Request the DMA channel to the controller */ + val |= MBOX_DMA_POLICY_RX_INT_TYPE; + + /* The direction is indicated from the DMA engine perspective + * i.e. we'll be using the RX registers for Playback and + * the TX registers for capture + */ + + val |= ADSS_MBOX_DMA_POLICY_SRAM_AC(phys_addr); + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + writel(phys_addr & MBOX_DMA_MASK, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_RX_DESCRIPTOR_BASE_REG); + ipq4019_mbox_intr_en(mbox_reg, MBOX_INT_ENABLE_RX_DMA_COMPLETE); + } else { + + val |= MBOX_DMA_POLICY_TX_INT_TYPE | + ADSS_MBOX_DMA_POLICY_TX_FIFO_THRESHOLD(6); + val |= ADSS_MBOX_DMA_POLICY_SRAM_AC(phys_addr); + writel(val, mbox_reg + ADSS_MBOXn_MBOX_DMA_POLICY_REG); + writel(phys_addr & MBOX_DMA_MASK, + mbox_reg + ADSS_MBOXn_MBOXn_DMA_TX_DESCRIPTOR_BASE_REG); + ipq4019_mbox_intr_en(mbox_reg, MBOX_INT_ENABLE_TX_DMA_COMPLETE); + } + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_prepare); + +void ipq4019_mbox_vuc_setup(int channel_id) +{ + uint32_t index, dir; + struct ipq4019_mbox_desc *desc; + int ndescs; + int i; + + index = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + ndescs = mbox_rtime[index]->dir_priv[dir].ndescs; + desc = mbox_rtime[index]->dir_priv[dir].dma_virt_head; + + /* Copy VUC from previous descriptors */ + for (i = 0; i < ndescs; i++) { + /* Setup V bits as 1, Acc to IEC 60958-3 Standard + * for non PCM data, we need to set invalid for + * both channels + * There are 6 DWORDS (192 bits) for Channel A + * and 6 DWORDS (192 bits) for channel B + */ + desc[i].vuc_dword[CHANNEL_A_VDWORD_1] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_A_VDWORD_2] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_A_VDWORD_3] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_A_VDWORD_4] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_A_VDWORD_5] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_A_VDWORD_6] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_1] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_2] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_3] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_4] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_5] = ADSS_MBOX_INVALID_PCM; + desc[i].vuc_dword[CHANNEL_B_VDWORD_6] = ADSS_MBOX_INVALID_PCM; + + /* Now setup C bits, acc to IEC-60958-3 */ + desc[i].vuc_dword[CHANNEL_A_CDWORD_1] = SPDIF_CONSUMER_COMPRESD; + desc[i].vuc_dword[CHANNEL_B_CDWORD_2] = SPDIF_CONSUMER_COMPRESD; + } +} +EXPORT_SYMBOL(ipq4019_mbox_vuc_setup); + +int ipq4019_mbox_form_ring(int channel_id, dma_addr_t baseaddr, u8 *area, + int period_bytes, int bufsize, int own_bit) +{ + struct ipq4019_mbox_desc *desc, *_desc_p; + dma_addr_t desc_p, baseaddr_const; + unsigned int i, ndescs; + u32 chan, dir; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + ndescs = DIV_ROUND_UP(bufsize, period_bytes); + + if (ndescs < MBOX_MIN_DESC_NUM) + ndescs *= MBOX_DESC_REPEAT_NUM; + + desc = (struct ipq4019_mbox_desc *)(area + (ndescs * period_bytes)); + desc_p = baseaddr + (ndescs * period_bytes); + + memset(desc, 0, ndescs * sizeof(struct ipq4019_mbox_desc)); + + mbox_cb->read = 0; + mbox_cb->write = 0; + mbox_cb->ndescs = ndescs; + mbox_cb->dma_virt_head = desc; + mbox_cb->dma_phys_head = desc_p; + _desc_p = (struct ipq4019_mbox_desc *)desc_p; + + baseaddr_const = baseaddr; + + for (i = 0; i < ndescs; i++, desc++) { + desc->OWN = own_bit; + desc->ei = 1; + desc->BufPtr = baseaddr & MBOX_DMA_MASK; + desc->NextPtr = (unsigned long)&_desc_p[(i + 1) % ndescs]; + desc->size = period_bytes; + desc->length = desc->size; + baseaddr += ALIGN(period_bytes, L1_CACHE_BYTES); + if (baseaddr >= (baseaddr_const + bufsize)) { + if (bufsize % period_bytes) + desc->size = bufsize % period_bytes; + else + desc->size = period_bytes; + + baseaddr = baseaddr_const; + } + } + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_form_ring); + +int ipq4019_mbox_dma_release(int channel_id) +{ + u32 chan, dir; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + + if (test_bit(CHN_STARTED, &mbox_cb->status)) { + ipq4019_mbox_intr_disable(mbox_rtime[chan]->mbox_reg_base, + (MBOX_INT_ENABLE_TX_DMA_COMPLETE | + MBOX_INT_ENABLE_RX_DMA_COMPLETE)); + /* + * ALSA framework calls ipq4019_mbox_dma_stop() before + * calling close API. + */ + mbox_cb->dma_virt_head = NULL; + + clear_bit(CHN_STARTED, &mbox_cb->status); + return 0; + } + + return -ENXIO; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_release); + +static void irq_proc_status(struct ipq4019_mbox_rt_dir_priv *priv, int irq, + u32 status, int cb, int stats, u32 *mask, u32 bit) +{ + if (status & bit) { + *mask |= bit; + if (cb && priv->callback) + priv->callback(irq, priv->dai_priv); + + if (stats) + priv->err_stats++; + } +} + +static irqreturn_t ipq4019_mbox_dma_irq(int irq, void *dev_id) +{ + unsigned int status, mask = 0; + struct ipq4019_mbox_rt_priv *curr_rtime = dev_id; + void __iomem *mbox_reg = curr_rtime->mbox_reg_base; + struct ipq4019_mbox_rt_dir_priv *p = &curr_rtime->dir_priv[PLAYBACK]; + struct ipq4019_mbox_rt_dir_priv *c = &curr_rtime->dir_priv[CAPTURE]; + + status = readl(mbox_reg + ADSS_MBOXn_MBOX_INT_STATUS_REG); + + irq_proc_status(p, irq, status, 1, 0, &mask, + MBOX_INT_STATUS_RX_DMA_COMPLETE); + irq_proc_status(c, irq, status, 1, 0, &mask, + MBOX_INT_STATUS_TX_DMA_COMPLETE); + irq_proc_status(p, irq, status, 0, 1, &mask, + MBOX_INT_STATUS_RX_UNDERFLOW); + irq_proc_status(p, irq, status, 0, 1, &mask, + MBOX_INT_STATUS_RX_FIFO_UNDERFLOW); + irq_proc_status(c, irq, status, 0, 1, &mask, + MBOX_INT_STATUS_TX_OVERFLOW); + irq_proc_status(c, irq, status, 0, 1, &mask, + MBOX_INT_STATUS_TX_FIFO_OVERFLOW); + + if (mask) { + writel(status & ~mask, + mbox_reg + ADSS_MBOXn_MBOX_INT_STATUS_REG); + return IRQ_HANDLED; + } + + return IRQ_NONE; +} + +int ipq4019_mbox_dma_deinit(u32 channel_id) +{ + u32 chan, dir; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + if (test_bit(CHN_STARTED, &mbox_cb->status)) + clear_bit(CHN_STARTED, &mbox_cb->status); + + mbox_cb->dai_priv = NULL; + mbox_cb->callback = NULL; + mbox_cb->dev = NULL; + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_deinit); + +int ipq4019_mbox_dma_init(struct device *dev, int channel_id, + irq_handler_t callback, void *private_data) +{ + u32 chan; + u32 dir; + struct ipq4019_mbox_rt_dir_priv *mbox_cb; + + chan = ipq4019_convert_id_to_channel(channel_id); + dir = ipq4019_convert_id_to_dir(channel_id); + + if (chan >= ADSS_MBOX_NR_CHANNELS) + return -EINVAL; + + if (!mbox_rtime[chan]) + return -EINVAL; + + mbox_cb = &mbox_rtime[chan]->dir_priv[dir]; + + if (!(mbox_cb->status & CHN_ENABLED)) + return -EINVAL; + + if (test_and_set_bit(CHN_STARTED, &mbox_cb->status)) + return -EBUSY; + + mbox_cb->dai_priv = private_data; + mbox_cb->callback = callback; + mbox_cb->dev = dev; + + return 0; +} +EXPORT_SYMBOL(ipq4019_mbox_dma_init); + +static int ipq4019_mbox_probe(struct platform_device *pdev) +{ + struct device_node *np; + int irq; + u32 tx_channel; + u32 rx_channel; + u32 id; + void __iomem *reg_base; + struct resource *res; + int rc; + + np = pdev->dev.of_node; + + if (of_property_read_u32(np, "dma-index", &id)) { + dev_err(&pdev->dev, + "unable to read (dma-index) from device node %s\n", + np->name); + return -EINVAL; + } + + if (id >= ADSS_MBOX_NR_CHANNELS) + return -EINVAL; + + if (of_property_read_u32(np, "tx-channel", &tx_channel)) + tx_channel = CHN_STATUS_DISABLE; + + if (of_property_read_u32(np, "rx-channel", &rx_channel)) + rx_channel = CHN_STATUS_DISABLE; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) { + dev_err(&pdev->dev, "%s: %d: Error getting mbox resource\n", + __func__, __LINE__); + return -EINVAL; + } + + /* + * Read interrupt and store + */ + irq = platform_get_irq(pdev, 0); + if (irq < 0) { + dev_err(&pdev->dev, "%s: MBOX %d IRQ %d is not provided\n", + __func__, id, irq); + return irq; + } + + reg_base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(reg_base)) + return PTR_ERR(reg_base); + + mbox_rtime[id] = devm_kzalloc(&pdev->dev, + sizeof(struct ipq4019_mbox_rt_priv), GFP_KERNEL); + if (!mbox_rtime[id]) + return -ENOMEM; + + rc = devm_request_irq(&pdev->dev, irq, ipq4019_mbox_dma_irq, 0, + "ipq4019-mbox", mbox_rtime[id]); + if (rc) { + dev_err(&pdev->dev, "request_irq() failed with ret: %d\n", rc); + return rc; + } + + mbox_rtime[id]->mbox_reg_base = reg_base; + mbox_rtime[id]->dir_priv[PLAYBACK].channel_id = tx_channel; + mbox_rtime[id]->dir_priv[CAPTURE].channel_id = rx_channel; + mbox_rtime[id]->dir_priv[PLAYBACK].status = + (tx_channel == CHN_STATUS_DISABLE) ? CHN_DISABLED : CHN_ENABLED; + mbox_rtime[id]->dir_priv[CAPTURE].status = + (rx_channel == CHN_STATUS_DISABLE) ? CHN_DISABLED : CHN_ENABLED; + mbox_rtime[id]->irq_no = irq; + + return 0; +} + +static const struct of_device_id ipq4019_mbox_table[] = { + { .compatible = "qca,ipq4019-mbox" }, + {}, +}; + +static struct platform_driver ipq4019_mbox_driver = { + .probe = ipq4019_mbox_probe, + .driver = { + .name = "ipq4019-mbox", + .of_match_table = ipq4019_mbox_table, + }, +}; + +module_platform_driver(ipq4019_mbox_driver); + +MODULE_ALIAS("platform:ipq4019-mbox"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 MBOX DRIVER"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-mbox.h b/sound/soc/qcom/ipq4019/ipq4019-mbox.h new file mode 100644 index 0000000..f2e5ede --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-mbox.h @@ -0,0 +1,146 @@ +/* + * Copyright (c) 2015-2016 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _IPQ4019_MBOX_H_ +#define _IPQ4019_MBOX_H_ + +#include "ipq4019-adss.h" + +#define ADSS_MBOX_INVALID_PCM (0xFFFFFFFF) +#define ADSS_MBOX_REG_BASE (0x7700000 + 0x6000) +#define ADSS_MBOX_RANGE (0xFA000) +#define ADSS_MBOX_SPDIF_IRQ (163 + 32) +#define ADSS_MBOX0_IRQ (156 + 32) +#define ADSS_MBOX1_IRQ (157 + 32) +#define ADSS_MBOX2_IRQ (158 + 32) +#define ADSS_MBOX3_IRQ (159 + 32) + +#define CHANNEL_A_VDWORD_START 0 +#define CHANNEL_B_VDWORD_START 18 + +#define CHANNEL_A_VDWORD_1 (CHANNEL_A_VDWORD_START + 0) +#define CHANNEL_A_VDWORD_2 (CHANNEL_A_VDWORD_START + 1) +#define CHANNEL_A_VDWORD_3 (CHANNEL_A_VDWORD_START + 2) +#define CHANNEL_A_VDWORD_4 (CHANNEL_A_VDWORD_START + 3) +#define CHANNEL_A_VDWORD_5 (CHANNEL_A_VDWORD_START + 4) +#define CHANNEL_A_VDWORD_6 (CHANNEL_A_VDWORD_START + 5) + +#define CHANNEL_B_VDWORD_1 (CHANNEL_B_VDWORD_START + 0) +#define CHANNEL_B_VDWORD_2 (CHANNEL_B_VDWORD_START + 1) +#define CHANNEL_B_VDWORD_3 (CHANNEL_B_VDWORD_START + 2) +#define CHANNEL_B_VDWORD_4 (CHANNEL_B_VDWORD_START + 3) +#define CHANNEL_B_VDWORD_5 (CHANNEL_B_VDWORD_START + 4) +#define CHANNEL_B_VDWORD_6 (CHANNEL_B_VDWORD_START + 5) + +#define CHANNEL_A_CDWORD_START 12 +#define CHANNEL_B_CDWORD_START 30 + +#define CHANNEL_A_CDWORD_1 (CHANNEL_A_CDWORD_START + 0) +#define CHANNEL_B_CDWORD_2 (CHANNEL_B_CDWORD_START + 0) + +/* Acc to IEC 60958-3, bit 0.0 = 0 is consumer + * bit 0.1 = 1is compressed playback + * bit 3.0 = 1 is sampling freq No specified + */ +#define SPDIF_CONSUMER_COMPRESD 0x01000006 +#define MBOX_MIN_DESC_NUM 3 +#define MBOX_DESC_REPEAT_NUM 5 + +enum { + ADSS_MBOX_NR_CHANNELS = 5, +}; + +struct ipq4019_mbox_desc { + unsigned int length : 12, /* bit 11-00 */ + size : 12, /* bit 23-12 */ + vuc : 1, /* bit 24 */ + ei : 1, /* bit 25 */ + rsvd1 : 4, /* bit 29-26 */ + EOM : 1, /* bit 30 */ + OWN : 1, /* bit 31 */ + BufPtr : 28, /* bit 27-00 */ + rsvd2 : 4, /* bit 31-28 */ + NextPtr : 28, /* bit 27-00 */ + rsvd3 : 4; /* bit 31-28 */ + + unsigned int vuc_dword[36]; +}; + +#define MBOX_DMA_MASK DMA_BIT_MASK(28) + +struct ipq4019_mbox_rt_dir_priv { + /* Desc array in virtual space */ + struct ipq4019_mbox_desc *dma_virt_head; + + /* Desc array for DMA */ + dma_addr_t dma_phys_head; + struct device *dev; + unsigned int ndescs; + irq_handler_t callback; + void *dai_priv; + unsigned long status; + u32 channel_id; + u32 err_stats; + u32 last_played_is_null; + u32 write; + u32 read; +}; + +struct ipq4019_mbox_rt_priv { + int irq_no; + void __iomem *mbox_reg_base; + struct ipq4019_mbox_rt_dir_priv dir_priv[2]; + int mbox_started; +}; + +/* Replaces struct ath_i2s_softc */ +struct ipq4019_pcm_pltfm_priv { + struct snd_pcm_substream *playback; + struct snd_pcm_substream *capture; +}; + +int ipq4019_mbox_fifo_reset(int channel_id); +int ipq4019_mbox_dma_start(int channel_id); +int ipq4019_mbox_dma_stop(int channel_id, u32 delay_in_ms); +int ipq4019_mbox_dma_reset_swap(int channel_id); +int ipq4019_mbox_dma_swap(int channel_id, snd_pcm_format_t format); +int ipq4019_mbox_dma_prepare(int channel_id); +int ipq4019_mbox_dma_resume(int channel_id); +int ipq4019_mbox_form_ring(int channel_id, dma_addr_t baseaddr, u8 *base, + int period_bytes, int bufsize, int own_bit); +int ipq4019_mbox_dma_release(int channel); +int ipq4019_mbox_dma_init(struct device *dev, int channel_id, + irq_handler_t callback, void *private_data); +void ipq4019_mbox_vuc_setup(int channel_id); +u32 ipq4019_mbox_get_played_offset(u32 channel_id); +int ipq4019_mbox_dma_deinit(u32 channel_id); +void ipq4019_mbox_desc_own(u32 channel_id, int desc_no, int own); +struct ipq4019_mbox_desc *ipq4019_mbox_get_last_played(unsigned int channel_id); +uint32_t ipq4019_mbox_get_elapsed_size(uint32_t channel_id); +void ipq4019_mbox_vuc_setup(int channel_id); +uint32_t ipq4019_mbox_get_played_offset_set_own(u32 channel_id); + +static inline u32 ipq4019_convert_id_to_channel(u32 id) +{ + return (id / 2); +} + +static inline u32 ipq4019_convert_id_to_dir(u32 id) +{ + return (id % 2); +} + +#endif /* _IPQ40XX_MBOX_H_ */ diff --git a/sound/soc/qcom/ipq4019/ipq4019-pcm-i2s.c b/sound/soc/qcom/ipq4019/ipq4019-pcm-i2s.c new file mode 100644 index 0000000..e93d999 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-pcm-i2s.c @@ -0,0 +1,609 @@ +/* + * Copyright (c) 2015-2016 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/time.h> +#include <linux/wait.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/dma-mapping.h> +#include <asm/dma.h> +#include <sound/core.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/pcm.h> +#include <sound/initval.h> +#include <sound/control.h> +#include <sound/pcm_params.h> + +#include "ipq4019-adss.h" +#include "ipq4019-pcm.h" + +static struct snd_pcm_hardware ipq4019_pcm_hardware_playback = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_PAUSE | + SNDRV_PCM_INFO_RESUME, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .buffer_bytes_max = IPQ4019_I2S_BUFF_SIZE, + .period_bytes_max = IPQ4019_I2S_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_I2S_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_I2S_NO_OF_PERIODS, + .periods_max = IPQ4019_I2S_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static struct snd_pcm_hardware ipq4019_pcm_hardware_capture = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .buffer_bytes_max = IPQ4019_I2S_BUFF_SIZE, + .period_bytes_max = IPQ4019_I2S_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_I2S_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_I2S_NO_OF_PERIODS, + .periods_max = IPQ4019_I2S_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static size_t ip4019_dma_buffer_size(struct snd_pcm_hardware *pcm_hw) +{ + return (pcm_hw->buffer_bytes_max + + (pcm_hw->periods_min * sizeof(struct ipq4019_mbox_desc))); +} + +static struct device *ss2dev(struct snd_pcm_substream *substream) +{ + return substream->pcm->card->dev; +} + +/* + * The MBOX descriptors and buffers should lie within the same 256MB + * region. Because, the buffer address pointer (in the descriptor structure) + * and descriptor base address pointer register share the same MSB 4 bits + * which is configured in MBOX DMA Policy register. + * + * Hence ensure that the entire allocated region falls in a 256MB region. + */ +static int ipq4019_mbox_buf_is_aligned(void *c_ptr, ssize_t size) +{ + u32 ptr = (u32)c_ptr; + + return (ptr & 0xF0000000) == ((ptr + size - 1) & 0xF0000000); +} + +static int ipq4019_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, + int stream) +{ + struct snd_pcm_substream *substream = pcm->streams[stream].substream; + struct snd_pcm_hardware *pcm_hw = NULL; + struct snd_dma_buffer *buf = &substream->dma_buffer; + size_t size; + u8 *area; + dma_addr_t addr; + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + pcm_hw = &ipq4019_pcm_hardware_playback; + break; + case SNDRV_PCM_STREAM_CAPTURE: + pcm_hw = &ipq4019_pcm_hardware_capture; + break; + default: + dev_err(ss2dev(substream), "Invalid stream: %d\n", + substream->stream); + return -EINVAL; + } + + size = ip4019_dma_buffer_size(pcm_hw); + buf->dev.type = SNDRV_DMA_TYPE_DEV; + buf->dev.dev = pcm->card->dev; + buf->private_data = NULL; + + /* + * |<-- buffers -->|<-- desc -->| + * +----+----+----+----+----+----+-+-+-+-+-+-+-+ + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * +----+----+----+----+----+----+-+-+-+-+-+-+-+ + * ^ ^ | | . . . + * | | | | + * +----|------------------------+ | + * +--------------------------+ + */ + + /* + * Currently payload uses uncached memory. + * TODO: Eventually we will move to cached memory for payload + * and dma_map_single() will be used for Invalidating/Flushing + * the buffers. + */ + + area = dma_alloc_coherent(pcm->card->dev, size, &addr, GFP_KERNEL); + + if (!area) { + dev_info(ss2dev(substream), "Alloc coherent memory failed\n"); + return -ENOMEM; + } + + if (!ipq4019_mbox_buf_is_aligned(area, size)) { + dev_info(ss2dev(substream), + "First allocation %p not within 256M region\n", area); + + buf->area = dma_alloc_coherent(pcm->card->dev, size, + &buf->addr, GFP_KERNEL); + /* + * If we are here, the previously allocated buffer is not + * usable for the driver. Have to free it anyway regardless + * of the success/failure of the second allocation. + */ + dma_free_coherent(pcm->card->dev, size, area, addr); + if (!buf->area) { + dev_info(ss2dev(substream), + "Second Alloc coherent memory failed\n"); + return -ENOMEM; + } + } else { + buf->area = area; + buf->addr = addr; + } + + buf->bytes = pcm_hw->buffer_bytes_max; + + return 0; +} + +static void ipq4019_pcm_free_dma_buffer(struct snd_pcm *pcm, int stream) +{ + struct snd_pcm_substream *substream; + struct snd_pcm_hardware *pcm_hw = NULL; + struct snd_dma_buffer *buf; + size_t size; + + substream = pcm->streams[stream].substream; + buf = &substream->dma_buffer; + + switch (stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + pcm_hw = &ipq4019_pcm_hardware_playback; + break; + case SNDRV_PCM_STREAM_CAPTURE: + pcm_hw = &ipq4019_pcm_hardware_capture; + break; + default: + dev_err(ss2dev(substream), "Invalid stream: %d\n", + substream->stream); + return; + } + + size = ip4019_dma_buffer_size(pcm_hw); + + dma_free_coherent(pcm->card->dev, size, buf->area, buf->addr); + + buf->addr = 0; + buf->area = NULL; + +} + +static irqreturn_t ipq4019_pcm_irq(int intrsrc, void *data) +{ + struct snd_pcm_substream *substream = data; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + + if (pcm_rtpriv->mmap_flag) + pcm_rtpriv->curr_pos = + ipq4019_mbox_get_played_offset_set_own( + pcm_rtpriv->channel); + else + pcm_rtpriv->curr_pos = + ipq4019_mbox_get_played_offset(pcm_rtpriv->channel); + + snd_pcm_period_elapsed(substream); + + return IRQ_HANDLED; +} + +static snd_pcm_uframes_t ipq4019_pcm_i2s_pointer( + struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + + return bytes_to_frames(runtime, pcm_rtpriv->curr_pos); +} + +static int ipq4019_pcm_i2s_copy(struct snd_pcm_substream *substream, int chan, + snd_pcm_uframes_t hwoff, void __user *ubuf, + snd_pcm_uframes_t frames) +{ + struct snd_dma_buffer *buf = &substream->dma_buffer; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + char *hwbuf; + u32 offset, size; + + offset = frames_to_bytes(runtime, hwoff); + size = frames_to_bytes(runtime, frames); + + hwbuf = buf->area + offset; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + if (copy_from_user(hwbuf, ubuf, size)) + return -EFAULT; + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + if (copy_to_user(ubuf, hwbuf, size)) + return -EFAULT; + } + + ipq4019_mbox_desc_own(pcm_rtpriv->channel, offset / size, 1); + + ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + + return 0; +} + +static int ipq4019_pcm_i2s_mmap(struct snd_pcm_substream *substream, + struct vm_area_struct *vma) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + + pcm_rtpriv->mmap_flag = 1; + + return dma_mmap_coherent(substream->pcm->card->dev, vma, + runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); +} + +static int ipq4019_pcm_hw_free(struct snd_pcm_substream *substream) +{ + snd_pcm_set_runtime_buffer(substream, NULL); + return 0; +} + + +static int ipq4019_pcm_i2s_prepare(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + u32 ret; + + ret = ipq4019_mbox_dma_prepare(pcm_rtpriv->channel); + if (ret) { + dev_err(ss2dev(substream), + "Error in dma prepare: channel: %d ret: %d\n", + pcm_rtpriv->channel, ret); + return ret; + } + + pcm_rtpriv->last_played = NULL; + + return 0; +} + +static int ipq4019_pcm_i2s_close(struct snd_pcm_substream *substream) +{ + struct ipq4019_pcm_rt_priv *pcm_rtpriv = + substream->runtime->private_data; + u32 ret; + + pcm_rtpriv->mmap_flag = 0; + + ret = ipq4019_mbox_dma_release(pcm_rtpriv->channel); + if (ret) + dev_err(ss2dev(substream), + "Error in dma release. ret: %d\n", ret); + + kfree(pcm_rtpriv); + + return 0; +} + +static int ipq4019_pcm_i2s_trigger(struct snd_pcm_substream *substream, int cmd) +{ + int ret; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + u32 desc_duration; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + ret = ipq4019_mbox_dma_start(pcm_rtpriv->channel); + if (ret) { + dev_err(ss2dev(substream), + "Error in dma start. ret: %d\n", ret); + } + break; + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + ret = ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + if (ret) { + dev_err(ss2dev(substream), + "Error in dma resume. ret: %d\n", ret); + } + break; + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + /* + * For e.g. the number of bytes needed to represent 1 second + * worth of audio data for sampling frequency, bit width, stereo + * combination of 16KHz, 32-bits and stereo, the calculation is + * as follows + * + * For 1 second, + * 16KHz * 32 bits * 2 (left & right channel of stereo) + * = 16000 * 4 bytes * 2 + * = 128000 bytes + * + * Hence the duration will be + * desc_buffer_size_in_bytes / 128000 * 1 sec + */ + desc_duration = + frames_to_bytes(runtime, runtime->period_size) * 1000 / + (runtime->rate * + DIV_ROUND_UP(runtime->sample_bits, 8) * + runtime->channels); + + dev_dbg(ss2dev(substream), + "period_size:%u rate:%u sample_bits:%u channels:%u desc_delay:%u\n", + frames_to_bytes(runtime, runtime->period_size), + runtime->rate, runtime->sample_bits, runtime->channels, + desc_duration); + + ret = ipq4019_mbox_dma_stop(pcm_rtpriv->channel, desc_duration); + if (ret) { + dev_err(ss2dev(substream), + "Error in dma stop. ret: %d\n", ret); + } + break; + default: + ret = -EINVAL; + break; + } + return ret; +} + +static int ipq4019_pcm_i2s_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + int ret; + unsigned int period_size, sample_size, sample_rate, frames, channels; + + ret = ipq4019_mbox_form_ring(pcm_rtpriv->channel, + substream->dma_buffer.addr, + substream->dma_buffer.area, + params_period_bytes(hw_params), + params_buffer_bytes(hw_params), + (substream->stream == SNDRV_PCM_STREAM_CAPTURE)); + if (ret) { + dev_dbg(ss2dev(substream), + "Error dma form ring ret: %d\n", ret); + return ret; + } + + period_size = params_period_bytes(hw_params); + sample_size = snd_pcm_format_size(params_format(hw_params), 1); + sample_rate = params_rate(hw_params); + channels = params_channels(hw_params); + frames = period_size / (sample_size * channels); + + pcm_rtpriv->period_size = params_period_bytes(hw_params); + + snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer); + + runtime->dma_bytes = params_buffer_bytes(hw_params); + return 0; +} + +static int ipq4019_pcm_i2s_open(struct snd_pcm_substream *substream) +{ + int ret; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_dai *dai = rtd->cpu_dai; + u32 intf = dai->driver->id; + + pcm_rtpriv = kmalloc(sizeof(struct ipq4019_pcm_rt_priv), GFP_KERNEL); + if (!pcm_rtpriv) + return -ENOMEM; + + dev_dbg(ss2dev(substream), "%s: 0x%xB allocated at 0x%08x\n", + __func__, sizeof(*pcm_rtpriv), (u32) pcm_rtpriv); + pcm_rtpriv->last_played = NULL; + pcm_rtpriv->dev = substream->pcm->card->dev; + pcm_rtpriv->channel = ipq4019_get_mbox_id(substream, intf); + pcm_rtpriv->curr_pos = 0; + pcm_rtpriv->mmap_flag = 0; + substream->runtime->private_data = pcm_rtpriv; + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + runtime->dma_bytes = + ipq4019_pcm_hardware_playback.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_playback); + break; + case SNDRV_PCM_STREAM_CAPTURE: + runtime->dma_bytes = + ipq4019_pcm_hardware_capture.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_capture); + break; + default: + dev_err(ss2dev(substream), "Invalid stream: %d\n", + substream->stream); + ret = -EINVAL; + goto error; + } + + ret = ipq4019_mbox_dma_init(pcm_rtpriv->dev, + pcm_rtpriv->channel, ipq4019_pcm_irq, substream); + if (ret) { + dev_err(ss2dev(substream), + "Error initializing dma. ret: %d\n", ret); + goto error; + } + + ret = snd_pcm_hw_constraint_integer(runtime, + SNDRV_PCM_HW_PARAM_PERIODS); + if (ret < 0) { + dev_err(ss2dev(substream), + "snd_pcm_hw_constraint_integer failed ret: %d\n", + ret); + goto error_hw_const; + } + + return 0; +error_hw_const: + ipq4019_mbox_dma_deinit(pcm_rtpriv->channel); +error: + kfree(pcm_rtpriv); + return ret; +} + +static struct snd_pcm_ops ipq4019_asoc_pcm_i2s_ops = { + .open = ipq4019_pcm_i2s_open, + .hw_params = ipq4019_pcm_i2s_hw_params, + .hw_free = ipq4019_pcm_hw_free, + .trigger = ipq4019_pcm_i2s_trigger, + .ioctl = snd_pcm_lib_ioctl, + .close = ipq4019_pcm_i2s_close, + .prepare = ipq4019_pcm_i2s_prepare, + .mmap = ipq4019_pcm_i2s_mmap, + .pointer = ipq4019_pcm_i2s_pointer, + .copy = ipq4019_pcm_i2s_copy, +}; + +static void ipq4019_asoc_pcm_i2s_free(struct snd_pcm *pcm) +{ + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_PLAYBACK); + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_CAPTURE); +} + +static int ipq4019_asoc_pcm_i2s_new(struct snd_soc_pcm_runtime *prtd) +{ + struct snd_card *card = prtd->card->snd_card; + struct snd_pcm *pcm = prtd->pcm; + int ret = 0, pback = 0; + + if (!card->dev->coherent_dma_mask) + card->dev->coherent_dma_mask = DMA_BIT_MASK(32); + + if (!card->dev->dma_mask) + card->dev->dma_mask = &card->dev->coherent_dma_mask; + + if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + if (ret) { + dev_err(card->dev, + "Error allocating playback dma. ret: %d\n", + ret); + return -ENOMEM; + } + pback = 1; + } + + if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_CAPTURE); + if (ret) { + dev_err(card->dev, + "Error allocating capture dma buf. ret: %d\n", + ret); + if (pback) + ipq4019_pcm_free_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + return -ENOMEM; + } + } + + return ret; +} + +static struct snd_soc_platform_driver ipq4019_asoc_pcm_i2s_platform = { + .ops = &ipq4019_asoc_pcm_i2s_ops, + .pcm_new = ipq4019_asoc_pcm_i2s_new, + .pcm_free = ipq4019_asoc_pcm_i2s_free, +}; + +static const struct of_device_id ipq4019_pcm_i2s_id_table[] = { + { .compatible = "qca,ipq4019-pcm-i2s" }, + { .compatible = "qca,ipq4019-pcm-i2s1" }, + { .compatible = "qca,ipq4019-pcm-i2s2" }, + { /* Sentinel */ }, +}; +MODULE_DEVICE_TABLE(of, ipq4019_pcm_i2s_id_table); + +static int ipq4019_pcm_i2s_driver_probe(struct platform_device *pdev) +{ + int ret; + + ret = snd_soc_register_platform(&pdev->dev, + &ipq4019_asoc_pcm_i2s_platform); + if (ret) + dev_err(&pdev->dev, + "Failed to register i2s pcm device ret: %d\n", ret); + return ret; +} + +static int ipq4019_pcm_i2s_driver_remove(struct platform_device *pdev) +{ + snd_soc_unregister_platform(&pdev->dev); + return 0; +} + +static struct platform_driver ipq4019_pcm_i2s_driver = { + .probe = ipq4019_pcm_i2s_driver_probe, + .remove = ipq4019_pcm_i2s_driver_remove, + .driver = { + .name = "qca-pcm-i2s", + .owner = THIS_MODULE, + .of_match_table = ipq4019_pcm_i2s_id_table, + }, +}; + +module_platform_driver(ipq4019_pcm_i2s_driver); + +MODULE_ALIAS("platform:qca-pcm-i2s"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 PCM I2S Platform Driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-pcm-spdif.c b/sound/soc/qcom/ipq4019/ipq4019-pcm-spdif.c new file mode 100644 index 0000000..08dac4a --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-pcm-spdif.c @@ -0,0 +1,664 @@ +/* + * Copyright (c) 2015-2016 The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/time.h> +#include <linux/wait.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/dma-mapping.h> +#include <asm/dma.h> +#include <sound/core.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/pcm.h> +#include <sound/initval.h> +#include <sound/control.h> +#include <sound/pcm_params.h> + +#include "ipq4019-pcm.h" +#include "ipq4019-adss.h" + +static struct snd_pcm_hardware ipq4019_pcm_hardware_playback = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_PAUSE | + SNDRV_PCM_INFO_RESUME, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .buffer_bytes_max = IPQ4019_I2S_BUFF_SIZE, + .period_bytes_max = IPQ4019_I2S_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_I2S_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_I2S_NO_OF_PERIODS, + .periods_max = IPQ4019_I2S_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static struct snd_pcm_hardware ipq4019_pcm_hardware_capture = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S24_3, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_STEREO, + .buffer_bytes_max = IPQ4019_I2S_BUFF_SIZE, + .period_bytes_max = IPQ4019_I2S_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_I2S_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_I2S_NO_OF_PERIODS, + .periods_max = IPQ4019_I2S_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static size_t ip4019_dma_buffer_size(struct snd_pcm_hardware *pcm_hw) +{ + return pcm_hw->buffer_bytes_max + + (pcm_hw->periods_min * sizeof(struct ipq4019_mbox_desc)); +} + +/* + * The MBOX descriptors and buffers should lie within the same 256MB + * region. Because, the buffer address pointer (in the descriptor structure) + * and descriptor base address pointer register share the same MSB 4 bits + * which is configured in MBOX DMA Policy register. + * + * Hence ensure that the entire allocated region falls in a 256MB region. + */ +static int ipq4019_mbox_buf_is_aligned(void *c_ptr, ssize_t size) +{ + u32 ptr = (u32)c_ptr; + + return (ptr & 0xF0000000) == ((ptr + size - 1) & 0xF0000000); +} + +static struct device *ss2dev(struct snd_pcm_substream *substream) +{ + return substream->pcm->card->dev; +} + +static int ipq4019_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, + int stream) +{ + struct snd_pcm_substream *substream = pcm->streams[stream].substream; + struct snd_dma_buffer *buf = &substream->dma_buffer; + struct snd_pcm_hardware *pcm_hw = NULL; + size_t size; + u8 *area; + dma_addr_t addr; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + pcm_hw = &ipq4019_pcm_hardware_playback; + else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) + pcm_hw = &ipq4019_pcm_hardware_capture; + else + return -EINVAL; + + size = ip4019_dma_buffer_size(pcm_hw); + buf->dev.type = SNDRV_DMA_TYPE_DEV; + buf->dev.dev = pcm->card->dev; + buf->private_data = NULL; + + area = dma_alloc_coherent(pcm->card->dev, size, &addr, GFP_KERNEL); + if (!area) { + dev_info(ss2dev(substream), "Alloc coherent memory failed\n"); + return -ENOMEM; + } + + if (!ipq4019_mbox_buf_is_aligned(area, size)) { + dev_info(ss2dev(substream), + "First allocation %p not within 256M region\n", area); + + buf->area = dma_alloc_coherent(pcm->card->dev, size, + &buf->addr, GFP_KERNEL); + /* + * If we are here, the previously allocated buffer is not + * usable for the driver. Have to free it anyway regardless + * of the success/failure of the second allocation. + */ + dma_free_coherent(pcm->card->dev, size, area, addr); + if (!buf->area) { + dev_info(ss2dev(substream), + "Second Alloc coherent memory failed\n"); + return -ENOMEM; + } + } else { + buf->area = area; + buf->addr = addr; + } + + buf->bytes = pcm_hw->buffer_bytes_max; + + return 0; +} + +static void ipq4019_pcm_free_dma_buffer(struct snd_pcm *pcm, int stream) +{ + struct snd_pcm_substream *substream; + struct snd_pcm_hardware *pcm_hw = NULL; + struct snd_dma_buffer *buf; + size_t size; + + substream = pcm->streams[stream].substream; + buf = &substream->dma_buffer; + + switch (stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + pcm_hw = &ipq4019_pcm_hardware_playback; + break; + case SNDRV_PCM_STREAM_CAPTURE: + pcm_hw = &ipq4019_pcm_hardware_capture; + break; + } + + size = ip4019_dma_buffer_size(pcm_hw); + + dma_free_coherent(pcm->card->dev, size, buf->area, buf->addr); + + buf->area = NULL; +} + +static irqreturn_t ipq4019_pcm_irq(int intrsrc, void *data) +{ + uint32_t processed_size; + int offset; + uint32_t *ptr; + + struct snd_pcm_substream *substream = data; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = + (struct ipq4019_pcm_rt_priv *)runtime->private_data; + + /* Store the last played buffer in the runtime priv struct */ + pcm_rtpriv->last_played = + ipq4019_mbox_get_last_played(pcm_rtpriv->channel); + + /* Set the OWN bits */ + processed_size = ipq4019_mbox_get_elapsed_size(pcm_rtpriv->channel); + pcm_rtpriv->processed_size = processed_size; + + if (processed_size > pcm_rtpriv->period_size) + snd_printd("Processed more than one period bytes : %d\n", + processed_size); + + /* Need to extract the data part alone in case of Rx */ + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + if (pcm_rtpriv->last_played == NULL) + offset = 0; + else + offset = (pcm_rtpriv->last_played->BufPtr - + (runtime->dma_addr & 0xFFFFFFF)); + + if (offset > 0) { + ptr = (uint32_t *)((char *)runtime->dma_area + offset - + processed_size); + + if (ptr < (uint32_t *)runtime->dma_area) + goto ack; + } + } + + snd_pcm_period_elapsed(substream); + + if (pcm_rtpriv->last_played == NULL) { + snd_printd("BUG: ISR called but no played buf found\n"); + goto ack; + } + +ack: + return IRQ_HANDLED; +} + +static snd_pcm_uframes_t ipq4019_pcm_spdif_pointer( + struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + snd_pcm_uframes_t ret; + + pcm_rtpriv = runtime->private_data; + + if (pcm_rtpriv->last_played == NULL) + ret = 0; + else + ret = (pcm_rtpriv->last_played->BufPtr - + (runtime->dma_addr & 0xFFFFFFF)); + ret = bytes_to_frames(runtime, ret); + return ret; +} + +static int ipq4019_pcm_spdif_copy(struct snd_pcm_substream *substream, int chan, + snd_pcm_uframes_t hwoff, void __user *ubuf, + snd_pcm_uframes_t frames) +{ + struct snd_dma_buffer *buf = &substream->dma_buffer; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + char *hwbuf; + u32 offset, size; + + offset = frames_to_bytes(runtime, hwoff); + size = frames_to_bytes(runtime, frames); + + hwbuf = buf->area + offset; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + if (copy_from_user(hwbuf, ubuf, size)) + return -EFAULT; + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + if (copy_to_user(ubuf, hwbuf, size)) + return -EFAULT; + } + + ipq4019_mbox_desc_own(pcm_rtpriv->channel, offset / size, 1); + + ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + + return 0; +} + +static int ipq4019_pcm_spdif_mmap(struct snd_pcm_substream *substream, + struct vm_area_struct *vma) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + + return dma_mmap_coherent(substream->pcm->card->dev, vma, + runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); +} + +static int ipq4019_pcm_hw_free(struct snd_pcm_substream *substream) +{ + snd_pcm_set_runtime_buffer(substream, NULL); + return 0; +} + + +static int ipq4019_pcm_spdif_prepare(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + + uint32_t ret; + + pcm_rtpriv = runtime->private_data; + + ret = ipq4019_mbox_dma_prepare(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma prepare : channel : %d\n", + __func__, __LINE__, pcm_rtpriv->channel); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + return ret; + } + + /* Set to swap the words */ + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + ret = ipq4019_mbox_dma_swap(pcm_rtpriv->channel, + runtime->format); + if (ret) { + pr_err("%s: %d: Error in dma swap : channel : %d\n", + __func__, __LINE__, pcm_rtpriv->channel); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + return ret; + } + + /* SWAP at PCM level for 24 bit samples */ + if ((substream->runtime->format == SNDRV_PCM_FORMAT_S24_3LE) || + (substream->runtime->format == SNDRV_PCM_FORMAT_S24_3BE)) + ipq4019_stereo_spdif_pcmswap(ENABLE, + ipq4019_get_stereo_id(substream, SPDIF)); + } + + /* Set the ownership bits */ + ipq4019_mbox_get_elapsed_size(pcm_rtpriv->channel); + + pcm_rtpriv->last_played = NULL; + + return ret; +} + +static int ipq4019_pcm_spdif_close(struct snd_pcm_substream *substream) +{ + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + uint32_t ret; + + pcm_rtpriv = substream->runtime->private_data; + ret = ipq4019_mbox_dma_release(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma release\n", + __func__, __LINE__); + } + + /* Reset the swap */ + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + ret = ipq4019_mbox_dma_reset_swap(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma release\n", + __func__, __LINE__); + } + + if ((substream->runtime->format == SNDRV_PCM_FORMAT_S24_3LE) || + (substream->runtime->format == SNDRV_PCM_FORMAT_S24_3BE)) + ipq4019_stereo_spdif_pcmswap(DISABLE, + ipq4019_get_stereo_id(substream, SPDIF)); + } + + kfree(pcm_rtpriv); + + return ret; +} + +static int ipq4019_pcm_spdif_trigger(struct snd_pcm_substream *substream, + int cmd) +{ + int ret; + u32 desc_duration; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = + substream->runtime->private_data; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + /* Enable the SPDIF Stereo block for operation */ + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + ipq4019_stereo_spdif_enable(ENABLE, + ipq4019_get_stereo_id(substream, + SPDIF)); + else + ipq4019_spdifin_ctrl_spdif_en(ENABLE); + + ret = ipq4019_mbox_dma_start(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma start\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + ret = ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma resume\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + /* Disable the SPDIF Stereo block */ + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + ipq4019_stereo_spdif_enable(DISABLE, + ipq4019_get_stereo_id(substream, + SPDIF)); + else + ipq4019_spdifin_ctrl_spdif_en(DISABLE); + + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + /* + * For e.g. the number of bytes needed to represent 1 second + * worth of audio data for sampling frequency, bit width, stereo + * combination of 16KHz, 32-bits and stereo, the calculation is + * as follows + * + * For 1 second, + * 16KHz * 32 bits * 2 (left & right channel of stereo) + * = 16000 * 4 bytes * 2 + * = 128000 bytes + * + * Hence the duration will be + * desc_buffer_size_in_bytes / 128000 * 1 sec + */ + desc_duration = + frames_to_bytes(runtime, runtime->period_size) * 1000 / + (runtime->rate * + DIV_ROUND_UP(runtime->sample_bits, 8) * + runtime->channels); + + ret = ipq4019_mbox_dma_stop(pcm_rtpriv->channel, desc_duration); + if (ret) { + pr_err("%s: %d: Error in dma stop\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + default: + ret = -EINVAL; + break; + } + return ret; +} + +static int ipq4019_pcm_spdif_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + int ret; + unsigned int period_size, sample_size, sample_rate, frames, channels; + + pr_debug("%s %d\n", __func__, __LINE__); + + pcm_rtpriv = runtime->private_data; + ret = ipq4019_mbox_form_ring(pcm_rtpriv->channel, + substream->dma_buffer.addr, + substream->dma_buffer.area, + params_period_bytes(hw_params), + params_buffer_bytes(hw_params), + (substream->stream == SNDRV_PCM_STREAM_CAPTURE)); + if (ret) { + pr_err("%s: %d: Error dma form ring\n", __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + return ret; + } + + period_size = params_period_bytes(hw_params); + sample_size = snd_pcm_format_size(params_format(hw_params), 1); + sample_rate = params_rate(hw_params); + channels = params_channels(hw_params); + frames = period_size / (sample_size * channels); + + pcm_rtpriv->period_size = params_period_bytes(hw_params); + + /* Check whether this is a compressed play or not + * if its a compressed play set VUC + */ + if (hw_params->reserved[0]) + ipq4019_mbox_vuc_setup(pcm_rtpriv->channel); + + snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer); + + runtime->dma_bytes = params_buffer_bytes(hw_params); + return ret; +} + +static int ipq4019_pcm_spdif_open(struct snd_pcm_substream *substream) +{ + int ret; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + + pr_debug("%s %d\n", __func__, __LINE__); + + pcm_rtpriv = kmalloc(sizeof(struct ipq4019_pcm_rt_priv), GFP_KERNEL); + if (!pcm_rtpriv) + return -ENOMEM; + + snd_printd("%s: 0x%xB allocated at 0x%08x\n", + __func__, sizeof(*pcm_rtpriv), (u32) pcm_rtpriv); + pcm_rtpriv->last_played = NULL; + pcm_rtpriv->dev = substream->pcm->card->dev; + pcm_rtpriv->channel = ipq4019_get_mbox_id(substream, SPDIF); + pcm_rtpriv->curr_pos = 0; + pcm_rtpriv->mmap_flag = 0; + substream->runtime->private_data = pcm_rtpriv; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + runtime->dma_bytes = + ipq4019_pcm_hardware_playback.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_playback); + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + runtime->dma_bytes = + ipq4019_pcm_hardware_capture.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_capture); + + } else { + pr_err("%s: Invalid stream\n", __func__); + ret = -EINVAL; + goto error; + } + ret = ipq4019_mbox_dma_init(pcm_rtpriv->dev, + pcm_rtpriv->channel, ipq4019_pcm_irq, substream); + if (ret) { + pr_err("%s: %d: Error initializing dma\n", + __func__, __LINE__); + goto error; + } + + ret = snd_pcm_hw_constraint_integer(runtime, + SNDRV_PCM_HW_PARAM_PERIODS); + if (ret < 0) { + pr_err("%s: snd_pcm_hw_constraint_integer failed\n", __func__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + goto error; + } + + return 0; +error: + kfree(pcm_rtpriv); + return ret; +} + +static struct snd_pcm_ops ipq4019_asoc_pcm_spdif_ops = { + .open = ipq4019_pcm_spdif_open, + .hw_params = ipq4019_pcm_spdif_hw_params, + .hw_free = ipq4019_pcm_hw_free, + .trigger = ipq4019_pcm_spdif_trigger, + .ioctl = snd_pcm_lib_ioctl, + .close = ipq4019_pcm_spdif_close, + .prepare = ipq4019_pcm_spdif_prepare, + .mmap = ipq4019_pcm_spdif_mmap, + .pointer = ipq4019_pcm_spdif_pointer, + .copy = ipq4019_pcm_spdif_copy, +}; + +static void ipq4019_asoc_pcm_spdif_free(struct snd_pcm *pcm) +{ + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_PLAYBACK); + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_CAPTURE); +} + +static int ipq4019_asoc_pcm_spdif_new(struct snd_soc_pcm_runtime *prtd) +{ + struct snd_card *card = prtd->card->snd_card; + struct snd_pcm *pcm = prtd->pcm; + + int ret = 0; + + if (!card->dev->coherent_dma_mask) + card->dev->coherent_dma_mask = DMA_BIT_MASK(32); + + if (!card->dev->dma_mask) + card->dev->dma_mask = &card->dev->coherent_dma_mask; + + if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + + if (ret) { + pr_err("%s: %d: Error allocating dma buf\n", + __func__, __LINE__); + return -ENOMEM; + } + } + + if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_CAPTURE); + if (ret) { + pr_err("%s: %d: Error allocating dma buf\n", + __func__, __LINE__); + ipq4019_pcm_free_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + return -ENOMEM; + } + } + + return ret; +} + +static struct snd_soc_platform_driver ipq4019_asoc_pcm_spdif_platform = { + .ops = &ipq4019_asoc_pcm_spdif_ops, + .pcm_new = ipq4019_asoc_pcm_spdif_new, + .pcm_free = ipq4019_asoc_pcm_spdif_free, +}; + +static const struct of_device_id ipq4019_pcm_spdif_id_table[] = { + { .compatible = "qca,ipq4019-pcm-spdif" }, + { /* Sentinel */ }, +}; +MODULE_DEVICE_TABLE(of, ipq4019_pcm_spdif_id_table); + +static int ipq4019_pcm_spdif_driver_probe(struct platform_device *pdev) +{ + int ret; + + pr_debug("%s %d\n", __func__, __LINE__); + ret = snd_soc_register_platform(&pdev->dev, + &ipq4019_asoc_pcm_spdif_platform); + if (ret) + dev_err(&pdev->dev, "%s: Failed to register spdif pcm device\n", + __func__); + return ret; +} + +static int ipq4019_pcm_spdif_driver_remove(struct platform_device *pdev) +{ + pr_debug("%s %d\n", __func__, __LINE__); + snd_soc_unregister_platform(&pdev->dev); + + return 0; +} + +static struct platform_driver ipq4019_pcm_spdif_driver = { + .probe = ipq4019_pcm_spdif_driver_probe, + .remove = ipq4019_pcm_spdif_driver_remove, + .driver = { + .name = "qca-pcm-spdif", + .owner = THIS_MODULE, + .of_match_table = ipq4019_pcm_spdif_id_table, + }, +}; + +module_platform_driver(ipq4019_pcm_spdif_driver); + +MODULE_ALIAS("platform:qca-pcm-spdif"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 PCM SPDIF Platform Driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-pcm-tdm.c b/sound/soc/qcom/ipq4019/ipq4019-pcm-tdm.c new file mode 100644 index 0000000..657a4a6 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-pcm-tdm.c @@ -0,0 +1,609 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/err.h> +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/time.h> +#include <linux/wait.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <linux/dma-mapping.h> +#include <asm/dma.h> +#include <sound/core.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/pcm.h> +#include <sound/initval.h> +#include <sound/control.h> +#include <sound/pcm_params.h> + +#include "ipq4019-pcm.h" +#include "ipq4019-adss.h" + +static struct snd_pcm_hardware ipq4019_pcm_hardware_playback = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED | + SNDRV_PCM_INFO_PAUSE | + SNDRV_PCM_INFO_RESUME, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .buffer_bytes_max = IPQ4019_TDM_BUFF_SIZE, + .period_bytes_max = IPQ4019_TDM_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_TDM_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_TDM_NO_OF_PERIODS, + .periods_max = IPQ4019_TDM_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static struct snd_pcm_hardware ipq4019_pcm_hardware_capture = { + .info = SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_BLOCK_TRANSFER | + SNDRV_PCM_INFO_MMAP_VALID | + SNDRV_PCM_INFO_INTERLEAVED, + .formats = SNDRV_PCM_FMTBIT_S16 | + SNDRV_PCM_FMTBIT_S32, + .rates = RATE_16000_96000, + .rate_min = FREQ_16000, + .rate_max = FREQ_96000, + .channels_min = CH_STEREO, + .channels_max = CH_7_1, + .buffer_bytes_max = IPQ4019_TDM_BUFF_SIZE, + .period_bytes_max = IPQ4019_TDM_BUFF_SIZE / 2, + .period_bytes_min = IPQ4019_TDM_PERIOD_BYTES_MIN, + .periods_min = IPQ4019_TDM_NO_OF_PERIODS, + .periods_max = IPQ4019_TDM_NO_OF_PERIODS, + .fifo_size = 0, +}; + +static size_t ip4019_dma_buffer_size(struct snd_pcm_hardware *pcm_hw) +{ + return (pcm_hw->buffer_bytes_max + + (pcm_hw->periods_min * sizeof(struct ipq4019_mbox_desc))); +} + +static struct device *ss2dev(struct snd_pcm_substream *substream) +{ + return substream->pcm->card->dev; +} + +/* + * The MBOX descriptors and buffers should lie within the same 256MB + * region. Because, the buffer address pointer (in the descriptor structure) + * and descriptor base address pointer register share the same MSB 4 bits + * which is configured in MBOX DMA Policy register. + * + * Hence ensure that the entire allocated region falls in a 256MB region. + */ +static int ipq4019_mbox_buf_is_aligned(void *c_ptr, ssize_t size) +{ + u32 ptr = (u32)c_ptr; + + return (ptr & 0xF0000000) == ((ptr + size - 1) & 0xF0000000); +} + +static int ipq4019_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, + int stream) +{ + struct snd_pcm_substream *substream = pcm->streams[stream].substream; + struct snd_pcm_hardware *pcm_hw = NULL; + struct snd_dma_buffer *buf = &substream->dma_buffer; + size_t size; + u8 *area; + dma_addr_t addr; + + switch (substream->stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + pcm_hw = &ipq4019_pcm_hardware_playback; + break; + case SNDRV_PCM_STREAM_CAPTURE: + pcm_hw = &ipq4019_pcm_hardware_capture; + break; + default: + dev_err(ss2dev(substream), "Invalid stream: %d\n", + substream->stream); + return -EINVAL; + } + + size = ip4019_dma_buffer_size(pcm_hw); + buf->dev.type = SNDRV_DMA_TYPE_DEV; + buf->dev.dev = pcm->card->dev; + buf->private_data = NULL; + + /* + * |<-- buffers -->|<-- desc -->| + * +----+----+----+----+----+----+-+-+-+-+-+-+-+ + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * | | | | | | | | | | | | | | + * +----+----+----+----+----+----+-+-+-+-+-+-+-+ + * ^ ^ | | . . . + * | | | | + * +----|------------------------+ | + * +--------------------------+ + */ + + /* + * Currently payload uses uncached memory. + * TODO: Eventually we will move to cached memory for payload + * and dma_map_single() will be used for Invalidating/Flushing + * the buffers. + */ + + area = dma_alloc_coherent(pcm->card->dev, size, &addr, GFP_KERNEL); + + if (!area) { + dev_info(ss2dev(substream), "Alloc coherent memory failed\n"); + return -ENOMEM; + } + + if (!ipq4019_mbox_buf_is_aligned(area, size)) { + dev_info(ss2dev(substream), + "First allocation %p not within 256M region\n", area); + + buf->area = dma_alloc_coherent(pcm->card->dev, size, + &buf->addr, GFP_KERNEL); + /* + * If we are here, the previously allocated buffer is not + * usable for the driver. Have to free it anyway regardless + * of the success/failure of the second allocation. + */ + dma_free_coherent(pcm->card->dev, size, area, addr); + if (!buf->area) { + dev_info(ss2dev(substream), + "Second Alloc coherent memory failed\n"); + return -ENOMEM; + } + } else { + buf->area = area; + buf->addr = addr; + } + + buf->bytes = pcm_hw->buffer_bytes_max; + + return 0; +} + +static void ipq4019_pcm_free_dma_buffer(struct snd_pcm *pcm, int stream) +{ + struct snd_pcm_substream *substream; + struct snd_pcm_hardware *pcm_hw = NULL; + struct snd_dma_buffer *buf; + size_t size; + + substream = pcm->streams[stream].substream; + buf = &substream->dma_buffer; + + switch (stream) { + case SNDRV_PCM_STREAM_PLAYBACK: + pcm_hw = &ipq4019_pcm_hardware_playback; + break; + case SNDRV_PCM_STREAM_CAPTURE: + pcm_hw = &ipq4019_pcm_hardware_capture; + break; + } + + size = ip4019_dma_buffer_size(pcm_hw); + + dma_free_coherent(pcm->card->dev, size, buf->area, buf->addr); + + buf->addr = 0; + buf->area = NULL; +} + +static irqreturn_t ipq4019_pcm_irq(int intrsrc, void *data) +{ + struct snd_pcm_substream *substream = data; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = + (struct ipq4019_pcm_rt_priv *)runtime->private_data; + + pcm_rtpriv->curr_pos = + ipq4019_mbox_get_played_offset(pcm_rtpriv->channel); + + snd_pcm_period_elapsed(substream); + + return IRQ_HANDLED; +} + +static snd_pcm_uframes_t ipq4019_pcm_tdm_pointer( + struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + snd_pcm_uframes_t ret; + + pcm_rtpriv = runtime->private_data; + + ret = bytes_to_frames(runtime, pcm_rtpriv->curr_pos); + return ret; +} + +static int ipq4019_pcm_tdm_copy(struct snd_pcm_substream *substream, int chan, + snd_pcm_uframes_t hwoff, void __user *ubuf, + snd_pcm_uframes_t frames) +{ + struct snd_dma_buffer *buf = &substream->dma_buffer; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = runtime->private_data; + char *hwbuf; + u32 offset, size; + + offset = frames_to_bytes(runtime, hwoff); + size = frames_to_bytes(runtime, frames); + + hwbuf = buf->area + offset; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + if (copy_from_user(hwbuf, ubuf, size)) + return -EFAULT; + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + if (copy_to_user(ubuf, hwbuf, size)) + return -EFAULT; + } + + ipq4019_mbox_desc_own(pcm_rtpriv->channel, offset / size, 1); + + ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + + return 0; +} + +static int ipq4019_pcm_tdm_mmap(struct snd_pcm_substream *substream, + struct vm_area_struct *vma) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + + return dma_mmap_coherent(substream->pcm->card->dev, vma, + runtime->dma_area, runtime->dma_addr, runtime->dma_bytes); +} + +static int ipq4019_pcm_hw_free(struct snd_pcm_substream *substream) +{ + snd_pcm_set_runtime_buffer(substream, NULL); + return 0; +} + + +static int ipq4019_pcm_tdm_prepare(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + + uint32_t ret; + + pcm_rtpriv = runtime->private_data; + ret = ipq4019_mbox_dma_prepare(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma prepare : channel : %d\n", + __func__, __LINE__, pcm_rtpriv->channel); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + return ret; + } + + /* Set the ownership bits */ + ipq4019_mbox_get_elapsed_size(pcm_rtpriv->channel); + + pcm_rtpriv->last_played = NULL; + + return ret; +} + +static int ipq4019_pcm_tdm_close(struct snd_pcm_substream *substream) +{ + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_dai *dai = rtd->cpu_dai; + u32 intf = dai->driver->id; + uint32_t ret; + + ipq4019_stereo_config_enable(DISABLE, + ipq4019_get_stereo_id(substream, intf)); + + pcm_rtpriv = substream->runtime->private_data; + if (!pcm_rtpriv) + return -EINVAL; + + ret = ipq4019_mbox_dma_release(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma release\n", + __func__, __LINE__); + } + + kfree(pcm_rtpriv); + + return 0; +} + +static int ipq4019_pcm_tdm_trigger(struct snd_pcm_substream *substream, int cmd) +{ + int ret; + u32 desc_duration; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv = + substream->runtime->private_data; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + + ret = ipq4019_mbox_dma_start(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma start\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + ret = ipq4019_mbox_dma_resume(pcm_rtpriv->channel); + if (ret) { + pr_err("%s: %d: Error in dma resume\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + /* + * For e.g. the number of bytes needed to represent 1 second + * worth of audio data for sampling frequency, bit width, stereo + * combination of 16KHz, 32-bits and stereo, the calculation is + * as follows + * + * For 1 second, + * 16KHz * 32 bits * 2 (left & right channel of stereo) + * = 16000 * 4 bytes * 2 + * = 128000 bytes + * + * Hence the duration will be + * desc_buffer_size_in_bytes / 128000 * 1 sec + */ + desc_duration = + frames_to_bytes(runtime, runtime->period_size) * 1000 / + (runtime->rate * + DIV_ROUND_UP(runtime->sample_bits, 8) * + runtime->channels); + + ret = ipq4019_mbox_dma_stop(pcm_rtpriv->channel, desc_duration); + if (ret) { + pr_err("%s: %d: Error in dma stop\n", + __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + } + break; + default: + ret = -EINVAL; + break; + } + return ret; +} + +static int ipq4019_pcm_tdm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + int ret; + unsigned int period_size, sample_size, sample_rate, frames, channels; + + pr_debug("%s %d\n", __func__, __LINE__); + + pcm_rtpriv = runtime->private_data; + + ret = ipq4019_mbox_form_ring(pcm_rtpriv->channel, + substream->dma_buffer.addr, + substream->dma_buffer.area, + params_period_bytes(hw_params), + params_buffer_bytes(hw_params), + (substream->stream == SNDRV_PCM_STREAM_CAPTURE)); + if (ret) { + pr_err("%s: %d: Error dma form ring\n", __func__, __LINE__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + return ret; + } + + period_size = params_period_bytes(hw_params); + sample_size = snd_pcm_format_size(params_format(hw_params), 1); + sample_rate = params_rate(hw_params); + channels = params_channels(hw_params); + frames = period_size / (sample_size * channels); + + pcm_rtpriv->period_size = params_period_bytes(hw_params); + + snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer); + + runtime->dma_bytes = params_buffer_bytes(hw_params); + return ret; +} + +static int ipq4019_pcm_tdm_open(struct snd_pcm_substream *substream) +{ + int ret; + struct snd_pcm_runtime *runtime = substream->runtime; + struct ipq4019_pcm_rt_priv *pcm_rtpriv; + + pr_debug("%s %d\n", __func__, __LINE__); + + pcm_rtpriv = kmalloc(sizeof(struct ipq4019_pcm_rt_priv), GFP_KERNEL); + + if (!pcm_rtpriv) + return -ENOMEM; + + snd_printd("%s: 0x%xB allocated at 0x%08x\n", + __func__, sizeof(*pcm_rtpriv), (u32) pcm_rtpriv); + pcm_rtpriv->last_played = NULL; + pcm_rtpriv->dev = substream->pcm->card->dev; + pcm_rtpriv->channel = ipq4019_get_mbox_id(substream, TDM); + pcm_rtpriv->curr_pos = 0; + pcm_rtpriv->mmap_flag = 0; + substream->runtime->private_data = pcm_rtpriv; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + runtime->dma_bytes = + ipq4019_pcm_hardware_playback.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_playback); + } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + runtime->dma_bytes = + ipq4019_pcm_hardware_capture.buffer_bytes_max; + snd_soc_set_runtime_hwparams(substream, + &ipq4019_pcm_hardware_capture); + + } else { + pr_err("%s: Invalid stream\n", __func__); + ret = -EINVAL; + goto error; + } + ret = ipq4019_mbox_dma_init(pcm_rtpriv->dev, + pcm_rtpriv->channel, ipq4019_pcm_irq, substream); + if (ret) { + pr_err("%s: %d: Error initializing dma\n", + __func__, __LINE__); + goto error; + } + + ret = snd_pcm_hw_constraint_integer(runtime, + SNDRV_PCM_HW_PARAM_PERIODS); + if (ret < 0) { + pr_err("%s: snd_pcm_hw_constraint_integer failed\n", __func__); + ipq4019_mbox_dma_release(pcm_rtpriv->channel); + goto error; + } + + return 0; +error: + kfree(pcm_rtpriv); + return ret; +} + +static struct snd_pcm_ops ipq4019_asoc_pcm_tdm_ops = { + .open = ipq4019_pcm_tdm_open, + .hw_params = ipq4019_pcm_tdm_hw_params, + .hw_free = ipq4019_pcm_hw_free, + .trigger = ipq4019_pcm_tdm_trigger, + .ioctl = snd_pcm_lib_ioctl, + .close = ipq4019_pcm_tdm_close, + .prepare = ipq4019_pcm_tdm_prepare, + .mmap = ipq4019_pcm_tdm_mmap, + .pointer = ipq4019_pcm_tdm_pointer, + .copy = ipq4019_pcm_tdm_copy, +}; + +static void ipq4019_asoc_pcm_tdm_free(struct snd_pcm *pcm) +{ + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_PLAYBACK); + ipq4019_pcm_free_dma_buffer(pcm, SNDRV_PCM_STREAM_CAPTURE); +} + +static int ipq4019_asoc_pcm_tdm_new(struct snd_soc_pcm_runtime *prtd) +{ + struct snd_card *card = prtd->card->snd_card; + struct snd_pcm *pcm = prtd->pcm; + + int ret = 0; + + if (!card->dev->coherent_dma_mask) + card->dev->coherent_dma_mask = DMA_BIT_MASK(32); + + if (!card->dev->dma_mask) + card->dev->dma_mask = &card->dev->coherent_dma_mask; + + if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + + if (ret) { + pr_err("%s: %d: Error allocating dma buf\n", + __func__, __LINE__); + return -ENOMEM; + } + } + + if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) { + ret = ipq4019_pcm_preallocate_dma_buffer(pcm, + SNDRV_PCM_STREAM_CAPTURE); + if (ret) { + pr_err("%s: %d: Error allocating dma buf\n", + __func__, __LINE__); + ipq4019_pcm_free_dma_buffer(pcm, + SNDRV_PCM_STREAM_PLAYBACK); + return -ENOMEM; + } + } + + return ret; +} + +static struct snd_soc_platform_driver ipq4019_asoc_pcm_tdm_platform = { + .ops = &ipq4019_asoc_pcm_tdm_ops, + .pcm_new = ipq4019_asoc_pcm_tdm_new, + .pcm_free = ipq4019_asoc_pcm_tdm_free, +}; + +static const struct of_device_id ipq4019_pcm_tdm_id_table[] = { + { .compatible = "qca,ipq4019-pcm-tdm" }, + { /* Sentinel */ }, +}; +MODULE_DEVICE_TABLE(of, ipq4019_pcm_tdm_id_table); + +static int ipq4019_pcm_tdm_driver_probe(struct platform_device *pdev) +{ + int ret; + + pr_debug("%s %d\n", __func__, __LINE__); + ret = snd_soc_register_platform(&pdev->dev, + &ipq4019_asoc_pcm_tdm_platform); + if (ret) + dev_err(&pdev->dev, "%s: Failed to register tdm pcm device\n", + __func__); + return ret; +} + +static int ipq4019_pcm_tdm_driver_remove(struct platform_device *pdev) +{ + pr_debug("%s %d\n", __func__, __LINE__); + snd_soc_unregister_platform(&pdev->dev); + + return 0; +} + +static struct platform_driver ipq4019_pcm_tdm_driver = { + .probe = ipq4019_pcm_tdm_driver_probe, + .remove = ipq4019_pcm_tdm_driver_remove, + .driver = { + .name = "qca-pcm-tdm", + .owner = THIS_MODULE, + .of_match_table = ipq4019_pcm_tdm_id_table, + }, +}; + +module_platform_driver(ipq4019_pcm_tdm_driver); + +MODULE_ALIAS("platform:qca-pcm-tdm"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 PCM TDM Platform Driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019-pcm.h b/sound/soc/qcom/ipq4019/ipq4019-pcm.h new file mode 100644 index 0000000..0c467d6 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-pcm.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2015, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _IPQ40XX_PCM_H_ +#define _IPQ40XX_PCM_H_ + +#include <linux/sound.h> +#include <linux/list.h> +#include <linux/spinlock.h> +#include <linux/interrupt.h> + +#include "ipq4019-mbox.h" + +struct ipq4019_pcm_rt_priv { + int channel; + struct device *dev; + struct ipq4019_mbox_desc *last_played; + unsigned int processed_size; + uint32_t period_size; + uint32_t curr_pos; + int mmap_flag; +}; + +#endif /* _IPQ40XX_PCM_H_ */ diff --git a/sound/soc/qcom/ipq4019/ipq4019-stereo.c b/sound/soc/qcom/ipq4019/ipq4019-stereo.c new file mode 100644 index 0000000..52e0c29 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019-stereo.c @@ -0,0 +1,313 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/init.h> +#include <linux/io.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/platform_device.h> +#include <sound/core.h> +#include <sound/pcm.h> +#include <sound/soc.h> +#include <sound/pcm_params.h> +#include <linux/delay.h> +#include <linux/spinlock.h> + +#include "ipq4019-adss.h" + +struct stereo_priv_data { + void __iomem *stereo_base; + spinlock_t stereo_lock; +}; + +static struct stereo_priv_data stereo_priv[MAX_STEREO_ENTRIES]; + +/* + * + * Stereo buffers and I2S state reset + */ +void ipq4019_stereo_config_reset(u32 reset, u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_RESET; + if (reset) + cfg |= STEREOn_CONFIG_RESET; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_stereo_config_reset); + +/* + * MIC buffers reset + */ +void ipq4019_stereo_config_mic_reset(u32 reset, u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_MIC_RESET; + if (reset) + cfg |= STEREOn_CONFIG_MIC_RESET; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_stereo_config_mic_reset); + +/* + * Enable the I2S Stereo block for operation + */ +void ipq4019_stereo_config_enable(u32 enable, u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_ENABLE; + if (enable) + cfg |= STEREOn_CONFIG_ENABLE; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_stereo_config_enable); + +/* + * Enable the SPDIF Stereo block for operation + */ +void ipq4019_stereo_spdif_enable(uint32_t enable, uint32_t stereo_id) +{ + uint32_t cfg; + + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~(STEREOn_CONFIG_SPDIF_ENABLE); + if (enable) + cfg |= STEREOn_CONFIG_SPDIF_ENABLE; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); +} +EXPORT_SYMBOL(ipq4019_stereo_spdif_enable); + +/* + * Enable/disable the swap within PCM sample + */ +void ipq4019_stereo_spdif_pcmswap(uint32_t enable, uint32_t stereo_id) +{ + uint32_t cfg; + + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + + cfg &= ~(STEREOn_CONFIG_PCM_SWAP); + if (enable) + cfg |= STEREOn_CONFIG_PCM_SWAP; + + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); +} +EXPORT_SYMBOL(ipq4019_stereo_spdif_pcmswap); + +/* Configure + * Data word size : Word size loaded into the PCM + * register from the MBOX FIFO. + * I2S word size : Word size sent to the external I2S DAC. + * When set to 32 bit words the PCM data + * will be left justified in the I2S word. + */ +int ipq4019_cfg_bit_width(u32 bit_width, u32 stereo_id) +{ + u32 cfg, mask = 0; + unsigned long flags; + + switch (bit_width) { + case SNDRV_PCM_FORMAT_S16_LE: + case SNDRV_PCM_FORMAT_S16_BE: + mask |= (STEREOn_CONFIG_DATA_WORD_SIZE(1) | + STEREOn_CONFIG_I2S_WORD_SIZE_16 | + STEREOn_CONFIG_MIC_WORD_SIZE_16); + break; + case SNDRV_PCM_FORMAT_S24_3LE: + case SNDRV_PCM_FORMAT_S24_3BE: + mask |= (STEREOn_CONFIG_DATA_WORD_SIZE(2) | + STEREOn_CONFIG_I2S_WORD_SIZE_32 | + STEREOn_CONFIG_MIC_WORD_SIZE_16); + break; + case SNDRV_PCM_FORMAT_S32_LE: + case SNDRV_PCM_FORMAT_S32_BE: + mask |= (STEREOn_CONFIG_DATA_WORD_SIZE(3) | + STEREOn_CONFIG_I2S_WORD_SIZE_32 | + STEREOn_CONFIG_MIC_WORD_SIZE_32); + break; + default: + return -ENOTSUPP; + } + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_DATA_WORD_SIZE_MASK; + cfg &= ~STEREOn_CONFIG_I2S_WORD_SIZE_32; + cfg &= ~STEREOn_CONFIG_MIC_WORD_SIZE_32; + cfg |= mask; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); + + return 0; +} +EXPORT_SYMBOL(ipq4019_cfg_bit_width); + +/* + * Configure stereo/mono mode + */ +void ipq4019_config_stereo_mode(u32 mode, u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_STEREO_MONO_MASK; + if (mode == CH_STEREO) + cfg |= STEREOn_CONFIG_STEREO_MODE; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_config_stereo_mode); + +/* + * Configure master mode + */ +void ipq4019_config_master(u32 enable, u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_MASTER; + if (enable) + cfg |= STEREOn_CONFIG_MASTER; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_config_master); + +/* Selects the raw clock source between + * divided audio clock and input master clock + * Val 0: Raw master clock is divided audio PLL clock + * Val 1: Raw master clock is MCLK IN + */ +void ipq4019_config_mclk_sel(u32 stereo_id, u32 val) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + cfg &= ~STEREOn_CONFIG_MCK_SEL; + cfg |= val; + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); + +} +EXPORT_SYMBOL(ipq4019_config_mclk_sel); + +/* + * Strategy to clear the sample counter TX and RX registers + */ +void ipq4019_config_sample_cnt_clear_type(u32 stereo_id) +{ + u32 cfg; + unsigned long flags; + + spin_lock_irqsave(&stereo_priv[stereo_id].stereo_lock, flags); + cfg = readl(stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + /* 0 - write an explicit zero data through software + * to the TX and RX sample counter registers + * 1 - software read of the TX and RX sample counter + * registers clears the counter registers + */ + cfg |= STEREOn_CONFIG_SAMPLE_CNT_CLEAR_TYPE; /* Write 1 */ + writel(cfg, stereo_priv[stereo_id].stereo_base + + ADSS_STEREOn_STEREO0_CONFIG_REG); + spin_unlock_irqrestore(&stereo_priv[stereo_id].stereo_lock, flags); +} +EXPORT_SYMBOL(ipq4019_config_sample_cnt_clear_type); + +static const struct of_device_id ipq4019_audio_stereo_id_table[] = { + { .compatible = "qca,ipq4019-stereo" }, + {}, +}; +MODULE_DEVICE_TABLE(of, ipq4019_audio_stereo_id_table); + +static int ipq4019_audio_stereo_probe(struct platform_device *pdev) +{ + struct resource *res; + struct stereo_priv_data *spd; + struct device_node *np = pdev->dev.of_node; + u32 stereo_port_id = 0; + + if (of_property_read_u32(np, "stereo-index", &stereo_port_id)) { + dev_err(&pdev->dev, "Error reading stereo-index\n"); + return -EINVAL; + } + if (stereo_port_id >= MAX_STEREO_ENTRIES) + return -ENODEV; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + spd = &stereo_priv[stereo_port_id]; + spd->stereo_base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(spd->stereo_base)) + return PTR_ERR(spd->stereo_base); + + spin_lock_init(&spd->stereo_lock); + return 0; +} + +static struct platform_driver ipq4019_audio_stereo_driver = { + .probe = ipq4019_audio_stereo_probe, + .driver = { + .name = "ipq4019-stereo", + .of_match_table = ipq4019_audio_stereo_id_table, + }, +}; + +module_platform_driver(ipq4019_audio_stereo_driver); + +MODULE_ALIAS("platform:ipq4019-stereo"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("IPQ4019 AUDIO Stereo driver"); diff --git a/sound/soc/qcom/ipq4019/ipq4019.c b/sound/soc/qcom/ipq4019/ipq4019.c new file mode 100644 index 0000000..a08fa5e6 --- /dev/null +++ b/sound/soc/qcom/ipq4019/ipq4019.c @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include <linux/clk.h> +#include <linux/delay.h> +#include <linux/module.h> +#include <linux/gpio.h> +#include <linux/platform_device.h> +#include <linux/of_platform.h> +#include <linux/gpio.h> +#include <linux/slab.h> +#include <sound/core.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/pcm.h> +#include <sound/jack.h> +#include <linux/io.h> + +static struct snd_soc_dai_link ipq4019_snd_dai[] = { + { + .name = "IPQ4019 Media1", + .stream_name = "I2S", + /* CPU DAI Name */ + .cpu_dai_name = "qca-i2s-dai", + /* Platform Driver Name */ + .platform_name = "7709000.qca-pcm-i2s", + /* Codec DAI Name */ + .codec_dai_name = "qca-i2s-codec-dai", + /*Codec Driver Name */ + .codec_name = "qca_codec.0-0012", + .dai_fmt = (SND_SOC_DAIFMT_I2S | + SND_SOC_DAIFMT_NB_NF | + SND_SOC_DAIFMT_CBS_CFS), + }, + { + .name = "IPQ4019 Media2", + .stream_name = "TDM", + .cpu_dai_name = "qca-tdm-dai", + .platform_name = "7709000.qca-pcm-tdm", + .codec_dai_name = "qca-tdm-codec-dai", + .codec_name = "qca_codec.0-0012", + }, + { + .name = "IPQ4019 Media3", + .stream_name = "I2S1", + .cpu_dai_name = "qca-i2s1-dai", + .platform_name = "770b000.qca-pcm-i2s1", + .codec_dai_name = "qca-i2s1-codec-dai", + .codec_name = "qca_codec.0-0012", + }, + { + .name = "IPQ4019 Media4", + .stream_name = "I2S2", + .cpu_dai_name = "qca-i2s2-dai", + .platform_name = "770d000.qca-pcm-i2s2", + .codec_dai_name = "qca-i2s2-codec-dai", + .codec_name = "qca_codec.0-0012", + }, + { + .name = "IPQ4019 Media5", + .stream_name = "SPDIF", + .cpu_dai_name = "qca-spdif-dai", + .platform_name = "7707000.qca-pcm-spdif", + .codec_dai_name = "qca-spdif-codec-dai", + .codec_name = "qca_codec.0-0012", + }, +}; + +static struct snd_soc_card snd_soc_card_qca = { + .name = "ipq4019_snd_card", + .dai_link = ipq4019_snd_dai, + .num_links = ARRAY_SIZE(ipq4019_snd_dai), +}; + +static const struct of_device_id ipq4019_audio_id_table[] = { + { .compatible = "qca,ipq4019-audio" }, + {}, +}; +MODULE_DEVICE_TABLE(of, ipq4019_audio_id_table); + +static int ipq4019_audio_probe(struct platform_device *pdev) +{ + int ret; + struct snd_soc_card *card = &snd_soc_card_qca; + + card->dev = &pdev->dev; + + ret = devm_snd_soc_register_card(&pdev->dev, card); + if (ret) + dev_err(&pdev->dev, "snd_soc_register_card() failed:%d\n", ret); + + return ret; +} + +static struct platform_driver ipq4019_audio_driver = { + .driver = { + .name = "ipq4019_audio", + .of_match_table = ipq4019_audio_id_table, + }, + .probe = ipq4019_audio_probe, +}; + +module_platform_driver(ipq4019_audio_driver); + +MODULE_ALIAS("platform:ipq4019_audio"); +MODULE_LICENSE("Dual BSD/GPL"); +MODULE_DESCRIPTION("ALSA SoC IPQ4019 Machine Driver");