| /* |
| * Copyright (C) 2014-2015 Broadcom Corporation |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License as |
| * published by the Free Software Foundation version 2. |
| * |
| * This program is distributed "as is" WITHOUT ANY WARRANTY of any |
| * kind, whether express or implied; without even the implied warranty |
| * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| #include <linux/clk.h> |
| #include <linux/delay.h> |
| #include <linux/init.h> |
| #include <linux/io.h> |
| #include <linux/module.h> |
| #include <linux/of_device.h> |
| #include <linux/slab.h> |
| #include <sound/core.h> |
| #include <sound/pcm.h> |
| #include <sound/pcm_params.h> |
| #include <sound/soc.h> |
| #include <sound/soc-dai.h> |
| |
| #include "cygnus-ssp.h" |
| |
| #define DEFAULT_VCO 1354750204 |
| |
| #define CAPTURE_FCI_ID_BASE 0x180 |
| #define CYGNUS_SSP_TRISTATE_MASK 0x001fff |
| #define CYGNUS_PLLCLKSEL_MASK 0xf |
| |
| /* Used with stream_on field to indicate which streams are active */ |
| #define PLAYBACK_STREAM_MASK BIT(0) |
| #define CAPTURE_STREAM_MASK BIT(1) |
| |
| #define I2S_STREAM_CFG_MASK 0xff003ff |
| #define I2S_CAP_STREAM_CFG_MASK 0xf0 |
| #define SPDIF_STREAM_CFG_MASK 0x3ff |
| #define CH_GRP_STEREO 0x1 |
| |
| /* Begin register offset defines */ |
| #define AUD_MISC_SEROUT_OE_REG_BASE 0x01c |
| #define AUD_MISC_SEROUT_SPDIF_OE 12 |
| #define AUD_MISC_SEROUT_MCLK_OE 3 |
| #define AUD_MISC_SEROUT_LRCK_OE 2 |
| #define AUD_MISC_SEROUT_SCLK_OE 1 |
| #define AUD_MISC_SEROUT_SDAT_OE 0 |
| |
| /* AUD_FMM_BF_CTRL_xxx regs */ |
| #define BF_DST_CFG0_OFFSET 0x100 |
| #define BF_DST_CFG1_OFFSET 0x104 |
| #define BF_DST_CFG2_OFFSET 0x108 |
| |
| #define BF_DST_CTRL0_OFFSET 0x130 |
| #define BF_DST_CTRL1_OFFSET 0x134 |
| #define BF_DST_CTRL2_OFFSET 0x138 |
| |
| #define BF_SRC_CFG0_OFFSET 0x148 |
| #define BF_SRC_CFG1_OFFSET 0x14c |
| #define BF_SRC_CFG2_OFFSET 0x150 |
| #define BF_SRC_CFG3_OFFSET 0x154 |
| |
| #define BF_SRC_CTRL0_OFFSET 0x1c0 |
| #define BF_SRC_CTRL1_OFFSET 0x1c4 |
| #define BF_SRC_CTRL2_OFFSET 0x1c8 |
| #define BF_SRC_CTRL3_OFFSET 0x1cc |
| |
| #define BF_SRC_GRP0_OFFSET 0x1fc |
| #define BF_SRC_GRP1_OFFSET 0x200 |
| #define BF_SRC_GRP2_OFFSET 0x204 |
| #define BF_SRC_GRP3_OFFSET 0x208 |
| |
| #define BF_SRC_GRP_EN_OFFSET 0x320 |
| #define BF_SRC_GRP_FLOWON_OFFSET 0x324 |
| #define BF_SRC_GRP_SYNC_DIS_OFFSET 0x328 |
| |
| /* AUD_FMM_IOP_OUT_I2S_xxx regs */ |
| #define OUT_I2S_0_STREAM_CFG_OFFSET 0xa00 |
| #define OUT_I2S_0_CFG_OFFSET 0xa04 |
| #define OUT_I2S_0_MCLK_CFG_OFFSET 0xa0c |
| |
| #define OUT_I2S_1_STREAM_CFG_OFFSET 0xa40 |
| #define OUT_I2S_1_CFG_OFFSET 0xa44 |
| #define OUT_I2S_1_MCLK_CFG_OFFSET 0xa4c |
| |
| #define OUT_I2S_2_STREAM_CFG_OFFSET 0xa80 |
| #define OUT_I2S_2_CFG_OFFSET 0xa84 |
| #define OUT_I2S_2_MCLK_CFG_OFFSET 0xa8c |
| |
| /* AUD_FMM_IOP_OUT_SPDIF_xxx regs */ |
| #define SPDIF_STREAM_CFG_OFFSET 0xac0 |
| #define SPDIF_CTRL_OFFSET 0xac4 |
| #define SPDIF_FORMAT_CFG_OFFSET 0xad8 |
| #define SPDIF_MCLK_CFG_OFFSET 0xadc |
| |
| /* AUD_FMM_IOP_PLL_0_xxx regs */ |
| #define IOP_PLL_0_MACRO_OFFSET 0xb00 |
| #define IOP_PLL_0_MDIV_Ch0_OFFSET 0xb14 |
| #define IOP_PLL_0_MDIV_Ch1_OFFSET 0xb18 |
| #define IOP_PLL_0_MDIV_Ch2_OFFSET 0xb1c |
| |
| #define IOP_PLL_0_ACTIVE_MDIV_Ch0_OFFSET 0xb30 |
| #define IOP_PLL_0_ACTIVE_MDIV_Ch1_OFFSET 0xb34 |
| #define IOP_PLL_0_ACTIVE_MDIV_Ch2_OFFSET 0xb38 |
| |
| /* AUD_FMM_IOP_xxx regs */ |
| #define IOP_PLL_0_CONTROL_OFFSET 0xb04 |
| #define IOP_PLL_0_USER_NDIV_OFFSET 0xb08 |
| #define IOP_PLL_0_ACTIVE_NDIV_OFFSET 0xb20 |
| #define IOP_PLL_0_RESET_OFFSET 0xb5c |
| |
| /* AUD_FMM_IOP_IN_I2S_xxx regs */ |
| #define IN_I2S_0_STREAM_CFG_OFFSET 0x00 |
| #define IN_I2S_0_CFG_OFFSET 0x04 |
| #define IN_I2S_1_STREAM_CFG_OFFSET 0x40 |
| #define IN_I2S_1_CFG_OFFSET 0x44 |
| #define IN_I2S_2_STREAM_CFG_OFFSET 0x80 |
| #define IN_I2S_2_CFG_OFFSET 0x84 |
| |
| /* AUD_FMM_IOP_MISC_xxx regs */ |
| #define IOP_SW_INIT_LOGIC 0x1c0 |
| |
| /* End register offset defines */ |
| |
| |
| /* AUD_FMM_IOP_OUT_I2S_x_MCLK_CFG_0_REG */ |
| #define I2S_OUT_MCLKRATE_SHIFT 16 |
| |
| /* AUD_FMM_IOP_OUT_I2S_x_MCLK_CFG_REG */ |
| #define I2S_OUT_PLLCLKSEL_SHIFT 0 |
| |
| /* AUD_FMM_IOP_OUT_I2S_x_STREAM_CFG */ |
| #define I2S_OUT_STREAM_ENA 31 |
| #define I2S_OUT_STREAM_CFG_GROUP_ID 20 |
| #define I2S_OUT_STREAM_CFG_CHANNEL_GROUPING 24 |
| |
| /* AUD_FMM_IOP_IN_I2S_x_CAP */ |
| #define I2S_IN_STREAM_CFG_CAP_ENA 31 |
| #define I2S_IN_STREAM_CFG_0_GROUP_ID 4 |
| |
| /* AUD_FMM_IOP_OUT_I2S_x_I2S_CFG_REG */ |
| #define I2S_OUT_CFGX_CLK_ENA 0 |
| #define I2S_OUT_CFGX_DATA_ENABLE 1 |
| #define I2S_OUT_CFGX_DATA_ALIGNMENT 6 |
| #define I2S_OUT_CFGX_BITS_PER_SLOT 13 |
| #define I2S_OUT_CFGX_VALID_SLOT 14 |
| #define I2S_OUT_CFGX_FSYNC_WIDTH 18 |
| #define I2S_OUT_CFGX_SCLKS_PER_1FS_DIV32 26 |
| #define I2S_OUT_CFGX_SLAVE_MODE 30 |
| #define I2S_OUT_CFGX_TDM_MODE 31 |
| |
| /* AUD_FMM_BF_CTRL_SOURCECH_CFGx_REG */ |
| #define BF_SRC_CFGX_SFIFO_ENA 0 |
| #define BF_SRC_CFGX_BUFFER_PAIR_ENABLE 1 |
| #define BF_SRC_CFGX_SAMPLE_CH_MODE 2 |
| #define BF_SRC_CFGX_SFIFO_SZ_DOUBLE 5 |
| #define BF_SRC_CFGX_NOT_PAUSE_WHEN_EMPTY 10 |
| #define BF_SRC_CFGX_BIT_RES 20 |
| #define BF_SRC_CFGX_PROCESS_SEQ_ID_VALID 31 |
| |
| /* AUD_FMM_BF_CTRL_DESTCH_CFGx_REG */ |
| #define BF_DST_CFGX_CAP_ENA 0 |
| #define BF_DST_CFGX_BUFFER_PAIR_ENABLE 1 |
| #define BF_DST_CFGX_DFIFO_SZ_DOUBLE 2 |
| #define BF_DST_CFGX_NOT_PAUSE_WHEN_FULL 11 |
| #define BF_DST_CFGX_FCI_ID 12 |
| #define BF_DST_CFGX_CAP_MODE 24 |
| #define BF_DST_CFGX_PROC_SEQ_ID_VALID 31 |
| |
| /* AUD_FMM_IOP_OUT_SPDIF_xxx */ |
| #define SPDIF_0_OUT_DITHER_ENA 3 |
| #define SPDIF_0_OUT_STREAM_ENA 31 |
| |
| /* AUD_FMM_IOP_PLL_0_USER */ |
| #define IOP_PLL_0_USER_NDIV_FRAC 10 |
| |
| /* AUD_FMM_IOP_PLL_0_ACTIVE */ |
| #define IOP_PLL_0_ACTIVE_NDIV_FRAC 10 |
| |
| |
| #define INIT_SSP_REGS(num) (struct cygnus_ssp_regs){ \ |
| .i2s_stream_cfg = OUT_I2S_ ##num## _STREAM_CFG_OFFSET, \ |
| .i2s_cap_stream_cfg = IN_I2S_ ##num## _STREAM_CFG_OFFSET, \ |
| .i2s_cfg = OUT_I2S_ ##num## _CFG_OFFSET, \ |
| .i2s_cap_cfg = IN_I2S_ ##num## _CFG_OFFSET, \ |
| .i2s_mclk_cfg = OUT_I2S_ ##num## _MCLK_CFG_OFFSET, \ |
| .bf_destch_ctrl = BF_DST_CTRL ##num## _OFFSET, \ |
| .bf_destch_cfg = BF_DST_CFG ##num## _OFFSET, \ |
| .bf_sourcech_ctrl = BF_SRC_CTRL ##num## _OFFSET, \ |
| .bf_sourcech_cfg = BF_SRC_CFG ##num## _OFFSET, \ |
| .bf_sourcech_grp = BF_SRC_GRP ##num## _OFFSET \ |
| } |
| |
| struct pll_macro_entry { |
| u32 mclk; |
| u32 pll_ch_num; |
| }; |
| |
| /* |
| * PLL has 3 output channels (1x, 2x, and 4x). Below are |
| * the common MCLK frequencies used by audio driver |
| */ |
| static const struct pll_macro_entry pll_predef_mclk[] = { |
| { 4096000, 0}, |
| { 8192000, 1}, |
| {16384000, 2}, |
| |
| { 5644800, 0}, |
| {11289600, 1}, |
| {22579200, 2}, |
| |
| { 6144000, 0}, |
| {12288000, 1}, |
| {24576000, 2}, |
| |
| {12288000, 0}, |
| {24576000, 1}, |
| {49152000, 2}, |
| |
| {22579200, 0}, |
| {45158400, 1}, |
| {90316800, 2}, |
| |
| {24576000, 0}, |
| {49152000, 1}, |
| {98304000, 2}, |
| }; |
| |
| #define CYGNUS_RATE_MIN 8000 |
| #define CYGNUS_RATE_MAX 384000 |
| |
| /* List of valid frame sizes for tdm mode */ |
| static const int ssp_valid_tdm_framesize[] = {32, 64, 128, 256, 512}; |
| |
| static const unsigned int cygnus_rates[] = { |
| 8000, 11025, 16000, 22050, 32000, 44100, 48000, |
| 88200, 96000, 176400, 192000, 352800, 384000 |
| }; |
| |
| static const struct snd_pcm_hw_constraint_list cygnus_rate_constraint = { |
| .count = ARRAY_SIZE(cygnus_rates), |
| .list = cygnus_rates, |
| }; |
| |
| static struct cygnus_aio_port *cygnus_dai_get_portinfo(struct snd_soc_dai *dai) |
| { |
| struct cygnus_audio *cygaud = snd_soc_dai_get_drvdata(dai); |
| |
| return &cygaud->portinfo[dai->id]; |
| } |
| |
| static int audio_ssp_init_portregs(struct cygnus_aio_port *aio) |
| { |
| u32 value, fci_id; |
| int status = 0; |
| |
| switch (aio->port_type) { |
| case PORT_TDM: |
| value = readl(aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| value &= ~I2S_STREAM_CFG_MASK; |
| |
| /* Set Group ID */ |
| writel(aio->portnum, |
| aio->cygaud->audio + aio->regs.bf_sourcech_grp); |
| |
| /* Configure the AUD_FMM_IOP_OUT_I2S_x_STREAM_CFG reg */ |
| value |= aio->portnum << I2S_OUT_STREAM_CFG_GROUP_ID; |
| value |= aio->portnum; /* FCI ID is the port num */ |
| value |= CH_GRP_STEREO << I2S_OUT_STREAM_CFG_CHANNEL_GROUPING; |
| writel(value, aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| |
| /* Configure the AUD_FMM_BF_CTRL_SOURCECH_CFGX reg */ |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~BIT(BF_SRC_CFGX_NOT_PAUSE_WHEN_EMPTY); |
| value |= BIT(BF_SRC_CFGX_SFIFO_SZ_DOUBLE); |
| value |= BIT(BF_SRC_CFGX_PROCESS_SEQ_ID_VALID); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| /* Configure the AUD_FMM_IOP_IN_I2S_x_CAP_STREAM_CFG_0 reg */ |
| value = readl(aio->cygaud->i2s_in + |
| aio->regs.i2s_cap_stream_cfg); |
| value &= ~I2S_CAP_STREAM_CFG_MASK; |
| value |= aio->portnum << I2S_IN_STREAM_CFG_0_GROUP_ID; |
| writel(value, aio->cygaud->i2s_in + |
| aio->regs.i2s_cap_stream_cfg); |
| |
| /* Configure the AUD_FMM_BF_CTRL_DESTCH_CFGX_REG_BASE reg */ |
| fci_id = CAPTURE_FCI_ID_BASE + aio->portnum; |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| value |= BIT(BF_DST_CFGX_DFIFO_SZ_DOUBLE); |
| value &= ~BIT(BF_DST_CFGX_NOT_PAUSE_WHEN_FULL); |
| value |= (fci_id << BF_DST_CFGX_FCI_ID); |
| value |= BIT(BF_DST_CFGX_PROC_SEQ_ID_VALID); |
| writel(value, aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| |
| /* Enable the transmit pin for this port */ |
| value = readl(aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| value &= ~BIT((aio->portnum * 4) + AUD_MISC_SEROUT_SDAT_OE); |
| writel(value, aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| break; |
| case PORT_SPDIF: |
| writel(aio->portnum, aio->cygaud->audio + BF_SRC_GRP3_OFFSET); |
| |
| value = readl(aio->cygaud->audio + SPDIF_CTRL_OFFSET); |
| value |= BIT(SPDIF_0_OUT_DITHER_ENA); |
| writel(value, aio->cygaud->audio + SPDIF_CTRL_OFFSET); |
| |
| /* Enable and set the FCI ID for the SPDIF channel */ |
| value = readl(aio->cygaud->audio + SPDIF_STREAM_CFG_OFFSET); |
| value &= ~SPDIF_STREAM_CFG_MASK; |
| value |= aio->portnum; /* FCI ID is the port num */ |
| value |= BIT(SPDIF_0_OUT_STREAM_ENA); |
| writel(value, aio->cygaud->audio + SPDIF_STREAM_CFG_OFFSET); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~BIT(BF_SRC_CFGX_NOT_PAUSE_WHEN_EMPTY); |
| value |= BIT(BF_SRC_CFGX_SFIFO_SZ_DOUBLE); |
| value |= BIT(BF_SRC_CFGX_PROCESS_SEQ_ID_VALID); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| /* Enable the spdif output pin */ |
| value = readl(aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| value &= ~BIT(AUD_MISC_SEROUT_SPDIF_OE); |
| writel(value, aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| break; |
| default: |
| dev_err(aio->cygaud->dev, "Port not supported\n"); |
| status = -EINVAL; |
| } |
| |
| return status; |
| } |
| |
| static void audio_ssp_in_enable(struct cygnus_aio_port *aio) |
| { |
| u32 value; |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| value |= BIT(BF_DST_CFGX_CAP_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| |
| writel(0x1, aio->cygaud->audio + aio->regs.bf_destch_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value |= BIT(I2S_OUT_CFGX_CLK_ENA); |
| value |= BIT(I2S_OUT_CFGX_DATA_ENABLE); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| |
| value = readl(aio->cygaud->i2s_in + aio->regs.i2s_cap_stream_cfg); |
| value |= BIT(I2S_IN_STREAM_CFG_CAP_ENA); |
| writel(value, aio->cygaud->i2s_in + aio->regs.i2s_cap_stream_cfg); |
| |
| aio->streams_on |= CAPTURE_STREAM_MASK; |
| } |
| |
| static void audio_ssp_in_disable(struct cygnus_aio_port *aio) |
| { |
| u32 value; |
| |
| value = readl(aio->cygaud->i2s_in + aio->regs.i2s_cap_stream_cfg); |
| value &= ~BIT(I2S_IN_STREAM_CFG_CAP_ENA); |
| writel(value, aio->cygaud->i2s_in + aio->regs.i2s_cap_stream_cfg); |
| |
| aio->streams_on &= ~CAPTURE_STREAM_MASK; |
| |
| /* If both playback and capture are off */ |
| if (!aio->streams_on) { |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value &= ~BIT(I2S_OUT_CFGX_CLK_ENA); |
| value &= ~BIT(I2S_OUT_CFGX_DATA_ENABLE); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| } |
| |
| writel(0x0, aio->cygaud->audio + aio->regs.bf_destch_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| value &= ~BIT(BF_DST_CFGX_CAP_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_destch_cfg); |
| } |
| |
| static int audio_ssp_out_enable(struct cygnus_aio_port *aio) |
| { |
| u32 value; |
| int status = 0; |
| |
| switch (aio->port_type) { |
| case PORT_TDM: |
| value = readl(aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| value |= BIT(I2S_OUT_STREAM_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| |
| writel(1, aio->cygaud->audio + aio->regs.bf_sourcech_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value |= BIT(I2S_OUT_CFGX_CLK_ENA); |
| value |= BIT(I2S_OUT_CFGX_DATA_ENABLE); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value |= BIT(BF_SRC_CFGX_SFIFO_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| aio->streams_on |= PLAYBACK_STREAM_MASK; |
| break; |
| case PORT_SPDIF: |
| value = readl(aio->cygaud->audio + SPDIF_FORMAT_CFG_OFFSET); |
| value |= 0x3; |
| writel(value, aio->cygaud->audio + SPDIF_FORMAT_CFG_OFFSET); |
| |
| writel(1, aio->cygaud->audio + aio->regs.bf_sourcech_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value |= BIT(BF_SRC_CFGX_SFIFO_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| break; |
| default: |
| dev_err(aio->cygaud->dev, |
| "Port not supported %d\n", aio->portnum); |
| status = -EINVAL; |
| } |
| |
| return status; |
| } |
| |
| static int audio_ssp_out_disable(struct cygnus_aio_port *aio) |
| { |
| u32 value; |
| int status = 0; |
| |
| switch (aio->port_type) { |
| case PORT_TDM: |
| aio->streams_on &= ~PLAYBACK_STREAM_MASK; |
| |
| /* If both playback and capture are off */ |
| if (!aio->streams_on) { |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value &= ~BIT(I2S_OUT_CFGX_CLK_ENA); |
| value &= ~BIT(I2S_OUT_CFGX_DATA_ENABLE); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| } |
| |
| /* set group_sync_dis = 1 */ |
| value = readl(aio->cygaud->audio + BF_SRC_GRP_SYNC_DIS_OFFSET); |
| value |= BIT(aio->portnum); |
| writel(value, aio->cygaud->audio + BF_SRC_GRP_SYNC_DIS_OFFSET); |
| |
| writel(0, aio->cygaud->audio + aio->regs.bf_sourcech_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~BIT(BF_SRC_CFGX_SFIFO_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| /* set group_sync_dis = 0 */ |
| value = readl(aio->cygaud->audio + BF_SRC_GRP_SYNC_DIS_OFFSET); |
| value &= ~BIT(aio->portnum); |
| writel(value, aio->cygaud->audio + BF_SRC_GRP_SYNC_DIS_OFFSET); |
| |
| value = readl(aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| value &= ~BIT(I2S_OUT_STREAM_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_stream_cfg); |
| |
| /* IOP SW INIT on OUT_I2S_x */ |
| value = readl(aio->cygaud->i2s_in + IOP_SW_INIT_LOGIC); |
| value |= BIT(aio->portnum); |
| writel(value, aio->cygaud->i2s_in + IOP_SW_INIT_LOGIC); |
| value &= ~BIT(aio->portnum); |
| writel(value, aio->cygaud->i2s_in + IOP_SW_INIT_LOGIC); |
| break; |
| case PORT_SPDIF: |
| value = readl(aio->cygaud->audio + SPDIF_FORMAT_CFG_OFFSET); |
| value &= ~0x3; |
| writel(value, aio->cygaud->audio + SPDIF_FORMAT_CFG_OFFSET); |
| writel(0, aio->cygaud->audio + aio->regs.bf_sourcech_ctrl); |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~BIT(BF_SRC_CFGX_SFIFO_ENA); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| break; |
| default: |
| dev_err(aio->cygaud->dev, |
| "Port not supported %d\n", aio->portnum); |
| status = -EINVAL; |
| } |
| |
| return status; |
| } |
| |
| static int pll_configure_mclk(struct cygnus_audio *cygaud, u32 mclk, |
| struct cygnus_aio_port *aio) |
| { |
| int i = 0, error; |
| bool found = false; |
| const struct pll_macro_entry *p_entry; |
| struct clk *ch_clk; |
| |
| for (i = 0; i < ARRAY_SIZE(pll_predef_mclk); i++) { |
| p_entry = &pll_predef_mclk[i]; |
| if (p_entry->mclk == mclk) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| dev_err(cygaud->dev, |
| "%s No valid mclk freq (%u) found!\n", __func__, mclk); |
| return -EINVAL; |
| } |
| |
| ch_clk = cygaud->audio_clk[p_entry->pll_ch_num]; |
| |
| if ((aio->clk_trace.cap_en) && (!aio->clk_trace.cap_clk_en)) { |
| error = clk_prepare_enable(ch_clk); |
| if (error) { |
| dev_err(cygaud->dev, "%s clk_prepare_enable failed %d\n", |
| __func__, error); |
| return error; |
| } |
| aio->clk_trace.cap_clk_en = true; |
| } |
| |
| if ((aio->clk_trace.play_en) && (!aio->clk_trace.play_clk_en)) { |
| error = clk_prepare_enable(ch_clk); |
| if (error) { |
| dev_err(cygaud->dev, "%s clk_prepare_enable failed %d\n", |
| __func__, error); |
| return error; |
| } |
| aio->clk_trace.play_clk_en = true; |
| } |
| |
| error = clk_set_rate(ch_clk, mclk); |
| if (error) { |
| dev_err(cygaud->dev, "%s Set MCLK rate failed: %d\n", |
| __func__, error); |
| return error; |
| } |
| |
| return p_entry->pll_ch_num; |
| } |
| |
| static int cygnus_ssp_set_clocks(struct cygnus_aio_port *aio) |
| { |
| u32 value; |
| u32 mask = 0xf; |
| u32 sclk; |
| u32 mclk_rate; |
| unsigned int bit_rate; |
| unsigned int ratio; |
| |
| bit_rate = aio->bit_per_frame * aio->lrclk; |
| |
| /* |
| * Check if the bit clock can be generated from the given MCLK. |
| * MCLK must be a perfect multiple of bit clock and must be one of the |
| * following values... (2,4,6,8,10,12,14) |
| */ |
| if ((aio->mclk % bit_rate) != 0) |
| return -EINVAL; |
| |
| ratio = aio->mclk / bit_rate; |
| switch (ratio) { |
| case 2: |
| case 4: |
| case 6: |
| case 8: |
| case 10: |
| case 12: |
| case 14: |
| mclk_rate = ratio / 2; |
| break; |
| |
| default: |
| dev_err(aio->cygaud->dev, |
| "Invalid combination of MCLK and BCLK\n"); |
| dev_err(aio->cygaud->dev, "lrclk = %u, bits/frame = %u, mclk = %u\n", |
| aio->lrclk, aio->bit_per_frame, aio->mclk); |
| return -EINVAL; |
| } |
| |
| /* Set sclk rate */ |
| switch (aio->port_type) { |
| case PORT_TDM: |
| sclk = aio->bit_per_frame; |
| if (sclk == 512) |
| sclk = 0; |
| |
| /* sclks_per_1fs_div = sclk cycles/32 */ |
| sclk /= 32; |
| |
| /* Set number of bitclks per frame */ |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value &= ~(mask << I2S_OUT_CFGX_SCLKS_PER_1FS_DIV32); |
| value |= sclk << I2S_OUT_CFGX_SCLKS_PER_1FS_DIV32; |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| dev_dbg(aio->cygaud->dev, |
| "SCLKS_PER_1FS_DIV32 = 0x%x\n", value); |
| break; |
| case PORT_SPDIF: |
| break; |
| default: |
| dev_err(aio->cygaud->dev, "Unknown port type\n"); |
| return -EINVAL; |
| } |
| |
| /* Set MCLK_RATE ssp port (spdif and ssp are the same) */ |
| value = readl(aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| value &= ~(0xf << I2S_OUT_MCLKRATE_SHIFT); |
| value |= (mclk_rate << I2S_OUT_MCLKRATE_SHIFT); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| |
| dev_dbg(aio->cygaud->dev, "mclk cfg reg = 0x%x\n", value); |
| dev_dbg(aio->cygaud->dev, "bits per frame = %u, mclk = %u Hz, lrclk = %u Hz\n", |
| aio->bit_per_frame, aio->mclk, aio->lrclk); |
| return 0; |
| } |
| |
| static int cygnus_ssp_hw_params(struct snd_pcm_substream *substream, |
| struct snd_pcm_hw_params *params, |
| struct snd_soc_dai *dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(dai); |
| int rate, bitres; |
| u32 value; |
| u32 mask = 0x1f; |
| int ret = 0; |
| |
| dev_dbg(aio->cygaud->dev, "%s port = %d\n", __func__, aio->portnum); |
| dev_dbg(aio->cygaud->dev, "params_channels %d\n", |
| params_channels(params)); |
| dev_dbg(aio->cygaud->dev, "rate %d\n", params_rate(params)); |
| dev_dbg(aio->cygaud->dev, "format %d\n", params_format(params)); |
| |
| rate = params_rate(params); |
| |
| switch (aio->mode) { |
| case CYGNUS_SSPMODE_TDM: |
| if ((rate == 192000) && (params_channels(params) > 4)) { |
| dev_err(aio->cygaud->dev, "Cannot run %d channels at %dHz\n", |
| params_channels(params), rate); |
| return -EINVAL; |
| } |
| break; |
| case CYGNUS_SSPMODE_I2S: |
| aio->bit_per_frame = 64; /* I2S must be 64 bit per frame */ |
| break; |
| default: |
| dev_err(aio->cygaud->dev, |
| "%s port running in unknown mode\n", __func__); |
| return -EINVAL; |
| } |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~BIT(BF_SRC_CFGX_BUFFER_PAIR_ENABLE); |
| value &= ~BIT(BF_SRC_CFGX_SAMPLE_CH_MODE); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| switch (params_format(params)) { |
| case SNDRV_PCM_FORMAT_S16_LE: |
| bitres = 16; |
| break; |
| |
| case SNDRV_PCM_FORMAT_S32_LE: |
| /* 32 bit mode is coded as 0 */ |
| bitres = 0; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| value = readl(aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| value &= ~(mask << BF_SRC_CFGX_BIT_RES); |
| value |= (bitres << BF_SRC_CFGX_BIT_RES); |
| writel(value, aio->cygaud->audio + aio->regs.bf_sourcech_cfg); |
| |
| } else { |
| |
| switch (params_format(params)) { |
| case SNDRV_PCM_FORMAT_S16_LE: |
| value = readl(aio->cygaud->audio + |
| aio->regs.bf_destch_cfg); |
| value |= BIT(BF_DST_CFGX_CAP_MODE); |
| writel(value, aio->cygaud->audio + |
| aio->regs.bf_destch_cfg); |
| break; |
| |
| case SNDRV_PCM_FORMAT_S32_LE: |
| value = readl(aio->cygaud->audio + |
| aio->regs.bf_destch_cfg); |
| value &= ~BIT(BF_DST_CFGX_CAP_MODE); |
| writel(value, aio->cygaud->audio + |
| aio->regs.bf_destch_cfg); |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| } |
| |
| aio->lrclk = rate; |
| |
| if (!aio->is_slave) |
| ret = cygnus_ssp_set_clocks(aio); |
| |
| return ret; |
| } |
| |
| /* |
| * This function sets the mclk frequency for pll clock |
| */ |
| static int cygnus_ssp_set_sysclk(struct snd_soc_dai *dai, |
| int clk_id, unsigned int freq, int dir) |
| { |
| int sel; |
| u32 value; |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(dai); |
| struct cygnus_audio *cygaud = snd_soc_dai_get_drvdata(dai); |
| |
| dev_dbg(aio->cygaud->dev, |
| "%s Enter port = %d\n", __func__, aio->portnum); |
| sel = pll_configure_mclk(cygaud, freq, aio); |
| if (sel < 0) { |
| dev_err(aio->cygaud->dev, |
| "%s Setting mclk failed.\n", __func__); |
| return -EINVAL; |
| } |
| |
| aio->mclk = freq; |
| |
| dev_dbg(aio->cygaud->dev, "%s Setting MCLKSEL to %d\n", __func__, sel); |
| value = readl(aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| value &= ~(0xf << I2S_OUT_PLLCLKSEL_SHIFT); |
| value |= (sel << I2S_OUT_PLLCLKSEL_SHIFT); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| |
| return 0; |
| } |
| |
| static int cygnus_ssp_startup(struct snd_pcm_substream *substream, |
| struct snd_soc_dai *dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(dai); |
| |
| snd_soc_dai_set_dma_data(dai, substream, aio); |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| aio->clk_trace.play_en = true; |
| else |
| aio->clk_trace.cap_en = true; |
| |
| substream->runtime->hw.rate_min = CYGNUS_RATE_MIN; |
| substream->runtime->hw.rate_max = CYGNUS_RATE_MAX; |
| |
| snd_pcm_hw_constraint_list(substream->runtime, 0, |
| SNDRV_PCM_HW_PARAM_RATE, &cygnus_rate_constraint); |
| return 0; |
| } |
| |
| static void cygnus_ssp_shutdown(struct snd_pcm_substream *substream, |
| struct snd_soc_dai *dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(dai); |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| aio->clk_trace.play_en = false; |
| else |
| aio->clk_trace.cap_en = false; |
| |
| if (!aio->is_slave) { |
| u32 val; |
| |
| val = readl(aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| val &= CYGNUS_PLLCLKSEL_MASK; |
| if (val >= ARRAY_SIZE(aio->cygaud->audio_clk)) { |
| dev_err(aio->cygaud->dev, "Clk index %u is out of bounds\n", |
| val); |
| return; |
| } |
| |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { |
| if (aio->clk_trace.play_clk_en) { |
| clk_disable_unprepare(aio->cygaud-> |
| audio_clk[val]); |
| aio->clk_trace.play_clk_en = false; |
| } |
| } else { |
| if (aio->clk_trace.cap_clk_en) { |
| clk_disable_unprepare(aio->cygaud-> |
| audio_clk[val]); |
| aio->clk_trace.cap_clk_en = false; |
| } |
| } |
| } |
| } |
| |
| /* |
| * Bit Update Notes |
| * 31 Yes TDM Mode (1 = TDM, 0 = i2s) |
| * 30 Yes Slave Mode (1 = Slave, 0 = Master) |
| * 29:26 No Sclks per frame |
| * 25:18 Yes FS Width |
| * 17:14 No Valid Slots |
| * 13 No Bits (1 = 16 bits, 0 = 32 bits) |
| * 12:08 No Bits per samp |
| * 07 Yes Justifcation (1 = LSB, 0 = MSB) |
| * 06 Yes Alignment (1 = Delay 1 clk, 0 = no delay |
| * 05 Yes SCLK polarity (1 = Rising, 0 = Falling) |
| * 04 Yes LRCLK Polarity (1 = High for left, 0 = Low for left) |
| * 03:02 Yes Reserved - write as zero |
| * 01 No Data Enable |
| * 00 No CLK Enable |
| */ |
| #define I2S_OUT_CFG_REG_UPDATE_MASK 0x3C03FF03 |
| |
| /* Input cfg is same as output, but the FS width is not a valid field */ |
| #define I2S_IN_CFG_REG_UPDATE_MASK (I2S_OUT_CFG_REG_UPDATE_MASK | 0x03FC0000) |
| |
| int cygnus_ssp_set_custom_fsync_width(struct snd_soc_dai *cpu_dai, int len) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(cpu_dai); |
| |
| if ((len > 0) && (len < 256)) { |
| aio->fsync_width = len; |
| return 0; |
| } else { |
| return -EINVAL; |
| } |
| } |
| EXPORT_SYMBOL_GPL(cygnus_ssp_set_custom_fsync_width); |
| |
| static int cygnus_ssp_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(cpu_dai); |
| u32 ssp_curcfg; |
| u32 ssp_newcfg; |
| u32 ssp_outcfg; |
| u32 ssp_incfg; |
| u32 val; |
| u32 mask; |
| |
| dev_dbg(aio->cygaud->dev, "%s Enter fmt: %x\n", __func__, fmt); |
| |
| if (aio->port_type == PORT_SPDIF) |
| return -EINVAL; |
| |
| ssp_newcfg = 0; |
| |
| switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { |
| case SND_SOC_DAIFMT_CBM_CFM: |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_SLAVE_MODE); |
| aio->is_slave = 1; |
| break; |
| case SND_SOC_DAIFMT_CBS_CFS: |
| ssp_newcfg &= ~BIT(I2S_OUT_CFGX_SLAVE_MODE); |
| aio->is_slave = 0; |
| break; |
| default: |
| return -EINVAL; |
| } |
| |
| switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { |
| case SND_SOC_DAIFMT_I2S: |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_DATA_ALIGNMENT); |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_FSYNC_WIDTH); |
| aio->mode = CYGNUS_SSPMODE_I2S; |
| break; |
| |
| case SND_SOC_DAIFMT_DSP_A: |
| case SND_SOC_DAIFMT_DSP_B: |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_TDM_MODE); |
| |
| /* DSP_A = data after FS, DSP_B = data during FS */ |
| if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_DSP_A) |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_DATA_ALIGNMENT); |
| |
| if ((aio->fsync_width > 0) && (aio->fsync_width < 256)) |
| ssp_newcfg |= |
| (aio->fsync_width << I2S_OUT_CFGX_FSYNC_WIDTH); |
| else |
| ssp_newcfg |= BIT(I2S_OUT_CFGX_FSYNC_WIDTH); |
| |
| aio->mode = CYGNUS_SSPMODE_TDM; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| /* |
| * SSP out cfg. |
| * Retain bits we do not want to update, then OR in new bits |
| */ |
| ssp_curcfg = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| ssp_outcfg = (ssp_curcfg & I2S_OUT_CFG_REG_UPDATE_MASK) | ssp_newcfg; |
| writel(ssp_outcfg, aio->cygaud->audio + aio->regs.i2s_cfg); |
| |
| /* |
| * SSP in cfg. |
| * Retain bits we do not want to update, then OR in new bits |
| */ |
| ssp_curcfg = readl(aio->cygaud->i2s_in + aio->regs.i2s_cap_cfg); |
| ssp_incfg = (ssp_curcfg & I2S_IN_CFG_REG_UPDATE_MASK) | ssp_newcfg; |
| writel(ssp_incfg, aio->cygaud->i2s_in + aio->regs.i2s_cap_cfg); |
| |
| val = readl(aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| |
| /* |
| * Configure the word clk and bit clk as output or tristate |
| * Each port has 4 bits for controlling its pins. |
| * Shift the mask based upon port number. |
| */ |
| mask = BIT(AUD_MISC_SEROUT_LRCK_OE) |
| | BIT(AUD_MISC_SEROUT_SCLK_OE) |
| | BIT(AUD_MISC_SEROUT_MCLK_OE); |
| mask = mask << (aio->portnum * 4); |
| if (aio->is_slave) |
| /* Set bit for tri-state */ |
| val |= mask; |
| else |
| /* Clear bit for drive */ |
| val &= ~mask; |
| |
| dev_dbg(aio->cygaud->dev, "%s Set OE bits 0x%x\n", __func__, val); |
| writel(val, aio->cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| |
| return 0; |
| } |
| |
| static int cygnus_ssp_trigger(struct snd_pcm_substream *substream, int cmd, |
| struct snd_soc_dai *dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(dai); |
| struct cygnus_audio *cygaud = snd_soc_dai_get_drvdata(dai); |
| |
| dev_dbg(aio->cygaud->dev, |
| "%s cmd %d at port = %d\n", __func__, cmd, aio->portnum); |
| |
| switch (cmd) { |
| case SNDRV_PCM_TRIGGER_START: |
| case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: |
| case SNDRV_PCM_TRIGGER_RESUME: |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| audio_ssp_out_enable(aio); |
| else |
| audio_ssp_in_enable(aio); |
| cygaud->active_ports++; |
| |
| break; |
| |
| case SNDRV_PCM_TRIGGER_STOP: |
| case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
| case SNDRV_PCM_TRIGGER_SUSPEND: |
| if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
| audio_ssp_out_disable(aio); |
| else |
| audio_ssp_in_disable(aio); |
| cygaud->active_ports--; |
| break; |
| |
| default: |
| return -EINVAL; |
| } |
| |
| return 0; |
| } |
| |
| static int cygnus_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, |
| unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(cpu_dai); |
| u32 value; |
| int bits_per_slot = 0; /* default to 32-bits per slot */ |
| int frame_bits; |
| unsigned int active_slots; |
| bool found = false; |
| int i; |
| |
| if (tx_mask != rx_mask) { |
| dev_err(aio->cygaud->dev, |
| "%s tx_mask must equal rx_mask\n", __func__); |
| return -EINVAL; |
| } |
| |
| active_slots = hweight32(tx_mask); |
| |
| if (active_slots > 16) |
| return -EINVAL; |
| |
| /* Slot value must be even */ |
| if (active_slots % 2) |
| return -EINVAL; |
| |
| /* We encode 16 slots as 0 in the reg */ |
| if (active_slots == 16) |
| active_slots = 0; |
| |
| /* Slot Width is either 16 or 32 */ |
| switch (slot_width) { |
| case 16: |
| bits_per_slot = 1; |
| break; |
| case 32: |
| bits_per_slot = 0; |
| break; |
| default: |
| bits_per_slot = 0; |
| dev_warn(aio->cygaud->dev, |
| "%s Defaulting Slot Width to 32\n", __func__); |
| } |
| |
| frame_bits = slots * slot_width; |
| |
| for (i = 0; i < ARRAY_SIZE(ssp_valid_tdm_framesize); i++) { |
| if (ssp_valid_tdm_framesize[i] == frame_bits) { |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| dev_err(aio->cygaud->dev, |
| "%s In TDM mode, frame bits INVALID (%d)\n", |
| __func__, frame_bits); |
| return -EINVAL; |
| } |
| |
| aio->bit_per_frame = frame_bits; |
| |
| dev_dbg(aio->cygaud->dev, "%s active_slots %u, bits per frame %d\n", |
| __func__, active_slots, frame_bits); |
| |
| /* Set capture side of ssp port */ |
| value = readl(aio->cygaud->i2s_in + aio->regs.i2s_cap_cfg); |
| value &= ~(0xf << I2S_OUT_CFGX_VALID_SLOT); |
| value |= (active_slots << I2S_OUT_CFGX_VALID_SLOT); |
| value &= ~BIT(I2S_OUT_CFGX_BITS_PER_SLOT); |
| value |= (bits_per_slot << I2S_OUT_CFGX_BITS_PER_SLOT); |
| writel(value, aio->cygaud->i2s_in + aio->regs.i2s_cap_cfg); |
| |
| /* Set playback side of ssp port */ |
| value = readl(aio->cygaud->audio + aio->regs.i2s_cfg); |
| value &= ~(0xf << I2S_OUT_CFGX_VALID_SLOT); |
| value |= (active_slots << I2S_OUT_CFGX_VALID_SLOT); |
| value &= ~BIT(I2S_OUT_CFGX_BITS_PER_SLOT); |
| value |= (bits_per_slot << I2S_OUT_CFGX_BITS_PER_SLOT); |
| writel(value, aio->cygaud->audio + aio->regs.i2s_cfg); |
| |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM_SLEEP |
| static int cygnus_ssp_suspend(struct snd_soc_dai *cpu_dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(cpu_dai); |
| |
| if (!aio->is_slave) { |
| u32 val; |
| |
| val = readl(aio->cygaud->audio + aio->regs.i2s_mclk_cfg); |
| val &= CYGNUS_PLLCLKSEL_MASK; |
| if (val >= ARRAY_SIZE(aio->cygaud->audio_clk)) { |
| dev_err(aio->cygaud->dev, "Clk index %u is out of bounds\n", |
| val); |
| return -EINVAL; |
| } |
| |
| if (aio->clk_trace.cap_clk_en) |
| clk_disable_unprepare(aio->cygaud->audio_clk[val]); |
| if (aio->clk_trace.play_clk_en) |
| clk_disable_unprepare(aio->cygaud->audio_clk[val]); |
| |
| aio->pll_clk_num = val; |
| } |
| |
| return 0; |
| } |
| |
| static int cygnus_ssp_resume(struct snd_soc_dai *cpu_dai) |
| { |
| struct cygnus_aio_port *aio = cygnus_dai_get_portinfo(cpu_dai); |
| int error; |
| |
| if (!aio->is_slave) { |
| if (aio->clk_trace.cap_clk_en) { |
| error = clk_prepare_enable(aio->cygaud-> |
| audio_clk[aio->pll_clk_num]); |
| if (error) { |
| dev_err(aio->cygaud->dev, "%s clk_prepare_enable failed\n", |
| __func__); |
| return -EINVAL; |
| } |
| } |
| if (aio->clk_trace.play_clk_en) { |
| error = clk_prepare_enable(aio->cygaud-> |
| audio_clk[aio->pll_clk_num]); |
| if (error) { |
| if (aio->clk_trace.cap_clk_en) |
| clk_disable_unprepare(aio->cygaud-> |
| audio_clk[aio->pll_clk_num]); |
| dev_err(aio->cygaud->dev, "%s clk_prepare_enable failed\n", |
| __func__); |
| return -EINVAL; |
| } |
| } |
| } |
| |
| return 0; |
| } |
| #else |
| #define cygnus_ssp_suspend NULL |
| #define cygnus_ssp_resume NULL |
| #endif |
| |
| static const struct snd_soc_dai_ops cygnus_ssp_dai_ops = { |
| .startup = cygnus_ssp_startup, |
| .shutdown = cygnus_ssp_shutdown, |
| .trigger = cygnus_ssp_trigger, |
| .hw_params = cygnus_ssp_hw_params, |
| .set_fmt = cygnus_ssp_set_fmt, |
| .set_sysclk = cygnus_ssp_set_sysclk, |
| .set_tdm_slot = cygnus_set_dai_tdm_slot, |
| }; |
| |
| static const struct snd_soc_dai_ops cygnus_spdif_dai_ops = { |
| .startup = cygnus_ssp_startup, |
| .shutdown = cygnus_ssp_shutdown, |
| .trigger = cygnus_ssp_trigger, |
| .hw_params = cygnus_ssp_hw_params, |
| .set_sysclk = cygnus_ssp_set_sysclk, |
| }; |
| |
| #define INIT_CPU_DAI(num) { \ |
| .name = "cygnus-ssp" #num, \ |
| .playback = { \ |
| .channels_min = 2, \ |
| .channels_max = 16, \ |
| .rates = SNDRV_PCM_RATE_KNOT, \ |
| .formats = SNDRV_PCM_FMTBIT_S16_LE | \ |
| SNDRV_PCM_FMTBIT_S32_LE, \ |
| }, \ |
| .capture = { \ |
| .channels_min = 2, \ |
| .channels_max = 16, \ |
| .rates = SNDRV_PCM_RATE_KNOT, \ |
| .formats = SNDRV_PCM_FMTBIT_S16_LE | \ |
| SNDRV_PCM_FMTBIT_S32_LE, \ |
| }, \ |
| .ops = &cygnus_ssp_dai_ops, \ |
| .suspend = cygnus_ssp_suspend, \ |
| .resume = cygnus_ssp_resume, \ |
| } |
| |
| static const struct snd_soc_dai_driver cygnus_ssp_dai_info[] = { |
| INIT_CPU_DAI(0), |
| INIT_CPU_DAI(1), |
| INIT_CPU_DAI(2), |
| }; |
| |
| static const struct snd_soc_dai_driver cygnus_spdif_dai_info = { |
| .name = "cygnus-spdif", |
| .playback = { |
| .channels_min = 2, |
| .channels_max = 2, |
| .rates = SNDRV_PCM_RATE_KNOT, |
| .formats = SNDRV_PCM_FMTBIT_S16_LE | |
| SNDRV_PCM_FMTBIT_S32_LE, |
| }, |
| .ops = &cygnus_spdif_dai_ops, |
| .suspend = cygnus_ssp_suspend, |
| .resume = cygnus_ssp_resume, |
| }; |
| |
| static struct snd_soc_dai_driver cygnus_ssp_dai[CYGNUS_MAX_PORTS]; |
| |
| static const struct snd_soc_component_driver cygnus_ssp_component = { |
| .name = "cygnus-audio", |
| }; |
| |
| /* |
| * Return < 0 if error |
| * Return 0 if disabled |
| * Return 1 if enabled and node is parsed successfully |
| */ |
| static int parse_ssp_child_node(struct platform_device *pdev, |
| struct device_node *dn, |
| struct cygnus_audio *cygaud, |
| struct snd_soc_dai_driver *p_dai) |
| { |
| struct cygnus_aio_port *aio; |
| struct cygnus_ssp_regs ssp_regs[3]; |
| u32 rawval; |
| int portnum = -1; |
| enum cygnus_audio_port_type port_type; |
| |
| if (of_property_read_u32(dn, "reg", &rawval)) { |
| dev_err(&pdev->dev, "Missing reg property\n"); |
| return -EINVAL; |
| } |
| |
| portnum = rawval; |
| switch (rawval) { |
| case 0: |
| ssp_regs[0] = INIT_SSP_REGS(0); |
| port_type = PORT_TDM; |
| break; |
| case 1: |
| ssp_regs[1] = INIT_SSP_REGS(1); |
| port_type = PORT_TDM; |
| break; |
| case 2: |
| ssp_regs[2] = INIT_SSP_REGS(2); |
| port_type = PORT_TDM; |
| break; |
| case 3: |
| port_type = PORT_SPDIF; |
| break; |
| default: |
| dev_err(&pdev->dev, "Bad value for reg %u\n", rawval); |
| return -EINVAL; |
| } |
| |
| aio = &cygaud->portinfo[portnum]; |
| aio->cygaud = cygaud; |
| aio->portnum = portnum; |
| aio->port_type = port_type; |
| aio->fsync_width = -1; |
| |
| switch (port_type) { |
| case PORT_TDM: |
| aio->regs = ssp_regs[portnum]; |
| *p_dai = cygnus_ssp_dai_info[portnum]; |
| aio->mode = CYGNUS_SSPMODE_UNKNOWN; |
| break; |
| |
| case PORT_SPDIF: |
| aio->regs.bf_sourcech_cfg = BF_SRC_CFG3_OFFSET; |
| aio->regs.bf_sourcech_ctrl = BF_SRC_CTRL3_OFFSET; |
| aio->regs.i2s_mclk_cfg = SPDIF_MCLK_CFG_OFFSET; |
| aio->regs.i2s_stream_cfg = SPDIF_STREAM_CFG_OFFSET; |
| *p_dai = cygnus_spdif_dai_info; |
| |
| /* For the purposes of this code SPDIF can be I2S mode */ |
| aio->mode = CYGNUS_SSPMODE_I2S; |
| break; |
| default: |
| dev_err(&pdev->dev, "Bad value for port_type %d\n", port_type); |
| return -EINVAL; |
| } |
| |
| dev_dbg(&pdev->dev, "%s portnum = %d\n", __func__, aio->portnum); |
| aio->streams_on = 0; |
| aio->cygaud->dev = &pdev->dev; |
| aio->clk_trace.play_en = false; |
| aio->clk_trace.cap_en = false; |
| |
| audio_ssp_init_portregs(aio); |
| return 0; |
| } |
| |
| static int audio_clk_init(struct platform_device *pdev, |
| struct cygnus_audio *cygaud) |
| { |
| int i; |
| char clk_name[PROP_LEN_MAX]; |
| |
| for (i = 0; i < ARRAY_SIZE(cygaud->audio_clk); i++) { |
| snprintf(clk_name, PROP_LEN_MAX, "ch%d_audio", i); |
| |
| cygaud->audio_clk[i] = devm_clk_get(&pdev->dev, clk_name); |
| if (IS_ERR(cygaud->audio_clk[i])) |
| return PTR_ERR(cygaud->audio_clk[i]); |
| } |
| |
| return 0; |
| } |
| |
| static int cygnus_ssp_probe(struct platform_device *pdev) |
| { |
| struct device *dev = &pdev->dev; |
| struct device_node *child_node; |
| struct resource *res = pdev->resource; |
| struct cygnus_audio *cygaud; |
| int err = -EINVAL; |
| int node_count; |
| int active_port_count; |
| |
| cygaud = devm_kzalloc(dev, sizeof(struct cygnus_audio), GFP_KERNEL); |
| if (!cygaud) |
| return -ENOMEM; |
| |
| dev_set_drvdata(dev, cygaud); |
| |
| res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "aud"); |
| cygaud->audio = devm_ioremap_resource(dev, res); |
| if (IS_ERR(cygaud->audio)) |
| return PTR_ERR(cygaud->audio); |
| |
| res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "i2s_in"); |
| cygaud->i2s_in = devm_ioremap_resource(dev, res); |
| if (IS_ERR(cygaud->i2s_in)) |
| return PTR_ERR(cygaud->i2s_in); |
| |
| /* Tri-state all controlable pins until we know that we need them */ |
| writel(CYGNUS_SSP_TRISTATE_MASK, |
| cygaud->audio + AUD_MISC_SEROUT_OE_REG_BASE); |
| |
| node_count = of_get_child_count(pdev->dev.of_node); |
| if ((node_count < 1) || (node_count > CYGNUS_MAX_PORTS)) { |
| dev_err(dev, "child nodes is %d. Must be between 1 and %d\n", |
| node_count, CYGNUS_MAX_PORTS); |
| return -EINVAL; |
| } |
| |
| active_port_count = 0; |
| |
| for_each_available_child_of_node(pdev->dev.of_node, child_node) { |
| err = parse_ssp_child_node(pdev, child_node, cygaud, |
| &cygnus_ssp_dai[active_port_count]); |
| |
| /* negative is err, 0 is active and good, 1 is disabled */ |
| if (err < 0) |
| return err; |
| else if (!err) { |
| dev_dbg(dev, "Activating DAI: %s\n", |
| cygnus_ssp_dai[active_port_count].name); |
| active_port_count++; |
| } |
| } |
| |
| cygaud->dev = dev; |
| cygaud->active_ports = 0; |
| |
| dev_dbg(dev, "Registering %d DAIs\n", active_port_count); |
| err = snd_soc_register_component(dev, &cygnus_ssp_component, |
| cygnus_ssp_dai, active_port_count); |
| if (err) { |
| dev_err(dev, "snd_soc_register_dai failed\n"); |
| return err; |
| } |
| |
| cygaud->irq_num = platform_get_irq(pdev, 0); |
| if (cygaud->irq_num <= 0) { |
| dev_err(dev, "platform_get_irq failed\n"); |
| err = cygaud->irq_num; |
| goto err_irq; |
| } |
| |
| err = audio_clk_init(pdev, cygaud); |
| if (err) { |
| dev_err(dev, "audio clock initialization failed\n"); |
| goto err_irq; |
| } |
| |
| err = cygnus_soc_platform_register(dev, cygaud); |
| if (err) { |
| dev_err(dev, "platform reg error %d\n", err); |
| goto err_irq; |
| } |
| |
| return 0; |
| |
| err_irq: |
| snd_soc_unregister_component(dev); |
| return err; |
| } |
| |
| static int cygnus_ssp_remove(struct platform_device *pdev) |
| { |
| cygnus_soc_platform_unregister(&pdev->dev); |
| snd_soc_unregister_component(&pdev->dev); |
| |
| return 0; |
| } |
| |
| static const struct of_device_id cygnus_ssp_of_match[] = { |
| { .compatible = "brcm,cygnus-audio" }, |
| {}, |
| }; |
| MODULE_DEVICE_TABLE(of, cygnus_ssp_of_match); |
| |
| static struct platform_driver cygnus_ssp_driver = { |
| .probe = cygnus_ssp_probe, |
| .remove = cygnus_ssp_remove, |
| .driver = { |
| .name = "cygnus-ssp", |
| .of_match_table = cygnus_ssp_of_match, |
| }, |
| }; |
| |
| module_platform_driver(cygnus_ssp_driver); |
| |
| MODULE_ALIAS("platform:cygnus-ssp"); |
| MODULE_LICENSE("GPL v2"); |
| MODULE_AUTHOR("Broadcom"); |
| MODULE_DESCRIPTION("Cygnus ASoC SSP Interface"); |