1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
2 //
3 // Copyright (c) 2018 BayLibre, SAS.
4 // Author: Jerome Brunet <jbrunet@baylibre.com>
5 
6 #include <linux/clk.h>
7 #include <linux/module.h>
8 #include <linux/of_platform.h>
9 #include <sound/pcm_params.h>
10 #include <sound/soc.h>
11 #include <sound/soc-dai.h>
12 
13 #include "axg-tdm.h"
14 
15 enum {
16 	TDM_IFACE_PAD,
17 	TDM_IFACE_LOOPBACK,
18 };
19 
20 static unsigned int axg_tdm_slots_total(u32 *mask)
21 {
22 	unsigned int slots = 0;
23 	int i;
24 
25 	if (!mask)
26 		return 0;
27 
28 	/* Count the total number of slots provided by all 4 lanes */
29 	for (i = 0; i < AXG_TDM_NUM_LANES; i++)
30 		slots += hweight32(mask[i]);
31 
32 	return slots;
33 }
34 
35 int axg_tdm_set_tdm_slots(struct snd_soc_dai *dai, u32 *tx_mask,
36 			  u32 *rx_mask, unsigned int slots,
37 			  unsigned int slot_width)
38 {
39 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
40 	struct axg_tdm_stream *tx = snd_soc_dai_dma_data_get_playback(dai);
41 	struct axg_tdm_stream *rx = snd_soc_dai_dma_data_get_capture(dai);
42 	unsigned int tx_slots, rx_slots;
43 	unsigned int fmt = 0;
44 
45 	tx_slots = axg_tdm_slots_total(tx_mask);
46 	rx_slots = axg_tdm_slots_total(rx_mask);
47 
48 	/* We should at least have a slot for a valid interface */
49 	if (!tx_slots && !rx_slots) {
50 		dev_err(dai->dev, "interface has no slot\n");
51 		return -EINVAL;
52 	}
53 
54 	iface->slots = slots;
55 
56 	switch (slot_width) {
57 	case 0:
58 		slot_width = 32;
59 		fallthrough;
60 	case 32:
61 		fmt |= SNDRV_PCM_FMTBIT_S32_LE;
62 		fallthrough;
63 	case 24:
64 		fmt |= SNDRV_PCM_FMTBIT_S24_LE;
65 		fmt |= SNDRV_PCM_FMTBIT_S20_LE;
66 		fallthrough;
67 	case 16:
68 		fmt |= SNDRV_PCM_FMTBIT_S16_LE;
69 		fallthrough;
70 	case 8:
71 		fmt |= SNDRV_PCM_FMTBIT_S8;
72 		break;
73 	default:
74 		dev_err(dai->dev, "unsupported slot width: %d\n", slot_width);
75 		return -EINVAL;
76 	}
77 
78 	iface->slot_width = slot_width;
79 
80 	/* Amend the dai driver and let dpcm merge do its job */
81 	if (tx) {
82 		tx->mask = tx_mask;
83 		dai->driver->playback.channels_max = tx_slots;
84 		dai->driver->playback.formats = fmt;
85 	}
86 
87 	if (rx) {
88 		rx->mask = rx_mask;
89 		dai->driver->capture.channels_max = rx_slots;
90 		dai->driver->capture.formats = fmt;
91 	}
92 
93 	return 0;
94 }
95 EXPORT_SYMBOL_GPL(axg_tdm_set_tdm_slots);
96 
97 static int axg_tdm_iface_set_sysclk(struct snd_soc_dai *dai, int clk_id,
98 				    unsigned int freq, int dir)
99 {
100 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
101 	int ret = -ENOTSUPP;
102 
103 	if (dir == SND_SOC_CLOCK_OUT && clk_id == 0) {
104 		if (!iface->mclk) {
105 			dev_warn(dai->dev, "master clock not provided\n");
106 		} else {
107 			ret = clk_set_rate(iface->mclk, freq);
108 			if (!ret)
109 				iface->mclk_rate = freq;
110 		}
111 	}
112 
113 	return ret;
114 }
115 
116 static int axg_tdm_iface_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
117 {
118 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
119 
120 	switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
121 	case SND_SOC_DAIFMT_BP_FP:
122 		if (!iface->mclk) {
123 			dev_err(dai->dev, "cpu clock master: mclk missing\n");
124 			return -ENODEV;
125 		}
126 		break;
127 
128 	case SND_SOC_DAIFMT_BC_FC:
129 		break;
130 
131 	case SND_SOC_DAIFMT_BP_FC:
132 	case SND_SOC_DAIFMT_BC_FP:
133 		dev_err(dai->dev, "only CBS_CFS and CBM_CFM are supported\n");
134 		fallthrough;
135 	default:
136 		return -EINVAL;
137 	}
138 
139 	iface->fmt = fmt;
140 	return 0;
141 }
142 
143 static int axg_tdm_iface_startup(struct snd_pcm_substream *substream,
144 				 struct snd_soc_dai *dai)
145 {
146 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
147 	struct axg_tdm_stream *ts =
148 		snd_soc_dai_get_dma_data(dai, substream);
149 	int ret;
150 
151 	if (!axg_tdm_slots_total(ts->mask)) {
152 		dev_err(dai->dev, "interface has not slots\n");
153 		return -EINVAL;
154 	}
155 
156 	/* Apply component wide rate symmetry */
157 	if (snd_soc_component_active(dai->component)) {
158 		ret = snd_pcm_hw_constraint_single(substream->runtime,
159 						   SNDRV_PCM_HW_PARAM_RATE,
160 						   iface->rate);
161 		if (ret < 0) {
162 			dev_err(dai->dev,
163 				"can't set iface rate constraint\n");
164 			return ret;
165 		}
166 	}
167 
168 	return 0;
169 }
170 
171 static int axg_tdm_iface_set_stream(struct snd_pcm_substream *substream,
172 				    struct snd_pcm_hw_params *params,
173 				    struct snd_soc_dai *dai)
174 {
175 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
176 	struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
177 	unsigned int channels = params_channels(params);
178 	unsigned int width = params_width(params);
179 
180 	/* Save rate and sample_bits for component symmetry */
181 	iface->rate = params_rate(params);
182 
183 	/* Make sure this interface can cope with the stream */
184 	if (axg_tdm_slots_total(ts->mask) < channels) {
185 		dev_err(dai->dev, "not enough slots for channels\n");
186 		return -EINVAL;
187 	}
188 
189 	if (iface->slot_width < width) {
190 		dev_err(dai->dev, "incompatible slots width for stream\n");
191 		return -EINVAL;
192 	}
193 
194 	/* Save the parameter for tdmout/tdmin widgets */
195 	ts->physical_width = params_physical_width(params);
196 	ts->width = params_width(params);
197 	ts->channels = params_channels(params);
198 
199 	return 0;
200 }
201 
202 static int axg_tdm_iface_set_lrclk(struct snd_soc_dai *dai,
203 				   struct snd_pcm_hw_params *params)
204 {
205 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
206 	unsigned int ratio_num;
207 	int ret;
208 
209 	ret = clk_set_rate(iface->lrclk, params_rate(params));
210 	if (ret) {
211 		dev_err(dai->dev, "setting sample clock failed: %d\n", ret);
212 		return ret;
213 	}
214 
215 	switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
216 	case SND_SOC_DAIFMT_I2S:
217 	case SND_SOC_DAIFMT_LEFT_J:
218 	case SND_SOC_DAIFMT_RIGHT_J:
219 		/* 50% duty cycle ratio */
220 		ratio_num = 1;
221 		break;
222 
223 	case SND_SOC_DAIFMT_DSP_A:
224 	case SND_SOC_DAIFMT_DSP_B:
225 		/*
226 		 * A zero duty cycle ratio will result in setting the mininum
227 		 * ratio possible which, for this clock, is 1 cycle of the
228 		 * parent bclk clock high and the rest low, This is exactly
229 		 * what we want here.
230 		 */
231 		ratio_num = 0;
232 		break;
233 
234 	default:
235 		return -EINVAL;
236 	}
237 
238 	ret = clk_set_duty_cycle(iface->lrclk, ratio_num, 2);
239 	if (ret) {
240 		dev_err(dai->dev,
241 			"setting sample clock duty cycle failed: %d\n", ret);
242 		return ret;
243 	}
244 
245 	/* Set sample clock inversion */
246 	ret = clk_set_phase(iface->lrclk,
247 			    axg_tdm_lrclk_invert(iface->fmt) ? 180 : 0);
248 	if (ret) {
249 		dev_err(dai->dev,
250 			"setting sample clock phase failed: %d\n", ret);
251 		return ret;
252 	}
253 
254 	return 0;
255 }
256 
257 static int axg_tdm_iface_set_sclk(struct snd_soc_dai *dai,
258 				  struct snd_pcm_hw_params *params)
259 {
260 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
261 	unsigned long srate;
262 	int ret;
263 
264 	srate = iface->slots * iface->slot_width * params_rate(params);
265 
266 	if (!iface->mclk_rate) {
267 		/* If no specific mclk is requested, default to bit clock * 4 */
268 		clk_set_rate(iface->mclk, 4 * srate);
269 	} else {
270 		/* Check if we can actually get the bit clock from mclk */
271 		if (iface->mclk_rate % srate) {
272 			dev_err(dai->dev,
273 				"can't derive sclk %lu from mclk %lu\n",
274 				srate, iface->mclk_rate);
275 			return -EINVAL;
276 		}
277 	}
278 
279 	ret = clk_set_rate(iface->sclk, srate);
280 	if (ret) {
281 		dev_err(dai->dev, "setting bit clock failed: %d\n", ret);
282 		return ret;
283 	}
284 
285 	/* Set the bit clock inversion */
286 	ret = clk_set_phase(iface->sclk,
287 			    axg_tdm_sclk_invert(iface->fmt) ? 0 : 180);
288 	if (ret) {
289 		dev_err(dai->dev, "setting bit clock phase failed: %d\n", ret);
290 		return ret;
291 	}
292 
293 	return ret;
294 }
295 
296 static int axg_tdm_iface_hw_params(struct snd_pcm_substream *substream,
297 				   struct snd_pcm_hw_params *params,
298 				   struct snd_soc_dai *dai)
299 {
300 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
301 	int ret;
302 
303 	switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
304 	case SND_SOC_DAIFMT_I2S:
305 	case SND_SOC_DAIFMT_LEFT_J:
306 	case SND_SOC_DAIFMT_RIGHT_J:
307 		if (iface->slots > 2) {
308 			dev_err(dai->dev, "bad slot number for format: %d\n",
309 				iface->slots);
310 			return -EINVAL;
311 		}
312 		break;
313 
314 	case SND_SOC_DAIFMT_DSP_A:
315 	case SND_SOC_DAIFMT_DSP_B:
316 		break;
317 
318 	default:
319 		dev_err(dai->dev, "unsupported dai format\n");
320 		return -EINVAL;
321 	}
322 
323 	ret = axg_tdm_iface_set_stream(substream, params, dai);
324 	if (ret)
325 		return ret;
326 
327 	if ((iface->fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) ==
328 	    SND_SOC_DAIFMT_BP_FP) {
329 		ret = axg_tdm_iface_set_sclk(dai, params);
330 		if (ret)
331 			return ret;
332 
333 		ret = axg_tdm_iface_set_lrclk(dai, params);
334 		if (ret)
335 			return ret;
336 	}
337 
338 	return 0;
339 }
340 
341 static int axg_tdm_iface_hw_free(struct snd_pcm_substream *substream,
342 				 struct snd_soc_dai *dai)
343 {
344 	struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
345 
346 	/* Stop all attached formatters */
347 	axg_tdm_stream_stop(ts);
348 
349 	return 0;
350 }
351 
352 static int axg_tdm_iface_prepare(struct snd_pcm_substream *substream,
353 				 struct snd_soc_dai *dai)
354 {
355 	struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
356 
357 	/* Force all attached formatters to update */
358 	return axg_tdm_stream_reset(ts);
359 }
360 
361 static int axg_tdm_iface_remove_dai(struct snd_soc_dai *dai)
362 {
363 	int stream;
364 
365 	for_each_pcm_streams(stream) {
366 		struct axg_tdm_stream *ts = snd_soc_dai_dma_data_get(dai, stream);
367 
368 		if (ts)
369 			axg_tdm_stream_free(ts);
370 	}
371 
372 	return 0;
373 }
374 
375 static int axg_tdm_iface_probe_dai(struct snd_soc_dai *dai)
376 {
377 	struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
378 	int stream;
379 
380 	for_each_pcm_streams(stream) {
381 		struct axg_tdm_stream *ts;
382 
383 		if (!snd_soc_dai_get_widget(dai, stream))
384 			continue;
385 
386 		ts = axg_tdm_stream_alloc(iface);
387 		if (!ts) {
388 			axg_tdm_iface_remove_dai(dai);
389 			return -ENOMEM;
390 		}
391 		snd_soc_dai_dma_data_set(dai, stream, ts);
392 	}
393 
394 	return 0;
395 }
396 
397 static const struct snd_soc_dai_ops axg_tdm_iface_ops = {
398 	.probe		= axg_tdm_iface_probe_dai,
399 	.remove		= axg_tdm_iface_remove_dai,
400 	.set_sysclk	= axg_tdm_iface_set_sysclk,
401 	.set_fmt	= axg_tdm_iface_set_fmt,
402 	.startup	= axg_tdm_iface_startup,
403 	.hw_params	= axg_tdm_iface_hw_params,
404 	.prepare	= axg_tdm_iface_prepare,
405 	.hw_free	= axg_tdm_iface_hw_free,
406 };
407 
408 /* TDM Backend DAIs */
409 static const struct snd_soc_dai_driver axg_tdm_iface_dai_drv[] = {
410 	[TDM_IFACE_PAD] = {
411 		.name = "TDM Pad",
412 		.playback = {
413 			.stream_name	= "Playback",
414 			.channels_min	= 1,
415 			.channels_max	= AXG_TDM_CHANNEL_MAX,
416 			.rates		= AXG_TDM_RATES,
417 			.formats	= AXG_TDM_FORMATS,
418 		},
419 		.capture = {
420 			.stream_name	= "Capture",
421 			.channels_min	= 1,
422 			.channels_max	= AXG_TDM_CHANNEL_MAX,
423 			.rates		= AXG_TDM_RATES,
424 			.formats	= AXG_TDM_FORMATS,
425 		},
426 		.id = TDM_IFACE_PAD,
427 		.ops = &axg_tdm_iface_ops,
428 	},
429 	[TDM_IFACE_LOOPBACK] = {
430 		.name = "TDM Loopback",
431 		.capture = {
432 			.stream_name	= "Loopback",
433 			.channels_min	= 1,
434 			.channels_max	= AXG_TDM_CHANNEL_MAX,
435 			.rates		= AXG_TDM_RATES,
436 			.formats	= AXG_TDM_FORMATS,
437 		},
438 		.id = TDM_IFACE_LOOPBACK,
439 		.ops = &axg_tdm_iface_ops,
440 	},
441 };
442 
443 static int axg_tdm_iface_set_bias_level(struct snd_soc_component *component,
444 					enum snd_soc_bias_level level)
445 {
446 	struct axg_tdm_iface *iface = snd_soc_component_get_drvdata(component);
447 	enum snd_soc_bias_level now =
448 		snd_soc_component_get_bias_level(component);
449 	int ret = 0;
450 
451 	switch (level) {
452 	case SND_SOC_BIAS_PREPARE:
453 		if (now == SND_SOC_BIAS_STANDBY)
454 			ret = clk_prepare_enable(iface->mclk);
455 		break;
456 
457 	case SND_SOC_BIAS_STANDBY:
458 		if (now == SND_SOC_BIAS_PREPARE)
459 			clk_disable_unprepare(iface->mclk);
460 		break;
461 
462 	case SND_SOC_BIAS_OFF:
463 	case SND_SOC_BIAS_ON:
464 		break;
465 	}
466 
467 	return ret;
468 }
469 
470 static const struct snd_soc_dapm_widget axg_tdm_iface_dapm_widgets[] = {
471 	SND_SOC_DAPM_SIGGEN("Playback Signal"),
472 };
473 
474 static const struct snd_soc_dapm_route axg_tdm_iface_dapm_routes[] = {
475 	{ "Loopback", NULL, "Playback Signal" },
476 };
477 
478 static const struct snd_soc_component_driver axg_tdm_iface_component_drv = {
479 	.dapm_widgets		= axg_tdm_iface_dapm_widgets,
480 	.num_dapm_widgets	= ARRAY_SIZE(axg_tdm_iface_dapm_widgets),
481 	.dapm_routes		= axg_tdm_iface_dapm_routes,
482 	.num_dapm_routes	= ARRAY_SIZE(axg_tdm_iface_dapm_routes),
483 	.set_bias_level		= axg_tdm_iface_set_bias_level,
484 };
485 
486 static const struct of_device_id axg_tdm_iface_of_match[] = {
487 	{ .compatible = "amlogic,axg-tdm-iface", },
488 	{}
489 };
490 MODULE_DEVICE_TABLE(of, axg_tdm_iface_of_match);
491 
492 static int axg_tdm_iface_probe(struct platform_device *pdev)
493 {
494 	struct device *dev = &pdev->dev;
495 	struct snd_soc_dai_driver *dai_drv;
496 	struct axg_tdm_iface *iface;
497 	int i;
498 
499 	iface = devm_kzalloc(dev, sizeof(*iface), GFP_KERNEL);
500 	if (!iface)
501 		return -ENOMEM;
502 	platform_set_drvdata(pdev, iface);
503 
504 	/*
505 	 * Duplicate dai driver: depending on the slot masks configuration
506 	 * We'll change the number of channel provided by DAI stream, so dpcm
507 	 * channel merge can be done properly
508 	 */
509 	dai_drv = devm_kcalloc(dev, ARRAY_SIZE(axg_tdm_iface_dai_drv),
510 			       sizeof(*dai_drv), GFP_KERNEL);
511 	if (!dai_drv)
512 		return -ENOMEM;
513 
514 	for (i = 0; i < ARRAY_SIZE(axg_tdm_iface_dai_drv); i++)
515 		memcpy(&dai_drv[i], &axg_tdm_iface_dai_drv[i],
516 		       sizeof(*dai_drv));
517 
518 	/* Bit clock provided on the pad */
519 	iface->sclk = devm_clk_get(dev, "sclk");
520 	if (IS_ERR(iface->sclk))
521 		return dev_err_probe(dev, PTR_ERR(iface->sclk), "failed to get sclk\n");
522 
523 	/* Sample clock provided on the pad */
524 	iface->lrclk = devm_clk_get(dev, "lrclk");
525 	if (IS_ERR(iface->lrclk))
526 		return dev_err_probe(dev, PTR_ERR(iface->lrclk), "failed to get lrclk\n");
527 
528 	/*
529 	 * mclk maybe be missing when the cpu dai is in slave mode and
530 	 * the codec does not require it to provide a master clock.
531 	 * At this point, ignore the error if mclk is missing. We'll
532 	 * throw an error if the cpu dai is master and mclk is missing
533 	 */
534 	iface->mclk = devm_clk_get_optional(dev, "mclk");
535 	if (IS_ERR(iface->mclk))
536 		return dev_err_probe(dev, PTR_ERR(iface->mclk), "failed to get mclk\n");
537 
538 	return devm_snd_soc_register_component(dev,
539 					&axg_tdm_iface_component_drv, dai_drv,
540 					ARRAY_SIZE(axg_tdm_iface_dai_drv));
541 }
542 
543 static struct platform_driver axg_tdm_iface_pdrv = {
544 	.probe = axg_tdm_iface_probe,
545 	.driver = {
546 		.name = "axg-tdm-iface",
547 		.of_match_table = axg_tdm_iface_of_match,
548 	},
549 };
550 module_platform_driver(axg_tdm_iface_pdrv);
551 
552 MODULE_DESCRIPTION("Amlogic AXG TDM interface driver");
553 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
554 MODULE_LICENSE("GPL v2");
555