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 mach->mach_params.subsystem_vendor = acp_data->subsystem_vendor; 339 mach->mach_params.subsystem_device = acp_data->subsystem_device; 340 mach->mach_params.subsystem_id_set = true; 341 342 dev_dbg(dev, "SSID %x%x\n", mach->mach_params.subsystem_vendor, 343 mach->mach_params.subsystem_device); 344 return mach; 345 } 346 } 347 dev_dbg(dev, "No SoundWire machine driver found\n"); 348 return NULL; 349 } 350 #else 351 static int acp_scan_sdw_devices(struct device *dev, u64 addr) 352 { 353 return 0; 354 } 355 356 static int amd_sdw_probe(struct device *dev) 357 { 358 return 0; 359 } 360 361 static int amd_sdw_exit(struct acp63_dev_data *acp_data) 362 { 363 return 0; 364 } 365 366 static struct snd_soc_acpi_mach *acp63_sdw_machine_select(struct device *dev) 367 { 368 return NULL; 369 } 370 #endif 371 372 static int acp63_machine_register(struct device *dev) 373 { 374 struct snd_soc_acpi_mach *mach; 375 struct acp63_dev_data *adata = dev_get_drvdata(dev); 376 int size; 377 378 if (adata->is_sdw_dev && adata->is_sdw_config) { 379 size = sizeof(*adata->machines); 380 mach = acp63_sdw_machine_select(dev); 381 if (mach) { 382 adata->mach_dev = platform_device_register_data(dev, mach->drv_name, 383 PLATFORM_DEVID_NONE, mach, 384 size); 385 if (IS_ERR(adata->mach_dev)) { 386 dev_err(dev, 387 "cannot register Machine device for SoundWire Interface\n"); 388 return PTR_ERR(adata->mach_dev); 389 } 390 } 391 392 } else if (adata->is_pdm_dev && !adata->is_sdw_dev && adata->is_pdm_config) { 393 adata->mach_dev = platform_device_register_data(dev, "acp_ps_mach", 394 PLATFORM_DEVID_NONE, NULL, 0); 395 if (IS_ERR(adata->mach_dev)) { 396 dev_err(dev, "cannot register amd_ps_mach device\n"); 397 return PTR_ERR(adata->mach_dev); 398 } 399 } 400 return 0; 401 } 402 403 static int get_acp63_device_config(struct pci_dev *pci, struct acp63_dev_data *acp_data) 404 { 405 struct acpi_device *pdm_dev; 406 const union acpi_object *obj; 407 acpi_handle handle; 408 acpi_integer dmic_status; 409 bool is_dmic_dev = false; 410 bool is_sdw_dev = false; 411 bool wov_en, dmic_en; 412 int ret; 413 414 /* IF WOV entry not found, enable dmic based on acp-audio-device-type entry*/ 415 wov_en = true; 416 dmic_en = false; 417 418 acp_hw_get_config(pci, acp_data); 419 420 if (acp_data->is_pdm_config) { 421 pdm_dev = acpi_find_child_device(ACPI_COMPANION(&pci->dev), ACP63_DMIC_ADDR, 0); 422 if (pdm_dev) { 423 /* is_dmic_dev flag will be set when ACP PDM controller device exists */ 424 if (!acpi_dev_get_property(pdm_dev, "acp-audio-device-type", 425 ACPI_TYPE_INTEGER, &obj) && 426 obj->integer.value == ACP_DMIC_DEV) 427 dmic_en = true; 428 } 429 430 handle = ACPI_HANDLE(&pci->dev); 431 ret = acpi_evaluate_integer(handle, "_WOV", NULL, &dmic_status); 432 if (!ACPI_FAILURE(ret)) 433 wov_en = dmic_status; 434 } 435 436 if (dmic_en && wov_en) 437 is_dmic_dev = true; 438 439 if (acp_data->is_sdw_config) { 440 ret = acp_scan_sdw_devices(&pci->dev, ACP63_SDW_ADDR); 441 if (!ret && acp_data->info.link_mask) 442 is_sdw_dev = true; 443 } 444 445 acp_data->is_pdm_dev = is_dmic_dev; 446 acp_data->is_sdw_dev = is_sdw_dev; 447 if (!is_dmic_dev && !is_sdw_dev) { 448 dev_dbg(&pci->dev, "No PDM or SoundWire manager devices found\n"); 449 return -ENODEV; 450 } 451 return 0; 452 } 453 454 static void acp63_fill_platform_dev_info(struct platform_device_info *pdevinfo, 455 struct device *parent, 456 struct fwnode_handle *fw_node, 457 char *name, unsigned int id, 458 const struct resource *res, 459 unsigned int num_res, 460 const void *data, 461 size_t size_data) 462 { 463 pdevinfo->name = name; 464 pdevinfo->id = id; 465 pdevinfo->parent = parent; 466 pdevinfo->num_res = num_res; 467 pdevinfo->res = res; 468 pdevinfo->data = data; 469 pdevinfo->size_data = size_data; 470 pdevinfo->fwnode = fw_node; 471 } 472 473 static int create_acp63_platform_devs(struct pci_dev *pci, struct acp63_dev_data *adata, u32 addr) 474 { 475 struct platform_device_info pdevinfo; 476 struct device *parent; 477 int ret; 478 479 parent = &pci->dev; 480 481 if (adata->is_sdw_dev || adata->is_pdm_dev) { 482 adata->res = devm_kzalloc(&pci->dev, sizeof(struct resource), GFP_KERNEL); 483 if (!adata->res) { 484 ret = -ENOMEM; 485 goto de_init; 486 } 487 adata->res->flags = IORESOURCE_MEM; 488 adata->res->start = addr; 489 adata->res->end = addr + (ACP63_REG_END - ACP63_REG_START); 490 memset(&pdevinfo, 0, sizeof(pdevinfo)); 491 } 492 493 if (adata->is_pdm_dev && adata->is_pdm_config) { 494 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "acp_ps_pdm_dma", 495 0, adata->res, 1, NULL, 0); 496 497 adata->pdm_dev = platform_device_register_full(&pdevinfo); 498 if (IS_ERR(adata->pdm_dev)) { 499 dev_err(&pci->dev, 500 "cannot register %s device\n", pdevinfo.name); 501 ret = PTR_ERR(adata->pdm_dev); 502 goto de_init; 503 } 504 memset(&pdevinfo, 0, sizeof(pdevinfo)); 505 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "dmic-codec", 506 0, NULL, 0, NULL, 0); 507 adata->dmic_codec_dev = platform_device_register_full(&pdevinfo); 508 if (IS_ERR(adata->dmic_codec_dev)) { 509 dev_err(&pci->dev, 510 "cannot register %s device\n", pdevinfo.name); 511 ret = PTR_ERR(adata->dmic_codec_dev); 512 goto unregister_pdm_dev; 513 } 514 } 515 if (adata->is_sdw_dev && adata->is_sdw_config) { 516 ret = amd_sdw_probe(&pci->dev); 517 if (ret) { 518 if (adata->is_pdm_dev) 519 goto unregister_dmic_codec_dev; 520 else 521 goto de_init; 522 } 523 memset(&pdevinfo, 0, sizeof(pdevinfo)); 524 acp63_fill_platform_dev_info(&pdevinfo, parent, NULL, "amd_ps_sdw_dma", 525 0, adata->res, 1, NULL, 0); 526 527 adata->sdw_dma_dev = platform_device_register_full(&pdevinfo); 528 if (IS_ERR(adata->sdw_dma_dev)) { 529 dev_err(&pci->dev, 530 "cannot register %s device\n", pdevinfo.name); 531 ret = PTR_ERR(adata->sdw_dma_dev); 532 if (adata->is_pdm_dev) 533 goto unregister_dmic_codec_dev; 534 else 535 goto de_init; 536 } 537 } 538 539 return 0; 540 unregister_dmic_codec_dev: 541 platform_device_unregister(adata->dmic_codec_dev); 542 unregister_pdm_dev: 543 platform_device_unregister(adata->pdm_dev); 544 de_init: 545 if (acp_hw_deinit(adata, &pci->dev)) 546 dev_err(&pci->dev, "ACP de-init failed\n"); 547 return ret; 548 } 549 550 static int acp_hw_init_ops(struct acp63_dev_data *adata, struct pci_dev *pci) 551 { 552 adata->hw_ops = devm_kzalloc(&pci->dev, sizeof(struct acp_hw_ops), 553 GFP_KERNEL); 554 if (!adata->hw_ops) 555 return -ENOMEM; 556 557 switch (adata->acp_rev) { 558 case ACP63_PCI_REV: 559 acp63_hw_init_ops(adata->hw_ops); 560 break; 561 case ACP70_PCI_REV: 562 case ACP71_PCI_REV: 563 case ACP72_PCI_REV: 564 acp70_hw_init_ops(adata->hw_ops); 565 break; 566 default: 567 dev_err(&pci->dev, "ACP device not found\n"); 568 return -ENODEV; 569 } 570 return 0; 571 } 572 573 static int snd_acp63_probe(struct pci_dev *pci, 574 const struct pci_device_id *pci_id) 575 { 576 struct acp63_dev_data *adata; 577 u32 addr; 578 u32 irqflags, flag; 579 int ret; 580 581 irqflags = IRQF_SHARED; 582 583 /* Return if acp config flag is defined */ 584 flag = snd_amd_acp_find_config(pci); 585 if (flag) 586 return -ENODEV; 587 588 /* ACP PCI revision id check for ACP6.3, ACP7.0 & ACP7.1 platforms */ 589 switch (pci->revision) { 590 case ACP63_PCI_REV: 591 case ACP70_PCI_REV: 592 case ACP71_PCI_REV: 593 case ACP72_PCI_REV: 594 break; 595 default: 596 dev_dbg(&pci->dev, "acp63/acp70/acp71 pci device not found\n"); 597 return -ENODEV; 598 } 599 if (pci_enable_device(pci)) { 600 dev_err(&pci->dev, "pci_enable_device failed\n"); 601 return -ENODEV; 602 } 603 604 ret = pci_request_regions(pci, "AMD ACP6.2 audio"); 605 if (ret < 0) { 606 dev_err(&pci->dev, "pci_request_regions failed\n"); 607 goto disable_pci; 608 } 609 adata = devm_kzalloc(&pci->dev, sizeof(struct acp63_dev_data), 610 GFP_KERNEL); 611 if (!adata) { 612 ret = -ENOMEM; 613 goto release_regions; 614 } 615 616 addr = pci_resource_start(pci, 0); 617 adata->acp63_base = devm_ioremap(&pci->dev, addr, 618 pci_resource_len(pci, 0)); 619 if (!adata->acp63_base) { 620 ret = -ENOMEM; 621 goto release_regions; 622 } 623 adata->addr = addr; 624 adata->reg_range = ACP63_REG_END - ACP63_REG_START; 625 adata->acp_rev = pci->revision; 626 adata->subsystem_vendor = pci->subsystem_vendor; 627 adata->subsystem_device = pci->subsystem_device; 628 629 pci_set_master(pci); 630 pci_set_drvdata(pci, adata); 631 mutex_init(&adata->acp_lock); 632 ret = acp_hw_init_ops(adata, pci); 633 if (ret) { 634 dev_err(&pci->dev, "ACP hw ops init failed\n"); 635 goto release_regions; 636 } 637 ret = acp_hw_init(adata, &pci->dev); 638 if (ret) 639 goto release_regions; 640 ret = devm_request_threaded_irq(&pci->dev, pci->irq, acp63_irq_handler, 641 acp63_irq_thread, irqflags, "ACP_PCI_IRQ", adata); 642 if (ret) { 643 dev_err(&pci->dev, "ACP PCI IRQ request failed\n"); 644 goto de_init; 645 } 646 ret = get_acp63_device_config(pci, adata); 647 /* ACP PCI driver probe should be continued even PDM or SoundWire Devices are not found */ 648 if (ret) { 649 dev_dbg(&pci->dev, "get acp device config failed:%d\n", ret); 650 goto skip_pdev_creation; 651 } 652 ret = create_acp63_platform_devs(pci, adata, addr); 653 if (ret < 0) { 654 dev_err(&pci->dev, "ACP platform devices creation failed\n"); 655 goto de_init; 656 } 657 if (adata->acp_rev >= ACP70_PCI_REV) 658 adata->machines = snd_soc_acpi_amd_acp70_sdw_machines; 659 else 660 adata->machines = snd_soc_acpi_amd_acp63_sdw_machines; 661 662 ret = acp63_machine_register(&pci->dev); 663 if (ret) { 664 dev_err(&pci->dev, "ACP machine register failed\n"); 665 goto de_init; 666 } 667 skip_pdev_creation: 668 device_set_wakeup_enable(&pci->dev, true); 669 pm_runtime_set_autosuspend_delay(&pci->dev, ACP_SUSPEND_DELAY_MS); 670 pm_runtime_use_autosuspend(&pci->dev); 671 pm_runtime_put_noidle(&pci->dev); 672 pm_runtime_allow(&pci->dev); 673 return 0; 674 de_init: 675 if (acp_hw_deinit(adata, &pci->dev)) 676 dev_err(&pci->dev, "ACP de-init failed\n"); 677 release_regions: 678 pci_release_regions(pci); 679 disable_pci: 680 pci_disable_device(pci); 681 682 return ret; 683 } 684 685 static int snd_acp_suspend(struct device *dev) 686 { 687 return acp_hw_suspend(dev); 688 } 689 690 static int snd_acp_runtime_resume(struct device *dev) 691 { 692 return acp_hw_runtime_resume(dev); 693 } 694 695 static int snd_acp_resume(struct device *dev) 696 { 697 return acp_hw_resume(dev); 698 } 699 700 static const struct dev_pm_ops acp63_pm_ops = { 701 RUNTIME_PM_OPS(snd_acp_suspend, snd_acp_runtime_resume, NULL) 702 SYSTEM_SLEEP_PM_OPS(snd_acp_suspend, snd_acp_resume) 703 }; 704 705 static void snd_acp63_remove(struct pci_dev *pci) 706 { 707 struct acp63_dev_data *adata; 708 int ret; 709 710 adata = pci_get_drvdata(pci); 711 if (adata->sdw) { 712 amd_sdw_exit(adata); 713 platform_device_unregister(adata->sdw_dma_dev); 714 } 715 if (adata->is_pdm_dev) { 716 platform_device_unregister(adata->pdm_dev); 717 platform_device_unregister(adata->dmic_codec_dev); 718 } 719 if (adata->mach_dev) 720 platform_device_unregister(adata->mach_dev); 721 ret = acp_hw_deinit(adata, &pci->dev); 722 if (ret) 723 dev_err(&pci->dev, "ACP de-init failed\n"); 724 pm_runtime_forbid(&pci->dev); 725 pm_runtime_get_noresume(&pci->dev); 726 pci_release_regions(pci); 727 pci_disable_device(pci); 728 } 729 730 static const struct pci_device_id snd_acp63_ids[] = { 731 { PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_DEVICE_ID), 732 .class = PCI_CLASS_MULTIMEDIA_OTHER << 8, 733 .class_mask = 0xffffff }, 734 { 0, }, 735 }; 736 MODULE_DEVICE_TABLE(pci, snd_acp63_ids); 737 738 static struct pci_driver ps_acp63_driver = { 739 .name = KBUILD_MODNAME, 740 .id_table = snd_acp63_ids, 741 .probe = snd_acp63_probe, 742 .remove = snd_acp63_remove, 743 .driver = { 744 .pm = pm_ptr(&acp63_pm_ops), 745 } 746 }; 747 748 module_pci_driver(ps_acp63_driver); 749 750 MODULE_AUTHOR("Vijendar.Mukunda@amd.com"); 751 MODULE_AUTHOR("Syed.SabaKareem@amd.com"); 752 MODULE_DESCRIPTION("AMD common ACP PCI driver for ACP6.3, ACP7.0 & ACP7.1 platforms"); 753 MODULE_IMPORT_NS("SOUNDWIRE_AMD_INIT"); 754 MODULE_IMPORT_NS("SND_AMD_SOUNDWIRE_ACPI"); 755 MODULE_LICENSE("GPL v2"); 756