tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ASoC: Intel: avs: Adjust platform names

Merge series from Cezary Rojewski <cezary.rojewski@intel.com>:

This series is a direct follow up to the recent
machine-board-registration changes [1]. Initially, a number of smaller
patchsets were part of a bigger block of changes. My attempt to split
them up to make the review easier was unfortunately not successful [2].

The goal of this series is the same one as with [1] - allow for multiple
cards of the same type without workarounds or code duplications.
With the machine-board names being unique - thanks to
PLATFORM_DEVID_AUTO - platform component names shall be adjusted too so
that no misbindings happen.

In essence, majority of the changes can be summarized as: simplifying
card and dai_link initialization. Actions:

- drop mach->mach_params.platform usage
- drop snd_soc_fixup_dai_links_platform_name() usage
- for the probe-board mach-context is dropped entirely. The panic [2] is
gone

[1]: https://lore.kernel.org/linux-sound/20250827142229.869139-1-cezary.rojewski@intel.com/
[2]: https://lore.kernel.org/linux-sound/20250829225532.GA400117@ax162/

Mark Brown 09be5b1c ce1a46b2

+143 -210
+4 -11
sound/soc/intel/avs/boards/da7219.c
··· 165 165 return 0; 166 166 } 167 167 168 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 169 - int tdm_slot, struct snd_soc_dai_link **dai_link) 168 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 169 + struct snd_soc_dai_link **dai_link) 170 170 { 171 171 struct snd_soc_dai_link_component *platform; 172 172 struct snd_soc_dai_link *dl; ··· 175 175 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 176 176 if (!dl || !platform) 177 177 return -ENOMEM; 178 - 179 - platform->name = platform_name; 180 178 181 179 dl->name = devm_kasprintf(dev, GFP_KERNEL, "SSP%d-Codec", ssp_port); 182 180 dl->name = devm_kasprintf(dev, GFP_KERNEL, ··· 191 193 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 192 194 return -ENOMEM; 193 195 196 + platform->name = dev_name(dev); 194 197 dl->num_cpus = 1; 195 198 dl->num_codecs = 1; 196 199 dl->platforms = platform; ··· 217 218 struct snd_soc_card *card; 218 219 struct snd_soc_jack *jack; 219 220 struct device *dev = &pdev->dev; 220 - const char *pname; 221 221 int ssp_port, tdm_slot, ret; 222 222 223 223 mach = dev_get_platdata(dev); 224 - pname = mach->mach_params.platform; 225 224 pdata = mach->pdata; 226 225 227 226 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 228 227 if (ret) 229 228 return ret; 230 229 231 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 230 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 232 231 if (ret) { 233 232 dev_err(dev, "Failed to create dai link: %d", ret); 234 233 return ret; ··· 255 258 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 256 259 card->fully_routed = true; 257 260 snd_soc_card_set_drvdata(card, jack); 258 - 259 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 260 - if (ret) 261 - return ret; 262 261 263 262 return devm_snd_soc_register_deferrable_card(dev, card); 264 263 }
+49 -31
sound/soc/intel/avs/boards/dmic.c
··· 14 14 15 15 SND_SOC_DAILINK_DEF(dmic_pin, DAILINK_COMP_ARRAY(COMP_CPU("DMIC Pin"))); 16 16 SND_SOC_DAILINK_DEF(dmic_wov_pin, DAILINK_COMP_ARRAY(COMP_CPU("DMIC WoV Pin"))); 17 - SND_SOC_DAILINK_DEF(dmic_codec, DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi"))); 18 - /* Name overridden on probe */ 19 - SND_SOC_DAILINK_DEF(platform, DAILINK_COMP_ARRAY(COMP_PLATFORM(""))); 20 - 21 - static struct snd_soc_dai_link card_dai_links[] = { 22 - /* Back ends */ 23 - { 24 - .name = "DMIC", 25 - .id = 0, 26 - .capture_only = 1, 27 - .nonatomic = 1, 28 - .no_pcm = 1, 29 - SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform), 30 - }, 31 - { 32 - .name = "DMIC WoV", 33 - .id = 1, 34 - .capture_only = 1, 35 - .nonatomic = 1, 36 - .no_pcm = 1, 37 - .ignore_suspend = 1, 38 - SND_SOC_DAILINK_REG(dmic_wov_pin, dmic_codec, platform), 39 - }, 40 - }; 41 17 42 18 static const struct snd_soc_dapm_widget card_widgets[] = { 43 19 SND_SOC_DAPM_MIC("SoC DMIC", NULL), ··· 23 47 {"DMic", NULL, "SoC DMIC"}, 24 48 }; 25 49 50 + static int avs_create_dai_links(struct device *dev, const char *codec_name, 51 + struct snd_soc_dai_link **links, int *num_links) 52 + { 53 + struct snd_soc_dai_link_component *platform; 54 + struct snd_soc_dai_link *dl; 55 + const int num_dl = 2; 56 + 57 + dl = devm_kcalloc(dev, num_dl, sizeof(*dl), GFP_KERNEL); 58 + platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 59 + if (!dl || !platform) 60 + return -ENOMEM; 61 + 62 + dl->codecs = devm_kzalloc(dev, sizeof(*dl->codecs), GFP_KERNEL); 63 + if (!dl->codecs) 64 + return -ENOMEM; 65 + 66 + dl->codecs->name = devm_kstrdup(dev, codec_name, GFP_KERNEL); 67 + dl->codecs->dai_name = devm_kasprintf(dev, GFP_KERNEL, "dmic-hifi"); 68 + if (!dl->codecs->name || !dl->codecs->dai_name) 69 + return -ENOMEM; 70 + 71 + platform->name = dev_name(dev); 72 + dl[0].num_cpus = 1; 73 + dl[0].num_codecs = 1; 74 + dl[0].platforms = platform; 75 + dl[0].num_platforms = 1; 76 + dl[0].nonatomic = 1; 77 + dl[0].no_pcm = 1; 78 + dl[0].capture_only = 1; 79 + memcpy(&dl[1], &dl[0], sizeof(*dl)); 80 + 81 + dl[0].name = "DMIC"; 82 + dl[0].cpus = dmic_pin; 83 + dl[0].id = 0; 84 + dl[1].name = "DMIC WoV"; 85 + dl[1].cpus = dmic_wov_pin; 86 + dl[1].id = 1; 87 + dl[1].ignore_suspend = 1; 88 + 89 + *links = dl; 90 + *num_links = num_dl; 91 + return 0; 92 + } 93 + 26 94 static int avs_dmic_probe(struct platform_device *pdev) 27 95 { 96 + struct device *dev = &pdev->dev; 28 97 struct snd_soc_acpi_mach *mach; 29 98 struct avs_mach_pdata *pdata; 30 99 struct snd_soc_card *card; 31 - struct device *dev = &pdev->dev; 32 100 int ret; 33 101 34 102 mach = dev_get_platdata(dev); ··· 82 62 if (!card) 83 63 return -ENOMEM; 84 64 65 + ret = avs_create_dai_links(dev, pdata->codec_name, &card->dai_link, &card->num_links); 66 + if (ret) 67 + return ret; 68 + 85 69 if (pdata->obsolete_card_names) { 86 70 card->name = "avs_dmic"; 87 71 } else { ··· 94 70 } 95 71 card->dev = dev; 96 72 card->owner = THIS_MODULE; 97 - card->dai_link = card_dai_links; 98 - card->num_links = ARRAY_SIZE(card_dai_links); 99 73 card->dapm_widgets = card_widgets; 100 74 card->num_dapm_widgets = ARRAY_SIZE(card_widgets); 101 75 card->dapm_routes = card_routes; 102 76 card->num_dapm_routes = ARRAY_SIZE(card_routes); 103 77 card->fully_routed = true; 104 - 105 - ret = snd_soc_fixup_dai_links_platform_name(card, mach->mach_params.platform); 106 - if (ret) 107 - return ret; 108 78 109 79 return devm_snd_soc_register_deferrable_card(dev, card); 110 80 }
+5 -11
sound/soc/intel/avs/boards/es8336.c
··· 195 195 196 196 return 0; 197 197 } 198 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 199 - int tdm_slot, struct snd_soc_dai_link **dai_link) 198 + 199 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 200 + struct snd_soc_dai_link **dai_link) 200 201 { 201 202 struct snd_soc_dai_link_component *platform; 202 203 struct snd_soc_dai_link *dl; ··· 206 205 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 207 206 if (!dl || !platform) 208 207 return -ENOMEM; 209 - 210 - platform->name = platform_name; 211 208 212 209 dl->name = devm_kasprintf(dev, GFP_KERNEL, 213 210 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 221 222 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 222 223 return -ENOMEM; 223 224 225 + platform->name = dev_name(dev); 224 226 dl->num_cpus = 1; 225 227 dl->num_codecs = 1; 226 228 dl->platforms = platform; ··· 263 263 struct avs_card_drvdata *data; 264 264 struct snd_soc_card *card; 265 265 struct device *dev = &pdev->dev; 266 - const char *pname; 267 266 int ssp_port, tdm_slot, ret; 268 267 269 268 mach = dev_get_platdata(dev); 270 - pname = mach->mach_params.platform; 271 269 pdata = mach->pdata; 272 270 273 271 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 274 272 if (ret) 275 273 return ret; 276 274 277 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 275 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 278 276 if (ret) { 279 277 dev_err(dev, "Failed to create dai link: %d", ret); 280 278 return ret; ··· 303 305 card->num_dapm_routes = ARRAY_SIZE(card_routes); 304 306 card->fully_routed = true; 305 307 snd_soc_card_set_drvdata(card, data); 306 - 307 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 308 - if (ret) 309 - return ret; 310 308 311 309 return devm_snd_soc_register_deferrable_card(dev, card); 312 310 }
+8 -5
sound/soc/intel/avs/boards/hdaudio.c
··· 16 16 #include "../utils.h" 17 17 18 18 static int avs_create_dai_links(struct device *dev, struct hda_codec *codec, int pcm_count, 19 - const char *platform_name, struct snd_soc_dai_link **links) 19 + struct snd_soc_dai_link **links) 20 20 { 21 21 struct snd_soc_dai_link_component *platform; 22 22 struct snd_soc_dai_link *dl; ··· 29 29 if (!dl || !platform) 30 30 return -ENOMEM; 31 31 32 - platform->name = platform_name; 32 + platform->name = dev_name(dev); 33 33 pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list); 34 34 35 35 for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) { ··· 142 142 list_for_each_entry(pcm, &codec->pcm_list_head, list) 143 143 pcm_count++; 144 144 145 - ret = avs_create_dai_links(card->dev, codec, pcm_count, mach->mach_params.platform, &links); 145 + ret = avs_create_dai_links(card->dev, codec, pcm_count, &links); 146 146 if (ret < 0) { 147 147 dev_err(card->dev, "create links failed: %d\n", ret); 148 148 return ret; ··· 197 197 if (!binder->codecs->name) 198 198 return -ENOMEM; 199 199 200 - binder->platforms->name = mach->mach_params.platform; 200 + binder->platforms->name = dev_name(dev); 201 201 binder->num_platforms = 1; 202 202 binder->codecs->dai_name = "codec-probing-DAI"; 203 203 binder->num_codecs = 1; ··· 207 207 return -ENOMEM; 208 208 209 209 if (pdata->obsolete_card_names) { 210 - card->name = binder->codecs->name; 210 + card->name = devm_kasprintf(dev, GFP_KERNEL, "hdaudioB%dD%d", codec->bus->core.idx, 211 + codec->core.addr); 212 + if (!card->name) 213 + return -ENOMEM; 211 214 } else { 212 215 card->driver_name = "avs_hdaudio"; 213 216 if (hda_codec_is_display(codec))
+4 -11
sound/soc/intel/avs/boards/i2s_test.c
··· 14 14 #include <sound/soc-dapm.h> 15 15 #include "../utils.h" 16 16 17 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 18 - int tdm_slot, struct snd_soc_dai_link **dai_link) 17 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 18 + struct snd_soc_dai_link **dai_link) 19 19 { 20 20 struct snd_soc_dai_link_component *platform; 21 21 struct snd_soc_dai_link *dl; ··· 24 24 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 25 25 if (!dl || !platform) 26 26 return -ENOMEM; 27 - 28 - platform->name = platform_name; 29 27 30 28 dl->name = devm_kasprintf(dev, GFP_KERNEL, 31 29 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 37 39 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 38 40 return -ENOMEM; 39 41 42 + platform->name = dev_name(dev); 40 43 dl->num_cpus = 1; 41 44 dl->num_codecs = 1; 42 45 dl->platforms = platform; ··· 58 59 struct avs_mach_pdata *pdata; 59 60 struct snd_soc_card *card; 60 61 struct device *dev = &pdev->dev; 61 - const char *pname; 62 62 int ssp_port, tdm_slot, ret; 63 63 64 64 mach = dev_get_platdata(dev); 65 - pname = mach->mach_params.platform; 66 65 pdata = mach->pdata; 67 66 68 67 if (!avs_mach_singular_ssp(mach)) { ··· 91 94 if (!card->name) 92 95 return -ENOMEM; 93 96 94 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 97 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 95 98 if (ret) { 96 99 dev_err(dev, "Failed to create dai link: %d\n", ret); 97 100 return ret; ··· 102 105 card->dai_link = dai_link; 103 106 card->num_links = 1; 104 107 card->fully_routed = true; 105 - 106 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 107 - if (ret) 108 - return ret; 109 108 110 109 return devm_snd_soc_register_deferrable_card(dev, card); 111 110 }
+4 -11
sound/soc/intel/avs/boards/max98357a.c
··· 46 46 return 0; 47 47 } 48 48 49 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 50 - int tdm_slot, struct snd_soc_dai_link **dai_link) 49 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 50 + struct snd_soc_dai_link **dai_link) 51 51 { 52 52 struct snd_soc_dai_link_component *platform; 53 53 struct snd_soc_dai_link *dl; ··· 56 56 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 57 57 if (!dl || !platform) 58 58 return -ENOMEM; 59 - 60 - platform->name = platform_name; 61 59 62 60 dl->name = devm_kasprintf(dev, GFP_KERNEL, 63 61 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 71 73 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 72 74 return -ENOMEM; 73 75 76 + platform->name = dev_name(dev); 74 77 dl->num_cpus = 1; 75 78 dl->num_codecs = 1; 76 79 dl->platforms = platform; ··· 95 96 struct avs_mach_pdata *pdata; 96 97 struct snd_soc_card *card; 97 98 struct device *dev = &pdev->dev; 98 - const char *pname; 99 99 int ssp_port, tdm_slot, ret; 100 100 101 101 mach = dev_get_platdata(dev); 102 - pname = mach->mach_params.platform; 103 102 pdata = mach->pdata; 104 103 105 104 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 106 105 if (ret) 107 106 return ret; 108 107 109 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 108 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 110 109 if (ret) { 111 110 dev_err(dev, "Failed to create dai link: %d", ret); 112 111 return ret; ··· 131 134 card->dapm_routes = card_base_routes; 132 135 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 133 136 card->fully_routed = true; 134 - 135 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 136 - if (ret) 137 - return ret; 138 137 139 138 return devm_snd_soc_register_deferrable_card(dev, card); 140 139 }
+4 -11
sound/soc/intel/avs/boards/max98373.c
··· 95 95 .hw_params = avs_max98373_hw_params, 96 96 }; 97 97 98 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 99 - int tdm_slot, struct snd_soc_dai_link **dai_link) 98 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 99 + struct snd_soc_dai_link **dai_link) 100 100 { 101 101 struct snd_soc_dai_link_component *platform; 102 102 struct snd_soc_dai_link *dl; ··· 105 105 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 106 106 if (!dl || !platform) 107 107 return -ENOMEM; 108 - 109 - platform->name = platform_name; 110 108 111 109 dl->name = devm_kasprintf(dev, GFP_KERNEL, 112 110 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 123 125 !dl->codecs[1].name || !dl->codecs[1].dai_name) 124 126 return -ENOMEM; 125 127 128 + platform->name = dev_name(dev); 126 129 dl->num_cpus = 1; 127 130 dl->num_codecs = 2; 128 131 dl->platforms = platform; ··· 148 149 struct avs_mach_pdata *pdata; 149 150 struct snd_soc_card *card; 150 151 struct device *dev = &pdev->dev; 151 - const char *pname; 152 152 int ssp_port, tdm_slot, ret; 153 153 154 154 mach = dev_get_platdata(dev); 155 - pname = mach->mach_params.platform; 156 155 pdata = mach->pdata; 157 156 158 157 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 159 158 if (ret) 160 159 return ret; 161 160 162 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 161 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 163 162 if (ret) { 164 163 dev_err(dev, "Failed to create dai link: %d", ret); 165 164 return ret; ··· 186 189 card->dapm_routes = card_base_routes; 187 190 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 188 191 card->fully_routed = true; 189 - 190 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 191 - if (ret) 192 - return ret; 193 192 194 193 return devm_snd_soc_register_deferrable_card(dev, card); 195 194 }
+4 -11
sound/soc/intel/avs/boards/max98927.c
··· 92 92 .hw_params = avs_max98927_hw_params, 93 93 }; 94 94 95 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 96 - int tdm_slot, struct snd_soc_dai_link **dai_link) 95 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 96 + struct snd_soc_dai_link **dai_link) 97 97 { 98 98 struct snd_soc_dai_link_component *platform; 99 99 struct snd_soc_dai_link *dl; ··· 102 102 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 103 103 if (!dl || !platform) 104 104 return -ENOMEM; 105 - 106 - platform->name = platform_name; 107 105 108 106 dl->name = devm_kasprintf(dev, GFP_KERNEL, 109 107 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 120 122 !dl->codecs[1].name || !dl->codecs[1].dai_name) 121 123 return -ENOMEM; 122 124 125 + platform->name = dev_name(dev); 123 126 dl->num_cpus = 1; 124 127 dl->num_codecs = 2; 125 128 dl->platforms = platform; ··· 145 146 struct avs_mach_pdata *pdata; 146 147 struct snd_soc_card *card; 147 148 struct device *dev = &pdev->dev; 148 - const char *pname; 149 149 int ssp_port, tdm_slot, ret; 150 150 151 151 mach = dev_get_platdata(dev); 152 - pname = mach->mach_params.platform; 153 152 pdata = mach->pdata; 154 153 155 154 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 156 155 if (ret) 157 156 return ret; 158 157 159 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 158 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 160 159 if (ret) { 161 160 dev_err(dev, "Failed to create dai link: %d", ret); 162 161 return ret; ··· 183 186 card->dapm_routes = card_base_routes; 184 187 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 185 188 card->fully_routed = true; 186 - 187 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 188 - if (ret) 189 - return ret; 190 189 191 190 return devm_snd_soc_register_deferrable_card(dev, card); 192 191 }
+4 -11
sound/soc/intel/avs/boards/nau8825.c
··· 172 172 .trigger = avs_nau8825_trigger, 173 173 }; 174 174 175 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 176 - int tdm_slot, struct snd_soc_dai_link **dai_link) 175 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 176 + struct snd_soc_dai_link **dai_link) 177 177 { 178 178 struct snd_soc_dai_link_component *platform; 179 179 struct snd_soc_dai_link *dl; ··· 182 182 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 183 183 if (!dl || !platform) 184 184 return -ENOMEM; 185 - 186 - platform->name = platform_name; 187 185 188 186 dl->name = devm_kasprintf(dev, GFP_KERNEL, 189 187 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 197 199 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 198 200 return -ENOMEM; 199 201 202 + platform->name = dev_name(dev); 200 203 dl->num_cpus = 1; 201 204 dl->num_codecs = 1; 202 205 dl->platforms = platform; ··· 249 250 struct snd_soc_card *card; 250 251 struct snd_soc_jack *jack; 251 252 struct device *dev = &pdev->dev; 252 - const char *pname; 253 253 int ssp_port, tdm_slot, ret; 254 254 255 255 mach = dev_get_platdata(dev); 256 - pname = mach->mach_params.platform; 257 256 pdata = mach->pdata; 258 257 259 258 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 260 259 if (ret) 261 260 return ret; 262 261 263 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 262 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 264 263 if (ret) { 265 264 dev_err(dev, "Failed to create dai link: %d", ret); 266 265 return ret; ··· 289 292 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 290 293 card->fully_routed = true; 291 294 snd_soc_card_set_drvdata(card, jack); 292 - 293 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 294 - if (ret) 295 - return ret; 296 295 297 296 return devm_snd_soc_register_deferrable_card(dev, card); 298 297 }
+29 -20
sound/soc/intel/avs/boards/probe.c
··· 9 9 #include <linux/device.h> 10 10 #include <linux/module.h> 11 11 #include <sound/soc.h> 12 - #include <sound/soc-acpi.h> 13 12 14 - SND_SOC_DAILINK_DEF(dummy, DAILINK_COMP_ARRAY(COMP_DUMMY())); 15 - SND_SOC_DAILINK_DEF(probe_cp, DAILINK_COMP_ARRAY(COMP_CPU("Probe Extraction CPU DAI"))); 16 - SND_SOC_DAILINK_DEF(platform, DAILINK_COMP_ARRAY(COMP_PLATFORM("probe-platform"))); 13 + static int avs_create_dai_links(struct device *dev, struct snd_soc_dai_link **links, int *num_links) 14 + { 15 + struct snd_soc_dai_link *dl; 17 16 18 - static struct snd_soc_dai_link probe_mb_dai_links[] = { 19 - { 20 - .name = "Compress Probe Capture", 21 - .nonatomic = 1, 22 - SND_SOC_DAILINK_REG(probe_cp, dummy, platform), 23 - }, 24 - }; 17 + dl = devm_kzalloc(dev, sizeof(*dl), GFP_KERNEL); 18 + if (!dl) 19 + return -ENOMEM; 20 + 21 + dl->cpus = devm_kzalloc(dev, sizeof(*dl->cpus), GFP_KERNEL); 22 + dl->platforms = devm_kzalloc(dev, sizeof(*dl->platforms), GFP_KERNEL); 23 + if (!dl->cpus || !dl->platforms) 24 + return -ENOMEM; 25 + 26 + dl->name = "Compress Probe Capture"; 27 + dl->cpus->dai_name = "Probe Extraction CPU DAI"; 28 + dl->num_cpus = 1; 29 + dl->codecs = &snd_soc_dummy_dlc; 30 + dl->num_codecs = 1; 31 + dl->platforms->name = dev_name(dev); 32 + dl->num_platforms = 1; 33 + dl->nonatomic = 1; 34 + 35 + *links = dl; 36 + *num_links = 1; 37 + return 0; 38 + } 25 39 26 40 static int avs_probe_mb_probe(struct platform_device *pdev) 27 41 { 28 42 struct device *dev = &pdev->dev; 29 - struct snd_soc_acpi_mach *mach; 30 43 struct snd_soc_card *card; 31 44 int ret; 32 - 33 - mach = dev_get_platdata(dev); 34 45 35 46 card = devm_kzalloc(dev, sizeof(*card), GFP_KERNEL); 36 47 if (!card) 37 48 return -ENOMEM; 38 49 50 + ret = avs_create_dai_links(dev, &card->dai_link, &card->num_links); 51 + if (ret) 52 + return ret; 53 + 39 54 card->driver_name = "avs_probe_mb"; 40 55 card->long_name = card->name = "AVS PROBE"; 41 56 card->dev = dev; 42 57 card->owner = THIS_MODULE; 43 - card->dai_link = probe_mb_dai_links; 44 - card->num_links = ARRAY_SIZE(probe_mb_dai_links); 45 58 card->fully_routed = true; 46 - 47 - ret = snd_soc_fixup_dai_links_platform_name(card, mach->mach_params.platform); 48 - if (ret) 49 - return ret; 50 59 51 60 return devm_snd_soc_register_deferrable_card(dev, card); 52 61 }
+4 -11
sound/soc/intel/avs/boards/rt274.c
··· 147 147 return 0; 148 148 } 149 149 150 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 151 - int tdm_slot, struct snd_soc_dai_link **dai_link) 150 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 151 + struct snd_soc_dai_link **dai_link) 152 152 { 153 153 struct snd_soc_dai_link_component *platform; 154 154 struct snd_soc_dai_link *dl; ··· 157 157 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 158 158 if (!dl || !platform) 159 159 return -ENOMEM; 160 - 161 - platform->name = platform_name; 162 160 163 161 dl->name = devm_kasprintf(dev, GFP_KERNEL, 164 162 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 172 174 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 173 175 return -ENOMEM; 174 176 177 + platform->name = dev_name(dev); 175 178 dl->num_cpus = 1; 176 179 dl->num_codecs = 1; 177 180 dl->platforms = platform; ··· 213 214 struct snd_soc_card *card; 214 215 struct snd_soc_jack *jack; 215 216 struct device *dev = &pdev->dev; 216 - const char *pname; 217 217 int ssp_port, tdm_slot, ret; 218 218 219 219 mach = dev_get_platdata(dev); 220 - pname = mach->mach_params.platform; 221 220 pdata = mach->pdata; 222 221 223 222 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 224 223 if (ret) 225 224 return ret; 226 225 227 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 226 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 228 227 if (ret) { 229 228 dev_err(dev, "Failed to create dai link: %d", ret); 230 229 return ret; ··· 253 256 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 254 257 card->fully_routed = true; 255 258 snd_soc_card_set_drvdata(card, jack); 256 - 257 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 258 - if (ret) 259 - return ret; 260 259 261 260 return devm_snd_soc_register_deferrable_card(dev, card); 262 261 }
+4 -11
sound/soc/intel/avs/boards/rt286.c
··· 115 115 .hw_params = avs_rt286_hw_params, 116 116 }; 117 117 118 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 119 - int tdm_slot, struct snd_soc_dai_link **dai_link) 118 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 119 + struct snd_soc_dai_link **dai_link) 120 120 { 121 121 struct snd_soc_dai_link_component *platform; 122 122 struct snd_soc_dai_link *dl; ··· 125 125 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 126 126 if (!dl || !platform) 127 127 return -ENOMEM; 128 - 129 - platform->name = platform_name; 130 128 131 129 dl->name = devm_kasprintf(dev, GFP_KERNEL, 132 130 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 140 142 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 141 143 return -ENOMEM; 142 144 145 + platform->name = dev_name(dev); 143 146 dl->num_cpus = 1; 144 147 dl->num_codecs = 1; 145 148 dl->platforms = platform; ··· 182 183 struct snd_soc_card *card; 183 184 struct snd_soc_jack *jack; 184 185 struct device *dev = &pdev->dev; 185 - const char *pname; 186 186 int ssp_port, tdm_slot, ret; 187 187 188 188 mach = dev_get_platdata(dev); 189 - pname = mach->mach_params.platform; 190 189 pdata = mach->pdata; 191 190 192 191 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 193 192 if (ret) 194 193 return ret; 195 194 196 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 195 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 197 196 198 197 if (ret) { 199 198 dev_err(dev, "Failed to create dai link: %d", ret); ··· 223 226 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 224 227 card->fully_routed = true; 225 228 snd_soc_card_set_drvdata(card, jack); 226 - 227 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 228 - if (ret) 229 - return ret; 230 229 231 230 return devm_snd_soc_register_deferrable_card(dev, card); 232 231 }
+4 -11
sound/soc/intel/avs/boards/rt298.c
··· 132 132 .hw_params = avs_rt298_hw_params, 133 133 }; 134 134 135 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 136 - int tdm_slot, struct snd_soc_dai_link **dai_link) 135 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 136 + struct snd_soc_dai_link **dai_link) 137 137 { 138 138 struct snd_soc_dai_link_component *platform; 139 139 struct snd_soc_dai_link *dl; ··· 142 142 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 143 143 if (!dl || !platform) 144 144 return -ENOMEM; 145 - 146 - platform->name = platform_name; 147 145 148 146 dl->name = devm_kasprintf(dev, GFP_KERNEL, 149 147 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 157 159 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 158 160 return -ENOMEM; 159 161 162 + platform->name = dev_name(dev); 160 163 dl->num_cpus = 1; 161 164 dl->num_codecs = 1; 162 165 dl->platforms = platform; ··· 202 203 struct snd_soc_card *card; 203 204 struct snd_soc_jack *jack; 204 205 struct device *dev = &pdev->dev; 205 - const char *pname; 206 206 int ssp_port, tdm_slot, ret; 207 207 208 208 mach = dev_get_platdata(dev); 209 - pname = mach->mach_params.platform; 210 209 pdata = mach->pdata; 211 210 212 211 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 213 212 if (ret) 214 213 return ret; 215 214 216 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 215 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 217 216 if (ret) { 218 217 dev_err(dev, "Failed to create dai link: %d", ret); 219 218 return ret; ··· 242 245 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 243 246 card->fully_routed = true; 244 247 snd_soc_card_set_drvdata(card, jack); 245 - 246 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 247 - if (ret) 248 - return ret; 249 248 250 249 return devm_snd_soc_register_deferrable_card(dev, card); 251 250 }
+4 -11
sound/soc/intel/avs/boards/rt5514.c
··· 84 84 .hw_params = avs_rt5514_hw_params, 85 85 }; 86 86 87 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 88 - int tdm_slot, struct snd_soc_dai_link **dai_link) 87 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 88 + struct snd_soc_dai_link **dai_link) 89 89 { 90 90 struct snd_soc_dai_link_component *platform; 91 91 struct snd_soc_dai_link *dl; ··· 94 94 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 95 95 if (!dl || !platform) 96 96 return -ENOMEM; 97 - 98 - platform->name = platform_name; 99 97 100 98 dl->name = devm_kasprintf(dev, GFP_KERNEL, 101 99 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 109 111 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 110 112 return -ENOMEM; 111 113 114 + platform->name = dev_name(dev); 112 115 dl->num_cpus = 1; 113 116 dl->num_codecs = 1; 114 117 dl->platforms = platform; ··· 135 136 struct avs_mach_pdata *pdata; 136 137 struct snd_soc_card *card; 137 138 struct device *dev = &pdev->dev; 138 - const char *pname; 139 139 int ssp_port, tdm_slot, ret; 140 140 141 141 mach = dev_get_platdata(dev); 142 - pname = mach->mach_params.platform; 143 142 pdata = mach->pdata; 144 143 145 144 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 146 145 if (ret) 147 146 return ret; 148 147 149 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 148 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 150 149 if (ret) { 151 150 dev_err(dev, "Failed to create dai link: %d", ret); 152 151 return ret; ··· 169 172 card->dapm_routes = card_base_routes; 170 173 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 171 174 card->fully_routed = true; 172 - 173 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 174 - if (ret) 175 - return ret; 176 175 177 176 return devm_snd_soc_register_deferrable_card(dev, card); 178 177 }
+4 -11
sound/soc/intel/avs/boards/rt5663.c
··· 134 134 }; 135 135 136 136 137 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 138 - int tdm_slot, struct snd_soc_dai_link **dai_link) 137 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 138 + struct snd_soc_dai_link **dai_link) 139 139 { 140 140 struct snd_soc_dai_link_component *platform; 141 141 struct snd_soc_dai_link *dl; ··· 144 144 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 145 145 if (!dl || !platform) 146 146 return -ENOMEM; 147 - 148 - platform->name = platform_name; 149 147 150 148 dl->name = devm_kasprintf(dev, GFP_KERNEL, 151 149 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 159 161 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 160 162 return -ENOMEM; 161 163 164 + platform->name = dev_name(dev); 162 165 dl->num_cpus = 1; 163 166 dl->num_codecs = 1; 164 167 dl->platforms = platform; ··· 201 202 struct snd_soc_card *card; 202 203 struct rt5663_private *priv; 203 204 struct device *dev = &pdev->dev; 204 - const char *pname; 205 205 int ssp_port, tdm_slot, ret; 206 206 207 207 mach = dev_get_platdata(dev); 208 - pname = mach->mach_params.platform; 209 208 pdata = mach->pdata; 210 209 211 210 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 212 211 if (ret) 213 212 return ret; 214 213 215 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 214 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 216 215 if (ret) { 217 216 dev_err(dev, "Failed to create dai link: %d", ret); 218 217 return ret; ··· 241 244 card->num_dapm_routes = ARRAY_SIZE(card_routes); 242 245 card->fully_routed = true; 243 246 snd_soc_card_set_drvdata(card, priv); 244 - 245 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 246 - if (ret) 247 - return ret; 248 247 249 248 return devm_snd_soc_register_deferrable_card(dev, card); 250 249 }
+4 -11
sound/soc/intel/avs/boards/rt5682.c
··· 204 204 return 0; 205 205 } 206 206 207 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 208 - int tdm_slot, struct snd_soc_dai_link **dai_link) 207 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 208 + struct snd_soc_dai_link **dai_link) 209 209 { 210 210 struct snd_soc_dai_link_component *platform; 211 211 struct snd_soc_dai_link *dl; ··· 214 214 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 215 215 if (!dl || !platform) 216 216 return -ENOMEM; 217 - 218 - platform->name = platform_name; 219 217 220 218 dl->name = devm_kasprintf(dev, GFP_KERNEL, 221 219 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 229 231 if (!dl->cpus->dai_name || !dl->codecs->name || !dl->codecs->dai_name) 230 232 return -ENOMEM; 231 233 234 + platform->name = dev_name(dev); 232 235 dl->num_cpus = 1; 233 236 dl->num_codecs = 1; 234 237 dl->platforms = platform; ··· 271 272 struct snd_soc_card *card; 272 273 struct snd_soc_jack *jack; 273 274 struct device *dev = &pdev->dev; 274 - const char *pname; 275 275 int ssp_port, tdm_slot, ret; 276 276 277 277 if (pdev->id_entry && pdev->id_entry->driver_data) ··· 280 282 dev_dbg(dev, "avs_rt5682_quirk = %lx\n", avs_rt5682_quirk); 281 283 282 284 mach = dev_get_platdata(dev); 283 - pname = mach->mach_params.platform; 284 285 pdata = mach->pdata; 285 286 286 287 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 287 288 if (ret) 288 289 return ret; 289 290 290 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 291 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 291 292 if (ret) { 292 293 dev_err(dev, "Failed to create dai link: %d", ret); 293 294 return ret; ··· 317 320 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 318 321 card->fully_routed = true; 319 322 snd_soc_card_set_drvdata(card, jack); 320 - 321 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 322 - if (ret) 323 - return ret; 324 323 325 324 return devm_snd_soc_register_deferrable_card(dev, card); 326 325 }
+4 -11
sound/soc/intel/avs/boards/ssm4567.c
··· 81 81 return 0; 82 82 } 83 83 84 - static int avs_create_dai_link(struct device *dev, const char *platform_name, int ssp_port, 85 - int tdm_slot, struct snd_soc_dai_link **dai_link) 84 + static int avs_create_dai_link(struct device *dev, int ssp_port, int tdm_slot, 85 + struct snd_soc_dai_link **dai_link) 86 86 { 87 87 struct snd_soc_dai_link_component *platform; 88 88 struct snd_soc_dai_link *dl; ··· 91 91 platform = devm_kzalloc(dev, sizeof(*platform), GFP_KERNEL); 92 92 if (!dl || !platform) 93 93 return -ENOMEM; 94 - 95 - platform->name = platform_name; 96 94 97 95 dl->name = devm_kasprintf(dev, GFP_KERNEL, 98 96 AVS_STRING_FMT("SSP", "-Codec", ssp_port, tdm_slot)); ··· 109 111 !dl->codecs[1].name || !dl->codecs[1].dai_name) 110 112 return -ENOMEM; 111 113 114 + platform->name = dev_name(dev); 112 115 dl->num_cpus = 1; 113 116 dl->num_codecs = 2; 114 117 dl->platforms = platform; ··· 134 135 struct avs_mach_pdata *pdata; 135 136 struct snd_soc_card *card; 136 137 struct device *dev = &pdev->dev; 137 - const char *pname; 138 138 int ssp_port, tdm_slot, ret; 139 139 140 140 mach = dev_get_platdata(dev); 141 - pname = mach->mach_params.platform; 142 141 pdata = mach->pdata; 143 142 144 143 ret = avs_mach_get_ssp_tdm(dev, mach, &ssp_port, &tdm_slot); 145 144 if (ret) 146 145 return ret; 147 146 148 - ret = avs_create_dai_link(dev, pname, ssp_port, tdm_slot, &dai_link); 147 + ret = avs_create_dai_link(dev, ssp_port, tdm_slot, &dai_link); 149 148 if (ret) { 150 149 dev_err(dev, "Failed to create dai link: %d", ret); 151 150 return ret; ··· 172 175 card->dapm_routes = card_base_routes; 173 176 card->num_dapm_routes = ARRAY_SIZE(card_base_routes); 174 177 card->fully_routed = true; 175 - 176 - ret = snd_soc_fixup_dai_links_platform_name(card, pname); 177 - if (ret) 178 - return ret; 179 178 180 179 return devm_snd_soc_register_deferrable_card(dev, card); 181 180 }