1 // SPDX-License-Identifier: GPL-2.0+
3 // siu_pcm.c - ALSA driver for Renesas SH7343, SH7722 SIU peripheral.
5 // Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de>
6 // Copyright (C) 2006 Carlos Munoz <carlos@kenati.com>
8 #include <linux/delay.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/dmaengine.h>
11 #include <linux/interrupt.h>
12 #include <linux/module.h>
13 #include <linux/platform_device.h>
15 #include <sound/control.h>
16 #include <sound/core.h>
17 #include <sound/pcm.h>
18 #include <sound/pcm_params.h>
19 #include <sound/soc.h>
25 #define DRV_NAME "siu-i2s"
26 #define GET_MAX_PERIODS(buf_bytes, period_bytes) \
27 ((buf_bytes) / (period_bytes))
28 #define PERIOD_OFFSET(buf_addr, period_num, period_bytes) \
29 ((buf_addr) + ((period_num) * (period_bytes)))
31 #define RWF_STM_RD 0x01 /* Read in progress */
32 #define RWF_STM_WT 0x02 /* Write in progress */
34 struct siu_port *siu_ports[SIU_PORT_NUM];
36 /* transfersize is number of u32 dma transfers per period */
37 static int siu_pcm_stmwrite_stop(struct siu_port *port_info)
39 struct siu_info *info = siu_i2s_data;
40 u32 __iomem *base = info->reg;
41 struct siu_stream *siu_stream = &port_info->playback;
44 if (!siu_stream->rw_flg)
47 /* output FIFO disable */
48 stfifo = siu_read32(base + SIU_STFIFO);
49 siu_write32(base + SIU_STFIFO, stfifo & ~0x0c180c18);
50 pr_debug("%s: STFIFO %x -> %x\n", __func__,
51 stfifo, stfifo & ~0x0c180c18);
53 /* during stmwrite clear */
54 siu_stream->rw_flg = 0;
59 static int siu_pcm_stmwrite_start(struct siu_port *port_info)
61 struct siu_stream *siu_stream = &port_info->playback;
63 if (siu_stream->rw_flg)
66 /* Current period in buffer */
67 port_info->playback.cur_period = 0;
69 /* during stmwrite flag set */
70 siu_stream->rw_flg = RWF_STM_WT;
72 /* DMA transfer start */
73 tasklet_schedule(&siu_stream->tasklet);
78 static void siu_dma_tx_complete(void *arg)
80 struct siu_stream *siu_stream = arg;
82 if (!siu_stream->rw_flg)
85 /* Update completed period count */
86 if (++siu_stream->cur_period >=
87 GET_MAX_PERIODS(siu_stream->buf_bytes,
88 siu_stream->period_bytes))
89 siu_stream->cur_period = 0;
91 pr_debug("%s: done period #%d (%u/%u bytes), cookie %d\n",
92 __func__, siu_stream->cur_period,
93 siu_stream->cur_period * siu_stream->period_bytes,
94 siu_stream->buf_bytes, siu_stream->cookie);
96 tasklet_schedule(&siu_stream->tasklet);
98 /* Notify alsa: a period is done */
99 snd_pcm_period_elapsed(siu_stream->substream);
102 static int siu_pcm_wr_set(struct siu_port *port_info,
103 dma_addr_t buff, u32 size)
105 struct siu_info *info = siu_i2s_data;
106 u32 __iomem *base = info->reg;
107 struct siu_stream *siu_stream = &port_info->playback;
108 struct snd_pcm_substream *substream = siu_stream->substream;
109 struct device *dev = substream->pcm->card->dev;
110 struct dma_async_tx_descriptor *desc;
112 struct scatterlist sg;
115 sg_init_table(&sg, 1);
116 sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),
117 size, offset_in_page(buff));
118 sg_dma_len(&sg) = size;
119 sg_dma_address(&sg) = buff;
121 desc = dmaengine_prep_slave_sg(siu_stream->chan,
122 &sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
124 dev_err(dev, "Failed to allocate a dma descriptor\n");
128 desc->callback = siu_dma_tx_complete;
129 desc->callback_param = siu_stream;
130 cookie = dmaengine_submit(desc);
132 dev_err(dev, "Failed to submit a dma transfer\n");
136 siu_stream->tx_desc = desc;
137 siu_stream->cookie = cookie;
139 dma_async_issue_pending(siu_stream->chan);
141 /* only output FIFO enable */
142 stfifo = siu_read32(base + SIU_STFIFO);
143 siu_write32(base + SIU_STFIFO, stfifo | (port_info->stfifo & 0x0c180c18));
144 dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
145 stfifo, stfifo | (port_info->stfifo & 0x0c180c18));
150 static int siu_pcm_rd_set(struct siu_port *port_info,
151 dma_addr_t buff, size_t size)
153 struct siu_info *info = siu_i2s_data;
154 u32 __iomem *base = info->reg;
155 struct siu_stream *siu_stream = &port_info->capture;
156 struct snd_pcm_substream *substream = siu_stream->substream;
157 struct device *dev = substream->pcm->card->dev;
158 struct dma_async_tx_descriptor *desc;
160 struct scatterlist sg;
163 dev_dbg(dev, "%s: %u@%llx\n", __func__, size, (unsigned long long)buff);
165 sg_init_table(&sg, 1);
166 sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)),
167 size, offset_in_page(buff));
168 sg_dma_len(&sg) = size;
169 sg_dma_address(&sg) = buff;
171 desc = dmaengine_prep_slave_sg(siu_stream->chan,
172 &sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
174 dev_err(dev, "Failed to allocate dma descriptor\n");
178 desc->callback = siu_dma_tx_complete;
179 desc->callback_param = siu_stream;
180 cookie = dmaengine_submit(desc);
182 dev_err(dev, "Failed to submit dma descriptor\n");
186 siu_stream->tx_desc = desc;
187 siu_stream->cookie = cookie;
189 dma_async_issue_pending(siu_stream->chan);
191 /* only input FIFO enable */
192 stfifo = siu_read32(base + SIU_STFIFO);
193 siu_write32(base + SIU_STFIFO, siu_read32(base + SIU_STFIFO) |
194 (port_info->stfifo & 0x13071307));
195 dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
196 stfifo, stfifo | (port_info->stfifo & 0x13071307));
201 static void siu_io_tasklet(unsigned long data)
203 struct siu_stream *siu_stream = (struct siu_stream *)data;
204 struct snd_pcm_substream *substream = siu_stream->substream;
205 struct device *dev = substream->pcm->card->dev;
206 struct snd_pcm_runtime *rt = substream->runtime;
207 struct siu_port *port_info = siu_port_info(substream);
209 dev_dbg(dev, "%s: flags %x\n", __func__, siu_stream->rw_flg);
211 if (!siu_stream->rw_flg) {
212 dev_dbg(dev, "%s: stream inactive\n", __func__);
216 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
221 buff = (dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
222 siu_stream->cur_period,
223 siu_stream->period_bytes);
224 virt = PERIOD_OFFSET(rt->dma_area,
225 siu_stream->cur_period,
226 siu_stream->period_bytes);
227 count = siu_stream->period_bytes;
229 /* DMA transfer start */
230 siu_pcm_rd_set(port_info, buff, count);
232 siu_pcm_wr_set(port_info,
233 (dma_addr_t)PERIOD_OFFSET(rt->dma_addr,
234 siu_stream->cur_period,
235 siu_stream->period_bytes),
236 siu_stream->period_bytes);
241 static int siu_pcm_stmread_start(struct siu_port *port_info)
243 struct siu_stream *siu_stream = &port_info->capture;
245 if (siu_stream->xfer_cnt > 0x1000000)
247 if (siu_stream->rw_flg)
250 /* Current period in buffer */
251 siu_stream->cur_period = 0;
253 /* during stmread flag set */
254 siu_stream->rw_flg = RWF_STM_RD;
256 tasklet_schedule(&siu_stream->tasklet);
261 static int siu_pcm_stmread_stop(struct siu_port *port_info)
263 struct siu_info *info = siu_i2s_data;
264 u32 __iomem *base = info->reg;
265 struct siu_stream *siu_stream = &port_info->capture;
266 struct device *dev = siu_stream->substream->pcm->card->dev;
269 if (!siu_stream->rw_flg)
272 /* input FIFO disable */
273 stfifo = siu_read32(base + SIU_STFIFO);
274 siu_write32(base + SIU_STFIFO, stfifo & ~0x13071307);
275 dev_dbg(dev, "%s: STFIFO %x -> %x\n", __func__,
276 stfifo, stfifo & ~0x13071307);
278 /* during stmread flag clear */
279 siu_stream->rw_flg = 0;
284 static int siu_pcm_hw_params(struct snd_soc_component *component,
285 struct snd_pcm_substream *ss,
286 struct snd_pcm_hw_params *hw_params)
288 struct siu_info *info = siu_i2s_data;
289 struct device *dev = ss->pcm->card->dev;
292 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
294 ret = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw_params));
296 dev_err(dev, "snd_pcm_lib_malloc_pages() failed\n");
301 static int siu_pcm_hw_free(struct snd_soc_component *component,
302 struct snd_pcm_substream *ss)
304 struct siu_info *info = siu_i2s_data;
305 struct siu_port *port_info = siu_port_info(ss);
306 struct device *dev = ss->pcm->card->dev;
307 struct siu_stream *siu_stream;
309 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
310 siu_stream = &port_info->playback;
312 siu_stream = &port_info->capture;
314 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
316 return snd_pcm_lib_free_pages(ss);
319 static bool filter(struct dma_chan *chan, void *slave)
321 struct sh_dmae_slave *param = slave;
323 pr_debug("%s: slave ID %d\n", __func__, param->shdma_slave.slave_id);
325 chan->private = ¶m->shdma_slave;
329 static int siu_pcm_open(struct snd_soc_component *component,
330 struct snd_pcm_substream *ss)
332 /* Playback / Capture */
333 struct siu_platform *pdata = component->dev->platform_data;
334 struct siu_info *info = siu_i2s_data;
335 struct siu_port *port_info = siu_port_info(ss);
336 struct siu_stream *siu_stream;
337 u32 port = info->port_id;
338 struct device *dev = ss->pcm->card->dev;
340 struct sh_dmae_slave *param;
343 dma_cap_set(DMA_SLAVE, mask);
345 dev_dbg(dev, "%s, port=%d@%p\n", __func__, port, port_info);
347 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) {
348 siu_stream = &port_info->playback;
349 param = &siu_stream->param;
350 param->shdma_slave.slave_id = port ? pdata->dma_slave_tx_b :
351 pdata->dma_slave_tx_a;
353 siu_stream = &port_info->capture;
354 param = &siu_stream->param;
355 param->shdma_slave.slave_id = port ? pdata->dma_slave_rx_b :
356 pdata->dma_slave_rx_a;
359 /* Get DMA channel */
360 siu_stream->chan = dma_request_channel(mask, filter, param);
361 if (!siu_stream->chan) {
362 dev_err(dev, "DMA channel allocation failed!\n");
366 siu_stream->substream = ss;
371 static int siu_pcm_close(struct snd_soc_component *component,
372 struct snd_pcm_substream *ss)
374 struct siu_info *info = siu_i2s_data;
375 struct device *dev = ss->pcm->card->dev;
376 struct siu_port *port_info = siu_port_info(ss);
377 struct siu_stream *siu_stream;
379 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id);
381 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
382 siu_stream = &port_info->playback;
384 siu_stream = &port_info->capture;
386 dma_release_channel(siu_stream->chan);
387 siu_stream->chan = NULL;
389 siu_stream->substream = NULL;
394 static int siu_pcm_prepare(struct snd_soc_component *component,
395 struct snd_pcm_substream *ss)
397 struct siu_info *info = siu_i2s_data;
398 struct siu_port *port_info = siu_port_info(ss);
399 struct device *dev = ss->pcm->card->dev;
400 struct snd_pcm_runtime *rt = ss->runtime;
401 struct siu_stream *siu_stream;
402 snd_pcm_sframes_t xfer_cnt;
404 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
405 siu_stream = &port_info->playback;
407 siu_stream = &port_info->capture;
409 rt = siu_stream->substream->runtime;
411 siu_stream->buf_bytes = snd_pcm_lib_buffer_bytes(ss);
412 siu_stream->period_bytes = snd_pcm_lib_period_bytes(ss);
414 dev_dbg(dev, "%s: port=%d, %d channels, period=%u bytes\n", __func__,
415 info->port_id, rt->channels, siu_stream->period_bytes);
417 /* We only support buffers that are multiples of the period */
418 if (siu_stream->buf_bytes % siu_stream->period_bytes) {
419 dev_err(dev, "%s() - buffer=%d not multiple of period=%d\n",
420 __func__, siu_stream->buf_bytes,
421 siu_stream->period_bytes);
425 xfer_cnt = bytes_to_frames(rt, siu_stream->period_bytes);
426 if (!xfer_cnt || xfer_cnt > 0x1000000)
429 siu_stream->format = rt->format;
430 siu_stream->xfer_cnt = xfer_cnt;
432 dev_dbg(dev, "port=%d buf=%lx buf_bytes=%d period_bytes=%d "
433 "format=%d channels=%d xfer_cnt=%d\n", info->port_id,
434 (unsigned long)rt->dma_addr, siu_stream->buf_bytes,
435 siu_stream->period_bytes,
436 siu_stream->format, rt->channels, (int)xfer_cnt);
441 static int siu_pcm_trigger(struct snd_soc_component *component,
442 struct snd_pcm_substream *ss, int cmd)
444 struct siu_info *info = siu_i2s_data;
445 struct device *dev = ss->pcm->card->dev;
446 struct siu_port *port_info = siu_port_info(ss);
449 dev_dbg(dev, "%s: port=%d@%p, cmd=%d\n", __func__,
450 info->port_id, port_info, cmd);
453 case SNDRV_PCM_TRIGGER_START:
454 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
455 ret = siu_pcm_stmwrite_start(port_info);
457 ret = siu_pcm_stmread_start(port_info);
460 dev_warn(dev, "%s: start failed on port=%d\n",
461 __func__, info->port_id);
464 case SNDRV_PCM_TRIGGER_STOP:
465 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
466 siu_pcm_stmwrite_stop(port_info);
468 siu_pcm_stmread_stop(port_info);
473 dev_err(dev, "%s() unsupported cmd=%d\n", __func__, cmd);
481 * So far only resolution of one period is supported, subject to extending the
484 static snd_pcm_uframes_t
485 siu_pcm_pointer_dma(struct snd_soc_component *component,
486 struct snd_pcm_substream *ss)
488 struct device *dev = ss->pcm->card->dev;
489 struct siu_info *info = siu_i2s_data;
490 u32 __iomem *base = info->reg;
491 struct siu_port *port_info = siu_port_info(ss);
492 struct snd_pcm_runtime *rt = ss->runtime;
494 struct siu_stream *siu_stream;
496 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK)
497 siu_stream = &port_info->playback;
499 siu_stream = &port_info->capture;
502 * ptr is the offset into the buffer where the dma is currently at. We
503 * check if the dma buffer has just wrapped.
505 ptr = PERIOD_OFFSET(rt->dma_addr,
506 siu_stream->cur_period,
507 siu_stream->period_bytes) - rt->dma_addr;
510 "%s: port=%d, events %x, FSTS %x, xferred %u/%u, cookie %d\n",
511 __func__, info->port_id, siu_read32(base + SIU_EVNTC),
512 siu_read32(base + SIU_SBFSTS), ptr, siu_stream->buf_bytes,
515 if (ptr >= siu_stream->buf_bytes)
518 return bytes_to_frames(ss->runtime, ptr);
521 static int siu_pcm_new(struct snd_soc_component *component,
522 struct snd_soc_pcm_runtime *rtd)
524 /* card->dev == socdev->dev, see snd_soc_new_pcms() */
525 struct snd_card *card = rtd->card->snd_card;
526 struct snd_pcm *pcm = rtd->pcm;
527 struct siu_info *info = siu_i2s_data;
528 struct platform_device *pdev = to_platform_device(card->dev);
532 /* pdev->id selects between SIUA and SIUB */
533 if (pdev->id < 0 || pdev->id >= SIU_PORT_NUM)
536 info->port_id = pdev->id;
539 * While the siu has 2 ports, only one port can be on at a time (only 1
540 * SPB). So far all the boards using the siu had only one of the ports
541 * wired to a codec. To simplify things, we only register one port with
542 * alsa. In case both ports are needed, it should be changed here
544 for (i = pdev->id; i < pdev->id + 1; i++) {
545 struct siu_port **port_info = &siu_ports[i];
547 ret = siu_init_port(i, port_info, card);
551 snd_pcm_lib_preallocate_pages_for_all(pcm,
552 SNDRV_DMA_TYPE_DEV, card->dev,
553 SIU_BUFFER_BYTES_MAX, SIU_BUFFER_BYTES_MAX);
555 (*port_info)->pcm = pcm;
558 tasklet_init(&(*port_info)->playback.tasklet, siu_io_tasklet,
559 (unsigned long)&(*port_info)->playback);
560 tasklet_init(&(*port_info)->capture.tasklet, siu_io_tasklet,
561 (unsigned long)&(*port_info)->capture);
564 dev_info(card->dev, "SuperH SIU driver initialized.\n");
568 static void siu_pcm_free(struct snd_soc_component *component,
571 struct platform_device *pdev = to_platform_device(pcm->card->dev);
572 struct siu_port *port_info = siu_ports[pdev->id];
574 tasklet_kill(&port_info->capture.tasklet);
575 tasklet_kill(&port_info->playback.tasklet);
577 siu_free_port(port_info);
579 dev_dbg(pcm->card->dev, "%s\n", __func__);
582 struct const snd_soc_component_driver siu_component = {
584 .open = siu_pcm_open,
585 .close = siu_pcm_close,
586 .ioctl = snd_soc_pcm_lib_ioctl,
587 .hw_params = siu_pcm_hw_params,
588 .hw_free = siu_pcm_hw_free,
589 .prepare = siu_pcm_prepare,
590 .trigger = siu_pcm_trigger,
591 .pointer = siu_pcm_pointer_dma,
592 .pcm_construct = siu_pcm_new,
593 .pcm_destruct = siu_pcm_free,
595 EXPORT_SYMBOL_GPL(siu_component);