1
2
3
4
5
6
7
8
9#include <linux/module.h>
10#include <linux/pm_runtime.h>
11#include <linux/regmap.h>
12#include <sound/soc.h>
13#include "mtk-afe-platform-driver.h"
14#include "mtk-afe-fe-dai.h"
15#include "mtk-base-afe.h"
16
17#define AFE_BASE_END_OFFSET 8
18
19static int mtk_regmap_update_bits(struct regmap *map, int reg,
20 unsigned int mask,
21 unsigned int val, int shift)
22{
23 if (reg < 0 || WARN_ON_ONCE(shift < 0))
24 return 0;
25 return regmap_update_bits(map, reg, mask << shift, val << shift);
26}
27
28static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val)
29{
30 if (reg < 0)
31 return 0;
32 return regmap_write(map, reg, val);
33}
34
35int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
36 struct snd_soc_dai *dai)
37{
38 struct snd_soc_pcm_runtime *rtd = substream->private_data;
39 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
40 struct snd_pcm_runtime *runtime = substream->runtime;
41 int memif_num = rtd->cpu_dai->id;
42 struct mtk_base_afe_memif *memif = &afe->memif[memif_num];
43 const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware;
44 int ret;
45
46 memif->substream = substream;
47
48 snd_pcm_hw_constraint_step(substream->runtime, 0,
49 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
50
51 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
52 1, 0, memif->data->agent_disable_shift);
53
54 snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware);
55
56
57
58
59
60
61
62 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
63 int periods_max = mtk_afe_hardware->periods_max;
64
65 ret = snd_pcm_hw_constraint_minmax(runtime,
66 SNDRV_PCM_HW_PARAM_PERIODS,
67 3, periods_max);
68 if (ret < 0) {
69 dev_err(afe->dev, "hw_constraint_minmax failed\n");
70 return ret;
71 }
72 }
73
74 ret = snd_pcm_hw_constraint_integer(runtime,
75 SNDRV_PCM_HW_PARAM_PERIODS);
76 if (ret < 0)
77 dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n");
78
79
80 if (memif->irq_usage < 0) {
81 int irq_id = mtk_dynamic_irq_acquire(afe);
82
83 if (irq_id != afe->irqs_size) {
84
85 memif->irq_usage = irq_id;
86 } else {
87 dev_err(afe->dev, "%s() error: no more asys irq\n",
88 __func__);
89 ret = -EBUSY;
90 }
91 }
92 return ret;
93}
94EXPORT_SYMBOL_GPL(mtk_afe_fe_startup);
95
96void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
97 struct snd_soc_dai *dai)
98{
99 struct snd_soc_pcm_runtime *rtd = substream->private_data;
100 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
101 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
102 int irq_id;
103
104 irq_id = memif->irq_usage;
105
106 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
107 1, 1, memif->data->agent_disable_shift);
108
109 if (!memif->const_irq) {
110 mtk_dynamic_irq_release(afe, irq_id);
111 memif->irq_usage = -1;
112 memif->substream = NULL;
113 }
114}
115EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown);
116
117int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream,
118 struct snd_pcm_hw_params *params,
119 struct snd_soc_dai *dai)
120{
121 struct snd_soc_pcm_runtime *rtd = substream->private_data;
122 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
123 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
124 int msb_at_bit33 = 0;
125 int ret, fs = 0;
126
127 ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
128 if (ret < 0)
129 return ret;
130
131 msb_at_bit33 = upper_32_bits(substream->runtime->dma_addr) ? 1 : 0;
132 memif->phys_buf_addr = lower_32_bits(substream->runtime->dma_addr);
133 memif->buffer_size = substream->runtime->dma_bytes;
134
135
136 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base,
137 memif->phys_buf_addr);
138
139 mtk_regmap_write(afe->regmap,
140 memif->data->reg_ofs_base + AFE_BASE_END_OFFSET,
141 memif->phys_buf_addr + memif->buffer_size - 1);
142
143
144 mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg,
145 1, msb_at_bit33, memif->data->msb_shift);
146
147
148 if (memif->data->mono_shift >= 0) {
149 unsigned int mono = (params_channels(params) == 1) ? 1 : 0;
150
151 mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg,
152 1, mono, memif->data->mono_shift);
153 }
154
155
156 if (memif->data->fs_shift < 0)
157 return 0;
158
159 fs = afe->memif_fs(substream, params_rate(params));
160
161 if (fs < 0)
162 return -EINVAL;
163
164 mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg,
165 memif->data->fs_maskbit, fs,
166 memif->data->fs_shift);
167
168 return 0;
169}
170EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params);
171
172int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
173 struct snd_soc_dai *dai)
174{
175 return snd_pcm_lib_free_pages(substream);
176}
177EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free);
178
179int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
180 struct snd_soc_dai *dai)
181{
182 struct snd_soc_pcm_runtime *rtd = substream->private_data;
183 struct snd_pcm_runtime * const runtime = substream->runtime;
184 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
185 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
186 struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage];
187 const struct mtk_base_irq_data *irq_data = irqs->irq_data;
188 unsigned int counter = runtime->period_size;
189 int fs;
190
191 dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd);
192
193 switch (cmd) {
194 case SNDRV_PCM_TRIGGER_START:
195 case SNDRV_PCM_TRIGGER_RESUME:
196 mtk_regmap_update_bits(afe->regmap,
197 memif->data->enable_reg,
198 1, 1, memif->data->enable_shift);
199
200
201 mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg,
202 irq_data->irq_cnt_maskbit, counter,
203 irq_data->irq_cnt_shift);
204
205
206 fs = afe->irq_fs(substream, runtime->rate);
207
208 if (fs < 0)
209 return -EINVAL;
210
211 mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg,
212 irq_data->irq_fs_maskbit, fs,
213 irq_data->irq_fs_shift);
214
215
216 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
217 1, 1, irq_data->irq_en_shift);
218
219 return 0;
220 case SNDRV_PCM_TRIGGER_STOP:
221 case SNDRV_PCM_TRIGGER_SUSPEND:
222 mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
223 1, 0, memif->data->enable_shift);
224
225 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
226 1, 0, irq_data->irq_en_shift);
227
228 mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg,
229 1 << irq_data->irq_clr_shift);
230 return 0;
231 default:
232 return -EINVAL;
233 }
234}
235EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger);
236
237int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
238 struct snd_soc_dai *dai)
239{
240 struct snd_soc_pcm_runtime *rtd = substream->private_data;
241 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
242 struct mtk_base_afe_memif *memif = &afe->memif[rtd->cpu_dai->id];
243 int hd_audio = 0;
244 int hd_align = 1;
245
246
247 switch (substream->runtime->format) {
248 case SNDRV_PCM_FORMAT_S16_LE:
249 hd_audio = 0;
250 break;
251 case SNDRV_PCM_FORMAT_S32_LE:
252 hd_audio = 1;
253 hd_align = 1;
254 break;
255 case SNDRV_PCM_FORMAT_S24_LE:
256 hd_audio = 1;
257 hd_align = 0;
258 break;
259 default:
260 dev_err(afe->dev, "%s() error: unsupported format %d\n",
261 __func__, substream->runtime->format);
262 break;
263 }
264
265 mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg,
266 1, hd_audio, memif->data->hd_shift);
267
268 mtk_regmap_update_bits(afe->regmap, memif->data->hd_align_reg,
269 1, hd_align, memif->data->hd_align_mshift);
270
271 return 0;
272}
273EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare);
274
275const struct snd_soc_dai_ops mtk_afe_fe_ops = {
276 .startup = mtk_afe_fe_startup,
277 .shutdown = mtk_afe_fe_shutdown,
278 .hw_params = mtk_afe_fe_hw_params,
279 .hw_free = mtk_afe_fe_hw_free,
280 .prepare = mtk_afe_fe_prepare,
281 .trigger = mtk_afe_fe_trigger,
282};
283EXPORT_SYMBOL_GPL(mtk_afe_fe_ops);
284
285static DEFINE_MUTEX(irqs_lock);
286int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe)
287{
288 int i;
289
290 mutex_lock(&afe->irq_alloc_lock);
291 for (i = 0; i < afe->irqs_size; ++i) {
292 if (afe->irqs[i].irq_occupyed == 0) {
293 afe->irqs[i].irq_occupyed = 1;
294 mutex_unlock(&afe->irq_alloc_lock);
295 return i;
296 }
297 }
298 mutex_unlock(&afe->irq_alloc_lock);
299 return afe->irqs_size;
300}
301EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire);
302
303int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id)
304{
305 mutex_lock(&afe->irq_alloc_lock);
306 if (irq_id >= 0 && irq_id < afe->irqs_size) {
307 afe->irqs[irq_id].irq_occupyed = 0;
308 mutex_unlock(&afe->irq_alloc_lock);
309 return 0;
310 }
311 mutex_unlock(&afe->irq_alloc_lock);
312 return -EINVAL;
313}
314EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release);
315
316int mtk_afe_dai_suspend(struct snd_soc_dai *dai)
317{
318 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
319 struct device *dev = afe->dev;
320 struct regmap *regmap = afe->regmap;
321 int i;
322
323 if (pm_runtime_status_suspended(dev) || afe->suspended)
324 return 0;
325
326 if (!afe->reg_back_up)
327 afe->reg_back_up =
328 devm_kcalloc(dev, afe->reg_back_up_list_num,
329 sizeof(unsigned int), GFP_KERNEL);
330
331 for (i = 0; i < afe->reg_back_up_list_num; i++)
332 regmap_read(regmap, afe->reg_back_up_list[i],
333 &afe->reg_back_up[i]);
334
335 afe->suspended = true;
336 afe->runtime_suspend(dev);
337 return 0;
338}
339EXPORT_SYMBOL_GPL(mtk_afe_dai_suspend);
340
341int mtk_afe_dai_resume(struct snd_soc_dai *dai)
342{
343 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
344 struct device *dev = afe->dev;
345 struct regmap *regmap = afe->regmap;
346 int i = 0;
347
348 if (pm_runtime_status_suspended(dev) || !afe->suspended)
349 return 0;
350
351 afe->runtime_resume(dev);
352
353 if (!afe->reg_back_up)
354 dev_dbg(dev, "%s no reg_backup\n", __func__);
355
356 for (i = 0; i < afe->reg_back_up_list_num; i++)
357 mtk_regmap_write(regmap, afe->reg_back_up_list[i],
358 afe->reg_back_up[i]);
359
360 afe->suspended = false;
361 return 0;
362}
363EXPORT_SYMBOL_GPL(mtk_afe_dai_resume);
364
365MODULE_DESCRIPTION("Mediatek simple fe dai operator");
366MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
367MODULE_LICENSE("GPL v2");
368
