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 * TDM Mode 404 * see 405 * rsnd_ssiu_init_gen2() 406 */ 407 wsr = ssi->wsr; 408 if (is_tdm) { 409 wsr |= WS_MODE; 410 cr_own |= CHNL_8; 411 } 412 413 /* 414 * We shouldn't exchange SWSP after running. 415 * This means, parent needs to care it. 416 */ 417 if (rsnd_ssi_is_parent(mod, io)) 418 goto init_end; 419 420 if (rsnd_io_is_play(io)) 421 cr_own |= TRMD; 422 423 cr_own &= ~DWL_MASK; 424 switch (snd_pcm_format_width(runtime->format)) { 425 case 8: 426 cr_own |= DWL_8; 427 break; 428 case 16: 429 cr_own |= DWL_16; 430 break; 431 case 24: 432 cr_own |= DWL_24; 433 break; 434 } 435 436 if (rsnd_ssi_is_dma_mode(mod)) { 437 cr_mode = UIEN | OIEN | /* over/under run */ 438 DMEN; /* DMA : enable DMA */ 439 } else { 440 cr_mode = DIEN; /* PIO : enable Data interrupt */ 441 } 442 443 init_end: 444 ssi->cr_own = cr_own; 445 ssi->cr_mode = cr_mode; 446 ssi->wsr = wsr; 447 } 448 449 static void rsnd_ssi_register_setup(struct rsnd_mod *mod) 450 { 451 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 452 453 rsnd_mod_write(mod, SSIWSR, ssi->wsr); 454 rsnd_mod_write(mod, SSICR, ssi->cr_own | 455 ssi->cr_clk | 456 ssi->cr_mode | 457 ssi->cr_en); 458 } 459 460 /* 461 * SSI mod common functions 462 */ 463 static int rsnd_ssi_init(struct rsnd_mod *mod, 464 struct rsnd_dai_stream *io, 465 struct rsnd_priv *priv) 466 { 467 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 468 469 if (!rsnd_ssi_is_run_mods(mod, io)) 470 return 0; 471 472 ssi->usrcnt++; 473 474 rsnd_mod_power_on(mod); 475 476 rsnd_ssi_config_init(mod, io); 477 478 rsnd_ssi_register_setup(mod); 479 480 /* clear error status */ 481 rsnd_ssi_status_clear(mod); 482 483 return 0; 484 } 485 486 static int rsnd_ssi_quit(struct rsnd_mod *mod, 487 struct rsnd_dai_stream *io, 488 struct rsnd_priv *priv) 489 { 490 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 491 struct device *dev = rsnd_priv_to_dev(priv); 492 493 if (!rsnd_ssi_is_run_mods(mod, io)) 494 return 0; 495 496 if (!ssi->usrcnt) { 497 dev_err(dev, "%s[%d] usrcnt error\n", 498 rsnd_mod_name(mod), rsnd_mod_id(mod)); 499 return -EIO; 500 } 501 502 rsnd_ssi_master_clk_stop(mod, io); 503 504 rsnd_mod_power_off(mod); 505 506 ssi->usrcnt--; 507 508 if (!ssi->usrcnt) { 509 ssi->cr_own = 0; 510 ssi->cr_mode = 0; 511 ssi->wsr = 0; 512 } 513 514 return 0; 515 } 516 517 static int rsnd_ssi_hw_params(struct rsnd_mod *mod, 518 struct rsnd_dai_stream *io, 519 struct snd_pcm_substream *substream, 520 struct snd_pcm_hw_params *params) 521 { 522 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 523 unsigned int fmt_width = snd_pcm_format_width(params_format(params)); 524 525 if (fmt_width > rdai->chan_width) { 526 struct rsnd_priv *priv = rsnd_io_to_priv(io); 527 struct device *dev = rsnd_priv_to_dev(priv); 528 529 dev_err(dev, "invalid combination of slot-width and format-data-width\n"); 530 return -EINVAL; 531 } 532 533 return 0; 534 } 535 536 static int rsnd_ssi_start(struct rsnd_mod *mod, 537 struct rsnd_dai_stream *io, 538 struct rsnd_priv *priv) 539 { 540 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 541 542 if (!rsnd_ssi_is_run_mods(mod, io)) 543 return 0; 544 545 /* 546 * EN will be set via SSIU :: SSI_CONTROL 547 * if Multi channel mode 548 */ 549 if (rsnd_ssi_multi_slaves_runtime(io)) 550 return 0; 551 552 /* 553 * EN is for data output. 554 * SSI parent EN is not needed. 555 */ 556 if (rsnd_ssi_is_parent(mod, io)) 557 return 0; 558 559 ssi->cr_en = EN; 560 561 rsnd_mod_write(mod, SSICR, ssi->cr_own | 562 ssi->cr_clk | 563 ssi->cr_mode | 564 ssi->cr_en); 565 566 return 0; 567 } 568 569 static int rsnd_ssi_stop(struct rsnd_mod *mod, 570 struct rsnd_dai_stream *io, 571 struct rsnd_priv *priv) 572 { 573 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 574 u32 cr; 575 576 if (!rsnd_ssi_is_run_mods(mod, io)) 577 return 0; 578 579 if (rsnd_ssi_is_parent(mod, io)) 580 return 0; 581 582 cr = ssi->cr_own | 583 ssi->cr_clk; 584 585 /* 586 * disable all IRQ, 587 * Playback: Wait all data was sent 588 * Capture: It might not receave data. Do nothing 589 */ 590 if (rsnd_io_is_play(io)) { 591 rsnd_mod_write(mod, SSICR, cr | EN); 592 rsnd_ssi_status_check(mod, DIRQ); 593 } 594 595 /* 596 * disable SSI, 597 * and, wait idle state 598 */ 599 rsnd_mod_write(mod, SSICR, cr); /* disabled all */ 600 rsnd_ssi_status_check(mod, IIRQ); 601 602 ssi->cr_en = 0; 603 604 return 0; 605 } 606 607 static int rsnd_ssi_irq(struct rsnd_mod *mod, 608 struct rsnd_dai_stream *io, 609 struct rsnd_priv *priv, 610 int enable) 611 { 612 u32 val = 0; 613 614 if (rsnd_is_gen1(priv)) 615 return 0; 616 617 if (rsnd_ssi_is_parent(mod, io)) 618 return 0; 619 620 if (!rsnd_ssi_is_run_mods(mod, io)) 621 return 0; 622 623 if (enable) 624 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000; 625 626 rsnd_mod_write(mod, SSI_INT_ENABLE, val); 627 628 return 0; 629 } 630 631 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod, 632 struct rsnd_dai_stream *io); 633 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, 634 struct rsnd_dai_stream *io) 635 { 636 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 637 struct device *dev = rsnd_priv_to_dev(priv); 638 int is_dma = rsnd_ssi_is_dma_mode(mod); 639 u32 status; 640 bool elapsed = false; 641 bool stop = false; 642 643 spin_lock(&priv->lock); 644 645 /* ignore all cases if not working */ 646 if (!rsnd_io_is_working(io)) 647 goto rsnd_ssi_interrupt_out; 648 649 status = rsnd_ssi_status_get(mod); 650 651 /* PIO only */ 652 if (!is_dma && (status & DIRQ)) 653 elapsed = rsnd_ssi_pio_interrupt(mod, io); 654 655 /* DMA only */ 656 if (is_dma && (status & (UIRQ | OIRQ))) { 657 rsnd_dbg_irq_status(dev, "%s[%d] err status : 0x%08x\n", 658 rsnd_mod_name(mod), rsnd_mod_id(mod), status); 659 660 stop = true; 661 } 662 663 rsnd_ssi_status_clear(mod); 664 rsnd_ssi_interrupt_out: 665 spin_unlock(&priv->lock); 666 667 if (elapsed) 668 rsnd_dai_period_elapsed(io); 669 670 if (stop) 671 snd_pcm_stop_xrun(io->substream); 672 673 } 674 675 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) 676 { 677 struct rsnd_mod *mod = data; 678 679 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); 680 681 return IRQ_HANDLED; 682 } 683 684 /* 685 * SSI PIO 686 */ 687 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, 688 struct rsnd_dai_stream *io) 689 { 690 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 691 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 692 693 if (!__rsnd_ssi_is_pin_sharing(mod)) 694 return; 695 696 if (!rsnd_rdai_is_clk_master(rdai)) 697 return; 698 699 switch (rsnd_mod_id(mod)) { 700 case 1: 701 case 2: 702 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); 703 break; 704 case 4: 705 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); 706 break; 707 case 8: 708 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); 709 break; 710 } 711 } 712 713 static int rsnd_ssi_pcm_new(struct rsnd_mod *mod, 714 struct rsnd_dai_stream *io, 715 struct snd_soc_pcm_runtime *rtd) 716 { 717 /* 718 * rsnd_rdai_is_clk_master() will be enabled after set_fmt, 719 * and, pcm_new will be called after it. 720 * This function reuse pcm_new at this point. 721 */ 722 rsnd_ssi_parent_attach(mod, io); 723 724 return 0; 725 } 726 727 static int rsnd_ssi_common_probe(struct rsnd_mod *mod, 728 struct rsnd_dai_stream *io, 729 struct rsnd_priv *priv) 730 { 731 struct device *dev = rsnd_priv_to_dev(priv); 732 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 733 int ret; 734 735 /* 736 * SSIP/SSIU/IRQ are not needed on 737 * SSI Multi slaves 738 */ 739 if (rsnd_ssi_is_multi_slave(mod, io)) 740 return 0; 741 742 /* 743 * It can't judge ssi parent at this point 744 * see rsnd_ssi_pcm_new() 745 */ 746 747 ret = rsnd_ssiu_attach(io, mod); 748 if (ret < 0) 749 return ret; 750 751 /* 752 * SSI might be called again as PIO fallback 753 * It is easy to manual handling for IRQ request/free 754 * 755 * OTOH, this function might be called many times if platform is 756 * using MIX. It needs xxx_attach() many times on xxx_probe(). 757 * Because of it, we can't control .probe/.remove calling count by 758 * mod->status. 759 * But it don't need to call request_irq() many times. 760 * Let's control it by RSND_SSI_PROBED flag. 761 */ 762 if (!rsnd_flags_has(ssi, RSND_SSI_PROBED)) { 763 ret = request_irq(ssi->irq, 764 rsnd_ssi_interrupt, 765 IRQF_SHARED, 766 dev_name(dev), mod); 767 768 rsnd_flags_set(ssi, RSND_SSI_PROBED); 769 } 770 771 return ret; 772 } 773 774 static int rsnd_ssi_common_remove(struct rsnd_mod *mod, 775 struct rsnd_dai_stream *io, 776 struct rsnd_priv *priv) 777 { 778 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 779 struct rsnd_mod *pure_ssi_mod = rsnd_io_to_mod_ssi(io); 780 781 /* Do nothing if non SSI (= SSI parent, multi SSI) mod */ 782 if (pure_ssi_mod != mod) 783 return 0; 784 785 /* PIO will request IRQ again */ 786 if (rsnd_flags_has(ssi, RSND_SSI_PROBED)) { 787 free_irq(ssi->irq, mod); 788 789 rsnd_flags_del(ssi, RSND_SSI_PROBED); 790 } 791 792 return 0; 793 } 794 795 /* 796 * SSI PIO functions 797 */ 798 static bool rsnd_ssi_pio_interrupt(struct rsnd_mod *mod, 799 struct rsnd_dai_stream *io) 800 { 801 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 802 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 803 u32 *buf = (u32 *)(runtime->dma_area + ssi->byte_pos); 804 int shift = 0; 805 int byte_pos; 806 bool elapsed = false; 807 808 if (snd_pcm_format_width(runtime->format) == 24) 809 shift = 8; 810 811 /* 812 * 8/16/32 data can be assesse to TDR/RDR register 813 * directly as 32bit data 814 * see rsnd_ssi_init() 815 */ 816 if (rsnd_io_is_play(io)) 817 rsnd_mod_write(mod, SSITDR, (*buf) << shift); 818 else 819 *buf = (rsnd_mod_read(mod, SSIRDR) >> shift); 820 821 byte_pos = ssi->byte_pos + sizeof(*buf); 822 823 if (byte_pos >= ssi->next_period_byte) { 824 int period_pos = byte_pos / ssi->byte_per_period; 825 826 if (period_pos >= runtime->periods) { 827 byte_pos = 0; 828 period_pos = 0; 829 } 830 831 ssi->next_period_byte = (period_pos + 1) * ssi->byte_per_period; 832 833 elapsed = true; 834 } 835 836 WRITE_ONCE(ssi->byte_pos, byte_pos); 837 838 return elapsed; 839 } 840 841 static int rsnd_ssi_pio_init(struct rsnd_mod *mod, 842 struct rsnd_dai_stream *io, 843 struct rsnd_priv *priv) 844 { 845 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 846 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 847 848 if (!rsnd_ssi_is_parent(mod, io)) { 849 ssi->byte_pos = 0; 850 ssi->byte_per_period = runtime->period_size * 851 runtime->channels * 852 samples_to_bytes(runtime, 1); 853 ssi->next_period_byte = ssi->byte_per_period; 854 } 855 856 return rsnd_ssi_init(mod, io, priv); 857 } 858 859 static int rsnd_ssi_pio_pointer(struct rsnd_mod *mod, 860 struct rsnd_dai_stream *io, 861 snd_pcm_uframes_t *pointer) 862 { 863 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 864 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 865 866 *pointer = bytes_to_frames(runtime, READ_ONCE(ssi->byte_pos)); 867 868 return 0; 869 } 870 871 static int rsnd_ssi_prepare(struct rsnd_mod *mod, 872 struct rsnd_dai_stream *io, 873 struct rsnd_priv *priv) 874 { 875 return rsnd_ssi_master_clk_start(mod, io); 876 } 877 878 static struct rsnd_mod_ops rsnd_ssi_pio_ops = { 879 .name = SSI_NAME, 880 .probe = rsnd_ssi_common_probe, 881 .remove = rsnd_ssi_common_remove, 882 .init = rsnd_ssi_pio_init, 883 .quit = rsnd_ssi_quit, 884 .start = rsnd_ssi_start, 885 .stop = rsnd_ssi_stop, 886 .irq = rsnd_ssi_irq, 887 .pointer = rsnd_ssi_pio_pointer, 888 .pcm_new = rsnd_ssi_pcm_new, 889 .hw_params = rsnd_ssi_hw_params, 890 .prepare = rsnd_ssi_prepare, 891 }; 892 893 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, 894 struct rsnd_dai_stream *io, 895 struct rsnd_priv *priv) 896 { 897 int ret; 898 899 /* 900 * SSIP/SSIU/IRQ/DMA are not needed on 901 * SSI Multi slaves 902 */ 903 if (rsnd_ssi_is_multi_slave(mod, io)) 904 return 0; 905 906 ret = rsnd_ssi_common_probe(mod, io, priv); 907 if (ret) 908 return ret; 909 910 /* SSI probe might be called many times in MUX multi path */ 911 ret = rsnd_dma_attach(io, mod, &io->dma); 912 913 return ret; 914 } 915 916 static int rsnd_ssi_fallback(struct rsnd_mod *mod, 917 struct rsnd_dai_stream *io, 918 struct rsnd_priv *priv) 919 { 920 struct device *dev = rsnd_priv_to_dev(priv); 921 922 /* 923 * fallback to PIO 924 * 925 * SSI .probe might be called again. 926 * see 927 * rsnd_rdai_continuance_probe() 928 */ 929 mod->ops = &rsnd_ssi_pio_ops; 930 931 dev_info(dev, "%s[%d] fallback to PIO mode\n", 932 rsnd_mod_name(mod), rsnd_mod_id(mod)); 933 934 return 0; 935 } 936 937 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, 938 struct rsnd_mod *mod) 939 { 940 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 941 int is_play = rsnd_io_is_play(io); 942 char *name; 943 944 if (rsnd_ssi_use_busif(io)) 945 name = is_play ? "rxu" : "txu"; 946 else 947 name = is_play ? "rx" : "tx"; 948 949 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), 950 mod, name); 951 } 952 953 static struct rsnd_mod_ops rsnd_ssi_dma_ops = { 954 .name = SSI_NAME, 955 .dma_req = rsnd_ssi_dma_req, 956 .probe = rsnd_ssi_dma_probe, 957 .remove = rsnd_ssi_common_remove, 958 .init = rsnd_ssi_init, 959 .quit = rsnd_ssi_quit, 960 .start = rsnd_ssi_start, 961 .stop = rsnd_ssi_stop, 962 .irq = rsnd_ssi_irq, 963 .pcm_new = rsnd_ssi_pcm_new, 964 .fallback = rsnd_ssi_fallback, 965 .hw_params = rsnd_ssi_hw_params, 966 .prepare = rsnd_ssi_prepare, 967 }; 968 969 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) 970 { 971 return mod->ops == &rsnd_ssi_dma_ops; 972 } 973 974 975 /* 976 * ssi mod function 977 */ 978 static void rsnd_ssi_connect(struct rsnd_mod *mod, 979 struct rsnd_dai_stream *io) 980 { 981 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 982 enum rsnd_mod_type types[] = { 983 RSND_MOD_SSI, 984 RSND_MOD_SSIM1, 985 RSND_MOD_SSIM2, 986 RSND_MOD_SSIM3, 987 }; 988 enum rsnd_mod_type type; 989 int i; 990 991 /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */ 992 for (i = 0; i < ARRAY_SIZE(types); i++) { 993 type = types[i]; 994 if (!rsnd_io_to_mod(io, type)) { 995 rsnd_dai_connect(mod, io, type); 996 rsnd_rdai_channels_set(rdai, (i + 1) * 2); 997 rsnd_rdai_ssi_lane_set(rdai, (i + 1)); 998 return; 999 } 1000 } 1001 } 1002 1003 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai, 1004 struct device_node *playback, 1005 struct device_node *capture) 1006 { 1007 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1008 struct device_node *node; 1009 struct device_node *np; 1010 struct rsnd_mod *mod; 1011 int i; 1012 1013 node = rsnd_ssi_of_node(priv); 1014 if (!node) 1015 return; 1016 1017 i = 0; 1018 for_each_child_of_node(node, np) { 1019 mod = rsnd_ssi_mod_get(priv, i); 1020 if (np == playback) 1021 rsnd_ssi_connect(mod, &rdai->playback); 1022 if (np == capture) 1023 rsnd_ssi_connect(mod, &rdai->capture); 1024 i++; 1025 } 1026 1027 of_node_put(node); 1028 } 1029 1030 static void __rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, 1031 struct rsnd_dai_stream *io, 1032 struct device_node *remote_ep) 1033 { 1034 struct device *dev = rsnd_priv_to_dev(priv); 1035 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 1036 struct rsnd_ssi *ssi; 1037 struct device_node *remote_node = of_graph_get_port_parent(remote_ep); 1038 1039 /* support Gen3 only */ 1040 if (!rsnd_is_gen3(priv)) 1041 return; 1042 1043 if (!mod) 1044 return; 1045 1046 ssi = rsnd_mod_to_ssi(mod); 1047 1048 /* HDMI0 */ 1049 if (strstr(remote_node->full_name, "hdmi@fead0000")) { 1050 rsnd_flags_set(ssi, RSND_SSI_HDMI0); 1051 dev_dbg(dev, "%s[%d] connected to HDMI0\n", 1052 rsnd_mod_name(mod), rsnd_mod_id(mod)); 1053 } 1054 1055 /* HDMI1 */ 1056 if (strstr(remote_node->full_name, "hdmi@feae0000")) { 1057 rsnd_flags_set(ssi, RSND_SSI_HDMI1); 1058 dev_dbg(dev, "%s[%d] connected to HDMI1\n", 1059 rsnd_mod_name(mod), rsnd_mod_id(mod)); 1060 } 1061 } 1062 1063 void rsnd_ssi_parse_hdmi_connection(struct rsnd_priv *priv, 1064 struct device_node *endpoint, 1065 int dai_i) 1066 { 1067 struct rsnd_dai *rdai = rsnd_rdai_get(priv, dai_i); 1068 struct device_node *remote_ep; 1069 1070 remote_ep = of_graph_get_remote_endpoint(endpoint); 1071 if (!remote_ep) 1072 return; 1073 1074 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->playback, remote_ep); 1075 __rsnd_ssi_parse_hdmi_connection(priv, &rdai->capture, remote_ep); 1076 } 1077 1078 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) 1079 { 1080 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) 1081 id = 0; 1082 1083 return rsnd_mod_get(rsnd_ssi_get(priv, id)); 1084 } 1085 1086 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) 1087 { 1088 if (!mod) 1089 return 0; 1090 1091 return !!(rsnd_flags_has(rsnd_mod_to_ssi(mod), RSND_SSI_CLK_PIN_SHARE)); 1092 } 1093 1094 static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io, 1095 struct rsnd_mod *mod, 1096 enum rsnd_mod_type type) 1097 { 1098 /* 1099 * SSIP (= SSI parent) needs to be special, otherwise, 1100 * 2nd SSI might doesn't start. see also rsnd_mod_call() 1101 * 1102 * We can't include parent SSI status on SSI, because we don't know 1103 * how many SSI requests parent SSI. Thus, it is localed on "io" now. 1104 * ex) trouble case 1105 * Playback: SSI0 1106 * Capture : SSI1 (needs SSI0) 1107 * 1108 * 1) start Capture -> SSI0/SSI1 are started. 1109 * 2) start Playback -> SSI0 doesn't work, because it is already 1110 * marked as "started" on 1) 1111 * 1112 * OTOH, using each mod's status is good for MUX case. 1113 * It doesn't need to start in 2nd start 1114 * ex) 1115 * IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0 1116 * | 1117 * IO-1: SRC1 -> CTU2 -+ 1118 * 1119 * 1) start IO-0 -> start SSI0 1120 * 2) start IO-1 -> SSI0 doesn't need to start, because it is 1121 * already started on 1) 1122 */ 1123 if (type == RSND_MOD_SSIP) 1124 return &io->parent_ssi_status; 1125 1126 return rsnd_mod_get_status(io, mod, type); 1127 } 1128 1129 int rsnd_ssi_probe(struct rsnd_priv *priv) 1130 { 1131 struct device_node *node; 1132 struct device_node *np; 1133 struct device *dev = rsnd_priv_to_dev(priv); 1134 struct rsnd_mod_ops *ops; 1135 struct clk *clk; 1136 struct rsnd_ssi *ssi; 1137 char name[RSND_SSI_NAME_SIZE]; 1138 int i, nr, ret; 1139 1140 node = rsnd_ssi_of_node(priv); 1141 if (!node) 1142 return -EINVAL; 1143 1144 nr = of_get_child_count(node); 1145 if (!nr) { 1146 ret = -EINVAL; 1147 goto rsnd_ssi_probe_done; 1148 } 1149 1150 ssi = devm_kcalloc(dev, nr, sizeof(*ssi), GFP_KERNEL); 1151 if (!ssi) { 1152 ret = -ENOMEM; 1153 goto rsnd_ssi_probe_done; 1154 } 1155 1156 priv->ssi = ssi; 1157 priv->ssi_nr = nr; 1158 1159 i = 0; 1160 for_each_child_of_node(node, np) { 1161 if (!of_device_is_available(np)) 1162 goto skip; 1163 1164 ssi = rsnd_ssi_get(priv, i); 1165 1166 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", 1167 SSI_NAME, i); 1168 1169 clk = devm_clk_get(dev, name); 1170 if (IS_ERR(clk)) { 1171 ret = PTR_ERR(clk); 1172 of_node_put(np); 1173 goto rsnd_ssi_probe_done; 1174 } 1175 1176 if (of_get_property(np, "shared-pin", NULL)) 1177 rsnd_flags_set(ssi, RSND_SSI_CLK_PIN_SHARE); 1178 1179 if (of_get_property(np, "no-busif", NULL)) 1180 rsnd_flags_set(ssi, RSND_SSI_NO_BUSIF); 1181 1182 ssi->irq = irq_of_parse_and_map(np, 0); 1183 if (!ssi->irq) { 1184 ret = -EINVAL; 1185 of_node_put(np); 1186 goto rsnd_ssi_probe_done; 1187 } 1188 1189 if (of_property_read_bool(np, "pio-transfer")) 1190 ops = &rsnd_ssi_pio_ops; 1191 else 1192 ops = &rsnd_ssi_dma_ops; 1193 1194 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 1195 rsnd_ssi_get_status, RSND_MOD_SSI, i); 1196 if (ret) { 1197 of_node_put(np); 1198 goto rsnd_ssi_probe_done; 1199 } 1200 skip: 1201 i++; 1202 } 1203 1204 ret = 0; 1205 1206 rsnd_ssi_probe_done: 1207 of_node_put(node); 1208 1209 return ret; 1210 } 1211 1212 void rsnd_ssi_remove(struct rsnd_priv *priv) 1213 { 1214 struct rsnd_ssi *ssi; 1215 int i; 1216 1217 for_each_rsnd_ssi(ssi, priv, i) { 1218 rsnd_mod_quit(rsnd_mod_get(ssi)); 1219 } 1220 } 1221