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