1
2
3
4
5
6
7
8#include <linux/delay.h>
9#include <linux/gpio/consumer.h>
10#include <linux/i2c.h>
11#include <linux/module.h>
12#include <linux/of_device.h>
13#include <linux/of_gpio.h>
14#include <linux/pm_runtime.h>
15#include <linux/slab.h>
16#include <sound/initval.h>
17#include <sound/pcm_params.h>
18#include <sound/soc.h>
19#include <sound/soc-dapm.h>
20#include <sound/tlv.h>
21
22#include "ak4458.h"
23
24struct ak4458_drvdata {
25 struct snd_soc_dai_driver *dai_drv;
26 const struct snd_soc_component_driver *comp_drv;
27};
28
29
30struct ak4458_priv {
31 struct device *dev;
32 struct regmap *regmap;
33 struct gpio_desc *reset_gpiod;
34 struct gpio_desc *mute_gpiod;
35 int digfil;
36 int fs;
37 int fmt;
38 int slots;
39 int slot_width;
40};
41
42static const struct reg_default ak4458_reg_defaults[] = {
43 { 0x00, 0x0C },
44 { 0x01, 0x22 },
45 { 0x02, 0x00 },
46 { 0x03, 0xFF },
47 { 0x04, 0xFF },
48 { 0x05, 0x00 },
49 { 0x06, 0x00 },
50 { 0x07, 0x03 },
51 { 0x08, 0x00 },
52 { 0x09, 0x00 },
53 { 0x0A, 0x0D },
54 { 0x0B, 0x0C },
55 { 0x0C, 0x00 },
56 { 0x0D, 0x00 },
57 { 0x0E, 0x50 },
58 { 0x0F, 0xFF },
59 { 0x10, 0xFF },
60 { 0x11, 0xFF },
61 { 0x12, 0xFF },
62 { 0x13, 0xFF },
63 { 0x14, 0xFF },
64};
65
66
67
68
69
70static DECLARE_TLV_DB_SCALE(dac_tlv, -12750, 50, 1);
71
72
73
74
75
76
77
78
79static const char * const ak4458_dem_select_texts[] = {
80 "44.1kHz", "OFF", "48kHz", "32kHz"
81};
82
83
84
85
86
87
88
89
90
91static const char * const ak4458_digfil_select_texts[] = {
92 "Sharp Roll-Off Filter",
93 "Slow Roll-Off Filter",
94 "Short delay Sharp Roll-Off Filter",
95 "Short delay Slow Roll-Off Filter",
96 "Super Slow Roll-Off Filter"
97};
98
99
100
101
102
103
104static const char * const ak4458_dzfb_select_texts[] = {"H", "L"};
105
106
107
108
109
110
111
112
113static const char * const ak4458_sc_select_texts[] = {
114 "Sound Mode 0", "Sound Mode 1", "Sound Mode 2"
115};
116
117
118static const char * const ak4458_fir_select_texts[] = {
119 "Mode 0", "Mode 1", "Mode 2", "Mode 3",
120 "Mode 4", "Mode 5", "Mode 6", "Mode 7",
121};
122
123
124static const char * const ak4458_ats_select_texts[] = {
125 "4080/fs", "2040/fs", "510/fs", "255/fs",
126};
127
128
129static const char * const ak4458_dif_select_texts[] = {"32fs,48fs", "64fs",};
130
131static const struct soc_enum ak4458_dac1_dem_enum =
132 SOC_ENUM_SINGLE(AK4458_01_CONTROL2, 1,
133 ARRAY_SIZE(ak4458_dem_select_texts),
134 ak4458_dem_select_texts);
135static const struct soc_enum ak4458_dac2_dem_enum =
136 SOC_ENUM_SINGLE(AK4458_0A_CONTROL6, 0,
137 ARRAY_SIZE(ak4458_dem_select_texts),
138 ak4458_dem_select_texts);
139static const struct soc_enum ak4458_dac3_dem_enum =
140 SOC_ENUM_SINGLE(AK4458_0E_CONTROL10, 4,
141 ARRAY_SIZE(ak4458_dem_select_texts),
142 ak4458_dem_select_texts);
143static const struct soc_enum ak4458_dac4_dem_enum =
144 SOC_ENUM_SINGLE(AK4458_0E_CONTROL10, 6,
145 ARRAY_SIZE(ak4458_dem_select_texts),
146 ak4458_dem_select_texts);
147static const struct soc_enum ak4458_digfil_enum =
148 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(ak4458_digfil_select_texts),
149 ak4458_digfil_select_texts);
150static const struct soc_enum ak4458_dzfb_enum =
151 SOC_ENUM_SINGLE(AK4458_02_CONTROL3, 2,
152 ARRAY_SIZE(ak4458_dzfb_select_texts),
153 ak4458_dzfb_select_texts);
154static const struct soc_enum ak4458_sm_enum =
155 SOC_ENUM_SINGLE(AK4458_08_SOUND_CONTROL, 0,
156 ARRAY_SIZE(ak4458_sc_select_texts),
157 ak4458_sc_select_texts);
158static const struct soc_enum ak4458_fir_enum =
159 SOC_ENUM_SINGLE(AK4458_0C_CONTROL8, 0,
160 ARRAY_SIZE(ak4458_fir_select_texts),
161 ak4458_fir_select_texts);
162static const struct soc_enum ak4458_ats_enum =
163 SOC_ENUM_SINGLE(AK4458_0B_CONTROL7, 6,
164 ARRAY_SIZE(ak4458_ats_select_texts),
165 ak4458_ats_select_texts);
166static const struct soc_enum ak4458_dif_enum =
167 SOC_ENUM_SINGLE(AK4458_00_CONTROL1, 3,
168 ARRAY_SIZE(ak4458_dif_select_texts),
169 ak4458_dif_select_texts);
170
171static int get_digfil(struct snd_kcontrol *kcontrol,
172 struct snd_ctl_elem_value *ucontrol)
173{
174 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
175 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
176
177 ucontrol->value.enumerated.item[0] = ak4458->digfil;
178
179 return 0;
180}
181
182static int set_digfil(struct snd_kcontrol *kcontrol,
183 struct snd_ctl_elem_value *ucontrol)
184{
185 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
186 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
187 int num;
188
189 num = ucontrol->value.enumerated.item[0];
190 if (num > 4)
191 return -EINVAL;
192
193 ak4458->digfil = num;
194
195
196 snd_soc_component_update_bits(component, AK4458_01_CONTROL2,
197 AK4458_SD_MASK,
198 ((ak4458->digfil & 0x02) << 4));
199
200
201 snd_soc_component_update_bits(component, AK4458_02_CONTROL3,
202 AK4458_SLOW_MASK,
203 (ak4458->digfil & 0x01));
204
205
206 snd_soc_component_update_bits(component, AK4458_05_CONTROL4,
207 AK4458_SSLOW_MASK,
208 ((ak4458->digfil & 0x04) >> 2));
209
210 return 0;
211}
212
213static const struct snd_kcontrol_new ak4458_snd_controls[] = {
214 SOC_DOUBLE_R_TLV("DAC1 Playback Volume", AK4458_03_LCHATT,
215 AK4458_04_RCHATT, 0, 0xFF, 0, dac_tlv),
216 SOC_DOUBLE_R_TLV("DAC2 Playback Volume", AK4458_0F_L2CHATT,
217 AK4458_10_R2CHATT, 0, 0xFF, 0, dac_tlv),
218 SOC_DOUBLE_R_TLV("DAC3 Playback Volume", AK4458_11_L3CHATT,
219 AK4458_12_R3CHATT, 0, 0xFF, 0, dac_tlv),
220 SOC_DOUBLE_R_TLV("DAC4 Playback Volume", AK4458_13_L4CHATT,
221 AK4458_14_R4CHATT, 0, 0xFF, 0, dac_tlv),
222 SOC_ENUM("AK4458 De-emphasis Response DAC1", ak4458_dac1_dem_enum),
223 SOC_ENUM("AK4458 De-emphasis Response DAC2", ak4458_dac2_dem_enum),
224 SOC_ENUM("AK4458 De-emphasis Response DAC3", ak4458_dac3_dem_enum),
225 SOC_ENUM("AK4458 De-emphasis Response DAC4", ak4458_dac4_dem_enum),
226 SOC_ENUM_EXT("AK4458 Digital Filter Setting", ak4458_digfil_enum,
227 get_digfil, set_digfil),
228 SOC_ENUM("AK4458 Inverting Enable of DZFB", ak4458_dzfb_enum),
229 SOC_ENUM("AK4458 Sound Mode", ak4458_sm_enum),
230 SOC_ENUM("AK4458 FIR Filter Mode Setting", ak4458_fir_enum),
231 SOC_ENUM("AK4458 Attenuation transition Time Setting",
232 ak4458_ats_enum),
233 SOC_ENUM("AK4458 BICK fs Setting", ak4458_dif_enum),
234};
235
236
237static const struct snd_soc_dapm_widget ak4458_dapm_widgets[] = {
238 SND_SOC_DAPM_DAC("AK4458 DAC1", NULL, AK4458_0A_CONTROL6, 2, 0),
239 SND_SOC_DAPM_AIF_IN("AK4458 SDTI", "Playback", 0, SND_SOC_NOPM, 0, 0),
240 SND_SOC_DAPM_OUTPUT("AK4458 AOUTA"),
241
242 SND_SOC_DAPM_DAC("AK4458 DAC2", NULL, AK4458_0A_CONTROL6, 3, 0),
243 SND_SOC_DAPM_OUTPUT("AK4458 AOUTB"),
244
245 SND_SOC_DAPM_DAC("AK4458 DAC3", NULL, AK4458_0B_CONTROL7, 2, 0),
246 SND_SOC_DAPM_OUTPUT("AK4458 AOUTC"),
247
248 SND_SOC_DAPM_DAC("AK4458 DAC4", NULL, AK4458_0B_CONTROL7, 3, 0),
249 SND_SOC_DAPM_OUTPUT("AK4458 AOUTD"),
250};
251
252static const struct snd_soc_dapm_route ak4458_intercon[] = {
253 {"AK4458 DAC1", NULL, "AK4458 SDTI"},
254 {"AK4458 AOUTA", NULL, "AK4458 DAC1"},
255
256 {"AK4458 DAC2", NULL, "AK4458 SDTI"},
257 {"AK4458 AOUTB", NULL, "AK4458 DAC2"},
258
259 {"AK4458 DAC3", NULL, "AK4458 SDTI"},
260 {"AK4458 AOUTC", NULL, "AK4458 DAC3"},
261
262 {"AK4458 DAC4", NULL, "AK4458 SDTI"},
263 {"AK4458 AOUTD", NULL, "AK4458 DAC4"},
264};
265
266
267static const struct snd_kcontrol_new ak4497_snd_controls[] = {
268 SOC_DOUBLE_R_TLV("DAC Playback Volume", AK4458_03_LCHATT,
269 AK4458_04_RCHATT, 0, 0xFF, 0, dac_tlv),
270 SOC_ENUM("AK4497 De-emphasis Response DAC", ak4458_dac1_dem_enum),
271 SOC_ENUM_EXT("AK4497 Digital Filter Setting", ak4458_digfil_enum,
272 get_digfil, set_digfil),
273 SOC_ENUM("AK4497 Inverting Enable of DZFB", ak4458_dzfb_enum),
274 SOC_ENUM("AK4497 Sound Mode", ak4458_sm_enum),
275 SOC_ENUM("AK4497 Attenuation transition Time Setting",
276 ak4458_ats_enum),
277};
278
279
280static const struct snd_soc_dapm_widget ak4497_dapm_widgets[] = {
281 SND_SOC_DAPM_DAC("AK4497 DAC", NULL, AK4458_0A_CONTROL6, 2, 0),
282 SND_SOC_DAPM_AIF_IN("AK4497 SDTI", "Playback", 0, SND_SOC_NOPM, 0, 0),
283 SND_SOC_DAPM_OUTPUT("AK4497 AOUT"),
284};
285
286
287static const struct snd_soc_dapm_route ak4497_intercon[] = {
288 {"AK4497 DAC", NULL, "AK4497 SDTI"},
289 {"AK4497 AOUT", NULL, "AK4497 DAC"},
290
291};
292
293static int ak4458_rstn_control(struct snd_soc_component *component, int bit)
294{
295 int ret;
296
297 if (bit)
298 ret = snd_soc_component_update_bits(component,
299 AK4458_00_CONTROL1,
300 AK4458_RSTN_MASK,
301 0x1);
302 else
303 ret = snd_soc_component_update_bits(component,
304 AK4458_00_CONTROL1,
305 AK4458_RSTN_MASK,
306 0x0);
307 if (ret < 0)
308 return ret;
309
310 return 0;
311}
312
313static int ak4458_hw_params(struct snd_pcm_substream *substream,
314 struct snd_pcm_hw_params *params,
315 struct snd_soc_dai *dai)
316{
317 struct snd_soc_component *component = dai->component;
318 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
319 int pcm_width = max(params_physical_width(params), ak4458->slot_width);
320 int nfs1;
321 u8 format;
322
323 nfs1 = params_rate(params);
324 ak4458->fs = nfs1;
325
326
327 snd_soc_component_update_bits(component, AK4458_00_CONTROL1, 0x80, 0x80);
328
329 switch (pcm_width) {
330 case 16:
331 if (ak4458->fmt == SND_SOC_DAIFMT_I2S)
332 format = AK4458_DIF_24BIT_I2S;
333 else
334 format = AK4458_DIF_16BIT_LSB;
335 break;
336 case 32:
337 switch (ak4458->fmt) {
338 case SND_SOC_DAIFMT_I2S:
339 format = AK4458_DIF_32BIT_I2S;
340 break;
341 case SND_SOC_DAIFMT_LEFT_J:
342 format = AK4458_DIF_32BIT_MSB;
343 break;
344 case SND_SOC_DAIFMT_RIGHT_J:
345 format = AK4458_DIF_32BIT_LSB;
346 break;
347 case SND_SOC_DAIFMT_DSP_B:
348 format = AK4458_DIF_32BIT_MSB;
349 break;
350 default:
351 return -EINVAL;
352 }
353 break;
354 default:
355 return -EINVAL;
356 }
357
358 snd_soc_component_update_bits(component, AK4458_00_CONTROL1,
359 AK4458_DIF_MASK, format);
360
361 ak4458_rstn_control(component, 0);
362 ak4458_rstn_control(component, 1);
363
364 return 0;
365}
366
367static int ak4458_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
368{
369 struct snd_soc_component *component = dai->component;
370 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
371
372 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
373 case SND_SOC_DAIFMT_CBS_CFS:
374 break;
375 case SND_SOC_DAIFMT_CBM_CFM:
376 case SND_SOC_DAIFMT_CBS_CFM:
377 case SND_SOC_DAIFMT_CBM_CFS:
378 default:
379 dev_err(component->dev, "Master mode unsupported\n");
380 return -EINVAL;
381 }
382
383 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
384 case SND_SOC_DAIFMT_I2S:
385 case SND_SOC_DAIFMT_LEFT_J:
386 case SND_SOC_DAIFMT_RIGHT_J:
387 case SND_SOC_DAIFMT_DSP_B:
388 ak4458->fmt = fmt & SND_SOC_DAIFMT_FORMAT_MASK;
389 break;
390 default:
391 dev_err(component->dev, "Audio format 0x%02X unsupported\n",
392 fmt & SND_SOC_DAIFMT_FORMAT_MASK);
393 return -EINVAL;
394 }
395
396 ak4458_rstn_control(component, 0);
397 ak4458_rstn_control(component, 1);
398
399 return 0;
400}
401
402static const int att_speed[] = { 4080, 2040, 510, 255 };
403
404static int ak4458_set_dai_mute(struct snd_soc_dai *dai, int mute)
405{
406 struct snd_soc_component *component = dai->component;
407 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
408 int nfs, ndt, ret, reg;
409 int ats;
410
411 nfs = ak4458->fs;
412
413 reg = snd_soc_component_read32(component, AK4458_0B_CONTROL7);
414 ats = (reg & AK4458_ATS_MASK) >> AK4458_ATS_SHIFT;
415
416 ndt = att_speed[ats] / (nfs / 1000);
417
418 if (mute) {
419 ret = snd_soc_component_update_bits(component, AK4458_01_CONTROL2, 0x01, 1);
420 mdelay(ndt);
421 if (ak4458->mute_gpiod)
422 gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
423 } else {
424 if (ak4458->mute_gpiod)
425 gpiod_set_value_cansleep(ak4458->mute_gpiod, 0);
426 ret = snd_soc_component_update_bits(component, AK4458_01_CONTROL2, 0x01, 0);
427 mdelay(ndt);
428 }
429
430 return 0;
431}
432
433static int ak4458_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
434 unsigned int rx_mask, int slots, int slot_width)
435{
436 struct snd_soc_component *component = dai->component;
437 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
438 int mode;
439
440 ak4458->slots = slots;
441 ak4458->slot_width = slot_width;
442
443 switch (slots * slot_width) {
444 case 128:
445 mode = AK4458_MODE_TDM128;
446 break;
447 case 256:
448 mode = AK4458_MODE_TDM256;
449 break;
450 case 512:
451 mode = AK4458_MODE_TDM512;
452 break;
453 default:
454 mode = AK4458_MODE_NORMAL;
455 break;
456 }
457
458 snd_soc_component_update_bits(component, AK4458_0A_CONTROL6,
459 AK4458_MODE_MASK,
460 mode);
461
462 return 0;
463}
464
465#define AK4458_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
466 SNDRV_PCM_FMTBIT_S24_LE |\
467 SNDRV_PCM_FMTBIT_S32_LE)
468
469static const unsigned int ak4458_rates[] = {
470 8000, 11025, 16000, 22050,
471 32000, 44100, 48000, 88200,
472 96000, 176400, 192000, 352800,
473 384000, 705600, 768000, 1411200,
474 2822400,
475};
476
477static const struct snd_pcm_hw_constraint_list ak4458_rate_constraints = {
478 .count = ARRAY_SIZE(ak4458_rates),
479 .list = ak4458_rates,
480};
481
482static int ak4458_startup(struct snd_pcm_substream *substream,
483 struct snd_soc_dai *dai)
484{
485 int ret;
486
487 ret = snd_pcm_hw_constraint_list(substream->runtime, 0,
488 SNDRV_PCM_HW_PARAM_RATE,
489 &ak4458_rate_constraints);
490
491 return ret;
492}
493
494static const struct snd_soc_dai_ops ak4458_dai_ops = {
495 .startup = ak4458_startup,
496 .hw_params = ak4458_hw_params,
497 .set_fmt = ak4458_set_dai_fmt,
498 .digital_mute = ak4458_set_dai_mute,
499 .set_tdm_slot = ak4458_set_tdm_slot,
500};
501
502static struct snd_soc_dai_driver ak4458_dai = {
503 .name = "ak4458-aif",
504 .playback = {
505 .stream_name = "Playback",
506 .channels_min = 1,
507 .channels_max = 8,
508 .rates = SNDRV_PCM_RATE_KNOT,
509 .formats = AK4458_FORMATS,
510 },
511 .ops = &ak4458_dai_ops,
512};
513
514static struct snd_soc_dai_driver ak4497_dai = {
515 .name = "ak4497-aif",
516 .playback = {
517 .stream_name = "Playback",
518 .channels_min = 1,
519 .channels_max = 2,
520 .rates = SNDRV_PCM_RATE_KNOT,
521 .formats = AK4458_FORMATS,
522 },
523 .ops = &ak4458_dai_ops,
524};
525
526static void ak4458_power_off(struct ak4458_priv *ak4458)
527{
528 if (ak4458->reset_gpiod) {
529 gpiod_set_value_cansleep(ak4458->reset_gpiod, 0);
530 usleep_range(1000, 2000);
531 }
532}
533
534static void ak4458_power_on(struct ak4458_priv *ak4458)
535{
536 if (ak4458->reset_gpiod) {
537 gpiod_set_value_cansleep(ak4458->reset_gpiod, 1);
538 usleep_range(1000, 2000);
539 }
540}
541
542static int ak4458_init(struct snd_soc_component *component)
543{
544 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
545 int ret;
546
547
548 if (ak4458->mute_gpiod)
549 gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
550
551 ak4458_power_on(ak4458);
552
553 ret = snd_soc_component_update_bits(component, AK4458_00_CONTROL1,
554 0x80, 0x80);
555 if (ret < 0)
556 return ret;
557
558 return ak4458_rstn_control(component, 1);
559}
560
561static int ak4458_probe(struct snd_soc_component *component)
562{
563 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
564
565 ak4458->fs = 48000;
566
567 return ak4458_init(component);
568}
569
570static void ak4458_remove(struct snd_soc_component *component)
571{
572 struct ak4458_priv *ak4458 = snd_soc_component_get_drvdata(component);
573
574 ak4458_power_off(ak4458);
575}
576
577#ifdef CONFIG_PM
578static int __maybe_unused ak4458_runtime_suspend(struct device *dev)
579{
580 struct ak4458_priv *ak4458 = dev_get_drvdata(dev);
581
582 regcache_cache_only(ak4458->regmap, true);
583
584 ak4458_power_off(ak4458);
585
586 if (ak4458->mute_gpiod)
587 gpiod_set_value_cansleep(ak4458->mute_gpiod, 0);
588
589 return 0;
590}
591
592static int __maybe_unused ak4458_runtime_resume(struct device *dev)
593{
594 struct ak4458_priv *ak4458 = dev_get_drvdata(dev);
595
596 if (ak4458->mute_gpiod)
597 gpiod_set_value_cansleep(ak4458->mute_gpiod, 1);
598
599 ak4458_power_off(ak4458);
600 ak4458_power_on(ak4458);
601
602 regcache_cache_only(ak4458->regmap, false);
603 regcache_mark_dirty(ak4458->regmap);
604
605 return regcache_sync(ak4458->regmap);
606}
607#endif
608
609static const struct snd_soc_component_driver soc_codec_dev_ak4458 = {
610 .probe = ak4458_probe,
611 .remove = ak4458_remove,
612 .controls = ak4458_snd_controls,
613 .num_controls = ARRAY_SIZE(ak4458_snd_controls),
614 .dapm_widgets = ak4458_dapm_widgets,
615 .num_dapm_widgets = ARRAY_SIZE(ak4458_dapm_widgets),
616 .dapm_routes = ak4458_intercon,
617 .num_dapm_routes = ARRAY_SIZE(ak4458_intercon),
618 .idle_bias_on = 1,
619 .use_pmdown_time = 1,
620 .endianness = 1,
621 .non_legacy_dai_naming = 1,
622};
623
624static const struct snd_soc_component_driver soc_codec_dev_ak4497 = {
625 .probe = ak4458_probe,
626 .remove = ak4458_remove,
627 .controls = ak4497_snd_controls,
628 .num_controls = ARRAY_SIZE(ak4497_snd_controls),
629 .dapm_widgets = ak4497_dapm_widgets,
630 .num_dapm_widgets = ARRAY_SIZE(ak4497_dapm_widgets),
631 .dapm_routes = ak4497_intercon,
632 .num_dapm_routes = ARRAY_SIZE(ak4497_intercon),
633 .idle_bias_on = 1,
634 .use_pmdown_time = 1,
635 .endianness = 1,
636 .non_legacy_dai_naming = 1,
637};
638
639static const struct regmap_config ak4458_regmap = {
640 .reg_bits = 8,
641 .val_bits = 8,
642
643 .max_register = AK4458_14_R4CHATT,
644 .reg_defaults = ak4458_reg_defaults,
645 .num_reg_defaults = ARRAY_SIZE(ak4458_reg_defaults),
646 .cache_type = REGCACHE_RBTREE,
647};
648
649static const struct ak4458_drvdata ak4458_drvdata = {
650 .dai_drv = &ak4458_dai,
651 .comp_drv = &soc_codec_dev_ak4458,
652};
653
654static const struct ak4458_drvdata ak4497_drvdata = {
655 .dai_drv = &ak4497_dai,
656 .comp_drv = &soc_codec_dev_ak4497,
657};
658
659static const struct dev_pm_ops ak4458_pm = {
660 SET_RUNTIME_PM_OPS(ak4458_runtime_suspend, ak4458_runtime_resume, NULL)
661 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
662 pm_runtime_force_resume)
663};
664
665static int ak4458_i2c_probe(struct i2c_client *i2c)
666{
667 struct ak4458_priv *ak4458;
668 const struct ak4458_drvdata *drvdata;
669 int ret;
670
671 ak4458 = devm_kzalloc(&i2c->dev, sizeof(*ak4458), GFP_KERNEL);
672 if (!ak4458)
673 return -ENOMEM;
674
675 ak4458->regmap = devm_regmap_init_i2c(i2c, &ak4458_regmap);
676 if (IS_ERR(ak4458->regmap))
677 return PTR_ERR(ak4458->regmap);
678
679 i2c_set_clientdata(i2c, ak4458);
680 ak4458->dev = &i2c->dev;
681
682 drvdata = of_device_get_match_data(&i2c->dev);
683
684 ak4458->reset_gpiod = devm_gpiod_get_optional(ak4458->dev, "reset",
685 GPIOD_OUT_LOW);
686 if (IS_ERR(ak4458->reset_gpiod))
687 return PTR_ERR(ak4458->reset_gpiod);
688
689 ak4458->mute_gpiod = devm_gpiod_get_optional(ak4458->dev, "mute",
690 GPIOD_OUT_LOW);
691 if (IS_ERR(ak4458->mute_gpiod))
692 return PTR_ERR(ak4458->mute_gpiod);
693
694 ret = devm_snd_soc_register_component(ak4458->dev, drvdata->comp_drv,
695 drvdata->dai_drv, 1);
696 if (ret < 0) {
697 dev_err(ak4458->dev, "Failed to register CODEC: %d\n", ret);
698 return ret;
699 }
700
701 pm_runtime_enable(&i2c->dev);
702
703 return 0;
704}
705
706static int ak4458_i2c_remove(struct i2c_client *i2c)
707{
708 pm_runtime_disable(&i2c->dev);
709
710 return 0;
711}
712
713static const struct of_device_id ak4458_of_match[] = {
714 { .compatible = "asahi-kasei,ak4458", .data = &ak4458_drvdata},
715 { .compatible = "asahi-kasei,ak4497", .data = &ak4497_drvdata},
716 { },
717};
718
719static struct i2c_driver ak4458_i2c_driver = {
720 .driver = {
721 .name = "ak4458",
722 .pm = &ak4458_pm,
723 .of_match_table = ak4458_of_match,
724 },
725 .probe_new = ak4458_i2c_probe,
726 .remove = ak4458_i2c_remove,
727};
728
729module_i2c_driver(ak4458_i2c_driver);
730
731MODULE_AUTHOR("Junichi Wakasugi <wakasugi.jb@om.asahi-kasei.co.jp>");
732MODULE_AUTHOR("Mihai Serban <mihai.serban@nxp.com>");
733MODULE_DESCRIPTION("ASoC AK4458 DAC driver");
734MODULE_LICENSE("GPL v2");
735
