sound/soc/codecs/madera.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Cirrus Logic Madera class codecs common support
   4 //
   5 // Copyright (C) 2015-2019 Cirrus Logic, Inc. and
   6 //                         Cirrus Logic International Semiconductor Ltd.
   7 //
   8
   9 #include <linux/delay.h>
  10 #include <linux/gcd.h>
  11 #include <linux/module.h>
  12 #include <linux/pm_runtime.h>
  13 #include <linux/slab.h>
  14 #include <sound/pcm.h>
  15 #include <sound/pcm_params.h>
  16 #include <sound/tlv.h>
  17
  18 #include <linux/irqchip/irq-madera.h>
  19 #include <linux/mfd/madera/core.h>
  20 #include <linux/mfd/madera/registers.h>
  21 #include <linux/mfd/madera/pdata.h>
  22 #include <sound/madera-pdata.h>
  23
  24 #include <dt-bindings/sound/madera.h>
  25
  26 #include "madera.h"
  27
  28 #define MADERA_AIF_BCLK_CTRL                    0x00
  29 #define MADERA_AIF_TX_PIN_CTRL                  0x01
  30 #define MADERA_AIF_RX_PIN_CTRL                  0x02
  31 #define MADERA_AIF_RATE_CTRL                    0x03
  32 #define MADERA_AIF_FORMAT                       0x04
  33 #define MADERA_AIF_RX_BCLK_RATE                 0x06
  34 #define MADERA_AIF_FRAME_CTRL_1                 0x07
  35 #define MADERA_AIF_FRAME_CTRL_2                 0x08
  36 #define MADERA_AIF_FRAME_CTRL_3                 0x09
  37 #define MADERA_AIF_FRAME_CTRL_4                 0x0A
  38 #define MADERA_AIF_FRAME_CTRL_5                 0x0B
  39 #define MADERA_AIF_FRAME_CTRL_6                 0x0C
  40 #define MADERA_AIF_FRAME_CTRL_7                 0x0D
  41 #define MADERA_AIF_FRAME_CTRL_8                 0x0E
  42 #define MADERA_AIF_FRAME_CTRL_9                 0x0F
  43 #define MADERA_AIF_FRAME_CTRL_10                0x10
  44 #define MADERA_AIF_FRAME_CTRL_11                0x11
  45 #define MADERA_AIF_FRAME_CTRL_12                0x12
  46 #define MADERA_AIF_FRAME_CTRL_13                0x13
  47 #define MADERA_AIF_FRAME_CTRL_14                0x14
  48 #define MADERA_AIF_FRAME_CTRL_15                0x15
  49 #define MADERA_AIF_FRAME_CTRL_16                0x16
  50 #define MADERA_AIF_FRAME_CTRL_17                0x17
  51 #define MADERA_AIF_FRAME_CTRL_18                0x18
  52 #define MADERA_AIF_TX_ENABLES                   0x19
  53 #define MADERA_AIF_RX_ENABLES                   0x1A
  54 #define MADERA_AIF_FORCE_WRITE                  0x1B
  55
  56 #define MADERA_DSP_CONFIG_1_OFFS                0x00
  57 #define MADERA_DSP_CONFIG_2_OFFS                0x02
  58
  59 #define MADERA_DSP_CLK_SEL_MASK                 0x70000
  60 #define MADERA_DSP_CLK_SEL_SHIFT                16
  61
  62 #define MADERA_DSP_RATE_MASK                    0x7800
  63 #define MADERA_DSP_RATE_SHIFT                   11
  64
  65 #define MADERA_SYSCLK_6MHZ                      0
  66 #define MADERA_SYSCLK_12MHZ                     1
  67 #define MADERA_SYSCLK_24MHZ                     2
  68 #define MADERA_SYSCLK_49MHZ                     3
  69 #define MADERA_SYSCLK_98MHZ                     4
  70
  71 #define MADERA_DSPCLK_9MHZ                      0
  72 #define MADERA_DSPCLK_18MHZ                     1
  73 #define MADERA_DSPCLK_36MHZ                     2
  74 #define MADERA_DSPCLK_73MHZ                     3
  75 #define MADERA_DSPCLK_147MHZ                    4
  76
  77 #define MADERA_FLL_VCO_CORNER                   141900000
  78 #define MADERA_FLL_MAX_FREF                     13500000
  79 #define MADERA_FLL_MAX_N                        1023
  80 #define MADERA_FLL_MIN_FOUT                     90000000
  81 #define MADERA_FLL_MAX_FOUT                     100000000
  82 #define MADERA_FLL_MAX_FRATIO                   16
  83 #define MADERA_FLL_MAX_REFDIV                   8
  84 #define MADERA_FLL_OUTDIV                       3
  85 #define MADERA_FLL_VCO_MULT                     3
  86 #define MADERA_FLLAO_MAX_FREF                   12288000
  87 #define MADERA_FLLAO_MIN_N                      4
  88 #define MADERA_FLLAO_MAX_N                      1023
  89 #define MADERA_FLLAO_MAX_FBDIV                  254
  90 #define MADERA_FLLHJ_INT_MAX_N                  1023
  91 #define MADERA_FLLHJ_INT_MIN_N                  1
  92 #define MADERA_FLLHJ_FRAC_MAX_N                 255
  93 #define MADERA_FLLHJ_FRAC_MIN_N                 4
  94 #define MADERA_FLLHJ_LOW_THRESH                 192000
  95 #define MADERA_FLLHJ_MID_THRESH                 1152000
  96 #define MADERA_FLLHJ_MAX_THRESH                 13000000
  97 #define MADERA_FLLHJ_LOW_GAINS                  0x23f0
  98 #define MADERA_FLLHJ_MID_GAINS                  0x22f2
  99 #define MADERA_FLLHJ_HIGH_GAINS                 0x21f0
 100
 101 #define MADERA_FLL_SYNCHRONISER_OFFS            0x10
 102 #define CS47L35_FLL_SYNCHRONISER_OFFS           0xE
 103 #define MADERA_FLL_CONTROL_1_OFFS               0x1
 104 #define MADERA_FLL_CONTROL_2_OFFS               0x2
 105 #define MADERA_FLL_CONTROL_3_OFFS               0x3
 106 #define MADERA_FLL_CONTROL_4_OFFS               0x4
 107 #define MADERA_FLL_CONTROL_5_OFFS               0x5
 108 #define MADERA_FLL_CONTROL_6_OFFS               0x6
 109 #define MADERA_FLL_GAIN_OFFS                    0x8
 110 #define MADERA_FLL_CONTROL_7_OFFS               0x9
 111 #define MADERA_FLL_EFS_2_OFFS                   0xA
 112 #define MADERA_FLL_SYNCHRONISER_1_OFFS          0x1
 113 #define MADERA_FLL_SYNCHRONISER_2_OFFS          0x2
 114 #define MADERA_FLL_SYNCHRONISER_3_OFFS          0x3
 115 #define MADERA_FLL_SYNCHRONISER_4_OFFS          0x4
 116 #define MADERA_FLL_SYNCHRONISER_5_OFFS          0x5
 117 #define MADERA_FLL_SYNCHRONISER_6_OFFS          0x6
 118 #define MADERA_FLL_SYNCHRONISER_7_OFFS          0x7
 119 #define MADERA_FLL_SPREAD_SPECTRUM_OFFS         0x9
 120 #define MADERA_FLL_GPIO_CLOCK_OFFS              0xA
 121 #define MADERA_FLL_CONTROL_10_OFFS              0xA
 122 #define MADERA_FLL_CONTROL_11_OFFS              0xB
 123 #define MADERA_FLL1_DIGITAL_TEST_1_OFFS         0xD
 124
 125 #define MADERA_FLLAO_CONTROL_1_OFFS             0x1
 126 #define MADERA_FLLAO_CONTROL_2_OFFS             0x2
 127 #define MADERA_FLLAO_CONTROL_3_OFFS             0x3
 128 #define MADERA_FLLAO_CONTROL_4_OFFS             0x4
 129 #define MADERA_FLLAO_CONTROL_5_OFFS             0x5
 130 #define MADERA_FLLAO_CONTROL_6_OFFS             0x6
 131 #define MADERA_FLLAO_CONTROL_7_OFFS             0x8
 132 #define MADERA_FLLAO_CONTROL_8_OFFS             0xA
 133 #define MADERA_FLLAO_CONTROL_9_OFFS             0xB
 134 #define MADERA_FLLAO_CONTROL_10_OFFS            0xC
 135 #define MADERA_FLLAO_CONTROL_11_OFFS            0xD
 136
 137 #define MADERA_FMT_DSP_MODE_A                   0
 138 #define MADERA_FMT_DSP_MODE_B                   1
 139 #define MADERA_FMT_I2S_MODE                     2
 140 #define MADERA_FMT_LEFT_JUSTIFIED_MODE          3
 141
 142 #define madera_fll_err(_fll, fmt, ...) \
 143         dev_err(_fll->madera->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
 144 #define madera_fll_warn(_fll, fmt, ...) \
 145         dev_warn(_fll->madera->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
 146 #define madera_fll_dbg(_fll, fmt, ...) \
 147         dev_dbg(_fll->madera->dev, "FLL%d: " fmt, _fll->id, ##__VA_ARGS__)
 148
 149 #define madera_aif_err(_dai, fmt, ...) \
 150         dev_err(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
 151 #define madera_aif_warn(_dai, fmt, ...) \
 152         dev_warn(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
 153 #define madera_aif_dbg(_dai, fmt, ...) \
 154         dev_dbg(_dai->dev, "AIF%d: " fmt, _dai->id, ##__VA_ARGS__)
 155
 156 static const int madera_dsp_bus_error_irqs[MADERA_MAX_ADSP] = {
 157         MADERA_IRQ_DSP1_BUS_ERR,
 158         MADERA_IRQ_DSP2_BUS_ERR,
 159         MADERA_IRQ_DSP3_BUS_ERR,
 160         MADERA_IRQ_DSP4_BUS_ERR,
 161         MADERA_IRQ_DSP5_BUS_ERR,
 162         MADERA_IRQ_DSP6_BUS_ERR,
 163         MADERA_IRQ_DSP7_BUS_ERR,
 164 };
 165
 166 int madera_clk_ev(struct snd_soc_dapm_widget *w,
 167                   struct snd_kcontrol *kcontrol, int event)
 168 {
 169         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 170         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 171         struct madera *madera = priv->madera;
 172         unsigned int val;
 173         int clk_idx;
 174         int ret;
 175
 176         ret = regmap_read(madera->regmap, w->reg, &val);
 177         if (ret) {
 178                 dev_err(madera->dev, "Failed to check clock source: %d\n", ret);
 179                 return ret;
 180         }
 181
 182         switch ((val & MADERA_SYSCLK_SRC_MASK) >> MADERA_SYSCLK_SRC_SHIFT) {
 183         case MADERA_CLK_SRC_MCLK1:
 184                 clk_idx = MADERA_MCLK1;
 185                 break;
 186         case MADERA_CLK_SRC_MCLK2:
 187                 clk_idx = MADERA_MCLK2;
 188                 break;
 189         case MADERA_CLK_SRC_MCLK3:
 190                 clk_idx = MADERA_MCLK3;
 191                 break;
 192         default:
 193                 return 0;
 194         }
 195
 196         switch (event) {
 197         case SND_SOC_DAPM_PRE_PMU:
 198                 return clk_prepare_enable(madera->mclk[clk_idx].clk);
 199         case SND_SOC_DAPM_POST_PMD:
 200                 clk_disable_unprepare(madera->mclk[clk_idx].clk);
 201                 return 0;
 202         default:
 203                 return 0;
 204         }
 205 }
 206 EXPORT_SYMBOL_GPL(madera_clk_ev);
 207
 208 static void madera_spin_sysclk(struct madera_priv *priv)
 209 {
 210         struct madera *madera = priv->madera;
 211         unsigned int val;
 212         int ret, i;
 213
 214         /* Skip this if the chip is down */
 215         if (pm_runtime_suspended(madera->dev))
 216                 return;
 217
 218         /*
 219          * Just read a register a few times to ensure the internal
 220          * oscillator sends out a few clocks.
 221          */
 222         for (i = 0; i < 4; i++) {
 223                 ret = regmap_read(madera->regmap, MADERA_SOFTWARE_RESET, &val);
 224                 if (ret)
 225                         dev_err(madera->dev,
 226                                 "Failed to read sysclk spin %d: %d\n", i, ret);
 227         }
 228
 229         udelay(300);
 230 }
 231
 232 int madera_sysclk_ev(struct snd_soc_dapm_widget *w,
 233                      struct snd_kcontrol *kcontrol, int event)
 234 {
 235         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 236         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 237
 238         switch (event) {
 239         case SND_SOC_DAPM_POST_PMU:
 240         case SND_SOC_DAPM_PRE_PMD:
 241                 madera_spin_sysclk(priv);
 242                 break;
 243         default:
 244                 break;
 245         }
 246
 247         return madera_clk_ev(w, kcontrol, event);
 248 }
 249 EXPORT_SYMBOL_GPL(madera_sysclk_ev);
 250
 251 static int madera_check_speaker_overheat(struct madera *madera,
 252                                          bool *warn, bool *shutdown)
 253 {
 254         unsigned int val;
 255         int ret;
 256
 257         ret = regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_15, &val);
 258         if (ret) {
 259                 dev_err(madera->dev, "Failed to read thermal status: %d\n",
 260                         ret);
 261                 return ret;
 262         }
 263
 264         *warn = val & MADERA_SPK_OVERHEAT_WARN_STS1;
 265         *shutdown = val & MADERA_SPK_OVERHEAT_STS1;
 266
 267         return 0;
 268 }
 269
 270 int madera_spk_ev(struct snd_soc_dapm_widget *w,
 271                   struct snd_kcontrol *kcontrol, int event)
 272 {
 273         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 274         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 275         struct madera *madera = priv->madera;
 276         bool warn, shutdown;
 277         int ret;
 278
 279         switch (event) {
 280         case SND_SOC_DAPM_POST_PMU:
 281                 ret = madera_check_speaker_overheat(madera, &warn, &shutdown);
 282                 if (ret)
 283                         return ret;
 284
 285                 if (shutdown) {
 286                         dev_crit(madera->dev,
 287                                  "Speaker not enabled due to temperature\n");
 288                         return -EBUSY;
 289                 }
 290
 291                 regmap_update_bits(madera->regmap, MADERA_OUTPUT_ENABLES_1,
 292                                    1 << w->shift, 1 << w->shift);
 293                 break;
 294         case SND_SOC_DAPM_PRE_PMD:
 295                 regmap_update_bits(madera->regmap, MADERA_OUTPUT_ENABLES_1,
 296                                    1 << w->shift, 0);
 297                 break;
 298         default:
 299                 break;
 300         }
 301
 302         return 0;
 303 }
 304 EXPORT_SYMBOL_GPL(madera_spk_ev);
 305
 306 static irqreturn_t madera_thermal_warn(int irq, void *data)
 307 {
 308         struct madera *madera = data;
 309         bool warn, shutdown;
 310         int ret;
 311
 312         ret = madera_check_speaker_overheat(madera, &warn, &shutdown);
 313         if (ret || shutdown) { /* for safety attempt to shutdown on error */
 314                 dev_crit(madera->dev, "Thermal shutdown\n");
 315                 ret = regmap_update_bits(madera->regmap,
 316                                          MADERA_OUTPUT_ENABLES_1,
 317                                          MADERA_OUT4L_ENA |
 318                                          MADERA_OUT4R_ENA, 0);
 319                 if (ret != 0)
 320                         dev_crit(madera->dev,
 321                                  "Failed to disable speaker outputs: %d\n",
 322                                  ret);
 323         } else if (warn) {
 324                 dev_alert(madera->dev, "Thermal warning\n");
 325         } else {
 326                 dev_info(madera->dev, "Spurious thermal warning\n");
 327                 return IRQ_NONE;
 328         }
 329
 330         return IRQ_HANDLED;
 331 }
 332
 333 int madera_init_overheat(struct madera_priv *priv)
 334 {
 335         struct madera *madera = priv->madera;
 336         struct device *dev = madera->dev;
 337         int ret;
 338
 339         ret = madera_request_irq(madera, MADERA_IRQ_SPK_OVERHEAT_WARN,
 340                                  "Thermal warning", madera_thermal_warn,
 341                                  madera);
 342         if (ret)
 343                 dev_err(dev, "Failed to get thermal warning IRQ: %d\n", ret);
 344
 345         ret = madera_request_irq(madera, MADERA_IRQ_SPK_OVERHEAT,
 346                                  "Thermal shutdown", madera_thermal_warn,
 347                                  madera);
 348         if (ret)
 349                 dev_err(dev, "Failed to get thermal shutdown IRQ: %d\n", ret);
 350
 351         return 0;
 352 }
 353 EXPORT_SYMBOL_GPL(madera_init_overheat);
 354
 355 int madera_free_overheat(struct madera_priv *priv)
 356 {
 357         struct madera *madera = priv->madera;
 358
 359         madera_free_irq(madera, MADERA_IRQ_SPK_OVERHEAT_WARN, madera);
 360         madera_free_irq(madera, MADERA_IRQ_SPK_OVERHEAT, madera);
 361
 362         return 0;
 363 }
 364 EXPORT_SYMBOL_GPL(madera_free_overheat);
 365
 366 static int madera_get_variable_u32_array(struct device *dev,
 367                                          const char *propname,
 368                                          u32 *dest, int n_max,
 369                                          int multiple)
 370 {
 371         int n, ret;
 372
 373         n = device_property_count_u32(dev, propname);
 374         if (n < 0) {
 375                 if (n == -EINVAL)
 376                         return 0;       /* missing, ignore */
 377
 378                 dev_warn(dev, "%s malformed (%d)\n", propname, n);
 379
 380                 return n;
 381         } else if ((n % multiple) != 0) {
 382                 dev_warn(dev, "%s not a multiple of %d entries\n",
 383                          propname, multiple);
 384
 385                 return -EINVAL;
 386         }
 387
 388         if (n > n_max)
 389                 n = n_max;
 390
 391         ret = device_property_read_u32_array(dev, propname, dest, n);
 392         if (ret < 0)
 393                 return ret;
 394
 395         return n;
 396 }
 397
 398 static void madera_prop_get_inmode(struct madera_priv *priv)
 399 {
 400         struct madera *madera = priv->madera;
 401         struct madera_codec_pdata *pdata = &madera->pdata.codec;
 402         u32 tmp[MADERA_MAX_INPUT * MADERA_MAX_MUXED_CHANNELS];
 403         int n, i, in_idx, ch_idx;
 404
 405         BUILD_BUG_ON(ARRAY_SIZE(pdata->inmode) != MADERA_MAX_INPUT);
 406         BUILD_BUG_ON(ARRAY_SIZE(pdata->inmode[0]) != MADERA_MAX_MUXED_CHANNELS);
 407
 408         n = madera_get_variable_u32_array(madera->dev, "cirrus,inmode",
 409                                           tmp, ARRAY_SIZE(tmp),
 410                                           MADERA_MAX_MUXED_CHANNELS);
 411         if (n < 0)
 412                 return;
 413
 414         in_idx = 0;
 415         ch_idx = 0;
 416         for (i = 0; i < n; ++i) {
 417                 pdata->inmode[in_idx][ch_idx] = tmp[i];
 418
 419                 if (++ch_idx == MADERA_MAX_MUXED_CHANNELS) {
 420                         ch_idx = 0;
 421                         ++in_idx;
 422                 }
 423         }
 424 }
 425
 426 static void madera_prop_get_pdata(struct madera_priv *priv)
 427 {
 428         struct madera *madera = priv->madera;
 429         struct madera_codec_pdata *pdata = &madera->pdata.codec;
 430         u32 out_mono[ARRAY_SIZE(pdata->out_mono)];
 431         int i, n;
 432
 433         madera_prop_get_inmode(priv);
 434
 435         n = madera_get_variable_u32_array(madera->dev, "cirrus,out-mono",
 436                                           out_mono, ARRAY_SIZE(out_mono), 1);
 437         if (n > 0)
 438                 for (i = 0; i < n; ++i)
 439                         pdata->out_mono[i] = !!out_mono[i];
 440
 441         madera_get_variable_u32_array(madera->dev,
 442                                       "cirrus,max-channels-clocked",
 443                                       pdata->max_channels_clocked,
 444                                       ARRAY_SIZE(pdata->max_channels_clocked),
 445                                       1);
 446
 447         madera_get_variable_u32_array(madera->dev, "cirrus,pdm-fmt",
 448                                       pdata->pdm_fmt,
 449                                       ARRAY_SIZE(pdata->pdm_fmt), 1);
 450
 451         madera_get_variable_u32_array(madera->dev, "cirrus,pdm-mute",
 452                                       pdata->pdm_mute,
 453                                       ARRAY_SIZE(pdata->pdm_mute), 1);
 454
 455         madera_get_variable_u32_array(madera->dev, "cirrus,dmic-ref",
 456                                       pdata->dmic_ref,
 457                                       ARRAY_SIZE(pdata->dmic_ref), 1);
 458 }
 459
 460 int madera_core_init(struct madera_priv *priv)
 461 {
 462         int i;
 463
 464         /* trap undersized array initializers */
 465         BUILD_BUG_ON(!madera_mixer_texts[MADERA_NUM_MIXER_INPUTS - 1]);
 466         BUILD_BUG_ON(!madera_mixer_values[MADERA_NUM_MIXER_INPUTS - 1]);
 467
 468         if (!dev_get_platdata(priv->madera->dev))
 469                 madera_prop_get_pdata(priv);
 470
 471         mutex_init(&priv->rate_lock);
 472
 473         for (i = 0; i < MADERA_MAX_HP_OUTPUT; i++)
 474                 priv->madera->out_clamp[i] = true;
 475
 476         return 0;
 477 }
 478 EXPORT_SYMBOL_GPL(madera_core_init);
 479
 480 int madera_core_free(struct madera_priv *priv)
 481 {
 482         mutex_destroy(&priv->rate_lock);
 483
 484         return 0;
 485 }
 486 EXPORT_SYMBOL_GPL(madera_core_free);
 487
 488 static void madera_debug_dump_domain_groups(const struct madera_priv *priv)
 489 {
 490         struct madera *madera = priv->madera;
 491         int i;
 492
 493         for (i = 0; i < ARRAY_SIZE(priv->domain_group_ref); ++i)
 494                 dev_dbg(madera->dev, "domain_grp_ref[%d]=%d\n", i,
 495                         priv->domain_group_ref[i]);
 496 }
 497
 498 int madera_domain_clk_ev(struct snd_soc_dapm_widget *w,
 499                          struct snd_kcontrol *kcontrol,
 500                          int event)
 501 {
 502         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 503         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 504         int dom_grp = w->shift;
 505
 506         if (dom_grp >= ARRAY_SIZE(priv->domain_group_ref)) {
 507                 WARN(true, "%s dom_grp exceeds array size\n", __func__);
 508                 return -EINVAL;
 509         }
 510
 511         /*
 512          * We can't rely on the DAPM mutex for locking because we need a lock
 513          * that can safely be called in hw_params
 514          */
 515         mutex_lock(&priv->rate_lock);
 516
 517         switch (event) {
 518         case SND_SOC_DAPM_PRE_PMU:
 519                 dev_dbg(priv->madera->dev, "Inc ref on domain group %d\n",
 520                         dom_grp);
 521                 ++priv->domain_group_ref[dom_grp];
 522                 break;
 523         case SND_SOC_DAPM_POST_PMD:
 524                 dev_dbg(priv->madera->dev, "Dec ref on domain group %d\n",
 525                         dom_grp);
 526                 --priv->domain_group_ref[dom_grp];
 527                 break;
 528         default:
 529                 break;
 530         }
 531
 532         madera_debug_dump_domain_groups(priv);
 533
 534         mutex_unlock(&priv->rate_lock);
 535
 536         return 0;
 537 }
 538 EXPORT_SYMBOL_GPL(madera_domain_clk_ev);
 539
 540 int madera_out1_demux_put(struct snd_kcontrol *kcontrol,
 541                           struct snd_ctl_elem_value *ucontrol)
 542 {
 543         struct snd_soc_component *component =
 544                 snd_soc_dapm_kcontrol_component(kcontrol);
 545         struct snd_soc_dapm_context *dapm =
 546                 snd_soc_dapm_kcontrol_dapm(kcontrol);
 547         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 548         struct madera *madera = priv->madera;
 549         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 550         unsigned int ep_sel, mux, change;
 551         bool out_mono;
 552         int ret;
 553
 554         if (ucontrol->value.enumerated.item[0] > e->items - 1)
 555                 return -EINVAL;
 556
 557         mux = ucontrol->value.enumerated.item[0];
 558
 559         snd_soc_dapm_mutex_lock(dapm);
 560
 561         ep_sel = mux << MADERA_EP_SEL_SHIFT;
 562
 563         change = snd_soc_component_test_bits(component, MADERA_OUTPUT_ENABLES_1,
 564                                              MADERA_EP_SEL_MASK,
 565                                              ep_sel);
 566         if (!change)
 567                 goto end;
 568
 569         /* EP_SEL should not be modified while HP or EP driver is enabled */
 570         ret = regmap_update_bits(madera->regmap, MADERA_OUTPUT_ENABLES_1,
 571                                  MADERA_OUT1L_ENA | MADERA_OUT1R_ENA, 0);
 572         if (ret)
 573                 dev_warn(madera->dev, "Failed to disable outputs: %d\n", ret);
 574
 575         usleep_range(2000, 3000); /* wait for wseq to complete */
 576
 577         /* change demux setting */
 578         ret = 0;
 579         if (madera->out_clamp[0])
 580                 ret = regmap_update_bits(madera->regmap,
 581                                          MADERA_OUTPUT_ENABLES_1,
 582                                          MADERA_EP_SEL_MASK, ep_sel);
 583         if (ret) {
 584                 dev_err(madera->dev, "Failed to set OUT1 demux: %d\n", ret);
 585         } else {
 586                 /* apply correct setting for mono mode */
 587                 if (!ep_sel && !madera->pdata.codec.out_mono[0])
 588                         out_mono = false; /* stereo HP */
 589                 else
 590                         out_mono = true; /* EP or mono HP */
 591
 592                 ret = madera_set_output_mode(component, 1, out_mono);
 593                 if (ret)
 594                         dev_warn(madera->dev,
 595                                  "Failed to set output mode: %d\n", ret);
 596         }
 597
 598         /*
 599          * if HPDET has disabled the clamp while switching to HPOUT
 600          * OUT1 should remain disabled
 601          */
 602         if (ep_sel ||
 603             (madera->out_clamp[0] && !madera->out_shorted[0])) {
 604                 ret = regmap_update_bits(madera->regmap,
 605                                          MADERA_OUTPUT_ENABLES_1,
 606                                          MADERA_OUT1L_ENA | MADERA_OUT1R_ENA,
 607                                          madera->hp_ena);
 608                 if (ret)
 609                         dev_warn(madera->dev,
 610                                  "Failed to restore earpiece outputs: %d\n",
 611                                  ret);
 612                 else if (madera->hp_ena)
 613                         msleep(34); /* wait for enable wseq */
 614                 else
 615                         usleep_range(2000, 3000); /* wait for disable wseq */
 616         }
 617
 618 end:
 619         snd_soc_dapm_mutex_unlock(dapm);
 620
 621         return snd_soc_dapm_mux_update_power(dapm, kcontrol, mux, e, NULL);
 622 }
 623 EXPORT_SYMBOL_GPL(madera_out1_demux_put);
 624
 625 int madera_out1_demux_get(struct snd_kcontrol *kcontrol,
 626                           struct snd_ctl_elem_value *ucontrol)
 627 {
 628         struct snd_soc_component *component =
 629                 snd_soc_dapm_kcontrol_component(kcontrol);
 630         unsigned int val;
 631         int ret;
 632
 633         ret = snd_soc_component_read(component, MADERA_OUTPUT_ENABLES_1, &val);
 634         if (ret)
 635                 return ret;
 636
 637         val &= MADERA_EP_SEL_MASK;
 638         val >>= MADERA_EP_SEL_SHIFT;
 639         ucontrol->value.enumerated.item[0] = val;
 640
 641         return 0;
 642 }
 643 EXPORT_SYMBOL_GPL(madera_out1_demux_get);
 644
 645 static int madera_inmux_put(struct snd_kcontrol *kcontrol,
 646                             struct snd_ctl_elem_value *ucontrol)
 647 {
 648         struct snd_soc_component *component =
 649                 snd_soc_dapm_kcontrol_component(kcontrol);
 650         struct snd_soc_dapm_context *dapm =
 651                 snd_soc_dapm_kcontrol_dapm(kcontrol);
 652         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 653         struct madera *madera = priv->madera;
 654         struct regmap *regmap = madera->regmap;
 655         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 656         unsigned int mux, val, mask;
 657         unsigned int inmode;
 658         bool changed;
 659         int ret;
 660
 661         mux = ucontrol->value.enumerated.item[0];
 662         if (mux > 1)
 663                 return -EINVAL;
 664
 665         val = mux << e->shift_l;
 666         mask = (e->mask << e->shift_l) | MADERA_IN1L_SRC_SE_MASK;
 667
 668         switch (e->reg) {
 669         case MADERA_ADC_DIGITAL_VOLUME_1L:
 670                 inmode = madera->pdata.codec.inmode[0][2 * mux];
 671                 break;
 672         case MADERA_ADC_DIGITAL_VOLUME_1R:
 673                 inmode = madera->pdata.codec.inmode[0][1 + (2 * mux)];
 674                 break;
 675         case MADERA_ADC_DIGITAL_VOLUME_2L:
 676                 inmode = madera->pdata.codec.inmode[1][2 * mux];
 677                 break;
 678         case MADERA_ADC_DIGITAL_VOLUME_2R:
 679                 inmode = madera->pdata.codec.inmode[1][1 + (2 * mux)];
 680                 break;
 681         default:
 682                 return -EINVAL;
 683         }
 684
 685         if (inmode & MADERA_INMODE_SE)
 686                 val |= 1 << MADERA_IN1L_SRC_SE_SHIFT;
 687
 688         dev_dbg(madera->dev, "mux=%u reg=0x%x inmode=0x%x mask=0x%x val=0x%x\n",
 689                 mux, e->reg, inmode, mask, val);
 690
 691         ret = regmap_update_bits_check(regmap, e->reg, mask, val, &changed);
 692         if (ret < 0)
 693                 return ret;
 694
 695         if (changed)
 696                 return snd_soc_dapm_mux_update_power(dapm, kcontrol,
 697                                                      mux, e, NULL);
 698         else
 699                 return 0;
 700 }
 701
 702 static const char * const madera_inmux_texts[] = {
 703         "A",
 704         "B",
 705 };
 706
 707 static SOC_ENUM_SINGLE_DECL(madera_in1muxl_enum,
 708                             MADERA_ADC_DIGITAL_VOLUME_1L,
 709                             MADERA_IN1L_SRC_SHIFT,
 710                             madera_inmux_texts);
 711
 712 static SOC_ENUM_SINGLE_DECL(madera_in1muxr_enum,
 713                             MADERA_ADC_DIGITAL_VOLUME_1R,
 714                             MADERA_IN1R_SRC_SHIFT,
 715                             madera_inmux_texts);
 716
 717 static SOC_ENUM_SINGLE_DECL(madera_in2muxl_enum,
 718                             MADERA_ADC_DIGITAL_VOLUME_2L,
 719                             MADERA_IN2L_SRC_SHIFT,
 720                             madera_inmux_texts);
 721
 722 static SOC_ENUM_SINGLE_DECL(madera_in2muxr_enum,
 723                             MADERA_ADC_DIGITAL_VOLUME_2R,
 724                             MADERA_IN2R_SRC_SHIFT,
 725                             madera_inmux_texts);
 726
 727 const struct snd_kcontrol_new madera_inmux[] = {
 728         SOC_DAPM_ENUM_EXT("IN1L Mux", madera_in1muxl_enum,
 729                           snd_soc_dapm_get_enum_double, madera_inmux_put),
 730         SOC_DAPM_ENUM_EXT("IN1R Mux", madera_in1muxr_enum,
 731                           snd_soc_dapm_get_enum_double, madera_inmux_put),
 732         SOC_DAPM_ENUM_EXT("IN2L Mux", madera_in2muxl_enum,
 733                           snd_soc_dapm_get_enum_double, madera_inmux_put),
 734         SOC_DAPM_ENUM_EXT("IN2R Mux", madera_in2muxr_enum,
 735                           snd_soc_dapm_get_enum_double, madera_inmux_put),
 736 };
 737 EXPORT_SYMBOL_GPL(madera_inmux);
 738
 739 static const char * const madera_dmode_texts[] = {
 740         "Analog",
 741         "Digital",
 742 };
 743
 744 static SOC_ENUM_SINGLE_DECL(madera_in1dmode_enum,
 745                             MADERA_IN1L_CONTROL,
 746                             MADERA_IN1_MODE_SHIFT,
 747                             madera_dmode_texts);
 748
 749 static SOC_ENUM_SINGLE_DECL(madera_in2dmode_enum,
 750                             MADERA_IN2L_CONTROL,
 751                             MADERA_IN2_MODE_SHIFT,
 752                             madera_dmode_texts);
 753
 754 static SOC_ENUM_SINGLE_DECL(madera_in3dmode_enum,
 755                             MADERA_IN3L_CONTROL,
 756                             MADERA_IN3_MODE_SHIFT,
 757                             madera_dmode_texts);
 758
 759 const struct snd_kcontrol_new madera_inmode[] = {
 760         SOC_DAPM_ENUM("IN1 Mode", madera_in1dmode_enum),
 761         SOC_DAPM_ENUM("IN2 Mode", madera_in2dmode_enum),
 762         SOC_DAPM_ENUM("IN3 Mode", madera_in3dmode_enum),
 763 };
 764 EXPORT_SYMBOL_GPL(madera_inmode);
 765
 766 static bool madera_can_change_grp_rate(const struct madera_priv *priv,
 767                                        unsigned int reg)
 768 {
 769         int count;
 770
 771         switch (reg) {
 772         case MADERA_FX_CTRL1:
 773                 count = priv->domain_group_ref[MADERA_DOM_GRP_FX];
 774                 break;
 775         case MADERA_ASRC1_RATE1:
 776         case MADERA_ASRC1_RATE2:
 777                 count = priv->domain_group_ref[MADERA_DOM_GRP_ASRC1];
 778                 break;
 779         case MADERA_ASRC2_RATE1:
 780         case MADERA_ASRC2_RATE2:
 781                 count = priv->domain_group_ref[MADERA_DOM_GRP_ASRC2];
 782                 break;
 783         case MADERA_ISRC_1_CTRL_1:
 784         case MADERA_ISRC_1_CTRL_2:
 785                 count = priv->domain_group_ref[MADERA_DOM_GRP_ISRC1];
 786                 break;
 787         case MADERA_ISRC_2_CTRL_1:
 788         case MADERA_ISRC_2_CTRL_2:
 789                 count = priv->domain_group_ref[MADERA_DOM_GRP_ISRC2];
 790                 break;
 791         case MADERA_ISRC_3_CTRL_1:
 792         case MADERA_ISRC_3_CTRL_2:
 793                 count = priv->domain_group_ref[MADERA_DOM_GRP_ISRC3];
 794                 break;
 795         case MADERA_ISRC_4_CTRL_1:
 796         case MADERA_ISRC_4_CTRL_2:
 797                 count = priv->domain_group_ref[MADERA_DOM_GRP_ISRC4];
 798                 break;
 799         case MADERA_OUTPUT_RATE_1:
 800                 count = priv->domain_group_ref[MADERA_DOM_GRP_OUT];
 801                 break;
 802         case MADERA_SPD1_TX_CONTROL:
 803                 count = priv->domain_group_ref[MADERA_DOM_GRP_SPD];
 804                 break;
 805         case MADERA_DSP1_CONFIG_1:
 806         case MADERA_DSP1_CONFIG_2:
 807                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP1];
 808                 break;
 809         case MADERA_DSP2_CONFIG_1:
 810         case MADERA_DSP2_CONFIG_2:
 811                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP2];
 812                 break;
 813         case MADERA_DSP3_CONFIG_1:
 814         case MADERA_DSP3_CONFIG_2:
 815                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP3];
 816                 break;
 817         case MADERA_DSP4_CONFIG_1:
 818         case MADERA_DSP4_CONFIG_2:
 819                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP4];
 820                 break;
 821         case MADERA_DSP5_CONFIG_1:
 822         case MADERA_DSP5_CONFIG_2:
 823                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP5];
 824                 break;
 825         case MADERA_DSP6_CONFIG_1:
 826         case MADERA_DSP6_CONFIG_2:
 827                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP6];
 828                 break;
 829         case MADERA_DSP7_CONFIG_1:
 830         case MADERA_DSP7_CONFIG_2:
 831                 count = priv->domain_group_ref[MADERA_DOM_GRP_DSP7];
 832                 break;
 833         case MADERA_AIF1_RATE_CTRL:
 834                 count = priv->domain_group_ref[MADERA_DOM_GRP_AIF1];
 835                 break;
 836         case MADERA_AIF2_RATE_CTRL:
 837                 count = priv->domain_group_ref[MADERA_DOM_GRP_AIF2];
 838                 break;
 839         case MADERA_AIF3_RATE_CTRL:
 840                 count = priv->domain_group_ref[MADERA_DOM_GRP_AIF3];
 841                 break;
 842         case MADERA_AIF4_RATE_CTRL:
 843                 count = priv->domain_group_ref[MADERA_DOM_GRP_AIF4];
 844                 break;
 845         case MADERA_SLIMBUS_RATES_1:
 846         case MADERA_SLIMBUS_RATES_2:
 847         case MADERA_SLIMBUS_RATES_3:
 848         case MADERA_SLIMBUS_RATES_4:
 849         case MADERA_SLIMBUS_RATES_5:
 850         case MADERA_SLIMBUS_RATES_6:
 851         case MADERA_SLIMBUS_RATES_7:
 852         case MADERA_SLIMBUS_RATES_8:
 853                 count = priv->domain_group_ref[MADERA_DOM_GRP_SLIMBUS];
 854                 break;
 855         case MADERA_PWM_DRIVE_1:
 856                 count = priv->domain_group_ref[MADERA_DOM_GRP_PWM];
 857                 break;
 858         default:
 859                 return false;
 860         }
 861
 862         dev_dbg(priv->madera->dev, "Rate reg 0x%x group ref %d\n", reg, count);
 863
 864         if (count)
 865                 return false;
 866         else
 867                 return true;
 868 }
 869
 870 static int madera_adsp_rate_get(struct snd_kcontrol *kcontrol,
 871                                 struct snd_ctl_elem_value *ucontrol)
 872 {
 873         struct snd_soc_component *component =
 874                 snd_soc_kcontrol_component(kcontrol);
 875         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 876         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 877         unsigned int cached_rate;
 878         const int adsp_num = e->shift_l;
 879         int item;
 880
 881         mutex_lock(&priv->rate_lock);
 882         cached_rate = priv->adsp_rate_cache[adsp_num];
 883         mutex_unlock(&priv->rate_lock);
 884
 885         item = snd_soc_enum_val_to_item(e, cached_rate);
 886         ucontrol->value.enumerated.item[0] = item;
 887
 888         return 0;
 889 }
 890
 891 static int madera_adsp_rate_put(struct snd_kcontrol *kcontrol,
 892                                 struct snd_ctl_elem_value *ucontrol)
 893 {
 894         struct snd_soc_component *component =
 895                 snd_soc_kcontrol_component(kcontrol);
 896         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
 897         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 898         const int adsp_num = e->shift_l;
 899         const unsigned int item = ucontrol->value.enumerated.item[0];
 900         int ret;
 901
 902         if (item >= e->items)
 903                 return -EINVAL;
 904
 905         /*
 906          * We don't directly write the rate register here but we want to
 907          * maintain consistent behaviour that rate domains cannot be changed
 908          * while in use since this is a hardware requirement
 909          */
 910         mutex_lock(&priv->rate_lock);
 911
 912         if (!madera_can_change_grp_rate(priv, priv->adsp[adsp_num].base)) {
 913                 dev_warn(priv->madera->dev,
 914                          "Cannot change '%s' while in use by active audio paths\n",
 915                          kcontrol->id.name);
 916                 ret = -EBUSY;
 917         } else {
 918                 /* Volatile register so defer until the codec is powered up */
 919                 priv->adsp_rate_cache[adsp_num] = e->values[item];
 920                 ret = 0;
 921         }
 922
 923         mutex_unlock(&priv->rate_lock);
 924
 925         return ret;
 926 }
 927
 928 static const struct soc_enum madera_adsp_rate_enum[] = {
 929         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 0, 0xf, MADERA_RATE_ENUM_SIZE,
 930                               madera_rate_text, madera_rate_val),
 931         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 1, 0xf, MADERA_RATE_ENUM_SIZE,
 932                               madera_rate_text, madera_rate_val),
 933         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 2, 0xf, MADERA_RATE_ENUM_SIZE,
 934                               madera_rate_text, madera_rate_val),
 935         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 3, 0xf, MADERA_RATE_ENUM_SIZE,
 936                               madera_rate_text, madera_rate_val),
 937         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 4, 0xf, MADERA_RATE_ENUM_SIZE,
 938                               madera_rate_text, madera_rate_val),
 939         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 5, 0xf, MADERA_RATE_ENUM_SIZE,
 940                               madera_rate_text, madera_rate_val),
 941         SOC_VALUE_ENUM_SINGLE(SND_SOC_NOPM, 6, 0xf, MADERA_RATE_ENUM_SIZE,
 942                               madera_rate_text, madera_rate_val),
 943 };
 944
 945 const struct snd_kcontrol_new madera_adsp_rate_controls[] = {
 946         SOC_ENUM_EXT("DSP1 Rate", madera_adsp_rate_enum[0],
 947                      madera_adsp_rate_get, madera_adsp_rate_put),
 948         SOC_ENUM_EXT("DSP2 Rate", madera_adsp_rate_enum[1],
 949                      madera_adsp_rate_get, madera_adsp_rate_put),
 950         SOC_ENUM_EXT("DSP3 Rate", madera_adsp_rate_enum[2],
 951                      madera_adsp_rate_get, madera_adsp_rate_put),
 952         SOC_ENUM_EXT("DSP4 Rate", madera_adsp_rate_enum[3],
 953                      madera_adsp_rate_get, madera_adsp_rate_put),
 954         SOC_ENUM_EXT("DSP5 Rate", madera_adsp_rate_enum[4],
 955                      madera_adsp_rate_get, madera_adsp_rate_put),
 956         SOC_ENUM_EXT("DSP6 Rate", madera_adsp_rate_enum[5],
 957                      madera_adsp_rate_get, madera_adsp_rate_put),
 958         SOC_ENUM_EXT("DSP7 Rate", madera_adsp_rate_enum[6],
 959                      madera_adsp_rate_get, madera_adsp_rate_put),
 960 };
 961 EXPORT_SYMBOL_GPL(madera_adsp_rate_controls);
 962
 963 static int madera_write_adsp_clk_setting(struct madera_priv *priv,
 964                                          struct wm_adsp *dsp,
 965                                          unsigned int freq)
 966 {
 967         unsigned int val;
 968         unsigned int mask = MADERA_DSP_RATE_MASK;
 969         int ret;
 970
 971         val = priv->adsp_rate_cache[dsp->num - 1] << MADERA_DSP_RATE_SHIFT;
 972
 973         switch (priv->madera->type) {
 974         case CS47L35:
 975         case CS47L85:
 976         case WM1840:
 977                 /* use legacy frequency registers */
 978                 mask |= MADERA_DSP_CLK_SEL_MASK;
 979                 val |= (freq << MADERA_DSP_CLK_SEL_SHIFT);
 980                 break;
 981         default:
 982                 /* Configure exact dsp frequency */
 983                 dev_dbg(priv->madera->dev, "Set DSP frequency to 0x%x\n", freq);
 984
 985                 ret = regmap_write(dsp->regmap,
 986                                    dsp->base + MADERA_DSP_CONFIG_2_OFFS, freq);
 987                 if (ret)
 988                         goto err;
 989                 break;
 990         }
 991
 992         ret = regmap_update_bits(dsp->regmap,
 993                                  dsp->base + MADERA_DSP_CONFIG_1_OFFS,
 994                                  mask, val);
 995         if (ret)
 996                 goto err;
 997
 998         dev_dbg(priv->madera->dev, "Set DSP clocking to 0x%x\n", val);
 999
1000         return 0;
1001
1002 err:
1003         dev_err(dsp->dev, "Failed to set DSP%d clock: %d\n", dsp->num, ret);
1004
1005         return ret;
1006 }
1007
1008 int madera_set_adsp_clk(struct madera_priv *priv, int dsp_num,
1009                         unsigned int freq)
1010 {
1011         struct wm_adsp *dsp = &priv->adsp[dsp_num];
1012         struct madera *madera = priv->madera;
1013         unsigned int cur, new;
1014         int ret;
1015
1016         /*
1017          * This is called at a higher DAPM priority than the mux widgets so
1018          * the muxes are still off at this point and it's safe to change
1019          * the rate domain control.
1020          * Also called at a lower DAPM priority than the domain group widgets
1021          * so locking the reads of adsp_rate_cache is not necessary as we know
1022          * changes are locked out by the domain_group_ref reference count.
1023          */
1024
1025         ret = regmap_read(dsp->regmap,  dsp->base, &cur);
1026         if (ret) {
1027                 dev_err(madera->dev,
1028                         "Failed to read current DSP rate: %d\n", ret);
1029                 return ret;
1030         }
1031
1032         cur &= MADERA_DSP_RATE_MASK;
1033
1034         new = priv->adsp_rate_cache[dsp->num - 1] << MADERA_DSP_RATE_SHIFT;
1035
1036         if (new == cur) {
1037                 dev_dbg(madera->dev, "DSP rate not changed\n");
1038                 return madera_write_adsp_clk_setting(priv, dsp, freq);
1039         } else {
1040                 dev_dbg(madera->dev, "DSP rate changed\n");
1041
1042                 /* The write must be guarded by a number of SYSCLK cycles */
1043                 madera_spin_sysclk(priv);
1044                 ret = madera_write_adsp_clk_setting(priv, dsp, freq);
1045                 madera_spin_sysclk(priv);
1046                 return ret;
1047         }
1048 }
1049 EXPORT_SYMBOL_GPL(madera_set_adsp_clk);
1050
1051 int madera_rate_put(struct snd_kcontrol *kcontrol,
1052                     struct snd_ctl_elem_value *ucontrol)
1053 {
1054         struct snd_soc_component *component =
1055                 snd_soc_kcontrol_component(kcontrol);
1056         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
1057         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1058         unsigned int item = ucontrol->value.enumerated.item[0];
1059         unsigned int val;
1060         int ret;
1061
1062         if (item >= e->items)
1063                 return -EINVAL;
1064
1065         /*
1066          * Prevent the domain powering up while we're checking whether it's
1067          * safe to change rate domain
1068          */
1069         mutex_lock(&priv->rate_lock);
1070
1071         ret = snd_soc_component_read(component, e->reg, &val);
1072         if (ret < 0) {
1073                 dev_warn(priv->madera->dev, "Failed to read 0x%x (%d)\n",
1074                          e->reg, ret);
1075                 goto out;
1076         }
1077         val >>= e->shift_l;
1078         val &= e->mask;
1079         if (snd_soc_enum_item_to_val(e, item) == val) {
1080                 ret = 0;
1081                 goto out;
1082         }
1083
1084         if (!madera_can_change_grp_rate(priv, e->reg)) {
1085                 dev_warn(priv->madera->dev,
1086                          "Cannot change '%s' while in use by active audio paths\n",
1087                          kcontrol->id.name);
1088                 ret = -EBUSY;
1089         } else {
1090                 /* The write must be guarded by a number of SYSCLK cycles */
1091                 madera_spin_sysclk(priv);
1092                 ret = snd_soc_put_enum_double(kcontrol, ucontrol);
1093                 madera_spin_sysclk(priv);
1094         }
1095 out:
1096         mutex_unlock(&priv->rate_lock);
1097
1098         return ret;
1099 }
1100 EXPORT_SYMBOL_GPL(madera_rate_put);
1101
1102 static void madera_configure_input_mode(struct madera *madera)
1103 {
1104         unsigned int dig_mode, ana_mode_l, ana_mode_r;
1105         int max_analogue_inputs, max_dmic_sup, i;
1106
1107         switch (madera->type) {
1108         case CS47L15:
1109                 max_analogue_inputs = 1;
1110                 max_dmic_sup = 2;
1111                 break;
1112         case CS47L35:
1113                 max_analogue_inputs = 2;
1114                 max_dmic_sup = 2;
1115                 break;
1116         case CS47L85:
1117         case WM1840:
1118                 max_analogue_inputs = 3;
1119                 max_dmic_sup = 3;
1120                 break;
1121         case CS47L90:
1122         case CS47L91:
1123                 max_analogue_inputs = 2;
1124                 max_dmic_sup = 2;
1125                 break;
1126         default:
1127                 max_analogue_inputs = 2;
1128                 max_dmic_sup = 4;
1129                 break;
1130         }
1131
1132         /*
1133          * Initialize input modes from the A settings. For muxed inputs the
1134          * B settings will be applied if the mux is changed
1135          */
1136         for (i = 0; i < max_dmic_sup; i++) {
1137                 dev_dbg(madera->dev, "IN%d mode %u:%u:%u:%u\n", i + 1,
1138                         madera->pdata.codec.inmode[i][0],
1139                         madera->pdata.codec.inmode[i][1],
1140                         madera->pdata.codec.inmode[i][2],
1141                         madera->pdata.codec.inmode[i][3]);
1142
1143                 dig_mode = madera->pdata.codec.dmic_ref[i] <<
1144                            MADERA_IN1_DMIC_SUP_SHIFT;
1145
1146                 switch (madera->pdata.codec.inmode[i][0]) {
1147                 case MADERA_INMODE_DIFF:
1148                         ana_mode_l = 0;
1149                         break;
1150                 case MADERA_INMODE_SE:
1151                         ana_mode_l = 1 << MADERA_IN1L_SRC_SE_SHIFT;
1152                         break;
1153                 default:
1154                         dev_warn(madera->dev,
1155                                  "IN%dAL Illegal inmode %u ignored\n",
1156                                  i + 1, madera->pdata.codec.inmode[i][0]);
1157                         continue;
1158                 }
1159
1160                 switch (madera->pdata.codec.inmode[i][1]) {
1161                 case MADERA_INMODE_DIFF:
1162                         ana_mode_r = 0;
1163                         break;
1164                 case MADERA_INMODE_SE:
1165                         ana_mode_r = 1 << MADERA_IN1R_SRC_SE_SHIFT;
1166                         break;
1167                 default:
1168                         dev_warn(madera->dev,
1169                                  "IN%dAR Illegal inmode %u ignored\n",
1170                                  i + 1, madera->pdata.codec.inmode[i][1]);
1171                         continue;
1172                 }
1173
1174                 dev_dbg(madera->dev,
1175                         "IN%dA DMIC mode=0x%x Analogue mode=0x%x,0x%x\n",
1176                         i + 1, dig_mode, ana_mode_l, ana_mode_r);
1177
1178                 regmap_update_bits(madera->regmap,
1179                                    MADERA_IN1L_CONTROL + (i * 8),
1180                                    MADERA_IN1_DMIC_SUP_MASK, dig_mode);
1181
1182                 if (i >= max_analogue_inputs)
1183                         continue;
1184
1185                 regmap_update_bits(madera->regmap,
1186                                    MADERA_ADC_DIGITAL_VOLUME_1L + (i * 8),
1187                                    MADERA_IN1L_SRC_SE_MASK, ana_mode_l);
1188
1189                 regmap_update_bits(madera->regmap,
1190                                    MADERA_ADC_DIGITAL_VOLUME_1R + (i * 8),
1191                                    MADERA_IN1R_SRC_SE_MASK, ana_mode_r);
1192         }
1193 }
1194
1195 int madera_init_inputs(struct snd_soc_component *component)
1196 {
1197         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
1198         struct madera *madera = priv->madera;
1199
1200         madera_configure_input_mode(madera);
1201
1202         return 0;
1203 }
1204 EXPORT_SYMBOL_GPL(madera_init_inputs);
1205
1206 static const struct snd_soc_dapm_route madera_mono_routes[] = {
1207         { "OUT1R", NULL, "OUT1L" },
1208         { "OUT2R", NULL, "OUT2L" },
1209         { "OUT3R", NULL, "OUT3L" },
1210         { "OUT4R", NULL, "OUT4L" },
1211         { "OUT5R", NULL, "OUT5L" },
1212         { "OUT6R", NULL, "OUT6L" },
1213 };
1214
1215 int madera_init_outputs(struct snd_soc_component *component,
1216                         const struct snd_soc_dapm_route *routes,
1217                         int n_mono_routes, int n_real)
1218 {
1219         struct snd_soc_dapm_context *dapm =
1220                 snd_soc_component_get_dapm(component);
1221         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
1222         struct madera *madera = priv->madera;
1223         const struct madera_codec_pdata *pdata = &madera->pdata.codec;
1224         unsigned int val;
1225         int i;
1226
1227         if (n_mono_routes > MADERA_MAX_OUTPUT) {
1228                 dev_warn(madera->dev,
1229                          "Requested %d mono outputs, using maximum allowed %d\n",
1230                          n_mono_routes, MADERA_MAX_OUTPUT);
1231                 n_mono_routes = MADERA_MAX_OUTPUT;
1232         }
1233
1234         if (!routes)
1235                 routes = madera_mono_routes;
1236
1237         for (i = 0; i < n_mono_routes; i++) {
1238                 /* Default is 0 so noop with defaults */
1239                 if (pdata->out_mono[i]) {
1240                         val = MADERA_OUT1_MONO;
1241                         snd_soc_dapm_add_routes(dapm, &routes[i], 1);
1242                 } else {
1243                         val = 0;
1244                 }
1245
1246                 if (i >= n_real)
1247                         continue;
1248
1249                 regmap_update_bits(madera->regmap,
1250                                    MADERA_OUTPUT_PATH_CONFIG_1L + (i * 8),
1251                                    MADERA_OUT1_MONO, val);
1252
1253                 dev_dbg(madera->dev, "OUT%d mono=0x%x\n", i + 1, val);
1254         }
1255
1256         for (i = 0; i < MADERA_MAX_PDM_SPK; i++) {
1257                 dev_dbg(madera->dev, "PDM%d fmt=0x%x mute=0x%x\n", i + 1,
1258                         pdata->pdm_fmt[i], pdata->pdm_mute[i]);
1259
1260                 if (pdata->pdm_mute[i])
1261                         regmap_update_bits(madera->regmap,
1262                                            MADERA_PDM_SPK1_CTRL_1 + (i * 2),
1263                                            MADERA_SPK1_MUTE_ENDIAN_MASK |
1264                                            MADERA_SPK1_MUTE_SEQ1_MASK,
1265                                            pdata->pdm_mute[i]);
1266
1267                 if (pdata->pdm_fmt[i])
1268                         regmap_update_bits(madera->regmap,
1269                                            MADERA_PDM_SPK1_CTRL_2 + (i * 2),
1270                                            MADERA_SPK1_FMT_MASK,
1271                                            pdata->pdm_fmt[i]);
1272         }
1273
1274         return 0;
1275 }
1276 EXPORT_SYMBOL_GPL(madera_init_outputs);
1277
1278 int madera_init_bus_error_irq(struct madera_priv *priv, int dsp_num,
1279                               irq_handler_t handler)
1280 {
1281         struct madera *madera = priv->madera;
1282         int ret;
1283
1284         ret = madera_request_irq(madera,
1285                                  madera_dsp_bus_error_irqs[dsp_num],
1286                                  "ADSP2 bus error",
1287                                  handler,
1288                                  &priv->adsp[dsp_num]);
1289         if (ret)
1290                 dev_err(madera->dev,
1291                         "Failed to request DSP Lock region IRQ: %d\n", ret);
1292
1293         return ret;
1294 }
1295 EXPORT_SYMBOL_GPL(madera_init_bus_error_irq);
1296
1297 void madera_free_bus_error_irq(struct madera_priv *priv, int dsp_num)
1298 {
1299         struct madera *madera = priv->madera;
1300
1301         madera_free_irq(madera,
1302                         madera_dsp_bus_error_irqs[dsp_num],
1303                         &priv->adsp[dsp_num]);
1304 }
1305 EXPORT_SYMBOL_GPL(madera_free_bus_error_irq);
1306
1307 const char * const madera_mixer_texts[] = {
1308         "None",
1309         "Tone Generator 1",
1310         "Tone Generator 2",
1311         "Haptics",
1312         "AEC1",
1313         "AEC2",
1314         "Mic Mute Mixer",
1315         "Noise Generator",
1316         "IN1L",
1317         "IN1R",
1318         "IN2L",
1319         "IN2R",
1320         "IN3L",
1321         "IN3R",
1322         "IN4L",
1323         "IN4R",
1324         "IN5L",
1325         "IN5R",
1326         "IN6L",
1327         "IN6R",
1328         "AIF1RX1",
1329         "AIF1RX2",
1330         "AIF1RX3",
1331         "AIF1RX4",
1332         "AIF1RX5",
1333         "AIF1RX6",
1334         "AIF1RX7",
1335         "AIF1RX8",
1336         "AIF2RX1",
1337         "AIF2RX2",
1338         "AIF2RX3",
1339         "AIF2RX4",
1340         "AIF2RX5",
1341         "AIF2RX6",
1342         "AIF2RX7",
1343         "AIF2RX8",
1344         "AIF3RX1",
1345         "AIF3RX2",
1346         "AIF3RX3",
1347         "AIF3RX4",
1348         "AIF4RX1",
1349         "AIF4RX2",
1350         "SLIMRX1",
1351         "SLIMRX2",
1352         "SLIMRX3",
1353         "SLIMRX4",
1354         "SLIMRX5",
1355         "SLIMRX6",
1356         "SLIMRX7",
1357         "SLIMRX8",
1358         "EQ1",
1359         "EQ2",
1360         "EQ3",
1361         "EQ4",
1362         "DRC1L",
1363         "DRC1R",
1364         "DRC2L",
1365         "DRC2R",
1366         "LHPF1",
1367         "LHPF2",
1368         "LHPF3",
1369         "LHPF4",
1370         "DSP1.1",
1371         "DSP1.2",
1372         "DSP1.3",
1373         "DSP1.4",
1374         "DSP1.5",
1375         "DSP1.6",
1376         "DSP2.1",
1377         "DSP2.2",
1378         "DSP2.3",
1379         "DSP2.4",
1380         "DSP2.5",
1381         "DSP2.6",
1382         "DSP3.1",
1383         "DSP3.2",
1384         "DSP3.3",
1385         "DSP3.4",
1386         "DSP3.5",
1387         "DSP3.6",
1388         "DSP4.1",
1389         "DSP4.2",
1390         "DSP4.3",
1391         "DSP4.4",
1392         "DSP4.5",
1393         "DSP4.6",
1394         "DSP5.1",
1395         "DSP5.2",
1396         "DSP5.3",
1397         "DSP5.4",
1398         "DSP5.5",
1399         "DSP5.6",
1400         "DSP6.1",
1401         "DSP6.2",
1402         "DSP6.3",
1403         "DSP6.4",
1404         "DSP6.5",
1405         "DSP6.6",
1406         "DSP7.1",
1407         "DSP7.2",
1408         "DSP7.3",
1409         "DSP7.4",
1410         "DSP7.5",
1411         "DSP7.6",
1412         "ASRC1IN1L",
1413         "ASRC1IN1R",
1414         "ASRC1IN2L",
1415         "ASRC1IN2R",
1416         "ASRC2IN1L",
1417         "ASRC2IN1R",
1418         "ASRC2IN2L",
1419         "ASRC2IN2R",
1420         "ISRC1INT1",
1421         "ISRC1INT2",
1422         "ISRC1INT3",
1423         "ISRC1INT4",
1424         "ISRC1DEC1",
1425         "ISRC1DEC2",
1426         "ISRC1DEC3",
1427         "ISRC1DEC4",
1428         "ISRC2INT1",
1429         "ISRC2INT2",
1430         "ISRC2INT3",
1431         "ISRC2INT4",
1432         "ISRC2DEC1",
1433         "ISRC2DEC2",
1434         "ISRC2DEC3",
1435         "ISRC2DEC4",
1436         "ISRC3INT1",
1437         "ISRC3INT2",
1438         "ISRC3INT3",
1439         "ISRC3INT4",
1440         "ISRC3DEC1",
1441         "ISRC3DEC2",
1442         "ISRC3DEC3",
1443         "ISRC3DEC4",
1444         "ISRC4INT1",
1445         "ISRC4INT2",
1446         "ISRC4DEC1",
1447         "ISRC4DEC2",
1448         "DFC1",
1449         "DFC2",
1450         "DFC3",
1451         "DFC4",
1452         "DFC5",
1453         "DFC6",
1454         "DFC7",
1455         "DFC8",
1456 };
1457 EXPORT_SYMBOL_GPL(madera_mixer_texts);
1458
1459 const unsigned int madera_mixer_values[] = {
1460         0x00,   /* None */
1461         0x04,   /* Tone Generator 1 */
1462         0x05,   /* Tone Generator 2 */
1463         0x06,   /* Haptics */
1464         0x08,   /* AEC */
1465         0x09,   /* AEC2 */
1466         0x0c,   /* Noise mixer */
1467         0x0d,   /* Comfort noise */
1468         0x10,   /* IN1L */
1469         0x11,
1470         0x12,
1471         0x13,
1472         0x14,
1473         0x15,
1474         0x16,
1475         0x17,
1476         0x18,
1477         0x19,
1478         0x1A,
1479         0x1B,
1480         0x20,   /* AIF1RX1 */
1481         0x21,
1482         0x22,
1483         0x23,
1484         0x24,
1485         0x25,
1486         0x26,
1487         0x27,
1488         0x28,   /* AIF2RX1 */
1489         0x29,
1490         0x2a,
1491         0x2b,
1492         0x2c,
1493         0x2d,
1494         0x2e,
1495         0x2f,
1496         0x30,   /* AIF3RX1 */
1497         0x31,
1498         0x32,
1499         0x33,
1500         0x34,   /* AIF4RX1 */
1501         0x35,
1502         0x38,   /* SLIMRX1 */
1503         0x39,
1504         0x3a,
1505         0x3b,
1506         0x3c,
1507         0x3d,
1508         0x3e,
1509         0x3f,
1510         0x50,   /* EQ1 */
1511         0x51,
1512         0x52,
1513         0x53,
1514         0x58,   /* DRC1L */
1515         0x59,
1516         0x5a,
1517         0x5b,
1518         0x60,   /* LHPF1 */
1519         0x61,
1520         0x62,
1521         0x63,
1522         0x68,   /* DSP1.1 */
1523         0x69,
1524         0x6a,
1525         0x6b,
1526         0x6c,
1527         0x6d,
1528         0x70,   /* DSP2.1 */
1529         0x71,
1530         0x72,
1531         0x73,
1532         0x74,
1533         0x75,
1534         0x78,   /* DSP3.1 */
1535         0x79,
1536         0x7a,
1537         0x7b,
1538         0x7c,
1539         0x7d,
1540         0x80,   /* DSP4.1 */
1541         0x81,
1542         0x82,
1543         0x83,
1544         0x84,
1545         0x85,
1546         0x88,   /* DSP5.1 */
1547         0x89,
1548         0x8a,
1549         0x8b,
1550         0x8c,
1551         0x8d,
1552         0xc0,   /* DSP6.1 */
1553         0xc1,
1554         0xc2,
1555         0xc3,
1556         0xc4,
1557         0xc5,
1558         0xc8,   /* DSP7.1 */
1559         0xc9,
1560         0xca,
1561         0xcb,
1562         0xcc,
1563         0xcd,
1564         0x90,   /* ASRC1IN1L */
1565         0x91,
1566         0x92,
1567         0x93,
1568         0x94,   /* ASRC2IN1L */
1569         0x95,
1570         0x96,
1571         0x97,
1572         0xa0,   /* ISRC1INT1 */
1573         0xa1,
1574         0xa2,
1575         0xa3,
1576         0xa4,   /* ISRC1DEC1 */
1577         0xa5,
1578         0xa6,
1579         0xa7,
1580         0xa8,   /* ISRC2DEC1 */
1581         0xa9,
1582         0xaa,
1583         0xab,
1584         0xac,   /* ISRC2INT1 */
1585         0xad,
1586         0xae,
1587         0xaf,
1588         0xb0,   /* ISRC3DEC1 */
1589         0xb1,
1590         0xb2,
1591         0xb3,
1592         0xb4,   /* ISRC3INT1 */
1593         0xb5,
1594         0xb6,
1595         0xb7,
1596         0xb8,   /* ISRC4INT1 */
1597         0xb9,
1598         0xbc,   /* ISRC4DEC1 */
1599         0xbd,
1600         0xf8,   /* DFC1 */
1601         0xf9,
1602         0xfa,
1603         0xfb,
1604         0xfc,
1605         0xfd,
1606         0xfe,
1607         0xff,   /* DFC8 */
1608 };
1609 EXPORT_SYMBOL_GPL(madera_mixer_values);
1610
1611 const DECLARE_TLV_DB_SCALE(madera_ana_tlv, 0, 100, 0);
1612 EXPORT_SYMBOL_GPL(madera_ana_tlv);
1613
1614 const DECLARE_TLV_DB_SCALE(madera_eq_tlv, -1200, 100, 0);
1615 EXPORT_SYMBOL_GPL(madera_eq_tlv);
1616
1617 const DECLARE_TLV_DB_SCALE(madera_digital_tlv, -6400, 50, 0);
1618 EXPORT_SYMBOL_GPL(madera_digital_tlv);
1619
1620 const DECLARE_TLV_DB_SCALE(madera_noise_tlv, -13200, 600, 0);
1621 EXPORT_SYMBOL_GPL(madera_noise_tlv);
1622
1623 const DECLARE_TLV_DB_SCALE(madera_ng_tlv, -12000, 600, 0);
1624 EXPORT_SYMBOL_GPL(madera_ng_tlv);
1625
1626 const DECLARE_TLV_DB_SCALE(madera_mixer_tlv, -3200, 100, 0);
1627 EXPORT_SYMBOL_GPL(madera_mixer_tlv);
1628
1629 const char * const madera_rate_text[MADERA_RATE_ENUM_SIZE] = {
1630         "SYNCCLK rate 1", "SYNCCLK rate 2", "SYNCCLK rate 3",
1631         "ASYNCCLK rate 1", "ASYNCCLK rate 2",
1632 };
1633 EXPORT_SYMBOL_GPL(madera_rate_text);
1634
1635 const unsigned int madera_rate_val[MADERA_RATE_ENUM_SIZE] = {
1636         0x0, 0x1, 0x2, 0x8, 0x9,
1637 };
1638 EXPORT_SYMBOL_GPL(madera_rate_val);
1639
1640 static const char * const madera_dfc_width_text[MADERA_DFC_WIDTH_ENUM_SIZE] = {
1641         "8 bit", "16 bit", "20 bit", "24 bit", "32 bit",
1642 };
1643
1644 static const unsigned int madera_dfc_width_val[MADERA_DFC_WIDTH_ENUM_SIZE] = {
1645         7, 15, 19, 23, 31,
1646 };
1647
1648 static const char * const madera_dfc_type_text[MADERA_DFC_TYPE_ENUM_SIZE] = {
1649         "Fixed", "Unsigned Fixed", "Single Precision Floating",
1650         "Half Precision Floating", "Arm Alternative Floating",
1651 };
1652
1653 static const unsigned int madera_dfc_type_val[MADERA_DFC_TYPE_ENUM_SIZE] = {
1654         0, 1, 2, 4, 5,
1655 };
1656
1657 const struct soc_enum madera_dfc_width[] = {
1658         SOC_VALUE_ENUM_SINGLE(MADERA_DFC1_RX,
1659                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1660                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1661                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1662                               ARRAY_SIZE(madera_dfc_width_text),
1663                               madera_dfc_width_text,
1664                               madera_dfc_width_val),
1665         SOC_VALUE_ENUM_SINGLE(MADERA_DFC1_TX,
1666                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1667                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1668                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1669                               ARRAY_SIZE(madera_dfc_width_text),
1670                               madera_dfc_width_text,
1671                               madera_dfc_width_val),
1672         SOC_VALUE_ENUM_SINGLE(MADERA_DFC2_RX,
1673                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1674                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1675                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1676                               ARRAY_SIZE(madera_dfc_width_text),
1677                               madera_dfc_width_text,
1678                               madera_dfc_width_val),
1679         SOC_VALUE_ENUM_SINGLE(MADERA_DFC2_TX,
1680                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1681                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1682                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1683                               ARRAY_SIZE(madera_dfc_width_text),
1684                               madera_dfc_width_text,
1685                               madera_dfc_width_val),
1686         SOC_VALUE_ENUM_SINGLE(MADERA_DFC3_RX,
1687                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1688                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1689                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1690                               ARRAY_SIZE(madera_dfc_width_text),
1691                               madera_dfc_width_text,
1692                               madera_dfc_width_val),
1693         SOC_VALUE_ENUM_SINGLE(MADERA_DFC3_TX,
1694                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1695                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1696                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1697                               ARRAY_SIZE(madera_dfc_width_text),
1698                               madera_dfc_width_text,
1699                               madera_dfc_width_val),
1700         SOC_VALUE_ENUM_SINGLE(MADERA_DFC4_RX,
1701                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1702                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1703                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1704                               ARRAY_SIZE(madera_dfc_width_text),
1705                               madera_dfc_width_text,
1706                               madera_dfc_width_val),
1707         SOC_VALUE_ENUM_SINGLE(MADERA_DFC4_TX,
1708                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1709                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1710                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1711                               ARRAY_SIZE(madera_dfc_width_text),
1712                               madera_dfc_width_text,
1713                               madera_dfc_width_val),
1714         SOC_VALUE_ENUM_SINGLE(MADERA_DFC5_RX,
1715                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1716                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1717                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1718                               ARRAY_SIZE(madera_dfc_width_text),
1719                               madera_dfc_width_text,
1720                               madera_dfc_width_val),
1721         SOC_VALUE_ENUM_SINGLE(MADERA_DFC5_TX,
1722                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1723                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1724                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1725                               ARRAY_SIZE(madera_dfc_width_text),
1726                               madera_dfc_width_text,
1727                               madera_dfc_width_val),
1728         SOC_VALUE_ENUM_SINGLE(MADERA_DFC6_RX,
1729                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1730                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1731                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1732                               ARRAY_SIZE(madera_dfc_width_text),
1733                               madera_dfc_width_text,
1734                               madera_dfc_width_val),
1735         SOC_VALUE_ENUM_SINGLE(MADERA_DFC6_TX,
1736                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1737                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1738                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1739                               ARRAY_SIZE(madera_dfc_width_text),
1740                               madera_dfc_width_text,
1741                               madera_dfc_width_val),
1742         SOC_VALUE_ENUM_SINGLE(MADERA_DFC7_RX,
1743                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1744                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1745                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1746                               ARRAY_SIZE(madera_dfc_width_text),
1747                               madera_dfc_width_text,
1748                               madera_dfc_width_val),
1749         SOC_VALUE_ENUM_SINGLE(MADERA_DFC7_TX,
1750                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1751                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1752                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1753                               ARRAY_SIZE(madera_dfc_width_text),
1754                               madera_dfc_width_text,
1755                               madera_dfc_width_val),
1756         SOC_VALUE_ENUM_SINGLE(MADERA_DFC8_RX,
1757                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1758                               MADERA_DFC1_RX_DATA_WIDTH_MASK >>
1759                               MADERA_DFC1_RX_DATA_WIDTH_SHIFT,
1760                               ARRAY_SIZE(madera_dfc_width_text),
1761                               madera_dfc_width_text,
1762                               madera_dfc_width_val),
1763         SOC_VALUE_ENUM_SINGLE(MADERA_DFC8_TX,
1764                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1765                               MADERA_DFC1_TX_DATA_WIDTH_MASK >>
1766                               MADERA_DFC1_TX_DATA_WIDTH_SHIFT,
1767                               ARRAY_SIZE(madera_dfc_width_text),
1768                               madera_dfc_width_text,
1769                               madera_dfc_width_val),
1770 };
1771 EXPORT_SYMBOL_GPL(madera_dfc_width);
1772
1773 const struct soc_enum madera_dfc_type[] = {
1774         SOC_VALUE_ENUM_SINGLE(MADERA_DFC1_RX,
1775                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1776                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1777                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1778                               ARRAY_SIZE(madera_dfc_type_text),
1779                               madera_dfc_type_text,
1780                               madera_dfc_type_val),
1781         SOC_VALUE_ENUM_SINGLE(MADERA_DFC1_TX,
1782                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1783                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1784                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1785                               ARRAY_SIZE(madera_dfc_type_text),
1786                               madera_dfc_type_text,
1787                               madera_dfc_type_val),
1788         SOC_VALUE_ENUM_SINGLE(MADERA_DFC2_RX,
1789                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1790                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1791                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1792                               ARRAY_SIZE(madera_dfc_type_text),
1793                               madera_dfc_type_text,
1794                               madera_dfc_type_val),
1795         SOC_VALUE_ENUM_SINGLE(MADERA_DFC2_TX,
1796                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1797                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1798                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1799                               ARRAY_SIZE(madera_dfc_type_text),
1800                               madera_dfc_type_text,
1801                               madera_dfc_type_val),
1802         SOC_VALUE_ENUM_SINGLE(MADERA_DFC3_RX,
1803                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1804                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1805                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1806                               ARRAY_SIZE(madera_dfc_type_text),
1807                               madera_dfc_type_text,
1808                               madera_dfc_type_val),
1809         SOC_VALUE_ENUM_SINGLE(MADERA_DFC3_TX,
1810                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1811                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1812                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1813                               ARRAY_SIZE(madera_dfc_type_text),
1814                               madera_dfc_type_text,
1815                               madera_dfc_type_val),
1816         SOC_VALUE_ENUM_SINGLE(MADERA_DFC4_RX,
1817                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1818                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1819                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1820                               ARRAY_SIZE(madera_dfc_type_text),
1821                               madera_dfc_type_text,
1822                               madera_dfc_type_val),
1823         SOC_VALUE_ENUM_SINGLE(MADERA_DFC4_TX,
1824                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1825                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1826                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1827                               ARRAY_SIZE(madera_dfc_type_text),
1828                               madera_dfc_type_text,
1829                               madera_dfc_type_val),
1830         SOC_VALUE_ENUM_SINGLE(MADERA_DFC5_RX,
1831                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1832                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1833                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1834                               ARRAY_SIZE(madera_dfc_type_text),
1835                               madera_dfc_type_text,
1836                               madera_dfc_type_val),
1837         SOC_VALUE_ENUM_SINGLE(MADERA_DFC5_TX,
1838                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1839                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1840                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1841                               ARRAY_SIZE(madera_dfc_type_text),
1842                               madera_dfc_type_text,
1843                               madera_dfc_type_val),
1844         SOC_VALUE_ENUM_SINGLE(MADERA_DFC6_RX,
1845                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1846                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1847                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1848                               ARRAY_SIZE(madera_dfc_type_text),
1849                               madera_dfc_type_text,
1850                               madera_dfc_type_val),
1851         SOC_VALUE_ENUM_SINGLE(MADERA_DFC6_TX,
1852                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1853                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1854                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1855                               ARRAY_SIZE(madera_dfc_type_text),
1856                               madera_dfc_type_text,
1857                               madera_dfc_type_val),
1858         SOC_VALUE_ENUM_SINGLE(MADERA_DFC7_RX,
1859                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1860                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1861                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1862                               ARRAY_SIZE(madera_dfc_type_text),
1863                               madera_dfc_type_text,
1864                               madera_dfc_type_val),
1865         SOC_VALUE_ENUM_SINGLE(MADERA_DFC7_TX,
1866                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1867                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1868                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1869                               ARRAY_SIZE(madera_dfc_type_text),
1870                               madera_dfc_type_text,
1871                               madera_dfc_type_val),
1872         SOC_VALUE_ENUM_SINGLE(MADERA_DFC8_RX,
1873                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1874                               MADERA_DFC1_RX_DATA_TYPE_MASK >>
1875                               MADERA_DFC1_RX_DATA_TYPE_SHIFT,
1876                               ARRAY_SIZE(madera_dfc_type_text),
1877                               madera_dfc_type_text,
1878                               madera_dfc_type_val),
1879         SOC_VALUE_ENUM_SINGLE(MADERA_DFC8_TX,
1880                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1881                               MADERA_DFC1_TX_DATA_TYPE_MASK >>
1882                               MADERA_DFC1_TX_DATA_TYPE_SHIFT,
1883                               ARRAY_SIZE(madera_dfc_type_text),
1884                               madera_dfc_type_text,
1885                               madera_dfc_type_val),
1886 };
1887 EXPORT_SYMBOL_GPL(madera_dfc_type);
1888
1889 const struct soc_enum madera_isrc_fsh[] = {
1890         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_1_CTRL_1,
1891                               MADERA_ISRC1_FSH_SHIFT, 0xf,
1892                               MADERA_RATE_ENUM_SIZE,
1893                               madera_rate_text, madera_rate_val),
1894         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_2_CTRL_1,
1895                               MADERA_ISRC2_FSH_SHIFT, 0xf,
1896                               MADERA_RATE_ENUM_SIZE,
1897                               madera_rate_text, madera_rate_val),
1898         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_3_CTRL_1,
1899                               MADERA_ISRC3_FSH_SHIFT, 0xf,
1900                               MADERA_RATE_ENUM_SIZE,
1901                               madera_rate_text, madera_rate_val),
1902         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_4_CTRL_1,
1903                               MADERA_ISRC4_FSH_SHIFT, 0xf,
1904                               MADERA_RATE_ENUM_SIZE,
1905                               madera_rate_text, madera_rate_val),
1906
1907 };
1908 EXPORT_SYMBOL_GPL(madera_isrc_fsh);
1909
1910 const struct soc_enum madera_isrc_fsl[] = {
1911         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_1_CTRL_2,
1912                               MADERA_ISRC1_FSL_SHIFT, 0xf,
1913                               MADERA_RATE_ENUM_SIZE,
1914                               madera_rate_text, madera_rate_val),
1915         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_2_CTRL_2,
1916                               MADERA_ISRC2_FSL_SHIFT, 0xf,
1917                               MADERA_RATE_ENUM_SIZE,
1918                               madera_rate_text, madera_rate_val),
1919         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_3_CTRL_2,
1920                               MADERA_ISRC3_FSL_SHIFT, 0xf,
1921                               MADERA_RATE_ENUM_SIZE,
1922                               madera_rate_text, madera_rate_val),
1923         SOC_VALUE_ENUM_SINGLE(MADERA_ISRC_4_CTRL_2,
1924                               MADERA_ISRC4_FSL_SHIFT, 0xf,
1925                               MADERA_RATE_ENUM_SIZE,
1926                               madera_rate_text, madera_rate_val),
1927
1928 };
1929 EXPORT_SYMBOL_GPL(madera_isrc_fsl);
1930
1931 const struct soc_enum madera_asrc1_rate[] = {
1932         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC1_RATE1,
1933                               MADERA_ASRC1_RATE1_SHIFT, 0xf,
1934                               MADERA_SYNC_RATE_ENUM_SIZE,
1935                               madera_rate_text, madera_rate_val),
1936         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC1_RATE2,
1937                               MADERA_ASRC1_RATE1_SHIFT, 0xf,
1938                               MADERA_ASYNC_RATE_ENUM_SIZE,
1939                               madera_rate_text + MADERA_SYNC_RATE_ENUM_SIZE,
1940                               madera_rate_val + MADERA_SYNC_RATE_ENUM_SIZE),
1941
1942 };
1943 EXPORT_SYMBOL_GPL(madera_asrc1_rate);
1944
1945 const struct soc_enum madera_asrc1_bidir_rate[] = {
1946         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC1_RATE1,
1947                               MADERA_ASRC1_RATE1_SHIFT, 0xf,
1948                               MADERA_RATE_ENUM_SIZE,
1949                               madera_rate_text, madera_rate_val),
1950         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC1_RATE2,
1951                               MADERA_ASRC1_RATE2_SHIFT, 0xf,
1952                               MADERA_RATE_ENUM_SIZE,
1953                               madera_rate_text, madera_rate_val),
1954 };
1955 EXPORT_SYMBOL_GPL(madera_asrc1_bidir_rate);
1956
1957 const struct soc_enum madera_asrc2_rate[] = {
1958         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC2_RATE1,
1959                               MADERA_ASRC2_RATE1_SHIFT, 0xf,
1960                               MADERA_SYNC_RATE_ENUM_SIZE,
1961                               madera_rate_text, madera_rate_val),
1962         SOC_VALUE_ENUM_SINGLE(MADERA_ASRC2_RATE2,
1963                               MADERA_ASRC2_RATE2_SHIFT, 0xf,
1964                               MADERA_ASYNC_RATE_ENUM_SIZE,
1965                               madera_rate_text + MADERA_SYNC_RATE_ENUM_SIZE,
1966                               madera_rate_val + MADERA_SYNC_RATE_ENUM_SIZE),
1967
1968 };
1969 EXPORT_SYMBOL_GPL(madera_asrc2_rate);
1970
1971 static const char * const madera_vol_ramp_text[] = {
1972         "0ms/6dB", "0.5ms/6dB", "1ms/6dB", "2ms/6dB", "4ms/6dB", "8ms/6dB",
1973         "15ms/6dB", "30ms/6dB",
1974 };
1975
1976 SOC_ENUM_SINGLE_DECL(madera_in_vd_ramp,
1977                      MADERA_INPUT_VOLUME_RAMP,
1978                      MADERA_IN_VD_RAMP_SHIFT,
1979                      madera_vol_ramp_text);
1980 EXPORT_SYMBOL_GPL(madera_in_vd_ramp);
1981
1982 SOC_ENUM_SINGLE_DECL(madera_in_vi_ramp,
1983                      MADERA_INPUT_VOLUME_RAMP,
1984                      MADERA_IN_VI_RAMP_SHIFT,
1985                      madera_vol_ramp_text);
1986 EXPORT_SYMBOL_GPL(madera_in_vi_ramp);
1987
1988 SOC_ENUM_SINGLE_DECL(madera_out_vd_ramp,
1989                      MADERA_OUTPUT_VOLUME_RAMP,
1990                      MADERA_OUT_VD_RAMP_SHIFT,
1991                      madera_vol_ramp_text);
1992 EXPORT_SYMBOL_GPL(madera_out_vd_ramp);
1993
1994 SOC_ENUM_SINGLE_DECL(madera_out_vi_ramp,
1995                      MADERA_OUTPUT_VOLUME_RAMP,
1996                      MADERA_OUT_VI_RAMP_SHIFT,
1997                      madera_vol_ramp_text);
1998 EXPORT_SYMBOL_GPL(madera_out_vi_ramp);
1999
2000 static const char * const madera_lhpf_mode_text[] = {
2001         "Low-pass", "High-pass"
2002 };
2003
2004 SOC_ENUM_SINGLE_DECL(madera_lhpf1_mode,
2005                      MADERA_HPLPF1_1,
2006                      MADERA_LHPF1_MODE_SHIFT,
2007                      madera_lhpf_mode_text);
2008 EXPORT_SYMBOL_GPL(madera_lhpf1_mode);
2009
2010 SOC_ENUM_SINGLE_DECL(madera_lhpf2_mode,
2011                      MADERA_HPLPF2_1,
2012                      MADERA_LHPF2_MODE_SHIFT,
2013                      madera_lhpf_mode_text);
2014 EXPORT_SYMBOL_GPL(madera_lhpf2_mode);
2015
2016 SOC_ENUM_SINGLE_DECL(madera_lhpf3_mode,
2017                      MADERA_HPLPF3_1,
2018                      MADERA_LHPF3_MODE_SHIFT,
2019                      madera_lhpf_mode_text);
2020 EXPORT_SYMBOL_GPL(madera_lhpf3_mode);
2021
2022 SOC_ENUM_SINGLE_DECL(madera_lhpf4_mode,
2023                      MADERA_HPLPF4_1,
2024                      MADERA_LHPF4_MODE_SHIFT,
2025                      madera_lhpf_mode_text);
2026 EXPORT_SYMBOL_GPL(madera_lhpf4_mode);
2027
2028 static const char * const madera_ng_hold_text[] = {
2029         "30ms", "120ms", "250ms", "500ms",
2030 };
2031
2032 SOC_ENUM_SINGLE_DECL(madera_ng_hold,
2033                      MADERA_NOISE_GATE_CONTROL,
2034                      MADERA_NGATE_HOLD_SHIFT,
2035                      madera_ng_hold_text);
2036 EXPORT_SYMBOL_GPL(madera_ng_hold);
2037
2038 static const char * const madera_in_hpf_cut_text[] = {
2039         "2.5Hz", "5Hz", "10Hz", "20Hz", "40Hz"
2040 };
2041
2042 SOC_ENUM_SINGLE_DECL(madera_in_hpf_cut_enum,
2043                      MADERA_HPF_CONTROL,
2044                      MADERA_IN_HPF_CUT_SHIFT,
2045                      madera_in_hpf_cut_text);
2046 EXPORT_SYMBOL_GPL(madera_in_hpf_cut_enum);
2047
2048 static const char * const madera_in_dmic_osr_text[MADERA_OSR_ENUM_SIZE] = {
2049         "384kHz", "768kHz", "1.536MHz", "3.072MHz", "6.144MHz",
2050 };
2051
2052 static const unsigned int madera_in_dmic_osr_val[MADERA_OSR_ENUM_SIZE] = {
2053         2, 3, 4, 5, 6,
2054 };
2055
2056 const struct soc_enum madera_in_dmic_osr[] = {
2057         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC1L_CONTROL, MADERA_IN1_OSR_SHIFT,
2058                               0x7, MADERA_OSR_ENUM_SIZE,
2059                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2060         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC2L_CONTROL, MADERA_IN2_OSR_SHIFT,
2061                               0x7, MADERA_OSR_ENUM_SIZE,
2062                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2063         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC3L_CONTROL, MADERA_IN3_OSR_SHIFT,
2064                               0x7, MADERA_OSR_ENUM_SIZE,
2065                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2066         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC4L_CONTROL, MADERA_IN4_OSR_SHIFT,
2067                               0x7, MADERA_OSR_ENUM_SIZE,
2068                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2069         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC5L_CONTROL, MADERA_IN5_OSR_SHIFT,
2070                               0x7, MADERA_OSR_ENUM_SIZE,
2071                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2072         SOC_VALUE_ENUM_SINGLE(MADERA_DMIC6L_CONTROL, MADERA_IN6_OSR_SHIFT,
2073                               0x7, MADERA_OSR_ENUM_SIZE,
2074                               madera_in_dmic_osr_text, madera_in_dmic_osr_val),
2075 };
2076 EXPORT_SYMBOL_GPL(madera_in_dmic_osr);
2077
2078 static const char * const madera_anc_input_src_text[] = {
2079         "None", "IN1", "IN2", "IN3", "IN4", "IN5", "IN6",
2080 };
2081
2082 static const char * const madera_anc_channel_src_text[] = {
2083         "None", "Left", "Right", "Combine",
2084 };
2085
2086 const struct soc_enum madera_anc_input_src[] = {
2087         SOC_ENUM_SINGLE(MADERA_ANC_SRC,
2088                         MADERA_IN_RXANCL_SEL_SHIFT,
2089                         ARRAY_SIZE(madera_anc_input_src_text),
2090                         madera_anc_input_src_text),
2091         SOC_ENUM_SINGLE(MADERA_FCL_ADC_REFORMATTER_CONTROL,
2092                         MADERA_FCL_MIC_MODE_SEL_SHIFT,
2093                         ARRAY_SIZE(madera_anc_channel_src_text),
2094                         madera_anc_channel_src_text),
2095         SOC_ENUM_SINGLE(MADERA_ANC_SRC,
2096                         MADERA_IN_RXANCR_SEL_SHIFT,
2097                         ARRAY_SIZE(madera_anc_input_src_text),
2098                         madera_anc_input_src_text),
2099         SOC_ENUM_SINGLE(MADERA_FCR_ADC_REFORMATTER_CONTROL,
2100                         MADERA_FCR_MIC_MODE_SEL_SHIFT,
2101                         ARRAY_SIZE(madera_anc_channel_src_text),
2102                         madera_anc_channel_src_text),
2103 };
2104 EXPORT_SYMBOL_GPL(madera_anc_input_src);
2105
2106 static const char * const madera_anc_ng_texts[] = {
2107         "None", "Internal", "External",
2108 };
2109
2110 SOC_ENUM_SINGLE_DECL(madera_anc_ng_enum, SND_SOC_NOPM, 0, madera_anc_ng_texts);
2111 EXPORT_SYMBOL_GPL(madera_anc_ng_enum);
2112
2113 static const char * const madera_out_anc_src_text[] = {
2114         "None", "RXANCL", "RXANCR",
2115 };
2116
2117 const struct soc_enum madera_output_anc_src[] = {
2118         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_1L,
2119                         MADERA_OUT1L_ANC_SRC_SHIFT,
2120                         ARRAY_SIZE(madera_out_anc_src_text),
2121                         madera_out_anc_src_text),
2122         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_1R,
2123                         MADERA_OUT1R_ANC_SRC_SHIFT,
2124                         ARRAY_SIZE(madera_out_anc_src_text),
2125                         madera_out_anc_src_text),
2126         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_2L,
2127                         MADERA_OUT2L_ANC_SRC_SHIFT,
2128                         ARRAY_SIZE(madera_out_anc_src_text),
2129                         madera_out_anc_src_text),
2130         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_2R,
2131                         MADERA_OUT2R_ANC_SRC_SHIFT,
2132                         ARRAY_SIZE(madera_out_anc_src_text),
2133                         madera_out_anc_src_text),
2134         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_3L,
2135                         MADERA_OUT3L_ANC_SRC_SHIFT,
2136                         ARRAY_SIZE(madera_out_anc_src_text),
2137                         madera_out_anc_src_text),
2138         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_3R,
2139                         MADERA_OUT3R_ANC_SRC_SHIFT,
2140                         ARRAY_SIZE(madera_out_anc_src_text),
2141                         madera_out_anc_src_text),
2142         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_4L,
2143                         MADERA_OUT4L_ANC_SRC_SHIFT,
2144                         ARRAY_SIZE(madera_out_anc_src_text),
2145                         madera_out_anc_src_text),
2146         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_4R,
2147                         MADERA_OUT4R_ANC_SRC_SHIFT,
2148                         ARRAY_SIZE(madera_out_anc_src_text),
2149                         madera_out_anc_src_text),
2150         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_5L,
2151                         MADERA_OUT5L_ANC_SRC_SHIFT,
2152                         ARRAY_SIZE(madera_out_anc_src_text),
2153                         madera_out_anc_src_text),
2154         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_5R,
2155                         MADERA_OUT5R_ANC_SRC_SHIFT,
2156                         ARRAY_SIZE(madera_out_anc_src_text),
2157                         madera_out_anc_src_text),
2158         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_6L,
2159                         MADERA_OUT6L_ANC_SRC_SHIFT,
2160                         ARRAY_SIZE(madera_out_anc_src_text),
2161                         madera_out_anc_src_text),
2162         SOC_ENUM_SINGLE(MADERA_OUTPUT_PATH_CONFIG_6R,
2163                         MADERA_OUT6R_ANC_SRC_SHIFT,
2164                         ARRAY_SIZE(madera_out_anc_src_text),
2165                         madera_out_anc_src_text),
2166 };
2167 EXPORT_SYMBOL_GPL(madera_output_anc_src);
2168
2169 int madera_dfc_put(struct snd_kcontrol *kcontrol,
2170                    struct snd_ctl_elem_value *ucontrol)
2171 {
2172         struct snd_soc_component *component =
2173                 snd_soc_kcontrol_component(kcontrol);
2174         struct snd_soc_dapm_context *dapm =
2175                 snd_soc_component_get_dapm(component);
2176         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2177         unsigned int reg = e->reg;
2178         unsigned int val;
2179         int ret = 0;
2180
2181         reg = ((reg / 6) * 6) - 2;
2182
2183         snd_soc_dapm_mutex_lock(dapm);
2184
2185         ret = snd_soc_component_read(component, reg, &val);
2186         if (ret)
2187                 goto exit;
2188
2189         if (val & MADERA_DFC1_ENA) {
2190                 ret = -EBUSY;
2191                 dev_err(component->dev, "Can't change mode on an active DFC\n");
2192                 goto exit;
2193         }
2194
2195         ret = snd_soc_put_enum_double(kcontrol, ucontrol);
2196 exit:
2197         snd_soc_dapm_mutex_unlock(dapm);
2198
2199         return ret;
2200 }
2201 EXPORT_SYMBOL_GPL(madera_dfc_put);
2202
2203 int madera_lp_mode_put(struct snd_kcontrol *kcontrol,
2204                        struct snd_ctl_elem_value *ucontrol)
2205 {
2206         struct soc_mixer_control *mc =
2207                 (struct soc_mixer_control *)kcontrol->private_value;
2208         struct snd_soc_component *component =
2209                 snd_soc_kcontrol_component(kcontrol);
2210         struct snd_soc_dapm_context *dapm =
2211                 snd_soc_component_get_dapm(component);
2212         unsigned int val, mask;
2213         int ret;
2214
2215         snd_soc_dapm_mutex_lock(dapm);
2216
2217         /* Cannot change lp mode on an active input */
2218         ret = snd_soc_component_read(component, MADERA_INPUT_ENABLES, &val);
2219         if (ret)
2220                 goto exit;
2221         mask = (mc->reg - MADERA_ADC_DIGITAL_VOLUME_1L) / 4;
2222         mask ^= 0x1; /* Flip bottom bit for channel order */
2223
2224         if (val & (1 << mask)) {
2225                 ret = -EBUSY;
2226                 dev_err(component->dev,
2227                         "Can't change lp mode on an active input\n");
2228                 goto exit;
2229         }
2230
2231         ret = snd_soc_put_volsw(kcontrol, ucontrol);
2232
2233 exit:
2234         snd_soc_dapm_mutex_unlock(dapm);
2235
2236         return ret;
2237 }
2238 EXPORT_SYMBOL_GPL(madera_lp_mode_put);
2239
2240 const struct snd_kcontrol_new madera_dsp_trigger_output_mux[] = {
2241         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2242         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2243         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2244         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2245         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2246         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2247         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2248 };
2249 EXPORT_SYMBOL_GPL(madera_dsp_trigger_output_mux);
2250
2251 const struct snd_kcontrol_new madera_drc_activity_output_mux[] = {
2252         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2253         SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0),
2254 };
2255 EXPORT_SYMBOL_GPL(madera_drc_activity_output_mux);
2256
2257 static void madera_in_set_vu(struct madera_priv *priv, bool enable)
2258 {
2259         unsigned int val;
2260         int i, ret;
2261
2262         if (enable)
2263                 val = MADERA_IN_VU;
2264         else
2265                 val = 0;
2266
2267         for (i = 0; i < priv->num_inputs; i++) {
2268                 ret = regmap_update_bits(priv->madera->regmap,
2269                                          MADERA_ADC_DIGITAL_VOLUME_1L + (i * 4),
2270                                          MADERA_IN_VU, val);
2271                 if (ret)
2272                         dev_warn(priv->madera->dev,
2273                                  "Failed to modify VU bits: %d\n", ret);
2274         }
2275 }
2276
2277 int madera_in_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
2278                  int event)
2279 {
2280         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
2281         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2282         unsigned int reg, val;
2283         int ret;
2284
2285         if (w->shift % 2)
2286                 reg = MADERA_ADC_DIGITAL_VOLUME_1L + ((w->shift / 2) * 8);
2287         else
2288                 reg = MADERA_ADC_DIGITAL_VOLUME_1R + ((w->shift / 2) * 8);
2289
2290         switch (event) {
2291         case SND_SOC_DAPM_PRE_PMU:
2292                 priv->in_pending++;
2293                 break;
2294         case SND_SOC_DAPM_POST_PMU:
2295                 priv->in_pending--;
2296                 snd_soc_component_update_bits(component, reg,
2297                                               MADERA_IN1L_MUTE, 0);
2298
2299                 /* If this is the last input pending then allow VU */
2300                 if (priv->in_pending == 0) {
2301                         usleep_range(1000, 3000);
2302                         madera_in_set_vu(priv, true);
2303                 }
2304                 break;
2305         case SND_SOC_DAPM_PRE_PMD:
2306                 snd_soc_component_update_bits(component, reg,
2307                                               MADERA_IN1L_MUTE | MADERA_IN_VU,
2308                                               MADERA_IN1L_MUTE | MADERA_IN_VU);
2309                 break;
2310         case SND_SOC_DAPM_POST_PMD:
2311                 /* Disable volume updates if no inputs are enabled */
2312                 ret = snd_soc_component_read(component, MADERA_INPUT_ENABLES,
2313                                              &val);
2314                 if (!ret && !val)
2315                         madera_in_set_vu(priv, false);
2316                 break;
2317         default:
2318                 break;
2319         }
2320
2321         return 0;
2322 }
2323 EXPORT_SYMBOL_GPL(madera_in_ev);
2324
2325 int madera_out_ev(struct snd_soc_dapm_widget *w,
2326                   struct snd_kcontrol *kcontrol, int event)
2327 {
2328         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
2329         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2330         struct madera *madera = priv->madera;
2331         int out_up_delay;
2332
2333         switch (madera->type) {
2334         case CS47L90:
2335         case CS47L91:
2336         case CS42L92:
2337         case CS47L92:
2338         case CS47L93:
2339                 out_up_delay = 6;
2340                 break;
2341         default:
2342                 out_up_delay = 17;
2343                 break;
2344         }
2345
2346         switch (event) {
2347         case SND_SOC_DAPM_PRE_PMU:
2348                 switch (w->shift) {
2349                 case MADERA_OUT1L_ENA_SHIFT:
2350                 case MADERA_OUT1R_ENA_SHIFT:
2351                 case MADERA_OUT2L_ENA_SHIFT:
2352                 case MADERA_OUT2R_ENA_SHIFT:
2353                 case MADERA_OUT3L_ENA_SHIFT:
2354                 case MADERA_OUT3R_ENA_SHIFT:
2355                         priv->out_up_pending++;
2356                         priv->out_up_delay += out_up_delay;
2357                         break;
2358                 default:
2359                         break;
2360                 }
2361                 break;
2362
2363         case SND_SOC_DAPM_POST_PMU:
2364                 switch (w->shift) {
2365                 case MADERA_OUT1L_ENA_SHIFT:
2366                 case MADERA_OUT1R_ENA_SHIFT:
2367                 case MADERA_OUT2L_ENA_SHIFT:
2368                 case MADERA_OUT2R_ENA_SHIFT:
2369                 case MADERA_OUT3L_ENA_SHIFT:
2370                 case MADERA_OUT3R_ENA_SHIFT:
2371                         priv->out_up_pending--;
2372                         if (!priv->out_up_pending) {
2373                                 msleep(priv->out_up_delay);
2374                                 priv->out_up_delay = 0;
2375                         }
2376                         break;
2377
2378                 default:
2379                         break;
2380                 }
2381                 break;
2382
2383         case SND_SOC_DAPM_PRE_PMD:
2384                 switch (w->shift) {
2385                 case MADERA_OUT1L_ENA_SHIFT:
2386                 case MADERA_OUT1R_ENA_SHIFT:
2387                 case MADERA_OUT2L_ENA_SHIFT:
2388                 case MADERA_OUT2R_ENA_SHIFT:
2389                 case MADERA_OUT3L_ENA_SHIFT:
2390                 case MADERA_OUT3R_ENA_SHIFT:
2391                         priv->out_down_pending++;
2392                         priv->out_down_delay++;
2393                         break;
2394                 default:
2395                         break;
2396                 }
2397                 break;
2398
2399         case SND_SOC_DAPM_POST_PMD:
2400                 switch (w->shift) {
2401                 case MADERA_OUT1L_ENA_SHIFT:
2402                 case MADERA_OUT1R_ENA_SHIFT:
2403                 case MADERA_OUT2L_ENA_SHIFT:
2404                 case MADERA_OUT2R_ENA_SHIFT:
2405                 case MADERA_OUT3L_ENA_SHIFT:
2406                 case MADERA_OUT3R_ENA_SHIFT:
2407                         priv->out_down_pending--;
2408                         if (!priv->out_down_pending) {
2409                                 msleep(priv->out_down_delay);
2410                                 priv->out_down_delay = 0;
2411                         }
2412                         break;
2413                 default:
2414                         break;
2415                 }
2416                 break;
2417         default:
2418                 break;
2419         }
2420
2421         return 0;
2422 }
2423 EXPORT_SYMBOL_GPL(madera_out_ev);
2424
2425 int madera_hp_ev(struct snd_soc_dapm_widget *w,
2426                  struct snd_kcontrol *kcontrol, int event)
2427 {
2428         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
2429         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2430         struct madera *madera = priv->madera;
2431         unsigned int mask = 1 << w->shift;
2432         unsigned int out_num = w->shift / 2;
2433         unsigned int val;
2434         unsigned int ep_sel = 0;
2435
2436         switch (event) {
2437         case SND_SOC_DAPM_POST_PMU:
2438                 val = mask;
2439                 break;
2440         case SND_SOC_DAPM_PRE_PMD:
2441                 val = 0;
2442                 break;
2443         case SND_SOC_DAPM_PRE_PMU:
2444         case SND_SOC_DAPM_POST_PMD:
2445                 return madera_out_ev(w, kcontrol, event);
2446         default:
2447                 return 0;
2448         }
2449
2450         /* Store the desired state for the HP outputs */
2451         madera->hp_ena &= ~mask;
2452         madera->hp_ena |= val;
2453
2454         switch (madera->type) {
2455         case CS42L92:
2456         case CS47L92:
2457         case CS47L93:
2458                 break;
2459         default:
2460                 /* if OUT1 is routed to EPOUT, ignore HP clamp and impedance */
2461                 regmap_read(madera->regmap, MADERA_OUTPUT_ENABLES_1, &ep_sel);
2462                 ep_sel &= MADERA_EP_SEL_MASK;
2463                 break;
2464         }
2465
2466         /* Force off if HPDET has disabled the clamp for this output */
2467         if (!ep_sel &&
2468             (!madera->out_clamp[out_num] || madera->out_shorted[out_num]))
2469                 val = 0;
2470
2471         regmap_update_bits(madera->regmap, MADERA_OUTPUT_ENABLES_1, mask, val);
2472
2473         return madera_out_ev(w, kcontrol, event);
2474 }
2475 EXPORT_SYMBOL_GPL(madera_hp_ev);
2476
2477 int madera_anc_ev(struct snd_soc_dapm_widget *w, struct snd_kcontrol *kcontrol,
2478                   int event)
2479 {
2480         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
2481         unsigned int val;
2482
2483         switch (event) {
2484         case SND_SOC_DAPM_POST_PMU:
2485                 val = 1 << w->shift;
2486                 break;
2487         case SND_SOC_DAPM_PRE_PMD:
2488                 val = 1 << (w->shift + 1);
2489                 break;
2490         default:
2491                 return 0;
2492         }
2493
2494         snd_soc_component_write(component, MADERA_CLOCK_CONTROL, val);
2495
2496         return 0;
2497 }
2498 EXPORT_SYMBOL_GPL(madera_anc_ev);
2499
2500 static const unsigned int madera_opclk_ref_48k_rates[] = {
2501         6144000,
2502         12288000,
2503         24576000,
2504         49152000,
2505 };
2506
2507 static const unsigned int madera_opclk_ref_44k1_rates[] = {
2508         5644800,
2509         11289600,
2510         22579200,
2511         45158400,
2512 };
2513
2514 static int madera_set_opclk(struct snd_soc_component *component,
2515                             unsigned int clk, unsigned int freq)
2516 {
2517         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2518         unsigned int mask = MADERA_OPCLK_DIV_MASK | MADERA_OPCLK_SEL_MASK;
2519         unsigned int reg, val;
2520         const unsigned int *rates;
2521         int ref, div, refclk;
2522
2523         BUILD_BUG_ON(ARRAY_SIZE(madera_opclk_ref_48k_rates) !=
2524                      ARRAY_SIZE(madera_opclk_ref_44k1_rates));
2525
2526         switch (clk) {
2527         case MADERA_CLK_OPCLK:
2528                 reg = MADERA_OUTPUT_SYSTEM_CLOCK;
2529                 refclk = priv->sysclk;
2530                 break;
2531         case MADERA_CLK_ASYNC_OPCLK:
2532                 reg = MADERA_OUTPUT_ASYNC_CLOCK;
2533                 refclk = priv->asyncclk;
2534                 break;
2535         default:
2536                 return -EINVAL;
2537         }
2538
2539         if (refclk % 4000)
2540                 rates = madera_opclk_ref_44k1_rates;
2541         else
2542                 rates = madera_opclk_ref_48k_rates;
2543
2544         for (ref = 0; ref < ARRAY_SIZE(madera_opclk_ref_48k_rates); ++ref) {
2545                 if (rates[ref] > refclk)
2546                         continue;
2547
2548                 div = 2;
2549                 while ((rates[ref] / div >= freq) && (div <= 30)) {
2550                         if (rates[ref] / div == freq) {
2551                                 dev_dbg(component->dev, "Configured %dHz OPCLK\n",
2552                                         freq);
2553
2554                                 val = (div << MADERA_OPCLK_DIV_SHIFT) | ref;
2555
2556                                 snd_soc_component_update_bits(component, reg,
2557                                                               mask, val);
2558                                 return 0;
2559                         }
2560                         div += 2;
2561                 }
2562         }
2563
2564         dev_err(component->dev, "Unable to generate %dHz OPCLK\n", freq);
2565
2566         return -EINVAL;
2567 }
2568
2569 static int madera_get_sysclk_setting(unsigned int freq)
2570 {
2571         switch (freq) {
2572         case 0:
2573         case 5644800:
2574         case 6144000:
2575                 return 0;
2576         case 11289600:
2577         case 12288000:
2578                 return MADERA_SYSCLK_12MHZ << MADERA_SYSCLK_FREQ_SHIFT;
2579         case 22579200:
2580         case 24576000:
2581                 return MADERA_SYSCLK_24MHZ << MADERA_SYSCLK_FREQ_SHIFT;
2582         case 45158400:
2583         case 49152000:
2584                 return MADERA_SYSCLK_49MHZ << MADERA_SYSCLK_FREQ_SHIFT;
2585         case 90316800:
2586         case 98304000:
2587                 return MADERA_SYSCLK_98MHZ << MADERA_SYSCLK_FREQ_SHIFT;
2588         default:
2589                 return -EINVAL;
2590         }
2591 }
2592
2593 static int madera_get_legacy_dspclk_setting(struct madera *madera,
2594                                             unsigned int freq)
2595 {
2596         switch (freq) {
2597         case 0:
2598                 return 0;
2599         case 45158400:
2600         case 49152000:
2601                 switch (madera->type) {
2602                 case CS47L85:
2603                 case WM1840:
2604                         if (madera->rev < 3)
2605                                 return -EINVAL;
2606                         else
2607                                 return MADERA_SYSCLK_49MHZ <<
2608                                        MADERA_SYSCLK_FREQ_SHIFT;
2609                 default:
2610                         return -EINVAL;
2611                 }
2612         case 135475200:
2613         case 147456000:
2614                 return MADERA_DSPCLK_147MHZ << MADERA_DSP_CLK_FREQ_LEGACY_SHIFT;
2615         default:
2616                 return -EINVAL;
2617         }
2618 }
2619
2620 static int madera_get_dspclk_setting(struct madera *madera,
2621                                      unsigned int freq,
2622                                      unsigned int *clock_2_val)
2623 {
2624         switch (madera->type) {
2625         case CS47L35:
2626         case CS47L85:
2627         case WM1840:
2628                 *clock_2_val = 0; /* don't use MADERA_DSP_CLOCK_2 */
2629                 return madera_get_legacy_dspclk_setting(madera, freq);
2630         default:
2631                 if (freq > 150000000)
2632                         return -EINVAL;
2633
2634                 /* Use new exact frequency control */
2635                 *clock_2_val = freq / 15625; /* freq * (2^6) / (10^6) */
2636                 return 0;
2637         }
2638 }
2639
2640 static int madera_set_outclk(struct snd_soc_component *component,
2641                              unsigned int source, unsigned int freq)
2642 {
2643         int div, div_inc, rate;
2644
2645         switch (source) {
2646         case MADERA_OUTCLK_SYSCLK:
2647                 dev_dbg(component->dev, "Configured OUTCLK to SYSCLK\n");
2648                 snd_soc_component_update_bits(component, MADERA_OUTPUT_RATE_1,
2649                                               MADERA_OUT_CLK_SRC_MASK, source);
2650                 return 0;
2651         case MADERA_OUTCLK_ASYNCCLK:
2652                 dev_dbg(component->dev, "Configured OUTCLK to ASYNCCLK\n");
2653                 snd_soc_component_update_bits(component, MADERA_OUTPUT_RATE_1,
2654                                               MADERA_OUT_CLK_SRC_MASK, source);
2655                 return 0;
2656         case MADERA_OUTCLK_MCLK1:
2657         case MADERA_OUTCLK_MCLK2:
2658         case MADERA_OUTCLK_MCLK3:
2659                 break;
2660         default:
2661                 return -EINVAL;
2662         }
2663
2664         if (freq % 4000)
2665                 rate = 5644800;
2666         else
2667                 rate = 6144000;
2668
2669         div = 1;
2670         div_inc = 0;
2671         while (div <= 8) {
2672                 if (freq / div == rate && !(freq % div)) {
2673                         dev_dbg(component->dev, "Configured %dHz OUTCLK\n", rate);
2674                         snd_soc_component_update_bits(component,
2675                                 MADERA_OUTPUT_RATE_1,
2676                                 MADERA_OUT_EXT_CLK_DIV_MASK |
2677                                 MADERA_OUT_CLK_SRC_MASK,
2678                                 (div_inc << MADERA_OUT_EXT_CLK_DIV_SHIFT) |
2679                                 source);
2680                         return 0;
2681                 }
2682                 div_inc++;
2683                 div *= 2;
2684         }
2685
2686         dev_err(component->dev,
2687                 "Unable to generate %dHz OUTCLK from %dHz MCLK\n",
2688                 rate, freq);
2689         return -EINVAL;
2690 }
2691
2692 int madera_set_sysclk(struct snd_soc_component *component, int clk_id,
2693                       int source, unsigned int freq, int dir)
2694 {
2695         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2696         struct madera *madera = priv->madera;
2697         char *name;
2698         unsigned int reg, clock_2_val = 0;
2699         unsigned int mask = MADERA_SYSCLK_FREQ_MASK | MADERA_SYSCLK_SRC_MASK;
2700         unsigned int val = source << MADERA_SYSCLK_SRC_SHIFT;
2701         int clk_freq_sel, *clk;
2702         int ret = 0;
2703
2704         switch (clk_id) {
2705         case MADERA_CLK_SYSCLK_1:
2706                 name = "SYSCLK";
2707                 reg = MADERA_SYSTEM_CLOCK_1;
2708                 clk = &priv->sysclk;
2709                 clk_freq_sel = madera_get_sysclk_setting(freq);
2710                 mask |= MADERA_SYSCLK_FRAC;
2711                 break;
2712         case MADERA_CLK_ASYNCCLK_1:
2713                 name = "ASYNCCLK";
2714                 reg = MADERA_ASYNC_CLOCK_1;
2715                 clk = &priv->asyncclk;
2716                 clk_freq_sel = madera_get_sysclk_setting(freq);
2717                 break;
2718         case MADERA_CLK_DSPCLK:
2719                 name = "DSPCLK";
2720                 reg = MADERA_DSP_CLOCK_1;
2721                 clk = &priv->dspclk;
2722                 clk_freq_sel = madera_get_dspclk_setting(madera, freq,
2723                                                          &clock_2_val);
2724                 break;
2725         case MADERA_CLK_OPCLK:
2726         case MADERA_CLK_ASYNC_OPCLK:
2727                 return madera_set_opclk(component, clk_id, freq);
2728         case MADERA_CLK_OUTCLK:
2729                 return madera_set_outclk(component, source, freq);
2730         default:
2731                 return -EINVAL;
2732         }
2733
2734         if (clk_freq_sel < 0) {
2735                 dev_err(madera->dev,
2736                         "Failed to get clk setting for %dHZ\n", freq);
2737                 return clk_freq_sel;
2738         }
2739
2740         *clk = freq;
2741
2742         if (freq == 0) {
2743                 dev_dbg(madera->dev, "%s cleared\n", name);
2744                 return 0;
2745         }
2746
2747         val |= clk_freq_sel;
2748
2749         if (clock_2_val) {
2750                 ret = regmap_write(madera->regmap, MADERA_DSP_CLOCK_2,
2751                                    clock_2_val);
2752                 if (ret) {
2753                         dev_err(madera->dev,
2754                                 "Failed to write DSP_CONFIG2: %d\n", ret);
2755                         return ret;
2756                 }
2757
2758                 /*
2759                  * We're using the frequency setting in MADERA_DSP_CLOCK_2 so
2760                  * don't change the frequency select bits in MADERA_DSP_CLOCK_1
2761                  */
2762                 mask = MADERA_SYSCLK_SRC_MASK;
2763         }
2764
2765         if (freq % 6144000)
2766                 val |= MADERA_SYSCLK_FRAC;
2767
2768         dev_dbg(madera->dev, "%s set to %uHz\n", name, freq);
2769
2770         return regmap_update_bits(madera->regmap, reg, mask, val);
2771 }
2772 EXPORT_SYMBOL_GPL(madera_set_sysclk);
2773
2774 static int madera_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2775 {
2776         struct snd_soc_component *component = dai->component;
2777         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2778         struct madera *madera = priv->madera;
2779         int lrclk, bclk, mode, base;
2780
2781         base = dai->driver->base;
2782
2783         lrclk = 0;
2784         bclk = 0;
2785
2786         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
2787         case SND_SOC_DAIFMT_DSP_A:
2788                 mode = MADERA_FMT_DSP_MODE_A;
2789                 break;
2790         case SND_SOC_DAIFMT_DSP_B:
2791                 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) !=
2792                     SND_SOC_DAIFMT_CBM_CFM) {
2793                         madera_aif_err(dai, "DSP_B not valid in slave mode\n");
2794                         return -EINVAL;
2795                 }
2796                 mode = MADERA_FMT_DSP_MODE_B;
2797                 break;
2798         case SND_SOC_DAIFMT_I2S:
2799                 mode = MADERA_FMT_I2S_MODE;
2800                 break;
2801         case SND_SOC_DAIFMT_LEFT_J:
2802                 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) !=
2803                     SND_SOC_DAIFMT_CBM_CFM) {
2804                         madera_aif_err(dai, "LEFT_J not valid in slave mode\n");
2805                         return -EINVAL;
2806                 }
2807                 mode = MADERA_FMT_LEFT_JUSTIFIED_MODE;
2808                 break;
2809         default:
2810                 madera_aif_err(dai, "Unsupported DAI format %d\n",
2811                                fmt & SND_SOC_DAIFMT_FORMAT_MASK);
2812                 return -EINVAL;
2813         }
2814
2815         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2816         case SND_SOC_DAIFMT_CBS_CFS:
2817                 break;
2818         case SND_SOC_DAIFMT_CBS_CFM:
2819                 lrclk |= MADERA_AIF1TX_LRCLK_MSTR;
2820                 break;
2821         case SND_SOC_DAIFMT_CBM_CFS:
2822                 bclk |= MADERA_AIF1_BCLK_MSTR;
2823                 break;
2824         case SND_SOC_DAIFMT_CBM_CFM:
2825                 bclk |= MADERA_AIF1_BCLK_MSTR;
2826                 lrclk |= MADERA_AIF1TX_LRCLK_MSTR;
2827                 break;
2828         default:
2829                 madera_aif_err(dai, "Unsupported master mode %d\n",
2830                                fmt & SND_SOC_DAIFMT_MASTER_MASK);
2831                 return -EINVAL;
2832         }
2833
2834         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
2835         case SND_SOC_DAIFMT_NB_NF:
2836                 break;
2837         case SND_SOC_DAIFMT_IB_IF:
2838                 bclk |= MADERA_AIF1_BCLK_INV;
2839                 lrclk |= MADERA_AIF1TX_LRCLK_INV;
2840                 break;
2841         case SND_SOC_DAIFMT_IB_NF:
2842                 bclk |= MADERA_AIF1_BCLK_INV;
2843                 break;
2844         case SND_SOC_DAIFMT_NB_IF:
2845                 lrclk |= MADERA_AIF1TX_LRCLK_INV;
2846                 break;
2847         default:
2848                 madera_aif_err(dai, "Unsupported invert mode %d\n",
2849                                fmt & SND_SOC_DAIFMT_INV_MASK);
2850                 return -EINVAL;
2851         }
2852
2853         regmap_update_bits(madera->regmap, base + MADERA_AIF_BCLK_CTRL,
2854                            MADERA_AIF1_BCLK_INV | MADERA_AIF1_BCLK_MSTR,
2855                            bclk);
2856         regmap_update_bits(madera->regmap, base + MADERA_AIF_TX_PIN_CTRL,
2857                            MADERA_AIF1TX_LRCLK_INV | MADERA_AIF1TX_LRCLK_MSTR,
2858                            lrclk);
2859         regmap_update_bits(madera->regmap, base + MADERA_AIF_RX_PIN_CTRL,
2860                            MADERA_AIF1RX_LRCLK_INV | MADERA_AIF1RX_LRCLK_MSTR,
2861                            lrclk);
2862         regmap_update_bits(madera->regmap, base + MADERA_AIF_FORMAT,
2863                            MADERA_AIF1_FMT_MASK, mode);
2864
2865         return 0;
2866 }
2867
2868 static const int madera_48k_bclk_rates[] = {
2869         -1,
2870         48000,
2871         64000,
2872         96000,
2873         128000,
2874         192000,
2875         256000,
2876         384000,
2877         512000,
2878         768000,
2879         1024000,
2880         1536000,
2881         2048000,
2882         3072000,
2883         4096000,
2884         6144000,
2885         8192000,
2886         12288000,
2887         24576000,
2888 };
2889
2890 static const int madera_44k1_bclk_rates[] = {
2891         -1,
2892         44100,
2893         58800,
2894         88200,
2895         117600,
2896         177640,
2897         235200,
2898         352800,
2899         470400,
2900         705600,
2901         940800,
2902         1411200,
2903         1881600,
2904         2822400,
2905         3763200,
2906         5644800,
2907         7526400,
2908         11289600,
2909         22579200,
2910 };
2911
2912 static const unsigned int madera_sr_vals[] = {
2913         0,
2914         12000,
2915         24000,
2916         48000,
2917         96000,
2918         192000,
2919         384000,
2920         768000,
2921         0,
2922         11025,
2923         22050,
2924         44100,
2925         88200,
2926         176400,
2927         352800,
2928         705600,
2929         4000,
2930         8000,
2931         16000,
2932         32000,
2933         64000,
2934         128000,
2935         256000,
2936         512000,
2937 };
2938
2939 #define MADERA_192K_48K_RATE_MASK       0x0F003E
2940 #define MADERA_192K_44K1_RATE_MASK      0x003E00
2941 #define MADERA_192K_RATE_MASK           (MADERA_192K_48K_RATE_MASK | \
2942                                          MADERA_192K_44K1_RATE_MASK)
2943 #define MADERA_384K_48K_RATE_MASK       0x0F007E
2944 #define MADERA_384K_44K1_RATE_MASK      0x007E00
2945 #define MADERA_384K_RATE_MASK           (MADERA_384K_48K_RATE_MASK | \
2946                                          MADERA_384K_44K1_RATE_MASK)
2947
2948 static const struct snd_pcm_hw_constraint_list madera_constraint = {
2949         .count  = ARRAY_SIZE(madera_sr_vals),
2950         .list   = madera_sr_vals,
2951 };
2952
2953 static int madera_startup(struct snd_pcm_substream *substream,
2954                           struct snd_soc_dai *dai)
2955 {
2956         struct snd_soc_component *component = dai->component;
2957         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
2958         struct madera_dai_priv *dai_priv = &priv->dai[dai->id - 1];
2959         struct madera *madera = priv->madera;
2960         unsigned int base_rate;
2961
2962         if (!substream->runtime)
2963                 return 0;
2964
2965         switch (dai_priv->clk) {
2966         case MADERA_CLK_SYSCLK_1:
2967         case MADERA_CLK_SYSCLK_2:
2968         case MADERA_CLK_SYSCLK_3:
2969                 base_rate = priv->sysclk;
2970                 break;
2971         case MADERA_CLK_ASYNCCLK_1:
2972         case MADERA_CLK_ASYNCCLK_2:
2973                 base_rate = priv->asyncclk;
2974                 break;
2975         default:
2976                 return 0;
2977         }
2978
2979         switch (madera->type) {
2980         case CS42L92:
2981         case CS47L92:
2982         case CS47L93:
2983                 if (base_rate == 0)
2984                         dai_priv->constraint.mask = MADERA_384K_RATE_MASK;
2985                 else if (base_rate % 4000)
2986                         dai_priv->constraint.mask = MADERA_384K_44K1_RATE_MASK;
2987                 else
2988                         dai_priv->constraint.mask = MADERA_384K_48K_RATE_MASK;
2989                 break;
2990         default:
2991                 if (base_rate == 0)
2992                         dai_priv->constraint.mask = MADERA_192K_RATE_MASK;
2993                 else if (base_rate % 4000)
2994                         dai_priv->constraint.mask = MADERA_192K_44K1_RATE_MASK;
2995                 else
2996                         dai_priv->constraint.mask = MADERA_192K_48K_RATE_MASK;
2997                 break;
2998         }
2999
3000         return snd_pcm_hw_constraint_list(substream->runtime, 0,
3001                                           SNDRV_PCM_HW_PARAM_RATE,
3002                                           &dai_priv->constraint);
3003 }
3004
3005 static int madera_hw_params_rate(struct snd_pcm_substream *substream,
3006                                  struct snd_pcm_hw_params *params,
3007                                  struct snd_soc_dai *dai)
3008 {
3009         struct snd_soc_component *component = dai->component;
3010         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
3011         struct madera_dai_priv *dai_priv = &priv->dai[dai->id - 1];
3012         int base = dai->driver->base;
3013         int i, sr_val;
3014         unsigned int reg, cur, tar;
3015         int ret;
3016
3017         for (i = 0; i < ARRAY_SIZE(madera_sr_vals); i++)
3018                 if (madera_sr_vals[i] == params_rate(params))
3019                         break;
3020
3021         if (i == ARRAY_SIZE(madera_sr_vals)) {
3022                 madera_aif_err(dai, "Unsupported sample rate %dHz\n",
3023                                params_rate(params));
3024                 return -EINVAL;
3025         }
3026         sr_val = i;
3027
3028         switch (dai_priv->clk) {
3029         case MADERA_CLK_SYSCLK_1:
3030                 reg = MADERA_SAMPLE_RATE_1;
3031                 tar = 0 << MADERA_AIF1_RATE_SHIFT;
3032                 break;
3033         case MADERA_CLK_SYSCLK_2:
3034                 reg = MADERA_SAMPLE_RATE_2;
3035                 tar = 1 << MADERA_AIF1_RATE_SHIFT;
3036                 break;
3037         case MADERA_CLK_SYSCLK_3:
3038                 reg = MADERA_SAMPLE_RATE_3;
3039                 tar = 2 << MADERA_AIF1_RATE_SHIFT;
3040                 break;
3041         case MADERA_CLK_ASYNCCLK_1:
3042                 reg = MADERA_ASYNC_SAMPLE_RATE_1,
3043                 tar = 8 << MADERA_AIF1_RATE_SHIFT;
3044                 break;
3045         case MADERA_CLK_ASYNCCLK_2:
3046                 reg = MADERA_ASYNC_SAMPLE_RATE_2,
3047                 tar = 9 << MADERA_AIF1_RATE_SHIFT;
3048                 break;
3049         default:
3050                 madera_aif_err(dai, "Invalid clock %d\n", dai_priv->clk);
3051                 return -EINVAL;
3052         }
3053
3054         snd_soc_component_update_bits(component, reg, MADERA_SAMPLE_RATE_1_MASK,
3055                                       sr_val);
3056
3057         if (!base)
3058                 return 0;
3059
3060         ret = regmap_read(priv->madera->regmap,
3061                           base + MADERA_AIF_RATE_CTRL, &cur);
3062         if (ret != 0) {
3063                 madera_aif_err(dai, "Failed to check rate: %d\n", ret);
3064                 return ret;
3065         }
3066
3067         if ((cur & MADERA_AIF1_RATE_MASK) == (tar & MADERA_AIF1_RATE_MASK))
3068                 return 0;
3069
3070         mutex_lock(&priv->rate_lock);
3071
3072         if (!madera_can_change_grp_rate(priv, base + MADERA_AIF_RATE_CTRL)) {
3073                 madera_aif_warn(dai, "Cannot change rate while active\n");
3074                 ret = -EBUSY;
3075                 goto out;
3076         }
3077
3078         /* Guard the rate change with SYSCLK cycles */
3079         madera_spin_sysclk(priv);
3080         snd_soc_component_update_bits(component, base + MADERA_AIF_RATE_CTRL,
3081                                       MADERA_AIF1_RATE_MASK, tar);
3082         madera_spin_sysclk(priv);
3083
3084 out:
3085         mutex_unlock(&priv->rate_lock);
3086
3087         return ret;
3088 }
3089
3090 static int madera_aif_cfg_changed(struct snd_soc_component *component,
3091                                   int base, int bclk, int lrclk, int frame)
3092 {
3093         unsigned int val;
3094         int ret;
3095
3096         ret = snd_soc_component_read(component, base + MADERA_AIF_BCLK_CTRL,
3097                                      &val);
3098         if (ret)
3099                 return ret;
3100         if (bclk != (val & MADERA_AIF1_BCLK_FREQ_MASK))
3101                 return 1;
3102
3103         ret = snd_soc_component_read(component, base + MADERA_AIF_RX_BCLK_RATE,
3104                                      &val);
3105         if (ret)
3106                 return ret;
3107         if (lrclk != (val & MADERA_AIF1RX_BCPF_MASK))
3108                 return 1;
3109
3110         ret = snd_soc_component_read(component, base + MADERA_AIF_FRAME_CTRL_1,
3111                                      &val);
3112         if (ret)
3113                 return ret;
3114         if (frame != (val & (MADERA_AIF1TX_WL_MASK |
3115                              MADERA_AIF1TX_SLOT_LEN_MASK)))
3116                 return 1;
3117
3118         return 0;
3119 }
3120
3121 static int madera_hw_params(struct snd_pcm_substream *substream,
3122                             struct snd_pcm_hw_params *params,
3123                             struct snd_soc_dai *dai)
3124 {
3125         struct snd_soc_component *component = dai->component;
3126         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
3127         struct madera *madera = priv->madera;
3128         int base = dai->driver->base;
3129         const int *rates;
3130         int i, ret;
3131         unsigned int val;
3132         unsigned int channels = params_channels(params);
3133         unsigned int rate = params_rate(params);
3134         unsigned int chan_limit =
3135                         madera->pdata.codec.max_channels_clocked[dai->id - 1];
3136         int tdm_width = priv->tdm_width[dai->id - 1];
3137         int tdm_slots = priv->tdm_slots[dai->id - 1];
3138         int bclk, lrclk, wl, frame, bclk_target, num_rates;
3139         int reconfig;
3140         unsigned int aif_tx_state = 0, aif_rx_state = 0;
3141
3142         if (rate % 4000) {
3143                 rates = &madera_44k1_bclk_rates[0];
3144                 num_rates = ARRAY_SIZE(madera_44k1_bclk_rates);
3145         } else {
3146                 rates = &madera_48k_bclk_rates[0];
3147                 num_rates = ARRAY_SIZE(madera_48k_bclk_rates);
3148         }
3149
3150         wl = snd_pcm_format_width(params_format(params));
3151
3152         if (tdm_slots) {
3153                 madera_aif_dbg(dai, "Configuring for %d %d bit TDM slots\n",
3154                                tdm_slots, tdm_width);
3155                 bclk_target = tdm_slots * tdm_width * rate;
3156                 channels = tdm_slots;
3157         } else {
3158                 bclk_target = snd_soc_params_to_bclk(params);
3159                 tdm_width = wl;
3160         }
3161
3162         if (chan_limit && chan_limit < channels) {
3163                 madera_aif_dbg(dai, "Limiting to %d channels\n", chan_limit);
3164                 bclk_target /= channels;
3165                 bclk_target *= chan_limit;
3166         }
3167
3168         /* Force multiple of 2 channels for I2S mode */
3169         ret = snd_soc_component_read(component, base + MADERA_AIF_FORMAT, &val);
3170         if (ret)
3171                 return ret;
3172
3173         val &= MADERA_AIF1_FMT_MASK;
3174         if ((channels & 1) && val == MADERA_FMT_I2S_MODE) {
3175                 madera_aif_dbg(dai, "Forcing stereo mode\n");
3176                 bclk_target /= channels;
3177                 bclk_target *= channels + 1;
3178         }
3179
3180         for (i = 0; i < num_rates; i++) {
3181                 if (rates[i] >= bclk_target && rates[i] % rate == 0) {
3182                         bclk = i;
3183                         break;
3184                 }
3185         }
3186
3187         if (i == num_rates) {
3188                 madera_aif_err(dai, "Unsupported sample rate %dHz\n", rate);
3189                 return -EINVAL;
3190         }
3191
3192         lrclk = rates[bclk] / rate;
3193
3194         madera_aif_dbg(dai, "BCLK %dHz LRCLK %dHz\n",
3195                        rates[bclk], rates[bclk] / lrclk);
3196
3197         frame = wl << MADERA_AIF1TX_WL_SHIFT | tdm_width;
3198
3199         reconfig = madera_aif_cfg_changed(component, base, bclk, lrclk, frame);
3200         if (reconfig < 0)
3201                 return reconfig;
3202
3203         if (reconfig) {
3204                 /* Save AIF TX/RX state */
3205                 regmap_read(madera->regmap, base + MADERA_AIF_TX_ENABLES,
3206                             &aif_tx_state);
3207                 regmap_read(madera->regmap, base + MADERA_AIF_RX_ENABLES,
3208                             &aif_rx_state);
3209                 /* Disable AIF TX/RX before reconfiguring it */
3210                 regmap_update_bits(madera->regmap,
3211                                    base + MADERA_AIF_TX_ENABLES, 0xff, 0x0);
3212                 regmap_update_bits(madera->regmap,
3213                                    base + MADERA_AIF_RX_ENABLES, 0xff, 0x0);
3214         }
3215
3216         ret = madera_hw_params_rate(substream, params, dai);
3217         if (ret != 0)
3218                 goto restore_aif;
3219
3220         if (reconfig) {
3221                 regmap_update_bits(madera->regmap,
3222                                    base + MADERA_AIF_BCLK_CTRL,
3223                                    MADERA_AIF1_BCLK_FREQ_MASK, bclk);
3224                 regmap_update_bits(madera->regmap,
3225                                    base + MADERA_AIF_RX_BCLK_RATE,
3226                                    MADERA_AIF1RX_BCPF_MASK, lrclk);
3227                 regmap_update_bits(madera->regmap,
3228                                    base + MADERA_AIF_FRAME_CTRL_1,
3229                                    MADERA_AIF1TX_WL_MASK |
3230                                    MADERA_AIF1TX_SLOT_LEN_MASK, frame);
3231                 regmap_update_bits(madera->regmap,
3232                                    base + MADERA_AIF_FRAME_CTRL_2,
3233                                    MADERA_AIF1RX_WL_MASK |
3234                                    MADERA_AIF1RX_SLOT_LEN_MASK, frame);
3235         }
3236
3237 restore_aif:
3238         if (reconfig) {
3239                 /* Restore AIF TX/RX state */
3240                 regmap_update_bits(madera->regmap,
3241                                    base + MADERA_AIF_TX_ENABLES,
3242                                    0xff, aif_tx_state);
3243                 regmap_update_bits(madera->regmap,
3244                                    base + MADERA_AIF_RX_ENABLES,
3245                                    0xff, aif_rx_state);
3246         }
3247
3248         return ret;
3249 }
3250
3251 static int madera_is_syncclk(int clk_id)
3252 {
3253         switch (clk_id) {
3254         case MADERA_CLK_SYSCLK_1:
3255         case MADERA_CLK_SYSCLK_2:
3256         case MADERA_CLK_SYSCLK_3:
3257                 return 1;
3258         case MADERA_CLK_ASYNCCLK_1:
3259         case MADERA_CLK_ASYNCCLK_2:
3260                 return 0;
3261         default:
3262                 return -EINVAL;
3263         }
3264 }
3265
3266 static int madera_dai_set_sysclk(struct snd_soc_dai *dai,
3267                                  int clk_id, unsigned int freq, int dir)
3268 {
3269         struct snd_soc_component *component = dai->component;
3270         struct snd_soc_dapm_context *dapm =
3271                 snd_soc_component_get_dapm(component);
3272         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
3273         struct madera_dai_priv *dai_priv = &priv->dai[dai->id - 1];
3274         struct snd_soc_dapm_route routes[2];
3275         int is_sync;
3276
3277         is_sync = madera_is_syncclk(clk_id);
3278         if (is_sync < 0) {
3279                 dev_err(component->dev, "Illegal DAI clock id %d\n", clk_id);
3280                 return is_sync;
3281         }
3282
3283         if (is_sync == madera_is_syncclk(dai_priv->clk))
3284                 return 0;
3285
3286         if (dai->active) {
3287                 dev_err(component->dev, "Can't change clock on active DAI %d\n",
3288                         dai->id);
3289                 return -EBUSY;
3290         }
3291
3292         dev_dbg(component->dev, "Setting AIF%d to %s\n", dai->id,
3293                 is_sync ? "SYSCLK" : "ASYNCCLK");
3294
3295         /*
3296          * A connection to SYSCLK is always required, we only add and remove
3297          * a connection to ASYNCCLK
3298          */
3299         memset(&routes, 0, sizeof(routes));
3300         routes[0].sink = dai->driver->capture.stream_name;
3301         routes[1].sink = dai->driver->playback.stream_name;
3302         routes[0].source = "ASYNCCLK";
3303         routes[1].source = "ASYNCCLK";
3304
3305         if (is_sync)
3306                 snd_soc_dapm_del_routes(dapm, routes, ARRAY_SIZE(routes));
3307         else
3308                 snd_soc_dapm_add_routes(dapm, routes, ARRAY_SIZE(routes));
3309
3310         dai_priv->clk = clk_id;
3311
3312         return snd_soc_dapm_sync(dapm);
3313 }
3314
3315 static int madera_set_tristate(struct snd_soc_dai *dai, int tristate)
3316 {
3317         struct snd_soc_component *component = dai->component;
3318         int base = dai->driver->base;
3319         unsigned int reg;
3320         int ret;
3321
3322         if (tristate)
3323                 reg = MADERA_AIF1_TRI;
3324         else
3325                 reg = 0;
3326
3327         ret = snd_soc_component_update_bits(component,
3328                                             base + MADERA_AIF_RATE_CTRL,
3329                                             MADERA_AIF1_TRI, reg);
3330         if (ret < 0)
3331                 return ret;
3332         else
3333                 return 0;
3334 }
3335
3336 static void madera_set_channels_to_mask(struct snd_soc_dai *dai,
3337                                         unsigned int base,
3338                                         int channels, unsigned int mask)
3339 {
3340         struct snd_soc_component *component = dai->component;
3341         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
3342         struct madera *madera = priv->madera;
3343         int slot, i;
3344
3345         for (i = 0; i < channels; ++i) {
3346                 slot = ffs(mask) - 1;
3347                 if (slot < 0)
3348                         return;
3349
3350                 regmap_write(madera->regmap, base + i, slot);
3351
3352                 mask &= ~(1 << slot);
3353         }
3354
3355         if (mask)
3356                 madera_aif_warn(dai, "Too many channels in TDM mask\n");
3357 }
3358
3359 static int madera_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
3360                                unsigned int rx_mask, int slots, int slot_width)
3361 {
3362         struct snd_soc_component *component = dai->component;
3363         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
3364         int base = dai->driver->base;
3365         int rx_max_chan = dai->driver->playback.channels_max;
3366         int tx_max_chan = dai->driver->capture.channels_max;
3367
3368         /* Only support TDM for the physical AIFs */
3369         if (dai->id > MADERA_MAX_AIF)
3370                 return -ENOTSUPP;
3371
3372         if (slots == 0) {
3373                 tx_mask = (1 << tx_max_chan) - 1;
3374                 rx_mask = (1 << rx_max_chan) - 1;
3375         }
3376
3377         madera_set_channels_to_mask(dai, base + MADERA_AIF_FRAME_CTRL_3,
3378                                     tx_max_chan, tx_mask);
3379         madera_set_channels_to_mask(dai, base + MADERA_AIF_FRAME_CTRL_11,
3380                                     rx_max_chan, rx_mask);
3381
3382         priv->tdm_width[dai->id - 1] = slot_width;
3383         priv->tdm_slots[dai->id - 1] = slots;
3384
3385         return 0;
3386 }
3387
3388 const struct snd_soc_dai_ops madera_dai_ops = {
3389         .startup = &madera_startup,
3390         .set_fmt = &madera_set_fmt,
3391         .set_tdm_slot = &madera_set_tdm_slot,
3392         .hw_params = &madera_hw_params,
3393         .set_sysclk = &madera_dai_set_sysclk,
3394         .set_tristate = &madera_set_tristate,
3395 };
3396 EXPORT_SYMBOL_GPL(madera_dai_ops);
3397
3398 const struct snd_soc_dai_ops madera_simple_dai_ops = {
3399         .startup = &madera_startup,
3400         .hw_params = &madera_hw_params_rate,
3401         .set_sysclk = &madera_dai_set_sysclk,
3402 };
3403 EXPORT_SYMBOL_GPL(madera_simple_dai_ops);
3404
3405 int madera_init_dai(struct madera_priv *priv, int id)
3406 {
3407         struct madera_dai_priv *dai_priv = &priv->dai[id];
3408
3409         dai_priv->clk = MADERA_CLK_SYSCLK_1;
3410         dai_priv->constraint = madera_constraint;
3411
3412         return 0;
3413 }
3414 EXPORT_SYMBOL_GPL(madera_init_dai);
3415
3416 static const struct {
3417         unsigned int min;
3418         unsigned int max;
3419         u16 fratio;
3420         int ratio;
3421 } fll_sync_fratios[] = {
3422         {       0,    64000, 4, 16 },
3423         {   64000,   128000, 3,  8 },
3424         {  128000,   256000, 2,  4 },
3425         {  256000,  1000000, 1,  2 },
3426         { 1000000, 13500000, 0,  1 },
3427 };
3428
3429 static const unsigned int pseudo_fref_max[MADERA_FLL_MAX_FRATIO] = {
3430         13500000,
3431          6144000,
3432          6144000,
3433          3072000,
3434          3072000,
3435          2822400,
3436          2822400,
3437          1536000,
3438          1536000,
3439          1536000,
3440          1536000,
3441          1536000,
3442          1536000,
3443          1536000,
3444          1536000,
3445           768000,
3446 };
3447
3448 struct madera_fll_gains {
3449         unsigned int min;
3450         unsigned int max;
3451         int gain;               /* main gain */
3452         int alt_gain;           /* alternate integer gain */
3453 };
3454
3455 static const struct madera_fll_gains madera_fll_sync_gains[] = {
3456         {       0,   256000, 0, -1 },
3457         {  256000,  1000000, 2, -1 },
3458         { 1000000, 13500000, 4, -1 },
3459 };
3460
3461 static const struct madera_fll_gains madera_fll_main_gains[] = {
3462         {       0,   100000, 0, 2 },
3463         {  100000,   375000, 2, 2 },
3464         {  375000,   768000, 3, 2 },
3465         {  768001,  1500000, 3, 3 },
3466         { 1500000,  6000000, 4, 3 },
3467         { 6000000, 13500000, 5, 3 },
3468 };
3469
3470 static int madera_find_sync_fratio(unsigned int fref, int *fratio)
3471 {
3472         int i;
3473
3474         for (i = 0; i < ARRAY_SIZE(fll_sync_fratios); i++) {
3475                 if (fll_sync_fratios[i].min <= fref &&
3476                     fref <= fll_sync_fratios[i].max) {
3477                         if (fratio)
3478                                 *fratio = fll_sync_fratios[i].fratio;
3479
3480                         return fll_sync_fratios[i].ratio;
3481                 }
3482         }
3483
3484         return -EINVAL;
3485 }
3486
3487 static int madera_find_main_fratio(unsigned int fref, unsigned int fout,
3488                                    int *fratio)
3489 {
3490         int ratio = 1;
3491
3492         while ((fout / (ratio * fref)) > MADERA_FLL_MAX_N)
3493                 ratio++;
3494
3495         if (fratio)
3496                 *fratio = ratio - 1;
3497
3498         return ratio;
3499 }
3500
3501 static int madera_find_fratio(struct madera_fll *fll, unsigned int fref,
3502                               bool sync, int *fratio)
3503 {
3504         switch (fll->madera->type) {
3505         case CS47L35:
3506                 switch (fll->madera->rev) {
3507                 case 0:
3508                         /* rev A0 uses sync calculation for both loops */
3509                         return madera_find_sync_fratio(fref, fratio);
3510                 default:
3511                         if (sync)
3512                                 return madera_find_sync_fratio(fref, fratio);
3513                         else
3514                                 return madera_find_main_fratio(fref,
3515                                                                fll->fout,
3516                                                                fratio);
3517                 }
3518                 break;
3519         case CS47L85:
3520         case WM1840:
3521                 /* these use the same calculation for main and sync loops */
3522                 return madera_find_sync_fratio(fref, fratio);
3523         default:
3524                 if (sync)
3525                         return madera_find_sync_fratio(fref, fratio);
3526                 else
3527                         return madera_find_main_fratio(fref, fll->fout, fratio);
3528         }
3529 }
3530
3531 static int madera_calc_fratio(struct madera_fll *fll,
3532                               struct madera_fll_cfg *cfg,
3533                               unsigned int fref, bool sync)
3534 {
3535         int init_ratio, ratio;
3536         int refdiv, div;
3537
3538         /* fref must be <=13.5MHz, find initial refdiv */
3539         div = 1;
3540         cfg->refdiv = 0;
3541         while (fref > MADERA_FLL_MAX_FREF) {
3542                 div *= 2;
3543                 fref /= 2;
3544                 cfg->refdiv++;
3545
3546                 if (div > MADERA_FLL_MAX_REFDIV)
3547                         return -EINVAL;
3548         }
3549
3550         /* Find an appropriate FLL_FRATIO */
3551         init_ratio = madera_find_fratio(fll, fref, sync, &cfg->fratio);
3552         if (init_ratio < 0) {
3553                 madera_fll_err(fll, "Unable to find FRATIO for fref=%uHz\n",
3554                                fref);
3555                 return init_ratio;
3556         }
3557
3558         if (!sync)
3559                 cfg->fratio = init_ratio - 1;
3560
3561         switch (fll->madera->type) {
3562         case CS47L35:
3563                 switch (fll->madera->rev) {
3564                 case 0:
3565                         if (sync)
3566                                 return init_ratio;
3567                         break;
3568                 default:
3569                         return init_ratio;
3570                 }
3571                 break;
3572         case CS47L85:
3573         case WM1840:
3574                 if (sync)
3575                         return init_ratio;
3576                 break;
3577         default:
3578                 return init_ratio;
3579         }
3580
3581         /*
3582          * For CS47L35 rev A0, CS47L85 and WM1840 adjust FRATIO/refdiv to avoid
3583          * integer mode if possible
3584          */
3585         refdiv = cfg->refdiv;
3586
3587         while (div <= MADERA_FLL_MAX_REFDIV) {
3588                 /*
3589                  * start from init_ratio because this may already give a
3590                  * fractional N.K
3591                  */
3592                 for (ratio = init_ratio; ratio > 0; ratio--) {
3593                         if (fll->fout % (ratio * fref)) {
3594                                 cfg->refdiv = refdiv;
3595                                 cfg->fratio = ratio - 1;
3596                                 return ratio;
3597                         }
3598                 }
3599
3600                 for (ratio = init_ratio + 1; ratio <= MADERA_FLL_MAX_FRATIO;
3601                      ratio++) {
3602                         if ((MADERA_FLL_VCO_CORNER / 2) /
3603                             (MADERA_FLL_VCO_MULT * ratio) < fref)
3604                                 break;
3605
3606                         if (fref > pseudo_fref_max[ratio - 1])
3607                                 break;
3608
3609                         if (fll->fout % (ratio * fref)) {
3610                                 cfg->refdiv = refdiv;
3611                                 cfg->fratio = ratio - 1;
3612                                 return ratio;
3613                         }
3614                 }
3615
3616                 div *= 2;
3617                 fref /= 2;
3618                 refdiv++;
3619                 init_ratio = madera_find_fratio(fll, fref, sync, NULL);
3620         }
3621
3622         madera_fll_warn(fll, "Falling back to integer mode operation\n");
3623
3624         return cfg->fratio + 1;
3625 }
3626
3627 static int madera_find_fll_gain(struct madera_fll *fll,
3628                                 struct madera_fll_cfg *cfg,
3629                                 unsigned int fref,
3630                                 const struct madera_fll_gains *gains,
3631                                 int n_gains)
3632 {
3633         int i;
3634
3635         for (i = 0; i < n_gains; i++) {
3636                 if (gains[i].min <= fref && fref <= gains[i].max) {
3637                         cfg->gain = gains[i].gain;
3638                         cfg->alt_gain = gains[i].alt_gain;
3639                         return 0;
3640                 }
3641         }
3642
3643         madera_fll_err(fll, "Unable to find gain for fref=%uHz\n", fref);
3644
3645         return -EINVAL;
3646 }
3647
3648 static int madera_calc_fll(struct madera_fll *fll,
3649                            struct madera_fll_cfg *cfg,
3650                            unsigned int fref, bool sync)
3651 {
3652         unsigned int gcd_fll;
3653         const struct madera_fll_gains *gains;
3654         int n_gains;
3655         int ratio, ret;
3656
3657         madera_fll_dbg(fll, "fref=%u Fout=%u fvco=%u\n",
3658                        fref, fll->fout, fll->fout * MADERA_FLL_VCO_MULT);
3659
3660         /* Find an appropriate FLL_FRATIO and refdiv */
3661         ratio = madera_calc_fratio(fll, cfg, fref, sync);
3662         if (ratio < 0)
3663                 return ratio;
3664
3665         /* Apply the division for our remaining calculations */
3666         fref = fref / (1 << cfg->refdiv);
3667
3668         cfg->n = fll->fout / (ratio * fref);
3669
3670         if (fll->fout % (ratio * fref)) {
3671                 gcd_fll = gcd(fll->fout, ratio * fref);
3672                 madera_fll_dbg(fll, "GCD=%u\n", gcd_fll);
3673
3674                 cfg->theta = (fll->fout - (cfg->n * ratio * fref))
3675                         / gcd_fll;
3676                 cfg->lambda = (ratio * fref) / gcd_fll;
3677         } else {
3678                 cfg->theta = 0;
3679                 cfg->lambda = 0;
3680         }
3681
3682         /*
3683          * Round down to 16bit range with cost of accuracy lost.
3684          * Denominator must be bigger than numerator so we only
3685          * take care of it.
3686          */
3687         while (cfg->lambda >= (1 << 16)) {
3688                 cfg->theta >>= 1;
3689                 cfg->lambda >>= 1;
3690         }
3691
3692         switch (fll->madera->type) {
3693         case CS47L35:
3694                 switch (fll->madera->rev) {
3695                 case 0:
3696                         /* Rev A0 uses the sync gains for both loops */
3697                         gains = madera_fll_sync_gains;
3698                         n_gains = ARRAY_SIZE(madera_fll_sync_gains);
3699                         break;
3700                 default:
3701                         if (sync) {
3702                                 gains = madera_fll_sync_gains;
3703                                 n_gains = ARRAY_SIZE(madera_fll_sync_gains);
3704                         } else {
3705                                 gains = madera_fll_main_gains;
3706                                 n_gains = ARRAY_SIZE(madera_fll_main_gains);
3707                         }
3708                         break;
3709                 }
3710                 break;
3711         case CS47L85:
3712         case WM1840:
3713                 /* These use the sync gains for both loops */
3714                 gains = madera_fll_sync_gains;
3715                 n_gains = ARRAY_SIZE(madera_fll_sync_gains);
3716                 break;
3717         default:
3718                 if (sync) {
3719                         gains = madera_fll_sync_gains;
3720                         n_gains = ARRAY_SIZE(madera_fll_sync_gains);
3721                 } else {
3722                         gains = madera_fll_main_gains;
3723                         n_gains = ARRAY_SIZE(madera_fll_main_gains);
3724                 }
3725                 break;
3726         }
3727
3728         ret = madera_find_fll_gain(fll, cfg, fref, gains, n_gains);
3729         if (ret)
3730                 return ret;
3731
3732         madera_fll_dbg(fll, "N=%d THETA=%d LAMBDA=%d\n",
3733                        cfg->n, cfg->theta, cfg->lambda);
3734         madera_fll_dbg(fll, "FRATIO=0x%x(%d) REFCLK_DIV=0x%x(%d)\n",
3735                        cfg->fratio, ratio, cfg->refdiv, 1 << cfg->refdiv);
3736         madera_fll_dbg(fll, "GAIN=0x%x(%d)\n", cfg->gain, 1 << cfg->gain);
3737
3738         return 0;
3739 }
3740
3741 static bool madera_write_fll(struct madera *madera, unsigned int base,
3742                              struct madera_fll_cfg *cfg, int source,
3743                              bool sync, int gain)
3744 {
3745         bool change, fll_change;
3746
3747         fll_change = false;
3748         regmap_update_bits_check(madera->regmap,
3749                                  base + MADERA_FLL_CONTROL_3_OFFS,
3750                                  MADERA_FLL1_THETA_MASK,
3751                                  cfg->theta, &change);
3752         fll_change |= change;
3753         regmap_update_bits_check(madera->regmap,
3754                                  base + MADERA_FLL_CONTROL_4_OFFS,
3755                                  MADERA_FLL1_LAMBDA_MASK,
3756                                  cfg->lambda, &change);
3757         fll_change |= change;
3758         regmap_update_bits_check(madera->regmap,
3759                                  base + MADERA_FLL_CONTROL_5_OFFS,
3760                                  MADERA_FLL1_FRATIO_MASK,
3761                                  cfg->fratio << MADERA_FLL1_FRATIO_SHIFT,
3762                                  &change);
3763         fll_change |= change;
3764         regmap_update_bits_check(madera->regmap,
3765                                  base + MADERA_FLL_CONTROL_6_OFFS,
3766                                  MADERA_FLL1_REFCLK_DIV_MASK |
3767                                  MADERA_FLL1_REFCLK_SRC_MASK,
3768                                  cfg->refdiv << MADERA_FLL1_REFCLK_DIV_SHIFT |
3769                                  source << MADERA_FLL1_REFCLK_SRC_SHIFT,
3770                                  &change);
3771         fll_change |= change;
3772
3773         if (sync) {
3774                 regmap_update_bits_check(madera->regmap,
3775                                          base + MADERA_FLL_SYNCHRONISER_7_OFFS,
3776                                          MADERA_FLL1_GAIN_MASK,
3777                                          gain << MADERA_FLL1_GAIN_SHIFT,
3778                                          &change);
3779                 fll_change |= change;
3780         } else {
3781                 regmap_update_bits_check(madera->regmap,
3782                                          base + MADERA_FLL_CONTROL_7_OFFS,
3783                                          MADERA_FLL1_GAIN_MASK,
3784                                          gain << MADERA_FLL1_GAIN_SHIFT,
3785                                          &change);
3786                 fll_change |= change;
3787         }
3788
3789         regmap_update_bits_check(madera->regmap,
3790                                  base + MADERA_FLL_CONTROL_2_OFFS,
3791                                  MADERA_FLL1_CTRL_UPD | MADERA_FLL1_N_MASK,
3792                                  MADERA_FLL1_CTRL_UPD | cfg->n, &change);
3793         fll_change |= change;
3794
3795         return fll_change;
3796 }
3797
3798 static int madera_is_enabled_fll(struct madera_fll *fll, int base)
3799 {
3800         struct madera *madera = fll->madera;
3801         unsigned int reg;
3802         int ret;
3803
3804         ret = regmap_read(madera->regmap,
3805                           base + MADERA_FLL_CONTROL_1_OFFS, &reg);
3806         if (ret != 0) {
3807                 madera_fll_err(fll, "Failed to read current state: %d\n", ret);
3808                 return ret;
3809         }
3810
3811         return reg & MADERA_FLL1_ENA;
3812 }
3813
3814 static int madera_wait_for_fll(struct madera_fll *fll, bool requested)
3815 {
3816         struct madera *madera = fll->madera;
3817         unsigned int val = 0;
3818         bool status;
3819         int i;
3820
3821         madera_fll_dbg(fll, "Waiting for FLL...\n");
3822
3823         for (i = 0; i < 30; i++) {
3824                 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_2, &val);
3825                 status = val & (MADERA_FLL1_LOCK_STS1 << (fll->id - 1));
3826                 if (status == requested)
3827                         return 0;
3828
3829                 switch (i) {
3830                 case 0 ... 5:
3831                         usleep_range(75, 125);
3832                         break;
3833                 case 11 ... 20:
3834                         usleep_range(750, 1250);
3835                         break;
3836                 default:
3837                         msleep(20);
3838                         break;
3839                 }
3840         }
3841
3842         madera_fll_warn(fll, "Timed out waiting for lock\n");
3843
3844         return -ETIMEDOUT;
3845 }
3846
3847 static bool madera_set_fll_phase_integrator(struct madera_fll *fll,
3848                                             struct madera_fll_cfg *ref_cfg,
3849                                             bool sync)
3850 {
3851         unsigned int val;
3852         bool reg_change;
3853
3854         if (!sync && ref_cfg->theta == 0)
3855                 val = (1 << MADERA_FLL1_PHASE_ENA_SHIFT) |
3856                       (2 << MADERA_FLL1_PHASE_GAIN_SHIFT);
3857         else
3858                 val = 2 << MADERA_FLL1_PHASE_GAIN_SHIFT;
3859
3860         regmap_update_bits_check(fll->madera->regmap,
3861                                  fll->base + MADERA_FLL_EFS_2_OFFS,
3862                                  MADERA_FLL1_PHASE_ENA_MASK |
3863                                  MADERA_FLL1_PHASE_GAIN_MASK,
3864                                  val, &reg_change);
3865
3866         return reg_change;
3867 }
3868
3869 static int madera_set_fll_clks_reg(struct madera_fll *fll, bool ena,
3870                                    unsigned int reg, unsigned int mask,
3871                                    unsigned int shift)
3872 {
3873         struct madera *madera = fll->madera;
3874         unsigned int src;
3875         struct clk *clk;
3876         int ret;
3877
3878         ret = regmap_read(madera->regmap, reg, &src);
3879         if (ret != 0) {
3880                 madera_fll_err(fll, "Failed to read current source: %d\n",
3881                                ret);
3882                 return ret;
3883         }
3884
3885         src = (src & mask) >> shift;
3886
3887         switch (src) {
3888         case MADERA_FLL_SRC_MCLK1:
3889                 clk = madera->mclk[MADERA_MCLK1].clk;
3890                 break;
3891         case MADERA_FLL_SRC_MCLK2:
3892                 clk = madera->mclk[MADERA_MCLK2].clk;
3893                 break;
3894         case MADERA_FLL_SRC_MCLK3:
3895                 clk = madera->mclk[MADERA_MCLK3].clk;
3896                 break;
3897         default:
3898                 return 0;
3899         }
3900
3901         if (ena) {
3902                 return clk_prepare_enable(clk);
3903         } else {
3904                 clk_disable_unprepare(clk);
3905                 return 0;
3906         }
3907 }
3908
3909 static inline int madera_set_fll_clks(struct madera_fll *fll, int base, bool ena)
3910 {
3911         return madera_set_fll_clks_reg(fll, ena,
3912                                        base + MADERA_FLL_CONTROL_6_OFFS,
3913                                        MADERA_FLL1_REFCLK_SRC_MASK,
3914                                        MADERA_FLL1_REFCLK_DIV_SHIFT);
3915 }
3916
3917 static inline int madera_set_fllao_clks(struct madera_fll *fll, int base, bool ena)
3918 {
3919         return madera_set_fll_clks_reg(fll, ena,
3920                                        base + MADERA_FLLAO_CONTROL_6_OFFS,
3921                                        MADERA_FLL_AO_REFCLK_SRC_MASK,
3922                                        MADERA_FLL_AO_REFCLK_SRC_SHIFT);
3923 }
3924
3925 static inline int madera_set_fllhj_clks(struct madera_fll *fll, int base, bool ena)
3926 {
3927         return madera_set_fll_clks_reg(fll, ena,
3928                                        base + MADERA_FLL_CONTROL_1_OFFS,
3929                                        CS47L92_FLL1_REFCLK_SRC_MASK,
3930                                        CS47L92_FLL1_REFCLK_SRC_SHIFT);
3931 }
3932
3933 static void madera_disable_fll(struct madera_fll *fll)
3934 {
3935         struct madera *madera = fll->madera;
3936         unsigned int sync_base;
3937         bool ref_change, sync_change;
3938
3939         switch (madera->type) {
3940         case CS47L35:
3941                 sync_base = fll->base + CS47L35_FLL_SYNCHRONISER_OFFS;
3942                 break;
3943         default:
3944                 sync_base = fll->base + MADERA_FLL_SYNCHRONISER_OFFS;
3945                 break;
3946         }
3947
3948         madera_fll_dbg(fll, "Disabling FLL\n");
3949
3950         regmap_update_bits(madera->regmap,
3951                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
3952                            MADERA_FLL1_FREERUN, MADERA_FLL1_FREERUN);
3953         regmap_update_bits_check(madera->regmap,
3954                                  fll->base + MADERA_FLL_CONTROL_1_OFFS,
3955                                  MADERA_FLL1_ENA, 0, &ref_change);
3956         regmap_update_bits_check(madera->regmap,
3957                                  sync_base + MADERA_FLL_SYNCHRONISER_1_OFFS,
3958                                  MADERA_FLL1_SYNC_ENA, 0, &sync_change);
3959         regmap_update_bits(madera->regmap,
3960                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
3961                            MADERA_FLL1_FREERUN, 0);
3962
3963         madera_wait_for_fll(fll, false);
3964
3965         if (sync_change)
3966                 madera_set_fll_clks(fll, sync_base, false);
3967
3968         if (ref_change) {
3969                 madera_set_fll_clks(fll, fll->base, false);
3970                 pm_runtime_put_autosuspend(madera->dev);
3971         }
3972 }
3973
3974 static int madera_enable_fll(struct madera_fll *fll)
3975 {
3976         struct madera *madera = fll->madera;
3977         bool have_sync = false;
3978         int already_enabled = madera_is_enabled_fll(fll, fll->base);
3979         int sync_enabled;
3980         struct madera_fll_cfg cfg;
3981         unsigned int sync_base;
3982         int gain, ret;
3983         bool fll_change = false;
3984
3985         if (already_enabled < 0)
3986                 return already_enabled; /* error getting current state */
3987
3988         if (fll->ref_src < 0 || fll->ref_freq == 0) {
3989                 madera_fll_err(fll, "No REFCLK\n");
3990                 ret = -EINVAL;
3991                 goto err;
3992         }
3993
3994         madera_fll_dbg(fll, "Enabling FLL, initially %s\n",
3995                        already_enabled ? "enabled" : "disabled");
3996
3997         if (fll->fout < MADERA_FLL_MIN_FOUT ||
3998             fll->fout > MADERA_FLL_MAX_FOUT) {
3999                 madera_fll_err(fll, "invalid fout %uHz\n", fll->fout);
4000                 ret = -EINVAL;
4001                 goto err;
4002         }
4003
4004         switch (madera->type) {
4005         case CS47L35:
4006                 sync_base = fll->base + CS47L35_FLL_SYNCHRONISER_OFFS;
4007                 break;
4008         default:
4009                 sync_base = fll->base + MADERA_FLL_SYNCHRONISER_OFFS;
4010                 break;
4011         }
4012
4013         sync_enabled = madera_is_enabled_fll(fll, sync_base);
4014         if (sync_enabled < 0)
4015                 return sync_enabled;
4016
4017         if (already_enabled) {
4018                 /* Facilitate smooth refclk across the transition */
4019                 regmap_update_bits(fll->madera->regmap,
4020                                    fll->base + MADERA_FLL_CONTROL_1_OFFS,
4021                                    MADERA_FLL1_FREERUN,
4022                                    MADERA_FLL1_FREERUN);
4023                 udelay(32);
4024                 regmap_update_bits(fll->madera->regmap,
4025                                    fll->base + MADERA_FLL_CONTROL_7_OFFS,
4026                                    MADERA_FLL1_GAIN_MASK, 0);
4027
4028                 if (sync_enabled > 0)
4029                         madera_set_fll_clks(fll, sync_base, false);
4030                 madera_set_fll_clks(fll, fll->base, false);
4031         }
4032
4033         /* Apply SYNCCLK setting */
4034         if (fll->sync_src >= 0) {
4035                 ret = madera_calc_fll(fll, &cfg, fll->sync_freq, true);
4036                 if (ret < 0)
4037                         goto err;
4038
4039                 fll_change |= madera_write_fll(madera, sync_base,
4040                                                &cfg, fll->sync_src,
4041                                                true, cfg.gain);
4042                 have_sync = true;
4043         }
4044
4045         if (already_enabled && !!sync_enabled != have_sync)
4046                 madera_fll_warn(fll, "Synchroniser changed on active FLL\n");
4047
4048         /* Apply REFCLK setting */
4049         ret = madera_calc_fll(fll, &cfg, fll->ref_freq, false);
4050         if (ret < 0)
4051                 goto err;
4052
4053         /* Ref path hardcodes lambda to 65536 when sync is on */
4054         if (have_sync && cfg.lambda)
4055                 cfg.theta = (cfg.theta * (1 << 16)) / cfg.lambda;
4056
4057         switch (fll->madera->type) {
4058         case CS47L35:
4059                 switch (fll->madera->rev) {
4060                 case 0:
4061                         gain = cfg.gain;
4062                         break;
4063                 default:
4064                         fll_change |=
4065                                 madera_set_fll_phase_integrator(fll, &cfg,
4066                                                                 have_sync);
4067                         if (!have_sync && cfg.theta == 0)
4068                                 gain = cfg.alt_gain;
4069                         else
4070                                 gain = cfg.gain;
4071                         break;
4072                 }
4073                 break;
4074         case CS47L85:
4075         case WM1840:
4076                 gain = cfg.gain;
4077                 break;
4078         default:
4079                 fll_change |= madera_set_fll_phase_integrator(fll, &cfg,
4080                                                               have_sync);
4081                 if (!have_sync && cfg.theta == 0)
4082                         gain = cfg.alt_gain;
4083                 else
4084                         gain = cfg.gain;
4085                 break;
4086         }
4087
4088         fll_change |= madera_write_fll(madera, fll->base,
4089                                        &cfg, fll->ref_src,
4090                                        false, gain);
4091
4092         /*
4093          * Increase the bandwidth if we're not using a low frequency
4094          * sync source.
4095          */
4096         if (have_sync && fll->sync_freq > 100000)
4097                 regmap_update_bits(madera->regmap,
4098                                    sync_base + MADERA_FLL_SYNCHRONISER_7_OFFS,
4099                                    MADERA_FLL1_SYNC_DFSAT_MASK, 0);
4100         else
4101                 regmap_update_bits(madera->regmap,
4102                                    sync_base + MADERA_FLL_SYNCHRONISER_7_OFFS,
4103                                    MADERA_FLL1_SYNC_DFSAT_MASK,
4104                                    MADERA_FLL1_SYNC_DFSAT);
4105
4106         if (!already_enabled)
4107                 pm_runtime_get_sync(madera->dev);
4108
4109         if (have_sync) {
4110                 madera_set_fll_clks(fll, sync_base, true);
4111                 regmap_update_bits(madera->regmap,
4112                                    sync_base + MADERA_FLL_SYNCHRONISER_1_OFFS,
4113                                    MADERA_FLL1_SYNC_ENA,
4114                                    MADERA_FLL1_SYNC_ENA);
4115         }
4116
4117         madera_set_fll_clks(fll, fll->base, true);
4118         regmap_update_bits(madera->regmap,
4119                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4120                            MADERA_FLL1_ENA, MADERA_FLL1_ENA);
4121
4122         if (already_enabled)
4123                 regmap_update_bits(madera->regmap,
4124                                    fll->base + MADERA_FLL_CONTROL_1_OFFS,
4125                                    MADERA_FLL1_FREERUN, 0);
4126
4127         if (fll_change || !already_enabled)
4128                 madera_wait_for_fll(fll, true);
4129
4130         return 0;
4131
4132 err:
4133          /* In case of error don't leave the FLL running with an old config */
4134         madera_disable_fll(fll);
4135
4136         return ret;
4137 }
4138
4139 static int madera_apply_fll(struct madera_fll *fll)
4140 {
4141         if (fll->fout) {
4142                 return madera_enable_fll(fll);
4143         } else {
4144                 madera_disable_fll(fll);
4145                 return 0;
4146         }
4147 }
4148
4149 int madera_set_fll_syncclk(struct madera_fll *fll, int source,
4150                            unsigned int fref, unsigned int fout)
4151 {
4152         /*
4153          * fout is ignored, since the synchronizer is an optional extra
4154          * constraint on the Fout generated from REFCLK, so the Fout is
4155          * set when configuring REFCLK
4156          */
4157
4158         if (fll->sync_src == source && fll->sync_freq == fref)
4159                 return 0;
4160
4161         fll->sync_src = source;
4162         fll->sync_freq = fref;
4163
4164         return madera_apply_fll(fll);
4165 }
4166 EXPORT_SYMBOL_GPL(madera_set_fll_syncclk);
4167
4168 int madera_set_fll_refclk(struct madera_fll *fll, int source,
4169                           unsigned int fref, unsigned int fout)
4170 {
4171         int ret;
4172
4173         if (fll->ref_src == source &&
4174             fll->ref_freq == fref && fll->fout == fout)
4175                 return 0;
4176
4177         /*
4178          * Changes of fout on an enabled FLL aren't allowed except when
4179          * setting fout==0 to disable the FLL
4180          */
4181         if (fout && fout != fll->fout) {
4182                 ret = madera_is_enabled_fll(fll, fll->base);
4183                 if (ret < 0)
4184                         return ret;
4185
4186                 if (ret) {
4187                         madera_fll_err(fll, "Can't change Fout on active FLL\n");
4188                         return -EBUSY;
4189                 }
4190         }
4191
4192         fll->ref_src = source;
4193         fll->ref_freq = fref;
4194         fll->fout = fout;
4195
4196         return madera_apply_fll(fll);
4197 }
4198 EXPORT_SYMBOL_GPL(madera_set_fll_refclk);
4199
4200 int madera_init_fll(struct madera *madera, int id, int base,
4201                     struct madera_fll *fll)
4202 {
4203         fll->id = id;
4204         fll->base = base;
4205         fll->madera = madera;
4206         fll->ref_src = MADERA_FLL_SRC_NONE;
4207         fll->sync_src = MADERA_FLL_SRC_NONE;
4208
4209         regmap_update_bits(madera->regmap,
4210                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4211                            MADERA_FLL1_FREERUN, 0);
4212
4213         return 0;
4214 }
4215 EXPORT_SYMBOL_GPL(madera_init_fll);
4216
4217 static const struct reg_sequence madera_fll_ao_32K_49M_patch[] = {
4218         { MADERA_FLLAO_CONTROL_2,  0x02EE },
4219         { MADERA_FLLAO_CONTROL_3,  0x0000 },
4220         { MADERA_FLLAO_CONTROL_4,  0x0001 },
4221         { MADERA_FLLAO_CONTROL_5,  0x0002 },
4222         { MADERA_FLLAO_CONTROL_6,  0x8001 },
4223         { MADERA_FLLAO_CONTROL_7,  0x0004 },
4224         { MADERA_FLLAO_CONTROL_8,  0x0077 },
4225         { MADERA_FLLAO_CONTROL_10, 0x06D8 },
4226         { MADERA_FLLAO_CONTROL_11, 0x0085 },
4227         { MADERA_FLLAO_CONTROL_2,  0x82EE },
4228 };
4229
4230 static const struct reg_sequence madera_fll_ao_32K_45M_patch[] = {
4231         { MADERA_FLLAO_CONTROL_2,  0x02B1 },
4232         { MADERA_FLLAO_CONTROL_3,  0x0001 },
4233         { MADERA_FLLAO_CONTROL_4,  0x0010 },
4234         { MADERA_FLLAO_CONTROL_5,  0x0002 },
4235         { MADERA_FLLAO_CONTROL_6,  0x8001 },
4236         { MADERA_FLLAO_CONTROL_7,  0x0004 },
4237         { MADERA_FLLAO_CONTROL_8,  0x0077 },
4238         { MADERA_FLLAO_CONTROL_10, 0x06D8 },
4239         { MADERA_FLLAO_CONTROL_11, 0x0005 },
4240         { MADERA_FLLAO_CONTROL_2,  0x82B1 },
4241 };
4242
4243 struct madera_fllao_patch {
4244         unsigned int fin;
4245         unsigned int fout;
4246         const struct reg_sequence *patch;
4247         unsigned int patch_size;
4248 };
4249
4250 static const struct madera_fllao_patch madera_fllao_settings[] = {
4251         {
4252                 .fin = 32768,
4253                 .fout = 49152000,
4254                 .patch = madera_fll_ao_32K_49M_patch,
4255                 .patch_size = ARRAY_SIZE(madera_fll_ao_32K_49M_patch),
4256
4257         },
4258         {
4259                 .fin = 32768,
4260                 .fout = 45158400,
4261                 .patch = madera_fll_ao_32K_45M_patch,
4262                 .patch_size = ARRAY_SIZE(madera_fll_ao_32K_45M_patch),
4263         },
4264 };
4265
4266 static int madera_enable_fll_ao(struct madera_fll *fll,
4267                                 const struct reg_sequence *patch,
4268                                 unsigned int patch_size)
4269 {
4270         struct madera *madera = fll->madera;
4271         int already_enabled = madera_is_enabled_fll(fll, fll->base);
4272         unsigned int val;
4273         int i;
4274
4275         if (already_enabled < 0)
4276                 return already_enabled;
4277
4278         if (!already_enabled)
4279                 pm_runtime_get_sync(madera->dev);
4280
4281         madera_fll_dbg(fll, "Enabling FLL_AO, initially %s\n",
4282                        already_enabled ? "enabled" : "disabled");
4283
4284         /* FLL_AO_HOLD must be set before configuring any registers */
4285         regmap_update_bits(fll->madera->regmap,
4286                            fll->base + MADERA_FLLAO_CONTROL_1_OFFS,
4287                            MADERA_FLL_AO_HOLD, MADERA_FLL_AO_HOLD);
4288
4289         if (already_enabled)
4290                 madera_set_fllao_clks(fll, fll->base, false);
4291
4292         for (i = 0; i < patch_size; i++) {
4293                 val = patch[i].def;
4294
4295                 /* modify the patch to apply fll->ref_src as input clock */
4296                 if (patch[i].reg == MADERA_FLLAO_CONTROL_6) {
4297                         val &= ~MADERA_FLL_AO_REFCLK_SRC_MASK;
4298                         val |= (fll->ref_src << MADERA_FLL_AO_REFCLK_SRC_SHIFT)
4299                                 & MADERA_FLL_AO_REFCLK_SRC_MASK;
4300                 }
4301
4302                 regmap_write(madera->regmap, patch[i].reg, val);
4303         }
4304
4305         madera_set_fllao_clks(fll, fll->base, true);
4306
4307         regmap_update_bits(madera->regmap,
4308                            fll->base + MADERA_FLLAO_CONTROL_1_OFFS,
4309                            MADERA_FLL_AO_ENA, MADERA_FLL_AO_ENA);
4310
4311         /* Release the hold so that fll_ao locks to external frequency */
4312         regmap_update_bits(madera->regmap,
4313                            fll->base + MADERA_FLLAO_CONTROL_1_OFFS,
4314                            MADERA_FLL_AO_HOLD, 0);
4315
4316         if (!already_enabled)
4317                 madera_wait_for_fll(fll, true);
4318
4319         return 0;
4320 }
4321
4322 static int madera_disable_fll_ao(struct madera_fll *fll)
4323 {
4324         struct madera *madera = fll->madera;
4325         bool change;
4326
4327         madera_fll_dbg(fll, "Disabling FLL_AO\n");
4328
4329         regmap_update_bits(madera->regmap,
4330                            fll->base + MADERA_FLLAO_CONTROL_1_OFFS,
4331                            MADERA_FLL_AO_HOLD, MADERA_FLL_AO_HOLD);
4332         regmap_update_bits_check(madera->regmap,
4333                                  fll->base + MADERA_FLLAO_CONTROL_1_OFFS,
4334                                  MADERA_FLL_AO_ENA, 0, &change);
4335
4336         madera_wait_for_fll(fll, false);
4337
4338         /*
4339          * ctrl_up gates the writes to all fll_ao register, setting it to 0
4340          * here ensures that after a runtime suspend/resume cycle when one
4341          * enables the fllao then ctrl_up is the last bit that is configured
4342          * by the fllao enable code rather than the cache sync operation which
4343          * would have updated it much earlier before writing out all fllao
4344          * registers
4345          */
4346         regmap_update_bits(madera->regmap,
4347                            fll->base + MADERA_FLLAO_CONTROL_2_OFFS,
4348                            MADERA_FLL_AO_CTRL_UPD_MASK, 0);
4349
4350         if (change) {
4351                 madera_set_fllao_clks(fll, fll->base, false);
4352                 pm_runtime_put_autosuspend(madera->dev);
4353         }
4354
4355         return 0;
4356 }
4357
4358 int madera_set_fll_ao_refclk(struct madera_fll *fll, int source,
4359                              unsigned int fin, unsigned int fout)
4360 {
4361         int ret = 0;
4362         const struct reg_sequence *patch = NULL;
4363         int patch_size = 0;
4364         unsigned int i;
4365
4366         if (fll->ref_src == source &&
4367             fll->ref_freq == fin && fll->fout == fout)
4368                 return 0;
4369
4370         madera_fll_dbg(fll, "Change FLL_AO refclk to fin=%u fout=%u source=%d\n",
4371                        fin, fout, source);
4372
4373         if (fout && (fll->ref_freq != fin || fll->fout != fout)) {
4374                 for (i = 0; i < ARRAY_SIZE(madera_fllao_settings); i++) {
4375                         if (madera_fllao_settings[i].fin == fin &&
4376                             madera_fllao_settings[i].fout == fout)
4377                                 break;
4378                 }
4379
4380                 if (i == ARRAY_SIZE(madera_fllao_settings)) {
4381                         madera_fll_err(fll,
4382                                        "No matching configuration for FLL_AO\n");
4383                         return -EINVAL;
4384                 }
4385
4386                 patch = madera_fllao_settings[i].patch;
4387                 patch_size = madera_fllao_settings[i].patch_size;
4388         }
4389
4390         fll->ref_src = source;
4391         fll->ref_freq = fin;
4392         fll->fout = fout;
4393
4394         if (fout)
4395                 ret = madera_enable_fll_ao(fll, patch, patch_size);
4396         else
4397                 madera_disable_fll_ao(fll);
4398
4399         return ret;
4400 }
4401 EXPORT_SYMBOL_GPL(madera_set_fll_ao_refclk);
4402
4403 static int madera_fllhj_disable(struct madera_fll *fll)
4404 {
4405         struct madera *madera = fll->madera;
4406         bool change;
4407
4408         madera_fll_dbg(fll, "Disabling FLL\n");
4409
4410         /* Disable lockdet, but don't set ctrl_upd update but.  This allows the
4411          * lock status bit to clear as normal, but should the FLL be enabled
4412          * again due to a control clock being required, the lock won't re-assert
4413          * as the FLL config registers are automatically applied when the FLL
4414          * enables.
4415          */
4416         regmap_update_bits(madera->regmap,
4417                            fll->base + MADERA_FLL_CONTROL_11_OFFS,
4418                            MADERA_FLL1_LOCKDET_MASK, 0);
4419         regmap_update_bits(madera->regmap,
4420                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4421                            MADERA_FLL1_HOLD_MASK, MADERA_FLL1_HOLD_MASK);
4422         regmap_update_bits_check(madera->regmap,
4423                                  fll->base + MADERA_FLL_CONTROL_1_OFFS,
4424                                  MADERA_FLL1_ENA_MASK, 0, &change);
4425
4426         madera_wait_for_fll(fll, false);
4427
4428         /* ctrl_up gates the writes to all the fll's registers, setting it to 0
4429          * here ensures that after a runtime suspend/resume cycle when one
4430          * enables the fll then ctrl_up is the last bit that is configured
4431          * by the fll enable code rather than the cache sync operation which
4432          * would have updated it much earlier before writing out all fll
4433          * registers
4434          */
4435         regmap_update_bits(madera->regmap,
4436                            fll->base + MADERA_FLL_CONTROL_2_OFFS,
4437                            MADERA_FLL1_CTRL_UPD_MASK, 0);
4438
4439         if (change) {
4440                 madera_set_fllhj_clks(fll, fll->base, false);
4441                 pm_runtime_put_autosuspend(madera->dev);
4442         }
4443
4444         return 0;
4445 }
4446
4447 static int madera_fllhj_apply(struct madera_fll *fll, int fin)
4448 {
4449         struct madera *madera = fll->madera;
4450         int refdiv, fref, fout, lockdet_thr, fbdiv, hp, fast_clk, fllgcd;
4451         bool frac = false;
4452         unsigned int fll_n, min_n, max_n, ratio, theta, lambda;
4453         unsigned int gains, val, num;
4454
4455         madera_fll_dbg(fll, "fin=%d, fout=%d\n", fin, fll->fout);
4456
4457         for (refdiv = 0; refdiv < 4; refdiv++)
4458                 if ((fin / (1 << refdiv)) <= MADERA_FLLHJ_MAX_THRESH)
4459                         break;
4460
4461         fref = fin / (1 << refdiv);
4462
4463         /* Use simple heuristic approach to find a configuration that
4464          * should work for most input clocks.
4465          */
4466         fast_clk = 0;
4467         fout = fll->fout;
4468         frac = fout % fref;
4469
4470         if (fref < MADERA_FLLHJ_LOW_THRESH) {
4471                 lockdet_thr = 2;
4472                 gains = MADERA_FLLHJ_LOW_GAINS;
4473                 if (frac)
4474                         fbdiv = 256;
4475                 else
4476                         fbdiv = 4;
4477         } else if (fref < MADERA_FLLHJ_MID_THRESH) {
4478                 lockdet_thr = 8;
4479                 gains = MADERA_FLLHJ_MID_GAINS;
4480                 fbdiv = 1;
4481         } else {
4482                 lockdet_thr = 8;
4483                 gains = MADERA_FLLHJ_HIGH_GAINS;
4484                 fbdiv = 1;
4485                 /* For high speed input clocks, enable 300MHz fast oscillator
4486                  * when we're in fractional divider mode.
4487                  */
4488                 if (frac) {
4489                         fast_clk = 0x3;
4490                         fout = fll->fout * 6;
4491                 }
4492         }
4493         /* Use high performance mode for fractional configurations. */
4494         if (frac) {
4495                 hp = 0x3;
4496                 min_n = MADERA_FLLHJ_FRAC_MIN_N;
4497                 max_n = MADERA_FLLHJ_FRAC_MAX_N;
4498         } else {
4499                 hp = 0x0;
4500                 min_n = MADERA_FLLHJ_INT_MIN_N;
4501                 max_n = MADERA_FLLHJ_INT_MAX_N;
4502         }
4503
4504         ratio = fout / fref;
4505
4506         madera_fll_dbg(fll, "refdiv=%d, fref=%d, frac:%d\n",
4507                        refdiv, fref, frac);
4508
4509         while (ratio / fbdiv < min_n) {
4510                 fbdiv /= 2;
4511                 if (fbdiv < 1) {
4512                         madera_fll_err(fll, "FBDIV (%d) must be >= 1\n", fbdiv);
4513                         return -EINVAL;
4514                 }
4515         }
4516         while (frac && (ratio / fbdiv > max_n)) {
4517                 fbdiv *= 2;
4518                 if (fbdiv >= 1024) {
4519                         madera_fll_err(fll, "FBDIV (%u) >= 1024\n", fbdiv);
4520                         return -EINVAL;
4521                 }
4522         }
4523
4524         madera_fll_dbg(fll, "lockdet=%d, hp=0x%x, fbdiv:%d\n",
4525                        lockdet_thr, hp, fbdiv);
4526
4527         /* Calculate N.K values */
4528         fllgcd = gcd(fout, fbdiv * fref);
4529         num = fout / fllgcd;
4530         lambda = (fref * fbdiv) / fllgcd;
4531         fll_n = num / lambda;
4532         theta = num % lambda;
4533
4534         madera_fll_dbg(fll, "fll_n=%d, gcd=%d, theta=%d, lambda=%d\n",
4535                        fll_n, fllgcd, theta, lambda);
4536
4537         /* Some sanity checks before any registers are written. */
4538         if (fll_n < min_n || fll_n > max_n) {
4539                 madera_fll_err(fll, "N not in valid %s mode range %d-%d: %d\n",
4540                                frac ? "fractional" : "integer", min_n, max_n,
4541                                fll_n);
4542                 return -EINVAL;
4543         }
4544         if (fbdiv < 1 || (frac && fbdiv >= 1024) || (!frac && fbdiv >= 256)) {
4545                 madera_fll_err(fll, "Invalid fbdiv for %s mode (%u)\n",
4546                                frac ? "fractional" : "integer", fbdiv);
4547                 return -EINVAL;
4548         }
4549
4550         /* clear the ctrl_upd bit to guarantee we write to it later. */
4551         regmap_write(madera->regmap,
4552                      fll->base + MADERA_FLL_CONTROL_2_OFFS,
4553                      fll_n << MADERA_FLL1_N_SHIFT);
4554         regmap_update_bits(madera->regmap,
4555                            fll->base + MADERA_FLL_CONTROL_3_OFFS,
4556                            MADERA_FLL1_THETA_MASK,
4557                            theta << MADERA_FLL1_THETA_SHIFT);
4558         regmap_update_bits(madera->regmap,
4559                            fll->base + MADERA_FLL_CONTROL_4_OFFS,
4560                            MADERA_FLL1_LAMBDA_MASK,
4561                            lambda << MADERA_FLL1_LAMBDA_SHIFT);
4562         regmap_update_bits(madera->regmap,
4563                            fll->base + MADERA_FLL_CONTROL_5_OFFS,
4564                            MADERA_FLL1_FB_DIV_MASK,
4565                            fbdiv << MADERA_FLL1_FB_DIV_SHIFT);
4566         regmap_update_bits(madera->regmap,
4567                            fll->base + MADERA_FLL_CONTROL_6_OFFS,
4568                            MADERA_FLL1_REFCLK_DIV_MASK,
4569                            refdiv << MADERA_FLL1_REFCLK_DIV_SHIFT);
4570         regmap_update_bits(madera->regmap,
4571                            fll->base + MADERA_FLL_GAIN_OFFS,
4572                            0xffff,
4573                            gains);
4574         val = hp << MADERA_FLL1_HP_SHIFT;
4575         val |= 1 << MADERA_FLL1_PHASEDET_ENA_SHIFT;
4576         regmap_update_bits(madera->regmap,
4577                            fll->base + MADERA_FLL_CONTROL_10_OFFS,
4578                            MADERA_FLL1_HP_MASK | MADERA_FLL1_PHASEDET_ENA_MASK,
4579                            val);
4580         regmap_update_bits(madera->regmap,
4581                            fll->base + MADERA_FLL_CONTROL_11_OFFS,
4582                            MADERA_FLL1_LOCKDET_THR_MASK,
4583                            lockdet_thr << MADERA_FLL1_LOCKDET_THR_SHIFT);
4584         regmap_update_bits(madera->regmap,
4585                            fll->base + MADERA_FLL1_DIGITAL_TEST_1_OFFS,
4586                            MADERA_FLL1_SYNC_EFS_ENA_MASK |
4587                            MADERA_FLL1_CLK_VCO_FAST_SRC_MASK,
4588                            fast_clk);
4589
4590         return 0;
4591 }
4592
4593 static int madera_fllhj_enable(struct madera_fll *fll)
4594 {
4595         struct madera *madera = fll->madera;
4596         int already_enabled = madera_is_enabled_fll(fll, fll->base);
4597         int ret;
4598
4599         if (already_enabled < 0)
4600                 return already_enabled;
4601
4602         if (!already_enabled)
4603                 pm_runtime_get_sync(madera->dev);
4604
4605         madera_fll_dbg(fll, "Enabling FLL, initially %s\n",
4606                        already_enabled ? "enabled" : "disabled");
4607
4608         /* FLLn_HOLD must be set before configuring any registers */
4609         regmap_update_bits(fll->madera->regmap,
4610                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4611                            MADERA_FLL1_HOLD_MASK,
4612                            MADERA_FLL1_HOLD_MASK);
4613
4614         if (already_enabled)
4615                 madera_set_fllhj_clks(fll, fll->base, false);
4616
4617         /* Apply refclk */
4618         ret = madera_fllhj_apply(fll, fll->ref_freq);
4619         if (ret) {
4620                 madera_fll_err(fll, "Failed to set FLL: %d\n", ret);
4621                 goto out;
4622         }
4623         regmap_update_bits(madera->regmap,
4624                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4625                            CS47L92_FLL1_REFCLK_SRC_MASK,
4626                            fll->ref_src << CS47L92_FLL1_REFCLK_SRC_SHIFT);
4627
4628         madera_set_fllhj_clks(fll, fll->base, true);
4629
4630         regmap_update_bits(madera->regmap,
4631                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4632                            MADERA_FLL1_ENA_MASK,
4633                            MADERA_FLL1_ENA_MASK);
4634
4635 out:
4636         regmap_update_bits(madera->regmap,
4637                            fll->base + MADERA_FLL_CONTROL_11_OFFS,
4638                            MADERA_FLL1_LOCKDET_MASK,
4639                            MADERA_FLL1_LOCKDET_MASK);
4640
4641         regmap_update_bits(madera->regmap,
4642                            fll->base + MADERA_FLL_CONTROL_2_OFFS,
4643                            MADERA_FLL1_CTRL_UPD_MASK,
4644                            MADERA_FLL1_CTRL_UPD_MASK);
4645
4646         /* Release the hold so that flln locks to external frequency */
4647         regmap_update_bits(madera->regmap,
4648                            fll->base + MADERA_FLL_CONTROL_1_OFFS,
4649                            MADERA_FLL1_HOLD_MASK,
4650                            0);
4651
4652         if (!already_enabled)
4653                 madera_wait_for_fll(fll, true);
4654
4655         return 0;
4656 }
4657
4658 static int madera_fllhj_validate(struct madera_fll *fll,
4659                                  unsigned int ref_in,
4660                                  unsigned int fout)
4661 {
4662         if (fout && !ref_in) {
4663                 madera_fll_err(fll, "fllout set without valid input clk\n");
4664                 return -EINVAL;
4665         }
4666
4667         if (fll->fout && fout != fll->fout) {
4668                 madera_fll_err(fll, "Can't change output on active FLL\n");
4669                 return -EINVAL;
4670         }
4671
4672         if (ref_in / MADERA_FLL_MAX_REFDIV > MADERA_FLLHJ_MAX_THRESH) {
4673                 madera_fll_err(fll, "Can't scale %dMHz to <=13MHz\n", ref_in);
4674                 return -EINVAL;
4675         }
4676
4677         return 0;
4678 }
4679
4680 int madera_fllhj_set_refclk(struct madera_fll *fll, int source,
4681                             unsigned int fin, unsigned int fout)
4682 {
4683         int ret = 0;
4684
4685         /* To remain consistent with previous FLLs, we expect fout to be
4686          * provided in the form of the required sysclk rate, which is
4687          * 2x the calculated fll out.
4688          */
4689         if (fout)
4690                 fout /= 2;
4691
4692         if (fll->ref_src == source && fll->ref_freq == fin &&
4693             fll->fout == fout)
4694                 return 0;
4695
4696         if (fin && fout && madera_fllhj_validate(fll, fin, fout))
4697                 return -EINVAL;
4698
4699         fll->ref_src = source;
4700         fll->ref_freq = fin;
4701         fll->fout = fout;
4702
4703         if (fout)
4704                 ret = madera_fllhj_enable(fll);
4705         else
4706                 madera_fllhj_disable(fll);
4707
4708         return ret;
4709 }
4710 EXPORT_SYMBOL_GPL(madera_fllhj_set_refclk);
4711
4712 /**
4713  * madera_set_output_mode - Set the mode of the specified output
4714  *
4715  * @component: Device to configure
4716  * @output: Output number
4717  * @differential: True to set the output to differential mode
4718  *
4719  * Some systems use external analogue switches to connect more
4720  * analogue devices to the CODEC than are supported by the device.  In
4721  * some systems this requires changing the switched output from single
4722  * ended to differential mode dynamically at runtime, an operation
4723  * supported using this function.
4724  *
4725  * Most systems have a single static configuration and should use
4726  * platform data instead.
4727  */
4728 int madera_set_output_mode(struct snd_soc_component *component, int output,
4729                            bool differential)
4730 {
4731         unsigned int reg, val;
4732         int ret;
4733
4734         if (output < 1 || output > MADERA_MAX_OUTPUT)
4735                 return -EINVAL;
4736
4737         reg = MADERA_OUTPUT_PATH_CONFIG_1L + (output - 1) * 8;
4738
4739         if (differential)
4740                 val = MADERA_OUT1_MONO;
4741         else
4742                 val = 0;
4743
4744         ret = snd_soc_component_update_bits(component, reg, MADERA_OUT1_MONO,
4745                                             val);
4746         if (ret < 0)
4747                 return ret;
4748         else
4749                 return 0;
4750 }
4751 EXPORT_SYMBOL_GPL(madera_set_output_mode);
4752
4753 static bool madera_eq_filter_unstable(bool mode, __be16 _a, __be16 _b)
4754 {
4755         s16 a = be16_to_cpu(_a);
4756         s16 b = be16_to_cpu(_b);
4757
4758         if (!mode) {
4759                 return abs(a) >= 4096;
4760         } else {
4761                 if (abs(b) >= 4096)
4762                         return true;
4763
4764                 return (abs((a << 16) / (4096 - b)) >= 4096 << 4);
4765         }
4766 }
4767
4768 int madera_eq_coeff_put(struct snd_kcontrol *kcontrol,
4769                         struct snd_ctl_elem_value *ucontrol)
4770 {
4771         struct snd_soc_component *component =
4772                 snd_soc_kcontrol_component(kcontrol);
4773         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
4774         struct madera *madera = priv->madera;
4775         struct soc_bytes *params = (void *)kcontrol->private_value;
4776         unsigned int val;
4777         __be16 *data;
4778         int len;
4779         int ret;
4780
4781         len = params->num_regs * regmap_get_val_bytes(madera->regmap);
4782
4783         data = kmemdup(ucontrol->value.bytes.data, len, GFP_KERNEL | GFP_DMA);
4784         if (!data)
4785                 return -ENOMEM;
4786
4787         data[0] &= cpu_to_be16(MADERA_EQ1_B1_MODE);
4788
4789         if (madera_eq_filter_unstable(!!data[0], data[1], data[2]) ||
4790             madera_eq_filter_unstable(true, data[4], data[5]) ||
4791             madera_eq_filter_unstable(true, data[8], data[9]) ||
4792             madera_eq_filter_unstable(true, data[12], data[13]) ||
4793             madera_eq_filter_unstable(false, data[16], data[17])) {
4794                 dev_err(madera->dev, "Rejecting unstable EQ coefficients\n");
4795                 ret = -EINVAL;
4796                 goto out;
4797         }
4798
4799         ret = regmap_read(madera->regmap, params->base, &val);
4800         if (ret != 0)
4801                 goto out;
4802
4803         val &= ~MADERA_EQ1_B1_MODE;
4804         data[0] |= cpu_to_be16(val);
4805
4806         ret = regmap_raw_write(madera->regmap, params->base, data, len);
4807
4808 out:
4809         kfree(data);
4810
4811         return ret;
4812 }
4813 EXPORT_SYMBOL_GPL(madera_eq_coeff_put);
4814
4815 int madera_lhpf_coeff_put(struct snd_kcontrol *kcontrol,
4816                           struct snd_ctl_elem_value *ucontrol)
4817 {
4818         struct snd_soc_component *component =
4819                 snd_soc_kcontrol_component(kcontrol);
4820         struct madera_priv *priv = snd_soc_component_get_drvdata(component);
4821         struct madera *madera = priv->madera;
4822         __be16 *data = (__be16 *)ucontrol->value.bytes.data;
4823         s16 val = be16_to_cpu(*data);
4824
4825         if (abs(val) >= 4096) {
4826                 dev_err(madera->dev, "Rejecting unstable LHPF coefficients\n");
4827                 return -EINVAL;
4828         }
4829
4830         return snd_soc_bytes_put(kcontrol, ucontrol);
4831 }
4832 EXPORT_SYMBOL_GPL(madera_lhpf_coeff_put);
4833
4834 MODULE_SOFTDEP("pre: madera");
4835 MODULE_DESCRIPTION("ASoC Cirrus Logic Madera codec support");
4836 MODULE_AUTHOR("Charles Keepax <ckeepax@opensource.cirrus.com>");
4837 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
4838 MODULE_LICENSE("GPL v2");