1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
3 // Copyright (c) 2018 BayLibre, SAS.
4 // Author: Jerome Brunet <jbrunet@baylibre.com>
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>
20 static unsigned int axg_tdm_slots_total(u32 *mask)
22 unsigned int slots = 0;
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]);
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)
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;
46 tx_slots = axg_tdm_slots_total(tx_mask);
47 rx_slots = axg_tdm_slots_total(rx_mask);
49 /* We should at least have a slot for a valid interface */
50 if (!tx_slots && !rx_slots) {
51 dev_err(dai->dev, "interface has no slot\n");
56 * Amend the dai driver channel number and let dpcm channel merge do
61 dai->driver->playback.channels_max = tx_slots;
66 dai->driver->capture.channels_max = rx_slots;
73 /* defaults width to 32 if not provided */
74 iface->slot_width = 32;
80 iface->slot_width = slot_width;
83 dev_err(dai->dev, "unsupported slot width: %d\n", slot_width);
89 EXPORT_SYMBOL_GPL(axg_tdm_set_tdm_slots);
91 static int axg_tdm_iface_set_sysclk(struct snd_soc_dai *dai, int clk_id,
92 unsigned int freq, int dir)
94 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
97 if (dir == SND_SOC_CLOCK_OUT && clk_id == 0) {
99 dev_warn(dai->dev, "master clock not provided\n");
101 ret = clk_set_rate(iface->mclk, freq);
103 iface->mclk_rate = freq;
110 static int axg_tdm_iface_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
112 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
114 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
115 case SND_SOC_DAIFMT_CBS_CFS:
117 dev_err(dai->dev, "cpu clock master: mclk missing\n");
122 case SND_SOC_DAIFMT_CBM_CFM:
125 case SND_SOC_DAIFMT_CBS_CFM:
126 case SND_SOC_DAIFMT_CBM_CFS:
127 dev_err(dai->dev, "only CBS_CFS and CBM_CFM are supported\n");
137 static int axg_tdm_iface_startup(struct snd_pcm_substream *substream,
138 struct snd_soc_dai *dai)
140 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
141 struct axg_tdm_stream *ts =
142 snd_soc_dai_get_dma_data(dai, substream);
145 if (!axg_tdm_slots_total(ts->mask)) {
146 dev_err(dai->dev, "interface has not slots\n");
150 /* Apply component wide rate symmetry */
151 if (dai->component->active) {
152 ret = snd_pcm_hw_constraint_single(substream->runtime,
153 SNDRV_PCM_HW_PARAM_RATE,
157 "can't set iface rate constraint\n");
165 static int axg_tdm_iface_set_stream(struct snd_pcm_substream *substream,
166 struct snd_pcm_hw_params *params,
167 struct snd_soc_dai *dai)
169 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
170 struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
171 unsigned int channels = params_channels(params);
172 unsigned int width = params_width(params);
174 /* Save rate and sample_bits for component symmetry */
175 iface->rate = params_rate(params);
177 /* Make sure this interface can cope with the stream */
178 if (axg_tdm_slots_total(ts->mask) < channels) {
179 dev_err(dai->dev, "not enough slots for channels\n");
183 if (iface->slot_width < width) {
184 dev_err(dai->dev, "incompatible slots width for stream\n");
188 /* Save the parameter for tdmout/tdmin widgets */
189 ts->physical_width = params_physical_width(params);
190 ts->width = params_width(params);
191 ts->channels = params_channels(params);
196 static int axg_tdm_iface_set_lrclk(struct snd_soc_dai *dai,
197 struct snd_pcm_hw_params *params)
199 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
200 unsigned int ratio_num;
203 ret = clk_set_rate(iface->lrclk, params_rate(params));
205 dev_err(dai->dev, "setting sample clock failed: %d\n", ret);
209 switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
210 case SND_SOC_DAIFMT_I2S:
211 case SND_SOC_DAIFMT_LEFT_J:
212 case SND_SOC_DAIFMT_RIGHT_J:
213 /* 50% duty cycle ratio */
217 case SND_SOC_DAIFMT_DSP_A:
218 case SND_SOC_DAIFMT_DSP_B:
220 * A zero duty cycle ratio will result in setting the mininum
221 * ratio possible which, for this clock, is 1 cycle of the
222 * parent bclk clock high and the rest low, This is exactly
232 ret = clk_set_duty_cycle(iface->lrclk, ratio_num, 2);
235 "setting sample clock duty cycle failed: %d\n", ret);
239 /* Set sample clock inversion */
240 ret = clk_set_phase(iface->lrclk,
241 axg_tdm_lrclk_invert(iface->fmt) ? 180 : 0);
244 "setting sample clock phase failed: %d\n", ret);
251 static int axg_tdm_iface_set_sclk(struct snd_soc_dai *dai,
252 struct snd_pcm_hw_params *params)
254 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
258 srate = iface->slots * iface->slot_width * params_rate(params);
260 if (!iface->mclk_rate) {
261 /* If no specific mclk is requested, default to bit clock * 4 */
262 clk_set_rate(iface->mclk, 4 * srate);
264 /* Check if we can actually get the bit clock from mclk */
265 if (iface->mclk_rate % srate) {
267 "can't derive sclk %lu from mclk %lu\n",
268 srate, iface->mclk_rate);
273 ret = clk_set_rate(iface->sclk, srate);
275 dev_err(dai->dev, "setting bit clock failed: %d\n", ret);
279 /* Set the bit clock inversion */
280 ret = clk_set_phase(iface->sclk,
281 axg_tdm_sclk_invert(iface->fmt) ? 0 : 180);
283 dev_err(dai->dev, "setting bit clock phase failed: %d\n", ret);
290 static int axg_tdm_iface_hw_params(struct snd_pcm_substream *substream,
291 struct snd_pcm_hw_params *params,
292 struct snd_soc_dai *dai)
294 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
297 switch (iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
298 case SND_SOC_DAIFMT_I2S:
299 case SND_SOC_DAIFMT_LEFT_J:
300 case SND_SOC_DAIFMT_RIGHT_J:
301 if (iface->slots > 2) {
302 dev_err(dai->dev, "bad slot number for format: %d\n",
308 case SND_SOC_DAI_FORMAT_DSP_A:
309 case SND_SOC_DAI_FORMAT_DSP_B:
313 dev_err(dai->dev, "unsupported dai format\n");
317 ret = axg_tdm_iface_set_stream(substream, params, dai);
321 if ((iface->fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
322 SND_SOC_DAIFMT_CBS_CFS) {
323 ret = axg_tdm_iface_set_sclk(dai, params);
327 ret = axg_tdm_iface_set_lrclk(dai, params);
335 static int axg_tdm_iface_hw_free(struct snd_pcm_substream *substream,
336 struct snd_soc_dai *dai)
338 struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
340 /* Stop all attached formatters */
341 axg_tdm_stream_stop(ts);
346 static int axg_tdm_iface_prepare(struct snd_pcm_substream *substream,
347 struct snd_soc_dai *dai)
349 struct axg_tdm_stream *ts = snd_soc_dai_get_dma_data(dai, substream);
351 /* Force all attached formatters to update */
352 return axg_tdm_stream_reset(ts);
355 static int axg_tdm_iface_remove_dai(struct snd_soc_dai *dai)
357 if (dai->capture_dma_data)
358 axg_tdm_stream_free(dai->capture_dma_data);
360 if (dai->playback_dma_data)
361 axg_tdm_stream_free(dai->playback_dma_data);
366 static int axg_tdm_iface_probe_dai(struct snd_soc_dai *dai)
368 struct axg_tdm_iface *iface = snd_soc_dai_get_drvdata(dai);
370 if (dai->capture_widget) {
371 dai->capture_dma_data = axg_tdm_stream_alloc(iface);
372 if (!dai->capture_dma_data)
376 if (dai->playback_widget) {
377 dai->playback_dma_data = axg_tdm_stream_alloc(iface);
378 if (!dai->playback_dma_data) {
379 axg_tdm_iface_remove_dai(dai);
387 static const struct snd_soc_dai_ops axg_tdm_iface_ops = {
388 .set_sysclk = axg_tdm_iface_set_sysclk,
389 .set_fmt = axg_tdm_iface_set_fmt,
390 .startup = axg_tdm_iface_startup,
391 .hw_params = axg_tdm_iface_hw_params,
392 .prepare = axg_tdm_iface_prepare,
393 .hw_free = axg_tdm_iface_hw_free,
396 /* TDM Backend DAIs */
397 static const struct snd_soc_dai_driver axg_tdm_iface_dai_drv[] = {
401 .stream_name = "Playback",
403 .channels_max = AXG_TDM_CHANNEL_MAX,
404 .rates = AXG_TDM_RATES,
405 .formats = AXG_TDM_FORMATS,
408 .stream_name = "Capture",
410 .channels_max = AXG_TDM_CHANNEL_MAX,
411 .rates = AXG_TDM_RATES,
412 .formats = AXG_TDM_FORMATS,
415 .ops = &axg_tdm_iface_ops,
416 .probe = axg_tdm_iface_probe_dai,
417 .remove = axg_tdm_iface_remove_dai,
419 [TDM_IFACE_LOOPBACK] = {
420 .name = "TDM Loopback",
422 .stream_name = "Loopback",
424 .channels_max = AXG_TDM_CHANNEL_MAX,
425 .rates = AXG_TDM_RATES,
426 .formats = AXG_TDM_FORMATS,
428 .id = TDM_IFACE_LOOPBACK,
429 .ops = &axg_tdm_iface_ops,
430 .probe = axg_tdm_iface_probe_dai,
431 .remove = axg_tdm_iface_remove_dai,
435 static int axg_tdm_iface_set_bias_level(struct snd_soc_component *component,
436 enum snd_soc_bias_level level)
438 struct axg_tdm_iface *iface = snd_soc_component_get_drvdata(component);
439 enum snd_soc_bias_level now =
440 snd_soc_component_get_bias_level(component);
444 case SND_SOC_BIAS_PREPARE:
445 if (now == SND_SOC_BIAS_STANDBY)
446 ret = clk_prepare_enable(iface->mclk);
449 case SND_SOC_BIAS_STANDBY:
450 if (now == SND_SOC_BIAS_PREPARE)
451 clk_disable_unprepare(iface->mclk);
454 case SND_SOC_BIAS_OFF:
455 case SND_SOC_BIAS_ON:
462 static const struct snd_soc_dapm_widget axg_tdm_iface_dapm_widgets[] = {
463 SND_SOC_DAPM_SIGGEN("Playback Signal"),
466 static const struct snd_soc_dapm_route axg_tdm_iface_dapm_routes[] = {
467 { "Loopback", NULL, "Playback Signal" },
470 static const struct snd_soc_component_driver axg_tdm_iface_component_drv = {
471 .dapm_widgets = axg_tdm_iface_dapm_widgets,
472 .num_dapm_widgets = ARRAY_SIZE(axg_tdm_iface_dapm_widgets),
473 .dapm_routes = axg_tdm_iface_dapm_routes,
474 .num_dapm_routes = ARRAY_SIZE(axg_tdm_iface_dapm_routes),
475 .set_bias_level = axg_tdm_iface_set_bias_level,
478 static const struct of_device_id axg_tdm_iface_of_match[] = {
479 { .compatible = "amlogic,axg-tdm-iface", },
482 MODULE_DEVICE_TABLE(of, axg_tdm_iface_of_match);
484 static int axg_tdm_iface_probe(struct platform_device *pdev)
486 struct device *dev = &pdev->dev;
487 struct snd_soc_dai_driver *dai_drv;
488 struct axg_tdm_iface *iface;
491 iface = devm_kzalloc(dev, sizeof(*iface), GFP_KERNEL);
494 platform_set_drvdata(pdev, iface);
497 * Duplicate dai driver: depending on the slot masks configuration
498 * We'll change the number of channel provided by DAI stream, so dpcm
499 * channel merge can be done properly
501 dai_drv = devm_kcalloc(dev, ARRAY_SIZE(axg_tdm_iface_dai_drv),
502 sizeof(*dai_drv), GFP_KERNEL);
506 for (i = 0; i < ARRAY_SIZE(axg_tdm_iface_dai_drv); i++)
507 memcpy(&dai_drv[i], &axg_tdm_iface_dai_drv[i],
510 /* Bit clock provided on the pad */
511 iface->sclk = devm_clk_get(dev, "sclk");
512 if (IS_ERR(iface->sclk)) {
513 ret = PTR_ERR(iface->sclk);
514 if (ret != -EPROBE_DEFER)
515 dev_err(dev, "failed to get sclk: %d\n", ret);
519 /* Sample clock provided on the pad */
520 iface->lrclk = devm_clk_get(dev, "lrclk");
521 if (IS_ERR(iface->lrclk)) {
522 ret = PTR_ERR(iface->lrclk);
523 if (ret != -EPROBE_DEFER)
524 dev_err(dev, "failed to get lrclk: %d\n", ret);
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
534 iface->mclk = devm_clk_get(dev, "mclk");
535 if (IS_ERR(iface->mclk)) {
536 ret = PTR_ERR(iface->mclk);
537 if (ret == -ENOENT) {
540 if (ret != -EPROBE_DEFER)
541 dev_err(dev, "failed to get mclk: %d\n", ret);
546 return devm_snd_soc_register_component(dev,
547 &axg_tdm_iface_component_drv, dai_drv,
548 ARRAY_SIZE(axg_tdm_iface_dai_drv));
551 static struct platform_driver axg_tdm_iface_pdrv = {
552 .probe = axg_tdm_iface_probe,
554 .name = "axg-tdm-iface",
555 .of_match_table = axg_tdm_iface_of_match,
558 module_platform_driver(axg_tdm_iface_pdrv);
560 MODULE_DESCRIPTION("Amlogic AXG TDM interface driver");
561 MODULE_AUTHOR("Jerome Brunet <jbrunet@baylibre.com>");
562 MODULE_LICENSE("GPL v2");