1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * AMD Pink Sardine ACP PCI Driver
4 *
5 * Copyright 2022 Advanced Micro Devices, Inc.
6 */
7
8 #include <linux/pci.h>
9 #include <linux/bitops.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/acpi.h>
15 #include <linux/interrupt.h>
16 #include <sound/pcm_params.h>
17 #include <linux/pm_runtime.h>
18 #include <linux/iopoll.h>
19 #include <linux/soundwire/sdw_amd.h>
20 #include "../mach-config.h"
21
22 #include "acp63.h"
23
24 static int acp63_power_on(void __iomem *acp_base)
25 {
26 u32 val;
27
28 val = readl(acp_base + ACP_PGFSM_STATUS);
29
30 if (!val)
31 return val;
32
33 if ((val & ACP_PGFSM_STATUS_MASK) != ACP_POWER_ON_IN_PROGRESS)
34 writel(ACP_PGFSM_CNTL_POWER_ON_MASK, acp_base + ACP_PGFSM_CONTROL);
35
36 return readl_poll_timeout(acp_base + ACP_PGFSM_STATUS, val, !val, DELAY_US, ACP_TIMEOUT);
37 }
38
39 static int acp63_reset(void __iomem *acp_base)
40 {
41 u32 val;
42 int ret;
43
44 writel(1, acp_base + ACP_SOFT_RESET);
45
46 ret = readl_poll_timeout(acp_base + ACP_SOFT_RESET, val,
47 val & ACP_SOFT_RESET_SOFTRESET_AUDDONE_MASK,
48 DELAY_US, ACP_TIMEOUT);
49 if (ret)
50 return ret;
51
52 writel(0, acp_base + ACP_SOFT_RESET);
53
54 return readl_poll_timeout(acp_base + ACP_SOFT_RESET, val, !val, DELAY_US, ACP_TIMEOUT);
55 }
56
57 static void acp63_enable_interrupts(void __iomem *acp_base)
58 {
59 writel(1, acp_base + ACP_EXTERNAL_INTR_ENB);
60 writel(ACP_ERROR_IRQ, acp_base + ACP_EXTERNAL_INTR_CNTL);
61 }
62
63 static void acp63_disable_interrupts(void __iomem *acp_base)
64 {
65 writel(ACP_EXT_INTR_STAT_CLEAR_MASK, acp_base + ACP_EXTERNAL_INTR_STAT);
66 writel(0, acp_base + ACP_EXTERNAL_INTR_CNTL);
67 writel(0, acp_base + ACP_EXTERNAL_INTR_ENB);
68 }
69
70 static int acp63_init(void __iomem *acp_base, struct device *dev)
71 {
72 int ret;
73
74 ret = acp63_power_on(acp_base);
75 if (ret) {
76 dev_err(dev, "ACP power on failed\n");
77 return ret;
78 }
79 writel(0x01, acp_base + ACP_CONTROL);
80 ret = acp63_reset(acp_base);
81 if (ret) {
82 dev_err(dev, "ACP reset failed\n");
83 return ret;
84 }
85 acp63_enable_interrupts(acp_base);
86 return 0;
87 }
88
89 static int acp63_deinit(void __iomem *acp_base, struct device *dev)
90 {
91 int ret;
92
93 acp63_disable_interrupts(acp_base);
94 ret = acp63_reset(acp_base);
95 if (ret) {
96 dev_err(dev, "ACP reset failed\n");
97 return ret;
98 }
99 writel(0, acp_base + ACP_CONTROL);
100 return 0;
101 }
102
103 static irqreturn_t acp63_irq_thread(int irq, void *context)
104 {
105 struct sdw_dma_dev_data *sdw_dma_data;
106 struct acp63_dev_data *adata = context;
107 u32 stream_index;
108
109 sdw_dma_data = dev_get_drvdata(&adata->sdw_dma_dev->dev);
110
111 for (stream_index = 0; stream_index < ACP63_SDW0_DMA_MAX_STREAMS; stream_index++) {
112 if (adata->sdw0_dma_intr_stat[stream_index]) {
113 if (sdw_dma_data->sdw0_dma_stream[stream_index])
114 snd_pcm_period_elapsed(sdw_dma_data->sdw0_dma_stream[stream_index]);
115 adata->sdw0_dma_intr_stat[stream_index] = 0;
116 }
117 }
118 for (stream_index = 0; stream_index < ACP63_SDW1_DMA_MAX_STREAMS; stream_index++) {
119 if (adata->sdw1_dma_intr_stat[stream_index]) {
120 if (sdw_dma_data->sdw1_dma_stream[stream_index])
121 snd_pcm_period_elapsed(sdw_dma_data->sdw1_dma_stream[stream_index]);
122 adata->sdw1_dma_intr_stat[stream_index] = 0;
123 }
124 }
125 return IRQ_HANDLED;
126 }
127
128 static irqreturn_t acp63_irq_handler(int irq, void *dev_id)
129 {
130 struct acp63_dev_data *adata;
131 struct pdm_dev_data *ps_pdm_data;
132 struct amd_sdw_manager *amd_manager;
133 u32 ext_intr_stat, ext_intr_stat1;
134 u32 stream_id = 0;
135 u16 irq_flag = 0;
136 u16 sdw_dma_irq_flag = 0;
137 u16 index;
138
139 adata = dev_id;
140 if (!adata)
141 return IRQ_NONE;
142 /* ACP interrupts will be cleared by reading particular bit and writing
143 * same value to the status register. writing zero's doesn't have any
144 * effect.
145 * Bit by bit checking of IRQ field is implemented.
146 */
147 ext_intr_stat = readl(adata->acp63_base + ACP_EXTERNAL_INTR_STAT);
148 if (ext_intr_stat & ACP_SDW0_STAT) {
149 writel(ACP_SDW0_STAT, adata->acp63_base + ACP_EXTERNAL_INTR_STAT);
150 amd_manager = dev_get_drvdata(&adata->sdw->pdev[0]->dev);
151 if (amd_manager)
152 schedule_work(&amd_manager->amd_sdw_irq_thread);
153 irq_flag = 1;
154 }
155
156 ext_intr_stat1 = readl(adata->acp63_base + ACP_EXTERNAL_INTR_STAT1);
157 if (ext_intr_stat1 & ACP_SDW1_STAT) {
158 writel(ACP_SDW1_STAT, adata->acp63_base + ACP_EXTERNAL_INTR_STAT1);
159 amd_manager = dev_get_drvdata(&adata->sdw->pdev[1]->dev);
160 if (amd_manager)
161 schedule_work(&amd_manager->amd_sdw_irq_thread);
162 irq_flag = 1;
163 }
164
165 if (ext_intr_stat & ACP_ERROR_IRQ) {
166 writel(ACP_ERROR_IRQ, adata->acp63_base + ACP_EXTERNAL_INTR_STAT);
167 /* TODO: Report SoundWire Manager instance errors */
168 writel(0, adata->acp63_base + ACP_SW0_I2S_ERROR_REASON);
169 writel(0, adata->acp63_base + ACP_SW1_I2S_ERROR_REASON);
170 writel(0, adata->acp63_base + ACP_ERROR_STATUS);
171 irq_flag = 1;
172 }
173
174 if (ext_intr_stat & BIT(PDM_DMA_STAT)) {
175 ps_pdm_data = dev_get_drvdata(&adata->pdm_dev->dev);
176 writel(BIT(PDM_DMA_STAT), adata->acp63_base + ACP_EXTERNAL_INTR_STAT);
177 if (ps_pdm_data->capture_stream)
178 snd_pcm_period_elapsed(ps_pdm_data->capture_stream);
179 irq_flag = 1;
180 }
181 if (ext_intr_stat & ACP_SDW_DMA_IRQ_MASK) {
182 for (index = ACP_AUDIO2_RX_THRESHOLD; index <= ACP_AUDIO0_TX_THRESHOLD; index++) {
183 if (ext_intr_stat & BIT(index)) {
184 writel(BIT(index), adata->acp63_base + ACP_EXTERNAL_INTR_STAT);
185 switch (index) {
186 case ACP_AUDIO0_TX_THRESHOLD:
187 stream_id = ACP_SDW0_AUDIO0_TX;
188 break;
189 case ACP_AUDIO1_TX_THRESHOLD:
190 stream_id = ACP_SDW0_AUDIO1_TX;
191 break;
192 case ACP_AUDIO2_TX_THRESHOLD:
193 stream_id = ACP_SDW0_AUDIO2_TX;
194 break;
195 case ACP_AUDIO0_RX_THRESHOLD:
196 stream_id = ACP_SDW0_AUDIO0_RX;
197 break;
198 case ACP_AUDIO1_RX_THRESHOLD:
199 stream_id = ACP_SDW0_AUDIO1_RX;
200 break;
201 case ACP_AUDIO2_RX_THRESHOLD:
202 stream_id = ACP_SDW0_AUDIO2_RX;
203 break;
204 }
205
206 adata->sdw0_dma_intr_stat[stream_id] = 1;
207 sdw_dma_irq_flag = 1;
208 }
209 }
210 }
211
212 if (ext_intr_stat1 & ACP_P1_AUDIO1_RX_THRESHOLD) {
213 writel(ACP_P1_AUDIO1_RX_THRESHOLD,
214 adata->acp63_base + ACP_EXTERNAL_INTR_STAT1);
215 adata->sdw1_dma_intr_stat[ACP_SDW1_AUDIO1_RX] = 1;
216 sdw_dma_irq_flag = 1;
217 }
218
219 if (ext_intr_stat1 & ACP_P1_AUDIO1_TX_THRESHOLD) {
220 writel(ACP_P1_AUDIO1_TX_THRESHOLD,
221 adata->acp63_base + ACP_EXTERNAL_INTR_STAT1);
222 adata->sdw1_dma_intr_stat[ACP_SDW1_AUDIO1_TX] = 1;
223 sdw_dma_irq_flag = 1;
224 }
225
226 if (sdw_dma_irq_flag)
227 return IRQ_WAKE_THREAD;
228
229 if (irq_flag)
230 return IRQ_HANDLED;
231 else
232 return IRQ_NONE;
233 }
234
235 #if IS_ENABLED(CONFIG_SND_SOC_AMD_SOUNDWIRE)
236 static int acp_scan_sdw_devices(struct device *dev, u64 addr)
237 {
238 struct acpi_device *sdw_dev;
239 struct acp63_dev_data *acp_data;
240
241 acp_data = dev_get_drvdata(dev);
242 if (!addr)
243 return -ENODEV;
244
245 sdw_dev = acpi_find_child_device(ACPI_COMPANION(dev), addr, 0);
246 if (!sdw_dev)
247 return -ENODEV;
248
249 acp_data->info.handle = sdw_dev->handle;
250 acp_data->info.count = AMD_SDW_MAX_MANAGERS;
251 return amd_sdw_scan_controller(&acp_data->info);
252 }
253
254 static int amd_sdw_probe(struct device *dev)
255 {
256 struct acp63_dev_data *acp_data;
257 struct sdw_amd_res sdw_res;
258 int ret;
259
260 acp_data = dev_get_drvdata(dev);
261 memset(&sdw_res, 0, sizeof(sdw_res));
262 sdw_res.addr = acp_data->addr;
263 sdw_res.reg_range = acp_data->reg_range;
264 sdw_res.handle = acp_data->info.handle;
265 sdw_res.parent = dev;
266 sdw_res.dev = dev;
267 sdw_res.acp_lock = &acp_data->acp_lock;
268 sdw_res.count = acp_data->info.count;
269 sdw_res.mmio_base = acp_data->acp63_base;
270 sdw_res.link_mask = acp_data->info.link_mask;
271 ret = sdw_amd_probe(&sdw_res, &acp_data->sdw);
272 if (ret)
273 dev_err(dev, "error: SoundWire probe failed\n");
274 return ret;
275 }
276
277 static int amd_sdw_exit(struct acp63_dev_data *acp_data)
278 {
279 if (acp_data->sdw)
280 sdw_amd_exit(acp_data->sdw);
281 acp_data->sdw = NULL;
282
283 return 0;
284 }
285
286 static struct snd_soc_acpi_mach *acp63_sdw_machine_select(struct device *dev)
287 {
288 struct snd_soc_acpi_mach *mach;
289 const struct snd_soc_acpi_link_adr *link;
290 struct acp63_dev_data *acp_data = dev_get_drvdata(dev);
291 int ret, i;
292
293 if (acp_data->info.count) {
294 ret = sdw_amd_get_slave_info(acp_data->sdw);
295 if (ret) {
296 dev_dbg(dev, "failed to read slave information\n");
297 return NULL;
298 }
299 for (mach = acp_data->machines; mach; mach++) {
300 if (!mach->links)
301 break;
302 link = mach->links;
303 for (i = 0; i < acp_data->info.count && link->num_adr; link++, i++) {
304 if (!snd_soc_acpi_sdw_link_slaves_found(dev, link,
305 acp_data->sdw->ids,
306 acp_data->sdw->num_slaves))
307 break;
308 }
309 if (i == acp_data->info.count || !link->num_adr)
310 break;
311 }
312 if (mach && mach->link_mask) {
313 mach->mach_params.links = mach->links;
314 mach->mach_params.link_mask = mach->link_mask;
315 return mach;
316 }
317 }
318 dev_dbg(dev, "No SoundWire machine driver found\n");
319 return NULL;
320 }
321 #else
322 static int acp_scan_sdw_devices(struct device *dev, u64 addr)
323 {
324 return 0;
325 }
326
327 static int amd_sdw_probe(struct device *dev)
328 {
329 return 0;
330 }
331
332 static int amd_sdw_exit(struct acp63_dev_data *acp_data)
333 {
334 return 0;
335 }
336
337 static struct snd_soc_acpi_mach *acp63_sdw_machine_select(struct device *dev)
338 {
339 return NULL;
340 }
341 #endif
342
343 static int acp63_machine_register(struct device *dev)
344 {
345 struct snd_soc_acpi_mach *mach;
346 struct acp63_dev_data *adata = dev_get_drvdata(dev);
347 int size;
348
349 if (adata->is_sdw_dev && adata->is_sdw_config) {
350 size = sizeof(*adata->machines);
351 mach = acp63_sdw_machine_select(dev);
352 if (mach) {
353 adata->mach_dev = platform_device_register_data(dev, mach->drv_name,
354 PLATFORM_DEVID_NONE, mach,
355 size);
356 if (IS_ERR(adata->mach_dev)) {
357 dev_err(dev,
358 "cannot register Machine device for SoundWire Interface\n");
359 return PTR_ERR(adata->mach_dev);
360 }
361 }
362
363 } else if (adata->is_pdm_dev && !adata->is_sdw_dev && adata->is_pdm_config) {
364 adata->mach_dev = platform_device_register_data(dev, "acp_ps_mach",
365 PLATFORM_DEVID_NONE, NULL, 0);
366 if (IS_ERR(adata->mach_dev)) {
367 dev_err(dev, "cannot register amd_ps_mach device\n");
368 return PTR_ERR(adata->mach_dev);
369 }
370 }
371 return 0;
372 }
373
374 static int get_acp63_device_config(struct pci_dev *pci, struct acp63_dev_data *acp_data)
375 {
376 struct acpi_device *pdm_dev;
377 const union acpi_object *obj;
378 u32 config;
379 bool is_dmic_dev = false;
380 bool is_sdw_dev = false;
381 int ret;
382
383 config = readl(acp_data->acp63_base + ACP_PIN_CONFIG);
384 switch (config) {
385 case ACP_CONFIG_4:
386 case ACP_CONFIG_5:
387 case ACP_CONFIG_10:
388 case ACP_CONFIG_11:
389 acp_data->is_pdm_config = true;
390 break;
391 case ACP_CONFIG_2:
392 case ACP_CONFIG_3:
393 acp_data->is_sdw_config = true;
394 break;
395 case ACP_CONFIG_6:
396 case ACP_CONFIG_7:
397 case ACP_CONFIG_12:
398 case ACP_CONFIG_8:
399 case ACP_CONFIG_13:
400 case ACP_CONFIG_14:
401 acp_data->is_pdm_config = true;
402 acp_data->is_sdw_config = true;
403 break;
404 default:
405 break;
406 }
407
408 if (acp_data->is_pdm_config) {
409 pdm_dev = acpi_find_child_device(ACPI_COMPANION(&pci->dev), ACP63_DMIC_ADDR, 0);
410 if (pdm_dev) {
411 /* is_dmic_dev flag will be set when ACP PDM controller device exists */
412 if (!acpi_dev_get_property(pdm_dev, "acp-audio-device-type",
413 ACPI_TYPE_INTEGER, &obj) &&
414 obj->integer.value == ACP_DMIC_DEV)
415 is_dmic_dev = true;
416 }
417 }
418
419 if (acp_data->is_sdw_config) {
420 ret = acp_scan_sdw_devices(&pci->dev, ACP63_SDW_ADDR);
421 if (!ret && acp_data->info.link_mask)
422 is_sdw_dev = true;
423 }
424
425 acp_data->is_pdm_dev = is_dmic_dev;
426 acp_data->is_sdw_dev = is_sdw_dev;
427 if (!is_dmic_dev && !is_sdw_dev) {
428 dev_dbg(&pci->dev, "No PDM or SoundWire manager devices found\n");
429 return -ENODEV;
430 }
431 return 0;
432 }
433
434 static void acp63_fill_platform_dev_info(struct platform_device_info *pdevinfo,
435 struct device *parent,
436 struct fwnode_handle *fw_node,
437 char *name, unsigned int id,
438 const struct resource *res,
439 unsigned int num_res,
440 const void *data,
441 size_t size_data)
442 {
443 pdevinfo->name = name;
444 pdevinfo->id = id;
445 pdevinfo->parent = parent;
446 pdevinfo->num_res = num_res;
447 pdevinfo->res = res;
448 pdevinfo->data = data;
449 pdevinfo->size_data = size_data;
450 pdevinfo->fwnode = fw_node;
451 }
452
453 static int create_acp63_platform_devs(struct pci_dev *pci, struct acp63_dev_data *adata, u32 addr)
454 {
455 struct platform_device_info pdevinfo;
456 struct device *parent;
457 int ret;
458
459 parent = &pci->dev;
460
461 if (adata->is_sdw_dev || adata->is_pdm_dev) {
462 adata->res = devm_kzalloc(&pci->dev, sizeof(struct resource), GFP_KERNEL);
463 if (!adata->res) {
464 ret = -ENOMEM;
465 goto de_init;
466 }
467 adata->res->flags = IORESOURCE_MEM;
468 adata->res->start = addr;
469 adata->res->end = addr + (ACP63_REG_END - ACP63_REG_START);
470 memset(&pdevinfo, 0, sizeof(pdevinfo));
471 }
472
473 if (adata->is_pdm_dev && adata->is_pdm_config) {
474 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "acp_ps_pdm_dma",
475 0, adata->res, 1, NULL, 0);
476
477 adata->pdm_dev = platform_device_register_full(&pdevinfo);
478 if (IS_ERR(adata->pdm_dev)) {
479 dev_err(&pci->dev,
480 "cannot register %s device\n", pdevinfo.name);
481 ret = PTR_ERR(adata->pdm_dev);
482 goto de_init;
483 }
484 memset(&pdevinfo, 0, sizeof(pdevinfo));
485 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "dmic-codec",
486 0, NULL, 0, NULL, 0);
487 adata->dmic_codec_dev = platform_device_register_full(&pdevinfo);
488 if (IS_ERR(adata->dmic_codec_dev)) {
489 dev_err(&pci->dev,
490 "cannot register %s device\n", pdevinfo.name);
491 ret = PTR_ERR(adata->dmic_codec_dev);
492 goto unregister_pdm_dev;
493 }
494 }
495 if (adata->is_sdw_dev && adata->is_sdw_config) {
496 ret = amd_sdw_probe(&pci->dev);
497 if (ret) {
498 if (adata->is_pdm_dev)
499 goto unregister_dmic_codec_dev;
500 else
501 goto de_init;
502 }
503 memset(&pdevinfo, 0, sizeof(pdevinfo));
504 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "amd_ps_sdw_dma",
505 0, adata->res, 1, NULL, 0);
506
507 adata->sdw_dma_dev = platform_device_register_full(&pdevinfo);
508 if (IS_ERR(adata->sdw_dma_dev)) {
509 dev_err(&pci->dev,
510 "cannot register %s device\n", pdevinfo.name);
511 ret = PTR_ERR(adata->sdw_dma_dev);
512 if (adata->is_pdm_dev)
513 goto unregister_dmic_codec_dev;
514 else
515 goto de_init;
516 }
517 }
518
519 return 0;
520 unregister_dmic_codec_dev:
521 platform_device_unregister(adata->dmic_codec_dev);
522 unregister_pdm_dev:
523 platform_device_unregister(adata->pdm_dev);
524 de_init:
525 if (acp63_deinit(adata->acp63_base, &pci->dev))
526 dev_err(&pci->dev, "ACP de-init failed\n");
527 return ret;
528 }
529
530 static int snd_acp63_probe(struct pci_dev *pci,
531 const struct pci_device_id *pci_id)
532 {
533 struct acp63_dev_data *adata;
534 u32 addr;
535 u32 irqflags, flag;
536 int ret;
537
538 irqflags = IRQF_SHARED;
539
540 /* Return if acp config flag is defined */
541 flag = snd_amd_acp_find_config(pci);
542 if (flag)
543 return -ENODEV;
544
545 /* Pink Sardine device check */
546 switch (pci->revision) {
547 case 0x63:
548 break;
549 default:
550 dev_dbg(&pci->dev, "acp63 pci device not found\n");
551 return -ENODEV;
552 }
553 if (pci_enable_device(pci)) {
554 dev_err(&pci->dev, "pci_enable_device failed\n");
555 return -ENODEV;
556 }
557
558 ret = pci_request_regions(pci, "AMD ACP6.2 audio");
559 if (ret < 0) {
560 dev_err(&pci->dev, "pci_request_regions failed\n");
561 goto disable_pci;
562 }
563 adata = devm_kzalloc(&pci->dev, sizeof(struct acp63_dev_data),
564 GFP_KERNEL);
565 if (!adata) {
566 ret = -ENOMEM;
567 goto release_regions;
568 }
569
570 addr = pci_resource_start(pci, 0);
571 adata->acp63_base = devm_ioremap(&pci->dev, addr,
572 pci_resource_len(pci, 0));
573 if (!adata->acp63_base) {
574 ret = -ENOMEM;
575 goto release_regions;
576 }
577 adata->addr = addr;
578 adata->reg_range = ACP63_REG_END - ACP63_REG_START;
579 pci_set_master(pci);
580 pci_set_drvdata(pci, adata);
581 mutex_init(&adata->acp_lock);
582 ret = acp63_init(adata->acp63_base, &pci->dev);
583 if (ret)
584 goto release_regions;
585 ret = devm_request_threaded_irq(&pci->dev, pci->irq, acp63_irq_handler,
586 acp63_irq_thread, irqflags, "ACP_PCI_IRQ", adata);
587 if (ret) {
588 dev_err(&pci->dev, "ACP PCI IRQ request failed\n");
589 goto de_init;
590 }
591 ret = get_acp63_device_config(pci, adata);
592 /* ACP PCI driver probe should be continued even PDM or SoundWire Devices are not found */
593 if (ret) {
594 dev_dbg(&pci->dev, "get acp device config failed:%d\n", ret);
595 goto skip_pdev_creation;
596 }
597 ret = create_acp63_platform_devs(pci, adata, addr);
598 if (ret < 0) {
599 dev_err(&pci->dev, "ACP platform devices creation failed\n");
600 goto de_init;
601 }
602 ret = acp63_machine_register(&pci->dev);
603 if (ret) {
604 dev_err(&pci->dev, "ACP machine register failed\n");
605 goto de_init;
606 }
607 skip_pdev_creation:
608 device_set_wakeup_enable(&pci->dev, true);
609 pm_runtime_set_autosuspend_delay(&pci->dev, ACP_SUSPEND_DELAY_MS);
610 pm_runtime_use_autosuspend(&pci->dev);
611 pm_runtime_put_noidle(&pci->dev);
612 pm_runtime_allow(&pci->dev);
613 return 0;
614 de_init:
615 if (acp63_deinit(adata->acp63_base, &pci->dev))
616 dev_err(&pci->dev, "ACP de-init failed\n");
617 release_regions:
618 pci_release_regions(pci);
619 disable_pci:
620 pci_disable_device(pci);
621
622 return ret;
623 }
624
625 static bool check_acp_sdw_enable_status(struct acp63_dev_data *adata)
626 {
627 u32 sdw0_en, sdw1_en;
628
629 sdw0_en = readl(adata->acp63_base + ACP_SW0_EN);
630 sdw1_en = readl(adata->acp63_base + ACP_SW1_EN);
631 return (sdw0_en || sdw1_en);
632 }
633
634 static void handle_acp63_sdw_pme_event(struct acp63_dev_data *adata)
635 {
636 u32 val;
637
638 val = readl(adata->acp63_base + ACP_SW0_WAKE_EN);
639 if (val && adata->sdw->pdev[0])
640 pm_request_resume(&adata->sdw->pdev[0]->dev);
641
642 val = readl(adata->acp63_base + ACP_SW1_WAKE_EN);
643 if (val && adata->sdw->pdev[1])
644 pm_request_resume(&adata->sdw->pdev[1]->dev);
645 }
646
647 static int __maybe_unused snd_acp63_suspend(struct device *dev)
648 {
649 struct acp63_dev_data *adata;
650 int ret;
651
652 adata = dev_get_drvdata(dev);
653 if (adata->is_sdw_dev) {
654 adata->sdw_en_stat = check_acp_sdw_enable_status(adata);
655 if (adata->sdw_en_stat)
656 return 0;
657 }
658 ret = acp63_deinit(adata->acp63_base, dev);
659 if (ret)
660 dev_err(dev, "ACP de-init failed\n");
661
662 return ret;
663 }
664
665 static int __maybe_unused snd_acp63_runtime_resume(struct device *dev)
666 {
667 struct acp63_dev_data *adata;
668 int ret;
669
670 adata = dev_get_drvdata(dev);
671 if (adata->sdw_en_stat)
672 return 0;
673
674 ret = acp63_init(adata->acp63_base, dev);
675 if (ret) {
676 dev_err(dev, "ACP init failed\n");
677 return ret;
678 }
679
680 if (!adata->sdw_en_stat)
681 handle_acp63_sdw_pme_event(adata);
682 return 0;
683 }
684
685 static int __maybe_unused snd_acp63_resume(struct device *dev)
686 {
687 struct acp63_dev_data *adata;
688 int ret;
689
690 adata = dev_get_drvdata(dev);
691 if (adata->sdw_en_stat)
692 return 0;
693
694 ret = acp63_init(adata->acp63_base, dev);
695 if (ret)
696 dev_err(dev, "ACP init failed\n");
697
698 return ret;
699 }
700
701 static const struct dev_pm_ops acp63_pm_ops = {
702 SET_RUNTIME_PM_OPS(snd_acp63_suspend, snd_acp63_runtime_resume, NULL)
703 SET_SYSTEM_SLEEP_PM_OPS(snd_acp63_suspend, snd_acp63_resume)
704 };
705
706 static void snd_acp63_remove(struct pci_dev *pci)
707 {
708 struct acp63_dev_data *adata;
709 int ret;
710
711 adata = pci_get_drvdata(pci);
712 if (adata->sdw) {
713 amd_sdw_exit(adata);
714 platform_device_unregister(adata->sdw_dma_dev);
715 }
716 if (adata->is_pdm_dev) {
717 platform_device_unregister(adata->pdm_dev);
718 platform_device_unregister(adata->dmic_codec_dev);
719 }
720 if (adata->mach_dev)
721 platform_device_unregister(adata->mach_dev);
722 ret = acp63_deinit(adata->acp63_base, &pci->dev);
723 if (ret)
724 dev_err(&pci->dev, "ACP de-init failed\n");
725 pm_runtime_forbid(&pci->dev);
726 pm_runtime_get_noresume(&pci->dev);
727 pci_release_regions(pci);
728 pci_disable_device(pci);
729 }
730
731 static const struct pci_device_id snd_acp63_ids[] = {
732 { PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_DEVICE_ID),
733 .class = PCI_CLASS_MULTIMEDIA_OTHER << 8,
734 .class_mask = 0xffffff },
735 { 0, },
736 };
737 MODULE_DEVICE_TABLE(pci, snd_acp63_ids);
738
739 static struct pci_driver ps_acp63_driver = {
740 .name = KBUILD_MODNAME,
741 .id_table = snd_acp63_ids,
742 .probe = snd_acp63_probe,
743 .remove = snd_acp63_remove,
744 .driver = {
745 .pm = &acp63_pm_ops,
746 }
747 };
748
749 module_pci_driver(ps_acp63_driver);
750
751 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
752 MODULE_AUTHOR("Syed.SabaKareem@amd.com");
753 MODULE_DESCRIPTION("AMD ACP Pink Sardine PCI driver");
754 MODULE_IMPORT_NS(SOUNDWIRE_AMD_INIT);
755 MODULE_IMPORT_NS(SND_AMD_SOUNDWIRE_ACPI);
756 MODULE_LICENSE("GPL v2");
757
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.