sound/soc/codecs/adau17x1.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Common code for ADAU1X61 and ADAU1X81 codecs
   4  *
   5  * Copyright 2011-2014 Analog Devices Inc.
   6  * Author: Lars-Peter Clausen <lars@metafoo.de>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/clk.h>
  12 #include <linux/delay.h>
  13 #include <linux/slab.h>
  14 #include <sound/core.h>
  15 #include <sound/pcm.h>
  16 #include <sound/pcm_params.h>
  17 #include <sound/soc.h>
  18 #include <sound/tlv.h>
  19 #include <linux/i2c.h>
  20 #include <linux/spi/spi.h>
  21 #include <linux/regmap.h>
  22 #include <asm/unaligned.h>
  23
  24 #include "sigmadsp.h"
  25 #include "adau17x1.h"
  26 #include "adau-utils.h"
  27
  28 #define ADAU17X1_SAFELOAD_TARGET_ADDRESS 0x0006
  29 #define ADAU17X1_SAFELOAD_TRIGGER 0x0007
  30 #define ADAU17X1_SAFELOAD_DATA 0x0001
  31 #define ADAU17X1_SAFELOAD_DATA_SIZE 20
  32 #define ADAU17X1_WORD_SIZE 4
  33
  34 static const char * const adau17x1_capture_mixer_boost_text[] = {
  35         "Normal operation", "Boost Level 1", "Boost Level 2", "Boost Level 3",
  36 };
  37
  38 static SOC_ENUM_SINGLE_DECL(adau17x1_capture_boost_enum,
  39         ADAU17X1_REC_POWER_MGMT, 5, adau17x1_capture_mixer_boost_text);
  40
  41 static const char * const adau17x1_mic_bias_mode_text[] = {
  42         "Normal operation", "High performance",
  43 };
  44
  45 static SOC_ENUM_SINGLE_DECL(adau17x1_mic_bias_mode_enum,
  46         ADAU17X1_MICBIAS, 3, adau17x1_mic_bias_mode_text);
  47
  48 static const DECLARE_TLV_DB_MINMAX(adau17x1_digital_tlv, -9563, 0);
  49
  50 static const struct snd_kcontrol_new adau17x1_controls[] = {
  51         SOC_DOUBLE_R_TLV("Digital Capture Volume",
  52                 ADAU17X1_LEFT_INPUT_DIGITAL_VOL,
  53                 ADAU17X1_RIGHT_INPUT_DIGITAL_VOL,
  54                 0, 0xff, 1, adau17x1_digital_tlv),
  55         SOC_DOUBLE_R_TLV("Digital Playback Volume", ADAU17X1_DAC_CONTROL1,
  56                 ADAU17X1_DAC_CONTROL2, 0, 0xff, 1, adau17x1_digital_tlv),
  57
  58         SOC_SINGLE("ADC High Pass Filter Switch", ADAU17X1_ADC_CONTROL,
  59                 5, 1, 0),
  60         SOC_SINGLE("Playback De-emphasis Switch", ADAU17X1_DAC_CONTROL0,
  61                 2, 1, 0),
  62
  63         SOC_ENUM("Capture Boost", adau17x1_capture_boost_enum),
  64
  65         SOC_ENUM("Mic Bias Mode", adau17x1_mic_bias_mode_enum),
  66 };
  67
  68 static int adau17x1_setup_firmware(struct snd_soc_component *component,
  69         unsigned int rate);
  70
  71 static int adau17x1_pll_event(struct snd_soc_dapm_widget *w,
  72         struct snd_kcontrol *kcontrol, int event)
  73 {
  74         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
  75         struct adau *adau = snd_soc_component_get_drvdata(component);
  76
  77         if (SND_SOC_DAPM_EVENT_ON(event)) {
  78                 adau->pll_regs[5] = 1;
  79         } else {
  80                 adau->pll_regs[5] = 0;
  81                 /* Bypass the PLL when disabled, otherwise registers will become
  82                  * inaccessible. */
  83                 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,
  84                         ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL, 0);
  85         }
  86
  87         /* The PLL register is 6 bytes long and can only be written at once. */
  88         regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL,
  89                         adau->pll_regs, ARRAY_SIZE(adau->pll_regs));
  90
  91         if (SND_SOC_DAPM_EVENT_ON(event)) {
  92                 mdelay(5);
  93                 regmap_update_bits(adau->regmap, ADAU17X1_CLOCK_CONTROL,
  94                         ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL,
  95                         ADAU17X1_CLOCK_CONTROL_CORECLK_SRC_PLL);
  96         }
  97
  98         return 0;
  99 }
 100
 101 static int adau17x1_adc_fixup(struct snd_soc_dapm_widget *w,
 102         struct snd_kcontrol *kcontrol, int event)
 103 {
 104         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 105         struct adau *adau = snd_soc_component_get_drvdata(component);
 106
 107         /*
 108          * If we are capturing, toggle the ADOSR bit in Converter Control 0 to
 109          * avoid losing SNR (workaround from ADI). This must be done after
 110          * the ADC(s) have been enabled. According to the data sheet, it is
 111          * normally illegal to set this bit when the sampling rate is 96 kHz,
 112          * but according to ADI it is acceptable for this workaround.
 113          */
 114         regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
 115                 ADAU17X1_CONVERTER0_ADOSR, ADAU17X1_CONVERTER0_ADOSR);
 116         regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
 117                 ADAU17X1_CONVERTER0_ADOSR, 0);
 118
 119         return 0;
 120 }
 121
 122 static const char * const adau17x1_mono_stereo_text[] = {
 123         "Stereo",
 124         "Mono Left Channel (L+R)",
 125         "Mono Right Channel (L+R)",
 126         "Mono (L+R)",
 127 };
 128
 129 static SOC_ENUM_SINGLE_DECL(adau17x1_dac_mode_enum,
 130         ADAU17X1_DAC_CONTROL0, 6, adau17x1_mono_stereo_text);
 131
 132 static const struct snd_kcontrol_new adau17x1_dac_mode_mux =
 133         SOC_DAPM_ENUM("DAC Mono-Stereo-Mode", adau17x1_dac_mode_enum);
 134
 135 static const struct snd_soc_dapm_widget adau17x1_dapm_widgets[] = {
 136         SND_SOC_DAPM_SUPPLY_S("PLL", 3, SND_SOC_NOPM, 0, 0, adau17x1_pll_event,
 137                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
 138
 139         SND_SOC_DAPM_SUPPLY("AIFCLK", SND_SOC_NOPM, 0, 0, NULL, 0),
 140
 141         SND_SOC_DAPM_SUPPLY("MICBIAS", ADAU17X1_MICBIAS, 0, 0, NULL, 0),
 142
 143         SND_SOC_DAPM_SUPPLY("Left Playback Enable", ADAU17X1_PLAY_POWER_MGMT,
 144                 0, 0, NULL, 0),
 145         SND_SOC_DAPM_SUPPLY("Right Playback Enable", ADAU17X1_PLAY_POWER_MGMT,
 146                 1, 0, NULL, 0),
 147
 148         SND_SOC_DAPM_MUX("Left DAC Mode Mux", SND_SOC_NOPM, 0, 0,
 149                 &adau17x1_dac_mode_mux),
 150         SND_SOC_DAPM_MUX("Right DAC Mode Mux", SND_SOC_NOPM, 0, 0,
 151                 &adau17x1_dac_mode_mux),
 152
 153         SND_SOC_DAPM_ADC_E("Left Decimator", NULL, ADAU17X1_ADC_CONTROL, 0, 0,
 154                            adau17x1_adc_fixup, SND_SOC_DAPM_POST_PMU),
 155         SND_SOC_DAPM_ADC("Right Decimator", NULL, ADAU17X1_ADC_CONTROL, 1, 0),
 156         SND_SOC_DAPM_DAC("Left DAC", NULL, ADAU17X1_DAC_CONTROL0, 0, 0),
 157         SND_SOC_DAPM_DAC("Right DAC", NULL, ADAU17X1_DAC_CONTROL0, 1, 0),
 158 };
 159
 160 static const struct snd_soc_dapm_route adau17x1_dapm_routes[] = {
 161         { "Left Decimator", NULL, "SYSCLK" },
 162         { "Right Decimator", NULL, "SYSCLK" },
 163         { "Left DAC", NULL, "SYSCLK" },
 164         { "Right DAC", NULL, "SYSCLK" },
 165         { "Capture", NULL, "SYSCLK" },
 166         { "Playback", NULL, "SYSCLK" },
 167
 168         { "Left DAC", NULL, "Left DAC Mode Mux" },
 169         { "Right DAC", NULL, "Right DAC Mode Mux" },
 170
 171         { "Capture", NULL, "AIFCLK" },
 172         { "Playback", NULL, "AIFCLK" },
 173 };
 174
 175 static const struct snd_soc_dapm_route adau17x1_dapm_pll_route = {
 176         "SYSCLK", NULL, "PLL",
 177 };
 178
 179 /*
 180  * The MUX register for the Capture and Playback MUXs selects either DSP as
 181  * source/destination or one of the TDM slots. The TDM slot is selected via
 182  * snd_soc_dai_set_tdm_slot(), so we only expose whether to go to the DSP or
 183  * directly to the DAI interface with this control.
 184  */
 185 static int adau17x1_dsp_mux_enum_put(struct snd_kcontrol *kcontrol,
 186         struct snd_ctl_elem_value *ucontrol)
 187 {
 188         struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
 189         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 190         struct adau *adau = snd_soc_component_get_drvdata(component);
 191         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 192         struct snd_soc_dapm_update update = {};
 193         unsigned int stream = e->shift_l;
 194         unsigned int val, change;
 195         int reg;
 196
 197         if (ucontrol->value.enumerated.item[0] >= e->items)
 198                 return -EINVAL;
 199
 200         switch (ucontrol->value.enumerated.item[0]) {
 201         case 0:
 202                 val = 0;
 203                 adau->dsp_bypass[stream] = false;
 204                 break;
 205         default:
 206                 val = (adau->tdm_slot[stream] * 2) + 1;
 207                 adau->dsp_bypass[stream] = true;
 208                 break;
 209         }
 210
 211         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
 212                 reg = ADAU17X1_SERIAL_INPUT_ROUTE;
 213         else
 214                 reg = ADAU17X1_SERIAL_OUTPUT_ROUTE;
 215
 216         change = snd_soc_component_test_bits(component, reg, 0xff, val);
 217         if (change) {
 218                 update.kcontrol = kcontrol;
 219                 update.mask = 0xff;
 220                 update.reg = reg;
 221                 update.val = val;
 222
 223                 snd_soc_dapm_mux_update_power(dapm, kcontrol,
 224                                 ucontrol->value.enumerated.item[0], e, &update);
 225         }
 226
 227         return change;
 228 }
 229
 230 static int adau17x1_dsp_mux_enum_get(struct snd_kcontrol *kcontrol,
 231         struct snd_ctl_elem_value *ucontrol)
 232 {
 233         struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
 234         struct adau *adau = snd_soc_component_get_drvdata(component);
 235         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 236         unsigned int stream = e->shift_l;
 237         unsigned int reg, val;
 238         int ret;
 239
 240         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
 241                 reg = ADAU17X1_SERIAL_INPUT_ROUTE;
 242         else
 243                 reg = ADAU17X1_SERIAL_OUTPUT_ROUTE;
 244
 245         ret = regmap_read(adau->regmap, reg, &val);
 246         if (ret)
 247                 return ret;
 248
 249         if (val != 0)
 250                 val = 1;
 251         ucontrol->value.enumerated.item[0] = val;
 252
 253         return 0;
 254 }
 255
 256 #define DECLARE_ADAU17X1_DSP_MUX_CTRL(_name, _label, _stream, _text) \
 257         const struct snd_kcontrol_new _name = \
 258                 SOC_DAPM_ENUM_EXT(_label, (const struct soc_enum)\
 259                         SOC_ENUM_SINGLE(SND_SOC_NOPM, _stream, \
 260                                 ARRAY_SIZE(_text), _text), \
 261                         adau17x1_dsp_mux_enum_get, adau17x1_dsp_mux_enum_put)
 262
 263 static const char * const adau17x1_dac_mux_text[] = {
 264         "DSP",
 265         "AIFIN",
 266 };
 267
 268 static const char * const adau17x1_capture_mux_text[] = {
 269         "DSP",
 270         "Decimator",
 271 };
 272
 273 static DECLARE_ADAU17X1_DSP_MUX_CTRL(adau17x1_dac_mux, "DAC Playback Mux",
 274         SNDRV_PCM_STREAM_PLAYBACK, adau17x1_dac_mux_text);
 275
 276 static DECLARE_ADAU17X1_DSP_MUX_CTRL(adau17x1_capture_mux, "Capture Mux",
 277         SNDRV_PCM_STREAM_CAPTURE, adau17x1_capture_mux_text);
 278
 279 static const struct snd_soc_dapm_widget adau17x1_dsp_dapm_widgets[] = {
 280         SND_SOC_DAPM_PGA("DSP", ADAU17X1_DSP_RUN, 0, 0, NULL, 0),
 281         SND_SOC_DAPM_SIGGEN("DSP Siggen"),
 282
 283         SND_SOC_DAPM_MUX("DAC Playback Mux", SND_SOC_NOPM, 0, 0,
 284                 &adau17x1_dac_mux),
 285         SND_SOC_DAPM_MUX("Capture Mux", SND_SOC_NOPM, 0, 0,
 286                 &adau17x1_capture_mux),
 287 };
 288
 289 static const struct snd_soc_dapm_route adau17x1_dsp_dapm_routes[] = {
 290         { "DAC Playback Mux", "DSP", "DSP" },
 291         { "DAC Playback Mux", "AIFIN", "Playback" },
 292
 293         { "Left DAC Mode Mux", "Stereo", "DAC Playback Mux" },
 294         { "Left DAC Mode Mux", "Mono (L+R)", "DAC Playback Mux" },
 295         { "Left DAC Mode Mux", "Mono Left Channel (L+R)", "DAC Playback Mux" },
 296         { "Right DAC Mode Mux", "Stereo", "DAC Playback Mux" },
 297         { "Right DAC Mode Mux", "Mono (L+R)", "DAC Playback Mux" },
 298         { "Right DAC Mode Mux", "Mono Right Channel (L+R)", "DAC Playback Mux" },
 299
 300         { "Capture Mux", "DSP", "DSP" },
 301         { "Capture Mux", "Decimator", "Left Decimator" },
 302         { "Capture Mux", "Decimator", "Right Decimator" },
 303
 304         { "Capture", NULL, "Capture Mux" },
 305
 306         { "DSP", NULL, "DSP Siggen" },
 307
 308         { "DSP", NULL, "Left Decimator" },
 309         { "DSP", NULL, "Right Decimator" },
 310         { "DSP", NULL, "Playback" },
 311 };
 312
 313 static const struct snd_soc_dapm_route adau17x1_no_dsp_dapm_routes[] = {
 314         { "Left DAC Mode Mux", "Stereo", "Playback" },
 315         { "Left DAC Mode Mux", "Mono (L+R)", "Playback" },
 316         { "Left DAC Mode Mux", "Mono Left Channel (L+R)", "Playback" },
 317         { "Right DAC Mode Mux", "Stereo", "Playback" },
 318         { "Right DAC Mode Mux", "Mono (L+R)", "Playback" },
 319         { "Right DAC Mode Mux", "Mono Right Channel (L+R)", "Playback" },
 320         { "Capture", NULL, "Left Decimator" },
 321         { "Capture", NULL, "Right Decimator" },
 322 };
 323
 324 static bool adau17x1_has_dsp(struct adau *adau)
 325 {
 326         switch (adau->type) {
 327         case ADAU1761:
 328         case ADAU1381:
 329         case ADAU1781:
 330                 return true;
 331         default:
 332                 return false;
 333         }
 334 }
 335
 336 /* Chip has a DSP but we're pretending it doesn't. */
 337 static bool adau17x1_has_disused_dsp(struct adau *adau)
 338 {
 339         switch (adau->type) {
 340         case ADAU1761_AS_1361:
 341                 return true;
 342         default:
 343                 return false;
 344         }
 345 }
 346
 347 static bool adau17x1_has_safeload(struct adau *adau)
 348 {
 349         switch (adau->type) {
 350         case ADAU1761:
 351         case ADAU1781:
 352                 return true;
 353         default:
 354                 return false;
 355         }
 356 }
 357
 358 static int adau17x1_set_dai_pll(struct snd_soc_dai *dai, int pll_id,
 359         int source, unsigned int freq_in, unsigned int freq_out)
 360 {
 361         struct snd_soc_component *component = dai->component;
 362         struct adau *adau = snd_soc_component_get_drvdata(component);
 363         int ret;
 364
 365         if (freq_in < 8000000 || freq_in > 27000000)
 366                 return -EINVAL;
 367
 368         ret = adau_calc_pll_cfg(freq_in, freq_out, adau->pll_regs);
 369         if (ret < 0)
 370                 return ret;
 371
 372         /* The PLL register is 6 bytes long and can only be written at once. */
 373         ret = regmap_raw_write(adau->regmap, ADAU17X1_PLL_CONTROL,
 374                         adau->pll_regs, ARRAY_SIZE(adau->pll_regs));
 375         if (ret)
 376                 return ret;
 377
 378         adau->pll_freq = freq_out;
 379
 380         return 0;
 381 }
 382
 383 static int adau17x1_set_dai_sysclk(struct snd_soc_dai *dai,
 384                 int clk_id, unsigned int freq, int dir)
 385 {
 386         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(dai->component);
 387         struct adau *adau = snd_soc_component_get_drvdata(dai->component);
 388         bool is_pll;
 389         bool was_pll;
 390
 391         switch (clk_id) {
 392         case ADAU17X1_CLK_SRC_MCLK:
 393                 is_pll = false;
 394                 break;
 395         case ADAU17X1_CLK_SRC_PLL_AUTO:
 396                 if (!adau->mclk)
 397                         return -EINVAL;
 398                 fallthrough;
 399         case ADAU17X1_CLK_SRC_PLL:
 400                 is_pll = true;
 401                 break;
 402         default:
 403                 return -EINVAL;
 404         }
 405
 406         switch (adau->clk_src) {
 407         case ADAU17X1_CLK_SRC_MCLK:
 408                 was_pll = false;
 409                 break;
 410         case ADAU17X1_CLK_SRC_PLL:
 411         case ADAU17X1_CLK_SRC_PLL_AUTO:
 412                 was_pll = true;
 413                 break;
 414         default:
 415                 return -EINVAL;
 416         }
 417
 418         adau->sysclk = freq;
 419
 420         if (is_pll != was_pll) {
 421                 if (is_pll) {
 422                         snd_soc_dapm_add_routes(dapm,
 423                                 &adau17x1_dapm_pll_route, 1);
 424                 } else {
 425                         snd_soc_dapm_del_routes(dapm,
 426                                 &adau17x1_dapm_pll_route, 1);
 427                 }
 428         }
 429
 430         adau->clk_src = clk_id;
 431
 432         return 0;
 433 }
 434
 435 static int adau17x1_auto_pll(struct snd_soc_dai *dai,
 436         struct snd_pcm_hw_params *params)
 437 {
 438         struct adau *adau = snd_soc_dai_get_drvdata(dai);
 439         unsigned int pll_rate;
 440
 441         switch (params_rate(params)) {
 442         case 48000:
 443         case 8000:
 444         case 12000:
 445         case 16000:
 446         case 24000:
 447         case 32000:
 448         case 96000:
 449                 pll_rate = 48000 * 1024;
 450                 break;
 451         case 44100:
 452         case 7350:
 453         case 11025:
 454         case 14700:
 455         case 22050:
 456         case 29400:
 457         case 88200:
 458                 pll_rate = 44100 * 1024;
 459                 break;
 460         default:
 461                 return -EINVAL;
 462         }
 463
 464         return adau17x1_set_dai_pll(dai, ADAU17X1_PLL, ADAU17X1_PLL_SRC_MCLK,
 465                 clk_get_rate(adau->mclk), pll_rate);
 466 }
 467
 468 static int adau17x1_hw_params(struct snd_pcm_substream *substream,
 469         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 470 {
 471         struct snd_soc_component *component = dai->component;
 472         struct adau *adau = snd_soc_component_get_drvdata(component);
 473         unsigned int val, div, dsp_div;
 474         unsigned int freq;
 475         int ret;
 476
 477         switch (adau->clk_src) {
 478         case ADAU17X1_CLK_SRC_PLL_AUTO:
 479                 ret = adau17x1_auto_pll(dai, params);
 480                 if (ret)
 481                         return ret;
 482                 fallthrough;
 483         case ADAU17X1_CLK_SRC_PLL:
 484                 freq = adau->pll_freq;
 485                 break;
 486         default:
 487                 freq = adau->sysclk;
 488                 break;
 489         }
 490
 491         if (freq % params_rate(params) != 0)
 492                 return -EINVAL;
 493
 494         switch (freq / params_rate(params)) {
 495         case 1024: /* fs */
 496                 div = 0;
 497                 dsp_div = 1;
 498                 break;
 499         case 6144: /* fs / 6 */
 500                 div = 1;
 501                 dsp_div = 6;
 502                 break;
 503         case 4096: /* fs / 4 */
 504                 div = 2;
 505                 dsp_div = 5;
 506                 break;
 507         case 3072: /* fs / 3 */
 508                 div = 3;
 509                 dsp_div = 4;
 510                 break;
 511         case 2048: /* fs / 2 */
 512                 div = 4;
 513                 dsp_div = 3;
 514                 break;
 515         case 1536: /* fs / 1.5 */
 516                 div = 5;
 517                 dsp_div = 2;
 518                 break;
 519         case 512: /* fs / 0.5 */
 520                 div = 6;
 521                 dsp_div = 0;
 522                 break;
 523         default:
 524                 return -EINVAL;
 525         }
 526
 527         regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
 528                 ADAU17X1_CONVERTER0_CONVSR_MASK, div);
 529
 530         if (adau17x1_has_dsp(adau) || adau17x1_has_disused_dsp(adau))
 531                 regmap_write(adau->regmap, ADAU17X1_SERIAL_SAMPLING_RATE, div);
 532         if (adau17x1_has_dsp(adau))
 533                 regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dsp_div);
 534
 535         if (adau->sigmadsp) {
 536                 ret = adau17x1_setup_firmware(component, params_rate(params));
 537                 if (ret < 0)
 538                         return ret;
 539         }
 540
 541         if (adau->dai_fmt != SND_SOC_DAIFMT_RIGHT_J)
 542                 return 0;
 543
 544         switch (params_width(params)) {
 545         case 16:
 546                 val = ADAU17X1_SERIAL_PORT1_DELAY16;
 547                 break;
 548         case 24:
 549                 val = ADAU17X1_SERIAL_PORT1_DELAY8;
 550                 break;
 551         case 32:
 552                 val = ADAU17X1_SERIAL_PORT1_DELAY0;
 553                 break;
 554         default:
 555                 return -EINVAL;
 556         }
 557
 558         return regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1,
 559                         ADAU17X1_SERIAL_PORT1_DELAY_MASK, val);
 560 }
 561
 562 static int adau17x1_set_dai_fmt(struct snd_soc_dai *dai,
 563                 unsigned int fmt)
 564 {
 565         struct adau *adau = snd_soc_component_get_drvdata(dai->component);
 566         unsigned int ctrl0, ctrl1;
 567         unsigned int ctrl0_mask;
 568         int lrclk_pol;
 569
 570         switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
 571         case SND_SOC_DAIFMT_CBP_CFP:
 572                 ctrl0 = ADAU17X1_SERIAL_PORT0_MASTER;
 573                 adau->master = true;
 574                 break;
 575         case SND_SOC_DAIFMT_CBC_CFC:
 576                 ctrl0 = 0;
 577                 adau->master = false;
 578                 break;
 579         default:
 580                 return -EINVAL;
 581         }
 582
 583         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 584         case SND_SOC_DAIFMT_I2S:
 585                 lrclk_pol = 0;
 586                 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY1;
 587                 break;
 588         case SND_SOC_DAIFMT_LEFT_J:
 589         case SND_SOC_DAIFMT_RIGHT_J:
 590                 lrclk_pol = 1;
 591                 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY0;
 592                 break;
 593         case SND_SOC_DAIFMT_DSP_A:
 594                 lrclk_pol = 1;
 595                 ctrl0 |= ADAU17X1_SERIAL_PORT0_PULSE_MODE;
 596                 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY1;
 597                 break;
 598         case SND_SOC_DAIFMT_DSP_B:
 599                 lrclk_pol = 1;
 600                 ctrl0 |= ADAU17X1_SERIAL_PORT0_PULSE_MODE;
 601                 ctrl1 = ADAU17X1_SERIAL_PORT1_DELAY0;
 602                 break;
 603         default:
 604                 return -EINVAL;
 605         }
 606
 607         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 608         case SND_SOC_DAIFMT_NB_NF:
 609                 break;
 610         case SND_SOC_DAIFMT_IB_NF:
 611                 ctrl0 |= ADAU17X1_SERIAL_PORT0_BCLK_POL;
 612                 break;
 613         case SND_SOC_DAIFMT_NB_IF:
 614                 lrclk_pol = !lrclk_pol;
 615                 break;
 616         case SND_SOC_DAIFMT_IB_IF:
 617                 ctrl0 |= ADAU17X1_SERIAL_PORT0_BCLK_POL;
 618                 lrclk_pol = !lrclk_pol;
 619                 break;
 620         default:
 621                 return -EINVAL;
 622         }
 623
 624         if (lrclk_pol)
 625                 ctrl0 |= ADAU17X1_SERIAL_PORT0_LRCLK_POL;
 626
 627         /* Set the mask to update all relevant bits in ADAU17X1_SERIAL_PORT0 */
 628         ctrl0_mask = ADAU17X1_SERIAL_PORT0_MASTER |
 629                      ADAU17X1_SERIAL_PORT0_LRCLK_POL |
 630                      ADAU17X1_SERIAL_PORT0_BCLK_POL |
 631                      ADAU17X1_SERIAL_PORT0_PULSE_MODE;
 632
 633         regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT0, ctrl0_mask,
 634                            ctrl0);
 635         regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1,
 636                            ADAU17X1_SERIAL_PORT1_DELAY_MASK, ctrl1);
 637
 638         adau->dai_fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
 639
 640         return 0;
 641 }
 642
 643 static int adau17x1_set_dai_tdm_slot(struct snd_soc_dai *dai,
 644         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
 645 {
 646         struct adau *adau = snd_soc_component_get_drvdata(dai->component);
 647         unsigned int ser_ctrl0, ser_ctrl1;
 648         unsigned int conv_ctrl0, conv_ctrl1;
 649
 650         /* I2S mode */
 651         if (slots == 0) {
 652                 slots = 2;
 653                 rx_mask = 3;
 654                 tx_mask = 3;
 655                 slot_width = 32;
 656         }
 657
 658         switch (slots) {
 659         case 2:
 660                 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_STEREO;
 661                 break;
 662         case 4:
 663                 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_TDM4;
 664                 break;
 665         case 8:
 666                 if (adau->type == ADAU1361)
 667                         return -EINVAL;
 668
 669                 ser_ctrl0 = ADAU17X1_SERIAL_PORT0_TDM8;
 670                 break;
 671         default:
 672                 return -EINVAL;
 673         }
 674
 675         switch (slot_width * slots) {
 676         case 32:
 677                 if (adau->type == ADAU1761 || adau->type == ADAU1761_AS_1361)
 678                         return -EINVAL;
 679
 680                 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK32;
 681                 break;
 682         case 64:
 683                 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK64;
 684                 break;
 685         case 48:
 686                 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK48;
 687                 break;
 688         case 128:
 689                 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK128;
 690                 break;
 691         case 256:
 692                 if (adau->type == ADAU1361)
 693                         return -EINVAL;
 694
 695                 ser_ctrl1 = ADAU17X1_SERIAL_PORT1_BCLK256;
 696                 break;
 697         default:
 698                 return -EINVAL;
 699         }
 700
 701         switch (rx_mask) {
 702         case 0x03:
 703                 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(1);
 704                 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 0;
 705                 break;
 706         case 0x0c:
 707                 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(2);
 708                 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 1;
 709                 break;
 710         case 0x30:
 711                 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(3);
 712                 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 2;
 713                 break;
 714         case 0xc0:
 715                 conv_ctrl1 = ADAU17X1_CONVERTER1_ADC_PAIR(4);
 716                 adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] = 3;
 717                 break;
 718         default:
 719                 return -EINVAL;
 720         }
 721
 722         switch (tx_mask) {
 723         case 0x03:
 724                 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(1);
 725                 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 0;
 726                 break;
 727         case 0x0c:
 728                 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(2);
 729                 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 1;
 730                 break;
 731         case 0x30:
 732                 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(3);
 733                 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 2;
 734                 break;
 735         case 0xc0:
 736                 conv_ctrl0 = ADAU17X1_CONVERTER0_DAC_PAIR(4);
 737                 adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] = 3;
 738                 break;
 739         default:
 740                 return -EINVAL;
 741         }
 742
 743         regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER0,
 744                 ADAU17X1_CONVERTER0_DAC_PAIR_MASK, conv_ctrl0);
 745         regmap_update_bits(adau->regmap, ADAU17X1_CONVERTER1,
 746                 ADAU17X1_CONVERTER1_ADC_PAIR_MASK, conv_ctrl1);
 747         regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT0,
 748                 ADAU17X1_SERIAL_PORT0_TDM_MASK, ser_ctrl0);
 749         regmap_update_bits(adau->regmap, ADAU17X1_SERIAL_PORT1,
 750                 ADAU17X1_SERIAL_PORT1_BCLK_MASK, ser_ctrl1);
 751
 752         if (!adau17x1_has_dsp(adau) && !adau17x1_has_disused_dsp(adau))
 753                 return 0;
 754
 755         if (adau->dsp_bypass[SNDRV_PCM_STREAM_PLAYBACK]) {
 756                 regmap_write(adau->regmap, ADAU17X1_SERIAL_INPUT_ROUTE,
 757                         (adau->tdm_slot[SNDRV_PCM_STREAM_PLAYBACK] * 2) + 1);
 758         }
 759
 760         if (adau->dsp_bypass[SNDRV_PCM_STREAM_CAPTURE]) {
 761                 regmap_write(adau->regmap, ADAU17X1_SERIAL_OUTPUT_ROUTE,
 762                         (adau->tdm_slot[SNDRV_PCM_STREAM_CAPTURE] * 2) + 1);
 763         }
 764
 765         return 0;
 766 }
 767
 768 static int adau17x1_startup(struct snd_pcm_substream *substream,
 769         struct snd_soc_dai *dai)
 770 {
 771         struct adau *adau = snd_soc_component_get_drvdata(dai->component);
 772
 773         if (adau->sigmadsp)
 774                 return sigmadsp_restrict_params(adau->sigmadsp, substream);
 775
 776         return 0;
 777 }
 778
 779 const struct snd_soc_dai_ops adau17x1_dai_ops = {
 780         .hw_params      = adau17x1_hw_params,
 781         .set_sysclk     = adau17x1_set_dai_sysclk,
 782         .set_fmt        = adau17x1_set_dai_fmt,
 783         .set_pll        = adau17x1_set_dai_pll,
 784         .set_tdm_slot   = adau17x1_set_dai_tdm_slot,
 785         .startup        = adau17x1_startup,
 786 };
 787 EXPORT_SYMBOL_GPL(adau17x1_dai_ops);
 788
 789 int adau17x1_set_micbias_voltage(struct snd_soc_component *component,
 790         enum adau17x1_micbias_voltage micbias)
 791 {
 792         struct adau *adau = snd_soc_component_get_drvdata(component);
 793
 794         switch (micbias) {
 795         case ADAU17X1_MICBIAS_0_90_AVDD:
 796         case ADAU17X1_MICBIAS_0_65_AVDD:
 797                 break;
 798         default:
 799                 return -EINVAL;
 800         }
 801
 802         return regmap_write(adau->regmap, ADAU17X1_MICBIAS, micbias << 2);
 803 }
 804 EXPORT_SYMBOL_GPL(adau17x1_set_micbias_voltage);
 805
 806 bool adau17x1_precious_register(struct device *dev, unsigned int reg)
 807 {
 808         /* SigmaDSP parameter memory */
 809         if (reg < 0x400)
 810                 return true;
 811
 812         return false;
 813 }
 814 EXPORT_SYMBOL_GPL(adau17x1_precious_register);
 815
 816 bool adau17x1_readable_register(struct device *dev, unsigned int reg)
 817 {
 818         /* SigmaDSP parameter memory */
 819         if (reg < 0x400)
 820                 return true;
 821
 822         switch (reg) {
 823         case ADAU17X1_CLOCK_CONTROL:
 824         case ADAU17X1_PLL_CONTROL:
 825         case ADAU17X1_REC_POWER_MGMT:
 826         case ADAU17X1_MICBIAS:
 827         case ADAU17X1_SERIAL_PORT0:
 828         case ADAU17X1_SERIAL_PORT1:
 829         case ADAU17X1_CONVERTER0:
 830         case ADAU17X1_CONVERTER1:
 831         case ADAU17X1_LEFT_INPUT_DIGITAL_VOL:
 832         case ADAU17X1_RIGHT_INPUT_DIGITAL_VOL:
 833         case ADAU17X1_ADC_CONTROL:
 834         case ADAU17X1_PLAY_POWER_MGMT:
 835         case ADAU17X1_DAC_CONTROL0:
 836         case ADAU17X1_DAC_CONTROL1:
 837         case ADAU17X1_DAC_CONTROL2:
 838         case ADAU17X1_SERIAL_PORT_PAD:
 839         case ADAU17X1_CONTROL_PORT_PAD0:
 840         case ADAU17X1_CONTROL_PORT_PAD1:
 841         case ADAU17X1_DSP_SAMPLING_RATE:
 842         case ADAU17X1_SERIAL_INPUT_ROUTE:
 843         case ADAU17X1_SERIAL_OUTPUT_ROUTE:
 844         case ADAU17X1_DSP_ENABLE:
 845         case ADAU17X1_DSP_RUN:
 846         case ADAU17X1_SERIAL_SAMPLING_RATE:
 847                 return true;
 848         default:
 849                 break;
 850         }
 851         return false;
 852 }
 853 EXPORT_SYMBOL_GPL(adau17x1_readable_register);
 854
 855 bool adau17x1_volatile_register(struct device *dev, unsigned int reg)
 856 {
 857         /* SigmaDSP parameter and program memory */
 858         if (reg < 0x4000)
 859                 return true;
 860
 861         switch (reg) {
 862         /* The PLL register is 6 bytes long */
 863         case ADAU17X1_PLL_CONTROL:
 864         case ADAU17X1_PLL_CONTROL + 1:
 865         case ADAU17X1_PLL_CONTROL + 2:
 866         case ADAU17X1_PLL_CONTROL + 3:
 867         case ADAU17X1_PLL_CONTROL + 4:
 868         case ADAU17X1_PLL_CONTROL + 5:
 869                 return true;
 870         default:
 871                 break;
 872         }
 873
 874         return false;
 875 }
 876 EXPORT_SYMBOL_GPL(adau17x1_volatile_register);
 877
 878 static int adau17x1_setup_firmware(struct snd_soc_component *component,
 879         unsigned int rate)
 880 {
 881         int ret;
 882         int dspsr, dsp_run;
 883         struct adau *adau = snd_soc_component_get_drvdata(component);
 884         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 885
 886         /* Check if sample rate is the same as before. If it is there is no
 887          * point in performing the below steps as the call to
 888          * sigmadsp_setup(...) will return directly when it finds the sample
 889          * rate to be the same as before. By checking this we can prevent an
 890          * audiable popping noise which occours when toggling DSP_RUN.
 891          */
 892         if (adau->sigmadsp->current_samplerate == rate)
 893                 return 0;
 894
 895         snd_soc_dapm_mutex_lock(dapm);
 896
 897         ret = regmap_read(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, &dspsr);
 898         if (ret)
 899                 goto err;
 900
 901         ret = regmap_read(adau->regmap, ADAU17X1_DSP_RUN, &dsp_run);
 902         if (ret)
 903                 goto err;
 904
 905         regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 1);
 906         regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, 0xf);
 907         regmap_write(adau->regmap, ADAU17X1_DSP_RUN, 0);
 908
 909         ret = sigmadsp_setup(adau->sigmadsp, rate);
 910         if (ret) {
 911                 regmap_write(adau->regmap, ADAU17X1_DSP_ENABLE, 0);
 912                 goto err;
 913         }
 914         regmap_write(adau->regmap, ADAU17X1_DSP_SAMPLING_RATE, dspsr);
 915         regmap_write(adau->regmap, ADAU17X1_DSP_RUN, dsp_run);
 916
 917 err:
 918         snd_soc_dapm_mutex_unlock(dapm);
 919
 920         return ret;
 921 }
 922
 923 int adau17x1_add_widgets(struct snd_soc_component *component)
 924 {
 925         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 926         struct adau *adau = snd_soc_component_get_drvdata(component);
 927         int ret;
 928
 929         ret = snd_soc_add_component_controls(component, adau17x1_controls,
 930                 ARRAY_SIZE(adau17x1_controls));
 931         if (ret)
 932                 return ret;
 933         ret = snd_soc_dapm_new_controls(dapm, adau17x1_dapm_widgets,
 934                 ARRAY_SIZE(adau17x1_dapm_widgets));
 935         if (ret)
 936                 return ret;
 937
 938         if (adau17x1_has_dsp(adau)) {
 939                 ret = snd_soc_dapm_new_controls(dapm, adau17x1_dsp_dapm_widgets,
 940                         ARRAY_SIZE(adau17x1_dsp_dapm_widgets));
 941                 if (ret)
 942                         return ret;
 943
 944                 if (!adau->sigmadsp)
 945                         return 0;
 946
 947                 ret = sigmadsp_attach(adau->sigmadsp, component);
 948                 if (ret) {
 949                         dev_err(component->dev, "Failed to attach firmware: %d\n",
 950                                 ret);
 951                         return ret;
 952                 }
 953         }
 954
 955         return 0;
 956 }
 957 EXPORT_SYMBOL_GPL(adau17x1_add_widgets);
 958
 959 int adau17x1_add_routes(struct snd_soc_component *component)
 960 {
 961         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 962         struct adau *adau = snd_soc_component_get_drvdata(component);
 963         int ret;
 964
 965         ret = snd_soc_dapm_add_routes(dapm, adau17x1_dapm_routes,
 966                 ARRAY_SIZE(adau17x1_dapm_routes));
 967         if (ret)
 968                 return ret;
 969
 970         if (adau17x1_has_dsp(adau)) {
 971                 ret = snd_soc_dapm_add_routes(dapm, adau17x1_dsp_dapm_routes,
 972                         ARRAY_SIZE(adau17x1_dsp_dapm_routes));
 973         } else {
 974                 ret = snd_soc_dapm_add_routes(dapm, adau17x1_no_dsp_dapm_routes,
 975                         ARRAY_SIZE(adau17x1_no_dsp_dapm_routes));
 976         }
 977
 978         if (adau->clk_src != ADAU17X1_CLK_SRC_MCLK)
 979                 snd_soc_dapm_add_routes(dapm, &adau17x1_dapm_pll_route, 1);
 980
 981         return ret;
 982 }
 983 EXPORT_SYMBOL_GPL(adau17x1_add_routes);
 984
 985 int adau17x1_resume(struct snd_soc_component *component)
 986 {
 987         struct adau *adau = snd_soc_component_get_drvdata(component);
 988
 989         if (adau->switch_mode)
 990                 adau->switch_mode(component->dev);
 991
 992         regcache_sync(adau->regmap);
 993
 994         return 0;
 995 }
 996 EXPORT_SYMBOL_GPL(adau17x1_resume);
 997
 998 static int adau17x1_safeload(struct sigmadsp *sigmadsp, unsigned int addr,
 999         const uint8_t bytes[], size_t len)
1000 {
1001         uint8_t buf[ADAU17X1_WORD_SIZE];
1002         uint8_t data[ADAU17X1_SAFELOAD_DATA_SIZE];
1003         unsigned int addr_offset;
1004         unsigned int nbr_words;
1005         int ret;
1006
1007         /* write data to safeload addresses. Check if len is not a multiple of
1008          * 4 bytes, if so we need to zero pad.
1009          */
1010         nbr_words = len / ADAU17X1_WORD_SIZE;
1011         if ((len - nbr_words * ADAU17X1_WORD_SIZE) == 0) {
1012                 ret = regmap_raw_write(sigmadsp->control_data,
1013                         ADAU17X1_SAFELOAD_DATA, bytes, len);
1014         } else {
1015                 nbr_words++;
1016                 memset(data, 0, ADAU17X1_SAFELOAD_DATA_SIZE);
1017                 memcpy(data, bytes, len);
1018                 ret = regmap_raw_write(sigmadsp->control_data,
1019                         ADAU17X1_SAFELOAD_DATA, data,
1020                         nbr_words * ADAU17X1_WORD_SIZE);
1021         }
1022
1023         if (ret < 0)
1024                 return ret;
1025
1026         /* Write target address, target address is offset by 1 */
1027         addr_offset = addr - 1;
1028         put_unaligned_be32(addr_offset, buf);
1029         ret = regmap_raw_write(sigmadsp->control_data,
1030                 ADAU17X1_SAFELOAD_TARGET_ADDRESS, buf, ADAU17X1_WORD_SIZE);
1031         if (ret < 0)
1032                 return ret;
1033
1034         /* write nbr of words to trigger address */
1035         put_unaligned_be32(nbr_words, buf);
1036         ret = regmap_raw_write(sigmadsp->control_data,
1037                 ADAU17X1_SAFELOAD_TRIGGER, buf, ADAU17X1_WORD_SIZE);
1038         if (ret < 0)
1039                 return ret;
1040
1041         return 0;
1042 }
1043
1044 static const struct sigmadsp_ops adau17x1_sigmadsp_ops = {
1045         .safeload = adau17x1_safeload,
1046 };
1047
1048 int adau17x1_probe(struct device *dev, struct regmap *regmap,
1049         enum adau17x1_type type, void (*switch_mode)(struct device *dev),
1050         const char *firmware_name)
1051 {
1052         struct adau *adau;
1053         int ret;
1054
1055         if (IS_ERR(regmap))
1056                 return PTR_ERR(regmap);
1057
1058         adau = devm_kzalloc(dev, sizeof(*adau), GFP_KERNEL);
1059         if (!adau)
1060                 return -ENOMEM;
1061
1062         /* Clock is optional (for the driver) */
1063         adau->mclk = devm_clk_get_optional(dev, "mclk");
1064         if (IS_ERR(adau->mclk))
1065                 return PTR_ERR(adau->mclk);
1066
1067         if (adau->mclk) {
1068                 adau->clk_src = ADAU17X1_CLK_SRC_PLL_AUTO;
1069
1070                 /*
1071                  * Any valid PLL output rate will work at this point, use one
1072                  * that is likely to be chosen later as well. The register will
1073                  * be written when the PLL is powered up for the first time.
1074                  */
1075                 ret = adau_calc_pll_cfg(clk_get_rate(adau->mclk), 48000 * 1024,
1076                                 adau->pll_regs);
1077                 if (ret < 0)
1078                         return ret;
1079
1080                 ret = clk_prepare_enable(adau->mclk);
1081                 if (ret)
1082                         return ret;
1083         }
1084
1085         adau->regmap = regmap;
1086         adau->switch_mode = switch_mode;
1087         adau->type = type;
1088
1089         dev_set_drvdata(dev, adau);
1090
1091         if (firmware_name) {
1092                 if (adau17x1_has_safeload(adau)) {
1093                         adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap,
1094                                 &adau17x1_sigmadsp_ops, firmware_name);
1095                 } else {
1096                         adau->sigmadsp = devm_sigmadsp_init_regmap(dev, regmap,
1097                                 NULL, firmware_name);
1098                 }
1099                 if (IS_ERR(adau->sigmadsp)) {
1100                         dev_warn(dev, "Could not find firmware file: %ld\n",
1101                                 PTR_ERR(adau->sigmadsp));
1102                         adau->sigmadsp = NULL;
1103                 }
1104         }
1105
1106         if (switch_mode)
1107                 switch_mode(dev);
1108
1109         return 0;
1110 }
1111 EXPORT_SYMBOL_GPL(adau17x1_probe);
1112
1113 void adau17x1_remove(struct device *dev)
1114 {
1115         struct adau *adau = dev_get_drvdata(dev);
1116
1117         clk_disable_unprepare(adau->mclk);
1118 }
1119 EXPORT_SYMBOL_GPL(adau17x1_remove);
1120
1121 MODULE_DESCRIPTION("ASoC ADAU1X61/ADAU1X81 common code");
1122 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
1123 MODULE_LICENSE("GPL");