bb86ee0424902d3f18bc0ad94bd33d20242416c0
[muen/linux.git] / sound / soc / generic / simple-scu-card.c
1 /*
2  * ASoC simple SCU sound card support
3  *
4  * Copyright (C) 2015 Renesas Solutions Corp.
5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6  *
7  * based on ${LINUX}/sound/soc/generic/simple-card.c
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13 #include <linux/clk.h>
14 #include <linux/device.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/of_device.h>
18 #include <linux/platform_device.h>
19 #include <linux/string.h>
20 #include <sound/jack.h>
21 #include <sound/soc.h>
22 #include <sound/soc-dai.h>
23 #include <sound/simple_card_utils.h>
24
25 struct simple_card_data {
26         struct snd_soc_card snd_card;
27         struct snd_soc_codec_conf codec_conf;
28         struct asoc_simple_dai *dai_props;
29         struct snd_soc_dai_link *dai_link;
30         u32 convert_rate;
31         u32 convert_channels;
32 };
33
34 #define simple_priv_to_dev(priv) ((priv)->snd_card.dev)
35 #define simple_priv_to_link(priv, i) ((priv)->snd_card.dai_link + (i))
36 #define simple_priv_to_props(priv, i) ((priv)->dai_props + (i))
37
38 #define DAI     "sound-dai"
39 #define CELL    "#sound-dai-cells"
40 #define PREFIX  "simple-audio-card,"
41
42 static int asoc_simple_card_startup(struct snd_pcm_substream *substream)
43 {
44         struct snd_soc_pcm_runtime *rtd = substream->private_data;
45         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
46         struct asoc_simple_dai *dai_props =
47                 simple_priv_to_props(priv, rtd->num);
48
49         return clk_prepare_enable(dai_props->clk);
50 }
51
52 static void asoc_simple_card_shutdown(struct snd_pcm_substream *substream)
53 {
54         struct snd_soc_pcm_runtime *rtd = substream->private_data;
55         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
56         struct asoc_simple_dai *dai_props =
57                 simple_priv_to_props(priv, rtd->num);
58
59         clk_disable_unprepare(dai_props->clk);
60 }
61
62 static const struct snd_soc_ops asoc_simple_card_ops = {
63         .startup = asoc_simple_card_startup,
64         .shutdown = asoc_simple_card_shutdown,
65 };
66
67 static int asoc_simple_card_dai_init(struct snd_soc_pcm_runtime *rtd)
68 {
69         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
70         struct snd_soc_dai *dai;
71         struct snd_soc_dai_link *dai_link;
72         struct asoc_simple_dai *dai_props;
73         int num = rtd->num;
74
75         dai_link        = simple_priv_to_link(priv, num);
76         dai_props       = simple_priv_to_props(priv, num);
77         dai             = dai_link->dynamic ?
78                                 rtd->cpu_dai :
79                                 rtd->codec_dai;
80
81         return asoc_simple_card_init_dai(dai, dai_props);
82 }
83
84 static int asoc_simple_card_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
85                                         struct snd_pcm_hw_params *params)
86 {
87         struct simple_card_data *priv = snd_soc_card_get_drvdata(rtd->card);
88         struct snd_interval *rate = hw_param_interval(params,
89                                                       SNDRV_PCM_HW_PARAM_RATE);
90         struct snd_interval *channels = hw_param_interval(params,
91                                                 SNDRV_PCM_HW_PARAM_CHANNELS);
92
93         if (priv->convert_rate)
94                 rate->min =
95                 rate->max = priv->convert_rate;
96
97         if (priv->convert_channels)
98                 channels->min =
99                 channels->max = priv->convert_channels;
100
101         return 0;
102 }
103
104 static int asoc_simple_card_dai_link_of(struct device_node *np,
105                                         struct simple_card_data *priv,
106                                         unsigned int daifmt,
107                                         int idx, bool is_fe)
108 {
109         struct device *dev = simple_priv_to_dev(priv);
110         struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, idx);
111         struct asoc_simple_dai *dai_props = simple_priv_to_props(priv, idx);
112         int ret;
113
114         if (is_fe) {
115                 int is_single_links = 0;
116
117                 /* BE is dummy */
118                 dai_link->codec_of_node         = NULL;
119                 dai_link->codec_dai_name        = "snd-soc-dummy-dai";
120                 dai_link->codec_name            = "snd-soc-dummy";
121
122                 /* FE settings */
123                 dai_link->dynamic               = 1;
124                 dai_link->dpcm_merged_format    = 1;
125
126                 ret = asoc_simple_card_parse_cpu(np, dai_link, DAI, CELL,
127                                                  &is_single_links);
128                 if (ret)
129                         return ret;
130
131                 ret = asoc_simple_card_parse_clk_cpu(np, dai_link, dai_props);
132                 if (ret < 0)
133                         return ret;
134
135                 ret = asoc_simple_card_set_dailink_name(dev, dai_link,
136                                                         "fe.%s",
137                                                         dai_link->cpu_dai_name);
138                 if (ret < 0)
139                         return ret;
140
141                 asoc_simple_card_canonicalize_cpu(dai_link, is_single_links);
142         } else {
143                 /* FE is dummy */
144                 dai_link->cpu_of_node           = NULL;
145                 dai_link->cpu_dai_name          = "snd-soc-dummy-dai";
146                 dai_link->cpu_name              = "snd-soc-dummy";
147
148                 /* BE settings */
149                 dai_link->no_pcm                = 1;
150                 dai_link->be_hw_params_fixup    = asoc_simple_card_be_hw_params_fixup;
151
152                 ret = asoc_simple_card_parse_codec(np, dai_link, DAI, CELL);
153                 if (ret < 0)
154                         return ret;
155
156                 ret = asoc_simple_card_parse_clk_codec(np, dai_link, dai_props);
157                 if (ret < 0)
158                         return ret;
159
160                 ret = asoc_simple_card_set_dailink_name(dev, dai_link,
161                                                         "be.%s",
162                                                         dai_link->codec_dai_name);
163                 if (ret < 0)
164                         return ret;
165
166                 snd_soc_of_parse_audio_prefix(&priv->snd_card,
167                                               &priv->codec_conf,
168                                               dai_link->codec_of_node,
169                                               PREFIX "prefix");
170         }
171
172         ret = snd_soc_of_parse_tdm_slot(np,
173                                         &dai_props->tx_slot_mask,
174                                         &dai_props->rx_slot_mask,
175                                         &dai_props->slots,
176                                         &dai_props->slot_width);
177         if (ret)
178                 return ret;
179
180         ret = asoc_simple_card_canonicalize_dailink(dai_link);
181         if (ret < 0)
182                 return ret;
183
184         dai_link->dai_fmt               = daifmt;
185         dai_link->dpcm_playback         = 1;
186         dai_link->dpcm_capture          = 1;
187         dai_link->ops                   = &asoc_simple_card_ops;
188         dai_link->init                  = asoc_simple_card_dai_init;
189
190         dev_dbg(dev, "\t%s / %04x / %d\n",
191                 dai_link->name,
192                 dai_link->dai_fmt,
193                 dai_props->sysclk);
194
195         return 0;
196 }
197
198 static int asoc_simple_card_parse_of(struct device_node *node,
199                                      struct simple_card_data *priv)
200
201 {
202         struct device *dev = simple_priv_to_dev(priv);
203         struct device_node *np;
204         unsigned int daifmt = 0;
205         bool is_fe;
206         int ret, i;
207
208         if (!node)
209                 return -EINVAL;
210
211         ret = snd_soc_of_parse_audio_routing(&priv->snd_card, PREFIX "routing");
212         if (ret < 0)
213                 return ret;
214
215         /* sampling rate convert */
216         of_property_read_u32(node, PREFIX "convert-rate", &priv->convert_rate);
217
218         /* channels transfer */
219         of_property_read_u32(node, PREFIX "convert-channels", &priv->convert_channels);
220
221         /* find 1st codec */
222         np = of_get_child_by_name(node, PREFIX "codec");
223         if (!np)
224                 return -ENODEV;
225
226         ret = asoc_simple_card_parse_daifmt(dev, node, np, PREFIX, &daifmt);
227         if (ret < 0)
228                 return ret;
229
230         i = 0;
231         for_each_child_of_node(node, np) {
232                 is_fe = false;
233                 if (strcmp(np->name, PREFIX "cpu") == 0)
234                         is_fe = true;
235
236                 ret = asoc_simple_card_dai_link_of(np, priv, daifmt, i, is_fe);
237                 if (ret < 0)
238                         return ret;
239                 i++;
240         }
241
242         ret = asoc_simple_card_parse_card_name(&priv->snd_card, PREFIX);
243         if (ret < 0)
244                 return ret;
245
246         dev_dbg(dev, "New card: %s\n",
247                 priv->snd_card.name ? priv->snd_card.name : "");
248         dev_dbg(dev, "convert_rate     %d\n", priv->convert_rate);
249         dev_dbg(dev, "convert_channels %d\n", priv->convert_channels);
250
251         return 0;
252 }
253
254 static int asoc_simple_card_probe(struct platform_device *pdev)
255 {
256         struct simple_card_data *priv;
257         struct snd_soc_dai_link *dai_link;
258         struct asoc_simple_dai *dai_props;
259         struct device *dev = &pdev->dev;
260         struct device_node *np = pdev->dev.of_node;
261         int num, ret;
262
263         /* Allocate the private data */
264         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
265         if (!priv)
266                 return -ENOMEM;
267
268         num = of_get_child_count(np);
269
270         dai_props = devm_kzalloc(dev, sizeof(*dai_props) * num, GFP_KERNEL);
271         dai_link  = devm_kzalloc(dev, sizeof(*dai_link)  * num, GFP_KERNEL);
272         if (!dai_props || !dai_link)
273                 return -ENOMEM;
274
275         priv->dai_props                         = dai_props;
276         priv->dai_link                          = dai_link;
277
278         /* Init snd_soc_card */
279         priv->snd_card.owner                    = THIS_MODULE;
280         priv->snd_card.dev                      = dev;
281         priv->snd_card.dai_link                 = priv->dai_link;
282         priv->snd_card.num_links                = num;
283         priv->snd_card.codec_conf               = &priv->codec_conf;
284         priv->snd_card.num_configs              = 1;
285
286         ret = asoc_simple_card_parse_of(np, priv);
287         if (ret < 0) {
288                 if (ret != -EPROBE_DEFER)
289                         dev_err(dev, "parse error %d\n", ret);
290                 goto err;
291         }
292
293         snd_soc_card_set_drvdata(&priv->snd_card, priv);
294
295         ret = devm_snd_soc_register_card(&pdev->dev, &priv->snd_card);
296         if (ret >= 0)
297                 return ret;
298 err:
299         asoc_simple_card_clean_reference(&priv->snd_card);
300
301         return ret;
302 }
303
304 static int asoc_simple_card_remove(struct platform_device *pdev)
305 {
306         struct snd_soc_card *card = platform_get_drvdata(pdev);
307
308         return asoc_simple_card_clean_reference(card);
309 }
310
311 static const struct of_device_id asoc_simple_of_match[] = {
312         { .compatible = "renesas,rsrc-card", },
313         { .compatible = "simple-scu-audio-card", },
314         {},
315 };
316 MODULE_DEVICE_TABLE(of, asoc_simple_of_match);
317
318 static struct platform_driver asoc_simple_card = {
319         .driver = {
320                 .name = "simple-scu-audio-card",
321                 .of_match_table = asoc_simple_of_match,
322         },
323         .probe = asoc_simple_card_probe,
324         .remove = asoc_simple_card_remove,
325 };
326
327 module_platform_driver(asoc_simple_card);
328
329 MODULE_ALIAS("platform:asoc-simple-scu-card");
330 MODULE_LICENSE("GPL v2");
331 MODULE_DESCRIPTION("ASoC Simple SCU Sound Card");
332 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");