~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/sti-sas.c

Version: ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 /* 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 
 41 enum {
 42         STI_SAS_DAI_SPDIF_OUT,
 43         STI_SAS_DAI_ANALOG_OUT,
 44 };
 45 
 46 static const struct reg_default stih407_sas_reg_defaults[] = {
 47         { STIH407_AUDIO_DAC_CTRL, 0x000000000 },
 48         { STIH407_AUDIO_GLUE_CTRL, 0x00000040 },
 49 };
 50 
 51 struct sti_dac_audio {
 52         struct regmap *regmap;
 53         struct regmap *virt_regmap;
 54         struct regmap_field  **field;
 55         struct reset_control *rst;
 56         int mclk;
 57 };
 58 
 59 struct sti_spdif_audio {
 60         struct regmap *regmap;
 61         struct regmap_field  **field;
 62         int mclk;
 63 };
 64 
 65 /* device data structure */
 66 struct sti_sas_dev_data {
 67         const struct regmap_config *regmap;
 68         const struct snd_soc_dai_ops *dac_ops;  /* DAC function callbacks */
 69         const struct snd_soc_dapm_widget *dapm_widgets; /* dapms declaration */
 70         const int num_dapm_widgets; /* dapms declaration */
 71         const struct snd_soc_dapm_route *dapm_routes; /* route declaration */
 72         const int num_dapm_routes; /* route declaration */
 73 };
 74 
 75 /* driver data structure */
 76 struct sti_sas_data {
 77         struct device *dev;
 78         const struct sti_sas_dev_data *dev_data;
 79         struct sti_dac_audio dac;
 80         struct sti_spdif_audio spdif;
 81 };
 82 
 83 /* Read a register from the sysconf reg bank */
 84 static int sti_sas_read_reg(void *context, unsigned int reg,
 85                             unsigned int *value)
 86 {
 87         struct sti_sas_data *drvdata = context;
 88         int status;
 89         u32 val;
 90 
 91         status = regmap_read(drvdata->dac.regmap, reg, &val);
 92         *value = (unsigned int)val;
 93 
 94         return status;
 95 }
 96 
 97 /* Read a register from the sysconf reg bank */
 98 static int sti_sas_write_reg(void *context, unsigned int reg,
 99                              unsigned int value)
100 {
101         struct sti_sas_data *drvdata = context;
102         int status;
103 
104         status = regmap_write(drvdata->dac.regmap, reg, value);
105 
106         return status;
107 }
108 
109 static int  sti_sas_init_sas_registers(struct snd_soc_component *component,
110                                        struct sti_sas_data *data)
111 {
112         int ret;
113         /*
114          * DAC and SPDIF are activated by default
115          * put them in IDLE to save power
116          */
117 
118         /* Initialise bi-phase formatter to disabled */
119         ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
120                                   SPDIF_BIPHASE_ENABLE_MASK, 0);
121 
122         if (!ret)
123                 /* Initialise bi-phase formatter idle value to 0 */
124                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
125                                           SPDIF_BIPHASE_IDLE_MASK, 0);
126         if (ret < 0) {
127                 dev_err(component->dev, "Failed to update SPDIF registers\n");
128                 return ret;
129         }
130 
131         /* Init DAC configuration */
132         /* init configuration */
133         ret =  snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
134                                    STIH407_DAC_STANDBY_MASK,
135                                    STIH407_DAC_STANDBY_MASK);
136 
137         if (!ret)
138                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
139                                           STIH407_DAC_STANDBY_ANA_MASK,
140                                           STIH407_DAC_STANDBY_ANA_MASK);
141         if (!ret)
142                 ret = snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
143                                           STIH407_DAC_SOFTMUTE_MASK,
144                                           STIH407_DAC_SOFTMUTE_MASK);
145 
146         if (ret < 0) {
147                 dev_err(component->dev, "Failed to update DAC registers\n");
148                 return ret;
149         }
150 
151         return ret;
152 }
153 
154 /*
155  * DAC
156  */
157 static int sti_sas_dac_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
158 {
159         /* Sanity check only */
160         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
161                 dev_err(dai->component->dev,
162                         "%s: ERROR: Unsupporter master mask 0x%x\n",
163                         __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
164                 return -EINVAL;
165         }
166 
167         return 0;
168 }
169 
170 static const struct snd_soc_dapm_widget stih407_sas_dapm_widgets[] = {
171         SND_SOC_DAPM_OUT_DRV("DAC standby ana", STIH407_AUDIO_DAC_CTRL,
172                              STIH407_DAC_STANDBY_ANA, 1, NULL, 0),
173         SND_SOC_DAPM_DAC("DAC standby",  "dac_p", STIH407_AUDIO_DAC_CTRL,
174                          STIH407_DAC_STANDBY, 1),
175         SND_SOC_DAPM_OUTPUT("DAC Output"),
176 };
177 
178 static const struct snd_soc_dapm_route stih407_sas_route[] = {
179         {"DAC Output", NULL, "DAC standby ana"},
180         {"DAC standby ana", NULL, "DAC standby"},
181 };
182 
183 
184 static int stih407_sas_dac_mute(struct snd_soc_dai *dai, int mute, int stream)
185 {
186         struct snd_soc_component *component = dai->component;
187 
188         if (mute) {
189                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
190                                             STIH407_DAC_SOFTMUTE_MASK,
191                                             STIH407_DAC_SOFTMUTE_MASK);
192         } else {
193                 return snd_soc_component_update_bits(component, STIH407_AUDIO_DAC_CTRL,
194                                             STIH407_DAC_SOFTMUTE_MASK,
195                                             0);
196         }
197 }
198 
199 /*
200  * SPDIF
201  */
202 static int sti_sas_spdif_set_fmt(struct snd_soc_dai *dai,
203                                  unsigned int fmt)
204 {
205         if ((fmt & SND_SOC_DAIFMT_MASTER_MASK) != SND_SOC_DAIFMT_CBS_CFS) {
206                 dev_err(dai->component->dev,
207                         "%s: ERROR: Unsupporter master mask 0x%x\n",
208                         __func__, fmt & SND_SOC_DAIFMT_MASTER_MASK);
209                 return -EINVAL;
210         }
211 
212         return 0;
213 }
214 
215 /*
216  * sti_sas_spdif_trigger:
217  * Trigger function is used to ensure that BiPhase Formater is disabled
218  * before CPU dai is stopped.
219  * This is mandatory to avoid that BPF is stalled
220  */
221 static int sti_sas_spdif_trigger(struct snd_pcm_substream *substream, int cmd,
222                                  struct snd_soc_dai *dai)
223 {
224         struct snd_soc_component *component = dai->component;
225 
226         switch (cmd) {
227         case SNDRV_PCM_TRIGGER_START:
228         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
229                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
230                                             SPDIF_BIPHASE_ENABLE_MASK,
231                                             SPDIF_BIPHASE_ENABLE_MASK);
232         case SNDRV_PCM_TRIGGER_RESUME:
233         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
234         case SNDRV_PCM_TRIGGER_STOP:
235         case SNDRV_PCM_TRIGGER_SUSPEND:
236                 return snd_soc_component_update_bits(component, STIH407_AUDIO_GLUE_CTRL,
237                                             SPDIF_BIPHASE_ENABLE_MASK,
238                                             0);
239         default:
240                 return -EINVAL;
241         }
242 }
243 
244 static bool sti_sas_volatile_register(struct device *dev, unsigned int reg)
245 {
246         if (reg == STIH407_AUDIO_GLUE_CTRL)
247                 return true;
248 
249         return false;
250 }
251 
252 /*
253  * CODEC DAIS
254  */
255 
256 /*
257  * sti_sas_set_sysclk:
258  * get MCLK input frequency to check that MCLK-FS ratio is coherent
259  */
260 static int sti_sas_set_sysclk(struct snd_soc_dai *dai, int clk_id,
261                               unsigned int freq, int dir)
262 {
263         struct snd_soc_component *component = dai->component;
264         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
265 
266         if (dir == SND_SOC_CLOCK_OUT)
267                 return 0;
268 
269         if (clk_id != 0)
270                 return -EINVAL;
271 
272         switch (dai->id) {
273         case STI_SAS_DAI_SPDIF_OUT:
274                 drvdata->spdif.mclk = freq;
275                 break;
276 
277         case STI_SAS_DAI_ANALOG_OUT:
278                 drvdata->dac.mclk = freq;
279                 break;
280         }
281 
282         return 0;
283 }
284 
285 static int sti_sas_prepare(struct snd_pcm_substream *substream,
286                            struct snd_soc_dai *dai)
287 {
288         struct snd_soc_component *component = dai->component;
289         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
290         struct snd_pcm_runtime *runtime = substream->runtime;
291 
292         switch (dai->id) {
293         case STI_SAS_DAI_SPDIF_OUT:
294                 if ((drvdata->spdif.mclk / runtime->rate) != 128) {
295                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
296                         return -EINVAL;
297                 }
298                 break;
299         case STI_SAS_DAI_ANALOG_OUT:
300                 if ((drvdata->dac.mclk / runtime->rate) != 256) {
301                         dev_err(component->dev, "unexpected mclk-fs ratio\n");
302                         return -EINVAL;
303                 }
304                 break;
305         }
306 
307         return 0;
308 }
309 
310 static const struct snd_soc_dai_ops stih407_dac_ops = {
311         .set_fmt = sti_sas_dac_set_fmt,
312         .mute_stream = stih407_sas_dac_mute,
313         .prepare = sti_sas_prepare,
314         .set_sysclk = sti_sas_set_sysclk,
315 };
316 
317 static const struct regmap_config stih407_sas_regmap = {
318         .reg_bits = 32,
319         .val_bits = 32,
320         .fast_io = true,
321         .max_register = STIH407_AUDIO_DAC_CTRL,
322         .reg_defaults = stih407_sas_reg_defaults,
323         .num_reg_defaults = ARRAY_SIZE(stih407_sas_reg_defaults),
324         .volatile_reg = sti_sas_volatile_register,
325         .cache_type = REGCACHE_RBTREE,
326         .reg_read = sti_sas_read_reg,
327         .reg_write = sti_sas_write_reg,
328 };
329 
330 static const struct sti_sas_dev_data stih407_data = {
331         .regmap = &stih407_sas_regmap,
332         .dac_ops = &stih407_dac_ops,
333         .dapm_widgets = stih407_sas_dapm_widgets,
334         .num_dapm_widgets = ARRAY_SIZE(stih407_sas_dapm_widgets),
335         .dapm_routes =  stih407_sas_route,
336         .num_dapm_routes = ARRAY_SIZE(stih407_sas_route),
337 };
338 
339 static struct snd_soc_dai_driver sti_sas_dai[] = {
340         {
341                 .name = "sas-dai-spdif-out",
342                 .id = STI_SAS_DAI_SPDIF_OUT,
343                 .playback = {
344                         .stream_name = "spdif_p",
345                         .channels_min = 2,
346                         .channels_max = 2,
347                         .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
348                                  SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_64000 |
349                                  SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 |
350                                  SNDRV_PCM_RATE_192000,
351                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
352                                    SNDRV_PCM_FMTBIT_S32_LE,
353                 },
354                 .ops = (struct snd_soc_dai_ops[]) {
355                         {
356                                 .set_fmt = sti_sas_spdif_set_fmt,
357                                 .trigger = sti_sas_spdif_trigger,
358                                 .set_sysclk = sti_sas_set_sysclk,
359                                 .prepare = sti_sas_prepare,
360                         }
361                 },
362         },
363         {
364                 .name = "sas-dai-dac",
365                 .id = STI_SAS_DAI_ANALOG_OUT,
366                 .playback = {
367                         .stream_name = "dac_p",
368                         .channels_min = 2,
369                         .channels_max = 2,
370                         .rates = SNDRV_PCM_RATE_8000_48000,
371                         .formats = SNDRV_PCM_FMTBIT_S16_LE |
372                                    SNDRV_PCM_FMTBIT_S32_LE,
373                 },
374         },
375 };
376 
377 #ifdef CONFIG_PM_SLEEP
378 static int sti_sas_resume(struct snd_soc_component *component)
379 {
380         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
381 
382         return sti_sas_init_sas_registers(component, drvdata);
383 }
384 #else
385 #define sti_sas_resume NULL
386 #endif
387 
388 static int sti_sas_component_probe(struct snd_soc_component *component)
389 {
390         struct sti_sas_data *drvdata = dev_get_drvdata(component->dev);
391         int ret;
392 
393         ret = sti_sas_init_sas_registers(component, drvdata);
394 
395         return ret;
396 }
397 
398 static struct snd_soc_component_driver sti_sas_driver = {
399         .probe                  = sti_sas_component_probe,
400         .resume                 = sti_sas_resume,
401         .idle_bias_on           = 1,
402         .use_pmdown_time        = 1,
403         .endianness             = 1,
404         .non_legacy_dai_naming  = 1,
405 };
406 
407 static const struct of_device_id sti_sas_dev_match[] = {
408         {
409                 .compatible = "st,stih407-sas-codec",
410                 .data = &stih407_data,
411         },
412         {},
413 };
414 
415 static int sti_sas_driver_probe(struct platform_device *pdev)
416 {
417         struct device_node *pnode = pdev->dev.of_node;
418         struct sti_sas_data *drvdata;
419         const struct of_device_id *of_id;
420 
421         /* Allocate device structure */
422         drvdata = devm_kzalloc(&pdev->dev, sizeof(struct sti_sas_data),
423                                GFP_KERNEL);
424         if (!drvdata)
425                 return -ENOMEM;
426 
427         /* Populate data structure depending on compatibility */
428         of_id = of_match_node(sti_sas_dev_match, pnode);
429         if (!of_id->data) {
430                 dev_err(&pdev->dev, "data associated to device is missing\n");
431                 return -EINVAL;
432         }
433 
434         drvdata->dev_data = (struct sti_sas_dev_data *)of_id->data;
435 
436         /* Initialise device structure */
437         drvdata->dev = &pdev->dev;
438 
439         /* Request the DAC & SPDIF registers memory region */
440         drvdata->dac.virt_regmap = devm_regmap_init(&pdev->dev, NULL, drvdata,
441                                                     drvdata->dev_data->regmap);
442         if (IS_ERR(drvdata->dac.virt_regmap)) {
443                 dev_err(&pdev->dev, "audio registers not enabled\n");
444                 return PTR_ERR(drvdata->dac.virt_regmap);
445         }
446 
447         /* Request the syscon region */
448         drvdata->dac.regmap =
449                 syscon_regmap_lookup_by_phandle(pnode, "st,syscfg");
450         if (IS_ERR(drvdata->dac.regmap)) {
451                 dev_err(&pdev->dev, "syscon registers not available\n");
452                 return PTR_ERR(drvdata->dac.regmap);
453         }
454         drvdata->spdif.regmap = drvdata->dac.regmap;
455 
456         sti_sas_dai[STI_SAS_DAI_ANALOG_OUT].ops = drvdata->dev_data->dac_ops;
457 
458         /* Set dapms*/
459         sti_sas_driver.dapm_widgets = drvdata->dev_data->dapm_widgets;
460         sti_sas_driver.num_dapm_widgets = drvdata->dev_data->num_dapm_widgets;
461 
462         sti_sas_driver.dapm_routes = drvdata->dev_data->dapm_routes;
463         sti_sas_driver.num_dapm_routes = drvdata->dev_data->num_dapm_routes;
464 
465         /* Store context */
466         dev_set_drvdata(&pdev->dev, drvdata);
467 
468         return devm_snd_soc_register_component(&pdev->dev, &sti_sas_driver,
469                                         sti_sas_dai,
470                                         ARRAY_SIZE(sti_sas_dai));
471 }
472 
473 static struct platform_driver sti_sas_platform_driver = {
474         .driver = {
475                 .name = "sti-sas-codec",
476                 .of_match_table = sti_sas_dev_match,
477         },
478         .probe = sti_sas_driver_probe,
479 };
480 
481 module_platform_driver(sti_sas_platform_driver);
482 
483 MODULE_DESCRIPTION("audio codec for STMicroelectronics sti platforms");
484 MODULE_AUTHOR("Arnaud.pouliquen@st.com");
485 MODULE_LICENSE("GPL v2");
486 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp