avs/boards/nau8825.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/input.h>
0010 #include <linux/module.h>
0011 #include <linux/platform_device.h>
0012 #include <sound/core.h>
0013 #include <sound/jack.h>
0014 #include <sound/pcm.h>
0015 #include <sound/pcm_params.h>
0016 #include <sound/soc.h>
0017 #include <sound/soc-acpi.h>
0018 #include "../../../codecs/nau8825.h"
0019
0020 #define SKL_NUVOTON_CODEC_DAI   "nau8825-hifi"
0021
0022 static int
0023 avs_nau8825_clock_control(struct snd_soc_dapm_widget *w, struct snd_kcontrol *control, int event)
0024 {
0025     struct snd_soc_dapm_context *dapm = w->dapm;
0026     struct snd_soc_card *card = dapm->card;
0027     struct snd_soc_dai *codec_dai;
0028     int ret;
0029
0030     codec_dai = snd_soc_card_get_codec_dai(card, SKL_NUVOTON_CODEC_DAI);
0031     if (!codec_dai) {
0032         dev_err(card->dev, "Codec dai not found\n");
0033         return -EINVAL;
0034     }
0035
0036     if (!SND_SOC_DAPM_EVENT_ON(event)) {
0037         ret = snd_soc_dai_set_sysclk(codec_dai, NAU8825_CLK_INTERNAL, 0, SND_SOC_CLOCK_IN);
0038         if (ret < 0) {
0039             dev_err(card->dev, "set sysclk err = %d\n", ret);
0040             return ret;
0041         }
0042     }
0043
0044     return 0;
0045 }
0046
0047 static const struct snd_kcontrol_new card_controls[] = {
0048     SOC_DAPM_PIN_SWITCH("Headphone Jack"),
0049     SOC_DAPM_PIN_SWITCH("Headset Mic"),
0050 };
0051
0052 static const struct snd_soc_dapm_widget card_widgets[] = {
0053     SND_SOC_DAPM_HP("Headphone Jack", NULL),
0054     SND_SOC_DAPM_MIC("Headset Mic", NULL),
0055     SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, avs_nau8825_clock_control,
0056                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
0057 };
0058
0059 static const struct snd_soc_dapm_route card_base_routes[] = {
0060     { "Headphone Jack", NULL, "HPOL" },
0061     { "Headphone Jack", NULL, "HPOR" },
0062
0063     { "MIC", NULL, "Headset Mic" },
0064
0065     { "Headphone Jack", NULL, "Platform Clock" },
0066     { "Headset Mic", NULL, "Platform Clock" },
0067 };
0068
0069 static struct snd_soc_jack_pin card_headset_pins[] = {
0070     {
0071         .pin = "Headphone Jack",
0072         .mask = SND_JACK_HEADPHONE,
0073     },
0074     {
0075         .pin = "Headset Mic",
0076         .mask = SND_JACK_MICROPHONE,
0077     },
0078 };
0079
0080 static int avs_nau8825_codec_init(struct snd_soc_pcm_runtime *runtime)
0081 {
0082     struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(runtime, 0);
0083     struct snd_soc_component *component = codec_dai->component;
0084     struct snd_soc_jack_pin *pins;
0085     struct snd_soc_jack *jack;
0086     struct snd_soc_card *card = runtime->card;
0087     int num_pins, ret;
0088
0089     jack = snd_soc_card_get_drvdata(card);
0090     num_pins = ARRAY_SIZE(card_headset_pins);
0091
0092     pins = devm_kmemdup(card->dev, card_headset_pins, sizeof(*pins) * num_pins, GFP_KERNEL);
0093     if (!pins)
0094         return -ENOMEM;
0095
0096     /*
0097      * 4 buttons here map to the google Reference headset.
0098      * The use of these buttons can be decided by the user space.
0099      */
0100     ret = snd_soc_card_jack_new_pins(card, "Headset", SND_JACK_HEADSET | SND_JACK_BTN_0 |
0101                      SND_JACK_BTN_1 | SND_JACK_BTN_2 | SND_JACK_BTN_3,
0102                      jack, pins, num_pins);
0103     if (ret)
0104         return ret;
0105
0106     snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
0107     snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
0108     snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
0109     snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
0110
0111     //snd_soc_component_set_jack(component, jack, NULL);
0112     // TODO: Fix nau8825 codec to use .set_jack, like everyone else
0113     nau8825_enable_jack_detect(component, jack);
0114
0115     return 0;
0116 }
0117
0118 static int
0119 avs_nau8825_be_fixup(struct snd_soc_pcm_runtime *runtime, struct snd_pcm_hw_params *params)
0120 {
0121     struct snd_interval *rate, *channels;
0122     struct snd_mask *fmt;
0123
0124     rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
0125     channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
0126     fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
0127
0128     /* The ADSP will convert the FE rate to 48k, stereo */
0129     rate->min = rate->max = 48000;
0130     channels->min = channels->max = 2;
0131
0132     /* set SSP to 24 bit */
0133     snd_mask_none(fmt);
0134     snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S24_LE);
0135
0136     return 0;
0137 }
0138
0139 static int avs_nau8825_trigger(struct snd_pcm_substream *substream, int cmd)
0140 {
0141     struct snd_pcm_runtime *runtime = substream->runtime;
0142     struct snd_soc_pcm_runtime *rtm = asoc_substream_to_rtd(substream);
0143     struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtm, 0);
0144     int ret = 0;
0145
0146     switch (cmd) {
0147     case SNDRV_PCM_TRIGGER_START:
0148         ret = snd_soc_dai_set_sysclk(codec_dai, NAU8825_CLK_FLL_FS, 0, SND_SOC_CLOCK_IN);
0149         if (ret < 0) {
0150             dev_err(codec_dai->dev, "can't set FS clock %d\n", ret);
0151             break;
0152         }
0153
0154         ret = snd_soc_dai_set_pll(codec_dai, 0, 0, runtime->rate, runtime->rate * 256);
0155         if (ret < 0)
0156             dev_err(codec_dai->dev, "can't set FLL: %d\n", ret);
0157         break;
0158
0159     case SNDRV_PCM_TRIGGER_RESUME:
0160         ret = snd_soc_dai_set_pll(codec_dai, 0, 0, runtime->rate, runtime->rate * 256);
0161         if (ret < 0)
0162             dev_err(codec_dai->dev, "can't set FLL: %d\n", ret);
0163         break;
0164     }
0165
0166     return ret;
0167 }
0168
0169
0170 static const struct snd_soc_ops avs_nau8825_ops = {
0171     .trigger = avs_nau8825_trigger,
0172 };
0173
0174 static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port,
0175                    struct snd_soc_dai_link **dai_link)
0176 {
0177     struct snd_soc_dai_link_component *platform;
0178     struct snd_soc_dai_link *dl;
0179
0180     dl = devm_kzalloc(dev, sizeof(*dl), GFP_KERNEL);
0181     platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL);
0182     if (!dl || !platform)
0183         return -ENOMEM;
0184
0185     platform->name = platform_name;
0186
0187     dl->name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", ssp_port);
0188     dl->cpus = devm_kzalloc(dev, sizeof(*dl->cpus), GFP_KERNEL);
0189     dl->codecs = devm_kzalloc(dev, sizeof(*dl->codecs), GFP_KERNEL);
0190     if (!dl->name || !dl->cpus || !dl->codecs)
0191         return -ENOMEM;
0192
0193     dl->cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d Pin", ssp_port);
0194     dl->codecs->name = devm_kasprintf(dev, GFP_KERNEL, "i2c-10508825:00");
0195     dl->codecs->dai_name = devm_kasprintf(dev, GFP_KERNEL, SKL_NUVOTON_CODEC_DAI);
0196     if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name)
0197         return -ENOMEM;
0198
0199     dl->num_cpus = 1;
0200     dl->num_codecs = 1;
0201     dl->platforms = platform;
0202     dl->num_platforms = 1;
0203     dl->id = 0;
0204     dl->dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS;
0205     dl->init = avs_nau8825_codec_init;
0206     dl->be_hw_params_fixup = avs_nau8825_be_fixup;
0207     dl->ops = &avs_nau8825_ops;
0208     dl->nonatomic = 1;
0209     dl->no_pcm = 1;
0210     dl->dpcm_capture = 1;
0211     dl->dpcm_playback = 1;
0212
0213     *dai_link = dl;
0214
0215     return 0;
0216 }
0217
0218 static int avs_create_dapm_routes(struct device *dev, int ssp_port,
0219                   struct snd_soc_dapm_route **routes, int *num_routes)
0220 {
0221     struct snd_soc_dapm_route *dr;
0222     const int num_base = ARRAY_SIZE(card_base_routes);
0223     const int num_dr = num_base + 2;
0224     int idx;
0225
0226     dr = devm_kcalloc(dev, num_dr, sizeof(*dr), GFP_KERNEL);
0227     if (!dr)
0228         return -ENOMEM;
0229
0230     memcpy(dr, card_base_routes, num_base * sizeof(*dr));
0231
0232     idx = num_base;
0233     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "Playback");
0234     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Tx", ssp_port);
0235     if (!dr[idx].sink || !dr[idx].source)
0236         return -ENOMEM;
0237
0238     idx++;
0239     dr[idx].sink = devm_kasprintf(dev, GFP_KERNEL, "ssp%d Rx", ssp_port);
0240     dr[idx].source = devm_kasprintf(dev, GFP_KERNEL, "Capture");
0241     if (!dr[idx].sink || !dr[idx].source)
0242         return -ENOMEM;
0243
0244     *routes = dr;
0245     *num_routes = num_dr;
0246
0247     return 0;
0248 }
0249
0250 static int avs_card_set_jack(struct snd_soc_card *card, struct snd_soc_jack *jack)
0251 {
0252     struct snd_soc_component *component;
0253
0254     for_each_card_components(card, component)
0255         snd_soc_component_set_jack(component, jack, NULL);
0256     return 0;
0257 }
0258
0259 static int avs_card_remove(struct snd_soc_card *card)
0260 {
0261     return avs_card_set_jack(card, NULL);
0262 }
0263
0264 static int avs_card_suspend_pre(struct snd_soc_card *card)
0265 {
0266     return avs_card_set_jack(card, NULL);
0267 }
0268
0269 static int avs_card_resume_post(struct snd_soc_card *card)
0270 {
0271     struct snd_soc_dai *codec_dai = snd_soc_card_get_codec_dai(card, SKL_NUVOTON_CODEC_DAI);
0272     struct snd_soc_jack *jack = snd_soc_card_get_drvdata(card);
0273
0274     if (!codec_dai) {
0275         dev_err(card->dev, "Codec dai not found\n");
0276         return -EINVAL;
0277     }
0278
0279     if (codec_dai->stream_active[SNDRV_PCM_STREAM_PLAYBACK] &&
0280         codec_dai->playback_widget->active)
0281         snd_soc_dai_set_sysclk(codec_dai, NAU8825_CLK_FLL_FS, 0, SND_SOC_CLOCK_IN);
0282
0283     return avs_card_set_jack(card, jack);
0284 }
0285
0286 static int avs_nau8825_probe(struct platform_device *pdev)
0287 {
0288     struct snd_soc_dapm_route *routes;
0289     struct snd_soc_dai_link *dai_link;
0290     struct snd_soc_acpi_mach *mach;
0291     struct snd_soc_card *card;
0292     struct snd_soc_jack *jack;
0293     struct device *dev = &pdev->dev;
0294     const char *pname;
0295     int num_routes, ssp_port, ret;
0296
0297     mach = dev_get_platdata(dev);
0298     pname = mach->mach_params.platform;
0299     ssp_port = __ffs(mach->mach_params.i2s_link_mask);
0300
0301     ret = avs_create_dai_link(dev, pname, ssp_port, &dai_link);
0302     if (ret) {
0303         dev_err(dev, "Failed to create dai link: %d", ret);
0304         return ret;
0305     }
0306
0307     ret = avs_create_dapm_routes(dev, ssp_port, &routes, &num_routes);
0308     if (ret) {
0309         dev_err(dev, "Failed to create dapm routes: %d", ret);
0310         return ret;
0311     }
0312
0313     jack = devm_kzalloc(dev, sizeof(*jack), GFP_KERNEL);
0314     card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
0315     if (!jack || !card)
0316         return -ENOMEM;
0317
0318     card->name = "avs_nau8825";
0319     card->dev = dev;
0320     card->owner = THIS_MODULE;
0321     card->remove = avs_card_remove;
0322     card->suspend_pre = avs_card_suspend_pre;
0323     card->resume_post = avs_card_resume_post;
0324     card->dai_link = dai_link;
0325     card->num_links = 1;
0326     card->controls = card_controls;
0327     card->num_controls = ARRAY_SIZE(card_controls);
0328     card->dapm_widgets = card_widgets;
0329     card->num_dapm_widgets = ARRAY_SIZE(card_widgets);
0330     card->dapm_routes = routes;
0331     card->num_dapm_routes = num_routes;
0332     card->fully_routed = true;
0333     snd_soc_card_set_drvdata(card, jack);
0334
0335     ret = snd_soc_fixup_dai_links_platform_name(card, pname);
0336     if (ret)
0337         return ret;
0338
0339     return devm_snd_soc_register_card(dev, card);
0340 }
0341
0342 static struct platform_driver avs_nau8825_driver = {
0343     .probe = avs_nau8825_probe,
0344     .driver = {
0345         .name = "avs_nau8825",
0346         .pm = &snd_soc_pm_ops,
0347     },
0348 };
0349
0350 module_platform_driver(avs_nau8825_driver)
0351
0352 MODULE_LICENSE("GPL");
0353 MODULE_ALIAS("platform:avs_nau8825");