~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/au1x/dma.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-only
  2 /*
  3  * Au1000/Au1500/Au1100 Audio DMA support.
  4  *
  5  * (c) 2011 Manuel Lauss <manuel.lauss@googlemail.com>
  6  *
  7  * copied almost verbatim from the old ALSA driver, written by
  8  *                      Charles Eidsness <charles@cooper-street.com>
  9  */
 10 
 11 #include <linux/module.h>
 12 #include <linux/init.h>
 13 #include <linux/platform_device.h>
 14 #include <linux/slab.h>
 15 #include <linux/dma-mapping.h>
 16 #include <sound/core.h>
 17 #include <sound/pcm.h>
 18 #include <sound/pcm_params.h>
 19 #include <sound/soc.h>
 20 #include <asm/mach-au1x00/au1000.h>
 21 #include <asm/mach-au1x00/au1000_dma.h>
 22 
 23 #include "psc.h"
 24 
 25 #define DRV_NAME "au1x_dma"
 26 
 27 struct pcm_period {
 28         u32 start;
 29         u32 relative_end;       /* relative to start of buffer */
 30         struct pcm_period *next;
 31 };
 32 
 33 struct audio_stream {
 34         struct snd_pcm_substream *substream;
 35         int dma;
 36         struct pcm_period *buffer;
 37         unsigned int period_size;
 38         unsigned int periods;
 39 };
 40 
 41 struct alchemy_pcm_ctx {
 42         struct audio_stream stream[2];  /* playback & capture */
 43 };
 44 
 45 static void au1000_release_dma_link(struct audio_stream *stream)
 46 {
 47         struct pcm_period *pointer;
 48         struct pcm_period *pointer_next;
 49 
 50         stream->period_size = 0;
 51         stream->periods = 0;
 52         pointer = stream->buffer;
 53         if (!pointer)
 54                 return;
 55         do {
 56                 pointer_next = pointer->next;
 57                 kfree(pointer);
 58                 pointer = pointer_next;
 59         } while (pointer != stream->buffer);
 60         stream->buffer = NULL;
 61 }
 62 
 63 static int au1000_setup_dma_link(struct audio_stream *stream,
 64                                  unsigned int period_bytes,
 65                                  unsigned int periods)
 66 {
 67         struct snd_pcm_substream *substream = stream->substream;
 68         struct snd_pcm_runtime *runtime = substream->runtime;
 69         struct pcm_period *pointer;
 70         unsigned long dma_start;
 71         int i;
 72 
 73         dma_start = virt_to_phys(runtime->dma_area);
 74 
 75         if (stream->period_size == period_bytes &&
 76             stream->periods == periods)
 77                 return 0; /* not changed */
 78 
 79         au1000_release_dma_link(stream);
 80 
 81         stream->period_size = period_bytes;
 82         stream->periods = periods;
 83 
 84         stream->buffer = kmalloc(sizeof(struct pcm_period), GFP_KERNEL);
 85         if (!stream->buffer)
 86                 return -ENOMEM;
 87         pointer = stream->buffer;
 88         for (i = 0; i < periods; i++) {
 89                 pointer->start = (u32)(dma_start + (i * period_bytes));
 90                 pointer->relative_end = (u32) (((i+1) * period_bytes) - 0x1);
 91                 if (i < periods - 1) {
 92                         pointer->next = kmalloc(sizeof(struct pcm_period),
 93                                                 GFP_KERNEL);
 94                         if (!pointer->next) {
 95                                 au1000_release_dma_link(stream);
 96                                 return -ENOMEM;
 97                         }
 98                         pointer = pointer->next;
 99                 }
100         }
101         pointer->next = stream->buffer;
102         return 0;
103 }
104 
105 static void au1000_dma_stop(struct audio_stream *stream)
106 {
107         if (stream->buffer)
108                 disable_dma(stream->dma);
109 }
110 
111 static void au1000_dma_start(struct audio_stream *stream)
112 {
113         if (!stream->buffer)
114                 return;
115 
116         init_dma(stream->dma);
117         if (get_dma_active_buffer(stream->dma) == 0) {
118                 clear_dma_done0(stream->dma);
119                 set_dma_addr0(stream->dma, stream->buffer->start);
120                 set_dma_count0(stream->dma, stream->period_size >> 1);
121                 set_dma_addr1(stream->dma, stream->buffer->next->start);
122                 set_dma_count1(stream->dma, stream->period_size >> 1);
123         } else {
124                 clear_dma_done1(stream->dma);
125                 set_dma_addr1(stream->dma, stream->buffer->start);
126                 set_dma_count1(stream->dma, stream->period_size >> 1);
127                 set_dma_addr0(stream->dma, stream->buffer->next->start);
128                 set_dma_count0(stream->dma, stream->period_size >> 1);
129         }
130         enable_dma_buffers(stream->dma);
131         start_dma(stream->dma);
132 }
133 
134 static irqreturn_t au1000_dma_interrupt(int irq, void *ptr)
135 {
136         struct audio_stream *stream = (struct audio_stream *)ptr;
137         struct snd_pcm_substream *substream = stream->substream;
138 
139         switch (get_dma_buffer_done(stream->dma)) {
140         case DMA_D0:
141                 stream->buffer = stream->buffer->next;
142                 clear_dma_done0(stream->dma);
143                 set_dma_addr0(stream->dma, stream->buffer->next->start);
144                 set_dma_count0(stream->dma, stream->period_size >> 1);
145                 enable_dma_buffer0(stream->dma);
146                 break;
147         case DMA_D1:
148                 stream->buffer = stream->buffer->next;
149                 clear_dma_done1(stream->dma);
150                 set_dma_addr1(stream->dma, stream->buffer->next->start);
151                 set_dma_count1(stream->dma, stream->period_size >> 1);
152                 enable_dma_buffer1(stream->dma);
153                 break;
154         case (DMA_D0 | DMA_D1):
155                 pr_debug("DMA %d missed interrupt.\n", stream->dma);
156                 au1000_dma_stop(stream);
157                 au1000_dma_start(stream);
158                 break;
159         case (~DMA_D0 & ~DMA_D1):
160                 pr_debug("DMA %d empty irq.\n", stream->dma);
161         }
162         snd_pcm_period_elapsed(substream);
163         return IRQ_HANDLED;
164 }
165 
166 static const struct snd_pcm_hardware alchemy_pcm_hardware = {
167         .info             = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
168                             SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BATCH,
169         .period_bytes_min = 1024,
170         .period_bytes_max = 16 * 1024 - 1,
171         .periods_min      = 4,
172         .periods_max      = 255,
173         .buffer_bytes_max = 128 * 1024,
174         .fifo_size        = 16,
175 };
176 
177 static inline struct alchemy_pcm_ctx *ss_to_ctx(struct snd_pcm_substream *ss)
178 {
179         struct snd_soc_pcm_runtime *rtd = ss->private_data;
180         struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
181         return snd_soc_component_get_drvdata(component);
182 }
183 
184 static inline struct audio_stream *ss_to_as(struct snd_pcm_substream *ss)
185 {
186         struct alchemy_pcm_ctx *ctx = ss_to_ctx(ss);
187         return &(ctx->stream[ss->stream]);
188 }
189 
190 static int alchemy_pcm_open(struct snd_pcm_substream *substream)
191 {
192         struct alchemy_pcm_ctx *ctx = ss_to_ctx(substream);
193         struct snd_soc_pcm_runtime *rtd = substream->private_data;
194         int *dmaids, s = substream->stream;
195         char *name;
196 
197         dmaids = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
198         if (!dmaids)
199                 return -ENODEV; /* whoa, has ordering changed? */
200 
201         /* DMA setup */
202         name = (s == SNDRV_PCM_STREAM_PLAYBACK) ? "audio-tx" : "audio-rx";
203         ctx->stream[s].dma = request_au1000_dma(dmaids[s], name,
204                                         au1000_dma_interrupt, 0,
205                                         &ctx->stream[s]);
206         set_dma_mode(ctx->stream[s].dma,
207                      get_dma_mode(ctx->stream[s].dma) & ~DMA_NC);
208 
209         ctx->stream[s].substream = substream;
210         ctx->stream[s].buffer = NULL;
211         snd_soc_set_runtime_hwparams(substream, &alchemy_pcm_hardware);
212 
213         return 0;
214 }
215 
216 static int alchemy_pcm_close(struct snd_pcm_substream *substream)
217 {
218         struct alchemy_pcm_ctx *ctx = ss_to_ctx(substream);
219         int stype = substream->stream;
220 
221         ctx->stream[stype].substream = NULL;
222         free_au1000_dma(ctx->stream[stype].dma);
223 
224         return 0;
225 }
226 
227 static int alchemy_pcm_hw_params(struct snd_pcm_substream *substream,
228                                  struct snd_pcm_hw_params *hw_params)
229 {
230         struct audio_stream *stream = ss_to_as(substream);
231         int err;
232 
233         err = snd_pcm_lib_malloc_pages(substream,
234                                        params_buffer_bytes(hw_params));
235         if (err < 0)
236                 return err;
237         err = au1000_setup_dma_link(stream,
238                                     params_period_bytes(hw_params),
239                                     params_periods(hw_params));
240         if (err)
241                 snd_pcm_lib_free_pages(substream);
242 
243         return err;
244 }
245 
246 static int alchemy_pcm_hw_free(struct snd_pcm_substream *substream)
247 {
248         struct audio_stream *stream = ss_to_as(substream);
249         au1000_release_dma_link(stream);
250         return snd_pcm_lib_free_pages(substream);
251 }
252 
253 static int alchemy_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
254 {
255         struct audio_stream *stream = ss_to_as(substream);
256         int err = 0;
257 
258         switch (cmd) {
259         case SNDRV_PCM_TRIGGER_START:
260                 au1000_dma_start(stream);
261                 break;
262         case SNDRV_PCM_TRIGGER_STOP:
263                 au1000_dma_stop(stream);
264                 break;
265         default:
266                 err = -EINVAL;
267                 break;
268         }
269         return err;
270 }
271 
272 static snd_pcm_uframes_t alchemy_pcm_pointer(struct snd_pcm_substream *ss)
273 {
274         struct audio_stream *stream = ss_to_as(ss);
275         long location;
276 
277         location = get_dma_residue(stream->dma);
278         location = stream->buffer->relative_end - location;
279         if (location == -1)
280                 location = 0;
281         return bytes_to_frames(ss->runtime, location);
282 }
283 
284 static const struct snd_pcm_ops alchemy_pcm_ops = {
285         .open                   = alchemy_pcm_open,
286         .close                  = alchemy_pcm_close,
287         .ioctl                  = snd_pcm_lib_ioctl,
288         .hw_params              = alchemy_pcm_hw_params,
289         .hw_free                = alchemy_pcm_hw_free,
290         .trigger                = alchemy_pcm_trigger,
291         .pointer                = alchemy_pcm_pointer,
292 };
293 
294 static int alchemy_pcm_new(struct snd_soc_pcm_runtime *rtd)
295 {
296         struct snd_pcm *pcm = rtd->pcm;
297 
298         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
299                 snd_dma_continuous_data(GFP_KERNEL), 65536, (4096 * 1024) - 1);
300 
301         return 0;
302 }
303 
304 static struct snd_soc_component_driver alchemy_pcm_soc_component = {
305         .name           = DRV_NAME,
306         .ops            = &alchemy_pcm_ops,
307         .pcm_new        = alchemy_pcm_new,
308 };
309 
310 static int alchemy_pcm_drvprobe(struct platform_device *pdev)
311 {
312         struct alchemy_pcm_ctx *ctx;
313 
314         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
315         if (!ctx)
316                 return -ENOMEM;
317 
318         platform_set_drvdata(pdev, ctx);
319 
320         return devm_snd_soc_register_component(&pdev->dev,
321                                         &alchemy_pcm_soc_component, NULL, 0);
322 }
323 
324 static struct platform_driver alchemy_pcmdma_driver = {
325         .driver = {
326                 .name   = "alchemy-pcm-dma",
327         },
328         .probe          = alchemy_pcm_drvprobe,
329 };
330 
331 module_platform_driver(alchemy_pcmdma_driver);
332 
333 MODULE_LICENSE("GPL");
334 MODULE_DESCRIPTION("Au1000/Au1500/Au1100 Audio DMA driver");
335 MODULE_AUTHOR("Manuel Lauss");
336 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp