2 * AMD ALSA SoC PCM Driver for ACP 2.x
4 * Copyright 2014-2015 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/module.h>
17 #include <linux/delay.h>
18 #include <linux/sizes.h>
20 #include <sound/soc.h>
24 #define PLAYBACK_MIN_NUM_PERIODS 2
25 #define PLAYBACK_MAX_NUM_PERIODS 2
26 #define PLAYBACK_MAX_PERIOD_SIZE 16384
27 #define PLAYBACK_MIN_PERIOD_SIZE 1024
28 #define CAPTURE_MIN_NUM_PERIODS 2
29 #define CAPTURE_MAX_NUM_PERIODS 2
30 #define CAPTURE_MAX_PERIOD_SIZE 16384
31 #define CAPTURE_MIN_PERIOD_SIZE 1024
33 #define MAX_BUFFER (PLAYBACK_MAX_PERIOD_SIZE * PLAYBACK_MAX_NUM_PERIODS)
34 #define MIN_BUFFER MAX_BUFFER
36 static const struct snd_pcm_hardware acp_pcm_hardware_playback
= {
37 .info
= SNDRV_PCM_INFO_INTERLEAVED
|
38 SNDRV_PCM_INFO_BLOCK_TRANSFER
| SNDRV_PCM_INFO_MMAP
|
39 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_BATCH
|
40 SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_RESUME
,
41 .formats
= SNDRV_PCM_FMTBIT_S16_LE
|
42 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S32_LE
,
45 .rates
= SNDRV_PCM_RATE_8000_96000
,
48 .buffer_bytes_max
= PLAYBACK_MAX_NUM_PERIODS
* PLAYBACK_MAX_PERIOD_SIZE
,
49 .period_bytes_min
= PLAYBACK_MIN_PERIOD_SIZE
,
50 .period_bytes_max
= PLAYBACK_MAX_PERIOD_SIZE
,
51 .periods_min
= PLAYBACK_MIN_NUM_PERIODS
,
52 .periods_max
= PLAYBACK_MAX_NUM_PERIODS
,
55 static const struct snd_pcm_hardware acp_pcm_hardware_capture
= {
56 .info
= SNDRV_PCM_INFO_INTERLEAVED
|
57 SNDRV_PCM_INFO_BLOCK_TRANSFER
| SNDRV_PCM_INFO_MMAP
|
58 SNDRV_PCM_INFO_MMAP_VALID
| SNDRV_PCM_INFO_BATCH
|
59 SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_RESUME
,
60 .formats
= SNDRV_PCM_FMTBIT_S16_LE
|
61 SNDRV_PCM_FMTBIT_S24_LE
| SNDRV_PCM_FMTBIT_S32_LE
,
64 .rates
= SNDRV_PCM_RATE_8000_48000
,
67 .buffer_bytes_max
= CAPTURE_MAX_NUM_PERIODS
* CAPTURE_MAX_PERIOD_SIZE
,
68 .period_bytes_min
= CAPTURE_MIN_PERIOD_SIZE
,
69 .period_bytes_max
= CAPTURE_MAX_PERIOD_SIZE
,
70 .periods_min
= CAPTURE_MIN_NUM_PERIODS
,
71 .periods_max
= CAPTURE_MAX_NUM_PERIODS
,
74 struct audio_drv_data
{
75 struct snd_pcm_substream
*play_stream
;
76 struct snd_pcm_substream
*capture_stream
;
77 void __iomem
*acp_mmio
;
80 static u32
acp_reg_read(void __iomem
*acp_mmio
, u32 reg
)
82 return readl(acp_mmio
+ (reg
* 4));
85 static void acp_reg_write(u32 val
, void __iomem
*acp_mmio
, u32 reg
)
87 writel(val
, acp_mmio
+ (reg
* 4));
90 /* Configure a given dma channel parameters - enable/disble,
91 * number of descriptors, priority
93 static void config_acp_dma_channel(void __iomem
*acp_mmio
, u8 ch_num
,
94 u16 dscr_strt_idx
, u16 num_dscrs
,
95 enum acp_dma_priority_level priority_level
)
99 /* disable the channel run field */
100 dma_ctrl
= acp_reg_read(acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
101 dma_ctrl
&= ~ACP_DMA_CNTL_0__DMAChRun_MASK
;
102 acp_reg_write(dma_ctrl
, acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
104 /* program a DMA channel with first descriptor to be processed. */
105 acp_reg_write((ACP_DMA_DSCR_STRT_IDX_0__DMAChDscrStrtIdx_MASK
107 acp_mmio
, mmACP_DMA_DSCR_STRT_IDX_0
+ ch_num
);
109 /* program a DMA channel with the number of descriptors to be
110 * processed in the transfer
112 acp_reg_write(ACP_DMA_DSCR_CNT_0__DMAChDscrCnt_MASK
& num_dscrs
,
113 acp_mmio
, mmACP_DMA_DSCR_CNT_0
+ ch_num
);
115 /* set DMA channel priority */
116 acp_reg_write(priority_level
, acp_mmio
, mmACP_DMA_PRIO_0
+ ch_num
);
119 /* Initialize a dma descriptor in SRAM based on descritor information passed */
120 static void config_dma_descriptor_in_sram(void __iomem
*acp_mmio
,
122 acp_dma_dscr_transfer_t
*descr_info
)
126 sram_offset
= (descr_idx
* sizeof(acp_dma_dscr_transfer_t
));
128 /* program the source base address. */
129 acp_reg_write(sram_offset
, acp_mmio
, mmACP_SRBM_Targ_Idx_Addr
);
130 acp_reg_write(descr_info
->src
, acp_mmio
, mmACP_SRBM_Targ_Idx_Data
);
131 /* program the destination base address. */
132 acp_reg_write(sram_offset
+ 4, acp_mmio
, mmACP_SRBM_Targ_Idx_Addr
);
133 acp_reg_write(descr_info
->dest
, acp_mmio
, mmACP_SRBM_Targ_Idx_Data
);
135 /* program the number of bytes to be transferred for this descriptor. */
136 acp_reg_write(sram_offset
+ 8, acp_mmio
, mmACP_SRBM_Targ_Idx_Addr
);
137 acp_reg_write(descr_info
->xfer_val
, acp_mmio
, mmACP_SRBM_Targ_Idx_Data
);
140 /* Initialize the DMA descriptor information for transfer between
141 * system memory <-> ACP SRAM
143 static void set_acp_sysmem_dma_descriptors(void __iomem
*acp_mmio
,
144 u32 size
, int direction
,
148 u16 dma_dscr_idx
= PLAYBACK_START_DMA_DESCR_CH12
;
149 acp_dma_dscr_transfer_t dmadscr
[NUM_DSCRS_PER_CHANNEL
];
151 for (i
= 0; i
< NUM_DSCRS_PER_CHANNEL
; i
++) {
152 dmadscr
[i
].xfer_val
= 0;
153 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
) {
154 dma_dscr_idx
= PLAYBACK_START_DMA_DESCR_CH12
+ i
;
155 dmadscr
[i
].dest
= ACP_SHARED_RAM_BANK_1_ADDRESS
+
156 (size
/ 2) - (i
* (size
/2));
157 dmadscr
[i
].src
= ACP_INTERNAL_APERTURE_WINDOW_0_ADDRESS
158 + (pte_offset
* SZ_4K
) + (i
* (size
/2));
159 dmadscr
[i
].xfer_val
|=
160 (ACP_DMA_ATTRIBUTES_DAGB_ONION_TO_SHAREDMEM
<< 16) |
163 dma_dscr_idx
= CAPTURE_START_DMA_DESCR_CH14
+ i
;
164 dmadscr
[i
].src
= ACP_SHARED_RAM_BANK_5_ADDRESS
+
166 dmadscr
[i
].dest
= ACP_INTERNAL_APERTURE_WINDOW_0_ADDRESS
167 + (pte_offset
* SZ_4K
) +
169 dmadscr
[i
].xfer_val
|=
171 (ACP_DMA_ATTRIBUTES_SHAREDMEM_TO_DAGB_ONION
<< 16) |
174 config_dma_descriptor_in_sram(acp_mmio
, dma_dscr_idx
,
177 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
)
178 config_acp_dma_channel(acp_mmio
, SYSRAM_TO_ACP_CH_NUM
,
179 PLAYBACK_START_DMA_DESCR_CH12
,
180 NUM_DSCRS_PER_CHANNEL
,
181 ACP_DMA_PRIORITY_LEVEL_NORMAL
);
183 config_acp_dma_channel(acp_mmio
, ACP_TO_SYSRAM_CH_NUM
,
184 CAPTURE_START_DMA_DESCR_CH14
,
185 NUM_DSCRS_PER_CHANNEL
,
186 ACP_DMA_PRIORITY_LEVEL_NORMAL
);
189 /* Initialize the DMA descriptor information for transfer between
192 static void set_acp_to_i2s_dma_descriptors(void __iomem
*acp_mmio
,
193 u32 size
, int direction
)
197 u16 dma_dscr_idx
= PLAYBACK_START_DMA_DESCR_CH13
;
198 acp_dma_dscr_transfer_t dmadscr
[NUM_DSCRS_PER_CHANNEL
];
200 for (i
= 0; i
< NUM_DSCRS_PER_CHANNEL
; i
++) {
201 dmadscr
[i
].xfer_val
= 0;
202 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
) {
203 dma_dscr_idx
= PLAYBACK_START_DMA_DESCR_CH13
+ i
;
204 dmadscr
[i
].src
= ACP_SHARED_RAM_BANK_1_ADDRESS
+
206 /* dmadscr[i].dest is unused by hardware. */
208 dmadscr
[i
].xfer_val
|= BIT(22) | (TO_ACP_I2S_1
<< 16) |
211 dma_dscr_idx
= CAPTURE_START_DMA_DESCR_CH15
+ i
;
212 /* dmadscr[i].src is unused by hardware. */
214 dmadscr
[i
].dest
= ACP_SHARED_RAM_BANK_5_ADDRESS
+
216 dmadscr
[i
].xfer_val
|= BIT(22) |
217 (FROM_ACP_I2S_1
<< 16) | (size
/ 2);
219 config_dma_descriptor_in_sram(acp_mmio
, dma_dscr_idx
,
222 /* Configure the DMA channel with the above descriptore */
223 if (direction
== SNDRV_PCM_STREAM_PLAYBACK
)
224 config_acp_dma_channel(acp_mmio
, ACP_TO_I2S_DMA_CH_NUM
,
225 PLAYBACK_START_DMA_DESCR_CH13
,
226 NUM_DSCRS_PER_CHANNEL
,
227 ACP_DMA_PRIORITY_LEVEL_NORMAL
);
229 config_acp_dma_channel(acp_mmio
, I2S_TO_ACP_DMA_CH_NUM
,
230 CAPTURE_START_DMA_DESCR_CH15
,
231 NUM_DSCRS_PER_CHANNEL
,
232 ACP_DMA_PRIORITY_LEVEL_NORMAL
);
235 /* Create page table entries in ACP SRAM for the allocated memory */
236 static void acp_pte_config(void __iomem
*acp_mmio
, struct page
*pg
,
237 u16 num_of_pages
, u32 pte_offset
)
245 offset
= ACP_DAGB_GRP_SRBM_SRAM_BASE_OFFSET
+ (pte_offset
* 8);
246 for (page_idx
= 0; page_idx
< (num_of_pages
); page_idx
++) {
247 /* Load the low address of page int ACP SRAM through SRBM */
248 acp_reg_write((offset
+ (page_idx
* 8)),
249 acp_mmio
, mmACP_SRBM_Targ_Idx_Addr
);
250 addr
= page_to_phys(pg
);
252 low
= lower_32_bits(addr
);
253 high
= upper_32_bits(addr
);
255 acp_reg_write(low
, acp_mmio
, mmACP_SRBM_Targ_Idx_Data
);
257 /* Load the High address of page int ACP SRAM through SRBM */
258 acp_reg_write((offset
+ (page_idx
* 8) + 4),
259 acp_mmio
, mmACP_SRBM_Targ_Idx_Addr
);
261 /* page enable in ACP */
263 acp_reg_write(high
, acp_mmio
, mmACP_SRBM_Targ_Idx_Data
);
265 /* Move to next physically contiguos page */
270 static void config_acp_dma(void __iomem
*acp_mmio
,
271 struct audio_substream_data
*audio_config
)
275 if (audio_config
->direction
== SNDRV_PCM_STREAM_PLAYBACK
)
276 pte_offset
= ACP_PLAYBACK_PTE_OFFSET
;
278 pte_offset
= ACP_CAPTURE_PTE_OFFSET
;
280 acp_pte_config(acp_mmio
, audio_config
->pg
, audio_config
->num_of_pages
,
283 /* Configure System memory <-> ACP SRAM DMA descriptors */
284 set_acp_sysmem_dma_descriptors(acp_mmio
, audio_config
->size
,
285 audio_config
->direction
, pte_offset
);
287 /* Configure ACP SRAM <-> I2S DMA descriptors */
288 set_acp_to_i2s_dma_descriptors(acp_mmio
, audio_config
->size
,
289 audio_config
->direction
);
292 /* Start a given DMA channel transfer */
293 static void acp_dma_start(void __iomem
*acp_mmio
,
294 u16 ch_num
, bool is_circular
)
298 /* read the dma control register and disable the channel run field */
299 dma_ctrl
= acp_reg_read(acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
301 /* Invalidating the DAGB cache */
302 acp_reg_write(1, acp_mmio
, mmACP_DAGB_ATU_CTRL
);
304 /* configure the DMA channel and start the DMA transfer
305 * set dmachrun bit to start the transfer and enable the
306 * interrupt on completion of the dma transfer
308 dma_ctrl
|= ACP_DMA_CNTL_0__DMAChRun_MASK
;
311 case ACP_TO_I2S_DMA_CH_NUM
:
312 case ACP_TO_SYSRAM_CH_NUM
:
313 case I2S_TO_ACP_DMA_CH_NUM
:
314 dma_ctrl
|= ACP_DMA_CNTL_0__DMAChIOCEn_MASK
;
317 dma_ctrl
&= ~ACP_DMA_CNTL_0__DMAChIOCEn_MASK
;
321 /* enable for ACP SRAM to/from I2S DMA channel */
322 if (is_circular
== true)
323 dma_ctrl
|= ACP_DMA_CNTL_0__Circular_DMA_En_MASK
;
325 dma_ctrl
&= ~ACP_DMA_CNTL_0__Circular_DMA_En_MASK
;
327 acp_reg_write(dma_ctrl
, acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
330 /* Stop a given DMA channel transfer */
331 static int acp_dma_stop(void __iomem
*acp_mmio
, u8 ch_num
)
335 u32 count
= ACP_DMA_RESET_TIME
;
337 dma_ctrl
= acp_reg_read(acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
339 /* clear the dma control register fields before writing zero
342 dma_ctrl
&= ~ACP_DMA_CNTL_0__DMAChRun_MASK
;
343 dma_ctrl
&= ~ACP_DMA_CNTL_0__DMAChIOCEn_MASK
;
345 acp_reg_write(dma_ctrl
, acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
346 dma_ch_sts
= acp_reg_read(acp_mmio
, mmACP_DMA_CH_STS
);
348 if (dma_ch_sts
& BIT(ch_num
)) {
349 /* set the reset bit for this channel to stop the dma
352 dma_ctrl
|= ACP_DMA_CNTL_0__DMAChRst_MASK
;
353 acp_reg_write(dma_ctrl
, acp_mmio
, mmACP_DMA_CNTL_0
+ ch_num
);
356 /* check the channel status bit for some time and return the status */
358 dma_ch_sts
= acp_reg_read(acp_mmio
, mmACP_DMA_CH_STS
);
359 if (!(dma_ch_sts
& BIT(ch_num
))) {
360 /* clear the reset flag after successfully stopping
361 * the dma transfer and break from the loop
363 dma_ctrl
&= ~ACP_DMA_CNTL_0__DMAChRst_MASK
;
365 acp_reg_write(dma_ctrl
, acp_mmio
, mmACP_DMA_CNTL_0
370 pr_err("Failed to stop ACP DMA channel : %d\n", ch_num
);
378 /* Initialize and bring ACP hardware to default state. */
379 static int acp_init(void __iomem
*acp_mmio
)
381 u32 val
, count
, sram_pte_offset
;
383 /* Assert Soft reset of ACP */
384 val
= acp_reg_read(acp_mmio
, mmACP_SOFT_RESET
);
386 val
|= ACP_SOFT_RESET__SoftResetAud_MASK
;
387 acp_reg_write(val
, acp_mmio
, mmACP_SOFT_RESET
);
389 count
= ACP_SOFT_RESET_DONE_TIME_OUT_VALUE
;
391 val
= acp_reg_read(acp_mmio
, mmACP_SOFT_RESET
);
392 if (ACP_SOFT_RESET__SoftResetAudDone_MASK
==
393 (val
& ACP_SOFT_RESET__SoftResetAudDone_MASK
))
396 pr_err("Failed to reset ACP\n");
402 /* Enable clock to ACP and wait until the clock is enabled */
403 val
= acp_reg_read(acp_mmio
, mmACP_CONTROL
);
404 val
= val
| ACP_CONTROL__ClkEn_MASK
;
405 acp_reg_write(val
, acp_mmio
, mmACP_CONTROL
);
407 count
= ACP_CLOCK_EN_TIME_OUT_VALUE
;
410 val
= acp_reg_read(acp_mmio
, mmACP_STATUS
);
414 pr_err("Failed to reset ACP\n");
420 /* Deassert the SOFT RESET flags */
421 val
= acp_reg_read(acp_mmio
, mmACP_SOFT_RESET
);
422 val
&= ~ACP_SOFT_RESET__SoftResetAud_MASK
;
423 acp_reg_write(val
, acp_mmio
, mmACP_SOFT_RESET
);
425 /* initiailize Onion control DAGB register */
426 acp_reg_write(ACP_ONION_CNTL_DEFAULT
, acp_mmio
,
427 mmACP_AXI2DAGB_ONION_CNTL
);
429 /* initiailize Garlic control DAGB registers */
430 acp_reg_write(ACP_GARLIC_CNTL_DEFAULT
, acp_mmio
,
431 mmACP_AXI2DAGB_GARLIC_CNTL
);
433 sram_pte_offset
= ACP_DAGB_GRP_SRAM_BASE_ADDRESS
|
434 ACP_DAGB_BASE_ADDR_GRP_1__AXI2DAGBSnoopSel_MASK
|
435 ACP_DAGB_BASE_ADDR_GRP_1__AXI2DAGBTargetMemSel_MASK
|
436 ACP_DAGB_BASE_ADDR_GRP_1__AXI2DAGBGrpEnable_MASK
;
437 acp_reg_write(sram_pte_offset
, acp_mmio
, mmACP_DAGB_BASE_ADDR_GRP_1
);
438 acp_reg_write(ACP_PAGE_SIZE_4K_ENABLE
, acp_mmio
,
439 mmACP_DAGB_PAGE_SIZE_GRP_1
);
441 acp_reg_write(ACP_SRAM_BASE_ADDRESS
, acp_mmio
,
442 mmACP_DMA_DESC_BASE_ADDR
);
444 /* Num of descriptiors in SRAM 0x4, means 256 descriptors;(64 * 4) */
445 acp_reg_write(0x4, acp_mmio
, mmACP_DMA_DESC_MAX_NUM_DSCR
);
446 acp_reg_write(ACP_EXTERNAL_INTR_CNTL__DMAIOCMask_MASK
,
447 acp_mmio
, mmACP_EXTERNAL_INTR_CNTL
);
452 /* Deintialize ACP */
453 static int acp_deinit(void __iomem
*acp_mmio
)
458 /* Assert Soft reset of ACP */
459 val
= acp_reg_read(acp_mmio
, mmACP_SOFT_RESET
);
461 val
|= ACP_SOFT_RESET__SoftResetAud_MASK
;
462 acp_reg_write(val
, acp_mmio
, mmACP_SOFT_RESET
);
464 count
= ACP_SOFT_RESET_DONE_TIME_OUT_VALUE
;
466 val
= acp_reg_read(acp_mmio
, mmACP_SOFT_RESET
);
467 if (ACP_SOFT_RESET__SoftResetAudDone_MASK
==
468 (val
& ACP_SOFT_RESET__SoftResetAudDone_MASK
))
471 pr_err("Failed to reset ACP\n");
476 /** Disable ACP clock */
477 val
= acp_reg_read(acp_mmio
, mmACP_CONTROL
);
478 val
&= ~ACP_CONTROL__ClkEn_MASK
;
479 acp_reg_write(val
, acp_mmio
, mmACP_CONTROL
);
481 count
= ACP_CLOCK_EN_TIME_OUT_VALUE
;
484 val
= acp_reg_read(acp_mmio
, mmACP_STATUS
);
485 if (!(val
& (u32
) 0x1))
488 pr_err("Failed to reset ACP\n");
496 /* ACP DMA irq handler routine for playback, capture usecases */
497 static irqreturn_t
dma_irq_handler(int irq
, void *arg
)
500 u32 intr_flag
, ext_intr_status
;
501 struct audio_drv_data
*irq_data
;
502 void __iomem
*acp_mmio
;
503 struct device
*dev
= arg
;
504 bool valid_irq
= false;
506 irq_data
= dev_get_drvdata(dev
);
507 acp_mmio
= irq_data
->acp_mmio
;
509 ext_intr_status
= acp_reg_read(acp_mmio
, mmACP_EXTERNAL_INTR_STAT
);
510 intr_flag
= (((ext_intr_status
&
511 ACP_EXTERNAL_INTR_STAT__DMAIOCStat_MASK
) >>
512 ACP_EXTERNAL_INTR_STAT__DMAIOCStat__SHIFT
));
514 if ((intr_flag
& BIT(ACP_TO_I2S_DMA_CH_NUM
)) != 0) {
516 if (acp_reg_read(acp_mmio
, mmACP_DMA_CUR_DSCR_13
) ==
517 PLAYBACK_START_DMA_DESCR_CH13
)
518 dscr_idx
= PLAYBACK_START_DMA_DESCR_CH12
;
520 dscr_idx
= PLAYBACK_END_DMA_DESCR_CH12
;
521 config_acp_dma_channel(acp_mmio
, SYSRAM_TO_ACP_CH_NUM
, dscr_idx
,
523 acp_dma_start(acp_mmio
, SYSRAM_TO_ACP_CH_NUM
, false);
525 snd_pcm_period_elapsed(irq_data
->play_stream
);
527 acp_reg_write((intr_flag
& BIT(ACP_TO_I2S_DMA_CH_NUM
)) << 16,
528 acp_mmio
, mmACP_EXTERNAL_INTR_STAT
);
531 if ((intr_flag
& BIT(I2S_TO_ACP_DMA_CH_NUM
)) != 0) {
533 if (acp_reg_read(acp_mmio
, mmACP_DMA_CUR_DSCR_15
) ==
534 CAPTURE_START_DMA_DESCR_CH15
)
535 dscr_idx
= CAPTURE_END_DMA_DESCR_CH14
;
537 dscr_idx
= CAPTURE_START_DMA_DESCR_CH14
;
538 config_acp_dma_channel(acp_mmio
, ACP_TO_SYSRAM_CH_NUM
, dscr_idx
,
540 acp_dma_start(acp_mmio
, ACP_TO_SYSRAM_CH_NUM
, false);
542 acp_reg_write((intr_flag
& BIT(I2S_TO_ACP_DMA_CH_NUM
)) << 16,
543 acp_mmio
, mmACP_EXTERNAL_INTR_STAT
);
546 if ((intr_flag
& BIT(ACP_TO_SYSRAM_CH_NUM
)) != 0) {
548 snd_pcm_period_elapsed(irq_data
->capture_stream
);
549 acp_reg_write((intr_flag
& BIT(ACP_TO_SYSRAM_CH_NUM
)) << 16,
550 acp_mmio
, mmACP_EXTERNAL_INTR_STAT
);
559 static int acp_dma_open(struct snd_pcm_substream
*substream
)
562 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
563 struct snd_soc_pcm_runtime
*prtd
= substream
->private_data
;
564 struct audio_drv_data
*intr_data
= dev_get_drvdata(prtd
->platform
->dev
);
566 struct audio_substream_data
*adata
=
567 kzalloc(sizeof(struct audio_substream_data
), GFP_KERNEL
);
571 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
572 runtime
->hw
= acp_pcm_hardware_playback
;
574 runtime
->hw
= acp_pcm_hardware_capture
;
576 ret
= snd_pcm_hw_constraint_integer(runtime
,
577 SNDRV_PCM_HW_PARAM_PERIODS
);
579 dev_err(prtd
->platform
->dev
, "set integer constraint failed\n");
583 adata
->acp_mmio
= intr_data
->acp_mmio
;
584 runtime
->private_data
= adata
;
586 /* Enable ACP irq, when neither playback or capture streams are
587 * active by the time when a new stream is being opened.
588 * This enablement is not required for another stream, if current
589 * stream is not closed
591 if (!intr_data
->play_stream
&& !intr_data
->capture_stream
)
592 acp_reg_write(1, adata
->acp_mmio
, mmACP_EXTERNAL_INTR_ENB
);
594 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
595 intr_data
->play_stream
= substream
;
597 intr_data
->capture_stream
= substream
;
602 static int acp_dma_hw_params(struct snd_pcm_substream
*substream
,
603 struct snd_pcm_hw_params
*params
)
607 struct snd_dma_buffer
*dma_buffer
;
609 struct snd_pcm_runtime
*runtime
;
610 struct audio_substream_data
*rtd
;
612 dma_buffer
= &substream
->dma_buffer
;
614 runtime
= substream
->runtime
;
615 rtd
= runtime
->private_data
;
620 size
= params_buffer_bytes(params
);
621 status
= snd_pcm_lib_malloc_pages(substream
, size
);
625 memset(substream
->runtime
->dma_area
, 0, params_buffer_bytes(params
));
626 pg
= virt_to_page(substream
->dma_buffer
.area
);
629 /* Save for runtime private data */
631 rtd
->order
= get_order(size
);
633 /* Fill the page table entries in ACP SRAM */
636 rtd
->num_of_pages
= PAGE_ALIGN(size
) >> PAGE_SHIFT
;
637 rtd
->direction
= substream
->stream
;
639 config_acp_dma(rtd
->acp_mmio
, rtd
);
647 static int acp_dma_hw_free(struct snd_pcm_substream
*substream
)
649 return snd_pcm_lib_free_pages(substream
);
652 static snd_pcm_uframes_t
acp_dma_pointer(struct snd_pcm_substream
*substream
)
655 u32 mul
, dma_config
, period_bytes
;
658 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
659 struct audio_substream_data
*rtd
= runtime
->private_data
;
661 period_bytes
= frames_to_bytes(runtime
, runtime
->period_size
);
662 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
663 dscr
= acp_reg_read(rtd
->acp_mmio
, mmACP_DMA_CUR_DSCR_13
);
665 if (dscr
== PLAYBACK_START_DMA_DESCR_CH13
)
669 pos
= (mul
* period_bytes
);
671 dma_config
= acp_reg_read(rtd
->acp_mmio
, mmACP_DMA_CNTL_14
);
672 if (dma_config
!= 0) {
673 dscr
= acp_reg_read(rtd
->acp_mmio
,
674 mmACP_DMA_CUR_DSCR_14
);
675 if (dscr
== CAPTURE_START_DMA_DESCR_CH14
)
679 pos
= (mul
* period_bytes
);
682 if (pos
>= (2 * period_bytes
))
686 return bytes_to_frames(runtime
, pos
);
689 static int acp_dma_mmap(struct snd_pcm_substream
*substream
,
690 struct vm_area_struct
*vma
)
692 return snd_pcm_lib_default_mmap(substream
, vma
);
695 static int acp_dma_prepare(struct snd_pcm_substream
*substream
)
697 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
698 struct audio_substream_data
*rtd
= runtime
->private_data
;
700 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
701 config_acp_dma_channel(rtd
->acp_mmio
, SYSRAM_TO_ACP_CH_NUM
,
702 PLAYBACK_START_DMA_DESCR_CH12
,
703 NUM_DSCRS_PER_CHANNEL
, 0);
704 config_acp_dma_channel(rtd
->acp_mmio
, ACP_TO_I2S_DMA_CH_NUM
,
705 PLAYBACK_START_DMA_DESCR_CH13
,
706 NUM_DSCRS_PER_CHANNEL
, 0);
707 /* Fill ACP SRAM (2 periods) with zeros from System RAM
708 * which is zero-ed in hw_params
710 acp_dma_start(rtd
->acp_mmio
, SYSRAM_TO_ACP_CH_NUM
, false);
712 /* ACP SRAM (2 periods of buffer size) is intially filled with
713 * zeros. Before rendering starts, 2nd half of SRAM will be
714 * filled with valid audio data DMA'ed from first half of system
715 * RAM and 1st half of SRAM will be filled with Zeros. This is
716 * the initial scenario when redering starts from SRAM. Later
717 * on, 2nd half of system memory will be DMA'ed to 1st half of
718 * SRAM, 1st half of system memory will be DMA'ed to 2nd half of
719 * SRAM in ping-pong way till rendering stops.
721 config_acp_dma_channel(rtd
->acp_mmio
, SYSRAM_TO_ACP_CH_NUM
,
722 PLAYBACK_START_DMA_DESCR_CH12
,
725 config_acp_dma_channel(rtd
->acp_mmio
, ACP_TO_SYSRAM_CH_NUM
,
726 CAPTURE_START_DMA_DESCR_CH14
,
727 NUM_DSCRS_PER_CHANNEL
, 0);
728 config_acp_dma_channel(rtd
->acp_mmio
, I2S_TO_ACP_DMA_CH_NUM
,
729 CAPTURE_START_DMA_DESCR_CH15
,
730 NUM_DSCRS_PER_CHANNEL
, 0);
735 static int acp_dma_trigger(struct snd_pcm_substream
*substream
, int cmd
)
740 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
741 struct snd_soc_pcm_runtime
*prtd
= substream
->private_data
;
742 struct audio_substream_data
*rtd
= runtime
->private_data
;
747 case SNDRV_PCM_TRIGGER_START
:
748 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
749 case SNDRV_PCM_TRIGGER_RESUME
:
750 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
751 acp_dma_start(rtd
->acp_mmio
,
752 SYSRAM_TO_ACP_CH_NUM
, false);
753 while (acp_reg_read(rtd
->acp_mmio
, mmACP_DMA_CH_STS
) &
754 BIT(SYSRAM_TO_ACP_CH_NUM
)) {
756 dev_err(prtd
->platform
->dev
,
757 "acp dma start timeout\n");
763 acp_dma_start(rtd
->acp_mmio
,
764 ACP_TO_I2S_DMA_CH_NUM
, true);
767 acp_dma_start(rtd
->acp_mmio
,
768 I2S_TO_ACP_DMA_CH_NUM
, true);
772 case SNDRV_PCM_TRIGGER_STOP
:
773 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
774 case SNDRV_PCM_TRIGGER_SUSPEND
:
775 /* Need to stop only circular DMA channels :
776 * ACP_TO_I2S_DMA_CH_NUM / I2S_TO_ACP_DMA_CH_NUM. Non-circular
777 * channels will stopped automatically after its transfer
778 * completes : SYSRAM_TO_ACP_CH_NUM / ACP_TO_SYSRAM_CH_NUM
780 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
781 ret
= acp_dma_stop(rtd
->acp_mmio
,
782 ACP_TO_I2S_DMA_CH_NUM
);
784 ret
= acp_dma_stop(rtd
->acp_mmio
,
785 I2S_TO_ACP_DMA_CH_NUM
);
794 static int acp_dma_new(struct snd_soc_pcm_runtime
*rtd
)
796 return snd_pcm_lib_preallocate_pages_for_all(rtd
->pcm
,
802 static int acp_dma_close(struct snd_pcm_substream
*substream
)
804 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
805 struct audio_substream_data
*rtd
= runtime
->private_data
;
806 struct snd_soc_pcm_runtime
*prtd
= substream
->private_data
;
807 struct audio_drv_data
*adata
= dev_get_drvdata(prtd
->platform
->dev
);
811 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
812 adata
->play_stream
= NULL
;
814 adata
->capture_stream
= NULL
;
816 /* Disable ACP irq, when the current stream is being closed and
817 * another stream is also not active.
819 if (!adata
->play_stream
&& !adata
->capture_stream
)
820 acp_reg_write(0, adata
->acp_mmio
, mmACP_EXTERNAL_INTR_ENB
);
825 static struct snd_pcm_ops acp_dma_ops
= {
826 .open
= acp_dma_open
,
827 .close
= acp_dma_close
,
828 .ioctl
= snd_pcm_lib_ioctl
,
829 .hw_params
= acp_dma_hw_params
,
830 .hw_free
= acp_dma_hw_free
,
831 .trigger
= acp_dma_trigger
,
832 .pointer
= acp_dma_pointer
,
833 .mmap
= acp_dma_mmap
,
834 .prepare
= acp_dma_prepare
,
837 static struct snd_soc_platform_driver acp_asoc_platform
= {
839 .pcm_new
= acp_dma_new
,
842 static int acp_audio_probe(struct platform_device
*pdev
)
845 struct audio_drv_data
*audio_drv_data
;
846 struct resource
*res
;
848 audio_drv_data
= devm_kzalloc(&pdev
->dev
, sizeof(struct audio_drv_data
),
850 if (audio_drv_data
== NULL
)
853 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
854 audio_drv_data
->acp_mmio
= devm_ioremap_resource(&pdev
->dev
, res
);
856 /* The following members gets populated in device 'open'
857 * function. Till then interrupts are disabled in 'acp_init'
858 * and device doesn't generate any interrupts.
861 audio_drv_data
->play_stream
= NULL
;
862 audio_drv_data
->capture_stream
= NULL
;
864 res
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
866 dev_err(&pdev
->dev
, "IORESOURCE_IRQ FAILED\n");
870 status
= devm_request_irq(&pdev
->dev
, res
->start
, dma_irq_handler
,
871 0, "ACP_IRQ", &pdev
->dev
);
873 dev_err(&pdev
->dev
, "ACP IRQ request failed\n");
877 dev_set_drvdata(&pdev
->dev
, audio_drv_data
);
879 /* Initialize the ACP */
880 acp_init(audio_drv_data
->acp_mmio
);
882 status
= snd_soc_register_platform(&pdev
->dev
, &acp_asoc_platform
);
884 dev_err(&pdev
->dev
, "Fail to register ALSA platform device\n");
891 static int acp_audio_remove(struct platform_device
*pdev
)
893 struct audio_drv_data
*adata
= dev_get_drvdata(&pdev
->dev
);
895 acp_deinit(adata
->acp_mmio
);
896 snd_soc_unregister_platform(&pdev
->dev
);
901 static struct platform_driver acp_dma_driver
= {
902 .probe
= acp_audio_probe
,
903 .remove
= acp_audio_remove
,
905 .name
= "acp_audio_dma",
909 module_platform_driver(acp_dma_driver
);
911 MODULE_AUTHOR("Maruthi.Bayyavarapu@amd.com");
912 MODULE_DESCRIPTION("AMD ACP PCM Driver");
913 MODULE_LICENSE("GPL v2");
914 MODULE_ALIAS("platform:acp-dma-audio");