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

TOMOYO Linux Cross Reference
Linux/sound/soc/blackfin/bf5xx-ac97-pcm.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ 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.72 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  * File:         sound/soc/blackfin/bf5xx-ac97-pcm.c
  3  * Author:       Cliff Cai <Cliff.Cai@analog.com>
  4  *
  5  * Created:      Tue June 06 2008
  6  * Description:  DMA Driver for AC97 sound chip
  7  *
  8  * Modified:
  9  *               Copyright 2008 Analog Devices Inc.
 10  *
 11  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
 12  *
 13  * This program is free software; you can redistribute it and/or modify
 14  * it under the terms of the GNU General Public License as published by
 15  * the Free Software Foundation; either version 2 of the License, or
 16  * (at your option) any later version.
 17  *
 18  * This program is distributed in the hope that it will be useful,
 19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 21  * GNU General Public License for more details.
 22  *
 23  * You should have received a copy of the GNU General Public License
 24  * along with this program; if not, see the file COPYING, or write
 25  * to the Free Software Foundation, Inc.,
 26  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 27  */
 28 
 29 #include <linux/module.h>
 30 #include <linux/init.h>
 31 #include <linux/platform_device.h>
 32 #include <linux/dma-mapping.h>
 33 #include <linux/gfp.h>
 34 
 35 #include <sound/core.h>
 36 #include <sound/pcm.h>
 37 #include <sound/pcm_params.h>
 38 #include <sound/soc.h>
 39 
 40 #include <asm/dma.h>
 41 
 42 #include "bf5xx-ac97.h"
 43 #include "bf5xx-sport.h"
 44 
 45 static unsigned int ac97_chan_mask[] = {
 46         SP_FL, /* Mono */
 47         SP_STEREO, /* Stereo */
 48         SP_2DOT1, /* 2.1*/
 49         SP_QUAD,/*Quadraquic*/
 50         SP_FL | SP_FR | SP_FC | SP_SL | SP_SR,/*5 channels */
 51         SP_5DOT1, /* 5.1 */
 52 };
 53 
 54 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
 55 static void bf5xx_mmap_copy(struct snd_pcm_substream *substream,
 56          snd_pcm_uframes_t count)
 57 {
 58         struct snd_pcm_runtime *runtime = substream->runtime;
 59         struct sport_device *sport = runtime->private_data;
 60         unsigned int chan_mask = ac97_chan_mask[runtime->channels - 1];
 61         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 62                 bf5xx_pcm_to_ac97((struct ac97_frame *)sport->tx_dma_buf +
 63                 sport->tx_pos, (__u16 *)runtime->dma_area + sport->tx_pos *
 64                 runtime->channels, count, chan_mask);
 65                 sport->tx_pos += runtime->period_size;
 66                 if (sport->tx_pos >= runtime->buffer_size)
 67                         sport->tx_pos %= runtime->buffer_size;
 68                 sport->tx_delay_pos = sport->tx_pos;
 69         } else {
 70                 bf5xx_ac97_to_pcm((struct ac97_frame *)sport->rx_dma_buf +
 71                 sport->rx_pos, (__u16 *)runtime->dma_area + sport->rx_pos *
 72                 runtime->channels, count);
 73                 sport->rx_pos += runtime->period_size;
 74                 if (sport->rx_pos >= runtime->buffer_size)
 75                         sport->rx_pos %= runtime->buffer_size;
 76         }
 77 }
 78 #endif
 79 
 80 static void bf5xx_dma_irq(void *data)
 81 {
 82         struct snd_pcm_substream *pcm = data;
 83 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
 84         struct snd_pcm_runtime *runtime = pcm->runtime;
 85         struct sport_device *sport = runtime->private_data;
 86         bf5xx_mmap_copy(pcm, runtime->period_size);
 87         if (pcm->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 88                 if (sport->once == 0) {
 89                         snd_pcm_period_elapsed(pcm);
 90                         bf5xx_mmap_copy(pcm, runtime->period_size);
 91                         sport->once = 1;
 92                 }
 93         }
 94 #endif
 95         snd_pcm_period_elapsed(pcm);
 96 }
 97 
 98 /* The memory size for pure pcm data is 128*1024 = 0x20000 bytes.
 99  * The total rx/tx buffer is for ac97 frame to hold all pcm data
100  * is  0x20000 * sizeof(struct ac97_frame) / 4.
101  */
102 static const struct snd_pcm_hardware bf5xx_pcm_hardware = {
103         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
104 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
105                                    SNDRV_PCM_INFO_MMAP |
106                                    SNDRV_PCM_INFO_MMAP_VALID |
107 #endif
108                                    SNDRV_PCM_INFO_BLOCK_TRANSFER,
109 
110         .formats                = SNDRV_PCM_FMTBIT_S16_LE,
111         .period_bytes_min       = 32,
112         .period_bytes_max       = 0x10000,
113         .periods_min            = 1,
114         .periods_max            = PAGE_SIZE/32,
115         .buffer_bytes_max       = 0x20000, /* 128 kbytes */
116         .fifo_size              = 16,
117 };
118 
119 static int bf5xx_pcm_hw_params(struct snd_pcm_substream *substream,
120         struct snd_pcm_hw_params *params)
121 {
122         size_t size = bf5xx_pcm_hardware.buffer_bytes_max
123                         * sizeof(struct ac97_frame) / 4;
124 
125         snd_pcm_lib_malloc_pages(substream, size);
126 
127         return 0;
128 }
129 
130 static int bf5xx_pcm_hw_free(struct snd_pcm_substream *substream)
131 {
132 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
133         struct snd_pcm_runtime *runtime = substream->runtime;
134         struct sport_device *sport = runtime->private_data;
135 
136         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
137                 sport->once = 0;
138                 if (runtime->dma_area)
139                         memset(runtime->dma_area, 0, runtime->buffer_size);
140                 memset(sport->tx_dma_buf, 0, runtime->buffer_size *
141                         sizeof(struct ac97_frame));
142         } else
143                 memset(sport->rx_dma_buf, 0, runtime->buffer_size *
144                         sizeof(struct ac97_frame));
145 #endif
146         snd_pcm_lib_free_pages(substream);
147         return 0;
148 }
149 
150 static int bf5xx_pcm_prepare(struct snd_pcm_substream *substream)
151 {
152         struct snd_pcm_runtime *runtime = substream->runtime;
153         struct sport_device *sport = runtime->private_data;
154 
155         /* An intermediate buffer is introduced for implementing mmap for
156          * SPORT working in TMD mode(include AC97).
157          */
158 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
159         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
160                 sport_set_tx_callback(sport, bf5xx_dma_irq, substream);
161                 sport_config_tx_dma(sport, sport->tx_dma_buf, runtime->periods,
162                         runtime->period_size * sizeof(struct ac97_frame));
163         } else {
164                 sport_set_rx_callback(sport, bf5xx_dma_irq, substream);
165                 sport_config_rx_dma(sport, sport->rx_dma_buf, runtime->periods,
166                         runtime->period_size * sizeof(struct ac97_frame));
167         }
168 #else
169         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
170                 sport_set_tx_callback(sport, bf5xx_dma_irq, substream);
171                 sport_config_tx_dma(sport, runtime->dma_area, runtime->periods,
172                         runtime->period_size * sizeof(struct ac97_frame));
173         } else {
174                 sport_set_rx_callback(sport, bf5xx_dma_irq, substream);
175                 sport_config_rx_dma(sport, runtime->dma_area, runtime->periods,
176                         runtime->period_size * sizeof(struct ac97_frame));
177         }
178 #endif
179         return 0;
180 }
181 
182 static int bf5xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
183 {
184         struct snd_pcm_runtime *runtime = substream->runtime;
185         struct sport_device *sport = runtime->private_data;
186         int ret = 0;
187 
188         pr_debug("%s enter\n", __func__);
189         switch (cmd) {
190         case SNDRV_PCM_TRIGGER_START:
191                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
192 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
193                         bf5xx_mmap_copy(substream, runtime->period_size);
194                         sport->tx_delay_pos = 0;
195 #endif
196                         sport_tx_start(sport);
197                 } else
198                         sport_rx_start(sport);
199                 break;
200         case SNDRV_PCM_TRIGGER_STOP:
201         case SNDRV_PCM_TRIGGER_SUSPEND:
202         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
203                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
204 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
205                         sport->tx_pos = 0;
206 #endif
207                         sport_tx_stop(sport);
208                 } else {
209 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
210                         sport->rx_pos = 0;
211 #endif
212                         sport_rx_stop(sport);
213                 }
214                 break;
215         default:
216                 ret = -EINVAL;
217         }
218         return ret;
219 }
220 
221 static snd_pcm_uframes_t bf5xx_pcm_pointer(struct snd_pcm_substream *substream)
222 {
223         struct snd_pcm_runtime *runtime = substream->runtime;
224         struct sport_device *sport = runtime->private_data;
225         unsigned int curr;
226 
227 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
228         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
229                 curr = sport->tx_delay_pos;
230         else
231                 curr = sport->rx_pos;
232 #else
233 
234         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
235                 curr = sport_curr_offset_tx(sport) / sizeof(struct ac97_frame);
236         else
237                 curr = sport_curr_offset_rx(sport) / sizeof(struct ac97_frame);
238 
239 #endif
240         return curr;
241 }
242 
243 static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
244 {
245         struct snd_soc_pcm_runtime *rtd = substream->private_data;
246         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
247         struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
248         struct snd_pcm_runtime *runtime = substream->runtime;
249         int ret;
250 
251         pr_debug("%s enter\n", __func__);
252         snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware);
253 
254         ret = snd_pcm_hw_constraint_integer(runtime,
255                                             SNDRV_PCM_HW_PARAM_PERIODS);
256         if (ret < 0)
257                 goto out;
258 
259         if (sport_handle != NULL)
260                 runtime->private_data = sport_handle;
261         else {
262                 pr_err("sport_handle is NULL\n");
263                 return -1;
264         }
265         return 0;
266 
267  out:
268         return ret;
269 }
270 
271 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
272 static int bf5xx_pcm_mmap(struct snd_pcm_substream *substream,
273         struct vm_area_struct *vma)
274 {
275         struct snd_pcm_runtime *runtime = substream->runtime;
276         size_t size = vma->vm_end - vma->vm_start;
277         vma->vm_start = (unsigned long)runtime->dma_area;
278         vma->vm_end = vma->vm_start + size;
279         vma->vm_flags |=  VM_SHARED;
280         return 0 ;
281 }
282 #else
283 static  int bf5xx_pcm_copy(struct snd_pcm_substream *substream, int channel,
284                     snd_pcm_uframes_t pos,
285                     void __user *buf, snd_pcm_uframes_t count)
286 {
287         struct snd_pcm_runtime *runtime = substream->runtime;
288         unsigned int chan_mask = ac97_chan_mask[runtime->channels - 1];
289         pr_debug("%s copy pos:0x%lx count:0x%lx\n",
290                         substream->stream ? "Capture" : "Playback", pos, count);
291 
292         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
293                 bf5xx_pcm_to_ac97((struct ac97_frame *)runtime->dma_area + pos,
294                         (__u16 *)buf, count, chan_mask);
295         else
296                 bf5xx_ac97_to_pcm((struct ac97_frame *)runtime->dma_area + pos,
297                         (__u16 *)buf, count);
298         return 0;
299 }
300 #endif
301 
302 static struct snd_pcm_ops bf5xx_pcm_ac97_ops = {
303         .open           = bf5xx_pcm_open,
304         .ioctl          = snd_pcm_lib_ioctl,
305         .hw_params      = bf5xx_pcm_hw_params,
306         .hw_free        = bf5xx_pcm_hw_free,
307         .prepare        = bf5xx_pcm_prepare,
308         .trigger        = bf5xx_pcm_trigger,
309         .pointer        = bf5xx_pcm_pointer,
310 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
311         .mmap           = bf5xx_pcm_mmap,
312 #else
313         .copy           = bf5xx_pcm_copy,
314 #endif
315 };
316 
317 static int bf5xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
318 {
319         struct snd_soc_pcm_runtime *rtd = pcm->private_data;
320         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
321         struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
322         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
323         struct snd_dma_buffer *buf = &substream->dma_buffer;
324         size_t size = bf5xx_pcm_hardware.buffer_bytes_max
325                         * sizeof(struct ac97_frame) / 4;
326 
327         buf->dev.type = SNDRV_DMA_TYPE_DEV;
328         buf->dev.dev = pcm->card->dev;
329         buf->private_data = NULL;
330         buf->area = dma_alloc_coherent(pcm->card->dev, size,
331                         &buf->addr, GFP_KERNEL);
332         if (!buf->area) {
333                 pr_err("Failed to allocate dma memory\n");
334                 pr_err("Please increase uncached DMA memory region\n");
335                 return -ENOMEM;
336         }
337         buf->bytes = size;
338 
339         pr_debug("%s, area:%p, size:0x%08lx\n", __func__,
340                         buf->area, buf->bytes);
341 
342         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
343                 sport_handle->tx_buf = buf->area;
344         else
345                 sport_handle->rx_buf = buf->area;
346 
347 /*
348  * Need to allocate local buffer when enable
349  * MMAP for SPORT working in TMD mode (include AC97).
350  */
351 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
352         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
353                 if (!sport_handle->tx_dma_buf) {
354                         sport_handle->tx_dma_buf = dma_alloc_coherent(NULL, \
355                                 size, &sport_handle->tx_dma_phy, GFP_KERNEL);
356                         if (!sport_handle->tx_dma_buf) {
357                                 pr_err("Failed to allocate memory for tx dma buf - Please increase uncached DMA memory region\n");
358                                 return -ENOMEM;
359                         } else
360                                 memset(sport_handle->tx_dma_buf, 0, size);
361                 } else
362                         memset(sport_handle->tx_dma_buf, 0, size);
363         } else {
364                 if (!sport_handle->rx_dma_buf) {
365                         sport_handle->rx_dma_buf = dma_alloc_coherent(NULL, \
366                                 size, &sport_handle->rx_dma_phy, GFP_KERNEL);
367                         if (!sport_handle->rx_dma_buf) {
368                                 pr_err("Failed to allocate memory for rx dma buf - Please increase uncached DMA memory region\n");
369                                 return -ENOMEM;
370                         } else
371                                 memset(sport_handle->rx_dma_buf, 0, size);
372                 } else
373                         memset(sport_handle->rx_dma_buf, 0, size);
374         }
375 #endif
376         return 0;
377 }
378 
379 static void bf5xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
380 {
381         struct snd_pcm_substream *substream;
382         struct snd_dma_buffer *buf;
383         int stream;
384 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
385         struct snd_soc_pcm_runtime *rtd = pcm->private_data;
386         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
387         struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
388         size_t size = bf5xx_pcm_hardware.buffer_bytes_max *
389                 sizeof(struct ac97_frame) / 4;
390 #endif
391         for (stream = 0; stream < 2; stream++) {
392                 substream = pcm->streams[stream].substream;
393                 if (!substream)
394                         continue;
395 
396                 buf = &substream->dma_buffer;
397                 if (!buf->area)
398                         continue;
399                 dma_free_coherent(NULL, buf->bytes, buf->area, 0);
400                 buf->area = NULL;
401 #if defined(CONFIG_SND_BF5XX_MMAP_SUPPORT)
402         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
403                 if (sport_handle->tx_dma_buf)
404                         dma_free_coherent(NULL, size, \
405                                 sport_handle->tx_dma_buf, 0);
406                 sport_handle->tx_dma_buf = NULL;
407         } else {
408 
409                 if (sport_handle->rx_dma_buf)
410                         dma_free_coherent(NULL, size, \
411                                 sport_handle->rx_dma_buf, 0);
412                 sport_handle->rx_dma_buf = NULL;
413         }
414 #endif
415         }
416 }
417 
418 static u64 bf5xx_pcm_dmamask = DMA_BIT_MASK(32);
419 
420 static int bf5xx_pcm_ac97_new(struct snd_soc_pcm_runtime *rtd)
421 {
422         struct snd_card *card = rtd->card->snd_card;
423         struct snd_pcm *pcm = rtd->pcm;
424         int ret = 0;
425 
426         pr_debug("%s enter\n", __func__);
427         if (!card->dev->dma_mask)
428                 card->dev->dma_mask = &bf5xx_pcm_dmamask;
429         if (!card->dev->coherent_dma_mask)
430                 card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
431 
432         if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
433                 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
434                         SNDRV_PCM_STREAM_PLAYBACK);
435                 if (ret)
436                         goto out;
437         }
438 
439         if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
440                 ret = bf5xx_pcm_preallocate_dma_buffer(pcm,
441                         SNDRV_PCM_STREAM_CAPTURE);
442                 if (ret)
443                         goto out;
444         }
445  out:
446         return ret;
447 }
448 
449 static struct snd_soc_platform_driver bf5xx_ac97_soc_platform = {
450         .ops                    = &bf5xx_pcm_ac97_ops,
451         .pcm_new        = bf5xx_pcm_ac97_new,
452         .pcm_free       = bf5xx_pcm_free_dma_buffers,
453 };
454 
455 static int bf5xx_soc_platform_probe(struct platform_device *pdev)
456 {
457         return snd_soc_register_platform(&pdev->dev, &bf5xx_ac97_soc_platform);
458 }
459 
460 static int bf5xx_soc_platform_remove(struct platform_device *pdev)
461 {
462         snd_soc_unregister_platform(&pdev->dev);
463         return 0;
464 }
465 
466 static struct platform_driver bf5xx_pcm_driver = {
467         .driver = {
468                         .name = "bfin-ac97-pcm-audio",
469                         .owner = THIS_MODULE,
470         },
471 
472         .probe = bf5xx_soc_platform_probe,
473         .remove = bf5xx_soc_platform_remove,
474 };
475 
476 module_platform_driver(bf5xx_pcm_driver);
477 
478 MODULE_AUTHOR("Cliff Cai");
479 MODULE_DESCRIPTION("ADI Blackfin AC97 PCM DMA module");
480 MODULE_LICENSE("GPL");
481 

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