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 wake_irq_flag = 0; 197 u16 sdw_dma_irq_flag = 0; 198 199 adata = dev_id; 200 if (!adata) 201 return IRQ_NONE; 202 /* ACP interrupts will be cleared by reading particular bit and writing 203 * same value to the status register. writing zero's doesn't have any 204 * effect. 205 * Bit by bit checking of IRQ field is implemented. 206 */ 207 ext_intr_stat = readl(adata->acp63_base + ACP_EXTERNAL_INTR_STAT); 208 if (ext_intr_stat & ACP_SDW0_STAT) { 209 writel(ACP_SDW0_STAT, adata->acp63_base + ACP_EXTERNAL_INTR_STAT); 210 amd_manager = dev_get_drvdata(&adata->sdw->pdev[0]->dev); 211 if (amd_manager) 212 schedule_work(&amd_manager->amd_sdw_irq_thread); 213 irq_flag = 1; 214 } 215 216 ext_intr_stat1 = readl(adata->acp63_base + ACP_EXTERNAL_INTR_STAT1); 217 if (ext_intr_stat1 & ACP_SDW1_STAT) { 218 writel(ACP_SDW1_STAT, adata->acp63_base + ACP_EXTERNAL_INTR_STAT1); 219 amd_manager = dev_get_drvdata(&adata->sdw->pdev[1]->dev); 220 if (amd_manager) 221 schedule_work(&amd_manager->amd_sdw_irq_thread); 222 irq_flag = 1; 223 } 224 225 if (ext_intr_stat & ACP_ERROR_IRQ) { 226 writel(ACP_ERROR_IRQ, adata->acp63_base + ACP_EXTERNAL_INTR_STAT); 227 /* TODO: Report SoundWire Manager instance errors */ 228 writel(0, adata->acp63_base + ACP_SW0_I2S_ERROR_REASON); 229 writel(0, adata->acp63_base + ACP_SW1_I2S_ERROR_REASON); 230 writel(0, adata->acp63_base + ACP_ERROR_STATUS); 231 irq_flag = 1; 232 } 233 234 if (adata->acp_rev >= ACP70_PCI_REV) 235 wake_irq_flag = check_and_handle_acp70_sdw_wake_irq(adata); 236 237 if (ext_intr_stat & BIT(PDM_DMA_STAT)) { 238 ps_pdm_data = dev_get_drvdata(&adata->pdm_dev->dev); 239 writel(BIT(PDM_DMA_STAT), adata->acp63_base + ACP_EXTERNAL_INTR_STAT); 240 if (ps_pdm_data->capture_stream) 241 snd_pcm_period_elapsed(ps_pdm_data->capture_stream); 242 irq_flag = 1; 243 } 244 245 sdw_dma_irq_flag = check_and_handle_sdw_dma_irq(adata, ext_intr_stat, ext_intr_stat1); 246 if (sdw_dma_irq_flag) 247 return IRQ_WAKE_THREAD; 248 249 if (irq_flag | wake_irq_flag) 250 return IRQ_HANDLED; 251 else 252 return IRQ_NONE; 253 } 254 255 #if IS_ENABLED(CONFIG_SND_SOC_AMD_SOUNDWIRE) 256 static int acp_scan_sdw_devices(struct device *dev, u64 addr) 257 { 258 struct acpi_device *sdw_dev; 259 struct acp63_dev_data *acp_data; 260 261 acp_data = dev_get_drvdata(dev); 262 if (!addr) 263 return -ENODEV; 264 265 sdw_dev = acpi_find_child_device(ACPI_COMPANION(dev), addr, 0); 266 if (!sdw_dev) 267 return -ENODEV; 268 269 acp_data->info.handle = sdw_dev->handle; 270 acp_data->info.count = AMD_SDW_MAX_MANAGERS; 271 return amd_sdw_scan_controller(&acp_data->info); 272 } 273 274 static int amd_sdw_probe(struct device *dev) 275 { 276 struct acp63_dev_data *acp_data; 277 struct sdw_amd_res sdw_res; 278 int ret; 279 280 acp_data = dev_get_drvdata(dev); 281 memset(&sdw_res, 0, sizeof(sdw_res)); 282 sdw_res.addr = acp_data->addr; 283 sdw_res.reg_range = acp_data->reg_range; 284 sdw_res.handle = acp_data->info.handle; 285 sdw_res.parent = dev; 286 sdw_res.dev = dev; 287 sdw_res.acp_lock = &acp_data->acp_lock; 288 sdw_res.count = acp_data->info.count; 289 sdw_res.mmio_base = acp_data->acp63_base; 290 sdw_res.acp_rev = acp_data->acp_rev; 291 sdw_res.link_mask = acp_data->info.link_mask; 292 ret = sdw_amd_probe(&sdw_res, &acp_data->sdw); 293 if (ret) 294 dev_err(dev, "error: SoundWire probe failed\n"); 295 return ret; 296 } 297 298 static int amd_sdw_exit(struct acp63_dev_data *acp_data) 299 { 300 if (acp_data->sdw) 301 sdw_amd_exit(acp_data->sdw); 302 acp_data->sdw = NULL; 303 304 return 0; 305 } 306 307 static struct snd_soc_acpi_mach *acp63_sdw_machine_select(struct device *dev) 308 { 309 struct snd_soc_acpi_mach *mach; 310 const struct snd_soc_acpi_link_adr *link; 311 struct acp63_dev_data *acp_data = dev_get_drvdata(dev); 312 int ret, i; 313 314 if (acp_data->info.count) { 315 ret = sdw_amd_get_slave_info(acp_data->sdw); 316 if (ret) { 317 dev_dbg(dev, "failed to read slave information\n"); 318 return NULL; 319 } 320 for (mach = acp_data->machines; mach; mach++) { 321 if (!mach->links) 322 break; 323 link = mach->links; 324 for (i = 0; i < acp_data->info.count && link->num_adr; link++, i++) { 325 if (!snd_soc_acpi_sdw_link_slaves_found(dev, link, 326 acp_data->sdw->peripherals)) 327 break; 328 } 329 if (i == acp_data->info.count || !link->num_adr) 330 break; 331 } 332 if (mach && mach->link_mask) { 333 mach->mach_params.links = mach->links; 334 mach->mach_params.link_mask = mach->link_mask; 335 mach->mach_params.subsystem_rev = acp_data->acp_rev; 336 return mach; 337 } 338 } 339 dev_dbg(dev, "No SoundWire machine driver found\n"); 340 return NULL; 341 } 342 #else 343 static int acp_scan_sdw_devices(struct device *dev, u64 addr) 344 { 345 return 0; 346 } 347 348 static int amd_sdw_probe(struct device *dev) 349 { 350 return 0; 351 } 352 353 static int amd_sdw_exit(struct acp63_dev_data *acp_data) 354 { 355 return 0; 356 } 357 358 static struct snd_soc_acpi_mach *acp63_sdw_machine_select(struct device *dev) 359 { 360 return NULL; 361 } 362 #endif 363 364 static int acp63_machine_register(struct device *dev) 365 { 366 struct snd_soc_acpi_mach *mach; 367 struct acp63_dev_data *adata = dev_get_drvdata(dev); 368 int size; 369 370 if (adata->is_sdw_dev && adata->is_sdw_config) { 371 size = sizeof(*adata->machines); 372 mach = acp63_sdw_machine_select(dev); 373 if (mach) { 374 adata->mach_dev = platform_device_register_data(dev, mach->drv_name, 375 PLATFORM_DEVID_NONE, mach, 376 size); 377 if (IS_ERR(adata->mach_dev)) { 378 dev_err(dev, 379 "cannot register Machine device for SoundWire Interface\n"); 380 return PTR_ERR(adata->mach_dev); 381 } 382 } 383 384 } else if (adata->is_pdm_dev && !adata->is_sdw_dev && adata->is_pdm_config) { 385 adata->mach_dev = platform_device_register_data(dev, "acp_ps_mach", 386 PLATFORM_DEVID_NONE, NULL, 0); 387 if (IS_ERR(adata->mach_dev)) { 388 dev_err(dev, "cannot register amd_ps_mach device\n"); 389 return PTR_ERR(adata->mach_dev); 390 } 391 } 392 return 0; 393 } 394 395 static int get_acp63_device_config(struct pci_dev *pci, struct acp63_dev_data *acp_data) 396 { 397 struct acpi_device *pdm_dev; 398 const union acpi_object *obj; 399 acpi_handle handle; 400 acpi_integer dmic_status; 401 bool is_dmic_dev = false; 402 bool is_sdw_dev = false; 403 bool wov_en, dmic_en; 404 int ret; 405 406 /* IF WOV entry not found, enable dmic based on acp-audio-device-type entry*/ 407 wov_en = true; 408 dmic_en = false; 409 410 acp_hw_get_config(pci, acp_data); 411 412 if (acp_data->is_pdm_config) { 413 pdm_dev = acpi_find_child_device(ACPI_COMPANION(&pci->dev), ACP63_DMIC_ADDR, 0); 414 if (pdm_dev) { 415 /* is_dmic_dev flag will be set when ACP PDM controller device exists */ 416 if (!acpi_dev_get_property(pdm_dev, "acp-audio-device-type", 417 ACPI_TYPE_INTEGER, &obj) && 418 obj->integer.value == ACP_DMIC_DEV) 419 dmic_en = true; 420 } 421 422 handle = ACPI_HANDLE(&pci->dev); 423 ret = acpi_evaluate_integer(handle, "_WOV", NULL, &dmic_status); 424 if (!ACPI_FAILURE(ret)) 425 wov_en = dmic_status; 426 } 427 428 if (dmic_en && wov_en) 429 is_dmic_dev = true; 430 431 if (acp_data->is_sdw_config) { 432 ret = acp_scan_sdw_devices(&pci->dev, ACP63_SDW_ADDR); 433 if (!ret && acp_data->info.link_mask) 434 is_sdw_dev = true; 435 } 436 437 acp_data->is_pdm_dev = is_dmic_dev; 438 acp_data->is_sdw_dev = is_sdw_dev; 439 if (!is_dmic_dev && !is_sdw_dev) { 440 dev_dbg(&pci->dev, "No PDM or SoundWire manager devices found\n"); 441 return -ENODEV; 442 } 443 return 0; 444 } 445 446 static void acp63_fill_platform_dev_info(struct platform_device_info *pdevinfo, 447 struct device *parent, 448 struct fwnode_handle *fw_node, 449 char *name, unsigned int id, 450 const struct resource *res, 451 unsigned int num_res, 452 const void *data, 453 size_t size_data) 454 { 455 pdevinfo->name = name; 456 pdevinfo->id = id; 457 pdevinfo->parent = parent; 458 pdevinfo->num_res = num_res; 459 pdevinfo->res = res; 460 pdevinfo->data = data; 461 pdevinfo->size_data = size_data; 462 pdevinfo->fwnode = fw_node; 463 } 464 465 static int create_acp63_platform_devs(struct pci_dev *pci, struct acp63_dev_data *adata, u32 addr) 466 { 467 struct platform_device_info pdevinfo; 468 struct device *parent; 469 int ret; 470 471 parent = &pci->dev; 472 473 if (adata->is_sdw_dev || adata->is_pdm_dev) { 474 adata->res = devm_kzalloc(&pci->dev, sizeof(struct resource), GFP_KERNEL); 475 if (!adata->res) { 476 ret = -ENOMEM; 477 goto de_init; 478 } 479 adata->res->flags = IORESOURCE_MEM; 480 adata->res->start = addr; 481 adata->res->end = addr + (ACP63_REG_END - ACP63_REG_START); 482 memset(&pdevinfo, 0, sizeof(pdevinfo)); 483 } 484 485 if (adata->is_pdm_dev && adata->is_pdm_config) { 486 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "acp_ps_pdm_dma", 487 0, adata->res, 1, NULL, 0); 488 489 adata->pdm_dev = platform_device_register_full(&pdevinfo); 490 if (IS_ERR(adata->pdm_dev)) { 491 dev_err(&pci->dev, 492 "cannot register %s device\n", pdevinfo.name); 493 ret = PTR_ERR(adata->pdm_dev); 494 goto de_init; 495 } 496 memset(&pdevinfo, 0, sizeof(pdevinfo)); 497 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "dmic-codec", 498 0, NULL, 0, NULL, 0); 499 adata->dmic_codec_dev = platform_device_register_full(&pdevinfo); 500 if (IS_ERR(adata->dmic_codec_dev)) { 501 dev_err(&pci->dev, 502 "cannot register %s device\n", pdevinfo.name); 503 ret = PTR_ERR(adata->dmic_codec_dev); 504 goto unregister_pdm_dev; 505 } 506 } 507 if (adata->is_sdw_dev && adata->is_sdw_config) { 508 ret = amd_sdw_probe(&pci->dev); 509 if (ret) { 510 if (adata->is_pdm_dev) 511 goto unregister_dmic_codec_dev; 512 else 513 goto de_init; 514 } 515 memset(&pdevinfo, 0, sizeof(pdevinfo)); 516 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "amd_ps_sdw_dma", 517 0, adata->res, 1, NULL, 0); 518 519 adata->sdw_dma_dev = platform_device_register_full(&pdevinfo); 520 if (IS_ERR(adata->sdw_dma_dev)) { 521 dev_err(&pci->dev, 522 "cannot register %s device\n", pdevinfo.name); 523 ret = PTR_ERR(adata->sdw_dma_dev); 524 if (adata->is_pdm_dev) 525 goto unregister_dmic_codec_dev; 526 else 527 goto de_init; 528 } 529 } 530 531 return 0; 532 unregister_dmic_codec_dev: 533 platform_device_unregister(adata->dmic_codec_dev); 534 unregister_pdm_dev: 535 platform_device_unregister(adata->pdm_dev); 536 de_init: 537 if (acp_hw_deinit(adata, &pci->dev)) 538 dev_err(&pci->dev, "ACP de-init failed\n"); 539 return ret; 540 } 541 542 static int acp_hw_init_ops(struct acp63_dev_data *adata, struct pci_dev *pci) 543 { 544 adata->hw_ops = devm_kzalloc(&pci->dev, sizeof(struct acp_hw_ops), 545 GFP_KERNEL); 546 if (!adata->hw_ops) 547 return -ENOMEM; 548 549 switch (adata->acp_rev) { 550 case ACP63_PCI_REV: 551 acp63_hw_init_ops(adata->hw_ops); 552 break; 553 case ACP70_PCI_REV: 554 case ACP71_PCI_REV: 555 acp70_hw_init_ops(adata->hw_ops); 556 break; 557 default: 558 dev_err(&pci->dev, "ACP device not found\n"); 559 return -ENODEV; 560 } 561 return 0; 562 } 563 564 static int snd_acp63_probe(struct pci_dev *pci, 565 const struct pci_device_id *pci_id) 566 { 567 struct acp63_dev_data *adata; 568 u32 addr; 569 u32 irqflags, flag; 570 int ret; 571 572 irqflags = IRQF_SHARED; 573 574 /* Return if acp config flag is defined */ 575 flag = snd_amd_acp_find_config(pci); 576 if (flag) 577 return -ENODEV; 578 579 /* ACP PCI revision id check for ACP6.3, ACP7.0 & ACP7.1 platforms */ 580 switch (pci->revision) { 581 case ACP63_PCI_REV: 582 case ACP70_PCI_REV: 583 case ACP71_PCI_REV: 584 break; 585 default: 586 dev_dbg(&pci->dev, "acp63/acp70/acp71 pci device not found\n"); 587 return -ENODEV; 588 } 589 if (pci_enable_device(pci)) { 590 dev_err(&pci->dev, "pci_enable_device failed\n"); 591 return -ENODEV; 592 } 593 594 ret = pci_request_regions(pci, "AMD ACP6.2 audio"); 595 if (ret < 0) { 596 dev_err(&pci->dev, "pci_request_regions failed\n"); 597 goto disable_pci; 598 } 599 adata = devm_kzalloc(&pci->dev, sizeof(struct acp63_dev_data), 600 GFP_KERNEL); 601 if (!adata) { 602 ret = -ENOMEM; 603 goto release_regions; 604 } 605 606 addr = pci_resource_start(pci, 0); 607 adata->acp63_base = devm_ioremap(&pci->dev, addr, 608 pci_resource_len(pci, 0)); 609 if (!adata->acp63_base) { 610 ret = -ENOMEM; 611 goto release_regions; 612 } 613 adata->addr = addr; 614 adata->reg_range = ACP63_REG_END - ACP63_REG_START; 615 adata->acp_rev = pci->revision; 616 pci_set_master(pci); 617 pci_set_drvdata(pci, adata); 618 mutex_init(&adata->acp_lock); 619 ret = acp_hw_init_ops(adata, pci); 620 if (ret) { 621 dev_err(&pci->dev, "ACP hw ops init failed\n"); 622 goto release_regions; 623 } 624 ret = acp_hw_init(adata, &pci->dev); 625 if (ret) 626 goto release_regions; 627 ret = devm_request_threaded_irq(&pci->dev, pci->irq, acp63_irq_handler, 628 acp63_irq_thread, irqflags, "ACP_PCI_IRQ", adata); 629 if (ret) { 630 dev_err(&pci->dev, "ACP PCI IRQ request failed\n"); 631 goto de_init; 632 } 633 ret = get_acp63_device_config(pci, adata); 634 /* ACP PCI driver probe should be continued even PDM or SoundWire Devices are not found */ 635 if (ret) { 636 dev_dbg(&pci->dev, "get acp device config failed:%d\n", ret); 637 goto skip_pdev_creation; 638 } 639 ret = create_acp63_platform_devs(pci, adata, addr); 640 if (ret < 0) { 641 dev_err(&pci->dev, "ACP platform devices creation failed\n"); 642 goto de_init; 643 } 644 if (adata->acp_rev >= ACP70_PCI_REV) 645 adata->machines = snd_soc_acpi_amd_acp70_sdw_machines; 646 else 647 adata->machines = snd_soc_acpi_amd_acp63_sdw_machines; 648 649 ret = acp63_machine_register(&pci->dev); 650 if (ret) { 651 dev_err(&pci->dev, "ACP machine register failed\n"); 652 goto de_init; 653 } 654 skip_pdev_creation: 655 device_set_wakeup_enable(&pci->dev, true); 656 pm_runtime_set_autosuspend_delay(&pci->dev, ACP_SUSPEND_DELAY_MS); 657 pm_runtime_use_autosuspend(&pci->dev); 658 pm_runtime_put_noidle(&pci->dev); 659 pm_runtime_allow(&pci->dev); 660 return 0; 661 de_init: 662 if (acp_hw_deinit(adata, &pci->dev)) 663 dev_err(&pci->dev, "ACP de-init failed\n"); 664 release_regions: 665 pci_release_regions(pci); 666 disable_pci: 667 pci_disable_device(pci); 668 669 return ret; 670 } 671 672 static int snd_acp_suspend(struct device *dev) 673 { 674 return acp_hw_suspend(dev); 675 } 676 677 static int snd_acp_runtime_resume(struct device *dev) 678 { 679 return acp_hw_runtime_resume(dev); 680 } 681 682 static int snd_acp_resume(struct device *dev) 683 { 684 return acp_hw_resume(dev); 685 } 686 687 static const struct dev_pm_ops acp63_pm_ops = { 688 RUNTIME_PM_OPS(snd_acp_suspend, snd_acp_runtime_resume, NULL) 689 SYSTEM_SLEEP_PM_OPS(snd_acp_suspend, snd_acp_resume) 690 }; 691 692 static void snd_acp63_remove(struct pci_dev *pci) 693 { 694 struct acp63_dev_data *adata; 695 int ret; 696 697 adata = pci_get_drvdata(pci); 698 if (adata->sdw) { 699 amd_sdw_exit(adata); 700 platform_device_unregister(adata->sdw_dma_dev); 701 } 702 if (adata->is_pdm_dev) { 703 platform_device_unregister(adata->pdm_dev); 704 platform_device_unregister(adata->dmic_codec_dev); 705 } 706 if (adata->mach_dev) 707 platform_device_unregister(adata->mach_dev); 708 ret = acp_hw_deinit(adata, &pci->dev); 709 if (ret) 710 dev_err(&pci->dev, "ACP de-init failed\n"); 711 pm_runtime_forbid(&pci->dev); 712 pm_runtime_get_noresume(&pci->dev); 713 pci_release_regions(pci); 714 pci_disable_device(pci); 715 } 716 717 static const struct pci_device_id snd_acp63_ids[] = { 718 { PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_DEVICE_ID), 719 .class = PCI_CLASS_MULTIMEDIA_OTHER << 8, 720 .class_mask = 0xffffff }, 721 { 0, }, 722 }; 723 MODULE_DEVICE_TABLE(pci, snd_acp63_ids); 724 725 static struct pci_driver ps_acp63_driver = { 726 .name = KBUILD_MODNAME, 727 .id_table = snd_acp63_ids, 728 .probe = snd_acp63_probe, 729 .remove = snd_acp63_remove, 730 .driver = { 731 .pm = pm_ptr(&acp63_pm_ops), 732 } 733 }; 734 735 module_pci_driver(ps_acp63_driver); 736 737 MODULE_AUTHOR("Vijendar.Mukunda@amd.com"); 738 MODULE_AUTHOR("Syed.SabaKareem@amd.com"); 739 MODULE_DESCRIPTION("AMD common ACP PCI driver for ACP6.3, ACP7.0 & ACP7.1 platforms"); 740 MODULE_IMPORT_NS("SOUNDWIRE_AMD_INIT"); 741 MODULE_IMPORT_NS("SND_AMD_SOUNDWIRE_ACPI"); 742 MODULE_LICENSE("GPL v2"); 743