1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2 //
3 // This file is provided under a dual BSD/GPLv2 license.  When using or
4 // redistributing this file, you may do so under either license.
5 //
6 // Copyright(c) 2018 Intel Corporation. All rights reserved.
7 //
8 // Authors: Liam Girdwood <liam.r.girdwood@linux.intel.com>
9 //	    Ranjani Sridharan <ranjani.sridharan@linux.intel.com>
10 //	    Rander Wang <rander.wang@intel.com>
11 //          Keyon Jie <yang.jie@linux.intel.com>
12 //
13 
14 /*
15  * Hardware interface for generic Intel audio DSP HDA IP
16  */
17 
18 #include <sound/hdaudio_ext.h>
19 #include <sound/hda_register.h>
20 
21 #include <linux/acpi.h>
22 #include <linux/module.h>
23 #include <linux/soundwire/sdw.h>
24 #include <linux/soundwire/sdw_intel.h>
25 #include <sound/intel-dsp-config.h>
26 #include <sound/intel-nhlt.h>
27 #include <sound/sof.h>
28 #include <sound/sof/xtensa.h>
29 #include "../sof-audio.h"
30 #include "../sof-pci-dev.h"
31 #include "../ops.h"
32 #include "hda.h"
33 
34 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
35 #include <sound/soc-acpi-intel-match.h>
36 #endif
37 
38 /* platform specific devices */
39 #include "shim.h"
40 
41 #define EXCEPT_MAX_HDR_SIZE	0x400
42 #define HDA_EXT_ROM_STATUS_SIZE 8
43 
hda_ctrl_dai_widget_setup(struct snd_soc_dapm_widget * w,unsigned int quirk_flags,struct snd_sof_dai_config_data * data)44 int hda_ctrl_dai_widget_setup(struct snd_soc_dapm_widget *w, unsigned int quirk_flags,
45 			      struct snd_sof_dai_config_data *data)
46 {
47 	struct snd_sof_widget *swidget = w->dobj.private;
48 	struct snd_soc_component *component = swidget->scomp;
49 	struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component);
50 	const struct sof_ipc_tplg_ops *tplg_ops = sdev->ipc->ops->tplg;
51 	struct snd_sof_dai *sof_dai = swidget->private;
52 	int ret;
53 
54 	if (!sof_dai) {
55 		dev_err(sdev->dev, "%s: No DAI for DAI widget %s\n", __func__, w->name);
56 		return -EINVAL;
57 	}
58 
59 	if (tplg_ops->dai_config) {
60 		unsigned int flags;
61 
62 		/* set HW_PARAMS flag along with quirks */
63 		flags = SOF_DAI_CONFIG_FLAGS_HW_PARAMS |
64 			quirk_flags << SOF_DAI_CONFIG_FLAGS_QUIRK_SHIFT;
65 
66 		ret = tplg_ops->dai_config(sdev, swidget, flags, data);
67 		if (ret < 0) {
68 			dev_err(sdev->dev, "%s: DAI config failed for widget %s\n", __func__,
69 				w->name);
70 			return ret;
71 		}
72 	}
73 
74 	return 0;
75 }
76 
hda_ctrl_dai_widget_free(struct snd_soc_dapm_widget * w,unsigned int quirk_flags,struct snd_sof_dai_config_data * data)77 int hda_ctrl_dai_widget_free(struct snd_soc_dapm_widget *w, unsigned int quirk_flags,
78 			     struct snd_sof_dai_config_data *data)
79 {
80 	struct snd_sof_widget *swidget = w->dobj.private;
81 	struct snd_soc_component *component = swidget->scomp;
82 	struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component);
83 	const struct sof_ipc_tplg_ops *tplg_ops = sdev->ipc->ops->tplg;
84 	struct snd_sof_dai *sof_dai = swidget->private;
85 
86 	if (!sof_dai) {
87 		dev_err(sdev->dev, "%s: No DAI for BE DAI widget %s\n", __func__, w->name);
88 		return -EINVAL;
89 	}
90 
91 	if (tplg_ops->dai_config) {
92 		unsigned int flags;
93 		int ret;
94 
95 		/* set HW_FREE flag along with any quirks */
96 		flags = SOF_DAI_CONFIG_FLAGS_HW_FREE |
97 			quirk_flags << SOF_DAI_CONFIG_FLAGS_QUIRK_SHIFT;
98 
99 		ret = tplg_ops->dai_config(sdev, swidget, flags, data);
100 		if (ret < 0)
101 			dev_err(sdev->dev, "%s: DAI config failed for widget '%s'\n", __func__,
102 				w->name);
103 	}
104 
105 	return 0;
106 }
107 
108 #if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
109 
110 /*
111  * The default for SoundWire clock stop quirks is to power gate the IP
112  * and do a Bus Reset, this will need to be modified when the DSP
113  * needs to remain in D0i3 so that the Master does not lose context
114  * and enumeration is not required on clock restart
115  */
116 static int sdw_clock_stop_quirks = SDW_INTEL_CLK_STOP_BUS_RESET;
117 module_param(sdw_clock_stop_quirks, int, 0444);
118 MODULE_PARM_DESC(sdw_clock_stop_quirks, "SOF SoundWire clock stop quirks");
119 
sdw_params_stream(struct device * dev,struct sdw_intel_stream_params_data * params_data)120 static int sdw_params_stream(struct device *dev,
121 			     struct sdw_intel_stream_params_data *params_data)
122 {
123 	struct snd_soc_dai *d = params_data->dai;
124 	struct snd_sof_dai_config_data data;
125 	struct snd_soc_dapm_widget *w;
126 
127 	w = snd_soc_dai_get_widget(d, params_data->stream);
128 	data.dai_index = (params_data->link_id << 8) | d->id;
129 	data.dai_data = params_data->alh_stream_id;
130 
131 	return hda_ctrl_dai_widget_setup(w, SOF_DAI_CONFIG_FLAGS_NONE, &data);
132 }
133 
sdw_free_stream(struct device * dev,struct sdw_intel_stream_free_data * free_data)134 static int sdw_free_stream(struct device *dev,
135 			   struct sdw_intel_stream_free_data *free_data)
136 {
137 	struct snd_soc_dai *d = free_data->dai;
138 	struct snd_sof_dai_config_data data;
139 	struct snd_soc_dapm_widget *w;
140 
141 	w = snd_soc_dai_get_widget(d, free_data->stream);
142 	data.dai_index = (free_data->link_id << 8) | d->id;
143 
144 	/* send invalid stream_id */
145 	data.dai_data = 0xFFFF;
146 
147 	return hda_ctrl_dai_widget_free(w, SOF_DAI_CONFIG_FLAGS_NONE, &data);
148 }
149 
150 static const struct sdw_intel_ops sdw_callback = {
151 	.params_stream = sdw_params_stream,
152 	.free_stream = sdw_free_stream,
153 };
154 
hda_sdw_int_enable(struct snd_sof_dev * sdev,bool enable)155 void hda_sdw_int_enable(struct snd_sof_dev *sdev, bool enable)
156 {
157 	sdw_intel_enable_irq(sdev->bar[HDA_DSP_BAR], enable);
158 }
159 
hda_sdw_acpi_scan(struct snd_sof_dev * sdev)160 static int hda_sdw_acpi_scan(struct snd_sof_dev *sdev)
161 {
162 	struct sof_intel_hda_dev *hdev;
163 	acpi_handle handle;
164 	int ret;
165 
166 	handle = ACPI_HANDLE(sdev->dev);
167 
168 	/* save ACPI info for the probe step */
169 	hdev = sdev->pdata->hw_pdata;
170 
171 	ret = sdw_intel_acpi_scan(handle, &hdev->info);
172 	if (ret < 0)
173 		return -EINVAL;
174 
175 	return 0;
176 }
177 
hda_sdw_probe(struct snd_sof_dev * sdev)178 static int hda_sdw_probe(struct snd_sof_dev *sdev)
179 {
180 	struct sof_intel_hda_dev *hdev;
181 	struct sdw_intel_res res;
182 	void *sdw;
183 
184 	hdev = sdev->pdata->hw_pdata;
185 
186 	memset(&res, 0, sizeof(res));
187 
188 	res.mmio_base = sdev->bar[HDA_DSP_BAR];
189 	res.shim_base = hdev->desc->sdw_shim_base;
190 	res.alh_base = hdev->desc->sdw_alh_base;
191 	res.irq = sdev->ipc_irq;
192 	res.handle = hdev->info.handle;
193 	res.parent = sdev->dev;
194 	res.ops = &sdw_callback;
195 	res.dev = sdev->dev;
196 	res.clock_stop_quirks = sdw_clock_stop_quirks;
197 
198 	/*
199 	 * ops and arg fields are not populated for now,
200 	 * they will be needed when the DAI callbacks are
201 	 * provided
202 	 */
203 
204 	/* we could filter links here if needed, e.g for quirks */
205 	res.count = hdev->info.count;
206 	res.link_mask = hdev->info.link_mask;
207 
208 	sdw = sdw_intel_probe(&res);
209 	if (!sdw) {
210 		dev_err(sdev->dev, "error: SoundWire probe failed\n");
211 		return -EINVAL;
212 	}
213 
214 	/* save context */
215 	hdev->sdw = sdw;
216 
217 	return 0;
218 }
219 
hda_sdw_startup(struct snd_sof_dev * sdev)220 int hda_sdw_startup(struct snd_sof_dev *sdev)
221 {
222 	struct sof_intel_hda_dev *hdev;
223 	struct snd_sof_pdata *pdata = sdev->pdata;
224 
225 	hdev = sdev->pdata->hw_pdata;
226 
227 	if (!hdev->sdw)
228 		return 0;
229 
230 	if (pdata->machine && !pdata->machine->mach_params.link_mask)
231 		return 0;
232 
233 	return sdw_intel_startup(hdev->sdw);
234 }
235 
hda_sdw_exit(struct snd_sof_dev * sdev)236 static int hda_sdw_exit(struct snd_sof_dev *sdev)
237 {
238 	struct sof_intel_hda_dev *hdev;
239 
240 	hdev = sdev->pdata->hw_pdata;
241 
242 	hda_sdw_int_enable(sdev, false);
243 
244 	if (hdev->sdw)
245 		sdw_intel_exit(hdev->sdw);
246 	hdev->sdw = NULL;
247 
248 	return 0;
249 }
250 
hda_common_check_sdw_irq(struct snd_sof_dev * sdev)251 bool hda_common_check_sdw_irq(struct snd_sof_dev *sdev)
252 {
253 	struct sof_intel_hda_dev *hdev;
254 	bool ret = false;
255 	u32 irq_status;
256 
257 	hdev = sdev->pdata->hw_pdata;
258 
259 	if (!hdev->sdw)
260 		return ret;
261 
262 	/* store status */
263 	irq_status = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPIS2);
264 
265 	/* invalid message ? */
266 	if (irq_status == 0xffffffff)
267 		goto out;
268 
269 	/* SDW message ? */
270 	if (irq_status & HDA_DSP_REG_ADSPIS2_SNDW)
271 		ret = true;
272 
273 out:
274 	return ret;
275 }
276 
hda_dsp_check_sdw_irq(struct snd_sof_dev * sdev)277 static bool hda_dsp_check_sdw_irq(struct snd_sof_dev *sdev)
278 {
279 	const struct sof_intel_dsp_desc *chip;
280 
281 	chip = get_chip_info(sdev->pdata);
282 	if (chip && chip->check_sdw_irq)
283 		return chip->check_sdw_irq(sdev);
284 
285 	return false;
286 }
287 
hda_dsp_sdw_thread(int irq,void * context)288 static irqreturn_t hda_dsp_sdw_thread(int irq, void *context)
289 {
290 	return sdw_intel_thread(irq, context);
291 }
292 
hda_sdw_check_wakeen_irq(struct snd_sof_dev * sdev)293 static bool hda_sdw_check_wakeen_irq(struct snd_sof_dev *sdev)
294 {
295 	struct sof_intel_hda_dev *hdev;
296 
297 	hdev = sdev->pdata->hw_pdata;
298 	if (hdev->sdw &&
299 	    snd_sof_dsp_read(sdev, HDA_DSP_BAR,
300 			     hdev->desc->sdw_shim_base + SDW_SHIM_WAKESTS))
301 		return true;
302 
303 	return false;
304 }
305 
hda_sdw_process_wakeen(struct snd_sof_dev * sdev)306 void hda_sdw_process_wakeen(struct snd_sof_dev *sdev)
307 {
308 	struct sof_intel_hda_dev *hdev;
309 
310 	hdev = sdev->pdata->hw_pdata;
311 	if (!hdev->sdw)
312 		return;
313 
314 	sdw_intel_process_wakeen_event(hdev->sdw);
315 }
316 
317 #else /* IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE) */
hda_sdw_acpi_scan(struct snd_sof_dev * sdev)318 static inline int hda_sdw_acpi_scan(struct snd_sof_dev *sdev)
319 {
320 	return 0;
321 }
322 
hda_sdw_probe(struct snd_sof_dev * sdev)323 static inline int hda_sdw_probe(struct snd_sof_dev *sdev)
324 {
325 	return 0;
326 }
327 
hda_sdw_exit(struct snd_sof_dev * sdev)328 static inline int hda_sdw_exit(struct snd_sof_dev *sdev)
329 {
330 	return 0;
331 }
332 
hda_dsp_check_sdw_irq(struct snd_sof_dev * sdev)333 static inline bool hda_dsp_check_sdw_irq(struct snd_sof_dev *sdev)
334 {
335 	return false;
336 }
337 
hda_dsp_sdw_thread(int irq,void * context)338 static inline irqreturn_t hda_dsp_sdw_thread(int irq, void *context)
339 {
340 	return IRQ_HANDLED;
341 }
342 
hda_sdw_check_wakeen_irq(struct snd_sof_dev * sdev)343 static inline bool hda_sdw_check_wakeen_irq(struct snd_sof_dev *sdev)
344 {
345 	return false;
346 }
347 
348 #endif /* IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE) */
349 
350 /*
351  * Debug
352  */
353 
354 struct hda_dsp_msg_code {
355 	u32 code;
356 	const char *msg;
357 };
358 
359 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG)
360 static bool hda_use_msi = true;
361 module_param_named(use_msi, hda_use_msi, bool, 0444);
362 MODULE_PARM_DESC(use_msi, "SOF HDA use PCI MSI mode");
363 #else
364 #define hda_use_msi	(1)
365 #endif
366 
367 int sof_hda_position_quirk = SOF_HDA_POSITION_QUIRK_USE_DPIB_REGISTERS;
368 module_param_named(position_quirk, sof_hda_position_quirk, int, 0444);
369 MODULE_PARM_DESC(position_quirk, "SOF HDaudio position quirk");
370 
371 static char *hda_model;
372 module_param(hda_model, charp, 0444);
373 MODULE_PARM_DESC(hda_model, "Use the given HDA board model.");
374 
375 static int dmic_num_override = -1;
376 module_param_named(dmic_num, dmic_num_override, int, 0444);
377 MODULE_PARM_DESC(dmic_num, "SOF HDA DMIC number");
378 
379 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
380 static bool hda_codec_use_common_hdmi = IS_ENABLED(CONFIG_SND_HDA_CODEC_HDMI);
381 module_param_named(use_common_hdmi, hda_codec_use_common_hdmi, bool, 0444);
382 MODULE_PARM_DESC(use_common_hdmi, "SOF HDA use common HDMI codec driver");
383 #endif
384 
385 static const struct hda_dsp_msg_code hda_dsp_rom_msg[] = {
386 	{HDA_DSP_ROM_FW_MANIFEST_LOADED, "status: manifest loaded"},
387 	{HDA_DSP_ROM_FW_FW_LOADED, "status: fw loaded"},
388 	{HDA_DSP_ROM_FW_ENTERED, "status: fw entered"},
389 	{HDA_DSP_ROM_CSE_ERROR, "error: cse error"},
390 	{HDA_DSP_ROM_CSE_WRONG_RESPONSE, "error: cse wrong response"},
391 	{HDA_DSP_ROM_IMR_TO_SMALL, "error: IMR too small"},
392 	{HDA_DSP_ROM_BASE_FW_NOT_FOUND, "error: base fw not found"},
393 	{HDA_DSP_ROM_CSE_VALIDATION_FAILED, "error: signature verification failed"},
394 	{HDA_DSP_ROM_IPC_FATAL_ERROR, "error: ipc fatal error"},
395 	{HDA_DSP_ROM_L2_CACHE_ERROR, "error: L2 cache error"},
396 	{HDA_DSP_ROM_LOAD_OFFSET_TO_SMALL, "error: load offset too small"},
397 	{HDA_DSP_ROM_API_PTR_INVALID, "error: API ptr invalid"},
398 	{HDA_DSP_ROM_BASEFW_INCOMPAT, "error: base fw incompatible"},
399 	{HDA_DSP_ROM_UNHANDLED_INTERRUPT, "error: unhandled interrupt"},
400 	{HDA_DSP_ROM_MEMORY_HOLE_ECC, "error: ECC memory hole"},
401 	{HDA_DSP_ROM_KERNEL_EXCEPTION, "error: kernel exception"},
402 	{HDA_DSP_ROM_USER_EXCEPTION, "error: user exception"},
403 	{HDA_DSP_ROM_UNEXPECTED_RESET, "error: unexpected reset"},
404 	{HDA_DSP_ROM_NULL_FW_ENTRY,	"error: null FW entry point"},
405 };
406 
hda_dsp_get_status(struct snd_sof_dev * sdev,const char * level)407 static void hda_dsp_get_status(struct snd_sof_dev *sdev, const char *level)
408 {
409 	const struct sof_intel_dsp_desc *chip;
410 	u32 status;
411 	int i;
412 
413 	chip = get_chip_info(sdev->pdata);
414 	status = snd_sof_dsp_read(sdev, HDA_DSP_BAR,
415 				  chip->rom_status_reg);
416 
417 	for (i = 0; i < ARRAY_SIZE(hda_dsp_rom_msg); i++) {
418 		if (status == hda_dsp_rom_msg[i].code) {
419 			dev_printk(level, sdev->dev, "%s - code %8.8x\n",
420 				   hda_dsp_rom_msg[i].msg, status);
421 			return;
422 		}
423 	}
424 
425 	/* not for us, must be generic sof message */
426 	dev_dbg(sdev->dev, "unknown ROM status value %8.8x\n", status);
427 }
428 
hda_dsp_get_registers(struct snd_sof_dev * sdev,struct sof_ipc_dsp_oops_xtensa * xoops,struct sof_ipc_panic_info * panic_info,u32 * stack,size_t stack_words)429 static void hda_dsp_get_registers(struct snd_sof_dev *sdev,
430 				  struct sof_ipc_dsp_oops_xtensa *xoops,
431 				  struct sof_ipc_panic_info *panic_info,
432 				  u32 *stack, size_t stack_words)
433 {
434 	u32 offset = sdev->dsp_oops_offset;
435 
436 	/* first read registers */
437 	sof_mailbox_read(sdev, offset, xoops, sizeof(*xoops));
438 
439 	/* note: variable AR register array is not read */
440 
441 	/* then get panic info */
442 	if (xoops->arch_hdr.totalsize > EXCEPT_MAX_HDR_SIZE) {
443 		dev_err(sdev->dev, "invalid header size 0x%x. FW oops is bogus\n",
444 			xoops->arch_hdr.totalsize);
445 		return;
446 	}
447 	offset += xoops->arch_hdr.totalsize;
448 	sof_block_read(sdev, sdev->mmio_bar, offset,
449 		       panic_info, sizeof(*panic_info));
450 
451 	/* then get the stack */
452 	offset += sizeof(*panic_info);
453 	sof_block_read(sdev, sdev->mmio_bar, offset, stack,
454 		       stack_words * sizeof(u32));
455 }
456 
457 /* dump the first 8 dwords representing the extended ROM status */
hda_dsp_dump_ext_rom_status(struct snd_sof_dev * sdev,const char * level,u32 flags)458 static void hda_dsp_dump_ext_rom_status(struct snd_sof_dev *sdev, const char *level,
459 					u32 flags)
460 {
461 	const struct sof_intel_dsp_desc *chip;
462 	char msg[128];
463 	int len = 0;
464 	u32 value;
465 	int i;
466 
467 	chip = get_chip_info(sdev->pdata);
468 	for (i = 0; i < HDA_EXT_ROM_STATUS_SIZE; i++) {
469 		value = snd_sof_dsp_read(sdev, HDA_DSP_BAR, chip->rom_status_reg + i * 0x4);
470 		len += scnprintf(msg + len, sizeof(msg) - len, " 0x%x", value);
471 	}
472 
473 	dev_printk(level, sdev->dev, "extended rom status: %s", msg);
474 
475 }
476 
hda_dsp_dump(struct snd_sof_dev * sdev,u32 flags)477 void hda_dsp_dump(struct snd_sof_dev *sdev, u32 flags)
478 {
479 	char *level = (flags & SOF_DBG_DUMP_OPTIONAL) ? KERN_DEBUG : KERN_ERR;
480 	struct sof_ipc_dsp_oops_xtensa xoops;
481 	struct sof_ipc_panic_info panic_info;
482 	u32 stack[HDA_DSP_STACK_DUMP_SIZE];
483 
484 	/* print ROM/FW status */
485 	hda_dsp_get_status(sdev, level);
486 
487 	if (flags & SOF_DBG_DUMP_REGS) {
488 		u32 status = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_SRAM_REG_FW_STATUS);
489 		u32 panic = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_SRAM_REG_FW_TRACEP);
490 
491 		hda_dsp_get_registers(sdev, &xoops, &panic_info, stack,
492 				      HDA_DSP_STACK_DUMP_SIZE);
493 		sof_print_oops_and_stack(sdev, level, status, panic, &xoops,
494 					 &panic_info, stack, HDA_DSP_STACK_DUMP_SIZE);
495 	} else {
496 		hda_dsp_dump_ext_rom_status(sdev, level, flags);
497 	}
498 }
499 
hda_check_ipc_irq(struct snd_sof_dev * sdev)500 static bool hda_check_ipc_irq(struct snd_sof_dev *sdev)
501 {
502 	const struct sof_intel_dsp_desc *chip;
503 
504 	chip = get_chip_info(sdev->pdata);
505 	if (chip && chip->check_ipc_irq)
506 		return chip->check_ipc_irq(sdev);
507 
508 	return false;
509 }
510 
hda_ipc_irq_dump(struct snd_sof_dev * sdev)511 void hda_ipc_irq_dump(struct snd_sof_dev *sdev)
512 {
513 	struct hdac_bus *bus = sof_to_bus(sdev);
514 	u32 adspis;
515 	u32 intsts;
516 	u32 intctl;
517 	u32 ppsts;
518 	u8 rirbsts;
519 
520 	/* read key IRQ stats and config registers */
521 	adspis = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_ADSPIS);
522 	intsts = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTSTS);
523 	intctl = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTCTL);
524 	ppsts = snd_sof_dsp_read(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPSTS);
525 	rirbsts = snd_hdac_chip_readb(bus, RIRBSTS);
526 
527 	dev_err(sdev->dev, "hda irq intsts 0x%8.8x intlctl 0x%8.8x rirb %2.2x\n",
528 		intsts, intctl, rirbsts);
529 	dev_err(sdev->dev, "dsp irq ppsts 0x%8.8x adspis 0x%8.8x\n", ppsts, adspis);
530 }
531 
hda_ipc_dump(struct snd_sof_dev * sdev)532 void hda_ipc_dump(struct snd_sof_dev *sdev)
533 {
534 	u32 hipcie;
535 	u32 hipct;
536 	u32 hipcctl;
537 
538 	hda_ipc_irq_dump(sdev);
539 
540 	/* read IPC status */
541 	hipcie = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_HIPCIE);
542 	hipct = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_HIPCT);
543 	hipcctl = snd_sof_dsp_read(sdev, HDA_DSP_BAR, HDA_DSP_REG_HIPCCTL);
544 
545 	/* dump the IPC regs */
546 	/* TODO: parse the raw msg */
547 	dev_err(sdev->dev, "host status 0x%8.8x dsp status 0x%8.8x mask 0x%8.8x\n",
548 		hipcie, hipct, hipcctl);
549 }
550 
hda_init(struct snd_sof_dev * sdev)551 static int hda_init(struct snd_sof_dev *sdev)
552 {
553 	struct hda_bus *hbus;
554 	struct hdac_bus *bus;
555 	struct pci_dev *pci = to_pci_dev(sdev->dev);
556 	int ret;
557 
558 	hbus = sof_to_hbus(sdev);
559 	bus = sof_to_bus(sdev);
560 
561 	/* HDA bus init */
562 	sof_hda_bus_init(bus, &pci->dev);
563 
564 	if (sof_hda_position_quirk == SOF_HDA_POSITION_QUIRK_USE_DPIB_REGISTERS)
565 		bus->use_posbuf = 0;
566 	else
567 		bus->use_posbuf = 1;
568 	bus->bdl_pos_adj = 0;
569 	bus->sync_write = 1;
570 
571 	mutex_init(&hbus->prepare_mutex);
572 	hbus->pci = pci;
573 	hbus->mixer_assigned = -1;
574 	hbus->modelname = hda_model;
575 
576 	/* initialise hdac bus */
577 	bus->addr = pci_resource_start(pci, 0);
578 	bus->remap_addr = pci_ioremap_bar(pci, 0);
579 	if (!bus->remap_addr) {
580 		dev_err(bus->dev, "error: ioremap error\n");
581 		return -ENXIO;
582 	}
583 
584 	/* HDA base */
585 	sdev->bar[HDA_DSP_HDA_BAR] = bus->remap_addr;
586 
587 	/* init i915 and HDMI codecs */
588 	ret = hda_codec_i915_init(sdev);
589 	if (ret < 0)
590 		dev_warn(sdev->dev, "init of i915 and HDMI codec failed\n");
591 
592 	/* get controller capabilities */
593 	ret = hda_dsp_ctrl_get_caps(sdev);
594 	if (ret < 0)
595 		dev_err(sdev->dev, "error: get caps error\n");
596 
597 	return ret;
598 }
599 
check_dmic_num(struct snd_sof_dev * sdev)600 static int check_dmic_num(struct snd_sof_dev *sdev)
601 {
602 	struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata;
603 	struct nhlt_acpi_table *nhlt;
604 	int dmic_num = 0;
605 
606 	nhlt = hdev->nhlt;
607 	if (nhlt)
608 		dmic_num = intel_nhlt_get_dmic_geo(sdev->dev, nhlt);
609 
610 	/* allow for module parameter override */
611 	if (dmic_num_override != -1) {
612 		dev_dbg(sdev->dev,
613 			"overriding DMICs detected in NHLT tables %d by kernel param %d\n",
614 			dmic_num, dmic_num_override);
615 		dmic_num = dmic_num_override;
616 	}
617 
618 	if (dmic_num < 0 || dmic_num > 4) {
619 		dev_dbg(sdev->dev, "invalid dmic_number %d\n", dmic_num);
620 		dmic_num = 0;
621 	}
622 
623 	return dmic_num;
624 }
625 
check_nhlt_ssp_mask(struct snd_sof_dev * sdev)626 static int check_nhlt_ssp_mask(struct snd_sof_dev *sdev)
627 {
628 	struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata;
629 	struct nhlt_acpi_table *nhlt;
630 	int ssp_mask = 0;
631 
632 	nhlt = hdev->nhlt;
633 	if (!nhlt)
634 		return ssp_mask;
635 
636 	if (intel_nhlt_has_endpoint_type(nhlt, NHLT_LINK_SSP)) {
637 		ssp_mask = intel_nhlt_ssp_endpoint_mask(nhlt, NHLT_DEVICE_I2S);
638 		if (ssp_mask)
639 			dev_info(sdev->dev, "NHLT_DEVICE_I2S detected, ssp_mask %#x\n", ssp_mask);
640 	}
641 
642 	return ssp_mask;
643 }
644 
645 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA) || IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
646 
fixup_tplg_name(struct snd_sof_dev * sdev,const char * sof_tplg_filename,const char * idisp_str,const char * dmic_str)647 static const char *fixup_tplg_name(struct snd_sof_dev *sdev,
648 				   const char *sof_tplg_filename,
649 				   const char *idisp_str,
650 				   const char *dmic_str)
651 {
652 	const char *tplg_filename = NULL;
653 	char *filename, *tmp;
654 	const char *split_ext;
655 
656 	filename = kstrdup(sof_tplg_filename, GFP_KERNEL);
657 	if (!filename)
658 		return NULL;
659 
660 	/* this assumes a .tplg extension */
661 	tmp = filename;
662 	split_ext = strsep(&tmp, ".");
663 	if (split_ext)
664 		tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,
665 					       "%s%s%s.tplg",
666 					       split_ext, idisp_str, dmic_str);
667 	kfree(filename);
668 
669 	return tplg_filename;
670 }
671 
dmic_topology_fixup(struct snd_sof_dev * sdev,const char ** tplg_filename,const char * idisp_str,int * dmic_found)672 static int dmic_topology_fixup(struct snd_sof_dev *sdev,
673 			       const char **tplg_filename,
674 			       const char *idisp_str,
675 			       int *dmic_found)
676 {
677 	const char *default_tplg_filename = *tplg_filename;
678 	const char *fixed_tplg_filename;
679 	const char *dmic_str;
680 	int dmic_num;
681 
682 	/* first check for DMICs (using NHLT or module parameter) */
683 	dmic_num = check_dmic_num(sdev);
684 
685 	switch (dmic_num) {
686 	case 1:
687 		dmic_str = "-1ch";
688 		break;
689 	case 2:
690 		dmic_str = "-2ch";
691 		break;
692 	case 3:
693 		dmic_str = "-3ch";
694 		break;
695 	case 4:
696 		dmic_str = "-4ch";
697 		break;
698 	default:
699 		dmic_num = 0;
700 		dmic_str = "";
701 		break;
702 	}
703 
704 	fixed_tplg_filename = fixup_tplg_name(sdev, default_tplg_filename,
705 					      idisp_str, dmic_str);
706 	if (!fixed_tplg_filename)
707 		return -ENOMEM;
708 
709 	dev_info(sdev->dev, "DMICs detected in NHLT tables: %d\n", dmic_num);
710 	*dmic_found = dmic_num;
711 	*tplg_filename = fixed_tplg_filename;
712 
713 	return 0;
714 }
715 #endif
716 
hda_init_caps(struct snd_sof_dev * sdev)717 static int hda_init_caps(struct snd_sof_dev *sdev)
718 {
719 	struct hdac_bus *bus = sof_to_bus(sdev);
720 	struct snd_sof_pdata *pdata = sdev->pdata;
721 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
722 	struct hdac_ext_link *hlink;
723 #endif
724 	struct sof_intel_hda_dev *hdev = pdata->hw_pdata;
725 	u32 link_mask;
726 	int ret = 0;
727 
728 	/* check if dsp is there */
729 	if (bus->ppcap)
730 		dev_dbg(sdev->dev, "PP capability, will probe DSP later.\n");
731 
732 	/* Init HDA controller after i915 init */
733 	ret = hda_dsp_ctrl_init_chip(sdev, true);
734 	if (ret < 0) {
735 		dev_err(bus->dev, "error: init chip failed with ret: %d\n",
736 			ret);
737 		return ret;
738 	}
739 
740 	/* scan SoundWire capabilities exposed by DSDT */
741 	ret = hda_sdw_acpi_scan(sdev);
742 	if (ret < 0) {
743 		dev_dbg(sdev->dev, "skipping SoundWire, not detected with ACPI scan\n");
744 		goto skip_soundwire;
745 	}
746 
747 	link_mask = hdev->info.link_mask;
748 	if (!link_mask) {
749 		dev_dbg(sdev->dev, "skipping SoundWire, no links enabled\n");
750 		goto skip_soundwire;
751 	}
752 
753 	/*
754 	 * probe/allocate SoundWire resources.
755 	 * The hardware configuration takes place in hda_sdw_startup
756 	 * after power rails are enabled.
757 	 * It's entirely possible to have a mix of I2S/DMIC/SoundWire
758 	 * devices, so we allocate the resources in all cases.
759 	 */
760 	ret = hda_sdw_probe(sdev);
761 	if (ret < 0) {
762 		dev_err(sdev->dev, "error: SoundWire probe error\n");
763 		return ret;
764 	}
765 
766 skip_soundwire:
767 
768 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
769 	if (bus->mlcap)
770 		snd_hdac_ext_bus_get_ml_capabilities(bus);
771 
772 	/* create codec instances */
773 	hda_codec_probe_bus(sdev, hda_codec_use_common_hdmi);
774 
775 	if (!HDA_IDISP_CODEC(bus->codec_mask))
776 		hda_codec_i915_display_power(sdev, false);
777 
778 	/*
779 	 * we are done probing so decrement link counts
780 	 */
781 	list_for_each_entry(hlink, &bus->hlink_list, list)
782 		snd_hdac_ext_bus_link_put(bus, hlink);
783 #endif
784 	return 0;
785 }
786 
hda_check_for_state_change(struct snd_sof_dev * sdev)787 static void hda_check_for_state_change(struct snd_sof_dev *sdev)
788 {
789 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
790 	struct hdac_bus *bus = sof_to_bus(sdev);
791 	unsigned int codec_mask;
792 
793 	codec_mask = snd_hdac_chip_readw(bus, STATESTS);
794 	if (codec_mask) {
795 		hda_codec_jack_check(sdev);
796 		snd_hdac_chip_writew(bus, STATESTS, codec_mask);
797 	}
798 #endif
799 }
800 
hda_dsp_interrupt_handler(int irq,void * context)801 static irqreturn_t hda_dsp_interrupt_handler(int irq, void *context)
802 {
803 	struct snd_sof_dev *sdev = context;
804 
805 	/*
806 	 * Get global interrupt status. It includes all hardware interrupt
807 	 * sources in the Intel HD Audio controller.
808 	 */
809 	if (snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTSTS) &
810 	    SOF_HDA_INTSTS_GIS) {
811 
812 		/* disable GIE interrupt */
813 		snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR,
814 					SOF_HDA_INTCTL,
815 					SOF_HDA_INT_GLOBAL_EN,
816 					0);
817 
818 		return IRQ_WAKE_THREAD;
819 	}
820 
821 	return IRQ_NONE;
822 }
823 
hda_dsp_interrupt_thread(int irq,void * context)824 static irqreturn_t hda_dsp_interrupt_thread(int irq, void *context)
825 {
826 	struct snd_sof_dev *sdev = context;
827 	struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata;
828 
829 	/* deal with streams and controller first */
830 	if (hda_dsp_check_stream_irq(sdev))
831 		hda_dsp_stream_threaded_handler(irq, sdev);
832 
833 	if (hda_check_ipc_irq(sdev))
834 		sof_ops(sdev)->irq_thread(irq, sdev);
835 
836 	if (hda_dsp_check_sdw_irq(sdev))
837 		hda_dsp_sdw_thread(irq, hdev->sdw);
838 
839 	if (hda_sdw_check_wakeen_irq(sdev))
840 		hda_sdw_process_wakeen(sdev);
841 
842 	hda_check_for_state_change(sdev);
843 
844 	/* enable GIE interrupt */
845 	snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR,
846 				SOF_HDA_INTCTL,
847 				SOF_HDA_INT_GLOBAL_EN,
848 				SOF_HDA_INT_GLOBAL_EN);
849 
850 	return IRQ_HANDLED;
851 }
852 
hda_dsp_probe(struct snd_sof_dev * sdev)853 int hda_dsp_probe(struct snd_sof_dev *sdev)
854 {
855 	struct pci_dev *pci = to_pci_dev(sdev->dev);
856 	struct sof_intel_hda_dev *hdev;
857 	struct hdac_bus *bus;
858 	const struct sof_intel_dsp_desc *chip;
859 	int ret = 0;
860 
861 	/*
862 	 * detect DSP by checking class/subclass/prog-id information
863 	 * class=04 subclass 03 prog-if 00: no DSP, legacy driver is required
864 	 * class=04 subclass 01 prog-if 00: DSP is present
865 	 *   (and may be required e.g. for DMIC or SSP support)
866 	 * class=04 subclass 03 prog-if 80: either of DSP or legacy mode works
867 	 */
868 	if (pci->class == 0x040300) {
869 		dev_err(sdev->dev, "error: the DSP is not enabled on this platform, aborting probe\n");
870 		return -ENODEV;
871 	} else if (pci->class != 0x040100 && pci->class != 0x040380) {
872 		dev_err(sdev->dev, "error: unknown PCI class/subclass/prog-if 0x%06x found, aborting probe\n", pci->class);
873 		return -ENODEV;
874 	}
875 	dev_info(sdev->dev, "DSP detected with PCI class/subclass/prog-if 0x%06x\n", pci->class);
876 
877 	chip = get_chip_info(sdev->pdata);
878 	if (!chip) {
879 		dev_err(sdev->dev, "error: no such device supported, chip id:%x\n",
880 			pci->device);
881 		ret = -EIO;
882 		goto err;
883 	}
884 
885 	sdev->num_cores = chip->cores_num;
886 
887 	hdev = devm_kzalloc(sdev->dev, sizeof(*hdev), GFP_KERNEL);
888 	if (!hdev)
889 		return -ENOMEM;
890 	sdev->pdata->hw_pdata = hdev;
891 	hdev->desc = chip;
892 
893 	hdev->dmic_dev = platform_device_register_data(sdev->dev, "dmic-codec",
894 						       PLATFORM_DEVID_NONE,
895 						       NULL, 0);
896 	if (IS_ERR(hdev->dmic_dev)) {
897 		dev_err(sdev->dev, "error: failed to create DMIC device\n");
898 		return PTR_ERR(hdev->dmic_dev);
899 	}
900 
901 	/*
902 	 * use position update IPC if either it is forced
903 	 * or we don't have other choice
904 	 */
905 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_FORCE_IPC_POSITION)
906 	hdev->no_ipc_position = 0;
907 #else
908 	hdev->no_ipc_position = sof_ops(sdev)->pcm_pointer ? 1 : 0;
909 #endif
910 
911 	/* set up HDA base */
912 	bus = sof_to_bus(sdev);
913 	ret = hda_init(sdev);
914 	if (ret < 0)
915 		goto hdac_bus_unmap;
916 
917 	/* DSP base */
918 	sdev->bar[HDA_DSP_BAR] = pci_ioremap_bar(pci, HDA_DSP_BAR);
919 	if (!sdev->bar[HDA_DSP_BAR]) {
920 		dev_err(sdev->dev, "error: ioremap error\n");
921 		ret = -ENXIO;
922 		goto hdac_bus_unmap;
923 	}
924 
925 	sdev->mmio_bar = HDA_DSP_BAR;
926 	sdev->mailbox_bar = HDA_DSP_BAR;
927 
928 	/* allow 64bit DMA address if supported by H/W */
929 	if (dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(64))) {
930 		dev_dbg(sdev->dev, "DMA mask is 32 bit\n");
931 		dma_set_mask_and_coherent(&pci->dev, DMA_BIT_MASK(32));
932 	}
933 	dma_set_max_seg_size(&pci->dev, UINT_MAX);
934 
935 	/* init streams */
936 	ret = hda_dsp_stream_init(sdev);
937 	if (ret < 0) {
938 		dev_err(sdev->dev, "error: failed to init streams\n");
939 		/*
940 		 * not all errors are due to memory issues, but trying
941 		 * to free everything does not harm
942 		 */
943 		goto free_streams;
944 	}
945 
946 	/*
947 	 * register our IRQ
948 	 * let's try to enable msi firstly
949 	 * if it fails, use legacy interrupt mode
950 	 * TODO: support msi multiple vectors
951 	 */
952 	if (hda_use_msi && pci_alloc_irq_vectors(pci, 1, 1, PCI_IRQ_MSI) > 0) {
953 		dev_info(sdev->dev, "use msi interrupt mode\n");
954 		sdev->ipc_irq = pci_irq_vector(pci, 0);
955 		/* initialised to "false" by kzalloc() */
956 		sdev->msi_enabled = true;
957 	}
958 
959 	if (!sdev->msi_enabled) {
960 		dev_info(sdev->dev, "use legacy interrupt mode\n");
961 		/*
962 		 * in IO-APIC mode, hda->irq and ipc_irq are using the same
963 		 * irq number of pci->irq
964 		 */
965 		sdev->ipc_irq = pci->irq;
966 	}
967 
968 	dev_dbg(sdev->dev, "using IPC IRQ %d\n", sdev->ipc_irq);
969 	ret = request_threaded_irq(sdev->ipc_irq, hda_dsp_interrupt_handler,
970 				   hda_dsp_interrupt_thread,
971 				   IRQF_SHARED, "AudioDSP", sdev);
972 	if (ret < 0) {
973 		dev_err(sdev->dev, "error: failed to register IPC IRQ %d\n",
974 			sdev->ipc_irq);
975 		goto free_irq_vector;
976 	}
977 
978 	pci_set_master(pci);
979 	synchronize_irq(pci->irq);
980 
981 	/*
982 	 * clear TCSEL to clear playback on some HD Audio
983 	 * codecs. PCI TCSEL is defined in the Intel manuals.
984 	 */
985 	snd_sof_pci_update_bits(sdev, PCI_TCSEL, 0x07, 0);
986 
987 	/* init HDA capabilities */
988 	ret = hda_init_caps(sdev);
989 	if (ret < 0)
990 		goto free_ipc_irq;
991 
992 	/* enable ppcap interrupt */
993 	hda_dsp_ctrl_ppcap_enable(sdev, true);
994 	hda_dsp_ctrl_ppcap_int_enable(sdev, true);
995 
996 	/* set default mailbox offset for FW ready message */
997 	sdev->dsp_box.offset = HDA_DSP_MBOX_UPLINK_OFFSET;
998 
999 	INIT_DELAYED_WORK(&hdev->d0i3_work, hda_dsp_d0i3_work);
1000 
1001 	hdev->nhlt = intel_nhlt_init(sdev->dev);
1002 
1003 	return 0;
1004 
1005 free_ipc_irq:
1006 	free_irq(sdev->ipc_irq, sdev);
1007 free_irq_vector:
1008 	if (sdev->msi_enabled)
1009 		pci_free_irq_vectors(pci);
1010 free_streams:
1011 	hda_dsp_stream_free(sdev);
1012 /* dsp_unmap: not currently used */
1013 	iounmap(sdev->bar[HDA_DSP_BAR]);
1014 hdac_bus_unmap:
1015 	platform_device_unregister(hdev->dmic_dev);
1016 	iounmap(bus->remap_addr);
1017 	hda_codec_i915_exit(sdev);
1018 err:
1019 	return ret;
1020 }
1021 
hda_dsp_remove(struct snd_sof_dev * sdev)1022 int hda_dsp_remove(struct snd_sof_dev *sdev)
1023 {
1024 	struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;
1025 	const struct sof_intel_dsp_desc *chip = hda->desc;
1026 	struct hdac_bus *bus = sof_to_bus(sdev);
1027 	struct pci_dev *pci = to_pci_dev(sdev->dev);
1028 	struct nhlt_acpi_table *nhlt = hda->nhlt;
1029 
1030 	if (nhlt)
1031 		intel_nhlt_free(nhlt);
1032 
1033 	/* cancel any attempt for DSP D0I3 */
1034 	cancel_delayed_work_sync(&hda->d0i3_work);
1035 
1036 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
1037 	/* codec removal, invoke bus_device_remove */
1038 	snd_hdac_ext_bus_device_remove(bus);
1039 #endif
1040 
1041 	hda_sdw_exit(sdev);
1042 
1043 	if (!IS_ERR_OR_NULL(hda->dmic_dev))
1044 		platform_device_unregister(hda->dmic_dev);
1045 
1046 	/* disable DSP IRQ */
1047 	snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPCTL,
1048 				SOF_HDA_PPCTL_PIE, 0);
1049 
1050 	/* disable CIE and GIE interrupts */
1051 	snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, SOF_HDA_INTCTL,
1052 				SOF_HDA_INT_CTRL_EN | SOF_HDA_INT_GLOBAL_EN, 0);
1053 
1054 	/* disable cores */
1055 	if (chip)
1056 		hda_dsp_core_reset_power_down(sdev, chip->host_managed_cores_mask);
1057 
1058 	/* disable DSP */
1059 	snd_sof_dsp_update_bits(sdev, HDA_DSP_PP_BAR, SOF_HDA_REG_PP_PPCTL,
1060 				SOF_HDA_PPCTL_GPROCEN, 0);
1061 
1062 	free_irq(sdev->ipc_irq, sdev);
1063 	if (sdev->msi_enabled)
1064 		pci_free_irq_vectors(pci);
1065 
1066 	hda_dsp_stream_free(sdev);
1067 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
1068 	snd_hdac_link_free_all(bus);
1069 #endif
1070 
1071 	iounmap(sdev->bar[HDA_DSP_BAR]);
1072 	iounmap(bus->remap_addr);
1073 
1074 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
1075 	snd_hdac_ext_bus_exit(bus);
1076 #endif
1077 	hda_codec_i915_exit(sdev);
1078 
1079 	return 0;
1080 }
1081 
1082 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)
hda_generic_machine_select(struct snd_sof_dev * sdev,struct snd_soc_acpi_mach ** mach)1083 static void hda_generic_machine_select(struct snd_sof_dev *sdev,
1084 				       struct snd_soc_acpi_mach **mach)
1085 {
1086 	struct hdac_bus *bus = sof_to_bus(sdev);
1087 	struct snd_soc_acpi_mach_params *mach_params;
1088 	struct snd_soc_acpi_mach *hda_mach;
1089 	struct snd_sof_pdata *pdata = sdev->pdata;
1090 	const char *tplg_filename;
1091 	const char *idisp_str;
1092 	int dmic_num = 0;
1093 	int codec_num = 0;
1094 	int ret;
1095 	int i;
1096 
1097 	/* codec detection */
1098 	if (!bus->codec_mask) {
1099 		dev_info(bus->dev, "no hda codecs found!\n");
1100 	} else {
1101 		dev_info(bus->dev, "hda codecs found, mask %lx\n",
1102 			 bus->codec_mask);
1103 
1104 		for (i = 0; i < HDA_MAX_CODECS; i++) {
1105 			if (bus->codec_mask & (1 << i))
1106 				codec_num++;
1107 		}
1108 
1109 		/*
1110 		 * If no machine driver is found, then:
1111 		 *
1112 		 * generic hda machine driver can handle:
1113 		 *  - one HDMI codec, and/or
1114 		 *  - one external HDAudio codec
1115 		 */
1116 		if (!*mach && codec_num <= 2) {
1117 			hda_mach = snd_soc_acpi_intel_hda_machines;
1118 
1119 			dev_info(bus->dev, "using HDA machine driver %s now\n",
1120 				 hda_mach->drv_name);
1121 
1122 			if (codec_num == 1 && HDA_IDISP_CODEC(bus->codec_mask))
1123 				idisp_str = "-idisp";
1124 			else
1125 				idisp_str = "";
1126 
1127 			/* topology: use the info from hda_machines */
1128 			tplg_filename = hda_mach->sof_tplg_filename;
1129 			ret = dmic_topology_fixup(sdev, &tplg_filename, idisp_str, &dmic_num);
1130 			if (ret < 0)
1131 				return;
1132 
1133 			hda_mach->mach_params.dmic_num = dmic_num;
1134 			pdata->tplg_filename = tplg_filename;
1135 
1136 			if (codec_num == 2) {
1137 				/*
1138 				 * Prevent SoundWire links from starting when an external
1139 				 * HDaudio codec is used
1140 				 */
1141 				hda_mach->mach_params.link_mask = 0;
1142 			}
1143 
1144 			*mach = hda_mach;
1145 		}
1146 	}
1147 
1148 	/* used by hda machine driver to create dai links */
1149 	if (*mach) {
1150 		mach_params = &(*mach)->mach_params;
1151 		mach_params->codec_mask = bus->codec_mask;
1152 		mach_params->common_hdmi_codec_drv = hda_codec_use_common_hdmi;
1153 	}
1154 }
1155 #else
hda_generic_machine_select(struct snd_sof_dev * sdev,struct snd_soc_acpi_mach ** mach)1156 static void hda_generic_machine_select(struct snd_sof_dev *sdev,
1157 				       struct snd_soc_acpi_mach **mach)
1158 {
1159 }
1160 #endif
1161 
1162 #if IS_ENABLED(CONFIG_SND_SOC_SOF_INTEL_SOUNDWIRE)
1163 
1164 #define SDW_CODEC_ADR_MASK(_adr) ((_adr) & (SDW_DISCO_LINK_ID_MASK | SDW_VERSION_MASK | \
1165 				  SDW_MFG_ID_MASK | SDW_PART_ID_MASK))
1166 
1167 /* Check if all Slaves defined on the link can be found */
link_slaves_found(struct snd_sof_dev * sdev,const struct snd_soc_acpi_link_adr * link,struct sdw_intel_ctx * sdw)1168 static bool link_slaves_found(struct snd_sof_dev *sdev,
1169 			      const struct snd_soc_acpi_link_adr *link,
1170 			      struct sdw_intel_ctx *sdw)
1171 {
1172 	struct hdac_bus *bus = sof_to_bus(sdev);
1173 	struct sdw_intel_slave_id *ids = sdw->ids;
1174 	int num_slaves = sdw->num_slaves;
1175 	unsigned int part_id, link_id, unique_id, mfg_id, version;
1176 	int i, j, k;
1177 
1178 	for (i = 0; i < link->num_adr; i++) {
1179 		u64 adr = link->adr_d[i].adr;
1180 		int reported_part_count = 0;
1181 
1182 		mfg_id = SDW_MFG_ID(adr);
1183 		part_id = SDW_PART_ID(adr);
1184 		link_id = SDW_DISCO_LINK_ID(adr);
1185 		version = SDW_VERSION(adr);
1186 
1187 		for (j = 0; j < num_slaves; j++) {
1188 			/* find out how many identical parts were reported on that link */
1189 			if (ids[j].link_id == link_id &&
1190 			    ids[j].id.part_id == part_id &&
1191 			    ids[j].id.mfg_id == mfg_id &&
1192 			    ids[j].id.sdw_version == version)
1193 				reported_part_count++;
1194 		}
1195 
1196 		for (j = 0; j < num_slaves; j++) {
1197 			int expected_part_count = 0;
1198 
1199 			if (ids[j].link_id != link_id ||
1200 			    ids[j].id.part_id != part_id ||
1201 			    ids[j].id.mfg_id != mfg_id ||
1202 			    ids[j].id.sdw_version != version)
1203 				continue;
1204 
1205 			/* find out how many identical parts are expected */
1206 			for (k = 0; k < link->num_adr; k++) {
1207 				u64 adr2 = link->adr_d[k].adr;
1208 
1209 				if (SDW_CODEC_ADR_MASK(adr2) == SDW_CODEC_ADR_MASK(adr))
1210 					expected_part_count++;
1211 			}
1212 
1213 			if (reported_part_count == expected_part_count) {
1214 				/*
1215 				 * we have to check unique id
1216 				 * if there is more than one
1217 				 * Slave on the link
1218 				 */
1219 				unique_id = SDW_UNIQUE_ID(adr);
1220 				if (reported_part_count == 1 ||
1221 				    ids[j].id.unique_id == unique_id) {
1222 					dev_dbg(bus->dev, "found %x at link %d\n",
1223 						part_id, link_id);
1224 					break;
1225 				}
1226 			} else {
1227 				dev_dbg(bus->dev, "part %x reported %d expected %d on link %d, skipping\n",
1228 					part_id, reported_part_count, expected_part_count, link_id);
1229 			}
1230 		}
1231 		if (j == num_slaves) {
1232 			dev_dbg(bus->dev,
1233 				"Slave %x not found\n",
1234 				part_id);
1235 			return false;
1236 		}
1237 	}
1238 	return true;
1239 }
1240 
hda_sdw_machine_select(struct snd_sof_dev * sdev)1241 static struct snd_soc_acpi_mach *hda_sdw_machine_select(struct snd_sof_dev *sdev)
1242 {
1243 	struct snd_sof_pdata *pdata = sdev->pdata;
1244 	const struct snd_soc_acpi_link_adr *link;
1245 	struct snd_soc_acpi_mach *mach;
1246 	struct sof_intel_hda_dev *hdev;
1247 	u32 link_mask;
1248 	int i;
1249 
1250 	hdev = pdata->hw_pdata;
1251 	link_mask = hdev->info.link_mask;
1252 
1253 	/*
1254 	 * Select SoundWire machine driver if needed using the
1255 	 * alternate tables. This case deals with SoundWire-only
1256 	 * machines, for mixed cases with I2C/I2S the detection relies
1257 	 * on the HID list.
1258 	 */
1259 	if (link_mask) {
1260 		for (mach = pdata->desc->alt_machines;
1261 		     mach && mach->link_mask; mach++) {
1262 			/*
1263 			 * On some platforms such as Up Extreme all links
1264 			 * are enabled but only one link can be used by
1265 			 * external codec. Instead of exact match of two masks,
1266 			 * first check whether link_mask of mach is subset of
1267 			 * link_mask supported by hw and then go on searching
1268 			 * link_adr
1269 			 */
1270 			if (~link_mask & mach->link_mask)
1271 				continue;
1272 
1273 			/* No need to match adr if there is no links defined */
1274 			if (!mach->links)
1275 				break;
1276 
1277 			link = mach->links;
1278 			for (i = 0; i < hdev->info.count && link->num_adr;
1279 			     i++, link++) {
1280 				/*
1281 				 * Try next machine if any expected Slaves
1282 				 * are not found on this link.
1283 				 */
1284 				if (!link_slaves_found(sdev, link, hdev->sdw))
1285 					break;
1286 			}
1287 			/* Found if all Slaves are checked */
1288 			if (i == hdev->info.count || !link->num_adr)
1289 				break;
1290 		}
1291 		if (mach && mach->link_mask) {
1292 			int dmic_num = 0;
1293 
1294 			mach->mach_params.links = mach->links;
1295 			mach->mach_params.link_mask = mach->link_mask;
1296 			mach->mach_params.platform = dev_name(sdev->dev);
1297 			pdata->fw_filename = pdata->desc->default_fw_filename[pdata->ipc_type];
1298 			pdata->tplg_filename = mach->sof_tplg_filename;
1299 
1300 			/*
1301 			 * DMICs use up to 4 pins and are typically pin-muxed with SoundWire
1302 			 * link 2 and 3, thus we only try to enable dmics if all conditions
1303 			 * are true:
1304 			 * a) link 2 and 3 are not used by SoundWire
1305 			 * b) the NHLT table reports the presence of microphones
1306 			 */
1307 			if (!(mach->link_mask & GENMASK(3, 2))) {
1308 				const char *tplg_filename = mach->sof_tplg_filename;
1309 				int ret;
1310 
1311 				ret = dmic_topology_fixup(sdev, &tplg_filename, "", &dmic_num);
1312 				if (ret < 0)
1313 					return NULL;
1314 
1315 				pdata->tplg_filename = tplg_filename;
1316 			}
1317 			mach->mach_params.dmic_num = dmic_num;
1318 
1319 			dev_dbg(sdev->dev,
1320 				"SoundWire machine driver %s topology %s\n",
1321 				mach->drv_name,
1322 				pdata->tplg_filename);
1323 
1324 			return mach;
1325 		}
1326 
1327 		dev_info(sdev->dev, "No SoundWire machine driver found\n");
1328 	}
1329 
1330 	return NULL;
1331 }
1332 #else
hda_sdw_machine_select(struct snd_sof_dev * sdev)1333 static struct snd_soc_acpi_mach *hda_sdw_machine_select(struct snd_sof_dev *sdev)
1334 {
1335 	return NULL;
1336 }
1337 #endif
1338 
hda_set_mach_params(struct snd_soc_acpi_mach * mach,struct snd_sof_dev * sdev)1339 void hda_set_mach_params(struct snd_soc_acpi_mach *mach,
1340 			 struct snd_sof_dev *sdev)
1341 {
1342 	struct snd_sof_pdata *pdata = sdev->pdata;
1343 	const struct sof_dev_desc *desc = pdata->desc;
1344 	struct snd_soc_acpi_mach_params *mach_params;
1345 
1346 	mach_params = &mach->mach_params;
1347 	mach_params->platform = dev_name(sdev->dev);
1348 	mach_params->num_dai_drivers = desc->ops->num_drv;
1349 	mach_params->dai_drivers = desc->ops->drv;
1350 }
1351 
hda_machine_select(struct snd_sof_dev * sdev)1352 struct snd_soc_acpi_mach *hda_machine_select(struct snd_sof_dev *sdev)
1353 {
1354 	struct snd_sof_pdata *sof_pdata = sdev->pdata;
1355 	const struct sof_dev_desc *desc = sof_pdata->desc;
1356 	struct snd_soc_acpi_mach *mach;
1357 	const char *tplg_filename;
1358 
1359 	mach = snd_soc_acpi_find_machine(desc->machines);
1360 	if (mach) {
1361 		bool add_extension = false;
1362 
1363 		/*
1364 		 * If tplg file name is overridden, use it instead of
1365 		 * the one set in mach table
1366 		 */
1367 		if (!sof_pdata->tplg_filename)
1368 			sof_pdata->tplg_filename = mach->sof_tplg_filename;
1369 
1370 		/* report to machine driver if any DMICs are found */
1371 		mach->mach_params.dmic_num = check_dmic_num(sdev);
1372 
1373 		if (mach->tplg_quirk_mask & SND_SOC_ACPI_TPLG_INTEL_DMIC_NUMBER &&
1374 		    mach->mach_params.dmic_num) {
1375 			tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,
1376 						       "%s%s%d%s",
1377 						       sof_pdata->tplg_filename,
1378 						       "-dmic",
1379 						       mach->mach_params.dmic_num,
1380 						       "ch");
1381 			if (!tplg_filename)
1382 				return NULL;
1383 
1384 			sof_pdata->tplg_filename = tplg_filename;
1385 			add_extension = true;
1386 		}
1387 
1388 		if (mach->link_mask) {
1389 			mach->mach_params.links = mach->links;
1390 			mach->mach_params.link_mask = mach->link_mask;
1391 		}
1392 
1393 		/* report SSP link mask to machine driver */
1394 		mach->mach_params.i2s_link_mask = check_nhlt_ssp_mask(sdev);
1395 
1396 		if (mach->tplg_quirk_mask & SND_SOC_ACPI_TPLG_INTEL_SSP_NUMBER &&
1397 		    mach->mach_params.i2s_link_mask) {
1398 			const struct sof_intel_dsp_desc *chip = get_chip_info(sdev->pdata);
1399 			int ssp_num;
1400 
1401 			if (hweight_long(mach->mach_params.i2s_link_mask) > 1 &&
1402 			    !(mach->tplg_quirk_mask & SND_SOC_ACPI_TPLG_INTEL_SSP_MSB))
1403 				dev_warn(sdev->dev, "More than one SSP exposed by NHLT, choosing MSB\n");
1404 
1405 			/* fls returns 1-based results, SSPs indices are 0-based */
1406 			ssp_num = fls(mach->mach_params.i2s_link_mask) - 1;
1407 
1408 			if (ssp_num >= chip->ssp_count) {
1409 				dev_err(sdev->dev, "Invalid SSP %d, max on this platform is %d\n",
1410 					ssp_num, chip->ssp_count);
1411 				return NULL;
1412 			}
1413 
1414 			tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,
1415 						       "%s%s%d",
1416 						       sof_pdata->tplg_filename,
1417 						       "-ssp",
1418 						       ssp_num);
1419 			if (!tplg_filename)
1420 				return NULL;
1421 
1422 			sof_pdata->tplg_filename = tplg_filename;
1423 			add_extension = true;
1424 		}
1425 
1426 		if (add_extension) {
1427 			tplg_filename = devm_kasprintf(sdev->dev, GFP_KERNEL,
1428 						       "%s%s",
1429 						       sof_pdata->tplg_filename,
1430 						       ".tplg");
1431 			if (!tplg_filename)
1432 				return NULL;
1433 
1434 			sof_pdata->tplg_filename = tplg_filename;
1435 		}
1436 	}
1437 
1438 	/*
1439 	 * If I2S fails, try SoundWire
1440 	 */
1441 	if (!mach)
1442 		mach = hda_sdw_machine_select(sdev);
1443 
1444 	/*
1445 	 * Choose HDA generic machine driver if mach is NULL.
1446 	 * Otherwise, set certain mach params.
1447 	 */
1448 	hda_generic_machine_select(sdev, &mach);
1449 	if (!mach)
1450 		dev_warn(sdev->dev, "warning: No matching ASoC machine driver found\n");
1451 
1452 	return mach;
1453 }
1454 
hda_pci_intel_probe(struct pci_dev * pci,const struct pci_device_id * pci_id)1455 int hda_pci_intel_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
1456 {
1457 	int ret;
1458 
1459 	ret = snd_intel_dsp_driver_probe(pci);
1460 	if (ret != SND_INTEL_DSP_DRIVER_ANY && ret != SND_INTEL_DSP_DRIVER_SOF) {
1461 		dev_dbg(&pci->dev, "SOF PCI driver not selected, aborting probe\n");
1462 		return -ENODEV;
1463 	}
1464 
1465 	return sof_pci_probe(pci, pci_id);
1466 }
1467 EXPORT_SYMBOL_NS(hda_pci_intel_probe, SND_SOC_SOF_INTEL_HDA_COMMON);
1468 
hda_register_clients(struct snd_sof_dev * sdev)1469 int hda_register_clients(struct snd_sof_dev *sdev)
1470 {
1471 	return hda_probes_register(sdev);
1472 }
1473 
hda_unregister_clients(struct snd_sof_dev * sdev)1474 void hda_unregister_clients(struct snd_sof_dev *sdev)
1475 {
1476 	hda_probes_unregister(sdev);
1477 }
1478 
1479 MODULE_LICENSE("Dual BSD/GPL");
1480 MODULE_IMPORT_NS(SND_SOC_SOF_PCI_DEV);
1481 MODULE_IMPORT_NS(SND_SOC_SOF_HDA_AUDIO_CODEC);
1482 MODULE_IMPORT_NS(SND_SOC_SOF_HDA_AUDIO_CODEC_I915);
1483 MODULE_IMPORT_NS(SND_SOC_SOF_XTENSA);
1484 MODULE_IMPORT_NS(SND_INTEL_SOUNDWIRE_ACPI);
1485 MODULE_IMPORT_NS(SOUNDWIRE_INTEL_INIT);
1486