1
2
3
4
5#include <linux/gpio.h>
6#include <linux/clk.h>
7#include <linux/module.h>
8
9#include <sound/soc.h>
10
11#include <linux/platform_data/asoc-s3c24xx_simtec.h>
12
13#include "s3c24xx-i2s.h"
14#include "s3c24xx_simtec.h"
15
16static struct s3c24xx_audio_simtec_pdata *pdata;
17static struct clk *xtal_clk;
18
19static int spk_gain;
20static int spk_unmute;
21
22
23
24
25
26
27
28
29static int speaker_gain_get(struct snd_kcontrol *kcontrol,
30 struct snd_ctl_elem_value *ucontrol)
31{
32 ucontrol->value.integer.value[0] = spk_gain;
33 return 0;
34}
35
36
37
38
39
40static void speaker_gain_set(int value)
41{
42 gpio_set_value_cansleep(pdata->amp_gain[0], value & 1);
43 gpio_set_value_cansleep(pdata->amp_gain[1], value >> 1);
44}
45
46
47
48
49
50
51
52
53
54
55
56
57
58static int speaker_gain_put(struct snd_kcontrol *kcontrol,
59 struct snd_ctl_elem_value *ucontrol)
60{
61 int value = ucontrol->value.integer.value[0];
62
63 spk_gain = value;
64
65 if (!spk_unmute)
66 speaker_gain_set(value);
67
68 return 0;
69}
70
71static const struct snd_kcontrol_new amp_gain_controls[] = {
72 SOC_SINGLE_EXT("Speaker Gain", 0, 0, 3, 0,
73 speaker_gain_get, speaker_gain_put),
74};
75
76
77
78
79
80static void spk_unmute_state(int to)
81{
82 pr_debug("%s: to=%d\n", __func__, to);
83
84 spk_unmute = to;
85 gpio_set_value(pdata->amp_gpio, to);
86
87
88 if (to && pdata->amp_gain[0] > 0)
89 speaker_gain_set(spk_gain);
90}
91
92
93
94
95
96
97
98
99static int speaker_unmute_get(struct snd_kcontrol *kcontrol,
100 struct snd_ctl_elem_value *ucontrol)
101{
102 ucontrol->value.integer.value[0] = spk_unmute;
103 return 0;
104}
105
106
107
108
109
110
111
112
113
114static int speaker_unmute_put(struct snd_kcontrol *kcontrol,
115 struct snd_ctl_elem_value *ucontrol)
116{
117 spk_unmute_state(ucontrol->value.integer.value[0]);
118 return 0;
119}
120
121
122
123
124
125static const struct snd_kcontrol_new amp_unmute_controls[] = {
126 SOC_SINGLE_EXT("Speaker Switch", 0, 0, 1, 0,
127 speaker_unmute_get, speaker_unmute_put),
128};
129
130void simtec_audio_init(struct snd_soc_pcm_runtime *rtd)
131{
132 struct snd_soc_card *card = rtd->card;
133
134 if (pdata->amp_gpio > 0) {
135 pr_debug("%s: adding amp routes\n", __func__);
136
137 snd_soc_add_card_controls(card, amp_unmute_controls,
138 ARRAY_SIZE(amp_unmute_controls));
139 }
140
141 if (pdata->amp_gain[0] > 0) {
142 pr_debug("%s: adding amp controls\n", __func__);
143 snd_soc_add_card_controls(card, amp_gain_controls,
144 ARRAY_SIZE(amp_gain_controls));
145 }
146}
147EXPORT_SYMBOL_GPL(simtec_audio_init);
148
149#define CODEC_CLOCK 12000000
150
151
152
153
154
155
156
157
158
159static int simtec_hw_params(struct snd_pcm_substream *substream,
160 struct snd_pcm_hw_params *params)
161{
162 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
163 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
164 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
165 int ret;
166
167 ret = snd_soc_dai_set_sysclk(codec_dai, 0,
168 CODEC_CLOCK, SND_SOC_CLOCK_IN);
169 if (ret) {
170 pr_err( "%s: failed setting codec sysclk\n", __func__);
171 return ret;
172 }
173
174 if (pdata->use_mpllin) {
175 ret = snd_soc_dai_set_sysclk(cpu_dai, S3C24XX_CLKSRC_MPLL,
176 0, SND_SOC_CLOCK_OUT);
177
178 if (ret) {
179 pr_err("%s: failed to set MPLLin as clksrc\n",
180 __func__);
181 return ret;
182 }
183 }
184
185 if (pdata->output_cdclk) {
186 int cdclk_scale;
187
188 cdclk_scale = clk_get_rate(xtal_clk) / CODEC_CLOCK;
189 cdclk_scale--;
190
191 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
192 cdclk_scale);
193 }
194
195 return 0;
196}
197
198static int simtec_call_startup(struct s3c24xx_audio_simtec_pdata *pd)
199{
200
201
202
203 if (pd->startup)
204 pd->startup();
205
206 return 0;
207}
208
209static const struct snd_soc_ops simtec_snd_ops = {
210 .hw_params = simtec_hw_params,
211};
212
213
214
215
216
217
218
219
220
221static int attach_gpio_amp(struct device *dev,
222 struct s3c24xx_audio_simtec_pdata *pd)
223{
224 int ret;
225
226
227 if (pdata->amp_gain[0] > 0) {
228 ret = gpio_request(pd->amp_gain[0], "gpio-amp-gain0");
229 if (ret) {
230 dev_err(dev, "cannot get amp gpio gain0\n");
231 return ret;
232 }
233
234 ret = gpio_request(pd->amp_gain[1], "gpio-amp-gain1");
235 if (ret) {
236 dev_err(dev, "cannot get amp gpio gain1\n");
237 gpio_free(pdata->amp_gain[0]);
238 return ret;
239 }
240
241 gpio_direction_output(pd->amp_gain[0], 0);
242 gpio_direction_output(pd->amp_gain[1], 0);
243 }
244
245
246 if (pdata->amp_gpio > 0) {
247 ret = gpio_request(pd->amp_gpio, "gpio-amp");
248 if (ret) {
249 dev_err(dev, "cannot get amp gpio %d (%d)\n",
250 pd->amp_gpio, ret);
251 goto err_amp;
252 }
253
254
255 spk_unmute_state(0);
256 }
257
258 return 0;
259
260err_amp:
261 if (pd->amp_gain[0] > 0) {
262 gpio_free(pd->amp_gain[0]);
263 gpio_free(pd->amp_gain[1]);
264 }
265
266 return ret;
267}
268
269static void detach_gpio_amp(struct s3c24xx_audio_simtec_pdata *pd)
270{
271 if (pd->amp_gain[0] > 0) {
272 gpio_free(pd->amp_gain[0]);
273 gpio_free(pd->amp_gain[1]);
274 }
275
276 if (pd->amp_gpio > 0)
277 gpio_free(pd->amp_gpio);
278}
279
280#ifdef CONFIG_PM
281static int simtec_audio_resume(struct device *dev)
282{
283 simtec_call_startup(pdata);
284 return 0;
285}
286
287const struct dev_pm_ops simtec_audio_pmops = {
288 .resume = simtec_audio_resume,
289};
290EXPORT_SYMBOL_GPL(simtec_audio_pmops);
291#endif
292
293int simtec_audio_core_probe(struct platform_device *pdev,
294 struct snd_soc_card *card)
295{
296 struct platform_device *snd_dev;
297 int ret;
298
299 card->dai_link->ops = &simtec_snd_ops;
300 card->dai_link->dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
301 SND_SOC_DAIFMT_CBM_CFM;
302
303 pdata = pdev->dev.platform_data;
304 if (!pdata) {
305 dev_err(&pdev->dev, "no platform data supplied\n");
306 return -EINVAL;
307 }
308
309 simtec_call_startup(pdata);
310
311 xtal_clk = clk_get(&pdev->dev, "xtal");
312 if (IS_ERR(xtal_clk)) {
313 dev_err(&pdev->dev, "could not get clkout0\n");
314 return -EINVAL;
315 }
316
317 dev_info(&pdev->dev, "xtal rate is %ld\n", clk_get_rate(xtal_clk));
318
319 ret = attach_gpio_amp(&pdev->dev, pdata);
320 if (ret)
321 goto err_clk;
322
323 snd_dev = platform_device_alloc("soc-audio", -1);
324 if (!snd_dev) {
325 dev_err(&pdev->dev, "failed to alloc soc-audio devicec\n");
326 ret = -ENOMEM;
327 goto err_gpio;
328 }
329
330 platform_set_drvdata(snd_dev, card);
331
332 ret = platform_device_add(snd_dev);
333 if (ret) {
334 dev_err(&pdev->dev, "failed to add soc-audio dev\n");
335 goto err_pdev;
336 }
337
338 platform_set_drvdata(pdev, snd_dev);
339 return 0;
340
341err_pdev:
342 platform_device_put(snd_dev);
343
344err_gpio:
345 detach_gpio_amp(pdata);
346
347err_clk:
348 clk_put(xtal_clk);
349 return ret;
350}
351EXPORT_SYMBOL_GPL(simtec_audio_core_probe);
352
353int simtec_audio_remove(struct platform_device *pdev)
354{
355 struct platform_device *snd_dev = platform_get_drvdata(pdev);
356
357 platform_device_unregister(snd_dev);
358
359 detach_gpio_amp(pdata);
360 clk_put(xtal_clk);
361 return 0;
362}
363EXPORT_SYMBOL_GPL(simtec_audio_remove);
364
365MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
366MODULE_DESCRIPTION("ALSA SoC Simtec Audio common support");
367MODULE_LICENSE("GPL");
368