avs/boards/rt274.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
0004 //
0005 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
0006 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
0007 //
0008
0009 #include <linux/module.h>
0010 #include <sound/jack.h>
0011 #include <sound/pcm.h>
0012 #include <sound/pcm_params.h>
0013 #include <sound/soc.h>
0014 #include <sound/soc-acpi.h>
0015 #include "../../../codecs/rt274.h"
0016
0017 #define AVS_RT274_FREQ_OUT  24000000
0018 #define AVS_RT274_BE_FIXUP_RATE 48000
0019 #define RT274_CODEC_DAI     "rt274-aif1"
0020
0021 static const struct snd_kcontrol_new card_controls[] = {
0022     SOC_DAPM_PIN_SWITCH("Headphone Jack"),
0023     SOC_DAPM_PIN_SWITCH("Mic Jack"),
0024 };
0025
0026 static int
0027 avs_rt274_clock_control(struct snd_soc_dapm_widget *w, struct snd_kcontrol *control, int event)
0028 {
0029     struct snd_soc_dapm_context *dapm = w->dapm;
0030     struct snd_soc_card *card = dapm->card;
0031     struct snd_soc_dai *codec_dai;
0032     int ret;
0033
0034     codec_dai = snd_soc_card_get_codec_dai(card, RT274_CODEC_DAI);
0035     if (!codec_dai)
0036         return -EINVAL;
0037
0038     /* Codec needs clock for Jack detection and button press */
0039     ret = snd_soc_dai_set_sysclk(codec_dai, RT274_SCLK_S_PLL2, AVS_RT274_FREQ_OUT,
0040                      SND_SOC_CLOCK_IN);
0041     if (ret < 0) {
0042         dev_err(codec_dai->dev, "set codec sysclk failed: %d\n", ret);
0043         return ret;
0044     }
0045
0046     if (SND_SOC_DAPM_EVENT_ON(event)) {
0047         int ratio = 100;
0048
0049         snd_soc_dai_set_bclk_ratio(codec_dai, ratio);
0050
0051         ret = snd_soc_dai_set_pll(codec_dai, 0, RT274_PLL2_S_BCLK,
0052                       AVS_RT274_BE_FIXUP_RATE * ratio, AVS_RT274_FREQ_OUT);
0053         if (ret) {
0054             dev_err(codec_dai->dev, "failed to enable PLL2: %d\n", ret);
0055             return ret;
0056         }
0057     }
0058
0059     return 0;
0060 }
0061
0062 static const struct snd_soc_dapm_widget card_widgets[] = {
0063     SND_SOC_DAPM_HP("Headphone Jack", NULL),
0064     SND_SOC_DAPM_MIC("Mic Jack", NULL),
0065     SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, avs_rt274_clock_control,
0066                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
0067 };
0068
0069 static const struct snd_soc_dapm_route card_base_routes[] = {
0070     {"Headphone Jack", NULL, "HPO Pin"},
0071     {"MIC", NULL, "Mic Jack"},
0072
0073     {"Headphone Jack", NULL, "Platform Clock"},
0074     {"MIC", NULL, "Platform Clock"},
0075 };
0076
0077 static struct snd_soc_jack_pin card_headset_pins[] = {
0078     {
0079         .pin = "Headphone Jack",
0080         .mask = SND_JACK_HEADPHONE,
0081     },
0082     {
0083         .pin = "Mic Jack",
0084         .mask = SND_JACK_MICROPHONE,
0085     },
0086 };
0087
0088 static int avs_rt274_codec_init(struct snd_soc_pcm_runtime *runtime)
0089 {
0090     struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(runtime, 0);
0091     struct snd_soc_component *component = codec_dai->component;
0092     struct snd_soc_jack_pin *pins;
0093     struct snd_soc_jack *jack;
0094     struct snd_soc_card *card = runtime->card;
0095     int num_pins, ret;
0096
0097     jack = snd_soc_card_get_drvdata(card);
0098     num_pins = ARRAY_SIZE(card_headset_pins);
0099
0100     pins = devm_kmemdup(card->dev, card_headset_pins, sizeof(*pins) * num_pins, GFP_KERNEL);
0101     if (!pins)
0102         return -ENOMEM;
0103
0104     ret = snd_soc_card_jack_new_pins(card, "Headset", SND_JACK_HEADSET, jack, pins, num_pins);
0105     if (ret)
0106         return ret;
0107
0108     snd_soc_component_set_jack(component, jack, NULL);
0109
0110     /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */
0111     ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xF, 0xF, 4, 24);
0112     if (ret < 0) {
0113         dev_err(card->dev, "can't set codec pcm format %d\n", ret);
0114         return ret;
0115     }
0116
0117     card->dapm.idle_bias_off = true;
0118
0119     return 0;
0120 }
0121
0122 static int avs_rt274_be_fixup(struct snd_soc_pcm_runtime *runtime, struct snd_pcm_hw_params *params)
0123 {
0124     struct snd_interval *rate, *channels;
0125     struct snd_mask *fmt;
0126
0127     rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
0128     channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
0129     fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
0130
0131     /* The ADSP will convert the FE rate to 48k, stereo */
0132     rate->min = rate->max = AVS_RT274_BE_FIXUP_RATE;
0133     channels->min = channels->max = 2;
0134
0135     /* set SSPN to 24 bit */
0136     snd_mask_none(fmt);
0137     snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
0138
0139     return 0;
0140 }
0141
0142 static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port,
0143                    struct snd_soc_dai_link **dai_link)
0144 {
0145     struct snd_soc_dai_link_component *platform;
0146     struct snd_soc_dai_link *dl;
0147
0148     dl = devm_kzalloc(dev, sizeof(*dl), GFP_KERNEL);
0149     platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL);
0150     if (!dl || !platform)
0151         return -ENOMEM;
0152
0153     platform->name = platform_name;
0154
0155     dl->name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", ssp_port);
0156     dl->cpus = devm_kzalloc(dev, sizeof(*dl->cpus), GFP_KERNEL);
0157     dl->codecs = devm_kzalloc(dev, sizeof(*dl->codecs), GFP_KERNEL);
0158     if (!dl->name || !dl->cpus || !dl->codecs)
0159         return -ENOMEM;
0160
0161     dl->cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", ssp_port);
0162     dl->codecs->name = devm_kasprintf(dev, GFP_KERNEL, "i2c-INT34C2:00");
0163     dl->codecs->dai_name = devm_kasprintf(dev, GFP_KERNEL, "rt274-aif1");
0164     if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name)
0165         return -ENOMEM;
0166
0167     dl->num_cpus = 1;
0168     dl->num_codecs = 1;
0169     dl->platforms = platform;
0170     dl->num_platforms = 1;
0171     dl->id = 0;
0172     dl->dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS;
0173     dl->init = avs_rt274_codec_init;
0174     dl->be_hw_params_fixup = avs_rt274_be_fixup;
0175     dl->nonatomic = 1;
0176     dl->no_pcm = 1;
0177     dl->dpcm_capture = 1;
0178     dl->dpcm_playback = 1;
0179
0180     *dai_link = dl;
0181
0182     return 0;
0183 }
0184
0185 static int avs_create_dapm_routes(struct device *dev, int ssp_port,
0186                   struct snd_soc_dapm_route **routes, int *num_routes)
0187 {
0188     struct snd_soc_dapm_route *dr;
0189     const int num_base = ARRAY_SIZE(card_base_routes);
0190     const int num_dr = num_base + 2;
0191     int idx;
0192
0193     dr = devm_kcalloc(dev, num_dr, sizeof(*dr), GFP_KERNEL);
0194     if (!dr)
0195         return -ENOMEM;
0196
0197     memcpy(dr, card_base_routes, num_base * sizeof(*dr));
0198
0199     idx = num_base;
0200     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "AIF1 Playback");
0201     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Tx", ssp_port);
0202     if (!dr[idx].sink || !dr[idx].source)
0203         return -ENOMEM;
0204
0205     idx++;
0206     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Rx", ssp_port);
0207     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "AIF1 Capture");
0208     if (!dr[idx].sink || !dr[idx].source)
0209         return -ENOMEM;
0210
0211     *routes = dr;
0212     *num_routes = num_dr;
0213
0214     return 0;
0215 }
0216
0217 static int avs_card_set_jack(struct snd_soc_card *card, struct snd_soc_jack *jack)
0218 {
0219     struct snd_soc_component *component;
0220
0221     for_each_card_components(card, component)
0222         snd_soc_component_set_jack(component, jack, NULL);
0223     return 0;
0224 }
0225
0226 static int avs_card_remove(struct snd_soc_card *card)
0227 {
0228     return avs_card_set_jack(card, NULL);
0229 }
0230
0231 static int avs_card_suspend_pre(struct snd_soc_card *card)
0232 {
0233     return avs_card_set_jack(card, NULL);
0234 }
0235
0236 static int avs_card_resume_post(struct snd_soc_card *card)
0237 {
0238     struct snd_soc_jack *jack = snd_soc_card_get_drvdata(card);
0239
0240     return avs_card_set_jack(card, jack);
0241 }
0242
0243 static int avs_rt274_probe(struct platform_device *pdev)
0244 {
0245     struct snd_soc_dapm_route *routes;
0246     struct snd_soc_dai_link *dai_link;
0247     struct snd_soc_acpi_mach *mach;
0248     struct snd_soc_card *card;
0249     struct snd_soc_jack *jack;
0250     struct device *dev = &pdev->dev;
0251     const char *pname;
0252     int num_routes, ssp_port, ret;
0253
0254     mach = dev_get_platdata(dev);
0255     pname = mach->mach_params.platform;
0256     ssp_port = __ffs(mach->mach_params.i2s_link_mask);
0257
0258     ret = avs_create_dai_link(dev, pname, ssp_port, &dai_link);
0259     if (ret) {
0260         dev_err(dev, "Failed to create dai link: %d", ret);
0261         return ret;
0262     }
0263
0264     ret = avs_create_dapm_routes(dev, ssp_port, &routes, &num_routes);
0265     if (ret) {
0266         dev_err(dev, "Failed to create dapm routes: %d", ret);
0267         return ret;
0268     }
0269
0270     jack = devm_kzalloc(dev, sizeof(*jack), GFP_KERNEL);
0271     card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
0272     if (!jack || !card)
0273         return -ENOMEM;
0274
0275     card->name = "avs_rt274";
0276     card->dev = dev;
0277     card->owner = THIS_MODULE;
0278     card->remove = avs_card_remove;
0279     card->suspend_pre = avs_card_suspend_pre;
0280     card->resume_post = avs_card_resume_post;
0281     card->dai_link = dai_link;
0282     card->num_links = 1;
0283     card->controls = card_controls;
0284     card->num_controls = ARRAY_SIZE(card_controls);
0285     card->dapm_widgets = card_widgets;
0286     card->num_dapm_widgets = ARRAY_SIZE(card_widgets);
0287     card->dapm_routes = routes;
0288     card->num_dapm_routes = num_routes;
0289     card->fully_routed = true;
0290     snd_soc_card_set_drvdata(card, jack);
0291
0292     ret = snd_soc_fixup_dai_links_platform_name(card, pname);
0293     if (ret)
0294         return ret;
0295
0296     return devm_snd_soc_register_card(dev, card);
0297 }
0298
0299 static struct platform_driver avs_rt274_driver = {
0300     .probe = avs_rt274_probe,
0301     .driver = {
0302         .name = "avs_rt274",
0303         .pm = &snd_soc_pm_ops,
0304     },
0305 };
0306
0307 module_platform_driver(avs_rt274_driver);
0308
0309 MODULE_LICENSE("GPL");
0310 MODULE_ALIAS("platform:avs_rt274");