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