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) 320 return 0xFF; 321 322 if (size <= id) 323 return 0xFF; 324 325 return entry[id]; 326 } 327 328 static u32 rsnd_dmapp_get_chcr(struct rsnd_dai_stream *io, 329 struct rsnd_mod *mod_from, 330 struct rsnd_mod *mod_to) 331 { 332 return (rsnd_dmapp_get_id(io, mod_from) << 24) + 333 (rsnd_dmapp_get_id(io, mod_to) << 16); 334 } 335 336 #define rsnd_dmapp_addr(dmac, dma, reg) \ 337 (dmac->base + 0x20 + reg + \ 338 (0x10 * rsnd_dma_to_dmapp(dma)->dmapp_id)) 339 static void rsnd_dmapp_write(struct rsnd_dma *dma, u32 data, u32 reg) 340 { 341 struct rsnd_mod *mod = rsnd_mod_get(dma); 342 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 343 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 344 struct device *dev = rsnd_priv_to_dev(priv); 345 346 dev_dbg(dev, "w %p : %08x\n", rsnd_dmapp_addr(dmac, dma, reg), data); 347 348 iowrite32(data, rsnd_dmapp_addr(dmac, dma, reg)); 349 } 350 351 static u32 rsnd_dmapp_read(struct rsnd_dma *dma, u32 reg) 352 { 353 struct rsnd_mod *mod = rsnd_mod_get(dma); 354 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 355 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 356 357 return ioread32(rsnd_dmapp_addr(dmac, dma, reg)); 358 } 359 360 static int rsnd_dmapp_stop(struct rsnd_mod *mod, 361 struct rsnd_dai_stream *io, 362 struct rsnd_priv *priv) 363 { 364 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 365 int i; 366 367 rsnd_dmapp_write(dma, 0, PDMACHCR); 368 369 for (i = 0; i < 1024; i++) { 370 if (0 == rsnd_dmapp_read(dma, PDMACHCR)) 371 return 0; 372 udelay(1); 373 } 374 375 return -EIO; 376 } 377 378 static int rsnd_dmapp_start(struct rsnd_mod *mod, 379 struct rsnd_dai_stream *io, 380 struct rsnd_priv *priv) 381 { 382 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 383 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 384 385 rsnd_dmapp_write(dma, dma->src_addr, PDMASAR); 386 rsnd_dmapp_write(dma, dma->dst_addr, PDMADAR); 387 rsnd_dmapp_write(dma, dmapp->chcr, PDMACHCR); 388 389 return 0; 390 } 391 392 static int rsnd_dmapp_attach(struct rsnd_dai_stream *io, 393 struct rsnd_dma *dma, int id, 394 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to) 395 { 396 struct rsnd_dmapp *dmapp = rsnd_dma_to_dmapp(dma); 397 struct rsnd_priv *priv = rsnd_io_to_priv(io); 398 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 399 struct device *dev = rsnd_priv_to_dev(priv); 400 401 dmapp->dmapp_id = dmac->dmapp_num; 402 dmapp->chcr = rsnd_dmapp_get_chcr(io, mod_from, mod_to) | PDMACHCR_DE; 403 404 dmac->dmapp_num++; 405 406 dev_dbg(dev, "id/src/dst/chcr = %d/%pad/%pad/%08x\n", 407 dmapp->dmapp_id, &dma->src_addr, &dma->dst_addr, dmapp->chcr); 408 409 return 0; 410 } 411 412 static struct rsnd_mod_ops rsnd_dmapp_ops = { 413 .name = "audmac-pp", 414 .start = rsnd_dmapp_start, 415 .stop = rsnd_dmapp_stop, 416 .quit = rsnd_dmapp_stop, 417 }; 418 419 /* 420 * Common DMAC Interface 421 */ 422 423 /* 424 * DMA read/write register offset 425 * 426 * RSND_xxx_I_N for Audio DMAC input 427 * RSND_xxx_O_N for Audio DMAC output 428 * RSND_xxx_I_P for Audio DMAC peri peri input 429 * RSND_xxx_O_P for Audio DMAC peri peri output 430 * 431 * ex) R-Car H2 case 432 * mod / DMAC in / DMAC out / DMAC PP in / DMAC pp out 433 * SSI : 0xec541000 / 0xec241008 / 0xec24100c 434 * SSIU: 0xec541000 / 0xec100000 / 0xec100000 / 0xec400000 / 0xec400000 435 * SCU : 0xec500000 / 0xec000000 / 0xec004000 / 0xec300000 / 0xec304000 436 * CMD : 0xec500000 / / 0xec008000 0xec308000 437 */ 438 #define RDMA_SSI_I_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0x8) 439 #define RDMA_SSI_O_N(addr, i) (addr ##_reg - 0x00300000 + (0x40 * i) + 0xc) 440 441 #define RDMA_SSIU_I_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i)) 442 #define RDMA_SSIU_O_N(addr, i) (addr ##_reg - 0x00441000 + (0x1000 * i)) 443 444 #define RDMA_SSIU_I_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i)) 445 #define RDMA_SSIU_O_P(addr, i) (addr ##_reg - 0x00141000 + (0x1000 * i)) 446 447 #define RDMA_SRC_I_N(addr, i) (addr ##_reg - 0x00500000 + (0x400 * i)) 448 #define RDMA_SRC_O_N(addr, i) (addr ##_reg - 0x004fc000 + (0x400 * i)) 449 450 #define RDMA_SRC_I_P(addr, i) (addr ##_reg - 0x00200000 + (0x400 * i)) 451 #define RDMA_SRC_O_P(addr, i) (addr ##_reg - 0x001fc000 + (0x400 * i)) 452 453 #define RDMA_CMD_O_N(addr, i) (addr ##_reg - 0x004f8000 + (0x400 * i)) 454 #define RDMA_CMD_O_P(addr, i) (addr ##_reg - 0x001f8000 + (0x400 * i)) 455 456 static dma_addr_t 457 rsnd_gen2_dma_addr(struct rsnd_dai_stream *io, 458 struct rsnd_mod *mod, 459 int is_play, int is_from) 460 { 461 struct rsnd_priv *priv = rsnd_io_to_priv(io); 462 struct device *dev = rsnd_priv_to_dev(priv); 463 phys_addr_t ssi_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SSI); 464 phys_addr_t src_reg = rsnd_gen_get_phy_addr(priv, RSND_GEN2_SCU); 465 int is_ssi = !!(rsnd_io_to_mod_ssi(io) == mod); 466 int use_src = !!rsnd_io_to_mod_src(io); 467 int use_cmd = !!rsnd_io_to_mod_dvc(io) || 468 !!rsnd_io_to_mod_mix(io) || 469 !!rsnd_io_to_mod_ctu(io); 470 int id = rsnd_mod_id(mod); 471 struct dma_addr { 472 dma_addr_t out_addr; 473 dma_addr_t in_addr; 474 } dma_addrs[3][2][3] = { 475 /* SRC */ 476 {{{ 0, 0 }, 477 /* Capture */ 478 { RDMA_SRC_O_N(src, id), RDMA_SRC_I_P(src, id) }, 479 { RDMA_CMD_O_N(src, id), RDMA_SRC_I_P(src, id) } }, 480 /* Playback */ 481 {{ 0, 0, }, 482 { RDMA_SRC_O_P(src, id), RDMA_SRC_I_N(src, id) }, 483 { RDMA_CMD_O_P(src, id), RDMA_SRC_I_N(src, id) } } 484 }, 485 /* SSI */ 486 /* Capture */ 487 {{{ RDMA_SSI_O_N(ssi, id), 0 }, 488 { RDMA_SSIU_O_P(ssi, id), 0 }, 489 { RDMA_SSIU_O_P(ssi, id), 0 } }, 490 /* Playback */ 491 {{ 0, RDMA_SSI_I_N(ssi, id) }, 492 { 0, RDMA_SSIU_I_P(ssi, id) }, 493 { 0, RDMA_SSIU_I_P(ssi, id) } } 494 }, 495 /* SSIU */ 496 /* Capture */ 497 {{{ RDMA_SSIU_O_N(ssi, id), 0 }, 498 { RDMA_SSIU_O_P(ssi, id), 0 }, 499 { RDMA_SSIU_O_P(ssi, id), 0 } }, 500 /* Playback */ 501 {{ 0, RDMA_SSIU_I_N(ssi, id) }, 502 { 0, RDMA_SSIU_I_P(ssi, id) }, 503 { 0, RDMA_SSIU_I_P(ssi, id) } } }, 504 }; 505 506 /* it shouldn't happen */ 507 if (use_cmd && !use_src) 508 dev_err(dev, "DVC is selected without SRC\n"); 509 510 /* use SSIU or SSI ? */ 511 if (is_ssi && rsnd_ssi_use_busif(io)) 512 is_ssi++; 513 514 return (is_from) ? 515 dma_addrs[is_ssi][is_play][use_src + use_cmd].out_addr : 516 dma_addrs[is_ssi][is_play][use_src + use_cmd].in_addr; 517 } 518 519 static dma_addr_t rsnd_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 525 /* 526 * gen1 uses default DMA addr 527 */ 528 if (rsnd_is_gen1(priv)) 529 return 0; 530 531 if (!mod) 532 return 0; 533 534 return rsnd_gen2_dma_addr(io, mod, is_play, is_from); 535 } 536 537 #define MOD_MAX (RSND_MOD_MAX + 1) /* +Memory */ 538 static void rsnd_dma_of_path(struct rsnd_mod *this, 539 struct rsnd_dai_stream *io, 540 int is_play, 541 struct rsnd_mod **mod_from, 542 struct rsnd_mod **mod_to) 543 { 544 struct rsnd_mod *ssi = rsnd_io_to_mod_ssi(io); 545 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 546 struct rsnd_mod *ctu = rsnd_io_to_mod_ctu(io); 547 struct rsnd_mod *mix = rsnd_io_to_mod_mix(io); 548 struct rsnd_mod *dvc = rsnd_io_to_mod_dvc(io); 549 struct rsnd_mod *mod[MOD_MAX]; 550 struct rsnd_mod *mod_start, *mod_end; 551 struct rsnd_priv *priv = rsnd_mod_to_priv(this); 552 struct device *dev = rsnd_priv_to_dev(priv); 553 int nr, i, idx; 554 555 if (!ssi) 556 return; 557 558 nr = 0; 559 for (i = 0; i < MOD_MAX; i++) { 560 mod[i] = NULL; 561 nr += !!rsnd_io_to_mod(io, i); 562 } 563 564 /* 565 * [S] -*-> [E] 566 * [S] -*-> SRC -o-> [E] 567 * [S] -*-> SRC -> DVC -o-> [E] 568 * [S] -*-> SRC -> CTU -> MIX -> DVC -o-> [E] 569 * 570 * playback [S] = mem 571 * [E] = SSI 572 * 573 * capture [S] = SSI 574 * [E] = mem 575 * 576 * -*-> Audio DMAC 577 * -o-> Audio DMAC peri peri 578 */ 579 mod_start = (is_play) ? NULL : ssi; 580 mod_end = (is_play) ? ssi : NULL; 581 582 idx = 0; 583 mod[idx++] = mod_start; 584 for (i = 1; i < nr; i++) { 585 if (src) { 586 mod[idx++] = src; 587 src = NULL; 588 } else if (ctu) { 589 mod[idx++] = ctu; 590 ctu = NULL; 591 } else if (mix) { 592 mod[idx++] = mix; 593 mix = NULL; 594 } else if (dvc) { 595 mod[idx++] = dvc; 596 dvc = NULL; 597 } 598 } 599 mod[idx] = mod_end; 600 601 /* 602 * | SSI | SRC | 603 * -------------+-----+-----+ 604 * is_play | o | * | 605 * !is_play | * | o | 606 */ 607 if ((this == ssi) == (is_play)) { 608 *mod_from = mod[idx - 1]; 609 *mod_to = mod[idx]; 610 } else { 611 *mod_from = mod[0]; 612 *mod_to = mod[1]; 613 } 614 615 dev_dbg(dev, "module connection (this is %s[%d])\n", 616 rsnd_mod_name(this), rsnd_mod_id(this)); 617 for (i = 0; i <= idx; i++) { 618 dev_dbg(dev, " %s[%d]%s\n", 619 rsnd_mod_name(mod[i]), rsnd_mod_id(mod[i]), 620 (mod[i] == *mod_from) ? " from" : 621 (mod[i] == *mod_to) ? " to" : ""); 622 } 623 } 624 625 int rsnd_dma_attach(struct rsnd_dai_stream *io, struct rsnd_mod *mod, 626 struct rsnd_mod **dma_mod, int id) 627 { 628 struct rsnd_mod *mod_from = NULL; 629 struct rsnd_mod *mod_to = NULL; 630 struct rsnd_priv *priv = rsnd_io_to_priv(io); 631 struct rsnd_dma_ctrl *dmac = rsnd_priv_to_dmac(priv); 632 struct device *dev = rsnd_priv_to_dev(priv); 633 struct rsnd_mod_ops *ops; 634 enum rsnd_mod_type type; 635 int (*attach)(struct rsnd_dai_stream *io, struct rsnd_dma *dma, int id, 636 struct rsnd_mod *mod_from, struct rsnd_mod *mod_to); 637 int is_play = rsnd_io_is_play(io); 638 int ret, dma_id; 639 640 /* 641 * DMA failed. try to PIO mode 642 * see 643 * rsnd_ssi_fallback() 644 * rsnd_rdai_continuance_probe() 645 */ 646 if (!dmac) 647 return -EAGAIN; 648 649 rsnd_dma_of_path(mod, io, is_play, &mod_from, &mod_to); 650 651 /* for Gen2 */ 652 if (mod_from && mod_to) { 653 ops = &rsnd_dmapp_ops; 654 attach = rsnd_dmapp_attach; 655 dma_id = dmac->dmapp_num; 656 type = RSND_MOD_AUDMAPP; 657 } else { 658 ops = &rsnd_dmaen_ops; 659 attach = rsnd_dmaen_attach; 660 dma_id = dmac->dmaen_num; 661 type = RSND_MOD_AUDMA; 662 } 663 664 /* for Gen1, overwrite */ 665 if (rsnd_is_gen1(priv)) { 666 ops = &rsnd_dmaen_ops; 667 attach = rsnd_dmaen_attach; 668 dma_id = dmac->dmaen_num; 669 type = RSND_MOD_AUDMA; 670 } 671 672 if (!(*dma_mod)) { 673 struct rsnd_dma *dma; 674 675 dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL); 676 if (!dma) 677 return -ENOMEM; 678 679 *dma_mod = rsnd_mod_get(dma); 680 681 dma->src_addr = rsnd_dma_addr(io, mod_from, is_play, 1); 682 dma->dst_addr = rsnd_dma_addr(io, mod_to, is_play, 0); 683 684 ret = rsnd_mod_init(priv, *dma_mod, ops, NULL, 685 rsnd_mod_get_status, type, dma_id); 686 if (ret < 0) 687 return ret; 688 689 dev_dbg(dev, "%s[%d] %s[%d] -> %s[%d]\n", 690 rsnd_mod_name(*dma_mod), rsnd_mod_id(*dma_mod), 691 rsnd_mod_name(mod_from), rsnd_mod_id(mod_from), 692 rsnd_mod_name(mod_to), rsnd_mod_id(mod_to)); 693 694 ret = attach(io, dma, id, mod_from, mod_to); 695 if (ret < 0) 696 return ret; 697 } 698 699 ret = rsnd_dai_connect(*dma_mod, io, type); 700 if (ret < 0) 701 return ret; 702 703 return 0; 704 } 705 706 int rsnd_dma_probe(struct rsnd_priv *priv) 707 { 708 struct platform_device *pdev = rsnd_priv_to_pdev(priv); 709 struct device *dev = rsnd_priv_to_dev(priv); 710 struct rsnd_dma_ctrl *dmac; 711 struct resource *res; 712 713 /* 714 * for Gen1 715 */ 716 if (rsnd_is_gen1(priv)) 717 return 0; 718 719 /* 720 * for Gen2 721 */ 722 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "audmapp"); 723 dmac = devm_kzalloc(dev, sizeof(*dmac), GFP_KERNEL); 724 if (!dmac || !res) { 725 dev_err(dev, "dma allocate failed\n"); 726 return 0; /* it will be PIO mode */ 727 } 728 729 dmac->dmapp_num = 0; 730 dmac->base = devm_ioremap_resource(dev, res); 731 if (IS_ERR(dmac->base)) 732 return PTR_ERR(dmac->base); 733 734 priv->dma = dmac; 735 736 return 0; 737 } 738