xref: /openbmc/linux/sound/soc/amd/acp/acp-pci.c (revision e158ed26)
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) 2022 Advanced Micro Devices, Inc. All rights reserved.
7 //
8 // Authors: Ajit Kumar Pandey <AjitKumar.Pandey@amd.com>
9 
10 /*
11  * Generic PCI interface for ACP device
12  */
13 
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/pci.h>
17 #include <linux/platform_device.h>
18 #include <linux/module.h>
19 #include <linux/pm_runtime.h>
20 
21 #include "amd.h"
22 #include "../mach-config.h"
23 
24 #define DRV_NAME "acp_pci"
25 
26 #define ACP3x_REG_START	0x1240000
27 #define ACP3x_REG_END	0x125C000
28 
29 static struct platform_device *dmic_dev;
30 static struct platform_device *pdev;
31 
32 static const struct resource acp_res[] = {
33 	{
34 		.start = 0,
35 		.end = ACP3x_REG_END - ACP3x_REG_START,
36 		.name = "acp_mem",
37 		.flags = IORESOURCE_MEM,
38 	},
39 	{
40 		.start = 0,
41 		.end = 0,
42 		.name = "acp_dai_irq",
43 		.flags = IORESOURCE_IRQ,
44 	},
45 };
46 
acp_pci_probe(struct pci_dev * pci,const struct pci_device_id * pci_id)47 static int acp_pci_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
48 {
49 	struct platform_device_info pdevinfo;
50 	struct device *dev = &pci->dev;
51 	const struct resource *res_acp;
52 	struct acp_chip_info *chip;
53 	struct resource *res;
54 	unsigned int flag, addr, num_res, i;
55 	int ret;
56 
57 	flag = snd_amd_acp_find_config(pci);
58 	if (flag != FLAG_AMD_LEGACY)
59 		return -ENODEV;
60 
61 	chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL);
62 	if (!chip)
63 		return -ENOMEM;
64 
65 	if (pci_enable_device(pci))
66 		return dev_err_probe(&pci->dev, -ENODEV,
67 				     "pci_enable_device failed\n");
68 
69 	ret = pci_request_regions(pci, "AMD ACP3x audio");
70 	if (ret < 0) {
71 		dev_err(&pci->dev, "pci_request_regions failed\n");
72 		ret = -ENOMEM;
73 		goto disable_pci;
74 	}
75 
76 	pci_set_master(pci);
77 
78 	res_acp = acp_res;
79 	num_res = ARRAY_SIZE(acp_res);
80 
81 	switch (pci->revision) {
82 	case 0x01:
83 		chip->name = "acp_asoc_renoir";
84 		chip->acp_rev = ACP3X_DEV;
85 		break;
86 	case 0x6f:
87 		chip->name = "acp_asoc_rembrandt";
88 		chip->acp_rev = ACP6X_DEV;
89 		break;
90 	default:
91 		dev_err(dev, "Unsupported device revision:0x%x\n", pci->revision);
92 		ret = -EINVAL;
93 		goto release_regions;
94 	}
95 
96 	dmic_dev = platform_device_register_data(dev, "dmic-codec", PLATFORM_DEVID_NONE, NULL, 0);
97 	if (IS_ERR(dmic_dev)) {
98 		dev_err(dev, "failed to create DMIC device\n");
99 		ret = PTR_ERR(dmic_dev);
100 		goto release_regions;
101 	}
102 
103 	addr = pci_resource_start(pci, 0);
104 	chip->base = devm_ioremap(&pci->dev, addr, pci_resource_len(pci, 0));
105 	if (!chip->base) {
106 		ret = -ENOMEM;
107 		goto unregister_dmic_dev;
108 	}
109 
110 	ret = acp_init(chip);
111 	if (ret)
112 		goto unregister_dmic_dev;
113 
114 	res = devm_kcalloc(&pci->dev, num_res, sizeof(struct resource), GFP_KERNEL);
115 	if (!res) {
116 		ret = -ENOMEM;
117 		goto unregister_dmic_dev;
118 	}
119 
120 	for (i = 0; i < num_res; i++, res_acp++) {
121 		res[i].name = res_acp->name;
122 		res[i].flags = res_acp->flags;
123 		res[i].start = addr + res_acp->start;
124 		res[i].end = addr + res_acp->end;
125 		if (res_acp->flags == IORESOURCE_IRQ) {
126 			res[i].start = pci->irq;
127 			res[i].end = res[i].start;
128 		}
129 	}
130 
131 	memset(&pdevinfo, 0, sizeof(pdevinfo));
132 
133 	pdevinfo.name = chip->name;
134 	pdevinfo.id = 0;
135 	pdevinfo.parent = &pci->dev;
136 	pdevinfo.num_res = num_res;
137 	pdevinfo.res = &res[0];
138 	pdevinfo.data = chip;
139 	pdevinfo.size_data = sizeof(*chip);
140 
141 	pdev = platform_device_register_full(&pdevinfo);
142 	if (IS_ERR(pdev)) {
143 		dev_err(&pci->dev, "cannot register %s device\n", pdevinfo.name);
144 		ret = PTR_ERR(pdev);
145 		goto unregister_dmic_dev;
146 	}
147 	chip->chip_pdev = pdev;
148 	dev_set_drvdata(&pci->dev, chip);
149 	pm_runtime_set_autosuspend_delay(&pci->dev, 2000);
150 	pm_runtime_use_autosuspend(&pci->dev);
151 	pm_runtime_put_noidle(&pci->dev);
152 	pm_runtime_allow(&pci->dev);
153 	return ret;
154 
155 unregister_dmic_dev:
156 	platform_device_unregister(dmic_dev);
157 release_regions:
158 	pci_release_regions(pci);
159 disable_pci:
160 	pci_disable_device(pci);
161 
162 	return ret;
163 };
164 
snd_acp_suspend(struct device * dev)165 static int __maybe_unused snd_acp_suspend(struct device *dev)
166 {
167 	struct acp_chip_info *chip;
168 	int ret;
169 
170 	chip = dev_get_drvdata(dev);
171 	ret = acp_deinit(chip->base);
172 	if (ret)
173 		dev_err(dev, "ACP de-init failed\n");
174 	return ret;
175 }
176 
snd_acp_resume(struct device * dev)177 static int __maybe_unused snd_acp_resume(struct device *dev)
178 {
179 	struct acp_chip_info *chip;
180 	struct acp_dev_data *adata;
181 	struct device child;
182 	int ret;
183 
184 	chip = dev_get_drvdata(dev);
185 	ret = acp_init(chip);
186 	if (ret)
187 		dev_err(dev, "ACP init failed\n");
188 	if (chip->chip_pdev) {
189 		child = chip->chip_pdev->dev;
190 		adata = dev_get_drvdata(&child);
191 		if (adata)
192 			acp_enable_interrupts(adata);
193 	}
194 	return ret;
195 }
196 
197 static const struct dev_pm_ops acp_pm_ops = {
198 	SET_RUNTIME_PM_OPS(snd_acp_suspend, snd_acp_resume, NULL)
199 	SET_SYSTEM_SLEEP_PM_OPS(snd_acp_suspend, snd_acp_resume)
200 };
201 
acp_pci_remove(struct pci_dev * pci)202 static void acp_pci_remove(struct pci_dev *pci)
203 {
204 	struct acp_chip_info *chip;
205 	int ret;
206 
207 	chip = pci_get_drvdata(pci);
208 	pm_runtime_forbid(&pci->dev);
209 	pm_runtime_get_noresume(&pci->dev);
210 	if (dmic_dev)
211 		platform_device_unregister(dmic_dev);
212 	if (pdev)
213 		platform_device_unregister(pdev);
214 	ret = acp_deinit(chip->base);
215 	if (ret)
216 		dev_err(&pci->dev, "ACP de-init failed\n");
217 }
218 
219 /* PCI IDs */
220 static const struct pci_device_id acp_pci_ids[] = {
221 	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_PCI_DEV_ID)},
222 	{ 0, }
223 };
224 MODULE_DEVICE_TABLE(pci, acp_pci_ids);
225 
226 /* pci_driver definition */
227 static struct pci_driver snd_amd_acp_pci_driver = {
228 	.name = KBUILD_MODNAME,
229 	.id_table = acp_pci_ids,
230 	.probe = acp_pci_probe,
231 	.remove = acp_pci_remove,
232 	.driver = {
233 		.pm = &acp_pm_ops,
234 	},
235 };
236 module_pci_driver(snd_amd_acp_pci_driver);
237 
238 MODULE_LICENSE("Dual BSD/GPL");
239 MODULE_IMPORT_NS(SND_SOC_ACP_COMMON);
240 MODULE_ALIAS(DRV_NAME);
241