Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

Linux/sound/soc/generic/simple-card.c

  1 /*
  2  * ASoC simple sound card support
  3  *
  4  * Copyright (C) 2012 Renesas Solutions Corp.
  5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 #include <linux/clk.h>
 12 #include <linux/device.h>
 13 #include <linux/module.h>
 14 #include <linux/of.h>
 15 #include <linux/platform_device.h>
 16 #include <linux/string.h>
 17 #include <sound/simple_card.h>
 18 #include <sound/soc-dai.h>
 19 #include <sound/soc.h>
 20 
 21 struct simple_card_data {
 22         struct snd_soc_card snd_card;
 23         struct simple_dai_props {
 24                 struct asoc_simple_dai cpu_dai;
 25                 struct asoc_simple_dai codec_dai;
 26         } *dai_props;
 27         unsigned int mclk_fs;
 28         struct snd_soc_dai_link dai_link[];     /* dynamically allocated */
 29 };
 30 
 31 static int asoc_simple_card_hw_params(struct snd_pcm_substream *substream,
 32                                       struct snd_pcm_hw_params *params)
 33 {
 34         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 35         struct snd_soc_dai *codec_dai = rtd->codec_dai;
 36         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
 37         unsigned int mclk;
 38         int ret = 0;
 39 
 40         if (priv->mclk_fs) {
 41                 mclk = params_rate(params) * priv->mclk_fs;
 42                 ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
 43                                              SND_SOC_CLOCK_IN);
 44         }
 45 
 46         return ret;
 47 }
 48 
 49 static struct snd_soc_ops asoc_simple_card_ops = {
 50         .hw_params = asoc_simple_card_hw_params,
 51 };
 52 
 53 static int __asoc_simple_card_dai_init(struct snd_soc_dai *dai,
 54                                        struct asoc_simple_dai *set)
 55 {
 56         int ret;
 57 
 58         if (set->fmt) {
 59                 ret = snd_soc_dai_set_fmt(dai, set->fmt);
 60                 if (ret && ret != -ENOTSUPP) {
 61                         dev_err(dai->dev, "simple-card: set_fmt error\n");
 62                         goto err;
 63                 }
 64         }
 65 
 66         if (set->sysclk) {
 67                 ret = snd_soc_dai_set_sysclk(dai, 0, set->sysclk, 0);
 68                 if (ret && ret != -ENOTSUPP) {
 69                         dev_err(dai->dev, "simple-card: set_sysclk error\n");
 70                         goto err;
 71                 }
 72         }
 73 
 74         if (set->slots) {
 75                 ret = snd_soc_dai_set_tdm_slot(dai, 0, 0,
 76                                                 set->slots,
 77                                                 set->slot_width);
 78                 if (ret && ret != -ENOTSUPP) {
 79                         dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
 80                         goto err;
 81                 }
 82         }
 83 
 84         ret = 0;
 85 
 86 err:
 87         return ret;
 88 }
 89 
 90 static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd)
 91 {
 92         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
 93         struct snd_soc_dai *codec = rtd->codec_dai;
 94         struct snd_soc_dai *cpu = rtd->cpu_dai;
 95         struct simple_dai_props *dai_props;
 96         int num, ret;
 97 
 98         num = rtd - rtd->card->rtd;
 99         dai_props = &priv->dai_props[num];
100         ret = __asoc_simple_card_dai_init(codec, &dai_props->codec_dai);
101         if (ret < 0)
102                 return ret;
103 
104         ret = __asoc_simple_card_dai_init(cpu, &dai_props->cpu_dai);
105         if (ret < 0)
106                 return ret;
107 
108         return 0;
109 }
110 
111 static int
112 asoc_simple_card_sub_parse_of(struct device_node *np,
113                               struct asoc_simple_dai *dai,
114                               const struct device_node **p_node,
115                               const char **name)
116 {
117         struct device_node *node;
118         struct clk *clk;
119         u32 val;
120         int ret;
121 
122         /*
123          * get node via "sound-dai = <&phandle port>"
124          * it will be used as xxx_of_node on soc_bind_dai_link()
125          */
126         node = of_parse_phandle(np, "sound-dai", 0);
127         if (!node)
128                 return -ENODEV;
129         *p_node = node;
130 
131         /* get dai->name */
132         ret = snd_soc_of_get_dai_name(np, name);
133         if (ret < 0)
134                 return ret;
135 
136         /* parse TDM slot */
137         ret = snd_soc_of_parse_tdm_slot(np, &dai->slots, &dai->slot_width);
138         if (ret)
139                 return ret;
140 
141         /*
142          * dai->sysclk come from
143          *  "clocks = <&xxx>" (if system has common clock)
144          *  or "system-clock-frequency = <xxx>"
145          *  or device's module clock.
146          */
147         if (of_property_read_bool(np, "clocks")) {
148                 clk = of_clk_get(np, 0);
149                 if (IS_ERR(clk)) {
150                         ret = PTR_ERR(clk);
151                         return ret;
152                 }
153 
154                 dai->sysclk = clk_get_rate(clk);
155         } else if (!of_property_read_u32(np, "system-clock-frequency", &val)) {
156                 dai->sysclk = val;
157         } else {
158                 clk = of_clk_get(node, 0);
159                 if (!IS_ERR(clk))
160                         dai->sysclk = clk_get_rate(clk);
161         }
162 
163         return 0;
164 }
165 
166 static int simple_card_dai_link_of(struct device_node *node,
167                                    struct device *dev,
168                                    struct snd_soc_dai_link *dai_link,
169                                    struct simple_dai_props *dai_props,
170                                    bool is_top_level_node)
171 {
172         struct device_node *np = NULL;
173         struct device_node *bitclkmaster = NULL;
174         struct device_node *framemaster = NULL;
175         unsigned int daifmt;
176         char *name;
177         char prop[128];
178         char *prefix = "";
179         int ret;
180 
181         if (is_top_level_node)
182                 prefix = "simple-audio-card,";
183 
184         daifmt = snd_soc_of_parse_daifmt(node, prefix,
185                                          &bitclkmaster, &framemaster);
186         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
187 
188         snprintf(prop, sizeof(prop), "%scpu", prefix);
189         np = of_get_child_by_name(node, prop);
190         if (!np) {
191                 ret = -EINVAL;
192                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
193                 goto dai_link_of_err;
194         }
195 
196         ret = asoc_simple_card_sub_parse_of(np, &dai_props->cpu_dai,
197                                             &dai_link->cpu_of_node,
198                                             &dai_link->cpu_dai_name);
199         if (ret < 0)
200                 goto dai_link_of_err;
201 
202         dai_props->cpu_dai.fmt = daifmt;
203         switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
204         case 0x11:
205                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
206                 break;
207         case 0x10:
208                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
209                 break;
210         case 0x01:
211                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
212                 break;
213         default:
214                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
215                 break;
216         }
217 
218         of_node_put(np);
219         snprintf(prop, sizeof(prop), "%scodec", prefix);
220         np = of_get_child_by_name(node, prop);
221         if (!np) {
222                 ret = -EINVAL;
223                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
224                 goto dai_link_of_err;
225         }
226 
227         ret = asoc_simple_card_sub_parse_of(np, &dai_props->codec_dai,
228                                             &dai_link->codec_of_node,
229                                             &dai_link->codec_dai_name);
230         if (ret < 0)
231                 goto dai_link_of_err;
232 
233         if (strlen(prefix) && !bitclkmaster && !framemaster) {
234                 /* No dai-link level and master setting was not found from
235                    sound node level, revert back to legacy DT parsing and
236                    take the settings from codec node. */
237                 dev_dbg(dev, "%s: Revert to legacy daifmt parsing\n",
238                         __func__);
239                 dai_props->cpu_dai.fmt = dai_props->codec_dai.fmt =
240                         snd_soc_of_parse_daifmt(np, NULL, NULL, NULL) |
241                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
242         } else {
243                 dai_props->codec_dai.fmt = daifmt;
244                 switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
245                 case 0x11:
246                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
247                         break;
248                 case 0x10:
249                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
250                         break;
251                 case 0x01:
252                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
253                         break;
254                 default:
255                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
256                         break;
257                 }
258         }
259 
260         if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
261                 ret = -EINVAL;
262                 goto dai_link_of_err;
263         }
264 
265         /* simple-card assumes platform == cpu */
266         dai_link->platform_of_node = dai_link->cpu_of_node;
267 
268         /* Link name is created from CPU/CODEC dai name */
269         name = devm_kzalloc(dev,
270                             strlen(dai_link->cpu_dai_name)   +
271                             strlen(dai_link->codec_dai_name) + 2,
272                             GFP_KERNEL);
273         sprintf(name, "%s-%s", dai_link->cpu_dai_name,
274                                 dai_link->codec_dai_name);
275         dai_link->name = dai_link->stream_name = name;
276         dai_link->ops = &asoc_simple_card_ops;
277 
278         dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
279         dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
280                 dai_link->cpu_dai_name,
281                 dai_props->cpu_dai.fmt,
282                 dai_props->cpu_dai.sysclk);
283         dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
284                 dai_link->codec_dai_name,
285                 dai_props->codec_dai.fmt,
286                 dai_props->codec_dai.sysclk);
287 
288 dai_link_of_err:
289         if (np)
290                 of_node_put(np);
291         if (bitclkmaster)
292                 of_node_put(bitclkmaster);
293         if (framemaster)
294                 of_node_put(framemaster);
295         return ret;
296 }
297 
298 static int asoc_simple_card_parse_of(struct device_node *node,
299                                      struct simple_card_data *priv,
300                                      struct device *dev,
301                                      int multi)
302 {
303         struct snd_soc_dai_link *dai_link = priv->snd_card.dai_link;
304         struct simple_dai_props *dai_props = priv->dai_props;
305         u32 val;
306         int ret;
307 
308         /* parsing the card name from DT */
309         snd_soc_of_parse_card_name(&priv->snd_card, "simple-audio-card,name");
310 
311         /* off-codec widgets */
312         if (of_property_read_bool(node, "simple-audio-card,widgets")) {
313                 ret = snd_soc_of_parse_audio_simple_widgets(&priv->snd_card,
314                                         "simple-audio-card,widgets");
315                 if (ret)
316                         return ret;
317         }
318 
319         /* DAPM routes */
320         if (of_property_read_bool(node, "simple-audio-card,routing")) {
321                 ret = snd_soc_of_parse_audio_routing(&priv->snd_card,
322                                         "simple-audio-card,routing");
323                 if (ret)
324                         return ret;
325         }
326 
327         /* Factor to mclk, used in hw_params() */
328         ret = of_property_read_u32(node, "simple-audio-card,mclk-fs", &val);
329         if (ret == 0)
330                 priv->mclk_fs = val;
331 
332         dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ?
333                 priv->snd_card.name : "");
334 
335         if (multi) {
336                 struct device_node *np = NULL;
337                 int i;
338                 for (i = 0; (np = of_get_next_child(node, np)); i++) {
339                         dev_dbg(dev, "\tlink %d:\n", i);
340                         ret = simple_card_dai_link_of(np, dev, dai_link + i,
341                                                       dai_props + i, false);
342                         if (ret < 0) {
343                                 of_node_put(np);
344                                 return ret;
345                         }
346                 }
347         } else {
348                 ret = simple_card_dai_link_of(node, dev, dai_link, dai_props,
349                                               true);
350                 if (ret < 0)
351                         return ret;
352         }
353 
354         if (!priv->snd_card.name)
355                 priv->snd_card.name = priv->snd_card.dai_link->name;
356 
357         return 0;
358 }
359 
360 /* update the reference count of the devices nodes at end of probe */
361 static int asoc_simple_card_unref(struct platform_device *pdev)
362 {
363         struct snd_soc_card *card = platform_get_drvdata(pdev);
364         struct snd_soc_dai_link *dai_link;
365         struct device_node *np;
366         int num_links;
367 
368         for (num_links = 0, dai_link = card->dai_link;
369              num_links < card->num_links;
370              num_links++, dai_link++) {
371                 np = (struct device_node *) dai_link->cpu_of_node;
372                 if (np)
373                         of_node_put(np);
374                 np = (struct device_node *) dai_link->codec_of_node;
375                 if (np)
376                         of_node_put(np);
377         }
378         return 0;
379 }
380 
381 static int asoc_simple_card_probe(struct platform_device *pdev)
382 {
383         struct simple_card_data *priv;
384         struct snd_soc_dai_link *dai_link;
385         struct device_node *np = pdev->dev.of_node;
386         struct device *dev = &pdev->dev;
387         int num_links, multi, ret;
388 
389         /* get the number of DAI links */
390         if (np && of_get_child_by_name(np, "simple-audio-card,dai-link")) {
391                 num_links = of_get_child_count(np);
392                 multi = 1;
393         } else {
394                 num_links = 1;
395                 multi = 0;
396         }
397 
398         /* allocate the private data and the DAI link array */
399         priv = devm_kzalloc(dev,
400                         sizeof(*priv) + sizeof(*dai_link) * num_links,
401                         GFP_KERNEL);
402         if (!priv)
403                 return -ENOMEM;
404 
405         /*
406          * init snd_soc_card
407          */
408         priv->snd_card.owner = THIS_MODULE;
409         priv->snd_card.dev = dev;
410         dai_link = priv->dai_link;
411         priv->snd_card.dai_link = dai_link;
412         priv->snd_card.num_links = num_links;
413 
414         /* get room for the other properties */
415         priv->dai_props = devm_kzalloc(dev,
416                         sizeof(*priv->dai_props) * num_links,
417                         GFP_KERNEL);
418         if (!priv->dai_props)
419                 return -ENOMEM;
420 
421         if (np && of_device_is_available(np)) {
422 
423                 ret = asoc_simple_card_parse_of(np, priv, dev, multi);
424                 if (ret < 0) {
425                         if (ret != -EPROBE_DEFER)
426                                 dev_err(dev, "parse error %d\n", ret);
427                         goto err;
428                 }
429 
430                 /*
431                  * soc_bind_dai_link() will check cpu name
432                  * after of_node matching if dai_link has cpu_dai_name.
433                  * but, it will never match if name was created by fmt_single_name()
434                  * remove cpu_dai_name to escape name matching.
435                  * see
436                  *      fmt_single_name()
437                  *      fmt_multiple_name()
438                  */
439                 if (num_links == 1)
440                         dai_link->cpu_dai_name = NULL;
441 
442         } else {
443                 struct asoc_simple_card_info *cinfo;
444 
445                 cinfo = dev->platform_data;
446                 if (!cinfo) {
447                         dev_err(dev, "no info for asoc-simple-card\n");
448                         return -EINVAL;
449                 }
450 
451                 if (!cinfo->name ||
452                     !cinfo->codec_dai.name ||
453                     !cinfo->codec ||
454                     !cinfo->platform ||
455                     !cinfo->cpu_dai.name) {
456                         dev_err(dev, "insufficient asoc_simple_card_info settings\n");
457                         return -EINVAL;
458                 }
459 
460                 priv->snd_card.name     = (cinfo->card) ? cinfo->card : cinfo->name;
461                 dai_link->name          = cinfo->name;
462                 dai_link->stream_name   = cinfo->name;
463                 dai_link->platform_name = cinfo->platform;
464                 dai_link->codec_name    = cinfo->codec;
465                 dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
466                 dai_link->codec_dai_name = cinfo->codec_dai.name;
467                 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
468                                         sizeof(priv->dai_props->cpu_dai));
469                 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
470                                         sizeof(priv->dai_props->codec_dai));
471 
472                 priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
473                 priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
474         }
475 
476         /*
477          * init snd_soc_dai_link
478          */
479         dai_link->init = asoc_simple_card_dai_init;
480 
481         snd_soc_card_set_drvdata(&priv->snd_card, priv);
482 
483         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
484         if (ret >= 0)
485                 return ret;
486 
487 err:
488         asoc_simple_card_unref(pdev);
489         return ret;
490 }
491 
492 static int asoc_simple_card_remove(struct platform_device *pdev)
493 {
494         return asoc_simple_card_unref(pdev);
495 }
496 
497 static const struct of_device_id asoc_simple_of_match[] = {
498         { .compatible = "simple-audio-card", },
499         {},
500 };
501 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
502 
503 static struct platform_driver asoc_simple_card = {
504         .driver = {
505                 .name = "asoc-simple-card",
506                 .owner = THIS_MODULE,
507                 .of_match_table = asoc_simple_of_match,
508         },
509         .probe = asoc_simple_card_probe,
510         .remove = asoc_simple_card_remove,
511 };
512 
513 module_platform_driver(asoc_simple_card);
514 
515 MODULE_ALIAS("platform:asoc-simple-card");
516 MODULE_LICENSE("GPL");
517 MODULE_DESCRIPTION("ASoC Simple Sound Card");
518 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
519 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us