sound/soc/codecs/sgtl5000.c

   1 /*
   2  * sgtl5000.c  --  SGTL5000 ALSA SoC Audio driver
   3  *
   4  * Copyright 2010-2011 Freescale Semiconductor, Inc. All Rights Reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/moduleparam.h>
  13 #include <linux/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/slab.h>
  16 #include <linux/pm.h>
  17 #include <linux/i2c.h>
  18 #include <linux/clk.h>
  19 #include <linux/log2.h>
  20 #include <linux/regmap.h>
  21 #include <linux/regulator/driver.h>
  22 #include <linux/regulator/machine.h>
  23 #include <linux/regulator/consumer.h>
  24 #include <linux/of_device.h>
  25 #include <sound/core.h>
  26 #include <sound/tlv.h>
  27 #include <sound/pcm.h>
  28 #include <sound/pcm_params.h>
  29 #include <sound/soc.h>
  30 #include <sound/soc-dapm.h>
  31 #include <sound/initval.h>
  32
  33 #include "sgtl5000.h"
  34
  35 #define SGTL5000_DAP_REG_OFFSET 0x0100
  36 #define SGTL5000_MAX_REG_OFFSET 0x013A
  37
  38 /* default value of sgtl5000 registers */
  39 static const struct reg_default sgtl5000_reg_defaults[] = {
  40         { SGTL5000_CHIP_DIG_POWER,              0x0000 },
  41         { SGTL5000_CHIP_CLK_CTRL,               0x0008 },
  42         { SGTL5000_CHIP_I2S_CTRL,               0x0010 },
  43         { SGTL5000_CHIP_SSS_CTRL,               0x0010 },
  44         { SGTL5000_CHIP_ADCDAC_CTRL,            0x020c },
  45         { SGTL5000_CHIP_DAC_VOL,                0x3c3c },
  46         { SGTL5000_CHIP_PAD_STRENGTH,           0x015f },
  47         { SGTL5000_CHIP_ANA_ADC_CTRL,           0x0000 },
  48         { SGTL5000_CHIP_ANA_HP_CTRL,            0x1818 },
  49         { SGTL5000_CHIP_ANA_CTRL,               0x0111 },
  50         { SGTL5000_CHIP_LINREG_CTRL,            0x0000 },
  51         { SGTL5000_CHIP_REF_CTRL,               0x0000 },
  52         { SGTL5000_CHIP_MIC_CTRL,               0x0000 },
  53         { SGTL5000_CHIP_LINE_OUT_CTRL,          0x0000 },
  54         { SGTL5000_CHIP_LINE_OUT_VOL,           0x0404 },
  55         { SGTL5000_CHIP_ANA_POWER,              0x7060 },
  56         { SGTL5000_CHIP_PLL_CTRL,               0x5000 },
  57         { SGTL5000_CHIP_CLK_TOP_CTRL,           0x0000 },
  58         { SGTL5000_CHIP_ANA_STATUS,             0x0000 },
  59         { SGTL5000_CHIP_SHORT_CTRL,             0x0000 },
  60         { SGTL5000_CHIP_ANA_TEST2,              0x0000 },
  61         { SGTL5000_DAP_CTRL,                    0x0000 },
  62         { SGTL5000_DAP_PEQ,                     0x0000 },
  63         { SGTL5000_DAP_BASS_ENHANCE,            0x0040 },
  64         { SGTL5000_DAP_BASS_ENHANCE_CTRL,       0x051f },
  65         { SGTL5000_DAP_AUDIO_EQ,                0x0000 },
  66         { SGTL5000_DAP_SURROUND,                0x0040 },
  67         { SGTL5000_DAP_EQ_BASS_BAND0,           0x002f },
  68         { SGTL5000_DAP_EQ_BASS_BAND1,           0x002f },
  69         { SGTL5000_DAP_EQ_BASS_BAND2,           0x002f },
  70         { SGTL5000_DAP_EQ_BASS_BAND3,           0x002f },
  71         { SGTL5000_DAP_EQ_BASS_BAND4,           0x002f },
  72         { SGTL5000_DAP_MAIN_CHAN,               0x8000 },
  73         { SGTL5000_DAP_MIX_CHAN,                0x0000 },
  74         { SGTL5000_DAP_AVC_CTRL,                0x0510 },
  75         { SGTL5000_DAP_AVC_THRESHOLD,           0x1473 },
  76         { SGTL5000_DAP_AVC_ATTACK,              0x0028 },
  77         { SGTL5000_DAP_AVC_DECAY,               0x0050 },
  78 };
  79
  80 /* regulator supplies for sgtl5000, VDDD is an optional external supply */
  81 enum sgtl5000_regulator_supplies {
  82         VDDA,
  83         VDDIO,
  84         VDDD,
  85         SGTL5000_SUPPLY_NUM
  86 };
  87
  88 /* vddd is optional supply */
  89 static const char *supply_names[SGTL5000_SUPPLY_NUM] = {
  90         "VDDA",
  91         "VDDIO",
  92         "VDDD"
  93 };
  94
  95 #define LDO_CONSUMER_NAME       "VDDD_LDO"
  96 #define LDO_VOLTAGE             1200000
  97
  98 static struct regulator_consumer_supply ldo_consumer[] = {
  99         REGULATOR_SUPPLY(LDO_CONSUMER_NAME, NULL),
 100 };
 101
 102 static struct regulator_init_data ldo_init_data = {
 103         .constraints = {
 104                 .min_uV                 = 1200000,
 105                 .max_uV                 = 1200000,
 106                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 107                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
 108         },
 109         .num_consumer_supplies = 1,
 110         .consumer_supplies = &ldo_consumer[0],
 111 };
 112
 113 /*
 114  * sgtl5000 internal ldo regulator,
 115  * enabled when VDDD not provided
 116  */
 117 struct ldo_regulator {
 118         struct regulator_desc desc;
 119         struct regulator_dev *dev;
 120         int voltage;
 121         void *codec_data;
 122         bool enabled;
 123 };
 124
 125 enum sgtl5000_micbias_resistor {
 126         SGTL5000_MICBIAS_OFF = 0,
 127         SGTL5000_MICBIAS_2K = 2,
 128         SGTL5000_MICBIAS_4K = 4,
 129         SGTL5000_MICBIAS_8K = 8,
 130 };
 131
 132 /* sgtl5000 private structure in codec */
 133 struct sgtl5000_priv {
 134         int sysclk;     /* sysclk rate */
 135         int master;     /* i2s master or not */
 136         int fmt;        /* i2s data format */
 137         struct regulator_bulk_data supplies[SGTL5000_SUPPLY_NUM];
 138         struct ldo_regulator *ldo;
 139         struct regmap *regmap;
 140         struct clk *mclk;
 141         int revision;
 142         u8 micbias_resistor;
 143         u8 micbias_voltage;
 144 };
 145
 146 /*
 147  * mic_bias power on/off share the same register bits with
 148  * output impedance of mic bias, when power on mic bias, we
 149  * need reclaim it to impedance value.
 150  * 0x0 = Powered off
 151  * 0x1 = 2Kohm
 152  * 0x2 = 4Kohm
 153  * 0x3 = 8Kohm
 154  */
 155 static int mic_bias_event(struct snd_soc_dapm_widget *w,
 156         struct snd_kcontrol *kcontrol, int event)
 157 {
 158         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 159         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 160
 161         switch (event) {
 162         case SND_SOC_DAPM_POST_PMU:
 163                 /* change mic bias resistor */
 164                 snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
 165                         SGTL5000_BIAS_R_MASK,
 166                         sgtl5000->micbias_resistor << SGTL5000_BIAS_R_SHIFT);
 167                 break;
 168
 169         case SND_SOC_DAPM_PRE_PMD:
 170                 snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
 171                                 SGTL5000_BIAS_R_MASK, 0);
 172                 break;
 173         }
 174         return 0;
 175 }
 176
 177 /*
 178  * As manual described, ADC/DAC only works when VAG powerup,
 179  * So enabled VAG before ADC/DAC up.
 180  * In power down case, we need wait 400ms when vag fully ramped down.
 181  */
 182 static int power_vag_event(struct snd_soc_dapm_widget *w,
 183         struct snd_kcontrol *kcontrol, int event)
 184 {
 185         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 186         const u32 mask = SGTL5000_DAC_POWERUP | SGTL5000_ADC_POWERUP;
 187
 188         switch (event) {
 189         case SND_SOC_DAPM_POST_PMU:
 190                 snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 191                         SGTL5000_VAG_POWERUP, SGTL5000_VAG_POWERUP);
 192                 break;
 193
 194         case SND_SOC_DAPM_PRE_PMD:
 195                 /*
 196                  * Don't clear VAG_POWERUP, when both DAC and ADC are
 197                  * operational to prevent inadvertently starving the
 198                  * other one of them.
 199                  */
 200                 if ((snd_soc_read(codec, SGTL5000_CHIP_ANA_POWER) &
 201                                 mask) != mask) {
 202                         snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 203                                 SGTL5000_VAG_POWERUP, 0);
 204                         msleep(400);
 205                 }
 206                 break;
 207         default:
 208                 break;
 209         }
 210
 211         return 0;
 212 }
 213
 214 /* input sources for ADC */
 215 static const char *adc_mux_text[] = {
 216         "MIC_IN", "LINE_IN"
 217 };
 218
 219 static SOC_ENUM_SINGLE_DECL(adc_enum,
 220                             SGTL5000_CHIP_ANA_CTRL, 2,
 221                             adc_mux_text);
 222
 223 static const struct snd_kcontrol_new adc_mux =
 224 SOC_DAPM_ENUM("Capture Mux", adc_enum);
 225
 226 /* input sources for DAC */
 227 static const char *dac_mux_text[] = {
 228         "DAC", "LINE_IN"
 229 };
 230
 231 static SOC_ENUM_SINGLE_DECL(dac_enum,
 232                             SGTL5000_CHIP_ANA_CTRL, 6,
 233                             dac_mux_text);
 234
 235 static const struct snd_kcontrol_new dac_mux =
 236 SOC_DAPM_ENUM("Headphone Mux", dac_enum);
 237
 238 static const struct snd_soc_dapm_widget sgtl5000_dapm_widgets[] = {
 239         SND_SOC_DAPM_INPUT("LINE_IN"),
 240         SND_SOC_DAPM_INPUT("MIC_IN"),
 241
 242         SND_SOC_DAPM_OUTPUT("HP_OUT"),
 243         SND_SOC_DAPM_OUTPUT("LINE_OUT"),
 244
 245         SND_SOC_DAPM_SUPPLY("Mic Bias", SGTL5000_CHIP_MIC_CTRL, 8, 0,
 246                             mic_bias_event,
 247                             SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 248
 249         SND_SOC_DAPM_PGA("HP", SGTL5000_CHIP_ANA_POWER, 4, 0, NULL, 0),
 250         SND_SOC_DAPM_PGA("LO", SGTL5000_CHIP_ANA_POWER, 0, 0, NULL, 0),
 251
 252         SND_SOC_DAPM_MUX("Capture Mux", SND_SOC_NOPM, 0, 0, &adc_mux),
 253         SND_SOC_DAPM_MUX("Headphone Mux", SND_SOC_NOPM, 0, 0, &dac_mux),
 254
 255         /* aif for i2s input */
 256         SND_SOC_DAPM_AIF_IN("AIFIN", "Playback",
 257                                 0, SGTL5000_CHIP_DIG_POWER,
 258                                 0, 0),
 259
 260         /* aif for i2s output */
 261         SND_SOC_DAPM_AIF_OUT("AIFOUT", "Capture",
 262                                 0, SGTL5000_CHIP_DIG_POWER,
 263                                 1, 0),
 264
 265         SND_SOC_DAPM_ADC("ADC", "Capture", SGTL5000_CHIP_ANA_POWER, 1, 0),
 266         SND_SOC_DAPM_DAC("DAC", "Playback", SGTL5000_CHIP_ANA_POWER, 3, 0),
 267
 268         SND_SOC_DAPM_PRE("VAG_POWER_PRE", power_vag_event),
 269         SND_SOC_DAPM_POST("VAG_POWER_POST", power_vag_event),
 270 };
 271
 272 /* routes for sgtl5000 */
 273 static const struct snd_soc_dapm_route sgtl5000_dapm_routes[] = {
 274         {"Capture Mux", "LINE_IN", "LINE_IN"},  /* line_in --> adc_mux */
 275         {"Capture Mux", "MIC_IN", "MIC_IN"},    /* mic_in --> adc_mux */
 276
 277         {"ADC", NULL, "Capture Mux"},           /* adc_mux --> adc */
 278         {"AIFOUT", NULL, "ADC"},                /* adc --> i2s_out */
 279
 280         {"DAC", NULL, "AIFIN"},                 /* i2s-->dac,skip audio mux */
 281         {"Headphone Mux", "DAC", "DAC"},        /* dac --> hp_mux */
 282         {"LO", NULL, "DAC"},                    /* dac --> line_out */
 283
 284         {"Headphone Mux", "LINE_IN", "LINE_IN"},/* line_in --> hp_mux */
 285         {"HP", NULL, "Headphone Mux"},          /* hp_mux --> hp */
 286
 287         {"LINE_OUT", NULL, "LO"},
 288         {"HP_OUT", NULL, "HP"},
 289 };
 290
 291 /* custom function to fetch info of PCM playback volume */
 292 static int dac_info_volsw(struct snd_kcontrol *kcontrol,
 293                           struct snd_ctl_elem_info *uinfo)
 294 {
 295         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 296         uinfo->count = 2;
 297         uinfo->value.integer.min = 0;
 298         uinfo->value.integer.max = 0xfc - 0x3c;
 299         return 0;
 300 }
 301
 302 /*
 303  * custom function to get of PCM playback volume
 304  *
 305  * dac volume register
 306  * 15-------------8-7--------------0
 307  * | R channel vol | L channel vol |
 308  *  -------------------------------
 309  *
 310  * PCM volume with 0.5017 dB steps from 0 to -90 dB
 311  *
 312  * register values map to dB
 313  * 0x3B and less = Reserved
 314  * 0x3C = 0 dB
 315  * 0x3D = -0.5 dB
 316  * 0xF0 = -90 dB
 317  * 0xFC and greater = Muted
 318  *
 319  * register value map to userspace value
 320  *
 321  * register value       0x3c(0dB)         0xf0(-90dB)0xfc
 322  *                      ------------------------------
 323  * userspace value      0xc0                         0
 324  */
 325 static int dac_get_volsw(struct snd_kcontrol *kcontrol,
 326                          struct snd_ctl_elem_value *ucontrol)
 327 {
 328         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 329         int reg;
 330         int l;
 331         int r;
 332
 333         reg = snd_soc_read(codec, SGTL5000_CHIP_DAC_VOL);
 334
 335         /* get left channel volume */
 336         l = (reg & SGTL5000_DAC_VOL_LEFT_MASK) >> SGTL5000_DAC_VOL_LEFT_SHIFT;
 337
 338         /* get right channel volume */
 339         r = (reg & SGTL5000_DAC_VOL_RIGHT_MASK) >> SGTL5000_DAC_VOL_RIGHT_SHIFT;
 340
 341         /* make sure value fall in (0x3c,0xfc) */
 342         l = clamp(l, 0x3c, 0xfc);
 343         r = clamp(r, 0x3c, 0xfc);
 344
 345         /* invert it and map to userspace value */
 346         l = 0xfc - l;
 347         r = 0xfc - r;
 348
 349         ucontrol->value.integer.value[0] = l;
 350         ucontrol->value.integer.value[1] = r;
 351
 352         return 0;
 353 }
 354
 355 /*
 356  * custom function to put of PCM playback volume
 357  *
 358  * dac volume register
 359  * 15-------------8-7--------------0
 360  * | R channel vol | L channel vol |
 361  *  -------------------------------
 362  *
 363  * PCM volume with 0.5017 dB steps from 0 to -90 dB
 364  *
 365  * register values map to dB
 366  * 0x3B and less = Reserved
 367  * 0x3C = 0 dB
 368  * 0x3D = -0.5 dB
 369  * 0xF0 = -90 dB
 370  * 0xFC and greater = Muted
 371  *
 372  * userspace value map to register value
 373  *
 374  * userspace value      0xc0                         0
 375  *                      ------------------------------
 376  * register value       0x3c(0dB)       0xf0(-90dB)0xfc
 377  */
 378 static int dac_put_volsw(struct snd_kcontrol *kcontrol,
 379                          struct snd_ctl_elem_value *ucontrol)
 380 {
 381         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 382         int reg;
 383         int l;
 384         int r;
 385
 386         l = ucontrol->value.integer.value[0];
 387         r = ucontrol->value.integer.value[1];
 388
 389         /* make sure userspace volume fall in (0, 0xfc-0x3c) */
 390         l = clamp(l, 0, 0xfc - 0x3c);
 391         r = clamp(r, 0, 0xfc - 0x3c);
 392
 393         /* invert it, get the value can be set to register */
 394         l = 0xfc - l;
 395         r = 0xfc - r;
 396
 397         /* shift to get the register value */
 398         reg = l << SGTL5000_DAC_VOL_LEFT_SHIFT |
 399                 r << SGTL5000_DAC_VOL_RIGHT_SHIFT;
 400
 401         snd_soc_write(codec, SGTL5000_CHIP_DAC_VOL, reg);
 402
 403         return 0;
 404 }
 405
 406 static const DECLARE_TLV_DB_SCALE(capture_6db_attenuate, -600, 600, 0);
 407
 408 /* tlv for mic gain, 0db 20db 30db 40db */
 409 static const DECLARE_TLV_DB_RANGE(mic_gain_tlv,
 410         0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
 411         1, 3, TLV_DB_SCALE_ITEM(2000, 1000, 0)
 412 );
 413
 414 /* tlv for hp volume, -51.5db to 12.0db, step .5db */
 415 static const DECLARE_TLV_DB_SCALE(headphone_volume, -5150, 50, 0);
 416
 417 static const struct snd_kcontrol_new sgtl5000_snd_controls[] = {
 418         /* SOC_DOUBLE_S8_TLV with invert */
 419         {
 420                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 421                 .name = "PCM Playback Volume",
 422                 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |
 423                         SNDRV_CTL_ELEM_ACCESS_READWRITE,
 424                 .info = dac_info_volsw,
 425                 .get = dac_get_volsw,
 426                 .put = dac_put_volsw,
 427         },
 428
 429         SOC_DOUBLE("Capture Volume", SGTL5000_CHIP_ANA_ADC_CTRL, 0, 4, 0xf, 0),
 430         SOC_SINGLE_TLV("Capture Attenuate Switch (-6dB)",
 431                         SGTL5000_CHIP_ANA_ADC_CTRL,
 432                         8, 1, 0, capture_6db_attenuate),
 433         SOC_SINGLE("Capture ZC Switch", SGTL5000_CHIP_ANA_CTRL, 1, 1, 0),
 434
 435         SOC_DOUBLE_TLV("Headphone Playback Volume",
 436                         SGTL5000_CHIP_ANA_HP_CTRL,
 437                         0, 8,
 438                         0x7f, 1,
 439                         headphone_volume),
 440         SOC_SINGLE("Headphone Playback ZC Switch", SGTL5000_CHIP_ANA_CTRL,
 441                         5, 1, 0),
 442
 443         SOC_SINGLE_TLV("Mic Volume", SGTL5000_CHIP_MIC_CTRL,
 444                         0, 3, 0, mic_gain_tlv),
 445 };
 446
 447 /* mute the codec used by alsa core */
 448 static int sgtl5000_digital_mute(struct snd_soc_dai *codec_dai, int mute)
 449 {
 450         struct snd_soc_codec *codec = codec_dai->codec;
 451         u16 adcdac_ctrl = SGTL5000_DAC_MUTE_LEFT | SGTL5000_DAC_MUTE_RIGHT;
 452
 453         snd_soc_update_bits(codec, SGTL5000_CHIP_ADCDAC_CTRL,
 454                         adcdac_ctrl, mute ? adcdac_ctrl : 0);
 455
 456         return 0;
 457 }
 458
 459 /* set codec format */
 460 static int sgtl5000_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
 461 {
 462         struct snd_soc_codec *codec = codec_dai->codec;
 463         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 464         u16 i2sctl = 0;
 465
 466         sgtl5000->master = 0;
 467         /*
 468          * i2s clock and frame master setting.
 469          * ONLY support:
 470          *  - clock and frame slave,
 471          *  - clock and frame master
 472          */
 473         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 474         case SND_SOC_DAIFMT_CBS_CFS:
 475                 break;
 476         case SND_SOC_DAIFMT_CBM_CFM:
 477                 i2sctl |= SGTL5000_I2S_MASTER;
 478                 sgtl5000->master = 1;
 479                 break;
 480         default:
 481                 return -EINVAL;
 482         }
 483
 484         /* setting i2s data format */
 485         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 486         case SND_SOC_DAIFMT_DSP_A:
 487                 i2sctl |= SGTL5000_I2S_MODE_PCM << SGTL5000_I2S_MODE_SHIFT;
 488                 break;
 489         case SND_SOC_DAIFMT_DSP_B:
 490                 i2sctl |= SGTL5000_I2S_MODE_PCM << SGTL5000_I2S_MODE_SHIFT;
 491                 i2sctl |= SGTL5000_I2S_LRALIGN;
 492                 break;
 493         case SND_SOC_DAIFMT_I2S:
 494                 i2sctl |= SGTL5000_I2S_MODE_I2S_LJ << SGTL5000_I2S_MODE_SHIFT;
 495                 break;
 496         case SND_SOC_DAIFMT_RIGHT_J:
 497                 i2sctl |= SGTL5000_I2S_MODE_RJ << SGTL5000_I2S_MODE_SHIFT;
 498                 i2sctl |= SGTL5000_I2S_LRPOL;
 499                 break;
 500         case SND_SOC_DAIFMT_LEFT_J:
 501                 i2sctl |= SGTL5000_I2S_MODE_I2S_LJ << SGTL5000_I2S_MODE_SHIFT;
 502                 i2sctl |= SGTL5000_I2S_LRALIGN;
 503                 break;
 504         default:
 505                 return -EINVAL;
 506         }
 507
 508         sgtl5000->fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
 509
 510         /* Clock inversion */
 511         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 512         case SND_SOC_DAIFMT_NB_NF:
 513                 break;
 514         case SND_SOC_DAIFMT_IB_NF:
 515                 i2sctl |= SGTL5000_I2S_SCLK_INV;
 516                 break;
 517         default:
 518                 return -EINVAL;
 519         }
 520
 521         snd_soc_write(codec, SGTL5000_CHIP_I2S_CTRL, i2sctl);
 522
 523         return 0;
 524 }
 525
 526 /* set codec sysclk */
 527 static int sgtl5000_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 528                                    int clk_id, unsigned int freq, int dir)
 529 {
 530         struct snd_soc_codec *codec = codec_dai->codec;
 531         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 532
 533         switch (clk_id) {
 534         case SGTL5000_SYSCLK:
 535                 sgtl5000->sysclk = freq;
 536                 break;
 537         default:
 538                 return -EINVAL;
 539         }
 540
 541         return 0;
 542 }
 543
 544 /*
 545  * set clock according to i2s frame clock,
 546  * sgtl5000 provides 2 clock sources:
 547  * 1. sys_mclk: sample freq can only be configured to
 548  *      1/256, 1/384, 1/512 of sys_mclk.
 549  * 2. pll: can derive any audio clocks.
 550  *
 551  * clock setting rules:
 552  * 1. in slave mode, only sys_mclk can be used
 553  * 2. as constraint by sys_mclk, sample freq should be set to 32 kHz, 44.1 kHz
 554  * and above.
 555  * 3. usage of sys_mclk is preferred over pll to save power.
 556  */
 557 static int sgtl5000_set_clock(struct snd_soc_codec *codec, int frame_rate)
 558 {
 559         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 560         int clk_ctl = 0;
 561         int sys_fs;     /* sample freq */
 562
 563         /*
 564          * sample freq should be divided by frame clock,
 565          * if frame clock is lower than 44.1 kHz, sample freq should be set to
 566          * 32 kHz or 44.1 kHz.
 567          */
 568         switch (frame_rate) {
 569         case 8000:
 570         case 16000:
 571                 sys_fs = 32000;
 572                 break;
 573         case 11025:
 574         case 22050:
 575                 sys_fs = 44100;
 576                 break;
 577         default:
 578                 sys_fs = frame_rate;
 579                 break;
 580         }
 581
 582         /* set divided factor of frame clock */
 583         switch (sys_fs / frame_rate) {
 584         case 4:
 585                 clk_ctl |= SGTL5000_RATE_MODE_DIV_4 << SGTL5000_RATE_MODE_SHIFT;
 586                 break;
 587         case 2:
 588                 clk_ctl |= SGTL5000_RATE_MODE_DIV_2 << SGTL5000_RATE_MODE_SHIFT;
 589                 break;
 590         case 1:
 591                 clk_ctl |= SGTL5000_RATE_MODE_DIV_1 << SGTL5000_RATE_MODE_SHIFT;
 592                 break;
 593         default:
 594                 return -EINVAL;
 595         }
 596
 597         /* set the sys_fs according to frame rate */
 598         switch (sys_fs) {
 599         case 32000:
 600                 clk_ctl |= SGTL5000_SYS_FS_32k << SGTL5000_SYS_FS_SHIFT;
 601                 break;
 602         case 44100:
 603                 clk_ctl |= SGTL5000_SYS_FS_44_1k << SGTL5000_SYS_FS_SHIFT;
 604                 break;
 605         case 48000:
 606                 clk_ctl |= SGTL5000_SYS_FS_48k << SGTL5000_SYS_FS_SHIFT;
 607                 break;
 608         case 96000:
 609                 clk_ctl |= SGTL5000_SYS_FS_96k << SGTL5000_SYS_FS_SHIFT;
 610                 break;
 611         default:
 612                 dev_err(codec->dev, "frame rate %d not supported\n",
 613                         frame_rate);
 614                 return -EINVAL;
 615         }
 616
 617         /*
 618          * calculate the divider of mclk/sample_freq,
 619          * factor of freq = 96 kHz can only be 256, since mclk is in the range
 620          * of 8 MHz - 27 MHz
 621          */
 622         switch (sgtl5000->sysclk / frame_rate) {
 623         case 256:
 624                 clk_ctl |= SGTL5000_MCLK_FREQ_256FS <<
 625                         SGTL5000_MCLK_FREQ_SHIFT;
 626                 break;
 627         case 384:
 628                 clk_ctl |= SGTL5000_MCLK_FREQ_384FS <<
 629                         SGTL5000_MCLK_FREQ_SHIFT;
 630                 break;
 631         case 512:
 632                 clk_ctl |= SGTL5000_MCLK_FREQ_512FS <<
 633                         SGTL5000_MCLK_FREQ_SHIFT;
 634                 break;
 635         default:
 636                 /* if mclk does not satisfy the divider, use pll */
 637                 if (sgtl5000->master) {
 638                         clk_ctl |= SGTL5000_MCLK_FREQ_PLL <<
 639                                 SGTL5000_MCLK_FREQ_SHIFT;
 640                 } else {
 641                         dev_err(codec->dev,
 642                                 "PLL not supported in slave mode\n");
 643                         dev_err(codec->dev, "%d ratio is not supported. "
 644                                 "SYS_MCLK needs to be 256, 384 or 512 * fs\n",
 645                                 sgtl5000->sysclk / frame_rate);
 646                         return -EINVAL;
 647                 }
 648         }
 649
 650         /* if using pll, please check manual 6.4.2 for detail */
 651         if ((clk_ctl & SGTL5000_MCLK_FREQ_MASK) == SGTL5000_MCLK_FREQ_PLL) {
 652                 u64 out, t;
 653                 int div2;
 654                 int pll_ctl;
 655                 unsigned int in, int_div, frac_div;
 656
 657                 if (sgtl5000->sysclk > 17000000) {
 658                         div2 = 1;
 659                         in = sgtl5000->sysclk / 2;
 660                 } else {
 661                         div2 = 0;
 662                         in = sgtl5000->sysclk;
 663                 }
 664                 if (sys_fs == 44100)
 665                         out = 180633600;
 666                 else
 667                         out = 196608000;
 668                 t = do_div(out, in);
 669                 int_div = out;
 670                 t *= 2048;
 671                 do_div(t, in);
 672                 frac_div = t;
 673                 pll_ctl = int_div << SGTL5000_PLL_INT_DIV_SHIFT |
 674                     frac_div << SGTL5000_PLL_FRAC_DIV_SHIFT;
 675
 676                 snd_soc_write(codec, SGTL5000_CHIP_PLL_CTRL, pll_ctl);
 677                 if (div2)
 678                         snd_soc_update_bits(codec,
 679                                 SGTL5000_CHIP_CLK_TOP_CTRL,
 680                                 SGTL5000_INPUT_FREQ_DIV2,
 681                                 SGTL5000_INPUT_FREQ_DIV2);
 682                 else
 683                         snd_soc_update_bits(codec,
 684                                 SGTL5000_CHIP_CLK_TOP_CTRL,
 685                                 SGTL5000_INPUT_FREQ_DIV2,
 686                                 0);
 687
 688                 /* power up pll */
 689                 snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 690                         SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP,
 691                         SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP);
 692
 693                 /* if using pll, clk_ctrl must be set after pll power up */
 694                 snd_soc_write(codec, SGTL5000_CHIP_CLK_CTRL, clk_ctl);
 695         } else {
 696                 /* otherwise, clk_ctrl must be set before pll power down */
 697                 snd_soc_write(codec, SGTL5000_CHIP_CLK_CTRL, clk_ctl);
 698
 699                 /* power down pll */
 700                 snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 701                         SGTL5000_PLL_POWERUP | SGTL5000_VCOAMP_POWERUP,
 702                         0);
 703         }
 704
 705         return 0;
 706 }
 707
 708 /*
 709  * Set PCM DAI bit size and sample rate.
 710  * input: params_rate, params_fmt
 711  */
 712 static int sgtl5000_pcm_hw_params(struct snd_pcm_substream *substream,
 713                                   struct snd_pcm_hw_params *params,
 714                                   struct snd_soc_dai *dai)
 715 {
 716         struct snd_soc_codec *codec = dai->codec;
 717         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 718         int channels = params_channels(params);
 719         int i2s_ctl = 0;
 720         int stereo;
 721         int ret;
 722
 723         /* sysclk should already set */
 724         if (!sgtl5000->sysclk) {
 725                 dev_err(codec->dev, "%s: set sysclk first!\n", __func__);
 726                 return -EFAULT;
 727         }
 728
 729         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 730                 stereo = SGTL5000_DAC_STEREO;
 731         else
 732                 stereo = SGTL5000_ADC_STEREO;
 733
 734         /* set mono to save power */
 735         snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER, stereo,
 736                         channels == 1 ? 0 : stereo);
 737
 738         /* set codec clock base on lrclk */
 739         ret = sgtl5000_set_clock(codec, params_rate(params));
 740         if (ret)
 741                 return ret;
 742
 743         /* set i2s data format */
 744         switch (params_width(params)) {
 745         case 16:
 746                 if (sgtl5000->fmt == SND_SOC_DAIFMT_RIGHT_J)
 747                         return -EINVAL;
 748                 i2s_ctl |= SGTL5000_I2S_DLEN_16 << SGTL5000_I2S_DLEN_SHIFT;
 749                 i2s_ctl |= SGTL5000_I2S_SCLKFREQ_32FS <<
 750                     SGTL5000_I2S_SCLKFREQ_SHIFT;
 751                 break;
 752         case 20:
 753                 i2s_ctl |= SGTL5000_I2S_DLEN_20 << SGTL5000_I2S_DLEN_SHIFT;
 754                 i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
 755                     SGTL5000_I2S_SCLKFREQ_SHIFT;
 756                 break;
 757         case 24:
 758                 i2s_ctl |= SGTL5000_I2S_DLEN_24 << SGTL5000_I2S_DLEN_SHIFT;
 759                 i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
 760                     SGTL5000_I2S_SCLKFREQ_SHIFT;
 761                 break;
 762         case 32:
 763                 if (sgtl5000->fmt == SND_SOC_DAIFMT_RIGHT_J)
 764                         return -EINVAL;
 765                 i2s_ctl |= SGTL5000_I2S_DLEN_32 << SGTL5000_I2S_DLEN_SHIFT;
 766                 i2s_ctl |= SGTL5000_I2S_SCLKFREQ_64FS <<
 767                     SGTL5000_I2S_SCLKFREQ_SHIFT;
 768                 break;
 769         default:
 770                 return -EINVAL;
 771         }
 772
 773         snd_soc_update_bits(codec, SGTL5000_CHIP_I2S_CTRL,
 774                             SGTL5000_I2S_DLEN_MASK | SGTL5000_I2S_SCLKFREQ_MASK,
 775                             i2s_ctl);
 776
 777         return 0;
 778 }
 779
 780 #ifdef CONFIG_REGULATOR
 781 static int ldo_regulator_is_enabled(struct regulator_dev *dev)
 782 {
 783         struct ldo_regulator *ldo = rdev_get_drvdata(dev);
 784
 785         return ldo->enabled;
 786 }
 787
 788 static int ldo_regulator_enable(struct regulator_dev *dev)
 789 {
 790         struct ldo_regulator *ldo = rdev_get_drvdata(dev);
 791         struct snd_soc_codec *codec = (struct snd_soc_codec *)ldo->codec_data;
 792         int reg;
 793
 794         if (ldo_regulator_is_enabled(dev))
 795                 return 0;
 796
 797         /* set regulator value firstly */
 798         reg = (1600 - ldo->voltage / 1000) / 50;
 799         reg = clamp(reg, 0x0, 0xf);
 800
 801         /* amend the voltage value, unit: uV */
 802         ldo->voltage = (1600 - reg * 50) * 1000;
 803
 804         /* set voltage to register */
 805         snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
 806                                 SGTL5000_LINREG_VDDD_MASK, reg);
 807
 808         snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 809                                 SGTL5000_LINEREG_D_POWERUP,
 810                                 SGTL5000_LINEREG_D_POWERUP);
 811
 812         /* when internal ldo is enabled, simple digital power can be disabled */
 813         snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 814                                 SGTL5000_LINREG_SIMPLE_POWERUP,
 815                                 0);
 816
 817         ldo->enabled = 1;
 818         return 0;
 819 }
 820
 821 static int ldo_regulator_disable(struct regulator_dev *dev)
 822 {
 823         struct ldo_regulator *ldo = rdev_get_drvdata(dev);
 824         struct snd_soc_codec *codec = (struct snd_soc_codec *)ldo->codec_data;
 825
 826         snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
 827                                 SGTL5000_LINEREG_D_POWERUP,
 828                                 0);
 829
 830         /* clear voltage info */
 831         snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
 832                                 SGTL5000_LINREG_VDDD_MASK, 0);
 833
 834         ldo->enabled = 0;
 835
 836         return 0;
 837 }
 838
 839 static int ldo_regulator_get_voltage(struct regulator_dev *dev)
 840 {
 841         struct ldo_regulator *ldo = rdev_get_drvdata(dev);
 842
 843         return ldo->voltage;
 844 }
 845
 846 static struct regulator_ops ldo_regulator_ops = {
 847         .is_enabled = ldo_regulator_is_enabled,
 848         .enable = ldo_regulator_enable,
 849         .disable = ldo_regulator_disable,
 850         .get_voltage = ldo_regulator_get_voltage,
 851 };
 852
 853 static int ldo_regulator_register(struct snd_soc_codec *codec,
 854                                 struct regulator_init_data *init_data,
 855                                 int voltage)
 856 {
 857         struct ldo_regulator *ldo;
 858         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 859         struct regulator_config config = { };
 860
 861         ldo = kzalloc(sizeof(struct ldo_regulator), GFP_KERNEL);
 862
 863         if (!ldo)
 864                 return -ENOMEM;
 865
 866         ldo->desc.name = kstrdup(dev_name(codec->dev), GFP_KERNEL);
 867         if (!ldo->desc.name) {
 868                 kfree(ldo);
 869                 dev_err(codec->dev, "failed to allocate decs name memory\n");
 870                 return -ENOMEM;
 871         }
 872
 873         ldo->desc.type  = REGULATOR_VOLTAGE;
 874         ldo->desc.owner = THIS_MODULE;
 875         ldo->desc.ops   = &ldo_regulator_ops;
 876         ldo->desc.n_voltages = 1;
 877
 878         ldo->codec_data = codec;
 879         ldo->voltage = voltage;
 880
 881         config.dev = codec->dev;
 882         config.driver_data = ldo;
 883         config.init_data = init_data;
 884
 885         ldo->dev = regulator_register(&ldo->desc, &config);
 886         if (IS_ERR(ldo->dev)) {
 887                 int ret = PTR_ERR(ldo->dev);
 888
 889                 dev_err(codec->dev, "failed to register regulator\n");
 890                 kfree(ldo->desc.name);
 891                 kfree(ldo);
 892
 893                 return ret;
 894         }
 895         sgtl5000->ldo = ldo;
 896
 897         return 0;
 898 }
 899
 900 static int ldo_regulator_remove(struct snd_soc_codec *codec)
 901 {
 902         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 903         struct ldo_regulator *ldo = sgtl5000->ldo;
 904
 905         if (!ldo)
 906                 return 0;
 907
 908         regulator_unregister(ldo->dev);
 909         kfree(ldo->desc.name);
 910         kfree(ldo);
 911
 912         return 0;
 913 }
 914 #else
 915 static int ldo_regulator_register(struct snd_soc_codec *codec,
 916                                 struct regulator_init_data *init_data,
 917                                 int voltage)
 918 {
 919         dev_err(codec->dev, "this setup needs regulator support in the kernel\n");
 920         return -EINVAL;
 921 }
 922
 923 static int ldo_regulator_remove(struct snd_soc_codec *codec)
 924 {
 925         return 0;
 926 }
 927 #endif
 928
 929 /*
 930  * set dac bias
 931  * common state changes:
 932  * startup:
 933  * off --> standby --> prepare --> on
 934  * standby --> prepare --> on
 935  *
 936  * stop:
 937  * on --> prepare --> standby
 938  */
 939 static int sgtl5000_set_bias_level(struct snd_soc_codec *codec,
 940                                    enum snd_soc_bias_level level)
 941 {
 942         int ret;
 943         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
 944
 945         switch (level) {
 946         case SND_SOC_BIAS_ON:
 947         case SND_SOC_BIAS_PREPARE:
 948                 break;
 949         case SND_SOC_BIAS_STANDBY:
 950                 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
 951                         ret = regulator_bulk_enable(
 952                                                 ARRAY_SIZE(sgtl5000->supplies),
 953                                                 sgtl5000->supplies);
 954                         if (ret)
 955                                 return ret;
 956                         udelay(10);
 957
 958                         regcache_cache_only(sgtl5000->regmap, false);
 959
 960                         ret = regcache_sync(sgtl5000->regmap);
 961                         if (ret != 0) {
 962                                 dev_err(codec->dev,
 963                                         "Failed to restore cache: %d\n", ret);
 964
 965                                 regcache_cache_only(sgtl5000->regmap, true);
 966                                 regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
 967                                                        sgtl5000->supplies);
 968
 969                                 return ret;
 970                         }
 971                 }
 972
 973                 break;
 974         case SND_SOC_BIAS_OFF:
 975                 regcache_cache_only(sgtl5000->regmap, true);
 976                 regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
 977                                         sgtl5000->supplies);
 978                 break;
 979         }
 980
 981         return 0;
 982 }
 983
 984 #define SGTL5000_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
 985                         SNDRV_PCM_FMTBIT_S20_3LE |\
 986                         SNDRV_PCM_FMTBIT_S24_LE |\
 987                         SNDRV_PCM_FMTBIT_S32_LE)
 988
 989 static const struct snd_soc_dai_ops sgtl5000_ops = {
 990         .hw_params = sgtl5000_pcm_hw_params,
 991         .digital_mute = sgtl5000_digital_mute,
 992         .set_fmt = sgtl5000_set_dai_fmt,
 993         .set_sysclk = sgtl5000_set_dai_sysclk,
 994 };
 995
 996 static struct snd_soc_dai_driver sgtl5000_dai = {
 997         .name = "sgtl5000",
 998         .playback = {
 999                 .stream_name = "Playback",
1000                 .channels_min = 1,
1001                 .channels_max = 2,
1002                 /*
1003                  * only support 8~48K + 96K,
1004                  * TODO modify hw_param to support more
1005                  */
1006                 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_96000,
1007                 .formats = SGTL5000_FORMATS,
1008         },
1009         .capture = {
1010                 .stream_name = "Capture",
1011                 .channels_min = 1,
1012                 .channels_max = 2,
1013                 .rates = SNDRV_PCM_RATE_8000_48000 | SNDRV_PCM_RATE_96000,
1014                 .formats = SGTL5000_FORMATS,
1015         },
1016         .ops = &sgtl5000_ops,
1017         .symmetric_rates = 1,
1018 };
1019
1020 static bool sgtl5000_volatile(struct device *dev, unsigned int reg)
1021 {
1022         switch (reg) {
1023         case SGTL5000_CHIP_ID:
1024         case SGTL5000_CHIP_ADCDAC_CTRL:
1025         case SGTL5000_CHIP_ANA_STATUS:
1026                 return true;
1027         }
1028
1029         return false;
1030 }
1031
1032 static bool sgtl5000_readable(struct device *dev, unsigned int reg)
1033 {
1034         switch (reg) {
1035         case SGTL5000_CHIP_ID:
1036         case SGTL5000_CHIP_DIG_POWER:
1037         case SGTL5000_CHIP_CLK_CTRL:
1038         case SGTL5000_CHIP_I2S_CTRL:
1039         case SGTL5000_CHIP_SSS_CTRL:
1040         case SGTL5000_CHIP_ADCDAC_CTRL:
1041         case SGTL5000_CHIP_DAC_VOL:
1042         case SGTL5000_CHIP_PAD_STRENGTH:
1043         case SGTL5000_CHIP_ANA_ADC_CTRL:
1044         case SGTL5000_CHIP_ANA_HP_CTRL:
1045         case SGTL5000_CHIP_ANA_CTRL:
1046         case SGTL5000_CHIP_LINREG_CTRL:
1047         case SGTL5000_CHIP_REF_CTRL:
1048         case SGTL5000_CHIP_MIC_CTRL:
1049         case SGTL5000_CHIP_LINE_OUT_CTRL:
1050         case SGTL5000_CHIP_LINE_OUT_VOL:
1051         case SGTL5000_CHIP_ANA_POWER:
1052         case SGTL5000_CHIP_PLL_CTRL:
1053         case SGTL5000_CHIP_CLK_TOP_CTRL:
1054         case SGTL5000_CHIP_ANA_STATUS:
1055         case SGTL5000_CHIP_SHORT_CTRL:
1056         case SGTL5000_CHIP_ANA_TEST2:
1057         case SGTL5000_DAP_CTRL:
1058         case SGTL5000_DAP_PEQ:
1059         case SGTL5000_DAP_BASS_ENHANCE:
1060         case SGTL5000_DAP_BASS_ENHANCE_CTRL:
1061         case SGTL5000_DAP_AUDIO_EQ:
1062         case SGTL5000_DAP_SURROUND:
1063         case SGTL5000_DAP_FLT_COEF_ACCESS:
1064         case SGTL5000_DAP_COEF_WR_B0_MSB:
1065         case SGTL5000_DAP_COEF_WR_B0_LSB:
1066         case SGTL5000_DAP_EQ_BASS_BAND0:
1067         case SGTL5000_DAP_EQ_BASS_BAND1:
1068         case SGTL5000_DAP_EQ_BASS_BAND2:
1069         case SGTL5000_DAP_EQ_BASS_BAND3:
1070         case SGTL5000_DAP_EQ_BASS_BAND4:
1071         case SGTL5000_DAP_MAIN_CHAN:
1072         case SGTL5000_DAP_MIX_CHAN:
1073         case SGTL5000_DAP_AVC_CTRL:
1074         case SGTL5000_DAP_AVC_THRESHOLD:
1075         case SGTL5000_DAP_AVC_ATTACK:
1076         case SGTL5000_DAP_AVC_DECAY:
1077         case SGTL5000_DAP_COEF_WR_B1_MSB:
1078         case SGTL5000_DAP_COEF_WR_B1_LSB:
1079         case SGTL5000_DAP_COEF_WR_B2_MSB:
1080         case SGTL5000_DAP_COEF_WR_B2_LSB:
1081         case SGTL5000_DAP_COEF_WR_A1_MSB:
1082         case SGTL5000_DAP_COEF_WR_A1_LSB:
1083         case SGTL5000_DAP_COEF_WR_A2_MSB:
1084         case SGTL5000_DAP_COEF_WR_A2_LSB:
1085                 return true;
1086
1087         default:
1088                 return false;
1089         }
1090 }
1091
1092 /*
1093  * This precalculated table contains all (vag_val * 100 / lo_calcntrl) results
1094  * to select an appropriate lo_vol_* in SGTL5000_CHIP_LINE_OUT_VOL
1095  * The calculatation was done for all possible register values which
1096  * is the array index and the following formula: 10^((idx−15)/40) * 100
1097  */
1098 static const u8 vol_quot_table[] = {
1099         42, 45, 47, 50, 53, 56, 60, 63,
1100         67, 71, 75, 79, 84, 89, 94, 100,
1101         106, 112, 119, 126, 133, 141, 150, 158,
1102         168, 178, 188, 200, 211, 224, 237, 251
1103 };
1104
1105 /*
1106  * sgtl5000 has 3 internal power supplies:
1107  * 1. VAG, normally set to vdda/2
1108  * 2. charge pump, set to different value
1109  *      according to voltage of vdda and vddio
1110  * 3. line out VAG, normally set to vddio/2
1111  *
1112  * and should be set according to:
1113  * 1. vddd provided by external or not
1114  * 2. vdda and vddio voltage value. > 3.1v or not
1115  * 3. chip revision >=0x11 or not. If >=0x11, not use external vddd.
1116  */
1117 static int sgtl5000_set_power_regs(struct snd_soc_codec *codec)
1118 {
1119         int vddd;
1120         int vdda;
1121         int vddio;
1122         u16 ana_pwr;
1123         u16 lreg_ctrl;
1124         int vag;
1125         int lo_vag;
1126         int vol_quot;
1127         int lo_vol;
1128         size_t i;
1129         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
1130
1131         vdda  = regulator_get_voltage(sgtl5000->supplies[VDDA].consumer);
1132         vddio = regulator_get_voltage(sgtl5000->supplies[VDDIO].consumer);
1133         vddd  = regulator_get_voltage(sgtl5000->supplies[VDDD].consumer);
1134
1135         vdda  = vdda / 1000;
1136         vddio = vddio / 1000;
1137         vddd  = vddd / 1000;
1138
1139         if (vdda <= 0 || vddio <= 0 || vddd < 0) {
1140                 dev_err(codec->dev, "regulator voltage not set correctly\n");
1141
1142                 return -EINVAL;
1143         }
1144
1145         /* according to datasheet, maximum voltage of supplies */
1146         if (vdda > 3600 || vddio > 3600 || vddd > 1980) {
1147                 dev_err(codec->dev,
1148                         "exceed max voltage vdda %dmV vddio %dmV vddd %dmV\n",
1149                         vdda, vddio, vddd);
1150
1151                 return -EINVAL;
1152         }
1153
1154         /* reset value */
1155         ana_pwr = snd_soc_read(codec, SGTL5000_CHIP_ANA_POWER);
1156         ana_pwr |= SGTL5000_DAC_STEREO |
1157                         SGTL5000_ADC_STEREO |
1158                         SGTL5000_REFTOP_POWERUP;
1159         lreg_ctrl = snd_soc_read(codec, SGTL5000_CHIP_LINREG_CTRL);
1160
1161         if (vddio < 3100 && vdda < 3100) {
1162                 /* enable internal oscillator used for charge pump */
1163                 snd_soc_update_bits(codec, SGTL5000_CHIP_CLK_TOP_CTRL,
1164                                         SGTL5000_INT_OSC_EN,
1165                                         SGTL5000_INT_OSC_EN);
1166                 /* Enable VDDC charge pump */
1167                 ana_pwr |= SGTL5000_VDDC_CHRGPMP_POWERUP;
1168         } else if (vddio >= 3100 && vdda >= 3100) {
1169                 ana_pwr &= ~SGTL5000_VDDC_CHRGPMP_POWERUP;
1170                 /* VDDC use VDDIO rail */
1171                 lreg_ctrl |= SGTL5000_VDDC_ASSN_OVRD;
1172                 lreg_ctrl |= SGTL5000_VDDC_MAN_ASSN_VDDIO <<
1173                             SGTL5000_VDDC_MAN_ASSN_SHIFT;
1174         }
1175
1176         snd_soc_write(codec, SGTL5000_CHIP_LINREG_CTRL, lreg_ctrl);
1177
1178         snd_soc_write(codec, SGTL5000_CHIP_ANA_POWER, ana_pwr);
1179
1180         /* set voltage to register */
1181         snd_soc_update_bits(codec, SGTL5000_CHIP_LINREG_CTRL,
1182                                 SGTL5000_LINREG_VDDD_MASK, 0x8);
1183
1184         /*
1185          * if vddd linear reg has been enabled,
1186          * simple digital supply should be clear to get
1187          * proper VDDD voltage.
1188          */
1189         if (ana_pwr & SGTL5000_LINEREG_D_POWERUP)
1190                 snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
1191                                 SGTL5000_LINREG_SIMPLE_POWERUP,
1192                                 0);
1193         else
1194                 snd_soc_update_bits(codec, SGTL5000_CHIP_ANA_POWER,
1195                                 SGTL5000_LINREG_SIMPLE_POWERUP |
1196                                 SGTL5000_STARTUP_POWERUP,
1197                                 0);
1198
1199         /*
1200          * set ADC/DAC VAG to vdda / 2,
1201          * should stay in range (0.8v, 1.575v)
1202          */
1203         vag = vdda / 2;
1204         if (vag <= SGTL5000_ANA_GND_BASE)
1205                 vag = 0;
1206         else if (vag >= SGTL5000_ANA_GND_BASE + SGTL5000_ANA_GND_STP *
1207                  (SGTL5000_ANA_GND_MASK >> SGTL5000_ANA_GND_SHIFT))
1208                 vag = SGTL5000_ANA_GND_MASK >> SGTL5000_ANA_GND_SHIFT;
1209         else
1210                 vag = (vag - SGTL5000_ANA_GND_BASE) / SGTL5000_ANA_GND_STP;
1211
1212         snd_soc_update_bits(codec, SGTL5000_CHIP_REF_CTRL,
1213                         SGTL5000_ANA_GND_MASK, vag << SGTL5000_ANA_GND_SHIFT);
1214
1215         /* set line out VAG to vddio / 2, in range (0.8v, 1.675v) */
1216         lo_vag = vddio / 2;
1217         if (lo_vag <= SGTL5000_LINE_OUT_GND_BASE)
1218                 lo_vag = 0;
1219         else if (lo_vag >= SGTL5000_LINE_OUT_GND_BASE +
1220                 SGTL5000_LINE_OUT_GND_STP * SGTL5000_LINE_OUT_GND_MAX)
1221                 lo_vag = SGTL5000_LINE_OUT_GND_MAX;
1222         else
1223                 lo_vag = (lo_vag - SGTL5000_LINE_OUT_GND_BASE) /
1224                     SGTL5000_LINE_OUT_GND_STP;
1225
1226         snd_soc_update_bits(codec, SGTL5000_CHIP_LINE_OUT_CTRL,
1227                         SGTL5000_LINE_OUT_CURRENT_MASK |
1228                         SGTL5000_LINE_OUT_GND_MASK,
1229                         lo_vag << SGTL5000_LINE_OUT_GND_SHIFT |
1230                         SGTL5000_LINE_OUT_CURRENT_360u <<
1231                                 SGTL5000_LINE_OUT_CURRENT_SHIFT);
1232
1233         /*
1234          * Set lineout output level in range (0..31)
1235          * the same value is used for right and left channel
1236          *
1237          * Searching for a suitable index solving this formula:
1238          * idx = 40 * log10(vag_val / lo_cagcntrl) + 15
1239          */
1240         vol_quot = (vag * 100) / lo_vag;
1241         lo_vol = 0;
1242         for (i = 0; i < ARRAY_SIZE(vol_quot_table); i++) {
1243                 if (vol_quot >= vol_quot_table[i])
1244                         lo_vol = i;
1245                 else
1246                         break;
1247         }
1248
1249         snd_soc_update_bits(codec, SGTL5000_CHIP_LINE_OUT_VOL,
1250                 SGTL5000_LINE_OUT_VOL_RIGHT_MASK |
1251                 SGTL5000_LINE_OUT_VOL_LEFT_MASK,
1252                 lo_vol << SGTL5000_LINE_OUT_VOL_RIGHT_SHIFT |
1253                 lo_vol << SGTL5000_LINE_OUT_VOL_LEFT_SHIFT);
1254
1255         return 0;
1256 }
1257
1258 static int sgtl5000_replace_vddd_with_ldo(struct snd_soc_codec *codec)
1259 {
1260         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
1261         int ret;
1262
1263         /* set internal ldo to 1.2v */
1264         ret = ldo_regulator_register(codec, &ldo_init_data, LDO_VOLTAGE);
1265         if (ret) {
1266                 dev_err(codec->dev,
1267                         "Failed to register vddd internal supplies: %d\n", ret);
1268                 return ret;
1269         }
1270
1271         sgtl5000->supplies[VDDD].supply = LDO_CONSUMER_NAME;
1272
1273         dev_info(codec->dev, "Using internal LDO instead of VDDD\n");
1274         return 0;
1275 }
1276
1277 static int sgtl5000_enable_regulators(struct snd_soc_codec *codec)
1278 {
1279         int ret;
1280         int i;
1281         int external_vddd = 0;
1282         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
1283         struct regulator *vddd;
1284
1285         for (i = 0; i < ARRAY_SIZE(sgtl5000->supplies); i++)
1286                 sgtl5000->supplies[i].supply = supply_names[i];
1287
1288         /* External VDDD only works before revision 0x11 */
1289         if (sgtl5000->revision < 0x11) {
1290                 vddd = regulator_get_optional(codec->dev, "VDDD");
1291                 if (IS_ERR(vddd)) {
1292                         /* See if it's just not registered yet */
1293                         if (PTR_ERR(vddd) == -EPROBE_DEFER)
1294                                 return -EPROBE_DEFER;
1295                 } else {
1296                         external_vddd = 1;
1297                         regulator_put(vddd);
1298                 }
1299         }
1300
1301         if (!external_vddd) {
1302                 ret = sgtl5000_replace_vddd_with_ldo(codec);
1303                 if (ret)
1304                         return ret;
1305         }
1306
1307         ret = regulator_bulk_get(codec->dev, ARRAY_SIZE(sgtl5000->supplies),
1308                                  sgtl5000->supplies);
1309         if (ret)
1310                 goto err_ldo_remove;
1311
1312         ret = regulator_bulk_enable(ARRAY_SIZE(sgtl5000->supplies),
1313                                         sgtl5000->supplies);
1314         if (ret)
1315                 goto err_regulator_free;
1316
1317         /* wait for all power rails bring up */
1318         udelay(10);
1319
1320         return 0;
1321
1322 err_regulator_free:
1323         regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
1324                                 sgtl5000->supplies);
1325 err_ldo_remove:
1326         if (!external_vddd)
1327                 ldo_regulator_remove(codec);
1328         return ret;
1329
1330 }
1331
1332 static int sgtl5000_probe(struct snd_soc_codec *codec)
1333 {
1334         int ret;
1335         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
1336
1337         ret = sgtl5000_enable_regulators(codec);
1338         if (ret)
1339                 return ret;
1340
1341         /* power up sgtl5000 */
1342         ret = sgtl5000_set_power_regs(codec);
1343         if (ret)
1344                 goto err;
1345
1346         /* enable small pop, introduce 400ms delay in turning off */
1347         snd_soc_update_bits(codec, SGTL5000_CHIP_REF_CTRL,
1348                                 SGTL5000_SMALL_POP, 1);
1349
1350         /* disable short cut detector */
1351         snd_soc_write(codec, SGTL5000_CHIP_SHORT_CTRL, 0);
1352
1353         /*
1354          * set i2s as default input of sound switch
1355          * TODO: add sound switch to control and dapm widge.
1356          */
1357         snd_soc_write(codec, SGTL5000_CHIP_SSS_CTRL,
1358                         SGTL5000_DAC_SEL_I2S_IN << SGTL5000_DAC_SEL_SHIFT);
1359         snd_soc_write(codec, SGTL5000_CHIP_DIG_POWER,
1360                         SGTL5000_ADC_EN | SGTL5000_DAC_EN);
1361
1362         /* enable dac volume ramp by default */
1363         snd_soc_write(codec, SGTL5000_CHIP_ADCDAC_CTRL,
1364                         SGTL5000_DAC_VOL_RAMP_EN |
1365                         SGTL5000_DAC_MUTE_RIGHT |
1366                         SGTL5000_DAC_MUTE_LEFT);
1367
1368         snd_soc_write(codec, SGTL5000_CHIP_PAD_STRENGTH, 0x015f);
1369
1370         snd_soc_write(codec, SGTL5000_CHIP_ANA_CTRL,
1371                         SGTL5000_HP_ZCD_EN |
1372                         SGTL5000_ADC_ZCD_EN);
1373
1374         snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
1375                         SGTL5000_BIAS_R_MASK,
1376                         sgtl5000->micbias_resistor << SGTL5000_BIAS_R_SHIFT);
1377
1378         snd_soc_update_bits(codec, SGTL5000_CHIP_MIC_CTRL,
1379                         SGTL5000_BIAS_VOLT_MASK,
1380                         sgtl5000->micbias_voltage << SGTL5000_BIAS_VOLT_SHIFT);
1381         /*
1382          * disable DAP
1383          * TODO:
1384          * Enable DAP in kcontrol and dapm.
1385          */
1386         snd_soc_write(codec, SGTL5000_DAP_CTRL, 0);
1387
1388         return 0;
1389
1390 err:
1391         regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
1392                                                 sgtl5000->supplies);
1393         regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
1394                                 sgtl5000->supplies);
1395         ldo_regulator_remove(codec);
1396
1397         return ret;
1398 }
1399
1400 static int sgtl5000_remove(struct snd_soc_codec *codec)
1401 {
1402         struct sgtl5000_priv *sgtl5000 = snd_soc_codec_get_drvdata(codec);
1403
1404         regulator_bulk_disable(ARRAY_SIZE(sgtl5000->supplies),
1405                                                 sgtl5000->supplies);
1406         regulator_bulk_free(ARRAY_SIZE(sgtl5000->supplies),
1407                                 sgtl5000->supplies);
1408         ldo_regulator_remove(codec);
1409
1410         return 0;
1411 }
1412
1413 static struct snd_soc_codec_driver sgtl5000_driver = {
1414         .probe = sgtl5000_probe,
1415         .remove = sgtl5000_remove,
1416         .set_bias_level = sgtl5000_set_bias_level,
1417         .suspend_bias_off = true,
1418         .controls = sgtl5000_snd_controls,
1419         .num_controls = ARRAY_SIZE(sgtl5000_snd_controls),
1420         .dapm_widgets = sgtl5000_dapm_widgets,
1421         .num_dapm_widgets = ARRAY_SIZE(sgtl5000_dapm_widgets),
1422         .dapm_routes = sgtl5000_dapm_routes,
1423         .num_dapm_routes = ARRAY_SIZE(sgtl5000_dapm_routes),
1424 };
1425
1426 static const struct regmap_config sgtl5000_regmap = {
1427         .reg_bits = 16,
1428         .val_bits = 16,
1429         .reg_stride = 2,
1430
1431         .max_register = SGTL5000_MAX_REG_OFFSET,
1432         .volatile_reg = sgtl5000_volatile,
1433         .readable_reg = sgtl5000_readable,
1434
1435         .cache_type = REGCACHE_RBTREE,
1436         .reg_defaults = sgtl5000_reg_defaults,
1437         .num_reg_defaults = ARRAY_SIZE(sgtl5000_reg_defaults),
1438 };
1439
1440 /*
1441  * Write all the default values from sgtl5000_reg_defaults[] array into the
1442  * sgtl5000 registers, to make sure we always start with the sane registers
1443  * values as stated in the datasheet.
1444  *
1445  * Since sgtl5000 does not have a reset line, nor a reset command in software,
1446  * we follow this approach to guarantee we always start from the default values
1447  * and avoid problems like, not being able to probe after an audio playback
1448  * followed by a system reset or a 'reboot' command in Linux
1449  */
1450 static int sgtl5000_fill_defaults(struct sgtl5000_priv *sgtl5000)
1451 {
1452         int i, ret, val, index;
1453
1454         for (i = 0; i < ARRAY_SIZE(sgtl5000_reg_defaults); i++) {
1455                 val = sgtl5000_reg_defaults[i].def;
1456                 index = sgtl5000_reg_defaults[i].reg;
1457                 ret = regmap_write(sgtl5000->regmap, index, val);
1458                 if (ret)
1459                         return ret;
1460         }
1461
1462         return 0;
1463 }
1464
1465 static int sgtl5000_i2c_probe(struct i2c_client *client,
1466                               const struct i2c_device_id *id)
1467 {
1468         struct sgtl5000_priv *sgtl5000;
1469         int ret, reg, rev;
1470         struct device_node *np = client->dev.of_node;
1471         u32 value;
1472
1473         sgtl5000 = devm_kzalloc(&client->dev, sizeof(*sgtl5000), GFP_KERNEL);
1474         if (!sgtl5000)
1475                 return -ENOMEM;
1476
1477         sgtl5000->regmap = devm_regmap_init_i2c(client, &sgtl5000_regmap);
1478         if (IS_ERR(sgtl5000->regmap)) {
1479                 ret = PTR_ERR(sgtl5000->regmap);
1480                 dev_err(&client->dev, "Failed to allocate regmap: %d\n", ret);
1481                 return ret;
1482         }
1483
1484         sgtl5000->mclk = devm_clk_get(&client->dev, NULL);
1485         if (IS_ERR(sgtl5000->mclk)) {
1486                 ret = PTR_ERR(sgtl5000->mclk);
1487                 dev_err(&client->dev, "Failed to get mclock: %d\n", ret);
1488                 /* Defer the probe to see if the clk will be provided later */
1489                 if (ret == -ENOENT)
1490                         return -EPROBE_DEFER;
1491                 return ret;
1492         }
1493
1494         ret = clk_prepare_enable(sgtl5000->mclk);
1495         if (ret)
1496                 return ret;
1497
1498         /* Need 8 clocks before I2C accesses */
1499         udelay(1);
1500
1501         /* read chip information */
1502         ret = regmap_read(sgtl5000->regmap, SGTL5000_CHIP_ID, &reg);
1503         if (ret)
1504                 goto disable_clk;
1505
1506         if (((reg & SGTL5000_PARTID_MASK) >> SGTL5000_PARTID_SHIFT) !=
1507             SGTL5000_PARTID_PART_ID) {
1508                 dev_err(&client->dev,
1509                         "Device with ID register %x is not a sgtl5000\n", reg);
1510                 ret = -ENODEV;
1511                 goto disable_clk;
1512         }
1513
1514         rev = (reg & SGTL5000_REVID_MASK) >> SGTL5000_REVID_SHIFT;
1515         dev_info(&client->dev, "sgtl5000 revision 0x%x\n", rev);
1516         sgtl5000->revision = rev;
1517
1518         if (np) {
1519                 if (!of_property_read_u32(np,
1520                         "micbias-resistor-k-ohms", &value)) {
1521                         switch (value) {
1522                         case SGTL5000_MICBIAS_OFF:
1523                                 sgtl5000->micbias_resistor = 0;
1524                                 break;
1525                         case SGTL5000_MICBIAS_2K:
1526                                 sgtl5000->micbias_resistor = 1;
1527                                 break;
1528                         case SGTL5000_MICBIAS_4K:
1529                                 sgtl5000->micbias_resistor = 2;
1530                                 break;
1531                         case SGTL5000_MICBIAS_8K:
1532                                 sgtl5000->micbias_resistor = 3;
1533                                 break;
1534                         default:
1535                                 sgtl5000->micbias_resistor = 2;
1536                                 dev_err(&client->dev,
1537                                         "Unsuitable MicBias resistor\n");
1538                         }
1539                 } else {
1540                         /* default is 4Kohms */
1541                         sgtl5000->micbias_resistor = 2;
1542                 }
1543                 if (!of_property_read_u32(np,
1544                         "micbias-voltage-m-volts", &value)) {
1545                         /* 1250mV => 0 */
1546                         /* steps of 250mV */
1547                         if ((value >= 1250) && (value <= 3000))
1548                                 sgtl5000->micbias_voltage = (value / 250) - 5;
1549                         else {
1550                                 sgtl5000->micbias_voltage = 0;
1551                                 dev_err(&client->dev,
1552                                         "Unsuitable MicBias voltage\n");
1553                         }
1554                 } else {
1555                         sgtl5000->micbias_voltage = 0;
1556                 }
1557         }
1558
1559         i2c_set_clientdata(client, sgtl5000);
1560
1561         /* Ensure sgtl5000 will start with sane register values */
1562         ret = sgtl5000_fill_defaults(sgtl5000);
1563         if (ret)
1564                 goto disable_clk;
1565
1566         ret = snd_soc_register_codec(&client->dev,
1567                         &sgtl5000_driver, &sgtl5000_dai, 1);
1568         if (ret)
1569                 goto disable_clk;
1570
1571         return 0;
1572
1573 disable_clk:
1574         clk_disable_unprepare(sgtl5000->mclk);
1575         return ret;
1576 }
1577
1578 static int sgtl5000_i2c_remove(struct i2c_client *client)
1579 {
1580         struct sgtl5000_priv *sgtl5000 = i2c_get_clientdata(client);
1581
1582         snd_soc_unregister_codec(&client->dev);
1583         clk_disable_unprepare(sgtl5000->mclk);
1584         return 0;
1585 }
1586
1587 static const struct i2c_device_id sgtl5000_id[] = {
1588         {"sgtl5000", 0},
1589         {},
1590 };
1591
1592 MODULE_DEVICE_TABLE(i2c, sgtl5000_id);
1593
1594 static const struct of_device_id sgtl5000_dt_ids[] = {
1595         { .compatible = "fsl,sgtl5000", },
1596         { /* sentinel */ }
1597 };
1598 MODULE_DEVICE_TABLE(of, sgtl5000_dt_ids);
1599
1600 static struct i2c_driver sgtl5000_i2c_driver = {
1601         .driver = {
1602                    .name = "sgtl5000",
1603                    .of_match_table = sgtl5000_dt_ids,
1604                    },
1605         .probe = sgtl5000_i2c_probe,
1606         .remove = sgtl5000_i2c_remove,
1607         .id_table = sgtl5000_id,
1608 };
1609
1610 module_i2c_driver(sgtl5000_i2c_driver);
1611
1612 MODULE_DESCRIPTION("Freescale SGTL5000 ALSA SoC Codec Driver");
1613 MODULE_AUTHOR("Zeng Zhaoming <zengzm.kernel@gmail.com>");
1614 MODULE_LICENSE("GPL");