sound/soc/amd/acp/acp-legacy-common.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
   2 //
   3 // This file is provided under a dual BSD/GPLv2 license. When using or
   4 // redistributing this file, you may do so under either license.
   5 //
   6 // Copyright(c) 2023 Advanced Micro Devices, Inc.
   7 //
   8 // Authors: Syed Saba Kareem <Syed.SabaKareem@amd.com>
   9 //
  10
  11 /*
  12  * Common file to be used by amd platforms
  13  */
  14
  15 #include "amd.h"
  16 #include <linux/pci.h>
  17 #include <linux/export.h>
  18
  19 void acp_enable_interrupts(struct acp_dev_data *adata)
  20 {
  21         struct acp_resource *rsrc = adata->rsrc;
  22         u32 ext_intr_ctrl;
  23
  24         writel(0x01, ACP_EXTERNAL_INTR_ENB(adata));
  25         ext_intr_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used));
  26         ext_intr_ctrl |= ACP_ERROR_MASK;
  27         writel(ext_intr_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used));
  28 }
  29 EXPORT_SYMBOL_NS_GPL(acp_enable_interrupts, SND_SOC_ACP_COMMON);
  30
  31 void acp_disable_interrupts(struct acp_dev_data *adata)
  32 {
  33         struct acp_resource *rsrc = adata->rsrc;
  34
  35         writel(ACP_EXT_INTR_STAT_CLEAR_MASK, ACP_EXTERNAL_INTR_STAT(adata, rsrc->irqp_used));
  36         writel(0x00, ACP_EXTERNAL_INTR_ENB(adata));
  37 }
  38 EXPORT_SYMBOL_NS_GPL(acp_disable_interrupts, SND_SOC_ACP_COMMON);
  39
  40 static int acp_power_on(struct acp_chip_info *chip)
  41 {
  42         u32 val, acp_pgfsm_stat_reg, acp_pgfsm_ctrl_reg;
  43         void __iomem *base;
  44
  45         base = chip->base;
  46         switch (chip->acp_rev) {
  47         case ACP3X_DEV:
  48                 acp_pgfsm_stat_reg = ACP_PGFSM_STATUS;
  49                 acp_pgfsm_ctrl_reg = ACP_PGFSM_CONTROL;
  50                 break;
  51         case ACP6X_DEV:
  52                 acp_pgfsm_stat_reg = ACP6X_PGFSM_STATUS;
  53                 acp_pgfsm_ctrl_reg = ACP6X_PGFSM_CONTROL;
  54                 break;
  55         default:
  56                 return -EINVAL;
  57         }
  58
  59         val = readl(base + acp_pgfsm_stat_reg);
  60         if (val == ACP_POWERED_ON)
  61                 return 0;
  62
  63         if ((val & ACP_PGFSM_STATUS_MASK) != ACP_POWER_ON_IN_PROGRESS)
  64                 writel(ACP_PGFSM_CNTL_POWER_ON_MASK, base + acp_pgfsm_ctrl_reg);
  65
  66         return readl_poll_timeout(base + acp_pgfsm_stat_reg, val,
  67                                   !val, DELAY_US, ACP_TIMEOUT);
  68 }
  69
  70 static int acp_reset(void __iomem *base)
  71 {
  72         u32 val;
  73         int ret;
  74
  75         writel(1, base + ACP_SOFT_RESET);
  76         ret = readl_poll_timeout(base + ACP_SOFT_RESET, val, val & ACP_SOFT_RST_DONE_MASK,
  77                                  DELAY_US, ACP_TIMEOUT);
  78         if (ret)
  79                 return ret;
  80
  81         writel(0, base + ACP_SOFT_RESET);
  82         return readl_poll_timeout(base + ACP_SOFT_RESET, val, !val, DELAY_US, ACP_TIMEOUT);
  83 }
  84
  85 int acp_init(struct acp_chip_info *chip)
  86 {
  87         int ret;
  88
  89         /* power on */
  90         ret = acp_power_on(chip);
  91         if (ret) {
  92                 pr_err("ACP power on failed\n");
  93                 return ret;
  94         }
  95         writel(0x01, chip->base + ACP_CONTROL);
  96
  97         /* Reset */
  98         ret = acp_reset(chip->base);
  99         if (ret) {
 100                 pr_err("ACP reset failed\n");
 101                 return ret;
 102         }
 103         return 0;
 104 }
 105 EXPORT_SYMBOL_NS_GPL(acp_init, SND_SOC_ACP_COMMON);
 106
 107 int acp_deinit(void __iomem *base)
 108 {
 109         int ret;
 110
 111         /* Reset */
 112         ret = acp_reset(base);
 113         if (ret)
 114                 return ret;
 115
 116         writel(0, base + ACP_CONTROL);
 117         return 0;
 118 }
 119 EXPORT_SYMBOL_NS_GPL(acp_deinit, SND_SOC_ACP_COMMON);
 120
 121 int smn_write(struct pci_dev *dev, u32 smn_addr, u32 data)
 122 {
 123         pci_write_config_dword(dev, 0x60, smn_addr);
 124         pci_write_config_dword(dev, 0x64, data);
 125         return 0;
 126 }
 127 EXPORT_SYMBOL_NS_GPL(smn_write, SND_SOC_ACP_COMMON);
 128
 129 int smn_read(struct pci_dev *dev, u32 smn_addr)
 130 {
 131         u32 data;
 132
 133         pci_write_config_dword(dev, 0x60, smn_addr);
 134         pci_read_config_dword(dev, 0x64, &data);
 135         return data;
 136 }
 137 EXPORT_SYMBOL_NS_GPL(smn_read, SND_SOC_ACP_COMMON);
 138
 139 MODULE_LICENSE("Dual BSD/GPL");