1 // SPDX-License-Identifier: GPL-2.0+
5 #include <linux/clk-provider.h>
6 #include <linux/delay.h>
7 #include <linux/dmaengine.h>
8 #include <linux/module.h>
9 #include <linux/of_device.h>
10 #include <linux/of_address.h>
11 #include <linux/pm_runtime.h>
12 #include <linux/regmap.h>
13 #include <linux/slab.h>
14 #include <linux/time.h>
15 #include <linux/pm_qos.h>
16 #include <sound/core.h>
17 #include <sound/dmaengine_pcm.h>
18 #include <sound/pcm_params.h>
19 #include <linux/dma-mapping.h>
21 #include "fsl_aud2htx.h"
24 static int fsl_aud2htx_trigger(struct snd_pcm_substream
*substream
, int cmd
,
25 struct snd_soc_dai
*dai
)
27 struct fsl_aud2htx
*aud2htx
= snd_soc_dai_get_drvdata(dai
);
30 case SNDRV_PCM_TRIGGER_START
:
31 case SNDRV_PCM_TRIGGER_RESUME
:
32 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
33 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL
,
34 AUD2HTX_CTRL_EN
, AUD2HTX_CTRL_EN
);
35 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL_EXT
,
36 AUD2HTX_CTRE_DE
, AUD2HTX_CTRE_DE
);
38 case SNDRV_PCM_TRIGGER_SUSPEND
:
39 case SNDRV_PCM_TRIGGER_STOP
:
40 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
41 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL_EXT
,
43 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL
,
52 static const struct snd_soc_dai_ops fsl_aud2htx_dai_ops
= {
53 .trigger
= fsl_aud2htx_trigger
,
56 static int fsl_aud2htx_dai_probe(struct snd_soc_dai
*cpu_dai
)
58 struct fsl_aud2htx
*aud2htx
= dev_get_drvdata(cpu_dai
->dev
);
60 /* DMA request when number of entries < WTMK_LOW */
61 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL_EXT
,
62 AUD2HTX_CTRE_DT_MASK
, 0);
64 /* Disable interrupts*/
65 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_IRQ_MASK
,
66 AUD2HTX_WM_HIGH_IRQ_MASK
|
67 AUD2HTX_WM_LOW_IRQ_MASK
|
69 AUD2HTX_WM_HIGH_IRQ_MASK
|
70 AUD2HTX_WM_LOW_IRQ_MASK
|
73 /* Configure watermark */
74 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL_EXT
,
76 AUD2HTX_WTMK_LOW
<< AUD2HTX_CTRE_WL_SHIFT
);
77 regmap_update_bits(aud2htx
->regmap
, AUD2HTX_CTRL_EXT
,
79 AUD2HTX_WTMK_HIGH
<< AUD2HTX_CTRE_WH_SHIFT
);
81 snd_soc_dai_init_dma_data(cpu_dai
, &aud2htx
->dma_params_tx
,
82 &aud2htx
->dma_params_rx
);
87 static struct snd_soc_dai_driver fsl_aud2htx_dai
= {
88 .probe
= fsl_aud2htx_dai_probe
,
90 .stream_name
= "CPU-Playback",
93 .rates
= SNDRV_PCM_RATE_32000
|
94 SNDRV_PCM_RATE_44100
|
95 SNDRV_PCM_RATE_48000
|
96 SNDRV_PCM_RATE_88200
|
97 SNDRV_PCM_RATE_96000
|
98 SNDRV_PCM_RATE_176400
|
99 SNDRV_PCM_RATE_192000
,
100 .formats
= FSL_AUD2HTX_FORMATS
,
102 .ops
= &fsl_aud2htx_dai_ops
,
105 static const struct snd_soc_component_driver fsl_aud2htx_component
= {
106 .name
= "fsl-aud2htx",
109 static const struct reg_default fsl_aud2htx_reg_defaults
[] = {
110 {AUD2HTX_CTRL
, 0x00000000},
111 {AUD2HTX_CTRL_EXT
, 0x00000000},
112 {AUD2HTX_WR
, 0x00000000},
113 {AUD2HTX_STATUS
, 0x00000000},
114 {AUD2HTX_IRQ_NOMASK
, 0x00000000},
115 {AUD2HTX_IRQ_MASKED
, 0x00000000},
116 {AUD2HTX_IRQ_MASK
, 0x00000000},
119 static bool fsl_aud2htx_readable_reg(struct device
*dev
, unsigned int reg
)
123 case AUD2HTX_CTRL_EXT
:
125 case AUD2HTX_IRQ_NOMASK
:
126 case AUD2HTX_IRQ_MASKED
:
127 case AUD2HTX_IRQ_MASK
:
134 static bool fsl_aud2htx_writeable_reg(struct device
*dev
, unsigned int reg
)
138 case AUD2HTX_CTRL_EXT
:
140 case AUD2HTX_IRQ_NOMASK
:
141 case AUD2HTX_IRQ_MASKED
:
142 case AUD2HTX_IRQ_MASK
:
149 static bool fsl_aud2htx_volatile_reg(struct device
*dev
, unsigned int reg
)
153 case AUD2HTX_IRQ_NOMASK
:
154 case AUD2HTX_IRQ_MASKED
:
161 static const struct regmap_config fsl_aud2htx_regmap_config
= {
166 .max_register
= AUD2HTX_IRQ_MASK
,
167 .reg_defaults
= fsl_aud2htx_reg_defaults
,
168 .num_reg_defaults
= ARRAY_SIZE(fsl_aud2htx_reg_defaults
),
169 .readable_reg
= fsl_aud2htx_readable_reg
,
170 .volatile_reg
= fsl_aud2htx_volatile_reg
,
171 .writeable_reg
= fsl_aud2htx_writeable_reg
,
172 .cache_type
= REGCACHE_RBTREE
,
175 static const struct of_device_id fsl_aud2htx_dt_ids
[] = {
176 { .compatible
= "fsl,imx8mp-aud2htx",},
179 MODULE_DEVICE_TABLE(of
, fsl_aud2htx_dt_ids
);
181 static irqreturn_t
fsl_aud2htx_isr(int irq
, void *dev_id
)
186 static int fsl_aud2htx_probe(struct platform_device
*pdev
)
188 struct fsl_aud2htx
*aud2htx
;
189 struct resource
*res
;
193 aud2htx
= devm_kzalloc(&pdev
->dev
, sizeof(*aud2htx
), GFP_KERNEL
);
197 aud2htx
->pdev
= pdev
;
199 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
200 regs
= devm_ioremap_resource(&pdev
->dev
, res
);
202 dev_err(&pdev
->dev
, "failed ioremap\n");
203 return PTR_ERR(regs
);
206 aud2htx
->regmap
= devm_regmap_init_mmio(&pdev
->dev
, regs
,
207 &fsl_aud2htx_regmap_config
);
208 if (IS_ERR(aud2htx
->regmap
)) {
209 dev_err(&pdev
->dev
, "failed to init regmap");
210 return PTR_ERR(aud2htx
->regmap
);
213 irq
= platform_get_irq(pdev
, 0);
217 ret
= devm_request_irq(&pdev
->dev
, irq
, fsl_aud2htx_isr
, 0,
218 dev_name(&pdev
->dev
), aud2htx
);
220 dev_err(&pdev
->dev
, "failed to claim irq %u: %d\n", irq
, ret
);
224 aud2htx
->bus_clk
= devm_clk_get(&pdev
->dev
, "bus");
225 if (IS_ERR(aud2htx
->bus_clk
)) {
226 dev_err(&pdev
->dev
, "failed to get mem clock\n");
227 return PTR_ERR(aud2htx
->bus_clk
);
230 aud2htx
->dma_params_tx
.chan_name
= "tx";
231 aud2htx
->dma_params_tx
.maxburst
= AUD2HTX_MAXBURST
;
232 aud2htx
->dma_params_tx
.addr
= res
->start
+ AUD2HTX_WR
;
234 platform_set_drvdata(pdev
, aud2htx
);
235 pm_runtime_enable(&pdev
->dev
);
237 regcache_cache_only(aud2htx
->regmap
, true);
239 ret
= devm_snd_soc_register_component(&pdev
->dev
,
240 &fsl_aud2htx_component
,
241 &fsl_aud2htx_dai
, 1);
243 dev_err(&pdev
->dev
, "failed to register ASoC DAI\n");
247 ret
= imx_pcm_dma_init(pdev
, IMX_DEFAULT_DMABUF_SIZE
);
249 dev_err(&pdev
->dev
, "failed to init imx pcm dma: %d\n", ret
);
254 static int fsl_aud2htx_remove(struct platform_device
*pdev
)
256 pm_runtime_disable(&pdev
->dev
);
261 static int __maybe_unused
fsl_aud2htx_runtime_suspend(struct device
*dev
)
263 struct fsl_aud2htx
*aud2htx
= dev_get_drvdata(dev
);
265 regcache_cache_only(aud2htx
->regmap
, true);
266 clk_disable_unprepare(aud2htx
->bus_clk
);
271 static int __maybe_unused
fsl_aud2htx_runtime_resume(struct device
*dev
)
273 struct fsl_aud2htx
*aud2htx
= dev_get_drvdata(dev
);
276 ret
= clk_prepare_enable(aud2htx
->bus_clk
);
280 regcache_cache_only(aud2htx
->regmap
, false);
281 regcache_mark_dirty(aud2htx
->regmap
);
282 regcache_sync(aud2htx
->regmap
);
287 static const struct dev_pm_ops fsl_aud2htx_pm_ops
= {
288 SET_RUNTIME_PM_OPS(fsl_aud2htx_runtime_suspend
,
289 fsl_aud2htx_runtime_resume
,
291 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend
,
292 pm_runtime_force_resume
)
295 static struct platform_driver fsl_aud2htx_driver
= {
296 .probe
= fsl_aud2htx_probe
,
297 .remove
= fsl_aud2htx_remove
,
299 .name
= "fsl-aud2htx",
300 .pm
= &fsl_aud2htx_pm_ops
,
301 .of_match_table
= fsl_aud2htx_dt_ids
,
304 module_platform_driver(fsl_aud2htx_driver
);
306 MODULE_AUTHOR("Shengjiu Wang <Shengjiu.Wang@nxp.com>");
307 MODULE_DESCRIPTION("NXP AUD2HTX driver");
308 MODULE_LICENSE("GPL v2");