1 // SPDX-License-Identifier: GPL-2.0+
2 //
3 // AMD Renoir ACP PCI Driver
4 //
5 //Copyright 2020 Advanced Micro Devices, Inc.
6 
7 #include <linux/pci.h>
8 #include <linux/acpi.h>
9 #include <linux/dmi.h>
10 #include <linux/module.h>
11 #include <linux/io.h>
12 #include <linux/delay.h>
13 #include <linux/platform_device.h>
14 #include <linux/interrupt.h>
15 #include <linux/pm_runtime.h>
16 
17 #include "rn_acp3x.h"
18 
19 static int acp_power_gating;
20 module_param(acp_power_gating, int, 0644);
21 MODULE_PARM_DESC(acp_power_gating, "Enable acp power gating");
22 
23 /*
24  * dmic_acpi_check = -1 - Use ACPI/DMI method to detect the DMIC hardware presence at runtime
25  *                 =  0 - Skip the DMIC device creation and return probe failure
26  *                 =  1 - Force DMIC support
27  */
28 static int dmic_acpi_check = ACP_DMIC_AUTO;
29 module_param(dmic_acpi_check, bint, 0644);
30 MODULE_PARM_DESC(dmic_acpi_check, "Digital microphone presence (-1=auto, 0=none, 1=force)");
31 
32 struct acp_dev_data {
33 	void __iomem *acp_base;
34 	struct resource *res;
35 	struct platform_device *pdev[ACP_DEVS];
36 };
37 
38 static int rn_acp_power_on(void __iomem *acp_base)
39 {
40 	u32 val;
41 	int timeout;
42 
43 	val = rn_readl(acp_base + ACP_PGFSM_STATUS);
44 
45 	if (val == 0)
46 		return val;
47 
48 	if ((val & ACP_PGFSM_STATUS_MASK) !=
49 				ACP_POWER_ON_IN_PROGRESS)
50 		rn_writel(ACP_PGFSM_CNTL_POWER_ON_MASK,
51 			  acp_base + ACP_PGFSM_CONTROL);
52 	timeout = 0;
53 	while (++timeout < 500) {
54 		val = rn_readl(acp_base + ACP_PGFSM_STATUS);
55 		if (!val)
56 			return 0;
57 		udelay(1);
58 	}
59 	return -ETIMEDOUT;
60 }
61 
62 static int rn_acp_power_off(void __iomem *acp_base)
63 {
64 	u32 val;
65 	int timeout;
66 
67 	rn_writel(ACP_PGFSM_CNTL_POWER_OFF_MASK,
68 		  acp_base + ACP_PGFSM_CONTROL);
69 	timeout = 0;
70 	while (++timeout < 500) {
71 		val = rn_readl(acp_base + ACP_PGFSM_STATUS);
72 		if ((val & ACP_PGFSM_STATUS_MASK) == ACP_POWERED_OFF)
73 			return 0;
74 		udelay(1);
75 	}
76 	return -ETIMEDOUT;
77 }
78 
79 static int rn_acp_reset(void __iomem *acp_base)
80 {
81 	u32 val;
82 	int timeout;
83 
84 	rn_writel(1, acp_base + ACP_SOFT_RESET);
85 	timeout = 0;
86 	while (++timeout < 500) {
87 		val = rn_readl(acp_base + ACP_SOFT_RESET);
88 		if (val & ACP_SOFT_RESET_SOFTRESET_AUDDONE_MASK)
89 			break;
90 		cpu_relax();
91 	}
92 	rn_writel(0, acp_base + ACP_SOFT_RESET);
93 	timeout = 0;
94 	while (++timeout < 500) {
95 		val = rn_readl(acp_base + ACP_SOFT_RESET);
96 		if (!val)
97 			return 0;
98 		cpu_relax();
99 	}
100 	return -ETIMEDOUT;
101 }
102 
103 static void rn_acp_enable_interrupts(void __iomem *acp_base)
104 {
105 	u32 ext_intr_ctrl;
106 
107 	rn_writel(0x01, acp_base + ACP_EXTERNAL_INTR_ENB);
108 	ext_intr_ctrl = rn_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);
109 	ext_intr_ctrl |= ACP_ERROR_MASK;
110 	rn_writel(ext_intr_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);
111 }
112 
113 static void rn_acp_disable_interrupts(void __iomem *acp_base)
114 {
115 	rn_writel(ACP_EXT_INTR_STAT_CLEAR_MASK, acp_base +
116 		  ACP_EXTERNAL_INTR_STAT);
117 	rn_writel(0x00, acp_base + ACP_EXTERNAL_INTR_ENB);
118 }
119 
120 static int rn_acp_init(void __iomem *acp_base)
121 {
122 	int ret;
123 
124 	/* power on */
125 	ret = rn_acp_power_on(acp_base);
126 	if (ret) {
127 		pr_err("ACP power on failed\n");
128 		return ret;
129 	}
130 	rn_writel(0x01, acp_base + ACP_CONTROL);
131 	/* Reset */
132 	ret = rn_acp_reset(acp_base);
133 	if (ret) {
134 		pr_err("ACP reset failed\n");
135 		return ret;
136 	}
137 	rn_writel(0x03, acp_base + ACP_CLKMUX_SEL);
138 	rn_acp_enable_interrupts(acp_base);
139 	return 0;
140 }
141 
142 static int rn_acp_deinit(void __iomem *acp_base)
143 {
144 	int ret;
145 
146 	rn_acp_disable_interrupts(acp_base);
147 	/* Reset */
148 	ret = rn_acp_reset(acp_base);
149 	if (ret) {
150 		pr_err("ACP reset failed\n");
151 		return ret;
152 	}
153 	rn_writel(0x00, acp_base + ACP_CLKMUX_SEL);
154 	rn_writel(0x00, acp_base + ACP_CONTROL);
155 	/* power off */
156 	if (acp_power_gating) {
157 		ret = rn_acp_power_off(acp_base);
158 		if (ret) {
159 			pr_err("ACP power off failed\n");
160 			return ret;
161 		}
162 	}
163 	return 0;
164 }
165 
166 static const struct dmi_system_id rn_acp_quirk_table[] = {
167 	{
168 		/* Lenovo IdeaPad S340-14API */
169 		.matches = {
170 			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
171 			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81NB"),
172 		}
173 	},
174 	{
175 		/* Lenovo IdeaPad Flex 5 14ARE05 */
176 		.matches = {
177 			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
178 			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81X2"),
179 		}
180 	},
181 	{
182 		/* Lenovo IdeaPad 5 15ARE05 */
183 		.matches = {
184 			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
185 			DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81YQ"),
186 		}
187 	},
188 	{
189 		/* Lenovo ThinkPad E14 Gen 2 */
190 		.matches = {
191 			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
192 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "20T6CTO1WW"),
193 		}
194 	},
195 	{
196 		/* Lenovo ThinkPad X395 */
197 		.matches = {
198 			DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
199 			DMI_EXACT_MATCH(DMI_BOARD_NAME, "20NLCTO1WW"),
200 		}
201 	},
202 	{}
203 };
204 
205 static int snd_rn_acp_probe(struct pci_dev *pci,
206 			    const struct pci_device_id *pci_id)
207 {
208 	struct acp_dev_data *adata;
209 	struct platform_device_info pdevinfo[ACP_DEVS];
210 #if defined(CONFIG_ACPI)
211 	acpi_handle handle;
212 	acpi_integer dmic_status;
213 #endif
214 	const struct dmi_system_id *dmi_id;
215 	unsigned int irqflags, flag;
216 	int ret, index;
217 	u32 addr;
218 
219 	/* Return if acp config flag is defined */
220 	flag = snd_amd_acp_find_config(pci);
221 	if (flag)
222 		return -ENODEV;
223 
224 	/* Renoir device check */
225 	if (pci->revision != 0x01)
226 		return -ENODEV;
227 
228 	if (pci_enable_device(pci)) {
229 		dev_err(&pci->dev, "pci_enable_device failed\n");
230 		return -ENODEV;
231 	}
232 
233 	ret = pci_request_regions(pci, "AMD ACP3x audio");
234 	if (ret < 0) {
235 		dev_err(&pci->dev, "pci_request_regions failed\n");
236 		goto disable_pci;
237 	}
238 
239 	adata = devm_kzalloc(&pci->dev, sizeof(struct acp_dev_data),
240 			     GFP_KERNEL);
241 	if (!adata) {
242 		ret = -ENOMEM;
243 		goto release_regions;
244 	}
245 
246 	/* check for msi interrupt support */
247 	ret = pci_enable_msi(pci);
248 	if (ret)
249 		/* msi is not enabled */
250 		irqflags = IRQF_SHARED;
251 	else
252 		/* msi is enabled */
253 		irqflags = 0;
254 
255 	addr = pci_resource_start(pci, 0);
256 	adata->acp_base = devm_ioremap(&pci->dev, addr,
257 				       pci_resource_len(pci, 0));
258 	if (!adata->acp_base) {
259 		ret = -ENOMEM;
260 		goto disable_msi;
261 	}
262 	pci_set_master(pci);
263 	pci_set_drvdata(pci, adata);
264 	ret = rn_acp_init(adata->acp_base);
265 	if (ret)
266 		goto disable_msi;
267 
268 	if (!dmic_acpi_check) {
269 		ret = -ENODEV;
270 		goto de_init;
271 	} else if (dmic_acpi_check == ACP_DMIC_AUTO) {
272 #if defined(CONFIG_ACPI)
273 		handle = ACPI_HANDLE(&pci->dev);
274 		ret = acpi_evaluate_integer(handle, "_WOV", NULL, &dmic_status);
275 		if (ACPI_FAILURE(ret)) {
276 			ret = -ENODEV;
277 			goto de_init;
278 		}
279 		if (!dmic_status) {
280 			ret = -ENODEV;
281 			goto de_init;
282 		}
283 #endif
284 		dmi_id = dmi_first_match(rn_acp_quirk_table);
285 		if (dmi_id && !dmi_id->driver_data) {
286 			dev_info(&pci->dev, "ACPI settings override using DMI (ACP mic is not present)");
287 			ret = -ENODEV;
288 			goto de_init;
289 		}
290 	}
291 
292 	adata->res = devm_kzalloc(&pci->dev,
293 				  sizeof(struct resource) * 2,
294 				  GFP_KERNEL);
295 	if (!adata->res) {
296 		ret = -ENOMEM;
297 		goto de_init;
298 	}
299 
300 	adata->res[0].name = "acp_pdm_iomem";
301 	adata->res[0].flags = IORESOURCE_MEM;
302 	adata->res[0].start = addr;
303 	adata->res[0].end = addr + (ACP_REG_END - ACP_REG_START);
304 	adata->res[1].name = "acp_pdm_irq";
305 	adata->res[1].flags = IORESOURCE_IRQ;
306 	adata->res[1].start = pci->irq;
307 	adata->res[1].end = pci->irq;
308 
309 	memset(&pdevinfo, 0, sizeof(pdevinfo));
310 	pdevinfo[0].name = "acp_rn_pdm_dma";
311 	pdevinfo[0].id = 0;
312 	pdevinfo[0].parent = &pci->dev;
313 	pdevinfo[0].num_res = 2;
314 	pdevinfo[0].res = adata->res;
315 	pdevinfo[0].data = &irqflags;
316 	pdevinfo[0].size_data = sizeof(irqflags);
317 
318 	pdevinfo[1].name = "dmic-codec";
319 	pdevinfo[1].id = 0;
320 	pdevinfo[1].parent = &pci->dev;
321 	pdevinfo[2].name = "acp_pdm_mach";
322 	pdevinfo[2].id = 0;
323 	pdevinfo[2].parent = &pci->dev;
324 	for (index = 0; index < ACP_DEVS; index++) {
325 		adata->pdev[index] =
326 				platform_device_register_full(&pdevinfo[index]);
327 		if (IS_ERR(adata->pdev[index])) {
328 			dev_err(&pci->dev, "cannot register %s device\n",
329 				pdevinfo[index].name);
330 			ret = PTR_ERR(adata->pdev[index]);
331 			goto unregister_devs;
332 		}
333 	}
334 	pm_runtime_set_autosuspend_delay(&pci->dev, ACP_SUSPEND_DELAY_MS);
335 	pm_runtime_use_autosuspend(&pci->dev);
336 	pm_runtime_put_noidle(&pci->dev);
337 	pm_runtime_allow(&pci->dev);
338 	return 0;
339 
340 unregister_devs:
341 	for (index = 0; index < ACP_DEVS; index++)
342 		platform_device_unregister(adata->pdev[index]);
343 de_init:
344 	if (rn_acp_deinit(adata->acp_base))
345 		dev_err(&pci->dev, "ACP de-init failed\n");
346 disable_msi:
347 	pci_disable_msi(pci);
348 release_regions:
349 	pci_release_regions(pci);
350 disable_pci:
351 	pci_disable_device(pci);
352 
353 	return ret;
354 }
355 
356 static int snd_rn_acp_suspend(struct device *dev)
357 {
358 	int ret;
359 	struct acp_dev_data *adata;
360 
361 	adata = dev_get_drvdata(dev);
362 	ret = rn_acp_deinit(adata->acp_base);
363 	if (ret)
364 		dev_err(dev, "ACP de-init failed\n");
365 	else
366 		dev_dbg(dev, "ACP de-initialized\n");
367 
368 	return ret;
369 }
370 
371 static int snd_rn_acp_resume(struct device *dev)
372 {
373 	int ret;
374 	struct acp_dev_data *adata;
375 
376 	adata = dev_get_drvdata(dev);
377 	ret = rn_acp_init(adata->acp_base);
378 	if (ret) {
379 		dev_err(dev, "ACP init failed\n");
380 		return ret;
381 	}
382 	return 0;
383 }
384 
385 static const struct dev_pm_ops rn_acp_pm = {
386 	.runtime_suspend = snd_rn_acp_suspend,
387 	.runtime_resume =  snd_rn_acp_resume,
388 	.suspend = snd_rn_acp_suspend,
389 	.resume =	snd_rn_acp_resume,
390 	.restore =	snd_rn_acp_resume,
391 	.poweroff =	snd_rn_acp_suspend,
392 };
393 
394 static void snd_rn_acp_remove(struct pci_dev *pci)
395 {
396 	struct acp_dev_data *adata;
397 	int ret, index;
398 
399 	adata = pci_get_drvdata(pci);
400 	for (index = 0; index < ACP_DEVS; index++)
401 		platform_device_unregister(adata->pdev[index]);
402 	ret = rn_acp_deinit(adata->acp_base);
403 	if (ret)
404 		dev_err(&pci->dev, "ACP de-init failed\n");
405 	pm_runtime_forbid(&pci->dev);
406 	pm_runtime_get_noresume(&pci->dev);
407 	pci_disable_msi(pci);
408 	pci_release_regions(pci);
409 	pci_disable_device(pci);
410 }
411 
412 static const struct pci_device_id snd_rn_acp_ids[] = {
413 	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_DEVICE_ID),
414 	.class = PCI_CLASS_MULTIMEDIA_OTHER << 8,
415 	.class_mask = 0xffffff },
416 	{ 0, },
417 };
418 MODULE_DEVICE_TABLE(pci, snd_rn_acp_ids);
419 
420 static struct pci_driver rn_acp_driver  = {
421 	.name = KBUILD_MODNAME,
422 	.id_table = snd_rn_acp_ids,
423 	.probe = snd_rn_acp_probe,
424 	.remove = snd_rn_acp_remove,
425 	.driver = {
426 		.pm = &rn_acp_pm,
427 	}
428 };
429 
430 module_pci_driver(rn_acp_driver);
431 
432 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
433 MODULE_DESCRIPTION("AMD ACP Renoir PCI driver");
434 MODULE_LICENSE("GPL v2");
435