amd/renoir/acp3x-pdm-dma.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // AMD ALSA SoC PDM Driver
0004 //
0005 //Copyright 2020 Advanced Micro Devices, Inc.
0006
0007 #include <linux/platform_device.h>
0008 #include <linux/module.h>
0009 #include <linux/err.h>
0010 #include <linux/io.h>
0011 #include <linux/pm_runtime.h>
0012 #include <sound/pcm_params.h>
0013 #include <sound/soc.h>
0014 #include <sound/soc-dai.h>
0015
0016 #include "rn_acp3x.h"
0017
0018 #define DRV_NAME "acp_rn_pdm_dma"
0019
0020 static const struct snd_pcm_hardware acp_pdm_hardware_capture = {
0021     .info = SNDRV_PCM_INFO_INTERLEAVED |
0022         SNDRV_PCM_INFO_BLOCK_TRANSFER |
0023         SNDRV_PCM_INFO_MMAP |
0024         SNDRV_PCM_INFO_MMAP_VALID |
0025         SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
0026     .formats = SNDRV_PCM_FMTBIT_S32_LE,
0027     .channels_min = 2,
0028     .channels_max = 2,
0029     .rates = SNDRV_PCM_RATE_48000,
0030     .rate_min = 48000,
0031     .rate_max = 48000,
0032     .buffer_bytes_max = CAPTURE_MAX_NUM_PERIODS * CAPTURE_MAX_PERIOD_SIZE,
0033     .period_bytes_min = CAPTURE_MIN_PERIOD_SIZE,
0034     .period_bytes_max = CAPTURE_MAX_PERIOD_SIZE,
0035     .periods_min = CAPTURE_MIN_NUM_PERIODS,
0036     .periods_max = CAPTURE_MAX_NUM_PERIODS,
0037 };
0038
0039 static irqreturn_t pdm_irq_handler(int irq, void *dev_id)
0040 {
0041     struct pdm_dev_data *rn_pdm_data;
0042     u16 cap_flag;
0043     u32 val;
0044
0045     rn_pdm_data = dev_id;
0046     if (!rn_pdm_data)
0047         return IRQ_NONE;
0048
0049     cap_flag = 0;
0050     val = rn_readl(rn_pdm_data->acp_base + ACP_EXTERNAL_INTR_STAT);
0051     if ((val & BIT(PDM_DMA_STAT)) && rn_pdm_data->capture_stream) {
0052         rn_writel(BIT(PDM_DMA_STAT), rn_pdm_data->acp_base +
0053               ACP_EXTERNAL_INTR_STAT);
0054         snd_pcm_period_elapsed(rn_pdm_data->capture_stream);
0055         cap_flag = 1;
0056     }
0057
0058     if (cap_flag)
0059         return IRQ_HANDLED;
0060     else
0061         return IRQ_NONE;
0062 }
0063
0064 static void init_pdm_ring_buffer(u32 physical_addr,
0065                  u32 buffer_size,
0066                  u32 watermark_size,
0067                  void __iomem *acp_base)
0068 {
0069     rn_writel(physical_addr, acp_base + ACP_WOV_RX_RINGBUFADDR);
0070     rn_writel(buffer_size, acp_base + ACP_WOV_RX_RINGBUFSIZE);
0071     rn_writel(watermark_size, acp_base + ACP_WOV_RX_INTR_WATERMARK_SIZE);
0072     rn_writel(0x01, acp_base + ACPAXI2AXI_ATU_CTRL);
0073 }
0074
0075 static void enable_pdm_clock(void __iomem *acp_base)
0076 {
0077     u32 pdm_clk_enable, pdm_ctrl;
0078
0079     pdm_clk_enable = ACP_PDM_CLK_FREQ_MASK;
0080
0081     rn_writel(pdm_clk_enable, acp_base + ACP_WOV_CLK_CTRL);
0082     pdm_ctrl = rn_readl(acp_base + ACP_WOV_MISC_CTRL);
0083     pdm_ctrl |= ACP_WOV_MISC_CTRL_MASK;
0084     rn_writel(pdm_ctrl, acp_base + ACP_WOV_MISC_CTRL);
0085 }
0086
0087 static void enable_pdm_interrupts(void __iomem *acp_base)
0088 {
0089     u32 ext_int_ctrl;
0090
0091     ext_int_ctrl = rn_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);
0092     ext_int_ctrl |= PDM_DMA_INTR_MASK;
0093     rn_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);
0094 }
0095
0096 static void disable_pdm_interrupts(void __iomem *acp_base)
0097 {
0098     u32 ext_int_ctrl;
0099
0100     ext_int_ctrl = rn_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);
0101     ext_int_ctrl |= ~PDM_DMA_INTR_MASK;
0102     rn_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);
0103 }
0104
0105 static bool check_pdm_dma_status(void __iomem *acp_base)
0106 {
0107     bool pdm_dma_status;
0108     u32 pdm_enable, pdm_dma_enable;
0109
0110     pdm_dma_status = false;
0111     pdm_enable = rn_readl(acp_base + ACP_WOV_PDM_ENABLE);
0112     pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
0113     if ((pdm_enable & ACP_PDM_ENABLE) && (pdm_dma_enable &
0114          ACP_PDM_DMA_EN_STATUS))
0115         pdm_dma_status = true;
0116     return pdm_dma_status;
0117 }
0118
0119 static int start_pdm_dma(void __iomem *acp_base)
0120 {
0121     u32 pdm_enable;
0122     u32 pdm_dma_enable;
0123     int timeout;
0124
0125     pdm_enable = 0x01;
0126     pdm_dma_enable  = 0x01;
0127
0128     enable_pdm_clock(acp_base);
0129     rn_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);
0130     rn_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);
0131     timeout = 0;
0132     while (++timeout < ACP_COUNTER) {
0133         pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
0134         if ((pdm_dma_enable & 0x02) == ACP_PDM_DMA_EN_STATUS)
0135             return 0;
0136         udelay(DELAY_US);
0137     }
0138     return -ETIMEDOUT;
0139 }
0140
0141 static int stop_pdm_dma(void __iomem *acp_base)
0142 {
0143     u32 pdm_enable, pdm_dma_enable;
0144     int timeout;
0145
0146     pdm_enable = rn_readl(acp_base + ACP_WOV_PDM_ENABLE);
0147     pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
0148     if (pdm_dma_enable & 0x01) {
0149         pdm_dma_enable = 0x02;
0150         rn_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);
0151         timeout = 0;
0152         while (++timeout < ACP_COUNTER) {
0153             pdm_dma_enable = rn_readl(acp_base +
0154                           ACP_WOV_PDM_DMA_ENABLE);
0155             if ((pdm_dma_enable & 0x02) == 0x00)
0156                 break;
0157             udelay(DELAY_US);
0158         }
0159         if (timeout == ACP_COUNTER)
0160             return -ETIMEDOUT;
0161     }
0162     if (pdm_enable == ACP_PDM_ENABLE) {
0163         pdm_enable = ACP_PDM_DISABLE;
0164         rn_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);
0165     }
0166     rn_writel(0x01, acp_base + ACP_WOV_PDM_FIFO_FLUSH);
0167     return 0;
0168 }
0169
0170 static void config_acp_dma(struct pdm_stream_instance *rtd, int direction)
0171 {
0172     u16 page_idx;
0173     u32 low, high, val;
0174     dma_addr_t addr;
0175
0176     addr = rtd->dma_addr;
0177     val = 0;
0178
0179     /* Group Enable */
0180     rn_writel(ACP_SRAM_PTE_OFFSET | BIT(31), rtd->acp_base +
0181           ACPAXI2AXI_ATU_BASE_ADDR_GRP_1);
0182     rn_writel(PAGE_SIZE_4K_ENABLE, rtd->acp_base +
0183           ACPAXI2AXI_ATU_PAGE_SIZE_GRP_1);
0184
0185     for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {
0186         /* Load the low address of page int ACP SRAM through SRBM */
0187         low = lower_32_bits(addr);
0188         high = upper_32_bits(addr);
0189
0190         rn_writel(low, rtd->acp_base + ACP_SCRATCH_REG_0 + val);
0191         high |= BIT(31);
0192         rn_writel(high, rtd->acp_base + ACP_SCRATCH_REG_0 + val + 4);
0193         val += 8;
0194         addr += PAGE_SIZE;
0195     }
0196 }
0197
0198 static int acp_pdm_dma_open(struct snd_soc_component *component,
0199                 struct snd_pcm_substream *substream)
0200 {
0201     struct snd_pcm_runtime *runtime;
0202     struct pdm_dev_data *adata;
0203     struct pdm_stream_instance *pdm_data;
0204     int ret;
0205
0206     runtime = substream->runtime;
0207     adata = dev_get_drvdata(component->dev);
0208     pdm_data = kzalloc(sizeof(*pdm_data), GFP_KERNEL);
0209     if (!pdm_data)
0210         return -EINVAL;
0211
0212     if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
0213         runtime->hw = acp_pdm_hardware_capture;
0214
0215     ret = snd_pcm_hw_constraint_integer(runtime,
0216                         SNDRV_PCM_HW_PARAM_PERIODS);
0217     if (ret < 0) {
0218         dev_err(component->dev, "set integer constraint failed\n");
0219         kfree(pdm_data);
0220         return ret;
0221     }
0222
0223     enable_pdm_interrupts(adata->acp_base);
0224
0225     if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
0226         adata->capture_stream = substream;
0227
0228     pdm_data->acp_base = adata->acp_base;
0229     runtime->private_data = pdm_data;
0230     return ret;
0231 }
0232
0233 static int acp_pdm_dma_hw_params(struct snd_soc_component *component,
0234                  struct snd_pcm_substream *substream,
0235                  struct snd_pcm_hw_params *params)
0236 {
0237     struct pdm_stream_instance *rtd;
0238     size_t size, period_bytes;
0239
0240     rtd = substream->runtime->private_data;
0241     if (!rtd)
0242         return -EINVAL;
0243     size = params_buffer_bytes(params);
0244     period_bytes = params_period_bytes(params);
0245     rtd->dma_addr = substream->runtime->dma_addr;
0246     rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);
0247     config_acp_dma(rtd, substream->stream);
0248     init_pdm_ring_buffer(MEM_WINDOW_START, size, period_bytes,
0249                  rtd->acp_base);
0250     return 0;
0251 }
0252
0253 static u64 acp_pdm_get_byte_count(struct pdm_stream_instance *rtd,
0254                   int direction)
0255 {
0256     union acp_pdm_dma_count byte_count;
0257
0258     byte_count.bcount.high =
0259             rn_readl(rtd->acp_base +
0260                  ACP_WOV_RX_LINEARPOSITIONCNTR_HIGH);
0261     byte_count.bcount.low =
0262             rn_readl(rtd->acp_base +
0263                  ACP_WOV_RX_LINEARPOSITIONCNTR_LOW);
0264     return byte_count.bytescount;
0265 }
0266
0267 static snd_pcm_uframes_t acp_pdm_dma_pointer(struct snd_soc_component *comp,
0268                          struct snd_pcm_substream *stream)
0269 {
0270     struct pdm_stream_instance *rtd;
0271     u32 pos, buffersize;
0272     u64 bytescount;
0273
0274     rtd = stream->runtime->private_data;
0275     buffersize = frames_to_bytes(stream->runtime,
0276                      stream->runtime->buffer_size);
0277     bytescount = acp_pdm_get_byte_count(rtd, stream->stream);
0278     if (bytescount > rtd->bytescount)
0279         bytescount -= rtd->bytescount;
0280     pos = do_div(bytescount, buffersize);
0281     return bytes_to_frames(stream->runtime, pos);
0282 }
0283
0284 static int acp_pdm_dma_new(struct snd_soc_component *component,
0285                struct snd_soc_pcm_runtime *rtd)
0286 {
0287     struct device *parent = component->dev->parent;
0288
0289     snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_DEV,
0290                        parent, MIN_BUFFER, MAX_BUFFER);
0291     return 0;
0292 }
0293
0294 static int acp_pdm_dma_close(struct snd_soc_component *component,
0295                  struct snd_pcm_substream *substream)
0296 {
0297     struct pdm_dev_data *adata = dev_get_drvdata(component->dev);
0298
0299     disable_pdm_interrupts(adata->acp_base);
0300     adata->capture_stream = NULL;
0301     return 0;
0302 }
0303
0304 static int acp_pdm_dai_trigger(struct snd_pcm_substream *substream,
0305                    int cmd, struct snd_soc_dai *dai)
0306 {
0307     struct pdm_stream_instance *rtd;
0308     int ret;
0309     bool pdm_status;
0310     unsigned int ch_mask;
0311
0312     rtd = substream->runtime->private_data;
0313     ret = 0;
0314     switch (substream->runtime->channels) {
0315     case TWO_CH:
0316         ch_mask = 0x00;
0317         break;
0318     default:
0319         return -EINVAL;
0320     }
0321     switch (cmd) {
0322     case SNDRV_PCM_TRIGGER_START:
0323     case SNDRV_PCM_TRIGGER_RESUME:
0324     case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
0325         rn_writel(ch_mask, rtd->acp_base + ACP_WOV_PDM_NO_OF_CHANNELS);
0326         rn_writel(PDM_DECIMATION_FACTOR, rtd->acp_base +
0327               ACP_WOV_PDM_DECIMATION_FACTOR);
0328         rtd->bytescount = acp_pdm_get_byte_count(rtd,
0329                              substream->stream);
0330         pdm_status = check_pdm_dma_status(rtd->acp_base);
0331         if (!pdm_status)
0332             ret = start_pdm_dma(rtd->acp_base);
0333         break;
0334     case SNDRV_PCM_TRIGGER_STOP:
0335     case SNDRV_PCM_TRIGGER_SUSPEND:
0336     case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
0337         pdm_status = check_pdm_dma_status(rtd->acp_base);
0338         if (pdm_status)
0339             ret = stop_pdm_dma(rtd->acp_base);
0340         break;
0341     default:
0342         ret = -EINVAL;
0343         break;
0344     }
0345     return ret;
0346 }
0347
0348 static const struct snd_soc_dai_ops acp_pdm_dai_ops = {
0349     .trigger   = acp_pdm_dai_trigger,
0350 };
0351
0352 static struct snd_soc_dai_driver acp_pdm_dai_driver = {
0353     .capture = {
0354         .rates = SNDRV_PCM_RATE_48000,
0355         .formats = SNDRV_PCM_FMTBIT_S24_LE |
0356                SNDRV_PCM_FMTBIT_S32_LE,
0357         .channels_min = 2,
0358         .channels_max = 2,
0359         .rate_min = 48000,
0360         .rate_max = 48000,
0361     },
0362     .ops = &acp_pdm_dai_ops,
0363 };
0364
0365 static const struct snd_soc_component_driver acp_pdm_component = {
0366     .name           = DRV_NAME,
0367     .open           = acp_pdm_dma_open,
0368     .close          = acp_pdm_dma_close,
0369     .hw_params      = acp_pdm_dma_hw_params,
0370     .pointer        = acp_pdm_dma_pointer,
0371     .pcm_construct      = acp_pdm_dma_new,
0372     .legacy_dai_naming  = 1,
0373 };
0374
0375 static int acp_pdm_audio_probe(struct platform_device *pdev)
0376 {
0377     struct resource *res;
0378     struct pdm_dev_data *adata;
0379     unsigned int irqflags;
0380     int status;
0381
0382     if (!pdev->dev.platform_data) {
0383         dev_err(&pdev->dev, "platform_data not retrieved\n");
0384         return -ENODEV;
0385     }
0386     irqflags = *((unsigned int *)(pdev->dev.platform_data));
0387
0388     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0389     if (!res) {
0390         dev_err(&pdev->dev, "IORESOURCE_MEM FAILED\n");
0391         return -ENODEV;
0392     }
0393
0394     adata = devm_kzalloc(&pdev->dev, sizeof(*adata), GFP_KERNEL);
0395     if (!adata)
0396         return -ENOMEM;
0397
0398     adata->acp_base = devm_ioremap(&pdev->dev, res->start,
0399                        resource_size(res));
0400     if (!adata->acp_base)
0401         return -ENOMEM;
0402
0403     status = platform_get_irq(pdev, 0);
0404     if (status < 0)
0405         return status;
0406     adata->pdm_irq = status;
0407
0408     adata->capture_stream = NULL;
0409
0410     dev_set_drvdata(&pdev->dev, adata);
0411     status = devm_snd_soc_register_component(&pdev->dev,
0412                          &acp_pdm_component,
0413                          &acp_pdm_dai_driver, 1);
0414     if (status) {
0415         dev_err(&pdev->dev, "Fail to register acp pdm dai\n");
0416
0417         return -ENODEV;
0418     }
0419     status = devm_request_irq(&pdev->dev, adata->pdm_irq, pdm_irq_handler,
0420                   irqflags, "ACP_PDM_IRQ", adata);
0421     if (status) {
0422         dev_err(&pdev->dev, "ACP PDM IRQ request failed\n");
0423         return -ENODEV;
0424     }
0425     pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS);
0426     pm_runtime_use_autosuspend(&pdev->dev);
0427     pm_runtime_enable(&pdev->dev);
0428     pm_runtime_allow(&pdev->dev);
0429     return 0;
0430 }
0431
0432 static int acp_pdm_audio_remove(struct platform_device *pdev)
0433 {
0434     pm_runtime_disable(&pdev->dev);
0435     return 0;
0436 }
0437
0438 static int acp_pdm_resume(struct device *dev)
0439 {
0440     struct pdm_dev_data *adata;
0441     struct snd_pcm_runtime *runtime;
0442     struct pdm_stream_instance *rtd;
0443     u32 period_bytes, buffer_len;
0444
0445     adata = dev_get_drvdata(dev);
0446     if (adata->capture_stream && adata->capture_stream->runtime) {
0447         runtime = adata->capture_stream->runtime;
0448         rtd = runtime->private_data;
0449         period_bytes = frames_to_bytes(runtime, runtime->period_size);
0450         buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
0451         config_acp_dma(rtd, SNDRV_PCM_STREAM_CAPTURE);
0452         init_pdm_ring_buffer(MEM_WINDOW_START, buffer_len, period_bytes,
0453                      adata->acp_base);
0454     }
0455     enable_pdm_interrupts(adata->acp_base);
0456     return 0;
0457 }
0458
0459 static int acp_pdm_runtime_suspend(struct device *dev)
0460 {
0461     struct pdm_dev_data *adata;
0462
0463     adata = dev_get_drvdata(dev);
0464     disable_pdm_interrupts(adata->acp_base);
0465
0466     return 0;
0467 }
0468
0469 static int acp_pdm_runtime_resume(struct device *dev)
0470 {
0471     struct pdm_dev_data *adata;
0472
0473     adata = dev_get_drvdata(dev);
0474     enable_pdm_interrupts(adata->acp_base);
0475     return 0;
0476 }
0477
0478 static const struct dev_pm_ops acp_pdm_pm_ops = {
0479     .runtime_suspend = acp_pdm_runtime_suspend,
0480     .runtime_resume = acp_pdm_runtime_resume,
0481     .resume = acp_pdm_resume,
0482 };
0483
0484 static struct platform_driver acp_pdm_dma_driver = {
0485     .probe = acp_pdm_audio_probe,
0486     .remove = acp_pdm_audio_remove,
0487     .driver = {
0488         .name = "acp_rn_pdm_dma",
0489         .pm = &acp_pdm_pm_ops,
0490     },
0491 };
0492
0493 module_platform_driver(acp_pdm_dma_driver);
0494
0495 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
0496 MODULE_DESCRIPTION("AMD ACP3x Renior PDM Driver");
0497 MODULE_LICENSE("GPL v2");
0498 MODULE_ALIAS("platform:" DRV_NAME);