sound/soc/amd/ps/pci-ps.c

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