1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Texas Instruments PCM186x Universal Audio ADC 4 * 5 * Copyright (C) 2015-2017 Texas Instruments Incorporated - https://www.ti.com 6 * Andreas Dannenberg <dannenberg@ti.com> 7 * Andrew F. Davis <afd@ti.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/moduleparam.h> 12 #include <linux/init.h> 13 #include <linux/delay.h> 14 #include <linux/pm.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/regmap.h> 17 #include <linux/slab.h> 18 #include <sound/core.h> 19 #include <sound/pcm.h> 20 #include <sound/pcm_params.h> 21 #include <sound/soc.h> 22 #include <sound/jack.h> 23 #include <sound/initval.h> 24 #include <sound/tlv.h> 25 26 #include "pcm186x.h" 27 28 static const char * const pcm186x_supply_names[] = { 29 "avdd", /* Analog power supply. Connect to 3.3-V supply. */ 30 "dvdd", /* Digital power supply. Connect to 3.3-V supply. */ 31 "iovdd", /* I/O power supply. Connect to 3.3-V or 1.8-V. */ 32 }; 33 #define PCM186x_NUM_SUPPLIES ARRAY_SIZE(pcm186x_supply_names) 34 35 struct pcm186x_priv { 36 struct regmap *regmap; 37 struct regulator_bulk_data supplies[PCM186x_NUM_SUPPLIES]; 38 unsigned int sysclk; 39 unsigned int tdm_offset; 40 bool is_tdm_mode; 41 bool is_provider_mode; 42 }; 43 44 static const DECLARE_TLV_DB_SCALE(pcm186x_pga_tlv, -1200, 50, 0); 45 46 static const struct snd_kcontrol_new pcm1863_snd_controls[] = { 47 SOC_DOUBLE_R_S_TLV("ADC Capture Volume", PCM186X_PGA_VAL_CH1_L, 48 PCM186X_PGA_VAL_CH1_R, 0, -24, 80, 7, 0, 49 pcm186x_pga_tlv), 50 }; 51 52 static const struct snd_kcontrol_new pcm1865_snd_controls[] = { 53 SOC_DOUBLE_R_S_TLV("ADC1 Capture Volume", PCM186X_PGA_VAL_CH1_L, 54 PCM186X_PGA_VAL_CH1_R, 0, -24, 80, 7, 0, 55 pcm186x_pga_tlv), 56 SOC_DOUBLE_R_S_TLV("ADC2 Capture Volume", PCM186X_PGA_VAL_CH2_L, 57 PCM186X_PGA_VAL_CH2_R, 0, -24, 80, 7, 0, 58 pcm186x_pga_tlv), 59 }; 60 61 static const unsigned int pcm186x_adc_input_channel_sel_value[] = { 62 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 63 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 64 0x10, 0x20, 0x30 65 }; 66 67 static const char * const pcm186x_adcl_input_channel_sel_text[] = { 68 "No Select", 69 "VINL1[SE]", /* Default for ADC1L */ 70 "VINL2[SE]", /* Default for ADC2L */ 71 "VINL2[SE] + VINL1[SE]", 72 "VINL3[SE]", 73 "VINL3[SE] + VINL1[SE]", 74 "VINL3[SE] + VINL2[SE]", 75 "VINL3[SE] + VINL2[SE] + VINL1[SE]", 76 "VINL4[SE]", 77 "VINL4[SE] + VINL1[SE]", 78 "VINL4[SE] + VINL2[SE]", 79 "VINL4[SE] + VINL2[SE] + VINL1[SE]", 80 "VINL4[SE] + VINL3[SE]", 81 "VINL4[SE] + VINL3[SE] + VINL1[SE]", 82 "VINL4[SE] + VINL3[SE] + VINL2[SE]", 83 "VINL4[SE] + VINL3[SE] + VINL2[SE] + VINL1[SE]", 84 "{VIN1P, VIN1M}[DIFF]", 85 "{VIN4P, VIN4M}[DIFF]", 86 "{VIN1P, VIN1M}[DIFF] + {VIN4P, VIN4M}[DIFF]" 87 }; 88 89 static const char * const pcm186x_adcr_input_channel_sel_text[] = { 90 "No Select", 91 "VINR1[SE]", /* Default for ADC1R */ 92 "VINR2[SE]", /* Default for ADC2R */ 93 "VINR2[SE] + VINR1[SE]", 94 "VINR3[SE]", 95 "VINR3[SE] + VINR1[SE]", 96 "VINR3[SE] + VINR2[SE]", 97 "VINR3[SE] + VINR2[SE] + VINR1[SE]", 98 "VINR4[SE]", 99 "VINR4[SE] + VINR1[SE]", 100 "VINR4[SE] + VINR2[SE]", 101 "VINR4[SE] + VINR2[SE] + VINR1[SE]", 102 "VINR4[SE] + VINR3[SE]", 103 "VINR4[SE] + VINR3[SE] + VINR1[SE]", 104 "VINR4[SE] + VINR3[SE] + VINR2[SE]", 105 "VINR4[SE] + VINR3[SE] + VINR2[SE] + VINR1[SE]", 106 "{VIN2P, VIN2M}[DIFF]", 107 "{VIN3P, VIN3M}[DIFF]", 108 "{VIN2P, VIN2M}[DIFF] + {VIN3P, VIN3M}[DIFF]" 109 }; 110 111 static const struct soc_enum pcm186x_adc_input_channel_sel[] = { 112 SOC_VALUE_ENUM_SINGLE(PCM186X_ADC1_INPUT_SEL_L, 0, 113 PCM186X_ADC_INPUT_SEL_MASK, 114 ARRAY_SIZE(pcm186x_adcl_input_channel_sel_text), 115 pcm186x_adcl_input_channel_sel_text, 116 pcm186x_adc_input_channel_sel_value), 117 SOC_VALUE_ENUM_SINGLE(PCM186X_ADC1_INPUT_SEL_R, 0, 118 PCM186X_ADC_INPUT_SEL_MASK, 119 ARRAY_SIZE(pcm186x_adcr_input_channel_sel_text), 120 pcm186x_adcr_input_channel_sel_text, 121 pcm186x_adc_input_channel_sel_value), 122 SOC_VALUE_ENUM_SINGLE(PCM186X_ADC2_INPUT_SEL_L, 0, 123 PCM186X_ADC_INPUT_SEL_MASK, 124 ARRAY_SIZE(pcm186x_adcl_input_channel_sel_text), 125 pcm186x_adcl_input_channel_sel_text, 126 pcm186x_adc_input_channel_sel_value), 127 SOC_VALUE_ENUM_SINGLE(PCM186X_ADC2_INPUT_SEL_R, 0, 128 PCM186X_ADC_INPUT_SEL_MASK, 129 ARRAY_SIZE(pcm186x_adcr_input_channel_sel_text), 130 pcm186x_adcr_input_channel_sel_text, 131 pcm186x_adc_input_channel_sel_value), 132 }; 133 134 static const struct snd_kcontrol_new pcm186x_adc_mux_controls[] = { 135 SOC_DAPM_ENUM("ADC1 Left Input", pcm186x_adc_input_channel_sel[0]), 136 SOC_DAPM_ENUM("ADC1 Right Input", pcm186x_adc_input_channel_sel[1]), 137 SOC_DAPM_ENUM("ADC2 Left Input", pcm186x_adc_input_channel_sel[2]), 138 SOC_DAPM_ENUM("ADC2 Right Input", pcm186x_adc_input_channel_sel[3]), 139 }; 140 141 static const struct snd_soc_dapm_widget pcm1863_dapm_widgets[] = { 142 SND_SOC_DAPM_INPUT("VINL1"), 143 SND_SOC_DAPM_INPUT("VINR1"), 144 SND_SOC_DAPM_INPUT("VINL2"), 145 SND_SOC_DAPM_INPUT("VINR2"), 146 SND_SOC_DAPM_INPUT("VINL3"), 147 SND_SOC_DAPM_INPUT("VINR3"), 148 SND_SOC_DAPM_INPUT("VINL4"), 149 SND_SOC_DAPM_INPUT("VINR4"), 150 151 SND_SOC_DAPM_MUX("ADC Left Capture Source", SND_SOC_NOPM, 0, 0, 152 &pcm186x_adc_mux_controls[0]), 153 SND_SOC_DAPM_MUX("ADC Right Capture Source", SND_SOC_NOPM, 0, 0, 154 &pcm186x_adc_mux_controls[1]), 155 156 /* 157 * Put the codec into SLEEP mode when not in use, allowing the 158 * Energysense mechanism to operate. 159 */ 160 SND_SOC_DAPM_ADC("ADC", "HiFi Capture", PCM186X_POWER_CTRL, 1, 1), 161 }; 162 163 static const struct snd_soc_dapm_widget pcm1865_dapm_widgets[] = { 164 SND_SOC_DAPM_INPUT("VINL1"), 165 SND_SOC_DAPM_INPUT("VINR1"), 166 SND_SOC_DAPM_INPUT("VINL2"), 167 SND_SOC_DAPM_INPUT("VINR2"), 168 SND_SOC_DAPM_INPUT("VINL3"), 169 SND_SOC_DAPM_INPUT("VINR3"), 170 SND_SOC_DAPM_INPUT("VINL4"), 171 SND_SOC_DAPM_INPUT("VINR4"), 172 173 SND_SOC_DAPM_MUX("ADC1 Left Capture Source", SND_SOC_NOPM, 0, 0, 174 &pcm186x_adc_mux_controls[0]), 175 SND_SOC_DAPM_MUX("ADC1 Right Capture Source", SND_SOC_NOPM, 0, 0, 176 &pcm186x_adc_mux_controls[1]), 177 SND_SOC_DAPM_MUX("ADC2 Left Capture Source", SND_SOC_NOPM, 0, 0, 178 &pcm186x_adc_mux_controls[2]), 179 SND_SOC_DAPM_MUX("ADC2 Right Capture Source", SND_SOC_NOPM, 0, 0, 180 &pcm186x_adc_mux_controls[3]), 181 182 /* 183 * Put the codec into SLEEP mode when not in use, allowing the 184 * Energysense mechanism to operate. 185 */ 186 SND_SOC_DAPM_ADC("ADC1", "HiFi Capture 1", PCM186X_POWER_CTRL, 1, 1), 187 SND_SOC_DAPM_ADC("ADC2", "HiFi Capture 2", PCM186X_POWER_CTRL, 1, 1), 188 }; 189 190 static const struct snd_soc_dapm_route pcm1863_dapm_routes[] = { 191 { "ADC Left Capture Source", NULL, "VINL1" }, 192 { "ADC Left Capture Source", NULL, "VINR1" }, 193 { "ADC Left Capture Source", NULL, "VINL2" }, 194 { "ADC Left Capture Source", NULL, "VINR2" }, 195 { "ADC Left Capture Source", NULL, "VINL3" }, 196 { "ADC Left Capture Source", NULL, "VINR3" }, 197 { "ADC Left Capture Source", NULL, "VINL4" }, 198 { "ADC Left Capture Source", NULL, "VINR4" }, 199 200 { "ADC", NULL, "ADC Left Capture Source" }, 201 202 { "ADC Right Capture Source", NULL, "VINL1" }, 203 { "ADC Right Capture Source", NULL, "VINR1" }, 204 { "ADC Right Capture Source", NULL, "VINL2" }, 205 { "ADC Right Capture Source", NULL, "VINR2" }, 206 { "ADC Right Capture Source", NULL, "VINL3" }, 207 { "ADC Right Capture Source", NULL, "VINR3" }, 208 { "ADC Right Capture Source", NULL, "VINL4" }, 209 { "ADC Right Capture Source", NULL, "VINR4" }, 210 211 { "ADC", NULL, "ADC Right Capture Source" }, 212 }; 213 214 static const struct snd_soc_dapm_route pcm1865_dapm_routes[] = { 215 { "ADC1 Left Capture Source", NULL, "VINL1" }, 216 { "ADC1 Left Capture Source", NULL, "VINR1" }, 217 { "ADC1 Left Capture Source", NULL, "VINL2" }, 218 { "ADC1 Left Capture Source", NULL, "VINR2" }, 219 { "ADC1 Left Capture Source", NULL, "VINL3" }, 220 { "ADC1 Left Capture Source", NULL, "VINR3" }, 221 { "ADC1 Left Capture Source", NULL, "VINL4" }, 222 { "ADC1 Left Capture Source", NULL, "VINR4" }, 223 224 { "ADC1", NULL, "ADC1 Left Capture Source" }, 225 226 { "ADC1 Right Capture Source", NULL, "VINL1" }, 227 { "ADC1 Right Capture Source", NULL, "VINR1" }, 228 { "ADC1 Right Capture Source", NULL, "VINL2" }, 229 { "ADC1 Right Capture Source", NULL, "VINR2" }, 230 { "ADC1 Right Capture Source", NULL, "VINL3" }, 231 { "ADC1 Right Capture Source", NULL, "VINR3" }, 232 { "ADC1 Right Capture Source", NULL, "VINL4" }, 233 { "ADC1 Right Capture Source", NULL, "VINR4" }, 234 235 { "ADC1", NULL, "ADC1 Right Capture Source" }, 236 237 { "ADC2 Left Capture Source", NULL, "VINL1" }, 238 { "ADC2 Left Capture Source", NULL, "VINR1" }, 239 { "ADC2 Left Capture Source", NULL, "VINL2" }, 240 { "ADC2 Left Capture Source", NULL, "VINR2" }, 241 { "ADC2 Left Capture Source", NULL, "VINL3" }, 242 { "ADC2 Left Capture Source", NULL, "VINR3" }, 243 { "ADC2 Left Capture Source", NULL, "VINL4" }, 244 { "ADC2 Left Capture Source", NULL, "VINR4" }, 245 246 { "ADC2", NULL, "ADC2 Left Capture Source" }, 247 248 { "ADC2 Right Capture Source", NULL, "VINL1" }, 249 { "ADC2 Right Capture Source", NULL, "VINR1" }, 250 { "ADC2 Right Capture Source", NULL, "VINL2" }, 251 { "ADC2 Right Capture Source", NULL, "VINR2" }, 252 { "ADC2 Right Capture Source", NULL, "VINL3" }, 253 { "ADC2 Right Capture Source", NULL, "VINR3" }, 254 { "ADC2 Right Capture Source", NULL, "VINL4" }, 255 { "ADC2 Right Capture Source", NULL, "VINR4" }, 256 257 { "ADC2", NULL, "ADC2 Right Capture Source" }, 258 }; 259 260 static int pcm186x_hw_params(struct snd_pcm_substream *substream, 261 struct snd_pcm_hw_params *params, 262 struct snd_soc_dai *dai) 263 { 264 struct snd_soc_component *component = dai->component; 265 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 266 unsigned int rate = params_rate(params); 267 snd_pcm_format_t format = params_format(params); 268 unsigned int width = params_width(params); 269 unsigned int channels = params_channels(params); 270 unsigned int div_lrck; 271 unsigned int div_bck; 272 u8 tdm_tx_sel = 0; 273 u8 pcm_cfg = 0; 274 275 dev_dbg(component->dev, "%s() rate=%u format=0x%x width=%u channels=%u\n", 276 __func__, rate, format, width, channels); 277 278 switch (width) { 279 case 16: 280 pcm_cfg = PCM186X_PCM_CFG_RX_WLEN_16 << 281 PCM186X_PCM_CFG_RX_WLEN_SHIFT | 282 PCM186X_PCM_CFG_TX_WLEN_16 << 283 PCM186X_PCM_CFG_TX_WLEN_SHIFT; 284 break; 285 case 20: 286 pcm_cfg = PCM186X_PCM_CFG_RX_WLEN_20 << 287 PCM186X_PCM_CFG_RX_WLEN_SHIFT | 288 PCM186X_PCM_CFG_TX_WLEN_20 << 289 PCM186X_PCM_CFG_TX_WLEN_SHIFT; 290 break; 291 case 24: 292 pcm_cfg = PCM186X_PCM_CFG_RX_WLEN_24 << 293 PCM186X_PCM_CFG_RX_WLEN_SHIFT | 294 PCM186X_PCM_CFG_TX_WLEN_24 << 295 PCM186X_PCM_CFG_TX_WLEN_SHIFT; 296 break; 297 case 32: 298 pcm_cfg = PCM186X_PCM_CFG_RX_WLEN_32 << 299 PCM186X_PCM_CFG_RX_WLEN_SHIFT | 300 PCM186X_PCM_CFG_TX_WLEN_32 << 301 PCM186X_PCM_CFG_TX_WLEN_SHIFT; 302 break; 303 default: 304 return -EINVAL; 305 } 306 307 snd_soc_component_update_bits(component, PCM186X_PCM_CFG, 308 PCM186X_PCM_CFG_RX_WLEN_MASK | 309 PCM186X_PCM_CFG_TX_WLEN_MASK, 310 pcm_cfg); 311 312 div_lrck = width * channels; 313 314 if (priv->is_tdm_mode) { 315 /* Select TDM transmission data */ 316 switch (channels) { 317 case 2: 318 tdm_tx_sel = PCM186X_TDM_TX_SEL_2CH; 319 break; 320 case 4: 321 tdm_tx_sel = PCM186X_TDM_TX_SEL_4CH; 322 break; 323 case 6: 324 tdm_tx_sel = PCM186X_TDM_TX_SEL_6CH; 325 break; 326 default: 327 return -EINVAL; 328 } 329 330 snd_soc_component_update_bits(component, PCM186X_TDM_TX_SEL, 331 PCM186X_TDM_TX_SEL_MASK, tdm_tx_sel); 332 333 /* In DSP/TDM mode, the LRCLK divider must be 256 */ 334 div_lrck = 256; 335 336 /* Configure 1/256 duty cycle for LRCK */ 337 snd_soc_component_update_bits(component, PCM186X_PCM_CFG, 338 PCM186X_PCM_CFG_TDM_LRCK_MODE, 339 PCM186X_PCM_CFG_TDM_LRCK_MODE); 340 } 341 342 /* Only configure clock dividers in provider mode. */ 343 if (priv->is_provider_mode) { 344 div_bck = priv->sysclk / (div_lrck * rate); 345 346 dev_dbg(component->dev, 347 "%s() master_clk=%u div_bck=%u div_lrck=%u\n", 348 __func__, priv->sysclk, div_bck, div_lrck); 349 350 snd_soc_component_write(component, PCM186X_BCK_DIV, div_bck - 1); 351 snd_soc_component_write(component, PCM186X_LRK_DIV, div_lrck - 1); 352 } 353 354 return 0; 355 } 356 357 static int pcm186x_set_fmt(struct snd_soc_dai *dai, unsigned int format) 358 { 359 struct snd_soc_component *component = dai->component; 360 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 361 u8 clk_ctrl = 0; 362 u8 pcm_cfg = 0; 363 364 dev_dbg(component->dev, "%s() format=0x%x\n", __func__, format); 365 366 switch (format & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 367 case SND_SOC_DAIFMT_CBP_CFP: 368 if (!priv->sysclk) { 369 dev_err(component->dev, "operating in provider mode requires sysclock to be configured\n"); 370 return -EINVAL; 371 } 372 clk_ctrl |= PCM186X_CLK_CTRL_MST_MODE; 373 priv->is_provider_mode = true; 374 break; 375 case SND_SOC_DAIFMT_CBC_CFC: 376 priv->is_provider_mode = false; 377 break; 378 default: 379 dev_err(component->dev, "Invalid DAI master/slave interface\n"); 380 return -EINVAL; 381 } 382 383 /* set interface polarity */ 384 switch (format & SND_SOC_DAIFMT_INV_MASK) { 385 case SND_SOC_DAIFMT_NB_NF: 386 break; 387 default: 388 dev_err(component->dev, "Inverted DAI clocks not supported\n"); 389 return -EINVAL; 390 } 391 392 /* set interface format */ 393 switch (format & SND_SOC_DAIFMT_FORMAT_MASK) { 394 case SND_SOC_DAIFMT_I2S: 395 pcm_cfg = PCM186X_PCM_CFG_FMT_I2S; 396 break; 397 case SND_SOC_DAIFMT_LEFT_J: 398 pcm_cfg = PCM186X_PCM_CFG_FMT_LEFTJ; 399 break; 400 case SND_SOC_DAIFMT_DSP_A: 401 priv->tdm_offset += 1; 402 fallthrough; 403 /* DSP_A uses the same basic config as DSP_B 404 * except we need to shift the TDM output by one BCK cycle 405 */ 406 case SND_SOC_DAIFMT_DSP_B: 407 priv->is_tdm_mode = true; 408 pcm_cfg = PCM186X_PCM_CFG_FMT_TDM; 409 break; 410 default: 411 dev_err(component->dev, "Invalid DAI format\n"); 412 return -EINVAL; 413 } 414 415 snd_soc_component_update_bits(component, PCM186X_CLK_CTRL, 416 PCM186X_CLK_CTRL_MST_MODE, clk_ctrl); 417 418 snd_soc_component_write(component, PCM186X_TDM_TX_OFFSET, priv->tdm_offset); 419 420 snd_soc_component_update_bits(component, PCM186X_PCM_CFG, 421 PCM186X_PCM_CFG_FMT_MASK, pcm_cfg); 422 423 return 0; 424 } 425 426 static int pcm186x_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, 427 unsigned int rx_mask, int slots, int slot_width) 428 { 429 struct snd_soc_component *component = dai->component; 430 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 431 unsigned int first_slot, last_slot, tdm_offset; 432 433 dev_dbg(component->dev, 434 "%s() tx_mask=0x%x rx_mask=0x%x slots=%d slot_width=%d\n", 435 __func__, tx_mask, rx_mask, slots, slot_width); 436 437 if (!tx_mask) { 438 dev_err(component->dev, "tdm tx mask must not be 0\n"); 439 return -EINVAL; 440 } 441 442 first_slot = __ffs(tx_mask); 443 last_slot = __fls(tx_mask); 444 445 if (last_slot - first_slot != hweight32(tx_mask) - 1) { 446 dev_err(component->dev, "tdm tx mask must be contiguous\n"); 447 return -EINVAL; 448 } 449 450 tdm_offset = first_slot * slot_width; 451 452 if (tdm_offset > 255) { 453 dev_err(component->dev, "tdm tx slot selection out of bounds\n"); 454 return -EINVAL; 455 } 456 457 priv->tdm_offset = tdm_offset; 458 459 return 0; 460 } 461 462 static int pcm186x_set_dai_sysclk(struct snd_soc_dai *dai, int clk_id, 463 unsigned int freq, int dir) 464 { 465 struct snd_soc_component *component = dai->component; 466 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 467 468 dev_dbg(component->dev, "%s() clk_id=%d freq=%u dir=%d\n", 469 __func__, clk_id, freq, dir); 470 471 priv->sysclk = freq; 472 473 return 0; 474 } 475 476 static const struct snd_soc_dai_ops pcm186x_dai_ops = { 477 .set_sysclk = pcm186x_set_dai_sysclk, 478 .set_tdm_slot = pcm186x_set_tdm_slot, 479 .set_fmt = pcm186x_set_fmt, 480 .hw_params = pcm186x_hw_params, 481 }; 482 483 static struct snd_soc_dai_driver pcm1863_dai = { 484 .name = "pcm1863-aif", 485 .capture = { 486 .stream_name = "Capture", 487 .channels_min = 1, 488 .channels_max = 2, 489 .rates = PCM186X_RATES, 490 .formats = PCM186X_FORMATS, 491 }, 492 .ops = &pcm186x_dai_ops, 493 }; 494 495 static struct snd_soc_dai_driver pcm1865_dai = { 496 .name = "pcm1865-aif", 497 .capture = { 498 .stream_name = "Capture", 499 .channels_min = 1, 500 .channels_max = 4, 501 .rates = PCM186X_RATES, 502 .formats = PCM186X_FORMATS, 503 }, 504 .ops = &pcm186x_dai_ops, 505 }; 506 507 static int pcm186x_power_on(struct snd_soc_component *component) 508 { 509 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 510 int ret = 0; 511 512 ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), 513 priv->supplies); 514 if (ret) 515 return ret; 516 517 regcache_cache_only(priv->regmap, false); 518 ret = regcache_sync(priv->regmap); 519 if (ret) { 520 dev_err(component->dev, "Failed to restore cache\n"); 521 regcache_cache_only(priv->regmap, true); 522 regulator_bulk_disable(ARRAY_SIZE(priv->supplies), 523 priv->supplies); 524 return ret; 525 } 526 527 snd_soc_component_update_bits(component, PCM186X_POWER_CTRL, 528 PCM186X_PWR_CTRL_PWRDN, 0); 529 530 return 0; 531 } 532 533 static int pcm186x_power_off(struct snd_soc_component *component) 534 { 535 struct pcm186x_priv *priv = snd_soc_component_get_drvdata(component); 536 537 snd_soc_component_update_bits(component, PCM186X_POWER_CTRL, 538 PCM186X_PWR_CTRL_PWRDN, PCM186X_PWR_CTRL_PWRDN); 539 540 regcache_cache_only(priv->regmap, true); 541 542 return regulator_bulk_disable(ARRAY_SIZE(priv->supplies), 543 priv->supplies); 544 } 545 546 static int pcm186x_set_bias_level(struct snd_soc_component *component, 547 enum snd_soc_bias_level level) 548 { 549 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component); 550 551 dev_dbg(component->dev, "## %s: %d -> %d\n", __func__, 552 snd_soc_dapm_get_bias_level(dapm), level); 553 554 switch (level) { 555 case SND_SOC_BIAS_ON: 556 break; 557 case SND_SOC_BIAS_PREPARE: 558 break; 559 case SND_SOC_BIAS_STANDBY: 560 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_OFF) 561 pcm186x_power_on(component); 562 break; 563 case SND_SOC_BIAS_OFF: 564 pcm186x_power_off(component); 565 break; 566 } 567 568 return 0; 569 } 570 571 static const struct snd_soc_component_driver soc_codec_dev_pcm1863 = { 572 .set_bias_level = pcm186x_set_bias_level, 573 .controls = pcm1863_snd_controls, 574 .num_controls = ARRAY_SIZE(pcm1863_snd_controls), 575 .dapm_widgets = pcm1863_dapm_widgets, 576 .num_dapm_widgets = ARRAY_SIZE(pcm1863_dapm_widgets), 577 .dapm_routes = pcm1863_dapm_routes, 578 .num_dapm_routes = ARRAY_SIZE(pcm1863_dapm_routes), 579 .idle_bias_on = 1, 580 .use_pmdown_time = 1, 581 .endianness = 1, 582 }; 583 584 static const struct snd_soc_component_driver soc_codec_dev_pcm1865 = { 585 .set_bias_level = pcm186x_set_bias_level, 586 .controls = pcm1865_snd_controls, 587 .num_controls = ARRAY_SIZE(pcm1865_snd_controls), 588 .dapm_widgets = pcm1865_dapm_widgets, 589 .num_dapm_widgets = ARRAY_SIZE(pcm1865_dapm_widgets), 590 .dapm_routes = pcm1865_dapm_routes, 591 .num_dapm_routes = ARRAY_SIZE(pcm1865_dapm_routes), 592 .suspend_bias_off = 1, 593 .idle_bias_on = 1, 594 .use_pmdown_time = 1, 595 .endianness = 1, 596 }; 597 598 static bool pcm186x_volatile(struct device *dev, unsigned int reg) 599 { 600 switch (reg) { 601 case PCM186X_PAGE: 602 case PCM186X_DEVICE_STATUS: 603 case PCM186X_FSAMPLE_STATUS: 604 case PCM186X_DIV_STATUS: 605 case PCM186X_CLK_STATUS: 606 case PCM186X_SUPPLY_STATUS: 607 case PCM186X_MMAP_STAT_CTRL: 608 case PCM186X_MMAP_ADDRESS: 609 return true; 610 } 611 612 return false; 613 } 614 615 static const struct regmap_range_cfg pcm186x_range = { 616 .name = "Pages", 617 .range_max = PCM186X_MAX_REGISTER, 618 .selector_reg = PCM186X_PAGE, 619 .selector_mask = 0xff, 620 .window_len = PCM186X_PAGE_LEN, 621 }; 622 623 const struct regmap_config pcm186x_regmap = { 624 .reg_bits = 8, 625 .val_bits = 8, 626 627 .volatile_reg = pcm186x_volatile, 628 629 .ranges = &pcm186x_range, 630 .num_ranges = 1, 631 632 .max_register = PCM186X_MAX_REGISTER, 633 634 .cache_type = REGCACHE_RBTREE, 635 }; 636 EXPORT_SYMBOL_GPL(pcm186x_regmap); 637 638 int pcm186x_probe(struct device *dev, enum pcm186x_type type, int irq, 639 struct regmap *regmap) 640 { 641 struct pcm186x_priv *priv; 642 int i, ret; 643 644 priv = devm_kzalloc(dev, sizeof(struct pcm186x_priv), GFP_KERNEL); 645 if (!priv) 646 return -ENOMEM; 647 648 dev_set_drvdata(dev, priv); 649 priv->regmap = regmap; 650 651 for (i = 0; i < ARRAY_SIZE(priv->supplies); i++) 652 priv->supplies[i].supply = pcm186x_supply_names[i]; 653 654 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(priv->supplies), 655 priv->supplies); 656 if (ret) { 657 dev_err(dev, "failed to request supplies: %d\n", ret); 658 return ret; 659 } 660 661 ret = regulator_bulk_enable(ARRAY_SIZE(priv->supplies), 662 priv->supplies); 663 if (ret) { 664 dev_err(dev, "failed enable supplies: %d\n", ret); 665 return ret; 666 } 667 668 /* Reset device registers for a consistent power-on like state */ 669 ret = regmap_write(regmap, PCM186X_PAGE, PCM186X_RESET); 670 if (ret) { 671 dev_err(dev, "failed to write device: %d\n", ret); 672 return ret; 673 } 674 675 ret = regulator_bulk_disable(ARRAY_SIZE(priv->supplies), 676 priv->supplies); 677 if (ret) { 678 dev_err(dev, "failed disable supplies: %d\n", ret); 679 return ret; 680 } 681 682 switch (type) { 683 case PCM1865: 684 case PCM1864: 685 ret = devm_snd_soc_register_component(dev, &soc_codec_dev_pcm1865, 686 &pcm1865_dai, 1); 687 break; 688 case PCM1863: 689 case PCM1862: 690 default: 691 ret = devm_snd_soc_register_component(dev, &soc_codec_dev_pcm1863, 692 &pcm1863_dai, 1); 693 } 694 if (ret) { 695 dev_err(dev, "failed to register CODEC: %d\n", ret); 696 return ret; 697 } 698 699 return 0; 700 } 701 EXPORT_SYMBOL_GPL(pcm186x_probe); 702 703 MODULE_AUTHOR("Andreas Dannenberg <dannenberg@ti.com>"); 704 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>"); 705 MODULE_DESCRIPTION("PCM186x Universal Audio ADC driver"); 706 MODULE_LICENSE("GPL v2"); 707