1// SPDX-License-Identifier: GPL-2.0
2//
3// Copyright (c) 2020 BayLibre, SAS.
4// Author: Jerome Brunet <jbrunet@baylibre.com>
5
6#include <linux/module.h>
7#include <linux/of_platform.h>
8#include <sound/soc.h>
9
10#include "meson-card.h"
11
12int meson_card_i2s_set_sysclk(struct snd_pcm_substream *substream,
13			      struct snd_pcm_hw_params *params,
14			      unsigned int mclk_fs)
15{
16	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
17	struct snd_soc_dai *codec_dai;
18	unsigned int mclk;
19	int ret, i;
20
21	if (!mclk_fs)
22		return 0;
23
24	mclk = params_rate(params) * mclk_fs;
25
26	for_each_rtd_codec_dais(rtd, i, codec_dai) {
27		ret = snd_soc_dai_set_sysclk(codec_dai, 0, mclk,
28					     SND_SOC_CLOCK_IN);
29		if (ret && ret != -ENOTSUPP)
30			return ret;
31	}
32
33	ret = snd_soc_dai_set_sysclk(snd_soc_rtd_to_cpu(rtd, 0), 0, mclk,
34				     SND_SOC_CLOCK_OUT);
35	if (ret && ret != -ENOTSUPP)
36		return ret;
37
38	return 0;
39}
40EXPORT_SYMBOL_GPL(meson_card_i2s_set_sysclk);
41
42int meson_card_reallocate_links(struct snd_soc_card *card,
43				unsigned int num_links)
44{
45	struct meson_card *priv = snd_soc_card_get_drvdata(card);
46	struct snd_soc_dai_link *links;
47	void **ldata;
48
49	links = krealloc(priv->card.dai_link,
50			 num_links * sizeof(*priv->card.dai_link),
51			 GFP_KERNEL | __GFP_ZERO);
52	if (!links)
53		goto err_links;
54
55	ldata = krealloc(priv->link_data,
56			 num_links * sizeof(*priv->link_data),
57			 GFP_KERNEL | __GFP_ZERO);
58	if (!ldata)
59		goto err_ldata;
60
61	priv->card.dai_link = links;
62	priv->link_data = ldata;
63	priv->card.num_links = num_links;
64	return 0;
65
66err_ldata:
67	kfree(links);
68err_links:
69	dev_err(priv->card.dev, "failed to allocate links\n");
70	return -ENOMEM;
71
72}
73EXPORT_SYMBOL_GPL(meson_card_reallocate_links);
74
75int meson_card_parse_dai(struct snd_soc_card *card,
76			 struct device_node *node,
77			 struct snd_soc_dai_link_component *dlc)
78{
79	int ret;
80
81	if (!dlc || !node)
82		return -EINVAL;
83
84	ret = snd_soc_of_get_dlc(node, NULL, dlc, 0);
85	if (ret)
86		return dev_err_probe(card->dev, ret, "can't parse dai\n");
87
88	return ret;
89}
90EXPORT_SYMBOL_GPL(meson_card_parse_dai);
91
92static int meson_card_set_link_name(struct snd_soc_card *card,
93				    struct snd_soc_dai_link *link,
94				    struct device_node *node,
95				    const char *prefix)
96{
97	char *name = devm_kasprintf(card->dev, GFP_KERNEL, "%s.%s",
98				    prefix, node->full_name);
99	if (!name)
100		return -ENOMEM;
101
102	link->name = name;
103	link->stream_name = name;
104
105	return 0;
106}
107
108unsigned int meson_card_parse_daifmt(struct device_node *node,
109				     struct device_node *cpu_node)
110{
111	struct device_node *bitclkmaster = NULL;
112	struct device_node *framemaster = NULL;
113	unsigned int daifmt;
114
115	daifmt = snd_soc_daifmt_parse_format(node, NULL);
116
117	snd_soc_daifmt_parse_clock_provider_as_phandle(node, NULL, &bitclkmaster, &framemaster);
118
119	/* If no master is provided, default to cpu master */
120	if (!bitclkmaster || bitclkmaster == cpu_node) {
121		daifmt |= (!framemaster || framemaster == cpu_node) ?
122			SND_SOC_DAIFMT_CBS_CFS : SND_SOC_DAIFMT_CBS_CFM;
123	} else {
124		daifmt |= (!framemaster || framemaster == cpu_node) ?
125			SND_SOC_DAIFMT_CBM_CFS : SND_SOC_DAIFMT_CBM_CFM;
126	}
127
128	of_node_put(bitclkmaster);
129	of_node_put(framemaster);
130
131	return daifmt;
132}
133EXPORT_SYMBOL_GPL(meson_card_parse_daifmt);
134
135int meson_card_set_be_link(struct snd_soc_card *card,
136			   struct snd_soc_dai_link *link,
137			   struct device_node *node)
138{
139	struct snd_soc_dai_link_component *codec;
140	struct device_node *np;
141	int ret, num_codecs;
142
143	num_codecs = of_get_child_count(node);
144	if (!num_codecs) {
145		dev_err(card->dev, "be link %s has no codec\n",
146			node->full_name);
147		return -EINVAL;
148	}
149
150	codec = devm_kcalloc(card->dev, num_codecs, sizeof(*codec), GFP_KERNEL);
151	if (!codec)
152		return -ENOMEM;
153
154	link->codecs = codec;
155	link->num_codecs = num_codecs;
156
157	for_each_child_of_node(node, np) {
158		ret = meson_card_parse_dai(card, np, codec);
159		if (ret) {
160			of_node_put(np);
161			return ret;
162		}
163
164		codec++;
165	}
166
167	ret = meson_card_set_link_name(card, link, node, "be");
168	if (ret)
169		dev_err(card->dev, "error setting %pOFn link name\n", np);
170
171	return ret;
172}
173EXPORT_SYMBOL_GPL(meson_card_set_be_link);
174
175int meson_card_set_fe_link(struct snd_soc_card *card,
176			   struct snd_soc_dai_link *link,
177			   struct device_node *node,
178			   bool is_playback)
179{
180	link->codecs = &snd_soc_dummy_dlc;
181	link->num_codecs = 1;
182
183	link->dynamic = 1;
184	link->dpcm_merged_format = 1;
185	link->dpcm_merged_chan = 1;
186	link->dpcm_merged_rate = 1;
187
188	if (is_playback)
189		link->dpcm_playback = 1;
190	else
191		link->dpcm_capture = 1;
192
193	return meson_card_set_link_name(card, link, node, "fe");
194}
195EXPORT_SYMBOL_GPL(meson_card_set_fe_link);
196
197static int meson_card_add_links(struct snd_soc_card *card)
198{
199	struct meson_card *priv = snd_soc_card_get_drvdata(card);
200	struct device_node *node = card->dev->of_node;
201	struct device_node *np;
202	int num, i, ret;
203
204	num = of_get_child_count(node);
205	if (!num) {
206		dev_err(card->dev, "card has no links\n");
207		return -EINVAL;
208	}
209
210	ret = meson_card_reallocate_links(card, num);
211	if (ret)
212		return ret;
213
214	i = 0;
215	for_each_child_of_node(node, np) {
216		ret = priv->match_data->add_link(card, np, &i);
217		if (ret) {
218			of_node_put(np);
219			return ret;
220		}
221
222		i++;
223	}
224
225	return 0;
226}
227
228static int meson_card_parse_of_optional(struct snd_soc_card *card,
229					const char *propname,
230					int (*func)(struct snd_soc_card *c,
231						    const char *p))
232{
233	/* If property is not provided, don't fail ... */
234	if (!of_property_read_bool(card->dev->of_node, propname))
235		return 0;
236
237	/* ... but do fail if it is provided and the parsing fails */
238	return func(card, propname);
239}
240
241static void meson_card_clean_references(struct meson_card *priv)
242{
243	struct snd_soc_card *card = &priv->card;
244	struct snd_soc_dai_link *link;
245	struct snd_soc_dai_link_component *codec;
246	struct snd_soc_aux_dev *aux;
247	int i, j;
248
249	if (card->dai_link) {
250		for_each_card_prelinks(card, i, link) {
251			if (link->cpus)
252				of_node_put(link->cpus->of_node);
253			for_each_link_codecs(link, j, codec)
254				of_node_put(codec->of_node);
255		}
256	}
257
258	if (card->aux_dev) {
259		for_each_card_pre_auxs(card, i, aux)
260			of_node_put(aux->dlc.of_node);
261	}
262
263	kfree(card->dai_link);
264	kfree(priv->link_data);
265}
266
267int meson_card_probe(struct platform_device *pdev)
268{
269	const struct meson_card_match_data *data;
270	struct device *dev = &pdev->dev;
271	struct meson_card *priv;
272	int ret;
273
274	data = of_device_get_match_data(dev);
275	if (!data) {
276		dev_err(dev, "failed to match device\n");
277		return -ENODEV;
278	}
279
280	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
281	if (!priv)
282		return -ENOMEM;
283
284	platform_set_drvdata(pdev, priv);
285	snd_soc_card_set_drvdata(&priv->card, priv);
286
287	priv->card.owner = THIS_MODULE;
288	priv->card.dev = dev;
289	priv->card.driver_name = dev->driver->name;
290	priv->match_data = data;
291
292	ret = snd_soc_of_parse_card_name(&priv->card, "model");
293	if (ret < 0)
294		return ret;
295
296	ret = meson_card_parse_of_optional(&priv->card, "audio-routing",
297					   snd_soc_of_parse_audio_routing);
298	if (ret) {
299		dev_err(dev, "error while parsing routing\n");
300		return ret;
301	}
302
303	ret = meson_card_parse_of_optional(&priv->card, "audio-widgets",
304					   snd_soc_of_parse_audio_simple_widgets);
305	if (ret) {
306		dev_err(dev, "error while parsing widgets\n");
307		return ret;
308	}
309
310	ret = meson_card_add_links(&priv->card);
311	if (ret)
312		goto out_err;
313
314	ret = snd_soc_of_parse_aux_devs(&priv->card, "audio-aux-devs");
315	if (ret)
316		goto out_err;
317
318	ret = devm_snd_soc_register_card(dev, &priv->card);
319	if (ret)
320		goto out_err;
321
322	return 0;
323
324out_err:
325	meson_card_clean_references(priv);
326	return ret;
327}
328EXPORT_SYMBOL_GPL(meson_card_probe);
329
330void meson_card_remove(struct platform_device *pdev)
331{
332	struct meson_card *priv = platform_get_drvdata(pdev);
333
334	meson_card_clean_references(priv);
335}
336EXPORT_SYMBOL_GPL(meson_card_remove);
337
338MODULE_DESCRIPTION("Amlogic Sound Card Utils");
339MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
340MODULE_LICENSE("GPL v2");
341