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