sound/soc/codecs/nau8825.c

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