2101 lines · c
1// SPDX-License-Identifier: GPL-2.02//3// Renesas R-Car SRU/SCU/SSIU/SSI support4//5// Copyright (C) 2013 Renesas Solutions Corp.6// Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>7//8// Based on fsi.c9// Kuninori Morimoto <morimoto.kuninori@renesas.com>10 11/*12 * Renesas R-Car sound device structure13 *14 * Gen115 *16 * SRU : Sound Routing Unit17 * - SRC : Sampling Rate Converter18 * - CMD19 * - CTU : Channel Count Conversion Unit20 * - MIX : Mixer21 * - DVC : Digital Volume and Mute Function22 * - SSI : Serial Sound Interface23 *24 * Gen225 *26 * SCU : Sampling Rate Converter Unit27 * - SRC : Sampling Rate Converter28 * - CMD29 * - CTU : Channel Count Conversion Unit30 * - MIX : Mixer31 * - DVC : Digital Volume and Mute Function32 * SSIU : Serial Sound Interface Unit33 * - SSI : Serial Sound Interface34 */35 36/*37 * driver data Image38 *39 * rsnd_priv40 * |41 * | ** this depends on Gen1/Gen242 * |43 * +- gen44 * |45 * | ** these depend on data path46 * | ** gen and platform data control it47 * |48 * +- rdai[0]49 * | | sru ssiu ssi50 * | +- playback -> [mod] -> [mod] -> [mod] -> ...51 * | |52 * | | sru ssiu ssi53 * | +- capture -> [mod] -> [mod] -> [mod] -> ...54 * |55 * +- rdai[1]56 * | | sru ssiu ssi57 * | +- playback -> [mod] -> [mod] -> [mod] -> ...58 * | |59 * | | sru ssiu ssi60 * | +- capture -> [mod] -> [mod] -> [mod] -> ...61 * ...62 * |63 * | ** these control ssi64 * |65 * +- ssi66 * | |67 * | +- ssi[0]68 * | +- ssi[1]69 * | +- ssi[2]70 * | ...71 * |72 * | ** these control src73 * |74 * +- src75 * |76 * +- src[0]77 * +- src[1]78 * +- src[2]79 * ...80 *81 *82 * for_each_rsnd_dai(xx, priv, xx)83 * rdai[0] => rdai[1] => rdai[2] => ...84 *85 * for_each_rsnd_mod(xx, rdai, xx)86 * [mod] => [mod] => [mod] => ...87 *88 * rsnd_dai_call(xxx, fn )89 * [mod]->fn() -> [mod]->fn() -> [mod]->fn()...90 *91 */92 93#include <linux/pm_runtime.h>94#include <linux/of_graph.h>95#include "rsnd.h"96 97#define RSND_RATES SNDRV_PCM_RATE_8000_19200098#define RSND_FMTS (SNDRV_PCM_FMTBIT_S8 |\99 SNDRV_PCM_FMTBIT_S16_LE |\100 SNDRV_PCM_FMTBIT_S24_LE)101 102static const struct of_device_id rsnd_of_match[] = {103 { .compatible = "renesas,rcar_sound-gen1", .data = (void *)RSND_GEN1 },104 { .compatible = "renesas,rcar_sound-gen2", .data = (void *)RSND_GEN2 },105 { .compatible = "renesas,rcar_sound-gen3", .data = (void *)RSND_GEN3 },106 { .compatible = "renesas,rcar_sound-gen4", .data = (void *)RSND_GEN4 },107 /* Special Handling */108 { .compatible = "renesas,rcar_sound-r8a77990", .data = (void *)(RSND_GEN3 | RSND_SOC_E) },109 {},110};111MODULE_DEVICE_TABLE(of, rsnd_of_match);112 113/*114 * rsnd_mod functions115 */116void rsnd_mod_make_sure(struct rsnd_mod *mod, enum rsnd_mod_type type)117{118 if (mod->type != type) {119 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);120 struct device *dev = rsnd_priv_to_dev(priv);121 122 dev_warn(dev, "%s is not your expected module\n",123 rsnd_mod_name(mod));124 }125}126 127struct dma_chan *rsnd_mod_dma_req(struct rsnd_dai_stream *io,128 struct rsnd_mod *mod)129{130 if (!mod || !mod->ops || !mod->ops->dma_req)131 return NULL;132 133 return mod->ops->dma_req(io, mod);134}135 136#define MOD_NAME_NUM 5137#define MOD_NAME_SIZE 16138char *rsnd_mod_name(struct rsnd_mod *mod)139{140 static char names[MOD_NAME_NUM][MOD_NAME_SIZE];141 static int num;142 char *name = names[num];143 144 num++;145 if (num >= MOD_NAME_NUM)146 num = 0;147 148 /*149 * Let's use same char to avoid pointlessness memory150 * Thus, rsnd_mod_name() should be used immediately151 * Don't keep pointer152 */153 if ((mod)->ops->id_sub) {154 snprintf(name, MOD_NAME_SIZE, "%s[%d%d]",155 mod->ops->name,156 rsnd_mod_id(mod),157 rsnd_mod_id_sub(mod));158 } else {159 snprintf(name, MOD_NAME_SIZE, "%s[%d]",160 mod->ops->name,161 rsnd_mod_id(mod));162 }163 164 return name;165}166 167u32 *rsnd_mod_get_status(struct rsnd_mod *mod,168 struct rsnd_dai_stream *io,169 enum rsnd_mod_type type)170{171 return &mod->status;172}173 174int rsnd_mod_id_raw(struct rsnd_mod *mod)175{176 return mod->id;177}178 179int rsnd_mod_id(struct rsnd_mod *mod)180{181 if ((mod)->ops->id)182 return (mod)->ops->id(mod);183 184 return rsnd_mod_id_raw(mod);185}186 187int rsnd_mod_id_sub(struct rsnd_mod *mod)188{189 if ((mod)->ops->id_sub)190 return (mod)->ops->id_sub(mod);191 192 return 0;193}194 195int rsnd_mod_init(struct rsnd_priv *priv,196 struct rsnd_mod *mod,197 struct rsnd_mod_ops *ops,198 struct clk *clk,199 enum rsnd_mod_type type,200 int id)201{202 int ret = clk_prepare(clk);203 204 if (ret)205 return ret;206 207 mod->id = id;208 mod->ops = ops;209 mod->type = type;210 mod->clk = clk;211 mod->priv = priv;212 213 return 0;214}215 216void rsnd_mod_quit(struct rsnd_mod *mod)217{218 clk_unprepare(mod->clk);219 mod->clk = NULL;220}221 222void rsnd_mod_interrupt(struct rsnd_mod *mod,223 void (*callback)(struct rsnd_mod *mod,224 struct rsnd_dai_stream *io))225{226 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);227 struct rsnd_dai *rdai;228 int i;229 230 for_each_rsnd_dai(rdai, priv, i) {231 struct rsnd_dai_stream *io = &rdai->playback;232 233 if (mod == io->mod[mod->type])234 callback(mod, io);235 236 io = &rdai->capture;237 if (mod == io->mod[mod->type])238 callback(mod, io);239 }240}241 242int rsnd_io_is_working(struct rsnd_dai_stream *io)243{244 /* see rsnd_dai_stream_init/quit() */245 if (io->substream)246 return snd_pcm_running(io->substream);247 248 return 0;249}250 251int rsnd_runtime_channel_original_with_params(struct rsnd_dai_stream *io,252 struct snd_pcm_hw_params *params)253{254 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);255 256 /*257 * params will be added when refine258 * see259 * __rsnd_soc_hw_rule_rate()260 * __rsnd_soc_hw_rule_channels()261 */262 if (params)263 return params_channels(params);264 else if (runtime)265 return runtime->channels;266 return 0;267}268 269int rsnd_runtime_channel_after_ctu_with_params(struct rsnd_dai_stream *io,270 struct snd_pcm_hw_params *params)271{272 int chan = rsnd_runtime_channel_original_with_params(io, params);273 struct rsnd_mod *ctu_mod = rsnd_io_to_mod_ctu(io);274 275 if (ctu_mod) {276 u32 converted_chan = rsnd_io_converted_chan(io);277 278 /*279 * !! Note !!280 *281 * converted_chan will be used for CTU,282 * or TDM Split mode.283 * User shouldn't use CTU with TDM Split mode.284 */285 if (rsnd_runtime_is_tdm_split(io)) {286 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io));287 288 dev_err(dev, "CTU and TDM Split should be used\n");289 }290 291 if (converted_chan)292 return converted_chan;293 }294 295 return chan;296}297 298int rsnd_channel_normalization(int chan)299{300 if (WARN_ON((chan > 8) || (chan < 0)))301 return 0;302 303 /* TDM Extend Mode needs 8ch */304 if (chan == 6)305 chan = 8;306 307 return chan;308}309 310int rsnd_runtime_channel_for_ssi_with_params(struct rsnd_dai_stream *io,311 struct snd_pcm_hw_params *params)312{313 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);314 int chan = rsnd_io_is_play(io) ?315 rsnd_runtime_channel_after_ctu_with_params(io, params) :316 rsnd_runtime_channel_original_with_params(io, params);317 318 /* Use Multi SSI */319 if (rsnd_runtime_is_multi_ssi(io))320 chan /= rsnd_rdai_ssi_lane_get(rdai);321 322 return rsnd_channel_normalization(chan);323}324 325int rsnd_runtime_is_multi_ssi(struct rsnd_dai_stream *io)326{327 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);328 int lane = rsnd_rdai_ssi_lane_get(rdai);329 int chan = rsnd_io_is_play(io) ?330 rsnd_runtime_channel_after_ctu(io) :331 rsnd_runtime_channel_original(io);332 333 return (chan > 2) && (lane > 1);334}335 336int rsnd_runtime_is_tdm(struct rsnd_dai_stream *io)337{338 return rsnd_runtime_channel_for_ssi(io) >= 6;339}340 341int rsnd_runtime_is_tdm_split(struct rsnd_dai_stream *io)342{343 return !!rsnd_flags_has(io, RSND_STREAM_TDM_SPLIT);344}345 346/*347 * ADINR function348 */349u32 rsnd_get_adinr_bit(struct rsnd_mod *mod, struct rsnd_dai_stream *io)350{351 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);352 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);353 struct device *dev = rsnd_priv_to_dev(priv);354 355 switch (snd_pcm_format_width(runtime->format)) {356 case 8:357 return 16 << 16;358 case 16:359 return 8 << 16;360 case 24:361 return 0 << 16;362 }363 364 dev_warn(dev, "not supported sample bits\n");365 366 return 0;367}368 369/*370 * DALIGN function371 */372u32 rsnd_get_dalign(struct rsnd_mod *mod, struct rsnd_dai_stream *io)373{374 static const u32 dalign_values[8] = {375 0x76543210, 0x00000032, 0x00007654, 0x00000076,376 0xfedcba98, 0x000000ba, 0x0000fedc, 0x000000fe,377 };378 int id = 0;379 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io);380 struct rsnd_mod *target;381 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);382 u32 dalign;383 384 /*385 * *Hardware* L/R and *Software* L/R are inverted for 16bit data.386 * 31..16 15...0387 * HW: [L ch] [R ch]388 * SW: [R ch] [L ch]389 * We need to care about inversion timing to control390 * Playback/Capture correctly.391 * The point is [DVC] needs *Hardware* L/R, [MEM] needs *Software* L/R392 *393 * sL/R : software L/R394 * hL/R : hardware L/R395 * (*) : conversion timing396 *397 * Playback398 * sL/R (*) hL/R hL/R hL/R hL/R hL/R399 * [MEM] -> [SRC] -> [DVC] -> [CMD] -> [SSIU] -> [SSI] -> codec400 *401 * Capture402 * hL/R hL/R hL/R hL/R hL/R (*) sL/R403 * codec -> [SSI] -> [SSIU] -> [SRC] -> [DVC] -> [CMD] -> [MEM]404 */405 if (rsnd_io_is_play(io)) {406 struct rsnd_mod *src = rsnd_io_to_mod_src(io);407 408 target = src ? src : ssiu;409 } else {410 struct rsnd_mod *cmd = rsnd_io_to_mod_cmd(io);411 412 target = cmd ? cmd : ssiu;413 }414 415 if (mod == ssiu)416 id = rsnd_mod_id_sub(mod);417 418 dalign = dalign_values[id];419 420 if (mod == target && snd_pcm_format_width(runtime->format) == 16) {421 /* Target mod needs inverted DALIGN when 16bit */422 dalign = (dalign & 0xf0f0f0f0) >> 4 |423 (dalign & 0x0f0f0f0f) << 4;424 }425 426 return dalign;427}428 429u32 rsnd_get_busif_shift(struct rsnd_dai_stream *io, struct rsnd_mod *mod)430{431 static const enum rsnd_mod_type playback_mods[] = {432 RSND_MOD_SRC,433 RSND_MOD_CMD,434 RSND_MOD_SSIU,435 };436 static const enum rsnd_mod_type capture_mods[] = {437 RSND_MOD_CMD,438 RSND_MOD_SRC,439 RSND_MOD_SSIU,440 };441 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);442 struct rsnd_mod *tmod = NULL;443 const enum rsnd_mod_type *mods =444 rsnd_io_is_play(io) ?445 playback_mods : capture_mods;446 int i;447 448 /*449 * This is needed for 24bit data450 * We need to shift 8bit451 *452 * Linux 24bit data is located as 0x00******453 * HW 24bit data is located as 0x******00454 *455 */456 if (snd_pcm_format_width(runtime->format) != 24)457 return 0;458 459 for (i = 0; i < ARRAY_SIZE(playback_mods); i++) {460 tmod = rsnd_io_to_mod(io, mods[i]);461 if (tmod)462 break;463 }464 465 if (tmod != mod)466 return 0;467 468 if (rsnd_io_is_play(io))469 return (0 << 20) | /* shift to Left */470 (8 << 16); /* 8bit */471 else472 return (1 << 20) | /* shift to Right */473 (8 << 16); /* 8bit */474}475 476/*477 * rsnd_dai functions478 */479struct rsnd_mod *rsnd_mod_next(int *iterator,480 struct rsnd_dai_stream *io,481 enum rsnd_mod_type *array,482 int array_size)483{484 int max = array ? array_size : RSND_MOD_MAX;485 486 for (; *iterator < max; (*iterator)++) {487 enum rsnd_mod_type type = (array) ? array[*iterator] : *iterator;488 struct rsnd_mod *mod = rsnd_io_to_mod(io, type);489 490 if (mod)491 return mod;492 }493 494 return NULL;495}496 497static enum rsnd_mod_type rsnd_mod_sequence[][RSND_MOD_MAX] = {498 {499 /* CAPTURE */500 RSND_MOD_AUDMAPP,501 RSND_MOD_AUDMA,502 RSND_MOD_DVC,503 RSND_MOD_MIX,504 RSND_MOD_CTU,505 RSND_MOD_CMD,506 RSND_MOD_SRC,507 RSND_MOD_SSIU,508 RSND_MOD_SSIM3,509 RSND_MOD_SSIM2,510 RSND_MOD_SSIM1,511 RSND_MOD_SSIP,512 RSND_MOD_SSI,513 }, {514 /* PLAYBACK */515 RSND_MOD_AUDMAPP,516 RSND_MOD_AUDMA,517 RSND_MOD_SSIM3,518 RSND_MOD_SSIM2,519 RSND_MOD_SSIM1,520 RSND_MOD_SSIP,521 RSND_MOD_SSI,522 RSND_MOD_SSIU,523 RSND_MOD_DVC,524 RSND_MOD_MIX,525 RSND_MOD_CTU,526 RSND_MOD_CMD,527 RSND_MOD_SRC,528 },529};530 531static int rsnd_status_update(struct rsnd_dai_stream *io,532 struct rsnd_mod *mod, enum rsnd_mod_type type,533 int shift, int add, int timing)534{535 u32 *status = mod->ops->get_status(mod, io, type);536 u32 mask = 0xF << shift;537 u8 val = (*status >> shift) & 0xF;538 u8 next_val = (val + add) & 0xF;539 int func_call = (val == timing);540 541 /* no status update */542 if (add == 0 || shift == 28)543 return 1;544 545 if (next_val == 0xF) /* underflow case */546 func_call = -1;547 else548 *status = (*status & ~mask) + (next_val << shift);549 550 return func_call;551}552 553#define rsnd_dai_call(fn, io, param...) \554({ \555 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); \556 struct rsnd_mod *mod; \557 int is_play = rsnd_io_is_play(io); \558 int ret = 0, i; \559 enum rsnd_mod_type *types = rsnd_mod_sequence[is_play]; \560 for_each_rsnd_mod_arrays(i, mod, io, types, RSND_MOD_MAX) { \561 int tmp = 0; \562 int func_call = rsnd_status_update(io, mod, types[i], \563 __rsnd_mod_shift_##fn, \564 __rsnd_mod_add_##fn, \565 __rsnd_mod_call_##fn); \566 if (func_call > 0 && (mod)->ops->fn) \567 tmp = (mod)->ops->fn(mod, io, param); \568 if (unlikely(func_call < 0) || \569 unlikely(tmp && (tmp != -EPROBE_DEFER))) \570 dev_err(dev, "%s : %s error (%d, %d)\n", \571 rsnd_mod_name(mod), #fn, tmp, func_call);\572 ret |= tmp; \573 } \574 ret; \575})576 577int rsnd_dai_connect(struct rsnd_mod *mod,578 struct rsnd_dai_stream *io,579 enum rsnd_mod_type type)580{581 struct rsnd_priv *priv;582 struct device *dev;583 584 if (!mod)585 return -EIO;586 587 if (io->mod[type] == mod)588 return 0;589 590 if (io->mod[type])591 return -EINVAL;592 593 priv = rsnd_mod_to_priv(mod);594 dev = rsnd_priv_to_dev(priv);595 596 io->mod[type] = mod;597 598 dev_dbg(dev, "%s is connected to io (%s)\n",599 rsnd_mod_name(mod),600 rsnd_io_is_play(io) ? "Playback" : "Capture");601 602 return 0;603}604 605static void rsnd_dai_disconnect(struct rsnd_mod *mod,606 struct rsnd_dai_stream *io,607 enum rsnd_mod_type type)608{609 io->mod[type] = NULL;610}611 612int rsnd_rdai_channels_ctrl(struct rsnd_dai *rdai,613 int max_channels)614{615 if (max_channels > 0)616 rdai->max_channels = max_channels;617 618 return rdai->max_channels;619}620 621int rsnd_rdai_ssi_lane_ctrl(struct rsnd_dai *rdai,622 int ssi_lane)623{624 if (ssi_lane > 0)625 rdai->ssi_lane = ssi_lane;626 627 return rdai->ssi_lane;628}629 630int rsnd_rdai_width_ctrl(struct rsnd_dai *rdai, int width)631{632 if (width > 0)633 rdai->chan_width = width;634 635 return rdai->chan_width;636}637 638struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id)639{640 if ((id < 0) || (id >= rsnd_rdai_nr(priv)))641 return NULL;642 643 return priv->rdai + id;644}645 646static struct snd_soc_dai_driver647*rsnd_daidrv_get(struct rsnd_priv *priv, int id)648{649 if ((id < 0) || (id >= rsnd_rdai_nr(priv)))650 return NULL;651 652 return priv->daidrv + id;653}654 655#define rsnd_dai_to_priv(dai) snd_soc_dai_get_drvdata(dai)656static struct rsnd_dai *rsnd_dai_to_rdai(struct snd_soc_dai *dai)657{658 struct rsnd_priv *priv = rsnd_dai_to_priv(dai);659 660 return rsnd_rdai_get(priv, dai->id);661}662 663static void rsnd_dai_stream_init(struct rsnd_dai_stream *io,664 struct snd_pcm_substream *substream)665{666 io->substream = substream;667}668 669static void rsnd_dai_stream_quit(struct rsnd_dai_stream *io)670{671 io->substream = NULL;672}673 674static675struct snd_soc_dai *rsnd_substream_to_dai(struct snd_pcm_substream *substream)676{677 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);678 679 return snd_soc_rtd_to_cpu(rtd, 0);680}681 682static683struct rsnd_dai_stream *rsnd_rdai_to_io(struct rsnd_dai *rdai,684 struct snd_pcm_substream *substream)685{686 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)687 return &rdai->playback;688 else689 return &rdai->capture;690}691 692static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd,693 struct snd_soc_dai *dai)694{695 struct rsnd_priv *priv = rsnd_dai_to_priv(dai);696 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);697 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);698 int ret;699 unsigned long flags;700 701 spin_lock_irqsave(&priv->lock, flags);702 703 switch (cmd) {704 case SNDRV_PCM_TRIGGER_START:705 case SNDRV_PCM_TRIGGER_RESUME:706 ret = rsnd_dai_call(init, io, priv);707 if (ret < 0)708 goto dai_trigger_end;709 710 ret = rsnd_dai_call(start, io, priv);711 if (ret < 0)712 goto dai_trigger_end;713 714 ret = rsnd_dai_call(irq, io, priv, 1);715 if (ret < 0)716 goto dai_trigger_end;717 718 break;719 case SNDRV_PCM_TRIGGER_STOP:720 case SNDRV_PCM_TRIGGER_SUSPEND:721 ret = rsnd_dai_call(irq, io, priv, 0);722 723 ret |= rsnd_dai_call(stop, io, priv);724 725 ret |= rsnd_dai_call(quit, io, priv);726 727 break;728 default:729 ret = -EINVAL;730 }731 732dai_trigger_end:733 spin_unlock_irqrestore(&priv->lock, flags);734 735 return ret;736}737 738static int rsnd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)739{740 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);741 742 /* set clock master for audio interface */743 switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {744 case SND_SOC_DAIFMT_BC_FC:745 rdai->clk_master = 0;746 break;747 case SND_SOC_DAIFMT_BP_FP:748 rdai->clk_master = 1; /* cpu is master */749 break;750 default:751 return -EINVAL;752 }753 754 /* set format */755 rdai->bit_clk_inv = 0;756 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {757 case SND_SOC_DAIFMT_I2S:758 rdai->sys_delay = 0;759 rdai->data_alignment = 0;760 rdai->frm_clk_inv = 0;761 break;762 case SND_SOC_DAIFMT_LEFT_J:763 case SND_SOC_DAIFMT_DSP_B:764 rdai->sys_delay = 1;765 rdai->data_alignment = 0;766 rdai->frm_clk_inv = 1;767 break;768 case SND_SOC_DAIFMT_RIGHT_J:769 rdai->sys_delay = 1;770 rdai->data_alignment = 1;771 rdai->frm_clk_inv = 1;772 break;773 case SND_SOC_DAIFMT_DSP_A:774 rdai->sys_delay = 0;775 rdai->data_alignment = 0;776 rdai->frm_clk_inv = 1;777 break;778 }779 780 /* set clock inversion */781 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {782 case SND_SOC_DAIFMT_NB_IF:783 rdai->frm_clk_inv = !rdai->frm_clk_inv;784 break;785 case SND_SOC_DAIFMT_IB_NF:786 rdai->bit_clk_inv = !rdai->bit_clk_inv;787 break;788 case SND_SOC_DAIFMT_IB_IF:789 rdai->bit_clk_inv = !rdai->bit_clk_inv;790 rdai->frm_clk_inv = !rdai->frm_clk_inv;791 break;792 case SND_SOC_DAIFMT_NB_NF:793 default:794 break;795 }796 797 return 0;798}799 800static int rsnd_soc_set_dai_tdm_slot(struct snd_soc_dai *dai,801 u32 tx_mask, u32 rx_mask,802 int slots, int slot_width)803{804 struct rsnd_priv *priv = rsnd_dai_to_priv(dai);805 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);806 struct device *dev = rsnd_priv_to_dev(priv);807 808 switch (slot_width) {809 case 16:810 case 24:811 case 32:812 break;813 default:814 /* use default */815 /*816 * Indicate warning if DT has "dai-tdm-slot-width"817 * but the value was not expected.818 */819 if (slot_width)820 dev_warn(dev, "unsupported TDM slot width (%d), force to use default 32\n",821 slot_width);822 slot_width = 32;823 }824 825 switch (slots) {826 case 2:827 /* TDM Split Mode */828 case 6:829 case 8:830 /* TDM Extend Mode */831 rsnd_rdai_channels_set(rdai, slots);832 rsnd_rdai_ssi_lane_set(rdai, 1);833 rsnd_rdai_width_set(rdai, slot_width);834 break;835 default:836 dev_err(dev, "unsupported TDM slots (%d)\n", slots);837 return -EINVAL;838 }839 840 return 0;841}842 843static unsigned int rsnd_soc_hw_channels_list[] = {844 2, 6, 8,845};846 847static unsigned int rsnd_soc_hw_rate_list[] = {848 8000,849 11025,850 16000,851 22050,852 32000,853 44100,854 48000,855 64000,856 88200,857 96000,858 176400,859 192000,860};861 862static int rsnd_soc_hw_rule(struct rsnd_dai *rdai,863 unsigned int *list, int list_num,864 struct snd_interval *baseline, struct snd_interval *iv,865 struct rsnd_dai_stream *io, char *unit)866{867 struct snd_interval p;868 unsigned int rate;869 int i;870 871 snd_interval_any(&p);872 p.min = UINT_MAX;873 p.max = 0;874 875 for (i = 0; i < list_num; i++) {876 877 if (!snd_interval_test(iv, list[i]))878 continue;879 880 rate = rsnd_ssi_clk_query(rdai,881 baseline->min, list[i], NULL);882 if (rate > 0) {883 p.min = min(p.min, list[i]);884 p.max = max(p.max, list[i]);885 }886 887 rate = rsnd_ssi_clk_query(rdai,888 baseline->max, list[i], NULL);889 if (rate > 0) {890 p.min = min(p.min, list[i]);891 p.max = max(p.max, list[i]);892 }893 }894 895 /* Indicate error once if it can't handle */896 if (!rsnd_flags_has(io, RSND_HW_RULE_ERR) && (p.min > p.max)) {897 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);898 struct device *dev = rsnd_priv_to_dev(priv);899 900 dev_warn(dev, "It can't handle %d %s <-> %d %s\n",901 baseline->min, unit, baseline->max, unit);902 rsnd_flags_set(io, RSND_HW_RULE_ERR);903 }904 905 return snd_interval_refine(iv, &p);906}907 908static int rsnd_soc_hw_rule_rate(struct snd_pcm_hw_params *params,909 struct snd_pcm_hw_rule *rule)910{911 struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);912 struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);913 struct snd_interval ic;914 struct rsnd_dai_stream *io = rule->private;915 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);916 917 /*918 * possible sampling rate limitation is same as919 * 2ch if it supports multi ssi920 * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init())921 */922 ic = *ic_;923 ic.min =924 ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params);925 926 return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_rate_list,927 ARRAY_SIZE(rsnd_soc_hw_rate_list),928 &ic, ir, io, "ch");929}930 931static int rsnd_soc_hw_rule_channels(struct snd_pcm_hw_params *params,932 struct snd_pcm_hw_rule *rule)933{934 struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);935 struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);936 struct snd_interval ic;937 struct rsnd_dai_stream *io = rule->private;938 struct rsnd_dai *rdai = rsnd_io_to_rdai(io);939 940 /*941 * possible sampling rate limitation is same as942 * 2ch if it supports multi ssi943 * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init())944 */945 ic = *ic_;946 ic.min =947 ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params);948 949 return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_channels_list,950 ARRAY_SIZE(rsnd_soc_hw_channels_list),951 ir, &ic, io, "Hz");952}953 954static const struct snd_pcm_hardware rsnd_pcm_hardware = {955 .info = SNDRV_PCM_INFO_INTERLEAVED |956 SNDRV_PCM_INFO_MMAP |957 SNDRV_PCM_INFO_MMAP_VALID,958 .buffer_bytes_max = 64 * 1024,959 .period_bytes_min = 32,960 .period_bytes_max = 8192,961 .periods_min = 1,962 .periods_max = 32,963 .fifo_size = 256,964};965 966static int rsnd_soc_dai_startup(struct snd_pcm_substream *substream,967 struct snd_soc_dai *dai)968{969 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);970 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);971 struct snd_pcm_hw_constraint_list *constraint = &rdai->constraint;972 struct snd_pcm_runtime *runtime = substream->runtime;973 unsigned int max_channels = rsnd_rdai_channels_get(rdai);974 int i;975 976 rsnd_flags_del(io, RSND_HW_RULE_ERR);977 978 rsnd_dai_stream_init(io, substream);979 980 /*981 * Channel Limitation982 * It depends on Platform design983 */984 constraint->list = rsnd_soc_hw_channels_list;985 constraint->count = 0;986 constraint->mask = 0;987 988 for (i = 0; i < ARRAY_SIZE(rsnd_soc_hw_channels_list); i++) {989 if (rsnd_soc_hw_channels_list[i] > max_channels)990 break;991 constraint->count = i + 1;992 }993 994 snd_soc_set_runtime_hwparams(substream, &rsnd_pcm_hardware);995 996 snd_pcm_hw_constraint_list(runtime, 0,997 SNDRV_PCM_HW_PARAM_CHANNELS, constraint);998 999 snd_pcm_hw_constraint_integer(runtime,1000 SNDRV_PCM_HW_PARAM_PERIODS);1001 1002 /*1003 * Sampling Rate / Channel Limitation1004 * It depends on Clock Master Mode1005 */1006 if (rsnd_rdai_is_clk_master(rdai)) {1007 int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;1008 1009 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,1010 rsnd_soc_hw_rule_rate,1011 is_play ? &rdai->playback : &rdai->capture,1012 SNDRV_PCM_HW_PARAM_CHANNELS, -1);1013 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,1014 rsnd_soc_hw_rule_channels,1015 is_play ? &rdai->playback : &rdai->capture,1016 SNDRV_PCM_HW_PARAM_RATE, -1);1017 }1018 1019 return 0;1020}1021 1022static void rsnd_soc_dai_shutdown(struct snd_pcm_substream *substream,1023 struct snd_soc_dai *dai)1024{1025 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1026 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);1027 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);1028 1029 /*1030 * call rsnd_dai_call without spinlock1031 */1032 rsnd_dai_call(cleanup, io, priv);1033 1034 rsnd_dai_stream_quit(io);1035}1036 1037static int rsnd_soc_dai_prepare(struct snd_pcm_substream *substream,1038 struct snd_soc_dai *dai)1039{1040 struct rsnd_priv *priv = rsnd_dai_to_priv(dai);1041 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1042 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);1043 1044 return rsnd_dai_call(prepare, io, priv);1045}1046 1047static const u64 rsnd_soc_dai_formats[] = {1048 /*1049 * 1st Priority1050 *1051 * Well tested formats.1052 * Select below from Sound Card, not auto1053 * SND_SOC_DAIFMT_CBC_CFC1054 * SND_SOC_DAIFMT_CBP_CFP1055 */1056 SND_SOC_POSSIBLE_DAIFMT_I2S |1057 SND_SOC_POSSIBLE_DAIFMT_RIGHT_J |1058 SND_SOC_POSSIBLE_DAIFMT_LEFT_J |1059 SND_SOC_POSSIBLE_DAIFMT_NB_NF |1060 SND_SOC_POSSIBLE_DAIFMT_NB_IF |1061 SND_SOC_POSSIBLE_DAIFMT_IB_NF |1062 SND_SOC_POSSIBLE_DAIFMT_IB_IF,1063 /*1064 * 2nd Priority1065 *1066 * Supported, but not well tested1067 */1068 SND_SOC_POSSIBLE_DAIFMT_DSP_A |1069 SND_SOC_POSSIBLE_DAIFMT_DSP_B,1070};1071 1072static void rsnd_parse_tdm_split_mode(struct rsnd_priv *priv,1073 struct rsnd_dai_stream *io,1074 struct device_node *dai_np)1075{1076 struct device *dev = rsnd_priv_to_dev(priv);1077 struct device_node *ssiu_np = rsnd_ssiu_of_node(priv);1078 struct device_node *np;1079 int is_play = rsnd_io_is_play(io);1080 int i;1081 1082 if (!ssiu_np)1083 return;1084 1085 /*1086 * This driver assumes that it is TDM Split mode1087 * if it includes ssiu node1088 */1089 for (i = 0;; i++) {1090 struct device_node *node = is_play ?1091 of_parse_phandle(dai_np, "playback", i) :1092 of_parse_phandle(dai_np, "capture", i);1093 1094 if (!node)1095 break;1096 1097 for_each_child_of_node(ssiu_np, np) {1098 if (np == node) {1099 rsnd_flags_set(io, RSND_STREAM_TDM_SPLIT);1100 dev_dbg(dev, "%s is part of TDM Split\n", io->name);1101 }1102 }1103 1104 of_node_put(node);1105 }1106 1107 of_node_put(ssiu_np);1108}1109 1110static void rsnd_parse_connect_simple(struct rsnd_priv *priv,1111 struct rsnd_dai_stream *io,1112 struct device_node *dai_np)1113{1114 if (!rsnd_io_to_mod_ssi(io))1115 return;1116 1117 rsnd_parse_tdm_split_mode(priv, io, dai_np);1118}1119 1120static void rsnd_parse_connect_graph(struct rsnd_priv *priv,1121 struct rsnd_dai_stream *io,1122 struct device_node *endpoint)1123{1124 struct device *dev = rsnd_priv_to_dev(priv);1125 struct device_node *remote_node;1126 1127 if (!rsnd_io_to_mod_ssi(io))1128 return;1129 1130 remote_node = of_graph_get_remote_port_parent(endpoint);1131 1132 /* HDMI0 */1133 if (strstr(remote_node->full_name, "hdmi@fead0000")) {1134 rsnd_flags_set(io, RSND_STREAM_HDMI0);1135 dev_dbg(dev, "%s connected to HDMI0\n", io->name);1136 }1137 1138 /* HDMI1 */1139 if (strstr(remote_node->full_name, "hdmi@feae0000")) {1140 rsnd_flags_set(io, RSND_STREAM_HDMI1);1141 dev_dbg(dev, "%s connected to HDMI1\n", io->name);1142 }1143 1144 rsnd_parse_tdm_split_mode(priv, io, endpoint);1145 1146 of_node_put(remote_node);1147}1148 1149void rsnd_parse_connect_common(struct rsnd_dai *rdai, char *name,1150 struct rsnd_mod* (*mod_get)(struct rsnd_priv *priv, int id),1151 struct device_node *node,1152 struct device_node *playback,1153 struct device_node *capture)1154{1155 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);1156 struct device *dev = rsnd_priv_to_dev(priv);1157 struct device_node *np;1158 int i;1159 1160 if (!node)1161 return;1162 1163 i = 0;1164 for_each_child_of_node(node, np) {1165 struct rsnd_mod *mod;1166 1167 i = rsnd_node_fixed_index(dev, np, name, i);1168 if (i < 0) {1169 of_node_put(np);1170 break;1171 }1172 1173 mod = mod_get(priv, i);1174 1175 if (np == playback)1176 rsnd_dai_connect(mod, &rdai->playback, mod->type);1177 if (np == capture)1178 rsnd_dai_connect(mod, &rdai->capture, mod->type);1179 i++;1180 }1181 1182 of_node_put(node);1183}1184 1185int rsnd_node_fixed_index(struct device *dev, struct device_node *node, char *name, int idx)1186{1187 char node_name[16];1188 1189 /*1190 * rsnd is assuming each device nodes are sequential numbering,1191 * but some of them are not.1192 * This function adjusts index for it.1193 *1194 * ex)1195 * Normal case, special case1196 * ssi-01197 * ssi-11198 * ssi-21199 * ssi-3 ssi-31200 * ssi-4 ssi-41201 * ...1202 *1203 * assume Max 64 node1204 */1205 for (; idx < 64; idx++) {1206 snprintf(node_name, sizeof(node_name), "%s-%d", name, idx);1207 1208 if (strncmp(node_name, of_node_full_name(node), sizeof(node_name)) == 0)1209 return idx;1210 }1211 1212 dev_err(dev, "strange node numbering (%s)",1213 of_node_full_name(node));1214 return -EINVAL;1215}1216 1217int rsnd_node_count(struct rsnd_priv *priv, struct device_node *node, char *name)1218{1219 struct device *dev = rsnd_priv_to_dev(priv);1220 struct device_node *np;1221 int i;1222 1223 i = 0;1224 for_each_child_of_node(node, np) {1225 i = rsnd_node_fixed_index(dev, np, name, i);1226 if (i < 0) {1227 of_node_put(np);1228 return 0;1229 }1230 i++;1231 }1232 1233 return i;1234}1235 1236static int rsnd_dai_of_node(struct rsnd_priv *priv, int *is_graph)1237{1238 struct device *dev = rsnd_priv_to_dev(priv);1239 struct device_node *np = dev->of_node;1240 struct device_node *ports, *node;1241 int nr = 0;1242 int i = 0;1243 1244 *is_graph = 0;1245 1246 /*1247 * parse both previous dai (= rcar_sound,dai), and1248 * graph dai (= ports/port)1249 */1250 1251 /*1252 * Simple-Card1253 */1254 node = of_get_child_by_name(np, RSND_NODE_DAI);1255 if (!node)1256 goto audio_graph;1257 1258 of_node_put(node);1259 1260 for_each_child_of_node(np, node) {1261 if (!of_node_name_eq(node, RSND_NODE_DAI))1262 continue;1263 1264 priv->component_dais[i] = of_get_child_count(node);1265 nr += priv->component_dais[i];1266 i++;1267 if (i >= RSND_MAX_COMPONENT) {1268 dev_info(dev, "reach to max component\n");1269 of_node_put(node);1270 break;1271 }1272 }1273 1274 return nr;1275 1276audio_graph:1277 /*1278 * Audio-Graph-Card1279 */1280 for_each_child_of_node(np, ports) {1281 if (!of_node_name_eq(ports, "ports") &&1282 !of_node_name_eq(ports, "port"))1283 continue;1284 priv->component_dais[i] =1285 of_graph_get_endpoint_count(of_node_name_eq(ports, "ports") ?1286 ports : np);1287 nr += priv->component_dais[i];1288 i++;1289 if (i >= RSND_MAX_COMPONENT) {1290 dev_info(dev, "reach to max component\n");1291 of_node_put(ports);1292 break;1293 }1294 }1295 1296 *is_graph = 1;1297 1298 return nr;1299}1300 1301 1302#define PREALLOC_BUFFER (32 * 1024)1303#define PREALLOC_BUFFER_MAX (32 * 1024)1304 1305static int rsnd_preallocate_pages(struct snd_soc_pcm_runtime *rtd,1306 struct rsnd_dai_stream *io,1307 int stream)1308{1309 struct rsnd_priv *priv = rsnd_io_to_priv(io);1310 struct device *dev = rsnd_priv_to_dev(priv);1311 struct snd_pcm_substream *substream;1312 1313 /*1314 * use Audio-DMAC dev if we can use IPMMU1315 * see1316 * rsnd_dmaen_attach()1317 */1318 if (io->dmac_dev)1319 dev = io->dmac_dev;1320 1321 for (substream = rtd->pcm->streams[stream].substream;1322 substream;1323 substream = substream->next) {1324 snd_pcm_set_managed_buffer(substream,1325 SNDRV_DMA_TYPE_DEV,1326 dev,1327 PREALLOC_BUFFER, PREALLOC_BUFFER_MAX);1328 }1329 1330 return 0;1331}1332 1333static int rsnd_soc_dai_pcm_new(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai)1334{1335 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1336 int ret;1337 1338 ret = rsnd_dai_call(pcm_new, &rdai->playback, rtd);1339 if (ret)1340 return ret;1341 1342 ret = rsnd_dai_call(pcm_new, &rdai->capture, rtd);1343 if (ret)1344 return ret;1345 1346 ret = rsnd_preallocate_pages(rtd, &rdai->playback,1347 SNDRV_PCM_STREAM_PLAYBACK);1348 if (ret)1349 return ret;1350 1351 ret = rsnd_preallocate_pages(rtd, &rdai->capture,1352 SNDRV_PCM_STREAM_CAPTURE);1353 if (ret)1354 return ret;1355 1356 return 0;1357}1358 1359static const struct snd_soc_dai_ops rsnd_soc_dai_ops = {1360 .pcm_new = rsnd_soc_dai_pcm_new,1361 .startup = rsnd_soc_dai_startup,1362 .shutdown = rsnd_soc_dai_shutdown,1363 .trigger = rsnd_soc_dai_trigger,1364 .set_fmt = rsnd_soc_dai_set_fmt,1365 .set_tdm_slot = rsnd_soc_set_dai_tdm_slot,1366 .prepare = rsnd_soc_dai_prepare,1367 .auto_selectable_formats = rsnd_soc_dai_formats,1368 .num_auto_selectable_formats = ARRAY_SIZE(rsnd_soc_dai_formats),1369};1370 1371static void __rsnd_dai_probe(struct rsnd_priv *priv,1372 struct device_node *dai_np,1373 struct device_node *node_np,1374 uint32_t node_arg,1375 int dai_i)1376{1377 struct rsnd_dai_stream *io_playback;1378 struct rsnd_dai_stream *io_capture;1379 struct snd_soc_dai_driver *drv;1380 struct rsnd_dai *rdai;1381 struct device *dev = rsnd_priv_to_dev(priv);1382 int playback_exist = 0, capture_exist = 0;1383 int io_i;1384 1385 rdai = rsnd_rdai_get(priv, dai_i);1386 drv = rsnd_daidrv_get(priv, dai_i);1387 io_playback = &rdai->playback;1388 io_capture = &rdai->capture;1389 1390 snprintf(rdai->name, RSND_DAI_NAME_SIZE, "rsnd-dai.%d", dai_i);1391 1392 /* for multi Component */1393 rdai->dai_args.np = node_np;1394 rdai->dai_args.args_count = 1;1395 rdai->dai_args.args[0] = node_arg;1396 1397 rdai->priv = priv;1398 drv->name = rdai->name;1399 drv->ops = &rsnd_soc_dai_ops;1400 drv->id = dai_i;1401 drv->dai_args = &rdai->dai_args;1402 1403 io_playback->rdai = rdai;1404 io_capture->rdai = rdai;1405 rsnd_rdai_channels_set(rdai, 2); /* default 2ch */1406 rsnd_rdai_ssi_lane_set(rdai, 1); /* default 1lane */1407 rsnd_rdai_width_set(rdai, 32); /* default 32bit width */1408 1409 for (io_i = 0;; io_i++) {1410 struct device_node *playback = of_parse_phandle(dai_np, "playback", io_i);1411 struct device_node *capture = of_parse_phandle(dai_np, "capture", io_i);1412 1413 if (!playback && !capture)1414 break;1415 1416 if (io_i == 0) {1417 /* check whether playback/capture property exists */1418 if (playback)1419 playback_exist = 1;1420 if (capture)1421 capture_exist = 1;1422 }1423 1424 rsnd_parse_connect_ssi(rdai, playback, capture);1425 rsnd_parse_connect_ssiu(rdai, playback, capture);1426 rsnd_parse_connect_src(rdai, playback, capture);1427 rsnd_parse_connect_ctu(rdai, playback, capture);1428 rsnd_parse_connect_mix(rdai, playback, capture);1429 rsnd_parse_connect_dvc(rdai, playback, capture);1430 1431 of_node_put(playback);1432 of_node_put(capture);1433 }1434 1435 if (playback_exist) {1436 snprintf(io_playback->name, RSND_DAI_NAME_SIZE, "DAI%d Playback", dai_i);1437 drv->playback.rates = RSND_RATES;1438 drv->playback.formats = RSND_FMTS;1439 drv->playback.channels_min = 2;1440 drv->playback.channels_max = 8;1441 drv->playback.stream_name = io_playback->name;1442 }1443 if (capture_exist) {1444 snprintf(io_capture->name, RSND_DAI_NAME_SIZE, "DAI%d Capture", dai_i);1445 drv->capture.rates = RSND_RATES;1446 drv->capture.formats = RSND_FMTS;1447 drv->capture.channels_min = 2;1448 drv->capture.channels_max = 8;1449 drv->capture.stream_name = io_capture->name;1450 }1451 1452 if (rsnd_ssi_is_pin_sharing(io_capture) ||1453 rsnd_ssi_is_pin_sharing(io_playback)) {1454 /* should have symmetric_rate if pin sharing */1455 drv->symmetric_rate = 1;1456 }1457 1458 dev_dbg(dev, "%s (%s/%s)\n", rdai->name,1459 rsnd_io_to_mod_ssi(io_playback) ? "play" : " -- ",1460 rsnd_io_to_mod_ssi(io_capture) ? "capture" : " -- ");1461}1462 1463static int rsnd_dai_probe(struct rsnd_priv *priv)1464{1465 struct snd_soc_dai_driver *rdrv;1466 struct device *dev = rsnd_priv_to_dev(priv);1467 struct device_node *np = dev->of_node;1468 struct rsnd_dai *rdai;1469 int nr = 0;1470 int is_graph;1471 int dai_i;1472 1473 nr = rsnd_dai_of_node(priv, &is_graph);1474 if (!nr)1475 return -EINVAL;1476 1477 rdrv = devm_kcalloc(dev, nr, sizeof(*rdrv), GFP_KERNEL);1478 rdai = devm_kcalloc(dev, nr, sizeof(*rdai), GFP_KERNEL);1479 if (!rdrv || !rdai)1480 return -ENOMEM;1481 1482 priv->rdai_nr = nr;1483 priv->daidrv = rdrv;1484 priv->rdai = rdai;1485 1486 /*1487 * parse all dai1488 */1489 dai_i = 0;1490 if (is_graph) {1491 struct device_node *ports;1492 struct device_node *dai_np;1493 1494 for_each_child_of_node(np, ports) {1495 if (!of_node_name_eq(ports, "ports") &&1496 !of_node_name_eq(ports, "port"))1497 continue;1498 for_each_endpoint_of_node(of_node_name_eq(ports, "ports") ?1499 ports : np, dai_np) {1500 __rsnd_dai_probe(priv, dai_np, dai_np, 0, dai_i);1501 if (!rsnd_is_gen1(priv) && !rsnd_is_gen2(priv)) {1502 rdai = rsnd_rdai_get(priv, dai_i);1503 1504 rsnd_parse_connect_graph(priv, &rdai->playback, dai_np);1505 rsnd_parse_connect_graph(priv, &rdai->capture, dai_np);1506 }1507 dai_i++;1508 }1509 }1510 } else {1511 struct device_node *node;1512 struct device_node *dai_np;1513 1514 for_each_child_of_node(np, node) {1515 if (!of_node_name_eq(node, RSND_NODE_DAI))1516 continue;1517 1518 for_each_child_of_node(node, dai_np) {1519 __rsnd_dai_probe(priv, dai_np, np, dai_i, dai_i);1520 if (!rsnd_is_gen1(priv) && !rsnd_is_gen2(priv)) {1521 rdai = rsnd_rdai_get(priv, dai_i);1522 1523 rsnd_parse_connect_simple(priv, &rdai->playback, dai_np);1524 rsnd_parse_connect_simple(priv, &rdai->capture, dai_np);1525 }1526 dai_i++;1527 }1528 }1529 }1530 1531 return 0;1532}1533 1534/*1535 * pcm ops1536 */1537static int rsnd_hw_update(struct snd_pcm_substream *substream,1538 struct snd_pcm_hw_params *hw_params)1539{1540 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream);1541 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1542 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);1543 struct rsnd_priv *priv = rsnd_io_to_priv(io);1544 unsigned long flags;1545 int ret;1546 1547 spin_lock_irqsave(&priv->lock, flags);1548 if (hw_params)1549 ret = rsnd_dai_call(hw_params, io, substream, hw_params);1550 else1551 ret = rsnd_dai_call(hw_free, io, substream);1552 spin_unlock_irqrestore(&priv->lock, flags);1553 1554 return ret;1555}1556 1557static int rsnd_hw_params(struct snd_soc_component *component,1558 struct snd_pcm_substream *substream,1559 struct snd_pcm_hw_params *hw_params)1560{1561 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream);1562 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1563 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);1564 struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);1565 1566 /*1567 * rsnd assumes that it might be used under DPCM if user want to use1568 * channel / rate convert. Then, rsnd should be FE.1569 * And then, this function will be called *after* BE settings.1570 * this means, each BE already has fixuped hw_params.1571 * see1572 * dpcm_fe_dai_hw_params()1573 * dpcm_be_dai_hw_params()1574 */1575 io->converted_rate = 0;1576 io->converted_chan = 0;1577 if (fe->dai_link->dynamic) {1578 struct rsnd_priv *priv = rsnd_io_to_priv(io);1579 struct device *dev = rsnd_priv_to_dev(priv);1580 struct snd_soc_dpcm *dpcm;1581 int stream = substream->stream;1582 1583 for_each_dpcm_be(fe, stream, dpcm) {1584 struct snd_soc_pcm_runtime *be = dpcm->be;1585 struct snd_pcm_hw_params *be_params = &be->dpcm[stream].hw_params;1586 1587 if (params_channels(hw_params) != params_channels(be_params))1588 io->converted_chan = params_channels(be_params);1589 if (params_rate(hw_params) != params_rate(be_params))1590 io->converted_rate = params_rate(be_params);1591 }1592 if (io->converted_chan)1593 dev_dbg(dev, "convert channels = %d\n", io->converted_chan);1594 if (io->converted_rate) {1595 /*1596 * SRC supports convert rates from params_rate(hw_params)/k_down1597 * to params_rate(hw_params)*k_up, where k_up is always 6, and1598 * k_down depends on number of channels and SRC unit.1599 * So all SRC units can upsample audio up to 6 times regardless1600 * its number of channels. And all SRC units can downsample1601 * 2 channel audio up to 6 times too.1602 */1603 int k_up = 6;1604 int k_down = 6;1605 int channel;1606 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);1607 1608 dev_dbg(dev, "convert rate = %d\n", io->converted_rate);1609 1610 channel = io->converted_chan ? io->converted_chan :1611 params_channels(hw_params);1612 1613 switch (rsnd_mod_id(src_mod)) {1614 /*1615 * SRC0 can downsample 4, 6 and 8 channel audio up to 4 times.1616 * SRC1, SRC3 and SRC4 can downsample 4 channel audio1617 * up to 4 times.1618 * SRC1, SRC3 and SRC4 can downsample 6 and 8 channel audio1619 * no more than twice.1620 */1621 case 1:1622 case 3:1623 case 4:1624 if (channel > 4) {1625 k_down = 2;1626 break;1627 }1628 fallthrough;1629 case 0:1630 if (channel > 2)1631 k_down = 4;1632 break;1633 1634 /* Other SRC units do not support more than 2 channels */1635 default:1636 if (channel > 2)1637 return -EINVAL;1638 }1639 1640 if (params_rate(hw_params) > io->converted_rate * k_down) {1641 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min =1642 io->converted_rate * k_down;1643 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max =1644 io->converted_rate * k_down;1645 hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE;1646 } else if (params_rate(hw_params) * k_up < io->converted_rate) {1647 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min =1648 DIV_ROUND_UP(io->converted_rate, k_up);1649 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max =1650 DIV_ROUND_UP(io->converted_rate, k_up);1651 hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE;1652 }1653 1654 /*1655 * TBD: Max SRC input and output rates also depend on number1656 * of channels and SRC unit:1657 * SRC1, SRC3 and SRC4 do not support more than 128kHz1658 * for 6 channel and 96kHz for 8 channel audio.1659 * Perhaps this function should return EINVAL if the input or1660 * the output rate exceeds the limitation.1661 */1662 }1663 }1664 1665 return rsnd_hw_update(substream, hw_params);1666}1667 1668static int rsnd_hw_free(struct snd_soc_component *component,1669 struct snd_pcm_substream *substream)1670{1671 return rsnd_hw_update(substream, NULL);1672}1673 1674static snd_pcm_uframes_t rsnd_pointer(struct snd_soc_component *component,1675 struct snd_pcm_substream *substream)1676{1677 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream);1678 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai);1679 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream);1680 snd_pcm_uframes_t pointer = 0;1681 1682 rsnd_dai_call(pointer, io, &pointer);1683 1684 return pointer;1685}1686 1687/*1688 * snd_kcontrol1689 */1690static int rsnd_kctrl_info(struct snd_kcontrol *kctrl,1691 struct snd_ctl_elem_info *uinfo)1692{1693 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl);1694 1695 if (cfg->texts) {1696 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;1697 uinfo->count = cfg->size;1698 uinfo->value.enumerated.items = cfg->max;1699 if (uinfo->value.enumerated.item >= cfg->max)1700 uinfo->value.enumerated.item = cfg->max - 1;1701 strscpy(uinfo->value.enumerated.name,1702 cfg->texts[uinfo->value.enumerated.item],1703 sizeof(uinfo->value.enumerated.name));1704 } else {1705 uinfo->count = cfg->size;1706 uinfo->value.integer.min = 0;1707 uinfo->value.integer.max = cfg->max;1708 uinfo->type = (cfg->max == 1) ?1709 SNDRV_CTL_ELEM_TYPE_BOOLEAN :1710 SNDRV_CTL_ELEM_TYPE_INTEGER;1711 }1712 1713 return 0;1714}1715 1716static int rsnd_kctrl_get(struct snd_kcontrol *kctrl,1717 struct snd_ctl_elem_value *uc)1718{1719 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl);1720 int i;1721 1722 for (i = 0; i < cfg->size; i++)1723 if (cfg->texts)1724 uc->value.enumerated.item[i] = cfg->val[i];1725 else1726 uc->value.integer.value[i] = cfg->val[i];1727 1728 return 0;1729}1730 1731static int rsnd_kctrl_put(struct snd_kcontrol *kctrl,1732 struct snd_ctl_elem_value *uc)1733{1734 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl);1735 int i, change = 0;1736 1737 if (!cfg->accept(cfg->io))1738 return 0;1739 1740 for (i = 0; i < cfg->size; i++) {1741 if (cfg->texts) {1742 change |= (uc->value.enumerated.item[i] != cfg->val[i]);1743 cfg->val[i] = uc->value.enumerated.item[i];1744 } else {1745 change |= (uc->value.integer.value[i] != cfg->val[i]);1746 cfg->val[i] = uc->value.integer.value[i];1747 }1748 }1749 1750 if (change && cfg->update)1751 cfg->update(cfg->io, cfg->mod);1752 1753 return change;1754}1755 1756int rsnd_kctrl_accept_anytime(struct rsnd_dai_stream *io)1757{1758 return 1;1759}1760 1761int rsnd_kctrl_accept_runtime(struct rsnd_dai_stream *io)1762{1763 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);1764 struct rsnd_priv *priv = rsnd_io_to_priv(io);1765 struct device *dev = rsnd_priv_to_dev(priv);1766 1767 if (!runtime) {1768 dev_warn(dev, "Can't update kctrl when idle\n");1769 return 0;1770 }1771 1772 return 1;1773}1774 1775struct rsnd_kctrl_cfg *rsnd_kctrl_init_m(struct rsnd_kctrl_cfg_m *cfg)1776{1777 cfg->cfg.val = cfg->val;1778 1779 return &cfg->cfg;1780}1781 1782struct rsnd_kctrl_cfg *rsnd_kctrl_init_s(struct rsnd_kctrl_cfg_s *cfg)1783{1784 cfg->cfg.val = &cfg->val;1785 1786 return &cfg->cfg;1787}1788 1789const char * const volume_ramp_rate[] = {1790 "128 dB/1 step", /* 00000 */1791 "64 dB/1 step", /* 00001 */1792 "32 dB/1 step", /* 00010 */1793 "16 dB/1 step", /* 00011 */1794 "8 dB/1 step", /* 00100 */1795 "4 dB/1 step", /* 00101 */1796 "2 dB/1 step", /* 00110 */1797 "1 dB/1 step", /* 00111 */1798 "0.5 dB/1 step", /* 01000 */1799 "0.25 dB/1 step", /* 01001 */1800 "0.125 dB/1 step", /* 01010 = VOLUME_RAMP_MAX_MIX */1801 "0.125 dB/2 steps", /* 01011 */1802 "0.125 dB/4 steps", /* 01100 */1803 "0.125 dB/8 steps", /* 01101 */1804 "0.125 dB/16 steps", /* 01110 */1805 "0.125 dB/32 steps", /* 01111 */1806 "0.125 dB/64 steps", /* 10000 */1807 "0.125 dB/128 steps", /* 10001 */1808 "0.125 dB/256 steps", /* 10010 */1809 "0.125 dB/512 steps", /* 10011 */1810 "0.125 dB/1024 steps", /* 10100 */1811 "0.125 dB/2048 steps", /* 10101 */1812 "0.125 dB/4096 steps", /* 10110 */1813 "0.125 dB/8192 steps", /* 10111 = VOLUME_RAMP_MAX_DVC */1814};1815 1816int rsnd_kctrl_new(struct rsnd_mod *mod,1817 struct rsnd_dai_stream *io,1818 struct snd_soc_pcm_runtime *rtd,1819 const unsigned char *name,1820 int (*accept)(struct rsnd_dai_stream *io),1821 void (*update)(struct rsnd_dai_stream *io,1822 struct rsnd_mod *mod),1823 struct rsnd_kctrl_cfg *cfg,1824 const char * const *texts,1825 int size,1826 u32 max)1827{1828 struct snd_card *card = rtd->card->snd_card;1829 struct snd_kcontrol *kctrl;1830 struct snd_kcontrol_new knew = {1831 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,1832 .name = name,1833 .info = rsnd_kctrl_info,1834 .index = rtd->num,1835 .get = rsnd_kctrl_get,1836 .put = rsnd_kctrl_put,1837 };1838 int ret;1839 1840 /*1841 * 1) Avoid duplicate register for DVC with MIX case1842 * 2) Allow duplicate register for MIX1843 * 3) re-register if card was rebinded1844 */1845 list_for_each_entry(kctrl, &card->controls, list) {1846 struct rsnd_kctrl_cfg *c = kctrl->private_data;1847 1848 if (c == cfg)1849 return 0;1850 }1851 1852 if (size > RSND_MAX_CHANNELS)1853 return -EINVAL;1854 1855 kctrl = snd_ctl_new1(&knew, cfg);1856 if (!kctrl)1857 return -ENOMEM;1858 1859 ret = snd_ctl_add(card, kctrl);1860 if (ret < 0)1861 return ret;1862 1863 cfg->texts = texts;1864 cfg->max = max;1865 cfg->size = size;1866 cfg->accept = accept;1867 cfg->update = update;1868 cfg->card = card;1869 cfg->kctrl = kctrl;1870 cfg->io = io;1871 cfg->mod = mod;1872 1873 return 0;1874}1875 1876/*1877 * snd_soc_component1878 */1879static const struct snd_soc_component_driver rsnd_soc_component = {1880 .name = "rsnd",1881 .probe = rsnd_debugfs_probe,1882 .hw_params = rsnd_hw_params,1883 .hw_free = rsnd_hw_free,1884 .pointer = rsnd_pointer,1885 .legacy_dai_naming = 1,1886};1887 1888static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv,1889 struct rsnd_dai_stream *io)1890{1891 int ret;1892 1893 ret = rsnd_dai_call(probe, io, priv);1894 if (ret == -EAGAIN) {1895 struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io);1896 struct rsnd_mod *mod;1897 int i;1898 1899 /*1900 * Fallback to PIO mode1901 */1902 1903 /*1904 * call "remove" for SSI/SRC/DVC1905 * SSI will be switch to PIO mode if it was DMA mode1906 * see1907 * rsnd_dma_init()1908 * rsnd_ssi_fallback()1909 */1910 rsnd_dai_call(remove, io, priv);1911 1912 /*1913 * remove all mod from io1914 * and, re connect ssi1915 */1916 for_each_rsnd_mod(i, mod, io)1917 rsnd_dai_disconnect(mod, io, i);1918 rsnd_dai_connect(ssi_mod, io, RSND_MOD_SSI);1919 1920 /*1921 * fallback1922 */1923 rsnd_dai_call(fallback, io, priv);1924 1925 /*1926 * retry to "probe".1927 * DAI has SSI which is PIO mode only now.1928 */1929 ret = rsnd_dai_call(probe, io, priv);1930 }1931 1932 return ret;1933}1934 1935/*1936 * rsnd probe1937 */1938static int rsnd_probe(struct platform_device *pdev)1939{1940 struct rsnd_priv *priv;1941 struct device *dev = &pdev->dev;1942 struct rsnd_dai *rdai;1943 int (*probe_func[])(struct rsnd_priv *priv) = {1944 rsnd_gen_probe,1945 rsnd_dma_probe,1946 rsnd_ssi_probe,1947 rsnd_ssiu_probe,1948 rsnd_src_probe,1949 rsnd_ctu_probe,1950 rsnd_mix_probe,1951 rsnd_dvc_probe,1952 rsnd_cmd_probe,1953 rsnd_adg_probe,1954 rsnd_dai_probe,1955 };1956 int ret, i;1957 int ci;1958 1959 /*1960 * init priv data1961 */1962 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);1963 if (!priv)1964 return -ENODEV;1965 1966 priv->pdev = pdev;1967 priv->flags = (unsigned long)of_device_get_match_data(dev);1968 spin_lock_init(&priv->lock);1969 1970 /*1971 * init each module1972 */1973 for (i = 0; i < ARRAY_SIZE(probe_func); i++) {1974 ret = probe_func[i](priv);1975 if (ret)1976 return ret;1977 }1978 1979 for_each_rsnd_dai(rdai, priv, i) {1980 ret = rsnd_rdai_continuance_probe(priv, &rdai->playback);1981 if (ret)1982 goto exit_snd_probe;1983 1984 ret = rsnd_rdai_continuance_probe(priv, &rdai->capture);1985 if (ret)1986 goto exit_snd_probe;1987 }1988 1989 dev_set_drvdata(dev, priv);1990 1991 /*1992 * asoc register1993 */1994 ci = 0;1995 for (i = 0; priv->component_dais[i] > 0; i++) {1996 int nr = priv->component_dais[i];1997 1998 ret = devm_snd_soc_register_component(dev, &rsnd_soc_component,1999 priv->daidrv + ci, nr);2000 if (ret < 0) {2001 dev_err(dev, "cannot snd component register\n");2002 goto exit_snd_probe;2003 }2004 2005 ci += nr;2006 }2007 2008 pm_runtime_enable(dev);2009 2010 dev_info(dev, "probed\n");2011 return ret;2012 2013exit_snd_probe:2014 for_each_rsnd_dai(rdai, priv, i) {2015 rsnd_dai_call(remove, &rdai->playback, priv);2016 rsnd_dai_call(remove, &rdai->capture, priv);2017 }2018 2019 /*2020 * adg is very special mod which can't use rsnd_dai_call(remove),2021 * and it registers ADG clock on probe.2022 * It should be unregister if probe failed.2023 * Mainly it is assuming -EPROBE_DEFER case2024 */2025 rsnd_adg_remove(priv);2026 2027 return ret;2028}2029 2030static void rsnd_remove(struct platform_device *pdev)2031{2032 struct rsnd_priv *priv = dev_get_drvdata(&pdev->dev);2033 struct rsnd_dai *rdai;2034 void (*remove_func[])(struct rsnd_priv *priv) = {2035 rsnd_ssi_remove,2036 rsnd_ssiu_remove,2037 rsnd_src_remove,2038 rsnd_ctu_remove,2039 rsnd_mix_remove,2040 rsnd_dvc_remove,2041 rsnd_cmd_remove,2042 rsnd_adg_remove,2043 };2044 int i;2045 2046 pm_runtime_disable(&pdev->dev);2047 2048 for_each_rsnd_dai(rdai, priv, i) {2049 int ret;2050 2051 ret = rsnd_dai_call(remove, &rdai->playback, priv);2052 if (ret)2053 dev_warn(&pdev->dev, "Failed to remove playback dai #%d\n", i);2054 2055 ret = rsnd_dai_call(remove, &rdai->capture, priv);2056 if (ret)2057 dev_warn(&pdev->dev, "Failed to remove capture dai #%d\n", i);2058 }2059 2060 for (i = 0; i < ARRAY_SIZE(remove_func); i++)2061 remove_func[i](priv);2062}2063 2064static int __maybe_unused rsnd_suspend(struct device *dev)2065{2066 struct rsnd_priv *priv = dev_get_drvdata(dev);2067 2068 rsnd_adg_clk_disable(priv);2069 2070 return 0;2071}2072 2073static int __maybe_unused rsnd_resume(struct device *dev)2074{2075 struct rsnd_priv *priv = dev_get_drvdata(dev);2076 2077 rsnd_adg_clk_enable(priv);2078 2079 return 0;2080}2081 2082static const struct dev_pm_ops rsnd_pm_ops = {2083 SET_SYSTEM_SLEEP_PM_OPS(rsnd_suspend, rsnd_resume)2084};2085 2086static struct platform_driver rsnd_driver = {2087 .driver = {2088 .name = "rcar_sound",2089 .pm = &rsnd_pm_ops,2090 .of_match_table = rsnd_of_match,2091 },2092 .probe = rsnd_probe,2093 .remove = rsnd_remove,2094};2095module_platform_driver(rsnd_driver);2096 2097MODULE_LICENSE("GPL v2");2098MODULE_DESCRIPTION("Renesas R-Car audio driver");2099MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");2100MODULE_ALIAS("platform:rcar-pcm-audio");2101