sound/soc/codecs/lpass-wsa-macro.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 // Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
   3
   4 #include <linux/module.h>
   5 #include <linux/init.h>
   6 #include <linux/io.h>
   7 #include <linux/platform_device.h>
   8 #include <linux/clk.h>
   9 #include <linux/of_clk.h>
  10 #include <linux/clk-provider.h>
  11 #include <sound/soc.h>
  12 #include <sound/soc-dapm.h>
  13 #include <linux/of_platform.h>
  14 #include <sound/tlv.h>
  15 #include "lpass-wsa-macro.h"
  16
  17 #define CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL       (0x0000)
  18 #define CDC_WSA_MCLK_EN_MASK                    BIT(0)
  19 #define CDC_WSA_MCLK_ENABLE                     BIT(0)
  20 #define CDC_WSA_MCLK_DISABLE                    0
  21 #define CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL     (0x0004)
  22 #define CDC_WSA_FS_CNT_EN_MASK                  BIT(0)
  23 #define CDC_WSA_FS_CNT_ENABLE                   BIT(0)
  24 #define CDC_WSA_FS_CNT_DISABLE                  0
  25 #define CDC_WSA_CLK_RST_CTRL_SWR_CONTROL        (0x0008)
  26 #define CDC_WSA_SWR_CLK_EN_MASK                 BIT(0)
  27 #define CDC_WSA_SWR_CLK_ENABLE                  BIT(0)
  28 #define CDC_WSA_SWR_RST_EN_MASK                 BIT(1)
  29 #define CDC_WSA_SWR_RST_ENABLE                  BIT(1)
  30 #define CDC_WSA_SWR_RST_DISABLE                 0
  31 #define CDC_WSA_TOP_TOP_CFG0                    (0x0080)
  32 #define CDC_WSA_TOP_TOP_CFG1                    (0x0084)
  33 #define CDC_WSA_TOP_FREQ_MCLK                   (0x0088)
  34 #define CDC_WSA_TOP_DEBUG_BUS_SEL               (0x008C)
  35 #define CDC_WSA_TOP_DEBUG_EN0                   (0x0090)
  36 #define CDC_WSA_TOP_DEBUG_EN1                   (0x0094)
  37 #define CDC_WSA_TOP_DEBUG_DSM_LB                (0x0098)
  38 #define CDC_WSA_TOP_RX_I2S_CTL                  (0x009C)
  39 #define CDC_WSA_TOP_TX_I2S_CTL                  (0x00A0)
  40 #define CDC_WSA_TOP_I2S_CLK                     (0x00A4)
  41 #define CDC_WSA_TOP_I2S_RESET                   (0x00A8)
  42 #define CDC_WSA_RX_INP_MUX_RX_INT0_CFG0         (0x0100)
  43 #define CDC_WSA_RX_INTX_1_MIX_INP0_SEL_MASK     GENMASK(2, 0)
  44 #define CDC_WSA_RX_INTX_1_MIX_INP1_SEL_MASK     GENMASK(5, 3)
  45 #define CDC_WSA_RX_INP_MUX_RX_INT0_CFG1         (0x0104)
  46 #define CDC_WSA_RX_INTX_2_SEL_MASK              GENMASK(2, 0)
  47 #define CDC_WSA_RX_INTX_1_MIX_INP2_SEL_MASK     GENMASK(5, 3)
  48 #define CDC_WSA_RX_INP_MUX_RX_INT1_CFG0         (0x0108)
  49 #define CDC_WSA_RX_INP_MUX_RX_INT1_CFG1         (0x010C)
  50 #define CDC_WSA_RX_INP_MUX_RX_MIX_CFG0          (0x0110)
  51 #define CDC_WSA_RX_MIX_TX1_SEL_MASK             GENMASK(5, 3)
  52 #define CDC_WSA_RX_MIX_TX1_SEL_SHFT             3
  53 #define CDC_WSA_RX_MIX_TX0_SEL_MASK             GENMASK(2, 0)
  54 #define CDC_WSA_RX_INP_MUX_RX_EC_CFG0           (0x0114)
  55 #define CDC_WSA_RX_INP_MUX_SOFTCLIP_CFG0        (0x0118)
  56 #define CDC_WSA_TX0_SPKR_PROT_PATH_CTL          (0x0244)
  57 #define CDC_WSA_TX_SPKR_PROT_RESET_MASK         BIT(5)
  58 #define CDC_WSA_TX_SPKR_PROT_RESET              BIT(5)
  59 #define CDC_WSA_TX_SPKR_PROT_NO_RESET           0
  60 #define CDC_WSA_TX_SPKR_PROT_CLK_EN_MASK        BIT(4)
  61 #define CDC_WSA_TX_SPKR_PROT_CLK_ENABLE         BIT(4)
  62 #define CDC_WSA_TX_SPKR_PROT_CLK_DISABLE        0
  63 #define CDC_WSA_TX_SPKR_PROT_PCM_RATE_MASK      GENMASK(3, 0)
  64 #define CDC_WSA_TX_SPKR_PROT_PCM_RATE_8K        0
  65 #define CDC_WSA_TX0_SPKR_PROT_PATH_CFG0         (0x0248)
  66 #define CDC_WSA_TX1_SPKR_PROT_PATH_CTL          (0x0264)
  67 #define CDC_WSA_TX1_SPKR_PROT_PATH_CFG0         (0x0268)
  68 #define CDC_WSA_TX2_SPKR_PROT_PATH_CTL          (0x0284)
  69 #define CDC_WSA_TX2_SPKR_PROT_PATH_CFG0         (0x0288)
  70 #define CDC_WSA_TX3_SPKR_PROT_PATH_CTL          (0x02A4)
  71 #define CDC_WSA_TX3_SPKR_PROT_PATH_CFG0         (0x02A8)
  72 #define CDC_WSA_INTR_CTRL_CFG                   (0x0340)
  73 #define CDC_WSA_INTR_CTRL_CLR_COMMIT            (0x0344)
  74 #define CDC_WSA_INTR_CTRL_PIN1_MASK0            (0x0360)
  75 #define CDC_WSA_INTR_CTRL_PIN1_STATUS0          (0x0368)
  76 #define CDC_WSA_INTR_CTRL_PIN1_CLEAR0           (0x0370)
  77 #define CDC_WSA_INTR_CTRL_PIN2_MASK0            (0x0380)
  78 #define CDC_WSA_INTR_CTRL_PIN2_STATUS0          (0x0388)
  79 #define CDC_WSA_INTR_CTRL_PIN2_CLEAR0           (0x0390)
  80 #define CDC_WSA_INTR_CTRL_LEVEL0                (0x03C0)
  81 #define CDC_WSA_INTR_CTRL_BYPASS0               (0x03C8)
  82 #define CDC_WSA_INTR_CTRL_SET0                  (0x03D0)
  83 #define CDC_WSA_RX0_RX_PATH_CTL                 (0x0400)
  84 #define CDC_WSA_RX_PATH_CLK_EN_MASK             BIT(5)
  85 #define CDC_WSA_RX_PATH_CLK_ENABLE              BIT(5)
  86 #define CDC_WSA_RX_PATH_CLK_DISABLE             0
  87 #define CDC_WSA_RX_PATH_PGA_MUTE_EN_MASK        BIT(4)
  88 #define CDC_WSA_RX_PATH_PGA_MUTE_ENABLE         BIT(4)
  89 #define CDC_WSA_RX_PATH_PGA_MUTE_DISABLE        0
  90 #define CDC_WSA_RX0_RX_PATH_CFG0                (0x0404)
  91 #define CDC_WSA_RX_PATH_COMP_EN_MASK            BIT(1)
  92 #define CDC_WSA_RX_PATH_COMP_ENABLE             BIT(1)
  93 #define CDC_WSA_RX_PATH_HD2_EN_MASK             BIT(2)
  94 #define CDC_WSA_RX_PATH_HD2_ENABLE              BIT(2)
  95 #define CDC_WSA_RX_PATH_SPKR_RATE_MASK          BIT(3)
  96 #define CDC_WSA_RX_PATH_SPKR_RATE_FS_2P4_3P072  BIT(3)
  97 #define CDC_WSA_RX0_RX_PATH_CFG1                (0x0408)
  98 #define CDC_WSA_RX_PATH_SMART_BST_EN_MASK       BIT(0)
  99 #define CDC_WSA_RX_PATH_SMART_BST_ENABLE        BIT(0)
 100 #define CDC_WSA_RX_PATH_SMART_BST_DISABLE       0
 101 #define CDC_WSA_RX0_RX_PATH_CFG2                (0x040C)
 102 #define CDC_WSA_RX0_RX_PATH_CFG3                (0x0410)
 103 #define CDC_WSA_RX_DC_DCOEFF_MASK               GENMASK(1, 0)
 104 #define CDC_WSA_RX0_RX_VOL_CTL                  (0x0414)
 105 #define CDC_WSA_RX0_RX_PATH_MIX_CTL             (0x0418)
 106 #define CDC_WSA_RX_PATH_MIX_CLK_EN_MASK         BIT(5)
 107 #define CDC_WSA_RX_PATH_MIX_CLK_ENABLE          BIT(5)
 108 #define CDC_WSA_RX_PATH_MIX_CLK_DISABLE         0
 109 #define CDC_WSA_RX0_RX_PATH_MIX_CFG             (0x041C)
 110 #define CDC_WSA_RX0_RX_VOL_MIX_CTL              (0x0420)
 111 #define CDC_WSA_RX0_RX_PATH_SEC0                (0x0424)
 112 #define CDC_WSA_RX0_RX_PATH_SEC1                (0x0428)
 113 #define CDC_WSA_RX_PGA_HALF_DB_MASK             BIT(0)
 114 #define CDC_WSA_RX_PGA_HALF_DB_ENABLE           BIT(0)
 115 #define CDC_WSA_RX_PGA_HALF_DB_DISABLE          0
 116 #define CDC_WSA_RX0_RX_PATH_SEC2                (0x042C)
 117 #define CDC_WSA_RX0_RX_PATH_SEC3                (0x0430)
 118 #define CDC_WSA_RX_PATH_HD2_SCALE_MASK          GENMASK(1, 0)
 119 #define CDC_WSA_RX_PATH_HD2_ALPHA_MASK          GENMASK(5, 2)
 120 #define CDC_WSA_RX0_RX_PATH_SEC5                (0x0438)
 121 #define CDC_WSA_RX0_RX_PATH_SEC6                (0x043C)
 122 #define CDC_WSA_RX0_RX_PATH_SEC7                (0x0440)
 123 #define CDC_WSA_RX0_RX_PATH_MIX_SEC0            (0x0444)
 124 #define CDC_WSA_RX0_RX_PATH_MIX_SEC1            (0x0448)
 125 #define CDC_WSA_RX0_RX_PATH_DSMDEM_CTL          (0x044C)
 126 #define CDC_WSA_RX_DSMDEM_CLK_EN_MASK           BIT(0)
 127 #define CDC_WSA_RX_DSMDEM_CLK_ENABLE            BIT(0)
 128 #define CDC_WSA_RX1_RX_PATH_CTL                 (0x0480)
 129 #define CDC_WSA_RX1_RX_PATH_CFG0                (0x0484)
 130 #define CDC_WSA_RX1_RX_PATH_CFG1                (0x0488)
 131 #define CDC_WSA_RX1_RX_PATH_CFG2                (0x048C)
 132 #define CDC_WSA_RX1_RX_PATH_CFG3                (0x0490)
 133 #define CDC_WSA_RX1_RX_VOL_CTL                  (0x0494)
 134 #define CDC_WSA_RX1_RX_PATH_MIX_CTL             (0x0498)
 135 #define CDC_WSA_RX1_RX_PATH_MIX_CFG             (0x049C)
 136 #define CDC_WSA_RX1_RX_VOL_MIX_CTL              (0x04A0)
 137 #define CDC_WSA_RX1_RX_PATH_SEC0                (0x04A4)
 138 #define CDC_WSA_RX1_RX_PATH_SEC1                (0x04A8)
 139 #define CDC_WSA_RX1_RX_PATH_SEC2                (0x04AC)
 140 #define CDC_WSA_RX1_RX_PATH_SEC3                (0x04B0)
 141 #define CDC_WSA_RX1_RX_PATH_SEC5                (0x04B8)
 142 #define CDC_WSA_RX1_RX_PATH_SEC6                (0x04BC)
 143 #define CDC_WSA_RX1_RX_PATH_SEC7                (0x04C0)
 144 #define CDC_WSA_RX1_RX_PATH_MIX_SEC0            (0x04C4)
 145 #define CDC_WSA_RX1_RX_PATH_MIX_SEC1            (0x04C8)
 146 #define CDC_WSA_RX1_RX_PATH_DSMDEM_CTL          (0x04CC)
 147 #define CDC_WSA_BOOST0_BOOST_PATH_CTL           (0x0500)
 148 #define CDC_WSA_BOOST_PATH_CLK_EN_MASK          BIT(4)
 149 #define CDC_WSA_BOOST_PATH_CLK_ENABLE           BIT(4)
 150 #define CDC_WSA_BOOST_PATH_CLK_DISABLE          0
 151 #define CDC_WSA_BOOST0_BOOST_CTL                (0x0504)
 152 #define CDC_WSA_BOOST0_BOOST_CFG1               (0x0508)
 153 #define CDC_WSA_BOOST0_BOOST_CFG2               (0x050C)
 154 #define CDC_WSA_BOOST1_BOOST_PATH_CTL           (0x0540)
 155 #define CDC_WSA_BOOST1_BOOST_CTL                (0x0544)
 156 #define CDC_WSA_BOOST1_BOOST_CFG1               (0x0548)
 157 #define CDC_WSA_BOOST1_BOOST_CFG2               (0x054C)
 158 #define CDC_WSA_COMPANDER0_CTL0                 (0x0580)
 159 #define CDC_WSA_COMPANDER_CLK_EN_MASK           BIT(0)
 160 #define CDC_WSA_COMPANDER_CLK_ENABLE            BIT(0)
 161 #define CDC_WSA_COMPANDER_SOFT_RST_MASK         BIT(1)
 162 #define CDC_WSA_COMPANDER_SOFT_RST_ENABLE       BIT(1)
 163 #define CDC_WSA_COMPANDER_HALT_MASK             BIT(2)
 164 #define CDC_WSA_COMPANDER_HALT                  BIT(2)
 165 #define CDC_WSA_COMPANDER0_CTL1                 (0x0584)
 166 #define CDC_WSA_COMPANDER0_CTL2                 (0x0588)
 167 #define CDC_WSA_COMPANDER0_CTL3                 (0x058C)
 168 #define CDC_WSA_COMPANDER0_CTL4                 (0x0590)
 169 #define CDC_WSA_COMPANDER0_CTL5                 (0x0594)
 170 #define CDC_WSA_COMPANDER0_CTL6                 (0x0598)
 171 #define CDC_WSA_COMPANDER0_CTL7                 (0x059C)
 172 #define CDC_WSA_COMPANDER1_CTL0                 (0x05C0)
 173 #define CDC_WSA_COMPANDER1_CTL1                 (0x05C4)
 174 #define CDC_WSA_COMPANDER1_CTL2                 (0x05C8)
 175 #define CDC_WSA_COMPANDER1_CTL3                 (0x05CC)
 176 #define CDC_WSA_COMPANDER1_CTL4                 (0x05D0)
 177 #define CDC_WSA_COMPANDER1_CTL5                 (0x05D4)
 178 #define CDC_WSA_COMPANDER1_CTL6                 (0x05D8)
 179 #define CDC_WSA_COMPANDER1_CTL7                 (0x05DC)
 180 #define CDC_WSA_SOFTCLIP0_CRC                   (0x0600)
 181 #define CDC_WSA_SOFTCLIP_CLK_EN_MASK            BIT(0)
 182 #define CDC_WSA_SOFTCLIP_CLK_ENABLE             BIT(0)
 183 #define CDC_WSA_SOFTCLIP0_SOFTCLIP_CTRL         (0x0604)
 184 #define CDC_WSA_SOFTCLIP_EN_MASK                BIT(0)
 185 #define CDC_WSA_SOFTCLIP_ENABLE                 BIT(0)
 186 #define CDC_WSA_SOFTCLIP1_CRC                   (0x0640)
 187 #define CDC_WSA_SOFTCLIP1_SOFTCLIP_CTRL         (0x0644)
 188 #define CDC_WSA_EC_HQ0_EC_REF_HQ_PATH_CTL       (0x0680)
 189 #define CDC_WSA_EC_HQ_EC_CLK_EN_MASK            BIT(0)
 190 #define CDC_WSA_EC_HQ_EC_CLK_ENABLE             BIT(0)
 191 #define CDC_WSA_EC_HQ0_EC_REF_HQ_CFG0           (0x0684)
 192 #define CDC_WSA_EC_HQ_EC_REF_PCM_RATE_MASK      GENMASK(4, 1)
 193 #define CDC_WSA_EC_HQ_EC_REF_PCM_RATE_48K       BIT(3)
 194 #define CDC_WSA_EC_HQ1_EC_REF_HQ_PATH_CTL       (0x06C0)
 195 #define CDC_WSA_EC_HQ1_EC_REF_HQ_CFG0           (0x06C4)
 196 #define CDC_WSA_SPLINE_ASRC0_CLK_RST_CTL        (0x0700)
 197 #define CDC_WSA_SPLINE_ASRC0_CTL0               (0x0704)
 198 #define CDC_WSA_SPLINE_ASRC0_CTL1               (0x0708)
 199 #define CDC_WSA_SPLINE_ASRC0_FIFO_CTL           (0x070C)
 200 #define CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_LSB       (0x0710)
 201 #define CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_MSB       (0x0714)
 202 #define CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_LSB       (0x0718)
 203 #define CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_MSB       (0x071C)
 204 #define CDC_WSA_SPLINE_ASRC0_STATUS_FIFO                (0x0720)
 205 #define CDC_WSA_SPLINE_ASRC1_CLK_RST_CTL                (0x0740)
 206 #define CDC_WSA_SPLINE_ASRC1_CTL0               (0x0744)
 207 #define CDC_WSA_SPLINE_ASRC1_CTL1               (0x0748)
 208 #define CDC_WSA_SPLINE_ASRC1_FIFO_CTL           (0x074C)
 209 #define CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_LSB (0x0750)
 210 #define CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_MSB (0x0754)
 211 #define CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_LSB (0x0758)
 212 #define CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_MSB (0x075C)
 213 #define CDC_WSA_SPLINE_ASRC1_STATUS_FIFO        (0x0760)
 214 #define WSA_MAX_OFFSET                          (0x0760)
 215
 216 #define WSA_MACRO_RX_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
 217                         SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000 |\
 218                         SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
 219 #define WSA_MACRO_RX_MIX_RATES (SNDRV_PCM_RATE_48000 |\
 220                         SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
 221 #define WSA_MACRO_RX_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
 222                 SNDRV_PCM_FMTBIT_S24_LE |\
 223                 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S32_LE)
 224
 225 #define WSA_MACRO_ECHO_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
 226                         SNDRV_PCM_RATE_48000)
 227 #define WSA_MACRO_ECHO_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
 228                 SNDRV_PCM_FMTBIT_S24_LE |\
 229                 SNDRV_PCM_FMTBIT_S24_3LE)
 230
 231 #define NUM_INTERPOLATORS 2
 232 #define WSA_NUM_CLKS_MAX        5
 233 #define WSA_MACRO_MCLK_FREQ 19200000
 234 #define WSA_MACRO_MUX_INP_MASK2 0x38
 235 #define WSA_MACRO_MUX_CFG_OFFSET 0x8
 236 #define WSA_MACRO_MUX_CFG1_OFFSET 0x4
 237 #define WSA_MACRO_RX_COMP_OFFSET 0x40
 238 #define WSA_MACRO_RX_SOFTCLIP_OFFSET 0x40
 239 #define WSA_MACRO_RX_PATH_OFFSET 0x80
 240 #define WSA_MACRO_RX_PATH_CFG3_OFFSET 0x10
 241 #define WSA_MACRO_RX_PATH_DSMDEM_OFFSET 0x4C
 242 #define WSA_MACRO_FS_RATE_MASK 0x0F
 243 #define WSA_MACRO_EC_MIX_TX0_MASK 0x03
 244 #define WSA_MACRO_EC_MIX_TX1_MASK 0x18
 245 #define WSA_MACRO_MAX_DMA_CH_PER_PORT 0x2
 246
 247 enum {
 248         WSA_MACRO_GAIN_OFFSET_M1P5_DB,
 249         WSA_MACRO_GAIN_OFFSET_0_DB,
 250 };
 251 enum {
 252         WSA_MACRO_RX0 = 0,
 253         WSA_MACRO_RX1,
 254         WSA_MACRO_RX_MIX,
 255         WSA_MACRO_RX_MIX0 = WSA_MACRO_RX_MIX,
 256         WSA_MACRO_RX_MIX1,
 257         WSA_MACRO_RX_MAX,
 258 };
 259
 260 enum {
 261         WSA_MACRO_TX0 = 0,
 262         WSA_MACRO_TX1,
 263         WSA_MACRO_TX_MAX,
 264 };
 265
 266 enum {
 267         WSA_MACRO_EC0_MUX = 0,
 268         WSA_MACRO_EC1_MUX,
 269         WSA_MACRO_EC_MUX_MAX,
 270 };
 271
 272 enum {
 273         WSA_MACRO_COMP1, /* SPK_L */
 274         WSA_MACRO_COMP2, /* SPK_R */
 275         WSA_MACRO_COMP_MAX
 276 };
 277
 278 enum {
 279         WSA_MACRO_SOFTCLIP0, /* RX0 */
 280         WSA_MACRO_SOFTCLIP1, /* RX1 */
 281         WSA_MACRO_SOFTCLIP_MAX
 282 };
 283
 284 enum {
 285         INTn_1_INP_SEL_ZERO = 0,
 286         INTn_1_INP_SEL_RX0,
 287         INTn_1_INP_SEL_RX1,
 288         INTn_1_INP_SEL_RX2,
 289         INTn_1_INP_SEL_RX3,
 290         INTn_1_INP_SEL_DEC0,
 291         INTn_1_INP_SEL_DEC1,
 292 };
 293
 294 enum {
 295         INTn_2_INP_SEL_ZERO = 0,
 296         INTn_2_INP_SEL_RX0,
 297         INTn_2_INP_SEL_RX1,
 298         INTn_2_INP_SEL_RX2,
 299         INTn_2_INP_SEL_RX3,
 300 };
 301
 302 struct interp_sample_rate {
 303         int sample_rate;
 304         int rate_val;
 305 };
 306
 307 static struct interp_sample_rate int_prim_sample_rate_val[] = {
 308         {8000, 0x0},    /* 8K */
 309         {16000, 0x1},   /* 16K */
 310         {24000, -EINVAL},/* 24K */
 311         {32000, 0x3},   /* 32K */
 312         {48000, 0x4},   /* 48K */
 313         {96000, 0x5},   /* 96K */
 314         {192000, 0x6},  /* 192K */
 315         {384000, 0x7},  /* 384K */
 316         {44100, 0x8}, /* 44.1K */
 317 };
 318
 319 static struct interp_sample_rate int_mix_sample_rate_val[] = {
 320         {48000, 0x4},   /* 48K */
 321         {96000, 0x5},   /* 96K */
 322         {192000, 0x6},  /* 192K */
 323 };
 324
 325 enum {
 326         WSA_MACRO_AIF_INVALID = 0,
 327         WSA_MACRO_AIF1_PB,
 328         WSA_MACRO_AIF_MIX1_PB,
 329         WSA_MACRO_AIF_VI,
 330         WSA_MACRO_AIF_ECHO,
 331         WSA_MACRO_MAX_DAIS,
 332 };
 333
 334 struct wsa_macro {
 335         struct device *dev;
 336         int comp_enabled[WSA_MACRO_COMP_MAX];
 337         int ec_hq[WSA_MACRO_RX1 + 1];
 338         u16 prim_int_users[WSA_MACRO_RX1 + 1];
 339         u16 wsa_mclk_users;
 340         bool reset_swr;
 341         unsigned long active_ch_mask[WSA_MACRO_MAX_DAIS];
 342         unsigned long active_ch_cnt[WSA_MACRO_MAX_DAIS];
 343         int rx_port_value[WSA_MACRO_RX_MAX];
 344         int ear_spkr_gain;
 345         int spkr_gain_offset;
 346         int spkr_mode;
 347         int is_softclip_on[WSA_MACRO_SOFTCLIP_MAX];
 348         int softclip_clk_users[WSA_MACRO_SOFTCLIP_MAX];
 349         struct regmap *regmap;
 350         struct clk_bulk_data clks[WSA_NUM_CLKS_MAX];
 351         struct clk_hw hw;
 352 };
 353 #define to_wsa_macro(_hw) container_of(_hw, struct wsa_macro, hw)
 354
 355 static const DECLARE_TLV_DB_SCALE(digital_gain, -8400, 100, -8400);
 356
 357 static const char *const rx_text[] = {
 358         "ZERO", "RX0", "RX1", "RX_MIX0", "RX_MIX1", "DEC0", "DEC1"
 359 };
 360
 361 static const char *const rx_mix_text[] = {
 362         "ZERO", "RX0", "RX1", "RX_MIX0", "RX_MIX1"
 363 };
 364
 365 static const char *const rx_mix_ec_text[] = {
 366         "ZERO", "RX_MIX_TX0", "RX_MIX_TX1"
 367 };
 368
 369 static const char *const rx_mux_text[] = {
 370         "ZERO", "AIF1_PB", "AIF_MIX1_PB"
 371 };
 372
 373 static const char *const rx_sidetone_mix_text[] = {
 374         "ZERO", "SRC0"
 375 };
 376
 377 static const char * const wsa_macro_ear_spkr_pa_gain_text[] = {
 378         "G_DEFAULT", "G_0_DB", "G_1_DB", "G_2_DB", "G_3_DB",
 379         "G_4_DB", "G_5_DB", "G_6_DB"
 380 };
 381
 382 static SOC_ENUM_SINGLE_EXT_DECL(wsa_macro_ear_spkr_pa_gain_enum,
 383                                 wsa_macro_ear_spkr_pa_gain_text);
 384
 385 /* RX INT0 */
 386 static const struct soc_enum rx0_prim_inp0_chain_enum =
 387         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT0_CFG0,
 388                 0, 7, rx_text);
 389
 390 static const struct soc_enum rx0_prim_inp1_chain_enum =
 391         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT0_CFG0,
 392                 3, 7, rx_text);
 393
 394 static const struct soc_enum rx0_prim_inp2_chain_enum =
 395         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT0_CFG1,
 396                 3, 7, rx_text);
 397
 398 static const struct soc_enum rx0_mix_chain_enum =
 399         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT0_CFG1,
 400                 0, 5, rx_mix_text);
 401
 402 static const struct soc_enum rx0_sidetone_mix_enum =
 403         SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, 2, rx_sidetone_mix_text);
 404
 405 static const struct snd_kcontrol_new rx0_prim_inp0_mux =
 406         SOC_DAPM_ENUM("WSA_RX0 INP0 Mux", rx0_prim_inp0_chain_enum);
 407
 408 static const struct snd_kcontrol_new rx0_prim_inp1_mux =
 409         SOC_DAPM_ENUM("WSA_RX0 INP1 Mux", rx0_prim_inp1_chain_enum);
 410
 411 static const struct snd_kcontrol_new rx0_prim_inp2_mux =
 412         SOC_DAPM_ENUM("WSA_RX0 INP2 Mux", rx0_prim_inp2_chain_enum);
 413
 414 static const struct snd_kcontrol_new rx0_mix_mux =
 415         SOC_DAPM_ENUM("WSA_RX0 MIX Mux", rx0_mix_chain_enum);
 416
 417 static const struct snd_kcontrol_new rx0_sidetone_mix_mux =
 418         SOC_DAPM_ENUM("WSA_RX0 SIDETONE MIX Mux", rx0_sidetone_mix_enum);
 419
 420 /* RX INT1 */
 421 static const struct soc_enum rx1_prim_inp0_chain_enum =
 422         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT1_CFG0,
 423                 0, 7, rx_text);
 424
 425 static const struct soc_enum rx1_prim_inp1_chain_enum =
 426         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT1_CFG0,
 427                 3, 7, rx_text);
 428
 429 static const struct soc_enum rx1_prim_inp2_chain_enum =
 430         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT1_CFG1,
 431                 3, 7, rx_text);
 432
 433 static const struct soc_enum rx1_mix_chain_enum =
 434         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_INT1_CFG1,
 435                 0, 5, rx_mix_text);
 436
 437 static const struct snd_kcontrol_new rx1_prim_inp0_mux =
 438         SOC_DAPM_ENUM("WSA_RX1 INP0 Mux", rx1_prim_inp0_chain_enum);
 439
 440 static const struct snd_kcontrol_new rx1_prim_inp1_mux =
 441         SOC_DAPM_ENUM("WSA_RX1 INP1 Mux", rx1_prim_inp1_chain_enum);
 442
 443 static const struct snd_kcontrol_new rx1_prim_inp2_mux =
 444         SOC_DAPM_ENUM("WSA_RX1 INP2 Mux", rx1_prim_inp2_chain_enum);
 445
 446 static const struct snd_kcontrol_new rx1_mix_mux =
 447         SOC_DAPM_ENUM("WSA_RX1 MIX Mux", rx1_mix_chain_enum);
 448
 449 static const struct soc_enum rx_mix_ec0_enum =
 450         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_MIX_CFG0,
 451                 0, 3, rx_mix_ec_text);
 452
 453 static const struct soc_enum rx_mix_ec1_enum =
 454         SOC_ENUM_SINGLE(CDC_WSA_RX_INP_MUX_RX_MIX_CFG0,
 455                 3, 3, rx_mix_ec_text);
 456
 457 static const struct snd_kcontrol_new rx_mix_ec0_mux =
 458         SOC_DAPM_ENUM("WSA RX_MIX EC0_Mux", rx_mix_ec0_enum);
 459
 460 static const struct snd_kcontrol_new rx_mix_ec1_mux =
 461         SOC_DAPM_ENUM("WSA RX_MIX EC1_Mux", rx_mix_ec1_enum);
 462
 463 static const struct reg_default wsa_defaults[] = {
 464         /* WSA Macro */
 465         { CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL, 0x00},
 466         { CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL, 0x00},
 467         { CDC_WSA_CLK_RST_CTRL_SWR_CONTROL, 0x00},
 468         { CDC_WSA_TOP_TOP_CFG0, 0x00},
 469         { CDC_WSA_TOP_TOP_CFG1, 0x00},
 470         { CDC_WSA_TOP_FREQ_MCLK, 0x00},
 471         { CDC_WSA_TOP_DEBUG_BUS_SEL, 0x00},
 472         { CDC_WSA_TOP_DEBUG_EN0, 0x00},
 473         { CDC_WSA_TOP_DEBUG_EN1, 0x00},
 474         { CDC_WSA_TOP_DEBUG_DSM_LB, 0x88},
 475         { CDC_WSA_TOP_RX_I2S_CTL, 0x0C},
 476         { CDC_WSA_TOP_TX_I2S_CTL, 0x0C},
 477         { CDC_WSA_TOP_I2S_CLK, 0x02},
 478         { CDC_WSA_TOP_I2S_RESET, 0x00},
 479         { CDC_WSA_RX_INP_MUX_RX_INT0_CFG0, 0x00},
 480         { CDC_WSA_RX_INP_MUX_RX_INT0_CFG1, 0x00},
 481         { CDC_WSA_RX_INP_MUX_RX_INT1_CFG0, 0x00},
 482         { CDC_WSA_RX_INP_MUX_RX_INT1_CFG1, 0x00},
 483         { CDC_WSA_RX_INP_MUX_RX_MIX_CFG0, 0x00},
 484         { CDC_WSA_RX_INP_MUX_RX_EC_CFG0, 0x00},
 485         { CDC_WSA_RX_INP_MUX_SOFTCLIP_CFG0, 0x00},
 486         { CDC_WSA_TX0_SPKR_PROT_PATH_CTL, 0x02},
 487         { CDC_WSA_TX0_SPKR_PROT_PATH_CFG0, 0x00},
 488         { CDC_WSA_TX1_SPKR_PROT_PATH_CTL, 0x02},
 489         { CDC_WSA_TX1_SPKR_PROT_PATH_CFG0, 0x00},
 490         { CDC_WSA_TX2_SPKR_PROT_PATH_CTL, 0x02},
 491         { CDC_WSA_TX2_SPKR_PROT_PATH_CFG0, 0x00},
 492         { CDC_WSA_TX3_SPKR_PROT_PATH_CTL, 0x02},
 493         { CDC_WSA_TX3_SPKR_PROT_PATH_CFG0, 0x00},
 494         { CDC_WSA_INTR_CTRL_CFG, 0x00},
 495         { CDC_WSA_INTR_CTRL_CLR_COMMIT, 0x00},
 496         { CDC_WSA_INTR_CTRL_PIN1_MASK0, 0xFF},
 497         { CDC_WSA_INTR_CTRL_PIN1_STATUS0, 0x00},
 498         { CDC_WSA_INTR_CTRL_PIN1_CLEAR0, 0x00},
 499         { CDC_WSA_INTR_CTRL_PIN2_MASK0, 0xFF},
 500         { CDC_WSA_INTR_CTRL_PIN2_STATUS0, 0x00},
 501         { CDC_WSA_INTR_CTRL_PIN2_CLEAR0, 0x00},
 502         { CDC_WSA_INTR_CTRL_LEVEL0, 0x00},
 503         { CDC_WSA_INTR_CTRL_BYPASS0, 0x00},
 504         { CDC_WSA_INTR_CTRL_SET0, 0x00},
 505         { CDC_WSA_RX0_RX_PATH_CTL, 0x04},
 506         { CDC_WSA_RX0_RX_PATH_CFG0, 0x00},
 507         { CDC_WSA_RX0_RX_PATH_CFG1, 0x64},
 508         { CDC_WSA_RX0_RX_PATH_CFG2, 0x8F},
 509         { CDC_WSA_RX0_RX_PATH_CFG3, 0x00},
 510         { CDC_WSA_RX0_RX_VOL_CTL, 0x00},
 511         { CDC_WSA_RX0_RX_PATH_MIX_CTL, 0x04},
 512         { CDC_WSA_RX0_RX_PATH_MIX_CFG, 0x7E},
 513         { CDC_WSA_RX0_RX_VOL_MIX_CTL, 0x00},
 514         { CDC_WSA_RX0_RX_PATH_SEC0, 0x04},
 515         { CDC_WSA_RX0_RX_PATH_SEC1, 0x08},
 516         { CDC_WSA_RX0_RX_PATH_SEC2, 0x00},
 517         { CDC_WSA_RX0_RX_PATH_SEC3, 0x00},
 518         { CDC_WSA_RX0_RX_PATH_SEC5, 0x00},
 519         { CDC_WSA_RX0_RX_PATH_SEC6, 0x00},
 520         { CDC_WSA_RX0_RX_PATH_SEC7, 0x00},
 521         { CDC_WSA_RX0_RX_PATH_MIX_SEC0, 0x08},
 522         { CDC_WSA_RX0_RX_PATH_MIX_SEC1, 0x00},
 523         { CDC_WSA_RX0_RX_PATH_DSMDEM_CTL, 0x00},
 524         { CDC_WSA_RX1_RX_PATH_CFG0, 0x00},
 525         { CDC_WSA_RX1_RX_PATH_CFG1, 0x64},
 526         { CDC_WSA_RX1_RX_PATH_CFG2, 0x8F},
 527         { CDC_WSA_RX1_RX_PATH_CFG3, 0x00},
 528         { CDC_WSA_RX1_RX_VOL_CTL, 0x00},
 529         { CDC_WSA_RX1_RX_PATH_MIX_CTL, 0x04},
 530         { CDC_WSA_RX1_RX_PATH_MIX_CFG, 0x7E},
 531         { CDC_WSA_RX1_RX_VOL_MIX_CTL, 0x00},
 532         { CDC_WSA_RX1_RX_PATH_SEC0, 0x04},
 533         { CDC_WSA_RX1_RX_PATH_SEC1, 0x08},
 534         { CDC_WSA_RX1_RX_PATH_SEC2, 0x00},
 535         { CDC_WSA_RX1_RX_PATH_SEC3, 0x00},
 536         { CDC_WSA_RX1_RX_PATH_SEC5, 0x00},
 537         { CDC_WSA_RX1_RX_PATH_SEC6, 0x00},
 538         { CDC_WSA_RX1_RX_PATH_SEC7, 0x00},
 539         { CDC_WSA_RX1_RX_PATH_MIX_SEC0, 0x08},
 540         { CDC_WSA_RX1_RX_PATH_MIX_SEC1, 0x00},
 541         { CDC_WSA_RX1_RX_PATH_DSMDEM_CTL, 0x00},
 542         { CDC_WSA_BOOST0_BOOST_PATH_CTL, 0x00},
 543         { CDC_WSA_BOOST0_BOOST_CTL, 0xD0},
 544         { CDC_WSA_BOOST0_BOOST_CFG1, 0x89},
 545         { CDC_WSA_BOOST0_BOOST_CFG2, 0x04},
 546         { CDC_WSA_BOOST1_BOOST_PATH_CTL, 0x00},
 547         { CDC_WSA_BOOST1_BOOST_CTL, 0xD0},
 548         { CDC_WSA_BOOST1_BOOST_CFG1, 0x89},
 549         { CDC_WSA_BOOST1_BOOST_CFG2, 0x04},
 550         { CDC_WSA_COMPANDER0_CTL0, 0x60},
 551         { CDC_WSA_COMPANDER0_CTL1, 0xDB},
 552         { CDC_WSA_COMPANDER0_CTL2, 0xFF},
 553         { CDC_WSA_COMPANDER0_CTL3, 0x35},
 554         { CDC_WSA_COMPANDER0_CTL4, 0xFF},
 555         { CDC_WSA_COMPANDER0_CTL5, 0x00},
 556         { CDC_WSA_COMPANDER0_CTL6, 0x01},
 557         { CDC_WSA_COMPANDER0_CTL7, 0x28},
 558         { CDC_WSA_COMPANDER1_CTL0, 0x60},
 559         { CDC_WSA_COMPANDER1_CTL1, 0xDB},
 560         { CDC_WSA_COMPANDER1_CTL2, 0xFF},
 561         { CDC_WSA_COMPANDER1_CTL3, 0x35},
 562         { CDC_WSA_COMPANDER1_CTL4, 0xFF},
 563         { CDC_WSA_COMPANDER1_CTL5, 0x00},
 564         { CDC_WSA_COMPANDER1_CTL6, 0x01},
 565         { CDC_WSA_COMPANDER1_CTL7, 0x28},
 566         { CDC_WSA_SOFTCLIP0_CRC, 0x00},
 567         { CDC_WSA_SOFTCLIP0_SOFTCLIP_CTRL, 0x38},
 568         { CDC_WSA_SOFTCLIP1_CRC, 0x00},
 569         { CDC_WSA_SOFTCLIP1_SOFTCLIP_CTRL, 0x38},
 570         { CDC_WSA_EC_HQ0_EC_REF_HQ_PATH_CTL, 0x00},
 571         { CDC_WSA_EC_HQ0_EC_REF_HQ_CFG0, 0x01},
 572         { CDC_WSA_EC_HQ1_EC_REF_HQ_PATH_CTL, 0x00},
 573         { CDC_WSA_EC_HQ1_EC_REF_HQ_CFG0, 0x01},
 574         { CDC_WSA_SPLINE_ASRC0_CLK_RST_CTL, 0x00},
 575         { CDC_WSA_SPLINE_ASRC0_CTL0, 0x00},
 576         { CDC_WSA_SPLINE_ASRC0_CTL1, 0x00},
 577         { CDC_WSA_SPLINE_ASRC0_FIFO_CTL, 0xA8},
 578         { CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_LSB, 0x00},
 579         { CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_MSB, 0x00},
 580         { CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_LSB, 0x00},
 581         { CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_MSB, 0x00},
 582         { CDC_WSA_SPLINE_ASRC0_STATUS_FIFO, 0x00},
 583         { CDC_WSA_SPLINE_ASRC1_CLK_RST_CTL, 0x00},
 584         { CDC_WSA_SPLINE_ASRC1_CTL0, 0x00},
 585         { CDC_WSA_SPLINE_ASRC1_CTL1, 0x00},
 586         { CDC_WSA_SPLINE_ASRC1_FIFO_CTL, 0xA8},
 587         { CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_LSB, 0x00},
 588         { CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_MSB, 0x00},
 589         { CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_LSB, 0x00},
 590         { CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_MSB, 0x00},
 591         { CDC_WSA_SPLINE_ASRC1_STATUS_FIFO, 0x00},
 592 };
 593
 594 static bool wsa_is_wronly_register(struct device *dev,
 595                                         unsigned int reg)
 596 {
 597         switch (reg) {
 598         case CDC_WSA_INTR_CTRL_CLR_COMMIT:
 599         case CDC_WSA_INTR_CTRL_PIN1_CLEAR0:
 600         case CDC_WSA_INTR_CTRL_PIN2_CLEAR0:
 601                 return true;
 602         }
 603
 604         return false;
 605 }
 606
 607 static bool wsa_is_rw_register(struct device *dev, unsigned int reg)
 608 {
 609         switch (reg) {
 610         case CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL:
 611         case CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL:
 612         case CDC_WSA_CLK_RST_CTRL_SWR_CONTROL:
 613         case CDC_WSA_TOP_TOP_CFG0:
 614         case CDC_WSA_TOP_TOP_CFG1:
 615         case CDC_WSA_TOP_FREQ_MCLK:
 616         case CDC_WSA_TOP_DEBUG_BUS_SEL:
 617         case CDC_WSA_TOP_DEBUG_EN0:
 618         case CDC_WSA_TOP_DEBUG_EN1:
 619         case CDC_WSA_TOP_DEBUG_DSM_LB:
 620         case CDC_WSA_TOP_RX_I2S_CTL:
 621         case CDC_WSA_TOP_TX_I2S_CTL:
 622         case CDC_WSA_TOP_I2S_CLK:
 623         case CDC_WSA_TOP_I2S_RESET:
 624         case CDC_WSA_RX_INP_MUX_RX_INT0_CFG0:
 625         case CDC_WSA_RX_INP_MUX_RX_INT0_CFG1:
 626         case CDC_WSA_RX_INP_MUX_RX_INT1_CFG0:
 627         case CDC_WSA_RX_INP_MUX_RX_INT1_CFG1:
 628         case CDC_WSA_RX_INP_MUX_RX_MIX_CFG0:
 629         case CDC_WSA_RX_INP_MUX_RX_EC_CFG0:
 630         case CDC_WSA_RX_INP_MUX_SOFTCLIP_CFG0:
 631         case CDC_WSA_TX0_SPKR_PROT_PATH_CTL:
 632         case CDC_WSA_TX0_SPKR_PROT_PATH_CFG0:
 633         case CDC_WSA_TX1_SPKR_PROT_PATH_CTL:
 634         case CDC_WSA_TX1_SPKR_PROT_PATH_CFG0:
 635         case CDC_WSA_TX2_SPKR_PROT_PATH_CTL:
 636         case CDC_WSA_TX2_SPKR_PROT_PATH_CFG0:
 637         case CDC_WSA_TX3_SPKR_PROT_PATH_CTL:
 638         case CDC_WSA_TX3_SPKR_PROT_PATH_CFG0:
 639         case CDC_WSA_INTR_CTRL_CFG:
 640         case CDC_WSA_INTR_CTRL_PIN1_MASK0:
 641         case CDC_WSA_INTR_CTRL_PIN2_MASK0:
 642         case CDC_WSA_INTR_CTRL_LEVEL0:
 643         case CDC_WSA_INTR_CTRL_BYPASS0:
 644         case CDC_WSA_INTR_CTRL_SET0:
 645         case CDC_WSA_RX0_RX_PATH_CTL:
 646         case CDC_WSA_RX0_RX_PATH_CFG0:
 647         case CDC_WSA_RX0_RX_PATH_CFG1:
 648         case CDC_WSA_RX0_RX_PATH_CFG2:
 649         case CDC_WSA_RX0_RX_PATH_CFG3:
 650         case CDC_WSA_RX0_RX_VOL_CTL:
 651         case CDC_WSA_RX0_RX_PATH_MIX_CTL:
 652         case CDC_WSA_RX0_RX_PATH_MIX_CFG:
 653         case CDC_WSA_RX0_RX_VOL_MIX_CTL:
 654         case CDC_WSA_RX0_RX_PATH_SEC0:
 655         case CDC_WSA_RX0_RX_PATH_SEC1:
 656         case CDC_WSA_RX0_RX_PATH_SEC2:
 657         case CDC_WSA_RX0_RX_PATH_SEC3:
 658         case CDC_WSA_RX0_RX_PATH_SEC5:
 659         case CDC_WSA_RX0_RX_PATH_SEC6:
 660         case CDC_WSA_RX0_RX_PATH_SEC7:
 661         case CDC_WSA_RX0_RX_PATH_MIX_SEC0:
 662         case CDC_WSA_RX0_RX_PATH_MIX_SEC1:
 663         case CDC_WSA_RX0_RX_PATH_DSMDEM_CTL:
 664         case CDC_WSA_RX1_RX_PATH_CTL:
 665         case CDC_WSA_RX1_RX_PATH_CFG0:
 666         case CDC_WSA_RX1_RX_PATH_CFG1:
 667         case CDC_WSA_RX1_RX_PATH_CFG2:
 668         case CDC_WSA_RX1_RX_PATH_CFG3:
 669         case CDC_WSA_RX1_RX_VOL_CTL:
 670         case CDC_WSA_RX1_RX_PATH_MIX_CTL:
 671         case CDC_WSA_RX1_RX_PATH_MIX_CFG:
 672         case CDC_WSA_RX1_RX_VOL_MIX_CTL:
 673         case CDC_WSA_RX1_RX_PATH_SEC0:
 674         case CDC_WSA_RX1_RX_PATH_SEC1:
 675         case CDC_WSA_RX1_RX_PATH_SEC2:
 676         case CDC_WSA_RX1_RX_PATH_SEC3:
 677         case CDC_WSA_RX1_RX_PATH_SEC5:
 678         case CDC_WSA_RX1_RX_PATH_SEC6:
 679         case CDC_WSA_RX1_RX_PATH_SEC7:
 680         case CDC_WSA_RX1_RX_PATH_MIX_SEC0:
 681         case CDC_WSA_RX1_RX_PATH_MIX_SEC1:
 682         case CDC_WSA_RX1_RX_PATH_DSMDEM_CTL:
 683         case CDC_WSA_BOOST0_BOOST_PATH_CTL:
 684         case CDC_WSA_BOOST0_BOOST_CTL:
 685         case CDC_WSA_BOOST0_BOOST_CFG1:
 686         case CDC_WSA_BOOST0_BOOST_CFG2:
 687         case CDC_WSA_BOOST1_BOOST_PATH_CTL:
 688         case CDC_WSA_BOOST1_BOOST_CTL:
 689         case CDC_WSA_BOOST1_BOOST_CFG1:
 690         case CDC_WSA_BOOST1_BOOST_CFG2:
 691         case CDC_WSA_COMPANDER0_CTL0:
 692         case CDC_WSA_COMPANDER0_CTL1:
 693         case CDC_WSA_COMPANDER0_CTL2:
 694         case CDC_WSA_COMPANDER0_CTL3:
 695         case CDC_WSA_COMPANDER0_CTL4:
 696         case CDC_WSA_COMPANDER0_CTL5:
 697         case CDC_WSA_COMPANDER0_CTL7:
 698         case CDC_WSA_COMPANDER1_CTL0:
 699         case CDC_WSA_COMPANDER1_CTL1:
 700         case CDC_WSA_COMPANDER1_CTL2:
 701         case CDC_WSA_COMPANDER1_CTL3:
 702         case CDC_WSA_COMPANDER1_CTL4:
 703         case CDC_WSA_COMPANDER1_CTL5:
 704         case CDC_WSA_COMPANDER1_CTL7:
 705         case CDC_WSA_SOFTCLIP0_CRC:
 706         case CDC_WSA_SOFTCLIP0_SOFTCLIP_CTRL:
 707         case CDC_WSA_SOFTCLIP1_CRC:
 708         case CDC_WSA_SOFTCLIP1_SOFTCLIP_CTRL:
 709         case CDC_WSA_EC_HQ0_EC_REF_HQ_PATH_CTL:
 710         case CDC_WSA_EC_HQ0_EC_REF_HQ_CFG0:
 711         case CDC_WSA_EC_HQ1_EC_REF_HQ_PATH_CTL:
 712         case CDC_WSA_EC_HQ1_EC_REF_HQ_CFG0:
 713         case CDC_WSA_SPLINE_ASRC0_CLK_RST_CTL:
 714         case CDC_WSA_SPLINE_ASRC0_CTL0:
 715         case CDC_WSA_SPLINE_ASRC0_CTL1:
 716         case CDC_WSA_SPLINE_ASRC0_FIFO_CTL:
 717         case CDC_WSA_SPLINE_ASRC1_CLK_RST_CTL:
 718         case CDC_WSA_SPLINE_ASRC1_CTL0:
 719         case CDC_WSA_SPLINE_ASRC1_CTL1:
 720         case CDC_WSA_SPLINE_ASRC1_FIFO_CTL:
 721                 return true;
 722         }
 723
 724         return false;
 725 }
 726
 727 static bool wsa_is_writeable_register(struct device *dev, unsigned int reg)
 728 {
 729         bool ret;
 730
 731         ret = wsa_is_rw_register(dev, reg);
 732         if (!ret)
 733                 return wsa_is_wronly_register(dev, reg);
 734
 735         return ret;
 736 }
 737
 738 static bool wsa_is_readable_register(struct device *dev, unsigned int reg)
 739 {
 740         switch (reg) {
 741         case CDC_WSA_INTR_CTRL_CLR_COMMIT:
 742         case CDC_WSA_INTR_CTRL_PIN1_CLEAR0:
 743         case CDC_WSA_INTR_CTRL_PIN2_CLEAR0:
 744         case CDC_WSA_INTR_CTRL_PIN1_STATUS0:
 745         case CDC_WSA_INTR_CTRL_PIN2_STATUS0:
 746         case CDC_WSA_COMPANDER0_CTL6:
 747         case CDC_WSA_COMPANDER1_CTL6:
 748         case CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_LSB:
 749         case CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_MSB:
 750         case CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_LSB:
 751         case CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_MSB:
 752         case CDC_WSA_SPLINE_ASRC0_STATUS_FIFO:
 753         case CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_LSB:
 754         case CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_MSB:
 755         case CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_LSB:
 756         case CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_MSB:
 757         case CDC_WSA_SPLINE_ASRC1_STATUS_FIFO:
 758                 return true;
 759         }
 760
 761         return wsa_is_rw_register(dev, reg);
 762 }
 763
 764 static bool wsa_is_volatile_register(struct device *dev, unsigned int reg)
 765 {
 766         /* Update volatile list for rx/tx macros */
 767         switch (reg) {
 768         case CDC_WSA_INTR_CTRL_PIN1_STATUS0:
 769         case CDC_WSA_INTR_CTRL_PIN2_STATUS0:
 770         case CDC_WSA_COMPANDER0_CTL6:
 771         case CDC_WSA_COMPANDER1_CTL6:
 772         case CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_LSB:
 773         case CDC_WSA_SPLINE_ASRC0_STATUS_FMIN_CNTR_MSB:
 774         case CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_LSB:
 775         case CDC_WSA_SPLINE_ASRC0_STATUS_FMAX_CNTR_MSB:
 776         case CDC_WSA_SPLINE_ASRC0_STATUS_FIFO:
 777         case CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_LSB:
 778         case CDC_WSA_SPLINE_ASRC1_STATUS_FMIN_CNTR_MSB:
 779         case CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_LSB:
 780         case CDC_WSA_SPLINE_ASRC1_STATUS_FMAX_CNTR_MSB:
 781         case CDC_WSA_SPLINE_ASRC1_STATUS_FIFO:
 782                 return true;
 783         }
 784         return false;
 785 }
 786
 787 static const struct regmap_config wsa_regmap_config = {
 788         .name = "wsa_macro",
 789         .reg_bits = 16,
 790         .val_bits = 32, /* 8 but with 32 bit read/write */
 791         .reg_stride = 4,
 792         .cache_type = REGCACHE_FLAT,
 793         .reg_defaults = wsa_defaults,
 794         .num_reg_defaults = ARRAY_SIZE(wsa_defaults),
 795         .max_register = WSA_MAX_OFFSET,
 796         .writeable_reg = wsa_is_writeable_register,
 797         .volatile_reg = wsa_is_volatile_register,
 798         .readable_reg = wsa_is_readable_register,
 799 };
 800
 801 /**
 802  * wsa_macro_set_spkr_mode - Configures speaker compander and smartboost
 803  * settings based on speaker mode.
 804  *
 805  * @component: codec instance
 806  * @mode: Indicates speaker configuration mode.
 807  *
 808  * Returns 0 on success or -EINVAL on error.
 809  */
 810 int wsa_macro_set_spkr_mode(struct snd_soc_component *component, int mode)
 811 {
 812         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
 813
 814         wsa->spkr_mode = mode;
 815
 816         switch (mode) {
 817         case WSA_MACRO_SPKR_MODE_1:
 818                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER0_CTL3, 0x80, 0x00);
 819                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER1_CTL3, 0x80, 0x00);
 820                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER0_CTL7, 0x01, 0x00);
 821                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER1_CTL7, 0x01, 0x00);
 822                 snd_soc_component_update_bits(component, CDC_WSA_BOOST0_BOOST_CTL, 0x7C, 0x44);
 823                 snd_soc_component_update_bits(component, CDC_WSA_BOOST1_BOOST_CTL, 0x7C, 0x44);
 824                 break;
 825         default:
 826                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER0_CTL3, 0x80, 0x80);
 827                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER1_CTL3, 0x80, 0x80);
 828                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER0_CTL7, 0x01, 0x01);
 829                 snd_soc_component_update_bits(component, CDC_WSA_COMPANDER1_CTL7, 0x01, 0x01);
 830                 snd_soc_component_update_bits(component, CDC_WSA_BOOST0_BOOST_CTL, 0x7C, 0x58);
 831                 snd_soc_component_update_bits(component, CDC_WSA_BOOST1_BOOST_CTL, 0x7C, 0x58);
 832                 break;
 833         }
 834         return 0;
 835 }
 836 EXPORT_SYMBOL(wsa_macro_set_spkr_mode);
 837
 838 static int wsa_macro_set_prim_interpolator_rate(struct snd_soc_dai *dai,
 839                                                 u8 int_prim_fs_rate_reg_val,
 840                                                 u32 sample_rate)
 841 {
 842         u8 int_1_mix1_inp;
 843         u32 j, port;
 844         u16 int_mux_cfg0, int_mux_cfg1;
 845         u16 int_fs_reg;
 846         u8 inp0_sel, inp1_sel, inp2_sel;
 847         struct snd_soc_component *component = dai->component;
 848         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
 849
 850         for_each_set_bit(port, &wsa->active_ch_mask[dai->id], WSA_MACRO_RX_MAX) {
 851                 int_1_mix1_inp = port;
 852                 if ((int_1_mix1_inp < WSA_MACRO_RX0) || (int_1_mix1_inp > WSA_MACRO_RX_MIX1)) {
 853                         dev_err(component->dev, "%s: Invalid RX port, Dai ID is %d\n",
 854                                 __func__, dai->id);
 855                         return -EINVAL;
 856                 }
 857
 858                 int_mux_cfg0 = CDC_WSA_RX_INP_MUX_RX_INT0_CFG0;
 859
 860                 /*
 861                  * Loop through all interpolator MUX inputs and find out
 862                  * to which interpolator input, the cdc_dma rx port
 863                  * is connected
 864                  */
 865                 for (j = 0; j < NUM_INTERPOLATORS; j++) {
 866                         int_mux_cfg1 = int_mux_cfg0 + WSA_MACRO_MUX_CFG1_OFFSET;
 867                         inp0_sel = snd_soc_component_read_field(component, int_mux_cfg0,
 868                                                                 CDC_WSA_RX_INTX_1_MIX_INP0_SEL_MASK);
 869                         inp1_sel = snd_soc_component_read_field(component, int_mux_cfg0,
 870                                                                 CDC_WSA_RX_INTX_1_MIX_INP1_SEL_MASK);
 871                         inp2_sel = snd_soc_component_read_field(component, int_mux_cfg1,
 872                                                                 CDC_WSA_RX_INTX_1_MIX_INP2_SEL_MASK);
 873
 874                         if ((inp0_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0) ||
 875                             (inp1_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0) ||
 876                             (inp2_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0)) {
 877                                 int_fs_reg = CDC_WSA_RX0_RX_PATH_CTL +
 878                                              WSA_MACRO_RX_PATH_OFFSET * j;
 879                                 /* sample_rate is in Hz */
 880                                 snd_soc_component_update_bits(component, int_fs_reg,
 881                                                               WSA_MACRO_FS_RATE_MASK,
 882                                                               int_prim_fs_rate_reg_val);
 883                         }
 884                         int_mux_cfg0 += WSA_MACRO_MUX_CFG_OFFSET;
 885                 }
 886         }
 887
 888         return 0;
 889 }
 890
 891 static int wsa_macro_set_mix_interpolator_rate(struct snd_soc_dai *dai,
 892                                                u8 int_mix_fs_rate_reg_val,
 893                                                u32 sample_rate)
 894 {
 895         u8 int_2_inp;
 896         u32 j, port;
 897         u16 int_mux_cfg1, int_fs_reg;
 898         u8 int_mux_cfg1_val;
 899         struct snd_soc_component *component = dai->component;
 900         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
 901
 902         for_each_set_bit(port, &wsa->active_ch_mask[dai->id], WSA_MACRO_RX_MAX) {
 903                 int_2_inp = port;
 904                 if ((int_2_inp < WSA_MACRO_RX0) || (int_2_inp > WSA_MACRO_RX_MIX1)) {
 905                         dev_err(component->dev, "%s: Invalid RX port, Dai ID is %d\n",
 906                                 __func__, dai->id);
 907                         return -EINVAL;
 908                 }
 909
 910                 int_mux_cfg1 = CDC_WSA_RX_INP_MUX_RX_INT0_CFG1;
 911                 for (j = 0; j < NUM_INTERPOLATORS; j++) {
 912                         int_mux_cfg1_val = snd_soc_component_read_field(component, int_mux_cfg1,
 913                                                                         CDC_WSA_RX_INTX_2_SEL_MASK);
 914
 915                         if (int_mux_cfg1_val == int_2_inp + INTn_2_INP_SEL_RX0) {
 916                                 int_fs_reg = CDC_WSA_RX0_RX_PATH_MIX_CTL +
 917                                         WSA_MACRO_RX_PATH_OFFSET * j;
 918
 919                                 snd_soc_component_update_bits(component,
 920                                                       int_fs_reg,
 921                                                       WSA_MACRO_FS_RATE_MASK,
 922                                                       int_mix_fs_rate_reg_val);
 923                         }
 924                         int_mux_cfg1 += WSA_MACRO_MUX_CFG_OFFSET;
 925                 }
 926         }
 927         return 0;
 928 }
 929
 930 static int wsa_macro_set_interpolator_rate(struct snd_soc_dai *dai,
 931                                            u32 sample_rate)
 932 {
 933         int rate_val = 0;
 934         int i, ret;
 935
 936         /* set mixing path rate */
 937         for (i = 0; i < ARRAY_SIZE(int_mix_sample_rate_val); i++) {
 938                 if (sample_rate == int_mix_sample_rate_val[i].sample_rate) {
 939                         rate_val = int_mix_sample_rate_val[i].rate_val;
 940                         break;
 941                 }
 942         }
 943         if ((i == ARRAY_SIZE(int_mix_sample_rate_val)) || (rate_val < 0))
 944                 goto prim_rate;
 945
 946         ret = wsa_macro_set_mix_interpolator_rate(dai, (u8) rate_val, sample_rate);
 947         if (ret < 0)
 948                 return ret;
 949 prim_rate:
 950         /* set primary path sample rate */
 951         for (i = 0; i < ARRAY_SIZE(int_prim_sample_rate_val); i++) {
 952                 if (sample_rate == int_prim_sample_rate_val[i].sample_rate) {
 953                         rate_val = int_prim_sample_rate_val[i].rate_val;
 954                         break;
 955                 }
 956         }
 957         if ((i == ARRAY_SIZE(int_prim_sample_rate_val)) || (rate_val < 0))
 958                 return -EINVAL;
 959
 960         ret = wsa_macro_set_prim_interpolator_rate(dai, (u8) rate_val, sample_rate);
 961
 962         return ret;
 963 }
 964
 965 static int wsa_macro_hw_params(struct snd_pcm_substream *substream,
 966                                struct snd_pcm_hw_params *params,
 967                                struct snd_soc_dai *dai)
 968 {
 969         struct snd_soc_component *component = dai->component;
 970         int ret;
 971
 972         switch (substream->stream) {
 973         case SNDRV_PCM_STREAM_PLAYBACK:
 974                 ret = wsa_macro_set_interpolator_rate(dai, params_rate(params));
 975                 if (ret) {
 976                         dev_err(component->dev,
 977                                 "%s: cannot set sample rate: %u\n",
 978                                 __func__, params_rate(params));
 979                         return ret;
 980                 }
 981                 break;
 982         default:
 983                 break;
 984         }
 985         return 0;
 986 }
 987
 988 static int wsa_macro_get_channel_map(struct snd_soc_dai *dai,
 989                                      unsigned int *tx_num, unsigned int *tx_slot,
 990                                      unsigned int *rx_num, unsigned int *rx_slot)
 991 {
 992         struct snd_soc_component *component = dai->component;
 993         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
 994         u16 val, mask = 0, cnt = 0, temp;
 995
 996         switch (dai->id) {
 997         case WSA_MACRO_AIF_VI:
 998                 *tx_slot = wsa->active_ch_mask[dai->id];
 999                 *tx_num = wsa->active_ch_cnt[dai->id];
1000                 break;
1001         case WSA_MACRO_AIF1_PB:
1002         case WSA_MACRO_AIF_MIX1_PB:
1003                 for_each_set_bit(temp, &wsa->active_ch_mask[dai->id],
1004                                         WSA_MACRO_RX_MAX) {
1005                         mask |= (1 << temp);
1006                         if (++cnt == WSA_MACRO_MAX_DMA_CH_PER_PORT)
1007                                 break;
1008                 }
1009                 if (mask & 0x0C)
1010                         mask = mask >> 0x2;
1011                 *rx_slot = mask;
1012                 *rx_num = cnt;
1013                 break;
1014         case WSA_MACRO_AIF_ECHO:
1015                 val = snd_soc_component_read(component, CDC_WSA_RX_INP_MUX_RX_MIX_CFG0);
1016                 if (val & WSA_MACRO_EC_MIX_TX1_MASK) {
1017                         mask |= 0x2;
1018                         cnt++;
1019                 }
1020                 if (val & WSA_MACRO_EC_MIX_TX0_MASK) {
1021                         mask |= 0x1;
1022                         cnt++;
1023                 }
1024                 *tx_slot = mask;
1025                 *tx_num = cnt;
1026                 break;
1027         default:
1028                 dev_err(component->dev, "%s: Invalid AIF\n", __func__);
1029                 break;
1030         }
1031         return 0;
1032 }
1033
1034 static const struct snd_soc_dai_ops wsa_macro_dai_ops = {
1035         .hw_params = wsa_macro_hw_params,
1036         .get_channel_map = wsa_macro_get_channel_map,
1037 };
1038
1039 static struct snd_soc_dai_driver wsa_macro_dai[] = {
1040         {
1041                 .name = "wsa_macro_rx1",
1042                 .id = WSA_MACRO_AIF1_PB,
1043                 .playback = {
1044                         .stream_name = "WSA_AIF1 Playback",
1045                         .rates = WSA_MACRO_RX_RATES,
1046                         .formats = WSA_MACRO_RX_FORMATS,
1047                         .rate_max = 384000,
1048                         .rate_min = 8000,
1049                         .channels_min = 1,
1050                         .channels_max = 2,
1051                 },
1052                 .ops = &wsa_macro_dai_ops,
1053         },
1054         {
1055                 .name = "wsa_macro_rx_mix",
1056                 .id = WSA_MACRO_AIF_MIX1_PB,
1057                 .playback = {
1058                         .stream_name = "WSA_AIF_MIX1 Playback",
1059                         .rates = WSA_MACRO_RX_MIX_RATES,
1060                         .formats = WSA_MACRO_RX_FORMATS,
1061                         .rate_max = 192000,
1062                         .rate_min = 48000,
1063                         .channels_min = 1,
1064                         .channels_max = 2,
1065                 },
1066                 .ops = &wsa_macro_dai_ops,
1067         },
1068         {
1069                 .name = "wsa_macro_vifeedback",
1070                 .id = WSA_MACRO_AIF_VI,
1071                 .capture = {
1072                         .stream_name = "WSA_AIF_VI Capture",
1073                         .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_48000,
1074                         .formats = WSA_MACRO_RX_FORMATS,
1075                         .rate_max = 48000,
1076                         .rate_min = 8000,
1077                         .channels_min = 1,
1078                         .channels_max = 4,
1079                 },
1080                 .ops = &wsa_macro_dai_ops,
1081         },
1082         {
1083                 .name = "wsa_macro_echo",
1084                 .id = WSA_MACRO_AIF_ECHO,
1085                 .capture = {
1086                         .stream_name = "WSA_AIF_ECHO Capture",
1087                         .rates = WSA_MACRO_ECHO_RATES,
1088                         .formats = WSA_MACRO_ECHO_FORMATS,
1089                         .rate_max = 48000,
1090                         .rate_min = 8000,
1091                         .channels_min = 1,
1092                         .channels_max = 2,
1093                 },
1094                 .ops = &wsa_macro_dai_ops,
1095         },
1096 };
1097
1098 static void wsa_macro_mclk_enable(struct wsa_macro *wsa, bool mclk_enable)
1099 {
1100         struct regmap *regmap = wsa->regmap;
1101
1102         if (mclk_enable) {
1103                 if (wsa->wsa_mclk_users == 0) {
1104                         regcache_mark_dirty(regmap);
1105                         regcache_sync(regmap);
1106                         /* 9.6MHz MCLK, set value 0x00 if other frequency */
1107                         regmap_update_bits(regmap, CDC_WSA_TOP_FREQ_MCLK, 0x01, 0x01);
1108                         regmap_update_bits(regmap,
1109                                            CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL,
1110                                            CDC_WSA_MCLK_EN_MASK,
1111                                            CDC_WSA_MCLK_ENABLE);
1112                         regmap_update_bits(regmap,
1113                                            CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL,
1114                                            CDC_WSA_FS_CNT_EN_MASK,
1115                                            CDC_WSA_FS_CNT_ENABLE);
1116                 }
1117                 wsa->wsa_mclk_users++;
1118         } else {
1119                 if (wsa->wsa_mclk_users <= 0) {
1120                         dev_err(wsa->dev, "clock already disabled\n");
1121                         wsa->wsa_mclk_users = 0;
1122                         return;
1123                 }
1124                 wsa->wsa_mclk_users--;
1125                 if (wsa->wsa_mclk_users == 0) {
1126                         regmap_update_bits(regmap,
1127                                            CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL,
1128                                            CDC_WSA_FS_CNT_EN_MASK,
1129                                            CDC_WSA_FS_CNT_DISABLE);
1130                         regmap_update_bits(regmap,
1131                                            CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL,
1132                                            CDC_WSA_MCLK_EN_MASK,
1133                                            CDC_WSA_MCLK_DISABLE);
1134                 }
1135         }
1136 }
1137
1138 static int wsa_macro_mclk_event(struct snd_soc_dapm_widget *w,
1139                                 struct snd_kcontrol *kcontrol, int event)
1140 {
1141         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1142         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1143
1144         wsa_macro_mclk_enable(wsa, event == SND_SOC_DAPM_PRE_PMU);
1145         return 0;
1146 }
1147
1148 static int wsa_macro_enable_vi_feedback(struct snd_soc_dapm_widget *w,
1149                                         struct snd_kcontrol *kcontrol,
1150                                         int event)
1151 {
1152         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1153         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1154         u32 tx_reg0, tx_reg1;
1155
1156         if (test_bit(WSA_MACRO_TX0, &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
1157                 tx_reg0 = CDC_WSA_TX0_SPKR_PROT_PATH_CTL;
1158                 tx_reg1 = CDC_WSA_TX1_SPKR_PROT_PATH_CTL;
1159         } else if (test_bit(WSA_MACRO_TX1, &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
1160                 tx_reg0 = CDC_WSA_TX2_SPKR_PROT_PATH_CTL;
1161                 tx_reg1 = CDC_WSA_TX3_SPKR_PROT_PATH_CTL;
1162         }
1163
1164         switch (event) {
1165         case SND_SOC_DAPM_POST_PMU:
1166                         /* Enable V&I sensing */
1167                 snd_soc_component_update_bits(component, tx_reg0,
1168                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1169                                               CDC_WSA_TX_SPKR_PROT_RESET);
1170                 snd_soc_component_update_bits(component, tx_reg1,
1171                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1172                                               CDC_WSA_TX_SPKR_PROT_RESET);
1173                 snd_soc_component_update_bits(component, tx_reg0,
1174                                               CDC_WSA_TX_SPKR_PROT_PCM_RATE_MASK,
1175                                               CDC_WSA_TX_SPKR_PROT_PCM_RATE_8K);
1176                 snd_soc_component_update_bits(component, tx_reg1,
1177                                               CDC_WSA_TX_SPKR_PROT_PCM_RATE_MASK,
1178                                               CDC_WSA_TX_SPKR_PROT_PCM_RATE_8K);
1179                 snd_soc_component_update_bits(component, tx_reg0,
1180                                               CDC_WSA_TX_SPKR_PROT_CLK_EN_MASK,
1181                                               CDC_WSA_TX_SPKR_PROT_CLK_ENABLE);
1182                 snd_soc_component_update_bits(component, tx_reg1,
1183                                               CDC_WSA_TX_SPKR_PROT_CLK_EN_MASK,
1184                                               CDC_WSA_TX_SPKR_PROT_CLK_ENABLE);
1185                 snd_soc_component_update_bits(component, tx_reg0,
1186                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1187                                               CDC_WSA_TX_SPKR_PROT_NO_RESET);
1188                 snd_soc_component_update_bits(component, tx_reg1,
1189                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1190                                               CDC_WSA_TX_SPKR_PROT_NO_RESET);
1191                 break;
1192         case SND_SOC_DAPM_POST_PMD:
1193                 /* Disable V&I sensing */
1194                 snd_soc_component_update_bits(component, tx_reg0,
1195                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1196                                               CDC_WSA_TX_SPKR_PROT_RESET);
1197                 snd_soc_component_update_bits(component, tx_reg1,
1198                                               CDC_WSA_TX_SPKR_PROT_RESET_MASK,
1199                                               CDC_WSA_TX_SPKR_PROT_RESET);
1200                 snd_soc_component_update_bits(component, tx_reg0,
1201                                               CDC_WSA_TX_SPKR_PROT_CLK_EN_MASK,
1202                                               CDC_WSA_TX_SPKR_PROT_CLK_DISABLE);
1203                 snd_soc_component_update_bits(component, tx_reg1,
1204                                               CDC_WSA_TX_SPKR_PROT_CLK_EN_MASK,
1205                                               CDC_WSA_TX_SPKR_PROT_CLK_DISABLE);
1206                 break;
1207         }
1208
1209         return 0;
1210 }
1211
1212 static int wsa_macro_enable_mix_path(struct snd_soc_dapm_widget *w,
1213                                      struct snd_kcontrol *kcontrol, int event)
1214 {
1215         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1216         u16 path_reg, gain_reg;
1217         int val;
1218
1219         switch (w->shift) {
1220         case WSA_MACRO_RX_MIX0:
1221                 path_reg = CDC_WSA_RX0_RX_PATH_MIX_CTL;
1222                 gain_reg = CDC_WSA_RX0_RX_VOL_MIX_CTL;
1223                 break;
1224         case WSA_MACRO_RX_MIX1:
1225                 path_reg = CDC_WSA_RX1_RX_PATH_MIX_CTL;
1226                 gain_reg = CDC_WSA_RX1_RX_VOL_MIX_CTL;
1227                 break;
1228         default:
1229                 return 0;
1230         }
1231
1232         switch (event) {
1233         case SND_SOC_DAPM_POST_PMU:
1234                 val = snd_soc_component_read(component, gain_reg);
1235                 snd_soc_component_write(component, gain_reg, val);
1236                 break;
1237         case SND_SOC_DAPM_POST_PMD:
1238                 snd_soc_component_update_bits(component, path_reg,
1239                                               CDC_WSA_RX_PATH_MIX_CLK_EN_MASK,
1240                                               CDC_WSA_RX_PATH_MIX_CLK_DISABLE);
1241                 break;
1242         }
1243
1244         return 0;
1245 }
1246
1247 static void wsa_macro_hd2_control(struct snd_soc_component *component,
1248                                   u16 reg, int event)
1249 {
1250         u16 hd2_scale_reg;
1251         u16 hd2_enable_reg;
1252
1253         if (reg == CDC_WSA_RX0_RX_PATH_CTL) {
1254                 hd2_scale_reg = CDC_WSA_RX0_RX_PATH_SEC3;
1255                 hd2_enable_reg = CDC_WSA_RX0_RX_PATH_CFG0;
1256         }
1257         if (reg == CDC_WSA_RX1_RX_PATH_CTL) {
1258                 hd2_scale_reg = CDC_WSA_RX1_RX_PATH_SEC3;
1259                 hd2_enable_reg = CDC_WSA_RX1_RX_PATH_CFG0;
1260         }
1261
1262         if (hd2_enable_reg && SND_SOC_DAPM_EVENT_ON(event)) {
1263                 snd_soc_component_update_bits(component, hd2_scale_reg,
1264                                               CDC_WSA_RX_PATH_HD2_ALPHA_MASK,
1265                                               0x10);
1266                 snd_soc_component_update_bits(component, hd2_scale_reg,
1267                                               CDC_WSA_RX_PATH_HD2_SCALE_MASK,
1268                                               0x1);
1269                 snd_soc_component_update_bits(component, hd2_enable_reg,
1270                                               CDC_WSA_RX_PATH_HD2_EN_MASK,
1271                                               CDC_WSA_RX_PATH_HD2_ENABLE);
1272         }
1273
1274         if (hd2_enable_reg && SND_SOC_DAPM_EVENT_OFF(event)) {
1275                 snd_soc_component_update_bits(component, hd2_enable_reg,
1276                                               CDC_WSA_RX_PATH_HD2_EN_MASK, 0);
1277                 snd_soc_component_update_bits(component, hd2_scale_reg,
1278                                               CDC_WSA_RX_PATH_HD2_SCALE_MASK,
1279                                               0);
1280                 snd_soc_component_update_bits(component, hd2_scale_reg,
1281                                               CDC_WSA_RX_PATH_HD2_ALPHA_MASK,
1282                                               0);
1283         }
1284 }
1285
1286 static int wsa_macro_config_compander(struct snd_soc_component *component,
1287                                       int comp, int event)
1288 {
1289         u16 comp_ctl0_reg, rx_path_cfg0_reg;
1290         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1291
1292         if (!wsa->comp_enabled[comp])
1293                 return 0;
1294
1295         comp_ctl0_reg = CDC_WSA_COMPANDER0_CTL0 +
1296                                         (comp * WSA_MACRO_RX_COMP_OFFSET);
1297         rx_path_cfg0_reg = CDC_WSA_RX0_RX_PATH_CFG0 +
1298                                         (comp * WSA_MACRO_RX_PATH_OFFSET);
1299
1300         if (SND_SOC_DAPM_EVENT_ON(event)) {
1301                 /* Enable Compander Clock */
1302                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1303                                               CDC_WSA_COMPANDER_CLK_EN_MASK,
1304                                               CDC_WSA_COMPANDER_CLK_ENABLE);
1305                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1306                                               CDC_WSA_COMPANDER_SOFT_RST_MASK,
1307                                               CDC_WSA_COMPANDER_SOFT_RST_ENABLE);
1308                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1309                                               CDC_WSA_COMPANDER_SOFT_RST_MASK,
1310                                               0);
1311                 snd_soc_component_update_bits(component, rx_path_cfg0_reg,
1312                                               CDC_WSA_RX_PATH_COMP_EN_MASK,
1313                                               CDC_WSA_RX_PATH_COMP_ENABLE);
1314         }
1315
1316         if (SND_SOC_DAPM_EVENT_OFF(event)) {
1317                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1318                                               CDC_WSA_COMPANDER_HALT_MASK,
1319                                               CDC_WSA_COMPANDER_HALT);
1320                 snd_soc_component_update_bits(component, rx_path_cfg0_reg,
1321                                               CDC_WSA_RX_PATH_COMP_EN_MASK, 0);
1322                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1323                                               CDC_WSA_COMPANDER_SOFT_RST_MASK,
1324                                               CDC_WSA_COMPANDER_SOFT_RST_ENABLE);
1325                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1326                                               CDC_WSA_COMPANDER_SOFT_RST_MASK,
1327                                               0);
1328                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1329                                               CDC_WSA_COMPANDER_CLK_EN_MASK, 0);
1330                 snd_soc_component_update_bits(component, comp_ctl0_reg,
1331                                               CDC_WSA_COMPANDER_HALT_MASK, 0);
1332         }
1333
1334         return 0;
1335 }
1336
1337 static void wsa_macro_enable_softclip_clk(struct snd_soc_component *component,
1338                                          struct wsa_macro *wsa,
1339                                          int path,
1340                                          bool enable)
1341 {
1342         u16 softclip_clk_reg = CDC_WSA_SOFTCLIP0_CRC +
1343                         (path * WSA_MACRO_RX_SOFTCLIP_OFFSET);
1344         u8 softclip_mux_mask = (1 << path);
1345         u8 softclip_mux_value = (1 << path);
1346
1347         if (enable) {
1348                 if (wsa->softclip_clk_users[path] == 0) {
1349                         snd_soc_component_update_bits(component,
1350                                                 softclip_clk_reg,
1351                                                 CDC_WSA_SOFTCLIP_CLK_EN_MASK,
1352                                                 CDC_WSA_SOFTCLIP_CLK_ENABLE);
1353                         snd_soc_component_update_bits(component,
1354                                 CDC_WSA_RX_INP_MUX_SOFTCLIP_CFG0,
1355                                 softclip_mux_mask, softclip_mux_value);
1356                 }
1357                 wsa->softclip_clk_users[path]++;
1358         } else {
1359                 wsa->softclip_clk_users[path]--;
1360                 if (wsa->softclip_clk_users[path] == 0) {
1361                         snd_soc_component_update_bits(component,
1362                                                 softclip_clk_reg,
1363                                                 CDC_WSA_SOFTCLIP_CLK_EN_MASK,
1364                                                 0);
1365                         snd_soc_component_update_bits(component,
1366                                 CDC_WSA_RX_INP_MUX_SOFTCLIP_CFG0,
1367                                 softclip_mux_mask, 0x00);
1368                 }
1369         }
1370 }
1371
1372 static int wsa_macro_config_softclip(struct snd_soc_component *component,
1373                                      int path, int event)
1374 {
1375         u16 softclip_ctrl_reg;
1376         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1377         int softclip_path = 0;
1378
1379         if (path == WSA_MACRO_COMP1)
1380                 softclip_path = WSA_MACRO_SOFTCLIP0;
1381         else if (path == WSA_MACRO_COMP2)
1382                 softclip_path = WSA_MACRO_SOFTCLIP1;
1383
1384         if (!wsa->is_softclip_on[softclip_path])
1385                 return 0;
1386
1387         softclip_ctrl_reg = CDC_WSA_SOFTCLIP0_SOFTCLIP_CTRL +
1388                                 (softclip_path * WSA_MACRO_RX_SOFTCLIP_OFFSET);
1389
1390         if (SND_SOC_DAPM_EVENT_ON(event)) {
1391                 /* Enable Softclip clock and mux */
1392                 wsa_macro_enable_softclip_clk(component, wsa, softclip_path,
1393                                               true);
1394                 /* Enable Softclip control */
1395                 snd_soc_component_update_bits(component, softclip_ctrl_reg,
1396                                               CDC_WSA_SOFTCLIP_EN_MASK,
1397                                               CDC_WSA_SOFTCLIP_ENABLE);
1398         }
1399
1400         if (SND_SOC_DAPM_EVENT_OFF(event)) {
1401                 snd_soc_component_update_bits(component, softclip_ctrl_reg,
1402                                               CDC_WSA_SOFTCLIP_EN_MASK, 0);
1403                 wsa_macro_enable_softclip_clk(component, wsa, softclip_path,
1404                                               false);
1405         }
1406
1407         return 0;
1408 }
1409
1410 static bool wsa_macro_adie_lb(struct snd_soc_component *component,
1411                               int interp_idx)
1412 {
1413         u16 int_mux_cfg0,  int_mux_cfg1;
1414         u8 int_n_inp0, int_n_inp1, int_n_inp2;
1415
1416         int_mux_cfg0 = CDC_WSA_RX_INP_MUX_RX_INT0_CFG0 + interp_idx * 8;
1417         int_mux_cfg1 = int_mux_cfg0 + 4;
1418
1419         int_n_inp0 = snd_soc_component_read_field(component, int_mux_cfg0,
1420                                                   CDC_WSA_RX_INTX_1_MIX_INP0_SEL_MASK);
1421         if (int_n_inp0 == INTn_1_INP_SEL_DEC0 ||
1422                 int_n_inp0 == INTn_1_INP_SEL_DEC1)
1423                 return true;
1424
1425         int_n_inp1 = snd_soc_component_read_field(component, int_mux_cfg0,
1426                                                   CDC_WSA_RX_INTX_1_MIX_INP1_SEL_MASK);
1427         if (int_n_inp1 == INTn_1_INP_SEL_DEC0 ||
1428                 int_n_inp1 == INTn_1_INP_SEL_DEC1)
1429                 return true;
1430
1431         int_n_inp2 = snd_soc_component_read_field(component, int_mux_cfg1,
1432                                                   CDC_WSA_RX_INTX_1_MIX_INP2_SEL_MASK);
1433         if (int_n_inp2 == INTn_1_INP_SEL_DEC0 ||
1434                 int_n_inp2 == INTn_1_INP_SEL_DEC1)
1435                 return true;
1436
1437         return false;
1438 }
1439
1440 static int wsa_macro_enable_main_path(struct snd_soc_dapm_widget *w,
1441                                       struct snd_kcontrol *kcontrol,
1442                                       int event)
1443 {
1444         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1445         u16 reg;
1446
1447         reg = CDC_WSA_RX0_RX_PATH_CTL + WSA_MACRO_RX_PATH_OFFSET * w->shift;
1448         switch (event) {
1449         case SND_SOC_DAPM_PRE_PMU:
1450                 if (wsa_macro_adie_lb(component, w->shift)) {
1451                         snd_soc_component_update_bits(component, reg,
1452                                              CDC_WSA_RX_PATH_CLK_EN_MASK,
1453                                              CDC_WSA_RX_PATH_CLK_ENABLE);
1454                 }
1455                 break;
1456         default:
1457                 break;
1458         }
1459         return 0;
1460 }
1461
1462 static int wsa_macro_interp_get_primary_reg(u16 reg, u16 *ind)
1463 {
1464         u16 prim_int_reg = 0;
1465
1466         switch (reg) {
1467         case CDC_WSA_RX0_RX_PATH_CTL:
1468         case CDC_WSA_RX0_RX_PATH_MIX_CTL:
1469                 prim_int_reg = CDC_WSA_RX0_RX_PATH_CTL;
1470                 *ind = 0;
1471                 break;
1472         case CDC_WSA_RX1_RX_PATH_CTL:
1473         case CDC_WSA_RX1_RX_PATH_MIX_CTL:
1474                 prim_int_reg = CDC_WSA_RX1_RX_PATH_CTL;
1475                 *ind = 1;
1476                 break;
1477         }
1478
1479         return prim_int_reg;
1480 }
1481
1482 static int wsa_macro_enable_prim_interpolator(struct snd_soc_component *component,
1483                                               u16 reg, int event)
1484 {
1485         u16 prim_int_reg;
1486         u16 ind = 0;
1487         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1488
1489         prim_int_reg = wsa_macro_interp_get_primary_reg(reg, &ind);
1490
1491         switch (event) {
1492         case SND_SOC_DAPM_PRE_PMU:
1493                 wsa->prim_int_users[ind]++;
1494                 if (wsa->prim_int_users[ind] == 1) {
1495                         snd_soc_component_update_bits(component,
1496                                                       prim_int_reg + WSA_MACRO_RX_PATH_CFG3_OFFSET,
1497                                                       CDC_WSA_RX_DC_DCOEFF_MASK,
1498                                                       0x3);
1499                         snd_soc_component_update_bits(component, prim_int_reg,
1500                                         CDC_WSA_RX_PATH_PGA_MUTE_EN_MASK,
1501                                         CDC_WSA_RX_PATH_PGA_MUTE_ENABLE);
1502                         wsa_macro_hd2_control(component, prim_int_reg, event);
1503                         snd_soc_component_update_bits(component,
1504                                 prim_int_reg + WSA_MACRO_RX_PATH_DSMDEM_OFFSET,
1505                                 CDC_WSA_RX_DSMDEM_CLK_EN_MASK,
1506                                 CDC_WSA_RX_DSMDEM_CLK_ENABLE);
1507                 }
1508                 if ((reg != prim_int_reg) &&
1509                     ((snd_soc_component_read(
1510                                 component, prim_int_reg)) & 0x10))
1511                         snd_soc_component_update_bits(component, reg,
1512                                         0x10, 0x10);
1513                 break;
1514         case SND_SOC_DAPM_POST_PMD:
1515                 wsa->prim_int_users[ind]--;
1516                 if (wsa->prim_int_users[ind] == 0) {
1517                         snd_soc_component_update_bits(component,
1518                                 prim_int_reg + WSA_MACRO_RX_PATH_DSMDEM_OFFSET,
1519                                 CDC_WSA_RX_DSMDEM_CLK_EN_MASK, 0);
1520                         wsa_macro_hd2_control(component, prim_int_reg, event);
1521                 }
1522                 break;
1523         }
1524
1525         return 0;
1526 }
1527
1528 static int wsa_macro_config_ear_spkr_gain(struct snd_soc_component *component,
1529                                           struct wsa_macro *wsa,
1530                                           int event, int gain_reg)
1531 {
1532         int comp_gain_offset, val;
1533
1534         switch (wsa->spkr_mode) {
1535         /* Compander gain in WSA_MACRO_SPKR_MODE1 case is 12 dB */
1536         case WSA_MACRO_SPKR_MODE_1:
1537                 comp_gain_offset = -12;
1538                 break;
1539         /* Default case compander gain is 15 dB */
1540         default:
1541                 comp_gain_offset = -15;
1542                 break;
1543         }
1544
1545         switch (event) {
1546         case SND_SOC_DAPM_POST_PMU:
1547                 /* Apply ear spkr gain only if compander is enabled */
1548                 if (wsa->comp_enabled[WSA_MACRO_COMP1] &&
1549                     (gain_reg == CDC_WSA_RX0_RX_VOL_CTL) &&
1550                     (wsa->ear_spkr_gain != 0)) {
1551                         /* For example, val is -8(-12+5-1) for 4dB of gain */
1552                         val = comp_gain_offset + wsa->ear_spkr_gain - 1;
1553                         snd_soc_component_write(component, gain_reg, val);
1554                 }
1555                 break;
1556         case SND_SOC_DAPM_POST_PMD:
1557                 /*
1558                  * Reset RX0 volume to 0 dB if compander is enabled and
1559                  * ear_spkr_gain is non-zero.
1560                  */
1561                 if (wsa->comp_enabled[WSA_MACRO_COMP1] &&
1562                     (gain_reg == CDC_WSA_RX0_RX_VOL_CTL) &&
1563                     (wsa->ear_spkr_gain != 0)) {
1564                         snd_soc_component_write(component, gain_reg, 0x0);
1565                 }
1566                 break;
1567         }
1568
1569         return 0;
1570 }
1571
1572 static int wsa_macro_enable_interpolator(struct snd_soc_dapm_widget *w,
1573                                          struct snd_kcontrol *kcontrol,
1574                                          int event)
1575 {
1576         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1577         u16 gain_reg;
1578         u16 reg;
1579         int val;
1580         int offset_val = 0;
1581         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1582
1583         if (w->shift == WSA_MACRO_COMP1) {
1584                 reg = CDC_WSA_RX0_RX_PATH_CTL;
1585                 gain_reg = CDC_WSA_RX0_RX_VOL_CTL;
1586         } else if (w->shift == WSA_MACRO_COMP2) {
1587                 reg = CDC_WSA_RX1_RX_PATH_CTL;
1588                 gain_reg = CDC_WSA_RX1_RX_VOL_CTL;
1589         }
1590
1591         switch (event) {
1592         case SND_SOC_DAPM_PRE_PMU:
1593                 /* Reset if needed */
1594                 wsa_macro_enable_prim_interpolator(component, reg, event);
1595                 break;
1596         case SND_SOC_DAPM_POST_PMU:
1597                 wsa_macro_config_compander(component, w->shift, event);
1598                 wsa_macro_config_softclip(component, w->shift, event);
1599                 /* apply gain after int clk is enabled */
1600                 if ((wsa->spkr_gain_offset == WSA_MACRO_GAIN_OFFSET_M1P5_DB) &&
1601                     (wsa->comp_enabled[WSA_MACRO_COMP1] ||
1602                      wsa->comp_enabled[WSA_MACRO_COMP2])) {
1603                         snd_soc_component_update_bits(component,
1604                                         CDC_WSA_RX0_RX_PATH_SEC1,
1605                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1606                                         CDC_WSA_RX_PGA_HALF_DB_ENABLE);
1607                         snd_soc_component_update_bits(component,
1608                                         CDC_WSA_RX0_RX_PATH_MIX_SEC0,
1609                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1610                                         CDC_WSA_RX_PGA_HALF_DB_ENABLE);
1611                         snd_soc_component_update_bits(component,
1612                                         CDC_WSA_RX1_RX_PATH_SEC1,
1613                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1614                                         CDC_WSA_RX_PGA_HALF_DB_ENABLE);
1615                         snd_soc_component_update_bits(component,
1616                                         CDC_WSA_RX1_RX_PATH_MIX_SEC0,
1617                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1618                                         CDC_WSA_RX_PGA_HALF_DB_ENABLE);
1619                         offset_val = -2;
1620                 }
1621                 val = snd_soc_component_read(component, gain_reg);
1622                 val += offset_val;
1623                 snd_soc_component_write(component, gain_reg, val);
1624                 wsa_macro_config_ear_spkr_gain(component, wsa,
1625                                                 event, gain_reg);
1626                 break;
1627         case SND_SOC_DAPM_POST_PMD:
1628                 wsa_macro_config_compander(component, w->shift, event);
1629                 wsa_macro_config_softclip(component, w->shift, event);
1630                 wsa_macro_enable_prim_interpolator(component, reg, event);
1631                 if ((wsa->spkr_gain_offset == WSA_MACRO_GAIN_OFFSET_M1P5_DB) &&
1632                     (wsa->comp_enabled[WSA_MACRO_COMP1] ||
1633                      wsa->comp_enabled[WSA_MACRO_COMP2])) {
1634                         snd_soc_component_update_bits(component,
1635                                         CDC_WSA_RX0_RX_PATH_SEC1,
1636                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1637                                         CDC_WSA_RX_PGA_HALF_DB_DISABLE);
1638                         snd_soc_component_update_bits(component,
1639                                         CDC_WSA_RX0_RX_PATH_MIX_SEC0,
1640                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1641                                         CDC_WSA_RX_PGA_HALF_DB_DISABLE);
1642                         snd_soc_component_update_bits(component,
1643                                         CDC_WSA_RX1_RX_PATH_SEC1,
1644                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1645                                         CDC_WSA_RX_PGA_HALF_DB_DISABLE);
1646                         snd_soc_component_update_bits(component,
1647                                         CDC_WSA_RX1_RX_PATH_MIX_SEC0,
1648                                         CDC_WSA_RX_PGA_HALF_DB_MASK,
1649                                         CDC_WSA_RX_PGA_HALF_DB_DISABLE);
1650                         offset_val = 2;
1651                         val = snd_soc_component_read(component, gain_reg);
1652                         val += offset_val;
1653                         snd_soc_component_write(component, gain_reg, val);
1654                 }
1655                 wsa_macro_config_ear_spkr_gain(component, wsa,
1656                                                 event, gain_reg);
1657                 break;
1658         }
1659
1660         return 0;
1661 }
1662
1663 static int wsa_macro_spk_boost_event(struct snd_soc_dapm_widget *w,
1664                                      struct snd_kcontrol *kcontrol,
1665                                      int event)
1666 {
1667         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1668         u16 boost_path_ctl, boost_path_cfg1;
1669         u16 reg, reg_mix;
1670
1671         if (!strcmp(w->name, "WSA_RX INT0 CHAIN")) {
1672                 boost_path_ctl = CDC_WSA_BOOST0_BOOST_PATH_CTL;
1673                 boost_path_cfg1 = CDC_WSA_RX0_RX_PATH_CFG1;
1674                 reg = CDC_WSA_RX0_RX_PATH_CTL;
1675                 reg_mix = CDC_WSA_RX0_RX_PATH_MIX_CTL;
1676         } else if (!strcmp(w->name, "WSA_RX INT1 CHAIN")) {
1677                 boost_path_ctl = CDC_WSA_BOOST1_BOOST_PATH_CTL;
1678                 boost_path_cfg1 = CDC_WSA_RX1_RX_PATH_CFG1;
1679                 reg = CDC_WSA_RX1_RX_PATH_CTL;
1680                 reg_mix = CDC_WSA_RX1_RX_PATH_MIX_CTL;
1681         }
1682
1683         switch (event) {
1684         case SND_SOC_DAPM_PRE_PMU:
1685                 snd_soc_component_update_bits(component, boost_path_cfg1,
1686                                               CDC_WSA_RX_PATH_SMART_BST_EN_MASK,
1687                                               CDC_WSA_RX_PATH_SMART_BST_ENABLE);
1688                 snd_soc_component_update_bits(component, boost_path_ctl,
1689                                               CDC_WSA_BOOST_PATH_CLK_EN_MASK,
1690                                               CDC_WSA_BOOST_PATH_CLK_ENABLE);
1691                 if ((snd_soc_component_read(component, reg_mix)) & 0x10)
1692                         snd_soc_component_update_bits(component, reg_mix,
1693                                                 0x10, 0x00);
1694                 break;
1695         case SND_SOC_DAPM_POST_PMU:
1696                 snd_soc_component_update_bits(component, reg, 0x10, 0x00);
1697                 break;
1698         case SND_SOC_DAPM_POST_PMD:
1699                 snd_soc_component_update_bits(component, boost_path_ctl,
1700                                               CDC_WSA_BOOST_PATH_CLK_EN_MASK,
1701                                               CDC_WSA_BOOST_PATH_CLK_DISABLE);
1702                 snd_soc_component_update_bits(component, boost_path_cfg1,
1703                                               CDC_WSA_RX_PATH_SMART_BST_EN_MASK,
1704                                               CDC_WSA_RX_PATH_SMART_BST_DISABLE);
1705                 break;
1706         }
1707
1708         return 0;
1709 }
1710
1711 static int wsa_macro_enable_echo(struct snd_soc_dapm_widget *w,
1712                                  struct snd_kcontrol *kcontrol,
1713                                  int event)
1714 {
1715         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1716         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1717         u16 val, ec_tx, ec_hq_reg;
1718
1719         val = snd_soc_component_read(component, CDC_WSA_RX_INP_MUX_RX_MIX_CFG0);
1720
1721         switch (w->shift) {
1722         case WSA_MACRO_EC0_MUX:
1723                 val = val & CDC_WSA_RX_MIX_TX0_SEL_MASK;
1724                 ec_tx = val - 1;
1725                 break;
1726         case WSA_MACRO_EC1_MUX:
1727                 val = val & CDC_WSA_RX_MIX_TX1_SEL_MASK;
1728                 ec_tx = (val >> CDC_WSA_RX_MIX_TX1_SEL_SHFT) - 1;
1729                 break;
1730         default:
1731                 dev_err(component->dev, "%s: Invalid shift %u\n",
1732                         __func__, w->shift);
1733                 return -EINVAL;
1734         }
1735
1736         if (wsa->ec_hq[ec_tx]) {
1737                 ec_hq_reg = CDC_WSA_EC_HQ0_EC_REF_HQ_PATH_CTL + 0x40 * ec_tx;
1738                 snd_soc_component_update_bits(component, ec_hq_reg,
1739                                              CDC_WSA_EC_HQ_EC_CLK_EN_MASK,
1740                                              CDC_WSA_EC_HQ_EC_CLK_ENABLE);
1741                 ec_hq_reg = CDC_WSA_EC_HQ0_EC_REF_HQ_CFG0 + 0x40 * ec_tx;
1742                 /* default set to 48k */
1743                 snd_soc_component_update_bits(component, ec_hq_reg,
1744                                       CDC_WSA_EC_HQ_EC_REF_PCM_RATE_MASK,
1745                                       CDC_WSA_EC_HQ_EC_REF_PCM_RATE_48K);
1746         }
1747
1748         return 0;
1749 }
1750
1751 static int wsa_macro_get_ec_hq(struct snd_kcontrol *kcontrol,
1752                                struct snd_ctl_elem_value *ucontrol)
1753 {
1754
1755         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1756         int ec_tx = ((struct soc_mixer_control *) kcontrol->private_value)->shift;
1757         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1758
1759         ucontrol->value.integer.value[0] = wsa->ec_hq[ec_tx];
1760
1761         return 0;
1762 }
1763
1764 static int wsa_macro_set_ec_hq(struct snd_kcontrol *kcontrol,
1765                                struct snd_ctl_elem_value *ucontrol)
1766 {
1767         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1768         int ec_tx = ((struct soc_mixer_control *) kcontrol->private_value)->shift;
1769         int value = ucontrol->value.integer.value[0];
1770         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1771
1772         wsa->ec_hq[ec_tx] = value;
1773
1774         return 0;
1775 }
1776
1777 static int wsa_macro_get_compander(struct snd_kcontrol *kcontrol,
1778                                    struct snd_ctl_elem_value *ucontrol)
1779 {
1780
1781         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1782         int comp = ((struct soc_mixer_control *) kcontrol->private_value)->shift;
1783         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1784
1785         ucontrol->value.integer.value[0] = wsa->comp_enabled[comp];
1786         return 0;
1787 }
1788
1789 static int wsa_macro_set_compander(struct snd_kcontrol *kcontrol,
1790                                    struct snd_ctl_elem_value *ucontrol)
1791 {
1792         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1793         int comp = ((struct soc_mixer_control *) kcontrol->private_value)->shift;
1794         int value = ucontrol->value.integer.value[0];
1795         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1796
1797         wsa->comp_enabled[comp] = value;
1798
1799         return 0;
1800 }
1801
1802 static int wsa_macro_ear_spkr_pa_gain_get(struct snd_kcontrol *kcontrol,
1803                                           struct snd_ctl_elem_value *ucontrol)
1804 {
1805         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1806         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1807
1808         ucontrol->value.integer.value[0] = wsa->ear_spkr_gain;
1809
1810         return 0;
1811 }
1812
1813 static int wsa_macro_ear_spkr_pa_gain_put(struct snd_kcontrol *kcontrol,
1814                                           struct snd_ctl_elem_value *ucontrol)
1815 {
1816         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1817         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1818
1819         wsa->ear_spkr_gain =  ucontrol->value.integer.value[0];
1820
1821         return 0;
1822 }
1823
1824 static int wsa_macro_rx_mux_get(struct snd_kcontrol *kcontrol,
1825                                 struct snd_ctl_elem_value *ucontrol)
1826 {
1827         struct snd_soc_dapm_widget *widget =
1828                 snd_soc_dapm_kcontrol_widget(kcontrol);
1829         struct snd_soc_component *component =
1830                                 snd_soc_dapm_to_component(widget->dapm);
1831         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1832
1833         ucontrol->value.integer.value[0] =
1834                         wsa->rx_port_value[widget->shift];
1835         return 0;
1836 }
1837
1838 static int wsa_macro_rx_mux_put(struct snd_kcontrol *kcontrol,
1839                                 struct snd_ctl_elem_value *ucontrol)
1840 {
1841         struct snd_soc_dapm_widget *widget =
1842                 snd_soc_dapm_kcontrol_widget(kcontrol);
1843         struct snd_soc_component *component =
1844                                 snd_soc_dapm_to_component(widget->dapm);
1845         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1846         struct snd_soc_dapm_update *update = NULL;
1847         u32 rx_port_value = ucontrol->value.integer.value[0];
1848         u32 bit_input;
1849         u32 aif_rst;
1850         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1851
1852         aif_rst = wsa->rx_port_value[widget->shift];
1853         if (!rx_port_value) {
1854                 if (aif_rst == 0) {
1855                         dev_err(component->dev, "%s: AIF reset already\n", __func__);
1856                         return 0;
1857                 }
1858                 if (aif_rst >= WSA_MACRO_RX_MAX) {
1859                         dev_err(component->dev, "%s: Invalid AIF reset\n", __func__);
1860                         return 0;
1861                 }
1862         }
1863         wsa->rx_port_value[widget->shift] = rx_port_value;
1864
1865         bit_input = widget->shift;
1866
1867         switch (rx_port_value) {
1868         case 0:
1869                 if (wsa->active_ch_cnt[aif_rst]) {
1870                         clear_bit(bit_input,
1871                                   &wsa->active_ch_mask[aif_rst]);
1872                         wsa->active_ch_cnt[aif_rst]--;
1873                 }
1874                 break;
1875         case 1:
1876         case 2:
1877                 set_bit(bit_input,
1878                         &wsa->active_ch_mask[rx_port_value]);
1879                 wsa->active_ch_cnt[rx_port_value]++;
1880                 break;
1881         default:
1882                 dev_err(component->dev,
1883                         "%s: Invalid AIF_ID for WSA RX MUX %d\n",
1884                         __func__, rx_port_value);
1885                 return -EINVAL;
1886         }
1887
1888         snd_soc_dapm_mux_update_power(widget->dapm, kcontrol,
1889                                         rx_port_value, e, update);
1890         return 0;
1891 }
1892
1893 static int wsa_macro_soft_clip_enable_get(struct snd_kcontrol *kcontrol,
1894                                           struct snd_ctl_elem_value *ucontrol)
1895 {
1896         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1897         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1898         int path = ((struct soc_mixer_control *)kcontrol->private_value)->shift;
1899
1900         ucontrol->value.integer.value[0] = wsa->is_softclip_on[path];
1901
1902         return 0;
1903 }
1904
1905 static int wsa_macro_soft_clip_enable_put(struct snd_kcontrol *kcontrol,
1906                                           struct snd_ctl_elem_value *ucontrol)
1907 {
1908         struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1909         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1910         int path = ((struct soc_mixer_control *) kcontrol->private_value)->shift;
1911
1912         wsa->is_softclip_on[path] =  ucontrol->value.integer.value[0];
1913
1914         return 0;
1915 }
1916
1917 static const struct snd_kcontrol_new wsa_macro_snd_controls[] = {
1918         SOC_ENUM_EXT("EAR SPKR PA Gain", wsa_macro_ear_spkr_pa_gain_enum,
1919                      wsa_macro_ear_spkr_pa_gain_get,
1920                      wsa_macro_ear_spkr_pa_gain_put),
1921         SOC_SINGLE_EXT("WSA_Softclip0 Enable", SND_SOC_NOPM,
1922                         WSA_MACRO_SOFTCLIP0, 1, 0,
1923                         wsa_macro_soft_clip_enable_get,
1924                         wsa_macro_soft_clip_enable_put),
1925         SOC_SINGLE_EXT("WSA_Softclip1 Enable", SND_SOC_NOPM,
1926                         WSA_MACRO_SOFTCLIP1, 1, 0,
1927                         wsa_macro_soft_clip_enable_get,
1928                         wsa_macro_soft_clip_enable_put),
1929
1930         SOC_SINGLE_S8_TLV("WSA_RX0 Digital Volume", CDC_WSA_RX0_RX_VOL_CTL,
1931                           -84, 40, digital_gain),
1932         SOC_SINGLE_S8_TLV("WSA_RX1 Digital Volume", CDC_WSA_RX1_RX_VOL_CTL,
1933                           -84, 40, digital_gain),
1934
1935         SOC_SINGLE("WSA_RX0 Digital Mute", CDC_WSA_RX0_RX_PATH_CTL, 4, 1, 0),
1936         SOC_SINGLE("WSA_RX1 Digital Mute", CDC_WSA_RX1_RX_PATH_CTL, 4, 1, 0),
1937         SOC_SINGLE("WSA_RX0_MIX Digital Mute", CDC_WSA_RX0_RX_PATH_MIX_CTL, 4,
1938                    1, 0),
1939         SOC_SINGLE("WSA_RX1_MIX Digital Mute", CDC_WSA_RX1_RX_PATH_MIX_CTL, 4,
1940                    1, 0),
1941         SOC_SINGLE_EXT("WSA_COMP1 Switch", SND_SOC_NOPM, WSA_MACRO_COMP1, 1, 0,
1942                        wsa_macro_get_compander, wsa_macro_set_compander),
1943         SOC_SINGLE_EXT("WSA_COMP2 Switch", SND_SOC_NOPM, WSA_MACRO_COMP2, 1, 0,
1944                        wsa_macro_get_compander, wsa_macro_set_compander),
1945         SOC_SINGLE_EXT("WSA_RX0 EC_HQ Switch", SND_SOC_NOPM, WSA_MACRO_RX0, 1, 0,
1946                        wsa_macro_get_ec_hq, wsa_macro_set_ec_hq),
1947         SOC_SINGLE_EXT("WSA_RX1 EC_HQ Switch", SND_SOC_NOPM, WSA_MACRO_RX1, 1, 0,
1948                        wsa_macro_get_ec_hq, wsa_macro_set_ec_hq),
1949 };
1950
1951 static const struct soc_enum rx_mux_enum =
1952         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(rx_mux_text), rx_mux_text);
1953
1954 static const struct snd_kcontrol_new rx_mux[WSA_MACRO_RX_MAX] = {
1955         SOC_DAPM_ENUM_EXT("WSA RX0 Mux", rx_mux_enum,
1956                           wsa_macro_rx_mux_get, wsa_macro_rx_mux_put),
1957         SOC_DAPM_ENUM_EXT("WSA RX1 Mux", rx_mux_enum,
1958                           wsa_macro_rx_mux_get, wsa_macro_rx_mux_put),
1959         SOC_DAPM_ENUM_EXT("WSA RX_MIX0 Mux", rx_mux_enum,
1960                           wsa_macro_rx_mux_get, wsa_macro_rx_mux_put),
1961         SOC_DAPM_ENUM_EXT("WSA RX_MIX1 Mux", rx_mux_enum,
1962                           wsa_macro_rx_mux_get, wsa_macro_rx_mux_put),
1963 };
1964
1965 static int wsa_macro_vi_feed_mixer_get(struct snd_kcontrol *kcontrol,
1966                                        struct snd_ctl_elem_value *ucontrol)
1967 {
1968         struct snd_soc_dapm_widget *widget = snd_soc_dapm_kcontrol_widget(kcontrol);
1969         struct snd_soc_component *component = snd_soc_dapm_to_component(widget->dapm);
1970         struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1971         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1972         u32 spk_tx_id = mixer->shift;
1973         u32 dai_id = widget->shift;
1974
1975         if (test_bit(spk_tx_id, &wsa->active_ch_mask[dai_id]))
1976                 ucontrol->value.integer.value[0] = 1;
1977         else
1978                 ucontrol->value.integer.value[0] = 0;
1979
1980         return 0;
1981 }
1982
1983 static int wsa_macro_vi_feed_mixer_put(struct snd_kcontrol *kcontrol,
1984                                        struct snd_ctl_elem_value *ucontrol)
1985 {
1986         struct snd_soc_dapm_widget *widget = snd_soc_dapm_kcontrol_widget(kcontrol);
1987         struct snd_soc_component *component = snd_soc_dapm_to_component(widget->dapm);
1988         struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
1989         struct wsa_macro *wsa = snd_soc_component_get_drvdata(component);
1990         u32 enable = ucontrol->value.integer.value[0];
1991         u32 spk_tx_id = mixer->shift;
1992
1993         if (enable) {
1994                 if (spk_tx_id == WSA_MACRO_TX0 &&
1995                         !test_bit(WSA_MACRO_TX0,
1996                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
1997                         set_bit(WSA_MACRO_TX0,
1998                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI]);
1999                         wsa->active_ch_cnt[WSA_MACRO_AIF_VI]++;
2000                 }
2001                 if (spk_tx_id == WSA_MACRO_TX1 &&
2002                         !test_bit(WSA_MACRO_TX1,
2003                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
2004                         set_bit(WSA_MACRO_TX1,
2005                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI]);
2006                         wsa->active_ch_cnt[WSA_MACRO_AIF_VI]++;
2007                 }
2008         } else {
2009                 if (spk_tx_id == WSA_MACRO_TX0 &&
2010                         test_bit(WSA_MACRO_TX0,
2011                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
2012                         clear_bit(WSA_MACRO_TX0,
2013                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI]);
2014                         wsa->active_ch_cnt[WSA_MACRO_AIF_VI]--;
2015                 }
2016                 if (spk_tx_id == WSA_MACRO_TX1 &&
2017                         test_bit(WSA_MACRO_TX1,
2018                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI])) {
2019                         clear_bit(WSA_MACRO_TX1,
2020                                 &wsa->active_ch_mask[WSA_MACRO_AIF_VI]);
2021                         wsa->active_ch_cnt[WSA_MACRO_AIF_VI]--;
2022                 }
2023         }
2024         snd_soc_dapm_mixer_update_power(widget->dapm, kcontrol, enable, NULL);
2025
2026         return 0;
2027 }
2028
2029 static const struct snd_kcontrol_new aif_vi_mixer[] = {
2030         SOC_SINGLE_EXT("WSA_SPKR_VI_1", SND_SOC_NOPM, WSA_MACRO_TX0, 1, 0,
2031                         wsa_macro_vi_feed_mixer_get,
2032                         wsa_macro_vi_feed_mixer_put),
2033         SOC_SINGLE_EXT("WSA_SPKR_VI_2", SND_SOC_NOPM, WSA_MACRO_TX1, 1, 0,
2034                         wsa_macro_vi_feed_mixer_get,
2035                         wsa_macro_vi_feed_mixer_put),
2036 };
2037
2038 static const struct snd_soc_dapm_widget wsa_macro_dapm_widgets[] = {
2039         SND_SOC_DAPM_AIF_IN("WSA AIF1 PB", "WSA_AIF1 Playback", 0,
2040                             SND_SOC_NOPM, 0, 0),
2041         SND_SOC_DAPM_AIF_IN("WSA AIF_MIX1 PB", "WSA_AIF_MIX1 Playback", 0,
2042                             SND_SOC_NOPM, 0, 0),
2043
2044         SND_SOC_DAPM_AIF_OUT_E("WSA AIF_VI", "WSA_AIF_VI Capture", 0,
2045                                SND_SOC_NOPM, WSA_MACRO_AIF_VI, 0,
2046                                wsa_macro_enable_vi_feedback,
2047                                SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2048         SND_SOC_DAPM_AIF_OUT("WSA AIF_ECHO", "WSA_AIF_ECHO Capture", 0,
2049                              SND_SOC_NOPM, 0, 0),
2050
2051         SND_SOC_DAPM_MIXER("WSA_AIF_VI Mixer", SND_SOC_NOPM, WSA_MACRO_AIF_VI,
2052                            0, aif_vi_mixer, ARRAY_SIZE(aif_vi_mixer)),
2053         SND_SOC_DAPM_MUX_E("WSA RX_MIX EC0_MUX", SND_SOC_NOPM,
2054                            WSA_MACRO_EC0_MUX, 0,
2055                            &rx_mix_ec0_mux, wsa_macro_enable_echo,
2056                            SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2057         SND_SOC_DAPM_MUX_E("WSA RX_MIX EC1_MUX", SND_SOC_NOPM,
2058                            WSA_MACRO_EC1_MUX, 0,
2059                            &rx_mix_ec1_mux, wsa_macro_enable_echo,
2060                            SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2061
2062         SND_SOC_DAPM_MUX("WSA RX0 MUX", SND_SOC_NOPM, WSA_MACRO_RX0, 0,
2063                          &rx_mux[WSA_MACRO_RX0]),
2064         SND_SOC_DAPM_MUX("WSA RX1 MUX", SND_SOC_NOPM, WSA_MACRO_RX1, 0,
2065                          &rx_mux[WSA_MACRO_RX1]),
2066         SND_SOC_DAPM_MUX("WSA RX_MIX0 MUX", SND_SOC_NOPM, WSA_MACRO_RX_MIX0, 0,
2067                          &rx_mux[WSA_MACRO_RX_MIX0]),
2068         SND_SOC_DAPM_MUX("WSA RX_MIX1 MUX", SND_SOC_NOPM, WSA_MACRO_RX_MIX1, 0,
2069                          &rx_mux[WSA_MACRO_RX_MIX1]),
2070
2071         SND_SOC_DAPM_MIXER("WSA RX0", SND_SOC_NOPM, 0, 0, NULL, 0),
2072         SND_SOC_DAPM_MIXER("WSA RX1", SND_SOC_NOPM, 0, 0, NULL, 0),
2073         SND_SOC_DAPM_MIXER("WSA RX_MIX0", SND_SOC_NOPM, 0, 0, NULL, 0),
2074         SND_SOC_DAPM_MIXER("WSA RX_MIX1", SND_SOC_NOPM, 0, 0, NULL, 0),
2075
2076         SND_SOC_DAPM_MUX("WSA_RX0 INP0", SND_SOC_NOPM, 0, 0, &rx0_prim_inp0_mux),
2077         SND_SOC_DAPM_MUX("WSA_RX0 INP1", SND_SOC_NOPM, 0, 0, &rx0_prim_inp1_mux),
2078         SND_SOC_DAPM_MUX("WSA_RX0 INP2", SND_SOC_NOPM, 0, 0, &rx0_prim_inp2_mux),
2079         SND_SOC_DAPM_MUX_E("WSA_RX0 MIX INP", SND_SOC_NOPM, WSA_MACRO_RX_MIX0,
2080                            0, &rx0_mix_mux, wsa_macro_enable_mix_path,
2081                            SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2082         SND_SOC_DAPM_MUX("WSA_RX1 INP0", SND_SOC_NOPM, 0, 0, &rx1_prim_inp0_mux),
2083         SND_SOC_DAPM_MUX("WSA_RX1 INP1", SND_SOC_NOPM, 0, 0, &rx1_prim_inp1_mux),
2084         SND_SOC_DAPM_MUX("WSA_RX1 INP2", SND_SOC_NOPM, 0, 0, &rx1_prim_inp2_mux),
2085         SND_SOC_DAPM_MUX_E("WSA_RX1 MIX INP", SND_SOC_NOPM, WSA_MACRO_RX_MIX1,
2086                            0, &rx1_mix_mux, wsa_macro_enable_mix_path,
2087                            SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2088
2089         SND_SOC_DAPM_MIXER_E("WSA_RX INT0 MIX", SND_SOC_NOPM, 0, 0, NULL, 0,
2090                              wsa_macro_enable_main_path, SND_SOC_DAPM_PRE_PMU),
2091         SND_SOC_DAPM_MIXER_E("WSA_RX INT1 MIX", SND_SOC_NOPM, 1, 0, NULL, 0,
2092                              wsa_macro_enable_main_path, SND_SOC_DAPM_PRE_PMU),
2093
2094         SND_SOC_DAPM_MIXER("WSA_RX INT0 SEC MIX", SND_SOC_NOPM, 0, 0, NULL, 0),
2095         SND_SOC_DAPM_MIXER("WSA_RX INT1 SEC MIX", SND_SOC_NOPM, 0, 0, NULL, 0),
2096
2097         SND_SOC_DAPM_MUX("WSA_RX0 INT0 SIDETONE MIX", CDC_WSA_RX0_RX_PATH_CFG1,
2098                          4, 0, &rx0_sidetone_mix_mux),
2099
2100         SND_SOC_DAPM_INPUT("WSA SRC0_INP"),
2101         SND_SOC_DAPM_INPUT("WSA_TX DEC0_INP"),
2102         SND_SOC_DAPM_INPUT("WSA_TX DEC1_INP"),
2103
2104         SND_SOC_DAPM_MIXER_E("WSA_RX INT0 INTERP", SND_SOC_NOPM,
2105                              WSA_MACRO_COMP1, 0, NULL, 0,
2106                              wsa_macro_enable_interpolator,
2107                              SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2108                              SND_SOC_DAPM_POST_PMD),
2109
2110         SND_SOC_DAPM_MIXER_E("WSA_RX INT1 INTERP", SND_SOC_NOPM,
2111                              WSA_MACRO_COMP2, 0, NULL, 0,
2112                              wsa_macro_enable_interpolator,
2113                              SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2114                              SND_SOC_DAPM_POST_PMD),
2115
2116         SND_SOC_DAPM_MIXER_E("WSA_RX INT0 CHAIN", SND_SOC_NOPM, 0, 0,
2117                              NULL, 0, wsa_macro_spk_boost_event,
2118                              SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2119                              SND_SOC_DAPM_POST_PMD),
2120
2121         SND_SOC_DAPM_MIXER_E("WSA_RX INT1 CHAIN", SND_SOC_NOPM, 0, 0,
2122                              NULL, 0, wsa_macro_spk_boost_event,
2123                              SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2124                              SND_SOC_DAPM_POST_PMD),
2125
2126         SND_SOC_DAPM_INPUT("VIINPUT_WSA"),
2127         SND_SOC_DAPM_OUTPUT("WSA_SPK1 OUT"),
2128         SND_SOC_DAPM_OUTPUT("WSA_SPK2 OUT"),
2129
2130         SND_SOC_DAPM_SUPPLY("WSA_RX0_CLK", CDC_WSA_RX0_RX_PATH_CTL, 5, 0, NULL, 0),
2131         SND_SOC_DAPM_SUPPLY("WSA_RX1_CLK", CDC_WSA_RX1_RX_PATH_CTL, 5, 0, NULL, 0),
2132         SND_SOC_DAPM_SUPPLY("WSA_RX_MIX0_CLK", CDC_WSA_RX0_RX_PATH_MIX_CTL, 5, 0, NULL, 0),
2133         SND_SOC_DAPM_SUPPLY("WSA_RX_MIX1_CLK", CDC_WSA_RX1_RX_PATH_MIX_CTL, 5, 0, NULL, 0),
2134         SND_SOC_DAPM_SUPPLY_S("WSA_MCLK", 0, SND_SOC_NOPM, 0, 0,
2135                               wsa_macro_mclk_event,
2136                               SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2137 };
2138
2139 static const struct snd_soc_dapm_route wsa_audio_map[] = {
2140         /* VI Feedback */
2141         {"WSA_AIF_VI Mixer", "WSA_SPKR_VI_1", "VIINPUT_WSA"},
2142         {"WSA_AIF_VI Mixer", "WSA_SPKR_VI_2", "VIINPUT_WSA"},
2143         {"WSA AIF_VI", NULL, "WSA_AIF_VI Mixer"},
2144         {"WSA AIF_VI", NULL, "WSA_MCLK"},
2145
2146         {"WSA RX_MIX EC0_MUX", "RX_MIX_TX0", "WSA_RX INT0 SEC MIX"},
2147         {"WSA RX_MIX EC1_MUX", "RX_MIX_TX0", "WSA_RX INT0 SEC MIX"},
2148         {"WSA RX_MIX EC0_MUX", "RX_MIX_TX1", "WSA_RX INT1 SEC MIX"},
2149         {"WSA RX_MIX EC1_MUX", "RX_MIX_TX1", "WSA_RX INT1 SEC MIX"},
2150         {"WSA AIF_ECHO", NULL, "WSA RX_MIX EC0_MUX"},
2151         {"WSA AIF_ECHO", NULL, "WSA RX_MIX EC1_MUX"},
2152         {"WSA AIF_ECHO", NULL, "WSA_MCLK"},
2153
2154         {"WSA AIF1 PB", NULL, "WSA_MCLK"},
2155         {"WSA AIF_MIX1 PB", NULL, "WSA_MCLK"},
2156
2157         {"WSA RX0 MUX", "AIF1_PB", "WSA AIF1 PB"},
2158         {"WSA RX1 MUX", "AIF1_PB", "WSA AIF1 PB"},
2159         {"WSA RX_MIX0 MUX", "AIF1_PB", "WSA AIF1 PB"},
2160         {"WSA RX_MIX1 MUX", "AIF1_PB", "WSA AIF1 PB"},
2161
2162         {"WSA RX0 MUX", "AIF_MIX1_PB", "WSA AIF_MIX1 PB"},
2163         {"WSA RX1 MUX", "AIF_MIX1_PB", "WSA AIF_MIX1 PB"},
2164         {"WSA RX_MIX0 MUX", "AIF_MIX1_PB", "WSA AIF_MIX1 PB"},
2165         {"WSA RX_MIX1 MUX", "AIF_MIX1_PB", "WSA AIF_MIX1 PB"},
2166
2167         {"WSA RX0", NULL, "WSA RX0 MUX"},
2168         {"WSA RX1", NULL, "WSA RX1 MUX"},
2169         {"WSA RX_MIX0", NULL, "WSA RX_MIX0 MUX"},
2170         {"WSA RX_MIX1", NULL, "WSA RX_MIX1 MUX"},
2171
2172         {"WSA RX0", NULL, "WSA_RX0_CLK"},
2173         {"WSA RX1", NULL, "WSA_RX1_CLK"},
2174         {"WSA RX_MIX0", NULL, "WSA_RX_MIX0_CLK"},
2175         {"WSA RX_MIX1", NULL, "WSA_RX_MIX1_CLK"},
2176
2177         {"WSA_RX0 INP0", "RX0", "WSA RX0"},
2178         {"WSA_RX0 INP0", "RX1", "WSA RX1"},
2179         {"WSA_RX0 INP0", "RX_MIX0", "WSA RX_MIX0"},
2180         {"WSA_RX0 INP0", "RX_MIX1", "WSA RX_MIX1"},
2181         {"WSA_RX0 INP0", "DEC0", "WSA_TX DEC0_INP"},
2182         {"WSA_RX0 INP0", "DEC1", "WSA_TX DEC1_INP"},
2183         {"WSA_RX INT0 MIX", NULL, "WSA_RX0 INP0"},
2184
2185         {"WSA_RX0 INP1", "RX0", "WSA RX0"},
2186         {"WSA_RX0 INP1", "RX1", "WSA RX1"},
2187         {"WSA_RX0 INP1", "RX_MIX0", "WSA RX_MIX0"},
2188         {"WSA_RX0 INP1", "RX_MIX1", "WSA RX_MIX1"},
2189         {"WSA_RX0 INP1", "DEC0", "WSA_TX DEC0_INP"},
2190         {"WSA_RX0 INP1", "DEC1", "WSA_TX DEC1_INP"},
2191         {"WSA_RX INT0 MIX", NULL, "WSA_RX0 INP1"},
2192
2193         {"WSA_RX0 INP2", "RX0", "WSA RX0"},
2194         {"WSA_RX0 INP2", "RX1", "WSA RX1"},
2195         {"WSA_RX0 INP2", "RX_MIX0", "WSA RX_MIX0"},
2196         {"WSA_RX0 INP2", "RX_MIX1", "WSA RX_MIX1"},
2197         {"WSA_RX0 INP2", "DEC0", "WSA_TX DEC0_INP"},
2198         {"WSA_RX0 INP2", "DEC1", "WSA_TX DEC1_INP"},
2199         {"WSA_RX INT0 MIX", NULL, "WSA_RX0 INP2"},
2200
2201         {"WSA_RX0 MIX INP", "RX0", "WSA RX0"},
2202         {"WSA_RX0 MIX INP", "RX1", "WSA RX1"},
2203         {"WSA_RX0 MIX INP", "RX_MIX0", "WSA RX_MIX0"},
2204         {"WSA_RX0 MIX INP", "RX_MIX1", "WSA RX_MIX1"},
2205         {"WSA_RX INT0 SEC MIX", NULL, "WSA_RX0 MIX INP"},
2206
2207         {"WSA_RX INT0 SEC MIX", NULL, "WSA_RX INT0 MIX"},
2208         {"WSA_RX INT0 INTERP", NULL, "WSA_RX INT0 SEC MIX"},
2209         {"WSA_RX0 INT0 SIDETONE MIX", "SRC0", "WSA SRC0_INP"},
2210         {"WSA_RX INT0 INTERP", NULL, "WSA_RX0 INT0 SIDETONE MIX"},
2211         {"WSA_RX INT0 CHAIN", NULL, "WSA_RX INT0 INTERP"},
2212
2213         {"WSA_SPK1 OUT", NULL, "WSA_RX INT0 CHAIN"},
2214         {"WSA_SPK1 OUT", NULL, "WSA_MCLK"},
2215
2216         {"WSA_RX1 INP0", "RX0", "WSA RX0"},
2217         {"WSA_RX1 INP0", "RX1", "WSA RX1"},
2218         {"WSA_RX1 INP0", "RX_MIX0", "WSA RX_MIX0"},
2219         {"WSA_RX1 INP0", "RX_MIX1", "WSA RX_MIX1"},
2220         {"WSA_RX1 INP0", "DEC0", "WSA_TX DEC0_INP"},
2221         {"WSA_RX1 INP0", "DEC1", "WSA_TX DEC1_INP"},
2222         {"WSA_RX INT1 MIX", NULL, "WSA_RX1 INP0"},
2223
2224         {"WSA_RX1 INP1", "RX0", "WSA RX0"},
2225         {"WSA_RX1 INP1", "RX1", "WSA RX1"},
2226         {"WSA_RX1 INP1", "RX_MIX0", "WSA RX_MIX0"},
2227         {"WSA_RX1 INP1", "RX_MIX1", "WSA RX_MIX1"},
2228         {"WSA_RX1 INP1", "DEC0", "WSA_TX DEC0_INP"},
2229         {"WSA_RX1 INP1", "DEC1", "WSA_TX DEC1_INP"},
2230         {"WSA_RX INT1 MIX", NULL, "WSA_RX1 INP1"},
2231
2232         {"WSA_RX1 INP2", "RX0", "WSA RX0"},
2233         {"WSA_RX1 INP2", "RX1", "WSA RX1"},
2234         {"WSA_RX1 INP2", "RX_MIX0", "WSA RX_MIX0"},
2235         {"WSA_RX1 INP2", "RX_MIX1", "WSA RX_MIX1"},
2236         {"WSA_RX1 INP2", "DEC0", "WSA_TX DEC0_INP"},
2237         {"WSA_RX1 INP2", "DEC1", "WSA_TX DEC1_INP"},
2238         {"WSA_RX INT1 MIX", NULL, "WSA_RX1 INP2"},
2239
2240         {"WSA_RX1 MIX INP", "RX0", "WSA RX0"},
2241         {"WSA_RX1 MIX INP", "RX1", "WSA RX1"},
2242         {"WSA_RX1 MIX INP", "RX_MIX0", "WSA RX_MIX0"},
2243         {"WSA_RX1 MIX INP", "RX_MIX1", "WSA RX_MIX1"},
2244         {"WSA_RX INT1 SEC MIX", NULL, "WSA_RX1 MIX INP"},
2245
2246         {"WSA_RX INT1 SEC MIX", NULL, "WSA_RX INT1 MIX"},
2247         {"WSA_RX INT1 INTERP", NULL, "WSA_RX INT1 SEC MIX"},
2248
2249         {"WSA_RX INT1 CHAIN", NULL, "WSA_RX INT1 INTERP"},
2250         {"WSA_SPK2 OUT", NULL, "WSA_RX INT1 CHAIN"},
2251         {"WSA_SPK2 OUT", NULL, "WSA_MCLK"},
2252 };
2253
2254 static int wsa_swrm_clock(struct wsa_macro *wsa, bool enable)
2255 {
2256         struct regmap *regmap = wsa->regmap;
2257
2258         if (enable) {
2259                 wsa_macro_mclk_enable(wsa, true);
2260
2261                 /* reset swr ip */
2262                 if (wsa->reset_swr)
2263                         regmap_update_bits(regmap,
2264                                            CDC_WSA_CLK_RST_CTRL_SWR_CONTROL,
2265                                            CDC_WSA_SWR_RST_EN_MASK,
2266                                            CDC_WSA_SWR_RST_ENABLE);
2267
2268                 regmap_update_bits(regmap, CDC_WSA_CLK_RST_CTRL_SWR_CONTROL,
2269                                    CDC_WSA_SWR_CLK_EN_MASK,
2270                                    CDC_WSA_SWR_CLK_ENABLE);
2271
2272                 /* Bring out of reset */
2273                 if (wsa->reset_swr)
2274                         regmap_update_bits(regmap,
2275                                            CDC_WSA_CLK_RST_CTRL_SWR_CONTROL,
2276                                            CDC_WSA_SWR_RST_EN_MASK,
2277                                            CDC_WSA_SWR_RST_DISABLE);
2278                 wsa->reset_swr = false;
2279         } else {
2280                 regmap_update_bits(regmap, CDC_WSA_CLK_RST_CTRL_SWR_CONTROL,
2281                                    CDC_WSA_SWR_CLK_EN_MASK, 0);
2282                 wsa_macro_mclk_enable(wsa, false);
2283         }
2284
2285         return 0;
2286 }
2287
2288 static int wsa_macro_component_probe(struct snd_soc_component *comp)
2289 {
2290         struct wsa_macro *wsa = snd_soc_component_get_drvdata(comp);
2291
2292         snd_soc_component_init_regmap(comp, wsa->regmap);
2293
2294         wsa->spkr_gain_offset = WSA_MACRO_GAIN_OFFSET_M1P5_DB;
2295
2296         /* set SPKR rate to FS_2P4_3P072 */
2297         snd_soc_component_update_bits(comp, CDC_WSA_RX0_RX_PATH_CFG1,
2298                                 CDC_WSA_RX_PATH_SPKR_RATE_MASK,
2299                                 CDC_WSA_RX_PATH_SPKR_RATE_FS_2P4_3P072);
2300
2301         snd_soc_component_update_bits(comp, CDC_WSA_RX1_RX_PATH_CFG1,
2302                                 CDC_WSA_RX_PATH_SPKR_RATE_MASK,
2303                                 CDC_WSA_RX_PATH_SPKR_RATE_FS_2P4_3P072);
2304
2305         wsa_macro_set_spkr_mode(comp, WSA_MACRO_SPKR_MODE_1);
2306
2307         return 0;
2308 }
2309
2310 static int swclk_gate_enable(struct clk_hw *hw)
2311 {
2312         return wsa_swrm_clock(to_wsa_macro(hw), true);
2313 }
2314
2315 static void swclk_gate_disable(struct clk_hw *hw)
2316 {
2317         wsa_swrm_clock(to_wsa_macro(hw), false);
2318 }
2319
2320 static int swclk_gate_is_enabled(struct clk_hw *hw)
2321 {
2322         struct wsa_macro *wsa = to_wsa_macro(hw);
2323         int ret, val;
2324
2325         regmap_read(wsa->regmap, CDC_WSA_CLK_RST_CTRL_SWR_CONTROL, &val);
2326         ret = val & BIT(0);
2327
2328         return ret;
2329 }
2330
2331 static unsigned long swclk_recalc_rate(struct clk_hw *hw,
2332                                        unsigned long parent_rate)
2333 {
2334         return parent_rate / 2;
2335 }
2336
2337 static const struct clk_ops swclk_gate_ops = {
2338         .prepare = swclk_gate_enable,
2339         .unprepare = swclk_gate_disable,
2340         .is_enabled = swclk_gate_is_enabled,
2341         .recalc_rate = swclk_recalc_rate,
2342 };
2343
2344 static int wsa_macro_register_mclk_output(struct wsa_macro *wsa)
2345 {
2346         struct device *dev = wsa->dev;
2347         const char *parent_clk_name;
2348         const char *clk_name = "mclk";
2349         struct clk_hw *hw;
2350         struct clk_init_data init;
2351         int ret;
2352
2353         parent_clk_name = __clk_get_name(wsa->clks[2].clk);
2354
2355         init.name = clk_name;
2356         init.ops = &swclk_gate_ops;
2357         init.flags = 0;
2358         init.parent_names = &parent_clk_name;
2359         init.num_parents = 1;
2360         wsa->hw.init = &init;
2361         hw = &wsa->hw;
2362         ret = clk_hw_register(wsa->dev, hw);
2363         if (ret)
2364                 return ret;
2365
2366         return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, hw);
2367 }
2368
2369 static const struct snd_soc_component_driver wsa_macro_component_drv = {
2370         .name = "WSA MACRO",
2371         .probe = wsa_macro_component_probe,
2372         .controls = wsa_macro_snd_controls,
2373         .num_controls = ARRAY_SIZE(wsa_macro_snd_controls),
2374         .dapm_widgets = wsa_macro_dapm_widgets,
2375         .num_dapm_widgets = ARRAY_SIZE(wsa_macro_dapm_widgets),
2376         .dapm_routes = wsa_audio_map,
2377         .num_dapm_routes = ARRAY_SIZE(wsa_audio_map),
2378 };
2379
2380 static int wsa_macro_probe(struct platform_device *pdev)
2381 {
2382         struct device *dev = &pdev->dev;
2383         struct wsa_macro *wsa;
2384         void __iomem *base;
2385         int ret;
2386
2387         wsa = devm_kzalloc(dev, sizeof(*wsa), GFP_KERNEL);
2388         if (!wsa)
2389                 return -ENOMEM;
2390
2391         wsa->clks[0].id = "macro";
2392         wsa->clks[1].id = "dcodec";
2393         wsa->clks[2].id = "mclk";
2394         wsa->clks[3].id = "npl";
2395         wsa->clks[4].id = "fsgen";
2396
2397         ret = devm_clk_bulk_get(dev, WSA_NUM_CLKS_MAX, wsa->clks);
2398         if (ret) {
2399                 dev_err(dev, "Error getting WSA Clocks (%d)\n", ret);
2400                 return ret;
2401         }
2402
2403         base = devm_platform_ioremap_resource(pdev, 0);
2404         if (IS_ERR(base))
2405                 return PTR_ERR(base);
2406
2407         wsa->regmap = devm_regmap_init_mmio(dev, base, &wsa_regmap_config);
2408
2409         dev_set_drvdata(dev, wsa);
2410
2411         wsa->reset_swr = true;
2412         wsa->dev = dev;
2413
2414         /* set MCLK and NPL rates */
2415         clk_set_rate(wsa->clks[2].clk, WSA_MACRO_MCLK_FREQ);
2416         clk_set_rate(wsa->clks[3].clk, WSA_MACRO_MCLK_FREQ);
2417
2418         ret = clk_bulk_prepare_enable(WSA_NUM_CLKS_MAX, wsa->clks);
2419         if (ret)
2420                 return ret;
2421
2422         wsa_macro_register_mclk_output(wsa);
2423
2424         ret = devm_snd_soc_register_component(dev, &wsa_macro_component_drv,
2425                                               wsa_macro_dai,
2426                                               ARRAY_SIZE(wsa_macro_dai));
2427         if (ret)
2428                 goto err;
2429
2430         return ret;
2431 err:
2432         clk_bulk_disable_unprepare(WSA_NUM_CLKS_MAX, wsa->clks);
2433
2434         return ret;
2435
2436 }
2437
2438 static int wsa_macro_remove(struct platform_device *pdev)
2439 {
2440         struct wsa_macro *wsa = dev_get_drvdata(&pdev->dev);
2441
2442         clk_bulk_disable_unprepare(WSA_NUM_CLKS_MAX, wsa->clks);
2443
2444         return 0;
2445 }
2446
2447 static const struct of_device_id wsa_macro_dt_match[] = {
2448         {.compatible = "qcom,sc7280-lpass-wsa-macro"},
2449         {.compatible = "qcom,sm8250-lpass-wsa-macro"},
2450         {}
2451 };
2452 MODULE_DEVICE_TABLE(of, wsa_macro_dt_match);
2453
2454 static struct platform_driver wsa_macro_driver = {
2455         .driver = {
2456                 .name = "wsa_macro",
2457                 .of_match_table = wsa_macro_dt_match,
2458         },
2459         .probe = wsa_macro_probe,
2460         .remove = wsa_macro_remove,
2461 };
2462
2463 module_platform_driver(wsa_macro_driver);
2464 MODULE_DESCRIPTION("WSA macro driver");
2465 MODULE_LICENSE("GPL");