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

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

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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                                                 struct snd_soc_component *component)
179 {
180         return snd_soc_component_get_drvdata(component);
181 }
182 
183 static inline struct audio_stream *ss_to_as(struct snd_pcm_substream *ss,
184                                             struct snd_soc_component *component)
185 {
186         struct alchemy_pcm_ctx *ctx = ss_to_ctx(ss, component);
187         return &(ctx->stream[ss->stream]);
188 }
189 
190 static int alchemy_pcm_open(struct snd_soc_component *component,
191                             struct snd_pcm_substream *substream)
192 {
193         struct alchemy_pcm_ctx *ctx = ss_to_ctx(substream, component);
194         struct snd_soc_pcm_runtime *rtd = substream->private_data;
195         int *dmaids, s = substream->stream;
196         char *name;
197 
198         dmaids = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
199         if (!dmaids)
200                 return -ENODEV; /* whoa, has ordering changed? */
201 
202         /* DMA setup */
203         name = (s == SNDRV_PCM_STREAM_PLAYBACK) ? "audio-tx" : "audio-rx";
204         ctx->stream[s].dma = request_au1000_dma(dmaids[s], name,
205                                         au1000_dma_interrupt, 0,
206                                         &ctx->stream[s]);
207         set_dma_mode(ctx->stream[s].dma,
208                      get_dma_mode(ctx->stream[s].dma) & ~DMA_NC);
209 
210         ctx->stream[s].substream = substream;
211         ctx->stream[s].buffer = NULL;
212         snd_soc_set_runtime_hwparams(substream, &alchemy_pcm_hardware);
213 
214         return 0;
215 }
216 
217 static int alchemy_pcm_close(struct snd_soc_component *component,
218                              struct snd_pcm_substream *substream)
219 {
220         struct alchemy_pcm_ctx *ctx = ss_to_ctx(substream, component);
221         int stype = substream->stream;
222 
223         ctx->stream[stype].substream = NULL;
224         free_au1000_dma(ctx->stream[stype].dma);
225 
226         return 0;
227 }
228 
229 static int alchemy_pcm_hw_params(struct snd_soc_component *component,
230                                  struct snd_pcm_substream *substream,
231                                  struct snd_pcm_hw_params *hw_params)
232 {
233         struct audio_stream *stream = ss_to_as(substream, component);
234         int err;
235 
236         err = snd_pcm_lib_malloc_pages(substream,
237                                        params_buffer_bytes(hw_params));
238         if (err < 0)
239                 return err;
240         err = au1000_setup_dma_link(stream,
241                                     params_period_bytes(hw_params),
242                                     params_periods(hw_params));
243         if (err)
244                 snd_pcm_lib_free_pages(substream);
245 
246         return err;
247 }
248 
249 static int alchemy_pcm_hw_free(struct snd_soc_component *component,
250                                struct snd_pcm_substream *substream)
251 {
252         struct audio_stream *stream = ss_to_as(substream, component);
253         au1000_release_dma_link(stream);
254         return snd_pcm_lib_free_pages(substream);
255 }
256 
257 static int alchemy_pcm_trigger(struct snd_soc_component *component,
258                                struct snd_pcm_substream *substream, int cmd)
259 {
260         struct audio_stream *stream = ss_to_as(substream, component);
261         int err = 0;
262 
263         switch (cmd) {
264         case SNDRV_PCM_TRIGGER_START:
265                 au1000_dma_start(stream);
266                 break;
267         case SNDRV_PCM_TRIGGER_STOP:
268                 au1000_dma_stop(stream);
269                 break;
270         default:
271                 err = -EINVAL;
272                 break;
273         }
274         return err;
275 }
276 
277 static snd_pcm_uframes_t alchemy_pcm_pointer(struct snd_soc_component *component,
278                                              struct snd_pcm_substream *ss)
279 {
280         struct audio_stream *stream = ss_to_as(ss, component);
281         long location;
282 
283         location = get_dma_residue(stream->dma);
284         location = stream->buffer->relative_end - location;
285         if (location == -1)
286                 location = 0;
287         return bytes_to_frames(ss->runtime, location);
288 }
289 
290 static int alchemy_pcm_new(struct snd_soc_component *component,
291                            struct snd_soc_pcm_runtime *rtd)
292 {
293         struct snd_pcm *pcm = rtd->pcm;
294 
295         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
296                                               NULL, 65536, (4096 * 1024) - 1);
297 
298         return 0;
299 }
300 
301 static struct snd_soc_component_driver alchemy_pcm_soc_component = {
302         .name           = DRV_NAME,
303         .open           = alchemy_pcm_open,
304         .close          = alchemy_pcm_close,
305         .ioctl          = snd_soc_pcm_lib_ioctl,
306         .hw_params      = alchemy_pcm_hw_params,
307         .hw_free        = alchemy_pcm_hw_free,
308         .trigger        = alchemy_pcm_trigger,
309         .pointer        = alchemy_pcm_pointer,
310         .pcm_construct  = alchemy_pcm_new,
311 };
312 
313 static int alchemy_pcm_drvprobe(struct platform_device *pdev)
314 {
315         struct alchemy_pcm_ctx *ctx;
316 
317         ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
318         if (!ctx)
319                 return -ENOMEM;
320 
321         platform_set_drvdata(pdev, ctx);
322 
323         return devm_snd_soc_register_component(&pdev->dev,
324                                         &alchemy_pcm_soc_component, NULL, 0);
325 }
326 
327 static struct platform_driver alchemy_pcmdma_driver = {
328         .driver = {
329                 .name   = "alchemy-pcm-dma",
330         },
331         .probe          = alchemy_pcm_drvprobe,
332 };
333 
334 module_platform_driver(alchemy_pcmdma_driver);
335 
336 MODULE_LICENSE("GPL");
337 MODULE_DESCRIPTION("Au1000/Au1500/Au1100 Audio DMA driver");
338 MODULE_AUTHOR("Manuel Lauss");
339 

~ [ 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