Version:  2.0.40 2.2.26 2.4.37 3.0 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

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         int ret;
120 
121         /*
122          * get node via "sound-dai = <&phandle port>"
123          * it will be used as xxx_of_node on soc_bind_dai_link()
124          */
125         node = of_parse_phandle(np, "sound-dai", 0);
126         if (!node)
127                 return -ENODEV;
128         *p_node = node;
129 
130         /* get dai->name */
131         ret = snd_soc_of_get_dai_name(np, name);
132         if (ret < 0)
133                 return ret;
134 
135         /* parse TDM slot */
136         ret = snd_soc_of_parse_tdm_slot(np, &dai->slots, &dai->slot_width);
137         if (ret)
138                 return ret;
139 
140         /*
141          * dai->sysclk come from
142          *  "clocks = <&xxx>" (if system has common clock)
143          *  or "system-clock-frequency = <xxx>"
144          *  or device's module clock.
145          */
146         if (of_property_read_bool(np, "clocks")) {
147                 clk = of_clk_get(np, 0);
148                 if (IS_ERR(clk)) {
149                         ret = PTR_ERR(clk);
150                         return ret;
151                 }
152 
153                 dai->sysclk = clk_get_rate(clk);
154         } else if (of_property_read_bool(np, "system-clock-frequency")) {
155                 of_property_read_u32(np,
156                                      "system-clock-frequency",
157                                      &dai->sysclk);
158         } else {
159                 clk = of_clk_get(node, 0);
160                 if (!IS_ERR(clk))
161                         dai->sysclk = clk_get_rate(clk);
162         }
163 
164         return 0;
165 }
166 
167 static int simple_card_dai_link_of(struct device_node *node,
168                                    struct device *dev,
169                                    struct snd_soc_dai_link *dai_link,
170                                    struct simple_dai_props *dai_props,
171                                    bool is_top_level_node)
172 {
173         struct device_node *np = NULL;
174         struct device_node *bitclkmaster = NULL;
175         struct device_node *framemaster = NULL;
176         unsigned int daifmt;
177         char *name;
178         char prop[128];
179         char *prefix = "";
180         int ret;
181 
182         if (is_top_level_node)
183                 prefix = "simple-audio-card,";
184 
185         daifmt = snd_soc_of_parse_daifmt(node, prefix,
186                                          &bitclkmaster, &framemaster);
187         daifmt &= ~SND_SOC_DAIFMT_MASTER_MASK;
188 
189         snprintf(prop, sizeof(prop), "%scpu", prefix);
190         np = of_get_child_by_name(node, prop);
191         if (!np) {
192                 ret = -EINVAL;
193                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
194                 goto dai_link_of_err;
195         }
196 
197         ret = asoc_simple_card_sub_parse_of(np, &dai_props->cpu_dai,
198                                             &dai_link->cpu_of_node,
199                                             &dai_link->cpu_dai_name);
200         if (ret < 0)
201                 goto dai_link_of_err;
202 
203         dai_props->cpu_dai.fmt = daifmt;
204         switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
205         case 0x11:
206                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
207                 break;
208         case 0x10:
209                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
210                 break;
211         case 0x01:
212                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
213                 break;
214         default:
215                 dai_props->cpu_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
216                 break;
217         }
218 
219         of_node_put(np);
220         snprintf(prop, sizeof(prop), "%scodec", prefix);
221         np = of_get_child_by_name(node, prop);
222         if (!np) {
223                 ret = -EINVAL;
224                 dev_err(dev, "%s: Can't find %s DT node\n", __func__, prop);
225                 goto dai_link_of_err;
226         }
227 
228         ret = asoc_simple_card_sub_parse_of(np, &dai_props->codec_dai,
229                                             &dai_link->codec_of_node,
230                                             &dai_link->codec_dai_name);
231         if (ret < 0)
232                 goto dai_link_of_err;
233 
234         if (strlen(prefix) && !bitclkmaster && !framemaster) {
235                 /* No dai-link level and master setting was not found from
236                    sound node level, revert back to legacy DT parsing and
237                    take the settings from codec node. */
238                 dev_dbg(dev, "%s: Revert to legacy daifmt parsing\n",
239                         __func__);
240                 dai_props->cpu_dai.fmt = dai_props->codec_dai.fmt =
241                         snd_soc_of_parse_daifmt(np, NULL, NULL, NULL) |
242                         (daifmt & ~SND_SOC_DAIFMT_CLOCK_MASK);
243         } else {
244                 dai_props->codec_dai.fmt = daifmt;
245                 switch (((np == bitclkmaster) << 4) | (np == framemaster)) {
246                 case 0x11:
247                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFM;
248                         break;
249                 case 0x10:
250                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBM_CFS;
251                         break;
252                 case 0x01:
253                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFM;
254                         break;
255                 default:
256                         dai_props->codec_dai.fmt |= SND_SOC_DAIFMT_CBS_CFS;
257                         break;
258                 }
259         }
260 
261         if (!dai_link->cpu_dai_name || !dai_link->codec_dai_name) {
262                 ret = -EINVAL;
263                 goto dai_link_of_err;
264         }
265 
266         /* simple-card assumes platform == cpu */
267         dai_link->platform_of_node = dai_link->cpu_of_node;
268 
269         /* Link name is created from CPU/CODEC dai name */
270         name = devm_kzalloc(dev,
271                             strlen(dai_link->cpu_dai_name)   +
272                             strlen(dai_link->codec_dai_name) + 2,
273                             GFP_KERNEL);
274         sprintf(name, "%s-%s", dai_link->cpu_dai_name,
275                                 dai_link->codec_dai_name);
276         dai_link->name = dai_link->stream_name = name;
277         dai_link->ops = &asoc_simple_card_ops;
278 
279         dev_dbg(dev, "\tname : %s\n", dai_link->stream_name);
280         dev_dbg(dev, "\tcpu : %s / %04x / %d\n",
281                 dai_link->cpu_dai_name,
282                 dai_props->cpu_dai.fmt,
283                 dai_props->cpu_dai.sysclk);
284         dev_dbg(dev, "\tcodec : %s / %04x / %d\n",
285                 dai_link->codec_dai_name,
286                 dai_props->codec_dai.fmt,
287                 dai_props->codec_dai.sysclk);
288 
289 dai_link_of_err:
290         if (np)
291                 of_node_put(np);
292         if (bitclkmaster)
293                 of_node_put(bitclkmaster);
294         if (framemaster)
295                 of_node_put(framemaster);
296         return ret;
297 }
298 
299 static int asoc_simple_card_parse_of(struct device_node *node,
300                                      struct simple_card_data *priv,
301                                      struct device *dev,
302                                      int multi)
303 {
304         struct snd_soc_dai_link *dai_link = priv->snd_card.dai_link;
305         struct simple_dai_props *dai_props = priv->dai_props;
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         of_property_read_u32(node, "simple-audio-card,mclk-fs",
329                              &priv->mclk_fs);
330 
331         dev_dbg(dev, "New simple-card: %s\n", priv->snd_card.name ?
332                 priv->snd_card.name : "");
333 
334         if (multi) {
335                 struct device_node *np = NULL;
336                 int i;
337                 for (i = 0; (np = of_get_next_child(node, np)); i++) {
338                         dev_dbg(dev, "\tlink %d:\n", i);
339                         ret = simple_card_dai_link_of(np, dev, dai_link + i,
340                                                       dai_props + i, false);
341                         if (ret < 0) {
342                                 of_node_put(np);
343                                 return ret;
344                         }
345                 }
346         } else {
347                 ret = simple_card_dai_link_of(node, dev, dai_link, dai_props,
348                                               true);
349                 if (ret < 0)
350                         return ret;
351         }
352 
353         if (!priv->snd_card.name)
354                 priv->snd_card.name = priv->snd_card.dai_link->name;
355 
356         return 0;
357 }
358 
359 /* update the reference count of the devices nodes at end of probe */
360 static int asoc_simple_card_unref(struct platform_device *pdev)
361 {
362         struct snd_soc_card *card = platform_get_drvdata(pdev);
363         struct snd_soc_dai_link *dai_link;
364         struct device_node *np;
365         int num_links;
366 
367         for (num_links = 0, dai_link = card->dai_link;
368              num_links < card->num_links;
369              num_links++, dai_link++) {
370                 np = (struct device_node *) dai_link->cpu_of_node;
371                 if (np)
372                         of_node_put(np);
373                 np = (struct device_node *) dai_link->codec_of_node;
374                 if (np)
375                         of_node_put(np);
376         }
377         return 0;
378 }
379 
380 static int asoc_simple_card_probe(struct platform_device *pdev)
381 {
382         struct simple_card_data *priv;
383         struct snd_soc_dai_link *dai_link;
384         struct device_node *np = pdev->dev.of_node;
385         struct device *dev = &pdev->dev;
386         int num_links, multi, ret;
387 
388         /* get the number of DAI links */
389         if (np && of_get_child_by_name(np, "simple-audio-card,dai-link")) {
390                 num_links = of_get_child_count(np);
391                 multi = 1;
392         } else {
393                 num_links = 1;
394                 multi = 0;
395         }
396 
397         /* allocate the private data and the DAI link array */
398         priv = devm_kzalloc(dev,
399                         sizeof(*priv) + sizeof(*dai_link) * num_links,
400                         GFP_KERNEL);
401         if (!priv)
402                 return -ENOMEM;
403 
404         /*
405          * init snd_soc_card
406          */
407         priv->snd_card.owner = THIS_MODULE;
408         priv->snd_card.dev = dev;
409         dai_link = priv->dai_link;
410         priv->snd_card.dai_link = dai_link;
411         priv->snd_card.num_links = num_links;
412 
413         /* get room for the other properties */
414         priv->dai_props = devm_kzalloc(dev,
415                         sizeof(*priv->dai_props) * num_links,
416                         GFP_KERNEL);
417         if (!priv->dai_props)
418                 return -ENOMEM;
419 
420         if (np && of_device_is_available(np)) {
421 
422                 ret = asoc_simple_card_parse_of(np, priv, dev, multi);
423                 if (ret < 0) {
424                         if (ret != -EPROBE_DEFER)
425                                 dev_err(dev, "parse error %d\n", ret);
426                         goto err;
427                 }
428 
429                 /*
430                  * soc_bind_dai_link() will check cpu name
431                  * after of_node matching if dai_link has cpu_dai_name.
432                  * but, it will never match if name was created by fmt_single_name()
433                  * remove cpu_dai_name to escape name matching.
434                  * see
435                  *      fmt_single_name()
436                  *      fmt_multiple_name()
437                  */
438                 if (num_links == 1)
439                         dai_link->cpu_dai_name = NULL;
440 
441         } else {
442                 struct asoc_simple_card_info *cinfo;
443 
444                 cinfo = dev->platform_data;
445                 if (!cinfo) {
446                         dev_err(dev, "no info for asoc-simple-card\n");
447                         return -EINVAL;
448                 }
449 
450                 if (!cinfo->name ||
451                     !cinfo->codec_dai.name ||
452                     !cinfo->codec ||
453                     !cinfo->platform ||
454                     !cinfo->cpu_dai.name) {
455                         dev_err(dev, "insufficient asoc_simple_card_info settings\n");
456                         return -EINVAL;
457                 }
458 
459                 priv->snd_card.name     = (cinfo->card) ? cinfo->card : cinfo->name;
460                 dai_link->name          = cinfo->name;
461                 dai_link->stream_name   = cinfo->name;
462                 dai_link->platform_name = cinfo->platform;
463                 dai_link->codec_name    = cinfo->codec;
464                 dai_link->cpu_dai_name  = cinfo->cpu_dai.name;
465                 dai_link->codec_dai_name = cinfo->codec_dai.name;
466                 memcpy(&priv->dai_props->cpu_dai, &cinfo->cpu_dai,
467                                         sizeof(priv->dai_props->cpu_dai));
468                 memcpy(&priv->dai_props->codec_dai, &cinfo->codec_dai,
469                                         sizeof(priv->dai_props->codec_dai));
470 
471                 priv->dai_props->cpu_dai.fmt    |= cinfo->daifmt;
472                 priv->dai_props->codec_dai.fmt  |= cinfo->daifmt;
473         }
474 
475         /*
476          * init snd_soc_dai_link
477          */
478         dai_link->init = asoc_simple_card_dai_init;
479 
480         snd_soc_card_set_drvdata(&priv->snd_card, priv);
481 
482         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
483 
484 err:
485         asoc_simple_card_unref(pdev);
486         return ret;
487 }
488 
489 static const struct of_device_id asoc_simple_of_match[] = {
490         { .compatible = "simple-audio-card", },
491         {},
492 };
493 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
494 
495 static struct platform_driver asoc_simple_card = {
496         .driver = {
497                 .name = "asoc-simple-card",
498                 .owner = THIS_MODULE,
499                 .of_match_table = asoc_simple_of_match,
500         },
501         .probe = asoc_simple_card_probe,
502 };
503 
504 module_platform_driver(asoc_simple_card);
505 
506 MODULE_ALIAS("platform:asoc-simple-card");
507 MODULE_LICENSE("GPL");
508 MODULE_DESCRIPTION("ASoC Simple Sound Card");
509 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
510 

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