1 // SPDX-License-Identifier: GPL-2.0+
3 // AMD Renoir ACP PCI Driver
5 //Copyright 2020 Advanced Micro Devices, Inc.
8 #include <linux/acpi.h>
10 #include <linux/module.h>
12 #include <linux/delay.h>
13 #include <linux/platform_device.h>
14 #include <linux/interrupt.h>
15 #include <linux/pm_runtime.h>
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");
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
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)");
33 void __iomem *acp_base;
35 struct platform_device *pdev[ACP_DEVS];
38 static int rn_acp_power_on(void __iomem *acp_base)
43 val = rn_readl(acp_base + ACP_PGFSM_STATUS);
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);
53 while (++timeout < 500) {
54 val = rn_readl(acp_base + ACP_PGFSM_STATUS);
62 static int rn_acp_power_off(void __iomem *acp_base)
67 rn_writel(ACP_PGFSM_CNTL_POWER_OFF_MASK,
68 acp_base + ACP_PGFSM_CONTROL);
70 while (++timeout < 500) {
71 val = rn_readl(acp_base + ACP_PGFSM_STATUS);
72 if ((val & ACP_PGFSM_STATUS_MASK) == ACP_POWERED_OFF)
79 static int rn_acp_reset(void __iomem *acp_base)
84 rn_writel(1, acp_base + ACP_SOFT_RESET);
86 while (++timeout < 500) {
87 val = rn_readl(acp_base + ACP_SOFT_RESET);
88 if (val & ACP_SOFT_RESET_SOFTRESET_AUDDONE_MASK)
92 rn_writel(0, acp_base + ACP_SOFT_RESET);
94 while (++timeout < 500) {
95 val = rn_readl(acp_base + ACP_SOFT_RESET);
103 static void rn_acp_enable_interrupts(void __iomem *acp_base)
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);
113 static void rn_acp_disable_interrupts(void __iomem *acp_base)
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);
120 static int rn_acp_init(void __iomem *acp_base)
125 ret = rn_acp_power_on(acp_base);
127 pr_err("ACP power on failed\n");
130 rn_writel(0x01, acp_base + ACP_CONTROL);
132 ret = rn_acp_reset(acp_base);
134 pr_err("ACP reset failed\n");
137 rn_writel(0x03, acp_base + ACP_CLKMUX_SEL);
138 rn_acp_enable_interrupts(acp_base);
142 static int rn_acp_deinit(void __iomem *acp_base)
146 rn_acp_disable_interrupts(acp_base);
148 ret = rn_acp_reset(acp_base);
150 pr_err("ACP reset failed\n");
153 rn_writel(0x00, acp_base + ACP_CLKMUX_SEL);
154 rn_writel(0x00, acp_base + ACP_CONTROL);
156 if (acp_power_gating) {
157 ret = rn_acp_power_off(acp_base);
159 pr_err("ACP power off failed\n");
166 static const struct dmi_system_id rn_acp_quirk_table[] = {
168 /* Lenovo IdeaPad S340-14API */
170 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
171 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81NB"),
175 /* Lenovo IdeaPad Flex 5 14ARE05 */
177 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
178 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81X2"),
182 /* Lenovo IdeaPad 5 15ARE05 */
184 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
185 DMI_EXACT_MATCH(DMI_PRODUCT_NAME, "81YQ"),
189 /* Lenovo ThinkPad E14 Gen 2 */
191 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
192 DMI_EXACT_MATCH(DMI_BOARD_NAME, "20T6CTO1WW"),
196 /* Lenovo ThinkPad X395 */
198 DMI_EXACT_MATCH(DMI_BOARD_VENDOR, "LENOVO"),
199 DMI_EXACT_MATCH(DMI_BOARD_NAME, "20NLCTO1WW"),
205 static int snd_rn_acp_probe(struct pci_dev *pci,
206 const struct pci_device_id *pci_id)
208 struct acp_dev_data *adata;
209 struct platform_device_info pdevinfo[ACP_DEVS];
210 #if defined(CONFIG_ACPI)
212 acpi_integer dmic_status;
214 const struct dmi_system_id *dmi_id;
215 unsigned int irqflags, flag;
219 /* Return if acp config flag is defined */
220 flag = snd_amd_acp_find_config(pci);
224 /* Renoir device check */
225 if (pci->revision != 0x01)
228 if (pci_enable_device(pci)) {
229 dev_err(&pci->dev, "pci_enable_device failed\n");
233 ret = pci_request_regions(pci, "AMD ACP3x audio");
235 dev_err(&pci->dev, "pci_request_regions failed\n");
239 adata = devm_kzalloc(&pci->dev, sizeof(struct acp_dev_data),
243 goto release_regions;
246 /* check for msi interrupt support */
247 ret = pci_enable_msi(pci);
249 /* msi is not enabled */
250 irqflags = IRQF_SHARED;
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) {
263 pci_set_drvdata(pci, adata);
264 ret = rn_acp_init(adata->acp_base);
268 if (!dmic_acpi_check) {
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)) {
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)");
292 adata->res = devm_kzalloc(&pci->dev,
293 sizeof(struct resource) * 2,
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;
309 memset(&pdevinfo, 0, sizeof(pdevinfo));
310 pdevinfo[0].name = "acp_rn_pdm_dma";
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);
318 pdevinfo[1].name = "dmic-codec";
320 pdevinfo[1].parent = &pci->dev;
321 pdevinfo[2].name = "acp_pdm_mach";
323 pdevinfo[2].parent = &pci->dev;
324 for (index = 0; index < ACP_DEVS; 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;
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);
341 for (index = 0; index < ACP_DEVS; index++)
342 platform_device_unregister(adata->pdev[index]);
344 if (rn_acp_deinit(adata->acp_base))
345 dev_err(&pci->dev, "ACP de-init failed\n");
347 pci_disable_msi(pci);
349 pci_release_regions(pci);
351 pci_disable_device(pci);
356 static int snd_rn_acp_suspend(struct device *dev)
359 struct acp_dev_data *adata;
361 adata = dev_get_drvdata(dev);
362 ret = rn_acp_deinit(adata->acp_base);
364 dev_err(dev, "ACP de-init failed\n");
366 dev_dbg(dev, "ACP de-initialized\n");
371 static int snd_rn_acp_resume(struct device *dev)
374 struct acp_dev_data *adata;
376 adata = dev_get_drvdata(dev);
377 ret = rn_acp_init(adata->acp_base);
379 dev_err(dev, "ACP init failed\n");
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,
394 static void snd_rn_acp_remove(struct pci_dev *pci)
396 struct acp_dev_data *adata;
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);
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);
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 },
418 MODULE_DEVICE_TABLE(pci, snd_rn_acp_ids);
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,
430 module_pci_driver(rn_acp_driver);
432 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
433 MODULE_DESCRIPTION("AMD ACP Renoir PCI driver");
434 MODULE_LICENSE("GPL v2");