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