tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

ASoC: amd: acp: Add new interrupt handle callbacks in acp_common_hw_ops

Add new interrupt handle callbacks in acp_common_hw_ops.
Refactor and move interrupt handler registration form platform
driver to pci driver.

Signed-off-by: Venkata Prasad Potturu <venkataprasad.potturu@amd.com>
Link: https://patch.msgid.link/20250310183201.11979-7-venkataprasad.potturu@amd.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Venkata Prasad Potturu and committed by
Mark Brown aaf7a668 6e60db74

+184 -91
+2 -2
sound/soc/amd/acp/acp-i2s.c
··· 617 617 writel(acp_fifo_addr, adata->acp_base + reg_fifo_addr); 618 618 writel(FIFO_SIZE, adata->acp_base + reg_fifo_size); 619 619 620 - ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 620 + ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 621 621 ext_int_ctrl |= BIT(I2S_RX_THRESHOLD(rsrc->offset)) | 622 622 BIT(BT_RX_THRESHOLD(rsrc->offset)) | 623 623 BIT(I2S_TX_THRESHOLD(rsrc->offset)) | ··· 625 625 BIT(HS_RX_THRESHOLD(rsrc->offset)) | 626 626 BIT(HS_TX_THRESHOLD(rsrc->offset)); 627 627 628 - writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 628 + writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 629 629 630 630 return 0; 631 631 }
+67 -12
sound/soc/amd/acp/acp-legacy-common.c
··· 27 27 /* ACP hardware initilizations */ 28 28 .acp_init = acp_init, 29 29 .acp_deinit = acp_deinit, 30 + 31 + /* ACP Interrupts*/ 32 + .irq = acp_irq_handler, 33 + .en_interrupts = acp_enable_interrupts, 34 + .dis_interrupts = acp_disable_interrupts, 30 35 }; 31 36 EXPORT_SYMBOL_NS_GPL(acp_common_hw_ops, "SND_SOC_ACP_COMMON"); 32 - void acp_enable_interrupts(struct acp_dev_data *adata) 37 + 38 + irqreturn_t acp_irq_handler(int irq, void *data) 33 39 { 40 + struct acp_chip_info *chip = data; 41 + struct acp_dev_data *adata = chip->adata; 34 42 struct acp_resource *rsrc = adata->rsrc; 43 + struct acp_stream *stream; 44 + u16 i2s_flag = 0; 45 + u32 ext_intr_stat, ext_intr_stat1; 46 + 47 + if (adata->rsrc->no_of_ctrls == 2) 48 + ext_intr_stat1 = readl(ACP_EXTERNAL_INTR_STAT(chip, (rsrc->irqp_used - 1))); 49 + 50 + ext_intr_stat = readl(ACP_EXTERNAL_INTR_STAT(chip, rsrc->irqp_used)); 51 + 52 + spin_lock(&adata->acp_lock); 53 + list_for_each_entry(stream, &adata->stream_list, list) { 54 + if (ext_intr_stat & stream->irq_bit) { 55 + writel(stream->irq_bit, 56 + ACP_EXTERNAL_INTR_STAT(chip, rsrc->irqp_used)); 57 + snd_pcm_period_elapsed(stream->substream); 58 + i2s_flag = 1; 59 + } 60 + if (adata->rsrc->no_of_ctrls == 2) { 61 + if (ext_intr_stat1 & stream->irq_bit) { 62 + writel(stream->irq_bit, ACP_EXTERNAL_INTR_STAT(chip, 63 + (rsrc->irqp_used - 1))); 64 + snd_pcm_period_elapsed(stream->substream); 65 + i2s_flag = 1; 66 + } 67 + } 68 + } 69 + spin_unlock(&adata->acp_lock); 70 + if (i2s_flag) 71 + return IRQ_HANDLED; 72 + 73 + return IRQ_NONE; 74 + } 75 + 76 + int acp_enable_interrupts(struct acp_chip_info *chip) 77 + { 78 + struct acp_resource *rsrc; 35 79 u32 ext_intr_ctrl; 36 80 37 - writel(0x01, ACP_EXTERNAL_INTR_ENB(adata)); 38 - ext_intr_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 81 + rsrc = chip->rsrc; 82 + writel(0x01, ACP_EXTERNAL_INTR_ENB(chip)); 83 + ext_intr_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 39 84 ext_intr_ctrl |= ACP_ERROR_MASK; 40 - writel(ext_intr_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 85 + writel(ext_intr_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 86 + 87 + return 0; 41 88 } 42 89 EXPORT_SYMBOL_NS_GPL(acp_enable_interrupts, "SND_SOC_ACP_COMMON"); 43 90 44 - void acp_disable_interrupts(struct acp_dev_data *adata) 91 + int acp_disable_interrupts(struct acp_chip_info *chip) 45 92 { 46 - struct acp_resource *rsrc = adata->rsrc; 93 + struct acp_resource *rsrc; 47 94 48 - writel(ACP_EXT_INTR_STAT_CLEAR_MASK, ACP_EXTERNAL_INTR_STAT(adata, rsrc->irqp_used)); 49 - writel(0x00, ACP_EXTERNAL_INTR_ENB(adata)); 95 + rsrc = chip->rsrc; 96 + writel(ACP_EXT_INTR_STAT_CLEAR_MASK, ACP_EXTERNAL_INTR_STAT(chip, rsrc->irqp_used)); 97 + writel(0x00, ACP_EXTERNAL_INTR_ENB(chip)); 98 + 99 + return 0; 50 100 } 51 101 EXPORT_SYMBOL_NS_GPL(acp_disable_interrupts, "SND_SOC_ACP_COMMON"); 52 102 ··· 140 90 struct acp_dev_data *adata) 141 91 { 142 92 struct snd_soc_dai *dai; 93 + struct device *dev; 94 + struct acp_chip_info *chip; 143 95 struct snd_soc_pcm_runtime *soc_runtime; 144 96 u32 ext_int_ctrl; 145 97 146 98 soc_runtime = snd_soc_substream_to_rtd(substream); 147 99 dai = snd_soc_rtd_to_cpu(soc_runtime, 0); 100 + dev = dai->component->dev; 101 + chip = dev_get_platdata(dev); 148 102 /* Programming channel mask and sampling rate */ 149 103 writel(adata->ch_mask, adata->acp_base + ACP_WOV_PDM_NO_OF_CHANNELS); 150 104 writel(PDM_DEC_64, adata->acp_base + ACP_WOV_PDM_DECIMATION_FACTOR); 151 105 152 106 /* Enabling ACP Pdm interuppts */ 153 - ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, 0)); 107 + ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, 0)); 154 108 ext_int_ctrl |= PDM_DMA_INTR_MASK; 155 - writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, 0)); 109 + writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, 0)); 156 110 set_acp_pdm_clk(substream, dai); 157 111 } 158 112 EXPORT_SYMBOL_NS_GPL(restore_acp_pdm_params, "SND_SOC_ACP_COMMON"); ··· 167 113 struct device *dev = dai->component->dev; 168 114 struct acp_dev_data *adata = dev_get_drvdata(dev); 169 115 struct acp_resource *rsrc = adata->rsrc; 116 + struct acp_chip_info *chip = dev_get_platdata(dev); 170 117 struct acp_stream *stream = substream->runtime->private_data; 171 118 u32 reg_dma_size, reg_fifo_size, reg_fifo_addr; 172 119 u32 phy_addr, acp_fifo_addr, ext_int_ctrl; ··· 240 185 writel(acp_fifo_addr, adata->acp_base + reg_fifo_addr); 241 186 writel(FIFO_SIZE, adata->acp_base + reg_fifo_size); 242 187 243 - ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 188 + ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 244 189 ext_int_ctrl |= BIT(I2S_RX_THRESHOLD(rsrc->offset)) | 245 190 BIT(BT_RX_THRESHOLD(rsrc->offset)) | 246 191 BIT(I2S_TX_THRESHOLD(rsrc->offset)) | ··· 248 193 BIT(HS_RX_THRESHOLD(rsrc->offset)) | 249 194 BIT(HS_TX_THRESHOLD(rsrc->offset)); 250 195 251 - writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, rsrc->irqp_used)); 196 + writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, rsrc->irqp_used)); 252 197 return 0; 253 198 } 254 199
+21 -8
sound/soc/amd/acp/acp-pci.c
··· 26 26 #define ACP3x_REG_START 0x1240000 27 27 #define ACP3x_REG_END 0x125C000 28 28 29 + static irqreturn_t irq_handler(int irq, void *data) 30 + { 31 + struct acp_chip_info *chip = data; 32 + 33 + if (chip && chip->acp_hw_ops && chip->acp_hw_ops->irq) 34 + return chip->acp_hw_ops->irq(irq, chip); 35 + 36 + return IRQ_NONE; 37 + } 29 38 static void acp_fill_platform_dev_info(struct platform_device_info *pdevinfo, 30 39 struct device *parent, 31 40 struct fwnode_handle *fw_node, ··· 175 166 if (ret) 176 167 goto release_regions; 177 168 169 + ret = devm_request_irq(dev, pci->irq, irq_handler, 170 + IRQF_SHARED, "ACP_I2S_IRQ", chip); 171 + if (ret) { 172 + dev_err(&pci->dev, "ACP I2S IRQ request failed %d\n", ret); 173 + return ret; 174 + } 175 + 178 176 check_acp_config(pci, chip); 179 177 if (!chip->is_pdm_dev && !chip->is_i2s_config) 180 178 goto skip_pdev_creation; ··· 229 213 static int __maybe_unused snd_acp_resume(struct device *dev) 230 214 { 231 215 struct acp_chip_info *chip; 232 - struct acp_dev_data *adata; 233 - struct device child; 234 216 int ret; 235 217 236 218 chip = dev_get_drvdata(dev); 237 219 ret = acp_hw_init(chip); 238 220 if (ret) 239 221 dev_err(dev, "ACP init failed\n"); 240 - if (chip->chip_pdev) { 241 - child = chip->chip_pdev->dev; 242 - adata = dev_get_drvdata(&child); 243 - if (adata) 244 - acp_enable_interrupts(adata); 245 - } 222 + 223 + ret = acp_hw_en_interrupts(chip); 224 + if (ret) 225 + dev_err(dev, "ACP en-interrupts failed\n"); 226 + 246 227 return ret; 247 228 } 248 229
+6 -6
sound/soc/amd/acp/acp-pdm.c
··· 145 145 { 146 146 struct acp_stream *stream = substream->runtime->private_data; 147 147 struct device *dev = dai->component->dev; 148 - struct acp_dev_data *adata = dev_get_drvdata(dev); 148 + struct acp_chip_info *chip = dev_get_platdata(dev); 149 149 u32 ext_int_ctrl; 150 150 151 151 stream->dai_id = DMIC_INSTANCE; ··· 154 154 stream->reg_offset = ACP_REGION2_OFFSET; 155 155 156 156 /* Enable DMIC Interrupts */ 157 - ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, 0)); 157 + ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, 0)); 158 158 ext_int_ctrl |= PDM_DMA_INTR_MASK; 159 - writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, 0)); 159 + writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, 0)); 160 160 161 161 return 0; 162 162 } ··· 165 165 struct snd_soc_dai *dai) 166 166 { 167 167 struct device *dev = dai->component->dev; 168 - struct acp_dev_data *adata = dev_get_drvdata(dev); 168 + struct acp_chip_info *chip = dev_get_platdata(dev); 169 169 u32 ext_int_ctrl; 170 170 171 171 /* Disable DMIC interrupts */ 172 - ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(adata, 0)); 172 + ext_int_ctrl = readl(ACP_EXTERNAL_INTR_CNTL(chip, 0)); 173 173 ext_int_ctrl &= ~PDM_DMA_INTR_MASK; 174 - writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(adata, 0)); 174 + writel(ext_int_ctrl, ACP_EXTERNAL_INTR_CNTL(chip, 0)); 175 175 } 176 176 177 177 const struct snd_soc_dai_ops acp_dmic_dai_ops = {
+7 -43
sound/soc/amd/acp/acp-platform.c
··· 107 107 .periods_max = CAPTURE_MAX_NUM_PERIODS, 108 108 }; 109 109 110 - static irqreturn_t i2s_irq_handler(int irq, void *data) 111 - { 112 - struct acp_dev_data *adata = data; 113 - struct acp_resource *rsrc = adata->rsrc; 114 - struct acp_stream *stream; 115 - u16 i2s_flag = 0; 116 - u32 ext_intr_stat, ext_intr_stat1; 117 - 118 - if (adata->rsrc->no_of_ctrls == 2) 119 - ext_intr_stat1 = readl(ACP_EXTERNAL_INTR_STAT(adata, (rsrc->irqp_used - 1))); 120 - 121 - ext_intr_stat = readl(ACP_EXTERNAL_INTR_STAT(adata, rsrc->irqp_used)); 122 - 123 - spin_lock(&adata->acp_lock); 124 - list_for_each_entry(stream, &adata->stream_list, list) { 125 - if (ext_intr_stat & stream->irq_bit) { 126 - writel(stream->irq_bit, 127 - ACP_EXTERNAL_INTR_STAT(adata, rsrc->irqp_used)); 128 - snd_pcm_period_elapsed(stream->substream); 129 - i2s_flag = 1; 130 - } 131 - if (adata->rsrc->no_of_ctrls == 2) { 132 - if (ext_intr_stat1 & stream->irq_bit) { 133 - writel(stream->irq_bit, ACP_EXTERNAL_INTR_STAT(adata, 134 - (rsrc->irqp_used - 1))); 135 - snd_pcm_period_elapsed(stream->substream); 136 - i2s_flag = 1; 137 - } 138 - } 139 - } 140 - spin_unlock(&adata->acp_lock); 141 - if (i2s_flag) 142 - return IRQ_HANDLED; 143 - 144 - return IRQ_NONE; 145 - } 146 - 147 110 void config_pte_for_stream(struct acp_dev_data *adata, struct acp_stream *stream) 148 111 { 149 112 struct acp_resource *rsrc = adata->rsrc; ··· 241 278 } 242 279 runtime->private_data = stream; 243 280 244 - writel(1, ACP_EXTERNAL_INTR_ENB(adata)); 281 + writel(1, ACP_EXTERNAL_INTR_ENB(chip)); 245 282 246 283 spin_lock_irq(&adata->acp_lock); 247 284 list_add_tail(&stream->list, &adata->stream_list); ··· 326 363 int acp_platform_register(struct device *dev) 327 364 { 328 365 struct acp_dev_data *adata = dev_get_drvdata(dev); 366 + struct acp_chip_info *chip; 329 367 struct snd_soc_dai_driver; 330 368 unsigned int status; 331 369 332 - status = devm_request_irq(dev, adata->i2s_irq, i2s_irq_handler, 333 - IRQF_SHARED, "ACP_I2S_IRQ", adata); 334 - if (status) { 335 - dev_err(dev, "ACP I2S IRQ request failed\n"); 336 - return status; 370 + chip = dev_get_platdata(dev); 371 + if (!chip || !chip->base) { 372 + dev_err(dev, "ACP chip data is NULL\n"); 373 + return -ENODEV; 337 374 } 338 375 376 + chip->adata = adata; 339 377 status = devm_snd_soc_register_component(dev, &acp_pcm_component, 340 378 adata->dai_driver, 341 379 adata->num_dai);
+12 -3
sound/soc/amd/acp/acp-rembrandt.c
··· 192 192 return -ENODEV; 193 193 } 194 194 195 + chip->rsrc = &rsrc; 195 196 adata->i2s_irq = res->start; 196 197 adata->dev = dev; 197 198 adata->dai_driver = acp_rmb_dai; ··· 209 208 if (ret) 210 209 return ret; 211 210 } 212 - acp_enable_interrupts(adata); 211 + ret = acp_hw_en_interrupts(chip); 212 + if (ret) { 213 + dev_err(dev, "ACP en-interrupts failed\n"); 214 + return ret; 215 + } 213 216 acp_platform_register(dev); 214 217 pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS); 215 218 pm_runtime_use_autosuspend(&pdev->dev); ··· 226 221 static void rembrandt_audio_remove(struct platform_device *pdev) 227 222 { 228 223 struct device *dev = &pdev->dev; 229 - struct acp_dev_data *adata = dev_get_drvdata(dev); 224 + struct acp_chip_info *chip = dev_get_platdata(dev); 225 + int ret; 230 226 231 - acp_disable_interrupts(adata); 227 + ret = acp_hw_dis_interrupts(chip); 228 + if (ret) 229 + dev_err(dev, "ACP dis-interrupts failed\n"); 230 + 232 231 acp_platform_unregister(dev); 233 232 pm_runtime_disable(&pdev->dev); 234 233 }
+12 -3
sound/soc/amd/acp/acp-renoir.c
··· 142 142 return ret; 143 143 adata->i2s_irq = ret; 144 144 145 + chip->rsrc = &rsrc; 145 146 adata->dev = dev; 146 147 adata->dai_driver = acp_renoir_dai; 147 148 adata->num_dai = ARRAY_SIZE(acp_renoir_dai); ··· 151 150 adata->flag = chip->flag; 152 151 153 152 dev_set_drvdata(dev, adata); 154 - acp_enable_interrupts(adata); 153 + ret = acp_hw_en_interrupts(chip); 154 + if (ret) { 155 + dev_err(dev, "ACP en-interrupts failed\n"); 156 + return ret; 157 + } 155 158 acp_platform_register(dev); 156 159 157 160 pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS); ··· 169 164 static void renoir_audio_remove(struct platform_device *pdev) 170 165 { 171 166 struct device *dev = &pdev->dev; 172 - struct acp_dev_data *adata = dev_get_drvdata(dev); 167 + struct acp_chip_info *chip = dev_get_platdata(dev); 168 + int ret; 173 169 174 - acp_disable_interrupts(adata); 170 + ret = acp_hw_dis_interrupts(chip); 171 + if (ret) 172 + dev_err(dev, "ACP dis-interrupts failed\n"); 173 + 175 174 acp_platform_unregister(dev); 176 175 } 177 176
+12 -3
sound/soc/amd/acp/acp63.c
··· 243 243 return -ENODEV; 244 244 } 245 245 246 + chip->rsrc = &rsrc; 246 247 adata->i2s_irq = res->start; 247 248 adata->dev = dev; 248 249 adata->dai_driver = acp63_dai; ··· 259 258 if (ret) 260 259 return ret; 261 260 } 262 - acp_enable_interrupts(adata); 261 + ret = acp_hw_en_interrupts(chip); 262 + if (ret) { 263 + dev_err(dev, "ACP en-interrupts failed\n"); 264 + return ret; 265 + } 263 266 acp_platform_register(dev); 264 267 pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS); 265 268 pm_runtime_use_autosuspend(&pdev->dev); ··· 276 271 static void acp63_audio_remove(struct platform_device *pdev) 277 272 { 278 273 struct device *dev = &pdev->dev; 279 - struct acp_dev_data *adata = dev_get_drvdata(dev); 274 + struct acp_chip_info *chip = dev_get_platdata(dev); 275 + int ret; 280 276 281 - acp_disable_interrupts(adata); 277 + ret = acp_hw_dis_interrupts(chip); 278 + if (ret) 279 + dev_err(dev, "ACP dis-interrupts failed\n"); 280 + 282 281 acp_platform_unregister(dev); 283 282 pm_runtime_disable(&pdev->dev); 284 283 }
+12 -3
sound/soc/amd/acp/acp70.c
··· 174 174 return -ENODEV; 175 175 } 176 176 177 + chip->rsrc = &rsrc; 177 178 adata->i2s_irq = res->start; 178 179 adata->dev = dev; 179 180 adata->dai_driver = acp70_dai; ··· 191 190 dev_err(&pdev->dev, "Failed to set I2S master clock as 196.608MHz\n"); 192 191 return ret; 193 192 } 194 - acp_enable_interrupts(adata); 193 + ret = acp_hw_en_interrupts(chip); 194 + if (ret) { 195 + dev_err(dev, "ACP en-interrupts failed\n"); 196 + return ret; 197 + } 195 198 acp_platform_register(dev); 196 199 pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS); 197 200 pm_runtime_use_autosuspend(&pdev->dev); ··· 208 203 static void acp_acp70_audio_remove(struct platform_device *pdev) 209 204 { 210 205 struct device *dev = &pdev->dev; 211 - struct acp_dev_data *adata = dev_get_drvdata(dev); 206 + struct acp_chip_info *chip = dev_get_platdata(dev); 207 + int ret; 212 208 213 - acp_disable_interrupts(adata); 209 + ret = acp_hw_dis_interrupts(chip); 210 + if (ret) 211 + dev_err(dev, "ACP dis-interrupts failed\n"); 212 + 214 213 acp_platform_unregister(dev); 215 214 pm_runtime_disable(&pdev->dev); 216 215 }
+27 -2
sound/soc/amd/acp/amd.h
··· 147 147 struct snd_acp_hw_ops *acp_hw_ops; 148 148 int (*acp_hw_ops_init)(struct acp_chip_info *chip); 149 149 struct platform_device *chip_pdev; 150 + struct acp_resource *rsrc; /* Platform specific resources*/ 150 151 struct platform_device *dmic_codec_dev; 151 152 struct platform_device *acp_plat_dev; 152 153 struct platform_device *mach_dev; 153 154 struct snd_soc_acpi_mach *machines; 155 + struct acp_dev_data *adata; 154 156 u32 addr; 155 157 unsigned int flag; /* Distinguish b/w Legacy or Only PDM */ 156 158 bool is_pdm_dev; /* flag set to true when ACP PDM controller exists */ ··· 217 215 * struct snd_acp_hw_ops - ACP PCI driver platform specific ops 218 216 * @acp_init: ACP initialization 219 217 * @acp_deinit: ACP de-initialization 218 + * @irq: ACP irq handler 219 + * @en_interrupts: ACP enable interrupts 220 + * @dis_interrupts: ACP disable interrupts 220 221 */ 221 222 struct snd_acp_hw_ops { 222 223 /* ACP hardware initilizations */ 223 224 int (*acp_init)(struct acp_chip_info *chip); 224 225 int (*acp_deinit)(struct acp_chip_info *chip); 226 + 227 + /* ACP Interrupts*/ 228 + irqreturn_t (*irq)(int irq, void *data); 229 + int (*en_interrupts)(struct acp_chip_info *chip); 230 + int (*dis_interrupts)(struct acp_chip_info *chip); 225 231 }; 226 232 227 233 enum acp_config { ··· 342 332 343 333 int acp_init(struct acp_chip_info *chip); 344 334 int acp_deinit(struct acp_chip_info *chip); 345 - void acp_enable_interrupts(struct acp_dev_data *adata); 346 - void acp_disable_interrupts(struct acp_dev_data *adata); 335 + int acp_enable_interrupts(struct acp_chip_info *chip); 336 + int acp_disable_interrupts(struct acp_chip_info *chip); 337 + irqreturn_t acp_irq_handler(int irq, void *data); 347 338 348 339 extern struct snd_acp_hw_ops acp31_common_hw_ops; 349 340 extern struct snd_acp_hw_ops acp6x_common_hw_ops; ··· 378 367 { 379 368 if (chip && chip->acp_hw_ops && chip->acp_hw_ops->acp_deinit) 380 369 return chip->acp_hw_ops->acp_deinit(chip); 370 + return -EOPNOTSUPP; 371 + } 372 + 373 + static inline int acp_hw_en_interrupts(struct acp_chip_info *chip) 374 + { 375 + if (chip && chip->acp_hw_ops && chip->acp_hw_ops->en_interrupts) 376 + return chip->acp_hw_ops->en_interrupts(chip); 377 + return -EOPNOTSUPP; 378 + } 379 + 380 + static inline int acp_hw_dis_interrupts(struct acp_chip_info *chip) 381 + { 382 + if (chip && chip->acp_hw_ops && chip->acp_hw_ops->dis_interrupts) 383 + chip->acp_hw_ops->dis_interrupts(chip); 381 384 return -EOPNOTSUPP; 382 385 } 383 386
+6 -6
sound/soc/amd/acp/chip_offset_byte.h
··· 29 29 #define ACP_PIN_CONFIG 0x1440 30 30 #define ACP3X_PIN_CONFIG 0x1400 31 31 32 - #define ACP_EXTERNAL_INTR_REG_ADDR(adata, offset, ctrl) \ 33 - (adata->acp_base + adata->rsrc->irq_reg_offset + offset + (ctrl * 0x04)) 32 + #define ACP_EXTERNAL_INTR_REG_ADDR(chip, offset, ctrl) \ 33 + (chip->base + chip->rsrc->irq_reg_offset + offset + (ctrl * 0x04)) 34 34 35 - #define ACP_EXTERNAL_INTR_ENB(adata) ACP_EXTERNAL_INTR_REG_ADDR(adata, 0x0, 0x0) 36 - #define ACP_EXTERNAL_INTR_CNTL(adata, ctrl) ACP_EXTERNAL_INTR_REG_ADDR(adata, 0x4, ctrl) 37 - #define ACP_EXTERNAL_INTR_STAT(adata, ctrl) ACP_EXTERNAL_INTR_REG_ADDR(adata, \ 38 - (0x4 + (adata->rsrc->no_of_ctrls * 0x04)), ctrl) 35 + #define ACP_EXTERNAL_INTR_ENB(chip) ACP_EXTERNAL_INTR_REG_ADDR(chip, 0x0, 0x0) 36 + #define ACP_EXTERNAL_INTR_CNTL(chip, ctrl) ACP_EXTERNAL_INTR_REG_ADDR(chip, 0x4, ctrl) 37 + #define ACP_EXTERNAL_INTR_STAT(chip, ctrl) ACP_EXTERNAL_INTR_REG_ADDR(chip, \ 38 + (0x4 + (chip->rsrc->no_of_ctrls * 0x04)), ctrl) 39 39 40 40 /* Registers from ACP_AUDIO_BUFFERS block */ 41 41