sound/soc/amd/renoir/acp3x-pdm-dma.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // AMD ALSA SoC PDM Driver
   4 //
   5 //Copyright 2020 Advanced Micro Devices, Inc.
   6
   7 #include <linux/platform_device.h>
   8 #include <linux/module.h>
   9 #include <linux/err.h>
  10 #include <linux/io.h>
  11 #include <linux/pm_runtime.h>
  12 #include <sound/pcm_params.h>
  13 #include <sound/soc.h>
  14 #include <sound/soc-dai.h>
  15
  16 #include "rn_acp3x.h"
  17
  18 #define DRV_NAME "acp_rn_pdm_dma"
  19
  20 static const struct snd_pcm_hardware acp_pdm_hardware_capture = {
  21         .info = SNDRV_PCM_INFO_INTERLEAVED |
  22                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  23                 SNDRV_PCM_INFO_MMAP |
  24                 SNDRV_PCM_INFO_MMAP_VALID |
  25                 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
  26         .formats = SNDRV_PCM_FMTBIT_S32_LE,
  27         .channels_min = 2,
  28         .channels_max = 2,
  29         .rates = SNDRV_PCM_RATE_48000,
  30         .rate_min = 48000,
  31         .rate_max = 48000,
  32         .buffer_bytes_max = CAPTURE_MAX_NUM_PERIODS * CAPTURE_MAX_PERIOD_SIZE,
  33         .period_bytes_min = CAPTURE_MIN_PERIOD_SIZE,
  34         .period_bytes_max = CAPTURE_MAX_PERIOD_SIZE,
  35         .periods_min = CAPTURE_MIN_NUM_PERIODS,
  36         .periods_max = CAPTURE_MAX_NUM_PERIODS,
  37 };
  38
  39 static irqreturn_t pdm_irq_handler(int irq, void *dev_id)
  40 {
  41         struct pdm_dev_data *rn_pdm_data;
  42         u16 cap_flag;
  43         u32 val;
  44
  45         rn_pdm_data = dev_id;
  46         if (!rn_pdm_data)
  47                 return IRQ_NONE;
  48
  49         cap_flag = 0;
  50         val = rn_readl(rn_pdm_data->acp_base + ACP_EXTERNAL_INTR_STAT);
  51         if ((val & BIT(PDM_DMA_STAT)) && rn_pdm_data->capture_stream) {
  52                 rn_writel(BIT(PDM_DMA_STAT), rn_pdm_data->acp_base +
  53                           ACP_EXTERNAL_INTR_STAT);
  54                 snd_pcm_period_elapsed(rn_pdm_data->capture_stream);
  55                 cap_flag = 1;
  56         }
  57
  58         if (cap_flag)
  59                 return IRQ_HANDLED;
  60         else
  61                 return IRQ_NONE;
  62 }
  63
  64 static void init_pdm_ring_buffer(u32 physical_addr,
  65                                  u32 buffer_size,
  66                                  u32 watermark_size,
  67                                  void __iomem *acp_base)
  68 {
  69         rn_writel(physical_addr, acp_base + ACP_WOV_RX_RINGBUFADDR);
  70         rn_writel(buffer_size, acp_base + ACP_WOV_RX_RINGBUFSIZE);
  71         rn_writel(watermark_size, acp_base + ACP_WOV_RX_INTR_WATERMARK_SIZE);
  72         rn_writel(0x01, acp_base + ACPAXI2AXI_ATU_CTRL);
  73 }
  74
  75 static void enable_pdm_clock(void __iomem *acp_base)
  76 {
  77         u32 pdm_clk_enable, pdm_ctrl;
  78
  79         pdm_clk_enable = ACP_PDM_CLK_FREQ_MASK;
  80
  81         rn_writel(pdm_clk_enable, acp_base + ACP_WOV_CLK_CTRL);
  82         pdm_ctrl = rn_readl(acp_base + ACP_WOV_MISC_CTRL);
  83         pdm_ctrl |= ACP_WOV_MISC_CTRL_MASK;
  84         rn_writel(pdm_ctrl, acp_base + ACP_WOV_MISC_CTRL);
  85 }
  86
  87 static void enable_pdm_interrupts(void __iomem *acp_base)
  88 {
  89         u32 ext_int_ctrl;
  90
  91         ext_int_ctrl = rn_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);
  92         ext_int_ctrl |= PDM_DMA_INTR_MASK;
  93         rn_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);
  94 }
  95
  96 static void disable_pdm_interrupts(void __iomem *acp_base)
  97 {
  98         u32 ext_int_ctrl;
  99
 100         ext_int_ctrl = rn_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);
 101         ext_int_ctrl |= ~PDM_DMA_INTR_MASK;
 102         rn_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);
 103 }
 104
 105 static bool check_pdm_dma_status(void __iomem *acp_base)
 106 {
 107         bool pdm_dma_status;
 108         u32 pdm_enable, pdm_dma_enable;
 109
 110         pdm_dma_status = false;
 111         pdm_enable = rn_readl(acp_base + ACP_WOV_PDM_ENABLE);
 112         pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
 113         if ((pdm_enable & ACP_PDM_ENABLE) && (pdm_dma_enable &
 114              ACP_PDM_DMA_EN_STATUS))
 115                 pdm_dma_status = true;
 116         return pdm_dma_status;
 117 }
 118
 119 static int start_pdm_dma(void __iomem *acp_base)
 120 {
 121         u32 pdm_enable;
 122         u32 pdm_dma_enable;
 123         int timeout;
 124
 125         pdm_enable = 0x01;
 126         pdm_dma_enable  = 0x01;
 127
 128         enable_pdm_clock(acp_base);
 129         rn_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);
 130         rn_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);
 131         timeout = 0;
 132         while (++timeout < ACP_COUNTER) {
 133                 pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
 134                 if ((pdm_dma_enable & 0x02) == ACP_PDM_DMA_EN_STATUS)
 135                         return 0;
 136                 udelay(DELAY_US);
 137         }
 138         return -ETIMEDOUT;
 139 }
 140
 141 static int stop_pdm_dma(void __iomem *acp_base)
 142 {
 143         u32 pdm_enable, pdm_dma_enable;
 144         int timeout;
 145
 146         pdm_enable = rn_readl(acp_base + ACP_WOV_PDM_ENABLE);
 147         pdm_dma_enable = rn_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);
 148         if (pdm_dma_enable & 0x01) {
 149                 pdm_dma_enable = 0x02;
 150                 rn_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);
 151                 timeout = 0;
 152                 while (++timeout < ACP_COUNTER) {
 153                         pdm_dma_enable = rn_readl(acp_base +
 154                                                   ACP_WOV_PDM_DMA_ENABLE);
 155                         if ((pdm_dma_enable & 0x02) == 0x00)
 156                                 break;
 157                         udelay(DELAY_US);
 158                 }
 159                 if (timeout == ACP_COUNTER)
 160                         return -ETIMEDOUT;
 161         }
 162         if (pdm_enable == ACP_PDM_ENABLE) {
 163                 pdm_enable = ACP_PDM_DISABLE;
 164                 rn_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);
 165         }
 166         rn_writel(0x01, acp_base + ACP_WOV_PDM_FIFO_FLUSH);
 167         return 0;
 168 }
 169
 170 static void config_acp_dma(struct pdm_stream_instance *rtd, int direction)
 171 {
 172         u16 page_idx;
 173         u32 low, high, val;
 174         dma_addr_t addr;
 175
 176         addr = rtd->dma_addr;
 177         val = 0;
 178
 179         /* Group Enable */
 180         rn_writel(ACP_SRAM_PTE_OFFSET | BIT(31), rtd->acp_base +
 181                   ACPAXI2AXI_ATU_BASE_ADDR_GRP_1);
 182         rn_writel(PAGE_SIZE_4K_ENABLE, rtd->acp_base +
 183                   ACPAXI2AXI_ATU_PAGE_SIZE_GRP_1);
 184
 185         for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {
 186                 /* Load the low address of page int ACP SRAM through SRBM */
 187                 low = lower_32_bits(addr);
 188                 high = upper_32_bits(addr);
 189
 190                 rn_writel(low, rtd->acp_base + ACP_SCRATCH_REG_0 + val);
 191                 high |= BIT(31);
 192                 rn_writel(high, rtd->acp_base + ACP_SCRATCH_REG_0 + val + 4);
 193                 val += 8;
 194                 addr += PAGE_SIZE;
 195         }
 196 }
 197
 198 static int acp_pdm_dma_open(struct snd_soc_component *component,
 199                             struct snd_pcm_substream *substream)
 200 {
 201         struct snd_pcm_runtime *runtime;
 202         struct pdm_dev_data *adata;
 203         struct pdm_stream_instance *pdm_data;
 204         int ret;
 205
 206         runtime = substream->runtime;
 207         adata = dev_get_drvdata(component->dev);
 208         pdm_data = kzalloc(sizeof(*pdm_data), GFP_KERNEL);
 209         if (!pdm_data)
 210                 return -EINVAL;
 211
 212         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 213                 runtime->hw = acp_pdm_hardware_capture;
 214
 215         ret = snd_pcm_hw_constraint_integer(runtime,
 216                                             SNDRV_PCM_HW_PARAM_PERIODS);
 217         if (ret < 0) {
 218                 dev_err(component->dev, "set integer constraint failed\n");
 219                 kfree(pdm_data);
 220                 return ret;
 221         }
 222
 223         enable_pdm_interrupts(adata->acp_base);
 224
 225         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 226                 adata->capture_stream = substream;
 227
 228         pdm_data->acp_base = adata->acp_base;
 229         runtime->private_data = pdm_data;
 230         return ret;
 231 }
 232
 233 static int acp_pdm_dma_hw_params(struct snd_soc_component *component,
 234                                  struct snd_pcm_substream *substream,
 235                                  struct snd_pcm_hw_params *params)
 236 {
 237         struct pdm_stream_instance *rtd;
 238         size_t size, period_bytes;
 239
 240         rtd = substream->runtime->private_data;
 241         if (!rtd)
 242                 return -EINVAL;
 243         size = params_buffer_bytes(params);
 244         period_bytes = params_period_bytes(params);
 245         rtd->dma_addr = substream->dma_buffer.addr;
 246         rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);
 247         config_acp_dma(rtd, substream->stream);
 248         init_pdm_ring_buffer(MEM_WINDOW_START, size, period_bytes,
 249                              rtd->acp_base);
 250         return 0;
 251 }
 252
 253 static u64 acp_pdm_get_byte_count(struct pdm_stream_instance *rtd,
 254                                   int direction)
 255 {
 256         union acp_pdm_dma_count byte_count;
 257
 258         byte_count.bcount.high =
 259                         rn_readl(rtd->acp_base +
 260                                  ACP_WOV_RX_LINEARPOSITIONCNTR_HIGH);
 261         byte_count.bcount.low =
 262                         rn_readl(rtd->acp_base +
 263                                  ACP_WOV_RX_LINEARPOSITIONCNTR_LOW);
 264         return byte_count.bytescount;
 265 }
 266
 267 static snd_pcm_uframes_t acp_pdm_dma_pointer(struct snd_soc_component *comp,
 268                                              struct snd_pcm_substream *stream)
 269 {
 270         struct pdm_stream_instance *rtd;
 271         u32 pos, buffersize;
 272         u64 bytescount;
 273
 274         rtd = stream->runtime->private_data;
 275         buffersize = frames_to_bytes(stream->runtime,
 276                                      stream->runtime->buffer_size);
 277         bytescount = acp_pdm_get_byte_count(rtd, stream->stream);
 278         if (bytescount > rtd->bytescount)
 279                 bytescount -= rtd->bytescount;
 280         pos = do_div(bytescount, buffersize);
 281         return bytes_to_frames(stream->runtime, pos);
 282 }
 283
 284 static int acp_pdm_dma_new(struct snd_soc_component *component,
 285                            struct snd_soc_pcm_runtime *rtd)
 286 {
 287         struct device *parent = component->dev->parent;
 288
 289         snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_DEV,
 290                                        parent, MIN_BUFFER, MAX_BUFFER);
 291         return 0;
 292 }
 293
 294 static int acp_pdm_dma_mmap(struct snd_soc_component *component,
 295                             struct snd_pcm_substream *substream,
 296                             struct vm_area_struct *vma)
 297 {
 298         return snd_pcm_lib_default_mmap(substream, vma);
 299 }
 300
 301 static int acp_pdm_dma_close(struct snd_soc_component *component,
 302                              struct snd_pcm_substream *substream)
 303 {
 304         struct pdm_dev_data *adata = dev_get_drvdata(component->dev);
 305
 306         disable_pdm_interrupts(adata->acp_base);
 307         adata->capture_stream = NULL;
 308         return 0;
 309 }
 310
 311 static int acp_pdm_dai_trigger(struct snd_pcm_substream *substream,
 312                                int cmd, struct snd_soc_dai *dai)
 313 {
 314         struct pdm_stream_instance *rtd;
 315         int ret;
 316         bool pdm_status;
 317         unsigned int ch_mask;
 318
 319         rtd = substream->runtime->private_data;
 320         ret = 0;
 321         switch (substream->runtime->channels) {
 322         case TWO_CH:
 323                 ch_mask = 0x00;
 324                 break;
 325         default:
 326                 return -EINVAL;
 327         }
 328         switch (cmd) {
 329         case SNDRV_PCM_TRIGGER_START:
 330         case SNDRV_PCM_TRIGGER_RESUME:
 331         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 332                 rn_writel(ch_mask, rtd->acp_base + ACP_WOV_PDM_NO_OF_CHANNELS);
 333                 rn_writel(PDM_DECIMATION_FACTOR, rtd->acp_base +
 334                           ACP_WOV_PDM_DECIMATION_FACTOR);
 335                 rtd->bytescount = acp_pdm_get_byte_count(rtd,
 336                                                          substream->stream);
 337                 pdm_status = check_pdm_dma_status(rtd->acp_base);
 338                 if (!pdm_status)
 339                         ret = start_pdm_dma(rtd->acp_base);
 340                 break;
 341         case SNDRV_PCM_TRIGGER_STOP:
 342         case SNDRV_PCM_TRIGGER_SUSPEND:
 343         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 344                 pdm_status = check_pdm_dma_status(rtd->acp_base);
 345                 if (pdm_status)
 346                         ret = stop_pdm_dma(rtd->acp_base);
 347                 break;
 348         default:
 349                 ret = -EINVAL;
 350                 break;
 351         }
 352         return ret;
 353 }
 354
 355 static const struct snd_soc_dai_ops acp_pdm_dai_ops = {
 356         .trigger   = acp_pdm_dai_trigger,
 357 };
 358
 359 static struct snd_soc_dai_driver acp_pdm_dai_driver = {
 360         .capture = {
 361                 .rates = SNDRV_PCM_RATE_48000,
 362                 .formats = SNDRV_PCM_FMTBIT_S24_LE |
 363                            SNDRV_PCM_FMTBIT_S32_LE,
 364                 .channels_min = 2,
 365                 .channels_max = 2,
 366                 .rate_min = 48000,
 367                 .rate_max = 48000,
 368         },
 369         .ops = &acp_pdm_dai_ops,
 370 };
 371
 372 static const struct snd_soc_component_driver acp_pdm_component = {
 373         .name           = DRV_NAME,
 374         .open           = acp_pdm_dma_open,
 375         .close          = acp_pdm_dma_close,
 376         .hw_params      = acp_pdm_dma_hw_params,
 377         .pointer        = acp_pdm_dma_pointer,
 378         .mmap           = acp_pdm_dma_mmap,
 379         .pcm_construct  = acp_pdm_dma_new,
 380 };
 381
 382 static int acp_pdm_audio_probe(struct platform_device *pdev)
 383 {
 384         struct resource *res;
 385         struct pdm_dev_data *adata;
 386         unsigned int irqflags;
 387         int status;
 388
 389         if (!pdev->dev.platform_data) {
 390                 dev_err(&pdev->dev, "platform_data not retrieved\n");
 391                 return -ENODEV;
 392         }
 393         irqflags = *((unsigned int *)(pdev->dev.platform_data));
 394
 395         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 396         if (!res) {
 397                 dev_err(&pdev->dev, "IORESOURCE_MEM FAILED\n");
 398                 return -ENODEV;
 399         }
 400
 401         adata = devm_kzalloc(&pdev->dev, sizeof(*adata), GFP_KERNEL);
 402         if (!adata)
 403                 return -ENOMEM;
 404
 405         adata->acp_base = devm_ioremap(&pdev->dev, res->start,
 406                                        resource_size(res));
 407         if (!adata->acp_base)
 408                 return -ENOMEM;
 409
 410         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 411         if (!res) {
 412                 dev_err(&pdev->dev, "IORESOURCE_IRQ FAILED\n");
 413                 return -ENODEV;
 414         }
 415
 416         adata->pdm_irq = res->start;
 417         adata->capture_stream = NULL;
 418
 419         dev_set_drvdata(&pdev->dev, adata);
 420         status = devm_snd_soc_register_component(&pdev->dev,
 421                                                  &acp_pdm_component,
 422                                                  &acp_pdm_dai_driver, 1);
 423         if (status) {
 424                 dev_err(&pdev->dev, "Fail to register acp pdm dai\n");
 425
 426                 return -ENODEV;
 427         }
 428         status = devm_request_irq(&pdev->dev, adata->pdm_irq, pdm_irq_handler,
 429                                   irqflags, "ACP_PDM_IRQ", adata);
 430         if (status) {
 431                 dev_err(&pdev->dev, "ACP PDM IRQ request failed\n");
 432                 return -ENODEV;
 433         }
 434         pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS);
 435         pm_runtime_use_autosuspend(&pdev->dev);
 436         pm_runtime_enable(&pdev->dev);
 437         pm_runtime_allow(&pdev->dev);
 438         return 0;
 439 }
 440
 441 static int acp_pdm_audio_remove(struct platform_device *pdev)
 442 {
 443         pm_runtime_disable(&pdev->dev);
 444         return 0;
 445 }
 446
 447 static int acp_pdm_resume(struct device *dev)
 448 {
 449         struct pdm_dev_data *adata;
 450         struct snd_pcm_runtime *runtime;
 451         struct pdm_stream_instance *rtd;
 452         u32 period_bytes, buffer_len;
 453
 454         adata = dev_get_drvdata(dev);
 455         if (adata->capture_stream && adata->capture_stream->runtime) {
 456                 runtime = adata->capture_stream->runtime;
 457                 rtd = runtime->private_data;
 458                 period_bytes = frames_to_bytes(runtime, runtime->period_size);
 459                 buffer_len = frames_to_bytes(runtime, runtime->buffer_size);
 460                 config_acp_dma(rtd, SNDRV_PCM_STREAM_CAPTURE);
 461                 init_pdm_ring_buffer(MEM_WINDOW_START, buffer_len, period_bytes,
 462                                      adata->acp_base);
 463         }
 464         enable_pdm_interrupts(adata->acp_base);
 465         return 0;
 466 }
 467
 468 static int acp_pdm_runtime_suspend(struct device *dev)
 469 {
 470         struct pdm_dev_data *adata;
 471
 472         adata = dev_get_drvdata(dev);
 473         disable_pdm_interrupts(adata->acp_base);
 474
 475         return 0;
 476 }
 477
 478 static int acp_pdm_runtime_resume(struct device *dev)
 479 {
 480         struct pdm_dev_data *adata;
 481
 482         adata = dev_get_drvdata(dev);
 483         enable_pdm_interrupts(adata->acp_base);
 484         return 0;
 485 }
 486
 487 static const struct dev_pm_ops acp_pdm_pm_ops = {
 488         .runtime_suspend = acp_pdm_runtime_suspend,
 489         .runtime_resume = acp_pdm_runtime_resume,
 490         .resume = acp_pdm_resume,
 491 };
 492
 493 static struct platform_driver acp_pdm_dma_driver = {
 494         .probe = acp_pdm_audio_probe,
 495         .remove = acp_pdm_audio_remove,
 496         .driver = {
 497                 .name = "acp_rn_pdm_dma",
 498                 .pm = &acp_pdm_pm_ops,
 499         },
 500 };
 501
 502 module_platform_driver(acp_pdm_dma_driver);
 503
 504 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
 505 MODULE_DESCRIPTION("AMD ACP3x Renior PDM Driver");
 506 MODULE_LICENSE("GPL v2");
 507 MODULE_ALIAS("platform:" DRV_NAME);