// SPDX-License-Identifier: GPL-2.0-only // // tegra_audio_graph_card.c - Audio Graph based Tegra Machine Driver // // Copyright (c) 2020-2021 NVIDIA CORPORATION. All rights reserved. #include #include #include #include #include #include #include #define MAX_PLLA_OUT0_DIV 128 #define simple_to_tegra_priv(simple) \ container_of(simple, struct tegra_audio_priv, simple) enum srate_type { /* * Sample rates multiple of 8000 Hz and below are supported: * ( 8000, 16000, 32000, 48000, 96000, 192000 Hz ) */ x8_RATE, /* * Sample rates multiple of 11025 Hz and below are supported: * ( 11025, 22050, 44100, 88200, 176400 Hz ) */ x11_RATE, NUM_RATE_TYPE, }; struct tegra_audio_priv { struct asoc_simple_priv simple; struct clk *clk_plla_out0; struct clk *clk_plla; }; /* Tegra audio chip data */ struct tegra_audio_cdata { unsigned int plla_rates[NUM_RATE_TYPE]; unsigned int plla_out0_rates[NUM_RATE_TYPE]; }; static bool need_clk_update(struct snd_soc_dai *dai) { if (snd_soc_dai_is_dummy(dai) || !dai->driver->ops || !dai->driver->name) return false; if (strstr(dai->driver->name, "I2S") || strstr(dai->driver->name, "DMIC") || strstr(dai->driver->name, "DSPK")) return true; return false; } /* Setup PLL clock as per the given sample rate */ static int tegra_audio_graph_update_pll(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); struct asoc_simple_priv *simple = snd_soc_card_get_drvdata(rtd->card); struct tegra_audio_priv *priv = simple_to_tegra_priv(simple); struct device *dev = rtd->card->dev; const struct tegra_audio_cdata *data = of_device_get_match_data(dev); unsigned int plla_rate, plla_out0_rate, bclk; unsigned int srate = params_rate(params); int err; switch (srate) { case 11025: case 22050: case 44100: case 88200: case 176400: plla_out0_rate = data->plla_out0_rates[x11_RATE]; plla_rate = data->plla_rates[x11_RATE]; break; case 8000: case 16000: case 32000: case 48000: case 96000: case 192000: plla_out0_rate = data->plla_out0_rates[x8_RATE]; plla_rate = data->plla_rates[x8_RATE]; break; default: dev_err(rtd->card->dev, "Unsupported sample rate %u\n", srate); return -EINVAL; } /* * Below is the clock relation: * * PLLA * | * |--> PLLA_OUT0 * | * |---> I2S modules * | * |---> DMIC modules * | * |---> DSPK modules * * * Default PLLA_OUT0 rate might be too high when I/O is running * at minimum PCM configurations. This may result in incorrect * clock rates and glitchy audio. The maximum divider is 128 * and any thing higher than that won't work. Thus reduce PLLA_OUT0 * to work for lower configurations. * * This problem is seen for I2S only, as DMIC and DSPK minimum * clock requirements are under allowed divider limits. */ bclk = srate * params_channels(params) * params_width(params); if (div_u64(plla_out0_rate, bclk) > MAX_PLLA_OUT0_DIV) plla_out0_rate >>= 1; dev_dbg(rtd->card->dev, "Update clock rates: PLLA(= %u Hz) and PLLA_OUT0(= %u Hz)\n", plla_rate, plla_out0_rate); /* Set PLLA rate */ err = clk_set_rate(priv->clk_plla, plla_rate); if (err) { dev_err(rtd->card->dev, "Can't set plla rate for %u, err: %d\n", plla_rate, err); return err; } /* Set PLLA_OUT0 rate */ err = clk_set_rate(priv->clk_plla_out0, plla_out0_rate); if (err) { dev_err(rtd->card->dev, "Can't set plla_out0 rate %u, err: %d\n", plla_out0_rate, err); return err; } return err; } static int tegra_audio_graph_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params) { struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0); int err; if (need_clk_update(cpu_dai)) { err = tegra_audio_graph_update_pll(substream, params); if (err) return err; } return asoc_simple_hw_params(substream, params); } static const struct snd_soc_ops tegra_audio_graph_ops = { .startup = asoc_simple_startup, .shutdown = asoc_simple_shutdown, .hw_params = tegra_audio_graph_hw_params, }; static int tegra_audio_graph_card_probe(struct snd_soc_card *card) { struct asoc_simple_priv *simple = snd_soc_card_get_drvdata(card); struct tegra_audio_priv *priv = simple_to_tegra_priv(simple); priv->clk_plla = devm_clk_get(card->dev, "pll_a"); if (IS_ERR(priv->clk_plla)) { dev_err(card->dev, "Can't retrieve clk pll_a\n"); return PTR_ERR(priv->clk_plla); } priv->clk_plla_out0 = devm_clk_get(card->dev, "plla_out0"); if (IS_ERR(priv->clk_plla_out0)) { dev_err(card->dev, "Can't retrieve clk plla_out0\n"); return PTR_ERR(priv->clk_plla_out0); } return asoc_graph_card_probe(card); } static int tegra_audio_graph_probe(struct platform_device *pdev) { struct tegra_audio_priv *priv; struct device *dev = &pdev->dev; struct snd_soc_card *card; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; card = simple_priv_to_card(&priv->simple); card->driver_name = "tegra-ape"; card->probe = tegra_audio_graph_card_probe; /* audio_graph_parse_of() depends on below */ card->component_chaining = 1; priv->simple.ops = &tegra_audio_graph_ops; priv->simple.force_dpcm = 1; return audio_graph_parse_of(&priv->simple, dev); } static const struct tegra_audio_cdata tegra210_data = { /* PLLA */ .plla_rates[x8_RATE] = 368640000, .plla_rates[x11_RATE] = 338688000, /* PLLA_OUT0 */ .plla_out0_rates[x8_RATE] = 49152000, .plla_out0_rates[x11_RATE] = 45158400, }; static const struct tegra_audio_cdata tegra186_data = { /* PLLA */ .plla_rates[x8_RATE] = 245760000, .plla_rates[x11_RATE] = 270950400, /* PLLA_OUT0 */ .plla_out0_rates[x8_RATE] = 49152000, .plla_out0_rates[x11_RATE] = 45158400, }; static const struct of_device_id graph_of_tegra_match[] = { { .compatible = "nvidia,tegra210-audio-graph-card", .data = &tegra210_data }, { .compatible = "nvidia,tegra186-audio-graph-card", .data = &tegra186_data }, {}, }; MODULE_DEVICE_TABLE(of, graph_of_tegra_match); static struct platform_driver tegra_audio_graph_card = { .driver = { .name = "tegra-audio-graph-card", .pm = &snd_soc_pm_ops, .of_match_table = graph_of_tegra_match, }, .probe = tegra_audio_graph_probe, .remove = asoc_simple_remove, }; module_platform_driver(tegra_audio_graph_card); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("ASoC Tegra Audio Graph Sound Card"); MODULE_AUTHOR("Sameer Pujar ");