34aa972669eddd845bad0d1a4a0ba596c57234c4
[linux-2.6.git] / sound / soc / txx9 / txx9aclc.c
1 /*
2  * Generic TXx9 ACLC platform driver
3  *
4  * Copyright (C) 2009 Atsushi Nemoto
5  *
6  * Based on RBTX49xx patch from CELF patch archive.
7  * (C) Copyright TOSHIBA CORPORATION 2004-2006
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/platform_device.h>
17 #include <linux/scatterlist.h>
18 #include <linux/slab.h>
19 #include <sound/core.h>
20 #include <sound/pcm.h>
21 #include <sound/pcm_params.h>
22 #include <sound/soc.h>
23 #include "txx9aclc.h"
24
25 static struct txx9aclc_soc_device {
26         struct txx9aclc_dmadata dmadata[2];
27 } txx9aclc_soc_device;
28
29 /* REVISIT: How to find txx9aclc_drvdata from snd_ac97? */
30 static struct txx9aclc_plat_drvdata *txx9aclc_drvdata;
31
32 static int txx9aclc_dma_init(struct txx9aclc_soc_device *dev,
33                              struct txx9aclc_dmadata *dmadata);
34
35 static const struct snd_pcm_hardware txx9aclc_pcm_hardware = {
36         /*
37          * REVISIT: SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
38          * needs more works for noncoherent MIPS.
39          */
40         .info             = SNDRV_PCM_INFO_INTERLEAVED |
41                             SNDRV_PCM_INFO_BATCH |
42                             SNDRV_PCM_INFO_PAUSE,
43 #ifdef __BIG_ENDIAN
44         .formats          = SNDRV_PCM_FMTBIT_S16_BE,
45 #else
46         .formats          = SNDRV_PCM_FMTBIT_S16_LE,
47 #endif
48         .period_bytes_min = 1024,
49         .period_bytes_max = 8 * 1024,
50         .periods_min      = 2,
51         .periods_max      = 4096,
52         .buffer_bytes_max = 32 * 1024,
53 };
54
55 static int txx9aclc_pcm_hw_params(struct snd_pcm_substream *substream,
56                                   struct snd_pcm_hw_params *params)
57 {
58         struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
59         struct snd_pcm_runtime *runtime = substream->runtime;
60         struct txx9aclc_dmadata *dmadata = runtime->private_data;
61         int ret;
62
63         ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
64         if (ret < 0)
65                 return ret;
66
67         dev_dbg(rtd->platform->dev,
68                 "runtime->dma_area = %#lx dma_addr = %#lx dma_bytes = %zd "
69                 "runtime->min_align %ld\n",
70                 (unsigned long)runtime->dma_area,
71                 (unsigned long)runtime->dma_addr, runtime->dma_bytes,
72                 runtime->min_align);
73         dev_dbg(rtd->platform->dev,
74                 "periods %d period_bytes %d stream %d\n",
75                 params_periods(params), params_period_bytes(params),
76                 substream->stream);
77
78         dmadata->substream = substream;
79         dmadata->pos = 0;
80         return 0;
81 }
82
83 static int txx9aclc_pcm_hw_free(struct snd_pcm_substream *substream)
84 {
85         return snd_pcm_lib_free_pages(substream);
86 }
87
88 static int txx9aclc_pcm_prepare(struct snd_pcm_substream *substream)
89 {
90         struct snd_pcm_runtime *runtime = substream->runtime;
91         struct txx9aclc_dmadata *dmadata = runtime->private_data;
92
93         dmadata->dma_addr = runtime->dma_addr;
94         dmadata->buffer_bytes = snd_pcm_lib_buffer_bytes(substream);
95         dmadata->period_bytes = snd_pcm_lib_period_bytes(substream);
96
97         if (dmadata->buffer_bytes == dmadata->period_bytes) {
98                 dmadata->frag_bytes = dmadata->period_bytes >> 1;
99                 dmadata->frags = 2;
100         } else {
101                 dmadata->frag_bytes = dmadata->period_bytes;
102                 dmadata->frags = dmadata->buffer_bytes / dmadata->period_bytes;
103         }
104         dmadata->frag_count = 0;
105         dmadata->pos = 0;
106         return 0;
107 }
108
109 static void txx9aclc_dma_complete(void *arg)
110 {
111         struct txx9aclc_dmadata *dmadata = arg;
112         unsigned long flags;
113
114         /* dma completion handler cannot submit new operations */
115         spin_lock_irqsave(&dmadata->dma_lock, flags);
116         if (dmadata->frag_count >= 0) {
117                 dmadata->dmacount--;
118                 BUG_ON(dmadata->dmacount < 0);
119                 tasklet_schedule(&dmadata->tasklet);
120         }
121         spin_unlock_irqrestore(&dmadata->dma_lock, flags);
122 }
123
124 static struct dma_async_tx_descriptor *
125 txx9aclc_dma_submit(struct txx9aclc_dmadata *dmadata, dma_addr_t buf_dma_addr)
126 {
127         struct dma_chan *chan = dmadata->dma_chan;
128         struct dma_async_tx_descriptor *desc;
129         struct scatterlist sg;
130
131         sg_init_table(&sg, 1);
132         sg_set_page(&sg, pfn_to_page(PFN_DOWN(buf_dma_addr)),
133                     dmadata->frag_bytes, buf_dma_addr & (PAGE_SIZE - 1));
134         sg_dma_address(&sg) = buf_dma_addr;
135         desc = chan->device->device_prep_slave_sg(chan, &sg, 1,
136                 dmadata->substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
137                 DMA_TO_DEVICE : DMA_FROM_DEVICE,
138                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
139         if (!desc) {
140                 dev_err(&chan->dev->device, "cannot prepare slave dma\n");
141                 return NULL;
142         }
143         desc->callback = txx9aclc_dma_complete;
144         desc->callback_param = dmadata;
145         desc->tx_submit(desc);
146         return desc;
147 }
148
149 #define NR_DMA_CHAIN            2
150
151 static void txx9aclc_dma_tasklet(unsigned long data)
152 {
153         struct txx9aclc_dmadata *dmadata = (struct txx9aclc_dmadata *)data;
154         struct dma_chan *chan = dmadata->dma_chan;
155         struct dma_async_tx_descriptor *desc;
156         struct snd_pcm_substream *substream = dmadata->substream;
157         u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
158                 ACCTL_AUDODMA : ACCTL_AUDIDMA;
159         int i;
160         unsigned long flags;
161
162         spin_lock_irqsave(&dmadata->dma_lock, flags);
163         if (dmadata->frag_count < 0) {
164                 struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata;
165                 void __iomem *base = drvdata->base;
166
167                 spin_unlock_irqrestore(&dmadata->dma_lock, flags);
168                 chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
169                 /* first time */
170                 for (i = 0; i < NR_DMA_CHAIN; i++) {
171                         desc = txx9aclc_dma_submit(dmadata,
172                                 dmadata->dma_addr + i * dmadata->frag_bytes);
173                         if (!desc)
174                                 return;
175                 }
176                 dmadata->dmacount = NR_DMA_CHAIN;
177                 chan->device->device_issue_pending(chan);
178                 spin_lock_irqsave(&dmadata->dma_lock, flags);
179                 __raw_writel(ctlbit, base + ACCTLEN);
180                 dmadata->frag_count = NR_DMA_CHAIN % dmadata->frags;
181                 spin_unlock_irqrestore(&dmadata->dma_lock, flags);
182                 return;
183         }
184         BUG_ON(dmadata->dmacount >= NR_DMA_CHAIN);
185         while (dmadata->dmacount < NR_DMA_CHAIN) {
186                 dmadata->dmacount++;
187                 spin_unlock_irqrestore(&dmadata->dma_lock, flags);
188                 desc = txx9aclc_dma_submit(dmadata,
189                         dmadata->dma_addr +
190                         dmadata->frag_count * dmadata->frag_bytes);
191                 if (!desc)
192                         return;
193                 chan->device->device_issue_pending(chan);
194
195                 spin_lock_irqsave(&dmadata->dma_lock, flags);
196                 dmadata->frag_count++;
197                 dmadata->frag_count %= dmadata->frags;
198                 dmadata->pos += dmadata->frag_bytes;
199                 dmadata->pos %= dmadata->buffer_bytes;
200                 if ((dmadata->frag_count * dmadata->frag_bytes) %
201                     dmadata->period_bytes == 0)
202                         snd_pcm_period_elapsed(substream);
203         }
204         spin_unlock_irqrestore(&dmadata->dma_lock, flags);
205 }
206
207 static int txx9aclc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
208 {
209         struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
210         struct txx9aclc_plat_drvdata *drvdata =txx9aclc_drvdata;
211         void __iomem *base = drvdata->base;
212         unsigned long flags;
213         int ret = 0;
214         u32 ctlbit = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
215                 ACCTL_AUDODMA : ACCTL_AUDIDMA;
216
217         spin_lock_irqsave(&dmadata->dma_lock, flags);
218         switch (cmd) {
219         case SNDRV_PCM_TRIGGER_START:
220                 dmadata->frag_count = -1;
221                 tasklet_schedule(&dmadata->tasklet);
222                 break;
223         case SNDRV_PCM_TRIGGER_STOP:
224         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
225         case SNDRV_PCM_TRIGGER_SUSPEND:
226                 __raw_writel(ctlbit, base + ACCTLDIS);
227                 break;
228         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
229         case SNDRV_PCM_TRIGGER_RESUME:
230                 __raw_writel(ctlbit, base + ACCTLEN);
231                 break;
232         default:
233                 ret = -EINVAL;
234         }
235         spin_unlock_irqrestore(&dmadata->dma_lock, flags);
236         return ret;
237 }
238
239 static snd_pcm_uframes_t
240 txx9aclc_pcm_pointer(struct snd_pcm_substream *substream)
241 {
242         struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
243
244         return bytes_to_frames(substream->runtime, dmadata->pos);
245 }
246
247 static int txx9aclc_pcm_open(struct snd_pcm_substream *substream)
248 {
249         struct txx9aclc_soc_device *dev = &txx9aclc_soc_device;
250         struct txx9aclc_dmadata *dmadata = &dev->dmadata[substream->stream];
251         int ret;
252
253         ret = snd_soc_set_runtime_hwparams(substream, &txx9aclc_pcm_hardware);
254         if (ret)
255                 return ret;
256         /* ensure that buffer size is a multiple of period size */
257         ret = snd_pcm_hw_constraint_integer(substream->runtime,
258                                             SNDRV_PCM_HW_PARAM_PERIODS);
259         if (ret < 0)
260                 return ret;
261         substream->runtime->private_data = dmadata;
262         return 0;
263 }
264
265 static int txx9aclc_pcm_close(struct snd_pcm_substream *substream)
266 {
267         struct txx9aclc_dmadata *dmadata = substream->runtime->private_data;
268         struct dma_chan *chan = dmadata->dma_chan;
269
270         dmadata->frag_count = -1;
271         chan->device->device_control(chan, DMA_TERMINATE_ALL, 0);
272         return 0;
273 }
274
275 static struct snd_pcm_ops txx9aclc_pcm_ops = {
276         .open           = txx9aclc_pcm_open,
277         .close          = txx9aclc_pcm_close,
278         .ioctl          = snd_pcm_lib_ioctl,
279         .hw_params      = txx9aclc_pcm_hw_params,
280         .hw_free        = txx9aclc_pcm_hw_free,
281         .prepare        = txx9aclc_pcm_prepare,
282         .trigger        = txx9aclc_pcm_trigger,
283         .pointer        = txx9aclc_pcm_pointer,
284 };
285
286 static void txx9aclc_pcm_free_dma_buffers(struct snd_pcm *pcm)
287 {
288         snd_pcm_lib_preallocate_free_for_all(pcm);
289 }
290
291 static int txx9aclc_pcm_new(struct snd_soc_pcm_runtime *rtd)
292 {
293         struct snd_soc_dai *dai = rtd->cpu_dai;
294         struct snd_pcm *pcm = rtd->pcm;
295         struct platform_device *pdev = to_platform_device(dai->platform->dev);
296         struct txx9aclc_soc_device *dev;
297         struct resource *r;
298         int i;
299         int ret;
300
301         /* at this point onwards the AC97 component has probed and this will be valid */
302         dev = snd_soc_dai_get_drvdata(dai);
303
304         dev->dmadata[0].stream = SNDRV_PCM_STREAM_PLAYBACK;
305         dev->dmadata[1].stream = SNDRV_PCM_STREAM_CAPTURE;
306         for (i = 0; i < 2; i++) {
307                 r = platform_get_resource(pdev, IORESOURCE_DMA, i);
308                 if (!r) {
309                         ret = -EBUSY;
310                         goto exit;
311                 }
312                 dev->dmadata[i].dma_res = r;
313                 ret = txx9aclc_dma_init(dev, &dev->dmadata[i]);
314                 if (ret)
315                         goto exit;
316         }
317         return snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
318                 card->dev, 64 * 1024, 4 * 1024 * 1024);
319
320 exit:
321         for (i = 0; i < 2; i++) {
322                 if (dev->dmadata[i].dma_chan)
323                         dma_release_channel(dev->dmadata[i].dma_chan);
324                 dev->dmadata[i].dma_chan = NULL;
325         }
326         return ret;
327 }
328
329 static bool filter(struct dma_chan *chan, void *param)
330 {
331         struct txx9aclc_dmadata *dmadata = param;
332         char *devname;
333         bool found = false;
334
335         devname = kasprintf(GFP_KERNEL, "%s.%d", dmadata->dma_res->name,
336                 (int)dmadata->dma_res->start);
337         if (strcmp(dev_name(chan->device->dev), devname) == 0) {
338                 chan->private = &dmadata->dma_slave;
339                 found = true;
340         }
341         kfree(devname);
342         return found;
343 }
344
345 static int txx9aclc_dma_init(struct txx9aclc_soc_device *dev,
346                              struct txx9aclc_dmadata *dmadata)
347 {
348         struct txx9aclc_plat_drvdata *drvdata =txx9aclc_drvdata;
349         struct txx9dmac_slave *ds = &dmadata->dma_slave;
350         dma_cap_mask_t mask;
351
352         spin_lock_init(&dmadata->dma_lock);
353
354         ds->reg_width = sizeof(u32);
355         if (dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK) {
356                 ds->tx_reg = drvdata->physbase + ACAUDODAT;
357                 ds->rx_reg = 0;
358         } else {
359                 ds->tx_reg = 0;
360                 ds->rx_reg = drvdata->physbase + ACAUDIDAT;
361         }
362
363         /* Try to grab a DMA channel */
364         dma_cap_zero(mask);
365         dma_cap_set(DMA_SLAVE, mask);
366         dmadata->dma_chan = dma_request_channel(mask, filter, dmadata);
367         if (!dmadata->dma_chan) {
368                 printk(KERN_ERR
369                         "DMA channel for %s is not available\n",
370                         dmadata->stream == SNDRV_PCM_STREAM_PLAYBACK ?
371                         "playback" : "capture");
372                 return -EBUSY;
373         }
374         tasklet_init(&dmadata->tasklet, txx9aclc_dma_tasklet,
375                      (unsigned long)dmadata);
376         return 0;
377 }
378
379 static int txx9aclc_pcm_probe(struct snd_soc_platform *platform)
380 {
381         snd_soc_platform_set_drvdata(platform, &txx9aclc_soc_device);
382         return 0;
383 }
384
385 static int txx9aclc_pcm_remove(struct snd_soc_platform *platform)
386 {
387         struct txx9aclc_soc_device *dev = snd_soc_platform_get_drvdata(platform);
388         struct txx9aclc_plat_drvdata *drvdata = txx9aclc_drvdata;
389         void __iomem *base = drvdata->base;
390         int i;
391
392         /* disable all FIFO DMAs */
393         __raw_writel(ACCTL_AUDODMA | ACCTL_AUDIDMA, base + ACCTLDIS);
394         /* dummy R/W to clear pending DMAREQ if any */
395         __raw_writel(__raw_readl(base + ACAUDIDAT), base + ACAUDODAT);
396
397         for (i = 0; i < 2; i++) {
398                 struct txx9aclc_dmadata *dmadata = &dev->dmadata[i];
399                 struct dma_chan *chan = dmadata->dma_chan;
400                 if (chan) {
401                         dmadata->frag_count = -1;
402                         chan->device->device_control(chan,
403                                                      DMA_TERMINATE_ALL, 0);
404                         dma_release_channel(chan);
405                 }
406                 dev->dmadata[i].dma_chan = NULL;
407         }
408         return 0;
409 }
410
411 static struct snd_soc_platform_driver txx9aclc_soc_platform = {
412         .probe          = txx9aclc_pcm_probe,
413         .remove         = txx9aclc_pcm_remove,
414         .ops            = &txx9aclc_pcm_ops,
415         .pcm_new        = txx9aclc_pcm_new,
416         .pcm_free       = txx9aclc_pcm_free_dma_buffers,
417 };
418
419 static int __devinit txx9aclc_soc_platform_probe(struct platform_device *pdev)
420 {
421         return snd_soc_register_platform(&pdev->dev, &txx9aclc_soc_platform);
422 }
423
424 static int __devexit txx9aclc_soc_platform_remove(struct platform_device *pdev)
425 {
426         snd_soc_unregister_platform(&pdev->dev);
427         return 0;
428 }
429
430 static struct platform_driver txx9aclc_pcm_driver = {
431         .driver = {
432                         .name = "txx9aclc-pcm-audio",
433                         .owner = THIS_MODULE,
434         },
435
436         .probe = txx9aclc_soc_platform_probe,
437         .remove = __devexit_p(txx9aclc_soc_platform_remove),
438 };
439
440 static int __init snd_txx9aclc_pcm_init(void)
441 {
442         return platform_driver_register(&txx9aclc_pcm_driver);
443 }
444 module_init(snd_txx9aclc_pcm_init);
445
446 static void __exit snd_txx9aclc_pcm_exit(void)
447 {
448         platform_driver_unregister(&txx9aclc_pcm_driver);
449 }
450 module_exit(snd_txx9aclc_pcm_exit);
451
452 MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
453 MODULE_DESCRIPTION("TXx9 ACLC Audio DMA driver");
454 MODULE_LICENSE("GPL");