1
2
3
4
5
6
7
8
9#include <linux/io.h>
10#include <linux/module.h>
11#include <linux/pm_runtime.h>
12#include <linux/regmap.h>
13#include <sound/soc.h>
14#include "mtk-afe-platform-driver.h"
15#include <sound/pcm_params.h>
16#include "mtk-afe-fe-dai.h"
17#include "mtk-base-afe.h"
18
19#define AFE_BASE_END_OFFSET 8
20
21static int mtk_regmap_update_bits(struct regmap *map, int reg,
22 unsigned int mask,
23 unsigned int val, int shift)
24{
25 if (reg < 0 || WARN_ON_ONCE(shift < 0))
26 return 0;
27 return regmap_update_bits(map, reg, mask << shift, val << shift);
28}
29
30static int mtk_regmap_write(struct regmap *map, int reg, unsigned int val)
31{
32 if (reg < 0)
33 return 0;
34 return regmap_write(map, reg, val);
35}
36
37int mtk_afe_fe_startup(struct snd_pcm_substream *substream,
38 struct snd_soc_dai *dai)
39{
40 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
41 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
42 struct snd_pcm_runtime *runtime = substream->runtime;
43 int memif_num = asoc_rtd_to_cpu(rtd, 0)->id;
44 struct mtk_base_afe_memif *memif = &afe->memif[memif_num];
45 const struct snd_pcm_hardware *mtk_afe_hardware = afe->mtk_afe_hardware;
46 int ret;
47
48 memif->substream = substream;
49
50 snd_pcm_hw_constraint_step(substream->runtime, 0,
51 SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
52
53 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
54 1, 0, memif->data->agent_disable_shift);
55
56 snd_soc_set_runtime_hwparams(substream, mtk_afe_hardware);
57
58
59
60
61
62
63
64 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
65 int periods_max = mtk_afe_hardware->periods_max;
66
67 ret = snd_pcm_hw_constraint_minmax(runtime,
68 SNDRV_PCM_HW_PARAM_PERIODS,
69 3, periods_max);
70 if (ret < 0) {
71 dev_err(afe->dev, "hw_constraint_minmax failed\n");
72 return ret;
73 }
74 }
75
76 ret = snd_pcm_hw_constraint_integer(runtime,
77 SNDRV_PCM_HW_PARAM_PERIODS);
78 if (ret < 0)
79 dev_err(afe->dev, "snd_pcm_hw_constraint_integer failed\n");
80
81
82 if (memif->irq_usage < 0) {
83 int irq_id = mtk_dynamic_irq_acquire(afe);
84
85 if (irq_id != afe->irqs_size) {
86
87 memif->irq_usage = irq_id;
88 } else {
89 dev_err(afe->dev, "%s() error: no more asys irq\n",
90 __func__);
91 ret = -EBUSY;
92 }
93 }
94 return ret;
95}
96EXPORT_SYMBOL_GPL(mtk_afe_fe_startup);
97
98void mtk_afe_fe_shutdown(struct snd_pcm_substream *substream,
99 struct snd_soc_dai *dai)
100{
101 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
102 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
103 struct mtk_base_afe_memif *memif = &afe->memif[asoc_rtd_to_cpu(rtd, 0)->id];
104 int irq_id;
105
106 irq_id = memif->irq_usage;
107
108 mtk_regmap_update_bits(afe->regmap, memif->data->agent_disable_reg,
109 1, 1, memif->data->agent_disable_shift);
110
111 if (!memif->const_irq) {
112 mtk_dynamic_irq_release(afe, irq_id);
113 memif->irq_usage = -1;
114 memif->substream = NULL;
115 }
116}
117EXPORT_SYMBOL_GPL(mtk_afe_fe_shutdown);
118
119int mtk_afe_fe_hw_params(struct snd_pcm_substream *substream,
120 struct snd_pcm_hw_params *params,
121 struct snd_soc_dai *dai)
122{
123 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
124 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
125 int id = asoc_rtd_to_cpu(rtd, 0)->id;
126 struct mtk_base_afe_memif *memif = &afe->memif[id];
127 int ret;
128 unsigned int channels = params_channels(params);
129 unsigned int rate = params_rate(params);
130 snd_pcm_format_t format = params_format(params);
131
132 if (afe->request_dram_resource)
133 afe->request_dram_resource(afe->dev);
134
135 dev_dbg(afe->dev, "%s(), %s, ch %d, rate %d, fmt %d, dma_addr %pad, dma_area %p, dma_bytes 0x%zx\n",
136 __func__, memif->data->name,
137 channels, rate, format,
138 &substream->runtime->dma_addr,
139 substream->runtime->dma_area,
140 substream->runtime->dma_bytes);
141
142 memset_io((void __force __iomem *)substream->runtime->dma_area, 0,
143 substream->runtime->dma_bytes);
144
145
146 ret = mtk_memif_set_addr(afe, id,
147 substream->runtime->dma_area,
148 substream->runtime->dma_addr,
149 substream->runtime->dma_bytes);
150 if (ret) {
151 dev_err(afe->dev, "%s(), error, id %d, set addr, ret %d\n",
152 __func__, id, ret);
153 return ret;
154 }
155
156
157 ret = mtk_memif_set_channel(afe, id, channels);
158 if (ret) {
159 dev_err(afe->dev, "%s(), error, id %d, set channel %d, ret %d\n",
160 __func__, id, channels, ret);
161 return ret;
162 }
163
164
165 ret = mtk_memif_set_rate_substream(substream, id, rate);
166 if (ret) {
167 dev_err(afe->dev, "%s(), error, id %d, set rate %d, ret %d\n",
168 __func__, id, rate, ret);
169 return ret;
170 }
171
172
173 ret = mtk_memif_set_format(afe, id, format);
174 if (ret) {
175 dev_err(afe->dev, "%s(), error, id %d, set format %d, ret %d\n",
176 __func__, id, format, ret);
177 return ret;
178 }
179
180 return 0;
181}
182EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_params);
183
184int mtk_afe_fe_hw_free(struct snd_pcm_substream *substream,
185 struct snd_soc_dai *dai)
186{
187 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
188
189 if (afe->release_dram_resource)
190 afe->release_dram_resource(afe->dev);
191
192 return 0;
193}
194EXPORT_SYMBOL_GPL(mtk_afe_fe_hw_free);
195
196int mtk_afe_fe_trigger(struct snd_pcm_substream *substream, int cmd,
197 struct snd_soc_dai *dai)
198{
199 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
200 struct snd_pcm_runtime * const runtime = substream->runtime;
201 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
202 int id = asoc_rtd_to_cpu(rtd, 0)->id;
203 struct mtk_base_afe_memif *memif = &afe->memif[id];
204 struct mtk_base_afe_irq *irqs = &afe->irqs[memif->irq_usage];
205 const struct mtk_base_irq_data *irq_data = irqs->irq_data;
206 unsigned int counter = runtime->period_size;
207 int fs;
208 int ret;
209
210 dev_dbg(afe->dev, "%s %s cmd=%d\n", __func__, memif->data->name, cmd);
211
212 switch (cmd) {
213 case SNDRV_PCM_TRIGGER_START:
214 case SNDRV_PCM_TRIGGER_RESUME:
215 ret = mtk_memif_set_enable(afe, id);
216 if (ret) {
217 dev_err(afe->dev, "%s(), error, id %d, memif enable, ret %d\n",
218 __func__, id, ret);
219 return ret;
220 }
221
222
223 mtk_regmap_update_bits(afe->regmap, irq_data->irq_cnt_reg,
224 irq_data->irq_cnt_maskbit, counter,
225 irq_data->irq_cnt_shift);
226
227
228 fs = afe->irq_fs(substream, runtime->rate);
229
230 if (fs < 0)
231 return -EINVAL;
232
233 mtk_regmap_update_bits(afe->regmap, irq_data->irq_fs_reg,
234 irq_data->irq_fs_maskbit, fs,
235 irq_data->irq_fs_shift);
236
237
238 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
239 1, 1, irq_data->irq_en_shift);
240
241 return 0;
242 case SNDRV_PCM_TRIGGER_STOP:
243 case SNDRV_PCM_TRIGGER_SUSPEND:
244 ret = mtk_memif_set_disable(afe, id);
245 if (ret) {
246 dev_err(afe->dev, "%s(), error, id %d, memif enable, ret %d\n",
247 __func__, id, ret);
248 }
249
250
251 mtk_regmap_update_bits(afe->regmap, irq_data->irq_en_reg,
252 1, 0, irq_data->irq_en_shift);
253
254 mtk_regmap_write(afe->regmap, irq_data->irq_clr_reg,
255 1 << irq_data->irq_clr_shift);
256 return ret;
257 default:
258 return -EINVAL;
259 }
260}
261EXPORT_SYMBOL_GPL(mtk_afe_fe_trigger);
262
263int mtk_afe_fe_prepare(struct snd_pcm_substream *substream,
264 struct snd_soc_dai *dai)
265{
266 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
267 struct mtk_base_afe *afe = snd_soc_dai_get_drvdata(dai);
268 int id = asoc_rtd_to_cpu(rtd, 0)->id;
269 int pbuf_size;
270
271 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
272 if (afe->get_memif_pbuf_size) {
273 pbuf_size = afe->get_memif_pbuf_size(substream);
274 mtk_memif_set_pbuf_size(afe, id, pbuf_size);
275 }
276 }
277 return 0;
278}
279EXPORT_SYMBOL_GPL(mtk_afe_fe_prepare);
280
281const struct snd_soc_dai_ops mtk_afe_fe_ops = {
282 .startup = mtk_afe_fe_startup,
283 .shutdown = mtk_afe_fe_shutdown,
284 .hw_params = mtk_afe_fe_hw_params,
285 .hw_free = mtk_afe_fe_hw_free,
286 .prepare = mtk_afe_fe_prepare,
287 .trigger = mtk_afe_fe_trigger,
288};
289EXPORT_SYMBOL_GPL(mtk_afe_fe_ops);
290
291static DEFINE_MUTEX(irqs_lock);
292int mtk_dynamic_irq_acquire(struct mtk_base_afe *afe)
293{
294 int i;
295
296 mutex_lock(&afe->irq_alloc_lock);
297 for (i = 0; i < afe->irqs_size; ++i) {
298 if (afe->irqs[i].irq_occupyed == 0) {
299 afe->irqs[i].irq_occupyed = 1;
300 mutex_unlock(&afe->irq_alloc_lock);
301 return i;
302 }
303 }
304 mutex_unlock(&afe->irq_alloc_lock);
305 return afe->irqs_size;
306}
307EXPORT_SYMBOL_GPL(mtk_dynamic_irq_acquire);
308
309int mtk_dynamic_irq_release(struct mtk_base_afe *afe, int irq_id)
310{
311 mutex_lock(&afe->irq_alloc_lock);
312 if (irq_id >= 0 && irq_id < afe->irqs_size) {
313 afe->irqs[irq_id].irq_occupyed = 0;
314 mutex_unlock(&afe->irq_alloc_lock);
315 return 0;
316 }
317 mutex_unlock(&afe->irq_alloc_lock);
318 return -EINVAL;
319}
320EXPORT_SYMBOL_GPL(mtk_dynamic_irq_release);
321
322int mtk_afe_suspend(struct snd_soc_component *component)
323{
324 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
325 struct device *dev = afe->dev;
326 struct regmap *regmap = afe->regmap;
327 int i;
328
329 if (pm_runtime_status_suspended(dev) || afe->suspended)
330 return 0;
331
332 if (!afe->reg_back_up)
333 afe->reg_back_up =
334 devm_kcalloc(dev, afe->reg_back_up_list_num,
335 sizeof(unsigned int), GFP_KERNEL);
336
337 if (afe->reg_back_up) {
338 for (i = 0; i < afe->reg_back_up_list_num; i++)
339 regmap_read(regmap, afe->reg_back_up_list[i],
340 &afe->reg_back_up[i]);
341 }
342
343 afe->suspended = true;
344 afe->runtime_suspend(dev);
345 return 0;
346}
347EXPORT_SYMBOL_GPL(mtk_afe_suspend);
348
349int mtk_afe_resume(struct snd_soc_component *component)
350{
351 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
352 struct device *dev = afe->dev;
353 struct regmap *regmap = afe->regmap;
354 int i = 0;
355
356 if (pm_runtime_status_suspended(dev) || !afe->suspended)
357 return 0;
358
359 afe->runtime_resume(dev);
360
361 if (!afe->reg_back_up) {
362 dev_dbg(dev, "%s no reg_backup\n", __func__);
363 } else {
364 for (i = 0; i < afe->reg_back_up_list_num; i++)
365 mtk_regmap_write(regmap, afe->reg_back_up_list[i],
366 afe->reg_back_up[i]);
367 }
368
369 afe->suspended = false;
370 return 0;
371}
372EXPORT_SYMBOL_GPL(mtk_afe_resume);
373
374int mtk_memif_set_enable(struct mtk_base_afe *afe, int id)
375{
376 struct mtk_base_afe_memif *memif = &afe->memif[id];
377
378 if (memif->data->enable_shift < 0) {
379 dev_warn(afe->dev, "%s(), error, id %d, enable_shift < 0\n",
380 __func__, id);
381 return 0;
382 }
383 return mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
384 1, 1, memif->data->enable_shift);
385}
386EXPORT_SYMBOL_GPL(mtk_memif_set_enable);
387
388int mtk_memif_set_disable(struct mtk_base_afe *afe, int id)
389{
390 struct mtk_base_afe_memif *memif = &afe->memif[id];
391
392 if (memif->data->enable_shift < 0) {
393 dev_warn(afe->dev, "%s(), error, id %d, enable_shift < 0\n",
394 __func__, id);
395 return 0;
396 }
397 return mtk_regmap_update_bits(afe->regmap, memif->data->enable_reg,
398 1, 0, memif->data->enable_shift);
399}
400EXPORT_SYMBOL_GPL(mtk_memif_set_disable);
401
402int mtk_memif_set_addr(struct mtk_base_afe *afe, int id,
403 unsigned char *dma_area,
404 dma_addr_t dma_addr,
405 size_t dma_bytes)
406{
407 struct mtk_base_afe_memif *memif = &afe->memif[id];
408 int msb_at_bit33 = upper_32_bits(dma_addr) ? 1 : 0;
409 unsigned int phys_buf_addr = lower_32_bits(dma_addr);
410 unsigned int phys_buf_addr_upper_32 = upper_32_bits(dma_addr);
411
412 memif->dma_area = dma_area;
413 memif->dma_addr = dma_addr;
414 memif->dma_bytes = dma_bytes;
415
416
417 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base,
418 phys_buf_addr);
419
420 if (memif->data->reg_ofs_end)
421 mtk_regmap_write(afe->regmap,
422 memif->data->reg_ofs_end,
423 phys_buf_addr + dma_bytes - 1);
424 else
425 mtk_regmap_write(afe->regmap,
426 memif->data->reg_ofs_base +
427 AFE_BASE_END_OFFSET,
428 phys_buf_addr + dma_bytes - 1);
429
430
431 if (memif->data->reg_ofs_base_msb) {
432 mtk_regmap_write(afe->regmap, memif->data->reg_ofs_base_msb,
433 phys_buf_addr_upper_32);
434 mtk_regmap_write(afe->regmap,
435 memif->data->reg_ofs_end_msb,
436 phys_buf_addr_upper_32);
437 }
438
439
440
441
442
443 if (memif->data->msb_reg)
444 mtk_regmap_update_bits(afe->regmap, memif->data->msb_reg,
445 1, msb_at_bit33, memif->data->msb_shift);
446
447
448 if (memif->data->msb_end_reg)
449 mtk_regmap_update_bits(afe->regmap, memif->data->msb_end_reg,
450 1, msb_at_bit33,
451 memif->data->msb_end_shift);
452
453 return 0;
454}
455EXPORT_SYMBOL_GPL(mtk_memif_set_addr);
456
457int mtk_memif_set_channel(struct mtk_base_afe *afe,
458 int id, unsigned int channel)
459{
460 struct mtk_base_afe_memif *memif = &afe->memif[id];
461 unsigned int mono;
462
463 if (memif->data->mono_shift < 0)
464 return 0;
465
466 if (memif->data->quad_ch_mask) {
467 unsigned int quad_ch = (channel == 4) ? 1 : 0;
468
469 mtk_regmap_update_bits(afe->regmap, memif->data->quad_ch_reg,
470 memif->data->quad_ch_mask,
471 quad_ch, memif->data->quad_ch_shift);
472 }
473
474 if (memif->data->mono_invert)
475 mono = (channel == 1) ? 0 : 1;
476 else
477 mono = (channel == 1) ? 1 : 0;
478
479
480 if (memif->data->int_odd_flag_reg)
481 mtk_regmap_update_bits(afe->regmap,
482 memif->data->int_odd_flag_reg,
483 1, mono,
484 memif->data->int_odd_flag_shift);
485
486 return mtk_regmap_update_bits(afe->regmap, memif->data->mono_reg,
487 1, mono, memif->data->mono_shift);
488}
489EXPORT_SYMBOL_GPL(mtk_memif_set_channel);
490
491static int mtk_memif_set_rate_fs(struct mtk_base_afe *afe,
492 int id, int fs)
493{
494 struct mtk_base_afe_memif *memif = &afe->memif[id];
495
496 if (memif->data->fs_shift >= 0)
497 mtk_regmap_update_bits(afe->regmap, memif->data->fs_reg,
498 memif->data->fs_maskbit,
499 fs, memif->data->fs_shift);
500
501 return 0;
502}
503
504int mtk_memif_set_rate(struct mtk_base_afe *afe,
505 int id, unsigned int rate)
506{
507 int fs = 0;
508
509 if (!afe->get_dai_fs) {
510 dev_err(afe->dev, "%s(), error, afe->get_dai_fs == NULL\n",
511 __func__);
512 return -EINVAL;
513 }
514
515 fs = afe->get_dai_fs(afe, id, rate);
516
517 if (fs < 0)
518 return -EINVAL;
519
520 return mtk_memif_set_rate_fs(afe, id, fs);
521}
522EXPORT_SYMBOL_GPL(mtk_memif_set_rate);
523
524int mtk_memif_set_rate_substream(struct snd_pcm_substream *substream,
525 int id, unsigned int rate)
526{
527 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
528 struct snd_soc_component *component =
529 snd_soc_rtdcom_lookup(rtd, AFE_PCM_NAME);
530 struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
531
532 int fs = 0;
533
534 if (!afe->memif_fs) {
535 dev_err(afe->dev, "%s(), error, afe->memif_fs == NULL\n",
536 __func__);
537 return -EINVAL;
538 }
539
540 fs = afe->memif_fs(substream, rate);
541
542 if (fs < 0)
543 return -EINVAL;
544
545 return mtk_memif_set_rate_fs(afe, id, fs);
546}
547EXPORT_SYMBOL_GPL(mtk_memif_set_rate_substream);
548
549int mtk_memif_set_format(struct mtk_base_afe *afe,
550 int id, snd_pcm_format_t format)
551{
552 struct mtk_base_afe_memif *memif = &afe->memif[id];
553 int hd_audio = 0;
554 int hd_align = 0;
555
556
557 switch (format) {
558 case SNDRV_PCM_FORMAT_S16_LE:
559 case SNDRV_PCM_FORMAT_U16_LE:
560 hd_audio = 0;
561 break;
562 case SNDRV_PCM_FORMAT_S32_LE:
563 case SNDRV_PCM_FORMAT_U32_LE:
564 if (afe->memif_32bit_supported) {
565 hd_audio = 2;
566 hd_align = 0;
567 } else {
568 hd_audio = 1;
569 hd_align = 1;
570 }
571 break;
572 case SNDRV_PCM_FORMAT_S24_LE:
573 case SNDRV_PCM_FORMAT_U24_LE:
574 hd_audio = 1;
575 break;
576 default:
577 dev_err(afe->dev, "%s() error: unsupported format %d\n",
578 __func__, format);
579 break;
580 }
581
582 mtk_regmap_update_bits(afe->regmap, memif->data->hd_reg,
583 0x3, hd_audio, memif->data->hd_shift);
584
585 mtk_regmap_update_bits(afe->regmap, memif->data->hd_align_reg,
586 0x1, hd_align, memif->data->hd_align_mshift);
587
588 return 0;
589}
590EXPORT_SYMBOL_GPL(mtk_memif_set_format);
591
592int mtk_memif_set_pbuf_size(struct mtk_base_afe *afe,
593 int id, int pbuf_size)
594{
595 const struct mtk_base_memif_data *memif_data = afe->memif[id].data;
596
597 if (memif_data->pbuf_mask == 0 || memif_data->minlen_mask == 0)
598 return 0;
599
600 mtk_regmap_update_bits(afe->regmap, memif_data->pbuf_reg,
601 memif_data->pbuf_mask,
602 pbuf_size, memif_data->pbuf_shift);
603
604 mtk_regmap_update_bits(afe->regmap, memif_data->minlen_reg,
605 memif_data->minlen_mask,
606 pbuf_size, memif_data->minlen_shift);
607 return 0;
608}
609EXPORT_SYMBOL_GPL(mtk_memif_set_pbuf_size);
610
611MODULE_DESCRIPTION("Mediatek simple fe dai operator");
612MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
613MODULE_LICENSE("GPL v2");
614
