sound/soc/codecs/adau17x1.c

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