1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
// SPDX-License-Identifier: GPL-2.0
/*
* mtk-afe-platform-driver.c -- Mediatek afe platform driver
*
* Copyright (c) 2016 MediaTek Inc.
* Author: Garlic Tseng <garlic.tseng@mediatek.com>
*/
#include <linux/module.h>
#include <linux/dma-mapping.h>
#include <sound/soc.h>
#include "mtk-afe-platform-driver.h"
#include "mtk-base-afe.h"
int mtk_afe_combine_sub_dai(struct mtk_base_afe *afe)
{
struct mtk_base_afe_dai *dai;
size_t num_dai_drivers = 0, dai_idx = 0;
/* calcualte total dai driver size */
list_for_each_entry(dai, &afe->sub_dais, list) {
num_dai_drivers += dai->num_dai_drivers;
}
dev_info(afe->dev, "%s(), num of dai %zd\n", __func__, num_dai_drivers);
/* combine sub_dais */
afe->num_dai_drivers = num_dai_drivers;
afe->dai_drivers = devm_kcalloc(afe->dev,
num_dai_drivers,
sizeof(struct snd_soc_dai_driver),
GFP_KERNEL);
if (!afe->dai_drivers)
return -ENOMEM;
list_for_each_entry(dai, &afe->sub_dais, list) {
/* dai driver */
memcpy(&afe->dai_drivers[dai_idx],
dai->dai_drivers,
dai->num_dai_drivers *
sizeof(struct snd_soc_dai_driver));
dai_idx += dai->num_dai_drivers;
}
return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_combine_sub_dai);
int mtk_afe_add_sub_dai_control(struct snd_soc_component *component)
{
struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
struct mtk_base_afe_dai *dai;
list_for_each_entry(dai, &afe->sub_dais, list) {
if (dai->controls)
snd_soc_add_component_controls(component,
dai->controls,
dai->num_controls);
if (dai->dapm_widgets)
snd_soc_dapm_new_controls(dapm,
dai->dapm_widgets,
dai->num_dapm_widgets);
}
/* add routes after all widgets are added */
list_for_each_entry(dai, &afe->sub_dais, list) {
if (dai->dapm_routes)
snd_soc_dapm_add_routes(dapm,
dai->dapm_routes,
dai->num_dapm_routes);
}
snd_soc_dapm_new_widgets(component->card);
return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_add_sub_dai_control);
snd_pcm_uframes_t mtk_afe_pcm_pointer(struct snd_soc_component *component,
struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
struct mtk_base_afe_memif *memif = &afe->memif[snd_soc_rtd_to_cpu(rtd, 0)->id];
const struct mtk_base_memif_data *memif_data = memif->data;
struct regmap *regmap = afe->regmap;
struct device *dev = afe->dev;
unsigned int hw_ptr_lower32 = 0, hw_ptr_upper32 = 0;
unsigned int hw_base_lower32 = 0, hw_base_upper32 = 0;
unsigned long long hw_ptr = 0, hw_base = 0;
int ret;
unsigned long long pcm_ptr_bytes = 0;
ret = regmap_read(regmap, memif_data->reg_ofs_cur, &hw_ptr_lower32);
if (ret) {
dev_err(dev, "%s hw_ptr_lower32 err\n", __func__);
return 0;
}
if (memif_data->reg_ofs_cur_msb) {
ret = regmap_read(regmap, memif_data->reg_ofs_cur_msb, &hw_ptr_upper32);
if (ret) {
dev_err(dev, "%s hw_ptr_upper32 err\n", __func__);
return 0;
}
}
ret = regmap_read(regmap, memif_data->reg_ofs_base, &hw_base_lower32);
if (ret) {
dev_err(dev, "%s hw_base_lower32 err\n", __func__);
return 0;
}
if (memif_data->reg_ofs_base_msb) {
ret = regmap_read(regmap, memif_data->reg_ofs_base_msb, &hw_base_upper32);
if (ret) {
dev_err(dev, "%s hw_base_upper32 err\n", __func__);
return 0;
}
}
hw_ptr = ((unsigned long long)hw_ptr_upper32 << 32) | hw_ptr_lower32;
hw_base = ((unsigned long long)hw_base_upper32 << 32) | hw_base_lower32;
if (!hw_ptr || !hw_base) {
dev_err(dev, "hw_ptr or hw_base = 0 err\n");
return 0;
}
pcm_ptr_bytes = MTK_ALIGN_16BYTES(hw_ptr - hw_base);
return bytes_to_frames(substream->runtime, (ssize_t)pcm_ptr_bytes);
}
EXPORT_SYMBOL_GPL(mtk_afe_pcm_pointer);
int mtk_afe_pcm_new(struct snd_soc_component *component,
struct snd_soc_pcm_runtime *rtd)
{
size_t size;
struct snd_pcm *pcm = rtd->pcm;
struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
size = afe->mtk_afe_hardware->buffer_bytes_max;
snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, afe->dev,
afe->preallocate_buffers ? size : 0,
size);
return 0;
}
EXPORT_SYMBOL_GPL(mtk_afe_pcm_new);
static int mtk_afe_component_probe(struct snd_soc_component *component)
{
struct mtk_base_afe *afe = snd_soc_component_get_drvdata(component);
int ret;
snd_soc_component_init_regmap(component, afe->regmap);
/* If the list was never initialized there are no sub-DAIs */
if (afe->sub_dais.next && afe->sub_dais.prev) {
ret = mtk_afe_add_sub_dai_control(component);
if (ret)
return ret;
}
return 0;
}
const struct snd_soc_component_driver mtk_afe_pcm_platform = {
.name = AFE_PCM_NAME,
.pointer = mtk_afe_pcm_pointer,
.pcm_new = mtk_afe_pcm_new,
.probe = mtk_afe_component_probe,
};
EXPORT_SYMBOL_GPL(mtk_afe_pcm_platform);
MODULE_DESCRIPTION("Mediatek simple platform driver");
MODULE_AUTHOR("Garlic Tseng <garlic.tseng@mediatek.com>");
MODULE_LICENSE("GPL v2");
|
