1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // siu_pcm.c - ALSA driver for Renesas SH7343, SH7722 SIU peripheral. 4 // 5 // Copyright (C) 2009-2010 Guennadi Liakhovetski <g.liakhovetski@gmx.de> 6 // Copyright (C) 2006 Carlos Munoz <carlos@kenati.com> 7 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> 14 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> 20 21 #include <asm/siu.h> 22 23 #include "siu.h" 24 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))) 30 31 #define RWF_STM_RD 0x01 /* Read in progress */ 32 #define RWF_STM_WT 0x02 /* Write in progress */ 33 34 struct siu_port *siu_ports[SIU_PORT_NUM]; 35 36 /* transfersize is number of u32 dma transfers per period */ 37 static int siu_pcm_stmwrite_stop(struct siu_port *port_info) 38 { 39 struct siu_info *info = siu_i2s_data; 40 u32 __iomem *base = info->reg; 41 struct siu_stream *siu_stream = &port_info->playback; 42 u32 stfifo; 43 44 if (!siu_stream->rw_flg) 45 return -EPERM; 46 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); 52 53 /* during stmwrite clear */ 54 siu_stream->rw_flg = 0; 55 56 return 0; 57 } 58 59 static int siu_pcm_stmwrite_start(struct siu_port *port_info) 60 { 61 struct siu_stream *siu_stream = &port_info->playback; 62 63 if (siu_stream->rw_flg) 64 return -EPERM; 65 66 /* Current period in buffer */ 67 port_info->playback.cur_period = 0; 68 69 /* during stmwrite flag set */ 70 siu_stream->rw_flg = RWF_STM_WT; 71 72 /* DMA transfer start */ 73 tasklet_schedule(&siu_stream->tasklet); 74 75 return 0; 76 } 77 78 static void siu_dma_tx_complete(void *arg) 79 { 80 struct siu_stream *siu_stream = arg; 81 82 if (!siu_stream->rw_flg) 83 return; 84 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; 90 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); 95 96 tasklet_schedule(&siu_stream->tasklet); 97 98 /* Notify alsa: a period is done */ 99 snd_pcm_period_elapsed(siu_stream->substream); 100 } 101 102 static int siu_pcm_wr_set(struct siu_port *port_info, 103 dma_addr_t buff, u32 size) 104 { 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; 111 dma_cookie_t cookie; 112 struct scatterlist sg; 113 u32 stfifo; 114 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; 120 121 desc = dmaengine_prep_slave_sg(siu_stream->chan, 122 &sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 123 if (!desc) { 124 dev_err(dev, "Failed to allocate a dma descriptor\n"); 125 return -ENOMEM; 126 } 127 128 desc->callback = siu_dma_tx_complete; 129 desc->callback_param = siu_stream; 130 cookie = dmaengine_submit(desc); 131 if (cookie < 0) { 132 dev_err(dev, "Failed to submit a dma transfer\n"); 133 return cookie; 134 } 135 136 siu_stream->tx_desc = desc; 137 siu_stream->cookie = cookie; 138 139 dma_async_issue_pending(siu_stream->chan); 140 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)); 146 147 return 0; 148 } 149 150 static int siu_pcm_rd_set(struct siu_port *port_info, 151 dma_addr_t buff, size_t size) 152 { 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; 159 dma_cookie_t cookie; 160 struct scatterlist sg; 161 u32 stfifo; 162 163 dev_dbg(dev, "%s: %u@%llx\n", __func__, size, (unsigned long long)buff); 164 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; 170 171 desc = dmaengine_prep_slave_sg(siu_stream->chan, 172 &sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 173 if (!desc) { 174 dev_err(dev, "Failed to allocate dma descriptor\n"); 175 return -ENOMEM; 176 } 177 178 desc->callback = siu_dma_tx_complete; 179 desc->callback_param = siu_stream; 180 cookie = dmaengine_submit(desc); 181 if (cookie < 0) { 182 dev_err(dev, "Failed to submit dma descriptor\n"); 183 return cookie; 184 } 185 186 siu_stream->tx_desc = desc; 187 siu_stream->cookie = cookie; 188 189 dma_async_issue_pending(siu_stream->chan); 190 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)); 197 198 return 0; 199 } 200 201 static void siu_io_tasklet(unsigned long data) 202 { 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); 208 209 dev_dbg(dev, "%s: flags %x\n", __func__, siu_stream->rw_flg); 210 211 if (!siu_stream->rw_flg) { 212 dev_dbg(dev, "%s: stream inactive\n", __func__); 213 return; 214 } 215 216 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 217 dma_addr_t buff; 218 size_t count; 219 u8 *virt; 220 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; 228 229 /* DMA transfer start */ 230 siu_pcm_rd_set(port_info, buff, count); 231 } else { 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); 237 } 238 } 239 240 /* Capture */ 241 static int siu_pcm_stmread_start(struct siu_port *port_info) 242 { 243 struct siu_stream *siu_stream = &port_info->capture; 244 245 if (siu_stream->xfer_cnt > 0x1000000) 246 return -EINVAL; 247 if (siu_stream->rw_flg) 248 return -EPERM; 249 250 /* Current period in buffer */ 251 siu_stream->cur_period = 0; 252 253 /* during stmread flag set */ 254 siu_stream->rw_flg = RWF_STM_RD; 255 256 tasklet_schedule(&siu_stream->tasklet); 257 258 return 0; 259 } 260 261 static int siu_pcm_stmread_stop(struct siu_port *port_info) 262 { 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; 267 u32 stfifo; 268 269 if (!siu_stream->rw_flg) 270 return -EPERM; 271 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); 277 278 /* during stmread flag clear */ 279 siu_stream->rw_flg = 0; 280 281 return 0; 282 } 283 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) 287 { 288 struct siu_info *info = siu_i2s_data; 289 struct device *dev = ss->pcm->card->dev; 290 int ret; 291 292 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id); 293 294 ret = snd_pcm_lib_malloc_pages(ss, params_buffer_bytes(hw_params)); 295 if (ret < 0) 296 dev_err(dev, "snd_pcm_lib_malloc_pages() failed\n"); 297 298 return ret; 299 } 300 301 static int siu_pcm_hw_free(struct snd_soc_component *component, 302 struct snd_pcm_substream *ss) 303 { 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; 308 309 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 310 siu_stream = &port_info->playback; 311 else 312 siu_stream = &port_info->capture; 313 314 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id); 315 316 return snd_pcm_lib_free_pages(ss); 317 } 318 319 static bool filter(struct dma_chan *chan, void *slave) 320 { 321 struct sh_dmae_slave *param = slave; 322 323 pr_debug("%s: slave ID %d\n", __func__, param->shdma_slave.slave_id); 324 325 chan->private = ¶m->shdma_slave; 326 return true; 327 } 328 329 static int siu_pcm_open(struct snd_soc_component *component, 330 struct snd_pcm_substream *ss) 331 { 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; 339 dma_cap_mask_t mask; 340 struct sh_dmae_slave *param; 341 342 dma_cap_zero(mask); 343 dma_cap_set(DMA_SLAVE, mask); 344 345 dev_dbg(dev, "%s, port=%d@%p\n", __func__, port, port_info); 346 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; 352 } else { 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; 357 } 358 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"); 363 return -EBUSY; 364 } 365 366 siu_stream->substream = ss; 367 368 return 0; 369 } 370 371 static int siu_pcm_close(struct snd_soc_component *component, 372 struct snd_pcm_substream *ss) 373 { 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; 378 379 dev_dbg(dev, "%s: port=%d\n", __func__, info->port_id); 380 381 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 382 siu_stream = &port_info->playback; 383 else 384 siu_stream = &port_info->capture; 385 386 dma_release_channel(siu_stream->chan); 387 siu_stream->chan = NULL; 388 389 siu_stream->substream = NULL; 390 391 return 0; 392 } 393 394 static int siu_pcm_prepare(struct snd_soc_component *component, 395 struct snd_pcm_substream *ss) 396 { 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; 403 404 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 405 siu_stream = &port_info->playback; 406 else 407 siu_stream = &port_info->capture; 408 409 rt = siu_stream->substream->runtime; 410 411 siu_stream->buf_bytes = snd_pcm_lib_buffer_bytes(ss); 412 siu_stream->period_bytes = snd_pcm_lib_period_bytes(ss); 413 414 dev_dbg(dev, "%s: port=%d, %d channels, period=%u bytes\n", __func__, 415 info->port_id, rt->channels, siu_stream->period_bytes); 416 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); 422 return -EINVAL; 423 } 424 425 xfer_cnt = bytes_to_frames(rt, siu_stream->period_bytes); 426 if (!xfer_cnt || xfer_cnt > 0x1000000) 427 return -EINVAL; 428 429 siu_stream->format = rt->format; 430 siu_stream->xfer_cnt = xfer_cnt; 431 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); 437 438 return 0; 439 } 440 441 static int siu_pcm_trigger(struct snd_soc_component *component, 442 struct snd_pcm_substream *ss, int cmd) 443 { 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); 447 int ret; 448 449 dev_dbg(dev, "%s: port=%d@%p, cmd=%d\n", __func__, 450 info->port_id, port_info, cmd); 451 452 switch (cmd) { 453 case SNDRV_PCM_TRIGGER_START: 454 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 455 ret = siu_pcm_stmwrite_start(port_info); 456 else 457 ret = siu_pcm_stmread_start(port_info); 458 459 if (ret < 0) 460 dev_warn(dev, "%s: start failed on port=%d\n", 461 __func__, info->port_id); 462 463 break; 464 case SNDRV_PCM_TRIGGER_STOP: 465 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 466 siu_pcm_stmwrite_stop(port_info); 467 else 468 siu_pcm_stmread_stop(port_info); 469 ret = 0; 470 471 break; 472 default: 473 dev_err(dev, "%s() unsupported cmd=%d\n", __func__, cmd); 474 ret = -EINVAL; 475 } 476 477 return ret; 478 } 479 480 /* 481 * So far only resolution of one period is supported, subject to extending the 482 * dmangine API 483 */ 484 static snd_pcm_uframes_t 485 siu_pcm_pointer_dma(struct snd_soc_component *component, 486 struct snd_pcm_substream *ss) 487 { 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; 493 size_t ptr; 494 struct siu_stream *siu_stream; 495 496 if (ss->stream == SNDRV_PCM_STREAM_PLAYBACK) 497 siu_stream = &port_info->playback; 498 else 499 siu_stream = &port_info->capture; 500 501 /* 502 * ptr is the offset into the buffer where the dma is currently at. We 503 * check if the dma buffer has just wrapped. 504 */ 505 ptr = PERIOD_OFFSET(rt->dma_addr, 506 siu_stream->cur_period, 507 siu_stream->period_bytes) - rt->dma_addr; 508 509 dev_dbg(dev, 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, 513 siu_stream->cookie); 514 515 if (ptr >= siu_stream->buf_bytes) 516 ptr = 0; 517 518 return bytes_to_frames(ss->runtime, ptr); 519 } 520 521 static int siu_pcm_new(struct snd_soc_component *component, 522 struct snd_soc_pcm_runtime *rtd) 523 { 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); 529 int ret; 530 int i; 531 532 /* pdev->id selects between SIUA and SIUB */ 533 if (pdev->id < 0 || pdev->id >= SIU_PORT_NUM) 534 return -EINVAL; 535 536 info->port_id = pdev->id; 537 538 /* 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 543 */ 544 for (i = pdev->id; i < pdev->id + 1; i++) { 545 struct siu_port **port_info = &siu_ports[i]; 546 547 ret = siu_init_port(i, port_info, card); 548 if (ret < 0) 549 return ret; 550 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); 554 555 (*port_info)->pcm = pcm; 556 557 /* IO tasklets */ 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); 562 } 563 564 dev_info(card->dev, "SuperH SIU driver initialized.\n"); 565 return 0; 566 } 567 568 static void siu_pcm_free(struct snd_soc_component *component, 569 struct snd_pcm *pcm) 570 { 571 struct platform_device *pdev = to_platform_device(pcm->card->dev); 572 struct siu_port *port_info = siu_ports[pdev->id]; 573 574 tasklet_kill(&port_info->capture.tasklet); 575 tasklet_kill(&port_info->playback.tasklet); 576 577 siu_free_port(port_info); 578 579 dev_dbg(pcm->card->dev, "%s\n", __func__); 580 } 581 582 struct const snd_soc_component_driver siu_component = { 583 .name = DRV_NAME, 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, 594 }; 595 EXPORT_SYMBOL_GPL(siu_component); 596