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