1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Renesas R-Car SSIU/SSI support 4 // 5 // Copyright (C) 2013 Renesas Solutions Corp. 6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 7 // 8 // Based on fsi.c 9 // Kuninori Morimoto <morimoto.kuninori@renesas.com> 10 11 /* 12 * you can enable below define if you don't need 13 * SSI interrupt status debug message when debugging 14 * see rsnd_dbg_irq_status() 15 * 16 * #define RSND_DEBUG_NO_IRQ_STATUS 1 17 */ 18 19 #include <sound/simple_card_utils.h> 20 #include <linux/delay.h> 21 #include "rsnd.h" 22 #define RSND_SSI_NAME_SIZE 16 23 24 /* 25 * SSICR 26 */ 27 #define FORCE (1 << 31) /* Fixed */ 28 #define DMEN (1 << 28) /* DMA Enable */ 29 #define UIEN (1 << 27) /* Underflow Interrupt Enable */ 30 #define OIEN (1 << 26) /* Overflow Interrupt Enable */ 31 #define IIEN (1 << 25) /* Idle Mode Interrupt Enable */ 32 #define DIEN (1 << 24) /* Data Interrupt Enable */ 33 #define CHNL_4 (1 << 22) /* Channels */ 34 #define CHNL_6 (2 << 22) /* Channels */ 35 #define CHNL_8 (3 << 22) /* Channels */ 36 #define DWL_MASK (7 << 19) /* Data Word Length mask */ 37 #define DWL_8 (0 << 19) /* Data Word Length */ 38 #define DWL_16 (1 << 19) /* Data Word Length */ 39 #define DWL_18 (2 << 19) /* Data Word Length */ 40 #define DWL_20 (3 << 19) /* Data Word Length */ 41 #define DWL_22 (4 << 19) /* Data Word Length */ 42 #define DWL_24 (5 << 19) /* Data Word Length */ 43 #define DWL_32 (6 << 19) /* Data Word Length */ 44 45 /* 46 * System word length 47 */ 48 #define SWL_16 (1 << 16) /* R/W System Word Length */ 49 #define SWL_24 (2 << 16) /* R/W System Word Length */ 50 #define SWL_32 (3 << 16) /* R/W System Word Length */ 51 52 #define SCKD (1 << 15) /* Serial Bit Clock Direction */ 53 #define SWSD (1 << 14) /* Serial WS Direction */ 54 #define SCKP (1 << 13) /* Serial Bit Clock Polarity */ 55 #define SWSP (1 << 12) /* Serial WS Polarity */ 56 #define SDTA (1 << 10) /* Serial Data Alignment */ 57 #define PDTA (1 << 9) /* Parallel Data Alignment */ 58 #define DEL (1 << 8) /* Serial Data Delay */ 59 #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */ 60 #define TRMD (1 << 1) /* Transmit/Receive Mode Select */ 61 #define EN (1 << 0) /* SSI Module Enable */ 62 63 /* 64 * SSISR 65 */ 66 #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */ 67 #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */ 68 #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */ 69 #define DIRQ (1 << 24) /* Data Interrupt Status Flag */ 70 71 /* 72 * SSIWSR 73 */ 74 #define CONT (1 << 8) /* WS Continue Function */ 75 #define WS_MODE (1 << 0) /* WS Mode */ 76 77 #define SSI_NAME "ssi" 78 79 struct rsnd_ssi { 80 struct rsnd_mod mod; 81 82 u32 flags; 83 u32 cr_own; 84 u32 cr_clk; 85 u32 cr_mode; 86 u32 cr_en; 87 u32 wsr; 88 int chan; 89 int rate; 90 int irq; 91 unsigned int usrcnt; 92 93 /* for PIO */ 94 int byte_pos; 95 int byte_per_period; 96 int next_period_byte; 97 }; 98 99 /* flags */ 100 #define RSND_SSI_CLK_PIN_SHARE (1 << 0) 101 #define RSND_SSI_NO_BUSIF (1 << 1) /* SSI+DMA without BUSIF */ 102 #define RSND_SSI_HDMI0 (1 << 2) /* for HDMI0 */ 103 #define RSND_SSI_HDMI1 (1 << 3) /* for HDMI1 */ 104 #define RSND_SSI_PROBED (1 << 4) 105 106 #define for_each_rsnd_ssi(pos, priv, i) \ 107 for (i = 0; \ 108 (i < rsnd_ssi_nr(priv)) && \ 109 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \ 110 i++) 111 112 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id) 113 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr) 114 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod) 115 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io)) 116 #define rsnd_ssi_is_multi_slave(mod, io) \ 117 (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod))) 118 #define rsnd_ssi_is_run_mods(mod, io) \ 119 (rsnd_ssi_run_mods(io) & (1 << rsnd_mod_id(mod))) 120 #define rsnd_ssi_can_output_clk(mod) (!__rsnd_ssi_is_pin_sharing(mod)) 121 122 int rsnd_ssi_hdmi_port(struct rsnd_dai_stream *io) 123 { 124 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 125 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 126 127 if (rsnd_flags_has(ssi, RSND_SSI_HDMI0)) 128 return RSND_SSI_HDMI_PORT0; 129 130 if (rsnd_flags_has(ssi, RSND_SSI_HDMI1)) 131 return RSND_SSI_HDMI_PORT1; 132 133 return 0; 134 } 135 136 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io) 137 { 138 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 139 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 140 int use_busif = 0; 141 142 if (!rsnd_ssi_is_dma_mode(mod)) 143 return 0; 144 145 if (!(rsnd_flags_has(ssi, RSND_SSI_NO_BUSIF))) 146 use_busif = 1; 147 if (rsnd_io_to_mod_src(io)) 148 use_busif = 1; 149 150 return use_busif; 151 } 152 153 int rsnd_ssi_get_busif(struct rsnd_dai_stream *io) 154 { 155 return 0; /* BUSIF0 only for now */ 156 } 157 158 static void rsnd_ssi_status_clear(struct rsnd_mod *mod) 159 { 160 rsnd_mod_write(mod, SSISR, 0); 161 } 162 163 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod) 164 { 165 return rsnd_mod_read(mod, SSISR); 166 } 167 168 static void rsnd_ssi_status_check(struct rsnd_mod *mod, 169 u32 bit) 170 { 171 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 172 struct device *dev = rsnd_priv_to_dev(priv); 173 u32 status; 174 int i; 175 176 for (i = 0; i < 1024; i++) { 177 status = rsnd_ssi_status_get(mod); 178 if (status & bit) 179 return; 180 181 udelay(5); 182 } 183 184 dev_warn(dev, "%s[%d] status check failed\n", 185 rsnd_mod_name(mod), rsnd_mod_id(mod)); 186 } 187 188 static u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io) 189 { 190 struct rsnd_mod *mod; 191 enum rsnd_mod_type types[] = { 192 RSND_MOD_SSIM1, 193 RSND_MOD_SSIM2, 194 RSND_MOD_SSIM3, 195 }; 196 int i, mask; 197 198 mask = 0; 199 for (i = 0; i < ARRAY_SIZE(types); i++) { 200 mod = rsnd_io_to_mod(io, types[i]); 201 if (!mod) 202 continue; 203 204 mask |= 1 << rsnd_mod_id(mod); 205 } 206 207 return mask; 208 } 209 210 static u32 rsnd_ssi_run_mods(struct rsnd_dai_stream *io) 211 { 212 struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); 213 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 214 u32 mods; 215 216 mods = rsnd_ssi_multi_slaves_runtime(io) | 217 1 << rsnd_mod_id(ssi_mod); 218 219 if (ssi_parent_mod) 220 mods |= 1 << rsnd_mod_id(ssi_parent_mod); 221 222 return mods; 223 } 224 225 u32 rsnd_ssi_multi_slaves_runtime(struct rsnd_dai_stream *io) 226 { 227 if (rsnd_runtime_is_ssi_multi(io)) 228 return rsnd_ssi_multi_slaves(io); 229 230 return 0; 231 } 232 233 static u32 rsnd_rdai_width_to_swl(struct rsnd_dai *rdai) 234 { 235 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 236 struct device *dev = rsnd_priv_to_dev(priv); 237 int width = rsnd_rdai_width_get(rdai); 238 239 switch (width) { 240 case 32: return SWL_32; 241 case 24: return SWL_24; 242 case 16: return SWL_16; 243 } 244 245 dev_err(dev, "unsupported slot width value: %d\n", width); 246 return 0; 247 } 248 249 unsigned int rsnd_ssi_clk_query(struct rsnd_dai *rdai, 250 int param1, int param2, int *idx) 251 { 252 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 253 int ssi_clk_mul_table[] = { 254 1, 2, 4, 8, 16, 6, 12, 255 }; 256 int j, ret; 257 unsigned int main_rate; 258 int width = rsnd_rdai_width_get(rdai); 259 260 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) { 261 262 /* 263 * It will set SSIWSR.CONT here, but SSICR.CKDV = 000 264 * with it is not allowed. (SSIWSR.WS_MODE with 265 * SSICR.CKDV = 000 is not allowed either). 266 * Skip it. See SSICR.CKDV 267 */ 268 if (j == 0) 269 continue; 270 271 main_rate = width * param1 * param2 * ssi_clk_mul_table[j]; 272 273 ret = rsnd_adg_clk_query(priv, main_rate); 274 if (ret < 0) 275 continue; 276 277 if (idx) 278 *idx = j; 279 280 return main_rate; 281 } 282 283 return 0; 284 } 285 286 static int rsnd_ssi_master_clk_start(struct rsnd_mod *mod, 287 struct rsnd_dai_stream *io) 288 { 289 struct rsnd_priv *priv = rsnd_io_to_priv(io); 290 struct device *dev = rsnd_priv_to_dev(priv); 291 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 292 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 293 int chan = rsnd_runtime_channel_for_ssi(io); 294 int idx, ret; 295 unsigned int main_rate; 296 unsigned int rate = rsnd_io_is_play(io) ? 297 rsnd_src_get_out_rate(priv, io) : 298 rsnd_src_get_in_rate(priv, io); 299 300 if (!rsnd_rdai_is_clk_master(rdai)) 301 return 0; 302 303 if (!rsnd_ssi_can_output_clk(mod)) 304 return 0; 305 306 if (rsnd_ssi_is_multi_slave(mod, io)) 307 return 0; 308 309 if (ssi->rate) { 310 if (ssi->rate != rate) { 311 dev_err(dev, "SSI parent/child should use same rate\n"); 312 return -EINVAL; 313 } 314 315 if (ssi->chan != chan) { 316 dev_err(dev, "SSI parent/child should use same chan\n"); 317 return -EINVAL; 318 } 319 320 return 0; 321 } 322 323 main_rate = rsnd_ssi_clk_query(rdai, rate, chan, &idx); 324 if (!main_rate) { 325 dev_err(dev, "unsupported clock rate\n"); 326 return -EIO; 327 } 328 329 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate); 330 if (ret < 0) 331 return ret; 332 333 /* 334 * SSI clock will be output contiguously 335 * by below settings. 336 * This means, rsnd_ssi_master_clk_start() 337 * and rsnd_ssi_register_setup() are necessary 338 * for SSI parent 339 * 340 * SSICR : FORCE, SCKD, SWSD 341 * SSIWSR : CONT 342 */ 343 ssi->cr_clk = FORCE | rsnd_rdai_width_to_swl(rdai) | 344 SCKD | SWSD | CKDV(idx); 345 ssi->wsr = CONT; 346 ssi->rate = rate; 347 ssi->chan = chan; 348 349 dev_dbg(dev, "%s[%d] outputs %u Hz\n", 350 rsnd_mod_name(mod), 351 rsnd_mod_id(mod), rate); 352 353 return 0; 354 } 355 356 static void rsnd_ssi_master_clk_stop(struct rsnd_mod *mod, 357 struct rsnd_dai_stream *io) 358 { 359 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 360 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 361 362 if (!rsnd_rdai_is_clk_master(rdai)) 363 return; 364 365 if (!rsnd_ssi_can_output_clk(mod)) 366 return; 367 368 if (ssi->usrcnt > 1) 369 return; 370 371 ssi->cr_clk = 0; 372 ssi->rate = 0; 373 ssi->chan = 0; 374 375 rsnd_adg_ssi_clk_stop(mod); 376 } 377 378 static void rsnd_ssi_config_init(struct rsnd_mod *mod, 379 struct rsnd_dai_stream *io) 380 { 381 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 382 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 383 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 384 u32 cr_own = ssi->cr_own; 385 u32 cr_mode = ssi->cr_mode; 386 u32 wsr = ssi->wsr; 387 int is_tdm; 388 389 is_tdm = rsnd_runtime_is_ssi_tdm(io); 390 391 cr_own |= FORCE | rsnd_rdai_width_to_swl(rdai); 392 393 if (rdai->bit_clk_inv) 394 cr_own |= SCKP; 395 if (rdai->frm_clk_inv ^ is_tdm) 396 cr_own |= SWSP; 397 if (rdai->data_alignment) 398 cr_own |= SDTA; 399 if (rdai->sys_delay) 400 cr_own |= DEL; 401 402 /* 403 * We shouldn't exchange SWSP after running. 404 * This means, parent needs to care it. 405 */ 406 if (rsnd_ssi_is_parent(mod, io)) 407 goto init_end; 408 409 if (rsnd_io_is_play(io)) 410 cr_own |= TRMD; 411 412 cr_own &= ~DWL_MASK; 413 switch (snd_pcm_format_width(runtime->format)) { 414 case 8: 415 cr_own |= DWL_8; 416 break; 417 case 16: 418 cr_own |= DWL_16; 419 break; 420 case 24: 421 cr_own |= DWL_24; 422 break; 423 } 424 425 if (rsnd_ssi_is_dma_mode(mod)) { 426 cr_mode = UIEN | OIEN | /* over/under run */ 427 DMEN; /* DMA : enable DMA */ 428 } else { 429 cr_mode = DIEN; /* PIO : enable Data interrupt */ 430 } 431 432 /* 433 * TDM Extend Mode 434 * see 435 * rsnd_ssiu_init_gen2() 436 */ 437 wsr = ssi->wsr; 438 if (is_tdm) { 439 wsr |= WS_MODE; 440 cr_own |= CHNL_8; 441 } 442 init_end: 443 ssi->cr_own = cr_own; 444 ssi->cr_mode = cr_mode; 445 ssi->wsr = wsr; 446 } 447 448 static void rsnd_ssi_register_setup(struct rsnd_mod *mod) 449 { 450 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 451 452 rsnd_mod_write(mod, SSIWSR, ssi->wsr); 453 rsnd_mod_write(mod, SSICR, ssi->cr_own | 454 ssi->cr_clk | 455 ssi->cr_mode | 456 ssi->cr_en); 457 } 458 459 /* 460 * SSI mod common functions 461 */ 462 static int rsnd_ssi_init(struct rsnd_mod *mod, 463 struct rsnd_dai_stream *io, 464 struct rsnd_priv *priv) 465 { 466 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 467 468 if (!rsnd_ssi_is_run_mods(mod, io)) 469 return 0; 470 471 ssi->usrcnt++; 472 473 rsnd_mod_power_on(mod); 474 475 rsnd_ssi_config_init(mod, io); 476 477 rsnd_ssi_register_setup(mod); 478 479 /* clear error status */ 480 rsnd_ssi_status_clear(mod); 481 482 return 0; 483 } 484 485 static int rsnd_ssi_quit(struct rsnd_mod *mod, 486 struct rsnd_dai_stream *io, 487 struct rsnd_priv *priv) 488 { 489 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 490 struct device *dev = rsnd_priv_to_dev(priv); 491 492 if (!rsnd_ssi_is_run_mods(mod, io)) 493 return 0; 494 495 if (!ssi->usrcnt) { 496 dev_err(dev, "%s[%d] usrcnt error\n", 497 rsnd_mod_name(mod), rsnd_mod_id(mod)); 498 return -EIO; 499 } 500 501 rsnd_ssi_master_clk_stop(mod, io); 502 503 rsnd_mod_power_off(mod); 504 505 ssi->usrcnt--; 506 507 if (!ssi->usrcnt) { 508 ssi->cr_own = 0; 509 ssi->cr_mode = 0; 510 ssi->wsr = 0; 511 } 512 513 return 0; 514 } 515 516 static int rsnd_ssi_hw_params(struct rsnd_mod *mod, 517 struct rsnd_dai_stream *io, 518 struct snd_pcm_substream *substream, 519 struct snd_pcm_hw_params *params) 520 { 521 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 522 unsigned int fmt_width = snd_pcm_format_width(params_format(params)); 523 524 if (fmt_width > rdai->chan_width) { 525 struct rsnd_priv *priv = rsnd_io_to_priv(io); 526 struct device *dev = rsnd_priv_to_dev(priv); 527 528 dev_err(dev, "invalid combination of slot-width and format-data-width\n"); 529 return -EINVAL; 530 } 531 532 return 0; 533 } 534 535 static int rsnd_ssi_start(struct rsnd_mod *mod, 536 struct rsnd_dai_stream *io, 537 struct rsnd_priv *priv) 538 { 539 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 540 541 if (!rsnd_ssi_is_run_mods(mod, io)) 542 return 0; 543 544 /* 545 * EN will be set via SSIU :: SSI_CONTROL 546 * if Multi channel mode 547 */ 548 if (rsnd_ssi_multi_slaves_runtime(io)) 549 return 0; 550 551 /* 552 * EN is for data output. 553 * SSI parent EN is not needed. 554 */ 555 if (rsnd_ssi_is_parent(mod, io)) 556 return 0; 557 558 ssi->cr_en = EN; 559 560 rsnd_mod_write(mod, SSICR, ssi->cr_own | 561 ssi->cr_clk | 562 ssi->cr_mode | 563 ssi->cr_en); 564 565 return 0; 566 } 567 568 static int rsnd_ssi_stop(struct rsnd_mod *mod, 569 struct rsnd_dai_stream *io, 570 struct rsnd_priv *priv) 571 { 572 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 573 u32 cr; 574 575 if (!rsnd_ssi_is_run_mods(mod, io)) 576 return 0; 577 578 if (rsnd_ssi_is_parent(mod, io)) 579 return 0; 580 581 cr = ssi->cr_own | 582 ssi->cr_clk; 583 584 /* 585 * disable all IRQ, 586 * Playback: Wait all data was sent 587 * Capture: It might not receave data. Do nothing 588 */ 589 if (rsnd_io_is_play(io)) { 590 rsnd_mod_write(mod, SSICR, cr | EN); 591 rsnd_ssi_status_check(mod, DIRQ); 592 } 593 594 /* 595 * disable SSI, 596 * and, wait idle state 597 */ 598 rsnd_mod_write(mod, SSICR, cr); /* disabled all */ 599 rsnd_ssi_status_check(mod, IIRQ); 600 601 ssi->cr_en = 0; 602 603 return 0; 604 } 605 606 static int rsnd_ssi_irq(struct rsnd_mod *mod, 607 struct rsnd_dai_stream *io, 608 struct rsnd_priv *priv, 609 int enable) 610 { 611 u32 val = 0; 612 613 if (rsnd_is_gen1(priv)) 614 return 0; 615 616 if (rsnd_ssi_is_parent(mod, io)) 617 return 0; 618 619 if (!rsnd_ssi_is_run_mods(mod, io)) 620 return 0; 621 622 if (enable) 623 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000; 624 625 rsnd_mod_write(mod, SSI_INT_ENABLE, val); 626 627 return 0; 628 } 629 630 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod, 631 struct rsnd_dai_stream *io); 632 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, 633 struct rsnd_dai_stream *io) 634 { 635 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 636 struct device *dev = rsnd_priv_to_dev(priv); 637 int is_dma = rsnd_ssi_is_dma_mode(mod); 638 u32 status; 639 bool elapsed = false; 640 bool stop = false; 641 642 spin_lock(&priv->lock); 643 644 /* ignore all cases if not working */ 645 if (!rsnd_io_is_working(io)) 646 goto rsnd_ssi_interrupt_out; 647 648 status = rsnd_ssi_status_get(mod); 649 650 /* PIO only */ 651 if (!is_dma && (status & DIRQ)) 652 elapsed = rsnd_ssi_pio_interrupt(mod, io); 653 654 /* DMA only */ 655 if (is_dma && (status & (UIRQ | OIRQ))) { 656 rsnd_dbg_irq_status(dev, "%s[%d] err status : 0x%08x\n", 657 rsnd_mod_name(mod), rsnd_mod_id(mod), status); 658 659 stop = true; 660 } 661 662 rsnd_ssi_status_clear(mod); 663 rsnd_ssi_interrupt_out: 664 spin_unlock(&priv->lock); 665 666 if (elapsed) 667 rsnd_dai_period_elapsed(io); 668 669 if (stop) 670 snd_pcm_stop_xrun(io->substream); 671 672 } 673 674 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) 675 { 676 struct rsnd_mod *mod = data; 677 678 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); 679 680 return IRQ_HANDLED; 681 } 682 683 /* 684 * SSI PIO 685 */ 686 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, 687 struct rsnd_dai_stream *io) 688 { 689 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 690 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 691 692 if (!__rsnd_ssi_is_pin_sharing(mod)) 693 return; 694 695 if (!rsnd_rdai_is_clk_master(rdai)) 696 return; 697 698 switch (rsnd_mod_id(mod)) { 699 case 1: 700 case 2: 701 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); 702 break; 703 case 4: 704 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); 705 break; 706 case 8: 707 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); 708 break; 709 } 710 } 711 712 static int rsnd_ssi_pcm_new(struct rsnd_mod *mod, 713 struct rsnd_dai_stream *io, 714 struct snd_soc_pcm_runtime *rtd) 715 { 716 /* 717 * rsnd_rdai_is_clk_master() will be enabled after set_fmt, 718 * and, pcm_new will be called after it. 719 * This function reuse pcm_new at this point. 720 */ 721 rsnd_ssi_parent_attach(mod, io); 722 723 return 0; 724 } 725 726 static int rsnd_ssi_common_probe(struct rsnd_mod *mod, 727 struct rsnd_dai_stream *io, 728 struct rsnd_priv *priv) 729 { 730 struct device *dev = rsnd_priv_to_dev(priv); 731 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 732 int ret; 733 734 /* 735 * SSIP/SSIU/IRQ are not needed on 736 * SSI Multi slaves 737 */ 738 if (rsnd_ssi_is_multi_slave(mod, io)) 739 return 0; 740 741 /* 742 * It can't judge ssi parent at this point 743 * see rsnd_ssi_pcm_new() 744 */ 745 746 ret = rsnd_ssiu_attach(io, mod); 747 if (ret < 0) 748 return ret; 749 750 /* 751 * SSI might be called again as PIO fallback 752 * It is easy to manual handling for IRQ request/free 753 * 754 * OTOH, this function might be called many times if platform is 755 * using MIX. It needs xxx_attach() many times on xxx_probe(). 756 * Because of it, we can't control .probe/.remove calling count by 757 * mod->status. 758 * But it don't need to call request_irq() many times. 759 * Let's control it by RSND_SSI_PROBED flag. 760 */ 761 if (!rsnd_flags_has(ssi, RSND_SSI_PROBED)) { 762 ret = request_irq(ssi->irq, 763 rsnd_ssi_interrupt, 764 IRQF_SHARED, 765 dev_name(dev), mod); 766 767 rsnd_flags_set(ssi, RSND_SSI_PROBED); 768 } 769 770 return ret; 771 } 772 773 static int rsnd_ssi_common_remove(struct rsnd_mod *mod, 774 struct rsnd_dai_stream *io, 775 struct rsnd_priv *priv) 776 { 777 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 778 struct rsnd_mod *pure_ssi_mod = rsnd_io_to_mod_ssi(io); 779 780 /* Do nothing if non SSI (= SSI parent, multi SSI) mod */ 781 if (pure_ssi_mod != mod) 782 return 0; 783 784 /* PIO will request IRQ again */ 785 if (rsnd_flags_has(ssi, RSND_SSI_PROBED)) { 786 free_irq(ssi->irq, mod); 787 788 rsnd_flags_del(ssi, RSND_SSI_PROBED); 789 } 790 791 return 0; 792 } 793 794 /* 795 * SSI PIO functions 796 */ 797 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod, 798 struct rsnd_dai_stream *io) 799 { 800 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 801 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 802 u32 *buf = (u32 *)(runtime->dma_area + ssi->byte_pos); 803 int shift = 0; 804 int byte_pos; 805 bool elapsed = false; 806 807 if (snd_pcm_format_width(runtime->format) == 24) 808 shift = 8; 809 810 /* 811 * 8/16/32 data can be assesse to TDR/RDR register 812 * directly as 32bit data 813 * see rsnd_ssi_init() 814 */ 815 if (rsnd_io_is_play(io)) 816 rsnd_mod_write(mod, SSITDR, (*buf) << shift); 817 else 818 *buf = (rsnd_mod_read(mod, SSIRDR) >> shift); 819 820 byte_pos = ssi->byte_pos + sizeof(*buf); 821 822 if (byte_pos >= ssi->next_period_byte) { 823 int period_pos = byte_pos / ssi->byte_per_period; 824 825 if (period_pos >= runtime->periods) { 826 byte_pos = 0; 827 period_pos = 0; 828 } 829 830 ssi->next_period_byte = (period_pos + 1) * ssi->byte_per_period; 831 832 elapsed = true; 833 } 834 835 WRITE_ONCE(ssi->byte_pos, byte_pos); 836 837 return elapsed; 838 } 839 840 static int rsnd_ssi_pio_init(struct rsnd_mod *mod, 841 struct rsnd_dai_stream *io, 842 struct rsnd_priv *priv) 843 { 844 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 845 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 846 847 if (!rsnd_ssi_is_parent(mod, io)) { 848 ssi->byte_pos = 0; 849 ssi->byte_per_period = runtime->period_size * 850 runtime->channels * 851 samples_to_bytes(runtime, 1); 852 ssi->next_period_byte = ssi->byte_per_period; 853 } 854 855 return rsnd_ssi_init(mod, io, priv); 856 } 857 858 static int rsnd_ssi_pio_pointer(struct rsnd_mod *mod, 859 struct rsnd_dai_stream *io, 860 snd_pcm_uframes_t *pointer) 861 { 862 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 863 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 864 865 *pointer = bytes_to_frames(runtime, READ_ONCE(ssi->byte_pos)); 866 867 return 0; 868 } 869 870 static int rsnd_ssi_prepare(struct rsnd_mod *mod, 871 struct rsnd_dai_stream *io, 872 struct rsnd_priv *priv) 873 { 874 return rsnd_ssi_master_clk_start(mod, io); 875 } 876 877 static struct rsnd_mod_ops rsnd_ssi_pio_ops = { 878 .name = SSI_NAME, 879 .probe = rsnd_ssi_common_probe, 880 .remove = rsnd_ssi_common_remove, 881 .init = rsnd_ssi_pio_init, 882 .quit = rsnd_ssi_quit, 883 .start = rsnd_ssi_start, 884 .stop = rsnd_ssi_stop, 885 .irq = rsnd_ssi_irq, 886 .pointer = rsnd_ssi_pio_pointer, 887 .pcm_new = rsnd_ssi_pcm_new, 888 .hw_params = rsnd_ssi_hw_params, 889 .prepare = rsnd_ssi_prepare, 890 }; 891 892 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, 893 struct rsnd_dai_stream *io, 894 struct rsnd_priv *priv) 895 { 896 int ret; 897 898 /* 899 * SSIP/SSIU/IRQ/DMA are not needed on 900 * SSI Multi slaves 901 */ 902 if (rsnd_ssi_is_multi_slave(mod, io)) 903 return 0; 904 905 ret = rsnd_ssi_common_probe(mod, io, priv); 906 if (ret) 907 return ret; 908 909 /* SSI probe might be called many times in MUX multi path */ 910 ret = rsnd_dma_attach(io, mod, &io->dma); 911 912 return ret; 913 } 914 915 static int rsnd_ssi_fallback(struct rsnd_mod *mod, 916 struct rsnd_dai_stream *io, 917 struct rsnd_priv *priv) 918 { 919 struct device *dev = rsnd_priv_to_dev(priv); 920 921 /* 922 * fallback to PIO 923 * 924 * SSI .probe might be called again. 925 * see 926 * rsnd_rdai_continuance_probe() 927 */ 928 mod->ops = &rsnd_ssi_pio_ops; 929 930 dev_info(dev, "%s[%d] fallback to PIO mode\n", 931 rsnd_mod_name(mod), rsnd_mod_id(mod)); 932 933 return 0; 934 } 935 936 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, 937 struct rsnd_mod *mod) 938 { 939 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 940 int is_play = rsnd_io_is_play(io); 941 char *name; 942 943 if (rsnd_ssi_use_busif(io)) 944 name = is_play ? "rxu" : "txu"; 945 else 946 name = is_play ? "rx" : "tx"; 947 948 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), 949 mod, name); 950 } 951 952 static struct rsnd_mod_ops rsnd_ssi_dma_ops = { 953 .name = SSI_NAME, 954 .dma_req = rsnd_ssi_dma_req, 955 .probe = rsnd_ssi_dma_probe, 956 .remove = rsnd_ssi_common_remove, 957 .init = rsnd_ssi_init, 958 .quit = rsnd_ssi_quit, 959 .start = rsnd_ssi_start, 960 .stop = rsnd_ssi_stop, 961 .irq = rsnd_ssi_irq, 962 .pcm_new = rsnd_ssi_pcm_new, 963 .fallback = rsnd_ssi_fallback, 964 .hw_params = rsnd_ssi_hw_params, 965 .prepare = rsnd_ssi_prepare, 966 }; 967 968 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) 969 { 970 return mod->ops == &rsnd_ssi_dma_ops; 971 } 972 973 974 /* 975 * ssi mod function 976 */ 977 static void rsnd_ssi_connect(struct rsnd_mod *mod, 978 struct rsnd_dai_stream *io) 979 { 980 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 981 enum rsnd_mod_type types[] = { 982 RSND_MOD_SSI, 983 RSND_MOD_SSIM1, 984 RSND_MOD_SSIM2, 985 RSND_MOD_SSIM3, 986 }; 987 enum rsnd_mod_type type; 988 int i; 989 990 /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */ 991 for (i = 0; i < ARRAY_SIZE(types); i++) { 992 type = types[i]; 993 if (!rsnd_io_to_mod(io, type)) { 994 rsnd_dai_connect(mod, io, type); 995 rsnd_rdai_channels_set(rdai, (i + 1) * 2); 996 rsnd_rdai_ssi_lane_set(rdai, (i + 1)); 997 return; 998 } 999 } 1000 } 1001 1002 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai, 1003 struct device_node *playback, 1004 struct device_node *capture) 1005 { 1006 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1007 struct device_node *node; 1008 struct device_node *np; 1009 struct rsnd_mod *mod; 1010 int i; 1011 1012 node = rsnd_ssi_of_node(priv); 1013 if (!node) 1014 return; 1015 1016 i = 0; 1017 for_each_child_of_node(node, np) { 1018 mod = rsnd_ssi_mod_get(priv, i); 1019 if (np == playback) 1020 rsnd_ssi_connect(mod, &rdai->playback); 1021 if (np == capture) 1022 rsnd_ssi_connect(mod, &rdai->capture); 1023 i++; 1024 } 1025 1026 of_node_put(node); 1027 } 1028 1029 static void __rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, 1030 struct rsnd_dai_stream *io, 1031 struct device_node *remote_ep) 1032 { 1033 struct device *dev = rsnd_priv_to_dev(priv); 1034 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 1035 struct rsnd_ssi *ssi; 1036 struct device_node *remote_node = of_graph_get_port_parent(remote_ep); 1037 1038 /* support Gen3 only */ 1039 if (!rsnd_is_gen3(priv)) 1040 return; 1041 1042 if (!mod) 1043 return; 1044 1045 ssi = rsnd_mod_to_ssi(mod); 1046 1047 /* HDMI0 */ 1048 if (strstr(remote_node->full_name, "hdmi@fead0000")) { 1049 rsnd_flags_set(ssi, RSND_SSI_HDMI0); 1050 dev_dbg(dev, "%s[%d] connected to HDMI0\n", 1051 rsnd_mod_name(mod), rsnd_mod_id(mod)); 1052 } 1053 1054 /* HDMI1 */ 1055 if (strstr(remote_node->full_name, "hdmi@feae0000")) { 1056 rsnd_flags_set(ssi, RSND_SSI_HDMI1); 1057 dev_dbg(dev, "%s[%d] connected to HDMI1\n", 1058 rsnd_mod_name(mod), rsnd_mod_id(mod)); 1059 } 1060 } 1061 1062 void rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, 1063 struct device_node *endpoint, 1064 int dai_i) 1065 { 1066 struct rsnd_dai *rdai = rsnd_rdai_get(priv, dai_i); 1067 struct device_node *remote_ep; 1068 1069 remote_ep = of_graph_get_remote_endpoint(endpoint); 1070 if (!remote_ep) 1071 return; 1072 1073 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->playback, remote_ep); 1074 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->capture, remote_ep); 1075 } 1076 1077 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) 1078 { 1079 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) 1080 id = 0; 1081 1082 return rsnd_mod_get(rsnd_ssi_get(priv, id)); 1083 } 1084 1085 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) 1086 { 1087 if (!mod) 1088 return 0; 1089 1090 return !!(rsnd_flags_has(rsnd_mod_to_ssi(mod), RSND_SSI_CLK_PIN_SHARE)); 1091 } 1092 1093 static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io, 1094 struct rsnd_mod *mod, 1095 enum rsnd_mod_type type) 1096 { 1097 /* 1098 * SSIP (= SSI parent) needs to be special, otherwise, 1099 * 2nd SSI might doesn't start. see also rsnd_mod_call() 1100 * 1101 * We can't include parent SSI status on SSI, because we don't know 1102 * how many SSI requests parent SSI. Thus, it is localed on "io" now. 1103 * ex) trouble case 1104 * Playback: SSI0 1105 * Capture : SSI1 (needs SSI0) 1106 * 1107 * 1) start Capture -> SSI0/SSI1 are started. 1108 * 2) start Playback -> SSI0 doesn't work, because it is already 1109 * marked as "started" on 1) 1110 * 1111 * OTOH, using each mod's status is good for MUX case. 1112 * It doesn't need to start in 2nd start 1113 * ex) 1114 * IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0 1115 * | 1116 * IO-1: SRC1 -> CTU2 -+ 1117 * 1118 * 1) start IO-0 -> start SSI0 1119 * 2) start IO-1 -> SSI0 doesn't need to start, because it is 1120 * already started on 1) 1121 */ 1122 if (type == RSND_MOD_SSIP) 1123 return &io->parent_ssi_status; 1124 1125 return rsnd_mod_get_status(io, mod, type); 1126 } 1127 1128 int rsnd_ssi_probe(struct rsnd_priv *priv) 1129 { 1130 struct device_node *node; 1131 struct device_node *np; 1132 struct device *dev = rsnd_priv_to_dev(priv); 1133 struct rsnd_mod_ops *ops; 1134 struct clk *clk; 1135 struct rsnd_ssi *ssi; 1136 char name[RSND_SSI_NAME_SIZE]; 1137 int i, nr, ret; 1138 1139 node = rsnd_ssi_of_node(priv); 1140 if (!node) 1141 return -EINVAL; 1142 1143 nr = of_get_child_count(node); 1144 if (!nr) { 1145 ret = -EINVAL; 1146 goto rsnd_ssi_probe_done; 1147 } 1148 1149 ssi = devm_kcalloc(dev, nr, sizeof(*ssi), GFP_KERNEL); 1150 if (!ssi) { 1151 ret = -ENOMEM; 1152 goto rsnd_ssi_probe_done; 1153 } 1154 1155 priv->ssi = ssi; 1156 priv->ssi_nr = nr; 1157 1158 i = 0; 1159 for_each_child_of_node(node, np) { 1160 if (!of_device_is_available(np)) 1161 goto skip; 1162 1163 ssi = rsnd_ssi_get(priv, i); 1164 1165 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", 1166 SSI_NAME, i); 1167 1168 clk = devm_clk_get(dev, name); 1169 if (IS_ERR(clk)) { 1170 ret = PTR_ERR(clk); 1171 of_node_put(np); 1172 goto rsnd_ssi_probe_done; 1173 } 1174 1175 if (of_get_property(np, "shared-pin", NULL)) 1176 rsnd_flags_set(ssi, RSND_SSI_CLK_PIN_SHARE); 1177 1178 if (of_get_property(np, "no-busif", NULL)) 1179 rsnd_flags_set(ssi, RSND_SSI_NO_BUSIF); 1180 1181 ssi->irq = irq_of_parse_and_map(np, 0); 1182 if (!ssi->irq) { 1183 ret = -EINVAL; 1184 of_node_put(np); 1185 goto rsnd_ssi_probe_done; 1186 } 1187 1188 if (of_property_read_bool(np, "pio-transfer")) 1189 ops = &rsnd_ssi_pio_ops; 1190 else 1191 ops = &rsnd_ssi_dma_ops; 1192 1193 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 1194 rsnd_ssi_get_status, RSND_MOD_SSI, i); 1195 if (ret) { 1196 of_node_put(np); 1197 goto rsnd_ssi_probe_done; 1198 } 1199 skip: 1200 i++; 1201 } 1202 1203 ret = 0; 1204 1205 rsnd_ssi_probe_done: 1206 of_node_put(node); 1207 1208 return ret; 1209 } 1210 1211 void rsnd_ssi_remove(struct rsnd_priv *priv) 1212 { 1213 struct rsnd_ssi *ssi; 1214 int i; 1215 1216 for_each_rsnd_ssi(ssi, priv, i) { 1217 rsnd_mod_quit(rsnd_mod_get(ssi)); 1218 } 1219 } 1220