1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright(c) 2015-18 Intel Corporation. 3 4 /* 5 * hdac_hda.c - ASoC extensions to reuse the legacy HDA codec drivers 6 * with ASoC platform drivers. These APIs are called by the legacy HDA 7 * codec drivers using hdac_ext_bus_ops ops. 8 */ 9 10 #include <linux/init.h> 11 #include <linux/delay.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <sound/pcm_params.h> 15 #include <sound/soc.h> 16 #include <sound/hdaudio_ext.h> 17 #include <sound/hda_codec.h> 18 #include <sound/hda_register.h> 19 #include "hdac_hda.h" 20 21 #define HDAC_ANALOG_DAI_ID 0 22 #define HDAC_DIGITAL_DAI_ID 1 23 #define HDAC_ALT_ANALOG_DAI_ID 2 24 25 #define STUB_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ 26 SNDRV_PCM_FMTBIT_U8 | \ 27 SNDRV_PCM_FMTBIT_S16_LE | \ 28 SNDRV_PCM_FMTBIT_U16_LE | \ 29 SNDRV_PCM_FMTBIT_S24_LE | \ 30 SNDRV_PCM_FMTBIT_U24_LE | \ 31 SNDRV_PCM_FMTBIT_S32_LE | \ 32 SNDRV_PCM_FMTBIT_U32_LE | \ 33 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE) 34 35 static int hdac_hda_dai_open(struct snd_pcm_substream *substream, 36 struct snd_soc_dai *dai); 37 static void hdac_hda_dai_close(struct snd_pcm_substream *substream, 38 struct snd_soc_dai *dai); 39 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream, 40 struct snd_soc_dai *dai); 41 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream, 42 struct snd_soc_dai *dai); 43 static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai, 44 unsigned int tx_mask, unsigned int rx_mask, 45 int slots, int slot_width); 46 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt, 47 struct snd_soc_dai *dai); 48 49 static struct snd_soc_dai_ops hdac_hda_dai_ops = { 50 .startup = hdac_hda_dai_open, 51 .shutdown = hdac_hda_dai_close, 52 .prepare = hdac_hda_dai_prepare, 53 .hw_free = hdac_hda_dai_hw_free, 54 .set_tdm_slot = hdac_hda_dai_set_tdm_slot, 55 }; 56 57 static struct snd_soc_dai_driver hdac_hda_dais[] = { 58 { 59 .id = HDAC_ANALOG_DAI_ID, 60 .name = "Analog Codec DAI", 61 .ops = &hdac_hda_dai_ops, 62 .playback = { 63 .stream_name = "Analog Codec Playback", 64 .channels_min = 1, 65 .channels_max = 16, 66 .rates = SNDRV_PCM_RATE_8000_192000, 67 .formats = STUB_FORMATS, 68 .sig_bits = 24, 69 }, 70 .capture = { 71 .stream_name = "Analog Codec Capture", 72 .channels_min = 1, 73 .channels_max = 16, 74 .rates = SNDRV_PCM_RATE_8000_192000, 75 .formats = STUB_FORMATS, 76 .sig_bits = 24, 77 }, 78 }, 79 { 80 .id = HDAC_DIGITAL_DAI_ID, 81 .name = "Digital Codec DAI", 82 .ops = &hdac_hda_dai_ops, 83 .playback = { 84 .stream_name = "Digital Codec Playback", 85 .channels_min = 1, 86 .channels_max = 16, 87 .rates = SNDRV_PCM_RATE_8000_192000, 88 .formats = STUB_FORMATS, 89 .sig_bits = 24, 90 }, 91 .capture = { 92 .stream_name = "Digital Codec Capture", 93 .channels_min = 1, 94 .channels_max = 16, 95 .rates = SNDRV_PCM_RATE_8000_192000, 96 .formats = STUB_FORMATS, 97 .sig_bits = 24, 98 }, 99 }, 100 { 101 .id = HDAC_ALT_ANALOG_DAI_ID, 102 .name = "Alt Analog Codec DAI", 103 .ops = &hdac_hda_dai_ops, 104 .playback = { 105 .stream_name = "Alt Analog Codec Playback", 106 .channels_min = 1, 107 .channels_max = 16, 108 .rates = SNDRV_PCM_RATE_8000_192000, 109 .formats = STUB_FORMATS, 110 .sig_bits = 24, 111 }, 112 .capture = { 113 .stream_name = "Alt Analog Codec Capture", 114 .channels_min = 1, 115 .channels_max = 16, 116 .rates = SNDRV_PCM_RATE_8000_192000, 117 .formats = STUB_FORMATS, 118 .sig_bits = 24, 119 }, 120 } 121 122 }; 123 124 static int hdac_hda_dai_set_tdm_slot(struct snd_soc_dai *dai, 125 unsigned int tx_mask, unsigned int rx_mask, 126 int slots, int slot_width) 127 { 128 struct snd_soc_component *component = dai->component; 129 struct hdac_hda_priv *hda_pvt; 130 struct hdac_hda_pcm *pcm; 131 132 hda_pvt = snd_soc_component_get_drvdata(component); 133 pcm = &hda_pvt->pcm[dai->id]; 134 if (tx_mask) 135 pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_PLAYBACK] = tx_mask; 136 else 137 pcm[dai->id].stream_tag[SNDRV_PCM_STREAM_CAPTURE] = rx_mask; 138 139 return 0; 140 } 141 142 static int hdac_hda_dai_hw_free(struct snd_pcm_substream *substream, 143 struct snd_soc_dai *dai) 144 { 145 struct snd_soc_component *component = dai->component; 146 struct hdac_hda_priv *hda_pvt; 147 struct hda_pcm_stream *hda_stream; 148 struct hda_pcm *pcm; 149 150 hda_pvt = snd_soc_component_get_drvdata(component); 151 pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai); 152 if (!pcm) 153 return -EINVAL; 154 155 hda_stream = &pcm->stream[substream->stream]; 156 snd_hda_codec_cleanup(&hda_pvt->codec, hda_stream, substream); 157 158 return 0; 159 } 160 161 static int hdac_hda_dai_prepare(struct snd_pcm_substream *substream, 162 struct snd_soc_dai *dai) 163 { 164 struct snd_soc_component *component = dai->component; 165 struct hdac_hda_priv *hda_pvt; 166 struct snd_pcm_runtime *runtime = substream->runtime; 167 struct hdac_device *hdev; 168 struct hda_pcm_stream *hda_stream; 169 unsigned int format_val; 170 struct hda_pcm *pcm; 171 unsigned int stream; 172 int ret = 0; 173 174 hda_pvt = snd_soc_component_get_drvdata(component); 175 hdev = &hda_pvt->codec.core; 176 pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai); 177 if (!pcm) 178 return -EINVAL; 179 180 hda_stream = &pcm->stream[substream->stream]; 181 182 format_val = snd_hdac_calc_stream_format(runtime->rate, 183 runtime->channels, 184 runtime->format, 185 hda_stream->maxbps, 186 0); 187 if (!format_val) { 188 dev_err(&hdev->dev, 189 "invalid format_val, rate=%d, ch=%d, format=%d\n", 190 runtime->rate, runtime->channels, runtime->format); 191 return -EINVAL; 192 } 193 194 stream = hda_pvt->pcm[dai->id].stream_tag[substream->stream]; 195 196 ret = snd_hda_codec_prepare(&hda_pvt->codec, hda_stream, 197 stream, format_val, substream); 198 if (ret < 0) 199 dev_err(&hdev->dev, "codec prepare failed %d\n", ret); 200 201 return ret; 202 } 203 204 static int hdac_hda_dai_open(struct snd_pcm_substream *substream, 205 struct snd_soc_dai *dai) 206 { 207 struct snd_soc_component *component = dai->component; 208 struct hdac_hda_priv *hda_pvt; 209 struct hda_pcm_stream *hda_stream; 210 struct hda_pcm *pcm; 211 int ret; 212 213 hda_pvt = snd_soc_component_get_drvdata(component); 214 pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai); 215 if (!pcm) 216 return -EINVAL; 217 218 snd_hda_codec_pcm_get(pcm); 219 220 hda_stream = &pcm->stream[substream->stream]; 221 222 ret = hda_stream->ops.open(hda_stream, &hda_pvt->codec, substream); 223 if (ret < 0) 224 snd_hda_codec_pcm_put(pcm); 225 226 return ret; 227 } 228 229 static void hdac_hda_dai_close(struct snd_pcm_substream *substream, 230 struct snd_soc_dai *dai) 231 { 232 struct snd_soc_component *component = dai->component; 233 struct hdac_hda_priv *hda_pvt; 234 struct hda_pcm_stream *hda_stream; 235 struct hda_pcm *pcm; 236 237 hda_pvt = snd_soc_component_get_drvdata(component); 238 pcm = snd_soc_find_pcm_from_dai(hda_pvt, dai); 239 if (!pcm) 240 return; 241 242 hda_stream = &pcm->stream[substream->stream]; 243 244 hda_stream->ops.close(hda_stream, &hda_pvt->codec, substream); 245 246 snd_hda_codec_pcm_put(pcm); 247 } 248 249 static struct hda_pcm *snd_soc_find_pcm_from_dai(struct hdac_hda_priv *hda_pvt, 250 struct snd_soc_dai *dai) 251 { 252 struct hda_codec *hcodec = &hda_pvt->codec; 253 struct hda_pcm *cpcm; 254 const char *pcm_name; 255 256 switch (dai->id) { 257 case HDAC_ANALOG_DAI_ID: 258 pcm_name = "Analog"; 259 break; 260 case HDAC_DIGITAL_DAI_ID: 261 pcm_name = "Digital"; 262 break; 263 case HDAC_ALT_ANALOG_DAI_ID: 264 pcm_name = "Alt Analog"; 265 break; 266 default: 267 dev_err(&hcodec->core.dev, "invalid dai id %d\n", dai->id); 268 return NULL; 269 } 270 271 list_for_each_entry(cpcm, &hcodec->pcm_list_head, list) { 272 if (strpbrk(cpcm->name, pcm_name)) 273 return cpcm; 274 } 275 276 dev_err(&hcodec->core.dev, "didn't find PCM for DAI %s\n", dai->name); 277 return NULL; 278 } 279 280 static int hdac_hda_codec_probe(struct snd_soc_component *component) 281 { 282 struct hdac_hda_priv *hda_pvt = 283 snd_soc_component_get_drvdata(component); 284 struct snd_soc_dapm_context *dapm = 285 snd_soc_component_get_dapm(component); 286 struct hdac_device *hdev = &hda_pvt->codec.core; 287 struct hda_codec *hcodec = &hda_pvt->codec; 288 struct hdac_ext_link *hlink; 289 hda_codec_patch_t patch; 290 int ret; 291 292 hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev)); 293 if (!hlink) { 294 dev_err(&hdev->dev, "hdac link not found\n"); 295 return -EIO; 296 } 297 298 snd_hdac_ext_bus_link_get(hdev->bus, hlink); 299 300 ret = snd_hda_codec_device_new(hcodec->bus, component->card->snd_card, 301 hdev->addr, hcodec); 302 if (ret < 0) { 303 dev_err(&hdev->dev, "failed to create hda codec %d\n", ret); 304 goto error_no_pm; 305 } 306 307 /* 308 * snd_hda_codec_device_new decrements the usage count so call get pm 309 * else the device will be powered off 310 */ 311 pm_runtime_get_noresume(&hdev->dev); 312 313 hcodec->bus->card = dapm->card->snd_card; 314 315 ret = snd_hda_codec_set_name(hcodec, hcodec->preset->name); 316 if (ret < 0) { 317 dev_err(&hdev->dev, "name failed %s\n", hcodec->preset->name); 318 goto error; 319 } 320 321 ret = snd_hdac_regmap_init(&hcodec->core); 322 if (ret < 0) { 323 dev_err(&hdev->dev, "regmap init failed\n"); 324 goto error; 325 } 326 327 patch = (hda_codec_patch_t)hcodec->preset->driver_data; 328 if (patch) { 329 ret = patch(hcodec); 330 if (ret < 0) { 331 dev_err(&hdev->dev, "patch failed %d\n", ret); 332 goto error; 333 } 334 } else { 335 dev_dbg(&hdev->dev, "no patch file found\n"); 336 } 337 338 ret = snd_hda_codec_parse_pcms(hcodec); 339 if (ret < 0) { 340 dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret); 341 goto error; 342 } 343 344 ret = snd_hda_codec_build_controls(hcodec); 345 if (ret < 0) { 346 dev_err(&hdev->dev, "unable to create controls %d\n", ret); 347 goto error; 348 } 349 350 hcodec->core.lazy_cache = true; 351 352 /* 353 * hdac_device core already sets the state to active and calls 354 * get_noresume. So enable runtime and set the device to suspend. 355 * pm_runtime_enable is also called during codec registeration 356 */ 357 pm_runtime_put(&hdev->dev); 358 pm_runtime_suspend(&hdev->dev); 359 360 return 0; 361 362 error: 363 pm_runtime_put(&hdev->dev); 364 error_no_pm: 365 snd_hdac_ext_bus_link_put(hdev->bus, hlink); 366 return ret; 367 } 368 369 static void hdac_hda_codec_remove(struct snd_soc_component *component) 370 { 371 struct hdac_hda_priv *hda_pvt = 372 snd_soc_component_get_drvdata(component); 373 struct hdac_device *hdev = &hda_pvt->codec.core; 374 struct hdac_ext_link *hlink = NULL; 375 376 hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev)); 377 if (!hlink) { 378 dev_err(&hdev->dev, "hdac link not found\n"); 379 return; 380 } 381 382 snd_hdac_ext_bus_link_put(hdev->bus, hlink); 383 pm_runtime_disable(&hdev->dev); 384 } 385 386 static const struct snd_soc_dapm_route hdac_hda_dapm_routes[] = { 387 {"AIF1TX", NULL, "Codec Input Pin1"}, 388 {"AIF2TX", NULL, "Codec Input Pin2"}, 389 {"AIF3TX", NULL, "Codec Input Pin3"}, 390 391 {"Codec Output Pin1", NULL, "AIF1RX"}, 392 {"Codec Output Pin2", NULL, "AIF2RX"}, 393 {"Codec Output Pin3", NULL, "AIF3RX"}, 394 }; 395 396 static const struct snd_soc_dapm_widget hdac_hda_dapm_widgets[] = { 397 /* Audio Interface */ 398 SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0, 399 SND_SOC_NOPM, 0, 0), 400 SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0, 401 SND_SOC_NOPM, 0, 0), 402 SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0, 403 SND_SOC_NOPM, 0, 0), 404 SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0, 405 SND_SOC_NOPM, 0, 0), 406 SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0, 407 SND_SOC_NOPM, 0, 0), 408 SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0, 409 SND_SOC_NOPM, 0, 0), 410 411 /* Input Pins */ 412 SND_SOC_DAPM_INPUT("Codec Input Pin1"), 413 SND_SOC_DAPM_INPUT("Codec Input Pin2"), 414 SND_SOC_DAPM_INPUT("Codec Input Pin3"), 415 416 /* Output Pins */ 417 SND_SOC_DAPM_OUTPUT("Codec Output Pin1"), 418 SND_SOC_DAPM_OUTPUT("Codec Output Pin2"), 419 SND_SOC_DAPM_OUTPUT("Codec Output Pin3"), 420 }; 421 422 static const struct snd_soc_component_driver hdac_hda_codec = { 423 .probe = hdac_hda_codec_probe, 424 .remove = hdac_hda_codec_remove, 425 .idle_bias_on = false, 426 .dapm_widgets = hdac_hda_dapm_widgets, 427 .num_dapm_widgets = ARRAY_SIZE(hdac_hda_dapm_widgets), 428 .dapm_routes = hdac_hda_dapm_routes, 429 .num_dapm_routes = ARRAY_SIZE(hdac_hda_dapm_routes), 430 }; 431 432 static int hdac_hda_dev_probe(struct hdac_device *hdev) 433 { 434 struct hdac_ext_link *hlink; 435 struct hdac_hda_priv *hda_pvt; 436 int ret; 437 438 /* hold the ref while we probe */ 439 hlink = snd_hdac_ext_bus_get_link(hdev->bus, dev_name(&hdev->dev)); 440 if (!hlink) { 441 dev_err(&hdev->dev, "hdac link not found\n"); 442 return -EIO; 443 } 444 snd_hdac_ext_bus_link_get(hdev->bus, hlink); 445 446 hda_pvt = hdac_to_hda_priv(hdev); 447 if (!hda_pvt) 448 return -ENOMEM; 449 450 /* ASoC specific initialization */ 451 ret = devm_snd_soc_register_component(&hdev->dev, 452 &hdac_hda_codec, hdac_hda_dais, 453 ARRAY_SIZE(hdac_hda_dais)); 454 if (ret < 0) { 455 dev_err(&hdev->dev, "failed to register HDA codec %d\n", ret); 456 return ret; 457 } 458 459 dev_set_drvdata(&hdev->dev, hda_pvt); 460 snd_hdac_ext_bus_link_put(hdev->bus, hlink); 461 462 return ret; 463 } 464 465 static int hdac_hda_dev_remove(struct hdac_device *hdev) 466 { 467 return 0; 468 } 469 470 static struct hdac_ext_bus_ops hdac_ops = { 471 .hdev_attach = hdac_hda_dev_probe, 472 .hdev_detach = hdac_hda_dev_remove, 473 }; 474 475 struct hdac_ext_bus_ops *snd_soc_hdac_hda_get_ops(void) 476 { 477 return &hdac_ops; 478 } 479 EXPORT_SYMBOL_GPL(snd_soc_hdac_hda_get_ops); 480 481 MODULE_LICENSE("GPL v2"); 482 MODULE_DESCRIPTION("ASoC Extensions for legacy HDA Drivers"); 483 MODULE_AUTHOR("Rakesh Ughreja<rakesh.a.ughreja@intel.com>"); 484