1 /* 2 * Renesas R-Car SRC support 3 * 4 * Copyright (C) 2013 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 12 /* 13 * you can enable below define if you don't need 14 * SSI interrupt status debug message when debugging 15 * see rsnd_dbg_irq_status() 16 * 17 * #define RSND_DEBUG_NO_IRQ_STATUS 1 18 */ 19 20 #include "rsnd.h" 21 22 #define SRC_NAME "src" 23 24 /* SCU_SYSTEM_STATUS0/1 */ 25 #define OUF_SRC(id) ((1 << (id + 16)) | (1 << id)) 26 27 struct rsnd_src { 28 struct rsnd_mod mod; 29 struct rsnd_mod *dma; 30 struct rsnd_kctrl_cfg_s sen; /* sync convert enable */ 31 struct rsnd_kctrl_cfg_s sync; /* sync convert */ 32 u32 convert_rate; /* sampling rate convert */ 33 int irq; 34 }; 35 36 #define RSND_SRC_NAME_SIZE 16 37 38 #define rsnd_src_get(priv, id) ((struct rsnd_src *)(priv->src) + id) 39 #define rsnd_src_nr(priv) ((priv)->src_nr) 40 #define rsnd_src_sync_is_enabled(mod) (rsnd_mod_to_src(mod)->sen.val) 41 42 #define rsnd_mod_to_src(_mod) \ 43 container_of((_mod), struct rsnd_src, mod) 44 45 #define for_each_rsnd_src(pos, priv, i) \ 46 for ((i) = 0; \ 47 ((i) < rsnd_src_nr(priv)) && \ 48 ((pos) = (struct rsnd_src *)(priv)->src + i); \ 49 i++) 50 51 52 /* 53 * image of SRC (Sampling Rate Converter) 54 * 55 * 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+ 56 * 48kHz <-> | SRC | <------> | SSI | <-----> | codec | 57 * 44.1kHz <-> +-----+ +-----+ +-------+ 58 * ... 59 * 60 */ 61 62 static void rsnd_src_activation(struct rsnd_mod *mod) 63 { 64 rsnd_mod_write(mod, SRC_SWRSR, 0); 65 rsnd_mod_write(mod, SRC_SWRSR, 1); 66 } 67 68 static void rsnd_src_halt(struct rsnd_mod *mod) 69 { 70 rsnd_mod_write(mod, SRC_SRCIR, 1); 71 rsnd_mod_write(mod, SRC_SWRSR, 0); 72 } 73 74 static struct dma_chan *rsnd_src_dma_req(struct rsnd_dai_stream *io, 75 struct rsnd_mod *mod) 76 { 77 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 78 int is_play = rsnd_io_is_play(io); 79 80 return rsnd_dma_request_channel(rsnd_src_of_node(priv), 81 mod, 82 is_play ? "rx" : "tx"); 83 } 84 85 static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io, 86 struct rsnd_mod *mod) 87 { 88 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 89 struct rsnd_src *src = rsnd_mod_to_src(mod); 90 u32 convert_rate; 91 92 if (!runtime) 93 return 0; 94 95 if (!rsnd_src_sync_is_enabled(mod)) 96 return src->convert_rate; 97 98 convert_rate = src->sync.val; 99 100 if (!convert_rate) 101 convert_rate = src->convert_rate; 102 103 if (!convert_rate) 104 convert_rate = runtime->rate; 105 106 return convert_rate; 107 } 108 109 unsigned int rsnd_src_get_rate(struct rsnd_priv *priv, 110 struct rsnd_dai_stream *io, 111 int is_in) 112 { 113 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); 114 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 115 unsigned int rate = 0; 116 int is_play = rsnd_io_is_play(io); 117 118 /* 119 * Playback 120 * runtime_rate -> [SRC] -> convert_rate 121 * 122 * Capture 123 * convert_rate -> [SRC] -> runtime_rate 124 */ 125 126 if (is_play == is_in) 127 return runtime->rate; 128 129 /* 130 * return convert rate if SRC is used, 131 * otherwise, return runtime->rate as usual 132 */ 133 if (src_mod) 134 rate = rsnd_src_convert_rate(io, src_mod); 135 136 if (!rate) 137 rate = runtime->rate; 138 139 return rate; 140 } 141 142 static int rsnd_src_hw_params(struct rsnd_mod *mod, 143 struct rsnd_dai_stream *io, 144 struct snd_pcm_substream *substream, 145 struct snd_pcm_hw_params *fe_params) 146 { 147 struct rsnd_src *src = rsnd_mod_to_src(mod); 148 struct snd_soc_pcm_runtime *fe = substream->private_data; 149 150 /* 151 * SRC assumes that it is used under DPCM if user want to use 152 * sampling rate convert. Then, SRC should be FE. 153 * And then, this function will be called *after* BE settings. 154 * this means, each BE already has fixuped hw_params. 155 * see 156 * dpcm_fe_dai_hw_params() 157 * dpcm_be_dai_hw_params() 158 */ 159 src->convert_rate = 0; 160 if (fe->dai_link->dynamic) { 161 int stream = substream->stream; 162 struct snd_soc_dpcm *dpcm; 163 struct snd_pcm_hw_params *be_params; 164 165 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 166 be_params = &dpcm->hw_params; 167 168 if (params_rate(fe_params) != params_rate(be_params)) 169 src->convert_rate = params_rate(be_params); 170 } 171 } 172 173 return 0; 174 } 175 176 static void rsnd_src_set_convert_rate(struct rsnd_dai_stream *io, 177 struct rsnd_mod *mod) 178 { 179 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 180 struct device *dev = rsnd_priv_to_dev(priv); 181 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 182 int is_play = rsnd_io_is_play(io); 183 int use_src = 0; 184 u32 fin, fout; 185 u32 ifscr, fsrate, adinr; 186 u32 cr, route; 187 u32 bsdsr, bsisr; 188 u32 i_busif, o_busif, tmp; 189 uint ratio; 190 191 if (!runtime) 192 return; 193 194 fin = rsnd_src_get_in_rate(priv, io); 195 fout = rsnd_src_get_out_rate(priv, io); 196 197 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */ 198 if (fin == fout) 199 ratio = 0; 200 else if (fin > fout) 201 ratio = 100 * fin / fout; 202 else 203 ratio = 100 * fout / fin; 204 205 if (ratio > 600) { 206 dev_err(dev, "FSO/FSI ratio error\n"); 207 return; 208 } 209 210 use_src = (fin != fout) | rsnd_src_sync_is_enabled(mod); 211 212 /* 213 * SRC_ADINR 214 */ 215 adinr = rsnd_get_adinr_bit(mod, io) | 216 rsnd_runtime_channel_original(io); 217 218 /* 219 * SRC_IFSCR / SRC_IFSVR 220 */ 221 ifscr = 0; 222 fsrate = 0; 223 if (use_src) { 224 u64 n; 225 226 ifscr = 1; 227 n = (u64)0x0400000 * fin; 228 do_div(n, fout); 229 fsrate = n; 230 } 231 232 /* 233 * SRC_SRCCR / SRC_ROUTE_MODE0 234 */ 235 cr = 0x00011110; 236 route = 0x0; 237 if (use_src) { 238 route = 0x1; 239 240 if (rsnd_src_sync_is_enabled(mod)) { 241 cr |= 0x1; 242 route |= rsnd_io_is_play(io) ? 243 (0x1 << 24) : (0x1 << 25); 244 } 245 } 246 247 /* 248 * SRC_BSDSR / SRC_BSISR 249 */ 250 switch (rsnd_mod_id(mod)) { 251 case 5: 252 case 6: 253 case 7: 254 case 8: 255 bsdsr = 0x02400000; /* 6 - 1/6 */ 256 bsisr = 0x00100060; /* 6 - 1/6 */ 257 break; 258 default: 259 bsdsr = 0x01800000; /* 6 - 1/6 */ 260 bsisr = 0x00100060 ;/* 6 - 1/6 */ 261 break; 262 } 263 264 /* BUSIF_MODE */ 265 tmp = rsnd_get_busif_shift(io, mod); 266 i_busif = ( is_play ? tmp : 0) | 1; 267 o_busif = (!is_play ? tmp : 0) | 1; 268 269 rsnd_mod_write(mod, SRC_ROUTE_MODE0, route); 270 271 rsnd_mod_write(mod, SRC_SRCIR, 1); /* initialize */ 272 rsnd_mod_write(mod, SRC_ADINR, adinr); 273 rsnd_mod_write(mod, SRC_IFSCR, ifscr); 274 rsnd_mod_write(mod, SRC_IFSVR, fsrate); 275 rsnd_mod_write(mod, SRC_SRCCR, cr); 276 rsnd_mod_write(mod, SRC_BSDSR, bsdsr); 277 rsnd_mod_write(mod, SRC_BSISR, bsisr); 278 rsnd_mod_write(mod, SRC_SRCIR, 0); /* cancel initialize */ 279 280 rsnd_mod_write(mod, SRC_I_BUSIF_MODE, i_busif); 281 rsnd_mod_write(mod, SRC_O_BUSIF_MODE, o_busif); 282 283 rsnd_mod_write(mod, SRC_BUSIF_DALIGN, rsnd_get_dalign(mod, io)); 284 285 rsnd_adg_set_src_timesel_gen2(mod, io, fin, fout); 286 } 287 288 static int rsnd_src_irq(struct rsnd_mod *mod, 289 struct rsnd_dai_stream *io, 290 struct rsnd_priv *priv, 291 int enable) 292 { 293 struct rsnd_src *src = rsnd_mod_to_src(mod); 294 u32 sys_int_val, int_val, sys_int_mask; 295 int irq = src->irq; 296 int id = rsnd_mod_id(mod); 297 298 sys_int_val = 299 sys_int_mask = OUF_SRC(id); 300 int_val = 0x3300; 301 302 /* 303 * IRQ is not supported on non-DT 304 * see 305 * rsnd_src_probe_() 306 */ 307 if ((irq <= 0) || !enable) { 308 sys_int_val = 0; 309 int_val = 0; 310 } 311 312 /* 313 * WORKAROUND 314 * 315 * ignore over flow error when rsnd_src_sync_is_enabled() 316 */ 317 if (rsnd_src_sync_is_enabled(mod)) 318 sys_int_val = sys_int_val & 0xffff; 319 320 rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val); 321 rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val); 322 rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val); 323 324 return 0; 325 } 326 327 static void rsnd_src_status_clear(struct rsnd_mod *mod) 328 { 329 u32 val = OUF_SRC(rsnd_mod_id(mod)); 330 331 rsnd_mod_write(mod, SCU_SYS_STATUS0, val); 332 rsnd_mod_write(mod, SCU_SYS_STATUS1, val); 333 } 334 335 static bool rsnd_src_error_occurred(struct rsnd_mod *mod) 336 { 337 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 338 struct device *dev = rsnd_priv_to_dev(priv); 339 u32 val0, val1; 340 u32 status0, status1; 341 bool ret = false; 342 343 val0 = val1 = OUF_SRC(rsnd_mod_id(mod)); 344 345 /* 346 * WORKAROUND 347 * 348 * ignore over flow error when rsnd_src_sync_is_enabled() 349 */ 350 if (rsnd_src_sync_is_enabled(mod)) 351 val0 = val0 & 0xffff; 352 353 status0 = rsnd_mod_read(mod, SCU_SYS_STATUS0); 354 status1 = rsnd_mod_read(mod, SCU_SYS_STATUS1); 355 if ((status0 & val0) || (status1 & val1)) { 356 rsnd_dbg_irq_status(dev, "%s[%d] err status : 0x%08x, 0x%08x\n", 357 rsnd_mod_name(mod), rsnd_mod_id(mod), 358 status0, status1); 359 360 ret = true; 361 } 362 363 return ret; 364 } 365 366 static int rsnd_src_start(struct rsnd_mod *mod, 367 struct rsnd_dai_stream *io, 368 struct rsnd_priv *priv) 369 { 370 u32 val; 371 372 /* 373 * WORKAROUND 374 * 375 * Enable SRC output if you want to use sync convert together with DVC 376 */ 377 val = (rsnd_io_to_mod_dvc(io) && !rsnd_src_sync_is_enabled(mod)) ? 378 0x01 : 0x11; 379 380 rsnd_mod_write(mod, SRC_CTRL, val); 381 382 return 0; 383 } 384 385 static int rsnd_src_stop(struct rsnd_mod *mod, 386 struct rsnd_dai_stream *io, 387 struct rsnd_priv *priv) 388 { 389 rsnd_mod_write(mod, SRC_CTRL, 0); 390 391 return 0; 392 } 393 394 static int rsnd_src_init(struct rsnd_mod *mod, 395 struct rsnd_dai_stream *io, 396 struct rsnd_priv *priv) 397 { 398 struct rsnd_src *src = rsnd_mod_to_src(mod); 399 400 /* reset sync convert_rate */ 401 src->sync.val = 0; 402 403 rsnd_mod_power_on(mod); 404 405 rsnd_src_activation(mod); 406 407 rsnd_src_set_convert_rate(io, mod); 408 409 rsnd_src_status_clear(mod); 410 411 return 0; 412 } 413 414 static int rsnd_src_quit(struct rsnd_mod *mod, 415 struct rsnd_dai_stream *io, 416 struct rsnd_priv *priv) 417 { 418 struct rsnd_src *src = rsnd_mod_to_src(mod); 419 420 rsnd_src_halt(mod); 421 422 rsnd_mod_power_off(mod); 423 424 /* reset sync convert_rate */ 425 src->sync.val = 0; 426 427 return 0; 428 } 429 430 static void __rsnd_src_interrupt(struct rsnd_mod *mod, 431 struct rsnd_dai_stream *io) 432 { 433 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 434 bool stop = false; 435 436 spin_lock(&priv->lock); 437 438 /* ignore all cases if not working */ 439 if (!rsnd_io_is_working(io)) 440 goto rsnd_src_interrupt_out; 441 442 if (rsnd_src_error_occurred(mod)) 443 stop = true; 444 445 rsnd_src_status_clear(mod); 446 rsnd_src_interrupt_out: 447 448 spin_unlock(&priv->lock); 449 450 if (stop) 451 snd_pcm_stop_xrun(io->substream); 452 } 453 454 static irqreturn_t rsnd_src_interrupt(int irq, void *data) 455 { 456 struct rsnd_mod *mod = data; 457 458 rsnd_mod_interrupt(mod, __rsnd_src_interrupt); 459 460 return IRQ_HANDLED; 461 } 462 463 static int rsnd_src_probe_(struct rsnd_mod *mod, 464 struct rsnd_dai_stream *io, 465 struct rsnd_priv *priv) 466 { 467 struct rsnd_src *src = rsnd_mod_to_src(mod); 468 struct device *dev = rsnd_priv_to_dev(priv); 469 int irq = src->irq; 470 int ret; 471 472 if (irq > 0) { 473 /* 474 * IRQ is not supported on non-DT 475 * see 476 * rsnd_src_irq() 477 */ 478 ret = devm_request_irq(dev, irq, 479 rsnd_src_interrupt, 480 IRQF_SHARED, 481 dev_name(dev), mod); 482 if (ret) 483 return ret; 484 } 485 486 ret = rsnd_dma_attach(io, mod, &src->dma); 487 488 return ret; 489 } 490 491 static int rsnd_src_pcm_new(struct rsnd_mod *mod, 492 struct rsnd_dai_stream *io, 493 struct snd_soc_pcm_runtime *rtd) 494 { 495 struct rsnd_src *src = rsnd_mod_to_src(mod); 496 int ret; 497 498 /* 499 * enable SRC sync convert if possible 500 */ 501 502 /* 503 * It can't use SRC Synchronous convert 504 * when Capture if it uses CMD 505 */ 506 if (rsnd_io_to_mod_cmd(io) && !rsnd_io_is_play(io)) 507 return 0; 508 509 /* 510 * enable sync convert 511 */ 512 ret = rsnd_kctrl_new_s(mod, io, rtd, 513 rsnd_io_is_play(io) ? 514 "SRC Out Rate Switch" : 515 "SRC In Rate Switch", 516 rsnd_kctrl_accept_anytime, 517 rsnd_src_set_convert_rate, 518 &src->sen, 1); 519 if (ret < 0) 520 return ret; 521 522 ret = rsnd_kctrl_new_s(mod, io, rtd, 523 rsnd_io_is_play(io) ? 524 "SRC Out Rate" : 525 "SRC In Rate", 526 rsnd_kctrl_accept_runtime, 527 rsnd_src_set_convert_rate, 528 &src->sync, 192000); 529 530 return ret; 531 } 532 533 static struct rsnd_mod_ops rsnd_src_ops = { 534 .name = SRC_NAME, 535 .dma_req = rsnd_src_dma_req, 536 .probe = rsnd_src_probe_, 537 .init = rsnd_src_init, 538 .quit = rsnd_src_quit, 539 .start = rsnd_src_start, 540 .stop = rsnd_src_stop, 541 .irq = rsnd_src_irq, 542 .hw_params = rsnd_src_hw_params, 543 .pcm_new = rsnd_src_pcm_new, 544 }; 545 546 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id) 547 { 548 if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv))) 549 id = 0; 550 551 return rsnd_mod_get(rsnd_src_get(priv, id)); 552 } 553 554 int rsnd_src_probe(struct rsnd_priv *priv) 555 { 556 struct device_node *node; 557 struct device_node *np; 558 struct device *dev = rsnd_priv_to_dev(priv); 559 struct rsnd_src *src; 560 struct clk *clk; 561 char name[RSND_SRC_NAME_SIZE]; 562 int i, nr, ret; 563 564 /* This driver doesn't support Gen1 at this point */ 565 if (rsnd_is_gen1(priv)) 566 return 0; 567 568 node = rsnd_src_of_node(priv); 569 if (!node) 570 return 0; /* not used is not error */ 571 572 nr = of_get_child_count(node); 573 if (!nr) { 574 ret = -EINVAL; 575 goto rsnd_src_probe_done; 576 } 577 578 src = devm_kcalloc(dev, nr, sizeof(*src), GFP_KERNEL); 579 if (!src) { 580 ret = -ENOMEM; 581 goto rsnd_src_probe_done; 582 } 583 584 priv->src_nr = nr; 585 priv->src = src; 586 587 i = 0; 588 for_each_child_of_node(node, np) { 589 if (!of_device_is_available(np)) 590 goto skip; 591 592 src = rsnd_src_get(priv, i); 593 594 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d", 595 SRC_NAME, i); 596 597 src->irq = irq_of_parse_and_map(np, 0); 598 if (!src->irq) { 599 ret = -EINVAL; 600 of_node_put(np); 601 goto rsnd_src_probe_done; 602 } 603 604 clk = devm_clk_get(dev, name); 605 if (IS_ERR(clk)) { 606 ret = PTR_ERR(clk); 607 of_node_put(np); 608 goto rsnd_src_probe_done; 609 } 610 611 ret = rsnd_mod_init(priv, rsnd_mod_get(src), 612 &rsnd_src_ops, clk, rsnd_mod_get_status, 613 RSND_MOD_SRC, i); 614 if (ret) { 615 of_node_put(np); 616 goto rsnd_src_probe_done; 617 } 618 619 skip: 620 i++; 621 } 622 623 ret = 0; 624 625 rsnd_src_probe_done: 626 of_node_put(node); 627 628 return ret; 629 } 630 631 void rsnd_src_remove(struct rsnd_priv *priv) 632 { 633 struct rsnd_src *src; 634 int i; 635 636 for_each_rsnd_src(src, priv, i) { 637 rsnd_mod_quit(rsnd_mod_get(src)); 638 } 639 } 640