1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Renesas R-Car Audio DMAC support 4 // 5 // Copyright (C) 2015 Renesas Electronics Corp. 6 // Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 7 8 #include <linux/delay.h> 9 #include <linux/of_dma.h> 10 #include "rsnd.h" 11 12 /* 13 * Audio DMAC peri peri register 14 */ 15 #define PDMASAR 0x00 16 #define PDMADAR 0x04 17 #define PDMACHCR 0x0c 18 19 /* PDMACHCR */ 20 #define PDMACHCR_DE (1 << 0) 21 22 23 struct rsnd_dmaen { 24 struct dma_chan *chan; 25 dma_cookie_t cookie; 26 unsigned int dma_len; 27 }; 28 29 struct rsnd_dmapp { 30 int dmapp_id; 31 u32 chcr; 32 }; 33 34 struct rsnd_dma { 35 struct rsnd_mod mod; 36 struct rsnd_mod *mod_from; 37 struct rsnd_mod *mod_to; 38 dma_addr_t src_addr; 39 dma_addr_t dst_addr; 40 union { 41 struct rsnd_dmaen en; 42 struct rsnd_dmapp pp; 43 } dma; 44 }; 45 46 struct rsnd_dma_ctrl { 47 void __iomem *ppbase; 48 phys_addr_t ppres; 49 int dmaen_num; 50 int dmapp_num; 51 }; 52 53 #define rsnd_priv_to_dmac(p) ((struct rsnd_dma_ctrl *)(p)->dma) 54 #define rsnd_mod_to_dma(_mod) container_of((_mod), struct rsnd_dma, mod) 55 #define rsnd_dma_to_dmaen(dma) (&(dma)->dma.en) 56 #define rsnd_dma_to_dmapp(dma) (&(dma)->dma.pp) 57 58 /* for DEBUG */ 59 static struct rsnd_mod_ops mem_ops = { 60 .name = "mem", 61 }; 62 63 static struct rsnd_mod mem = { 64 }; 65 66 /* 67 * Audio DMAC 68 */ 69 static void __rsnd_dmaen_complete(struct rsnd_mod *mod, 70 struct rsnd_dai_stream *io) 71 { 72 if (rsnd_io_is_working(io)) 73 rsnd_dai_period_elapsed(io); 74 } 75 76 static void rsnd_dmaen_complete(void *data) 77 { 78 struct rsnd_mod *mod = data; 79 80 rsnd_mod_interrupt(mod, __rsnd_dmaen_complete); 81 } 82 83 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io, 84 struct rsnd_mod *mod_from, 85 struct rsnd_mod *mod_to) 86 { 87 if ((!mod_from && !mod_to) || 88 (mod_from && mod_to)) 89 return NULL; 90 91 if (mod_from) 92 return rsnd_mod_dma_req(io, mod_from); 93 else 94 return rsnd_mod_dma_req(io, mod_to); 95 } 96 97 static int rsnd_dmaen_stop(struct rsnd_mod *mod, 98 struct rsnd_dai_stream *io, 99 struct rsnd_priv *priv) 100 { 101 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 102 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 103 104 if (dmaen->chan) 105 dmaengine_terminate_all(dmaen->chan); 106 107 return 0; 108 } 109 110 static int rsnd_dmaen_cleanup(struct rsnd_mod *mod, 111 struct rsnd_dai_stream *io, 112 struct rsnd_priv *priv) 113 { 114 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 115 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 116 117 /* 118 * DMAEngine release uses mutex lock. 119 * Thus, it shouldn't be called under spinlock. 120 * Let's call it under prepare 121 */ 122 if (dmaen->chan) 123 dma_release_channel(dmaen->chan); 124 125 dmaen->chan = NULL; 126 127 return 0; 128 } 129 130 static int rsnd_dmaen_prepare(struct rsnd_mod *mod, 131 struct rsnd_dai_stream *io, 132 struct rsnd_priv *priv) 133 { 134 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 135 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 136 struct device *dev = rsnd_priv_to_dev(priv); 137 138 /* maybe suspended */ 139 if (dmaen->chan) 140 return 0; 141 142 /* 143 * DMAEngine request uses mutex lock. 144 * Thus, it shouldn't be called under spinlock. 145 * Let's call it under prepare 146 */ 147 dmaen->chan = rsnd_dmaen_request_channel(io, 148 dma->mod_from, 149 dma->mod_to); 150 if (IS_ERR_OR_NULL(dmaen->chan)) { 151 dmaen->chan = NULL; 152 dev_err(dev, "can't get dma channel\n"); 153 return -EIO; 154 } 155 156 return 0; 157 } 158 159 static int rsnd_dmaen_start(struct rsnd_mod *mod, 160 struct rsnd_dai_stream *io, 161 struct rsnd_priv *priv) 162 { 163 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 164 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 165 struct snd_pcm_substream *substream = io->substream; 166 struct device *dev = rsnd_priv_to_dev(priv); 167 struct dma_async_tx_descriptor *desc; 168 struct dma_slave_config cfg = {}; 169 enum dma_slave_buswidth buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES; 170 int is_play = rsnd_io_is_play(io); 171 int ret; 172 173 /* 174 * in case of monaural data writing or reading through Audio-DMAC 175 * data is always in Left Justified format, so both src and dst 176 * DMA Bus width need to be set equal to physical data width. 177 */ 178 if (rsnd_runtime_channel_original(io) == 1) { 179 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 180 int bits = snd_pcm_format_physical_width(runtime->format); 181 182 switch (bits) { 183 case 8: 184 buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE; 185 break; 186 case 16: 187 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; 188 break; 189 case 32: 190 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES; 191 break; 192 default: 193 dev_err(dev, "invalid format width %d\n", bits); 194 return -EINVAL; 195 } 196 } 197 198 cfg.direction = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; 199 cfg.src_addr = dma->src_addr; 200 cfg.dst_addr = dma->dst_addr; 201 cfg.src_addr_width = buswidth; 202 cfg.dst_addr_width = buswidth; 203 204 dev_dbg(dev, "%s %pad -> %pad\n", 205 rsnd_mod_name(mod), 206 &cfg.src_addr, &cfg.dst_addr); 207 208 ret = dmaengine_slave_config(dmaen->chan, &cfg); 209 if (ret < 0) 210 return ret; 211 212 desc = dmaengine_prep_dma_cyclic(dmaen->chan, 213 substream->runtime->dma_addr, 214 snd_pcm_lib_buffer_bytes(substream), 215 snd_pcm_lib_period_bytes(substream), 216 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM, 217 DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 218 219 if (!desc) { 220 dev_err(dev, "dmaengine_prep_slave_sg() fail\n"); 221 return -EIO; 222 } 223 224 desc->callback = rsnd_dmaen_complete; 225 desc->callback_param = rsnd_mod_get(dma); 226 227 dmaen->dma_len = snd_pcm_lib_buffer_bytes(substream); 228 229 dmaen->cookie = dmaengine_submit(desc); 230 if (dmaen->cookie < 0) { 231 dev_err(dev, "dmaengine_submit() fail\n"); 232 return -EIO; 233 } 234 235 dma_async_issue_pending(dmaen->chan); 236 237 return 0; 238 } 239 240 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node, 241 struct rsnd_mod *mod, char *name) 242 { 243 struct dma_chan *chan = NULL; 244 struct device_node *np; 245 int i = 0; 246 247 for_each_child_of_node(of_node, np) { 248 if (i == rsnd_mod_id_raw(mod) && (!chan)) 249 chan = of_dma_request_slave_channel(np, name); 250 i++; 251 } 252 253 /* It should call of_node_put(), since, it is rsnd_xxx_of_node() */ 254 of_node_put(of_node); 255 256 return chan; 257 } 258 259 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io, 260 struct rsnd_dma *dma, 261 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 262 { 263 struct rsnd_priv *priv = rsnd_io_to_priv(io); 264 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 265 struct dma_chan *chan; 266 267 /* try to get DMAEngine channel */ 268 chan = rsnd_dmaen_request_channel(io, mod_from, mod_to); 269 if (IS_ERR_OR_NULL(chan)) { 270 /* Let's follow when -EPROBE_DEFER case */ 271 if (PTR_ERR(chan) == -EPROBE_DEFER) 272 return PTR_ERR(chan); 273 274 /* 275 * DMA failed. try to PIO mode 276 * see 277 * rsnd_ssi_fallback() 278 * rsnd_rdai_continuance_probe() 279 */ 280 return -EAGAIN; 281 } 282 283 /* 284 * use it for IPMMU if needed 285 * see 286 * rsnd_preallocate_pages() 287 */ 288 io->dmac_dev = chan->device->dev; 289 290 dma_release_channel(chan); 291 292 dmac->dmaen_num++; 293 294 return 0; 295 } 296 297 static int rsnd_dmaen_pointer(struct rsnd_mod *mod, 298 struct rsnd_dai_stream *io, 299 snd_pcm_uframes_t *pointer) 300 { 301 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 302 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 303 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 304 struct dma_tx_state state; 305 enum dma_status status; 306 unsigned int pos = 0; 307 308 status = dmaengine_tx_status(dmaen->chan, dmaen->cookie, &state); 309 if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) { 310 if (state.residue > 0 && state.residue <= dmaen->dma_len) 311 pos = dmaen->dma_len - state.residue; 312 } 313 *pointer = bytes_to_frames(runtime, pos); 314 315 return 0; 316 } 317 318 static struct rsnd_mod_ops rsnd_dmaen_ops = { 319 .name = "audmac", 320 .prepare = rsnd_dmaen_prepare, 321 .cleanup = rsnd_dmaen_cleanup, 322 .start = rsnd_dmaen_start, 323 .stop = rsnd_dmaen_stop, 324 .pointer = rsnd_dmaen_pointer, 325 .get_status = rsnd_mod_get_status, 326 }; 327 328 /* 329 * Audio DMAC peri peri 330 */ 331 static const u8 gen2_id_table_ssiu[] = { 332 /* SSI00 ~ SSI07 */ 333 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c, 334 /* SSI10 ~ SSI17 */ 335 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40, 336 /* SSI20 ~ SSI27 */ 337 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44, 338 /* SSI30 ~ SSI37 */ 339 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 340 /* SSI40 ~ SSI47 */ 341 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 342 /* SSI5 */ 343 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 344 /* SSI6 */ 345 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 346 /* SSI7 */ 347 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 348 /* SSI8 */ 349 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 350 /* SSI90 ~ SSI97 */ 351 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56, 352 }; 353 static const u8 gen2_id_table_scu[] = { 354 0x2d, /* SCU_SRCI0 */ 355 0x2e, /* SCU_SRCI1 */ 356 0x2f, /* SCU_SRCI2 */ 357 0x30, /* SCU_SRCI3 */ 358 0x31, /* SCU_SRCI4 */ 359 0x32, /* SCU_SRCI5 */ 360 0x33, /* SCU_SRCI6 */ 361 0x34, /* SCU_SRCI7 */ 362 0x35, /* SCU_SRCI8 */ 363 0x36, /* SCU_SRCI9 */ 364 }; 365 static const u8 gen2_id_table_cmd[] = { 366 0x37, /* SCU_CMD0 */ 367 0x38, /* SCU_CMD1 */ 368 }; 369 370 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io, 371 struct rsnd_mod *mod) 372 { 373 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); 374 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); 375 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 376 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 377 const u8 *entry = NULL; 378 int id = 255; 379 int size = 0; 380 381 if ((mod == ssi) || 382 (mod == ssiu)) { 383 int busif = rsnd_mod_id_sub(ssiu); 384 385 entry = gen2_id_table_ssiu; 386 size = ARRAY_SIZE(gen2_id_table_ssiu); 387 id = (rsnd_mod_id(mod) * 8) + busif; 388 } else if (mod == src) { 389 entry = gen2_id_table_scu; 390 size = ARRAY_SIZE(gen2_id_table_scu); 391 id = rsnd_mod_id(mod); 392 } else if (mod == dvc) { 393 entry = gen2_id_table_cmd; 394 size = ARRAY_SIZE(gen2_id_table_cmd); 395 id = rsnd_mod_id(mod); 396 } 397 398 if ((!entry) || (size <= id)) { 399 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); 400 401 dev_err(dev, "unknown connection (%s)\n", rsnd_mod_name(mod)); 402 403 /* use non-prohibited SRS number as error */ 404 return 0x00; /* SSI00 */ 405 } 406 407 return entry[id]; 408 } 409 410 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io, 411 struct rsnd_mod *mod_from, 412 struct rsnd_mod *mod_to) 413 { 414 return (rsnd_dmapp_get_id(io, mod_from) << 24) + 415 (rsnd_dmapp_get_id(io, mod_to) << 16); 416 } 417 418 #define rsnd_dmapp_addr(dmac, dma, reg) \ 419 (dmac->ppbase + 0x20 + reg + \ 420 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id)) 421 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg) 422 { 423 struct rsnd_mod *mod = rsnd_mod_get(dma); 424 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 425 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 426 struct device *dev = rsnd_priv_to_dev(priv); 427 428 dev_dbg(dev, "w 0x%px : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data); 429 430 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg)); 431 } 432 433 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg) 434 { 435 struct rsnd_mod *mod = rsnd_mod_get(dma); 436 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 437 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 438 439 return ioread32(rsnd_dmapp_addr(dmac, dma, reg)); 440 } 441 442 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg) 443 { 444 struct rsnd_mod *mod = rsnd_mod_get(dma); 445 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 446 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 447 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg); 448 u32 val = ioread32(addr); 449 450 val &= ~mask; 451 val |= (data & mask); 452 453 iowrite32(val, addr); 454 } 455 456 static int rsnd_dmapp_stop(struct rsnd_mod *mod, 457 struct rsnd_dai_stream *io, 458 struct rsnd_priv *priv) 459 { 460 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 461 int i; 462 463 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR); 464 465 for (i = 0; i < 1024; i++) { 466 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE)) 467 return 0; 468 udelay(1); 469 } 470 471 return -EIO; 472 } 473 474 static int rsnd_dmapp_start(struct rsnd_mod *mod, 475 struct rsnd_dai_stream *io, 476 struct rsnd_priv *priv) 477 { 478 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 479 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 480 481 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR); 482 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR); 483 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR); 484 485 return 0; 486 } 487 488 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io, 489 struct rsnd_dma *dma, 490 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 491 { 492 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 493 struct rsnd_priv *priv = rsnd_io_to_priv(io); 494 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 495 struct device *dev = rsnd_priv_to_dev(priv); 496 497 dmapp->dmapp_id = dmac->dmapp_num; 498 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE; 499 500 dmac->dmapp_num++; 501 502 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n", 503 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr); 504 505 return 0; 506 } 507 508 #ifdef CONFIG_DEBUG_FS 509 static void rsnd_dmapp_debug_info(struct seq_file *m, 510 struct rsnd_dai_stream *io, 511 struct rsnd_mod *mod) 512 { 513 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 514 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 515 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 516 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 517 518 rsnd_debugfs_reg_show(m, dmac->ppres, dmac->ppbase, 519 0x20 + 0x10 * dmapp->dmapp_id, 0x10); 520 } 521 #define DEBUG_INFO .debug_info = rsnd_dmapp_debug_info 522 #else 523 #define DEBUG_INFO 524 #endif 525 526 static struct rsnd_mod_ops rsnd_dmapp_ops = { 527 .name = "audmac-pp", 528 .start = rsnd_dmapp_start, 529 .stop = rsnd_dmapp_stop, 530 .quit = rsnd_dmapp_stop, 531 .get_status = rsnd_mod_get_status, 532 DEBUG_INFO 533 }; 534 535 /* 536 * Common DMAC Interface 537 */ 538 539 /* 540 * DMA read/write register offset 541 * 542 * RSND_xxx_I_N for Audio DMAC input 543 * RSND_xxx_O_N for Audio DMAC output 544 * RSND_xxx_I_P for Audio DMAC peri peri input 545 * RSND_xxx_O_P for Audio DMAC peri peri output 546 * 547 * ex) R-Car H2 case 548 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out 549 * SSI : 0xec541000 / 0xec241008 / 0xec24100c 550 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000 551 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000 552 * CMD : 0xec500000 / / 0xec008000 0xec308000 553 */ 554 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8) 555 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc) 556 557 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4))) 558 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j) 559 560 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4))) 561 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j) 562 563 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i)) 564 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i)) 565 566 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i)) 567 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i)) 568 569 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i)) 570 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i)) 571 572 static dma_addr_t 573 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io, 574 struct rsnd_mod *mod, 575 int is_play, int is_from) 576 { 577 struct rsnd_priv *priv = rsnd_io_to_priv(io); 578 struct device *dev = rsnd_priv_to_dev(priv); 579 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI); 580 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU); 581 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod) || 582 !!(rsnd_io_to_mod_ssiu(io) == mod); 583 int use_src = !!rsnd_io_to_mod_src(io); 584 int use_cmd = !!rsnd_io_to_mod_dvc(io) || 585 !!rsnd_io_to_mod_mix(io) || 586 !!rsnd_io_to_mod_ctu(io); 587 int id = rsnd_mod_id(mod); 588 int busif = rsnd_mod_id_sub(rsnd_io_to_mod_ssiu(io)); 589 struct dma_addr { 590 dma_addr_t out_addr; 591 dma_addr_t in_addr; 592 } dma_addrs[3][2][3] = { 593 /* SRC */ 594 /* Capture */ 595 {{{ 0, 0 }, 596 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) }, 597 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } }, 598 /* Playback */ 599 {{ 0, 0, }, 600 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) }, 601 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } } 602 }, 603 /* SSI */ 604 /* Capture */ 605 {{{ RDMA_SSI_O_N(ssi, id), 0 }, 606 { RDMA_SSIU_O_P(ssi, id, busif), 0 }, 607 { RDMA_SSIU_O_P(ssi, id, busif), 0 } }, 608 /* Playback */ 609 {{ 0, RDMA_SSI_I_N(ssi, id) }, 610 { 0, RDMA_SSIU_I_P(ssi, id, busif) }, 611 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } 612 }, 613 /* SSIU */ 614 /* Capture */ 615 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 }, 616 { RDMA_SSIU_O_P(ssi, id, busif), 0 }, 617 { RDMA_SSIU_O_P(ssi, id, busif), 0 } }, 618 /* Playback */ 619 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) }, 620 { 0, RDMA_SSIU_I_P(ssi, id, busif) }, 621 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } }, 622 }; 623 624 /* 625 * FIXME 626 * 627 * We can't support SSI9-4/5/6/7, because its address is 628 * out of calculation rule 629 */ 630 if ((id == 9) && (busif >= 4)) 631 dev_err(dev, "This driver doesn't support SSI%d-%d, so far", 632 id, busif); 633 634 /* it shouldn't happen */ 635 if (use_cmd && !use_src) 636 dev_err(dev, "DVC is selected without SRC\n"); 637 638 /* use SSIU or SSI ? */ 639 if (is_ssi && rsnd_ssi_use_busif(io)) 640 is_ssi++; 641 642 return (is_from) ? 643 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr : 644 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr; 645 } 646 647 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io, 648 struct rsnd_mod *mod, 649 int is_play, int is_from) 650 { 651 struct rsnd_priv *priv = rsnd_io_to_priv(io); 652 653 /* 654 * gen1 uses default DMA addr 655 */ 656 if (rsnd_is_gen1(priv)) 657 return 0; 658 659 if (!mod) 660 return 0; 661 662 return rsnd_gen2_dma_addr(io, mod, is_play, is_from); 663 } 664 665 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */ 666 static void rsnd_dma_of_path(struct rsnd_mod *this, 667 struct rsnd_dai_stream *io, 668 int is_play, 669 struct rsnd_mod **mod_from, 670 struct rsnd_mod **mod_to) 671 { 672 struct rsnd_mod *ssi; 673 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 674 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io); 675 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io); 676 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 677 struct rsnd_mod *mod[MOD_MAX]; 678 struct rsnd_mod *mod_start, *mod_end; 679 struct rsnd_priv *priv = rsnd_mod_to_priv(this); 680 struct device *dev = rsnd_priv_to_dev(priv); 681 int nr, i, idx; 682 683 /* 684 * It should use "rcar_sound,ssiu" on DT. 685 * But, we need to keep compatibility for old version. 686 * 687 * If it has "rcar_sound.ssiu", it will be used. 688 * If not, "rcar_sound.ssi" will be used. 689 * see 690 * rsnd_ssiu_dma_req() 691 * rsnd_ssi_dma_req() 692 */ 693 if (rsnd_ssiu_of_node(priv)) { 694 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); 695 696 /* use SSIU */ 697 ssi = ssiu; 698 if (this == rsnd_io_to_mod_ssi(io)) 699 this = ssiu; 700 } else { 701 /* keep compatible, use SSI */ 702 ssi = rsnd_io_to_mod_ssi(io); 703 } 704 705 if (!ssi) 706 return; 707 708 nr = 0; 709 for (i = 0; i < MOD_MAX; i++) { 710 mod[i] = NULL; 711 nr += !!rsnd_io_to_mod(io, i); 712 } 713 714 /* 715 * [S] -*-> [E] 716 * [S] -*-> SRC -o-> [E] 717 * [S] -*-> SRC -> DVC -o-> [E] 718 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E] 719 * 720 * playback [S] = mem 721 * [E] = SSI 722 * 723 * capture [S] = SSI 724 * [E] = mem 725 * 726 * -*-> Audio DMAC 727 * -o-> Audio DMAC peri peri 728 */ 729 mod_start = (is_play) ? NULL : ssi; 730 mod_end = (is_play) ? ssi : NULL; 731 732 idx = 0; 733 mod[idx++] = mod_start; 734 for (i = 1; i < nr; i++) { 735 if (src) { 736 mod[idx++] = src; 737 src = NULL; 738 } else if (ctu) { 739 mod[idx++] = ctu; 740 ctu = NULL; 741 } else if (mix) { 742 mod[idx++] = mix; 743 mix = NULL; 744 } else if (dvc) { 745 mod[idx++] = dvc; 746 dvc = NULL; 747 } 748 } 749 mod[idx] = mod_end; 750 751 /* 752 * | SSI | SRC | 753 * -------------+-----+-----+ 754 * is_play | o | * | 755 * !is_play | * | o | 756 */ 757 if ((this == ssi) == (is_play)) { 758 *mod_from = mod[idx - 1]; 759 *mod_to = mod[idx]; 760 } else { 761 *mod_from = mod[0]; 762 *mod_to = mod[1]; 763 } 764 765 dev_dbg(dev, "module connection (this is %s)\n", rsnd_mod_name(this)); 766 for (i = 0; i <= idx; i++) { 767 dev_dbg(dev, " %s%s\n", 768 rsnd_mod_name(mod[i] ? mod[i] : &mem), 769 (mod[i] == *mod_from) ? " from" : 770 (mod[i] == *mod_to) ? " to" : ""); 771 } 772 } 773 774 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 775 struct rsnd_mod **dma_mod) 776 { 777 struct rsnd_mod *mod_from = NULL; 778 struct rsnd_mod *mod_to = NULL; 779 struct rsnd_priv *priv = rsnd_io_to_priv(io); 780 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 781 struct device *dev = rsnd_priv_to_dev(priv); 782 struct rsnd_dma *dma; 783 struct rsnd_mod_ops *ops; 784 enum rsnd_mod_type type; 785 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma, 786 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to); 787 int is_play = rsnd_io_is_play(io); 788 int ret, dma_id; 789 790 /* 791 * DMA failed. try to PIO mode 792 * see 793 * rsnd_ssi_fallback() 794 * rsnd_rdai_continuance_probe() 795 */ 796 if (!dmac) 797 return -EAGAIN; 798 799 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to); 800 801 /* for Gen2 or later */ 802 if (mod_from && mod_to) { 803 ops = &rsnd_dmapp_ops; 804 attach = rsnd_dmapp_attach; 805 dma_id = dmac->dmapp_num; 806 type = RSND_MOD_AUDMAPP; 807 } else { 808 ops = &rsnd_dmaen_ops; 809 attach = rsnd_dmaen_attach; 810 dma_id = dmac->dmaen_num; 811 type = RSND_MOD_AUDMA; 812 } 813 814 /* for Gen1, overwrite */ 815 if (rsnd_is_gen1(priv)) { 816 ops = &rsnd_dmaen_ops; 817 attach = rsnd_dmaen_attach; 818 dma_id = dmac->dmaen_num; 819 type = RSND_MOD_AUDMA; 820 } 821 822 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL); 823 if (!dma) 824 return -ENOMEM; 825 826 *dma_mod = rsnd_mod_get(dma); 827 828 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL, 829 type, dma_id); 830 if (ret < 0) 831 return ret; 832 833 dev_dbg(dev, "%s %s -> %s\n", 834 rsnd_mod_name(*dma_mod), 835 rsnd_mod_name(mod_from ? mod_from : &mem), 836 rsnd_mod_name(mod_to ? mod_to : &mem)); 837 838 ret = attach(io, dma, mod_from, mod_to); 839 if (ret < 0) 840 return ret; 841 842 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1); 843 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0); 844 dma->mod_from = mod_from; 845 dma->mod_to = mod_to; 846 847 return 0; 848 } 849 850 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 851 struct rsnd_mod **dma_mod) 852 { 853 if (!(*dma_mod)) { 854 int ret = rsnd_dma_alloc(io, mod, dma_mod); 855 856 if (ret < 0) 857 return ret; 858 } 859 860 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type); 861 } 862 863 int rsnd_dma_probe(struct rsnd_priv *priv) 864 { 865 struct platform_device *pdev = rsnd_priv_to_pdev(priv); 866 struct device *dev = rsnd_priv_to_dev(priv); 867 struct rsnd_dma_ctrl *dmac; 868 struct resource *res; 869 870 /* 871 * for Gen1 872 */ 873 if (rsnd_is_gen1(priv)) 874 return 0; 875 876 /* 877 * for Gen2 or later 878 */ 879 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp"); 880 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL); 881 if (!dmac || !res) { 882 dev_err(dev, "dma allocate failed\n"); 883 return 0; /* it will be PIO mode */ 884 } 885 886 dmac->dmapp_num = 0; 887 dmac->ppres = res->start; 888 dmac->ppbase = devm_ioremap_resource(dev, res); 889 if (IS_ERR(dmac->ppbase)) 890 return PTR_ERR(dmac->ppbase); 891 892 priv->dma = dmac; 893 894 /* dummy mem mod for debug */ 895 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, 0, 0); 896 } 897