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