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