1 /* 2 * Renesas R-Car SSIU/SSI support 3 * 4 * Copyright (C) 2013 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * Based on fsi.c 8 * Kuninori Morimoto <morimoto.kuninori@renesas.com> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License version 2 as 12 * published by the Free Software Foundation. 13 */ 14 #include <linux/delay.h> 15 #include "rsnd.h" 16 #define RSND_SSI_NAME_SIZE 16 17 18 /* 19 * SSICR 20 */ 21 #define FORCE (1 << 31) /* Fixed */ 22 #define DMEN (1 << 28) /* DMA Enable */ 23 #define UIEN (1 << 27) /* Underflow Interrupt Enable */ 24 #define OIEN (1 << 26) /* Overflow Interrupt Enable */ 25 #define IIEN (1 << 25) /* Idle Mode Interrupt Enable */ 26 #define DIEN (1 << 24) /* Data Interrupt Enable */ 27 #define CHNL_4 (1 << 22) /* Channels */ 28 #define CHNL_6 (2 << 22) /* Channels */ 29 #define CHNL_8 (3 << 22) /* Channels */ 30 #define DWL_8 (0 << 19) /* Data Word Length */ 31 #define DWL_16 (1 << 19) /* Data Word Length */ 32 #define DWL_18 (2 << 19) /* Data Word Length */ 33 #define DWL_20 (3 << 19) /* Data Word Length */ 34 #define DWL_22 (4 << 19) /* Data Word Length */ 35 #define DWL_24 (5 << 19) /* Data Word Length */ 36 #define DWL_32 (6 << 19) /* Data Word Length */ 37 38 #define SWL_32 (3 << 16) /* R/W System Word Length */ 39 #define SCKD (1 << 15) /* Serial Bit Clock Direction */ 40 #define SWSD (1 << 14) /* Serial WS Direction */ 41 #define SCKP (1 << 13) /* Serial Bit Clock Polarity */ 42 #define SWSP (1 << 12) /* Serial WS Polarity */ 43 #define SDTA (1 << 10) /* Serial Data Alignment */ 44 #define PDTA (1 << 9) /* Parallel Data Alignment */ 45 #define DEL (1 << 8) /* Serial Data Delay */ 46 #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */ 47 #define TRMD (1 << 1) /* Transmit/Receive Mode Select */ 48 #define EN (1 << 0) /* SSI Module Enable */ 49 50 /* 51 * SSISR 52 */ 53 #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */ 54 #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */ 55 #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */ 56 #define DIRQ (1 << 24) /* Data Interrupt Status Flag */ 57 58 /* 59 * SSIWSR 60 */ 61 #define CONT (1 << 8) /* WS Continue Function */ 62 #define WS_MODE (1 << 0) /* WS Mode */ 63 64 #define SSI_NAME "ssi" 65 66 struct rsnd_ssi { 67 struct rsnd_mod mod; 68 struct rsnd_mod *dma; 69 70 u32 flags; 71 u32 cr_own; 72 u32 cr_clk; 73 u32 cr_mode; 74 u32 wsr; 75 int chan; 76 int rate; 77 int irq; 78 unsigned int usrcnt; 79 }; 80 81 /* flags */ 82 #define RSND_SSI_CLK_PIN_SHARE (1 << 0) 83 #define RSND_SSI_NO_BUSIF (1 << 1) /* SSI+DMA without BUSIF */ 84 85 #define for_each_rsnd_ssi(pos, priv, i) \ 86 for (i = 0; \ 87 (i < rsnd_ssi_nr(priv)) && \ 88 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \ 89 i++) 90 91 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id) 92 #define rsnd_ssi_to_dma(mod) ((ssi)->dma) 93 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr) 94 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod) 95 #define rsnd_ssi_mode_flags(p) ((p)->flags) 96 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io)) 97 #define rsnd_ssi_is_multi_slave(mod, io) \ 98 (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod))) 99 #define rsnd_ssi_is_run_mods(mod, io) \ 100 (rsnd_ssi_run_mods(io) & (1 << rsnd_mod_id(mod))) 101 102 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io) 103 { 104 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 105 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 106 int use_busif = 0; 107 108 if (!rsnd_ssi_is_dma_mode(mod)) 109 return 0; 110 111 if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF)) 112 use_busif = 1; 113 if (rsnd_io_to_mod_src(io)) 114 use_busif = 1; 115 116 return use_busif; 117 } 118 119 static void rsnd_ssi_status_clear(struct rsnd_mod *mod) 120 { 121 rsnd_mod_write(mod, SSISR, 0); 122 } 123 124 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod) 125 { 126 return rsnd_mod_read(mod, SSISR); 127 } 128 129 static void rsnd_ssi_status_check(struct rsnd_mod *mod, 130 u32 bit) 131 { 132 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 133 struct device *dev = rsnd_priv_to_dev(priv); 134 u32 status; 135 int i; 136 137 for (i = 0; i < 1024; i++) { 138 status = rsnd_ssi_status_get(mod); 139 if (status & bit) 140 return; 141 142 udelay(50); 143 } 144 145 dev_warn(dev, "%s[%d] status check failed\n", 146 rsnd_mod_name(mod), rsnd_mod_id(mod)); 147 } 148 149 static u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io) 150 { 151 struct rsnd_mod *mod; 152 enum rsnd_mod_type types[] = { 153 RSND_MOD_SSIM1, 154 RSND_MOD_SSIM2, 155 RSND_MOD_SSIM3, 156 }; 157 int i, mask; 158 159 mask = 0; 160 for (i = 0; i < ARRAY_SIZE(types); i++) { 161 mod = rsnd_io_to_mod(io, types[i]); 162 if (!mod) 163 continue; 164 165 mask |= 1 << rsnd_mod_id(mod); 166 } 167 168 return mask; 169 } 170 171 static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io) 172 { 173 struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); 174 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 175 176 return rsnd_ssi_multi_slaves_runtime(io) | 177 1 << rsnd_mod_id(ssi_mod) | 178 1 << rsnd_mod_id(ssi_parent_mod); 179 } 180 181 u32 rsnd_ssi_multi_slaves_runtime(struct rsnd_dai_stream *io) 182 { 183 if (rsnd_runtime_is_ssi_multi(io)) 184 return rsnd_ssi_multi_slaves(io); 185 186 return 0; 187 } 188 189 static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod, 190 struct rsnd_dai_stream *io) 191 { 192 struct rsnd_priv *priv = rsnd_io_to_priv(io); 193 struct device *dev = rsnd_priv_to_dev(priv); 194 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 195 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 196 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 197 int chan = rsnd_runtime_channel_for_ssi(io); 198 int j, ret; 199 int ssi_clk_mul_table[] = { 200 1, 2, 4, 8, 16, 6, 12, 201 }; 202 unsigned int main_rate; 203 unsigned int rate = rsnd_io_is_play(io) ? 204 rsnd_src_get_out_rate(priv, io) : 205 rsnd_src_get_in_rate(priv, io); 206 207 if (!rsnd_rdai_is_clk_master(rdai)) 208 return 0; 209 210 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io)) 211 return 0; 212 213 if (rsnd_ssi_is_multi_slave(mod, io)) 214 return 0; 215 216 if (ssi->usrcnt > 1) { 217 if (ssi->rate != rate) { 218 dev_err(dev, "SSI parent/child should use same rate\n"); 219 return -EINVAL; 220 } 221 222 return 0; 223 } 224 225 /* 226 * Find best clock, and try to start ADG 227 */ 228 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) { 229 230 /* 231 * It will set SSIWSR.CONT here, but SSICR.CKDV = 000 232 * with it is not allowed. (SSIWSR.WS_MODE with 233 * SSICR.CKDV = 000 is not allowed either). 234 * Skip it. See SSICR.CKDV 235 */ 236 if (j == 0) 237 continue; 238 239 /* 240 * this driver is assuming that 241 * system word is 32bit x chan 242 * see rsnd_ssi_init() 243 */ 244 main_rate = rate * 32 * chan * ssi_clk_mul_table[j]; 245 246 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate); 247 if (0 == ret) { 248 ssi->cr_clk = FORCE | SWL_32 | 249 SCKD | SWSD | CKDV(j); 250 ssi->wsr = CONT; 251 252 ssi->rate = rate; 253 254 dev_dbg(dev, "%s[%d] outputs %u Hz\n", 255 rsnd_mod_name(mod), 256 rsnd_mod_id(mod), rate); 257 258 return 0; 259 } 260 } 261 262 dev_err(dev, "unsupported clock rate\n"); 263 return -EIO; 264 } 265 266 static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod, 267 struct rsnd_dai_stream *io) 268 { 269 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 270 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 271 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 272 273 if (!rsnd_rdai_is_clk_master(rdai)) 274 return; 275 276 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io)) 277 return; 278 279 if (ssi->usrcnt > 1) 280 return; 281 282 ssi->cr_clk = 0; 283 ssi->rate = 0; 284 285 rsnd_adg_ssi_clk_stop(mod); 286 } 287 288 static void rsnd_ssi_config_init(struct rsnd_mod *mod, 289 struct rsnd_dai_stream *io) 290 { 291 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 292 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 293 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 294 u32 cr_own; 295 u32 cr_mode; 296 u32 wsr; 297 int is_tdm; 298 299 is_tdm = rsnd_runtime_is_ssi_tdm(io); 300 301 /* 302 * always use 32bit system word. 303 * see also rsnd_ssi_master_clk_enable() 304 */ 305 cr_own = FORCE | SWL_32 | PDTA; 306 307 if (rdai->bit_clk_inv) 308 cr_own |= SCKP; 309 if (rdai->frm_clk_inv ^ is_tdm) 310 cr_own |= SWSP; 311 if (rdai->data_alignment) 312 cr_own |= SDTA; 313 if (rdai->sys_delay) 314 cr_own |= DEL; 315 if (rsnd_io_is_play(io)) 316 cr_own |= TRMD; 317 318 switch (runtime->sample_bits) { 319 case 16: 320 cr_own |= DWL_16; 321 break; 322 case 32: 323 cr_own |= DWL_24; 324 break; 325 } 326 327 if (rsnd_ssi_is_dma_mode(mod)) { 328 cr_mode = UIEN | OIEN | /* over/under run */ 329 DMEN; /* DMA : enable DMA */ 330 } else { 331 cr_mode = DIEN; /* PIO : enable Data interrupt */ 332 } 333 334 /* 335 * TDM Extend Mode 336 * see 337 * rsnd_ssiu_init_gen2() 338 */ 339 wsr = ssi->wsr; 340 if (is_tdm) { 341 wsr |= WS_MODE; 342 cr_own |= CHNL_8; 343 } 344 345 ssi->cr_own = cr_own; 346 ssi->cr_mode = cr_mode; 347 ssi->wsr = wsr; 348 } 349 350 static void rsnd_ssi_register_setup(struct rsnd_mod *mod) 351 { 352 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 353 354 rsnd_mod_write(mod, SSIWSR, ssi->wsr); 355 rsnd_mod_write(mod, SSICR, ssi->cr_own | 356 ssi->cr_clk | 357 ssi->cr_mode); /* without EN */ 358 } 359 360 /* 361 * SSI mod common functions 362 */ 363 static int rsnd_ssi_init(struct rsnd_mod *mod, 364 struct rsnd_dai_stream *io, 365 struct rsnd_priv *priv) 366 { 367 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 368 int ret; 369 370 if (!rsnd_ssi_is_run_mods(mod, io)) 371 return 0; 372 373 ssi->usrcnt++; 374 375 rsnd_mod_power_on(mod); 376 377 ret = rsnd_ssi_master_clk_start(mod, io); 378 if (ret < 0) 379 return ret; 380 381 if (!rsnd_ssi_is_parent(mod, io)) 382 rsnd_ssi_config_init(mod, io); 383 384 rsnd_ssi_register_setup(mod); 385 386 /* clear error status */ 387 rsnd_ssi_status_clear(mod); 388 389 return 0; 390 } 391 392 static int rsnd_ssi_quit(struct rsnd_mod *mod, 393 struct rsnd_dai_stream *io, 394 struct rsnd_priv *priv) 395 { 396 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 397 struct device *dev = rsnd_priv_to_dev(priv); 398 399 if (!rsnd_ssi_is_run_mods(mod, io)) 400 return 0; 401 402 if (!ssi->usrcnt) { 403 dev_err(dev, "%s[%d] usrcnt error\n", 404 rsnd_mod_name(mod), rsnd_mod_id(mod)); 405 return -EIO; 406 } 407 408 if (!rsnd_ssi_is_parent(mod, io)) 409 ssi->cr_own = 0; 410 411 rsnd_ssi_master_clk_stop(mod, io); 412 413 rsnd_mod_power_off(mod); 414 415 ssi->usrcnt--; 416 417 return 0; 418 } 419 420 static int rsnd_ssi_hw_params(struct rsnd_mod *mod, 421 struct rsnd_dai_stream *io, 422 struct snd_pcm_substream *substream, 423 struct snd_pcm_hw_params *params) 424 { 425 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 426 int chan = params_channels(params); 427 428 /* 429 * snd_pcm_ops::hw_params will be called *before* 430 * snd_soc_dai_ops::trigger. Thus, ssi->usrcnt is 0 431 * in 1st call. 432 */ 433 if (ssi->usrcnt) { 434 /* 435 * Already working. 436 * It will happen if SSI has parent/child connection. 437 * it is error if child <-> parent SSI uses 438 * different channels. 439 */ 440 if (ssi->chan != chan) 441 return -EIO; 442 } 443 444 ssi->chan = chan; 445 446 return 0; 447 } 448 449 static int rsnd_ssi_start(struct rsnd_mod *mod, 450 struct rsnd_dai_stream *io, 451 struct rsnd_priv *priv) 452 { 453 if (!rsnd_ssi_is_run_mods(mod, io)) 454 return 0; 455 456 /* 457 * EN will be set via SSIU :: SSI_CONTROL 458 * if Multi channel mode 459 */ 460 if (rsnd_ssi_multi_slaves_runtime(io)) 461 return 0; 462 463 rsnd_mod_bset(mod, SSICR, EN, EN); 464 465 return 0; 466 } 467 468 static int rsnd_ssi_stop(struct rsnd_mod *mod, 469 struct rsnd_dai_stream *io, 470 struct rsnd_priv *priv) 471 { 472 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 473 u32 cr; 474 475 if (!rsnd_ssi_is_run_mods(mod, io)) 476 return 0; 477 478 /* 479 * don't stop if not last user 480 * see also 481 * rsnd_ssi_start 482 * rsnd_ssi_interrupt 483 */ 484 if (ssi->usrcnt > 1) 485 return 0; 486 487 /* 488 * disable all IRQ, 489 * and, wait all data was sent 490 */ 491 cr = ssi->cr_own | 492 ssi->cr_clk; 493 494 rsnd_mod_write(mod, SSICR, cr | EN); 495 rsnd_ssi_status_check(mod, DIRQ); 496 497 /* 498 * disable SSI, 499 * and, wait idle state 500 */ 501 rsnd_mod_write(mod, SSICR, cr); /* disabled all */ 502 rsnd_ssi_status_check(mod, IIRQ); 503 504 return 0; 505 } 506 507 static int rsnd_ssi_irq(struct rsnd_mod *mod, 508 struct rsnd_dai_stream *io, 509 struct rsnd_priv *priv, 510 int enable) 511 { 512 u32 val = 0; 513 514 if (rsnd_is_gen1(priv)) 515 return 0; 516 517 if (rsnd_ssi_is_parent(mod, io)) 518 return 0; 519 520 if (!rsnd_ssi_is_run_mods(mod, io)) 521 return 0; 522 523 if (enable) 524 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000; 525 526 rsnd_mod_write(mod, SSI_INT_ENABLE, val); 527 528 return 0; 529 } 530 531 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, 532 struct rsnd_dai_stream *io) 533 { 534 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 535 int is_dma = rsnd_ssi_is_dma_mode(mod); 536 u32 status; 537 bool elapsed = false; 538 bool stop = false; 539 540 spin_lock(&priv->lock); 541 542 /* ignore all cases if not working */ 543 if (!rsnd_io_is_working(io)) 544 goto rsnd_ssi_interrupt_out; 545 546 status = rsnd_ssi_status_get(mod); 547 548 /* PIO only */ 549 if (!is_dma && (status & DIRQ)) { 550 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 551 u32 *buf = (u32 *)(runtime->dma_area + 552 rsnd_dai_pointer_offset(io, 0)); 553 554 /* 555 * 8/16/32 data can be assesse to TDR/RDR register 556 * directly as 32bit data 557 * see rsnd_ssi_init() 558 */ 559 if (rsnd_io_is_play(io)) 560 rsnd_mod_write(mod, SSITDR, *buf); 561 else 562 *buf = rsnd_mod_read(mod, SSIRDR); 563 564 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf)); 565 } 566 567 /* DMA only */ 568 if (is_dma && (status & (UIRQ | OIRQ))) 569 stop = true; 570 571 rsnd_ssi_status_clear(mod); 572 rsnd_ssi_interrupt_out: 573 spin_unlock(&priv->lock); 574 575 if (elapsed) 576 rsnd_dai_period_elapsed(io); 577 578 if (stop) 579 snd_pcm_stop_xrun(io->substream); 580 581 } 582 583 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) 584 { 585 struct rsnd_mod *mod = data; 586 587 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); 588 589 return IRQ_HANDLED; 590 } 591 592 /* 593 * SSI PIO 594 */ 595 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, 596 struct rsnd_dai_stream *io) 597 { 598 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 599 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 600 601 if (!__rsnd_ssi_is_pin_sharing(mod)) 602 return; 603 604 if (!rsnd_rdai_is_clk_master(rdai)) 605 return; 606 607 switch (rsnd_mod_id(mod)) { 608 case 1: 609 case 2: 610 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); 611 break; 612 case 4: 613 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); 614 break; 615 case 8: 616 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); 617 break; 618 } 619 } 620 621 static int rsnd_ssi_pcm_new(struct rsnd_mod *mod, 622 struct rsnd_dai_stream *io, 623 struct snd_soc_pcm_runtime *rtd) 624 { 625 /* 626 * rsnd_rdai_is_clk_master() will be enabled after set_fmt, 627 * and, pcm_new will be called after it. 628 * This function reuse pcm_new at this point. 629 */ 630 rsnd_ssi_parent_attach(mod, io); 631 632 return 0; 633 } 634 635 static int rsnd_ssi_common_probe(struct rsnd_mod *mod, 636 struct rsnd_dai_stream *io, 637 struct rsnd_priv *priv) 638 { 639 struct device *dev = rsnd_priv_to_dev(priv); 640 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 641 int ret; 642 643 /* 644 * SSIP/SSIU/IRQ are not needed on 645 * SSI Multi slaves 646 */ 647 if (rsnd_ssi_is_multi_slave(mod, io)) 648 return 0; 649 650 /* 651 * It can't judge ssi parent at this point 652 * see rsnd_ssi_pcm_new() 653 */ 654 655 ret = rsnd_ssiu_attach(io, mod); 656 if (ret < 0) 657 return ret; 658 659 /* 660 * SSI might be called again as PIO fallback 661 * It is easy to manual handling for IRQ request/free 662 */ 663 ret = request_irq(ssi->irq, 664 rsnd_ssi_interrupt, 665 IRQF_SHARED, 666 dev_name(dev), mod); 667 668 return ret; 669 } 670 671 static struct rsnd_mod_ops rsnd_ssi_pio_ops = { 672 .name = SSI_NAME, 673 .probe = rsnd_ssi_common_probe, 674 .init = rsnd_ssi_init, 675 .quit = rsnd_ssi_quit, 676 .start = rsnd_ssi_start, 677 .stop = rsnd_ssi_stop, 678 .irq = rsnd_ssi_irq, 679 .pcm_new = rsnd_ssi_pcm_new, 680 .hw_params = rsnd_ssi_hw_params, 681 }; 682 683 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, 684 struct rsnd_dai_stream *io, 685 struct rsnd_priv *priv) 686 { 687 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 688 int ret; 689 690 /* 691 * SSIP/SSIU/IRQ/DMA are not needed on 692 * SSI Multi slaves 693 */ 694 if (rsnd_ssi_is_multi_slave(mod, io)) 695 return 0; 696 697 ret = rsnd_ssi_common_probe(mod, io, priv); 698 if (ret) 699 return ret; 700 701 /* SSI probe might be called many times in MUX multi path */ 702 ret = rsnd_dma_attach(io, mod, &ssi->dma); 703 704 return ret; 705 } 706 707 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod, 708 struct rsnd_dai_stream *io, 709 struct rsnd_priv *priv) 710 { 711 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 712 713 /* PIO will request IRQ again */ 714 free_irq(ssi->irq, mod); 715 716 return 0; 717 } 718 719 static int rsnd_ssi_fallback(struct rsnd_mod *mod, 720 struct rsnd_dai_stream *io, 721 struct rsnd_priv *priv) 722 { 723 struct device *dev = rsnd_priv_to_dev(priv); 724 725 /* 726 * fallback to PIO 727 * 728 * SSI .probe might be called again. 729 * see 730 * rsnd_rdai_continuance_probe() 731 */ 732 mod->ops = &rsnd_ssi_pio_ops; 733 734 dev_info(dev, "%s[%d] fallback to PIO mode\n", 735 rsnd_mod_name(mod), rsnd_mod_id(mod)); 736 737 return 0; 738 } 739 740 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, 741 struct rsnd_mod *mod) 742 { 743 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 744 int is_play = rsnd_io_is_play(io); 745 char *name; 746 747 if (rsnd_ssi_use_busif(io)) 748 name = is_play ? "rxu" : "txu"; 749 else 750 name = is_play ? "rx" : "tx"; 751 752 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), 753 mod, name); 754 } 755 756 static struct rsnd_mod_ops rsnd_ssi_dma_ops = { 757 .name = SSI_NAME, 758 .dma_req = rsnd_ssi_dma_req, 759 .probe = rsnd_ssi_dma_probe, 760 .remove = rsnd_ssi_dma_remove, 761 .init = rsnd_ssi_init, 762 .quit = rsnd_ssi_quit, 763 .start = rsnd_ssi_start, 764 .stop = rsnd_ssi_stop, 765 .irq = rsnd_ssi_irq, 766 .pcm_new = rsnd_ssi_pcm_new, 767 .fallback = rsnd_ssi_fallback, 768 .hw_params = rsnd_ssi_hw_params, 769 }; 770 771 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) 772 { 773 return mod->ops == &rsnd_ssi_dma_ops; 774 } 775 776 777 /* 778 * Non SSI 779 */ 780 static struct rsnd_mod_ops rsnd_ssi_non_ops = { 781 .name = SSI_NAME, 782 }; 783 784 /* 785 * ssi mod function 786 */ 787 static void rsnd_ssi_connect(struct rsnd_mod *mod, 788 struct rsnd_dai_stream *io) 789 { 790 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 791 enum rsnd_mod_type types[] = { 792 RSND_MOD_SSI, 793 RSND_MOD_SSIM1, 794 RSND_MOD_SSIM2, 795 RSND_MOD_SSIM3, 796 }; 797 enum rsnd_mod_type type; 798 int i; 799 800 /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */ 801 for (i = 0; i < ARRAY_SIZE(types); i++) { 802 type = types[i]; 803 if (!rsnd_io_to_mod(io, type)) { 804 rsnd_dai_connect(mod, io, type); 805 rsnd_set_slot(rdai, 2 * (i + 1), (i + 1)); 806 return; 807 } 808 } 809 } 810 811 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai, 812 struct device_node *playback, 813 struct device_node *capture) 814 { 815 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 816 struct device_node *node; 817 struct device_node *np; 818 struct rsnd_mod *mod; 819 int i; 820 821 node = rsnd_ssi_of_node(priv); 822 if (!node) 823 return; 824 825 i = 0; 826 for_each_child_of_node(node, np) { 827 mod = rsnd_ssi_mod_get(priv, i); 828 if (np == playback) 829 rsnd_ssi_connect(mod, &rdai->playback); 830 if (np == capture) 831 rsnd_ssi_connect(mod, &rdai->capture); 832 i++; 833 } 834 835 of_node_put(node); 836 } 837 838 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) 839 { 840 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) 841 id = 0; 842 843 return rsnd_mod_get(rsnd_ssi_get(priv, id)); 844 } 845 846 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) 847 { 848 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 849 850 return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE); 851 } 852 853 static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io, 854 struct rsnd_mod *mod, 855 enum rsnd_mod_type type) 856 { 857 /* 858 * SSIP (= SSI parent) needs to be special, otherwise, 859 * 2nd SSI might doesn't start. see also rsnd_mod_call() 860 * 861 * We can't include parent SSI status on SSI, because we don't know 862 * how many SSI requests parent SSI. Thus, it is localed on "io" now. 863 * ex) trouble case 864 * Playback: SSI0 865 * Capture : SSI1 (needs SSI0) 866 * 867 * 1) start Capture -> SSI0/SSI1 are started. 868 * 2) start Playback -> SSI0 doesn't work, because it is already 869 * marked as "started" on 1) 870 * 871 * OTOH, using each mod's status is good for MUX case. 872 * It doesn't need to start in 2nd start 873 * ex) 874 * IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0 875 * | 876 * IO-1: SRC1 -> CTU2 -+ 877 * 878 * 1) start IO-0 -> start SSI0 879 * 2) start IO-1 -> SSI0 doesn't need to start, because it is 880 * already started on 1) 881 */ 882 if (type == RSND_MOD_SSIP) 883 return &io->parent_ssi_status; 884 885 return rsnd_mod_get_status(io, mod, type); 886 } 887 888 int rsnd_ssi_probe(struct rsnd_priv *priv) 889 { 890 struct device_node *node; 891 struct device_node *np; 892 struct device *dev = rsnd_priv_to_dev(priv); 893 struct rsnd_mod_ops *ops; 894 struct clk *clk; 895 struct rsnd_ssi *ssi; 896 char name[RSND_SSI_NAME_SIZE]; 897 int i, nr, ret; 898 899 node = rsnd_ssi_of_node(priv); 900 if (!node) 901 return -EINVAL; 902 903 nr = of_get_child_count(node); 904 if (!nr) { 905 ret = -EINVAL; 906 goto rsnd_ssi_probe_done; 907 } 908 909 ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); 910 if (!ssi) { 911 ret = -ENOMEM; 912 goto rsnd_ssi_probe_done; 913 } 914 915 priv->ssi = ssi; 916 priv->ssi_nr = nr; 917 918 i = 0; 919 for_each_child_of_node(node, np) { 920 ssi = rsnd_ssi_get(priv, i); 921 922 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", 923 SSI_NAME, i); 924 925 clk = devm_clk_get(dev, name); 926 if (IS_ERR(clk)) { 927 ret = PTR_ERR(clk); 928 goto rsnd_ssi_probe_done; 929 } 930 931 if (of_get_property(np, "shared-pin", NULL)) 932 ssi->flags |= RSND_SSI_CLK_PIN_SHARE; 933 934 if (of_get_property(np, "no-busif", NULL)) 935 ssi->flags |= RSND_SSI_NO_BUSIF; 936 937 ssi->irq = irq_of_parse_and_map(np, 0); 938 if (!ssi->irq) { 939 ret = -EINVAL; 940 goto rsnd_ssi_probe_done; 941 } 942 943 ops = &rsnd_ssi_non_ops; 944 if (of_property_read_bool(np, "pio-transfer")) 945 ops = &rsnd_ssi_pio_ops; 946 else 947 ops = &rsnd_ssi_dma_ops; 948 949 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 950 rsnd_ssi_get_status, RSND_MOD_SSI, i); 951 if (ret) 952 goto rsnd_ssi_probe_done; 953 954 i++; 955 } 956 957 ret = 0; 958 959 rsnd_ssi_probe_done: 960 of_node_put(node); 961 962 return ret; 963 } 964 965 void rsnd_ssi_remove(struct rsnd_priv *priv) 966 { 967 struct rsnd_ssi *ssi; 968 int i; 969 970 for_each_rsnd_ssi(ssi, priv, i) { 971 rsnd_mod_quit(rsnd_mod_get(ssi)); 972 } 973 } 974