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 <linux/delay.h> 15 #include "rsnd.h" 16 #define RSND_SSI_NAME_SIZE 16 17 18 /* 19 * SSICR 20 */ 21 #define FORCE (1 << 31) /* Fixed */ 22 #define DMEN (1 << 28) /* DMA Enable */ 23 #define UIEN (1 << 27) /* Underflow Interrupt Enable */ 24 #define OIEN (1 << 26) /* Overflow Interrupt Enable */ 25 #define IIEN (1 << 25) /* Idle Mode Interrupt Enable */ 26 #define DIEN (1 << 24) /* Data Interrupt Enable */ 27 #define CHNL_4 (1 << 22) /* Channels */ 28 #define CHNL_6 (2 << 22) /* Channels */ 29 #define CHNL_8 (3 << 22) /* Channels */ 30 #define DWL_8 (0 << 19) /* Data Word Length */ 31 #define DWL_16 (1 << 19) /* Data Word Length */ 32 #define DWL_18 (2 << 19) /* Data Word Length */ 33 #define DWL_20 (3 << 19) /* Data Word Length */ 34 #define DWL_22 (4 << 19) /* Data Word Length */ 35 #define DWL_24 (5 << 19) /* Data Word Length */ 36 #define DWL_32 (6 << 19) /* Data Word Length */ 37 38 #define SWL_32 (3 << 16) /* R/W System Word Length */ 39 #define SCKD (1 << 15) /* Serial Bit Clock Direction */ 40 #define SWSD (1 << 14) /* Serial WS Direction */ 41 #define SCKP (1 << 13) /* Serial Bit Clock Polarity */ 42 #define SWSP (1 << 12) /* Serial WS Polarity */ 43 #define SDTA (1 << 10) /* Serial Data Alignment */ 44 #define PDTA (1 << 9) /* Parallel Data Alignment */ 45 #define DEL (1 << 8) /* Serial Data Delay */ 46 #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */ 47 #define TRMD (1 << 1) /* Transmit/Receive Mode Select */ 48 #define EN (1 << 0) /* SSI Module Enable */ 49 50 /* 51 * SSISR 52 */ 53 #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */ 54 #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */ 55 #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */ 56 #define DIRQ (1 << 24) /* Data Interrupt Status Flag */ 57 58 /* 59 * SSIWSR 60 */ 61 #define CONT (1 << 8) /* WS Continue Function */ 62 #define WS_MODE (1 << 0) /* WS Mode */ 63 64 #define SSI_NAME "ssi" 65 66 struct rsnd_ssi { 67 struct rsnd_ssi *parent; 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 wsr; 76 int chan; 77 int rate; 78 int err; 79 int irq; 80 unsigned int usrcnt; 81 }; 82 83 /* flags */ 84 #define RSND_SSI_CLK_PIN_SHARE (1 << 0) 85 #define RSND_SSI_NO_BUSIF (1 << 1) /* SSI+DMA without BUSIF */ 86 87 #define for_each_rsnd_ssi(pos, priv, i) \ 88 for (i = 0; \ 89 (i < rsnd_ssi_nr(priv)) && \ 90 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \ 91 i++) 92 93 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id) 94 #define rsnd_ssi_to_dma(mod) ((ssi)->dma) 95 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr) 96 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod) 97 #define rsnd_ssi_mode_flags(p) ((p)->flags) 98 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io)) 99 #define rsnd_ssi_is_multi_slave(ssi, io) ((mod) != rsnd_io_to_mod_ssi(io)) 100 101 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io) 102 { 103 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 104 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 105 int use_busif = 0; 106 107 if (!rsnd_ssi_is_dma_mode(mod)) 108 return 0; 109 110 if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF)) 111 use_busif = 1; 112 if (rsnd_io_to_mod_src(io)) 113 use_busif = 1; 114 115 return use_busif; 116 } 117 118 static void rsnd_ssi_status_clear(struct rsnd_mod *mod) 119 { 120 rsnd_mod_write(mod, SSISR, 0); 121 } 122 123 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod) 124 { 125 return rsnd_mod_read(mod, SSISR); 126 } 127 128 static void rsnd_ssi_status_check(struct rsnd_mod *mod, 129 u32 bit) 130 { 131 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 132 struct device *dev = rsnd_priv_to_dev(priv); 133 u32 status; 134 int i; 135 136 for (i = 0; i < 1024; i++) { 137 status = rsnd_ssi_status_get(mod); 138 if (status & bit) 139 return; 140 141 udelay(50); 142 } 143 144 dev_warn(dev, "status check failed\n"); 145 } 146 147 static int rsnd_ssi_irq_enable(struct rsnd_mod *ssi_mod) 148 { 149 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 150 151 if (rsnd_is_gen1(priv)) 152 return 0; 153 154 /* enable SSI interrupt if Gen2 */ 155 rsnd_mod_write(ssi_mod, SSI_INT_ENABLE, 156 rsnd_ssi_is_dma_mode(ssi_mod) ? 157 0x0e000000 : 0x0f000000); 158 159 return 0; 160 } 161 162 static int rsnd_ssi_irq_disable(struct rsnd_mod *ssi_mod) 163 { 164 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 165 166 if (rsnd_is_gen1(priv)) 167 return 0; 168 169 /* disable SSI interrupt if Gen2 */ 170 rsnd_mod_write(ssi_mod, SSI_INT_ENABLE, 0x00000000); 171 172 return 0; 173 } 174 175 u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io) 176 { 177 struct rsnd_mod *mod; 178 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 179 struct rsnd_priv *priv = rsnd_io_to_priv(io); 180 struct device *dev = rsnd_priv_to_dev(priv); 181 enum rsnd_mod_type types[] = { 182 RSND_MOD_SSIM1, 183 RSND_MOD_SSIM2, 184 RSND_MOD_SSIM3, 185 }; 186 int i, mask; 187 188 switch (runtime->channels) { 189 case 2: /* Multi channel is not needed for Stereo */ 190 return 0; 191 case 6: 192 break; 193 default: 194 dev_err(dev, "unsupported channel\n"); 195 return 0; 196 } 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 int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi, 211 struct rsnd_dai_stream *io) 212 { 213 struct rsnd_priv *priv = rsnd_io_to_priv(io); 214 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 215 struct device *dev = rsnd_priv_to_dev(priv); 216 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 217 struct rsnd_mod *mod = rsnd_mod_get(ssi); 218 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 219 int slots = rsnd_get_slot_width(io); 220 int j, ret; 221 int ssi_clk_mul_table[] = { 222 1, 2, 4, 8, 16, 6, 12, 223 }; 224 unsigned int main_rate; 225 unsigned int rate = rsnd_src_get_ssi_rate(priv, io, runtime); 226 227 if (!rsnd_rdai_is_clk_master(rdai)) 228 return 0; 229 230 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io)) 231 return 0; 232 233 if (rsnd_ssi_is_multi_slave(mod, io)) 234 return 0; 235 236 if (ssi->usrcnt > 1) { 237 if (ssi->rate != rate) { 238 dev_err(dev, "SSI parent/child should use same rate\n"); 239 return -EINVAL; 240 } 241 242 return 0; 243 } 244 245 /* 246 * Find best clock, and try to start ADG 247 */ 248 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) { 249 250 /* 251 * this driver is assuming that 252 * system word is 32bit x slots 253 * see rsnd_ssi_init() 254 */ 255 main_rate = rate * 32 * slots * ssi_clk_mul_table[j]; 256 257 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate); 258 if (0 == ret) { 259 ssi->cr_clk = FORCE | SWL_32 | 260 SCKD | SWSD | CKDV(j); 261 ssi->wsr = CONT; 262 263 ssi->rate = rate; 264 265 dev_dbg(dev, "%s[%d] outputs %u Hz\n", 266 rsnd_mod_name(mod), 267 rsnd_mod_id(mod), rate); 268 269 return 0; 270 } 271 } 272 273 dev_err(dev, "unsupported clock rate\n"); 274 return -EIO; 275 } 276 277 static void rsnd_ssi_master_clk_stop(struct rsnd_ssi *ssi, 278 struct rsnd_dai_stream *io) 279 { 280 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 281 struct rsnd_mod *mod = rsnd_mod_get(ssi); 282 struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io); 283 284 if (!rsnd_rdai_is_clk_master(rdai)) 285 return; 286 287 if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io)) 288 return; 289 290 if (ssi->usrcnt > 1) 291 return; 292 293 ssi->cr_clk = 0; 294 ssi->rate = 0; 295 296 rsnd_adg_ssi_clk_stop(mod); 297 } 298 299 static int rsnd_ssi_config_init(struct rsnd_ssi *ssi, 300 struct rsnd_dai_stream *io) 301 { 302 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 303 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 304 u32 cr_own; 305 u32 cr_mode; 306 u32 wsr; 307 int is_tdm; 308 309 is_tdm = (rsnd_get_slot_width(io) >= 6) ? 1 : 0; 310 311 /* 312 * always use 32bit system word. 313 * see also rsnd_ssi_master_clk_enable() 314 */ 315 cr_own = FORCE | SWL_32 | PDTA; 316 317 if (rdai->bit_clk_inv) 318 cr_own |= SCKP; 319 if (rdai->frm_clk_inv ^ is_tdm) 320 cr_own |= SWSP; 321 if (rdai->data_alignment) 322 cr_own |= SDTA; 323 if (rdai->sys_delay) 324 cr_own |= DEL; 325 if (rsnd_io_is_play(io)) 326 cr_own |= TRMD; 327 328 switch (runtime->sample_bits) { 329 case 16: 330 cr_own |= DWL_16; 331 break; 332 case 32: 333 cr_own |= DWL_24; 334 break; 335 default: 336 return -EINVAL; 337 } 338 339 if (rsnd_ssi_is_dma_mode(rsnd_mod_get(ssi))) { 340 cr_mode = UIEN | OIEN | /* over/under run */ 341 DMEN; /* DMA : enable DMA */ 342 } else { 343 cr_mode = DIEN; /* PIO : enable Data interrupt */ 344 } 345 346 /* 347 * TDM Extend Mode 348 * see 349 * rsnd_ssiu_init_gen2() 350 */ 351 wsr = ssi->wsr; 352 if (is_tdm) { 353 wsr |= WS_MODE; 354 cr_own |= CHNL_8; 355 } 356 357 ssi->cr_own = cr_own; 358 ssi->cr_mode = cr_mode; 359 ssi->wsr = wsr; 360 361 return 0; 362 } 363 364 /* 365 * SSI mod common functions 366 */ 367 static int rsnd_ssi_init(struct rsnd_mod *mod, 368 struct rsnd_dai_stream *io, 369 struct rsnd_priv *priv) 370 { 371 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 372 int ret; 373 374 ssi->usrcnt++; 375 376 rsnd_mod_power_on(mod); 377 378 ret = rsnd_ssi_master_clk_start(ssi, io); 379 if (ret < 0) 380 return ret; 381 382 if (rsnd_ssi_is_parent(mod, io)) 383 return 0; 384 385 ret = rsnd_ssi_config_init(ssi, io); 386 if (ret < 0) 387 return ret; 388 389 ssi->err = -1; /* ignore 1st error */ 390 391 /* clear error status */ 392 rsnd_ssi_status_clear(mod); 393 394 rsnd_ssi_irq_enable(mod); 395 396 return 0; 397 } 398 399 static int rsnd_ssi_quit(struct rsnd_mod *mod, 400 struct rsnd_dai_stream *io, 401 struct rsnd_priv *priv) 402 { 403 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 404 struct device *dev = rsnd_priv_to_dev(priv); 405 406 if (!ssi->usrcnt) { 407 dev_err(dev, "%s[%d] usrcnt error\n", 408 rsnd_mod_name(mod), rsnd_mod_id(mod)); 409 return -EIO; 410 } 411 412 if (!rsnd_ssi_is_parent(mod, io)) { 413 if (ssi->err > 0) 414 dev_warn(dev, "%s[%d] under/over flow err = %d\n", 415 rsnd_mod_name(mod), rsnd_mod_id(mod), 416 ssi->err); 417 418 ssi->cr_own = 0; 419 ssi->err = 0; 420 421 rsnd_ssi_irq_disable(mod); 422 } 423 424 rsnd_ssi_master_clk_stop(ssi, io); 425 426 rsnd_mod_power_off(mod); 427 428 ssi->usrcnt--; 429 430 return 0; 431 } 432 433 static int rsnd_ssi_hw_params(struct rsnd_mod *mod, 434 struct rsnd_dai_stream *io, 435 struct snd_pcm_substream *substream, 436 struct snd_pcm_hw_params *params) 437 { 438 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 439 int chan = params_channels(params); 440 441 /* 442 * Already working. 443 * It will happen if SSI has parent/child connection. 444 */ 445 if (ssi->usrcnt > 1) { 446 /* 447 * it is error if child <-> parent SSI uses 448 * different channels. 449 */ 450 if (ssi->chan != chan) 451 return -EIO; 452 } 453 454 ssi->chan = chan; 455 456 return 0; 457 } 458 459 static u32 rsnd_ssi_record_error(struct rsnd_ssi *ssi) 460 { 461 struct rsnd_mod *mod = rsnd_mod_get(ssi); 462 u32 status = rsnd_ssi_status_get(mod); 463 464 /* under/over flow error */ 465 if (status & (UIRQ | OIRQ)) 466 ssi->err++; 467 468 return status; 469 } 470 471 static int __rsnd_ssi_start(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 u32 cr; 477 478 cr = ssi->cr_own | 479 ssi->cr_clk | 480 ssi->cr_mode; 481 482 /* 483 * EN will be set via SSIU :: SSI_CONTROL 484 * if Multi channel mode 485 */ 486 if (!rsnd_ssi_multi_slaves(io)) 487 cr |= EN; 488 489 rsnd_mod_write(mod, SSICR, cr); 490 rsnd_mod_write(mod, SSIWSR, ssi->wsr); 491 492 return 0; 493 } 494 495 static int rsnd_ssi_start(struct rsnd_mod *mod, 496 struct rsnd_dai_stream *io, 497 struct rsnd_priv *priv) 498 { 499 /* 500 * no limit to start 501 * see also 502 * rsnd_ssi_stop 503 * rsnd_ssi_interrupt 504 */ 505 return __rsnd_ssi_start(mod, io, priv); 506 } 507 508 static int __rsnd_ssi_stop(struct rsnd_mod *mod, 509 struct rsnd_dai_stream *io, 510 struct rsnd_priv *priv) 511 { 512 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 513 u32 cr; 514 515 /* 516 * disable all IRQ, 517 * and, wait all data was sent 518 */ 519 cr = ssi->cr_own | 520 ssi->cr_clk; 521 522 rsnd_mod_write(mod, SSICR, cr | EN); 523 rsnd_ssi_status_check(mod, DIRQ); 524 525 /* 526 * disable SSI, 527 * and, wait idle state 528 */ 529 rsnd_mod_write(mod, SSICR, cr); /* disabled all */ 530 rsnd_ssi_status_check(mod, IIRQ); 531 532 return 0; 533 } 534 535 static int rsnd_ssi_stop(struct rsnd_mod *mod, 536 struct rsnd_dai_stream *io, 537 struct rsnd_priv *priv) 538 { 539 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 540 541 /* 542 * don't stop if not last user 543 * see also 544 * rsnd_ssi_start 545 * rsnd_ssi_interrupt 546 */ 547 if (ssi->usrcnt > 1) 548 return 0; 549 550 return __rsnd_ssi_stop(mod, io, priv); 551 } 552 553 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, 554 struct rsnd_dai_stream *io) 555 { 556 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 557 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 558 struct device *dev = rsnd_priv_to_dev(priv); 559 int is_dma = rsnd_ssi_is_dma_mode(mod); 560 u32 status; 561 bool elapsed = false; 562 563 spin_lock(&priv->lock); 564 565 /* ignore all cases if not working */ 566 if (!rsnd_io_is_working(io)) 567 goto rsnd_ssi_interrupt_out; 568 569 status = rsnd_ssi_record_error(ssi); 570 571 /* PIO only */ 572 if (!is_dma && (status & DIRQ)) { 573 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 574 u32 *buf = (u32 *)(runtime->dma_area + 575 rsnd_dai_pointer_offset(io, 0)); 576 577 /* 578 * 8/16/32 data can be assesse to TDR/RDR register 579 * directly as 32bit data 580 * see rsnd_ssi_init() 581 */ 582 if (rsnd_io_is_play(io)) 583 rsnd_mod_write(mod, SSITDR, *buf); 584 else 585 *buf = rsnd_mod_read(mod, SSIRDR); 586 587 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf)); 588 } 589 590 /* DMA only */ 591 if (is_dma && (status & (UIRQ | OIRQ))) { 592 /* 593 * restart SSI 594 */ 595 dev_dbg(dev, "%s[%d] restart\n", 596 rsnd_mod_name(mod), rsnd_mod_id(mod)); 597 598 __rsnd_ssi_stop(mod, io, priv); 599 __rsnd_ssi_start(mod, io, priv); 600 } 601 602 if (ssi->err > 1024) { 603 rsnd_ssi_irq_disable(mod); 604 605 dev_warn(dev, "no more %s[%d] restart\n", 606 rsnd_mod_name(mod), rsnd_mod_id(mod)); 607 } 608 609 rsnd_ssi_status_clear(mod); 610 rsnd_ssi_interrupt_out: 611 spin_unlock(&priv->lock); 612 613 if (elapsed) 614 rsnd_dai_period_elapsed(io); 615 } 616 617 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) 618 { 619 struct rsnd_mod *mod = data; 620 621 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); 622 623 return IRQ_HANDLED; 624 } 625 626 /* 627 * SSI PIO 628 */ 629 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod, 630 struct rsnd_dai_stream *io, 631 struct rsnd_priv *priv) 632 { 633 if (!__rsnd_ssi_is_pin_sharing(mod)) 634 return; 635 636 switch (rsnd_mod_id(mod)) { 637 case 1: 638 case 2: 639 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP); 640 break; 641 case 4: 642 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP); 643 break; 644 case 8: 645 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP); 646 break; 647 } 648 } 649 650 static int rsnd_ssi_common_probe(struct rsnd_mod *mod, 651 struct rsnd_dai_stream *io, 652 struct rsnd_priv *priv) 653 { 654 struct device *dev = rsnd_priv_to_dev(priv); 655 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 656 int ret; 657 658 /* 659 * SSIP/SSIU/IRQ are not needed on 660 * SSI Multi slaves 661 */ 662 if (rsnd_ssi_is_multi_slave(mod, io)) 663 return 0; 664 665 rsnd_ssi_parent_attach(mod, io, priv); 666 667 ret = rsnd_ssiu_attach(io, mod); 668 if (ret < 0) 669 return ret; 670 671 ret = devm_request_irq(dev, ssi->irq, 672 rsnd_ssi_interrupt, 673 IRQF_SHARED, 674 dev_name(dev), mod); 675 676 return ret; 677 } 678 679 static struct rsnd_mod_ops rsnd_ssi_pio_ops = { 680 .name = SSI_NAME, 681 .probe = rsnd_ssi_common_probe, 682 .init = rsnd_ssi_init, 683 .quit = rsnd_ssi_quit, 684 .start = rsnd_ssi_start, 685 .stop = rsnd_ssi_stop, 686 .hw_params = rsnd_ssi_hw_params, 687 }; 688 689 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, 690 struct rsnd_dai_stream *io, 691 struct rsnd_priv *priv) 692 { 693 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 694 int dma_id = 0; /* not needed */ 695 int ret; 696 697 /* 698 * SSIP/SSIU/IRQ/DMA are not needed on 699 * SSI Multi slaves 700 */ 701 if (rsnd_ssi_is_multi_slave(mod, io)) 702 return 0; 703 704 ret = rsnd_ssi_common_probe(mod, io, priv); 705 if (ret) 706 return ret; 707 708 ssi->dma = rsnd_dma_attach(io, mod, dma_id); 709 if (IS_ERR(ssi->dma)) 710 return PTR_ERR(ssi->dma); 711 712 return ret; 713 } 714 715 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod, 716 struct rsnd_dai_stream *io, 717 struct rsnd_priv *priv) 718 { 719 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 720 struct device *dev = rsnd_priv_to_dev(priv); 721 int irq = ssi->irq; 722 723 /* PIO will request IRQ again */ 724 devm_free_irq(dev, irq, mod); 725 726 return 0; 727 } 728 729 static int rsnd_ssi_fallback(struct rsnd_mod *mod, 730 struct rsnd_dai_stream *io, 731 struct rsnd_priv *priv) 732 { 733 struct device *dev = rsnd_priv_to_dev(priv); 734 735 /* 736 * fallback to PIO 737 * 738 * SSI .probe might be called again. 739 * see 740 * rsnd_rdai_continuance_probe() 741 */ 742 mod->ops = &rsnd_ssi_pio_ops; 743 744 dev_info(dev, "%s[%d] fallback to PIO mode\n", 745 rsnd_mod_name(mod), rsnd_mod_id(mod)); 746 747 return 0; 748 } 749 750 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, 751 struct rsnd_mod *mod) 752 { 753 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 754 int is_play = rsnd_io_is_play(io); 755 char *name; 756 757 if (rsnd_ssi_use_busif(io)) 758 name = is_play ? "rxu" : "txu"; 759 else 760 name = is_play ? "rx" : "tx"; 761 762 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), 763 mod, name); 764 } 765 766 static struct rsnd_mod_ops rsnd_ssi_dma_ops = { 767 .name = SSI_NAME, 768 .dma_req = rsnd_ssi_dma_req, 769 .probe = rsnd_ssi_dma_probe, 770 .remove = rsnd_ssi_dma_remove, 771 .init = rsnd_ssi_init, 772 .quit = rsnd_ssi_quit, 773 .start = rsnd_ssi_start, 774 .stop = rsnd_ssi_stop, 775 .fallback = rsnd_ssi_fallback, 776 .hw_params = rsnd_ssi_hw_params, 777 }; 778 779 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) 780 { 781 return mod->ops == &rsnd_ssi_dma_ops; 782 } 783 784 785 /* 786 * Non SSI 787 */ 788 static struct rsnd_mod_ops rsnd_ssi_non_ops = { 789 .name = SSI_NAME, 790 }; 791 792 /* 793 * ssi mod function 794 */ 795 static void rsnd_ssi_connect(struct rsnd_mod *mod, 796 struct rsnd_dai_stream *io) 797 { 798 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 799 enum rsnd_mod_type types[] = { 800 RSND_MOD_SSI, 801 RSND_MOD_SSIM1, 802 RSND_MOD_SSIM2, 803 RSND_MOD_SSIM3, 804 }; 805 enum rsnd_mod_type type; 806 int i; 807 808 /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */ 809 for (i = 0; i < ARRAY_SIZE(types); i++) { 810 type = types[i]; 811 if (!rsnd_io_to_mod(io, type)) { 812 rsnd_dai_connect(mod, io, type); 813 rsnd_set_slot(rdai, 2 * (i + 1), (i + 1)); 814 return; 815 } 816 } 817 } 818 819 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai, 820 struct device_node *playback, 821 struct device_node *capture) 822 { 823 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 824 struct device_node *node; 825 struct device_node *np; 826 struct rsnd_mod *mod; 827 int i; 828 829 node = rsnd_ssi_of_node(priv); 830 if (!node) 831 return; 832 833 i = 0; 834 for_each_child_of_node(node, np) { 835 mod = rsnd_ssi_mod_get(priv, i); 836 if (np == playback) 837 rsnd_ssi_connect(mod, &rdai->playback); 838 if (np == capture) 839 rsnd_ssi_connect(mod, &rdai->capture); 840 i++; 841 } 842 843 of_node_put(node); 844 } 845 846 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) 847 { 848 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) 849 id = 0; 850 851 return rsnd_mod_get(rsnd_ssi_get(priv, id)); 852 } 853 854 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) 855 { 856 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 857 858 return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE); 859 } 860 861 int rsnd_ssi_probe(struct rsnd_priv *priv) 862 { 863 struct device_node *node; 864 struct device_node *np; 865 struct device *dev = rsnd_priv_to_dev(priv); 866 struct rsnd_mod_ops *ops; 867 struct clk *clk; 868 struct rsnd_ssi *ssi; 869 char name[RSND_SSI_NAME_SIZE]; 870 int i, nr, ret; 871 872 node = rsnd_ssi_of_node(priv); 873 if (!node) 874 return -EINVAL; 875 876 nr = of_get_child_count(node); 877 if (!nr) { 878 ret = -EINVAL; 879 goto rsnd_ssi_probe_done; 880 } 881 882 ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); 883 if (!ssi) { 884 ret = -ENOMEM; 885 goto rsnd_ssi_probe_done; 886 } 887 888 priv->ssi = ssi; 889 priv->ssi_nr = nr; 890 891 i = 0; 892 for_each_child_of_node(node, np) { 893 ssi = rsnd_ssi_get(priv, i); 894 895 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", 896 SSI_NAME, i); 897 898 clk = devm_clk_get(dev, name); 899 if (IS_ERR(clk)) { 900 ret = PTR_ERR(clk); 901 goto rsnd_ssi_probe_done; 902 } 903 904 if (of_get_property(np, "shared-pin", NULL)) 905 ssi->flags |= RSND_SSI_CLK_PIN_SHARE; 906 907 if (of_get_property(np, "no-busif", NULL)) 908 ssi->flags |= RSND_SSI_NO_BUSIF; 909 910 ssi->irq = irq_of_parse_and_map(np, 0); 911 if (!ssi->irq) { 912 ret = -EINVAL; 913 goto rsnd_ssi_probe_done; 914 } 915 916 ops = &rsnd_ssi_non_ops; 917 if (of_get_property(np, "pio-transfer", NULL)) 918 ops = &rsnd_ssi_pio_ops; 919 else 920 ops = &rsnd_ssi_dma_ops; 921 922 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 923 RSND_MOD_SSI, i); 924 if (ret) 925 goto rsnd_ssi_probe_done; 926 927 i++; 928 } 929 930 ret = 0; 931 932 rsnd_ssi_probe_done: 933 of_node_put(node); 934 935 return ret; 936 } 937 938 void rsnd_ssi_remove(struct rsnd_priv *priv) 939 { 940 struct rsnd_ssi *ssi; 941 int i; 942 943 for_each_rsnd_ssi(ssi, priv, i) { 944 rsnd_mod_quit(rsnd_mod_get(ssi)); 945 } 946 } 947