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
hda_codec_create_dais(struct hda_codec * codec,int pcm_count,struct snd_soc_dai_driver ** drivers)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
hda_codec_register_dais(struct hda_codec * codec,struct snd_soc_component * component)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
hda_codec_unregister_dais(struct hda_codec * codec,struct snd_soc_component * component)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 int stream;
130
131 list_for_each_entry(pcm, &codec->pcm_list_head, list) {
132 if (strcmp(dai->driver->name, pcm->name))
133 continue;
134
135 for_each_pcm_streams(stream)
136 snd_soc_dapm_free_widget(snd_soc_dai_get_widget(dai, stream));
137
138 snd_soc_unregister_dai(dai);
139 break;
140 }
141 }
142 }
143
hda_codec_probe_complete(struct hda_codec * codec)144 int hda_codec_probe_complete(struct hda_codec *codec)
145 {
146 struct hdac_device *hdev = &codec->core;
147 struct hdac_bus *bus = hdev->bus;
148 int ret;
149
150 ret = snd_hda_codec_build_controls(codec);
151 if (ret < 0) {
152 dev_err(&hdev->dev, "unable to create controls %d\n", ret);
153 goto out;
154 }
155
156 /* Bus suspended codecs as it does not manage their pm */
157 pm_runtime_set_active(&hdev->dev);
158 /* rpm was forbidden in snd_hda_codec_device_new() */
159 snd_hda_codec_set_power_save(codec, 2000);
160 snd_hda_codec_register(codec);
161 out:
162 /* Complement pm_runtime_get_sync(bus) in probe */
163 pm_runtime_mark_last_busy(bus->dev);
164 pm_runtime_put_autosuspend(bus->dev);
165
166 return ret;
167 }
168 EXPORT_SYMBOL_GPL(hda_codec_probe_complete);
169
170 /* Expects codec with usage_count=1 and status=suspended */
hda_codec_probe(struct snd_soc_component * component)171 static int hda_codec_probe(struct snd_soc_component *component)
172 {
173 struct hda_codec *codec = dev_to_hda_codec(component->dev);
174 struct hdac_device *hdev = &codec->core;
175 struct hdac_bus *bus = hdev->bus;
176 struct hdac_ext_link *hlink;
177 hda_codec_patch_t patch;
178 int ret;
179
180 #ifdef CONFIG_PM
181 WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 ||
182 !pm_runtime_status_suspended(&hdev->dev));
183 #endif
184
185 hlink = snd_hdac_ext_bus_get_hlink_by_addr(bus, hdev->addr);
186 if (!hlink) {
187 dev_err(&hdev->dev, "hdac link not found\n");
188 return -EIO;
189 }
190
191 pm_runtime_get_sync(bus->dev);
192 if (hda_codec_is_display(codec))
193 snd_hdac_display_power(bus, hdev->addr, true);
194 snd_hdac_ext_bus_link_get(bus, hlink);
195
196 ret = snd_hda_codec_device_new(codec->bus, component->card->snd_card, hdev->addr, codec,
197 false);
198 if (ret < 0) {
199 dev_err(&hdev->dev, "create hda codec failed: %d\n", ret);
200 goto device_new_err;
201 }
202
203 ret = snd_hda_codec_set_name(codec, codec->preset->name);
204 if (ret < 0) {
205 dev_err(&hdev->dev, "name failed %s\n", codec->preset->name);
206 goto err;
207 }
208
209 ret = snd_hdac_regmap_init(&codec->core);
210 if (ret < 0) {
211 dev_err(&hdev->dev, "regmap init failed\n");
212 goto err;
213 }
214
215 patch = (hda_codec_patch_t)codec->preset->driver_data;
216 if (!patch) {
217 dev_err(&hdev->dev, "no patch specified\n");
218 ret = -EINVAL;
219 goto err;
220 }
221
222 ret = patch(codec);
223 if (ret < 0) {
224 dev_err(&hdev->dev, "patch failed %d\n", ret);
225 goto err;
226 }
227
228 ret = snd_hda_codec_parse_pcms(codec);
229 if (ret < 0) {
230 dev_err(&hdev->dev, "unable to map pcms to dai %d\n", ret);
231 goto parse_pcms_err;
232 }
233
234 ret = hda_codec_register_dais(codec, component);
235 if (ret < 0) {
236 dev_err(&hdev->dev, "update dais failed: %d\n", ret);
237 goto parse_pcms_err;
238 }
239
240 if (!hda_codec_is_display(codec)) {
241 ret = hda_codec_probe_complete(codec);
242 if (ret < 0)
243 goto complete_err;
244 }
245
246 codec->core.lazy_cache = true;
247
248 return 0;
249
250 complete_err:
251 hda_codec_unregister_dais(codec, component);
252 parse_pcms_err:
253 if (codec->patch_ops.free)
254 codec->patch_ops.free(codec);
255 err:
256 snd_hda_codec_cleanup_for_unbind(codec);
257 device_new_err:
258 if (hda_codec_is_display(codec))
259 snd_hdac_display_power(bus, hdev->addr, false);
260
261 snd_hdac_ext_bus_link_put(bus, hlink);
262
263 pm_runtime_mark_last_busy(bus->dev);
264 pm_runtime_put_autosuspend(bus->dev);
265 return ret;
266 }
267
268 /* Leaves codec with usage_count=1 and status=suspended */
hda_codec_remove(struct snd_soc_component * component)269 static void hda_codec_remove(struct snd_soc_component *component)
270 {
271 struct hda_codec *codec = dev_to_hda_codec(component->dev);
272 struct hdac_device *hdev = &codec->core;
273 struct hdac_bus *bus = hdev->bus;
274 struct hdac_ext_link *hlink;
275 bool was_registered = codec->core.registered;
276
277 /* Don't allow any more runtime suspends */
278 pm_runtime_forbid(&hdev->dev);
279
280 hda_codec_unregister_dais(codec, component);
281
282 if (codec->patch_ops.free)
283 codec->patch_ops.free(codec);
284
285 snd_hda_codec_cleanup_for_unbind(codec);
286 pm_runtime_put_noidle(&hdev->dev);
287 /* snd_hdac_device_exit() is only called on bus remove */
288 pm_runtime_set_suspended(&hdev->dev);
289
290 if (hda_codec_is_display(codec))
291 snd_hdac_display_power(bus, hdev->addr, false);
292
293 hlink = snd_hdac_ext_bus_get_hlink_by_addr(bus, hdev->addr);
294 if (hlink)
295 snd_hdac_ext_bus_link_put(bus, hlink);
296 /*
297 * HDMI card's hda_codec_probe_complete() (see late_probe()) may
298 * not be called due to early error, leaving bus uc unbalanced
299 */
300 if (!was_registered) {
301 pm_runtime_mark_last_busy(bus->dev);
302 pm_runtime_put_autosuspend(bus->dev);
303 }
304
305 #ifdef CONFIG_PM
306 WARN_ON(atomic_read(&hdev->dev.power.usage_count) != 1 ||
307 !pm_runtime_status_suspended(&hdev->dev));
308 #endif
309 }
310
311 static const struct snd_soc_dapm_route hda_dapm_routes[] = {
312 {"AIF1TX", NULL, "Codec Input Pin1"},
313 {"AIF2TX", NULL, "Codec Input Pin2"},
314 {"AIF3TX", NULL, "Codec Input Pin3"},
315
316 {"Codec Output Pin1", NULL, "AIF1RX"},
317 {"Codec Output Pin2", NULL, "AIF2RX"},
318 {"Codec Output Pin3", NULL, "AIF3RX"},
319 };
320
321 static const struct snd_soc_dapm_widget hda_dapm_widgets[] = {
322 /* Audio Interface */
323 SND_SOC_DAPM_AIF_IN("AIF1RX", "Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0),
324 SND_SOC_DAPM_AIF_IN("AIF2RX", "Digital Codec Playback", 0, SND_SOC_NOPM, 0, 0),
325 SND_SOC_DAPM_AIF_IN("AIF3RX", "Alt Analog Codec Playback", 0, SND_SOC_NOPM, 0, 0),
326 SND_SOC_DAPM_AIF_OUT("AIF1TX", "Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0),
327 SND_SOC_DAPM_AIF_OUT("AIF2TX", "Digital Codec Capture", 0, SND_SOC_NOPM, 0, 0),
328 SND_SOC_DAPM_AIF_OUT("AIF3TX", "Alt Analog Codec Capture", 0, SND_SOC_NOPM, 0, 0),
329
330 /* Input Pins */
331 SND_SOC_DAPM_INPUT("Codec Input Pin1"),
332 SND_SOC_DAPM_INPUT("Codec Input Pin2"),
333 SND_SOC_DAPM_INPUT("Codec Input Pin3"),
334
335 /* Output Pins */
336 SND_SOC_DAPM_OUTPUT("Codec Output Pin1"),
337 SND_SOC_DAPM_OUTPUT("Codec Output Pin2"),
338 SND_SOC_DAPM_OUTPUT("Codec Output Pin3"),
339 };
340
341 static struct snd_soc_dai_driver card_binder_dai = {
342 .id = -1,
343 .name = "codec-probing-DAI",
344 };
345
hda_hdev_attach(struct hdac_device * hdev)346 static int hda_hdev_attach(struct hdac_device *hdev)
347 {
348 struct hda_codec *codec = dev_to_hda_codec(&hdev->dev);
349 struct snd_soc_component_driver *comp_drv;
350
351 comp_drv = devm_kzalloc(&hdev->dev, sizeof(*comp_drv), GFP_KERNEL);
352 if (!comp_drv)
353 return -ENOMEM;
354
355 /*
356 * It's save to rely on dev_name() rather than a copy as component
357 * driver's lifetime is directly tied to hda codec one
358 */
359 comp_drv->name = dev_name(&hdev->dev);
360 comp_drv->probe = hda_codec_probe;
361 comp_drv->remove = hda_codec_remove;
362 comp_drv->idle_bias_on = false;
363 if (!hda_codec_is_display(codec)) {
364 comp_drv->dapm_widgets = hda_dapm_widgets;
365 comp_drv->num_dapm_widgets = ARRAY_SIZE(hda_dapm_widgets);
366 comp_drv->dapm_routes = hda_dapm_routes;
367 comp_drv->num_dapm_routes = ARRAY_SIZE(hda_dapm_routes);
368 }
369
370 return snd_soc_register_component(&hdev->dev, comp_drv, &card_binder_dai, 1);
371 }
372
hda_hdev_detach(struct hdac_device * hdev)373 static int hda_hdev_detach(struct hdac_device *hdev)
374 {
375 struct hda_codec *codec = dev_to_hda_codec(&hdev->dev);
376
377 if (codec->core.registered)
378 cancel_delayed_work_sync(&codec->jackpoll_work);
379
380 snd_soc_unregister_component(&hdev->dev);
381
382 return 0;
383 }
384
385 const struct hdac_ext_bus_ops soc_hda_ext_bus_ops = {
386 .hdev_attach = hda_hdev_attach,
387 .hdev_detach = hda_hdev_detach,
388 };
389 EXPORT_SYMBOL_GPL(soc_hda_ext_bus_ops);
390
391 MODULE_DESCRIPTION("HD-Audio codec driver");
392 MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
393 MODULE_LICENSE("GPL");
394
