1
2
3
4
5
6
7
8
9#include <linux/init.h>
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/device.h>
13#include <linux/i2c.h>
14#include <linux/spi/spi.h>
15#include <linux/slab.h>
16#include <sound/core.h>
17#include <sound/pcm.h>
18#include <sound/pcm_params.h>
19#include <sound/initval.h>
20#include <sound/soc.h>
21#include <sound/tlv.h>
22#include "ad193x.h"
23
24
25struct ad193x_priv {
26 struct regmap *regmap;
27 int sysclk;
28};
29
30
31
32
33static const char * const ad193x_deemp[] = {"None", "48kHz", "44.1kHz", "32kHz"};
34
35static const struct soc_enum ad193x_deemp_enum =
36 SOC_ENUM_SINGLE(AD193X_DAC_CTRL2, 1, 4, ad193x_deemp);
37
38static const DECLARE_TLV_DB_MINMAX(adau193x_tlv, -9563, 0);
39
40static const struct snd_kcontrol_new ad193x_snd_controls[] = {
41
42 SOC_DOUBLE_R_TLV("DAC1 Volume", AD193X_DAC_L1_VOL,
43 AD193X_DAC_R1_VOL, 0, 0xFF, 1, adau193x_tlv),
44 SOC_DOUBLE_R_TLV("DAC2 Volume", AD193X_DAC_L2_VOL,
45 AD193X_DAC_R2_VOL, 0, 0xFF, 1, adau193x_tlv),
46 SOC_DOUBLE_R_TLV("DAC3 Volume", AD193X_DAC_L3_VOL,
47 AD193X_DAC_R3_VOL, 0, 0xFF, 1, adau193x_tlv),
48 SOC_DOUBLE_R_TLV("DAC4 Volume", AD193X_DAC_L4_VOL,
49 AD193X_DAC_R4_VOL, 0, 0xFF, 1, adau193x_tlv),
50
51
52 SOC_DOUBLE("ADC1 Switch", AD193X_ADC_CTRL0, AD193X_ADCL1_MUTE,
53 AD193X_ADCR1_MUTE, 1, 1),
54 SOC_DOUBLE("ADC2 Switch", AD193X_ADC_CTRL0, AD193X_ADCL2_MUTE,
55 AD193X_ADCR2_MUTE, 1, 1),
56
57
58 SOC_DOUBLE("DAC1 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL1_MUTE,
59 AD193X_DACR1_MUTE, 1, 1),
60 SOC_DOUBLE("DAC2 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL2_MUTE,
61 AD193X_DACR2_MUTE, 1, 1),
62 SOC_DOUBLE("DAC3 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL3_MUTE,
63 AD193X_DACR3_MUTE, 1, 1),
64 SOC_DOUBLE("DAC4 Switch", AD193X_DAC_CHNL_MUTE, AD193X_DACL4_MUTE,
65 AD193X_DACR4_MUTE, 1, 1),
66
67
68 SOC_SINGLE("ADC High Pass Filter Switch", AD193X_ADC_CTRL0,
69 AD193X_ADC_HIGHPASS_FILTER, 1, 0),
70
71
72 SOC_ENUM("Playback Deemphasis", ad193x_deemp_enum),
73};
74
75static const struct snd_soc_dapm_widget ad193x_dapm_widgets[] = {
76 SND_SOC_DAPM_DAC("DAC", "Playback", AD193X_DAC_CTRL0, 0, 1),
77 SND_SOC_DAPM_ADC("ADC", "Capture", SND_SOC_NOPM, 0, 0),
78 SND_SOC_DAPM_SUPPLY("PLL_PWR", AD193X_PLL_CLK_CTRL0, 0, 1, NULL, 0),
79 SND_SOC_DAPM_SUPPLY("ADC_PWR", AD193X_ADC_CTRL0, 0, 1, NULL, 0),
80 SND_SOC_DAPM_SUPPLY("SYSCLK", AD193X_PLL_CLK_CTRL0, 7, 0, NULL, 0),
81 SND_SOC_DAPM_OUTPUT("DAC1OUT"),
82 SND_SOC_DAPM_OUTPUT("DAC2OUT"),
83 SND_SOC_DAPM_OUTPUT("DAC3OUT"),
84 SND_SOC_DAPM_OUTPUT("DAC4OUT"),
85 SND_SOC_DAPM_INPUT("ADC1IN"),
86 SND_SOC_DAPM_INPUT("ADC2IN"),
87};
88
89static const struct snd_soc_dapm_route audio_paths[] = {
90 { "DAC", NULL, "SYSCLK" },
91 { "ADC", NULL, "SYSCLK" },
92 { "DAC", NULL, "ADC_PWR" },
93 { "ADC", NULL, "ADC_PWR" },
94 { "DAC1OUT", NULL, "DAC" },
95 { "DAC2OUT", NULL, "DAC" },
96 { "DAC3OUT", NULL, "DAC" },
97 { "DAC4OUT", NULL, "DAC" },
98 { "ADC", NULL, "ADC1IN" },
99 { "ADC", NULL, "ADC2IN" },
100 { "SYSCLK", NULL, "PLL_PWR" },
101};
102
103
104
105
106
107static int ad193x_mute(struct snd_soc_dai *dai, int mute)
108{
109 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(dai->codec);
110
111 if (mute)
112 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2,
113 AD193X_DAC_MASTER_MUTE,
114 AD193X_DAC_MASTER_MUTE);
115 else
116 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2,
117 AD193X_DAC_MASTER_MUTE, 0);
118
119 return 0;
120}
121
122static int ad193x_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
123 unsigned int rx_mask, int slots, int width)
124{
125 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(dai->codec);
126 unsigned int channels;
127
128 switch (slots) {
129 case 2:
130 channels = AD193X_2_CHANNELS;
131 break;
132 case 4:
133 channels = AD193X_4_CHANNELS;
134 break;
135 case 8:
136 channels = AD193X_8_CHANNELS;
137 break;
138 case 16:
139 channels = AD193X_16_CHANNELS;
140 break;
141 default:
142 return -EINVAL;
143 }
144
145 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL1,
146 AD193X_DAC_CHAN_MASK, channels << AD193X_DAC_CHAN_SHFT);
147 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL2,
148 AD193X_ADC_CHAN_MASK, channels << AD193X_ADC_CHAN_SHFT);
149
150 return 0;
151}
152
153static int ad193x_set_dai_fmt(struct snd_soc_dai *codec_dai,
154 unsigned int fmt)
155{
156 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec_dai->codec);
157 unsigned int adc_serfmt = 0;
158 unsigned int adc_fmt = 0;
159 unsigned int dac_fmt = 0;
160
161
162
163
164 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
165 case SND_SOC_DAIFMT_I2S:
166 adc_serfmt |= AD193X_ADC_SERFMT_TDM;
167 break;
168 case SND_SOC_DAIFMT_DSP_A:
169 adc_serfmt |= AD193X_ADC_SERFMT_AUX;
170 break;
171 default:
172 return -EINVAL;
173 }
174
175 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
176 case SND_SOC_DAIFMT_NB_NF:
177 break;
178 case SND_SOC_DAIFMT_NB_IF:
179 adc_fmt |= AD193X_ADC_LEFT_HIGH;
180 dac_fmt |= AD193X_DAC_LEFT_HIGH;
181 break;
182 case SND_SOC_DAIFMT_IB_NF:
183 adc_fmt |= AD193X_ADC_BCLK_INV;
184 dac_fmt |= AD193X_DAC_BCLK_INV;
185 break;
186 case SND_SOC_DAIFMT_IB_IF:
187 adc_fmt |= AD193X_ADC_LEFT_HIGH;
188 adc_fmt |= AD193X_ADC_BCLK_INV;
189 dac_fmt |= AD193X_DAC_LEFT_HIGH;
190 dac_fmt |= AD193X_DAC_BCLK_INV;
191 break;
192 default:
193 return -EINVAL;
194 }
195
196 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
197 case SND_SOC_DAIFMT_CBM_CFM:
198 adc_fmt |= AD193X_ADC_LCR_MASTER;
199 adc_fmt |= AD193X_ADC_BCLK_MASTER;
200 dac_fmt |= AD193X_DAC_LCR_MASTER;
201 dac_fmt |= AD193X_DAC_BCLK_MASTER;
202 break;
203 case SND_SOC_DAIFMT_CBS_CFM:
204 adc_fmt |= AD193X_ADC_LCR_MASTER;
205 dac_fmt |= AD193X_DAC_LCR_MASTER;
206 break;
207 case SND_SOC_DAIFMT_CBM_CFS:
208 adc_fmt |= AD193X_ADC_BCLK_MASTER;
209 dac_fmt |= AD193X_DAC_BCLK_MASTER;
210 break;
211 case SND_SOC_DAIFMT_CBS_CFS:
212 break;
213 default:
214 return -EINVAL;
215 }
216
217 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL1,
218 AD193X_ADC_SERFMT_MASK, adc_serfmt);
219 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL2,
220 AD193X_ADC_FMT_MASK, adc_fmt);
221 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL1,
222 AD193X_DAC_FMT_MASK, dac_fmt);
223
224 return 0;
225}
226
227static int ad193x_set_dai_sysclk(struct snd_soc_dai *codec_dai,
228 int clk_id, unsigned int freq, int dir)
229{
230 struct snd_soc_codec *codec = codec_dai->codec;
231 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
232 switch (freq) {
233 case 12288000:
234 case 18432000:
235 case 24576000:
236 case 36864000:
237 ad193x->sysclk = freq;
238 return 0;
239 }
240 return -EINVAL;
241}
242
243static int ad193x_hw_params(struct snd_pcm_substream *substream,
244 struct snd_pcm_hw_params *params,
245 struct snd_soc_dai *dai)
246{
247 int word_len = 0, master_rate = 0;
248 struct snd_soc_codec *codec = dai->codec;
249 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
250
251
252 switch (params_format(params)) {
253 case SNDRV_PCM_FORMAT_S16_LE:
254 word_len = 3;
255 break;
256 case SNDRV_PCM_FORMAT_S20_3LE:
257 word_len = 1;
258 break;
259 case SNDRV_PCM_FORMAT_S24_LE:
260 case SNDRV_PCM_FORMAT_S32_LE:
261 word_len = 0;
262 break;
263 }
264
265 switch (ad193x->sysclk) {
266 case 12288000:
267 master_rate = AD193X_PLL_INPUT_256;
268 break;
269 case 18432000:
270 master_rate = AD193X_PLL_INPUT_384;
271 break;
272 case 24576000:
273 master_rate = AD193X_PLL_INPUT_512;
274 break;
275 case 36864000:
276 master_rate = AD193X_PLL_INPUT_768;
277 break;
278 }
279
280 regmap_update_bits(ad193x->regmap, AD193X_PLL_CLK_CTRL0,
281 AD193X_PLL_INPUT_MASK, master_rate);
282
283 regmap_update_bits(ad193x->regmap, AD193X_DAC_CTRL2,
284 AD193X_DAC_WORD_LEN_MASK,
285 word_len << AD193X_DAC_WORD_LEN_SHFT);
286
287 regmap_update_bits(ad193x->regmap, AD193X_ADC_CTRL1,
288 AD193X_ADC_WORD_LEN_MASK, word_len);
289
290 return 0;
291}
292
293static const struct snd_soc_dai_ops ad193x_dai_ops = {
294 .hw_params = ad193x_hw_params,
295 .digital_mute = ad193x_mute,
296 .set_tdm_slot = ad193x_set_tdm_slot,
297 .set_sysclk = ad193x_set_dai_sysclk,
298 .set_fmt = ad193x_set_dai_fmt,
299};
300
301
302static struct snd_soc_dai_driver ad193x_dai = {
303 .name = "ad193x-hifi",
304 .playback = {
305 .stream_name = "Playback",
306 .channels_min = 2,
307 .channels_max = 8,
308 .rates = SNDRV_PCM_RATE_48000,
309 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
310 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
311 },
312 .capture = {
313 .stream_name = "Capture",
314 .channels_min = 2,
315 .channels_max = 4,
316 .rates = SNDRV_PCM_RATE_48000,
317 .formats = SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S16_LE |
318 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE,
319 },
320 .ops = &ad193x_dai_ops,
321};
322
323static int ad193x_probe(struct snd_soc_codec *codec)
324{
325 struct ad193x_priv *ad193x = snd_soc_codec_get_drvdata(codec);
326 int ret;
327
328 codec->control_data = ad193x->regmap;
329 ret = snd_soc_codec_set_cache_io(codec, 0, 0, SND_SOC_REGMAP);
330 if (ret < 0) {
331 dev_err(codec->dev, "failed to set cache I/O: %d\n", ret);
332 return ret;
333 }
334
335
336
337
338 regmap_write(ad193x->regmap, AD193X_DAC_CHNL_MUTE, 0x0);
339
340 regmap_write(ad193x->regmap, AD193X_DAC_CTRL2, 0x1A);
341
342 regmap_write(ad193x->regmap, AD193X_DAC_CTRL0, 0x41);
343
344 regmap_write(ad193x->regmap, AD193X_ADC_CTRL0, 0x3);
345
346 regmap_write(ad193x->regmap, AD193X_ADC_CTRL1, 0x43);
347
348 regmap_write(ad193x->regmap, AD193X_PLL_CLK_CTRL0, 0x99);
349 regmap_write(ad193x->regmap, AD193X_PLL_CLK_CTRL1, 0x04);
350
351 return ret;
352}
353
354static struct snd_soc_codec_driver soc_codec_dev_ad193x = {
355 .probe = ad193x_probe,
356 .controls = ad193x_snd_controls,
357 .num_controls = ARRAY_SIZE(ad193x_snd_controls),
358 .dapm_widgets = ad193x_dapm_widgets,
359 .num_dapm_widgets = ARRAY_SIZE(ad193x_dapm_widgets),
360 .dapm_routes = audio_paths,
361 .num_dapm_routes = ARRAY_SIZE(audio_paths),
362};
363
364static bool adau193x_reg_volatile(struct device *dev, unsigned int reg)
365{
366 return false;
367}
368
369#if defined(CONFIG_SPI_MASTER)
370
371static const struct regmap_config ad193x_spi_regmap_config = {
372 .val_bits = 8,
373 .reg_bits = 16,
374 .read_flag_mask = 0x09,
375 .write_flag_mask = 0x08,
376
377 .max_register = AD193X_NUM_REGS - 1,
378 .volatile_reg = adau193x_reg_volatile,
379};
380
381static int ad193x_spi_probe(struct spi_device *spi)
382{
383 struct ad193x_priv *ad193x;
384
385 ad193x = devm_kzalloc(&spi->dev, sizeof(struct ad193x_priv),
386 GFP_KERNEL);
387 if (ad193x == NULL)
388 return -ENOMEM;
389
390 ad193x->regmap = devm_regmap_init_spi(spi, &ad193x_spi_regmap_config);
391 if (IS_ERR(ad193x->regmap))
392 return PTR_ERR(ad193x->regmap);
393
394 spi_set_drvdata(spi, ad193x);
395
396 return snd_soc_register_codec(&spi->dev, &soc_codec_dev_ad193x,
397 &ad193x_dai, 1);
398}
399
400static int ad193x_spi_remove(struct spi_device *spi)
401{
402 snd_soc_unregister_codec(&spi->dev);
403 return 0;
404}
405
406static struct spi_driver ad193x_spi_driver = {
407 .driver = {
408 .name = "ad193x",
409 .owner = THIS_MODULE,
410 },
411 .probe = ad193x_spi_probe,
412 .remove = ad193x_spi_remove,
413};
414#endif
415
416#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
417
418static const struct regmap_config ad193x_i2c_regmap_config = {
419 .val_bits = 8,
420 .reg_bits = 8,
421
422 .max_register = AD193X_NUM_REGS - 1,
423 .volatile_reg = adau193x_reg_volatile,
424};
425
426static const struct i2c_device_id ad193x_id[] = {
427 { "ad1936", 0 },
428 { "ad1937", 0 },
429 { }
430};
431MODULE_DEVICE_TABLE(i2c, ad193x_id);
432
433static int ad193x_i2c_probe(struct i2c_client *client,
434 const struct i2c_device_id *id)
435{
436 struct ad193x_priv *ad193x;
437
438 ad193x = devm_kzalloc(&client->dev, sizeof(struct ad193x_priv),
439 GFP_KERNEL);
440 if (ad193x == NULL)
441 return -ENOMEM;
442
443 ad193x->regmap = devm_regmap_init_i2c(client, &ad193x_i2c_regmap_config);
444 if (IS_ERR(ad193x->regmap))
445 return PTR_ERR(ad193x->regmap);
446
447 i2c_set_clientdata(client, ad193x);
448
449 return snd_soc_register_codec(&client->dev, &soc_codec_dev_ad193x,
450 &ad193x_dai, 1);
451}
452
453static int ad193x_i2c_remove(struct i2c_client *client)
454{
455 snd_soc_unregister_codec(&client->dev);
456 return 0;
457}
458
459static struct i2c_driver ad193x_i2c_driver = {
460 .driver = {
461 .name = "ad193x",
462 },
463 .probe = ad193x_i2c_probe,
464 .remove = ad193x_i2c_remove,
465 .id_table = ad193x_id,
466};
467#endif
468
469static int __init ad193x_modinit(void)
470{
471 int ret;
472
473#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
474 ret = i2c_add_driver(&ad193x_i2c_driver);
475 if (ret != 0) {
476 printk(KERN_ERR "Failed to register AD193X I2C driver: %d\n",
477 ret);
478 }
479#endif
480
481#if defined(CONFIG_SPI_MASTER)
482 ret = spi_register_driver(&ad193x_spi_driver);
483 if (ret != 0) {
484 printk(KERN_ERR "Failed to register AD193X SPI driver: %d\n",
485 ret);
486 }
487#endif
488 return ret;
489}
490module_init(ad193x_modinit);
491
492static void __exit ad193x_modexit(void)
493{
494#if defined(CONFIG_SPI_MASTER)
495 spi_unregister_driver(&ad193x_spi_driver);
496#endif
497
498#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
499 i2c_del_driver(&ad193x_i2c_driver);
500#endif
501}
502module_exit(ad193x_modexit);
503
504MODULE_DESCRIPTION("ASoC ad193x driver");
505MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
506MODULE_LICENSE("GPL");
507
