2 * AMD ALSA SoC PCM Driver
4 * Copyright 2016 Advanced Micro Devices, Inc.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #include <linux/platform_device.h>
17 #include <linux/module.h>
18 #include <linux/err.h>
20 #include <sound/pcm.h>
21 #include <sound/pcm_params.h>
22 #include <sound/soc.h>
23 #include <sound/soc-dai.h>
27 #define DRV_NAME "acp3x-i2s-audio"
33 void __iomem *acp3x_base;
34 struct snd_pcm_substream *play_stream;
35 struct snd_pcm_substream *capture_stream;
38 struct i2s_stream_instance {
43 void __iomem *acp3x_base;
46 static const struct snd_pcm_hardware acp3x_pcm_hardware_playback = {
47 .info = SNDRV_PCM_INFO_INTERLEAVED |
48 SNDRV_PCM_INFO_BLOCK_TRANSFER |
49 SNDRV_PCM_INFO_BATCH |
50 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
51 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 |
52 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S24_LE |
53 SNDRV_PCM_FMTBIT_S32_LE,
56 .rates = SNDRV_PCM_RATE_8000_96000,
59 .buffer_bytes_max = PLAYBACK_MAX_NUM_PERIODS * PLAYBACK_MAX_PERIOD_SIZE,
60 .period_bytes_min = PLAYBACK_MIN_PERIOD_SIZE,
61 .period_bytes_max = PLAYBACK_MAX_PERIOD_SIZE,
62 .periods_min = PLAYBACK_MIN_NUM_PERIODS,
63 .periods_max = PLAYBACK_MAX_NUM_PERIODS,
66 static const struct snd_pcm_hardware acp3x_pcm_hardware_capture = {
67 .info = SNDRV_PCM_INFO_INTERLEAVED |
68 SNDRV_PCM_INFO_BLOCK_TRANSFER |
69 SNDRV_PCM_INFO_BATCH |
70 SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
71 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 |
72 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S24_LE |
73 SNDRV_PCM_FMTBIT_S32_LE,
76 .rates = SNDRV_PCM_RATE_8000_48000,
79 .buffer_bytes_max = CAPTURE_MAX_NUM_PERIODS * CAPTURE_MAX_PERIOD_SIZE,
80 .period_bytes_min = CAPTURE_MIN_PERIOD_SIZE,
81 .period_bytes_max = CAPTURE_MAX_PERIOD_SIZE,
82 .periods_min = CAPTURE_MIN_NUM_PERIODS,
83 .periods_max = CAPTURE_MAX_NUM_PERIODS,
86 static int acp3x_power_on(void __iomem *acp3x_base, bool on)
93 mask = ACP3x_POWER_ON;
96 mask = ACP3x_POWER_OFF;
99 rv_writel(val, acp3x_base + mmACP_PGFSM_CONTROL);
102 val = rv_readl(acp3x_base + mmACP_PGFSM_STATUS);
103 if ((val & ACP3x_POWER_OFF_IN_PROGRESS) == mask)
106 pr_err("ACP3x power state change failure\n");
115 static int acp3x_reset(void __iomem *acp3x_base)
119 rv_writel(1, acp3x_base + mmACP_SOFT_RESET);
122 val = rv_readl(acp3x_base + mmACP_SOFT_RESET);
123 if ((val & ACP3x_SOFT_RESET__SoftResetAudDone_MASK) ||
125 if (val & ACP3x_SOFT_RESET__SoftResetAudDone_MASK)
133 rv_writel(0, acp3x_base + mmACP_SOFT_RESET);
136 val = rv_readl(acp3x_base + mmACP_SOFT_RESET);
137 if (!val || timeout > 100) {
148 static int acp3x_init(void __iomem *acp3x_base)
153 ret = acp3x_power_on(acp3x_base, true);
155 pr_err("ACP3x power on failed\n");
159 ret = acp3x_reset(acp3x_base);
161 pr_err("ACP3x reset failed\n");
167 static int acp3x_deinit(void __iomem *acp3x_base)
172 ret = acp3x_reset(acp3x_base);
174 pr_err("ACP3x reset failed\n");
178 ret = acp3x_power_on(acp3x_base, false);
180 pr_err("ACP3x power off failed\n");
186 static irqreturn_t i2s_irq_handler(int irq, void *dev_id)
188 u16 play_flag, cap_flag;
190 struct i2s_dev_data *rv_i2s_data = dev_id;
197 val = rv_readl(rv_i2s_data->acp3x_base + mmACP_EXTERNAL_INTR_STAT);
198 if ((val & BIT(BT_TX_THRESHOLD)) && rv_i2s_data->play_stream) {
199 rv_writel(BIT(BT_TX_THRESHOLD), rv_i2s_data->acp3x_base +
200 mmACP_EXTERNAL_INTR_STAT);
201 snd_pcm_period_elapsed(rv_i2s_data->play_stream);
205 if ((val & BIT(BT_RX_THRESHOLD)) && rv_i2s_data->capture_stream) {
206 rv_writel(BIT(BT_RX_THRESHOLD), rv_i2s_data->acp3x_base +
207 mmACP_EXTERNAL_INTR_STAT);
208 snd_pcm_period_elapsed(rv_i2s_data->capture_stream);
212 if (play_flag | cap_flag)
218 static void config_acp3x_dma(struct i2s_stream_instance *rtd, int direction)
222 u32 low, high, val, acp_fifo_addr;
223 struct page *pg = rtd->pg;
225 /* 8 scratch registers used to map one 64 bit address */
226 if (direction == SNDRV_PCM_STREAM_PLAYBACK)
229 val = rtd->num_pages * 8;
232 rv_writel(ACP_SRAM_PTE_OFFSET | BIT(31), rtd->acp3x_base +
233 mmACPAXI2AXI_ATU_BASE_ADDR_GRP_1);
234 rv_writel(PAGE_SIZE_4K_ENABLE, rtd->acp3x_base +
235 mmACPAXI2AXI_ATU_PAGE_SIZE_GRP_1);
237 for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {
238 /* Load the low address of page int ACP SRAM through SRBM */
239 addr = page_to_phys(pg);
240 low = lower_32_bits(addr);
241 high = upper_32_bits(addr);
243 rv_writel(low, rtd->acp3x_base + mmACP_SCRATCH_REG_0 + val);
245 rv_writel(high, rtd->acp3x_base + mmACP_SCRATCH_REG_0 + val
247 /* Move to next physically contiguos page */
252 if (direction == SNDRV_PCM_STREAM_PLAYBACK) {
253 /* Config ringbuffer */
254 rv_writel(MEM_WINDOW_START, rtd->acp3x_base +
255 mmACP_BT_TX_RINGBUFADDR);
256 rv_writel(MAX_BUFFER, rtd->acp3x_base +
257 mmACP_BT_TX_RINGBUFSIZE);
258 rv_writel(DMA_SIZE, rtd->acp3x_base + mmACP_BT_TX_DMA_SIZE);
260 /* Config audio fifo */
261 acp_fifo_addr = ACP_SRAM_PTE_OFFSET + (rtd->num_pages * 8)
262 + PLAYBACK_FIFO_ADDR_OFFSET;
263 rv_writel(acp_fifo_addr, rtd->acp3x_base +
264 mmACP_BT_TX_FIFOADDR);
265 rv_writel(FIFO_SIZE, rtd->acp3x_base + mmACP_BT_TX_FIFOSIZE);
267 /* Config ringbuffer */
268 rv_writel(MEM_WINDOW_START + MAX_BUFFER, rtd->acp3x_base +
269 mmACP_BT_RX_RINGBUFADDR);
270 rv_writel(MAX_BUFFER, rtd->acp3x_base +
271 mmACP_BT_RX_RINGBUFSIZE);
272 rv_writel(DMA_SIZE, rtd->acp3x_base + mmACP_BT_RX_DMA_SIZE);
274 /* Config audio fifo */
275 acp_fifo_addr = ACP_SRAM_PTE_OFFSET +
276 (rtd->num_pages * 8) + CAPTURE_FIFO_ADDR_OFFSET;
277 rv_writel(acp_fifo_addr, rtd->acp3x_base +
278 mmACP_BT_RX_FIFOADDR);
279 rv_writel(FIFO_SIZE, rtd->acp3x_base + mmACP_BT_RX_FIFOSIZE);
282 /* Enable watermark/period interrupt to host */
283 rv_writel(BIT(BT_TX_THRESHOLD) | BIT(BT_RX_THRESHOLD),
284 rtd->acp3x_base + mmACP_EXTERNAL_INTR_CNTL);
287 static int acp3x_dma_open(struct snd_pcm_substream *substream)
291 struct snd_pcm_runtime *runtime = substream->runtime;
292 struct snd_soc_pcm_runtime *prtd = substream->private_data;
293 struct snd_soc_component *component = snd_soc_rtdcom_lookup(prtd,
295 struct i2s_dev_data *adata = dev_get_drvdata(component->dev);
297 struct i2s_stream_instance *i2s_data = kzalloc(sizeof(struct i2s_stream_instance),
302 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
303 runtime->hw = acp3x_pcm_hardware_playback;
305 runtime->hw = acp3x_pcm_hardware_capture;
307 ret = snd_pcm_hw_constraint_integer(runtime,
308 SNDRV_PCM_HW_PARAM_PERIODS);
310 dev_err(component->dev, "set integer constraint failed\n");
314 if (!adata->play_stream && !adata->capture_stream)
315 rv_writel(1, adata->acp3x_base + mmACP_EXTERNAL_INTR_ENB);
317 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
318 adata->play_stream = substream;
320 adata->capture_stream = substream;
322 i2s_data->acp3x_base = adata->acp3x_base;
323 runtime->private_data = i2s_data;
327 static int acp3x_dma_hw_params(struct snd_pcm_substream *substream,
328 struct snd_pcm_hw_params *params)
332 struct snd_dma_buffer *dma_buffer;
334 struct snd_pcm_runtime *runtime = substream->runtime;
335 struct i2s_stream_instance *rtd = runtime->private_data;
340 dma_buffer = &substream->dma_buffer;
341 size = params_buffer_bytes(params);
342 status = snd_pcm_lib_malloc_pages(substream, size);
346 memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
347 pg = virt_to_page(substream->dma_buffer.area);
350 rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);
351 config_acp3x_dma(rtd, substream->stream);
359 static snd_pcm_uframes_t acp3x_dma_pointer(struct snd_pcm_substream *substream)
362 struct i2s_stream_instance *rtd = substream->runtime->private_data;
364 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
365 pos = rv_readl(rtd->acp3x_base +
366 mmACP_BT_TX_LINKPOSITIONCNTR);
368 pos = rv_readl(rtd->acp3x_base +
369 mmACP_BT_RX_LINKPOSITIONCNTR);
371 if (pos >= MAX_BUFFER)
374 return bytes_to_frames(substream->runtime, pos);
377 static int acp3x_dma_new(struct snd_soc_pcm_runtime *rtd)
379 return snd_pcm_lib_preallocate_pages_for_all(rtd->pcm,
385 static int acp3x_dma_hw_free(struct snd_pcm_substream *substream)
387 return snd_pcm_lib_free_pages(substream);
390 static int acp3x_dma_mmap(struct snd_pcm_substream *substream,
391 struct vm_area_struct *vma)
393 return snd_pcm_lib_default_mmap(substream, vma);
396 static int acp3x_dma_close(struct snd_pcm_substream *substream)
398 struct snd_soc_pcm_runtime *prtd = substream->private_data;
399 struct i2s_stream_instance *rtd = substream->runtime->private_data;
400 struct snd_soc_component *component = snd_soc_rtdcom_lookup(prtd,
402 struct i2s_dev_data *adata = dev_get_drvdata(component->dev);
404 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
405 adata->play_stream = NULL;
407 adata->capture_stream = NULL;
409 /* Disable ACP irq, when the current stream is being closed and
410 * another stream is also not active.
412 if (!adata->play_stream && !adata->capture_stream)
413 rv_writel(0, adata->acp3x_base + mmACP_EXTERNAL_INTR_ENB);
418 static struct snd_pcm_ops acp3x_dma_ops = {
419 .open = acp3x_dma_open,
420 .close = acp3x_dma_close,
421 .ioctl = snd_pcm_lib_ioctl,
422 .hw_params = acp3x_dma_hw_params,
423 .hw_free = acp3x_dma_hw_free,
424 .pointer = acp3x_dma_pointer,
425 .mmap = acp3x_dma_mmap,
429 static int acp3x_dai_i2s_set_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
432 struct i2s_dev_data *adata = snd_soc_dai_get_drvdata(cpu_dai);
434 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
435 case SND_SOC_DAIFMT_I2S:
436 adata->tdm_mode = false;
438 case SND_SOC_DAIFMT_DSP_A:
439 adata->tdm_mode = true;
448 static int acp3x_dai_set_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
449 u32 rx_mask, int slots, int slot_width)
454 struct i2s_dev_data *adata = snd_soc_dai_get_drvdata(cpu_dai);
456 switch (slot_width) {
473 val = rv_readl(adata->acp3x_base + mmACP_BTTDM_ITER);
474 rv_writel((val | 0x2), adata->acp3x_base + mmACP_BTTDM_ITER);
475 val = rv_readl(adata->acp3x_base + mmACP_BTTDM_IRER);
476 rv_writel((val | 0x2), adata->acp3x_base + mmACP_BTTDM_IRER);
478 val = (FRM_LEN | (slots << 15) | (slot_len << 18));
479 rv_writel(val, adata->acp3x_base + mmACP_BTTDM_TXFRMT);
480 rv_writel(val, adata->acp3x_base + mmACP_BTTDM_RXFRMT);
482 adata->tdm_fmt = val;
486 static int acp3x_dai_i2s_hwparams(struct snd_pcm_substream *substream,
487 struct snd_pcm_hw_params *params,
488 struct snd_soc_dai *dai)
491 struct i2s_stream_instance *rtd = substream->runtime->private_data;
493 switch (params_format(params)) {
494 case SNDRV_PCM_FORMAT_U8:
495 case SNDRV_PCM_FORMAT_S8:
496 rtd->xfer_resolution = 0x0;
498 case SNDRV_PCM_FORMAT_S16_LE:
499 rtd->xfer_resolution = 0x02;
501 case SNDRV_PCM_FORMAT_S24_LE:
502 rtd->xfer_resolution = 0x04;
504 case SNDRV_PCM_FORMAT_S32_LE:
505 rtd->xfer_resolution = 0x05;
510 val = rv_readl(rtd->acp3x_base + mmACP_BTTDM_ITER);
511 val = val | (rtd->xfer_resolution << 3);
512 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
513 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_ITER);
515 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_IRER);
520 static int acp3x_dai_i2s_trigger(struct snd_pcm_substream *substream,
521 int cmd, struct snd_soc_dai *dai)
524 struct i2s_stream_instance *rtd = substream->runtime->private_data;
525 u32 val, period_bytes;
527 period_bytes = frames_to_bytes(substream->runtime,
528 substream->runtime->period_size);
530 case SNDRV_PCM_TRIGGER_START:
531 case SNDRV_PCM_TRIGGER_RESUME:
532 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
533 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
534 rv_writel(period_bytes, rtd->acp3x_base +
535 mmACP_BT_TX_INTR_WATERMARK_SIZE);
536 val = rv_readl(rtd->acp3x_base + mmACP_BTTDM_ITER);
538 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_ITER);
540 rv_writel(period_bytes, rtd->acp3x_base +
541 mmACP_BT_RX_INTR_WATERMARK_SIZE);
542 val = rv_readl(rtd->acp3x_base + mmACP_BTTDM_IRER);
544 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_IRER);
546 rv_writel(1, rtd->acp3x_base + mmACP_BTTDM_IER);
548 case SNDRV_PCM_TRIGGER_STOP:
549 case SNDRV_PCM_TRIGGER_SUSPEND:
550 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
551 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
552 val = rv_readl(rtd->acp3x_base + mmACP_BTTDM_ITER);
554 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_ITER);
556 val = rv_readl(rtd->acp3x_base + mmACP_BTTDM_IRER);
558 rv_writel(val, rtd->acp3x_base + mmACP_BTTDM_IRER);
560 rv_writel(0, rtd->acp3x_base + mmACP_BTTDM_IER);
570 struct snd_soc_dai_ops acp3x_dai_i2s_ops = {
571 .hw_params = acp3x_dai_i2s_hwparams,
572 .trigger = acp3x_dai_i2s_trigger,
573 .set_fmt = acp3x_dai_i2s_set_fmt,
574 .set_tdm_slot = acp3x_dai_set_tdm_slot,
577 static struct snd_soc_dai_driver acp3x_i2s_dai_driver = {
579 .rates = SNDRV_PCM_RATE_8000_96000,
580 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 |
581 SNDRV_PCM_FMTBIT_U8 |
582 SNDRV_PCM_FMTBIT_S24_LE |
583 SNDRV_PCM_FMTBIT_S32_LE,
591 .rates = SNDRV_PCM_RATE_8000_48000,
592 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S8 |
593 SNDRV_PCM_FMTBIT_U8 |
594 SNDRV_PCM_FMTBIT_S24_LE |
595 SNDRV_PCM_FMTBIT_S32_LE,
601 .ops = &acp3x_dai_i2s_ops,
604 static const struct snd_soc_component_driver acp3x_i2s_component = {
606 .ops = &acp3x_dma_ops,
607 .pcm_new = acp3x_dma_new,
610 static int acp3x_audio_probe(struct platform_device *pdev)
613 struct resource *res;
614 struct i2s_dev_data *adata;
615 unsigned int irqflags;
617 if (!pdev->dev.platform_data) {
618 dev_err(&pdev->dev, "platform_data not retrieved\n");
621 irqflags = *((unsigned int *)(pdev->dev.platform_data));
623 adata = devm_kzalloc(&pdev->dev, sizeof(struct i2s_dev_data),
625 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
627 dev_err(&pdev->dev, "IORESOURCE_IRQ FAILED\n");
631 adata->acp3x_base = devm_ioremap(&pdev->dev, res->start,
634 res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
636 dev_err(&pdev->dev, "IORESOURCE_IRQ FAILED\n");
640 adata->i2s_irq = res->start;
641 adata->play_stream = NULL;
642 adata->capture_stream = NULL;
644 dev_set_drvdata(&pdev->dev, adata);
646 status = acp3x_init(adata->acp3x_base);
649 status = devm_snd_soc_register_component(&pdev->dev,
650 &acp3x_i2s_component,
651 &acp3x_i2s_dai_driver, 1);
653 dev_err(&pdev->dev, "Fail to register acp i2s dai\n");
656 status = devm_request_irq(&pdev->dev, adata->i2s_irq, i2s_irq_handler,
657 irqflags, "ACP3x_I2S_IRQ", adata);
659 dev_err(&pdev->dev, "ACP3x I2S IRQ request failed\n");
665 status = acp3x_deinit(adata->acp3x_base);
667 dev_err(&pdev->dev, "ACP de-init failed\n");
669 dev_info(&pdev->dev, "ACP de-initialized\n");
670 /*ignore device status and return driver probe error*/
674 static int acp3x_audio_remove(struct platform_device *pdev)
677 struct i2s_dev_data *adata = dev_get_drvdata(&pdev->dev);
679 ret = acp3x_deinit(adata->acp3x_base);
681 dev_err(&pdev->dev, "ACP de-init failed\n");
683 dev_info(&pdev->dev, "ACP de-initialized\n");
688 static struct platform_driver acp3x_dma_driver = {
689 .probe = acp3x_audio_probe,
690 .remove = acp3x_audio_remove,
692 .name = "acp3x_rv_i2s",
696 module_platform_driver(acp3x_dma_driver);
698 MODULE_AUTHOR("Maruthi.Bayyavarapu@amd.com");
699 MODULE_AUTHOR("Vijendar.Mukunda@amd.com");
700 MODULE_DESCRIPTION("AMD ACP 3.x PCM Driver");
701 MODULE_LICENSE("GPL v2");
702 MODULE_ALIAS("platform:" DRV_NAME);