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