sound/soc/intel/avs/boards/hdaudio.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
   4 //
   5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
   6 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
   7 //
   8
   9 #include <linux/module.h>
  10 #include <linux/platform_device.h>
  11 #include <sound/hda_codec.h>
  12 #include <sound/hda_i915.h>
  13 #include <sound/soc.h>
  14 #include <sound/soc-acpi.h>
  15 #include "../../../codecs/hda.h"
  16
  17 static int avs_create_dai_links(struct device *dev, struct hda_codec *codec, int pcm_count,
  18                                 const char *platform_name, struct snd_soc_dai_link **links)
  19 {
  20         struct snd_soc_dai_link_component *platform;
  21         struct snd_soc_dai_link *dl;
  22         struct hda_pcm *pcm;
  23         const char *cname = dev_name(&codec->core.dev);
  24         int i;
  25
  26         dl = devm_kcalloc(dev, pcm_count, sizeof(*dl), GFP_KERNEL);
  27         platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL);
  28         if (!dl || !platform)
  29                 return -ENOMEM;
  30
  31         platform->name = platform_name;
  32         pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list);
  33
  34         for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) {
  35                 dl[i].name = devm_kasprintf(dev, GFP_KERNEL, "%s link%d", cname, i);
  36                 if (!dl[i].name)
  37                         return -ENOMEM;
  38
  39                 dl[i].id = i;
  40                 dl[i].nonatomic = 1;
  41                 dl[i].no_pcm = 1;
  42                 dl[i].dpcm_playback = 1;
  43                 dl[i].dpcm_capture = 1;
  44                 dl[i].platforms = platform;
  45                 dl[i].num_platforms = 1;
  46                 dl[i].ignore_pmdown_time = 1;
  47
  48                 dl[i].codecs = devm_kzalloc(dev, sizeof(*dl->codecs), GFP_KERNEL);
  49                 dl[i].cpus = devm_kzalloc(dev, sizeof(*dl->cpus), GFP_KERNEL);
  50                 if (!dl[i].codecs || !dl[i].cpus)
  51                         return -ENOMEM;
  52
  53                 dl[i].cpus->dai_name = devm_kasprintf(dev, GFP_KERNEL, "%s-cpu%d", cname, i);
  54                 if (!dl[i].cpus->dai_name)
  55                         return -ENOMEM;
  56
  57                 dl[i].codecs->name = devm_kstrdup(dev, cname, GFP_KERNEL);
  58                 dl[i].codecs->dai_name = pcm->name;
  59                 dl[i].num_codecs = 1;
  60                 dl[i].num_cpus = 1;
  61         }
  62
  63         *links = dl;
  64         return 0;
  65 }
  66
  67 /* Should be aligned with SectionPCM's name from topology */
  68 #define FEDAI_NAME_PREFIX "HDMI"
  69
  70 static struct snd_pcm *
  71 avs_card_hdmi_pcm_at(struct snd_soc_card *card, int hdmi_idx)
  72 {
  73         struct snd_soc_pcm_runtime *rtd;
  74         int dir = SNDRV_PCM_STREAM_PLAYBACK;
  75
  76         for_each_card_rtds(card, rtd) {
  77                 struct snd_pcm *spcm;
  78                 int ret, n;
  79
  80                 spcm = rtd->pcm ? rtd->pcm->streams[dir].pcm : NULL;
  81                 if (!spcm || !strstr(spcm->id, FEDAI_NAME_PREFIX))
  82                         continue;
  83
  84                 ret = sscanf(spcm->id, FEDAI_NAME_PREFIX "%d", &n);
  85                 if (ret != 1)
  86                         continue;
  87                 if (n == hdmi_idx)
  88                         return rtd->pcm;
  89         }
  90
  91         return NULL;
  92 }
  93
  94 static int avs_card_late_probe(struct snd_soc_card *card)
  95 {
  96         struct snd_soc_acpi_mach *mach = dev_get_platdata(card->dev);
  97         struct hda_codec *codec = mach->pdata;
  98         struct hda_pcm *hpcm;
  99         /* Topology pcm indexing is 1-based */
 100         int i = 1;
 101
 102         list_for_each_entry(hpcm, &codec->pcm_list_head, list) {
 103                 struct snd_pcm *spcm;
 104
 105                 spcm = avs_card_hdmi_pcm_at(card, i);
 106                 if (spcm) {
 107                         hpcm->pcm = spcm;
 108                         hpcm->device = spcm->device;
 109                         dev_info(card->dev, "%s: mapping HDMI converter %d to PCM %d (%p)\n",
 110                                  __func__, i, hpcm->device, spcm);
 111                 } else {
 112                         hpcm->pcm = NULL;
 113                         hpcm->device = SNDRV_PCM_INVALID_DEVICE;
 114                         dev_warn(card->dev, "%s: no PCM in topology for HDMI converter %d\n",
 115                                  __func__, i);
 116                 }
 117                 i++;
 118         }
 119
 120         return hda_codec_probe_complete(codec);
 121 }
 122
 123 static int avs_probing_link_init(struct snd_soc_pcm_runtime *rtm)
 124 {
 125         struct snd_soc_acpi_mach *mach;
 126         struct snd_soc_dai_link *links = NULL;
 127         struct snd_soc_card *card = rtm->card;
 128         struct hda_codec *codec;
 129         struct hda_pcm *pcm;
 130         int ret, pcm_count = 0;
 131
 132         mach = dev_get_platdata(card->dev);
 133         codec = mach->pdata;
 134
 135         if (list_empty(&codec->pcm_list_head))
 136                 return -EINVAL;
 137         list_for_each_entry(pcm, &codec->pcm_list_head, list)
 138                 pcm_count++;
 139
 140         ret = avs_create_dai_links(card->dev, codec, pcm_count, mach->mach_params.platform, &links);
 141         if (ret < 0) {
 142                 dev_err(card->dev, "create links failed: %d\n", ret);
 143                 return ret;
 144         }
 145
 146         ret = snd_soc_add_pcm_runtimes(card, links, pcm_count);
 147         if (ret < 0) {
 148                 dev_err(card->dev, "add links failed: %d\n", ret);
 149                 return ret;
 150         }
 151
 152         return 0;
 153 }
 154
 155 SND_SOC_DAILINK_DEF(dummy, DAILINK_COMP_ARRAY(COMP_DUMMY()));
 156
 157 static struct snd_soc_dai_link probing_link = {
 158         .name = "probing-LINK",
 159         .id = -1,
 160         .nonatomic = 1,
 161         .no_pcm = 1,
 162         .dpcm_playback = 1,
 163         .dpcm_capture = 1,
 164         .cpus = dummy,
 165         .num_cpus = ARRAY_SIZE(dummy),
 166         .init = avs_probing_link_init,
 167 };
 168
 169 static int avs_hdaudio_probe(struct platform_device *pdev)
 170 {
 171         struct snd_soc_dai_link *binder;
 172         struct snd_soc_acpi_mach *mach;
 173         struct snd_soc_card *card;
 174         struct device *dev = &pdev->dev;
 175         struct hda_codec *codec;
 176
 177         mach = dev_get_platdata(dev);
 178         codec = mach->pdata;
 179
 180         /* codec may be unloaded before card's probe() fires */
 181         if (!device_is_registered(&codec->core.dev))
 182                 return -ENODEV;
 183
 184         binder = devm_kmemdup(dev, &probing_link, sizeof(probing_link), GFP_KERNEL);
 185         if (!binder)
 186                 return -ENOMEM;
 187
 188         binder->platforms = devm_kzalloc(dev, sizeof(*binder->platforms), GFP_KERNEL);
 189         binder->codecs = devm_kzalloc(dev, sizeof(*binder->codecs), GFP_KERNEL);
 190         if (!binder->platforms || !binder->codecs)
 191                 return -ENOMEM;
 192
 193         binder->codecs->name = devm_kstrdup(dev, dev_name(&codec->core.dev), GFP_KERNEL);
 194         if (!binder->codecs->name)
 195                 return -ENOMEM;
 196
 197         binder->platforms->name = mach->mach_params.platform;
 198         binder->num_platforms = 1;
 199         binder->codecs->dai_name = "codec-probing-DAI";
 200         binder->num_codecs = 1;
 201
 202         card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL);
 203         if (!card)
 204                 return -ENOMEM;
 205
 206         card->name = binder->codecs->name;
 207         card->dev = dev;
 208         card->owner = THIS_MODULE;
 209         card->dai_link = binder;
 210         card->num_links = 1;
 211         card->fully_routed = true;
 212         if (hda_codec_is_display(codec))
 213                 card->late_probe = avs_card_late_probe;
 214
 215         return devm_snd_soc_register_card(dev, card);
 216 }
 217
 218 static struct platform_driver avs_hdaudio_driver = {
 219         .probe = avs_hdaudio_probe,
 220         .driver = {
 221                 .name = "avs_hdaudio",
 222                 .pm = &snd_soc_pm_ops,
 223         },
 224 };
 225
 226 module_platform_driver(avs_hdaudio_driver)
 227
 228 MODULE_DESCRIPTION("Intel HD-Audio machine driver");
 229 MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
 230 MODULE_LICENSE("GPL");
 231 MODULE_ALIAS("platform:avs_hdaudio");