1  // SPDX-License-Identifier: GPL-2.0
2  //
3  // simple-card-utils.c
4  //
5  // Copyright (c) 2016 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6  
7  #include <dt-bindings/sound/audio-graph.h>
8  #include <linux/cleanup.h>
9  #include <linux/clk.h>
10  #include <linux/gpio/consumer.h>
11  #include <linux/module.h>
12  #include <linux/of.h>
13  #include <linux/of_graph.h>
14  #include <sound/jack.h>
15  #include <sound/pcm_params.h>
16  #include <sound/simple_card_utils.h>
17  
simple_util_get_sample_fmt(struct simple_util_data * data)18  int simple_util_get_sample_fmt(struct simple_util_data *data)
19  {
20  	int i;
21  	int val = -EINVAL;
22  
23  	struct {
24  		char *fmt;
25  		u32 val;
26  	} of_sample_fmt_table[] = {
27  		{ "s8",		SNDRV_PCM_FORMAT_S8},
28  		{ "s16_le",	SNDRV_PCM_FORMAT_S16_LE},
29  		{ "s24_le",	SNDRV_PCM_FORMAT_S24_LE},
30  		{ "s24_3le",	SNDRV_PCM_FORMAT_S24_3LE},
31  		{ "s32_le",	SNDRV_PCM_FORMAT_S32_LE},
32  	};
33  
34  	for (i = 0; i < ARRAY_SIZE(of_sample_fmt_table); i++) {
35  		if (!strcmp(data->convert_sample_format,
36  			    of_sample_fmt_table[i].fmt)) {
37  			val = of_sample_fmt_table[i].val;
38  			break;
39  		}
40  	}
41  	return val;
42  }
43  EXPORT_SYMBOL_GPL(simple_util_get_sample_fmt);
44  
simple_fixup_sample_fmt(struct simple_util_data * data,struct snd_pcm_hw_params * params)45  static void simple_fixup_sample_fmt(struct simple_util_data *data,
46  				    struct snd_pcm_hw_params *params)
47  {
48  	int val;
49  	struct snd_mask *mask = hw_param_mask(params,
50  					      SNDRV_PCM_HW_PARAM_FORMAT);
51  
52  	val = simple_util_get_sample_fmt(data);
53  	if (val >= 0) {
54  		snd_mask_none(mask);
55  		snd_mask_set(mask, val);
56  	}
57  }
58  
simple_util_parse_convert(struct device_node * np,char * prefix,struct simple_util_data * data)59  void simple_util_parse_convert(struct device_node *np,
60  			       char *prefix,
61  			       struct simple_util_data *data)
62  {
63  	char prop[128];
64  
65  	if (!np)
66  		return;
67  
68  	if (!prefix)
69  		prefix = "";
70  
71  	/* sampling rate convert */
72  	snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-rate");
73  	of_property_read_u32(np, prop, &data->convert_rate);
74  
75  	/* channels transfer */
76  	snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-channels");
77  	of_property_read_u32(np, prop, &data->convert_channels);
78  
79  	/* convert sample format */
80  	snprintf(prop, sizeof(prop), "%s%s", prefix, "convert-sample-format");
81  	of_property_read_string(np, prop, &data->convert_sample_format);
82  }
83  EXPORT_SYMBOL_GPL(simple_util_parse_convert);
84  
85  /**
86   * simple_util_is_convert_required() - Query if HW param conversion was requested
87   * @data: Link data.
88   *
89   * Returns true if any HW param conversion was requested for this DAI link with
90   * any "convert-xxx" properties.
91   */
simple_util_is_convert_required(const struct simple_util_data * data)92  bool simple_util_is_convert_required(const struct simple_util_data *data)
93  {
94  	return data->convert_rate ||
95  	       data->convert_channels ||
96  	       data->convert_sample_format;
97  }
98  EXPORT_SYMBOL_GPL(simple_util_is_convert_required);
99  
simple_util_parse_daifmt(struct device * dev,struct device_node * node,struct device_node * codec,char * prefix,unsigned int * retfmt)100  int simple_util_parse_daifmt(struct device *dev,
101  			     struct device_node *node,
102  			     struct device_node *codec,
103  			     char *prefix,
104  			     unsigned int *retfmt)
105  {
106  	struct device_node *bitclkmaster = NULL;
107  	struct device_node *framemaster = NULL;
108  	unsigned int daifmt;
109  
110  	daifmt = snd_soc_daifmt_parse_format(node, prefix);
111  
112  	snd_soc_daifmt_parse_clock_provider_as_phandle(node, prefix, &bitclkmaster, &framemaster);
113  	if (!bitclkmaster && !framemaster) {
114  		/*
115  		 * No dai-link level and master setting was not found from
116  		 * sound node level, revert back to legacy DT parsing and
117  		 * take the settings from codec node.
118  		 */
119  		dev_dbg(dev, "Revert to legacy daifmt parsing\n");
120  
121  		daifmt |= snd_soc_daifmt_parse_clock_provider_as_flag(codec, NULL);
122  	} else {
123  		daifmt |= snd_soc_daifmt_clock_provider_from_bitmap(
124  				((codec == bitclkmaster) << 4) | (codec == framemaster));
125  	}
126  
127  	of_node_put(bitclkmaster);
128  	of_node_put(framemaster);
129  
130  	*retfmt = daifmt;
131  
132  	return 0;
133  }
134  EXPORT_SYMBOL_GPL(simple_util_parse_daifmt);
135  
simple_util_parse_tdm_width_map(struct device * dev,struct device_node * np,struct simple_util_dai * dai)136  int simple_util_parse_tdm_width_map(struct device *dev, struct device_node *np,
137  				    struct simple_util_dai *dai)
138  {
139  	int n, i, ret;
140  	u32 *p;
141  
142  	if (!of_property_read_bool(np, "dai-tdm-slot-width-map"))
143  		return 0;
144  
145  	n = of_property_count_elems_of_size(np, "dai-tdm-slot-width-map", sizeof(u32));
146  	if (n % 3) {
147  		dev_err(dev, "Invalid number of cells for dai-tdm-slot-width-map\n");
148  		return -EINVAL;
149  	}
150  
151  	dai->tdm_width_map = devm_kcalloc(dev, n, sizeof(*dai->tdm_width_map), GFP_KERNEL);
152  	if (!dai->tdm_width_map)
153  		return -ENOMEM;
154  
155  	u32 *array_values __free(kfree) = kcalloc(n, sizeof(*array_values),
156  						  GFP_KERNEL);
157  	if (!array_values)
158  		return -ENOMEM;
159  
160  	ret = of_property_read_u32_array(np, "dai-tdm-slot-width-map", array_values, n);
161  	if (ret < 0) {
162  		dev_err(dev, "Could not read dai-tdm-slot-width-map: %d\n", ret);
163  		return ret;
164  	}
165  
166  	p = array_values;
167  	for (i = 0; i < n / 3; ++i) {
168  		dai->tdm_width_map[i].sample_bits = *p++;
169  		dai->tdm_width_map[i].slot_width = *p++;
170  		dai->tdm_width_map[i].slot_count = *p++;
171  	}
172  
173  	dai->n_tdm_widths = i;
174  
175  	return 0;
176  }
177  EXPORT_SYMBOL_GPL(simple_util_parse_tdm_width_map);
178  
simple_util_set_dailink_name(struct device * dev,struct snd_soc_dai_link * dai_link,const char * fmt,...)179  int simple_util_set_dailink_name(struct device *dev,
180  				 struct snd_soc_dai_link *dai_link,
181  				 const char *fmt, ...)
182  {
183  	va_list ap;
184  	char *name = NULL;
185  	int ret = -ENOMEM;
186  
187  	va_start(ap, fmt);
188  	name = devm_kvasprintf(dev, GFP_KERNEL, fmt, ap);
189  	va_end(ap);
190  
191  	if (name) {
192  		ret = 0;
193  
194  		dai_link->name		= name;
195  		dai_link->stream_name	= name;
196  	}
197  
198  	return ret;
199  }
200  EXPORT_SYMBOL_GPL(simple_util_set_dailink_name);
201  
simple_util_parse_card_name(struct snd_soc_card * card,char * prefix)202  int simple_util_parse_card_name(struct snd_soc_card *card,
203  				char *prefix)
204  {
205  	int ret;
206  
207  	if (!prefix)
208  		prefix = "";
209  
210  	/* Parse the card name from DT */
211  	ret = snd_soc_of_parse_card_name(card, "label");
212  	if (ret < 0 || !card->name) {
213  		char prop[128];
214  
215  		snprintf(prop, sizeof(prop), "%sname", prefix);
216  		ret = snd_soc_of_parse_card_name(card, prop);
217  		if (ret < 0)
218  			return ret;
219  	}
220  
221  	if (!card->name && card->dai_link)
222  		card->name = card->dai_link->name;
223  
224  	return 0;
225  }
226  EXPORT_SYMBOL_GPL(simple_util_parse_card_name);
227  
simple_clk_enable(struct simple_util_dai * dai)228  static int simple_clk_enable(struct simple_util_dai *dai)
229  {
230  	if (dai)
231  		return clk_prepare_enable(dai->clk);
232  
233  	return 0;
234  }
235  
simple_clk_disable(struct simple_util_dai * dai)236  static void simple_clk_disable(struct simple_util_dai *dai)
237  {
238  	if (dai)
239  		clk_disable_unprepare(dai->clk);
240  }
241  
simple_util_parse_clk(struct device * dev,struct device_node * node,struct simple_util_dai * simple_dai,struct snd_soc_dai_link_component * dlc)242  int simple_util_parse_clk(struct device *dev,
243  			  struct device_node *node,
244  			  struct simple_util_dai *simple_dai,
245  			  struct snd_soc_dai_link_component *dlc)
246  {
247  	struct clk *clk;
248  	u32 val;
249  
250  	/*
251  	 * Parse dai->sysclk come from "clocks = <&xxx>"
252  	 * (if system has common clock)
253  	 *  or "system-clock-frequency = <xxx>"
254  	 *  or device's module clock.
255  	 */
256  	clk = devm_get_clk_from_child(dev, node, NULL);
257  	simple_dai->clk_fixed = of_property_read_bool(
258  		node, "system-clock-fixed");
259  	if (!IS_ERR(clk)) {
260  		simple_dai->sysclk = clk_get_rate(clk);
261  
262  		simple_dai->clk = clk;
263  	} else if (!of_property_read_u32(node, "system-clock-frequency", &val)) {
264  		simple_dai->sysclk = val;
265  		simple_dai->clk_fixed = true;
266  	} else {
267  		clk = devm_get_clk_from_child(dev, dlc->of_node, NULL);
268  		if (!IS_ERR(clk))
269  			simple_dai->sysclk = clk_get_rate(clk);
270  	}
271  
272  	if (of_property_read_bool(node, "system-clock-direction-out"))
273  		simple_dai->clk_direction = SND_SOC_CLOCK_OUT;
274  
275  	return 0;
276  }
277  EXPORT_SYMBOL_GPL(simple_util_parse_clk);
278  
simple_check_fixed_sysclk(struct device * dev,struct simple_util_dai * dai,unsigned int * fixed_sysclk)279  static int simple_check_fixed_sysclk(struct device *dev,
280  					  struct simple_util_dai *dai,
281  					  unsigned int *fixed_sysclk)
282  {
283  	if (dai->clk_fixed) {
284  		if (*fixed_sysclk && *fixed_sysclk != dai->sysclk) {
285  			dev_err(dev, "inconsistent fixed sysclk rates (%u vs %u)\n",
286  				*fixed_sysclk, dai->sysclk);
287  			return -EINVAL;
288  		}
289  		*fixed_sysclk = dai->sysclk;
290  	}
291  
292  	return 0;
293  }
294  
simple_util_startup(struct snd_pcm_substream * substream)295  int simple_util_startup(struct snd_pcm_substream *substream)
296  {
297  	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
298  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card);
299  	struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
300  	struct simple_util_dai *dai;
301  	unsigned int fixed_sysclk = 0;
302  	int i1, i2, i;
303  	int ret;
304  
305  	for_each_prop_dai_cpu(props, i1, dai) {
306  		ret = simple_clk_enable(dai);
307  		if (ret)
308  			goto cpu_err;
309  		ret = simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
310  		if (ret)
311  			goto cpu_err;
312  	}
313  
314  	for_each_prop_dai_codec(props, i2, dai) {
315  		ret = simple_clk_enable(dai);
316  		if (ret)
317  			goto codec_err;
318  		ret = simple_check_fixed_sysclk(rtd->dev, dai, &fixed_sysclk);
319  		if (ret)
320  			goto codec_err;
321  	}
322  
323  	if (fixed_sysclk && props->mclk_fs) {
324  		unsigned int fixed_rate = fixed_sysclk / props->mclk_fs;
325  
326  		if (fixed_sysclk % props->mclk_fs) {
327  			dev_err(rtd->dev, "fixed sysclk %u not divisible by mclk_fs %u\n",
328  				fixed_sysclk, props->mclk_fs);
329  			ret = -EINVAL;
330  			goto codec_err;
331  		}
332  		ret = snd_pcm_hw_constraint_minmax(substream->runtime, SNDRV_PCM_HW_PARAM_RATE,
333  			fixed_rate, fixed_rate);
334  		if (ret < 0)
335  			goto codec_err;
336  	}
337  
338  	return 0;
339  
340  codec_err:
341  	for_each_prop_dai_codec(props, i, dai) {
342  		if (i >= i2)
343  			break;
344  		simple_clk_disable(dai);
345  	}
346  cpu_err:
347  	for_each_prop_dai_cpu(props, i, dai) {
348  		if (i >= i1)
349  			break;
350  		simple_clk_disable(dai);
351  	}
352  	return ret;
353  }
354  EXPORT_SYMBOL_GPL(simple_util_startup);
355  
simple_util_shutdown(struct snd_pcm_substream * substream)356  void simple_util_shutdown(struct snd_pcm_substream *substream)
357  {
358  	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
359  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card);
360  	struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
361  	struct simple_util_dai *dai;
362  	int i;
363  
364  	for_each_prop_dai_cpu(props, i, dai) {
365  		struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, i);
366  
367  		if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(cpu_dai))
368  			snd_soc_dai_set_sysclk(cpu_dai,
369  					       0, 0, SND_SOC_CLOCK_OUT);
370  
371  		simple_clk_disable(dai);
372  	}
373  	for_each_prop_dai_codec(props, i, dai) {
374  		struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, i);
375  
376  		if (props->mclk_fs && !dai->clk_fixed && !snd_soc_dai_active(codec_dai))
377  			snd_soc_dai_set_sysclk(codec_dai,
378  					       0, 0, SND_SOC_CLOCK_IN);
379  
380  		simple_clk_disable(dai);
381  	}
382  }
383  EXPORT_SYMBOL_GPL(simple_util_shutdown);
384  
simple_set_clk_rate(struct device * dev,struct simple_util_dai * simple_dai,unsigned long rate)385  static int simple_set_clk_rate(struct device *dev,
386  				    struct simple_util_dai *simple_dai,
387  				    unsigned long rate)
388  {
389  	if (!simple_dai)
390  		return 0;
391  
392  	if (simple_dai->clk_fixed && rate != simple_dai->sysclk) {
393  		dev_err(dev, "dai %s invalid clock rate %lu\n", simple_dai->name, rate);
394  		return -EINVAL;
395  	}
396  
397  	if (!simple_dai->clk)
398  		return 0;
399  
400  	if (clk_get_rate(simple_dai->clk) == rate)
401  		return 0;
402  
403  	return clk_set_rate(simple_dai->clk, rate);
404  }
405  
simple_set_tdm(struct snd_soc_dai * dai,struct simple_util_dai * simple_dai,struct snd_pcm_hw_params * params)406  static int simple_set_tdm(struct snd_soc_dai *dai,
407  				struct simple_util_dai *simple_dai,
408  				struct snd_pcm_hw_params *params)
409  {
410  	int sample_bits = params_width(params);
411  	int slot_width, slot_count;
412  	int i, ret;
413  
414  	if (!simple_dai || !simple_dai->tdm_width_map)
415  		return 0;
416  
417  	slot_width = simple_dai->slot_width;
418  	slot_count = simple_dai->slots;
419  
420  	if (slot_width == 0)
421  		slot_width = sample_bits;
422  
423  	for (i = 0; i < simple_dai->n_tdm_widths; ++i) {
424  		if (simple_dai->tdm_width_map[i].sample_bits == sample_bits) {
425  			slot_width = simple_dai->tdm_width_map[i].slot_width;
426  			slot_count = simple_dai->tdm_width_map[i].slot_count;
427  			break;
428  		}
429  	}
430  
431  	ret = snd_soc_dai_set_tdm_slot(dai,
432  				       simple_dai->tx_slot_mask,
433  				       simple_dai->rx_slot_mask,
434  				       slot_count,
435  				       slot_width);
436  	if (ret && ret != -ENOTSUPP) {
437  		dev_err(dai->dev, "simple-card: set_tdm_slot error: %d\n", ret);
438  		return ret;
439  	}
440  
441  	return 0;
442  }
443  
simple_util_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)444  int simple_util_hw_params(struct snd_pcm_substream *substream,
445  			  struct snd_pcm_hw_params *params)
446  {
447  	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
448  	struct simple_util_dai *pdai;
449  	struct snd_soc_dai *sdai;
450  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card);
451  	struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
452  	unsigned int mclk, mclk_fs = 0;
453  	int i, ret;
454  
455  	if (props->mclk_fs)
456  		mclk_fs = props->mclk_fs;
457  
458  	if (mclk_fs) {
459  		struct snd_soc_component *component;
460  		mclk = params_rate(params) * mclk_fs;
461  
462  		for_each_prop_dai_codec(props, i, pdai) {
463  			ret = simple_set_clk_rate(rtd->dev, pdai, mclk);
464  			if (ret < 0)
465  				return ret;
466  		}
467  
468  		for_each_prop_dai_cpu(props, i, pdai) {
469  			ret = simple_set_clk_rate(rtd->dev, pdai, mclk);
470  			if (ret < 0)
471  				return ret;
472  		}
473  
474  		/* Ensure sysclk is set on all components in case any
475  		 * (such as platform components) are missed by calls to
476  		 * snd_soc_dai_set_sysclk.
477  		 */
478  		for_each_rtd_components(rtd, i, component) {
479  			ret = snd_soc_component_set_sysclk(component, 0, 0,
480  							   mclk, SND_SOC_CLOCK_IN);
481  			if (ret && ret != -ENOTSUPP)
482  				return ret;
483  		}
484  
485  		for_each_rtd_codec_dais(rtd, i, sdai) {
486  			ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_IN);
487  			if (ret && ret != -ENOTSUPP)
488  				return ret;
489  		}
490  
491  		for_each_rtd_cpu_dais(rtd, i, sdai) {
492  			ret = snd_soc_dai_set_sysclk(sdai, 0, mclk, SND_SOC_CLOCK_OUT);
493  			if (ret && ret != -ENOTSUPP)
494  				return ret;
495  		}
496  	}
497  
498  	for_each_prop_dai_codec(props, i, pdai) {
499  		sdai = snd_soc_rtd_to_codec(rtd, i);
500  		ret = simple_set_tdm(sdai, pdai, params);
501  		if (ret < 0)
502  			return ret;
503  	}
504  
505  	for_each_prop_dai_cpu(props, i, pdai) {
506  		sdai = snd_soc_rtd_to_cpu(rtd, i);
507  		ret = simple_set_tdm(sdai, pdai, params);
508  		if (ret < 0)
509  			return ret;
510  	}
511  
512  	return 0;
513  }
514  EXPORT_SYMBOL_GPL(simple_util_hw_params);
515  
simple_util_be_hw_params_fixup(struct snd_soc_pcm_runtime * rtd,struct snd_pcm_hw_params * params)516  int simple_util_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
517  				   struct snd_pcm_hw_params *params)
518  {
519  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card);
520  	struct simple_dai_props *dai_props = simple_priv_to_props(priv, rtd->num);
521  	struct simple_util_data *data = &dai_props->adata;
522  	struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
523  	struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
524  
525  	if (data->convert_rate)
526  		rate->min =
527  		rate->max = data->convert_rate;
528  
529  	if (data->convert_channels)
530  		channels->min =
531  		channels->max = data->convert_channels;
532  
533  	if (data->convert_sample_format)
534  		simple_fixup_sample_fmt(data, params);
535  
536  	return 0;
537  }
538  EXPORT_SYMBOL_GPL(simple_util_be_hw_params_fixup);
539  
simple_init_dai(struct snd_soc_dai * dai,struct simple_util_dai * simple_dai)540  static int simple_init_dai(struct snd_soc_dai *dai, struct simple_util_dai *simple_dai)
541  {
542  	int ret;
543  
544  	if (!simple_dai)
545  		return 0;
546  
547  	if (simple_dai->sysclk) {
548  		ret = snd_soc_dai_set_sysclk(dai, 0, simple_dai->sysclk,
549  					     simple_dai->clk_direction);
550  		if (ret && ret != -ENOTSUPP) {
551  			dev_err(dai->dev, "simple-card: set_sysclk error\n");
552  			return ret;
553  		}
554  	}
555  
556  	if (simple_dai->slots) {
557  		ret = snd_soc_dai_set_tdm_slot(dai,
558  					       simple_dai->tx_slot_mask,
559  					       simple_dai->rx_slot_mask,
560  					       simple_dai->slots,
561  					       simple_dai->slot_width);
562  		if (ret && ret != -ENOTSUPP) {
563  			dev_err(dai->dev, "simple-card: set_tdm_slot error\n");
564  			return ret;
565  		}
566  	}
567  
568  	return 0;
569  }
570  
simple_component_is_codec(struct snd_soc_component * component)571  static inline int simple_component_is_codec(struct snd_soc_component *component)
572  {
573  	return component->driver->endianness;
574  }
575  
simple_init_for_codec2codec(struct snd_soc_pcm_runtime * rtd,struct simple_dai_props * dai_props)576  static int simple_init_for_codec2codec(struct snd_soc_pcm_runtime *rtd,
577  				       struct simple_dai_props *dai_props)
578  {
579  	struct snd_soc_dai_link *dai_link = rtd->dai_link;
580  	struct snd_soc_component *component;
581  	struct snd_soc_pcm_stream *c2c_params;
582  	struct snd_pcm_hardware hw;
583  	int i, ret, stream;
584  
585  	/* Do nothing if it already has Codec2Codec settings */
586  	if (dai_link->c2c_params)
587  		return 0;
588  
589  	/* Do nothing if it was DPCM :: BE */
590  	if (dai_link->no_pcm)
591  		return 0;
592  
593  	/* Only Codecs */
594  	for_each_rtd_components(rtd, i, component) {
595  		if (!simple_component_is_codec(component))
596  			return 0;
597  	}
598  
599  	/* Assumes the capabilities are the same for all supported streams */
600  	for_each_pcm_streams(stream) {
601  		ret = snd_soc_runtime_calc_hw(rtd, &hw, stream);
602  		if (ret == 0)
603  			break;
604  	}
605  
606  	if (ret < 0) {
607  		dev_err(rtd->dev, "simple-card: no valid dai_link params\n");
608  		return ret;
609  	}
610  
611  	c2c_params = devm_kzalloc(rtd->dev, sizeof(*c2c_params), GFP_KERNEL);
612  	if (!c2c_params)
613  		return -ENOMEM;
614  
615  	c2c_params->formats		= hw.formats;
616  	c2c_params->rates		= hw.rates;
617  	c2c_params->rate_min		= hw.rate_min;
618  	c2c_params->rate_max		= hw.rate_max;
619  	c2c_params->channels_min	= hw.channels_min;
620  	c2c_params->channels_max	= hw.channels_max;
621  
622  	dai_link->c2c_params		= c2c_params;
623  	dai_link->num_c2c_params	= 1;
624  
625  	return 0;
626  }
627  
simple_util_dai_init(struct snd_soc_pcm_runtime * rtd)628  int simple_util_dai_init(struct snd_soc_pcm_runtime *rtd)
629  {
630  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(rtd->card);
631  	struct simple_dai_props *props = simple_priv_to_props(priv, rtd->num);
632  	struct simple_util_dai *dai;
633  	int i, ret;
634  
635  	for_each_prop_dai_codec(props, i, dai) {
636  		ret = simple_init_dai(snd_soc_rtd_to_codec(rtd, i), dai);
637  		if (ret < 0)
638  			return ret;
639  	}
640  	for_each_prop_dai_cpu(props, i, dai) {
641  		ret = simple_init_dai(snd_soc_rtd_to_cpu(rtd, i), dai);
642  		if (ret < 0)
643  			return ret;
644  	}
645  
646  	ret = simple_init_for_codec2codec(rtd, props);
647  	if (ret < 0)
648  		return ret;
649  
650  	return 0;
651  }
652  EXPORT_SYMBOL_GPL(simple_util_dai_init);
653  
simple_util_canonicalize_platform(struct snd_soc_dai_link_component * platforms,struct snd_soc_dai_link_component * cpus)654  void simple_util_canonicalize_platform(struct snd_soc_dai_link_component *platforms,
655  				       struct snd_soc_dai_link_component *cpus)
656  {
657  	/*
658  	 * Assumes Platform == CPU
659  	 *
660  	 * Some CPU might be using soc-generic-dmaengine-pcm. This means CPU and Platform
661  	 * are different Component, but are sharing same component->dev.
662  	 *
663  	 * Let's assume Platform is same as CPU if it doesn't identify Platform on DT.
664  	 * see
665  	 *	simple-card.c :: simple_count_noml()
666  	 */
667  	if (!platforms->of_node)
668  		snd_soc_dlc_use_cpu_as_platform(platforms, cpus);
669  }
670  EXPORT_SYMBOL_GPL(simple_util_canonicalize_platform);
671  
simple_util_canonicalize_cpu(struct snd_soc_dai_link_component * cpus,int is_single_links)672  void simple_util_canonicalize_cpu(struct snd_soc_dai_link_component *cpus,
673  				  int is_single_links)
674  {
675  	/*
676  	 * In soc_bind_dai_link() will check cpu name after
677  	 * of_node matching if dai_link has cpu_dai_name.
678  	 * but, it will never match if name was created by
679  	 * fmt_single_name() remove cpu_dai_name if cpu_args
680  	 * was 0. See:
681  	 *	fmt_single_name()
682  	 *	fmt_multiple_name()
683  	 */
684  	if (is_single_links)
685  		cpus->dai_name = NULL;
686  }
687  EXPORT_SYMBOL_GPL(simple_util_canonicalize_cpu);
688  
simple_util_clean_reference(struct snd_soc_card * card)689  void simple_util_clean_reference(struct snd_soc_card *card)
690  {
691  	struct snd_soc_dai_link *dai_link;
692  	struct snd_soc_dai_link_component *cpu;
693  	struct snd_soc_dai_link_component *codec;
694  	int i, j;
695  
696  	for_each_card_prelinks(card, i, dai_link) {
697  		for_each_link_cpus(dai_link, j, cpu)
698  			of_node_put(cpu->of_node);
699  		for_each_link_codecs(dai_link, j, codec)
700  			of_node_put(codec->of_node);
701  	}
702  }
703  EXPORT_SYMBOL_GPL(simple_util_clean_reference);
704  
simple_util_parse_routing(struct snd_soc_card * card,char * prefix)705  int simple_util_parse_routing(struct snd_soc_card *card,
706  			      char *prefix)
707  {
708  	struct device_node *node = card->dev->of_node;
709  	char prop[128];
710  
711  	if (!prefix)
712  		prefix = "";
713  
714  	snprintf(prop, sizeof(prop), "%s%s", prefix, "routing");
715  
716  	if (!of_property_read_bool(node, prop))
717  		return 0;
718  
719  	return snd_soc_of_parse_audio_routing(card, prop);
720  }
721  EXPORT_SYMBOL_GPL(simple_util_parse_routing);
722  
simple_util_parse_widgets(struct snd_soc_card * card,char * prefix)723  int simple_util_parse_widgets(struct snd_soc_card *card,
724  			      char *prefix)
725  {
726  	struct device_node *node = card->dev->of_node;
727  	char prop[128];
728  
729  	if (!prefix)
730  		prefix = "";
731  
732  	snprintf(prop, sizeof(prop), "%s%s", prefix, "widgets");
733  
734  	if (of_property_read_bool(node, prop))
735  		return snd_soc_of_parse_audio_simple_widgets(card, prop);
736  
737  	/* no widgets is not error */
738  	return 0;
739  }
740  EXPORT_SYMBOL_GPL(simple_util_parse_widgets);
741  
simple_util_parse_pin_switches(struct snd_soc_card * card,char * prefix)742  int simple_util_parse_pin_switches(struct snd_soc_card *card,
743  				   char *prefix)
744  {
745  	char prop[128];
746  
747  	if (!prefix)
748  		prefix = "";
749  
750  	snprintf(prop, sizeof(prop), "%s%s", prefix, "pin-switches");
751  
752  	return snd_soc_of_parse_pin_switches(card, prop);
753  }
754  EXPORT_SYMBOL_GPL(simple_util_parse_pin_switches);
755  
simple_util_init_jack(struct snd_soc_card * card,struct simple_util_jack * sjack,int is_hp,char * prefix,char * pin)756  int simple_util_init_jack(struct snd_soc_card *card,
757  			  struct simple_util_jack *sjack,
758  			  int is_hp, char *prefix,
759  			  char *pin)
760  {
761  	struct device *dev = card->dev;
762  	struct gpio_desc *desc;
763  	char prop[128];
764  	char *pin_name;
765  	char *gpio_name;
766  	int mask;
767  	int error;
768  
769  	if (!prefix)
770  		prefix = "";
771  
772  	if (is_hp) {
773  		snprintf(prop, sizeof(prop), "%shp-det", prefix);
774  		pin_name	= pin ? pin : "Headphones";
775  		gpio_name	= "Headphone detection";
776  		mask		= SND_JACK_HEADPHONE;
777  	} else {
778  		snprintf(prop, sizeof(prop), "%smic-det", prefix);
779  		pin_name	= pin ? pin : "Mic Jack";
780  		gpio_name	= "Mic detection";
781  		mask		= SND_JACK_MICROPHONE;
782  	}
783  
784  	desc = gpiod_get_optional(dev, prop, GPIOD_IN);
785  	error = PTR_ERR_OR_ZERO(desc);
786  	if (error)
787  		return error;
788  
789  	if (desc) {
790  		error = gpiod_set_consumer_name(desc, gpio_name);
791  		if (error)
792  			return error;
793  
794  		sjack->pin.pin		= pin_name;
795  		sjack->pin.mask		= mask;
796  
797  		sjack->gpio.name	= gpio_name;
798  		sjack->gpio.report	= mask;
799  		sjack->gpio.desc	= desc;
800  		sjack->gpio.debounce_time = 150;
801  
802  		snd_soc_card_jack_new_pins(card, pin_name, mask, &sjack->jack,
803  					   &sjack->pin, 1);
804  
805  		snd_soc_jack_add_gpios(&sjack->jack, 1, &sjack->gpio);
806  	}
807  
808  	return 0;
809  }
810  EXPORT_SYMBOL_GPL(simple_util_init_jack);
811  
simple_util_init_aux_jacks(struct simple_util_priv * priv,char * prefix)812  int simple_util_init_aux_jacks(struct simple_util_priv *priv, char *prefix)
813  {
814  	struct snd_soc_card *card = simple_priv_to_card(priv);
815  	struct snd_soc_component *component;
816  	int found_jack_index = 0;
817  	int type = 0;
818  	int num = 0;
819  	int ret;
820  
821  	if (priv->aux_jacks)
822  		return 0;
823  
824  	for_each_card_auxs(card, component) {
825  		type = snd_soc_component_get_jack_type(component);
826  		if (type > 0)
827  			num++;
828  	}
829  	if (num < 1)
830  		return 0;
831  
832  	priv->aux_jacks = devm_kcalloc(card->dev, num,
833  				       sizeof(struct snd_soc_jack), GFP_KERNEL);
834  	if (!priv->aux_jacks)
835  		return -ENOMEM;
836  
837  	for_each_card_auxs(card, component) {
838  		char id[128];
839  		struct snd_soc_jack *jack;
840  
841  		if (found_jack_index >= num)
842  			break;
843  
844  		type = snd_soc_component_get_jack_type(component);
845  		if (type <= 0)
846  			continue;
847  
848  		/* create jack */
849  		jack = &(priv->aux_jacks[found_jack_index++]);
850  		snprintf(id, sizeof(id), "%s-jack", component->name);
851  		ret = snd_soc_card_jack_new(card, id, type, jack);
852  		if (ret)
853  			continue;
854  
855  		(void)snd_soc_component_set_jack(component, jack, NULL);
856  	}
857  	return 0;
858  }
859  EXPORT_SYMBOL_GPL(simple_util_init_aux_jacks);
860  
simple_util_init_priv(struct simple_util_priv * priv,struct link_info * li)861  int simple_util_init_priv(struct simple_util_priv *priv,
862  			  struct link_info *li)
863  {
864  	struct snd_soc_card *card = simple_priv_to_card(priv);
865  	struct device *dev = simple_priv_to_dev(priv);
866  	struct snd_soc_dai_link *dai_link;
867  	struct simple_dai_props *dai_props;
868  	struct simple_util_dai *dais;
869  	struct snd_soc_dai_link_component *dlcs;
870  	struct snd_soc_codec_conf *cconf = NULL;
871  	int i, dai_num = 0, dlc_num = 0, cnf_num = 0;
872  
873  	dai_props = devm_kcalloc(dev, li->link, sizeof(*dai_props), GFP_KERNEL);
874  	dai_link  = devm_kcalloc(dev, li->link, sizeof(*dai_link),  GFP_KERNEL);
875  	if (!dai_props || !dai_link)
876  		return -ENOMEM;
877  
878  	/*
879  	 * dais (= CPU+Codec)
880  	 * dlcs (= CPU+Codec+Platform)
881  	 */
882  	for (i = 0; i < li->link; i++) {
883  		int cc = li->num[i].cpus + li->num[i].codecs;
884  
885  		dai_num += cc;
886  		dlc_num += cc + li->num[i].platforms;
887  
888  		if (!li->num[i].cpus)
889  			cnf_num += li->num[i].codecs;
890  	}
891  
892  	dais = devm_kcalloc(dev, dai_num, sizeof(*dais), GFP_KERNEL);
893  	dlcs = devm_kcalloc(dev, dlc_num, sizeof(*dlcs), GFP_KERNEL);
894  	if (!dais || !dlcs)
895  		return -ENOMEM;
896  
897  	if (cnf_num) {
898  		cconf = devm_kcalloc(dev, cnf_num, sizeof(*cconf), GFP_KERNEL);
899  		if (!cconf)
900  			return -ENOMEM;
901  	}
902  
903  	dev_dbg(dev, "link %d, dais %d, ccnf %d\n",
904  		li->link, dai_num, cnf_num);
905  
906  	priv->dai_props		= dai_props;
907  	priv->dai_link		= dai_link;
908  	priv->dais		= dais;
909  	priv->dlcs		= dlcs;
910  	priv->codec_conf	= cconf;
911  
912  	card->dai_link		= priv->dai_link;
913  	card->num_links		= li->link;
914  	card->codec_conf	= cconf;
915  	card->num_configs	= cnf_num;
916  
917  	for (i = 0; i < li->link; i++) {
918  		if (li->num[i].cpus) {
919  			/* Normal CPU */
920  			dai_link[i].cpus	= dlcs;
921  			dai_props[i].num.cpus	=
922  			dai_link[i].num_cpus	= li->num[i].cpus;
923  			dai_props[i].cpu_dai	= dais;
924  
925  			dlcs += li->num[i].cpus;
926  			dais += li->num[i].cpus;
927  		} else {
928  			/* DPCM Be's CPU = dummy */
929  			dai_link[i].cpus	= &snd_soc_dummy_dlc;
930  			dai_props[i].num.cpus	=
931  			dai_link[i].num_cpus	= 1;
932  		}
933  
934  		if (li->num[i].codecs) {
935  			/* Normal Codec */
936  			dai_link[i].codecs	= dlcs;
937  			dai_props[i].num.codecs	=
938  			dai_link[i].num_codecs	= li->num[i].codecs;
939  			dai_props[i].codec_dai	= dais;
940  
941  			dlcs += li->num[i].codecs;
942  			dais += li->num[i].codecs;
943  
944  			if (!li->num[i].cpus) {
945  				/* DPCM Be's Codec */
946  				dai_props[i].codec_conf = cconf;
947  				cconf += li->num[i].codecs;
948  			}
949  		} else {
950  			/* DPCM Fe's Codec = dummy */
951  			dai_link[i].codecs	= &snd_soc_dummy_dlc;
952  			dai_props[i].num.codecs	=
953  			dai_link[i].num_codecs	= 1;
954  		}
955  
956  		if (li->num[i].platforms) {
957  			/* Have Platform */
958  			dai_link[i].platforms		= dlcs;
959  			dai_props[i].num.platforms	=
960  			dai_link[i].num_platforms	= li->num[i].platforms;
961  
962  			dlcs += li->num[i].platforms;
963  		} else {
964  			/* Doesn't have Platform */
965  			dai_link[i].platforms		= NULL;
966  			dai_props[i].num.platforms	=
967  			dai_link[i].num_platforms	= 0;
968  		}
969  	}
970  
971  	return 0;
972  }
973  EXPORT_SYMBOL_GPL(simple_util_init_priv);
974  
simple_util_remove(struct platform_device * pdev)975  void simple_util_remove(struct platform_device *pdev)
976  {
977  	struct snd_soc_card *card = platform_get_drvdata(pdev);
978  
979  	simple_util_clean_reference(card);
980  }
981  EXPORT_SYMBOL_GPL(simple_util_remove);
982  
graph_util_card_probe(struct snd_soc_card * card)983  int graph_util_card_probe(struct snd_soc_card *card)
984  {
985  	struct simple_util_priv *priv = snd_soc_card_get_drvdata(card);
986  	int ret;
987  
988  	ret = simple_util_init_hp(card, &priv->hp_jack, NULL);
989  	if (ret < 0)
990  		return ret;
991  
992  	ret = simple_util_init_mic(card, &priv->mic_jack, NULL);
993  	if (ret < 0)
994  		return ret;
995  
996  	return 0;
997  }
998  EXPORT_SYMBOL_GPL(graph_util_card_probe);
999  
graph_util_is_ports0(struct device_node * np)1000  int graph_util_is_ports0(struct device_node *np)
1001  {
1002  	struct device_node *port, *ports, *ports0, *top;
1003  	int ret;
1004  
1005  	/* np is "endpoint" or "port" */
1006  	if (of_node_name_eq(np, "endpoint")) {
1007  		port = of_get_parent(np);
1008  	} else {
1009  		port = np;
1010  		of_node_get(port);
1011  	}
1012  
1013  	ports	= of_get_parent(port);
1014  	top	= of_get_parent(ports);
1015  	ports0	= of_get_child_by_name(top, "ports");
1016  
1017  	ret = ports0 == ports;
1018  
1019  	of_node_put(port);
1020  	of_node_put(ports);
1021  	of_node_put(ports0);
1022  	of_node_put(top);
1023  
1024  	return ret;
1025  }
1026  EXPORT_SYMBOL_GPL(graph_util_is_ports0);
1027  
graph_get_dai_id(struct device_node * ep)1028  static int graph_get_dai_id(struct device_node *ep)
1029  {
1030  	struct device_node *node;
1031  	struct device_node *endpoint;
1032  	struct of_endpoint info;
1033  	int i, id;
1034  	int ret;
1035  
1036  	/* use driver specified DAI ID if exist */
1037  	ret = snd_soc_get_dai_id(ep);
1038  	if (ret != -ENOTSUPP)
1039  		return ret;
1040  
1041  	/* use endpoint/port reg if exist */
1042  	ret = of_graph_parse_endpoint(ep, &info);
1043  	if (ret == 0) {
1044  		/*
1045  		 * Because it will count port/endpoint if it doesn't have "reg".
1046  		 * But, we can't judge whether it has "no reg", or "reg = <0>"
1047  		 * only of_graph_parse_endpoint().
1048  		 * We need to check "reg" property
1049  		 */
1050  		if (of_property_present(ep,   "reg"))
1051  			return info.id;
1052  
1053  		node = of_get_parent(ep);
1054  		ret = of_property_present(node, "reg");
1055  		of_node_put(node);
1056  		if (ret)
1057  			return info.port;
1058  	}
1059  	node = of_graph_get_port_parent(ep);
1060  
1061  	/*
1062  	 * Non HDMI sound case, counting port/endpoint on its DT
1063  	 * is enough. Let's count it.
1064  	 */
1065  	i = 0;
1066  	id = -1;
1067  	for_each_endpoint_of_node(node, endpoint) {
1068  		if (endpoint == ep)
1069  			id = i;
1070  		i++;
1071  	}
1072  
1073  	of_node_put(node);
1074  
1075  	if (id < 0)
1076  		return -ENODEV;
1077  
1078  	return id;
1079  }
1080  
graph_util_parse_dai(struct device * dev,struct device_node * ep,struct snd_soc_dai_link_component * dlc,int * is_single_link)1081  int graph_util_parse_dai(struct device *dev, struct device_node *ep,
1082  			 struct snd_soc_dai_link_component *dlc, int *is_single_link)
1083  {
1084  	struct device_node *node;
1085  	struct of_phandle_args args = {};
1086  	struct snd_soc_dai *dai;
1087  	int ret;
1088  
1089  	if (!ep)
1090  		return 0;
1091  
1092  	node = of_graph_get_port_parent(ep);
1093  
1094  	/*
1095  	 * Try to find from DAI node
1096  	 */
1097  	args.np = ep;
1098  	dai = snd_soc_get_dai_via_args(&args);
1099  	if (dai) {
1100  		dlc->dai_name = snd_soc_dai_name_get(dai);
1101  		dlc->dai_args = snd_soc_copy_dai_args(dev, &args);
1102  		if (!dlc->dai_args)
1103  			return -ENOMEM;
1104  
1105  		goto parse_dai_end;
1106  	}
1107  
1108  	/* Get dai->name */
1109  	args.np		= node;
1110  	args.args[0]	= graph_get_dai_id(ep);
1111  	args.args_count	= (of_graph_get_endpoint_count(node) > 1);
1112  
1113  	/*
1114  	 * FIXME
1115  	 *
1116  	 * Here, dlc->dai_name is pointer to CPU/Codec DAI name.
1117  	 * If user unbinded CPU or Codec driver, but not for Sound Card,
1118  	 * dlc->dai_name is keeping unbinded CPU or Codec
1119  	 * driver's pointer.
1120  	 *
1121  	 * If user re-bind CPU or Codec driver again, ALSA SoC will try
1122  	 * to rebind Card via snd_soc_try_rebind_card(), but because of
1123  	 * above reason, it might can't bind Sound Card.
1124  	 * Because Sound Card is pointing to released dai_name pointer.
1125  	 *
1126  	 * To avoid this rebind Card issue,
1127  	 * 1) It needs to alloc memory to keep dai_name eventhough
1128  	 *    CPU or Codec driver was unbinded, or
1129  	 * 2) user need to rebind Sound Card everytime
1130  	 *    if he unbinded CPU or Codec.
1131  	 */
1132  	ret = snd_soc_get_dlc(&args, dlc);
1133  	if (ret < 0) {
1134  		of_node_put(node);
1135  		return ret;
1136  	}
1137  
1138  parse_dai_end:
1139  	if (is_single_link)
1140  		*is_single_link = of_graph_get_endpoint_count(node) == 1;
1141  
1142  	return 0;
1143  }
1144  EXPORT_SYMBOL_GPL(graph_util_parse_dai);
1145  
graph_util_parse_link_direction(struct device_node * np,bool * playback_only,bool * capture_only)1146  void graph_util_parse_link_direction(struct device_node *np,
1147  				    bool *playback_only, bool *capture_only)
1148  {
1149  	bool is_playback_only = of_property_read_bool(np, "playback-only");
1150  	bool is_capture_only  = of_property_read_bool(np, "capture-only");
1151  
1152  	if (is_playback_only)
1153  		*playback_only = is_playback_only;
1154  	if (is_capture_only)
1155  		*capture_only = is_capture_only;
1156  }
1157  EXPORT_SYMBOL_GPL(graph_util_parse_link_direction);
1158  
1159  static enum snd_soc_trigger_order
__graph_util_parse_trigger_order(struct simple_util_priv * priv,struct device_node * np,const char * prop)1160  __graph_util_parse_trigger_order(struct simple_util_priv *priv,
1161  				 struct device_node *np,
1162  				 const char *prop)
1163  {
1164  	u32 val[SND_SOC_TRIGGER_SIZE];
1165  	int ret;
1166  
1167  	ret = of_property_read_u32_array(np, prop, val, SND_SOC_TRIGGER_SIZE);
1168  	if (ret == 0) {
1169  		struct device *dev = simple_priv_to_dev(priv);
1170  		u32 order =	(val[0] << 8) +
1171  			(val[1] << 4) +
1172  			(val[2]);
1173  
1174  		switch (order) {
1175  		case	(SND_SOC_TRIGGER_LINK		<< 8) +
1176  			(SND_SOC_TRIGGER_COMPONENT	<< 4) +
1177  			(SND_SOC_TRIGGER_DAI):
1178  			return SND_SOC_TRIGGER_ORDER_DEFAULT;
1179  
1180  		case	(SND_SOC_TRIGGER_LINK		<< 8) +
1181  			(SND_SOC_TRIGGER_DAI		<< 4) +
1182  			(SND_SOC_TRIGGER_COMPONENT):
1183  			return SND_SOC_TRIGGER_ORDER_LDC;
1184  
1185  		default:
1186  			dev_err(dev, "unsupported trigger order [0x%x]\n", order);
1187  		}
1188  	}
1189  
1190  	/* SND_SOC_TRIGGER_ORDER_MAX means error */
1191  	return SND_SOC_TRIGGER_ORDER_MAX;
1192  }
1193  
graph_util_parse_trigger_order(struct simple_util_priv * priv,struct device_node * np,enum snd_soc_trigger_order * trigger_start,enum snd_soc_trigger_order * trigger_stop)1194  void graph_util_parse_trigger_order(struct simple_util_priv *priv,
1195  				    struct device_node *np,
1196  				    enum snd_soc_trigger_order *trigger_start,
1197  				    enum snd_soc_trigger_order *trigger_stop)
1198  {
1199  	static enum snd_soc_trigger_order order;
1200  
1201  	/*
1202  	 * We can use it like below
1203  	 *
1204  	 * #include <dt-bindings/sound/audio-graph.h>
1205  	 *
1206  	 * link-trigger-order = <SND_SOC_TRIGGER_LINK
1207  	 *			 SND_SOC_TRIGGER_COMPONENT
1208  	 *			 SND_SOC_TRIGGER_DAI>;
1209  	 */
1210  
1211  	order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order");
1212  	if (order < SND_SOC_TRIGGER_ORDER_MAX) {
1213  		*trigger_start = order;
1214  		*trigger_stop  = order;
1215  	}
1216  
1217  	order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order-start");
1218  	if (order < SND_SOC_TRIGGER_ORDER_MAX)
1219  		*trigger_start = order;
1220  
1221  	order = __graph_util_parse_trigger_order(priv, np, "link-trigger-order-stop");
1222  	if (order < SND_SOC_TRIGGER_ORDER_MAX)
1223  		*trigger_stop  = order;
1224  
1225  	return;
1226  }
1227  EXPORT_SYMBOL_GPL(graph_util_parse_trigger_order);
1228  
1229  /* Module information */
1230  MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
1231  MODULE_DESCRIPTION("ALSA SoC Simple Card Utils");
1232  MODULE_LICENSE("GPL v2");
1233