1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/slab.h>
18#include <linux/device.h>
19#include <linux/delay.h>
20#include <linux/mutex.h>
21#include <linux/suspend.h>
22#include <sound/core.h>
23#include <sound/pcm.h>
24#include <sound/initval.h>
25#include <sound/soc.h>
26#include <asm/mach-au1x00/au1000.h>
27#include <asm/mach-au1x00/au1xxx_psc.h>
28
29#include "psc.h"
30
31
32#define AC97_RW_RETRIES 5
33
34#define AC97_DIR \
35 (SND_SOC_DAIDIR_PLAYBACK | SND_SOC_DAIDIR_CAPTURE)
36
37#define AC97_RATES \
38 SNDRV_PCM_RATE_8000_48000
39
40#define AC97_FMTS \
41 (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3BE)
42
43#define AC97PCR_START(stype) \
44 ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TS : PSC_AC97PCR_RS)
45#define AC97PCR_STOP(stype) \
46 ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TP : PSC_AC97PCR_RP)
47#define AC97PCR_CLRFIFO(stype) \
48 ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97PCR_TC : PSC_AC97PCR_RC)
49
50#define AC97STAT_BUSY(stype) \
51 ((stype) == SNDRV_PCM_STREAM_PLAYBACK ? PSC_AC97STAT_TB : PSC_AC97STAT_RB)
52
53
54static struct au1xpsc_audio_data *au1xpsc_ac97_workdata;
55
56#if 0
57
58
59
60
61
62static inline struct au1xpsc_audio_data *ac97_to_pscdata(struct snd_ac97 *x)
63{
64 struct snd_soc_card *c = x->bus->card->private_data;
65 return snd_soc_dai_get_drvdata(c->rtd->cpu_dai);
66}
67
68#else
69
70#define ac97_to_pscdata(x) au1xpsc_ac97_workdata
71
72#endif
73
74
75static unsigned short au1xpsc_ac97_read(struct snd_ac97 *ac97,
76 unsigned short reg)
77{
78 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
79 unsigned short retry, tmo;
80 unsigned long data;
81
82 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
83 au_sync();
84
85 retry = AC97_RW_RETRIES;
86 do {
87 mutex_lock(&pscdata->lock);
88
89 au_writel(PSC_AC97CDC_RD | PSC_AC97CDC_INDX(reg),
90 AC97_CDC(pscdata));
91 au_sync();
92
93 tmo = 20;
94 do {
95 udelay(21);
96 if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
97 break;
98 } while (--tmo);
99
100 data = au_readl(AC97_CDC(pscdata));
101
102 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
103 au_sync();
104
105 mutex_unlock(&pscdata->lock);
106
107 if (reg != ((data >> 16) & 0x7f))
108 tmo = 1;
109
110 } while (--retry && !tmo);
111
112 return retry ? data & 0xffff : 0xffff;
113}
114
115
116static void au1xpsc_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
117 unsigned short val)
118{
119 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
120 unsigned int tmo, retry;
121
122 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
123 au_sync();
124
125 retry = AC97_RW_RETRIES;
126 do {
127 mutex_lock(&pscdata->lock);
128
129 au_writel(PSC_AC97CDC_INDX(reg) | (val & 0xffff),
130 AC97_CDC(pscdata));
131 au_sync();
132
133 tmo = 20;
134 do {
135 udelay(21);
136 if (au_readl(AC97_EVNT(pscdata)) & PSC_AC97EVNT_CD)
137 break;
138 } while (--tmo);
139
140 au_writel(PSC_AC97EVNT_CD, AC97_EVNT(pscdata));
141 au_sync();
142
143 mutex_unlock(&pscdata->lock);
144 } while (--retry && !tmo);
145}
146
147
148static void au1xpsc_ac97_warm_reset(struct snd_ac97 *ac97)
149{
150 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
151
152 au_writel(PSC_AC97RST_SNC, AC97_RST(pscdata));
153 au_sync();
154 msleep(10);
155 au_writel(0, AC97_RST(pscdata));
156 au_sync();
157}
158
159static void au1xpsc_ac97_cold_reset(struct snd_ac97 *ac97)
160{
161 struct au1xpsc_audio_data *pscdata = ac97_to_pscdata(ac97);
162 int i;
163
164
165 au_writel(0, AC97_CFG(au1xpsc_ac97_workdata));
166 au_sync();
167 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(pscdata));
168 au_sync();
169
170
171 au_writel(PSC_AC97RST_RST, AC97_RST(pscdata));
172 au_sync();
173 msleep(500);
174 au_writel(0, AC97_RST(pscdata));
175 au_sync();
176
177
178 au_writel(PSC_CTRL_ENABLE, PSC_CTRL(pscdata));
179 au_sync();
180
181
182 i = 1000;
183 while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_SR)) && (--i))
184 msleep(1);
185
186 if (i == 0) {
187 printk(KERN_ERR "au1xpsc-ac97: PSC not ready!\n");
188 return;
189 }
190
191
192 au_writel(pscdata->cfg | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
193 au_sync();
194
195
196 i = 1000;
197 while (!((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && (--i))
198 msleep(1);
199 if (i == 0)
200 printk(KERN_ERR "au1xpsc-ac97: AC97 ctrl not ready\n");
201}
202
203
204struct snd_ac97_bus_ops soc_ac97_ops = {
205 .read = au1xpsc_ac97_read,
206 .write = au1xpsc_ac97_write,
207 .reset = au1xpsc_ac97_cold_reset,
208 .warm_reset = au1xpsc_ac97_warm_reset,
209};
210EXPORT_SYMBOL_GPL(soc_ac97_ops);
211
212static int au1xpsc_ac97_hw_params(struct snd_pcm_substream *substream,
213 struct snd_pcm_hw_params *params,
214 struct snd_soc_dai *dai)
215{
216 struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
217 unsigned long r, ro, stat;
218 int chans, t, stype = substream->stream;
219
220 chans = params_channels(params);
221
222 r = ro = au_readl(AC97_CFG(pscdata));
223 stat = au_readl(AC97_STAT(pscdata));
224
225
226 if (stat & (PSC_AC97STAT_TB | PSC_AC97STAT_RB)) {
227
228 if ((PSC_AC97CFG_GET_LEN(r) != params->msbits) ||
229 (pscdata->rate != params_rate(params)))
230 return -EINVAL;
231 } else {
232
233
234 r &= ~PSC_AC97CFG_LEN_MASK;
235 r |= PSC_AC97CFG_SET_LEN(params->msbits);
236
237
238 if (stype == SNDRV_PCM_STREAM_PLAYBACK) {
239 r &= ~PSC_AC97CFG_TXSLOT_MASK;
240 r |= PSC_AC97CFG_TXSLOT_ENA(3);
241 r |= PSC_AC97CFG_TXSLOT_ENA(4);
242 } else {
243 r &= ~PSC_AC97CFG_RXSLOT_MASK;
244 r |= PSC_AC97CFG_RXSLOT_ENA(3);
245 r |= PSC_AC97CFG_RXSLOT_ENA(4);
246 }
247
248
249 if (!(r ^ ro))
250 goto out;
251
252
253 mutex_lock(&pscdata->lock);
254
255
256 au_writel(r & ~PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
257 au_sync();
258
259
260 t = 100;
261 while ((au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR) && --t)
262 msleep(1);
263
264 if (!t)
265 printk(KERN_ERR "PSC-AC97: can't disable!\n");
266
267
268 au_writel(r, AC97_CFG(pscdata));
269 au_sync();
270
271
272 au_writel(r | PSC_AC97CFG_DE_ENABLE, AC97_CFG(pscdata));
273 au_sync();
274
275
276 t = 100;
277 while ((!(au_readl(AC97_STAT(pscdata)) & PSC_AC97STAT_DR)) && --t)
278 msleep(1);
279
280 if (!t)
281 printk(KERN_ERR "PSC-AC97: can't enable!\n");
282
283 mutex_unlock(&pscdata->lock);
284
285 pscdata->cfg = r;
286 pscdata->rate = params_rate(params);
287 }
288
289out:
290 return 0;
291}
292
293static int au1xpsc_ac97_trigger(struct snd_pcm_substream *substream,
294 int cmd, struct snd_soc_dai *dai)
295{
296 struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
297 int ret, stype = substream->stream;
298
299 ret = 0;
300
301 switch (cmd) {
302 case SNDRV_PCM_TRIGGER_START:
303 case SNDRV_PCM_TRIGGER_RESUME:
304 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
305 au_sync();
306 au_writel(AC97PCR_START(stype), AC97_PCR(pscdata));
307 au_sync();
308 break;
309 case SNDRV_PCM_TRIGGER_STOP:
310 case SNDRV_PCM_TRIGGER_SUSPEND:
311 au_writel(AC97PCR_STOP(stype), AC97_PCR(pscdata));
312 au_sync();
313
314 while (au_readl(AC97_STAT(pscdata)) & AC97STAT_BUSY(stype))
315 asm volatile ("nop");
316
317 au_writel(AC97PCR_CLRFIFO(stype), AC97_PCR(pscdata));
318 au_sync();
319
320 break;
321 default:
322 ret = -EINVAL;
323 }
324 return ret;
325}
326
327static int au1xpsc_ac97_startup(struct snd_pcm_substream *substream,
328 struct snd_soc_dai *dai)
329{
330 struct au1xpsc_audio_data *pscdata = snd_soc_dai_get_drvdata(dai);
331 snd_soc_dai_set_dma_data(dai, substream, &pscdata->dmaids[0]);
332 return 0;
333}
334
335static int au1xpsc_ac97_probe(struct snd_soc_dai *dai)
336{
337 return au1xpsc_ac97_workdata ? 0 : -ENODEV;
338}
339
340static const struct snd_soc_dai_ops au1xpsc_ac97_dai_ops = {
341 .startup = au1xpsc_ac97_startup,
342 .trigger = au1xpsc_ac97_trigger,
343 .hw_params = au1xpsc_ac97_hw_params,
344};
345
346static const struct snd_soc_dai_driver au1xpsc_ac97_dai_template = {
347 .ac97_control = 1,
348 .probe = au1xpsc_ac97_probe,
349 .playback = {
350 .rates = AC97_RATES,
351 .formats = AC97_FMTS,
352 .channels_min = 2,
353 .channels_max = 2,
354 },
355 .capture = {
356 .rates = AC97_RATES,
357 .formats = AC97_FMTS,
358 .channels_min = 2,
359 .channels_max = 2,
360 },
361 .ops = &au1xpsc_ac97_dai_ops,
362};
363
364static int au1xpsc_ac97_drvprobe(struct platform_device *pdev)
365{
366 int ret;
367 struct resource *iores, *dmares;
368 unsigned long sel;
369 struct au1xpsc_audio_data *wd;
370
371 wd = devm_kzalloc(&pdev->dev, sizeof(struct au1xpsc_audio_data),
372 GFP_KERNEL);
373 if (!wd)
374 return -ENOMEM;
375
376 mutex_init(&wd->lock);
377
378 iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
379 if (!iores)
380 return -ENODEV;
381
382 if (!devm_request_mem_region(&pdev->dev, iores->start,
383 resource_size(iores),
384 pdev->name))
385 return -EBUSY;
386
387 wd->mmio = devm_ioremap(&pdev->dev, iores->start,
388 resource_size(iores));
389 if (!wd->mmio)
390 return -EBUSY;
391
392 dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
393 if (!dmares)
394 return -EBUSY;
395 wd->dmaids[SNDRV_PCM_STREAM_PLAYBACK] = dmares->start;
396
397 dmares = platform_get_resource(pdev, IORESOURCE_DMA, 1);
398 if (!dmares)
399 return -EBUSY;
400 wd->dmaids[SNDRV_PCM_STREAM_CAPTURE] = dmares->start;
401
402
403 wd->cfg = PSC_AC97CFG_RT_FIFO8 | PSC_AC97CFG_TT_FIFO8 |
404 PSC_AC97CFG_DE_ENABLE;
405
406
407 sel = au_readl(PSC_SEL(wd)) & PSC_SEL_CLK_MASK;
408 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
409 au_sync();
410 au_writel(0, PSC_SEL(wd));
411 au_sync();
412 au_writel(PSC_SEL_PS_AC97MODE | sel, PSC_SEL(wd));
413 au_sync();
414
415
416 memcpy(&wd->dai_drv, &au1xpsc_ac97_dai_template,
417 sizeof(struct snd_soc_dai_driver));
418 wd->dai_drv.name = dev_name(&pdev->dev);
419
420 platform_set_drvdata(pdev, wd);
421
422 ret = snd_soc_register_dai(&pdev->dev, &wd->dai_drv);
423 if (ret)
424 return ret;
425
426 au1xpsc_ac97_workdata = wd;
427 return 0;
428}
429
430static int au1xpsc_ac97_drvremove(struct platform_device *pdev)
431{
432 struct au1xpsc_audio_data *wd = platform_get_drvdata(pdev);
433
434 snd_soc_unregister_dai(&pdev->dev);
435
436
437 au_writel(0, AC97_CFG(wd));
438 au_sync();
439 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
440 au_sync();
441
442 au1xpsc_ac97_workdata = NULL;
443
444 return 0;
445}
446
447#ifdef CONFIG_PM
448static int au1xpsc_ac97_drvsuspend(struct device *dev)
449{
450 struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
451
452
453 wd->pm[0] = au_readl(PSC_SEL(wd));
454
455 au_writel(0, AC97_CFG(wd));
456 au_sync();
457 au_writel(PSC_CTRL_DISABLE, PSC_CTRL(wd));
458 au_sync();
459
460 return 0;
461}
462
463static int au1xpsc_ac97_drvresume(struct device *dev)
464{
465 struct au1xpsc_audio_data *wd = dev_get_drvdata(dev);
466
467
468 au_writel(wd->pm[0] | PSC_SEL_PS_AC97MODE, PSC_SEL(wd));
469 au_sync();
470
471
472
473
474
475 return 0;
476}
477
478static struct dev_pm_ops au1xpscac97_pmops = {
479 .suspend = au1xpsc_ac97_drvsuspend,
480 .resume = au1xpsc_ac97_drvresume,
481};
482
483#define AU1XPSCAC97_PMOPS &au1xpscac97_pmops
484
485#else
486
487#define AU1XPSCAC97_PMOPS NULL
488
489#endif
490
491static struct platform_driver au1xpsc_ac97_driver = {
492 .driver = {
493 .name = "au1xpsc_ac97",
494 .owner = THIS_MODULE,
495 .pm = AU1XPSCAC97_PMOPS,
496 },
497 .probe = au1xpsc_ac97_drvprobe,
498 .remove = au1xpsc_ac97_drvremove,
499};
500
501static int __init au1xpsc_ac97_load(void)
502{
503 au1xpsc_ac97_workdata = NULL;
504 return platform_driver_register(&au1xpsc_ac97_driver);
505}
506
507static void __exit au1xpsc_ac97_unload(void)
508{
509 platform_driver_unregister(&au1xpsc_ac97_driver);
510}
511
512module_init(au1xpsc_ac97_load);
513module_exit(au1xpsc_ac97_unload);
514
515MODULE_LICENSE("GPL");
516MODULE_DESCRIPTION("Au12x0/Au1550 PSC AC97 ALSA ASoC audio driver");
517MODULE_AUTHOR("Manuel Lauss");
518
519
