1 /* 2 * Renesas R-Car Audio DMAC support 3 * 4 * Copyright (C) 2015 Renesas Electronics Corp. 5 * Copyright (c) 2015 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include <linux/delay.h> 12 #include <linux/of_dma.h> 13 #include "rsnd.h" 14 15 /* 16 * Audio DMAC peri peri register 17 */ 18 #define PDMASAR 0x00 19 #define PDMADAR 0x04 20 #define PDMACHCR 0x0c 21 22 /* PDMACHCR */ 23 #define PDMACHCR_DE (1 << 0) 24 25 26 struct rsnd_dmaen { 27 struct dma_chan *chan; 28 }; 29 30 struct rsnd_dmapp { 31 int dmapp_id; 32 u32 chcr; 33 }; 34 35 struct rsnd_dma { 36 struct rsnd_mod mod; 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 *base; 47 int dmaen_num; 48 int dmapp_num; 49 }; 50 51 #define rsnd_priv_to_dmac(p) ((struct rsnd_dma_ctrl *)(p)->dma) 52 #define rsnd_mod_to_dma(_mod) container_of((_mod), struct rsnd_dma, mod) 53 #define rsnd_dma_to_dmaen(dma) (&(dma)->dma.en) 54 #define rsnd_dma_to_dmapp(dma) (&(dma)->dma.pp) 55 56 /* 57 * Audio DMAC 58 */ 59 static void __rsnd_dmaen_complete(struct rsnd_mod *mod, 60 struct rsnd_dai_stream *io) 61 { 62 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 63 bool elapsed = false; 64 unsigned long flags; 65 66 /* 67 * Renesas sound Gen1 needs 1 DMAC, 68 * Gen2 needs 2 DMAC. 69 * In Gen2 case, it are Audio-DMAC, and Audio-DMAC-peri-peri. 70 * But, Audio-DMAC-peri-peri doesn't have interrupt, 71 * and this driver is assuming that here. 72 * 73 * If Audio-DMAC-peri-peri has interrpt, 74 * rsnd_dai_pointer_update() will be called twice, 75 * ant it will breaks io->byte_pos 76 */ 77 spin_lock_irqsave(&priv->lock, flags); 78 79 if (rsnd_io_is_working(io)) 80 elapsed = rsnd_dai_pointer_update(io, io->byte_per_period); 81 82 spin_unlock_irqrestore(&priv->lock, flags); 83 84 if (elapsed) 85 rsnd_dai_period_elapsed(io); 86 } 87 88 static void rsnd_dmaen_complete(void *data) 89 { 90 struct rsnd_mod *mod = data; 91 92 rsnd_mod_interrupt(mod, __rsnd_dmaen_complete); 93 } 94 95 static int rsnd_dmaen_stop(struct rsnd_mod *mod, 96 struct rsnd_dai_stream *io, 97 struct rsnd_priv *priv) 98 { 99 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 100 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 101 102 dmaengine_terminate_all(dmaen->chan); 103 104 return 0; 105 } 106 107 static int rsnd_dmaen_start(struct rsnd_mod *mod, 108 struct rsnd_dai_stream *io, 109 struct rsnd_priv *priv) 110 { 111 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 112 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 113 struct snd_pcm_substream *substream = io->substream; 114 struct device *dev = rsnd_priv_to_dev(priv); 115 struct dma_async_tx_descriptor *desc; 116 int is_play = rsnd_io_is_play(io); 117 118 desc = dmaengine_prep_dma_cyclic(dmaen->chan, 119 substream->runtime->dma_addr, 120 snd_pcm_lib_buffer_bytes(substream), 121 snd_pcm_lib_period_bytes(substream), 122 is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM, 123 DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 124 125 if (!desc) { 126 dev_err(dev, "dmaengine_prep_slave_sg() fail\n"); 127 return -EIO; 128 } 129 130 desc->callback = rsnd_dmaen_complete; 131 desc->callback_param = rsnd_mod_get(dma); 132 133 if (dmaengine_submit(desc) < 0) { 134 dev_err(dev, "dmaengine_submit() fail\n"); 135 return -EIO; 136 } 137 138 dma_async_issue_pending(dmaen->chan); 139 140 return 0; 141 } 142 143 struct dma_chan *rsnd_dma_request_channel(struct device_node *of_node, 144 struct rsnd_mod *mod, char *name) 145 { 146 struct dma_chan *chan; 147 struct device_node *np; 148 int i = 0; 149 150 for_each_child_of_node(of_node, np) { 151 if (i == rsnd_mod_id(mod)) 152 break; 153 i++; 154 } 155 156 chan = of_dma_request_slave_channel(np, name); 157 158 of_node_put(np); 159 of_node_put(of_node); 160 161 return chan; 162 } 163 164 static struct dma_chan *rsnd_dmaen_request_channel(struct rsnd_dai_stream *io, 165 struct rsnd_mod *mod_from, 166 struct rsnd_mod *mod_to) 167 { 168 if ((!mod_from && !mod_to) || 169 (mod_from && mod_to)) 170 return NULL; 171 172 if (mod_from) 173 return rsnd_mod_dma_req(io, mod_from); 174 else 175 return rsnd_mod_dma_req(io, mod_to); 176 } 177 178 static int rsnd_dmaen_remove(struct rsnd_mod *mod, 179 struct rsnd_dai_stream *io, 180 struct rsnd_priv *priv) 181 { 182 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 183 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 184 185 if (dmaen->chan) 186 dma_release_channel(dmaen->chan); 187 188 dmaen->chan = NULL; 189 190 return 0; 191 } 192 193 static int rsnd_dmaen_attach(struct rsnd_dai_stream *io, 194 struct rsnd_dma *dma, int id, 195 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 196 { 197 struct rsnd_mod *mod = rsnd_mod_get(dma); 198 struct rsnd_dmaen *dmaen = rsnd_dma_to_dmaen(dma); 199 struct rsnd_priv *priv = rsnd_io_to_priv(io); 200 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 201 struct device *dev = rsnd_priv_to_dev(priv); 202 struct dma_slave_config cfg = {}; 203 int is_play = rsnd_io_is_play(io); 204 int ret; 205 206 if (dmaen->chan) { 207 dev_err(dev, "it already has dma channel\n"); 208 return -EIO; 209 } 210 211 if (dev->of_node) { 212 dmaen->chan = rsnd_dmaen_request_channel(io, mod_from, mod_to); 213 } else { 214 dma_cap_mask_t mask; 215 216 dma_cap_zero(mask); 217 dma_cap_set(DMA_SLAVE, mask); 218 219 dmaen->chan = dma_request_channel(mask, shdma_chan_filter, 220 (void *)(uintptr_t)id); 221 } 222 if (IS_ERR_OR_NULL(dmaen->chan)) { 223 dmaen->chan = NULL; 224 dev_err(dev, "can't get dma channel\n"); 225 goto rsnd_dma_channel_err; 226 } 227 228 cfg.direction = is_play ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM; 229 cfg.src_addr = dma->src_addr; 230 cfg.dst_addr = dma->dst_addr; 231 cfg.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; 232 cfg.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES; 233 234 dev_dbg(dev, "%s[%d] %pad -> %pad\n", 235 rsnd_mod_name(mod), rsnd_mod_id(mod), 236 &cfg.src_addr, &cfg.dst_addr); 237 238 ret = dmaengine_slave_config(dmaen->chan, &cfg); 239 if (ret < 0) 240 goto rsnd_dma_attach_err; 241 242 dmac->dmaen_num++; 243 244 return 0; 245 246 rsnd_dma_attach_err: 247 rsnd_dmaen_remove(mod, io, priv); 248 rsnd_dma_channel_err: 249 250 /* 251 * DMA failed. try to PIO mode 252 * see 253 * rsnd_ssi_fallback() 254 * rsnd_rdai_continuance_probe() 255 */ 256 return -EAGAIN; 257 } 258 259 static struct rsnd_mod_ops rsnd_dmaen_ops = { 260 .name = "audmac", 261 .start = rsnd_dmaen_start, 262 .stop = rsnd_dmaen_stop, 263 .remove = rsnd_dmaen_remove, 264 }; 265 266 /* 267 * Audio DMAC peri peri 268 */ 269 static const u8 gen2_id_table_ssiu[] = { 270 0x00, /* SSI00 */ 271 0x04, /* SSI10 */ 272 0x08, /* SSI20 */ 273 0x0c, /* SSI3 */ 274 0x0d, /* SSI4 */ 275 0x0e, /* SSI5 */ 276 0x0f, /* SSI6 */ 277 0x10, /* SSI7 */ 278 0x11, /* SSI8 */ 279 0x12, /* SSI90 */ 280 }; 281 static const u8 gen2_id_table_scu[] = { 282 0x2d, /* SCU_SRCI0 */ 283 0x2e, /* SCU_SRCI1 */ 284 0x2f, /* SCU_SRCI2 */ 285 0x30, /* SCU_SRCI3 */ 286 0x31, /* SCU_SRCI4 */ 287 0x32, /* SCU_SRCI5 */ 288 0x33, /* SCU_SRCI6 */ 289 0x34, /* SCU_SRCI7 */ 290 0x35, /* SCU_SRCI8 */ 291 0x36, /* SCU_SRCI9 */ 292 }; 293 static const u8 gen2_id_table_cmd[] = { 294 0x37, /* SCU_CMD0 */ 295 0x38, /* SCU_CMD1 */ 296 }; 297 298 static u32 rsnd_dmapp_get_id(struct rsnd_dai_stream *io, 299 struct rsnd_mod *mod) 300 { 301 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); 302 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 303 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 304 const u8 *entry = NULL; 305 int id = rsnd_mod_id(mod); 306 int size = 0; 307 308 if (mod == ssi) { 309 entry = gen2_id_table_ssiu; 310 size = ARRAY_SIZE(gen2_id_table_ssiu); 311 } else if (mod == src) { 312 entry = gen2_id_table_scu; 313 size = ARRAY_SIZE(gen2_id_table_scu); 314 } else if (mod == dvc) { 315 entry = gen2_id_table_cmd; 316 size = ARRAY_SIZE(gen2_id_table_cmd); 317 } 318 319 if ((!entry) || (size <= id)) { 320 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); 321 322 dev_err(dev, "unknown connection (%s[%d])\n", 323 rsnd_mod_name(mod), rsnd_mod_id(mod)); 324 325 /* use non-prohibited SRS number as error */ 326 return 0x00; /* SSI00 */ 327 } 328 329 return entry[id]; 330 } 331 332 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io, 333 struct rsnd_mod *mod_from, 334 struct rsnd_mod *mod_to) 335 { 336 return (rsnd_dmapp_get_id(io, mod_from) << 24) + 337 (rsnd_dmapp_get_id(io, mod_to) << 16); 338 } 339 340 #define rsnd_dmapp_addr(dmac, dma, reg) \ 341 (dmac->base + 0x20 + reg + \ 342 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id)) 343 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg) 344 { 345 struct rsnd_mod *mod = rsnd_mod_get(dma); 346 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 347 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 348 struct device *dev = rsnd_priv_to_dev(priv); 349 350 dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data); 351 352 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg)); 353 } 354 355 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg) 356 { 357 struct rsnd_mod *mod = rsnd_mod_get(dma); 358 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 359 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 360 361 return ioread32(rsnd_dmapp_addr(dmac, dma, reg)); 362 } 363 364 static int rsnd_dmapp_stop(struct rsnd_mod *mod, 365 struct rsnd_dai_stream *io, 366 struct rsnd_priv *priv) 367 { 368 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 369 int i; 370 371 rsnd_dmapp_write(dma, 0, PDMACHCR); 372 373 for (i = 0; i < 1024; i++) { 374 if (0 == rsnd_dmapp_read(dma, PDMACHCR)) 375 return 0; 376 udelay(1); 377 } 378 379 return -EIO; 380 } 381 382 static int rsnd_dmapp_start(struct rsnd_mod *mod, 383 struct rsnd_dai_stream *io, 384 struct rsnd_priv *priv) 385 { 386 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 387 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 388 389 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR); 390 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR); 391 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR); 392 393 return 0; 394 } 395 396 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io, 397 struct rsnd_dma *dma, int id, 398 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 399 { 400 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 401 struct rsnd_priv *priv = rsnd_io_to_priv(io); 402 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 403 struct device *dev = rsnd_priv_to_dev(priv); 404 405 dmapp->dmapp_id = dmac->dmapp_num; 406 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE; 407 408 dmac->dmapp_num++; 409 410 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n", 411 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr); 412 413 return 0; 414 } 415 416 static struct rsnd_mod_ops rsnd_dmapp_ops = { 417 .name = "audmac-pp", 418 .start = rsnd_dmapp_start, 419 .stop = rsnd_dmapp_stop, 420 .quit = rsnd_dmapp_stop, 421 }; 422 423 /* 424 * Common DMAC Interface 425 */ 426 427 /* 428 * DMA read/write register offset 429 * 430 * RSND_xxx_I_N for Audio DMAC input 431 * RSND_xxx_O_N for Audio DMAC output 432 * RSND_xxx_I_P for Audio DMAC peri peri input 433 * RSND_xxx_O_P for Audio DMAC peri peri output 434 * 435 * ex) R-Car H2 case 436 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out 437 * SSI : 0xec541000 / 0xec241008 / 0xec24100c 438 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000 439 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000 440 * CMD : 0xec500000 / / 0xec008000 0xec308000 441 */ 442 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8) 443 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc) 444 445 #define RDMA_SSIU_I_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i)) 446 #define RDMA_SSIU_O_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i)) 447 448 #define RDMA_SSIU_I_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i)) 449 #define RDMA_SSIU_O_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i)) 450 451 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i)) 452 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i)) 453 454 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i)) 455 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i)) 456 457 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i)) 458 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i)) 459 460 static dma_addr_t 461 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io, 462 struct rsnd_mod *mod, 463 int is_play, int is_from) 464 { 465 struct rsnd_priv *priv = rsnd_io_to_priv(io); 466 struct device *dev = rsnd_priv_to_dev(priv); 467 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI); 468 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU); 469 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod); 470 int use_src = !!rsnd_io_to_mod_src(io); 471 int use_cmd = !!rsnd_io_to_mod_dvc(io) || 472 !!rsnd_io_to_mod_mix(io) || 473 !!rsnd_io_to_mod_ctu(io); 474 int id = rsnd_mod_id(mod); 475 struct dma_addr { 476 dma_addr_t out_addr; 477 dma_addr_t in_addr; 478 } dma_addrs[3][2][3] = { 479 /* SRC */ 480 {{{ 0, 0 }, 481 /* Capture */ 482 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) }, 483 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } }, 484 /* Playback */ 485 {{ 0, 0, }, 486 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) }, 487 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } } 488 }, 489 /* SSI */ 490 /* Capture */ 491 {{{ RDMA_SSI_O_N(ssi, id), 0 }, 492 { RDMA_SSIU_O_P(ssi, id), 0 }, 493 { RDMA_SSIU_O_P(ssi, id), 0 } }, 494 /* Playback */ 495 {{ 0, RDMA_SSI_I_N(ssi, id) }, 496 { 0, RDMA_SSIU_I_P(ssi, id) }, 497 { 0, RDMA_SSIU_I_P(ssi, id) } } 498 }, 499 /* SSIU */ 500 /* Capture */ 501 {{{ RDMA_SSIU_O_N(ssi, id), 0 }, 502 { RDMA_SSIU_O_P(ssi, id), 0 }, 503 { RDMA_SSIU_O_P(ssi, id), 0 } }, 504 /* Playback */ 505 {{ 0, RDMA_SSIU_I_N(ssi, id) }, 506 { 0, RDMA_SSIU_I_P(ssi, id) }, 507 { 0, RDMA_SSIU_I_P(ssi, id) } } }, 508 }; 509 510 /* it shouldn't happen */ 511 if (use_cmd && !use_src) 512 dev_err(dev, "DVC is selected without SRC\n"); 513 514 /* use SSIU or SSI ? */ 515 if (is_ssi && rsnd_ssi_use_busif(io)) 516 is_ssi++; 517 518 return (is_from) ? 519 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr : 520 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr; 521 } 522 523 static dma_addr_t rsnd_dma_addr(struct rsnd_dai_stream *io, 524 struct rsnd_mod *mod, 525 int is_play, int is_from) 526 { 527 struct rsnd_priv *priv = rsnd_io_to_priv(io); 528 529 /* 530 * gen1 uses default DMA addr 531 */ 532 if (rsnd_is_gen1(priv)) 533 return 0; 534 535 if (!mod) 536 return 0; 537 538 return rsnd_gen2_dma_addr(io, mod, is_play, is_from); 539 } 540 541 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */ 542 static void rsnd_dma_of_path(struct rsnd_mod *this, 543 struct rsnd_dai_stream *io, 544 int is_play, 545 struct rsnd_mod **mod_from, 546 struct rsnd_mod **mod_to) 547 { 548 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); 549 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 550 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io); 551 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io); 552 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 553 struct rsnd_mod *mod[MOD_MAX]; 554 struct rsnd_mod *mod_start, *mod_end; 555 struct rsnd_priv *priv = rsnd_mod_to_priv(this); 556 struct device *dev = rsnd_priv_to_dev(priv); 557 int nr, i, idx; 558 559 if (!ssi) 560 return; 561 562 nr = 0; 563 for (i = 0; i < MOD_MAX; i++) { 564 mod[i] = NULL; 565 nr += !!rsnd_io_to_mod(io, i); 566 } 567 568 /* 569 * [S] -*-> [E] 570 * [S] -*-> SRC -o-> [E] 571 * [S] -*-> SRC -> DVC -o-> [E] 572 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E] 573 * 574 * playback [S] = mem 575 * [E] = SSI 576 * 577 * capture [S] = SSI 578 * [E] = mem 579 * 580 * -*-> Audio DMAC 581 * -o-> Audio DMAC peri peri 582 */ 583 mod_start = (is_play) ? NULL : ssi; 584 mod_end = (is_play) ? ssi : NULL; 585 586 idx = 0; 587 mod[idx++] = mod_start; 588 for (i = 1; i < nr; i++) { 589 if (src) { 590 mod[idx++] = src; 591 src = NULL; 592 } else if (ctu) { 593 mod[idx++] = ctu; 594 ctu = NULL; 595 } else if (mix) { 596 mod[idx++] = mix; 597 mix = NULL; 598 } else if (dvc) { 599 mod[idx++] = dvc; 600 dvc = NULL; 601 } 602 } 603 mod[idx] = mod_end; 604 605 /* 606 * | SSI | SRC | 607 * -------------+-----+-----+ 608 * is_play | o | * | 609 * !is_play | * | o | 610 */ 611 if ((this == ssi) == (is_play)) { 612 *mod_from = mod[idx - 1]; 613 *mod_to = mod[idx]; 614 } else { 615 *mod_from = mod[0]; 616 *mod_to = mod[1]; 617 } 618 619 dev_dbg(dev, "module connection (this is %s[%d])\n", 620 rsnd_mod_name(this), rsnd_mod_id(this)); 621 for (i = 0; i <= idx; i++) { 622 dev_dbg(dev, " %s[%d]%s\n", 623 rsnd_mod_name(mod[i]), rsnd_mod_id(mod[i]), 624 (mod[i] == *mod_from) ? " from" : 625 (mod[i] == *mod_to) ? " to" : ""); 626 } 627 } 628 629 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 630 struct rsnd_mod **dma_mod, int id) 631 { 632 struct rsnd_mod *mod_from = NULL; 633 struct rsnd_mod *mod_to = NULL; 634 struct rsnd_priv *priv = rsnd_io_to_priv(io); 635 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 636 struct device *dev = rsnd_priv_to_dev(priv); 637 struct rsnd_mod_ops *ops; 638 enum rsnd_mod_type type; 639 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma, int id, 640 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to); 641 int is_play = rsnd_io_is_play(io); 642 int ret, dma_id; 643 644 /* 645 * DMA failed. try to PIO mode 646 * see 647 * rsnd_ssi_fallback() 648 * rsnd_rdai_continuance_probe() 649 */ 650 if (!dmac) 651 return -EAGAIN; 652 653 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to); 654 655 /* for Gen2 */ 656 if (mod_from && mod_to) { 657 ops = &rsnd_dmapp_ops; 658 attach = rsnd_dmapp_attach; 659 dma_id = dmac->dmapp_num; 660 type = RSND_MOD_AUDMAPP; 661 } else { 662 ops = &rsnd_dmaen_ops; 663 attach = rsnd_dmaen_attach; 664 dma_id = dmac->dmaen_num; 665 type = RSND_MOD_AUDMA; 666 } 667 668 /* for Gen1, overwrite */ 669 if (rsnd_is_gen1(priv)) { 670 ops = &rsnd_dmaen_ops; 671 attach = rsnd_dmaen_attach; 672 dma_id = dmac->dmaen_num; 673 type = RSND_MOD_AUDMA; 674 } 675 676 if (!(*dma_mod)) { 677 struct rsnd_dma *dma; 678 679 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL); 680 if (!dma) 681 return -ENOMEM; 682 683 *dma_mod = rsnd_mod_get(dma); 684 685 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1); 686 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0); 687 688 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL, 689 rsnd_mod_get_status, type, dma_id); 690 if (ret < 0) 691 return ret; 692 693 dev_dbg(dev, "%s[%d] %s[%d] -> %s[%d]\n", 694 rsnd_mod_name(*dma_mod), rsnd_mod_id(*dma_mod), 695 rsnd_mod_name(mod_from), rsnd_mod_id(mod_from), 696 rsnd_mod_name(mod_to), rsnd_mod_id(mod_to)); 697 698 ret = attach(io, dma, id, mod_from, mod_to); 699 if (ret < 0) 700 return ret; 701 } 702 703 ret = rsnd_dai_connect(*dma_mod, io, type); 704 if (ret < 0) 705 return ret; 706 707 return 0; 708 } 709 710 int rsnd_dma_probe(struct rsnd_priv *priv) 711 { 712 struct platform_device *pdev = rsnd_priv_to_pdev(priv); 713 struct device *dev = rsnd_priv_to_dev(priv); 714 struct rsnd_dma_ctrl *dmac; 715 struct resource *res; 716 717 /* 718 * for Gen1 719 */ 720 if (rsnd_is_gen1(priv)) 721 return 0; 722 723 /* 724 * for Gen2 725 */ 726 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp"); 727 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL); 728 if (!dmac || !res) { 729 dev_err(dev, "dma allocate failed\n"); 730 return 0; /* it will be PIO mode */ 731 } 732 733 dmac->dmapp_num = 0; 734 dmac->base = devm_ioremap_resource(dev, res); 735 if (IS_ERR(dmac->base)) 736 return PTR_ERR(dmac->base); 737 738 priv->dma = dmac; 739 740 return 0; 741 } 742