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