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_async(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, char *name, 241 struct rsnd_mod *mod, char *x) 242 { 243 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 244 struct device *dev = rsnd_priv_to_dev(priv); 245 struct dma_chan *chan = NULL; 246 struct device_node *np; 247 int i = 0; 248 249 for_each_child_of_node(of_node, np) { 250 i = rsnd_node_fixed_index(dev, np, name, i); 251 if (i < 0) { 252 chan = NULL; 253 of_node_put(np); 254 break; 255 } 256 257 if (i == rsnd_mod_id_raw(mod) && (!chan)) 258 chan = of_dma_request_slave_channel(np, x); 259 i++; 260 } 261 262 /* It should call of_node_put(), since, it is rsnd_xxx_of_node() */ 263 of_node_put(of_node); 264 265 return chan; 266 } 267 268 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io, 269 struct rsnd_dma *dma, 270 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 271 { 272 struct rsnd_priv *priv = rsnd_io_to_priv(io); 273 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 274 struct dma_chan *chan; 275 276 /* try to get DMAEngine channel */ 277 chan = rsnd_dmaen_request_channel(io, mod_from, mod_to); 278 if (IS_ERR_OR_NULL(chan)) { 279 /* Let's follow when -EPROBE_DEFER case */ 280 if (PTR_ERR(chan) == -EPROBE_DEFER) 281 return PTR_ERR(chan); 282 283 /* 284 * DMA failed. try to PIO mode 285 * see 286 * rsnd_ssi_fallback() 287 * rsnd_rdai_continuance_probe() 288 */ 289 return -EAGAIN; 290 } 291 292 /* 293 * use it for IPMMU if needed 294 * see 295 * rsnd_preallocate_pages() 296 */ 297 io->dmac_dev = chan->device->dev; 298 299 dma_release_channel(chan); 300 301 dmac->dmaen_num++; 302 303 return 0; 304 } 305 306 static int rsnd_dmaen_pointer(struct rsnd_mod *mod, 307 struct rsnd_dai_stream *io, 308 snd_pcm_uframes_t *pointer) 309 { 310 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 311 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 312 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 313 struct dma_tx_state state; 314 enum dma_status status; 315 unsigned int pos = 0; 316 317 status = dmaengine_tx_status(dmaen->chan, dmaen->cookie, &state); 318 if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) { 319 if (state.residue > 0 && state.residue <= dmaen->dma_len) 320 pos = dmaen->dma_len - state.residue; 321 } 322 *pointer = bytes_to_frames(runtime, pos); 323 324 return 0; 325 } 326 327 static struct rsnd_mod_ops rsnd_dmaen_ops = { 328 .name = "audmac", 329 .prepare = rsnd_dmaen_prepare, 330 .cleanup = rsnd_dmaen_cleanup, 331 .start = rsnd_dmaen_start, 332 .stop = rsnd_dmaen_stop, 333 .pointer = rsnd_dmaen_pointer, 334 .get_status = rsnd_mod_get_status, 335 }; 336 337 /* 338 * Audio DMAC peri peri 339 */ 340 static const u8 gen2_id_table_ssiu[] = { 341 /* SSI00 ~ SSI07 */ 342 0x00, 0x01, 0x02, 0x03, 0x39, 0x3a, 0x3b, 0x3c, 343 /* SSI10 ~ SSI17 */ 344 0x04, 0x05, 0x06, 0x07, 0x3d, 0x3e, 0x3f, 0x40, 345 /* SSI20 ~ SSI27 */ 346 0x08, 0x09, 0x0a, 0x0b, 0x41, 0x42, 0x43, 0x44, 347 /* SSI30 ~ SSI37 */ 348 0x0c, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 349 /* SSI40 ~ SSI47 */ 350 0x0d, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 351 /* SSI5 */ 352 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 353 /* SSI6 */ 354 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 355 /* SSI7 */ 356 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 357 /* SSI8 */ 358 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 359 /* SSI90 ~ SSI97 */ 360 0x12, 0x13, 0x14, 0x15, 0x53, 0x54, 0x55, 0x56, 361 }; 362 static const u8 gen2_id_table_scu[] = { 363 0x2d, /* SCU_SRCI0 */ 364 0x2e, /* SCU_SRCI1 */ 365 0x2f, /* SCU_SRCI2 */ 366 0x30, /* SCU_SRCI3 */ 367 0x31, /* SCU_SRCI4 */ 368 0x32, /* SCU_SRCI5 */ 369 0x33, /* SCU_SRCI6 */ 370 0x34, /* SCU_SRCI7 */ 371 0x35, /* SCU_SRCI8 */ 372 0x36, /* SCU_SRCI9 */ 373 }; 374 static const u8 gen2_id_table_cmd[] = { 375 0x37, /* SCU_CMD0 */ 376 0x38, /* SCU_CMD1 */ 377 }; 378 379 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io, 380 struct rsnd_mod *mod) 381 { 382 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); 383 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); 384 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 385 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 386 const u8 *entry = NULL; 387 int id = 255; 388 int size = 0; 389 390 if ((mod == ssi) || 391 (mod == ssiu)) { 392 int busif = rsnd_mod_id_sub(ssiu); 393 394 entry = gen2_id_table_ssiu; 395 size = ARRAY_SIZE(gen2_id_table_ssiu); 396 id = (rsnd_mod_id(mod) * 8) + busif; 397 } else if (mod == src) { 398 entry = gen2_id_table_scu; 399 size = ARRAY_SIZE(gen2_id_table_scu); 400 id = rsnd_mod_id(mod); 401 } else if (mod == dvc) { 402 entry = gen2_id_table_cmd; 403 size = ARRAY_SIZE(gen2_id_table_cmd); 404 id = rsnd_mod_id(mod); 405 } 406 407 if ((!entry) || (size <= id)) { 408 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); 409 410 dev_err(dev, "unknown connection (%s)\n", rsnd_mod_name(mod)); 411 412 /* use non-prohibited SRS number as error */ 413 return 0x00; /* SSI00 */ 414 } 415 416 return entry[id]; 417 } 418 419 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io, 420 struct rsnd_mod *mod_from, 421 struct rsnd_mod *mod_to) 422 { 423 return (rsnd_dmapp_get_id(io, mod_from) << 24) + 424 (rsnd_dmapp_get_id(io, mod_to) << 16); 425 } 426 427 #define rsnd_dmapp_addr(dmac, dma, reg) \ 428 (dmac->ppbase + 0x20 + reg + \ 429 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id)) 430 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg) 431 { 432 struct rsnd_mod *mod = rsnd_mod_get(dma); 433 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 434 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 435 struct device *dev = rsnd_priv_to_dev(priv); 436 437 dev_dbg(dev, "w 0x%px : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data); 438 439 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg)); 440 } 441 442 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, 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 448 return ioread32(rsnd_dmapp_addr(dmac, dma, reg)); 449 } 450 451 static void rsnd_dmapp_bset(struct rsnd_dma *dma, u32 data, u32 mask, u32 reg) 452 { 453 struct rsnd_mod *mod = rsnd_mod_get(dma); 454 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 455 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 456 void __iomem *addr = rsnd_dmapp_addr(dmac, dma, reg); 457 u32 val = ioread32(addr); 458 459 val &= ~mask; 460 val |= (data & mask); 461 462 iowrite32(val, addr); 463 } 464 465 static int rsnd_dmapp_stop(struct rsnd_mod *mod, 466 struct rsnd_dai_stream *io, 467 struct rsnd_priv *priv) 468 { 469 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 470 int i; 471 472 rsnd_dmapp_bset(dma, 0, PDMACHCR_DE, PDMACHCR); 473 474 for (i = 0; i < 1024; i++) { 475 if (0 == (rsnd_dmapp_read(dma, PDMACHCR) & PDMACHCR_DE)) 476 return 0; 477 udelay(1); 478 } 479 480 return -EIO; 481 } 482 483 static int rsnd_dmapp_start(struct rsnd_mod *mod, 484 struct rsnd_dai_stream *io, 485 struct rsnd_priv *priv) 486 { 487 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 488 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 489 490 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR); 491 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR); 492 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR); 493 494 return 0; 495 } 496 497 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io, 498 struct rsnd_dma *dma, 499 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 500 { 501 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 502 struct rsnd_priv *priv = rsnd_io_to_priv(io); 503 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 504 struct device *dev = rsnd_priv_to_dev(priv); 505 506 dmapp->dmapp_id = dmac->dmapp_num; 507 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE; 508 509 dmac->dmapp_num++; 510 511 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n", 512 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr); 513 514 return 0; 515 } 516 517 #ifdef CONFIG_DEBUG_FS 518 static void rsnd_dmapp_debug_info(struct seq_file *m, 519 struct rsnd_dai_stream *io, 520 struct rsnd_mod *mod) 521 { 522 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 523 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 524 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 525 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 526 527 rsnd_debugfs_reg_show(m, dmac->ppres, dmac->ppbase, 528 0x20 + 0x10 * dmapp->dmapp_id, 0x10); 529 } 530 #define DEBUG_INFO .debug_info = rsnd_dmapp_debug_info 531 #else 532 #define DEBUG_INFO 533 #endif 534 535 static struct rsnd_mod_ops rsnd_dmapp_ops = { 536 .name = "audmac-pp", 537 .start = rsnd_dmapp_start, 538 .stop = rsnd_dmapp_stop, 539 .quit = rsnd_dmapp_stop, 540 .get_status = rsnd_mod_get_status, 541 DEBUG_INFO 542 }; 543 544 /* 545 * Common DMAC Interface 546 */ 547 548 /* 549 * DMA read/write register offset 550 * 551 * RSND_xxx_I_N for Audio DMAC input 552 * RSND_xxx_O_N for Audio DMAC output 553 * RSND_xxx_I_P for Audio DMAC peri peri input 554 * RSND_xxx_O_P for Audio DMAC peri peri output 555 * 556 * ex) R-Car H2 case 557 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out 558 * SSI : 0xec541000 / 0xec241008 / 0xec24100c 559 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000 560 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000 561 * CMD : 0xec500000 / / 0xec008000 0xec308000 562 */ 563 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8) 564 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc) 565 566 #define RDMA_SSIU_I_N(addr, i, j) (addr ##_reg - 0x00441000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4))) 567 #define RDMA_SSIU_O_N(addr, i, j) RDMA_SSIU_I_N(addr, i, j) 568 569 #define RDMA_SSIU_I_P(addr, i, j) (addr ##_reg - 0x00141000 + (0x1000 * (i)) + (((j) / 4) * 0xA000) + (((j) % 4) * 0x400) - (0x4000 * ((i) / 9) * ((j) / 4))) 570 #define RDMA_SSIU_O_P(addr, i, j) RDMA_SSIU_I_P(addr, i, j) 571 572 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i)) 573 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i)) 574 575 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i)) 576 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i)) 577 578 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i)) 579 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i)) 580 581 static dma_addr_t 582 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io, 583 struct rsnd_mod *mod, 584 int is_play, int is_from) 585 { 586 struct rsnd_priv *priv = rsnd_io_to_priv(io); 587 struct device *dev = rsnd_priv_to_dev(priv); 588 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI); 589 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU); 590 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod) || 591 !!(rsnd_io_to_mod_ssiu(io) == mod); 592 int use_src = !!rsnd_io_to_mod_src(io); 593 int use_cmd = !!rsnd_io_to_mod_dvc(io) || 594 !!rsnd_io_to_mod_mix(io) || 595 !!rsnd_io_to_mod_ctu(io); 596 int id = rsnd_mod_id(mod); 597 int busif = rsnd_mod_id_sub(rsnd_io_to_mod_ssiu(io)); 598 struct dma_addr { 599 dma_addr_t out_addr; 600 dma_addr_t in_addr; 601 } dma_addrs[3][2][3] = { 602 /* SRC */ 603 /* Capture */ 604 {{{ 0, 0 }, 605 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) }, 606 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } }, 607 /* Playback */ 608 {{ 0, 0, }, 609 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) }, 610 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } } 611 }, 612 /* SSI */ 613 /* Capture */ 614 {{{ RDMA_SSI_O_N(ssi, id), 0 }, 615 { RDMA_SSIU_O_P(ssi, id, busif), 0 }, 616 { RDMA_SSIU_O_P(ssi, id, busif), 0 } }, 617 /* Playback */ 618 {{ 0, RDMA_SSI_I_N(ssi, id) }, 619 { 0, RDMA_SSIU_I_P(ssi, id, busif) }, 620 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } 621 }, 622 /* SSIU */ 623 /* Capture */ 624 {{{ RDMA_SSIU_O_N(ssi, id, busif), 0 }, 625 { RDMA_SSIU_O_P(ssi, id, busif), 0 }, 626 { RDMA_SSIU_O_P(ssi, id, busif), 0 } }, 627 /* Playback */ 628 {{ 0, RDMA_SSIU_I_N(ssi, id, busif) }, 629 { 0, RDMA_SSIU_I_P(ssi, id, busif) }, 630 { 0, RDMA_SSIU_I_P(ssi, id, busif) } } }, 631 }; 632 633 /* 634 * FIXME 635 * 636 * We can't support SSI9-4/5/6/7, because its address is 637 * out of calculation rule 638 */ 639 if ((id == 9) && (busif >= 4)) 640 dev_err(dev, "This driver doesn't support SSI%d-%d, so far", 641 id, busif); 642 643 /* it shouldn't happen */ 644 if (use_cmd && !use_src) 645 dev_err(dev, "DVC is selected without SRC\n"); 646 647 /* use SSIU or SSI ? */ 648 if (is_ssi && rsnd_ssi_use_busif(io)) 649 is_ssi++; 650 651 return (is_from) ? 652 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr : 653 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr; 654 } 655 656 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io, 657 struct rsnd_mod *mod, 658 int is_play, int is_from) 659 { 660 struct rsnd_priv *priv = rsnd_io_to_priv(io); 661 662 /* 663 * gen1 uses default DMA addr 664 */ 665 if (rsnd_is_gen1(priv)) 666 return 0; 667 668 if (!mod) 669 return 0; 670 671 return rsnd_gen2_dma_addr(io, mod, is_play, is_from); 672 } 673 674 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */ 675 static void rsnd_dma_of_path(struct rsnd_mod *this, 676 struct rsnd_dai_stream *io, 677 int is_play, 678 struct rsnd_mod **mod_from, 679 struct rsnd_mod **mod_to) 680 { 681 struct rsnd_mod *ssi; 682 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 683 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io); 684 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io); 685 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 686 struct rsnd_mod *mod[MOD_MAX]; 687 struct rsnd_mod *mod_start, *mod_end; 688 struct rsnd_priv *priv = rsnd_mod_to_priv(this); 689 struct device *dev = rsnd_priv_to_dev(priv); 690 int nr, i, idx; 691 692 /* 693 * It should use "rcar_sound,ssiu" on DT. 694 * But, we need to keep compatibility for old version. 695 * 696 * If it has "rcar_sound.ssiu", it will be used. 697 * If not, "rcar_sound.ssi" will be used. 698 * see 699 * rsnd_ssiu_dma_req() 700 * rsnd_ssi_dma_req() 701 */ 702 if (rsnd_ssiu_of_node(priv)) { 703 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); 704 705 /* use SSIU */ 706 ssi = ssiu; 707 if (this == rsnd_io_to_mod_ssi(io)) 708 this = ssiu; 709 } else { 710 /* keep compatible, use SSI */ 711 ssi = rsnd_io_to_mod_ssi(io); 712 } 713 714 if (!ssi) 715 return; 716 717 nr = 0; 718 for (i = 0; i < MOD_MAX; i++) { 719 mod[i] = NULL; 720 nr += !!rsnd_io_to_mod(io, i); 721 } 722 723 /* 724 * [S] -*-> [E] 725 * [S] -*-> SRC -o-> [E] 726 * [S] -*-> SRC -> DVC -o-> [E] 727 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E] 728 * 729 * playback [S] = mem 730 * [E] = SSI 731 * 732 * capture [S] = SSI 733 * [E] = mem 734 * 735 * -*-> Audio DMAC 736 * -o-> Audio DMAC peri peri 737 */ 738 mod_start = (is_play) ? NULL : ssi; 739 mod_end = (is_play) ? ssi : NULL; 740 741 idx = 0; 742 mod[idx++] = mod_start; 743 for (i = 1; i < nr; i++) { 744 if (src) { 745 mod[idx++] = src; 746 src = NULL; 747 } else if (ctu) { 748 mod[idx++] = ctu; 749 ctu = NULL; 750 } else if (mix) { 751 mod[idx++] = mix; 752 mix = NULL; 753 } else if (dvc) { 754 mod[idx++] = dvc; 755 dvc = NULL; 756 } 757 } 758 mod[idx] = mod_end; 759 760 /* 761 * | SSI | SRC | 762 * -------------+-----+-----+ 763 * is_play | o | * | 764 * !is_play | * | o | 765 */ 766 if ((this == ssi) == (is_play)) { 767 *mod_from = mod[idx - 1]; 768 *mod_to = mod[idx]; 769 } else { 770 *mod_from = mod[0]; 771 *mod_to = mod[1]; 772 } 773 774 dev_dbg(dev, "module connection (this is %s)\n", rsnd_mod_name(this)); 775 for (i = 0; i <= idx; i++) { 776 dev_dbg(dev, " %s%s\n", 777 rsnd_mod_name(mod[i] ? mod[i] : &mem), 778 (mod[i] == *mod_from) ? " from" : 779 (mod[i] == *mod_to) ? " to" : ""); 780 } 781 } 782 783 static int rsnd_dma_alloc(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 784 struct rsnd_mod **dma_mod) 785 { 786 struct rsnd_mod *mod_from = NULL; 787 struct rsnd_mod *mod_to = NULL; 788 struct rsnd_priv *priv = rsnd_io_to_priv(io); 789 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 790 struct device *dev = rsnd_priv_to_dev(priv); 791 struct rsnd_dma *dma; 792 struct rsnd_mod_ops *ops; 793 enum rsnd_mod_type type; 794 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma, 795 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to); 796 int is_play = rsnd_io_is_play(io); 797 int ret, dma_id; 798 799 /* 800 * DMA failed. try to PIO mode 801 * see 802 * rsnd_ssi_fallback() 803 * rsnd_rdai_continuance_probe() 804 */ 805 if (!dmac) 806 return -EAGAIN; 807 808 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to); 809 810 /* for Gen2 or later */ 811 if (mod_from && mod_to) { 812 ops = &rsnd_dmapp_ops; 813 attach = rsnd_dmapp_attach; 814 dma_id = dmac->dmapp_num; 815 type = RSND_MOD_AUDMAPP; 816 } else { 817 ops = &rsnd_dmaen_ops; 818 attach = rsnd_dmaen_attach; 819 dma_id = dmac->dmaen_num; 820 type = RSND_MOD_AUDMA; 821 } 822 823 /* for Gen1, overwrite */ 824 if (rsnd_is_gen1(priv)) { 825 ops = &rsnd_dmaen_ops; 826 attach = rsnd_dmaen_attach; 827 dma_id = dmac->dmaen_num; 828 type = RSND_MOD_AUDMA; 829 } 830 831 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL); 832 if (!dma) 833 return -ENOMEM; 834 835 *dma_mod = rsnd_mod_get(dma); 836 837 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL, 838 type, dma_id); 839 if (ret < 0) 840 return ret; 841 842 dev_dbg(dev, "%s %s -> %s\n", 843 rsnd_mod_name(*dma_mod), 844 rsnd_mod_name(mod_from ? mod_from : &mem), 845 rsnd_mod_name(mod_to ? mod_to : &mem)); 846 847 ret = attach(io, dma, mod_from, mod_to); 848 if (ret < 0) 849 return ret; 850 851 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1); 852 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0); 853 dma->mod_from = mod_from; 854 dma->mod_to = mod_to; 855 856 return 0; 857 } 858 859 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 860 struct rsnd_mod **dma_mod) 861 { 862 if (!(*dma_mod)) { 863 int ret = rsnd_dma_alloc(io, mod, dma_mod); 864 865 if (ret < 0) 866 return ret; 867 } 868 869 return rsnd_dai_connect(*dma_mod, io, (*dma_mod)->type); 870 } 871 872 int rsnd_dma_probe(struct rsnd_priv *priv) 873 { 874 struct platform_device *pdev = rsnd_priv_to_pdev(priv); 875 struct device *dev = rsnd_priv_to_dev(priv); 876 struct rsnd_dma_ctrl *dmac; 877 struct resource *res; 878 879 /* 880 * for Gen1 881 */ 882 if (rsnd_is_gen1(priv)) 883 return 0; 884 885 /* 886 * for Gen2 or later 887 */ 888 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp"); 889 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL); 890 if (!dmac || !res) { 891 dev_err(dev, "dma allocate failed\n"); 892 return 0; /* it will be PIO mode */ 893 } 894 895 dmac->dmapp_num = 0; 896 dmac->ppres = res->start; 897 dmac->ppbase = devm_ioremap_resource(dev, res); 898 if (IS_ERR(dmac->ppbase)) 899 return PTR_ERR(dmac->ppbase); 900 901 priv->dma = dmac; 902 903 /* dummy mem mod for debug */ 904 return rsnd_mod_init(NULL, &mem, &mem_ops, NULL, 0, 0); 905 } 906