sound/soc/codecs/nau8825.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Nuvoton NAU8825 audio codec driver
   4  *
   5  * Copyright 2015 Google Chromium project.
   6  *  Author: Anatol Pomozov <anatol@chromium.org>
   7  * Copyright 2015 Nuvoton Technology Corp.
   8  *  Co-author: Meng-Huang Kuo <mhkuo@nuvoton.com>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/delay.h>
  13 #include <linux/init.h>
  14 #include <linux/i2c.h>
  15 #include <linux/regmap.h>
  16 #include <linux/slab.h>
  17 #include <linux/clk.h>
  18 #include <linux/acpi.h>
  19 #include <linux/math64.h>
  20 #include <linux/semaphore.h>
  21
  22 #include <sound/initval.h>
  23 #include <sound/tlv.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 #include <sound/pcm_params.h>
  27 #include <sound/soc.h>
  28 #include <sound/jack.h>
  29
  30
  31 #include "nau8825.h"
  32
  33
  34 #define NUVOTON_CODEC_DAI "nau8825-hifi"
  35
  36 #define NAU_FREF_MAX 13500000
  37 #define NAU_FVCO_MAX 124000000
  38 #define NAU_FVCO_MIN 90000000
  39
  40 /* cross talk suppression detection */
  41 #define LOG10_MAGIC 646456993
  42 #define GAIN_AUGMENT 22500
  43 #define SIDETONE_BASE 207000
  44
  45 /* the maximum frequency of CLK_ADC and CLK_DAC */
  46 #define CLK_DA_AD_MAX 6144000
  47
  48 static int nau8825_configure_sysclk(struct nau8825 *nau8825,
  49                 int clk_id, unsigned int freq);
  50
  51 struct nau8825_fll {
  52         int mclk_src;
  53         int ratio;
  54         int fll_frac;
  55         int fll_int;
  56         int clk_ref_div;
  57 };
  58
  59 struct nau8825_fll_attr {
  60         unsigned int param;
  61         unsigned int val;
  62 };
  63
  64 /* scaling for mclk from sysclk_src output */
  65 static const struct nau8825_fll_attr mclk_src_scaling[] = {
  66         { 1, 0x0 },
  67         { 2, 0x2 },
  68         { 4, 0x3 },
  69         { 8, 0x4 },
  70         { 16, 0x5 },
  71         { 32, 0x6 },
  72         { 3, 0x7 },
  73         { 6, 0xa },
  74         { 12, 0xb },
  75         { 24, 0xc },
  76         { 48, 0xd },
  77         { 96, 0xe },
  78         { 5, 0xf },
  79 };
  80
  81 /* ratio for input clk freq */
  82 static const struct nau8825_fll_attr fll_ratio[] = {
  83         { 512000, 0x01 },
  84         { 256000, 0x02 },
  85         { 128000, 0x04 },
  86         { 64000, 0x08 },
  87         { 32000, 0x10 },
  88         { 8000, 0x20 },
  89         { 4000, 0x40 },
  90 };
  91
  92 static const struct nau8825_fll_attr fll_pre_scalar[] = {
  93         { 1, 0x0 },
  94         { 2, 0x1 },
  95         { 4, 0x2 },
  96         { 8, 0x3 },
  97 };
  98
  99 /* over sampling rate */
 100 struct nau8825_osr_attr {
 101         unsigned int osr;
 102         unsigned int clk_src;
 103 };
 104
 105 static const struct nau8825_osr_attr osr_dac_sel[] = {
 106         { 64, 2 },      /* OSR 64, SRC 1/4 */
 107         { 256, 0 },     /* OSR 256, SRC 1 */
 108         { 128, 1 },     /* OSR 128, SRC 1/2 */
 109         { 0, 0 },
 110         { 32, 3 },      /* OSR 32, SRC 1/8 */
 111 };
 112
 113 static const struct nau8825_osr_attr osr_adc_sel[] = {
 114         { 32, 3 },      /* OSR 32, SRC 1/8 */
 115         { 64, 2 },      /* OSR 64, SRC 1/4 */
 116         { 128, 1 },     /* OSR 128, SRC 1/2 */
 117         { 256, 0 },     /* OSR 256, SRC 1 */
 118 };
 119
 120 static const struct reg_default nau8825_reg_defaults[] = {
 121         { NAU8825_REG_ENA_CTRL, 0x00ff },
 122         { NAU8825_REG_IIC_ADDR_SET, 0x0 },
 123         { NAU8825_REG_CLK_DIVIDER, 0x0050 },
 124         { NAU8825_REG_FLL1, 0x0 },
 125         { NAU8825_REG_FLL2, 0x3126 },
 126         { NAU8825_REG_FLL3, 0x0008 },
 127         { NAU8825_REG_FLL4, 0x0010 },
 128         { NAU8825_REG_FLL5, 0x0 },
 129         { NAU8825_REG_FLL6, 0x6000 },
 130         { NAU8825_REG_FLL_VCO_RSV, 0xf13c },
 131         { NAU8825_REG_HSD_CTRL, 0x000c },
 132         { NAU8825_REG_JACK_DET_CTRL, 0x0 },
 133         { NAU8825_REG_INTERRUPT_MASK, 0x0 },
 134         { NAU8825_REG_INTERRUPT_DIS_CTRL, 0xffff },
 135         { NAU8825_REG_SAR_CTRL, 0x0015 },
 136         { NAU8825_REG_KEYDET_CTRL, 0x0110 },
 137         { NAU8825_REG_VDET_THRESHOLD_1, 0x0 },
 138         { NAU8825_REG_VDET_THRESHOLD_2, 0x0 },
 139         { NAU8825_REG_VDET_THRESHOLD_3, 0x0 },
 140         { NAU8825_REG_VDET_THRESHOLD_4, 0x0 },
 141         { NAU8825_REG_GPIO34_CTRL, 0x0 },
 142         { NAU8825_REG_GPIO12_CTRL, 0x0 },
 143         { NAU8825_REG_TDM_CTRL, 0x0 },
 144         { NAU8825_REG_I2S_PCM_CTRL1, 0x000b },
 145         { NAU8825_REG_I2S_PCM_CTRL2, 0x8010 },
 146         { NAU8825_REG_LEFT_TIME_SLOT, 0x0 },
 147         { NAU8825_REG_RIGHT_TIME_SLOT, 0x0 },
 148         { NAU8825_REG_BIQ_CTRL, 0x0 },
 149         { NAU8825_REG_BIQ_COF1, 0x0 },
 150         { NAU8825_REG_BIQ_COF2, 0x0 },
 151         { NAU8825_REG_BIQ_COF3, 0x0 },
 152         { NAU8825_REG_BIQ_COF4, 0x0 },
 153         { NAU8825_REG_BIQ_COF5, 0x0 },
 154         { NAU8825_REG_BIQ_COF6, 0x0 },
 155         { NAU8825_REG_BIQ_COF7, 0x0 },
 156         { NAU8825_REG_BIQ_COF8, 0x0 },
 157         { NAU8825_REG_BIQ_COF9, 0x0 },
 158         { NAU8825_REG_BIQ_COF10, 0x0 },
 159         { NAU8825_REG_ADC_RATE, 0x0010 },
 160         { NAU8825_REG_DAC_CTRL1, 0x0001 },
 161         { NAU8825_REG_DAC_CTRL2, 0x0 },
 162         { NAU8825_REG_DAC_DGAIN_CTRL, 0x0 },
 163         { NAU8825_REG_ADC_DGAIN_CTRL, 0x00cf },
 164         { NAU8825_REG_MUTE_CTRL, 0x0 },
 165         { NAU8825_REG_HSVOL_CTRL, 0x0 },
 166         { NAU8825_REG_DACL_CTRL, 0x02cf },
 167         { NAU8825_REG_DACR_CTRL, 0x00cf },
 168         { NAU8825_REG_ADC_DRC_KNEE_IP12, 0x1486 },
 169         { NAU8825_REG_ADC_DRC_KNEE_IP34, 0x0f12 },
 170         { NAU8825_REG_ADC_DRC_SLOPES, 0x25ff },
 171         { NAU8825_REG_ADC_DRC_ATKDCY, 0x3457 },
 172         { NAU8825_REG_DAC_DRC_KNEE_IP12, 0x1486 },
 173         { NAU8825_REG_DAC_DRC_KNEE_IP34, 0x0f12 },
 174         { NAU8825_REG_DAC_DRC_SLOPES, 0x25f9 },
 175         { NAU8825_REG_DAC_DRC_ATKDCY, 0x3457 },
 176         { NAU8825_REG_IMM_MODE_CTRL, 0x0 },
 177         { NAU8825_REG_CLASSG_CTRL, 0x0 },
 178         { NAU8825_REG_OPT_EFUSE_CTRL, 0x0 },
 179         { NAU8825_REG_MISC_CTRL, 0x0 },
 180         { NAU8825_REG_BIAS_ADJ, 0x0 },
 181         { NAU8825_REG_TRIM_SETTINGS, 0x0 },
 182         { NAU8825_REG_ANALOG_CONTROL_1, 0x0 },
 183         { NAU8825_REG_ANALOG_CONTROL_2, 0x0 },
 184         { NAU8825_REG_ANALOG_ADC_1, 0x0011 },
 185         { NAU8825_REG_ANALOG_ADC_2, 0x0020 },
 186         { NAU8825_REG_RDAC, 0x0008 },
 187         { NAU8825_REG_MIC_BIAS, 0x0006 },
 188         { NAU8825_REG_BOOST, 0x0 },
 189         { NAU8825_REG_FEPGA, 0x0 },
 190         { NAU8825_REG_POWER_UP_CONTROL, 0x0 },
 191         { NAU8825_REG_CHARGE_PUMP, 0x0 },
 192 };
 193
 194 /* register backup table when cross talk detection */
 195 static struct reg_default nau8825_xtalk_baktab[] = {
 196         { NAU8825_REG_ADC_DGAIN_CTRL, 0x00cf },
 197         { NAU8825_REG_HSVOL_CTRL, 0 },
 198         { NAU8825_REG_DACL_CTRL, 0x00cf },
 199         { NAU8825_REG_DACR_CTRL, 0x02cf },
 200 };
 201
 202 static const unsigned short logtable[256] = {
 203         0x0000, 0x0171, 0x02e0, 0x044e, 0x05ba, 0x0725, 0x088e, 0x09f7,
 204         0x0b5d, 0x0cc3, 0x0e27, 0x0f8a, 0x10eb, 0x124b, 0x13aa, 0x1508,
 205         0x1664, 0x17bf, 0x1919, 0x1a71, 0x1bc8, 0x1d1e, 0x1e73, 0x1fc6,
 206         0x2119, 0x226a, 0x23ba, 0x2508, 0x2656, 0x27a2, 0x28ed, 0x2a37,
 207         0x2b80, 0x2cc8, 0x2e0f, 0x2f54, 0x3098, 0x31dc, 0x331e, 0x345f,
 208         0x359f, 0x36de, 0x381b, 0x3958, 0x3a94, 0x3bce, 0x3d08, 0x3e41,
 209         0x3f78, 0x40af, 0x41e4, 0x4319, 0x444c, 0x457f, 0x46b0, 0x47e1,
 210         0x4910, 0x4a3f, 0x4b6c, 0x4c99, 0x4dc5, 0x4eef, 0x5019, 0x5142,
 211         0x526a, 0x5391, 0x54b7, 0x55dc, 0x5700, 0x5824, 0x5946, 0x5a68,
 212         0x5b89, 0x5ca8, 0x5dc7, 0x5ee5, 0x6003, 0x611f, 0x623a, 0x6355,
 213         0x646f, 0x6588, 0x66a0, 0x67b7, 0x68ce, 0x69e4, 0x6af8, 0x6c0c,
 214         0x6d20, 0x6e32, 0x6f44, 0x7055, 0x7165, 0x7274, 0x7383, 0x7490,
 215         0x759d, 0x76aa, 0x77b5, 0x78c0, 0x79ca, 0x7ad3, 0x7bdb, 0x7ce3,
 216         0x7dea, 0x7ef0, 0x7ff6, 0x80fb, 0x81ff, 0x8302, 0x8405, 0x8507,
 217         0x8608, 0x8709, 0x8809, 0x8908, 0x8a06, 0x8b04, 0x8c01, 0x8cfe,
 218         0x8dfa, 0x8ef5, 0x8fef, 0x90e9, 0x91e2, 0x92db, 0x93d2, 0x94ca,
 219         0x95c0, 0x96b6, 0x97ab, 0x98a0, 0x9994, 0x9a87, 0x9b7a, 0x9c6c,
 220         0x9d5e, 0x9e4f, 0x9f3f, 0xa02e, 0xa11e, 0xa20c, 0xa2fa, 0xa3e7,
 221         0xa4d4, 0xa5c0, 0xa6ab, 0xa796, 0xa881, 0xa96a, 0xaa53, 0xab3c,
 222         0xac24, 0xad0c, 0xadf2, 0xaed9, 0xafbe, 0xb0a4, 0xb188, 0xb26c,
 223         0xb350, 0xb433, 0xb515, 0xb5f7, 0xb6d9, 0xb7ba, 0xb89a, 0xb97a,
 224         0xba59, 0xbb38, 0xbc16, 0xbcf4, 0xbdd1, 0xbead, 0xbf8a, 0xc065,
 225         0xc140, 0xc21b, 0xc2f5, 0xc3cf, 0xc4a8, 0xc580, 0xc658, 0xc730,
 226         0xc807, 0xc8de, 0xc9b4, 0xca8a, 0xcb5f, 0xcc34, 0xcd08, 0xcddc,
 227         0xceaf, 0xcf82, 0xd054, 0xd126, 0xd1f7, 0xd2c8, 0xd399, 0xd469,
 228         0xd538, 0xd607, 0xd6d6, 0xd7a4, 0xd872, 0xd93f, 0xda0c, 0xdad9,
 229         0xdba5, 0xdc70, 0xdd3b, 0xde06, 0xded0, 0xdf9a, 0xe063, 0xe12c,
 230         0xe1f5, 0xe2bd, 0xe385, 0xe44c, 0xe513, 0xe5d9, 0xe69f, 0xe765,
 231         0xe82a, 0xe8ef, 0xe9b3, 0xea77, 0xeb3b, 0xebfe, 0xecc1, 0xed83,
 232         0xee45, 0xef06, 0xefc8, 0xf088, 0xf149, 0xf209, 0xf2c8, 0xf387,
 233         0xf446, 0xf505, 0xf5c3, 0xf680, 0xf73e, 0xf7fb, 0xf8b7, 0xf973,
 234         0xfa2f, 0xfaea, 0xfba5, 0xfc60, 0xfd1a, 0xfdd4, 0xfe8e, 0xff47
 235 };
 236
 237 /**
 238  * nau8825_sema_acquire - acquire the semaphore of nau88l25
 239  * @nau8825:  component to register the codec private data with
 240  * @timeout: how long in jiffies to wait before failure or zero to wait
 241  * until release
 242  *
 243  * Attempts to acquire the semaphore with number of jiffies. If no more
 244  * tasks are allowed to acquire the semaphore, calling this function will
 245  * put the task to sleep. If the semaphore is not released within the
 246  * specified number of jiffies, this function returns.
 247  * If the semaphore is not released within the specified number of jiffies,
 248  * this function returns -ETIME. If the sleep is interrupted by a signal,
 249  * this function will return -EINTR. It returns 0 if the semaphore was
 250  * acquired successfully.
 251  *
 252  * Acquires the semaphore without jiffies. Try to acquire the semaphore
 253  * atomically. Returns 0 if the semaphore has been acquired successfully
 254  * or 1 if it cannot be acquired.
 255  */
 256 static int nau8825_sema_acquire(struct nau8825 *nau8825, long timeout)
 257 {
 258         int ret;
 259
 260         if (timeout) {
 261                 ret = down_timeout(&nau8825->xtalk_sem, timeout);
 262                 if (ret < 0)
 263                         dev_warn(nau8825->dev, "Acquire semaphore timeout\n");
 264         } else {
 265                 ret = down_trylock(&nau8825->xtalk_sem);
 266                 if (ret)
 267                         dev_warn(nau8825->dev, "Acquire semaphore fail\n");
 268         }
 269
 270         return ret;
 271 }
 272
 273 /**
 274  * nau8825_sema_release - release the semaphore of nau88l25
 275  * @nau8825:  component to register the codec private data with
 276  *
 277  * Release the semaphore which may be called from any context and
 278  * even by tasks which have never called down().
 279  */
 280 static inline void nau8825_sema_release(struct nau8825 *nau8825)
 281 {
 282         up(&nau8825->xtalk_sem);
 283 }
 284
 285 /**
 286  * nau8825_sema_reset - reset the semaphore for nau88l25
 287  * @nau8825:  component to register the codec private data with
 288  *
 289  * Reset the counter of the semaphore. Call this function to restart
 290  * a new round task management.
 291  */
 292 static inline void nau8825_sema_reset(struct nau8825 *nau8825)
 293 {
 294         nau8825->xtalk_sem.count = 1;
 295 }
 296
 297 /**
 298  * nau8825_hpvol_ramp - Ramp up the headphone volume change gradually to target level.
 299  *
 300  * @nau8825:  component to register the codec private data with
 301  * @vol_from: the volume to start up
 302  * @vol_to: the target volume
 303  * @step: the volume span to move on
 304  *
 305  * The headphone volume is from 0dB to minimum -54dB and -1dB per step.
 306  * If the volume changes sharp, there is a pop noise heard in headphone. We
 307  * provide the function to ramp up the volume up or down by delaying 10ms
 308  * per step.
 309  */
 310 static void nau8825_hpvol_ramp(struct nau8825 *nau8825,
 311         unsigned int vol_from, unsigned int vol_to, unsigned int step)
 312 {
 313         unsigned int value, volume, ramp_up, from, to;
 314
 315         if (vol_from == vol_to || step == 0) {
 316                 return;
 317         } else if (vol_from < vol_to) {
 318                 ramp_up = true;
 319                 from = vol_from;
 320                 to = vol_to;
 321         } else {
 322                 ramp_up = false;
 323                 from = vol_to;
 324                 to = vol_from;
 325         }
 326         /* only handle volume from 0dB to minimum -54dB */
 327         if (to > NAU8825_HP_VOL_MIN)
 328                 to = NAU8825_HP_VOL_MIN;
 329
 330         for (volume = from; volume < to; volume += step) {
 331                 if (ramp_up)
 332                         value = volume;
 333                 else
 334                         value = to - volume + from;
 335                 regmap_update_bits(nau8825->regmap, NAU8825_REG_HSVOL_CTRL,
 336                         NAU8825_HPL_VOL_MASK | NAU8825_HPR_VOL_MASK,
 337                         (value << NAU8825_HPL_VOL_SFT) | value);
 338                 usleep_range(10000, 10500);
 339         }
 340         if (ramp_up)
 341                 value = to;
 342         else
 343                 value = from;
 344         regmap_update_bits(nau8825->regmap, NAU8825_REG_HSVOL_CTRL,
 345                 NAU8825_HPL_VOL_MASK | NAU8825_HPR_VOL_MASK,
 346                 (value << NAU8825_HPL_VOL_SFT) | value);
 347 }
 348
 349 /**
 350  * nau8825_intlog10_dec3 - Computes log10 of a value
 351  * the result is round off to 3 decimal. This function takes reference to
 352  * dvb-math. The source code locates as the following.
 353  * Linux/drivers/media/dvb-core/dvb_math.c
 354  * @value:  input for log10
 355  *
 356  * return log10(value) * 1000
 357  */
 358 static u32 nau8825_intlog10_dec3(u32 value)
 359 {
 360         u32 msb, logentry, significand, interpolation, log10val;
 361         u64 log2val;
 362
 363         /* first detect the msb (count begins at 0) */
 364         msb = fls(value) - 1;
 365         /**
 366          *      now we use a logtable after the following method:
 367          *
 368          *      log2(2^x * y) * 2^24 = x * 2^24 + log2(y) * 2^24
 369          *      where x = msb and therefore 1 <= y < 2
 370          *      first y is determined by shifting the value left
 371          *      so that msb is bit 31
 372          *              0x00231f56 -> 0x8C7D5800
 373          *      the result is y * 2^31 -> "significand"
 374          *      then the highest 9 bits are used for a table lookup
 375          *      the highest bit is discarded because it's always set
 376          *      the highest nine bits in our example are 100011000
 377          *      so we would use the entry 0x18
 378          */
 379         significand = value << (31 - msb);
 380         logentry = (significand >> 23) & 0xff;
 381         /**
 382          *      last step we do is interpolation because of the
 383          *      limitations of the log table the error is that part of
 384          *      the significand which isn't used for lookup then we
 385          *      compute the ratio between the error and the next table entry
 386          *      and interpolate it between the log table entry used and the
 387          *      next one the biggest error possible is 0x7fffff
 388          *      (in our example it's 0x7D5800)
 389          *      needed value for next table entry is 0x800000
 390          *      so the interpolation is
 391          *      (error / 0x800000) * (logtable_next - logtable_current)
 392          *      in the implementation the division is moved to the end for
 393          *      better accuracy there is also an overflow correction if
 394          *      logtable_next is 256
 395          */
 396         interpolation = ((significand & 0x7fffff) *
 397                 ((logtable[(logentry + 1) & 0xff] -
 398                 logtable[logentry]) & 0xffff)) >> 15;
 399
 400         log2val = ((msb << 24) + (logtable[logentry] << 8) + interpolation);
 401         /**
 402          *      log10(x) = log2(x) * log10(2)
 403          */
 404         log10val = (log2val * LOG10_MAGIC) >> 31;
 405         /**
 406          *      the result is round off to 3 decimal
 407          */
 408         return log10val / ((1 << 24) / 1000);
 409 }
 410
 411 /**
 412  * nau8825_xtalk_sidetone - computes cross talk suppression sidetone gain.
 413  *
 414  * @sig_org: orignal signal level
 415  * @sig_cros: cross talk signal level
 416  *
 417  * The orignal and cross talk signal vlues need to be characterized.
 418  * Once these values have been characterized, this sidetone value
 419  * can be converted to decibel with the equation below.
 420  * sidetone = 20 * log (original signal level / crosstalk signal level)
 421  *
 422  * return cross talk sidetone gain
 423  */
 424 static u32 nau8825_xtalk_sidetone(u32 sig_org, u32 sig_cros)
 425 {
 426         u32 gain, sidetone;
 427
 428         if (WARN_ON(sig_org == 0 || sig_cros == 0))
 429                 return 0;
 430
 431         sig_org = nau8825_intlog10_dec3(sig_org);
 432         sig_cros = nau8825_intlog10_dec3(sig_cros);
 433         if (sig_org >= sig_cros)
 434                 gain = (sig_org - sig_cros) * 20 + GAIN_AUGMENT;
 435         else
 436                 gain = (sig_cros - sig_org) * 20 + GAIN_AUGMENT;
 437         sidetone = SIDETONE_BASE - gain * 2;
 438         sidetone /= 1000;
 439
 440         return sidetone;
 441 }
 442
 443 static int nau8825_xtalk_baktab_index_by_reg(unsigned int reg)
 444 {
 445         int index;
 446
 447         for (index = 0; index < ARRAY_SIZE(nau8825_xtalk_baktab); index++)
 448                 if (nau8825_xtalk_baktab[index].reg == reg)
 449                         return index;
 450         return -EINVAL;
 451 }
 452
 453 static void nau8825_xtalk_backup(struct nau8825 *nau8825)
 454 {
 455         int i;
 456
 457         if (nau8825->xtalk_baktab_initialized)
 458                 return;
 459
 460         /* Backup some register values to backup table */
 461         for (i = 0; i < ARRAY_SIZE(nau8825_xtalk_baktab); i++)
 462                 regmap_read(nau8825->regmap, nau8825_xtalk_baktab[i].reg,
 463                                 &nau8825_xtalk_baktab[i].def);
 464
 465         nau8825->xtalk_baktab_initialized = true;
 466 }
 467
 468 static void nau8825_xtalk_restore(struct nau8825 *nau8825, bool cause_cancel)
 469 {
 470         int i, volume;
 471
 472         if (!nau8825->xtalk_baktab_initialized)
 473                 return;
 474
 475         /* Restore register values from backup table; When the driver restores
 476          * the headphone volume in XTALK_DONE state, it needs recover to
 477          * original level gradually with 3dB per step for less pop noise.
 478          * Otherwise, the restore should do ASAP.
 479          */
 480         for (i = 0; i < ARRAY_SIZE(nau8825_xtalk_baktab); i++) {
 481                 if (!cause_cancel && nau8825_xtalk_baktab[i].reg ==
 482                         NAU8825_REG_HSVOL_CTRL) {
 483                         /* Ramping up the volume change to reduce pop noise */
 484                         volume = nau8825_xtalk_baktab[i].def &
 485                                 NAU8825_HPR_VOL_MASK;
 486                         nau8825_hpvol_ramp(nau8825, 0, volume, 3);
 487                         continue;
 488                 }
 489                 regmap_write(nau8825->regmap, nau8825_xtalk_baktab[i].reg,
 490                                 nau8825_xtalk_baktab[i].def);
 491         }
 492
 493         nau8825->xtalk_baktab_initialized = false;
 494 }
 495
 496 static void nau8825_xtalk_prepare_dac(struct nau8825 *nau8825)
 497 {
 498         /* Enable power of DAC path */
 499         regmap_update_bits(nau8825->regmap, NAU8825_REG_ENA_CTRL,
 500                 NAU8825_ENABLE_DACR | NAU8825_ENABLE_DACL |
 501                 NAU8825_ENABLE_ADC | NAU8825_ENABLE_ADC_CLK |
 502                 NAU8825_ENABLE_DAC_CLK, NAU8825_ENABLE_DACR |
 503                 NAU8825_ENABLE_DACL | NAU8825_ENABLE_ADC |
 504                 NAU8825_ENABLE_ADC_CLK | NAU8825_ENABLE_DAC_CLK);
 505         /* Prevent startup click by letting charge pump to ramp up and
 506          * change bump enable
 507          */
 508         regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 509                 NAU8825_JAMNODCLOW | NAU8825_CHANRGE_PUMP_EN,
 510                 NAU8825_JAMNODCLOW | NAU8825_CHANRGE_PUMP_EN);
 511         /* Enable clock sync of DAC and DAC clock */
 512         regmap_update_bits(nau8825->regmap, NAU8825_REG_RDAC,
 513                 NAU8825_RDAC_EN | NAU8825_RDAC_CLK_EN |
 514                 NAU8825_RDAC_FS_BCLK_ENB,
 515                 NAU8825_RDAC_EN | NAU8825_RDAC_CLK_EN);
 516         /* Power up output driver with 2 stage */
 517         regmap_update_bits(nau8825->regmap, NAU8825_REG_POWER_UP_CONTROL,
 518                 NAU8825_POWERUP_INTEGR_R | NAU8825_POWERUP_INTEGR_L |
 519                 NAU8825_POWERUP_DRV_IN_R | NAU8825_POWERUP_DRV_IN_L,
 520                 NAU8825_POWERUP_INTEGR_R | NAU8825_POWERUP_INTEGR_L |
 521                 NAU8825_POWERUP_DRV_IN_R | NAU8825_POWERUP_DRV_IN_L);
 522         regmap_update_bits(nau8825->regmap, NAU8825_REG_POWER_UP_CONTROL,
 523                 NAU8825_POWERUP_HP_DRV_R | NAU8825_POWERUP_HP_DRV_L,
 524                 NAU8825_POWERUP_HP_DRV_R | NAU8825_POWERUP_HP_DRV_L);
 525         /* HP outputs not shouted to ground  */
 526         regmap_update_bits(nau8825->regmap, NAU8825_REG_HSD_CTRL,
 527                 NAU8825_SPKR_DWN1R | NAU8825_SPKR_DWN1L, 0);
 528         /* Enable HP boost driver */
 529         regmap_update_bits(nau8825->regmap, NAU8825_REG_BOOST,
 530                 NAU8825_HP_BOOST_DIS, NAU8825_HP_BOOST_DIS);
 531         /* Enable class G compare path to supply 1.8V or 0.9V. */
 532         regmap_update_bits(nau8825->regmap, NAU8825_REG_CLASSG_CTRL,
 533                 NAU8825_CLASSG_LDAC_EN | NAU8825_CLASSG_RDAC_EN,
 534                 NAU8825_CLASSG_LDAC_EN | NAU8825_CLASSG_RDAC_EN);
 535 }
 536
 537 static void nau8825_xtalk_prepare_adc(struct nau8825 *nau8825)
 538 {
 539         /* Power up left ADC and raise 5dB than Vmid for Vref  */
 540         regmap_update_bits(nau8825->regmap, NAU8825_REG_ANALOG_ADC_2,
 541                 NAU8825_POWERUP_ADCL | NAU8825_ADC_VREFSEL_MASK,
 542                 NAU8825_POWERUP_ADCL | NAU8825_ADC_VREFSEL_VMID_PLUS_0_5DB);
 543 }
 544
 545 static void nau8825_xtalk_clock(struct nau8825 *nau8825)
 546 {
 547         /* Recover FLL default value */
 548         regmap_write(nau8825->regmap, NAU8825_REG_FLL1, 0x0);
 549         regmap_write(nau8825->regmap, NAU8825_REG_FLL2, 0x3126);
 550         regmap_write(nau8825->regmap, NAU8825_REG_FLL3, 0x0008);
 551         regmap_write(nau8825->regmap, NAU8825_REG_FLL4, 0x0010);
 552         regmap_write(nau8825->regmap, NAU8825_REG_FLL5, 0x0);
 553         regmap_write(nau8825->regmap, NAU8825_REG_FLL6, 0x6000);
 554         /* Enable internal VCO clock for detection signal generated */
 555         regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
 556                 NAU8825_CLK_SRC_MASK, NAU8825_CLK_SRC_VCO);
 557         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL6, NAU8825_DCO_EN,
 558                 NAU8825_DCO_EN);
 559         /* Given specific clock frequency of internal clock to
 560          * generate signal.
 561          */
 562         regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
 563                 NAU8825_CLK_MCLK_SRC_MASK, 0xf);
 564         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL1,
 565                 NAU8825_FLL_RATIO_MASK, 0x10);
 566 }
 567
 568 static void nau8825_xtalk_prepare(struct nau8825 *nau8825)
 569 {
 570         int volume, index;
 571
 572         /* Backup those registers changed by cross talk detection */
 573         nau8825_xtalk_backup(nau8825);
 574         /* Config IIS as master to output signal by codec */
 575         regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL2,
 576                 NAU8825_I2S_MS_MASK | NAU8825_I2S_LRC_DIV_MASK |
 577                 NAU8825_I2S_BLK_DIV_MASK, NAU8825_I2S_MS_MASTER |
 578                 (0x2 << NAU8825_I2S_LRC_DIV_SFT) | 0x1);
 579         /* Ramp up headphone volume to 0dB to get better performance and
 580          * avoid pop noise in headphone.
 581          */
 582         index = nau8825_xtalk_baktab_index_by_reg(NAU8825_REG_HSVOL_CTRL);
 583         if (index != -EINVAL) {
 584                 volume = nau8825_xtalk_baktab[index].def &
 585                                 NAU8825_HPR_VOL_MASK;
 586                 nau8825_hpvol_ramp(nau8825, volume, 0, 3);
 587         }
 588         nau8825_xtalk_clock(nau8825);
 589         nau8825_xtalk_prepare_dac(nau8825);
 590         nau8825_xtalk_prepare_adc(nau8825);
 591         /* Config channel path and digital gain */
 592         regmap_update_bits(nau8825->regmap, NAU8825_REG_DACL_CTRL,
 593                 NAU8825_DACL_CH_SEL_MASK | NAU8825_DACL_CH_VOL_MASK,
 594                 NAU8825_DACL_CH_SEL_L | 0xab);
 595         regmap_update_bits(nau8825->regmap, NAU8825_REG_DACR_CTRL,
 596                 NAU8825_DACR_CH_SEL_MASK | NAU8825_DACR_CH_VOL_MASK,
 597                 NAU8825_DACR_CH_SEL_R | 0xab);
 598         /* Config cross talk parameters and generate the 23Hz sine wave with
 599          * 1/16 full scale of signal level for impedance measurement.
 600          */
 601         regmap_update_bits(nau8825->regmap, NAU8825_REG_IMM_MODE_CTRL,
 602                 NAU8825_IMM_THD_MASK | NAU8825_IMM_GEN_VOL_MASK |
 603                 NAU8825_IMM_CYC_MASK | NAU8825_IMM_DAC_SRC_MASK,
 604                 (0x9 << NAU8825_IMM_THD_SFT) | NAU8825_IMM_GEN_VOL_1_16th |
 605                 NAU8825_IMM_CYC_8192 | NAU8825_IMM_DAC_SRC_SIN);
 606         /* RMS intrruption enable */
 607         regmap_update_bits(nau8825->regmap,
 608                 NAU8825_REG_INTERRUPT_MASK, NAU8825_IRQ_RMS_EN, 0);
 609         /* Power up left and right DAC */
 610         regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 611                 NAU8825_POWER_DOWN_DACR | NAU8825_POWER_DOWN_DACL, 0);
 612 }
 613
 614 static void nau8825_xtalk_clean_dac(struct nau8825 *nau8825)
 615 {
 616         /* Disable HP boost driver */
 617         regmap_update_bits(nau8825->regmap, NAU8825_REG_BOOST,
 618                 NAU8825_HP_BOOST_DIS, 0);
 619         /* HP outputs shouted to ground  */
 620         regmap_update_bits(nau8825->regmap, NAU8825_REG_HSD_CTRL,
 621                 NAU8825_SPKR_DWN1R | NAU8825_SPKR_DWN1L,
 622                 NAU8825_SPKR_DWN1R | NAU8825_SPKR_DWN1L);
 623         /* Power down left and right DAC */
 624         regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 625                 NAU8825_POWER_DOWN_DACR | NAU8825_POWER_DOWN_DACL,
 626                 NAU8825_POWER_DOWN_DACR | NAU8825_POWER_DOWN_DACL);
 627         /* Enable the TESTDAC and  disable L/R HP impedance */
 628         regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 629                 NAU8825_BIAS_HPR_IMP | NAU8825_BIAS_HPL_IMP |
 630                 NAU8825_BIAS_TESTDAC_EN, NAU8825_BIAS_TESTDAC_EN);
 631         /* Power down output driver with 2 stage */
 632         regmap_update_bits(nau8825->regmap, NAU8825_REG_POWER_UP_CONTROL,
 633                 NAU8825_POWERUP_HP_DRV_R | NAU8825_POWERUP_HP_DRV_L, 0);
 634         regmap_update_bits(nau8825->regmap, NAU8825_REG_POWER_UP_CONTROL,
 635                 NAU8825_POWERUP_INTEGR_R | NAU8825_POWERUP_INTEGR_L |
 636                 NAU8825_POWERUP_DRV_IN_R | NAU8825_POWERUP_DRV_IN_L, 0);
 637         /* Disable clock sync of DAC and DAC clock */
 638         regmap_update_bits(nau8825->regmap, NAU8825_REG_RDAC,
 639                 NAU8825_RDAC_EN | NAU8825_RDAC_CLK_EN, 0);
 640         /* Disable charge pump ramp up function and change bump */
 641         regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 642                 NAU8825_JAMNODCLOW | NAU8825_CHANRGE_PUMP_EN, 0);
 643         /* Disable power of DAC path */
 644         regmap_update_bits(nau8825->regmap, NAU8825_REG_ENA_CTRL,
 645                 NAU8825_ENABLE_DACR | NAU8825_ENABLE_DACL |
 646                 NAU8825_ENABLE_ADC_CLK | NAU8825_ENABLE_DAC_CLK, 0);
 647         if (!nau8825->irq)
 648                 regmap_update_bits(nau8825->regmap,
 649                         NAU8825_REG_ENA_CTRL, NAU8825_ENABLE_ADC, 0);
 650 }
 651
 652 static void nau8825_xtalk_clean_adc(struct nau8825 *nau8825)
 653 {
 654         /* Power down left ADC and restore voltage to Vmid */
 655         regmap_update_bits(nau8825->regmap, NAU8825_REG_ANALOG_ADC_2,
 656                 NAU8825_POWERUP_ADCL | NAU8825_ADC_VREFSEL_MASK, 0);
 657 }
 658
 659 static void nau8825_xtalk_clean(struct nau8825 *nau8825, bool cause_cancel)
 660 {
 661         /* Enable internal VCO needed for interruptions */
 662         nau8825_configure_sysclk(nau8825, NAU8825_CLK_INTERNAL, 0);
 663         nau8825_xtalk_clean_dac(nau8825);
 664         nau8825_xtalk_clean_adc(nau8825);
 665         /* Clear cross talk parameters and disable */
 666         regmap_write(nau8825->regmap, NAU8825_REG_IMM_MODE_CTRL, 0);
 667         /* RMS intrruption disable */
 668         regmap_update_bits(nau8825->regmap, NAU8825_REG_INTERRUPT_MASK,
 669                 NAU8825_IRQ_RMS_EN, NAU8825_IRQ_RMS_EN);
 670         /* Recover default value for IIS */
 671         regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL2,
 672                 NAU8825_I2S_MS_MASK | NAU8825_I2S_LRC_DIV_MASK |
 673                 NAU8825_I2S_BLK_DIV_MASK, NAU8825_I2S_MS_SLAVE);
 674         /* Restore value of specific register for cross talk */
 675         nau8825_xtalk_restore(nau8825, cause_cancel);
 676 }
 677
 678 static void nau8825_xtalk_imm_start(struct nau8825 *nau8825, int vol)
 679 {
 680         /* Apply ADC volume for better cross talk performance */
 681         regmap_update_bits(nau8825->regmap, NAU8825_REG_ADC_DGAIN_CTRL,
 682                                 NAU8825_ADC_DIG_VOL_MASK, vol);
 683         /* Disables JKTIP(HPL) DAC channel for right to left measurement.
 684          * Do it before sending signal in order to erase pop noise.
 685          */
 686         regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 687                 NAU8825_BIAS_TESTDACR_EN | NAU8825_BIAS_TESTDACL_EN,
 688                 NAU8825_BIAS_TESTDACL_EN);
 689         switch (nau8825->xtalk_state) {
 690         case NAU8825_XTALK_HPR_R2L:
 691                 /* Enable right headphone impedance */
 692                 regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 693                         NAU8825_BIAS_HPR_IMP | NAU8825_BIAS_HPL_IMP,
 694                         NAU8825_BIAS_HPR_IMP);
 695                 break;
 696         case NAU8825_XTALK_HPL_R2L:
 697                 /* Enable left headphone impedance */
 698                 regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 699                         NAU8825_BIAS_HPR_IMP | NAU8825_BIAS_HPL_IMP,
 700                         NAU8825_BIAS_HPL_IMP);
 701                 break;
 702         default:
 703                 break;
 704         }
 705         msleep(100);
 706         /* Impedance measurement mode enable */
 707         regmap_update_bits(nau8825->regmap, NAU8825_REG_IMM_MODE_CTRL,
 708                                 NAU8825_IMM_EN, NAU8825_IMM_EN);
 709 }
 710
 711 static void nau8825_xtalk_imm_stop(struct nau8825 *nau8825)
 712 {
 713         /* Impedance measurement mode disable */
 714         regmap_update_bits(nau8825->regmap,
 715                 NAU8825_REG_IMM_MODE_CTRL, NAU8825_IMM_EN, 0);
 716 }
 717
 718 /* The cross talk measurement function can reduce cross talk across the
 719  * JKTIP(HPL) and JKR1(HPR) outputs which measures the cross talk signal
 720  * level to determine what cross talk reduction gain is. This system works by
 721  * sending a 23Hz -24dBV sine wave into the headset output DAC and through
 722  * the PGA. The output of the PGA is then connected to an internal current
 723  * sense which measures the attenuated 23Hz signal and passing the output to
 724  * an ADC which converts the measurement to a binary code. With two separated
 725  * measurement, one for JKR1(HPR) and the other JKTIP(HPL), measurement data
 726  * can be separated read in IMM_RMS_L for HSR and HSL after each measurement.
 727  * Thus, the measurement function has four states to complete whole sequence.
 728  * 1. Prepare state : Prepare the resource for detection and transfer to HPR
 729  *     IMM stat to make JKR1(HPR) impedance measure.
 730  * 2. HPR IMM state : Read out orignal signal level of JKR1(HPR) and transfer
 731  *     to HPL IMM state to make JKTIP(HPL) impedance measure.
 732  * 3. HPL IMM state : Read out cross talk signal level of JKTIP(HPL) and
 733  *     transfer to IMM state to determine suppression sidetone gain.
 734  * 4. IMM state : Computes cross talk suppression sidetone gain with orignal
 735  *     and cross talk signal level. Apply this gain and then restore codec
 736  *     configuration. Then transfer to Done state for ending.
 737  */
 738 static void nau8825_xtalk_measure(struct nau8825 *nau8825)
 739 {
 740         u32 sidetone;
 741
 742         switch (nau8825->xtalk_state) {
 743         case NAU8825_XTALK_PREPARE:
 744                 /* In prepare state, set up clock, intrruption, DAC path, ADC
 745                  * path and cross talk detection parameters for preparation.
 746                  */
 747                 nau8825_xtalk_prepare(nau8825);
 748                 msleep(280);
 749                 /* Trigger right headphone impedance detection */
 750                 nau8825->xtalk_state = NAU8825_XTALK_HPR_R2L;
 751                 nau8825_xtalk_imm_start(nau8825, 0x00d2);
 752                 break;
 753         case NAU8825_XTALK_HPR_R2L:
 754                 /* In right headphone IMM state, read out right headphone
 755                  * impedance measure result, and then start up left side.
 756                  */
 757                 regmap_read(nau8825->regmap, NAU8825_REG_IMM_RMS_L,
 758                         &nau8825->imp_rms[NAU8825_XTALK_HPR_R2L]);
 759                 dev_dbg(nau8825->dev, "HPR_R2L imm: %x\n",
 760                         nau8825->imp_rms[NAU8825_XTALK_HPR_R2L]);
 761                 /* Disable then re-enable IMM mode to update */
 762                 nau8825_xtalk_imm_stop(nau8825);
 763                 /* Trigger left headphone impedance detection */
 764                 nau8825->xtalk_state = NAU8825_XTALK_HPL_R2L;
 765                 nau8825_xtalk_imm_start(nau8825, 0x00ff);
 766                 break;
 767         case NAU8825_XTALK_HPL_R2L:
 768                 /* In left headphone IMM state, read out left headphone
 769                  * impedance measure result, and delay some time to wait
 770                  * detection sine wave output finish. Then, we can calculate
 771                  * the cross talk suppresstion side tone according to the L/R
 772                  * headphone imedance.
 773                  */
 774                 regmap_read(nau8825->regmap, NAU8825_REG_IMM_RMS_L,
 775                         &nau8825->imp_rms[NAU8825_XTALK_HPL_R2L]);
 776                 dev_dbg(nau8825->dev, "HPL_R2L imm: %x\n",
 777                         nau8825->imp_rms[NAU8825_XTALK_HPL_R2L]);
 778                 nau8825_xtalk_imm_stop(nau8825);
 779                 msleep(150);
 780                 nau8825->xtalk_state = NAU8825_XTALK_IMM;
 781                 break;
 782         case NAU8825_XTALK_IMM:
 783                 /* In impedance measure state, the orignal and cross talk
 784                  * signal level vlues are ready. The side tone gain is deter-
 785                  * mined with these signal level. After all, restore codec
 786                  * configuration.
 787                  */
 788                 sidetone = nau8825_xtalk_sidetone(
 789                         nau8825->imp_rms[NAU8825_XTALK_HPR_R2L],
 790                         nau8825->imp_rms[NAU8825_XTALK_HPL_R2L]);
 791                 dev_dbg(nau8825->dev, "cross talk sidetone: %x\n", sidetone);
 792                 regmap_write(nau8825->regmap, NAU8825_REG_DAC_DGAIN_CTRL,
 793                                         (sidetone << 8) | sidetone);
 794                 nau8825_xtalk_clean(nau8825, false);
 795                 nau8825->xtalk_state = NAU8825_XTALK_DONE;
 796                 break;
 797         default:
 798                 break;
 799         }
 800 }
 801
 802 static void nau8825_xtalk_work(struct work_struct *work)
 803 {
 804         struct nau8825 *nau8825 = container_of(
 805                 work, struct nau8825, xtalk_work);
 806
 807         nau8825_xtalk_measure(nau8825);
 808         /* To determine the cross talk side tone gain when reach
 809          * the impedance measure state.
 810          */
 811         if (nau8825->xtalk_state == NAU8825_XTALK_IMM)
 812                 nau8825_xtalk_measure(nau8825);
 813
 814         /* Delay jack report until cross talk detection process
 815          * completed. It can avoid application to do playback
 816          * preparation before cross talk detection is still working.
 817          * Meanwhile, the protection of the cross talk detection
 818          * is released.
 819          */
 820         if (nau8825->xtalk_state == NAU8825_XTALK_DONE) {
 821                 snd_soc_jack_report(nau8825->jack, nau8825->xtalk_event,
 822                                 nau8825->xtalk_event_mask);
 823                 nau8825_sema_release(nau8825);
 824                 nau8825->xtalk_protect = false;
 825         }
 826 }
 827
 828 static void nau8825_xtalk_cancel(struct nau8825 *nau8825)
 829 {
 830         /* If the crosstalk is eanbled and the process is on going,
 831          * the driver forces to cancel the crosstalk task and
 832          * restores the configuration to original status.
 833          */
 834         if (nau8825->xtalk_enable && nau8825->xtalk_state !=
 835                 NAU8825_XTALK_DONE) {
 836                 cancel_work_sync(&nau8825->xtalk_work);
 837                 nau8825_xtalk_clean(nau8825, true);
 838         }
 839         /* Reset parameters for cross talk suppression function */
 840         nau8825_sema_reset(nau8825);
 841         nau8825->xtalk_state = NAU8825_XTALK_DONE;
 842         nau8825->xtalk_protect = false;
 843 }
 844
 845 static bool nau8825_readable_reg(struct device *dev, unsigned int reg)
 846 {
 847         switch (reg) {
 848         case NAU8825_REG_ENA_CTRL ... NAU8825_REG_FLL_VCO_RSV:
 849         case NAU8825_REG_HSD_CTRL ... NAU8825_REG_JACK_DET_CTRL:
 850         case NAU8825_REG_INTERRUPT_MASK ... NAU8825_REG_KEYDET_CTRL:
 851         case NAU8825_REG_VDET_THRESHOLD_1 ... NAU8825_REG_DACR_CTRL:
 852         case NAU8825_REG_ADC_DRC_KNEE_IP12 ... NAU8825_REG_ADC_DRC_ATKDCY:
 853         case NAU8825_REG_DAC_DRC_KNEE_IP12 ... NAU8825_REG_DAC_DRC_ATKDCY:
 854         case NAU8825_REG_IMM_MODE_CTRL ... NAU8825_REG_IMM_RMS_R:
 855         case NAU8825_REG_CLASSG_CTRL ... NAU8825_REG_OPT_EFUSE_CTRL:
 856         case NAU8825_REG_MISC_CTRL:
 857         case NAU8825_REG_I2C_DEVICE_ID ... NAU8825_REG_SARDOUT_RAM_STATUS:
 858         case NAU8825_REG_BIAS_ADJ:
 859         case NAU8825_REG_TRIM_SETTINGS ... NAU8825_REG_ANALOG_CONTROL_2:
 860         case NAU8825_REG_ANALOG_ADC_1 ... NAU8825_REG_MIC_BIAS:
 861         case NAU8825_REG_BOOST ... NAU8825_REG_FEPGA:
 862         case NAU8825_REG_POWER_UP_CONTROL ... NAU8825_REG_GENERAL_STATUS:
 863                 return true;
 864         default:
 865                 return false;
 866         }
 867
 868 }
 869
 870 static bool nau8825_writeable_reg(struct device *dev, unsigned int reg)
 871 {
 872         switch (reg) {
 873         case NAU8825_REG_RESET ... NAU8825_REG_FLL_VCO_RSV:
 874         case NAU8825_REG_HSD_CTRL ... NAU8825_REG_JACK_DET_CTRL:
 875         case NAU8825_REG_INTERRUPT_MASK:
 876         case NAU8825_REG_INT_CLR_KEY_STATUS ... NAU8825_REG_KEYDET_CTRL:
 877         case NAU8825_REG_VDET_THRESHOLD_1 ... NAU8825_REG_DACR_CTRL:
 878         case NAU8825_REG_ADC_DRC_KNEE_IP12 ... NAU8825_REG_ADC_DRC_ATKDCY:
 879         case NAU8825_REG_DAC_DRC_KNEE_IP12 ... NAU8825_REG_DAC_DRC_ATKDCY:
 880         case NAU8825_REG_IMM_MODE_CTRL:
 881         case NAU8825_REG_CLASSG_CTRL ... NAU8825_REG_OPT_EFUSE_CTRL:
 882         case NAU8825_REG_MISC_CTRL:
 883         case NAU8825_REG_BIAS_ADJ:
 884         case NAU8825_REG_TRIM_SETTINGS ... NAU8825_REG_ANALOG_CONTROL_2:
 885         case NAU8825_REG_ANALOG_ADC_1 ... NAU8825_REG_MIC_BIAS:
 886         case NAU8825_REG_BOOST ... NAU8825_REG_FEPGA:
 887         case NAU8825_REG_POWER_UP_CONTROL ... NAU8825_REG_CHARGE_PUMP:
 888                 return true;
 889         default:
 890                 return false;
 891         }
 892 }
 893
 894 static bool nau8825_volatile_reg(struct device *dev, unsigned int reg)
 895 {
 896         switch (reg) {
 897         case NAU8825_REG_RESET:
 898         case NAU8825_REG_IRQ_STATUS:
 899         case NAU8825_REG_INT_CLR_KEY_STATUS:
 900         case NAU8825_REG_IMM_RMS_L:
 901         case NAU8825_REG_IMM_RMS_R:
 902         case NAU8825_REG_I2C_DEVICE_ID:
 903         case NAU8825_REG_SARDOUT_RAM_STATUS:
 904         case NAU8825_REG_CHARGE_PUMP_INPUT_READ:
 905         case NAU8825_REG_GENERAL_STATUS:
 906         case NAU8825_REG_BIQ_CTRL ... NAU8825_REG_BIQ_COF10:
 907                 return true;
 908         default:
 909                 return false;
 910         }
 911 }
 912
 913 static int nau8825_adc_event(struct snd_soc_dapm_widget *w,
 914                 struct snd_kcontrol *kcontrol, int event)
 915 {
 916         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 917         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
 918
 919         switch (event) {
 920         case SND_SOC_DAPM_POST_PMU:
 921                 msleep(125);
 922                 regmap_update_bits(nau8825->regmap, NAU8825_REG_ENA_CTRL,
 923                         NAU8825_ENABLE_ADC, NAU8825_ENABLE_ADC);
 924                 break;
 925         case SND_SOC_DAPM_POST_PMD:
 926                 if (!nau8825->irq)
 927                         regmap_update_bits(nau8825->regmap,
 928                                 NAU8825_REG_ENA_CTRL, NAU8825_ENABLE_ADC, 0);
 929                 break;
 930         default:
 931                 return -EINVAL;
 932         }
 933
 934         return 0;
 935 }
 936
 937 static int nau8825_pump_event(struct snd_soc_dapm_widget *w,
 938         struct snd_kcontrol *kcontrol, int event)
 939 {
 940         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 941         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
 942
 943         switch (event) {
 944         case SND_SOC_DAPM_POST_PMU:
 945                 /* Prevent startup click by letting charge pump to ramp up */
 946                 msleep(10);
 947                 regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 948                         NAU8825_JAMNODCLOW, NAU8825_JAMNODCLOW);
 949                 break;
 950         case SND_SOC_DAPM_PRE_PMD:
 951                 regmap_update_bits(nau8825->regmap, NAU8825_REG_CHARGE_PUMP,
 952                         NAU8825_JAMNODCLOW, 0);
 953                 break;
 954         default:
 955                 return -EINVAL;
 956         }
 957
 958         return 0;
 959 }
 960
 961 static int nau8825_output_dac_event(struct snd_soc_dapm_widget *w,
 962         struct snd_kcontrol *kcontrol, int event)
 963 {
 964         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 965         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
 966
 967         switch (event) {
 968         case SND_SOC_DAPM_PRE_PMU:
 969                 /* Disables the TESTDAC to let DAC signal pass through. */
 970                 regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 971                         NAU8825_BIAS_TESTDAC_EN, 0);
 972                 break;
 973         case SND_SOC_DAPM_POST_PMD:
 974                 regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
 975                         NAU8825_BIAS_TESTDAC_EN, NAU8825_BIAS_TESTDAC_EN);
 976                 break;
 977         default:
 978                 return -EINVAL;
 979         }
 980
 981         return 0;
 982 }
 983
 984 static int nau8825_biq_coeff_get(struct snd_kcontrol *kcontrol,
 985                                      struct snd_ctl_elem_value *ucontrol)
 986 {
 987         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 988         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
 989
 990         if (!component->regmap)
 991                 return -EINVAL;
 992
 993         regmap_raw_read(component->regmap, NAU8825_REG_BIQ_COF1,
 994                 ucontrol->value.bytes.data, params->max);
 995         return 0;
 996 }
 997
 998 static int nau8825_biq_coeff_put(struct snd_kcontrol *kcontrol,
 999                                      struct snd_ctl_elem_value *ucontrol)
1000 {
1001         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1002         struct soc_bytes_ext *params = (void *)kcontrol->private_value;
1003         void *data;
1004
1005         if (!component->regmap)
1006                 return -EINVAL;
1007
1008         data = kmemdup(ucontrol->value.bytes.data,
1009                 params->max, GFP_KERNEL | GFP_DMA);
1010         if (!data)
1011                 return -ENOMEM;
1012
1013         regmap_update_bits(component->regmap, NAU8825_REG_BIQ_CTRL,
1014                 NAU8825_BIQ_WRT_EN, 0);
1015         regmap_raw_write(component->regmap, NAU8825_REG_BIQ_COF1,
1016                 data, params->max);
1017         regmap_update_bits(component->regmap, NAU8825_REG_BIQ_CTRL,
1018                 NAU8825_BIQ_WRT_EN, NAU8825_BIQ_WRT_EN);
1019
1020         kfree(data);
1021         return 0;
1022 }
1023
1024 static const char * const nau8825_biq_path[] = {
1025         "ADC", "DAC"
1026 };
1027
1028 static const struct soc_enum nau8825_biq_path_enum =
1029         SOC_ENUM_SINGLE(NAU8825_REG_BIQ_CTRL, NAU8825_BIQ_PATH_SFT,
1030                 ARRAY_SIZE(nau8825_biq_path), nau8825_biq_path);
1031
1032 static const char * const nau8825_adc_decimation[] = {
1033         "32", "64", "128", "256"
1034 };
1035
1036 static const struct soc_enum nau8825_adc_decimation_enum =
1037         SOC_ENUM_SINGLE(NAU8825_REG_ADC_RATE, NAU8825_ADC_SYNC_DOWN_SFT,
1038                 ARRAY_SIZE(nau8825_adc_decimation), nau8825_adc_decimation);
1039
1040 static const char * const nau8825_dac_oversampl[] = {
1041         "64", "256", "128", "", "32"
1042 };
1043
1044 static const struct soc_enum nau8825_dac_oversampl_enum =
1045         SOC_ENUM_SINGLE(NAU8825_REG_DAC_CTRL1, NAU8825_DAC_OVERSAMPLE_SFT,
1046                 ARRAY_SIZE(nau8825_dac_oversampl), nau8825_dac_oversampl);
1047
1048 static const DECLARE_TLV_DB_MINMAX_MUTE(adc_vol_tlv, -10300, 2400);
1049 static const DECLARE_TLV_DB_MINMAX_MUTE(sidetone_vol_tlv, -4200, 0);
1050 static const DECLARE_TLV_DB_MINMAX(dac_vol_tlv, -5400, 0);
1051 static const DECLARE_TLV_DB_MINMAX(fepga_gain_tlv, -100, 3600);
1052 static const DECLARE_TLV_DB_MINMAX_MUTE(crosstalk_vol_tlv, -9600, 2400);
1053
1054 static const struct snd_kcontrol_new nau8825_controls[] = {
1055         SOC_SINGLE_TLV("Mic Volume", NAU8825_REG_ADC_DGAIN_CTRL,
1056                 0, 0xff, 0, adc_vol_tlv),
1057         SOC_DOUBLE_TLV("Headphone Bypass Volume", NAU8825_REG_ADC_DGAIN_CTRL,
1058                 12, 8, 0x0f, 0, sidetone_vol_tlv),
1059         SOC_DOUBLE_TLV("Headphone Volume", NAU8825_REG_HSVOL_CTRL,
1060                 6, 0, 0x3f, 1, dac_vol_tlv),
1061         SOC_SINGLE_TLV("Frontend PGA Volume", NAU8825_REG_POWER_UP_CONTROL,
1062                 8, 37, 0, fepga_gain_tlv),
1063         SOC_DOUBLE_TLV("Headphone Crosstalk Volume", NAU8825_REG_DAC_DGAIN_CTRL,
1064                 0, 8, 0xff, 0, crosstalk_vol_tlv),
1065
1066         SOC_ENUM("ADC Decimation Rate", nau8825_adc_decimation_enum),
1067         SOC_ENUM("DAC Oversampling Rate", nau8825_dac_oversampl_enum),
1068         /* programmable biquad filter */
1069         SOC_ENUM("BIQ Path Select", nau8825_biq_path_enum),
1070         SND_SOC_BYTES_EXT("BIQ Coefficients", 20,
1071                   nau8825_biq_coeff_get, nau8825_biq_coeff_put),
1072 };
1073
1074 /* DAC Mux 0x33[9] and 0x34[9] */
1075 static const char * const nau8825_dac_src[] = {
1076         "DACL", "DACR",
1077 };
1078
1079 static SOC_ENUM_SINGLE_DECL(
1080         nau8825_dacl_enum, NAU8825_REG_DACL_CTRL,
1081         NAU8825_DACL_CH_SEL_SFT, nau8825_dac_src);
1082
1083 static SOC_ENUM_SINGLE_DECL(
1084         nau8825_dacr_enum, NAU8825_REG_DACR_CTRL,
1085         NAU8825_DACR_CH_SEL_SFT, nau8825_dac_src);
1086
1087 static const struct snd_kcontrol_new nau8825_dacl_mux =
1088         SOC_DAPM_ENUM("DACL Source", nau8825_dacl_enum);
1089
1090 static const struct snd_kcontrol_new nau8825_dacr_mux =
1091         SOC_DAPM_ENUM("DACR Source", nau8825_dacr_enum);
1092
1093
1094 static const struct snd_soc_dapm_widget nau8825_dapm_widgets[] = {
1095         SND_SOC_DAPM_AIF_OUT("AIFTX", "Capture", 0, NAU8825_REG_I2S_PCM_CTRL2,
1096                 15, 1),
1097
1098         SND_SOC_DAPM_INPUT("MIC"),
1099         SND_SOC_DAPM_MICBIAS("MICBIAS", NAU8825_REG_MIC_BIAS, 8, 0),
1100
1101         SND_SOC_DAPM_PGA("Frontend PGA", NAU8825_REG_POWER_UP_CONTROL, 14, 0,
1102                 NULL, 0),
1103
1104         SND_SOC_DAPM_ADC_E("ADC", NULL, SND_SOC_NOPM, 0, 0,
1105                 nau8825_adc_event, SND_SOC_DAPM_POST_PMU |
1106                 SND_SOC_DAPM_POST_PMD),
1107         SND_SOC_DAPM_SUPPLY("ADC Clock", NAU8825_REG_ENA_CTRL, 7, 0, NULL, 0),
1108         SND_SOC_DAPM_SUPPLY("ADC Power", NAU8825_REG_ANALOG_ADC_2, 6, 0, NULL,
1109                 0),
1110
1111         /* ADC for button press detection. A dapm supply widget is used to
1112          * prevent dapm_power_widgets keeping the codec at SND_SOC_BIAS_ON
1113          * during suspend.
1114          */
1115         SND_SOC_DAPM_SUPPLY("SAR", NAU8825_REG_SAR_CTRL,
1116                 NAU8825_SAR_ADC_EN_SFT, 0, NULL, 0),
1117
1118         SND_SOC_DAPM_PGA_S("ADACL", 2, NAU8825_REG_RDAC, 12, 0, NULL, 0),
1119         SND_SOC_DAPM_PGA_S("ADACR", 2, NAU8825_REG_RDAC, 13, 0, NULL, 0),
1120         SND_SOC_DAPM_PGA_S("ADACL Clock", 3, NAU8825_REG_RDAC, 8, 0, NULL, 0),
1121         SND_SOC_DAPM_PGA_S("ADACR Clock", 3, NAU8825_REG_RDAC, 9, 0, NULL, 0),
1122
1123         SND_SOC_DAPM_DAC("DDACR", NULL, NAU8825_REG_ENA_CTRL,
1124                 NAU8825_ENABLE_DACR_SFT, 0),
1125         SND_SOC_DAPM_DAC("DDACL", NULL, NAU8825_REG_ENA_CTRL,
1126                 NAU8825_ENABLE_DACL_SFT, 0),
1127         SND_SOC_DAPM_SUPPLY("DDAC Clock", NAU8825_REG_ENA_CTRL, 6, 0, NULL, 0),
1128
1129         SND_SOC_DAPM_MUX("DACL Mux", SND_SOC_NOPM, 0, 0, &nau8825_dacl_mux),
1130         SND_SOC_DAPM_MUX("DACR Mux", SND_SOC_NOPM, 0, 0, &nau8825_dacr_mux),
1131
1132         SND_SOC_DAPM_PGA_S("HP amp L", 0,
1133                 NAU8825_REG_CLASSG_CTRL, 1, 0, NULL, 0),
1134         SND_SOC_DAPM_PGA_S("HP amp R", 0,
1135                 NAU8825_REG_CLASSG_CTRL, 2, 0, NULL, 0),
1136
1137         SND_SOC_DAPM_PGA_S("Charge Pump", 1, NAU8825_REG_CHARGE_PUMP, 5, 0,
1138                 nau8825_pump_event, SND_SOC_DAPM_POST_PMU |
1139                 SND_SOC_DAPM_PRE_PMD),
1140
1141         SND_SOC_DAPM_PGA_S("Output Driver R Stage 1", 4,
1142                 NAU8825_REG_POWER_UP_CONTROL, 5, 0, NULL, 0),
1143         SND_SOC_DAPM_PGA_S("Output Driver L Stage 1", 4,
1144                 NAU8825_REG_POWER_UP_CONTROL, 4, 0, NULL, 0),
1145         SND_SOC_DAPM_PGA_S("Output Driver R Stage 2", 5,
1146                 NAU8825_REG_POWER_UP_CONTROL, 3, 0, NULL, 0),
1147         SND_SOC_DAPM_PGA_S("Output Driver L Stage 2", 5,
1148                 NAU8825_REG_POWER_UP_CONTROL, 2, 0, NULL, 0),
1149         SND_SOC_DAPM_PGA_S("Output Driver R Stage 3", 6,
1150                 NAU8825_REG_POWER_UP_CONTROL, 1, 0, NULL, 0),
1151         SND_SOC_DAPM_PGA_S("Output Driver L Stage 3", 6,
1152                 NAU8825_REG_POWER_UP_CONTROL, 0, 0, NULL, 0),
1153
1154         SND_SOC_DAPM_PGA_S("Output DACL", 7,
1155                 NAU8825_REG_CHARGE_PUMP, 8, 1, nau8825_output_dac_event,
1156                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
1157         SND_SOC_DAPM_PGA_S("Output DACR", 7,
1158                 NAU8825_REG_CHARGE_PUMP, 9, 1, nau8825_output_dac_event,
1159                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
1160
1161         /* HPOL/R are ungrounded by disabling 16 Ohm pull-downs on playback */
1162         SND_SOC_DAPM_PGA_S("HPOL Pulldown", 8,
1163                 NAU8825_REG_HSD_CTRL, 0, 1, NULL, 0),
1164         SND_SOC_DAPM_PGA_S("HPOR Pulldown", 8,
1165                 NAU8825_REG_HSD_CTRL, 1, 1, NULL, 0),
1166
1167         /* High current HPOL/R boost driver */
1168         SND_SOC_DAPM_PGA_S("HP Boost Driver", 9,
1169                 NAU8825_REG_BOOST, 9, 1, NULL, 0),
1170
1171         /* Class G operation control*/
1172         SND_SOC_DAPM_PGA_S("Class G", 10,
1173                 NAU8825_REG_CLASSG_CTRL, 0, 0, NULL, 0),
1174
1175         SND_SOC_DAPM_OUTPUT("HPOL"),
1176         SND_SOC_DAPM_OUTPUT("HPOR"),
1177 };
1178
1179 static const struct snd_soc_dapm_route nau8825_dapm_routes[] = {
1180         {"Frontend PGA", NULL, "MIC"},
1181         {"ADC", NULL, "Frontend PGA"},
1182         {"ADC", NULL, "ADC Clock"},
1183         {"ADC", NULL, "ADC Power"},
1184         {"AIFTX", NULL, "ADC"},
1185
1186         {"DDACL", NULL, "Playback"},
1187         {"DDACR", NULL, "Playback"},
1188         {"DDACL", NULL, "DDAC Clock"},
1189         {"DDACR", NULL, "DDAC Clock"},
1190         {"DACL Mux", "DACL", "DDACL"},
1191         {"DACL Mux", "DACR", "DDACR"},
1192         {"DACR Mux", "DACL", "DDACL"},
1193         {"DACR Mux", "DACR", "DDACR"},
1194         {"HP amp L", NULL, "DACL Mux"},
1195         {"HP amp R", NULL, "DACR Mux"},
1196         {"Charge Pump", NULL, "HP amp L"},
1197         {"Charge Pump", NULL, "HP amp R"},
1198         {"ADACL", NULL, "Charge Pump"},
1199         {"ADACR", NULL, "Charge Pump"},
1200         {"ADACL Clock", NULL, "ADACL"},
1201         {"ADACR Clock", NULL, "ADACR"},
1202         {"Output Driver L Stage 1", NULL, "ADACL Clock"},
1203         {"Output Driver R Stage 1", NULL, "ADACR Clock"},
1204         {"Output Driver L Stage 2", NULL, "Output Driver L Stage 1"},
1205         {"Output Driver R Stage 2", NULL, "Output Driver R Stage 1"},
1206         {"Output Driver L Stage 3", NULL, "Output Driver L Stage 2"},
1207         {"Output Driver R Stage 3", NULL, "Output Driver R Stage 2"},
1208         {"Output DACL", NULL, "Output Driver L Stage 3"},
1209         {"Output DACR", NULL, "Output Driver R Stage 3"},
1210         {"HPOL Pulldown", NULL, "Output DACL"},
1211         {"HPOR Pulldown", NULL, "Output DACR"},
1212         {"HP Boost Driver", NULL, "HPOL Pulldown"},
1213         {"HP Boost Driver", NULL, "HPOR Pulldown"},
1214         {"Class G", NULL, "HP Boost Driver"},
1215         {"HPOL", NULL, "Class G"},
1216         {"HPOR", NULL, "Class G"},
1217 };
1218
1219 static int nau8825_clock_check(struct nau8825 *nau8825,
1220         int stream, int rate, int osr)
1221 {
1222         int osrate;
1223
1224         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
1225                 if (osr >= ARRAY_SIZE(osr_dac_sel))
1226                         return -EINVAL;
1227                 osrate = osr_dac_sel[osr].osr;
1228         } else {
1229                 if (osr >= ARRAY_SIZE(osr_adc_sel))
1230                         return -EINVAL;
1231                 osrate = osr_adc_sel[osr].osr;
1232         }
1233
1234         if (!osrate || rate * osr > CLK_DA_AD_MAX) {
1235                 dev_err(nau8825->dev, "exceed the maximum frequency of CLK_ADC or CLK_DAC\n");
1236                 return -EINVAL;
1237         }
1238
1239         return 0;
1240 }
1241
1242 static int nau8825_hw_params(struct snd_pcm_substream *substream,
1243                                 struct snd_pcm_hw_params *params,
1244                                 struct snd_soc_dai *dai)
1245 {
1246         struct snd_soc_component *component = dai->component;
1247         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
1248         unsigned int val_len = 0, osr, ctrl_val, bclk_fs, bclk_div;
1249
1250         nau8825_sema_acquire(nau8825, 3 * HZ);
1251
1252         /* CLK_DAC or CLK_ADC = OSR * FS
1253          * DAC or ADC clock frequency is defined as Over Sampling Rate (OSR)
1254          * multiplied by the audio sample rate (Fs). Note that the OSR and Fs
1255          * values must be selected such that the maximum frequency is less
1256          * than 6.144 MHz.
1257          */
1258         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1259                 regmap_read(nau8825->regmap, NAU8825_REG_DAC_CTRL1, &osr);
1260                 osr &= NAU8825_DAC_OVERSAMPLE_MASK;
1261                 if (nau8825_clock_check(nau8825, substream->stream,
1262                         params_rate(params), osr)) {
1263                         nau8825_sema_release(nau8825);
1264                         return -EINVAL;
1265                 }
1266                 regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
1267                         NAU8825_CLK_DAC_SRC_MASK,
1268                         osr_dac_sel[osr].clk_src << NAU8825_CLK_DAC_SRC_SFT);
1269         } else {
1270                 regmap_read(nau8825->regmap, NAU8825_REG_ADC_RATE, &osr);
1271                 osr &= NAU8825_ADC_SYNC_DOWN_MASK;
1272                 if (nau8825_clock_check(nau8825, substream->stream,
1273                         params_rate(params), osr)) {
1274                         nau8825_sema_release(nau8825);
1275                         return -EINVAL;
1276                 }
1277                 regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
1278                         NAU8825_CLK_ADC_SRC_MASK,
1279                         osr_adc_sel[osr].clk_src << NAU8825_CLK_ADC_SRC_SFT);
1280         }
1281
1282         /* make BCLK and LRC divde configuration if the codec as master. */
1283         regmap_read(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL2, &ctrl_val);
1284         if (ctrl_val & NAU8825_I2S_MS_MASTER) {
1285                 /* get the bclk and fs ratio */
1286                 bclk_fs = snd_soc_params_to_bclk(params) / params_rate(params);
1287                 if (bclk_fs <= 32)
1288                         bclk_div = 2;
1289                 else if (bclk_fs <= 64)
1290                         bclk_div = 1;
1291                 else if (bclk_fs <= 128)
1292                         bclk_div = 0;
1293                 else {
1294                         nau8825_sema_release(nau8825);
1295                         return -EINVAL;
1296                 }
1297                 regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL2,
1298                         NAU8825_I2S_LRC_DIV_MASK | NAU8825_I2S_BLK_DIV_MASK,
1299                         ((bclk_div + 1) << NAU8825_I2S_LRC_DIV_SFT) | bclk_div);
1300         }
1301
1302         switch (params_width(params)) {
1303         case 16:
1304                 val_len |= NAU8825_I2S_DL_16;
1305                 break;
1306         case 20:
1307                 val_len |= NAU8825_I2S_DL_20;
1308                 break;
1309         case 24:
1310                 val_len |= NAU8825_I2S_DL_24;
1311                 break;
1312         case 32:
1313                 val_len |= NAU8825_I2S_DL_32;
1314                 break;
1315         default:
1316                 nau8825_sema_release(nau8825);
1317                 return -EINVAL;
1318         }
1319
1320         regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL1,
1321                 NAU8825_I2S_DL_MASK, val_len);
1322
1323         /* Release the semaphore. */
1324         nau8825_sema_release(nau8825);
1325
1326         return 0;
1327 }
1328
1329 static int nau8825_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
1330 {
1331         struct snd_soc_component *component = codec_dai->component;
1332         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
1333         unsigned int ctrl1_val = 0, ctrl2_val = 0;
1334
1335         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1336         case SND_SOC_DAIFMT_CBM_CFM:
1337                 ctrl2_val |= NAU8825_I2S_MS_MASTER;
1338                 break;
1339         case SND_SOC_DAIFMT_CBS_CFS:
1340                 break;
1341         default:
1342                 return -EINVAL;
1343         }
1344
1345         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1346         case SND_SOC_DAIFMT_NB_NF:
1347                 break;
1348         case SND_SOC_DAIFMT_IB_NF:
1349                 ctrl1_val |= NAU8825_I2S_BP_INV;
1350                 break;
1351         default:
1352                 return -EINVAL;
1353         }
1354
1355         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1356         case SND_SOC_DAIFMT_I2S:
1357                 ctrl1_val |= NAU8825_I2S_DF_I2S;
1358                 break;
1359         case SND_SOC_DAIFMT_LEFT_J:
1360                 ctrl1_val |= NAU8825_I2S_DF_LEFT;
1361                 break;
1362         case SND_SOC_DAIFMT_RIGHT_J:
1363                 ctrl1_val |= NAU8825_I2S_DF_RIGTH;
1364                 break;
1365         case SND_SOC_DAIFMT_DSP_A:
1366                 ctrl1_val |= NAU8825_I2S_DF_PCM_AB;
1367                 break;
1368         case SND_SOC_DAIFMT_DSP_B:
1369                 ctrl1_val |= NAU8825_I2S_DF_PCM_AB;
1370                 ctrl1_val |= NAU8825_I2S_PCMB_EN;
1371                 break;
1372         default:
1373                 return -EINVAL;
1374         }
1375
1376         nau8825_sema_acquire(nau8825, 3 * HZ);
1377
1378         regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL1,
1379                 NAU8825_I2S_DL_MASK | NAU8825_I2S_DF_MASK |
1380                 NAU8825_I2S_BP_MASK | NAU8825_I2S_PCMB_MASK,
1381                 ctrl1_val);
1382         regmap_update_bits(nau8825->regmap, NAU8825_REG_I2S_PCM_CTRL2,
1383                 NAU8825_I2S_MS_MASK, ctrl2_val);
1384
1385         /* Release the semaphore. */
1386         nau8825_sema_release(nau8825);
1387
1388         return 0;
1389 }
1390
1391 static const struct snd_soc_dai_ops nau8825_dai_ops = {
1392         .hw_params      = nau8825_hw_params,
1393         .set_fmt        = nau8825_set_dai_fmt,
1394 };
1395
1396 #define NAU8825_RATES   SNDRV_PCM_RATE_8000_192000
1397 #define NAU8825_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE \
1398                          | SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S32_LE)
1399
1400 static struct snd_soc_dai_driver nau8825_dai = {
1401         .name = "nau8825-hifi",
1402         .playback = {
1403                 .stream_name     = "Playback",
1404                 .channels_min    = 1,
1405                 .channels_max    = 2,
1406                 .rates           = NAU8825_RATES,
1407                 .formats         = NAU8825_FORMATS,
1408         },
1409         .capture = {
1410                 .stream_name     = "Capture",
1411                 .channels_min    = 1,
1412                 .channels_max    = 1,
1413                 .rates           = NAU8825_RATES,
1414                 .formats         = NAU8825_FORMATS,
1415         },
1416         .ops = &nau8825_dai_ops,
1417 };
1418
1419 /**
1420  * nau8825_enable_jack_detect - Specify a jack for event reporting
1421  *
1422  * @component:  component to register the jack with
1423  * @jack: jack to use to report headset and button events on
1424  *
1425  * After this function has been called the headset insert/remove and button
1426  * events will be routed to the given jack.  Jack can be null to stop
1427  * reporting.
1428  */
1429 int nau8825_enable_jack_detect(struct snd_soc_component *component,
1430                                 struct snd_soc_jack *jack)
1431 {
1432         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
1433         struct regmap *regmap = nau8825->regmap;
1434
1435         nau8825->jack = jack;
1436
1437         /* Ground HP Outputs[1:0], needed for headset auto detection
1438          * Enable Automatic Mic/Gnd switching reading on insert interrupt[6]
1439          */
1440         regmap_update_bits(regmap, NAU8825_REG_HSD_CTRL,
1441                 NAU8825_HSD_AUTO_MODE | NAU8825_SPKR_DWN1R | NAU8825_SPKR_DWN1L,
1442                 NAU8825_HSD_AUTO_MODE | NAU8825_SPKR_DWN1R | NAU8825_SPKR_DWN1L);
1443
1444         return 0;
1445 }
1446 EXPORT_SYMBOL_GPL(nau8825_enable_jack_detect);
1447
1448
1449 static bool nau8825_is_jack_inserted(struct regmap *regmap)
1450 {
1451         bool active_high, is_high;
1452         int status, jkdet;
1453
1454         regmap_read(regmap, NAU8825_REG_JACK_DET_CTRL, &jkdet);
1455         active_high = jkdet & NAU8825_JACK_POLARITY;
1456         regmap_read(regmap, NAU8825_REG_I2C_DEVICE_ID, &status);
1457         is_high = status & NAU8825_GPIO2JD1;
1458         /* return jack connection status according to jack insertion logic
1459          * active high or active low.
1460          */
1461         return active_high == is_high;
1462 }
1463
1464 static void nau8825_restart_jack_detection(struct regmap *regmap)
1465 {
1466         /* this will restart the entire jack detection process including MIC/GND
1467          * switching and create interrupts. We have to go from 0 to 1 and back
1468          * to 0 to restart.
1469          */
1470         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1471                 NAU8825_JACK_DET_RESTART, NAU8825_JACK_DET_RESTART);
1472         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1473                 NAU8825_JACK_DET_RESTART, 0);
1474 }
1475
1476 static void nau8825_int_status_clear_all(struct regmap *regmap)
1477 {
1478         int active_irq, clear_irq, i;
1479
1480         /* Reset the intrruption status from rightmost bit if the corres-
1481          * ponding irq event occurs.
1482          */
1483         regmap_read(regmap, NAU8825_REG_IRQ_STATUS, &active_irq);
1484         for (i = 0; i < NAU8825_REG_DATA_LEN; i++) {
1485                 clear_irq = (0x1 << i);
1486                 if (active_irq & clear_irq)
1487                         regmap_write(regmap,
1488                                 NAU8825_REG_INT_CLR_KEY_STATUS, clear_irq);
1489         }
1490 }
1491
1492 static void nau8825_eject_jack(struct nau8825 *nau8825)
1493 {
1494         struct snd_soc_dapm_context *dapm = nau8825->dapm;
1495         struct regmap *regmap = nau8825->regmap;
1496
1497         /* Force to cancel the cross talk detection process */
1498         nau8825_xtalk_cancel(nau8825);
1499
1500         snd_soc_dapm_disable_pin(dapm, "SAR");
1501         snd_soc_dapm_disable_pin(dapm, "MICBIAS");
1502         /* Detach 2kOhm Resistors from MICBIAS to MICGND1/2 */
1503         regmap_update_bits(regmap, NAU8825_REG_MIC_BIAS,
1504                 NAU8825_MICBIAS_JKSLV | NAU8825_MICBIAS_JKR2, 0);
1505         /* ground HPL/HPR, MICGRND1/2 */
1506         regmap_update_bits(regmap, NAU8825_REG_HSD_CTRL, 0xf, 0xf);
1507
1508         snd_soc_dapm_sync(dapm);
1509
1510         /* Clear all interruption status */
1511         nau8825_int_status_clear_all(regmap);
1512
1513         /* Enable the insertion interruption, disable the ejection inter-
1514          * ruption, and then bypass de-bounce circuit.
1515          */
1516         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_DIS_CTRL,
1517                 NAU8825_IRQ_EJECT_DIS | NAU8825_IRQ_INSERT_DIS,
1518                 NAU8825_IRQ_EJECT_DIS);
1519         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
1520                 NAU8825_IRQ_OUTPUT_EN | NAU8825_IRQ_EJECT_EN |
1521                 NAU8825_IRQ_HEADSET_COMPLETE_EN | NAU8825_IRQ_INSERT_EN,
1522                 NAU8825_IRQ_OUTPUT_EN | NAU8825_IRQ_EJECT_EN |
1523                 NAU8825_IRQ_HEADSET_COMPLETE_EN);
1524         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1525                 NAU8825_JACK_DET_DB_BYPASS, NAU8825_JACK_DET_DB_BYPASS);
1526
1527         /* Disable ADC needed for interruptions at audo mode */
1528         regmap_update_bits(regmap, NAU8825_REG_ENA_CTRL,
1529                 NAU8825_ENABLE_ADC, 0);
1530
1531         /* Close clock for jack type detection at manual mode */
1532         nau8825_configure_sysclk(nau8825, NAU8825_CLK_DIS, 0);
1533 }
1534
1535 /* Enable audo mode interruptions with internal clock. */
1536 static void nau8825_setup_auto_irq(struct nau8825 *nau8825)
1537 {
1538         struct regmap *regmap = nau8825->regmap;
1539
1540         /* Enable headset jack type detection complete interruption and
1541          * jack ejection interruption.
1542          */
1543         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
1544                 NAU8825_IRQ_HEADSET_COMPLETE_EN | NAU8825_IRQ_EJECT_EN, 0);
1545
1546         /* Enable internal VCO needed for interruptions */
1547         nau8825_configure_sysclk(nau8825, NAU8825_CLK_INTERNAL, 0);
1548
1549         /* Enable ADC needed for interruptions */
1550         regmap_update_bits(regmap, NAU8825_REG_ENA_CTRL,
1551                 NAU8825_ENABLE_ADC, NAU8825_ENABLE_ADC);
1552
1553         /* Chip needs one FSCLK cycle in order to generate interruptions,
1554          * as we cannot guarantee one will be provided by the system. Turning
1555          * master mode on then off enables us to generate that FSCLK cycle
1556          * with a minimum of contention on the clock bus.
1557          */
1558         regmap_update_bits(regmap, NAU8825_REG_I2S_PCM_CTRL2,
1559                 NAU8825_I2S_MS_MASK, NAU8825_I2S_MS_MASTER);
1560         regmap_update_bits(regmap, NAU8825_REG_I2S_PCM_CTRL2,
1561                 NAU8825_I2S_MS_MASK, NAU8825_I2S_MS_SLAVE);
1562
1563         /* Not bypass de-bounce circuit */
1564         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1565                 NAU8825_JACK_DET_DB_BYPASS, 0);
1566
1567         /* Unmask all interruptions */
1568         regmap_write(regmap, NAU8825_REG_INTERRUPT_DIS_CTRL, 0);
1569
1570         /* Restart the jack detection process at auto mode */
1571         nau8825_restart_jack_detection(regmap);
1572 }
1573
1574 static int nau8825_button_decode(int value)
1575 {
1576         int buttons = 0;
1577
1578         /* The chip supports up to 8 buttons, but ALSA defines only 6 buttons */
1579         if (value & BIT(0))
1580                 buttons |= SND_JACK_BTN_0;
1581         if (value & BIT(1))
1582                 buttons |= SND_JACK_BTN_1;
1583         if (value & BIT(2))
1584                 buttons |= SND_JACK_BTN_2;
1585         if (value & BIT(3))
1586                 buttons |= SND_JACK_BTN_3;
1587         if (value & BIT(4))
1588                 buttons |= SND_JACK_BTN_4;
1589         if (value & BIT(5))
1590                 buttons |= SND_JACK_BTN_5;
1591
1592         return buttons;
1593 }
1594
1595 static int nau8825_jack_insert(struct nau8825 *nau8825)
1596 {
1597         struct regmap *regmap = nau8825->regmap;
1598         struct snd_soc_dapm_context *dapm = nau8825->dapm;
1599         int jack_status_reg, mic_detected;
1600         int type = 0;
1601
1602         regmap_read(regmap, NAU8825_REG_GENERAL_STATUS, &jack_status_reg);
1603         mic_detected = (jack_status_reg >> 10) & 3;
1604         /* The JKSLV and JKR2 all detected in high impedance headset */
1605         if (mic_detected == 0x3)
1606                 nau8825->high_imped = true;
1607         else
1608                 nau8825->high_imped = false;
1609
1610         switch (mic_detected) {
1611         case 0:
1612                 /* no mic */
1613                 type = SND_JACK_HEADPHONE;
1614                 break;
1615         case 1:
1616                 dev_dbg(nau8825->dev, "OMTP (micgnd1) mic connected\n");
1617                 type = SND_JACK_HEADSET;
1618
1619                 /* Unground MICGND1 */
1620                 regmap_update_bits(regmap, NAU8825_REG_HSD_CTRL, 3 << 2,
1621                         1 << 2);
1622                 /* Attach 2kOhm Resistor from MICBIAS to MICGND1 */
1623                 regmap_update_bits(regmap, NAU8825_REG_MIC_BIAS,
1624                         NAU8825_MICBIAS_JKSLV | NAU8825_MICBIAS_JKR2,
1625                         NAU8825_MICBIAS_JKR2);
1626                 /* Attach SARADC to MICGND1 */
1627                 regmap_update_bits(regmap, NAU8825_REG_SAR_CTRL,
1628                         NAU8825_SAR_INPUT_MASK,
1629                         NAU8825_SAR_INPUT_JKR2);
1630
1631                 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
1632                 snd_soc_dapm_force_enable_pin(dapm, "SAR");
1633                 snd_soc_dapm_sync(dapm);
1634                 break;
1635         case 2:
1636                 dev_dbg(nau8825->dev, "CTIA (micgnd2) mic connected\n");
1637                 type = SND_JACK_HEADSET;
1638
1639                 /* Unground MICGND2 */
1640                 regmap_update_bits(regmap, NAU8825_REG_HSD_CTRL, 3 << 2,
1641                         2 << 2);
1642                 /* Attach 2kOhm Resistor from MICBIAS to MICGND2 */
1643                 regmap_update_bits(regmap, NAU8825_REG_MIC_BIAS,
1644                         NAU8825_MICBIAS_JKSLV | NAU8825_MICBIAS_JKR2,
1645                         NAU8825_MICBIAS_JKSLV);
1646                 /* Attach SARADC to MICGND2 */
1647                 regmap_update_bits(regmap, NAU8825_REG_SAR_CTRL,
1648                         NAU8825_SAR_INPUT_MASK,
1649                         NAU8825_SAR_INPUT_JKSLV);
1650
1651                 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS");
1652                 snd_soc_dapm_force_enable_pin(dapm, "SAR");
1653                 snd_soc_dapm_sync(dapm);
1654                 break;
1655         case 3:
1656                 /* detect error case */
1657                 dev_err(nau8825->dev, "detection error; disable mic function\n");
1658                 type = SND_JACK_HEADPHONE;
1659                 break;
1660         }
1661
1662         /* Leaving HPOL/R grounded after jack insert by default. They will be
1663          * ungrounded as part of the widget power up sequence at the beginning
1664          * of playback to reduce pop.
1665          */
1666         return type;
1667 }
1668
1669 #define NAU8825_BUTTONS (SND_JACK_BTN_0 | SND_JACK_BTN_1 | \
1670                 SND_JACK_BTN_2 | SND_JACK_BTN_3)
1671
1672 static irqreturn_t nau8825_interrupt(int irq, void *data)
1673 {
1674         struct nau8825 *nau8825 = (struct nau8825 *)data;
1675         struct regmap *regmap = nau8825->regmap;
1676         int active_irq, clear_irq = 0, event = 0, event_mask = 0;
1677
1678         if (regmap_read(regmap, NAU8825_REG_IRQ_STATUS, &active_irq)) {
1679                 dev_err(nau8825->dev, "failed to read irq status\n");
1680                 return IRQ_NONE;
1681         }
1682
1683         if ((active_irq & NAU8825_JACK_EJECTION_IRQ_MASK) ==
1684                 NAU8825_JACK_EJECTION_DETECTED) {
1685
1686                 nau8825_eject_jack(nau8825);
1687                 event_mask |= SND_JACK_HEADSET;
1688                 clear_irq = NAU8825_JACK_EJECTION_IRQ_MASK;
1689         } else if (active_irq & NAU8825_KEY_SHORT_PRESS_IRQ) {
1690                 int key_status;
1691
1692                 regmap_read(regmap, NAU8825_REG_INT_CLR_KEY_STATUS,
1693                         &key_status);
1694
1695                 /* upper 8 bits of the register are for short pressed keys,
1696                  * lower 8 bits - for long pressed buttons
1697                  */
1698                 nau8825->button_pressed = nau8825_button_decode(
1699                         key_status >> 8);
1700
1701                 event |= nau8825->button_pressed;
1702                 event_mask |= NAU8825_BUTTONS;
1703                 clear_irq = NAU8825_KEY_SHORT_PRESS_IRQ;
1704         } else if (active_irq & NAU8825_KEY_RELEASE_IRQ) {
1705                 event_mask = NAU8825_BUTTONS;
1706                 clear_irq = NAU8825_KEY_RELEASE_IRQ;
1707         } else if (active_irq & NAU8825_HEADSET_COMPLETION_IRQ) {
1708                 if (nau8825_is_jack_inserted(regmap)) {
1709                         event |= nau8825_jack_insert(nau8825);
1710                         if (nau8825->xtalk_enable && !nau8825->high_imped) {
1711                                 /* Apply the cross talk suppression in the
1712                                  * headset without high impedance.
1713                                  */
1714                                 if (!nau8825->xtalk_protect) {
1715                                         /* Raise protection for cross talk de-
1716                                          * tection if no protection before.
1717                                          * The driver has to cancel the pro-
1718                                          * cess and restore changes if process
1719                                          * is ongoing when ejection.
1720                                          */
1721                                         int ret;
1722                                         nau8825->xtalk_protect = true;
1723                                         ret = nau8825_sema_acquire(nau8825, 0);
1724                                         if (ret)
1725                                                 nau8825->xtalk_protect = false;
1726                                 }
1727                                 /* Startup cross talk detection process */
1728                                 if (nau8825->xtalk_protect) {
1729                                         nau8825->xtalk_state =
1730                                                 NAU8825_XTALK_PREPARE;
1731                                         schedule_work(&nau8825->xtalk_work);
1732                                 }
1733                         } else {
1734                                 /* The cross talk suppression shouldn't apply
1735                                  * in the headset with high impedance. Thus,
1736                                  * relieve the protection raised before.
1737                                  */
1738                                 if (nau8825->xtalk_protect) {
1739                                         nau8825_sema_release(nau8825);
1740                                         nau8825->xtalk_protect = false;
1741                                 }
1742                         }
1743                 } else {
1744                         dev_warn(nau8825->dev, "Headset completion IRQ fired but no headset connected\n");
1745                         nau8825_eject_jack(nau8825);
1746                 }
1747
1748                 event_mask |= SND_JACK_HEADSET;
1749                 clear_irq = NAU8825_HEADSET_COMPLETION_IRQ;
1750                 /* Record the interruption report event for driver to report
1751                  * the event later. The jack report will delay until cross
1752                  * talk detection process is done.
1753                  */
1754                 if (nau8825->xtalk_state == NAU8825_XTALK_PREPARE) {
1755                         nau8825->xtalk_event = event;
1756                         nau8825->xtalk_event_mask = event_mask;
1757                 }
1758         } else if (active_irq & NAU8825_IMPEDANCE_MEAS_IRQ) {
1759                 /* crosstalk detection enable and process on going */
1760                 if (nau8825->xtalk_enable && nau8825->xtalk_protect)
1761                         schedule_work(&nau8825->xtalk_work);
1762                 clear_irq = NAU8825_IMPEDANCE_MEAS_IRQ;
1763         } else if ((active_irq & NAU8825_JACK_INSERTION_IRQ_MASK) ==
1764                 NAU8825_JACK_INSERTION_DETECTED) {
1765                 /* One more step to check GPIO status directly. Thus, the
1766                  * driver can confirm the real insertion interruption because
1767                  * the intrruption at manual mode has bypassed debounce
1768                  * circuit which can get rid of unstable status.
1769                  */
1770                 if (nau8825_is_jack_inserted(regmap)) {
1771                         /* Turn off insertion interruption at manual mode */
1772                         regmap_update_bits(regmap,
1773                                 NAU8825_REG_INTERRUPT_DIS_CTRL,
1774                                 NAU8825_IRQ_INSERT_DIS,
1775                                 NAU8825_IRQ_INSERT_DIS);
1776                         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
1777                                 NAU8825_IRQ_INSERT_EN, NAU8825_IRQ_INSERT_EN);
1778                         /* Enable interruption for jack type detection at audo
1779                          * mode which can detect microphone and jack type.
1780                          */
1781                         nau8825_setup_auto_irq(nau8825);
1782                 }
1783         }
1784
1785         if (!clear_irq)
1786                 clear_irq = active_irq;
1787         /* clears the rightmost interruption */
1788         regmap_write(regmap, NAU8825_REG_INT_CLR_KEY_STATUS, clear_irq);
1789
1790         /* Delay jack report until cross talk detection is done. It can avoid
1791          * application to do playback preparation when cross talk detection
1792          * process is still working. Otherwise, the resource like clock and
1793          * power will be issued by them at the same time and conflict happens.
1794          */
1795         if (event_mask && nau8825->xtalk_state == NAU8825_XTALK_DONE)
1796                 snd_soc_jack_report(nau8825->jack, event, event_mask);
1797
1798         return IRQ_HANDLED;
1799 }
1800
1801 static void nau8825_setup_buttons(struct nau8825 *nau8825)
1802 {
1803         struct regmap *regmap = nau8825->regmap;
1804
1805         regmap_update_bits(regmap, NAU8825_REG_SAR_CTRL,
1806                 NAU8825_SAR_TRACKING_GAIN_MASK,
1807                 nau8825->sar_voltage << NAU8825_SAR_TRACKING_GAIN_SFT);
1808         regmap_update_bits(regmap, NAU8825_REG_SAR_CTRL,
1809                 NAU8825_SAR_COMPARE_TIME_MASK,
1810                 nau8825->sar_compare_time << NAU8825_SAR_COMPARE_TIME_SFT);
1811         regmap_update_bits(regmap, NAU8825_REG_SAR_CTRL,
1812                 NAU8825_SAR_SAMPLING_TIME_MASK,
1813                 nau8825->sar_sampling_time << NAU8825_SAR_SAMPLING_TIME_SFT);
1814
1815         regmap_update_bits(regmap, NAU8825_REG_KEYDET_CTRL,
1816                 NAU8825_KEYDET_LEVELS_NR_MASK,
1817                 (nau8825->sar_threshold_num - 1) << NAU8825_KEYDET_LEVELS_NR_SFT);
1818         regmap_update_bits(regmap, NAU8825_REG_KEYDET_CTRL,
1819                 NAU8825_KEYDET_HYSTERESIS_MASK,
1820                 nau8825->sar_hysteresis << NAU8825_KEYDET_HYSTERESIS_SFT);
1821         regmap_update_bits(regmap, NAU8825_REG_KEYDET_CTRL,
1822                 NAU8825_KEYDET_SHORTKEY_DEBOUNCE_MASK,
1823                 nau8825->key_debounce << NAU8825_KEYDET_SHORTKEY_DEBOUNCE_SFT);
1824
1825         regmap_write(regmap, NAU8825_REG_VDET_THRESHOLD_1,
1826                 (nau8825->sar_threshold[0] << 8) | nau8825->sar_threshold[1]);
1827         regmap_write(regmap, NAU8825_REG_VDET_THRESHOLD_2,
1828                 (nau8825->sar_threshold[2] << 8) | nau8825->sar_threshold[3]);
1829         regmap_write(regmap, NAU8825_REG_VDET_THRESHOLD_3,
1830                 (nau8825->sar_threshold[4] << 8) | nau8825->sar_threshold[5]);
1831         regmap_write(regmap, NAU8825_REG_VDET_THRESHOLD_4,
1832                 (nau8825->sar_threshold[6] << 8) | nau8825->sar_threshold[7]);
1833
1834         /* Enable short press and release interruptions */
1835         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
1836                 NAU8825_IRQ_KEY_SHORT_PRESS_EN | NAU8825_IRQ_KEY_RELEASE_EN,
1837                 0);
1838 }
1839
1840 static void nau8825_init_regs(struct nau8825 *nau8825)
1841 {
1842         struct regmap *regmap = nau8825->regmap;
1843
1844         /* Latch IIC LSB value */
1845         regmap_write(regmap, NAU8825_REG_IIC_ADDR_SET, 0x0001);
1846         /* Enable Bias/Vmid */
1847         regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
1848                 NAU8825_BIAS_VMID, NAU8825_BIAS_VMID);
1849         regmap_update_bits(nau8825->regmap, NAU8825_REG_BOOST,
1850                 NAU8825_GLOBAL_BIAS_EN, NAU8825_GLOBAL_BIAS_EN);
1851
1852         /* VMID Tieoff */
1853         regmap_update_bits(regmap, NAU8825_REG_BIAS_ADJ,
1854                 NAU8825_BIAS_VMID_SEL_MASK,
1855                 nau8825->vref_impedance << NAU8825_BIAS_VMID_SEL_SFT);
1856         /* Disable Boost Driver, Automatic Short circuit protection enable */
1857         regmap_update_bits(regmap, NAU8825_REG_BOOST,
1858                 NAU8825_PRECHARGE_DIS | NAU8825_HP_BOOST_DIS |
1859                 NAU8825_HP_BOOST_G_DIS | NAU8825_SHORT_SHUTDOWN_EN,
1860                 NAU8825_PRECHARGE_DIS | NAU8825_HP_BOOST_DIS |
1861                 NAU8825_HP_BOOST_G_DIS | NAU8825_SHORT_SHUTDOWN_EN);
1862
1863         regmap_update_bits(regmap, NAU8825_REG_GPIO12_CTRL,
1864                 NAU8825_JKDET_OUTPUT_EN,
1865                 nau8825->jkdet_enable ? 0 : NAU8825_JKDET_OUTPUT_EN);
1866         regmap_update_bits(regmap, NAU8825_REG_GPIO12_CTRL,
1867                 NAU8825_JKDET_PULL_EN,
1868                 nau8825->jkdet_pull_enable ? 0 : NAU8825_JKDET_PULL_EN);
1869         regmap_update_bits(regmap, NAU8825_REG_GPIO12_CTRL,
1870                 NAU8825_JKDET_PULL_UP,
1871                 nau8825->jkdet_pull_up ? NAU8825_JKDET_PULL_UP : 0);
1872         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1873                 NAU8825_JACK_POLARITY,
1874                 /* jkdet_polarity - 1  is for active-low */
1875                 nau8825->jkdet_polarity ? 0 : NAU8825_JACK_POLARITY);
1876
1877         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1878                 NAU8825_JACK_INSERT_DEBOUNCE_MASK,
1879                 nau8825->jack_insert_debounce << NAU8825_JACK_INSERT_DEBOUNCE_SFT);
1880         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
1881                 NAU8825_JACK_EJECT_DEBOUNCE_MASK,
1882                 nau8825->jack_eject_debounce << NAU8825_JACK_EJECT_DEBOUNCE_SFT);
1883
1884         /* Pull up IRQ pin */
1885         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
1886                 NAU8825_IRQ_PIN_PULLUP | NAU8825_IRQ_PIN_PULL_EN,
1887                 NAU8825_IRQ_PIN_PULLUP | NAU8825_IRQ_PIN_PULL_EN);
1888         /* Mask unneeded IRQs: 1 - disable, 0 - enable */
1889         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK, 0x7ff, 0x7ff);
1890
1891         regmap_update_bits(regmap, NAU8825_REG_MIC_BIAS,
1892                 NAU8825_MICBIAS_VOLTAGE_MASK, nau8825->micbias_voltage);
1893
1894         if (nau8825->sar_threshold_num)
1895                 nau8825_setup_buttons(nau8825);
1896
1897         /* Default oversampling/decimations settings are unusable
1898          * (audible hiss). Set it to something better.
1899          */
1900         regmap_update_bits(regmap, NAU8825_REG_ADC_RATE,
1901                 NAU8825_ADC_SYNC_DOWN_MASK | NAU8825_ADC_SINC4_EN,
1902                 NAU8825_ADC_SYNC_DOWN_64);
1903         regmap_update_bits(regmap, NAU8825_REG_DAC_CTRL1,
1904                 NAU8825_DAC_OVERSAMPLE_MASK, NAU8825_DAC_OVERSAMPLE_64);
1905         /* Disable DACR/L power */
1906         regmap_update_bits(regmap, NAU8825_REG_CHARGE_PUMP,
1907                 NAU8825_POWER_DOWN_DACR | NAU8825_POWER_DOWN_DACL,
1908                 NAU8825_POWER_DOWN_DACR | NAU8825_POWER_DOWN_DACL);
1909         /* Enable TESTDAC. This sets the analog DAC inputs to a '0' input
1910          * signal to avoid any glitches due to power up transients in both
1911          * the analog and digital DAC circuit.
1912          */
1913         regmap_update_bits(nau8825->regmap, NAU8825_REG_BIAS_ADJ,
1914                 NAU8825_BIAS_TESTDAC_EN, NAU8825_BIAS_TESTDAC_EN);
1915         /* CICCLP off */
1916         regmap_update_bits(regmap, NAU8825_REG_DAC_CTRL1,
1917                 NAU8825_DAC_CLIP_OFF, NAU8825_DAC_CLIP_OFF);
1918
1919         /* Class AB bias current to 2x, DAC Capacitor enable MSB/LSB */
1920         regmap_update_bits(regmap, NAU8825_REG_ANALOG_CONTROL_2,
1921                 NAU8825_HP_NON_CLASSG_CURRENT_2xADJ |
1922                 NAU8825_DAC_CAPACITOR_MSB | NAU8825_DAC_CAPACITOR_LSB,
1923                 NAU8825_HP_NON_CLASSG_CURRENT_2xADJ |
1924                 NAU8825_DAC_CAPACITOR_MSB | NAU8825_DAC_CAPACITOR_LSB);
1925         /* Class G timer 64ms */
1926         regmap_update_bits(regmap, NAU8825_REG_CLASSG_CTRL,
1927                 NAU8825_CLASSG_TIMER_MASK,
1928                 0x20 << NAU8825_CLASSG_TIMER_SFT);
1929         /* DAC clock delay 2ns, VREF */
1930         regmap_update_bits(regmap, NAU8825_REG_RDAC,
1931                 NAU8825_RDAC_CLK_DELAY_MASK | NAU8825_RDAC_VREF_MASK,
1932                 (0x2 << NAU8825_RDAC_CLK_DELAY_SFT) |
1933                 (0x3 << NAU8825_RDAC_VREF_SFT));
1934         /* Config L/R channel */
1935         regmap_update_bits(nau8825->regmap, NAU8825_REG_DACL_CTRL,
1936                 NAU8825_DACL_CH_SEL_MASK, NAU8825_DACL_CH_SEL_L);
1937         regmap_update_bits(nau8825->regmap, NAU8825_REG_DACR_CTRL,
1938                 NAU8825_DACL_CH_SEL_MASK, NAU8825_DACL_CH_SEL_R);
1939         /* Disable short Frame Sync detection logic */
1940         regmap_update_bits(regmap, NAU8825_REG_LEFT_TIME_SLOT,
1941                 NAU8825_DIS_FS_SHORT_DET, NAU8825_DIS_FS_SHORT_DET);
1942 }
1943
1944 static const struct regmap_config nau8825_regmap_config = {
1945         .val_bits = NAU8825_REG_DATA_LEN,
1946         .reg_bits = NAU8825_REG_ADDR_LEN,
1947
1948         .max_register = NAU8825_REG_MAX,
1949         .readable_reg = nau8825_readable_reg,
1950         .writeable_reg = nau8825_writeable_reg,
1951         .volatile_reg = nau8825_volatile_reg,
1952
1953         .cache_type = REGCACHE_RBTREE,
1954         .reg_defaults = nau8825_reg_defaults,
1955         .num_reg_defaults = ARRAY_SIZE(nau8825_reg_defaults),
1956 };
1957
1958 static int nau8825_component_probe(struct snd_soc_component *component)
1959 {
1960         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
1961         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1962
1963         nau8825->dapm = dapm;
1964
1965         return 0;
1966 }
1967
1968 static void nau8825_component_remove(struct snd_soc_component *component)
1969 {
1970         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
1971
1972         /* Cancel and reset cross tak suppresstion detection funciton */
1973         nau8825_xtalk_cancel(nau8825);
1974 }
1975
1976 /**
1977  * nau8825_calc_fll_param - Calculate FLL parameters.
1978  * @fll_in: external clock provided to codec.
1979  * @fs: sampling rate.
1980  * @fll_param: Pointer to structure of FLL parameters.
1981  *
1982  * Calculate FLL parameters to configure codec.
1983  *
1984  * Returns 0 for success or negative error code.
1985  */
1986 static int nau8825_calc_fll_param(unsigned int fll_in, unsigned int fs,
1987                 struct nau8825_fll *fll_param)
1988 {
1989         u64 fvco, fvco_max;
1990         unsigned int fref, i, fvco_sel;
1991
1992         /* Ensure the reference clock frequency (FREF) is <= 13.5MHz by dividing
1993          * freq_in by 1, 2, 4, or 8 using FLL pre-scalar.
1994          * FREF = freq_in / NAU8825_FLL_REF_DIV_MASK
1995          */
1996         for (i = 0; i < ARRAY_SIZE(fll_pre_scalar); i++) {
1997                 fref = fll_in / fll_pre_scalar[i].param;
1998                 if (fref <= NAU_FREF_MAX)
1999                         break;
2000         }
2001         if (i == ARRAY_SIZE(fll_pre_scalar))
2002                 return -EINVAL;
2003         fll_param->clk_ref_div = fll_pre_scalar[i].val;
2004
2005         /* Choose the FLL ratio based on FREF */
2006         for (i = 0; i < ARRAY_SIZE(fll_ratio); i++) {
2007                 if (fref >= fll_ratio[i].param)
2008                         break;
2009         }
2010         if (i == ARRAY_SIZE(fll_ratio))
2011                 return -EINVAL;
2012         fll_param->ratio = fll_ratio[i].val;
2013
2014         /* Calculate the frequency of DCO (FDCO) given freq_out = 256 * Fs.
2015          * FDCO must be within the 90MHz - 124MHz or the FFL cannot be
2016          * guaranteed across the full range of operation.
2017          * FDCO = freq_out * 2 * mclk_src_scaling
2018          */
2019         fvco_max = 0;
2020         fvco_sel = ARRAY_SIZE(mclk_src_scaling);
2021         for (i = 0; i < ARRAY_SIZE(mclk_src_scaling); i++) {
2022                 fvco = 256ULL * fs * 2 * mclk_src_scaling[i].param;
2023                 if (fvco > NAU_FVCO_MIN && fvco < NAU_FVCO_MAX &&
2024                         fvco_max < fvco) {
2025                         fvco_max = fvco;
2026                         fvco_sel = i;
2027                 }
2028         }
2029         if (ARRAY_SIZE(mclk_src_scaling) == fvco_sel)
2030                 return -EINVAL;
2031         fll_param->mclk_src = mclk_src_scaling[fvco_sel].val;
2032
2033         /* Calculate the FLL 10-bit integer input and the FLL 16-bit fractional
2034          * input based on FDCO, FREF and FLL ratio.
2035          */
2036         fvco = div_u64(fvco_max << 16, fref * fll_param->ratio);
2037         fll_param->fll_int = (fvco >> 16) & 0x3FF;
2038         fll_param->fll_frac = fvco & 0xFFFF;
2039         return 0;
2040 }
2041
2042 static void nau8825_fll_apply(struct nau8825 *nau8825,
2043                 struct nau8825_fll *fll_param)
2044 {
2045         regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
2046                 NAU8825_CLK_SRC_MASK | NAU8825_CLK_MCLK_SRC_MASK,
2047                 NAU8825_CLK_SRC_MCLK | fll_param->mclk_src);
2048         /* Make DSP operate at high speed for better performance. */
2049         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL1,
2050                 NAU8825_FLL_RATIO_MASK | NAU8825_ICTRL_LATCH_MASK,
2051                 fll_param->ratio | (0x6 << NAU8825_ICTRL_LATCH_SFT));
2052         /* FLL 16-bit fractional input */
2053         regmap_write(nau8825->regmap, NAU8825_REG_FLL2, fll_param->fll_frac);
2054         /* FLL 10-bit integer input */
2055         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL3,
2056                         NAU8825_FLL_INTEGER_MASK, fll_param->fll_int);
2057         /* FLL pre-scaler */
2058         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL4,
2059                         NAU8825_FLL_REF_DIV_MASK,
2060                         fll_param->clk_ref_div << NAU8825_FLL_REF_DIV_SFT);
2061         /* select divided VCO input */
2062         regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL5,
2063                 NAU8825_FLL_CLK_SW_MASK, NAU8825_FLL_CLK_SW_REF);
2064         /* Disable free-running mode */
2065         regmap_update_bits(nau8825->regmap,
2066                 NAU8825_REG_FLL6, NAU8825_DCO_EN, 0);
2067         if (fll_param->fll_frac) {
2068                 /* set FLL loop filter enable and cutoff frequency at 500Khz */
2069                 regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL5,
2070                         NAU8825_FLL_PDB_DAC_EN | NAU8825_FLL_LOOP_FTR_EN |
2071                         NAU8825_FLL_FTR_SW_MASK,
2072                         NAU8825_FLL_PDB_DAC_EN | NAU8825_FLL_LOOP_FTR_EN |
2073                         NAU8825_FLL_FTR_SW_FILTER);
2074                 regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL6,
2075                         NAU8825_SDM_EN | NAU8825_CUTOFF500,
2076                         NAU8825_SDM_EN | NAU8825_CUTOFF500);
2077         } else {
2078                 /* disable FLL loop filter and cutoff frequency */
2079                 regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL5,
2080                         NAU8825_FLL_PDB_DAC_EN | NAU8825_FLL_LOOP_FTR_EN |
2081                         NAU8825_FLL_FTR_SW_MASK, NAU8825_FLL_FTR_SW_ACCU);
2082                 regmap_update_bits(nau8825->regmap, NAU8825_REG_FLL6,
2083                         NAU8825_SDM_EN | NAU8825_CUTOFF500, 0);
2084         }
2085 }
2086
2087 /* freq_out must be 256*Fs in order to achieve the best performance */
2088 static int nau8825_set_pll(struct snd_soc_component *component, int pll_id, int source,
2089                 unsigned int freq_in, unsigned int freq_out)
2090 {
2091         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
2092         struct nau8825_fll fll_param;
2093         int ret, fs;
2094
2095         fs = freq_out / 256;
2096         ret = nau8825_calc_fll_param(freq_in, fs, &fll_param);
2097         if (ret < 0) {
2098                 dev_err(component->dev, "Unsupported input clock %d\n", freq_in);
2099                 return ret;
2100         }
2101         dev_dbg(component->dev, "mclk_src=%x ratio=%x fll_frac=%x fll_int=%x clk_ref_div=%x\n",
2102                 fll_param.mclk_src, fll_param.ratio, fll_param.fll_frac,
2103                 fll_param.fll_int, fll_param.clk_ref_div);
2104
2105         nau8825_fll_apply(nau8825, &fll_param);
2106         mdelay(2);
2107         regmap_update_bits(nau8825->regmap, NAU8825_REG_CLK_DIVIDER,
2108                         NAU8825_CLK_SRC_MASK, NAU8825_CLK_SRC_VCO);
2109         return 0;
2110 }
2111
2112 static int nau8825_mclk_prepare(struct nau8825 *nau8825, unsigned int freq)
2113 {
2114         int ret;
2115
2116         nau8825->mclk = devm_clk_get(nau8825->dev, "mclk");
2117         if (IS_ERR(nau8825->mclk)) {
2118                 dev_info(nau8825->dev, "No 'mclk' clock found, assume MCLK is managed externally");
2119                 return 0;
2120         }
2121
2122         if (!nau8825->mclk_freq) {
2123                 ret = clk_prepare_enable(nau8825->mclk);
2124                 if (ret) {
2125                         dev_err(nau8825->dev, "Unable to prepare codec mclk\n");
2126                         return ret;
2127                 }
2128         }
2129
2130         if (nau8825->mclk_freq != freq) {
2131                 freq = clk_round_rate(nau8825->mclk, freq);
2132                 ret = clk_set_rate(nau8825->mclk, freq);
2133                 if (ret) {
2134                         dev_err(nau8825->dev, "Unable to set mclk rate\n");
2135                         return ret;
2136                 }
2137                 nau8825->mclk_freq = freq;
2138         }
2139
2140         return 0;
2141 }
2142
2143 static void nau8825_configure_mclk_as_sysclk(struct regmap *regmap)
2144 {
2145         regmap_update_bits(regmap, NAU8825_REG_CLK_DIVIDER,
2146                 NAU8825_CLK_SRC_MASK, NAU8825_CLK_SRC_MCLK);
2147         regmap_update_bits(regmap, NAU8825_REG_FLL6,
2148                 NAU8825_DCO_EN, 0);
2149         /* Make DSP operate as default setting for power saving. */
2150         regmap_update_bits(regmap, NAU8825_REG_FLL1,
2151                 NAU8825_ICTRL_LATCH_MASK, 0);
2152 }
2153
2154 static int nau8825_configure_sysclk(struct nau8825 *nau8825, int clk_id,
2155         unsigned int freq)
2156 {
2157         struct regmap *regmap = nau8825->regmap;
2158         int ret;
2159
2160         switch (clk_id) {
2161         case NAU8825_CLK_DIS:
2162                 /* Clock provided externally and disable internal VCO clock */
2163                 nau8825_configure_mclk_as_sysclk(regmap);
2164                 if (nau8825->mclk_freq) {
2165                         clk_disable_unprepare(nau8825->mclk);
2166                         nau8825->mclk_freq = 0;
2167                 }
2168
2169                 break;
2170         case NAU8825_CLK_MCLK:
2171                 /* Acquire the semaphore to synchronize the playback and
2172                  * interrupt handler. In order to avoid the playback inter-
2173                  * fered by cross talk process, the driver make the playback
2174                  * preparation halted until cross talk process finish.
2175                  */
2176                 nau8825_sema_acquire(nau8825, 3 * HZ);
2177                 nau8825_configure_mclk_as_sysclk(regmap);
2178                 /* MCLK not changed by clock tree */
2179                 regmap_update_bits(regmap, NAU8825_REG_CLK_DIVIDER,
2180                         NAU8825_CLK_MCLK_SRC_MASK, 0);
2181                 /* Release the semaphore. */
2182                 nau8825_sema_release(nau8825);
2183
2184                 ret = nau8825_mclk_prepare(nau8825, freq);
2185                 if (ret)
2186                         return ret;
2187
2188                 break;
2189         case NAU8825_CLK_INTERNAL:
2190                 if (nau8825_is_jack_inserted(nau8825->regmap)) {
2191                         regmap_update_bits(regmap, NAU8825_REG_FLL6,
2192                                 NAU8825_DCO_EN, NAU8825_DCO_EN);
2193                         regmap_update_bits(regmap, NAU8825_REG_CLK_DIVIDER,
2194                                 NAU8825_CLK_SRC_MASK, NAU8825_CLK_SRC_VCO);
2195                         /* Decrease the VCO frequency and make DSP operate
2196                          * as default setting for power saving.
2197                          */
2198                         regmap_update_bits(regmap, NAU8825_REG_CLK_DIVIDER,
2199                                 NAU8825_CLK_MCLK_SRC_MASK, 0xf);
2200                         regmap_update_bits(regmap, NAU8825_REG_FLL1,
2201                                 NAU8825_ICTRL_LATCH_MASK |
2202                                 NAU8825_FLL_RATIO_MASK, 0x10);
2203                         regmap_update_bits(regmap, NAU8825_REG_FLL6,
2204                                 NAU8825_SDM_EN, NAU8825_SDM_EN);
2205                 } else {
2206                         /* The clock turns off intentionally for power saving
2207                          * when no headset connected.
2208                          */
2209                         nau8825_configure_mclk_as_sysclk(regmap);
2210                         dev_warn(nau8825->dev, "Disable clock for power saving when no headset connected\n");
2211                 }
2212                 if (nau8825->mclk_freq) {
2213                         clk_disable_unprepare(nau8825->mclk);
2214                         nau8825->mclk_freq = 0;
2215                 }
2216
2217                 break;
2218         case NAU8825_CLK_FLL_MCLK:
2219                 /* Acquire the semaphore to synchronize the playback and
2220                  * interrupt handler. In order to avoid the playback inter-
2221                  * fered by cross talk process, the driver make the playback
2222                  * preparation halted until cross talk process finish.
2223                  */
2224                 nau8825_sema_acquire(nau8825, 3 * HZ);
2225                 /* Higher FLL reference input frequency can only set lower
2226                  * gain error, such as 0000 for input reference from MCLK
2227                  * 12.288Mhz.
2228                  */
2229                 regmap_update_bits(regmap, NAU8825_REG_FLL3,
2230                         NAU8825_FLL_CLK_SRC_MASK | NAU8825_GAIN_ERR_MASK,
2231                         NAU8825_FLL_CLK_SRC_MCLK | 0);
2232                 /* Release the semaphore. */
2233                 nau8825_sema_release(nau8825);
2234
2235                 ret = nau8825_mclk_prepare(nau8825, freq);
2236                 if (ret)
2237                         return ret;
2238
2239                 break;
2240         case NAU8825_CLK_FLL_BLK:
2241                 /* Acquire the semaphore to synchronize the playback and
2242                  * interrupt handler. In order to avoid the playback inter-
2243                  * fered by cross talk process, the driver make the playback
2244                  * preparation halted until cross talk process finish.
2245                  */
2246                 nau8825_sema_acquire(nau8825, 3 * HZ);
2247                 /* If FLL reference input is from low frequency source,
2248                  * higher error gain can apply such as 0xf which has
2249                  * the most sensitive gain error correction threshold,
2250                  * Therefore, FLL has the most accurate DCO to
2251                  * target frequency.
2252                  */
2253                 regmap_update_bits(regmap, NAU8825_REG_FLL3,
2254                         NAU8825_FLL_CLK_SRC_MASK | NAU8825_GAIN_ERR_MASK,
2255                         NAU8825_FLL_CLK_SRC_BLK |
2256                         (0xf << NAU8825_GAIN_ERR_SFT));
2257                 /* Release the semaphore. */
2258                 nau8825_sema_release(nau8825);
2259
2260                 if (nau8825->mclk_freq) {
2261                         clk_disable_unprepare(nau8825->mclk);
2262                         nau8825->mclk_freq = 0;
2263                 }
2264
2265                 break;
2266         case NAU8825_CLK_FLL_FS:
2267                 /* Acquire the semaphore to synchronize the playback and
2268                  * interrupt handler. In order to avoid the playback inter-
2269                  * fered by cross talk process, the driver make the playback
2270                  * preparation halted until cross talk process finish.
2271                  */
2272                 nau8825_sema_acquire(nau8825, 3 * HZ);
2273                 /* If FLL reference input is from low frequency source,
2274                  * higher error gain can apply such as 0xf which has
2275                  * the most sensitive gain error correction threshold,
2276                  * Therefore, FLL has the most accurate DCO to
2277                  * target frequency.
2278                  */
2279                 regmap_update_bits(regmap, NAU8825_REG_FLL3,
2280                         NAU8825_FLL_CLK_SRC_MASK | NAU8825_GAIN_ERR_MASK,
2281                         NAU8825_FLL_CLK_SRC_FS |
2282                         (0xf << NAU8825_GAIN_ERR_SFT));
2283                 /* Release the semaphore. */
2284                 nau8825_sema_release(nau8825);
2285
2286                 if (nau8825->mclk_freq) {
2287                         clk_disable_unprepare(nau8825->mclk);
2288                         nau8825->mclk_freq = 0;
2289                 }
2290
2291                 break;
2292         default:
2293                 dev_err(nau8825->dev, "Invalid clock id (%d)\n", clk_id);
2294                 return -EINVAL;
2295         }
2296
2297         dev_dbg(nau8825->dev, "Sysclk is %dHz and clock id is %d\n", freq,
2298                 clk_id);
2299         return 0;
2300 }
2301
2302 static int nau8825_set_sysclk(struct snd_soc_component *component, int clk_id,
2303         int source, unsigned int freq, int dir)
2304 {
2305         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
2306
2307         return nau8825_configure_sysclk(nau8825, clk_id, freq);
2308 }
2309
2310 static int nau8825_resume_setup(struct nau8825 *nau8825)
2311 {
2312         struct regmap *regmap = nau8825->regmap;
2313
2314         /* Close clock when jack type detection at manual mode */
2315         nau8825_configure_sysclk(nau8825, NAU8825_CLK_DIS, 0);
2316
2317         /* Clear all interruption status */
2318         nau8825_int_status_clear_all(regmap);
2319
2320         /* Enable both insertion and ejection interruptions, and then
2321          * bypass de-bounce circuit.
2322          */
2323         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_MASK,
2324                 NAU8825_IRQ_OUTPUT_EN | NAU8825_IRQ_HEADSET_COMPLETE_EN |
2325                 NAU8825_IRQ_EJECT_EN | NAU8825_IRQ_INSERT_EN,
2326                 NAU8825_IRQ_OUTPUT_EN | NAU8825_IRQ_HEADSET_COMPLETE_EN);
2327         regmap_update_bits(regmap, NAU8825_REG_JACK_DET_CTRL,
2328                 NAU8825_JACK_DET_DB_BYPASS, NAU8825_JACK_DET_DB_BYPASS);
2329         regmap_update_bits(regmap, NAU8825_REG_INTERRUPT_DIS_CTRL,
2330                 NAU8825_IRQ_INSERT_DIS | NAU8825_IRQ_EJECT_DIS, 0);
2331
2332         return 0;
2333 }
2334
2335 static int nau8825_set_bias_level(struct snd_soc_component *component,
2336                                    enum snd_soc_bias_level level)
2337 {
2338         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
2339         int ret;
2340
2341         switch (level) {
2342         case SND_SOC_BIAS_ON:
2343                 break;
2344
2345         case SND_SOC_BIAS_PREPARE:
2346                 break;
2347
2348         case SND_SOC_BIAS_STANDBY:
2349                 if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
2350                         if (nau8825->mclk_freq) {
2351                                 ret = clk_prepare_enable(nau8825->mclk);
2352                                 if (ret) {
2353                                         dev_err(nau8825->dev, "Unable to prepare component mclk\n");
2354                                         return ret;
2355                                 }
2356                         }
2357                         /* Setup codec configuration after resume */
2358                         nau8825_resume_setup(nau8825);
2359                 }
2360                 break;
2361
2362         case SND_SOC_BIAS_OFF:
2363                 /* Reset the configuration of jack type for detection */
2364                 /* Detach 2kOhm Resistors from MICBIAS to MICGND1/2 */
2365                 regmap_update_bits(nau8825->regmap, NAU8825_REG_MIC_BIAS,
2366                         NAU8825_MICBIAS_JKSLV | NAU8825_MICBIAS_JKR2, 0);
2367                 /* ground HPL/HPR, MICGRND1/2 */
2368                 regmap_update_bits(nau8825->regmap,
2369                         NAU8825_REG_HSD_CTRL, 0xf, 0xf);
2370                 /* Cancel and reset cross talk detection funciton */
2371                 nau8825_xtalk_cancel(nau8825);
2372                 /* Turn off all interruptions before system shutdown. Keep the
2373                  * interruption quiet before resume setup completes.
2374                  */
2375                 regmap_write(nau8825->regmap,
2376                         NAU8825_REG_INTERRUPT_DIS_CTRL, 0xffff);
2377                 /* Disable ADC needed for interruptions at audo mode */
2378                 regmap_update_bits(nau8825->regmap, NAU8825_REG_ENA_CTRL,
2379                         NAU8825_ENABLE_ADC, 0);
2380                 if (nau8825->mclk_freq)
2381                         clk_disable_unprepare(nau8825->mclk);
2382                 break;
2383         }
2384         return 0;
2385 }
2386
2387 static int __maybe_unused nau8825_suspend(struct snd_soc_component *component)
2388 {
2389         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
2390
2391         disable_irq(nau8825->irq);
2392         snd_soc_component_force_bias_level(component, SND_SOC_BIAS_OFF);
2393         /* Power down codec power; don't suppoet button wakeup */
2394         snd_soc_dapm_disable_pin(nau8825->dapm, "SAR");
2395         snd_soc_dapm_disable_pin(nau8825->dapm, "MICBIAS");
2396         snd_soc_dapm_sync(nau8825->dapm);
2397         regcache_cache_only(nau8825->regmap, true);
2398         regcache_mark_dirty(nau8825->regmap);
2399
2400         return 0;
2401 }
2402
2403 static int __maybe_unused nau8825_resume(struct snd_soc_component *component)
2404 {
2405         struct nau8825 *nau8825 = snd_soc_component_get_drvdata(component);
2406         int ret;
2407
2408         regcache_cache_only(nau8825->regmap, false);
2409         regcache_sync(nau8825->regmap);
2410         nau8825->xtalk_protect = true;
2411         ret = nau8825_sema_acquire(nau8825, 0);
2412         if (ret)
2413                 nau8825->xtalk_protect = false;
2414         enable_irq(nau8825->irq);
2415
2416         return 0;
2417 }
2418
2419 static const struct snd_soc_component_driver nau8825_component_driver = {
2420         .probe                  = nau8825_component_probe,
2421         .remove                 = nau8825_component_remove,
2422         .set_sysclk             = nau8825_set_sysclk,
2423         .set_pll                = nau8825_set_pll,
2424         .set_bias_level         = nau8825_set_bias_level,
2425         .suspend                = nau8825_suspend,
2426         .resume                 = nau8825_resume,
2427         .controls               = nau8825_controls,
2428         .num_controls           = ARRAY_SIZE(nau8825_controls),
2429         .dapm_widgets           = nau8825_dapm_widgets,
2430         .num_dapm_widgets       = ARRAY_SIZE(nau8825_dapm_widgets),
2431         .dapm_routes            = nau8825_dapm_routes,
2432         .num_dapm_routes        = ARRAY_SIZE(nau8825_dapm_routes),
2433         .suspend_bias_off       = 1,
2434         .idle_bias_on           = 1,
2435         .use_pmdown_time        = 1,
2436         .endianness             = 1,
2437         .non_legacy_dai_naming  = 1,
2438 };
2439
2440 static void nau8825_reset_chip(struct regmap *regmap)
2441 {
2442         regmap_write(regmap, NAU8825_REG_RESET, 0x00);
2443         regmap_write(regmap, NAU8825_REG_RESET, 0x00);
2444 }
2445
2446 static void nau8825_print_device_properties(struct nau8825 *nau8825)
2447 {
2448         int i;
2449         struct device *dev = nau8825->dev;
2450
2451         dev_dbg(dev, "jkdet-enable:         %d\n", nau8825->jkdet_enable);
2452         dev_dbg(dev, "jkdet-pull-enable:    %d\n", nau8825->jkdet_pull_enable);
2453         dev_dbg(dev, "jkdet-pull-up:        %d\n", nau8825->jkdet_pull_up);
2454         dev_dbg(dev, "jkdet-polarity:       %d\n", nau8825->jkdet_polarity);
2455         dev_dbg(dev, "micbias-voltage:      %d\n", nau8825->micbias_voltage);
2456         dev_dbg(dev, "vref-impedance:       %d\n", nau8825->vref_impedance);
2457
2458         dev_dbg(dev, "sar-threshold-num:    %d\n", nau8825->sar_threshold_num);
2459         for (i = 0; i < nau8825->sar_threshold_num; i++)
2460                 dev_dbg(dev, "sar-threshold[%d]=%d\n", i,
2461                                 nau8825->sar_threshold[i]);
2462
2463         dev_dbg(dev, "sar-hysteresis:       %d\n", nau8825->sar_hysteresis);
2464         dev_dbg(dev, "sar-voltage:          %d\n", nau8825->sar_voltage);
2465         dev_dbg(dev, "sar-compare-time:     %d\n", nau8825->sar_compare_time);
2466         dev_dbg(dev, "sar-sampling-time:    %d\n", nau8825->sar_sampling_time);
2467         dev_dbg(dev, "short-key-debounce:   %d\n", nau8825->key_debounce);
2468         dev_dbg(dev, "jack-insert-debounce: %d\n",
2469                         nau8825->jack_insert_debounce);
2470         dev_dbg(dev, "jack-eject-debounce:  %d\n",
2471                         nau8825->jack_eject_debounce);
2472         dev_dbg(dev, "crosstalk-enable:     %d\n",
2473                         nau8825->xtalk_enable);
2474 }
2475
2476 static int nau8825_read_device_properties(struct device *dev,
2477         struct nau8825 *nau8825) {
2478         int ret;
2479
2480         nau8825->jkdet_enable = device_property_read_bool(dev,
2481                 "nuvoton,jkdet-enable");
2482         nau8825->jkdet_pull_enable = device_property_read_bool(dev,
2483                 "nuvoton,jkdet-pull-enable");
2484         nau8825->jkdet_pull_up = device_property_read_bool(dev,
2485                 "nuvoton,jkdet-pull-up");
2486         ret = device_property_read_u32(dev, "nuvoton,jkdet-polarity",
2487                 &nau8825->jkdet_polarity);
2488         if (ret)
2489                 nau8825->jkdet_polarity = 1;
2490         ret = device_property_read_u32(dev, "nuvoton,micbias-voltage",
2491                 &nau8825->micbias_voltage);
2492         if (ret)
2493                 nau8825->micbias_voltage = 6;
2494         ret = device_property_read_u32(dev, "nuvoton,vref-impedance",
2495                 &nau8825->vref_impedance);
2496         if (ret)
2497                 nau8825->vref_impedance = 2;
2498         ret = device_property_read_u32(dev, "nuvoton,sar-threshold-num",
2499                 &nau8825->sar_threshold_num);
2500         if (ret)
2501                 nau8825->sar_threshold_num = 4;
2502         ret = device_property_read_u32_array(dev, "nuvoton,sar-threshold",
2503                 nau8825->sar_threshold, nau8825->sar_threshold_num);
2504         if (ret) {
2505                 nau8825->sar_threshold[0] = 0x08;
2506                 nau8825->sar_threshold[1] = 0x12;
2507                 nau8825->sar_threshold[2] = 0x26;
2508                 nau8825->sar_threshold[3] = 0x73;
2509         }
2510         ret = device_property_read_u32(dev, "nuvoton,sar-hysteresis",
2511                 &nau8825->sar_hysteresis);
2512         if (ret)
2513                 nau8825->sar_hysteresis = 0;
2514         ret = device_property_read_u32(dev, "nuvoton,sar-voltage",
2515                 &nau8825->sar_voltage);
2516         if (ret)
2517                 nau8825->sar_voltage = 6;
2518         ret = device_property_read_u32(dev, "nuvoton,sar-compare-time",
2519                 &nau8825->sar_compare_time);
2520         if (ret)
2521                 nau8825->sar_compare_time = 1;
2522         ret = device_property_read_u32(dev, "nuvoton,sar-sampling-time",
2523                 &nau8825->sar_sampling_time);
2524         if (ret)
2525                 nau8825->sar_sampling_time = 1;
2526         ret = device_property_read_u32(dev, "nuvoton,short-key-debounce",
2527                 &nau8825->key_debounce);
2528         if (ret)
2529                 nau8825->key_debounce = 3;
2530         ret = device_property_read_u32(dev, "nuvoton,jack-insert-debounce",
2531                 &nau8825->jack_insert_debounce);
2532         if (ret)
2533                 nau8825->jack_insert_debounce = 7;
2534         ret = device_property_read_u32(dev, "nuvoton,jack-eject-debounce",
2535                 &nau8825->jack_eject_debounce);
2536         if (ret)
2537                 nau8825->jack_eject_debounce = 0;
2538         nau8825->xtalk_enable = device_property_read_bool(dev,
2539                 "nuvoton,crosstalk-enable");
2540
2541         nau8825->mclk = devm_clk_get(dev, "mclk");
2542         if (PTR_ERR(nau8825->mclk) == -EPROBE_DEFER) {
2543                 return -EPROBE_DEFER;
2544         } else if (PTR_ERR(nau8825->mclk) == -ENOENT) {
2545                 /* The MCLK is managed externally or not used at all */
2546                 nau8825->mclk = NULL;
2547                 dev_info(dev, "No 'mclk' clock found, assume MCLK is managed externally");
2548         } else if (IS_ERR(nau8825->mclk)) {
2549                 return -EINVAL;
2550         }
2551
2552         return 0;
2553 }
2554
2555 static int nau8825_setup_irq(struct nau8825 *nau8825)
2556 {
2557         int ret;
2558
2559         ret = devm_request_threaded_irq(nau8825->dev, nau8825->irq, NULL,
2560                 nau8825_interrupt, IRQF_TRIGGER_LOW | IRQF_ONESHOT,
2561                 "nau8825", nau8825);
2562
2563         if (ret) {
2564                 dev_err(nau8825->dev, "Cannot request irq %d (%d)\n",
2565                         nau8825->irq, ret);
2566                 return ret;
2567         }
2568
2569         return 0;
2570 }
2571
2572 static int nau8825_i2c_probe(struct i2c_client *i2c,
2573         const struct i2c_device_id *id)
2574 {
2575         struct device *dev = &i2c->dev;
2576         struct nau8825 *nau8825 = dev_get_platdata(&i2c->dev);
2577         int ret, value;
2578
2579         if (!nau8825) {
2580                 nau8825 = devm_kzalloc(dev, sizeof(*nau8825), GFP_KERNEL);
2581                 if (!nau8825)
2582                         return -ENOMEM;
2583                 ret = nau8825_read_device_properties(dev, nau8825);
2584                 if (ret)
2585                         return ret;
2586         }
2587
2588         i2c_set_clientdata(i2c, nau8825);
2589
2590         nau8825->regmap = devm_regmap_init_i2c(i2c, &nau8825_regmap_config);
2591         if (IS_ERR(nau8825->regmap))
2592                 return PTR_ERR(nau8825->regmap);
2593         nau8825->dev = dev;
2594         nau8825->irq = i2c->irq;
2595         /* Initiate parameters, semaphore and work queue which are needed in
2596          * cross talk suppression measurment function.
2597          */
2598         nau8825->xtalk_state = NAU8825_XTALK_DONE;
2599         nau8825->xtalk_protect = false;
2600         nau8825->xtalk_baktab_initialized = false;
2601         sema_init(&nau8825->xtalk_sem, 1);
2602         INIT_WORK(&nau8825->xtalk_work, nau8825_xtalk_work);
2603
2604         nau8825_print_device_properties(nau8825);
2605
2606         nau8825_reset_chip(nau8825->regmap);
2607         ret = regmap_read(nau8825->regmap, NAU8825_REG_I2C_DEVICE_ID, &value);
2608         if (ret < 0) {
2609                 dev_err(dev, "Failed to read device id from the NAU8825: %d\n",
2610                         ret);
2611                 return ret;
2612         }
2613         if ((value & NAU8825_SOFTWARE_ID_MASK) !=
2614                         NAU8825_SOFTWARE_ID_NAU8825) {
2615                 dev_err(dev, "Not a NAU8825 chip\n");
2616                 return -ENODEV;
2617         }
2618
2619         nau8825_init_regs(nau8825);
2620
2621         if (i2c->irq)
2622                 nau8825_setup_irq(nau8825);
2623
2624         return devm_snd_soc_register_component(&i2c->dev,
2625                 &nau8825_component_driver,
2626                 &nau8825_dai, 1);
2627 }
2628
2629 static int nau8825_i2c_remove(struct i2c_client *client)
2630 {
2631         return 0;
2632 }
2633
2634 static const struct i2c_device_id nau8825_i2c_ids[] = {
2635         { "nau8825", 0 },
2636         { }
2637 };
2638 MODULE_DEVICE_TABLE(i2c, nau8825_i2c_ids);
2639
2640 #ifdef CONFIG_OF
2641 static const struct of_device_id nau8825_of_ids[] = {
2642         { .compatible = "nuvoton,nau8825", },
2643         {}
2644 };
2645 MODULE_DEVICE_TABLE(of, nau8825_of_ids);
2646 #endif
2647
2648 #ifdef CONFIG_ACPI
2649 static const struct acpi_device_id nau8825_acpi_match[] = {
2650         { "10508825", 0 },
2651         {},
2652 };
2653 MODULE_DEVICE_TABLE(acpi, nau8825_acpi_match);
2654 #endif
2655
2656 static struct i2c_driver nau8825_driver = {
2657         .driver = {
2658                 .name = "nau8825",
2659                 .of_match_table = of_match_ptr(nau8825_of_ids),
2660                 .acpi_match_table = ACPI_PTR(nau8825_acpi_match),
2661         },
2662         .probe = nau8825_i2c_probe,
2663         .remove = nau8825_i2c_remove,
2664         .id_table = nau8825_i2c_ids,
2665 };
2666 module_i2c_driver(nau8825_driver);
2667
2668 MODULE_DESCRIPTION("ASoC nau8825 driver");
2669 MODULE_AUTHOR("Anatol Pomozov <anatol@chromium.org>");
2670 MODULE_LICENSE("GPL");