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