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 28 #define DWL_8 (0 << 19) /* Data Word Length */ 29 #define DWL_16 (1 << 19) /* Data Word Length */ 30 #define DWL_18 (2 << 19) /* Data Word Length */ 31 #define DWL_20 (3 << 19) /* Data Word Length */ 32 #define DWL_22 (4 << 19) /* Data Word Length */ 33 #define DWL_24 (5 << 19) /* Data Word Length */ 34 #define DWL_32 (6 << 19) /* Data Word Length */ 35 36 #define SWL_32 (3 << 16) /* R/W System Word Length */ 37 #define SCKD (1 << 15) /* Serial Bit Clock Direction */ 38 #define SWSD (1 << 14) /* Serial WS Direction */ 39 #define SCKP (1 << 13) /* Serial Bit Clock Polarity */ 40 #define SWSP (1 << 12) /* Serial WS Polarity */ 41 #define SDTA (1 << 10) /* Serial Data Alignment */ 42 #define DEL (1 << 8) /* Serial Data Delay */ 43 #define CKDV(v) (v << 4) /* Serial Clock Division Ratio */ 44 #define TRMD (1 << 1) /* Transmit/Receive Mode Select */ 45 #define EN (1 << 0) /* SSI Module Enable */ 46 47 /* 48 * SSISR 49 */ 50 #define UIRQ (1 << 27) /* Underflow Error Interrupt Status */ 51 #define OIRQ (1 << 26) /* Overflow Error Interrupt Status */ 52 #define IIRQ (1 << 25) /* Idle Mode Interrupt Status */ 53 #define DIRQ (1 << 24) /* Data Interrupt Status Flag */ 54 55 /* 56 * SSIWSR 57 */ 58 #define CONT (1 << 8) /* WS Continue Function */ 59 60 #define SSI_NAME "ssi" 61 62 struct rsnd_ssi { 63 struct rsnd_ssi_platform_info *info; /* rcar_snd.h */ 64 struct rsnd_ssi *parent; 65 struct rsnd_mod mod; 66 67 u32 cr_own; 68 u32 cr_clk; 69 int chan; 70 int err; 71 unsigned int usrcnt; 72 }; 73 74 #define for_each_rsnd_ssi(pos, priv, i) \ 75 for (i = 0; \ 76 (i < rsnd_ssi_nr(priv)) && \ 77 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i)); \ 78 i++) 79 80 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr) 81 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod) 82 #define rsnd_ssi_pio_available(ssi) ((ssi)->info->irq > 0) 83 #define rsnd_ssi_parent(ssi) ((ssi)->parent) 84 #define rsnd_ssi_mode_flags(p) ((p)->info->flags) 85 #define rsnd_ssi_dai_id(ssi) ((ssi)->info->dai_id) 86 #define rsnd_ssi_of_node(priv) \ 87 of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,ssi") 88 89 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io) 90 { 91 struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io); 92 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 93 int use_busif = 0; 94 95 if (!rsnd_ssi_is_dma_mode(mod)) 96 return 0; 97 98 if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF)) 99 use_busif = 1; 100 if (rsnd_io_to_mod_src(io)) 101 use_busif = 1; 102 103 return use_busif; 104 } 105 106 static void rsnd_ssi_status_check(struct rsnd_mod *mod, 107 u32 bit) 108 { 109 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 110 struct device *dev = rsnd_priv_to_dev(priv); 111 u32 status; 112 int i; 113 114 for (i = 0; i < 1024; i++) { 115 status = rsnd_mod_read(mod, SSISR); 116 if (status & bit) 117 return; 118 119 udelay(50); 120 } 121 122 dev_warn(dev, "status check failed\n"); 123 } 124 125 static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi, 126 struct rsnd_dai_stream *io) 127 { 128 struct rsnd_priv *priv = rsnd_io_to_priv(io); 129 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 130 struct device *dev = rsnd_priv_to_dev(priv); 131 struct rsnd_mod *mod = rsnd_mod_get(ssi); 132 int j, ret; 133 int ssi_clk_mul_table[] = { 134 1, 2, 4, 8, 16, 6, 12, 135 }; 136 unsigned int main_rate; 137 unsigned int rate = rsnd_src_get_ssi_rate(priv, io, runtime); 138 139 /* 140 * Find best clock, and try to start ADG 141 */ 142 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) { 143 144 /* 145 * this driver is assuming that 146 * system word is 64fs (= 2 x 32bit) 147 * see rsnd_ssi_init() 148 */ 149 main_rate = rate * 32 * 2 * ssi_clk_mul_table[j]; 150 151 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate); 152 if (0 == ret) { 153 ssi->cr_clk = FORCE | SWL_32 | 154 SCKD | SWSD | CKDV(j); 155 156 dev_dbg(dev, "%s[%d] outputs %u Hz\n", 157 rsnd_mod_name(mod), 158 rsnd_mod_id(mod), rate); 159 160 return 0; 161 } 162 } 163 164 dev_err(dev, "unsupported clock rate\n"); 165 return -EIO; 166 } 167 168 static void rsnd_ssi_master_clk_stop(struct rsnd_ssi *ssi) 169 { 170 struct rsnd_mod *mod = rsnd_mod_get(ssi); 171 172 ssi->cr_clk = 0; 173 rsnd_adg_ssi_clk_stop(mod); 174 } 175 176 static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi, 177 struct rsnd_dai_stream *io) 178 { 179 struct rsnd_priv *priv = rsnd_io_to_priv(io); 180 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 181 struct device *dev = rsnd_priv_to_dev(priv); 182 struct rsnd_mod *mod = rsnd_mod_get(ssi); 183 u32 cr_mode; 184 u32 cr; 185 186 if (0 == ssi->usrcnt) { 187 rsnd_mod_power_on(mod); 188 189 if (rsnd_rdai_is_clk_master(rdai)) { 190 struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi); 191 192 if (ssi_parent) 193 rsnd_ssi_hw_start(ssi_parent, io); 194 else 195 rsnd_ssi_master_clk_start(ssi, io); 196 } 197 } 198 199 if (rsnd_ssi_is_dma_mode(mod)) { 200 cr_mode = UIEN | OIEN | /* over/under run */ 201 DMEN; /* DMA : enable DMA */ 202 } else { 203 cr_mode = DIEN; /* PIO : enable Data interrupt */ 204 } 205 206 cr = ssi->cr_own | 207 ssi->cr_clk | 208 cr_mode | 209 EN; 210 211 rsnd_mod_write(mod, SSICR, cr); 212 213 /* enable WS continue */ 214 if (rsnd_rdai_is_clk_master(rdai)) 215 rsnd_mod_write(mod, SSIWSR, CONT); 216 217 /* clear error status */ 218 rsnd_mod_write(mod, SSISR, 0); 219 220 ssi->usrcnt++; 221 222 dev_dbg(dev, "%s[%d] hw started\n", 223 rsnd_mod_name(mod), rsnd_mod_id(mod)); 224 } 225 226 static void rsnd_ssi_hw_stop(struct rsnd_dai_stream *io, struct rsnd_ssi *ssi) 227 { 228 struct rsnd_mod *mod = rsnd_mod_get(ssi); 229 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 230 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 231 struct device *dev = rsnd_priv_to_dev(priv); 232 u32 cr; 233 234 if (0 == ssi->usrcnt) { 235 dev_err(dev, "%s called without starting\n", __func__); 236 return; 237 } 238 239 ssi->usrcnt--; 240 241 if (0 == ssi->usrcnt) { 242 /* 243 * disable all IRQ, 244 * and, wait all data was sent 245 */ 246 cr = ssi->cr_own | 247 ssi->cr_clk; 248 249 rsnd_mod_write(mod, SSICR, cr | EN); 250 rsnd_ssi_status_check(mod, DIRQ); 251 252 /* 253 * disable SSI, 254 * and, wait idle state 255 */ 256 rsnd_mod_write(mod, SSICR, cr); /* disabled all */ 257 rsnd_ssi_status_check(mod, IIRQ); 258 259 if (rsnd_rdai_is_clk_master(rdai)) { 260 struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi); 261 262 if (ssi_parent) 263 rsnd_ssi_hw_stop(io, ssi_parent); 264 else 265 rsnd_ssi_master_clk_stop(ssi); 266 } 267 268 rsnd_mod_power_off(mod); 269 270 ssi->chan = 0; 271 } 272 273 dev_dbg(dev, "%s[%d] hw stopped\n", 274 rsnd_mod_name(mod), rsnd_mod_id(mod)); 275 } 276 277 /* 278 * SSI mod common functions 279 */ 280 static int rsnd_ssi_init(struct rsnd_mod *mod, 281 struct rsnd_dai_stream *io, 282 struct rsnd_priv *priv) 283 { 284 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 285 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 286 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 287 u32 cr; 288 289 cr = FORCE; 290 291 /* 292 * always use 32bit system word for easy clock calculation. 293 * see also rsnd_ssi_master_clk_enable() 294 */ 295 cr |= SWL_32; 296 297 /* 298 * init clock settings for SSICR 299 */ 300 switch (runtime->sample_bits) { 301 case 16: 302 cr |= DWL_16; 303 break; 304 case 32: 305 cr |= DWL_24; 306 break; 307 default: 308 return -EIO; 309 } 310 311 if (rdai->bit_clk_inv) 312 cr |= SCKP; 313 if (rdai->frm_clk_inv) 314 cr |= SWSP; 315 if (rdai->data_alignment) 316 cr |= SDTA; 317 if (rdai->sys_delay) 318 cr |= DEL; 319 if (rsnd_io_is_play(io)) 320 cr |= TRMD; 321 322 /* 323 * set ssi parameter 324 */ 325 ssi->cr_own = cr; 326 ssi->err = -1; /* ignore 1st error */ 327 328 return 0; 329 } 330 331 static int rsnd_ssi_quit(struct rsnd_mod *mod, 332 struct rsnd_dai_stream *io, 333 struct rsnd_priv *priv) 334 { 335 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 336 struct device *dev = rsnd_priv_to_dev(priv); 337 338 if (ssi->err > 0) 339 dev_warn(dev, "%s[%d] under/over flow err = %d\n", 340 rsnd_mod_name(mod), rsnd_mod_id(mod), ssi->err); 341 342 ssi->cr_own = 0; 343 ssi->err = 0; 344 345 return 0; 346 } 347 348 static int rsnd_ssi_hw_params(struct rsnd_mod *mod, 349 struct rsnd_dai_stream *io, 350 struct snd_pcm_substream *substream, 351 struct snd_pcm_hw_params *params) 352 { 353 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 354 struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi); 355 int chan = params_channels(params); 356 357 /* 358 * Already working. 359 * It will happen if SSI has parent/child connection. 360 */ 361 if (ssi->usrcnt) { 362 /* 363 * it is error if child <-> parent SSI uses 364 * different channels. 365 */ 366 if (ssi->chan != chan) 367 return -EIO; 368 } 369 370 /* It will be removed on rsnd_ssi_hw_stop */ 371 ssi->chan = chan; 372 if (ssi_parent) 373 return rsnd_ssi_hw_params(rsnd_mod_get(ssi_parent), io, 374 substream, params); 375 376 return 0; 377 } 378 379 static void rsnd_ssi_record_error(struct rsnd_ssi *ssi, u32 status) 380 { 381 struct rsnd_mod *mod = rsnd_mod_get(ssi); 382 383 /* under/over flow error */ 384 if (status & (UIRQ | OIRQ)) { 385 ssi->err++; 386 387 /* clear error status */ 388 rsnd_mod_write(mod, SSISR, 0); 389 } 390 } 391 392 static int rsnd_ssi_start(struct rsnd_mod *mod, 393 struct rsnd_dai_stream *io, 394 struct rsnd_priv *priv) 395 { 396 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 397 398 rsnd_src_ssiu_start(mod, io, rsnd_ssi_use_busif(io)); 399 400 rsnd_ssi_hw_start(ssi, io); 401 402 rsnd_src_ssi_irq_enable(mod); 403 404 return 0; 405 } 406 407 static int rsnd_ssi_stop(struct rsnd_mod *mod, 408 struct rsnd_dai_stream *io, 409 struct rsnd_priv *priv) 410 { 411 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 412 413 rsnd_src_ssi_irq_disable(mod); 414 415 rsnd_ssi_record_error(ssi, rsnd_mod_read(mod, SSISR)); 416 417 rsnd_ssi_hw_stop(io, ssi); 418 419 rsnd_src_ssiu_stop(mod, io); 420 421 return 0; 422 } 423 424 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod, 425 struct rsnd_dai_stream *io) 426 { 427 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 428 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 429 int is_dma = rsnd_ssi_is_dma_mode(mod); 430 u32 status; 431 bool elapsed = false; 432 433 spin_lock(&priv->lock); 434 435 /* ignore all cases if not working */ 436 if (!rsnd_io_is_working(io)) 437 goto rsnd_ssi_interrupt_out; 438 439 status = rsnd_mod_read(mod, SSISR); 440 441 /* PIO only */ 442 if (!is_dma && (status & DIRQ)) { 443 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 444 u32 *buf = (u32 *)(runtime->dma_area + 445 rsnd_dai_pointer_offset(io, 0)); 446 447 /* 448 * 8/16/32 data can be assesse to TDR/RDR register 449 * directly as 32bit data 450 * see rsnd_ssi_init() 451 */ 452 if (rsnd_io_is_play(io)) 453 rsnd_mod_write(mod, SSITDR, *buf); 454 else 455 *buf = rsnd_mod_read(mod, SSIRDR); 456 457 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf)); 458 } 459 460 /* DMA only */ 461 if (is_dma && (status & (UIRQ | OIRQ))) { 462 struct device *dev = rsnd_priv_to_dev(priv); 463 464 /* 465 * restart SSI 466 */ 467 dev_dbg(dev, "%s[%d] restart\n", 468 rsnd_mod_name(mod), rsnd_mod_id(mod)); 469 470 rsnd_ssi_stop(mod, io, priv); 471 if (ssi->err < 1024) 472 rsnd_ssi_start(mod, io, priv); 473 else 474 dev_warn(dev, "no more SSI restart\n"); 475 } 476 477 rsnd_ssi_record_error(ssi, status); 478 479 rsnd_ssi_interrupt_out: 480 spin_unlock(&priv->lock); 481 482 if (elapsed) 483 rsnd_dai_period_elapsed(io); 484 } 485 486 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data) 487 { 488 struct rsnd_mod *mod = data; 489 490 rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt); 491 492 return IRQ_HANDLED; 493 } 494 495 /* 496 * SSI PIO 497 */ 498 static int rsnd_ssi_pio_probe(struct rsnd_mod *mod, 499 struct rsnd_dai_stream *io, 500 struct rsnd_priv *priv) 501 { 502 struct device *dev = rsnd_priv_to_dev(priv); 503 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 504 int ret; 505 506 ret = devm_request_irq(dev, ssi->info->irq, 507 rsnd_ssi_interrupt, 508 IRQF_SHARED, 509 dev_name(dev), mod); 510 511 return ret; 512 } 513 514 static struct rsnd_mod_ops rsnd_ssi_pio_ops = { 515 .name = SSI_NAME, 516 .probe = rsnd_ssi_pio_probe, 517 .init = rsnd_ssi_init, 518 .quit = rsnd_ssi_quit, 519 .start = rsnd_ssi_start, 520 .stop = rsnd_ssi_stop, 521 .hw_params = rsnd_ssi_hw_params, 522 }; 523 524 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod, 525 struct rsnd_dai_stream *io, 526 struct rsnd_priv *priv) 527 { 528 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 529 struct device *dev = rsnd_priv_to_dev(priv); 530 int dma_id = ssi->info->dma_id; 531 int ret; 532 533 ret = devm_request_irq(dev, ssi->info->irq, 534 rsnd_ssi_interrupt, 535 IRQF_SHARED, 536 dev_name(dev), mod); 537 if (ret) 538 return ret; 539 540 ret = rsnd_dma_init( 541 io, rsnd_mod_to_dma(mod), 542 dma_id); 543 544 return ret; 545 } 546 547 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod, 548 struct rsnd_dai_stream *io, 549 struct rsnd_priv *priv) 550 { 551 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 552 struct device *dev = rsnd_priv_to_dev(priv); 553 int irq = ssi->info->irq; 554 555 rsnd_dma_quit(io, rsnd_mod_to_dma(mod)); 556 557 /* PIO will request IRQ again */ 558 devm_free_irq(dev, irq, mod); 559 560 return 0; 561 } 562 563 static int rsnd_ssi_fallback(struct rsnd_mod *mod, 564 struct rsnd_dai_stream *io, 565 struct rsnd_priv *priv) 566 { 567 struct device *dev = rsnd_priv_to_dev(priv); 568 569 /* 570 * fallback to PIO 571 * 572 * SSI .probe might be called again. 573 * see 574 * rsnd_rdai_continuance_probe() 575 */ 576 mod->ops = &rsnd_ssi_pio_ops; 577 578 dev_info(dev, "%s[%d] fallback to PIO mode\n", 579 rsnd_mod_name(mod), rsnd_mod_id(mod)); 580 581 return 0; 582 } 583 584 static int rsnd_ssi_dma_start(struct rsnd_mod *mod, 585 struct rsnd_dai_stream *io, 586 struct rsnd_priv *priv) 587 { 588 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 589 590 rsnd_dma_start(io, dma); 591 592 rsnd_ssi_start(mod, io, priv); 593 594 return 0; 595 } 596 597 static int rsnd_ssi_dma_stop(struct rsnd_mod *mod, 598 struct rsnd_dai_stream *io, 599 struct rsnd_priv *priv) 600 { 601 struct rsnd_dma *dma = rsnd_mod_to_dma(mod); 602 603 rsnd_ssi_stop(mod, io, priv); 604 605 rsnd_dma_stop(io, dma); 606 607 return 0; 608 } 609 610 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io, 611 struct rsnd_mod *mod) 612 { 613 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 614 int is_play = rsnd_io_is_play(io); 615 char *name; 616 617 if (rsnd_ssi_use_busif(io)) 618 name = is_play ? "rxu" : "txu"; 619 else 620 name = is_play ? "rx" : "tx"; 621 622 return rsnd_dma_request_channel(rsnd_ssi_of_node(priv), 623 mod, name); 624 } 625 626 static struct rsnd_mod_ops rsnd_ssi_dma_ops = { 627 .name = SSI_NAME, 628 .dma_req = rsnd_ssi_dma_req, 629 .probe = rsnd_ssi_dma_probe, 630 .remove = rsnd_ssi_dma_remove, 631 .init = rsnd_ssi_init, 632 .quit = rsnd_ssi_quit, 633 .start = rsnd_ssi_dma_start, 634 .stop = rsnd_ssi_dma_stop, 635 .fallback = rsnd_ssi_fallback, 636 .hw_params = rsnd_ssi_hw_params, 637 }; 638 639 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod) 640 { 641 return mod->ops == &rsnd_ssi_dma_ops; 642 } 643 644 645 /* 646 * Non SSI 647 */ 648 static struct rsnd_mod_ops rsnd_ssi_non_ops = { 649 .name = SSI_NAME, 650 }; 651 652 /* 653 * ssi mod function 654 */ 655 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id) 656 { 657 if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv))) 658 id = 0; 659 660 return rsnd_mod_get((struct rsnd_ssi *)(priv->ssi) + id); 661 } 662 663 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod) 664 { 665 struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod); 666 667 return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE); 668 } 669 670 static void rsnd_ssi_parent_setup(struct rsnd_priv *priv, struct rsnd_ssi *ssi) 671 { 672 struct rsnd_mod *mod = rsnd_mod_get(ssi); 673 674 if (!__rsnd_ssi_is_pin_sharing(mod)) 675 return; 676 677 switch (rsnd_mod_id(mod)) { 678 case 1: 679 case 2: 680 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 0)); 681 break; 682 case 4: 683 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 3)); 684 break; 685 case 8: 686 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 7)); 687 break; 688 } 689 } 690 691 692 static void rsnd_of_parse_ssi(struct platform_device *pdev, 693 const struct rsnd_of_data *of_data, 694 struct rsnd_priv *priv) 695 { 696 struct device_node *node; 697 struct device_node *np; 698 struct rsnd_ssi_platform_info *ssi_info; 699 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 700 struct device *dev = &pdev->dev; 701 int nr, i; 702 703 node = rsnd_ssi_of_node(priv); 704 if (!node) 705 return; 706 707 nr = of_get_child_count(node); 708 if (!nr) 709 goto rsnd_of_parse_ssi_end; 710 711 ssi_info = devm_kzalloc(dev, 712 sizeof(struct rsnd_ssi_platform_info) * nr, 713 GFP_KERNEL); 714 if (!ssi_info) { 715 dev_err(dev, "ssi info allocation error\n"); 716 goto rsnd_of_parse_ssi_end; 717 } 718 719 info->ssi_info = ssi_info; 720 info->ssi_info_nr = nr; 721 722 i = -1; 723 for_each_child_of_node(node, np) { 724 i++; 725 726 ssi_info = info->ssi_info + i; 727 728 /* 729 * pin settings 730 */ 731 if (of_get_property(np, "shared-pin", NULL)) 732 ssi_info->flags |= RSND_SSI_CLK_PIN_SHARE; 733 734 /* 735 * irq 736 */ 737 ssi_info->irq = irq_of_parse_and_map(np, 0); 738 739 /* 740 * DMA 741 */ 742 ssi_info->dma_id = of_get_property(np, "pio-transfer", NULL) ? 743 0 : 1; 744 745 if (of_get_property(np, "no-busif", NULL)) 746 ssi_info->flags |= RSND_SSI_NO_BUSIF; 747 } 748 749 rsnd_of_parse_ssi_end: 750 of_node_put(node); 751 } 752 753 int rsnd_ssi_probe(struct platform_device *pdev, 754 const struct rsnd_of_data *of_data, 755 struct rsnd_priv *priv) 756 { 757 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 758 struct rsnd_ssi_platform_info *pinfo; 759 struct device *dev = rsnd_priv_to_dev(priv); 760 struct rsnd_mod_ops *ops; 761 struct clk *clk; 762 struct rsnd_ssi *ssi; 763 char name[RSND_SSI_NAME_SIZE]; 764 int i, nr, ret; 765 766 rsnd_of_parse_ssi(pdev, of_data, priv); 767 768 /* 769 * init SSI 770 */ 771 nr = info->ssi_info_nr; 772 ssi = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL); 773 if (!ssi) 774 return -ENOMEM; 775 776 priv->ssi = ssi; 777 priv->ssi_nr = nr; 778 779 for_each_rsnd_ssi(ssi, priv, i) { 780 pinfo = &info->ssi_info[i]; 781 782 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d", 783 SSI_NAME, i); 784 785 clk = devm_clk_get(dev, name); 786 if (IS_ERR(clk)) 787 return PTR_ERR(clk); 788 789 ssi->info = pinfo; 790 791 ops = &rsnd_ssi_non_ops; 792 if (pinfo->dma_id > 0) 793 ops = &rsnd_ssi_dma_ops; 794 else if (rsnd_ssi_pio_available(ssi)) 795 ops = &rsnd_ssi_pio_ops; 796 797 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk, 798 RSND_MOD_SSI, i); 799 if (ret) 800 return ret; 801 802 rsnd_ssi_parent_setup(priv, ssi); 803 } 804 805 return 0; 806 } 807 808 void rsnd_ssi_remove(struct platform_device *pdev, 809 struct rsnd_priv *priv) 810 { 811 struct rsnd_ssi *ssi; 812 int i; 813 814 for_each_rsnd_ssi(ssi, priv, i) { 815 rsnd_mod_quit(rsnd_mod_get(ssi)); 816 } 817 } 818