blob: a3881c4381c9151771ffca5e5133ef01707ba9ea [file] [log] [blame]
Cliff Cai88740da2008-09-05 18:21:38 +08001/*
2 * File: sound/soc/blackfin/bf5xx-i2s-pcm.c
3 * Author: Cliff Cai <Cliff.Cai@analog.com>
4 *
5 * Created: Tue June 06 2008
6 * Description: DMA driver for i2s codec
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>
Cliff Cai88740da2008-09-05 18:21:38 +080032#include <linux/dma-mapping.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/gfp.h>
Cliff Cai88740da2008-09-05 18:21:38 +080034
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
Cliff Cai88740da2008-09-05 18:21:38 +080042#include "bf5xx-sport.h"
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +020043#include "bf5xx-i2s-pcm.h"
Cliff Cai88740da2008-09-05 18:21:38 +080044
45static void bf5xx_dma_irq(void *data)
46{
47 struct snd_pcm_substream *pcm = data;
48 snd_pcm_period_elapsed(pcm);
49}
50
51static const struct snd_pcm_hardware bf5xx_pcm_hardware = {
52 .info = SNDRV_PCM_INFO_INTERLEAVED |
Cliff Cai88740da2008-09-05 18:21:38 +080053 SNDRV_PCM_INFO_MMAP_VALID |
54 SNDRV_PCM_INFO_BLOCK_TRANSFER,
Cliff Cai88740da2008-09-05 18:21:38 +080055 .period_bytes_min = 32,
56 .period_bytes_max = 0x10000,
57 .periods_min = 1,
58 .periods_max = PAGE_SIZE/32,
59 .buffer_bytes_max = 0x20000, /* 128 kbytes */
60 .fifo_size = 16,
61};
62
63static int bf5xx_pcm_hw_params(struct snd_pcm_substream *substream,
64 struct snd_pcm_hw_params *params)
65{
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +020066 struct snd_soc_pcm_runtime *rtd = substream->private_data;
67 unsigned int buffer_size = params_buffer_bytes(params);
68 struct bf5xx_i2s_pcm_data *dma_data;
69
70 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
71
72 if (dma_data->tdm_mode)
73 buffer_size = buffer_size / params_channels(params) * 8;
74
75 return snd_pcm_lib_malloc_pages(substream, buffer_size);
Cliff Cai88740da2008-09-05 18:21:38 +080076}
77
78static int bf5xx_pcm_hw_free(struct snd_pcm_substream *substream)
79{
80 snd_pcm_lib_free_pages(substream);
81
82 return 0;
83}
84
85static int bf5xx_pcm_prepare(struct snd_pcm_substream *substream)
86{
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +020087 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Cliff Cai88740da2008-09-05 18:21:38 +080088 struct snd_pcm_runtime *runtime = substream->runtime;
89 struct sport_device *sport = runtime->private_data;
90 int period_bytes = frames_to_bytes(runtime, runtime->period_size);
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +020091 struct bf5xx_i2s_pcm_data *dma_data;
92
93 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
94
95 if (dma_data->tdm_mode)
96 period_bytes = period_bytes / runtime->channels * 8;
Cliff Cai88740da2008-09-05 18:21:38 +080097
98 pr_debug("%s enter\n", __func__);
99 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
100 sport_set_tx_callback(sport, bf5xx_dma_irq, substream);
101 sport_config_tx_dma(sport, runtime->dma_area,
102 runtime->periods, period_bytes);
103 } else {
104 sport_set_rx_callback(sport, bf5xx_dma_irq, substream);
105 sport_config_rx_dma(sport, runtime->dma_area,
106 runtime->periods, period_bytes);
107 }
108
109 return 0;
110}
111
112static int bf5xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
113{
114 struct snd_pcm_runtime *runtime = substream->runtime;
115 struct sport_device *sport = runtime->private_data;
116 int ret = 0;
117
118 pr_debug("%s enter\n", __func__);
119 switch (cmd) {
120 case SNDRV_PCM_TRIGGER_START:
121 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
122 sport_tx_start(sport);
123 else
124 sport_rx_start(sport);
125 break;
126 case SNDRV_PCM_TRIGGER_STOP:
127 case SNDRV_PCM_TRIGGER_SUSPEND:
128 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
129 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
130 sport_tx_stop(sport);
131 else
132 sport_rx_stop(sport);
133 break;
134 default:
135 ret = -EINVAL;
136 }
137
138 return ret;
139}
140
141static snd_pcm_uframes_t bf5xx_pcm_pointer(struct snd_pcm_substream *substream)
142{
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200143 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Cliff Cai88740da2008-09-05 18:21:38 +0800144 struct snd_pcm_runtime *runtime = substream->runtime;
145 struct sport_device *sport = runtime->private_data;
146 unsigned int diff;
147 snd_pcm_uframes_t frames;
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200148 struct bf5xx_i2s_pcm_data *dma_data;
149
150 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
151
Cliff Cai88740da2008-09-05 18:21:38 +0800152 pr_debug("%s enter\n", __func__);
153 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
154 diff = sport_curr_offset_tx(sport);
Cliff Cai88740da2008-09-05 18:21:38 +0800155 } else {
156 diff = sport_curr_offset_rx(sport);
Cliff Cai88740da2008-09-05 18:21:38 +0800157 }
Mark Browne999dc52011-06-13 12:14:07 +0100158
159 /*
160 * TX at least can report one frame beyond the end of the
161 * buffer if we hit the wraparound case - clamp to within the
162 * buffer as the ALSA APIs require.
163 */
164 if (diff == snd_pcm_lib_buffer_bytes(substream))
165 diff = 0;
166
167 frames = bytes_to_frames(substream->runtime, diff);
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200168 if (dma_data->tdm_mode)
169 frames = frames * runtime->channels / 8;
Mark Browne999dc52011-06-13 12:14:07 +0100170
Cliff Cai88740da2008-09-05 18:21:38 +0800171 return frames;
172}
173
174static int bf5xx_pcm_open(struct snd_pcm_substream *substream)
175{
Barry Song2c66cb92011-03-28 01:45:10 -0400176 struct snd_soc_pcm_runtime *rtd = substream->private_data;
177 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
178 struct sport_device *sport_handle = snd_soc_dai_get_drvdata(cpu_dai);
Cliff Cai88740da2008-09-05 18:21:38 +0800179 struct snd_pcm_runtime *runtime = substream->runtime;
Barry Song2c66cb92011-03-28 01:45:10 -0400180 struct snd_dma_buffer *buf = &substream->dma_buffer;
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200181 struct bf5xx_i2s_pcm_data *dma_data;
Cliff Cai88740da2008-09-05 18:21:38 +0800182 int ret;
183
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200184 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
185
Cliff Cai88740da2008-09-05 18:21:38 +0800186 pr_debug("%s enter\n", __func__);
Barry Song2c66cb92011-03-28 01:45:10 -0400187
Cliff Cai88740da2008-09-05 18:21:38 +0800188 snd_soc_set_runtime_hwparams(substream, &bf5xx_pcm_hardware);
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200189 if (dma_data->tdm_mode)
190 runtime->hw.buffer_bytes_max /= 4;
191 else
192 runtime->hw.info |= SNDRV_PCM_INFO_MMAP;
Cliff Cai88740da2008-09-05 18:21:38 +0800193
Mark Brownb83e60c2011-06-13 17:50:18 +0100194 ret = snd_pcm_hw_constraint_integer(runtime,
Cliff Cai88740da2008-09-05 18:21:38 +0800195 SNDRV_PCM_HW_PARAM_PERIODS);
196 if (ret < 0)
197 goto out;
198
Barry Song2c66cb92011-03-28 01:45:10 -0400199 if (sport_handle != NULL) {
200 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
201 sport_handle->tx_buf = buf->area;
202 else
203 sport_handle->rx_buf = buf->area;
204
Cliff Cai88740da2008-09-05 18:21:38 +0800205 runtime->private_data = sport_handle;
Barry Song2c66cb92011-03-28 01:45:10 -0400206 } else {
Cliff Cai88740da2008-09-05 18:21:38 +0800207 pr_err("sport_handle is NULL\n");
208 return -1;
209 }
210 return 0;
211
212 out:
213 return ret;
214}
215
216static int bf5xx_pcm_mmap(struct snd_pcm_substream *substream,
217 struct vm_area_struct *vma)
218{
219 struct snd_pcm_runtime *runtime = substream->runtime;
220 size_t size = vma->vm_end - vma->vm_start;
221 vma->vm_start = (unsigned long)runtime->dma_area;
222 vma->vm_end = vma->vm_start + size;
223 vma->vm_flags |= VM_SHARED;
224
225 return 0 ;
226}
227
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200228static int bf5xx_pcm_copy(struct snd_pcm_substream *substream, int channel,
229 snd_pcm_uframes_t pos, void *buf, snd_pcm_uframes_t count)
230{
231 struct snd_soc_pcm_runtime *rtd = substream->private_data;
232 struct snd_pcm_runtime *runtime = substream->runtime;
233 unsigned int sample_size = runtime->sample_bits / 8;
234 struct bf5xx_i2s_pcm_data *dma_data;
235 unsigned int i;
236 void *src, *dst;
237
238 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
239
240 if (dma_data->tdm_mode) {
241 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
242 src = buf;
243 dst = runtime->dma_area;
244 dst += pos * sample_size * 8;
245
246 while (count--) {
247 for (i = 0; i < runtime->channels; i++) {
248 memcpy(dst + dma_data->map[i] *
249 sample_size, src, sample_size);
250 src += sample_size;
251 }
252 dst += 8 * sample_size;
253 }
254 } else {
255 src = runtime->dma_area;
256 src += pos * sample_size * 8;
257 dst = buf;
258
259 while (count--) {
260 for (i = 0; i < runtime->channels; i++) {
261 memcpy(dst, src + dma_data->map[i] *
262 sample_size, sample_size);
263 dst += sample_size;
264 }
265 src += 8 * sample_size;
266 }
267 }
268 } else {
269 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
270 src = buf;
271 dst = runtime->dma_area;
272 dst += frames_to_bytes(runtime, pos);
273 } else {
274 src = runtime->dma_area;
275 src += frames_to_bytes(runtime, pos);
276 dst = buf;
277 }
278
279 memcpy(dst, src, frames_to_bytes(runtime, count));
280 }
281
282 return 0;
283}
284
285static int bf5xx_pcm_silence(struct snd_pcm_substream *substream,
286 int channel, snd_pcm_uframes_t pos, snd_pcm_uframes_t count)
287{
288 struct snd_soc_pcm_runtime *rtd = substream->private_data;
289 struct snd_pcm_runtime *runtime = substream->runtime;
290 unsigned int sample_size = runtime->sample_bits / 8;
291 void *buf = runtime->dma_area;
292 struct bf5xx_i2s_pcm_data *dma_data;
293 unsigned int offset, size;
294
295 dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
296
297 if (dma_data->tdm_mode) {
298 offset = pos * 8 * sample_size;
299 size = count * 8 * sample_size;
300 } else {
301 offset = frames_to_bytes(runtime, pos);
302 size = frames_to_bytes(runtime, count);
303 }
304
305 snd_pcm_format_set_silence(runtime->format, buf + offset, size);
306
307 return 0;
308}
309
Mark Brownb2a19d02009-01-17 19:14:26 +0000310static struct snd_pcm_ops bf5xx_pcm_i2s_ops = {
Cliff Cai88740da2008-09-05 18:21:38 +0800311 .open = bf5xx_pcm_open,
312 .ioctl = snd_pcm_lib_ioctl,
313 .hw_params = bf5xx_pcm_hw_params,
314 .hw_free = bf5xx_pcm_hw_free,
315 .prepare = bf5xx_pcm_prepare,
316 .trigger = bf5xx_pcm_trigger,
317 .pointer = bf5xx_pcm_pointer,
318 .mmap = bf5xx_pcm_mmap,
Lars-Peter Clausen8b5e2e32013-05-28 19:22:14 +0200319 .copy = bf5xx_pcm_copy,
320 .silence = bf5xx_pcm_silence,
Cliff Cai88740da2008-09-05 18:21:38 +0800321};
322
Axel Lin3b70e3b2011-09-21 14:40:58 +0800323static int bf5xx_pcm_i2s_new(struct snd_soc_pcm_runtime *rtd)
Cliff Cai88740da2008-09-05 18:21:38 +0800324{
Liam Girdwood552d1ef2011-06-07 16:08:33 +0100325 struct snd_card *card = rtd->card->snd_card;
Lars-Peter Clausena3935a22013-05-28 19:22:13 +0200326 size_t size = bf5xx_pcm_hardware.buffer_bytes_max;
Russell Kingc9bd5e62013-06-27 12:53:37 +0100327 int ret;
Cliff Cai88740da2008-09-05 18:21:38 +0800328
329 pr_debug("%s enter\n", __func__);
Russell Kingc9bd5e62013-06-27 12:53:37 +0100330 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
331 if (ret)
332 return ret;
Cliff Cai88740da2008-09-05 18:21:38 +0800333
Lars-Peter Clausena3935a22013-05-28 19:22:13 +0200334 return snd_pcm_lib_preallocate_pages_for_all(rtd->pcm,
335 SNDRV_DMA_TYPE_DEV, card->dev, size, size);
Cliff Cai88740da2008-09-05 18:21:38 +0800336}
337
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000338static struct snd_soc_platform_driver bf5xx_i2s_soc_platform = {
339 .ops = &bf5xx_pcm_i2s_ops,
Cliff Cai88740da2008-09-05 18:21:38 +0800340 .pcm_new = bf5xx_pcm_i2s_new,
Cliff Cai88740da2008-09-05 18:21:38 +0800341};
Cliff Cai88740da2008-09-05 18:21:38 +0800342
Bill Pembertondca66da2012-12-07 09:26:13 -0500343static int bfin_i2s_soc_platform_probe(struct platform_device *pdev)
Mark Brown958e7922008-12-03 19:58:17 +0000344{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000345 return snd_soc_register_platform(&pdev->dev, &bf5xx_i2s_soc_platform);
Mark Brown958e7922008-12-03 19:58:17 +0000346}
Mark Brown958e7922008-12-03 19:58:17 +0000347
Bill Pembertondca66da2012-12-07 09:26:13 -0500348static int bfin_i2s_soc_platform_remove(struct platform_device *pdev)
Mark Brown958e7922008-12-03 19:58:17 +0000349{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000350 snd_soc_unregister_platform(&pdev->dev);
351 return 0;
Mark Brown958e7922008-12-03 19:58:17 +0000352}
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000353
354static struct platform_driver bfin_i2s_pcm_driver = {
355 .driver = {
Mark Brownb83e60c2011-06-13 17:50:18 +0100356 .name = "bfin-i2s-pcm-audio",
357 .owner = THIS_MODULE,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000358 },
359
360 .probe = bfin_i2s_soc_platform_probe,
Bill Pembertondca66da2012-12-07 09:26:13 -0500361 .remove = bfin_i2s_soc_platform_remove,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000362};
363
Axel Linfb802972011-11-24 14:44:52 +0800364module_platform_driver(bfin_i2s_pcm_driver);
Mark Brown958e7922008-12-03 19:58:17 +0000365
Cliff Cai88740da2008-09-05 18:21:38 +0800366MODULE_AUTHOR("Cliff Cai");
367MODULE_DESCRIPTION("ADI Blackfin I2S PCM DMA module");
368MODULE_LICENSE("GPL");