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