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

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

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