avs/boards/rt298.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/rt298.h"
0016
0017 static const struct snd_kcontrol_new card_controls[] = {
0018     SOC_DAPM_PIN_SWITCH("Headphone Jack"),
0019     SOC_DAPM_PIN_SWITCH("Mic Jack"),
0020     SOC_DAPM_PIN_SWITCH("Speaker"),
0021 };
0022
0023 static const struct snd_soc_dapm_widget card_widgets[] = {
0024     SND_SOC_DAPM_HP("Headphone Jack", NULL),
0025     SND_SOC_DAPM_MIC("Mic Jack", NULL),
0026     SND_SOC_DAPM_SPK("Speaker", NULL),
0027 };
0028
0029 static const struct snd_soc_dapm_route card_base_routes[] = {
0030     /* HP jack connectors - unknown if we have jack detect */
0031     {"Headphone Jack", NULL, "HPO Pin"},
0032     {"MIC1", NULL, "Mic Jack"},
0033
0034     {"Speaker", NULL, "SPOR"},
0035     {"Speaker", NULL, "SPOL"},
0036 };
0037
0038 static struct snd_soc_jack_pin card_headset_pins[] = {
0039     {
0040         .pin = "Headphone Jack",
0041         .mask = SND_JACK_HEADPHONE,
0042     },
0043     {
0044         .pin = "Mic Jack",
0045         .mask = SND_JACK_MICROPHONE,
0046     },
0047 };
0048
0049 static int avs_rt298_codec_init(struct snd_soc_pcm_runtime *runtime)
0050 {
0051     struct snd_soc_component *component = asoc_rtd_to_codec(runtime, 0)->component;
0052     struct snd_soc_jack_pin *pins;
0053     struct snd_soc_jack *jack;
0054     struct snd_soc_card *card = runtime->card;
0055     int num_pins, ret;
0056
0057     jack = snd_soc_card_get_drvdata(card);
0058     num_pins = ARRAY_SIZE(card_headset_pins);
0059
0060     pins = devm_kmemdup(card->dev, card_headset_pins, sizeof(*pins) * num_pins, GFP_KERNEL);
0061     if (!pins)
0062         return -ENOMEM;
0063
0064     ret = snd_soc_card_jack_new_pins(card, "Headset", SND_JACK_HEADSET | SND_JACK_BTN_0, jack,
0065                      pins, num_pins);
0066     if (ret)
0067         return ret;
0068
0069     snd_soc_component_set_jack(component, jack, NULL);
0070
0071     return 0;
0072 }
0073
0074 static int avs_rt298_be_fixup(struct snd_soc_pcm_runtime *runtime, struct snd_pcm_hw_params *params)
0075 {
0076     struct snd_interval *rate, *channels;
0077     struct snd_mask *fmt;
0078
0079     rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
0080     channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
0081     fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
0082
0083     /* The ADSP will convert the FE rate to 48k, stereo */
0084     rate->min = rate->max = 48000;
0085     channels->min = channels->max = 2;
0086
0087     /* set SSP0 to 24 bit */
0088     snd_mask_none(fmt);
0089     snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
0090
0091     return 0;
0092 }
0093
0094 static int
0095 avs_rt298_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params)
0096 {
0097     struct snd_soc_pcm_runtime *rtd = substream->private_data;
0098     struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
0099     int ret;
0100
0101     ret = snd_soc_dai_set_sysclk(codec_dai, RT298_SCLK_S_PLL, 19200000, SND_SOC_CLOCK_IN);
0102     if (ret < 0)
0103         dev_err(rtd->dev, "Set codec sysclk failed: %d\n", ret);
0104
0105     return ret;
0106 }
0107
0108 static const struct snd_soc_ops avs_rt298_ops = {
0109     .hw_params = avs_rt298_hw_params,
0110 };
0111
0112 static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port,
0113                    struct snd_soc_dai_link **dai_link)
0114 {
0115     struct snd_soc_dai_link_component *platform;
0116     struct snd_soc_dai_link *dl;
0117
0118     dl = devm_kzalloc(dev, sizeof(*dl), GFP_KERNEL);
0119     platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL);
0120     if (!dl || !platform)
0121         return -ENOMEM;
0122
0123     platform->name = platform_name;
0124
0125     dl->name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", ssp_port);
0126     dl->cpus = devm_kzalloc(dev, sizeof(*dl->cpus), GFP_KERNEL);
0127     dl->codecs = devm_kzalloc(dev, sizeof(*dl->codecs), GFP_KERNEL);
0128     if (!dl->name || !dl->cpus || !dl->codecs)
0129         return -ENOMEM;
0130
0131     dl->cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", ssp_port);
0132     dl->codecs->name = devm_kasprintf(dev, GFP_KERNEL, "i2c-INT343A:00");
0133     dl->codecs->dai_name = devm_kasprintf(dev, GFP_KERNEL, "rt298-aif1");
0134     if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name)
0135         return -ENOMEM;
0136
0137     dl->num_cpus = 1;
0138     dl->num_codecs = 1;
0139     dl->platforms = platform;
0140     dl->num_platforms = 1;
0141     dl->id = 0;
0142     dl->dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS;
0143     dl->init = avs_rt298_codec_init;
0144     dl->be_hw_params_fixup = avs_rt298_be_fixup;
0145     dl->ops = &avs_rt298_ops;
0146     dl->nonatomic = 1;
0147     dl->no_pcm = 1;
0148     dl->dpcm_capture = 1;
0149     dl->dpcm_playback = 1;
0150
0151     *dai_link = dl;
0152
0153     return 0;
0154 }
0155
0156 static int avs_create_dapm_routes(struct device *dev, int ssp_port,
0157                   struct snd_soc_dapm_route **routes, int *num_routes)
0158 {
0159     struct snd_soc_dapm_route *dr;
0160     const int num_base = ARRAY_SIZE(card_base_routes);
0161     const int num_dr = num_base + 2;
0162     int idx;
0163
0164     dr = devm_kcalloc(dev, num_dr, sizeof(*dr), GFP_KERNEL);
0165     if (!dr)
0166         return -ENOMEM;
0167
0168     memcpy(dr, card_base_routes, num_base * sizeof(*dr));
0169
0170     idx = num_base;
0171     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "AIF1 Playback");
0172     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Tx", ssp_port);
0173     if (!dr[idx].sink || !dr[idx].source)
0174         return -ENOMEM;
0175
0176     idx++;
0177     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Rx", ssp_port);
0178     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "AIF1 Capture");
0179     if (!dr[idx].sink || !dr[idx].source)
0180         return -ENOMEM;
0181
0182     *routes = dr;
0183     *num_routes = num_dr;
0184
0185     return 0;
0186 }
0187
0188 static int avs_card_set_jack(struct snd_soc_card *card, struct snd_soc_jack *jack)
0189 {
0190     struct snd_soc_component *component;
0191
0192     for_each_card_components(card, component)
0193         snd_soc_component_set_jack(component, jack, NULL);
0194     return 0;
0195 }
0196
0197 static int avs_card_remove(struct snd_soc_card *card)
0198 {
0199     return avs_card_set_jack(card, NULL);
0200 }
0201
0202 static int avs_card_suspend_pre(struct snd_soc_card *card)
0203 {
0204     return avs_card_set_jack(card, NULL);
0205 }
0206
0207 static int avs_card_resume_post(struct snd_soc_card *card)
0208 {
0209     struct snd_soc_jack *jack = snd_soc_card_get_drvdata(card);
0210
0211     return avs_card_set_jack(card, jack);
0212 }
0213
0214 static int avs_rt298_probe(struct platform_device *pdev)
0215 {
0216     struct snd_soc_dapm_route *routes;
0217     struct snd_soc_dai_link *dai_link;
0218     struct snd_soc_acpi_mach *mach;
0219     struct snd_soc_card *card;
0220     struct snd_soc_jack *jack;
0221     struct device *dev = &pdev->dev;
0222     const char *pname;
0223     int num_routes, ssp_port, ret;
0224
0225     mach = dev_get_platdata(dev);
0226     pname = mach->mach_params.platform;
0227     ssp_port = __ffs(mach->mach_params.i2s_link_mask);
0228
0229     ret = avs_create_dai_link(dev, pname, ssp_port, &dai_link);
0230     if (ret) {
0231         dev_err(dev, "Failed to create dai link: %d", ret);
0232         return ret;
0233     }
0234
0235     ret = avs_create_dapm_routes(dev, ssp_port, &routes, &num_routes);
0236     if (ret) {
0237         dev_err(dev, "Failed to create dapm routes: %d", ret);
0238         return ret;
0239     }
0240
0241     jack = devm_kzalloc(dev, sizeof(*jack), GFP_KERNEL);
0242     card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
0243     if (!jack || !card)
0244         return -ENOMEM;
0245
0246     card->name = "avs_rt298";
0247     card->dev = dev;
0248     card->owner = THIS_MODULE;
0249     card->remove = avs_card_remove;
0250     card->suspend_pre = avs_card_suspend_pre;
0251     card->resume_post = avs_card_resume_post;
0252     card->dai_link = dai_link;
0253     card->num_links = 1;
0254     card->controls = card_controls;
0255     card->num_controls = ARRAY_SIZE(card_controls);
0256     card->dapm_widgets = card_widgets;
0257     card->num_dapm_widgets = ARRAY_SIZE(card_widgets);
0258     card->dapm_routes = routes;
0259     card->num_dapm_routes = num_routes;
0260     card->fully_routed = true;
0261     snd_soc_card_set_drvdata(card, jack);
0262
0263     ret = snd_soc_fixup_dai_links_platform_name(card, pname);
0264     if (ret)
0265         return ret;
0266
0267     return devm_snd_soc_register_card(dev, card);
0268 }
0269
0270 static struct platform_driver avs_rt298_driver = {
0271     .probe = avs_rt298_probe,
0272     .driver = {
0273         .name = "avs_rt298",
0274         .pm = &snd_soc_pm_ops,
0275     },
0276 };
0277
0278 module_platform_driver(avs_rt298_driver);
0279
0280 MODULE_LICENSE("GPL");
0281 MODULE_ALIAS("platform:avs_rt298");