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