1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved. 4 // 5 // Author: Cezary Rojewski <cezary.rojewski@intel.com> 6 // 7 8 #include <linux/module.h> 9 #include <linux/pm_runtime.h> 10 #include <sound/soc.h> 11 #include <sound/hdaudio_ext.h> 12 #include <sound/hda_i915.h> 13 #include <sound/hda_codec.h> 14 #include "hda.h" 15 16 static int hda_codec_create_dais(struct hda_codec *codec, int pcm_count, 17 struct snd_soc_dai_driver **drivers) 18 { 19 struct device *dev = &codec->core.dev; 20 struct snd_soc_dai_driver *drvs; 21 struct hda_pcm *pcm; 22 int i; 23 24 drvs = devm_kcalloc(dev, pcm_count, sizeof(*drvs), GFP_KERNEL); 25 if (!drvs) 26 return -ENOMEM; 27 28 pcm = list_first_entry(&codec->pcm_list_head, struct hda_pcm, list); 29 30 for (i = 0; i < pcm_count; i++, pcm = list_next_entry(pcm, list)) { 31 struct snd_soc_pcm_stream *stream; 32 int dir; 33 34 dev_info(dev, "creating for %s %d\n", pcm->name, i); 35 drvs[i].id = i; 36 drvs[i].name = pcm->name; 37 drvs[i].ops = &snd_soc_hda_codec_dai_ops; 38 39 dir = SNDRV_PCM_STREAM_PLAYBACK; 40 stream = &drvs[i].playback; 41 if (!pcm->stream[dir].substreams) { 42 dev_info(dev, "skipping playback dai for %s\n", pcm->name); 43 goto capture_dais; 44 } 45 46 stream->stream_name = 47 devm_kasprintf(dev, GFP_KERNEL, "%s %s", pcm->name, 48 snd_pcm_direction_name(dir)); 49 if (!stream->stream_name) 50 return -ENOMEM; 51 stream->channels_min = pcm->stream[dir].channels_min; 52 stream->channels_max = pcm->stream[dir].channels_max; 53 stream->rates = pcm->stream[dir].rates; 54 stream->formats = pcm->stream[dir].formats; 55 stream->sig_bits = pcm->stream[dir].maxbps; 56 57 capture_dais: 58 dir = SNDRV_PCM_STREAM_CAPTURE; 59 stream = &drvs[i].capture; 60 if (!pcm->stream[dir].substreams) { 61 dev_info(dev, "skipping capture dai for %s\n", pcm->name); 62 continue; 63 } 64 65 stream->stream_name = 66 devm_kasprintf(dev, GFP_KERNEL, "%s %s", pcm->name, 67 snd_pcm_direction_name(dir)); 68 if (!stream->stream_name) 69 return -ENOMEM; 70 stream->channels_min = pcm->stream[dir].channels_min; 71 stream->channels_max = pcm->stream[dir].channels_max; 72 stream->rates = pcm->stream[dir].rates; 73 stream->formats = pcm->stream[dir].formats; 74 stream->sig_bits = pcm->stream[dir].maxbps; 75 } 76 77 *drivers = drvs; 78 return 0; 79 } 80 81 static int hda_codec_register_dais(struct hda_codec *codec, struct snd_soc_component *component) 82 { 83 struct snd_soc_dai_driver *drvs = NULL; 84 struct snd_soc_dapm_context *dapm; 85 struct hda_pcm *pcm; 86 int ret, pcm_count = 0; 87 88 if (list_empty(&codec->pcm_list_head)) 89 return -EINVAL; 90 list_for_each_entry(pcm, &codec->pcm_list_head, list) 91 pcm_count++; 92 93 ret = hda_codec_create_dais(codec, pcm_count, &drvs); 94 if (ret < 0) 95 return ret; 96 97 dapm = snd_soc_component_get_dapm(component); 98 99 list_for_each_entry(pcm, &codec->pcm_list_head, list) { 100 struct snd_soc_dai *dai; 101 102 dai = snd_soc_register_dai(component, drvs, false); 103 if (!dai) { 104 dev_err(component->dev, "register dai for %s failed\n", pcm->name); 105 return -EINVAL; 106 } 107 108 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 109 if (ret < 0) { 110 dev_err(component->dev, "create widgets failed: %d\n", ret); 111 snd_soc_unregister_dai(dai); 112 return ret; 113 } 114 115 snd_soc_dai_init_dma_data(dai, &pcm->stream[0], &pcm->stream[1]); 116 drvs++; 117 } 118 119 return 0; 120 } 121 122 static void hda_codec_unregister_dais(struct hda_codec *codec, 123 struct snd_soc_component *component) 124 { 125 struct snd_soc_dai *dai, *save; 126 struct hda_pcm *pcm; 127 128 for_each_component_dais_safe(component, dai, save) { 129 list_for_each_entry(pcm, &codec->pcm_list_head, list) { 130 if (strcmp(dai->driver->name, pcm->name)) 131 continue; 132 133 snd_soc_dapm_free_widget(dai->playback_widget); 134 snd_soc_dapm_free_widget(dai->capture_widget); 135 snd_soc_unregister_dai(dai); 136 break; 137 } 138 } 139 } 140 141 int hda_codec_probe_complete(struct hda_codec *codec) 142 { 143 struct hdac_device *hdev = &codec->core; 144 struct hdac_bus *bus = hdev->bus; 145 int ret; 146 147 ret = snd_hda_codec_build_controls(codec); 148 if (ret < 0) { 149 dev_err(&hdev->dev, "unable to create controls %d\n", ret); 150 goto out; 151 } 152 153 /* Bus suspended codecs as it does not manage their pm */ 154 pm_runtime_set_active(&hdev->dev); 155 /* rpm was forbidden in snd_hda_codec_device_new() */ 156 snd_hda_codec_set_power_save(codec, 2000); 157 snd_hda_codec_register(codec); 158 out: 159 /* Complement pm_runtime_get_sync(bus) in probe */ 160 pm_runtime_mark_last_busy(bus->dev); 161 pm_runtime_put_autosuspend(bus->dev); 162 163 return ret; 164 } 165 EXPORT_SYMBOL_GPL(hda_codec_probe_complete); 166 167 /* Expects codec with usage_count=1 and status=suspended */ 168 static int hda_codec_probe(struct snd_soc_component *component) 169 { 170 struct hda_codec *codec = dev_to_hda_codec(component->dev); 171 struct hdac_device *hdev = &codec->core; 172 struct hdac_bus *bus = hdev->bus; 173 struct hdac_ext_link *hlink; 174 hda_codec_patch_t patch; 175 int ret; 176 177 #ifdef CONFIG_PM 178 WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 || 179 !pm_runtime_status_suspended(&hdev->dev)); 180 #endif 181 182 hlink = snd_hdac_ext_bus_get_hlink_by_addr(bus, hdev->addr); 183 if (!hlink) { 184 dev_err(&hdev->dev, "hdac link not found\n"); 185 return -EIO; 186 } 187 188 pm_runtime_get_sync(bus->dev); 189 if (hda_codec_is_display(codec)) 190 snd_hdac_display_power(bus, hdev->addr, true); 191 snd_hdac_ext_bus_link_get(bus, hlink); 192 193 ret = snd_hda_codec_device_new(codec->bus, component->card->snd_card, hdev->addr, codec, 194 false); 195 if (ret < 0) { 196 dev_err(&hdev->dev, "create hda codec failed: %d\n", ret); 197 goto device_new_err; 198 } 199 200 ret = snd_hda_codec_set_name(codec, codec->preset->name); 201 if (ret < 0) { 202 dev_err(&hdev->dev, "name failed %s\n", codec->preset->name); 203 goto err; 204 } 205 206 ret = snd_hdac_regmap_init(&codec->core); 207 if (ret < 0) { 208 dev_err(&hdev->dev, "regmap init failed\n"); 209 goto err; 210 } 211 212 patch = (hda_codec_patch_t)codec->preset->driver_data; 213 if (!patch) { 214 dev_err(&hdev->dev, "no patch specified\n"); 215 ret = -EINVAL; 216 goto err; 217 } 218 219 ret = patch(codec); 220 if (ret < 0) { 221 dev_err(&hdev->dev, "patch failed %d\n", ret); 222 goto err; 223 } 224 225 ret = snd_hda_codec_parse_pcms(codec); 226 if (ret < 0) { 227 dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret); 228 goto parse_pcms_err; 229 } 230 231 ret = hda_codec_register_dais(codec, component); 232 if (ret < 0) { 233 dev_err(&hdev->dev, "update dais failed: %d\n", ret); 234 goto parse_pcms_err; 235 } 236 237 if (!hda_codec_is_display(codec)) { 238 ret = hda_codec_probe_complete(codec); 239 if (ret < 0) 240 goto complete_err; 241 } 242 243 codec->core.lazy_cache = true; 244 245 return 0; 246 247 complete_err: 248 hda_codec_unregister_dais(codec, component); 249 parse_pcms_err: 250 if (codec->patch_ops.free) 251 codec->patch_ops.free(codec); 252 err: 253 snd_hda_codec_cleanup_for_unbind(codec); 254 device_new_err: 255 if (hda_codec_is_display(codec)) 256 snd_hdac_display_power(bus, hdev->addr, false); 257 258 snd_hdac_ext_bus_link_put(bus, hlink); 259 260 pm_runtime_mark_last_busy(bus->dev); 261 pm_runtime_put_autosuspend(bus->dev); 262 return ret; 263 } 264 265 /* Leaves codec with usage_count=1 and status=suspended */ 266 static void hda_codec_remove(struct snd_soc_component *component) 267 { 268 struct hda_codec *codec = dev_to_hda_codec(component->dev); 269 struct hdac_device *hdev = &codec->core; 270 struct hdac_bus *bus = hdev->bus; 271 struct hdac_ext_link *hlink; 272 bool was_registered = codec->core.registered; 273 274 /* Don't allow any more runtime suspends */ 275 pm_runtime_forbid(&hdev->dev); 276 277 hda_codec_unregister_dais(codec, component); 278 279 if (codec->patch_ops.free) 280 codec->patch_ops.free(codec); 281 282 snd_hda_codec_cleanup_for_unbind(codec); 283 pm_runtime_put_noidle(&hdev->dev); 284 /* snd_hdac_device_exit() is only called on bus remove */ 285 pm_runtime_set_suspended(&hdev->dev); 286 287 if (hda_codec_is_display(codec)) 288 snd_hdac_display_power(bus, hdev->addr, false); 289 290 hlink = snd_hdac_ext_bus_get_hlink_by_addr(bus, hdev->addr); 291 if (hlink) 292 snd_hdac_ext_bus_link_put(bus, hlink); 293 /* 294 * HDMI card's hda_codec_probe_complete() (see late_probe()) may 295 * not be called due to early error, leaving bus uc unbalanced 296 */ 297 if (!was_registered) { 298 pm_runtime_mark_last_busy(bus->dev); 299 pm_runtime_put_autosuspend(bus->dev); 300 } 301 302 #ifdef CONFIG_PM 303 WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 || 304 !pm_runtime_status_suspended(&hdev->dev)); 305 #endif 306 } 307 308 static const struct snd_soc_dapm_route hda_dapm_routes[] = { 309 {"AIF1TX", NULL, "Codec Input Pin1"}, 310 {"AIF2TX", NULL, "Codec Input Pin2"}, 311 {"AIF3TX", NULL, "Codec Input Pin3"}, 312 313 {"Codec Output Pin1", NULL, "AIF1RX"}, 314 {"Codec Output Pin2", NULL, "AIF2RX"}, 315 {"Codec Output Pin3", NULL, "AIF3RX"}, 316 }; 317 318 static const struct snd_soc_dapm_widget hda_dapm_widgets[] = { 319 /* Audio Interface */ 320 SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0), 321 SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0, SND_SOC_NOPM, 0, 0), 322 SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0), 323 SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0), 324 SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0, SND_SOC_NOPM, 0, 0), 325 SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0), 326 327 /* Input Pins */ 328 SND_SOC_DAPM_INPUT("Codec Input Pin1"), 329 SND_SOC_DAPM_INPUT("Codec Input Pin2"), 330 SND_SOC_DAPM_INPUT("Codec Input Pin3"), 331 332 /* Output Pins */ 333 SND_SOC_DAPM_OUTPUT("Codec Output Pin1"), 334 SND_SOC_DAPM_OUTPUT("Codec Output Pin2"), 335 SND_SOC_DAPM_OUTPUT("Codec Output Pin3"), 336 }; 337 338 static struct snd_soc_dai_driver card_binder_dai = { 339 .id = -1, 340 .name = "codec-probing-DAI", 341 }; 342 343 static int hda_hdev_attach(struct hdac_device *hdev) 344 { 345 struct hda_codec *codec = dev_to_hda_codec(&hdev->dev); 346 struct snd_soc_component_driver *comp_drv; 347 348 comp_drv = devm_kzalloc(&hdev->dev, sizeof(*comp_drv), GFP_KERNEL); 349 if (!comp_drv) 350 return -ENOMEM; 351 352 /* 353 * It's save to rely on dev_name() rather than a copy as component 354 * driver's lifetime is directly tied to hda codec one 355 */ 356 comp_drv->name = dev_name(&hdev->dev); 357 comp_drv->probe = hda_codec_probe; 358 comp_drv->remove = hda_codec_remove; 359 comp_drv->idle_bias_on = false; 360 if (!hda_codec_is_display(codec)) { 361 comp_drv->dapm_widgets = hda_dapm_widgets; 362 comp_drv->num_dapm_widgets = ARRAY_SIZE(hda_dapm_widgets); 363 comp_drv->dapm_routes = hda_dapm_routes; 364 comp_drv->num_dapm_routes = ARRAY_SIZE(hda_dapm_routes); 365 } 366 367 return snd_soc_register_component(&hdev->dev, comp_drv, &card_binder_dai, 1); 368 } 369 370 static int hda_hdev_detach(struct hdac_device *hdev) 371 { 372 struct hda_codec *codec = dev_to_hda_codec(&hdev->dev); 373 374 if (codec->core.registered) 375 cancel_delayed_work_sync(&codec->jackpoll_work); 376 377 snd_soc_unregister_component(&hdev->dev); 378 379 return 0; 380 } 381 382 const struct hdac_ext_bus_ops soc_hda_ext_bus_ops = { 383 .hdev_attach = hda_hdev_attach, 384 .hdev_detach = hda_hdev_detach, 385 }; 386 EXPORT_SYMBOL_GPL(soc_hda_ext_bus_ops); 387 388 MODULE_DESCRIPTION("HD-Audio codec driver"); 389 MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>"); 390 MODULE_LICENSE("GPL"); 391