2 * siu_pcm.c - ALSA driver for Renesas SH7343, SH7722 SIU peripheral.
4 * Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
5 * Copyright (C) 2006 Carlos Munoz <carlos@kenati.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <linux/delay.h>
22 #include <linux/dma-mapping.h>
23 #include <linux/dmaengine.h>
24 #include <linux/interrupt.h>
25 #include <linux/module.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
29 #include <sound/control.h>
30 #include <sound/core.h>
31 #include <sound/pcm.h>
32 #include <sound/pcm_params.h>
33 #include <sound/soc-dai.h>
35 #include <asm/dma-sh.h>
40 #define GET_MAX_PERIODS(buf_bytes, period_bytes) \
41 ((buf_bytes) / (period_bytes))
42 #define PERIOD_OFFSET(buf_addr, period_num, period_bytes) \
43 ((buf_addr) + ((period_num) * (period_bytes)))
45 #define RWF_STM_RD 0x01 /* Read in progress */
46 #define RWF_STM_WT 0x02 /* Write in progress */
48 struct siu_port
*siu_ports
[SIU_PORT_NUM
];
50 /* transfersize is number of u32 dma transfers per period */
51 static int siu_pcm_stmwrite_stop(struct siu_port
*port_info
)
53 struct siu_info
*info
= siu_i2s_dai
.private_data
;
54 u32 __iomem
*base
= info
->reg
;
55 struct siu_stream
*siu_stream
= &port_info
->playback
;
58 if (!siu_stream
->rw_flg
)
61 /* output FIFO disable */
62 stfifo
= siu_read32(base
+ SIU_STFIFO
);
63 siu_write32(base
+ SIU_STFIFO
, stfifo
& ~0x0c180c18);
64 pr_debug("%s: STFIFO %x -> %x\n", __func__
,
65 stfifo
, stfifo
& ~0x0c180c18);
67 /* during stmwrite clear */
68 siu_stream
->rw_flg
= 0;
73 static int siu_pcm_stmwrite_start(struct siu_port
*port_info
)
75 struct siu_stream
*siu_stream
= &port_info
->playback
;
77 if (siu_stream
->rw_flg
)
80 /* Current period in buffer */
81 port_info
->playback
.cur_period
= 0;
83 /* during stmwrite flag set */
84 siu_stream
->rw_flg
= RWF_STM_WT
;
86 /* DMA transfer start */
87 tasklet_schedule(&siu_stream
->tasklet
);
92 static void siu_dma_tx_complete(void *arg
)
94 struct siu_stream
*siu_stream
= arg
;
96 if (!siu_stream
->rw_flg
)
99 /* Update completed period count */
100 if (++siu_stream
->cur_period
>=
101 GET_MAX_PERIODS(siu_stream
->buf_bytes
,
102 siu_stream
->period_bytes
))
103 siu_stream
->cur_period
= 0;
105 pr_debug("%s: done period #%d (%u/%u bytes), cookie %d\n",
106 __func__
, siu_stream
->cur_period
,
107 siu_stream
->cur_period
* siu_stream
->period_bytes
,
108 siu_stream
->buf_bytes
, siu_stream
->cookie
);
110 tasklet_schedule(&siu_stream
->tasklet
);
112 /* Notify alsa: a period is done */
113 snd_pcm_period_elapsed(siu_stream
->substream
);
116 static int siu_pcm_wr_set(struct siu_port
*port_info
,
117 dma_addr_t buff
, u32 size
)
119 struct siu_info
*info
= siu_i2s_dai
.private_data
;
120 u32 __iomem
*base
= info
->reg
;
121 struct siu_stream
*siu_stream
= &port_info
->playback
;
122 struct snd_pcm_substream
*substream
= siu_stream
->substream
;
123 struct device
*dev
= substream
->pcm
->card
->dev
;
124 struct dma_async_tx_descriptor
*desc
;
126 struct scatterlist sg
;
129 sg_init_table(&sg
, 1);
130 sg_set_page(&sg
, pfn_to_page(PFN_DOWN(buff
)),
131 size
, offset_in_page(buff
));
132 sg_dma_address(&sg
) = buff
;
134 desc
= siu_stream
->chan
->device
->device_prep_slave_sg(siu_stream
->chan
,
135 &sg
, 1, DMA_TO_DEVICE
, DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
137 dev_err(dev
, "Failed to allocate a dma descriptor\n");
141 desc
->callback
= siu_dma_tx_complete
;
142 desc
->callback_param
= siu_stream
;
143 cookie
= desc
->tx_submit(desc
);
145 dev_err(dev
, "Failed to submit a dma transfer\n");
149 siu_stream
->tx_desc
= desc
;
150 siu_stream
->cookie
= cookie
;
152 dma_async_issue_pending(siu_stream
->chan
);
154 /* only output FIFO enable */
155 stfifo
= siu_read32(base
+ SIU_STFIFO
);
156 siu_write32(base
+ SIU_STFIFO
, stfifo
| (port_info
->stfifo
& 0x0c180c18));
157 dev_dbg(dev
, "%s: STFIFO %x -> %x\n", __func__
,
158 stfifo
, stfifo
| (port_info
->stfifo
& 0x0c180c18));
163 static int siu_pcm_rd_set(struct siu_port
*port_info
,
164 dma_addr_t buff
, size_t size
)
166 struct siu_info
*info
= siu_i2s_dai
.private_data
;
167 u32 __iomem
*base
= info
->reg
;
168 struct siu_stream
*siu_stream
= &port_info
->capture
;
169 struct snd_pcm_substream
*substream
= siu_stream
->substream
;
170 struct device
*dev
= substream
->pcm
->card
->dev
;
171 struct dma_async_tx_descriptor
*desc
;
173 struct scatterlist sg
;
176 dev_dbg(dev
, "%s: %u@%llx\n", __func__
, size
, (unsigned long long)buff
);
178 sg_init_table(&sg
, 1);
179 sg_set_page(&sg
, pfn_to_page(PFN_DOWN(buff
)),
180 size
, offset_in_page(buff
));
181 sg_dma_address(&sg
) = buff
;
183 desc
= siu_stream
->chan
->device
->device_prep_slave_sg(siu_stream
->chan
,
184 &sg
, 1, DMA_FROM_DEVICE
, DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
186 dev_err(dev
, "Failed to allocate dma descriptor\n");
190 desc
->callback
= siu_dma_tx_complete
;
191 desc
->callback_param
= siu_stream
;
192 cookie
= desc
->tx_submit(desc
);
194 dev_err(dev
, "Failed to submit dma descriptor\n");
198 siu_stream
->tx_desc
= desc
;
199 siu_stream
->cookie
= cookie
;
201 dma_async_issue_pending(siu_stream
->chan
);
203 /* only input FIFO enable */
204 stfifo
= siu_read32(base
+ SIU_STFIFO
);
205 siu_write32(base
+ SIU_STFIFO
, siu_read32(base
+ SIU_STFIFO
) |
206 (port_info
->stfifo
& 0x13071307));
207 dev_dbg(dev
, "%s: STFIFO %x -> %x\n", __func__
,
208 stfifo
, stfifo
| (port_info
->stfifo
& 0x13071307));
213 static void siu_io_tasklet(unsigned long data
)
215 struct siu_stream
*siu_stream
= (struct siu_stream
*)data
;
216 struct snd_pcm_substream
*substream
= siu_stream
->substream
;
217 struct device
*dev
= substream
->pcm
->card
->dev
;
218 struct snd_pcm_runtime
*rt
= substream
->runtime
;
219 struct siu_port
*port_info
= siu_port_info(substream
);
221 dev_dbg(dev
, "%s: flags %x\n", __func__
, siu_stream
->rw_flg
);
223 if (!siu_stream
->rw_flg
) {
224 dev_dbg(dev
, "%s: stream inactive\n", __func__
);
228 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
) {
233 buff
= (dma_addr_t
)PERIOD_OFFSET(rt
->dma_addr
,
234 siu_stream
->cur_period
,
235 siu_stream
->period_bytes
);
236 virt
= PERIOD_OFFSET(rt
->dma_area
,
237 siu_stream
->cur_period
,
238 siu_stream
->period_bytes
);
239 count
= siu_stream
->period_bytes
;
241 /* DMA transfer start */
242 siu_pcm_rd_set(port_info
, buff
, count
);
244 siu_pcm_wr_set(port_info
,
245 (dma_addr_t
)PERIOD_OFFSET(rt
->dma_addr
,
246 siu_stream
->cur_period
,
247 siu_stream
->period_bytes
),
248 siu_stream
->period_bytes
);
253 static int siu_pcm_stmread_start(struct siu_port
*port_info
)
255 struct siu_stream
*siu_stream
= &port_info
->capture
;
257 if (siu_stream
->xfer_cnt
> 0x1000000)
259 if (siu_stream
->rw_flg
)
262 /* Current period in buffer */
263 siu_stream
->cur_period
= 0;
265 /* during stmread flag set */
266 siu_stream
->rw_flg
= RWF_STM_RD
;
268 tasklet_schedule(&siu_stream
->tasklet
);
273 static int siu_pcm_stmread_stop(struct siu_port
*port_info
)
275 struct siu_info
*info
= siu_i2s_dai
.private_data
;
276 u32 __iomem
*base
= info
->reg
;
277 struct siu_stream
*siu_stream
= &port_info
->capture
;
278 struct device
*dev
= siu_stream
->substream
->pcm
->card
->dev
;
281 if (!siu_stream
->rw_flg
)
284 /* input FIFO disable */
285 stfifo
= siu_read32(base
+ SIU_STFIFO
);
286 siu_write32(base
+ SIU_STFIFO
, stfifo
& ~0x13071307);
287 dev_dbg(dev
, "%s: STFIFO %x -> %x\n", __func__
,
288 stfifo
, stfifo
& ~0x13071307);
290 /* during stmread flag clear */
291 siu_stream
->rw_flg
= 0;
296 static int siu_pcm_hw_params(struct snd_pcm_substream
*ss
,
297 struct snd_pcm_hw_params
*hw_params
)
299 struct siu_info
*info
= siu_i2s_dai
.private_data
;
300 struct device
*dev
= ss
->pcm
->card
->dev
;
303 dev_dbg(dev
, "%s: port=%d\n", __func__
, info
->port_id
);
305 ret
= snd_pcm_lib_malloc_pages(ss
, params_buffer_bytes(hw_params
));
307 dev_err(dev
, "snd_pcm_lib_malloc_pages() failed\n");
312 static int siu_pcm_hw_free(struct snd_pcm_substream
*ss
)
314 struct siu_info
*info
= siu_i2s_dai
.private_data
;
315 struct siu_port
*port_info
= siu_port_info(ss
);
316 struct device
*dev
= ss
->pcm
->card
->dev
;
317 struct siu_stream
*siu_stream
;
319 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
320 siu_stream
= &port_info
->playback
;
322 siu_stream
= &port_info
->capture
;
324 dev_dbg(dev
, "%s: port=%d\n", __func__
, info
->port_id
);
326 return snd_pcm_lib_free_pages(ss
);
329 static bool filter(struct dma_chan
*chan
, void *slave
)
331 struct sh_dmae_slave
*param
= slave
;
333 pr_debug("%s: slave ID %d\n", __func__
, param
->slave_id
);
335 if (unlikely(param
->dma_dev
!= chan
->device
->dev
))
338 chan
->private = param
;
342 static int siu_pcm_open(struct snd_pcm_substream
*ss
)
344 /* Playback / Capture */
345 struct siu_info
*info
= siu_i2s_dai
.private_data
;
346 struct siu_port
*port_info
= siu_port_info(ss
);
347 struct siu_stream
*siu_stream
;
348 u32 port
= info
->port_id
;
349 struct siu_platform
*pdata
= siu_i2s_dai
.dev
->platform_data
;
350 struct device
*dev
= ss
->pcm
->card
->dev
;
352 struct sh_dmae_slave
*param
;
355 dma_cap_set(DMA_SLAVE
, mask
);
357 dev_dbg(dev
, "%s, port=%d@%p\n", __func__
, port
, port_info
);
359 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
360 siu_stream
= &port_info
->playback
;
361 param
= &siu_stream
->param
;
362 param
->slave_id
= port
? SHDMA_SLAVE_SIUB_TX
:
365 siu_stream
= &port_info
->capture
;
366 param
= &siu_stream
->param
;
367 param
->slave_id
= port
? SHDMA_SLAVE_SIUB_RX
:
371 param
->dma_dev
= pdata
->dma_dev
;
372 /* Get DMA channel */
373 siu_stream
->chan
= dma_request_channel(mask
, filter
, param
);
374 if (!siu_stream
->chan
) {
375 dev_err(dev
, "DMA channel allocation failed!\n");
379 siu_stream
->substream
= ss
;
384 static int siu_pcm_close(struct snd_pcm_substream
*ss
)
386 struct siu_info
*info
= siu_i2s_dai
.private_data
;
387 struct device
*dev
= ss
->pcm
->card
->dev
;
388 struct siu_port
*port_info
= siu_port_info(ss
);
389 struct siu_stream
*siu_stream
;
391 dev_dbg(dev
, "%s: port=%d\n", __func__
, info
->port_id
);
393 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
394 siu_stream
= &port_info
->playback
;
396 siu_stream
= &port_info
->capture
;
398 dma_release_channel(siu_stream
->chan
);
399 siu_stream
->chan
= NULL
;
401 siu_stream
->substream
= NULL
;
406 static int siu_pcm_prepare(struct snd_pcm_substream
*ss
)
408 struct siu_info
*info
= siu_i2s_dai
.private_data
;
409 struct siu_port
*port_info
= siu_port_info(ss
);
410 struct device
*dev
= ss
->pcm
->card
->dev
;
411 struct snd_pcm_runtime
*rt
= ss
->runtime
;
412 struct siu_stream
*siu_stream
;
413 snd_pcm_sframes_t xfer_cnt
;
415 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
416 siu_stream
= &port_info
->playback
;
418 siu_stream
= &port_info
->capture
;
420 rt
= siu_stream
->substream
->runtime
;
422 siu_stream
->buf_bytes
= snd_pcm_lib_buffer_bytes(ss
);
423 siu_stream
->period_bytes
= snd_pcm_lib_period_bytes(ss
);
425 dev_dbg(dev
, "%s: port=%d, %d channels, period=%u bytes\n", __func__
,
426 info
->port_id
, rt
->channels
, siu_stream
->period_bytes
);
428 /* We only support buffers that are multiples of the period */
429 if (siu_stream
->buf_bytes
% siu_stream
->period_bytes
) {
430 dev_err(dev
, "%s() - buffer=%d not multiple of period=%d\n",
431 __func__
, siu_stream
->buf_bytes
,
432 siu_stream
->period_bytes
);
436 xfer_cnt
= bytes_to_frames(rt
, siu_stream
->period_bytes
);
437 if (!xfer_cnt
|| xfer_cnt
> 0x1000000)
440 siu_stream
->format
= rt
->format
;
441 siu_stream
->xfer_cnt
= xfer_cnt
;
443 dev_dbg(dev
, "port=%d buf=%lx buf_bytes=%d period_bytes=%d "
444 "format=%d channels=%d xfer_cnt=%d\n", info
->port_id
,
445 (unsigned long)rt
->dma_addr
, siu_stream
->buf_bytes
,
446 siu_stream
->period_bytes
,
447 siu_stream
->format
, rt
->channels
, (int)xfer_cnt
);
452 static int siu_pcm_trigger(struct snd_pcm_substream
*ss
, int cmd
)
454 struct siu_info
*info
= siu_i2s_dai
.private_data
;
455 struct device
*dev
= ss
->pcm
->card
->dev
;
456 struct siu_port
*port_info
= siu_port_info(ss
);
459 dev_dbg(dev
, "%s: port=%d@%p, cmd=%d\n", __func__
,
460 info
->port_id
, port_info
, cmd
);
463 case SNDRV_PCM_TRIGGER_START
:
464 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
465 ret
= siu_pcm_stmwrite_start(port_info
);
467 ret
= siu_pcm_stmread_start(port_info
);
470 dev_warn(dev
, "%s: start failed on port=%d\n",
471 __func__
, info
->port_id
);
474 case SNDRV_PCM_TRIGGER_STOP
:
475 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
476 siu_pcm_stmwrite_stop(port_info
);
478 siu_pcm_stmread_stop(port_info
);
483 dev_err(dev
, "%s() unsupported cmd=%d\n", __func__
, cmd
);
491 * So far only resolution of one period is supported, subject to extending the
494 static snd_pcm_uframes_t
siu_pcm_pointer_dma(struct snd_pcm_substream
*ss
)
496 struct device
*dev
= ss
->pcm
->card
->dev
;
497 struct siu_info
*info
= siu_i2s_dai
.private_data
;
498 u32 __iomem
*base
= info
->reg
;
499 struct siu_port
*port_info
= siu_port_info(ss
);
500 struct snd_pcm_runtime
*rt
= ss
->runtime
;
502 struct siu_stream
*siu_stream
;
504 if (ss
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
505 siu_stream
= &port_info
->playback
;
507 siu_stream
= &port_info
->capture
;
510 * ptr is the offset into the buffer where the dma is currently at. We
511 * check if the dma buffer has just wrapped.
513 ptr
= PERIOD_OFFSET(rt
->dma_addr
,
514 siu_stream
->cur_period
,
515 siu_stream
->period_bytes
) - rt
->dma_addr
;
518 "%s: port=%d, events %x, FSTS %x, xferred %u/%u, cookie %d\n",
519 __func__
, info
->port_id
, siu_read32(base
+ SIU_EVNTC
),
520 siu_read32(base
+ SIU_SBFSTS
), ptr
, siu_stream
->buf_bytes
,
523 if (ptr
>= siu_stream
->buf_bytes
)
526 return bytes_to_frames(ss
->runtime
, ptr
);
529 static int siu_pcm_new(struct snd_card
*card
, struct snd_soc_dai
*dai
,
532 /* card->dev == socdev->dev, see snd_soc_new_pcms() */
533 struct siu_info
*info
= siu_i2s_dai
.private_data
;
534 struct platform_device
*pdev
= to_platform_device(card
->dev
);
538 /* pdev->id selects between SIUA and SIUB */
539 if (pdev
->id
< 0 || pdev
->id
>= SIU_PORT_NUM
)
542 info
->port_id
= pdev
->id
;
545 * While the siu has 2 ports, only one port can be on at a time (only 1
546 * SPB). So far all the boards using the siu had only one of the ports
547 * wired to a codec. To simplify things, we only register one port with
548 * alsa. In case both ports are needed, it should be changed here
550 for (i
= pdev
->id
; i
< pdev
->id
+ 1; i
++) {
551 struct siu_port
**port_info
= &siu_ports
[i
];
553 ret
= siu_init_port(i
, port_info
, card
);
557 ret
= snd_pcm_lib_preallocate_pages_for_all(pcm
,
558 SNDRV_DMA_TYPE_DEV
, NULL
,
559 SIU_BUFFER_BYTES_MAX
, SIU_BUFFER_BYTES_MAX
);
562 "snd_pcm_lib_preallocate_pages_for_all() err=%d",
567 (*port_info
)->pcm
= pcm
;
570 tasklet_init(&(*port_info
)->playback
.tasklet
, siu_io_tasklet
,
571 (unsigned long)&(*port_info
)->playback
);
572 tasklet_init(&(*port_info
)->capture
.tasklet
, siu_io_tasklet
,
573 (unsigned long)&(*port_info
)->capture
);
576 dev_info(card
->dev
, "SuperH SIU driver initialized.\n");
580 siu_free_port(siu_ports
[pdev
->id
]);
581 dev_err(card
->dev
, "SIU: failed to initialize.\n");
585 static void siu_pcm_free(struct snd_pcm
*pcm
)
587 struct platform_device
*pdev
= to_platform_device(pcm
->card
->dev
);
588 struct siu_port
*port_info
= siu_ports
[pdev
->id
];
590 tasklet_kill(&port_info
->capture
.tasklet
);
591 tasklet_kill(&port_info
->playback
.tasklet
);
593 siu_free_port(port_info
);
594 snd_pcm_lib_preallocate_free_for_all(pcm
);
596 dev_dbg(pcm
->card
->dev
, "%s\n", __func__
);
599 static struct snd_pcm_ops siu_pcm_ops
= {
600 .open
= siu_pcm_open
,
601 .close
= siu_pcm_close
,
602 .ioctl
= snd_pcm_lib_ioctl
,
603 .hw_params
= siu_pcm_hw_params
,
604 .hw_free
= siu_pcm_hw_free
,
605 .prepare
= siu_pcm_prepare
,
606 .trigger
= siu_pcm_trigger
,
607 .pointer
= siu_pcm_pointer_dma
,
610 struct snd_soc_platform siu_platform
= {
612 .pcm_ops
= &siu_pcm_ops
,
613 .pcm_new
= siu_pcm_new
,
614 .pcm_free
= siu_pcm_free
,
616 EXPORT_SYMBOL_GPL(siu_platform
);