Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (C) STMicroelectronics SA 2015
4 * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
5 * for STMicroelectronics.
6 */
7
8#include <linux/io.h>
9#include <linux/module.h>
10#include <linux/regmap.h>
11#include <linux/reset.h>
12#include <linux/mfd/syscon.h>
13
14#include <sound/soc.h>
15#include <sound/soc-dapm.h>
16
17/* DAC definitions */
18
19/* stih407 DAC registers */
20/* sysconf 5041: Audio-Gue-Control */
21#define STIH407_AUDIO_GLUE_CTRL 0x000000A4
22/* sysconf 5042: Audio-DAC-Control */
23#define STIH407_AUDIO_DAC_CTRL 0x000000A8
24
25/* DAC definitions */
26#define STIH407_DAC_SOFTMUTE 0x0
27#define STIH407_DAC_STANDBY_ANA 0x1
28#define STIH407_DAC_STANDBY 0x2
29
30#define STIH407_DAC_SOFTMUTE_MASK BIT(STIH407_DAC_SOFTMUTE)
31#define STIH407_DAC_STANDBY_ANA_MASK BIT(STIH407_DAC_STANDBY_ANA)
32#define STIH407_DAC_STANDBY_MASK BIT(STIH407_DAC_STANDBY)
33
34/* SPDIF definitions */
35#define SPDIF_BIPHASE_ENABLE 0x6
36#define SPDIF_BIPHASE_IDLE 0x7
37
38#define SPDIF_BIPHASE_ENABLE_MASK BIT(SPDIF_BIPHASE_ENABLE)
39#define SPDIF_BIPHASE_IDLE_MASK BIT(SPDIF_BIPHASE_IDLE)
40
41enum {
42 STI_SAS_DAI_SPDIF_OUT,
43 STI_SAS_DAI_ANALOG_OUT,
44};
45
46static const struct reg_default stih407_sas_reg_defaults[] = {
47 { STIH407_AUDIO_DAC_CTRL, 0x000000000 },
48 { STIH407_AUDIO_GLUE_CTRL, 0x00000040 },
49};
50
51struct sti_dac_audio {
52 struct regmap *regmap;
53 struct regmap *virt_regmap;
54 int mclk;
55};
56
57struct sti_spdif_audio {
58 struct regmap *regmap;
59 int mclk;
60};
61
62/* device data structure */
63struct sti_sas_dev_data {
64 const struct regmap_config *regmap;
65 const struct snd_soc_dai_ops *dac_ops; /* DAC function callbacks */
66};
67
68/* driver data structure */
69struct sti_sas_data {
70 struct device *dev;
71 const struct sti_sas_dev_data *dev_data;
72 struct sti_dac_audio dac;
73 struct sti_spdif_audio spdif;
74};
75
76/* Read a register from the sysconf reg bank */
77static int sti_sas_read_reg(void *context, unsigned int reg,
78 unsigned int *value)
79{
80 struct sti_sas_data *drvdata = context;
81 int status;
82 u32 val;
83
84 status = regmap_read(drvdata->dac.regmap, reg, &val);
85 *value = (unsigned int)val;
86
87 return status;
88}
89
90/* Read a register from the sysconf reg bank */
91static int sti_sas_write_reg(void *context, unsigned int reg,
92 unsigned int value)
93{
94 struct sti_sas_data *drvdata = context;
95
96 return regmap_write(drvdata->dac.regmap, reg, value);
97}
98
99static int sti_sas_init_sas_registers(struct snd_soc_component *component,
100 struct sti_sas_data *data)
101{
102 int ret;
103 /*
104 * DAC and SPDIF are activated by default
105 * put them in IDLE to save power
106 */
107
108 /* Initialise bi-phase formatter to disabled */
109 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
110 SPDIF_BIPHASE_ENABLE_MASK, 0);
111
112 if (!ret)
113 /* Initialise bi-phase formatter idle value to 0 */
114 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
115 SPDIF_BIPHASE_IDLE_MASK, 0);
116 if (ret < 0) {
117 dev_err(component->dev, "Failed to update SPDIF registers\n");
118 return ret;
119 }
120
121 /* Init DAC configuration */
122 /* init configuration */
123 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
124 STIH407_DAC_STANDBY_MASK,
125 STIH407_DAC_STANDBY_MASK);
126
127 if (!ret)
128 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
129 STIH407_DAC_STANDBY_ANA_MASK,
130 STIH407_DAC_STANDBY_ANA_MASK);
131 if (!ret)
132 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
133 STIH407_DAC_SOFTMUTE_MASK,
134 STIH407_DAC_SOFTMUTE_MASK);
135
136 if (ret < 0) {
137 dev_err(component->dev, "Failed to update DAC registers\n");
138 return ret;
139 }
140
141 return ret;
142}
143
144/*
145 * DAC
146 */
147static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
148{
149 /* Sanity check only */
150 if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_CBC_CFC) {
151 dev_err(dai->component->dev,
152 "%s: ERROR: Unsupported clocking 0x%x\n",
153 __func__, fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK);
154 return -EINVAL;
155 }
156
157 return 0;
158}
159
160static const struct snd_soc_dapm_widget stih407_sas_dapm_widgets[] = {
161 SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH407_AUDIO_DAC_CTRL,
162 STIH407_DAC_STANDBY_ANA, 1, NULL, 0),
163 SND_SOC_DAPM_DAC("DAC standby", "dac_p", STIH407_AUDIO_DAC_CTRL,
164 STIH407_DAC_STANDBY, 1),
165 SND_SOC_DAPM_OUTPUT("DAC Output"),
166};
167
168static const struct snd_soc_dapm_route stih407_sas_route[] = {
169 {"DAC Output", NULL, "DAC standby ana"},
170 {"DAC standby ana", NULL, "DAC standby"},
171};
172
173
174static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
175{
176 struct snd_soc_component *component = dai->component;
177
178 if (mute) {
179 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
180 STIH407_DAC_SOFTMUTE_MASK,
181 STIH407_DAC_SOFTMUTE_MASK);
182 } else {
183 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
184 STIH407_DAC_SOFTMUTE_MASK,
185 0);
186 }
187}
188
189/*
190 * SPDIF
191 */
192static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
193 unsigned int fmt)
194{
195 if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_CBC_CFC) {
196 dev_err(dai->component->dev,
197 "%s: ERROR: Unsupported clocking mask 0x%x\n",
198 __func__, fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK);
199 return -EINVAL;
200 }
201
202 return 0;
203}
204
205/*
206 * sti_sas_spdif_trigger:
207 * Trigger function is used to ensure that BiPhase Formater is disabled
208 * before CPU dai is stopped.
209 * This is mandatory to avoid that BPF is stalled
210 */
211static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
212 struct snd_soc_dai *dai)
213{
214 struct snd_soc_component *component = dai->component;
215
216 switch (cmd) {
217 case SNDRV_PCM_TRIGGER_START:
218 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
219 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
220 SPDIF_BIPHASE_ENABLE_MASK,
221 SPDIF_BIPHASE_ENABLE_MASK);
222 case SNDRV_PCM_TRIGGER_RESUME:
223 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
224 case SNDRV_PCM_TRIGGER_STOP:
225 case SNDRV_PCM_TRIGGER_SUSPEND:
226 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
227 SPDIF_BIPHASE_ENABLE_MASK,
228 0);
229 default:
230 return -EINVAL;
231 }
232}
233
234static bool sti_sas_volatile_register(struct device *dev, unsigned int reg)
235{
236 if (reg == STIH407_AUDIO_GLUE_CTRL)
237 return true;
238
239 return false;
240}
241
242/*
243 * CODEC DAIS
244 */
245
246/*
247 * sti_sas_set_sysclk:
248 * get MCLK input frequency to check that MCLK-FS ratio is coherent
249 */
250static int sti_sas_set_sysclk(struct snd_soc_dai *dai, int clk_id,
251 unsigned int freq, int dir)
252{
253 struct snd_soc_component *component = dai->component;
254 struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
255
256 if (dir == SND_SOC_CLOCK_OUT)
257 return 0;
258
259 if (clk_id != 0)
260 return -EINVAL;
261
262 switch (dai->id) {
263 case STI_SAS_DAI_SPDIF_OUT:
264 drvdata->spdif.mclk = freq;
265 break;
266
267 case STI_SAS_DAI_ANALOG_OUT:
268 drvdata->dac.mclk = freq;
269 break;
270 }
271
272 return 0;
273}
274
275static int sti_sas_prepare(struct snd_pcm_substream *substream,
276 struct snd_soc_dai *dai)
277{
278 struct snd_soc_component *component = dai->component;
279 struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
280 struct snd_pcm_runtime *runtime = substream->runtime;
281
282 switch (dai->id) {
283 case STI_SAS_DAI_SPDIF_OUT:
284 if ((drvdata->spdif.mclk / runtime->rate) != 128) {
285 dev_err(component->dev, "unexpected mclk-fs ratio\n");
286 return -EINVAL;
287 }
288 break;
289 case STI_SAS_DAI_ANALOG_OUT:
290 if ((drvdata->dac.mclk / runtime->rate) != 256) {
291 dev_err(component->dev, "unexpected mclk-fs ratio\n");
292 return -EINVAL;
293 }
294 break;
295 }
296
297 return 0;
298}
299
300static const struct snd_soc_dai_ops stih407_dac_ops = {
301 .set_fmt = sti_sas_dac_set_fmt,
302 .mute_stream = stih407_sas_dac_mute,
303 .prepare = sti_sas_prepare,
304 .set_sysclk = sti_sas_set_sysclk,
305};
306
307static const struct regmap_config stih407_sas_regmap = {
308 .reg_bits = 32,
309 .val_bits = 32,
310 .fast_io = true,
311 .max_register = STIH407_AUDIO_DAC_CTRL,
312 .reg_defaults = stih407_sas_reg_defaults,
313 .num_reg_defaults = ARRAY_SIZE(stih407_sas_reg_defaults),
314 .volatile_reg = sti_sas_volatile_register,
315 .cache_type = REGCACHE_MAPLE,
316 .reg_read = sti_sas_read_reg,
317 .reg_write = sti_sas_write_reg,
318};
319
320static const struct sti_sas_dev_data stih407_data = {
321 .regmap = &stih407_sas_regmap,
322 .dac_ops = &stih407_dac_ops,
323};
324
325static struct snd_soc_dai_driver sti_sas_dai[] = {
326 {
327 .name = "sas-dai-spdif-out",
328 .id = STI_SAS_DAI_SPDIF_OUT,
329 .playback = {
330 .stream_name = "spdif_p",
331 .channels_min = 2,
332 .channels_max = 2,
333 .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
334 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
335 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
336 SNDRV_PCM_RATE_192000,
337 .formats = SNDRV_PCM_FMTBIT_S16_LE |
338 SNDRV_PCM_FMTBIT_S32_LE,
339 },
340 .ops = (struct snd_soc_dai_ops[]) {
341 {
342 .set_fmt = sti_sas_spdif_set_fmt,
343 .trigger = sti_sas_spdif_trigger,
344 .set_sysclk = sti_sas_set_sysclk,
345 .prepare = sti_sas_prepare,
346 }
347 },
348 },
349 {
350 .name = "sas-dai-dac",
351 .id = STI_SAS_DAI_ANALOG_OUT,
352 .playback = {
353 .stream_name = "dac_p",
354 .channels_min = 2,
355 .channels_max = 2,
356 .rates = SNDRV_PCM_RATE_8000_48000,
357 .formats = SNDRV_PCM_FMTBIT_S16_LE |
358 SNDRV_PCM_FMTBIT_S32_LE,
359 },
360 },
361};
362
363#ifdef CONFIG_PM_SLEEP
364static int sti_sas_resume(struct snd_soc_component *component)
365{
366 struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
367
368 return sti_sas_init_sas_registers(component, drvdata);
369}
370#else
371#define sti_sas_resume NULL
372#endif
373
374static int sti_sas_component_probe(struct snd_soc_component *component)
375{
376 struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
377
378 return sti_sas_init_sas_registers(component, drvdata);
379}
380
381static const struct snd_soc_component_driver sti_sas_driver = {
382 .probe = sti_sas_component_probe,
383 .resume = sti_sas_resume,
384 .idle_bias_on = 1,
385 .use_pmdown_time = 1,
386 .endianness = 1,
387 .dapm_widgets = stih407_sas_dapm_widgets,
388 .num_dapm_widgets = ARRAY_SIZE(stih407_sas_dapm_widgets),
389 .dapm_routes = stih407_sas_route,
390 .num_dapm_routes = ARRAY_SIZE(stih407_sas_route),
391};
392
393static const struct of_device_id sti_sas_dev_match[] = {
394 {
395 .compatible = "st,stih407-sas-codec",
396 .data = &stih407_data,
397 },
398 {},
399};
400MODULE_DEVICE_TABLE(of, sti_sas_dev_match);
401
402static int sti_sas_driver_probe(struct platform_device *pdev)
403{
404 struct device_node *pnode = pdev->dev.of_node;
405 struct sti_sas_data *drvdata;
406 const struct of_device_id *of_id;
407
408 /* Allocate device structure */
409 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data),
410 GFP_KERNEL);
411 if (!drvdata)
412 return -ENOMEM;
413
414 /* Populate data structure depending on compatibility */
415 of_id = of_match_node(sti_sas_dev_match, pnode);
416 if (!of_id->data) {
417 dev_err(&pdev->dev, "data associated to device is missing\n");
418 return -EINVAL;
419 }
420
421 drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data;
422
423 /* Initialise device structure */
424 drvdata->dev = &pdev->dev;
425
426 /* Request the DAC & SPDIF registers memory region */
427 drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata,
428 drvdata->dev_data->regmap);
429 if (IS_ERR(drvdata->dac.virt_regmap)) {
430 dev_err(&pdev->dev, "audio registers not enabled\n");
431 return PTR_ERR(drvdata->dac.virt_regmap);
432 }
433
434 /* Request the syscon region */
435 drvdata->dac.regmap =
436 syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
437 if (IS_ERR(drvdata->dac.regmap)) {
438 dev_err(&pdev->dev, "syscon registers not available\n");
439 return PTR_ERR(drvdata->dac.regmap);
440 }
441 drvdata->spdif.regmap = drvdata->dac.regmap;
442
443 sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops;
444
445 /* Store context */
446 dev_set_drvdata(&pdev->dev, drvdata);
447
448 return devm_snd_soc_register_component(&pdev->dev, &sti_sas_driver,
449 sti_sas_dai,
450 ARRAY_SIZE(sti_sas_dai));
451}
452
453static struct platform_driver sti_sas_platform_driver = {
454 .driver = {
455 .name = "sti-sas-codec",
456 .of_match_table = sti_sas_dev_match,
457 },
458 .probe = sti_sas_driver_probe,
459};
460
461module_platform_driver(sti_sas_platform_driver);
462
463MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
464MODULE_AUTHOR("Arnaud.pouliquen@st.com");
465MODULE_LICENSE("GPL v2");
1/*
2 * Copyright (C) STMicroelectronics SA 2015
3 * Authors: Arnaud Pouliquen <arnaud.pouliquen@st.com>
4 * for STMicroelectronics.
5 * License terms: GNU General Public License (GPL), version 2
6 */
7
8#include <linux/io.h>
9#include <linux/module.h>
10#include <linux/regmap.h>
11#include <linux/reset.h>
12#include <linux/mfd/syscon.h>
13
14#include <sound/soc.h>
15#include <sound/soc-dapm.h>
16
17/* chipID supported */
18#define CHIPID_STIH416 0
19#define CHIPID_STIH407 1
20
21/* DAC definitions */
22
23/* stih416 DAC registers */
24/* sysconf 2517: Audio-DAC-Control */
25#define STIH416_AUDIO_DAC_CTRL 0x00000814
26/* sysconf 2519: Audio-Gue-Control */
27#define STIH416_AUDIO_GLUE_CTRL 0x0000081C
28
29#define STIH416_DAC_NOT_STANDBY 0x3
30#define STIH416_DAC_SOFTMUTE 0x4
31#define STIH416_DAC_ANA_NOT_PWR 0x5
32#define STIH416_DAC_NOT_PNDBG 0x6
33
34#define STIH416_DAC_NOT_STANDBY_MASK BIT(STIH416_DAC_NOT_STANDBY)
35#define STIH416_DAC_SOFTMUTE_MASK BIT(STIH416_DAC_SOFTMUTE)
36#define STIH416_DAC_ANA_NOT_PWR_MASK BIT(STIH416_DAC_ANA_NOT_PWR)
37#define STIH416_DAC_NOT_PNDBG_MASK BIT(STIH416_DAC_NOT_PNDBG)
38
39/* stih407 DAC registers */
40/* sysconf 5041: Audio-Gue-Control */
41#define STIH407_AUDIO_GLUE_CTRL 0x000000A4
42/* sysconf 5042: Audio-DAC-Control */
43#define STIH407_AUDIO_DAC_CTRL 0x000000A8
44
45/* DAC definitions */
46#define STIH407_DAC_SOFTMUTE 0x0
47#define STIH407_DAC_STANDBY_ANA 0x1
48#define STIH407_DAC_STANDBY 0x2
49
50#define STIH407_DAC_SOFTMUTE_MASK BIT(STIH407_DAC_SOFTMUTE)
51#define STIH407_DAC_STANDBY_ANA_MASK BIT(STIH407_DAC_STANDBY_ANA)
52#define STIH407_DAC_STANDBY_MASK BIT(STIH407_DAC_STANDBY)
53
54/* SPDIF definitions */
55#define SPDIF_BIPHASE_ENABLE 0x6
56#define SPDIF_BIPHASE_IDLE 0x7
57
58#define SPDIF_BIPHASE_ENABLE_MASK BIT(SPDIF_BIPHASE_ENABLE)
59#define SPDIF_BIPHASE_IDLE_MASK BIT(SPDIF_BIPHASE_IDLE)
60
61enum {
62 STI_SAS_DAI_SPDIF_OUT,
63 STI_SAS_DAI_ANALOG_OUT,
64};
65
66static const struct reg_default stih416_sas_reg_defaults[] = {
67 { STIH407_AUDIO_GLUE_CTRL, 0x00000040 },
68 { STIH407_AUDIO_DAC_CTRL, 0x000000000 },
69};
70
71static const struct reg_default stih407_sas_reg_defaults[] = {
72 { STIH416_AUDIO_DAC_CTRL, 0x000000000 },
73 { STIH416_AUDIO_GLUE_CTRL, 0x00000040 },
74};
75
76struct sti_dac_audio {
77 struct regmap *regmap;
78 struct regmap *virt_regmap;
79 struct regmap_field **field;
80 struct reset_control *rst;
81 int mclk;
82};
83
84struct sti_spdif_audio {
85 struct regmap *regmap;
86 struct regmap_field **field;
87 int mclk;
88};
89
90/* device data structure */
91struct sti_sas_dev_data {
92 const int chipid; /* IC version */
93 const struct regmap_config *regmap;
94 const struct snd_soc_dai_ops *dac_ops; /* DAC function callbacks */
95 const struct snd_soc_dapm_widget *dapm_widgets; /* dapms declaration */
96 const int num_dapm_widgets; /* dapms declaration */
97 const struct snd_soc_dapm_route *dapm_routes; /* route declaration */
98 const int num_dapm_routes; /* route declaration */
99};
100
101/* driver data structure */
102struct sti_sas_data {
103 struct device *dev;
104 const struct sti_sas_dev_data *dev_data;
105 struct sti_dac_audio dac;
106 struct sti_spdif_audio spdif;
107};
108
109/* Read a register from the sysconf reg bank */
110static int sti_sas_read_reg(void *context, unsigned int reg,
111 unsigned int *value)
112{
113 struct sti_sas_data *drvdata = context;
114 int status;
115 u32 val;
116
117 status = regmap_read(drvdata->dac.regmap, reg, &val);
118 *value = (unsigned int)val;
119
120 return status;
121}
122
123/* Read a register from the sysconf reg bank */
124static int sti_sas_write_reg(void *context, unsigned int reg,
125 unsigned int value)
126{
127 struct sti_sas_data *drvdata = context;
128 int status;
129
130 status = regmap_write(drvdata->dac.regmap, reg, value);
131
132 return status;
133}
134
135static int sti_sas_init_sas_registers(struct snd_soc_codec *codec,
136 struct sti_sas_data *data)
137{
138 int ret;
139 /*
140 * DAC and SPDIF are activated by default
141 * put them in IDLE to save power
142 */
143
144 /* Initialise bi-phase formatter to disabled */
145 ret = snd_soc_update_bits(codec, STIH407_AUDIO_GLUE_CTRL,
146 SPDIF_BIPHASE_ENABLE_MASK, 0);
147
148 if (!ret)
149 /* Initialise bi-phase formatter idle value to 0 */
150 ret = snd_soc_update_bits(codec, STIH407_AUDIO_GLUE_CTRL,
151 SPDIF_BIPHASE_IDLE_MASK, 0);
152 if (ret < 0) {
153 dev_err(codec->dev, "Failed to update SPDIF registers");
154 return ret;
155 }
156
157 /* Init DAC configuration */
158 switch (data->dev_data->chipid) {
159 case CHIPID_STIH407:
160 /* init configuration */
161 ret = snd_soc_update_bits(codec, STIH407_AUDIO_DAC_CTRL,
162 STIH407_DAC_STANDBY_MASK,
163 STIH407_DAC_STANDBY_MASK);
164
165 if (!ret)
166 ret = snd_soc_update_bits(codec, STIH407_AUDIO_DAC_CTRL,
167 STIH407_DAC_STANDBY_ANA_MASK,
168 STIH407_DAC_STANDBY_ANA_MASK);
169 if (!ret)
170 ret = snd_soc_update_bits(codec, STIH407_AUDIO_DAC_CTRL,
171 STIH407_DAC_SOFTMUTE_MASK,
172 STIH407_DAC_SOFTMUTE_MASK);
173 break;
174 case CHIPID_STIH416:
175 ret = snd_soc_update_bits(codec, STIH416_AUDIO_DAC_CTRL,
176 STIH416_DAC_NOT_STANDBY_MASK, 0);
177 if (!ret)
178 ret = snd_soc_update_bits(codec,
179 STIH416_AUDIO_DAC_CTRL,
180 STIH416_DAC_ANA_NOT_PWR, 0);
181 if (!ret)
182 ret = snd_soc_update_bits(codec,
183 STIH416_AUDIO_DAC_CTRL,
184 STIH416_DAC_NOT_PNDBG_MASK,
185 0);
186 if (!ret)
187 ret = snd_soc_update_bits(codec,
188 STIH416_AUDIO_DAC_CTRL,
189 STIH416_DAC_SOFTMUTE_MASK,
190 STIH416_DAC_SOFTMUTE_MASK);
191 break;
192 default:
193 return -EINVAL;
194 }
195
196 if (ret < 0) {
197 dev_err(codec->dev, "Failed to update DAC registers");
198 return ret;
199 }
200
201 return ret;
202}
203
204/*
205 * DAC
206 */
207static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
208{
209 /* Sanity check only */
210 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
211 dev_err(dai->codec->dev,
212 "%s: ERROR: Unsupporter master mask 0x%x\n",
213 __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
214 return -EINVAL;
215 }
216
217 return 0;
218}
219
220static int stih416_dac_probe(struct snd_soc_dai *dai)
221{
222 struct snd_soc_codec *codec = dai->codec;
223 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev);
224 struct sti_dac_audio *dac = &drvdata->dac;
225
226 /* Get reset control */
227 dac->rst = devm_reset_control_get(codec->dev, "dac_rst");
228 if (IS_ERR(dac->rst)) {
229 dev_err(dai->codec->dev,
230 "%s: ERROR: DAC reset control not defined !\n",
231 __func__);
232 dac->rst = NULL;
233 return -EFAULT;
234 }
235 /* Put the DAC into reset */
236 reset_control_assert(dac->rst);
237
238 return 0;
239}
240
241static const struct snd_soc_dapm_widget stih416_sas_dapm_widgets[] = {
242 SND_SOC_DAPM_PGA("DAC bandgap", STIH416_AUDIO_DAC_CTRL,
243 STIH416_DAC_NOT_PNDBG_MASK, 0, NULL, 0),
244 SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH416_AUDIO_DAC_CTRL,
245 STIH416_DAC_ANA_NOT_PWR, 0, NULL, 0),
246 SND_SOC_DAPM_DAC("DAC standby", "dac_p", STIH416_AUDIO_DAC_CTRL,
247 STIH416_DAC_NOT_STANDBY, 0),
248 SND_SOC_DAPM_OUTPUT("DAC Output"),
249};
250
251static const struct snd_soc_dapm_widget stih407_sas_dapm_widgets[] = {
252 SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH407_AUDIO_DAC_CTRL,
253 STIH407_DAC_STANDBY_ANA, 1, NULL, 0),
254 SND_SOC_DAPM_DAC("DAC standby", "dac_p", STIH407_AUDIO_DAC_CTRL,
255 STIH407_DAC_STANDBY, 1),
256 SND_SOC_DAPM_OUTPUT("DAC Output"),
257};
258
259static const struct snd_soc_dapm_route stih416_sas_route[] = {
260 {"DAC Output", NULL, "DAC bandgap"},
261 {"DAC Output", NULL, "DAC standby ana"},
262 {"DAC standby ana", NULL, "DAC standby"},
263};
264
265static const struct snd_soc_dapm_route stih407_sas_route[] = {
266 {"DAC Output", NULL, "DAC standby ana"},
267 {"DAC standby ana", NULL, "DAC standby"},
268};
269
270static int stih416_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
271{
272 struct snd_soc_codec *codec = dai->codec;
273
274 if (mute) {
275 return snd_soc_update_bits(codec, STIH416_AUDIO_DAC_CTRL,
276 STIH416_DAC_SOFTMUTE_MASK,
277 STIH416_DAC_SOFTMUTE_MASK);
278 } else {
279 return snd_soc_update_bits(codec, STIH416_AUDIO_DAC_CTRL,
280 STIH416_DAC_SOFTMUTE_MASK, 0);
281 }
282}
283
284static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
285{
286 struct snd_soc_codec *codec = dai->codec;
287
288 if (mute) {
289 return snd_soc_update_bits(codec, STIH407_AUDIO_DAC_CTRL,
290 STIH407_DAC_SOFTMUTE_MASK,
291 STIH407_DAC_SOFTMUTE_MASK);
292 } else {
293 return snd_soc_update_bits(codec, STIH407_AUDIO_DAC_CTRL,
294 STIH407_DAC_SOFTMUTE_MASK,
295 0);
296 }
297}
298
299/*
300 * SPDIF
301 */
302static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
303 unsigned int fmt)
304{
305 if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
306 dev_err(dai->codec->dev,
307 "%s: ERROR: Unsupporter master mask 0x%x\n",
308 __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
309 return -EINVAL;
310 }
311
312 return 0;
313}
314
315/*
316 * sti_sas_spdif_trigger:
317 * Trigger function is used to ensure that BiPhase Formater is disabled
318 * before CPU dai is stopped.
319 * This is mandatory to avoid that BPF is stalled
320 */
321static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
322 struct snd_soc_dai *dai)
323{
324 struct snd_soc_codec *codec = dai->codec;
325
326 switch (cmd) {
327 case SNDRV_PCM_TRIGGER_START:
328 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
329 return snd_soc_update_bits(codec, STIH407_AUDIO_GLUE_CTRL,
330 SPDIF_BIPHASE_ENABLE_MASK,
331 SPDIF_BIPHASE_ENABLE_MASK);
332 case SNDRV_PCM_TRIGGER_RESUME:
333 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
334 case SNDRV_PCM_TRIGGER_STOP:
335 case SNDRV_PCM_TRIGGER_SUSPEND:
336 return snd_soc_update_bits(codec, STIH407_AUDIO_GLUE_CTRL,
337 SPDIF_BIPHASE_ENABLE_MASK,
338 0);
339 default:
340 return -EINVAL;
341 }
342}
343
344static bool sti_sas_volatile_register(struct device *dev, unsigned int reg)
345{
346 if (reg == STIH407_AUDIO_GLUE_CTRL)
347 return true;
348
349 return false;
350}
351
352/*
353 * CODEC DAIS
354 */
355
356/*
357 * sti_sas_set_sysclk:
358 * get MCLK input frequency to check that MCLK-FS ratio is coherent
359 */
360static int sti_sas_set_sysclk(struct snd_soc_dai *dai, int clk_id,
361 unsigned int freq, int dir)
362{
363 struct snd_soc_codec *codec = dai->codec;
364 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev);
365
366 if (dir == SND_SOC_CLOCK_OUT)
367 return 0;
368
369 if (clk_id != 0)
370 return -EINVAL;
371
372 switch (dai->id) {
373 case STI_SAS_DAI_SPDIF_OUT:
374 drvdata->spdif.mclk = freq;
375 break;
376
377 case STI_SAS_DAI_ANALOG_OUT:
378 drvdata->dac.mclk = freq;
379 break;
380 }
381
382 return 0;
383}
384
385static int sti_sas_prepare(struct snd_pcm_substream *substream,
386 struct snd_soc_dai *dai)
387{
388 struct snd_soc_codec *codec = dai->codec;
389 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev);
390 struct snd_pcm_runtime *runtime = substream->runtime;
391
392 switch (dai->id) {
393 case STI_SAS_DAI_SPDIF_OUT:
394 if ((drvdata->spdif.mclk / runtime->rate) != 128) {
395 dev_err(codec->dev, "unexpected mclk-fs ratio");
396 return -EINVAL;
397 }
398 break;
399 case STI_SAS_DAI_ANALOG_OUT:
400 if ((drvdata->dac.mclk / runtime->rate) != 256) {
401 dev_err(codec->dev, "unexpected mclk-fs ratio");
402 return -EINVAL;
403 }
404 break;
405 }
406
407 return 0;
408}
409
410static const struct snd_soc_dai_ops stih416_dac_ops = {
411 .set_fmt = sti_sas_dac_set_fmt,
412 .mute_stream = stih416_sas_dac_mute,
413 .prepare = sti_sas_prepare,
414 .set_sysclk = sti_sas_set_sysclk,
415};
416
417static const struct snd_soc_dai_ops stih407_dac_ops = {
418 .set_fmt = sti_sas_dac_set_fmt,
419 .mute_stream = stih407_sas_dac_mute,
420 .prepare = sti_sas_prepare,
421 .set_sysclk = sti_sas_set_sysclk,
422};
423
424static const struct regmap_config stih407_sas_regmap = {
425 .reg_bits = 32,
426 .val_bits = 32,
427
428 .max_register = STIH407_AUDIO_DAC_CTRL,
429 .reg_defaults = stih407_sas_reg_defaults,
430 .num_reg_defaults = ARRAY_SIZE(stih407_sas_reg_defaults),
431 .volatile_reg = sti_sas_volatile_register,
432 .cache_type = REGCACHE_RBTREE,
433 .reg_read = sti_sas_read_reg,
434 .reg_write = sti_sas_write_reg,
435};
436
437static const struct regmap_config stih416_sas_regmap = {
438 .reg_bits = 32,
439 .val_bits = 32,
440
441 .max_register = STIH416_AUDIO_DAC_CTRL,
442 .reg_defaults = stih416_sas_reg_defaults,
443 .num_reg_defaults = ARRAY_SIZE(stih416_sas_reg_defaults),
444 .volatile_reg = sti_sas_volatile_register,
445 .cache_type = REGCACHE_RBTREE,
446 .reg_read = sti_sas_read_reg,
447 .reg_write = sti_sas_write_reg,
448};
449
450static const struct sti_sas_dev_data stih416_data = {
451 .chipid = CHIPID_STIH416,
452 .regmap = &stih416_sas_regmap,
453 .dac_ops = &stih416_dac_ops,
454 .dapm_widgets = stih416_sas_dapm_widgets,
455 .num_dapm_widgets = ARRAY_SIZE(stih416_sas_dapm_widgets),
456 .dapm_routes = stih416_sas_route,
457 .num_dapm_routes = ARRAY_SIZE(stih416_sas_route),
458};
459
460static const struct sti_sas_dev_data stih407_data = {
461 .chipid = CHIPID_STIH407,
462 .regmap = &stih407_sas_regmap,
463 .dac_ops = &stih407_dac_ops,
464 .dapm_widgets = stih407_sas_dapm_widgets,
465 .num_dapm_widgets = ARRAY_SIZE(stih407_sas_dapm_widgets),
466 .dapm_routes = stih407_sas_route,
467 .num_dapm_routes = ARRAY_SIZE(stih407_sas_route),
468};
469
470static struct snd_soc_dai_driver sti_sas_dai[] = {
471 {
472 .name = "sas-dai-spdif-out",
473 .id = STI_SAS_DAI_SPDIF_OUT,
474 .playback = {
475 .stream_name = "spdif_p",
476 .channels_min = 2,
477 .channels_max = 2,
478 .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
479 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
480 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
481 SNDRV_PCM_RATE_192000,
482 .formats = SNDRV_PCM_FMTBIT_S16_LE |
483 SNDRV_PCM_FMTBIT_S32_LE,
484 },
485 .ops = (struct snd_soc_dai_ops[]) {
486 {
487 .set_fmt = sti_sas_spdif_set_fmt,
488 .trigger = sti_sas_spdif_trigger,
489 .set_sysclk = sti_sas_set_sysclk,
490 .prepare = sti_sas_prepare,
491 }
492 },
493 },
494 {
495 .name = "sas-dai-dac",
496 .id = STI_SAS_DAI_ANALOG_OUT,
497 .playback = {
498 .stream_name = "dac_p",
499 .channels_min = 2,
500 .channels_max = 2,
501 .rates = SNDRV_PCM_RATE_8000_48000,
502 .formats = SNDRV_PCM_FMTBIT_S16_LE |
503 SNDRV_PCM_FMTBIT_S32_LE,
504 },
505 },
506};
507
508#ifdef CONFIG_PM_SLEEP
509static int sti_sas_resume(struct snd_soc_codec *codec)
510{
511 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev);
512
513 return sti_sas_init_sas_registers(codec, drvdata);
514}
515#else
516#define sti_sas_resume NULL
517#endif
518
519static int sti_sas_codec_probe(struct snd_soc_codec *codec)
520{
521 struct sti_sas_data *drvdata = dev_get_drvdata(codec->dev);
522 int ret;
523
524 ret = sti_sas_init_sas_registers(codec, drvdata);
525
526 return ret;
527}
528
529static struct snd_soc_codec_driver sti_sas_driver = {
530 .probe = sti_sas_codec_probe,
531 .resume = sti_sas_resume,
532};
533
534static const struct of_device_id sti_sas_dev_match[] = {
535 {
536 .compatible = "st,stih416-sas-codec",
537 .data = &stih416_data,
538 },
539 {
540 .compatible = "st,stih407-sas-codec",
541 .data = &stih407_data,
542 },
543 {},
544};
545
546static int sti_sas_driver_probe(struct platform_device *pdev)
547{
548 struct device_node *pnode = pdev->dev.of_node;
549 struct sti_sas_data *drvdata;
550 const struct of_device_id *of_id;
551
552 /* Allocate device structure */
553 drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data),
554 GFP_KERNEL);
555 if (!drvdata)
556 return -ENOMEM;
557
558 /* Populate data structure depending on compatibility */
559 of_id = of_match_node(sti_sas_dev_match, pnode);
560 if (!of_id->data) {
561 dev_err(&pdev->dev, "data associated to device is missing");
562 return -EINVAL;
563 }
564
565 drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data;
566
567 /* Initialise device structure */
568 drvdata->dev = &pdev->dev;
569
570 /* Request the DAC & SPDIF registers memory region */
571 drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata,
572 drvdata->dev_data->regmap);
573 if (IS_ERR(drvdata->dac.virt_regmap)) {
574 dev_err(&pdev->dev, "audio registers not enabled\n");
575 return PTR_ERR(drvdata->dac.virt_regmap);
576 }
577
578 /* Request the syscon region */
579 drvdata->dac.regmap =
580 syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
581 if (IS_ERR(drvdata->dac.regmap)) {
582 dev_err(&pdev->dev, "syscon registers not available\n");
583 return PTR_ERR(drvdata->dac.regmap);
584 }
585 drvdata->spdif.regmap = drvdata->dac.regmap;
586
587 /* Set DAC dai probe */
588 if (drvdata->dev_data->chipid == CHIPID_STIH416)
589 sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].probe = stih416_dac_probe;
590
591 sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops;
592
593 /* Set dapms*/
594 sti_sas_driver.dapm_widgets = drvdata->dev_data->dapm_widgets;
595 sti_sas_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets;
596
597 sti_sas_driver.dapm_routes = drvdata->dev_data->dapm_routes;
598 sti_sas_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes;
599
600 /* Store context */
601 dev_set_drvdata(&pdev->dev, drvdata);
602
603 return snd_soc_register_codec(&pdev->dev, &sti_sas_driver,
604 sti_sas_dai,
605 ARRAY_SIZE(sti_sas_dai));
606}
607
608static int sti_sas_driver_remove(struct platform_device *pdev)
609{
610 snd_soc_unregister_codec(&pdev->dev);
611
612 return 0;
613}
614
615static struct platform_driver sti_sas_platform_driver = {
616 .driver = {
617 .name = "sti-sas-codec",
618 .of_match_table = sti_sas_dev_match,
619 },
620 .probe = sti_sas_driver_probe,
621 .remove = sti_sas_driver_remove,
622};
623
624module_platform_driver(sti_sas_platform_driver);
625
626MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
627MODULE_AUTHOR("Arnaud.pouliquen@st.com");
628MODULE_LICENSE("GPL v2");