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