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